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>
36#include <kiface_base.h>
37#include <kiplatform/app.h>
38#include <kiway_express.h>
39#include <symbol_edit_frame.h>
41#include <lib_text.h>
43#include <paths.h>
44#include <pgm_base.h>
45#include <project_sch.h>
46#include <sch_painter.h>
47#include <sch_view.h>
49#include <symbol_lib_table.h>
50#include <tool/action_manager.h>
51#include <tool/action_toolbar.h>
52#include <tool/common_control.h>
53#include <tool/common_tools.h>
55#include <tool/picker_tool.h>
57#include <tool/selection.h>
59#include <tool/tool_manager.h>
60#include <tool/zoom_tool.h>
61#include <tools/ee_actions.h>
71#include <widgets/wx_infobar.h>
72#include <widgets/lib_tree.h>
78#include <panel_sym_lib_table.h>
79#include <string_utils.h>
80
81
83
84
85BEGIN_EVENT_TABLE( SYMBOL_EDIT_FRAME, SCH_BASE_FRAME )
87
88 // menubar commands
89 EVT_MENU( wxID_EXIT, SYMBOL_EDIT_FRAME::OnExitKiCad )
90 EVT_MENU( wxID_CLOSE, SYMBOL_EDIT_FRAME::CloseWindow )
91
92 // Update user interface elements.
94
95 // Drop files event
96 EVT_DROP_FILES( SYMBOL_EDIT_FRAME::OnDropFiles )
97
98END_EVENT_TABLE()
99
100
101SYMBOL_EDIT_FRAME::SYMBOL_EDIT_FRAME( KIWAY* aKiway, wxWindow* aParent ) :
102 SCH_BASE_FRAME( aKiway, aParent, FRAME_SCH_SYMBOL_EDITOR, _( "Library Editor" ),
103 wxDefaultPosition, wxDefaultSize, KICAD_DEFAULT_DRAWFRAME_STYLE,
105 m_unitSelectBox( nullptr ),
106 m_isSymbolFromSchematic( false )
107{
108 SetShowDeMorgan( false );
109 m_SyncPinEdit = false;
110
111 m_symbol = nullptr;
112 m_treePane = nullptr;
113 m_libMgr = nullptr;
114 m_unit = 1;
115 m_convert = 1;
116 m_aboutTitle = _HKI( "KiCad Symbol Editor" );
117
118 wxIcon icon;
119 wxIconBundle icon_bundle;
120
121 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_libedit ) );
122 icon_bundle.AddIcon( icon );
123 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_libedit_32 ) );
124 icon_bundle.AddIcon( icon );
125 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_libedit_16 ) );
126 icon_bundle.AddIcon( icon );
127
128 SetIcons( icon_bundle );
129
130 m_settings = Pgm().GetSettingsManager().GetAppSettings<SYMBOL_EDITOR_SETTINGS>();
131 LoadSettings( m_settings );
132
133 m_libMgr = new LIB_SYMBOL_LIBRARY_MANAGER( *this );
134 bool loadingCancelled = false;
135
136 {
137 // Preload libraries before using SyncLibraries the first time, as the preload is
138 // multi-threaded
139 WX_PROGRESS_REPORTER reporter( this, _( "Loading Symbol Libraries" ),
140 m_libMgr->GetLibraryCount(), true );
141 m_libMgr->Preload( reporter );
142
143 loadingCancelled = reporter.IsCancelled();
144 wxSafeYield();
145 }
146
147 SyncLibraries( false, loadingCancelled );
148 m_treePane = new SYMBOL_TREE_PANE( this, m_libMgr );
149 m_treePane->GetLibTree()->SetSortMode( (LIB_TREE_MODEL_ADAPTER::SORT_MODE) m_settings->m_LibrarySortMode );
150
151 resolveCanvasType();
152 SwitchCanvas( m_canvasType );
153
154 // Ensure axis are always drawn
155 KIGFX::GAL_DISPLAY_OPTIONS& gal_opts = GetGalDisplayOptions();
156 gal_opts.m_axesEnabled = true;
157
158 m_dummyScreen = new SCH_SCREEN();
159 SetScreen( m_dummyScreen );
160 GetScreen()->m_Center = true;
161
162 GetCanvas()->GetViewControls()->SetCrossHairCursorPosition( VECTOR2D( 0, 0 ), false );
163
164 GetRenderSettings()->LoadColors( GetColorSettings() );
165 GetRenderSettings()->m_IsSymbolEditor = true;
166 GetCanvas()->GetGAL()->SetAxesColor( m_colorSettings->GetColor( LAYER_SCHEMATIC_GRID_AXES ) );
167
168 setupTools();
169 setupUIConditions();
170
171 ReCreateMenuBar();
172 ReCreateHToolbar();
173 ReCreateVToolbar();
174 ReCreateOptToolbar();
175
176 UpdateTitle();
177 UpdateSymbolMsgPanelInfo();
178 RebuildSymbolUnitsList();
179
180 m_propertiesPanel = new SCH_PROPERTIES_PANEL( this, this );
181 m_propertiesPanel->SetSplitterProportion( m_settings->m_AuiPanels.properties_splitter );
182
183 m_auimgr.SetManagedWindow( this );
184
185 CreateInfoBar();
186
187 // Rows; layers 4 - 6
188 m_auimgr.AddPane( m_mainToolBar, EDA_PANE().HToolbar().Name( "MainToolbar" )
189 .Top().Layer( 6 ) );
190
191 m_auimgr.AddPane( m_messagePanel, EDA_PANE().Messages().Name( "MsgPanel" )
192 .Bottom().Layer( 6 ) );
193
194 // Columns; layers 1 - 3
195 m_auimgr.AddPane( m_treePane, EDA_PANE().Palette().Name( "SymbolTree" )
196 .Left().Layer( 3 )
197 .TopDockable( false ).BottomDockable( false )
198 .Caption( _( "Libraries" ) )
199 .MinSize( 250, -1 ).BestSize( 250, -1 ) );
200
201 m_auimgr.AddPane( m_propertiesPanel, defaultPropertiesPaneInfo() );
202 // Show or hide m_propertiesPanel depending on current settings:
203 wxAuiPaneInfo& propertiesPaneInfo = m_auimgr.GetPane( PropertiesPaneName() );
204 propertiesPaneInfo.Show( m_settings->m_AuiPanels.show_properties );
205
206 m_auimgr.AddPane( m_optionsToolBar, EDA_PANE().VToolbar().Name( "OptToolbar" )
207 .Left().Layer( 2 ) );
208
209 m_auimgr.AddPane( m_drawToolBar, EDA_PANE().VToolbar().Name( "ToolsToolbar" )
210 .Right().Layer( 2 ) );
211
212 // Center
213 m_auimgr.AddPane( GetCanvas(), wxAuiPaneInfo().Name( "DrawFrame" )
214 .CentrePane() );
215
216 FinishAUIInitialization();
217
218 if( m_settings->m_LibWidth > 0 )
219 SetAuiPaneSize( m_auimgr, m_auimgr.GetPane( "SymbolTree" ), m_settings->m_LibWidth, -1 );
220
221 Raise();
222 Show( true );
223
224 SyncView();
225 GetCanvas()->GetView()->UseDrawPriority( true );
226 GetCanvas()->GetGAL()->SetAxesEnabled( true );
227
228 setupUnits( m_settings );
229
230 // Set the working/draw area size to display a symbol to a reasonable value:
231 // A 600mm x 600mm with a origin at the area center looks like a large working area
232 double max_size_x = schIUScale.mmToIU( 600 );
233 double max_size_y = schIUScale.mmToIU( 600 );
234 BOX2D bbox;
235 bbox.SetOrigin( -max_size_x /2, -max_size_y/2 );
236 bbox.SetSize( max_size_x, max_size_y );
237 GetCanvas()->GetView()->SetBoundary( bbox );
238
239 m_toolManager->RunAction( ACTIONS::zoomFitScreen );
240
241 m_acceptedExts.emplace( KiCadSymbolLibFileExtension, &ACTIONS::ddAddLibrary );
242 DragAcceptFiles( true );
243
244 KIPLATFORM::APP::SetShutdownBlockReason( this, _( "Library changes are unsaved" ) );
245
246 // Catch unhandled accelerator command characters that were no handled by the library tree
247 // panel.
248 Bind( wxEVT_CHAR, &TOOL_DISPATCHER::DispatchWxEvent, m_toolDispatcher );
249 Bind( wxEVT_CHAR_HOOK, &TOOL_DISPATCHER::DispatchWxEvent, m_toolDispatcher );
250
251 // Ensure the window is on top
252 Raise();
253
254 if( loadingCancelled )
255 ShowInfoBarWarning( _( "Symbol library loading was cancelled by user." ) );
256}
257
258
260{
261 // Shutdown all running tools
262 if( m_toolManager )
264
265 setSymWatcher( nullptr );
266
268 {
269 delete m_symbol;
270 m_symbol = nullptr;
271
272 SCH_SCREEN* screen = GetScreen();
273 delete screen;
275 }
276
277 // current screen is destroyed in EDA_DRAW_FRAME
279
280 SYMBOL_EDITOR_SETTINGS* cfg = nullptr;
281
282 try
283 {
284 cfg = Pgm().GetSettingsManager().GetAppSettings<SYMBOL_EDITOR_SETTINGS>();
285 }
286 catch( const std::runtime_error& e )
287 {
288 wxFAIL_MSG( e.what() );
289 }
290
291 if( cfg )
292 {
293 Pgm().GetSettingsManager().Save( cfg );
294 }
295
296 delete m_libMgr;
297}
298
299
301{
302 wxCHECK_RET( m_settings, "Call to SYMBOL_EDIT_FRAME::LoadSettings with null m_boardAdapter" );
303
305
307 GetRenderSettings()->SetDefaultFont( wxEmptyString );
308}
309
310
312{
313 wxCHECK_RET( m_settings, "Call to SYMBOL_EDIT_FRAME::LoadSettings with null m_boardAdapter" );
314
316
318
320 m_settings->m_LibWidth = m_treePane->GetSize().x;
321
323
325 bool prop_shown = m_auimgr.GetPane( PropertiesPaneName() ).IsShown();
327}
328
329
331{
332 return static_cast<APP_SETTINGS_BASE*>( GetSettings() );
333}
334
335
337{
338 SETTINGS_MANAGER& mgr = Pgm().GetSettingsManager();
339
340 if( GetSettings()->m_UseEeschemaColorSettings )
342 else
343 return mgr.GetColorSettings( GetSettings()->m_ColorTheme );
344}
345
346
348{
349 // Create the manager and dispatcher & route draw panel events to the dispatcher
352 GetCanvas()->GetViewControls(), GetSettings(), this );
353 m_actions = new EE_ACTIONS();
355
356 // Register tools
371
372 // Run the selection tool, it is supposed to be always active
373 m_toolManager->InvokeTool( "eeschema.InteractiveSelection" );
374
376}
377
378
380{
382
384 EDITOR_CONDITIONS cond( this );
385
386 wxASSERT( mgr );
387
388#define ENABLE( x ) ACTION_CONDITIONS().Enable( x )
389#define CHECK( x ) ACTION_CONDITIONS().Check( x )
390
391 auto haveSymbolCond =
392 [this]( const SELECTION& )
393 {
394 return m_symbol;
395 };
396
397 auto isEditableCond =
398 [this]( const SELECTION& )
399 {
400 // Only root symbols from the new s-expression libraries or the schematic
401 // are editable.
402 return IsSymbolEditable() && !IsSymbolAlias();
403 };
404
405 auto symbolModifiedCondition =
406 [this]( const SELECTION& sel )
407 {
410 };
411
412 auto libSelectedCondition =
413 [this]( const SELECTION& sel )
414 {
415 return !GetTargetLibId().GetLibNickname().empty();
416 };
417
418 auto canEditProperties =
419 [this]( const SELECTION& sel )
420 {
422 };
423
424 auto saveSymbolAsCondition =
425 [this]( const SELECTION& aSel )
426 {
427 return getTargetSymbol() != nullptr;
428 };
429
432 mgr->SetConditions( EE_ACTIONS::saveLibraryAs, ENABLE( libSelectedCondition ) );
433 mgr->SetConditions( EE_ACTIONS::saveSymbolCopyAs, ENABLE( saveSymbolAsCondition ) );
436
437 mgr->SetConditions( ACTIONS::undo, ENABLE( haveSymbolCond && cond.UndoAvailable() ) );
438 mgr->SetConditions( ACTIONS::redo, ENABLE( haveSymbolCond && cond.RedoAvailable() ) );
439 mgr->SetConditions( ACTIONS::revert, ENABLE( symbolModifiedCondition ) );
440
444 mgr->SetConditions( ACTIONS::millimetersUnits, CHECK( cond.Units( EDA_UNITS::MILLIMETRES ) ) );
445 mgr->SetConditions( ACTIONS::inchesUnits, CHECK( cond.Units( EDA_UNITS::INCHES ) ) );
446 mgr->SetConditions( ACTIONS::milsUnits, CHECK( cond.Units( EDA_UNITS::MILS ) ) );
447
448 mgr->SetConditions( ACTIONS::cut, ENABLE( isEditableCond ) );
449 mgr->SetConditions( ACTIONS::copy, ENABLE( haveSymbolCond ) );
451 mgr->SetConditions( ACTIONS::doDelete, ENABLE( isEditableCond ) );
452 mgr->SetConditions( ACTIONS::duplicate, ENABLE( isEditableCond ) );
453 mgr->SetConditions( ACTIONS::selectAll, ENABLE( haveSymbolCond ) );
454 mgr->SetConditions( ACTIONS::unselectAll, ENABLE( haveSymbolCond ) );
455
456 mgr->SetConditions( EE_ACTIONS::rotateCW, ENABLE( isEditableCond ) );
457 mgr->SetConditions( EE_ACTIONS::rotateCCW, ENABLE( isEditableCond ) );
458 mgr->SetConditions( EE_ACTIONS::mirrorH, ENABLE( isEditableCond ) );
459 mgr->SetConditions( EE_ACTIONS::mirrorV, ENABLE( isEditableCond ) );
460
463
464 auto pinTypeCond =
465 [this]( const SELECTION& )
466 {
468 };
469
470 auto showCompTreeCond =
471 [this]( const SELECTION& )
472 {
473 return IsSymbolTreeShown();
474 };
475
476 auto propertiesCond =
477 [this] ( const SELECTION& )
478 {
479 return m_auimgr.GetPane( PropertiesPaneName() ).IsShown();
480 };
481
484 mgr->SetConditions( EE_ACTIONS::showSymbolTree, CHECK( showCompTreeCond ) );
485 mgr->SetConditions( ACTIONS::showProperties, CHECK( propertiesCond ) );
486
487 auto demorganCond =
488 [this]( const SELECTION& )
489 {
490 return GetShowDeMorgan();
491 };
492
493 auto demorganStandardCond =
494 [this]( const SELECTION& )
495 {
497 };
498
499 auto demorganAlternateCond =
500 [this]( const SELECTION& )
501 {
503 };
504
505 auto multiUnitModeCond =
506 [this]( const SELECTION& )
507 {
508 return m_symbol && m_symbol->IsMulti() && !m_symbol->UnitsLocked();
509 };
510
511 auto hasMultipleUnitsCond =
512 [this]( const SELECTION& )
513 {
514 return m_symbol && m_symbol->IsMulti();
515 };
516
517 auto syncedPinsModeCond =
518 [this]( const SELECTION& )
519 {
520 return m_SyncPinEdit;
521 };
522
523 auto haveDatasheetCond =
524 [this]( const SELECTION& )
525 {
526 return m_symbol && !m_symbol->GetDatasheetField().GetText().IsEmpty();
527 };
528
529 mgr->SetConditions( EE_ACTIONS::showDatasheet, ENABLE( haveDatasheetCond ) );
530 mgr->SetConditions( EE_ACTIONS::symbolProperties, ENABLE( canEditProperties && haveSymbolCond ) );
531 mgr->SetConditions( EE_ACTIONS::runERC, ENABLE( haveSymbolCond ) );
532 mgr->SetConditions( EE_ACTIONS::pinTable, ENABLE( isEditableCond && haveSymbolCond ) );
533
535 ACTION_CONDITIONS().Enable( demorganCond ).Check( demorganStandardCond ) );
537 ACTION_CONDITIONS().Enable( demorganCond ).Check( demorganAlternateCond ) );
539 ACTION_CONDITIONS().Enable( multiUnitModeCond ).Check( syncedPinsModeCond ) );
541 ACTION_CONDITIONS().Enable( isEditableCond && hasMultipleUnitsCond ) );
542
543// Only enable a tool if the symbol is edtable
544#define EDIT_TOOL( tool ) ACTION_CONDITIONS().Enable( isEditableCond ).Check( cond.CurrentTool( tool ) )
545
557
558#undef CHECK
559#undef ENABLE
560#undef EDIT_TOOL
561}
562
563
565{
566 if( IsContentModified() )
567 {
568 SCH_EDIT_FRAME* schframe = (SCH_EDIT_FRAME*) Kiway().Player( FRAME_SCH, false );
569 wxString msg = _( "Save changes to '%s' before closing?" );
570
571 switch( UnsavedChangesDialog( this, wxString::Format( msg, m_reference ), nullptr ) )
572 {
573 case wxID_YES:
574 if( schframe && GetCurSymbol() ) // Should be always the case
576
577 break;
578
579 case wxID_NO:
580 break;
581
582 default:
583 case wxID_CANCEL:
584 return false;
585 }
586 }
587
588 if( doClose )
589 {
590 SetCurSymbol( nullptr, false );
591 UpdateTitle();
592 }
593
594 return true;
595}
596
597
598bool SYMBOL_EDIT_FRAME::canCloseWindow( wxCloseEvent& aEvent )
599{
600 // Shutdown blocks must be determined and vetoed as early as possible
602 && aEvent.GetId() == wxEVT_QUERY_END_SESSION
603 && IsContentModified() )
604 {
605 return false;
606 }
607
609 return false;
610
611 if( !saveAllLibraries( true ) )
612 return false;
613
614 // Save symbol tree column widths
615 m_libMgr->GetAdapter()->SaveSettings();
616
617 return true;
618}
619
620
622{
623 Destroy();
624}
625
626
628{
629 if( !m_unitSelectBox )
630 return;
631
632 if( m_unitSelectBox->GetCount() != 0 )
633 m_unitSelectBox->Clear();
634
635 if( !m_symbol || m_symbol->GetUnitCount() <= 1 )
636 {
637 m_unit = 1;
638 m_unitSelectBox->Append( wxEmptyString );
639 }
640 else
641 {
642 for( int i = 0; i < m_symbol->GetUnitCount(); i++ )
643 {
644 wxString unitDisplayName = m_symbol->GetUnitDisplayName( i + 1 );
645 m_unitSelectBox->Append( unitDisplayName );
646 }
647 }
648
649 // Ensure the selected unit is compatible with the number of units of the current symbol:
651 m_unit = 1;
652
653 m_unitSelectBox->SetSelection(( m_unit > 0 ) ? m_unit - 1 : 0 );
654}
655
656
657void SYMBOL_EDIT_FRAME::OnToggleSymbolTree( wxCommandEvent& event )
658{
659 wxAuiPaneInfo& treePane = m_auimgr.GetPane( m_treePane );
660 treePane.Show( !IsSymbolTreeShown() );
661 m_auimgr.Update();
662}
663
664
666{
667 return const_cast<wxAuiManager&>( m_auimgr ).GetPane( m_treePane ).IsShown();
668}
669
670
672{
673 m_treePane->Freeze();
674 m_libMgr->GetAdapter()->Freeze();
675}
676
677
679{
680 m_libMgr->GetAdapter()->Thaw();
681 m_treePane->Thaw();
682}
683
684
685void SYMBOL_EDIT_FRAME::OnExitKiCad( wxCommandEvent& event )
686{
687 Kiway().OnKiCadExit();
688}
689
690
691void SYMBOL_EDIT_FRAME::OnUpdateUnitNumber( wxUpdateUIEvent& event )
692{
693 event.Enable( m_symbol && m_symbol->GetUnitCount() > 1 );
694}
695
696
697void SYMBOL_EDIT_FRAME::OnSelectUnit( wxCommandEvent& event )
698{
699 int i = event.GetSelection();
700
701 if( ( i == wxNOT_FOUND ) || ( ( i + 1 ) == m_unit ) )
702 return;
703
706
707 m_unit = i + 1;
708
710 RebuildView();
712}
713
714
716{
717 if( m_symbol )
718 {
720
721 if( row && row->GetType() == SCH_IO_MGR::ShowType( SCH_IO_MGR::SCH_LEGACY ) )
722 return true;
723 }
724
725 return false;
726}
727
728
730{
731 wxString libNickname = Prj().GetRString( PROJECT::SCH_LIBEDIT_CUR_LIB );
732
733 if( !libNickname.empty() )
734 {
735 if( !PROJECT_SCH::SchSymbolLibTable( &Prj() )->HasLibrary( libNickname ) )
736 {
737 Prj().SetRString( PROJECT::SCH_LIBEDIT_CUR_LIB, wxEmptyString );
738 libNickname = wxEmptyString;
739 }
740 }
741
742 return libNickname;
743}
744
745
746wxString SYMBOL_EDIT_FRAME::SetCurLib( const wxString& aLibNickname )
747{
748 wxString old = GetCurLib();
749
750 if( aLibNickname.empty() || !PROJECT_SCH::SchSymbolLibTable( &Prj() )->HasLibrary( aLibNickname ) )
751 Prj().SetRString( PROJECT::SCH_LIBEDIT_CUR_LIB, wxEmptyString );
752 else
754
755 return old;
756}
757
758
759void SYMBOL_EDIT_FRAME::SetCurSymbol( LIB_SYMBOL* aSymbol, bool aUpdateZoom )
760{
761 wxCHECK( m_toolManager, /* void */ );
762
764 GetCanvas()->GetView()->Clear();
765 delete m_symbol;
766
767 m_symbol = aSymbol;
768
769 // select the current symbol in the tree widget
772 else
774
775 wxString symbolName = m_symbol ? m_symbol->GetName() : wxString();
776
777 // retain in case this wxFrame is re-opened later on the same PROJECT
779
780 // Ensure synchronized pin edit can be enabled only symbols with interchangeable units
781 m_SyncPinEdit = aSymbol && aSymbol->IsRoot() && aSymbol->IsMulti() && !aSymbol->UnitsLocked();
782
784
792
793 if( aUpdateZoom )
795
796 GetCanvas()->Refresh();
797
798 WX_INFOBAR* infobar = GetInfoBar();
799
801 {
802 wxString msg;
803 msg.Printf( _( "Editing symbol %s from schematic. Saving will update the schematic "
804 "only." ), m_reference );
805
806 infobar->RemoveAllButtons();
807 infobar->ShowMessage( msg, wxICON_INFORMATION );
808 }
809 else if( IsSymbolFromLegacyLibrary() )
810 {
811 wxHyperlinkCtrl* button = new wxHyperlinkCtrl( infobar, wxID_ANY,
812 _( "Manage symbol libraries" ),
813 wxEmptyString );
814
815 button->Bind( wxEVT_COMMAND_HYPERLINK, std::function<void( wxHyperlinkEvent& aEvent )>(
816 [=]( wxHyperlinkEvent& aEvent )
817 {
819 } ) );
820
821 infobar->RemoveAllButtons();
822 infobar->AddButton( button );
823 infobar->ShowMessage( _( "Symbols in legacy libraries are not editable. Use Manage "
824 "Symbol Libraries to migrate to current format." ),
825 wxICON_INFORMATION );
826 }
827 else if( IsSymbolAlias() )
828 {
829 wxString rootSymbolName;
830
831 // Don't assume the parent symbol shared pointer is still valid.
832 if( std::shared_ptr<LIB_SYMBOL> rootSymbol = m_symbol->GetRootSymbol() )
833 rootSymbolName = rootSymbol->GetName();
834 else
835 {
836 wxCHECK( false, /* void */ );
837 }
838
839 int unit = GetUnit();
840 int convert = GetConvert();
841 wxString msg;
842 wxString link;
843
844 msg.Printf( _( "Symbol %s is a derived symbol. Symbol graphics will not be editable." ),
845 UnescapeString( symbolName ) );
846
847 link.Printf( _( "Open %s" ), UnescapeString( rootSymbolName ) );
848
849 wxHyperlinkCtrl* button = new wxHyperlinkCtrl( infobar, wxID_ANY, link, wxEmptyString );
850 button->Bind( wxEVT_COMMAND_HYPERLINK, std::function<void( wxHyperlinkEvent& aEvent )>(
851 [=]( wxHyperlinkEvent& aEvent )
852 {
853 LoadSymbolFromCurrentLib( rootSymbolName, unit, convert );
854 } ) );
855
856 infobar->RemoveAllButtons();
857 infobar->AddButton( button );
858 infobar->ShowMessage( msg, wxICON_INFORMATION );
859 }
860 else
861 {
862 infobar->Dismiss();
863 }
864}
865
866
868{
869 wxASSERT( m_libMgr );
870 return *m_libMgr;
871}
872
873
875{
877
879 m_autoSaveRequired = true;
880
881 if( !IsSymbolFromSchematic() )
883
885
886 if( !GetTitle().StartsWith( "*" ) )
887 UpdateTitle();
888}
889
890
892{
894}
895
896
897wxString SYMBOL_EDIT_FRAME::AddLibraryFile( bool aCreateNew )
898{
899 // Select the target library table (global/project)
901
902 if( !libTable )
903 return wxEmptyString;
904
905 wxFileName fn = m_libMgr->GetUniqueLibraryName();
906
907 if( !LibraryFileBrowser( !aCreateNew, fn, KiCadSymbolLibFileWildcard(),
909 ( libTable == &SYMBOL_LIB_TABLE::GetGlobalLibTable() ),
911 {
912 return wxEmptyString;
913 }
914
915 wxString libName = fn.GetName();
916
917 if( libName.IsEmpty() )
918 return wxEmptyString;
919
920 if( m_libMgr->LibraryExists( libName ) )
921 {
922 DisplayError( this, wxString::Format( _( "Library '%s' already exists." ), libName ) );
923 return wxEmptyString;
924 }
925
926 if( aCreateNew )
927 {
928 if( !m_libMgr->CreateLibrary( fn.GetFullPath(), libTable ) )
929 {
930 DisplayError( this, wxString::Format( _( "Could not create the library file '%s'.\n"
931 "Make sure you have write permissions and "
932 "try again." ),
933 fn.GetFullPath() ) );
934 return wxEmptyString;
935 }
936 }
937 else
938 {
939 if( !m_libMgr->AddLibrary( fn.GetFullPath(), libTable ) )
940 {
941 DisplayError( this, _( "Could not open the library file." ) );
942 return wxEmptyString;
943 }
944 }
945
946 bool globalTable = ( libTable == &SYMBOL_LIB_TABLE::GetGlobalLibTable() );
947 saveSymbolLibTables( globalTable, !globalTable );
948
949 std::string packet = fn.GetFullPath().ToStdString();
951
952 return fn.GetFullPath();
953}
954
955
956void SYMBOL_EDIT_FRAME::DdAddLibrary( wxString aLibFile )
957{
958 // Select the target library table (global/project)
960
961 if( !libTable )
962 return;
963
964 wxFileName fn = wxFileName( aLibFile );
965
966 wxString libName = fn.GetName();
967
968 if( libName.IsEmpty() )
969 return;
970
971 if( m_libMgr->LibraryExists( libName ) )
972 {
973 DisplayError( this, wxString::Format( _( "Library '%s' already exists." ), libName ) );
974 return;
975 }
976
977 if( !m_libMgr->AddLibrary( fn.GetFullPath(), libTable ) )
978 {
979 DisplayError( this, _( "Could not open the library file." ) );
980 return;
981 }
982
983 bool globalTable = ( libTable == &SYMBOL_LIB_TABLE::GetGlobalLibTable() );
984 saveSymbolLibTables( globalTable, !globalTable );
985
986 std::string packet = fn.GetFullPath().ToStdString();
988}
989
990
992{
993 return m_treePane->GetLibTree()->GetSelectedLibId( aUnit );
994}
995
996
998{
1000}
1001
1002int SYMBOL_EDIT_FRAME::GetTreeLIBIDs( std::vector<LIB_ID>& aSelection ) const
1003{
1004 return m_treePane->GetLibTree()->GetSelectedLibIds( aSelection );
1005}
1006
1007
1009{
1010 if( IsSymbolTreeShown() )
1011 {
1012 LIB_ID libId = GetTreeLIBID();
1013
1014 if( libId.IsValid() )
1015 return m_libMgr->GetAlias( libId.GetLibItemName(), libId.GetLibNickname() );
1016 }
1017
1018 return m_symbol;
1019}
1020
1021
1023{
1024 LIB_ID id;
1025
1026 if( IsSymbolTreeShown() )
1027 id = GetTreeLIBID();
1028
1029 if( id.GetLibNickname().empty() && m_symbol )
1030 id = m_symbol->GetLibId();
1031
1032 return id;
1033}
1034
1035
1036std::vector<LIB_ID> SYMBOL_EDIT_FRAME::GetSelectedLibIds() const
1037{
1038 std::vector<LIB_ID> ids;
1039 GetTreeLIBIDs( ids );
1040 return ids;
1041}
1042
1043
1045{
1047}
1048
1049
1051{
1052 return GetTargetLibId().GetLibNickname();
1053}
1054
1055
1056void SYMBOL_EDIT_FRAME::SyncLibraries( bool aShowProgress, bool aPreloadCancelled,
1057 const wxString& aForceRefresh )
1058{
1059 LIB_ID selected;
1060
1061 if( m_treePane )
1062 selected = m_treePane->GetLibTree()->GetSelectedLibId();
1063
1064 if( aShowProgress )
1065 {
1066 APP_PROGRESS_DIALOG progressDlg( _( "Loading Symbol Libraries" ), wxEmptyString,
1067 m_libMgr->GetAdapter()->GetLibrariesCount(), this );
1068
1069 m_libMgr->Sync( aForceRefresh,
1070 [&]( int progress, int max, const wxString& libName )
1071 {
1072 progressDlg.Update( progress, wxString::Format( _( "Loading library '%s'..." ),
1073 libName ) );
1074 } );
1075 }
1076 else if( !aPreloadCancelled )
1077 {
1078 m_libMgr->Sync( aForceRefresh,
1079 [&]( int progress, int max, const wxString& libName )
1080 {
1081 } );
1082 }
1083
1084 if( m_treePane )
1085 {
1086 wxDataViewItem found;
1087
1088 if( selected.IsValid() )
1089 {
1090 // Check if the previously selected item is still valid,
1091 // if not - it has to be unselected to prevent crash
1092 found = m_libMgr->GetAdapter()->FindItem( selected );
1093
1094 if( !found )
1096 }
1097
1098 m_treePane->GetLibTree()->Regenerate( true );
1099
1100 // Try to select the parent library, in case the symbol is not found
1101 if( !found && selected.IsValid() )
1102 {
1103 selected.SetLibItemName( "" );
1104 found = m_libMgr->GetAdapter()->FindItem( selected );
1105
1106 if( found )
1107 m_treePane->GetLibTree()->SelectLibId( selected );
1108 }
1109
1110 // If no selection, see if there's a current symbol to centre
1111 if( !selected.IsValid() && m_symbol )
1112 {
1113 LIB_ID current( GetCurLib(), m_symbol->GetName() );
1114 m_treePane->GetLibTree()->CenterLibId( current );
1115 }
1116 }
1117}
1118
1119
1121{
1122 LIB_ID target = GetTargetLibId();
1123
1124 m_treePane->GetLibTree()->Regenerate( true );
1125
1126 if( target.IsValid() )
1127 m_treePane->GetLibTree()->CenterLibId( target );
1128}
1129
1130
1132{
1134}
1135
1136
1138{
1139 m_treePane->GetLibTree()->SelectLibId( aLibID );
1140}
1141
1142
1143void SYMBOL_EDIT_FRAME::UpdateLibraryTree( const wxDataViewItem& aTreeItem, LIB_SYMBOL* aSymbol )
1144{
1145 if( aTreeItem.IsOk() ) // Can be not found in tree if the current footprint is imported
1146 // from file therefore not yet in tree.
1147 {
1148 static_cast<LIB_TREE_NODE_ITEM*>( aTreeItem.GetID() )->Update( aSymbol );
1150 }
1151}
1152
1153
1154bool SYMBOL_EDIT_FRAME::backupFile( const wxFileName& aOriginalFile, const wxString& aBackupExt )
1155{
1156 if( aOriginalFile.FileExists() )
1157 {
1158 wxFileName backupFileName( aOriginalFile );
1159 backupFileName.SetExt( aBackupExt );
1160
1161 if( backupFileName.FileExists() )
1162 wxRemoveFile( backupFileName.GetFullPath() );
1163
1164 if( !wxCopyFile( aOriginalFile.GetFullPath(), backupFileName.GetFullPath() ) )
1165 {
1166 DisplayError( this, wxString::Format( _( "Failed to save backup to '%s'." ),
1167 backupFileName.GetFullPath() ) );
1168 return false;
1169 }
1170 }
1171
1172 return true;
1173}
1174
1175
1177{
1178 if( m_symbol && !GetCurLib().IsEmpty() && GetScreen()->IsContentModified() )
1179 m_libMgr->UpdateSymbol( m_symbol, GetCurLib() ); // UpdateSymbol() makes a copy
1180}
1181
1182
1184{
1185 // This will return the root symbol of any alias
1187 aLibId.GetLibNickname() );
1188
1189 // Now we can compare the libId of the current symbol and the root symbol
1190 return ( symbol && m_symbol && symbol->GetLibId() == m_symbol->GetLibId() );
1191}
1192
1193
1195{
1197 SetCurLib( wxEmptyString );
1198 SetCurSymbol( nullptr, false );
1202 Refresh();
1203}
1204
1205
1206void SYMBOL_EDIT_FRAME::CommonSettingsChanged( bool aEnvVarsChanged, bool aTextVarsChanged )
1207{
1208 SCH_BASE_FRAME::CommonSettingsChanged( aEnvVarsChanged, aTextVarsChanged );
1209
1212
1214
1216
1217 if( m_symbol )
1219
1221
1223 GetCanvas()->Refresh();
1224
1226
1227 if( aEnvVarsChanged )
1228 SyncLibraries( true );
1229
1230 Layout();
1231 SendSizeEvent();
1232}
1233
1234
1236{
1237 // call my base class
1239
1240 // tooltips in toolbars
1242
1243 // For some obscure reason, the AUI manager hides the first modified pane.
1244 // So force show panes
1245 wxAuiPaneInfo& tree_pane_info = m_auimgr.GetPane( m_treePane );
1246 bool tree_shown = tree_pane_info.IsShown();
1247 tree_pane_info.Caption( _( "Libraries" ) );
1248 tree_pane_info.Show( tree_shown );
1249 m_auimgr.Update();
1250
1252
1253 // status bar
1255
1256 if( GetRenderSettings()->m_ShowPinsElectricalType )
1257 {
1259 GetCanvas()->Refresh();
1260 }
1261
1262 UpdateTitle();
1263}
1264
1265
1267{
1268 SCH_BASE_FRAME::SetScreen( aScreen );
1269
1270 // Let tools add things to the view if necessary
1271 if( m_toolManager )
1273}
1274
1275
1277{
1285
1286 // Let tools add things to the view if necessary
1287 if( m_toolManager )
1289
1291 GetCanvas()->Refresh();
1292}
1293
1294
1296{
1297 SyncLibraries( true );
1298
1299 if( m_symbol )
1300 {
1302 EE_SELECTION& selection = selectionTool->GetSelection();
1303
1304 for( LIB_ITEM& item : m_symbol->GetDrawItems() )
1305 {
1306 if( !alg::contains( selection, &item ) )
1307 item.ClearSelected();
1308 else
1309 item.SetSelected();
1310 }
1311
1313 }
1314
1315 RebuildView();
1316}
1317
1318
1319const BOX2I SYMBOL_EDIT_FRAME::GetDocumentExtents( bool aIncludeAllVisible ) const
1320{
1321 if( !m_symbol )
1322 {
1323 // Gives a reasonable drawing area size
1324 int width = schIUScale.mmToIU( 50 );
1325 int height = schIUScale.mmToIU( 30 );
1326
1327 return BOX2I( VECTOR2I( -width/2, -height/2 ),
1328 VECTOR2I( width, height ) );
1329 }
1330 else
1331 {
1332 return m_symbol->Flatten()->GetUnitBoundingBox( m_unit, m_convert );
1333 }
1334}
1335
1336
1338{
1339 static KIID lastBrightenedItemID( niluuid );
1340
1341 LIB_ITEM* lastItem = nullptr;
1342
1343 if( m_symbol )
1344 {
1345 for( LIB_PIN* pin : m_symbol->GetAllLibPins() )
1346 {
1347 if( pin->m_Uuid == lastBrightenedItemID )
1348 lastItem = pin;
1349 }
1350
1351 std::vector<LIB_FIELD*> fields;
1352
1353 m_symbol->GetFields( fields );
1354
1355 for( LIB_FIELD* field : fields )
1356 {
1357 if( field->m_Uuid == lastBrightenedItemID )
1358 lastItem = field;
1359 }
1360 }
1361
1362 if( lastItem && lastItem != aItem )
1363 {
1364 lastItem->ClearBrightened();
1365
1366 UpdateItem( lastItem );
1367 lastBrightenedItemID = niluuid;
1368 }
1369
1370 if( aItem )
1371 {
1372 if( !aItem->IsBrightened() )
1373 {
1374 aItem->SetBrightened();
1375
1376 UpdateItem( aItem );
1377 lastBrightenedItemID = aItem->m_Uuid;
1378 }
1379
1380 FocusOnLocation( VECTOR2I( aItem->GetFocusPosition().x, -aItem->GetFocusPosition().y ) );
1381 }
1382}
1383
1384
1386{
1387 const std::string& payload = mail.GetPayload();
1388
1389 switch( mail.Command() )
1390 {
1391 case MAIL_LIB_EDIT:
1392 if( !payload.empty() )
1393 {
1394 wxString libFileName( payload );
1395 wxString libNickname;
1396 wxString msg;
1397
1399 const LIB_TABLE_ROW* libTableRow = libTable->FindRowByURI( libFileName );
1400
1401 if( !libTableRow )
1402 {
1403 msg.Printf( _( "The current configuration does not include the library '%s'.\n"
1404 "Use Manage Symbol Libraries to edit the configuration." ),
1405 libFileName );
1406 DisplayErrorMessage( this, _( "Library not found in symbol library table." ), msg );
1407 break;
1408 }
1409
1410 libNickname = libTableRow->GetNickName();
1411
1412 if( !libTable->HasLibrary( libNickname, true ) )
1413 {
1414 msg.Printf( _( "The library '%s' is not enabled in the current configuration.\n"
1415 "Use Manage Symbol Libraries to edit the configuration." ),
1416 UnescapeString( libNickname ) );
1417 DisplayErrorMessage( this, _( "Symbol library not enabled." ), msg );
1418 break;
1419 }
1420
1421 SetCurLib( libNickname );
1422
1423 if( m_treePane )
1424 {
1425 LIB_ID id( libNickname, wxEmptyString );
1429 }
1430 }
1431
1432 break;
1433
1434 case MAIL_RELOAD_LIB:
1435 {
1436 wxString currentLib = GetCurLib();
1438
1440
1441 // Check if the currently selected symbol library been removed or disabled.
1442 if( !currentLib.empty() && libTable && !libTable->HasLibrary( currentLib, true ) )
1443 {
1444 SetCurLib( wxEmptyString );
1445 emptyScreen();
1446 }
1447
1448 SyncLibraries( true );
1451
1452 break;
1453 }
1454
1456 {
1458 LIB_SYMBOL* symbol = GetCurSymbol();
1459
1460 wxLogTrace( "KICAD_LIB_WATCH", "Received refresh symbol request for %s",
1461 payload );
1462
1463 if( !tbl || !symbol )
1464 break;
1465
1466 wxString libName = symbol->GetLibId().GetLibNickname();
1467 const SYMBOL_LIB_TABLE_ROW* row = tbl->FindRow( libName );
1468
1469 if( !row )
1470 return;
1471
1472 wxFileName libfullname( row->GetFullURI( true ) );
1473
1474 wxFileName changedLib( mail.GetPayload() );
1475 wxLogTrace( "KICAD_LIB_WATCH",
1476 "Received refresh symbol request for %s, current symbols is %s",
1477 changedLib.GetFullPath(), libfullname.GetFullPath() );
1478
1479 if( changedLib == libfullname )
1480 {
1481 wxLogTrace( "KICAD_LIB_WATCH", "Refreshing symbol %s", symbol->GetName() );
1482
1483 m_libMgr->UpdateLibraryBuffer( libName );
1484
1485 LIB_SYMBOL* lib_symbol = m_libMgr->GetBufferedSymbol( symbol->GetName(), libName );
1486 wxCHECK2_MSG( lib_symbol, break, wxString::Format( "Symbol %s not found in library %s",
1487 symbol->GetName(), libName ) );
1488
1489 // The buffered screen for the symbol
1490 SCH_SCREEN* symbol_screen = m_libMgr->GetScreen( lib_symbol->GetName(), libName );
1491
1492 SetScreen( symbol_screen );
1493 SetCurSymbol( new LIB_SYMBOL( *lib_symbol ), false );
1495 SetShowDeMorgan( GetCurSymbol()->HasConversion() );
1496
1497 if( m_toolManager )
1499 }
1500
1501 break;
1502 }
1503
1504 default:
1505 ;
1506 }
1507}
1508
1509
1511{
1512 // switches currently used canvas ( Cairo / OpenGL):
1513 SCH_BASE_FRAME::SwitchCanvas( aCanvasType );
1514
1515 // Set options specific to symbol editor (axies are always enabled):
1516 GetCanvas()->GetGAL()->SetAxesEnabled( true );
1518}
1519
1520
1522{
1523 wxCHECK( m_libMgr, false );
1524
1525 return m_libMgr->HasModifications();
1526}
1527
1528
1530{
1531 wxCHECK( m_libMgr, false );
1532
1533 // Test if the currently edited symbol is modified
1535 return true;
1536
1537 // Test if any library has been modified
1538 for( const wxString& libName : m_libMgr->GetLibraryNames() )
1539 {
1540 if( m_libMgr->IsLibraryModified( libName ) && !m_libMgr->IsLibraryReadOnly( libName ) )
1541 return true;
1542 }
1543
1544 return false;
1545}
1546
1547
1549{
1550 if( aItemCount == 0 )
1551 return;
1552
1553 UNDO_REDO_CONTAINER& list = whichList == UNDO_LIST ? m_undoList : m_redoList;
1554
1555 for( PICKED_ITEMS_LIST* command : list.m_CommandsList )
1556 {
1557 command->ClearListAndDeleteItems( []( EDA_ITEM* aItem )
1558 {
1559 delete aItem;
1560 } );
1561 delete command;
1562 }
1563
1564 list.m_CommandsList.clear();
1565}
1566
1567
1569{
1570 return m_toolManager->GetTool<EE_SELECTION_TOOL>()->GetSelection();
1571}
1572
1573
1575{
1576 std::unique_ptr<LIB_SYMBOL> symbol = aSymbol->GetLibSymbolRef()->Flatten();
1577 wxCHECK( symbol, /* void */ );
1578
1579 // Take in account the symbol orientation and mirroring. to calculate the field
1580 // positions in symbol editor (i.e. no rotation, no mirroring)
1581 int orientation = aSymbol->GetOrientation() & ~( SYM_MIRROR_X | SYM_MIRROR_Y );
1582 int mirror = aSymbol->GetOrientation() & ( SYM_MIRROR_X | SYM_MIRROR_Y );
1583
1584 std::vector<LIB_FIELD> fullSetOfFields;
1585
1586 for( int i = 0; i < (int) aSymbol->GetFields().size(); ++i )
1587 {
1588 const SCH_FIELD& field = aSymbol->GetFields()[i];
1589 VECTOR2I pos = field.GetPosition() - aSymbol->GetPosition();
1590 LIB_FIELD libField( symbol.get(), field.GetId() );
1591
1592 if( i >= MANDATORY_FIELDS && !field.GetName( false ).IsEmpty() )
1593 libField.SetName( field.GetName( false ) );
1594
1595 libField.SetText( field.GetText() );
1596 libField.SetAttributes( field );
1597
1598 // The inverse transform is mirroring before, rotate after
1599 switch( mirror )
1600 {
1601 default:; break;
1602 case SYM_MIRROR_X: pos.y = -pos.y; break;
1603 case SYM_MIRROR_Y: pos.x = -pos.x; break;
1604 }
1605
1606 switch( orientation )
1607 {
1608 default:
1609 case SYM_ORIENT_0: break;
1610 case SYM_ORIENT_90:
1611 std::swap( pos.x, pos.y );
1612 pos.x = - pos.x;
1613 break;
1614 case SYM_ORIENT_270:
1615 std::swap( pos.x, pos.y );
1616 pos.y = - pos.y;
1617 break;
1618 case SYM_ORIENT_180:
1619 pos.x = - pos.x;
1620 pos.y = - pos.y;
1621 break;
1622 }
1623
1624 libField.SetPosition( VECTOR2I( pos.x, -pos.y ) );
1625
1626 fullSetOfFields.emplace_back( std::move( libField ) );
1627 }
1628
1629 symbol->SetFields( fullSetOfFields );
1630
1631 if( m_symbol )
1632 SetCurSymbol( nullptr, false );
1633
1635 m_schematicSymbolUUID = aSymbol->m_Uuid;
1636 m_reference = symbol->GetFieldById( REFERENCE_FIELD )->GetText();
1637 m_unit = std::max( 1, aSymbol->GetUnit() );
1638 m_convert = std::max( 1, aSymbol->GetConvert() );
1639
1640 // Optimize default edit options for this symbol
1641 // Usually if units are locked, graphic items are specific to each unit
1642 // and if units are interchangeable, graphic items are common to units
1644 tools->SetDrawSpecificUnit( symbol->UnitsLocked() );
1645
1646 // The buffered screen for the symbol
1647 SCH_SCREEN* tmpScreen = new SCH_SCREEN();
1648
1649 SetScreen( tmpScreen );
1650 SetCurSymbol( symbol.release(), true );
1651 setSymWatcher( nullptr );
1652
1655
1656 if( IsSymbolTreeShown() )
1657 {
1658 wxCommandEvent evt;
1659 OnToggleSymbolTree( evt );
1660 }
1661
1662 UpdateTitle();
1664 SetShowDeMorgan( GetCurSymbol()->HasConversion() );
1666
1667 // Let tools add things to the view if necessary
1668 if( m_toolManager )
1670
1672 GetCanvas()->Refresh();
1673}
1674
1675
1676bool SYMBOL_EDIT_FRAME::addLibTableEntry( const wxString& aLibFile, TABLE_SCOPE aScope )
1677{
1678 wxFileName fn = aLibFile;
1679 wxFileName libTableFileName( Prj().GetProjectPath(),
1681 wxString libNickname = fn.GetName();
1683 const ENV_VAR_MAP& envVars = Pgm().GetLocalEnvVariables();
1684
1685 if( libTable->HasLibrary( libNickname ) )
1686 {
1687 wxString tmp;
1688 int suffix = 1;
1689
1690 while( libTable->HasLibrary( libNickname ) )
1691 {
1692 tmp.Printf( "%s%d", fn.GetName(), suffix );
1693 libNickname = tmp;
1694 suffix += 1;
1695 }
1696 }
1697
1699 row->SetNickName( libNickname );
1700
1701 wxString normalizedPath = NormalizePath( aLibFile, &envVars, Prj().GetProjectPath() );
1702
1703 if( aScope == GLOBAL_LIB_TABLE )
1704 {
1706 libTableFileName = SYMBOL_LIB_TABLE::GetGlobalTableFileName();
1707
1708 // We cannot normalize against the current project path when saving to global table.
1709 normalizedPath = NormalizePath( aLibFile, &envVars, wxEmptyString );
1710 }
1711
1712 row->SetFullURI( normalizedPath );
1713
1714 wxCHECK( libTable->InsertRow( row ), false );
1715
1716 try
1717 {
1718 libTable->Save( libTableFileName.GetFullPath() );
1719 }
1720 catch( const IO_ERROR& ioe )
1721 {
1722 wxString msg = aScope == GLOBAL_LIB_TABLE ? _( "Error saving global library table." )
1723 : _( "Error saving project library table." );
1724
1725 wxMessageDialog dlg( this, msg, _( "File Save Error" ), wxOK | wxICON_ERROR );
1726 dlg.SetExtendedMessage( ioe.What() );
1727 dlg.ShowModal();
1728
1729 return false;
1730 }
1731
1732 return true;
1733}
1734
1735
1736bool SYMBOL_EDIT_FRAME::replaceLibTableEntry( const wxString& aLibNickname,
1737 const wxString& aLibFile )
1738{
1739 // Check the global library table first because checking the project library table
1740 // checks the global library table as well due to library chaining.
1741 bool isGlobalTable = true;
1742 wxFileName libTableFileName = SYMBOL_LIB_TABLE::GetGlobalTableFileName();;
1743 const ENV_VAR_MAP& envVars = Pgm().GetLocalEnvVariables();
1745 SYMBOL_LIB_TABLE_ROW* row = libTable->FindRow( aLibNickname );
1746
1747 if( !row )
1748 {
1749 libTableFileName.SetPath( Prj().GetProjectPath() );
1750 libTableFileName.SetName( SYMBOL_LIB_TABLE::GetSymbolLibTableFileName() );
1751 libTable = PROJECT_SCH::SchSymbolLibTable( &Prj() );
1752 isGlobalTable = false;
1753 row = libTable->FindRow( aLibNickname );
1754 }
1755
1756 wxCHECK( row, false );
1757
1758 wxString projectPath;
1759
1760 if( !isGlobalTable )
1761 projectPath = Prj().GetProjectPath();
1762
1763 wxString normalizedPath = NormalizePath( aLibFile, &envVars, projectPath );
1764
1765 row->SetFullURI( normalizedPath );
1766 row->SetType( "KiCad" );
1767
1768 try
1769 {
1770 libTable->Save( libTableFileName.GetFullPath() );
1771 }
1772 catch( const IO_ERROR& ioe )
1773 {
1774 wxString msg = isGlobalTable ? _( "Error saving global library table." )
1775 : _( "Error saving project library table." );
1776
1777 wxMessageDialog dlg( this, msg, _( "File Save Error" ), wxOK | wxICON_ERROR );
1778 dlg.SetExtendedMessage( ioe.What() );
1779 dlg.ShowModal();
1780
1781 return false;
1782 }
1783
1784 return true;
1785}
1786
1787
1789{
1790 return m_symbol && !m_symbol->IsRoot();
1791}
1792
1793
1795{
1797}
1798
1799
1800void SYMBOL_EDIT_FRAME::UpdateItem( EDA_ITEM* aItem, bool isAddOrDelete, bool aUpdateRtree )
1801{
1802 SCH_BASE_FRAME::UpdateItem( aItem, isAddOrDelete, aUpdateRtree );
1803
1804 if( EDA_TEXT* eda_text = dynamic_cast<EDA_TEXT*>( aItem ) )
1805 {
1806 eda_text->ClearBoundingBoxCache();
1807 eda_text->ClearRenderCache();
1808 }
1809}
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:104
@ icon_libedit_32
@ icon_libedit
@ icon_libedit_16
BOX2< VECTOR2I > BOX2I
Definition: box2.h:853
static TOOL_ACTION toggleGrid
Definition: actions.h:148
static TOOL_ACTION paste
Definition: actions.h:69
static TOOL_ACTION cancelInteractive
Definition: actions.h:63
static TOOL_ACTION millimetersUnits
Definition: actions.h:156
static TOOL_ACTION unselectAll
Definition: actions.h:72
static TOOL_ACTION revert
Definition: actions.h:55
static TOOL_ACTION copy
Definition: actions.h:68
static TOOL_ACTION milsUnits
Definition: actions.h:155
static TOOL_ACTION toggleBoundingBoxes
Definition: actions.h:111
static TOOL_ACTION saveAll
Definition: actions.h:54
static TOOL_ACTION undo
Definition: actions.h:65
static TOOL_ACTION duplicate
Definition: actions.h:73
static TOOL_ACTION inchesUnits
Definition: actions.h:154
static TOOL_ACTION toggleCursorStyle
Definition: actions.h:108
static TOOL_ACTION doDelete
Definition: actions.h:74
static TOOL_ACTION selectionTool
Definition: actions.h:163
static TOOL_ACTION save
Definition: actions.h:51
static TOOL_ACTION zoomFitScreen
Definition: actions.h:100
static TOOL_ACTION redo
Definition: actions.h:66
static TOOL_ACTION deleteTool
Definition: actions.h:75
static TOOL_ACTION zoomTool
Definition: actions.h:103
static TOOL_ACTION showProperties
Definition: actions.h:177
static TOOL_ACTION cut
Definition: actions.h:67
static TOOL_ACTION ddAddLibrary
Definition: actions.h:60
static TOOL_ACTION toggleGridOverrides
Definition: actions.h:149
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:92
WINDOW_SETTINGS m_Window
Definition: app_settings.h:169
wxString m_ColorTheme
Active color theme name.
Definition: app_settings.h:172
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:203
void SetSize(const Vec &size)
Definition: box2.h:214
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:85
virtual const VECTOR2I GetFocusPosition() const
Similar to GetPosition, but allows items to return their visual center rather than their anchor.
Definition: eda_item.h:246
const KIID m_Uuid
Definition: eda_item.h:482
void ClearBrightened()
Definition: eda_item.h:119
void SetBrightened()
Definition: eda_item.h:116
bool IsBrightened() const
Definition: eda_item.h:108
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:80
virtual const wxString & GetText() const
Return the string associated with the text object.
Definition: eda_text.h:95
void SetAttributes(const EDA_TEXT &aSrc, bool aSetPosition=true)
Set the text attributes from another instance.
Definition: eda_text.cpp:276
virtual void SetText(const wxString &aText)
Definition: eda_text.cpp:183
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:115
static TOOL_ACTION drawSymbolPolygon
Definition: ee_actions.h:114
static TOOL_ACTION showDeMorganAlternate
Definition: ee_actions.h:136
static TOOL_ACTION newSymbol
Definition: ee_actions.h:200
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:198
static TOOL_ACTION symbolImportGraphics
Definition: ee_actions.h:116
static TOOL_ACTION placeSymbolText
Definition: ee_actions.h:111
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:209
static TOOL_ACTION showDatasheet
Inspection and Editing.
Definition: ee_actions.h:150
static TOOL_ACTION saveSymbolCopyAs
Definition: ee_actions.h:199
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:212
static TOOL_ACTION drawSymbolTextBox
Definition: ee_actions.h:112
static TOOL_ACTION drawSymbolLines
Definition: ee_actions.h:113
static TOOL_ACTION drawArc
Definition: ee_actions.h:97
static TOOL_ACTION toggleSyncedPinsMode
Definition: ee_actions.h:239
static TOOL_ACTION showSymbolTree
Definition: ee_actions.h:247
static TOOL_ACTION placeSymbolPin
Definition: ee_actions.h:110
static TOOL_ACTION showElectricalTypes
Definition: ee_actions.h:245
Tool that displays edit points allowing to modify items by dragging the points.
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:192
void ClearHiddenFlags()
Clear the hide flag of all items in the view.
Definition: sch_view.cpp:185
void Clear()
Remove all items from the view.
Definition: view.cpp:1115
void UpdateAllItems(int aUpdateFlags)
Update all items in the view according to the given flags.
Definition: view.cpp:1500
Definition: kiid.h:49
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:737
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:553
Field object used in symbol libraries.
Definition: lib_field.h:62
void SetName(const wxString &aName)
Set a user definable field name to aName.
Definition: lib_field.cpp:507
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
The base class for drawable items used by schematic library symbols.
Definition: lib_item.h:68
@ BASE
Definition: lib_item.h:77
@ DEMORGAN
Definition: lib_item.h:77
void SetPosition(const VECTOR2I &aPosition) override
Definition: lib_item.h:297
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:599
bool UnitsLocked() const
Check whether symbol units are interchangeable.
Definition: lib_symbol.h:285
bool IsRoot() const override
For symbols derived from other symbols, IsRoot() indicates no derivation.
Definition: lib_symbol.h:214
wxString GetUnitDisplayName(int aUnit) override
Return the user-defined display name for aUnit for symbols with units.
Definition: lib_symbol.cpp:551
LIB_ITEMS_CONTAINER & GetDrawItems()
Return a reference to the draw item list.
Definition: lib_symbol.h:544
LIB_ID GetLibId() const override
Definition: lib_symbol.h:163
wxString GetName() const override
Definition: lib_symbol.h:160
void GetFields(std::vector< LIB_FIELD * > &aList)
Return a list of fields within this symbol.
wxString GetLibNickname() const override
Sets the Description field text value.
Definition: lib_symbol.h:169
std::vector< LIB_PIN * > GetAllLibPins() const
Return a list of pin pointers for all units / converts.
void ClearCaches()
Definition: lib_symbol.cpp:682
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:605
LIB_FIELD & GetDatasheetField()
Return reference to the datasheet field.
LIB_SYMBOL_SPTR GetRootSymbol() const
Get the parent symbol that does not have another parent.
Definition: lib_symbol.cpp:527
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:396
LIB_TREE_NODE * GetCurrentTreeNode() const
Definition: lib_tree.cpp:302
void CenterLibId(const LIB_ID &aLibId)
Ensure that an item is visible (preferably centered).
Definition: lib_tree.cpp:319
int GetSelectionCount() const
Definition: lib_tree.h:90
void ShowChangedLanguage()
Definition: lib_tree.cpp:261
void SelectLibId(const LIB_ID &aLibId)
Select an item in the tree widget.
Definition: lib_tree.cpp:313
LIB_TREE_MODEL_ADAPTER::SORT_MODE GetSortMode() const
Definition: lib_tree.h:137
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:285
void Unselect()
Unselect currently selected item in wxDataViewCtrl.
Definition: lib_tree.cpp:325
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:271
void ExpandLibId(const LIB_ID &aLibId)
Expand and item i the tree widget.
Definition: lib_tree.cpp:331
void Regenerate(bool aKeepState)
Regenerate the tree.
Definition: lib_tree.cpp:378
static wxString GetDefaultUserSymbolsPath()
Gets the default path we point users to create projects.
Definition: paths.cpp:98
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:143
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:277
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:288
float SplitterProportion() const
Action handler for the Properties panel.
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:52
VECTOR2I GetPosition() const override
Definition: sch_field.cpp:1261
int GetId() const
Definition: sch_field.h:128
wxString GetName(bool aUseDefaultName=true) const
Return the field name (not translated).
Definition: sch_field.cpp:1000
static const wxString ShowType(SCH_FILE_T aFileType)
Return a brief name for a plugin, given aFileType enum.
Definition: sch_io_mgr.cpp:92
Schematic symbol object.
Definition: sch_symbol.h:81
int GetUnit() const
Definition: sch_symbol.h:226
int GetConvert() const
Definition: sch_symbol.h:268
VECTOR2I GetPosition() const override
Definition: sch_symbol.h:698
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:981
std::unique_ptr< LIB_SYMBOL > & GetLibSymbolRef()
Definition: sch_symbol.h:190
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 FocusOnItem(LIB_ITEM *aItem)
void setupUIConditions() override
Setup the UI conditions for the various actions and their controls in this frame.
APP_SETTINGS_BASE * config() const override
Returns the settings object used in SaveSettings(), and is overloaded in KICAD_MANAGER_FRAME.
bool addLibTableEntry(const wxString &aLibFile, TABLE_SCOPE aScope=GLOBAL_LIB_TABLE)
Add aLibFile to the symbol library table defined by aScope.
void storeCurrentSymbol()
Rename LIB_SYMBOL aliases to avoid conflicts before adding a symbol to a library.
const BOX2I GetDocumentExtents(bool aIncludeAllVisible=true) const override
Returns bbox of document with option to not include some items.
SELECTION & GetCurrentSelection() override
Get the current selection from the canvas area.
wxString getTargetLib() const
bool IsCurrentSymbol(const LIB_ID &aLibId) const
Restore the empty editor screen, without any symbol or library selected.
bool backupFile(const wxFileName &aOriginalFile, const wxString &aBackupExt)
Return currently edited symbol.
void 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 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.
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:165
TOOL_DISPATCHER * m_toolDispatcher
Definition: tools_holder.h:167
TOOL_MANAGER * GetToolManager() const
Return the MVC controller.
Definition: tools_holder.h:55
ACTIONS * m_actions
Definition: tools_holder.h:166
@ 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:57
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:145
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:289
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:280
void DisplayErrorMessage(wxWindow *aParent, const wxString &aText, const wxString &aExtraInfo)
Display an error message with aMessage.
Definition: confirm.cpp:305
int UnsavedChangesDialog(wxWindow *parent, const wxString &aMessage, bool *aApplyToAll)
A specialized version of HandleUnsavedChanges which handles an apply-to-all checkbox.
Definition: confirm.cpp:177
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 & defaultPropertiesPaneInfo()
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()
std::map< wxString, ENV_VAR_ITEM > ENV_VAR_MAP
PROJECT & Prj()
Definition: kicad.cpp:576
KIID niluuid(0)
KIWAY Kiway
@ LAYER_SCHEMATIC_GRID_AXES
Definition: layer_ids.h:381
@ MAIL_LIB_EDIT
Definition: mail_type.h:54
@ MAIL_REFRESH_SYMBOL
Definition: mail_type.h:58
@ MAIL_RELOAD_LIB
Definition: mail_type.h:56
@ ALL
All except INITIAL_ADD.
Definition: view_item.h:58
void SetShutdownBlockReason(wxWindow *aWindow, const wxString &aReason)
Sets the block reason why the window/application is preventing OS shutdown.
Definition: gtk/app.cpp:90
bool SupportsShutdownBlockReason()
Whether or not the window supports setting a shutdown block reason.
Definition: gtk/app.cpp:79
bool contains(const _Container &__container, _Value __value)
Returns true if the container contains the given value.
Definition: kicad_algo.h:100
void InvokeSchEditSymbolLibTable(KIWAY *aKiway, wxWindow *aParent)
void Refresh()
Update the board display after modifying it by a python script (note: it is automatically called by a...
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:119
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 5 are mandatory, and must be instantiated in SCH_COMPONENT and LIB_PART constructors.
@ REFERENCE_FIELD
Field Reference of part, i.e. "IC21".
VECTOR2< double > VECTOR2D
Definition: vector2d.h:587
VECTOR2< int > VECTOR2I
Definition: vector2d.h:588
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.