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/embed_tool.h>
56#include <tool/picker_tool.h>
58#include <tool/selection.h>
60#include <tool/tool_manager.h>
61#include <tool/zoom_tool.h>
62#include <tools/ee_actions.h>
71#include <view/view_controls.h>
73#include <widgets/wx_infobar.h>
80#include <panel_sym_lib_table.h>
81#include <string_utils.h>
82#include <wx/msgdlg.h>
83#include <wx/log.h>
84
85
87
88
89BEGIN_EVENT_TABLE( SYMBOL_EDIT_FRAME, SCH_BASE_FRAME )
91
92 // menubar commands
93 EVT_MENU( wxID_EXIT, SYMBOL_EDIT_FRAME::OnExitKiCad )
94 EVT_MENU( wxID_CLOSE, SYMBOL_EDIT_FRAME::CloseWindow )
95
96 // Update user interface elements.
98
99 // Drop files event
100 EVT_DROP_FILES( SYMBOL_EDIT_FRAME::OnDropFiles )
101
102END_EVENT_TABLE()
103
104
105SYMBOL_EDIT_FRAME::SYMBOL_EDIT_FRAME( KIWAY* aKiway, wxWindow* aParent ) :
106 SCH_BASE_FRAME( aKiway, aParent, FRAME_SCH_SYMBOL_EDITOR, _( "Library Editor" ),
107 wxDefaultPosition, wxDefaultSize, KICAD_DEFAULT_DRAWFRAME_STYLE,
109 m_unitSelectBox( nullptr ),
110 m_isSymbolFromSchematic( false )
111{
112 SetShowDeMorgan( false );
113 m_SyncPinEdit = false;
114
115 m_symbol = nullptr;
116 m_treePane = nullptr;
117 m_libMgr = nullptr;
118 m_unit = 1;
119 m_bodyStyle = 1;
120 m_aboutTitle = _HKI( "KiCad Symbol Editor" );
121
122 wxIcon icon;
123 wxIconBundle icon_bundle;
124
125 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_libedit, 48 ) );
126 icon_bundle.AddIcon( icon );
127 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_libedit, 256 ) );
128 icon_bundle.AddIcon( icon );
129 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_libedit, 128 ) );
130 icon_bundle.AddIcon( icon );
131 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_libedit_32 ) );
132 icon_bundle.AddIcon( icon );
133 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_libedit_16 ) );
134 icon_bundle.AddIcon( icon );
135
136 SetIcons( icon_bundle );
137
139 LoadSettings( m_settings );
140
141 m_libMgr = new LIB_SYMBOL_LIBRARY_MANAGER( *this );
142 bool loadingCancelled = false;
143
144 {
145 // Preload libraries before using SyncLibraries the first time, as the preload is
146 // multi-threaded
147 WX_PROGRESS_REPORTER reporter( this, _( "Loading Symbol Libraries" ),
148 m_libMgr->GetLibraryCount(), true );
149 m_libMgr->Preload( reporter );
150
151 loadingCancelled = reporter.IsCancelled();
152 wxSafeYield();
153 }
154
155 SyncLibraries( false, loadingCancelled );
156 m_treePane = new SYMBOL_TREE_PANE( this, m_libMgr );
157 m_treePane->GetLibTree()->SetSortMode( (LIB_TREE_MODEL_ADAPTER::SORT_MODE) m_settings->m_LibrarySortMode );
158
159 resolveCanvasType();
160 SwitchCanvas( m_canvasType );
161
162 // Ensure axis are always drawn
163 KIGFX::GAL_DISPLAY_OPTIONS& gal_opts = GetGalDisplayOptions();
164 gal_opts.m_axesEnabled = true;
165
166 m_dummyScreen = new SCH_SCREEN();
167 SetScreen( m_dummyScreen );
168 GetScreen()->m_Center = true;
169
170 GetCanvas()->GetViewControls()->SetCrossHairCursorPosition( VECTOR2D( 0, 0 ), false );
171
172 GetRenderSettings()->LoadColors( GetColorSettings() );
173 GetRenderSettings()->m_IsSymbolEditor = true;
174 GetCanvas()->GetGAL()->SetAxesColor( m_colorSettings->GetColor( LAYER_SCHEMATIC_GRID_AXES ) );
175
176 setupTools();
177 setupUIConditions();
178
179 ReCreateMenuBar();
180 ReCreateHToolbar();
181 ReCreateVToolbar();
182 ReCreateOptToolbar();
183
184 UpdateTitle();
185 UpdateSymbolMsgPanelInfo();
186 RebuildSymbolUnitsList();
187
188 m_propertiesPanel = new SCH_PROPERTIES_PANEL( this, this );
189 m_propertiesPanel->SetSplitterProportion( m_settings->m_AuiPanels.properties_splitter );
190
191 m_selectionFilterPanel = new PANEL_SCH_SELECTION_FILTER( this );
192
193 m_auimgr.SetManagedWindow( this );
194
195 CreateInfoBar();
196
197 // Rows; layers 4 - 6
198 m_auimgr.AddPane( m_mainToolBar, EDA_PANE().HToolbar().Name( "MainToolbar" )
199 .Top().Layer( 6 ) );
200
201 m_auimgr.AddPane( m_messagePanel, EDA_PANE().Messages().Name( "MsgPanel" )
202 .Bottom().Layer( 6 ) );
203
204 // Columns; layers 1 - 3
205 m_auimgr.AddPane( m_treePane, EDA_PANE().Palette().Name( "LibraryTree" )
206 .Left().Layer( 3 )
207 .TopDockable( false ).BottomDockable( false )
208 .Caption( _( "Libraries" ) )
209 .MinSize( FromDIP( 250 ), -1 ).BestSize( FromDIP( 250 ), -1 ) );
210
211 m_auimgr.AddPane( m_propertiesPanel, defaultPropertiesPaneInfo( this ) );
212 // Show or hide m_propertiesPanel depending on current settings:
213 wxAuiPaneInfo& propertiesPaneInfo = m_auimgr.GetPane( PropertiesPaneName() );
214
215 m_auimgr.AddPane( m_selectionFilterPanel, defaultSchSelectionFilterPaneInfo( this ) );
216
217 wxAuiPaneInfo& selectionFilterPane = m_auimgr.GetPane( wxS( "SelectionFilter" ) );
218 // The selection filter doesn't need to grow in the vertical direction when docked
219 selectionFilterPane.dock_proportion = 0;
220
221 propertiesPaneInfo.Show( m_settings->m_AuiPanels.show_properties );
222 updateSelectionFilterVisbility();
223
224 m_auimgr.AddPane( m_optionsToolBar, EDA_PANE().VToolbar().Name( "OptToolbar" )
225 .Left().Layer( 2 ) );
226
227 m_auimgr.AddPane( m_drawToolBar, EDA_PANE().VToolbar().Name( "ToolsToolbar" )
228 .Right().Layer( 2 ) );
229
230 // Center
231 m_auimgr.AddPane( GetCanvas(), wxAuiPaneInfo().Name( "DrawFrame" )
232 .CentrePane() );
233
234 FinishAUIInitialization();
235
236 // Can't put this in LoadSettings, because it has to be called before setupTools :/
237 EE_SELECTION_TOOL* selTool = GetToolManager()->GetTool<EE_SELECTION_TOOL>();
238 selTool->GetFilter() = GetSettings()->m_SelectionFilter;
239
240 if( m_settings->m_LibWidth > 0 )
241 SetAuiPaneSize( m_auimgr, m_auimgr.GetPane( "LibraryTree" ), m_settings->m_LibWidth, -1 );
242
243 Raise();
244 Show( true );
245
246 SyncView();
247 GetCanvas()->GetView()->UseDrawPriority( true );
248 GetCanvas()->GetGAL()->SetAxesEnabled( true );
249
250 setupUnits( m_settings );
251
252 // Set the working/draw area size to display a symbol to a reasonable value:
253 // A 600mm x 600mm with a origin at the area center looks like a large working area
254 double max_size_x = schIUScale.mmToIU( 600 );
255 double max_size_y = schIUScale.mmToIU( 600 );
256 BOX2D bbox;
257 bbox.SetOrigin( -max_size_x /2, -max_size_y/2 );
258 bbox.SetSize( max_size_x, max_size_y );
259 GetCanvas()->GetView()->SetBoundary( bbox );
260
261 m_toolManager->RunAction( ACTIONS::zoomFitScreen );
262
264 DragAcceptFiles( true );
265
266 KIPLATFORM::APP::SetShutdownBlockReason( this, _( "Library changes are unsaved" ) );
267
268 // Catch unhandled accelerator command characters that were no handled by the library tree
269 // panel.
270 Bind( wxEVT_CHAR, &TOOL_DISPATCHER::DispatchWxEvent, m_toolDispatcher );
271 Bind( wxEVT_CHAR_HOOK, &TOOL_DISPATCHER::DispatchWxEvent, m_toolDispatcher );
272
273 // Ensure the window is on top
274 Raise();
275
276 if( loadingCancelled )
277 ShowInfoBarWarning( _( "Symbol library loading was cancelled by user." ) );
278}
279
280
282{
283 // Shutdown all running tools
284 if( m_toolManager )
286
287 setSymWatcher( nullptr );
288
290 {
291 delete m_symbol;
292 m_symbol = nullptr;
293
294 SCH_SCREEN* screen = GetScreen();
295 delete screen;
297 }
298
299 // current screen is destroyed in EDA_DRAW_FRAME
301
302 SYMBOL_EDITOR_SETTINGS* cfg = nullptr;
303
304 try
305 {
307 }
308 catch( const std::runtime_error& e )
309 {
310 wxFAIL_MSG( e.what() );
311 }
312
313 if( cfg )
314 Pgm().GetSettingsManager().Save( cfg );
315
316 delete m_libMgr;
317}
318
319
321{
322 wxCHECK_RET( m_settings, "Call to SYMBOL_EDIT_FRAME::LoadSettings with null m_boardAdapter" );
323
325
329 GetRenderSettings()->SetDefaultFont( wxEmptyString );
330}
331
332
334{
335 wxCHECK_RET( m_settings, "Call to SYMBOL_EDIT_FRAME::LoadSettings with null m_boardAdapter" );
336
338
340
344
345 m_settings->m_LibWidth = m_treePane->GetSize().x;
346
348
350 bool prop_shown = m_auimgr.GetPane( PropertiesPaneName() ).IsShown();
352
355}
356
357
359{
360 return static_cast<APP_SETTINGS_BASE*>( GetSettings() );
361}
362
363
365{
367
368 if( GetSettings()->m_UseEeschemaColorSettings )
370 else
371 return mgr.GetColorSettings( GetSettings()->m_ColorTheme );
372}
373
374
376{
377 // Create the manager and dispatcher & route draw panel events to the dispatcher
380 GetCanvas()->GetViewControls(), GetSettings(), this );
381 m_actions = new EE_ACTIONS();
383
384 // Register tools
401
402 // Run the selection tool, it is supposed to be always active
403 m_toolManager->InvokeTool( "eeschema.InteractiveSelection" );
404
406}
407
408
410{
412
414 EDITOR_CONDITIONS cond( this );
415
416 wxASSERT( mgr );
417
418#define ENABLE( x ) ACTION_CONDITIONS().Enable( x )
419#define CHECK( x ) ACTION_CONDITIONS().Check( x )
420
421 auto haveSymbolCond =
422 [this]( const SELECTION& )
423 {
424 return m_symbol;
425 };
426
427 auto isEditableCond =
428 [this]( const SELECTION& )
429 {
430 // Only root symbols from the new s-expression libraries or the schematic
431 // are editable.
432 return IsSymbolEditable() && !IsSymbolAlias();
433 };
434
435 auto isEditableInAliasCond =
436 [this]( const SELECTION& )
437 {
438 // Less restrictive than isEditableCond
439 // Symbols fields (root symbols and aliases) from the new s-expression libraries
440 // or in the schematic are editable.
441 return IsSymbolEditable();
442 };
443
444 auto symbolModifiedCondition =
445 [this]( const SELECTION& sel )
446 {
449 };
450
451 auto libSelectedCondition =
452 [this]( const SELECTION& sel )
453 {
454 return !GetTargetLibId().GetLibNickname().empty();
455 };
456
457 auto canEditProperties =
458 [this]( const SELECTION& sel )
459 {
461 };
462
463 auto saveSymbolAsCondition =
464 [this]( const SELECTION& aSel )
465 {
466 return getTargetSymbol() != nullptr;
467 };
468
471 mgr->SetConditions( EE_ACTIONS::saveLibraryAs, ENABLE( libSelectedCondition ) );
472 mgr->SetConditions( EE_ACTIONS::saveSymbolCopyAs, ENABLE( saveSymbolAsCondition ) );
475
476 mgr->SetConditions( ACTIONS::undo, ENABLE( haveSymbolCond && cond.UndoAvailable() ) );
477 mgr->SetConditions( ACTIONS::redo, ENABLE( haveSymbolCond && cond.RedoAvailable() ) );
478 mgr->SetConditions( ACTIONS::revert, ENABLE( symbolModifiedCondition ) );
479
483 mgr->SetConditions( ACTIONS::millimetersUnits, CHECK( cond.Units( EDA_UNITS::MILLIMETRES ) ) );
484 mgr->SetConditions( ACTIONS::inchesUnits, CHECK( cond.Units( EDA_UNITS::INCHES ) ) );
485 mgr->SetConditions( ACTIONS::milsUnits, CHECK( cond.Units( EDA_UNITS::MILS ) ) );
486
487 mgr->SetConditions( ACTIONS::cut, ENABLE( isEditableCond ) );
488 mgr->SetConditions( ACTIONS::copy, ENABLE( haveSymbolCond ) );
490 mgr->SetConditions( ACTIONS::doDelete, ENABLE( isEditableCond ) );
491 mgr->SetConditions( ACTIONS::duplicate, ENABLE( isEditableCond ) );
492 mgr->SetConditions( ACTIONS::selectAll, ENABLE( haveSymbolCond ) );
493 mgr->SetConditions( ACTIONS::unselectAll, ENABLE( haveSymbolCond ) );
494
495 // These actions in symbol editor when editing alias field rotations are allowed.
496 mgr->SetConditions( EE_ACTIONS::rotateCW, ENABLE( isEditableInAliasCond ) );
497 mgr->SetConditions( EE_ACTIONS::rotateCCW, ENABLE( isEditableInAliasCond ) );
498
499 mgr->SetConditions( EE_ACTIONS::mirrorH, ENABLE( isEditableCond ) );
500 mgr->SetConditions( EE_ACTIONS::mirrorV, ENABLE( isEditableCond ) );
501
504
505 auto pinTypeCond =
506 [this]( const SELECTION& )
507 {
509 };
510
511 auto hiddenPinCond =
512 [this]( const SELECTION& )
513 {
515 };
516
517 auto hiddenFieldCond =
518 [this]( const SELECTION& )
519 {
521 };
522
523 auto showLibraryTreeCond =
524 [this]( const SELECTION& )
525 {
526 return IsLibraryTreeShown();
527 };
528
529 auto propertiesCond =
530 [this] ( const SELECTION& )
531 {
532 return m_auimgr.GetPane( PropertiesPaneName() ).IsShown();
533 };
534
537 mgr->SetConditions( ACTIONS::showLibraryTree, CHECK( showLibraryTreeCond ) );
538 mgr->SetConditions( ACTIONS::showProperties, CHECK( propertiesCond ) );
539 mgr->SetConditions( EE_ACTIONS::showHiddenPins, CHECK( hiddenPinCond ) );
540 mgr->SetConditions( EE_ACTIONS::showHiddenFields, CHECK( hiddenFieldCond ) );
541
542 auto demorganCond =
543 [this]( const SELECTION& )
544 {
545 return GetShowDeMorgan();
546 };
547
548 auto demorganStandardCond =
549 [this]( const SELECTION& )
550 {
551 return m_bodyStyle == BODY_STYLE::BASE;
552 };
553
554 auto demorganAlternateCond =
555 [this]( const SELECTION& )
556 {
557 return m_bodyStyle == BODY_STYLE::DEMORGAN;
558 };
559
560 auto multiUnitModeCond =
561 [this]( const SELECTION& )
562 {
563 return m_symbol && m_symbol->IsMulti() && !m_symbol->UnitsLocked();
564 };
565
566 auto hasMultipleUnitsCond =
567 [this]( const SELECTION& )
568 {
569 return m_symbol && m_symbol->IsMulti();
570 };
571
572 auto syncedPinsModeCond =
573 [this]( const SELECTION& )
574 {
575 return m_SyncPinEdit;
576 };
577
578 auto haveDatasheetCond =
579 [this]( const SELECTION& )
580 {
581 return m_symbol && !m_symbol->GetDatasheetField().GetText().IsEmpty();
582 };
583
584 mgr->SetConditions( EE_ACTIONS::showDatasheet, ENABLE( haveDatasheetCond ) );
585 mgr->SetConditions( EE_ACTIONS::symbolProperties, ENABLE( canEditProperties && haveSymbolCond ) );
586 mgr->SetConditions( EE_ACTIONS::runERC, ENABLE( haveSymbolCond ) );
587 mgr->SetConditions( EE_ACTIONS::pinTable, ENABLE( isEditableCond && haveSymbolCond ) );
588
590 ACTION_CONDITIONS().Enable( demorganCond ).Check( demorganStandardCond ) );
592 ACTION_CONDITIONS().Enable( demorganCond ).Check( demorganAlternateCond ) );
594 ACTION_CONDITIONS().Enable( multiUnitModeCond ).Check( syncedPinsModeCond ) );
596 ACTION_CONDITIONS().Enable( isEditableCond && hasMultipleUnitsCond ) );
597
598// Only enable a tool if the symbol is edtable
599#define EDIT_TOOL( tool ) ACTION_CONDITIONS().Enable( isEditableCond ).Check( cond.CurrentTool( tool ) )
600
612
613#undef CHECK
614#undef ENABLE
615#undef EDIT_TOOL
616}
617
618
620{
621 if( IsContentModified() )
622 {
623 SCH_EDIT_FRAME* schframe = (SCH_EDIT_FRAME*) Kiway().Player( FRAME_SCH, false );
624 wxString msg = _( "Save changes to '%s' before closing?" );
625
626 switch( UnsavedChangesDialog( this, wxString::Format( msg, m_reference ), nullptr ) )
627 {
628 case wxID_YES:
629 if( schframe && GetCurSymbol() ) // Should be always the case
631
632 break;
633
634 case wxID_NO:
635 break;
636
637 default:
638 case wxID_CANCEL:
639 return false;
640 }
641 }
642
643 if( doClose )
644 {
645 SetCurSymbol( nullptr, false );
646 UpdateTitle();
647 }
648
649 return true;
650}
651
652
653bool SYMBOL_EDIT_FRAME::canCloseWindow( wxCloseEvent& aEvent )
654{
655 // Shutdown blocks must be determined and vetoed as early as possible
657 && aEvent.GetId() == wxEVT_QUERY_END_SESSION
658 && IsContentModified() )
659 {
660 return false;
661 }
662
664 return false;
665
666 if( !saveAllLibraries( true ) )
667 return false;
668
669 // Save symbol tree column widths
670 m_libMgr->GetAdapter()->SaveSettings();
671
672 return true;
673}
674
675
677{
678 Destroy();
679}
680
681
683{
684 if( !m_unitSelectBox )
685 return;
686
687 if( m_unitSelectBox->GetCount() != 0 )
688 m_unitSelectBox->Clear();
689
690 if( !m_symbol || m_symbol->GetUnitCount() <= 1 )
691 {
692 m_unit = 1;
693 m_unitSelectBox->Append( wxEmptyString );
694 }
695 else
696 {
697 for( int i = 0; i < m_symbol->GetUnitCount(); i++ )
698 {
699 wxString unitDisplayName = m_symbol->GetUnitDisplayName( i + 1 );
700 m_unitSelectBox->Append( unitDisplayName );
701 }
702 }
703
704 // Ensure the selected unit is compatible with the number of units of the current symbol:
706 m_unit = 1;
707
708 m_unitSelectBox->SetSelection(( m_unit > 0 ) ? m_unit - 1 : 0 );
709}
710
711
713{
714 wxAuiPaneInfo& treePane = m_auimgr.GetPane( m_treePane );
715 treePane.Show( !IsLibraryTreeShown() );
717 m_auimgr.Update();
718 Refresh();
719}
720
721
723{
724 return const_cast<wxAuiManager&>( m_auimgr ).GetPane( m_treePane ).IsShown();
725}
726
727
729{
731}
732
733
735{
736 m_treePane->Freeze();
737 m_libMgr->GetAdapter()->Freeze();
738}
739
740
742{
743 m_libMgr->GetAdapter()->Thaw();
744 m_treePane->Thaw();
745}
746
747
748void SYMBOL_EDIT_FRAME::OnExitKiCad( wxCommandEvent& event )
749{
750 Kiway().OnKiCadExit();
751}
752
753
754void SYMBOL_EDIT_FRAME::OnUpdateUnitNumber( wxUpdateUIEvent& event )
755{
756 event.Enable( m_symbol && m_symbol->GetUnitCount() > 1 );
757}
758
759
760void SYMBOL_EDIT_FRAME::OnSelectUnit( wxCommandEvent& event )
761{
762 int i = event.GetSelection();
763
764 if( ( i == wxNOT_FOUND ) || ( ( i + 1 ) == m_unit ) )
765 return;
766
769
770 m_unit = i + 1;
771
773 RebuildView();
775}
776
777
779{
780 if( m_symbol )
781 {
783
784 if( row && row->GetType() == SCH_IO_MGR::ShowType( SCH_IO_MGR::SCH_LEGACY ) )
785 return true;
786 }
787
788 return false;
789}
790
791
793{
794 wxString libNickname = Prj().GetRString( PROJECT::SCH_LIBEDIT_CUR_LIB );
795
796 if( !libNickname.empty() )
797 {
798 if( !PROJECT_SCH::SchSymbolLibTable( &Prj() )->HasLibrary( libNickname ) )
799 {
800 Prj().SetRString( PROJECT::SCH_LIBEDIT_CUR_LIB, wxEmptyString );
801 libNickname = wxEmptyString;
802 }
803 }
804
805 return libNickname;
806}
807
808
809wxString SYMBOL_EDIT_FRAME::SetCurLib( const wxString& aLibNickname )
810{
811 wxString old = GetCurLib();
812
813 if( aLibNickname.empty() || !PROJECT_SCH::SchSymbolLibTable( &Prj() )->HasLibrary( aLibNickname ) )
814 Prj().SetRString( PROJECT::SCH_LIBEDIT_CUR_LIB, wxEmptyString );
815 else
817
818 return old;
819}
820
821
822void SYMBOL_EDIT_FRAME::SetCurSymbol( LIB_SYMBOL* aSymbol, bool aUpdateZoom )
823{
824 wxCHECK( m_toolManager, /* void */ );
825
827 GetCanvas()->GetView()->Clear();
828 delete m_symbol;
829
830 m_symbol = aSymbol;
831
832 // select the current symbol in the tree widget
835 else
836 GetLibTree()->Unselect();
837
838 wxString symbolName = m_symbol ? m_symbol->GetName() : wxString();
839
840 // retain in case this wxFrame is re-opened later on the same PROJECT
842
843 // Ensure synchronized pin edit can be enabled only symbols with interchangeable units
844 m_SyncPinEdit = aSymbol && aSymbol->IsRoot() && aSymbol->IsMulti() && !aSymbol->UnitsLocked();
845
847
855
856 if( aUpdateZoom )
858
859 GetCanvas()->Refresh();
860
861 WX_INFOBAR* infobar = GetInfoBar();
862
864 {
865 wxString msg;
866 msg.Printf( _( "Editing symbol %s from schematic. Saving will update the schematic "
867 "only." ), m_reference );
868
869 infobar->RemoveAllButtons();
870 infobar->ShowMessage( msg, wxICON_INFORMATION );
871 }
872 else if( IsSymbolFromLegacyLibrary() )
873 {
874 wxHyperlinkCtrl* button = new wxHyperlinkCtrl( infobar, wxID_ANY,
875 _( "Manage symbol libraries" ),
876 wxEmptyString );
877
878 button->Bind( wxEVT_COMMAND_HYPERLINK, std::function<void( wxHyperlinkEvent& aEvent )>(
879 [this]( wxHyperlinkEvent& aEvent )
880 {
882 } ) );
883
884 infobar->RemoveAllButtons();
885 infobar->AddButton( button );
886 infobar->ShowMessage( _( "Symbols in legacy libraries are not editable. Use Manage "
887 "Symbol Libraries to migrate to current format." ),
888 wxICON_INFORMATION );
889 }
890 else if( IsSymbolAlias() )
891 {
892 wxString rootSymbolName;
893
894 // Don't assume the parent symbol shared pointer is still valid.
895 if( std::shared_ptr<LIB_SYMBOL> rootSymbol = m_symbol->GetRootSymbol() )
896 rootSymbolName = rootSymbol->GetName();
897 else
898 {
899 wxCHECK( false, /* void */ );
900 }
901
902 int unit = GetUnit();
903 int bodyStyle = GetBodyStyle();
904 wxString msg;
905 wxString link;
906
907 msg.Printf( _( "Symbol %s is a derived symbol. Symbol graphics will not be editable." ),
908 UnescapeString( symbolName ) );
909
910 link.Printf( _( "Open %s" ), UnescapeString( rootSymbolName ) );
911
912 wxHyperlinkCtrl* button = new wxHyperlinkCtrl( infobar, wxID_ANY, link, wxEmptyString );
913 button->Bind( wxEVT_COMMAND_HYPERLINK, std::function<void( wxHyperlinkEvent& aEvent )>(
914 [this, rootSymbolName, unit, bodyStyle]( wxHyperlinkEvent& aEvent )
915 {
916 LoadSymbolFromCurrentLib( rootSymbolName, unit, bodyStyle );
917 } ) );
918
919 infobar->RemoveAllButtons();
920 infobar->AddButton( button );
921 infobar->ShowMessage( msg, wxICON_INFORMATION );
922 }
923 else
924 {
925 infobar->Dismiss();
926 }
927}
928
929
931{
932 wxASSERT( m_libMgr );
933 return *m_libMgr;
934}
935
936
938{
940
942 m_autoSaveRequired = true;
943
944 if( !IsSymbolFromSchematic() )
946
948
949 if( !GetTitle().StartsWith( "*" ) )
950 UpdateTitle();
951}
952
953
955{
957}
958
959
960wxString SYMBOL_EDIT_FRAME::AddLibraryFile( bool aCreateNew )
961{
962 // Select the target library table (global/project)
964
965 if( !libTable )
966 return wxEmptyString;
967
968 wxFileName fn = m_libMgr->GetUniqueLibraryName();
969
972 ( libTable == &SYMBOL_LIB_TABLE::GetGlobalLibTable() ),
974 {
975 return wxEmptyString;
976 }
977
978 wxString libName = fn.GetName();
979
980 if( libName.IsEmpty() )
981 return wxEmptyString;
982
983 if( m_libMgr->LibraryExists( libName ) )
984 {
985 DisplayError( this, wxString::Format( _( "Library '%s' already exists." ), libName ) );
986 return wxEmptyString;
987 }
988
989 if( aCreateNew )
990 {
991 if( !m_libMgr->CreateLibrary( fn.GetFullPath(), libTable ) )
992 {
993 DisplayError( this, wxString::Format( _( "Could not create the library file '%s'.\n"
994 "Make sure you have write permissions and "
995 "try again." ),
996 fn.GetFullPath() ) );
997 return wxEmptyString;
998 }
999 }
1000 else
1001 {
1002 if( !m_libMgr->AddLibrary( fn.GetFullPath(), libTable ) )
1003 {
1004 DisplayError( this, _( "Could not open the library file." ) );
1005 return wxEmptyString;
1006 }
1007 }
1008
1009 bool globalTable = ( libTable == &SYMBOL_LIB_TABLE::GetGlobalLibTable() );
1010 saveSymbolLibTables( globalTable, !globalTable );
1011
1012 std::string packet = fn.GetFullPath().ToStdString();
1014
1015 return fn.GetFullPath();
1016}
1017
1018
1019void SYMBOL_EDIT_FRAME::DdAddLibrary( wxString aLibFile )
1020{
1021 // Select the target library table (global/project)
1022 SYMBOL_LIB_TABLE* libTable = SelectSymLibTable();
1023
1024 if( !libTable )
1025 return;
1026
1027 wxFileName fn = wxFileName( aLibFile );
1028
1029 wxString libName = fn.GetName();
1030
1031 if( libName.IsEmpty() )
1032 return;
1033
1034 if( m_libMgr->LibraryExists( libName ) )
1035 {
1036 DisplayError( this, wxString::Format( _( "Library '%s' already exists." ), libName ) );
1037 return;
1038 }
1039
1040 if( !m_libMgr->AddLibrary( fn.GetFullPath(), libTable ) )
1041 {
1042 DisplayError( this, _( "Could not open the library file." ) );
1043 return;
1044 }
1045
1046 bool globalTable = ( libTable == &SYMBOL_LIB_TABLE::GetGlobalLibTable() );
1047 saveSymbolLibTables( globalTable, !globalTable );
1048
1049 std::string packet = fn.GetFullPath().ToStdString();
1051}
1052
1053
1055{
1056 return GetLibTree()->GetSelectedLibId( aUnit );
1057}
1058
1059
1061{
1062 return GetLibTree()->GetSelectionCount();
1063}
1064
1065int SYMBOL_EDIT_FRAME::GetTreeLIBIDs( std::vector<LIB_ID>& aSelection ) const
1066{
1067 return GetLibTree()->GetSelectedLibIds( aSelection );
1068}
1069
1070
1072{
1073 if( IsLibraryTreeShown() )
1074 {
1075 LIB_ID libId = GetTreeLIBID();
1076
1077 if( libId.IsValid() )
1078 return m_libMgr->GetAlias( libId.GetLibItemName(), libId.GetLibNickname() );
1079 }
1080
1081 return m_symbol;
1082}
1083
1084
1086{
1087 LIB_ID id;
1088
1089 if( IsLibraryTreeShown() )
1090 id = GetTreeLIBID();
1091
1092 if( id.GetLibNickname().empty() && m_symbol )
1093 id = m_symbol->GetLibId();
1094
1095 return id;
1096}
1097
1098
1099std::vector<LIB_ID> SYMBOL_EDIT_FRAME::GetSelectedLibIds() const
1100{
1101 std::vector<LIB_ID> ids;
1102 GetTreeLIBIDs( ids );
1103 return ids;
1104}
1105
1106
1108{
1109 return GetTargetLibId().GetLibNickname();
1110}
1111
1112
1113void SYMBOL_EDIT_FRAME::SyncLibraries( bool aShowProgress, bool aPreloadCancelled,
1114 const wxString& aForceRefresh )
1115{
1116 LIB_ID selected;
1117
1118 if( m_treePane )
1119 selected = GetLibTree()->GetSelectedLibId();
1120
1121 if( aShowProgress )
1122 {
1123 APP_PROGRESS_DIALOG progressDlg( _( "Loading Symbol Libraries" ), wxEmptyString,
1124 m_libMgr->GetAdapter()->GetLibrariesCount(), this );
1125
1126 m_libMgr->Sync( aForceRefresh,
1127 [&]( int progress, int max, const wxString& libName )
1128 {
1129 progressDlg.Update( progress, wxString::Format( _( "Loading library '%s'..." ),
1130 libName ) );
1131 } );
1132 }
1133 else if( !aPreloadCancelled )
1134 {
1135 m_libMgr->Sync( aForceRefresh,
1136 [&]( int progress, int max, const wxString& libName )
1137 {
1138 } );
1139 }
1140
1141 if( m_treePane )
1142 {
1143 wxDataViewItem found;
1144
1145 if( selected.IsValid() )
1146 {
1147 // Check if the previously selected item is still valid,
1148 // if not - it has to be unselected to prevent crash
1149 found = m_libMgr->GetAdapter()->FindItem( selected );
1150
1151 if( !found )
1152 GetLibTree()->Unselect();
1153 }
1154
1155 GetLibTree()->Regenerate( true );
1156
1157 // Try to select the parent library, in case the symbol is not found
1158 if( !found && selected.IsValid() )
1159 {
1160 selected.SetLibItemName( "" );
1161 found = m_libMgr->GetAdapter()->FindItem( selected );
1162
1163 if( found )
1164 GetLibTree()->SelectLibId( selected );
1165 }
1166
1167 // If no selection, see if there's a current symbol to centre
1168 if( !selected.IsValid() && m_symbol )
1169 {
1170 LIB_ID current( GetCurLib(), m_symbol->GetName() );
1171 GetLibTree()->CenterLibId( current );
1172 }
1173 }
1174}
1175
1176
1178{
1180}
1181
1182
1184{
1185 GetLibTree()->SelectLibId( aLibID );
1186}
1187
1188
1189void SYMBOL_EDIT_FRAME::UpdateLibraryTree( const wxDataViewItem& aTreeItem, LIB_SYMBOL* aSymbol )
1190{
1191 if( aTreeItem.IsOk() ) // Can be not found in tree if the current footprint is imported
1192 // from file therefore not yet in tree.
1193 {
1194 static_cast<LIB_TREE_NODE_ITEM*>( aTreeItem.GetID() )->Update( aSymbol );
1196 }
1197}
1198
1199
1200bool SYMBOL_EDIT_FRAME::backupFile( const wxFileName& aOriginalFile, const wxString& aBackupExt )
1201{
1202 if( aOriginalFile.FileExists() )
1203 {
1204 wxFileName backupFileName( aOriginalFile );
1205 backupFileName.SetExt( aBackupExt );
1206
1207 if( backupFileName.FileExists() )
1208 wxRemoveFile( backupFileName.GetFullPath() );
1209
1210 if( !wxCopyFile( aOriginalFile.GetFullPath(), backupFileName.GetFullPath() ) )
1211 {
1212 DisplayError( this, wxString::Format( _( "Failed to save backup to '%s'." ),
1213 backupFileName.GetFullPath() ) );
1214 return false;
1215 }
1216 }
1217
1218 return true;
1219}
1220
1221
1223{
1224 if( m_symbol && !GetCurLib().IsEmpty() && GetScreen()->IsContentModified() )
1225 m_libMgr->UpdateSymbol( m_symbol, GetCurLib() ); // UpdateSymbol() makes a copy
1226}
1227
1228
1230{
1231 // This will return the root symbol of any alias
1233 aLibId.GetLibNickname() );
1234
1235 // Now we can compare the libId of the current symbol and the root symbol
1236 return ( symbol && m_symbol && symbol->GetLibId() == m_symbol->GetLibId() );
1237}
1238
1239
1241{
1242 GetLibTree()->Unselect();
1243 SetCurLib( wxEmptyString );
1244 SetCurSymbol( nullptr, false );
1248 Refresh();
1249}
1250
1251
1252void SYMBOL_EDIT_FRAME::CommonSettingsChanged( bool aEnvVarsChanged, bool aTextVarsChanged )
1253{
1254 SCH_BASE_FRAME::CommonSettingsChanged( aEnvVarsChanged, aTextVarsChanged );
1255
1258
1262
1264
1265 if( m_symbol )
1267
1269
1271 GetCanvas()->Refresh();
1272
1274
1275 if( aEnvVarsChanged )
1276 SyncLibraries( true );
1277
1278 Layout();
1279 SendSizeEvent();
1280}
1281
1282
1284{
1285 // call my base class
1287
1288 // tooltips in toolbars
1290
1291 // For some obscure reason, the AUI manager hides the first modified pane.
1292 // So force show panes
1293 wxAuiPaneInfo& tree_pane_info = m_auimgr.GetPane( m_treePane );
1294 bool tree_shown = tree_pane_info.IsShown();
1295 tree_pane_info.Caption( _( "Libraries" ) );
1296 tree_pane_info.Show( tree_shown );
1297 m_auimgr.Update();
1298
1300
1301 // status bar
1303
1304 if( GetRenderSettings()->m_ShowPinsElectricalType )
1305 {
1307 GetCanvas()->Refresh();
1308 }
1309
1310 UpdateTitle();
1311}
1312
1313
1315{
1316 SCH_BASE_FRAME::SetScreen( aScreen );
1317
1318 // Let tools add things to the view if necessary
1319 if( m_toolManager )
1321}
1322
1323
1325{
1333
1334 // Let tools add things to the view if necessary
1335 if( m_toolManager )
1337
1339 GetCanvas()->Refresh();
1340}
1341
1342
1344{
1345 SyncLibraries( true );
1346
1347 if( m_symbol )
1348 {
1350 EE_SELECTION& selection = selectionTool->GetSelection();
1351
1352 for( SCH_ITEM& item : m_symbol->GetDrawItems() )
1353 {
1354 if( !alg::contains( selection, &item ) )
1355 item.ClearSelected();
1356 else
1357 item.SetSelected();
1358 }
1359
1361 }
1362
1363 RebuildView();
1364}
1365
1366
1367const BOX2I SYMBOL_EDIT_FRAME::GetDocumentExtents( bool aIncludeAllVisible ) const
1368{
1369 if( !m_symbol )
1370 {
1371 // Gives a reasonable drawing area size
1372 int width = schIUScale.mmToIU( 50 );
1373 int height = schIUScale.mmToIU( 30 );
1374
1375 return BOX2I( VECTOR2I( -width/2, -height/2 ), VECTOR2I( width, height ) );
1376 }
1377 else
1378 {
1379 return m_symbol->Flatten()->GetUnitBoundingBox( m_unit, m_bodyStyle );
1380 }
1381}
1382
1383
1385{
1386 static KIID lastBrightenedItemID( niluuid );
1387
1388 SCH_ITEM* lastItem = nullptr;
1389
1390 if( m_symbol )
1391 {
1392 for( SCH_PIN* pin : m_symbol->GetAllLibPins() )
1393 {
1394 if( pin->m_Uuid == lastBrightenedItemID )
1395 lastItem = pin;
1396 }
1397
1398 std::vector<SCH_FIELD*> fields;
1399 m_symbol->GetFields( fields );
1400
1401 for( SCH_FIELD* field : fields )
1402 {
1403 if( field->m_Uuid == lastBrightenedItemID )
1404 lastItem = field;
1405 }
1406 }
1407
1408 if( lastItem && lastItem != aItem )
1409 {
1410 lastItem->ClearBrightened();
1411
1412 UpdateItem( lastItem );
1413 lastBrightenedItemID = niluuid;
1414 }
1415
1416 if( aItem )
1417 {
1418 if( !aItem->IsBrightened() )
1419 {
1420 aItem->SetBrightened();
1421
1422 UpdateItem( aItem );
1423 lastBrightenedItemID = aItem->m_Uuid;
1424 }
1425
1426 FocusOnLocation( VECTOR2I( aItem->GetFocusPosition().x, -aItem->GetFocusPosition().y ) );
1427 }
1428}
1429
1430
1432{
1433 const std::string& payload = mail.GetPayload();
1434
1435 switch( mail.Command() )
1436 {
1437 case MAIL_LIB_EDIT:
1438 if( !payload.empty() )
1439 {
1440 wxString libFileName( payload );
1441 wxString libNickname;
1442 wxString msg;
1443
1445 const LIB_TABLE_ROW* libTableRow = libTable->FindRowByURI( libFileName );
1446
1447 if( !libTableRow )
1448 {
1449 msg.Printf( _( "The current configuration does not include the symbol library '%s'." ),
1450 libFileName );
1451 msg += wxS( "\n" ) + _( "Use Manage Symbol Libraries to edit the configuration." );
1452 DisplayErrorMessage( this, _( "Library not found in symbol library table." ), msg );
1453 break;
1454 }
1455
1456 libNickname = libTableRow->GetNickName();
1457
1458 if( !libTable->HasLibrary( libNickname, true ) )
1459 {
1460 msg.Printf( _( "The symbol library '%s' is not enabled in the current configuration." ),
1461 UnescapeString( libNickname ) );
1462 msg += wxS( "\n" ) + _( "Use Manage Symbol Libraries to edit the configuration." );
1463 DisplayErrorMessage( this, _( "Symbol library not enabled." ), msg );
1464 break;
1465 }
1466
1467 SetCurLib( libNickname );
1468
1469 if( m_treePane )
1470 {
1471 LIB_ID id( libNickname, wxEmptyString );
1472 GetLibTree()->SelectLibId( id );
1473 GetLibTree()->ExpandLibId( id );
1474 GetLibTree()->CenterLibId( id );
1475 }
1476 }
1477
1478 break;
1479
1480 case MAIL_RELOAD_LIB:
1481 {
1482 wxString currentLib = GetCurLib();
1484
1486
1487 // Check if the currently selected symbol library been removed or disabled.
1488 if( !currentLib.empty() && libTable && !libTable->HasLibrary( currentLib, true ) )
1489 {
1490 SetCurLib( wxEmptyString );
1491 emptyScreen();
1492 }
1493
1494 SyncLibraries( true );
1497
1498 break;
1499 }
1500
1502 {
1504 LIB_SYMBOL* symbol = GetCurSymbol();
1505
1506 wxLogTrace( "KICAD_LIB_WATCH", "Received refresh symbol request for %s",
1507 payload );
1508
1509 if( !tbl || !symbol )
1510 break;
1511
1512 wxString libName = symbol->GetLibId().GetLibNickname();
1513 const SYMBOL_LIB_TABLE_ROW* row = tbl->FindRow( libName );
1514
1515 if( !row )
1516 return;
1517
1518 wxFileName libfullname( row->GetFullURI( true ) );
1519
1520 wxFileName changedLib( mail.GetPayload() );
1521 wxLogTrace( "KICAD_LIB_WATCH",
1522 "Received refresh symbol request for %s, current symbols is %s",
1523 changedLib.GetFullPath(), libfullname.GetFullPath() );
1524
1525 if( changedLib == libfullname )
1526 {
1527 wxLogTrace( "KICAD_LIB_WATCH", "Refreshing symbol %s", symbol->GetName() );
1528
1529 SetScreen( m_dummyScreen ); // UpdateLibraryBuffer will destroy the old screen
1530 m_libMgr->UpdateLibraryBuffer( libName );
1531
1532 LIB_SYMBOL* lib_symbol = m_libMgr->GetBufferedSymbol( symbol->GetName(), libName );
1533 wxCHECK2_MSG( lib_symbol, break, wxString::Format( "Symbol %s not found in library %s",
1534 symbol->GetName(), libName ) );
1535
1536 // The buffered screen for the symbol
1537 SCH_SCREEN* symbol_screen = m_libMgr->GetScreen( lib_symbol->GetName(), libName );
1538
1539 SetScreen( symbol_screen );
1540 SetCurSymbol( new LIB_SYMBOL( *lib_symbol ), false );
1542 SetShowDeMorgan( GetCurSymbol()->HasAlternateBodyStyle() );
1543
1544 if( m_toolManager )
1546 }
1547
1548 break;
1549 }
1550
1551 default:
1552 ;
1553 }
1554}
1555
1556
1558{
1559 // switches currently used canvas ( Cairo / OpenGL):
1560 SCH_BASE_FRAME::SwitchCanvas( aCanvasType );
1561
1562 // Set options specific to symbol editor (axies are always enabled):
1563 GetCanvas()->GetGAL()->SetAxesEnabled( true );
1565}
1566
1567
1569{
1570 wxCHECK( m_libMgr, false );
1571
1572 return m_libMgr->HasModifications();
1573}
1574
1575
1577{
1578 wxCHECK( m_libMgr, false );
1579
1580 // Test if the currently edited symbol is modified
1582 return true;
1583
1584 // Test if any library has been modified
1585 for( const wxString& libName : m_libMgr->GetLibraryNames() )
1586 {
1587 if( m_libMgr->IsLibraryModified( libName ) && !m_libMgr->IsLibraryReadOnly( libName ) )
1588 return true;
1589 }
1590
1591 return false;
1592}
1593
1594
1596{
1597 if( aItemCount == 0 )
1598 return;
1599
1600 UNDO_REDO_CONTAINER& list = ( whichList == UNDO_LIST ) ? m_undoList : m_redoList;
1601
1602 if( aItemCount < 0 )
1603 {
1604 list.ClearCommandList();
1605 }
1606 else
1607 {
1608 for( int ii = 0; ii < aItemCount; ii++ )
1609 {
1610 if( list.m_CommandsList.size() == 0 )
1611 break;
1612
1613 PICKED_ITEMS_LIST* curr_cmd = list.m_CommandsList[0];
1614 list.m_CommandsList.erase( list.m_CommandsList.begin() );
1615
1616 curr_cmd->ClearListAndDeleteItems( []( EDA_ITEM* aItem )
1617 {
1618 delete aItem;
1619 } );
1620 delete curr_cmd; // Delete command
1621 }
1622 }
1623}
1624
1625
1627{
1628 return m_toolManager->GetTool<EE_SELECTION_TOOL>()->GetSelection();
1629}
1630
1631
1633{
1634 std::unique_ptr<LIB_SYMBOL> symbol = aSymbol->GetLibSymbolRef()->Flatten();
1635 wxCHECK( symbol, /* void */ );
1636
1637 // Take in account the symbol orientation and mirroring. to calculate the field
1638 // positions in symbol editor (i.e. no rotation, no mirroring)
1639 int orientation = aSymbol->GetOrientation() & ~( SYM_MIRROR_X | SYM_MIRROR_Y );
1640 int mirror = aSymbol->GetOrientation() & ( SYM_MIRROR_X | SYM_MIRROR_Y );
1641
1642 std::vector<SCH_FIELD> fullSetOfFields;
1643
1644 for( int i = 0; i < (int) aSymbol->GetFields().size(); ++i )
1645 {
1646 const SCH_FIELD& field = aSymbol->GetFields()[i];
1647 VECTOR2I pos = field.GetPosition() - aSymbol->GetPosition();
1648 SCH_FIELD libField( symbol.get(), field.GetId() );
1649
1650 if( i >= MANDATORY_FIELDS && !field.GetName( false ).IsEmpty() )
1651 libField.SetName( field.GetName( false ) );
1652
1653 libField.SetText( field.GetText() );
1654 libField.SetAttributes( field );
1655
1656 // The inverse transform is mirroring before, rotate after
1657 switch( mirror )
1658 {
1659 case SYM_MIRROR_X: pos.y = -pos.y; break;
1660 case SYM_MIRROR_Y: pos.x = -pos.x; break;
1661 default: break;
1662 }
1663
1664 switch( orientation )
1665 {
1666 case SYM_ORIENT_90:
1667 std::swap( pos.x, pos.y );
1668 pos.x = - pos.x;
1669 break;
1670 case SYM_ORIENT_270:
1671 std::swap( pos.x, pos.y );
1672 pos.y = - pos.y;
1673 break;
1674 case SYM_ORIENT_180:
1675 pos.x = - pos.x;
1676 pos.y = - pos.y;
1677 break;
1678 default:
1679 break;
1680 }
1681
1682 libField.SetPosition( pos );
1683
1684 fullSetOfFields.emplace_back( std::move( libField ) );
1685 }
1686
1687 symbol->SetFields( fullSetOfFields );
1688
1689 if( m_symbol )
1690 SetCurSymbol( nullptr, false );
1691
1693 m_schematicSymbolUUID = aSymbol->m_Uuid;
1694 m_reference = symbol->GetFieldById( REFERENCE_FIELD )->GetText();
1695 m_unit = std::max( 1, aSymbol->GetUnit() );
1696 m_bodyStyle = std::max( 1, aSymbol->GetBodyStyle() );
1697
1698 // Optimize default edit options for this symbol
1699 // Usually if units are locked, graphic items are specific to each unit
1700 // and if units are interchangeable, graphic items are common to units
1702 tools->SetDrawSpecificUnit( symbol->UnitsLocked() );
1703
1704 // The buffered screen for the symbol
1705 SCH_SCREEN* tmpScreen = new SCH_SCREEN();
1706
1707 SetScreen( tmpScreen );
1708 SetCurSymbol( symbol.release(), true );
1709 setSymWatcher( nullptr );
1710
1713
1714 if( IsLibraryTreeShown() )
1716
1717 UpdateTitle();
1719 SetShowDeMorgan( GetCurSymbol()->HasAlternateBodyStyle() );
1721
1722 // Let tools add things to the view if necessary
1723 if( m_toolManager )
1725
1727 GetCanvas()->Refresh();
1728}
1729
1730
1731bool SYMBOL_EDIT_FRAME::addLibTableEntry( const wxString& aLibFile, TABLE_SCOPE aScope )
1732{
1733 wxFileName fn = aLibFile;
1734 wxFileName libTableFileName( Prj().GetProjectPath(),
1736 wxString libNickname = fn.GetName();
1738 const ENV_VAR_MAP& envVars = Pgm().GetLocalEnvVariables();
1739
1740 if( libTable->HasLibrary( libNickname ) )
1741 {
1742 wxString tmp;
1743 int suffix = 1;
1744
1745 while( libTable->HasLibrary( libNickname ) )
1746 {
1747 tmp.Printf( "%s%d", fn.GetName(), suffix );
1748 libNickname = tmp;
1749 suffix += 1;
1750 }
1751 }
1752
1754 row->SetNickName( libNickname );
1755
1756 wxString normalizedPath = NormalizePath( aLibFile, &envVars, Prj().GetProjectPath() );
1757
1758 if( aScope == GLOBAL_LIB_TABLE )
1759 {
1761 libTableFileName = SYMBOL_LIB_TABLE::GetGlobalTableFileName();
1762
1763 // We cannot normalize against the current project path when saving to global table.
1764 normalizedPath = NormalizePath( aLibFile, &envVars, wxEmptyString );
1765 }
1766
1767 row->SetFullURI( normalizedPath );
1768
1769 wxCHECK( libTable->InsertRow( row ), false );
1770
1771 try
1772 {
1773 libTable->Save( libTableFileName.GetFullPath() );
1774 }
1775 catch( const IO_ERROR& ioe )
1776 {
1777 wxString msg = aScope == GLOBAL_LIB_TABLE ? _( "Error saving global library table." )
1778 : _( "Error saving project library table." );
1779
1780 wxMessageDialog dlg( this, msg, _( "File Save Error" ), wxOK | wxICON_ERROR );
1781 dlg.SetExtendedMessage( ioe.What() );
1782 dlg.ShowModal();
1783
1784 return false;
1785 }
1786
1787 return true;
1788}
1789
1790
1791bool SYMBOL_EDIT_FRAME::replaceLibTableEntry( const wxString& aLibNickname,
1792 const wxString& aLibFile )
1793{
1794 // Check the global library table first because checking the project library table
1795 // checks the global library table as well due to library chaining.
1796 bool isGlobalTable = true;
1797 wxFileName libTableFileName = SYMBOL_LIB_TABLE::GetGlobalTableFileName();;
1798 const ENV_VAR_MAP& envVars = Pgm().GetLocalEnvVariables();
1800 SYMBOL_LIB_TABLE_ROW* row = libTable->FindRow( aLibNickname );
1801
1802 if( !row )
1803 {
1804 libTableFileName.SetPath( Prj().GetProjectPath() );
1805 libTableFileName.SetName( SYMBOL_LIB_TABLE::GetSymbolLibTableFileName() );
1806 libTable = PROJECT_SCH::SchSymbolLibTable( &Prj() );
1807 isGlobalTable = false;
1808 row = libTable->FindRow( aLibNickname );
1809 }
1810
1811 wxCHECK( row, false );
1812
1813 wxString projectPath;
1814
1815 if( !isGlobalTable )
1816 projectPath = Prj().GetProjectPath();
1817
1818 wxString normalizedPath = NormalizePath( aLibFile, &envVars, projectPath );
1819
1820 row->SetFullURI( normalizedPath );
1821 row->SetType( "KiCad" );
1822
1823 try
1824 {
1825 libTable->Save( libTableFileName.GetFullPath() );
1826 }
1827 catch( const IO_ERROR& ioe )
1828 {
1829 wxString msg = isGlobalTable ? _( "Error saving global library table." )
1830 : _( "Error saving project library table." );
1831
1832 wxMessageDialog dlg( this, msg, _( "File Save Error" ), wxOK | wxICON_ERROR );
1833 dlg.SetExtendedMessage( ioe.What() );
1834 dlg.ShowModal();
1835
1836 return false;
1837 }
1838
1839 return true;
1840}
1841
1842
1844{
1845 return m_symbol && !m_symbol->IsRoot();
1846}
1847
1848
1850{
1852}
1853
1854
1855void SYMBOL_EDIT_FRAME::UpdateItem( EDA_ITEM* aItem, bool isAddOrDelete, bool aUpdateRtree )
1856{
1857 SCH_BASE_FRAME::UpdateItem( aItem, isAddOrDelete, aUpdateRtree );
1858
1859 if( EDA_TEXT* eda_text = dynamic_cast<EDA_TEXT*>( aItem ) )
1860 {
1861 eda_text->ClearBoundingBoxCache();
1862 eda_text->ClearRenderCache();
1863 }
1864}
1865
1866
1868{
1869 wxAuiPaneInfo& treePane = m_auimgr.GetPane( "SymbolTree" );
1870 wxAuiPaneInfo& propertiesPane = m_auimgr.GetPane( PropertiesPaneName() );
1871 wxAuiPaneInfo& selectionFilterPane = m_auimgr.GetPane( wxS( "SelectionFilter" ) );
1872
1873 // Don't give the selection filter its own visibility controls; instead show it if
1874 // anything else is visible
1875 bool showFilter = ( treePane.IsShown() && treePane.IsDocked() )
1876 || ( propertiesPane.IsShown() && propertiesPane.IsDocked() );
1877
1878 selectionFilterPane.Show( showFilter );
1879}
1880
1881
1883{
1884 // Returns the current render option for invisible fields
1886}
1887
1888
1890{
1891 // Returns the current render option for invisible pins
1893}
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:177
static TOOL_ACTION paste
Definition: actions.h:72
static TOOL_ACTION cancelInteractive
Definition: actions.h:65
static TOOL_ACTION millimetersUnits
Definition: actions.h:185
static TOOL_ACTION unselectAll
Definition: actions.h:75
static TOOL_ACTION revert
Definition: actions.h:55
static TOOL_ACTION showLibraryTree
Definition: actions.h:144
static TOOL_ACTION copy
Definition: actions.h:71
static TOOL_ACTION milsUnits
Definition: actions.h:184
static TOOL_ACTION toggleBoundingBoxes
Definition: actions.h:137
static TOOL_ACTION saveAll
Definition: actions.h:54
static TOOL_ACTION undo
Definition: actions.h:68
static TOOL_ACTION duplicate
Definition: actions.h:76
static TOOL_ACTION inchesUnits
Definition: actions.h:183
static TOOL_ACTION toggleCursorStyle
Definition: actions.h:134
static TOOL_ACTION doDelete
Definition: actions.h:77
static TOOL_ACTION selectionTool
Definition: actions.h:192
static TOOL_ACTION save
Definition: actions.h:51
static TOOL_ACTION zoomFitScreen
Definition: actions.h:126
static TOOL_ACTION redo
Definition: actions.h:69
static TOOL_ACTION deleteTool
Definition: actions.h:78
static TOOL_ACTION zoomTool
Definition: actions.h:129
static TOOL_ACTION showProperties
Definition: actions.h:206
static TOOL_ACTION cut
Definition: actions.h:70
static TOOL_ACTION ddAddLibrary
Definition: actions.h:60
static TOOL_ACTION toggleGridOverrides
Definition: actions.h:178
static TOOL_ACTION selectAll
Definition: actions.h:74
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: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:291
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:236
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:254
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 showHiddenPins
Definition: ee_actions.h:235
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: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: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
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
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:841
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: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:1462
int GetId() const
Definition: sch_field.h:133
wxString GetName(bool aUseDefaultName=true) const
Return the field name (not translated).
Definition: sch_field.cpp:1204
void SetPosition(const VECTOR2I &aPosition) override
Definition: sch_field.cpp:1442
void SetName(const wxString &aName)
Definition: sch_field.cpp:1179
void SetText(const wxString &aText) override
Definition: sch_field.cpp:1189
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: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:967
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.
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
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 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 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.
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...
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.
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: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
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: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< int32_t > VECTOR2I
Definition: vector2d.h:673
VECTOR2< double > VECTOR2D
Definition: vector2d.h:672
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.