KiCad PCB EDA Suite
Loading...
Searching...
No Matches
pcb_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-2016 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
26#include "pcb_control.h"
28
29#include <kiplatform/ui.h>
30#include <tools/edit_tool.h>
32#include <router/router_tool.h>
33#include <pgm_base.h>
34#include <tools/pcb_actions.h>
39#include <board_commit.h>
40#include <board.h>
42#include <board_item.h>
44#include <clipboard.h>
45#include <design_block.h>
47#include <pcb_dimension.h>
51#include <footprint.h>
52#include <layer_pairs.h>
53#include <pcb_group.h>
55#include <pcb_reference_image.h>
56#include <pcb_textbox.h>
57#include <pcb_track.h>
58#include <pcb_generator.h>
59#include <project_pcb.h>
61#include <filename_resolver.h>
62#include <3d_cache/3d_cache.h>
63#include <embedded_files.h>
64#include <wx/filename.h>
65#include <zone.h>
66#include <confirm.h>
67#include <kidialog.h>
69#include <core/kicad_algo.h>
71#include <kicad_clipboard.h>
72#include <origin_viewitem.h>
73#include <pcb_edit_frame.h>
74#include <pcb_painter.h>
76#include <string>
77#include <tool/tool_manager.h>
85#include <widgets/wx_infobar.h>
86#include <wx/hyperlink.h>
87
88
89using namespace std::placeholders;
90
91
92// files.cpp
93extern bool AskLoadBoardFileName( PCB_EDIT_FRAME* aParent, wxString* aFileName, int aCtl = 0 );
94
95
97 PCB_TOOL_BASE( "pcbnew.Control" ),
98 m_frame( nullptr ),
99 m_pickerItem( nullptr )
100{
102}
103
104
108
109
111{
113
114 if( aReason == MODEL_RELOAD || aReason == GAL_SWITCH || aReason == REDRAW )
115 {
116 m_gridOrigin->SetPosition( board()->GetDesignSettings().GetGridOrigin() );
117
118 double backgroundBrightness = m_frame->GetCanvas()->GetGAL()->GetClearColor().GetBrightness();
119 COLOR4D color = m_frame->GetGridColor();
120
121 if( backgroundBrightness > 0.5 )
122 color.Darken( 0.25 );
123 else
124 color.Brighten( 0.25 );
125
126 m_gridOrigin->SetColor( color );
127
128 getView()->Remove( m_gridOrigin.get() );
129 getView()->Add( m_gridOrigin.get() );
130 }
131}
132
133
135{
136 if( m_frame->IsType( FRAME_FOOTPRINT_EDITOR ) || m_frame->IsType( FRAME_PCB_EDITOR ) )
137 {
138 if( aEvent.IsAction( &ACTIONS::newLibrary ) )
139 static_cast<PCB_BASE_EDIT_FRAME*>( m_frame )->CreateNewLibrary( _( "New Footprint Library" ) );
140 else if( aEvent.IsAction( &ACTIONS::addLibrary ) )
141 static_cast<PCB_BASE_EDIT_FRAME*>( m_frame )->AddLibrary( _( "Add Footprint Library" ) );
142 }
143
144 return 0;
145}
146
147
149{
150 if( m_frame->IsType( FRAME_FOOTPRINT_EDITOR ) )
151 static_cast<FOOTPRINT_EDIT_FRAME*>( m_frame )->LoadFootprintFromBoard( nullptr );
152
153 return 0;
154}
155
156
158{
159 if( m_frame->IsType( FRAME_FOOTPRINT_EDITOR ) )
160 static_cast<FOOTPRINT_EDIT_FRAME*>( m_frame )->SaveFootprintToBoard( true );
161 else if( m_frame->IsType( FRAME_FOOTPRINT_VIEWER ) )
162 static_cast<FOOTPRINT_VIEWER_FRAME*>( m_frame )->AddFootprintToPCB();
163
164 return 0;
165}
166
167
169{
170 const wxString fn = *aEvent.Parameter<wxString*>();
171 static_cast<PCB_BASE_EDIT_FRAME*>( m_frame )->AddLibrary( _( "Add Footprint Library" ), fn,
173 return 0;
174}
175
176
178{
179 const wxString fn = *aEvent.Parameter<wxString*>();
180 static_cast<FOOTPRINT_EDIT_FRAME*>( m_frame )->ImportFootprint( fn );
181 m_frame->Zoom_Automatique( false );
182 return 0;
183}
184
185
187{
188 if( m_frame->IsType( FRAME_FOOTPRINT_VIEWER ) )
189 static_cast<FOOTPRINT_VIEWER_FRAME*>( m_frame )->SelectAndViewFootprint( aEvent.Parameter<FPVIEWER_CONSTANTS>() );
190
191 return 0;
192}
193
194
195int PCB_CONTROL::Quit( const TOOL_EVENT& aEvent )
196{
197 m_frame->Close( false );
198 return 0;
199}
200
201
202template<class T> void Flip( T& aValue )
203{
204 aValue = !aValue;
205}
206
207
209{
210 Flip( displayOptions().m_DisplayPcbTrackFill );
211
212 for( PCB_TRACK* track : board()->Tracks() )
213 {
214 if( track->Type() == PCB_TRACE_T || track->Type() == PCB_ARC_T )
215 view()->Update( track, KIGFX::REPAINT );
216 }
217
218 for( BOARD_ITEM* shape : board()->Drawings() )
219 {
220 if( shape->Type() == PCB_SHAPE_T && static_cast<PCB_SHAPE*>( shape )->IsOnCopperLayer() )
221 view()->Update( shape, KIGFX::REPAINT );
222 }
223
224 canvas()->Refresh();
225
226 return 0;
227}
228
229
231{
232 if( PCB_EDIT_FRAME* editFrame = dynamic_cast<PCB_EDIT_FRAME*>( m_frame ) )
233 {
234 if( aEvent.IsAction( &PCB_ACTIONS::showRatsnest ) )
235 {
236 // N.B. Do not disable the Ratsnest layer here. We use it for local ratsnest
237 Flip( displayOptions().m_ShowGlobalRatsnest );
238 editFrame->SetElementVisibility( LAYER_RATSNEST, displayOptions().m_ShowGlobalRatsnest );
239
240 }
241 else if( aEvent.IsAction( &PCB_ACTIONS::ratsnestLineMode ) )
242 {
243 Flip( displayOptions().m_DisplayRatsnestLinesCurved );
244 }
245
246 editFrame->OnDisplayOptionsChanged();
247
249 canvas()->Refresh();
250 }
251
252 return 0;
253}
254
255
257{
258 Flip( displayOptions().m_DisplayViaFill );
259
260 for( PCB_TRACK* track : board()->Tracks() )
261 {
262 if( track->Type() == PCB_VIA_T )
263 view()->Update( track, KIGFX::REPAINT );
264 }
265
266 canvas()->Refresh();
267 return 0;
268}
269
270
277{
278 if( Pgm().GetCommonSettings()->m_DoNotShowAgain.zone_fill_warning )
279 return;
280
281 bool unfilledZones = false;
282
283 for( const ZONE* zone : board()->Zones() )
284 {
285 if( !zone->GetIsRuleArea() && !zone->IsFilled() )
286 {
287 unfilledZones = true;
288 break;
289 }
290 }
291
292 if( unfilledZones )
293 {
294 WX_INFOBAR* infobar = m_frame->GetInfoBar();
295 wxHyperlinkCtrl* button = new wxHyperlinkCtrl( infobar, wxID_ANY, _( "Don't show again" ), wxEmptyString );
296
297 button->Bind( wxEVT_COMMAND_HYPERLINK, std::function<void( wxHyperlinkEvent& aEvent )>(
298 [&]( wxHyperlinkEvent& aEvent )
299 {
301 m_frame->GetInfoBar()->Dismiss();
302 } ) );
303
304 infobar->RemoveAllButtons();
305 infobar->AddButton( button );
306
307 wxString msg;
308 msg.Printf( _( "Not all zones are filled. Use Edit > Fill All Zones (%s) "
309 "if you wish to see all fills." ),
311
312 infobar->ShowMessageFor( msg, 5000, wxICON_WARNING );
313 }
314}
315
316
318{
319 PCB_DISPLAY_OPTIONS opts = m_frame->GetDisplayOptions();
320
321 // Apply new display options to the GAL canvas
323 {
325
327 }
328 else if( aEvent.IsAction( &PCB_ACTIONS::zoneDisplayOutline ) )
329 {
331 }
332 else if( aEvent.IsAction( &PCB_ACTIONS::zoneDisplayFractured ) )
333 {
335 }
337 {
339 }
340 else if( aEvent.IsAction( &PCB_ACTIONS::zoneDisplayToggle ) )
341 {
344 else
346 }
347 else
348 {
349 wxFAIL;
350 }
351
352 m_frame->SetDisplayOptions( opts );
353
354 for( ZONE* zone : board()->Zones() )
355 view()->Update( zone, KIGFX::REPAINT );
356
357 canvas()->Refresh();
358
359 return 0;
360}
361
362
364{
365 PCB_DISPLAY_OPTIONS opts = m_frame->GetDisplayOptions();
366
370
371 m_frame->SetDisplayOptions( opts );
372 return 0;
373}
374
375
377{
378 PCB_DISPLAY_OPTIONS opts = m_frame->GetDisplayOptions();
379
380 switch( opts.m_ContrastModeDisplay )
381 {
385 }
386
387 m_frame->SetDisplayOptions( opts );
388
390 return 0;
391}
392
393
395{
396 if( !Pgm().GetCommonSettings()->m_Input.hotkey_feedback )
397 return 0;
398
399 PCB_DISPLAY_OPTIONS opts = m_frame->GetDisplayOptions();
400
401 wxArrayString labels;
402 labels.Add( _( "Normal" ) );
403 labels.Add( _( "Dimmed" ) );
404 labels.Add( _( "Hidden" ) );
405
406 if( !m_frame->GetHotkeyPopup() )
407 m_frame->CreateHotkeyPopup();
408
409 HOTKEY_CYCLE_POPUP* popup = m_frame->GetHotkeyPopup();
410
411 if( popup )
412 {
413 popup->Popup( _( "Inactive Layer Display" ), labels,
414 static_cast<int>( opts.m_ContrastModeDisplay ) );
415 }
416
417 return 0;
418}
419
420
422{
423 PCB_DISPLAY_OPTIONS opts = m_frame->GetDisplayOptions();
424
425 switch( opts.m_NetColorMode )
426 {
430 }
431
432 m_frame->SetDisplayOptions( opts );
433 return 0;
434}
435
436
438{
439 if( PCB_EDIT_FRAME* editFrame = dynamic_cast<PCB_EDIT_FRAME*>( m_frame ) )
440 {
441 if( !displayOptions().m_ShowGlobalRatsnest )
442 {
445 }
446 else if( displayOptions().m_RatsnestMode == RATSNEST_MODE::ALL )
447 {
449 }
450 else
451 {
453 }
454
455 editFrame->SetElementVisibility( LAYER_RATSNEST, displayOptions().m_ShowGlobalRatsnest );
456
457 editFrame->OnDisplayOptionsChanged();
458
460 canvas()->Refresh();
461 }
462
463 return 0;
464}
465
466
468{
469 m_frame->SwitchLayer( aEvent.Parameter<PCB_LAYER_ID>() );
470
471 return 0;
472}
473
474
476{
477 BOARD* brd = board();
478 PCB_LAYER_ID layer = m_frame->GetActiveLayer();
479 bool wraparound = false;
480
481 if( !IsCopperLayer( layer ) )
482 {
483 m_frame->SwitchLayer( B_Cu );
484 return 0;
485 }
486
487 LSET cuMask = LSET::AllCuMask( brd->GetCopperLayerCount() );
488 LSEQ layerStack = cuMask.UIOrder();
489
490 int ii = 0;
491
492 // Find the active layer in list
493 for( ; ii < (int)layerStack.size(); ii++ )
494 {
495 if( layer == layerStack[ii] )
496 break;
497 }
498
499 // Find the next visible layer in list
500 for( ; ii < (int)layerStack.size(); ii++ )
501 {
502 int jj = ii+1;
503
504 if( jj >= (int)layerStack.size() )
505 jj = 0;
506
507 layer = layerStack[jj];
508
509 if( brd->IsLayerVisible( layer ) )
510 break;
511
512 if( jj == 0 ) // the end of list is reached. Try from the beginning
513 {
514 if( wraparound )
515 {
516 wxBell();
517 return 0;
518 }
519 else
520 {
521 wraparound = true;
522 ii = -1;
523 }
524 }
525 }
526
527 wxCHECK( IsCopperLayer( layer ), 0 );
528 m_frame->SwitchLayer( layer );
529
530 return 0;
531}
532
533
535{
536 BOARD* brd = board();
537 PCB_LAYER_ID layer = m_frame->GetActiveLayer();
538 bool wraparound = false;
539
540 if( !IsCopperLayer( layer ) )
541 {
542 m_frame->SwitchLayer( F_Cu );
543 return 0;
544 }
545
546 LSET cuMask = LSET::AllCuMask( brd->GetCopperLayerCount() );
547 LSEQ layerStack = cuMask.UIOrder();
548
549 int ii = 0;
550
551 // Find the active layer in list
552 for( ; ii < (int)layerStack.size(); ii++ )
553 {
554 if( layer == layerStack[ii] )
555 break;
556 }
557
558 // Find the previous visible layer in list
559 for( ; ii >= 0; ii-- )
560 {
561 int jj = ii - 1;
562
563 if( jj < 0 )
564 jj = (int)layerStack.size() - 1;
565
566 layer = layerStack[jj];
567
568 if( brd->IsLayerVisible( layer ) )
569 break;
570
571 if( ii == 0 ) // the start of list is reached. Try from the last
572 {
573 if( wraparound )
574 {
575 wxBell();
576 return 0;
577 }
578 else
579 {
580 wraparound = true;
581 ii = 1;
582 }
583 }
584 }
585
586 wxCHECK( IsCopperLayer( layer ), 0 );
587 m_frame->SwitchLayer( layer );
588
589 return 0;
590}
591
592
594{
595 int currentLayer = m_frame->GetActiveLayer();
596 PCB_SCREEN* screen = m_frame->GetScreen();
597
598 if( currentLayer == screen->m_Route_Layer_TOP )
599 m_frame->SwitchLayer( screen->m_Route_Layer_BOTTOM );
600 else
601 m_frame->SwitchLayer( screen->m_Route_Layer_TOP );
602
603 return 0;
604}
605
606
607// It'd be nice to share the min/max with the DIALOG_COLOR_PICKER, but those are
608// set in wxFormBuilder.
609#define ALPHA_MIN 0.20
610#define ALPHA_MAX 1.00
611#define ALPHA_STEP 0.05
612
613
615{
616 COLOR_SETTINGS* settings = m_frame->GetColorSettings();
617 int currentLayer = m_frame->GetActiveLayer();
618 KIGFX::COLOR4D currentColor = settings->GetColor( currentLayer );
619
620 if( currentColor.a <= ALPHA_MAX - ALPHA_STEP )
621 {
622 currentColor.a += ALPHA_STEP;
623 settings->SetColor( currentLayer, currentColor );
624 m_frame->GetCanvas()->UpdateColors();
625
626 KIGFX::VIEW* view = m_frame->GetCanvas()->GetView();
627 view->UpdateLayerColor( currentLayer );
628 view->UpdateLayerColor( GetNetnameLayer( currentLayer ) );
629
630 if( IsCopperLayer( currentLayer ) )
631 view->UpdateLayerColor( ZONE_LAYER_FOR( currentLayer ) );
632
633 m_frame->GetCanvas()->ForceRefresh();
634 }
635 else
636 {
637 wxBell();
638 }
639
640 return 0;
641}
642
643
645{
646 COLOR_SETTINGS* settings = m_frame->GetColorSettings();
647 int currentLayer = m_frame->GetActiveLayer();
648 KIGFX::COLOR4D currentColor = settings->GetColor( currentLayer );
649
650 if( currentColor.a >= ALPHA_MIN + ALPHA_STEP )
651 {
652 currentColor.a -= ALPHA_STEP;
653 settings->SetColor( currentLayer, currentColor );
654 m_frame->GetCanvas()->UpdateColors();
655
656 KIGFX::VIEW* view = m_frame->GetCanvas()->GetView();
657 view->UpdateLayerColor( currentLayer );
658 view->UpdateLayerColor( GetNetnameLayer( currentLayer ) );
659
660 if( IsCopperLayer( currentLayer ) )
661 view->UpdateLayerColor( ZONE_LAYER_FOR( currentLayer ) );
662
663 m_frame->GetCanvas()->ForceRefresh();
664 }
665 else
666 {
667 wxBell();
668 }
669
670 return 0;
671}
672
673
675{
676 if( PCB_EDIT_FRAME* editFrame = dynamic_cast<PCB_EDIT_FRAME*>( m_frame ) )
677 {
678 LAYER_PAIR_SETTINGS* settings = editFrame->GetLayerPairSettings();
679
680 if( !settings )
681 return 0;
682
683 int currentIndex;
684 std::vector<LAYER_PAIR_INFO> presets = settings->GetEnabledLayerPairs( currentIndex );
685
686 if( presets.size() < 2 )
687 return 0;
688
689 if( currentIndex < 0 )
690 {
691 wxASSERT_MSG( false, "Current layer pair not found in layer settings" );
692 currentIndex = 0;
693 }
694
695 const int nextIndex = ( currentIndex + 1 ) % presets.size();
696 const LAYER_PAIR& nextPair = presets[nextIndex].GetLayerPair();
697
698 settings->SetCurrentLayerPair( nextPair );
699
701 }
702
703 return 0;
704}
705
706
708{
709 if( !Pgm().GetCommonSettings()->m_Input.hotkey_feedback )
710 return 0;
711
712 if( PCB_EDIT_FRAME* editFrame = dynamic_cast<PCB_EDIT_FRAME*>( m_frame ) )
713 {
714 LAYER_PAIR_SETTINGS* settings = editFrame->GetLayerPairSettings();
715
716 if( !settings )
717 return 0;
718
719 PCB_LAYER_PRESENTATION layerPresentation( editFrame );
720
721 int currentIndex;
722 std::vector<LAYER_PAIR_INFO> presets = settings->GetEnabledLayerPairs( currentIndex );
723
724 wxArrayString labels;
725 for( const LAYER_PAIR_INFO& layerPairInfo : presets )
726 {
727 wxString label = layerPresentation.getLayerPairName( layerPairInfo.GetLayerPair() );
728
729 if( layerPairInfo.GetName() )
730 label += wxT( " (" ) + *layerPairInfo.GetName() + wxT( ")" );
731
732 labels.Add( label );
733 }
734
735 if( !editFrame->GetHotkeyPopup() )
736 editFrame->CreateHotkeyPopup();
737
738 HOTKEY_CYCLE_POPUP* popup = editFrame->GetHotkeyPopup();
739
740 if( popup )
741 {
742 int selection = currentIndex;
743 popup->Popup( _( "Preset Layer Pairs" ), labels, selection );
744 }
745 }
746
747 return 0;
748}
749
750
752 EDA_ITEM* originViewItem, const VECTOR2D& aPoint )
753{
754 aFrame->GetDesignSettings().SetGridOrigin( VECTOR2I( aPoint ) );
755 aView->GetGAL()->SetGridOrigin( aPoint );
756 originViewItem->SetPosition( aPoint );
757 aView->MarkDirty();
758 aFrame->OnModify();
759}
760
761
763{
764 VECTOR2D* origin = aEvent.Parameter<VECTOR2D*>();
765
766 if( origin )
767 {
768 // We can't undo the other grid dialog settings, so no sense undoing just the origin
769 DoSetGridOrigin( getView(), m_frame, m_gridOrigin.get(), *origin );
770 delete origin;
771 }
772 else
773 {
775 return 0;
776
777 PCB_PICKER_TOOL* picker = m_toolMgr->GetTool<PCB_PICKER_TOOL>();
778
779 if( !picker ) // Happens in footprint wizard
780 return 0;
781
782 // Deactivate other tools; particularly important if another PICKER is currently running
783 Activate();
784
785 picker->SetCursor( KICURSOR::PLACE );
786 picker->ClearHandlers();
787
788 picker->SetClickHandler(
789 [this]( const VECTOR2D& pt ) -> bool
790 {
791 m_frame->SaveCopyInUndoList( m_gridOrigin.get(), UNDO_REDO::GRIDORIGIN );
793 return false; // drill origin is a one-shot; don't continue with tool
794 } );
795
796 m_toolMgr->RunAction( ACTIONS::pickerTool, &aEvent );
797 }
798
799 return 0;
800}
801
802
804{
805 m_frame->SaveCopyInUndoList( m_gridOrigin.get(), UNDO_REDO::GRIDORIGIN );
807 return 0;
808}
809
810
811#define HITTEST_THRESHOLD_PIXELS 5
812
813
815{
816 if( m_isFootprintEditor && !m_frame->GetBoard()->GetFirstFootprint() )
817 return 0;
818
819 PCB_PICKER_TOOL* picker = m_toolMgr->GetTool<PCB_PICKER_TOOL>();
820
821 m_pickerItem = nullptr;
823
824 // Deactivate other tools; particularly important if another PICKER is currently running
825 Activate();
826
827 picker->SetCursor( KICURSOR::REMOVE );
828 picker->SetSnapping( false );
829 picker->ClearHandlers();
830
831 picker->SetClickHandler(
832 [this]( const VECTOR2D& aPosition ) -> bool
833 {
834 if( m_pickerItem )
835 {
836 if( m_pickerItem && m_pickerItem->IsLocked() )
837 {
839 m_statusPopup->SetText( _( "Item locked." ) );
840 m_statusPopup->PopupFor( 2000 );
841 m_statusPopup->Move( KIPLATFORM::UI::GetMousePosition() + wxPoint( 20, 20 ) );
842 return true;
843 }
844
845 PCB_SELECTION_TOOL* selectionTool = m_toolMgr->GetTool<PCB_SELECTION_TOOL>();
846 selectionTool->UnbrightenItem( m_pickerItem );
847
848 PCB_SELECTION items;
849 items.Add( m_pickerItem );
850
851 EDIT_TOOL* editTool = m_toolMgr->GetTool<EDIT_TOOL>();
852 editTool->DeleteItems( items, false );
853
854 m_pickerItem = nullptr;
855 }
856
857 return true;
858 } );
859
860 picker->SetMotionHandler(
861 [this]( const VECTOR2D& aPos )
862 {
863 BOARD* board = m_frame->GetBoard();
864 PCB_SELECTION_TOOL* selectionTool = m_toolMgr->GetTool<PCB_SELECTION_TOOL>();
865 GENERAL_COLLECTORS_GUIDE guide = m_frame->GetCollectorsGuide();
866 GENERAL_COLLECTOR collector;
867 collector.m_Threshold = KiROUND( getView()->ToWorld( HITTEST_THRESHOLD_PIXELS ) );
868
870 collector.Collect( board, GENERAL_COLLECTOR::FootprintItems, aPos, guide );
871 else
872 collector.Collect( board, GENERAL_COLLECTOR::BoardLevelItems, aPos, guide );
873
874 // Remove unselectable items
875 for( int i = collector.GetCount() - 1; i >= 0; --i )
876 {
877 if( !selectionTool->Selectable( collector[ i ] ) )
878 collector.Remove( i );
879 }
880
881 selectionTool->FilterCollectorForHierarchy( collector, false );
882 selectionTool->FilterCollectedItems( collector, false, nullptr );
883
884 if( collector.GetCount() > 1 )
885 selectionTool->GuessSelectionCandidates( collector, aPos );
886
887 BOARD_ITEM* item = collector.GetCount() == 1 ? collector[ 0 ] : nullptr;
888
889 if( m_pickerItem != item )
890 {
891 if( m_pickerItem )
892 selectionTool->UnbrightenItem( m_pickerItem );
893
894 m_pickerItem = item;
895
896 if( m_pickerItem )
897 selectionTool->BrightenItem( m_pickerItem );
898 }
899 } );
900
901 picker->SetFinalizeHandler(
902 [this]( const int& aFinalState )
903 {
904 if( m_pickerItem )
905 m_toolMgr->GetTool<PCB_SELECTION_TOOL>()->UnbrightenItem( m_pickerItem );
906
907 m_statusPopup.reset();
908
909 // Ensure the cursor gets changed&updated
910 m_frame->GetCanvas()->SetCurrentCursor( KICURSOR::ARROW );
911 m_frame->GetCanvas()->Refresh();
912 } );
913
914 m_toolMgr->RunAction( ACTIONS::pickerTool, &aEvent );
915
916 return 0;
917}
918
919
920static void pasteFootprintItemsToFootprintEditor( FOOTPRINT* aClipFootprint, BOARD* aBoard,
921 std::vector<BOARD_ITEM*>& aPastedItems )
922{
923 FOOTPRINT* editorFootprint = aBoard->GetFirstFootprint();
924
925 aClipFootprint->SetParent( aBoard );
926
927 for( PAD* pad : aClipFootprint->Pads() )
928 {
929 pad->SetParent( editorFootprint );
930 aPastedItems.push_back( pad );
931 }
932
933 aClipFootprint->Pads().clear();
934
935 // Not all items can be added to the current footprint: mandatory fields are already existing
936 // in the current footprint.
937 //
938 for( PCB_FIELD* field : aClipFootprint->GetFields() )
939 {
940 if( field->IsMandatory() )
941 {
942 if( EDA_GROUP* parentGroup = field->GetParentGroup() )
943 parentGroup->RemoveItem( field );
944 }
945 else
946 {
947 PCB_TEXT* text = static_cast<PCB_TEXT*>( field );
948
949 text->SetTextAngle( text->GetTextAngle() - aClipFootprint->GetOrientation() );
950 text->SetTextAngle( text->GetTextAngle() + editorFootprint->GetOrientation() );
951
952 VECTOR2I pos = field->GetFPRelativePosition();
953 field->SetParent( editorFootprint );
954 field->SetFPRelativePosition( pos );
955
956 aPastedItems.push_back( field );
957 }
958 }
959
960 aClipFootprint->GetFields().clear();
961
962 for( BOARD_ITEM* item : aClipFootprint->GraphicalItems() )
963 {
964 if( item->Type() == PCB_TEXT_T )
965 {
966 PCB_TEXT* text = static_cast<PCB_TEXT*>( item );
967
968 text->SetTextAngle( text->GetTextAngle() - aClipFootprint->GetOrientation() );
969 text->SetTextAngle( text->GetTextAngle() + editorFootprint->GetOrientation() );
970 }
971
972 item->Rotate( item->GetPosition(), -aClipFootprint->GetOrientation() );
973 item->Rotate( item->GetPosition(), editorFootprint->GetOrientation() );
974
975 VECTOR2I pos = item->GetFPRelativePosition();
976 item->SetParent( editorFootprint );
977 item->SetFPRelativePosition( pos );
978
979 aPastedItems.push_back( item );
980 }
981
982 aClipFootprint->GraphicalItems().clear();
983
984 for( ZONE* zone : aClipFootprint->Zones() )
985 {
986 zone->SetParent( editorFootprint );
987 aPastedItems.push_back( zone );
988 }
989
990 aClipFootprint->Zones().clear();
991
992 for( PCB_GROUP* group : aClipFootprint->Groups() )
993 {
994 group->SetParent( editorFootprint );
995 aPastedItems.push_back( group );
996 }
997
998 aClipFootprint->Groups().clear();
999}
1000
1001
1002void PCB_CONTROL::pruneItemLayers( std::vector<BOARD_ITEM*>& aItems )
1003{
1004 // Do not prune items or layers when copying to the FP editor, because all
1005 // layers are accepted, even if they are not enabled in the dummy board
1006 // This is mainly true for internal copper layers: all are allowed but only one
1007 // (In1.cu) is enabled for the GUI.
1009 return;
1010
1011 LSET enabledLayers = board()->GetEnabledLayers();
1012 std::vector<BOARD_ITEM*> returnItems;
1013 bool fpItemDeleted = false;
1014
1015 for( BOARD_ITEM* item : aItems )
1016 {
1017 if( item->Type() == PCB_FOOTPRINT_T )
1018 {
1019 FOOTPRINT* fp = static_cast<FOOTPRINT*>( item );
1020
1021 // Items living in a parent footprint are never removed, even if their
1022 // layer does not exist in the board editor
1023 // Otherwise the parent footprint could be seriously broken especially
1024 // if some layers are later re-enabled.
1025 // Moreover a fp lives in a fp library, that does not know the enabled
1026 // layers of a given board, so fp items are just ignored when on not
1027 // enabled layers in board editor
1028 returnItems.push_back( fp );
1029 }
1030 else if( item->Type() == PCB_GROUP_T || item->Type() == PCB_GENERATOR_T )
1031 {
1032 returnItems.push_back( item );
1033 }
1034 else
1035 {
1036 LSET allowed = item->GetLayerSet() & enabledLayers;
1037 bool item_valid = true;
1038
1039 // Ensure, for vias, the top and bottom layers are compatible with
1040 // the current board copper layers.
1041 // Otherwise they must be skipped, even is one layer is valid
1042 if( item->Type() == PCB_VIA_T )
1043 item_valid = static_cast<PCB_VIA*>( item )->HasValidLayerPair(
1044 board()->GetCopperLayerCount() );
1045
1046 if( allowed.any() && item_valid )
1047 {
1048 item->SetLayerSet( allowed );
1049 returnItems.push_back( item );
1050 }
1051 else
1052 {
1053 if( EDA_GROUP* parentGroup = item->GetParentGroup() )
1054 parentGroup->RemoveItem( item );
1055 }
1056 }
1057 }
1058
1059 if( ( returnItems.size() < aItems.size() ) || fpItemDeleted )
1060 {
1061 DisplayError( m_frame, _( "Warning: some pasted items were on layers which are not "
1062 "present in the current board.\n"
1063 "These items could not be pasted.\n" ) );
1064 }
1065
1066 aItems = returnItems;
1067}
1068
1069
1070int PCB_CONTROL::Paste( const TOOL_EVENT& aEvent )
1071{
1072 // The viewer frames cannot paste
1073 if( !m_frame->IsType( FRAME_FOOTPRINT_EDITOR ) && !m_frame->IsType( FRAME_PCB_EDITOR ) )
1074 return 0;
1075
1076 bool isFootprintEditor = m_isFootprintEditor || m_frame->IsType( FRAME_FOOTPRINT_EDITOR );
1077
1078 // The clipboard can contain two different things, an entire kicad_pcb or a single footprint
1079 if( isFootprintEditor && ( !board() || !footprint() ) )
1080 return 0;
1081
1082 // We should never get here if a modal dialog is up... but we do on MacOS.
1083 // https://gitlab.com/kicad/code/kicad/-/issues/18912
1084#ifdef __WXMAC__
1085 if( wxDialog::OSXHasModalDialogsOpen() )
1086 {
1087 wxBell();
1088 return 0;
1089 }
1090#endif
1091
1092 BOARD_COMMIT commit( m_frame );
1093
1094 CLIPBOARD_IO pi;
1095 BOARD_ITEM* clipItem = pi.Parse();
1096
1097 if( !clipItem )
1098 {
1099 // When the clipboard doesn't parse, create a PCB item with the clipboard contents
1100 std::vector<BOARD_ITEM*> newItems;
1101
1102 if( std::unique_ptr<wxImage> clipImg = GetImageFromClipboard() )
1103 {
1104 auto refImg = std::make_unique<PCB_REFERENCE_IMAGE>( m_frame->GetModel() );
1105
1106 if( refImg->GetReferenceImage().SetImage( *clipImg ) )
1107 newItems.push_back( refImg.release() );
1108 }
1109 else
1110 {
1111 const wxString clipText = GetClipboardUTF8();
1112
1113 if( clipText.empty() )
1114 return 0;
1115
1116 // If it wasn't content, then paste as a text object.
1117 if( clipText.size() > static_cast<size_t>( ADVANCED_CFG::GetCfg().m_MaxPastedTextLength ) )
1118 {
1119 int result = IsOK( m_frame, _( "Pasting a long text text string may be very slow. "
1120 "Do you want to continue?" ) );
1121 if( !result )
1122 return 0;
1123 }
1124
1125 std::unique_ptr<PCB_TEXT> item = std::make_unique<PCB_TEXT>( m_frame->GetModel() );
1126 item->SetText( clipText );
1127
1128 newItems.push_back( item.release() );
1129 }
1130
1131 bool cancelled = !placeBoardItems( &commit, newItems, true, false, false, false );
1132
1133 if( cancelled )
1134 commit.Revert();
1135 else
1136 commit.Push( _( "Paste Text" ) );
1137 return 0;
1138 }
1139
1140 // If we get here, we have a parsed board/FP to paste
1141
1143 bool clear_nets = false;
1144 const wxString defaultRef = wxT( "REF**" );
1145
1146 if( aEvent.IsAction( &ACTIONS::pasteSpecial ) )
1147 {
1148 DIALOG_PASTE_SPECIAL dlg( m_frame, &mode, defaultRef );
1149
1150 if( clipItem->Type() != PCB_T )
1151 dlg.HideClearNets();
1152
1153 if( dlg.ShowModal() == wxID_CANCEL )
1154 return 0;
1155
1156 clear_nets = dlg.GetClearNets();
1157 }
1158
1159 if( clipItem->Type() == PCB_T )
1160 {
1161 BOARD* clipBoard = static_cast<BOARD*>( clipItem );
1162
1163 if( isFootprintEditor || clear_nets )
1164 {
1165 for( BOARD_CONNECTED_ITEM* item : clipBoard->AllConnectedItems() )
1166 item->SetNet( NETINFO_LIST::OrphanedItem() );
1167 }
1168 else
1169 {
1170 clipBoard->MapNets( m_frame->GetBoard() );
1171 }
1172 }
1173
1174 bool cancelled = false;
1175
1176 switch( clipItem->Type() )
1177 {
1178 case PCB_T:
1179 {
1180 BOARD* clipBoard = static_cast<BOARD*>( clipItem );
1181
1182 if( isFootprintEditor )
1183 {
1184 FOOTPRINT* editorFootprint = board()->GetFirstFootprint();
1185 std::vector<BOARD_ITEM*> pastedItems;
1186
1187 for( PCB_GROUP* group : clipBoard->Groups() )
1188 {
1189 group->SetParent( editorFootprint );
1190 pastedItems.push_back( group );
1191 }
1192
1193 clipBoard->RemoveAll( { PCB_GROUP_T } );
1194
1195 for( FOOTPRINT* clipFootprint : clipBoard->Footprints() )
1196 pasteFootprintItemsToFootprintEditor( clipFootprint, board(), pastedItems );
1197
1198 for( BOARD_ITEM* clipDrawItem : clipBoard->Drawings() )
1199 {
1200 switch( clipDrawItem->Type() )
1201 {
1202 case PCB_TEXT_T:
1203 case PCB_TEXTBOX_T:
1204 case PCB_TABLE_T:
1205 case PCB_SHAPE_T:
1206 case PCB_DIM_ALIGNED_T:
1207 case PCB_DIM_CENTER_T:
1208 case PCB_DIM_LEADER_T:
1210 case PCB_DIM_RADIAL_T:
1211 clipDrawItem->SetParent( editorFootprint );
1212 pastedItems.push_back( clipDrawItem );
1213 break;
1214
1215 default:
1216 // Everything we *didn't* put into pastedItems is going to get nuked, so
1217 // make sure it's not still included in its parent group.
1218 if( EDA_GROUP* parentGroup = clipDrawItem->GetParentGroup() )
1219 parentGroup->RemoveItem( clipDrawItem );
1220
1221 break;
1222 }
1223 }
1224
1225 // NB: PCB_SHAPE_T actually removes everything in Drawings() (including PCB_TEXTs,
1226 // PCB_TABLES, dimensions, etc.), not just PCB_SHAPEs.)
1227 clipBoard->RemoveAll( { PCB_SHAPE_T } );
1228
1229 clipBoard->Visit(
1230 [&]( EDA_ITEM* item, void* testData )
1231 {
1232 if( item->IsBOARD_ITEM() )
1233 {
1234 // Anything still on the clipboard didn't get copied and needs to be
1235 // removed from the pasted groups.
1236 BOARD_ITEM* boardItem = static_cast<BOARD_ITEM*>( item );
1237 EDA_GROUP* parentGroup = boardItem->GetParentGroup();
1238
1239 if( parentGroup )
1240 parentGroup->RemoveItem( boardItem );
1241 }
1242
1244 },
1246
1247 delete clipBoard;
1248
1249 pruneItemLayers( pastedItems );
1250
1251 cancelled = !placeBoardItems( &commit, pastedItems, true, true, mode == PASTE_MODE::UNIQUE_ANNOTATIONS,
1252 false );
1253 }
1254 else // isBoardEditor
1255 {
1256 // Fixup footprint component classes
1257 for( FOOTPRINT* fp : clipBoard->Footprints() )
1258 {
1259 fp->ResolveComponentClassNames( board(), fp->GetTransientComponentClassNames() );
1260 fp->ClearTransientComponentClassNames();
1261 }
1262
1263 if( mode == PASTE_MODE::REMOVE_ANNOTATIONS )
1264 {
1265 for( FOOTPRINT* fp : clipBoard->Footprints() )
1266 fp->SetReference( defaultRef );
1267 }
1268
1269 cancelled = !placeBoardItems( &commit, clipBoard, true, mode == PASTE_MODE::UNIQUE_ANNOTATIONS,
1270 false );
1271 }
1272
1273 break;
1274 }
1275
1276 case PCB_FOOTPRINT_T:
1277 {
1278 FOOTPRINT* clipFootprint = static_cast<FOOTPRINT*>( clipItem );
1279 std::vector<BOARD_ITEM*> pastedItems;
1280
1281 if( isFootprintEditor )
1282 {
1283 pasteFootprintItemsToFootprintEditor( clipFootprint, board(), pastedItems );
1284 delete clipFootprint;
1285 }
1286 else
1287 {
1288 if( mode == PASTE_MODE::REMOVE_ANNOTATIONS )
1289 clipFootprint->SetReference( defaultRef );
1290
1291 clipFootprint->SetParent( board() );
1292 clipFootprint->ResolveComponentClassNames( board(), clipFootprint->GetTransientComponentClassNames() );
1293 clipFootprint->ClearTransientComponentClassNames();
1294 pastedItems.push_back( clipFootprint );
1295 }
1296
1297 pruneItemLayers( pastedItems );
1298
1299 cancelled = !placeBoardItems( &commit, pastedItems, true, true, mode == PASTE_MODE::UNIQUE_ANNOTATIONS,
1300 false );
1301 break;
1302 }
1303
1304 default:
1305 m_frame->DisplayToolMsg( _( "Invalid clipboard contents" ) );
1306 break;
1307 }
1308
1309 if( cancelled )
1310 commit.Revert();
1311 else
1312 commit.Push( _( "Paste" ) );
1313
1314 return 1;
1315}
1316
1317
1319{
1320 wxString fileName;
1321
1322 PCB_EDIT_FRAME* editFrame = dynamic_cast<PCB_EDIT_FRAME*>( m_frame );
1323
1324 if( !editFrame )
1325 return 1;
1326
1327 // Pick a file to append
1328 if( !AskLoadBoardFileName( editFrame, &fileName, KICTL_KICAD_ONLY ) )
1329 return 1;
1330
1332 IO_RELEASER<PCB_IO> pi( PCB_IO_MGR::PluginFind( pluginType ) );
1333
1334 if( !pi )
1335 return 1;
1336
1337 return AppendBoard( *pi, fileName );
1338}
1339
1340
1342{
1343 PCB_EDIT_FRAME* editFrame = dynamic_cast<PCB_EDIT_FRAME*>( m_frame );
1344
1345 if( !editFrame )
1346 return 1;
1347
1348 if( !editFrame->GetDesignBlockPane()->GetSelectedLibId().IsValid() )
1349 return 1;
1350
1351 DESIGN_BLOCK_PANE* designBlockPane = editFrame->GetDesignBlockPane();
1352 std::unique_ptr<DESIGN_BLOCK> designBlock( designBlockPane->GetDesignBlock( designBlockPane->GetSelectedLibId(),
1353 true, true ) );
1354
1355 if( !designBlock || designBlock->GetBoardFile().IsEmpty() )
1356 return 1;
1357
1359 IO_RELEASER<PCB_IO> pi( PCB_IO_MGR::PluginFind( pluginType ) );
1360
1361 if( !pi )
1362 return 1;
1363
1364 bool repeatPlacement = false;
1365
1366 if( APP_SETTINGS_BASE* cfg = editFrame->config() )
1367 repeatPlacement = cfg->m_DesignBlockChooserPanel.repeated_placement;
1368
1369 int ret = 0;
1370
1371 do
1372 {
1373 ret = AppendBoard( *pi, designBlock->GetBoardFile(), designBlock.get() );
1374 } while( repeatPlacement && ret == 0 );
1375
1376 return ret;
1377}
1378
1380{
1381 PCB_EDIT_FRAME* editFrame = dynamic_cast<PCB_EDIT_FRAME*>( m_frame );
1382
1383 if( !editFrame )
1384 return 1;
1385
1386 BOARD* brd = board();
1387
1388 if( !brd )
1389 return 1;
1390
1391 // Need to have a group selected and it needs to have a linked design block
1392 PCB_SELECTION_TOOL* selTool = m_toolMgr->GetTool<PCB_SELECTION_TOOL>();
1394
1395 if( selection.Size() != 1 || selection[0]->Type() != PCB_GROUP_T )
1396 return 1;
1397
1398 PCB_GROUP* group = static_cast<PCB_GROUP*>( selection[0] );
1399
1400 if( !group->HasDesignBlockLink() )
1401 return 1;
1402
1403 BOARD_COMMIT tempCommit( m_frame );
1404
1405 std::set<EDA_ITEM*> originalItems;
1406 // Apply MCT_SKIP_STRUCT to every EDA_ITEM on the board so we know what is not part of the design block
1407 // Can't use SKIP_STRUCT as that is used and cleared by the temporary board appending
1408 brd->Visit( []( EDA_ITEM* item, void* )
1409 {
1410 item->SetFlags( MCT_SKIP_STRUCT );
1412 },
1414
1415 int ret = 1;
1416
1417 bool skipMove = true;
1418
1419 // If we succeeded in placing the linked design block, we're ready to apply the multichannel tool
1420 if( m_toolMgr->RunSynchronousAction( PCB_ACTIONS::placeLinkedDesignBlock, &tempCommit, &skipMove ) )
1421 {
1422 // Lambda for the bounding box of all the components
1423 auto generateBoundingBox = [&]( std::unordered_set<EDA_ITEM*> aItems )
1424 {
1425 std::vector<VECTOR2I> bbCorners;
1426 bbCorners.reserve( aItems.size() * 4 );
1427
1428 for( auto item : aItems )
1429 {
1430 const BOX2I bb = item->GetBoundingBox().GetInflated( 100000 );
1431 KIGEOM::CollectBoxCorners( bb, bbCorners );
1432 }
1433
1434 std::vector<VECTOR2I> hullVertices;
1435 BuildConvexHull( hullVertices, bbCorners );
1436
1437 SHAPE_LINE_CHAIN hull( hullVertices );
1438
1439 // Make the newly computed convex hull use only 90 degree segments
1440 return KIGEOM::RectifyPolygon( hull );
1441 };
1442
1443 // Build a rule area that contains all the components in the design block,
1444 // meaning all items without SKIP_STRUCT set.
1445 RULE_AREA dbRA;
1446
1448 dbRA.m_generateEnabled = true;
1449
1450 // Add all components that aren't marked MCT_SKIP_STRUCT to ra.m_components
1451 brd->Visit(
1452 [&]( EDA_ITEM* item, void* data )
1453 {
1454 if( !item->HasFlag( MCT_SKIP_STRUCT ) )
1455 {
1456 dbRA.m_designBlockItems.insert( item );
1457
1458 if( item->Type() == PCB_FOOTPRINT_T )
1459 dbRA.m_components.insert( static_cast<FOOTPRINT*>( item ) );
1460 }
1462 },
1464
1465 dbRA.m_zone = new ZONE( board() );
1466 //dbRA.m_area->SetZoneName( wxString::Format( wxT( "design-block-source-%s" ), group->GetDesignBlockLibId().GetUniStringLibId() ) );
1467 dbRA.m_zone->SetIsRuleArea( true );
1469 dbRA.m_zone->SetPlacementAreaEnabled( true );
1470 dbRA.m_zone->SetDoNotAllowZoneFills( false );
1471 dbRA.m_zone->SetDoNotAllowVias( false );
1472 dbRA.m_zone->SetDoNotAllowTracks( false );
1473 dbRA.m_zone->SetDoNotAllowPads( false );
1474 dbRA.m_zone->SetDoNotAllowFootprints( false );
1476 dbRA.m_zone->SetPlacementAreaSource( group->GetDesignBlockLibId().GetUniStringLibId() );
1478 dbRA.m_zone->AddPolygon( generateBoundingBox( dbRA.m_designBlockItems ) );
1479 dbRA.m_center = dbRA.m_zone->Outline()->COutline( 0 ).Centre();
1480
1481 // Create the destination rule area for the group
1482 RULE_AREA destRA;
1483
1485
1486 // Add all the design block group footprints to the destination rule area
1487 for( EDA_ITEM* item : group->GetItems() )
1488 {
1489 if( item->Type() == PCB_FOOTPRINT_T )
1490 {
1491 FOOTPRINT* fp = static_cast<FOOTPRINT*>( item );
1492
1493 // If the footprint is locked, we can't place it
1494 if( fp->IsLocked() )
1495 {
1496 wxString msg;
1497 msg.Printf( _( "Footprint %s is locked and cannot be placed." ), fp->GetReference() );
1498 m_frame->GetInfoBar()->ShowMessageFor( msg, 5000, wxICON_WARNING );
1499 return 1;
1500 }
1501
1502 destRA.m_components.insert( fp );
1503 }
1504 }
1505
1506 destRA.m_zone = new ZONE( board() );
1507 destRA.m_zone->SetZoneName(
1508 wxString::Format( wxT( "design-block-dest-%s" ), group->GetDesignBlockLibId().GetUniStringLibId() ) );
1509 destRA.m_zone->SetIsRuleArea( true );
1510 destRA.m_zone->SetLayerSet( LSET::AllCuMask() );
1511 destRA.m_zone->SetPlacementAreaEnabled( true );
1512 destRA.m_zone->SetDoNotAllowZoneFills( false );
1513 destRA.m_zone->SetDoNotAllowVias( false );
1514 destRA.m_zone->SetDoNotAllowTracks( false );
1515 destRA.m_zone->SetDoNotAllowPads( false );
1516 destRA.m_zone->SetDoNotAllowFootprints( false );
1518 destRA.m_zone->SetPlacementAreaSource( group->GetName() );
1520 destRA.m_zone->AddPolygon( generateBoundingBox( group->GetItems() ) );
1521 destRA.m_center = destRA.m_zone->Outline()->COutline( 0 ).Centre();
1522
1523 // Use the multichannel tool to repeat the layout
1525
1526 ret = mct->RepeatLayout( aEvent, dbRA, destRA );
1527
1528 // Get rid of the temporary design blocks and rule areas
1529 tempCommit.Revert();
1530
1531 delete dbRA.m_zone;
1532 delete destRA.m_zone;
1533 }
1534
1535 // We're done, remove SKIP_STRUCT
1536 brd->Visit( []( EDA_ITEM* item, void* )
1537 {
1538 item->ClearFlags( MCT_SKIP_STRUCT );
1540 },
1542
1543 return ret;
1544}
1545
1547{
1548 PCB_EDIT_FRAME* editFrame = dynamic_cast<PCB_EDIT_FRAME*>( m_frame );
1549
1550 if( !editFrame )
1551 return 1;
1552
1553 // Need to have a group selected and it needs to have a linked design block
1554 PCB_SELECTION_TOOL* selTool = m_toolMgr->GetTool<PCB_SELECTION_TOOL>();
1556
1557 if( selection.Size() != 1 || selection[0]->Type() != PCB_GROUP_T )
1558 return 1;
1559
1560 PCB_GROUP* group = static_cast<PCB_GROUP*>( selection[0] );
1561
1562 if( !group->HasDesignBlockLink() )
1563 return 1;
1564
1565 // Get the associated design block
1566 DESIGN_BLOCK_PANE* designBlockPane = editFrame->GetDesignBlockPane();
1567 std::unique_ptr<DESIGN_BLOCK> designBlock( designBlockPane->GetDesignBlock( group->GetDesignBlockLibId(),
1568 true, true ) );
1569
1570 if( !designBlock )
1571 {
1572 wxString msg;
1573 msg.Printf( _( "Could not find design block %s." ), group->GetDesignBlockLibId().GetUniStringLibId() );
1574 m_frame->GetInfoBar()->ShowMessageFor( msg, 5000, wxICON_WARNING );
1575 return 1;
1576 }
1577
1578 if( designBlock->GetBoardFile().IsEmpty() )
1579 {
1580 wxString msg;
1581 msg.Printf( _( "Design block %s does not have a board file." ),
1582 group->GetDesignBlockLibId().GetUniStringLibId() );
1583 m_frame->GetInfoBar()->ShowMessageFor( msg, 5000, wxICON_WARNING );
1584 return 1;
1585 }
1586
1587
1589 IO_RELEASER<PCB_IO> pi( PCB_IO_MGR::PluginFind( pluginType ) );
1590
1591 if( !pi )
1592 return 1;
1593
1594 if( aEvent.Parameter<bool*>() != nullptr )
1595 return AppendBoard( *pi, designBlock->GetBoardFile(), designBlock.get(),
1596 static_cast<BOARD_COMMIT*>( aEvent.Commit() ), *aEvent.Parameter<bool*>() );
1597 else
1598 return AppendBoard( *pi, designBlock->GetBoardFile(), designBlock.get() );
1599}
1600
1601
1603{
1604 PCB_EDIT_FRAME* editFrame = dynamic_cast<PCB_EDIT_FRAME*>( m_frame );
1605
1606 if( !editFrame )
1607 return 1;
1608
1609 // Need to have a group selected and it needs to have a linked design block
1610 PCB_SELECTION_TOOL* selTool = m_toolMgr->GetTool<PCB_SELECTION_TOOL>();
1612
1613 if( selection.Size() != 1 || selection[0]->Type() != PCB_GROUP_T )
1614 return 1;
1615
1616 PCB_GROUP* group = static_cast<PCB_GROUP*>( selection[0] );
1617
1618 if( !group->HasDesignBlockLink() )
1619 return 1;
1620
1621 // Get the associated design block
1622 DESIGN_BLOCK_PANE* designBlockPane = editFrame->GetDesignBlockPane();
1623 std::unique_ptr<DESIGN_BLOCK> designBlock( designBlockPane->GetDesignBlock( group->GetDesignBlockLibId(),
1624 true, true ) );
1625
1626 if( !designBlock )
1627 {
1628 wxString msg;
1629 msg.Printf( _( "Could not find design block %s." ), group->GetDesignBlockLibId().GetUniStringLibId() );
1630 m_frame->GetInfoBar()->ShowMessageFor( msg, 5000, wxICON_WARNING );
1631 return 1;
1632 }
1633
1634 editFrame->GetDesignBlockPane()->SelectLibId( group->GetDesignBlockLibId() );
1635
1636 return m_toolMgr->RunAction( PCB_ACTIONS::saveSelectionToDesignBlock ) ? 1 : 0;
1637}
1638
1639
1640template<typename T>
1641static void moveUnflaggedItems( const std::deque<T>& aList, std::vector<BOARD_ITEM*>& aTarget,
1642 bool aIsNew )
1643{
1644 std::copy_if( aList.begin(), aList.end(), std::back_inserter( aTarget ),
1645 [aIsNew]( T aItem )
1646 {
1647 bool doCopy = ( aItem->GetFlags() & SKIP_STRUCT ) == 0;
1648
1649 aItem->ClearFlags( SKIP_STRUCT );
1650 aItem->SetFlags( aIsNew ? IS_NEW : 0 );
1651
1652 return doCopy;
1653 } );
1654}
1655
1656
1657template<typename T>
1658static void moveUnflaggedItems( const std::vector<T>& aList, std::vector<BOARD_ITEM*>& aTarget,
1659 bool aIsNew )
1660{
1661 std::copy_if( aList.begin(), aList.end(), std::back_inserter( aTarget ),
1662 [aIsNew]( T aItem )
1663 {
1664 bool doCopy = ( aItem->GetFlags() & SKIP_STRUCT ) == 0;
1665
1666 aItem->ClearFlags( SKIP_STRUCT );
1667 aItem->SetFlags( aIsNew ? IS_NEW : 0 );
1668
1669 return doCopy;
1670 } );
1671}
1672
1673
1674bool PCB_CONTROL::placeBoardItems( BOARD_COMMIT* aCommit, BOARD* aBoard, bool aAnchorAtOrigin,
1675 bool aReannotateDuplicates, bool aSkipMove )
1676{
1677 // items are new if the current board is not the board source
1678 bool isNew = board() != aBoard;
1679 std::vector<BOARD_ITEM*> items;
1680
1681 moveUnflaggedItems( aBoard->Tracks(), items, isNew );
1682 moveUnflaggedItems( aBoard->Footprints(), items, isNew );
1683 moveUnflaggedItems( aBoard->Drawings(), items, isNew );
1684 moveUnflaggedItems( aBoard->Zones(), items, isNew );
1685
1686 // Subtlety: When selecting a group via the mouse,
1687 // PCB_SELECTION_TOOL::highlightInternal runs, which does a SetSelected() on all
1688 // descendants. In PCB_CONTROL::placeBoardItems, below, we skip that and
1689 // mark items non-recursively. That works because the saving of the
1690 // selection created aBoard that has the group and all descendants in it.
1691 moveUnflaggedItems( aBoard->Groups(), items, isNew );
1692
1693 moveUnflaggedItems( aBoard->Generators(), items, isNew );
1694
1695 if( isNew )
1696 aBoard->RemoveAll();
1697
1698 // Reparent before calling pruneItemLayers, as SetLayer can have a dependence on the
1699 // item's parent board being set correctly.
1700 if( isNew )
1701 {
1702 for( BOARD_ITEM* item : items )
1703 item->SetParent( board() );
1704 }
1705
1706 pruneItemLayers( items );
1707
1708 return placeBoardItems( aCommit, items, isNew, aAnchorAtOrigin, aReannotateDuplicates, aSkipMove );
1709}
1710
1711
1712bool PCB_CONTROL::placeBoardItems( BOARD_COMMIT* aCommit, std::vector<BOARD_ITEM*>& aItems, bool aIsNew,
1713 bool aAnchorAtOrigin, bool aReannotateDuplicates, bool aSkipMove )
1714{
1715 m_toolMgr->RunAction( ACTIONS::selectionClear );
1716
1717 PCB_SELECTION_TOOL* selectionTool = m_toolMgr->GetTool<PCB_SELECTION_TOOL>();
1718
1719 std::vector<BOARD_ITEM*> itemsToSel;
1720 itemsToSel.reserve( aItems.size() );
1721
1722 for( BOARD_ITEM* item : aItems )
1723 {
1724 if( aIsNew )
1725 {
1726 const_cast<KIID&>( item->m_Uuid ) = KIID();
1727
1728 item->RunOnChildren(
1729 []( BOARD_ITEM* aChild )
1730 {
1731 const_cast<KIID&>( aChild->m_Uuid ) = KIID();
1732 },
1734
1735 // While BOARD_COMMIT::Push() will add any new items to the entered group,
1736 // we need to do it earlier so that the previews while moving are correct.
1737 if( PCB_GROUP* enteredGroup = selectionTool->GetEnteredGroup() )
1738 {
1739 if( item->IsGroupableType() && !item->GetParentGroup() )
1740 {
1741 aCommit->Modify( enteredGroup, nullptr, RECURSE_MODE::NO_RECURSE );
1742 enteredGroup->AddItem( item );
1743 }
1744 }
1745
1746 item->SetParent( board() );
1747 }
1748
1749 // Update item attributes if needed
1750 if( BaseType( item->Type() ) == PCB_DIMENSION_T )
1751 {
1752 static_cast<PCB_DIMENSION_BASE*>( item )->UpdateUnits();
1753 }
1754 else if( item->Type() == PCB_FOOTPRINT_T )
1755 {
1756 FOOTPRINT* footprint = static_cast<FOOTPRINT*>( item );
1757
1758 // Update the footprint path with the new KIID path if the footprint is new
1759 if( aIsNew )
1760 footprint->SetPath( KIID_PATH() );
1761
1762 for( BOARD_ITEM* dwg : footprint->GraphicalItems() )
1763 {
1764 if( BaseType( dwg->Type() ) == PCB_DIMENSION_T )
1765 static_cast<PCB_DIMENSION_BASE*>( dwg )->UpdateUnits();
1766 }
1767 }
1768
1769 // We only need to add the items that aren't inside a group currently selected
1770 // to the selection. If an item is inside a group and that group is selected,
1771 // then the selection tool will select it for us.
1772 if( !item->GetParentGroup() || !alg::contains( aItems, item->GetParentGroup()->AsEdaItem() ) )
1773 itemsToSel.push_back( item );
1774 }
1775
1776 // Select the items that should be selected
1777 EDA_ITEMS toSel( itemsToSel.begin(), itemsToSel.end() );
1778 m_toolMgr->RunAction<EDA_ITEMS*>( ACTIONS::selectItems, &toSel );
1779
1780 // Reannotate duplicate footprints (make sense only in board editor )
1781 if( aReannotateDuplicates && m_isBoardEditor )
1782 m_toolMgr->GetTool<BOARD_REANNOTATE_TOOL>()->ReannotateDuplicatesInSelection();
1783
1784 for( BOARD_ITEM* item : aItems )
1785 {
1786 if( aIsNew )
1787 aCommit->Add( item );
1788 else
1789 aCommit->Added( item );
1790 }
1791
1792 PCB_SELECTION& selection = selectionTool->GetSelection();
1793
1794 if( selection.Size() > 0 )
1795 {
1796 if( aAnchorAtOrigin )
1797 {
1798 selection.SetReferencePoint( VECTOR2I( 0, 0 ) );
1799 }
1800 else if( BOARD_ITEM* item = dynamic_cast<BOARD_ITEM*>( selection.GetTopLeftItem() ) )
1801 {
1802 selection.SetReferencePoint( item->GetPosition() );
1803 }
1804
1805 getViewControls()->SetCursorPosition( getViewControls()->GetMousePosition(), false );
1806
1807 m_toolMgr->ProcessEvent( EVENTS::SelectedEvent );
1808
1809 if( !aSkipMove )
1810 return m_toolMgr->RunSynchronousAction( PCB_ACTIONS::move, aCommit );
1811 }
1812
1813 return true;
1814}
1815
1816
1817int PCB_CONTROL::AppendBoard( PCB_IO& pi, const wxString& fileName, DESIGN_BLOCK* aDesignBlock, BOARD_COMMIT* aCommit,
1818 bool aSkipMove )
1819{
1820 PCB_EDIT_FRAME* editFrame = dynamic_cast<PCB_EDIT_FRAME*>( m_frame );
1821
1822 if( !editFrame )
1823 return 1;
1824
1825 BOARD* brd = board();
1826
1827 if( !brd )
1828 return 1;
1829
1830 // Give ourselves a commit to work with if we weren't provided one
1831 std::unique_ptr<BOARD_COMMIT> tempCommit;
1832 BOARD_COMMIT* commit = aCommit;
1833
1834 if( !commit )
1835 {
1836 tempCommit = std::make_unique<BOARD_COMMIT>( editFrame );
1837 commit = tempCommit.get();
1838 }
1839
1840 // Mark existing items, in order to know what are the new items so we can select only
1841 // the new items after loading
1842 for( PCB_TRACK* track : brd->Tracks() )
1843 track->SetFlags( SKIP_STRUCT );
1844
1845 for( FOOTPRINT* footprint : brd->Footprints() )
1846 footprint->SetFlags( SKIP_STRUCT );
1847
1848 for( PCB_GROUP* group : brd->Groups() )
1849 group->SetFlags( SKIP_STRUCT );
1850
1851 for( BOARD_ITEM* drawing : brd->Drawings() )
1852 drawing->SetFlags( SKIP_STRUCT );
1853
1854 for( ZONE* zone : brd->Zones() )
1855 zone->SetFlags( SKIP_STRUCT );
1856
1857 for( PCB_GENERATOR* generator : brd->Generators() )
1858 generator->SetFlags( SKIP_STRUCT );
1859
1860 std::map<wxString, wxString> oldProperties = brd->GetProperties();
1861 std::map<wxString, wxString> newProperties;
1862
1863 PAGE_INFO oldPageInfo = brd->GetPageSettings();
1864 TITLE_BLOCK oldTitleBlock = brd->GetTitleBlock();
1865
1866 // Keep also the count of copper layers, to adjust if necessary
1867 int initialCopperLayerCount = brd->GetCopperLayerCount();
1868 LSET initialEnabledLayers = brd->GetEnabledLayers();
1869
1870 // Load the data
1871 try
1872 {
1873 std::map<std::string, UTF8> props;
1874
1875 // PCB_IO_EAGLE can use this info to center the BOARD, but it does not yet.
1876
1877 props["page_width"] = std::to_string( editFrame->GetPageSizeIU().x );
1878 props["page_height"] = std::to_string( editFrame->GetPageSizeIU().y );
1879
1881 [&]( wxString aTitle, int aIcon, wxString aMessage, wxString aAction ) -> bool
1882 {
1883 KIDIALOG dlg( editFrame, aMessage, aTitle, wxOK | wxCANCEL | aIcon );
1884
1885 if( !aAction.IsEmpty() )
1886 dlg.SetOKLabel( aAction );
1887
1888 dlg.DoNotShowCheckbox( aMessage, 0 );
1889
1890 return dlg.ShowModal() == wxID_OK;
1891 } );
1892
1893 WX_PROGRESS_REPORTER progressReporter( editFrame, _( "Load PCB" ), 1, PR_CAN_ABORT );
1894
1896 pi.SetProgressReporter( &progressReporter );
1897 pi.LoadBoard( fileName, brd, &props, nullptr );
1898 }
1899 catch( const IO_ERROR& ioe )
1900 {
1901 DisplayErrorMessage( editFrame, _( "Error loading board." ), ioe.What() );
1902
1903 return 0;
1904 }
1905
1906 newProperties = brd->GetProperties();
1907
1908 for( const std::pair<const wxString, wxString>& prop : oldProperties )
1909 newProperties[ prop.first ] = prop.second;
1910
1911 brd->SetProperties( newProperties );
1912
1913 brd->SetPageSettings( oldPageInfo );
1914 brd->SetTitleBlock( oldTitleBlock );
1915
1916 // rebuild nets and ratsnest before any use of nets
1917 brd->BuildListOfNets();
1918 brd->SynchronizeNetsAndNetClasses( true );
1919 brd->BuildConnectivity();
1920
1921 // Synchronize layers
1922 // we should not ask PLUGINs to do these items:
1923 int copperLayerCount = brd->GetCopperLayerCount();
1924
1925 if( copperLayerCount > initialCopperLayerCount )
1926 brd->SetCopperLayerCount( copperLayerCount );
1927
1928 // Enable all used layers, and make them visible:
1929 LSET enabledLayers = brd->GetEnabledLayers();
1930 enabledLayers |= initialEnabledLayers;
1931 brd->SetEnabledLayers( enabledLayers );
1932 brd->SetVisibleLayers( enabledLayers );
1933
1934 int ret = 0;
1935
1936 bool placeAsGroup = false;
1937
1938 if( APP_SETTINGS_BASE* cfg = editFrame->config() )
1939 placeAsGroup = cfg->m_DesignBlockChooserPanel.place_as_group;
1940
1941 if( placeBoardItems( commit, brd, false, false /* Don't reannotate dupes on Append Board */, aSkipMove ) )
1942 {
1943 if( placeAsGroup )
1944 {
1945 PCB_GROUP* group = new PCB_GROUP( brd );
1946
1947 if( aDesignBlock )
1948 {
1949 group->SetName( aDesignBlock->GetLibId().GetLibItemName() );
1950 group->SetDesignBlockLibId( aDesignBlock->GetLibId() );
1951 }
1952 else
1953 {
1954 group->SetName( wxFileName( fileName ).GetName() );
1955 }
1956
1957 // Get the selection tool selection
1958 PCB_SELECTION_TOOL* selTool = m_toolMgr->GetTool<PCB_SELECTION_TOOL>();
1960
1961 for( EDA_ITEM* eda_item : selection )
1962 {
1963 if( eda_item->IsBOARD_ITEM() )
1964 {
1965 if( static_cast<BOARD_ITEM*>( eda_item )->IsLocked() )
1966 group->SetLocked( true );
1967 }
1968 }
1969
1970 commit->Add( group );
1971
1972 for( EDA_ITEM* eda_item : selection )
1973 {
1974 if( eda_item->IsBOARD_ITEM() && !static_cast<BOARD_ITEM*>( eda_item )->GetParentFootprint() )
1975 {
1976 commit->Modify( eda_item );
1977 group->AddItem( eda_item );
1978 }
1979 }
1980
1981 selTool->ClearSelection();
1982 selTool->select( group );
1983
1985 m_frame->OnModify();
1986 m_frame->Refresh();
1987 }
1988
1989 // If we were provided a commit, let the caller control when to push it
1990 if( !aCommit )
1991 commit->Push( aDesignBlock ? _( "Place Design Block" ) : _( "Append Board" ) );
1992
1993 editFrame->GetBoard()->BuildConnectivity();
1994 ret = 0;
1995 }
1996 else
1997 {
1998 // If we were provided a commit, let the caller control when to revert it
1999 if( !aCommit )
2000 commit->Revert();
2001
2002 ret = 1;
2003 }
2004
2005 // Refresh the UI for the updated board properties
2006 editFrame->GetAppearancePanel()->OnBoardChanged();
2007
2008 return ret;
2009}
2010
2011
2012int PCB_CONTROL::Undo( const TOOL_EVENT& aEvent )
2013{
2014 PCB_BASE_EDIT_FRAME* editFrame = dynamic_cast<PCB_BASE_EDIT_FRAME*>( m_frame );
2015 wxCommandEvent dummy;
2016
2017 if( editFrame )
2018 editFrame->RestoreCopyFromUndoList( dummy );
2019
2020 return 0;
2021}
2022
2023
2024int PCB_CONTROL::Redo( const TOOL_EVENT& aEvent )
2025{
2026 PCB_BASE_EDIT_FRAME* editFrame = dynamic_cast<PCB_BASE_EDIT_FRAME*>( m_frame );
2027 wxCommandEvent dummy;
2028
2029 if( editFrame )
2030 editFrame->RestoreCopyFromRedoList( dummy );
2031
2032 return 0;
2033}
2034
2035
2037{
2038 MAGNETIC_SETTINGS& settings = m_isFootprintEditor ? m_frame->GetFootprintEditorSettings()->m_MagneticItems
2039 : m_frame->GetPcbNewSettings()->m_MagneticItems;
2040 bool& snapMode = settings.allLayers;
2041
2043 snapMode = false;
2044 else if( aEvent.IsAction( &PCB_ACTIONS::magneticSnapAllLayers ) )
2045 snapMode = true;
2046 else
2047 snapMode = !snapMode;
2048
2050
2051 return 0;
2052}
2053
2054
2056{
2057 if( !Pgm().GetCommonSettings()->m_Input.hotkey_feedback )
2058 return 0;
2059
2060 wxArrayString labels;
2061 labels.Add( _( "Active Layer" ) );
2062 labels.Add( _( "All Layers" ) );
2063
2064 if( !m_frame->GetHotkeyPopup() )
2065 m_frame->CreateHotkeyPopup();
2066
2067 HOTKEY_CYCLE_POPUP* popup = m_frame->GetHotkeyPopup();
2068
2069 MAGNETIC_SETTINGS& settings = m_isFootprintEditor ? m_frame->GetFootprintEditorSettings()->m_MagneticItems
2070 : m_frame->GetPcbNewSettings()->m_MagneticItems;
2071
2072 if( popup )
2073 popup->Popup( _( "Object Snapping" ), labels, static_cast<int>( settings.allLayers ) );
2074
2075 return 0;
2076}
2077
2078
2080{
2081 PCB_SELECTION_TOOL* selTool = m_toolMgr->GetTool<PCB_SELECTION_TOOL>();
2082 ROUTER_TOOL* routerTool = m_toolMgr->GetTool<ROUTER_TOOL>();
2083 PCB_SELECTION& selection = selTool->GetSelection();
2084 PCB_EDIT_FRAME* pcbFrame = dynamic_cast<PCB_EDIT_FRAME*>( m_frame );
2085 std::shared_ptr<DRC_ENGINE> drcEngine = m_frame->GetBoard()->GetDesignSettings().m_DRCEngine;
2086 DRC_CONSTRAINT constraint;
2087
2088 std::vector<MSG_PANEL_ITEM> msgItems;
2089
2090 if( routerTool && routerTool->RoutingInProgress() )
2091 {
2092 routerTool->UpdateMessagePanel();
2093 return 0;
2094 }
2095
2096 if( !pcbFrame && !m_frame->GetModel() )
2097 return 0;
2098
2099 if( selection.Empty() )
2100 {
2101 if( !pcbFrame )
2102 {
2103 FOOTPRINT* fp = static_cast<FOOTPRINT*>( m_frame->GetModel() );
2104 fp->GetMsgPanelInfo( m_frame, msgItems );
2105 }
2106 else
2107 {
2108 m_frame->SetMsgPanel( m_frame->GetBoard() );
2109 }
2110 }
2111 else if( selection.GetSize() == 1 )
2112 {
2113 EDA_ITEM* item = selection.Front();
2114
2115 if( std::optional<wxString> uuid = GetMsgPanelDisplayUuid( item->m_Uuid ) )
2116 msgItems.emplace_back( _( "UUID" ), *uuid );
2117
2118 item->GetMsgPanelInfo( m_frame, msgItems );
2119
2120 PCB_TRACK* track = dynamic_cast<PCB_TRACK*>( item );
2121 NETINFO_ITEM* net = track ? track->GetNet() : nullptr;
2122 NETINFO_ITEM* coupledNet = net ? m_frame->GetBoard()->DpCoupledNet( net ) : nullptr;
2123
2124 if( coupledNet )
2125 {
2126 SEG trackSeg( track->GetStart(), track->GetEnd() );
2127 PCB_TRACK* coupledItem = nullptr;
2128 SEG::ecoord closestDist_sq = VECTOR2I::ECOORD_MAX;
2129
2130 for( PCB_TRACK* candidate : m_frame->GetBoard()->Tracks() )
2131 {
2132 if( candidate->GetNet() != coupledNet )
2133 continue;
2134
2135 SEG::ecoord dist_sq = trackSeg.SquaredDistance( SEG( candidate->GetStart(),
2136 candidate->GetEnd() ) );
2137
2138 if( !coupledItem || dist_sq < closestDist_sq )
2139 {
2140 coupledItem = candidate;
2141 closestDist_sq = dist_sq;
2142 }
2143 }
2144
2145 constraint = drcEngine->EvalRules( DIFF_PAIR_GAP_CONSTRAINT, track, coupledItem,
2146 track->GetLayer() );
2147
2148 wxString msg = m_frame->MessageTextFromMinOptMax( constraint.Value() );
2149
2150 if( !msg.IsEmpty() )
2151 {
2152 msgItems.emplace_back( wxString::Format( _( "DP Gap Constraints: %s" ), msg ),
2153 wxString::Format( _( "(from %s)" ), constraint.GetName() ) );
2154 }
2155
2156 constraint = drcEngine->EvalRules( MAX_UNCOUPLED_CONSTRAINT, track,
2157 coupledItem, track->GetLayer() );
2158
2159 if( constraint.Value().HasMax() )
2160 {
2161 msg = m_frame->MessageTextFromValue( constraint.Value().Max() );
2162 msgItems.emplace_back( wxString::Format( _( "DP Max Uncoupled-length: %s" ), msg ),
2163 wxString::Format( _( "(from %s)" ), constraint.GetName() ) );
2164 }
2165 }
2166 }
2167 else if( pcbFrame && selection.GetSize() == 2 )
2168 {
2169 // Pair selection broken into multiple, optional data, starting with the selected item
2170 // names
2171
2172 BOARD_ITEM* a = dynamic_cast<BOARD_ITEM*>( selection[0] );
2173 BOARD_ITEM* b = dynamic_cast<BOARD_ITEM*>( selection[1] );
2174
2175 if( a && b )
2176 {
2177 msgItems.emplace_back( MSG_PANEL_ITEM( a->GetItemDescription( m_frame, false ),
2178 b->GetItemDescription( m_frame, false ) ) );
2179 }
2180
2181 BOARD_CONNECTED_ITEM* a_conn = dynamic_cast<BOARD_CONNECTED_ITEM*>( a );
2182 BOARD_CONNECTED_ITEM* b_conn = dynamic_cast<BOARD_CONNECTED_ITEM*>( b );
2183
2184 if( a_conn && b_conn )
2185 {
2186 LSET overlap = a_conn->GetLayerSet() & b_conn->GetLayerSet() & LSET::AllCuMask();
2187 int a_netcode = a_conn->GetNetCode();
2188 int b_netcode = b_conn->GetNetCode();
2189
2190 if( overlap.count() > 0 )
2191 {
2192 PCB_LAYER_ID layer = overlap.CuStack().front();
2193
2194 if( a_netcode != b_netcode || a_netcode < 0 || b_netcode < 0 )
2195 {
2196 constraint = drcEngine->EvalRules( CLEARANCE_CONSTRAINT, a, b, layer );
2197 msgItems.emplace_back( _( "Resolved Clearance" ),
2198 m_frame->MessageTextFromValue( constraint.m_Value.Min() ) );
2199 }
2200
2201 std::shared_ptr<SHAPE> a_shape( a_conn->GetEffectiveShape( layer ) );
2202 std::shared_ptr<SHAPE> b_shape( b_conn->GetEffectiveShape( layer ) );
2203
2204 int actual_clearance = a_shape->GetClearance( b_shape.get() );
2205
2206 if( actual_clearance > -1 && actual_clearance < std::numeric_limits<int>::max() )
2207 {
2208 msgItems.emplace_back( _( "Actual Clearance" ),
2209 m_frame->MessageTextFromValue( actual_clearance ) );
2210 }
2211 }
2212 }
2213
2214 if( a && b && ( a->HasHole() || b->HasHole() ) )
2215 {
2216 PCB_LAYER_ID active = m_frame->GetActiveLayer();
2218
2219 if( b->IsOnLayer( active ) && IsCopperLayer( active ) )
2220 layer = active;
2221 else if( b->HasHole() && a->IsOnLayer( active ) && IsCopperLayer( active ) )
2222 layer = active;
2223 else if( a->HasHole() && b->IsOnCopperLayer() )
2224 layer = b->GetLayer();
2225 else if( b->HasHole() && a->IsOnCopperLayer() )
2226 layer = a->GetLayer();
2227
2228 if( IsCopperLayer( layer ) )
2229 {
2230 int actual = std::numeric_limits<int>::max();
2231
2232 if( a->HasHole() && b->IsOnCopperLayer() )
2233 {
2234 std::shared_ptr<SHAPE_SEGMENT> hole = a->GetEffectiveHoleShape();
2235 std::shared_ptr<SHAPE> other( b->GetEffectiveShape( layer ) );
2236
2237 actual = std::min( actual, hole->GetClearance( other.get() ) );
2238 }
2239
2240 if( b->HasHole() && a->IsOnCopperLayer() )
2241 {
2242 std::shared_ptr<SHAPE_SEGMENT> hole = b->GetEffectiveHoleShape();
2243 std::shared_ptr<SHAPE> other( a->GetEffectiveShape( layer ) );
2244
2245 actual = std::min( actual, hole->GetClearance( other.get() ) );
2246 }
2247
2248 if( actual < std::numeric_limits<int>::max() )
2249 {
2250 constraint = drcEngine->EvalRules( HOLE_CLEARANCE_CONSTRAINT, a, b, layer );
2251 msgItems.emplace_back( _( "Resolved Hole Clearance" ),
2252 m_frame->MessageTextFromValue( constraint.m_Value.Min() ) );
2253
2254 if( actual > -1 && actual < std::numeric_limits<int>::max() )
2255 {
2256 msgItems.emplace_back( _( "Actual Hole Clearance" ),
2257 m_frame->MessageTextFromValue( actual ) );
2258 }
2259 }
2260 }
2261 }
2262
2263 if( a && b )
2264 {
2265 for( PCB_LAYER_ID edgeLayer : { Edge_Cuts, Margin } )
2266 {
2267 PCB_LAYER_ID active = m_frame->GetActiveLayer();
2269
2270 if( a->IsOnLayer( edgeLayer ) && b->Type() != PCB_FOOTPRINT_T )
2271 {
2272 if( b->IsOnLayer( active ) && IsCopperLayer( active ) )
2273 layer = active;
2274 else if( IsCopperLayer( b->GetLayer() ) )
2275 layer = b->GetLayer();
2276 }
2277 else if( b->IsOnLayer( edgeLayer ) && a->Type() != PCB_FOOTPRINT_T )
2278 {
2279 if( a->IsOnLayer( active ) && IsCopperLayer( active ) )
2280 layer = active;
2281 else if( IsCopperLayer( a->GetLayer() ) )
2282 layer = a->GetLayer();
2283 }
2284
2285 if( layer >= 0 )
2286 {
2287 constraint = drcEngine->EvalRules( EDGE_CLEARANCE_CONSTRAINT, a, b, layer );
2288
2289 if( edgeLayer == Edge_Cuts )
2290 {
2291 msgItems.emplace_back( _( "Resolved Edge Clearance" ),
2292 m_frame->MessageTextFromValue( constraint.m_Value.Min() ) );
2293 }
2294 else
2295 {
2296 msgItems.emplace_back( _( "Resolved Margin Clearance" ),
2297 m_frame->MessageTextFromValue( constraint.m_Value.Min() ) );
2298 }
2299 }
2300 }
2301 }
2302 }
2303
2304 if( selection.GetSize() )
2305 {
2306 if( msgItems.empty() )
2307 {
2308 msgItems.emplace_back( _( "Selected Items" ),
2309 wxString::Format( wxT( "%d" ), selection.GetSize() ) );
2310
2311 if( m_isBoardEditor )
2312 {
2313 std::set<wxString> netNames;
2314 std::set<wxString> netClasses;
2315
2316 for( EDA_ITEM* item : selection )
2317 {
2318 if( BOARD_CONNECTED_ITEM* bci = dynamic_cast<BOARD_CONNECTED_ITEM*>( item ) )
2319 {
2320 netNames.insert( UnescapeString( bci->GetNetname() ) );
2321 netClasses.insert( UnescapeString( bci->GetEffectiveNetClass()->GetHumanReadableName() ) );
2322
2323 if( netNames.size() > 1 && netClasses.size() > 1 )
2324 break;
2325 }
2326 }
2327
2328 if( netNames.size() == 1 )
2329 msgItems.emplace_back( _( "Net" ), *netNames.begin() );
2330
2331 if( netClasses.size() == 1 )
2332 msgItems.emplace_back( _( "Resolved Netclass" ), *netClasses.begin() );
2333 }
2334 }
2335
2336 if( selection.GetSize() >= 2 )
2337 {
2338 bool lengthValid = true;
2339 double selectedLength = 0;
2340
2341 // Lambda to accumulate track length if item is a track or arc, otherwise mark invalid
2342 std::function<void( EDA_ITEM* )> accumulateTrackLength;
2343
2344 accumulateTrackLength =
2345 [&]( EDA_ITEM* aItem )
2346 {
2347 if( aItem->Type() == PCB_TRACE_T || aItem->Type() == PCB_ARC_T )
2348 {
2349 selectedLength += static_cast<PCB_TRACK*>( aItem )->GetLength();
2350 }
2351 else if( aItem->Type() == PCB_VIA_T )
2352 {
2353 // zero 2D length
2354 }
2355 else if( aItem->Type() == PCB_SHAPE_T )
2356 {
2357 PCB_SHAPE* shape = static_cast<PCB_SHAPE*>( aItem );
2358
2359 if( shape->GetShape() == SHAPE_T::SEGMENT
2360 || shape->GetShape() == SHAPE_T::ARC
2361 || shape->GetShape() == SHAPE_T::BEZIER )
2362 {
2363 selectedLength += shape->GetLength();
2364 }
2365 else
2366 {
2367 lengthValid = false;
2368 }
2369 }
2370 // Use dynamic_cast to include PCB_GENERATORs.
2371 else if( PCB_GROUP* group = dynamic_cast<PCB_GROUP*>( aItem ) )
2372 {
2373 group->RunOnChildren( accumulateTrackLength, RECURSE_MODE::RECURSE );
2374 }
2375 else
2376 {
2377 lengthValid = false;
2378 }
2379 };
2380
2381 for( EDA_ITEM* item : selection )
2382 {
2383 if( lengthValid )
2384 accumulateTrackLength( item );
2385 }
2386
2387 if( lengthValid )
2388 {
2389 msgItems.emplace_back( _( "Selected 2D Length" ),
2390 m_frame->MessageTextFromValue( selectedLength ) );
2391 }
2392 }
2393
2394 if( selection.GetSize() >= 2 && selection.GetSize() < 100 )
2395 {
2396 LSET enabledCopper = LSET::AllCuMask( m_frame->GetBoard()->GetCopperLayerCount() );
2397 bool areaValid = true;
2398
2399 std::map<PCB_LAYER_ID, SHAPE_POLY_SET> copperPolys;
2400 SHAPE_POLY_SET holes;
2401
2402 std::function<void( EDA_ITEM* )> accumulateArea;
2403
2404 accumulateArea =
2405 [&]( EDA_ITEM* aItem )
2406 {
2407 if( aItem->Type() == PCB_FOOTPRINT_T || aItem->Type() == PCB_MARKER_T )
2408 {
2409 areaValid = false;
2410 return;
2411 }
2412
2413 if( PCB_GROUP* group = dynamic_cast<PCB_GROUP*>( aItem ) )
2414 {
2415 group->RunOnChildren( accumulateArea, RECURSE_MODE::RECURSE );
2416 return;
2417 }
2418
2419 if( BOARD_ITEM* boardItem = dynamic_cast<BOARD_ITEM*>( aItem ) )
2420 {
2421 boardItem->RunOnChildren( accumulateArea, RECURSE_MODE::NO_RECURSE );
2422
2423 for( PCB_LAYER_ID layer : LSET( boardItem->GetLayerSet() & enabledCopper ) )
2424 {
2425 boardItem->TransformShapeToPolySet( copperPolys[layer], layer, 0,
2427 }
2428
2429 if( aItem->Type() == PCB_PAD_T && static_cast<PAD*>( aItem )->HasHole() )
2430 {
2431 static_cast<PAD*>( aItem )->TransformHoleToPolygon( holes, 0, ARC_LOW_DEF,
2432 ERROR_OUTSIDE );
2433 }
2434 else if( aItem->Type() == PCB_VIA_T )
2435 {
2436 PCB_VIA* via = static_cast<PCB_VIA*>( aItem );
2437 VECTOR2I center = via->GetPosition();
2438 int R = via->GetDrillValue() / 2;
2439
2441 }
2442 }
2443 };
2444
2445 for( EDA_ITEM* item : selection )
2446 {
2447 if( areaValid )
2448 accumulateArea( item );
2449 }
2450
2451 if( areaValid )
2452 {
2453 double area = 0.0;
2454
2455 for( auto& [layer, copperPoly] : copperPolys )
2456 {
2457 copperPoly.BooleanSubtract( holes );
2458 area += copperPoly.Area();
2459 }
2460
2461 msgItems.emplace_back( _( "Selected 2D Copper Area" ),
2462 m_frame->MessageTextFromValue( area, true, EDA_DATA_TYPE::AREA ) );
2463 }
2464 }
2465 }
2466 else
2467 {
2468 m_frame->GetBoard()->GetMsgPanelInfo( m_frame, msgItems );
2469 }
2470
2471 m_frame->SetMsgPanel( msgItems );
2472
2473 return 0;
2474}
2475
2476
2478{
2479 wxFileName fileName = wxFileName( *aEvent.Parameter<wxString*>() );
2480
2481 PCB_EDIT_FRAME* editFrame = dynamic_cast<PCB_EDIT_FRAME*>( m_frame );
2482
2483 if( !editFrame )
2484 return 1;
2485
2486 wxString filePath = fileName.GetFullPath();
2488 IO_RELEASER<PCB_IO> pi( PCB_IO_MGR::PluginFind( pluginType ) );
2489
2490 if( !pi )
2491 return 1;
2492
2493 return AppendBoard( *pi, filePath );
2494}
2495
2496
2498{
2499 BOARD_COMMIT commit( this );
2500 BOARD_DESIGN_SETTINGS& settings = m_frame->GetBoard()->GetDesignSettings();
2501 BOARD_STACKUP& stackup = settings.GetStackupDescriptor();
2502
2503 stackup.SynchronizeWithBoard( &settings );
2504
2505 PCB_TABLE* table = new PCB_TABLE( m_frame->GetModel(), pcbIUScale.mmToIU( DEFAULT_LINE_WIDTH ) );
2506 table->SetLayer( m_frame->GetActiveLayer() );
2507 table->SetColCount( 4 );
2508
2509 auto addHeaderCell =
2510 [&]( const wxString& text )
2511 {
2512 PCB_TABLECELL* c = new PCB_TABLECELL( table );
2513 c->SetTextSize( VECTOR2I( pcbIUScale.mmToIU( 2.0 ), pcbIUScale.mmToIU( 2.0 ) ) );
2514 c->SetTextThickness( pcbIUScale.mmToIU( 0.4 ) );
2515 c->SetText( text );
2516 c->SetColSpan( table->GetColCount() );
2517 table->AddCell( c );
2518 };
2519
2520 auto addDataCell =
2521 [&]( const wxString& text )
2522 {
2523 PCB_TABLECELL* c = new PCB_TABLECELL( table );
2524 c->SetTextSize( VECTOR2I( pcbIUScale.mmToIU( 1.5 ), pcbIUScale.mmToIU( 1.5 ) ) );
2525 c->SetTextThickness( pcbIUScale.mmToIU( 0.2 ) );
2526 c->SetText( text );
2527 table->AddCell( c );
2528 };
2529
2530 addHeaderCell( _( "BOARD CHARACTERISTICS" ) );
2531
2532 for( int col = 1; col < table->GetColCount(); ++col )
2533 {
2534 addHeaderCell( wxEmptyString );
2535 table->GetCell( 0, col )->SetColSpan( 0 );
2536 }
2537
2538 addDataCell( _( "Copper layer count: " ) );
2540 settings.GetCopperLayerCount(), false ) );
2541
2542 addDataCell( _( "Board thickness: " ) );
2543 addDataCell( m_frame->MessageTextFromValue( settings.GetBoardThickness(), true ) );
2544
2545 SHAPE_POLY_SET outline;
2546 m_frame->GetBoard()->GetBoardPolygonOutlines( outline );
2547 BOX2I size = outline.BBox();
2548
2549 addDataCell( _( "Board overall dimensions: " ) );
2550 addDataCell( wxString::Format( wxT( "%s x %s" ),
2551 m_frame->MessageTextFromValue( size.GetWidth(), true ),
2552 m_frame->MessageTextFromValue( size.GetHeight(), true ) ) );
2553
2554 addDataCell( wxEmptyString );
2555 addDataCell( wxEmptyString );
2556
2557 addDataCell( _( "Min track/spacing: " ) );
2558 addDataCell( wxString::Format( wxT( "%s / %s" ),
2559 m_frame->MessageTextFromValue( settings.m_TrackMinWidth, true ),
2560 m_frame->MessageTextFromValue( settings.m_MinClearance, true ) ) );
2561
2562 double holeSize = std::min( settings.m_MinThroughDrill, settings.m_ViasMinSize );
2563
2564 addDataCell( _( "Min hole diameter: " ) );
2565 addDataCell( m_frame->MessageTextFromValue( holeSize, true ) );
2566
2567 addDataCell( _( "Copper finish: " ) );
2568 addDataCell( stackup.m_FinishType );
2569
2570 addDataCell( _( "Impedance control: " ) );
2571 addDataCell( stackup.m_HasDielectricConstrains ? _( "Yes" ) : _( "No" ) );
2572
2573 addDataCell( _( "Castellated pads: " ) );
2574 int castellated_pad_count = m_frame->GetBoard()->GetPadWithCastellatedAttrCount();
2575 addDataCell( castellated_pad_count ? _( "Yes" ) : _( "No" ) );
2576
2577 addDataCell( _( "Press-fit pads: " ) );
2578 int pressfit_pad_count = m_frame->GetBoard()->GetPadWithPressFitAttrCount();
2579 addDataCell( pressfit_pad_count ? _( "Yes" ) : _( "No" ) );
2580
2581 addDataCell( _( "Plated board edge: " ) );
2582 addDataCell( stackup.m_EdgePlating ? _( "Yes" ) : _( "No" ) );
2583
2584 wxString msg;
2585
2586 switch( stackup.m_EdgeConnectorConstraints )
2587 {
2588 case BS_EDGE_CONNECTOR_NONE: msg = _( "No" ); break;
2589 case BS_EDGE_CONNECTOR_IN_USE: msg = _( "Yes" ); break;
2590 case BS_EDGE_CONNECTOR_BEVELLED: msg = _( "Yes, Bevelled" ); break;
2591 }
2592
2593 addDataCell( _( "Edge card connectors: " ) );
2594 addDataCell( msg );
2595
2596 // We are building a table having 4 columns.
2597 // So we must have a cell count multible of 4, to have fully build row.
2598 // Othewise the table is really badly drawn.
2599 std::vector<PCB_TABLECELL*> cells_list = table->GetCells();
2600 int cell_to_add_cnt = cells_list.size() % table->GetColCount();
2601
2602 for( int ii = 0; ii < cell_to_add_cnt; ii++ )
2603 addDataCell( wxEmptyString );
2604
2605 table->SetStrokeExternal( false );
2606 table->SetStrokeHeaderSeparator( false );
2607 table->SetStrokeColumns( false );
2608 table->SetStrokeRows( false );
2609 table->Autosize();
2610
2611 std::vector<BOARD_ITEM*> items;
2612 items.push_back( table );
2613
2614 if( placeBoardItems( &commit, items, true, true, false, false ) )
2615 commit.Push( _( "Place Board Characteristics" ) );
2616 else
2617 delete table;
2618
2619 return 0;
2620}
2621
2622
2623
2625{
2626 BOARD_COMMIT commit( this );
2627 BOARD_DESIGN_SETTINGS& settings = m_frame->GetBoard()->GetDesignSettings();
2628 BOARD_STACKUP& stackup = settings.GetStackupDescriptor();
2629
2630 stackup.SynchronizeWithBoard( &settings );
2631
2632 std::vector<BOARD_STACKUP_ITEM*> layers = stackup.GetList();
2633
2634 PCB_TABLE* table = new PCB_TABLE( m_frame->GetModel(), pcbIUScale.mmToIU( DEFAULT_LINE_WIDTH ) );
2635 table->SetLayer( m_frame->GetActiveLayer() );
2636 table->SetColCount( 7 );
2637
2638 const auto addHeaderCell =
2639 [&]( const wxString& text )
2640 {
2641 PCB_TABLECELL* c = new PCB_TABLECELL( table );
2642 c->SetTextSize( VECTOR2I( pcbIUScale.mmToIU( 1.5 ), pcbIUScale.mmToIU( 1.5 ) ) );
2643 c->SetTextThickness( pcbIUScale.mmToIU( 0.3 ) );
2644 c->SetText( text );
2645 table->AddCell( c );
2646 };
2647
2648 const auto addDataCell =
2649 [&]( const wxString& text, const char align = 'L' )
2650 {
2651 PCB_TABLECELL* c = new PCB_TABLECELL( table );
2652 c->SetTextSize( VECTOR2I( pcbIUScale.mmToIU( 1.5 ), pcbIUScale.mmToIU( 1.5 ) ) );
2653 c->SetTextThickness( pcbIUScale.mmToIU( 0.2 ) );
2654
2655 if( align == 'R' )
2657
2658 c->SetText( text );
2659 table->AddCell( c );
2660 };
2661
2662 const auto layerThicknessString =
2663 [&]( const BOARD_STACKUP_ITEM& aStackupItem, int aSublayerId )
2664 {
2665 const int layerThickness = aStackupItem.GetThickness( aSublayerId );
2666
2667 // Layers like silkscreen, paste, etc. have no defined thickness, but that
2668 // does not mean that they are specified as exactly 0mm
2669 if( !aStackupItem.IsThicknessEditable() )
2670 return NotSpecifiedPrm();
2671
2672 return m_frame->StringFromValue( layerThickness, true );
2673 };
2674
2675 addHeaderCell( _( "Layer Name" ) );
2676 addHeaderCell( _( "Type" ) );
2677 addHeaderCell( _( "Material" ) );
2678 addHeaderCell( _( "Thickness" ) );
2679 addHeaderCell( _( "Color" ) );
2680 addHeaderCell( _( "Epsilon R" ) );
2681 addHeaderCell( _( "Loss Tangent" ) );
2682
2683 for( int i = 0; i < stackup.GetCount(); i++ )
2684 {
2685 BOARD_STACKUP_ITEM* stackup_item = layers.at( i );
2686
2687 for( int sublayer_id = 0; sublayer_id < stackup_item->GetSublayersCount(); sublayer_id++ )
2688 {
2689 // Layer names are empty until we close at least once the board setup dialog.
2690 // If the user did not open the dialog, then get the names from the board.
2691 // But dielectric layer names will be missing.
2692 // In this case, for dielectric, a dummy name will be used
2693 if( stackup_item->GetLayerName().IsEmpty() )
2694 {
2695 wxString layerName;
2696
2697 if( IsValidLayer( stackup_item->GetBrdLayerId() ) )
2698 layerName = m_frame->GetBoard()->GetLayerName( stackup_item->GetBrdLayerId() );
2699
2700 if( layerName.IsEmpty() && stackup_item->GetType() == BS_ITEM_TYPE_DIELECTRIC )
2701 layerName = _( "Dielectric" );
2702
2703 addDataCell( layerName );
2704 }
2705 else
2706 {
2707 addDataCell( stackup_item->GetLayerName() );
2708 }
2709
2710 addDataCell( InitialCaps( stackup_item->GetTypeName() ) );
2711 addDataCell( stackup_item->GetMaterial( sublayer_id ) );
2712 addDataCell( layerThicknessString( *stackup_item, sublayer_id ), 'R' );
2713 addDataCell( stackup_item->GetColor( sublayer_id ) );
2715 stackup_item->GetEpsilonR( sublayer_id ) ), 'R' );
2717 stackup_item->GetLossTangent( sublayer_id ) ), 'R' );
2718 }
2719 }
2720
2721 table->Autosize();
2722
2723 std::vector<BOARD_ITEM*> items;
2724 items.push_back( table );
2725
2726 if( placeBoardItems( &commit, items, true, true, false, false ) )
2727 commit.Push( _( "Place Board Stackup Table" ) );
2728 else
2729 delete table;
2730
2731 return 0;
2732}
2733
2734
2735
2737{
2738 view()->SetMirror( !view()->IsMirroredX(), false );
2739 view()->RecacheAllItems();
2740 m_frame->GetCanvas()->ForceRefresh();
2741 m_frame->OnDisplayOptionsChanged();
2742 return 0;
2743}
2744
2745
2747{
2748 if( aItem->Type() == PCB_SHAPE_T )
2749 {
2750 static_cast<PCB_SHAPE*>( aItem )->UpdateHatching();
2751
2752 if( view() )
2753 view()->Update( aItem );
2754 }
2755}
2756
2757
2759{
2760 for( FOOTPRINT* footprint : board()->Footprints() )
2761 footprint->RunOnChildren( std::bind( &PCB_CONTROL::rehatchBoardItem, this, _1 ), NO_RECURSE );
2762
2763 for( BOARD_ITEM* item : board()->Drawings() )
2764 rehatchBoardItem( item );
2765
2766 return 0;
2767}
2768
2769
2771{
2772 BOARD* brd = board();
2773
2774 if( !brd )
2775 return 0;
2776
2777 PROJECT& prj = m_frame->Prj();
2779 FILENAME_RESOLVER* resolver = cache ? cache->GetResolver() : nullptr;
2780
2781 wxString workingPath = prj.GetProjectPath();
2782 std::vector<const EMBEDDED_FILES*> stack;
2783 stack.push_back( brd->GetEmbeddedFiles() );
2784
2785 BOARD_COMMIT commit( m_frame );
2786 int embeddedCount = 0;
2787
2788 for( FOOTPRINT* fp : brd->Footprints() )
2789 {
2790 bool fpModified = false;
2791
2792 for( FP_3DMODEL& model : fp->Models() )
2793 {
2794 if( model.m_Filename.StartsWith( FILEEXT::KiCadUriPrefix ) )
2795 continue;
2796
2797 wxString fullPath =
2798 resolver ? resolver->ResolvePath( model.m_Filename, workingPath, stack ) : model.m_Filename;
2799 wxFileName fname( fullPath );
2800
2801 if( fname.Exists() )
2802 {
2803 if( EMBEDDED_FILES::EMBEDDED_FILE* file = brd->GetEmbeddedFiles()->AddFile( fname, false ) )
2804 {
2805 model.m_Filename = file->GetLink();
2806 fpModified = true;
2807 embeddedCount++;
2808 }
2809 }
2810 }
2811
2812 if( fpModified )
2813 commit.Modify( fp );
2814 }
2815
2816 if( embeddedCount > 0 )
2817 {
2818 commit.Push( _( "Embed 3D Models" ) );
2819 wxString msg = wxString::Format( _( "%d 3D model(s) successfully embedded." ), embeddedCount );
2820 m_frame->GetInfoBar()->ShowMessageFor( msg, 5000 );
2821 }
2822
2823 return 0;
2824}
2825
2826
2827// clang-format off
2829{
2832 Go( &PCB_CONTROL::Print, ACTIONS::print.MakeEvent() );
2833 Go( &PCB_CONTROL::Quit, ACTIONS::quit.MakeEvent() );
2834
2835 // Footprint library actions
2840
2841 // Display modes
2858
2859 // Layer control
2897
2900
2901 // Grid control
2904
2905 Go( &PCB_CONTROL::Undo, ACTIONS::undo.MakeEvent() );
2906 Go( &PCB_CONTROL::Redo, ACTIONS::redo.MakeEvent() );
2907
2908 // Snapping control
2913
2914 // Miscellaneous
2917
2918 // Append control
2927
2928 Go( &PCB_CONTROL::Paste, ACTIONS::paste.MakeEvent() );
2930
2937
2938 // Add library by dropping file
2941}
2942// clang-format on
int color
@ ERROR_OUTSIDE
@ ERROR_INSIDE
constexpr EDA_IU_SCALE pcbIUScale
Definition base_units.h:112
constexpr int ARC_LOW_DEF
Definition base_units.h:128
constexpr EDA_IU_SCALE unityScale
Definition base_units.h:115
#define DEFAULT_LINE_WIDTH
@ NORMAL
Inactive layers are shown normally (no high-contrast mode)
@ HIDDEN
Inactive layers are hidden.
@ DIMMED
Inactive layers are dimmed (old high-contrast mode)
@ RATSNEST
Net/netclass colors are shown on ratsnest lines only.
@ ALL
Net/netclass colors are shown on all net copper.
@ OFF
Net (and netclass) colors are not shown.
@ VISIBLE
Ratsnest lines are drawn to items on visible layers only.
@ ALL
Ratsnest lines are drawn to items on all layers (default)
@ BS_EDGE_CONNECTOR_BEVELLED
@ BS_EDGE_CONNECTOR_NONE
@ BS_EDGE_CONNECTOR_IN_USE
@ BS_ITEM_TYPE_DIELECTRIC
BOX2< VECTOR2I > BOX2I
Definition box2.h:922
constexpr BOX2I KiROUND(const BOX2D &aBoxD)
Definition box2.h:990
static TOOL_ACTION paste
Definition actions.h:80
static TOOL_ACTION addLibrary
Definition actions.h:56
static TOOL_ACTION pickerTool
Definition actions.h:252
static TOOL_ACTION gridResetOrigin
Definition actions.h:195
static TOOL_ACTION pasteSpecial
Definition actions.h:81
static TOOL_ACTION highContrastModeCycle
Definition actions.h:155
static TOOL_ACTION undo
Definition actions.h:75
static TOOL_ACTION highContrastMode
Definition actions.h:154
static TOOL_ACTION quit
Definition actions.h:66
static TOOL_ACTION redo
Definition actions.h:76
static TOOL_ACTION deleteTool
Definition actions.h:86
static TOOL_ACTION selectionClear
Clear the current selection.
Definition actions.h:223
static TOOL_ACTION print
Definition actions.h:64
static TOOL_ACTION newLibrary
Definition actions.h:55
static TOOL_ACTION gridSetOrigin
Definition actions.h:194
static TOOL_ACTION ddAddLibrary
Definition actions.h:67
static TOOL_ACTION selectItems
Select a list of items (specified as the event parameter)
Definition actions.h:231
static const ADVANCED_CFG & GetCfg()
Get the singleton instance's config, which is shared by all consumers.
APP_SETTINGS_BASE is a settings class that should be derived for each standalone KiCad application.
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.
std::shared_ptr< NET_SETTINGS > m_NetSettings
void SetGridOrigin(const VECTOR2I &aOrigin)
int GetBoardThickness() const
The full thickness of the board including copper and masks.
BOARD_STACKUP & GetStackupDescriptor()
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition board_item.h:79
virtual PCB_LAYER_ID GetLayer() const
Return the primary layer this item is on.
Definition board_item.h:232
virtual bool IsOnLayer(PCB_LAYER_ID aLayer) const
Test to see if this object is on the given layer.
Definition board_item.h:314
virtual std::shared_ptr< SHAPE > GetEffectiveShape(PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING aFlash=FLASHING::DEFAULT) const
Some pad shapes can be complex (rounded/chamfered rectangle), even without considering custom shapes.
FOOTPRINT * GetParentFootprint() const
virtual LSET GetLayerSet() const
Return a std::bitset of all layers on which the item physically resides.
Definition board_item.h:252
virtual bool IsOnCopperLayer() const
Definition board_item.h:151
virtual std::shared_ptr< SHAPE_SEGMENT > GetEffectiveHoleShape() const
virtual bool HasHole() const
Definition board_item.h:156
Manage one layer needed to make a physical board.
wxString GetTypeName() const
int GetSublayersCount() const
double GetEpsilonR(int aDielectricSubLayer=0) const
wxString GetColor(int aDielectricSubLayer=0) const
wxString GetLayerName() const
PCB_LAYER_ID GetBrdLayerId() const
bool IsThicknessEditable() const
int GetThickness(int aDielectricSubLayer=0) const
BOARD_STACKUP_ITEM_TYPE GetType() const
wxString GetMaterial(int aDielectricSubLayer=0) const
double GetLossTangent(int aDielectricSubLayer=0) const
Manage layers needed to make a physical board.
const std::vector< BOARD_STACKUP_ITEM * > & GetList() const
int GetCount() const
bool SynchronizeWithBoard(BOARD_DESIGN_SETTINGS *aSettings)
Synchronize the BOARD_STACKUP_ITEM* list with the board.
bool m_HasDielectricConstrains
True if some layers have impedance controlled tracks or have specific constrains for micro-wave appli...
bool m_EdgePlating
True if the edge board is plated.
BS_EDGE_CONNECTOR_CONSTRAINTS m_EdgeConnectorConstraints
If the board has edge connector cards, some constrains can be specified in job file: BS_EDGE_CONNECTO...
wxString m_FinishType
The name of external copper finish.
Information pertinent to a Pcbnew printed circuit board.
Definition board.h:317
INSPECT_RESULT Visit(INSPECTOR inspector, void *testData, const std::vector< KICAD_T > &scanTypes) override
May be re-implemented for each derived class in order to handle all the types given by its member dat...
Definition board.cpp:1994
EMBEDDED_FILES * GetEmbeddedFiles() override
Definition board.cpp:2710
void SetVisibleLayers(const LSET &aLayerMask)
A proxy function that calls the correspondent function in m_BoardSettings changes the bit-mask of vis...
Definition board.cpp:955
void MapNets(BOARD *aDestBoard)
Map all nets in the given board to nets with the same name (if any) in the destination board.
Definition board.cpp:2805
void BuildListOfNets()
Definition board.h:896
const GENERATORS & Generators() const
Definition board.h:364
const std::vector< BOARD_CONNECTED_ITEM * > AllConnectedItems()
Definition board.cpp:2779
const PAGE_INFO & GetPageSettings() const
Definition board.h:741
void SetProperties(const std::map< wxString, wxString > &aProps)
Definition board.h:396
const ZONES & Zones() const
Definition board.h:362
const GROUPS & Groups() const
The groups must maintain the following invariants.
Definition board.h:391
bool BuildConnectivity(PROGRESS_REPORTER *aReporter=nullptr)
Build or rebuild the board connectivity database for the board, especially the list of connected item...
Definition board.cpp:188
void SynchronizeNetsAndNetClasses(bool aResetTrackAndViaSizes)
Copy NETCLASS info to each NET, based on NET membership in a NETCLASS.
Definition board.cpp:2287
FOOTPRINT * GetFirstFootprint() const
Get the first footprint on the board or nullptr.
Definition board.h:488
TITLE_BLOCK & GetTitleBlock()
Definition board.h:747
int GetCopperLayerCount() const
Definition board.cpp:875
const std::map< wxString, wxString > & GetProperties() const
Definition board.h:395
const FOOTPRINTS & Footprints() const
Definition board.h:358
void RemoveAll(std::initializer_list< KICAD_T > aTypes={ PCB_NETINFO_T, PCB_MARKER_T, PCB_GROUP_T, PCB_ZONE_T, PCB_GENERATOR_T, PCB_FOOTPRINT_T, PCB_TRACE_T, PCB_SHAPE_T })
An efficient way to remove all items of a certain type from the board.
Definition board.cpp:1443
const TRACKS & Tracks() const
Definition board.h:356
void SetPageSettings(const PAGE_INFO &aPageSettings)
Definition board.h:742
void SetCopperLayerCount(int aCount)
Definition board.cpp:881
bool IsLayerVisible(PCB_LAYER_ID aLayer) const
A proxy function that calls the correspondent function in m_BoardSettings tests whether a given layer...
Definition board.cpp:929
const LSET & GetEnabledLayers() const
A proxy function that calls the corresponding function in m_BoardSettings.
Definition board.cpp:923
void SetEnabledLayers(const LSET &aLayerMask)
A proxy function that calls the correspondent function in m_BoardSettings.
Definition board.cpp:943
void SetTitleBlock(const TITLE_BLOCK &aTitleBlock)
Definition board.h:749
const DRAWINGS & Drawings() const
Definition board.h:360
constexpr size_type GetWidth() const
Definition box2.h:214
constexpr size_type GetHeight() const
Definition box2.h:215
constexpr BOX2< Vec > GetInflated(coord_type aDx, coord_type aDy) const
Get a new rectangle that is this one, inflated by aDx and aDy.
Definition box2.h:638
BOARD_ITEM * Parse()
int GetCount() const
Return the number of objects in the list.
Definition collector.h:83
void Remove(int aIndex)
Remove the item at aIndex (first position is 0).
Definition collector.h:111
int m_Threshold
Definition collector.h:236
Color settings are a bit different than most of the settings objects in that there can be more than o...
void SetColor(int aLayer, const COLOR4D &aColor)
COLOR4D GetColor(int aLayer) const
COMMIT & Added(EDA_ITEM *aItem, BASE_SCREEN *aScreen=nullptr)
Notify observers that aItem has been added.
Definition commit.h:84
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:106
COMMIT & Add(EDA_ITEM *aItem, BASE_SCREEN *aScreen=nullptr)
Add a new item to the model.
Definition commit.h:78
DO_NOT_SHOW_AGAIN m_DoNotShowAgain
void SelectLibId(const LIB_ID &aLibId)
LIB_ID GetSelectedLibId(int *aUnit=nullptr) const
DESIGN_BLOCK * GetDesignBlock(const LIB_ID &aLibId, bool aUseCacheLib, bool aShowErrorMsg)
Load design block from design block library table.
const LIB_ID & GetLibId() const
int ShowModal() override
wxString GetName() const
Definition drc_rule.h:170
MINOPTMAX< int > & Value()
Definition drc_rule.h:163
MINOPTMAX< int > m_Value
Definition drc_rule.h:204
virtual APP_SETTINGS_BASE * config() const
Return the settings object used in SaveSettings(), and is overloaded in KICAD_MANAGER_FRAME.
virtual void Refresh(bool aEraseBackground=true, const wxRect *aRect=nullptr) override
A set of EDA_ITEMs (i.e., without duplicates).
Definition eda_group.h:46
void RemoveItem(EDA_ITEM *aItem)
Remove item from group.
Definition eda_group.cpp:40
A base class for most all the KiCad significant classes used in schematics and boards.
Definition eda_item.h:98
virtual void SetPosition(const VECTOR2I &aPos)
Definition eda_item.h:273
virtual const BOX2I GetBoundingBox() const
Return the orthogonal bounding box of this object for display purposes.
Definition eda_item.cpp:110
void SetFlags(EDA_ITEM_FLAGS aMask)
Definition eda_item.h:142
virtual wxString GetItemDescription(UNITS_PROVIDER *aUnitsProvider, bool aFull) const
Return a user-visible description string of this item.
Definition eda_item.cpp:144
const KIID m_Uuid
Definition eda_item.h:516
virtual EDA_GROUP * GetParentGroup() const
Definition eda_item.h:116
KICAD_T Type() const
Returns the type of object.
Definition eda_item.h:110
void ClearFlags(EDA_ITEM_FLAGS aMask=EDA_ITEM_ALL_FLAGS)
Definition eda_item.h:144
virtual void GetMsgPanelInfo(EDA_DRAW_FRAME *aFrame, std::vector< MSG_PANEL_ITEM > &aList)
Populate aList of MSG_PANEL_ITEM objects with it's internal state for display purposes.
Definition eda_item.h:220
virtual void SetParent(EDA_ITEM *aParent)
Definition eda_item.h:113
bool HasFlag(EDA_ITEM_FLAGS aFlag) const
Definition eda_item.h:146
SHAPE_T GetShape() const
Definition eda_shape.h:168
double GetLength() const
void SetTextSize(VECTOR2I aNewSize, bool aEnforceMinTextSize=true)
Definition eda_text.cpp:534
void SetTextThickness(int aWidth)
The TextThickness is that set by the user.
Definition eda_text.cpp:285
virtual void SetText(const wxString &aText)
Definition eda_text.cpp:271
void SetHorizJustify(GR_TEXT_H_ALIGN_T aType)
Definition eda_text.cpp:410
The interactive edit tool.
Definition edit_tool.h:56
void DeleteItems(const PCB_SELECTION &aItem, bool aIsCut)
EMBEDDED_FILE * AddFile(const wxFileName &aName, bool aOverwrite)
Load a file from disk and adds it to the collection.
static const TOOL_EVENT ClearedEvent
Definition actions.h:348
static const TOOL_EVENT SelectedEvent
Definition actions.h:346
static const TOOL_EVENT SelectedItemsModified
Selected items were moved, this can be very high frequency on the canvas, use with care.
Definition actions.h:353
static const TOOL_EVENT PointSelectedEvent
Definition actions.h:345
static const TOOL_EVENT ContrastModeChangedByKeyEvent
Definition actions.h:367
static const TOOL_EVENT ConnectivityChangedEvent
Selected item had a property changed (except movement)
Definition actions.h:350
static const TOOL_EVENT UnselectedEvent
Definition actions.h:347
Provide an extensible class to resolve 3D model paths.
Component library viewer main window.
EDA_ANGLE GetOrientation() const
Definition footprint.h:248
ZONES & Zones()
Definition footprint.h:230
std::deque< PAD * > & Pads()
Definition footprint.h:224
void ResolveComponentClassNames(BOARD *aBoard, const std::unordered_set< wxString > &aComponentClassNames)
Resolves a set of component class names to this footprint's actual component class.
const std::unordered_set< wxString > & GetTransientComponentClassNames()
Gets the transient component class names.
Definition footprint.h:1054
void SetReference(const wxString &aReference)
Definition footprint.h:667
bool IsLocked() const override
Definition footprint.h:454
void ClearTransientComponentClassNames()
Remove the transient component class names.
Definition footprint.h:1060
void GetMsgPanelInfo(EDA_DRAW_FRAME *aFrame, std::vector< MSG_PANEL_ITEM > &aList) override
Populate aList of MSG_PANEL_ITEM objects with it's internal state for display purposes.
GROUPS & Groups()
Definition footprint.h:233
void GetFields(std::vector< PCB_FIELD * > &aVector, bool aVisibleOnly) const
Populate a std::vector with PCB_TEXTs.
const wxString & GetReference() const
Definition footprint.h:661
DRAWINGS & GraphicalItems()
Definition footprint.h:227
A general implementation of a COLLECTORS_GUIDE.
Definition collectors.h:324
Used when the right click button is pressed, or when the select tool is in effect.
Definition collectors.h:207
static const std::vector< KICAD_T > BoardLevelItems
A scan list for all primary board items, omitting items which are subordinate to a FOOTPRINT,...
Definition collectors.h:68
static const std::vector< KICAD_T > AllBoardItems
A scan list for all editable board items.
Definition collectors.h:41
void Collect(BOARD_ITEM *aItem, const std::vector< KICAD_T > &aScanList, const VECTOR2I &aRefPos, const COLLECTORS_GUIDE &aGuide)
Scan a BOARD_ITEM using this class's Inspector method, which does the collection.
static const std::vector< KICAD_T > FootprintItems
A scan list for primary footprint items.
Definition collectors.h:105
Similar to EDA_VIEW_SWITCHER, this dialog is a popup that shows feedback when using a hotkey to cycle...
void Popup(const wxString &aTitle, const wxArrayString &aItems, int aSelection)
virtual void SetProgressReporter(PROGRESS_REPORTER *aReporter)
Set an optional progress reporter.
Definition io_base.h:89
Hold an error message and may be used when throwing exceptions containing meaningful error messages.
virtual const wxString What() const
A composite of Problem() and Where()
Helper class to create more flexible dialogs, including 'do not show again' checkbox handling.
Definition kidialog.h:42
void DoNotShowCheckbox(wxString file, int line)
Shows the 'do not show again' checkbox.
Definition kidialog.cpp:55
int ShowModal() override
Definition kidialog.cpp:93
A color representation with 4 components: red, green, blue, alpha.
Definition color4d.h:104
double a
Alpha component.
Definition color4d.h:395
void SetGridOrigin(const VECTOR2D &aGridOrigin)
Set the origin point for the grid.
virtual void Update(const VIEW_ITEM *aItem, int aUpdateFlags) const override
For dynamic VIEWs, inform the associated VIEW that the graphical representation of this item has chan...
Definition pcb_view.cpp:91
virtual void SetCursorPosition(const VECTOR2D &aPosition, bool aWarpView=true, bool aTriggeredByArrows=false, long aArrowCommand=0)=0
Move cursor to the requested position expressed in world coordinates.
bool IsBOARD_ITEM() const
Definition view_item.h:102
Hold a (potentially large) number of VIEW_ITEMs and renders them on a graphics device provided by the...
Definition view.h:66
void SetMirror(bool aMirrorX, bool aMirrorY)
Control the mirroring of the VIEW.
Definition view.cpp:557
virtual void Add(VIEW_ITEM *aItem, int aDrawPriority=-1)
Add a VIEW_ITEM to the view.
Definition view.cpp:298
virtual void Remove(VIEW_ITEM *aItem)
Remove a VIEW_ITEM from the view.
Definition view.cpp:341
GAL * GetGAL() const
Return the GAL this view is using to draw graphical primitives.
Definition view.h:202
void RecacheAllItems()
Rebuild GAL display lists.
Definition view.cpp:1451
void MarkDirty()
Force redraw of view on the next rendering.
Definition view.h:659
Definition kiid.h:49
All information about a layer pair as stored in the layer pair store.
Management class for layer pairs in a PCB.
Definition layer_pairs.h:47
std::vector< LAYER_PAIR_INFO > GetEnabledLayerPairs(int &aCurrentIndex) const
Get a vector of all enabled layer pairs, in order.
void SetCurrentLayerPair(const LAYER_PAIR &aPair)
Set the "active" layer pair.
bool IsValid() const
Check if this LID_ID is valid.
Definition lib_id.h:172
const UTF8 & GetLibItemName() const
Definition lib_id.h:102
LSEQ is a sequence (and therefore also a set) of PCB_LAYER_IDs.
Definition lseq.h:47
LSET is a set of PCB_LAYER_IDs.
Definition lset.h:37
LSEQ UIOrder() const
Return the copper, technical and user layers in the order shown in layer widget.
Definition lset.cpp:726
LSEQ CuStack() const
Return a sequence of copper layers in starting from the front/top and extending to the back/bottom.
Definition lset.cpp:246
static LSET AllCuMask(int aCuLayerCount)
Return a mask holding the requested number of Cu PCB_LAYER_IDs.
Definition lset.cpp:582
static LSET AllCuMask()
return AllCuMask( MAX_CU_LAYERS );
Definition lset.cpp:591
T Min() const
Definition minoptmax.h:33
bool HasMax() const
Definition minoptmax.h:38
T Max() const
Definition minoptmax.h:34
EDA_MSG_PANEL items for displaying messages.
Definition msgpanel.h:54
int RepeatLayout(const TOOL_EVENT &aEvent, ZONE *aRefZone)
Handle the data for a net.
Definition netinfo.h:54
static NETINFO_ITEM * OrphanedItem()
NETINFO_ITEM meaning that there was no net assigned for an item, as there was no board storing net li...
Definition netinfo.h:373
void ClearNetclasses()
Clears all netclasses Calling this method will reset the effective netclass calculation caches.
Definition pad.h:54
bool HasHole() const override
Definition pad.h:106
Describe the page size and margins of a paper page on which to eventually print or plot.
Definition page_info.h:79
static TOOL_ACTION layerToggle
static TOOL_ACTION layerInner12
static TOOL_ACTION nextFootprint
static TOOL_ACTION layerInner8
static TOOL_ACTION zoneDisplayToggle
static TOOL_ACTION previousFootprint
static TOOL_ACTION layerInner3
static TOOL_ACTION layerPrev
static TOOL_ACTION showRatsnest
static TOOL_ACTION zoneFillAll
static TOOL_ACTION layerInner2
static TOOL_ACTION magneticSnapAllLayers
static TOOL_ACTION collect3DModels
static TOOL_ACTION saveToLinkedDesignBlock
static TOOL_ACTION ddAppendBoard
Drag and drop.
static TOOL_ACTION layerInner25
static TOOL_ACTION magneticSnapActiveLayer
Snapping controls.
static TOOL_ACTION layerAlphaDec
static TOOL_ACTION zoneDisplayFilled
static TOOL_ACTION layerInner24
static TOOL_ACTION viaDisplayMode
static TOOL_ACTION layerInner29
static TOOL_ACTION placeCharacteristics
static TOOL_ACTION layerInner11
static TOOL_ACTION layerAlphaInc
static TOOL_ACTION layerPairPresetsCycle
static TOOL_ACTION layerInner16
static TOOL_ACTION layerInner26
static TOOL_ACTION layerInner18
static TOOL_ACTION layerInner14
static TOOL_ACTION trackDisplayMode
static TOOL_ACTION magneticSnapToggle
static TOOL_ACTION layerInner6
static TOOL_ACTION applyDesignBlockLayout
static TOOL_ACTION ddImportFootprint
static TOOL_ACTION zoneDisplayTriangulated
static TOOL_ACTION rehatchShapes
static TOOL_ACTION layerInner22
static TOOL_ACTION placeDesignBlock
static TOOL_ACTION layerInner5
static TOOL_ACTION zoneDisplayFractured
static TOOL_ACTION ratsnestModeCycle
static TOOL_ACTION layerInner20
static TOOL_ACTION layerInner7
static TOOL_ACTION layerInner27
static TOOL_ACTION loadFpFromBoard
static TOOL_ACTION appendBoard
static TOOL_ACTION netColorModeCycle
static TOOL_ACTION layerInner1
static TOOL_ACTION layerInner10
static TOOL_ACTION layerInner15
static TOOL_ACTION layerInner17
static TOOL_ACTION flipBoard
static TOOL_ACTION layerBottom
static TOOL_ACTION zoneDisplayOutline
static TOOL_ACTION ratsnestLineMode
static TOOL_ACTION layerInner19
static TOOL_ACTION layerInner9
static TOOL_ACTION saveSelectionToDesignBlock
static TOOL_ACTION move
move or drag an item
static TOOL_ACTION layerInner30
static TOOL_ACTION layerTop
static TOOL_ACTION layerInner4
static TOOL_ACTION layerInner13
static TOOL_ACTION layerInner21
static TOOL_ACTION saveFpToBoard
static TOOL_ACTION layerNext
static TOOL_ACTION placeLinkedDesignBlock
static TOOL_ACTION placeStackup
static TOOL_ACTION layerInner23
static TOOL_ACTION layerInner28
Common, abstract interface for edit frames.
void RestoreCopyFromUndoList(wxCommandEvent &aEvent)
Undo the last edit:
APPEARANCE_CONTROLS * GetAppearancePanel()
void RestoreCopyFromRedoList(wxCommandEvent &aEvent)
Redo the last edit:
Base PCB main window class for Pcbnew, Gerbview, and CvPcb footprint viewer.
const VECTOR2I GetPageSizeIU() const override
Works off of GetPageSettings() to return the size of the paper page in the internal units of this par...
void OnModify() override
Must be called after a change in order to set the "modify" flag and update other data structures and ...
BOARD * GetBoard() const
virtual BOARD_DESIGN_SETTINGS & GetDesignSettings() const
Return the BOARD_DESIGN_SETTINGS for the open project.
int RehatchShapes(const TOOL_EVENT &aEvent)
void setTransitions() override
< Sets up handlers for various events.
int AppendBoardFromFile(const TOOL_EVENT &aEvent)
int AddLibrary(const TOOL_EVENT &aEvent)
int DdAppendBoard(const TOOL_EVENT &aEvent)
int LoadFpFromBoard(const TOOL_EVENT &aEvent)
int SaveToLinkedDesignBlock(const TOOL_EVENT &aEvent)
int DdImportFootprint(const TOOL_EVENT &aEvent)
int SnapModeFeedback(const TOOL_EVENT &aEvent)
int NetColorModeCycle(const TOOL_EVENT &aEvent)
int SaveFpToBoard(const TOOL_EVENT &aEvent)
int RatsnestModeCycle(const TOOL_EVENT &aEvent)
int TrackDisplayMode(const TOOL_EVENT &aEvent)
int DdAddLibrary(const TOOL_EVENT &aEvent)
int Redo(const TOOL_EVENT &aEvent)
int PlaceLinkedDesignBlock(const TOOL_EVENT &aEvent)
bool placeBoardItems(BOARD_COMMIT *aCommit, std::vector< BOARD_ITEM * > &aItems, bool aIsNew, bool aAnchorAtOrigin, bool aReannotateDuplicates, bool aSkipMove)
Add and select or just select for move/place command a list of board items.
int LayerPresetFeedback(const TOOL_EVENT &aEvent)
int UpdateMessagePanel(const TOOL_EVENT &aEvent)
int LayerAlphaDec(const TOOL_EVENT &aEvent)
int LayerNext(const TOOL_EVENT &aEvent)
int PlaceStackup(const TOOL_EVENT &aEvent)
std::unique_ptr< STATUS_TEXT_POPUP > m_statusPopup
int ToggleRatsnest(const TOOL_EVENT &aEvent)
int LayerAlphaInc(const TOOL_EVENT &aEvent)
int HighContrastModeCycle(const TOOL_EVENT &aEvent)
std::unique_ptr< KIGFX::ORIGIN_VIEWITEM > m_gridOrigin
int Quit(const TOOL_EVENT &aEvent)
int HighContrastMode(const TOOL_EVENT &aEvent)
int Undo(const TOOL_EVENT &aEvent)
int ViaDisplayMode(const TOOL_EVENT &aEvent)
PCB_BASE_FRAME * m_frame
static void DoSetGridOrigin(KIGFX::VIEW *aView, PCB_BASE_FRAME *aFrame, EDA_ITEM *originViewItem, const VECTOR2D &aPoint)
int CollectAndEmbed3DModels(const TOOL_EVENT &aEvent)
void pruneItemLayers(std::vector< BOARD_ITEM * > &aItems)
Helper for pasting.
int GridPlaceOrigin(const TOOL_EVENT &aEvent)
int FlipPcbView(const TOOL_EVENT &aEvent)
int PlaceCharacteristics(const TOOL_EVENT &aEvent)
int ApplyDesignBlockLayout(const TOOL_EVENT &aEvent)
int SnapMode(const TOOL_EVENT &aEvent)
int ContrastModeFeedback(const TOOL_EVENT &aEvent)
int LayerToggle(const TOOL_EVENT &aEvent)
int AppendBoard(PCB_IO &pi, const wxString &fileName, DESIGN_BLOCK *aDesignBlock=nullptr, BOARD_COMMIT *aCommit=nullptr, bool aSkipMove=false)
void Reset(RESET_REASON aReason) override
Bring the tool to a known, initial state.
int IterateFootprint(const TOOL_EVENT &aEvent)
int Print(const TOOL_EVENT &aEvent)
void rehatchBoardItem(BOARD_ITEM *aItem)
int ZoneDisplayMode(const TOOL_EVENT &aEvent)
int GridResetOrigin(const TOOL_EVENT &aEvent)
BOARD_ITEM * m_pickerItem
int InteractiveDelete(const TOOL_EVENT &aEvent)
int AppendDesignBlock(const TOOL_EVENT &aEvent)
int LayerPrev(const TOOL_EVENT &aEvent)
int CycleLayerPresets(const TOOL_EVENT &aEvent)
int Paste(const TOOL_EVENT &aEvent)
void unfilledZoneCheck()
We have bug reports indicating that some new users confuse zone filling/unfilling with the display mo...
int LayerSwitch(const TOOL_EVENT &aEvent)
Abstract dimension API.
HIGH_CONTRAST_MODE m_ContrastModeDisplay
How inactive layers are displayed.
NET_COLOR_MODE m_NetColorMode
How to use color overrides on specific nets and netclasses.
ZONE_DISPLAY_MODE m_ZoneDisplayMode
void RedrawRatsnest()
Return the bounding box of the view that should be used if model is not valid.
The main frame for Pcbnew.
PCB_DESIGN_BLOCK_PANE * GetDesignBlockPane() const
static const TOOL_EVENT & SnappingModeChangedByKeyEvent()
Hotkey feedback.
static const TOOL_EVENT & LayerPairPresetChangedByKeyEvent()
A set of BOARD_ITEMs (i.e., without duplicates).
Definition pcb_group.h:53
static PCB_IO * PluginFind(PCB_FILE_T aFileType)
Return a #PLUGIN which the caller can use to import, export, save, or load design documents.
PCB_FILE_T
The set of file types that the PCB_IO_MGR knows about, and for which there has been a plugin written,...
Definition pcb_io_mgr.h:56
@ KICAD_SEXP
S-expression Pcbnew file format.
Definition pcb_io_mgr.h:58
static PCB_FILE_T FindPluginTypeFromBoardPath(const wxString &aFileName, int aCtl=0)
Return a plugin type given a path for a board file.
A base class that BOARD loading and saving plugins should derive from.
Definition pcb_io.h:71
virtual void SetQueryUserCallback(std::function< bool(wxString aTitle, int aIcon, wxString aMessage, wxString aAction)> aCallback)
Registers a KIDIALOG callback for collecting info from the user.
Definition pcb_io.h:97
virtual BOARD * LoadBoard(const wxString &aFileName, BOARD *aAppendToMe, const std::map< std::string, UTF8 > *aProperties=nullptr, PROJECT *aProject=nullptr)
Load information from some input file format that this PCB_IO implementation knows about into either ...
Definition pcb_io.cpp:74
Class that manages the presentation of PCB layers in a PCB frame.
wxString getLayerPairName(const LAYER_PAIR &aPair) const
Definition sel_layer.cpp:90
Generic tool for picking an item.
PCB_LAYER_ID m_Route_Layer_TOP
Definition pcb_screen.h:43
PCB_LAYER_ID m_Route_Layer_BOTTOM
Definition pcb_screen.h:44
The selection tool: currently supports:
void GuessSelectionCandidates(GENERAL_COLLECTOR &aCollector, const VECTOR2I &aWhere) const
Try to guess best selection candidates in case multiple items are clicked, by doing some brain-dead h...
void select(EDA_ITEM *aItem) override
Take necessary action mark an item as selected.
bool Selectable(const BOARD_ITEM *aItem, bool checkVisibilityOnly=false) const
PCB_GROUP * GetEnteredGroup()
void FilterCollectorForHierarchy(GENERAL_COLLECTOR &aCollector, bool aMultiselect) const
In general we don't want to select both a parent and any of it's children.
int ClearSelection(const TOOL_EVENT &aEvent)
PCB_SELECTION & GetSelection()
void FilterCollectedItems(GENERAL_COLLECTOR &aCollector, bool aMultiSelect, PCB_SELECTION_FILTER_OPTIONS *aRejected=nullptr)
Apply the SELECTION_FITLER_OPTIONS to the collector.
void SetColSpan(int aSpan)
KIGFX::PCB_VIEW * view() const
PCB_TOOL_BASE(TOOL_ID aId, const std::string &aName)
Constructor.
BOARD * board() const
PCB_DRAW_PANEL_GAL * canvas() const
PCBNEW_SETTINGS::DISPLAY_OPTIONS & displayOptions() const
const PCB_SELECTION & selection() const
FOOTPRINT * footprint() const
const VECTOR2I & GetStart() const
Definition pcb_track.h:152
const VECTOR2I & GetEnd() const
Definition pcb_track.h:149
virtual COMMON_SETTINGS * GetCommonSettings() const
Definition pgm_base.cpp:576
void SetMotionHandler(MOTION_HANDLER aHandler)
Set a handler for mouse motion.
Definition picker_tool.h:92
void SetClickHandler(CLICK_HANDLER aHandler)
Set a handler for mouse click event.
Definition picker_tool.h:81
void SetSnapping(bool aSnap)
Definition picker_tool.h:66
void SetCursor(KICURSOR aCursor)
Definition picker_tool.h:64
void SetFinalizeHandler(FINALIZE_HANDLER aHandler)
Set a handler for the finalize event.
static FP_LIB_TABLE * PcbFootprintLibs(PROJECT *aProject)
Return the table of footprint libraries without Kiway.
static S3D_CACHE * Get3DCacheManager(PROJECT *aProject, bool updateProjDir=false)
Return a pointer to an instance of the 3D cache manager.
Container for project specific data.
Definition project.h:65
virtual const wxString GetProjectPath() const
Return the full path of the project.
Definition project.cpp:162
Cache for storing the 3D shapes.
Definition 3d_cache.h:55
FILENAME_RESOLVER * GetResolver() noexcept
Definition 3d_cache.cpp:513
Definition seg.h:42
ecoord SquaredDistance(const SEG &aSeg) const
Definition seg.cpp:80
VECTOR2I::extended_type ecoord
Definition seg.h:44
void BrightenItem(EDA_ITEM *aItem)
void UnbrightenItem(EDA_ITEM *aItem)
virtual void Add(EDA_ITEM *aItem)
Definition selection.cpp:42
Represent a polyline containing arcs as well as line segments: A chain of connected line and/or arc s...
Represent a set of closed polygons.
const SHAPE_LINE_CHAIN & COutline(int aIndex) const
const BOX2I BBox(int aClearance=0) const override
Compute a bounding box of the shape, with a margin of aClearance a collision.
virtual VECTOR2I Centre() const
Compute a center-of-mass of the shape.
Definition shape.h:232
Extension of STATUS_POPUP for displaying a single line text.
Hold the information shown in the lower right corner of a plot, printout, or editing view.
Definition title_block.h:41
T * getEditFrame() const
Return the application window object, casted to requested user type.
Definition tool_base.h:186
const std::string & GetName() const
Return the name of the tool.
Definition tool_base.h:136
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
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:171
COMMIT * Commit() const
Definition tool_event.h:283
bool IsAction(const TOOL_ACTION *aAction) const
Test if the event contains an action issued upon activation of the given TOOL_ACTION.
T Parameter() const
Return a parameter assigned to the event.
Definition tool_event.h:473
void Go(int(T::*aStateFunc)(const TOOL_EVENT &), const TOOL_EVENT_LIST &aConditions=TOOL_EVENT(TC_ANY, TA_ANY))
Define which state (aStateFunc) to go when a certain event arrives (aConditions).
void Activate()
Run the tool.
static constexpr extended_type ECOORD_MAX
Definition vector2d.h:76
A modified version of the wxInfoBar class that allows us to:
Definition wx_infobar.h:76
void RemoveAllButtons()
Remove all the buttons that have been added by the user.
void ShowMessageFor(const wxString &aMessage, int aTime, int aFlags=wxICON_INFORMATION, MESSAGE_TYPE aType=WX_INFOBAR::MESSAGE_TYPE::GENERIC)
Show the infobar with the provided message and icon for a specific period of time.
void AddButton(wxButton *aButton)
Add an already created button to the infobar.
Multi-thread safe progress reporter dialog, intended for use of tasks that parallel reporting back of...
Handle a list of polygons defining a copper zone.
Definition zone.h:74
void SetDoNotAllowPads(bool aEnable)
Definition zone.h:728
void AddPolygon(std::vector< VECTOR2I > &aPolygon)
Add a polygon to the zone outline.
Definition zone.cpp:1117
void SetPlacementAreaSource(const wxString &aSource)
Definition zone.h:710
void SetPlacementAreaSourceType(PLACEMENT_SOURCE_T aType)
Definition zone.h:715
SHAPE_POLY_SET * Outline()
Definition zone.h:335
void SetHatchStyle(ZONE_BORDER_DISPLAY_STYLE aStyle)
Definition zone.h:590
void SetIsRuleArea(bool aEnable)
Definition zone.h:705
void SetDoNotAllowTracks(bool aEnable)
Definition zone.h:727
void SetLayerSet(const LSET &aLayerSet) override
Definition zone.cpp:511
void SetDoNotAllowVias(bool aEnable)
Definition zone.h:726
void SetDoNotAllowFootprints(bool aEnable)
Definition zone.h:729
void SetDoNotAllowZoneFills(bool aEnable)
Definition zone.h:725
void SetZoneName(const wxString &aName)
Definition zone.h:164
void SetPlacementAreaEnabled(bool aEnabled)
Definition zone.h:707
std::string GetClipboardUTF8()
Return the information currently stored in the system clipboard.
Definition clipboard.cpp:58
std::unique_ptr< wxImage > GetImageFromClipboard()
Get image data from the clipboard, if there is any.
Definition clipboard.cpp:84
bool IsOK(wxWindow *aParent, const wxString &aMessage)
Display a yes/no dialog with aMessage and returns the user response.
Definition confirm.cpp:251
void DisplayErrorMessage(wxWindow *aParent, const wxString &aText, const wxString &aExtraInfo)
Display an error message with aMessage.
Definition confirm.cpp:194
void DisplayError(wxWindow *aParent, const wxString &aText)
Display an error or warning message box with aMessage.
Definition confirm.cpp:169
This file is part of the common library.
void TransformCircleToPolygon(SHAPE_LINE_CHAIN &aBuffer, const VECTOR2I &aCenter, int aRadius, int aError, ERROR_LOC aErrorLoc, int aMinSegCount=0)
Convert a circle to a polygon, using multiple straight lines.
void BuildConvexHull(std::vector< VECTOR2I > &aResult, const std::vector< VECTOR2I > &aPoly)
Calculate the convex hull of a list of points in counter-clockwise order.
@ REMOVE
Definition cursors.h:52
@ PLACE
Definition cursors.h:96
@ ARROW
Definition cursors.h:46
#define ALPHA_MAX
@ DIFF_PAIR_GAP_CONSTRAINT
Definition drc_rule.h:73
@ EDGE_CLEARANCE_CONSTRAINT
Definition drc_rule.h:53
@ CLEARANCE_CONSTRAINT
Definition drc_rule.h:49
@ MAX_UNCOUPLED_CONSTRAINT
Definition drc_rule.h:74
@ HOLE_CLEARANCE_CONSTRAINT
Definition drc_rule.h:51
#define _(s)
Declaration of the eda_3d_viewer class.
@ RECURSE
Definition eda_item.h:51
@ NO_RECURSE
Definition eda_item.h:52
std::vector< EDA_ITEM * > EDA_ITEMS
Define list of drawing items for screens.
Definition eda_item.h:566
#define MCT_SKIP_STRUCT
flag used by the multichannel tool to mark items that should be skipped
#define SKIP_STRUCT
flag indicating that the structure should be ignored
@ SEGMENT
Definition eda_shape.h:45
static FILENAME_RESOLVER * resolver
@ FRAME_PCB_EDITOR
Definition frame_type.h:42
@ FRAME_FOOTPRINT_VIEWER
Definition frame_type.h:45
@ FRAME_FOOTPRINT_EDITOR
Definition frame_type.h:43
static const std::string KiCadUriPrefix
wxString KeyNameFromKeyCode(int aKeycode, bool *aIsFound)
Return the key name from the key code.
std::unique_ptr< T > IO_RELEASER
Helper to hold and release an IO_BASE object when exceptions are thrown.
Definition io_mgr.h:33
#define KICTL_KICAD_ONLY
chosen file is from KiCad according to user
int GetNetnameLayer(int aLayer)
Return a netname layer corresponding to the given layer.
Definition layer_ids.h:850
bool IsCopperLayer(int aLayerId)
Test whether a layer is a copper layer.
Definition layer_ids.h:674
@ LAYER_RATSNEST
Definition layer_ids.h:252
PCB_LAYER_ID
A quick note on layer IDs:
Definition layer_ids.h:60
@ Edge_Cuts
Definition layer_ids.h:112
@ B_Cu
Definition layer_ids.h:65
@ Margin
Definition layer_ids.h:113
@ UNDEFINED_LAYER
Definition layer_ids.h:61
@ F_Cu
Definition layer_ids.h:64
#define ZONE_LAYER_FOR(boardLayer)
Definition layer_ids.h:367
bool IsValidLayer(int aLayerId)
Test whether a given integer is a valid layer index, i.e.
Definition layer_ids.h:652
std::optional< wxString > GetMsgPanelDisplayUuid(const KIID &aKiid)
Get a formatted UUID string for display in the message panel, according to the current advanced confi...
Definition msgpanel.cpp:245
KICOMMON_API wxString StringFromValue(const EDA_IU_SCALE &aIuScale, EDA_UNITS aUnits, double aValue, bool aAddUnitsText=false, EDA_DATA_TYPE aType=EDA_DATA_TYPE::DISTANCE)
Return the string from aValue according to aUnits (inch, mm ...) for display.
SHAPE_LINE_CHAIN RectifyPolygon(const SHAPE_LINE_CHAIN &aPoly)
void CollectBoxCorners(const BOX2I &aBox, std::vector< VECTOR2I > &aCorners)
Add the 4 corners of a BOX2I to a vector.
@ REPAINT
Item needs to be redrawn.
Definition view_item.h:58
wxPoint GetMousePosition()
Returns the mouse position in screen coordinates.
Definition wxgtk/ui.cpp:689
bool contains(const _Container &__container, _Value __value)
Returns true if the container contains the given value.
Definition kicad_algo.h:100
bool AskLoadBoardFileName(PCB_EDIT_FRAME *aParent, wxString *aFileName, int aCtl=0)
Show a wxFileDialog asking for a BOARD filename to open.
#define ALPHA_STEP
static void pasteFootprintItemsToFootprintEditor(FOOTPRINT *aClipFootprint, BOARD *aBoard, std::vector< BOARD_ITEM * > &aPastedItems)
#define ALPHA_MIN
void Flip(T &aValue)
static void moveUnflaggedItems(const std::deque< T > &aList, std::vector< BOARD_ITEM * > &aTarget, bool aIsNew)
Class to handle a set of BOARD_ITEMs.
bool AskLoadBoardFileName(PCB_EDIT_FRAME *aParent, wxString *aFileName, int aCtl=0)
Show a wxFileDialog asking for a BOARD filename to open.
PGM_BASE & Pgm()
The global program "get" accessor.
Definition pgm_base.cpp:913
see class PGM_BASE
#define HITTEST_THRESHOLD_PIXELS
Utility functions for working with shapes.
std::vector< FAB_LAYER_COLOR > dummy
wxString NotSpecifiedPrm()
wxString UnescapeString(const wxString &aSource)
wxString InitialCaps(const wxString &aString)
Capitalize only the first word.
VECTOR2I m_center
std::unordered_set< EDA_ITEM * > m_designBlockItems
PLACEMENT_SOURCE_T m_sourceType
std::set< FOOTPRINT * > m_components
VECTOR2I center
int actual
wxString result
Test unit parsing edge cases and error handling.
@ GR_TEXT_H_ALIGN_RIGHT
constexpr KICAD_T BaseType(const KICAD_T aType)
Return the underlying type of the given type.
Definition typeinfo.h:252
@ PCB_T
Definition typeinfo.h:82
@ PCB_SHAPE_T
class PCB_SHAPE, a segment not on copper layers
Definition typeinfo.h:88
@ PCB_DIM_ORTHOGONAL_T
class PCB_DIM_ORTHOGONAL, a linear dimension constrained to x/y
Definition typeinfo.h:105
@ PCB_DIM_LEADER_T
class PCB_DIM_LEADER, a leader dimension (graphic item)
Definition typeinfo.h:102
@ 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_DIM_CENTER_T
class PCB_DIM_CENTER, a center point marking (graphic item)
Definition typeinfo.h:103
@ PCB_GROUP_T
class PCB_GROUP, a set of BOARD_ITEMs
Definition typeinfo.h:110
@ PCB_TEXTBOX_T
class PCB_TEXTBOX, wrapped text on a layer
Definition typeinfo.h:93
@ PCB_TEXT_T
class PCB_TEXT, text on a layer
Definition typeinfo.h:92
@ PCB_MARKER_T
class PCB_MARKER, a marker used to show something
Definition typeinfo.h:99
@ PCB_FOOTPRINT_T
class FOOTPRINT, a footprint
Definition typeinfo.h:86
@ PCB_DIM_ALIGNED_T
class PCB_DIM_ALIGNED, a linear dimension (graphic item)
Definition typeinfo.h:101
@ PCB_PAD_T
class PAD, a pad in a footprint
Definition typeinfo.h:87
@ PCB_ARC_T
class PCB_ARC, an arc track segment on a copper layer
Definition typeinfo.h:98
@ PCB_DIMENSION_T
class PCB_DIMENSION_BASE: abstract dimension meta-type
Definition typeinfo.h:100
@ PCB_TABLE_T
class PCB_TABLE, table of PCB_TABLECELLs
Definition typeinfo.h:94
@ PCB_TRACE_T
class PCB_TRACK, a track segment (segment on a copper layer)
Definition typeinfo.h:96
@ PCB_DIM_RADIAL_T
class PCB_DIM_RADIAL, a radius or diameter dimension
Definition typeinfo.h:104
VECTOR2< int32_t > VECTOR2I
Definition vector2d.h:695
VECTOR2< double > VECTOR2D
Definition vector2d.h:694
Definition of file extensions used in Kicad.
#define PR_CAN_ABORT