KiCad PCB EDA Suite
Loading...
Searching...
No Matches
sch_editor_control.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 (C) 1992-2024 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, you may find one here:
19 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
20 * or you may search the http://www.gnu.org website for the version 2 license,
21 * or you may write to the Free Software Foundation, Inc.,
22 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
23 */
24
25#include <symbol_library.h>
26#include <confirm.h>
27#include <connection_graph.h>
36#include <project_rescue.h>
37#include <erc.h>
38#include <invoke_sch_dialog.h>
39#include <string_utils.h>
40#include <kiway.h>
42#include <paths.h>
43#include <pgm_base.h>
46#include <project_sch.h>
47#include <sch_edit_frame.h>
49#include <sch_line.h>
50#include <sch_junction.h>
51#include <sch_bus_entry.h>
52#include <sch_shape.h>
53#include <sch_painter.h>
54#include <sch_sheet.h>
55#include <sch_sheet_pin.h>
56#include <sch_view.h>
57#include <schematic.h>
58#include <sch_commit.h>
59#include <advanced_config.h>
61#include <sim/simulator_frame.h>
62#include <sim/spice_generator.h>
63#include <sim/sim_lib_mgr.h>
65#include <symbol_viewer_frame.h>
66#include <tool/common_tools.h>
67#include <tool/picker_tool.h>
68#include <tool/tool_manager.h>
69#include <tools/ee_actions.h>
70#include <tools/ee_selection.h>
73#include <tools/sch_move_tool.h>
75#include <eda_list_dialog.h>
77#include <wx_filename.h>
78#include <sch_sheet_path.h>
79#include <wx/filedlg.h>
80#include <wx/treectrl.h>
81#include "sch_edit_table_tool.h"
82
83
89static const wxChar traceSchPaste[] = wxT( "KICAD_SCH_PASTE" );
90
91
93{
95 return 0;
96}
97
98
100{
102 return 0;
103}
104
105
107{
109 return 0;
110}
111
112
114{
115 m_frame->SaveProject( true );
116 return 0;
117}
118
119
121{
122 SCH_SHEET* curr_sheet = m_frame->GetCurrentSheet().Last();
123 wxFileName curr_fn = curr_sheet->GetFileName();
124 wxFileDialog dlg( m_frame, _( "Schematic Files" ), curr_fn.GetPath(), curr_fn.GetFullName(),
126 wxFD_SAVE | wxFD_OVERWRITE_PROMPT );
127
128 if( dlg.ShowModal() == wxID_CANCEL )
129 return false;
130
131 wxString newFilename =
133
134 m_frame->saveSchematicFile( curr_sheet, newFilename );
135 return 0;
136}
137
138
140{
141 SCHEMATIC& schematic = m_frame->Schematic();
142 SCH_SHEET& root = schematic.Root();
143
144 if( m_frame->GetCurrentSheet().Last() != &root )
145 {
148
149 // Store the current zoom level into the current screen before switching
151
152 SCH_SHEET_PATH rootSheetPath;
153 rootSheetPath.push_back( &root );
154 m_frame->SetCurrentSheet( rootSheetPath );
156
157 wxSafeYield();
158 }
159
160 wxString msg;
161 msg.Printf( _( "Revert '%s' (and all sub-sheets) to last version saved?" ),
162 schematic.GetFileName() );
163
164 if( !IsOK( m_frame, msg ) )
165 return false;
166
167 SCH_SCREENS screenList( schematic.Root() );
168
169 for( SCH_SCREEN* screen = screenList.GetFirst(); screen; screen = screenList.GetNext() )
170 screen->SetContentModified( false ); // do not prompt the user for changes
171
173 m_frame->OpenProjectFiles( std::vector<wxString>( 1, schematic.GetFileName() ), KICTL_REVERT );
174
175 return 0;
176}
177
178
180{
182 return 0;
183}
184
185
187{
188 PICKED_ITEMS_LIST undoCmd;
190 ITEM_PICKER wrapper( m_frame->GetScreen(), undoItem, UNDO_REDO::PAGESETTINGS );
191
192 undoCmd.PushItem( wrapper );
193 undoCmd.SetDescription( _( "Page Settings" ) );
194 m_frame->SaveCopyInUndoList( undoCmd, UNDO_REDO::PAGESETTINGS, false, false );
195
199
200 if( dlg.ShowModal() == wxID_OK )
201 {
202 // Update text variables
206
207 m_frame->OnModify();
208 }
209 else
210 {
212 }
213
214 return 0;
215}
216
217
219{
220 SCH_SCREENS schematic( m_frame->Schematic().Root() );
221
222 if( schematic.HasNoFullyDefinedLibIds() )
223 RescueLegacyProject( true );
224 else
226
227 return 0;
228}
229
230
231bool SCH_EDITOR_CONTROL::RescueLegacyProject( bool aRunningOnDemand )
232{
235
236 return rescueProject( rescuer, aRunningOnDemand );
237}
238
239
241{
245
246 return rescueProject( rescuer, aRunningOnDemand );
247}
248
249
250bool SCH_EDITOR_CONTROL::rescueProject( RESCUER& aRescuer, bool aRunningOnDemand )
251{
252 if( !RESCUER::RescueProject( m_frame, aRescuer, aRunningOnDemand ) )
253 return false;
254
255 if( aRescuer.GetCandidateCount() )
256 {
257 KIWAY_PLAYER* viewer = m_frame->Kiway().Player( FRAME_SCH_VIEWER, false );
258
259 if( viewer )
260 static_cast<SYMBOL_VIEWER_FRAME*>( viewer )->ReCreateLibList();
261
262 if( aRunningOnDemand )
263 {
264 SCH_SCREENS schematic( m_frame->Schematic().Root() );
265
266 schematic.UpdateSymbolLinks();
268 }
269
271 m_frame->SyncView();
273 m_frame->OnModify();
274 }
275
276 return true;
277}
278
279
281{
282 DIALOG_SYMBOL_REMAP dlgRemap( m_frame );
283
284 dlgRemap.ShowQuasiModal();
285
286 m_frame->GetCanvas()->Refresh( true );
287
288 return 0;
289}
290
291
293{
295 return 0;
296}
297
298
300{
302
303 dlg.ShowModal();
304
305 // save project config if the prj config has changed:
306 if( dlg.PrjConfigChanged() )
307 m_frame->OnModify();
308
309 return 0;
310}
311
312
314{
315 m_frame->Close( false );
316 return 0;
317}
318
319
321{
322 doCrossProbeSchToPcb( aEvent, false );
323 return 0;
324}
325
326
328{
329 doCrossProbeSchToPcb( aEvent, true );
330 return 0;
331}
332
333
334void SCH_EDITOR_CONTROL::doCrossProbeSchToPcb( const TOOL_EVENT& aEvent, bool aForce )
335{
336 // Don't get in an infinite loop SCH -> PCB -> SCH -> PCB -> SCH -> ...
338 return;
339
341
342 EE_SELECTION& selection = aForce ? selTool->RequestSelection() : selTool->GetSelection();
343
344 m_frame->SendSelectItemsToPcb( selection.GetItemsSortedBySelectionOrder(), aForce );
345}
346
347
349{
350 bool savePowerSymbols = IsOK( m_frame,
351 _( "Include power symbols in schematic to the library?" ) );
352
353 bool createNew = aEvent.IsAction( &EE_ACTIONS::exportSymbolsToNewLibrary );
354
355 SCH_REFERENCE_LIST symbols;
356 m_frame->Schematic().GetSheets().GetSymbols( symbols, savePowerSymbols );
357
358 std::map<LIB_ID, LIB_SYMBOL*> libSymbols;
359 std::map<LIB_ID, std::vector<SCH_SYMBOL*>> symbolMap;
360
361 for( size_t i = 0; i < symbols.GetCount(); ++i )
362 {
363 SCH_SYMBOL* symbol = symbols[i].GetSymbol();
364 LIB_SYMBOL* libSymbol = symbol->GetLibSymbolRef().get();
365 LIB_ID id = libSymbol->GetLibId();
366
367 if( libSymbols.count( id ) )
368 {
369 wxASSERT_MSG( libSymbols[id]->Compare( *libSymbol, LIB_ITEM::COMPARE_FLAGS::ERC ) == 0,
370 "Two symbols have the same LIB_ID but are different!" );
371 }
372 else
373 {
374 libSymbols[id] = libSymbol;
375 }
376
377 symbolMap[id].emplace_back( symbol );
378 }
379
381
382 wxString targetLib;
383
384 if( createNew )
385 {
386 wxFileName fn;
388
389 if( !libTable ) // Cancelled by user
390 return 0;
391
394 ( libTable == &SYMBOL_LIB_TABLE::GetGlobalLibTable() ),
396 {
397 return 0;
398 }
399
400 targetLib = fn.GetName();
401
402 if( libTable->HasLibrary( targetLib, false ) )
403 {
404 DisplayError( m_frame, wxString::Format( _( "Library '%s' already exists." ),
405 targetLib ) );
406 return 0;
407 }
408
409 // if the "new" library is in fact an existing library and the used asked for replacing
410 // it by the recreated lib, erase it:
411 if( fn.FileExists() )
412 wxRemoveFile( fn.GetFullPath() );
413
414 if( !mgr.CreateLibrary( fn.GetFullPath(), libTable ) )
415 {
416 DisplayError( m_frame, wxString::Format( _( "Could not add library '%s'." ),
417 targetLib ) );
418 return 0;
419 }
420 }
421 else
422 {
423 targetLib = m_frame->SelectLibraryFromList();
424 }
425
426 if( targetLib.IsEmpty() )
427 return 0;
428
429 bool map = IsOK( m_frame, _( "Update symbols in schematic to refer to new library?" ) );
430 bool append = false;
431
432 SYMBOL_LIB_TABLE_ROW* row = mgr.GetLibrary( targetLib );
433 SCH_IO_MGR::SCH_FILE_T type = SCH_IO_MGR::EnumFromStr( row->GetType() );
434 IO_RELEASER<SCH_IO> pi( SCH_IO_MGR::FindPlugin( type ) );
435
436 wxFileName dest = row->GetFullURI( true );
437 dest.Normalize( FN_NORMALIZE_FLAGS | wxPATH_NORM_ENV_VARS );
438
439 for( const std::pair<const LIB_ID, LIB_SYMBOL*>& it : libSymbols )
440 {
441 LIB_SYMBOL* origSym = it.second;
442 LIB_SYMBOL* newSym = origSym->Flatten().release();
443
444 try
445 {
446 pi->SaveSymbol( dest.GetFullPath(), newSym );
447 }
448 catch( const IO_ERROR& ioe )
449 {
450 wxString msg;
451 msg.Printf( _( "Error saving symbol %s to library '%s'." ),
452 newSym->GetName(), row->GetNickName() );
453 msg += wxS( "\n\n" ) + ioe.What();
454 wxLogWarning( msg );
455 return 0;
456 }
457
458 if( map )
459 {
460 LIB_ID id = it.first;
461 id.SetLibNickname( targetLib );
462
463 for( SCH_SYMBOL* symbol : symbolMap[it.first] )
464 {
465 m_frame->SaveCopyInUndoList( m_frame->GetScreen(), symbol, UNDO_REDO::CHANGED,
466 append, false );
467 symbol->SetLibId( id );
468 append = true;
469 }
470 }
471 }
472
473 // Save the modified symbol library table. We need to look this up by name in each table to find
474 // whether the new library is a global or project entity as the code above to choose the library
475 // returns a different type depending on whether a global or project library is chosen.
477 SYMBOL_LIB_TABLE* projectTable = nullptr;
478
479 if( !m_frame->Prj().IsNullProject() )
480 projectTable = PROJECT_SCH::SchSymbolLibTable( &m_frame->Prj() );
481
482 if( globalTable->FindRow( targetLib ) )
483 {
484 try
485 {
486 wxString globalTablePath = SYMBOL_LIB_TABLE::GetGlobalTableFileName();
487 globalTable->Save( globalTablePath );
488 }
489 catch( const IO_ERROR& ioe )
490 {
491 wxString msg;
492 msg.Printf( _( "Error saving global library table:\n\n%s" ), ioe.What() );
493 wxMessageBox( msg, _( "File Save Error" ), wxOK | wxICON_ERROR );
494 }
495 }
496 else if( projectTable && projectTable->FindRow( targetLib ) )
497 {
498 try
499 {
500 wxString projectPath = m_frame->Prj().GetProjectPath();
501 wxFileName projectTableFn( projectPath, SYMBOL_LIB_TABLE::GetSymbolLibTableFileName() );
502 projectTable->Save( projectTableFn.GetFullPath() );
503 }
504 catch( const IO_ERROR& ioe )
505 {
506 wxString msg;
507 msg.Printf( _( "Error saving project-specific library table:\n\n%s" ), ioe.What() );
508 wxMessageBox( msg, _( "File Save Error" ), wxOK | wxICON_ERROR );
509 }
510 }
511
512 if( append )
513 {
514 std::set<SCH_SCREEN*> processedScreens;
516
517 for( SCH_SHEET_PATH& sheet : sheets )
518 {
519 SCH_SCREEN* screen = sheet.LastScreen();
520
521 if( processedScreens.find( ( screen ) ) == processedScreens.end() )
522 {
523 processedScreens.insert( screen );
524 screen->UpdateSymbolLinks();
525 }
526 }
527
528 m_frame->OnModify();
529 }
530
531 return 0;
532}
533
534
535#define HITTEST_THRESHOLD_PIXELS 5
536
538{
541 false );
542
543 if( !simFrame ) // Defensive coding; shouldn't happen.
544 return 0;
545
546 if( wxWindow* blocking_win = simFrame->Kiway().GetBlockingDialog() )
547 blocking_win->Close( true );
548
549 // Deactivate other tools; particularly important if another PICKER is currently running
550 Activate();
551
552 picker->SetCursor( KICURSOR::VOLTAGE_PROBE );
553 picker->SetSnapping( false );
554
555 picker->SetClickHandler(
556 [this, simFrame]( const VECTOR2D& aPosition )
557 {
559 EDA_ITEM* item = selTool->GetNode( aPosition );
561
562 if( !item )
563 return false;
564
565 if( item->Type() == SCH_PIN_T )
566 {
567 try
568 {
569 LIB_PIN* pin = static_cast<SCH_PIN*>( item )->GetLibPin();
570 SCH_SYMBOL* symbol = static_cast<SCH_SYMBOL*>( item->GetParent() );
571
572 wxString msg;
573 WX_STRING_REPORTER reporter( &msg );
574 SIM_LIB_MGR mgr( &m_frame->Prj() );
575
576 SIM_MODEL& model = mgr.CreateModel( &sheet, *symbol, reporter ).model;
577
578 if( reporter.HasMessage() )
579 THROW_IO_ERROR( msg );
580
581 SPICE_ITEM spiceItem;
582 spiceItem.refName = symbol->GetRef( &sheet ).ToStdString();
583 std::vector<std::string> currentNames =
584 model.SpiceGenerator().CurrentNames( spiceItem );
585
586 if( currentNames.size() == 0 )
587 {
588 return true;
589 }
590 else if( currentNames.size() == 1 )
591 {
592 simFrame->AddCurrentTrace( currentNames.at( 0 ) );
593 return true;
594 }
595
596 int modelPinIndex = model.FindModelPinIndex( pin->GetNumber().ToStdString() );
597
598 if( modelPinIndex != SIM_MODEL::PIN::NOT_CONNECTED )
599 {
600 wxString name = currentNames.at( modelPinIndex );
601 simFrame->AddCurrentTrace( name );
602 }
603 }
604 catch( const IO_ERROR& e )
605 {
607 }
608 }
609 else if( item->IsType( { SCH_ITEM_LOCATE_WIRE_T } )
610 || item->IsType( { SCH_JUNCTION_T } ) )
611 {
612 if( SCH_CONNECTION* conn = static_cast<SCH_ITEM*>( item )->Connection() )
613 {
614 std::string spiceNet = UnescapeString( conn->Name() ).ToStdString();
616
617 simFrame->AddVoltageTrace( wxString::Format( "V(%s)", spiceNet ) );
618 }
619 }
620
621 return true;
622 } );
623
624 picker->SetMotionHandler(
625 [this, picker]( const VECTOR2D& aPos )
626 {
627 EE_COLLECTOR collector;
628 collector.m_Threshold = KiROUND( getView()->ToWorld( HITTEST_THRESHOLD_PIXELS ) );
629 collector.Collect( m_frame->GetScreen(), { SCH_ITEM_LOCATE_WIRE_T,
630 SCH_PIN_T,
631 SCH_SHEET_PIN_T }, aPos );
632
634 selectionTool->GuessSelectionCandidates( collector, aPos );
635
636 EDA_ITEM* item = collector.GetCount() == 1 ? collector[ 0 ] : nullptr;
637 SCH_LINE* wire = dynamic_cast<SCH_LINE*>( item );
638
639 const SCH_CONNECTION* conn = nullptr;
640
641 if( wire )
642 {
643 item = nullptr;
644 conn = wire->Connection();
645 }
646
647 if( item && item->Type() == SCH_PIN_T )
648 picker->SetCursor( KICURSOR::CURRENT_PROBE );
649 else
650 picker->SetCursor( KICURSOR::VOLTAGE_PROBE );
651
652 if( m_pickerItem != item )
653 {
654 if( m_pickerItem )
655 selectionTool->UnbrightenItem( m_pickerItem );
656
657 m_pickerItem = item;
658
659 if( m_pickerItem )
660 selectionTool->BrightenItem( m_pickerItem );
661 }
662
663 wxString connectionName = ( conn ) ? conn->Name() : wxString( wxS( "" ) );
664
665 if( m_frame->GetHighlightedConnection() != connectionName )
666 {
667 m_frame->SetHighlightedConnection( connectionName );
668
669 TOOL_EVENT dummyEvent;
670 UpdateNetHighlighting( dummyEvent );
671 }
672 } );
673
674 picker->SetFinalizeHandler(
675 [this]( const int& aFinalState )
676 {
677 if( m_pickerItem )
678 m_toolMgr->GetTool<EE_SELECTION_TOOL>()->UnbrightenItem( m_pickerItem );
679
680 if( !m_frame->GetHighlightedConnection().IsEmpty() )
681 {
682 m_frame->SetHighlightedConnection( wxEmptyString );
683
684 TOOL_EVENT dummyEvent;
685 UpdateNetHighlighting( dummyEvent );
686 }
687
688 // Wake the selection tool after exiting to ensure the cursor gets updated
690 } );
691
693
694 return 0;
695}
696
697
699{
701
702 // Deactivate other tools; particularly important if another PICKER is currently running
703 Activate();
704
705 picker->SetCursor( KICURSOR::TUNE );
706 picker->SetSnapping( false );
707
708 picker->SetClickHandler(
709 [this]( const VECTOR2D& aPosition )
710 {
712 EDA_ITEM* item = nullptr;
713 selTool->SelectPoint( aPosition, { SCH_SYMBOL_T, SCH_FIELD_T }, &item );
714
715 if( !item )
716 return false;
717
718 if( item->Type() != SCH_SYMBOL_T )
719 {
720 item = item->GetParent();
721
722 if( item->Type() != SCH_SYMBOL_T )
723 return false;
724 }
725
726 SCH_SYMBOL* symbol = static_cast<SCH_SYMBOL*>( item );
727 SCH_SHEET_PATH sheetPath = symbol->Schematic()->CurrentSheet();
728 KIWAY_PLAYER* simFrame = m_frame->Kiway().Player( FRAME_SIMULATOR, false );
729
730 if( simFrame )
731 {
732 if( wxWindow* blocking_win = simFrame->Kiway().GetBlockingDialog() )
733 blocking_win->Close( true );
734
735 static_cast<SIMULATOR_FRAME*>( simFrame )->AddTuner( sheetPath, symbol );
736 }
737
738 // We do not really want to keep a symbol selected in schematic,
739 // so clear the current selection
740 selTool->ClearSelection();
741 return true;
742 } );
743
744 picker->SetMotionHandler(
745 [this]( const VECTOR2D& aPos )
746 {
747 EE_COLLECTOR collector;
748 collector.m_Threshold = KiROUND( getView()->ToWorld( HITTEST_THRESHOLD_PIXELS ) );
749 collector.Collect( m_frame->GetScreen(), { SCH_SYMBOL_T, SCH_FIELD_T }, aPos );
750
752 selectionTool->GuessSelectionCandidates( collector, aPos );
753
754 EDA_ITEM* item = collector.GetCount() == 1 ? collector[ 0 ] : nullptr;
755
756 if( m_pickerItem != item )
757 {
758 if( m_pickerItem )
759 selectionTool->UnbrightenItem( m_pickerItem );
760
761 m_pickerItem = item;
762
763 if( m_pickerItem )
764 selectionTool->BrightenItem( m_pickerItem );
765 }
766 } );
767
768 picker->SetFinalizeHandler(
769 [this]( const int& aFinalState )
770 {
771 if( m_pickerItem )
772 m_toolMgr->GetTool<EE_SELECTION_TOOL>()->UnbrightenItem( m_pickerItem );
773
774 // Wake the selection tool after exiting to ensure the cursor gets updated
775 // and deselect previous selection from simulator to avoid any issue
776 // ( avoid crash in some cases when the SimTune tool is deselected )
778 selectionTool->ClearSelection();
780 } );
781
783
784 return 0;
785}
786
787
788// A singleton reference for clearing the highlight
790
791
792static bool highlightNet( TOOL_MANAGER* aToolMgr, const VECTOR2D& aPosition )
793{
794 SCH_EDIT_FRAME* editFrame = static_cast<SCH_EDIT_FRAME*>( aToolMgr->GetToolHolder() );
795 EE_SELECTION_TOOL* selTool = aToolMgr->GetTool<EE_SELECTION_TOOL>();
796 SCH_EDITOR_CONTROL* editorControl = aToolMgr->GetTool<SCH_EDITOR_CONTROL>();
797 SCH_CONNECTION* conn = nullptr;
798 SCH_ITEM* item = nullptr;
799 bool retVal = true;
800
801 if( aPosition != CLEAR )
802 {
803 ERC_TESTER erc( &editFrame->Schematic() );
804
805 if( erc.TestDuplicateSheetNames( false ) > 0 )
806 {
807 wxMessageBox( _( "Error: duplicate sub-sheet names found in current sheet." ) );
808 retVal = false;
809 }
810 else
811 {
812 item = static_cast<SCH_ITEM*>( selTool->GetNode( aPosition ) );
813 SCH_SYMBOL* symbol = dynamic_cast<SCH_SYMBOL*>( item );
814
815 if( item )
816 {
817 if( item->IsConnectivityDirty() )
818 editFrame->RecalculateConnections( nullptr, NO_CLEANUP );
819
820 if( item->Type() == SCH_FIELD_T )
821 symbol = dynamic_cast<SCH_SYMBOL*>( item->GetParent() );
822
823 if( symbol && symbol->GetLibSymbolRef() && symbol->GetLibSymbolRef()->IsPower() )
824 {
825 std::vector<SCH_PIN*> pins = symbol->GetPins();
826
827 if( pins.size() == 1 )
828 conn = pins[0]->Connection();
829 }
830 else
831 {
832 conn = item->Connection();
833 }
834 }
835 }
836 }
837
838 wxString connName = ( conn ) ? conn->Name() : wxString( wxS( "" ) );
839
840 if( !conn )
841 {
842 editFrame->SetStatusText( wxT( "" ) );
843 editFrame->SendCrossProbeClearHighlight();
844 editFrame->SetHighlightedConnection( wxEmptyString );
845 editorControl->SetHighlightBusMembers( false );
846 }
847 else
848 {
849 NET_NAVIGATOR_ITEM_DATA itemData( editFrame->GetCurrentSheet(), item );
850
851 if( connName != editFrame->GetHighlightedConnection() )
852 {
853 editorControl->SetHighlightBusMembers( false );
854 editFrame->SetCrossProbeConnection( conn );
855 editFrame->SetHighlightedConnection( connName, &itemData );
856 }
857 else
858 {
859 editorControl->SetHighlightBusMembers( !editorControl->GetHighlightBusMembers() );
860
861 if( item != editFrame->GetSelectedNetNavigatorItem() )
862 editFrame->SelectNetNavigatorItem( &itemData );
863 }
864 }
865
866 editFrame->UpdateNetHighlightStatus();
867
869 editorControl->UpdateNetHighlighting( dummy );
870
871 return retVal;
872}
873
874
876{
878 VECTOR2D cursorPos = controls->GetCursorPosition( !aEvent.DisableGridSnapping() );
879
880 highlightNet( m_toolMgr, cursorPos );
881
882 return 0;
883}
884
885
887{
889
890 return 0;
891}
892
893
895{
897 SCHEMATIC& schematic = m_frame->Schematic();
899
900 const SCH_CONNECTION* conn = nullptr;
901 VECTOR2D connPos;
902
903 for( EDA_ITEM* item : selectionTool->GetSelection() )
904 {
905 conn = static_cast<SCH_ITEM*>( item )->Connection();
906 connPos = item->GetPosition();
907
908 if( conn )
909 break;
910 }
911
912 if( !conn )
913 {
914 m_frame->ShowInfoBarError( _( "No net selected." ) );
915 return 0;
916 }
917
918 // Remove selection in favor of highlighting so the whole net is highlighted
919 selectionTool->ClearSelection();
920 highlightNet( m_toolMgr, connPos );
921
922 wxString netName = conn->Name();
923
924 if( conn->IsBus() )
925 {
926 wxString prefix;
927
928 if( NET_SETTINGS::ParseBusVector( netName, &prefix, nullptr ) )
929 {
930 netName = prefix + wxT( "*" );
931 }
932 else if( NET_SETTINGS::ParseBusGroup( netName, &prefix, nullptr ) )
933 {
934 netName = prefix + wxT( ".*" );
935 }
936 }
937 else if( !conn->Driver() || CONNECTION_SUBGRAPH::GetDriverPriority( conn->Driver() )
939 {
940 m_frame->ShowInfoBarError( _( "Net must be labeled to assign a netclass." ) );
942 return 0;
943 }
944
945 DIALOG_ASSIGN_NETCLASS dlg( m_frame, netName, schematic.GetNetClassAssignmentCandidates(),
946 [&]( const std::vector<wxString>& aNetNames )
947 {
948 for( SCH_ITEM* item : screen->Items() )
949 {
950 bool redraw = item->IsBrightened();
951 SCH_CONNECTION* itemConn = item->Connection();
952
953 if( itemConn && alg::contains( aNetNames, itemConn->Name() ) )
954 item->SetBrightened();
955 else
956 item->ClearBrightened();
957
958 redraw |= item->IsBrightened();
959
960 if( item->Type() == SCH_SYMBOL_T )
961 {
962 SCH_SYMBOL* symbol = static_cast<SCH_SYMBOL*>( item );
963
964 redraw |= symbol->HasBrightenedPins();
965
966 symbol->ClearBrightenedPins();
967
968 for( SCH_PIN* pin : symbol->GetPins() )
969 {
970 SCH_CONNECTION* pin_conn = pin->Connection();
971
972 if( pin_conn && alg::contains( aNetNames, pin_conn->Name() ) )
973 {
974 pin->SetBrightened();
975 redraw = true;
976 }
977 }
978 }
979 else if( item->Type() == SCH_SHEET_T )
980 {
981 for( SCH_SHEET_PIN* pin : static_cast<SCH_SHEET*>( item )->GetPins() )
982 {
983 SCH_CONNECTION* pin_conn = pin->Connection();
984
985 redraw |= pin->IsBrightened();
986
987 if( pin_conn && alg::contains( aNetNames, pin_conn->Name() ) )
988 pin->SetBrightened();
989 else
990 pin->ClearBrightened();
991
992 redraw |= pin->IsBrightened();
993 }
994 }
995
996 if( redraw )
997 getView()->Update( item, KIGFX::VIEW_UPDATE_FLAGS::REPAINT );
998 }
999
1001 } );
1002
1003 if( dlg.ShowModal() )
1004 {
1005 getView()->UpdateAllItemsConditionally(
1006 [&]( KIGFX::VIEW_ITEM* aItem ) -> int
1007 {
1008 int flags = 0;
1009
1010 // Netclass coloured items
1011 //
1012 if( dynamic_cast<SCH_LINE*>( aItem ) )
1013 flags |= KIGFX::REPAINT;
1014 else if( dynamic_cast<SCH_JUNCTION*>( aItem ) )
1015 flags |= KIGFX::REPAINT;
1016 else if( dynamic_cast<SCH_BUS_ENTRY_BASE*>( aItem ) )
1017 flags |= KIGFX::REPAINT;
1018
1019 // Items that might reference an item's netclass name
1020 //
1021 if( SCH_ITEM* item = dynamic_cast<SCH_ITEM*>( aItem ) )
1022 {
1023 item->RunOnChildren(
1024 [&flags]( SCH_ITEM* aChild )
1025 {
1026 EDA_TEXT* text = dynamic_cast<EDA_TEXT*>( aChild );
1027
1028 if( text && text->HasTextVars() )
1029 {
1030 text->ClearRenderCache();
1031 text->ClearBoundingBoxCache();
1032 flags |= KIGFX::GEOMETRY | KIGFX::REPAINT;
1033 }
1034 } );
1035
1036 EDA_TEXT* text = dynamic_cast<EDA_TEXT*>( aItem );
1037
1038 if( text && text->HasTextVars() )
1039 {
1040 text->ClearRenderCache();
1041 text->ClearBoundingBoxCache();
1043 }
1044
1045 if( flags & KIGFX::GEOMETRY )
1046 m_frame->GetScreen()->Update( item, false ); // Refresh RTree
1047 }
1048
1049 return flags;
1050 } );
1051 }
1052
1053 highlightNet( m_toolMgr, CLEAR );
1054 return 0;
1055}
1056
1057
1059{
1060 wxCHECK( m_frame, 0 );
1061
1062 const SCH_SHEET_PATH& sheetPath = m_frame->GetCurrentSheet();
1064 CONNECTION_GRAPH* connectionGraph = m_frame->Schematic().ConnectionGraph();
1065 wxString selectedName = m_frame->GetHighlightedConnection();
1066
1067 std::set<wxString> connNames;
1068 std::vector<EDA_ITEM*> itemsToRedraw;
1069
1070 wxCHECK( screen && connectionGraph, 0 );
1071
1072 if( !selectedName.IsEmpty() )
1073 {
1074 connNames.emplace( selectedName );
1075
1076 CONNECTION_SUBGRAPH* sg = connectionGraph->FindSubgraphByName( selectedName, sheetPath );
1077
1078 if( sg && m_highlightBusMembers )
1079 {
1080 for( const SCH_ITEM* item : sg->GetItems() )
1081 {
1082 wxCHECK2( item, continue );
1083
1084 SCH_CONNECTION* connection = item->Connection();
1085
1086 wxCHECK2( connection, continue );
1087
1088 for( const std::shared_ptr<SCH_CONNECTION>& member : connection->AllMembers() )
1089 {
1090 if( member )
1091 connNames.emplace( member->Name() );
1092 }
1093 }
1094 }
1095 }
1096
1097 for( SCH_ITEM* item : screen->Items() )
1098 {
1099 wxCHECK2( item, continue );
1100
1101 if( !item->IsConnectable() )
1102 continue;
1103
1104 SCH_ITEM* redrawItem = nullptr;
1105
1106 if( item->Type() == SCH_SYMBOL_T )
1107 {
1108 SCH_SYMBOL* symbol = static_cast<SCH_SYMBOL*>( item );
1109
1110 wxCHECK2( symbol, continue );
1111
1112 for( SCH_PIN* pin : symbol->GetPins() )
1113 {
1114 SCH_CONNECTION* pin_conn = pin->Connection();
1115
1116 wxCHECK2( pin_conn, continue );
1117
1118 if( !pin->IsBrightened() && connNames.count( pin_conn->Name() ) )
1119 {
1120 pin->SetBrightened();
1121 redrawItem = symbol;
1122 }
1123 else if( pin->IsBrightened() && !connNames.count( pin_conn->Name() ) )
1124 {
1125 pin->ClearBrightened();
1126 redrawItem = symbol;
1127 }
1128 }
1129
1130 if( symbol->IsPower() )
1131 {
1132 wxCHECK2( symbol->GetPins().size(), continue );
1133
1134 SCH_CONNECTION* pinConn = symbol->GetPins()[0]->Connection();
1135
1136 wxCHECK2( pinConn, continue );
1137
1138 std::vector<SCH_FIELD>& fields = symbol->GetFields();
1139
1140 for( int id : { REFERENCE_FIELD, VALUE_FIELD } )
1141 {
1142 if( !fields[id].IsVisible() )
1143 continue;
1144
1145 if( !fields[id].IsBrightened() && connNames.count( pinConn->Name() ) )
1146 {
1147 fields[id].SetBrightened();
1148 redrawItem = symbol;
1149 }
1150 else if( fields[id].IsBrightened() && !connNames.count( pinConn->Name() ) )
1151 {
1152 fields[id].ClearBrightened();
1153 redrawItem = symbol;
1154 }
1155 }
1156 }
1157 }
1158 else if( item->Type() == SCH_SHEET_T )
1159 {
1160 SCH_SHEET* sheet = static_cast<SCH_SHEET*>( item );
1161
1162 wxCHECK2( sheet, continue );
1163
1164 for( SCH_SHEET_PIN* pin : sheet->GetPins() )
1165 {
1166 wxCHECK2( pin, continue );
1167
1168 SCH_CONNECTION* pin_conn = pin->Connection();
1169
1170 wxCHECK2( pin_conn, continue );
1171
1172 if( !pin->IsBrightened() && connNames.count( pin_conn->Name() ) )
1173 {
1174 pin->SetBrightened();
1175 redrawItem = sheet;
1176 }
1177 else if( pin->IsBrightened() && !connNames.count( pin_conn->Name() ) )
1178 {
1179 pin->ClearBrightened();
1180 redrawItem = sheet;
1181 }
1182 }
1183 }
1184 else
1185 {
1186 SCH_CONNECTION* itemConn = item->Connection();
1187
1188 wxCHECK2( itemConn, continue );
1189
1190 if( !item->IsBrightened() && connNames.count( itemConn->Name() ) )
1191 {
1192 item->SetBrightened();
1193 redrawItem = item;
1194 }
1195 else if( item->IsBrightened() && !connNames.count( itemConn->Name() ) )
1196 {
1197 item->ClearBrightened();
1198 redrawItem = item;
1199 }
1200 }
1201
1202 if( redrawItem )
1203 itemsToRedraw.push_back( redrawItem );
1204 }
1205
1206 if( itemsToRedraw.size() )
1207 {
1208 // Be sure highlight change will be redrawn
1209 KIGFX::VIEW* view = getView();
1210
1211 for( EDA_ITEM* redrawItem : itemsToRedraw )
1213
1215 }
1216
1217 return 0;
1218}
1219
1220
1222{
1224
1225 // Deactivate other tools; particularly important if another PICKER is currently running
1226 Activate();
1227
1228 picker->SetCursor( KICURSOR::BULLSEYE );
1229 picker->SetSnapping( false );
1230
1231 picker->SetClickHandler(
1232 [this] ( const VECTOR2D& aPos )
1233 {
1234 return highlightNet( m_toolMgr, aPos );
1235 } );
1236
1238
1239 return 0;
1240}
1241
1242
1244{
1245 wxCHECK( m_frame, 0 );
1246
1247 if( m_frame->GetUndoCommandCount() <= 0 )
1248 return 0;
1249
1250 // Inform tools that undo command was issued
1252
1253 // Get the old list
1255
1256 wxCHECK( undo_list, 0 );
1257
1258 m_frame->PutDataInPreviousState( undo_list );
1259
1260 // Now push the old command to the RedoList
1261 undo_list->ReversePickersListOrder();
1262 m_frame->PushCommandToRedoList( undo_list );
1263
1264 m_toolMgr->GetTool<EE_SELECTION_TOOL>()->RebuildSelection();
1265
1267 m_frame->OnModify();
1268
1269 return 0;
1270}
1271
1272
1274{
1275 wxCHECK( m_frame, 0 );
1276
1277 if( m_frame->GetRedoCommandCount() == 0 )
1278 return 0;
1279
1280 // Inform tools that undo command was issued
1282
1283 /* Get the old list */
1285
1286 wxCHECK( list, 0 );
1287
1288 /* Redo the command: */
1290
1291 /* Put the old list in UndoList */
1294
1295 m_toolMgr->GetTool<EE_SELECTION_TOOL>()->RebuildSelection();
1296
1298 m_frame->OnModify();
1299
1300 return 0;
1301}
1302
1303
1304bool SCH_EDITOR_CONTROL::doCopy( bool aUseDuplicateClipboard )
1305{
1307 EE_SELECTION& selection = selTool->RequestSelection();
1308 SCHEMATIC& schematic = m_frame->Schematic();
1309
1310 if( selection.Empty() )
1311 return false;
1312
1313 if( aUseDuplicateClipboard )
1314 m_duplicateIsHoverSelection = selection.IsHover();
1315
1316 selection.SetScreen( m_frame->GetScreen() );
1318
1319 for( EDA_ITEM* item : selection )
1320 {
1321 if( item->Type() == SCH_SHEET_T )
1322 {
1323 SCH_SHEET* sheet = (SCH_SHEET*) item;
1324 m_supplementaryClipboard[ sheet->GetFileName() ] = sheet->GetScreen();
1325 }
1326 else if( item->Type() == SCH_FIELD_T && selection.IsHover() )
1327 {
1328 // Most of the time the user is trying to duplicate the parent symbol
1329 // and the field text is in it
1330 selection.Add( item->GetParent() );
1331 }
1332 else if( item->Type() == SCH_MARKER_T )
1333 {
1334 // Don't let the markers be copied
1335 selection.Remove( item );
1336 }
1337 }
1338
1339 STRING_FORMATTER formatter;
1340 SCH_IO_KICAD_SEXPR plugin;
1341 SCH_SHEET_LIST hierarchy = schematic.GetSheets();
1343
1344 plugin.Format( &selection, &selPath, schematic, &formatter, true );
1345
1346 if( selection.IsHover() )
1348
1349 if( aUseDuplicateClipboard )
1350 {
1351 m_duplicateClipboard = formatter.GetString();
1352 return true;
1353 }
1354
1355 return m_toolMgr->SaveClipboard( formatter.GetString() );
1356}
1357
1358
1359bool SCH_EDITOR_CONTROL::searchSupplementaryClipboard( const wxString& aSheetFilename,
1360 SCH_SCREEN** aScreen )
1361{
1362 if( m_supplementaryClipboard.count( aSheetFilename ) > 0 )
1363 {
1364 *aScreen = m_supplementaryClipboard[ aSheetFilename ];
1365 return true;
1366 }
1367
1368 return false;
1369}
1370
1371
1373{
1374 doCopy( true ); // Use the local clipboard
1375 Paste( aEvent );
1376
1377 return 0;
1378}
1379
1380
1382{
1383 wxTextEntry* textEntry = dynamic_cast<wxTextEntry*>( wxWindow::FindFocus() );
1384
1385 if( textEntry )
1386 {
1387 textEntry->Cut();
1388 return 0;
1389 }
1390
1391 if( doCopy() )
1393
1394 return 0;
1395}
1396
1397
1399{
1400 wxTextEntry* textEntry = dynamic_cast<wxTextEntry*>( wxWindow::FindFocus() );
1401
1402 if( textEntry )
1403 {
1404 textEntry->Copy();
1405 return 0;
1406 }
1407
1408 doCopy();
1409
1410 return 0;
1411}
1412
1413
1415 const SCH_SHEET_PATH& aPastePath,
1416 const KIID_PATH& aClipPath,
1417 bool aForceKeepAnnotations )
1418{
1419 wxCHECK( m_frame && aSymbol, /* void */ );
1420
1421 SCH_SYMBOL_INSTANCE newInstance;
1422 bool instanceFound = false;
1423 KIID_PATH pasteLookupPath = aClipPath;
1424
1425 m_pastedSymbols.insert( aSymbol );
1426
1427 for( const SCH_SYMBOL_INSTANCE& tmp : aSymbol->GetInstances() )
1428 {
1429 if( ( tmp.m_Path.empty() && aClipPath.empty() )
1430 || ( !aClipPath.empty() && tmp.m_Path.EndsWith( aClipPath ) ) )
1431 {
1432 newInstance = tmp;
1433 instanceFound = true;
1434
1435 wxLogTrace( traceSchPaste,
1436 wxS( "Pasting found symbol instance with reference %s, unit %d:"
1437 "\n\tClipboard path: %s\n\tSymbol UUID: %s." ),
1438 tmp.m_Reference, tmp.m_Unit,
1439 aClipPath.AsString(), aSymbol->m_Uuid.AsString() );
1440
1441 break;
1442 }
1443 }
1444
1445 // The pasted symbol look up paths include the symbol UUID.
1446 pasteLookupPath.push_back( aSymbol->m_Uuid );
1447
1448 if( !instanceFound )
1449 {
1450 wxLogTrace( traceSchPaste,
1451 wxS( "Clipboard symbol instance **not** found:\n\tClipboard path: %s\n\t"
1452 "Symbol UUID: %s." ),
1453 aClipPath.AsString(), aSymbol->m_Uuid.AsString() );
1454
1455 // Some legacy versions saved value fields escaped. While we still do in the symbol
1456 // editor, we don't anymore in the schematic, so be sure to unescape them.
1457 SCH_FIELD* valueField = aSymbol->GetField( VALUE_FIELD );
1458 valueField->SetText( UnescapeString( valueField->GetText() ) );
1459
1460 // Pasted from notepad or an older instance of eeschema. Use the values in the fields
1461 // instead.
1462 newInstance.m_Reference = aSymbol->GetField( REFERENCE_FIELD )->GetText();
1463 newInstance.m_Unit = aSymbol->GetUnit();
1464 }
1465
1466 newInstance.m_Path = aPastePath.Path();
1467 newInstance.m_ProjectName = m_frame->Prj().GetProjectName();
1468
1469 aSymbol->AddHierarchicalReference( newInstance );
1470
1471 if( !aForceKeepAnnotations )
1472 aSymbol->ClearAnnotation( &aPastePath, false );
1473
1474 // We might clear annotations but always leave the original unit number from the paste.
1475 aSymbol->SetUnit( newInstance.m_Unit );
1476}
1477
1478
1480 const SCH_SHEET_PATH& aPastePath,
1481 const KIID_PATH& aClipPath,
1482 bool aForceKeepAnnotations,
1483 SCH_SHEET_LIST* aPastedSheets,
1484 std::map<SCH_SHEET_PATH,
1485 SCH_REFERENCE_LIST>& aPastedSymbols )
1486{
1487 wxCHECK( aSheet && aPastedSheets, aPastePath );
1488
1489 SCH_SHEET_PATH sheetPath = aPastePath;
1490 sheetPath.push_back( aSheet );
1491
1492 aPastedSheets->push_back( sheetPath );
1493
1494 if( aSheet->GetScreen() == nullptr )
1495 return sheetPath; // We can only really set the page number but not load any items
1496
1497 for( SCH_ITEM* item : aSheet->GetScreen()->Items() )
1498 {
1499 if( item->IsConnectable() )
1500 item->SetConnectivityDirty();
1501
1502 if( item->Type() == SCH_SYMBOL_T )
1503 {
1504 SCH_SYMBOL* symbol = static_cast<SCH_SYMBOL*>( item );
1505
1506 wxCHECK2( symbol, continue );
1507
1508 // Only do this once if the symbol is shared across multiple sheets.
1509 if( !m_pastedSymbols.count( symbol ) )
1510 {
1511 for( SCH_PIN* pin : symbol->GetPins() )
1512 {
1513 const_cast<KIID&>( pin->m_Uuid ) = KIID();
1514 pin->SetConnectivityDirty();
1515 }
1516 }
1517
1518 updatePastedSymbol( symbol, sheetPath, aClipPath, aForceKeepAnnotations );
1519 }
1520 else if( item->Type() == SCH_SHEET_T )
1521 {
1522 SCH_SHEET* subsheet = static_cast<SCH_SHEET*>( item );
1523
1524 wxCHECK2( subsheet, continue );
1525
1526 // Make sure pins get a new UUID and set the dirty connectivity flag.
1527 if( !aPastedSheets->ContainsSheet( subsheet ) )
1528 {
1529 for( SCH_SHEET_PIN* pin : subsheet->GetPins() )
1530 {
1531 const_cast<KIID&>( pin->m_Uuid ) = KIID();
1532 pin->SetConnectivityDirty();
1533 }
1534 }
1535
1536 KIID_PATH newClipPath = aClipPath;
1537 newClipPath.push_back( subsheet->m_Uuid );
1538
1539 updatePastedSheet( subsheet, sheetPath, newClipPath, aForceKeepAnnotations,
1540 aPastedSheets, aPastedSymbols );
1541 }
1542 }
1543
1544 sheetPath.GetSymbols( aPastedSymbols[aPastePath] );
1545
1546 return sheetPath;
1547}
1548
1549
1551{
1552 wxCHECK( aScreen, /* void */ );
1553
1554 for( const SCH_ITEM* item : aScreen->Items() )
1555 {
1556 if( item->Type() == SCH_SYMBOL_T )
1557 {
1558 const SCH_SYMBOL* symbol = static_cast<const SCH_SYMBOL*>( item );
1559
1560 wxCHECK2( symbol, continue );
1561
1562 for( const SCH_SYMBOL_INSTANCE& symbolInstance : symbol->GetInstances() )
1563 {
1564 KIID_PATH pathWithSymbol = symbolInstance.m_Path;
1565
1566 pathWithSymbol.push_back( symbol->m_Uuid );
1567
1568 m_clipboardSymbolInstances[pathWithSymbol] = symbolInstance;
1569 }
1570 }
1571 }
1572}
1573
1574
1576{
1577 wxCHECK( m_frame, /* void */ );
1578
1579 for( SCH_SYMBOL* symbol : m_pastedSymbols )
1580 {
1581 wxCHECK2( symbol, continue );
1582
1583 std::vector<KIID_PATH> instancePathsToRemove;
1584
1585 for( const SCH_SYMBOL_INSTANCE& instance : symbol->GetInstances() )
1586 {
1587 if( ( instance.m_ProjectName != m_frame->Prj().GetProjectName() )
1588 || instance.m_Path.empty() )
1589 instancePathsToRemove.emplace_back( instance.m_Path );
1590 }
1591
1592 for( const KIID_PATH& path : instancePathsToRemove )
1593 symbol->RemoveInstance( path );
1594 }
1595}
1596
1597
1599{
1600 wxTextEntry* textEntry = dynamic_cast<wxTextEntry*>( wxWindow::FindFocus() );
1601
1602 if( textEntry )
1603 {
1604 textEntry->Paste();
1605 return 0;
1606 }
1607
1609 std::string content;
1610 VECTOR2I eventPos;
1611
1612 if( aEvent.IsAction( &ACTIONS::duplicate ) )
1613 content = m_duplicateClipboard;
1614 else
1615 content = m_toolMgr->GetClipboardUTF8();
1616
1617 if( content.empty() )
1618 return 0;
1619
1620 if( aEvent.IsAction( &ACTIONS::duplicate ) )
1621 eventPos = getViewControls()->GetCursorPosition( false );
1622
1623 STRING_LINE_READER reader( content, "Clipboard" );
1624 SCH_IO_KICAD_SEXPR plugin;
1625
1626 SCH_SHEET tempSheet;
1627 SCH_SCREEN* tempScreen = new SCH_SCREEN( &m_frame->Schematic() );
1628
1630 int annotateStartNum = m_frame->Schematic().Settings().m_AnnotateStartNum;
1631
1632 // Screen object on heap is owned by the sheet.
1633 tempSheet.SetScreen( tempScreen );
1634
1635 try
1636 {
1637 plugin.LoadContent( reader, &tempSheet );
1638 }
1639 catch( IO_ERROR& )
1640 {
1641 // If it wasn't content, then paste as text object.
1642 SCH_TEXT* text_item = new SCH_TEXT( VECTOR2I( 0, 0 ), content );
1643 tempScreen->Append( text_item );
1644 }
1645
1646 m_pastedSymbols.clear();
1648
1649 // Save pasted symbol instances in case the user chooses to keep existing symbol annotation.
1650 setPastedSymbolInstances( tempScreen );
1651
1652 tempScreen->MigrateSimModels();
1653
1654 PASTE_MODE pasteMode = annotate.automatic ? PASTE_MODE::RESPECT_OPTIONS
1655 : PASTE_MODE::REMOVE_ANNOTATIONS;
1656
1657 if( aEvent.IsAction( &ACTIONS::pasteSpecial ) )
1658 {
1659 DIALOG_PASTE_SPECIAL dlg( m_frame, &pasteMode );
1660
1661 if( dlg.ShowModal() == wxID_CANCEL )
1662 return 0;
1663 }
1664
1665 bool forceKeepAnnotations = pasteMode != PASTE_MODE::REMOVE_ANNOTATIONS;
1666
1667 // SCH_SEXP_PLUGIN added the items to the paste screen, but not to the view or anything
1668 // else. Pull them back out to start with.
1669 SCH_COMMIT commit( m_toolMgr );
1670 EDA_ITEMS loadedItems;
1671 std::vector<SCH_ITEM*> sortedLoadedItems;
1672 bool sheetsPasted = false;
1673 SCH_SHEET_LIST hierarchy = m_frame->Schematic().GetSheets();
1674 SCH_SHEET_PATH& pasteRoot = m_frame->GetCurrentSheet();
1675 wxFileName destFn = pasteRoot.Last()->GetFileName();
1676
1677 if( destFn.IsRelative() )
1678 destFn.MakeAbsolute( m_frame->Prj().GetProjectPath() );
1679
1680 // List of paths in the hierarchy that refer to the destination sheet of the paste
1681 SCH_SHEET_LIST sheetPathsForScreen = hierarchy.FindAllSheetsForScreen( pasteRoot.LastScreen() );
1682 sheetPathsForScreen.SortByPageNumbers();
1683
1684 // Build a list of screens from the current design (to avoid loading sheets that already exist)
1685 std::map<wxString, SCH_SCREEN*> loadedScreens;
1686
1687 for( const SCH_SHEET_PATH& item : hierarchy )
1688 {
1689 if( item.LastScreen() )
1690 loadedScreens[item.Last()->GetFileName()] = item.LastScreen();
1691 }
1692
1693 // Build symbol list for reannotation of duplicates
1694 SCH_REFERENCE_LIST existingRefs;
1695 hierarchy.GetSymbols( existingRefs );
1696 existingRefs.SortByReferenceOnly();
1697
1698 // Build UUID map for fetching last-resolved-properties
1699 std::map<KIID, EDA_ITEM*> itemMap;
1700 hierarchy.FillItemMap( itemMap );
1701
1702 // Keep track of pasted sheets and symbols for the different paths to the hierarchy.
1703 std::map<SCH_SHEET_PATH, SCH_REFERENCE_LIST> pastedSymbols;
1704 std::map<SCH_SHEET_PATH, SCH_SHEET_LIST> pastedSheets;
1705
1706 for( SCH_ITEM* item : tempScreen->Items() )
1707 {
1708 if( item->Type() == SCH_SHEET_T )
1709 sortedLoadedItems.push_back( item );
1710 else
1711 loadedItems.push_back( item );
1712 }
1713
1714 sort( sortedLoadedItems.begin(), sortedLoadedItems.end(),
1715 []( SCH_ITEM* firstItem, SCH_ITEM* secondItem )
1716 {
1717 SCH_SHEET* firstSheet = static_cast<SCH_SHEET*>( firstItem );
1718 SCH_SHEET* secondSheet = static_cast<SCH_SHEET*>( secondItem );
1719 return StrNumCmp( firstSheet->GetName(), secondSheet->GetName(), false ) < 0;
1720 });
1721
1722
1723 for( SCH_ITEM* item : sortedLoadedItems )
1724 {
1725 loadedItems.push_back( item );
1726
1727 if( item->Type() == SCH_SHEET_T )
1728 {
1729 SCH_SHEET* sheet = static_cast<SCH_SHEET*>( item );
1730 SCH_FIELD& nameField = sheet->GetFields()[SHEETNAME];
1731 wxString baseName = nameField.GetText();
1732 wxFileName srcFn = sheet->GetFileName();
1733
1734 if( srcFn.IsRelative() )
1735 srcFn.MakeAbsolute( m_frame->Prj().GetProjectPath() );
1736
1737 SCH_SHEET_LIST sheetHierarchy( sheet );
1738
1739 if( hierarchy.TestForRecursion( sheetHierarchy, destFn.GetFullPath( wxPATH_UNIX ) ) )
1740 {
1741 auto msg = wxString::Format( _( "The pasted sheet '%s'\n"
1742 "was dropped because the destination already has "
1743 "the sheet or one of its subsheets as a parent." ),
1744 sheet->GetFileName() );
1745 DisplayError( m_frame, msg );
1746 loadedItems.pop_back();
1747 }
1748 }
1749 }
1750
1751 // Remove the references from our temporary screen to prevent freeing on the DTOR
1752 tempScreen->Clear( false );
1753
1754 for( EDA_ITEM* item : loadedItems )
1755 {
1756 KIID_PATH clipPath( wxT( "/" ) ); // clipboard is at root
1757
1758 SCH_ITEM* schItem = static_cast<SCH_ITEM*>( item );
1759
1760 wxCHECK2( schItem, continue );
1761
1762 if( schItem->IsConnectable() )
1763 schItem->SetConnectivityDirty();
1764
1765 if( item->Type() == SCH_SYMBOL_T )
1766 {
1767 SCH_SYMBOL* symbol = static_cast<SCH_SYMBOL*>( item );
1768
1769 // The library symbol gets set from the cached library symbols in the current
1770 // schematic not the symbol libraries. The cached library symbol may have
1771 // changed from the original library symbol which would cause the copy to
1772 // be incorrect.
1773 SCH_SCREEN* currentScreen = m_frame->GetScreen();
1774
1775 wxCHECK2( currentScreen, continue );
1776
1777 auto it = currentScreen->GetLibSymbols().find( symbol->GetSchSymbolLibraryName() );
1778 auto end = currentScreen->GetLibSymbols().end();
1779
1780 if( it == end )
1781 {
1782 // If can't find library definition in the design, use the pasted library
1783 it = tempScreen->GetLibSymbols().find( symbol->GetSchSymbolLibraryName() );
1784 end = tempScreen->GetLibSymbols().end();
1785 }
1786
1787 LIB_SYMBOL* libSymbol = nullptr;
1788
1789 if( it != end )
1790 {
1791 libSymbol = new LIB_SYMBOL( *it->second );
1792 symbol->SetLibSymbol( libSymbol );
1793 }
1794
1795 for( SCH_SHEET_PATH& sheetPath : sheetPathsForScreen )
1796 updatePastedSymbol( symbol, sheetPath, clipPath, forceKeepAnnotations );
1797
1798 // Assign a new KIID
1799 const_cast<KIID&>( item->m_Uuid ) = KIID();
1800
1801 // Make sure pins get a new UUID
1802 for( SCH_PIN* pin : symbol->GetPins() )
1803 {
1804 const_cast<KIID&>( pin->m_Uuid ) = KIID();
1805 pin->SetConnectivityDirty();
1806 }
1807
1808 for( SCH_SHEET_PATH& sheetPath : sheetPathsForScreen )
1809 {
1810 // Ignore symbols from a non-existant library.
1811 if( libSymbol )
1812 {
1813 SCH_REFERENCE schReference( symbol, libSymbol, sheetPath );
1814 schReference.SetSheetNumber( sheetPath.GetVirtualPageNumber() );
1815 pastedSymbols[sheetPath].AddItem( schReference );
1816 }
1817 }
1818 }
1819 else if( item->Type() == SCH_SHEET_T )
1820 {
1821 SCH_SHEET* sheet = (SCH_SHEET*) item;
1822 SCH_FIELD& nameField = sheet->GetFields()[SHEETNAME];
1823 wxString baseName = nameField.GetText();
1824 wxString candidateName = baseName;
1825 wxString number;
1826
1827 while( !baseName.IsEmpty() && wxIsdigit( baseName.Last() ) )
1828 {
1829 number = baseName.Last() + number;
1830 baseName.RemoveLast();
1831 }
1832
1833 // Update hierarchy to include any other sheets we already added, avoiding
1834 // duplicate sheet names
1835 hierarchy = m_frame->Schematic().GetSheets();
1836
1837 //@todo: it might be better to just iterate through the sheet names
1838 // in this screen instead of the whole hierarchy.
1839 int uniquifier = std::max( 0, wxAtoi( number ) ) + 1;
1840
1841 while( hierarchy.NameExists( candidateName ) )
1842 candidateName = wxString::Format( wxT( "%s%d" ), baseName, uniquifier++ );
1843
1844 nameField.SetText( candidateName );
1845
1846 wxFileName fn = sheet->GetFileName();
1847 SCH_SCREEN* existingScreen = nullptr;
1848
1849 sheet->SetParent( pasteRoot.Last() );
1850 sheet->SetScreen( nullptr );
1851
1852 if( !fn.IsAbsolute() )
1853 {
1854 wxFileName currentSheetFileName = pasteRoot.LastScreen()->GetFileName();
1855 fn.Normalize( FN_NORMALIZE_FLAGS | wxPATH_NORM_ENV_VARS,
1856 currentSheetFileName.GetPath() );
1857 }
1858
1859 // Try to find the screen for the pasted sheet by several means
1860 if( !m_frame->Schematic().Root().SearchHierarchy( fn.GetFullPath( wxPATH_UNIX ),
1861 &existingScreen ) )
1862 {
1863 if( loadedScreens.count( sheet->GetFileName() ) > 0 )
1864 existingScreen = loadedScreens.at( sheet->GetFileName() );
1865 else
1866 searchSupplementaryClipboard( sheet->GetFileName(), &existingScreen );
1867 }
1868
1869 if( existingScreen )
1870 {
1871 sheet->SetScreen( existingScreen );
1872 }
1873 else
1874 {
1875 if( !m_frame->LoadSheetFromFile( sheet, &pasteRoot, fn.GetFullPath() ) )
1876 m_frame->InitSheet( sheet, sheet->GetFileName() );
1877 }
1878
1879 // Save the symbol instances in case the user chooses to keep the existing
1880 // symbol annotation.
1882 sheetsPasted = true;
1883
1884 // Push it to the clipboard path while it still has its old KIID
1885 clipPath.push_back( sheet->m_Uuid );
1886
1887 // Assign a new KIID to the pasted sheet
1888 const_cast<KIID&>( sheet->m_Uuid ) = KIID();
1889
1890 // Make sure pins get a new UUID
1891 for( SCH_SHEET_PIN* pin : sheet->GetPins() )
1892 {
1893 const_cast<KIID&>( pin->m_Uuid ) = KIID();
1894 pin->SetConnectivityDirty();
1895 }
1896
1897 // Once we have our new KIID we can update all pasted instances. This will either
1898 // reset the annotations or copy "kept" annotations from the supplementary clipboard.
1899 for( SCH_SHEET_PATH& sheetPath : sheetPathsForScreen )
1900 {
1901 SCH_SHEET_PATH subPath = updatePastedSheet( sheet, sheetPath, clipPath,
1902 ( forceKeepAnnotations && annotate.automatic ),
1903 &pastedSheets[sheetPath],
1904 pastedSymbols );
1905 }
1906 }
1907 else
1908 {
1909 SCH_ITEM* srcItem = dynamic_cast<SCH_ITEM*>( itemMap[ item->m_Uuid ] );
1910 SCH_ITEM* destItem = dynamic_cast<SCH_ITEM*>( item );
1911
1912 // Everything gets a new KIID
1913 const_cast<KIID&>( item->m_Uuid ) = KIID();
1914
1915 if( srcItem && destItem )
1916 {
1917 destItem->SetConnectivityDirty( true );
1918 destItem->SetLastResolvedState( srcItem );
1919 }
1920 }
1921
1922 // Lines need both ends selected for a move after paste so the whole line moves.
1923 if( item->Type() == SCH_LINE_T )
1924 item->SetFlags( STARTPOINT | ENDPOINT );
1925
1926 item->SetFlags( IS_NEW | IS_PASTED | IS_MOVING );
1927
1928 if( !m_frame->GetScreen()->CheckIfOnDrawList( (SCH_ITEM*) item ) ) // don't want a loop!
1929 m_frame->AddToScreen( item, m_frame->GetScreen() );
1930
1931 commit.Added( (SCH_ITEM*) item, m_frame->GetScreen() );
1932
1933 // Start out hidden so the pasted items aren't "ghosted" in their original location
1934 // before being moved to the current location.
1935 getView()->Hide( item, true );
1936 }
1937
1938 if( sheetsPasted )
1939 {
1940 // Update page numbers: Find next free numeric page number
1941 for( SCH_SHEET_PATH& sheetPath : sheetPathsForScreen )
1942 {
1943 for( SCH_SHEET_PATH& pastedSheet : pastedSheets[sheetPath] )
1944 {
1945 int page = 1;
1946 wxString pageNum = wxString::Format( "%d", page );
1947
1948 while( hierarchy.PageNumberExists( pageNum ) )
1949 pageNum = wxString::Format( "%d", ++page );
1950
1951 SCH_SHEET_INSTANCE sheetInstance;
1952
1953 sheetInstance.m_Path = pastedSheet.Path();
1954
1955 // Don't include the actual sheet in the instance path.
1956 sheetInstance.m_Path.pop_back();
1957 sheetInstance.m_PageNumber = pageNum;
1958 sheetInstance.m_ProjectName = m_frame->Prj().GetProjectName();
1959
1960 SCH_SHEET* sheet = pastedSheet.Last();
1961
1962 wxCHECK2( sheet, continue );
1963
1964 sheet->AddInstance( sheetInstance );
1965 hierarchy.push_back( pastedSheet );
1966
1967 // Remove all pasted sheet instance data that is not part of the current project.
1968 std::vector<KIID_PATH> instancesToRemove;
1969
1970 for( const SCH_SHEET_INSTANCE& instance : sheet->GetInstances() )
1971 {
1972 if( !hierarchy.HasPath( instance.m_Path ) )
1973 instancesToRemove.push_back( instance.m_Path );
1974 }
1975
1976 for( const KIID_PATH& instancePath : instancesToRemove )
1977 sheet->RemoveInstance( instancePath );
1978 }
1979 }
1980
1982
1983 // Get a version with correct sheet numbers since we've pasted sheets,
1984 // we'll need this when annotating next
1985 hierarchy = m_frame->Schematic().GetSheets();
1986 }
1987
1988 std::map<SCH_SHEET_PATH, SCH_REFERENCE_LIST> annotatedSymbols;
1989
1990 // Update the list of symbol instances that satisfy the annotation criteria.
1991 for( const SCH_SHEET_PATH& sheetPath : sheetPathsForScreen )
1992 {
1993 for( size_t i = 0; i < pastedSymbols[sheetPath].GetCount(); i++ )
1994 {
1995 if( pasteMode == PASTE_MODE::UNIQUE_ANNOTATIONS
1996 || pasteMode == PASTE_MODE::RESPECT_OPTIONS
1997 || pastedSymbols[sheetPath][i].AlwaysAnnotate() )
1998 {
1999 annotatedSymbols[sheetPath].AddItem( pastedSymbols[sheetPath][i] );
2000 }
2001 }
2002
2003 for( const SCH_SHEET_PATH& pastedSheetPath : pastedSheets[sheetPath] )
2004 {
2005 for( size_t i = 0; i < pastedSymbols[pastedSheetPath].GetCount(); i++ )
2006 {
2007 if( pasteMode == PASTE_MODE::UNIQUE_ANNOTATIONS
2008 || pasteMode == PASTE_MODE::RESPECT_OPTIONS
2009 || pastedSymbols[pastedSheetPath][i].AlwaysAnnotate() )
2010 {
2011 annotatedSymbols[pastedSheetPath].AddItem( pastedSymbols[pastedSheetPath][i] );
2012 }
2013 }
2014 }
2015 }
2016
2017 if( !annotatedSymbols.empty() )
2018 {
2019 for( SCH_SHEET_PATH& path : sheetPathsForScreen )
2020 {
2021 annotatedSymbols[path].SortByReferenceOnly();
2022
2023 if( pasteMode == PASTE_MODE::UNIQUE_ANNOTATIONS )
2024 {
2025 annotatedSymbols[path].ReannotateDuplicates( existingRefs );
2026 }
2027 else
2028 {
2029 annotatedSymbols[path].ReannotateByOptions( (ANNOTATE_ORDER_T) annotate.sort_order,
2030 (ANNOTATE_ALGO_T) annotate.method,
2031 annotateStartNum, existingRefs, false,
2032 &hierarchy );
2033 }
2034
2035 annotatedSymbols[path].UpdateAnnotation();
2036
2037 // Update existing refs for next iteration
2038 for( size_t i = 0; i < annotatedSymbols[path].GetCount(); i++ )
2039 existingRefs.AddItem( annotatedSymbols[path][i] );
2040
2041 for( const SCH_SHEET_PATH& pastedSheetPath : pastedSheets[path] )
2042 {
2043 annotatedSymbols[pastedSheetPath].SortByReferenceOnly();
2044
2045 if( pasteMode == PASTE_MODE::UNIQUE_ANNOTATIONS )
2046 {
2047 annotatedSymbols[pastedSheetPath].ReannotateDuplicates( existingRefs );
2048 }
2049 else
2050 {
2051 annotatedSymbols[pastedSheetPath].ReannotateByOptions( (ANNOTATE_ORDER_T) annotate.sort_order,
2052 (ANNOTATE_ALGO_T) annotate.method,
2053 annotateStartNum, existingRefs,
2054 false,
2055 &hierarchy );
2056 }
2057
2058 annotatedSymbols[pastedSheetPath].UpdateAnnotation();
2059
2060 // Update existing refs for next iteration
2061 for( size_t i = 0; i < annotatedSymbols[pastedSheetPath].GetCount(); i++ )
2062 existingRefs.AddItem( annotatedSymbols[pastedSheetPath][i] );
2063 }
2064 }
2065 }
2066
2068
2069 // The copy operation creates instance paths that are not valid for the current project or
2070 // saved as part of another project. Prune them now so they do not accumulate in the saved
2071 // schematic file.
2073
2074 SCH_SCREENS allScreens( m_frame->Schematic().Root() );
2075
2080
2081 // Now clear the previous selection, select the pasted items, and fire up the "move" tool.
2084
2085 EE_SELECTION& selection = selTool->GetSelection();
2086
2087 if( !selection.Empty() )
2088 {
2089 if( aEvent.IsAction( &ACTIONS::duplicate ) )
2090 {
2091 int closest_dist = INT_MAX;
2092
2093 auto processPt =
2094 [&]( const VECTOR2I& pt )
2095 {
2096 int dist = ( eventPos - pt ).EuclideanNorm();
2097
2098 if( dist < closest_dist )
2099 {
2100 selection.SetReferencePoint( pt );
2101 closest_dist = dist;
2102 }
2103 };
2104
2105 // Prefer connection points (which should remain on grid)
2106 for( EDA_ITEM* item : selection.Items() )
2107 {
2108 SCH_ITEM* sch_item = dynamic_cast<SCH_ITEM*>( item );
2109 LIB_PIN* lib_pin = dynamic_cast<LIB_PIN*>( item );
2110
2111 if( sch_item && sch_item->IsConnectable() )
2112 {
2113 for( const VECTOR2I& pt : sch_item->GetConnectionPoints() )
2114 processPt( pt );
2115 }
2116 else if( lib_pin )
2117 {
2118 processPt( lib_pin->GetPosition() );
2119 }
2120 }
2121
2122 // Only process other points if we didn't find any connection points
2123 if( closest_dist == INT_MAX )
2124 {
2125 for( EDA_ITEM* item : selection.Items() )
2126 {
2127 switch( item->Type() )
2128 {
2129 case SCH_LINE_T:
2130 processPt( static_cast<SCH_LINE*>( item )->GetStartPoint() );
2131 processPt( static_cast<SCH_LINE*>( item )->GetEndPoint() );
2132 break;
2133
2134 case SCH_SHAPE_T:
2135 {
2136 SCH_SHAPE* shape = static_cast<SCH_SHAPE*>( item );
2137
2138 switch( shape->GetShape() )
2139 {
2140 case SHAPE_T::RECTANGLE:
2141 for( const VECTOR2I& pt : shape->GetRectCorners() )
2142 processPt( pt );
2143
2144 break;
2145
2146 case SHAPE_T::CIRCLE:
2147 processPt( shape->GetCenter() );
2148 break;
2149
2150 case SHAPE_T::POLY:
2151 for( int ii = 0; ii < shape->GetPolyShape().TotalVertices(); ++ii )
2152 processPt( shape->GetPolyShape().CVertex( ii ) );
2153
2154 break;
2155
2156 default:
2157 processPt( shape->GetStart() );
2158 processPt( shape->GetEnd() );
2159 break;
2160 }
2161
2162 break;
2163 }
2164
2165 default:
2166 processPt( item->GetPosition() );
2167 break;
2168 }
2169 }
2170 }
2171
2172 selection.SetIsHover( m_duplicateIsHoverSelection );
2173 }
2174 else
2175 {
2176 SCH_ITEM* item = static_cast<SCH_ITEM*>( selection.GetTopLeftItem() );
2177
2178 selection.SetReferencePoint( item->GetPosition() );
2179 }
2180
2182 {
2183 // Pushing the commit will update the connectivity.
2184 commit.Push( _( "Paste" ) );
2185
2186 if( sheetsPasted )
2188 }
2189 else
2190 {
2191 commit.Revert();
2192 }
2193 }
2194
2195 return 0;
2196}
2197
2198
2200{
2202 EE_SELECTION& selection = selTool->RequestSelection( { SCH_SYMBOL_T } );
2203 SCH_SYMBOL* symbol = nullptr;
2204 SYMBOL_EDIT_FRAME* symbolEditor;
2205
2206 if( selection.GetSize() >= 1 )
2207 symbol = (SCH_SYMBOL*) selection.Front();
2208
2209 if( selection.IsHover() )
2211
2212 if( !symbol )
2213 {
2214 // Giant hack: by default we assign Edit Table to the same hotkey, so give the table
2215 // tool a chance to handle it if we can't.
2217 tableTool->EditTable( aEvent );
2218
2219 return 0;
2220 }
2221
2222 if( symbol->GetEditFlags() != 0 )
2223 return 0;
2224
2225 if( symbol->IsMissingLibSymbol() )
2226 {
2227 m_frame->ShowInfoBarError( _( "Symbols with broken library symbol links cannot "
2228 "be edited." ) );
2229 return 0;
2230 }
2231
2233 symbolEditor = (SYMBOL_EDIT_FRAME*) m_frame->Kiway().Player( FRAME_SCH_SYMBOL_EDITOR, false );
2234
2235 if( symbolEditor )
2236 {
2237 if( wxWindow* blocking_win = symbolEditor->Kiway().GetBlockingDialog() )
2238 blocking_win->Close( true );
2239
2240 if( aEvent.IsAction( &EE_ACTIONS::editWithLibEdit ) )
2241 {
2242 symbolEditor->LoadSymbolFromSchematic( symbol );
2243 }
2245 {
2246 symbolEditor->LoadSymbol( symbol->GetLibId(), symbol->GetUnit(),
2247 symbol->GetBodyStyle() );
2248
2249 if( !symbolEditor->IsSymbolTreeShown() )
2250 {
2251 wxCommandEvent evt;
2252 symbolEditor->OnToggleSymbolTree( evt );
2253 }
2254 }
2255 }
2256
2257 return 0;
2258}
2259
2260
2262{
2263 wxCommandEvent dummy;
2265 return 0;
2266}
2267
2268
2270{
2271 wxCommandEvent dummy;
2273 return 0;
2274}
2275
2276
2278{
2280
2281 wxCHECK( dlg, 0 );
2282
2283 // Needed at least on Windows. Raise() is not enough
2284 dlg->Show( true );
2285
2286 // Bring it to the top if already open. Dual monitor users need this.
2287 dlg->Raise();
2288
2289 dlg->ShowEditTab();
2290
2291 return 0;
2292}
2293
2294
2296{
2299
2300 return 0;
2301}
2302
2303
2305{
2306 wxCommandEvent dummy;
2308 return 0;
2309}
2310
2311
2313{
2314 wxCommandEvent dummy;
2316 return 0;
2317}
2318
2319
2321{
2323 dlg.ShowModal();
2324 return 0;
2325}
2326
2327
2329{
2330 int result = NET_PLUGIN_CHANGE;
2331
2332 // If a plugin is removed or added, rebuild and reopen the new dialog
2333 while( result == NET_PLUGIN_CHANGE )
2334 result = InvokeDialogNetList( m_frame );
2335
2336 return 0;
2337}
2338
2339
2341{
2342 EditSymbolFields( aEvent );
2344 return 0;
2345}
2346
2347
2349{
2351 return 0;
2352}
2353
2354
2356{
2359 return 0;
2360}
2361
2362
2364{
2365 getEditFrame<SCH_EDIT_FRAME>()->ToggleSearch();
2366 return 0;
2367}
2368
2369
2371{
2372 getEditFrame<SCH_EDIT_FRAME>()->ToggleSchematicHierarchy();
2373 return 0;
2374}
2375
2376
2378{
2379 getEditFrame<SCH_EDIT_FRAME>()->ToggleNetNavigator();
2380 return 0;
2381}
2382
2383
2385{
2386 getEditFrame<SCH_EDIT_FRAME>()->ToggleProperties();
2387 return 0;
2388}
2389
2390
2392{
2395
2398
2399 return 0;
2400}
2401
2402
2404{
2407
2410
2411 return 0;
2412}
2413
2414
2416{
2419
2422
2423 return 0;
2424}
2425
2426
2428{
2431
2434
2435 return 0;
2436}
2437
2438
2440{
2443
2446
2447 return 0;
2448}
2449
2450
2452{
2455
2458
2459 return 0;
2460}
2461
2462
2464{
2467
2471
2472 return 0;
2473}
2474
2475
2477{
2480
2484
2485 return 0;
2486}
2487
2488
2490{
2493 return 0;
2494}
2495
2496
2498{
2500 m_frame->eeconfig()->m_Drawing.line_mode %= LINE_MODE::LINE_MODE_COUNT;
2502 return 0;
2503}
2504
2505
2507{
2510 return 0;
2511}
2512
2513
2515{
2518 return 0;
2519}
2520
2521
2523{
2524
2526 return 0;
2527}
2528
2529
2531{
2532 int errors = 0;
2533 wxString details;
2534 bool quiet = aEvent.Parameter<bool>();
2535
2536 // Repair duplicate IDs.
2537 std::map<KIID, EDA_ITEM*> ids;
2538 int duplicates = 0;
2539
2540 auto processItem =
2541 [&]( EDA_ITEM* aItem )
2542 {
2543 auto it = ids.find( aItem->m_Uuid );
2544
2545 if( it != ids.end() && it->second != aItem )
2546 {
2547 duplicates++;
2548 const_cast<KIID&>( aItem->m_Uuid ) = KIID();
2549 }
2550
2551 ids[ aItem->m_Uuid ] = aItem;
2552 };
2553
2554 // Symbol IDs are the most important, so give them the first crack at "claiming" a
2555 // particular KIID.
2556
2557 for( const SCH_SHEET_PATH& sheet : m_frame->Schematic().GetSheets() )
2558 {
2559 SCH_SCREEN* screen = sheet.LastScreen();
2560
2561 for( SCH_ITEM* item : screen->Items().OfType( SCH_SYMBOL_T ) )
2562 {
2563 processItem( item );
2564
2565 for( SCH_PIN* pin : static_cast<SCH_SYMBOL*>( item )->GetPins( &sheet ) )
2566 processItem( pin );
2567 }
2568 }
2569
2570 for( const SCH_SHEET_PATH& sheet : m_frame->Schematic().GetSheets() )
2571 {
2572 SCH_SCREEN* screen = sheet.LastScreen();
2573
2574 for( SCH_ITEM* item : screen->Items() )
2575 {
2576 processItem( item );
2577
2578 item->RunOnChildren(
2579 [&]( SCH_ITEM* aChild )
2580 {
2581 processItem( item );
2582 } );
2583 }
2584 }
2585
2586 /*******************************
2587 * Your test here
2588 */
2589
2590 /*******************************
2591 * Inform the user
2592 */
2593
2594 if( duplicates )
2595 {
2596 errors += duplicates;
2597 details += wxString::Format( _( "%d duplicate IDs replaced.\n" ), duplicates );
2598 }
2599
2600 if( errors )
2601 {
2602 m_frame->OnModify();
2603
2604 wxString msg = wxString::Format( _( "%d potential problems repaired." ), errors );
2605
2606 if( !quiet )
2607 DisplayInfoMessage( m_frame, msg, details );
2608 }
2609 else if( !quiet )
2610 {
2611 DisplayInfoMessage( m_frame, _( "No errors found." ) );
2612 }
2613
2614 return 0;
2615}
2616
2617
2619{
2620 if( !Pgm().GetCommonSettings()->m_Input.hotkey_feedback )
2621 return 0;
2622
2623 GRID_SETTINGS& gridSettings = m_toolMgr->GetSettings()->m_Window.grid;
2624 int currentIdx = m_toolMgr->GetSettings()->m_Window.grid.last_size_idx;
2625
2626 wxArrayString gridsLabels;
2627
2628 for( const GRID& grid : gridSettings.grids )
2629 gridsLabels.Add( grid.UserUnitsMessageText( m_frame ) );
2630
2631 if( !m_frame->GetHotkeyPopup() )
2633
2635
2636 if( popup )
2637 popup->Popup( _( "Grid" ), gridsLabels, currentIdx );
2638
2639 return 0;
2640}
2641
2642
2644{
2645 Go( &SCH_EDITOR_CONTROL::New, ACTIONS::doNew.MakeEvent() );
2646 Go( &SCH_EDITOR_CONTROL::Open, ACTIONS::open.MakeEvent() );
2647 Go( &SCH_EDITOR_CONTROL::Save, ACTIONS::save.MakeEvent() );
2654 Go( &SCH_EDITOR_CONTROL::Plot, ACTIONS::plot.MakeEvent() );
2655 Go( &SCH_EDITOR_CONTROL::Quit, ACTIONS::quit.MakeEvent() );
2656
2659
2665
2668
2674
2676
2677 Go( &SCH_EDITOR_CONTROL::Undo, ACTIONS::undo.MakeEvent() );
2678 Go( &SCH_EDITOR_CONTROL::Redo, ACTIONS::redo.MakeEvent() );
2679 Go( &SCH_EDITOR_CONTROL::Cut, ACTIONS::cut.MakeEvent() );
2680 Go( &SCH_EDITOR_CONTROL::Copy, ACTIONS::copy.MakeEvent() );
2684
2686
2703
2708
2722
2724
2726
2731}
const char * name
Definition: DXF_plotter.cpp:57
static TOOL_ACTION updatePcbFromSchematic
Definition: actions.h:199
static TOOL_ACTION paste
Definition: actions.h:70
static TOOL_ACTION cancelInteractive
Definition: actions.h:63
static TOOL_ACTION revert
Definition: actions.h:55
static TOOL_ACTION saveAs
Definition: actions.h:52
static TOOL_ACTION copy
Definition: actions.h:69
static TOOL_ACTION pickerTool
Definition: actions.h:189
static TOOL_ACTION showSymbolEditor
Definition: actions.h:196
static TOOL_ACTION pasteSpecial
Definition: actions.h:71
static TOOL_ACTION plot
Definition: actions.h:58
static TOOL_ACTION open
Definition: actions.h:50
static TOOL_ACTION pageSettings
Definition: actions.h:56
static TOOL_ACTION showSearch
Definition: actions.h:98
static TOOL_ACTION undo
Definition: actions.h:66
static TOOL_ACTION duplicate
Definition: actions.h:74
static TOOL_ACTION doDelete
Definition: actions.h:75
static TOOL_ACTION quit
Definition: actions.h:59
static TOOL_ACTION save
Definition: actions.h:51
static TOOL_ACTION redo
Definition: actions.h:67
static TOOL_ACTION updateSchematicFromPcb
Definition: actions.h:200
static TOOL_ACTION print
Definition: actions.h:57
static TOOL_ACTION showProperties
Definition: actions.h:201
static TOOL_ACTION doNew
Definition: actions.h:47
static TOOL_ACTION cut
Definition: actions.h:68
static TOOL_ACTION refreshPreview
Definition: actions.h:137
WINDOW_SETTINGS m_Window
Definition: app_settings.h:170
static wxString m_DrawingSheetFileName
the name of the drawing sheet file, or empty to use the default drawing sheet
Definition: base_screen.h:85
int GetCount() const
Return the number of objects in the list.
Definition: collector.h:81
int m_Threshold
Definition: collector.h:234
COMMIT & Added(EDA_ITEM *aItem, BASE_SCREEN *aScreen=nullptr)
Remove a new item from the model.
Definition: commit.h:86
Calculate the connectivity of a schematic and generates netlists.
CONNECTION_SUBGRAPH * FindSubgraphByName(const wxString &aNetName, const SCH_SHEET_PATH &aPath)
Return the subgraph for a given net name on a given sheet.
A subgraph is a set of items that are electrically connected on a single sheet.
PRIORITY GetDriverPriority()
const std::set< SCH_ITEM * > & GetItems() const
Provide a read-only reference to the items in the subgraph.
void SetWksFileName(const wxString &aFilename)
bool PrjConfigChanged()
Return true if the project configuration was modified.
bool Show(bool show) override
int ShowQuasiModal()
virtual void PushCommandToUndoList(PICKED_ITEMS_LIST *aItem)
Add a command to undo in the undo list.
virtual int GetRedoCommandCount() const
virtual void ClearUndoRedoList()
Clear the undo and redo list using ClearUndoORRedoList()
virtual PICKED_ITEMS_LIST * PopCommandFromRedoList()
Return the last command to undo and remove it from list, nothing is deleted.
virtual PICKED_ITEMS_LIST * PopCommandFromUndoList()
Return the last command to undo and remove it from list, nothing is deleted.
virtual int GetUndoCommandCount() const
virtual void PushCommandToRedoList(PICKED_ITEMS_LIST *aItem)
Add a command to redo in the redo list.
void ShowInfoBarError(const wxString &aErrorMsg, bool aShowCloseButton=false, WX_INFOBAR::MESSAGE_TYPE aType=WX_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...
HOTKEY_CYCLE_POPUP * GetHotkeyPopup()
void ReleaseFile()
Release the current file marked in use.
void ScriptingConsoleEnableDisable()
Toggles the scripting console visibility.
bool LibraryFileBrowser(bool doOpen, wxFileName &aFilename, const wxString &wildcard, const wxString &ext, bool isDirectory=false, bool aIsGlobal=false, const wxString &aGlobalPath=wxEmptyString)
virtual void CreateHotkeyPopup()
GAL_TYPE GetBackend() const
Return the type of backend currently used by GAL canvas.
void ForceRefresh()
Force a redraw.
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:85
virtual VECTOR2I GetPosition() const
Definition: eda_item.h:239
EDA_ITEM_FLAGS GetEditFlags() const
Definition: eda_item.h:129
const KIID m_Uuid
Definition: eda_item.h:482
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:97
virtual void SetParent(EDA_ITEM *aParent)
Definition: eda_item.h:100
void ClearBrightened()
Definition: eda_item.h:119
EDA_ITEM * GetParent() const
Definition: eda_item.h:99
SHAPE_POLY_SET & GetPolyShape()
Definition: eda_shape.h:263
SHAPE_T GetShape() const
Definition: eda_shape.h:119
const VECTOR2I & GetEnd() const
Return the ending point of the graphic.
Definition: eda_shape.h:151
const VECTOR2I & GetStart() const
Return the starting point of the graphic.
Definition: eda_shape.h:126
std::vector< VECTOR2I > GetRectCorners() const
Definition: eda_shape.cpp:1132
A mix-in class (via multiple inheritance) that handles texts such as labels, parts,...
Definition: eda_text.h:80
virtual const wxString & GetText() const
Return the string associated with the text object.
Definition: eda_text.h:95
PANEL_ANNOTATE m_AnnotatePanel
static TOOL_ACTION importFPAssignments
Definition: ee_actions.h:173
static TOOL_ACTION repairSchematic
Definition: ee_actions.h:256
static TOOL_ACTION remapSymbols
Definition: ee_actions.h:167
static TOOL_ACTION selectionActivate
Activation of the selection tool.
Definition: ee_actions.h:46
static TOOL_ACTION toggleAnnotateAuto
Definition: ee_actions.h:265
static TOOL_ACTION lineMode90
Definition: ee_actions.h:260
static TOOL_ACTION toggleHiddenPins
Definition: ee_actions.h:231
static TOOL_ACTION highlightNet
Definition: ee_actions.h:287
static TOOL_ACTION addItemsToSel
Selects a list of items (specified as the event parameter)
Definition: ee_actions.h:63
static TOOL_ACTION move
Definition: ee_actions.h:118
static TOOL_ACTION clearHighlight
Definition: ee_actions.h:288
static TOOL_ACTION assignNetclass
Definition: ee_actions.h:159
static TOOL_ACTION clearSelection
Clears the current selection.
Definition: ee_actions.h:56
static TOOL_ACTION showPythonConsole
Definition: ee_actions.h:255
static TOOL_ACTION toggleERCWarnings
Definition: ee_actions.h:236
static TOOL_ACTION simTune
Definition: ee_actions.h:276
static TOOL_ACTION toggleERCExclusions
Definition: ee_actions.h:238
static TOOL_ACTION lineModeNext
Definition: ee_actions.h:262
static TOOL_ACTION lineModeFree
Definition: ee_actions.h:259
static TOOL_ACTION editLibSymbolWithLibEdit
Definition: ee_actions.h:171
static TOOL_ACTION generateBOMLegacy
Definition: ee_actions.h:176
static TOOL_ACTION toggleERCErrors
Definition: ee_actions.h:237
static TOOL_ACTION toggleOPCurrents
Definition: ee_actions.h:240
static TOOL_ACTION highlightNetTool
Definition: ee_actions.h:290
static TOOL_ACTION updateNetHighlighting
Definition: ee_actions.h:289
static TOOL_ACTION exportNetlist
Definition: ee_actions.h:174
static TOOL_ACTION assignFootprints
Definition: ee_actions.h:158
static TOOL_ACTION selectOnPCB
Definition: ee_actions.h:243
static TOOL_ACTION rescueSymbols
Definition: ee_actions.h:166
static TOOL_ACTION toggleHiddenFields
Definition: ee_actions.h:232
static TOOL_ACTION editWithLibEdit
Definition: ee_actions.h:170
static TOOL_ACTION simProbe
Definition: ee_actions.h:275
static TOOL_ACTION exportSymbolsToLibrary
Definition: ee_actions.h:179
static TOOL_ACTION drawSheetOnClipboard
Definition: ee_actions.h:251
static TOOL_ACTION editSymbolFields
Definition: ee_actions.h:150
static TOOL_ACTION showNetNavigator
Definition: ee_actions.h:291
static TOOL_ACTION annotate
Definition: ee_actions.h:149
static TOOL_ACTION toggleDirectiveLabels
Definition: ee_actions.h:235
static TOOL_ACTION showHierarchy
Definition: ee_actions.h:223
static TOOL_ACTION toggleOPVoltages
Definition: ee_actions.h:239
static TOOL_ACTION lineMode45
Definition: ee_actions.h:261
static TOOL_ACTION editSymbolLibraryLinks
Definition: ee_actions.h:151
static TOOL_ACTION saveCurrSheetCopyAs
Definition: ee_actions.h:42
static TOOL_ACTION showPcbNew
Definition: ee_actions.h:172
static TOOL_ACTION generateBOM
Definition: ee_actions.h:175
static TOOL_ACTION schematicSetup
Definition: ee_actions.h:160
static TOOL_ACTION exportSymbolsToNewLibrary
Definition: ee_actions.h:180
void Collect(SCH_SCREEN *aScreen, const std::vector< KICAD_T > &aScanTypes, const VECTOR2I &aPos, int aUnit=0, int aConvert=0)
Scan a EDA_ITEM using this class's Inspector method which does the collection.
EE_TYPE OfType(KICAD_T aType) const
Definition: sch_rtree.h:238
void GuessSelectionCandidates(EE_COLLECTOR &collector, const VECTOR2I &aPos)
Apply heuristics to try and determine a single object when multiple are found under the cursor.
EE_SELECTION & RequestSelection(const std::vector< KICAD_T > &aScanTypes={ SCH_LOCATE_ANY_T }, bool aPromoteCellSelections=false)
Return either an existing selection (filtered), or the selection at the current cursor position if th...
EDA_ITEM * GetNode(const VECTOR2I &aPosition)
Finds a connected item at a point (usually the cursor position).
bool SelectPoint(const VECTOR2I &aWhere, const std::vector< KICAD_T > &aScanTypes={ SCH_LOCATE_ANY_T }, EDA_ITEM **aItem=nullptr, bool *aSelectionCancelledFlag=nullptr, bool aCheckLocked=false, bool aAdd=false, bool aSubtract=false, bool aExclusiveOr=false)
Perform a click-type selection at a point (usually the cursor position).
int ClearSelection(const TOOL_EVENT &aEvent)
Select all visible items in sheet.
EE_SELECTION & GetSelection()
Definition: erc.h:46
static const TOOL_EVENT ClearedEvent
Definition: actions.h:259
static const TOOL_EVENT GridChangedByKeyEvent
Definition: actions.h:277
static const TOOL_EVENT SelectedEvent
Definition: actions.h:257
static const TOOL_EVENT SelectedItemsModified
Selected items were moved, this can be very high frequency on the canvas, use with care.
Definition: actions.h:264
static const TOOL_EVENT PointSelectedEvent
Definition: actions.h:256
static const TOOL_EVENT UnselectedEvent
Definition: actions.h:258
Similar to EDA_VIEW_SWITCHER, this dialog is a popup that shows feedback when using a hotkey to cycle...
void Popup(const wxString &aTitle, const wxArrayString &aItems, int aSelection)
Hold an error message and may be used when throwing exceptions containing meaningful error messages.
Definition: ki_exception.h:77
virtual const wxString What() const
A composite of Problem() and Where()
Definition: exceptions.cpp:30
An interface for classes handling user events controlling the view behavior such as zooming,...
VECTOR2D GetCursorPosition() const
Return the current cursor position in world coordinates.
An abstract base class for deriving all objects that can be added to a VIEW.
Definition: view_item.h:84
Hold a (potentially large) number of VIEW_ITEMs and renders them on a graphics device provided by the...
Definition: view.h:68
double GetScale() const
Definition: view.h:271
virtual void Update(const VIEW_ITEM *aItem, int aUpdateFlags) const
For dynamic VIEWs, inform the associated VIEW that the graphical representation of this item has chan...
Definition: view.cpp:1636
void SetLayerVisible(int aLayer, bool aVisible=true)
Control the visibility of a particular layer.
Definition: view.h:395
void UpdateAllItems(int aUpdateFlags)
Update all items in the view according to the given flags.
Definition: view.cpp:1518
void Hide(VIEW_ITEM *aItem, bool aHide=true, bool aHideOverlay=false)
Temporarily hide the item in the view (e.g.
Definition: view.cpp:1584
void MarkDirty()
Force redraw of view on the next rendering.
Definition: view.h:643
bool EndsWith(const KIID_PATH &aPath) const
Test if aPath from the last path towards the first path.
Definition: kiid.cpp:341
wxString AsString() const
Definition: kiid.cpp:362
Definition: kiid.h:49
wxString AsString() const
Definition: kiid.cpp:257
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.
Definition: kiway_holder.h:53
A wxFrame capable of the OpenProjectFiles function, meaning it can load a portion of a KiCad project.
Definition: kiway_player.h:67
virtual KIWAY_PLAYER * Player(FRAME_T aFrameType, bool doCreate=true, wxTopLevelWindow *aParent=nullptr)
Return the KIWAY_PLAYER* given a FRAME_T.
Definition: kiway.cpp:432
wxWindow * GetBlockingDialog()
Gets the window pointer to the blocking dialog (to send it signals)
Definition: kiway.cpp:695
A logical library item identifier and consists of various portions much like a URI.
Definition: lib_id.h:49
int SetLibNickname(const UTF8 &aLibNickname)
Override the logical library name portion of the LIB_ID to aLibNickname.
Definition: lib_id.cpp:99
VECTOR2I GetPosition() const override
Definition: lib_pin.h:232
Define a library symbol object.
Definition: lib_symbol.h:99
LIB_ID GetLibId() const override
Definition: lib_symbol.h:163
wxString GetName() const override
Definition: lib_symbol.h:160
std::unique_ptr< LIB_SYMBOL > Flatten() const
Return a flattened symbol inheritance to the caller.
Definition: lib_symbol.cpp:605
const wxString & GetNickName() const
const wxString GetFullURI(bool aSubstituted=false) const
Return the full location specifying URI for the LIB, either in original UI form or in environment var...
bool HasLibrary(const wxString &aNickname, bool aCheckEnabled=false) const
Test for the existence of aNickname in the library table.
void Save(const wxString &aFileName) const
Write this library table to aFileName in s-expression form.
static void ConvertToSpiceMarkup(std::string &aNetName)
Remove formatting wrappers and replace illegal spice net name characters with underscores.
Tree view item data for the net navigator.
static bool ParseBusGroup(const wxString &aGroup, wxString *name, std::vector< wxString > *aMemberList)
Parse a bus group label into the name and a list of components.
static bool ParseBusVector(const wxString &aBus, wxString *aName, std::vector< wxString > *aMemberList)
Parse a bus vector (e.g.
static wxString GetDefaultUserSymbolsPath()
Gets the default path we point users to create projects.
Definition: paths.cpp:98
A holder to handle information on schematic or board items.
void PushItem(const ITEM_PICKER &aItem)
Push aItem to the top of the list.
void SetDescription(const wxString &aDescription)
void ReversePickersListOrder()
Reverse the order of pickers stored in this list.
void SetMotionHandler(MOTION_HANDLER aHandler)
Set a handler for mouse motion.
Definition: picker_tool.h:83
void SetClickHandler(CLICK_HANDLER aHandler)
Set a handler for mouse click event.
Definition: picker_tool.h:72
void SetSnapping(bool aSnap)
Definition: picker_tool.h:65
void SetCursor(KICURSOR aCursor)
Definition: picker_tool.h:63
void SetFinalizeHandler(FINALIZE_HANDLER aHandler)
Set a handler for the finalize event.
Definition: picker_tool.h:103
static SYMBOL_LIB_TABLE * SchSymbolLibTable(PROJECT *aProject)
Accessor for project symbol library table.
virtual const wxString GetProjectPath() const
Return the full path of the project.
Definition: project.cpp:135
virtual const wxString GetProjectName() const
Return the short name of the project.
Definition: project.cpp:147
virtual bool IsNullProject() const
Check if this project is a null project (i.e.
Definition: project.cpp:153
static bool RescueProject(wxWindow *aParent, RESCUER &aRescuer, bool aRunningOnDemand)
size_t GetCandidateCount()
Return the number of rescue candidates found.
Holds all the data relating to one schematic.
Definition: schematic.h:75
SCH_SHEET_PATH & CurrentSheet() const override
Definition: schematic.h:136
wxString GetFileName() const override
Helper to retrieve the filename from the root sheet screen.
Definition: schematic.cpp:281
SCHEMATIC_SETTINGS & Settings() const
Definition: schematic.cpp:287
CONNECTION_GRAPH * ConnectionGraph() const override
Definition: schematic.h:146
SCH_SHEET_LIST GetSheets() const override
Builds and returns an updated schematic hierarchy TODO: can this be cached?
Definition: schematic.h:100
SCH_SHEET & Root() const
Definition: schematic.h:105
void AddToScreen(EDA_ITEM *aItem, SCH_SCREEN *aScreen=nullptr)
Add an item to the screen (and view) aScreen is the screen the item is located on,...
SCH_DRAW_PANEL * GetCanvas() const override
Return a pointer to GAL-based canvas of given EDA draw frame.
SYMBOL_LIB_TABLE * SelectSymLibTable(bool aOptional=false)
Display a dialog asking the user to select a symbol library table.
wxString SelectLibraryFromList()
Display a list of loaded libraries and allows the user to select a library.
void SyncView()
Mark all items for refresh.
EESCHEMA_SETTINGS * eeconfig() const
Base class for a bus or wire entry.
Definition: sch_bus_entry.h:38
virtual void Push(const wxString &aMessage=wxT("A commit"), int aCommitFlags=0) override
Revert the commit by restoring the modified items state.
Definition: sch_commit.cpp:393
virtual void Revert() override
Definition: sch_commit.cpp:474
Each graphical item can have a SCH_CONNECTION describing its logical connection (to a bus or net).
const std::vector< std::shared_ptr< SCH_CONNECTION > > AllMembers() const
wxString Name(bool aIgnoreSheet=false) const
bool IsBus() const
SCH_ITEM * Driver() const
KIGFX::SCH_VIEW * GetView() const override
Return a pointer to the #VIEW instance used in the panel.
Handle actions specific to the schematic editor.
int PageSetup(const TOOL_EVENT &aEvent)
bool RescueLegacyProject(bool aRunningOnDemand)
int ToggleDirectiveLabels(const TOOL_EVENT &aEvent)
int SaveAs(const TOOL_EVENT &aEvent)
int Annotate(const TOOL_EVENT &aEvent)
int ToggleAnnotateRecursive(const TOOL_EVENT &aEvent)
int ShowSchematicSetup(const TOOL_EVENT &aEvent)
int HighlightNet(const TOOL_EVENT &aEvent)
Remove any net highlighting.
int ClearHighlight(const TOOL_EVENT &aEvent)
Update net highlighting after an edit.
int EditSymbolFields(const TOOL_EVENT &aEvent)
int GenerateBOMLegacy(const TOOL_EVENT &aEvent)
int HighlightNetCursor(const TOOL_EVENT &aEvent)
int ImportFPAssignments(const TOOL_EVENT &aEvent)
int ChangeLineMode(const TOOL_EVENT &aEvent)
void doCrossProbeSchToPcb(const TOOL_EVENT &aEvent, bool aForce)
int ExportSymbolsToLibrary(const TOOL_EVENT &aEvent)
int SaveCurrSheetCopyAs(const TOOL_EVENT &aEvent)
Saves the currently-open schematic sheet to an other name.
bool rescueProject(RESCUER &aRescuer, bool aRunningOnDemand)
int CrossProbeToPcb(const TOOL_EVENT &aEvent)
Equivalent to the above, but initiated by the user.
int Quit(const TOOL_EVENT &aEvent)
int RemapSymbols(const TOOL_EVENT &aEvent)
int DrawSheetOnClipboard(const TOOL_EVENT &aEvent)
SCH_SHEET_PATH updatePastedSheet(SCH_SHEET *aSheet, const SCH_SHEET_PATH &aPastePath, const KIID_PATH &aClipPath, bool aForceKeepAnnotations, SCH_SHEET_LIST *aPastedSheets, std::map< SCH_SHEET_PATH, SCH_REFERENCE_LIST > &aPastedSymbols)
int RescueSymbols(const TOOL_EVENT &aEvent)
Perform rescue operations to recover old projects from before certain changes were made.
int AssignNetclass(const TOOL_EVENT &aEvent)
std::string m_duplicateClipboard
int ExportNetlist(const TOOL_EVENT &aEvent)
int Open(const TOOL_EVENT &aEvent)
int Paste(const TOOL_EVENT &aEvent)
int ToggleOPVoltages(const TOOL_EVENT &aEvent)
int Copy(const TOOL_EVENT &aEvent)
int ToggleERCWarnings(const TOOL_EVENT &aEvent)
int NextLineMode(const TOOL_EVENT &aEvent)
int Redo(const TOOL_EVENT &aEvent)
Clipboard support.
int UpdatePCB(const TOOL_EVENT &aEvent)
int UpdateFromPCB(const TOOL_EVENT &aEvent)
int ToggleAnnotateAuto(const TOOL_EVENT &aEvent)
int ToggleHiddenPins(const TOOL_EVENT &aEvent)
int Duplicate(const TOOL_EVENT &aEvent)
bool searchSupplementaryClipboard(const wxString &aSheetFilename, SCH_SCREEN **aScreen)
int GridFeedback(const TOOL_EVENT &aEvent)
int ShowSearch(const TOOL_EVENT &aEvent)
int EditWithSymbolEditor(const TOOL_EVENT &aEvent)
int SimTune(const TOOL_EVENT &aEvent)
Highlight net under the cursor.
int EditSymbolLibraryLinks(const TOOL_EVENT &aEvent)
int New(const TOOL_EVENT &aEvent)
std::map< wxString, SCH_SCREEN * > m_supplementaryClipboard
int ExplicitCrossProbeToPcb(const TOOL_EVENT &aEvent)
int ToggleOPCurrents(const TOOL_EVENT &aEvent)
int ShowPcbNew(const TOOL_EVENT &aEvent)
int UpdateNetHighlighting(const TOOL_EVENT &aEvent)
Launch a tool to highlight nets.
int ToggleERCErrors(const TOOL_EVENT &aEvent)
int TogglePythonConsole(const TOOL_EVENT &aEvent)
int ShowHierarchy(const TOOL_EVENT &aEvent)
void setTransitions() override
This method is meant to be overridden in order to specify handlers for events.
int ShowNetNavigator(const TOOL_EVENT &aEvent)
int SimProbe(const TOOL_EVENT &aEvent)
void updatePastedSymbol(SCH_SYMBOL *aSymbol, const SCH_SHEET_PATH &aPastePath, const KIID_PATH &aClipPath, bool aForceKeepAnnotations)
int ShowCvpcb(const TOOL_EVENT &aEvent)
int RepairSchematic(const TOOL_EVENT &aEvent)
std::set< SCH_SYMBOL * > m_pastedSymbols
void prunePastedSymbolInstances()
Remove all pasted symbol instances that do not belong to the current project.
int Cut(const TOOL_EVENT &aEvent)
int ToggleProperties(const TOOL_EVENT &aEvent)
std::map< KIID_PATH, SCH_SYMBOL_INSTANCE > m_clipboardSymbolInstances
int Save(const TOOL_EVENT &aEvent)
bool RescueSymbolLibTableProject(bool aRunningOnDemand)
Notifies pcbnew about the selected item.
bool doCopy(bool aUseDuplicateClipboard=false)
< copy selection to clipboard or to m_duplicateClipboard
int Undo(const TOOL_EVENT &aEvent)
int ToggleERCExclusions(const TOOL_EVENT &aEvent)
int Plot(const TOOL_EVENT &aEvent)
int Print(const TOOL_EVENT &aEvent)
int Revert(const TOOL_EVENT &aEvent)
int GenerateBOM(const TOOL_EVENT &aEvent)
void setPastedSymbolInstances(const SCH_SCREEN *aScreen)
int ToggleHiddenFields(const TOOL_EVENT &aEvent)
Schematic editor (Eeschema) main window.
void ShowSchematicSetupDialog(const wxString &aInitialPage=wxEmptyString)
void RollbackSchematicFromUndo()
Perform an undo of the last edit WITHOUT logging a corresponding redo.
bool IsSyncingSelection()
bool LoadSheetFromFile(SCH_SHEET *aSheet, SCH_SHEET_PATH *aCurrentSheet, const wxString &aFileName)
Load a the KiCad schematic file aFileName into the sheet aSheet.
Definition: sheet.cpp:164
void RefreshOperatingPointDisplay()
Refresh the display of any operaintg points.
void OnOpenCvpcb(wxCommandEvent &event)
void OnModify() override
Must be called after a schematic change in order to set the "modify" flag and update other data struc...
bool OpenProjectFiles(const std::vector< wxString > &aFileSet, int aCtl=0) override
Open a project or set of files given by aFileList.
void SetHighlightedConnection(const wxString &aConnection, const NET_NAVIGATOR_ITEM_DATA *aSelection=nullptr)
SCH_SCREEN * GetScreen() const override
Return a pointer to a BASE_SCREEN or one of its derivatives.
void InitSheet(SCH_SHEET *aSheet, const wxString &aNewFilename)
Definition: sheet.cpp:105
void SendSelectItemsToPcb(const std::vector< EDA_ITEM * > &aItems, bool aForce)
Send items to board editor for selection.
void SaveCopyInUndoList(SCH_SCREEN *aScreen, SCH_ITEM *aItemToCopy, UNDO_REDO aTypeCommand, bool aAppend, bool aDirtyConnectivity=true)
Create a copy of the current schematic item, and put it in the undo list.
void SendCrossProbeClearHighlight()
Tell Pcbnew to clear the existing highlighted net, if one exists.
void HardRedraw() override
Rebuild the GAL and redraw the screen.
SCH_SHEET_PATH & GetCurrentSheet() const
const SCH_ITEM * GetSelectedNetNavigatorItem() const
SCHEMATIC & Schematic() const
bool saveSchematicFile(SCH_SHEET *aSheet, const wxString &aSavePath)
Save aSheet to a schematic file.
void DrawCurrentSheetToClipboard()
Use the wxWidgets print code to draw an image of the current sheet onto the clipboard.
Definition: sheet.cpp:611
void OnUpdatePCB(wxCommandEvent &event)
void OnOpenPcbnew(wxCommandEvent &event)
void OnAnnotate(wxCommandEvent &event)
void SetSheetNumberAndCount()
Set the m_ScreenNumber and m_NumberOfScreens members for screens.
void RecalculateConnections(SCH_COMMIT *aCommit, SCH_CLEANUP_FLAGS aCleanupFlags)
Generate the connection data for the entire schematic hierarchy.
void SetCurrentSheet(const SCH_SHEET_PATH &aSheet)
void DisplayCurrentSheet()
Draw the current sheet on the display.
void PutDataInPreviousState(PICKED_ITEMS_LIST *aList)
Restore an undo or redo command to put data pointed by aList in the previous state.
const wxString & GetHighlightedConnection() const
void UpdateNetHighlightStatus()
void UpdateHierarchyNavigator()
Update the hierarchy navigation tree and history.
void SelectNetNavigatorItem(const NET_NAVIGATOR_ITEM_DATA *aSelection=nullptr)
DIALOG_SYMBOL_FIELDS_TABLE * GetSymbolFieldsTableDialog()
void SetCrossProbeConnection(const SCH_CONNECTION *aConnection)
Send a connection (net or bus) to Pcbnew for highlighting.
bool SaveProject(bool aSaveAs=false)
Save the currently-open schematic (including its hierarchy) and associated project.
Instances are attached to a symbol or sheet and provide a place for the symbol's value,...
Definition: sch_field.h:52
void SetText(const wxString &aText) override
Definition: sch_field.cpp:996
A SCH_IO derivation for loading schematic files using the new s-expression file format.
void LoadContent(LINE_READER &aReader, SCH_SHEET *aSheet, int aVersion=SEXPR_SCHEMATIC_FILE_VERSION)
void Format(SCH_SHEET *aSheet)
static SCH_FILE_T EnumFromStr(const wxString &aFileType)
Return the #SCH_FILE_T from the corresponding plugin type name: "kicad", "legacy",...
Definition: sch_io_mgr.cpp:107
Base class for any item which can be embedded within the SCHEMATIC container class,...
Definition: sch_item.h:165
virtual bool IsConnectable() const
Definition: sch_item.h:389
SCHEMATIC * Schematic() const
Searches the item hierarchy to find a SCHEMATIC.
Definition: sch_item.cpp:113
virtual void SetLastResolvedState(const SCH_ITEM *aItem)
Definition: sch_item.h:484
void SetConnectivityDirty(bool aDirty=true)
Definition: sch_item.h:455
bool IsConnectivityDirty() const
Definition: sch_item.h:453
SCH_CONNECTION * Connection(const SCH_SHEET_PATH *aSheet=nullptr) const
Retrieve the connection associated with this object in the given sheet.
Definition: sch_item.cpp:147
virtual std::vector< VECTOR2I > GetConnectionPoints() const
Add all the connection points for this item to aPoints.
Definition: sch_item.h:404
Segment description base class to describe items which have 2 end points (track, wire,...
Definition: sch_line.h:40
Container to create a flattened list of symbols because in a complex hierarchy, a symbol can be used ...
void SortByReferenceOnly()
Sort the list of references by reference.
size_t GetCount() const
void AddItem(const SCH_REFERENCE &aItem)
A helper to define a symbol's reference designator in a schematic.
void SetSheetNumber(int aSheetNumber)
Container class that holds multiple SCH_SCREEN objects in a hierarchy.
Definition: sch_screen.h:704
SCH_SCREEN * GetNext()
void UpdateSymbolLinks(REPORTER *aReporter=nullptr)
Initialize the LIB_SYMBOL reference for each SCH_SYMBOL found in the full schematic.
SCH_SCREEN * GetFirst()
void PruneOrphanedSheetInstances(const wxString &aProjectName, const SCH_SHEET_LIST &aValidSheetPaths)
void PruneOrphanedSymbolInstances(const wxString &aProjectName, const SCH_SHEET_LIST &aValidSheetPaths)
bool HasNoFullyDefinedLibIds()
Test all of the schematic symbols to see if all LIB_ID objects library nickname is not set.
void Append(SCH_ITEM *aItem, bool aUpdateLibSymbol=true)
Definition: sch_screen.cpp:150
void Clear(bool aFree=true)
Delete all draw items and clears the project settings.
Definition: sch_screen.cpp:275
void UpdateSymbolLinks(REPORTER *aReporter=nullptr)
Initialize the LIB_SYMBOL reference for each SCH_SYMBOL found in this schematic from the project SYMB...
Definition: sch_screen.cpp:880
const std::map< wxString, LIB_SYMBOL * > & GetLibSymbols() const
Fetch a list of unique LIB_SYMBOL object pointers required to properly render each SCH_SYMBOL in this...
Definition: sch_screen.h:481
double m_LastZoomLevel
last value for the zoom level, useful in Eeschema when changing the current displayed sheet to reuse ...
Definition: sch_screen.h:628
EE_RTREE & Items()
Gets the full RTree, usually for iterating.
Definition: sch_screen.h:109
const wxString & GetFileName() const
Definition: sch_screen.h:144
bool Remove(SCH_ITEM *aItem, bool aUpdateLibSymbol=true)
Remove aItem from the schematic associated with this screen.
Definition: sch_screen.cpp:320
bool CheckIfOnDrawList(const SCH_ITEM *aItem) const
Definition: sch_screen.cpp:383
void MigrateSimModels()
Migrate any symbols having V6 simulation models to their V7 equivalents.
VECTOR2I GetCenter() const
Definition: sch_shape.h:80
A container for handling SCH_SHEET_PATH objects in a flattened hierarchy.
void FillItemMap(std::map< KIID, EDA_ITEM * > &aMap)
Fill an item cache for temporary use when many items need to be fetched.
void SortByPageNumbers(bool aUpdateVirtualPageNums=true)
Sort the list of sheets by page number.
bool NameExists(const wxString &aSheetName) const
SCH_SHEET_LIST FindAllSheetsForScreen(const SCH_SCREEN *aScreen) const
Return a SCH_SHEET_LIST with a copy of all the SCH_SHEET_PATH using a particular screen.
void GetSymbols(SCH_REFERENCE_LIST &aReferences, bool aIncludePowerSymbols=true, bool aForceIncludeOrphanSymbols=false) const
Add a SCH_REFERENCE object to aReferences for each symbol in the list of sheets.
bool PageNumberExists(const wxString &aPageNumber) const
bool ContainsSheet(const SCH_SHEET *aSheet) const
bool HasPath(const KIID_PATH &aPath) const
bool TestForRecursion(const SCH_SHEET_LIST &aSrcSheetHierarchy, const wxString &aDestFileName)
Test every SCH_SHEET_PATH in this SCH_SHEET_LIST to verify if adding the sheets stored in aSrcSheetHi...
Handle access to a stack of flattened SCH_SHEET objects by way of a path for creating a flattened sch...
void GetSymbols(SCH_REFERENCE_LIST &aReferences, bool aIncludePowerSymbols=true, bool aForceIncludeOrphanSymbols=false) const
Adds SCH_REFERENCE object to aReferences for each symbol in the sheet.
KIID_PATH Path() const
Get the sheet path as an KIID_PATH.
void UpdateAllScreenReferences() const
Update all the symbol references for this sheet path.
SCH_SCREEN * LastScreen()
SCH_SHEET * Last() const
Return a pointer to the last SCH_SHEET of the list.
void push_back(SCH_SHEET *aSheet)
Forwarded method from std::vector.
Define a sheet pin (label) used in sheets to create hierarchical schematics.
Definition: sch_sheet_pin.h:66
Sheet symbol placed in a schematic, and is the entry point for a sub schematic.
Definition: sch_sheet.h:57
wxString GetFileName() const
Return the filename corresponding to this sheet.
Definition: sch_sheet.h:308
void RemoveInstance(const KIID_PATH &aInstancePath)
Definition: sch_sheet.cpp:1277
std::vector< SCH_FIELD > & GetFields()
Definition: sch_sheet.h:93
bool SearchHierarchy(const wxString &aFilename, SCH_SCREEN **aScreen)
Search the existing hierarchy for an instance of screen loaded from aFileName.
Definition: sch_sheet.cpp:728
void AddInstance(const SCH_SHEET_INSTANCE &aInstance)
Definition: sch_sheet.cpp:1298
SCH_SCREEN * GetScreen() const
Definition: sch_sheet.h:110
void SetScreen(SCH_SCREEN *aScreen)
Set the SCH_SCREEN associated with this sheet to aScreen.
Definition: sch_sheet.cpp:162
std::vector< SCH_SHEET_PIN * > & GetPins()
Definition: sch_sheet.h:181
const std::vector< SCH_SHEET_INSTANCE > & GetInstances() const
Definition: sch_sheet.h:392
Schematic symbol object.
Definition: sch_symbol.h:109
const std::vector< SCH_SYMBOL_INSTANCE > & GetInstances() const
Definition: sch_symbol.h:168
int GetUnit() const
Definition: sch_symbol.h:258
wxString GetSchSymbolLibraryName() const
Definition: sch_symbol.cpp:296
const wxString GetRef(const SCH_SHEET_PATH *aSheet, bool aIncludeUnit=false) const
Return the reference for the given sheet path.
Definition: sch_symbol.cpp:751
SCH_FIELD * GetField(MANDATORY_FIELD_T aFieldType)
Return a mandatory field in this symbol.
Definition: sch_symbol.cpp:953
void ClearAnnotation(const SCH_SHEET_PATH *aSheetPath, bool aResetPrefix)
Clear exiting symbol annotation.
std::vector< SCH_PIN * > GetPins(const SCH_SHEET_PATH *aSheet=nullptr) const
Retrieve a list of the SCH_PINs for the given sheet path.
void AddHierarchicalReference(const KIID_PATH &aPath, const wxString &aRef, int aUnit)
Add a full hierarchical reference to this symbol.
Definition: sch_symbol.cpp:649
bool IsMissingLibSymbol() const
Check to see if the library symbol is set to the dummy library symbol.
Definition: sch_symbol.cpp:245
void SetUnit(int aUnit)
Change the unit number to aUnit.
Definition: sch_symbol.cpp:455
const LIB_ID & GetLibId() const
Definition: sch_symbol.h:203
void GetFields(std::vector< SCH_FIELD * > &aVector, bool aVisibleOnly)
Populate a std::vector with SCH_FIELDs.
std::unique_ptr< LIB_SYMBOL > & GetLibSymbolRef()
Definition: sch_symbol.h:222
void SetLibSymbol(LIB_SYMBOL *aLibSymbol)
Set this schematic symbol library symbol reference to aLibSymbol.
Definition: sch_symbol.cpp:305
int GetBodyStyle() const
Definition: sch_symbol.h:300
bool IsPower() const
void BrightenItem(EDA_ITEM *aItem)
void UnbrightenItem(EDA_ITEM *aItem)
const VECTOR2I & CVertex(int aIndex, int aOutline, int aHole) const
Return the index-th vertex in a given hole outline within a given outline.
The SIMULATOR_FRAME holds the main user-interface for running simulations.
SIM_MODEL & CreateModel(SIM_MODEL::TYPE aType, const std::vector< LIB_PIN * > &aPins, REPORTER &aReporter)
int FindModelPinIndex(const std::string &aSymbolPinNumber)
Definition: sim_model.cpp:725
const SPICE_GENERATOR & SpiceGenerator() const
Definition: sim_model.h:440
virtual std::vector< std::string > CurrentNames(const SPICE_ITEM &aItem) const
Implement an OUTPUTFORMATTER to a memory buffer.
Definition: richio.h:433
const std::string & GetString()
Definition: richio.h:456
Is a LINE_READER that reads from a multiline 8 bit wide std::string.
Definition: richio.h:253
The symbol library editor main window.
void LoadSymbol(const wxString &aLibrary, const wxString &aSymbol, int Unit)
bool IsSymbolTreeShown() const
void OnToggleSymbolTree(wxCommandEvent &event)
void LoadSymbolFromSchematic(SCH_SYMBOL *aSymbol)
Load a symbol from the schematic to edit in place.
Class to handle modifications to the symbol libraries.
bool CreateLibrary(const wxString &aFilePath, SYMBOL_LIB_TABLE *aTable)
Create an empty library and adds it to the library table.
SYMBOL_LIB_TABLE_ROW * GetLibrary(const wxString &aLibrary) const
Find a single library within the (aggregate) library table.
Hold a record identifying a symbol library accessed by the appropriate symbol library SCH_IO object i...
const wxString GetType() const override
Return the type of symbol library table represented by this row.
static SYMBOL_LIB_TABLE & GetGlobalLibTable()
static const wxString & GetSymbolLibTableFileName()
static wxString GetGlobalTableFileName()
Fetch the global symbol library table file name.
SYMBOL_LIB_TABLE_ROW * FindRow(const wxString &aNickName, bool aCheckIfEnabled=false)
Return an SYMBOL_LIB_TABLE_ROW if aNickName is found in this table or in any chained fallBack table f...
Symbol library viewer main window.
KIGFX::VIEW_CONTROLS * getViewControls() const
Return the instance of VIEW_CONTROLS object used in the application.
Definition: tool_base.cpp:42
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:216
KIGFX::VIEW * getView() const
Returns the instance of #VIEW object used in the application.
Definition: tool_base.cpp:36
Generic, UI-independent tool event.
Definition: tool_event.h:167
bool DisableGridSnapping() const
Definition: tool_event.h:363
bool IsAction(const TOOL_ACTION *aAction) const
Test if the event contains an action issued upon activation of the given TOOL_ACTION.
Definition: tool_event.cpp:82
T Parameter() const
Return a parameter assigned to the event.
Definition: tool_event.h:460
void Go(int(T::*aStateFunc)(const TOOL_EVENT &), const TOOL_EVENT_LIST &aConditions=TOOL_EVENT(TC_ANY, TA_ANY))
Define which state (aStateFunc) to go when a certain event arrives (aConditions).
void Activate()
Run the tool.
Master controller class:
Definition: tool_manager.h:57
bool ProcessEvent(const TOOL_EVENT &aEvent)
Propagate an event to tools that requested events of matching type(s).
bool RunAction(const std::string &aActionName, T aParam)
Run the specified action immediately, pausing the current action to run the new one.
Definition: tool_manager.h:145
std::string GetClipboardUTF8() const
Return the information currently stored in the system clipboard.
TOOLS_HOLDER * GetToolHolder() const
Definition: tool_manager.h:389
APP_SETTINGS_BASE * GetSettings() const
Definition: tool_manager.h:387
bool PostAction(const std::string &aActionName, T aParam)
Run the specified action after the current action (coroutine) ends.
Definition: tool_manager.h:230
bool SaveClipboard(const std::string &aTextUTF8)
Store information to the system clipboard.
bool RunSynchronousAction(const TOOL_ACTION &aAction, COMMIT *aCommit, T aParam)
Run the specified action immediately, pausing the current action to run the new one.
Definition: tool_manager.h:192
A wrapper for reporting to a wxString object.
Definition: reporter.h:164
bool HasMessage() const override
Returns true if the reporter client is non-empty.
Definition: reporter.cpp:71
wxString EnsureFileExtension(const wxString &aFilename, const wxString &aExtension)
It's annoying to throw up nag dialogs when the extension isn't right.
Definition: common.cpp:415
bool IsOK(wxWindow *aParent, const wxString &aMessage)
Display a yes/no dialog with aMessage and returns the user response.
Definition: confirm.cpp:360
void DisplayError(wxWindow *aParent, const wxString &aText, int aDisplayTime)
Display an error or warning message box with aMessage.
Definition: confirm.cpp:280
void DisplayInfoMessage(wxWindow *aParent, const wxString &aMessage, const wxString &aExtraInfo)
Display an informational message box with aMessage.
Definition: confirm.cpp:332
void DisplayErrorMessage(wxWindow *aParent, const wxString &aText, const wxString &aExtraInfo)
Display an error message with aMessage.
Definition: confirm.cpp:305
This file is part of the common library.
int InvokeDialogCreateBOM(SCH_EDIT_FRAME *aCaller)
Create and show DIALOG_BOM and return whatever DIALOG_BOM::ShowModal() returns.
Definition: dialog_bom.cpp:110
bool InvokeDialogEditSymbolsLibId(SCH_EDIT_FRAME *aCaller)
Run a dialog to modify the LIB_ID of symbols for instance when a symbol has moved from a symbol libra...
int InvokeDialogNetList(SCH_EDIT_FRAME *aCaller)
#define _(s)
std::vector< EDA_ITEM * > EDA_ITEMS
Define list of drawing items for screens.
Definition: eda_item.h:529
#define IS_PASTED
Modifier on IS_NEW which indicates it came from clipboard.
#define IS_NEW
New item, just created.
#define ENDPOINT
ends. (Used to support dragging.)
#define IS_MOVING
Item being moved.
#define STARTPOINT
When a line is selected, these flags indicate which.
#define HITTEST_THRESHOLD_PIXELS
LINE_MODE
@ FRAME_SCH_SYMBOL_EDITOR
Definition: frame_type.h:35
@ FRAME_SCH_VIEWER
Definition: frame_type.h:36
@ FRAME_SIMULATOR
Definition: frame_type.h:38
static const std::string KiCadSchematicFileExtension
static const std::string KiCadSymbolLibFileExtension
static wxString KiCadSymbolLibFileWildcard()
static wxString KiCadSchematicFileWildcard()
static const wxChar traceSchPaste[]
Flag to enable schematic paste debugging output.
int InvokeDialogPrintUsingPrinter(SCH_EDIT_FRAME *aCaller)
Create and show DIALOG_PRINT_USING_PRINTER and return whatever DIALOG_PRINT_USING_PRINTER::ShowModal(...
#define NET_PLUGIN_CHANGE
Create and shows DIALOG_EXPORT_NETLIST and returns whatever DIALOG_EXPORT_NETLIST::ShowModal() return...
std::unique_ptr< T > IO_RELEASER
Helper to hold and release an IO_BASE object when exceptions are thrown.
Definition: io_mgr.h:33
#define THROW_IO_ERROR(msg)
Definition: ki_exception.h:39
#define KICTL_REVERT
reverting to a previously-saved (KiCad) file.
Definition: kiway_player.h:80
@ LAYER_ERC_WARN
Definition: layer_ids.h:381
@ LAYER_ERC_EXCLUSION
Definition: layer_ids.h:383
@ LAYER_ERC_ERR
Definition: layer_ids.h:382
@ LAYER_OP_CURRENTS
Definition: layer_ids.h:400
@ LAYER_OP_VOLTAGES
Definition: layer_ids.h:399
@ REPAINT
Item needs to be redrawn.
Definition: view_item.h:57
@ GEOMETRY
Position or shape has changed.
Definition: view_item.h:54
#define MAX_PAGE_SIZE_EESCHEMA_MILS
Definition: page_info.h:40
see class PGM_BASE
@ LOCAL_CLEANUP
@ NO_CLEANUP
@ GLOBAL_CLEANUP
static bool highlightNet(TOOL_MANAGER *aToolMgr, const VECTOR2D &aPosition)
static VECTOR2D CLEAR
ANNOTATE_ORDER_T
Schematic annotation order options.
ANNOTATE_ALGO_T
Schematic annotation type options.
@ SHEETNAME
Definition: sch_sheet.h:45
Definition of the SCH_SHEET_PATH and SCH_SHEET_LIST classes for Eeschema.
KIWAY Kiway & Pgm(), KFCTL_STANDALONE
The global Program "get" accessor.
Definition: single_top.cpp:119
std::vector< FAB_LAYER_COLOR > dummy
wxString UnescapeString(const wxString &aSource)
std::vector< GRID > grids
Definition: grid_settings.h:66
Common grid settings, available to every frame.
Definition: grid_settings.h:34
A simple container for sheet instance information.
A simple container for schematic symbol instance information.
static constexpr auto NOT_CONNECTED
Definition: sim_model.h:311
std::string refName
GRID_SETTINGS grid
Definition: app_settings.h:81
Definition for symbol library class.
@ VALUE_FIELD
Field Value of part, i.e. "3.3K".
@ REFERENCE_FIELD
Field Reference of part, i.e. "IC21".
@ AS_GLOBAL
Global action (toolbar/main menu event, global shortcut)
Definition: tool_action.h:48
@ TA_UNDO_REDO_PRE
Definition: tool_event.h:105
@ TC_MESSAGE
Definition: tool_event.h:57
double EuclideanNorm(const VECTOR2I &vector)
Definition: trigo.h:128
@ SCH_LINE_T
Definition: typeinfo.h:148
@ SCH_SYMBOL_T
Definition: typeinfo.h:160
@ SCH_FIELD_T
Definition: typeinfo.h:159
@ SCH_SHEET_T
Definition: typeinfo.h:162
@ SCH_MARKER_T
Definition: typeinfo.h:143
@ SCH_SHAPE_T
Definition: typeinfo.h:149
@ SCH_PIN_T
Definition: typeinfo.h:163
constexpr ret_type KiROUND(fp_type v)
Round a floating point number to an integer using "round halfway cases away from zero".
Definition: util.h:85
VECTOR2< int > VECTOR2I
Definition: vector2d.h:588
Definition of file extensions used in Kicad.
#define FN_NORMALIZE_FLAGS
Default flags to pass to wxFileName::Normalize().
Definition: wx_filename.h:39