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 );
382 name += wxT( "." ) + wxString( FILEEXT::SpecctraSessionFileExtension );
383
384 fullFileName = wxFileSelector( _( "Specctra Session File" ), path, name,
385 wxT( "." ) + wxString( FILEEXT::SpecctraSessionFileExtension ),
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>()->ToggleNetInspector();
698 return 0;
699}
700
701
703{
704 getEditFrame<PCB_EDIT_FRAME>()->ToggleSearch();
705 return 0;
706}
707
708
710{
712 return 0;
713}
714
715
716// Track & via size control
718{
719 BOARD_DESIGN_SETTINGS& bds = getModel<BOARD>()->GetDesignSettings();
721
723 && SELECTION_CONDITIONS::OnlyTypes( { PCB_TRACE_T, PCB_ARC_T, PCB_VIA_T } )( selection ) )
724 {
725 BOARD_COMMIT commit( this );
726
727 for( EDA_ITEM* item : selection )
728 {
729 if( item->IsType( { PCB_TRACE_T, PCB_ARC_T } ) )
730 {
731 PCB_TRACK* track = static_cast<PCB_TRACK*>( item );
732
733 for( int i = 0; i < (int) bds.m_TrackWidthList.size(); ++i )
734 {
735 int candidate = bds.m_NetSettings->m_DefaultNetClass->GetTrackWidth();
736
737 if( i > 0 )
738 candidate = bds.m_TrackWidthList[ i ];
739
740 if( candidate > track->GetWidth() )
741 {
742 commit.Modify( track );
743 track->SetWidth( candidate );
744 break;
745 }
746 }
747 }
748 }
749
750 commit.Push( wxT( "Increase Track Width" ) );
751 return 0;
752 }
753
754 ROUTER_TOOL* routerTool = m_toolMgr->GetTool<ROUTER_TOOL>();
755
756 if( routerTool && routerTool->IsToolActive()
757 && routerTool->Router()->Mode() == PNS::PNS_MODE_ROUTE_DIFF_PAIR )
758 {
759 int widthIndex = (int) bds.GetDiffPairIndex() + 1;
760
761 // If we go past the last track width entry in the list, start over at the beginning
762 if( widthIndex >= (int) bds.m_DiffPairDimensionsList.size() )
763 widthIndex = 0;
764
765 bds.SetDiffPairIndex( widthIndex );
766 bds.UseCustomDiffPairDimensions( false );
767
769 }
770 else
771 {
772 int widthIndex = (int) bds.GetTrackWidthIndex();
773
774 if( routerTool && routerTool->IsToolActive()
777 {
778 bds.m_TempOverrideTrackWidth = true;
779 }
780 else
781 {
782 widthIndex++;
783 }
784
785 // If we go past the last track width entry in the list, start over at the beginning
786 if( widthIndex >= (int) bds.m_TrackWidthList.size() )
787 widthIndex = 0;
788
789 bds.SetTrackWidthIndex( widthIndex );
790 bds.UseCustomTrackViaSize( false );
791
793 }
794
795 return 0;
796}
797
798
800{
801 BOARD_DESIGN_SETTINGS& bds = getModel<BOARD>()->GetDesignSettings();
803
805 && SELECTION_CONDITIONS::OnlyTypes( { PCB_TRACE_T, PCB_ARC_T, PCB_VIA_T } )( selection ) )
806 {
807 BOARD_COMMIT commit( this );
808
809 for( EDA_ITEM* item : selection )
810 {
811 if( item->IsType( { PCB_TRACE_T, PCB_ARC_T } ) )
812 {
813 PCB_TRACK* track = static_cast<PCB_TRACK*>( item );
814
815 for( int i = (int) bds.m_TrackWidthList.size() - 1; i >= 0; --i )
816 {
817 int candidate = bds.m_NetSettings->m_DefaultNetClass->GetTrackWidth();
818
819 if( i > 0 )
820 candidate = bds.m_TrackWidthList[ i ];
821
822 if( candidate < track->GetWidth() )
823 {
824 commit.Modify( track );
825 track->SetWidth( candidate );
826 break;
827 }
828 }
829 }
830 }
831
832 commit.Push( wxT( "Decrease Track Width" ) );
833 return 0;
834 }
835
836 ROUTER_TOOL* routerTool = m_toolMgr->GetTool<ROUTER_TOOL>();
837
838 if( routerTool && routerTool->IsToolActive()
839 && routerTool->Router()->Mode() == PNS::PNS_MODE_ROUTE_DIFF_PAIR )
840 {
841 int widthIndex = (int) bds.GetDiffPairIndex() - 1;
842
843 // If we get to the lowest entry start over at the highest
844 if( widthIndex < 0 )
845 widthIndex = (int) bds.m_DiffPairDimensionsList.size() - 1;
846
847 bds.SetDiffPairIndex( widthIndex );
848 bds.UseCustomDiffPairDimensions( false );
849
851 }
852 else
853 {
854 int widthIndex = (int) bds.GetTrackWidthIndex();
855
856 if( routerTool && routerTool->IsToolActive()
859 {
860 bds.m_TempOverrideTrackWidth = true;
861 }
862 else
863 {
864 widthIndex--;
865 }
866
867 // If we get to the lowest entry start over at the highest
868 if( widthIndex < 0 )
869 widthIndex = (int) bds.m_TrackWidthList.size() - 1;
870
871 bds.SetTrackWidthIndex( widthIndex );
872 bds.UseCustomTrackViaSize( false );
873
875 }
876
877 return 0;
878}
879
880
882{
883 BOARD_DESIGN_SETTINGS& bds = getModel<BOARD>()->GetDesignSettings();
885
887 && SELECTION_CONDITIONS::OnlyTypes( { PCB_TRACE_T, PCB_ARC_T, PCB_VIA_T } )( selection ) )
888 {
889 BOARD_COMMIT commit( this );
890
891 for( EDA_ITEM* item : selection )
892 {
893 if( item->Type() == PCB_VIA_T )
894 {
895 PCB_VIA* via = static_cast<PCB_VIA*>( item );
896
897 for( int i = 0; i < (int) bds.m_ViasDimensionsList.size(); ++i )
898 {
899 VIA_DIMENSION dims( bds.m_NetSettings->m_DefaultNetClass->GetViaDiameter(),
900 bds.m_NetSettings->m_DefaultNetClass->GetViaDrill() );
901
902 if( i> 0 )
903 dims = bds.m_ViasDimensionsList[ i ];
904
905 if( dims.m_Diameter > via->GetWidth() )
906 {
907 commit.Modify( via );
908 via->SetWidth( dims.m_Diameter );
909 via->SetDrill( dims.m_Drill );
910 break;
911 }
912 }
913 }
914 }
915
916 commit.Push( wxT( "Increase Via Size" ) );
917 }
918 else
919 {
920 int sizeIndex = (int) bds.GetViaSizeIndex() + 1;
921
922 // If we go past the last via entry in the list, start over at the beginning
923 if( sizeIndex >= (int) bds.m_ViasDimensionsList.size() )
924 sizeIndex = 0;
925
926 bds.SetViaSizeIndex( sizeIndex );
927 bds.UseCustomTrackViaSize( false );
928
930 }
931
932 return 0;
933}
934
935
937{
938 BOARD_DESIGN_SETTINGS& bds = getModel<BOARD>()->GetDesignSettings();
940
942 && SELECTION_CONDITIONS::OnlyTypes( { PCB_TRACE_T, PCB_ARC_T, PCB_VIA_T } )( selection ) )
943 {
944 BOARD_COMMIT commit( this );
945
946 for( EDA_ITEM* item : selection )
947 {
948 if( item->Type() == PCB_VIA_T )
949 {
950 PCB_VIA* via = static_cast<PCB_VIA*>( item );
951
952 for( int i = (int) bds.m_ViasDimensionsList.size() - 1; i >= 0; --i )
953 {
954 VIA_DIMENSION dims( bds.m_NetSettings->m_DefaultNetClass->GetViaDiameter(),
955 bds.m_NetSettings->m_DefaultNetClass->GetViaDrill() );
956
957 if( i > 0 )
958 dims = bds.m_ViasDimensionsList[ i ];
959
960 if( dims.m_Diameter < via->GetWidth() )
961 {
962 commit.Modify( via );
963 via->SetWidth( dims.m_Diameter );
964 via->SetDrill( dims.m_Drill );
965 break;
966 }
967 }
968 }
969 }
970
971 commit.Push( "Decrease Via Size" );
972 }
973 else
974 {
975 int sizeIndex = 0; // Assume we only have a single via size entry
976
977 // If there are more, cycle through them backwards
978 if( bds.m_ViasDimensionsList.size() > 0 )
979 {
980 sizeIndex = (int) bds.GetViaSizeIndex() - 1;
981
982 // If we get to the lowest entry start over at the highest
983 if( sizeIndex < 0 )
984 sizeIndex = (int) bds.m_ViasDimensionsList.size() - 1;
985 }
986
987 bds.SetViaSizeIndex( sizeIndex );
988 bds.UseCustomTrackViaSize( false );
989
991 }
992
993 return 0;
994}
995
996
998{
1000 return 0;
1001
1003
1004 FOOTPRINT* fp = aEvent.Parameter<FOOTPRINT*>();
1005 bool fromOtherCommand = fp != nullptr;
1007 BOARD_COMMIT commit( m_frame );
1008 BOARD* board = getModel<BOARD>();
1009 COMMON_SETTINGS* common_settings = Pgm().GetCommonSettings();
1010
1012
1013 m_frame->PushTool( aEvent );
1014
1015 auto setCursor =
1016 [&]()
1017 {
1018 m_frame->GetCanvas()->SetCurrentCursor( KICURSOR::PENCIL );
1019 };
1020
1021 auto cleanup =
1022 [&] ()
1023 {
1025 commit.Revert();
1026
1027 if( fromOtherCommand )
1028 {
1030
1031 if( undo )
1032 {
1035 delete undo;
1036 }
1037 }
1038
1039 fp = nullptr;
1040 m_placingFootprint = false;
1041 };
1042
1043 Activate();
1044 // Must be done after Activate() so that it gets set into the correct context
1045 controls->ShowCursor( true );
1046 // Set initial cursor
1047 setCursor();
1048
1049 VECTOR2I cursorPos = controls->GetCursorPosition();
1050 bool ignorePrimePosition = false;
1051 bool reselect = false;
1052
1053 // Prime the pump
1054 if( fp )
1055 {
1056 m_placingFootprint = true;
1057 fp->SetPosition( cursorPos );
1060 }
1061 else if( aEvent.HasPosition() )
1062 {
1063 m_toolMgr->PrimeTool( aEvent.Position() );
1064 }
1065 else if( common_settings->m_Input.immediate_actions && !aEvent.IsReactivate() )
1066 {
1067 m_toolMgr->PrimeTool( { 0, 0 } );
1068 ignorePrimePosition = true;
1069 }
1070
1071 // Main loop: keep receiving events
1072 while( TOOL_EVENT* evt = Wait() )
1073 {
1074 setCursor();
1075 cursorPos = controls->GetCursorPosition( !evt->DisableGridSnapping() );
1076
1077 if( reselect && fp )
1079
1080 if( evt->IsCancelInteractive() || ( fp && evt->IsAction( &ACTIONS::undo ) ) )
1081 {
1082 if( fp )
1083 {
1084 cleanup();
1085 }
1086 else
1087 {
1088 m_frame->PopTool( aEvent );
1089 break;
1090 }
1091 }
1092 else if( evt->IsActivate() )
1093 {
1094 if( fp )
1095 cleanup();
1096
1097 if( evt->IsMoveTool() )
1098 {
1099 // leave ourselves on the stack so we come back after the move
1100 break;
1101 }
1102 else
1103 {
1104 frame()->PopTool( aEvent );
1105 break;
1106 }
1107 }
1108 else if( evt->IsClick( BUT_LEFT ) )
1109 {
1110 if( !fp )
1111 {
1112 // Pick the footprint to be placed
1114
1115 if( fp == nullptr )
1116 continue;
1117
1118 // If we started with a hotkey which has a position then warp back to that.
1119 // Otherwise update to the current mouse position pinned inside the autoscroll
1120 // boundaries.
1121 if( evt->IsPrime() && !ignorePrimePosition )
1122 {
1123 cursorPos = evt->Position();
1124 getViewControls()->WarpMouseCursor( cursorPos, true );
1125 }
1126 else
1127 {
1129 cursorPos = getViewControls()->GetMousePosition();
1130 }
1131
1132 m_placingFootprint = true;
1133
1134 fp->SetLink( niluuid );
1135
1136 fp->SetFlags( IS_NEW ); // whatever
1137
1138 // Set parent so that clearance can be loaded
1139 fp->SetParent( board );
1141
1142 for( PAD* pad : fp->Pads() )
1143 {
1144 pad->SetLocalRatsnestVisible( m_frame->GetPcbNewSettings()->m_Display.m_ShowGlobalRatsnest );
1145
1146 // Pads in the library all have orphaned nets. Replace with Default.
1147 pad->SetNetCode( 0 );
1148 }
1149
1150 // Put it on FRONT layer,
1151 // (Can be stored flipped if the lib is an archive built from a board)
1152 if( fp->IsFlipped() )
1154
1155 fp->SetOrientation( ANGLE_0 );
1156 fp->SetPosition( cursorPos );
1157
1158 // Fill this in since it won't be synced from a symbol
1160
1161 commit.Add( fp );
1163
1165 }
1166 else
1167 {
1169 commit.Push( _( "Place a Footprint" ) );
1170 fp = nullptr; // to indicate that there is no footprint that we currently modify
1171 m_placingFootprint = false;
1172 }
1173 }
1174 else if( evt->IsClick( BUT_RIGHT ) )
1175 {
1177 }
1178 else if( fp && ( evt->IsMotion() || evt->IsAction( &ACTIONS::refreshPreview ) ) )
1179 {
1180 fp->SetPosition( cursorPos );
1181 selection().SetReferencePoint( cursorPos );
1182 getView()->Update( &selection() );
1183 getView()->Update( fp );
1184 }
1185 else if( fp && evt->IsAction( &PCB_ACTIONS::properties ) )
1186 {
1187 // Calling 'Properties' action clears the selection, so we need to restore it
1188 reselect = true;
1189 }
1190 else if( fp && ( ZONE_FILLER_TOOL::IsZoneFillAction( evt )
1191 || evt->IsAction( &ACTIONS::redo ) ) )
1192 {
1193 wxBell();
1194 }
1195 else
1196 {
1197 evt->SetPassEvent();
1198 }
1199
1200 // Enable autopanning and cursor capture only when there is a footprint to be placed
1201 controls->SetAutoPan( fp != nullptr );
1202 controls->CaptureCursor( fp != nullptr );
1203 }
1204
1205 controls->SetAutoPan( false );
1206 controls->CaptureCursor( false );
1207 m_frame->GetCanvas()->SetCurrentCursor( KICURSOR::ARROW );
1208
1209 return 0;
1210}
1211
1212
1214{
1215 return modifyLockSelected( TOGGLE );
1216}
1217
1218
1220{
1221 return modifyLockSelected( ON );
1222}
1223
1224
1226{
1227 return modifyLockSelected( OFF );
1228}
1229
1230
1232{
1234 const PCB_SELECTION& selection = selTool->GetSelection();
1235 BOARD_COMMIT commit( m_frame );
1236
1237 if( selection.Empty() )
1239
1240 // Resolve TOGGLE mode
1241 if( aMode == TOGGLE )
1242 {
1243 aMode = ON;
1244
1245 for( EDA_ITEM* item : selection )
1246 {
1247 BOARD_ITEM* board_item = dynamic_cast<BOARD_ITEM*>( item );
1248
1249 if( board_item && board_item->IsLocked() )
1250 {
1251 aMode = OFF;
1252 break;
1253 }
1254 }
1255 }
1256
1257 for( EDA_ITEM* item : selection )
1258 {
1259 BOARD_ITEM* board_item = dynamic_cast<BOARD_ITEM*>( item );
1260 wxCHECK2( board_item, continue );
1261
1262 PCB_GENERATOR* generator = dynamic_cast<PCB_GENERATOR*>( board_item->GetParentGroup() );
1263
1264 if( generator && commit.GetStatus( generator ) != CHT_MODIFY )
1265 {
1266 commit.Modify( generator );
1267
1268 if( aMode == ON )
1269 generator->SetLocked( true );
1270 else
1271 generator->SetLocked( false );
1272 }
1273
1274 commit.Modify( board_item );
1275
1276 if( aMode == ON )
1277 board_item->SetLocked( true );
1278 else
1279 board_item->SetLocked( false );
1280 }
1281
1282 if( !commit.Empty() )
1283 {
1284 commit.Push( aMode == ON ? _( "Lock" ) : _( "Unlock" ) );
1285
1287 m_frame->OnModify();
1288 }
1289
1290 return 0;
1291}
1292
1293
1294static bool mergeZones( EDA_DRAW_FRAME* aFrame, BOARD_COMMIT& aCommit,
1295 std::vector<ZONE*>& aOriginZones, std::vector<ZONE*>& aMergedZones )
1296{
1297 aCommit.Modify( aOriginZones[0] );
1298
1299 for( unsigned int i = 1; i < aOriginZones.size(); i++ )
1300 {
1301 aOriginZones[0]->Outline()->BooleanAdd( *aOriginZones[i]->Outline(),
1303 }
1304
1305 aOriginZones[0]->Outline()->Simplify( SHAPE_POLY_SET::PM_FAST );
1306
1307 // We should have one polygon, possibly with holes. If we end up with two polygons (either
1308 // because the intersection was a single point or because the intersection was within one of
1309 // the zone's holes) then we can't merge.
1310 if( aOriginZones[0]->Outline()->IsSelfIntersecting()
1311 || aOriginZones[0]->Outline()->OutlineCount() > 1 )
1312 {
1313 DisplayErrorMessage( aFrame, _( "Zones have insufficient overlap for merging." ) );
1314 aCommit.Revert();
1315 return false;
1316 }
1317
1318 for( unsigned int i = 1; i < aOriginZones.size(); i++ )
1319 aCommit.Remove( aOriginZones[i] );
1320
1321 aMergedZones.push_back( aOriginZones[0] );
1322
1323 aOriginZones[0]->SetLocalFlags( 1 );
1324 aOriginZones[0]->HatchBorder();
1325 aOriginZones[0]->CacheTriangulation();
1326
1327 return true;
1328}
1329
1330
1332{
1333 const PCB_SELECTION& selection = m_toolMgr->GetTool<PCB_SELECTION_TOOL>()->GetSelection();
1334 BOARD* board = getModel<BOARD>();
1335 BOARD_COMMIT commit( m_frame );
1336
1337 if( selection.Size() < 2 )
1338 return 0;
1339
1340 int netcode = -1;
1341
1342 ZONE* firstZone = nullptr;
1343 std::vector<ZONE*> toMerge, merged;
1344
1345 for( EDA_ITEM* item : selection )
1346 {
1347 ZONE* curr_area = dynamic_cast<ZONE*>( item );
1348
1349 if( !curr_area )
1350 continue;
1351
1352 if( !firstZone )
1353 firstZone = curr_area;
1354
1355 netcode = curr_area->GetNetCode();
1356
1357 if( firstZone->GetNetCode() != netcode )
1358 {
1359 wxLogMessage( _( "Some zone netcodes did not match and were not merged." ) );
1360 continue;
1361 }
1362
1363 if( curr_area->GetAssignedPriority() != firstZone->GetAssignedPriority() )
1364 {
1365 wxLogMessage( _( "Some zone priorities did not match and were not merged." ) );
1366 continue;
1367 }
1368
1369 if( curr_area->GetIsRuleArea() != firstZone->GetIsRuleArea() )
1370 {
1371 wxLogMessage( _( "Some zones were rule areas and were not merged." ) );
1372 continue;
1373 }
1374
1375 if( curr_area->GetLayerSet() != firstZone->GetLayerSet() )
1376 {
1377 wxLogMessage( _( "Some zone layer sets did not match and were not merged." ) );
1378 continue;
1379 }
1380
1381 bool intersects = curr_area == firstZone;
1382
1383 for( ZONE* candidate : toMerge )
1384 {
1385 if( intersects )
1386 break;
1387
1388 if( board->TestZoneIntersection( curr_area, candidate ) )
1389 intersects = true;
1390 }
1391
1392 if( !intersects )
1393 {
1394 wxLogMessage( _( "Some zones did not intersect and were not merged." ) );
1395 continue;
1396 }
1397
1398 toMerge.push_back( curr_area );
1399 }
1400
1402
1403 if( !toMerge.empty() )
1404 {
1405 if( mergeZones( m_frame, commit, toMerge, merged ) )
1406 {
1407 commit.Push( wxT( "Merge Zones" ) );
1408
1409 for( EDA_ITEM* item : merged )
1411 }
1412 }
1413
1414 return 0;
1415}
1416
1417
1419{
1421 const PCB_SELECTION& selection = selTool->GetSelection();
1422
1423 // because this pops up the zone editor, it would be confusing to handle multiple zones,
1424 // so just handle single selections containing exactly one zone
1425 if( selection.Size() != 1 )
1426 return 0;
1427
1428 ZONE* oldZone = dynamic_cast<ZONE*>( selection[0] );
1429
1430 if( !oldZone )
1431 return 0;
1432
1433 ZONE_SETTINGS zoneSettings;
1434 zoneSettings << *oldZone;
1435 int dialogResult;
1436
1437 if( oldZone->GetIsRuleArea() )
1438 dialogResult = InvokeRuleAreaEditor( m_frame, &zoneSettings );
1439 else if( oldZone->IsOnCopperLayer() )
1440 dialogResult = InvokeCopperZonesEditor( m_frame, &zoneSettings );
1441 else
1442 dialogResult = InvokeNonCopperZonesEditor( m_frame, &zoneSettings );
1443
1444 if( dialogResult != wxID_OK )
1445 return 0;
1446
1447 // duplicate the zone
1448 BOARD_COMMIT commit( m_frame );
1449
1450 std::unique_ptr<ZONE> newZone = std::make_unique<ZONE>( *oldZone );
1451 newZone->ClearSelected();
1452 newZone->UnFill();
1453 zoneSettings.ExportSetting( *newZone );
1454
1455 // If the new zone is on the same layer(s) as the initial zone,
1456 // offset it a bit so it can more easily be picked.
1457 if( oldZone->GetLayerSet() == zoneSettings.m_Layers )
1458 newZone->Move( VECTOR2I( pcbIUScale.IU_PER_MM, pcbIUScale.IU_PER_MM ) );
1459
1460 commit.Add( newZone.release() );
1461 commit.Push( _( "Duplicate Zone" ) );
1462
1463 return 0;
1464}
1465
1466
1468{
1469 doCrossProbePcbToSch( aEvent, false );
1470 return 0;
1471}
1472
1473
1475{
1476 doCrossProbePcbToSch( aEvent, true );
1477 return 0;
1478}
1479
1480
1482{
1483 // Don't get in an infinite loop PCB -> SCH -> PCB -> SCH -> ...
1485 return;
1486
1488 const PCB_SELECTION& selection = selTool->GetSelection();
1489 EDA_ITEM* focusItem = nullptr;
1490
1491 if( aEvent.Matches( EVENTS::PointSelectedEvent ) )
1492 focusItem = selection.GetLastAddedItem();
1493
1494 m_frame->SendSelectItemsToSch( selection.GetItems(), focusItem, aForce );
1495
1496 // Update 3D viewer highlighting
1498}
1499
1500
1502{
1504
1505 const PCB_SELECTION& selection = selectionTool->RequestSelection(
1506 []( const VECTOR2I& aPt, GENERAL_COLLECTOR& aCollector, PCB_SELECTION_TOOL* sTool )
1507 {
1508 // Iterate from the back so we don't have to worry about removals.
1509 for( int i = aCollector.GetCount() - 1; i >= 0; --i )
1510 {
1511 if( !dynamic_cast<BOARD_CONNECTED_ITEM*>( aCollector[ i ] ) )
1512 aCollector.Remove( aCollector[ i ] );
1513 }
1514 },
1515 true /* prompt user regarding locked items */ );
1516
1517 int netCode = -1;
1518 wxString netName;
1519
1520 for( EDA_ITEM* item : selection )
1521 {
1522 NETINFO_ITEM* net = static_cast<BOARD_CONNECTED_ITEM*>( item )->GetNet();
1523
1524 if( !net->HasAutoGeneratedNetname() )
1525 {
1526 netCode = net->GetNetCode();
1527 netName = net->GetNetname();
1528 break;
1529 }
1530 }
1531
1532 if( netName.IsEmpty() )
1533 {
1534 m_frame->ShowInfoBarError( _( "Selection contains no items with labeled nets." ) );
1535 return 0;
1536 }
1537
1538 selectionTool->ClearSelection();
1540 canvas()->ForceRefresh();
1541
1542 DIALOG_ASSIGN_NETCLASS dlg( m_frame, netName, board()->GetNetClassAssignmentCandidates(),
1543 [this]( const std::vector<wxString>& aNetNames )
1544 {
1546 selTool->ClearSelection();
1547
1548 for( const wxString& curr_netName : aNetNames )
1549 {
1550 int curr_netCode = board()->GetNetInfo().GetNetItem( curr_netName )->GetNetCode();
1551
1552 if( curr_netCode > 0 )
1553 selTool->SelectAllItemsOnNet( curr_netCode );
1554 }
1555
1556 canvas()->ForceRefresh();
1558 } );
1559
1560 if( dlg.ShowModal() == wxID_OK )
1561 {
1563 // Refresh UI that depends on netclasses, such as the properties panel
1565 }
1566
1567 return 0;
1568}
1569
1570
1572{
1575
1576 if( selection.Empty() )
1577 {
1578 // Giant hack: by default we assign Edit Table to the same hotkey, so give the table
1579 // tool a chance to handle it if we can't.
1581 tableTool->EditTable( aEvent );
1582
1583 return 0;
1584 }
1585
1587
1588 if( !fp )
1589 return 0;
1590
1591 PCB_BASE_EDIT_FRAME* editFrame = getEditFrame<PCB_BASE_EDIT_FRAME>();
1592
1593 auto editor = (FOOTPRINT_EDIT_FRAME*) editFrame->Kiway().Player( FRAME_FOOTPRINT_EDITOR, true );
1594
1596 editor->LoadFootprintFromBoard( fp );
1597 else if( aEvent.IsAction( &PCB_ACTIONS::editLibFpInFpEditor ) )
1598 editor->LoadFootprintFromLibrary( fp->GetFPID() );
1599
1600 editor->Show( true );
1601 editor->Raise(); // Iconize( false );
1602
1603 if( selection.IsHover() )
1605
1606 return 0;
1607}
1608
1609
1611 EDA_ITEM* originViewItem, const VECTOR2D& aPosition )
1612{
1613 aFrame->GetDesignSettings().SetAuxOrigin( VECTOR2I( aPosition ) );
1614 originViewItem->SetPosition( aPosition );
1615 aView->MarkDirty();
1616 aFrame->OnModify();
1617}
1618
1619
1621{
1623 {
1624 m_frame->SaveCopyInUndoList( m_placeOrigin.get(), UNDO_REDO::GRIDORIGIN );
1626 return 0;
1627 }
1628
1630
1631 // Deactivate other tools; particularly important if another PICKER is currently running
1632 Activate();
1633
1634 picker->SetClickHandler(
1635 [this] ( const VECTOR2D& pt ) -> bool
1636 {
1637 m_frame->SaveCopyInUndoList( m_placeOrigin.get(), UNDO_REDO::DRILLORIGIN );
1639 return false; // drill origin is a one-shot; don't continue with tool
1640 } );
1641
1643
1644 return 0;
1645}
1646
1647
1649{
1658
1663
1668
1669 if( ADVANCED_CFG::GetCfg().m_ShowPcbnewExportNetlist && m_frame &&
1672
1680
1681 // Track & via size control
1686
1687 // Zone actions
1690
1691 // Placing tools
1695
1698
1699 // Cross-select
1705
1706 // Other
1710
1712
1722}
1723
1724
1725const int BOARD_EDITOR_CONTROL::WIDTH_STEP = 100000;
const char * name
Definition: DXF_plotter.cpp:57
constexpr EDA_IU_SCALE pcbIUScale
Definition: base_units.h:108
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 ToggleNetInspector(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:281
const NETINFO_LIST & GetNetInfo() const
Definition: board.h:850
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_MODE::INSERT, bool aSkipConnectivity=false) override
Removes an item from the container.
Definition: board.cpp:882
void UpdateUserUnits(BOARD_ITEM *aItem, KIGFX::VIEW *aView)
Update any references within aItem (or its descendants) to the user units.
Definition: board.cpp:1213
NETINFO_ITEM * FindNet(int aNetcode) const
Search for a net with the given netcode.
Definition: board.cpp:1804
void SynchronizeNetsAndNetClasses(bool aResetTrackAndViaSizes)
Copy NETCLASS info to each NET, based on NET membership in a NETCLASS.
Definition: board.cpp:1937
const wxString & GetFileName() const
Definition: board.h:318
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:88
virtual void SetPosition(const VECTOR2I &aPos)
Definition: eda_item.h:243
void SetFlags(EDA_ITEM_FLAGS aMask)
Definition: eda_item.h:126
virtual void SetParent(EDA_ITEM *aParent)
Definition: eda_item.h:103
A mix-in class (via multiple inheritance) that handles texts such as labels, parts,...
Definition: eda_text.h:83
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:2788
static const TOOL_EVENT ClearedEvent
Definition: actions.h:262
static const TOOL_EVENT SelectedEvent
Definition: actions.h:260
static const TOOL_EVENT SelectedItemsModified
Selected items were moved, this can be very high frequency on the canvas, use with care.
Definition: actions.h:267
static const TOOL_EVENT PointSelectedEvent
Definition: actions.h:259
static const TOOL_EVENT UnselectedEvent
Definition: actions.h:261
Used for text file output.
Definition: richio.h:475
void SetPosition(const VECTOR2I &aPos) override
Definition: footprint.cpp:2300
void SetLink(const KIID &aLink)
Definition: footprint.h:836
ZONES & Zones()
Definition: footprint.h:197
void SetOrientation(const EDA_ANGLE &aNewAngle)
Definition: footprint.cpp:2372
PCB_FIELD & Value()
read/write accessors:
Definition: footprint.h:624
wxString GetFPIDAsString() const
Definition: footprint.h:240
bool IsFlipped() const
Definition: footprint.h:377
PADS & Pads()
Definition: footprint.h:191
const LIB_ID & GetFPID() const
Definition: footprint.h:233
PCB_FIELD & Reference()
Definition: footprint.h:625
GROUPS & Groups()
Definition: footprint.h:200
PCB_FIELDS & Fields()
Definition: footprint.h:188
void Flip(const VECTOR2I &aCentre, bool aFlipLeftRight) override
Flip this object, i.e.
Definition: footprint.cpp:2240
const wxString & GetValue() const
Definition: footprint.h:610
const wxString & GetReference() const
Definition: footprint.h:588
PCB_FIELD * GetField(MANDATORY_FIELD_T aFieldType)
Return a mandatory field in this symbol.
Definition: footprint.cpp:505
const KIID_PATH & GetPath() const
Definition: footprint.h:249
VECTOR2I GetPosition() const override
Definition: footprint.h:209
DRAWINGS & GraphicalItems()
Definition: footprint.h:194
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:1639
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:1531
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:55
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:406
wxWindow * GetBlockingDialog()
Gets the window pointer to the blocking dialog (to send it signals)
Definition: kiway.cpp:669
virtual void ExpressMail(FRAME_T aDestination, MAIL_T aCommand, std::string &aPayload, wxWindow *aSource=nullptr)
Send aPayload to aDestination from aSource.
Definition: kiway.cpp:527
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:430
static TOOL_ACTION zoneFillAll
Definition: pcb_actions.h:392
static TOOL_ACTION showLayersManager
Definition: pcb_actions.h:437
static TOOL_ACTION trackWidthDec
Definition: pcb_actions.h:382
static TOOL_ACTION generateDrillFiles
Definition: pcb_actions.h:425
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:429
static TOOL_ACTION trackViaSizeChanged
Definition: pcb_actions.h:386
static TOOL_ACTION exportSpecctraDSN
Definition: pcb_actions.h:422
static TOOL_ACTION trackWidthInc
Definition: pcb_actions.h:381
static TOOL_ACTION generateIPC2581File
Definition: pcb_actions.h:428
static TOOL_ACTION getAndPlace
Find an item and start moving.
Definition: pcb_actions.h:562
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:434
static TOOL_ACTION selectionClear
Clear the current selection.
Definition: pcb_actions.h:68
static TOOL_ACTION toggleLock
Definition: pcb_actions.h:514
static TOOL_ACTION drillResetOrigin
Definition: pcb_actions.h:530
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:426
static TOOL_ACTION drillOrigin
Definition: pcb_actions.h:529
static TOOL_ACTION assignNetClass
Definition: pcb_actions.h:388
static TOOL_ACTION repairBoard
Definition: pcb_actions.h:536
static TOOL_ACTION showNetInspector
Definition: pcb_actions.h:438
static TOOL_ACTION generateGerbers
Definition: pcb_actions.h:424
static TOOL_ACTION generateReportFile
Definition: pcb_actions.h:427
static TOOL_ACTION zoneDuplicate
Duplicate zone onto another layer.
Definition: pcb_actions.h:399
static TOOL_ACTION importNetlist
Definition: pcb_actions.h:419
static TOOL_ACTION drawSimilarZone
Definition: pcb_actions.h:217
static TOOL_ACTION boardSetup
Definition: pcb_actions.h:405
static TOOL_ACTION showEeschema
Definition: pcb_actions.h:533
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:435
static TOOL_ACTION zoneMerge
Definition: pcb_actions.h:396
static TOOL_ACTION unlock
Definition: pcb_actions.h:516
static TOOL_ACTION placeFootprint
Definition: pcb_actions.h:220
static TOOL_ACTION showPythonConsole
Definition: pcb_actions.h:439
static TOOL_ACTION importSpecctraSession
Definition: pcb_actions.h:421
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:515
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:636
void RollbackFromUndo()
Perform an undo of the last edit without logging a corresponding redo.
Definition: undo_redo.cpp:652
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
virtual COMMON_SETTINGS * GetCommonSettings() const
Definition: pgm_base.cpp:678
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
PGM_BASE & Pgm()
The global Program "get" accessor.
Definition: pgm_base.cpp:1059
see class PGM_BASE
@ LAST_PATH_SPECCTRADSN
Definition: project_file.h:53
std::vector< FAB_LAYER_COLOR > dummy
wxString UnescapeString(const wxString &aSource)
const double IU_PER_MM
Definition: base_units.h:76
const double IU_PER_MILS
Definition: base_units.h:77
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.