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/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>
76#include <view/view_controls.h>
78#include <wx_filename.h>
79#include <sch_sheet_path.h>
80#include <wx/filedlg.h>
81#include <wx/log.h>
82#include <wx/treectrl.h>
83#include <wx/msgdlg.h>
84#include "sch_edit_table_tool.h"
85
86#ifdef KICAD_IPC_API
88#endif
89
90
96static const wxChar traceSchPaste[] = wxT( "KICAD_SCH_PASTE" );
97
98
100{
102 return 0;
103}
104
105
107{
109 return 0;
110}
111
112
114{
116 return 0;
117}
118
119
121{
122 m_frame->SaveProject( true );
123 return 0;
124}
125
126
128{
129 SCH_SHEET* curr_sheet = m_frame->GetCurrentSheet().Last();
130 wxFileName curr_fn = curr_sheet->GetFileName();
131 wxFileDialog dlg( m_frame, _( "Schematic Files" ), curr_fn.GetPath(), curr_fn.GetFullName(),
133 wxFD_SAVE | wxFD_OVERWRITE_PROMPT );
134
135 if( dlg.ShowModal() == wxID_CANCEL )
136 return false;
137
138 wxString newFilename =
140
141 m_frame->saveSchematicFile( curr_sheet, newFilename );
142 return 0;
143}
144
145
147{
148 SCHEMATIC& schematic = m_frame->Schematic();
149 SCH_SHEET& root = schematic.Root();
150
151 if( m_frame->GetCurrentSheet().Last() != &root )
152 {
155
156 // Store the current zoom level into the current screen before switching
158
159 SCH_SHEET_PATH rootSheetPath;
160 rootSheetPath.push_back( &root );
161 m_frame->SetCurrentSheet( rootSheetPath );
163
164 wxSafeYield();
165 }
166
167 wxString msg;
168 msg.Printf( _( "Revert '%s' (and all sub-sheets) to last version saved?" ),
169 schematic.GetFileName() );
170
171 if( !IsOK( m_frame, msg ) )
172 return false;
173
174 SCH_SCREENS screenList( schematic.Root() );
175
176 for( SCH_SCREEN* screen = screenList.GetFirst(); screen; screen = screenList.GetNext() )
177 screen->SetContentModified( false ); // do not prompt the user for changes
178
180 m_frame->OpenProjectFiles( std::vector<wxString>( 1, schematic.GetFileName() ), KICTL_REVERT );
181
182 return 0;
183}
184
185
187{
189 return 0;
190}
191
192
194{
195 PICKED_ITEMS_LIST undoCmd;
197 ITEM_PICKER wrapper( m_frame->GetScreen(), undoItem, UNDO_REDO::PAGESETTINGS );
198
199 undoCmd.PushItem( wrapper );
200 undoCmd.SetDescription( _( "Page Settings" ) );
201 m_frame->SaveCopyInUndoList( undoCmd, UNDO_REDO::PAGESETTINGS, false, false );
202
206
207 if( dlg.ShowModal() == wxID_OK )
208 {
209 // Update text variables
213
214 m_frame->OnModify();
215 }
216 else
217 {
219 }
220
221 return 0;
222}
223
224
226{
227 SCH_SCREENS schematic( m_frame->Schematic().Root() );
228
229 if( schematic.HasNoFullyDefinedLibIds() )
230 RescueLegacyProject( true );
231 else
233
234 return 0;
235}
236
237
238bool SCH_EDITOR_CONTROL::RescueLegacyProject( bool aRunningOnDemand )
239{
242
243 return rescueProject( rescuer, aRunningOnDemand );
244}
245
246
248{
252
253 return rescueProject( rescuer, aRunningOnDemand );
254}
255
256
257bool SCH_EDITOR_CONTROL::rescueProject( RESCUER& aRescuer, bool aRunningOnDemand )
258{
259 if( !RESCUER::RescueProject( m_frame, aRescuer, aRunningOnDemand ) )
260 return false;
261
262 if( aRescuer.GetCandidateCount() )
263 {
264 KIWAY_PLAYER* viewer = m_frame->Kiway().Player( FRAME_SCH_VIEWER, false );
265
266 if( viewer )
267 static_cast<SYMBOL_VIEWER_FRAME*>( viewer )->ReCreateLibList();
268
269 if( aRunningOnDemand )
270 {
271 SCH_SCREENS schematic( m_frame->Schematic().Root() );
272
273 schematic.UpdateSymbolLinks();
275 }
276
278 m_frame->SyncView();
280 m_frame->OnModify();
281 }
282
283 return true;
284}
285
286
288{
289 DIALOG_SYMBOL_REMAP dlgRemap( m_frame );
290
291 dlgRemap.ShowQuasiModal();
292
293 m_frame->GetCanvas()->Refresh( true );
294
295 return 0;
296}
297
298
300{
302 return 0;
303}
304
305
307{
309
310 dlg.ShowModal();
311
312 // save project config if the prj config has changed:
313 if( dlg.PrjConfigChanged() )
314 m_frame->OnModify();
315
316 return 0;
317}
318
319
321{
322 m_frame->Close( false );
323 return 0;
324}
325
326
328{
329 doCrossProbeSchToPcb( aEvent, false );
330 return 0;
331}
332
333
335{
336 doCrossProbeSchToPcb( aEvent, true );
337 return 0;
338}
339
340
341void SCH_EDITOR_CONTROL::doCrossProbeSchToPcb( const TOOL_EVENT& aEvent, bool aForce )
342{
343 // Don't get in an infinite loop SCH -> PCB -> SCH -> PCB -> SCH -> ...
345 return;
346
348
349 EE_SELECTION& selection = aForce ? selTool->RequestSelection() : selTool->GetSelection();
350
351 m_frame->SendSelectItemsToPcb( selection.GetItemsSortedBySelectionOrder(), aForce );
352}
353
354
356{
357 bool savePowerSymbols = IsOK( m_frame,
358 _( "Include power symbols in schematic to the library?" ) );
359
360 bool createNew = aEvent.IsAction( &EE_ACTIONS::exportSymbolsToNewLibrary );
361
362 SCH_REFERENCE_LIST symbols;
363 m_frame->Schematic().GetSheets().GetSymbols( symbols, savePowerSymbols );
364
365 std::map<LIB_ID, LIB_SYMBOL*> libSymbols;
366 std::map<LIB_ID, std::vector<SCH_SYMBOL*>> symbolMap;
367
368 for( size_t i = 0; i < symbols.GetCount(); ++i )
369 {
370 SCH_SYMBOL* symbol = symbols[i].GetSymbol();
371 LIB_SYMBOL* libSymbol = symbol->GetLibSymbolRef().get();
372 LIB_ID id = libSymbol->GetLibId();
373
374 if( libSymbols.count( id ) )
375 {
376 wxASSERT_MSG( libSymbols[id]->Compare( *libSymbol, SCH_ITEM::COMPARE_FLAGS::ERC ) == 0,
377 "Two symbols have the same LIB_ID but are different!" );
378 }
379 else
380 {
381 libSymbols[id] = libSymbol;
382 }
383
384 symbolMap[id].emplace_back( symbol );
385 }
386
388
389 wxString targetLib;
390
391 if( createNew )
392 {
393 wxFileName fn;
395
396 if( !libTable ) // Cancelled by user
397 return 0;
398
401 ( libTable == &SYMBOL_LIB_TABLE::GetGlobalLibTable() ),
403 {
404 return 0;
405 }
406
407 targetLib = fn.GetName();
408
409 if( libTable->HasLibrary( targetLib, false ) )
410 {
411 DisplayError( m_frame, wxString::Format( _( "Library '%s' already exists." ),
412 targetLib ) );
413 return 0;
414 }
415
416 // if the "new" library is in fact an existing library and the used asked for replacing
417 // it by the recreated lib, erase it:
418 if( fn.FileExists() )
419 wxRemoveFile( fn.GetFullPath() );
420
421 if( !mgr.CreateLibrary( fn.GetFullPath(), libTable ) )
422 {
423 DisplayError( m_frame, wxString::Format( _( "Could not add library '%s'." ),
424 targetLib ) );
425 return 0;
426 }
427 }
428 else
429 {
430 targetLib = m_frame->SelectLibraryFromList();
431 }
432
433 if( targetLib.IsEmpty() )
434 return 0;
435
436 bool map = IsOK( m_frame, _( "Update symbols in schematic to refer to new library?" ) );
437 bool append = false;
438
439 SYMBOL_LIB_TABLE_ROW* row = mgr.GetLibrary( targetLib );
440 SCH_IO_MGR::SCH_FILE_T type = SCH_IO_MGR::EnumFromStr( row->GetType() );
441 IO_RELEASER<SCH_IO> pi( SCH_IO_MGR::FindPlugin( type ) );
442
443 wxFileName dest = row->GetFullURI( true );
444 dest.Normalize( FN_NORMALIZE_FLAGS | wxPATH_NORM_ENV_VARS );
445
446 for( const std::pair<const LIB_ID, LIB_SYMBOL*>& it : libSymbols )
447 {
448 LIB_SYMBOL* origSym = it.second;
449 LIB_SYMBOL* newSym = origSym->Flatten().release();
450
451 try
452 {
453 pi->SaveSymbol( dest.GetFullPath(), newSym );
454 }
455 catch( const IO_ERROR& ioe )
456 {
457 wxString msg;
458 msg.Printf( _( "Error saving symbol %s to library '%s'." ),
459 newSym->GetName(), row->GetNickName() );
460 msg += wxS( "\n\n" ) + ioe.What();
461 wxLogWarning( msg );
462 return 0;
463 }
464
465 if( map )
466 {
467 LIB_ID id = it.first;
468 id.SetLibNickname( targetLib );
469
470 for( SCH_SYMBOL* symbol : symbolMap[it.first] )
471 {
472 m_frame->SaveCopyInUndoList( m_frame->GetScreen(), symbol, UNDO_REDO::CHANGED,
473 append, false );
474 symbol->SetLibId( id );
475 append = true;
476 }
477 }
478 }
479
480 // Save the modified symbol library table. We need to look this up by name in each table to find
481 // whether the new library is a global or project entity as the code above to choose the library
482 // returns a different type depending on whether a global or project library is chosen.
484 SYMBOL_LIB_TABLE* projectTable = nullptr;
485
486 if( !m_frame->Prj().IsNullProject() )
487 projectTable = PROJECT_SCH::SchSymbolLibTable( &m_frame->Prj() );
488
489 if( globalTable->FindRow( targetLib ) )
490 {
491 try
492 {
493 wxString globalTablePath = SYMBOL_LIB_TABLE::GetGlobalTableFileName();
494 globalTable->Save( globalTablePath );
495 }
496 catch( const IO_ERROR& ioe )
497 {
498 wxString msg;
499 msg.Printf( _( "Error saving global library table:\n\n%s" ), ioe.What() );
500 wxMessageBox( msg, _( "File Save Error" ), wxOK | wxICON_ERROR );
501 }
502 }
503 else if( projectTable && projectTable->FindRow( targetLib ) )
504 {
505 try
506 {
507 wxString projectPath = m_frame->Prj().GetProjectPath();
508 wxFileName projectTableFn( projectPath, SYMBOL_LIB_TABLE::GetSymbolLibTableFileName() );
509 projectTable->Save( projectTableFn.GetFullPath() );
510 }
511 catch( const IO_ERROR& ioe )
512 {
513 wxString msg;
514 msg.Printf( _( "Error saving project-specific library table:\n\n%s" ), ioe.What() );
515 wxMessageBox( msg, _( "File Save Error" ), wxOK | wxICON_ERROR );
516 }
517 }
518
519 if( append )
520 {
521 std::set<SCH_SCREEN*> processedScreens;
523
524 for( SCH_SHEET_PATH& sheet : sheets )
525 {
526 SCH_SCREEN* screen = sheet.LastScreen();
527
528 if( processedScreens.find( ( screen ) ) == processedScreens.end() )
529 {
530 processedScreens.insert( screen );
531 screen->UpdateSymbolLinks();
532 }
533 }
534
535 m_frame->OnModify();
536 }
537
538 return 0;
539}
540
541
542#define HITTEST_THRESHOLD_PIXELS 5
543
545{
547 KIWAY_PLAYER* player = m_frame->Kiway().Player( FRAME_SIMULATOR, false );
548 SIMULATOR_FRAME* simFrame = static_cast<SIMULATOR_FRAME*>( player );
549
550 if( !simFrame ) // Defensive coding; shouldn't happen.
551 return 0;
552
553 if( wxWindow* blocking_win = simFrame->Kiway().GetBlockingDialog() )
554 blocking_win->Close( true );
555
556 // Deactivate other tools; particularly important if another PICKER is currently running
557 Activate();
558
559 picker->SetCursor( KICURSOR::VOLTAGE_PROBE );
560 picker->SetSnapping( false );
561
562 picker->SetClickHandler(
563 [this, simFrame]( const VECTOR2D& aPosition )
564 {
566 EDA_ITEM* item = selTool->GetNode( aPosition );
568
569 if( !item )
570 return false;
571
572 if( item->Type() == SCH_PIN_T )
573 {
574 try
575 {
576 SCH_PIN* pin = static_cast<SCH_PIN*>( item )->GetLibPin();
577 SCH_SYMBOL* symbol = static_cast<SCH_SYMBOL*>( item->GetParent() );
578
579 wxString msg;
580 WX_STRING_REPORTER reporter( &msg );
581 SIM_LIB_MGR mgr( &m_frame->Prj() );
582
583 SIM_MODEL& model = mgr.CreateModel( &sheet, *symbol, reporter ).model;
584
585 if( reporter.HasMessage() )
586 THROW_IO_ERROR( msg );
587
588 SPICE_ITEM spiceItem;
589 spiceItem.refName = symbol->GetRef( &sheet ).ToStdString();
590 std::vector<std::string> currentNames =
591 model.SpiceGenerator().CurrentNames( spiceItem );
592
593 if( currentNames.size() == 0 )
594 {
595 return true;
596 }
597 else if( currentNames.size() == 1 )
598 {
599 simFrame->AddCurrentTrace( currentNames.at( 0 ) );
600 return true;
601 }
602
603 int modelPinIndex = model.FindModelPinIndex( pin->GetNumber().ToStdString() );
604
605 if( modelPinIndex != SIM_MODEL_PIN::NOT_CONNECTED )
606 {
607 wxString name = currentNames.at( modelPinIndex );
608 simFrame->AddCurrentTrace( name );
609 }
610 }
611 catch( const IO_ERROR& e )
612 {
614 }
615 }
616 else if( item->IsType( { SCH_ITEM_LOCATE_WIRE_T } )
617 || item->IsType( { SCH_JUNCTION_T } ) )
618 {
619 if( SCH_CONNECTION* conn = static_cast<SCH_ITEM*>( item )->Connection() )
620 {
621 std::string spiceNet = UnescapeString( conn->Name() ).ToStdString();
623
624 simFrame->AddVoltageTrace( wxString::Format( "V(%s)", spiceNet ) );
625 }
626 }
627
628 return true;
629 } );
630
631 picker->SetMotionHandler(
632 [this, picker]( const VECTOR2D& aPos )
633 {
634 EE_COLLECTOR collector;
635 collector.m_Threshold = KiROUND( getView()->ToWorld( HITTEST_THRESHOLD_PIXELS ) );
636 collector.Collect( m_frame->GetScreen(), { SCH_ITEM_LOCATE_WIRE_T,
637 SCH_PIN_T,
638 SCH_SHEET_PIN_T }, aPos );
639
641 selectionTool->GuessSelectionCandidates( collector, aPos );
642
643 EDA_ITEM* item = collector.GetCount() == 1 ? collector[ 0 ] : nullptr;
644 SCH_LINE* wire = dynamic_cast<SCH_LINE*>( item );
645
646 const SCH_CONNECTION* conn = nullptr;
647
648 if( wire )
649 {
650 item = nullptr;
651 conn = wire->Connection();
652 }
653
654 if( item && item->Type() == SCH_PIN_T )
655 picker->SetCursor( KICURSOR::CURRENT_PROBE );
656 else
657 picker->SetCursor( KICURSOR::VOLTAGE_PROBE );
658
659 if( m_pickerItem != item )
660 {
661 if( m_pickerItem )
662 selectionTool->UnbrightenItem( m_pickerItem );
663
664 m_pickerItem = item;
665
666 if( m_pickerItem )
667 selectionTool->BrightenItem( m_pickerItem );
668 }
669
670 wxString connectionName = ( conn ) ? conn->Name() : wxString( wxS( "" ) );
671
672 if( m_frame->GetHighlightedConnection() != connectionName )
673 {
674 m_frame->SetHighlightedConnection( connectionName );
675
676 TOOL_EVENT dummyEvent;
677 UpdateNetHighlighting( dummyEvent );
678 }
679 } );
680
681 picker->SetFinalizeHandler(
682 [this]( const int& aFinalState )
683 {
684 if( m_pickerItem )
685 m_toolMgr->GetTool<EE_SELECTION_TOOL>()->UnbrightenItem( m_pickerItem );
686
687 if( !m_frame->GetHighlightedConnection().IsEmpty() )
688 {
689 m_frame->SetHighlightedConnection( wxEmptyString );
690
691 TOOL_EVENT dummyEvent;
692 UpdateNetHighlighting( dummyEvent );
693 }
694
695 // Wake the selection tool after exiting to ensure the cursor gets updated
697 } );
698
700
701 return 0;
702}
703
704
706{
708
709 // Deactivate other tools; particularly important if another PICKER is currently running
710 Activate();
711
712 picker->SetCursor( KICURSOR::TUNE );
713 picker->SetSnapping( false );
714
715 picker->SetClickHandler(
716 [this]( const VECTOR2D& aPosition )
717 {
719 EDA_ITEM* item = nullptr;
720 selTool->SelectPoint( aPosition, { SCH_SYMBOL_T, SCH_FIELD_T }, &item );
721
722 if( !item )
723 return false;
724
725 if( item->Type() != SCH_SYMBOL_T )
726 {
727 item = item->GetParent();
728
729 if( item->Type() != SCH_SYMBOL_T )
730 return false;
731 }
732
733 SCH_SYMBOL* symbol = static_cast<SCH_SYMBOL*>( item );
734 SCH_SHEET_PATH sheetPath = symbol->Schematic()->CurrentSheet();
735 KIWAY_PLAYER* simFrame = m_frame->Kiway().Player( FRAME_SIMULATOR, false );
736
737 if( simFrame )
738 {
739 if( wxWindow* blocking_win = simFrame->Kiway().GetBlockingDialog() )
740 blocking_win->Close( true );
741
742 static_cast<SIMULATOR_FRAME*>( simFrame )->AddTuner( sheetPath, symbol );
743 }
744
745 // We do not really want to keep a symbol selected in schematic,
746 // so clear the current selection
747 selTool->ClearSelection();
748 return true;
749 } );
750
751 picker->SetMotionHandler(
752 [this]( const VECTOR2D& aPos )
753 {
754 EE_COLLECTOR collector;
755 collector.m_Threshold = KiROUND( getView()->ToWorld( HITTEST_THRESHOLD_PIXELS ) );
756 collector.Collect( m_frame->GetScreen(), { SCH_SYMBOL_T, SCH_FIELD_T }, aPos );
757
759 selectionTool->GuessSelectionCandidates( collector, aPos );
760
761 EDA_ITEM* item = collector.GetCount() == 1 ? collector[ 0 ] : nullptr;
762
763 if( m_pickerItem != item )
764 {
765 if( m_pickerItem )
766 selectionTool->UnbrightenItem( m_pickerItem );
767
768 m_pickerItem = item;
769
770 if( m_pickerItem )
771 selectionTool->BrightenItem( m_pickerItem );
772 }
773 } );
774
775 picker->SetFinalizeHandler(
776 [this]( const int& aFinalState )
777 {
778 if( m_pickerItem )
779 m_toolMgr->GetTool<EE_SELECTION_TOOL>()->UnbrightenItem( m_pickerItem );
780
781 // Wake the selection tool after exiting to ensure the cursor gets updated
782 // and deselect previous selection from simulator to avoid any issue
783 // ( avoid crash in some cases when the SimTune tool is deselected )
785 selectionTool->ClearSelection();
787 } );
788
790
791 return 0;
792}
793
794
795// A singleton reference for clearing the highlight
797
798
799static bool highlightNet( TOOL_MANAGER* aToolMgr, const VECTOR2D& aPosition )
800{
801 SCH_EDIT_FRAME* editFrame = static_cast<SCH_EDIT_FRAME*>( aToolMgr->GetToolHolder() );
802 EE_SELECTION_TOOL* selTool = aToolMgr->GetTool<EE_SELECTION_TOOL>();
803 SCH_EDITOR_CONTROL* editorControl = aToolMgr->GetTool<SCH_EDITOR_CONTROL>();
804 SCH_CONNECTION* conn = nullptr;
805 SCH_ITEM* item = nullptr;
806 bool retVal = true;
807
808 if( aPosition != CLEAR )
809 {
810 ERC_TESTER erc( &editFrame->Schematic() );
811
812 if( erc.TestDuplicateSheetNames( false ) > 0 )
813 {
814 wxMessageBox( _( "Error: duplicate sub-sheet names found in current sheet." ) );
815 retVal = false;
816 }
817 else
818 {
819 item = static_cast<SCH_ITEM*>( selTool->GetNode( aPosition ) );
820 SCH_SYMBOL* symbol = dynamic_cast<SCH_SYMBOL*>( item );
821
822 if( item )
823 {
824 if( item->IsConnectivityDirty() )
825 editFrame->RecalculateConnections( nullptr, NO_CLEANUP );
826
827 if( item->Type() == SCH_FIELD_T )
828 symbol = dynamic_cast<SCH_SYMBOL*>( item->GetParent() );
829
830 if( symbol && symbol->GetLibSymbolRef() && symbol->GetLibSymbolRef()->IsPower() )
831 {
832 std::vector<SCH_PIN*> pins = symbol->GetPins();
833
834 if( pins.size() == 1 )
835 conn = pins[0]->Connection();
836 }
837 else
838 {
839 conn = item->Connection();
840 }
841 }
842 }
843 }
844
845 wxString connName = ( conn ) ? conn->Name() : wxString( wxS( "" ) );
846
847 if( !conn )
848 {
849 editFrame->SetStatusText( wxT( "" ) );
850 editFrame->SendCrossProbeClearHighlight();
851 editFrame->SetHighlightedConnection( wxEmptyString );
852 editorControl->SetHighlightBusMembers( false );
853 }
854 else
855 {
856 NET_NAVIGATOR_ITEM_DATA itemData( editFrame->GetCurrentSheet(), item );
857
858 if( connName != editFrame->GetHighlightedConnection() )
859 {
860 editorControl->SetHighlightBusMembers( false );
861 editFrame->SetCrossProbeConnection( conn );
862 editFrame->SetHighlightedConnection( connName, &itemData );
863 }
864 else
865 {
866 editorControl->SetHighlightBusMembers( !editorControl->GetHighlightBusMembers() );
867
868 if( item != editFrame->GetSelectedNetNavigatorItem() )
869 editFrame->SelectNetNavigatorItem( &itemData );
870 }
871 }
872
873 editFrame->UpdateNetHighlightStatus();
874
876 editorControl->UpdateNetHighlighting( dummy );
877
878 return retVal;
879}
880
881
883{
885 VECTOR2D cursorPos = controls->GetCursorPosition( !aEvent.DisableGridSnapping() );
886
887 highlightNet( m_toolMgr, cursorPos );
888
889 return 0;
890}
891
892
894{
896
897 return 0;
898}
899
900
902{
904 SCHEMATIC& schematic = m_frame->Schematic();
906
907 const SCH_CONNECTION* conn = nullptr;
908 VECTOR2D connPos;
909
910 for( EDA_ITEM* item : selectionTool->GetSelection() )
911 {
912 conn = static_cast<SCH_ITEM*>( item )->Connection();
913 connPos = item->GetPosition();
914
915 if( conn )
916 break;
917 }
918
919 if( !conn )
920 {
921 m_frame->ShowInfoBarError( _( "No net selected." ) );
922 return 0;
923 }
924
925 // Remove selection in favor of highlighting so the whole net is highlighted
926 selectionTool->ClearSelection();
927 highlightNet( m_toolMgr, connPos );
928
929 wxString netName = conn->Name();
930
931 if( conn->IsBus() )
932 {
933 wxString prefix;
934
935 if( NET_SETTINGS::ParseBusVector( netName, &prefix, nullptr ) )
936 {
937 netName = prefix + wxT( "*" );
938 }
939 else if( NET_SETTINGS::ParseBusGroup( netName, &prefix, nullptr ) )
940 {
941 netName = prefix + wxT( ".*" );
942 }
943 }
944 else if( !conn->Driver() || CONNECTION_SUBGRAPH::GetDriverPriority( conn->Driver() )
946 {
947 m_frame->ShowInfoBarError( _( "Net must be labeled to assign a netclass." ) );
949 return 0;
950 }
951
952 DIALOG_ASSIGN_NETCLASS dlg( m_frame, netName, schematic.GetNetClassAssignmentCandidates(),
953 [&]( const std::vector<wxString>& aNetNames )
954 {
955 for( SCH_ITEM* item : screen->Items() )
956 {
957 bool redraw = item->IsBrightened();
958 SCH_CONNECTION* itemConn = item->Connection();
959
960 if( itemConn && alg::contains( aNetNames, itemConn->Name() ) )
961 item->SetBrightened();
962 else
963 item->ClearBrightened();
964
965 redraw |= item->IsBrightened();
966
967 if( item->Type() == SCH_SYMBOL_T )
968 {
969 SCH_SYMBOL* symbol = static_cast<SCH_SYMBOL*>( item );
970
971 redraw |= symbol->HasBrightenedPins();
972
973 symbol->ClearBrightenedPins();
974
975 for( SCH_PIN* pin : symbol->GetPins() )
976 {
977 SCH_CONNECTION* pin_conn = pin->Connection();
978
979 if( pin_conn && alg::contains( aNetNames, pin_conn->Name() ) )
980 {
981 pin->SetBrightened();
982 redraw = true;
983 }
984 }
985 }
986 else if( item->Type() == SCH_SHEET_T )
987 {
988 for( SCH_SHEET_PIN* pin : static_cast<SCH_SHEET*>( item )->GetPins() )
989 {
990 SCH_CONNECTION* pin_conn = pin->Connection();
991
992 redraw |= pin->IsBrightened();
993
994 if( pin_conn && alg::contains( aNetNames, pin_conn->Name() ) )
995 pin->SetBrightened();
996 else
997 pin->ClearBrightened();
998
999 redraw |= pin->IsBrightened();
1000 }
1001 }
1002
1003 if( redraw )
1004 getView()->Update( item, KIGFX::VIEW_UPDATE_FLAGS::REPAINT );
1005 }
1006
1008 } );
1009
1010 if( dlg.ShowModal() )
1011 {
1012 getView()->UpdateAllItemsConditionally(
1013 [&]( KIGFX::VIEW_ITEM* aItem ) -> int
1014 {
1015 int flags = 0;
1016
1017 // Netclass coloured items
1018 //
1019 if( dynamic_cast<SCH_LINE*>( aItem ) )
1020 flags |= KIGFX::REPAINT;
1021 else if( dynamic_cast<SCH_JUNCTION*>( aItem ) )
1022 flags |= KIGFX::REPAINT;
1023 else if( dynamic_cast<SCH_BUS_ENTRY_BASE*>( aItem ) )
1024 flags |= KIGFX::REPAINT;
1025
1026 // Items that might reference an item's netclass name
1027 //
1028 if( SCH_ITEM* item = dynamic_cast<SCH_ITEM*>( aItem ) )
1029 {
1030 item->RunOnChildren(
1031 [&flags]( SCH_ITEM* aChild )
1032 {
1033 EDA_TEXT* text = dynamic_cast<EDA_TEXT*>( aChild );
1034
1035 if( text && text->HasTextVars() )
1036 {
1037 text->ClearRenderCache();
1038 text->ClearBoundingBoxCache();
1039 flags |= KIGFX::GEOMETRY | KIGFX::REPAINT;
1040 }
1041 } );
1042
1043 EDA_TEXT* text = dynamic_cast<EDA_TEXT*>( aItem );
1044
1045 if( text && text->HasTextVars() )
1046 {
1047 text->ClearRenderCache();
1048 text->ClearBoundingBoxCache();
1050 }
1051
1052 if( flags & KIGFX::GEOMETRY )
1053 m_frame->GetScreen()->Update( item, false ); // Refresh RTree
1054 }
1055
1056 return flags;
1057 } );
1058 }
1059
1060 highlightNet( m_toolMgr, CLEAR );
1061 return 0;
1062}
1063
1064
1066{
1067 wxCHECK( m_frame, 0 );
1068
1069 const SCH_SHEET_PATH& sheetPath = m_frame->GetCurrentSheet();
1071 CONNECTION_GRAPH* connectionGraph = m_frame->Schematic().ConnectionGraph();
1072 wxString selectedName = m_frame->GetHighlightedConnection();
1073
1074 std::set<wxString> connNames;
1075 std::vector<EDA_ITEM*> itemsToRedraw;
1076
1077 wxCHECK( screen && connectionGraph, 0 );
1078
1079 if( !selectedName.IsEmpty() )
1080 {
1081 connNames.emplace( selectedName );
1082
1083 CONNECTION_SUBGRAPH* sg = connectionGraph->FindSubgraphByName( selectedName, sheetPath );
1084
1085 if( sg && m_highlightBusMembers )
1086 {
1087 for( const SCH_ITEM* item : sg->GetItems() )
1088 {
1089 wxCHECK2( item, continue );
1090
1091 SCH_CONNECTION* connection = item->Connection();
1092
1093 wxCHECK2( connection, continue );
1094
1095 for( const std::shared_ptr<SCH_CONNECTION>& member : connection->AllMembers() )
1096 {
1097 if( member )
1098 connNames.emplace( member->Name() );
1099 }
1100 }
1101 }
1102 }
1103
1104 for( SCH_ITEM* item : screen->Items() )
1105 {
1106 wxCHECK2( item, continue );
1107
1108 if( !item->IsConnectable() )
1109 continue;
1110
1111 SCH_ITEM* redrawItem = nullptr;
1112
1113 if( item->Type() == SCH_SYMBOL_T )
1114 {
1115 SCH_SYMBOL* symbol = static_cast<SCH_SYMBOL*>( item );
1116
1117 wxCHECK2( symbol, continue );
1118
1119 for( SCH_PIN* pin : symbol->GetPins() )
1120 {
1121 SCH_CONNECTION* pin_conn = pin->Connection();
1122
1123 wxCHECK2( pin_conn, continue );
1124
1125 if( !pin->IsBrightened() && connNames.count( pin_conn->Name() ) )
1126 {
1127 pin->SetBrightened();
1128 redrawItem = symbol;
1129 }
1130 else if( pin->IsBrightened() && !connNames.count( pin_conn->Name() ) )
1131 {
1132 pin->ClearBrightened();
1133 redrawItem = symbol;
1134 }
1135 }
1136
1137 if( symbol->IsPower() )
1138 {
1139 wxCHECK2( symbol->GetPins().size(), continue );
1140
1141 SCH_CONNECTION* pinConn = symbol->GetPins()[0]->Connection();
1142
1143 wxCHECK2( pinConn, continue );
1144
1145 std::vector<SCH_FIELD>& fields = symbol->GetFields();
1146
1147 for( int id : { REFERENCE_FIELD, VALUE_FIELD } )
1148 {
1149 if( !fields[id].IsVisible() )
1150 continue;
1151
1152 if( !fields[id].IsBrightened() && connNames.count( pinConn->Name() ) )
1153 {
1154 fields[id].SetBrightened();
1155 redrawItem = symbol;
1156 }
1157 else if( fields[id].IsBrightened() && !connNames.count( pinConn->Name() ) )
1158 {
1159 fields[id].ClearBrightened();
1160 redrawItem = symbol;
1161 }
1162 }
1163 }
1164 }
1165 else if( item->Type() == SCH_SHEET_T )
1166 {
1167 SCH_SHEET* sheet = static_cast<SCH_SHEET*>( item );
1168
1169 wxCHECK2( sheet, continue );
1170
1171 for( SCH_SHEET_PIN* pin : sheet->GetPins() )
1172 {
1173 wxCHECK2( pin, continue );
1174
1175 SCH_CONNECTION* pin_conn = pin->Connection();
1176
1177 wxCHECK2( pin_conn, continue );
1178
1179 if( !pin->IsBrightened() && connNames.count( pin_conn->Name() ) )
1180 {
1181 pin->SetBrightened();
1182 redrawItem = sheet;
1183 }
1184 else if( pin->IsBrightened() && !connNames.count( pin_conn->Name() ) )
1185 {
1186 pin->ClearBrightened();
1187 redrawItem = sheet;
1188 }
1189 }
1190 }
1191 else
1192 {
1193 SCH_CONNECTION* itemConn = item->Connection();
1194
1195 wxCHECK2( itemConn, continue );
1196
1197 if( !item->IsBrightened() && connNames.count( itemConn->Name() ) )
1198 {
1199 item->SetBrightened();
1200 redrawItem = item;
1201 }
1202 else if( item->IsBrightened() && !connNames.count( itemConn->Name() ) )
1203 {
1204 item->ClearBrightened();
1205 redrawItem = item;
1206 }
1207 }
1208
1209 if( redrawItem )
1210 itemsToRedraw.push_back( redrawItem );
1211 }
1212
1213 if( itemsToRedraw.size() )
1214 {
1215 // Be sure highlight change will be redrawn
1216 KIGFX::VIEW* view = getView();
1217
1218 for( EDA_ITEM* redrawItem : itemsToRedraw )
1220
1222 }
1223
1224 return 0;
1225}
1226
1227
1229{
1231
1232 // Deactivate other tools; particularly important if another PICKER is currently running
1233 Activate();
1234
1235 picker->SetCursor( KICURSOR::BULLSEYE );
1236 picker->SetSnapping( false );
1237
1238 picker->SetClickHandler(
1239 [this] ( const VECTOR2D& aPos )
1240 {
1241 return highlightNet( m_toolMgr, aPos );
1242 } );
1243
1245
1246 return 0;
1247}
1248
1249
1251{
1252 wxCHECK( m_frame, 0 );
1253
1254 if( m_frame->GetUndoCommandCount() <= 0 )
1255 return 0;
1256
1257 // Inform tools that undo command was issued
1259
1260 // Get the old list
1262
1263 wxCHECK( undo_list, 0 );
1264
1265 m_frame->PutDataInPreviousState( undo_list );
1266
1267 // Now push the old command to the RedoList
1268 undo_list->ReversePickersListOrder();
1269 m_frame->PushCommandToRedoList( undo_list );
1270
1271 m_toolMgr->GetTool<EE_SELECTION_TOOL>()->RebuildSelection();
1272
1274 m_frame->OnModify();
1275
1276 return 0;
1277}
1278
1279
1281{
1282 wxCHECK( m_frame, 0 );
1283
1284 if( m_frame->GetRedoCommandCount() == 0 )
1285 return 0;
1286
1287 // Inform tools that undo command was issued
1289
1290 /* Get the old list */
1292
1293 wxCHECK( list, 0 );
1294
1295 /* Redo the command: */
1297
1298 /* Put the old list in UndoList */
1301
1302 m_toolMgr->GetTool<EE_SELECTION_TOOL>()->RebuildSelection();
1303
1305 m_frame->OnModify();
1306
1307 return 0;
1308}
1309
1310
1311bool SCH_EDITOR_CONTROL::doCopy( bool aUseDuplicateClipboard )
1312{
1314 EE_SELECTION& selection = selTool->RequestSelection();
1315 SCHEMATIC& schematic = m_frame->Schematic();
1316
1317 if( selection.Empty() )
1318 return false;
1319
1320 if( aUseDuplicateClipboard )
1321 m_duplicateIsHoverSelection = selection.IsHover();
1322
1323 selection.SetScreen( m_frame->GetScreen() );
1325
1326 for( EDA_ITEM* item : selection )
1327 {
1328 if( item->Type() == SCH_SHEET_T )
1329 {
1330 SCH_SHEET* sheet = (SCH_SHEET*) item;
1331 m_supplementaryClipboard[ sheet->GetFileName() ] = sheet->GetScreen();
1332 }
1333 else if( item->Type() == SCH_FIELD_T && selection.IsHover() )
1334 {
1335 // Most of the time the user is trying to duplicate the parent symbol
1336 // and the field text is in it
1337 selection.Add( item->GetParent() );
1338 }
1339 else if( item->Type() == SCH_MARKER_T )
1340 {
1341 // Don't let the markers be copied
1342 selection.Remove( item );
1343 }
1344 }
1345
1346 STRING_FORMATTER formatter;
1347 SCH_IO_KICAD_SEXPR plugin;
1348 SCH_SHEET_LIST hierarchy = schematic.GetSheets();
1350
1351 plugin.Format( &selection, &selPath, schematic, &formatter, true );
1352
1353 if( selection.IsHover() )
1355
1356 if( aUseDuplicateClipboard )
1357 {
1358 m_duplicateClipboard = formatter.GetString();
1359 return true;
1360 }
1361
1362 return m_toolMgr->SaveClipboard( formatter.GetString() );
1363}
1364
1365
1366bool SCH_EDITOR_CONTROL::searchSupplementaryClipboard( const wxString& aSheetFilename,
1367 SCH_SCREEN** aScreen )
1368{
1369 if( m_supplementaryClipboard.count( aSheetFilename ) > 0 )
1370 {
1371 *aScreen = m_supplementaryClipboard[ aSheetFilename ];
1372 return true;
1373 }
1374
1375 return false;
1376}
1377
1378
1380{
1381 doCopy( true ); // Use the local clipboard
1382 Paste( aEvent );
1383
1384 return 0;
1385}
1386
1387
1389{
1390 wxTextEntry* textEntry = dynamic_cast<wxTextEntry*>( wxWindow::FindFocus() );
1391
1392 if( textEntry )
1393 {
1394 textEntry->Cut();
1395 return 0;
1396 }
1397
1398 if( doCopy() )
1400
1401 return 0;
1402}
1403
1404
1406{
1407 wxTextEntry* textEntry = dynamic_cast<wxTextEntry*>( wxWindow::FindFocus() );
1408
1409 if( textEntry )
1410 {
1411 textEntry->Copy();
1412 return 0;
1413 }
1414
1415 doCopy();
1416
1417 return 0;
1418}
1419
1420
1422 const SCH_SHEET_PATH& aPastePath,
1423 const KIID_PATH& aClipPath,
1424 bool aForceKeepAnnotations )
1425{
1426 wxCHECK( m_frame && aSymbol, /* void */ );
1427
1428 SCH_SYMBOL_INSTANCE newInstance;
1429 bool instanceFound = false;
1430 KIID_PATH pasteLookupPath = aClipPath;
1431
1432 m_pastedSymbols.insert( aSymbol );
1433
1434 for( const SCH_SYMBOL_INSTANCE& tmp : aSymbol->GetInstances() )
1435 {
1436 if( ( tmp.m_Path.empty() && aClipPath.empty() )
1437 || ( !aClipPath.empty() && tmp.m_Path.EndsWith( aClipPath ) ) )
1438 {
1439 newInstance = tmp;
1440 instanceFound = true;
1441
1442 wxLogTrace( traceSchPaste,
1443 wxS( "Pasting found symbol instance with reference %s, unit %d:"
1444 "\n\tClipboard path: %s\n\tSymbol UUID: %s." ),
1445 tmp.m_Reference, tmp.m_Unit,
1446 aClipPath.AsString(), aSymbol->m_Uuid.AsString() );
1447
1448 break;
1449 }
1450 }
1451
1452 // The pasted symbol look up paths include the symbol UUID.
1453 pasteLookupPath.push_back( aSymbol->m_Uuid );
1454
1455 if( !instanceFound )
1456 {
1457 wxLogTrace( traceSchPaste,
1458 wxS( "Clipboard symbol instance **not** found:\n\tClipboard path: %s\n\t"
1459 "Symbol UUID: %s." ),
1460 aClipPath.AsString(), aSymbol->m_Uuid.AsString() );
1461
1462 // Some legacy versions saved value fields escaped. While we still do in the symbol
1463 // editor, we don't anymore in the schematic, so be sure to unescape them.
1464 SCH_FIELD* valueField = aSymbol->GetField( VALUE_FIELD );
1465 valueField->SetText( UnescapeString( valueField->GetText() ) );
1466
1467 // Pasted from notepad or an older instance of eeschema. Use the values in the fields
1468 // instead.
1469 newInstance.m_Reference = aSymbol->GetField( REFERENCE_FIELD )->GetText();
1470 newInstance.m_Unit = aSymbol->GetUnit();
1471 }
1472
1473 newInstance.m_Path = aPastePath.Path();
1474 newInstance.m_ProjectName = m_frame->Prj().GetProjectName();
1475
1476 aSymbol->AddHierarchicalReference( newInstance );
1477
1478 if( !aForceKeepAnnotations )
1479 aSymbol->ClearAnnotation( &aPastePath, false );
1480
1481 // We might clear annotations but always leave the original unit number from the paste.
1482 aSymbol->SetUnit( newInstance.m_Unit );
1483}
1484
1485
1487 const SCH_SHEET_PATH& aPastePath,
1488 const KIID_PATH& aClipPath,
1489 bool aForceKeepAnnotations,
1490 SCH_SHEET_LIST* aPastedSheets,
1491 std::map<SCH_SHEET_PATH,
1492 SCH_REFERENCE_LIST>& aPastedSymbols )
1493{
1494 wxCHECK( aSheet && aPastedSheets, aPastePath );
1495
1496 SCH_SHEET_PATH sheetPath = aPastePath;
1497 sheetPath.push_back( aSheet );
1498
1499 aPastedSheets->push_back( sheetPath );
1500
1501 if( aSheet->GetScreen() == nullptr )
1502 return sheetPath; // We can only really set the page number but not load any items
1503
1504 for( SCH_ITEM* item : aSheet->GetScreen()->Items() )
1505 {
1506 if( item->IsConnectable() )
1507 item->SetConnectivityDirty();
1508
1509 if( item->Type() == SCH_SYMBOL_T )
1510 {
1511 SCH_SYMBOL* symbol = static_cast<SCH_SYMBOL*>( item );
1512
1513 wxCHECK2( symbol, continue );
1514
1515 // Only do this once if the symbol is shared across multiple sheets.
1516 if( !m_pastedSymbols.count( symbol ) )
1517 {
1518 for( SCH_PIN* pin : symbol->GetPins() )
1519 {
1520 const_cast<KIID&>( pin->m_Uuid ) = KIID();
1521 pin->SetConnectivityDirty();
1522 }
1523 }
1524
1525 updatePastedSymbol( symbol, sheetPath, aClipPath, aForceKeepAnnotations );
1526 }
1527 else if( item->Type() == SCH_SHEET_T )
1528 {
1529 SCH_SHEET* subsheet = static_cast<SCH_SHEET*>( item );
1530
1531 wxCHECK2( subsheet, continue );
1532
1533 // Make sure pins get a new UUID and set the dirty connectivity flag.
1534 if( !aPastedSheets->ContainsSheet( subsheet ) )
1535 {
1536 for( SCH_SHEET_PIN* pin : subsheet->GetPins() )
1537 {
1538 const_cast<KIID&>( pin->m_Uuid ) = KIID();
1539 pin->SetConnectivityDirty();
1540 }
1541 }
1542
1543 KIID_PATH newClipPath = aClipPath;
1544 newClipPath.push_back( subsheet->m_Uuid );
1545
1546 updatePastedSheet( subsheet, sheetPath, newClipPath, aForceKeepAnnotations,
1547 aPastedSheets, aPastedSymbols );
1548 }
1549 }
1550
1551 sheetPath.GetSymbols( aPastedSymbols[aPastePath] );
1552
1553 return sheetPath;
1554}
1555
1556
1558{
1559 wxCHECK( aScreen, /* void */ );
1560
1561 for( const SCH_ITEM* item : aScreen->Items() )
1562 {
1563 if( item->Type() == SCH_SYMBOL_T )
1564 {
1565 const SCH_SYMBOL* symbol = static_cast<const SCH_SYMBOL*>( item );
1566
1567 wxCHECK2( symbol, continue );
1568
1569 for( const SCH_SYMBOL_INSTANCE& symbolInstance : symbol->GetInstances() )
1570 {
1571 KIID_PATH pathWithSymbol = symbolInstance.m_Path;
1572
1573 pathWithSymbol.push_back( symbol->m_Uuid );
1574
1575 m_clipboardSymbolInstances[pathWithSymbol] = symbolInstance;
1576 }
1577 }
1578 }
1579}
1580
1581
1583{
1584 wxCHECK( m_frame, /* void */ );
1585
1586 for( SCH_SYMBOL* symbol : m_pastedSymbols )
1587 {
1588 wxCHECK2( symbol, continue );
1589
1590 std::vector<KIID_PATH> instancePathsToRemove;
1591
1592 for( const SCH_SYMBOL_INSTANCE& instance : symbol->GetInstances() )
1593 {
1594 if( ( instance.m_ProjectName != m_frame->Prj().GetProjectName() )
1595 || instance.m_Path.empty() )
1596 instancePathsToRemove.emplace_back( instance.m_Path );
1597 }
1598
1599 for( const KIID_PATH& path : instancePathsToRemove )
1600 symbol->RemoveInstance( path );
1601 }
1602}
1603
1604
1606{
1607 wxTextEntry* textEntry = dynamic_cast<wxTextEntry*>( wxWindow::FindFocus() );
1608
1609 if( textEntry )
1610 {
1611 textEntry->Paste();
1612 return 0;
1613 }
1614
1616 std::string content;
1617 VECTOR2I eventPos;
1618
1619 if( aEvent.IsAction( &ACTIONS::duplicate ) )
1620 content = m_duplicateClipboard;
1621 else
1622 content = m_toolMgr->GetClipboardUTF8();
1623
1624 if( content.empty() )
1625 return 0;
1626
1627 if( aEvent.IsAction( &ACTIONS::duplicate ) )
1628 eventPos = getViewControls()->GetCursorPosition( false );
1629
1630 STRING_LINE_READER reader( content, "Clipboard" );
1631 SCH_IO_KICAD_SEXPR plugin;
1632
1633 SCH_SHEET tempSheet;
1634 SCH_SCREEN* tempScreen = new SCH_SCREEN( &m_frame->Schematic() );
1635
1637 int annotateStartNum = m_frame->Schematic().Settings().m_AnnotateStartNum;
1638
1639 // Screen object on heap is owned by the sheet.
1640 tempSheet.SetScreen( tempScreen );
1641
1642 try
1643 {
1644 plugin.LoadContent( reader, &tempSheet );
1645 }
1646 catch( IO_ERROR& )
1647 {
1648 // If it wasn't content, then paste as text object.
1649 SCH_TEXT* text_item = new SCH_TEXT( VECTOR2I( 0, 0 ), content );
1650 tempScreen->Append( text_item );
1651 }
1652
1653 m_pastedSymbols.clear();
1655
1656 // Save pasted symbol instances in case the user chooses to keep existing symbol annotation.
1657 setPastedSymbolInstances( tempScreen );
1658
1659 tempScreen->MigrateSimModels();
1660
1661 PASTE_MODE pasteMode = annotate.automatic ? PASTE_MODE::RESPECT_OPTIONS
1662 : PASTE_MODE::REMOVE_ANNOTATIONS;
1663
1664 if( aEvent.IsAction( &ACTIONS::pasteSpecial ) )
1665 {
1666 DIALOG_PASTE_SPECIAL dlg( m_frame, &pasteMode );
1667
1668 if( dlg.ShowModal() == wxID_CANCEL )
1669 return 0;
1670 }
1671
1672 bool forceKeepAnnotations = pasteMode != PASTE_MODE::REMOVE_ANNOTATIONS;
1673
1674 // SCH_SEXP_PLUGIN added the items to the paste screen, but not to the view or anything
1675 // else. Pull them back out to start with.
1676 SCH_COMMIT commit( m_toolMgr );
1677 EDA_ITEMS loadedItems;
1678 std::vector<SCH_ITEM*> sortedLoadedItems;
1679 bool sheetsPasted = false;
1680 SCH_SHEET_LIST hierarchy = m_frame->Schematic().GetSheets();
1681 SCH_SHEET_PATH& pasteRoot = m_frame->GetCurrentSheet();
1682 wxFileName destFn = pasteRoot.Last()->GetFileName();
1683
1684 if( destFn.IsRelative() )
1685 destFn.MakeAbsolute( m_frame->Prj().GetProjectPath() );
1686
1687 // List of paths in the hierarchy that refer to the destination sheet of the paste
1688 SCH_SHEET_LIST sheetPathsForScreen = hierarchy.FindAllSheetsForScreen( pasteRoot.LastScreen() );
1689 sheetPathsForScreen.SortByPageNumbers();
1690
1691 // Build a list of screens from the current design (to avoid loading sheets that already exist)
1692 std::map<wxString, SCH_SCREEN*> loadedScreens;
1693
1694 for( const SCH_SHEET_PATH& item : hierarchy )
1695 {
1696 if( item.LastScreen() )
1697 loadedScreens[item.Last()->GetFileName()] = item.LastScreen();
1698 }
1699
1700 // Build symbol list for reannotation of duplicates
1701 SCH_REFERENCE_LIST existingRefs;
1702 hierarchy.GetSymbols( existingRefs );
1703 existingRefs.SortByReferenceOnly();
1704
1705 // Build UUID map for fetching last-resolved-properties
1706 std::map<KIID, EDA_ITEM*> itemMap;
1707 hierarchy.FillItemMap( itemMap );
1708
1709 // Keep track of pasted sheets and symbols for the different paths to the hierarchy.
1710 std::map<SCH_SHEET_PATH, SCH_REFERENCE_LIST> pastedSymbols;
1711 std::map<SCH_SHEET_PATH, SCH_SHEET_LIST> pastedSheets;
1712
1713 for( SCH_ITEM* item : tempScreen->Items() )
1714 {
1715 if( item->Type() == SCH_SHEET_T )
1716 sortedLoadedItems.push_back( item );
1717 else
1718 loadedItems.push_back( item );
1719 }
1720
1721 sort( sortedLoadedItems.begin(), sortedLoadedItems.end(),
1722 []( SCH_ITEM* firstItem, SCH_ITEM* secondItem )
1723 {
1724 SCH_SHEET* firstSheet = static_cast<SCH_SHEET*>( firstItem );
1725 SCH_SHEET* secondSheet = static_cast<SCH_SHEET*>( secondItem );
1726 return StrNumCmp( firstSheet->GetName(), secondSheet->GetName(), false ) < 0;
1727 });
1728
1729
1730 for( SCH_ITEM* item : sortedLoadedItems )
1731 {
1732 loadedItems.push_back( item );
1733
1734 if( item->Type() == SCH_SHEET_T )
1735 {
1736 SCH_SHEET* sheet = static_cast<SCH_SHEET*>( item );
1737 SCH_FIELD& nameField = sheet->GetFields()[SHEETNAME];
1738 wxString baseName = nameField.GetText();
1739 wxFileName srcFn = sheet->GetFileName();
1740
1741 if( srcFn.IsRelative() )
1742 srcFn.MakeAbsolute( m_frame->Prj().GetProjectPath() );
1743
1744 SCH_SHEET_LIST sheetHierarchy( sheet );
1745
1746 if( hierarchy.TestForRecursion( sheetHierarchy, destFn.GetFullPath( wxPATH_UNIX ) ) )
1747 {
1748 auto msg = wxString::Format( _( "The pasted sheet '%s'\n"
1749 "was dropped because the destination already has "
1750 "the sheet or one of its subsheets as a parent." ),
1751 sheet->GetFileName() );
1752 DisplayError( m_frame, msg );
1753 loadedItems.pop_back();
1754 }
1755 }
1756 }
1757
1758 // Remove the references from our temporary screen to prevent freeing on the DTOR
1759 tempScreen->Clear( false );
1760
1761 for( EDA_ITEM* item : loadedItems )
1762 {
1763 KIID_PATH clipPath( wxT( "/" ) ); // clipboard is at root
1764
1765 SCH_ITEM* schItem = static_cast<SCH_ITEM*>( item );
1766
1767 wxCHECK2( schItem, continue );
1768
1769 if( schItem->IsConnectable() )
1770 schItem->SetConnectivityDirty();
1771
1772 if( item->Type() == SCH_SYMBOL_T )
1773 {
1774 SCH_SYMBOL* symbol = static_cast<SCH_SYMBOL*>( item );
1775
1776 // The library symbol gets set from the cached library symbols in the current
1777 // schematic not the symbol libraries. The cached library symbol may have
1778 // changed from the original library symbol which would cause the copy to
1779 // be incorrect.
1780 SCH_SCREEN* currentScreen = m_frame->GetScreen();
1781
1782 wxCHECK2( currentScreen, continue );
1783
1784 auto it = currentScreen->GetLibSymbols().find( symbol->GetSchSymbolLibraryName() );
1785 auto end = currentScreen->GetLibSymbols().end();
1786
1787 if( it == end )
1788 {
1789 // If can't find library definition in the design, use the pasted library
1790 it = tempScreen->GetLibSymbols().find( symbol->GetSchSymbolLibraryName() );
1791 end = tempScreen->GetLibSymbols().end();
1792 }
1793
1794 LIB_SYMBOL* libSymbol = nullptr;
1795
1796 if( it != end )
1797 {
1798 libSymbol = new LIB_SYMBOL( *it->second );
1799 symbol->SetLibSymbol( libSymbol );
1800 }
1801
1802 for( SCH_SHEET_PATH& sheetPath : sheetPathsForScreen )
1803 updatePastedSymbol( symbol, sheetPath, clipPath, forceKeepAnnotations );
1804
1805 // Assign a new KIID
1806 const_cast<KIID&>( item->m_Uuid ) = KIID();
1807
1808 // Make sure pins get a new UUID
1809 for( SCH_PIN* pin : symbol->GetPins() )
1810 {
1811 const_cast<KIID&>( pin->m_Uuid ) = KIID();
1812 pin->SetConnectivityDirty();
1813 }
1814
1815 for( SCH_SHEET_PATH& sheetPath : sheetPathsForScreen )
1816 {
1817 // Ignore symbols from a non-existant library.
1818 if( libSymbol )
1819 {
1820 SCH_REFERENCE schReference( symbol, libSymbol, sheetPath );
1821 schReference.SetSheetNumber( sheetPath.GetVirtualPageNumber() );
1822 pastedSymbols[sheetPath].AddItem( schReference );
1823 }
1824 }
1825 }
1826 else if( item->Type() == SCH_SHEET_T )
1827 {
1828 SCH_SHEET* sheet = (SCH_SHEET*) item;
1829 SCH_FIELD& nameField = sheet->GetFields()[SHEETNAME];
1830 wxString baseName = nameField.GetText();
1831 wxString candidateName = baseName;
1832 wxString number;
1833
1834 while( !baseName.IsEmpty() && wxIsdigit( baseName.Last() ) )
1835 {
1836 number = baseName.Last() + number;
1837 baseName.RemoveLast();
1838 }
1839
1840 // Update hierarchy to include any other sheets we already added, avoiding
1841 // duplicate sheet names
1842 hierarchy = m_frame->Schematic().GetSheets();
1843
1844 //@todo: it might be better to just iterate through the sheet names
1845 // in this screen instead of the whole hierarchy.
1846 int uniquifier = std::max( 0, wxAtoi( number ) ) + 1;
1847
1848 while( hierarchy.NameExists( candidateName ) )
1849 candidateName = wxString::Format( wxT( "%s%d" ), baseName, uniquifier++ );
1850
1851 nameField.SetText( candidateName );
1852
1853 wxFileName fn = sheet->GetFileName();
1854 SCH_SCREEN* existingScreen = nullptr;
1855
1856 sheet->SetParent( pasteRoot.Last() );
1857 sheet->SetScreen( nullptr );
1858
1859 if( !fn.IsAbsolute() )
1860 {
1861 wxFileName currentSheetFileName = pasteRoot.LastScreen()->GetFileName();
1862 fn.Normalize( FN_NORMALIZE_FLAGS | wxPATH_NORM_ENV_VARS,
1863 currentSheetFileName.GetPath() );
1864 }
1865
1866 // Try to find the screen for the pasted sheet by several means
1867 if( !m_frame->Schematic().Root().SearchHierarchy( fn.GetFullPath( wxPATH_UNIX ),
1868 &existingScreen ) )
1869 {
1870 if( loadedScreens.count( sheet->GetFileName() ) > 0 )
1871 existingScreen = loadedScreens.at( sheet->GetFileName() );
1872 else
1873 searchSupplementaryClipboard( sheet->GetFileName(), &existingScreen );
1874 }
1875
1876 if( existingScreen )
1877 {
1878 sheet->SetScreen( existingScreen );
1879 }
1880 else
1881 {
1882 if( !m_frame->LoadSheetFromFile( sheet, &pasteRoot, fn.GetFullPath() ) )
1883 m_frame->InitSheet( sheet, sheet->GetFileName() );
1884 }
1885
1886 // Save the symbol instances in case the user chooses to keep the existing
1887 // symbol annotation.
1889 sheetsPasted = true;
1890
1891 // Push it to the clipboard path while it still has its old KIID
1892 clipPath.push_back( sheet->m_Uuid );
1893
1894 // Assign a new KIID to the pasted sheet
1895 const_cast<KIID&>( sheet->m_Uuid ) = KIID();
1896
1897 // Make sure pins get a new UUID
1898 for( SCH_SHEET_PIN* pin : sheet->GetPins() )
1899 {
1900 const_cast<KIID&>( pin->m_Uuid ) = KIID();
1901 pin->SetConnectivityDirty();
1902 }
1903
1904 // Once we have our new KIID we can update all pasted instances. This will either
1905 // reset the annotations or copy "kept" annotations from the supplementary clipboard.
1906 for( SCH_SHEET_PATH& sheetPath : sheetPathsForScreen )
1907 {
1908 SCH_SHEET_PATH subPath = updatePastedSheet( sheet, sheetPath, clipPath,
1909 ( forceKeepAnnotations && annotate.automatic ),
1910 &pastedSheets[sheetPath],
1911 pastedSymbols );
1912 }
1913 }
1914 else
1915 {
1916 SCH_ITEM* srcItem = dynamic_cast<SCH_ITEM*>( itemMap[ item->m_Uuid ] );
1917 SCH_ITEM* destItem = dynamic_cast<SCH_ITEM*>( item );
1918
1919 // Everything gets a new KIID
1920 const_cast<KIID&>( item->m_Uuid ) = KIID();
1921
1922 if( srcItem && destItem )
1923 {
1924 destItem->SetConnectivityDirty( true );
1925 destItem->SetLastResolvedState( srcItem );
1926 }
1927 }
1928
1929 // Lines need both ends selected for a move after paste so the whole line moves.
1930 if( item->Type() == SCH_LINE_T )
1931 item->SetFlags( STARTPOINT | ENDPOINT );
1932
1933 item->SetFlags( IS_NEW | IS_PASTED | IS_MOVING );
1934
1935 if( !m_frame->GetScreen()->CheckIfOnDrawList( (SCH_ITEM*) item ) ) // don't want a loop!
1936 m_frame->AddToScreen( item, m_frame->GetScreen() );
1937
1938 commit.Added( (SCH_ITEM*) item, m_frame->GetScreen() );
1939
1940 // Start out hidden so the pasted items aren't "ghosted" in their original location
1941 // before being moved to the current location.
1942 getView()->Hide( item, true );
1943 }
1944
1945 if( sheetsPasted )
1946 {
1947 // Update page numbers: Find next free numeric page number
1948 for( SCH_SHEET_PATH& sheetPath : sheetPathsForScreen )
1949 {
1950 for( SCH_SHEET_PATH& pastedSheet : pastedSheets[sheetPath] )
1951 {
1952 int page = 1;
1953 wxString pageNum = wxString::Format( "%d", page );
1954
1955 while( hierarchy.PageNumberExists( pageNum ) )
1956 pageNum = wxString::Format( "%d", ++page );
1957
1958 SCH_SHEET_INSTANCE sheetInstance;
1959
1960 sheetInstance.m_Path = pastedSheet.Path();
1961
1962 // Don't include the actual sheet in the instance path.
1963 sheetInstance.m_Path.pop_back();
1964 sheetInstance.m_PageNumber = pageNum;
1965 sheetInstance.m_ProjectName = m_frame->Prj().GetProjectName();
1966
1967 SCH_SHEET* sheet = pastedSheet.Last();
1968
1969 wxCHECK2( sheet, continue );
1970
1971 sheet->AddInstance( sheetInstance );
1972 hierarchy.push_back( pastedSheet );
1973
1974 // Remove all pasted sheet instance data that is not part of the current project.
1975 std::vector<KIID_PATH> instancesToRemove;
1976
1977 for( const SCH_SHEET_INSTANCE& instance : sheet->GetInstances() )
1978 {
1979 if( !hierarchy.HasPath( instance.m_Path ) )
1980 instancesToRemove.push_back( instance.m_Path );
1981 }
1982
1983 for( const KIID_PATH& instancePath : instancesToRemove )
1984 sheet->RemoveInstance( instancePath );
1985 }
1986 }
1987
1989
1990 // Get a version with correct sheet numbers since we've pasted sheets,
1991 // we'll need this when annotating next
1992 hierarchy = m_frame->Schematic().GetSheets();
1993 }
1994
1995 std::map<SCH_SHEET_PATH, SCH_REFERENCE_LIST> annotatedSymbols;
1996
1997 // Update the list of symbol instances that satisfy the annotation criteria.
1998 for( const SCH_SHEET_PATH& sheetPath : sheetPathsForScreen )
1999 {
2000 for( size_t i = 0; i < pastedSymbols[sheetPath].GetCount(); i++ )
2001 {
2002 if( pasteMode == PASTE_MODE::UNIQUE_ANNOTATIONS
2003 || pasteMode == PASTE_MODE::RESPECT_OPTIONS
2004 || pastedSymbols[sheetPath][i].AlwaysAnnotate() )
2005 {
2006 annotatedSymbols[sheetPath].AddItem( pastedSymbols[sheetPath][i] );
2007 }
2008 }
2009
2010 for( const SCH_SHEET_PATH& pastedSheetPath : pastedSheets[sheetPath] )
2011 {
2012 for( size_t i = 0; i < pastedSymbols[pastedSheetPath].GetCount(); i++ )
2013 {
2014 if( pasteMode == PASTE_MODE::UNIQUE_ANNOTATIONS
2015 || pasteMode == PASTE_MODE::RESPECT_OPTIONS
2016 || pastedSymbols[pastedSheetPath][i].AlwaysAnnotate() )
2017 {
2018 annotatedSymbols[pastedSheetPath].AddItem( pastedSymbols[pastedSheetPath][i] );
2019 }
2020 }
2021 }
2022 }
2023
2024 if( !annotatedSymbols.empty() )
2025 {
2026 for( SCH_SHEET_PATH& path : sheetPathsForScreen )
2027 {
2028 annotatedSymbols[path].SortByReferenceOnly();
2029
2030 if( pasteMode == PASTE_MODE::UNIQUE_ANNOTATIONS )
2031 {
2032 annotatedSymbols[path].ReannotateDuplicates( existingRefs );
2033 }
2034 else
2035 {
2036 annotatedSymbols[path].ReannotateByOptions( (ANNOTATE_ORDER_T) annotate.sort_order,
2037 (ANNOTATE_ALGO_T) annotate.method,
2038 annotateStartNum, existingRefs, false,
2039 &hierarchy );
2040 }
2041
2042 annotatedSymbols[path].UpdateAnnotation();
2043
2044 // Update existing refs for next iteration
2045 for( size_t i = 0; i < annotatedSymbols[path].GetCount(); i++ )
2046 existingRefs.AddItem( annotatedSymbols[path][i] );
2047
2048 for( const SCH_SHEET_PATH& pastedSheetPath : pastedSheets[path] )
2049 {
2050 annotatedSymbols[pastedSheetPath].SortByReferenceOnly();
2051
2052 if( pasteMode == PASTE_MODE::UNIQUE_ANNOTATIONS )
2053 {
2054 annotatedSymbols[pastedSheetPath].ReannotateDuplicates( existingRefs );
2055 }
2056 else
2057 {
2058 annotatedSymbols[pastedSheetPath].ReannotateByOptions( (ANNOTATE_ORDER_T) annotate.sort_order,
2059 (ANNOTATE_ALGO_T) annotate.method,
2060 annotateStartNum, existingRefs,
2061 false,
2062 &hierarchy );
2063 }
2064
2065 annotatedSymbols[pastedSheetPath].UpdateAnnotation();
2066
2067 // Update existing refs for next iteration
2068 for( size_t i = 0; i < annotatedSymbols[pastedSheetPath].GetCount(); i++ )
2069 existingRefs.AddItem( annotatedSymbols[pastedSheetPath][i] );
2070 }
2071 }
2072 }
2073
2075
2076 // The copy operation creates instance paths that are not valid for the current project or
2077 // saved as part of another project. Prune them now so they do not accumulate in the saved
2078 // schematic file.
2080
2081 SCH_SCREENS allScreens( m_frame->Schematic().Root() );
2082
2087
2088 // Now clear the previous selection, select the pasted items, and fire up the "move" tool.
2091
2092 EE_SELECTION& selection = selTool->GetSelection();
2093
2094 if( !selection.Empty() )
2095 {
2096 if( aEvent.IsAction( &ACTIONS::duplicate ) )
2097 {
2098 int closest_dist = INT_MAX;
2099
2100 auto processPt =
2101 [&]( const VECTOR2I& pt )
2102 {
2103 int dist = ( eventPos - pt ).EuclideanNorm();
2104
2105 if( dist < closest_dist )
2106 {
2107 selection.SetReferencePoint( pt );
2108 closest_dist = dist;
2109 }
2110 };
2111
2112 // Prefer connection points (which should remain on grid)
2113 for( EDA_ITEM* item : selection.Items() )
2114 {
2115 SCH_ITEM* sch_item = dynamic_cast<SCH_ITEM*>( item );
2116 SCH_PIN* pin = dynamic_cast<SCH_PIN*>( item );
2117
2118 if( sch_item && sch_item->IsConnectable() )
2119 {
2120 for( const VECTOR2I& pt : sch_item->GetConnectionPoints() )
2121 processPt( pt );
2122 }
2123 else if( pin )
2124 {
2125 processPt( pin->GetPosition() );
2126 }
2127 }
2128
2129 // Only process other points if we didn't find any connection points
2130 if( closest_dist == INT_MAX )
2131 {
2132 for( EDA_ITEM* item : selection.Items() )
2133 {
2134 switch( item->Type() )
2135 {
2136 case SCH_LINE_T:
2137 processPt( static_cast<SCH_LINE*>( item )->GetStartPoint() );
2138 processPt( static_cast<SCH_LINE*>( item )->GetEndPoint() );
2139 break;
2140
2141 case SCH_SHAPE_T:
2142 {
2143 SCH_SHAPE* shape = static_cast<SCH_SHAPE*>( item );
2144
2145 switch( shape->GetShape() )
2146 {
2147 case SHAPE_T::RECTANGLE:
2148 for( const VECTOR2I& pt : shape->GetRectCorners() )
2149 processPt( pt );
2150
2151 break;
2152
2153 case SHAPE_T::CIRCLE:
2154 processPt( shape->GetCenter() );
2155 break;
2156
2157 case SHAPE_T::POLY:
2158 for( int ii = 0; ii < shape->GetPolyShape().TotalVertices(); ++ii )
2159 processPt( shape->GetPolyShape().CVertex( ii ) );
2160
2161 break;
2162
2163 default:
2164 processPt( shape->GetStart() );
2165 processPt( shape->GetEnd() );
2166 break;
2167 }
2168
2169 break;
2170 }
2171
2172 default:
2173 processPt( item->GetPosition() );
2174 break;
2175 }
2176 }
2177 }
2178
2179 selection.SetIsHover( m_duplicateIsHoverSelection );
2180 }
2181 else
2182 {
2183 SCH_ITEM* item = static_cast<SCH_ITEM*>( selection.GetTopLeftItem() );
2184
2185 selection.SetReferencePoint( item->GetPosition() );
2186 }
2187
2189 {
2190 // Pushing the commit will update the connectivity.
2191 commit.Push( _( "Paste" ) );
2192
2193 if( sheetsPasted )
2195 // UpdateHierarchyNavigator() will call RefreshNetNavigator()
2196 else
2198 }
2199 else
2200 {
2201 commit.Revert();
2202 }
2203 }
2204
2205 return 0;
2206}
2207
2208
2210{
2212 EE_SELECTION& selection = selTool->RequestSelection( { SCH_SYMBOL_T } );
2213 SCH_SYMBOL* symbol = nullptr;
2214 SYMBOL_EDIT_FRAME* symbolEditor;
2215
2216 if( selection.GetSize() >= 1 )
2217 symbol = (SCH_SYMBOL*) selection.Front();
2218
2219 if( selection.IsHover() )
2221
2222 if( !symbol )
2223 {
2224 // Giant hack: by default we assign Edit Table to the same hotkey, so give the table
2225 // tool a chance to handle it if we can't.
2227 tableTool->EditTable( aEvent );
2228
2229 return 0;
2230 }
2231
2232 if( symbol->GetEditFlags() != 0 )
2233 return 0;
2234
2235 if( symbol->IsMissingLibSymbol() )
2236 {
2237 m_frame->ShowInfoBarError( _( "Symbols with broken library symbol links cannot "
2238 "be edited." ) );
2239 return 0;
2240 }
2241
2243 symbolEditor = (SYMBOL_EDIT_FRAME*) m_frame->Kiway().Player( FRAME_SCH_SYMBOL_EDITOR, false );
2244
2245 if( symbolEditor )
2246 {
2247 if( wxWindow* blocking_win = symbolEditor->Kiway().GetBlockingDialog() )
2248 blocking_win->Close( true );
2249
2250 if( aEvent.IsAction( &EE_ACTIONS::editWithLibEdit ) )
2251 {
2252 symbolEditor->LoadSymbolFromSchematic( symbol );
2253 }
2255 {
2256 symbolEditor->LoadSymbol( symbol->GetLibId(), symbol->GetUnit(),
2257 symbol->GetBodyStyle() );
2258
2259 if( !symbolEditor->IsSymbolTreeShown() )
2260 {
2261 wxCommandEvent evt;
2262 symbolEditor->OnToggleSymbolTree( evt );
2263 }
2264 }
2265 }
2266
2267 return 0;
2268}
2269
2270
2272{
2273 wxCommandEvent dummy;
2275 return 0;
2276}
2277
2278
2280{
2281 wxCommandEvent dummy;
2283 return 0;
2284}
2285
2286
2288{
2290
2291 wxCHECK( dlg, 0 );
2292
2293 // Needed at least on Windows. Raise() is not enough
2294 dlg->Show( true );
2295
2296 // Bring it to the top if already open. Dual monitor users need this.
2297 dlg->Raise();
2298
2299 dlg->ShowEditTab();
2300
2301 return 0;
2302}
2303
2304
2306{
2309
2310 return 0;
2311}
2312
2313
2315{
2316 wxCommandEvent dummy;
2318 return 0;
2319}
2320
2321
2323{
2324 wxCommandEvent dummy;
2326 return 0;
2327}
2328
2329
2331{
2333 dlg.ShowModal();
2334 return 0;
2335}
2336
2337
2339{
2340 int result = NET_PLUGIN_CHANGE;
2341
2342 // If a plugin is removed or added, rebuild and reopen the new dialog
2343 while( result == NET_PLUGIN_CHANGE )
2344 result = InvokeDialogNetList( m_frame );
2345
2346 return 0;
2347}
2348
2349
2351{
2353
2354 wxCHECK( dlg, 0 );
2355
2356 // Needed at least on Windows. Raise() is not enough
2357 dlg->Show( true );
2358
2359 // Bring it to the top if already open. Dual monitor users need this.
2360 dlg->Raise();
2361
2362 dlg->ShowExportTab();
2363
2364 return 0;
2365}
2366
2367
2369{
2371 return 0;
2372}
2373
2374
2376{
2379 return 0;
2380}
2381
2382
2384{
2385 getEditFrame<SCH_EDIT_FRAME>()->ToggleSearch();
2386 return 0;
2387}
2388
2389
2391{
2392 getEditFrame<SCH_EDIT_FRAME>()->ToggleSchematicHierarchy();
2393 return 0;
2394}
2395
2396
2398{
2399 getEditFrame<SCH_EDIT_FRAME>()->ToggleNetNavigator();
2400 return 0;
2401}
2402
2403
2405{
2406 getEditFrame<SCH_EDIT_FRAME>()->ToggleProperties();
2407 return 0;
2408}
2409
2410
2412{
2415
2418
2419 return 0;
2420}
2421
2422
2424{
2427
2430
2431 return 0;
2432}
2433
2434
2436{
2439
2442
2443 return 0;
2444}
2445
2446
2448{
2451
2454
2455 return 0;
2456}
2457
2458
2460{
2463
2466
2467 return 0;
2468}
2469
2470
2472{
2475
2478
2479 return 0;
2480}
2481
2482
2484{
2487
2491
2492 return 0;
2493}
2494
2495
2497{
2500
2504
2505 return 0;
2506}
2507
2508
2510{
2513 return 0;
2514}
2515
2516
2518{
2520 m_frame->eeconfig()->m_Drawing.line_mode %= LINE_MODE::LINE_MODE_COUNT;
2522 return 0;
2523}
2524
2525
2527{
2530 return 0;
2531}
2532
2533
2535{
2538 return 0;
2539}
2540
2541
2543{
2544
2546 return 0;
2547}
2548
2549
2551{
2552#ifdef KICAD_IPC_API
2553 Pgm().GetPluginManager().ReloadPlugins();
2554#endif
2555 return 0;
2556}
2557
2558
2560{
2561 int errors = 0;
2562 wxString details;
2563 bool quiet = aEvent.Parameter<bool>();
2564
2565 // Repair duplicate IDs.
2566 std::map<KIID, EDA_ITEM*> ids;
2567 int duplicates = 0;
2568
2569 auto processItem =
2570 [&]( EDA_ITEM* aItem )
2571 {
2572 auto it = ids.find( aItem->m_Uuid );
2573
2574 if( it != ids.end() && it->second != aItem )
2575 {
2576 duplicates++;
2577 const_cast<KIID&>( aItem->m_Uuid ) = KIID();
2578 }
2579
2580 ids[ aItem->m_Uuid ] = aItem;
2581 };
2582
2583 // Symbol IDs are the most important, so give them the first crack at "claiming" a
2584 // particular KIID.
2585
2586 for( const SCH_SHEET_PATH& sheet : m_frame->Schematic().GetSheets() )
2587 {
2588 SCH_SCREEN* screen = sheet.LastScreen();
2589
2590 for( SCH_ITEM* item : screen->Items().OfType( SCH_SYMBOL_T ) )
2591 {
2592 processItem( item );
2593
2594 for( SCH_PIN* pin : static_cast<SCH_SYMBOL*>( item )->GetPins( &sheet ) )
2595 processItem( pin );
2596 }
2597 }
2598
2599 for( const SCH_SHEET_PATH& sheet : m_frame->Schematic().GetSheets() )
2600 {
2601 SCH_SCREEN* screen = sheet.LastScreen();
2602
2603 for( SCH_ITEM* item : screen->Items() )
2604 {
2605 processItem( item );
2606
2607 item->RunOnChildren(
2608 [&]( SCH_ITEM* aChild )
2609 {
2610 processItem( item );
2611 } );
2612 }
2613 }
2614
2615 /*******************************
2616 * Your test here
2617 */
2618
2619 /*******************************
2620 * Inform the user
2621 */
2622
2623 if( duplicates )
2624 {
2625 errors += duplicates;
2626 details += wxString::Format( _( "%d duplicate IDs replaced.\n" ), duplicates );
2627 }
2628
2629 if( errors )
2630 {
2631 m_frame->OnModify();
2632
2633 wxString msg = wxString::Format( _( "%d potential problems repaired." ), errors );
2634
2635 if( !quiet )
2636 DisplayInfoMessage( m_frame, msg, details );
2637 }
2638 else if( !quiet )
2639 {
2640 DisplayInfoMessage( m_frame, _( "No errors found." ) );
2641 }
2642
2643 return 0;
2644}
2645
2646
2648{
2649 if( !Pgm().GetCommonSettings()->m_Input.hotkey_feedback )
2650 return 0;
2651
2652 GRID_SETTINGS& gridSettings = m_toolMgr->GetSettings()->m_Window.grid;
2653 int currentIdx = m_toolMgr->GetSettings()->m_Window.grid.last_size_idx;
2654
2655 wxArrayString gridsLabels;
2656
2657 for( const GRID& grid : gridSettings.grids )
2658 gridsLabels.Add( grid.UserUnitsMessageText( m_frame ) );
2659
2660 if( !m_frame->GetHotkeyPopup() )
2662
2664
2665 if( popup )
2666 popup->Popup( _( "Grid" ), gridsLabels, currentIdx );
2667
2668 return 0;
2669}
2670
2671
2673{
2674 Go( &SCH_EDITOR_CONTROL::New, ACTIONS::doNew.MakeEvent() );
2675 Go( &SCH_EDITOR_CONTROL::Open, ACTIONS::open.MakeEvent() );
2676 Go( &SCH_EDITOR_CONTROL::Save, ACTIONS::save.MakeEvent() );
2683 Go( &SCH_EDITOR_CONTROL::Plot, ACTIONS::plot.MakeEvent() );
2684 Go( &SCH_EDITOR_CONTROL::Quit, ACTIONS::quit.MakeEvent() );
2685
2688
2694
2697
2703
2705
2706 Go( &SCH_EDITOR_CONTROL::Undo, ACTIONS::undo.MakeEvent() );
2707 Go( &SCH_EDITOR_CONTROL::Redo, ACTIONS::redo.MakeEvent() );
2708 Go( &SCH_EDITOR_CONTROL::Cut, ACTIONS::cut.MakeEvent() );
2709 Go( &SCH_EDITOR_CONTROL::Copy, ACTIONS::copy.MakeEvent() );
2713
2715
2732
2737
2751
2754
2756
2761}
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 pluginsReload
Cursor control event types.
Definition: actions.h:224
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:172
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:88
virtual VECTOR2I GetPosition() const
Definition: eda_item.h:242
EDA_ITEM_FLAGS GetEditFlags() const
Definition: eda_item.h:132
const KIID m_Uuid
Definition: eda_item.h:485
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:100
virtual void SetParent(EDA_ITEM *aParent)
Definition: eda_item.h:103
void ClearBrightened()
Definition: eda_item.h:122
EDA_ITEM * GetParent() const
Definition: eda_item.h:102
SHAPE_POLY_SET & GetPolyShape()
Definition: eda_shape.h:274
SHAPE_T GetShape() const
Definition: eda_shape.h:120
const VECTOR2I & GetEnd() const
Return the ending point of the graphic.
Definition: eda_shape.h:162
const VECTOR2I & GetStart() const
Return the starting point of the graphic.
Definition: eda_shape.h:125
std::vector< VECTOR2I > GetRectCorners() const
Definition: eda_shape.cpp:1165
A mix-in class (via multiple inheritance) that handles texts such as labels, parts,...
Definition: eda_text.h:83
virtual const wxString & GetText() const
Return the string associated with the text object.
Definition: eda_text.h:98
PANEL_ANNOTATE m_AnnotatePanel
static TOOL_ACTION importFPAssignments
Definition: ee_actions.h:176
static TOOL_ACTION repairSchematic
Definition: ee_actions.h:260
static TOOL_ACTION remapSymbols
Definition: ee_actions.h:170
static TOOL_ACTION selectionActivate
Activation of the selection tool.
Definition: ee_actions.h:46
static TOOL_ACTION toggleAnnotateAuto
Definition: ee_actions.h:269
static TOOL_ACTION lineMode90
Definition: ee_actions.h:264
static TOOL_ACTION toggleHiddenPins
Definition: ee_actions.h:234
static TOOL_ACTION highlightNet
Definition: ee_actions.h:293
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:121
static TOOL_ACTION clearHighlight
Definition: ee_actions.h:294
static TOOL_ACTION assignNetclass
Definition: ee_actions.h:162
static TOOL_ACTION clearSelection
Clears the current selection.
Definition: ee_actions.h:56
static TOOL_ACTION showPythonConsole
Definition: ee_actions.h:259
static TOOL_ACTION toggleERCWarnings
Definition: ee_actions.h:239
static TOOL_ACTION simTune
Definition: ee_actions.h:282
static TOOL_ACTION toggleERCExclusions
Definition: ee_actions.h:241
static TOOL_ACTION lineModeNext
Definition: ee_actions.h:266
static TOOL_ACTION lineModeFree
Definition: ee_actions.h:263
static TOOL_ACTION editLibSymbolWithLibEdit
Definition: ee_actions.h:174
static TOOL_ACTION generateBOMLegacy
Definition: ee_actions.h:179
static TOOL_ACTION toggleERCErrors
Definition: ee_actions.h:240
static TOOL_ACTION toggleOPCurrents
Definition: ee_actions.h:243
static TOOL_ACTION highlightNetTool
Definition: ee_actions.h:296
static TOOL_ACTION updateNetHighlighting
Definition: ee_actions.h:295
static TOOL_ACTION exportNetlist
Definition: ee_actions.h:177
static TOOL_ACTION assignFootprints
Definition: ee_actions.h:161
static TOOL_ACTION selectOnPCB
Definition: ee_actions.h:246
static TOOL_ACTION rescueSymbols
Definition: ee_actions.h:169
static TOOL_ACTION toggleHiddenFields
Definition: ee_actions.h:235
static TOOL_ACTION editWithLibEdit
Definition: ee_actions.h:173
static TOOL_ACTION simProbe
Definition: ee_actions.h:281
static TOOL_ACTION exportSymbolsToLibrary
Definition: ee_actions.h:182
static TOOL_ACTION drawSheetOnClipboard
Definition: ee_actions.h:255
static TOOL_ACTION editSymbolFields
Definition: ee_actions.h:153
static TOOL_ACTION showNetNavigator
Definition: ee_actions.h:297
static TOOL_ACTION annotate
Definition: ee_actions.h:152
static TOOL_ACTION toggleDirectiveLabels
Definition: ee_actions.h:238
static TOOL_ACTION showHierarchy
Definition: ee_actions.h:226
static TOOL_ACTION toggleOPVoltages
Definition: ee_actions.h:242
static TOOL_ACTION lineMode45
Definition: ee_actions.h:265
static TOOL_ACTION editSymbolLibraryLinks
Definition: ee_actions.h:154
static TOOL_ACTION saveCurrSheetCopyAs
Definition: ee_actions.h:42
static TOOL_ACTION showPcbNew
Definition: ee_actions.h:175
static TOOL_ACTION generateBOM
Definition: ee_actions.h:178
static TOOL_ACTION schematicSetup
Definition: ee_actions.h:163
static TOOL_ACTION exportSymbolsToNewLibrary
Definition: ee_actions.h:183
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:50
static const TOOL_EVENT ClearedEvent
Definition: actions.h:262
static const TOOL_EVENT GridChangedByKeyEvent
Definition: actions.h:280
static const TOOL_EVENT SelectedEvent
Definition: actions.h:260
static const TOOL_EVENT SelectedItemsModified
Selected items were moved, this can be very high frequency on the canvas, use with care.
Definition: actions.h:267
static const TOOL_EVENT PointSelectedEvent
Definition: actions.h:259
static const TOOL_EVENT UnselectedEvent
Definition: actions.h:261
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:1631
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:1513
void Hide(VIEW_ITEM *aItem, bool aHide=true, bool aHideOverlay=false)
Temporarily hide the item in the view (e.g.
Definition: view.cpp:1579
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:347
wxString AsString() const
Definition: kiid.cpp:368
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:55
A wxFrame capable of the OpenProjectFiles function, meaning it can load a portion of a KiCad project.
Definition: kiway_player.h:65
virtual KIWAY_PLAYER * Player(FRAME_T aFrameType, bool doCreate=true, wxTopLevelWindow *aParent=nullptr)
Return the KIWAY_PLAYER* given a FRAME_T.
Definition: kiway.cpp:406
wxWindow * GetBlockingDialog()
Gets the window pointer to the blocking dialog (to send it signals)
Definition: kiway.cpp:669
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
Define a library symbol object.
Definition: lib_symbol.h:77
const LIB_ID & GetLibId() const override
Definition: lib_symbol.h:142
wxString GetName() const override
Definition: lib_symbol.h:136
std::unique_ptr< LIB_SYMBOL > Flatten() const
Return a flattened symbol inheritance to the caller.
Definition: lib_symbol.cpp:579
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:87
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:283
SCHEMATIC_SETTINGS & Settings() const
Definition: schematic.cpp:289
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:406
virtual void Revert() override
Definition: sch_commit.cpp:484
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)
int ReloadPlugins(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:166
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:107
void UpdateHierarchyNavigator(bool aRefreshNetNavigator=true)
Update the hierarchy navigation tree and history.
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:613
void RefreshNetNavigator(const NET_NAVIGATOR_ITEM_DATA *aSelection=nullptr)
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 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:51
void SetText(const wxString &aText) override
Definition: sch_field.cpp:1138
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:174
virtual bool IsConnectable() const
Definition: sch_item.h:457
SCHEMATIC * Schematic() const
Searches the item hierarchy to find a SCHEMATIC.
Definition: sch_item.cpp:145
virtual void SetLastResolvedState(const SCH_ITEM *aItem)
Definition: sch_item.h:549
int GetBodyStyle() const
Definition: sch_item.h:240
int GetUnit() const
Definition: sch_item.h:237
void SetConnectivityDirty(bool aDirty=true)
Definition: sch_item.h:520
bool IsConnectivityDirty() const
Definition: sch_item.h:518
virtual void SetUnit(int aUnit)
Definition: sch_item.h:236
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:216
virtual std::vector< VECTOR2I > GetConnectionPoints() const
Add all the connection points for this item to aPoints.
Definition: sch_item.h:472
Segment description base class to describe items which have 2 end points (track, wire,...
Definition: sch_line.h:41
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:703
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:152
void Clear(bool aFree=true)
Delete all draw items and clears the project settings.
Definition: sch_screen.cpp:277
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:777
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:480
double m_LastZoomLevel
last value for the zoom level, useful in Eeschema when changing the current displayed sheet to reuse ...
Definition: sch_screen.h:627
EE_RTREE & Items()
Gets the full RTree, usually for iterating.
Definition: sch_screen.h:108
const wxString & GetFileName() const
Definition: sch_screen.h:143
bool Remove(SCH_ITEM *aItem, bool aUpdateLibSymbol=true)
Remove aItem from the schematic associated with this screen.
Definition: sch_screen.cpp:322
bool CheckIfOnDrawList(const SCH_ITEM *aItem) const
Definition: sch_screen.cpp:385
void MigrateSimModels()
Migrate any symbols having V6 simulation models to their V7 equivalents.
VECTOR2I GetCenter() const
Definition: sch_shape.h:73
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:306
void RemoveInstance(const KIID_PATH &aInstancePath)
Definition: sch_sheet.cpp:1275
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:1296
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:393
Schematic symbol object.
Definition: sch_symbol.h:105
const std::vector< SCH_SYMBOL_INSTANCE > & GetInstances() const
Definition: sch_symbol.h:164
wxString GetSchSymbolLibraryName() const
Definition: sch_symbol.cpp:266
SCH_FIELD * GetField(MANDATORY_FIELD_T aFieldType)
Return a mandatory field in this symbol.
Definition: sch_symbol.cpp:912
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:613
bool IsMissingLibSymbol() const
Check to see if the library symbol is set to the dummy library symbol.
Definition: sch_symbol.cpp:233
const LIB_ID & GetLibId() const override
Definition: sch_symbol.h:194
void GetFields(std::vector< SCH_FIELD * > &aVector, bool aVisibleOnly)
Populate a std::vector with SCH_FIELDs.
Definition: sch_symbol.cpp:960
std::unique_ptr< LIB_SYMBOL > & GetLibSymbolRef()
Definition: sch_symbol.h:213
void SetLibSymbol(LIB_SYMBOL *aLibSymbol)
Set this schematic symbol library symbol reference to aLibSymbol.
Definition: sch_symbol.cpp:275
const wxString GetRef(const SCH_SHEET_PATH *aSheet, bool aIncludeUnit=false) const override
Definition: sch_symbol.cpp:713
bool IsPower() const override
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.
void AddCurrentTrace(const wxString &aDeviceName)
Add a current trace for a given device to the current plot.
void AddVoltageTrace(const wxString &aNetName)
Add a voltage trace for a given net to the current plot.
SIM_MODEL & CreateModel(SIM_MODEL::TYPE aType, const std::vector< SCH_PIN * > &aPins, REPORTER &aReporter)
int FindModelPinIndex(const std::string &aSymbolPinNumber)
Definition: sim_model.cpp:708
const SPICE_GENERATOR & SpiceGenerator() const
Definition: sim_model.h:435
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:217
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:62
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:150
std::string GetClipboardUTF8() const
Return the information currently stored in the system clipboard.
TOOLS_HOLDER * GetToolHolder() const
Definition: tool_manager.h:402
APP_SETTINGS_BASE * GetSettings() const
Definition: tool_manager.h:400
bool PostAction(const std::string &aActionName, T aParam)
Run the specified action after the current action (coroutine) ends.
Definition: tool_manager.h:235
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:197
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:80
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:250
void DisplayError(wxWindow *aParent, const wxString &aText, int aDisplayTime)
Display an error or warning message box with aMessage.
Definition: confirm.cpp:170
void DisplayInfoMessage(wxWindow *aParent, const wxString &aMessage, const wxString &aExtraInfo)
Display an informational message box with aMessage.
Definition: confirm.cpp:222
void DisplayErrorMessage(wxWindow *aParent, const wxString &aText, const wxString &aExtraInfo)
Display an error message with aMessage.
Definition: confirm.cpp:195
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:111
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:532
#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:78
@ LAYER_ERC_WARN
Definition: layer_ids.h:383
@ LAYER_ERC_EXCLUSION
Definition: layer_ids.h:385
@ LAYER_ERC_ERR
Definition: layer_ids.h:384
@ LAYER_OP_CURRENTS
Definition: layer_ids.h:402
@ LAYER_OP_VOLTAGES
Definition: layer_ids.h:401
@ 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
PGM_BASE & Pgm()
The global Program "get" accessor.
Definition: pgm_base.cpp:1059
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.
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:73
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:163
@ SCH_SYMBOL_T
Definition: typeinfo.h:172
@ SCH_FIELD_T
Definition: typeinfo.h:150
@ SCH_SHEET_T
Definition: typeinfo.h:174
@ SCH_MARKER_T
Definition: typeinfo.h:158
@ SCH_SHAPE_T
Definition: typeinfo.h:149
@ SCH_PIN_T
Definition: typeinfo.h:153
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:118
VECTOR2< int > VECTOR2I
Definition: vector2d.h:602
Definition of file extensions used in Kicad.
#define FN_NORMALIZE_FLAGS
Default flags to pass to wxFileName::Normalize().
Definition: wx_filename.h:39