KiCad PCB EDA Suite
Loading...
Searching...
No Matches
symbol_edit_frame.cpp
Go to the documentation of this file.
1/*
2 * This program source code file is part of KiCad, a free EDA CAD application.
3 *
4 * Copyright (C) 2013 Jean-Pierre Charras, jp.charras at wanadoo.fr
5 * Copyright (C) 2008 Wayne Stambaugh <[email protected]>
6 * Copyright (C) 2004-2024 KiCad Developers, see AUTHORS.txt for contributors.
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version 2
11 * of the License, or (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, you may find one here:
20 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
21 * or you may search the http://www.gnu.org website for the version 2 license,
22 * or you may write to the Free Software Foundation, Inc.,
23 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
24 */
25
26#include <bitmaps.h>
27#include <wx/hyperlink.h>
28#include <base_screen.h>
29#include <symbol_library.h>
30#include <confirm.h>
31#include <core/kicad_algo.h>
32#include <eeschema_id.h>
33#include <eeschema_settings.h>
34#include <env_paths.h>
36#include <kiface_base.h>
37#include <kiplatform/app.h>
38#include <kiway_express.h>
39#include <symbol_edit_frame.h>
42#include <paths.h>
43#include <pgm_base.h>
44#include <project_sch.h>
45#include <sch_painter.h>
46#include <sch_view.h>
48#include <symbol_lib_table.h>
49#include <tool/action_manager.h>
50#include <tool/action_toolbar.h>
51#include <tool/common_control.h>
52#include <tool/common_tools.h>
54#include <tool/picker_tool.h>
56#include <tool/selection.h>
58#include <tool/tool_manager.h>
59#include <tool/zoom_tool.h>
60#include <tools/ee_actions.h>
69#include <view/view_controls.h>
71#include <widgets/wx_infobar.h>
72#include <widgets/lib_tree.h>
79#include <panel_sym_lib_table.h>
80#include <string_utils.h>
81#include <wx/msgdlg.h>
82#include <wx/log.h>
83
84
86
87
88BEGIN_EVENT_TABLE( SYMBOL_EDIT_FRAME, SCH_BASE_FRAME )
90
91 // menubar commands
92 EVT_MENU( wxID_EXIT, SYMBOL_EDIT_FRAME::OnExitKiCad )
93 EVT_MENU( wxID_CLOSE, SYMBOL_EDIT_FRAME::CloseWindow )
94
95 // Update user interface elements.
97
98 // Drop files event
99 EVT_DROP_FILES( SYMBOL_EDIT_FRAME::OnDropFiles )
100
101END_EVENT_TABLE()
102
103
104SYMBOL_EDIT_FRAME::SYMBOL_EDIT_FRAME( KIWAY* aKiway, wxWindow* aParent ) :
105 SCH_BASE_FRAME( aKiway, aParent, FRAME_SCH_SYMBOL_EDITOR, _( "Library Editor" ),
106 wxDefaultPosition, wxDefaultSize, KICAD_DEFAULT_DRAWFRAME_STYLE,
108 m_unitSelectBox( nullptr ),
109 m_isSymbolFromSchematic( false )
110{
111 SetShowDeMorgan( false );
112 m_SyncPinEdit = false;
113
114 m_symbol = nullptr;
115 m_treePane = nullptr;
116 m_libMgr = nullptr;
117 m_unit = 1;
118 m_bodyStyle = 1;
119 m_aboutTitle = _HKI( "KiCad Symbol Editor" );
120
121 wxIcon icon;
122 wxIconBundle icon_bundle;
123
124 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_libedit, 48 ) );
125 icon_bundle.AddIcon( icon );
126 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_libedit, 256 ) );
127 icon_bundle.AddIcon( icon );
128 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_libedit, 128 ) );
129 icon_bundle.AddIcon( icon );
130 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_libedit_32 ) );
131 icon_bundle.AddIcon( icon );
132 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_libedit_16 ) );
133 icon_bundle.AddIcon( icon );
134
135 SetIcons( icon_bundle );
136
138 LoadSettings( m_settings );
139
140 m_libMgr = new LIB_SYMBOL_LIBRARY_MANAGER( *this );
141 bool loadingCancelled = false;
142
143 {
144 // Preload libraries before using SyncLibraries the first time, as the preload is
145 // multi-threaded
146 WX_PROGRESS_REPORTER reporter( this, _( "Loading Symbol Libraries" ),
147 m_libMgr->GetLibraryCount(), true );
148 m_libMgr->Preload( reporter );
149
150 loadingCancelled = reporter.IsCancelled();
151 wxSafeYield();
152 }
153
154 SyncLibraries( false, loadingCancelled );
155 m_treePane = new SYMBOL_TREE_PANE( this, m_libMgr );
156 m_treePane->GetLibTree()->SetSortMode( (LIB_TREE_MODEL_ADAPTER::SORT_MODE) m_settings->m_LibrarySortMode );
157
158 resolveCanvasType();
159 SwitchCanvas( m_canvasType );
160
161 // Ensure axis are always drawn
162 KIGFX::GAL_DISPLAY_OPTIONS& gal_opts = GetGalDisplayOptions();
163 gal_opts.m_axesEnabled = true;
164
165 m_dummyScreen = new SCH_SCREEN();
166 SetScreen( m_dummyScreen );
167 GetScreen()->m_Center = true;
168
169 GetCanvas()->GetViewControls()->SetCrossHairCursorPosition( VECTOR2D( 0, 0 ), false );
170
171 GetRenderSettings()->LoadColors( GetColorSettings() );
172 GetRenderSettings()->m_IsSymbolEditor = true;
173 GetCanvas()->GetGAL()->SetAxesColor( m_colorSettings->GetColor( LAYER_SCHEMATIC_GRID_AXES ) );
174
175 setupTools();
176 setupUIConditions();
177
178 ReCreateMenuBar();
179 ReCreateHToolbar();
180 ReCreateVToolbar();
181 ReCreateOptToolbar();
182
183 UpdateTitle();
184 UpdateSymbolMsgPanelInfo();
185 RebuildSymbolUnitsList();
186
187 m_propertiesPanel = new SCH_PROPERTIES_PANEL( this, this );
188 m_propertiesPanel->SetSplitterProportion( m_settings->m_AuiPanels.properties_splitter );
189
190 m_selectionFilterPanel = new PANEL_SCH_SELECTION_FILTER( this );
191
192 m_auimgr.SetManagedWindow( this );
193
194 CreateInfoBar();
195
196 // Rows; layers 4 - 6
197 m_auimgr.AddPane( m_mainToolBar, EDA_PANE().HToolbar().Name( "MainToolbar" )
198 .Top().Layer( 6 ) );
199
200 m_auimgr.AddPane( m_messagePanel, EDA_PANE().Messages().Name( "MsgPanel" )
201 .Bottom().Layer( 6 ) );
202
203 // Columns; layers 1 - 3
204 m_auimgr.AddPane( m_treePane, EDA_PANE().Palette().Name( "SymbolTree" )
205 .Left().Layer( 3 )
206 .TopDockable( false ).BottomDockable( false )
207 .Caption( _( "Libraries" ) )
208 .MinSize( FromDIP( 250 ), -1 ).BestSize( FromDIP( 250 ), -1 ) );
209
210 m_auimgr.AddPane( m_propertiesPanel, defaultPropertiesPaneInfo( this ) );
211 // Show or hide m_propertiesPanel depending on current settings:
212 wxAuiPaneInfo& propertiesPaneInfo = m_auimgr.GetPane( PropertiesPaneName() );
213
214 m_auimgr.AddPane( m_selectionFilterPanel, defaultSchSelectionFilterPaneInfo( this ) );
215
216 wxAuiPaneInfo& selectionFilterPane = m_auimgr.GetPane( wxS( "SelectionFilter" ) );
217 // The selection filter doesn't need to grow in the vertical direction when docked
218 selectionFilterPane.dock_proportion = 0;
219
220 propertiesPaneInfo.Show( m_settings->m_AuiPanels.show_properties );
221 updateSelectionFilterVisbility();
222
223 m_auimgr.AddPane( m_optionsToolBar, EDA_PANE().VToolbar().Name( "OptToolbar" )
224 .Left().Layer( 2 ) );
225
226 m_auimgr.AddPane( m_drawToolBar, EDA_PANE().VToolbar().Name( "ToolsToolbar" )
227 .Right().Layer( 2 ) );
228
229 // Center
230 m_auimgr.AddPane( GetCanvas(), wxAuiPaneInfo().Name( "DrawFrame" )
231 .CentrePane() );
232
233 FinishAUIInitialization();
234
235 // Can't put this in LoadSettings, because it has to be called before setupTools :/
236 EE_SELECTION_TOOL* selTool = GetToolManager()->GetTool<EE_SELECTION_TOOL>();
237 selTool->GetFilter() = GetSettings()->m_SelectionFilter;
238
239 if( m_settings->m_LibWidth > 0 )
240 SetAuiPaneSize( m_auimgr, m_auimgr.GetPane( "SymbolTree" ), m_settings->m_LibWidth, -1 );
241
242 Raise();
243 Show( true );
244
245 SyncView();
246 GetCanvas()->GetView()->UseDrawPriority( true );
247 GetCanvas()->GetGAL()->SetAxesEnabled( true );
248
249 setupUnits( m_settings );
250
251 // Set the working/draw area size to display a symbol to a reasonable value:
252 // A 600mm x 600mm with a origin at the area center looks like a large working area
253 double max_size_x = schIUScale.mmToIU( 600 );
254 double max_size_y = schIUScale.mmToIU( 600 );
255 BOX2D bbox;
256 bbox.SetOrigin( -max_size_x /2, -max_size_y/2 );
257 bbox.SetSize( max_size_x, max_size_y );
258 GetCanvas()->GetView()->SetBoundary( bbox );
259
260 m_toolManager->RunAction( ACTIONS::zoomFitScreen );
261
263 DragAcceptFiles( true );
264
265 KIPLATFORM::APP::SetShutdownBlockReason( this, _( "Library changes are unsaved" ) );
266
267 // Catch unhandled accelerator command characters that were no handled by the library tree
268 // panel.
269 Bind( wxEVT_CHAR, &TOOL_DISPATCHER::DispatchWxEvent, m_toolDispatcher );
270 Bind( wxEVT_CHAR_HOOK, &TOOL_DISPATCHER::DispatchWxEvent, m_toolDispatcher );
271
272 // Ensure the window is on top
273 Raise();
274
275 if( loadingCancelled )
276 ShowInfoBarWarning( _( "Symbol library loading was cancelled by user." ) );
277}
278
279
281{
282 // Shutdown all running tools
283 if( m_toolManager )
285
286 setSymWatcher( nullptr );
287
289 {
290 delete m_symbol;
291 m_symbol = nullptr;
292
293 SCH_SCREEN* screen = GetScreen();
294 delete screen;
296 }
297
298 // current screen is destroyed in EDA_DRAW_FRAME
300
301 SYMBOL_EDITOR_SETTINGS* cfg = nullptr;
302
303 try
304 {
306 }
307 catch( const std::runtime_error& e )
308 {
309 wxFAIL_MSG( e.what() );
310 }
311
312 if( cfg )
313 {
314 Pgm().GetSettingsManager().Save( cfg );
315 }
316
317 delete m_libMgr;
318}
319
320
322{
323 wxCHECK_RET( m_settings, "Call to SYMBOL_EDIT_FRAME::LoadSettings with null m_boardAdapter" );
324
326
330 GetRenderSettings()->SetDefaultFont( wxEmptyString );
331}
332
333
335{
336 wxCHECK_RET( m_settings, "Call to SYMBOL_EDIT_FRAME::LoadSettings with null m_boardAdapter" );
337
339
341
345
346 m_settings->m_LibWidth = m_treePane->GetSize().x;
347
349
351 bool prop_shown = m_auimgr.GetPane( PropertiesPaneName() ).IsShown();
353
356}
357
358
360{
361 return static_cast<APP_SETTINGS_BASE*>( GetSettings() );
362}
363
364
366{
368
369 if( GetSettings()->m_UseEeschemaColorSettings )
371 else
372 return mgr.GetColorSettings( GetSettings()->m_ColorTheme );
373}
374
375
377{
378 // Create the manager and dispatcher & route draw panel events to the dispatcher
381 GetCanvas()->GetViewControls(), GetSettings(), this );
382 m_actions = new EE_ACTIONS();
384
385 // Register tools
400
401 // Run the selection tool, it is supposed to be always active
402 m_toolManager->InvokeTool( "eeschema.InteractiveSelection" );
403
405}
406
407
409{
411
413 EDITOR_CONDITIONS cond( this );
414
415 wxASSERT( mgr );
416
417#define ENABLE( x ) ACTION_CONDITIONS().Enable( x )
418#define CHECK( x ) ACTION_CONDITIONS().Check( x )
419
420 auto haveSymbolCond =
421 [this]( const SELECTION& )
422 {
423 return m_symbol;
424 };
425
426 auto isEditableCond =
427 [this]( const SELECTION& )
428 {
429 // Only root symbols from the new s-expression libraries or the schematic
430 // are editable.
431 return IsSymbolEditable() && !IsSymbolAlias();
432 };
433
434 auto symbolModifiedCondition =
435 [this]( const SELECTION& sel )
436 {
439 };
440
441 auto libSelectedCondition =
442 [this]( const SELECTION& sel )
443 {
444 return !GetTargetLibId().GetLibNickname().empty();
445 };
446
447 auto canEditProperties =
448 [this]( const SELECTION& sel )
449 {
451 };
452
453 auto saveSymbolAsCondition =
454 [this]( const SELECTION& aSel )
455 {
456 return getTargetSymbol() != nullptr;
457 };
458
461 mgr->SetConditions( EE_ACTIONS::saveLibraryAs, ENABLE( libSelectedCondition ) );
462 mgr->SetConditions( EE_ACTIONS::saveSymbolCopyAs, ENABLE( saveSymbolAsCondition ) );
465
466 mgr->SetConditions( ACTIONS::undo, ENABLE( haveSymbolCond && cond.UndoAvailable() ) );
467 mgr->SetConditions( ACTIONS::redo, ENABLE( haveSymbolCond && cond.RedoAvailable() ) );
468 mgr->SetConditions( ACTIONS::revert, ENABLE( symbolModifiedCondition ) );
469
473 mgr->SetConditions( ACTIONS::millimetersUnits, CHECK( cond.Units( EDA_UNITS::MILLIMETRES ) ) );
474 mgr->SetConditions( ACTIONS::inchesUnits, CHECK( cond.Units( EDA_UNITS::INCHES ) ) );
475 mgr->SetConditions( ACTIONS::milsUnits, CHECK( cond.Units( EDA_UNITS::MILS ) ) );
476
477 mgr->SetConditions( ACTIONS::cut, ENABLE( isEditableCond ) );
478 mgr->SetConditions( ACTIONS::copy, ENABLE( haveSymbolCond ) );
480 mgr->SetConditions( ACTIONS::doDelete, ENABLE( isEditableCond ) );
481 mgr->SetConditions( ACTIONS::duplicate, ENABLE( isEditableCond ) );
482 mgr->SetConditions( ACTIONS::selectAll, ENABLE( haveSymbolCond ) );
483 mgr->SetConditions( ACTIONS::unselectAll, ENABLE( haveSymbolCond ) );
484
485 mgr->SetConditions( EE_ACTIONS::rotateCW, ENABLE( isEditableCond ) );
486 mgr->SetConditions( EE_ACTIONS::rotateCCW, ENABLE( isEditableCond ) );
487 mgr->SetConditions( EE_ACTIONS::mirrorH, ENABLE( isEditableCond ) );
488 mgr->SetConditions( EE_ACTIONS::mirrorV, ENABLE( isEditableCond ) );
489
492
493 auto pinTypeCond =
494 [this]( const SELECTION& )
495 {
497 };
498
499 auto hiddenPinCond =
500 [this]( const SELECTION& )
501 {
503 };
504
505 auto hiddenFieldCond =
506 [this]( const SELECTION& )
507 {
509 };
510
511 auto showCompTreeCond =
512 [this]( const SELECTION& )
513 {
514 return IsSymbolTreeShown();
515 };
516
517 auto propertiesCond =
518 [this] ( const SELECTION& )
519 {
520 return m_auimgr.GetPane( PropertiesPaneName() ).IsShown();
521 };
522
525 mgr->SetConditions( EE_ACTIONS::showSymbolTree, CHECK( showCompTreeCond ) );
526 mgr->SetConditions( ACTIONS::showProperties, CHECK( propertiesCond ) );
527 mgr->SetConditions( EE_ACTIONS::showHiddenPins, CHECK( hiddenPinCond ) );
528 mgr->SetConditions( EE_ACTIONS::showHiddenFields, CHECK( hiddenFieldCond ) );
529
530 auto demorganCond =
531 [this]( const SELECTION& )
532 {
533 return GetShowDeMorgan();
534 };
535
536 auto demorganStandardCond =
537 [this]( const SELECTION& )
538 {
539 return m_bodyStyle == BODY_STYLE::BASE;
540 };
541
542 auto demorganAlternateCond =
543 [this]( const SELECTION& )
544 {
545 return m_bodyStyle == BODY_STYLE::DEMORGAN;
546 };
547
548 auto multiUnitModeCond =
549 [this]( const SELECTION& )
550 {
551 return m_symbol && m_symbol->IsMulti() && !m_symbol->UnitsLocked();
552 };
553
554 auto hasMultipleUnitsCond =
555 [this]( const SELECTION& )
556 {
557 return m_symbol && m_symbol->IsMulti();
558 };
559
560 auto syncedPinsModeCond =
561 [this]( const SELECTION& )
562 {
563 return m_SyncPinEdit;
564 };
565
566 auto haveDatasheetCond =
567 [this]( const SELECTION& )
568 {
569 return m_symbol && !m_symbol->GetDatasheetField().GetText().IsEmpty();
570 };
571
572 mgr->SetConditions( EE_ACTIONS::showDatasheet, ENABLE( haveDatasheetCond ) );
573 mgr->SetConditions( EE_ACTIONS::symbolProperties, ENABLE( canEditProperties && haveSymbolCond ) );
574 mgr->SetConditions( EE_ACTIONS::runERC, ENABLE( haveSymbolCond ) );
575 mgr->SetConditions( EE_ACTIONS::pinTable, ENABLE( isEditableCond && haveSymbolCond ) );
576
578 ACTION_CONDITIONS().Enable( demorganCond ).Check( demorganStandardCond ) );
580 ACTION_CONDITIONS().Enable( demorganCond ).Check( demorganAlternateCond ) );
582 ACTION_CONDITIONS().Enable( multiUnitModeCond ).Check( syncedPinsModeCond ) );
584 ACTION_CONDITIONS().Enable( isEditableCond && hasMultipleUnitsCond ) );
585
586// Only enable a tool if the symbol is edtable
587#define EDIT_TOOL( tool ) ACTION_CONDITIONS().Enable( isEditableCond ).Check( cond.CurrentTool( tool ) )
588
600
601#undef CHECK
602#undef ENABLE
603#undef EDIT_TOOL
604}
605
606
608{
609 if( IsContentModified() )
610 {
611 SCH_EDIT_FRAME* schframe = (SCH_EDIT_FRAME*) Kiway().Player( FRAME_SCH, false );
612 wxString msg = _( "Save changes to '%s' before closing?" );
613
614 switch( UnsavedChangesDialog( this, wxString::Format( msg, m_reference ), nullptr ) )
615 {
616 case wxID_YES:
617 if( schframe && GetCurSymbol() ) // Should be always the case
619
620 break;
621
622 case wxID_NO:
623 break;
624
625 default:
626 case wxID_CANCEL:
627 return false;
628 }
629 }
630
631 if( doClose )
632 {
633 SetCurSymbol( nullptr, false );
634 UpdateTitle();
635 }
636
637 return true;
638}
639
640
641bool SYMBOL_EDIT_FRAME::canCloseWindow( wxCloseEvent& aEvent )
642{
643 // Shutdown blocks must be determined and vetoed as early as possible
645 && aEvent.GetId() == wxEVT_QUERY_END_SESSION
646 && IsContentModified() )
647 {
648 return false;
649 }
650
652 return false;
653
654 if( !saveAllLibraries( true ) )
655 return false;
656
657 // Save symbol tree column widths
658 m_libMgr->GetAdapter()->SaveSettings();
659
660 return true;
661}
662
663
665{
666 Destroy();
667}
668
669
671{
672 if( !m_unitSelectBox )
673 return;
674
675 if( m_unitSelectBox->GetCount() != 0 )
676 m_unitSelectBox->Clear();
677
678 if( !m_symbol || m_symbol->GetUnitCount() <= 1 )
679 {
680 m_unit = 1;
681 m_unitSelectBox->Append( wxEmptyString );
682 }
683 else
684 {
685 for( int i = 0; i < m_symbol->GetUnitCount(); i++ )
686 {
687 wxString unitDisplayName = m_symbol->GetUnitDisplayName( i + 1 );
688 m_unitSelectBox->Append( unitDisplayName );
689 }
690 }
691
692 // Ensure the selected unit is compatible with the number of units of the current symbol:
694 m_unit = 1;
695
696 m_unitSelectBox->SetSelection(( m_unit > 0 ) ? m_unit - 1 : 0 );
697}
698
699
700void SYMBOL_EDIT_FRAME::OnToggleSymbolTree( wxCommandEvent& event )
701{
702 wxAuiPaneInfo& treePane = m_auimgr.GetPane( m_treePane );
703 treePane.Show( !IsSymbolTreeShown() );
705 m_auimgr.Update();
706}
707
708
710{
711 return const_cast<wxAuiManager&>( m_auimgr ).GetPane( m_treePane ).IsShown();
712}
713
714
716{
718}
719
720
722{
723 m_treePane->Freeze();
724 m_libMgr->GetAdapter()->Freeze();
725}
726
727
729{
730 m_libMgr->GetAdapter()->Thaw();
731 m_treePane->Thaw();
732}
733
734
735void SYMBOL_EDIT_FRAME::OnExitKiCad( wxCommandEvent& event )
736{
737 Kiway().OnKiCadExit();
738}
739
740
741void SYMBOL_EDIT_FRAME::OnUpdateUnitNumber( wxUpdateUIEvent& event )
742{
743 event.Enable( m_symbol && m_symbol->GetUnitCount() > 1 );
744}
745
746
747void SYMBOL_EDIT_FRAME::OnSelectUnit( wxCommandEvent& event )
748{
749 int i = event.GetSelection();
750
751 if( ( i == wxNOT_FOUND ) || ( ( i + 1 ) == m_unit ) )
752 return;
753
756
757 m_unit = i + 1;
758
760 RebuildView();
762}
763
764
766{
767 if( m_symbol )
768 {
770
771 if( row && row->GetType() == SCH_IO_MGR::ShowType( SCH_IO_MGR::SCH_LEGACY ) )
772 return true;
773 }
774
775 return false;
776}
777
778
780{
781 wxString libNickname = Prj().GetRString( PROJECT::SCH_LIBEDIT_CUR_LIB );
782
783 if( !libNickname.empty() )
784 {
785 if( !PROJECT_SCH::SchSymbolLibTable( &Prj() )->HasLibrary( libNickname ) )
786 {
787 Prj().SetRString( PROJECT::SCH_LIBEDIT_CUR_LIB, wxEmptyString );
788 libNickname = wxEmptyString;
789 }
790 }
791
792 return libNickname;
793}
794
795
796wxString SYMBOL_EDIT_FRAME::SetCurLib( const wxString& aLibNickname )
797{
798 wxString old = GetCurLib();
799
800 if( aLibNickname.empty() || !PROJECT_SCH::SchSymbolLibTable( &Prj() )->HasLibrary( aLibNickname ) )
801 Prj().SetRString( PROJECT::SCH_LIBEDIT_CUR_LIB, wxEmptyString );
802 else
804
805 return old;
806}
807
808
809void SYMBOL_EDIT_FRAME::SetCurSymbol( LIB_SYMBOL* aSymbol, bool aUpdateZoom )
810{
811 wxCHECK( m_toolManager, /* void */ );
812
814 GetCanvas()->GetView()->Clear();
815 delete m_symbol;
816
817 m_symbol = aSymbol;
818
819 // select the current symbol in the tree widget
822 else
824
825 wxString symbolName = m_symbol ? m_symbol->GetName() : wxString();
826
827 // retain in case this wxFrame is re-opened later on the same PROJECT
829
830 // Ensure synchronized pin edit can be enabled only symbols with interchangeable units
831 m_SyncPinEdit = aSymbol && aSymbol->IsRoot() && aSymbol->IsMulti() && !aSymbol->UnitsLocked();
832
834
842
843 if( aUpdateZoom )
845
846 GetCanvas()->Refresh();
847
848 WX_INFOBAR* infobar = GetInfoBar();
849
851 {
852 wxString msg;
853 msg.Printf( _( "Editing symbol %s from schematic. Saving will update the schematic "
854 "only." ), m_reference );
855
856 infobar->RemoveAllButtons();
857 infobar->ShowMessage( msg, wxICON_INFORMATION );
858 }
859 else if( IsSymbolFromLegacyLibrary() )
860 {
861 wxHyperlinkCtrl* button = new wxHyperlinkCtrl( infobar, wxID_ANY,
862 _( "Manage symbol libraries" ),
863 wxEmptyString );
864
865 button->Bind( wxEVT_COMMAND_HYPERLINK, std::function<void( wxHyperlinkEvent& aEvent )>(
866 [this]( wxHyperlinkEvent& aEvent )
867 {
869 } ) );
870
871 infobar->RemoveAllButtons();
872 infobar->AddButton( button );
873 infobar->ShowMessage( _( "Symbols in legacy libraries are not editable. Use Manage "
874 "Symbol Libraries to migrate to current format." ),
875 wxICON_INFORMATION );
876 }
877 else if( IsSymbolAlias() )
878 {
879 wxString rootSymbolName;
880
881 // Don't assume the parent symbol shared pointer is still valid.
882 if( std::shared_ptr<LIB_SYMBOL> rootSymbol = m_symbol->GetRootSymbol() )
883 rootSymbolName = rootSymbol->GetName();
884 else
885 {
886 wxCHECK( false, /* void */ );
887 }
888
889 int unit = GetUnit();
890 int bodyStyle = GetBodyStyle();
891 wxString msg;
892 wxString link;
893
894 msg.Printf( _( "Symbol %s is a derived symbol. Symbol graphics will not be editable." ),
895 UnescapeString( symbolName ) );
896
897 link.Printf( _( "Open %s" ), UnescapeString( rootSymbolName ) );
898
899 wxHyperlinkCtrl* button = new wxHyperlinkCtrl( infobar, wxID_ANY, link, wxEmptyString );
900 button->Bind( wxEVT_COMMAND_HYPERLINK, std::function<void( wxHyperlinkEvent& aEvent )>(
901 [this, rootSymbolName, unit, bodyStyle]( wxHyperlinkEvent& aEvent )
902 {
903 LoadSymbolFromCurrentLib( rootSymbolName, unit, bodyStyle );
904 } ) );
905
906 infobar->RemoveAllButtons();
907 infobar->AddButton( button );
908 infobar->ShowMessage( msg, wxICON_INFORMATION );
909 }
910 else
911 {
912 infobar->Dismiss();
913 }
914}
915
916
918{
919 wxASSERT( m_libMgr );
920 return *m_libMgr;
921}
922
923
925{
927
929 m_autoSaveRequired = true;
930
931 if( !IsSymbolFromSchematic() )
933
935
936 if( !GetTitle().StartsWith( "*" ) )
937 UpdateTitle();
938}
939
940
942{
944}
945
946
947wxString SYMBOL_EDIT_FRAME::AddLibraryFile( bool aCreateNew )
948{
949 // Select the target library table (global/project)
951
952 if( !libTable )
953 return wxEmptyString;
954
955 wxFileName fn = m_libMgr->GetUniqueLibraryName();
956
959 ( libTable == &SYMBOL_LIB_TABLE::GetGlobalLibTable() ),
961 {
962 return wxEmptyString;
963 }
964
965 wxString libName = fn.GetName();
966
967 if( libName.IsEmpty() )
968 return wxEmptyString;
969
970 if( m_libMgr->LibraryExists( libName ) )
971 {
972 DisplayError( this, wxString::Format( _( "Library '%s' already exists." ), libName ) );
973 return wxEmptyString;
974 }
975
976 if( aCreateNew )
977 {
978 if( !m_libMgr->CreateLibrary( fn.GetFullPath(), libTable ) )
979 {
980 DisplayError( this, wxString::Format( _( "Could not create the library file '%s'.\n"
981 "Make sure you have write permissions and "
982 "try again." ),
983 fn.GetFullPath() ) );
984 return wxEmptyString;
985 }
986 }
987 else
988 {
989 if( !m_libMgr->AddLibrary( fn.GetFullPath(), libTable ) )
990 {
991 DisplayError( this, _( "Could not open the library file." ) );
992 return wxEmptyString;
993 }
994 }
995
996 bool globalTable = ( libTable == &SYMBOL_LIB_TABLE::GetGlobalLibTable() );
997 saveSymbolLibTables( globalTable, !globalTable );
998
999 std::string packet = fn.GetFullPath().ToStdString();
1001
1002 return fn.GetFullPath();
1003}
1004
1005
1006void SYMBOL_EDIT_FRAME::DdAddLibrary( wxString aLibFile )
1007{
1008 // Select the target library table (global/project)
1009 SYMBOL_LIB_TABLE* libTable = SelectSymLibTable();
1010
1011 if( !libTable )
1012 return;
1013
1014 wxFileName fn = wxFileName( aLibFile );
1015
1016 wxString libName = fn.GetName();
1017
1018 if( libName.IsEmpty() )
1019 return;
1020
1021 if( m_libMgr->LibraryExists( libName ) )
1022 {
1023 DisplayError( this, wxString::Format( _( "Library '%s' already exists." ), libName ) );
1024 return;
1025 }
1026
1027 if( !m_libMgr->AddLibrary( fn.GetFullPath(), libTable ) )
1028 {
1029 DisplayError( this, _( "Could not open the library file." ) );
1030 return;
1031 }
1032
1033 bool globalTable = ( libTable == &SYMBOL_LIB_TABLE::GetGlobalLibTable() );
1034 saveSymbolLibTables( globalTable, !globalTable );
1035
1036 std::string packet = fn.GetFullPath().ToStdString();
1038}
1039
1040
1042{
1043 return m_treePane->GetLibTree()->GetSelectedLibId( aUnit );
1044}
1045
1046
1048{
1050}
1051
1052int SYMBOL_EDIT_FRAME::GetTreeLIBIDs( std::vector<LIB_ID>& aSelection ) const
1053{
1054 return m_treePane->GetLibTree()->GetSelectedLibIds( aSelection );
1055}
1056
1057
1059{
1060 if( IsSymbolTreeShown() )
1061 {
1062 LIB_ID libId = GetTreeLIBID();
1063
1064 if( libId.IsValid() )
1065 return m_libMgr->GetAlias( libId.GetLibItemName(), libId.GetLibNickname() );
1066 }
1067
1068 return m_symbol;
1069}
1070
1071
1073{
1074 LIB_ID id;
1075
1076 if( IsSymbolTreeShown() )
1077 id = GetTreeLIBID();
1078
1079 if( id.GetLibNickname().empty() && m_symbol )
1080 id = m_symbol->GetLibId();
1081
1082 return id;
1083}
1084
1085
1086std::vector<LIB_ID> SYMBOL_EDIT_FRAME::GetSelectedLibIds() const
1087{
1088 std::vector<LIB_ID> ids;
1089 GetTreeLIBIDs( ids );
1090 return ids;
1091}
1092
1093
1095{
1097}
1098
1099
1101{
1102 return GetTargetLibId().GetLibNickname();
1103}
1104
1105
1106void SYMBOL_EDIT_FRAME::SyncLibraries( bool aShowProgress, bool aPreloadCancelled,
1107 const wxString& aForceRefresh )
1108{
1109 LIB_ID selected;
1110
1111 if( m_treePane )
1112 selected = m_treePane->GetLibTree()->GetSelectedLibId();
1113
1114 if( aShowProgress )
1115 {
1116 APP_PROGRESS_DIALOG progressDlg( _( "Loading Symbol Libraries" ), wxEmptyString,
1117 m_libMgr->GetAdapter()->GetLibrariesCount(), this );
1118
1119 m_libMgr->Sync( aForceRefresh,
1120 [&]( int progress, int max, const wxString& libName )
1121 {
1122 progressDlg.Update( progress, wxString::Format( _( "Loading library '%s'..." ),
1123 libName ) );
1124 } );
1125 }
1126 else if( !aPreloadCancelled )
1127 {
1128 m_libMgr->Sync( aForceRefresh,
1129 [&]( int progress, int max, const wxString& libName )
1130 {
1131 } );
1132 }
1133
1134 if( m_treePane )
1135 {
1136 wxDataViewItem found;
1137
1138 if( selected.IsValid() )
1139 {
1140 // Check if the previously selected item is still valid,
1141 // if not - it has to be unselected to prevent crash
1142 found = m_libMgr->GetAdapter()->FindItem( selected );
1143
1144 if( !found )
1146 }
1147
1148 m_treePane->GetLibTree()->Regenerate( true );
1149
1150 // Try to select the parent library, in case the symbol is not found
1151 if( !found && selected.IsValid() )
1152 {
1153 selected.SetLibItemName( "" );
1154 found = m_libMgr->GetAdapter()->FindItem( selected );
1155
1156 if( found )
1157 m_treePane->GetLibTree()->SelectLibId( selected );
1158 }
1159
1160 // If no selection, see if there's a current symbol to centre
1161 if( !selected.IsValid() && m_symbol )
1162 {
1163 LIB_ID current( GetCurLib(), m_symbol->GetName() );
1164 m_treePane->GetLibTree()->CenterLibId( current );
1165 }
1166 }
1167}
1168
1169
1171{
1172 LIB_ID target = GetTargetLibId();
1173
1174 m_treePane->GetLibTree()->Regenerate( true );
1175
1176 if( target.IsValid() )
1177 m_treePane->GetLibTree()->CenterLibId( target );
1178}
1179
1180
1182{
1184}
1185
1186
1188{
1189 m_treePane->GetLibTree()->SelectLibId( aLibID );
1190}
1191
1192
1193void SYMBOL_EDIT_FRAME::UpdateLibraryTree( const wxDataViewItem& aTreeItem, LIB_SYMBOL* aSymbol )
1194{
1195 if( aTreeItem.IsOk() ) // Can be not found in tree if the current footprint is imported
1196 // from file therefore not yet in tree.
1197 {
1198 static_cast<LIB_TREE_NODE_ITEM*>( aTreeItem.GetID() )->Update( aSymbol );
1200 }
1201}
1202
1203
1204bool SYMBOL_EDIT_FRAME::backupFile( const wxFileName& aOriginalFile, const wxString& aBackupExt )
1205{
1206 if( aOriginalFile.FileExists() )
1207 {
1208 wxFileName backupFileName( aOriginalFile );
1209 backupFileName.SetExt( aBackupExt );
1210
1211 if( backupFileName.FileExists() )
1212 wxRemoveFile( backupFileName.GetFullPath() );
1213
1214 if( !wxCopyFile( aOriginalFile.GetFullPath(), backupFileName.GetFullPath() ) )
1215 {
1216 DisplayError( this, wxString::Format( _( "Failed to save backup to '%s'." ),
1217 backupFileName.GetFullPath() ) );
1218 return false;
1219 }
1220 }
1221
1222 return true;
1223}
1224
1225
1227{
1228 if( m_symbol && !GetCurLib().IsEmpty() && GetScreen()->IsContentModified() )
1229 m_libMgr->UpdateSymbol( m_symbol, GetCurLib() ); // UpdateSymbol() makes a copy
1230}
1231
1232
1234{
1235 // This will return the root symbol of any alias
1237 aLibId.GetLibNickname() );
1238
1239 // Now we can compare the libId of the current symbol and the root symbol
1240 return ( symbol && m_symbol && symbol->GetLibId() == m_symbol->GetLibId() );
1241}
1242
1243
1245{
1247 SetCurLib( wxEmptyString );
1248 SetCurSymbol( nullptr, false );
1252 Refresh();
1253}
1254
1255
1256void SYMBOL_EDIT_FRAME::CommonSettingsChanged( bool aEnvVarsChanged, bool aTextVarsChanged )
1257{
1258 SCH_BASE_FRAME::CommonSettingsChanged( aEnvVarsChanged, aTextVarsChanged );
1259
1262
1266
1268
1269 if( m_symbol )
1271
1273
1275 GetCanvas()->Refresh();
1276
1278
1279 if( aEnvVarsChanged )
1280 SyncLibraries( true );
1281
1282 Layout();
1283 SendSizeEvent();
1284}
1285
1286
1288{
1289 // call my base class
1291
1292 // tooltips in toolbars
1294
1295 // For some obscure reason, the AUI manager hides the first modified pane.
1296 // So force show panes
1297 wxAuiPaneInfo& tree_pane_info = m_auimgr.GetPane( m_treePane );
1298 bool tree_shown = tree_pane_info.IsShown();
1299 tree_pane_info.Caption( _( "Libraries" ) );
1300 tree_pane_info.Show( tree_shown );
1301 m_auimgr.Update();
1302
1304
1305 // status bar
1307
1308 if( GetRenderSettings()->m_ShowPinsElectricalType )
1309 {
1311 GetCanvas()->Refresh();
1312 }
1313
1314 UpdateTitle();
1315}
1316
1317
1319{
1320 SCH_BASE_FRAME::SetScreen( aScreen );
1321
1322 // Let tools add things to the view if necessary
1323 if( m_toolManager )
1325}
1326
1327
1329{
1337
1338 // Let tools add things to the view if necessary
1339 if( m_toolManager )
1341
1343 GetCanvas()->Refresh();
1344}
1345
1346
1348{
1349 SyncLibraries( true );
1350
1351 if( m_symbol )
1352 {
1354 EE_SELECTION& selection = selectionTool->GetSelection();
1355
1356 for( SCH_ITEM& item : m_symbol->GetDrawItems() )
1357 {
1358 if( !alg::contains( selection, &item ) )
1359 item.ClearSelected();
1360 else
1361 item.SetSelected();
1362 }
1363
1365 }
1366
1367 RebuildView();
1368}
1369
1370
1371const BOX2I SYMBOL_EDIT_FRAME::GetDocumentExtents( bool aIncludeAllVisible ) const
1372{
1373 if( !m_symbol )
1374 {
1375 // Gives a reasonable drawing area size
1376 int width = schIUScale.mmToIU( 50 );
1377 int height = schIUScale.mmToIU( 30 );
1378
1379 return BOX2I( VECTOR2I( -width/2, -height/2 ),
1380 VECTOR2I( width, height ) );
1381 }
1382 else
1383 {
1384 return m_symbol->Flatten()->GetUnitBoundingBox( m_unit, m_bodyStyle );
1385 }
1386}
1387
1388
1390{
1391 static KIID lastBrightenedItemID( niluuid );
1392
1393 SCH_ITEM* lastItem = nullptr;
1394
1395 if( m_symbol )
1396 {
1397 for( SCH_PIN* pin : m_symbol->GetAllLibPins() )
1398 {
1399 if( pin->m_Uuid == lastBrightenedItemID )
1400 lastItem = pin;
1401 }
1402
1403 std::vector<SCH_FIELD*> fields;
1404 m_symbol->GetFields( fields );
1405
1406 for( SCH_FIELD* field : fields )
1407 {
1408 if( field->m_Uuid == lastBrightenedItemID )
1409 lastItem = field;
1410 }
1411 }
1412
1413 if( lastItem && lastItem != aItem )
1414 {
1415 lastItem->ClearBrightened();
1416
1417 UpdateItem( lastItem );
1418 lastBrightenedItemID = niluuid;
1419 }
1420
1421 if( aItem )
1422 {
1423 if( !aItem->IsBrightened() )
1424 {
1425 aItem->SetBrightened();
1426
1427 UpdateItem( aItem );
1428 lastBrightenedItemID = aItem->m_Uuid;
1429 }
1430
1431 FocusOnLocation( VECTOR2I( aItem->GetFocusPosition().x, -aItem->GetFocusPosition().y ) );
1432 }
1433}
1434
1435
1437{
1438 const std::string& payload = mail.GetPayload();
1439
1440 switch( mail.Command() )
1441 {
1442 case MAIL_LIB_EDIT:
1443 if( !payload.empty() )
1444 {
1445 wxString libFileName( payload );
1446 wxString libNickname;
1447 wxString msg;
1448
1450 const LIB_TABLE_ROW* libTableRow = libTable->FindRowByURI( libFileName );
1451
1452 if( !libTableRow )
1453 {
1454 msg.Printf( _( "The current configuration does not include the symbol library '%s'." ),
1455 libFileName );
1456 msg += wxS( "\n" ) + _( "Use Manage Symbol Libraries to edit the configuration." );
1457 DisplayErrorMessage( this, _( "Library not found in symbol library table." ), msg );
1458 break;
1459 }
1460
1461 libNickname = libTableRow->GetNickName();
1462
1463 if( !libTable->HasLibrary( libNickname, true ) )
1464 {
1465 msg.Printf( _( "The symbol library '%s' is not enabled in the current configuration." ),
1466 UnescapeString( libNickname ) );
1467 msg += wxS( "\n" ) + _( "Use Manage Symbol Libraries to edit the configuration." );
1468 DisplayErrorMessage( this, _( "Symbol library not enabled." ), msg );
1469 break;
1470 }
1471
1472 SetCurLib( libNickname );
1473
1474 if( m_treePane )
1475 {
1476 LIB_ID id( libNickname, wxEmptyString );
1480 }
1481 }
1482
1483 break;
1484
1485 case MAIL_RELOAD_LIB:
1486 {
1487 wxString currentLib = GetCurLib();
1489
1491
1492 // Check if the currently selected symbol library been removed or disabled.
1493 if( !currentLib.empty() && libTable && !libTable->HasLibrary( currentLib, true ) )
1494 {
1495 SetCurLib( wxEmptyString );
1496 emptyScreen();
1497 }
1498
1499 SyncLibraries( true );
1502
1503 break;
1504 }
1505
1507 {
1509 LIB_SYMBOL* symbol = GetCurSymbol();
1510
1511 wxLogTrace( "KICAD_LIB_WATCH", "Received refresh symbol request for %s",
1512 payload );
1513
1514 if( !tbl || !symbol )
1515 break;
1516
1517 wxString libName = symbol->GetLibId().GetLibNickname();
1518 const SYMBOL_LIB_TABLE_ROW* row = tbl->FindRow( libName );
1519
1520 if( !row )
1521 return;
1522
1523 wxFileName libfullname( row->GetFullURI( true ) );
1524
1525 wxFileName changedLib( mail.GetPayload() );
1526 wxLogTrace( "KICAD_LIB_WATCH",
1527 "Received refresh symbol request for %s, current symbols is %s",
1528 changedLib.GetFullPath(), libfullname.GetFullPath() );
1529
1530 if( changedLib == libfullname )
1531 {
1532 wxLogTrace( "KICAD_LIB_WATCH", "Refreshing symbol %s", symbol->GetName() );
1533
1534 SetScreen( m_dummyScreen ); // UpdateLibraryBuffer will destroy the old screen
1535 m_libMgr->UpdateLibraryBuffer( libName );
1536
1537 LIB_SYMBOL* lib_symbol = m_libMgr->GetBufferedSymbol( symbol->GetName(), libName );
1538 wxCHECK2_MSG( lib_symbol, break, wxString::Format( "Symbol %s not found in library %s",
1539 symbol->GetName(), libName ) );
1540
1541 // The buffered screen for the symbol
1542 SCH_SCREEN* symbol_screen = m_libMgr->GetScreen( lib_symbol->GetName(), libName );
1543
1544 SetScreen( symbol_screen );
1545 SetCurSymbol( new LIB_SYMBOL( *lib_symbol ), false );
1547 SetShowDeMorgan( GetCurSymbol()->HasAlternateBodyStyle() );
1548
1549 if( m_toolManager )
1551 }
1552
1553 break;
1554 }
1555
1556 default:
1557 ;
1558 }
1559}
1560
1561
1563{
1564 // switches currently used canvas ( Cairo / OpenGL):
1565 SCH_BASE_FRAME::SwitchCanvas( aCanvasType );
1566
1567 // Set options specific to symbol editor (axies are always enabled):
1568 GetCanvas()->GetGAL()->SetAxesEnabled( true );
1570}
1571
1572
1574{
1575 wxCHECK( m_libMgr, false );
1576
1577 return m_libMgr->HasModifications();
1578}
1579
1580
1582{
1583 wxCHECK( m_libMgr, false );
1584
1585 // Test if the currently edited symbol is modified
1587 return true;
1588
1589 // Test if any library has been modified
1590 for( const wxString& libName : m_libMgr->GetLibraryNames() )
1591 {
1592 if( m_libMgr->IsLibraryModified( libName ) && !m_libMgr->IsLibraryReadOnly( libName ) )
1593 return true;
1594 }
1595
1596 return false;
1597}
1598
1599
1601{
1602 if( aItemCount == 0 )
1603 return;
1604
1605 UNDO_REDO_CONTAINER& list = ( whichList == UNDO_LIST ) ? m_undoList : m_redoList;
1606
1607 if( aItemCount < 0 )
1608 {
1609 list.ClearCommandList();
1610 }
1611 else
1612 {
1613 for( int ii = 0; ii < aItemCount; ii++ )
1614 {
1615 if( list.m_CommandsList.size() == 0 )
1616 break;
1617
1618 PICKED_ITEMS_LIST* curr_cmd = list.m_CommandsList[0];
1619 list.m_CommandsList.erase( list.m_CommandsList.begin() );
1620
1621 curr_cmd->ClearListAndDeleteItems( []( EDA_ITEM* aItem )
1622 {
1623 delete aItem;
1624 } );
1625 delete curr_cmd; // Delete command
1626 }
1627 }
1628}
1629
1630
1632{
1633 return m_toolManager->GetTool<EE_SELECTION_TOOL>()->GetSelection();
1634}
1635
1636
1638{
1639 std::unique_ptr<LIB_SYMBOL> symbol = aSymbol->GetLibSymbolRef()->Flatten();
1640 wxCHECK( symbol, /* void */ );
1641
1642 // Take in account the symbol orientation and mirroring. to calculate the field
1643 // positions in symbol editor (i.e. no rotation, no mirroring)
1644 int orientation = aSymbol->GetOrientation() & ~( SYM_MIRROR_X | SYM_MIRROR_Y );
1645 int mirror = aSymbol->GetOrientation() & ( SYM_MIRROR_X | SYM_MIRROR_Y );
1646
1647 std::vector<SCH_FIELD> fullSetOfFields;
1648
1649 for( int i = 0; i < (int) aSymbol->GetFields().size(); ++i )
1650 {
1651 const SCH_FIELD& field = aSymbol->GetFields()[i];
1652 VECTOR2I pos = field.GetPosition() - aSymbol->GetPosition();
1653 SCH_FIELD libField( symbol.get(), field.GetId() );
1654
1655 if( i >= MANDATORY_FIELDS && !field.GetName( false ).IsEmpty() )
1656 libField.SetName( field.GetName( false ) );
1657
1658 libField.SetText( field.GetText() );
1659 libField.SetAttributes( field );
1660
1661 // The inverse transform is mirroring before, rotate after
1662 switch( mirror )
1663 {
1664 case SYM_MIRROR_X: pos.y = -pos.y; break;
1665 case SYM_MIRROR_Y: pos.x = -pos.x; break;
1666 default: break;
1667 }
1668
1669 switch( orientation )
1670 {
1671 case SYM_ORIENT_90:
1672 std::swap( pos.x, pos.y );
1673 pos.x = - pos.x;
1674 break;
1675 case SYM_ORIENT_270:
1676 std::swap( pos.x, pos.y );
1677 pos.y = - pos.y;
1678 break;
1679 case SYM_ORIENT_180:
1680 pos.x = - pos.x;
1681 pos.y = - pos.y;
1682 break;
1683 default:
1684 break;
1685 }
1686
1687 libField.SetPosition( pos );
1688
1689 fullSetOfFields.emplace_back( std::move( libField ) );
1690 }
1691
1692 symbol->SetFields( fullSetOfFields );
1693
1694 if( m_symbol )
1695 SetCurSymbol( nullptr, false );
1696
1698 m_schematicSymbolUUID = aSymbol->m_Uuid;
1699 m_reference = symbol->GetFieldById( REFERENCE_FIELD )->GetText();
1700 m_unit = std::max( 1, aSymbol->GetUnit() );
1701 m_bodyStyle = std::max( 1, aSymbol->GetBodyStyle() );
1702
1703 // Optimize default edit options for this symbol
1704 // Usually if units are locked, graphic items are specific to each unit
1705 // and if units are interchangeable, graphic items are common to units
1707 tools->SetDrawSpecificUnit( symbol->UnitsLocked() );
1708
1709 // The buffered screen for the symbol
1710 SCH_SCREEN* tmpScreen = new SCH_SCREEN();
1711
1712 SetScreen( tmpScreen );
1713 SetCurSymbol( symbol.release(), true );
1714 setSymWatcher( nullptr );
1715
1718
1719 if( IsSymbolTreeShown() )
1720 {
1721 wxCommandEvent evt;
1722 OnToggleSymbolTree( evt );
1723 }
1724
1725 UpdateTitle();
1727 SetShowDeMorgan( GetCurSymbol()->HasAlternateBodyStyle() );
1729
1730 // Let tools add things to the view if necessary
1731 if( m_toolManager )
1733
1735 GetCanvas()->Refresh();
1736}
1737
1738
1739bool SYMBOL_EDIT_FRAME::addLibTableEntry( const wxString& aLibFile, TABLE_SCOPE aScope )
1740{
1741 wxFileName fn = aLibFile;
1742 wxFileName libTableFileName( Prj().GetProjectPath(),
1744 wxString libNickname = fn.GetName();
1746 const ENV_VAR_MAP& envVars = Pgm().GetLocalEnvVariables();
1747
1748 if( libTable->HasLibrary( libNickname ) )
1749 {
1750 wxString tmp;
1751 int suffix = 1;
1752
1753 while( libTable->HasLibrary( libNickname ) )
1754 {
1755 tmp.Printf( "%s%d", fn.GetName(), suffix );
1756 libNickname = tmp;
1757 suffix += 1;
1758 }
1759 }
1760
1762 row->SetNickName( libNickname );
1763
1764 wxString normalizedPath = NormalizePath( aLibFile, &envVars, Prj().GetProjectPath() );
1765
1766 if( aScope == GLOBAL_LIB_TABLE )
1767 {
1769 libTableFileName = SYMBOL_LIB_TABLE::GetGlobalTableFileName();
1770
1771 // We cannot normalize against the current project path when saving to global table.
1772 normalizedPath = NormalizePath( aLibFile, &envVars, wxEmptyString );
1773 }
1774
1775 row->SetFullURI( normalizedPath );
1776
1777 wxCHECK( libTable->InsertRow( row ), false );
1778
1779 try
1780 {
1781 libTable->Save( libTableFileName.GetFullPath() );
1782 }
1783 catch( const IO_ERROR& ioe )
1784 {
1785 wxString msg = aScope == GLOBAL_LIB_TABLE ? _( "Error saving global library table." )
1786 : _( "Error saving project library table." );
1787
1788 wxMessageDialog dlg( this, msg, _( "File Save Error" ), wxOK | wxICON_ERROR );
1789 dlg.SetExtendedMessage( ioe.What() );
1790 dlg.ShowModal();
1791
1792 return false;
1793 }
1794
1795 return true;
1796}
1797
1798
1799bool SYMBOL_EDIT_FRAME::replaceLibTableEntry( const wxString& aLibNickname,
1800 const wxString& aLibFile )
1801{
1802 // Check the global library table first because checking the project library table
1803 // checks the global library table as well due to library chaining.
1804 bool isGlobalTable = true;
1805 wxFileName libTableFileName = SYMBOL_LIB_TABLE::GetGlobalTableFileName();;
1806 const ENV_VAR_MAP& envVars = Pgm().GetLocalEnvVariables();
1808 SYMBOL_LIB_TABLE_ROW* row = libTable->FindRow( aLibNickname );
1809
1810 if( !row )
1811 {
1812 libTableFileName.SetPath( Prj().GetProjectPath() );
1813 libTableFileName.SetName( SYMBOL_LIB_TABLE::GetSymbolLibTableFileName() );
1814 libTable = PROJECT_SCH::SchSymbolLibTable( &Prj() );
1815 isGlobalTable = false;
1816 row = libTable->FindRow( aLibNickname );
1817 }
1818
1819 wxCHECK( row, false );
1820
1821 wxString projectPath;
1822
1823 if( !isGlobalTable )
1824 projectPath = Prj().GetProjectPath();
1825
1826 wxString normalizedPath = NormalizePath( aLibFile, &envVars, projectPath );
1827
1828 row->SetFullURI( normalizedPath );
1829 row->SetType( "KiCad" );
1830
1831 try
1832 {
1833 libTable->Save( libTableFileName.GetFullPath() );
1834 }
1835 catch( const IO_ERROR& ioe )
1836 {
1837 wxString msg = isGlobalTable ? _( "Error saving global library table." )
1838 : _( "Error saving project library table." );
1839
1840 wxMessageDialog dlg( this, msg, _( "File Save Error" ), wxOK | wxICON_ERROR );
1841 dlg.SetExtendedMessage( ioe.What() );
1842 dlg.ShowModal();
1843
1844 return false;
1845 }
1846
1847 return true;
1848}
1849
1850
1852{
1853 return m_symbol && !m_symbol->IsRoot();
1854}
1855
1856
1858{
1860}
1861
1862
1863void SYMBOL_EDIT_FRAME::UpdateItem( EDA_ITEM* aItem, bool isAddOrDelete, bool aUpdateRtree )
1864{
1865 SCH_BASE_FRAME::UpdateItem( aItem, isAddOrDelete, aUpdateRtree );
1866
1867 if( EDA_TEXT* eda_text = dynamic_cast<EDA_TEXT*>( aItem ) )
1868 {
1869 eda_text->ClearBoundingBoxCache();
1870 eda_text->ClearRenderCache();
1871 }
1872}
1873
1874
1876{
1877 wxAuiPaneInfo& treePane = m_auimgr.GetPane( "SymbolTree" );
1878 wxAuiPaneInfo& propertiesPane = m_auimgr.GetPane( PropertiesPaneName() );
1879 wxAuiPaneInfo& selectionFilterPane = m_auimgr.GetPane( wxS( "SelectionFilter" ) );
1880
1881 // Don't give the selection filter its own visibility controls; instead show it if
1882 // anything else is visible
1883 bool showFilter = ( treePane.IsShown() && treePane.IsDocked() )
1884 || ( propertiesPane.IsShown() && propertiesPane.IsDocked() );
1885
1886 selectionFilterPane.Show( showFilter );
1887}
1888
1889
1891{
1892 // Returns the current render option for invisible fields
1894}
1895
1896
1898{
1899 // Returns the current render option for invisible pins
1901}
BASE_SCREEN class implementation.
constexpr EDA_IU_SCALE schIUScale
Definition: base_units.h:110
wxBitmap KiBitmap(BITMAPS aBitmap, int aHeightTag)
Construct a wxBitmap from an image identifier Returns the image from the active theme if the image ha...
Definition: bitmap.cpp:104
@ icon_libedit_32
@ icon_libedit
@ icon_libedit_16
BOX2< VECTOR2I > BOX2I
Definition: box2.h:877
static TOOL_ACTION toggleGrid
Definition: actions.h:172
static TOOL_ACTION paste
Definition: actions.h:70
static TOOL_ACTION cancelInteractive
Definition: actions.h:63
static TOOL_ACTION millimetersUnits
Definition: actions.h:180
static TOOL_ACTION unselectAll
Definition: actions.h:73
static TOOL_ACTION revert
Definition: actions.h:55
static TOOL_ACTION copy
Definition: actions.h:69
static TOOL_ACTION milsUnits
Definition: actions.h:179
static TOOL_ACTION toggleBoundingBoxes
Definition: actions.h:135
static TOOL_ACTION saveAll
Definition: actions.h:54
static TOOL_ACTION undo
Definition: actions.h:66
static TOOL_ACTION duplicate
Definition: actions.h:74
static TOOL_ACTION inchesUnits
Definition: actions.h:178
static TOOL_ACTION toggleCursorStyle
Definition: actions.h:132
static TOOL_ACTION doDelete
Definition: actions.h:75
static TOOL_ACTION selectionTool
Definition: actions.h:187
static TOOL_ACTION save
Definition: actions.h:51
static TOOL_ACTION zoomFitScreen
Definition: actions.h:124
static TOOL_ACTION redo
Definition: actions.h:67
static TOOL_ACTION deleteTool
Definition: actions.h:76
static TOOL_ACTION zoomTool
Definition: actions.h:127
static TOOL_ACTION showProperties
Definition: actions.h:201
static TOOL_ACTION cut
Definition: actions.h:68
static TOOL_ACTION ddAddLibrary
Definition: actions.h:60
static TOOL_ACTION toggleGridOverrides
Definition: actions.h:173
static TOOL_ACTION selectAll
Definition: actions.h:72
Manage TOOL_ACTION objects.
void SetConditions(const TOOL_ACTION &aAction, const ACTION_CONDITIONS &aConditions)
Set the conditions the UI elements for activating a specific tool action should use for determining t...
wxProgressDialog with the option to also update the application progress on the taskbar
virtual bool Update(int aValue, const wxString &aNewMsg=wxEmptyString, bool *aSkip=nullptr) override
APP_SETTINGS_BASE is a settings class that should be derived for each standalone KiCad application.
Definition: app_settings.h:92
WINDOW_SETTINGS m_Window
Definition: app_settings.h:172
wxString m_ColorTheme
Active color theme name.
Definition: app_settings.h:175
Handles how to draw a screen (a board, a schematic ...)
Definition: base_screen.h:41
void SetContentModified(bool aModified=true)
Definition: base_screen.h:59
void SetOrigin(const Vec &pos)
Definition: box2.h:227
void SetSize(const SizeVec &size)
Definition: box2.h:238
Color settings are a bit different than most of the settings objects in that there can be more than o...
COLOR4D GetColor(int aLayer) const
Handle actions that are shared between different applications.
Handles action that are shared between different applications.
Definition: common_tools.h:38
UNDO_REDO_CONTAINER m_undoList
void ShowChangedLanguage() override
Redraw the menus and what not in current language.
virtual void setupUIConditions()
Setup the UI conditions for the various actions and their controls in this frame.
virtual void ClearUndoRedoList()
Clear the undo and redo list using ClearUndoORRedoList()
SETTINGS_MANAGER * GetSettingsManager() const
UNDO_REDO_LIST
Specifies whether we are interacting with the undo or redo stacks.
virtual void OnModify()
Must be called after a model change in order to set the "modify" flag and do other frame-specific pro...
wxAuiManager m_auimgr
UNDO_REDO_CONTAINER m_redoList
virtual void OnDropFiles(wxDropFilesEvent &aEvent)
Handles event fired when a file is dropped to the window.
void ReCreateMenuBar()
Recreates the menu bar.
WX_INFOBAR * GetInfoBar()
COLOR_SETTINGS * m_colorSettings
bool LibraryFileBrowser(bool doOpen, wxFileName &aFilename, const wxString &wildcard, const wxString &ext, bool isDirectory=false, bool aIsGlobal=false, const wxString &aGlobalPath=wxEmptyString)
virtual void SwitchCanvas(EDA_DRAW_PANEL_GAL::GAL_TYPE aCanvasType)
Changes the current rendering backend.
GAL_DISPLAY_OPTIONS_IMPL & GetGalDisplayOptions()
Return a reference to the gal rendering options used by GAL for rendering.
static const wxString PropertiesPaneName()
void FocusOnLocation(const VECTOR2I &aPos)
Useful to focus on a particular location, in find functions.
virtual void SetScreen(BASE_SCREEN *aScreen)
void RecreateToolbars()
Rebuild all toolbars, and update the checked state of check tools.
PROPERTIES_PANEL * m_propertiesPanel
void ForceRefresh()
Force a redraw.
virtual void Refresh(bool aEraseBackground=true, const wxRect *aRect=nullptr) override
KIGFX::GAL * GetGAL() const
Return a pointer to the GAL instance used in the panel.
void SetEventDispatcher(TOOL_DISPATCHER *aEventDispatcher)
Set a dispatcher that processes events and forwards them to tools.
A base class for most all the KiCad significant classes used in schematics and boards.
Definition: eda_item.h:88
virtual const VECTOR2I GetFocusPosition() const
Similar to GetPosition, but allows items to return their visual center rather than their anchor.
Definition: eda_item.h:249
const KIID m_Uuid
Definition: eda_item.h:485
void ClearBrightened()
Definition: eda_item.h:122
void SetBrightened()
Definition: eda_item.h:119
bool IsBrightened() const
Definition: eda_item.h:111
Specialization of the wxAuiPaneInfo class for KiCad panels.
A mix-in class (via multiple inheritance) that handles texts such as labels, parts,...
Definition: eda_text.h:83
virtual const wxString & GetText() const
Return the string associated with the text object.
Definition: eda_text.h:98
void SetAttributes(const EDA_TEXT &aSrc, bool aSetPosition=true)
Set the text attributes from another instance.
Definition: eda_text.cpp:290
Class that groups generic conditions for editor states.
SELECTION_CONDITION BoundingBoxes()
SELECTION_CONDITION RedoAvailable()
Create a functor that tests if there are any items in the redo queue.
SELECTION_CONDITION CurrentTool(const TOOL_ACTION &aTool)
Create a functor testing if the specified tool is the current active tool in the frame.
virtual SELECTION_CONDITION UndoAvailable()
Create a functor that tests if there are any items in the undo queue.
SELECTION_CONDITION Units(EDA_UNITS aUnit)
Create a functor that tests if the frame has the specified units.
SELECTION_CONDITION GridVisible()
Create a functor testing if the grid is visible in a frame.
SELECTION_CONDITION GridOverrides()
Create a functor testing if the grid overrides wires is enabled in a frame.
SELECTION_CONDITION FullscreenCursor()
Create a functor testing if the cursor is full screen in a frame.
Gather all the actions that are shared by tools.
Definition: ee_actions.h:39
static TOOL_ACTION mirrorV
Definition: ee_actions.h:126
static TOOL_ACTION runERC
Definition: ee_actions.h:151
static TOOL_ACTION pinTable
Definition: ee_actions.h:156
static TOOL_ACTION clearSelection
Clears the current selection.
Definition: ee_actions.h:56
static TOOL_ACTION placeSymbolAnchor
Definition: ee_actions.h:117
static TOOL_ACTION showHiddenFields
Definition: ee_actions.h:237
static TOOL_ACTION drawSymbolPolygon
Definition: ee_actions.h:116
static TOOL_ACTION showDeMorganAlternate
Definition: ee_actions.h:136
static TOOL_ACTION newSymbol
Definition: ee_actions.h:202
static TOOL_ACTION drawCircle
Definition: ee_actions.h:101
static TOOL_ACTION showDeMorganStandard
Definition: ee_actions.h:135
static TOOL_ACTION rotateCCW
Definition: ee_actions.h:125
static TOOL_ACTION saveLibraryAs
Definition: ee_actions.h:200
static TOOL_ACTION placeSymbolText
Definition: ee_actions.h:113
static TOOL_ACTION mirrorH
Definition: ee_actions.h:127
static TOOL_ACTION rotateCW
Definition: ee_actions.h:124
static TOOL_ACTION importGraphics
Definition: ee_actions.h:256
static TOOL_ACTION importSymbol
Definition: ee_actions.h:211
static TOOL_ACTION showDatasheet
Inspection and Editing.
Definition: ee_actions.h:150
static TOOL_ACTION saveSymbolCopyAs
Definition: ee_actions.h:201
static TOOL_ACTION symbolProperties
Definition: ee_actions.h:155
static TOOL_ACTION drawRectangle
Definition: ee_actions.h:100
static TOOL_ACTION setUnitDisplayName
Definition: ee_actions.h:214
static TOOL_ACTION drawSymbolTextBox
Definition: ee_actions.h:114
static TOOL_ACTION drawSymbolLines
Definition: ee_actions.h:115
static TOOL_ACTION drawArc
Definition: ee_actions.h:102
static TOOL_ACTION toggleSyncedPinsMode
Definition: ee_actions.h:244
static TOOL_ACTION showSymbolTree
Definition: ee_actions.h:252
static TOOL_ACTION showHiddenPins
Definition: ee_actions.h:236
static TOOL_ACTION placeSymbolPin
Definition: ee_actions.h:112
static TOOL_ACTION showElectricalTypes
Definition: ee_actions.h:250
Tool that displays edit points allowing to modify items by dragging the points.
SCH_SELECTION_FILTER_OPTIONS & GetFilter()
EE_SELECTION & GetSelection()
void ReadWindowSettings(WINDOW_SETTINGS &aCfg)
Read GAL config options from application-level config.
Hold an error message and may be used when throwing exceptions containing meaningful error messages.
Definition: ki_exception.h:77
virtual const wxString What() const
A composite of Problem() and Where()
Definition: exceptions.cpp:30
bool m_axesEnabled
Fullscreen crosshair or small cross.
void SetAxesEnabled(bool aAxesEnabled)
Enable drawing the axes.
void SetAxesColor(const COLOR4D &aAxesColor)
Set the axes color.
void SetDefaultFont(const wxString &aFont)
void HideDrawingSheet()
Definition: sch_view.cpp:186
void ClearHiddenFlags()
Clear the hide flag of all items in the view.
Definition: sch_view.cpp:179
void Clear()
Remove all items from the view.
Definition: view.cpp:1124
void UpdateAllItems(int aUpdateFlags)
Update all items in the view according to the given flags.
Definition: view.cpp:1513
Definition: kiid.h:49
Carry a payload from one KIWAY_PLAYER to another within a PROJECT.
Definition: kiway_express.h:40
std::string & GetPayload()
Return the payload, which can be any text but it typically self identifying s-expression.
Definition: kiway_express.h:58
MAIL_T Command()
Returns the MAIL_T associated with this mail.
Definition: kiway_express.h:50
bool Destroy() override
Our version of Destroy() which is virtual from wxWidgets.
A minimalistic software bus for communications between various DLLs/DSOs (DSOs) within the same KiCad...
Definition: kiway.h:279
void OnKiCadExit()
Definition: kiway.cpp:717
virtual KIWAY_PLAYER * Player(FRAME_T aFrameType, bool doCreate=true, wxTopLevelWindow *aParent=nullptr)
Return the KIWAY_PLAYER* given a FRAME_T.
Definition: kiway.cpp:406
virtual void ExpressMail(FRAME_T aDestination, MAIL_T aCommand, std::string &aPayload, wxWindow *aSource=nullptr)
Send aPayload to aDestination from aSource.
Definition: kiway.cpp:527
A logical library item identifier and consists of various portions much like a URI.
Definition: lib_id.h:49
int SetLibItemName(const UTF8 &aLibItemName)
Override the library item name portion of the LIB_ID to aLibItemName.
Definition: lib_id.cpp:110
bool IsValid() const
Check if this LID_ID is valid.
Definition: lib_id.h:172
const UTF8 & GetLibItemName() const
Definition: lib_id.h:102
const UTF8 & GetLibNickname() const
Return the logical library name portion of a LIB_ID.
Definition: lib_id.h:87
Symbol library management helper that is specific to the symbol library editor frame.
void Sync(const wxString &aForceRefresh, std::function< void(int, int, const wxString &)> aProgressCallback)
Updates the SYMBOL_LIBRARY_MANAGER data to synchronize with Symbol Library Table.
wxObjectDataPtr< LIB_TREE_MODEL_ADAPTER > & GetAdapter()
Return the adapter object that provides the stored data.
Define a library symbol object.
Definition: lib_symbol.h:77
const LIB_ID & GetLibId() const override
Definition: lib_symbol.h:142
bool IsMulti() const override
Definition: lib_symbol.h:541
bool UnitsLocked() const
Check whether symbol units are interchangeable.
Definition: lib_symbol.h:263
void GetFields(std::vector< SCH_FIELD * > &aList)
Return a list of fields within this symbol.
bool IsRoot() const override
For symbols derived from other symbols, IsRoot() indicates no derivation.
Definition: lib_symbol.h:193
wxString GetUnitDisplayName(int aUnit) override
Return the user-defined display name for aUnit for symbols with units.
Definition: lib_symbol.cpp:535
std::vector< SCH_PIN * > GetAllLibPins() const
Return a list of pin pointers for all units / converts.
SCH_FIELD & GetDatasheetField() const
Return reference to the datasheet field.
LIB_ITEMS_CONTAINER & GetDrawItems()
Return a reference to the draw item list.
Definition: lib_symbol.h:486
wxString GetName() const override
Definition: lib_symbol.h:136
wxString GetLibNickname() const override
Sets the Description field text value.
Definition: lib_symbol.h:148
int GetUnitCount() const override
std::unique_ptr< LIB_SYMBOL > Flatten() const
Return a flattened symbol inheritance to the caller.
Definition: lib_symbol.cpp:579
LIB_SYMBOL_SPTR GetRootSymbol() const
Get the parent symbol that does not have another parent.
Definition: lib_symbol.cpp:511
Hold a record identifying a library accessed by the appropriate plug in object in the LIB_TABLE.
void SetFullURI(const wxString &aFullURI)
Change the full URI for the library.
void SetNickName(const wxString &aNickName)
Change the logical name of this library, useful for an editor.
const wxString & GetNickName() const
const wxString GetFullURI(bool aSubstituted=false) const
Return the full location specifying URI for the LIB, either in original UI form or in environment var...
bool HasLibrary(const wxString &aNickname, bool aCheckEnabled=false) const
Test for the existence of aNickname in the library table.
bool InsertRow(LIB_TABLE_ROW *aRow, bool doReplace=false)
Adds aRow if it does not already exist or if doReplace is true.
const LIB_TABLE_ROW * FindRowByURI(const wxString &aURI)
void Save(const wxString &aFileName) const
Write this library table to aFileName in s-expression form.
Node type: LIB_ID.
Model class in the component selector Model-View-Adapter (mediated MVC) architecture.
void RefreshLibTree()
Refreshes the tree (mainly to update highlighting and asterisking)
Definition: lib_tree.cpp:438
LIB_TREE_NODE * GetCurrentTreeNode() const
Definition: lib_tree.cpp:332
void CenterLibId(const LIB_ID &aLibId)
Ensure that an item is visible (preferably centered).
Definition: lib_tree.cpp:349
int GetSelectionCount() const
Definition: lib_tree.h:91
void ShowChangedLanguage()
Definition: lib_tree.cpp:291
void FocusSearchFieldIfExists()
Focus the search widget if it exists.
Definition: lib_tree.cpp:453
void SelectLibId(const LIB_ID &aLibId)
Select an item in the tree widget.
Definition: lib_tree.cpp:343
LIB_TREE_MODEL_ADAPTER::SORT_MODE GetSortMode() const
Definition: lib_tree.h:141
int GetSelectedLibIds(std::vector< LIB_ID > &aSelection, std::vector< int > *aUnit=nullptr) const
Retrieves a list of selections for trees that allow multi-selection.
Definition: lib_tree.cpp:315
void Unselect()
Unselect currently selected item in wxDataViewCtrl.
Definition: lib_tree.cpp:355
LIB_ID GetSelectedLibId(int *aUnit=nullptr) const
For multi-unit symbols, if the user selects the symbol itself rather than picking an individual unit,...
Definition: lib_tree.cpp:301
void ExpandLibId(const LIB_ID &aLibId)
Expand and item i the tree widget.
Definition: lib_tree.cpp:361
void Regenerate(bool aKeepState)
Regenerate the tree.
Definition: lib_tree.cpp:420
static wxString GetDefaultUserSymbolsPath()
Gets the default path we point users to create projects.
Definition: paths.cpp:87
virtual ENV_VAR_MAP & GetLocalEnvVariables() const
Definition: pgm_base.cpp:923
virtual SETTINGS_MANAGER & GetSettingsManager() const
Definition: pgm_base.h:142
A holder to handle information on schematic or board items.
void ClearListAndDeleteItems(std::function< void(EDA_ITEM *)> aItemDeleter)
Delete the list of pickers AND the data pointed by #m_PickedItem or #m_PickedItemLink according to th...
bool IsCancelled() const override
static SYMBOL_LIB_TABLE * SchSymbolLibTable(PROJECT *aProject)
Accessor for project symbol library table.
@ SCH_LIBEDIT_CUR_LIB
Definition: project.h:184
@ SCH_LIBEDIT_CUR_SYMBOL
Definition: project.h:185
virtual const wxString GetProjectPath() const
Return the full path of the project.
Definition: project.cpp:135
virtual void SetRString(RSTRING_T aStringId, const wxString &aString)
Store a "retained string", which is any session and project specific string identified in enum RSTRIN...
Definition: project.cpp:269
virtual const wxString & GetRString(RSTRING_T aStringId)
Return a "retained string", which is any session and project specific string identified in enum RSTRI...
Definition: project.cpp:280
float SplitterProportion() const
Action handler for the Properties panel.
A shim class between EDA_DRAW_FRAME and several derived classes: SYMBOL_EDIT_FRAME,...
SCH_RENDER_SETTINGS * GetRenderSettings()
void SaveSettings(APP_SETTINGS_BASE *aCfg) override
Save common frame parameters to a configuration data file.
void LoadSettings(APP_SETTINGS_BASE *aCfg) override
Load common frame parameters from a configuration file.
SCH_SCREEN * GetScreen() const override
Return a pointer to a BASE_SCREEN or one of its derivatives.
SCH_DRAW_PANEL * GetCanvas() const override
Return a pointer to GAL-based canvas of given EDA draw frame.
SYMBOL_LIB_TABLE * SelectSymLibTable(bool aOptional=false)
Display a dialog asking the user to select a symbol library table.
void CommonSettingsChanged(bool aEnvVarsChanged, bool aTextVarsChanged) override
Notification event that some of the common (suite-wide) settings have changed.
bool saveSymbolLibTables(bool aGlobal, bool aProject)
Save Symbol Library Tables to disk.
virtual void UpdateItem(EDA_ITEM *aItem, bool isAddOrDelete=false, bool aUpdateRtree=false)
Mark an item for refresh.
void setSymWatcher(const LIB_ID *aSymbol)
Creates (or removes) a watcher on the specified symbol library.
KIGFX::SCH_VIEW * GetView() const override
Return a pointer to the #VIEW instance used in the panel.
void DisplaySymbol(LIB_SYMBOL *aSymbol)
Schematic editor (Eeschema) main window.
void SaveSymbolToSchematic(const LIB_SYMBOL &aSymbol, const KIID &aSchematicSymbolUUID)
Update a schematic symbol from a LIB_SYMBOL.
Instances are attached to a symbol or sheet and provide a place for the symbol's value,...
Definition: sch_field.h:51
VECTOR2I GetPosition() const override
Definition: sch_field.cpp:1407
int GetId() const
Definition: sch_field.h:133
wxString GetName(bool aUseDefaultName=true) const
Return the field name (not translated).
Definition: sch_field.cpp:1149
void SetPosition(const VECTOR2I &aPosition) override
Definition: sch_field.cpp:1387
void SetName(const wxString &aName)
Definition: sch_field.cpp:1128
void SetText(const wxString &aText) override
Definition: sch_field.cpp:1138
static const wxString ShowType(SCH_FILE_T aFileType)
Return a brief name for a plugin, given aFileType enum.
Definition: sch_io_mgr.cpp:83
Base class for any item which can be embedded within the SCHEMATIC container class,...
Definition: sch_item.h:174
int GetBodyStyle() const
Definition: sch_item.h:240
int GetUnit() const
Definition: sch_item.h:237
virtual void ClearCaches()
Definition: sch_item.cpp:370
Schematic symbol object.
Definition: sch_symbol.h:105
VECTOR2I GetPosition() const override
Definition: sch_symbol.h:802
int GetOrientation() const
Get the display symbol orientation.
void GetFields(std::vector< SCH_FIELD * > &aVector, bool aVisibleOnly)
Populate a std::vector with SCH_FIELDs.
Definition: sch_symbol.cpp:960
std::unique_ptr< LIB_SYMBOL > & GetLibSymbolRef()
Definition: sch_symbol.h:213
static bool Idle(const SELECTION &aSelection)
Test if there no items selected or being edited.
static bool ShowAlways(const SELECTION &aSelection)
The default condition function (always returns true).
T * GetAppSettings()
Returns a handle to the a given settings by type If the settings have already been loaded,...
COLOR_SETTINGS * GetColorSettings(const wxString &aName="user")
Retrieves a color settings object that applications can read colors from.
Handle actions for the various symbol editor and viewers.
SYMBOL_EDITOR_DRAWING_TOOLS.
SCH_SELECTION_FILTER_OPTIONS m_SelectionFilter
The symbol library editor main window.
void OnExitKiCad(wxCommandEvent &event)
void LoadSettings(APP_SETTINGS_BASE *aCfg) override
Load common frame parameters from a configuration file.
void UpdateItem(EDA_ITEM *aItem, bool isAddOrDelete=false, bool aUpdateRtree=false) override
Mark an item for refresh.
void setupUIConditions() override
Setup the UI conditions for the various actions and their controls in this frame.
APP_SETTINGS_BASE * config() const override
Returns the settings object used in SaveSettings(), and is overloaded in KICAD_MANAGER_FRAME.
bool addLibTableEntry(const wxString &aLibFile, TABLE_SCOPE aScope=GLOBAL_LIB_TABLE)
Add aLibFile to the symbol library table defined by aScope.
void storeCurrentSymbol()
Rename LIB_SYMBOL aliases to avoid conflicts before adding a symbol to a library.
const BOX2I GetDocumentExtents(bool aIncludeAllVisible=true) const override
Returns bbox of document with option to not include some items.
SELECTION & GetCurrentSelection() override
Get the current selection from the canvas area.
wxString getTargetLib() const
bool IsCurrentSymbol(const LIB_ID &aLibId) const
Restore the empty editor screen, without any symbol or library selected.
bool backupFile(const wxFileName &aOriginalFile, const wxString &aBackupExt)
Return currently edited symbol.
void FocusOnItem(SCH_ITEM *aItem)
void RefreshLibraryTree()
Redisplay the library tree.
void updateSelectionFilterVisbility() override
Selection filter panel doesn't have a dedicated visibility control, so show it if any other AUI panel...
wxComboBox * m_unitSelectBox
int GetTreeLIBIDs(std::vector< LIB_ID > &aSelection) const
LIB_ID GetTreeLIBID(int *aUnit=nullptr) const
Return the LIB_ID of the library or symbol selected in the symbol tree.
LIB_SYMBOL_LIBRARY_MANAGER * m_libMgr
wxString GetCurLib() const
The nickname of the current library being edited and empty string if none.
LIB_ID GetTargetLibId() const
Return either the symbol selected in the symbol tree (if context menu is active) or the symbol on the...
void FocusOnLibId(const LIB_ID &aLibID)
bool IsSymbolAlias() const
Return true if aLibId is an alias for the editor screen symbol.
SYMBOL_EDITOR_SETTINGS * m_settings
int GetBodyStyle() const
void HardRedraw() override
Rebuild the GAL and redraw the screen.
bool GetShowDeMorgan() const
bool IsSymbolTreeShown() const
bool m_SyncPinEdit
Set to true to synchronize pins at the same position when editing symbols with multiple units or mult...
int GetTreeSelectionCount() const
void SaveSettings(APP_SETTINGS_BASE *aCfg) override
Save common frame parameters to a configuration data file.
bool CanCloseSymbolFromSchematic(bool doClose)
bool IsSymbolFromLegacyLibrary() const
bool replaceLibTableEntry(const wxString &aLibNickname, const wxString &aLibFile)
Replace the file path of the symbol library table entry aLibNickname with aLibFile.
bool IsSymbolFromSchematic() const
void OnToggleSymbolTree(wxCommandEvent &event)
static bool m_showDeMorgan
void SetScreen(BASE_SCREEN *aScreen) override
SYMBOL_EDITOR_SETTINGS * GetSettings() const
SCH_SCREEN * m_dummyScreen
< Helper screen used when no symbol is loaded
void KiwayMailIn(KIWAY_EXPRESS &mail) override
Receive KIWAY_EXPRESS messages from other players.
void SetCurSymbol(LIB_SYMBOL *aSymbol, bool aUpdateZoom)
Take ownership of aSymbol and notes that it is the one currently being edited.
KIID m_schematicSymbolUUID
RefDes of the symbol (only valid if symbol was loaded from schematic)
bool IsSymbolEditable() const
Test if a symbol is loaded and can be edited.
std::vector< LIB_ID > GetSelectedLibIds() const
LIB_TREE_NODE * GetCurrentTreeNode() const
void SyncLibraries(bool aShowProgress, bool aPreloadCancelled=false, const wxString &aForceRefresh=wxEmptyString)
Synchronize the library manager to the symbol library table, and then the symbol tree to the library ...
void RegenerateLibraryTree()
Filter, sort, and redisplay the library tree.
void OnSelectUnit(wxCommandEvent &event)
LIB_SYMBOL * GetCurSymbol() const
Return the current symbol being edited or NULL if none selected.
void UpdateSymbolMsgPanelInfo()
Display the documentation of the selected symbol.
bool canCloseWindow(wxCloseEvent &aCloseEvent) override
int m_bodyStyle
Flag if the symbol being edited was loaded directly from a schematic.
bool saveAllLibraries(bool aRequireConfirmation)
Save the current symbol.
void UpdateMsgPanel() override
Redraw the message panel.
void ClearUndoORRedoList(UNDO_REDO_LIST whichList, int aItemCount=-1) override
Free the undo or redo list from aList element.
wxString SetCurLib(const wxString &aLibNickname)
Set the current library nickname and returns the old library nickname.
void UpdateTitle()
Update the main window title bar with the current library name and read only status of the library.
void ReCreateHToolbar() override
void CommonSettingsChanged(bool aEnvVarsChanged, bool aTextVarsChanged) override
Called after the preferences dialog is run.
bool HasLibModifications() const
Check if any pending libraries have been modified.
SYMBOL_TREE_PANE * m_treePane
void LoadSymbolFromSchematic(SCH_SYMBOL *aSymbol)
Load a symbol from the schematic to edit in place.
bool LoadSymbolFromCurrentLib(const wxString &aAliasName, int aUnit=0, int aBodyStyle=0)
Load a symbol from the current active library, optionally setting the selected unit and convert.
COLOR_SETTINGS * GetColorSettings(bool aForceRefresh=false) const override
Returns a pointer to the active color theme settings.
LIB_SYMBOL_LIBRARY_MANAGER & GetLibManager()
void SwitchCanvas(EDA_DRAW_PANEL_GAL::GAL_TYPE aCanvasType) override
Switch currently used canvas ( Cairo / OpenGL).
void doCloseWindow() override
void DdAddLibrary(wxString aLibFile)
Add a library dropped file to the symbol library table.
wxString AddLibraryFile(bool aCreateNew)
Create or add an existing library to the symbol library table.
void CloseWindow(wxCommandEvent &event)
Trigger the wxCloseEvent, which is handled by the function given to EVT_CLOSE() macro:
void UpdateLibraryTree(const wxDataViewItem &aTreeItem, LIB_SYMBOL *aSymbol)
Update a symbol node in the library tree.
void OnModify() override
Must be called after a schematic change in order to set the "modify" flag of the current symbol.
void SetShowDeMorgan(bool show)
void ShowChangedLanguage() override
bool IsContentModified() const override
Get if any symbols or libraries have been modified but not saved.
LIB_SYMBOL * getTargetSymbol() const
Return either the library selected in the symbol tree, if context menu is active or the library that ...
void OnUpdateUnitNumber(wxUpdateUIEvent &event)
LIB_SYMBOL * GetBufferedSymbol(const wxString &aAlias, const wxString &aLibrary)
Return the symbol copy from the buffer.
bool IsLibraryReadOnly(const wxString &aLibrary) const
Return true if the library is stored in a read-only file.
bool LibraryExists(const wxString &aLibrary, bool aCheckEnabled=false) const
Return true if library exists.
LIB_SYMBOL * GetAlias(const wxString &aAlias, const wxString &aLibrary) const
Return either an alias of a working LIB_SYMBOL copy, or alias of the original symbol if there is no w...
SCH_SCREEN * GetScreen(const wxString &aAlias, const wxString &aLibrary)
Return the screen used to edit a specific symbol.
bool IsLibraryModified(const wxString &aLibrary) const
Return true if library has unsaved modifications.
wxArrayString GetLibraryNames() const
Return the array of library names.
wxString GetUniqueLibraryName() const
Return a library name that is not currently in use.
bool AddLibrary(const wxString &aFilePath, SYMBOL_LIB_TABLE *aTable)
Add an existing library.
bool CreateLibrary(const wxString &aFilePath, SYMBOL_LIB_TABLE *aTable)
Create an empty library and adds it to the library table.
bool IsSymbolModified(const wxString &aAlias, const wxString &aLibrary) const
Return true if symbol has unsaved modifications.
SYMBOL_LIB_TABLE_ROW * GetLibrary(const wxString &aLibrary) const
Find a single library within the (aggregate) library table.
bool UpdateSymbol(LIB_SYMBOL *aSymbol, const wxString &aLibrary)
Update the symbol buffer with a new version of the symbol.
bool UpdateLibraryBuffer(const wxString &aLibrary)
Update the library buffer with a new version of the library.
Hold a record identifying a symbol library accessed by the appropriate symbol library SCH_IO object i...
void SetType(const wxString &aType) override
Change the schematic plugin type represented by this row.
const wxString GetType() const override
Return the type of symbol library table represented by this row.
static SYMBOL_LIB_TABLE & GetGlobalLibTable()
static const wxString & GetSymbolLibTableFileName()
static wxString GetGlobalTableFileName()
Fetch the global symbol library table file name.
SYMBOL_LIB_TABLE_ROW * FindRow(const wxString &aNickName, bool aCheckIfEnabled=false)
Return an SYMBOL_LIB_TABLE_ROW if aNickName is found in this table or in any chained fallBack table f...
Library Editor pane with symbol tree and symbol library table selector.
LIB_TREE * GetLibTree() const
TOOL_MANAGER * m_toolManager
Definition: tools_holder.h:167
TOOL_DISPATCHER * m_toolDispatcher
Definition: tools_holder.h:169
TOOL_MANAGER * GetToolManager() const
Return the MVC controller.
Definition: tools_holder.h:55
ACTIONS * m_actions
Definition: tools_holder.h:168
@ MODEL_RELOAD
Model changes (the sheet for a schematic)
Definition: tool_base.h:80
virtual void DispatchWxEvent(wxEvent &aEvent)
Process wxEvents (mostly UI events), translate them to TOOL_EVENTs, and make tools handle those.
Master controller class:
Definition: tool_manager.h:62
bool RunAction(const std::string &aActionName, T aParam)
Run the specified action immediately, pausing the current action to run the new one.
Definition: tool_manager.h:150
bool InvokeTool(TOOL_ID aToolId)
Call a tool by sending a tool activation event to tool of given ID.
ACTION_MANAGER * GetActionManager() const
Definition: tool_manager.h:302
void ResetTools(TOOL_BASE::RESET_REASON aReason)
Reset all tools (i.e.
void RegisterTool(TOOL_BASE *aTool)
Add a tool to the manager set and sets it up.
void SetEnvironment(EDA_ITEM *aModel, KIGFX::VIEW *aView, KIGFX::VIEW_CONTROLS *aViewControls, APP_SETTINGS_BASE *aSettings, TOOLS_HOLDER *aFrame)
Set the work environment (model, view, view controls and the parent window).
void InitTools()
Initializes all registered tools.
void ShutdownAllTools()
Shutdown all tools with a currently registered event loop in this tool manager by waking them up with...
A holder to handle a list of undo (or redo) commands.
std::vector< PICKED_ITEMS_LIST * > m_CommandsList
bool empty() const
Definition: utf8.h:104
A modified version of the wxInfoBar class that allows us to:
Definition: wx_infobar.h:75
void RemoveAllButtons()
Remove all the buttons that have been added by the user.
Definition: wx_infobar.cpp:301
void AddButton(wxButton *aButton)
Add an already created button to the infobar.
Definition: wx_infobar.cpp:260
void Dismiss() override
Dismisses the infobar and updates the containing layout and AUI manager (if one is provided).
Definition: wx_infobar.cpp:187
void ShowMessage(const wxString &aMessage, int aFlags=wxICON_INFORMATION) override
Show the info bar with the provided message and icon.
Definition: wx_infobar.cpp:154
Multi-thread safe progress reporter dialog, intended for use of tasks that parallel reporting back of...
void DisplayError(wxWindow *aParent, const wxString &aText, int aDisplayTime)
Display an error or warning message box with aMessage.
Definition: confirm.cpp:170
void DisplayErrorMessage(wxWindow *aParent, const wxString &aText, const wxString &aExtraInfo)
Display an error message with aMessage.
Definition: confirm.cpp:195
int UnsavedChangesDialog(wxWindow *parent, const wxString &aMessage, bool *aApplyToAll)
A specialized version of HandleUnsavedChanges which handles an apply-to-all checkbox.
Definition: confirm.cpp:66
This file is part of the common library.
#define CHECK(x)
#define ENABLE(x)
#define _HKI(x)
static bool empty(const wxTextEntryBase *aCtrl)
#define _(s)
#define KICAD_DEFAULT_DRAWFRAME_STYLE
#define LIB_EDIT_FRAME_NAME
@ ID_LIBEDIT_SELECT_UNIT_NUMBER
Definition: eeschema_id.h:60
const wxAuiPaneInfo & defaultSchSelectionFilterPaneInfo(wxWindow *aWindow)
const wxAuiPaneInfo & defaultPropertiesPaneInfo(wxWindow *aWindow)
wxString NormalizePath(const wxFileName &aFilePath, const ENV_VAR_MAP *aEnvVars, const wxString &aProjectPath)
Normalize a file path to an environmental variable, if possible.
Definition: env_paths.cpp:71
GERBVIEW_FRAME::OnZipFileHistory GERBVIEW_FRAME::OnSelectHighlightChoice EVT_UPDATE_UI(ID_TOOLBARH_GERBVIEW_SELECT_ACTIVE_LAYER, GERBVIEW_FRAME::OnUpdateLayerSelectBox) void GERBVIEW_FRAME
@ FRAME_SCH_SYMBOL_EDITOR
Definition: frame_type.h:35
@ FRAME_SCH
Definition: frame_type.h:34
static const std::string KiCadSymbolLibFileExtension
static wxString KiCadSymbolLibFileWildcard()
std::map< wxString, ENV_VAR_ITEM > ENV_VAR_MAP
PROJECT & Prj()
Definition: kicad.cpp:595
KIID niluuid(0)
@ LAYER_SCHEMATIC_GRID_AXES
Definition: layer_ids.h:389
@ MAIL_LIB_EDIT
Definition: mail_type.h:54
@ MAIL_REFRESH_SYMBOL
Definition: mail_type.h:58
@ MAIL_RELOAD_LIB
Definition: mail_type.h:56
@ ALL
All except INITIAL_ADD.
Definition: view_item.h:58
void SetShutdownBlockReason(wxWindow *aWindow, const wxString &aReason)
Sets the block reason why the window/application is preventing OS shutdown.
Definition: gtk/app.cpp:90
bool SupportsShutdownBlockReason()
Whether or not the window supports setting a shutdown block reason.
Definition: gtk/app.cpp:79
bool contains(const _Container &__container, _Value __value)
Returns true if the container contains the given value.
Definition: kicad_algo.h:100
void InvokeSchEditSymbolLibTable(KIWAY *aKiway, wxWindow *aParent)
void Refresh()
Update the board display after modifying it by a python script (note: it is automatically called by a...
PGM_BASE & Pgm()
The global Program "get" accessor.
Definition: pgm_base.cpp:1059
see class PGM_BASE
@ SYM_ORIENT_270
Definition: sch_symbol.h:84
@ SYM_MIRROR_Y
Definition: sch_symbol.h:86
@ SYM_ORIENT_180
Definition: sch_symbol.h:83
@ SYM_MIRROR_X
Definition: sch_symbol.h:85
@ SYM_ORIENT_90
Definition: sch_symbol.h:82
KIWAY Kiway(KFCTL_STANDALONE)
wxString UnescapeString(const wxString &aSource)
Functors that can be used to figure out how the action controls should be displayed in the UI and if ...
ACTION_CONDITIONS & Enable(const SELECTION_CONDITION &aCondition)
ACTION_CONDITIONS & Check(const SELECTION_CONDITION &aCondition)
constexpr int mmToIU(double mm) const
Definition: base_units.h:88
#define EDIT_TOOL(tool)
Definition for symbol library class.
@ MANDATORY_FIELDS
The first 5 are mandatory, and must be instantiated in SCH_COMPONENT and LIB_PART constructors.
@ REFERENCE_FIELD
Field Reference of part, i.e. "IC21".
VECTOR2< double > VECTOR2D
Definition: vector2d.h:601
VECTOR2< int > VECTOR2I
Definition: vector2d.h:602
Definition of file extensions used in Kicad.
void SetAuiPaneSize(wxAuiManager &aManager, wxAuiPaneInfo &aPane, int aWidth, int aHeight)
Sets the size of an AUI pane, working around http://trac.wxwidgets.org/ticket/13180.