sch_base_frame.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2012 SoftPLC Corporation, Dick Hollenbeck <[email protected]>
 * Copyright (C) 2015-2023 KiCad Developers, see change_log.txt for contributors.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, you may find one here:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
 */
 
#include <advanced_config.h>
#include <base_units.h>
#include <kiway.h>
#include <lib_tree_model_adapter.h>
#include <pgm_base.h>
#include <eda_list_dialog.h>
#include <eeschema_settings.h>
#include <gal/graphics_abstraction_layer.h>
#include <project/project_file.h>
#include <symbol_editor/symbol_editor_settings.h>
#include <sch_draw_panel.h>
#include <sch_view.h>
#include <sch_painter.h>
#include <settings/settings_manager.h>
#include <confirm.h>
#include <preview_items/selection_area.h>
#include <project_sch.h>
#include <symbol_library.h>
#include <sch_base_frame.h>
#include <symbol_lib_table.h>
#include <tool/action_toolbar.h>
#include <tool/tool_manager.h>
#include <tool/tool_dispatcher.h>
#include <tools/ee_actions.h>
#include <tools/ee_selection_tool.h>
#include <view/view_controls.h>
#include <wx/choicdlg.h>
#include <wx/fswatcher.h>
#include <wx/log.h>
#include <wx/msgdlg.h>
 
#include <navlib/nl_schematic_plugin.h>
 
