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 The 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, see <https://www.gnu.org/licenses/>.
20 */
21
22#include <bitmaps.h>
26#include <api/api_server.h>
28#include <api/api_utils.h>
29#include <wx/hyperlink.h>
30#include <base_screen.h>
31#include <confirm.h>
32#include <core/kicad_algo.h>
33#include <core/throttle.h>
34#include <eeschema_id.h>
35#include <eeschema_settings.h>
36#include <env_paths.h>
38#include <kidialog.h>
39#include <kiface_base.h>
40#include <kiplatform/app.h>
41#include <kiplatform/io.h>
42#include <kiway_mail.h>
43#include <symbol_edit_frame.h>
44#include <sch_edit_frame.h>
48#include <paths.h>
49#include <pgm_base.h>
50#include <project_sch.h>
51#include <sch_painter.h>
52#include <sch_view.h>
56#include <tool/action_manager.h>
57#include <tool/action_toolbar.h>
58#include <tool/common_control.h>
59#include <tool/common_tools.h>
61#include <tool/embed_tool.h>
63#include <tool/picker_tool.h>
65#include <tool/selection.h>
67#include <tool/tool_manager.h>
68#include <tool/zoom_tool.h>
69#include <tools/sch_actions.h>
81#include <view/view_controls.h>
83#include <widgets/wx_infobar.h>
89#include <widgets/lib_tree.h>
94#include <panel_sym_lib_table.h>
95#include <string_utils.h>
97#include <wx/dir.h>
98#include <wx/msgdlg.h>
99#include <wx/combobox.h>
100#include <wx/log.h>
101#include <wx/wfstream.h>
102#include <wx/zipstrm.h>
103#include <trace_helpers.h>
104
105
107
108
112class UNPACKED_SYMBOL_LIBRARY_DIR_TRAVERSER : public wxDirTraverser
113{
114public:
115 UNPACKED_SYMBOL_LIBRARY_DIR_TRAVERSER( std::vector<wxString>& aFiles ) :
116 m_files( aFiles) { }
117
118 virtual wxDirTraverseResult OnFile( const wxString& aFilename ) override
119 {
120 wxFileName fn( aFilename );
122
123 if( ext.CmpNoCase( fn.GetExt() ) == 0 )
124 m_files.push_back( aFilename );
125
126 return wxDIR_CONTINUE;
127 }
128
129 virtual wxDirTraverseResult OnDir( const wxString& WXUNUSED( aDirname ) ) override
130 {
131 return wxDIR_CONTINUE;
132 }
133
134private:
135 std::vector<wxString>& m_files;
136};
137
138
139BEGIN_EVENT_TABLE( SYMBOL_EDIT_FRAME, SCH_BASE_FRAME )
142
143 // menubar commands
146
147 // Update user interface elements.
150
153
154 // Drop files event
155 EVT_DROP_FILES( SYMBOL_EDIT_FRAME::OnDropFiles )
156
157END_EVENT_TABLE()
158
159
160SYMBOL_EDIT_FRAME::SYMBOL_EDIT_FRAME( KIWAY* aKiway, wxWindow* aParent ) :
161 SCH_BASE_FRAME( aKiway, aParent, FRAME_SCH_SYMBOL_EDITOR, _( "Symbol Editor" ),
162 wxDefaultPosition, wxDefaultSize, KICAD_DEFAULT_DRAWFRAME_STYLE,
164 m_unitSelectBox( nullptr ),
165 m_bodyStyleSelectBox( nullptr ),
166 m_drawSpecificUnit( false ),
170{
171 m_symbol = nullptr;
172 m_treePane = nullptr;
173 m_libMgr = nullptr;
174 m_unit = 1;
175 m_bodyStyle = 1;
177 m_aboutTitle = _HKI( "KiCad Symbol Editor" );
178
179 wxIcon icon;
180 wxIconBundle icon_bundle;
181
182 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_libedit, 48 ) );
183 icon_bundle.AddIcon( icon );
184 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_libedit, 256 ) );
185 icon_bundle.AddIcon( icon );
186 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_libedit, 128 ) );
187 icon_bundle.AddIcon( icon );
188 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_libedit_32 ) );
189 icon_bundle.AddIcon( icon );
190 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_libedit_16 ) );
191 icon_bundle.AddIcon( icon );
192
193 SetIcons( icon_bundle );
194
197
199
200 m_treePane = new SYMBOL_TREE_PANE( this, m_libMgr );
201 m_treePane->GetLibTree()->SetSortMode( (LIB_TREE_MODEL_ADAPTER::SORT_MODE) m_settings->m_LibrarySortMode );
202
204
205 // Ensure axis are always drawn
207 gal_opts.m_axesEnabled = true;
208
211 GetScreen()->m_Center = true;
212
213 GetCanvas()->GetViewControls()->SetCrossHairCursorPosition( VECTOR2D( 0, 0 ), false );
214
215 GetRenderSettings()->LoadColors( GetColorSettings() );
216 GetRenderSettings()->m_IsSymbolEditor = true;
217 GetCanvas()->GetGAL()->SetAxesColor( m_colorSettings->GetColor( LAYER_SCHEMATIC_GRID_AXES ) );
218
219 setupTools();
221
223
226
230
233
234 m_propertiesPanel = new SCH_PROPERTIES_PANEL( this, this );
235 m_propertiesPanel->SetSplitterProportion( m_settings->m_AuiPanels.properties_splitter );
236
238
239 m_auimgr.SetManagedWindow( this );
240
242
243 // Rows; layers 4 - 6
244 m_auimgr.AddPane( m_tbTopMain, EDA_PANE().HToolbar().Name( "TopMainToolbar" )
245 .Top().Layer( 6 ) );
246
247 m_auimgr.AddPane( m_messagePanel, EDA_PANE().Messages().Name( "MsgPanel" )
248 .Bottom().Layer( 6 ) );
249
250 m_auimgr.AddPane( m_tbLeft, EDA_PANE().VToolbar().Name( "LeftToolbar" )
251 .Left().Layer( 2 ) );
252
253 m_auimgr.AddPane( m_tbRight, EDA_PANE().VToolbar().Name( "RightToolbar" )
254 .Right().Layer( 2 ) );
255
256 m_tabsPanel = new EDITOR_TABS_PANEL( this, GetCanvas() );
257
258 m_tabsPanel->onActivateTab =
259 [this]( int aIdx )
260 {
262 activateSymbolTab( ctx );
263 };
264
265 m_tabsPanel->onCloseTabRequested =
266 [this]( int aIdx ) -> bool
267 {
268 return promptAndCloseSymbolTab( aIdx );
269 };
270
271 m_tabsPanel->onQueryVisualState =
272 [this]( int aIdx ) -> TAB_VISUAL_STATE
273 {
274 // The panel model owns preview. Read modified from the live context.
275 const std::vector<EDITOR_TABS_MODEL::ENTRY>& entries = m_tabsPanel->Model().Entries();
276
277 if( aIdx < 0 || aIdx >= static_cast<int>( entries.size() ) )
278 return TAB_VISUAL_STATE{};
279
280 bool modified = entries[aIdx].modified;
281
283 modified = ctx->IsModified();
284
285 return ResolveTabVisualState( entries[aIdx].preview, modified );
286 };
287
288 m_auimgr.AddPane( m_tabsPanel, wxAuiPaneInfo().Name( "DrawFrame" )
289 .CentrePane() );
290
291 // Columns; layers 1 - 3
292 m_auimgr.AddPane( m_treePane, EDA_PANE().Palette().Name( "LibraryTree" )
293 .Left().Layer( 3 )
294 .TopDockable( false ).BottomDockable( false )
295 .Caption( _( "Libraries" ) )
296 // Don't use -1 for don't-change-height on a growable panel; it has side-effects.
297 .MinSize( FromDIP( 250 ), FromDIP( 80 ) )
298 .BestSize( FromDIP( 250 ), -1 ) );
299
302
303 // Can be called only when all panes are created, because (at least on Windows) when items
304 // managed by m_auimgr are not the same as those existing when saved by Perspective()
305 // in config, broken settings can happen.
307
308 // Protect against broken saved Perspective() due to bugs in previous version
309 // This is currently a workaround.
310 m_auimgr.GetPane( "TopMainToolbar" ).Top().Layer( 6 ).Position(0).Show( true );
311 m_auimgr.GetPane( "LeftToolbar" ).Position(0).Show( true );
312 m_auimgr.GetPane( "RightToolbar" ).Show( true );
313
314 // Show or hide m_propertiesPanel depending on current settings:
315 wxAuiPaneInfo& propertiesPaneInfo = m_auimgr.GetPane( PropertiesPaneName() );
316 wxAuiPaneInfo& selectionFilterPane = m_auimgr.GetPane( wxS( "SelectionFilter" ) );
317 // The selection filter doesn't need to grow in the vertical direction when docked
318 selectionFilterPane.dock_proportion = 0;
319
320 // wx 3.3.3 turns a -1 min height into 1, and a legacy perspective restores one
321 selectionFilterPane.min_size.y = m_selectionFilterPanel->GetBestSize().y;
322
323 propertiesPaneInfo.Show( m_settings->m_AuiPanels.show_properties );
325
327
328 // Can't put this in LoadSettings, because it has to be called before setupTools :/
330 selTool->GetFilter() = GetSettings()->m_SelectionFilter;
331 m_selectionFilterPanel->SetCheckboxesFromFilter( selTool->GetFilter() );
332
333 if( m_settings->m_LibWidth > 0 )
334 SetAuiPaneSize( m_auimgr, m_auimgr.GetPane( "LibraryTree" ), m_settings->m_LibWidth, -1 );
335
336 Raise();
337 Show( true );
338
339 SyncView();
340 GetCanvas()->GetView()->UseDrawPriority( true );
341 GetCanvas()->GetGAL()->SetAxesEnabled( true );
342
344
345 // Set the working/draw area size to display a symbol to a reasonable value:
346 // A 600mm x 600mm with a origin at the area center looks like a large working area
347 double max_size_x = schIUScale.mmToIU( 600 );
348 double max_size_y = schIUScale.mmToIU( 600 );
349 BOX2D bbox;
350 bbox.SetOrigin( -max_size_x /2, -max_size_y/2 );
351 bbox.SetSize( max_size_x, max_size_y );
352 GetCanvas()->GetView()->SetBoundary( bbox );
353
355
357 m_acceptedExts.emplace( wxS( "dxf" ), &SCH_ACTIONS::ddImportGraphics );
359 DragAcceptFiles( true );
360
361 KIPLATFORM::APP::SetShutdownBlockReason( this, _( "Library changes are unsaved" ) );
362
363 // Catch unhandled accelerator command characters that were no handled by the library tree
364 // panel.
366 Bind( wxEVT_CHAR_HOOK, &TOOL_DISPATCHER::DispatchWxEvent, m_toolDispatcher );
367
368 // GTK rejects WXK_TAB as an accelerator so cycle tabs from the char hook ahead of the dispatcher.
369 Bind( wxEVT_CHAR_HOOK, &SYMBOL_EDIT_FRAME::OnTabCharHook, this );
370
371 // Ensure the window is on top
372 Raise();
373
374 // run SyncLibraries with progress reporter enabled. The progress reporter is useful
375 // in debug mode because the loading time of ecah library can be really noticeable
376 SyncLibraries( true );
377
378 m_apiHandler = std::make_unique<API_HANDLER_SYMBOL>( this );
380
381 if( Kiface().IsSingle() )
382 {
383 m_apiHandlerCommon = std::make_unique<API_HANDLER_COMMON>();
385 m_apiLibrariesHandler = std::make_unique<API_HANDLER_LIBRARIES>(
388 }
389
390 // Must follow SyncLibraries so persisted tabs can resolve against the loaded libraries.
392}
393
394
396{
397 // Ensure that teardowns without doCloseWindow() are fully unregistered
399
400 if( Kiface().IsSingle() )
401 {
404 }
405
406 // Hand the borrowed canvas back before the base destructor frees it, else the panel reparents
407 // freed memory on its own teardown.
408 m_tabsPanel->ReleaseSharedCanvas();
409
410 // Shutdown all running tools
411 if( m_toolManager )
412 m_toolManager->ShutdownAllTools();
413
414 setSymWatcher( nullptr );
415
416 if( m_activeTab )
417 {
418 // Hand the working objects back so the context deletes them exactly once below; raw deleting
419 // here would double-free with the context dtor and leak the swapped-in undo list. Covers an
420 // active instance tab too, whose m_isSymbolFromSchematic mirror is only frame state.
422 m_activeTab->AdoptWorkingObjects( m_symbol, static_cast<SCH_SCREEN*>( GetScreen() ) );
423 m_activeTab = nullptr;
424 m_symbol = nullptr;
426 }
427 else
428 {
429 // No active tab owns the current screen, so let EDA_DRAW_FRAME free it.
431 }
432
433 // Free each detached context's undo/redo with the frame on the dummy screen to avoid double-frees.
434 for( const std::unique_ptr<SYMBOL_EDITOR_TAB_CONTEXT>& ctx : m_tabContexts )
436
437 m_tabContexts.clear();
438
440 Pgm().GetSettingsManager().Save( cfg );
441
442 delete m_libMgr;
443}
444
445
447{
448 wxCHECK_RET( m_settings, "Call to SYMBOL_EDIT_FRAME::LoadSettings with null m_settings" );
449
451
452 GetRenderSettings()->m_ShowPinsElectricalType = m_settings->m_ShowPinElectricalType;
453 GetRenderSettings()->m_ShowHiddenPins = m_settings->m_ShowHiddenPins;
454 GetRenderSettings()->m_ShowHiddenFields = m_settings->m_ShowHiddenFields;
455 GetRenderSettings()->m_ShowPinAltIcons = m_settings->m_ShowPinAltIcons;
456 GetRenderSettings()->SetDefaultFont( wxEmptyString );
457}
458
459
461{
462 wxCHECK_RET( m_settings, "Call to SYMBOL_EDIT_FRAME:SaveSettings with null m_settings" );
463
465
466 // The library tree is hidden while editing a symbol from the schematic. Force it visible in the
467 // serialized AUI layout so the user's preference survives a restart, but only touch the pane
468 // metadata (not ToggleLibraryTree) to avoid a mid-session repaint/flicker and a spurious tree
469 // width capture below.
470 wxAuiPaneInfo& treePane = m_auimgr.GetPane( m_treePane );
471 wxAuiPaneInfo& filterPane = m_auimgr.GetPane( wxS( "SelectionFilter" ) );
472
473 const bool treeShown = treePane.IsShown();
474 const bool filterShown = filterPane.IsShown();
475
476 // Gate on the pending-restore flag alone, not the active-tab schematic state, which is cleared
477 // when a schematic tab closes while the tree stays auto-hidden.
478 const bool forceTreeShown = m_libTreeAutoHiddenForSchematicEdit && !treeShown;
479
480 if( forceTreeShown )
481 {
482 treePane.Show( true );
484 }
485
487
488 if( forceTreeShown )
489 {
490 treePane.Show( treeShown );
491 filterPane.Show( filterShown );
492 }
493
494 m_settings->m_ShowPinElectricalType = GetRenderSettings()->m_ShowPinsElectricalType;
495 m_settings->m_ShowHiddenPins = GetRenderSettings()->m_ShowHiddenPins;
496 m_settings->m_ShowHiddenFields = GetRenderSettings()->m_ShowHiddenFields;
497 m_settings->m_ShowPinAltIcons = GetRenderSettings()->m_ShowPinAltIcons;
498
499 m_settings->m_LibWidth = m_treePane->GetSize().x;
500
501 m_settings->m_LibrarySortMode = GetLibTree()->GetSortMode();
502
503 m_settings->m_AuiPanels.properties_splitter = m_propertiesPanel->SplitterProportion();
504 bool prop_shown = m_auimgr.GetPane( PropertiesPaneName() ).IsShown();
505 m_settings->m_AuiPanels.show_properties = prop_shown;
506
507 if( TOOL_MANAGER* toolMgr = GetToolManager() )
508 {
509 if( SCH_SELECTION_TOOL* selTool = toolMgr->GetTool<SCH_SELECTION_TOOL>() )
510 m_settings->m_SelectionFilter = selTool->GetFilter();
511 }
512
514}
515
516
521
522
524{
526
527 if( cfg && static_cast<SYMBOL_EDITOR_SETTINGS*>( cfg )->m_UseEeschemaColorSettings )
528 cfg = GetAppSettings<EESCHEMA_SETTINGS>( "eeschema" );
529
530 return ::GetColorSettings( cfg ? cfg->m_ColorTheme : DEFAULT_THEME );
531}
532
533
535{
536 // Create the manager and dispatcher & route draw panel events to the dispatcher
538 m_toolManager->SetEnvironment( GetScreen(), GetCanvas()->GetView(), GetCanvas()->GetViewControls(), GetSettings(),
539 this );
540 m_actions = new SCH_ACTIONS();
542
543 // Register tools
544 m_toolManager->RegisterTool( new COMMON_CONTROL );
545 m_toolManager->RegisterTool( new COMMON_TOOLS );
546 m_toolManager->RegisterTool( new ZOOM_TOOL );
547 m_toolManager->RegisterTool( new SCH_SELECTION_TOOL );
548 m_toolManager->RegisterTool( new PICKER_TOOL );
549 m_toolManager->RegisterTool( new SCH_INSPECTION_TOOL );
550 m_toolManager->RegisterTool( new SYMBOL_EDITOR_PIN_TOOL );
551 m_toolManager->RegisterTool( new SYMBOL_EDITOR_DRAWING_TOOLS );
552 m_toolManager->RegisterTool( new EE_GRAPHIC_TOOL );
553 m_toolManager->RegisterTool( new SCH_POINT_EDITOR );
554 m_toolManager->RegisterTool( new SCH_FIND_REPLACE_TOOL );
555 m_toolManager->RegisterTool( new SYMBOL_EDITOR_MOVE_TOOL );
556 m_toolManager->RegisterTool( new SYMBOL_EDITOR_EDIT_TOOL );
557 m_toolManager->RegisterTool( new LIBRARY_EDITOR_CONTROL );
558 m_toolManager->RegisterTool( new SYMBOL_EDITOR_CONTROL );
559 m_toolManager->RegisterTool( new PROPERTIES_TOOL );
560 m_toolManager->RegisterTool( new EMBED_TOOL );
561 m_toolManager->InitTools();
562
563 // Run the selection tool, it is supposed to be always active
564 m_toolManager->InvokeTool( "common.InteractiveSelection" );
565
567}
568
569
571{
573
574 ACTION_MANAGER* mgr = m_toolManager->GetActionManager();
575 EDITOR_CONDITIONS cond( this );
576
577 wxASSERT( mgr );
578
579#define ENABLE( x ) ACTION_CONDITIONS().Enable( x )
580#define CHECK( x ) ACTION_CONDITIONS().Check( x )
581
582 auto haveSymbolCond =
583 [this]( const SELECTION& )
584 {
585 return m_symbol;
586 };
587
588 auto isGraphicallyEditableCond =
589 [this]( const SELECTION& )
590 {
592 };
593
594 auto isEditableInAliasCond =
595 [this]( const SELECTION& )
596 {
597 // Less restrictive than isGraphicallyEditableCond
598 // Symbols fields (root symbols and aliases) from the new s-expression libraries
599 // or in the schematic are editable.
600 return IsSymbolEditable();
601 };
602
603 auto canUpdateFieldsCond =
604 [this]( const SELECTION& )
605 {
606 return IsSymbolEditable() && m_symbol && m_symbol->CanUpdateFieldsFromParent();
607 };
608
609 auto revertableCondition =
610 [this]( const SELECTION& sel )
611 {
612 if( !m_libMgr )
613 return false;
614
615 const LIB_ID target = GetTargetLibId();
616
617 // A library row reverts the whole library
618 if( target.GetLibItemName().empty() )
619 return m_libMgr->IsLibraryModified( target.GetLibNickname() );
620
621 return m_libMgr->IsSymbolModified( target.GetLibItemName(), target.GetLibNickname() );
622 };
623
624 auto libSelectedCondition =
625 [this]( const SELECTION& sel )
626 {
627 return !GetTargetLibId().GetLibNickname().empty();
628 };
629
630 auto canEditProperties =
631 [this]( const SELECTION& sel )
632 {
634 };
635
636 auto symbolSelectedInTreeCondition =
637 [this]( const SELECTION& sel )
638 {
639 LIB_ID targetLibId = GetTargetLibId();
640 return !targetLibId.GetLibNickname().empty() && !targetLibId.GetLibItemName().empty();
641 };
642
643 auto saveSymbolAsCondition =
644 [this]( const SELECTION& aSel )
645 {
646 return getTargetSymbol() != nullptr;
647 };
648
649 const auto isSymbolFromSchematicCond =
650 [this]( const SELECTION& )
651 {
652 return IsSymbolFromSchematic();
653 };
654
655 // clang-format off
658 mgr->SetConditions( SCH_ACTIONS::saveLibraryAs, ENABLE( libSelectedCondition ) );
659 mgr->SetConditions( ACTIONS::exportForOlderVersion, ENABLE( libSelectedCondition ) );
660 mgr->SetConditions( SCH_ACTIONS::saveSymbolAs, ENABLE( saveSymbolAsCondition ) );
661 mgr->SetConditions( SCH_ACTIONS::saveSymbolCopyAs, ENABLE( saveSymbolAsCondition ) );
664 mgr->SetConditions( SCH_ACTIONS::editLibSymbolWithLibEdit, ENABLE( isSymbolFromSchematicCond ) );
665
666 mgr->SetConditions( ACTIONS::undo, ENABLE( haveSymbolCond && cond.UndoAvailable() ) );
667 mgr->SetConditions( ACTIONS::redo, ENABLE( haveSymbolCond && cond.RedoAvailable() ) );
668 mgr->SetConditions( ACTIONS::revert, ENABLE( revertableCondition ) );
669
672
673 mgr->SetConditions( ACTIONS::cut, ENABLE( isGraphicallyEditableCond ) );
674 mgr->SetConditions( ACTIONS::copy, ENABLE( haveSymbolCond ) );
675 mgr->SetConditions( ACTIONS::copyAsText, ENABLE( haveSymbolCond ) );
676 mgr->SetConditions( ACTIONS::paste, ENABLE( isGraphicallyEditableCond && SELECTION_CONDITIONS::Idle && cond.NoActiveTool() ) );
677 mgr->SetConditions( ACTIONS::doDelete, ENABLE( isGraphicallyEditableCond ) );
678 mgr->SetConditions( ACTIONS::duplicate, ENABLE( isGraphicallyEditableCond ) );
679 mgr->SetConditions( ACTIONS::selectAll, ENABLE( haveSymbolCond ) );
680 mgr->SetConditions( ACTIONS::unselectAll, ENABLE( haveSymbolCond ) );
681
682 // These actions in symbol editor when editing alias field rotations are allowed.
684 .HotkeyEnable( isEditableInAliasCond ) );
686 .HotkeyEnable( isEditableInAliasCond ) );
687
688 mgr->SetConditions( SCH_ACTIONS::mirrorH, ENABLE( SELECTION_CONDITIONS::NotEmpty && isGraphicallyEditableCond )
689 .HotkeyEnable( isGraphicallyEditableCond ) );
690 mgr->SetConditions( SCH_ACTIONS::mirrorV, ENABLE( SELECTION_CONDITIONS::NotEmpty && isGraphicallyEditableCond )
691 .HotkeyEnable( isGraphicallyEditableCond ) );
692
695 // clang-format on
696
697 auto pinTypeCond =
698 [this]( const SELECTION& )
699 {
701 };
702
703 auto hiddenPinCond =
704 [this]( const SELECTION& )
705 {
707 };
708
709 auto hiddenFieldCond =
710 [this]( const SELECTION& )
711 {
713 };
714
715 auto showPinAltIconsCond =
716 [this]( const SELECTION& )
717 {
719 };
720
721 auto showLibraryTreeCond =
722 [this]( const SELECTION& )
723 {
724 return IsLibraryTreeShown();
725 };
726
727 auto propertiesCond =
728 [this] ( const SELECTION& )
729 {
730 return m_auimgr.GetPane( PropertiesPaneName() ).IsShown();
731 };
732
735 mgr->SetConditions( ACTIONS::showLibraryTree, CHECK( showLibraryTreeCond ) );
736 mgr->SetConditions( ACTIONS::showProperties, CHECK( propertiesCond ) );
737 mgr->SetConditions( SCH_ACTIONS::showHiddenPins, CHECK( hiddenPinCond ) );
738 mgr->SetConditions( SCH_ACTIONS::showHiddenFields, CHECK( hiddenFieldCond ) );
739 mgr->SetConditions( SCH_ACTIONS::togglePinAltIcons, CHECK( showPinAltIconsCond ) );
740
741 auto multiUnitModeCond =
742 [this]( const SELECTION& )
743 {
744 return m_symbol && m_symbol->IsMultiUnit() && !m_symbol->UnitsLocked();
745 };
746
747 auto multiBodyStyleModeCond =
748 [this]( const SELECTION& )
749 {
750 return m_symbol && m_symbol->IsMultiBodyStyle();
751 };
752
753 auto syncedPinsModeCond =
754 [this]( const SELECTION& )
755 {
756 return SynchronizePins();
757 };
758
759 auto haveDatasheetCond =
760 [this]( const SELECTION& )
761 {
762 return m_symbol && !m_symbol->GetDatasheetField().GetText().IsEmpty();
763 };
764
765 mgr->SetConditions( ACTIONS::showDatasheet, ENABLE( haveDatasheetCond ) );
766 mgr->SetConditions( SCH_ACTIONS::symbolProperties, ENABLE( symbolSelectedInTreeCondition || ( canEditProperties && haveSymbolCond ) ) );
767 mgr->SetConditions( SCH_ACTIONS::runERC, ENABLE( haveSymbolCond ) );
768 mgr->SetConditions( SCH_ACTIONS::pinTable, ENABLE( isGraphicallyEditableCond && haveSymbolCond ) );
769 mgr->SetConditions( SCH_ACTIONS::editSymbolPinMaps, ENABLE( isGraphicallyEditableCond && haveSymbolCond ) );
770 mgr->SetConditions( SCH_ACTIONS::updateSymbolFields, ENABLE( canUpdateFieldsCond ) );
771 mgr->SetConditions( SCH_ACTIONS::cycleBodyStyle, ENABLE( multiBodyStyleModeCond ) );
772
773 mgr->SetConditions( SCH_ACTIONS::toggleSyncedPinsMode, ACTION_CONDITIONS().Enable( multiUnitModeCond ).Check( syncedPinsModeCond ) );
774
775// Only enable a tool if the symbol is edtable
776#define EDIT_TOOL( tool ) ACTION_CONDITIONS().Enable( isGraphicallyEditableCond ).Check( cond.CurrentTool( tool ) )
777
787 setArcModeConditions( SCH_ACTIONS::drawArc, isGraphicallyEditableCond );
793
794#undef CHECK
795#undef ENABLE
796#undef EDIT_TOOL
797}
798
799
801{
802 wxLogTrace( traceApi, "Symbol editor frame: EDA_EVT_PLUGIN_AVAILABILITY_CHANGED" );
805 aEvt.Skip();
806}
807
808
810{
811 if( IsContentModified() )
812 {
813 wxString msg = _( "Save changes to '%s' before closing?" );
814
815 if( !HandleUnsavedChanges( this, wxString::Format( msg, m_reference ),
816 [&]() -> bool
817 {
818 SCH_EDIT_FRAME* schframe = (SCH_EDIT_FRAME*) Kiway().Player( FRAME_SCH, false );
819 LIB_SYMBOL* symbol = GetCurSymbol();
820
821 if( schframe && symbol ) // Should be always the case
822 return schframe->SaveSymbolToSchematic( *symbol, m_schematicSymbolUUID );
823
824 return false;
825 } ) )
826 {
827 return false;
828 }
829 }
830
831 if( doClose )
832 SetCurSymbol( nullptr, false );
833
834 return true;
835}
836
837
838bool SYMBOL_EDIT_FRAME::canCloseWindow( wxCloseEvent& aEvent )
839{
840 // Shutdown blocks must be determined and vetoed as early as possible, before any modal prompt.
841 // IsContentModified only sees the active tab, so also account for dirty inactive instance tabs.
843 {
844 aEvent.Veto();
845 return false;
846 }
847
849 {
850 aEvent.Veto();
851 return false;
852 }
853
854 // Prompt for any dirty inactive instance (symbols from the schematic) tabs, which the active-tab
855 // checks above miss.
857 return false;
858
859 // A dirty unsaved tab has no library buffer for saveAllLibraries to prompt about, so ask here
860 if( m_activeTab && m_activeTab->IsUnsaved() && GetScreen()->IsContentModified() )
861 {
862 wxString msg = wxString::Format( _( "Save changes to '%s' before closing?" ),
863 m_activeTab->GetDisplayName( true ) );
864
865 KIDIALOG dlg( this, msg, _( "Confirmation" ), wxYES_NO | wxCANCEL | wxICON_WARNING );
866 dlg.SetYesNoCancelLabels( _( "Save" ), _( "Discard Changes" ), _( "Cancel" ) );
867
868 switch( dlg.ShowModal() )
869 {
870 case wxID_YES:
871 if( !saveCurrentSymbol() )
872 {
873 aEvent.Veto();
874 return false;
875 }
876
877 break;
878
879 case wxID_NO:
880 break;
881
882 default:
883 aEvent.Veto();
884 return false;
885 }
886 }
887
888 if( !saveAllLibraries( true ) )
889 return false;
890
891 // Save symbol tree column widths
892 m_libMgr->GetAdapter()->SaveSettings();
893
894 return true;
895}
896
897
899{
901
902 if( Pgm().ApiServerOrNull() )
903 {
905
906 if( Kiface().IsSingle() )
907 {
910 }
911 }
912
913 wxTheApp->Unbind( EDA_EVT_PLUGIN_AVAILABILITY_CHANGED,
915
916 if( GetLibTree() )
918
919 delete m_toolManager;
920 m_toolManager = nullptr;
921
922 Destroy();
923}
924
925
927{
928 if( m_unitSelectBox )
929 {
930 if( m_unitSelectBox->GetCount() != 0 )
931 m_unitSelectBox->Clear();
932
933 if( !m_symbol || m_symbol->GetUnitCount() <= 1 )
934 {
935 m_unit = 1;
936 m_unitSelectBox->Append( wxEmptyString );
937 }
938 else
939 {
940 for( int i = 0; i < m_symbol->GetUnitCount(); i++ )
941 m_unitSelectBox->Append( m_symbol->GetUnitDisplayName( i + 1, true ) );
942 }
943
944 // Ensure the selected unit is compatible with the number of units of the current symbol:
945 if( m_symbol && m_symbol->GetUnitCount() < m_unit )
946 m_unit = 1;
947
948 m_unitSelectBox->SetSelection( ( m_unit > 0 ) ? m_unit - 1 : 0 );
949 }
950
952 {
953 if( m_bodyStyleSelectBox->GetCount() != 0 )
954 m_bodyStyleSelectBox->Clear();
955
956 if( !m_symbol || !m_symbol->IsMultiBodyStyle() )
957 {
958 m_bodyStyle = 1;
959 m_bodyStyleSelectBox->Append( wxEmptyString );
960 }
961 else if( m_symbol && m_symbol->HasDeMorganBodyStyles() )
962 {
963 m_bodyStyleSelectBox->Append( wxGetTranslation( DEMORGAN_STD ) );
964 m_bodyStyleSelectBox->Append( wxGetTranslation( DEMORGAN_ALT ) );
965 }
966 else
967 {
968 for( int i = 0; i < m_symbol->GetBodyStyleCount(); i++ )
969 m_bodyStyleSelectBox->Append( m_symbol->GetBodyStyleNames()[i] );
970 }
971
972 // Ensure the selected body style is compatible with the number of body styles of the current symbol:
973 if( m_symbol && m_symbol->GetBodyStyleCount() < m_bodyStyle )
974 m_bodyStyle = 1;
975
976 m_bodyStyleSelectBox->SetSelection( ( m_bodyStyle > 0 ) ? m_bodyStyle - 1 : 0 );
977 }
978}
979
980
982{
983 if( !m_propertiesPanel )
984 return;
985
986 bool show = !m_propertiesPanel->IsShownOnScreen();
987
988 wxAuiPaneInfo& propertiesPaneInfo = m_auimgr.GetPane( PropertiesPaneName() );
989 propertiesPaneInfo.Show( show );
991
992 if( show )
993 SetAuiPaneSize( m_auimgr, propertiesPaneInfo, m_settings->m_AuiPanels.properties_panel_width, -1 );
994 else
995 m_settings->m_AuiPanels.properties_panel_width = m_propertiesPanel->GetSize().x;
996
997 m_auimgr.Update();
998 Refresh();
999}
1000
1001
1003{
1004 // An explicit toggle makes the live visibility authoritative, so drop any pending restore that
1005 // LoadSymbolFromSchematic's auto-hide left behind.
1007
1008 wxAuiPaneInfo& treePane = m_auimgr.GetPane( m_treePane );
1009 treePane.Show( !IsLibraryTreeShown() );
1011 m_auimgr.Update();
1012 Refresh();
1013}
1014
1015
1017{
1018 return const_cast<wxAuiManager&>( m_auimgr ).GetPane( m_treePane ).IsShown();
1019}
1020
1021
1026
1027
1029{
1030 m_treePane->Freeze();
1031 m_libMgr->GetAdapter()->Freeze();
1032}
1033
1034
1036{
1037 m_libMgr->GetAdapter()->Thaw();
1038 m_treePane->Thaw();
1039}
1040
1041
1042void SYMBOL_EDIT_FRAME::OnExitKiCad( wxCommandEvent& event )
1043{
1044 Kiway().OnKiCadExit();
1045}
1046
1047
1048void SYMBOL_EDIT_FRAME::OnUpdateUnitNumber( wxUpdateUIEvent& event )
1049{
1050 event.Enable( m_symbol && m_symbol->GetUnitCount() > 1 );
1051}
1052
1053
1054void SYMBOL_EDIT_FRAME::OnSelectUnit( wxCommandEvent& event )
1055{
1056 if( event.GetSelection() == wxNOT_FOUND )
1057 return;
1058
1059 SetUnit( event.GetSelection() + 1 );
1060}
1061
1062
1063void SYMBOL_EDIT_FRAME::OnUpdateBodyStyle( wxUpdateUIEvent& event )
1064{
1065 event.Enable( m_symbol && m_symbol->GetBodyStyleCount() > 1 );
1066}
1067
1068
1069void SYMBOL_EDIT_FRAME::OnSelectBodyStyle( wxCommandEvent& event )
1070{
1071 if( event.GetSelection() == wxNOT_FOUND )
1072 return;
1073
1074 SetBodyStyle( event.GetSelection() + 1 );
1075}
1076
1077
1079{
1080 if( m_symbol )
1081 {
1083
1084 if( std::optional<LIBRARY_TABLE_ROW*> row = adapter->GetRow( m_symbol->GetLibNickname() ); row.has_value() )
1085 {
1086 if( ( *row )->Type() == SCH_IO_MGR::ShowType( SCH_IO_MGR::SCH_LEGACY ) )
1087 return true;
1088 }
1089 }
1090
1091 return false;
1092}
1093
1094
1096{
1097 // Use CallAfter so that we update the canvas before waiting for the infobar animation
1098 CallAfter(
1099 [this]()
1100 {
1101 WX_INFOBAR& infobar = *GetInfoBar();
1102 infobar.RemoveAllButtons();
1103
1104 wxArrayString msgs;
1105 int infobarFlags = wxICON_INFORMATION;
1106 wxString symbolName;
1107 wxString libName;
1108
1109 if( m_symbol )
1110 {
1111 symbolName = m_symbol->GetName();
1112 libName = m_symbol->GetLibId().GetLibNickname().wx_str();
1113 }
1114
1115 if( IsSymbolFromSchematic() )
1116 {
1117 msgs.push_back( wxString::Format( _( "Editing %s from schematic. Saving will update the "
1118 "schematic only." ),
1119 m_reference ) );
1120
1121 infobar.AddLink( wxString::Format( _( "Open symbol from library %s" ), UnescapeString( libName ) ),
1122 [this]( wxHyperlinkEvent& aEvent )
1123 {
1125 } );
1126 }
1127 else if( IsSymbolFromLegacyLibrary() )
1128 {
1129 msgs.push_back( _( "Symbols in legacy libraries are not editable. Use Manage Symbol "
1130 "Libraries to migrate to current format." ) );
1131
1132 infobar.AddLink( _( "Manage symbol libraries" ),
1133 [this]( wxHyperlinkEvent& aEvent )
1134 {
1136 } );
1137 }
1138 else if( IsSymbolAlias() )
1139 {
1140 msgs.push_back( wxString::Format( _( "Symbol %s is a derived symbol. Symbol graphics will "
1141 "not be editable." ),
1142 UnescapeString( symbolName ) ) );
1143
1144 // Don't assume the parent symbol shared pointer is still valid.
1145 if( std::shared_ptr<LIB_SYMBOL> rootSymbol = m_symbol->GetRootSymbol() )
1146 {
1147 int unit = GetUnit();
1148 int bodyStyle = GetBodyStyle();
1149 wxString rootSymbolName = rootSymbol->GetName();
1150
1151 infobar.AddLink( wxString::Format( _( "Open %s" ), UnescapeString( rootSymbolName ) ),
1152 [this, libName, rootSymbolName, unit, bodyStyle]( wxHyperlinkEvent& aEvent )
1153 {
1154 LoadSymbolFromLib( libName, rootSymbolName, unit, bodyStyle );
1155 } );
1156 }
1157 }
1158
1159 if( m_symbol
1161 && m_libMgr->IsLibraryReadOnly( m_symbol->GetLibId().GetFullLibraryName() ) )
1162 {
1163 msgs.push_back( _( "Library is read-only. Changes cannot be saved to this library." ) );
1164
1165 infobar.AddLink( _( "Create an editable copy" ),
1166 [this, libName]( wxHyperlinkEvent& aEvent )
1167 {
1168 wxString msg = wxString::Format( _( "Create an editable copy of the symbol or "
1169 "the entire library (%s)?" ),
1170 UnescapeString( libName ) );
1171
1172 KIDIALOG errorDlg( this, msg, _( "Select type of item to save" ),
1173 wxYES_NO | wxCANCEL | wxICON_QUESTION );
1174 // These buttons are in a weird order(?)
1175 errorDlg.SetYesNoCancelLabels( _( "Copy symbol" ), _( "Cancel" ), _( "Copy library" ) );
1176
1177 int choice = errorDlg.ShowModal();
1178
1179 switch( choice )
1180 {
1181 case wxID_YES: SaveSymbolCopyAs( true ); break;
1182 case wxID_CANCEL: SaveLibraryAs(); break;
1183 default: return;
1184 }
1185
1186 // Get rid of the save-will-update-schematic-only (or any other dismissable warning)
1187 WX_INFOBAR* local_infobar = GetInfoBar();
1188
1189 if( local_infobar->IsShownOnScreen() && local_infobar->HasCloseButton() )
1190 local_infobar->Dismiss();
1191
1193 } );
1194 }
1195
1196 if( msgs.empty() )
1197 {
1198 infobar.Dismiss();
1199 }
1200 else
1201 {
1202 wxString msg = wxJoin( msgs, '\n', '\0' );
1203 infobar.AddCloseButton();
1204 infobar.ShowMessage( msg, infobarFlags );
1205 }
1206 } );
1207}
1208
1209
1210void SYMBOL_EDIT_FRAME::SetCurSymbol( LIB_SYMBOL* aSymbol, bool aUpdateZoom )
1211{
1212 wxCHECK( m_toolManager, /* void */ );
1213
1215 GetCanvas()->GetView()->Clear();
1216
1217 // Install the replacement and refresh the active context before freeing the old symbol, so the
1218 // context never observes a freed pointer.
1219 LIB_SYMBOL* oldSymbol = m_symbol;
1220
1221 m_symbol = aSymbol;
1222
1223 if( m_activeTab )
1224 m_activeTab->RefreshFrameOwnedObjects( m_symbol, static_cast<SCH_SCREEN*>( GetScreen() ) );
1225
1226 delete oldSymbol;
1227
1228 // select the current symbol in the tree widget
1230 GetLibTree()->SelectLibId( m_symbol->GetLibId() );
1231 else
1232 GetLibTree()->Unselect();
1233
1235
1243
1244 if( aUpdateZoom )
1246
1247 GetCanvas()->Refresh();
1248 m_propertiesPanel->UpdateData();
1249 updateInfoBar();
1250}
1251
1252
1258
1259
1261{
1263
1265
1266 if( !IsSymbolFromSchematic() && !( m_activeTab && m_activeTab->IsUnsaved() ) )
1267 {
1269 m_libMgr->UpdateSymbol( m_symbol, m_symbol->GetLibNickname() ); // UpdateSymbol() makes a copy
1270 }
1271
1272 if( m_isClosing )
1273 return;
1274
1275 // Clear preview so a later library-open gets its own tab instead of replacing this edited one.
1276 if( m_activeTab )
1277 {
1278 m_activeTab->SetPreview( false );
1279
1280 if( int idx = m_tabsPanel->FindTab( m_activeTab->GetTabKey() ); idx >= 0 )
1281 m_tabsPanel->MarkModified( idx, true );
1282 }
1283
1285}
1286
1287
1289{
1290 wxCHECK( aUnit > 0 && aUnit <= GetCurSymbol()->GetUnitCount(), /* void*/ );
1291
1292 if( m_unit == aUnit )
1293 return;
1294
1297
1298 m_unit = aUnit;
1299
1300 if( m_unitSelectBox->GetSelection() != ( m_unit - 1 ) )
1301 m_unitSelectBox->SetSelection( m_unit - 1 );
1302
1304 RebuildView();
1306}
1307
1308
1310{
1311 wxCHECK( aBodyStyle > 0 && aBodyStyle <= GetCurSymbol()->GetBodyStyleCount(), /* void */ );
1312
1313 if( m_bodyStyle == aBodyStyle )
1314 return;
1315
1318
1319 m_bodyStyle = aBodyStyle;
1320
1321 if( m_bodyStyleSelectBox->GetSelection() != ( m_bodyStyle - 1 ) )
1322 m_bodyStyleSelectBox->SetSelection( m_bodyStyle - 1 );
1323
1324
1326 RebuildView();
1328}
1329
1330
1332{
1333 return m_settings && m_settings->m_SyncPinEdit && m_symbol && m_symbol->IsMultiUnit() && !m_symbol->UnitsLocked();
1334}
1335
1336
1337wxString SYMBOL_EDIT_FRAME::AddLibraryFile( bool aCreateNew )
1338{
1339 wxFileName fn = m_libMgr->GetUniqueLibraryName();
1340 bool useGlobalTable = true;
1341 FILEDLG_HOOK_NEW_LIBRARY tableChooser( useGlobalTable );
1342
1343 if( !LibraryFileBrowser( aCreateNew ? _( "New Symbol Library" ) : _( "Add Symbol Library" ),
1344 !aCreateNew, fn, FILEEXT::KiCadSymbolLibFileWildcard(),
1346 Pgm().GetSettingsManager().IsProjectOpenNotDummy() ? &tableChooser : nullptr ) )
1347 {
1348 return wxEmptyString;
1349 }
1350
1353
1354 LIBRARY_MANAGER& manager = Pgm().GetLibraryManager();
1355 std::optional<LIBRARY_TABLE*> optTable = manager.Table( LIBRARY_TABLE_TYPE::SYMBOL, scope );
1356
1357 wxCHECK( optTable.has_value(), wxEmptyString );
1358 LIBRARY_TABLE* table = optTable.value();
1359
1360 wxString libName = fn.GetName();
1361
1362 if( libName.IsEmpty() )
1363 return wxEmptyString;
1364
1366
1367 if( adapter->HasLibrary( libName ) )
1368 {
1369 DisplayError( this, wxString::Format( _( "Library '%s' already exists." ), libName ) );
1370 return wxEmptyString;
1371 }
1372
1373 if( aCreateNew )
1374 {
1375 // The file browser already asked to overwrite, so drop the old file here.
1376 // CreateLibrary fails on an existing path.
1377 if( fn.FileExists() && !wxRemoveFile( fn.GetFullPath() ) )
1378 {
1379 DisplayError( this, wxString::Format( _( "Could not overwrite the library file '%s'.\n"
1380 "Make sure you have write permissions and try again." ),
1381 fn.GetFullPath() ) );
1382 return wxEmptyString;
1383 }
1384
1385 if( !m_libMgr->CreateLibrary( fn.GetFullPath(), scope ) )
1386 {
1387 DisplayError( this, wxString::Format( _( "Could not create the library file '%s'.\n"
1388 "Make sure you have write permissions and try again." ),
1389 fn.GetFullPath() ) );
1390 return wxEmptyString;
1391 }
1392 }
1393 else
1394 {
1395 if( !m_libMgr->AddLibrary( fn.GetFullPath(), scope ) )
1396 {
1397 DisplayError( this, _( "Could not open the library file." ) );
1398 return wxEmptyString;
1399 }
1400 }
1401
1402 bool success = true;
1403
1404 // Tables are reinitialized by m_libMgr->AddLibrary(). So reinit table reference.
1405 optTable = manager.Table( LIBRARY_TABLE_TYPE::SYMBOL, scope );
1406 wxCHECK( optTable.has_value(), wxEmptyString );
1407 table = optTable.value();
1408
1409 table->Save().map_error(
1410 [&]( const LIBRARY_ERROR& aError )
1411 {
1412 KICAD_MESSAGE_DIALOG dlg( this, _( "Error saving library table." ), _( "File Save Error" ),
1413 wxOK | wxICON_ERROR );
1414 dlg.SetExtendedMessage( aError.message );
1415 dlg.ShowModal();
1416
1417 success = false;
1418 } );
1419
1420 if( success )
1421 adapter->LoadOne( fn.GetName() );
1422
1423 SyncLibraries( false );
1424
1425 if( m_treePane )
1426 {
1427 LIB_ID libId( fn.GetName(), wxEmptyString );
1428 GetLibTree()->SelectLibId( libId );
1429 GetLibTree()->CenterLibId( libId );
1430 }
1431
1432 return fn.GetFullPath();
1433}
1434
1435
1436void SYMBOL_EDIT_FRAME::DdAddLibrary( wxString aLibFile )
1437{
1438 wxFileName fn = wxFileName( aLibFile );
1439 wxString libName = fn.GetName();
1440
1441 if( libName.IsEmpty() )
1442 return;
1443
1444 LIBRARY_MANAGER& manager = Pgm().GetLibraryManager();
1446
1447 if( adapter->HasLibrary( libName ) )
1448 {
1449 DisplayError( this, wxString::Format( _( "Library '%s' already exists." ), libName ) );
1450 return;
1451 }
1452
1453 if( !m_libMgr->AddLibrary( fn.GetFullPath(), LIBRARY_TABLE_SCOPE::PROJECT ) )
1454 {
1455 DisplayError( this, _( "Could not open the library file." ) );
1456 return;
1457 }
1458
1459 std::optional<LIBRARY_TABLE*> optTable = manager.Table( LIBRARY_TABLE_TYPE::SYMBOL, LIBRARY_TABLE_SCOPE::PROJECT );
1460 wxCHECK( optTable.has_value(), /* void */ );
1461 LIBRARY_TABLE* table = optTable.value();
1462 bool success = true;
1463
1464 table->Save().map_error(
1465 [&]( const LIBRARY_ERROR& aError )
1466 {
1467 KICAD_MESSAGE_DIALOG dlg( this, _( "Error saving library table." ), _( "File Save Error" ),
1468 wxOK | wxICON_ERROR );
1469 dlg.SetExtendedMessage( aError.message );
1470 dlg.ShowModal();
1471
1472 success = false;
1473 } );
1474
1475 if( success )
1476 adapter->LoadOne( libName );
1477
1478 std::string packet = fn.GetFullPath().ToStdString();
1481}
1482
1483
1485{
1486 return GetLibTree()->GetSelectedLibId( aUnit );
1487}
1488
1489
1494
1495int SYMBOL_EDIT_FRAME::GetTreeLIBIDs( std::vector<LIB_ID>& aSelection ) const
1496{
1497 return GetLibTree()->GetSelectedLibIds( aSelection );
1498}
1499
1500
1502{
1503 if( IsLibraryTreeShown() )
1504 {
1505 LIB_ID libId = GetTreeLIBID();
1506
1507 if( libId.IsValid() )
1508 return m_libMgr->GetSymbol( libId.GetLibItemName(), libId.GetLibNickname() );
1509 }
1510
1511 return m_symbol;
1512}
1513
1514
1516{
1517 LIB_ID id;
1518
1519 if( IsLibraryTreeShown() )
1520 id = GetTreeLIBID();
1521
1522 if( id.GetLibNickname().empty() && m_symbol )
1523 id = m_symbol->GetLibId();
1524
1525 return id;
1526}
1527
1528
1529std::vector<LIB_ID> SYMBOL_EDIT_FRAME::GetSelectedLibIds() const
1530{
1531 std::vector<LIB_ID> ids;
1532 GetTreeLIBIDs( ids );
1533 return ids;
1534}
1535
1536
1538{
1539 return GetTargetLibId().GetLibNickname();
1540}
1541
1542
1543void SYMBOL_EDIT_FRAME::SyncLibraries( bool aShowProgress, bool aPreloadCancelled, const wxString& aForceRefresh )
1544{
1545 wxLogTrace( wxT( "KICAD_TABS_DBG" ),
1546 wxT( "SYMBOL_EDIT_FRAME::SyncLibraries enter (progress=%d, forceRefresh='%s')" ),
1547 aShowProgress, aForceRefresh );
1548
1549 // Prevent re-entrant calls. The progress dialog yields the event loop during Sync(),
1550 // which can dispatch queued UI events (e.g. menu clicks queued while the app was busy
1551 // loading libraries). A re-entrant call would corrupt the library tree mid-rebuild.
1553 {
1554 wxLogTrace( wxT( "KICAD_TABS_DBG" ), wxT( "SYMBOL_EDIT_FRAME::SyncLibraries re-entrant; skipping" ) );
1555 return;
1556 }
1557
1559
1560 auto resetGuard =
1561 [this]( bool* )
1562 {
1564 };
1565
1566 std::unique_ptr<bool, decltype( resetGuard )> guard( &m_syncLibrariesInProgress, resetGuard );
1567
1568 LIB_ID selected;
1569 std::vector<LIB_ID> expanded;
1570
1571 if( m_treePane )
1572 {
1573 selected = GetLibTree()->GetSelectedLibId();
1574 expanded = GetLibTree()->GetExpandedLibraries();
1575 }
1576
1577 // Ensure any in-progress background library preloading is complete before syncing the
1578 // tree. Without this, libraries still in LOADING state get skipped by Sync(), resulting
1579 // in an incomplete tree that requires a manual refresh to fully populate.
1581 adapter->BlockUntilLoaded();
1582
1583 if( aShowProgress )
1584 {
1585 APP_PROGRESS_DIALOG progressDlg( _( "Loading Symbol Libraries" ), wxEmptyString,
1586 m_libMgr->GetAdapter()->GetLibrariesCount(), this );
1587
1588 THROTTLE progressThrottle( std::chrono::milliseconds( 350 ) );
1589 int pendingProgress = 0;
1590 bool callbackFired = false;
1591 wxString pendingLibName;
1592
1593 m_libMgr->Sync( aForceRefresh,
1594 [&]( int progress, int max, const wxString& libName )
1595 {
1596 pendingProgress = progress;
1597 pendingLibName = libName;
1598 callbackFired = true;
1599
1600 if( progressThrottle.Ready() )
1601 progressDlg.Update( progress, wxString::Format( _( "Loading library '%s'..." ), libName ) );
1602 } );
1603
1604 if( callbackFired )
1605 progressDlg.Update( pendingProgress, wxString::Format( _( "Loading library '%s'..." ), pendingLibName ) );
1606 }
1607 else if( !aPreloadCancelled )
1608 {
1609 m_libMgr->Sync( aForceRefresh, [&]( int progress, int max, const wxString& libName ) {} );
1610 }
1611
1612 if( m_treePane )
1613 {
1614 wxDataViewItem found;
1615
1616 if( selected.IsValid() )
1617 {
1618 // Check if the previously selected item is still valid,
1619 // if not - it has to be unselected to prevent crash
1620 found = m_libMgr->GetAdapter()->FindItem( selected );
1621
1622 if( !found )
1623 GetLibTree()->Unselect();
1624 }
1625
1626 wxLogTrace( wxT( "KICAD_TABS_DBG" ), wxT( "SYMBOL_EDIT_FRAME::SyncLibraries Regenerate" ) );
1627 GetLibTree()->Regenerate( true );
1628
1629 // Sync() collapsed the tree, so re-expand the libraries that were open before it.
1630 for( const LIB_ID& libId : expanded )
1631 GetLibTree()->ExpandLibId( libId );
1632
1633 // A filter selects its best match, which tree actions would take for the user's choice
1634 if( selected.GetLibNickname().empty() )
1635 GetLibTree()->Unselect();
1636
1637 // Try to select the parent library, in case the symbol is not found
1638 if( !found && selected.IsValid() )
1639 {
1640 selected.SetLibItemName( "" );
1641 found = m_libMgr->GetAdapter()->FindItem( selected );
1642
1643 if( found )
1644 GetLibTree()->SelectLibId( selected );
1645 }
1646 }
1647
1648 wxLogTrace( wxT( "KICAD_TABS_DBG" ), wxT( "SYMBOL_EDIT_FRAME::SyncLibraries exit" ) );
1649}
1650
1651
1656
1657
1659{
1660 GetLibTree()->SelectLibId( aLibID );
1661}
1662
1663
1664void SYMBOL_EDIT_FRAME::UpdateLibraryTree( const wxDataViewItem& aTreeItem, LIB_SYMBOL* aSymbol )
1665{
1666 if( aTreeItem.IsOk() ) // Can be not found in tree if the current footprint is imported
1667 // from file therefore not yet in tree.
1668 {
1669 static_cast<LIB_TREE_NODE_ITEM*>( aTreeItem.GetID() )->Update( aSymbol );
1671 }
1672}
1673
1674
1675bool SYMBOL_EDIT_FRAME::backupLibrary( const wxFileName& aOriginalFile, wxString& aErrorMsg )
1676{
1677 wxFileName backupFileName;
1678
1679 if( !aOriginalFile.IsDir() && aOriginalFile.FileExists() )
1680 {
1681 backupFileName = aOriginalFile;
1682 backupFileName.SetExt( wxT( "bak" ) );
1683
1684 if( backupFileName.FileExists() )
1685 {
1686 if( !wxRemoveFile( backupFileName.GetFullPath() ) )
1687 {
1688 aErrorMsg.Printf( _( "Failed to remove existing library backup file '%s'." ),
1689 backupFileName.GetFullPath() );
1690 return false;
1691 }
1692 }
1693
1694 if( !wxCopyFile( aOriginalFile.GetFullPath(), backupFileName.GetFullPath() ) )
1695 {
1696 aErrorMsg.Printf( _( "Failed to save backup to '%s'." ), backupFileName.GetFullPath() );
1697 return false;
1698 }
1699 }
1700 else if( aOriginalFile.IsDir() && aOriginalFile.DirExists() )
1701 {
1702 backupFileName.SetPath( aOriginalFile.GetPath() );
1703 backupFileName.SetName( backupFileName.GetDirs().Last() + wxString( "_backup" ) );
1704 backupFileName.SetExt( "zip" );
1705
1706 std::vector<wxString> libFiles;
1707 wxDir libDir( aOriginalFile.GetPath() );
1708 UNPACKED_SYMBOL_LIBRARY_DIR_TRAVERSER libTraverser( libFiles );
1709
1710 if( backupFileName.FileExists() )
1711 {
1712 if( !wxRemoveFile( backupFileName.GetFullPath() ) )
1713 {
1714 aErrorMsg.Printf( _( "Failed to remove existing library backup file '%s'." ),
1715 backupFileName.GetFullPath() );
1716 return false;
1717 }
1718 }
1719
1720 if( !libDir.IsOpened() )
1721 {
1722 aErrorMsg.Printf( _( "Error opening unpacked library directory: '%s'." ), aOriginalFile.GetPath() );
1723 return false;
1724 }
1725
1726 libDir.Traverse( libTraverser, wxEmptyString, wxDIR_FILES );
1727
1728 wxFFileOutputStream ostream( backupFileName.GetFullPath() );
1729
1730 if( !ostream.IsOk() )
1731 {
1732 aErrorMsg.Printf( _( "Failed to create library backup file '%s'." ), backupFileName.GetFullPath() );
1733 return false;
1734 }
1735
1736 // Use a large I/O buffer to improve compatibility with cloud-synced folders.
1737 if( FILE* fp = ostream.GetFile()->fp() )
1738 setvbuf( fp, nullptr, _IOFBF, KIPLATFORM::IO::CLOUD_SYNC_BUFFER_SIZE );
1739
1740 wxZipOutputStream zipstream( ostream, -1, wxConvUTF8 );
1741
1742 for( const wxString& fileName : libFiles )
1743 {
1744 wxFileName fn( fileName );
1745 wxFileSystem fsFile;
1746
1747 fn.MakeRelativeTo( aOriginalFile.GetPath() );
1748
1749 wxString relativeFn = fn.GetFullPath();
1750
1751 // Read input file and add it to the zip file:
1752 wxFSFile* infile = nullptr;
1753 wxString sysError;
1754
1755 {
1756 // Failures are reported through an error dialog, prevent wx from popping its own dialog.
1757 wxLogNull suppressSysErrorPopups;
1758 infile = fsFile.OpenFile( fileName );
1759
1760 if( !infile )
1761 {
1762 if( unsigned long code = wxSysErrorCode() )
1763 sysError = wxSysErrorMsgStr( code );
1764 }
1765 }
1766
1767 if( infile )
1768 {
1769 zipstream.PutNextEntry( relativeFn, infile->GetModificationTime() );
1770 infile->GetStream()->Read( zipstream );
1771 zipstream.CloseEntry();
1772
1773 delete infile;
1774 }
1775 else
1776 {
1777 if( sysError.IsEmpty() )
1778 aErrorMsg.Printf( _( "Failed to archive file '%s'." ), relativeFn );
1779 else
1780 aErrorMsg.Printf( _( "Failed to archive file '%s': %s" ), relativeFn, sysError );
1781
1782 zipstream.Close();
1783 return false;
1784 }
1785 }
1786
1787 if( !zipstream.Close() )
1788 {
1789 aErrorMsg.Printf( _( "Failed to create file '%s'." ), backupFileName.GetFullPath() );
1790 return false;
1791 }
1792 }
1793
1794 return true;
1795}
1796
1797
1799{
1800 // This will return the root symbol of any alias
1801 LIB_SYMBOL* symbol = m_libMgr->GetBufferedSymbol( aLibId.GetLibItemName(), aLibId.GetLibNickname() );
1802
1803 // Now we can compare the libId of the current symbol and the root symbol
1804 return ( symbol && m_symbol && symbol->GetLibId() == m_symbol->GetLibId() );
1805}
1806
1807
1809{
1811
1813 {
1814 GetRenderSettings()->m_ShowPinsElectricalType = cfg->m_ShowPinElectricalType;
1815 GetRenderSettings()->m_ShowHiddenPins = cfg->m_ShowHiddenPins;
1816 GetRenderSettings()->m_ShowHiddenFields = cfg->m_ShowHiddenFields;
1817 GetRenderSettings()->m_ShowPinAltIcons = cfg->m_ShowPinAltIcons;
1818
1819 // This editor always shows the axes, whatever a settings file not yet saved by it says
1820 cfg->m_Window.grid.axes_enabled = true;
1821 GetGalDisplayOptions().ReadWindowSettings( cfg->m_Window );
1822 }
1823
1824 if( m_symbol )
1825 m_symbol->ClearCaches();
1826
1828
1830 GetCanvas()->Refresh();
1831
1833
1834 if( aFlags & ENVVARS_CHANGED )
1835 SyncLibraries( true );
1836
1837 Layout();
1838 SendSizeEvent();
1839}
1840
1841
1843{
1844 // call my base class
1846
1847 // tooltips in toolbars
1849
1850 // For some obscure reason, the AUI manager hides the first modified pane.
1851 // So force show panes
1852 wxAuiPaneInfo& tree_pane_info = m_auimgr.GetPane( m_treePane );
1853 bool tree_shown = tree_pane_info.IsShown();
1854 tree_pane_info.Caption( _( "Libraries" ) );
1855 tree_pane_info.Show( tree_shown );
1856 m_auimgr.Update();
1857
1859
1860 // status bar
1862
1863 if( GetRenderSettings()->m_ShowPinsElectricalType )
1864 {
1866 GetCanvas()->Refresh();
1867 }
1868
1869 UpdateTitle();
1870}
1871
1872
1874{
1875 SCH_BASE_FRAME::SetScreen( aScreen );
1876
1877 if( m_toolManager )
1878 {
1879 m_toolManager->SetEnvironment( aScreen, GetCanvas()->GetView(), GetCanvas()->GetViewControls(), GetSettings(),
1880 this );
1882 }
1883}
1884
1885
1903
1904
1906{
1907 SyncLibraries( true );
1908
1909 if( m_symbol )
1910 {
1911 SCH_SELECTION_TOOL* selectionTool = m_toolManager->GetTool<SCH_SELECTION_TOOL>();
1912 SCH_SELECTION& selection = selectionTool->GetSelection();
1913
1914 for( SCH_ITEM& item : m_symbol->GetDrawItems() )
1915 {
1916 if( !alg::contains( selection, &item ) )
1917 item.ClearSelected();
1918 else
1919 item.SetSelected();
1920 }
1921
1922 m_symbol->ClearCaches();
1923 }
1924
1925 RebuildView();
1926}
1927
1928
1929const BOX2I SYMBOL_EDIT_FRAME::GetDocumentExtents( bool aIncludeAllVisible ) const
1930{
1931 if( !m_symbol )
1932 {
1933 // Gives a reasonable drawing area size
1934 int width = schIUScale.mmToIU( 50 );
1935 int height = schIUScale.mmToIU( 30 );
1936
1937 return BOX2I( VECTOR2I( -width/2, -height/2 ), VECTOR2I( width, height ) );
1938 }
1939 else
1940 {
1941 return m_symbol->Flatten()->GetUnitBoundingBox( m_unit, m_bodyStyle );
1942 }
1943}
1944
1945
1946void SYMBOL_EDIT_FRAME::FocusOnItem( EDA_ITEM* aItem, bool aAllowScroll )
1947{
1948 static KIID lastBrightenedItemID( niluuid );
1949
1950 SCH_ITEM* lastItem = nullptr;
1951
1952 // nullptr will clear the current focus
1953 if( aItem != nullptr && !aItem->IsSCH_ITEM() )
1954 return;
1955
1956 if( m_symbol )
1957 {
1958 for( SCH_PIN* pin : m_symbol->GetGraphicalPins( 0, 0 ) )
1959 {
1960 if( pin->m_Uuid == lastBrightenedItemID )
1961 lastItem = pin;
1962 }
1963
1964 std::vector<SCH_FIELD*> fields;
1965 m_symbol->GetFields( fields );
1966
1967 for( SCH_FIELD* field : fields )
1968 {
1969 if( field->m_Uuid == lastBrightenedItemID )
1970 lastItem = field;
1971 }
1972 }
1973
1974 if( lastItem && lastItem != aItem )
1975 {
1976 lastItem->ClearBrightened();
1977
1978 UpdateItem( lastItem );
1979 lastBrightenedItemID = niluuid;
1980 }
1981
1982 if( aItem )
1983 {
1984 if( aItem->IsSCH_ITEM() )
1985 {
1986 SCH_ITEM* item = static_cast<SCH_ITEM*>( aItem );
1987
1988 if( int unit = item->GetUnit() )
1989 SetUnit( unit );
1990
1991 if( int bodyStyle = item->GetBodyStyle() )
1992 SetBodyStyle( bodyStyle );
1993 }
1994
1995 if( !aItem->IsBrightened() )
1996 {
1997 aItem->SetBrightened();
1998
1999 UpdateItem( aItem );
2000 lastBrightenedItemID = aItem->m_Uuid;
2001 }
2002
2003 FocusOnLocation( VECTOR2I( aItem->GetFocusPosition().x, aItem->GetFocusPosition().y ), aAllowScroll );
2004 }
2005}
2006
2007
2009{
2010 const std::string& payload = mail.GetPayload();
2011
2012 wxLogTrace( wxT( "KICAD_TABS_DBG" ), wxT( "SYMBOL_EDIT_FRAME::KiwayMailIn cmd=%d" ), (int) mail.Command() );
2013
2014 switch( mail.Command() )
2015 {
2016 case MAIL_LIB_EDIT:
2017 if( !payload.empty() )
2018 {
2019 wxString uri( payload );
2020 wxString libNickname;
2021 wxString msg;
2022
2024 std::optional<const LIBRARY_TABLE_ROW*> libTableRow = adapter->FindRowByURI( uri );
2025
2026 if( !libTableRow )
2027 {
2028 msg.Printf( _( "The current configuration does not include the symbol library '%s'." ),
2029 uri );
2030 msg += wxS( "\n" ) + _( "Use Manage Symbol Libraries to edit the configuration." );
2031 DisplayErrorMessage( this, _( "Library not found in symbol library table." ), msg );
2032 break;
2033 }
2034
2035 libNickname = ( *libTableRow )->Nickname();
2036
2037 if( !adapter->HasLibrary( libNickname, true ) )
2038 {
2039 msg.Printf( _( "The symbol library '%s' is not enabled in the current configuration." ),
2040 UnescapeString( libNickname ) );
2041 msg += wxS( "\n" ) + _( "Use Manage Symbol Libraries to edit the configuration." );
2042 DisplayErrorMessage( this, _( "Symbol library not enabled." ), msg );
2043 break;
2044 }
2045
2046 if( m_treePane )
2047 {
2048 LIB_ID id( libNickname, wxEmptyString );
2049 GetLibTree()->SelectLibId( id );
2050 GetLibTree()->ExpandLibId( id );
2051 GetLibTree()->CenterLibId( id );
2052 }
2053 }
2054
2055 break;
2056
2058 {
2059 LIB_ID libId;
2060 const int badPos = libId.Parse( wxString::FromUTF8( payload ) );
2061
2062 if( badPos == -1 && libId.IsValid() )
2063 {
2064 LoadSymbol( libId, 1, BODY_STYLE::BASE );
2065 Raise();
2066 }
2067
2068 break;
2069 }
2070
2071 case MAIL_LIB_SAVE_ALL:
2072 mail.SetPayload( saveAllLibraries( false ) ? "success" : "failed" );
2073 break;
2074
2076 {
2077 // A symbol from the schematic is saved with it, so Save All Libraries could never clear it
2078 bool unsaved = HasLibModifications() || ( IsContentModified() && !IsSymbolFromSchematic() );
2079 mail.SetPayload( unsaved ? "yes" : "no" );
2080 break;
2081 }
2082
2083 case MAIL_RELOAD_LIB:
2084 {
2085 wxLogTrace( wxT( "KICAD_TABS_DBG" ), wxT( "SYMBOL_EDIT_FRAME::KiwayMailIn MAIL_RELOAD_LIB -> SyncLibraries" ) );
2086
2087 LIB_SYMBOL* current = GetCurSymbol();
2088 wxString lib = current ? current->GetLibId().GetLibNickname().wx_str() : wxString();
2089
2090 // The open symbol is a copy, so an unedited one is refreshed when nothing holds on to it
2091 bool refresh = current && !IsContentModified() && !IsSymbolFromSchematic() && IsEnabled()
2093
2094 // A derived symbol's copy links to its parent in the buffer, so keep every buffer a copy
2095 // still shows
2096 std::set<wxString> keep;
2097
2098 for( const std::unique_ptr<SYMBOL_EDITOR_TAB_CONTEXT>& ctx : m_tabContexts )
2099 {
2100 if( ctx.get() != m_activeTab || !refresh )
2101 keep.insert( ctx->GetLibrary() );
2102 }
2103
2104 if( current && !refresh )
2105 keep.insert( lib );
2106
2107 // Holds a refreshed copy's parent alive until the copy is replaced
2108 std::shared_ptr<LIB_SYMBOL> heldParent = refresh ? current->GetParent().lock() : nullptr;
2109
2110 // Untouched buffers hold the files as they were, and a pull may have changed them since
2111 std::vector<wxString> dropped = m_libMgr->DropUnmodifiedBuffers( keep );
2112
2113 // Only the pane is frozen. A frozen adapter hides every parent, and the view rebuilt from it
2114 // at the end of the sync is left with rows that no longer exist.
2115 m_treePane->Freeze();
2116
2117 // Suppress the progress dialog for this background reload. It would steal focus from the
2118 // editor that broadcast the reload, and the tree is already frozen around the sync.
2119 SyncLibraries( false );
2120 m_treePane->Thaw();
2122
2123 if( refresh && alg::contains( dropped, lib ) )
2124 {
2125 const wxString name = current->GetName();
2126 LIB_SYMBOL* refreshed = nullptr;
2127
2128 if( m_libMgr->SymbolExists( name, lib ) )
2129 refreshed = m_libMgr->GetBufferedSymbol( name, lib );
2130
2131 LIB_SYMBOL* replacement = nullptr;
2132
2133 if( refreshed )
2134 replacement = new LIB_SYMBOL( *refreshed );
2135 else if( heldParent )
2136 replacement = current->Flatten().release(); // The pull removed it and its parent dies with heldParent
2137
2138 if( replacement )
2139 {
2140 // The undo list holds the replaced copy's items
2142 SetCurSymbol( replacement, false );
2144
2145 if( m_toolManager )
2147 }
2148 }
2149
2150 break;
2151 }
2152
2154 {
2156 LIB_SYMBOL* symbol = GetCurSymbol();
2157
2158 wxLogTrace( traceLibWatch, "Received refresh symbol request for %s", payload );
2159
2160 if( !symbol )
2161 break;
2162
2163 // Capture the name now. UpdateLibraryBuffer() recreates the buffer, so reading it from the
2164 // buffer copy afterwards would be a use-after-free.
2165 const wxString refreshSymbolName = symbol->GetName();
2166
2167 // A modal dialog may be registered before wxGTK disables the frame. Refreshing the
2168 // symbol in either state would delete the LIB_SYMBOL being edited by the dialog.
2169 if( !IsEnabled() || Kiway().HasBlockingDialog() )
2170 {
2171 wxLogTrace( traceLibWatch, "Deferring symbol refresh; dialog is open on the symbol editor." );
2172 break;
2173 }
2174 // Defensive backstop for refresh mail that did not originate from this frame's debounce
2175 // timer (which already defers while a tool is active). An interactive tool holds
2176 // references into the current symbol, so replacing it here would crash; drop this refresh
2177 // and let the originating watcher retry.
2178 else if( !ToolStackIsEmpty() )
2179 {
2180 wxLogTrace( traceLibWatch, "Deferring symbol refresh; an interactive tool is active." );
2181 break;
2182 }
2183
2184 wxString libName = symbol->GetLibId().GetLibNickname();
2185 std::optional<const LIBRARY_TABLE_ROW*> row = adapter->GetRow( libName );
2186
2187 if( !row )
2188 return;
2189
2190 wxFileName libfullname( LIBRARY_MANAGER::GetFullURI( *row, true ) );
2191
2192 wxFileName changedLib( mail.GetPayload() );
2193
2194 wxLogTrace( traceLibWatch, "Received refresh symbol request for %s, current symbols is %s",
2195 changedLib.GetFullPath(), libfullname.GetFullPath() );
2196
2197 if( changedLib == libfullname )
2198 {
2199 wxLogTrace( traceLibWatch, "Refreshing symbol %s", refreshSymbolName );
2200
2201 m_libMgr->UpdateLibraryBuffer( libName );
2202
2203 if( LIB_SYMBOL* lib_symbol = m_libMgr->GetBufferedSymbol( refreshSymbolName, libName ) )
2204 {
2205 SetCurSymbol( new LIB_SYMBOL( *lib_symbol ), false );
2207
2208 if( m_toolManager )
2210 }
2211 }
2212
2213 break;
2214 }
2215
2216 default:
2217 break;
2218 }
2219}
2220
2221
2222std::unique_ptr<GRID_HELPER> SYMBOL_EDIT_FRAME::MakeGridHelper()
2223{
2224 return std::make_unique<EE_GRID_HELPER>( m_toolManager );
2225}
2226
2227
2229{
2230 // switches currently used canvas ( Cairo / OpenGL):
2231 SCH_BASE_FRAME::SwitchCanvas( aCanvasType );
2232
2233 // Set options specific to symbol editor (axies are always enabled):
2234 GetCanvas()->GetGAL()->SetAxesEnabled( true );
2236}
2237
2238
2240{
2241 wxCHECK( m_libMgr, false );
2242
2243 return m_libMgr->HasModifications();
2244}
2245
2246
2248{
2249 wxCHECK( m_libMgr, false );
2250
2251 // Test if the currently edited symbol is modified
2253 return true;
2254
2255 // Test if any library has been modified
2256 for( const wxString& libName : m_libMgr->GetLibraryNames() )
2257 {
2258 if( m_libMgr->IsLibraryModified( libName ) && !m_libMgr->IsLibraryReadOnly( libName ) )
2259 return true;
2260 }
2261
2262 return false;
2263}
2264
2265
2266bool SYMBOL_EDIT_FRAME::hasUnsavedLibraryEdits( const wxString& aLibNickname ) const
2267{
2268 // Edits in any tab of the library live in its buffer, which a reload replaces
2269 return SCH_BASE_FRAME::hasUnsavedLibraryEdits( aLibNickname ) || m_libMgr->IsLibraryModified( aLibNickname );
2270}
2271
2272
2274{
2275 if( aItemCount == 0 )
2276 return;
2277
2278 UNDO_REDO_CONTAINER& list = ( whichList == UNDO_LIST ) ? m_undoList : m_redoList;
2279
2280 // UR_TRANSIENT is flagged on the picked item, not the wrapper, so the shared deleters miss it.
2281 // Free the items carrying UR_TRANSIENT. m_symbol never carries it, so the live copy is safe.
2282 if( aItemCount < 0 )
2283 {
2285 }
2286 else
2287 {
2288 for( int ii = 0; ii < aItemCount; ii++ )
2289 {
2290 if( list.m_CommandsList.size() == 0 )
2291 break;
2292
2293 PICKED_ITEMS_LIST* curr_cmd = list.m_CommandsList[0];
2294 list.m_CommandsList.erase( list.m_CommandsList.begin() );
2295
2296 for( unsigned jj = 0; jj < curr_cmd->GetCount(); ++jj )
2297 {
2298 EDA_ITEM* item = curr_cmd->GetPickedItem( jj );
2299
2300 if( item && item->HasFlag( UR_TRANSIENT ) && item != m_symbol )
2301 delete item;
2302 }
2303
2304 curr_cmd->ClearItemsList();
2305 delete curr_cmd; // Delete command
2306 }
2307 }
2308}
2309
2310
2312{
2313 return m_toolManager->GetTool<SCH_SELECTION_TOOL>()->GetSelection();
2314}
2315
2316
2318 bool aRestorePending, bool aTreeShownNow )
2319{
2320 // Auto-hiding a visible tree schedules its restore. A chained schematic edit finds the tree
2321 // already auto-hidden, so keep the pending restore rather than dropping it. An explicit user
2322 // toggle clears the flag elsewhere, so a tree hidden without a pending restore stays that way.
2323 if( aTreeShownNow )
2324 return true;
2325
2326 return aWasFromSchematic && aRestorePending;
2327}
2328
2329
2331{
2332 std::unique_ptr<LIB_SYMBOL> symbol = aSymbol->GetLibSymbolRef()->Flatten();
2333 wxCHECK( symbol, /* void */ );
2334
2335 symbol->SetLibId( aSymbol->GetLibId() );
2336
2337 // Take in account the symbol orientation and mirroring. to calculate the field
2338 // positions in symbol editor (i.e. no rotation, no mirroring)
2339 int orientation = aSymbol->GetOrientation() & ~( SYM_MIRROR_X | SYM_MIRROR_Y );
2340 int mirror = aSymbol->GetOrientation() & ( SYM_MIRROR_X | SYM_MIRROR_Y );
2341
2342 std::vector<SCH_FIELD> fullSetOfFields;
2343
2344 for( const SCH_FIELD& field : aSymbol->GetFields() )
2345 {
2346 VECTOR2I pos = field.GetPosition() - aSymbol->GetPosition();
2347 SCH_FIELD libField( symbol.get(), field.GetId() );
2348
2349 libField = field;
2350
2351 // The inverse transform is mirroring before, rotate after
2352 switch( mirror )
2353 {
2354 case SYM_MIRROR_X: pos.y = -pos.y; break;
2355 case SYM_MIRROR_Y: pos.x = -pos.x; break;
2356 default: break;
2357 }
2358
2359 switch( orientation )
2360 {
2361 case SYM_ORIENT_90:
2362 std::swap( pos.x, pos.y );
2363 pos.x = - pos.x;
2364 break;
2365 case SYM_ORIENT_270:
2366 std::swap( pos.x, pos.y );
2367 pos.y = - pos.y;
2368 break;
2369 case SYM_ORIENT_180:
2370 pos.x = - pos.x;
2371 pos.y = - pos.y;
2372 break;
2373 default:
2374 break;
2375 }
2376
2377 libField.SetPosition( pos );
2378
2379 fullSetOfFields.emplace_back( std::move( libField ) );
2380 }
2381
2382 symbol->SetFields( fullSetOfFields );
2383
2384 const wxString reference = symbol->GetReferenceField().GetText();
2385 const int unit = std::max( 1, aSymbol->GetUnit() );
2386 const int bodyStyle = std::max( 1, aSymbol->GetBodyStyle() );
2387
2388 // Optimize default edit options for this symbol
2389 // Usually if units are locked, graphic items are specific to each unit
2390 // and if units are interchangeable, graphic items are common to units
2391 SetDrawSpecificUnit( symbol->UnitsLocked() );
2392
2393 // Hand the transient working symbol/screen to a session-only instance tab, whose activation
2394 // restores the frame's schematic-source state so the save path routes back to the schematic.
2395 SCH_SCREEN* tmpScreen = new SCH_SCREEN();
2396
2397 setSymWatcher( nullptr );
2398
2399 SYMBOL_EDITOR_TAB_CONTEXT* ctx = findOrCreateSymbolInstanceTab( symbol.release(), tmpScreen,
2400 aSymbol->m_Uuid, reference, unit,
2401 bodyStyle );
2402 wxCHECK( ctx, /* void */ );
2403
2406
2407 // Auto-hide the tree while editing a schematic symbol, remembering to restore it in SaveSettings
2408 // so the user's preference survives a restart. Hide via the pane directly, not ToggleLibraryTree,
2409 // which would treat this as a user toggle and drop the pending restore.
2412
2413 if( IsLibraryTreeShown() )
2414 {
2415 m_auimgr.GetPane( m_treePane ).Show( false );
2417 m_auimgr.Update();
2418 Refresh();
2419 }
2420
2423 updateInfoBar();
2424
2425 // Let tools add things to the view if necessary
2426 if( m_toolManager )
2428
2430 GetCanvas()->Refresh();
2431}
2432
2433
2434bool SYMBOL_EDIT_FRAME::addLibTableEntry( const wxString& aLibFile, LIBRARY_TABLE_SCOPE aScope )
2435{
2436 wxFileName fn = aLibFile;
2437 wxFileName libTableFileName( Prj().GetProjectPath(), FILEEXT::SymbolLibraryTableFileName );
2438 wxString libNickname = fn.GetName();
2440 LIBRARY_MANAGER& manager = Pgm().GetLibraryManager();
2441 const ENV_VAR_MAP& envVars = Pgm().GetLocalEnvVariables();
2442
2443 if( adapter->HasLibrary( libNickname ) )
2444 {
2445 wxString tmp;
2446 int suffix = 1;
2447
2448 while( adapter->HasLibrary( libNickname ) )
2449 {
2450 tmp.Printf( "%s%d", fn.GetName(), suffix );
2451 libNickname = tmp;
2452 suffix += 1;
2453 }
2454 }
2455
2456 std::optional<LIBRARY_TABLE*> optTable = manager.Table( LIBRARY_TABLE_TYPE::SYMBOL, aScope );
2457 wxCHECK( optTable.has_value(), false );
2458 LIBRARY_TABLE* table = optTable.value();
2459
2460 LIBRARY_TABLE_ROW* row = &table->InsertRow();
2461
2462 row->SetNickname( libNickname );
2463
2464 // We cannot normalize against the current project path when saving to global table.
2465 wxString normalizedPath = NormalizePath( aLibFile, &envVars,
2466 aScope == LIBRARY_TABLE_SCOPE::PROJECT ? Prj().GetProjectPath()
2467 : wxString( wxEmptyString ) );
2468
2469 row->SetURI( normalizedPath );
2471
2472 bool success = true;
2473
2474 table->Save().map_error(
2475 [&]( const LIBRARY_ERROR& aError )
2476 {
2477 KICAD_MESSAGE_DIALOG dlg( this, _( "Error saving library table." ), _( "File Save Error" ),
2478 wxOK | wxICON_ERROR );
2479 dlg.SetExtendedMessage( aError.message );
2480 dlg.ShowModal();
2481
2482 success = false;
2483 } );
2484
2485 if( success )
2486 {
2487 manager.ReloadTables( aScope, { LIBRARY_TABLE_TYPE::SYMBOL } );
2488 adapter->LoadOne( libNickname );
2489 }
2490
2491 return success;
2492}
2493
2494
2495bool SYMBOL_EDIT_FRAME::replaceLibTableEntry( const wxString& aLibNickname, const wxString& aLibFile )
2496{
2498 LIBRARY_MANAGER& manager = Pgm().GetLibraryManager();
2499 LIBRARY_TABLE* table = nullptr;
2501
2502 // Check the global library table first because checking the project library table
2503 // checks the global library table as well due to library chaining.
2504 if( adapter->GetRow( aLibNickname, scope ) )
2505 {
2506 std::optional<LIBRARY_TABLE*> optTable = manager.Table( LIBRARY_TABLE_TYPE::SYMBOL, scope );
2507 wxCHECK( optTable.has_value(), false );
2508 table = optTable.value();
2509 }
2510 else
2511 {
2513
2514 if( adapter->GetRow( aLibNickname, scope ) )
2515 {
2516 std::optional<LIBRARY_TABLE*> optTable = manager.Table( LIBRARY_TABLE_TYPE::SYMBOL, scope );
2517
2518 if( optTable.has_value() )
2519 table = optTable.value();
2520 }
2521 }
2522
2523 wxCHECK( table, false );
2524
2525 std::optional<LIBRARY_TABLE_ROW*> optRow = adapter->GetRow( aLibNickname, scope );
2526 wxCHECK( optRow.has_value(), false );
2527 LIBRARY_TABLE_ROW* row = optRow.value();
2528
2529 const ENV_VAR_MAP& envVars = Pgm().GetLocalEnvVariables();
2530
2531 wxString projectPath;
2532
2533 if( scope == LIBRARY_TABLE_SCOPE::PROJECT )
2534 projectPath = Prj().GetProjectPath();
2535
2536 wxString normalizedPath = NormalizePath( aLibFile, &envVars, projectPath );
2537
2538 row->SetURI( normalizedPath );
2539 row->SetType( "KiCad" );
2540
2541 bool success = true;
2542
2543 table->Save().map_error(
2544 [&]( const LIBRARY_ERROR& aError )
2545 {
2546 KICAD_MESSAGE_DIALOG dlg( this, _( "Error saving library table." ), _( "File Save Error" ),
2547 wxOK | wxICON_ERROR );
2548 dlg.SetExtendedMessage( aError.message );
2549 dlg.ShowModal();
2550
2551 success = false;
2552 } );
2553
2554 if( success )
2555 {
2556 manager.ReloadTables( scope, { LIBRARY_TABLE_TYPE::SYMBOL } );
2557 adapter->LoadOne( aLibNickname );
2558 }
2559
2560 return success;
2561}
2562
2563
2565{
2566 return m_symbol && !m_symbol->IsRoot();
2567}
2568
2569
2574
2575
2577{
2578 // Cannot edit graphics of symbols from legacy libraries, or of symbol aliases
2579 // unless the symbol is from a schematic (in which case it is a working copy of the symbol).
2581}
2582
2583
2584void SYMBOL_EDIT_FRAME::UpdateItem( EDA_ITEM* aItem, bool isAddOrDelete, bool aUpdateRtree )
2585{
2586 SCH_BASE_FRAME::UpdateItem( aItem, isAddOrDelete, aUpdateRtree );
2587
2588 if( EDA_TEXT* eda_text = dynamic_cast<EDA_TEXT*>( aItem ) )
2589 {
2590 eda_text->ClearBoundingBoxCache();
2591 eda_text->ClearRenderCache();
2592 }
2593}
2594
2595
2597{
2598 wxAuiPaneInfo& treePane = m_auimgr.GetPane( m_treePane );
2599 wxAuiPaneInfo& propertiesPane = m_auimgr.GetPane( PropertiesPaneName() );
2600 wxAuiPaneInfo& selectionFilterPane = m_auimgr.GetPane( wxS( "SelectionFilter" ) );
2601
2602 // Don't give the selection filter its own visibility controls; instead show it if
2603 // anything else is visible
2604 bool showFilter = ( treePane.IsShown() && treePane.IsDocked() )
2605 || ( propertiesPane.IsShown() && propertiesPane.IsDocked() );
2606
2607 selectionFilterPane.Show( showFilter );
2608}
2609
2610
2612{
2613 // Returns the current render option for invisible fields
2615}
2616
2617
2619{
2620 // Returns the current render option for invisible pins
2622}
const char * name
const KICOMMON_API wxEventTypeTag< wxCommandEvent > EDA_EVT_PLUGIN_AVAILABILITY_CHANGED
Notifies other parts of KiCad when plugin availability changes.
BASE_SCREEN class implementation.
constexpr EDA_IU_SCALE schIUScale
Definition base_units.h:130
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:100
@ icon_libedit_32
@ icon_libedit_16
BOX2< VECTOR2I > BOX2I
Definition box2.h:917
BOX2< VECTOR2D > BOX2D
Definition box2.h:918
static TOOL_ACTION toggleGrid
Definition actions.h:195
static TOOL_ACTION paste
Definition actions.h:77
static TOOL_ACTION cancelInteractive
Definition actions.h:69
static TOOL_ACTION unselectAll
Definition actions.h:80
static TOOL_ACTION revert
Definition actions.h:58
static TOOL_ACTION showLibraryTree
Definition actions.h:161
static TOOL_ACTION exportForOlderVersion
Definition actions.h:60
static TOOL_ACTION copy
Definition actions.h:75
static TOOL_ACTION showDatasheet
Definition actions.h:265
static TOOL_ACTION toggleBoundingBoxes
Definition actions.h:154
static TOOL_ACTION saveAll
Definition actions.h:57
static TOOL_ACTION undo
Definition actions.h:72
static TOOL_ACTION duplicate
Definition actions.h:81
static TOOL_ACTION doDelete
Definition actions.h:82
static TOOL_ACTION selectionTool
Definition actions.h:248
static TOOL_ACTION save
Definition actions.h:54
static TOOL_ACTION zoomFitScreen
Definition actions.h:139
static TOOL_ACTION redo
Definition actions.h:73
static TOOL_ACTION deleteTool
Definition actions.h:83
static TOOL_ACTION zoomTool
Definition actions.h:143
static TOOL_ACTION selectionClear
Clear the current selection.
Definition actions.h:221
static TOOL_ACTION showProperties
Definition actions.h:263
static TOOL_ACTION cut
Definition actions.h:74
static TOOL_ACTION ddAddLibrary
Definition actions.h:64
static TOOL_ACTION copyAsText
Definition actions.h:76
static TOOL_ACTION toggleGridOverrides
Definition actions.h:196
static TOOL_ACTION selectAll
Definition actions.h:79
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.
wxString m_ColorTheme
Active color theme name.
Handles how to draw a screen (a board, a schematic ...)
Definition base_screen.h:37
void SetContentModified(bool aModified=true)
Definition base_screen.h:55
constexpr void SetOrigin(const Vec &pos)
Definition box2.h:240
constexpr void SetSize(const SizeVec &size)
Definition box2.h:251
Color settings are a bit different than most of the settings objects in that there can be more than o...
Handle actions that are shared between different applications.
Handles action that are shared between different applications.
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
Specify 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...
bool isBlockableSessionEnd() const
Return true when the session is ending on a platform that shows a shutdown block reason.
ACTION_TOOLBAR * m_tbRight
TOOLBAR_SETTINGS * m_toolbarSettings
wxAuiManager m_auimgr
virtual void RecreateToolbars()
UNDO_REDO_CONTAINER m_redoList
ACTION_TOOLBAR * m_tbLeft
virtual void OnDropFiles(wxDropFilesEvent &aEvent)
Handle event fired when a file is dropped to the window.
std::map< const wxString, TOOL_ACTION * > m_acceptedExts
Associate file extensions with action to execute.
ACTION_TOOLBAR * m_tbTopMain
wxString m_aboutTitle
bool m_isClosing
Set by the close window event handler after frames are asked if they can close.
void ReCreateMenuBar()
Recreate the menu bar.
WX_INFOBAR * GetInfoBar()
COLOR_SETTINGS * m_colorSettings
void OnSelectGrid(wxCommandEvent &event)
Command event handler for selecting grid sizes.
void setupUnits(APP_SETTINGS_BASE *aCfg)
void setArcModeConditions(const TOOL_ACTION &aDrawArc, const std::function< bool(const SELECTION &)> &aEnable)
Check each arc mode's tool action while the arc tool runs in that mode.
virtual void SwitchCanvas(EDA_DRAW_PANEL_GAL::GAL_TYPE aCanvasType)
Change the current rendering backend.
virtual void OnSelectZoom(wxCommandEvent &event)
Set the zoom factor when selected by the zoom list box in the main tool bar.
GAL_DISPLAY_OPTIONS_IMPL & GetGalDisplayOptions()
Return a reference to the gal rendering options used by GAL for rendering.
virtual void resolveCanvasType()
Determine the canvas type to load (with prompt if required) and initializes m_canvasType.
static const wxString PropertiesPaneName()
EDA_MSG_PANEL * m_messagePanel
virtual void SetScreen(BASE_SCREEN *aScreen)
bool LibraryFileBrowser(const wxString &aTitle, bool doOpen, wxFileName &aFilename, const wxString &wildcard, const wxString &ext, bool isDirectory, FILEDLG_HOOK_NEW_LIBRARY *aFileDlgHook=nullptr)
void FocusOnLocation(const VECTOR2I &aPos, bool aAllowScroll=true)
Useful to focus on a particular location, in find functions.
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:98
virtual const VECTOR2I GetFocusPosition() const
Similar to GetPosition() but allows items to return their visual center rather than their anchor.
Definition eda_item.h:355
const KIID m_Uuid
Definition eda_item.h:599
void ClearBrightened()
Definition eda_item.h:154
void SetBrightened()
Definition eda_item.h:151
bool HasFlag(EDA_ITEM_FLAGS aFlag) const
Definition eda_item.h:168
bool IsBrightened() const
Definition eda_item.h:136
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:94
Class that groups generic conditions for editor states.
SELECTION_CONDITION NoActiveTool()
Create a functor testing if there are no tools active in the frame.
SELECTION_CONDITION BoundingBoxes()
SELECTION_CONDITION RedoAvailable()
Create a functor that tests if there are any items in the redo queue.
SELECTION_CONDITION CurrentTool(const TOOL_ACTION &aTool)
Create a functor testing if the specified tool is the current active tool in the frame.
virtual SELECTION_CONDITION UndoAvailable()
Create a functor that tests if there are any items in the undo queue.
SELECTION_CONDITION 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.
The tab strip plus the single shared GAL canvas.
Tool responsible for drawing graphical shapes (rectangles, circles, arcs, beziers,...
void ReadWindowSettings(WINDOW_SETTINGS &aCfg)
Read GAL config options from application-level config.
void RegisterHandler(API_HANDLER *aHandler)
Adds a new request handler to the server.
void DeregisterHandler(API_HANDLER *aHandler)
Helper class to create more flexible dialogs, including 'do not show again' checkbox handling.
Definition kidialog.h:38
int ShowModal() override
Definition kidialog.cpp:89
bool m_axesEnabled
Whether or not to draw the coordinate system axes.
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:317
void ClearHiddenFlags()
Clear the hide flag of all items in the view.
Definition sch_view.cpp:305
bool IsSCH_ITEM() const
Definition view_item.h:97
void Clear()
Remove all items from the view.
Definition view.cpp:1773
void UpdateAllItems(int aUpdateFlags)
Update all items in the view according to the given flags.
Definition view.cpp:2474
Definition kiid.h:46
Carry a payload from one KIWAY_PLAYER to another within a PROJECT.
Definition kiway_mail.h:34
std::string & GetPayload()
Return the payload, which can be any text but it typically self identifying s-expression.
Definition kiway_mail.h:52
void SetPayload(const std::string &aPayload)
Definition kiway_mail.h:53
MAIL_T Command()
Returns the MAIL_T associated with this mail.
Definition kiway_mail.h:44
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:348
void OnKiCadExit()
Definition kiway.cpp:826
virtual KIWAY_PLAYER * Player(FRAME_T aFrameType, bool doCreate=true, wxTopLevelWindow *aParent=nullptr)
Return the KIWAY_PLAYER* given a FRAME_T.
Definition kiway.cpp:407
virtual void ExpressMail(FRAME_T aDestination, MAIL_T aCommand, std::string &aPayload, wxWindow *aSource=nullptr, bool aFromOtherThread=false)
Send aPayload to aDestination from aSource.
Definition kiway.cpp:511
bool HasBlockingDialog() const
Definition kiway.h:527
Module editor specific tools.
std::optional< LIBRARY_TABLE_ROW * > FindRowByURI(const wxString &aUri, LIBRARY_TABLE_SCOPE aScope=LIBRARY_TABLE_SCOPE::BOTH) const
Like LIBRARY_MANAGER::FindRowByURI but filtered to the LIBRARY_TABLE_TYPE of this adapter.
bool HasLibrary(const wxString &aNickname, bool aCheckEnabled=false) const
Test for the existence of aNickname in the library tables.
std::optional< LIBRARY_TABLE_ROW * > GetRow(const wxString &aNickname, LIBRARY_TABLE_SCOPE aScope=LIBRARY_TABLE_SCOPE::BOTH) const
Like LIBRARY_MANAGER::GetRow but filtered to the LIBRARY_TABLE_TYPE of this adapter.
void ReloadTables(LIBRARY_TABLE_SCOPE aScope, std::initializer_list< LIBRARY_TABLE_TYPE > aTablesToLoad={})
std::optional< LIBRARY_TABLE * > Table(LIBRARY_TABLE_TYPE aType, LIBRARY_TABLE_SCOPE aScope)
Retrieves a given table; creating a new empty project table if a valid project is loaded and the give...
std::optional< wxString > GetFullURI(LIBRARY_TABLE_TYPE aType, const wxString &aNickname, bool aSubstituted=false)
Return the full location specifying URI for the LIB, either in original UI form or in environment var...
void SetNickname(const wxString &aNickname)
void SetType(const wxString &aType)
void SetURI(const wxString &aUri)
A logical library item identifier and consists of various portions much like a URI.
Definition lib_id.h:45
int Parse(const UTF8 &aId, bool aFix=false)
Parse LIB_ID with the information from aId.
Definition lib_id.cpp:65
int SetLibItemName(const UTF8 &aLibItemName)
Override the library item name portion of the LIB_ID to aLibItemName.
Definition lib_id.cpp:124
bool IsValid() const
Check if this LID_ID is valid.
Definition lib_id.h:168
const UTF8 & GetLibItemName() const
Definition lib_id.h:98
const UTF8 & GetLibNickname() const
Return the logical library name portion of a LIB_ID.
Definition lib_id.h:83
Symbol library management helper that is specific to the symbol library editor frame.
Define a library symbol object.
Definition lib_symbol.h:114
const LIB_ID & GetLibId() const override
Definition lib_symbol.h:190
std::weak_ptr< LIB_SYMBOL > & GetParent()
Definition lib_symbol.h:152
wxString GetName() const override
Definition lib_symbol.h:183
std::unique_ptr< LIB_SYMBOL > Flatten() const
Return a flattened symbol inheritance to the caller.
Node type: LIB_ID.
void Update(LIB_TREE_ITEM *aItem)
Update the node using data from a LIB_ALIAS object.
void RefreshLibTree()
Refresh the tree (mainly to update highlighting and asterisking)
Definition lib_tree.cpp:492
void CenterLibId(const LIB_ID &aLibId)
Ensure that an item is visible (preferably centered).
Definition lib_tree.cpp:382
int GetSelectionCount() const
Definition lib_tree.h:85
void ShutdownPreviews()
Definition lib_tree.cpp:282
void ShowChangedLanguage()
Definition lib_tree.cpp:299
void FocusSearchFieldIfExists()
Focus the search widget if it exists.
Definition lib_tree.cpp:514
std::vector< LIB_ID > GetExpandedLibraries() const
Definition lib_tree.cpp:402
void SelectLibId(const LIB_ID &aLibId)
Select an item in the tree widget.
Definition lib_tree.cpp:370
LIB_TREE_MODEL_ADAPTER::SORT_MODE GetSortMode() const
Definition lib_tree.h:151
int GetSelectedLibIds(std::vector< LIB_ID > &aSelection, std::vector< int > *aUnit=nullptr) const
Retrieve a list of selections for trees that allow multi-selection.
Definition lib_tree.cpp:329
void Unselect()
Unselect currently selected item in wxDataViewCtrl.
Definition lib_tree.cpp:388
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:309
void ExpandLibId(const LIB_ID &aLibId)
Expand and item i the tree widget.
Definition lib_tree.cpp:396
void Regenerate(bool aKeepState)
Regenerate the tree.
Definition lib_tree.cpp:474
virtual ENV_VAR_MAP & GetLocalEnvVariables() const
Definition pgm_base.cpp:846
KICAD_API_SERVER & GetApiServer()
Definition pgm_base.h:142
virtual SETTINGS_MANAGER & GetSettingsManager() const
Definition pgm_base.h:124
virtual LIBRARY_MANAGER & GetLibraryManager() const
Definition pgm_base.h:126
A holder to handle information on schematic or board items.
unsigned GetCount() const
void ClearItemsList()
Delete only the list of pickers NOT the picked data itself.
EDA_ITEM * GetPickedItem(unsigned int aIdx) const
static SYMBOL_LIBRARY_ADAPTER * SymbolLibAdapter(PROJECT *aProject)
Accessor for project symbol library manager adapter.
virtual const wxString GetProjectPath() const
Return the full path of the project.
Definition project.cpp:277
Action handler for the Properties panel.
Gather all the actions that are shared by tools.
Definition sch_actions.h:46
static TOOL_ACTION rotateCCW
static TOOL_ACTION editSymbolPinMaps
static TOOL_ACTION importSymbol
static TOOL_ACTION newSymbol
static TOOL_ACTION saveLibraryAs
static TOOL_ACTION mirrorV
static TOOL_ACTION drawEllipseArc
static TOOL_ACTION editLibSymbolWithLibEdit
static TOOL_ACTION drawArc
static TOOL_ACTION pinTable
static TOOL_ACTION drawSymbolLines
static TOOL_ACTION placeSymbolPin
static TOOL_ACTION drawSymbolTextBox
static TOOL_ACTION ddImportGraphics
static TOOL_ACTION drawRectangle
static TOOL_ACTION drawEllipse
static TOOL_ACTION drawCircle
static TOOL_ACTION importGraphics
static TOOL_ACTION drawBezier
static TOOL_ACTION saveSymbolCopyAs
static TOOL_ACTION rotateCW
static TOOL_ACTION showElectricalTypes
static TOOL_ACTION drawSymbolPolygon
static TOOL_ACTION showHiddenFields
static TOOL_ACTION placeSymbolAnchor
static TOOL_ACTION showHiddenPins
static TOOL_ACTION cycleBodyStyle
static TOOL_ACTION mirrorH
static TOOL_ACTION runERC
Inspection and Editing.
static TOOL_ACTION symbolProperties
static TOOL_ACTION placeSymbolText
static TOOL_ACTION toggleSyncedPinsMode
static TOOL_ACTION togglePinAltIcons
static TOOL_ACTION updateSymbolFields
static TOOL_ACTION saveSymbolAs
A shim class between EDA_DRAW_FRAME and several derived classes: SYMBOL_EDIT_FRAME,...
SCH_BASE_FRAME(KIWAY *aKiway, wxWindow *aParent, FRAME_T aWindowType, const wxString &aTitle, const wxPoint &aPosition, const wxSize &aSize, long aStyle, const wxString &aFrameName)
SCH_RENDER_SETTINGS * GetRenderSettings()
virtual bool hasUnsavedLibraryEdits(const wxString &aLibNickname) const
Return true if reloading library aLibNickname from disk would discard unsaved edits.
void doCloseWindow() override
void SaveSettings(APP_SETTINGS_BASE *aCfg) override
Save common frame parameters to a configuration data file.
void LoadSettings(APP_SETTINGS_BASE *aCfg) override
Load common frame parameters from a configuration file.
SCH_SCREEN * GetScreen() const override
Return a pointer to a BASE_SCREEN or one of its derivatives.
SYMBOL_EDITOR_SETTINGS * libeditconfig() const
SCH_DRAW_PANEL * GetCanvas() const override
Return a pointer to GAL-based canvas of given EDA draw frame.
void CommonSettingsChanged(int aFlags) override
Notification event that some of the common (suite-wide) settings have changed.
void SyncView()
Mark all items for refresh.
PANEL_SCH_SELECTION_FILTER * m_selectionFilterPanel
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 KIGFX::VIEW instance used in the panel.
void DisplaySymbol(LIB_SYMBOL *aSymbol)
Schematic editor (Eeschema) main window.
bool SaveSymbolToSchematic(const LIB_SYMBOL &aSymbol, const KIID &aSchematicSymbolUUID)
Update a schematic symbol from a LIB_SYMBOL.
void SetPosition(const VECTOR2I &aPosition) override
Handle actions specific to the schematic editor.
static const wxString ShowType(SCH_FILE_T aFileType)
Return a brief name for a plugin, given aFileType enum.
static SCH_FILE_T GuessPluginTypeFromLibPath(const wxString &aLibPath, int aCtl=0)
Return a plugin type given a symbol library using the file extension of aLibPath.
Base class for any item which can be embedded within the SCHEMATIC container class,...
Definition sch_item.h:170
int GetBodyStyle() const
Definition sch_item.h:253
int GetUnit() const
Definition sch_item.h:243
Tool that displays edit points allowing to modify items by dragging the points.
SCH_SELECTION & GetSelection()
SCH_SELECTION_FILTER_OPTIONS & GetFilter()
Schematic symbol object.
Definition sch_symbol.h:76
void GetFields(std::vector< SCH_FIELD * > &aVector, bool aVisibleOnly) const override
Populate a std::vector with SCH_FIELDs, sorted in ordinal order.
VECTOR2I GetPosition() const override
Definition sch_symbol.h:958
const LIB_ID & GetLibId() const override
Definition sch_symbol.h:166
int GetOrientation() const override
Get the display symbol orientation.
std::unique_ptr< LIB_SYMBOL > & GetLibSymbolRef()
Definition sch_symbol.h:185
static bool NotEmpty(const SELECTION &aSelection)
Test if there are any items selected.
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).
Handle actions for the various symbol editor and viewers.
One open symbol tab owning a working LIB_SYMBOL and screen lent to the frame while active.
The symbol library editor main window.
std::vector< std::unique_ptr< SYMBOL_EDITOR_TAB_CONTEXT > > m_tabContexts
bool m_isSymbolFromSchematic
Flag if the symbol being edited was loaded directly from a schematic.
void restoreSymbolTabsFromSettings()
Recreate tabs from the persisted open-tab list once the libraries have loaded.
void OnExitKiCad(wxCommandEvent &event)
void LoadSettings(APP_SETTINGS_BASE *aCfg) override
Load common frame parameters from a configuration file.
bool promptToSaveInactiveInstanceTabs()
Prompt to save each dirty instance (symbol from schematic) tab that is not the active one,...
std::unique_ptr< GRID_HELPER > MakeGridHelper() override
void UpdateItem(EDA_ITEM *aItem, bool isAddOrDelete=false, bool aUpdateRtree=false) override
Mark an item for refresh.
void setupUIConditions() override
Setup the UI conditions for the various actions and their controls in this frame.
APP_SETTINGS_BASE * config() const override
Return the settings object used in SaveSettings(), and is overloaded in KICAD_MANAGER_FRAME.
std::unique_ptr< API_HANDLER_COMMON > m_apiHandlerCommon
bool hasDirtyInactiveInstanceTabs() const
True if any non-active instance (schematic) tab has unsaved edits.
bool IsLibraryTreeShown() const override
const BOX2I GetDocumentExtents(bool aIncludeAllVisible=true) const override
Return bounding box of document with option to not include some items.
SELECTION & GetCurrentSelection() override
Get the current selection from the canvas area.
wxString getTargetLib() const
Return either the library selected in the symbol tree, if context menu is active or the library that ...
bool LoadSymbolFromLib(const wxString &aLibName, const wxString &aSymbolName, int aUnit=0, int aBodyStyle=0)
Load a symbol from a library, optionally setting the selected unit and body style.
bool IsCurrentSymbol(const LIB_ID &aLibId) const
Return true if aLibId is an alias for the editor screen symbol.
bool backupLibrary(const wxFileName &aOriginalFile, wxString &aErrorMsg)
Create a backup copy of a symbol library.
static void freeTransientUndoCommands(UNDO_REDO_CONTAINER &aList, const LIB_SYMBOL *aLiveSymbol)
Free every command in the list and the UR_TRANSIENT-flagged copies it owns, which the shared deleters...
void OnSelectBodyStyle(wxCommandEvent &event)
wxString m_reference
RefDes of the symbol (only valid if symbol was loaded from schematic)
EDITOR_TABS_PANEL * m_tabsPanel
SYMBOL_EDITOR_TAB_CONTEXT * findOrCreateSymbolInstanceTab(LIB_SYMBOL *aSymbol, SCH_SCREEN *aScreen, const KIID &aSchematicSymbolUUID, const wxString &aReference, int aUnit, int aBodyStyle)
Find or create the instance tab for a placed schematic symbol and make it active.
void RefreshLibraryTree()
Redisplay the library tree.
void updateSelectionFilterVisbility() override
Selection filter panel doesn't have a dedicated visibility control, so show it if any other AUI panel...
void CommonSettingsChanged(int aFlags) override
Called after the preferences dialog is run.
void FocusLibraryTreeInput() override
wxComboBox * m_unitSelectBox
bool m_drawSpecificBodyStyle
When editing a symbol: only apply new graphic items to the current body style.
void RebuildSymbolUnitAndBodyStyleLists()
int GetTreeLIBIDs(std::vector< LIB_ID > &aSelection) const
void OnTabCharHook(wxKeyEvent &aEvent)
Cycle symbol tabs from the char hook, since GTK cannot register WXK_TAB as an accelerator.
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
void FocusOnLibId(const LIB_ID &aLibID)
void SaveLibraryAs(SAVE_LIBRARY_AS aSaveType=SAVE_LIBRARY_AS::NEW)
Save the currently selected library to a new file.
void ToggleProperties() override
SYMBOL_EDITOR_SETTINGS * m_settings
void LoadSymbol(const wxString &aLibrary, const wxString &aSymbol, int Unit)
void onPluginAvailabilityChanged(wxCommandEvent &aEvt)
void HardRedraw() override
Rebuild the GAL and redraw the screen.
int GetTreeSelectionCount() const
bool addLibTableEntry(const wxString &aLibFile, LIBRARY_TABLE_SCOPE aScope=LIBRARY_TABLE_SCOPE::GLOBAL)
Add aLibFile to the symbol library table defined by aScope.
void SaveSettings(APP_SETTINGS_BASE *aCfg) override
Save common frame parameters to a configuration data file.
int m_unit
The unit number to edit and show.
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 SetScreen(BASE_SCREEN *aScreen) override
void KiwayMailIn(KIWAY_MAIL_EVENT &mail) override
Receive KIWAY_MAIL_EVENT messages from other players.
SYMBOL_EDITOR_TAB_CONTEXT * m_activeTab
SYMBOL_EDITOR_SETTINGS * GetSettings() const
SCH_SCREEN * m_dummyScreen
Helper screen used when no symbol is loaded.
void SetCurSymbol(LIB_SYMBOL *aSymbol, bool aUpdateZoom)
Take ownership of aSymbol and notes that it is the one currently being edited.
SYMBOL_EDIT_FRAME(KIWAY *aKiway, wxWindow *aParent)
static bool libTreeAutoHiddenForSchematicEdit(bool aWasFromSchematic, bool aRestorePending, bool aTreeShownNow)
Resolve whether the library tree's auto-hide for a schematic edit still needs restoring on save.
bool IsSymbolEditable() const
Test if a symbol is loaded and can be edited.
std::unique_ptr< API_HANDLER_SYMBOL > m_apiHandler
std::vector< LIB_ID > GetSelectedLibIds() const
void SyncLibraries(bool aShowProgress, bool aPreloadCancelled=false, const wxString &aForceRefresh=wxEmptyString)
Synchronize the library manager to the symbol library table, and then the symbol tree to the library ...
void OnSelectUnit(wxCommandEvent &event)
void storeSymbolTabsToSettings()
Write the current tab set into the editor settings for the next session.
LIB_SYMBOL * GetCurSymbol() const
Return the current symbol being edited or NULL if none selected.
void UpdateSymbolMsgPanelInfo()
Display the documentation of the selected symbol.
bool canCloseWindow(wxCloseEvent &aCloseEvent) override
LIB_ID GetTargetLibId() const override
Return either the symbol selected in the symbol tree (if context menu is active) or the symbol on the...
bool m_libTreeAutoHiddenForSchematicEdit
True while a schematic-edit auto-hide of the library tree still needs restoring on save.
void SetBodyStyle(int aBodyStyle)
int m_bodyStyle
Show the normal shape (m_bodyStyle <= 1) or the DeMorgan converted shape (m_bodyStyle > 1)
bool saveAllLibraries(bool aRequireConfirmation)
Return true when the operation has succeeded (all requested libraries have been saved or none was sel...
void UpdateMsgPanel() override
Redraw the message panel.
void ClearUndoORRedoList(UNDO_REDO_LIST whichList, int aItemCount=-1) override
Free the undo or redo list from aList element.
LIB_TREE * GetLibTree() const override
void UpdateTitle()
Update the main window title bar with the current library name and read only status of the library.
bool HasLibModifications() const
Check if any pending libraries have been modified.
std::unique_ptr< API_HANDLER_LIBRARIES > m_apiLibrariesHandler
bool promptAndCloseSymbolTab(int aIdx)
Prompt for unsaved changes on the tab and drop its context.
SYMBOL_TREE_PANE * m_treePane
void SetDrawSpecificUnit(bool aSpecific)
void LoadSymbolFromSchematic(SCH_SYMBOL *aSymbol)
Load a symbol from the schematic to edit in place.
bool m_drawSpecificUnit
When editing a symbol: only apply new graphic items to the current unit.
bool saveCurrentSymbol()
Save the current symbol.
bool IsSymbolGraphicallyEditable() const
Test if a symbol is loaded and can be edited graphically.
COLOR_SETTINGS * GetColorSettings(bool aForceRefresh=false) const override
Returns a pointer to the active color theme settings.
LIB_SYMBOL_LIBRARY_MANAGER & GetLibManager()
void OnUpdateBodyStyle(wxUpdateUIEvent &event)
void SaveSymbolCopyAs(bool aOpenCopy)
Save the currently selected symbol to a new name and/or location.
void SwitchCanvas(EDA_DRAW_PANEL_GAL::GAL_TYPE aCanvasType) override
Switch currently used canvas ( Cairo / OpenGL).
void doCloseWindow() override
SYMBOL_EDITOR_TAB_CONTEXT * symbolTabContextForIndex(int aIdx) const
Resolve the tab context for a panel tab index, or nullptr.
static void clearSymbolTabUndoRedo(SYMBOL_EDITOR_TAB_CONTEXT &aContext)
Free a detached context's undo/redo, which the frame's own teardown path never reaches.
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 FocusOnItem(EDA_ITEM *aItem, bool aAllowScroll=true) override
Focus on a particular canvas item.
void configureToolbars() override
bool hasUnsavedLibraryEdits(const wxString &aLibNickname) const override
Return true if reloading library aLibNickname from disk would discard unsaved edits.
void CloseWindow(wxCommandEvent &event)
Trigger the wxCloseEvent, which is handled by the function given to EVT_CLOSE() macro:
wxComboBox * m_bodyStyleSelectBox
void activateSymbolTab(SYMBOL_EDITOR_TAB_CONTEXT *aContext)
Make aContext the active tab, borrowing its working symbol, undo/redo, view and selection,...
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 ShowChangedLanguage() override
Redraw the menus and what not in current language.
bool IsContentModified() const override
Get if any symbols or libraries have been modified but not saved.
void ToggleLibraryTree() override
LIB_SYMBOL * getTargetSymbol() const
Return currently edited symbol.
void OnUpdateUnitNumber(wxUpdateUIEvent &event)
An interface to the global shared library manager that is schematic-specific and linked to one projec...
std::optional< LIB_STATUS > LoadOne(LIB_DATA *aLib) override
Loads or reloads the given library, if it exists.
Library Editor pane with symbol tree and symbol library table selector.
Rate-limiter that fires at most once per interval.
Definition throttle.h:31
bool Ready()
Definition throttle.h:44
TOOL_MANAGER * m_toolManager
TOOL_DISPATCHER * m_toolDispatcher
bool ToolStackIsEmpty()
TOOL_MANAGER * GetToolManager() const
Return the MVC controller.
ACTIONS * m_actions
@ MODEL_RELOAD
Model changes (the sheet for a schematic)
Definition tool_base.h:76
virtual void DispatchWxEvent(wxEvent &aEvent)
Process wxEvents (mostly UI events), translate them to TOOL_EVENTs, and make tools handle those.
Master controller class:
bool RunAction(const std::string &aActionName, T aParam)
Run the specified action immediately, pausing the current action to run the new one.
A holder to handle a list of undo (or redo) commands.
A wxDirTraverser to filter out symbol (.kicad_sym) files in an unpacked symbol library.
virtual wxDirTraverseResult OnFile(const wxString &aFilename) override
virtual wxDirTraverseResult OnDir(const wxString &WXUNUSED(aDirname)) override
UNPACKED_SYMBOL_LIBRARY_DIR_TRAVERSER(std::vector< wxString > &aFiles)
bool empty() const
Definition utf8.h:105
wxString wx_str() const
Definition utf8.cpp:41
A modified version of the wxInfoBar class that allows us to:
Definition wx_infobar.h:77
void RemoveAllButtons()
Remove all the buttons that have been added by the user.
bool HasCloseButton() const
void AddLink(const wxString &aLinkText, const std::function< void(wxHyperlinkEvent &)> &aFn)
Add a hypertext link to the infobar.
void Dismiss() override
Dismisses the infobar and updates the containing layout and AUI manager (if one is provided).
void AddCloseButton(const wxString &aTooltip=_("Hide this message."))
Add the default close button to the infobar on the right side.
void ShowMessage(const wxString &aMessage, int aFlags=wxICON_INFORMATION) override
Show the info bar with the provided message and icon.
bool HandleUnsavedChanges(wxWindow *aParent, const wxString &aMessage, const std::function< bool()> &aSaveFunction)
Display a dialog with Save, Cancel and Discard Changes buttons.
Definition confirm.cpp:146
void DisplayErrorMessage(wxWindow *aParent, const wxString &aText, const wxString &aExtraInfo)
Display an error message with aMessage.
Definition confirm.cpp:217
void DisplayError(wxWindow *aParent, const wxString &aText)
Display an error or warning message box with aMessage.
Definition confirm.cpp:192
This file is part of the common library.
#define KICAD_MESSAGE_DIALOG
Definition confirm.h:48
KIFACE_BASE & Kiface()
Global KIFACE_BASE "get" accessor.
Definition cvpcb.cpp:178
#define CHECK(x)
#define ENABLE(x)
static bool empty(const wxTextEntryBase *aCtrl)
#define _(s)
#define KICAD_DEFAULT_DRAWFRAME_STYLE
#define LIB_EDIT_FRAME_NAME
#define UR_TRANSIENT
indicates the item is owned by the undo/redo stack
@ ID_LIBEDIT_SELECT_UNIT_NUMBER
Definition eeschema_id.h:59
@ ID_LIBEDIT_SELECT_BODY_STYLE
Definition eeschema_id.h:60
const wxAuiPaneInfo & defaultSchSelectionFilterPaneInfo(wxWindow *aWindow)
const wxAuiPaneInfo & defaultPropertiesPaneInfo(wxWindow *aWindow)
wxString NormalizePath(const wxFileName &aFilePath, const ENV_VAR_MAP *aEnvVars, const wxString &aProjectPath)
Normalize a file path to an environmental variable, if possible.
Definition env_paths.cpp:73
Helper functions to substitute paths with environmental variables.
@ FRAME_SCH_SYMBOL_EDITOR
Definition frame_type.h:31
@ FRAME_SCH
Definition frame_type.h:30
static const std::string SymbolLibraryTableFileName
static const std::string KiCadSymbolLibFileExtension
static const std::string SVGFileExtension
static wxString KiCadSymbolLibFileWildcard()
const wxChar *const traceLibWatch
Flag to enable debug output for library file watch refreshes.
const wxChar *const traceApi
Flag to enable debug output related to the IPC API and its plugin system.
Definition api_utils.cpp:33
@ ID_ON_GRID_SELECT
Definition id.h:113
@ ID_ON_ZOOM_SELECT
Definition id.h:112
std::map< wxString, ENV_VAR_ITEM > ENV_VAR_MAP
PROJECT & Prj()
Definition kicad.cpp:730
EVT_MENU(ID_COMPARE_PROJECT_BRANCHES, KICAD_MANAGER_FRAME::OnCompareProjectBranches) KICAD_MANAGER_FRAME
TAB_VISUAL_STATE ResolveTabVisualState(bool aPreview, bool aModified)
Resolve a tab's decorations from its document state flags.
KIID niluuid(0)
@ LAYER_SCHEMATIC_GRID_AXES
Definition layer_ids.h:518
LIBRARY_TABLE_SCOPE
@ MAIL_SCH_EDIT_LIBID
Definition mail_type.h:54
@ MAIL_LIB_EDIT
Definition mail_type.h:51
@ MAIL_LIB_HAS_UNSAVED
Definition mail_type.h:70
@ MAIL_REFRESH_SYMBOL
Definition mail_type.h:57
@ MAIL_RELOAD_LIB
Definition mail_type.h:55
@ MAIL_LIB_SAVE_ALL
Definition mail_type.h:69
@ ALL
All except INITIAL_ADD.
Definition view_item.h:55
void SetShutdownBlockReason(wxWindow *aWindow, const wxString &aReason)
Sets the block reason why the window/application is preventing OS shutdown.
Definition unix/app.cpp:108
static constexpr size_t CLOUD_SYNC_BUFFER_SIZE
Buffer size for file I/O operations on cloud-synced folders.
Definition io.h:169
bool contains(const _Container &__container, _Value __value)
Returns true if the container contains the given value.
Definition kicad_algo.h:96
static std::string normalizedPath(std::string aPath)
#define _HKI(x)
Definition page_info.cpp:40
void InvokeSchEditSymbolLibTable(KIWAY *aKiway, wxWindow *aParent)
PGM_BASE & Pgm()
The global program "get" accessor.
see class PGM_BASE
@ BASE
Definition sch_item.h:64
#define DEFAULT_THEME
COLOR_SETTINGS * GetColorSettings(const wxString &aName)
T * GetToolbarSettings(const wxString &aFilename)
T * GetAppSettings(const char *aFilename)
KIWAY Kiway(KFCTL_STANDALONE)
wxString UnescapeString(const wxString &aSource)
Functors that can be used to figure out how the action controls should be displayed in the UI and if ...
wxString message
Visual decorations derived from document state: preview is italic, modified is bold with a leading as...
@ SYM_ORIENT_270
Definition symbol.h:39
@ SYM_MIRROR_Y
Definition symbol.h:41
@ SYM_ORIENT_180
Definition symbol.h:38
@ SYM_MIRROR_X
Definition symbol.h:40
@ SYM_ORIENT_90
Definition symbol.h:37
#define EDIT_TOOL(tool)
#define DEMORGAN_ALT
#define DEMORGAN_STD
const std::string table
static EDA_ORIENTATION orientation(double d)
KIBIS_PIN * pin
#define ENVVARS_CHANGED
wxLogTrace helper definitions.
VECTOR2< int32_t > VECTOR2I
Definition vector2d.h:708
VECTOR2< double > VECTOR2D
Definition vector2d.h:707
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.