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
363 SCH_REFERENCE_LIST symbols;
364 sheets.GetSymbols( symbols, savePowerSymbols );
365
366 std::map<LIB_ID, LIB_SYMBOL*> libSymbols;
367 std::map<LIB_ID, std::vector<SCH_SYMBOL*>> symbolMap;
368
369 for( size_t i = 0; i < symbols.GetCount(); ++i )
370 {
371 SCH_SYMBOL* symbol = symbols[i].GetSymbol();
372 LIB_SYMBOL* libSymbol = symbol->GetLibSymbolRef().get();
373 LIB_ID id = libSymbol->GetLibId();
374
375 if( libSymbols.count( id ) )
376 {
377 wxASSERT_MSG( libSymbols[id]->Compare( *libSymbol, SCH_ITEM::COMPARE_FLAGS::ERC ) == 0,
378 "Two symbols have the same LIB_ID but are different!" );
379 }
380 else
381 {
382 libSymbols[id] = libSymbol;
383 }
384
385 symbolMap[id].emplace_back( symbol );
386 }
387
389
390 wxString targetLib;
391
392 if( createNew )
393 {
394 wxFileName fn;
396
397 if( !libTable ) // Cancelled by user
398 return 0;
399
402 ( libTable == &SYMBOL_LIB_TABLE::GetGlobalLibTable() ),
404 {
405 return 0;
406 }
407
408 targetLib = fn.GetName();
409
410 if( libTable->HasLibrary( targetLib, false ) )
411 {
412 DisplayError( m_frame, wxString::Format( _( "Library '%s' already exists." ),
413 targetLib ) );
414 return 0;
415 }
416
417 // if the "new" library is in fact an existing library and the used asked for replacing
418 // it by the recreated lib, erase it:
419 if( fn.FileExists() )
420 wxRemoveFile( fn.GetFullPath() );
421
422 if( !mgr.CreateLibrary( fn.GetFullPath(), libTable ) )
423 {
424 DisplayError( m_frame, wxString::Format( _( "Could not add library '%s'." ),
425 targetLib ) );
426 return 0;
427 }
428 }
429 else
430 {
431 targetLib = m_frame->SelectLibraryFromList();
432 }
433
434 if( targetLib.IsEmpty() )
435 return 0;
436
437 bool map = IsOK( m_frame, _( "Update symbols in schematic to refer to new library?" ) );
438 bool append = false;
439
440 SYMBOL_LIB_TABLE_ROW* row = mgr.GetLibrary( targetLib );
441 SCH_IO_MGR::SCH_FILE_T type = SCH_IO_MGR::EnumFromStr( row->GetType() );
442 IO_RELEASER<SCH_IO> pi( SCH_IO_MGR::FindPlugin( type ) );
443
444 wxFileName dest = row->GetFullURI( true );
445 dest.Normalize( FN_NORMALIZE_FLAGS | wxPATH_NORM_ENV_VARS );
446
447 for( const std::pair<const LIB_ID, LIB_SYMBOL*>& it : libSymbols )
448 {
449 LIB_SYMBOL* origSym = it.second;
450 LIB_SYMBOL* newSym = origSym->Flatten().release();
451
452 try
453 {
454 pi->SaveSymbol( dest.GetFullPath(), newSym );
455 }
456 catch( const IO_ERROR& ioe )
457 {
458 wxString msg;
459 msg.Printf( _( "Error saving symbol %s to library '%s'." ),
460 newSym->GetName(), row->GetNickName() );
461 msg += wxS( "\n\n" ) + ioe.What();
462 wxLogWarning( msg );
463 return 0;
464 }
465
466 if( map )
467 {
468 LIB_ID id = it.first;
469 id.SetLibNickname( targetLib );
470
471 for( SCH_SYMBOL* symbol : symbolMap[it.first] )
472 {
473 m_frame->SaveCopyInUndoList( m_frame->GetScreen(), symbol, UNDO_REDO::CHANGED,
474 append, false );
475 symbol->SetLibId( id );
476 append = true;
477 }
478 }
479 }
480
481 // Save the modified symbol library table. We need to look this up by name in each table to find
482 // whether the new library is a global or project entity as the code above to choose the library
483 // returns a different type depending on whether a global or project library is chosen.
485 SYMBOL_LIB_TABLE* projectTable = nullptr;
486
487 if( !m_frame->Prj().IsNullProject() )
488 projectTable = PROJECT_SCH::SchSymbolLibTable( &m_frame->Prj() );
489
490 if( globalTable->FindRow( targetLib ) )
491 {
492 try
493 {
494 wxString globalTablePath = SYMBOL_LIB_TABLE::GetGlobalTableFileName();
495 globalTable->Save( globalTablePath );
496 }
497 catch( const IO_ERROR& ioe )
498 {
499 wxString msg;
500 msg.Printf( _( "Error saving global library table:\n\n%s" ), ioe.What() );
501 wxMessageBox( msg, _( "File Save Error" ), wxOK | wxICON_ERROR );
502 }
503 }
504 else if( projectTable && projectTable->FindRow( targetLib ) )
505 {
506 try
507 {
508 wxString projectPath = m_frame->Prj().GetProjectPath();
509 wxFileName projectTableFn( projectPath, SYMBOL_LIB_TABLE::GetSymbolLibTableFileName() );
510 projectTable->Save( projectTableFn.GetFullPath() );
511 }
512 catch( const IO_ERROR& ioe )
513 {
514 wxString msg;
515 msg.Printf( _( "Error saving project-specific library table:\n\n%s" ), ioe.What() );
516 wxMessageBox( msg, _( "File Save Error" ), wxOK | wxICON_ERROR );
517 }
518 }
519
520 if( append )
521 {
522 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 wxString spiceNet = UnescapeString( conn->Name() );
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 auto invalidateTextVars =
1018 [&flags]( EDA_TEXT* text )
1019 {
1020 if( text->HasTextVars() )
1021 {
1022 text->ClearRenderCache();
1023 text->ClearBoundingBoxCache();
1025 }
1026 };
1027
1028 // Netclass coloured items
1029 //
1030 if( dynamic_cast<SCH_LINE*>( aItem ) )
1031 flags |= KIGFX::REPAINT;
1032 else if( dynamic_cast<SCH_JUNCTION*>( aItem ) )
1033 flags |= KIGFX::REPAINT;
1034 else if( dynamic_cast<SCH_BUS_ENTRY_BASE*>( aItem ) )
1035 flags |= KIGFX::REPAINT;
1036
1037 // Items that might reference an item's netclass name
1038 //
1039 if( SCH_ITEM* item = dynamic_cast<SCH_ITEM*>( aItem ) )
1040 {
1041 item->RunOnChildren(
1042 [&invalidateTextVars]( SCH_ITEM* aChild )
1043 {
1044 if( EDA_TEXT* text = dynamic_cast<EDA_TEXT*>( aChild ) )
1045 invalidateTextVars( text );
1046 } );
1047
1048 if( flags & KIGFX::GEOMETRY )
1049 m_frame->GetScreen()->Update( item, false ); // Refresh RTree
1050 }
1051
1052 if( EDA_TEXT* text = dynamic_cast<EDA_TEXT*>( aItem ) )
1053 invalidateTextVars( text );
1054
1055 return flags;
1056 } );
1057 }
1058
1059 highlightNet( m_toolMgr, CLEAR );
1060 return 0;
1061}
1062
1063
1065{
1066 wxCHECK( m_frame, 0 );
1067
1068 const SCH_SHEET_PATH& sheetPath = m_frame->GetCurrentSheet();
1070 CONNECTION_GRAPH* connectionGraph = m_frame->Schematic().ConnectionGraph();
1071 wxString selectedName = m_frame->GetHighlightedConnection();
1072
1073 std::set<wxString> connNames;
1074 std::vector<EDA_ITEM*> itemsToRedraw;
1075
1076 wxCHECK( screen && connectionGraph, 0 );
1077
1078 if( !selectedName.IsEmpty() )
1079 {
1080 connNames.emplace( selectedName );
1081
1082 CONNECTION_SUBGRAPH* sg = connectionGraph->FindSubgraphByName( selectedName, sheetPath );
1083
1084 if( sg && m_highlightBusMembers )
1085 {
1086 for( const SCH_ITEM* item : sg->GetItems() )
1087 {
1088 wxCHECK2( item, continue );
1089
1090 SCH_CONNECTION* connection = item->Connection();
1091
1092 wxCHECK2( connection, continue );
1093
1094 for( const std::shared_ptr<SCH_CONNECTION>& member : connection->AllMembers() )
1095 {
1096 if( member )
1097 connNames.emplace( member->Name() );
1098 }
1099 }
1100 }
1101 }
1102
1103 for( SCH_ITEM* item : screen->Items() )
1104 {
1105 wxCHECK2( item, continue );
1106
1107 if( !item->IsConnectable() )
1108 continue;
1109
1110 SCH_ITEM* redrawItem = nullptr;
1111
1112 if( item->Type() == SCH_SYMBOL_T )
1113 {
1114 SCH_SYMBOL* symbol = static_cast<SCH_SYMBOL*>( item );
1115
1116 wxCHECK2( symbol, continue );
1117
1118 for( SCH_PIN* pin : symbol->GetPins() )
1119 {
1120 SCH_CONNECTION* pin_conn = pin->Connection();
1121
1122 wxCHECK2( pin_conn, continue );
1123
1124 if( !pin->IsBrightened() && connNames.count( pin_conn->Name() ) )
1125 {
1126 pin->SetBrightened();
1127 redrawItem = symbol;
1128 }
1129 else if( pin->IsBrightened() && !connNames.count( pin_conn->Name() ) )
1130 {
1131 pin->ClearBrightened();
1132 redrawItem = symbol;
1133 }
1134 }
1135
1136 if( symbol->IsPower() )
1137 {
1138 wxCHECK2( symbol->GetPins().size(), continue );
1139
1140 SCH_CONNECTION* pinConn = symbol->GetPins()[0]->Connection();
1141
1142 wxCHECK2( pinConn, continue );
1143
1144 std::vector<SCH_FIELD>& fields = symbol->GetFields();
1145
1146 for( int id : { REFERENCE_FIELD, VALUE_FIELD } )
1147 {
1148 if( !fields[id].IsVisible() )
1149 continue;
1150
1151 if( !fields[id].IsBrightened() && connNames.count( pinConn->Name() ) )
1152 {
1153 fields[id].SetBrightened();
1154 redrawItem = symbol;
1155 }
1156 else if( fields[id].IsBrightened() && !connNames.count( pinConn->Name() ) )
1157 {
1158 fields[id].ClearBrightened();
1159 redrawItem = symbol;
1160 }
1161 }
1162 }
1163 }
1164 else if( item->Type() == SCH_SHEET_T )
1165 {
1166 SCH_SHEET* sheet = static_cast<SCH_SHEET*>( item );
1167
1168 wxCHECK2( sheet, continue );
1169
1170 for( SCH_SHEET_PIN* pin : sheet->GetPins() )
1171 {
1172 wxCHECK2( pin, continue );
1173
1174 SCH_CONNECTION* pin_conn = pin->Connection();
1175
1176 wxCHECK2( pin_conn, continue );
1177
1178 if( !pin->IsBrightened() && connNames.count( pin_conn->Name() ) )
1179 {
1180 pin->SetBrightened();
1181 redrawItem = sheet;
1182 }
1183 else if( pin->IsBrightened() && !connNames.count( pin_conn->Name() ) )
1184 {
1185 pin->ClearBrightened();
1186 redrawItem = sheet;
1187 }
1188 }
1189 }
1190 else
1191 {
1192 SCH_CONNECTION* itemConn = item->Connection();
1193
1194 wxCHECK2( itemConn, continue );
1195
1196 if( !item->IsBrightened() && connNames.count( itemConn->Name() ) )
1197 {
1198 item->SetBrightened();
1199 redrawItem = item;
1200 }
1201 else if( item->IsBrightened() && !connNames.count( itemConn->Name() ) )
1202 {
1203 item->ClearBrightened();
1204 redrawItem = item;
1205 }
1206 }
1207
1208 if( redrawItem )
1209 itemsToRedraw.push_back( redrawItem );
1210 }
1211
1212 if( itemsToRedraw.size() )
1213 {
1214 // Be sure highlight change will be redrawn
1215 KIGFX::VIEW* view = getView();
1216
1217 for( EDA_ITEM* redrawItem : itemsToRedraw )
1219
1221 }
1222
1223 return 0;
1224}
1225
1226
1228{
1230
1231 // Deactivate other tools; particularly important if another PICKER is currently running
1232 Activate();
1233
1234 picker->SetCursor( KICURSOR::BULLSEYE );
1235 picker->SetSnapping( false );
1236
1237 picker->SetClickHandler(
1238 [this] ( const VECTOR2D& aPos )
1239 {
1240 return highlightNet( m_toolMgr, aPos );
1241 } );
1242
1244
1245 return 0;
1246}
1247
1248
1250{
1251 wxCHECK( m_frame, 0 );
1252
1253 if( m_frame->GetUndoCommandCount() <= 0 )
1254 return 0;
1255
1256 // Inform tools that undo command was issued
1258
1259 // Get the old list
1261
1262 wxCHECK( undo_list, 0 );
1263
1264 m_frame->PutDataInPreviousState( undo_list );
1265
1266 // Now push the old command to the RedoList
1267 undo_list->ReversePickersListOrder();
1268 m_frame->PushCommandToRedoList( undo_list );
1269
1270 m_toolMgr->GetTool<EE_SELECTION_TOOL>()->RebuildSelection();
1271
1273 m_frame->OnModify();
1274
1275 return 0;
1276}
1277
1278
1280{
1281 wxCHECK( m_frame, 0 );
1282
1283 if( m_frame->GetRedoCommandCount() == 0 )
1284 return 0;
1285
1286 // Inform tools that undo command was issued
1288
1289 /* Get the old list */
1291
1292 wxCHECK( list, 0 );
1293
1294 /* Redo the command: */
1296
1297 /* Put the old list in UndoList */
1300
1301 m_toolMgr->GetTool<EE_SELECTION_TOOL>()->RebuildSelection();
1302
1304 m_frame->OnModify();
1305
1306 return 0;
1307}
1308
1309
1310bool SCH_EDITOR_CONTROL::doCopy( bool aUseDuplicateClipboard )
1311{
1313 EE_SELECTION& selection = selTool->RequestSelection();
1314 SCHEMATIC& schematic = m_frame->Schematic();
1315
1316 if( selection.Empty() )
1317 return false;
1318
1319 if( aUseDuplicateClipboard )
1320 m_duplicateIsHoverSelection = selection.IsHover();
1321
1322 selection.SetScreen( m_frame->GetScreen() );
1324
1325 for( EDA_ITEM* item : selection )
1326 {
1327 if( item->Type() == SCH_SHEET_T )
1328 {
1329 SCH_SHEET* sheet = (SCH_SHEET*) item;
1330 m_supplementaryClipboard[ sheet->GetFileName() ] = sheet->GetScreen();
1331 }
1332 else if( item->Type() == SCH_FIELD_T && selection.IsHover() )
1333 {
1334 // Most of the time the user is trying to duplicate the parent symbol
1335 // and the field text is in it
1336 selection.Add( item->GetParent() );
1337 }
1338 else if( item->Type() == SCH_MARKER_T )
1339 {
1340 // Don't let the markers be copied
1341 selection.Remove( item );
1342 }
1343 }
1344
1345 STRING_FORMATTER formatter;
1346 SCH_IO_KICAD_SEXPR plugin;
1348
1349 plugin.Format( &selection, &selPath, schematic, &formatter, true );
1350
1351 if( selection.IsHover() )
1353
1354 if( aUseDuplicateClipboard )
1355 {
1356 m_duplicateClipboard = formatter.GetString();
1357 return true;
1358 }
1359
1360 return m_toolMgr->SaveClipboard( formatter.GetString() );
1361}
1362
1363
1364bool SCH_EDITOR_CONTROL::searchSupplementaryClipboard( const wxString& aSheetFilename,
1365 SCH_SCREEN** aScreen )
1366{
1367 if( m_supplementaryClipboard.count( aSheetFilename ) > 0 )
1368 {
1369 *aScreen = m_supplementaryClipboard[ aSheetFilename ];
1370 return true;
1371 }
1372
1373 return false;
1374}
1375
1376
1378{
1379 doCopy( true ); // Use the local clipboard
1380 Paste( aEvent );
1381
1382 return 0;
1383}
1384
1385
1387{
1388 wxTextEntry* textEntry = dynamic_cast<wxTextEntry*>( wxWindow::FindFocus() );
1389
1390 if( textEntry )
1391 {
1392 textEntry->Cut();
1393 return 0;
1394 }
1395
1396 if( doCopy() )
1398
1399 return 0;
1400}
1401
1402
1404{
1405 wxTextEntry* textEntry = dynamic_cast<wxTextEntry*>( wxWindow::FindFocus() );
1406
1407 if( textEntry )
1408 {
1409 textEntry->Copy();
1410 return 0;
1411 }
1412
1413 doCopy();
1414
1415 return 0;
1416}
1417
1418
1420 const SCH_SHEET_PATH& aPastePath,
1421 const KIID_PATH& aClipPath,
1422 bool aForceKeepAnnotations )
1423{
1424 wxCHECK( m_frame && aSymbol, /* void */ );
1425
1426 SCH_SYMBOL_INSTANCE newInstance;
1427 bool instanceFound = false;
1428 KIID_PATH pasteLookupPath = aClipPath;
1429
1430 m_pastedSymbols.insert( aSymbol );
1431
1432 for( const SCH_SYMBOL_INSTANCE& tmp : aSymbol->GetInstances() )
1433 {
1434 if( ( tmp.m_Path.empty() && aClipPath.empty() )
1435 || ( !aClipPath.empty() && tmp.m_Path.EndsWith( aClipPath ) ) )
1436 {
1437 newInstance = tmp;
1438 instanceFound = true;
1439
1440 wxLogTrace( traceSchPaste,
1441 wxS( "Pasting found symbol instance with reference %s, unit %d:"
1442 "\n\tClipboard path: %s\n\tSymbol UUID: %s." ),
1443 tmp.m_Reference, tmp.m_Unit,
1444 aClipPath.AsString(), aSymbol->m_Uuid.AsString() );
1445
1446 break;
1447 }
1448 }
1449
1450 // The pasted symbol look up paths include the symbol UUID.
1451 pasteLookupPath.push_back( aSymbol->m_Uuid );
1452
1453 if( !instanceFound )
1454 {
1455 wxLogTrace( traceSchPaste,
1456 wxS( "Clipboard symbol instance **not** found:\n\tClipboard path: %s\n\t"
1457 "Symbol UUID: %s." ),
1458 aClipPath.AsString(), aSymbol->m_Uuid.AsString() );
1459
1460 // Some legacy versions saved value fields escaped. While we still do in the symbol
1461 // editor, we don't anymore in the schematic, so be sure to unescape them.
1462 SCH_FIELD* valueField = aSymbol->GetField( VALUE_FIELD );
1463 valueField->SetText( UnescapeString( valueField->GetText() ) );
1464
1465 // Pasted from notepad or an older instance of eeschema. Use the values in the fields
1466 // instead.
1467 newInstance.m_Reference = aSymbol->GetField( REFERENCE_FIELD )->GetText();
1468 newInstance.m_Unit = aSymbol->GetUnit();
1469 }
1470
1471 newInstance.m_Path = aPastePath.Path();
1472 newInstance.m_ProjectName = m_frame->Prj().GetProjectName();
1473
1474 aSymbol->AddHierarchicalReference( newInstance );
1475
1476 if( !aForceKeepAnnotations )
1477 aSymbol->ClearAnnotation( &aPastePath, false );
1478
1479 // We might clear annotations but always leave the original unit number from the paste.
1480 aSymbol->SetUnit( newInstance.m_Unit );
1481}
1482
1483
1485 const SCH_SHEET_PATH& aPastePath,
1486 const KIID_PATH& aClipPath,
1487 bool aForceKeepAnnotations,
1488 SCH_SHEET_LIST* aPastedSheets,
1489 std::map<SCH_SHEET_PATH,
1490 SCH_REFERENCE_LIST>& aPastedSymbols )
1491{
1492 wxCHECK( aSheet && aPastedSheets, aPastePath );
1493
1494 SCH_SHEET_PATH sheetPath = aPastePath;
1495 sheetPath.push_back( aSheet );
1496
1497 aPastedSheets->push_back( sheetPath );
1498
1499 if( aSheet->GetScreen() == nullptr )
1500 return sheetPath; // We can only really set the page number but not load any items
1501
1502 for( SCH_ITEM* item : aSheet->GetScreen()->Items() )
1503 {
1504 if( item->IsConnectable() )
1505 item->SetConnectivityDirty();
1506
1507 if( item->Type() == SCH_SYMBOL_T )
1508 {
1509 SCH_SYMBOL* symbol = static_cast<SCH_SYMBOL*>( item );
1510
1511 wxCHECK2( symbol, continue );
1512
1513 // Only do this once if the symbol is shared across multiple sheets.
1514 if( !m_pastedSymbols.count( symbol ) )
1515 {
1516 for( SCH_PIN* pin : symbol->GetPins() )
1517 {
1518 const_cast<KIID&>( pin->m_Uuid ) = KIID();
1519 pin->SetConnectivityDirty();
1520 }
1521 }
1522
1523 updatePastedSymbol( symbol, sheetPath, aClipPath, aForceKeepAnnotations );
1524 }
1525 else if( item->Type() == SCH_SHEET_T )
1526 {
1527 SCH_SHEET* subsheet = static_cast<SCH_SHEET*>( item );
1528
1529 wxCHECK2( subsheet, continue );
1530
1531 // Make sure pins get a new UUID and set the dirty connectivity flag.
1532 if( !aPastedSheets->ContainsSheet( subsheet ) )
1533 {
1534 for( SCH_SHEET_PIN* pin : subsheet->GetPins() )
1535 {
1536 const_cast<KIID&>( pin->m_Uuid ) = KIID();
1537 pin->SetConnectivityDirty();
1538 }
1539 }
1540
1541 KIID_PATH newClipPath = aClipPath;
1542 newClipPath.push_back( subsheet->m_Uuid );
1543
1544 updatePastedSheet( subsheet, sheetPath, newClipPath, aForceKeepAnnotations,
1545 aPastedSheets, aPastedSymbols );
1546 }
1547 }
1548
1549 sheetPath.GetSymbols( aPastedSymbols[aPastePath] );
1550
1551 return sheetPath;
1552}
1553
1554
1556{
1557 wxCHECK( aScreen, /* void */ );
1558
1559 for( const SCH_ITEM* item : aScreen->Items() )
1560 {
1561 if( item->Type() == SCH_SYMBOL_T )
1562 {
1563 const SCH_SYMBOL* symbol = static_cast<const SCH_SYMBOL*>( item );
1564
1565 wxCHECK2( symbol, continue );
1566
1567 for( const SCH_SYMBOL_INSTANCE& symbolInstance : symbol->GetInstances() )
1568 {
1569 KIID_PATH pathWithSymbol = symbolInstance.m_Path;
1570
1571 pathWithSymbol.push_back( symbol->m_Uuid );
1572
1573 m_clipboardSymbolInstances[pathWithSymbol] = symbolInstance;
1574 }
1575 }
1576 }
1577}
1578
1579
1581{
1582 wxCHECK( m_frame, /* void */ );
1583
1584 for( SCH_SYMBOL* symbol : m_pastedSymbols )
1585 {
1586 wxCHECK2( symbol, continue );
1587
1588 std::vector<KIID_PATH> instancePathsToRemove;
1589
1590 for( const SCH_SYMBOL_INSTANCE& instance : symbol->GetInstances() )
1591 {
1592 if( ( instance.m_ProjectName != m_frame->Prj().GetProjectName() )
1593 || instance.m_Path.empty() )
1594 instancePathsToRemove.emplace_back( instance.m_Path );
1595 }
1596
1597 for( const KIID_PATH& path : instancePathsToRemove )
1598 symbol->RemoveInstance( path );
1599 }
1600}
1601
1602
1604{
1605 wxTextEntry* textEntry = dynamic_cast<wxTextEntry*>( wxWindow::FindFocus() );
1606
1607 if( textEntry )
1608 {
1609 textEntry->Paste();
1610 return 0;
1611 }
1612
1614 std::string content;
1615 VECTOR2I eventPos;
1616
1617 if( aEvent.IsAction( &ACTIONS::duplicate ) )
1618 content = m_duplicateClipboard;
1619 else
1620 content = m_toolMgr->GetClipboardUTF8();
1621
1622 if( content.empty() )
1623 return 0;
1624
1625 if( aEvent.IsAction( &ACTIONS::duplicate ) )
1626 eventPos = getViewControls()->GetCursorPosition( false );
1627
1628 STRING_LINE_READER reader( content, "Clipboard" );
1629 SCH_IO_KICAD_SEXPR plugin;
1630
1631 SCH_SHEET tempSheet;
1632 SCH_SCREEN* tempScreen = new SCH_SCREEN( &m_frame->Schematic() );
1633
1635 int annotateStartNum = m_frame->Schematic().Settings().m_AnnotateStartNum;
1636
1637 // Screen object on heap is owned by the sheet.
1638 tempSheet.SetScreen( tempScreen );
1639
1640 try
1641 {
1642 plugin.LoadContent( reader, &tempSheet );
1643 }
1644 catch( IO_ERROR& )
1645 {
1646 // If it wasn't content, then paste as text object.
1647 SCH_TEXT* text_item = new SCH_TEXT( VECTOR2I( 0, 0 ), content );
1648 tempScreen->Append( text_item );
1649 }
1650
1651 m_pastedSymbols.clear();
1653
1654 // Save pasted symbol instances in case the user chooses to keep existing symbol annotation.
1655 setPastedSymbolInstances( tempScreen );
1656
1657 tempScreen->MigrateSimModels();
1658
1659 PASTE_MODE pasteMode = annotate.automatic ? PASTE_MODE::RESPECT_OPTIONS
1660 : PASTE_MODE::REMOVE_ANNOTATIONS;
1661
1662 if( aEvent.IsAction( &ACTIONS::pasteSpecial ) )
1663 {
1664 DIALOG_PASTE_SPECIAL dlg( m_frame, &pasteMode );
1665
1666 if( dlg.ShowModal() == wxID_CANCEL )
1667 return 0;
1668 }
1669
1670 bool forceKeepAnnotations = pasteMode != PASTE_MODE::REMOVE_ANNOTATIONS;
1671
1672 // SCH_SEXP_PLUGIN added the items to the paste screen, but not to the view or anything
1673 // else. Pull them back out to start with.
1674 SCH_COMMIT commit( m_toolMgr );
1675 EDA_ITEMS loadedItems;
1676 std::vector<SCH_ITEM*> sortedLoadedItems;
1677 bool sheetsPasted = false;
1679 SCH_SHEET_PATH& pasteRoot = m_frame->GetCurrentSheet();
1680 wxFileName destFn = pasteRoot.Last()->GetFileName();
1681
1682 if( destFn.IsRelative() )
1683 destFn.MakeAbsolute( m_frame->Prj().GetProjectPath() );
1684
1685 // List of paths in the hierarchy that refer to the destination sheet of the paste
1686 SCH_SHEET_LIST sheetPathsForScreen = hierarchy.FindAllSheetsForScreen( pasteRoot.LastScreen() );
1687 sheetPathsForScreen.SortByPageNumbers();
1688
1689 // Build a list of screens from the current design (to avoid loading sheets that already exist)
1690 std::map<wxString, SCH_SCREEN*> loadedScreens;
1691
1692 for( const SCH_SHEET_PATH& item : hierarchy )
1693 {
1694 if( item.LastScreen() )
1695 loadedScreens[item.Last()->GetFileName()] = item.LastScreen();
1696 }
1697
1698 // Build symbol list for reannotation of duplicates
1699 SCH_REFERENCE_LIST existingRefs;
1700 hierarchy.GetSymbols( existingRefs );
1701 existingRefs.SortByReferenceOnly();
1702
1703 // Build UUID map for fetching last-resolved-properties
1704 std::map<KIID, EDA_ITEM*> itemMap;
1705 hierarchy.FillItemMap( itemMap );
1706
1707 // Keep track of pasted sheets and symbols for the different paths to the hierarchy.
1708 std::map<SCH_SHEET_PATH, SCH_REFERENCE_LIST> pastedSymbols;
1709 std::map<SCH_SHEET_PATH, SCH_SHEET_LIST> pastedSheets;
1710
1711 for( SCH_ITEM* item : tempScreen->Items() )
1712 {
1713 if( item->Type() == SCH_SHEET_T )
1714 sortedLoadedItems.push_back( item );
1715 else
1716 loadedItems.push_back( item );
1717 }
1718
1719 sort( sortedLoadedItems.begin(), sortedLoadedItems.end(),
1720 []( SCH_ITEM* firstItem, SCH_ITEM* secondItem )
1721 {
1722 SCH_SHEET* firstSheet = static_cast<SCH_SHEET*>( firstItem );
1723 SCH_SHEET* secondSheet = static_cast<SCH_SHEET*>( secondItem );
1724 return StrNumCmp( firstSheet->GetName(), secondSheet->GetName(), false ) < 0;
1725 });
1726
1727
1728 for( SCH_ITEM* item : sortedLoadedItems )
1729 {
1730 loadedItems.push_back( item );
1731
1732 if( item->Type() == SCH_SHEET_T )
1733 {
1734 SCH_SHEET* sheet = static_cast<SCH_SHEET*>( item );
1735 SCH_FIELD& nameField = sheet->GetFields()[SHEETNAME];
1736 wxString baseName = nameField.GetText();
1737 wxFileName srcFn = sheet->GetFileName();
1738
1739 if( srcFn.IsRelative() )
1740 srcFn.MakeAbsolute( m_frame->Prj().GetProjectPath() );
1741
1742 SCH_SHEET_LIST sheetHierarchy( sheet );
1743
1744 if( hierarchy.TestForRecursion( sheetHierarchy, destFn.GetFullPath( wxPATH_UNIX ) ) )
1745 {
1746 auto msg = wxString::Format( _( "The pasted sheet '%s'\n"
1747 "was dropped because the destination already has "
1748 "the sheet or one of its subsheets as a parent." ),
1749 sheet->GetFileName() );
1750 DisplayError( m_frame, msg );
1751 loadedItems.pop_back();
1752 }
1753 }
1754 }
1755
1756 // Remove the references from our temporary screen to prevent freeing on the DTOR
1757 tempScreen->Clear( false );
1758
1759 for( EDA_ITEM* item : loadedItems )
1760 {
1761 KIID_PATH clipPath( wxT( "/" ) ); // clipboard is at root
1762
1763 SCH_ITEM* schItem = static_cast<SCH_ITEM*>( item );
1764
1765 wxCHECK2( schItem, continue );
1766
1767 if( schItem->IsConnectable() )
1768 schItem->SetConnectivityDirty();
1769
1770 if( item->Type() == SCH_SYMBOL_T )
1771 {
1772 SCH_SYMBOL* symbol = static_cast<SCH_SYMBOL*>( item );
1773
1774 // The library symbol gets set from the cached library symbols in the current
1775 // schematic not the symbol libraries. The cached library symbol may have
1776 // changed from the original library symbol which would cause the copy to
1777 // be incorrect.
1778 SCH_SCREEN* currentScreen = m_frame->GetScreen();
1779
1780 wxCHECK2( currentScreen, continue );
1781
1782 auto it = currentScreen->GetLibSymbols().find( symbol->GetSchSymbolLibraryName() );
1783 auto end = currentScreen->GetLibSymbols().end();
1784
1785 if( it == end )
1786 {
1787 // If can't find library definition in the design, use the pasted library
1788 it = tempScreen->GetLibSymbols().find( symbol->GetSchSymbolLibraryName() );
1789 end = tempScreen->GetLibSymbols().end();
1790 }
1791
1792 LIB_SYMBOL* libSymbol = nullptr;
1793
1794 if( it != end )
1795 {
1796 libSymbol = new LIB_SYMBOL( *it->second );
1797 symbol->SetLibSymbol( libSymbol );
1798 }
1799
1800 for( SCH_SHEET_PATH& sheetPath : sheetPathsForScreen )
1801 updatePastedSymbol( symbol, sheetPath, clipPath, forceKeepAnnotations );
1802
1803 // Assign a new KIID
1804 const_cast<KIID&>( item->m_Uuid ) = KIID();
1805
1806 // Make sure pins get a new UUID
1807 for( SCH_PIN* pin : symbol->GetPins() )
1808 {
1809 const_cast<KIID&>( pin->m_Uuid ) = KIID();
1810 pin->SetConnectivityDirty();
1811 }
1812
1813 for( SCH_SHEET_PATH& sheetPath : sheetPathsForScreen )
1814 {
1815 // Ignore symbols from a non-existant library.
1816 if( libSymbol )
1817 {
1818 SCH_REFERENCE schReference( symbol, sheetPath );
1819 schReference.SetSheetNumber( sheetPath.GetVirtualPageNumber() );
1820 pastedSymbols[sheetPath].AddItem( schReference );
1821 }
1822 }
1823 }
1824 else if( item->Type() == SCH_SHEET_T )
1825 {
1826 SCH_SHEET* sheet = (SCH_SHEET*) item;
1827 SCH_FIELD& nameField = sheet->GetFields()[SHEETNAME];
1828 wxString baseName = nameField.GetText();
1829 wxString candidateName = baseName;
1830 wxString number;
1831
1832 while( !baseName.IsEmpty() && wxIsdigit( baseName.Last() ) )
1833 {
1834 number = baseName.Last() + number;
1835 baseName.RemoveLast();
1836 }
1837
1838 // Update hierarchy to include any other sheets we already added, avoiding
1839 // duplicate sheet names
1841
1842 //@todo: it might be better to just iterate through the sheet names
1843 // in this screen instead of the whole hierarchy.
1844 int uniquifier = std::max( 0, wxAtoi( number ) ) + 1;
1845
1846 while( hierarchy.NameExists( candidateName ) )
1847 candidateName = wxString::Format( wxT( "%s%d" ), baseName, uniquifier++ );
1848
1849 nameField.SetText( candidateName );
1850
1851 wxFileName fn = sheet->GetFileName();
1852 SCH_SCREEN* existingScreen = nullptr;
1853
1854 sheet->SetParent( pasteRoot.Last() );
1855 sheet->SetScreen( nullptr );
1856
1857 if( !fn.IsAbsolute() )
1858 {
1859 wxFileName currentSheetFileName = pasteRoot.LastScreen()->GetFileName();
1860 fn.Normalize( FN_NORMALIZE_FLAGS | wxPATH_NORM_ENV_VARS,
1861 currentSheetFileName.GetPath() );
1862 }
1863
1864 // Try to find the screen for the pasted sheet by several means
1865 if( !m_frame->Schematic().Root().SearchHierarchy( fn.GetFullPath( wxPATH_UNIX ),
1866 &existingScreen ) )
1867 {
1868 if( loadedScreens.count( sheet->GetFileName() ) > 0 )
1869 existingScreen = loadedScreens.at( sheet->GetFileName() );
1870 else
1871 searchSupplementaryClipboard( sheet->GetFileName(), &existingScreen );
1872 }
1873
1874 if( existingScreen )
1875 {
1876 sheet->SetScreen( existingScreen );
1877 }
1878 else
1879 {
1880 if( !m_frame->LoadSheetFromFile( sheet, &pasteRoot, fn.GetFullPath() ) )
1881 m_frame->InitSheet( sheet, sheet->GetFileName() );
1882 }
1883
1884 // Save the symbol instances in case the user chooses to keep the existing
1885 // symbol annotation.
1887 sheetsPasted = true;
1888
1889 // Push it to the clipboard path while it still has its old KIID
1890 clipPath.push_back( sheet->m_Uuid );
1891
1892 // Assign a new KIID to the pasted sheet
1893 const_cast<KIID&>( sheet->m_Uuid ) = KIID();
1894
1895 // Make sure pins get a new UUID
1896 for( SCH_SHEET_PIN* pin : sheet->GetPins() )
1897 {
1898 const_cast<KIID&>( pin->m_Uuid ) = KIID();
1899 pin->SetConnectivityDirty();
1900 }
1901
1902 // Once we have our new KIID we can update all pasted instances. This will either
1903 // reset the annotations or copy "kept" annotations from the supplementary clipboard.
1904 for( SCH_SHEET_PATH& sheetPath : sheetPathsForScreen )
1905 {
1906 SCH_SHEET_PATH subPath = updatePastedSheet( sheet, sheetPath, clipPath,
1907 ( forceKeepAnnotations && annotate.automatic ),
1908 &pastedSheets[sheetPath],
1909 pastedSymbols );
1910 }
1911 }
1912 else
1913 {
1914 SCH_ITEM* srcItem = dynamic_cast<SCH_ITEM*>( itemMap[ item->m_Uuid ] );
1915 SCH_ITEM* destItem = dynamic_cast<SCH_ITEM*>( item );
1916
1917 // Everything gets a new KIID
1918 const_cast<KIID&>( item->m_Uuid ) = KIID();
1919
1920 if( srcItem && destItem )
1921 {
1922 destItem->SetConnectivityDirty( true );
1923 destItem->SetLastResolvedState( srcItem );
1924 }
1925 }
1926
1927 // Lines need both ends selected for a move after paste so the whole line moves.
1928 if( item->Type() == SCH_LINE_T )
1929 item->SetFlags( STARTPOINT | ENDPOINT );
1930
1931 item->SetFlags( IS_NEW | IS_PASTED | IS_MOVING );
1932
1933 if( !m_frame->GetScreen()->CheckIfOnDrawList( (SCH_ITEM*) item ) ) // don't want a loop!
1934 m_frame->AddToScreen( item, m_frame->GetScreen() );
1935
1936 commit.Added( (SCH_ITEM*) item, m_frame->GetScreen() );
1937
1938 // Start out hidden so the pasted items aren't "ghosted" in their original location
1939 // before being moved to the current location.
1940 getView()->Hide( item, true );
1941 }
1942
1943 if( sheetsPasted )
1944 {
1945 // Update page numbers: Find next free numeric page number
1946 for( SCH_SHEET_PATH& sheetPath : sheetPathsForScreen )
1947 {
1948 for( SCH_SHEET_PATH& pastedSheet : pastedSheets[sheetPath] )
1949 {
1950 int page = 1;
1951 wxString pageNum = wxString::Format( "%d", page );
1952
1953 while( hierarchy.PageNumberExists( pageNum ) )
1954 pageNum = wxString::Format( "%d", ++page );
1955
1956 SCH_SHEET_INSTANCE sheetInstance;
1957
1958 sheetInstance.m_Path = pastedSheet.Path();
1959
1960 // Don't include the actual sheet in the instance path.
1961 sheetInstance.m_Path.pop_back();
1962 sheetInstance.m_PageNumber = pageNum;
1963 sheetInstance.m_ProjectName = m_frame->Prj().GetProjectName();
1964
1965 SCH_SHEET* sheet = pastedSheet.Last();
1966
1967 wxCHECK2( sheet, continue );
1968
1969 sheet->AddInstance( sheetInstance );
1970 hierarchy.push_back( pastedSheet );
1971
1972 // Remove all pasted sheet instance data that is not part of the current project.
1973 std::vector<KIID_PATH> instancesToRemove;
1974
1975 for( const SCH_SHEET_INSTANCE& instance : sheet->GetInstances() )
1976 {
1977 if( !hierarchy.HasPath( instance.m_Path ) )
1978 instancesToRemove.push_back( instance.m_Path );
1979 }
1980
1981 for( const KIID_PATH& instancePath : instancesToRemove )
1982 sheet->RemoveInstance( instancePath );
1983 }
1984 }
1985
1987
1988 // Get a version with correct sheet numbers since we've pasted sheets,
1989 // we'll need this when annotating next
1991 }
1992
1993 std::map<SCH_SHEET_PATH, SCH_REFERENCE_LIST> annotatedSymbols;
1994
1995 // Update the list of symbol instances that satisfy the annotation criteria.
1996 for( const SCH_SHEET_PATH& sheetPath : sheetPathsForScreen )
1997 {
1998 for( size_t i = 0; i < pastedSymbols[sheetPath].GetCount(); i++ )
1999 {
2000 if( pasteMode == PASTE_MODE::UNIQUE_ANNOTATIONS
2001 || pasteMode == PASTE_MODE::RESPECT_OPTIONS
2002 || pastedSymbols[sheetPath][i].AlwaysAnnotate() )
2003 {
2004 annotatedSymbols[sheetPath].AddItem( pastedSymbols[sheetPath][i] );
2005 }
2006 }
2007
2008 for( const SCH_SHEET_PATH& pastedSheetPath : pastedSheets[sheetPath] )
2009 {
2010 for( size_t i = 0; i < pastedSymbols[pastedSheetPath].GetCount(); i++ )
2011 {
2012 if( pasteMode == PASTE_MODE::UNIQUE_ANNOTATIONS
2013 || pasteMode == PASTE_MODE::RESPECT_OPTIONS
2014 || pastedSymbols[pastedSheetPath][i].AlwaysAnnotate() )
2015 {
2016 annotatedSymbols[pastedSheetPath].AddItem( pastedSymbols[pastedSheetPath][i] );
2017 }
2018 }
2019 }
2020 }
2021
2022 if( !annotatedSymbols.empty() )
2023 {
2024 for( SCH_SHEET_PATH& path : sheetPathsForScreen )
2025 {
2026 annotatedSymbols[path].SortByReferenceOnly();
2027
2028 if( pasteMode == PASTE_MODE::UNIQUE_ANNOTATIONS )
2029 {
2030 annotatedSymbols[path].ReannotateDuplicates( existingRefs );
2031 }
2032 else
2033 {
2034 annotatedSymbols[path].ReannotateByOptions( (ANNOTATE_ORDER_T) annotate.sort_order,
2035 (ANNOTATE_ALGO_T) annotate.method,
2036 annotateStartNum, existingRefs, false,
2037 &hierarchy );
2038 }
2039
2040 annotatedSymbols[path].UpdateAnnotation();
2041
2042 // Update existing refs for next iteration
2043 for( size_t i = 0; i < annotatedSymbols[path].GetCount(); i++ )
2044 existingRefs.AddItem( annotatedSymbols[path][i] );
2045
2046 for( const SCH_SHEET_PATH& pastedSheetPath : pastedSheets[path] )
2047 {
2048 annotatedSymbols[pastedSheetPath].SortByReferenceOnly();
2049
2050 if( pasteMode == PASTE_MODE::UNIQUE_ANNOTATIONS )
2051 {
2052 annotatedSymbols[pastedSheetPath].ReannotateDuplicates( existingRefs );
2053 }
2054 else
2055 {
2056 annotatedSymbols[pastedSheetPath].ReannotateByOptions( (ANNOTATE_ORDER_T) annotate.sort_order,
2057 (ANNOTATE_ALGO_T) annotate.method,
2058 annotateStartNum, existingRefs,
2059 false,
2060 &hierarchy );
2061 }
2062
2063 annotatedSymbols[pastedSheetPath].UpdateAnnotation();
2064
2065 // Update existing refs for next iteration
2066 for( size_t i = 0; i < annotatedSymbols[pastedSheetPath].GetCount(); i++ )
2067 existingRefs.AddItem( annotatedSymbols[pastedSheetPath][i] );
2068 }
2069 }
2070 }
2071
2073
2074 // The copy operation creates instance paths that are not valid for the current project or
2075 // saved as part of another project. Prune them now so they do not accumulate in the saved
2076 // schematic file.
2078
2080 SCH_SCREENS allScreens( m_frame->Schematic().Root() );
2081
2082 allScreens.PruneOrphanedSymbolInstances( m_frame->Prj().GetProjectName(), sheets );
2083 allScreens.PruneOrphanedSheetInstances( m_frame->Prj().GetProjectName(), sheets );
2084
2085 // Now clear the previous selection, select the pasted items, and fire up the "move" tool.
2088
2089 EE_SELECTION& selection = selTool->GetSelection();
2090
2091 if( !selection.Empty() )
2092 {
2093 if( aEvent.IsAction( &ACTIONS::duplicate ) )
2094 {
2095 int closest_dist = INT_MAX;
2096
2097 auto processPt =
2098 [&]( const VECTOR2I& pt )
2099 {
2100 int dist = ( eventPos - pt ).EuclideanNorm();
2101
2102 if( dist < closest_dist )
2103 {
2104 selection.SetReferencePoint( pt );
2105 closest_dist = dist;
2106 }
2107 };
2108
2109 // Prefer connection points (which should remain on grid)
2110 for( EDA_ITEM* item : selection.Items() )
2111 {
2112 SCH_ITEM* sch_item = dynamic_cast<SCH_ITEM*>( item );
2113 SCH_PIN* pin = dynamic_cast<SCH_PIN*>( item );
2114
2115 if( sch_item && sch_item->IsConnectable() )
2116 {
2117 for( const VECTOR2I& pt : sch_item->GetConnectionPoints() )
2118 processPt( pt );
2119 }
2120 else if( pin )
2121 {
2122 processPt( pin->GetPosition() );
2123 }
2124 }
2125
2126 // Only process other points if we didn't find any connection points
2127 if( closest_dist == INT_MAX )
2128 {
2129 for( EDA_ITEM* item : selection.Items() )
2130 {
2131 switch( item->Type() )
2132 {
2133 case SCH_LINE_T:
2134 processPt( static_cast<SCH_LINE*>( item )->GetStartPoint() );
2135 processPt( static_cast<SCH_LINE*>( item )->GetEndPoint() );
2136 break;
2137
2138 case SCH_SHAPE_T:
2139 {
2140 SCH_SHAPE* shape = static_cast<SCH_SHAPE*>( item );
2141
2142 switch( shape->GetShape() )
2143 {
2144 case SHAPE_T::RECTANGLE:
2145 for( const VECTOR2I& pt : shape->GetRectCorners() )
2146 processPt( pt );
2147
2148 break;
2149
2150 case SHAPE_T::CIRCLE:
2151 processPt( shape->GetCenter() );
2152 break;
2153
2154 case SHAPE_T::POLY:
2155 for( int ii = 0; ii < shape->GetPolyShape().TotalVertices(); ++ii )
2156 processPt( shape->GetPolyShape().CVertex( ii ) );
2157
2158 break;
2159
2160 default:
2161 processPt( shape->GetStart() );
2162 processPt( shape->GetEnd() );
2163 break;
2164 }
2165
2166 break;
2167 }
2168
2169 default:
2170 processPt( item->GetPosition() );
2171 break;
2172 }
2173 }
2174 }
2175
2176 selection.SetIsHover( m_duplicateIsHoverSelection );
2177 }
2178 else
2179 {
2180 SCH_ITEM* item = static_cast<SCH_ITEM*>( selection.GetTopLeftItem() );
2181
2182 selection.SetReferencePoint( item->GetPosition() );
2183 }
2184
2186 {
2187 // Pushing the commit will update the connectivity.
2188 commit.Push( _( "Paste" ) );
2189
2190 if( sheetsPasted )
2192 // UpdateHierarchyNavigator() will call RefreshNetNavigator()
2193 else
2195 }
2196 else
2197 {
2198 commit.Revert();
2199 }
2200 }
2201
2202 return 0;
2203}
2204
2205
2207{
2209 EE_SELECTION& selection = selTool->RequestSelection( { SCH_SYMBOL_T } );
2210 SCH_SYMBOL* symbol = nullptr;
2211 SYMBOL_EDIT_FRAME* symbolEditor;
2212
2213 if( selection.GetSize() >= 1 )
2214 symbol = (SCH_SYMBOL*) selection.Front();
2215
2216 if( selection.IsHover() )
2218
2219 if( !symbol )
2220 {
2221 // Giant hack: by default we assign Edit Table to the same hotkey, so give the table
2222 // tool a chance to handle it if we can't.
2224 tableTool->EditTable( aEvent );
2225
2226 return 0;
2227 }
2228
2229 if( symbol->GetEditFlags() != 0 )
2230 return 0;
2231
2232 if( symbol->IsMissingLibSymbol() )
2233 {
2234 m_frame->ShowInfoBarError( _( "Symbols with broken library symbol links cannot "
2235 "be edited." ) );
2236 return 0;
2237 }
2238
2240 symbolEditor = (SYMBOL_EDIT_FRAME*) m_frame->Kiway().Player( FRAME_SCH_SYMBOL_EDITOR, false );
2241
2242 if( symbolEditor )
2243 {
2244 if( wxWindow* blocking_win = symbolEditor->Kiway().GetBlockingDialog() )
2245 blocking_win->Close( true );
2246
2247 if( aEvent.IsAction( &EE_ACTIONS::editWithLibEdit ) )
2248 {
2249 symbolEditor->LoadSymbolFromSchematic( symbol );
2250 }
2252 {
2253 symbolEditor->LoadSymbol( symbol->GetLibId(), symbol->GetUnit(),
2254 symbol->GetBodyStyle() );
2255
2256 if( !symbolEditor->IsLibraryTreeShown() )
2257 symbolEditor->ToggleLibraryTree();
2258 }
2259 }
2260
2261 return 0;
2262}
2263
2264
2266{
2267 wxCommandEvent dummy;
2269 return 0;
2270}
2271
2272
2274{
2275 wxCommandEvent dummy;
2277 return 0;
2278}
2279
2280
2282{
2284
2285 wxCHECK( dlg, 0 );
2286
2287 // Needed at least on Windows. Raise() is not enough
2288 dlg->Show( true );
2289
2290 // Bring it to the top if already open. Dual monitor users need this.
2291 dlg->Raise();
2292
2293 dlg->ShowEditTab();
2294
2295 return 0;
2296}
2297
2298
2300{
2303
2304 return 0;
2305}
2306
2307
2309{
2310 wxCommandEvent dummy;
2312 return 0;
2313}
2314
2315
2317{
2318 wxCommandEvent dummy;
2320 return 0;
2321}
2322
2323
2325{
2327 dlg.ShowModal();
2328 return 0;
2329}
2330
2331
2333{
2334 int result = NET_PLUGIN_CHANGE;
2335
2336 // If a plugin is removed or added, rebuild and reopen the new dialog
2337 while( result == NET_PLUGIN_CHANGE )
2338 result = InvokeDialogNetList( m_frame );
2339
2340 return 0;
2341}
2342
2343
2345{
2347
2348 wxCHECK( dlg, 0 );
2349
2350 // Needed at least on Windows. Raise() is not enough
2351 dlg->Show( true );
2352
2353 // Bring it to the top if already open. Dual monitor users need this.
2354 dlg->Raise();
2355
2356 dlg->ShowExportTab();
2357
2358 return 0;
2359}
2360
2361
2363{
2365 return 0;
2366}
2367
2368
2370{
2373 return 0;
2374}
2375
2376
2378{
2379 getEditFrame<SCH_EDIT_FRAME>()->ToggleSearch();
2380 return 0;
2381}
2382
2383
2385{
2386 getEditFrame<SCH_EDIT_FRAME>()->ToggleSchematicHierarchy();
2387 return 0;
2388}
2389
2390
2392{
2393 getEditFrame<SCH_EDIT_FRAME>()->ToggleNetNavigator();
2394 return 0;
2395}
2396
2397
2399{
2400 getEditFrame<SCH_EDIT_FRAME>()->ToggleProperties();
2401 return 0;
2402}
2403
2404
2406{
2409
2412
2413 return 0;
2414}
2415
2416
2418{
2421
2424
2425 return 0;
2426}
2427
2428
2430{
2433
2436
2437 return 0;
2438}
2439
2440
2442{
2445
2448
2449 return 0;
2450}
2451
2452
2454{
2457
2460
2461 return 0;
2462}
2463
2464
2466{
2469
2471
2472 return 0;
2473}
2474
2475
2477{
2480
2482 [&]( KIGFX::VIEW_ITEM* aItem ) -> int
2483 {
2484 int flags = 0;
2485
2486 auto invalidateTextVars =
2487 [&flags]( EDA_TEXT* text )
2488 {
2489 if( text->HasTextVars() )
2490 {
2491 text->ClearRenderCache();
2492 text->ClearBoundingBoxCache();
2494 }
2495 };
2496
2497 if( SCH_ITEM* item = dynamic_cast<SCH_ITEM*>( aItem ) )
2498 {
2499 item->RunOnChildren(
2500 [&invalidateTextVars]( SCH_ITEM* aChild )
2501 {
2502 if( EDA_TEXT* text = dynamic_cast<EDA_TEXT*>( aChild ) )
2503 invalidateTextVars( text );
2504 } );
2505
2506 if( item->GetExcludedFromSim() )
2508 }
2509
2510 if( EDA_TEXT* text = dynamic_cast<EDA_TEXT*>( aItem ) )
2511 invalidateTextVars( text );
2512
2513 return flags;
2514 } );
2515
2517
2518 return 0;
2519}
2520
2521
2523{
2526
2530
2531 return 0;
2532}
2533
2534
2536{
2539
2543
2544 return 0;
2545}
2546
2547
2549{
2552 return 0;
2553}
2554
2555
2557{
2559 m_frame->eeconfig()->m_Drawing.line_mode %= LINE_MODE::LINE_MODE_COUNT;
2561 return 0;
2562}
2563
2564
2566{
2569 return 0;
2570}
2571
2572
2574{
2577 return 0;
2578}
2579
2580
2582{
2583
2585 return 0;
2586}
2587
2588
2590{
2591#ifdef KICAD_IPC_API
2592 Pgm().GetPluginManager().ReloadPlugins();
2593#endif
2594 return 0;
2595}
2596
2597
2599{
2600 int errors = 0;
2601 wxString details;
2602 bool quiet = aEvent.Parameter<bool>();
2603
2604 // Repair duplicate IDs.
2605 std::map<KIID, EDA_ITEM*> ids;
2606 int duplicates = 0;
2607
2609
2610 auto processItem =
2611 [&]( EDA_ITEM* aItem )
2612 {
2613 auto it = ids.find( aItem->m_Uuid );
2614
2615 if( it != ids.end() && it->second != aItem )
2616 {
2617 duplicates++;
2618 const_cast<KIID&>( aItem->m_Uuid ) = KIID();
2619 }
2620
2621 ids[ aItem->m_Uuid ] = aItem;
2622 };
2623
2624 // Symbol IDs are the most important, so give them the first crack at "claiming" a
2625 // particular KIID.
2626
2627 for( const SCH_SHEET_PATH& sheet : sheets )
2628 {
2629 SCH_SCREEN* screen = sheet.LastScreen();
2630
2631 for( SCH_ITEM* item : screen->Items().OfType( SCH_SYMBOL_T ) )
2632 {
2633 processItem( item );
2634
2635 for( SCH_PIN* pin : static_cast<SCH_SYMBOL*>( item )->GetPins( &sheet ) )
2636 processItem( pin );
2637 }
2638 }
2639
2640 for( const SCH_SHEET_PATH& sheet : sheets )
2641 {
2642 SCH_SCREEN* screen = sheet.LastScreen();
2643
2644 for( SCH_ITEM* item : screen->Items() )
2645 {
2646 processItem( item );
2647
2648 item->RunOnChildren(
2649 [&]( SCH_ITEM* aChild )
2650 {
2651 processItem( item );
2652 } );
2653 }
2654 }
2655
2656 /*******************************
2657 * Your test here
2658 */
2659
2660 /*******************************
2661 * Inform the user
2662 */
2663
2664 if( duplicates )
2665 {
2666 errors += duplicates;
2667 details += wxString::Format( _( "%d duplicate IDs replaced.\n" ), duplicates );
2668 }
2669
2670 if( errors )
2671 {
2672 m_frame->OnModify();
2673
2674 wxString msg = wxString::Format( _( "%d potential problems repaired." ), errors );
2675
2676 if( !quiet )
2677 DisplayInfoMessage( m_frame, msg, details );
2678 }
2679 else if( !quiet )
2680 {
2681 DisplayInfoMessage( m_frame, _( "No errors found." ) );
2682 }
2683
2684 return 0;
2685}
2686
2687
2689{
2690 if( !Pgm().GetCommonSettings()->m_Input.hotkey_feedback )
2691 return 0;
2692
2693 GRID_SETTINGS& gridSettings = m_toolMgr->GetSettings()->m_Window.grid;
2694 int currentIdx = m_toolMgr->GetSettings()->m_Window.grid.last_size_idx;
2695
2696 wxArrayString gridsLabels;
2697
2698 for( const GRID& grid : gridSettings.grids )
2699 gridsLabels.Add( grid.UserUnitsMessageText( m_frame ) );
2700
2701 if( !m_frame->GetHotkeyPopup() )
2703
2705
2706 if( popup )
2707 popup->Popup( _( "Grid" ), gridsLabels, currentIdx );
2708
2709 return 0;
2710}
2711
2712
2714{
2715 Go( &SCH_EDITOR_CONTROL::New, ACTIONS::doNew.MakeEvent() );
2716 Go( &SCH_EDITOR_CONTROL::Open, ACTIONS::open.MakeEvent() );
2717 Go( &SCH_EDITOR_CONTROL::Save, ACTIONS::save.MakeEvent() );
2724 Go( &SCH_EDITOR_CONTROL::Plot, ACTIONS::plot.MakeEvent() );
2725 Go( &SCH_EDITOR_CONTROL::Quit, ACTIONS::quit.MakeEvent() );
2726
2729
2735
2738
2744
2746
2747 Go( &SCH_EDITOR_CONTROL::Undo, ACTIONS::undo.MakeEvent() );
2748 Go( &SCH_EDITOR_CONTROL::Redo, ACTIONS::redo.MakeEvent() );
2749 Go( &SCH_EDITOR_CONTROL::Cut, ACTIONS::cut.MakeEvent() );
2750 Go( &SCH_EDITOR_CONTROL::Copy, ACTIONS::copy.MakeEvent() );
2754
2756
2773
2778
2793
2796
2798
2803}
const char * name
Definition: DXF_plotter.cpp:57
static TOOL_ACTION updatePcbFromSchematic
Definition: actions.h:204
static TOOL_ACTION paste
Definition: actions.h:72
static TOOL_ACTION cancelInteractive
Definition: actions.h:65
static TOOL_ACTION revert
Definition: actions.h:55
static TOOL_ACTION saveAs
Definition: actions.h:52
static TOOL_ACTION copy
Definition: actions.h:71
static TOOL_ACTION pluginsReload
Definition: actions.h:229
static TOOL_ACTION pickerTool
Definition: actions.h:194
static TOOL_ACTION showSymbolEditor
Definition: actions.h:201
static TOOL_ACTION pasteSpecial
Definition: actions.h:73
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:100
static TOOL_ACTION undo
Definition: actions.h:68
static TOOL_ACTION duplicate
Definition: actions.h:76
static TOOL_ACTION doDelete
Definition: actions.h:77
static TOOL_ACTION quit
Definition: actions.h:59
static TOOL_ACTION save
Definition: actions.h:51
static TOOL_ACTION redo
Definition: actions.h:69
static TOOL_ACTION updateSchematicFromPcb
Definition: actions.h:205
static TOOL_ACTION print
Definition: actions.h:57
static TOOL_ACTION showProperties
Definition: actions.h:206
static TOOL_ACTION doNew
Definition: actions.h:47
static TOOL_ACTION cut
Definition: actions.h:70
static TOOL_ACTION refreshPreview
Definition: actions.h:139
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:89
virtual VECTOR2I GetPosition() const
Definition: eda_item.h:243
EDA_ITEM_FLAGS GetEditFlags() const
Definition: eda_item.h:133
const KIID m_Uuid
Definition: eda_item.h:489
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:101
virtual void SetParent(EDA_ITEM *aParent)
Definition: eda_item.h:104
void ClearBrightened()
Definition: eda_item.h:123
EDA_ITEM * GetParent() const
Definition: eda_item.h:103
SHAPE_POLY_SET & GetPolyShape()
Definition: eda_shape.h:279
SHAPE_T GetShape() const
Definition: eda_shape.h:125
const VECTOR2I & GetEnd() const
Return the ending point of the graphic.
Definition: eda_shape.h:167
const VECTOR2I & GetStart() const
Return the starting point of the graphic.
Definition: eda_shape.h:130
std::vector< VECTOR2I > GetRectCorners() const
Definition: eda_shape.cpp:1171
A mix-in class (via multiple inheritance) that handles texts such as labels, parts,...
Definition: eda_text.h:79
virtual const wxString & GetText() const
Return the string associated with the text object.
Definition: eda_text.h:94
PANEL_ANNOTATE m_AnnotatePanel
static TOOL_ACTION importFPAssignments
Definition: ee_actions.h:176
static TOOL_ACTION repairSchematic
Definition: ee_actions.h:258
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:267
static TOOL_ACTION lineMode90
Definition: ee_actions.h:262
static TOOL_ACTION toggleHiddenPins
Definition: ee_actions.h:233
static TOOL_ACTION highlightNet
Definition: ee_actions.h:291
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:292
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:257
static TOOL_ACTION toggleERCWarnings
Definition: ee_actions.h:238
static TOOL_ACTION simTune
Definition: ee_actions.h:280
static TOOL_ACTION toggleERCExclusions
Definition: ee_actions.h:240
static TOOL_ACTION lineModeNext
Definition: ee_actions.h:264
static TOOL_ACTION lineModeFree
Definition: ee_actions.h:261
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:239
static TOOL_ACTION toggleOPCurrents
Definition: ee_actions.h:243
static TOOL_ACTION highlightNetTool
Definition: ee_actions.h:294
static TOOL_ACTION updateNetHighlighting
Definition: ee_actions.h:293
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:234
static TOOL_ACTION editWithLibEdit
Definition: ee_actions.h:173
static TOOL_ACTION simProbe
Definition: ee_actions.h:279
static TOOL_ACTION exportSymbolsToLibrary
Definition: ee_actions.h:182
static TOOL_ACTION drawSheetOnClipboard
Definition: ee_actions.h:253
static TOOL_ACTION editSymbolFields
Definition: ee_actions.h:153
static TOOL_ACTION showNetNavigator
Definition: ee_actions.h:295
static TOOL_ACTION annotate
Definition: ee_actions.h:152
static TOOL_ACTION toggleDirectiveLabels
Definition: ee_actions.h:237
static TOOL_ACTION showHierarchy
Definition: ee_actions.h:225
static TOOL_ACTION toggleOPVoltages
Definition: ee_actions.h:242
static TOOL_ACTION lineMode45
Definition: ee_actions.h:263
static TOOL_ACTION markSimExclusions
Definition: ee_actions.h:241
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:52
static const TOOL_EVENT ClearedEvent
Definition: actions.h:272
static const TOOL_EVENT GridChangedByKeyEvent
Definition: actions.h:290
static const TOOL_EVENT SelectedEvent
Definition: actions.h:270
static const TOOL_EVENT SelectedItemsModified
Selected items were moved, this can be very high frequency on the canvas, use with care.
Definition: actions.h:277
static const TOOL_EVENT PointSelectedEvent
Definition: actions.h:269
static const TOOL_EVENT UnselectedEvent
Definition: actions.h:271
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:277
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:1687
void SetLayerVisible(int aLayer, bool aVisible=true)
Control the visibility of a particular layer.
Definition: view.h:401
void UpdateAllItems(int aUpdateFlags)
Update all items in the view according to the given flags.
Definition: view.cpp:1563
void Hide(VIEW_ITEM *aItem, bool aHide=true, bool aHideOverlay=false)
Temporarily hide the item in the view (e.g.
Definition: view.cpp:1635
void MarkDirty()
Force redraw of view on the next rendering.
Definition: view.h:649
void UpdateAllItemsConditionally(int aUpdateFlags, std::function< bool(VIEW_ITEM *)> aCondition)
Update items in the view according to the given flags and condition.
Definition: view.cpp:1573
bool EndsWith(const KIID_PATH &aPath) const
Test if aPath from the last path towards the first path.
Definition: kiid.cpp:335
wxString AsString() const
Definition: kiid.cpp:356
Definition: kiid.h:49
wxString AsString() const
Definition: kiid.cpp:246
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:78
const LIB_ID & GetLibId() const override
Definition: lib_symbol.h:143
wxString GetName() const override
Definition: lib_symbol.h:137
std::unique_ptr< LIB_SYMBOL > Flatten() const
Return a flattened symbol inheritance to the caller.
Definition: lib_symbol.cpp:304
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(wxString *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:76
SCH_SHEET_PATH & CurrentSheet() const override
Definition: schematic.h:144
wxString GetFileName() const override
Helper to retrieve the filename from the root sheet screen.
Definition: schematic.cpp:291
SCHEMATIC_SETTINGS & Settings() const
Definition: schematic.cpp:297
CONNECTION_GRAPH * ConnectionGraph() const override
Definition: schematic.h:154
SCH_SHEET_LIST BuildUnorderedSheetList() const
Definition: schematic.h:101
EMBEDDED_FILES * GetEmbeddedFiles() override
Definition: schematic.cpp:854
SCH_SHEET & Root() const
Definition: schematic.h:113
SCH_SHEET_LIST BuildSheetListSortedByPageNumbers() const override
Definition: schematic.h:96
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 MarkSimExclusions(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:1189
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:166
virtual bool IsConnectable() const
Definition: sch_item.h:449
SCHEMATIC * Schematic() const
Searches the item hierarchy to find a SCHEMATIC.
Definition: sch_item.cpp:150
virtual void SetLastResolvedState(const SCH_ITEM *aItem)
Definition: sch_item.h:541
int GetBodyStyle() const
Definition: sch_item.h:232
int GetUnit() const
Definition: sch_item.h:229
void SetConnectivityDirty(bool aDirty=true)
Definition: sch_item.h:512
bool IsConnectivityDirty() const
Definition: sch_item.h:510
virtual void SetUnit(int aUnit)
Definition: sch_item.h:228
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:221
virtual std::vector< VECTOR2I > GetConnectionPoints() const
Add all the connection points for this item to aPoints.
Definition: sch_item.h:464
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:710
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:634
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:1397
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:782
void AddInstance(const SCH_SHEET_INSTANCE &aInstance)
Definition: sch_sheet.cpp:1418
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:172
std::vector< SCH_SHEET_PIN * > & GetPins()
Definition: sch_sheet.h:181
const std::vector< SCH_SHEET_INSTANCE > & GetInstances() const
Definition: sch_sheet.h:417
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:919
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:620
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:967
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:720
bool IsPower() const override
void BrightenItem(EDA_ITEM *aItem)
void UnbrightenItem(EDA_ITEM *aItem)
void SetReferencePoint(const VECTOR2I &aP)
Definition: selection.cpp:180
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.
bool IsLibraryTreeShown() const override
void LoadSymbol(const wxString &aLibrary, const wxString &aSymbol, int Unit)
void LoadSymbolFromSchematic(SCH_SYMBOL *aSymbol)
Load a symbol from the schematic to edit in place.
void ToggleLibraryTree() override
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:218
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:424
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:536
#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:384
@ LAYER_ERC_ERR
Definition: layer_ids.h:385
@ LAYER_OP_CURRENTS
Definition: layer_ids.h:404
@ LAYER_OP_VOLTAGES
Definition: layer_ids.h:403
@ 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
@ 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:121
VECTOR2< int32_t > VECTOR2I
Definition: vector2d.h:673
Definition of file extensions used in Kicad.
#define FN_NORMALIZE_FLAGS
Default flags to pass to wxFileName::Normalize().
Definition: wx_filename.h:39