KiCad PCB EDA Suite
Loading...
Searching...
No Matches
symbol_edit_frame_tabs.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 The KiCad Developers, see AUTHORS.txt for contributors.
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version 2
9 * of the License, or (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <https://www.gnu.org/licenses/>.
18 */
19
26
27#include <sch_render_settings.h>
28#include <symbol_edit_frame.h>
29
30#include <kidialog.h>
31#include <lib_symbol.h>
33#include <sch_screen.h>
34#include <sch_view.h>
37#include <tool/actions.h>
38#include <tool/selection.h>
39#include <tool/tool_manager.h>
41#include <view/view.h>
42#include <view/view_controls.h>
44#include <widgets/lib_tree.h>
46
47
49{
51
52 if( KIGFX::VIEW* view = GetCanvas() ? GetCanvas()->GetView() : nullptr )
53 {
54 snapshot.scale = view->GetScale();
55 snapshot.center = view->GetCenter();
56 snapshot.valid = true;
57 }
58
59 return snapshot;
60}
61
62
64{
65 if( !aSnapshot.valid )
66 return;
67
68 if( KIGFX::VIEW* view = GetCanvas() ? GetCanvas()->GetView() : nullptr )
69 {
70 view->SetScale( aSnapshot.scale );
71 view->SetCenter( aSnapshot.center );
72 }
73}
74
75
77{
78 std::vector<KIID> kiids;
79
81 : nullptr;
82
83 if( !selTool )
84 return kiids;
85
86 for( EDA_ITEM* item : selTool->GetSelection() )
87 {
88 if( item )
89 kiids.push_back( item->m_Uuid );
90 }
91
92 return kiids;
93}
94
95
96void SYMBOL_EDIT_FRAME::restoreSymbolSelectionKiids( const std::vector<KIID>& aKiids )
97{
98 if( aKiids.empty() )
99 return;
100
102 : nullptr;
103 SCH_SCREEN* screen = GetScreen();
104
105 if( !selTool || !screen )
106 return;
107
108 for( SCH_ITEM* item : screen->Items() )
109 {
110 for( const KIID& kiid : aKiids )
111 {
112 if( item->m_Uuid == kiid )
113 {
114 selTool->AddItemToSel( item, true );
115 break;
116 }
117 }
118 }
119}
120
121
123{
124 if( !m_activeTab )
125 return;
126
127 m_activeTab->ViewSnapshot() = captureSymbolViewSnapshot();
128 m_activeTab->SavedSelection() = captureSymbolSelectionKiids();
129 m_activeTab->SetUnit( m_unit );
130 m_activeTab->SetBodyStyle( m_bodyStyle );
131
132 // m_symbol may have been replaced by undo/redo since activation.
133 m_activeTab->AdoptWorkingObjects( m_symbol, static_cast<SCH_SCREEN*>( GetScreen() ) );
134
135 m_activeTab->UndoList().m_CommandsList.swap( m_undoList.m_CommandsList );
136 m_activeTab->RedoList().m_CommandsList.swap( m_redoList.m_CommandsList );
137}
138
139
141{
142 wxCHECK( m_toolManager, /* void */ );
143
144 if( !aContext )
145 return;
146
147 if( aContext == m_activeTab )
148 {
149 // Already active, but the caller may have requested a different unit/body style; apply it.
150 m_unit = aContext->GetUnit();
151 m_bodyStyle = aContext->GetBodyStyle();
152
157
160 GetCanvas()->Refresh();
161 return;
162 }
163
165 m_activeTab = aContext;
166
167 m_undoList.m_CommandsList.swap( aContext->UndoList().m_CommandsList );
168 m_redoList.m_CommandsList.swap( aContext->RedoList().m_CommandsList );
169
171
172 aContext->ReleaseToFrame();
173
174 // Restore the frame's schematic-source state from the incoming tab so the existing save path
175 // (SaveSymbolToSchematic vs the library) keys off the active tab, not whichever tab loaded last.
178 m_reference = aContext->GetReference();
179
180 m_symbol = aContext->GetSymbol();
181 m_unit = aContext->GetUnit();
182 m_bodyStyle = aContext->GetBodyStyle();
183
184 // Install the new screen before SetScreen, whose ResetTools would otherwise deref the freed one.
185 m_toolManager->SetEnvironment( aContext->GetScreen(), GetCanvas()->GetView(), GetCanvas()->GetViewControls(),
186 GetSettings(), this );
187 SetScreen( aContext->GetScreen() );
188
189 if( m_symbol )
190 {
191 wxLogTrace( wxT( "KICAD_TABS_DBG" ), wxT( "activateSymbolTab SelectLibId '%s'" ),
192 m_symbol->GetLibId().Format().wx_str() );
193 GetLibTree()->SelectLibId( m_symbol->GetLibId() );
194 }
195
196 // A restored or switched-to tab otherwise keeps watching whichever library loaded last
197 LIB_ID watched = m_symbol && !IsSymbolFromSchematic() ? m_symbol->GetLibId() : LIB_ID();
198 setSymWatcher( watched.IsValid() ? &watched : nullptr );
199
200 m_toolManager->SetEnvironment( GetScreen(), GetCanvas()->GetView(), GetCanvas()->GetViewControls(),
201 GetSettings(), this );
202
207
211
212 // MODEL_RELOAD clears the selection, so restore the saved one afterwards.
214
215 if( aContext->ViewSnapshot().valid )
216 {
218 }
219 else
220 {
221 // First time this tab is shown there is no saved view
223 }
224
226
228
230 m_propertiesPanel->UpdateData();
231
234 GetCanvas()->Refresh();
235}
236
237
238void SYMBOL_EDIT_FRAME::OnTabCharHook( wxKeyEvent& aEvent )
239{
240 // Only plain Ctrl+Tab and Ctrl+Shift+Tab are ours; anything else falls through.
241 const bool isTab = aEvent.GetKeyCode() == WXK_TAB;
242 const bool ctrlOnly = aEvent.ControlDown() && !aEvent.AltDown() && !aEvent.MetaDown();
243
244 // Ctrl+W closes the active tab while tabs are open, else falls through to close-window. The
245 // keycode arrives as 'W' or the control char 0x17 depending on platform, so accept both.
246 const int keyCode = aEvent.GetKeyCode();
247 const bool isCtrlW = ctrlOnly && !aEvent.ShiftDown()
248 && ( keyCode == 'W' || keyCode == ( 'W' - '@' ) );
249
250 if( isCtrlW && m_tabsPanel->Model().Entries().size() >= 1 )
251 {
252 // Route through CloseTab so the unsaved-changes prompt still runs.
253 m_tabsPanel->CloseTab( m_tabsPanel->GetActiveTab() );
254 return;
255 }
256
257 if( !isTab || !ctrlOnly )
258 {
259 aEvent.Skip();
260 return;
261 }
262
263 m_tabsPanel->AdvanceTab( !aEvent.ShiftDown() );
264
265 // Consume the event so GTK's default Tab focus-traversal does not also run.
266}
267
268
270 const LIB_SYMBOL* aLiveSymbol )
271{
272 for( PICKED_ITEMS_LIST* cmd : aList.m_CommandsList )
273 {
274 // The undo copy is the picked ITEM flagged UR_TRANSIENT, not the wrapper, so the shared
275 // deleters skip it. Free exactly the items that carry UR_TRANSIENT here.
276 for( unsigned ii = 0; ii < cmd->GetCount(); ++ii )
277 {
278 EDA_ITEM* item = cmd->GetPickedItem( ii );
279
280 if( !item || !item->HasFlag( UR_TRANSIENT ) )
281 continue;
282
283 // The live working symbol clears UR_TRANSIENT when it becomes m_symbol; guard anyway
284 // against a double-free of the live symbol.
285 wxCHECK2_MSG( item != aLiveSymbol, continue,
286 wxT( "Live working symbol flagged UR_TRANSIENT in undo/redo list" ) );
287
288 delete item;
289 }
290
291 cmd->ClearItemsList();
292 delete cmd;
293 }
294
295 aList.m_CommandsList.clear();
296}
297
298
300{
301 // The context is detached here, so no undo copy is the live working object.
302 freeTransientUndoCommands( aContext.UndoList(), nullptr );
303 freeTransientUndoCommands( aContext.RedoList(), nullptr );
304}
305
306
308 EDITOR_TABS_MODEL& aModel )
309{
310 // An active tab's screen aliases the frame's current screen, so this clears the live flag too.
311 if( SCH_SCREEN* screen = aContext.GetScreen() )
312 screen->SetContentModified( false );
313
314 aModel.MarkModified( aContext.GetTabKey(), false );
315}
316
317
319{
320 for( const std::unique_ptr<SYMBOL_EDITOR_TAB_CONTEXT>& ctx : m_tabContexts )
321 {
322 if( ctx->GetLibrary() != aLibrary )
323 continue;
324
325 clearTabModifiedState( *ctx, m_tabsPanel->MutableModel() );
326 }
327
328 // The strip queries the dirty flag only on repaint, so without this the cleared asterisk lingers
329 // until the next stray paint event reaches the tab the user was on.
330 m_tabsPanel->RefreshTabLabels();
331}
332
333
335{
336 for( const std::unique_ptr<SYMBOL_EDITOR_TAB_CONTEXT>& ctx : m_tabContexts )
337 {
338 if( ctx->GetTabKey() == aKey )
339 return ctx.get();
340 }
341
342 return nullptr;
343}
344
345
346void SYMBOL_EDIT_FRAME::dropSymbolTabContext( const wxString& aKey )
347{
349
350 // The active context is still on screen and owned by the frame, so never drop it here; only an
351 // evicted, inactive preview reaches this path.
352 if( !ctx || ctx == m_activeTab )
353 return;
354
356
357 std::erase_if( m_tabContexts,
358 [ctx]( const std::unique_ptr<SYMBOL_EDITOR_TAB_CONTEXT>& aOwned )
359 {
360 return aOwned.get() == ctx;
361 } );
362}
363
364
366{
367 const std::vector<EDITOR_TABS_MODEL::ENTRY>& entries = m_tabsPanel->Model().Entries();
368
369 if( aIdx < 0 || aIdx >= static_cast<int>( entries.size() ) )
370 return nullptr;
371
372 return symbolTabContextForKey( entries[aIdx].key );
373}
374
375
376SYMBOL_EDITOR_TAB_CONTEXT* SYMBOL_EDIT_FRAME::findOrCreateSymbolTab( const wxString& aLib, const wxString& aName,
377 int aUnit, int aBodyStyle, bool aAsPreview,
378 bool* aWasCreated )
379{
380 const wxString key = SYMBOL_EDITOR_TAB_CONTEXT::MakeTabKey( aLib, aName );
381 const int unit = aUnit > 0 ? aUnit : 1;
382 const int bodyStyle = aBodyStyle > 0 ? aBodyStyle : 1;
383
385
386 if( aWasCreated )
387 *aWasCreated = false;
388
389 if( !ctx )
390 {
391 SYMBOL_BUFFER* buffer = m_libMgr ? m_libMgr->GetBuffer( aName, aLib ) : nullptr;
392
393 if( !buffer )
394 return nullptr;
395
396 m_tabContexts.push_back( std::make_unique<SYMBOL_EDITOR_TAB_CONTEXT>( aLib, aName, buffer ) );
397 ctx = m_tabContexts.back().get();
398
399 if( aWasCreated )
400 *aWasCreated = true;
401 }
402
403 ctx->SetUnit( unit );
404 ctx->SetBodyStyle( bodyStyle );
405
406 // A previewed open reuses the existing preview slot in the panel instead of adding a tab.
407 // The panel drops the evicted key from its model, but the matching context lingers in
408 // m_tabContexts and would be persisted as a phantom tab, so capture the evicted key and drop
409 // its context once the reuse completes.
410 wxString replacedKey;
411
412 if( aAsPreview )
413 {
414 const std::vector<EDITOR_TABS_MODEL::ENTRY>& entries = m_tabsPanel->Model().Entries();
415 const int previewIdx = m_tabsPanel->Model().PreviewIndex();
416
417 if( previewIdx >= 0 && previewIdx < static_cast<int>( entries.size() ) && entries[previewIdx].key != key )
418 replacedKey = entries[previewIdx].key;
419 }
420
421 m_tabsPanel->ActivateOrCreateTab( key, aName, aAsPreview );
422
423 if( !replacedKey.empty() )
424 dropSymbolTabContext( replacedKey );
425
426 return ctx;
427}
428
429
432 const KIID& aSchematicSymbolUUID, const wxString& aReference,
433 int aUnit, int aBodyStyle )
434{
435 const wxString key = SYMBOL_EDITOR_TAB_CONTEXT::MakeInstanceTabKey( aSchematicSymbolUUID );
436 const int unit = aUnit > 0 ? aUnit : 1;
437 const int bodyStyle = aBodyStyle > 0 ? aBodyStyle : 1;
438
440 {
441 // Re-editing the same placed symbol focuses the live tab, so free the redundant new objects.
442 delete aSymbol;
443 delete aScreen;
444
445 existing->SetUnit( unit );
446 existing->SetBodyStyle( bodyStyle );
447
448 m_tabsPanel->ActivateOrCreateTab( key, existing->GetDisplayName(), false );
449
450 return existing;
451 }
452
453 m_tabContexts.push_back( std::make_unique<SYMBOL_EDITOR_TAB_CONTEXT>( aSymbol, aScreen, aSchematicSymbolUUID,
454 aReference ) );
455 SYMBOL_EDITOR_TAB_CONTEXT* ctx = m_tabContexts.back().get();
456
457 ctx->SetUnit( unit );
458 ctx->SetBodyStyle( bodyStyle );
459
460 m_tabsPanel->ActivateOrCreateTab( key, ctx->GetDisplayName(), false );
461
462 return ctx;
463}
464
465
467{
468 auto ctx = std::make_unique<SYMBOL_EDITOR_TAB_CONTEXT>( aSymbol, aScreen );
469 SYMBOL_EDITOR_TAB_CONTEXT* raw = ctx.get();
470
471 m_tabContexts.push_back( std::move( ctx ) );
472
473 m_tabsPanel->ActivateOrCreateTab( raw->GetTabKey(), raw->GetDisplayName(), false );
474
475 return raw;
476}
477
478
480{
482
483 if( !ctx )
484 return true;
485
486 if( ctx->IsModified() && !m_silentSymbolTabClose )
487 {
488 wxString msg = wxString::Format( _( "Save changes to '%s' before closing?" ), ctx->GetDisplayName( true ) );
489
490 KIDIALOG dlg( this, msg, _( "Confirmation" ), wxYES_NO | wxCANCEL | wxICON_WARNING );
491 dlg.SetYesNoCancelLabels( _( "Save" ), _( "Discard Changes" ), _( "Cancel" ) );
492
493 switch( dlg.ShowModal() )
494 {
495 case wxID_YES:
496 // saveCurrentSymbol operates on the active tab, so activate this one first to save it.
497 if( ctx != m_activeTab )
498 activateSymbolTab( ctx );
499
500 if( !saveCurrentSymbol() )
501 return false;
502
503 if( IsLibraryTreeShown() )
504 m_treePane->GetLibTree()->RefreshLibTree();
505
506 break;
507
508 case wxID_NO:
509 // Edits reach the library buffer as they are made, so discarding them must restore it too
510 if( !ctx->IsTransient() && m_libMgr->IsSymbolModified( ctx->GetName(), ctx->GetLibrary() ) )
511 {
512 m_libMgr->RevertSymbol( LIB_ID( ctx->GetLibrary(), ctx->GetName() ) );
513
514 if( IsLibraryTreeShown() )
515 m_treePane->GetLibTree()->RefreshLibTree();
516 }
517
518 break;
519
520 default:
521 return false;
522 }
523 }
524
525 // If this is the active tab the frame holds its objects, so repoint at the dummy screen and drop
526 // m_symbol before destroying the context, then let the context free them once.
527 if( ctx == m_activeTab )
528 {
529 // Clear the frame's undo/redo so nothing references the about-to-be-deleted working symbol.
531 ctx->AdoptWorkingObjects( m_symbol, static_cast<SCH_SCREEN*>( GetScreen() ) );
532
533 m_activeTab = nullptr;
534 m_symbol = nullptr;
536
537 // Clear the mirrored schematic-source state so the frame no longer looks like it holds an
538 // instance symbol; a successor tab's activateSymbolTab restores these from its own context.
541 m_reference = wxEmptyString;
542 }
543 else
544 {
545 // An inactive tab's undo/redo still holds transient copies; free them before destroying it.
547 }
548
549 std::erase_if( m_tabContexts,
550 [ctx]( const std::unique_ptr<SYMBOL_EDITOR_TAB_CONTEXT>& aOwned )
551 {
552 return aOwned.get() == ctx;
553 } );
554
555 return true;
556}
557
558
560{
561 for( const std::unique_ptr<SYMBOL_EDITOR_TAB_CONTEXT>& ctx : m_tabContexts )
562 {
563 if( ctx.get() != m_activeTab && ctx->IsTransient() && ctx->IsModified() )
564 return true;
565 }
566
567 return false;
568}
569
570
572{
573 // Collect first; saving activates a tab, which mutates m_activeTab and m_tabContexts ordering.
574 std::vector<SYMBOL_EDITOR_TAB_CONTEXT*> dirty;
575
576 for( const std::unique_ptr<SYMBOL_EDITOR_TAB_CONTEXT>& ctx : m_tabContexts )
577 {
578 // The active tab and library tabs are handled by the existing close checks.
579 if( ctx.get() != m_activeTab && ctx->IsTransient() && ctx->IsModified() )
580 dirty.push_back( ctx.get() );
581 }
582
583 // Saving activates each dirty tab in turn; restore the tab the user was on so a vetoed close leaves
584 // the editor where it was and a successful close persists the real active tab, not a discarded one.
585 SYMBOL_EDITOR_TAB_CONTEXT* originalActive = m_activeTab;
586
587 for( SYMBOL_EDITOR_TAB_CONTEXT* ctx : dirty )
588 {
589 wxString msg = wxString::Format( _( "Save changes to '%s' before closing?" ), ctx->GetDisplayName() );
590
591 KIDIALOG dlg( this, msg, _( "Confirmation" ), wxYES_NO | wxCANCEL | wxICON_WARNING );
592 dlg.SetYesNoCancelLabels( _( "Save" ), _( "Discard Changes" ), _( "Cancel" ) );
593
594 const int answer = dlg.ShowModal();
595
596 if( answer == wxID_YES )
597 {
598 // saveCurrentSymbol saves the active tab via the mirrored frame state, so activate this
599 // one first; it clears the screen's modified flag on success.
600 activateSymbolTab( ctx );
601
602 if( !saveCurrentSymbol() )
603 {
604 activateSymbolTab( originalActive );
605 return false;
606 }
607 }
608 else if( answer != wxID_NO )
609 {
610 activateSymbolTab( originalActive );
611 return false;
612 }
613 }
614
615 activateSymbolTab( originalActive );
616
617 return true;
618}
619
620
622{
623 const wxString key = SYMBOL_EDITOR_TAB_CONTEXT::MakeTabKey( aLibId.GetLibNickname(), aLibId.GetLibItemName() );
624
625 const int idx = m_tabsPanel->FindTab( key );
626
627 if( idx < 0 )
628 return;
629
630 // The caller already confirmed the deletion, so close without re-prompting. The panel selects a
631 // successor tab when this was the active one.
633 m_tabsPanel->CloseTab( idx );
635}
636
637
638void SYMBOL_EDIT_FRAME::RenameSymbolTab( const LIB_ID& aOldId, const LIB_ID& aNewId )
639{
640 const wxString newLib = aNewId.GetLibNickname();
641 const wxString newName = aNewId.GetLibItemName();
642
643 if( m_activeTab && m_activeTab->IsUnsaved() && aOldId.GetLibNickname().empty() && !newLib.IsEmpty() )
644 {
645 const wxString unsavedKey = m_activeTab->GetTabKey();
646
647 m_activeTab->PromoteToLibrary( newLib, newName );
648 m_tabsPanel->RenameTab( unsavedKey, m_activeTab->GetTabKey(), m_activeTab->GetDisplayName() );
649
650 return;
651 }
652
653 const wxString oldKey = SYMBOL_EDITOR_TAB_CONTEXT::MakeTabKey( aOldId.GetLibNickname(), aOldId.GetLibItemName() );
654
656 {
657 ctx->SetName( newName );
658 m_tabsPanel->RenameTab( oldKey, SYMBOL_EDITOR_TAB_CONTEXT::MakeTabKey( newLib, newName ), newName );
659 }
660}
661
662
664{
665 wxLogTrace( wxT( "KICAD_TABS_DBG" ), wxT( "restoreSymbolTabsFromSettings enter" ) );
666
667 if( !m_settings )
668 return;
669
670 m_loadingSymbolTab = true;
671
672 wxString activeKey = m_settings->m_ActiveTabKey;
673 int activeIdx = -1;
674
675 for( const SYMBOL_EDITOR_SETTINGS::OPEN_TAB& tab : m_settings->m_OpenTabs )
676 {
677 if( !m_libMgr->LibraryExists( tab.lib ) || !m_libMgr->SymbolExists( tab.name, tab.lib ) )
678 {
679 wxLogTrace( "KICAD_TABS", "Dropping unresolved persisted symbol tab '%s:%s'.", tab.lib, tab.name );
680 continue;
681 }
682
684 findOrCreateSymbolTab( tab.lib, tab.name, tab.unit, tab.bodyStyle, tab.preview );
685
686 if( !ctx )
687 {
688 wxLogTrace( "KICAD_TABS", "Dropping persisted symbol tab '%s:%s'; buffer unavailable.", tab.lib, tab.name );
689 continue;
690 }
691
692 const int idx = m_tabsPanel->FindTab( ctx->GetTabKey() );
693
694 if( ctx->GetTabKey() == activeKey )
695 activeIdx = idx;
696 }
697
698 m_loadingSymbolTab = false;
699
700 if( activeIdx >= 0 )
701 m_tabsPanel->SelectTab( activeIdx );
702
703 wxLogTrace( wxT( "KICAD_TABS_DBG" ), wxT( "restoreSymbolTabsFromSettings exit (activeIdx=%d)" ), activeIdx );
704}
705
706
708{
709 if( !m_settings )
710 return;
711
712 m_settings->m_OpenTabs.clear();
713 m_settings->m_ActiveTabKey.clear();
714
715 for( const std::unique_ptr<SYMBOL_EDITOR_TAB_CONTEXT>& ctx : m_tabContexts )
716 {
717 // Instance tabs are session-only and never persisted.
718 if( ctx->IsTransient() )
719 continue;
720
722 tab.lib = ctx->GetLibrary();
723 tab.name = ctx->GetName();
724 tab.unit = ctx->GetUnit();
725 tab.bodyStyle = ctx->GetBodyStyle();
726
727 const int idx = m_tabsPanel->FindTab( ctx->GetTabKey() );
728 const std::vector<EDITOR_TABS_MODEL::ENTRY>& entries = m_tabsPanel->Model().Entries();
729
730 if( idx >= 0 && idx < static_cast<int>( entries.size() ) )
731 tab.preview = entries[idx].preview;
732
733 m_settings->m_OpenTabs.push_back( tab );
734 }
735
736 // Never restore an instance tab as the active tab, since it is not persisted.
737 if( m_activeTab && !m_activeTab->IsTransient() )
738 m_settings->m_ActiveTabKey = m_activeTab->GetTabKey();
739}
static TOOL_ACTION zoomFitScreen
Definition actions.h:139
static TOOL_ACTION selectionClear
Clear the current selection.
Definition actions.h:221
UNDO_REDO_CONTAINER m_undoList
virtual void ClearUndoRedoList()
Clear the undo and redo list using ClearUndoORRedoList()
UNDO_REDO_CONTAINER m_redoList
PROPERTIES_PANEL * m_propertiesPanel
virtual void Refresh(bool aEraseBackground=true, const wxRect *aRect=nullptr) override
A base class for most all the KiCad significant classes used in schematics and boards.
Definition eda_item.h:98
bool HasFlag(EDA_ITEM_FLAGS aFlag) const
Definition eda_item.h:168
GUI-free preview/dirty/close state machine.
void MarkModified(const wxString &aKey, bool aModified)
Update the modified flag.
VIEW_SNAPSHOT & ViewSnapshot()
std::vector< KIID > & SavedSelection()
Selection saved as resolved KIIDs, restored after the view is rebuilt.
UNDO_REDO_CONTAINER & RedoList()
UNDO_REDO_CONTAINER & UndoList()
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
void HideDrawingSheet()
Definition sch_view.cpp:317
void ClearHiddenFlags()
Clear the hide flag of all items in the view.
Definition sch_view.cpp:305
Hold a (potentially large) number of VIEW_ITEMs and renders them on a graphics device provided by the...
Definition view.h:68
Definition kiid.h:46
A logical library item identifier and consists of various portions much like a URI.
Definition lib_id.h:45
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
Define a library symbol object.
Definition lib_symbol.h:114
void SelectLibId(const LIB_ID &aLibId)
Select an item in the tree widget.
Definition lib_tree.cpp:370
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
SCH_RENDER_SETTINGS * GetRenderSettings()
SCH_SCREEN * GetScreen() const override
Return a pointer to a BASE_SCREEN or one of its derivatives.
SCH_DRAW_PANEL * GetCanvas() const override
Return a pointer to GAL-based canvas of given EDA draw frame.
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)
Base class for any item which can be embedded within the SCHEMATIC container class,...
Definition sch_item.h:170
EE_RTREE & Items()
Get the full RTree, usually for iterating.
Definition sch_screen.h:122
SCH_SELECTION & GetSelection()
int AddItemToSel(const TOOL_EVENT &aEvent)
One open symbol tab owning a working LIB_SYMBOL and screen lent to the frame while active.
void ReleaseToFrame()
Hand the working symbol/screen to the frame as the tab becomes active.
LIB_SYMBOL * GetSymbol() const
Observe the working symbol/screen.
const wxString & GetReference() const
static wxString MakeTabKey(const wxString &aLib, const wxString &aName)
De-duplication key for a library:symbol pair.
static wxString MakeInstanceTabKey(const KIID &aSchematicSymbolUUID)
De-duplication key for a placed schematic instance, in a namespace disjoint from library keys.
wxString GetTabKey() const override
Stable identity for persistence and de-duplication.
wxString GetDisplayName(bool aShortForm=false) const override
Short label shown on the tab.
const KIID & GetSchematicSymbolUUID() const
bool IsModified() const override
True when the working screen carries unsaved edits.
void AdoptWorkingObjects(LIB_SYMBOL *aSymbol, SCH_SCREEN *aScreen)
Take ownership back on detach, capturing whatever the frame's symbol now points at.
const wxString & GetLibrary() const
bool IsTransient() const
True for a tab that is session-only and not persisted.
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.
bool promptToSaveInactiveInstanceTabs()
Prompt to save each dirty instance (symbol from schematic) tab that is not the active one,...
bool hasDirtyInactiveInstanceTabs() const
True if any non-active instance (schematic) tab has unsaved edits.
bool IsLibraryTreeShown() const override
void RenameSymbolTab(const LIB_ID &aOldId, const LIB_ID &aNewId)
Update the open tab for aOldId, if any, to the renamed symbol aNewId so its label and key track the r...
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...
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 restoreSymbolSelectionKiids(const std::vector< KIID > &aKiids)
Reselect the items named by aKiids after a reload rebuilt the view.
static void clearTabModifiedState(SYMBOL_EDITOR_TAB_CONTEXT &aContext, EDITOR_TABS_MODEL &aModel)
Clear a tab's dirty state on both the context (read on repaint) and the strip model (read on close),...
void RebuildSymbolUnitAndBodyStyleLists()
void OnTabCharHook(wxKeyEvent &aEvent)
Cycle symbol tabs from the char hook, since GTK cannot register WXK_TAB as an accelerator.
LIB_SYMBOL_LIBRARY_MANAGER * m_libMgr
SYMBOL_EDITOR_SETTINGS * m_settings
void dropSymbolTabContext(const wxString &aKey)
Drop the inactive context for aKey from m_tabContexts, freeing its undo/redo.
int m_unit
The unit number to edit and show.
bool IsSymbolFromLegacyLibrary() const
bool IsSymbolFromSchematic() const
void SetScreen(BASE_SCREEN *aScreen) override
SYMBOL_EDITOR_TAB_CONTEXT * m_activeTab
SYMBOL_EDITOR_SETTINGS * GetSettings() const
SCH_SCREEN * m_dummyScreen
Helper screen used when no symbol is loaded.
EDITOR_TAB_CONTEXT::VIEW_SNAPSHOT captureSymbolViewSnapshot() const
Capture the current view zoom/center for the active tab's snapshot.
void restoreSymbolViewSnapshot(const EDITOR_TAB_CONTEXT::VIEW_SNAPSHOT &aSnapshot)
Restore a previously captured view zoom/center.
bool m_silentSymbolTabClose
While true, promptAndCloseSymbolTab() skips the unsaved-changes dialog.
SYMBOL_EDITOR_TAB_CONTEXT * findOrCreateSymbolTab(const wxString &aLib, const wxString &aName, int aUnit, int aBodyStyle, bool aAsPreview, bool *aWasCreated=nullptr)
Open aName from aLib in a tab, creating it when absent, and return the activated context.
SYMBOL_EDITOR_TAB_CONTEXT * symbolTabContextForKey(const wxString &aKey) const
Resolve the tab context for a tab key, or nullptr.
void storeSymbolTabsToSettings()
Write the current tab set into the editor settings for the next session.
void UpdateSymbolMsgPanelInfo()
Display the documentation of the selected symbol.
int m_bodyStyle
Show the normal shape (m_bodyStyle <= 1) or the DeMorgan converted shape (m_bodyStyle > 1)
LIB_TREE * GetLibTree() const override
SYMBOL_EDITOR_TAB_CONTEXT * CreateUnsavedSymbolTab(LIB_SYMBOL *aSymbol, SCH_SCREEN *aScreen)
Open a new tab over a transient working symbol and screen and make it active.
bool promptAndCloseSymbolTab(int aIdx)
Prompt for unsaved changes on the tab and drop its context.
SYMBOL_TREE_PANE * m_treePane
std::vector< KIID > captureSymbolSelectionKiids() const
Capture the KIIDs of the current selection for the active tab's snapshot.
void closeSymbolTab(const LIB_ID &aLibId)
Close the open tab for aLibId, if any, without prompting and leaving the other tabs open.
bool saveCurrentSymbol()
Save the current symbol.
void clearSymbolTabsModifiedForLibrary(const wxString &aLibrary)
Clear the unsaved-edits flag on every tab in a saved library so its dirty indicator clears.
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 detachActiveSymbolTab()
Snapshot the active tab's view and selection into its context without deleting the document.
void activateSymbolTab(SYMBOL_EDITOR_TAB_CONTEXT *aContext)
Make aContext the active tab, borrowing its working symbol, undo/redo, view and selection,...
TOOL_MANAGER * m_toolManager
@ MODEL_RELOAD
Model changes (the sheet for a schematic)
Definition tool_base.h:76
A holder to handle a list of undo (or redo) commands.
std::vector< PICKED_ITEMS_LIST * > m_CommandsList
bool empty() const
Definition utf8.h:105
#define _(s)
#define UR_TRANSIENT
indicates the item is owned by the undo/redo stack
KIID niluuid(0)
View snapshot captured on detach, restored on activate.
One persisted open editor tab, restored on the next session.