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 The 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
27
28#include <functional>
29#include <memory>
30
31#include <pgm_base.h>
32#include <executable_names.h>
33#include <advanced_config.h>
34#include <bitmaps.h>
35#include <gestfich.h>
36#include <pcb_painter.h>
37#include <board.h>
38#include <board_commit.h>
40#include <pcb_generator.h>
41#include <footprint.h>
42#include <pad.h>
43#include <pcb_target.h>
44#include <pcb_track.h>
45#include <zone.h>
46#include <pcb_marker.h>
47#include <confirm.h>
51#include <dialog_plot.h>
52#include <kiface_base.h>
53#include <kiway.h>
55#include <origin_viewitem.h>
56#include <pcb_edit_frame.h>
57#include <pcbnew_id.h>
58#include <project.h>
59#include <project/project_file.h> // LAST_PATH_TYPE
60#include <tool/tool_manager.h>
61#include <tool/tool_event.h>
62#include <tools/drawing_tool.h>
63#include <tools/pcb_actions.h>
68#include <tools/edit_tool.h>
71#include <richio.h>
72#include <router/router_tool.h>
73#include <view/view_controls.h>
74#include <view/view_group.h>
78#include <wx/filedlg.h>
79#include <wx/msgdlg.h>
80#include <wx/log.h>
81
83
84using namespace std::placeholders;
85
86
88{
89public:
91 ACTION_MENU( true )
92 {
93 SetIcon( BITMAPS::add_zone );
94 SetTitle( _( "Zones" ) );
95
100
101 AppendSeparator();
102
107
108 AppendSeparator();
109
111 }
112
113protected:
114 ACTION_MENU* create() const override
115 {
116 return new ZONE_CONTEXT_MENU();
117 }
118};
119
120
122{
123public:
125 CONDITIONAL_MENU( aTool )
126 {
127 SetIcon( BITMAPS::locked );
128 SetTitle( _( "Locking" ) );
129
133 }
134
135 ACTION_MENU* create() const override
136 {
137 return new LOCK_CONTEXT_MENU( this->m_tool );
138 }
139};
140
141
143 PCB_TOOL_BASE( "pcbnew.EditorControl" ),
144 m_frame( nullptr ),
145 m_inPlaceFootprint( false ),
146 m_placingFootprint( false )
147{
148 m_placeOrigin = std::make_unique<KIGFX::ORIGIN_VIEWITEM>( KIGFX::COLOR4D( 0.8, 0.0, 0.0, 1.0 ),
150}
151
152
154{
155}
156
157
159{
160 m_frame = getEditFrame<PCB_EDIT_FRAME>();
161
162 if( aReason == MODEL_RELOAD || aReason == GAL_SWITCH || aReason == REDRAW )
163 {
164 m_placeOrigin->SetPosition( getModel<BOARD>()->GetDesignSettings().GetAuxOrigin() );
165 getView()->Remove( m_placeOrigin.get() );
166 getView()->Add( m_placeOrigin.get() );
167 }
168}
169
170
172{
173 auto activeToolCondition =
174 [this]( const SELECTION& aSel )
175 {
176 return ( !m_frame->ToolStackIsEmpty() );
177 };
178
179 auto inactiveStateCondition =
180 [this]( const SELECTION& aSel )
181 {
182 return ( m_frame->ToolStackIsEmpty() && aSel.Size() == 0 );
183 };
184
185 auto placeModuleCondition =
186 [this]( const SELECTION& aSel )
187 {
188 return m_frame->IsCurrentTool( PCB_ACTIONS::placeFootprint ) && aSel.GetSize() == 0;
189 };
190
191 auto& ctxMenu = m_menu->GetMenu();
192
193 // "Cancel" goes at the top of the context menu when a tool is active
194 ctxMenu.AddItem( ACTIONS::cancelInteractive, activeToolCondition, 1 );
195 ctxMenu.AddSeparator( 1 );
196
197 // "Get and Place Footprint" should be available for Place Footprint tool
198 ctxMenu.AddItem( PCB_ACTIONS::getAndPlace, placeModuleCondition, 1000 );
199 ctxMenu.AddSeparator( 1000 );
200
201 // Finally, add the standard zoom & grid items
202 getEditFrame<PCB_BASE_FRAME>()->AddStandardSubMenus( *m_menu.get() );
203
204 std::shared_ptr<ZONE_CONTEXT_MENU> zoneMenu = std::make_shared<ZONE_CONTEXT_MENU>();
205 zoneMenu->SetTool( this );
206
207 std::shared_ptr<LOCK_CONTEXT_MENU> lockMenu = std::make_shared<LOCK_CONTEXT_MENU>( this );
208
209 // Add the PCB control menus to relevant other tools
210
212
213 if( selTool )
214 {
215 TOOL_MENU& toolMenu = selTool->GetToolMenu();
216 CONDITIONAL_MENU& menu = toolMenu.GetMenu();
217
218 // Add "Get and Place Footprint" when Selection tool is in an inactive state
219 menu.AddItem( PCB_ACTIONS::getAndPlace, inactiveStateCondition );
220 menu.AddSeparator();
221
222 toolMenu.RegisterSubMenu( zoneMenu );
223 toolMenu.RegisterSubMenu( lockMenu );
224
225 menu.AddMenu( lockMenu.get(), SELECTION_CONDITIONS::NotEmpty, 100 );
226
227 menu.AddMenu( zoneMenu.get(), SELECTION_CONDITIONS::OnlyTypes( { PCB_ZONE_T } ), 100 );
228 }
229
230 DRAWING_TOOL* drawingTool = m_toolMgr->GetTool<DRAWING_TOOL>();
231
232 if( drawingTool )
233 {
234 TOOL_MENU& toolMenu = drawingTool->GetToolMenu();
235 CONDITIONAL_MENU& menu = toolMenu.GetMenu();
236
237 toolMenu.RegisterSubMenu( zoneMenu );
238
239 // Functor to say if the PCB_EDIT_FRAME is in a given mode
240 // Capture the tool pointer and tool mode by value
241 auto toolActiveFunctor =
242 [=]( DRAWING_TOOL::MODE aMode )
243 {
244 return [=]( const SELECTION& sel )
245 {
246 return drawingTool->GetDrawingMode() == aMode;
247 };
248 };
249
250 menu.AddMenu( zoneMenu.get(), toolActiveFunctor( DRAWING_TOOL::MODE::ZONE ), 300 );
251 }
252
253 return true;
254}
255
256
258{
260 return 0;
261}
262
263
265{
266 m_frame->SaveBoard( true );
267 return 0;
268}
269
270
272{
273 m_frame->SaveBoard( true, true );
274 return 0;
275}
276
277
279{
281 return 0;
282}
283
284
286{
288 return 0;
289}
290
291
293{
294 PICKED_ITEMS_LIST undoCmd;
296 ITEM_PICKER wrapper( nullptr, undoItem, UNDO_REDO::PAGESETTINGS );
297
298 undoCmd.PushItem( wrapper );
299 undoCmd.SetDescription( _( "Page Settings" ) );
300 m_frame->SaveCopyInUndoList( undoCmd, UNDO_REDO::PAGESETTINGS );
301
305
306 if( dlg.ShowModal() == wxID_OK )
307 {
309 [&]( KIGFX::VIEW_ITEM* aItem ) -> int
310 {
311 EDA_TEXT* text = dynamic_cast<EDA_TEXT*>( aItem );
312
313 if( text && text->HasTextVars() )
314 {
315 text->ClearRenderCache();
316 text->ClearBoundingBoxCache();
318 }
319
320 return 0;
321 } );
322
323 m_frame->OnModify();
324 }
325 else
326 {
328 }
329
330 return 0;
331}
332
333
335{
336 DIALOG_PLOT dlg( m_frame );
337 dlg.ShowQuasiModal();
338 return 0;
339}
340
341
343{
345 return 0;
346}
347
348
350{
352 return 0;
353}
354
355
357{
359 return 0;
360}
361
362
364{
365 getEditFrame<PCB_EDIT_FRAME>()->ShowBoardSetupDialog();
366 return 0;
367}
368
369
371{
372 getEditFrame<PCB_EDIT_FRAME>()->InstallNetlistFrame();
373 return 0;
374}
375
376
378{
379 wxString fullFileName = frame()->GetBoard()->GetFileName();
380 wxString path;
381 wxString name;
382 wxString ext;
383
384 wxFileName::SplitPath( fullFileName, &path, &name, &ext );
385 name += wxT( "." ) + wxString( FILEEXT::SpecctraSessionFileExtension );
386
387 fullFileName = wxFileSelector( _( "Specctra Session File" ), path, name,
388 wxT( "." ) + wxString( FILEEXT::SpecctraSessionFileExtension ),
389 FILEEXT::SpecctraSessionFileWildcard(), wxFD_OPEN | wxFD_CHANGE_DIR,
390 frame() );
391
392 if( !fullFileName.IsEmpty() )
393 getEditFrame<PCB_EDIT_FRAME>()->ImportSpecctraSession( fullFileName );
394
395 return 0;
396}
397
398
400{
401 wxString fullFileName = m_frame->GetLastPath( LAST_PATH_SPECCTRADSN );
402 wxFileName fn;
403
404 if( fullFileName.IsEmpty() )
405 {
406 fn = m_frame->GetBoard()->GetFileName();
408 }
409 else
410 {
411 fn = fullFileName;
412 }
413
414 fullFileName = wxFileSelector( _( "Specctra DSN File" ), fn.GetPath(), fn.GetFullName(),
416 wxFD_SAVE | wxFD_OVERWRITE_PROMPT | wxFD_CHANGE_DIR, frame() );
417
418 if( !fullFileName.IsEmpty() )
419 {
420 m_frame->SetLastPath( LAST_PATH_SPECCTRADSN, fullFileName );
421 getEditFrame<PCB_EDIT_FRAME>()->ExportSpecctraFile( fullFileName );
422 }
423
424 return 0;
425}
426
427
429{
430 wxCHECK( m_frame, 0 );
431
432 wxFileName fn = m_frame->Prj().GetProjectFullName();
433
434 // Use a different file extension for the board netlist so the schematic netlist file
435 // is accidentally overwritten.
436 fn.SetExt( wxT( "pcb_net" ) );
437
438 wxFileDialog dlg( m_frame, _( "Export Board Netlist" ), fn.GetPath(), fn.GetFullName(),
439 _( "KiCad board netlist files" ) + AddFileExtListToFilter( { "pcb_net" } ),
440 wxFD_SAVE | wxFD_OVERWRITE_PROMPT );
441
442 dlg.SetExtraControlCreator( &LEGACYFILEDLG_NETLIST_OPTIONS::Create );
443
444 if( dlg.ShowModal() == wxID_CANCEL )
445 return 0;
446
447 fn = dlg.GetPath();
448
449 if( !fn.IsDirWritable() )
450 {
451 wxString msg;
452
453 msg.Printf( _( "Path `%s` is read only." ), fn.GetPath() );
454 wxMessageDialog( m_frame, msg, _( "I/O Error" ), wxOK | wxCENTER | wxICON_EXCLAMATION );
455 return 0;
456 }
457
459 dynamic_cast<const LEGACYFILEDLG_NETLIST_OPTIONS*>( dlg.GetExtraControl() );
460 wxCHECK( noh, 0 );
461
463
464 for( const FOOTPRINT* footprint : board()->Footprints() )
465 {
468 { footprint->m_Uuid } );
469
470 for( const PAD* pad : footprint->Pads() )
471 {
472 const wxString& netname = pad->GetShortNetname();
473
474 if( !netname.IsEmpty() )
475 {
476 component->AddNet( pad->GetNumber(), netname, pad->GetPinFunction(),
477 pad->GetPinType() );
478 }
479 }
480
481 nlohmann::ordered_map<wxString, wxString> fields;
482
483 for( PCB_FIELD* field : footprint->GetFields() )
484 fields[field->GetCanonicalName()] = field->GetText();
485
486 component->SetFields( fields );
487
488 netlist.AddComponent( component );
489 }
490
491 FILE_OUTPUTFORMATTER formatter( fn.GetFullPath() );
492
493 netlist.Format( "pcb_netlist", &formatter, 0, noh->GetNetlistOptions() );
494
495 return 0;
496}
497
498
500{
501 PCB_PLOT_PARAMS plotSettings = m_frame->GetPlotSettings();
502
503 plotSettings.SetFormat( PLOT_FORMAT::GERBER );
504
505 m_frame->SetPlotSettings( plotSettings );
506
507 DIALOG_PLOT dlg( m_frame );
508 dlg.ShowQuasiModal( );
509
510 return 0;
511}
512
513
515{
516 int errors = 0;
517 wxString details;
518 bool quiet = aEvent.Parameter<bool>();
519
520 // Repair duplicate IDs and missing nets.
521 std::set<KIID> ids;
522 int duplicates = 0;
523
524 auto processItem =
525 [&]( EDA_ITEM* aItem )
526 {
527 if( ids.count( aItem->m_Uuid ) )
528 {
529 duplicates++;
530 const_cast<KIID&>( aItem->m_Uuid ) = KIID();
531 }
532
533 ids.insert( aItem->m_Uuid );
534
535 BOARD_CONNECTED_ITEM* cItem = dynamic_cast<BOARD_CONNECTED_ITEM*>( aItem );
536
537 if( cItem && cItem->GetNetCode() )
538 {
539 NETINFO_ITEM* netinfo = cItem->GetNet();
540
541 if( netinfo && !board()->FindNet( netinfo->GetNetname() ) )
542 {
543 board()->Add( netinfo );
544
545 details += wxString::Format( _( "Orphaned net %s re-parented.\n" ),
546 netinfo->GetNetname() );
547 errors++;
548 }
549 }
550 };
551
552 // Footprint IDs are the most important, so give them the first crack at "claiming" a
553 // particular KIID.
554
555 for( FOOTPRINT* footprint : board()->Footprints() )
556 processItem( footprint );
557
558 // After that the principal use is for DRC marker pointers, which are most likely to pads
559 // or tracks.
560
561 for( FOOTPRINT* footprint : board()->Footprints() )
562 {
563 for( PAD* pad : footprint->Pads() )
564 processItem( pad );
565 }
566
567 for( PCB_TRACK* track : board()->Tracks() )
568 processItem( track );
569
570 // From here out I don't think order matters much.
571
572 for( FOOTPRINT* footprint : board()->Footprints() )
573 {
574 processItem( &footprint->Reference() );
575 processItem( &footprint->Value() );
576
577 for( BOARD_ITEM* item : footprint->GraphicalItems() )
578 processItem( item );
579
580 for( ZONE* zone : footprint->Zones() )
581 processItem( zone );
582
583 for( PCB_GROUP* group : footprint->Groups() )
584 processItem( group );
585 }
586
587 for( BOARD_ITEM* drawing : board()->Drawings() )
588 processItem( drawing );
589
590 for( ZONE* zone : board()->Zones() )
591 processItem( zone );
592
593 for( PCB_MARKER* marker : board()->Markers() )
594 processItem( marker );
595
596 for( PCB_GROUP* group : board()->Groups() )
597 processItem( group );
598
599 if( duplicates )
600 {
601 errors += duplicates;
602 details += wxString::Format( _( "%d duplicate IDs replaced.\n" ), duplicates );
603 }
604
605 /*******************************
606 * Your test here
607 */
608
609 /*******************************
610 * Inform the user
611 */
612
613 if( errors )
614 {
615 m_frame->OnModify();
616
617 wxString msg = wxString::Format( _( "%d potential problems repaired." ), errors );
618
619 if( !quiet )
620 DisplayInfoMessage( m_frame, msg, details );
621 }
622 else if( !quiet )
623 {
624 DisplayInfoMessage( m_frame, _( "No board problems found." ) );
625 }
626
627 return 0;
628}
629
630
632{
634
635 if( m_frame->FetchNetlistFromSchematic( netlist, _( "Updating PCB requires a fully annotated "
636 "schematic." ) ) )
637 {
638 DIALOG_UPDATE_PCB updateDialog( m_frame, &netlist );
639 updateDialog.ShowModal();
640 }
641
642 return 0;
643}
644
646{
647 if( Kiface().IsSingle() )
648 {
649 DisplayErrorMessage( m_frame, _( "Cannot update schematic because Pcbnew is opened in "
650 "stand-alone mode. In order to create or update PCBs "
651 "from schematics, you must launch the KiCad project "
652 "manager and create a project." ) );
653 return 0;
654 }
655
658
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{
676 wxString msg;
677 PCB_EDIT_FRAME* boardFrame = m_frame;
678 PROJECT& project = boardFrame->Prj();
679 wxFileName schematic( project.GetProjectPath(), project.GetProjectName(),
681
682 if( !schematic.FileExists() )
683 {
684 wxFileName legacySchematic( project.GetProjectPath(), project.GetProjectName(),
686
687 if( legacySchematic.FileExists() )
688 {
689 schematic = legacySchematic;
690 }
691 else
692 {
693 msg.Printf( _( "Schematic file '%s' not found." ), schematic.GetFullPath() );
695 return 0;
696 }
697 }
698
699 if( Kiface().IsSingle() )
700 {
701 ExecuteFile( EESCHEMA_EXE, schematic.GetFullPath() );
702 }
703 else
704 {
706
707 // Please: note: DIALOG_EDIT_LIBENTRY_FIELDS_IN_LIB::initBuffers() calls
708 // Kiway.Player( FRAME_SCH, true )
709 // therefore, the schematic editor is sometimes running, but the schematic project
710 // is not loaded, if the library editor was called, and the dialog field editor was used.
711 // On Linux, it happens the first time the schematic editor is launched, if
712 // library editor was running, and the dialog field editor was open
713 // On Windows, it happens always after the library editor was called,
714 // and the dialog field editor was used
715 if( !frame )
716 {
717 try
718 {
719 frame = boardFrame->Kiway().Player( FRAME_SCH, true );
720 }
721 catch( const IO_ERROR& err )
722 {
723
724 DisplayErrorMessage( boardFrame, _( "Eeschema failed to load." ) + wxS( "\n" ) + err.What() );
725 return 0;
726 }
727 }
728
729 wxEventBlocker blocker( boardFrame );
730
731 // If Kiway() cannot create the eeschema frame, it shows a error message, and
732 // frame is null
733 if( !frame )
734 return 0;
735
736 if( !frame->IsShownOnScreen() ) // the frame exists, (created by the dialog field editor)
737 // but no project loaded.
738 {
739 frame->OpenProjectFiles( std::vector<wxString>( 1, schematic.GetFullPath() ) );
740 frame->Show( true );
741 }
742
743 // On Windows, Raise() does not bring the window on screen, when iconized or not shown
744 // On Linux, Raise() brings the window on screen, but this code works fine
745 if( frame->IsIconized() )
746 {
747 frame->Iconize( false );
748
749 // If an iconized frame was created by Pcbnew, Iconize( false ) is not enough
750 // to show the frame at its normal size: Maximize should be called.
751 frame->Maximize( false );
752 }
753
754 frame->Raise();
755 }
756
757 return 0;
758}
759
760
762{
763 getEditFrame<PCB_EDIT_FRAME>()->ToggleLayersManager();
764 return 0;
765}
766
767
769{
770 getEditFrame<PCB_EDIT_FRAME>()->ToggleProperties();
771 return 0;
772}
773
774
776{
777 getEditFrame<PCB_EDIT_FRAME>()->ToggleNetInspector();
778 return 0;
779}
780
781
783{
784 getEditFrame<PCB_EDIT_FRAME>()->ToggleLibraryTree();
785 return 0;
786}
787
788
790{
791 getEditFrame<PCB_EDIT_FRAME>()->ToggleSearch();
792 return 0;
793}
794
795
797{
799 return 0;
800}
801
802
803// Track & via size control
805{
806 BOARD_DESIGN_SETTINGS& bds = getModel<BOARD>()->GetDesignSettings();
808
810 && SELECTION_CONDITIONS::OnlyTypes( { PCB_TRACE_T, PCB_ARC_T, PCB_VIA_T } )( selection ) )
811 {
812 BOARD_COMMIT commit( this );
813
814 for( EDA_ITEM* item : selection )
815 {
816 if( item->IsType( { PCB_TRACE_T, PCB_ARC_T } ) )
817 {
818 PCB_TRACK* track = static_cast<PCB_TRACK*>( item );
819
820 for( int i = 0; i < (int) bds.m_TrackWidthList.size(); ++i )
821 {
822 int candidate = bds.m_NetSettings->GetDefaultNetclass()->GetTrackWidth();
823
824 if( i > 0 )
825 candidate = bds.m_TrackWidthList[ i ];
826
827 if( candidate > track->GetWidth() )
828 {
829 commit.Modify( track );
830 track->SetWidth( candidate );
831 break;
832 }
833 }
834 }
835 }
836
837 commit.Push( _( "Increase Track Width" ) );
838 return 0;
839 }
840
841 ROUTER_TOOL* routerTool = m_toolMgr->GetTool<ROUTER_TOOL>();
842
843 if( routerTool && routerTool->IsToolActive()
844 && routerTool->Router()->Mode() == PNS::PNS_MODE_ROUTE_DIFF_PAIR )
845 {
846 int widthIndex = (int) bds.GetDiffPairIndex() + 1;
847
848 // If we go past the last track width entry in the list, start over at the beginning
849 if( widthIndex >= (int) bds.m_DiffPairDimensionsList.size() )
850 widthIndex = 0;
851
852 bds.SetDiffPairIndex( widthIndex );
853 bds.UseCustomDiffPairDimensions( false );
854
856 }
857 else
858 {
859 int widthIndex = (int) bds.GetTrackWidthIndex();
860
861 if( routerTool && routerTool->IsToolActive()
864 {
865 bds.m_TempOverrideTrackWidth = true;
866 }
867 else
868 {
869 widthIndex++;
870 }
871
872 // If we go past the last track width entry in the list, start over at the beginning
873 if( widthIndex >= (int) bds.m_TrackWidthList.size() )
874 widthIndex = 0;
875
876 bds.SetTrackWidthIndex( widthIndex );
877 bds.UseCustomTrackViaSize( false );
878
880 }
881
882 return 0;
883}
884
885
887{
888 BOARD_DESIGN_SETTINGS& bds = getModel<BOARD>()->GetDesignSettings();
890
892 && SELECTION_CONDITIONS::OnlyTypes( { PCB_TRACE_T, PCB_ARC_T, PCB_VIA_T } )( selection ) )
893 {
894 BOARD_COMMIT commit( this );
895
896 for( EDA_ITEM* item : selection )
897 {
898 if( item->IsType( { PCB_TRACE_T, PCB_ARC_T } ) )
899 {
900 PCB_TRACK* track = static_cast<PCB_TRACK*>( item );
901
902 for( int i = (int) bds.m_TrackWidthList.size() - 1; i >= 0; --i )
903 {
904 int candidate = bds.m_NetSettings->GetDefaultNetclass()->GetTrackWidth();
905
906 if( i > 0 )
907 candidate = bds.m_TrackWidthList[ i ];
908
909 if( candidate < track->GetWidth() )
910 {
911 commit.Modify( track );
912 track->SetWidth( candidate );
913 break;
914 }
915 }
916 }
917 }
918
919 commit.Push( _( "Decrease Track Width" ) );
920 return 0;
921 }
922
923 ROUTER_TOOL* routerTool = m_toolMgr->GetTool<ROUTER_TOOL>();
924
925 if( routerTool && routerTool->IsToolActive()
926 && routerTool->Router()->Mode() == PNS::PNS_MODE_ROUTE_DIFF_PAIR )
927 {
928 int widthIndex = (int) bds.GetDiffPairIndex() - 1;
929
930 // If we get to the lowest entry start over at the highest
931 if( widthIndex < 0 )
932 widthIndex = (int) bds.m_DiffPairDimensionsList.size() - 1;
933
934 bds.SetDiffPairIndex( widthIndex );
935 bds.UseCustomDiffPairDimensions( false );
936
938 }
939 else
940 {
941 int widthIndex = (int) bds.GetTrackWidthIndex();
942
943 if( routerTool && routerTool->IsToolActive()
946 {
947 bds.m_TempOverrideTrackWidth = true;
948 }
949 else
950 {
951 widthIndex--;
952 }
953
954 // If we get to the lowest entry start over at the highest
955 if( widthIndex < 0 )
956 widthIndex = (int) bds.m_TrackWidthList.size() - 1;
957
958 bds.SetTrackWidthIndex( widthIndex );
959 bds.UseCustomTrackViaSize( false );
960
962 }
963
964 return 0;
965}
966
967
969{
970 BOARD_DESIGN_SETTINGS& bds = getModel<BOARD>()->GetDesignSettings();
972
974 && SELECTION_CONDITIONS::OnlyTypes( { PCB_TRACE_T, PCB_ARC_T, PCB_VIA_T } )( selection ) )
975 {
976 BOARD_COMMIT commit( this );
977
978 for( EDA_ITEM* item : selection )
979 {
980 if( item->Type() == PCB_VIA_T )
981 {
982 PCB_VIA* via = static_cast<PCB_VIA*>( item );
983
984 for( int i = 0; i < (int) bds.m_ViasDimensionsList.size(); ++i )
985 {
986 VIA_DIMENSION dims( bds.m_NetSettings->GetDefaultNetclass()->GetViaDiameter(),
987 bds.m_NetSettings->GetDefaultNetclass()->GetViaDrill() );
988
989 if( i> 0 )
990 dims = bds.m_ViasDimensionsList[ i ];
991
992 // TODO(JE) padstacks
993 if( dims.m_Diameter > via->GetWidth( PADSTACK::ALL_LAYERS ) )
994 {
995 commit.Modify( via );
996 via->SetWidth( PADSTACK::ALL_LAYERS, dims.m_Diameter );
997 via->SetDrill( dims.m_Drill );
998 break;
999 }
1000 }
1001 }
1002 }
1003
1004 commit.Push( _( "Increase Via Size" ) );
1005 }
1006 else
1007 {
1008 int sizeIndex = (int) bds.GetViaSizeIndex() + 1;
1009
1010 // If we go past the last via entry in the list, start over at the beginning
1011 if( sizeIndex >= (int) bds.m_ViasDimensionsList.size() )
1012 sizeIndex = 0;
1013
1014 bds.SetViaSizeIndex( sizeIndex );
1015 bds.UseCustomTrackViaSize( false );
1016
1018 }
1019
1020 return 0;
1021}
1022
1023
1025{
1026 BOARD_DESIGN_SETTINGS& bds = getModel<BOARD>()->GetDesignSettings();
1028
1030 && SELECTION_CONDITIONS::OnlyTypes( { PCB_TRACE_T, PCB_ARC_T, PCB_VIA_T } )( selection ) )
1031 {
1032 BOARD_COMMIT commit( this );
1033
1034 for( EDA_ITEM* item : selection )
1035 {
1036 if( item->Type() == PCB_VIA_T )
1037 {
1038 PCB_VIA* via = static_cast<PCB_VIA*>( item );
1039
1040 for( int i = (int) bds.m_ViasDimensionsList.size() - 1; i >= 0; --i )
1041 {
1042 VIA_DIMENSION dims( bds.m_NetSettings->GetDefaultNetclass()->GetViaDiameter(),
1043 bds.m_NetSettings->GetDefaultNetclass()->GetViaDrill() );
1044
1045 if( i > 0 )
1046 dims = bds.m_ViasDimensionsList[ i ];
1047
1048 // TODO(JE) padstacks
1049 if( dims.m_Diameter < via->GetWidth( PADSTACK::ALL_LAYERS ) )
1050 {
1051 commit.Modify( via );
1052 via->SetWidth( PADSTACK::ALL_LAYERS, dims.m_Diameter );
1053 via->SetDrill( dims.m_Drill );
1054 break;
1055 }
1056 }
1057 }
1058 }
1059
1060 commit.Push( "Decrease Via Size" );
1061 }
1062 else
1063 {
1064 int sizeIndex = 0; // Assume we only have a single via size entry
1065
1066 // If there are more, cycle through them backwards
1067 if( bds.m_ViasDimensionsList.size() > 0 )
1068 {
1069 sizeIndex = (int) bds.GetViaSizeIndex() - 1;
1070
1071 // If we get to the lowest entry start over at the highest
1072 if( sizeIndex < 0 )
1073 sizeIndex = (int) bds.m_ViasDimensionsList.size() - 1;
1074 }
1075
1076 bds.SetViaSizeIndex( sizeIndex );
1077 bds.UseCustomTrackViaSize( false );
1078
1080 }
1081
1082 return 0;
1083}
1084
1085
1087{
1088 BOARD_DESIGN_SETTINGS& bds = getModel<BOARD>()->GetDesignSettings();
1089
1090 if( bds.UseCustomTrackViaSize() )
1091 {
1092 bds.UseCustomTrackViaSize( false );
1093 bds.m_UseConnectedTrackWidth = true;
1094 }
1095 else
1096 {
1098 }
1099
1100 return 0;
1101}
1102
1103
1105{
1106 if( m_inPlaceFootprint )
1107 return 0;
1108
1110
1111 FOOTPRINT* fp = aEvent.Parameter<FOOTPRINT*>();
1112 bool fromOtherCommand = fp != nullptr;
1114 BOARD_COMMIT commit( m_frame );
1115 BOARD* board = getModel<BOARD>();
1116 COMMON_SETTINGS* common_settings = Pgm().GetCommonSettings();
1117
1119
1120 m_frame->PushTool( aEvent );
1121
1122 auto setCursor =
1123 [&]()
1124 {
1125 m_frame->GetCanvas()->SetCurrentCursor( KICURSOR::PENCIL );
1126 };
1127
1128 auto cleanup =
1129 [&] ()
1130 {
1132 commit.Revert();
1133
1134 if( fromOtherCommand )
1135 {
1137
1138 if( undo )
1139 {
1142 delete undo;
1143 }
1144 }
1145
1146 fp = nullptr;
1147 m_placingFootprint = false;
1148 };
1149
1150 Activate();
1151 // Must be done after Activate() so that it gets set into the correct context
1152 controls->ShowCursor( true );
1153 // Set initial cursor
1154 setCursor();
1155
1156 VECTOR2I cursorPos = controls->GetCursorPosition();
1157 bool ignorePrimePosition = false;
1158 bool reselect = false;
1159
1160 // Prime the pump
1161 if( fp )
1162 {
1163 m_placingFootprint = true;
1164 fp->SetPosition( cursorPos );
1167 }
1168 else if( aEvent.HasPosition() )
1169 {
1170 m_toolMgr->PrimeTool( aEvent.Position() );
1171 }
1172 else if( common_settings->m_Input.immediate_actions && !aEvent.IsReactivate() )
1173 {
1174 m_toolMgr->PrimeTool( { 0, 0 } );
1175 ignorePrimePosition = true;
1176 }
1177
1178 // Main loop: keep receiving events
1179 while( TOOL_EVENT* evt = Wait() )
1180 {
1181 setCursor();
1182 cursorPos = controls->GetCursorPosition( !evt->DisableGridSnapping() );
1183
1184 if( reselect && fp )
1186
1187 if( evt->IsCancelInteractive() || ( fp && evt->IsAction( &ACTIONS::undo ) ) )
1188 {
1189 if( fp )
1190 {
1191 cleanup();
1192 }
1193 else
1194 {
1195 m_frame->PopTool( aEvent );
1196 break;
1197 }
1198 }
1199 else if( evt->IsActivate() )
1200 {
1201 if( fp )
1202 cleanup();
1203
1204 if( evt->IsMoveTool() )
1205 {
1206 // leave ourselves on the stack so we come back after the move
1207 break;
1208 }
1209 else
1210 {
1211 frame()->PopTool( aEvent );
1212 break;
1213 }
1214 }
1215 else if( evt->IsClick( BUT_LEFT ) )
1216 {
1217 if( !fp )
1218 {
1219 // Pick the footprint to be placed
1221
1222 if( fp == nullptr )
1223 continue;
1224
1225 // If we started with a hotkey which has a position then warp back to that.
1226 // Otherwise update to the current mouse position pinned inside the autoscroll
1227 // boundaries.
1228 if( evt->IsPrime() && !ignorePrimePosition )
1229 {
1230 cursorPos = evt->Position();
1231 getViewControls()->WarpMouseCursor( cursorPos, true );
1232 }
1233 else
1234 {
1236 cursorPos = getViewControls()->GetMousePosition();
1237 }
1238
1239 m_placingFootprint = true;
1240
1241 fp->SetLink( niluuid );
1242
1243 fp->SetFlags( IS_NEW ); // whatever
1244
1245 // Set parent so that clearance can be loaded
1246 fp->SetParent( board );
1248
1249 for( PAD* pad : fp->Pads() )
1250 {
1251 pad->SetLocalRatsnestVisible( m_frame->GetPcbNewSettings()->m_Display.m_ShowGlobalRatsnest );
1252
1253 // Pads in the library all have orphaned nets. Replace with Default.
1254 pad->SetNetCode( 0 );
1255 }
1256
1257 // Put it on FRONT layer,
1258 // (Can be stored flipped if the lib is an archive built from a board)
1259 if( fp->IsFlipped() )
1261
1262 fp->SetOrientation( ANGLE_0 );
1263 fp->SetPosition( cursorPos );
1264
1265 commit.Add( fp );
1267
1269 }
1270 else
1271 {
1273 commit.Push( _( "Place Footprint" ) );
1274 fp = nullptr; // to indicate that there is no footprint that we currently modify
1275 m_placingFootprint = false;
1276 }
1277 }
1278 else if( evt->IsClick( BUT_RIGHT ) )
1279 {
1280 m_menu->ShowContextMenu( selection() );
1281 }
1282 else if( fp && ( evt->IsMotion() || evt->IsAction( &ACTIONS::refreshPreview ) ) )
1283 {
1284 fp->SetPosition( cursorPos );
1285 selection().SetReferencePoint( cursorPos );
1286 getView()->Update( &selection() );
1287 getView()->Update( fp );
1288 }
1289 else if( fp && evt->IsAction( &PCB_ACTIONS::properties ) )
1290 {
1291 // Calling 'Properties' action clears the selection, so we need to restore it
1292 reselect = true;
1293 }
1294 else if( fp && ( ZONE_FILLER_TOOL::IsZoneFillAction( evt )
1295 || evt->IsAction( &ACTIONS::redo ) ) )
1296 {
1297 wxBell();
1298 }
1299 else
1300 {
1301 evt->SetPassEvent();
1302 }
1303
1304 // Enable autopanning and cursor capture only when there is a footprint to be placed
1305 controls->SetAutoPan( fp != nullptr );
1306 controls->CaptureCursor( fp != nullptr );
1307 }
1308
1309 controls->SetAutoPan( false );
1310 controls->CaptureCursor( false );
1311 m_frame->GetCanvas()->SetCurrentCursor( KICURSOR::ARROW );
1312
1313 return 0;
1314}
1315
1316
1318{
1319 return modifyLockSelected( TOGGLE );
1320}
1321
1322
1324{
1325 return modifyLockSelected( ON );
1326}
1327
1328
1330{
1331 return modifyLockSelected( OFF );
1332}
1333
1334
1336{
1338 const PCB_SELECTION& selection = selTool->GetSelection();
1339 BOARD_COMMIT commit( m_frame );
1340
1341 if( selection.Empty() )
1343
1344 // Resolve TOGGLE mode
1345 if( aMode == TOGGLE )
1346 {
1347 aMode = ON;
1348
1349 for( EDA_ITEM* item : selection )
1350 {
1351 if( !item->IsBOARD_ITEM() )
1352 continue;
1353
1354 if( static_cast<BOARD_ITEM*>( item )->IsLocked() )
1355 {
1356 aMode = OFF;
1357 break;
1358 }
1359 }
1360 }
1361
1362 for( EDA_ITEM* item : selection )
1363 {
1364 if( !item->IsBOARD_ITEM() )
1365 continue;
1366
1367 BOARD_ITEM* const board_item = static_cast<BOARD_ITEM*>( item );
1368
1369 // Disallow locking free pads - it's confusing and not persisted
1370 // through save/load anyway.
1371 if( board_item->Type() == PCB_PAD_T )
1372 continue;
1373
1374 EDA_GROUP* parent_group = board_item->GetParentGroup();
1375
1376 if( parent_group && parent_group->AsEdaItem()->Type() == PCB_GENERATOR_T )
1377 {
1378 PCB_GENERATOR* generator = static_cast<PCB_GENERATOR*>( parent_group );
1379
1380 if( generator && commit.GetStatus( generator ) != CHT_MODIFY )
1381 {
1382 commit.Modify( generator );
1383
1384 if( aMode == ON )
1385 generator->SetLocked( true );
1386 else
1387 generator->SetLocked( false );
1388 }
1389 }
1390
1391 commit.Modify( board_item );
1392
1393 if( aMode == ON )
1394 board_item->SetLocked( true );
1395 else
1396 board_item->SetLocked( false );
1397 }
1398
1399 if( !commit.Empty() )
1400 {
1401 commit.Push( aMode == ON ? _( "Lock" ) : _( "Unlock" ) );
1402
1404 m_frame->OnModify();
1405 }
1406
1407 return 0;
1408}
1409
1410
1411static bool mergeZones( EDA_DRAW_FRAME* aFrame, BOARD_COMMIT& aCommit,
1412 std::vector<ZONE*>& aOriginZones, std::vector<ZONE*>& aMergedZones )
1413{
1414 aCommit.Modify( aOriginZones[0] );
1415
1416 for( unsigned int i = 1; i < aOriginZones.size(); i++ )
1417 {
1418 aOriginZones[0]->Outline()->BooleanAdd( *aOriginZones[i]->Outline() );
1419 }
1420
1421 aOriginZones[0]->Outline()->Simplify();
1422
1423 // We should have one polygon, possibly with holes. If we end up with two polygons (either
1424 // because the intersection was a single point or because the intersection was within one of
1425 // the zone's holes) then we can't merge.
1426 if( aOriginZones[0]->Outline()->IsSelfIntersecting()
1427 || aOriginZones[0]->Outline()->OutlineCount() > 1 )
1428 {
1429 DisplayErrorMessage( aFrame, _( "Zones have insufficient overlap for merging." ) );
1430 aCommit.Revert();
1431 return false;
1432 }
1433
1434 for( unsigned int i = 1; i < aOriginZones.size(); i++ )
1435 aCommit.Remove( aOriginZones[i] );
1436
1437 aMergedZones.push_back( aOriginZones[0] );
1438
1439 aOriginZones[0]->SetLocalFlags( 1 );
1440 aOriginZones[0]->HatchBorder();
1441 aOriginZones[0]->CacheTriangulation();
1442
1443 return true;
1444}
1445
1446
1448{
1449 const PCB_SELECTION& selection = m_toolMgr->GetTool<PCB_SELECTION_TOOL>()->GetSelection();
1450 BOARD* board = getModel<BOARD>();
1451 BOARD_COMMIT commit( m_frame );
1452
1453 if( selection.Size() < 2 )
1454 return 0;
1455
1456 int netcode = -1;
1457
1458 ZONE* firstZone = nullptr;
1459 std::vector<ZONE*> toMerge, merged;
1460
1461 for( EDA_ITEM* item : selection )
1462 {
1463 ZONE* curr_area = dynamic_cast<ZONE*>( item );
1464
1465 if( !curr_area )
1466 continue;
1467
1468 if( !firstZone )
1469 firstZone = curr_area;
1470
1471 netcode = curr_area->GetNetCode();
1472
1473 if( firstZone->GetNetCode() != netcode )
1474 {
1475 wxLogMessage( _( "Some zone netcodes did not match and were not merged." ) );
1476 continue;
1477 }
1478
1479 if( curr_area->GetAssignedPriority() != firstZone->GetAssignedPriority() )
1480 {
1481 wxLogMessage( _( "Some zone priorities did not match and were not merged." ) );
1482 continue;
1483 }
1484
1485 if( curr_area->GetIsRuleArea() != firstZone->GetIsRuleArea() )
1486 {
1487 wxLogMessage( _( "Some zones were rule areas and were not merged." ) );
1488 continue;
1489 }
1490
1491 if( curr_area->GetLayerSet() != firstZone->GetLayerSet() )
1492 {
1493 wxLogMessage( _( "Some zone layer sets did not match and were not merged." ) );
1494 continue;
1495 }
1496
1497 bool intersects = curr_area == firstZone;
1498
1499 for( ZONE* candidate : toMerge )
1500 {
1501 if( intersects )
1502 break;
1503
1504 if( board->TestZoneIntersection( curr_area, candidate ) )
1505 intersects = true;
1506 }
1507
1508 if( !intersects )
1509 {
1510 wxLogMessage( _( "Some zones did not intersect and were not merged." ) );
1511 continue;
1512 }
1513
1514 toMerge.push_back( curr_area );
1515 }
1516
1518
1519 if( !toMerge.empty() )
1520 {
1521 if( mergeZones( m_frame, commit, toMerge, merged ) )
1522 {
1523 commit.Push( _( "Merge Zones" ) );
1524
1525 for( EDA_ITEM* item : merged )
1527 }
1528 }
1529
1530 return 0;
1531}
1532
1533
1535{
1537 const PCB_SELECTION& selection = selTool->GetSelection();
1538
1539 // because this pops up the zone editor, it would be confusing to handle multiple zones,
1540 // so just handle single selections containing exactly one zone
1541 if( selection.Size() != 1 )
1542 return 0;
1543
1544 ZONE* oldZone = dynamic_cast<ZONE*>( selection[0] );
1545
1546 if( !oldZone )
1547 return 0;
1548
1549 ZONE_SETTINGS zoneSettings;
1550 zoneSettings << *oldZone;
1551 int dialogResult;
1552
1553 if( oldZone->GetIsRuleArea() )
1554 dialogResult = InvokeRuleAreaEditor( m_frame, &zoneSettings, board() );
1555 else if( oldZone->IsOnCopperLayer() )
1556 dialogResult = InvokeCopperZonesEditor( m_frame, &zoneSettings );
1557 else
1558 dialogResult = InvokeNonCopperZonesEditor( m_frame, &zoneSettings );
1559
1560 if( dialogResult != wxID_OK )
1561 return 0;
1562
1563 // duplicate the zone
1564 BOARD_COMMIT commit( m_frame );
1565
1566 std::unique_ptr<ZONE> newZone = std::make_unique<ZONE>( *oldZone );
1567 newZone->ClearSelected();
1568 newZone->UnFill();
1569 zoneSettings.ExportSetting( *newZone );
1570
1571 // If the new zone is on the same layer(s) as the initial zone,
1572 // offset it a bit so it can more easily be picked.
1573 if( oldZone->GetLayerSet() == zoneSettings.m_Layers )
1574 newZone->Move( VECTOR2I( pcbIUScale.IU_PER_MM, pcbIUScale.IU_PER_MM ) );
1575
1576 commit.Add( newZone.release() );
1577 commit.Push( _( "Duplicate Zone" ) );
1578
1579 return 0;
1580}
1581
1582
1584{
1585 doCrossProbePcbToSch( aEvent, false );
1586 return 0;
1587}
1588
1589
1591{
1592 doCrossProbePcbToSch( aEvent, true );
1593 return 0;
1594}
1595
1596
1598{
1599 // Don't get in an infinite loop PCB -> SCH -> PCB -> SCH -> ...
1601 return;
1602
1604 const PCB_SELECTION& selection = selTool->GetSelection();
1605 EDA_ITEM* focusItem = nullptr;
1606
1607 if( aEvent.Matches( EVENTS::PointSelectedEvent ) )
1608 focusItem = selection.GetLastAddedItem();
1609
1610 m_frame->SendSelectItemsToSch( selection.GetItems(), focusItem, aForce );
1611
1612 // Update 3D viewer highlighting
1613 m_frame->Update3DView( false, frame()->GetPcbNewSettings()->m_Display.m_Live3DRefresh );
1614}
1615
1616
1618{
1620
1621 const PCB_SELECTION& selection = selectionTool->RequestSelection(
1622 []( const VECTOR2I& aPt, GENERAL_COLLECTOR& aCollector, PCB_SELECTION_TOOL* sTool )
1623 {
1624 // Iterate from the back so we don't have to worry about removals.
1625 for( int i = aCollector.GetCount() - 1; i >= 0; --i )
1626 {
1627 if( !dynamic_cast<BOARD_CONNECTED_ITEM*>( aCollector[ i ] ) )
1628 aCollector.Remove( aCollector[ i ] );
1629 }
1630 },
1631 true /* prompt user regarding locked items */ );
1632
1633 int netCode = -1;
1634 wxString netName;
1635
1636 for( EDA_ITEM* item : selection )
1637 {
1638 NETINFO_ITEM* net = static_cast<BOARD_CONNECTED_ITEM*>( item )->GetNet();
1639
1640 if( !net->HasAutoGeneratedNetname() )
1641 {
1642 netCode = net->GetNetCode();
1643 netName = net->GetNetname();
1644 break;
1645 }
1646 }
1647
1648 if( netName.IsEmpty() )
1649 {
1650 m_frame->ShowInfoBarError( _( "Selection contains no items with labeled nets." ) );
1651 return 0;
1652 }
1653
1654 selectionTool->ClearSelection();
1656 canvas()->ForceRefresh();
1657
1658 DIALOG_ASSIGN_NETCLASS dlg( m_frame, netName, board()->GetNetClassAssignmentCandidates(),
1659 [this]( const std::vector<wxString>& aNetNames )
1660 {
1662 selTool->ClearSelection();
1663
1664 for( const wxString& curr_netName : aNetNames )
1665 {
1666 int curr_netCode = board()->GetNetInfo().GetNetItem( curr_netName )->GetNetCode();
1667
1668 if( curr_netCode > 0 )
1669 selTool->SelectAllItemsOnNet( curr_netCode );
1670 }
1671
1672 canvas()->ForceRefresh();
1674 } );
1675
1676 if( dlg.ShowModal() == wxID_OK )
1677 {
1679 // Refresh UI that depends on netclasses, such as the properties panel
1681 }
1682
1683 return 0;
1684}
1685
1686
1688{
1691
1692 if( selection.Empty() )
1693 {
1694 // Giant hack: by default we assign Edit Table to the same hotkey, so give the table
1695 // tool a chance to handle it if we can't.
1697 tableTool->EditTable( aEvent );
1698
1699 return 0;
1700 }
1701
1703
1704 if( !fp )
1705 return 0;
1706
1707 PCB_BASE_EDIT_FRAME* editFrame = getEditFrame<PCB_BASE_EDIT_FRAME>();
1708
1709 if( KIWAY_PLAYER* frame = editFrame->Kiway().Player( FRAME_FOOTPRINT_EDITOR, true ) )
1710 {
1711 FOOTPRINT_EDIT_FRAME* fp_editor = static_cast<FOOTPRINT_EDIT_FRAME*>( frame );
1712
1714 fp_editor->LoadFootprintFromBoard( fp );
1715 else if( aEvent.IsAction( &PCB_ACTIONS::editLibFpInFpEditor ) )
1716 fp_editor->LoadFootprintFromLibrary( fp->GetFPID() );
1717
1718 fp_editor->Show( true );
1719 fp_editor->Raise(); // Iconize( false );
1720 }
1721
1722 if( selection.IsHover() )
1724
1725 return 0;
1726}
1727
1728
1730 EDA_ITEM* originViewItem, const VECTOR2D& aPosition )
1731{
1732 aFrame->GetDesignSettings().SetAuxOrigin( VECTOR2I( aPosition ) );
1733 originViewItem->SetPosition( aPosition );
1734 aView->MarkDirty();
1735 aFrame->OnModify();
1736}
1737
1738
1740{
1742 {
1743 m_frame->SaveCopyInUndoList( m_placeOrigin.get(), UNDO_REDO::GRIDORIGIN );
1745 return 0;
1746 }
1747
1748 if( aEvent.IsAction( &PCB_ACTIONS::drillSetOrigin ) )
1749 {
1750 VECTOR2I origin = aEvent.Parameter<VECTOR2I>();
1751 m_frame->SaveCopyInUndoList( m_placeOrigin.get(), UNDO_REDO::GRIDORIGIN );
1752 DoSetDrillOrigin( getView(), m_frame, m_placeOrigin.get(), origin );
1753 return 0;
1754 }
1755
1757
1758 // Deactivate other tools; particularly important if another PICKER is currently running
1759 Activate();
1760
1761 picker->SetClickHandler(
1762 [this] ( const VECTOR2D& pt ) -> bool
1763 {
1764 m_frame->SaveCopyInUndoList( m_placeOrigin.get(), UNDO_REDO::DRILLORIGIN );
1766 return false; // drill origin is a one-shot; don't continue with tool
1767 } );
1768
1770
1771 return 0;
1772}
1773
1774
1776{
1785
1790
1799
1800 if( ADVANCED_CFG::GetCfg().m_ShowPcbnewExportNetlist && m_frame
1802 {
1804 }
1805
1814
1821
1822 // Track & via size control
1828
1829 // Zone actions
1832
1833 // Placing tools
1838
1841
1842 // Cross-select
1848
1849 // Other
1853
1855
1866}
1867
const char * name
Definition: DXF_plotter.cpp:62
constexpr EDA_IU_SCALE pcbIUScale
Definition: base_units.h:112
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:257
static TOOL_ACTION cancelInteractive
Definition: actions.h:72
static TOOL_ACTION revert
Definition: actions.h:62
static TOOL_ACTION selectItem
Select an item (specified as the event parameter).
Definition: actions.h:220
static TOOL_ACTION saveAs
Definition: actions.h:59
static TOOL_ACTION selectionCursor
Select a single item under the cursor position.
Definition: actions.h:214
static TOOL_ACTION pickerTool
Definition: actions.h:246
static TOOL_ACTION findPrevious
Definition: actions.h:119
static TOOL_ACTION plot
Definition: actions.h:65
static TOOL_ACTION open
Definition: actions.h:57
static TOOL_ACTION findNext
Definition: actions.h:118
static TOOL_ACTION pageSettings
Definition: actions.h:63
static TOOL_ACTION showSearch
Definition: actions.h:115
static TOOL_ACTION undo
Definition: actions.h:75
static TOOL_ACTION save
Definition: actions.h:58
static TOOL_ACTION redo
Definition: actions.h:76
static TOOL_ACTION updateSchematicFromPcb
Definition: actions.h:258
static TOOL_ACTION selectionClear
Clear the current selection.
Definition: actions.h:217
static TOOL_ACTION showProperties
Definition: actions.h:259
static TOOL_ACTION doNew
Definition: actions.h:54
static TOOL_ACTION saveCopy
Definition: actions.h:60
static TOOL_ACTION refreshPreview
Definition: actions.h:156
static TOOL_ACTION find
Definition: actions.h:116
Define 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
Creator of the menu.
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
Execute the changes.
virtual void Revert() override
Revert the commit by restoring the modified items state.
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)
int GenBOMFileFromBoard(const TOOL_EVENT &aEvent)
int RescueAutosave(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 ExportFootprints(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 ExportHyperlynx(const TOOL_EVENT &aEvent)
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 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 ExportFootprintsAs(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)
int GenerateODBPPFiles(const TOOL_EVENT &aEvent)
int ToggleLockSelected(const TOOL_EVENT &aEvent)
Lock selected items.
int AutoTrackWidth(const TOOL_EVENT &aEvent)
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 ToggleLibraryTree(const TOOL_EVENT &aEvent)
int ExportGenCAD(const TOOL_EVENT &aEvent)
Export GenCAD 1.4 format.
int ViaSizeInc(const TOOL_EVENT &aEvent)
int New(const TOOL_EVENT &aEvent)
int ExportCmpFile(const TOOL_EVENT &aEvent)
int Find(const TOOL_EVENT &aEvent)
int GenFootprintsReport(const TOOL_EVENT &aEvent)
void doCrossProbePcbToSch(const TOOL_EVENT &aEvent, bool aForce)
int GenD356File(const TOOL_EVENT &aEvent)
int Plot(const TOOL_EVENT &aEvent)
int ExportIDF(const TOOL_EVENT &aEvent)
int TrackWidthDec(const TOOL_EVENT &aEvent)
int Revert(const TOOL_EVENT &aEvent)
int Search(const TOOL_EVENT &aEvent)
int GenIPC2581File(const TOOL_EVENT &aEvent)
int ExportVRML(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 GenerateGerbers(const TOOL_EVENT &aEvent)
int ToggleProperties(const TOOL_EVENT &aEvent)
int OpenNonKicadBoard(const TOOL_EVENT &aEvent)
int ExportSTEP(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:79
void SetLocked(bool aLocked) override
Definition: board_item.h:326
Information pertinent to a Pcbnew printed circuit board.
Definition: board.h:317
const NETINFO_LIST & GetNetInfo() const
Definition: board.h:922
EMBEDDED_FILES * GetEmbeddedFiles() override
Definition: board.cpp:2577
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_MODE::INSERT, bool aSkipConnectivity=false) override
Removes an item from the container.
Definition: board.cpp:1060
void UpdateUserUnits(BOARD_ITEM *aItem, KIGFX::VIEW *aView)
Update any references within aItem (or its descendants) to the user units.
Definition: board.cpp:1410
NETINFO_ITEM * FindNet(int aNetcode) const
Search for a net with the given netcode.
Definition: board.cpp:2014
void SynchronizeNetsAndNetClasses(bool aResetTrackAndViaSizes)
Copy NETCLASS info to each NET, based on NET membership in a NETCLASS.
Definition: board.cpp:2153
const wxString & GetFileName() const
Definition: board.h:354
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:82
void Remove(int aIndex)
Remove the item at aIndex (first position is 0).
Definition: collector.h:110
COMMIT & Remove(EDA_ITEM *aItem, BASE_SCREEN *aScreen=nullptr)
Remove a new item from the model.
Definition: commit.h:91
bool Empty() const
Definition: commit.h:150
COMMIT & Modify(EDA_ITEM *aItem, BASE_SCREEN *aScreen=nullptr, RECURSE_MODE aRecurse=RECURSE_MODE::NO_RECURSE)
Modify a given item in the model.
Definition: commit.h:107
COMMIT & Add(EDA_ITEM *aItem, BASE_SCREEN *aScreen=nullptr)
Add a new item to the model.
Definition: commit.h:79
int GetStatus(EDA_ITEM *aItem, BASE_SCREEN *aScreen=nullptr)
Returns status of an item.
Definition: commit.cpp:122
Store all of the related footprint information found in a netlist.
Definition: pcb_netlist.h:100
void SetFields(nlohmann::ordered_map< wxString, wxString > &aFields)
Definition: pcb_netlist.h:148
void AddNet(const wxString &aPinName, const wxString &aNetName, const wxString &aPinFunction, const wxString &aPinType)
Definition: pcb_netlist.h:120
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)
A dialog to set the plot options and create plot files in various formats.
Definition: dialog_plot.h:41
int ShowQuasiModal()
int ShowModal() override
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()
Toggle 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 set of EDA_ITEMs (i.e., without duplicates).
Definition: eda_group.h:46
virtual EDA_ITEM * AsEdaItem()=0
A base class for most all the KiCad significant classes used in schematics and boards.
Definition: eda_item.h:97
virtual void SetPosition(const VECTOR2I &aPos)
Definition: eda_item.h:260
void SetFlags(EDA_ITEM_FLAGS aMask)
Definition: eda_item.h:141
virtual EDA_GROUP * GetParentGroup() const
Definition: eda_item.h:115
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:109
virtual void SetParent(EDA_ITEM *aParent)
Definition: eda_item.h:112
A mix-in class (via multiple inheritance) that handles texts such as labels, parts,...
Definition: eda_text.h:79
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:3148
static const TOOL_EVENT ClearedEvent
Definition: actions.h:340
static const TOOL_EVENT SelectedEvent
Definition: actions.h:338
static const TOOL_EVENT SelectedItemsModified
Selected items were moved, this can be very high frequency on the canvas, use with care.
Definition: actions.h:345
static const TOOL_EVENT PointSelectedEvent
Definition: actions.h:337
static const TOOL_EVENT UnselectedEvent
Definition: actions.h:339
Used for text file output.
Definition: richio.h:491
void LoadFootprintFromLibrary(LIB_ID aFPID)
bool LoadFootprintFromBoard(FOOTPRINT *aFootprint)
Load a footprint from the main board into the Footprint Editor.
void SetPosition(const VECTOR2I &aPos) override
Definition: footprint.cpp:2457
void SetLink(const KIID &aLink)
Definition: footprint.h:842
ZONES & Zones()
Definition: footprint.h:215
void SetOrientation(const EDA_ANGLE &aNewAngle)
Definition: footprint.cpp:2539
PCB_FIELD & Value()
read/write accessors:
Definition: footprint.h:661
std::deque< PAD * > & Pads()
Definition: footprint.h:209
bool IsFlipped() const
Definition: footprint.h:400
const LIB_ID & GetFPID() const
Definition: footprint.h:251
PCB_FIELD & Reference()
Definition: footprint.h:662
void Flip(const VECTOR2I &aCentre, FLIP_DIRECTION aFlipDirection) override
Flip this object, i.e.
Definition: footprint.cpp:2398
GROUPS & Groups()
Definition: footprint.h:218
void GetFields(std::vector< PCB_FIELD * > &aVector, bool aVisibleOnly) const
Populate a std::vector with PCB_TEXTs.
Definition: footprint.cpp:634
const wxString & GetValue() const
Definition: footprint.h:647
const wxString & GetReference() const
Definition: footprint.h:625
const KIID_PATH & GetPath() const
Definition: footprint.h:266
VECTOR2I GetPosition() const override
Definition: footprint.h:227
DRAWINGS & GraphicalItems()
Definition: footprint.h:212
Used when the right click button is pressed, or when the select tool is in effect.
Definition: collectors.h:202
Hold an error message and may be used when throwing exceptions containing meaningful error messages.
Definition: ki_exception.h:77
virtual const wxString What() const
A composite of Problem() and Where()
Definition: exceptions.cpp:30
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:86
Hold a (potentially large) number of VIEW_ITEMs and renders them on a graphics device provided by the...
Definition: view.h:67
virtual void Add(VIEW_ITEM *aItem, int aDrawPriority=-1)
Add a VIEW_ITEM to the view.
Definition: view.cpp:297
virtual void Remove(VIEW_ITEM *aItem)
Remove a VIEW_ITEM from the view.
Definition: view.cpp:332
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:1675
void MarkDirty()
Force redraw of view on the next rendering.
Definition: view.h:655
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:1561
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:65
virtual KIWAY_PLAYER * Player(FRAME_T aFrameType, bool doCreate=true, wxTopLevelWindow *aParent=nullptr)
Return the KIWAY_PLAYER* given a FRAME_T.
Definition: kiway.cpp:395
virtual void ExpressMail(FRAME_T aDestination, MAIL_T aCommand, std::string &aPayload, wxWindow *aSource=nullptr)
Send aPayload to aDestination from aSource.
Definition: kiway.cpp:499
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:274
static constexpr PCB_LAYER_ID ALL_LAYERS
! Temporary layer identifier to identify code that is not padstack-aware
Definition: padstack.h:144
Definition: pad.h:54
DISPLAY_OPTIONS m_Display
FLIP_DIRECTION m_FlipDirection
static TOOL_ACTION zonesManager
Definition: pcb_actions.h:455
static TOOL_ACTION generateBOM
Definition: pcb_actions.h:424
static TOOL_ACTION exportGenCAD
Definition: pcb_actions.h:426
static TOOL_ACTION zoneFillAll
Definition: pcb_actions.h:392
static TOOL_ACTION showLayersManager
Definition: pcb_actions.h:452
static TOOL_ACTION trackWidthDec
Definition: pcb_actions.h:380
static TOOL_ACTION generateDrillFiles
Definition: pcb_actions.h:418
static TOOL_ACTION exportVRML
Definition: pcb_actions.h:427
static TOOL_ACTION generateD356File
Definition: pcb_actions.h:423
static TOOL_ACTION exportCmpFile
Definition: pcb_actions.h:430
static TOOL_ACTION trackViaSizeChanged
Definition: pcb_actions.h:386
static TOOL_ACTION exportSpecctraDSN
Definition: pcb_actions.h:415
static TOOL_ACTION trackWidthInc
Definition: pcb_actions.h:379
static TOOL_ACTION autoTrackWidth
Definition: pcb_actions.h:384
static TOOL_ACTION generateIPC2581File
Definition: pcb_actions.h:421
static TOOL_ACTION getAndPlace
Find an item and start moving.
Definition: pcb_actions.h:583
static TOOL_ACTION generateODBPPFile
Definition: pcb_actions.h:422
static TOOL_ACTION drawZoneCutout
Definition: pcb_actions.h:212
static TOOL_ACTION openNonKicadBoard
Definition: pcb_actions.h:407
static TOOL_ACTION viaSizeDec
Definition: pcb_actions.h:382
static TOOL_ACTION zoneFill
Definition: pcb_actions.h:391
static TOOL_ACTION properties
Activation of the edit tool.
Definition: pcb_actions.h:168
static TOOL_ACTION editFpInFpEditor
Definition: pcb_actions.h:449
static TOOL_ACTION toggleLock
Definition: pcb_actions.h:543
static TOOL_ACTION drillResetOrigin
Definition: pcb_actions.h:552
static TOOL_ACTION viaSizeInc
Definition: pcb_actions.h:381
static TOOL_ACTION zoneUnfill
Definition: pcb_actions.h:394
static TOOL_ACTION generatePosFile
Definition: pcb_actions.h:419
static TOOL_ACTION drillOrigin
Definition: pcb_actions.h:551
static TOOL_ACTION assignNetClass
Definition: pcb_actions.h:388
static TOOL_ACTION repairBoard
Definition: pcb_actions.h:557
static TOOL_ACTION exportSTEP
Definition: pcb_actions.h:429
static TOOL_ACTION showNetInspector
Definition: pcb_actions.h:453
static TOOL_ACTION generateGerbers
Definition: pcb_actions.h:417
static TOOL_ACTION generateReportFile
Definition: pcb_actions.h:420
static TOOL_ACTION exportHyperlynx
Definition: pcb_actions.h:431
static TOOL_ACTION exportIDF
Definition: pcb_actions.h:428
static TOOL_ACTION zoneDuplicate
Duplicate zone onto another layer.
Definition: pcb_actions.h:399
static TOOL_ACTION importNetlist
Definition: pcb_actions.h:412
static TOOL_ACTION drawSimilarZone
Definition: pcb_actions.h:213
static TOOL_ACTION boardSetup
Definition: pcb_actions.h:410
static TOOL_ACTION showEeschema
Definition: pcb_actions.h:554
static TOOL_ACTION showDesignBlockPanel
Definition: pcb_actions.h:461
static TOOL_ACTION zoneUnfillAll
Definition: pcb_actions.h:395
static TOOL_ACTION selectNet
Select all connections belonging to a single net.
Definition: pcb_actions.h:82
static TOOL_ACTION editLibFpInFpEditor
Definition: pcb_actions.h:450
static TOOL_ACTION zoneMerge
Definition: pcb_actions.h:396
static TOOL_ACTION drillSetOrigin
Definition: pcb_actions.h:553
static TOOL_ACTION unlock
Definition: pcb_actions.h:545
static TOOL_ACTION exportFootprints
Definition: pcb_actions.h:408
static TOOL_ACTION placeFootprint
Definition: pcb_actions.h:216
static TOOL_ACTION showPythonConsole
Definition: pcb_actions.h:454
static TOOL_ACTION exportFootprintsAs
Definition: pcb_actions.h:409
static TOOL_ACTION rescueAutosave
Definition: pcb_actions.h:406
static TOOL_ACTION importSpecctraSession
Definition: pcb_actions.h:414
static TOOL_ACTION selectOnSchematic
Select symbols/pins on schematic corresponding to selected footprints/pads.
Definition: pcb_actions.h:100
static TOOL_ACTION lock
Definition: pcb_actions.h:544
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:164
void ClearListAndDeleteItems(PICKED_ITEMS_LIST *aList)
Definition: undo_redo.cpp:658
void RollbackFromUndo()
Perform an undo of the last edit without logging a corresponding redo.
Definition: undo_redo.cpp:671
void PutDataInPreviousState(PICKED_ITEMS_LIST *aList)
Used in undo or redo command.
Definition: undo_redo.cpp:263
Base PCB main window class for Pcbnew, Gerbview, and CvPcb footprint viewer.
virtual const PCB_PLOT_PARAMS & GetPlotSettings() const
Return the PCB_PLOT_PARAMS for the BOARD owned by this frame.
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
Return the BOARD_DESIGN_SETTINGS for the open project.
virtual void SetPlotSettings(const PCB_PLOT_PARAMS &aSettings)
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.
The main frame for Pcbnew.
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 OnModify() override
Must be called after a board change to set the modified flag.
bool SaveBoard(bool aSaveAs=false, bool aSaveCopy=false)
void ExportFootprintsToLibrary(bool aStoreInNewLib, const wxString &aLibName=wxEmptyString, wxString *aLibPath=nullptr)
Save footprints in a library:
wxString GetLastPath(LAST_PATH_TYPE aType)
Get the last path for a particular type.
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...
A set of BOARD_ITEMs (i.e., without duplicates).
Definition: pcb_group.h:53
void SetLocked(bool aLocked) override
Definition: pcb_group.cpp:130
Generic tool for picking an item.
Parameters and options when plotting/printing a board.
void SetFormat(PLOT_FORMAT aFormat)
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.
T * frame() const
KIGFX::VIEW_CONTROLS * controls() const
BOARD * board() const
PCB_DRAW_PANEL_GAL * canvas() const
const PCB_SELECTION & selection() const
FOOTPRINT * footprint() const
virtual void SetWidth(int aWidth)
Definition: pcb_track.h:145
virtual int GetWidth() const
Definition: pcb_track.h:146
virtual COMMON_SETTINGS * GetCommonSettings() const
Definition: pgm_base.cpp:556
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:73
ROUTER_MODE Mode() const
Definition: pns_router.h:150
RouterState GetState() const
Definition: pns_router.h:152
ROUTER * Router() const
Container for project specific data.
Definition: project.h:65
virtual const wxString GetProjectFullName() const
Return the full path and name of the project.
Definition: project.cpp:142
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:188
const std::deque< EDA_ITEM * > GetItems() const
Definition: selection.h:121
EDA_ITEM * GetLastAddedItem() const
Definition: selection.h:126
bool IsHover() const
Definition: selection.h:84
int Size() const
Returns the number of selected parts.
Definition: selection.h:116
void SetReferencePoint(const VECTOR2I &aP)
Definition: selection.cpp:178
bool Empty() const
Checks if there is anything selected.
Definition: selection.h:110
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:44
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:220
KIGFX::VIEW * getView() const
Returns the instance of #VIEW object used in the application.
Definition: tool_base.cpp:38
bool IsToolActive() const
Definition: tool_base.cpp:32
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:168
bool HasPosition() const
Returns if it this event has a valid position (true for mouse events and context-menu or hotkey-based...
Definition: tool_event.h:257
bool Matches(const TOOL_EVENT &aEvent) const
Test whether two events match in terms of category & action or command.
Definition: tool_event.h:389
const VECTOR2D Position() const
Return mouse cursor position in world coordinates.
Definition: tool_event.h:290
bool IsReactivate() const
Control whether the tool is first being pushed to the stack or being reactivated after a pause.
Definition: tool_event.h:270
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:465
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()
std::unique_ptr< 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:150
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:235
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
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:88
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:74
bool GetIsRuleArea() const
Accessors to parameters used in Rule Area zones:
Definition: zone.h:699
virtual LSET GetLayerSet() const override
Return a std::bitset of all layers on which the item physically resides.
Definition: zone.h:136
bool IsOnCopperLayer() const override
Definition: zone.cpp:500
unsigned GetAssignedPriority() const
Definition: zone.h:126
@ CHT_MODIFY
Definition: commit.h:45
void DisplayInfoMessage(wxWindow *aParent, const wxString &aMessage, const wxString &aExtraInfo)
Display an informational message box with aMessage.
Definition: confirm.cpp:231
void DisplayErrorMessage(wxWindow *aParent, const wxString &aText, const wxString &aExtraInfo)
Display an error message with aMessage.
Definition: confirm.cpp:203
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, BOARD *aBoard, 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:404
#define IS_NEW
New item, just created.
KiCad executable names.
const wxString EESCHEMA_EXE
@ FRAME_SCH
Definition: frame_type.h:34
@ FRAME_FOOTPRINT_EDITOR
Definition: frame_type.h:43
int ExecuteFile(const wxString &aEditorName, const wxString &aFileName, wxProcess *aCallback, bool aFileForKicad)
Call the executable file aEditorName with the parameter aFileName.
Definition: gestfich.cpp:143
static const std::string LegacySchematicFileExtension
static const std::string KiCadSchematicFileExtension
static const std::string SpecctraDsnFileExtension
static const std::string SpecctraSessionFileExtension
static wxString SpecctraSessionFileWildcard()
static wxString SpecctraDsnFileWildcard()
KIID niluuid(0)
@ MAIL_SCH_UPDATE
Definition: mail_type.h:47
@ REPAINT
Item needs to be redrawn.
Definition: view_item.h:58
@ GEOMETRY
Position or shape has changed.
Definition: view_item.h:55
@ PNS_MODE_ROUTE_DIFF_PAIR
Definition: pns_router.h:64
#define MAX_PAGE_SIZE_PCBNEW_MILS
Definition: page_info.h:39
PGM_BASE & Pgm()
The global program "get" accessor.
Definition: pgm_base.cpp:893
see class PGM_BASE
@ LAST_PATH_SPECCTRADSN
Definition: project_file.h:56
std::vector< FAB_LAYER_COLOR > dummy
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...
@ BUT_LEFT
Definition: tool_event.h:132
@ BUT_RIGHT
Definition: tool_event.h:133
@ PCB_GENERATOR_T
class PCB_GENERATOR, generator on a layer
Definition: typeinfo.h:91
@ 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
@ PCB_PAD_T
class PAD, a pad in a footprint
Definition: typeinfo.h:87
VECTOR2< int32_t > VECTOR2I
Definition: vector2d.h:695
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.