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-2023 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>
35#include <kiface_base.h>
36#include <kiplatform/app.h>
37#include <kiway_express.h>
38#include <symbol_edit_frame.h>
40#include <lib_text.h>
42#include <paths.h>
43#include <pgm_base.h>
44#include <sch_painter.h>
45#include <sch_view.h>
47#include <symbol_lib_table.h>
48#include <tool/action_manager.h>
49#include <tool/action_toolbar.h>
50#include <tool/common_control.h>
51#include <tool/common_tools.h>
53#include <tool/picker_tool.h>
54#include <tool/selection.h>
56#include <tool/tool_manager.h>
57#include <tool/zoom_tool.h>
58#include <tools/ee_actions.h>
68#include <widgets/wx_infobar.h>
69#include <widgets/lib_tree.h>
73#include <panel_sym_lib_table.h>
74#include <string_utils.h>
75
76
78
79
80BEGIN_EVENT_TABLE( SYMBOL_EDIT_FRAME, SCH_BASE_FRAME )
82
83 // menubar commands
84 EVT_MENU( wxID_EXIT, SYMBOL_EDIT_FRAME::OnExitKiCad )
85 EVT_MENU( wxID_CLOSE, SYMBOL_EDIT_FRAME::CloseWindow )
87
88 // Update user interface elements.
90
91 // Drop files event
92 EVT_DROP_FILES( SYMBOL_EDIT_FRAME::OnDropFiles )
93
94END_EVENT_TABLE()
95
96
97SYMBOL_EDIT_FRAME::SYMBOL_EDIT_FRAME( KIWAY* aKiway, wxWindow* aParent ) :
98 SCH_BASE_FRAME( aKiway, aParent, FRAME_SCH_SYMBOL_EDITOR, _( "Library Editor" ),
99 wxDefaultPosition, wxDefaultSize, KICAD_DEFAULT_DRAWFRAME_STYLE,
101 m_unitSelectBox( nullptr ),
102 m_isSymbolFromSchematic( false )
103{
104 SetShowDeMorgan( false );
105 m_SyncPinEdit = false;
106
107 m_symbol = nullptr;
108 m_treePane = nullptr;
109 m_libMgr = nullptr;
110 m_unit = 1;
111 m_convert = 1;
112 m_aboutTitle = _HKI( "KiCad Symbol Editor" );
113
114 wxIcon icon;
115 wxIconBundle icon_bundle;
116
117 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_libedit ) );
118 icon_bundle.AddIcon( icon );
119 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_libedit_32 ) );
120 icon_bundle.AddIcon( icon );
121 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_libedit_16 ) );
122 icon_bundle.AddIcon( icon );
123
124 SetIcons( icon_bundle );
125
126 m_settings = Pgm().GetSettingsManager().GetAppSettings<SYMBOL_EDITOR_SETTINGS>();
127 LoadSettings( m_settings );
128
129 m_libMgr = new LIB_SYMBOL_LIBRARY_MANAGER( *this );
130 bool loadingCancelled = false;
131
132 {
133 // Preload libraries before using SyncLibraries the first time, as the preload is
134 // multi-threaded
135 WX_PROGRESS_REPORTER reporter( this, _( "Loading Symbol Libraries" ),
136 m_libMgr->GetLibraryCount(), true );
137 m_libMgr->Preload( reporter );
138
139 loadingCancelled = reporter.IsCancelled();
140 wxSafeYield();
141 }
142
143 SyncLibraries( false, loadingCancelled );
144 m_treePane = new SYMBOL_TREE_PANE( this, m_libMgr );
145 m_treePane->GetLibTree()->SetSortMode( (LIB_TREE_MODEL_ADAPTER::SORT_MODE) m_settings->m_LibrarySortMode );
146
147 resolveCanvasType();
148 SwitchCanvas( m_canvasType );
149
150 // Ensure axis are always drawn
151 KIGFX::GAL_DISPLAY_OPTIONS& gal_opts = GetGalDisplayOptions();
152 gal_opts.m_axesEnabled = true;
153
154 m_dummyScreen = new SCH_SCREEN();
155 SetScreen( m_dummyScreen );
156 GetScreen()->m_Center = true;
157
158 GetCanvas()->GetViewControls()->SetCrossHairCursorPosition( VECTOR2D( 0, 0 ), false );
159
160 GetRenderSettings()->LoadColors( GetColorSettings() );
161 GetRenderSettings()->m_IsSymbolEditor = true;
162 GetCanvas()->GetGAL()->SetAxesColor( m_colorSettings->GetColor( LAYER_SCHEMATIC_GRID_AXES ) );
163
164 setupTools();
165 setupUIConditions();
166
167 ReCreateMenuBar();
168 ReCreateHToolbar();
169 ReCreateVToolbar();
170 ReCreateOptToolbar();
171
172 updateTitle();
173 UpdateSymbolMsgPanelInfo();
174 RebuildSymbolUnitsList();
175
176 m_auimgr.SetManagedWindow( this );
177
178 CreateInfoBar();
179
180 // Rows; layers 4 - 6
181 m_auimgr.AddPane( m_mainToolBar, EDA_PANE().HToolbar().Name( "MainToolbar" )
182 .Top().Layer( 6 ) );
183
184 m_auimgr.AddPane( m_messagePanel, EDA_PANE().Messages().Name( "MsgPanel" )
185 .Bottom().Layer( 6 ) );
186
187 // Columns; layers 1 - 3
188 m_auimgr.AddPane( m_treePane, EDA_PANE().Palette().Name( "SymbolTree" )
189 .Left().Layer( 3 )
190 .Caption( _( "Libraries" ) )
191 .MinSize( 250, -1 ).BestSize( 250, -1 ) );
192 m_auimgr.AddPane( m_optionsToolBar, EDA_PANE().VToolbar().Name( "OptToolbar" )
193 .Left().Layer( 2 ) );
194
195 m_auimgr.AddPane( m_drawToolBar, EDA_PANE().VToolbar().Name( "ToolsToolbar" )
196 .Right().Layer( 2 ) );
197
198 // Center
199 m_auimgr.AddPane( GetCanvas(), wxAuiPaneInfo().Name( "DrawFrame" )
200 .CentrePane() );
201
202 FinishAUIInitialization();
203
204 if( m_settings->m_LibWidth > 0 )
205 {
206 wxAuiPaneInfo& treePane = m_auimgr.GetPane( "SymbolTree" );
207
208 // wxAUI hack: force width by setting MinSize() and then Fixed()
209 // thanks to ZenJu http://trac.wxwidgets.org/ticket/13180
210 treePane.MinSize( m_settings->m_LibWidth, -1 );
211 treePane.Fixed();
212 m_auimgr.Update();
213
214 // now make it resizable again
215 treePane.Resizable();
216 m_auimgr.Update();
217
218 // Note: DO NOT call m_auimgr.Update() anywhere after this; it will nuke the size
219 // back to minimum.
220 treePane.MinSize( 250, -1 );
221 }
222
223 Raise();
224 Show( true );
225
226 SyncView();
227 GetCanvas()->GetView()->UseDrawPriority( true );
228 GetCanvas()->GetGAL()->SetAxesEnabled( true );
229
230 setupUnits( m_settings );
231
232 // Set the working/draw area size to display a symbol to a reasonable value:
233 // A 600mm x 600mm with a origin at the area center looks like a large working area
234 double max_size_x = schIUScale.mmToIU( 600 );
235 double max_size_y = schIUScale.mmToIU( 600 );
236 BOX2D bbox;
237 bbox.SetOrigin( -max_size_x /2, -max_size_y/2 );
238 bbox.SetSize( max_size_x, max_size_y );
239 GetCanvas()->GetView()->SetBoundary( bbox );
240
241 m_toolManager->RunAction( ACTIONS::zoomFitScreen, true );
242
243 m_acceptedExts.emplace( KiCadSymbolLibFileExtension, &ACTIONS::ddAddLibrary );
244 DragAcceptFiles( true );
245
246 KIPLATFORM::APP::SetShutdownBlockReason( this, _( "Library changes are unsaved" ) );
247
248 // Catch unhandled accelerator command characters that were no handled by the library tree
249 // panel.
250 Bind( wxEVT_CHAR, &TOOL_DISPATCHER::DispatchWxEvent, m_toolDispatcher );
251 Bind( wxEVT_CHAR_HOOK, &TOOL_DISPATCHER::DispatchWxEvent, m_toolDispatcher );
252
253 // Ensure the window is on top
254 Raise();
255
256 if( loadingCancelled )
257 ShowInfoBarWarning( _( "Symbol library loading was cancelled by user." ) );
258}
259
260
262{
263 // Shutdown all running tools
264 if( m_toolManager )
266
267 setSymWatcher( nullptr );
268
270 {
271 delete m_symbol;
272 m_symbol = nullptr;
273
274 SCH_SCREEN* screen = GetScreen();
275 delete screen;
277 }
278
279 // current screen is destroyed in EDA_DRAW_FRAME
281
282 auto libedit = Pgm().GetSettingsManager().GetAppSettings<SYMBOL_EDITOR_SETTINGS>();
283 Pgm().GetSettingsManager().Save( libedit );
284
285 delete m_libMgr;
286}
287
288
290{
291 wxCHECK_RET( m_settings, "Call to SYMBOL_EDIT_FRAME::LoadSettings with null m_boardAdapter" );
292
294
296 GetRenderSettings()->SetDefaultFont( wxEmptyString );
297}
298
299
301{
302 wxCHECK_RET( m_settings, "Call to SYMBOL_EDIT_FRAME::LoadSettings with null m_boardAdapter" );
303
305
307
309 m_settings->m_LibWidth = m_treePane->GetSize().x;
310
312}
313
314
316{
317 return static_cast<APP_SETTINGS_BASE*>( GetSettings() );
318}
319
320
322{
323 SETTINGS_MANAGER& mgr = Pgm().GetSettingsManager();
324
325 if( GetSettings()->m_UseEeschemaColorSettings )
327 else
328 return mgr.GetColorSettings( GetSettings()->m_ColorTheme );
329}
330
331
333{
334 // Create the manager and dispatcher & route draw panel events to the dispatcher
337 GetCanvas()->GetViewControls(), GetSettings(), this );
338 m_actions = new EE_ACTIONS();
340
341 // Register tools
355
356 // Run the selection tool, it is supposed to be always active
357 m_toolManager->InvokeTool( "eeschema.InteractiveSelection" );
358
360}
361
362
364{
366
368 EDITOR_CONDITIONS cond( this );
369
370 wxASSERT( mgr );
371
372#define ENABLE( x ) ACTION_CONDITIONS().Enable( x )
373#define CHECK( x ) ACTION_CONDITIONS().Check( x )
374
375 auto haveSymbolCond =
376 [this]( const SELECTION& )
377 {
378 return m_symbol;
379 };
380
381 auto isEditableCond =
382 [this]( const SELECTION& )
383 {
384 // Only root symbols from the new s-expression libraries or the schematic
385 // are editable.
386 return IsSymbolEditable() && !IsSymbolAlias();
387 };
388
389 auto symbolModifiedCondition =
390 [this]( const SELECTION& sel )
391 {
394 };
395
396 auto libSelectedCondition =
397 [this]( const SELECTION& sel )
398 {
399 return !GetTargetLibId().GetLibNickname().empty();
400 };
401
402 auto canEditProperties =
403 [this]( const SELECTION& sel )
404 {
406 };
407
408 auto saveSymbolAsCondition =
409 [this]( const SELECTION& aSel )
410 {
411 return getTargetSymbol() != nullptr;
412 };
413
416 mgr->SetConditions( EE_ACTIONS::saveLibraryAs, ENABLE( libSelectedCondition ) );
417 mgr->SetConditions( EE_ACTIONS::saveSymbolAs, ENABLE( saveSymbolAsCondition ) );
420
421 mgr->SetConditions( ACTIONS::undo, ENABLE( haveSymbolCond && cond.UndoAvailable() ) );
422 mgr->SetConditions( ACTIONS::redo, ENABLE( haveSymbolCond && cond.RedoAvailable() ) );
423 mgr->SetConditions( ACTIONS::revert, ENABLE( symbolModifiedCondition ) );
424
427 mgr->SetConditions( ACTIONS::millimetersUnits, CHECK( cond.Units( EDA_UNITS::MILLIMETRES ) ) );
428 mgr->SetConditions( ACTIONS::inchesUnits, CHECK( cond.Units( EDA_UNITS::INCHES ) ) );
429 mgr->SetConditions( ACTIONS::milsUnits, CHECK( cond.Units( EDA_UNITS::MILS ) ) );
430
431 mgr->SetConditions( ACTIONS::cut, ENABLE( isEditableCond ) );
432 mgr->SetConditions( ACTIONS::copy, ENABLE( haveSymbolCond ) );
434 mgr->SetConditions( ACTIONS::doDelete, ENABLE( isEditableCond ) );
435 mgr->SetConditions( ACTIONS::duplicate, ENABLE( isEditableCond ) );
436 mgr->SetConditions( ACTIONS::selectAll, ENABLE( haveSymbolCond ) );
437
438 mgr->SetConditions( EE_ACTIONS::rotateCW, ENABLE( isEditableCond ) );
439 mgr->SetConditions( EE_ACTIONS::rotateCCW, ENABLE( isEditableCond ) );
440 mgr->SetConditions( EE_ACTIONS::mirrorH, ENABLE( isEditableCond ) );
441 mgr->SetConditions( EE_ACTIONS::mirrorV, ENABLE( isEditableCond ) );
442
445
446 auto pinTypeCond =
447 [this]( const SELECTION& )
448 {
450 };
451
452 auto showCompTreeCond =
453 [this]( const SELECTION& )
454 {
455 return IsSymbolTreeShown();
456 };
457
460 mgr->SetConditions( EE_ACTIONS::showSymbolTree, CHECK( showCompTreeCond ) );
461
462 auto demorganCond =
463 [this]( const SELECTION& )
464 {
465 return GetShowDeMorgan();
466 };
467
468 auto demorganStandardCond =
469 [this]( const SELECTION& )
470 {
472 };
473
474 auto demorganAlternateCond =
475 [this]( const SELECTION& )
476 {
478 };
479
480 auto multiUnitModeCond =
481 [this]( const SELECTION& )
482 {
483 return m_symbol && m_symbol->IsMulti() && !m_symbol->UnitsLocked();
484 };
485
486 auto hasMultipleUnitsCond =
487 [this]( const SELECTION& )
488 {
489 return m_symbol && m_symbol->IsMulti();
490 };
491
492 auto syncedPinsModeCond =
493 [this]( const SELECTION& )
494 {
495 return m_SyncPinEdit;
496 };
497
498 auto haveDatasheetCond =
499 [this]( const SELECTION& )
500 {
501 return m_symbol && !m_symbol->GetDatasheetField().GetText().IsEmpty();
502 };
503
504 mgr->SetConditions( EE_ACTIONS::showDatasheet, ENABLE( haveDatasheetCond ) );
505 mgr->SetConditions( EE_ACTIONS::symbolProperties, ENABLE( canEditProperties && haveSymbolCond ) );
506 mgr->SetConditions( EE_ACTIONS::runERC, ENABLE( haveSymbolCond ) );
507 mgr->SetConditions( EE_ACTIONS::pinTable, ENABLE( isEditableCond && haveSymbolCond ) );
508
510 ACTION_CONDITIONS().Enable( demorganCond ).Check( demorganStandardCond ) );
512 ACTION_CONDITIONS().Enable( demorganCond ).Check( demorganAlternateCond ) );
514 ACTION_CONDITIONS().Enable( multiUnitModeCond ).Check( syncedPinsModeCond ) );
516 ACTION_CONDITIONS().Enable( isEditableCond && hasMultipleUnitsCond ) );
517
518// Only enable a tool if the symbol is edtable
519#define EDIT_TOOL( tool ) ACTION_CONDITIONS().Enable( isEditableCond ).Check( cond.CurrentTool( tool ) )
520
531
532#undef CHECK
533#undef ENABLE
534#undef EDIT_TOOL
535}
536
537
539{
540 if( IsContentModified() )
541 {
542 SCH_EDIT_FRAME* schframe = (SCH_EDIT_FRAME*) Kiway().Player( FRAME_SCH, false );
543 wxString msg = _( "Save changes to '%s' before closing?" );
544
545 switch( UnsavedChangesDialog( this, wxString::Format( msg, m_reference ), nullptr ) )
546 {
547 case wxID_YES:
548 if( schframe && GetCurSymbol() ) // Should be always the case
550
551 break;
552
553 case wxID_NO:
554 break;
555
556 default:
557 case wxID_CANCEL:
558 return false;
559 }
560 }
561
562 if( doClose )
563 {
564 SetCurSymbol( nullptr, false );
565 updateTitle();
566 }
567
568 return true;
569}
570
571
572bool SYMBOL_EDIT_FRAME::canCloseWindow( wxCloseEvent& aEvent )
573{
574 // Shutdown blocks must be determined and vetoed as early as possible
576 && aEvent.GetId() == wxEVT_QUERY_END_SESSION
577 && IsContentModified() )
578 {
579 return false;
580 }
581
583 return false;
584
585 if( !saveAllLibraries( true ) )
586 return false;
587
588 // Save symbol tree column widths
589 m_libMgr->GetAdapter()->SaveSettings();
590
591 return true;
592}
593
594
596{
597 Destroy();
598}
599
600
602{
603 if( !m_unitSelectBox )
604 return;
605
606 if( m_unitSelectBox->GetCount() != 0 )
607 m_unitSelectBox->Clear();
608
609 if( !m_symbol || m_symbol->GetUnitCount() <= 1 )
610 {
611 m_unit = 1;
612 m_unitSelectBox->Append( wxEmptyString );
613 }
614 else
615 {
616 for( int i = 0; i < m_symbol->GetUnitCount(); i++ )
617 {
618 wxString unitDisplayName = m_symbol->GetUnitDisplayName( i + 1 );
619 m_unitSelectBox->Append( unitDisplayName );
620 }
621 }
622
623 // Ensure the selected unit is compatible with the number of units of the current symbol:
625 m_unit = 1;
626
627 m_unitSelectBox->SetSelection(( m_unit > 0 ) ? m_unit - 1 : 0 );
628}
629
630
631void SYMBOL_EDIT_FRAME::OnToggleSymbolTree( wxCommandEvent& event )
632{
633 wxAuiPaneInfo& treePane = m_auimgr.GetPane( m_treePane );
634 treePane.Show( !IsSymbolTreeShown() );
635 m_auimgr.Update();
636}
637
638
640{
641 return const_cast<wxAuiManager&>( m_auimgr ).GetPane( m_treePane ).IsShown();
642}
643
644
646{
647 m_treePane->Freeze();
648 m_libMgr->GetAdapter()->Freeze();
649}
650
651
653{
654 m_libMgr->GetAdapter()->Thaw();
655 m_treePane->Thaw();
656}
657
658
659void SYMBOL_EDIT_FRAME::OnExitKiCad( wxCommandEvent& event )
660{
661 Kiway().OnKiCadExit();
662}
663
664
665void SYMBOL_EDIT_FRAME::OnUpdateUnitNumber( wxUpdateUIEvent& event )
666{
667 event.Enable( m_symbol && m_symbol->GetUnitCount() > 1 );
668}
669
670
671void SYMBOL_EDIT_FRAME::OnSelectUnit( wxCommandEvent& event )
672{
673 int i = event.GetSelection();
674
675 if( ( i == wxNOT_FOUND ) || ( ( i + 1 ) == m_unit ) )
676 return;
677
680
681 m_unit = i + 1;
682
684 RebuildView();
686}
687
688
690{
691 if( m_symbol )
692 {
694
695 if( row && row->GetType() == SCH_IO_MGR::ShowType( SCH_IO_MGR::SCH_LEGACY ) )
696 return true;
697 }
698
699 return false;
700}
701
702
704{
705 wxString libNickname = Prj().GetRString( PROJECT::SCH_LIBEDIT_CUR_LIB );
706
707 if( !libNickname.empty() )
708 {
709 if( !Prj().SchSymbolLibTable()->HasLibrary( libNickname ) )
710 {
711 Prj().SetRString( PROJECT::SCH_LIBEDIT_CUR_LIB, wxEmptyString );
712 libNickname = wxEmptyString;
713 }
714 }
715
716 return libNickname;
717}
718
719
720wxString SYMBOL_EDIT_FRAME::SetCurLib( const wxString& aLibNickname )
721{
722 wxString old = GetCurLib();
723
724 if( aLibNickname.empty() || !Prj().SchSymbolLibTable()->HasLibrary( aLibNickname ) )
725 Prj().SetRString( PROJECT::SCH_LIBEDIT_CUR_LIB, wxEmptyString );
726 else
728
729 return old;
730}
731
732
733void SYMBOL_EDIT_FRAME::SetCurSymbol( LIB_SYMBOL* aSymbol, bool aUpdateZoom )
734{
736 GetCanvas()->GetView()->Clear();
737 delete m_symbol;
738
739 m_symbol = aSymbol;
740
741 // select the current symbol in the tree widget
744 else
746
747 wxString symbolName = m_symbol ? m_symbol->GetName() : wxString();
748
749 // retain in case this wxFrame is re-opened later on the same PROJECT
751
752 // Ensure synchronized pin edit can be enabled only symbols with interchangeable units
753 m_SyncPinEdit = aSymbol && aSymbol->IsRoot() && aSymbol->IsMulti() && !aSymbol->UnitsLocked();
754
756
764
765 if( aUpdateZoom )
767
768 GetCanvas()->Refresh();
769
770 WX_INFOBAR* infobar = GetInfoBar();
771
773 {
774 wxString msg;
775 msg.Printf( _( "Editing symbol %s from schematic. Saving will update the schematic "
776 "only." ), m_reference );
777
778 infobar->RemoveAllButtons();
779 infobar->ShowMessage( msg, wxICON_INFORMATION );
780 }
781 else if( IsSymbolFromLegacyLibrary() )
782 {
783 wxHyperlinkCtrl* button = new wxHyperlinkCtrl( infobar, wxID_ANY,
784 _( "Manage symbol libraries" ),
785 wxEmptyString );
786
787 button->Bind( wxEVT_COMMAND_HYPERLINK, std::function<void( wxHyperlinkEvent& aEvent )>(
788 [=]( wxHyperlinkEvent& aEvent )
789 {
791 } ) );
792
793 infobar->RemoveAllButtons();
794 infobar->AddButton( button );
795 infobar->ShowMessage( _( "Symbols in legacy libraries are not editable. Use Manage "
796 "Symbol Libraries to migrate to current format." ),
797 wxICON_INFORMATION );
798 }
799 else if( IsSymbolAlias() )
800 {
801 std::shared_ptr<LIB_SYMBOL> parent = m_symbol->GetParent().lock();
802
803 // Don't assume the parent symbol shared pointer is still valid.
804 wxCHECK( parent, /* void */ );
805
806 wxString parentSymbolName = parent->GetName();
807 int unit = GetUnit();
808 int convert = GetConvert();
809 wxString msg;
810 wxString link;
811
812 msg.Printf( _( "Symbol %s is derived from %s. Symbol graphics will not be editable." ),
813 UnescapeString( symbolName ),
814 UnescapeString( parentSymbolName ) );
815
816 link.Printf( _( "Open %s" ), UnescapeString( parentSymbolName ) );
817
818 wxHyperlinkCtrl* button = new wxHyperlinkCtrl( infobar, wxID_ANY, link, wxEmptyString );
819 button->Bind( wxEVT_COMMAND_HYPERLINK, std::function<void( wxHyperlinkEvent& aEvent )>(
820 [=]( wxHyperlinkEvent& aEvent )
821 {
822 LoadSymbolFromCurrentLib( parentSymbolName, unit, convert );
823 } ) );
824
825 infobar->RemoveAllButtons();
826 infobar->AddButton( button );
827 infobar->ShowMessage( msg, wxICON_INFORMATION );
828 }
829 else
830 {
831 infobar->Dismiss();
832 }
833}
834
835
837{
838 wxASSERT( m_libMgr );
839 return *m_libMgr;
840}
841
842
844{
846
848 m_autoSaveRequired = true;
849
850 if( !IsSymbolFromSchematic() )
852
854
855 if( !GetTitle().StartsWith( "*" ) )
856 updateTitle();
857}
858
859
861{
863}
864
865
866wxString SYMBOL_EDIT_FRAME::AddLibraryFile( bool aCreateNew )
867{
868 // Select the target library table (global/project)
870
871 if( !libTable )
872 return wxEmptyString;
873
874 wxFileName fn = m_libMgr->GetUniqueLibraryName();
875
876 if( !LibraryFileBrowser( !aCreateNew, fn, KiCadSymbolLibFileWildcard(),
878 ( libTable == &SYMBOL_LIB_TABLE::GetGlobalLibTable() ),
880 {
881 return wxEmptyString;
882 }
883
884 wxString libName = fn.GetName();
885
886 if( libName.IsEmpty() )
887 return wxEmptyString;
888
889 if( m_libMgr->LibraryExists( libName ) )
890 {
891 DisplayError( this, wxString::Format( _( "Library '%s' already exists." ), libName ) );
892 return wxEmptyString;
893 }
894
895 if( aCreateNew )
896 {
897 if( !m_libMgr->CreateLibrary( fn.GetFullPath(), libTable ) )
898 {
899 DisplayError( this, wxString::Format( _( "Could not create the library file '%s'.\n"
900 "Make sure you have write permissions and "
901 "try again." ),
902 fn.GetFullPath() ) );
903 return wxEmptyString;
904 }
905 }
906 else
907 {
908 if( !m_libMgr->AddLibrary( fn.GetFullPath(), libTable ) )
909 {
910 DisplayError( this, _( "Could not open the library file." ) );
911 return wxEmptyString;
912 }
913 }
914
915 bool globalTable = ( libTable == &SYMBOL_LIB_TABLE::GetGlobalLibTable() );
916 saveSymbolLibTables( globalTable, !globalTable );
917
918 std::string packet = fn.GetFullPath().ToStdString();
920
921 return fn.GetFullPath();
922}
923
924
925void SYMBOL_EDIT_FRAME::DdAddLibrary( wxString aLibFile )
926{
927 // Select the target library table (global/project)
929
930 if( !libTable )
931 return;
932
933 wxFileName fn = wxFileName( aLibFile );
934
935 wxString libName = fn.GetName();
936
937 if( libName.IsEmpty() )
938 return;
939
940 if( m_libMgr->LibraryExists( libName ) )
941 {
942 DisplayError( this, wxString::Format( _( "Library '%s' already exists." ), libName ) );
943 return;
944 }
945
946 if( !m_libMgr->AddLibrary( fn.GetFullPath(), libTable ) )
947 {
948 DisplayError( this, _( "Could not open the library file." ) );
949 return;
950 }
951
952 bool globalTable = ( libTable == &SYMBOL_LIB_TABLE::GetGlobalLibTable() );
953 saveSymbolLibTables( globalTable, !globalTable );
954
955 std::string packet = fn.GetFullPath().ToStdString();
957}
958
959
961{
962 return m_treePane->GetLibTree()->GetSelectedLibId( aUnit );
963}
964
965
967{
969}
970
971int SYMBOL_EDIT_FRAME::GetTreeLIBIDs( std::vector<LIB_ID>& aSelection ) const
972{
973 return m_treePane->GetLibTree()->GetSelectedLibIds( aSelection );
974}
975
976
978{
979 if( IsSymbolTreeShown() )
980 {
981 LIB_ID libId = GetTreeLIBID();
982
983 if( libId.IsValid() )
984 return m_libMgr->GetAlias( libId.GetLibItemName(), libId.GetLibNickname() );
985 }
986
987 return m_symbol;
988}
989
990
992{
993 LIB_ID id;
994
995 if( IsSymbolTreeShown() )
996 id = GetTreeLIBID();
997
998 if( id.GetLibNickname().empty() && m_symbol )
999 id = m_symbol->GetLibId();
1000
1001 return id;
1002}
1003
1004
1005std::vector<LIB_ID> SYMBOL_EDIT_FRAME::GetSelectedLibIds() const
1006{
1007 std::vector<LIB_ID> ids;
1008 GetTreeLIBIDs( ids );
1009 return ids;
1010}
1011
1012
1014{
1016}
1017
1018
1020{
1021 return GetTargetLibId().GetLibNickname();
1022}
1023
1024
1025void SYMBOL_EDIT_FRAME::SyncLibraries( bool aShowProgress, bool aPreloadCancelled,
1026 const wxString& aForceRefresh )
1027{
1028 LIB_ID selected;
1029
1030 if( m_treePane )
1031 selected = m_treePane->GetLibTree()->GetSelectedLibId();
1032
1033 if( aShowProgress )
1034 {
1035 APP_PROGRESS_DIALOG progressDlg( _( "Loading Symbol Libraries" ), wxEmptyString,
1036 m_libMgr->GetAdapter()->GetLibrariesCount(), this );
1037
1038 m_libMgr->Sync( aForceRefresh,
1039 [&]( int progress, int max, const wxString& libName )
1040 {
1041 progressDlg.Update( progress, wxString::Format( _( "Loading library '%s'..." ),
1042 libName ) );
1043 } );
1044 }
1045 else if( !aPreloadCancelled )
1046 {
1047 m_libMgr->Sync( aForceRefresh,
1048 [&]( int progress, int max, const wxString& libName )
1049 {
1050 } );
1051 }
1052
1053 if( m_treePane )
1054 {
1055 wxDataViewItem found;
1056
1057 if( selected.IsValid() )
1058 {
1059 // Check if the previously selected item is still valid,
1060 // if not - it has to be unselected to prevent crash
1061 found = m_libMgr->GetAdapter()->FindItem( selected );
1062
1063 if( !found )
1065 }
1066
1067 m_treePane->GetLibTree()->Regenerate( true );
1068
1069 // Try to select the parent library, in case the symbol is not found
1070 if( !found && selected.IsValid() )
1071 {
1072 selected.SetLibItemName( "" );
1073 found = m_libMgr->GetAdapter()->FindItem( selected );
1074
1075 if( found )
1076 m_treePane->GetLibTree()->SelectLibId( selected );
1077 }
1078
1079 // If no selection, see if there's a current symbol to centre
1080 if( !selected.IsValid() && m_symbol )
1081 {
1082 LIB_ID current( GetCurLib(), m_symbol->GetName() );
1083 m_treePane->GetLibTree()->CenterLibId( current );
1084 }
1085 }
1086}
1087
1088
1090{
1091 LIB_ID target = GetTargetLibId();
1092
1093 m_treePane->GetLibTree()->Regenerate( true );
1094
1095 if( target.IsValid() )
1096 m_treePane->GetLibTree()->CenterLibId( target );
1097}
1098
1099
1101{
1103}
1104
1105
1107{
1108 m_treePane->GetLibTree()->SelectLibId( aLibID );
1109}
1110
1111
1112void SYMBOL_EDIT_FRAME::UpdateLibraryTree( const wxDataViewItem& aTreeItem, LIB_SYMBOL* aSymbol )
1113{
1114 if( aTreeItem.IsOk() ) // Can be not found in tree if the current footprint is imported
1115 // from file therefore not yet in tree.
1116 {
1117 static_cast<LIB_TREE_NODE_LIB_ID*>( aTreeItem.GetID() )->Update( aSymbol );
1119 }
1120}
1121
1122
1123bool SYMBOL_EDIT_FRAME::backupFile( const wxFileName& aOriginalFile, const wxString& aBackupExt )
1124{
1125 if( aOriginalFile.FileExists() )
1126 {
1127 wxFileName backupFileName( aOriginalFile );
1128 backupFileName.SetExt( aBackupExt );
1129
1130 if( backupFileName.FileExists() )
1131 wxRemoveFile( backupFileName.GetFullPath() );
1132
1133 if( !wxCopyFile( aOriginalFile.GetFullPath(), backupFileName.GetFullPath() ) )
1134 {
1135 DisplayError( this, wxString::Format( _( "Failed to save backup to '%s'." ),
1136 backupFileName.GetFullPath() ) );
1137 return false;
1138 }
1139 }
1140
1141 return true;
1142}
1143
1144
1146{
1147 if( m_symbol && !GetCurLib().IsEmpty() && GetScreen()->IsContentModified() )
1148 m_libMgr->UpdateSymbol( m_symbol, GetCurLib() ); // UpdateSymbol() makes a copy
1149}
1150
1151
1153{
1154 // This will return the root symbol of any alias
1156 aLibId.GetLibNickname() );
1157
1158 // Now we can compare the libId of the current symbol and the root symbol
1159 return ( symbol && m_symbol && symbol->GetLibId() == m_symbol->GetLibId() );
1160}
1161
1162
1164{
1166 SetCurLib( wxEmptyString );
1167 SetCurSymbol( nullptr, false );
1171 Refresh();
1172}
1173
1174
1175void SYMBOL_EDIT_FRAME::CommonSettingsChanged( bool aEnvVarsChanged, bool aTextVarsChanged )
1176{
1177 SCH_BASE_FRAME::CommonSettingsChanged( aEnvVarsChanged, aTextVarsChanged );
1178
1181
1183
1185
1186 if( m_symbol )
1188
1190
1192 GetCanvas()->Refresh();
1193
1195
1196 if( aEnvVarsChanged )
1197 SyncLibraries( true );
1198
1199 Layout();
1200 SendSizeEvent();
1201}
1202
1203
1205{
1206 // call my base class
1208
1209 // tooltips in toolbars
1211
1212 // For some obscure reason, the AUI manager hides the first modified pane.
1213 // So force show panes
1214 wxAuiPaneInfo& tree_pane_info = m_auimgr.GetPane( m_treePane );
1215 bool tree_shown = tree_pane_info.IsShown();
1216 tree_pane_info.Caption( _( "Libraries" ) );
1217 tree_pane_info.Show( tree_shown );
1218 m_auimgr.Update();
1219
1221
1222 // status bar
1224
1225 if( GetRenderSettings()->m_ShowPinsElectricalType )
1226 {
1228 GetCanvas()->Refresh();
1229 }
1230
1231 updateTitle();
1232}
1233
1234
1236{
1237 SCH_BASE_FRAME::SetScreen( aScreen );
1238
1239 // Let tools add things to the view if necessary
1240 if( m_toolManager )
1242}
1243
1244
1246{
1254
1255 // Let tools add things to the view if necessary
1256 if( m_toolManager )
1258
1260 GetCanvas()->Refresh();
1261}
1262
1263
1265{
1266 SyncLibraries( true );
1267
1268 if( m_symbol )
1269 {
1271 EE_SELECTION& selection = selectionTool->GetSelection();
1272
1273 for( LIB_ITEM& item : m_symbol->GetDrawItems() )
1274 {
1275 if( !alg::contains( selection, &item ) )
1276 item.ClearSelected();
1277 else
1278 item.SetSelected();
1279 }
1280
1282 }
1283
1284 RebuildView();
1285}
1286
1287
1288const BOX2I SYMBOL_EDIT_FRAME::GetDocumentExtents( bool aIncludeAllVisible ) const
1289{
1290 if( !m_symbol )
1291 {
1292 // Gives a reasonable drawing area size
1293 int width = schIUScale.mmToIU( 50 );
1294 int height = schIUScale.mmToIU( 30 );
1295
1296 return BOX2I( VECTOR2I( -width/2, -height/2 ),
1297 VECTOR2I( width, height ) );
1298 }
1299 else
1300 {
1301 return m_symbol->Flatten()->GetUnitBoundingBox( m_unit, m_convert );
1302 }
1303}
1304
1305
1307{
1308 const std::string& payload = mail.GetPayload();
1309
1310 switch( mail.Command() )
1311 {
1312 case MAIL_LIB_EDIT:
1313 if( !payload.empty() )
1314 {
1315 wxString libFileName( payload );
1316 wxString libNickname;
1317 wxString msg;
1318
1319 SYMBOL_LIB_TABLE* libTable = Prj().SchSymbolLibTable();
1320 const LIB_TABLE_ROW* libTableRow = libTable->FindRowByURI( libFileName );
1321
1322 if( !libTableRow )
1323 {
1324 msg.Printf( _( "The current configuration does not include the library '%s'.\n"
1325 "Use Manage Symbol Libraries to edit the configuration." ),
1326 libFileName );
1327 DisplayErrorMessage( this, _( "Library not found in symbol library table." ), msg );
1328 break;
1329 }
1330
1331 libNickname = libTableRow->GetNickName();
1332
1333 if( !libTable->HasLibrary( libNickname, true ) )
1334 {
1335 msg.Printf( _( "The library '%s' is not enabled in the current configuration.\n"
1336 "Use Manage Symbol Libraries to edit the configuration." ),
1337 UnescapeString( libNickname ) );
1338 DisplayErrorMessage( this, _( "Symbol library not enabled." ), msg );
1339 break;
1340 }
1341
1342 SetCurLib( libNickname );
1343
1344 if( m_treePane )
1345 {
1346 LIB_ID id( libNickname, wxEmptyString );
1350 }
1351 }
1352
1353 break;
1354
1355 case MAIL_RELOAD_LIB:
1356 {
1357 wxString currentLib = GetCurLib();
1358 SYMBOL_LIB_TABLE* libTable = Prj().SchSymbolLibTable();
1359
1361
1362 // Check if the currently selected symbol library been removed or disabled.
1363 if( !currentLib.empty() && libTable && !libTable->HasLibrary( currentLib, true ) )
1364 {
1365 SetCurLib( wxEmptyString );
1366 emptyScreen();
1367 }
1368
1369 SyncLibraries( true );
1372
1373 break;
1374 }
1375
1377 {
1378 SYMBOL_LIB_TABLE* tbl = Prj().SchSymbolLibTable();
1379 LIB_SYMBOL* symbol = GetCurSymbol();
1380
1381 wxLogTrace( "KICAD_LIB_WATCH", "Received refresh symbol request for %s",
1382 payload );
1383
1384 if( !tbl || !symbol )
1385 break;
1386
1387 wxString libName = symbol->GetLibId().GetLibNickname();
1388 const SYMBOL_LIB_TABLE_ROW* row = tbl->FindRow( libName );
1389
1390 if( !row )
1391 return;
1392
1393 wxFileName libfullname( row->GetFullURI( true ) );
1394
1395 wxFileName changedLib( mail.GetPayload() );
1396 wxLogTrace( "KICAD_LIB_WATCH",
1397 "Received refresh symbol request for %s, current symbols is %s",
1398 changedLib.GetFullPath(), libfullname.GetFullPath() );
1399
1400 if( changedLib == libfullname )
1401 {
1402 wxLogTrace( "KICAD_LIB_WATCH", "Refreshing symbol %s", symbol->GetName() );
1403
1404 m_libMgr->UpdateLibraryBuffer( libName );
1405
1406 LIB_SYMBOL* lib_symbol = m_libMgr->GetBufferedSymbol( symbol->GetName(), libName );
1407 wxCHECK2_MSG( lib_symbol, break, wxString::Format( "Symbol %s not found in library %s",
1408 symbol->GetName(), libName ) );
1409
1410 // The buffered screen for the symbol
1411 SCH_SCREEN* symbol_screen = m_libMgr->GetScreen( lib_symbol->GetName(), libName );
1412
1413 SetScreen( symbol_screen );
1414 SetCurSymbol( new LIB_SYMBOL( *lib_symbol ), false );
1416 SetShowDeMorgan( GetCurSymbol()->HasConversion() );
1417 }
1418
1419 break;
1420 }
1421
1422 default:
1423 ;
1424 }
1425}
1426
1427
1429{
1430 // switches currently used canvas ( Cairo / OpenGL):
1431 SCH_BASE_FRAME::SwitchCanvas( aCanvasType );
1432
1433 // Set options specific to symbol editor (axies are always enabled):
1434 GetCanvas()->GetGAL()->SetAxesEnabled( true );
1436}
1437
1438
1440{
1441 wxCHECK( m_libMgr, false );
1442
1443 return m_libMgr->HasModifications();
1444}
1445
1446
1448{
1449 wxCHECK( m_libMgr, false );
1450
1451 // Test if the currently edited symbol is modified
1453 return true;
1454
1455 // Test if any library has been modified
1456 for( const wxString& libName : m_libMgr->GetLibraryNames() )
1457 {
1458 if( m_libMgr->IsLibraryModified( libName ) && !m_libMgr->IsLibraryReadOnly( libName ) )
1459 return true;
1460 }
1461
1462 return false;
1463}
1464
1465
1467{
1468 if( aItemCount == 0 )
1469 return;
1470
1471 UNDO_REDO_CONTAINER& list = whichList == UNDO_LIST ? m_undoList : m_redoList;
1472
1473 for( PICKED_ITEMS_LIST* command : list.m_CommandsList )
1474 {
1475 command->ClearListAndDeleteItems( []( EDA_ITEM* aItem )
1476 {
1477 delete aItem;
1478 } );
1479 delete command;
1480 }
1481
1482 list.m_CommandsList.clear();
1483}
1484
1485
1487{
1488 return m_toolManager->GetTool<EE_SELECTION_TOOL>()->GetSelection();
1489}
1490
1491
1493{
1494 std::unique_ptr<LIB_SYMBOL> symbol = aSymbol->GetLibSymbolRef()->Flatten();
1495 wxCHECK( symbol, /* void */ );
1496
1497 // Take in account the symbol orientation and mirroring. to calculate the field
1498 // positions in symbol editor (i.e. no rotation, no mirroring)
1499 int orientation = aSymbol->GetOrientation() & ~( SYM_MIRROR_X | SYM_MIRROR_Y );
1500 int mirror = aSymbol->GetOrientation() & ( SYM_MIRROR_X | SYM_MIRROR_Y );
1501
1502 std::vector<LIB_FIELD> fullSetOfFields;
1503
1504 for( int i = 0; i < (int) aSymbol->GetFields().size(); ++i )
1505 {
1506 const SCH_FIELD& field = aSymbol->GetFields()[i];
1507 VECTOR2I pos = field.GetPosition() - aSymbol->GetPosition();
1508 LIB_FIELD libField( symbol.get(), field.GetId() );
1509
1510 if( i >= MANDATORY_FIELDS && !field.GetName( false ).IsEmpty() )
1511 libField.SetName( field.GetName( false ) );
1512
1513 libField.SetText( field.GetText() );
1514 libField.SetAttributes( field );
1515
1516 // The inverse transform is mirroring before, rotate after
1517 switch( mirror )
1518 {
1519 default:; break;
1520 case SYM_MIRROR_X: pos.y = -pos.y; break;
1521 case SYM_MIRROR_Y: pos.x = -pos.x; break;
1522 }
1523
1524 switch( orientation )
1525 {
1526 default:
1527 case SYM_ORIENT_0: break;
1528 case SYM_ORIENT_90:
1529 std::swap( pos.x, pos.y );
1530 pos.x = - pos.x;
1531 break;
1532 case SYM_ORIENT_270:
1533 std::swap( pos.x, pos.y );
1534 pos.y = - pos.y;
1535 break;
1536 case SYM_ORIENT_180:
1537 pos.x = - pos.x;
1538 pos.y = - pos.y;
1539 break;
1540 }
1541
1542 libField.SetPosition( VECTOR2I( pos.x, -pos.y ) );
1543
1544 fullSetOfFields.emplace_back( std::move( libField ) );
1545 }
1546
1547 symbol->SetFields( fullSetOfFields );
1548
1549 if( m_symbol )
1550 SetCurSymbol( nullptr, false );
1551
1553 m_schematicSymbolUUID = aSymbol->m_Uuid;
1554 m_reference = symbol->GetFieldById( REFERENCE_FIELD )->GetText();
1555 m_unit = std::max( 1, aSymbol->GetUnit() );
1556 m_convert = std::max( 1, aSymbol->GetConvert() );
1557
1558 // Optimize default edit options for this symbol
1559 // Usually if units are locked, graphic items are specific to each unit
1560 // and if units are interchangeable, graphic items are common to units
1562 tools->SetDrawSpecificUnit( symbol->UnitsLocked() );
1563
1564 // The buffered screen for the symbol
1565 SCH_SCREEN* tmpScreen = new SCH_SCREEN();
1566
1567 SetScreen( tmpScreen );
1568 SetCurSymbol( symbol.release(), true );
1569 setSymWatcher( nullptr );
1570
1573
1574 if( IsSymbolTreeShown() )
1575 {
1576 wxCommandEvent evt;
1577 OnToggleSymbolTree( evt );
1578 }
1579
1580 updateTitle();
1582 SetShowDeMorgan( GetCurSymbol()->HasConversion() );
1584
1585 // Let tools add things to the view if necessary
1586 if( m_toolManager )
1588
1590 GetCanvas()->Refresh();
1591}
1592
1593
1594bool SYMBOL_EDIT_FRAME::addLibTableEntry( const wxString& aLibFile, TABLE_SCOPE aScope )
1595{
1596 wxFileName fn = aLibFile;
1597 wxFileName libTableFileName( Prj().GetProjectPath(),
1599 wxString libNickname = fn.GetName();
1600 SYMBOL_LIB_TABLE* libTable = Prj().SchSymbolLibTable();
1601 const ENV_VAR_MAP& envVars = Pgm().GetLocalEnvVariables();
1602
1603 if( libTable->HasLibrary( libNickname ) )
1604 {
1605 wxString tmp;
1606 int suffix = 1;
1607
1608 while( libTable->HasLibrary( libNickname ) )
1609 {
1610 tmp.Printf( "%s%d", fn.GetName(), suffix );
1611 libNickname = tmp;
1612 suffix += 1;
1613 }
1614 }
1615
1617 row->SetNickName( libNickname );
1618
1619 wxString normalizedPath = NormalizePath( aLibFile, &envVars, Prj().GetProjectPath() );
1620
1621 if( aScope == GLOBAL_LIB_TABLE )
1622 {
1624 libTableFileName = SYMBOL_LIB_TABLE::GetGlobalTableFileName();
1625
1626 // We cannot normalize against the current project path when saving to global table.
1627 normalizedPath = NormalizePath( aLibFile, &envVars, wxEmptyString );
1628 }
1629
1630 row->SetFullURI( normalizedPath );
1631
1632 wxCHECK( libTable->InsertRow( row ), false );
1633
1634 try
1635 {
1636 libTable->Save( libTableFileName.GetFullPath() );
1637 }
1638 catch( const IO_ERROR& ioe )
1639 {
1640 wxString msg = aScope == GLOBAL_LIB_TABLE ? _( "Error saving global library table." )
1641 : _( "Error saving project library table." );
1642
1643 wxMessageDialog dlg( this, msg, _( "File Save Error" ), wxOK | wxICON_ERROR );
1644 dlg.SetExtendedMessage( ioe.What() );
1645 dlg.ShowModal();
1646
1647 return false;
1648 }
1649
1650 return true;
1651}
1652
1653
1654bool SYMBOL_EDIT_FRAME::replaceLibTableEntry( const wxString& aLibNickname,
1655 const wxString& aLibFile )
1656{
1657 // Check the global library table first because checking the project library table
1658 // checks the global library table as well due to library chaining.
1659 bool isGlobalTable = true;
1660 wxFileName libTableFileName = SYMBOL_LIB_TABLE::GetGlobalTableFileName();;
1661 const ENV_VAR_MAP& envVars = Pgm().GetLocalEnvVariables();
1663 SYMBOL_LIB_TABLE_ROW* row = libTable->FindRow( aLibNickname );
1664
1665 if( !row )
1666 {
1667 libTableFileName.SetPath( Prj().GetProjectPath() );
1668 libTableFileName.SetName( SYMBOL_LIB_TABLE::GetSymbolLibTableFileName() );
1669 libTable = Prj().SchSymbolLibTable();
1670 isGlobalTable = false;
1671 row = libTable->FindRow( aLibNickname );
1672 }
1673
1674 wxCHECK( row, false );
1675
1676 wxString projectPath;
1677
1678 if( !isGlobalTable )
1679 projectPath = Prj().GetProjectPath();
1680
1681 wxString normalizedPath = NormalizePath( aLibFile, &envVars, projectPath );
1682
1683 row->SetFullURI( normalizedPath );
1684 row->SetType( "KiCad" );
1685
1686 try
1687 {
1688 libTable->Save( libTableFileName.GetFullPath() );
1689 }
1690 catch( const IO_ERROR& ioe )
1691 {
1692 wxString msg = isGlobalTable ? _( "Error saving global library table." )
1693 : _( "Error saving project library table." );
1694
1695 wxMessageDialog dlg( this, msg, _( "File Save Error" ), wxOK | wxICON_ERROR );
1696 dlg.SetExtendedMessage( ioe.What() );
1697 dlg.ShowModal();
1698
1699 return false;
1700 }
1701
1702 return true;
1703}
1704
1705
1707{
1708 return m_symbol && !m_symbol->IsRoot();
1709}
1710
1711
1713{
1715}
1716
1717
1718void SYMBOL_EDIT_FRAME::UpdateItem( EDA_ITEM* aItem, bool isAddOrDelete, bool aUpdateRtree )
1719{
1720 SCH_BASE_FRAME::UpdateItem( aItem, isAddOrDelete, aUpdateRtree );
1721
1722 if( EDA_TEXT* eda_text = dynamic_cast<EDA_TEXT*>( aItem ) )
1723 {
1724 eda_text->ClearBoundingBoxCache();
1725 eda_text->ClearRenderCache();
1726 }
1727}
BASE_SCREEN class implementation.
constexpr EDA_IU_SCALE schIUScale
Definition: base_units.h:111
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:106
@ icon_libedit_32
@ icon_libedit
@ icon_libedit_16
BOX2< VECTOR2I > BOX2I
Definition: box2.h:847
static TOOL_ACTION toggleGrid
Definition: actions.h:144
static TOOL_ACTION paste
Definition: actions.h:69
static TOOL_ACTION cancelInteractive
Definition: actions.h:63
static TOOL_ACTION millimetersUnits
Definition: actions.h:150
static TOOL_ACTION revert
Definition: actions.h:55
static TOOL_ACTION copy
Definition: actions.h:68
static TOOL_ACTION milsUnits
Definition: actions.h:149
static TOOL_ACTION toggleBoundingBoxes
Definition: actions.h:108
static TOOL_ACTION saveAll
Definition: actions.h:54
static TOOL_ACTION undo
Definition: actions.h:65
static TOOL_ACTION duplicate
Definition: actions.h:72
static TOOL_ACTION inchesUnits
Definition: actions.h:148
static TOOL_ACTION toggleCursorStyle
Definition: actions.h:105
static TOOL_ACTION doDelete
Definition: actions.h:73
static TOOL_ACTION selectionTool
Definition: actions.h:157
static TOOL_ACTION save
Definition: actions.h:51
static TOOL_ACTION zoomFitScreen
Definition: actions.h:99
static TOOL_ACTION redo
Definition: actions.h:66
static TOOL_ACTION deleteTool
Definition: actions.h:74
static TOOL_ACTION zoomTool
Definition: actions.h:102
static TOOL_ACTION cut
Definition: actions.h:67
static TOOL_ACTION ddAddLibrary
Definition: actions.h:60
static TOOL_ACTION selectAll
Definition: actions.h:71
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:110
WINDOW_SETTINGS m_Window
Definition: app_settings.h:187
wxString m_ColorTheme
Active color theme name.
Definition: app_settings.h:190
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:202
void SetSize(const Vec &size)
Definition: box2.h:213
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
KIGFX::GAL_DISPLAY_OPTIONS & GetGalDisplayOptions()
Return a reference to the gal rendering options used by GAL for rendering.
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.
virtual void SetScreen(BASE_SCREEN *aScreen)
void RecreateToolbars()
Rebuild all toolbars, and update the checked state of check tools.
void OnGridSettings(wxCommandEvent &event)
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:85
const KIID m_Uuid
Definition: eda_item.h:475
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:72
virtual const wxString & GetText() const
Return the string associated with the text object.
Definition: eda_text.h:87
void SetAttributes(const EDA_TEXT &aSrc)
Set the text attributes from another instance.
Definition: eda_text.cpp:276
virtual void SetText(const wxString &aText)
Definition: eda_text.cpp:175
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.
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 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 saveSymbolAs
Definition: ee_actions.h:198
static TOOL_ACTION clearSelection
Clears the current selection.
Definition: ee_actions.h:56
static TOOL_ACTION placeSymbolAnchor
Definition: ee_actions.h:114
static TOOL_ACTION drawSymbolPolygon
Definition: ee_actions.h:113
static TOOL_ACTION showDeMorganAlternate
Definition: ee_actions.h:136
static TOOL_ACTION newSymbol
Definition: ee_actions.h:199
static TOOL_ACTION drawCircle
Definition: ee_actions.h:96
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:197
static TOOL_ACTION placeSymbolText
Definition: ee_actions.h:110
static TOOL_ACTION mirrorH
Definition: ee_actions.h:127
static TOOL_ACTION rotateCW
Definition: ee_actions.h:124
static TOOL_ACTION importSymbol
Definition: ee_actions.h:208
static TOOL_ACTION showDatasheet
Inspection and Editing.
Definition: ee_actions.h:150
static TOOL_ACTION symbolProperties
Definition: ee_actions.h:155
static TOOL_ACTION drawRectangle
Definition: ee_actions.h:95
static TOOL_ACTION setUnitDisplayName
Definition: ee_actions.h:211
static TOOL_ACTION drawSymbolTextBox
Definition: ee_actions.h:111
static TOOL_ACTION drawSymbolLines
Definition: ee_actions.h:112
static TOOL_ACTION drawArc
Definition: ee_actions.h:97
static TOOL_ACTION toggleSyncedPinsMode
Definition: ee_actions.h:238
static TOOL_ACTION showSymbolTree
Definition: ee_actions.h:246
static TOOL_ACTION placeSymbolPin
Definition: ee_actions.h:109
static TOOL_ACTION showElectricalTypes
Definition: ee_actions.h:244
Tool that displays edit points allowing to modify items by dragging the points.
EE_SELECTION & GetSelection()
Hold an error message and may be used when throwing exceptions containing meaningful error messages.
Definition: ki_exception.h:76
virtual const wxString What() const
A composite of Problem() and Where()
Definition: exceptions.cpp:30
void ReadWindowSettings(WINDOW_SETTINGS &aCfg)
Read GAL config options from application-level config.
bool m_axesEnabled
Fullscreen crosshair or small cross.
void SetAxesEnabled(bool aAxesEnabled)
Enable drawing the axes.
void SetAxesColor(const COLOR4D &aAxesColor)
Set the axes color.
void SetDefaultFont(const wxString &aFont)
void HideDrawingSheet()
Definition: sch_view.cpp:186
void ClearHiddenFlags()
Clear the hide flag of all items in the view.
Definition: sch_view.cpp:179
void Clear()
Remove all items from the view.
Definition: view.cpp:1116
void UpdateAllItems(int aUpdateFlags)
Update all items in the view according to the given flags.
Definition: view.cpp:1501
Carry a payload from one KIWAY_PLAYER to another within a PROJECT.
Definition: kiway_express.h:39
std::string & GetPayload()
Return the payload, which can be any text but it typically self identifying s-expression.
Definition: kiway_express.h:57
MAIL_T Command()
Returns the MAIL_T associated with this mail.
Definition: kiway_express.h:49
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:733
virtual KIWAY_PLAYER * Player(FRAME_T aFrameType, bool doCreate=true, wxTopLevelWindow *aParent=nullptr)
Return the KIWAY_PLAYER* given a FRAME_T.
Definition: kiway.cpp:432
virtual void ExpressMail(FRAME_T aDestination, MAIL_T aCommand, std::string &aPayload, wxWindow *aSource=nullptr)
Send aPayload to aDestination from aSource.
Definition: kiway.cpp:549
Field object used in symbol libraries.
Definition: lib_field.h:61
void SetName(const wxString &aName)
Set a user definable field name to aName.
Definition: lib_field.cpp:512
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:109
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
The base class for drawable items used by schematic library symbols.
Definition: lib_item.h:61
@ BASE
Definition: lib_item.h:70
@ DEMORGAN
Definition: lib_item.h:70
void SetPosition(const VECTOR2I &aPosition) override
Definition: lib_item.h:254
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:99
bool IsMulti() const
Definition: lib_symbol.h:564
bool UnitsLocked() const
Check whether symbol units are interchangeable.
Definition: lib_symbol.h:263
bool IsRoot() const override
For symbols derived from other symbols, IsRoot() indicates no derivation.
Definition: lib_symbol.h:192
wxString GetUnitDisplayName(int aUnit) override
Return the user-defined display name for aUnit for symbols with units.
Definition: lib_symbol.cpp:534
LIB_ITEMS_CONTAINER & GetDrawItems()
Return a reference to the draw item list.
Definition: lib_symbol.h:515
LIB_ID GetLibId() const override
Definition: lib_symbol.h:146
wxString GetName() const override
Definition: lib_symbol.h:143
wxString GetLibNickname() const override
Definition: lib_symbol.h:152
void ClearCaches()
Definition: lib_symbol.cpp:662
int GetUnitCount() const override
For items with units, return the number of units.
std::unique_ptr< LIB_SYMBOL > Flatten() const
Return a flattened symbol inheritance to the caller.
Definition: lib_symbol.cpp:588
LIB_FIELD & GetDatasheetField()
Return reference to the datasheet field.
LIB_SYMBOL_REF & GetParent()
Definition: lib_symbol.h:127
Hold a record identifying a library accessed by the appropriate plug in object in the LIB_TABLE.
void SetFullURI(const wxString &aFullURI)
Change the full URI for the library.
void SetNickName(const wxString &aNickName)
Change the logical name of this library, useful for an editor.
const wxString & GetNickName() const
const wxString GetFullURI(bool aSubstituted=false) const
Return the full location specifying URI for the LIB, either in original UI form or in environment var...
bool HasLibrary(const wxString &aNickname, bool aCheckEnabled=false) const
Test for the existence of aNickname in the library table.
bool InsertRow(LIB_TABLE_ROW *aRow, bool doReplace=false)
Adds aRow if it does not already exist or if doReplace is true.
const LIB_TABLE_ROW * FindRowByURI(const wxString &aURI)
void Save(const wxString &aFileName) const
Write this library table to aFileName in s-expression form.
Node type: LIB_ID.
Model class in the component selector Model-View-Adapter (mediated MVC) architecture.
void RefreshLibTree()
Refreshes the tree (mainly to update highlighting and asterisking)
Definition: lib_tree.cpp:361
LIB_TREE_NODE * GetCurrentTreeNode() const
Definition: lib_tree.cpp:267
void CenterLibId(const LIB_ID &aLibId)
Ensure that an item is visible (preferably centered).
Definition: lib_tree.cpp:284
int GetSelectionCount() const
Definition: lib_tree.h:88
void ShowChangedLanguage()
Definition: lib_tree.cpp:226
void SelectLibId(const LIB_ID &aLibId)
Select an item in the tree widget.
Definition: lib_tree.cpp:278
LIB_TREE_MODEL_ADAPTER::SORT_MODE GetSortMode() const
Definition: lib_tree.h:135
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:250
void Unselect()
Unselect currently selected item in wxDataViewCtrl.
Definition: lib_tree.cpp:290
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:236
void ExpandLibId(const LIB_ID &aLibId)
Expand and item i the tree widget.
Definition: lib_tree.cpp:296
void Regenerate(bool aKeepState)
Regenerate the tree.
Definition: lib_tree.cpp:343
static wxString GetDefaultUserSymbolsPath()
Gets the default path we point users to create projects.
Definition: paths.cpp:97
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
@ SCH_LIBEDIT_CUR_LIB
Definition: project.h:167
@ SCH_LIBEDIT_CUR_SYMBOL
Definition: project.h:168
virtual const wxString GetProjectPath() const
Return the full path of the project.
Definition: project.cpp:126
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:254
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:265
A shim class between EDA_DRAW_FRAME and several derived classes: SYMBOL_EDIT_FRAME,...
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.
KIGFX::SCH_RENDER_SETTINGS * GetRenderSettings()
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:1079
int GetId() const
Definition: sch_field.h:125
wxString GetName(bool aUseDefaultName=true) const
Return the field name (not translated).
Definition: sch_field.cpp:815
static const wxString ShowType(SCH_FILE_T aFileType)
Return a brief name for a plugin, given aFileType enum.
Definition: sch_io_mgr.cpp:84
Schematic symbol object.
Definition: sch_symbol.h:81
int GetUnit() const
Definition: sch_symbol.h:231
int GetConvert() const
Definition: sch_symbol.h:273
VECTOR2I GetPosition() const override
Definition: sch_symbol.h:726
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:939
std::unique_ptr< LIB_SYMBOL > & GetLibSymbolRef()
Definition: sch_symbol.h:195
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.
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.
int m_convert
Flag if the symbol being edited was loaded directly from a schematic.
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.
void updateTitle()
Update the main window title bar with the current library name and read only status of the library.
const BOX2I GetDocumentExtents(bool aIncludeAllVisible=true) const override
Returns bbox of document with option to not include some items.
SELECTION & GetCurrentSelection() override
Get the current selection from the canvas area.
wxString getTargetLib() const
bool IsCurrentSymbol(const LIB_ID &aLibId) const
Restore the empty editor screen, without any symbol or library selected.
bool backupFile(const wxFileName &aOriginalFile, const wxString &aBackupExt)
Return currently edited symbol.
void RefreshLibraryTree()
Redisplay the library tree.
wxComboBox * m_unitSelectBox
int GetTreeLIBIDs(std::vector< LIB_ID > &aSelection) const
LIB_ID GetTreeLIBID(int *aUnit=nullptr) const
Return the LIB_ID of the library or symbol selected in the symbol tree.
LIB_SYMBOL_LIBRARY_MANAGER * m_libMgr
wxString GetCurLib() const
The nickname of the current library being edited and empty string if none.
LIB_ID GetTargetLibId() const
Return either the symbol selected in the symbol tree (if context menu is active) or the symbol on the...
void FocusOnLibId(const LIB_ID &aLibID)
bool IsSymbolAlias() const
Return true if aLibId is an alias for the editor screen symbol.
SYMBOL_EDITOR_SETTINGS * m_settings
bool LoadSymbolFromCurrentLib(const wxString &aAliasName, int aUnit=0, int aConvert=0)
Load a symbol from the current active library, optionally setting the selected unit and convert.
void HardRedraw() override
Rebuild the GAL and redraw the screen.
bool GetShowDeMorgan() const
bool IsSymbolTreeShown() const
bool m_SyncPinEdit
Set to true to synchronize pins at the same position when editing symbols with multiple units or mult...
int GetTreeSelectionCount() const
void SaveSettings(APP_SETTINGS_BASE *aCfg) override
Save common frame parameters to a configuration data file.
bool CanCloseSymbolFromSchematic(bool doClose)
bool IsSymbolFromLegacyLibrary() const
bool replaceLibTableEntry(const wxString &aLibNickname, const wxString &aLibFile)
Replace the file path of the symbol library table entry aLibNickname with aLibFile.
bool IsSymbolFromSchematic() const
void OnToggleSymbolTree(wxCommandEvent &event)
static bool m_showDeMorgan
void SetScreen(BASE_SCREEN *aScreen) override
SYMBOL_EDITOR_SETTINGS * GetSettings() const
SCH_SCREEN * m_dummyScreen
< Helper screen used when no symbol is loaded
void KiwayMailIn(KIWAY_EXPRESS &mail) override
Receive KIWAY_EXPRESS messages from other players.
void SetCurSymbol(LIB_SYMBOL *aSymbol, bool aUpdateZoom)
Take ownership of aSymbol and notes that it is the one currently being edited.
KIID m_schematicSymbolUUID
RefDes of the symbol (only valid if symbol was loaded from schematic)
bool IsSymbolEditable() const
Test if a symbol is loaded and can be edited.
std::vector< LIB_ID > GetSelectedLibIds() const
LIB_TREE_NODE * GetCurrentTreeNode() const
void SyncLibraries(bool aShowProgress, bool aPreloadCancelled=false, const wxString &aForceRefresh=wxEmptyString)
Synchronize the library manager to the symbol library table, and then the symbol tree to the library ...
void RegenerateLibraryTree()
Filter, sort, and redisplay the library tree.
void OnSelectUnit(wxCommandEvent &event)
LIB_SYMBOL * GetCurSymbol() const
Return the current symbol being edited or NULL if none selected.
void UpdateSymbolMsgPanelInfo()
Display the documentation of the selected symbol.
bool canCloseWindow(wxCloseEvent &aCloseEvent) override
bool saveAllLibraries(bool aRequireConfirmation)
Save the current symbol.
void UpdateMsgPanel() override
Redraw the message panel.
void ClearUndoORRedoList(UNDO_REDO_LIST whichList, int aItemCount=-1) override
Free the undo or redo list from aList element.
wxString SetCurLib(const wxString &aLibNickname)
Set the current library nickname and returns the old library nickname.
void 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.
COLOR_SETTINGS * GetColorSettings(bool aForceRefresh=false) const override
Returns a pointer to the active color theme settings.
LIB_SYMBOL_LIBRARY_MANAGER & GetLibManager()
void SwitchCanvas(EDA_DRAW_PANEL_GAL::GAL_TYPE aCanvasType) override
Switch currently used canvas ( Cairo / OpenGL).
void doCloseWindow() override
void DdAddLibrary(wxString aLibFile)
Add a library dropped file to the symbol library table.
wxString AddLibraryFile(bool aCreateNew)
Create or add an existing library to the symbol library table.
void CloseWindow(wxCommandEvent &event)
Trigger the wxCloseEvent, which is handled by the function given to EVT_CLOSE() macro:
void UpdateLibraryTree(const wxDataViewItem &aTreeItem, LIB_SYMBOL *aSymbol)
Update a symbol node in the library tree.
void OnModify() override
Must be called after a schematic change in order to set the "modify" flag of the current symbol.
void SetShowDeMorgan(bool show)
void ShowChangedLanguage() override
bool IsContentModified() const override
Get if any symbols or libraries have been modified but not saved.
LIB_SYMBOL * getTargetSymbol() const
Return either the library selected in the symbol tree, if context menu is active or the library that ...
void OnUpdateUnitNumber(wxUpdateUIEvent &event)
LIB_SYMBOL * GetBufferedSymbol(const wxString &aAlias, const wxString &aLibrary)
Return the symbol copy from the buffer.
bool IsLibraryReadOnly(const wxString &aLibrary) const
Return true if the library is stored in a read-only file.
bool LibraryExists(const wxString &aLibrary, bool aCheckEnabled=false) const
Return true if library exists.
LIB_SYMBOL * GetAlias(const wxString &aAlias, const wxString &aLibrary) const
Return either an alias of a working LIB_SYMBOL copy, or alias of the original symbol if there is no w...
SCH_SCREEN * GetScreen(const wxString &aAlias, const wxString &aLibrary)
Return the screen used to edit a specific symbol.
bool IsLibraryModified(const wxString &aLibrary) const
Return true if library has unsaved modifications.
wxArrayString GetLibraryNames() const
Return the array of library names.
wxString GetUniqueLibraryName() const
Return a library name that is not currently in use.
bool AddLibrary(const wxString &aFilePath, SYMBOL_LIB_TABLE *aTable)
Add an existing library.
bool CreateLibrary(const wxString &aFilePath, SYMBOL_LIB_TABLE *aTable)
Create an empty library and adds it to the library table.
bool IsSymbolModified(const wxString &aAlias, const wxString &aLibrary) const
Return true if symbol has unsaved modifications.
SYMBOL_LIB_TABLE_ROW * GetLibrary(const wxString &aLibrary) const
Find a single library within the (aggregate) library table.
bool UpdateSymbol(LIB_SYMBOL *aSymbol, const wxString &aLibrary)
Update the symbol buffer with a new version of the symbol.
bool UpdateLibraryBuffer(const wxString &aLibrary)
Update the library buffer with a new version of the library.
Hold a record identifying a symbol library accessed by the appropriate symbol library SCH_PLUGIN obje...
void SetType(const wxString &aType) override
Change the schematic plugin type represented by this row.
const wxString GetType() const override
Return the type of symbol library table represented by this row.
static SYMBOL_LIB_TABLE & GetGlobalLibTable()
static const wxString & GetSymbolLibTableFileName()
static wxString GetGlobalTableFileName()
Fetch the global symbol library table file name.
SYMBOL_LIB_TABLE_ROW * FindRow(const wxString &aNickName, bool aCheckIfEnabled=false)
Return an SYMBOL_LIB_TABLE_ROW if aNickName is found in this table or in any chained fallBack table f...
Library Editor pane with symbol tree and symbol library table selector.
LIB_TREE * GetLibTree() const
TOOL_MANAGER * m_toolManager
Definition: tools_holder.h:170
TOOL_DISPATCHER * m_toolDispatcher
Definition: tools_holder.h:172
TOOL_MANAGER * GetToolManager() const
Return the MVC controller.
Definition: tools_holder.h:54
ACTIONS * m_actions
Definition: tools_holder.h:171
@ 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:55
bool RunAction(const std::string &aActionName, bool aNow=false, T aParam=NULL)
Run the specified action.
Definition: tool_manager.h:142
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:196
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:103
A modified version of the wxInfoBar class that allows us to:
Definition: wx_infobar.h:75
void RemoveAllButtons()
Remove all the buttons that have been added by the user.
Definition: wx_infobar.cpp:301
void AddButton(wxButton *aButton)
Add an already created button to the infobar.
Definition: wx_infobar.cpp:260
void Dismiss() override
Dismisses the infobar and updates the containing layout and AUI manager (if one is provided).
Definition: wx_infobar.cpp:187
void ShowMessage(const wxString &aMessage, int aFlags=wxICON_INFORMATION) override
Show the info bar with the provided message and icon.
Definition: wx_infobar.cpp:154
Multi-thread safe progress reporter dialog, intended for use of tasks that parallel reporting back of...
void DisplayError(wxWindow *aParent, const wxString &aText, int aDisplayTime)
Display an error or warning message box with aMessage.
Definition: confirm.cpp:283
void DisplayErrorMessage(wxWindow *aParent, const wxString &aText, const wxString &aExtraInfo)
Display an error message with aMessage.
Definition: confirm.cpp:308
int UnsavedChangesDialog(wxWindow *parent, const wxString &aMessage, bool *aApplyToAll)
A specialized version of HandleUnsavedChanges which handles an apply-to-all checkbox.
Definition: confirm.cpp:180
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:66
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
EVT_UPDATE_UI(ID_LOAD_FOOTPRINT_FROM_BOARD, FOOTPRINT_EDIT_FRAME::OnUpdateLoadFootprintFromBoard) EVT_UPDATE_UI(ID_ADD_FOOTPRINT_TO_BOARD
@ FRAME_SCH_SYMBOL_EDITOR
Definition: frame_type.h:35
@ FRAME_SCH
Definition: frame_type.h:34
const std::string KiCadSymbolLibFileExtension
wxString KiCadSymbolLibFileWildcard()
@ ID_GRID_SETTINGS
Definition: id.h:146
std::map< wxString, ENV_VAR_ITEM > ENV_VAR_MAP
PROJECT & Prj()
Definition: kicad.cpp:575
KIWAY Kiway
@ LAYER_SCHEMATIC_GRID_AXES
Definition: layer_ids.h:379
@ MAIL_LIB_EDIT
Definition: mail_type.h:53
@ MAIL_REFRESH_SYMBOL
Definition: mail_type.h:57
@ MAIL_RELOAD_LIB
Definition: mail_type.h:55
@ ALL
All except INITIAL_ADD.
Definition: view_item.h:53
void SetShutdownBlockReason(wxWindow *aWindow, const wxString &aReason)
Sets the block reason why the window/application is preventing OS shutdown.
Definition: gtk/app.cpp:83
bool SupportsShutdownBlockReason()
Whether or not the window supports setting a shutdown block reason.
Definition: gtk/app.cpp:72
bool contains(const _Container &__container, _Value __value)
Returns true if the container contains the given value.
Definition: kicad_algo.h:99
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...
see class PGM_BASE
@ SYM_ORIENT_270
@ SYM_MIRROR_Y
@ SYM_ORIENT_180
@ SYM_MIRROR_X
@ SYM_ORIENT_90
@ SYM_ORIENT_0
KIWAY Kiway & Pgm(), KFCTL_STANDALONE
The global Program "get" accessor.
Definition: single_top.cpp:115
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:89
#define EDIT_TOOL(tool)
Definition for symbol library class.
@ MANDATORY_FIELDS
The first 4 are mandatory, and must be instantiated in SCH_COMPONENT and LIB_PART constructors.
@ REFERENCE_FIELD
Field Reference of part, i.e. "IC21".
VECTOR2< double > VECTOR2D
Definition: vector2d.h:587
VECTOR2< int > VECTOR2I
Definition: vector2d.h:588
Definition of file extensions used in Kicad.