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_group.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>
63#include <tools/edit_tool.h>
66#include <router/router_tool.h>
67#include <view/view_controls.h>
68#include <view/view_group.h>
72#include <wx/filedlg.h>
73#include <wx/log.h>
74
76
77using namespace std::placeholders;
78
79
81{
82public:
84 ACTION_MENU( true )
85 {
86 SetIcon( BITMAPS::add_zone );
87 SetTitle( _( "Zones" ) );
88
93
94 AppendSeparator();
95
100 }
101
102protected:
103 ACTION_MENU* create() const override
104 {
105 return new ZONE_CONTEXT_MENU();
106 }
107};
108
109
111{
112public:
114 CONDITIONAL_MENU( aTool )
115 {
116 SetIcon( BITMAPS::locked );
117 SetTitle( _( "Locking" ) );
118
122 }
123
124 ACTION_MENU* create() const override
125 {
126 return new LOCK_CONTEXT_MENU( this->m_tool );
127 }
128};
129
130
132 PCB_TOOL_BASE( "pcbnew.EditorControl" ),
133 m_frame( nullptr ),
134 m_inPlaceFootprint( false ),
135 m_placingFootprint( false ),
136 m_inPlaceTarget( false )
137{
138 m_placeOrigin = std::make_unique<KIGFX::ORIGIN_VIEWITEM>( KIGFX::COLOR4D( 0.8, 0.0, 0.0, 1.0 ),
140}
141
142
144{
145}
146
147
149{
150 m_frame = getEditFrame<PCB_EDIT_FRAME>();
151
152 if( aReason == MODEL_RELOAD || aReason == GAL_SWITCH || aReason == REDRAW )
153 {
154 m_placeOrigin->SetPosition( getModel<BOARD>()->GetDesignSettings().GetAuxOrigin() );
155 getView()->Remove( m_placeOrigin.get() );
156 getView()->Add( m_placeOrigin.get() );
157 }
158}
159
160
162{
163 auto activeToolCondition =
164 [this]( const SELECTION& aSel )
165 {
166 return ( !m_frame->ToolStackIsEmpty() );
167 };
168
169 auto inactiveStateCondition =
170 [this]( const SELECTION& aSel )
171 {
172 return ( m_frame->ToolStackIsEmpty() && aSel.Size() == 0 );
173 };
174
175 auto placeModuleCondition =
176 [this]( const SELECTION& aSel )
177 {
178 return m_frame->IsCurrentTool( PCB_ACTIONS::placeFootprint ) && aSel.GetSize() == 0;
179 };
180
181 auto& ctxMenu = m_menu.GetMenu();
182
183 // "Cancel" goes at the top of the context menu when a tool is active
184 ctxMenu.AddItem( ACTIONS::cancelInteractive, activeToolCondition, 1 );
185 ctxMenu.AddSeparator( 1 );
186
187 // "Get and Place Footprint" should be available for Place Footprint tool
188 ctxMenu.AddItem( PCB_ACTIONS::getAndPlace, placeModuleCondition, 1000 );
189 ctxMenu.AddSeparator( 1000 );
190
191 // Finally, add the standard zoom & grid items
192 getEditFrame<PCB_BASE_FRAME>()->AddStandardSubMenus( m_menu );
193
194 std::shared_ptr<ZONE_CONTEXT_MENU> zoneMenu = std::make_shared<ZONE_CONTEXT_MENU>();
195 zoneMenu->SetTool( this );
196
197 std::shared_ptr<LOCK_CONTEXT_MENU> lockMenu = std::make_shared<LOCK_CONTEXT_MENU>( this );
198
199 // Add the PCB control menus to relevant other tools
200
202
203 if( selTool )
204 {
205 TOOL_MENU& toolMenu = selTool->GetToolMenu();
206 CONDITIONAL_MENU& menu = toolMenu.GetMenu();
207
208 // Add "Get and Place Footprint" when Selection tool is in an inactive state
209 menu.AddItem( PCB_ACTIONS::getAndPlace, inactiveStateCondition );
210 menu.AddSeparator();
211
212 toolMenu.RegisterSubMenu( zoneMenu );
213 toolMenu.RegisterSubMenu( lockMenu );
214
215 menu.AddMenu( lockMenu.get(), SELECTION_CONDITIONS::NotEmpty, 100 );
216
217 menu.AddMenu( zoneMenu.get(), SELECTION_CONDITIONS::OnlyTypes( { PCB_ZONE_T } ), 100 );
218 }
219
220 DRAWING_TOOL* drawingTool = m_toolMgr->GetTool<DRAWING_TOOL>();
221
222 if( drawingTool )
223 {
224 TOOL_MENU& toolMenu = drawingTool->GetToolMenu();
225 CONDITIONAL_MENU& menu = toolMenu.GetMenu();
226
227 toolMenu.RegisterSubMenu( zoneMenu );
228
229 // Functor to say if the PCB_EDIT_FRAME is in a given mode
230 // Capture the tool pointer and tool mode by value
231 auto toolActiveFunctor =
232 [=]( DRAWING_TOOL::MODE aMode )
233 {
234 return [=]( const SELECTION& sel )
235 {
236 return drawingTool->GetDrawingMode() == aMode;
237 };
238 };
239
240 menu.AddMenu( zoneMenu.get(), toolActiveFunctor( DRAWING_TOOL::MODE::ZONE ), 300 );
241 }
242
243 return true;
244}
245
246
248{
250 return 0;
251}
252
253
255{
257 return 0;
258}
259
260
262{
264 return 0;
265}
266
267
269{
271 return 0;
272}
273
274
276{
278 return 0;
279}
280
281
283{
285 return 0;
286}
287
288
290{
291 PICKED_ITEMS_LIST undoCmd;
293 ITEM_PICKER wrapper( nullptr, undoItem, UNDO_REDO::PAGESETTINGS );
294
295 undoCmd.PushItem( wrapper );
296 undoCmd.SetDescription( _( "Page Settings" ) );
297 m_frame->SaveCopyInUndoList( undoCmd, UNDO_REDO::PAGESETTINGS );
298
302
303 if( dlg.ShowModal() == wxID_OK )
304 {
306 [&]( KIGFX::VIEW_ITEM* aItem ) -> int
307 {
308 EDA_TEXT* text = dynamic_cast<EDA_TEXT*>( aItem );
309
310 if( text && text->HasTextVars() )
311 {
312 text->ClearRenderCache();
313 text->ClearBoundingBoxCache();
315 }
316
317 return 0;
318 } );
319
320 m_frame->OnModify();
321 }
322 else
323 {
325 }
326
327 return 0;
328}
329
330
332{
334 return 0;
335}
336
337
339{
341 return 0;
342}
343
344
346{
348 return 0;
349}
350
351
353{
355 return 0;
356}
357
358
360{
361 getEditFrame<PCB_EDIT_FRAME>()->ShowBoardSetupDialog();
362 return 0;
363}
364
365
367{
368 getEditFrame<PCB_EDIT_FRAME>()->InstallNetlistFrame();
369 return 0;
370}
371
372
374{
375 wxString fullFileName = frame()->GetBoard()->GetFileName();
376 wxString path;
377 wxString name;
378 wxString ext;
379
380 wxFileName::SplitPath( fullFileName, &path, &name, &ext );
381 name += wxT( "." ) + SpecctraSessionFileExtension;
382
383 fullFileName = wxFileSelector( _( "Specctra Session File" ), path, name,
384 wxT( "." ) + SpecctraSessionFileExtension,
385 SpecctraSessionFileWildcard(), wxFD_OPEN | wxFD_CHANGE_DIR,
386 frame() );
387
388 if( !fullFileName.IsEmpty() )
389 getEditFrame<PCB_EDIT_FRAME>()->ImportSpecctraSession( fullFileName );
390
391 return 0;
392}
393
394
396{
397 wxString fullFileName = m_frame->GetLastPath( LAST_PATH_SPECCTRADSN );
398 wxFileName fn;
399
400 if( fullFileName.IsEmpty() )
401 {
402 fn = m_frame->GetBoard()->GetFileName();
403 fn.SetExt( SpecctraDsnFileExtension );
404 }
405 else
406 {
407 fn = fullFileName;
408 }
409
410 fullFileName = wxFileSelector( _( "Specctra DSN File" ), fn.GetPath(), fn.GetFullName(),
412 wxFD_SAVE | wxFD_OVERWRITE_PROMPT | wxFD_CHANGE_DIR, frame() );
413
414 if( !fullFileName.IsEmpty() )
415 {
416 m_frame->SetLastPath( LAST_PATH_SPECCTRADSN, fullFileName );
417 getEditFrame<PCB_EDIT_FRAME>()->ExportSpecctraFile( fullFileName );
418 }
419
420 return 0;
421}
422
423
425{
426 wxCHECK( m_frame, 0 );
427
428 wxFileName fn = m_frame->Prj().GetProjectFullName();
429
430 // Use a different file extension for the board netlist so the schematic netlist file
431 // is accidentally overwritten.
432 fn.SetExt( wxT( "pcb_net" ) );
433
434 wxFileDialog dlg( m_frame, _( "Export Board Netlist" ), fn.GetPath(), fn.GetFullName(),
435 _( "KiCad board netlist files" ) + AddFileExtListToFilter( { "pcb_net" } ),
436 wxFD_SAVE | wxFD_OVERWRITE_PROMPT );
437
438 dlg.SetExtraControlCreator( &LEGACYFILEDLG_NETLIST_OPTIONS::Create );
439
440 if( dlg.ShowModal() == wxID_CANCEL )
441 return 0;
442
443 fn = dlg.GetPath();
444
445 if( !fn.IsDirWritable() )
446 {
447 wxString msg;
448
449 msg.Printf( _( "Path `%s` is read only." ), fn.GetPath() );
450 wxMessageDialog( m_frame, msg, _( "I/O Error" ), wxOK | wxCENTER | wxICON_EXCLAMATION );
451 return 0;
452 }
453
455 dynamic_cast<const LEGACYFILEDLG_NETLIST_OPTIONS*>( dlg.GetExtraControl() );
456 wxCHECK( noh, 0 );
457
459
460 for( const FOOTPRINT* footprint : board()->Footprints() )
461 {
464 { footprint->m_Uuid } );
465
466 for( const PAD* pad : footprint->Pads() )
467 {
468 const wxString& netname = pad->GetShortNetname();
469
470 if( !netname.IsEmpty() )
471 {
472 component->AddNet( pad->GetNumber(), netname, pad->GetPinFunction(),
473 pad->GetPinType() );
474 }
475 }
476
477 nlohmann::ordered_map<wxString, wxString> fields;
478 for( PCB_FIELD* field : footprint->Fields() )
479 fields[field->GetCanonicalName()] = field->GetText();
480
481 component->SetFields( fields );
482
483 netlist.AddComponent( component );
484 }
485
486 FILE_OUTPUTFORMATTER formatter( fn.GetFullPath() );
487
488 netlist.Format( "pcb_netlist", &formatter, 0, noh->GetNetlistOptions() );
489
490 return 0;
491}
492
493
495{
496 wxCommandEvent dummy;
497
500 else if( aEvent.IsAction( &PCB_ACTIONS::generateReportFile ) )
502 else if( aEvent.IsAction( &PCB_ACTIONS::generateD356File ) )
504 else if( aEvent.IsAction( &PCB_ACTIONS::generateBOM ) )
506 else if( aEvent.IsAction( &PCB_ACTIONS::generateIPC2581File ) )
508 else
509 wxFAIL_MSG( wxT( "GenerateFabFiles(): unexpected request" ) );
510
511 return 0;
512}
513
514
516{
517 int errors = 0;
518 wxString details;
519 bool quiet = aEvent.Parameter<bool>();
520
521 // Repair duplicate IDs and missing nets.
522 std::set<KIID> ids;
523 int duplicates = 0;
524
525 auto processItem =
526 [&]( EDA_ITEM* aItem )
527 {
528 if( ids.count( aItem->m_Uuid ) )
529 {
530 duplicates++;
531 const_cast<KIID&>( aItem->m_Uuid ) = KIID();
532 }
533
534 ids.insert( aItem->m_Uuid );
535
536 BOARD_CONNECTED_ITEM* cItem = dynamic_cast<BOARD_CONNECTED_ITEM*>( aItem );
537
538 if( cItem && cItem->GetNetCode() )
539 {
540 NETINFO_ITEM* netinfo = cItem->GetNet();
541
542 if( netinfo && !board()->FindNet( netinfo->GetNetname() ) )
543 {
544 board()->Add( netinfo );
545
546 details += wxString::Format( _( "Orphaned net %s re-parented.\n" ),
547 netinfo->GetNetname() );
548 errors++;
549 }
550 }
551 };
552
553 // Footprint IDs are the most important, so give them the first crack at "claiming" a
554 // particular KIID.
555
556 for( FOOTPRINT* footprint : board()->Footprints() )
557 processItem( footprint );
558
559 // After that the principal use is for DRC marker pointers, which are most likely to pads
560 // or tracks.
561
562 for( FOOTPRINT* footprint : board()->Footprints() )
563 {
564 for( PAD* pad : footprint->Pads() )
565 processItem( pad );
566 }
567
568 for( PCB_TRACK* track : board()->Tracks() )
569 processItem( track );
570
571 // From here out I don't think order matters much.
572
573 for( FOOTPRINT* footprint : board()->Footprints() )
574 {
575 processItem( &footprint->Reference() );
576 processItem( &footprint->Value() );
577
578 for( BOARD_ITEM* item : footprint->GraphicalItems() )
579 processItem( item );
580
581 for( ZONE* zone : footprint->Zones() )
582 processItem( zone );
583
584 for( PCB_GROUP* group : footprint->Groups() )
585 processItem( group );
586 }
587
588 for( BOARD_ITEM* drawing : board()->Drawings() )
589 processItem( drawing );
590
591 for( ZONE* zone : board()->Zones() )
592 processItem( zone );
593
594 for( PCB_MARKER* marker : board()->Markers() )
595 processItem( marker );
596
597 for( PCB_GROUP* group : board()->Groups() )
598 processItem( group );
599
600 if( duplicates )
601 {
602 errors += duplicates;
603 details += wxString::Format( _( "%d duplicate IDs replaced.\n" ), duplicates );
604 }
605
606 /*******************************
607 * Your test here
608 */
609
610 /*******************************
611 * Inform the user
612 */
613
614 if( errors )
615 {
616 m_frame->OnModify();
617
618 wxString msg = wxString::Format( _( "%d potential problems repaired." ), errors );
619
620 if( !quiet )
621 DisplayInfoMessage( m_frame, msg, details );
622 }
623 else if( !quiet )
624 {
625 DisplayInfoMessage( m_frame, _( "No board problems found." ) );
626 }
627
628 return 0;
629}
630
631
633{
635
636 if( m_frame->FetchNetlistFromSchematic( netlist, _( "Updating PCB requires a fully annotated "
637 "schematic." ) ) )
638 {
639 DIALOG_UPDATE_PCB updateDialog( m_frame, &netlist );
640 updateDialog.ShowModal();
641 }
642
643 return 0;
644}
645
647{
648 if( Kiface().IsSingle() )
649 {
650 DisplayErrorMessage( m_frame, _( "Cannot update schematic because Pcbnew is opened in "
651 "stand-alone mode. In order to create or update PCBs "
652 "from schematics, you must launch the KiCad project "
653 "manager and create a project." ) );
654 return 0;
655 }
656
659
660 if( frame )
661 {
662 std::string payload;
663
664 if( wxWindow* blocking_win = frame->Kiway().GetBlockingDialog() )
665 blocking_win->Close( true );
666
668 }
669 return 0;
670}
671
672
674{
676 return 0;
677}
678
679
681{
682 getEditFrame<PCB_EDIT_FRAME>()->ToggleLayersManager();
683 return 0;
684}
685
686
688{
689 getEditFrame<PCB_EDIT_FRAME>()->ToggleProperties();
690 return 0;
691}
692
693
695{
696 getEditFrame<PCB_EDIT_FRAME>()->ToggleSearch();
697 return 0;
698}
699
700
702{
704 return 0;
705}
706
707
708// Track & via size control
710{
711 BOARD_DESIGN_SETTINGS& bds = getModel<BOARD>()->GetDesignSettings();
713
715 && SELECTION_CONDITIONS::OnlyTypes( { PCB_TRACE_T, PCB_ARC_T, PCB_VIA_T } )( selection ) )
716 {
717 BOARD_COMMIT commit( this );
718
719 for( EDA_ITEM* item : selection )
720 {
721 if( item->IsType( { PCB_TRACE_T, PCB_ARC_T } ) )
722 {
723 PCB_TRACK* track = static_cast<PCB_TRACK*>( item );
724
725 for( int i = 0; i < (int) bds.m_TrackWidthList.size(); ++i )
726 {
727 int candidate = bds.m_NetSettings->m_DefaultNetClass->GetTrackWidth();
728
729 if( i > 0 )
730 candidate = bds.m_TrackWidthList[ i ];
731
732 if( candidate > track->GetWidth() )
733 {
734 commit.Modify( track );
735 track->SetWidth( candidate );
736 break;
737 }
738 }
739 }
740 }
741
742 commit.Push( wxT( "Increase Track Width" ) );
743 return 0;
744 }
745
746 ROUTER_TOOL* routerTool = m_toolMgr->GetTool<ROUTER_TOOL>();
747
748 if( routerTool && routerTool->IsToolActive()
749 && routerTool->Router()->Mode() == PNS::PNS_MODE_ROUTE_DIFF_PAIR )
750 {
751 int widthIndex = (int) bds.GetDiffPairIndex() + 1;
752
753 // If we go past the last track width entry in the list, start over at the beginning
754 if( widthIndex >= (int) bds.m_DiffPairDimensionsList.size() )
755 widthIndex = 0;
756
757 bds.SetDiffPairIndex( widthIndex );
758 bds.UseCustomDiffPairDimensions( false );
759
761 }
762 else
763 {
764 int widthIndex = (int) bds.GetTrackWidthIndex();
765
766 if( routerTool && routerTool->IsToolActive()
769 {
770 bds.m_TempOverrideTrackWidth = true;
771 }
772 else
773 {
774 widthIndex++;
775 }
776
777 // If we go past the last track width entry in the list, start over at the beginning
778 if( widthIndex >= (int) bds.m_TrackWidthList.size() )
779 widthIndex = 0;
780
781 bds.SetTrackWidthIndex( widthIndex );
782 bds.UseCustomTrackViaSize( false );
783
785 }
786
787 return 0;
788}
789
790
792{
793 BOARD_DESIGN_SETTINGS& bds = getModel<BOARD>()->GetDesignSettings();
795
797 && SELECTION_CONDITIONS::OnlyTypes( { PCB_TRACE_T, PCB_ARC_T, PCB_VIA_T } )( selection ) )
798 {
799 BOARD_COMMIT commit( this );
800
801 for( EDA_ITEM* item : selection )
802 {
803 if( item->IsType( { PCB_TRACE_T, PCB_ARC_T } ) )
804 {
805 PCB_TRACK* track = static_cast<PCB_TRACK*>( item );
806
807 for( int i = (int) bds.m_TrackWidthList.size() - 1; i >= 0; --i )
808 {
809 int candidate = bds.m_NetSettings->m_DefaultNetClass->GetTrackWidth();
810
811 if( i > 0 )
812 candidate = bds.m_TrackWidthList[ i ];
813
814 if( candidate < track->GetWidth() )
815 {
816 commit.Modify( track );
817 track->SetWidth( candidate );
818 break;
819 }
820 }
821 }
822 }
823
824 commit.Push( wxT( "Decrease Track Width" ) );
825 return 0;
826 }
827
828 ROUTER_TOOL* routerTool = m_toolMgr->GetTool<ROUTER_TOOL>();
829
830 if( routerTool && routerTool->IsToolActive()
831 && routerTool->Router()->Mode() == PNS::PNS_MODE_ROUTE_DIFF_PAIR )
832 {
833 int widthIndex = (int) bds.GetDiffPairIndex() - 1;
834
835 // If we get to the lowest entry start over at the highest
836 if( widthIndex < 0 )
837 widthIndex = (int) bds.m_DiffPairDimensionsList.size() - 1;
838
839 bds.SetDiffPairIndex( widthIndex );
840 bds.UseCustomDiffPairDimensions( false );
841
843 }
844 else
845 {
846 int widthIndex = (int) bds.GetTrackWidthIndex();
847
848 if( routerTool && routerTool->IsToolActive()
851 {
852 bds.m_TempOverrideTrackWidth = true;
853 }
854 else
855 {
856 widthIndex--;
857 }
858
859 // If we get to the lowest entry start over at the highest
860 if( widthIndex < 0 )
861 widthIndex = (int) bds.m_TrackWidthList.size() - 1;
862
863 bds.SetTrackWidthIndex( widthIndex );
864 bds.UseCustomTrackViaSize( false );
865
867 }
868
869 return 0;
870}
871
872
874{
875 BOARD_DESIGN_SETTINGS& bds = getModel<BOARD>()->GetDesignSettings();
877
879 && SELECTION_CONDITIONS::OnlyTypes( { PCB_TRACE_T, PCB_ARC_T, PCB_VIA_T } )( selection ) )
880 {
881 BOARD_COMMIT commit( this );
882
883 for( EDA_ITEM* item : selection )
884 {
885 if( item->Type() == PCB_VIA_T )
886 {
887 PCB_VIA* via = static_cast<PCB_VIA*>( item );
888
889 for( int i = 0; i < (int) bds.m_ViasDimensionsList.size(); ++i )
890 {
891 VIA_DIMENSION dims( bds.m_NetSettings->m_DefaultNetClass->GetViaDiameter(),
892 bds.m_NetSettings->m_DefaultNetClass->GetViaDrill() );
893
894 if( i> 0 )
895 dims = bds.m_ViasDimensionsList[ i ];
896
897 if( dims.m_Diameter > via->GetWidth() )
898 {
899 commit.Modify( via );
900 via->SetWidth( dims.m_Diameter );
901 via->SetDrill( dims.m_Drill );
902 break;
903 }
904 }
905 }
906 }
907
908 commit.Push( wxT( "Increase Via Size" ) );
909 }
910 else
911 {
912 int sizeIndex = (int) bds.GetViaSizeIndex() + 1;
913
914 // If we go past the last via entry in the list, start over at the beginning
915 if( sizeIndex >= (int) bds.m_ViasDimensionsList.size() )
916 sizeIndex = 0;
917
918 bds.SetViaSizeIndex( sizeIndex );
919 bds.UseCustomTrackViaSize( false );
920
922 }
923
924 return 0;
925}
926
927
929{
930 BOARD_DESIGN_SETTINGS& bds = getModel<BOARD>()->GetDesignSettings();
932
934 && SELECTION_CONDITIONS::OnlyTypes( { PCB_TRACE_T, PCB_ARC_T, PCB_VIA_T } )( selection ) )
935 {
936 BOARD_COMMIT commit( this );
937
938 for( EDA_ITEM* item : selection )
939 {
940 if( item->Type() == PCB_VIA_T )
941 {
942 PCB_VIA* via = static_cast<PCB_VIA*>( item );
943
944 for( int i = (int) bds.m_ViasDimensionsList.size() - 1; i >= 0; --i )
945 {
946 VIA_DIMENSION dims( bds.m_NetSettings->m_DefaultNetClass->GetViaDiameter(),
947 bds.m_NetSettings->m_DefaultNetClass->GetViaDrill() );
948
949 if( i > 0 )
950 dims = bds.m_ViasDimensionsList[ i ];
951
952 if( dims.m_Diameter < via->GetWidth() )
953 {
954 commit.Modify( via );
955 via->SetWidth( dims.m_Diameter );
956 via->SetDrill( dims.m_Drill );
957 break;
958 }
959 }
960 }
961 }
962
963 commit.Push( "Decrease Via Size" );
964 }
965 else
966 {
967 int sizeIndex = 0; // Assume we only have a single via size entry
968
969 // If there are more, cycle through them backwards
970 if( bds.m_ViasDimensionsList.size() > 0 )
971 {
972 sizeIndex = (int) bds.GetViaSizeIndex() - 1;
973
974 // If we get to the lowest entry start over at the highest
975 if( sizeIndex < 0 )
976 sizeIndex = (int) bds.m_ViasDimensionsList.size() - 1;
977 }
978
979 bds.SetViaSizeIndex( sizeIndex );
980 bds.UseCustomTrackViaSize( false );
981
983 }
984
985 return 0;
986}
987
988
990{
992 return 0;
993
995
996 FOOTPRINT* fp = aEvent.Parameter<FOOTPRINT*>();
997 bool fromOtherCommand = fp != nullptr;
999 BOARD_COMMIT commit( m_frame );
1000 BOARD* board = getModel<BOARD>();
1001 COMMON_SETTINGS* common_settings = Pgm().GetCommonSettings();
1002
1004
1005 m_frame->PushTool( aEvent );
1006
1007 auto setCursor =
1008 [&]()
1009 {
1010 m_frame->GetCanvas()->SetCurrentCursor( KICURSOR::PENCIL );
1011 };
1012
1013 auto cleanup =
1014 [&] ()
1015 {
1017 commit.Revert();
1018
1019 if( fromOtherCommand )
1020 {
1022
1023 if( undo )
1024 {
1027 delete undo;
1028 }
1029 }
1030
1031 fp = nullptr;
1032 m_placingFootprint = false;
1033 };
1034
1035 Activate();
1036 // Must be done after Activate() so that it gets set into the correct context
1037 controls->ShowCursor( true );
1038 // Set initial cursor
1039 setCursor();
1040
1041 VECTOR2I cursorPos = controls->GetCursorPosition();
1042 bool ignorePrimePosition = false;
1043 bool reselect = false;
1044
1045 // Prime the pump
1046 if( fp )
1047 {
1048 m_placingFootprint = true;
1049 fp->SetPosition( cursorPos );
1052 }
1053 else if( aEvent.HasPosition() )
1054 {
1055 m_toolMgr->PrimeTool( aEvent.Position() );
1056 }
1057 else if( common_settings->m_Input.immediate_actions && !aEvent.IsReactivate() )
1058 {
1059 m_toolMgr->PrimeTool( { 0, 0 } );
1060 ignorePrimePosition = true;
1061 }
1062
1063 // Main loop: keep receiving events
1064 while( TOOL_EVENT* evt = Wait() )
1065 {
1066 setCursor();
1067 cursorPos = controls->GetCursorPosition( !evt->DisableGridSnapping() );
1068
1069 if( reselect && fp )
1071
1072 if( evt->IsCancelInteractive() || ( fp && evt->IsAction( &ACTIONS::undo ) ) )
1073 {
1074 if( fp )
1075 {
1076 cleanup();
1077 }
1078 else
1079 {
1080 m_frame->PopTool( aEvent );
1081 break;
1082 }
1083 }
1084 else if( evt->IsActivate() )
1085 {
1086 if( fp )
1087 cleanup();
1088
1089 if( evt->IsMoveTool() )
1090 {
1091 // leave ourselves on the stack so we come back after the move
1092 break;
1093 }
1094 else
1095 {
1096 frame()->PopTool( aEvent );
1097 break;
1098 }
1099 }
1100 else if( evt->IsClick( BUT_LEFT ) )
1101 {
1102 if( !fp )
1103 {
1104 // Pick the footprint to be placed
1106
1107 if( fp == nullptr )
1108 continue;
1109
1110 // If we started with a hotkey which has a position then warp back to that.
1111 // Otherwise update to the current mouse position pinned inside the autoscroll
1112 // boundaries.
1113 if( evt->IsPrime() && !ignorePrimePosition )
1114 {
1115 cursorPos = evt->Position();
1116 getViewControls()->WarpMouseCursor( cursorPos, true );
1117 }
1118 else
1119 {
1121 cursorPos = getViewControls()->GetMousePosition();
1122 }
1123
1124 m_placingFootprint = true;
1125
1126 fp->SetLink( niluuid );
1127
1128 fp->SetFlags( IS_NEW ); // whatever
1129
1130 // Set parent so that clearance can be loaded
1131 fp->SetParent( board );
1133
1134 for( PAD* pad : fp->Pads() )
1135 {
1136 pad->SetLocalRatsnestVisible( m_frame->GetPcbNewSettings()->m_Display.m_ShowGlobalRatsnest );
1137
1138 // Pads in the library all have orphaned nets. Replace with Default.
1139 pad->SetNetCode( 0 );
1140 }
1141
1142 // Put it on FRONT layer,
1143 // (Can be stored flipped if the lib is an archive built from a board)
1144 if( fp->IsFlipped() )
1146
1147 fp->SetOrientation( ANGLE_0 );
1148 fp->SetPosition( cursorPos );
1149
1150 // Fill this in since it won't be synced from a symbol
1152
1153 commit.Add( fp );
1155
1157 }
1158 else
1159 {
1161 commit.Push( _( "Place a footprint" ) );
1162 fp = nullptr; // to indicate that there is no footprint that we currently modify
1163 m_placingFootprint = false;
1164 }
1165 }
1166 else if( evt->IsClick( BUT_RIGHT ) )
1167 {
1169 }
1170 else if( fp && ( evt->IsMotion() || evt->IsAction( &ACTIONS::refreshPreview ) ) )
1171 {
1172 fp->SetPosition( cursorPos );
1173 selection().SetReferencePoint( cursorPos );
1174 getView()->Update( &selection() );
1175 getView()->Update( fp );
1176 }
1177 else if( fp && evt->IsAction( &PCB_ACTIONS::properties ) )
1178 {
1179 // Calling 'Properties' action clears the selection, so we need to restore it
1180 reselect = true;
1181 }
1182 else if( fp && ( ZONE_FILLER_TOOL::IsZoneFillAction( evt )
1183 || evt->IsAction( &ACTIONS::redo ) ) )
1184 {
1185 wxBell();
1186 }
1187 else
1188 {
1189 evt->SetPassEvent();
1190 }
1191
1192 // Enable autopanning and cursor capture only when there is a footprint to be placed
1193 controls->SetAutoPan( fp != nullptr );
1194 controls->CaptureCursor( fp != nullptr );
1195 }
1196
1197 controls->SetAutoPan( false );
1198 controls->CaptureCursor( false );
1199 m_frame->GetCanvas()->SetCurrentCursor( KICURSOR::ARROW );
1200
1201 return 0;
1202}
1203
1204
1206{
1207 return modifyLockSelected( TOGGLE );
1208}
1209
1210
1212{
1213 return modifyLockSelected( ON );
1214}
1215
1216
1218{
1219 return modifyLockSelected( OFF );
1220}
1221
1222
1224{
1226 const PCB_SELECTION& selection = selTool->GetSelection();
1227 BOARD_COMMIT commit( m_frame );
1228
1229 if( selection.Empty() )
1231
1232 // Resolve TOGGLE mode
1233 if( aMode == TOGGLE )
1234 {
1235 aMode = ON;
1236
1237 for( EDA_ITEM* item : selection )
1238 {
1239 BOARD_ITEM* board_item = dynamic_cast<BOARD_ITEM*>( item );
1240
1241 if( board_item && board_item->IsLocked() )
1242 {
1243 aMode = OFF;
1244 break;
1245 }
1246 }
1247 }
1248
1249 bool modified = false;
1250
1251 for( EDA_ITEM* item : selection )
1252 {
1253 BOARD_ITEM* board_item = dynamic_cast<BOARD_ITEM*>( item );
1254 wxCHECK2( board_item, continue );
1255
1256 commit.Modify( board_item );
1257
1258 if( aMode == ON )
1259 {
1260 modified |= !board_item->IsLocked();
1261 board_item->SetLocked( true );
1262 }
1263 else
1264 {
1265 modified |= board_item->IsLocked();
1266 board_item->SetLocked( false );
1267 }
1268 }
1269
1270 if( modified )
1271 {
1272 commit.Push( aMode == ON ? _( "Lock" ) : _( "Unlock" ) );
1273
1275 m_frame->OnModify();
1276 }
1277
1278 return 0;
1279}
1280
1281
1282static bool mergeZones( EDA_DRAW_FRAME* aFrame, BOARD_COMMIT& aCommit,
1283 std::vector<ZONE*>& aOriginZones, std::vector<ZONE*>& aMergedZones )
1284{
1285 aCommit.Modify( aOriginZones[0] );
1286
1287 for( unsigned int i = 1; i < aOriginZones.size(); i++ )
1288 {
1289 aOriginZones[0]->Outline()->BooleanAdd( *aOriginZones[i]->Outline(),
1291 }
1292
1293 aOriginZones[0]->Outline()->Simplify( SHAPE_POLY_SET::PM_FAST );
1294
1295 // We should have one polygon, possibly with holes. If we end up with two polygons (either
1296 // because the intersection was a single point or because the intersection was within one of
1297 // the zone's holes) then we can't merge.
1298 if( aOriginZones[0]->Outline()->IsSelfIntersecting()
1299 || aOriginZones[0]->Outline()->OutlineCount() > 1 )
1300 {
1301 DisplayErrorMessage( aFrame, _( "Zones have insufficient overlap for merging." ) );
1302 aCommit.Revert();
1303 return false;
1304 }
1305
1306 for( unsigned int i = 1; i < aOriginZones.size(); i++ )
1307 aCommit.Remove( aOriginZones[i] );
1308
1309 aMergedZones.push_back( aOriginZones[0] );
1310
1311 aOriginZones[0]->SetLocalFlags( 1 );
1312 aOriginZones[0]->HatchBorder();
1313 aOriginZones[0]->CacheTriangulation();
1314
1315 return true;
1316}
1317
1318
1320{
1321 const PCB_SELECTION& selection = m_toolMgr->GetTool<PCB_SELECTION_TOOL>()->GetSelection();
1322 BOARD* board = getModel<BOARD>();
1323 BOARD_COMMIT commit( m_frame );
1324
1325 if( selection.Size() < 2 )
1326 return 0;
1327
1328 int netcode = -1;
1329
1330 ZONE* firstZone = nullptr;
1331 std::vector<ZONE*> toMerge, merged;
1332
1333 for( EDA_ITEM* item : selection )
1334 {
1335 ZONE* curr_area = dynamic_cast<ZONE*>( item );
1336
1337 if( !curr_area )
1338 continue;
1339
1340 if( !firstZone )
1341 firstZone = curr_area;
1342
1343 netcode = curr_area->GetNetCode();
1344
1345 if( firstZone->GetNetCode() != netcode )
1346 {
1347 wxLogMessage( _( "Some zone netcodes did not match and were not merged." ) );
1348 continue;
1349 }
1350
1351 if( curr_area->GetAssignedPriority() != firstZone->GetAssignedPriority() )
1352 {
1353 wxLogMessage( _( "Some zone priorities did not match and were not merged." ) );
1354 continue;
1355 }
1356
1357 if( curr_area->GetIsRuleArea() != firstZone->GetIsRuleArea() )
1358 {
1359 wxLogMessage( _( "Some zones were rule areas and were not merged." ) );
1360 continue;
1361 }
1362
1363 if( curr_area->GetLayerSet() != firstZone->GetLayerSet() )
1364 {
1365 wxLogMessage( _( "Some zone layer sets did not match and were not merged." ) );
1366 continue;
1367 }
1368
1369 bool intersects = curr_area == firstZone;
1370
1371 for( ZONE* candidate : toMerge )
1372 {
1373 if( intersects )
1374 break;
1375
1376 if( board->TestZoneIntersection( curr_area, candidate ) )
1377 intersects = true;
1378 }
1379
1380 if( !intersects )
1381 {
1382 wxLogMessage( _( "Some zones did not intersect and were not merged." ) );
1383 continue;
1384 }
1385
1386 toMerge.push_back( curr_area );
1387 }
1388
1390
1391 if( !toMerge.empty() )
1392 {
1393 if( mergeZones( m_frame, commit, toMerge, merged ) )
1394 {
1395 commit.Push( wxT( "Merge Zones" ) );
1396
1397 for( EDA_ITEM* item : merged )
1399 }
1400 }
1401
1402 return 0;
1403}
1404
1405
1407{
1409 const PCB_SELECTION& selection = selTool->GetSelection();
1410
1411 // because this pops up the zone editor, it would be confusing to handle multiple zones,
1412 // so just handle single selections containing exactly one zone
1413 if( selection.Size() != 1 )
1414 return 0;
1415
1416 ZONE* oldZone = dynamic_cast<ZONE*>( selection[0] );
1417
1418 if( !oldZone )
1419 return 0;
1420
1421 ZONE_SETTINGS zoneSettings;
1422 zoneSettings << *oldZone;
1423 int dialogResult;
1424
1425 if( oldZone->GetIsRuleArea() )
1426 dialogResult = InvokeRuleAreaEditor( m_frame, &zoneSettings );
1427 else if( oldZone->IsOnCopperLayer() )
1428 dialogResult = InvokeCopperZonesEditor( m_frame, &zoneSettings );
1429 else
1430 dialogResult = InvokeNonCopperZonesEditor( m_frame, &zoneSettings );
1431
1432 if( dialogResult != wxID_OK )
1433 return 0;
1434
1435 // duplicate the zone
1436 BOARD_COMMIT commit( m_frame );
1437
1438 std::unique_ptr<ZONE> newZone = std::make_unique<ZONE>( *oldZone );
1439 newZone->ClearSelected();
1440 newZone->UnFill();
1441 zoneSettings.ExportSetting( *newZone );
1442
1443 // If the new zone is on the same layer(s) as the initial zone,
1444 // offset it a bit so it can more easily be picked.
1445 if( oldZone->GetLayerSet() == zoneSettings.m_Layers )
1446 newZone->Move( VECTOR2I( pcbIUScale.IU_PER_MM, pcbIUScale.IU_PER_MM ) );
1447
1448 commit.Add( newZone.release() );
1449 commit.Push( _( "Duplicate Zone" ) );
1450
1451 return 0;
1452}
1453
1454
1456{
1457 doCrossProbePcbToSch( aEvent, false );
1458 return 0;
1459}
1460
1461
1463{
1464 doCrossProbePcbToSch( aEvent, true );
1465 return 0;
1466}
1467
1468
1470{
1471 // Don't get in an infinite loop PCB -> SCH -> PCB -> SCH -> ...
1473 return;
1474
1476 const PCB_SELECTION& selection = selTool->GetSelection();
1477 EDA_ITEM* focusItem = nullptr;
1478
1479 if( aEvent.Matches( EVENTS::PointSelectedEvent ) )
1480 focusItem = selection.GetLastAddedItem();
1481
1482 m_frame->SendSelectItemsToSch( selection.GetItems(), focusItem, aForce );
1483
1484 // Update 3D viewer highlighting
1486}
1487
1488
1490{
1492
1493 const PCB_SELECTION& selection = selectionTool->RequestSelection(
1494 []( const VECTOR2I& aPt, GENERAL_COLLECTOR& aCollector, PCB_SELECTION_TOOL* sTool )
1495 {
1496 // Iterate from the back so we don't have to worry about removals.
1497 for( int i = aCollector.GetCount() - 1; i >= 0; --i )
1498 {
1499 if( !dynamic_cast<BOARD_CONNECTED_ITEM*>( aCollector[ i ] ) )
1500 aCollector.Remove( aCollector[ i ] );
1501 }
1502 },
1503 true /* prompt user regarding locked items */ );
1504
1505 int netCode = -1;
1506 wxString netName;
1507
1508 for( EDA_ITEM* item : selection )
1509 {
1510 NETINFO_ITEM* net = static_cast<BOARD_CONNECTED_ITEM*>( item )->GetNet();
1511
1512 if( !net->HasAutoGeneratedNetname() )
1513 {
1514 netCode = net->GetNetCode();
1515 netName = net->GetNetname();
1516 break;
1517 }
1518 }
1519
1520 if( netName.IsEmpty() )
1521 {
1522 m_frame->ShowInfoBarError( _( "Selection contains no items with labeled nets." ) );
1523 return 0;
1524 }
1525
1526 selectionTool->ClearSelection();
1528 canvas()->ForceRefresh();
1529
1530 DIALOG_ASSIGN_NETCLASS dlg( m_frame, netName, board()->GetNetClassAssignmentCandidates(),
1531 [this]( const std::vector<wxString>& aNetNames )
1532 {
1534 selTool->ClearSelection();
1535
1536 for( const wxString& curr_netName : aNetNames )
1537 {
1538 int curr_netCode = board()->GetNetInfo().GetNetItem( curr_netName )->GetNetCode();
1539
1540 if( curr_netCode > 0 )
1541 selTool->SelectAllItemsOnNet( curr_netCode );
1542 }
1543
1544 canvas()->ForceRefresh();
1546 } );
1547
1548 if( dlg.ShowModal() == wxID_OK )
1549 {
1551 // Refresh UI that depends on netclasses, such as the properties panel
1553 }
1554
1555 return 0;
1556}
1557
1558
1560{
1563
1564 if( selection.Empty() )
1565 return 0;
1566
1568
1569 if( !fp )
1570 return 0;
1571
1572 PCB_BASE_EDIT_FRAME* editFrame = getEditFrame<PCB_BASE_EDIT_FRAME>();
1573
1574 auto editor = (FOOTPRINT_EDIT_FRAME*) editFrame->Kiway().Player( FRAME_FOOTPRINT_EDITOR, true );
1575
1577 editor->LoadFootprintFromBoard( fp );
1578 else if( aEvent.IsAction( &PCB_ACTIONS::editLibFpInFpEditor ) )
1579 editor->LoadFootprintFromLibrary( fp->GetFPID() );
1580
1581 editor->Show( true );
1582 editor->Raise(); // Iconize( false );
1583
1584 if( selection.IsHover() )
1586
1587 return 0;
1588}
1589
1590
1592 EDA_ITEM* originViewItem, const VECTOR2D& aPosition )
1593{
1594 aFrame->GetDesignSettings().SetAuxOrigin( VECTOR2I( aPosition ) );
1595 originViewItem->SetPosition( aPosition );
1596 aView->MarkDirty();
1597 aFrame->OnModify();
1598}
1599
1600
1602{
1604 {
1605 m_frame->SaveCopyInUndoList( m_placeOrigin.get(), UNDO_REDO::GRIDORIGIN );
1607 return 0;
1608 }
1609
1611
1612 // Deactivate other tools; particularly important if another PICKER is currently running
1613 Activate();
1614
1615 picker->SetClickHandler(
1616 [this] ( const VECTOR2D& pt ) -> bool
1617 {
1618 m_frame->SaveCopyInUndoList( m_placeOrigin.get(), UNDO_REDO::DRILLORIGIN );
1620 return false; // drill origin is a one-shot; don't continue with tool
1621 } );
1622
1624
1625 return 0;
1626}
1627
1628
1630{
1639
1644
1649
1650 if( ADVANCED_CFG::GetCfg().m_ShowPcbnewExportNetlist && m_frame &&
1653
1661
1662 // Track & via size control
1667
1668 // Zone actions
1671
1672 // Placing tools
1676
1679
1680 // Cross-select
1686
1687 // Other
1691
1693
1702}
1703
1704
1705const 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:175
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:165
static TOOL_ACTION findPrevious
Definition: actions.h:82
static TOOL_ACTION plot
Definition: actions.h:58
static TOOL_ACTION open
Definition: actions.h:50
static TOOL_ACTION findNext
Definition: actions.h:81
static TOOL_ACTION pageSettings
Definition: actions.h:56
static TOOL_ACTION showSearch
Definition: actions.h:78
static TOOL_ACTION undo
Definition: actions.h:65
static TOOL_ACTION save
Definition: actions.h:51
static TOOL_ACTION redo
Definition: actions.h:66
static TOOL_ACTION updateSchematicFromPcb
Definition: actions.h:176
static TOOL_ACTION showProperties
Definition: actions.h:177
static TOOL_ACTION doNew
Definition: actions.h:47
static TOOL_ACTION saveCopy
Definition: actions.h:53
static TOOL_ACTION refreshPreview
Definition: actions.h:113
static TOOL_ACTION find
Definition: actions.h:79
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:91
void SetIcon(BITMAPS aIcon)
Assign an icon for the entry.
Definition: action_menu.cpp:77
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:275
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:299
virtual bool IsLocked() const
Definition: board_item.cpp:73
Information pertinent to a Pcbnew printed circuit board.
Definition: board.h:276
const NETINFO_LIST & GetNetInfo() const
Definition: board.h:827
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_MODE::INSERT, bool aSkipConnectivity=false) override
Removes an item from the container.
Definition: board.cpp:855
void UpdateUserUnits(BOARD_ITEM *aItem, KIGFX::VIEW *aView)
Update any references within aItem (or its descendants) to the user units.
Definition: board.cpp:1072
NETINFO_ITEM * FindNet(int aNetcode) const
Search for a net with the given netcode.
Definition: board.cpp:1642
void SynchronizeNetsAndNetClasses(bool aResetTrackAndViaSizes)
Copy NETCLASS info to each NET, based on NET membership in a NETCLASS.
Definition: board.cpp:1775
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:90
COMMIT & Modify(EDA_ITEM *aItem, BASE_SCREEN *aScreen=nullptr)
Create an undo entry for an item that has been already modified.
Definition: commit.h:103
COMMIT & Add(EDA_ITEM *aItem, BASE_SCREEN *aScreen=nullptr)
Notify observers that aItem has been added.
Definition: commit.h:78
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:2590
static const TOOL_EVENT ClearedEvent
Definition: actions.h:235
static const TOOL_EVENT SelectedEvent
Definition: actions.h:233
static const TOOL_EVENT SelectedItemsModified
Selected items were moved, this can be very high frequency on the canvas, use with care.
Definition: actions.h:240
static const TOOL_EVENT PointSelectedEvent
Definition: actions.h:232
static const TOOL_EVENT UnselectedEvent
Definition: actions.h:234
Used for text file output.
Definition: richio.h:475
void SetPosition(const VECTOR2I &aPos) override
Definition: footprint.cpp:1997
void SetLink(const KIID &aLink)
Definition: footprint.h:798
ZONES & Zones()
Definition: footprint.h:194
void SetOrientation(const EDA_ANGLE &aNewAngle)
Definition: footprint.cpp:2069
PCB_FIELD & Value()
read/write accessors:
Definition: footprint.h:592
wxString GetFPIDAsString() const
Definition: footprint.h:233
bool IsFlipped() const
Definition: footprint.h:351
PADS & Pads()
Definition: footprint.h:188
const LIB_ID & GetFPID() const
Definition: footprint.h:230
PCB_FIELD & Reference()
Definition: footprint.h:593
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:1937
const wxString & GetValue() const
Definition: footprint.h:578
const wxString & GetReference() const
Definition: footprint.h:556
PCB_FIELD * GetField(MANDATORY_FIELD_T aFieldType)
Return a mandatory field in this symbol.
Definition: footprint.cpp:260
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:204
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:313
virtual void Remove(VIEW_ITEM *aItem)
Remove a VIEW_ITEM from the view.
Definition: view.cpp:350
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:1618
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:1510
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:689
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:58
DISPLAY_OPTIONS m_Display
static TOOL_ACTION generateBOM
Definition: pcb_actions.h:429
static TOOL_ACTION zoneFillAll
Definition: pcb_actions.h:390
static TOOL_ACTION showLayersManager
Definition: pcb_actions.h:437
static TOOL_ACTION trackWidthDec
Definition: pcb_actions.h:380
static TOOL_ACTION generateDrillFiles
Definition: pcb_actions.h:424
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:428
static TOOL_ACTION trackViaSizeChanged
Definition: pcb_actions.h:384
static TOOL_ACTION exportSpecctraDSN
Definition: pcb_actions.h:421
static TOOL_ACTION trackWidthInc
Definition: pcb_actions.h:379
static TOOL_ACTION generateIPC2581File
Definition: pcb_actions.h:427
static TOOL_ACTION getAndPlace
Find an item and start moving.
Definition: pcb_actions.h:564
static TOOL_ACTION drawZoneCutout
Definition: pcb_actions.h:215
static TOOL_ACTION viaSizeDec
Definition: pcb_actions.h:382
static TOOL_ACTION zoneFill
Definition: pcb_actions.h:389
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:516
static TOOL_ACTION drillResetOrigin
Definition: pcb_actions.h:532
static TOOL_ACTION viaSizeInc
Definition: pcb_actions.h:381
static TOOL_ACTION zoneUnfill
Definition: pcb_actions.h:392
static TOOL_ACTION generatePosFile
Definition: pcb_actions.h:425
static TOOL_ACTION drillOrigin
Definition: pcb_actions.h:531
static TOOL_ACTION assignNetClass
Definition: pcb_actions.h:386
static TOOL_ACTION repairBoard
Definition: pcb_actions.h:538
static TOOL_ACTION generateGerbers
Definition: pcb_actions.h:423
static TOOL_ACTION generateReportFile
Definition: pcb_actions.h:426
static TOOL_ACTION zoneDuplicate
Duplicate zone onto another layer.
Definition: pcb_actions.h:397
static TOOL_ACTION importNetlist
Definition: pcb_actions.h:418
static TOOL_ACTION drawSimilarZone
Definition: pcb_actions.h:216
static TOOL_ACTION boardSetup
Definition: pcb_actions.h:404
static TOOL_ACTION showEeschema
Definition: pcb_actions.h:535
static TOOL_ACTION zoneUnfillAll
Definition: pcb_actions.h:393
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:394
static TOOL_ACTION unlock
Definition: pcb_actions.h:518
static TOOL_ACTION placeFootprint
Definition: pcb_actions.h:219
static TOOL_ACTION showPythonConsole
Definition: pcb_actions.h:438
static TOOL_ACTION importSpecctraSession
Definition: pcb_actions.h:420
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:517
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:171
void ClearListAndDeleteItems(PICKED_ITEMS_LIST *aList)
Definition: undo_redo.cpp:518
void RollbackFromUndo()
Perform an undo of the last edit without logging a corresponding redo.
Definition: undo_redo.cpp:531
void PutDataInPreviousState(PICKED_ITEMS_LIST *aList)
Used in undo or redo command.
Definition: undo_redo.cpp:266
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
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:135
RouterState GetState() const
Definition: pns_router.h:137
ROUTER * Router() const
virtual const wxString GetProjectFullName() const
Return the full path and name of the project.
Definition: project.cpp:137
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.h:260
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:123
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:266
unsigned GetAssignedPriority() const
Definition: zone.h:119
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:437
#define IS_NEW
New item, just created.
@ FRAME_SCH
Definition: frame_type.h:34
@ FRAME_FOOTPRINT_EDITOR
Definition: frame_type.h:43
const std::string SpecctraDsnFileExtension
const std::string SpecctraSessionFileExtension
wxString AddFileExtListToFilter(const std::vector< std::string > &aExts)
Build the wildcard extension file dialog wildcard filter to add to the base message dialog.
wxString SpecctraDsnFileWildcard()
wxString SpecctraSessionFileWildcard()
@ 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:38
Class to handle a set of BOARD_ITEMs.
@ 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:95
@ PCB_ZONE_T
class ZONE, a copper pour area
Definition: typeinfo.h:105
VECTOR2< int > VECTOR2I
Definition: vector2d.h:588
Definition of file extensions used in Kicad.