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 <kidialog.h>
37#include <kiface_base.h>
38#include <kiplatform/app.h>
39#include <kiway_express.h>
40#include <symbol_edit_frame.h>
43#include <paths.h>
44#include <pgm_base.h>
45#include <project_sch.h>
46#include <sch_painter.h>
47#include <sch_view.h>
49#include <symbol_lib_table.h>
50#include <tool/action_manager.h>
51#include <tool/action_toolbar.h>
52#include <tool/common_control.h>
53#include <tool/common_tools.h>
55#include <tool/embed_tool.h>
57#include <tool/picker_tool.h>
59#include <tool/selection.h>
61#include <tool/tool_manager.h>
62#include <tool/zoom_tool.h>
63#include <tools/ee_actions.h>
73#include <view/view_controls.h>
75#include <widgets/wx_infobar.h>
82#include <panel_sym_lib_table.h>
83#include <string_utils.h>
84#include <wx/msgdlg.h>
85#include <wx/log.h>
86
87
89
90
91BEGIN_EVENT_TABLE( SYMBOL_EDIT_FRAME, SCH_BASE_FRAME )
93
94 // menubar commands
95 EVT_MENU( wxID_EXIT, SYMBOL_EDIT_FRAME::OnExitKiCad )
96 EVT_MENU( wxID_CLOSE, SYMBOL_EDIT_FRAME::CloseWindow )
97
98 // Update user interface elements.
100
101 // Drop files event
102 EVT_DROP_FILES( SYMBOL_EDIT_FRAME::OnDropFiles )
103
104END_EVENT_TABLE()
105
106
107SYMBOL_EDIT_FRAME::SYMBOL_EDIT_FRAME( KIWAY* aKiway, wxWindow* aParent ) :
108 SCH_BASE_FRAME( aKiway, aParent, FRAME_SCH_SYMBOL_EDITOR, _( "Library Editor" ),
109 wxDefaultPosition, wxDefaultSize, KICAD_DEFAULT_DRAWFRAME_STYLE,
111 m_unitSelectBox( nullptr ),
112 m_isSymbolFromSchematic( false )
113{
114 SetShowDeMorgan( false );
115 m_SyncPinEdit = false;
116
117 m_symbol = nullptr;
118 m_treePane = nullptr;
119 m_libMgr = nullptr;
120 m_unit = 1;
121 m_bodyStyle = 1;
122 m_aboutTitle = _HKI( "KiCad Symbol Editor" );
123
124 wxIcon icon;
125 wxIconBundle icon_bundle;
126
127 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_libedit, 48 ) );
128 icon_bundle.AddIcon( icon );
129 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_libedit, 256 ) );
130 icon_bundle.AddIcon( icon );
131 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_libedit, 128 ) );
132 icon_bundle.AddIcon( icon );
133 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_libedit_32 ) );
134 icon_bundle.AddIcon( icon );
135 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_libedit_16 ) );
136 icon_bundle.AddIcon( icon );
137
138 SetIcons( icon_bundle );
139
141 LoadSettings( m_settings );
142
143 m_libMgr = new LIB_SYMBOL_LIBRARY_MANAGER( *this );
144 bool loadingCancelled = false;
145
146 {
147 // Preload libraries before using SyncLibraries the first time, as the preload is
148 // multi-threaded
149 WX_PROGRESS_REPORTER reporter( this, _( "Loading Symbol Libraries" ),
150 m_libMgr->GetLibraryCount(), true );
151 m_libMgr->Preload( reporter );
152
153 loadingCancelled = reporter.IsCancelled();
154 wxSafeYield();
155 }
156
157 SyncLibraries( false, loadingCancelled );
158 m_treePane = new SYMBOL_TREE_PANE( this, m_libMgr );
159 m_treePane->GetLibTree()->SetSortMode( (LIB_TREE_MODEL_ADAPTER::SORT_MODE) m_settings->m_LibrarySortMode );
160
161 resolveCanvasType();
162 SwitchCanvas( m_canvasType );
163
164 // Ensure axis are always drawn
165 KIGFX::GAL_DISPLAY_OPTIONS& gal_opts = GetGalDisplayOptions();
166 gal_opts.m_axesEnabled = true;
167
168 m_dummyScreen = new SCH_SCREEN();
169 SetScreen( m_dummyScreen );
170 GetScreen()->m_Center = true;
171
172 GetCanvas()->GetViewControls()->SetCrossHairCursorPosition( VECTOR2D( 0, 0 ), false );
173
174 GetRenderSettings()->LoadColors( GetColorSettings() );
175 GetRenderSettings()->m_IsSymbolEditor = true;
176 GetCanvas()->GetGAL()->SetAxesColor( m_colorSettings->GetColor( LAYER_SCHEMATIC_GRID_AXES ) );
177
178 setupTools();
179 setupUIConditions();
180
181 ReCreateMenuBar();
182 ReCreateHToolbar();
183 ReCreateVToolbar();
184 ReCreateOptToolbar();
185
186 UpdateTitle();
187 UpdateSymbolMsgPanelInfo();
188 RebuildSymbolUnitsList();
189
190 m_propertiesPanel = new SCH_PROPERTIES_PANEL( this, this );
191 m_propertiesPanel->SetSplitterProportion( m_settings->m_AuiPanels.properties_splitter );
192
193 m_selectionFilterPanel = new PANEL_SCH_SELECTION_FILTER( this );
194
195 m_auimgr.SetManagedWindow( this );
196
197 CreateInfoBar();
198
199 // Rows; layers 4 - 6
200 m_auimgr.AddPane( m_mainToolBar, EDA_PANE().HToolbar().Name( "MainToolbar" )
201 .Top().Layer( 6 ) );
202
203 m_auimgr.AddPane( m_messagePanel, EDA_PANE().Messages().Name( "MsgPanel" )
204 .Bottom().Layer( 6 ) );
205
206 // Columns; layers 1 - 3
207 m_auimgr.AddPane( m_treePane, EDA_PANE().Palette().Name( "LibraryTree" )
208 .Left().Layer( 3 )
209 .TopDockable( false ).BottomDockable( false )
210 .Caption( _( "Libraries" ) )
211 .MinSize( FromDIP( 250 ), -1 ).BestSize( FromDIP( 250 ), -1 ) );
212
213 m_auimgr.AddPane( m_propertiesPanel, defaultPropertiesPaneInfo( this ) );
214 // Show or hide m_propertiesPanel depending on current settings:
215 wxAuiPaneInfo& propertiesPaneInfo = m_auimgr.GetPane( PropertiesPaneName() );
216
217 m_auimgr.AddPane( m_selectionFilterPanel, defaultSchSelectionFilterPaneInfo( this ) );
218
219 wxAuiPaneInfo& selectionFilterPane = m_auimgr.GetPane( wxS( "SelectionFilter" ) );
220 // The selection filter doesn't need to grow in the vertical direction when docked
221 selectionFilterPane.dock_proportion = 0;
222
223 propertiesPaneInfo.Show( m_settings->m_AuiPanels.show_properties );
224 updateSelectionFilterVisbility();
225
226 m_auimgr.AddPane( m_optionsToolBar, EDA_PANE().VToolbar().Name( "OptToolbar" )
227 .Left().Layer( 2 ) );
228
229 m_auimgr.AddPane( m_drawToolBar, EDA_PANE().VToolbar().Name( "ToolsToolbar" )
230 .Right().Layer( 2 ) );
231
232 // Center
233 m_auimgr.AddPane( GetCanvas(), wxAuiPaneInfo().Name( "DrawFrame" )
234 .CentrePane() );
235
236 FinishAUIInitialization();
237
238 // Can't put this in LoadSettings, because it has to be called before setupTools :/
239 EE_SELECTION_TOOL* selTool = GetToolManager()->GetTool<EE_SELECTION_TOOL>();
240 selTool->GetFilter() = GetSettings()->m_SelectionFilter;
241
242 if( m_settings->m_LibWidth > 0 )
243 SetAuiPaneSize( m_auimgr, m_auimgr.GetPane( "LibraryTree" ), m_settings->m_LibWidth, -1 );
244
245 Raise();
246 Show( true );
247
248 SyncView();
249 GetCanvas()->GetView()->UseDrawPriority( true );
250 GetCanvas()->GetGAL()->SetAxesEnabled( true );
251
252 setupUnits( m_settings );
253
254 // Set the working/draw area size to display a symbol to a reasonable value:
255 // A 600mm x 600mm with a origin at the area center looks like a large working area
256 double max_size_x = schIUScale.mmToIU( 600 );
257 double max_size_y = schIUScale.mmToIU( 600 );
258 BOX2D bbox;
259 bbox.SetOrigin( -max_size_x /2, -max_size_y/2 );
260 bbox.SetSize( max_size_x, max_size_y );
261 GetCanvas()->GetView()->SetBoundary( bbox );
262
263 m_toolManager->RunAction( ACTIONS::zoomFitScreen );
264
266 DragAcceptFiles( true );
267
268 KIPLATFORM::APP::SetShutdownBlockReason( this, _( "Library changes are unsaved" ) );
269
270 // Catch unhandled accelerator command characters that were no handled by the library tree
271 // panel.
272 Bind( wxEVT_CHAR, &TOOL_DISPATCHER::DispatchWxEvent, m_toolDispatcher );
273 Bind( wxEVT_CHAR_HOOK, &TOOL_DISPATCHER::DispatchWxEvent, m_toolDispatcher );
274
275 // Ensure the window is on top
276 Raise();
277
278 if( loadingCancelled )
279 ShowInfoBarWarning( _( "Symbol library loading was cancelled by user." ) );
280}
281
282
284{
285 // Shutdown all running tools
286 if( m_toolManager )
288
289 setSymWatcher( nullptr );
290
292 {
293 delete m_symbol;
294 m_symbol = nullptr;
295
296 SCH_SCREEN* screen = GetScreen();
297 delete screen;
299 }
300
301 // current screen is destroyed in EDA_DRAW_FRAME
303
304 SYMBOL_EDITOR_SETTINGS* cfg = nullptr;
305
306 try
307 {
309 }
310 catch( const std::runtime_error& e )
311 {
312 wxFAIL_MSG( e.what() );
313 }
314
315 if( cfg )
316 Pgm().GetSettingsManager().Save( cfg );
317
318 delete m_libMgr;
319}
320
321
323{
324 wxCHECK_RET( m_settings, "Call to SYMBOL_EDIT_FRAME::LoadSettings with null m_boardAdapter" );
325
327
332 GetRenderSettings()->SetDefaultFont( wxEmptyString );
333}
334
335
337{
338 wxCHECK_RET( m_settings, "Call to SYMBOL_EDIT_FRAME::LoadSettings with null m_boardAdapter" );
339
341
343
348
349 m_settings->m_LibWidth = m_treePane->GetSize().x;
350
352
354 bool prop_shown = m_auimgr.GetPane( PropertiesPaneName() ).IsShown();
356
359}
360
361
363{
364 return static_cast<APP_SETTINGS_BASE*>( GetSettings() );
365}
366
367
369{
371
372 if( GetSettings()->m_UseEeschemaColorSettings )
374 else
375 return mgr.GetColorSettings( GetSettings()->m_ColorTheme );
376}
377
378
380{
381 // Create the manager and dispatcher & route draw panel events to the dispatcher
384 GetCanvas()->GetViewControls(), GetSettings(), this );
385 m_actions = new EE_ACTIONS();
387
388 // Register tools
405
406 // Run the selection tool, it is supposed to be always active
407 m_toolManager->InvokeTool( "eeschema.InteractiveSelection" );
408
410}
411
412
414{
416
418 EDITOR_CONDITIONS cond( this );
419
420 wxASSERT( mgr );
421
422#define ENABLE( x ) ACTION_CONDITIONS().Enable( x )
423#define CHECK( x ) ACTION_CONDITIONS().Check( x )
424
425 auto haveSymbolCond =
426 [this]( const SELECTION& )
427 {
428 return m_symbol;
429 };
430
431 auto isEditableCond =
432 [this]( const SELECTION& )
433 {
434 // Only root symbols from the new s-expression libraries or the schematic
435 // are editable.
436 return IsSymbolEditable() && !IsSymbolAlias();
437 };
438
439 auto isEditableInAliasCond =
440 [this]( const SELECTION& )
441 {
442 // Less restrictive than isEditableCond
443 // Symbols fields (root symbols and aliases) from the new s-expression libraries
444 // or in the schematic are editable.
445 return IsSymbolEditable();
446 };
447
448 auto symbolModifiedCondition =
449 [this]( const SELECTION& sel )
450 {
453 };
454
455 auto libSelectedCondition =
456 [this]( const SELECTION& sel )
457 {
458 return !GetTargetLibId().GetLibNickname().empty();
459 };
460
461 auto canEditProperties =
462 [this]( const SELECTION& sel )
463 {
465 };
466
467 auto saveSymbolAsCondition =
468 [this]( const SELECTION& aSel )
469 {
470 return getTargetSymbol() != nullptr;
471 };
472
475 mgr->SetConditions( EE_ACTIONS::saveLibraryAs, ENABLE( libSelectedCondition ) );
476 mgr->SetConditions( EE_ACTIONS::saveSymbolAs, ENABLE( saveSymbolAsCondition ) );
477 mgr->SetConditions( EE_ACTIONS::saveSymbolCopyAs, ENABLE( saveSymbolAsCondition ) );
480
481 mgr->SetConditions( ACTIONS::undo, ENABLE( haveSymbolCond && cond.UndoAvailable() ) );
482 mgr->SetConditions( ACTIONS::redo, ENABLE( haveSymbolCond && cond.RedoAvailable() ) );
483 mgr->SetConditions( ACTIONS::revert, ENABLE( symbolModifiedCondition ) );
484
488 mgr->SetConditions( ACTIONS::millimetersUnits, CHECK( cond.Units( EDA_UNITS::MILLIMETRES ) ) );
489 mgr->SetConditions( ACTIONS::inchesUnits, CHECK( cond.Units( EDA_UNITS::INCHES ) ) );
490 mgr->SetConditions( ACTIONS::milsUnits, CHECK( cond.Units( EDA_UNITS::MILS ) ) );
491
492 mgr->SetConditions( ACTIONS::cut, ENABLE( isEditableCond ) );
493 mgr->SetConditions( ACTIONS::copy, ENABLE( haveSymbolCond ) );
494 mgr->SetConditions( ACTIONS::copyAsText, ENABLE( haveSymbolCond ) );
495 mgr->SetConditions( ACTIONS::paste, ENABLE( isEditableCond &&
497 mgr->SetConditions( ACTIONS::doDelete, ENABLE( isEditableCond ) );
498 mgr->SetConditions( ACTIONS::duplicate, ENABLE( isEditableCond ) );
499 mgr->SetConditions( ACTIONS::selectAll, ENABLE( haveSymbolCond ) );
500 mgr->SetConditions( ACTIONS::unselectAll, ENABLE( haveSymbolCond ) );
501
502 // These actions in symbol editor when editing alias field rotations are allowed.
503 mgr->SetConditions( EE_ACTIONS::rotateCW, ENABLE( isEditableInAliasCond ) );
504 mgr->SetConditions( EE_ACTIONS::rotateCCW, ENABLE( isEditableInAliasCond ) );
505
506 mgr->SetConditions( EE_ACTIONS::mirrorH, ENABLE( isEditableCond ) );
507 mgr->SetConditions( EE_ACTIONS::mirrorV, ENABLE( isEditableCond ) );
508
511
512 auto pinTypeCond =
513 [this]( const SELECTION& )
514 {
516 };
517
518 auto hiddenPinCond =
519 [this]( const SELECTION& )
520 {
522 };
523
524 auto hiddenFieldCond =
525 [this]( const SELECTION& )
526 {
528 };
529
530 auto showPinAltIconsCond =
531 [this]( const SELECTION& )
532 {
534 };
535
536 auto showLibraryTreeCond =
537 [this]( const SELECTION& )
538 {
539 return IsLibraryTreeShown();
540 };
541
542 auto propertiesCond =
543 [this] ( const SELECTION& )
544 {
545 return m_auimgr.GetPane( PropertiesPaneName() ).IsShown();
546 };
547
550 mgr->SetConditions( EE_ACTIONS::showDesignBlockPanel, CHECK( showLibraryTreeCond ) );
551 mgr->SetConditions( ACTIONS::showProperties, CHECK( propertiesCond ) );
552 mgr->SetConditions( EE_ACTIONS::showHiddenPins, CHECK( hiddenPinCond ) );
553 mgr->SetConditions( EE_ACTIONS::showHiddenFields, CHECK( hiddenFieldCond ) );
554 mgr->SetConditions( EE_ACTIONS::togglePinAltIcons, CHECK( showPinAltIconsCond ) );
555
556 auto demorganCond =
557 [this]( const SELECTION& )
558 {
559 return GetShowDeMorgan();
560 };
561
562 auto demorganStandardCond =
563 [this]( const SELECTION& )
564 {
565 return m_bodyStyle == BODY_STYLE::BASE;
566 };
567
568 auto demorganAlternateCond =
569 [this]( const SELECTION& )
570 {
571 return m_bodyStyle == BODY_STYLE::DEMORGAN;
572 };
573
574 auto multiUnitModeCond =
575 [this]( const SELECTION& )
576 {
577 return m_symbol && m_symbol->IsMulti() && !m_symbol->UnitsLocked();
578 };
579
580 auto hasMultipleUnitsCond =
581 [this]( const SELECTION& )
582 {
583 return m_symbol && m_symbol->IsMulti();
584 };
585
586 auto syncedPinsModeCond =
587 [this]( const SELECTION& )
588 {
589 return m_SyncPinEdit;
590 };
591
592 auto haveDatasheetCond =
593 [this]( const SELECTION& )
594 {
595 return m_symbol && !m_symbol->GetDatasheetField().GetText().IsEmpty();
596 };
597
598 mgr->SetConditions( ACTIONS::showDatasheet, ENABLE( haveDatasheetCond ) );
599 mgr->SetConditions( EE_ACTIONS::symbolProperties, ENABLE( canEditProperties && haveSymbolCond ) );
600 mgr->SetConditions( EE_ACTIONS::runERC, ENABLE( haveSymbolCond ) );
601 mgr->SetConditions( EE_ACTIONS::pinTable, ENABLE( isEditableCond && haveSymbolCond ) );
602
604 ACTION_CONDITIONS().Enable( demorganCond ).Check( demorganStandardCond ) );
606 ACTION_CONDITIONS().Enable( demorganCond ).Check( demorganAlternateCond ) );
608 ACTION_CONDITIONS().Enable( multiUnitModeCond ).Check( syncedPinsModeCond ) );
610 ACTION_CONDITIONS().Enable( isEditableCond && hasMultipleUnitsCond ) );
611
612// Only enable a tool if the symbol is edtable
613#define EDIT_TOOL( tool ) ACTION_CONDITIONS().Enable( isEditableCond ).Check( cond.CurrentTool( tool ) )
614
627
628#undef CHECK
629#undef ENABLE
630#undef EDIT_TOOL
631}
632
633
635{
636 if( IsContentModified() )
637 {
638 SCH_EDIT_FRAME* schframe = (SCH_EDIT_FRAME*) Kiway().Player( FRAME_SCH, false );
639 wxString msg = _( "Save changes to '%s' before closing?" );
640
641 switch( UnsavedChangesDialog( this, wxString::Format( msg, m_reference ), nullptr ) )
642 {
643 case wxID_YES:
644 if( schframe && GetCurSymbol() ) // Should be always the case
646
647 break;
648
649 case wxID_NO:
650 break;
651
652 default:
653 case wxID_CANCEL:
654 return false;
655 }
656 }
657
658 if( doClose )
659 {
660 SetCurSymbol( nullptr, false );
661 UpdateTitle();
662 }
663
664 return true;
665}
666
667
668bool SYMBOL_EDIT_FRAME::canCloseWindow( wxCloseEvent& aEvent )
669{
670 // Shutdown blocks must be determined and vetoed as early as possible
672 && aEvent.GetId() == wxEVT_QUERY_END_SESSION
673 && IsContentModified() )
674 {
675 return false;
676 }
677
679 return false;
680
681 if( !saveAllLibraries( true ) )
682 return false;
683
684 // Save symbol tree column widths
685 m_libMgr->GetAdapter()->SaveSettings();
686
687 return true;
688}
689
690
692{
693 Destroy();
694}
695
696
698{
699 if( !m_unitSelectBox )
700 return;
701
702 if( m_unitSelectBox->GetCount() != 0 )
703 m_unitSelectBox->Clear();
704
705 if( !m_symbol || m_symbol->GetUnitCount() <= 1 )
706 {
707 m_unit = 1;
708 m_unitSelectBox->Append( wxEmptyString );
709 }
710 else
711 {
712 for( int i = 0; i < m_symbol->GetUnitCount(); i++ )
713 {
714 wxString unitDisplayName = m_symbol->GetUnitDisplayName( i + 1 );
715 m_unitSelectBox->Append( unitDisplayName );
716 }
717 }
718
719 // Ensure the selected unit is compatible with the number of units of the current symbol:
721 m_unit = 1;
722
723 m_unitSelectBox->SetSelection(( m_unit > 0 ) ? m_unit - 1 : 0 );
724}
725
726
728{
729 wxAuiPaneInfo& treePane = m_auimgr.GetPane( m_treePane );
730 treePane.Show( !IsLibraryTreeShown() );
732 m_auimgr.Update();
733 Refresh();
734}
735
736
738{
739 return const_cast<wxAuiManager&>( m_auimgr ).GetPane( m_treePane ).IsShown();
740}
741
742
744{
746}
747
748
750{
751 m_treePane->Freeze();
752 m_libMgr->GetAdapter()->Freeze();
753}
754
755
757{
758 m_libMgr->GetAdapter()->Thaw();
759 m_treePane->Thaw();
760}
761
762
763void SYMBOL_EDIT_FRAME::OnExitKiCad( wxCommandEvent& event )
764{
765 Kiway().OnKiCadExit();
766}
767
768
769void SYMBOL_EDIT_FRAME::OnUpdateUnitNumber( wxUpdateUIEvent& event )
770{
771 event.Enable( m_symbol && m_symbol->GetUnitCount() > 1 );
772}
773
774
775void SYMBOL_EDIT_FRAME::OnSelectUnit( wxCommandEvent& event )
776{
777 int i = event.GetSelection();
778
779 if( i == wxNOT_FOUND )
780 return;
781
782 SetUnit( i + 1 );
783}
784
785
787{
788 if( m_symbol )
789 {
791
792 if( row && row->GetType() == SCH_IO_MGR::ShowType( SCH_IO_MGR::SCH_LEGACY ) )
793 return true;
794 }
795
796 return false;
797}
798
799
801{
802 wxString libNickname = Prj().GetRString( PROJECT::SCH_LIBEDIT_CUR_LIB );
803
804 if( !libNickname.empty() )
805 {
806 if( !PROJECT_SCH::SchSymbolLibTable( &Prj() )->HasLibrary( libNickname ) )
807 {
808 Prj().SetRString( PROJECT::SCH_LIBEDIT_CUR_LIB, wxEmptyString );
809 libNickname = wxEmptyString;
810 }
811 }
812
813 return libNickname;
814}
815
816
817wxString SYMBOL_EDIT_FRAME::SetCurLib( const wxString& aLibNickname )
818{
819 wxString old = GetCurLib();
820
821 if( aLibNickname.empty() || !PROJECT_SCH::SchSymbolLibTable( &Prj() )->HasLibrary( aLibNickname ) )
822 Prj().SetRString( PROJECT::SCH_LIBEDIT_CUR_LIB, wxEmptyString );
823 else
825
826 return old;
827}
828
829
830void SYMBOL_EDIT_FRAME::SetCurSymbol( LIB_SYMBOL* aSymbol, bool aUpdateZoom )
831{
832 wxCHECK( m_toolManager, /* void */ );
833
835 GetCanvas()->GetView()->Clear();
836 delete m_symbol;
837
838 m_symbol = aSymbol;
839
840 // select the current symbol in the tree widget
843 else
844 GetLibTree()->Unselect();
845
846 wxString symbolName;
847 wxString libName;
848
849 if( m_symbol )
850 {
851 symbolName = m_symbol->GetName();
853 }
854
855 // retain in case this wxFrame is re-opened later on the same PROJECT
857
858 // Ensure synchronized pin edit can be enabled only symbols with interchangeable units
859 m_SyncPinEdit = aSymbol && aSymbol->IsRoot() && aSymbol->IsMulti() && !aSymbol->UnitsLocked();
860
862
870
871 if( aUpdateZoom )
873
874 GetCanvas()->Refresh();
875
876 WX_INFOBAR& infobar = *GetInfoBar();
877 infobar.RemoveAllButtons();
878
879 wxArrayString msgs;
880 int infobarFlags = wxICON_INFORMATION;
881
883 {
884 msgs.push_back( wxString::Format( _( "Editing symbol %s from schematic. Saving will "
885 "update the schematic only." ),
886 m_reference ) );
887
888 wxString link = wxString::Format( _( "Open symbol from library %s" ), libName );
889 wxHyperlinkCtrl* button = new wxHyperlinkCtrl( &infobar, wxID_ANY, link, wxEmptyString );
890
891 button->Bind( wxEVT_COMMAND_HYPERLINK, std::function<void( wxHyperlinkEvent& aEvent )>(
892 [this, symbolName, libName]( wxHyperlinkEvent& aEvent )
893 {
895 {
896 if( !IsLibraryTreeShown() )
898 }
899 else
900 {
901 DisplayError( this, wxString::Format( _( "Failed to load symbol %s from "
902 "library %s." ),
903 symbolName,
904 libName ) );
905 }
906 } ) );
907
908 infobar.AddButton( button );
909 }
910 else if( IsSymbolFromLegacyLibrary() )
911 {
912 msgs.push_back( _( "Symbols in legacy libraries are not editable. Use Manage Symbol "
913 "Libraries to migrate to current format." ) );
914
915 wxString link = _( "Manage symbol libraries" );
916 wxHyperlinkCtrl* button = new wxHyperlinkCtrl( &infobar, wxID_ANY, link, wxEmptyString );
917
918 button->Bind( wxEVT_COMMAND_HYPERLINK, std::function<void( wxHyperlinkEvent& aEvent )>(
919 [this]( wxHyperlinkEvent& aEvent )
920 {
922 } ) );
923
924 infobar.AddButton( button );
925 }
926 else if( IsSymbolAlias() )
927 {
928 msgs.push_back( wxString::Format( _( "Symbol %s is a derived symbol. Symbol graphics will "
929 "not be editable." ),
930 UnescapeString( symbolName ) ) );
931
932 // Don't assume the parent symbol shared pointer is still valid.
933 if( std::shared_ptr<LIB_SYMBOL> rootSymbol = m_symbol->GetRootSymbol() )
934 {
935 int unit = GetUnit();
936 int bodyStyle = GetBodyStyle();
937 wxString rootSymbolName = rootSymbol->GetName();
938 wxString link = wxString::Format( _( "Open %s" ), UnescapeString( rootSymbolName ) );
939
940 wxHyperlinkCtrl* button = new wxHyperlinkCtrl( &infobar, wxID_ANY, link,
941 wxEmptyString );
942
943 button->Bind( wxEVT_COMMAND_HYPERLINK, std::function<void( wxHyperlinkEvent& aEvent )>(
944 [this, rootSymbolName, unit, bodyStyle]( wxHyperlinkEvent& aEvent )
945 {
946 LoadSymbolFromCurrentLib( rootSymbolName, unit, bodyStyle );
947 } ) );
948
949 infobar.AddButton( button );
950 }
951 }
952
953 if( m_symbol
956 {
957 msgs.push_back( _( "Library is read-only. Changes cannot be saved to this library." ) );
958
959 wxString link = wxString::Format( _( "Create an editable copy" ) );
960 wxHyperlinkCtrl* button = new wxHyperlinkCtrl( &infobar, wxID_ANY, link, wxEmptyString );
961
962 button->Bind( wxEVT_COMMAND_HYPERLINK, std::function<void( wxHyperlinkEvent& aEvent )>(
963 [this, symbolName, libName]( wxHyperlinkEvent& aEvent )
964 {
965 wxString msg = wxString::Format( _( "Create an editable copy of the symbol or "
966 "the entire library (%s)?" ),
967 libName );
968
969 KIDIALOG errorDlg( this, msg, _( "Select type of item to save" ),
970 wxYES_NO | wxCANCEL | wxICON_QUESTION );
971 // These buttons are in a weird order(?)
972 errorDlg.SetYesNoCancelLabels( _( "Copy symbol" ), _( "Cancel" ),
973 _( "Copy library" ) );
974
975 int choice = errorDlg.ShowModal();
976
977 switch( choice )
978 {
979 case wxID_YES:
980 SaveSymbolCopyAs( true );
981 break;
982 case wxID_CANCEL:
984 break;
985 default:
986 // Do nothing
987 break;
988 }
989 } ) );
990
991 infobar.AddButton( button );
992 }
993
994 if( msgs.empty() )
995 {
996 infobar.Dismiss();
997 }
998 else
999 {
1000 wxString msg = wxJoin( msgs, '\n', '\0' );
1001 infobar.ShowMessage( msg, infobarFlags );
1002 }
1003}
1004
1005
1007{
1008 wxASSERT( m_libMgr );
1009 return *m_libMgr;
1010}
1011
1012
1014{
1016
1018 m_autoSaveRequired = true;
1019
1020 if( !IsSymbolFromSchematic() )
1022
1024
1025 if( !GetTitle().StartsWith( "*" ) )
1026 UpdateTitle();
1027}
1028
1029
1031{
1032 wxCHECK( aUnit > 0 && aUnit <= GetCurSymbol()->GetUnitCount(), /* void*/ );
1033
1034 if( m_unit == aUnit )
1035 return;
1036
1039
1040 m_unit = aUnit;
1041
1042 if( m_unitSelectBox->GetSelection() != ( m_unit - 1 ) )
1043 m_unitSelectBox->SetSelection( m_unit - 1 );
1044
1046 RebuildView();
1048}
1049
1050
1052{
1054}
1055
1056
1057wxString SYMBOL_EDIT_FRAME::AddLibraryFile( bool aCreateNew )
1058{
1059 // Select the target library table (global/project)
1060 SYMBOL_LIB_TABLE* libTable = SelectSymLibTable();
1061
1062 if( !libTable )
1063 return wxEmptyString;
1064
1065 wxFileName fn = m_libMgr->GetUniqueLibraryName();
1066
1069 ( libTable == &SYMBOL_LIB_TABLE::GetGlobalLibTable() ),
1071 {
1072 return wxEmptyString;
1073 }
1074
1075 wxString libName = fn.GetName();
1076
1077 if( libName.IsEmpty() )
1078 return wxEmptyString;
1079
1080 if( m_libMgr->LibraryExists( libName ) )
1081 {
1082 DisplayError( this, wxString::Format( _( "Library '%s' already exists." ), libName ) );
1083 return wxEmptyString;
1084 }
1085
1086 if( aCreateNew )
1087 {
1088 if( !m_libMgr->CreateLibrary( fn.GetFullPath(), *libTable ) )
1089 {
1090 DisplayError( this, wxString::Format( _( "Could not create the library file '%s'.\n"
1091 "Make sure you have write permissions and "
1092 "try again." ),
1093 fn.GetFullPath() ) );
1094 return wxEmptyString;
1095 }
1096 }
1097 else
1098 {
1099 if( !m_libMgr->AddLibrary( fn.GetFullPath(), *libTable ) )
1100 {
1101 DisplayError( this, _( "Could not open the library file." ) );
1102 return wxEmptyString;
1103 }
1104 }
1105
1106 bool globalTable = ( libTable == &SYMBOL_LIB_TABLE::GetGlobalLibTable() );
1107 saveSymbolLibTables( globalTable, !globalTable );
1108
1109 std::string packet = fn.GetFullPath().ToStdString();
1111
1112 return fn.GetFullPath();
1113}
1114
1115
1116void SYMBOL_EDIT_FRAME::DdAddLibrary( wxString aLibFile )
1117{
1118 // Select the target library table (global/project)
1119 SYMBOL_LIB_TABLE* libTable = SelectSymLibTable();
1120
1121 if( !libTable )
1122 return;
1123
1124 wxFileName fn = wxFileName( aLibFile );
1125
1126 wxString libName = fn.GetName();
1127
1128 if( libName.IsEmpty() )
1129 return;
1130
1131 if( m_libMgr->LibraryExists( libName ) )
1132 {
1133 DisplayError( this, wxString::Format( _( "Library '%s' already exists." ), libName ) );
1134 return;
1135 }
1136
1137 if( !m_libMgr->AddLibrary( fn.GetFullPath(), *libTable ) )
1138 {
1139 DisplayError( this, _( "Could not open the library file." ) );
1140 return;
1141 }
1142
1143 bool globalTable = ( libTable == &SYMBOL_LIB_TABLE::GetGlobalLibTable() );
1144 saveSymbolLibTables( globalTable, !globalTable );
1145
1146 std::string packet = fn.GetFullPath().ToStdString();
1148}
1149
1150
1152{
1153 return GetLibTree()->GetSelectedLibId( aUnit );
1154}
1155
1156
1158{
1159 return GetLibTree()->GetSelectionCount();
1160}
1161
1162int SYMBOL_EDIT_FRAME::GetTreeLIBIDs( std::vector<LIB_ID>& aSelection ) const
1163{
1164 return GetLibTree()->GetSelectedLibIds( aSelection );
1165}
1166
1167
1169{
1170 if( IsLibraryTreeShown() )
1171 {
1172 LIB_ID libId = GetTreeLIBID();
1173
1174 if( libId.IsValid() )
1175 return m_libMgr->GetAlias( libId.GetLibItemName(), libId.GetLibNickname() );
1176 }
1177
1178 return m_symbol;
1179}
1180
1181
1183{
1184 LIB_ID id;
1185
1186 if( IsLibraryTreeShown() )
1187 id = GetTreeLIBID();
1188
1189 if( id.GetLibNickname().empty() && m_symbol )
1190 id = m_symbol->GetLibId();
1191
1192 return id;
1193}
1194
1195
1196std::vector<LIB_ID> SYMBOL_EDIT_FRAME::GetSelectedLibIds() const
1197{
1198 std::vector<LIB_ID> ids;
1199 GetTreeLIBIDs( ids );
1200 return ids;
1201}
1202
1203
1205{
1206 return GetTargetLibId().GetLibNickname();
1207}
1208
1209
1210void SYMBOL_EDIT_FRAME::SyncLibraries( bool aShowProgress, bool aPreloadCancelled,
1211 const wxString& aForceRefresh )
1212{
1213 LIB_ID selected;
1214
1215 if( m_treePane )
1216 selected = GetLibTree()->GetSelectedLibId();
1217
1218 if( aShowProgress )
1219 {
1220 APP_PROGRESS_DIALOG progressDlg( _( "Loading Symbol Libraries" ), wxEmptyString,
1221 m_libMgr->GetAdapter()->GetLibrariesCount(), this );
1222
1223 m_libMgr->Sync( aForceRefresh,
1224 [&]( int progress, int max, const wxString& libName )
1225 {
1226 progressDlg.Update( progress, wxString::Format( _( "Loading library '%s'..." ),
1227 libName ) );
1228 } );
1229 }
1230 else if( !aPreloadCancelled )
1231 {
1232 m_libMgr->Sync( aForceRefresh,
1233 [&]( int progress, int max, const wxString& libName )
1234 {
1235 } );
1236 }
1237
1238 if( m_treePane )
1239 {
1240 wxDataViewItem found;
1241
1242 if( selected.IsValid() )
1243 {
1244 // Check if the previously selected item is still valid,
1245 // if not - it has to be unselected to prevent crash
1246 found = m_libMgr->GetAdapter()->FindItem( selected );
1247
1248 if( !found )
1249 GetLibTree()->Unselect();
1250 }
1251
1252 GetLibTree()->Regenerate( true );
1253
1254 // Try to select the parent library, in case the symbol is not found
1255 if( !found && selected.IsValid() )
1256 {
1257 selected.SetLibItemName( "" );
1258 found = m_libMgr->GetAdapter()->FindItem( selected );
1259
1260 if( found )
1261 GetLibTree()->SelectLibId( selected );
1262 }
1263
1264 // If no selection, see if there's a current symbol to centre
1265 if( !selected.IsValid() && m_symbol )
1266 {
1267 LIB_ID current( GetCurLib(), m_symbol->GetName() );
1268 GetLibTree()->CenterLibId( current );
1269 }
1270 }
1271}
1272
1273
1275{
1277}
1278
1279
1281{
1282 GetLibTree()->SelectLibId( aLibID );
1283}
1284
1285
1286void SYMBOL_EDIT_FRAME::UpdateLibraryTree( const wxDataViewItem& aTreeItem, LIB_SYMBOL* aSymbol )
1287{
1288 if( aTreeItem.IsOk() ) // Can be not found in tree if the current footprint is imported
1289 // from file therefore not yet in tree.
1290 {
1291 static_cast<LIB_TREE_NODE_ITEM*>( aTreeItem.GetID() )->Update( aSymbol );
1293 }
1294}
1295
1296
1297bool SYMBOL_EDIT_FRAME::backupFile( const wxFileName& aOriginalFile, const wxString& aBackupExt )
1298{
1299 if( aOriginalFile.FileExists() )
1300 {
1301 wxFileName backupFileName( aOriginalFile );
1302 backupFileName.SetExt( aBackupExt );
1303
1304 if( backupFileName.FileExists() )
1305 wxRemoveFile( backupFileName.GetFullPath() );
1306
1307 if( !wxCopyFile( aOriginalFile.GetFullPath(), backupFileName.GetFullPath() ) )
1308 {
1309 DisplayError( this, wxString::Format( _( "Failed to save backup to '%s'." ),
1310 backupFileName.GetFullPath() ) );
1311 return false;
1312 }
1313 }
1314
1315 return true;
1316}
1317
1318
1320{
1321 if( m_symbol && !GetCurLib().IsEmpty() && GetScreen()->IsContentModified() )
1322 m_libMgr->UpdateSymbol( m_symbol, GetCurLib() ); // UpdateSymbol() makes a copy
1323}
1324
1325
1327{
1328 // This will return the root symbol of any alias
1330 aLibId.GetLibNickname() );
1331
1332 // Now we can compare the libId of the current symbol and the root symbol
1333 return ( symbol && m_symbol && symbol->GetLibId() == m_symbol->GetLibId() );
1334}
1335
1336
1338{
1339 GetLibTree()->Unselect();
1340 SetCurLib( wxEmptyString );
1341 SetCurSymbol( nullptr, false );
1345 Refresh();
1346}
1347
1348
1349void SYMBOL_EDIT_FRAME::CommonSettingsChanged( bool aEnvVarsChanged, bool aTextVarsChanged )
1350{
1351 SCH_BASE_FRAME::CommonSettingsChanged( aEnvVarsChanged, aTextVarsChanged );
1352
1355
1360
1362
1363 if( m_symbol )
1365
1367
1369 GetCanvas()->Refresh();
1370
1372
1373 if( aEnvVarsChanged )
1374 SyncLibraries( true );
1375
1376 Layout();
1377 SendSizeEvent();
1378}
1379
1380
1382{
1383 // call my base class
1385
1386 // tooltips in toolbars
1388
1389 // For some obscure reason, the AUI manager hides the first modified pane.
1390 // So force show panes
1391 wxAuiPaneInfo& tree_pane_info = m_auimgr.GetPane( m_treePane );
1392 bool tree_shown = tree_pane_info.IsShown();
1393 tree_pane_info.Caption( _( "Libraries" ) );
1394 tree_pane_info.Show( tree_shown );
1395 m_auimgr.Update();
1396
1398
1399 // status bar
1401
1402 if( GetRenderSettings()->m_ShowPinsElectricalType )
1403 {
1405 GetCanvas()->Refresh();
1406 }
1407
1408 UpdateTitle();
1409}
1410
1411
1413{
1414 SCH_BASE_FRAME::SetScreen( aScreen );
1415
1416 // Let tools add things to the view if necessary
1417 if( m_toolManager )
1419}
1420
1421
1423{
1431
1432 // Let tools add things to the view if necessary
1433 if( m_toolManager )
1435
1437 GetCanvas()->Refresh();
1438}
1439
1440
1442{
1443 SyncLibraries( true );
1444
1445 if( m_symbol )
1446 {
1448 EE_SELECTION& selection = selectionTool->GetSelection();
1449
1450 for( SCH_ITEM& item : m_symbol->GetDrawItems() )
1451 {
1452 if( !alg::contains( selection, &item ) )
1453 item.ClearSelected();
1454 else
1455 item.SetSelected();
1456 }
1457
1459 }
1460
1461 RebuildView();
1462}
1463
1464
1465const BOX2I SYMBOL_EDIT_FRAME::GetDocumentExtents( bool aIncludeAllVisible ) const
1466{
1467 if( !m_symbol )
1468 {
1469 // Gives a reasonable drawing area size
1470 int width = schIUScale.mmToIU( 50 );
1471 int height = schIUScale.mmToIU( 30 );
1472
1473 return BOX2I( VECTOR2I( -width/2, -height/2 ), VECTOR2I( width, height ) );
1474 }
1475 else
1476 {
1477 return m_symbol->Flatten()->GetUnitBoundingBox( m_unit, m_bodyStyle );
1478 }
1479}
1480
1481
1483{
1484 static KIID lastBrightenedItemID( niluuid );
1485
1486 SCH_ITEM* lastItem = nullptr;
1487
1488 if( m_symbol )
1489 {
1490 for( SCH_PIN* pin : m_symbol->GetAllLibPins() )
1491 {
1492 if( pin->m_Uuid == lastBrightenedItemID )
1493 lastItem = pin;
1494 }
1495
1496 std::vector<SCH_FIELD*> fields;
1497 m_symbol->GetFields( fields );
1498
1499 for( SCH_FIELD* field : fields )
1500 {
1501 if( field->m_Uuid == lastBrightenedItemID )
1502 lastItem = field;
1503 }
1504 }
1505
1506 if( lastItem && lastItem != aItem )
1507 {
1508 lastItem->ClearBrightened();
1509
1510 UpdateItem( lastItem );
1511 lastBrightenedItemID = niluuid;
1512 }
1513
1514 if( aItem )
1515 {
1516 if( !aItem->IsBrightened() )
1517 {
1518 aItem->SetBrightened();
1519
1520 UpdateItem( aItem );
1521 lastBrightenedItemID = aItem->m_Uuid;
1522 }
1523
1524 FocusOnLocation( VECTOR2I( aItem->GetFocusPosition().x, -aItem->GetFocusPosition().y ) );
1525 }
1526}
1527
1528
1530{
1531 const std::string& payload = mail.GetPayload();
1532
1533 switch( mail.Command() )
1534 {
1535 case MAIL_LIB_EDIT:
1536 if( !payload.empty() )
1537 {
1538 wxString libFileName( payload );
1539 wxString libNickname;
1540 wxString msg;
1541
1543 const LIB_TABLE_ROW* libTableRow = libTable->FindRowByURI( libFileName );
1544
1545 if( !libTableRow )
1546 {
1547 msg.Printf( _( "The current configuration does not include the symbol library '%s'." ),
1548 libFileName );
1549 msg += wxS( "\n" ) + _( "Use Manage Symbol Libraries to edit the configuration." );
1550 DisplayErrorMessage( this, _( "Library not found in symbol library table." ), msg );
1551 break;
1552 }
1553
1554 libNickname = libTableRow->GetNickName();
1555
1556 if( !libTable->HasLibrary( libNickname, true ) )
1557 {
1558 msg.Printf( _( "The symbol library '%s' is not enabled in the current configuration." ),
1559 UnescapeString( libNickname ) );
1560 msg += wxS( "\n" ) + _( "Use Manage Symbol Libraries to edit the configuration." );
1561 DisplayErrorMessage( this, _( "Symbol library not enabled." ), msg );
1562 break;
1563 }
1564
1565 SetCurLib( libNickname );
1566
1567 if( m_treePane )
1568 {
1569 LIB_ID id( libNickname, wxEmptyString );
1570 GetLibTree()->SelectLibId( id );
1571 GetLibTree()->ExpandLibId( id );
1572 GetLibTree()->CenterLibId( id );
1573 }
1574 }
1575
1576 break;
1577
1578 case MAIL_RELOAD_LIB:
1579 {
1580 wxString currentLib = GetCurLib();
1582
1584
1585 // Check if the currently selected symbol library been removed or disabled.
1586 if( !currentLib.empty() && libTable && !libTable->HasLibrary( currentLib, true ) )
1587 {
1588 SetCurLib( wxEmptyString );
1589 emptyScreen();
1590 }
1591
1592 SyncLibraries( true );
1595
1596 break;
1597 }
1598
1600 {
1602 LIB_SYMBOL* symbol = GetCurSymbol();
1603
1604 wxLogTrace( "KICAD_LIB_WATCH", "Received refresh symbol request for %s",
1605 payload );
1606
1607 if( !tbl || !symbol )
1608 break;
1609
1610 wxString libName = symbol->GetLibId().GetLibNickname();
1611 const SYMBOL_LIB_TABLE_ROW* row = tbl->FindRow( libName );
1612
1613 if( !row )
1614 return;
1615
1616 wxFileName libfullname( row->GetFullURI( true ) );
1617
1618 wxFileName changedLib( mail.GetPayload() );
1619 wxLogTrace( "KICAD_LIB_WATCH",
1620 "Received refresh symbol request for %s, current symbols is %s",
1621 changedLib.GetFullPath(), libfullname.GetFullPath() );
1622
1623 if( changedLib == libfullname )
1624 {
1625 wxLogTrace( "KICAD_LIB_WATCH", "Refreshing symbol %s", symbol->GetName() );
1626
1627 SetScreen( m_dummyScreen ); // UpdateLibraryBuffer will destroy the old screen
1628 m_libMgr->UpdateLibraryBuffer( libName );
1629
1630 LIB_SYMBOL* lib_symbol = m_libMgr->GetBufferedSymbol( symbol->GetName(), libName );
1631 wxCHECK2_MSG( lib_symbol, break, wxString::Format( "Symbol %s not found in library %s",
1632 symbol->GetName(), libName ) );
1633
1634 // The buffered screen for the symbol
1635 SCH_SCREEN* symbol_screen = m_libMgr->GetScreen( lib_symbol->GetName(), libName );
1636
1637 SetScreen( symbol_screen );
1638 SetCurSymbol( new LIB_SYMBOL( *lib_symbol ), false );
1640 SetShowDeMorgan( GetCurSymbol()->HasAlternateBodyStyle() );
1641
1642 if( m_toolManager )
1644 }
1645
1646 break;
1647 }
1648
1649 default:
1650 ;
1651 }
1652}
1653
1654
1655std::unique_ptr<GRID_HELPER> SYMBOL_EDIT_FRAME::MakeGridHelper()
1656{
1657 return std::make_unique<EE_GRID_HELPER>( m_toolManager );
1658}
1659
1660
1662{
1663 // switches currently used canvas ( Cairo / OpenGL):
1664 SCH_BASE_FRAME::SwitchCanvas( aCanvasType );
1665
1666 // Set options specific to symbol editor (axies are always enabled):
1667 GetCanvas()->GetGAL()->SetAxesEnabled( true );
1669}
1670
1671
1673{
1674 wxCHECK( m_libMgr, false );
1675
1676 return m_libMgr->HasModifications();
1677}
1678
1679
1681{
1682 wxCHECK( m_libMgr, false );
1683
1684 // Test if the currently edited symbol is modified
1686 return true;
1687
1688 // Test if any library has been modified
1689 for( const wxString& libName : m_libMgr->GetLibraryNames() )
1690 {
1691 if( m_libMgr->IsLibraryModified( libName ) && !m_libMgr->IsLibraryReadOnly( libName ) )
1692 return true;
1693 }
1694
1695 return false;
1696}
1697
1698
1700{
1701 if( aItemCount == 0 )
1702 return;
1703
1704 UNDO_REDO_CONTAINER& list = ( whichList == UNDO_LIST ) ? m_undoList : m_redoList;
1705
1706 if( aItemCount < 0 )
1707 {
1708 list.ClearCommandList();
1709 }
1710 else
1711 {
1712 for( int ii = 0; ii < aItemCount; ii++ )
1713 {
1714 if( list.m_CommandsList.size() == 0 )
1715 break;
1716
1717 PICKED_ITEMS_LIST* curr_cmd = list.m_CommandsList[0];
1718 list.m_CommandsList.erase( list.m_CommandsList.begin() );
1719
1720 curr_cmd->ClearListAndDeleteItems( []( EDA_ITEM* aItem )
1721 {
1722 delete aItem;
1723 } );
1724 delete curr_cmd; // Delete command
1725 }
1726 }
1727}
1728
1729
1731{
1732 return m_toolManager->GetTool<EE_SELECTION_TOOL>()->GetSelection();
1733}
1734
1735
1737{
1738 std::unique_ptr<LIB_SYMBOL> symbol = aSymbol->GetLibSymbolRef()->Flatten();
1739 wxCHECK( symbol, /* void */ );
1740
1741 symbol->SetLibId( aSymbol->GetLibId() );
1742
1743 // Take in account the symbol orientation and mirroring. to calculate the field
1744 // positions in symbol editor (i.e. no rotation, no mirroring)
1745 int orientation = aSymbol->GetOrientation() & ~( SYM_MIRROR_X | SYM_MIRROR_Y );
1746 int mirror = aSymbol->GetOrientation() & ( SYM_MIRROR_X | SYM_MIRROR_Y );
1747
1748 std::vector<SCH_FIELD> fullSetOfFields;
1749
1750 for( int i = 0; i < (int) aSymbol->GetFields().size(); ++i )
1751 {
1752 const SCH_FIELD& field = aSymbol->GetFields()[i];
1753 VECTOR2I pos = field.GetPosition() - aSymbol->GetPosition();
1754 SCH_FIELD libField( symbol.get(), field.GetId() );
1755
1756 if( i >= MANDATORY_FIELDS && !field.GetName( false ).IsEmpty() )
1757 libField.SetName( field.GetName( false ) );
1758
1759 libField.SetText( field.GetText() );
1760 libField.SetAttributes( field );
1761
1762 // The inverse transform is mirroring before, rotate after
1763 switch( mirror )
1764 {
1765 case SYM_MIRROR_X: pos.y = -pos.y; break;
1766 case SYM_MIRROR_Y: pos.x = -pos.x; break;
1767 default: break;
1768 }
1769
1770 switch( orientation )
1771 {
1772 case SYM_ORIENT_90:
1773 std::swap( pos.x, pos.y );
1774 pos.x = - pos.x;
1775 break;
1776 case SYM_ORIENT_270:
1777 std::swap( pos.x, pos.y );
1778 pos.y = - pos.y;
1779 break;
1780 case SYM_ORIENT_180:
1781 pos.x = - pos.x;
1782 pos.y = - pos.y;
1783 break;
1784 default:
1785 break;
1786 }
1787
1788 libField.SetPosition( pos );
1789
1790 fullSetOfFields.emplace_back( std::move( libField ) );
1791 }
1792
1793 symbol->SetFields( fullSetOfFields );
1794
1795 if( m_symbol )
1796 SetCurSymbol( nullptr, false );
1797
1799 m_schematicSymbolUUID = aSymbol->m_Uuid;
1800 m_reference = symbol->GetFieldById( REFERENCE_FIELD )->GetText();
1801 m_unit = std::max( 1, aSymbol->GetUnit() );
1802 m_bodyStyle = std::max( 1, aSymbol->GetBodyStyle() );
1803
1804 // Optimize default edit options for this symbol
1805 // Usually if units are locked, graphic items are specific to each unit
1806 // and if units are interchangeable, graphic items are common to units
1808 tools->SetDrawSpecificUnit( symbol->UnitsLocked() );
1809
1810 // The buffered screen for the symbol
1811 SCH_SCREEN* tmpScreen = new SCH_SCREEN();
1812
1813 SetScreen( tmpScreen );
1814 SetCurSymbol( symbol.release(), true );
1815 setSymWatcher( nullptr );
1816
1819
1820 if( IsLibraryTreeShown() )
1822
1823 UpdateTitle();
1825 SetShowDeMorgan( GetCurSymbol()->HasAlternateBodyStyle() );
1827
1828 // Let tools add things to the view if necessary
1829 if( m_toolManager )
1831
1833 GetCanvas()->Refresh();
1834}
1835
1836
1837bool SYMBOL_EDIT_FRAME::addLibTableEntry( const wxString& aLibFile, TABLE_SCOPE aScope )
1838{
1839 wxFileName fn = aLibFile;
1840 wxFileName libTableFileName( Prj().GetProjectPath(),
1842 wxString libNickname = fn.GetName();
1844 const ENV_VAR_MAP& envVars = Pgm().GetLocalEnvVariables();
1845
1846 if( libTable->HasLibrary( libNickname ) )
1847 {
1848 wxString tmp;
1849 int suffix = 1;
1850
1851 while( libTable->HasLibrary( libNickname ) )
1852 {
1853 tmp.Printf( "%s%d", fn.GetName(), suffix );
1854 libNickname = tmp;
1855 suffix += 1;
1856 }
1857 }
1858
1860 row->SetNickName( libNickname );
1861
1862 wxString normalizedPath = NormalizePath( aLibFile, &envVars, Prj().GetProjectPath() );
1863
1864 if( aScope == GLOBAL_LIB_TABLE )
1865 {
1867 libTableFileName = SYMBOL_LIB_TABLE::GetGlobalTableFileName();
1868
1869 // We cannot normalize against the current project path when saving to global table.
1870 normalizedPath = NormalizePath( aLibFile, &envVars, wxEmptyString );
1871 }
1872
1873 row->SetFullURI( normalizedPath );
1874
1875 wxCHECK( libTable->InsertRow( row ), false );
1876
1877 try
1878 {
1879 libTable->Save( libTableFileName.GetFullPath() );
1880 }
1881 catch( const IO_ERROR& ioe )
1882 {
1883 wxString msg = aScope == GLOBAL_LIB_TABLE ? _( "Error saving global library table." )
1884 : _( "Error saving project library table." );
1885
1886 wxMessageDialog dlg( this, msg, _( "File Save Error" ), wxOK | wxICON_ERROR );
1887 dlg.SetExtendedMessage( ioe.What() );
1888 dlg.ShowModal();
1889
1890 return false;
1891 }
1892
1893 return true;
1894}
1895
1896
1897bool SYMBOL_EDIT_FRAME::replaceLibTableEntry( const wxString& aLibNickname,
1898 const wxString& aLibFile )
1899{
1900 // Check the global library table first because checking the project library table
1901 // checks the global library table as well due to library chaining.
1902 bool isGlobalTable = true;
1903 wxFileName libTableFileName = SYMBOL_LIB_TABLE::GetGlobalTableFileName();;
1904 const ENV_VAR_MAP& envVars = Pgm().GetLocalEnvVariables();
1906 SYMBOL_LIB_TABLE_ROW* row = libTable->FindRow( aLibNickname );
1907
1908 if( !row )
1909 {
1910 libTableFileName.SetPath( Prj().GetProjectPath() );
1911 libTableFileName.SetName( SYMBOL_LIB_TABLE::GetSymbolLibTableFileName() );
1912 libTable = PROJECT_SCH::SchSymbolLibTable( &Prj() );
1913 isGlobalTable = false;
1914 row = libTable->FindRow( aLibNickname );
1915 }
1916
1917 wxCHECK( row, false );
1918
1919 wxString projectPath;
1920
1921 if( !isGlobalTable )
1922 projectPath = Prj().GetProjectPath();
1923
1924 wxString normalizedPath = NormalizePath( aLibFile, &envVars, projectPath );
1925
1926 row->SetFullURI( normalizedPath );
1927 row->SetType( "KiCad" );
1928
1929 try
1930 {
1931 libTable->Save( libTableFileName.GetFullPath() );
1932 }
1933 catch( const IO_ERROR& ioe )
1934 {
1935 wxString msg = isGlobalTable ? _( "Error saving global library table." )
1936 : _( "Error saving project library table." );
1937
1938 wxMessageDialog dlg( this, msg, _( "File Save Error" ), wxOK | wxICON_ERROR );
1939 dlg.SetExtendedMessage( ioe.What() );
1940 dlg.ShowModal();
1941
1942 return false;
1943 }
1944
1945 return true;
1946}
1947
1948
1950{
1951 return m_symbol && !m_symbol->IsRoot();
1952}
1953
1954
1956{
1958}
1959
1960
1961void SYMBOL_EDIT_FRAME::UpdateItem( EDA_ITEM* aItem, bool isAddOrDelete, bool aUpdateRtree )
1962{
1963 SCH_BASE_FRAME::UpdateItem( aItem, isAddOrDelete, aUpdateRtree );
1964
1965 if( EDA_TEXT* eda_text = dynamic_cast<EDA_TEXT*>( aItem ) )
1966 {
1967 eda_text->ClearBoundingBoxCache();
1968 eda_text->ClearRenderCache();
1969 }
1970}
1971
1972
1974{
1975 wxAuiPaneInfo& treePane = m_auimgr.GetPane( "SymbolTree" );
1976 wxAuiPaneInfo& propertiesPane = m_auimgr.GetPane( PropertiesPaneName() );
1977 wxAuiPaneInfo& selectionFilterPane = m_auimgr.GetPane( wxS( "SelectionFilter" ) );
1978
1979 // Don't give the selection filter its own visibility controls; instead show it if
1980 // anything else is visible
1981 bool showFilter = ( treePane.IsShown() && treePane.IsDocked() )
1982 || ( propertiesPane.IsShown() && propertiesPane.IsDocked() );
1983
1984 selectionFilterPane.Show( showFilter );
1985}
1986
1987
1989{
1990 // Returns the current render option for invisible fields
1992}
1993
1994
1996{
1997 // Returns the current render option for invisible pins
1999}
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:922
static TOOL_ACTION toggleGrid
Definition: actions.h:185
static TOOL_ACTION paste
Definition: actions.h:73
static TOOL_ACTION cancelInteractive
Definition: actions.h:65
static TOOL_ACTION millimetersUnits
Definition: actions.h:193
static TOOL_ACTION unselectAll
Definition: actions.h:76
static TOOL_ACTION revert
Definition: actions.h:55
static TOOL_ACTION copy
Definition: actions.h:71
static TOOL_ACTION showDatasheet
Definition: actions.h:215
static TOOL_ACTION milsUnits
Definition: actions.h:192
static TOOL_ACTION toggleBoundingBoxes
Definition: actions.h:145
static TOOL_ACTION saveAll
Definition: actions.h:54
static TOOL_ACTION undo
Definition: actions.h:68
static TOOL_ACTION duplicate
Definition: actions.h:77
static TOOL_ACTION inchesUnits
Definition: actions.h:191
static TOOL_ACTION toggleCursorStyle
Definition: actions.h:142
static TOOL_ACTION doDelete
Definition: actions.h:78
static TOOL_ACTION selectionTool
Definition: actions.h:200
static TOOL_ACTION save
Definition: actions.h:51
static TOOL_ACTION zoomFitScreen
Definition: actions.h:134
static TOOL_ACTION redo
Definition: actions.h:69
static TOOL_ACTION deleteTool
Definition: actions.h:79
static TOOL_ACTION zoomTool
Definition: actions.h:137
static TOOL_ACTION showProperties
Definition: actions.h:214
static TOOL_ACTION cut
Definition: actions.h:70
static TOOL_ACTION ddAddLibrary
Definition: actions.h:60
static TOOL_ACTION copyAsText
Definition: actions.h:72
static TOOL_ACTION toggleGridOverrides
Definition: actions.h:186
static TOOL_ACTION selectAll
Definition: actions.h:75
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
constexpr void SetOrigin(const Vec &pos)
Definition: box2.h:237
constexpr void SetSize(const SizeVec &size)
Definition: box2.h:248
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:89
virtual const VECTOR2I GetFocusPosition() const
Similar to GetPosition, but allows items to return their visual center rather than their anchor.
Definition: eda_item.h:250
const KIID m_Uuid
Definition: eda_item.h:489
void ClearBrightened()
Definition: eda_item.h:123
void SetBrightened()
Definition: eda_item.h:120
bool IsBrightened() const
Definition: eda_item.h:112
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:79
virtual const wxString & GetText() const
Return the string associated with the text object.
Definition: eda_text.h:94
void SetAttributes(const EDA_TEXT &aSrc, bool aSetPosition=true)
Set the text attributes from another instance.
Definition: eda_text.cpp:322
Class that groups generic conditions for editor states.
SELECTION_CONDITION NoActiveTool()
Create a functor testing if there are no tools active in the frame.
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:132
static TOOL_ACTION runERC
Inspection and Editing.
Definition: ee_actions.h:156
static TOOL_ACTION pinTable
Definition: ee_actions.h:162
static TOOL_ACTION saveSymbolAs
Definition: ee_actions.h:214
static TOOL_ACTION clearSelection
Clears the current selection.
Definition: ee_actions.h:56
static TOOL_ACTION placeSymbolAnchor
Definition: ee_actions.h:123
static TOOL_ACTION showHiddenFields
Definition: ee_actions.h:250
static TOOL_ACTION drawSymbolPolygon
Definition: ee_actions.h:122
static TOOL_ACTION showDeMorganAlternate
Definition: ee_actions.h:142
static TOOL_ACTION newSymbol
Definition: ee_actions.h:216
static TOOL_ACTION drawCircle
Definition: ee_actions.h:106
static TOOL_ACTION showDeMorganStandard
Definition: ee_actions.h:141
static TOOL_ACTION rotateCCW
Definition: ee_actions.h:131
static TOOL_ACTION saveLibraryAs
Definition: ee_actions.h:213
static TOOL_ACTION placeSymbolText
Definition: ee_actions.h:119
static TOOL_ACTION mirrorH
Definition: ee_actions.h:133
static TOOL_ACTION rotateCW
Definition: ee_actions.h:130
static TOOL_ACTION togglePinAltIcons
Definition: ee_actions.h:258
static TOOL_ACTION importGraphics
Definition: ee_actions.h:269
static TOOL_ACTION importSymbol
Definition: ee_actions.h:225
static TOOL_ACTION saveSymbolCopyAs
Definition: ee_actions.h:215
static TOOL_ACTION symbolProperties
Definition: ee_actions.h:161
static TOOL_ACTION drawRectangle
Definition: ee_actions.h:105
static TOOL_ACTION setUnitDisplayName
Definition: ee_actions.h:228
static TOOL_ACTION drawSymbolTextBox
Definition: ee_actions.h:120
static TOOL_ACTION showDesignBlockPanel
Definition: ee_actions.h:206
static TOOL_ACTION drawSymbolLines
Definition: ee_actions.h:121
static TOOL_ACTION drawArc
Definition: ee_actions.h:107
static TOOL_ACTION toggleSyncedPinsMode
Definition: ee_actions.h:259
static TOOL_ACTION drawBezier
Definition: ee_actions.h:108
static TOOL_ACTION showHiddenPins
Definition: ee_actions.h:249
static TOOL_ACTION placeSymbolPin
Definition: ee_actions.h:118
static TOOL_ACTION showElectricalTypes
Definition: ee_actions.h:265
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
Helper class to create more flexible dialogs, including 'do not show again' checkbox handling.
Definition: kidialog.h:43
int ShowModal() override
Definition: kidialog.cpp:95
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:191
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:1168
void UpdateAllItems(int aUpdateFlags)
Update all items in the view according to the given flags.
Definition: view.cpp:1563
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:284
void OnKiCadExit()
Definition: kiway.cpp:725
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
Module editor specific tools.
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
const wxString GetFullLibraryName() const
Definition: lib_id.cpp:277
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:78
const LIB_ID & GetLibId() const override
Definition: lib_symbol.h:143
bool IsMulti() const override
Definition: lib_symbol.h:554
bool UnitsLocked() const
Check whether symbol units are interchangeable.
Definition: lib_symbol.h:264
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:194
wxString GetUnitDisplayName(int aUnit) override
Return the user-defined display name for aUnit for symbols with units.
Definition: lib_symbol.cpp:260
std::vector< SCH_PIN * > GetAllLibPins() const
Return a list of pin pointers for all units / converts.
Definition: lib_symbol.cpp:842
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:499
wxString GetName() const override
Definition: lib_symbol.h:137
wxString GetLibNickname() const override
Sets the Description field text value.
Definition: lib_symbol.h:149
int GetUnitCount() const override
std::unique_ptr< LIB_SYMBOL > Flatten() const
Return a flattened symbol inheritance to the caller.
Definition: lib_symbol.cpp:304
LIB_SYMBOL_SPTR GetRootSymbol() const
Get the parent symbol that does not have another parent.
Definition: lib_symbol.cpp:236
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.
void RefreshLibTree()
Refreshes the tree (mainly to update highlighting and asterisking)
Definition: lib_tree.cpp:440
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:455
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:363
void Regenerate(bool aKeepState)
Regenerate the tree.
Definition: lib_tree.cpp:422
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:924
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:218
@ SCH_LIBEDIT_CUR_SYMBOL
Definition: project.h:219
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:307
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:318
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.
SYMBOL_EDITOR_SETTINGS * libeditconfig() const
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:1485
int GetId() const
Definition: sch_field.h:133
wxString GetName(bool aUseDefaultName=true) const
Return the field name (not translated).
Definition: sch_field.cpp:1227
void SetPosition(const VECTOR2I &aPosition) override
Definition: sch_field.cpp:1465
void SetName(const wxString &aName)
Definition: sch_field.cpp:1202
void SetText(const wxString &aText) override
Definition: sch_field.cpp:1212
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:166
int GetBodyStyle() const
Definition: sch_item.h:232
int GetUnit() const
Definition: sch_item.h:229
virtual void ClearCaches()
Definition: sch_item.cpp:375
Schematic symbol object.
Definition: sch_symbol.h:104
VECTOR2I GetPosition() const override
Definition: sch_symbol.h:807
const LIB_ID & GetLibId() const override
Definition: sch_symbol.h:193
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:987
std::unique_ptr< LIB_SYMBOL > & GetLibSymbolRef()
Definition: sch_symbol.h:212
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
bool m_ShowPinAltIcons
When true, dragging an outline edge will drag pins rooted on it.
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.
std::unique_ptr< GRID_HELPER > MakeGridHelper() override
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.
bool IsLibraryTreeShown() const override
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...
void FocusLibraryTreeInput() override
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.
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
void LoadSymbol(const wxString &aLibrary, const wxString &aSymbol, int Unit)
int GetBodyStyle() const
void HardRedraw() override
Rebuild the GAL and redraw the screen.
bool GetShowDeMorgan() 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
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
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 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
LIB_ID GetTargetLibId() const override
Return either the symbol selected in the symbol tree (if context menu is active) or the symbol on the...
int m_bodyStyle
Flag if the symbol being edited was loaded directly from a schematic.
bool saveAllLibraries(bool aRequireConfirmation)
Save the current symbol.
void SetUnit(int aUnit)
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.
LIB_TREE * GetLibTree() const override
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 SaveSymbolCopyAs(bool aOpenCopy)
Save the currently selected symbol to a new name and/or location.
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
void SaveLibraryAs()
Save the currently selected library to a new file.
bool IsContentModified() const override
Get if any symbols or libraries have been modified but not saved.
void ToggleLibraryTree() override
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...
bool AddLibrary(const wxString &aFilePath, SYMBOL_LIB_TABLE &aTable)
Add an existing library.
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 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.
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:76
void RemoveAllButtons()
Remove all the buttons that have been added by the user.
Definition: wx_infobar.cpp:304
void AddButton(wxButton *aButton)
Add an already created button to the infobar.
Definition: wx_infobar.cpp:263
void Dismiss() override
Dismisses the infobar and updates the containing layout and AUI manager (if one is provided).
Definition: wx_infobar.cpp:190
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
This file is part of the common library.
KIID niluuid(0)
@ LAYER_SCHEMATIC_GRID_AXES
Definition: layer_ids.h:391
@ 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: unix/app.cpp:90
bool SupportsShutdownBlockReason()
Whether or not the window supports setting a shutdown block reason.
Definition: unix/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:1060
see class PGM_BASE
@ SYM_ORIENT_270
Definition: sch_symbol.h:83
@ SYM_MIRROR_Y
Definition: sch_symbol.h:85
@ SYM_ORIENT_180
Definition: sch_symbol.h:82
@ SYM_MIRROR_X
Definition: sch_symbol.h:84
@ SYM_ORIENT_90
Definition: sch_symbol.h:81
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< int32_t > VECTOR2I
Definition: vector2d.h:691
VECTOR2< double > VECTOR2D
Definition: vector2d.h:690
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.