KiCad PCB EDA Suite
Loading...
Searching...
No Matches
board_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) 2014 CERN
5 * Copyright (C) 2014-2022 KiCad Developers, see AUTHORS.txt for contributors.
6 * @author Maciej Suminski <[email protected]>
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version 2
11 * of the License, or (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, you may find one here:
20 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
21 * or you may search the http://www.gnu.org website for the version 2 license,
22 * or you may write to the Free Software Foundation, Inc.,
23 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
24 */
25
26#include <functional>
27#include <memory>
28
29#include <pgm_base.h>
30#include <advanced_config.h>
32#include <bitmaps.h>
33#include <pcb_painter.h>
34#include <board.h>
35#include <board_commit.h>
37#include <pcb_generator.h>
38#include <footprint.h>
39#include <pad.h>
40#include <pcb_target.h>
41#include <pcb_track.h>
42#include <zone.h>
43#include <pcb_marker.h>
44#include <confirm.h>
48#include <kiface_base.h>
49#include <kiway.h>
51#include <origin_viewitem.h>
52#include <pcb_edit_frame.h>
53#include <pcbnew_id.h>
54#include <project.h>
55#include <project/project_file.h> // LAST_PATH_TYPE
56#include <tool/tool_manager.h>
57#include <tool/tool_event.h>
58#include <tools/drawing_tool.h>
59#include <tools/pcb_actions.h>
64#include <tools/edit_tool.h>
67#include <router/router_tool.h>
68#include <view/view_controls.h>
69#include <view/view_group.h>
73#include <wx/filedlg.h>
74#include <wx/log.h>
75
77
78using namespace std::placeholders;
79
80
82{
83public:
85 ACTION_MENU( true )
86 {
87 SetIcon( BITMAPS::add_zone );
88 SetTitle( _( "Zones" ) );
89
94
95 AppendSeparator();
96
101 }
102
103protected:
104 ACTION_MENU* create() const override
105 {
106 return new ZONE_CONTEXT_MENU();
107 }
108};
109
110
112{
113public:
115 CONDITIONAL_MENU( aTool )
116 {
117 SetIcon( BITMAPS::locked );
118 SetTitle( _( "Locking" ) );
119
123 }
124
125 ACTION_MENU* create() const override
126 {
127 return new LOCK_CONTEXT_MENU( this->m_tool );
128 }
129};
130
131
133 PCB_TOOL_BASE( "pcbnew.EditorControl" ),
134 m_frame( nullptr ),
135 m_inPlaceFootprint( false ),
136 m_placingFootprint( false ),
137 m_inPlaceTarget( false )
138{
139 m_placeOrigin = std::make_unique<KIGFX::ORIGIN_VIEWITEM>( KIGFX::COLOR4D( 0.8, 0.0, 0.0, 1.0 ),
141}
142
143
145{
146}
147
148
150{
151 m_frame = getEditFrame<PCB_EDIT_FRAME>();
152
153 if( aReason == MODEL_RELOAD || aReason == GAL_SWITCH || aReason == REDRAW )
154 {
155 m_placeOrigin->SetPosition( getModel<BOARD>()->GetDesignSettings().GetAuxOrigin() );
156 getView()->Remove( m_placeOrigin.get() );
157 getView()->Add( m_placeOrigin.get() );
158 }
159}
160
161
163{
164 auto activeToolCondition =
165 [this]( const SELECTION& aSel )
166 {
167 return ( !m_frame->ToolStackIsEmpty() );
168 };
169
170 auto inactiveStateCondition =
171 [this]( const SELECTION& aSel )
172 {
173 return ( m_frame->ToolStackIsEmpty() && aSel.Size() == 0 );
174 };
175
176 auto placeModuleCondition =
177 [this]( const SELECTION& aSel )
178 {
179 return m_frame->IsCurrentTool( PCB_ACTIONS::placeFootprint ) && aSel.GetSize() == 0;
180 };
181
182 auto& ctxMenu = m_menu.GetMenu();
183
184 // "Cancel" goes at the top of the context menu when a tool is active
185 ctxMenu.AddItem( ACTIONS::cancelInteractive, activeToolCondition, 1 );
186 ctxMenu.AddSeparator( 1 );
187
188 // "Get and Place Footprint" should be available for Place Footprint tool
189 ctxMenu.AddItem( PCB_ACTIONS::getAndPlace, placeModuleCondition, 1000 );
190 ctxMenu.AddSeparator( 1000 );
191
192 // Finally, add the standard zoom & grid items
193 getEditFrame<PCB_BASE_FRAME>()->AddStandardSubMenus( m_menu );
194
195 std::shared_ptr<ZONE_CONTEXT_MENU> zoneMenu = std::make_shared<ZONE_CONTEXT_MENU>();
196 zoneMenu->SetTool( this );
197
198 std::shared_ptr<LOCK_CONTEXT_MENU> lockMenu = std::make_shared<LOCK_CONTEXT_MENU>( this );
199
200 // Add the PCB control menus to relevant other tools
201
203
204 if( selTool )
205 {
206 TOOL_MENU& toolMenu = selTool->GetToolMenu();
207 CONDITIONAL_MENU& menu = toolMenu.GetMenu();
208
209 // Add "Get and Place Footprint" when Selection tool is in an inactive state
210 menu.AddItem( PCB_ACTIONS::getAndPlace, inactiveStateCondition );
211 menu.AddSeparator();
212
213 toolMenu.RegisterSubMenu( zoneMenu );
214 toolMenu.RegisterSubMenu( lockMenu );
215
216 menu.AddMenu( lockMenu.get(), SELECTION_CONDITIONS::NotEmpty, 100 );
217
218 menu.AddMenu( zoneMenu.get(), SELECTION_CONDITIONS::OnlyTypes( { PCB_ZONE_T } ), 100 );
219 }
220
221 DRAWING_TOOL* drawingTool = m_toolMgr->GetTool<DRAWING_TOOL>();
222
223 if( drawingTool )
224 {
225 TOOL_MENU& toolMenu = drawingTool->GetToolMenu();
226 CONDITIONAL_MENU& menu = toolMenu.GetMenu();
227
228 toolMenu.RegisterSubMenu( zoneMenu );
229
230 // Functor to say if the PCB_EDIT_FRAME is in a given mode
231 // Capture the tool pointer and tool mode by value
232 auto toolActiveFunctor =
233 [=]( DRAWING_TOOL::MODE aMode )
234 {
235 return [=]( const SELECTION& sel )
236 {
237 return drawingTool->GetDrawingMode() == aMode;
238 };
239 };
240
241 menu.AddMenu( zoneMenu.get(), toolActiveFunctor( DRAWING_TOOL::MODE::ZONE ), 300 );
242 }
243
244 return true;
245}
246
247
249{
251 return 0;
252}
253
254
256{
258 return 0;
259}
260
261
263{
265 return 0;
266}
267
268
270{
272 return 0;
273}
274
275
277{
279 return 0;
280}
281
282
284{
286 return 0;
287}
288
289
291{
292 PICKED_ITEMS_LIST undoCmd;
294 ITEM_PICKER wrapper( nullptr, undoItem, UNDO_REDO::PAGESETTINGS );
295
296 undoCmd.PushItem( wrapper );
297 undoCmd.SetDescription( _( "Page Settings" ) );
298 m_frame->SaveCopyInUndoList( undoCmd, UNDO_REDO::PAGESETTINGS );
299
303
304 if( dlg.ShowModal() == wxID_OK )
305 {
307 [&]( KIGFX::VIEW_ITEM* aItem ) -> int
308 {
309 EDA_TEXT* text = dynamic_cast<EDA_TEXT*>( aItem );
310
311 if( text && text->HasTextVars() )
312 {
313 text->ClearRenderCache();
314 text->ClearBoundingBoxCache();
316 }
317
318 return 0;
319 } );
320
321 m_frame->OnModify();
322 }
323 else
324 {
326 }
327
328 return 0;
329}
330
331
333{
335 return 0;
336}
337
338
340{
342 return 0;
343}
344
345
347{
349 return 0;
350}
351
352
354{
356 return 0;
357}
358
359
361{
362 getEditFrame<PCB_EDIT_FRAME>()->ShowBoardSetupDialog();
363 return 0;
364}
365
366
368{
369 getEditFrame<PCB_EDIT_FRAME>()->InstallNetlistFrame();
370 return 0;
371}
372
373
375{
376 wxString fullFileName = frame()->GetBoard()->GetFileName();
377 wxString path;
378 wxString name;
379 wxString ext;
380
381 wxFileName::SplitPath( fullFileName, &path, &name, &ext );
383
384 fullFileName = wxFileSelector( _( "Specctra Session File" ), path, name,
386 FILEEXT::SpecctraSessionFileWildcard(), wxFD_OPEN | wxFD_CHANGE_DIR,
387 frame() );
388
389 if( !fullFileName.IsEmpty() )
390 getEditFrame<PCB_EDIT_FRAME>()->ImportSpecctraSession( fullFileName );
391
392 return 0;
393}
394
395
397{
398 wxString fullFileName = m_frame->GetLastPath( LAST_PATH_SPECCTRADSN );
399 wxFileName fn;
400
401 if( fullFileName.IsEmpty() )
402 {
403 fn = m_frame->GetBoard()->GetFileName();
405 }
406 else
407 {
408 fn = fullFileName;
409 }
410
411 fullFileName = wxFileSelector( _( "Specctra DSN File" ), fn.GetPath(), fn.GetFullName(),
413 wxFD_SAVE | wxFD_OVERWRITE_PROMPT | wxFD_CHANGE_DIR, frame() );
414
415 if( !fullFileName.IsEmpty() )
416 {
417 m_frame->SetLastPath( LAST_PATH_SPECCTRADSN, fullFileName );
418 getEditFrame<PCB_EDIT_FRAME>()->ExportSpecctraFile( fullFileName );
419 }
420
421 return 0;
422}
423
424
426{
427 wxCHECK( m_frame, 0 );
428
429 wxFileName fn = m_frame->Prj().GetProjectFullName();
430
431 // Use a different file extension for the board netlist so the schematic netlist file
432 // is accidentally overwritten.
433 fn.SetExt( wxT( "pcb_net" ) );
434
435 wxFileDialog dlg( m_frame, _( "Export Board Netlist" ), fn.GetPath(), fn.GetFullName(),
436 _( "KiCad board netlist files" ) + AddFileExtListToFilter( { "pcb_net" } ),
437 wxFD_SAVE | wxFD_OVERWRITE_PROMPT );
438
439 dlg.SetExtraControlCreator( &LEGACYFILEDLG_NETLIST_OPTIONS::Create );
440
441 if( dlg.ShowModal() == wxID_CANCEL )
442 return 0;
443
444 fn = dlg.GetPath();
445
446 if( !fn.IsDirWritable() )
447 {
448 wxString msg;
449
450 msg.Printf( _( "Path `%s` is read only." ), fn.GetPath() );
451 wxMessageDialog( m_frame, msg, _( "I/O Error" ), wxOK | wxCENTER | wxICON_EXCLAMATION );
452 return 0;
453 }
454
456 dynamic_cast<const LEGACYFILEDLG_NETLIST_OPTIONS*>( dlg.GetExtraControl() );
457 wxCHECK( noh, 0 );
458
460
461 for( const FOOTPRINT* footprint : board()->Footprints() )
462 {
465 { footprint->m_Uuid } );
466
467 for( const PAD* pad : footprint->Pads() )
468 {
469 const wxString& netname = pad->GetShortNetname();
470
471 if( !netname.IsEmpty() )
472 {
473 component->AddNet( pad->GetNumber(), netname, pad->GetPinFunction(),
474 pad->GetPinType() );
475 }
476 }
477
478 nlohmann::ordered_map<wxString, wxString> fields;
479 for( PCB_FIELD* field : footprint->Fields() )
480 fields[field->GetCanonicalName()] = field->GetText();
481
482 component->SetFields( fields );
483
484 netlist.AddComponent( component );
485 }
486
487 FILE_OUTPUTFORMATTER formatter( fn.GetFullPath() );
488
489 netlist.Format( "pcb_netlist", &formatter, 0, noh->GetNetlistOptions() );
490
491 return 0;
492}
493
494
496{
497 wxCommandEvent dummy;
498
501 else if( aEvent.IsAction( &PCB_ACTIONS::generateReportFile ) )
503 else if( aEvent.IsAction( &PCB_ACTIONS::generateD356File ) )
505 else if( aEvent.IsAction( &PCB_ACTIONS::generateBOM ) )
507 else if( aEvent.IsAction( &PCB_ACTIONS::generateIPC2581File ) )
509 else
510 wxFAIL_MSG( wxT( "GenerateFabFiles(): unexpected request" ) );
511
512 return 0;
513}
514
515
517{
518 int errors = 0;
519 wxString details;
520 bool quiet = aEvent.Parameter<bool>();
521
522 // Repair duplicate IDs and missing nets.
523 std::set<KIID> ids;
524 int duplicates = 0;
525
526 auto processItem =
527 [&]( EDA_ITEM* aItem )
528 {
529 if( ids.count( aItem->m_Uuid ) )
530 {
531 duplicates++;
532 const_cast<KIID&>( aItem->m_Uuid ) = KIID();
533 }
534
535 ids.insert( aItem->m_Uuid );
536
537 BOARD_CONNECTED_ITEM* cItem = dynamic_cast<BOARD_CONNECTED_ITEM*>( aItem );
538
539 if( cItem && cItem->GetNetCode() )
540 {
541 NETINFO_ITEM* netinfo = cItem->GetNet();
542
543 if( netinfo && !board()->FindNet( netinfo->GetNetname() ) )
544 {
545 board()->Add( netinfo );
546
547 details += wxString::Format( _( "Orphaned net %s re-parented.\n" ),
548 netinfo->GetNetname() );
549 errors++;
550 }
551 }
552 };
553
554 // Footprint IDs are the most important, so give them the first crack at "claiming" a
555 // particular KIID.
556
557 for( FOOTPRINT* footprint : board()->Footprints() )
558 processItem( footprint );
559
560 // After that the principal use is for DRC marker pointers, which are most likely to pads
561 // or tracks.
562
563 for( FOOTPRINT* footprint : board()->Footprints() )
564 {
565 for( PAD* pad : footprint->Pads() )
566 processItem( pad );
567 }
568
569 for( PCB_TRACK* track : board()->Tracks() )
570 processItem( track );
571
572 // From here out I don't think order matters much.
573
574 for( FOOTPRINT* footprint : board()->Footprints() )
575 {
576 processItem( &footprint->Reference() );
577 processItem( &footprint->Value() );
578
579 for( BOARD_ITEM* item : footprint->GraphicalItems() )
580 processItem( item );
581
582 for( ZONE* zone : footprint->Zones() )
583 processItem( zone );
584
585 for( PCB_GROUP* group : footprint->Groups() )
586 processItem( group );
587 }
588
589 for( BOARD_ITEM* drawing : board()->Drawings() )
590 processItem( drawing );
591
592 for( ZONE* zone : board()->Zones() )
593 processItem( zone );
594
595 for( PCB_MARKER* marker : board()->Markers() )
596 processItem( marker );
597
598 for( PCB_GROUP* group : board()->Groups() )
599 processItem( group );
600
601 if( duplicates )
602 {
603 errors += duplicates;
604 details += wxString::Format( _( "%d duplicate IDs replaced.\n" ), duplicates );
605 }
606
607 /*******************************
608 * Your test here
609 */
610
611 /*******************************
612 * Inform the user
613 */
614
615 if( errors )
616 {
617 m_frame->OnModify();
618
619 wxString msg = wxString::Format( _( "%d potential problems repaired." ), errors );
620
621 if( !quiet )
622 DisplayInfoMessage( m_frame, msg, details );
623 }
624 else if( !quiet )
625 {
626 DisplayInfoMessage( m_frame, _( "No board problems found." ) );
627 }
628
629 return 0;
630}
631
632
634{
636
637 if( m_frame->FetchNetlistFromSchematic( netlist, _( "Updating PCB requires a fully annotated "
638 "schematic." ) ) )
639 {
640 DIALOG_UPDATE_PCB updateDialog( m_frame, &netlist );
641 updateDialog.ShowModal();
642 }
643
644 return 0;
645}
646
648{
649 if( Kiface().IsSingle() )
650 {
651 DisplayErrorMessage( m_frame, _( "Cannot update schematic because Pcbnew is opened in "
652 "stand-alone mode. In order to create or update PCBs "
653 "from schematics, you must launch the KiCad project "
654 "manager and create a project." ) );
655 return 0;
656 }
657
660
661 if( frame )
662 {
663 std::string payload;
664
665 if( wxWindow* blocking_win = frame->Kiway().GetBlockingDialog() )
666 blocking_win->Close( true );
667
669 }
670 return 0;
671}
672
673
675{
677 return 0;
678}
679
680
682{
683 getEditFrame<PCB_EDIT_FRAME>()->ToggleLayersManager();
684 return 0;
685}
686
687
689{
690 getEditFrame<PCB_EDIT_FRAME>()->ToggleProperties();
691 return 0;
692}
693
694
696{
697 getEditFrame<PCB_EDIT_FRAME>()->ToggleSearch();
698 return 0;
699}
700
701
703{
705 return 0;
706}
707
708
709// Track & via size control
711{
712 BOARD_DESIGN_SETTINGS& bds = getModel<BOARD>()->GetDesignSettings();
714
716 && SELECTION_CONDITIONS::OnlyTypes( { PCB_TRACE_T, PCB_ARC_T, PCB_VIA_T } )( selection ) )
717 {
718 BOARD_COMMIT commit( this );
719
720 for( EDA_ITEM* item : selection )
721 {
722 if( item->IsType( { PCB_TRACE_T, PCB_ARC_T } ) )
723 {
724 PCB_TRACK* track = static_cast<PCB_TRACK*>( item );
725
726 for( int i = 0; i < (int) bds.m_TrackWidthList.size(); ++i )
727 {
728 int candidate = bds.m_NetSettings->m_DefaultNetClass->GetTrackWidth();
729
730 if( i > 0 )
731 candidate = bds.m_TrackWidthList[ i ];
732
733 if( candidate > track->GetWidth() )
734 {
735 commit.Modify( track );
736 track->SetWidth( candidate );
737 break;
738 }
739 }
740 }
741 }
742
743 commit.Push( wxT( "Increase Track Width" ) );
744 return 0;
745 }
746
747 ROUTER_TOOL* routerTool = m_toolMgr->GetTool<ROUTER_TOOL>();
748
749 if( routerTool && routerTool->IsToolActive()
750 && routerTool->Router()->Mode() == PNS::PNS_MODE_ROUTE_DIFF_PAIR )
751 {
752 int widthIndex = (int) bds.GetDiffPairIndex() + 1;
753
754 // If we go past the last track width entry in the list, start over at the beginning
755 if( widthIndex >= (int) bds.m_DiffPairDimensionsList.size() )
756 widthIndex = 0;
757
758 bds.SetDiffPairIndex( widthIndex );
759 bds.UseCustomDiffPairDimensions( false );
760
762 }
763 else
764 {
765 int widthIndex = (int) bds.GetTrackWidthIndex();
766
767 if( routerTool && routerTool->IsToolActive()
770 {
771 bds.m_TempOverrideTrackWidth = true;
772 }
773 else
774 {
775 widthIndex++;
776 }
777
778 // If we go past the last track width entry in the list, start over at the beginning
779 if( widthIndex >= (int) bds.m_TrackWidthList.size() )
780 widthIndex = 0;
781
782 bds.SetTrackWidthIndex( widthIndex );
783 bds.UseCustomTrackViaSize( false );
784
786 }
787
788 return 0;
789}
790
791
793{
794 BOARD_DESIGN_SETTINGS& bds = getModel<BOARD>()->GetDesignSettings();
796
798 && SELECTION_CONDITIONS::OnlyTypes( { PCB_TRACE_T, PCB_ARC_T, PCB_VIA_T } )( selection ) )
799 {
800 BOARD_COMMIT commit( this );
801
802 for( EDA_ITEM* item : selection )
803 {
804 if( item->IsType( { PCB_TRACE_T, PCB_ARC_T } ) )
805 {
806 PCB_TRACK* track = static_cast<PCB_TRACK*>( item );
807
808 for( int i = (int) bds.m_TrackWidthList.size() - 1; i >= 0; --i )
809 {
810 int candidate = bds.m_NetSettings->m_DefaultNetClass->GetTrackWidth();
811
812 if( i > 0 )
813 candidate = bds.m_TrackWidthList[ i ];
814
815 if( candidate < track->GetWidth() )
816 {
817 commit.Modify( track );
818 track->SetWidth( candidate );
819 break;
820 }
821 }
822 }
823 }
824
825 commit.Push( wxT( "Decrease Track Width" ) );
826 return 0;
827 }
828
829 ROUTER_TOOL* routerTool = m_toolMgr->GetTool<ROUTER_TOOL>();
830
831 if( routerTool && routerTool->IsToolActive()
832 && routerTool->Router()->Mode() == PNS::PNS_MODE_ROUTE_DIFF_PAIR )
833 {
834 int widthIndex = (int) bds.GetDiffPairIndex() - 1;
835
836 // If we get to the lowest entry start over at the highest
837 if( widthIndex < 0 )
838 widthIndex = (int) bds.m_DiffPairDimensionsList.size() - 1;
839
840 bds.SetDiffPairIndex( widthIndex );
841 bds.UseCustomDiffPairDimensions( false );
842
844 }
845 else
846 {
847 int widthIndex = (int) bds.GetTrackWidthIndex();
848
849 if( routerTool && routerTool->IsToolActive()
852 {
853 bds.m_TempOverrideTrackWidth = true;
854 }
855 else
856 {
857 widthIndex--;
858 }
859
860 // If we get to the lowest entry start over at the highest
861 if( widthIndex < 0 )
862 widthIndex = (int) bds.m_TrackWidthList.size() - 1;
863
864 bds.SetTrackWidthIndex( widthIndex );
865 bds.UseCustomTrackViaSize( false );
866
868 }
869
870 return 0;
871}
872
873
875{
876 BOARD_DESIGN_SETTINGS& bds = getModel<BOARD>()->GetDesignSettings();
878
880 && SELECTION_CONDITIONS::OnlyTypes( { PCB_TRACE_T, PCB_ARC_T, PCB_VIA_T } )( selection ) )
881 {
882 BOARD_COMMIT commit( this );
883
884 for( EDA_ITEM* item : selection )
885 {
886 if( item->Type() == PCB_VIA_T )
887 {
888 PCB_VIA* via = static_cast<PCB_VIA*>( item );
889
890 for( int i = 0; i < (int) bds.m_ViasDimensionsList.size(); ++i )
891 {
892 VIA_DIMENSION dims( bds.m_NetSettings->m_DefaultNetClass->GetViaDiameter(),
893 bds.m_NetSettings->m_DefaultNetClass->GetViaDrill() );
894
895 if( i> 0 )
896 dims = bds.m_ViasDimensionsList[ i ];
897
898 if( dims.m_Diameter > via->GetWidth() )
899 {
900 commit.Modify( via );
901 via->SetWidth( dims.m_Diameter );
902 via->SetDrill( dims.m_Drill );
903 break;
904 }
905 }
906 }
907 }
908
909 commit.Push( wxT( "Increase Via Size" ) );
910 }
911 else
912 {
913 int sizeIndex = (int) bds.GetViaSizeIndex() + 1;
914
915 // If we go past the last via entry in the list, start over at the beginning
916 if( sizeIndex >= (int) bds.m_ViasDimensionsList.size() )
917 sizeIndex = 0;
918
919 bds.SetViaSizeIndex( sizeIndex );
920 bds.UseCustomTrackViaSize( false );
921
923 }
924
925 return 0;
926}
927
928
930{
931 BOARD_DESIGN_SETTINGS& bds = getModel<BOARD>()->GetDesignSettings();
933
935 && SELECTION_CONDITIONS::OnlyTypes( { PCB_TRACE_T, PCB_ARC_T, PCB_VIA_T } )( selection ) )
936 {
937 BOARD_COMMIT commit( this );
938
939 for( EDA_ITEM* item : selection )
940 {
941 if( item->Type() == PCB_VIA_T )
942 {
943 PCB_VIA* via = static_cast<PCB_VIA*>( item );
944
945 for( int i = (int) bds.m_ViasDimensionsList.size() - 1; i >= 0; --i )
946 {
947 VIA_DIMENSION dims( bds.m_NetSettings->m_DefaultNetClass->GetViaDiameter(),
948 bds.m_NetSettings->m_DefaultNetClass->GetViaDrill() );
949
950 if( i > 0 )
951 dims = bds.m_ViasDimensionsList[ i ];
952
953 if( dims.m_Diameter < via->GetWidth() )
954 {
955 commit.Modify( via );
956 via->SetWidth( dims.m_Diameter );
957 via->SetDrill( dims.m_Drill );
958 break;
959 }
960 }
961 }
962 }
963
964 commit.Push( "Decrease Via Size" );
965 }
966 else
967 {
968 int sizeIndex = 0; // Assume we only have a single via size entry
969
970 // If there are more, cycle through them backwards
971 if( bds.m_ViasDimensionsList.size() > 0 )
972 {
973 sizeIndex = (int) bds.GetViaSizeIndex() - 1;
974
975 // If we get to the lowest entry start over at the highest
976 if( sizeIndex < 0 )
977 sizeIndex = (int) bds.m_ViasDimensionsList.size() - 1;
978 }
979
980 bds.SetViaSizeIndex( sizeIndex );
981 bds.UseCustomTrackViaSize( false );
982
984 }
985
986 return 0;
987}
988
989
991{
993 return 0;
994
996
997 FOOTPRINT* fp = aEvent.Parameter<FOOTPRINT*>();
998 bool fromOtherCommand = fp != nullptr;
1000 BOARD_COMMIT commit( m_frame );
1001 BOARD* board = getModel<BOARD>();
1002 COMMON_SETTINGS* common_settings = Pgm().GetCommonSettings();
1003
1005
1006 m_frame->PushTool( aEvent );
1007
1008 auto setCursor =
1009 [&]()
1010 {
1011 m_frame->GetCanvas()->SetCurrentCursor( KICURSOR::PENCIL );
1012 };
1013
1014 auto cleanup =
1015 [&] ()
1016 {
1018 commit.Revert();
1019
1020 if( fromOtherCommand )
1021 {
1023
1024 if( undo )
1025 {
1028 delete undo;
1029 }
1030 }
1031
1032 fp = nullptr;
1033 m_placingFootprint = false;
1034 };
1035
1036 Activate();
1037 // Must be done after Activate() so that it gets set into the correct context
1038 controls->ShowCursor( true );
1039 // Set initial cursor
1040 setCursor();
1041
1042 VECTOR2I cursorPos = controls->GetCursorPosition();
1043 bool ignorePrimePosition = false;
1044 bool reselect = false;
1045
1046 // Prime the pump
1047 if( fp )
1048 {
1049 m_placingFootprint = true;
1050 fp->SetPosition( cursorPos );
1053 }
1054 else if( aEvent.HasPosition() )
1055 {
1056 m_toolMgr->PrimeTool( aEvent.Position() );
1057 }
1058 else if( common_settings->m_Input.immediate_actions && !aEvent.IsReactivate() )
1059 {
1060 m_toolMgr->PrimeTool( { 0, 0 } );
1061 ignorePrimePosition = true;
1062 }
1063
1064 // Main loop: keep receiving events
1065 while( TOOL_EVENT* evt = Wait() )
1066 {
1067 setCursor();
1068 cursorPos = controls->GetCursorPosition( !evt->DisableGridSnapping() );
1069
1070 if( reselect && fp )
1072
1073 if( evt->IsCancelInteractive() || ( fp && evt->IsAction( &ACTIONS::undo ) ) )
1074 {
1075 if( fp )
1076 {
1077 cleanup();
1078 }
1079 else
1080 {
1081 m_frame->PopTool( aEvent );
1082 break;
1083 }
1084 }
1085 else if( evt->IsActivate() )
1086 {
1087 if( fp )
1088 cleanup();
1089
1090 if( evt->IsMoveTool() )
1091 {
1092 // leave ourselves on the stack so we come back after the move
1093 break;
1094 }
1095 else
1096 {
1097 frame()->PopTool( aEvent );
1098 break;
1099 }
1100 }
1101 else if( evt->IsClick( BUT_LEFT ) )
1102 {
1103 if( !fp )
1104 {
1105 // Pick the footprint to be placed
1107
1108 if( fp == nullptr )
1109 continue;
1110
1111 // If we started with a hotkey which has a position then warp back to that.
1112 // Otherwise update to the current mouse position pinned inside the autoscroll
1113 // boundaries.
1114 if( evt->IsPrime() && !ignorePrimePosition )
1115 {
1116 cursorPos = evt->Position();
1117 getViewControls()->WarpMouseCursor( cursorPos, true );
1118 }
1119 else
1120 {
1122 cursorPos = getViewControls()->GetMousePosition();
1123 }
1124
1125 m_placingFootprint = true;
1126
1127 fp->SetLink( niluuid );
1128
1129 fp->SetFlags( IS_NEW ); // whatever
1130
1131 // Set parent so that clearance can be loaded
1132 fp->SetParent( board );
1134
1135 for( PAD* pad : fp->Pads() )
1136 {
1137 pad->SetLocalRatsnestVisible( m_frame->GetPcbNewSettings()->m_Display.m_ShowGlobalRatsnest );
1138
1139 // Pads in the library all have orphaned nets. Replace with Default.
1140 pad->SetNetCode( 0 );
1141 }
1142
1143 // Put it on FRONT layer,
1144 // (Can be stored flipped if the lib is an archive built from a board)
1145 if( fp->IsFlipped() )
1147
1148 fp->SetOrientation( ANGLE_0 );
1149 fp->SetPosition( cursorPos );
1150
1151 // Fill this in since it won't be synced from a symbol
1153
1154 commit.Add( fp );
1156
1158 }
1159 else
1160 {
1162 commit.Push( _( "Place a Footprint" ) );
1163 fp = nullptr; // to indicate that there is no footprint that we currently modify
1164 m_placingFootprint = false;
1165 }
1166 }
1167 else if( evt->IsClick( BUT_RIGHT ) )
1168 {
1170 }
1171 else if( fp && ( evt->IsMotion() || evt->IsAction( &ACTIONS::refreshPreview ) ) )
1172 {
1173 fp->SetPosition( cursorPos );
1174 selection().SetReferencePoint( cursorPos );
1175 getView()->Update( &selection() );
1176 getView()->Update( fp );
1177 }
1178 else if( fp && evt->IsAction( &PCB_ACTIONS::properties ) )
1179 {
1180 // Calling 'Properties' action clears the selection, so we need to restore it
1181 reselect = true;
1182 }
1183 else if( fp && ( ZONE_FILLER_TOOL::IsZoneFillAction( evt )
1184 || evt->IsAction( &ACTIONS::redo ) ) )
1185 {
1186 wxBell();
1187 }
1188 else
1189 {
1190 evt->SetPassEvent();
1191 }
1192
1193 // Enable autopanning and cursor capture only when there is a footprint to be placed
1194 controls->SetAutoPan( fp != nullptr );
1195 controls->CaptureCursor( fp != nullptr );
1196 }
1197
1198 controls->SetAutoPan( false );
1199 controls->CaptureCursor( false );
1200 m_frame->GetCanvas()->SetCurrentCursor( KICURSOR::ARROW );
1201
1202 return 0;
1203}
1204
1205
1207{
1208 return modifyLockSelected( TOGGLE );
1209}
1210
1211
1213{
1214 return modifyLockSelected( ON );
1215}
1216
1217
1219{
1220 return modifyLockSelected( OFF );
1221}
1222
1223
1225{
1227 const PCB_SELECTION& selection = selTool->GetSelection();
1228 BOARD_COMMIT commit( m_frame );
1229
1230 if( selection.Empty() )
1232
1233 // Resolve TOGGLE mode
1234 if( aMode == TOGGLE )
1235 {
1236 aMode = ON;
1237
1238 for( EDA_ITEM* item : selection )
1239 {
1240 BOARD_ITEM* board_item = dynamic_cast<BOARD_ITEM*>( item );
1241
1242 if( board_item && board_item->IsLocked() )
1243 {
1244 aMode = OFF;
1245 break;
1246 }
1247 }
1248 }
1249
1250 for( EDA_ITEM* item : selection )
1251 {
1252 BOARD_ITEM* board_item = dynamic_cast<BOARD_ITEM*>( item );
1253 wxCHECK2( board_item, continue );
1254
1255 PCB_GENERATOR* generator = dynamic_cast<PCB_GENERATOR*>( board_item->GetParentGroup() );
1256
1257 if( generator && commit.GetStatus( generator ) != CHT_MODIFY )
1258 {
1259 commit.Modify( generator );
1260
1261 if( aMode == ON )
1262 generator->SetLocked( true );
1263 else
1264 generator->SetLocked( false );
1265 }
1266
1267 commit.Modify( board_item );
1268
1269 if( aMode == ON )
1270 board_item->SetLocked( true );
1271 else
1272 board_item->SetLocked( false );
1273 }
1274
1275 if( !commit.Empty() )
1276 {
1277 commit.Push( aMode == ON ? _( "Lock" ) : _( "Unlock" ) );
1278
1280 m_frame->OnModify();
1281 }
1282
1283 return 0;
1284}
1285
1286
1287static bool mergeZones( EDA_DRAW_FRAME* aFrame, BOARD_COMMIT& aCommit,
1288 std::vector<ZONE*>& aOriginZones, std::vector<ZONE*>& aMergedZones )
1289{
1290 aCommit.Modify( aOriginZones[0] );
1291
1292 for( unsigned int i = 1; i < aOriginZones.size(); i++ )
1293 {
1294 aOriginZones[0]->Outline()->BooleanAdd( *aOriginZones[i]->Outline(),
1296 }
1297
1298 aOriginZones[0]->Outline()->Simplify( SHAPE_POLY_SET::PM_FAST );
1299
1300 // We should have one polygon, possibly with holes. If we end up with two polygons (either
1301 // because the intersection was a single point or because the intersection was within one of
1302 // the zone's holes) then we can't merge.
1303 if( aOriginZones[0]->Outline()->IsSelfIntersecting()
1304 || aOriginZones[0]->Outline()->OutlineCount() > 1 )
1305 {
1306 DisplayErrorMessage( aFrame, _( "Zones have insufficient overlap for merging." ) );
1307 aCommit.Revert();
1308 return false;
1309 }
1310
1311 for( unsigned int i = 1; i < aOriginZones.size(); i++ )
1312 aCommit.Remove( aOriginZones[i] );
1313
1314 aMergedZones.push_back( aOriginZones[0] );
1315
1316 aOriginZones[0]->SetLocalFlags( 1 );
1317 aOriginZones[0]->HatchBorder();
1318 aOriginZones[0]->CacheTriangulation();
1319
1320 return true;
1321}
1322
1323
1325{
1326 const PCB_SELECTION& selection = m_toolMgr->GetTool<PCB_SELECTION_TOOL>()->GetSelection();
1327 BOARD* board = getModel<BOARD>();
1328 BOARD_COMMIT commit( m_frame );
1329
1330 if( selection.Size() < 2 )
1331 return 0;
1332
1333 int netcode = -1;
1334
1335 ZONE* firstZone = nullptr;
1336 std::vector<ZONE*> toMerge, merged;
1337
1338 for( EDA_ITEM* item : selection )
1339 {
1340 ZONE* curr_area = dynamic_cast<ZONE*>( item );
1341
1342 if( !curr_area )
1343 continue;
1344
1345 if( !firstZone )
1346 firstZone = curr_area;
1347
1348 netcode = curr_area->GetNetCode();
1349
1350 if( firstZone->GetNetCode() != netcode )
1351 {
1352 wxLogMessage( _( "Some zone netcodes did not match and were not merged." ) );
1353 continue;
1354 }
1355
1356 if( curr_area->GetAssignedPriority() != firstZone->GetAssignedPriority() )
1357 {
1358 wxLogMessage( _( "Some zone priorities did not match and were not merged." ) );
1359 continue;
1360 }
1361
1362 if( curr_area->GetIsRuleArea() != firstZone->GetIsRuleArea() )
1363 {
1364 wxLogMessage( _( "Some zones were rule areas and were not merged." ) );
1365 continue;
1366 }
1367
1368 if( curr_area->GetLayerSet() != firstZone->GetLayerSet() )
1369 {
1370 wxLogMessage( _( "Some zone layer sets did not match and were not merged." ) );
1371 continue;
1372 }
1373
1374 bool intersects = curr_area == firstZone;
1375
1376 for( ZONE* candidate : toMerge )
1377 {
1378 if( intersects )
1379 break;
1380
1381 if( board->TestZoneIntersection( curr_area, candidate ) )
1382 intersects = true;
1383 }
1384
1385 if( !intersects )
1386 {
1387 wxLogMessage( _( "Some zones did not intersect and were not merged." ) );
1388 continue;
1389 }
1390
1391 toMerge.push_back( curr_area );
1392 }
1393
1395
1396 if( !toMerge.empty() )
1397 {
1398 if( mergeZones( m_frame, commit, toMerge, merged ) )
1399 {
1400 commit.Push( wxT( "Merge Zones" ) );
1401
1402 for( EDA_ITEM* item : merged )
1404 }
1405 }
1406
1407 return 0;
1408}
1409
1410
1412{
1414 const PCB_SELECTION& selection = selTool->GetSelection();
1415
1416 // because this pops up the zone editor, it would be confusing to handle multiple zones,
1417 // so just handle single selections containing exactly one zone
1418 if( selection.Size() != 1 )
1419 return 0;
1420
1421 ZONE* oldZone = dynamic_cast<ZONE*>( selection[0] );
1422
1423 if( !oldZone )
1424 return 0;
1425
1426 ZONE_SETTINGS zoneSettings;
1427 zoneSettings << *oldZone;
1428 int dialogResult;
1429
1430 if( oldZone->GetIsRuleArea() )
1431 dialogResult = InvokeRuleAreaEditor( m_frame, &zoneSettings );
1432 else if( oldZone->IsOnCopperLayer() )
1433 dialogResult = InvokeCopperZonesEditor( m_frame, &zoneSettings );
1434 else
1435 dialogResult = InvokeNonCopperZonesEditor( m_frame, &zoneSettings );
1436
1437 if( dialogResult != wxID_OK )
1438 return 0;
1439
1440 // duplicate the zone
1441 BOARD_COMMIT commit( m_frame );
1442
1443 std::unique_ptr<ZONE> newZone = std::make_unique<ZONE>( *oldZone );
1444 newZone->ClearSelected();
1445 newZone->UnFill();
1446 zoneSettings.ExportSetting( *newZone );
1447
1448 // If the new zone is on the same layer(s) as the initial zone,
1449 // offset it a bit so it can more easily be picked.
1450 if( oldZone->GetLayerSet() == zoneSettings.m_Layers )
1451 newZone->Move( VECTOR2I( pcbIUScale.IU_PER_MM, pcbIUScale.IU_PER_MM ) );
1452
1453 commit.Add( newZone.release() );
1454 commit.Push( _( "Duplicate Zone" ) );
1455
1456 return 0;
1457}
1458
1459
1461{
1462 doCrossProbePcbToSch( aEvent, false );
1463 return 0;
1464}
1465
1466
1468{
1469 doCrossProbePcbToSch( aEvent, true );
1470 return 0;
1471}
1472
1473
1475{
1476 // Don't get in an infinite loop PCB -> SCH -> PCB -> SCH -> ...
1478 return;
1479
1481 const PCB_SELECTION& selection = selTool->GetSelection();
1482 EDA_ITEM* focusItem = nullptr;
1483
1484 if( aEvent.Matches( EVENTS::PointSelectedEvent ) )
1485 focusItem = selection.GetLastAddedItem();
1486
1487 m_frame->SendSelectItemsToSch( selection.GetItems(), focusItem, aForce );
1488
1489 // Update 3D viewer highlighting
1491}
1492
1493
1495{
1497
1498 const PCB_SELECTION& selection = selectionTool->RequestSelection(
1499 []( const VECTOR2I& aPt, GENERAL_COLLECTOR& aCollector, PCB_SELECTION_TOOL* sTool )
1500 {
1501 // Iterate from the back so we don't have to worry about removals.
1502 for( int i = aCollector.GetCount() - 1; i >= 0; --i )
1503 {
1504 if( !dynamic_cast<BOARD_CONNECTED_ITEM*>( aCollector[ i ] ) )
1505 aCollector.Remove( aCollector[ i ] );
1506 }
1507 },
1508 true /* prompt user regarding locked items */ );
1509
1510 int netCode = -1;
1511 wxString netName;
1512
1513 for( EDA_ITEM* item : selection )
1514 {
1515 NETINFO_ITEM* net = static_cast<BOARD_CONNECTED_ITEM*>( item )->GetNet();
1516
1517 if( !net->HasAutoGeneratedNetname() )
1518 {
1519 netCode = net->GetNetCode();
1520 netName = net->GetNetname();
1521 break;
1522 }
1523 }
1524
1525 if( netName.IsEmpty() )
1526 {
1527 m_frame->ShowInfoBarError( _( "Selection contains no items with labeled nets." ) );
1528 return 0;
1529 }
1530
1531 selectionTool->ClearSelection();
1533 canvas()->ForceRefresh();
1534
1535 DIALOG_ASSIGN_NETCLASS dlg( m_frame, netName, board()->GetNetClassAssignmentCandidates(),
1536 [this]( const std::vector<wxString>& aNetNames )
1537 {
1539 selTool->ClearSelection();
1540
1541 for( const wxString& curr_netName : aNetNames )
1542 {
1543 int curr_netCode = board()->GetNetInfo().GetNetItem( curr_netName )->GetNetCode();
1544
1545 if( curr_netCode > 0 )
1546 selTool->SelectAllItemsOnNet( curr_netCode );
1547 }
1548
1549 canvas()->ForceRefresh();
1551 } );
1552
1553 if( dlg.ShowModal() == wxID_OK )
1554 {
1556 // Refresh UI that depends on netclasses, such as the properties panel
1558 }
1559
1560 return 0;
1561}
1562
1563
1565{
1568
1569 if( selection.Empty() )
1570 {
1571 // Giant hack: by default we assign Edit Table to the same hotkey, so give the table
1572 // tool a chance to handle it if we can't.
1574 tableTool->EditTable( aEvent );
1575
1576 return 0;
1577 }
1578
1580
1581 if( !fp )
1582 return 0;
1583
1584 PCB_BASE_EDIT_FRAME* editFrame = getEditFrame<PCB_BASE_EDIT_FRAME>();
1585
1586 auto editor = (FOOTPRINT_EDIT_FRAME*) editFrame->Kiway().Player( FRAME_FOOTPRINT_EDITOR, true );
1587
1589 editor->LoadFootprintFromBoard( fp );
1590 else if( aEvent.IsAction( &PCB_ACTIONS::editLibFpInFpEditor ) )
1591 editor->LoadFootprintFromLibrary( fp->GetFPID() );
1592
1593 editor->Show( true );
1594 editor->Raise(); // Iconize( false );
1595
1596 if( selection.IsHover() )
1598
1599 return 0;
1600}
1601
1602
1604 EDA_ITEM* originViewItem, const VECTOR2D& aPosition )
1605{
1606 aFrame->GetDesignSettings().SetAuxOrigin( VECTOR2I( aPosition ) );
1607 originViewItem->SetPosition( aPosition );
1608 aView->MarkDirty();
1609 aFrame->OnModify();
1610}
1611
1612
1614{
1616 {
1617 m_frame->SaveCopyInUndoList( m_placeOrigin.get(), UNDO_REDO::GRIDORIGIN );
1619 return 0;
1620 }
1621
1623
1624 // Deactivate other tools; particularly important if another PICKER is currently running
1625 Activate();
1626
1627 picker->SetClickHandler(
1628 [this] ( const VECTOR2D& pt ) -> bool
1629 {
1630 m_frame->SaveCopyInUndoList( m_placeOrigin.get(), UNDO_REDO::DRILLORIGIN );
1632 return false; // drill origin is a one-shot; don't continue with tool
1633 } );
1634
1636
1637 return 0;
1638}
1639
1640
1642{
1651
1656
1661
1662 if( ADVANCED_CFG::GetCfg().m_ShowPcbnewExportNetlist && m_frame &&
1665
1673
1674 // Track & via size control
1679
1680 // Zone actions
1683
1684 // Placing tools
1688
1691
1692 // Cross-select
1698
1699 // Other
1703
1705
1714}
1715
1716
1717const int BOARD_EDITOR_CONTROL::WIDTH_STEP = 100000;
const char * name
Definition: DXF_plotter.cpp:57
constexpr EDA_IU_SCALE pcbIUScale
Definition: base_units.h:109
KIFACE_BASE & Kiface()
Global KIFACE_BASE "get" accessor.
static bool mergeZones(EDA_DRAW_FRAME *aFrame, BOARD_COMMIT &aCommit, std::vector< ZONE * > &aOriginZones, std::vector< ZONE * > &aMergedZones)
static TOOL_ACTION updatePcbFromSchematic
Definition: actions.h:199
static TOOL_ACTION cancelInteractive
Definition: actions.h:63
static TOOL_ACTION revert
Definition: actions.h:55
static TOOL_ACTION saveAs
Definition: actions.h:52
static TOOL_ACTION pickerTool
Definition: actions.h:189
static TOOL_ACTION findPrevious
Definition: actions.h:102
static TOOL_ACTION plot
Definition: actions.h:58
static TOOL_ACTION open
Definition: actions.h:50
static TOOL_ACTION findNext
Definition: actions.h:101
static TOOL_ACTION pageSettings
Definition: actions.h:56
static TOOL_ACTION showSearch
Definition: actions.h:98
static TOOL_ACTION undo
Definition: actions.h:66
static TOOL_ACTION save
Definition: actions.h:51
static TOOL_ACTION redo
Definition: actions.h:67
static TOOL_ACTION updateSchematicFromPcb
Definition: actions.h:200
static TOOL_ACTION showProperties
Definition: actions.h:201
static TOOL_ACTION doNew
Definition: actions.h:47
static TOOL_ACTION saveCopy
Definition: actions.h:53
static TOOL_ACTION refreshPreview
Definition: actions.h:137
static TOOL_ACTION find
Definition: actions.h:99
Defines the structure of a menu based on ACTIONs.
Definition: action_menu.h:49
void SetTitle(const wxString &aTitle) override
Set title for the menu.
Definition: action_menu.cpp:92
void SetIcon(BITMAPS aIcon)
Assign an icon for the entry.
Definition: action_menu.cpp:78
wxMenuItem * Add(const wxString &aLabel, int aId, BITMAPS aIcon)
Add a wxWidgets-style entry to the menu.
TOOL_INTERACTIVE * m_tool
Associates tool actions with menu item IDs. Non-owning.
Definition: action_menu.h:278
static const ADVANCED_CFG & GetCfg()
Get the singleton instance's config, which is shared by all consumers.
static wxString m_DrawingSheetFileName
the name of the drawing sheet file, or empty to use the default drawing sheet
Definition: base_screen.h:85
virtual void Push(const wxString &aMessage=wxEmptyString, int aCommitFlags=0) override
Revert the commit by restoring the modified items state.
virtual void Revert() override
A base class derived from BOARD_ITEM for items that can be connected and have a net,...
NETINFO_ITEM * GetNet() const
Return #NET_INFO object for a given item.
Container for design settings for a BOARD object.
void UseCustomTrackViaSize(bool aEnabled)
Enables/disables custom track/via size settings.
void SetDiffPairIndex(unsigned aIndex)
std::shared_ptr< NET_SETTINGS > m_NetSettings
std::vector< DIFF_PAIR_DIMENSION > m_DiffPairDimensionsList
void SetTrackWidthIndex(unsigned aIndex)
Set the current track width list index to aIndex.
void SetAuxOrigin(const VECTOR2I &aOrigin)
void SetViaSizeIndex(unsigned aIndex)
Set the current via size list index to aIndex.
unsigned GetTrackWidthIndex() const
unsigned GetViaSizeIndex() const
void UseCustomDiffPairDimensions(bool aEnabled)
Enables/disables custom differential pair dimensions.
std::vector< int > m_TrackWidthList
unsigned GetDiffPairIndex() const
std::vector< VIA_DIMENSION > m_ViasDimensionsList
int ExportNetlist(const TOOL_EVENT &aEvent)
int UnlockSelected(const TOOL_EVENT &aEvent)
Run the drill origin tool for setting the origin for drill and pick-and-place files.
int Save(const TOOL_EVENT &aEvent)
int ImportNetlist(const TOOL_EVENT &aEvent)
int GenerateDrillFiles(const TOOL_EVENT &aEvent)
int ZoneMerge(const TOOL_EVENT &aEvent)
Duplicate a zone onto a layer (prompts for new layer)
int CrossProbeToSch(const TOOL_EVENT &aEvent)
Equivalent to the above, but initiated by the user.
int TogglePythonConsole(const TOOL_EVENT &aEvent)
static void DoSetDrillOrigin(KIGFX::VIEW *aView, PCB_BASE_FRAME *aFrame, EDA_ITEM *aItem, const VECTOR2D &aPoint)
int UpdatePCBFromSchematic(const TOOL_EVENT &aEvent)
std::unique_ptr< KIGFX::ORIGIN_VIEWITEM > m_placeOrigin
int ShowEeschema(const TOOL_EVENT &aEvent)
int SaveAs(const TOOL_EVENT &aEvent)
int AssignNetclass(const TOOL_EVENT &aEvent)
int UpdateSchematicFromPCB(const TOOL_EVENT &aEvent)
int ExplicitCrossProbeToSch(const TOOL_EVENT &aEvent)
Assign a netclass to a labelled net.
int ToggleSearch(const TOOL_EVENT &aEvent)
int DrillOrigin(const TOOL_EVENT &aEvent)
Low-level access (below undo) to setting the drill origin.
MODIFY_MODE
< How to modify a property for selected items.
int GenerateFabFiles(const TOOL_EVENT &aEvent)
int ViaSizeDec(const TOOL_EVENT &aEvent)
void Reset(RESET_REASON aReason) override
Bring the tool to a known, initial state.
int RepairBoard(const TOOL_EVENT &aEvent)
int ZoneDuplicate(const TOOL_EVENT &aEvent)
int ToggleLayersManager(const TOOL_EVENT &aEvent)
int ImportSpecctraSession(const TOOL_EVENT &aEvent)
bool Init() override
Init() is called once upon a registration of the tool.
int PlaceFootprint(const TOOL_EVENT &aEvent)
Display a dialog to select a footprint to be added and allows the user to set its position.
int BoardSetup(const TOOL_EVENT &aEvent)
int modifyLockSelected(MODIFY_MODE aMode)
Set up handlers for various events.
void setTransitions() override
This method is meant to be overridden in order to specify handlers for events.
int TrackWidthInc(const TOOL_EVENT &aEvent)
static const int WIDTH_STEP
How does line width change after one -/+ key press.
int ToggleLockSelected(const TOOL_EVENT &aEvent)
Lock selected items.
int LockSelected(const TOOL_EVENT &aEvent)
Unlock selected items.
int PageSettings(const TOOL_EVENT &aEvent)
int ExportSpecctraDSN(const TOOL_EVENT &aEvent)
int FindNext(const TOOL_EVENT &aEvent)
int ViaSizeInc(const TOOL_EVENT &aEvent)
int New(const TOOL_EVENT &aEvent)
int Find(const TOOL_EVENT &aEvent)
void doCrossProbePcbToSch(const TOOL_EVENT &aEvent, bool aForce)
int Plot(const TOOL_EVENT &aEvent)
int TrackWidthDec(const TOOL_EVENT &aEvent)
int Revert(const TOOL_EVENT &aEvent)
int Search(const TOOL_EVENT &aEvent)
int Open(const TOOL_EVENT &aEvent)
int SaveCopy(const TOOL_EVENT &aEvent)
int GeneratePosFile(const TOOL_EVENT &aEvent)
int EditFpInFpEditor(const TOOL_EVENT &aEvent)
Notify Eeschema about selected items.
int ToggleProperties(const TOOL_EVENT &aEvent)
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:77
virtual void SetLocked(bool aLocked)
Definition: board_item.h:300
PCB_GROUP * GetParentGroup() const
Definition: board_item.h:91
virtual bool IsLocked() const
Definition: board_item.cpp:74
Information pertinent to a Pcbnew printed circuit board.
Definition: board.h:276
const NETINFO_LIST & GetNetInfo() const
Definition: board.h:832
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_MODE::INSERT, bool aSkipConnectivity=false) override
Removes an item from the container.
Definition: board.cpp:891
void UpdateUserUnits(BOARD_ITEM *aItem, KIGFX::VIEW *aView)
Update any references within aItem (or its descendants) to the user units.
Definition: board.cpp:1095
NETINFO_ITEM * FindNet(int aNetcode) const
Search for a net with the given netcode.
Definition: board.cpp:1680
void SynchronizeNetsAndNetClasses(bool aResetTrackAndViaSizes)
Copy NETCLASS info to each NET, based on NET membership in a NETCLASS.
Definition: board.cpp:1813
const wxString & GetFileName() const
Definition: board.h:313
bool TestZoneIntersection(ZONE *aZone1, ZONE *aZone2)
Test for intersection of 2 copper areas.
int GetCount() const
Return the number of objects in the list.
Definition: collector.h:81
void Remove(int aIndex)
Remove the item at aIndex (first position is 0).
Definition: collector.h:109
COMMIT & Remove(EDA_ITEM *aItem, BASE_SCREEN *aScreen=nullptr)
Notify observers that aItem has been removed.
Definition: commit.h:92
COMMIT & Modify(EDA_ITEM *aItem, BASE_SCREEN *aScreen=nullptr)
Create an undo entry for an item that has been already modified.
Definition: commit.h:105
bool Empty() const
Returns status of an item.
Definition: commit.h:144
COMMIT & Add(EDA_ITEM *aItem, BASE_SCREEN *aScreen=nullptr)
Notify observers that aItem has been added.
Definition: commit.h:80
int GetStatus(EDA_ITEM *aItem, BASE_SCREEN *aScreen=nullptr)
Definition: commit.cpp:129
Store all of the related footprint information found in a netlist.
Definition: pcb_netlist.h:86
void SetFields(nlohmann::ordered_map< wxString, wxString > &aFields)
Definition: pcb_netlist.h:132
void AddNet(const wxString &aPinName, const wxString &aNetName, const wxString &aPinFunction, const wxString &aPinType)
Definition: pcb_netlist.h:104
void AddItem(const TOOL_ACTION &aAction, const SELECTION_CONDITION &aCondition, int aOrder=ANY_ORDER)
Add a menu entry to run a TOOL_ACTION on selected items.
void AddSeparator(int aOrder=ANY_ORDER)
Add a separator to the menu.
void AddMenu(ACTION_MENU *aMenu, const SELECTION_CONDITION &aCondition=SELECTION_CONDITIONS::ShowAlways, int aOrder=ANY_ORDER)
Add a submenu to the menu.
void SetWksFileName(const wxString &aFilename)
Tool responsible for drawing graphical elements like lines, arcs, circles, etc.
Definition: drawing_tool.h:55
MODE GetDrawingMode() const
Return the current drawing mode of the DRAWING_TOOL or MODE::NONE if not currently in any drawing mod...
virtual PICKED_ITEMS_LIST * PopCommandFromUndoList()
Return the last command to undo and remove it from list, nothing is deleted.
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...
The base class for create windows for drawing purpose.
void ScriptingConsoleEnableDisable()
Toggles the scripting console visibility.
virtual void UpdateMsgPanel()
Redraw the message panel.
void ForceRefresh()
Force a redraw.
void SetCurrentCursor(KICURSOR aCursor)
Set the current cursor shape for this panel.
A base class for most all the KiCad significant classes used in schematics and boards.
Definition: eda_item.h:85
virtual void SetPosition(const VECTOR2I &aPos)
Definition: eda_item.h:240
void SetFlags(EDA_ITEM_FLAGS aMask)
Definition: eda_item.h:123
virtual void SetParent(EDA_ITEM *aParent)
Definition: eda_item.h:100
A mix-in class (via multiple inheritance) that handles texts such as labels, parts,...
Definition: eda_text.h:80
virtual void SetText(const wxString &aText)
Definition: eda_text.cpp:183
static void FootprintFilter(const VECTOR2I &, GENERAL_COLLECTOR &aCollector, PCB_SELECTION_TOOL *sTool)
A selection filter which prunes the selection to contain only items of type #PCB_MODULE_T.
Definition: edit_tool.cpp:2738
static const TOOL_EVENT ClearedEvent
Definition: actions.h:259
static const TOOL_EVENT SelectedEvent
Definition: actions.h:257
static const TOOL_EVENT SelectedItemsModified
Selected items were moved, this can be very high frequency on the canvas, use with care.
Definition: actions.h:264
static const TOOL_EVENT PointSelectedEvent
Definition: actions.h:256
static const TOOL_EVENT UnselectedEvent
Definition: actions.h:258
Used for text file output.
Definition: richio.h:475
void SetPosition(const VECTOR2I &aPos) override
Definition: footprint.cpp:2056
void SetLink(const KIID &aLink)
Definition: footprint.h:829
ZONES & Zones()
Definition: footprint.h:194
void SetOrientation(const EDA_ANGLE &aNewAngle)
Definition: footprint.cpp:2128
PCB_FIELD & Value()
read/write accessors:
Definition: footprint.h:617
wxString GetFPIDAsString() const
Definition: footprint.h:233
bool IsFlipped() const
Definition: footprint.h:370
PADS & Pads()
Definition: footprint.h:188
const LIB_ID & GetFPID() const
Definition: footprint.h:230
PCB_FIELD & Reference()
Definition: footprint.h:618
GROUPS & Groups()
Definition: footprint.h:197
PCB_FIELDS & Fields()
Definition: footprint.h:185
void Flip(const VECTOR2I &aCentre, bool aFlipLeftRight) override
Flip this object, i.e.
Definition: footprint.cpp:1996
const wxString & GetValue() const
Definition: footprint.h:603
const wxString & GetReference() const
Definition: footprint.h:581
PCB_FIELD * GetField(MANDATORY_FIELD_T aFieldType)
Return a mandatory field in this symbol.
Definition: footprint.cpp:256
const KIID_PATH & GetPath() const
Definition: footprint.h:242
VECTOR2I GetPosition() const override
Definition: footprint.h:206
DRAWINGS & GraphicalItems()
Definition: footprint.h:191
Used when the right click button is pressed, or when the select tool is in effect.
Definition: collectors.h:206
A color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:104
An interface for classes handling user events controlling the view behavior such as zooming,...
virtual void CaptureCursor(bool aEnabled)
Force the cursor to stay within the drawing panel area.
virtual void ShowCursor(bool aEnabled)
Enable or disables display of cursor.
virtual void WarpMouseCursor(const VECTOR2D &aPosition, bool aWorldCoordinates=false, bool aWarpView=false)=0
If enabled (.
VECTOR2D GetCursorPosition() const
Return the current cursor position in world coordinates.
virtual VECTOR2D GetMousePosition(bool aWorldCoordinates=true) const =0
Return the current mouse pointer position.
virtual void SetAutoPan(bool aEnabled)
Turn on/off auto panning (this feature is used when there is a tool active (eg.
virtual void PinCursorInsideNonAutoscrollArea(bool aWarpMouseCursor)=0
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
virtual void Add(VIEW_ITEM *aItem, int aDrawPriority=-1)
Add a VIEW_ITEM to the view.
Definition: view.cpp:315
virtual void Remove(VIEW_ITEM *aItem)
Remove a VIEW_ITEM from the view.
Definition: view.cpp:354
virtual void Update(const VIEW_ITEM *aItem, int aUpdateFlags) const
For dynamic VIEWs, inform the associated VIEW that the graphical representation of this item has chan...
Definition: view.cpp:1636
void MarkDirty()
Force redraw of view on the next rendering.
Definition: view.h:643
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:1528
Definition: kiid.h:49
PROJECT & Prj() const
Return a reference to the PROJECT associated with this KIWAY.
KIWAY & Kiway() const
Return a reference to the KIWAY that this object has an opportunity to participate in.
Definition: kiway_holder.h:53
A wxFrame capable of the OpenProjectFiles function, meaning it can load a portion of a KiCad project.
Definition: kiway_player.h:67
virtual KIWAY_PLAYER * Player(FRAME_T aFrameType, bool doCreate=true, wxTopLevelWindow *aParent=nullptr)
Return the KIWAY_PLAYER* given a FRAME_T.
Definition: kiway.cpp:432
wxWindow * GetBlockingDialog()
Gets the window pointer to the blocking dialog (to send it signals)
Definition: kiway.cpp:695
virtual void ExpressMail(FRAME_T aDestination, MAIL_T aCommand, std::string &aPayload, wxWindow *aSource=nullptr)
Send aPayload to aDestination from aSource.
Definition: kiway.cpp:553
Helper widget to add controls to a wxFileDialog to set netlist configuration options.
static wxWindow * Create(wxWindow *aParent)
ACTION_MENU * create() const override
< Return an instance of this class. It has to be overridden in inheriting classes.
LOCK_CONTEXT_MENU(TOOL_INTERACTIVE *aTool)
Handle the data for a net.
Definition: netinfo.h:56
bool HasAutoGeneratedNetname()
Definition: netinfo.h:129
const wxString & GetNetname() const
Definition: netinfo.h:114
int GetNetCode() const
Definition: netinfo.h:108
NETINFO_ITEM * GetNetItem(int aNetCode) const
Store information read from a netlist along with the flags used to update the NETLIST in the BOARD.
Definition: pcb_netlist.h:223
Definition: pad.h:59
DISPLAY_OPTIONS m_Display
static TOOL_ACTION generateBOM
Definition: pcb_actions.h:431
static TOOL_ACTION zoneFillAll
Definition: pcb_actions.h:392
static TOOL_ACTION showLayersManager
Definition: pcb_actions.h:439
static TOOL_ACTION trackWidthDec
Definition: pcb_actions.h:382
static TOOL_ACTION generateDrillFiles
Definition: pcb_actions.h:426
static TOOL_ACTION selectionCursor
Select a single item under the cursor position.
Definition: pcb_actions.h:65
static TOOL_ACTION generateD356File
Definition: pcb_actions.h:430
static TOOL_ACTION trackViaSizeChanged
Definition: pcb_actions.h:386
static TOOL_ACTION exportSpecctraDSN
Definition: pcb_actions.h:423
static TOOL_ACTION trackWidthInc
Definition: pcb_actions.h:381
static TOOL_ACTION generateIPC2581File
Definition: pcb_actions.h:429
static TOOL_ACTION getAndPlace
Find an item and start moving.
Definition: pcb_actions.h:563
static TOOL_ACTION drawZoneCutout
Definition: pcb_actions.h:216
static TOOL_ACTION viaSizeDec
Definition: pcb_actions.h:384
static TOOL_ACTION zoneFill
Definition: pcb_actions.h:391
static TOOL_ACTION properties
Activation of the edit tool.
Definition: pcb_actions.h:174
static TOOL_ACTION editFpInFpEditor
Definition: pcb_actions.h:436
static TOOL_ACTION selectionClear
Clear the current selection.
Definition: pcb_actions.h:68
static TOOL_ACTION toggleLock
Definition: pcb_actions.h:515
static TOOL_ACTION drillResetOrigin
Definition: pcb_actions.h:531
static TOOL_ACTION viaSizeInc
Definition: pcb_actions.h:383
static TOOL_ACTION zoneUnfill
Definition: pcb_actions.h:394
static TOOL_ACTION generatePosFile
Definition: pcb_actions.h:427
static TOOL_ACTION drillOrigin
Definition: pcb_actions.h:530
static TOOL_ACTION assignNetClass
Definition: pcb_actions.h:388
static TOOL_ACTION repairBoard
Definition: pcb_actions.h:537
static TOOL_ACTION generateGerbers
Definition: pcb_actions.h:425
static TOOL_ACTION generateReportFile
Definition: pcb_actions.h:428
static TOOL_ACTION zoneDuplicate
Duplicate zone onto another layer.
Definition: pcb_actions.h:399
static TOOL_ACTION importNetlist
Definition: pcb_actions.h:420
static TOOL_ACTION drawSimilarZone
Definition: pcb_actions.h:217
static TOOL_ACTION boardSetup
Definition: pcb_actions.h:406
static TOOL_ACTION showEeschema
Definition: pcb_actions.h:534
static TOOL_ACTION zoneUnfillAll
Definition: pcb_actions.h:395
static TOOL_ACTION selectItem
Select an item (specified as the event parameter).
Definition: pcb_actions.h:71
static TOOL_ACTION selectNet
Select all connections belonging to a single net.
Definition: pcb_actions.h:96
static TOOL_ACTION editLibFpInFpEditor
Definition: pcb_actions.h:437
static TOOL_ACTION zoneMerge
Definition: pcb_actions.h:396
static TOOL_ACTION unlock
Definition: pcb_actions.h:517
static TOOL_ACTION placeFootprint
Definition: pcb_actions.h:220
static TOOL_ACTION showPythonConsole
Definition: pcb_actions.h:440
static TOOL_ACTION importSpecctraSession
Definition: pcb_actions.h:422
static TOOL_ACTION selectOnSchematic
Select symbols/pins on schematic corresponding to selected footprints/pads.
Definition: pcb_actions.h:114
static TOOL_ACTION lock
Definition: pcb_actions.h:516
Common, abstract interface for edit frames.
void SaveCopyInUndoList(EDA_ITEM *aItemToCopy, UNDO_REDO aTypeCommand) override
Create a new entry in undo list of commands.
Definition: undo_redo.cpp:162
void ClearListAndDeleteItems(PICKED_ITEMS_LIST *aList)
Definition: undo_redo.cpp:527
void RollbackFromUndo()
Perform an undo of the last edit without logging a corresponding redo.
Definition: undo_redo.cpp:543
void PutDataInPreviousState(PICKED_ITEMS_LIST *aList)
Used in undo or redo command.
Definition: undo_redo.cpp:257
Base PCB main window class for Pcbnew, Gerbview, and CvPcb footprint viewer.
PCBNEW_SETTINGS * GetPcbNewSettings() const
void OnModify() override
Must be called after a change in order to set the "modify" flag and update other data structures and ...
FOOTPRINT * SelectFootprintFromLibrary(LIB_ID aPreselect=LIB_ID())
Open a dialog to select a footprint.
PCB_DRAW_PANEL_GAL * GetCanvas() const override
Return a pointer to GAL-based canvas of given EDA draw frame.
BOARD * GetBoard() const
virtual BOARD_DESIGN_SETTINGS & GetDesignSettings() const
Returns the BOARD_DESIGN_SETTINGS for the open project.
virtual void Update3DView(bool aMarkDirty, bool aRefresh, const wxString *aTitle=nullptr)
Update the 3D view, if the viewer is opened by this frame.
virtual KIGFX::PCB_VIEW * GetView() const override
Return a pointer to the #VIEW instance used in the panel.
void SetLastPath(LAST_PATH_TYPE aType, const wxString &aLastPath)
Set the path of the last file successfully read.
void FindNext(bool reverse=false)
Find the next item using our existing search parameters.
TOOL_ACTION * GetExportNetlistAction()
void GenIPC2581File(wxCommandEvent &event)
Create and IPC2581 output file.
void OnModify() override
Must be called after a board change to set the modified flag.
void RecreateBOMFileFromBoard(wxCommandEvent &aEvent)
Create a BOM file from the current loaded board.
void GenD356File(wxCommandEvent &event)
wxString GetLastPath(LAST_PATH_TYPE aType)
Get the last path for a particular type.
bool Files_io_from_id(int aId)
Read and write board files according to aId.
void ShowFindDialog()
Show the Find dialog.
bool FetchNetlistFromSchematic(NETLIST &aNetlist, const wxString &aAnnotateMessage)
void SendSelectItemsToSch(const std::deque< EDA_ITEM * > &aItems, EDA_ITEM *aFocusItem, bool aForce)
Send a message to the schematic editor to try to find schematic counterparts of specified PCB items a...
void GenFootprintsReport(wxCommandEvent &event)
Call DoGenFootprintsReport to create a footprint report file.
void ToPlotter(int aID)
Open a dialog frame to create plot and drill files relative to the current board.
A set of BOARD_ITEMs (i.e., without duplicates).
Definition: pcb_group.h:51
void SetLocked(bool aLocked) override
Definition: pcb_group.cpp:183
Generic tool for picking an item.
static bool HasUnlockedItems(const SELECTION &aSelection)
Test if any selected items are unlocked.
static bool HasLockedItems(const SELECTION &aSelection)
Test if any selected items are locked.
The selection tool: currently supports:
PCB_SELECTION & RequestSelection(CLIENT_SELECTION_FILTER aClientFilter, bool aConfirmLockedItems=false)
Return the current selection, filtered according to aClientFilter.
int ClearSelection(const TOOL_EVENT &aEvent)
PCB_SELECTION & GetSelection()
void SelectAllItemsOnNet(int aNetCode, bool aSelect=true)
Select all items with the given net code.
PCB_BASE_EDIT_FRAME * frame() const
KIGFX::VIEW_CONTROLS * controls() const
BOARD * board() const
PCB_DRAW_PANEL_GAL * canvas() const
const PCB_SELECTION & selection() const
FOOTPRINT * footprint() const
void SetWidth(int aWidth)
Definition: pcb_track.h:106
int GetWidth() const
Definition: pcb_track.h:107
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 SetClickHandler(CLICK_HANDLER aHandler)
Set a handler for mouse click event.
Definition: picker_tool.h:72
ROUTER_MODE Mode() const
Definition: pns_router.h:136
RouterState GetState() const
Definition: pns_router.h:138
ROUTER * Router() const
virtual const wxString GetProjectFullName() const
Return the full path and name of the project.
Definition: project.cpp:129
static bool NotEmpty(const SELECTION &aSelection)
Test if there are any items selected.
static bool ShowAlways(const SELECTION &aSelection)
The default condition function (always returns true).
static SELECTION_CONDITION OnlyTypes(std::vector< KICAD_T > aTypes)
Create a functor that tests if the selected items are only of given types.
T * FirstOfKind() const
Definition: selection.h:224
const std::deque< EDA_ITEM * > GetItems() const
Definition: selection.h:120
EDA_ITEM * GetLastAddedItem() const
Definition: selection.h:125
bool IsHover() const
Definition: selection.h:83
int Size() const
Returns the number of selected parts.
Definition: selection.h:115
void SetReferencePoint(const VECTOR2I &aP)
Definition: selection.cpp:179
bool Empty() const
Checks if there is anything selected.
Definition: selection.h:109
virtual void PopTool(const TOOL_EVENT &aEvent)
Pops a tool from the stack.
virtual void PushTool(const TOOL_EVENT &aEvent)
NB: the definition of "tool" is different at the user level.
bool ToolStackIsEmpty()
Definition: tools_holder.h:125
bool IsCurrentTool(const TOOL_ACTION &aAction) const
TOOL_EVENT MakeEvent() const
Return the event associated with the action (i.e.
KIGFX::VIEW_CONTROLS * getViewControls() const
Return the instance of VIEW_CONTROLS object used in the application.
Definition: tool_base.cpp:42
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:216
KIGFX::VIEW * getView() const
Returns the instance of #VIEW object used in the application.
Definition: tool_base.cpp:36
bool IsToolActive() const
Definition: tool_base.cpp:31
RESET_REASON
Determine the reason of reset for a tool.
Definition: tool_base.h:78
@ REDRAW
Full drawing refresh.
Definition: tool_base.h:83
@ MODEL_RELOAD
Model changes (the sheet for a schematic)
Definition: tool_base.h:80
@ GAL_SWITCH
Rendering engine changes.
Definition: tool_base.h:82
Generic, UI-independent tool event.
Definition: tool_event.h:167
bool HasPosition() const
Definition: tool_event.h:256
bool Matches(const TOOL_EVENT &aEvent) const
Test whether two events match in terms of category & action or command.
Definition: tool_event.h:384
const VECTOR2D Position() const
Returns the point where dragging has started.
Definition: tool_event.h:285
bool IsReactivate() const
Definition: tool_event.h:268
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).
TOOL_MENU & GetToolMenu()
TOOL_MENU m_menu
The functions below are not yet implemented - their interface may change.
TOOL_EVENT * Wait(const TOOL_EVENT_LIST &aEventList=TOOL_EVENT(TC_ANY, TA_ANY))
Suspend execution of the tool until an event specified in aEventList arrives.
void Activate()
Run the tool.
bool ProcessEvent(const TOOL_EVENT &aEvent)
Propagate an event to tools that requested events of matching type(s).
void PostEvent(const TOOL_EVENT &aEvent)
Put an event to the event queue to be processed at the end of event processing cycle.
bool RunAction(const std::string &aActionName, T aParam)
Run the specified action immediately, pausing the current action to run the new one.
Definition: tool_manager.h:145
void PrimeTool(const VECTOR2D &aPosition)
"Prime" a tool by sending a cursor left-click event with the mouse position set to the passed in posi...
bool PostAction(const std::string &aActionName, T aParam)
Run the specified action after the current action (coroutine) ends.
Definition: tool_manager.h:230
Manage a CONDITIONAL_MENU and some number of CONTEXT_MENUs as sub-menus.
Definition: tool_menu.h:43
CONDITIONAL_MENU & GetMenu()
Definition: tool_menu.cpp:44
void RegisterSubMenu(std::shared_ptr< ACTION_MENU > aSubMenu)
Store a submenu of this menu model.
Definition: tool_menu.cpp:50
void ShowContextMenu(SELECTION &aSelection)
Helper function to set and immediately show a CONDITIONAL_MENU in concert with the given SELECTION.
Definition: tool_menu.cpp:57
ACTION_MENU * create() const override
< Return an instance of this class. It has to be overridden in inheriting classes.
static bool IsZoneFillAction(const TOOL_EVENT *aEvent)
ZONE_SETTINGS handles zones parameters.
Definition: zone_settings.h:71
void ExportSetting(ZONE &aTarget, bool aFullExport=true) const
Function ExportSetting copy settings to a given zone.
Handle a list of polygons defining a copper zone.
Definition: zone.h:72
bool GetIsRuleArea() const
Accessors to parameters used in Rule Area zones:
Definition: zone.h:710
virtual LSET GetLayerSet() const override
Return a std::bitset of all layers on which the item physically resides.
Definition: zone.h:129
bool IsOnCopperLayer() const override
Definition: zone.cpp:255
unsigned GetAssignedPriority() const
Definition: zone.h:119
@ CHT_MODIFY
Definition: commit.h:44
void DisplayInfoMessage(wxWindow *aParent, const wxString &aMessage, const wxString &aExtraInfo)
Display an informational message box with aMessage.
Definition: confirm.cpp:332
void DisplayErrorMessage(wxWindow *aParent, const wxString &aText, const wxString &aExtraInfo)
Display an error message with aMessage.
Definition: confirm.cpp:305
This file is part of the common library.
int InvokeCopperZonesEditor(PCB_BASE_FRAME *aCaller, ZONE_SETTINGS *aSettings, CONVERT_SETTINGS *aConvertSettings)
Function InvokeCopperZonesEditor invokes up a modal dialog window for copper zone editing.
int InvokeNonCopperZonesEditor(PCB_BASE_FRAME *aParent, ZONE_SETTINGS *aSettings, CONVERT_SETTINGS *aConvertSettings)
Function InvokeNonCopperZonesEditor invokes up a modal dialog window for non-copper zone editing.
int InvokeRuleAreaEditor(PCB_BASE_FRAME *aCaller, ZONE_SETTINGS *aZoneSettings, CONVERT_SETTINGS *aConvertSettings)
Function InvokeRuleAreaEditor invokes up a modal dialog window for copper zone editing.
#define _(s)
static constexpr EDA_ANGLE ANGLE_0
Definition: eda_angle.h:435
#define IS_NEW
New item, just created.
@ FRAME_SCH
Definition: frame_type.h:34
@ FRAME_FOOTPRINT_EDITOR
Definition: frame_type.h:43
static const std::string SpecctraDsnFileExtension
static const std::string SpecctraSessionFileExtension
static wxString SpecctraSessionFileWildcard()
static wxString SpecctraDsnFileWildcard()
@ ID_NEW_BOARD
Definition: id.h:76
@ ID_SAVE_BOARD
Definition: id.h:77
@ ID_LOAD_FILE
Definition: id.h:75
@ ID_GEN_PLOT_GERBER
Definition: id.h:94
@ ID_GEN_PLOT
Definition: id.h:91
@ ID_SAVE_BOARD_AS
Definition: id.h:78
KIID niluuid(0)
@ MAIL_SCH_UPDATE
Definition: mail_type.h:47
@ REPAINT
Item needs to be redrawn.
Definition: view_item.h:57
@ GEOMETRY
Position or shape has changed.
Definition: view_item.h:54
@ PNS_MODE_ROUTE_DIFF_PAIR
Definition: pns_router.h:64
#define MAX_PAGE_SIZE_PCBNEW_MILS
Definition: page_info.h:39
@ ID_REVERT_BOARD
Definition: pcbnew_id.h:18
@ ID_COPY_BOARD_AS
Definition: pcbnew_id.h:17
see class PGM_BASE
@ LAST_PATH_SPECCTRADSN
Definition: project_file.h:53
KIWAY Kiway & Pgm(), KFCTL_STANDALONE
The global Program "get" accessor.
Definition: single_top.cpp:119
std::vector< FAB_LAYER_COLOR > dummy
wxString UnescapeString(const wxString &aSource)
const double IU_PER_MM
Definition: base_units.h:77
const double IU_PER_MILS
Definition: base_units.h:78
Container to handle a stock of specific vias each with unique diameter and drill sizes in the BOARD c...
@ FOOTPRINT_FIELD
Field Name Module PCB, i.e. "16DIP300".
@ BUT_LEFT
Definition: tool_event.h:131
@ BUT_RIGHT
Definition: tool_event.h:132
@ PCB_VIA_T
class PCB_VIA, a via (like a track segment on a copper layer)
Definition: typeinfo.h:97
@ PCB_ZONE_T
class ZONE, a copper pour area
Definition: typeinfo.h:107
VECTOR2< int > VECTOR2I
Definition: vector2d.h:588
wxString AddFileExtListToFilter(const std::vector< std::string > &aExts)
Build the wildcard extension file dialog wildcard filter to add to the base message dialog.
Definition of file extensions used in Kicad.