KiCad PCB EDA Suite
Loading...
Searching...
No Matches
sch_inspection_tool.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) 2019-2023 CERN
5 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 2
10 * of the License, or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program. If not, see <https://www.gnu.org/licenses/>.
19 */
20
21#include <tool/tool_manager.h>
24
25#include <sch_symbol.h>
26#include <id.h>
27#include <kiway.h>
28#include <kiplatform/ui.h>
29#include <confirm.h>
30#include <string_utils.h>
34#include <tools/sch_actions.h>
36#include <tools/sch_selection.h>
37#include <sim/simulator_frame.h>
38#include <sch_edit_frame.h>
39#include <symbol_edit_frame.h>
40#include <symbol_viewer_frame.h>
41#include <eda_doc.h>
42#include <sch_marker.h>
43#include <project.h>
44#include <project_sch.h>
46#include <dialogs/dialog_erc.h>
51#include <math/util.h> // for KiROUND
52
58#include <eeschema_helpers.h>
59#include <schematic.h>
61#include <local_history.h>
63#include <wx/filedlg.h>
64#include <wx/filename.h>
65
66
68 SCH_TOOL_BASE<SCH_BASE_FRAME>( "eeschema.InspectionTool" ), m_busSyntaxHelp( nullptr )
69{
70}
71
72
74{
76
77 // Add inspection actions to the selection tool menu
78 //
79 CONDITIONAL_MENU& selToolMenu = m_selectionTool->GetToolMenu().GetMenu();
80
82
85
86 return true;
87}
88
89
91{
92 SCH_TOOL_BASE::Reset( aReason );
93
94 if( aReason == SUPERMODEL_RELOAD || aReason == RESET_REASON::SHUTDOWN )
95 {
96 wxCommandEvent* evt = new wxCommandEvent( EDA_EVT_CLOSE_ERC_DIALOG, wxID_ANY );
97
98 wxQueueEvent( m_frame, evt );
99 }
100}
101
102
104{
106 return 0;
107}
108
109
111{
112 SCH_EDIT_FRAME* frame = dynamic_cast<SCH_EDIT_FRAME*>( m_frame );
113
114 wxCHECK( frame, /* void */ );
115
116 DIALOG_ERC* dlg = frame->GetErcDialog();
117
118 wxCHECK( dlg, /* void */ );
119
120 // Needed at least on Windows. Raise() is not enough
121 dlg->Show( true );
122
123 // Bring it to the top if already open. Dual monitor users need this.
124 dlg->Raise();
125
126 if( wxButton* okButton = dynamic_cast<wxButton*>( dlg->FindWindow( wxID_OK ) ) )
127 {
128 KIPLATFORM::UI::ForceFocus( okButton );
129 okButton->SetDefault();
130 }
131}
132
133
135{
136 SCH_EDIT_FRAME* frame = dynamic_cast<SCH_EDIT_FRAME*>( m_frame );
137
138 wxCHECK( frame, 0 );
139
140 DIALOG_ERC* dlg = frame->GetErcDialog();
141
142 if( dlg )
143 {
144 dlg->Show( true );
145 dlg->Raise();
146 dlg->PrevMarker();
147 }
148
149 return 0;
150}
151
152
154{
155 SCH_EDIT_FRAME* frame = dynamic_cast<SCH_EDIT_FRAME*>( m_frame );
156
157 wxCHECK( frame, 0 );
158
159 DIALOG_ERC* dlg = frame->GetErcDialog();
160
161 wxCHECK( dlg, 0 );
162
163 dlg->Show( true );
164 dlg->Raise();
165 dlg->NextMarker();
166
167 return 0;
168}
169
170
172{
173 SCH_SELECTION_TOOL* selectionTool = m_toolMgr->GetTool<SCH_SELECTION_TOOL>();
174
175 wxCHECK( selectionTool, 0 );
176
177 SCH_SELECTION& selection = selectionTool->GetSelection();
178
179 if( selection.GetSize() == 1 && selection.Front()->Type() == SCH_MARKER_T )
180 {
181 SCH_EDIT_FRAME* frame = dynamic_cast<SCH_EDIT_FRAME*>( m_frame );
182 DIALOG_ERC* dlg = frame ? frame->GetErcDialog() : nullptr;
183
184 if( dlg && dlg->IsShownOnScreen() )
185 dlg->SelectMarker( static_cast<SCH_MARKER*>( selection.Front() ) );
186 }
187
188 // Show the item info on a left click on this item
189 UpdateMessagePanel( aEvent );
190
191 return 0;
192}
193
194
196{
197 SCH_EDIT_FRAME* frame = dynamic_cast<SCH_EDIT_FRAME*>( m_frame );
198
199 wxCHECK( frame, /* void */ );
200
201 DIALOG_ERC* dlg = frame->GetErcDialog();
202
203 if( dlg )
204 {
205 if( !dlg->IsShownOnScreen() )
206 {
207 dlg->Show( true );
208 dlg->Raise();
209 }
210
211 dlg->SelectMarker( aMarker );
212 }
213}
214
215
216wxString SCH_INSPECTION_TOOL::InspectERCErrorMenuText( const std::shared_ptr<RC_ITEM>& aERCItem )
217{
218 if( aERCItem->GetErrorCode() == ERCE_BUS_TO_NET_CONFLICT )
219 {
220 return m_frame->GetRunMenuCommandDescription( SCH_ACTIONS::showBusSyntaxHelp );
221 }
222 else if( aERCItem->GetErrorCode() == ERCE_LIB_SYMBOL_MISMATCH )
223 {
224 return m_frame->GetRunMenuCommandDescription( SCH_ACTIONS::diffSymbol );
225 }
226
227 return wxEmptyString;
228}
229
230
231void SCH_INSPECTION_TOOL::InspectERCError( const std::shared_ptr<RC_ITEM>& aERCItem )
232{
233 SCH_EDIT_FRAME* frame = dynamic_cast<SCH_EDIT_FRAME*>( m_frame );
234
235 wxCHECK( frame, /* void */ );
236
237 EDA_ITEM* a = frame->ResolveItem( aERCItem->GetMainItemID() );
238
239 if( aERCItem->GetErrorCode() == ERCE_BUS_TO_NET_CONFLICT )
240 {
242 }
243 else if( aERCItem->GetErrorCode() == ERCE_LIB_SYMBOL_MISMATCH )
244 {
245 if( SCH_SYMBOL* symbol = dynamic_cast<SCH_SYMBOL*>( a ) )
246 DiffSymbol( symbol );
247 }
248}
249
250
252{
253 SCH_SELECTION_TOOL* selTool = m_toolMgr->GetTool<SCH_SELECTION_TOOL>();
254 SCH_SELECTION& selection = selTool->GetSelection();
255 SCH_MARKER* marker = nullptr;
256
257 if( selection.GetSize() == 1 && selection.Front()->Type() == SCH_MARKER_T )
258 marker = static_cast<SCH_MARKER*>( selection.Front() );
259
260 SCH_EDIT_FRAME* frame = dynamic_cast<SCH_EDIT_FRAME*>( m_frame );
261
262 wxCHECK( frame, 0 );
263
264 DIALOG_ERC* dlg = frame->GetErcDialog();
265
266 wxCHECK( dlg, 0 );
267
268 // Let the ERC dialog handle it since it owns the marker provider's cached counts and view
269 // updates. If marker is nullptr the dialog excludes whichever marker is selected in the
270 // dialog itself.
271 dlg->ExcludeMarker( marker );
272
273 return 0;
274}
275
276
277extern void CheckLibSymbol( LIB_SYMBOL* aSymbol, std::vector<wxString>& aMessages,
278 int aGridForPins, UNITS_PROVIDER* aUnitsProvider );
279
281{
282 LIB_SYMBOL* symbol = static_cast<SYMBOL_EDIT_FRAME*>( m_frame )->GetCurSymbol();
283
284 if( !symbol )
285 return 0;
286
287 std::vector<wxString> messages;
288 const int grid_size = KiROUND( getView()->GetGAL()->GetGridSize().x );
289
290 CheckLibSymbol( symbol, messages, grid_size, m_frame );
291
292 if( messages.empty() )
293 {
294 DisplayInfoMessage( m_frame, _( "No symbol issues found." ) );
295 }
296 else
297 {
298 HTML_MESSAGE_BOX dlg( m_frame, _( "Symbol Warnings" ) );
299
300 for( const wxString& single_msg : messages )
301 dlg.AddHTML_Text( single_msg );
302
303 dlg.ShowModal();
304 }
305
306 return 0;
307}
308
309
311{
312 if( m_busSyntaxHelp )
313 {
314 m_busSyntaxHelp->Raise();
315 m_busSyntaxHelp->Show( true );
316 return 0;
317 }
318
320 return 0;
321}
322
323
325{
326 SCH_EDIT_FRAME* schEditorFrame = dynamic_cast<SCH_EDIT_FRAME*>( m_frame );
327
328 wxCHECK( schEditorFrame, 0 );
329
330 SCH_SELECTION& selection = m_selectionTool->RequestSelection( { SCH_SYMBOL_T } );
331
332 if( selection.Empty() )
333 {
334 m_frame->ShowInfoBarError( _( "Select a symbol to diff against its library equivalent." ) );
335 return 0;
336 }
337
338 DiffSymbol( static_cast<SCH_SYMBOL*>( selection.Front() ) );
339 return 0;
340}
341
342
344{
345 SCH_EDIT_FRAME* schEditorFrame = dynamic_cast<SCH_EDIT_FRAME*>( m_frame );
346
347 wxCHECK( schEditorFrame, /* void */ );
348
349 DIALOG_BOOK_REPORTER* dialog = schEditorFrame->GetSymbolDiffDialog();
350
351 wxCHECK( dialog, /* void */ );
352
353 dialog->DeleteAllPages();
354 dialog->SetUserItemID( symbol->m_Uuid );
355
356 wxString symbolDesc = wxString::Format( _( "Symbol %s" ), symbol->GetCurrentSheetRef() );
357 LIB_ID libId = symbol->GetLibId();
358 wxString libName = libId.GetLibNickname();
359 wxString symbolName = libId.GetLibItemName();
360
361 WX_HTML_REPORT_BOX* r = dialog->AddHTMLPage( _( "Summary" ) );
362
363 r->Report( wxS( "<h7>" ) + _( "Schematic vs library diff for:" ) + wxS( "</h7>" ) );
364 r->Report( wxS( "<ul><li>" ) + EscapeHTML( symbolDesc ) + wxS( "</li>" )
365 + wxS( "<li>" ) + _( "Library: " ) + EscapeHTML( libName ) + wxS( "</li>" )
366 + wxS( "<li>" ) + _( "Library item: " ) + EscapeHTML( symbolName )
367 + wxS( "</li></ul>" ) );
368
369 r->Report( "" );
370
372
373 if( !libs->HasLibrary( libName, false ) )
374 {
375 r->Report( _( "The library is not included in the current configuration." )
376 + wxS( "&nbsp;&nbsp;&nbsp" )
377 + wxS( "<a href='$CONFIG'>" ) + _( "Manage Symbol Libraries" ) + wxS( "</a>" ) );
378 }
379 else if( !libs->HasLibrary( libName, true ) )
380 {
381 r->Report( _( "The library is not enabled in the current configuration." )
382 + wxS( "&nbsp;&nbsp;&nbsp" )
383 + wxS( "<a href='$CONFIG'>" ) + _( "Manage Symbol Libraries" ) + wxS( "</a>" ) );
384 }
385 else
386 {
387 std::unique_ptr<LIB_SYMBOL> flattenedLibSymbol;
388 std::unique_ptr<LIB_SYMBOL> flattenedSchSymbol = symbol->GetLibSymbolRef()->Flatten();
389
390 try
391 {
392 if( LIB_SYMBOL* libAlias = libs->LoadSymbol( libName, symbolName ) )
393 flattenedLibSymbol = libAlias->Flatten();
394 }
395 catch( const IO_ERROR& )
396 {
397 }
398
399 if( !flattenedLibSymbol )
400 {
401 r->Report( wxString::Format( _( "The library no longer contains the item %s." ), symbolName ) );
402 }
403 else
404 {
405 std::vector<SCH_FIELD> fields;
406
407 for( SCH_FIELD& field : symbol->GetFields() )
408 {
409 fields.emplace_back( SCH_FIELD( flattenedLibSymbol.get(), field.GetId(), field.GetName( false ) ) );
410 fields.back().CopyText( field );
411 fields.back().SetAttributes( field );
412 fields.back().Move( -symbol->GetPosition() );
413 }
414
415 flattenedSchSymbol->SetFields( fields );
416
417 int flags = schEditorFrame->Schematic().Settings().SymbolCompareFlags();
418
419 if( flattenedSchSymbol->Compare( *flattenedLibSymbol, flags, r ) == 0 )
420 r->Report( _( "No relevant differences detected." ) );
421
422 wxPanel* panel = dialog->AddBlankPage( _( "Visual" ) );
423 SYMBOL_DIFF_WIDGET* diff = constructDiffPanel( panel );
424
425 diff->DisplayDiff( flattenedSchSymbol.release(), flattenedLibSymbol.release(),
426 symbol->GetUnit(), symbol->GetBodyStyle() );
427 }
428 }
429
430 r->Flush();
431
432 dialog->Raise();
433 dialog->Show( true );
434}
435
436
438{
439 wxBoxSizer* sizer = new wxBoxSizer( wxVERTICAL );
440
441 EDA_DRAW_PANEL_GAL::GAL_TYPE backend = m_frame->GetCanvas()->GetBackend();
442 SYMBOL_DIFF_WIDGET* diffWidget = new SYMBOL_DIFF_WIDGET( aParentPanel, backend );
443
444 sizer->Add( diffWidget, 1, wxEXPAND | wxALL, 5 );
445 aParentPanel->SetSizer( sizer );
446 aParentPanel->Layout();
447
448 return diffWidget;
449}
450
451
452namespace
453{
454void buildSchOverrides( const KICAD_DIFF::DOCUMENT_DIFF& aDiff, const KICAD_DIFF::DIFF_COLOR_THEME& aTheme,
455 std::map<KIID, KIGFX::COLOR4D>& aRefO, std::map<KIID, KIGFX::COLOR4D>& aCompO,
456 std::map<KIID, KICAD_DIFF::CATEGORY>& aCats )
457{
458 aRefO.clear();
459 aCompO.clear();
460 aCats.clear();
461
462 std::function<void( const KICAD_DIFF::ITEM_CHANGE& )> visit =
463 [&]( const KICAD_DIFF::ITEM_CHANGE& aChange )
464 {
465 if( !aChange.id.empty() )
466 {
467 const KIID& kiid = aChange.id.back();
468 aCats[kiid] = KICAD_DIFF::CategoryFor( aChange.kind );
469
470 switch( aChange.kind )
471 {
472 case KICAD_DIFF::CHANGE_KIND::ADDED: aCompO[kiid] = aTheme.added; break;
474 aRefO[kiid] = aTheme.removed;
475 aCompO[kiid] = aTheme.removed;
476 break;
478 aRefO[kiid] = aTheme.modified;
479 aCompO[kiid] = aTheme.modified;
480 break;
481 default:
482 aRefO[kiid] = aTheme.conflict;
483 aCompO[kiid] = aTheme.conflict;
484 break;
485 }
486 }
487
488 for( const KICAD_DIFF::ITEM_CHANGE& child : aChange.children )
489 visit( child );
490 };
491
492 for( const KICAD_DIFF::ITEM_CHANGE& change : aDiff.changes )
493 visit( change );
494}
495
496
497DIALOG_KICAD_DIFF::SHEET_SWITCHER makeSchSwitcher( SCHEMATIC* aRef, SCHEMATIC* aComp,
498 std::map<KIID, KIGFX::COLOR4D> aRefOverrides,
499 std::map<KIID, KIGFX::COLOR4D> aCompOverrides,
500 std::map<KIID, KICAD_DIFF::CATEGORY> aCategories,
501 const KICAD_DIFF::DIFF_COLOR_THEME& aTheme )
502{
503 return [aRef, aComp, modifiedColor = aTheme.modified, removedColor = aTheme.removed,
504 refO = std::move( aRefOverrides ), compO = std::move( aCompOverrides ),
505 cats = std::move( aCategories )]( WIDGET_DIFF_CANVAS& aCanvas, const KIID_PATH& aSheetPath )
506 {
507 SCH_SCREEN* compScreen = aComp->RootScreen();
508 SCH_SCREEN* refScreen = aRef->RootScreen();
509
510 if( !aSheetPath.empty() )
511 {
512 if( auto sp = aComp->Hierarchy().GetSheetPathByKIIDPath( aSheetPath, true ) )
513 compScreen = sp->LastScreen();
514
515 if( auto sp = aRef->Hierarchy().GetSheetPathByKIIDPath( aSheetPath, true ) )
516 refScreen = sp->LastScreen();
517 }
518
519 // Removed items exist only in the reference, so the canvas keeps copies of them
520 auto removed = std::make_shared<std::vector<std::unique_ptr<SCH_ITEM>>>();
521
522 if( refScreen )
523 {
524 for( const auto& [kiid, c] : refO )
525 {
526 if( c != removedColor )
527 continue;
528
529 for( SCH_ITEM* item : refScreen->Items() )
530 {
531 if( item && item->m_Uuid == kiid )
532 {
533 if( auto* clone = dynamic_cast<SCH_ITEM*>( item->Clone() ) )
534 removed->emplace_back( clone );
535
536 break;
537 }
538 }
539 }
540 }
541
542 std::vector<KIGFX::VIEW_ITEM*> extras;
543
544 for( const auto& clone : *removed )
545 extras.push_back( clone.get() );
546
547 KICAD_DIFF::ConfigureSchDiffCanvasContext( aCanvas, nullptr, aComp, modifiedColor, compO, extras, cats, nullptr,
548 compScreen, removed );
549 };
550}
551
552
553struct DRILL_FRAME
554{
555 SCH_SHEET_PATH editorPath;
556 SCHEMATIC* compSch = nullptr;
557 wxString compFile;
558 KIID_PATH compScope;
559};
560
561
562void reloadDrillFrame( DIALOG_KICAD_DIFF& aDlg, SCHEMATIC* aRefSch, const KICAD_DIFF::DIFF_COLOR_THEME& aTheme,
563 const DRILL_FRAME& aFrame )
564{
565 KICAD_DIFF::SCH_DIFFER differ( aRefSch, aFrame.compSch, aFrame.compFile );
566 const KIID_PATH scope = aFrame.editorPath.Path();
567
568 if( !scope.empty() && !aFrame.compScope.empty() )
569 differ.SetScope( scope, aFrame.compScope );
570
571 KICAD_DIFF::DOCUMENT_DIFF diff = differ.Diff();
572
573 std::map<KIID, KIGFX::COLOR4D> refO;
574 std::map<KIID, KIGFX::COLOR4D> compO;
575 std::map<KIID, KICAD_DIFF::CATEGORY> cats;
576 buildSchOverrides( diff, aTheme, refO, compO, cats );
577
578 auto switcher = makeSchSwitcher( aRefSch, aFrame.compSch, refO, compO, cats, aTheme );
579
580 SCH_SCREEN* refScreen = aFrame.editorPath.LastScreen();
581 wxString refLabel = refScreen ? refScreen->GetFileName() : wxString();
582
583 aDlg.Reload( refLabel, aFrame.compFile, std::move( diff ), /*aReferenceGeometry=*/{},
584 /*aComparisonGeometry=*/{}, std::move( switcher ), scope );
585}
586} // namespace
587
588
590{
591 SCH_EDIT_FRAME* schEditorFrame = dynamic_cast<SCH_EDIT_FRAME*>( m_frame );
592
593 wxCHECK( schEditorFrame, 0 );
594
595 wxFileDialog dlg( schEditorFrame, _( "Choose Schematic to Compare With" ), wxEmptyString,
596 wxEmptyString, FILEEXT::KiCadSchematicFileWildcard(), wxFD_OPEN | wxFD_FILE_MUST_EXIST );
597
598 if( dlg.ShowModal() != wxID_OK )
599 return 0;
600
601 wxFileName otherFn( dlg.GetPath() );
602 otherFn.MakeAbsolute();
603
604 if( !otherFn.GetExt().IsSameAs( FILEEXT::KiCadSchematicFileExtension, false ) )
605 {
606 schEditorFrame->ShowInfoBarError( _( "Select a KiCad s-expression schematic file (.kicad_sch)." ) );
607 return 0;
608 }
609
610 const wxString otherPath = otherFn.GetFullPath();
611
612 wxFileName projectFn = otherFn;
613 projectFn.SetExt( FILEEXT::ProjectFileExtension );
614 const wxString projectPath = projectFn.GetFullPath();
615
616 wxFileName activeProjectFn( schEditorFrame->Prj().GetProjectFullName() );
617 activeProjectFn.MakeAbsolute();
618
619 // Refuse the self-compare; attaching the active PROJECT to a second
620 // SCHEMATIC would clobber its ERC/schematic settings.
621 if( projectFn.SameAs( activeProjectFn ) )
622 {
623 schEditorFrame->ShowInfoBarError( _( "Select a schematic file from another project to compare." ) );
624 return 0;
625 }
626
627 return showSchematicComparison( otherPath, projectPath, otherPath );
628}
629
630
631int SCH_INSPECTION_TOOL::showSchematicComparison( const wxString& aOtherPath, const wxString& aProjectPath,
632 const wxString& aComparisonLabel )
633{
634 SCH_EDIT_FRAME* schEditorFrame = dynamic_cast<SCH_EDIT_FRAME*>( m_frame );
635
636 wxCHECK( schEditorFrame, 0 );
637
638 SETTINGS_MANAGER* mgr = schEditorFrame->GetSettingsManager();
639
640 wxCHECK( mgr, 0 );
641
642 // A missing .kicad_pro is fine (LoadProject returns false but still
643 // inserts a defaults-only slot); a present-but-malformed .kicad_pro is
644 // treated as failure.
645 bool projectLoadOk = mgr->LoadProject( aProjectPath, false );
646 PROJECT* otherPrj = mgr->GetProject( aProjectPath );
647
648 if( !otherPrj )
649 {
650 schEditorFrame->ShowInfoBarError( wxString::Format( _( "Failed to load project for %s" ), aOtherPath ) );
651 return 0;
652 }
653
654 if( !projectLoadOk && wxFileName( aProjectPath ).FileExists() )
655 {
656 mgr->UnloadProject( otherPrj, false );
657 schEditorFrame->ShowInfoBarError( wxString::Format( _( "Failed to load project for %s" ), aOtherPath ) );
658 return 0;
659 }
660
661 // SCH_DIFFER walks the sheet hierarchy and properties; connectivity build
662 // is unnecessary and slow for a read-only compare.
663 SCHEMATIC* loadedSchematic = nullptr;
664
665 try
666 {
667 loadedSchematic = EESCHEMA_HELPERS::LoadSchematic( aOtherPath,
668 /*aSetActive=*/false,
669 /*aForceDefaultProject=*/false, otherPrj,
670 /*aCalculateConnectivity=*/false );
671 }
672 catch( ... )
673 {
674 schEditorFrame->ShowInfoBarError( wxString::Format( _( "Failed to load %s" ), aOtherPath ) );
675 mgr->UnloadProject( otherPrj, false );
676 return 0;
677 }
678
679 SCHEMATIC* mySch = &schEditorFrame->Schematic();
680
681 // Belt-and-suspenders: EESCHEMA_HELPERS::LoadSchematic has a fallback
682 // branch that returns the active editor's schematic when the project
683 // happens to be the active one. The path guard above should have caught
684 // this, but a path-alias miss would leave the unique_ptr owning the live
685 // schematic and SetProject(nullptr) would destroy editor state.
686 if( loadedSchematic == mySch )
687 {
688 schEditorFrame->ShowInfoBarError( _( "Select a schematic file from another project to compare." ) );
689 mgr->UnloadProject( otherPrj, false );
690 return 0;
691 }
692
693 std::unique_ptr<SCHEMATIC> otherSchematic{ loadedSchematic };
694
695 if( !otherSchematic )
696 {
697 schEditorFrame->ShowInfoBarError( wxString::Format( _( "Failed to load %s" ), aOtherPath ) );
698 mgr->UnloadProject( otherPrj, false );
699 return 0;
700 }
701
702 KICAD_DIFF::SCH_DIFFER differ( mySch, otherSchematic.get(), aOtherPath );
703
704 // Scope to the editor's current sheet. Comparison resolves the matching
705 // sheet by KIID when present, else falls back to its root.
706 const KIID_PATH scopeBefore = schEditorFrame->GetCurrentSheet().Path();
707 const SCH_SHEET_LIST otherSheets = otherSchematic->BuildSheetListSortedByPageNumbers();
708 KIID_PATH scopeAfter;
709
710 if( auto sp = otherSchematic->Hierarchy().GetSheetPathByKIIDPath( scopeBefore, true ) )
711 scopeAfter = sp->Path();
712 else if( !otherSheets.empty() )
713 scopeAfter = otherSheets.front().Path();
714
715 if( !scopeBefore.empty() && !scopeAfter.empty() )
716 differ.SetScope( scopeBefore, scopeAfter );
717
719
721
722 std::map<KIID, KIGFX::COLOR4D> refOverrides;
723 std::map<KIID, KIGFX::COLOR4D> compOverrides;
724 std::map<KIID, KICAD_DIFF::CATEGORY> kiidCategories;
725
726 buildSchOverrides( result, theme, refOverrides, compOverrides, kiidCategories );
727
729 refOverrides );
731 theme.comparison,
732 compOverrides );
733
734 DIALOG_KICAD_DIFF::SHEET_SWITCHER initialSwitcher = makeSchSwitcher( mySch, otherSchematic.get(), refOverrides,
735 compOverrides, kiidCategories, theme );
736
737 KIID_PATH initialSheet = schEditorFrame->GetCurrentSheet().Path();
738 SCH_SCREEN* currentSheetScreen = schEditorFrame->GetCurrentSheet().LastScreen();
739 wxString referenceLabel = currentSheetScreen ? currentSheetScreen->GetFileName() : mySch->GetFileName();
740
741 DIALOG_KICAD_DIFF dlgDiff( schEditorFrame, referenceLabel, aComparisonLabel, result, std::move( refGeometry ),
742 std::move( compGeometry ), std::move( initialSwitcher ), std::move( initialSheet ) );
743
744 // Drill state owns the comparison schematics loaded across double-click
745 // drills. The editor schematic stays the reference on all drills.
746 DRILL_FRAME drillCurrent{ schEditorFrame->GetCurrentSheet(), otherSchematic.get(), aOtherPath, scopeAfter };
747
748 std::vector<DRILL_FRAME> drillBack;
749 std::vector<std::unique_ptr<SCHEMATIC>> drilledSchs;
750
751 drilledSchs.push_back( std::move( otherSchematic ) );
752
753 if( WIDGET_DIFF_CANVAS* canvas = dlgDiff.DiffCanvas() )
754 {
755 canvas->SetDoubleClickHandler(
756 [&dlgDiff, &drillCurrent, &drillBack, &drilledSchs, mySch, otherPrj, theme,
757 schEditorFrame]( KIGFX::VIEW_ITEM* aItem )
758 {
759 auto* sheet = dynamic_cast<SCH_SHEET*>( aItem );
760
761 if( !sheet )
762 return;
763
764 const wxString sheetFile = sheet->GetFileName();
765
766 if( sheetFile.IsEmpty() )
767 return;
768
769 KIID_PATH newEditorKiid = drillCurrent.editorPath.Path();
770 newEditorKiid.push_back( sheet->m_Uuid );
771
772 auto newEditorSheet = mySch->Hierarchy().GetSheetPathByKIIDPath( newEditorKiid, true );
773
774 if( !newEditorSheet )
775 return;
776
777 // Prefer resolving inside the current comparison schematic so
778 // shared-sheet instance context is preserved on both sides.
779 DRILL_FRAME next{ *newEditorSheet, drillCurrent.compSch, drillCurrent.compFile, KIID_PATH() };
780
781 if( auto compMatch = next.compSch->Hierarchy().GetSheetPathByKIIDPath( newEditorKiid, true ) )
782 {
783 next.compScope = compMatch->Path();
784
785 if( SCH_SCREEN* compMatchScreen = compMatch->LastScreen() )
786 next.compFile = compMatchScreen->GetFileName();
787 }
788 else
789 {
790 wxFileName newCompFn( sheetFile );
791 newCompFn.MakeAbsolute( wxFileName( drillCurrent.compFile ).GetPath() );
792
793 SCHEMATIC* loaded = EESCHEMA_HELPERS::LoadSchematic( newCompFn.GetFullPath(),
794 /*aSetActive*/ false,
795 /*aForceDefaultProject*/ false, otherPrj,
796 /*aCalculateConnectivity*/ false );
797
798 if( !loaded )
799 {
800 schEditorFrame->ShowInfoBarError( wxString::Format( _( "Failed to load %s" ),
801 newCompFn.GetFullPath() ) );
802 return;
803 }
804
805 const SCH_SHEET_LIST loadedSheets = loaded->BuildSheetListSortedByPageNumbers();
806
807 if( !loadedSheets.empty() )
808 next.compScope = loadedSheets.front().Path();
809
810 drilledSchs.emplace_back( loaded );
811 next.compSch = loaded;
812 next.compFile = newCompFn.GetFullPath();
813 }
814
815 reloadDrillFrame( dlgDiff, mySch, theme, next );
816
817 drillBack.push_back( drillCurrent );
818 drillCurrent = next;
819 dlgDiff.EnableUp( true );
820 } );
821
822 dlgDiff.SetUpHandler(
823 [&dlgDiff, &drillCurrent, &drillBack, mySch, theme]()
824 {
825 if( drillBack.empty() )
826 return;
827
828 reloadDrillFrame( dlgDiff, mySch, theme, drillBack.back() );
829
830 drillCurrent = drillBack.back();
831 drillBack.pop_back();
832 dlgDiff.EnableUp( !drillBack.empty() );
833 } );
834 }
835
836 dlgDiff.ShowModal();
837
838 if( WIDGET_DIFF_CANVAS* canvas = dlgDiff.DiffCanvas() )
839 canvas->SetContextItems( {} );
840
841 // Detach schematics from the project before unloading so the project's
842 // ERC and schematic settings release cleanly.
843 for( auto& sch : drilledSchs )
844 {
845 if( sch )
846 sch->SetProject( nullptr );
847 }
848
849 drilledSchs.clear();
850
851 mgr->UnloadProject( otherPrj, false );
852
853 return 0;
854}
855
856
858{
859 SCH_EDIT_FRAME* schEditorFrame = dynamic_cast<SCH_EDIT_FRAME*>( m_frame );
860
861 wxCHECK( schEditorFrame, 0 );
862
863 SCHEMATIC* mySch = &schEditorFrame->Schematic();
864
865 if( mySch->GetFileName().IsEmpty() )
866 {
867 schEditorFrame->ShowInfoBarError( _( "Save the schematic before comparing against local history." ) );
868 return 0;
869 }
870
871 const wxString projectPath = schEditorFrame->Prj().GetProjectPath();
872 LOCAL_HISTORY& history = schEditorFrame->Kiway().LocalHistory();
873
874 std::vector<LOCAL_HISTORY_SNAPSHOT_INFO> snapshots = history.GetSnapshots( projectPath );
875
876 if( snapshots.empty() )
877 {
878 schEditorFrame->ShowInfoBarError( _( "No local history snapshots for this project." ) );
879 return 0;
880 }
881
882 SETTINGS_MANAGER* mgr = schEditorFrame->GetSettingsManager();
883
884 wxCHECK( mgr, 0 );
885
886 auto relTo =
887 [&]( const wxString& aFull )
888 {
889 wxFileName fn( aFull );
890 fn.MakeRelativeTo( projectPath );
891 return fn.GetFullPath( wxPATH_UNIX );
892 };
893
894 const wxString rootRel = relTo( mySch->GetFileName() );
895 const wxString projRel = relTo( schEditorFrame->Prj().GetProjectFullName() );
896
897 // One entry per distinct schematic version: newest-first, skipping commits
898 // with no schematic or whose schematic content (any .kicad_sch sheet) matches
899 // the previously kept one. This drops board-only saves like "PCB Save".
900 std::vector<LOCAL_HISTORY_SNAPSHOT_INFO> filtered;
901 wxString prevFingerprint;
902
903 for( const LOCAL_HISTORY_SNAPSHOT_INFO& s : snapshots )
904 {
905 wxString fingerprint = history.TreeFingerprint( projectPath, s.hash, wxS( ".kicad_sch" ) );
906
907 if( fingerprint.IsEmpty() || fingerprint == prevFingerprint )
908 continue;
909
910 prevFingerprint = fingerprint;
911 filtered.push_back( s );
912 }
913
914 if( filtered.empty() )
915 {
916 schEditorFrame->ShowInfoBarError( _( "No local history snapshots change this schematic." ) );
917 return 0;
918 }
919
920 snapshots = std::move( filtered );
921
922 std::vector<wxString> labels;
923
924 for( const LOCAL_HISTORY_SNAPSHOT_INFO& s : snapshots )
925 {
926 wxString summary = s.summary.IsEmpty() ? s.message.BeforeFirst( '\n' ) : s.summary;
927 labels.push_back( wxString::Format( wxS( "%s (%s)" ), summary, s.hash.Left( 8 ) ) );
928 }
929
931 const KIID_PATH scopeBefore = schEditorFrame->GetCurrentSheet().Path();
932
933 struct SCH_DIFF_VIEW
934 {
939 KIID_PATH compScope;
940 };
941
942 auto buildView =
943 [&]( SCHEMATIC* aComp, const wxString& aPath ) -> SCH_DIFF_VIEW
944 {
945 SCH_DIFF_VIEW view;
946 KICAD_DIFF::SCH_DIFFER differ( mySch, aComp, aPath );
947
948 KIID_PATH scopeAfter;
949
950 if( std::optional<SCH_SHEET_PATH> sp = aComp->Hierarchy().GetSheetPathByKIIDPath( scopeBefore, true ) )
951 {
952 scopeAfter = sp->Path();
953 }
954 else
955 {
957
958 if( !sheets.empty() )
959 scopeAfter = sheets.front().Path();
960 }
961
962 if( !scopeBefore.empty() && !scopeAfter.empty() )
963 differ.SetScope( scopeBefore, scopeAfter );
964
965 view.compScope = scopeAfter;
966 view.result = differ.Diff();
967
968 std::map<KIID, KIGFX::COLOR4D> refO;
969 std::map<KIID, KIGFX::COLOR4D> compO;
970 std::map<KIID, KICAD_DIFF::CATEGORY> cats;
971 buildSchOverrides( view.result, theme, refO, compO, cats );
972
973 view.refGeom = KICAD_DIFF::ExtractSchematicGeometry( *mySch, theme.reference, refO );
974 view.compGeom = KICAD_DIFF::ExtractSchematicGeometry( *aComp, theme.comparison, compO );
975 view.switcher = makeSchSwitcher( mySch, aComp, refO, compO, cats, theme );
976
977 return view;
978 };
979
980 // State for the revision currently shown. Swapped on each dropdown change.
981 std::unique_ptr<SCHEMATIC> curSch;
982 PROJECT* curPrj = nullptr;
983 wxString curTempDir;
984
985 // Drill state: which comparison sheet is shown and sub-schematics loaded on
986 // double-click. Reset when the revision changes.
987 DRILL_FRAME drillCurrent;
988 std::vector<DRILL_FRAME> drillBack;
989 std::vector<std::unique_ptr<SCHEMATIC>> drilledSchs;
990
991 auto cleanupCurrent =
992 [&]()
993 {
994 for( std::unique_ptr<SCHEMATIC>& sch : drilledSchs )
995 {
996 if( sch )
997 sch->SetProject( nullptr );
998 }
999
1000 drilledSchs.clear();
1001
1002 if( curSch )
1003 {
1004 curSch->SetProject( nullptr );
1005 curSch.reset();
1006 }
1007
1008 // Skip if the project was already evicted from the manager.
1009 if( curPrj && mgr->IsProjectLoaded( curPrj ) )
1010 mgr->UnloadProject( curPrj, false );
1011
1012 curPrj = nullptr;
1013
1014 if( !curTempDir.IsEmpty() )
1015 {
1016 wxFileName::Rmdir( curTempDir, wxPATH_RMDIR_RECURSIVE );
1017 curTempDir.Clear();
1018 }
1019 };
1020
1021 // Extract the hierarchy at snapshot aIndex and load its root sheet, cleaning
1022 // up the temp dir on any failure.
1023 auto loadRevision =
1024 [&]( int aIndex, std::unique_ptr<SCHEMATIC>& aSch, PROJECT*& aPrj, wxString& aTempDir ) -> bool
1025 {
1026 const wxString hash = snapshots[aIndex].hash;
1027 wxFileName dirFn;
1028 dirFn.AssignDir( wxFileName::GetTempDir() );
1029 dirFn.AppendDir( wxS( "kicad-history-" ) + hash.Left( 8 ) );
1030 const wxString tempDir = dirFn.GetPath();
1031
1032 // Extract just the schematic sheets and project file, skipping the
1033 // board, 3D models, gerbers, etc.
1034 if( !history.ExtractAllFilesAtCommit( projectPath, hash, tempDir,
1035 { wxS( ".kicad_sch" ), wxS( ".kicad_pro" ) } ) )
1036 {
1037 wxFileName::Rmdir( tempDir, wxPATH_RMDIR_RECURSIVE );
1038 return false;
1039 }
1040
1041 const wxString root = tempDir + wxS( "/" ) + rootRel;
1042 const wxString proj = tempDir + wxS( "/" ) + projRel;
1043
1044 mgr->LoadProject( proj, false );
1045 PROJECT* prj = mgr->GetProject( proj );
1046
1047 if( !prj )
1048 {
1049 wxFileName::Rmdir( tempDir, wxPATH_RMDIR_RECURSIVE );
1050 return false;
1051 }
1052
1053 SCHEMATIC* loaded = nullptr;
1054
1055 try
1056 {
1057 loaded = EESCHEMA_HELPERS::LoadSchematic( root, /*aSetActive*/ false,
1058 /*aForceDefaultProject*/ false, prj,
1059 /*aCalculateConnectivity*/ false );
1060 }
1061 catch( ... )
1062 {
1063 mgr->UnloadProject( prj, false );
1064 wxFileName::Rmdir( tempDir, wxPATH_RMDIR_RECURSIVE );
1065 return false;
1066 }
1067
1068 if( !loaded || loaded == mySch )
1069 {
1070 mgr->UnloadProject( prj, false );
1071 wxFileName::Rmdir( tempDir, wxPATH_RMDIR_RECURSIVE );
1072 return false;
1073 }
1074
1075 aSch.reset( loaded );
1076 aPrj = prj;
1077 aTempDir = tempDir;
1078 return true;
1079 };
1080
1081 auto loadView =
1082 [&]( int aIndex, std::unique_ptr<SCHEMATIC>& aSch, PROJECT*& aPrj, wxString& aTempDir,
1083 SCH_DIFF_VIEW& aView ) -> bool
1084 {
1085 if( !loadRevision( aIndex, aSch, aPrj, aTempDir ) )
1086 return false;
1087
1088 try
1089 {
1090 aView = buildView( aSch.get(), aTempDir + wxS( "/" ) + rootRel );
1091 }
1092 catch( ... )
1093 {
1094 aSch->SetProject( nullptr );
1095 aSch.reset();
1096 mgr->UnloadProject( aPrj, false );
1097 aPrj = nullptr;
1098 wxFileName::Rmdir( aTempDir, wxPATH_RMDIR_RECURSIVE );
1099 aTempDir.Clear();
1100 return false;
1101 }
1102
1103 return true;
1104 };
1105
1106 SCH_DIFF_VIEW view;
1107 int startIndex = 0;
1108
1109 if( !loadView( 0, curSch, curPrj, curTempDir, view ) )
1110 {
1111 schEditorFrame->ShowInfoBarError( _( "Could not compare against the selected snapshot." ) );
1112 return 0;
1113 }
1114
1115 // Default to the first commit back from HEAD that actually differs from the
1116 // current schematic, so opening lands on real changes rather than an in-sync HEAD.
1117 while( view.result.Empty() && startIndex + 1 < static_cast<int>( snapshots.size() ) )
1118 {
1119 std::unique_ptr<SCHEMATIC> nextSch;
1120 PROJECT* nextPrj = nullptr;
1121 wxString nextTempDir;
1122 SCH_DIFF_VIEW nextView;
1123
1124 if( !loadView( startIndex + 1, nextSch, nextPrj, nextTempDir, nextView ) )
1125 break;
1126
1127 cleanupCurrent();
1128 view = std::move( nextView );
1129 curSch = std::move( nextSch );
1130 curPrj = nextPrj;
1131 curTempDir = nextTempDir;
1132 startIndex++;
1133 }
1134
1135 drillCurrent = { schEditorFrame->GetCurrentSheet(), curSch.get(), curTempDir + wxS( "/" ) + rootRel,
1136 view.compScope };
1137
1138 int shownIndex = startIndex;
1139
1140 SCH_SCREEN* curScreen = schEditorFrame->GetCurrentSheet().LastScreen();
1141 wxString referenceLabel = curScreen ? curScreen->GetFileName() : mySch->GetFileName();
1142
1143 std::unique_ptr<DIALOG_KICAD_DIFF> dlgDiff = std::make_unique<DIALOG_KICAD_DIFF>( schEditorFrame, referenceLabel,
1144 labels[startIndex], view.result,
1145 view.refGeom, view.compGeom,
1146 view.switcher, scopeBefore );
1147
1148 // Double-click a sheet to drill into its sub-schematic, within the current
1149 // revision's extracted hierarchy.
1150 if( WIDGET_DIFF_CANVAS* canvas = dlgDiff->DiffCanvas() )
1151 {
1152 canvas->SetDoubleClickHandler(
1153 [&]( KIGFX::VIEW_ITEM* aItem )
1154 {
1155 SCH_SHEET* sheet = dynamic_cast<SCH_SHEET*>( aItem );
1156
1157 if( !sheet || sheet->GetFileName().IsEmpty() )
1158 return;
1159
1160 KIID_PATH newEditorKiid = drillCurrent.editorPath.Path();
1161 newEditorKiid.push_back( sheet->m_Uuid );
1162
1163 auto newEditorSheet = mySch->Hierarchy().GetSheetPathByKIIDPath( newEditorKiid, true );
1164
1165 if( !newEditorSheet )
1166 return;
1167
1168 DRILL_FRAME next{ *newEditorSheet, drillCurrent.compSch, drillCurrent.compFile, KIID_PATH() };
1169
1170 if( auto compMatch = next.compSch->Hierarchy().GetSheetPathByKIIDPath( newEditorKiid, true ) )
1171 {
1172 next.compScope = compMatch->Path();
1173
1174 if( SCH_SCREEN* matchScreen = compMatch->LastScreen() )
1175 next.compFile = matchScreen->GetFileName();
1176 }
1177 else
1178 {
1179 wxFileName subFn( sheet->GetFileName() );
1180 subFn.MakeAbsolute( wxFileName( drillCurrent.compFile ).GetPath() );
1181
1182 SCHEMATIC* loaded = nullptr;
1183
1184 try
1185 {
1186 loaded = EESCHEMA_HELPERS::LoadSchematic( subFn.GetFullPath(), /*aSetActive=*/false,
1187 /*aForceDefaultProject=*/false, curPrj,
1188 /*aCalculateConnectivity=*/false );
1189 }
1190 catch( ... )
1191 {
1192 loaded = nullptr;
1193 }
1194
1195 if( !loaded || loaded == mySch )
1196 {
1197 schEditorFrame->ShowInfoBarError( wxString::Format( _( "Failed to load %s" ),
1198 subFn.GetFullPath() ) );
1199 return;
1200 }
1201
1202 SCH_SHEET_LIST loadedSheets = loaded->BuildSheetListSortedByPageNumbers();
1203
1204 if( !loadedSheets.empty() )
1205 next.compScope = loadedSheets.front().Path();
1206
1207 drilledSchs.emplace_back( loaded );
1208 next.compSch = loaded;
1209 next.compFile = subFn.GetFullPath();
1210 }
1211
1212 try
1213 {
1214 reloadDrillFrame( *dlgDiff, mySch, theme, next );
1215 }
1216 catch( ... )
1217 {
1218 schEditorFrame->ShowInfoBarError( _( "Could not open this sheet for comparison." ) );
1219 return;
1220 }
1221
1222 drillBack.push_back( drillCurrent );
1223 drillCurrent = next;
1224 dlgDiff->EnableUp( true );
1225 } );
1226
1227 dlgDiff->SetUpHandler(
1228 [&]()
1229 {
1230 if( drillBack.empty() )
1231 return;
1232
1233 try
1234 {
1235 reloadDrillFrame( *dlgDiff, mySch, theme, drillBack.back() );
1236 }
1237 catch( ... )
1238 {
1239 schEditorFrame->ShowInfoBarError( _( "Could not open this sheet for comparison." ) );
1240 return;
1241 }
1242
1243 drillCurrent = drillBack.back();
1244 drillBack.pop_back();
1245 dlgDiff->EnableUp( !drillBack.empty() );
1246 } );
1247 }
1248
1249 dlgDiff->SetRevisionChooser(
1250 labels, startIndex,
1251 [&]( int aIndex )
1252 {
1253 if( aIndex == shownIndex )
1254 return;
1255
1256 std::unique_ptr<SCHEMATIC> newSch;
1257 PROJECT* newPrj = nullptr;
1258 wxString newTempDir;
1259 SCH_DIFF_VIEW newView;
1260
1261 if( !loadView( aIndex, newSch, newPrj, newTempDir, newView ) )
1262 {
1263 schEditorFrame->ShowInfoBarError( _( "Could not compare against the selected snapshot." ) );
1264 return;
1265 }
1266
1267 dlgDiff->Reload( referenceLabel, labels[aIndex], newView.result, newView.refGeom,
1268 newView.compGeom, newView.switcher, scopeBefore );
1269
1270 cleanupCurrent();
1271 view = std::move( newView );
1272 curSch = std::move( newSch );
1273 curPrj = newPrj;
1274 curTempDir = newTempDir;
1275 shownIndex = aIndex;
1276
1277 // Restart drilling from the new revision's root.
1278 drillBack.clear();
1279 drillCurrent = { schEditorFrame->GetCurrentSheet(), curSch.get(), curTempDir + wxS( "/" ) + rootRel,
1280 view.compScope };
1281 dlgDiff->EnableUp( false );
1282 } );
1283
1284 dlgDiff->ShowModal();
1285
1286 // Destroy the dialog before the schematics it references are freed.
1287 dlgDiff.reset();
1288
1289 cleanupCurrent();
1290 return 0;
1291}
1292
1293
1295{
1296 SIMULATOR_FRAME* simFrame = (SIMULATOR_FRAME*) m_frame->Kiway().Player( FRAME_SIMULATOR, true );
1297
1298 if( !simFrame )
1299 return -1;
1300
1301 if( wxWindow* blocking_win = simFrame->Kiway().GetBlockingDialog() )
1302 blocking_win->Close( true );
1303
1304 simFrame->Show( true );
1305
1306 // On Windows, Raise() does not bring the window on screen, when iconized
1307 if( simFrame->IsIconized() )
1308 simFrame->Iconize( false );
1309
1310 simFrame->Raise();
1311
1312 return 0;
1313}
1314
1315
1317{
1318 wxString datasheet;
1319 std::vector<EMBEDDED_FILES*> filesStack;
1320
1321 if( m_frame->IsType( FRAME_SCH_SYMBOL_EDITOR ) )
1322 {
1323 LIB_SYMBOL* symbol = static_cast<SYMBOL_EDIT_FRAME*>( m_frame )->GetCurSymbol();
1324
1325 if( !symbol )
1326 return 0;
1327
1328 datasheet = symbol->GetDatasheetField().GetText();
1329
1330 symbol->AppendParentEmbeddedFiles( filesStack );
1331 filesStack.push_back( symbol );
1332 }
1333 else if( m_frame->IsType( FRAME_SCH_VIEWER ) )
1334 {
1335 LIB_SYMBOL* entry = static_cast<SYMBOL_VIEWER_FRAME*>( m_frame )->GetSelectedSymbol();
1336
1337 if( !entry )
1338 return 0;
1339
1340 datasheet = entry->GetDatasheetField().GetText();
1341
1342 entry->AppendParentEmbeddedFiles( filesStack );
1343 filesStack.push_back( entry );
1344 }
1345 else if( m_frame->IsType( FRAME_SCH ) )
1346 {
1347 SCH_SELECTION& selection = m_selectionTool->RequestSelection( { SCH_SYMBOL_T } );
1348
1349 if( selection.Empty() )
1350 return 0;
1351
1352 SCH_SYMBOL* symbol = (SCH_SYMBOL*) selection.Front();
1353 SCH_FIELD* field = symbol->GetField( FIELD_T::DATASHEET );
1354
1355 // Use GetShownText() to resolve any text variables
1356 datasheet = field->GetShownText( &symbol->Schematic()->CurrentSheet(), FOR_GUI );
1357
1358 filesStack.push_back( symbol->Schematic() );
1359
1360 if( symbol->GetLibSymbolRef() )
1361 symbol->GetLibSymbolRef()->AppendParentEmbeddedFiles( filesStack );
1362
1363 if( symbol->GetEmbeddedFiles() )
1364 filesStack.push_back( symbol->GetEmbeddedFiles() );
1365 }
1366
1367 if( datasheet.IsEmpty() || datasheet == wxS( "~" ) )
1368 {
1369 m_frame->ShowInfoBarError( _( "No datasheet defined." ) );
1370 }
1371 else
1372 {
1374 filesStack );
1375 }
1376
1377 return 0;
1378}
1379
1380
1382{
1383 SYMBOL_EDIT_FRAME* symbolEditFrame = dynamic_cast<SYMBOL_EDIT_FRAME*>( m_frame );
1384 SCH_EDIT_FRAME* schEditFrame = dynamic_cast<SCH_EDIT_FRAME*>( m_frame );
1385 SCH_SELECTION_TOOL* selTool = m_toolMgr->GetTool<SCH_SELECTION_TOOL>();
1386 SCH_SELECTION& selection = selTool->GetSelection();
1387
1388 // Note: the symbol viewer manages its own message panel
1389
1390 if( symbolEditFrame || schEditFrame )
1391 {
1392 if( selection.GetSize() == 1 )
1393 {
1394 EDA_ITEM* item = (EDA_ITEM*) selection.Front();
1395 std::vector<MSG_PANEL_ITEM> msgItems;
1396
1397 if( std::optional<wxString> uuid = GetMsgPanelDisplayUuid( item->m_Uuid ) )
1398 msgItems.emplace_back( _( "UUID" ), *uuid );
1399
1400 item->GetMsgPanelInfo( m_frame, msgItems );
1401 m_frame->SetMsgPanel( msgItems );
1402 }
1403 else
1404 {
1405 m_frame->ClearMsgPanel();
1406 }
1407 }
1408
1409 if( schEditFrame )
1410 {
1411 schEditFrame->UpdateNetHighlightStatus();
1412 schEditFrame->UpdateHierarchySelection();
1413 }
1414
1415 return 0;
1416}
1417
1418
1420{
1424 // See note 1:
1428
1435
1437
1438 // Note 1: tUpdateMessagePanel is called by CrossProbe. So uncomment this line if
1439 // call to CrossProbe is modifiied
1440 // Go( &SCH_INSPECTION_TOOL::UpdateMessagePanel, EVENTS::SelectedEvent );
1444}
1445
constexpr BOX2I KiROUND(const BOX2D &aBoxD)
Definition box2.h:985
static TOOL_ACTION excludeMarker
Definition actions.h:126
static TOOL_ACTION nextMarker
Definition actions.h:125
static TOOL_ACTION showDatasheet
Definition actions.h:265
static TOOL_ACTION prevMarker
Definition actions.h:124
void AddItem(const TOOL_ACTION &aAction, const SELECTION_CONDITION &aCondition, int aOrder=ANY_ORDER)
Add a menu entry to run a TOOL_ACTION on selected items.
wxPanel * AddBlankPage(const wxString &aTitle)
WX_HTML_REPORT_BOX * AddHTMLPage(const wxString &aTitle)
void SetUserItemID(const KIID &aID)
void ExcludeMarker(SCH_MARKER *aMarker=nullptr)
Exclude aMarker from the ERC list.
void SelectMarker(const SCH_MARKER *aMarker)
void PrevMarker()
void NextMarker()
File-compare dialog (Phase 7).
void SetUpHandler(UP_HANDLER aHandler)
std::function< void(WIDGET_DIFF_CANVAS &, const KIID_PATH &)> SHEET_SWITCHER
WIDGET_DIFF_CANVAS * DiffCanvas() const
void EnableUp(bool aEnable)
void Reload(const wxString &aReferencePath, const wxString &aComparisonPath, KICAD_DIFF::DOCUMENT_DIFF aDiff, KICAD_DIFF::DOCUMENT_GEOMETRY aReferenceGeometry, KICAD_DIFF::DOCUMENT_GEOMETRY aComparisonGeometry, SHEET_SWITCHER aSheetSwitcher, KIID_PATH aInitialSheet)
Swap in a fresh diff with new schematics.
bool Show(bool show) override
int ShowModal() override
SETTINGS_MANAGER * GetSettingsManager() const
void ShowInfoBarError(const wxString &aErrorMsg, bool aShowCloseButton=false, INFOBAR_MESSAGE_TYPE aType=INFOBAR_MESSAGE_TYPE::GENERIC)
Show the WX_INFOBAR displayed on the top of the canvas with a message and an error icon on the left o...
A base class for most all the KiCad significant classes used in schematics and boards.
Definition eda_item.h:98
const KIID m_Uuid
Definition eda_item.h:599
KICAD_T Type() const
Returns the type of object.
Definition eda_item.h:110
virtual void GetMsgPanelInfo(EDA_DRAW_FRAME *aFrame, std::vector< MSG_PANEL_ITEM > &aList)
Populate aList of MSG_PANEL_ITEM objects with it's internal state for display purposes.
Definition eda_item.h:296
static SCHEMATIC * LoadSchematic(const wxString &aFileName, bool aSetActive, bool aForceDefaultProject, PROJECT *aProject=nullptr, bool aCalculateConnectivity=true, REPORTER *aRootReporter=nullptr)
static const TOOL_EVENT ClearedEvent
Definition actions.h:349
static const TOOL_EVENT SelectedEvent
Definition actions.h:347
static const TOOL_EVENT SelectedItemsModified
Selected item had a property changed (except movement)
Definition actions.h:354
static const TOOL_EVENT PointSelectedEvent
Definition actions.h:346
static const TOOL_EVENT UnselectedEvent
Definition actions.h:348
void AddHTML_Text(const wxString &message)
Add HTML text (without any change) to message list.
Hold an error message and may be used when throwing exceptions containing meaningful error messages.
Diff two already-parsed SCHEMATICs and produce a DOCUMENT_DIFF.
Definition sch_differ.h:55
void SetScope(const KIID_PATH &aBeforeScope, const KIID_PATH &aAfterScope)
Restrict the diff to one sheet on each side.
DOCUMENT_DIFF Diff() override
Produce a DOCUMENT_DIFF of the inputs the concrete differ was constructed with.
An abstract base class for deriving all objects that can be added to a VIEW.
Definition view_item.h:82
Definition kiid.h:46
PROJECT & Prj() const
Return a reference to the PROJECT associated with this KIWAY.
KIWAY & Kiway() const
Return a reference to the KIWAY that this object has an opportunity to participate in.
wxWindow * GetBlockingDialog()
Gets the window pointer to the blocking dialog (to send it signals)
Definition kiway.cpp:705
LOCAL_HISTORY & LocalHistory()
Return the LOCAL_HISTORY associated with this KIWAY.
Definition kiway.h:460
bool HasLibrary(const wxString &aNickname, bool aCheckEnabled=false) const
Test for the existence of aNickname in the library tables.
A logical library item identifier and consists of various portions much like a URI.
Definition lib_id.h:45
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
SCH_FIELD & GetDatasheetField()
Definition lib_symbol.h:461
void AppendParentEmbeddedFiles(std::vector< EMBEDDED_FILES * > &aStack) const
std::unique_ptr< LIB_SYMBOL > Flatten() const
Return a flattened symbol inheritance to the caller.
Simple local history manager built on libgit2.
std::vector< LOCAL_HISTORY_SNAPSHOT_INFO > GetSnapshots(const wxString &aProjectPath)
Snapshots (commits) for the project, newest first.
wxString TreeFingerprint(const wxString &aProjectPath, const wxString &aHash, const wxString &aExtension)
Fingerprint of all files ending in aExtension recorded by commit aHash (sorted path:blob pairs).
bool ExtractAllFilesAtCommit(const wxString &aProjectPath, const wxString &aHash, const wxString &aDestDir, const std::vector< wxString > &aExtensions={})
Write files recorded at aHash into aDestDir, recreating the project's relative folder structure.
static SYMBOL_LIBRARY_ADAPTER * SymbolLibAdapter(PROJECT *aProject)
Accessor for project symbol library manager adapter.
static SEARCH_STACK * SchSearchS(PROJECT *aProject)
Accessor for Eeschema search stack.
Container for project specific data.
Definition project.h:63
virtual const wxString GetProjectFullName() const
Return the full path and name of the project.
Definition project.cpp:271
virtual const wxString GetProjectPath() const
Return the full path of the project.
Definition project.cpp:277
Holds all the data relating to one schematic.
Definition schematic.h:155
SCH_SHEET_LIST BuildSheetListSortedByPageNumbers() const
wxString GetFileName() const
Helper to retrieve the filename from the root sheet screen.
SCHEMATIC_SETTINGS & Settings() const
SCH_SHEET_LIST Hierarchy() const
Return the full schematic flattened hierarchical sheet list.
SCH_SCREEN * RootScreen() const
Helper to retrieve the screen of the root sheet.
SCH_SHEET_PATH & CurrentSheet() const
Definition schematic.h:399
static TOOL_ACTION compareSchematicWithHistory
static TOOL_ACTION showBusSyntaxHelp
static TOOL_ACTION checkSymbol
static TOOL_ACTION compareSchematicWithFile
static TOOL_ACTION showSimulator
static TOOL_ACTION runERC
Inspection and Editing.
static TOOL_ACTION diffSymbol
A shim class between EDA_DRAW_FRAME and several derived classes: SYMBOL_EDIT_FRAME,...
static SELECTION_CONDITION SingleSymbol
static SELECTION_CONDITION SingleNonExcludedMarker
Schematic editor (Eeschema) main window.
void UpdateHierarchySelection()
Update the hierarchy navigation tree selection (cross-probe from schematic to hierarchy pane).
SCH_SHEET_PATH & GetCurrentSheet() const
SCHEMATIC & Schematic() const
DIALOG_BOOK_REPORTER * GetSymbolDiffDialog()
void UpdateNetHighlightStatus()
virtual const wxString & GetText() const override
Return the string associated with the text object.
Definition sch_field.h:139
wxString GetShownText(const SCH_SHEET_PATH *aPath, RESOLUTION_CONTEXT aContext, const wxString &aVariantName=wxEmptyString, int aDepth=0) const
int CompareSchematicWithHistory(const TOOL_EVENT &aEvent)
Diff the current schematic against the most recent local-history commit.
void InspectERCError(const std::shared_ptr< RC_ITEM > &aERCItem)
bool Init() override
Init() is called once upon a registration of the tool.
SYMBOL_DIFF_WIDGET * constructDiffPanel(wxPanel *aParentPanel)
int NextMarker(const TOOL_EVENT &aEvent)
int DiffSymbol(const TOOL_EVENT &aEvent)
int RunERC(const TOOL_EVENT &aEvent)
HTML_MESSAGE_BOX * m_busSyntaxHelp
int RunSimulation(const TOOL_EVENT &aEvent)
int ShowDatasheet(const TOOL_EVENT &aEvent)
wxString InspectERCErrorMenuText(const std::shared_ptr< RC_ITEM > &aERCItem)
int ExcludeMarker(const TOOL_EVENT &aEvent)
int CheckSymbol(const TOOL_EVENT &aEvent)
void setTransitions() override
This method is meant to be overridden in order to specify handlers for events.
int UpdateMessagePanel(const TOOL_EVENT &aEvent)
Display the selected item info (when clicking on a item)
int PrevMarker(const TOOL_EVENT &aEvent)
int showSchematicComparison(const wxString &aOtherPath, const wxString &aProjectPath, const wxString &aComparisonLabel)
Diff the schematic at aOtherPath against the live one and show the dialog.
int CompareSchematicWithFile(const TOOL_EVENT &aEvent)
Diff the current schematic against a user-selected .kicad_sch file.
int CrossProbe(const TOOL_EVENT &aEvent)
Called when clicking on a item:
int ShowBusSyntaxHelp(const TOOL_EVENT &aEvent)
void Reset(RESET_REASON aReason) override
Bring the tool to a known, initial state.
Base class for any item which can be embedded within the SCHEMATIC container class,...
Definition sch_item.h:170
SCHEMATIC * Schematic() const
Search the item hierarchy to find a SCHEMATIC.
Definition sch_item.cpp:302
int GetBodyStyle() const
Definition sch_item.h:253
int GetUnit() const
Definition sch_item.h:243
EE_RTREE & Items()
Get the full RTree, usually for iterating.
Definition sch_screen.h:122
const wxString & GetFileName() const
Definition sch_screen.h:157
SCH_SELECTION & GetSelection()
A container for handling SCH_SHEET_PATH objects in a flattened hierarchy.
std::optional< SCH_SHEET_PATH > GetSheetPathByKIIDPath(const KIID_PATH &aPath, bool aIncludeLastSheet=true) const
Finds a SCH_SHEET_PATH that matches the provided KIID_PATH.
KIID_PATH Path() const
Get the sheet path as an KIID_PATH.
SCH_SCREEN * LastScreen()
Sheet symbol placed in a schematic, and is the entry point for a sub schematic.
Definition sch_sheet.h:50
wxString GetFileName() const
Return the filename corresponding to this sheet.
Definition sch_sheet.h:428
Schematic symbol object.
Definition sch_symbol.h:76
EMBEDDED_FILES * GetEmbeddedFiles() override
SCH_SYMBOLs don't currently support embedded files, but their LIB_SYMBOL counterparts do.
wxString GetCurrentSheetRef() const
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
std::unique_ptr< LIB_SYMBOL > & GetLibSymbolRef()
Definition sch_symbol.h:185
SCH_FIELD * GetField(FIELD_T aFieldType)
Return a mandatory field in this symbol.
static HTML_MESSAGE_BOX * ShowSyntaxHelp(wxWindow *aParentWindow)
bool Init() override
Init() is called once upon a registration of the tool.
void Reset(RESET_REASON aReason) override
Bring the tool to a known, initial state.
SCH_TOOL_BASE(const std::string &aName)
SCH_SELECTION_TOOL * m_selectionTool
static bool Idle(const SELECTION &aSelection)
Test if there no items selected or being edited.
virtual unsigned int GetSize() const override
Return the number of stored items.
Definition selection.h:104
EDA_ITEM * Front() const
Definition selection.h:176
bool Empty() const
Checks if there is anything selected.
Definition selection.h:114
bool IsProjectLoaded(PROJECT *aProject) const
True if aProject is still owned by the manager.
PROJECT * GetProject(const wxString &aFullPath) const
Retrieve a loaded project by name.
bool UnloadProject(PROJECT *aProject, bool aSave=true)
Save, unload and unregister the given PROJECT.
bool LoadProject(const wxString &aFullPath, bool aSetActive=true, bool aOverrideLock=false)
Load a project or sets up a new project with a specified path.
The SIMULATOR_FRAME holds the main user-interface for running simulations.
void DisplayDiff(LIB_SYMBOL *aSchSymbol, LIB_SYMBOL *aLibSymbol, int aUnit, int aBodyStyle)
Set the currently displayed symbol.
The symbol library editor main window.
An interface to the global shared library manager that is schematic-specific and linked to one projec...
LIB_SYMBOL * LoadSymbol(const wxString &aNickname, const wxString &aName)
Load a LIB_SYMBOL having aName from the library given by aNickname.
Symbol library viewer main window.
KIGFX::VIEW * getView() const
Definition tool_base.cpp:34
@ SHUTDOWN
Tool is being shut down.
Definition tool_base.h:80
Generic, UI-independent tool event.
Definition tool_event.h:167
void Go(int(SCH_BASE_FRAME::*aStateFunc)(const TOOL_EVENT &), const TOOL_EVENT_LIST &aConditions=TOOL_EVENT(TC_ANY, TA_ANY))
GAL-backed canvas for visualizing a KICAD_DIFF::DIFF_SCENE.
A slimmed down version of WX_HTML_REPORT_PANEL.
REPORTER & Report(const wxString &aText, SEVERITY aSeverity=RPT_SEVERITY_UNDEFINED) override
Report a string with a given severity.
void Flush()
Build the HTML messages page.
@ FOR_GUI
Definition common.h:93
void DisplayInfoMessage(wxWindow *aParent, const wxString &aMessage, const wxString &aExtraInfo)
Display an informational message box with aMessage.
Definition confirm.cpp:245
This file is part of the common library.
#define _(s)
bool GetAssociatedDocument(wxWindow *aParent, const wxString &aDocName, PROJECT *aProject, SEARCH_STACK *aPaths, std::vector< EMBEDDED_FILES * > aFilesStack)
Open a document (file) with the suitable browser.
Definition eda_doc.cpp:59
This file is part of the common library.
@ ERCE_BUS_TO_NET_CONFLICT
A bus wire is graphically connected to a net port/pin (or vice versa).
@ ERCE_LIB_SYMBOL_MISMATCH
Symbol doesn't match copy in library.
@ FRAME_SCH_SYMBOL_EDITOR
Definition frame_type.h:31
@ FRAME_SCH_VIEWER
Definition frame_type.h:32
@ FRAME_SCH
Definition frame_type.h:30
@ FRAME_SIMULATOR
Definition frame_type.h:34
static const std::string ProjectFileExtension
static const std::string KiCadSchematicFileExtension
static wxString KiCadSchematicFileWildcard()
std::optional< wxString > GetMsgPanelDisplayUuid(const KIID &aKiid)
Get a formatted UUID string for display in the message panel, according to the current advanced confi...
Definition msgpanel.cpp:216
void ConfigureSchDiffCanvasContext(WIDGET_DIFF_CANVAS &aCanvas, SCHEMATIC *aReference, SCHEMATIC *aComparison, const KIGFX::COLOR4D &aColor, const std::map< KIID, KIGFX::COLOR4D > &aOverrides, const std::vector< KIGFX::VIEW_ITEM * > &aExtraItems, const std::map< KIID, KICAD_DIFF::CATEGORY > &aCategories, SCH_SCREEN *aReferenceScreen, SCH_SCREEN *aComparisonScreen, std::shared_ptr< const void > aOwner)
DOCUMENT_GEOMETRY ExtractSchematicGeometry(const SCHEMATIC &aSchematic, const KIGFX::COLOR4D &aColor, const std::map< KIID, KIGFX::COLOR4D > &aOverrides, bool aOnlyOverrides)
Extract a coarse outline of a SCHEMATIC into a DOCUMENT_GEOMETRY for use as background context in DIF...
CATEGORY CategoryFor(CHANGE_KIND aKind)
Map a CHANGE_KIND to the visual category it belongs to.
void ForceFocus(wxWindow *aWindow)
Pass the current focus to the window.
Definition wxgtk/ui.cpp:211
CITER next(CITER it)
Definition ptree.cpp:120
void CheckLibSymbol(LIB_SYMBOL *aSymbol, std::vector< wxString > &aMessages, int aGridForPins, UNITS_PROVIDER *aUnitsProvider)
Check a library symbol to find incorrect settings.
wxString EscapeHTML(const wxString &aString)
Return a new wxString escaped for embedding in HTML.
Diff colors with defaults for light backgrounds.
Definition diff_scene.h:278
KIGFX::COLOR4D reference
Default color for source-document context geometry.
Definition diff_scene.h:292
The full set of changes between two parsed documents of one type.
std::vector< ITEM_CHANGE > changes
Aggregate of background geometry extracted from one source document.
Definition diff_scene.h:163
One change record on a single item.
std::vector< ITEM_CHANGE > children
void CheckLibSymbol(LIB_SYMBOL *aSymbol, std::vector< wxString > &aMessages, int aGridForPins, UNITS_PROVIDER *aUnitsProvider)
Check a library symbol to find incorrect settings.
@ DATASHEET
name of datasheet
wxString result
Test unit parsing edge cases and error handling.
@ SCH_SYMBOL_T
Definition typeinfo.h:168
@ SCH_MARKER_T
Definition typeinfo.h:154
Definition of file extensions used in Kicad.