LIB_SYMBOL* SchGetLibSymbol( const LIB_ID& aLibId, SYMBOL_LIB_TABLE* aLibTable,
 SYMBOL_LIB* aCacheLib, wxWindow* aParent, bool aShowErrorMsg )
{
 wxCHECK_MSG( aLibTable, nullptr, wxS( "Invalid symbol library table." ) );
 
 LIB_SYMBOL* symbol = nullptr;
 
 try
 {
 symbol = aLibTable->LoadSymbol( aLibId );
 
 if( !symbol && aCacheLib )
 {
 wxCHECK_MSG( aCacheLib->IsCache(), nullptr, wxS( "Invalid cache library." ) );
 
 wxString cacheName = aLibId.GetLibNickname().wx_str();
 cacheName << "_" << aLibId.GetLibItemName();
 symbol = aCacheLib->FindSymbol( cacheName );
 }
 }
 catch( const IO_ERROR& ioe )
 {
 if( aShowErrorMsg )
 {
 wxString msg = wxString::Format( _( "Error loading symbol %s from library '%s'." ),
 aLibId.GetLibItemName().wx_str(),
 aLibId.GetLibNickname().wx_str() );
 DisplayErrorMessage( aParent, msg, ioe.What() );
 }
 }
 
 return symbol;
}
 
 
SCH_BASE_FRAME::SCH_BASE_FRAME( KIWAY* aKiway, wxWindow* aParent, FRAME_T aWindowType,
 const wxString& aTitle, const wxPoint& aPosition,
 const wxSize& aSize, long aStyle, const wxString& aFrameName ) :
 EDA_DRAW_FRAME( aKiway, aParent, aWindowType, aTitle, aPosition, aSize, aStyle,
 aFrameName, schIUScale ),
 m_base_frame_defaults( nullptr, "base_Frame_defaults" ),
 m_selectionFilterPanel( nullptr ),
 m_spaceMouse( nullptr )
{
 if( ( aStyle & wxFRAME_NO_TASKBAR ) == 0 )
 createCanvas();
 
 Bind( wxEVT_IDLE,
 [this]( wxIdleEvent& aEvent )
 {
 // Handle cursor adjustments. While we can get motion and key events through
 // wxWidgets, we can't get modifier-key-up events.
 if( m_toolManager )
 {
 EE_SELECTION_TOOL* selTool = m_toolManager->GetTool<EE_SELECTION_TOOL>();
 
 if( selTool )
 selTool->OnIdle( aEvent );
 }
 } );
 
 m_watcherDebounceTimer.Bind( wxEVT_TIMER, &SCH_BASE_FRAME::OnSymChangeDebounceTimer, this );
}
 
 
SCH_BASE_FRAME::~SCH_BASE_FRAME()
{
 delete m_spaceMouse;
}
 
 
SCH_SCREEN* SCH_BASE_FRAME::GetScreen() const
{
 return (SCH_SCREEN*) EDA_DRAW_FRAME::GetScreen();
}
 
 
EESCHEMA_SETTINGS* SCH_BASE_FRAME::eeconfig() const
{
 return dynamic_cast<EESCHEMA_SETTINGS*>( config() );
}
 
 
SYMBOL_EDITOR_SETTINGS* SCH_BASE_FRAME::libeditconfig() const
{
 return dynamic_cast<SYMBOL_EDITOR_SETTINGS*>( config() );
}
 
 
void SCH_BASE_FRAME::SetPageSettings( const PAGE_INFO& aPageSettings )
{
 GetScreen()->SetPageSettings( aPageSettings );
}
 
 
const PAGE_INFO& SCH_BASE_FRAME::GetPageSettings () const
{
 return GetScreen()->GetPageSettings();
}
 
 
const VECTOR2I SCH_BASE_FRAME::GetPageSizeIU() const
{
 // GetSizeIU is compile time dependent:
 return GetScreen()->GetPageSettings().GetSizeIU( schIUScale.IU_PER_MILS );
}
 
 
const TITLE_BLOCK& SCH_BASE_FRAME::GetTitleBlock() const
{
 wxASSERT( GetScreen() );
 return GetScreen()->GetTitleBlock();
}
 
 
void SCH_BASE_FRAME::SetTitleBlock( const TITLE_BLOCK& aTitleBlock )
{
 wxASSERT( GetScreen() );
 GetScreen()->SetTitleBlock( aTitleBlock );
}
 
 
void SCH_BASE_FRAME::UpdateStatusBar()
{
 wxString line;
 BASE_SCREEN* screen = GetScreen();
 
 if( !screen )
 return;
 
 EDA_DRAW_FRAME::UpdateStatusBar();
 
 // Display absolute and relative coordinates
 VECTOR2D cursorPos = GetCanvas()->GetViewControls()->GetCursorPosition();
 VECTOR2D d = cursorPos - screen->m_LocalOrigin;
 
 line.Printf( wxS( "X %s Y %s" ),
 MessageTextFromValue( cursorPos.x, false ),
 MessageTextFromValue( cursorPos.y, false ) );
 SetStatusText( line, 2 );
 
 line.Printf( wxS( "dx %s dy %s dist %s" ),
 MessageTextFromValue( d.x, false ),
 MessageTextFromValue( d.y, false ),
 MessageTextFromValue( hypot( d.x, d.y ), false ) );
 SetStatusText( line, 3 );
 
 DisplayGridMsg();
 DisplayUnitsMsg();
}
 
 
LIB_SYMBOL* SCH_BASE_FRAME::GetLibSymbol( const LIB_ID& aLibId, bool aUseCacheLib,
 bool aShowErrorMsg )
{
 SYMBOL_LIB* cache =
 ( aUseCacheLib ) ? PROJECT_SCH::SchLibs( &Prj() )->GetCacheLibrary() : nullptr;
 
 return SchGetLibSymbol( aLibId, PROJECT_SCH::SchSymbolLibTable( &Prj() ), cache, this,
 aShowErrorMsg );
}
 
 
bool SCH_BASE_FRAME::saveSymbolLibTables( bool aGlobal, bool aProject )
{
 wxString msg;
 bool success = true;
 
 if( aGlobal )
 {
 try
 {
 SYMBOL_LIB_TABLE::GetGlobalLibTable().Save( SYMBOL_LIB_TABLE::GetGlobalTableFileName() );
 }
 catch( const IO_ERROR& ioe )
 {
 success = false;
 msg.Printf( _( "Error saving global symbol library table:\n%s" ), ioe.What() );
 DisplayErrorMessage( this, msg );
 }
 }
 
 if( aProject && !Prj().GetProjectName().IsEmpty() )
 {
 wxFileName fn( Prj().GetProjectPath(), SYMBOL_LIB_TABLE::GetSymbolLibTableFileName() );
 
 try
 {
 PROJECT_SCH::SchSymbolLibTable( &Prj() )->Save( fn.GetFullPath() );
 }
 catch( const IO_ERROR& ioe )
 {
 success = false;
 msg.Printf( _( "Error saving project-specific symbol library table:\n%s" ),
 ioe.What() );
 DisplayErrorMessage( this, msg );
 }
 }
 
 return success;
}
 
 
SYMBOL_LIB_TABLE* SCH_BASE_FRAME::SelectSymLibTable( bool aOptional )
{
 // If no project is loaded, always work with the global table
 if( Prj().IsNullProject() )
 {
 SYMBOL_LIB_TABLE* ret = &SYMBOL_LIB_TABLE::GetGlobalLibTable();
 
 if( aOptional )
 {
 wxMessageDialog dlg( this, _( "Add the library to the global library table?" ),
 _( "Add To Global Library Table" ), wxYES_NO );
 
 if( dlg.ShowModal() != wxID_OK )
 ret = nullptr;
 }
 
 return ret;
 }
 
 wxArrayString libTableNames;
 libTableNames.Add( _( "Global" ) );
 libTableNames.Add( _( "Project" ) );
 
 wxSingleChoiceDialog dlg( this, _( "Choose the Library Table to add the library to:" ),
 _( "Add To Library Table" ), libTableNames );
 
 if( aOptional )
 {
 dlg.FindWindow( wxID_CANCEL )->SetLabel( _( "Skip" ) );
 dlg.FindWindow( wxID_OK )->SetLabel( _( "Add" ) );
 }
 
 if( dlg.ShowModal() != wxID_OK )
 return nullptr;
 
 switch( dlg.GetSelection() )
 {
 case 0: return &SYMBOL_LIB_TABLE::GetGlobalLibTable();
 case 1: return PROJECT_SCH::SchSymbolLibTable( &Prj() );
 default: return nullptr;
 }
}
 
 
void SCH_BASE_FRAME::RedrawScreen( const VECTOR2I& aCenterPoint, bool aWarpPointer )
{
 GetCanvas()->GetView()->SetCenter( aCenterPoint );
 
 if( aWarpPointer )
 GetCanvas()->GetViewControls()->CenterOnCursor();
 
 GetCanvas()->Refresh();
}
 
 
void SCH_BASE_FRAME::HardRedraw()
{
 if( GetCanvas() && GetCanvas()->GetView() )
 {
 GetCanvas()->GetView()->UpdateAllItems( KIGFX::ALL );
 GetCanvas()->ForceRefresh();
 }
}
 
 
SCH_DRAW_PANEL* SCH_BASE_FRAME::GetCanvas() const
{
 return static_cast<SCH_DRAW_PANEL*>( EDA_DRAW_FRAME::GetCanvas() );
}
 
 
SCH_RENDER_SETTINGS* SCH_BASE_FRAME::GetRenderSettings()
{
 if( GetCanvas() && GetCanvas()->GetView() )
 {
 if( KIGFX::PAINTER* painter = GetCanvas()->GetView()->GetPainter() )
 return static_cast<SCH_RENDER_SETTINGS*>( painter->GetSettings() );
 }
 
 return nullptr;
}
 
 
void SCH_BASE_FRAME::createCanvas()
{
 m_canvasType = loadCanvasTypeSetting();
 
 SetCanvas( new SCH_DRAW_PANEL( this, wxID_ANY, wxPoint( 0, 0 ), m_frameSize,
 GetGalDisplayOptions(), m_canvasType ) );
 ActivateGalCanvas();
}
 
 
void SCH_BASE_FRAME::ActivateGalCanvas()
{
 EDA_DRAW_FRAME::ActivateGalCanvas();
 
 try
 {
 if( !m_spaceMouse )
 m_spaceMouse = new NL_SCHEMATIC_PLUGIN();
 
 m_spaceMouse->SetCanvas( GetCanvas() );
 }
 catch( const std::system_error& e )
 {
 wxLogTrace( wxT( "KI_TRACE_NAVLIB" ), e.what() );
 }
}
 
 
void SCH_BASE_FRAME::UpdateItem( EDA_ITEM* aItem, bool isAddOrDelete, bool aUpdateRtree )
{
 EDA_ITEM* parent = aItem->GetParent();
 
 if( aItem->Type() == SCH_SHEET_PIN_T )
 {
 // Sheet pins aren't in the view. Refresh their parent.
 if( parent )
 GetCanvas()->GetView()->Update( parent );
 }
 else
 {
 if( !isAddOrDelete )
 GetCanvas()->GetView()->Update( aItem );
 
 // Some children are drawn from their parents. Mark them for re-paint.
 if( parent && parent->IsType( { SCH_SYMBOL_T, SCH_SHEET_T, SCH_LABEL_LOCATE_ANY_T, SCH_TABLE_T } ) )
 GetCanvas()->GetView()->Update( parent, KIGFX::REPAINT );
 }
 
 if( aUpdateRtree && dynamic_cast<SCH_ITEM*>( aItem ) )
 GetScreen()->Update( static_cast<SCH_ITEM*>( aItem ) );
 
 // Calling Refresh() here introduces a bi-stable state: when doing operations on a
 // large number of items if at some point the refresh timer times out and does a
 // refresh it will take long enough that the next item will also time out, and the
 // next, and the next, etc.
 // GetCanvas()->Refresh();
}
 
 
void SCH_BASE_FRAME::RefreshZoomDependentItems()
{
 // We currently have two zoom-dependent renderings: text, which is rendered as bitmap text
 // when too small to see the difference, and selection shadows.
 //
 // Because non-selected text is cached by OpenGL, we only apply the bitmap performance hack
 // to selected text items.
 //
 // Thus, as it currently stands, all zoom-dependent items can be found in the list of selected
 // items.
 
 if( m_toolManager )
 {
 EE_SELECTION_TOOL* selectionTool = m_toolManager->GetTool<EE_SELECTION_TOOL>();
 SELECTION& selection = selectionTool->GetSelection();
 KIGFX::SCH_VIEW* view = GetCanvas()->GetView();
 
 for( EDA_ITEM* item : selection )
 {
 if( item->RenderAsBitmap( view->GetGAL()->GetWorldScale() ) != item->IsShownAsBitmap()
 || item->IsType( KIGFX::SCH_PAINTER::g_ScaledSelectionTypes ) )
 {
 view->Update( item, KIGFX::REPAINT );
 
 EDA_ITEM* parent = item->GetParent();
 
 // Symbol children are drawn from their parents. Mark them for re-paint.
 if( parent && parent->Type() == SCH_SYMBOL_T )
 GetCanvas()->GetView()->Update( parent, KIGFX::REPAINT );
 }
 }
 }
}
 
 
void SCH_BASE_FRAME::AddToScreen( EDA_ITEM* aItem, SCH_SCREEN* aScreen )
{
 // Null pointers will cause boost::ptr_vector to raise a boost::bad_pointer exception which
 // will be unhandled. There is no valid reason to pass an invalid EDA_ITEM pointer to the
 // screen append function.
 wxCHECK( aItem != nullptr, /* void */ );
 
 auto screen = aScreen;
 
 if( aScreen == nullptr )
 screen = GetScreen();
 
 if( aItem->Type() != SCH_TABLECELL_T )
 screen->Append( (SCH_ITEM*) aItem );
 
 if( screen == GetScreen() )
 {
 GetCanvas()->GetView()->Add( aItem );
 UpdateItem( aItem, true ); // handle any additional parent semantics
 }
}
 
 
void SCH_BASE_FRAME::RemoveFromScreen( EDA_ITEM* aItem, SCH_SCREEN* aScreen )
{
 auto screen = aScreen;
 
 if( aScreen == nullptr )
 screen = GetScreen();
 
 if( screen == GetScreen() )
 GetCanvas()->GetView()->Remove( aItem );
 
 if( aItem->Type() != SCH_TABLECELL_T )
 screen->Remove( (SCH_ITEM*) aItem );
 
 if( screen == GetScreen() )
 UpdateItem( aItem, true ); // handle any additional parent semantics
}
 
 
void SCH_BASE_FRAME::SyncView()
{
 // Let tools add things to the view if necessary
 if( m_toolManager )
 m_toolManager->ResetTools( TOOL_BASE::MODEL_RELOAD );
 
 GetCanvas()->GetView()->UpdateAllItems( KIGFX::ALL );
}
 
 
COLOR4D SCH_BASE_FRAME::GetLayerColor( SCH_LAYER_ID aLayer )
{
 return GetColorSettings()->GetColor( aLayer );
}
 
 
void SCH_BASE_FRAME::CommonSettingsChanged( bool aEnvVarsChanged, bool aTextVarsChanged )
{
 EDA_DRAW_FRAME::CommonSettingsChanged( aEnvVarsChanged, aTextVarsChanged );
 
 COLOR_SETTINGS* colorSettings = GetColorSettings( true );
 
 GetCanvas()->GetView()->GetPainter()->GetSettings()->LoadColors( colorSettings );
 GetCanvas()->GetGAL()->SetAxesColor( colorSettings->GetColor( LAYER_SCHEMATIC_GRID_AXES ) );
 
 GetCanvas()->GetView()->UpdateAllItems( KIGFX::ALL );
 GetCanvas()->GetView()->RecacheAllItems();
 GetCanvas()->GetView()->MarkTargetDirty( KIGFX::TARGET_NONCACHED );
}
 
 
COLOR_SETTINGS* SCH_BASE_FRAME::GetColorSettings( bool aForceRefresh ) const
{
 if( !m_colorSettings || aForceRefresh )
 {
 SETTINGS_MANAGER& mgr = Pgm().GetSettingsManager();
 EESCHEMA_SETTINGS* cfg = mgr.GetAppSettings<EESCHEMA_SETTINGS>();
 wxString colorTheme = cfg->m_ColorTheme;
 
 if( IsType( FRAME_SCH_SYMBOL_EDITOR ) )
 {
 SYMBOL_EDITOR_SETTINGS* symCfg = mgr.GetAppSettings<SYMBOL_EDITOR_SETTINGS>();
 
 if( !symCfg->m_UseEeschemaColorSettings )
 colorTheme = symCfg->m_ColorTheme;
 }
 
 COLOR_SETTINGS* colorSettings = mgr.GetColorSettings( colorTheme );
 
 const_cast<SCH_BASE_FRAME*>( this )->m_colorSettings = colorSettings;
 }
 
 return m_colorSettings;
}
 
 
COLOR4D SCH_BASE_FRAME::GetDrawBgColor() const
{
 return GetColorSettings()->GetColor( LAYER_SCHEMATIC_BACKGROUND );
}
 
 
void SCH_BASE_FRAME::handleActivateEvent( wxActivateEvent& aEvent )
{
 EDA_DRAW_FRAME::handleActivateEvent( aEvent );
 
 if( m_spaceMouse )
 m_spaceMouse->SetFocus( aEvent.GetActive() );
}
 
 
void SCH_BASE_FRAME::handleIconizeEvent( wxIconizeEvent& aEvent )
{
 EDA_DRAW_FRAME::handleIconizeEvent( aEvent );
 
 if( m_spaceMouse )
 m_spaceMouse->SetFocus( false );
}
 
 
wxString SCH_BASE_FRAME::SelectLibraryFromList()
{
 COMMON_SETTINGS* cfg = Pgm().GetCommonSettings();
 PROJECT& prj = Prj();
 
 if( PROJECT_SCH::SchSymbolLibTable( &prj )->IsEmpty() )
 {
 ShowInfoBarError( _( "No symbol libraries are loaded." ) );
 return wxEmptyString;
 }
 
 wxArrayString headers;
 
 headers.Add( _( "Library" ) );
 
 std::vector< wxArrayString > itemsToDisplay;
 std::vector< wxString > libNicknames = PROJECT_SCH::SchSymbolLibTable( &prj )->GetLogicalLibs();
 
 for( const wxString& name : libNicknames )
 {
 // Exclude read only libraries.
 if( !PROJECT_SCH::SchSymbolLibTable( &prj )->IsSymbolLibWritable( name ) )
 continue;
 
 if( alg::contains( prj.GetProjectFile().m_PinnedSymbolLibs, name )
 || alg::contains( cfg->m_Session.pinned_symbol_libs, name ) )
 {
 wxArrayString item;
 
 item.Add( LIB_TREE_MODEL_ADAPTER::GetPinningSymbol() + name );
 itemsToDisplay.push_back( item );
 }
 }
 
 for( const wxString& name : libNicknames )
 {
 // Exclude read only libraries.
 if( !PROJECT_SCH::SchSymbolLibTable( &prj )->IsSymbolLibWritable( name ) )
 continue;
 
 if( !alg::contains( prj.GetProjectFile().m_PinnedSymbolLibs, name )
 && !alg::contains( cfg->m_Session.pinned_symbol_libs, name ) )
 {
 wxArrayString item;
 
 item.Add( name );
 itemsToDisplay.push_back( item );
 }
 }
 
 wxString oldLibName = prj.GetRString( PROJECT::SCH_LIB_SELECT );
 
 EDA_LIST_DIALOG dlg( this, _( "Select Symbol Library" ), headers, itemsToDisplay, oldLibName,
 false );
 
 if( dlg.ShowModal() != wxID_OK )
 return wxEmptyString;
 
 wxString libName = dlg.GetTextSelection();
 
 if( !libName.empty() )
 {
 if( PROJECT_SCH::SchSymbolLibTable( &prj )->HasLibrary( libName ) )
 prj.SetRString( PROJECT::SCH_LIB_SELECT, libName );
 else
 libName = wxEmptyString;
 }
 
 return libName;
}
 
 
void SCH_BASE_FRAME::setSymWatcher( const LIB_ID* aID )
{
 Unbind( wxEVT_FSWATCHER, &SCH_BASE_FRAME::OnSymChange, this );
 
 if( m_watcher )
 {
 wxLogTrace( "KICAD_LIB_WATCH", "Remove watch" );
 m_watcher->RemoveAll();
 m_watcher->SetOwner( nullptr );
 m_watcher.reset();
 }
 
 wxString libfullname;
 SYMBOL_LIB_TABLE* tbl = PROJECT_SCH::SchSymbolLibTable( &Prj() );
 
 if( !aID || !tbl )
 return;
 
 try
 {
 const SYMBOL_LIB_TABLE_ROW* row = tbl->FindRow( aID->GetLibNickname() );
 
 if( !row )
 return;
 
 libfullname = row->GetFullURI( true );
 }
 catch( const std::exception& e )
 {
 DisplayInfoMessage( this, e.what() );
 return;
 }
 catch( const IO_ERROR& error )
 {
 wxLogTrace( "KICAD_LIB_WATCH", "Error: %s", error.What() );
 return;
 }
 
 wxLogTrace( "KICAD_LIB_WATCH", "Setting up watcher for %s", libfullname );
 m_watcherFileName.Assign( libfullname );
 
 if( !m_watcherFileName.FileExists() )
 return;
 
 wxLog::EnableLogging( false );
 m_watcherLastModified = m_watcherFileName.GetModificationTime();
 wxLog::EnableLogging( true );
 
 Bind( wxEVT_FSWATCHER, &SCH_BASE_FRAME::OnSymChange, this );
 m_watcher = std::make_unique<wxFileSystemWatcher>();
 m_watcher->SetOwner( this );
 
 wxFileName fn;
 fn.AssignDir( m_watcherFileName.GetPath() );
 fn.DontFollowLink();
 
 m_watcher->Add( fn );
}
 
 
void SCH_BASE_FRAME::OnSymChange( wxFileSystemWatcherEvent& aEvent )
{
 SYMBOL_LIBS* libs = PROJECT_SCH::SchLibs( &Prj() );
 
 wxLogTrace( "KICAD_LIB_WATCH", "OnSymChange: %s, watcher file: %s",
 aEvent.GetPath().GetFullPath(), m_watcherFileName.GetFullPath() );
 
 if( !libs || !m_watcher || !m_watcher.get() || m_watcherFileName.GetPath().IsEmpty() )
 return;
 
 if( aEvent.GetPath() != m_watcherFileName )
 return;
 
 // Start the debounce timer (set to 1 second)
 if( !m_watcherDebounceTimer.StartOnce( 1000 ) )
 {
 wxLogTrace( "KICAD_LIB_WATCH", "Failed to start the debounce timer" );
 return;
 }
}
 
 
void SCH_BASE_FRAME::OnSymChangeDebounceTimer( wxTimerEvent& aEvent )
{
 wxLogTrace( "KICAD_LIB_WATCH", "OnSymChangeDebounceTimer" );
 // Disable logging to avoid spurious messages and check if the file has changed
 wxLog::EnableLogging( false );
 wxDateTime lastModified = m_watcherFileName.GetModificationTime();
 wxLog::EnableLogging( true );
 
 if( lastModified == m_watcherLastModified || !lastModified.IsValid() )
 return;
 
 m_watcherLastModified = lastModified;
 
 if( !GetScreen()->IsContentModified() || IsOK( this, _( "The library containing the current symbol has changed.\n"
 "Do you want to reload the library?" ) ) )
 {
 wxLogTrace( "KICAD_LIB_WATCH", "Sending refresh symbol mail" );
 std::string libName = m_watcherFileName.GetFullPath().ToStdString();
 Kiway().ExpressMail( FRAME_SCH_VIEWER, MAIL_REFRESH_SYMBOL, libName );
 Kiway().ExpressMail( FRAME_SCH_SYMBOL_EDITOR, MAIL_REFRESH_SYMBOL, libName );
 }
}