KiCad PCB EDA Suite
Loading...
Searching...
No Matches
footprint_edit_frame.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) 2015 Jean-Pierre Charras, jp.charras at wanadoo.fr
5 * Copyright (C) 2015 SoftPLC Corporation, Dick Hollenbeck <[email protected]>
6 * Copyright (C) 2015-2016 Wayne Stambaugh <[email protected]>
7 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
8 *
9 * This program is free software: you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the
11 * Free Software Foundation, either version 3 of the License, or (at your
12 * option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License along
20 * with this program. If not, see <http://www.gnu.org/licenses/>.
21 */
22
23#include "tool/embed_tool.h"
24#include "tools/convert_tool.h"
25#include "tools/drawing_tool.h"
26#include "tools/edit_tool.h"
29#include "tools/pad_tool.h"
30#include "tools/pcb_actions.h"
31#include "tools/pcb_control.h"
39#include <bitmaps.h>
40#include <board.h>
41#include <footprint.h>
42#include <confirm.h>
45#include <footprint_info_impl.h>
46#include <fp_lib_table.h>
48#include <kiface_base.h>
49#include <kiplatform/app.h>
50#include <kiway.h>
51#include <macros.h>
52#include <pcbnew_id.h>
53#include <pgm_base.h>
54#include <project.h>
55#include <project_pcb.h>
57#include <tool/action_toolbar.h>
58#include <tool/common_control.h>
59#include <tool/common_tools.h>
61#include <tool/selection.h>
64#include <tool/tool_manager.h>
65#include <tool/zoom_tool.h>
66#include <tools/array_tool.h>
73#include <widgets/lib_tree.h>
80
81#include <wx/filedlg.h>
82#include <wx/hyperlink.h>
83
84BEGIN_EVENT_TABLE( FOOTPRINT_EDIT_FRAME, PCB_BASE_FRAME )
85 EVT_MENU( wxID_CLOSE, FOOTPRINT_EDIT_FRAME::CloseFootprintEditor )
86 EVT_MENU( wxID_EXIT, FOOTPRINT_EDIT_FRAME::OnExitKiCad )
87
89
92
94
95 // Drop files event
96 EVT_DROP_FILES( FOOTPRINT_EDIT_FRAME::OnDropFiles )
97
98END_EVENT_TABLE()
99
100
101FOOTPRINT_EDIT_FRAME::FOOTPRINT_EDIT_FRAME( KIWAY* aKiway, wxWindow* aParent ) :
102 PCB_BASE_EDIT_FRAME( aKiway, aParent, FRAME_FOOTPRINT_EDITOR, wxEmptyString,
103 wxDefaultPosition, wxDefaultSize,
106{
107 m_showBorderAndTitleBlock = false; // true to show the frame references
108 m_aboutTitle = _HKI( "KiCad Footprint Editor" );
109 m_editorSettings = nullptr;
110
111 // Give an icon
112 wxIcon icon;
113 wxIconBundle icon_bundle;
114
115 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_modedit, 48 ) );
116 icon_bundle.AddIcon( icon );
117 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_modedit, 128 ) );
118 icon_bundle.AddIcon( icon );
119 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_modedit, 256 ) );
120 icon_bundle.AddIcon( icon );
121 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_modedit_32 ) );
122 icon_bundle.AddIcon( icon );
123 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_modedit_16 ) );
124 icon_bundle.AddIcon( icon );
125
126 SetIcons( icon_bundle );
127
128 // Create GAL canvas
130
131 PCB_DRAW_PANEL_GAL* drawPanel = new PCB_DRAW_PANEL_GAL( this, -1, wxPoint( 0, 0 ), m_frameSize,
133 SetCanvas( drawPanel );
134
136
137 SetBoard( new BOARD() );
138
139 // This board will only be used to hold a footprint for editing
141
142 // In Footprint Editor, the default net clearance is not known (it depends on the actual
143 // board). So we do not show the default clearance, by setting it to 0. The footprint or
144 // pad specific clearance will be shown.
146
147 // Don't show the default board solder mask expansion in the footprint editor. Only the
148 // footprint or pad mask expansions settings should be shown.
150
151 // Ensure all layers and items are visible:
152 // In footprint editor, some layers have no meaning or cannot be used, but we show all of
153 // them, at least to be able to edit a bad layer
155
156 GetGalDisplayOptions().m_axesEnabled = true;
157
158 // In Footprint Editor, set the default paper size to A4 for plot/print
160 SetScreen( new PCB_SCREEN( GetPageSettings().GetSizeIU( pcbIUScale.IU_PER_MILS ) ) );
161
162 // Create the manager and dispatcher & route draw panel events to the dispatcher
163 setupTools();
165
167 m_treePane = new FOOTPRINT_TREE_PANE( this );
168
172 ReCreateLayerBox( false );
173
175
177 m_appearancePanel = new APPEARANCE_CONTROLS( this, GetCanvas(), true );
178 m_propertiesPanel = new PCB_PROPERTIES_PANEL( this, this );
179
180 // LoadSettings() *after* creating m_LayersManager, because LoadSettings() initialize
181 // parameters in m_LayersManager
182 // NOTE: KifaceSettings() will return PCBNEW_SETTINGS if we started from pcbnew
184
186
187 float proportion = GetFootprintEditorSettings()->m_AuiPanels.properties_splitter;
188 m_propertiesPanel->SetSplitterProportion( proportion );
189
191
192 // Fetch a COPY of the config as a lot of these initializations are going to overwrite our
193 // data.
194 int libWidth = 0;
196
198 {
199 libWidth = cfg->m_LibWidth;
200 aui_cfg = cfg->m_AuiPanels;
201 }
202 else
203 {
204 // keep gcc quiet about uninitalized vars:
205 aui_cfg.appearance_panel_tab = 0;
206 aui_cfg.right_panel_width = -1;
207 }
208
209 m_auimgr.SetManagedWindow( this );
210
211 unsigned int auiFlags = wxAUI_MGR_DEFAULT;
212#if !defined( _WIN32 )
213 // Windows cannot redraw the UI fast enough during a live resize and may lead to all kinds
214 // of graphical glitches
215 auiFlags |= wxAUI_MGR_LIVE_RESIZE;
216#endif
217 m_auimgr.SetFlags( auiFlags );
218
219 // Rows; layers 4 - 6
220 m_auimgr.AddPane( m_tbTopMain, EDA_PANE().HToolbar().Name( "TopMainToolbar" )
221 .Top().Layer( 6 ) );
222
223 m_auimgr.AddPane( m_messagePanel, EDA_PANE().Messages().Name( "MsgPanel" )
224 .Bottom().Layer( 6 ) );
225
226 // Columns; layers 1 - 3
227 m_auimgr.AddPane( m_treePane, EDA_PANE().Palette().Name( "Footprints" )
228 .Left().Layer( 4 )
229 .Caption( _( "Libraries" ) )
230 .MinSize( FromDIP( 250 ), -1 ).BestSize( FromDIP( 250 ), -1 ) );
232 .Left().Layer( 3 )
233 .Caption( _( "Properties" ) ).PaneBorder( false )
234 .MinSize( FromDIP( wxSize( 240, 60 ) ) ).BestSize( FromDIP( wxSize( 300, 200 ) ) ) );
235 m_auimgr.AddPane( m_tbLeft, EDA_PANE().VToolbar().Name( "LeftToolbar" )
236 .Left().Layer( 2 ) );
237
238 m_auimgr.AddPane( m_tbRight, EDA_PANE().VToolbar().Name( "RightToolbar" )
239 .Right().Layer(2) );
240 m_auimgr.AddPane( m_appearancePanel, EDA_PANE().Name( "LayersManager" )
241 .Right().Layer( 3 )
242 .Caption( _( "Appearance" ) ).PaneBorder( false )
243 .MinSize( FromDIP( 180 ), -1 ).BestSize( FromDIP( 180 ), -1 ) );
244 m_auimgr.AddPane( m_selectionFilterPanel, EDA_PANE().Palette().Name( "SelectionFilter" )
245 .Right().Layer( 3 ).Position( 2 )
246 .Caption( _( "Selection Filter" ) ).PaneBorder( false )
247 .MinSize( FromDIP( 180 ), -1 ).BestSize( FromDIP( 180 ), -1 ) );
248
249 // Center
250 m_auimgr.AddPane( GetCanvas(), EDA_PANE().Canvas().Name( "DrawFrame" )
251 .Center() );
252
253 m_auimgr.GetPane( "LayersManager" ).Show( m_show_layer_manager_tools );
254 m_auimgr.GetPane( "SelectionFilter" ).Show( m_show_layer_manager_tools );
255 m_auimgr.GetPane( PropertiesPaneName() ).Show( GetSettings()->m_AuiPanels.show_properties );
256
257 // The selection filter doesn't need to grow in the vertical direction when docked
258 m_auimgr.GetPane( "SelectionFilter" ).dock_proportion = 0;
259
262 DragAcceptFiles( true );
263
265
266 // Apply saved visibility stuff at the end
267 wxAuiPaneInfo& treePane = m_auimgr.GetPane( "Footprints" );
268 wxAuiPaneInfo& layersManager = m_auimgr.GetPane( "LayersManager" );
269
270 if( libWidth > 0 )
271 SetAuiPaneSize( m_auimgr, treePane, libWidth, -1 );
272
273 if( aui_cfg.right_panel_width > 0 )
274 SetAuiPaneSize( m_auimgr, layersManager, aui_cfg.right_panel_width, -1 );
275
276 m_appearancePanel->SetTabIndex( aui_cfg.appearance_panel_tab );
277
279 {
280 m_appearancePanel->SetUserLayerPresets( cfg->m_LayerPresets );
281 m_appearancePanel->ApplyLayerPreset( cfg->m_ActiveLayerPreset );
282 }
283
284 // restore the last footprint from the project, if any, after the library has been init'ed
285 // N.B. This needs to happen after the AUI manager has been initialized so that we can
286 // properly call the WX_INFOBAR without crashing on some systems.
288
289 // This displays the last footprint loaded, if any, so it must be done after restoreLastFootprint()
291
292 GetToolManager()->PostAction( ACTIONS::zoomFitScreen );
293 UpdateTitle();
295
297
298 // Default shutdown reason until a file is loaded
299 KIPLATFORM::APP::SetShutdownBlockReason( this, _( "Footprint changes are unsaved" ) );
300
301 // Catch unhandled accelerator command characters that were no handled by the library tree
302 // panel.
304 Bind( wxEVT_CHAR_HOOK, &TOOL_DISPATCHER::DispatchWxEvent, m_toolDispatcher );
305
306 // Ensure the window is on top
307 Raise();
308 Show( true );
309
310 // Register a call to update the toolbar sizes. It can't be done immediately because
311 // it seems to require some sizes calculated that aren't yet (at least on GTK).
312 CallAfter(
313 [this]()
314 {
315 // Ensure the controls on the toolbars all are correctly sized
317 m_treePane->FocusSearchFieldIfExists();
318 } );
319}
320
321
323{
324 // Shutdown all running tools
325 if( m_toolManager )
326 m_toolManager->ShutdownAllTools();
327
328 // save the footprint in the PROJECT
330
331 // Clear the watched file
332 setFPWatcher( nullptr );
333
334 // We passed ownership of these to wxAuiManager.
335 // delete m_selectionFilterPanel;
336 // delete m_appearancePanel;
337 // delete m_treePane;
338}
339
340
342{
344
345 FOOTPRINT* fp = static_cast<FOOTPRINT*>( GetModel() );
346
347 if( fp )
348 {
349 std::vector<MSG_PANEL_ITEM> msgItems;
350 fp->GetMsgPanelInfo( this, msgItems );
351 SetMsgPanel( msgItems );
352 }
353}
354
355
361
362
364{
365 return m_toolManager->GetTool<PCB_SELECTION_TOOL>()->GetSelection();
366}
367
368
370{
371 // switches currently used canvas (Cairo / OpenGL).
372 PCB_BASE_FRAME::SwitchCanvas( aCanvasType );
373
374 GetCanvas()->GetGAL()->SetAxesEnabled( true );
375
376 // The base class method *does not reinit* the layers manager. We must update the layer
377 // widget to match board visibility states, both layers and render columns, and and some
378 // settings dependent on the canvas.
380}
381
382
388
389
391{
392 wxAuiPaneInfo& treePane = m_auimgr.GetPane( m_treePane );
393 treePane.Show( !IsLibraryTreeShown() );
394
395 if( IsLibraryTreeShown() )
396 {
397 // SetAuiPaneSize also updates m_auimgr
398 SetAuiPaneSize( m_auimgr, treePane, m_editorSettings->m_LibWidth, -1 );
399 }
400 else
401 {
402 m_editorSettings->m_LibWidth = m_treePane->GetSize().x;
403 m_auimgr.Update();
404 }
405}
406
407
409{
410 m_treePane->FocusSearchFieldIfExists();
411}
412
413
415{
417 wxAuiPaneInfo& layersManager = m_auimgr.GetPane( "LayersManager" );
418 wxAuiPaneInfo& selectionFilter = m_auimgr.GetPane( "SelectionFilter" );
419
420 // show auxiliary Vertical layers and visibility manager toolbar
422 layersManager.Show( m_show_layer_manager_tools );
423 selectionFilter.Show( m_show_layer_manager_tools );
424
426 {
427 SetAuiPaneSize( m_auimgr, layersManager, settings->m_AuiPanels.right_panel_width, -1 );
428 }
429 else
430 {
431 settings->m_AuiPanels.right_panel_width = m_appearancePanel->GetSize().x;
432 m_auimgr.Update();
433 }
434}
435
436
438{
439 return const_cast<wxAuiManager&>( m_auimgr ).GetPane( m_treePane ).IsShown();
440}
441
442
447
448
450{
451 LIB_ID id;
452
453 if( IsLibraryTreeShown() )
455
456 if( id.GetLibNickname().empty() )
457 id = GetLoadedFPID();
458
459 return id;
460}
461
462
464{
465 FOOTPRINT* footprint = GetBoard()->GetFirstFootprint();
466
467 if( footprint )
468 return LIB_ID( footprint->GetFPID().GetLibNickname(), m_footprintNameWhenLoaded );
469 else
470 return LIB_ID();
471}
472
473
475{
476 if( GetBoard()->GetFirstFootprint() )
477 {
480 }
481
482 GetScreen()->SetContentModified( false );
483}
484
485
487{
488 // If we've already vetted closing this window, then we have no FP anymore
489 if( m_isClosing || !GetBoard() )
490 return false;
491
492 FOOTPRINT* footprint = GetBoard()->GetFirstFootprint();
493
494 return ( footprint && footprint->GetLink() != niluuid );
495}
496
497
499{
500 LIB_ID id = GetLoadedFPID();
501
502 if( id.IsValid() )
503 {
505 Prj().SetRString( PROJECT::PCB_FOOTPRINT_EDITOR_FP_NAME, id.GetLibItemName() );
506 }
507}
508
509
511{
512 const wxString& footprintName = Prj().GetRString( PROJECT::PCB_FOOTPRINT_EDITOR_FP_NAME );
513 const wxString& libNickname = Prj().GetRString( PROJECT::PCB_FOOTPRINT_EDITOR_LIB_NICKNAME );
514
515 if( libNickname.Length() && footprintName.Length() )
516 {
517 LIB_ID id;
518 id.SetLibNickname( libNickname );
519 id.SetLibItemName( footprintName );
520
521 FOOTPRINT* footprint = loadFootprint( id );
522
523 if( footprint )
524 AddFootprintToBoard( footprint );
525 }
526}
527
528
530{
531 FOOTPRINT* footprint = static_cast<FOOTPRINT*>( GetModel() );
532 BOARD& board = *GetBoard();
533
534 // All FPs have these layers enabled
535 LSET enabledLayers = LSET::AllTechMask() | LSET::UserMask();
536
537 const auto configureStackup = [&]( FOOTPRINT_STACKUP aMode, const LSET& aLayerSet )
538 {
539 const LSET cuLayers = aLayerSet & LSET::AllCuMask();
540 board.SetCopperLayerCount( cuLayers.count() );
541
542 switch( aMode )
543 {
545 {
546 enabledLayers |= LSET{ F_Cu, In1_Cu, B_Cu };
547 enabledLayers |= LSET::UserDefinedLayersMask( 4 );
548 board.SetLayerName( In1_Cu, _( "Inner layers" ) );
549 break;
550 }
552 {
553 // Nothing extra to add
554
555 // Clear layer name defaults
556 board.SetLayerName( In1_Cu, wxEmptyString );
557 break;
558 }
559 }
560
561 enabledLayers |= aLayerSet;
562 };
563
564 if( footprint )
565 {
566 configureStackup( footprint->GetStackupMode(), footprint->GetStackupLayers() );
567 }
568 else
569 {
570 // If no footprint is loaded, we assume the default stackup mode
571 configureStackup( FOOTPRINT_STACKUP::EXPAND_INNER_LAYERS, LSET{} );
572 }
573
575 {
576 m_originalFootprintCopy->RunOnChildren(
577 [&]( BOARD_ITEM* child )
578 {
579 LSET childLayers = child->GetLayerSet() & LSET::UserDefinedLayersMask();
580
581 for( PCB_LAYER_ID layer : childLayers )
582 enabledLayers.set( layer );
583 },
585 }
586
587 // Enable any layers that the user has gone to the trouble to name
589 {
590 for( const PCB_LAYER_ID& user : LSET::UserDefinedLayersMask() )
591 {
592 if( cfg->m_DesignSettings.m_UserLayerNames.contains( LSET::Name( user ).ToStdString() ) )
593 enabledLayers.set( user );
594 }
595 }
596
597 board.SetEnabledLayers( enabledLayers );
598
599 // Footprint Editor layer visibility is kept in the view, not the board (because the board
600 // just delegates to the project file, which we don't have).
601 for( const PCB_LAYER_ID& layer : GetBoard()->GetEnabledLayers() )
602 GetCanvas()->GetView()->SetLayerVisible( layer, true );
603}
604
605
607{
609
610 m_originalFootprintCopy.reset( static_cast<FOOTPRINT*>( aFootprint->Clone() ) );
611 m_originalFootprintCopy->SetParent( nullptr );
612
614
616 // Ensure item UUIDs are valid
617 // ("old" footprints can have null uuids that create issues in fp editor)
618 aFootprint->FixUuids();
619
621
622 const wxString libName = aFootprint->GetFPID().GetLibNickname();
623
625 {
626 const wxString msg = wxString::Format( _( "Editing %s from board. Saving will update the board only." ),
627 aFootprint->GetReference() );
628 const wxString openLibLink = wxString::Format( _( "Open in library %s" ),
629 UnescapeString( libName ) );
630
631 const auto openLibraryCopy =
632 [this]( wxHyperlinkEvent& aEvent )
633 {
635 };
636
637 if( WX_INFOBAR* infobar = GetInfoBar() )
638 {
639 wxHyperlinkCtrl* button = new wxHyperlinkCtrl( infobar, wxID_ANY, openLibLink,
640 wxEmptyString );
641 button->Bind( wxEVT_COMMAND_HYPERLINK, openLibraryCopy );
642
643 infobar->RemoveAllButtons();
644 infobar->AddButton( button );
645 infobar->AddCloseButton();
646 infobar->ShowMessage( msg, wxICON_INFORMATION );
647 }
648 }
649 // An empty libname is OK - you get that when creating a new footprint from the main menu
650 // In that case. treat is as editable, and the user will be prompted for save-as when saving.
651 else if( !libName.empty()
652 && !PROJECT_PCB::PcbFootprintLibs( &Prj() )->IsFootprintLibWritable( libName ) )
653 {
654 wxString msg = wxString::Format( _( "Editing footprint from read-only library %s." ),
655 UnescapeString( libName ) );
656
657 if( WX_INFOBAR* infobar = GetInfoBar() )
658 {
659 wxString link = _( "Save as editable copy" );
660
661 const auto saveAsEditableCopy =
662 [this, aFootprint]( wxHyperlinkEvent& aEvent )
663 {
664 SaveFootprintAs( aFootprint );
665 };
666
667 wxHyperlinkCtrl* button = new wxHyperlinkCtrl( infobar, wxID_ANY, link, wxEmptyString );
668 button->Bind( wxEVT_COMMAND_HYPERLINK, saveAsEditableCopy );
669
670 infobar->RemoveAllButtons();
671 infobar->AddButton( button );
672 infobar->AddCloseButton();
673 infobar->ShowMessage( msg, wxICON_INFORMATION );
674 }
675 }
676 else
677 {
678 if( WX_INFOBAR* infobar = GetInfoBar() )
679 infobar->Dismiss();
680 }
681
684}
685
686
688{
689 ReloadFootprint( aFootprint );
690
692 setFPWatcher( nullptr );
693 else
694 setFPWatcher( aFootprint );
695}
696
697
702
703
708
709
711{
712 wxFAIL_MSG( wxT( "Plotting not supported in Footprint Editor" ) );
713
715}
716
717
719{
720 wxFAIL_MSG( wxT( "Plotting not supported in Footprint Editor" ) );
721}
722
723
731
732
740
741
743{
744 // Get our own settings; aCfg will be the PCBNEW_SETTINGS because we're part of the pcbnew
745 // compile unit
747
748 if( cfg )
749 {
751
753
756
758 m_selectionFilterPanel->SetCheckboxesFromFilter( cfg->m_SelectionFilter );
759
761
762 for( auto& [source_name, dest_name] : cfg->m_DesignSettings.m_UserLayerNames )
763 {
764 wxString wx_source_name = source_name;
765 PCB_LAYER_ID layer = static_cast<PCB_LAYER_ID>( LSET::NameToLayer( wx_source_name ) );
766
767 if( IsUserLayer( layer ) )
768 GetBoard()->SetLayerName( layer, dest_name );
769 }
770
771 }
772}
773
774
776{
777 // Load canvas type from the FOOTPRINT_EDITOR_SETTINGS:
779
780 // If we had an OpenGL failure this session, use the fallback GAL but don't update the
781 // user preference silently:
782
785}
786
787
789{
791
792 // Get our own settings; aCfg will be the PCBNEW_SETTINGS because we're part of the pcbnew
793 // compile unit
795
796 if( cfg )
797 {
799
802 cfg->m_LibWidth = m_treePane->GetSize().x;
804
806
808 {
809 cfg->m_AuiPanels.show_properties = m_propertiesPanel->IsShownOnScreen();
811 cfg->m_AuiPanels.properties_splitter = m_propertiesPanel->SplitterProportion();
812 }
813
815
817 {
820 cfg->m_LayerPresets = m_appearancePanel->GetUserLayerPresets();
821 cfg->m_ActiveLayerPreset = m_appearancePanel->GetActiveLayerPreset();
822 }
823 }
824}
825
826
827
829{
830 FOOTPRINT_EDITOR_SETTINGS* cfg = const_cast<FOOTPRINT_EDIT_FRAME*>( this )->GetSettings();
831
832 return cfg ? cfg->m_RotationAngle : ANGLE_90;
833}
834
835
836
838{
840 return ::GetColorSettings( cfg ? cfg->m_ColorTheme : DEFAULT_THEME );
841}
842
843
845{
846 static MAGNETIC_SETTINGS fallback;
847
849 return &cfg->m_MagneticItems;
850
851 return &fallback;
852}
853
854
855const BOX2I FOOTPRINT_EDIT_FRAME::GetDocumentExtents( bool aIncludeAllVisible ) const
856{
857 FOOTPRINT* footprint = GetBoard()->GetFirstFootprint();
858
859 if( footprint )
860 {
861 bool hasGraphicalItem = footprint->Pads().size() || footprint->Zones().size();
862
863 if( !hasGraphicalItem )
864 {
865 for( const BOARD_ITEM* item : footprint->GraphicalItems() )
866 {
867 if( item->Type() == PCB_TEXT_T || item->Type() == PCB_TEXTBOX_T )
868 continue;
869
870 hasGraphicalItem = true;
871 break;
872 }
873 }
874
875 if( hasGraphicalItem )
876 {
877 return footprint->GetBoundingBox( false );
878 }
879 else
880 {
881 BOX2I newFootprintBB( { 0, 0 }, { 0, 0 } );
882 newFootprintBB.Inflate( pcbIUScale.mmToIU( 12 ) );
883 return newFootprintBB;
884 }
885 }
886
887 return GetBoardBoundingBox( false );
888}
889
890
892{
893 if( IsContentModified() )
894 {
895 wxString footprintName = GetBoard()->GetFirstFootprint()->GetReference();
896 wxString msg = _( "Save changes to '%s' before closing?" );
897
898 if( !HandleUnsavedChanges( this, wxString::Format( msg, footprintName ),
899 [&]() -> bool
900 {
901 return SaveFootprint( GetBoard()->GetFirstFootprint() );
902 } ) )
903 {
904 return false;
905 }
906 }
907
908 if( doClose )
909 {
910 GetInfoBar()->ShowMessageFor( wxEmptyString, 1 );
911 Clear_Pcb( false );
912 UpdateTitle();
913 }
914
915 return true;
916}
917
918
919bool FOOTPRINT_EDIT_FRAME::canCloseWindow( wxCloseEvent& aEvent )
920{
921 if( IsContentModified() )
922 {
923 // Shutdown blocks must be determined and vetoed as early as possible
925 aEvent.GetId() == wxEVT_QUERY_END_SESSION )
926 {
927 aEvent.Veto();
928 return false;
929 }
930
931 wxString footprintName = GetBoard()->GetFirstFootprint()->GetFPID().GetLibItemName();
932
934 footprintName = GetBoard()->GetFirstFootprint()->GetReference();
935
936 wxString msg = _( "Save changes to '%s' before closing?" );
937
938 if( !HandleUnsavedChanges( this, wxString::Format( msg, footprintName ),
939 [&]() -> bool
940 {
941 return SaveFootprint( GetBoard()->GetFirstFootprint() );
942 } ) )
943 {
944 aEvent.Veto();
945 return false;
946 }
947 }
948
949 PAD_TOOL* padTool = m_toolManager->GetTool<PAD_TOOL>();
950
951 if( padTool->InPadEditMode() )
952 padTool->ExitPadEditMode();
953
954 // Save footprint tree column widths
955 m_adapter->SaveSettings();
956
958}
959
960
962{
963 // No more vetos
964 GetCanvas()->SetEventDispatcher( nullptr );
966
967 if( GetLibTree() )
969
970 // Do not show the layer manager during closing to avoid flicker
971 // on some platforms (Windows) that generate useless redraw of items in
972 // the Layer Manager
973 m_auimgr.GetPane( wxT( "LayersManager" ) ).Show( false );
974 m_auimgr.GetPane( wxT( "SelectionFilter" ) ).Show( false );
975
976 Clear_Pcb( false );
977
979
980 if( mgr->IsProjectOpen() && wxFileName::IsDirWritable( Prj().GetProjectPath() ) )
981 {
982 GFootprintList.WriteCacheToFile( Prj().GetProjectPath() + wxT( "fp-info-cache" ) );
983 }
984}
985
986
987void FOOTPRINT_EDIT_FRAME::OnExitKiCad( wxCommandEvent& event )
988{
989 Kiway().OnKiCadExit();
990}
991
992
994{
995 Close();
996}
997
998
1000{
1001 // call my base class
1003
1004 // We have 2 panes to update.
1005 // For some obscure reason, the AUI manager hides the first modified pane.
1006 // So force show panes
1007 wxAuiPaneInfo& tree_pane_info = m_auimgr.GetPane( m_treePane );
1008 bool tree_shown = tree_pane_info.IsShown();
1009 tree_pane_info.Caption( _( "Libraries" ) );
1010
1011 wxAuiPaneInfo& lm_pane_info = m_auimgr.GetPane( m_appearancePanel );
1012 bool lm_shown = lm_pane_info.IsShown();
1013 lm_pane_info.Caption( _( "Appearance" ) );
1014 wxAuiPaneInfo& sf_pane_info = m_auimgr.GetPane( m_selectionFilterPanel );
1015 sf_pane_info.Caption( _( "Selection Filter" ) );
1016
1017 // update the layer manager
1019
1020 // Now restore the visibility:
1021 lm_pane_info.Show( lm_shown );
1022 tree_pane_info.Show( tree_shown );
1023 m_auimgr.Update();
1024
1026
1027 UpdateTitle();
1028}
1029
1030
1032{
1034
1035 if( m_isClosing )
1036 return;
1037
1038 Update3DView( true, true );
1040
1041 if( !GetTitle().StartsWith( wxT( "*" ) ) )
1042 UpdateTitle();
1043}
1044
1045
1047{
1048 wxString title;
1049 LIB_ID fpid = GetLoadedFPID();
1050 FOOTPRINT* footprint = GetBoard()->GetFirstFootprint();
1051 bool writable = true;
1052
1053 if( IsCurrentFPFromBoard() )
1054 {
1055 if( IsContentModified() )
1056 title = wxT( "*" );
1057
1058 title += footprint->GetReference();
1059 title += wxS( " " ) + wxString::Format( _( "[from %s]" ), Prj().GetProjectName()
1060 + wxT( "." )
1061 + FILEEXT::PcbFileExtension );
1062 }
1063 else if( fpid.IsValid() )
1064 {
1065 try
1066 {
1068 }
1069 catch( const IO_ERROR& )
1070 {
1071 // best efforts...
1072 }
1073
1074 // Note: don't used GetLoadedFPID(); footprint name may have been edited
1075 if( IsContentModified() )
1076 title = wxT( "*" );
1077
1078 title += From_UTF8( footprint->GetFPID().Format().c_str() );
1079
1080 if( !writable )
1081 title += wxS( " " ) + _( "[Read Only]" );
1082 }
1083 else if( !fpid.GetLibItemName().empty() )
1084 {
1085 // Note: don't used GetLoadedFPID(); footprint name may have been edited
1086 if( IsContentModified() )
1087 title = wxT( "*" );
1088
1089 title += From_UTF8( footprint->GetFPID().GetLibItemName().c_str() );
1090 title += wxS( " " ) + _( "[Unsaved]" );
1091 }
1092 else
1093 {
1094 title = _( "[no footprint loaded]" );
1095 }
1096
1097 title += wxT( " \u2014 " ) + _( "Footprint Editor" );
1098
1099 SetTitle( title );
1100}
1101
1102
1104{
1105 m_appearancePanel->OnBoardChanged();
1106}
1107
1108
1116
1117
1119{
1121
1122 WX_PROGRESS_REPORTER progressReporter( this, _( "Load Footprint Libraries" ), 1, PR_CAN_ABORT );
1123
1124 if( GFootprintList.GetCount() == 0 )
1125 GFootprintList.ReadCacheFromFile( Prj().GetProjectPath() + wxT( "fp-info-cache" ) );
1126
1127 GFootprintList.ReadFootprintFiles( fpTable, nullptr, &progressReporter );
1128 progressReporter.Show( false );
1129
1130 if( GFootprintList.GetErrorCount() )
1131 GFootprintList.DisplayErrors( this );
1132
1134 auto adapter = static_cast<FP_TREE_SYNCHRONIZING_ADAPTER*>( m_adapter.get() );
1135
1136 adapter->AddLibraries( this );
1137}
1138
1139
1141{
1143 auto adapter = static_cast<FP_TREE_SYNCHRONIZING_ADAPTER*>( m_adapter.get() );
1144 LIB_ID target = GetTargetFPID();
1145 bool targetSelected = ( target == GetLibTree()->GetSelectedLibId() );
1146
1147 // Sync FOOTPRINT_INFO list to the libraries on disk
1148 if( aProgress )
1149 {
1150 WX_PROGRESS_REPORTER progressReporter( this, _( "Update Footprint Libraries" ), 1, PR_CAN_ABORT );
1151 GFootprintList.ReadFootprintFiles( fpTable, nullptr, &progressReporter );
1152 progressReporter.Show( false );
1153 }
1154 else
1155 {
1156 GFootprintList.ReadFootprintFiles( fpTable, nullptr, nullptr );
1157 }
1158
1159 // Unselect before syncing to avoid null reference in the adapter
1160 // if a selected item is removed during the sync
1161 GetLibTree()->Unselect();
1162
1163 // Sync the LIB_TREE to the FOOTPRINT_INFO list
1164 adapter->Sync( fpTable );
1165
1166 GetLibTree()->Regenerate( true );
1167
1168 if( target.IsValid() )
1169 {
1170 if( adapter->FindItem( target ) )
1171 {
1172 if( targetSelected )
1173 GetLibTree()->SelectLibId( target );
1174 else
1175 GetLibTree()->CenterLibId( target );
1176 }
1177 else
1178 {
1179 // Try to focus on parent
1180 target.SetLibItemName( wxEmptyString );
1181 GetLibTree()->CenterLibId( target );
1182 }
1183 }
1184}
1185
1186
1191
1192
1194{
1195 GetLibTree()->SelectLibId( aLibID );
1196}
1197
1198
1200{
1201 m_appearancePanel->UpdateDisplayOptions();
1202}
1203
1204
1206{
1207 // Create the manager and dispatcher & route draw panel events to the dispatcher
1209 m_toolManager->SetEnvironment( GetBoard(), GetCanvas()->GetView(),
1210 GetCanvas()->GetViewControls(), config(), this );
1211 m_actions = new PCB_ACTIONS();
1213
1215
1216 m_toolManager->RegisterTool( new COMMON_CONTROL );
1217 m_toolManager->RegisterTool( new COMMON_TOOLS );
1218 m_toolManager->RegisterTool( new PCB_SELECTION_TOOL );
1219 m_toolManager->RegisterTool( new ZOOM_TOOL );
1220 m_toolManager->RegisterTool( new EDIT_TOOL );
1221 m_toolManager->RegisterTool( new PCB_EDIT_TABLE_TOOL );
1222 m_toolManager->RegisterTool( new PAD_TOOL );
1223 m_toolManager->RegisterTool( new DRAWING_TOOL );
1224 m_toolManager->RegisterTool( new PCB_POINT_EDITOR );
1225 m_toolManager->RegisterTool( new PCB_CONTROL ); // copy/paste
1226 m_toolManager->RegisterTool( new LIBRARY_EDITOR_CONTROL );
1227 m_toolManager->RegisterTool( new FOOTPRINT_EDITOR_CONTROL );
1228 m_toolManager->RegisterTool( new ALIGN_DISTRIBUTE_TOOL );
1229 m_toolManager->RegisterTool( new PCB_PICKER_TOOL );
1230 m_toolManager->RegisterTool( new POSITION_RELATIVE_TOOL );
1231 m_toolManager->RegisterTool( new ARRAY_TOOL );
1232 m_toolManager->RegisterTool( new PCB_VIEWER_TOOLS );
1233 m_toolManager->RegisterTool( new PCB_GROUP_TOOL );
1234 m_toolManager->RegisterTool( new CONVERT_TOOL );
1235 m_toolManager->RegisterTool( new SCRIPTING_TOOL );
1236 m_toolManager->RegisterTool( new PROPERTIES_TOOL );
1237 m_toolManager->RegisterTool( new EMBED_TOOL );
1238
1239 for( TOOL_BASE* tool : m_toolManager->Tools() )
1240 {
1241 if( PCB_TOOL_BASE* pcbTool = dynamic_cast<PCB_TOOL_BASE*>( tool ) )
1242 pcbTool->SetIsFootprintEditor( true );
1243 }
1244
1245 m_toolManager->GetTool<PCB_VIEWER_TOOLS>()->SetFootprintFrame( true );
1246 m_toolManager->InitTools();
1247
1248 m_toolManager->InvokeTool( "common.InteractiveSelection" );
1249
1250 // Load or reload wizard plugins in case they changed since the last time the frame opened
1251 // Because the board editor has also a plugin python menu,
1252 // call the PCB_EDIT_FRAME RunAction() if the board editor is running
1253 // Otherwise run the current RunAction().
1254 PCB_EDIT_FRAME* pcbframe = static_cast<PCB_EDIT_FRAME*>( Kiway().Player( FRAME_PCB_EDITOR, false ) );
1255
1256 if( pcbframe )
1258 else
1260}
1261
1262
1264{
1266
1267 ACTION_MANAGER* mgr = m_toolManager->GetActionManager();
1268 PCB_EDITOR_CONDITIONS cond( this );
1269
1270 wxASSERT( mgr );
1271
1272#define ENABLE( x ) ACTION_CONDITIONS().Enable( x )
1273#define CHECK( x ) ACTION_CONDITIONS().Check( x )
1274
1275 auto haveFootprintCond =
1276 [this]( const SELECTION& )
1277 {
1278 return GetBoard() && GetBoard()->GetFirstFootprint() != nullptr;
1279 };
1280
1281 auto footprintTargettedCond =
1282 [this]( const SELECTION& )
1283 {
1284 return !GetTargetFPID().GetLibItemName().empty();
1285 };
1286
1287 const auto footprintFromBoardCond =
1288 [this]( const SELECTION& )
1289 {
1290 return IsCurrentFPFromBoard();
1291 };
1292
1293 auto pcbFrameExistsCond =
1294 [this]( const SELECTION& )
1295 {
1296 PCB_EDIT_FRAME* frame = dynamic_cast<PCB_EDIT_FRAME*>( Kiway().Player( FRAME_PCB_EDITOR, false ) );
1297
1298 return ( frame != nullptr );
1299 };
1300
1301 auto boardFootprintExistsCond =
1302 [this]( const SELECTION& )
1303 {
1304 PCB_EDIT_FRAME* frame = dynamic_cast<PCB_EDIT_FRAME*>( Kiway().Player( FRAME_PCB_EDITOR, false ) );
1305
1306 FOOTPRINT* editorFootprint = GetBoard()->GetFirstFootprint();
1307 bool canInsert = frame && editorFootprint && editorFootprint->GetLink() == niluuid;
1308
1309 // If the source was deleted, the footprint can inserted but not updated in the board.
1310 if( frame && editorFootprint && editorFootprint->GetLink() != niluuid )
1311 {
1312 BOARD* mainpcb = frame->GetBoard();
1313 canInsert = true;
1314
1315 // search if the source footprint was not deleted:
1316 for( FOOTPRINT* candidate : mainpcb->Footprints() )
1317 {
1318 if( editorFootprint->GetLink() == candidate->m_Uuid )
1319 {
1320 canInsert = false;
1321 break;
1322 }
1323 }
1324 }
1325
1326 return canInsert;
1327 };
1328
1329 // clang-format off
1330 mgr->SetConditions( ACTIONS::saveAs, ENABLE( footprintTargettedCond ) );
1333 mgr->SetConditions( PCB_ACTIONS::editLibFpInFpEditor,ENABLE( footprintFromBoardCond ) );
1334
1335 mgr->SetConditions( PCB_ACTIONS::saveFpToBoard, ENABLE( boardFootprintExistsCond ) );
1336 mgr->SetConditions( PCB_ACTIONS::loadFpFromBoard, ENABLE( pcbFrameExistsCond ) );
1337
1340
1349
1350 mgr->SetConditions( ACTIONS::cut, ENABLE( cond.HasItems() ) );
1351 mgr->SetConditions( ACTIONS::copy, ENABLE( cond.HasItems() ) );
1358
1365
1369
1372 // clang-format on
1373
1374 auto constrainedDrawingModeCond =
1375 [this]( const SELECTION& )
1376 {
1378 };
1379
1380 auto highContrastCond =
1381 [this]( const SELECTION& )
1382 {
1384 };
1385
1386 auto boardFlippedCond =
1387 [this]( const SELECTION& )
1388 {
1389 return GetCanvas() && GetCanvas()->GetView()->IsMirroredX();
1390 };
1391
1392 auto libraryTreeCond =
1393 [this](const SELECTION& )
1394 {
1395 return IsLibraryTreeShown();
1396 };
1397
1398 auto layerManagerCond =
1399 [this]( const SELECTION& )
1400 {
1401 return m_auimgr.GetPane( "LayersManager" ).IsShown();
1402 };
1403
1404 auto propertiesCond =
1405 [this] ( const SELECTION& )
1406 {
1407 return m_auimgr.GetPane( PropertiesPaneName() ).IsShown();
1408 };
1409
1410 mgr->SetConditions( PCB_ACTIONS::toggleHV45Mode, CHECK( constrainedDrawingModeCond ) );
1411 mgr->SetConditions( ACTIONS::highContrastMode, CHECK( highContrastCond ) );
1412 mgr->SetConditions( PCB_ACTIONS::flipBoard, CHECK( boardFlippedCond ) );
1414
1415 mgr->SetConditions( ACTIONS::showLibraryTree, CHECK( libraryTreeCond ) );
1416 mgr->SetConditions( PCB_ACTIONS::showLayersManager, CHECK( layerManagerCond ) );
1417 mgr->SetConditions( ACTIONS::showProperties, CHECK( propertiesCond ) );
1418
1419 mgr->SetConditions( ACTIONS::print, ENABLE( haveFootprintCond ) );
1420 mgr->SetConditions( PCB_ACTIONS::exportFootprint, ENABLE( haveFootprintCond ) );
1421 mgr->SetConditions( PCB_ACTIONS::placeImportedGraphics, ENABLE( haveFootprintCond ) );
1422
1423 mgr->SetConditions( PCB_ACTIONS::footprintProperties, ENABLE( haveFootprintCond ) );
1424 mgr->SetConditions( PCB_ACTIONS::padTable, ENABLE( haveFootprintCond ) );
1425 mgr->SetConditions( PCB_ACTIONS::editTextAndGraphics, ENABLE( haveFootprintCond ) );
1426 mgr->SetConditions( PCB_ACTIONS::checkFootprint, ENABLE( haveFootprintCond ) );
1427 mgr->SetConditions( PCB_ACTIONS::repairFootprint, ENABLE( haveFootprintCond ) );
1428 mgr->SetConditions( PCB_ACTIONS::cleanupGraphics, ENABLE( haveFootprintCond ) );
1429 mgr->SetConditions( ACTIONS::showDatasheet, ENABLE( haveFootprintCond ) );
1430
1431 const auto isArcKeepCenterMode =
1432 [this]( const SELECTION& )
1433 {
1435 };
1436
1437 const auto isArcKeepEndpointMode =
1438 [this]( const SELECTION& )
1439 {
1441 };
1442
1443 const auto isArcKeepRadiusMode =
1444 [this]( const SELECTION& )
1445 {
1447 };
1448
1449 // clang-format off
1450 mgr->SetConditions( ACTIONS::pointEditorArcKeepCenter, CHECK( isArcKeepCenterMode ) );
1451 mgr->SetConditions( ACTIONS::pointEditorArcKeepEndpoint, CHECK( isArcKeepEndpointMode ) );
1452 mgr->SetConditions( ACTIONS::pointEditorArcKeepRadius, CHECK( isArcKeepRadiusMode ) );
1453 // clang-format on
1454
1455// Only enable a tool if the part is edtable
1456#define CURRENT_EDIT_TOOL( action ) \
1457 mgr->SetConditions( action, ACTION_CONDITIONS().Enable( haveFootprintCond ) \
1458 .Check( cond.CurrentTool( action ) ) )
1459
1483
1484#undef CURRENT_EDIT_TOOL
1485#undef ENABLE
1486#undef CHECK
1487}
1488
1489
1491{
1493
1494 // Be sure the axis are enabled
1495 GetCanvas()->GetGAL()->SetAxesEnabled( true );
1496
1497 UpdateView();
1498
1499 // Ensure the m_Layers settings are using the canvas type:
1501}
1502
1503
1505{
1507
1509 {
1510 GetGalDisplayOptions().ReadWindowSettings( cfg->m_Window );
1511
1512 GetBoard()->GetDesignSettings() = cfg->m_DesignSettings;
1514 }
1515
1519
1521
1522 if( aFlags & ENVVARS_CHANGED )
1523 SyncLibraryTree( true );
1524
1525 Layout();
1526 SendSizeEvent();
1527}
1528
1529
1530std::unique_ptr<GRID_HELPER> FOOTPRINT_EDIT_FRAME::MakeGridHelper()
1531{
1532 return std::make_unique<PCB_GRID_HELPER>( m_toolManager, GetMagneticItemsSettings() );
1533}
1534
1535
1537{
1538 LIB_ID id = GetLoadedFPID();
1539
1540 if( id.empty() )
1541 {
1542 DisplayErrorMessage( this, _( "No footprint selected." ) );
1543 return;
1544 }
1545
1546 wxFileName fn( id.GetLibItemName() );
1547 fn.SetExt( wxT( "png" ) );
1548
1549 wxString projectPath = wxPathOnly( Prj().GetProjectFullName() );
1550
1551 wxFileDialog dlg( this, _( "Export View as PNG" ), projectPath, fn.GetFullName(),
1552 FILEEXT::PngFileWildcard(), wxFD_SAVE | wxFD_OVERWRITE_PROMPT );
1553
1554 if( dlg.ShowModal() == wxID_CANCEL || dlg.GetPath().IsEmpty() )
1555 return;
1556
1557 // calling wxYield is mandatory under Linux, after closing the file selector dialog
1558 // to refresh the screen before creating the PNG or JPEG image from screen
1559 wxYield();
1560 this->SaveCanvasImageToFile( dlg.GetPath(), BITMAP_TYPE::PNG );
1561}
@ KEEP_ENDPOINTS_OR_START_DIRECTION
Whe editing endpoints, the other end remains in place.
@ KEEP_CENTER_ENDS_ADJUST_ANGLE
When editing endpoints, only the angle is adjusted.
@ KEEP_CENTER_ADJUST_ANGLE_RADIUS
When editing endpoints, the angle and radius are adjusted.
constexpr EDA_IU_SCALE pcbIUScale
Definition base_units.h:112
wxBitmap KiBitmap(BITMAPS aBitmap, int aHeightTag)
Construct a wxBitmap from an image identifier Returns the image from the active theme if the image ha...
Definition bitmap.cpp:104
@ icon_modedit_32
@ icon_modedit_16
@ FPHOLDER
Definition board.h:309
@ NORMAL
Inactive layers are shown normally (no high-contrast mode)
BOX2< VECTOR2I > BOX2I
Definition box2.h:922
static TOOL_ACTION toggleGrid
Definition actions.h:197
static TOOL_ACTION paste
Definition actions.h:80
static TOOL_ACTION millimetersUnits
Definition actions.h:205
static TOOL_ACTION unselectAll
Definition actions.h:83
static TOOL_ACTION revert
Definition actions.h:62
static TOOL_ACTION showLibraryTree
Definition actions.h:163
static TOOL_ACTION cursorSmallCrosshairs
Definition actions.h:151
static TOOL_ACTION saveAs
Definition actions.h:59
static TOOL_ACTION copy
Definition actions.h:78
static TOOL_ACTION pluginsReload
Definition actions.h:295
static TOOL_ACTION group
Definition actions.h:238
static TOOL_ACTION pasteSpecial
Definition actions.h:81
static TOOL_ACTION showDatasheet
Definition actions.h:266
static TOOL_ACTION pointEditorArcKeepCenter
Definition actions.h:274
static TOOL_ACTION milsUnits
Definition actions.h:204
static TOOL_ACTION ungroup
Definition actions.h:239
static TOOL_ACTION toggleBoundingBoxes
Definition actions.h:156
static TOOL_ACTION pointEditorArcKeepRadius
Definition actions.h:276
static TOOL_ACTION undo
Definition actions.h:75
static TOOL_ACTION duplicate
Definition actions.h:84
static TOOL_ACTION inchesUnits
Definition actions.h:203
static TOOL_ACTION highContrastMode
Definition actions.h:154
static TOOL_ACTION embeddedFiles
Definition actions.h:298
static TOOL_ACTION measureTool
Definition actions.h:251
static TOOL_ACTION doDelete
Definition actions.h:85
static TOOL_ACTION selectionTool
Definition actions.h:250
static TOOL_ACTION save
Definition actions.h:58
static TOOL_ACTION zoomFitScreen
Definition actions.h:141
static TOOL_ACTION redo
Definition actions.h:76
static TOOL_ACTION deleteTool
Definition actions.h:86
static TOOL_ACTION zoomTool
Definition actions.h:145
static TOOL_ACTION cursor45Crosshairs
Definition actions.h:153
static TOOL_ACTION print
Definition actions.h:64
static TOOL_ACTION showProperties
Definition actions.h:265
static TOOL_ACTION cut
Definition actions.h:77
static TOOL_ACTION gridSetOrigin
Definition actions.h:194
static TOOL_ACTION ddAddLibrary
Definition actions.h:67
static TOOL_ACTION toggleGridOverrides
Definition actions.h:198
static TOOL_ACTION selectAll
Definition actions.h:82
static TOOL_ACTION pointEditorArcKeepEndpoint
Definition actions.h:275
static TOOL_ACTION cursorFullCrosshairs
Definition actions.h:152
Manage TOOL_ACTION objects.
void SetConditions(const TOOL_ACTION &aAction, const ACTION_CONDITIONS &aConditions)
Set the conditions the UI elements for activating a specific tool action should use for determining t...
APP_SETTINGS_BASE is a settings class that should be derived for each standalone KiCad application.
wxString m_ColorTheme
Active color theme name.
The array tool.
Definition array_tool.h:48
bool IsContentModified() const
Definition base_screen.h:60
void SetContentModified(bool aModified=true)
Definition base_screen.h:59
BASE_SET & set(size_t pos)
Definition base_set.h:116
Container for design settings for a BOARD object.
std::shared_ptr< NET_SETTINGS > m_NetSettings
std::map< std::string, wxString > m_UserLayerNames
Abstract interface for BOARD_ITEMs capable of storing other items inside.
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition board_item.h:79
virtual LSET GetLayerSet() const
Return a std::bitset of all layers on which the item physically resides.
Definition board_item.h:252
Information pertinent to a Pcbnew printed circuit board.
Definition board.h:317
void SetBoardUse(BOARD_USE aUse)
Set what the board is going to be used for.
Definition board.h:329
bool SetLayerName(PCB_LAYER_ID aLayer, const wxString &aLayerName)
Changes the name of the layer given by aLayer.
Definition board.cpp:709
FOOTPRINT * GetFirstFootprint() const
Get the first footprint on the board or nullptr.
Definition board.h:488
void SetVisibleAlls()
Change the bit-mask of visible element categories and layers.
Definition board.cpp:972
const FOOTPRINTS & Footprints() const
Definition board.h:358
void SetCopperLayerCount(int aCount)
Definition board.cpp:881
void DeleteAllFootprints()
Remove all footprints from the deque and free the memory associated with them.
Definition board.cpp:1593
BOARD_DESIGN_SETTINGS & GetDesignSettings() const
Definition board.cpp:1040
void SetEnabledLayers(const LSET &aLayerMask)
A proxy function that calls the correspondent function in m_BoardSettings.
Definition board.cpp:943
Color settings are a bit different than most of the settings objects in that there can be more than o...
Handle actions that are shared between different applications.
Handles action that are shared between different applications.
Tool responsible for drawing graphical elements like lines, arcs, circles, etc.
void CommonSettingsChanged(int aFlags) override
Notification event that some of the common (suite-wide) settings have changed.
void ShowChangedLanguage() override
Redraw the menus and what not in current language.
virtual void setupUIConditions()
Setup the UI conditions for the various actions and their controls in this frame.
virtual void UpdateToolbarControlSizes()
Update the sizes of any controls in the toolbars of the frame.
ACTION_TOOLBAR * m_tbRight
TOOLBAR_SETTINGS * m_toolbarSettings
wxAuiManager m_auimgr
virtual void RecreateToolbars()
ACTION_TOOLBAR * m_tbLeft
virtual void OnSize(wxSizeEvent &aEvent)
virtual bool canCloseWindow(wxCloseEvent &aCloseEvent)
virtual void OnDropFiles(wxDropFilesEvent &aEvent)
Handle event fired when a file is dropped to the window.
std::map< const wxString, TOOL_ACTION * > m_acceptedExts
Associate file extensions with action to execute.
ACTION_TOOLBAR * m_tbTopMain
wxString m_aboutTitle
bool m_isClosing
Set by the close window event handler after frames are asked if they can close.
void ReCreateMenuBar()
Recreate the menu bar.
WX_INFOBAR * GetInfoBar()
EDA_DRAW_PANEL_GAL::GAL_TYPE m_canvasType
The current canvas type.
void OnSelectGrid(wxCommandEvent &event)
Command event handler for selecting grid sizes.
void setupUnits(APP_SETTINGS_BASE *aCfg)
void SetMsgPanel(const std::vector< MSG_PANEL_ITEM > &aList)
Clear the message panel and populates it with the contents of aList.
bool SaveCanvasImageToFile(const wxString &aFileName, BITMAP_TYPE aBitmapType)
Save the current view as an image file.
virtual void SwitchCanvas(EDA_DRAW_PANEL_GAL::GAL_TYPE aCanvasType)
Change the current rendering backend.
virtual void OnSelectZoom(wxCommandEvent &event)
Set the zoom factor when selected by the zoom list box in the main tool bar.
GAL_DISPLAY_OPTIONS_IMPL & GetGalDisplayOptions()
Return a reference to the gal rendering options used by GAL for rendering.
static bool m_openGLFailureOccured
Has any failure occurred when switching to OpenGL in any EDA_DRAW_FRAME?
static const wxString PropertiesPaneName()
EDA_MSG_PANEL * m_messagePanel
void SetCanvas(EDA_DRAW_PANEL_GAL *aPanel)
virtual void SetScreen(BASE_SCREEN *aScreen)
virtual void UpdateMsgPanel()
Redraw the message panel.
EDA_DRAW_PANEL_GAL::GAL_TYPE loadCanvasTypeSetting()
Return the canvas type stored in the application settings.
PROPERTIES_PANEL * m_propertiesPanel
bool m_showBorderAndTitleBlock
static constexpr GAL_TYPE GAL_FALLBACK
void StopDrawing()
Prevent the GAL canvas from further drawing until it is recreated or StartDrawing() is called.
void ForceRefresh()
Force a redraw.
@ GAL_TYPE_OPENGL
OpenGL implementation.
KIGFX::GAL * GetGAL() const
Return a pointer to the GAL instance used in the panel.
void SetEventDispatcher(TOOL_DISPATCHER *aEventDispatcher)
Set a dispatcher that processes events and forwards them to tools.
Specialization of the wxAuiPaneInfo class for KiCad panels.
SELECTION_CONDITION NoActiveTool()
Create a functor testing if there are no tools active in the frame.
SELECTION_CONDITION BoundingBoxes()
SELECTION_CONDITION RedoAvailable()
Create a functor that tests if there are any items in the redo queue.
SELECTION_CONDITION CurrentTool(const TOOL_ACTION &aTool)
Create a functor testing if the specified tool is the current active tool in the frame.
virtual SELECTION_CONDITION UndoAvailable()
Create a functor that tests if there are any items in the undo queue.
SELECTION_CONDITION Units(EDA_UNITS aUnit)
Create a functor that tests if the frame has the specified units.
SELECTION_CONDITION CursorSmallCrosshairs()
Create a functor testing if the cursor is full screen in a frame.
SELECTION_CONDITION GridVisible()
Create a functor testing if the grid is visible in a frame.
SELECTION_CONDITION ContentModified()
Create a functor that tests if the content of the frame is modified.
SELECTION_CONDITION GridOverrides()
Create a functor testing if the grid overrides wires is enabled in a frame.
SELECTION_CONDITION Cursor45Crosshairs()
SELECTION_CONDITION CursorFullCrosshairs()
Module editor specific tools.
BOARD_DESIGN_SETTINGS m_DesignSettings
Only some of these settings are actually used for footprint editing.
std::vector< LAYER_PRESET > m_LayerPresets
PCB_SELECTION_FILTER_OPTIONS m_SelectionFilter
void CloseFootprintEditor(wxCommandEvent &Event)
BOARD_DESIGN_SETTINGS & GetDesignSettings() const override
Return the BOARD_DESIGN_SETTINGS for the open project.
void setupUIConditions() override
Setup the UI conditions for the various actions and their controls in this frame.
void ActivateGalCanvas() override
Use to start up the GAL drawing canvas.
void HardRedraw() override
Refresh the library tree and redraw the window.
static const wxChar * GetFootprintEditorFrameName()
void SyncLibraryTree(bool aProgress)
Synchronize the footprint library tree to the current state of the footprint library table.
void OnSaveFootprintAsPng(wxCommandEvent &event)
bool SaveFootprintAs(FOOTPRINT *aFootprint)
void FocusLibraryTreeInput() override
BOARD_ITEM_CONTAINER * GetModel() const override
void ReCreateLayerBox(bool aForceResizeToolbar=true)
Re create the layer Box by clearing the old list, and building a new one from the new layers names an...
LIB_TREE * GetLibTree() const override
bool canCloseWindow(wxCloseEvent &Event) override
void UpdateMsgPanel() override
Redraw the message panel.
LIB_ID GetTargetFPID() const
Return the LIB_ID of the part selected in the footprint tree, or the loaded part if there is no selec...
LIB_ID GetLoadedFPID() const
Return the LIB_ID of the part being edited.
APP_SETTINGS_BASE * config() const override
Return the settings object used in SaveSettings(), and is overloaded in KICAD_MANAGER_FRAME.
void SetPlotSettings(const PCB_PLOT_PARAMS &aSettings) override
bool SaveFootprint(FOOTPRINT *aFootprint)
Save in an existing library a given footprint.
void initLibraryTree()
Make sure the footprint info list is loaded (with a progress dialog) and then initialize the footprin...
void LoadSettings(APP_SETTINGS_BASE *aCfg) override
Load common frame parameters from a configuration file.
void ShowChangedLanguage() override
Update visible items after a language change.
void resolveCanvasType() override
Determines the Canvas type to load (with prompt if required) and initializes m_canvasType.
void CommonSettingsChanged(int aFlags) override
Called after the preferences dialog is run.
bool IsContentModified() const override
Get if any footprints or libraries have been modified but not saved.
void UpdateUserInterface()
Update the layer manager and other widgets from the board setup (layer and items visibility,...
wxObjectDataPtr< LIB_TREE_MODEL_ADAPTER > m_adapter
bool IsLibraryTreeShown() const override
FOOTPRINT_EDITOR_SETTINGS * m_editorSettings
const BOX2I GetDocumentExtents(bool aIncludeAllVisible=true) const override
Return bounding box of document with option to not include some items.
bool Clear_Pcb(bool doAskAboutUnsavedChanges)
Delete all and reinitialize the current board.
Definition initpcb.cpp:108
FOOTPRINT_EDIT_FRAME(KIWAY *aKiway, wxWindow *aParent)
protected so only friend PCB::IFACE::CreateWindow() can act as sole factory.
SELECTION & GetCurrentSelection() override
Get the current selection from the canvas area.
bool CanCloseFPFromBoard(bool doClose)
void SetActiveLayer(PCB_LAYER_ID aLayer) override
void AddFootprintToBoard(FOOTPRINT *aFootprint) override
Override from PCB_BASE_EDIT_FRAME which adds a footprint to the editor's dummy board,...
void OnModify() override
Must be called after a footprint change in order to set the "modify" flag of the current screen and p...
FOOTPRINT_TREE_PANE * m_treePane
std::unique_ptr< GRID_HELPER > MakeGridHelper() override
void OnDisplayOptionsChanged() override
void FocusOnLibID(const LIB_ID &aLibID)
const PCB_PLOT_PARAMS & GetPlotSettings() const override
Return the PCB_PLOT_PARAMS for the BOARD owned by this frame.
std::unique_ptr< FOOTPRINT > m_originalFootprintCopy
void ReloadFootprint(FOOTPRINT *aFootprint) override
Override from PCB_BASE_FRAME which reloads the footprint from the library without setting the footpri...
EDA_ANGLE GetRotationAngle() const override
Return the angle used for rotate operations.
void RefreshLibraryTree()
Redisplay the library tree.
void OnExitKiCad(wxCommandEvent &aEvent)
void SaveSettings(APP_SETTINGS_BASE *aCfg) override
Save common frame parameters to a configuration data file.
MAGNETIC_SETTINGS * GetMagneticItemsSettings() override
FOOTPRINT_EDITOR_SETTINGS * GetSettings()
void SwitchCanvas(EDA_DRAW_PANEL_GAL::GAL_TYPE aCanvasType) override
Switch the currently used canvas (Cairo / OpenGL).
COLOR_SETTINGS * GetColorSettings(bool aForceRefresh=false) const override
Helper to retrieve the current color settings.
Footprint Editor pane with footprint library tree.
bool FixUuids()
Old footprints do not always have a valid UUID (some can be set to null uuid) However null UUIDs,...
ZONES & Zones()
Definition footprint.h:230
EDA_ITEM * Clone() const override
Invoke a function on all children.
std::deque< PAD * > & Pads()
Definition footprint.h:224
const LIB_ID & GetFPID() const
Definition footprint.h:269
const LSET & GetStackupLayers() const
Definition footprint.h:325
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.
KIID GetLink() const
Definition footprint.h:877
const wxString & GetReference() const
Definition footprint.h:661
FOOTPRINT_STACKUP GetStackupMode() const
Definition footprint.h:318
DRAWINGS & GraphicalItems()
Definition footprint.h:227
const BOX2I GetBoundingBox() const override
Return the orthogonal bounding box of this object for display purposes.
bool IsFootprintLibWritable(const wxString &aNickname)
Return true if the library given by aNickname is writable.
void AddLibraries(EDA_BASE_FRAME *aParent)
static wxObjectDataPtr< LIB_TREE_MODEL_ADAPTER > Create(FOOTPRINT_EDIT_FRAME *aFrame, FP_LIB_TABLE *aLibs)
void ReadWindowSettings(WINDOW_SETTINGS &aCfg)
Read GAL config options from application-level config.
Hold an error message and may be used when throwing exceptions containing meaningful error messages.
bool m_axesEnabled
Crosshair drawing mode.
void SetAxesEnabled(bool aAxesEnabled)
Enable drawing the axes.
void UpdateAllLayersColor()
Apply the new coloring scheme to all layers.
Definition view.cpp:775
void SetLayerVisible(int aLayer, bool aVisible=true)
Control the visibility of a particular layer.
Definition view.h:400
bool IsMirroredX() const
Return true if view is flipped across the X axis.
Definition view.h:250
void MarkTargetDirty(int aTarget)
Set or clear target 'dirty' flag.
Definition view.h:639
A minimalistic software bus for communications between various DLLs/DSOs (DSOs) within the same KiCad...
Definition kiway.h:286
void OnKiCadExit()
Definition kiway.cpp:717
virtual KIWAY_PLAYER * Player(FRAME_T aFrameType, bool doCreate=true, wxTopLevelWindow *aParent=nullptr)
Return the KIWAY_PLAYER* given a FRAME_T.
Definition kiway.cpp:395
Module editor specific tools.
A logical library item identifier and consists of various portions much like a URI.
Definition lib_id.h:49
int SetLibItemName(const UTF8 &aLibItemName)
Override the library item name portion of the LIB_ID to aLibItemName.
Definition lib_id.cpp:111
bool IsValid() const
Check if this LID_ID is valid.
Definition lib_id.h:172
int SetLibNickname(const UTF8 &aLibNickname)
Override the logical library name portion of the LIB_ID to aLibNickname.
Definition lib_id.cpp:100
UTF8 Format() const
Definition lib_id.cpp:119
const wxString GetUniStringLibItemName() const
Get strings for display messages in dialogs.
Definition lib_id.h:112
const UTF8 & GetLibItemName() const
Definition lib_id.h:102
const UTF8 & GetLibNickname() const
Return the logical library name portion of a LIB_ID.
Definition lib_id.h:87
void RefreshLibTree()
Refresh the tree (mainly to update highlighting and asterisking)
Definition lib_tree.cpp:472
void CenterLibId(const LIB_ID &aLibId)
Ensure that an item is visible (preferably centered).
Definition lib_tree.cpp:381
void ShutdownPreviews()
Definition lib_tree.cpp:287
void ShowChangedLanguage()
Definition lib_tree.cpp:304
void SelectLibId(const LIB_ID &aLibId)
Select an item in the tree widget.
Definition lib_tree.cpp:375
LIB_TREE_MODEL_ADAPTER::SORT_MODE GetSortMode() const
Definition lib_tree.h:155
void Unselect()
Unselect currently selected item in wxDataViewCtrl.
Definition lib_tree.cpp:387
LIB_ID GetSelectedLibId(int *aUnit=nullptr) const
For multi-unit symbols, if the user selects the symbol itself rather than picking an individual unit,...
Definition lib_tree.cpp:314
void Regenerate(bool aKeepState)
Regenerate the tree.
Definition lib_tree.cpp:454
void SetSortMode(LIB_TREE_MODEL_ADAPTER::SORT_MODE aMode)
Save/restore the sorting mode.
Definition lib_tree.h:154
LSET is a set of PCB_LAYER_IDs.
Definition lset.h:37
static const LSET & UserMask()
Definition lset.cpp:673
static int NameToLayer(wxString &aName)
Return the layer number from a layer name.
Definition lset.cpp:117
static const LSET & AllTechMask()
Return a mask holding all technical layers (no CU layer) on both side.
Definition lset.cpp:659
static LSET UserDefinedLayersMask(int aUserDefinedLayerCount=MAX_USER_DEFINED_LAYERS)
Return a mask with the requested number of user defined layers.
Definition lset.cpp:687
static LSET AllCuMask()
return AllCuMask( MAX_CU_LAYERS );
Definition lset.cpp:591
static wxString Name(PCB_LAYER_ID aLayerId)
Return the fixed name association with aLayerId.
Definition lset.cpp:188
void SetClearance(int aClearance)
Definition netclass.h:119
std::shared_ptr< NETCLASS > GetDefaultNetclass()
Gets the default netclass for the project.
void ExitPadEditMode()
Definition pad_tool.cpp:834
bool InPadEditMode()
Definition pad_tool.h:63
Describe the page size and margins of a paper page on which to eventually print or plot.
Definition page_info.h:79
Gather all the actions that are shared by tools.
Definition pcb_actions.h:51
static TOOL_ACTION toggleHV45Mode
static TOOL_ACTION drawRuleArea
static TOOL_ACTION drawBezier
static TOOL_ACTION placeText
static TOOL_ACTION drawOrthogonalDimension
static TOOL_ACTION drawRectangle
static TOOL_ACTION setAnchor
static TOOL_ACTION padDisplayMode
static TOOL_ACTION placeReferenceImage
static TOOL_ACTION showLayersManager
static TOOL_ACTION drawCircle
static TOOL_ACTION mirrorH
Mirroring of selected items.
static TOOL_ACTION exportFootprint
static TOOL_ACTION drawTable
static TOOL_ACTION drawTextBox
static TOOL_ACTION drawPolygon
static TOOL_ACTION placePad
Activation of the drawing tool (placing a PAD)
static TOOL_ACTION drawRadialDimension
static TOOL_ACTION padTable
static TOOL_ACTION editTextAndGraphics
static TOOL_ACTION drawLeader
static TOOL_ACTION ddImportFootprint
static TOOL_ACTION placeImportedGraphics
static TOOL_ACTION drawArc
static TOOL_ACTION graphicsOutlines
Display footprint graphics as outlines.
static TOOL_ACTION loadFpFromBoard
static TOOL_ACTION drawCenterDimension
static TOOL_ACTION footprintProperties
static TOOL_ACTION flipBoard
static TOOL_ACTION textOutlines
Display texts as lines.
static TOOL_ACTION checkFootprint
static TOOL_ACTION placePoint
static TOOL_ACTION editLibFpInFpEditor
static TOOL_ACTION mirrorV
static TOOL_ACTION repairFootprint
static TOOL_ACTION saveFpToBoard
static TOOL_ACTION drawLine
static TOOL_ACTION cleanupGraphics
static TOOL_ACTION rotateCw
Rotation of selected objects.
static TOOL_ACTION rotateCcw
static TOOL_ACTION drawAlignedDimension
virtual void SetBoard(BOARD *aBoard, PROGRESS_REPORTER *aReporter=nullptr) override
Set the #m_Pcb member in such as way as to ensure deleting any previous BOARD.
void configureToolbars() override
PCB_BASE_EDIT_FRAME(KIWAY *aKiway, wxWindow *aParent, FRAME_T aFrameType, const wxString &aTitle, const wxPoint &aPos, const wxSize &aSize, long aStyle, const wxString &aFrameName)
APPEARANCE_CONTROLS * m_appearancePanel
PANEL_SELECTION_FILTER * m_selectionFilterPanel
void ActivateGalCanvas() override
Set the #m_Pcb member in such as way as to ensure deleting any previous BOARD.
Base PCB main window class for Pcbnew, Gerbview, and CvPcb footprint viewer.
virtual const PCB_PLOT_PARAMS & GetPlotSettings() const
Return the PCB_PLOT_PARAMS for the BOARD owned by this frame.
const PCB_DISPLAY_OPTIONS & GetDisplayOptions() const
Display options control the way tracks, vias, outlines and other things are shown (for instance solid...
void LoadSettings(APP_SETTINGS_BASE *aCfg) override
Load common frame parameters from a configuration file.
void setFPWatcher(FOOTPRINT *aFootprint)
Create or removes a watcher on the specified footprint.
void OnModify() override
Must be called after a change in order to set the "modify" flag and update other data structures and ...
FOOTPRINT * loadFootprint(const LIB_ID &aFootprintId)
Attempt to load aFootprintId from the footprint library table.
const PAGE_INFO & GetPageSettings() const override
BOX2I GetBoardBoundingBox(bool aBoardEdgesOnly=false) const
Calculate the bounding box containing all board items (or board edge segments).
PCB_DRAW_PANEL_GAL * GetCanvas() const override
Return a pointer to GAL-based canvas of given EDA draw frame.
virtual void SetPageSettings(const PAGE_INFO &aPageSettings) override
void SaveSettings(APP_SETTINGS_BASE *aCfg) override
Save common frame parameters to a configuration data file.
PCB_SCREEN * GetScreen() const override
Return a pointer to a BASE_SCREEN or one of its derivatives.
BOARD * GetBoard() const
virtual void AddFootprintToBoard(FOOTPRINT *aFootprint)
Add the given footprint to the board.
PCB_DISPLAY_OPTIONS m_displayOptions
FOOTPRINT_EDITOR_SETTINGS * GetFootprintEditorSettings() const
virtual void Update3DView(bool aMarkDirty, bool aRefresh, const wxString *aTitle=nullptr)
Update the 3D view, if the viewer is opened by this frame.
Handle actions that are shared between different frames in PcbNew.
Definition pcb_control.h:47
HIGH_CONTRAST_MODE m_ContrastModeDisplay
How inactive layers are displayed.
void UpdateColors()
Update the color settings in the painter and GAL.
virtual KIGFX::PCB_VIEW * GetView() const override
Return a pointer to the #VIEW instance used in the panel.
void DisplayBoard(BOARD *aBoard, PROGRESS_REPORTER *aReporter=nullptr)
Add all items from the current board to the VIEW, so they can be displayed by GAL.
Group generic conditions for PCB editor states.
SELECTION_CONDITION PadFillDisplay()
Create a functor that tests if the frame fills the pads.
SELECTION_CONDITION HasItems()
Create a functor that tests if there are items in the board.
SELECTION_CONDITION GraphicsFillDisplay()
Create a functor that tests if the frame fills graphics items.
SELECTION_CONDITION TextFillDisplay()
Create a functor that tests if the frame fills text items.
The main frame for Pcbnew.
Generic tool for picking an item.
Parameters and options when plotting/printing a board.
Tool that displays edit points allowing to modify items by dragging the points.
The selection tool: currently supports:
Tool useful for viewing footprints.
virtual SETTINGS_MANAGER & GetSettingsManager() const
Definition pgm_base.h:125
The interactive edit tool.
static FP_LIB_TABLE * PcbFootprintLibs(PROJECT *aProject)
Return the table of footprint libraries without Kiway.
@ PCB_FOOTPRINT_EDITOR_FP_NAME
Definition project.h:231
@ PCB_FOOTPRINT_EDITOR_LIB_NICKNAME
Definition project.h:232
virtual void SetRString(RSTRING_T aStringId, const wxString &aString)
Store a "retained string", which is any session and project specific string identified in enum RSTRIN...
Definition project.cpp:334
virtual const wxString & GetRString(RSTRING_T aStringId)
Return a "retained string", which is any session and project specific string identified in enum RSTRI...
Definition project.cpp:345
Action handler for the Properties panel.
Tool relating to pads and pad settings.
static SELECTION_CONDITION HasType(KICAD_T aType)
Create a functor that tests if among the selected items there is at least one of a given type.
static bool NotEmpty(const SELECTION &aSelection)
Test if there are any items selected.
static bool Idle(const SELECTION &aSelection)
Test if there no items selected or being edited.
static bool ShowAlways(const SELECTION &aSelection)
The default condition function (always returns true).
T * GetAppSettings(const char *aFilename)
Return a handle to the a given settings by type.
bool IsProjectOpen() const
Helper for checking if we have a project open.
TOOL_MANAGER * m_toolManager
TOOL_DISPATCHER * m_toolDispatcher
TOOL_MANAGER * GetToolManager() const
Return the MVC controller.
ACTIONS * m_actions
Base abstract interface for all kinds of tools.
Definition tool_base.h:66
@ MODEL_RELOAD
Model changes (the sheet for a schematic)
Definition tool_base.h:80
virtual void DispatchWxEvent(wxEvent &aEvent)
Process wxEvents (mostly UI events), translate them to TOOL_EVENTs, and make tools handle those.
Master controller class:
bool RunAction(const std::string &aActionName, T aParam)
Run the specified action immediately, pausing the current action to run the new one.
bool empty() const
Definition utf8.h:110
const char * c_str() const
Definition utf8.h:109
A modified version of the wxInfoBar class that allows us to:
Definition wx_infobar.h:76
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.
Multi-thread safe progress reporter dialog, intended for use of tasks that parallel reporting back of...
bool HandleUnsavedChanges(wxWindow *aParent, const wxString &aMessage, const std::function< bool()> &aSaveFunction)
Display a dialog with Save, Cancel and Discard Changes buttons.
Definition confirm.cpp:129
void DisplayErrorMessage(wxWindow *aParent, const wxString &aText, const wxString &aExtraInfo)
Display an error message with aMessage.
Definition confirm.cpp:194
This file is part of the common library.
#define CHECK(x)
#define ENABLE(x)
static bool empty(const wxTextEntryBase *aCtrl)
#define _(s)
Declaration of the eda_3d_viewer class.
static constexpr EDA_ANGLE ANGLE_90
Definition eda_angle.h:413
#define KICAD_DEFAULT_DRAWFRAME_STYLE
#define FOOTPRINT_EDIT_FRAME_NAME
@ RECURSE
Definition eda_item.h:51
FOOTPRINT_STACKUP
Definition footprint.h:91
@ EXPAND_INNER_LAYERS
The 'normal' stackup handling, where there is a single inner layer (In1) and rule areas using it expa...
Definition footprint.h:96
@ CUSTOM_LAYERS
Stackup handling where the footprint can have any number of copper layers, and objects on those layer...
Definition footprint.h:101
#define CURRENT_EDIT_TOOL(action)
FOOTPRINT_LIST_IMPL GFootprintList
The global footprint info table.
Definition cvpcb.cpp:156
@ FRAME_PCB_EDITOR
Definition frame_type.h:42
@ FRAME_FOOTPRINT_EDITOR
Definition frame_type.h:43
a few functions useful in geometry calculations.
@ DIRECT
Unconstrained point-to-point.
static const std::string KiCadFootprintLibPathExtension
static const std::string KiCadFootprintFileExtension
static wxString PngFileWildcard()
@ ID_ON_GRID_SELECT
Definition id.h:114
@ ID_ON_ZOOM_SELECT
Definition id.h:112
PROJECT & Prj()
Definition kicad.cpp:612
KIID niluuid(0)
bool IsUserLayer(PCB_LAYER_ID aLayerId)
Test whether a layer is a non copper and a non tech layer.
Definition layer_ids.h:755
PCB_LAYER_ID
A quick note on layer IDs:
Definition layer_ids.h:60
@ B_Cu
Definition layer_ids.h:65
@ F_SilkS
Definition layer_ids.h:100
@ In1_Cu
Definition layer_ids.h:66
@ F_Cu
Definition layer_ids.h:64
This file contains miscellaneous commonly used macros and functions.
@ TARGET_NONCACHED
Auxiliary rendering target (noncached)
Definition definitions.h:38
void SetShutdownBlockReason(wxWindow *aWindow, const wxString &aReason)
Sets the block reason why the window/application is preventing OS shutdown.
Definition unix/app.cpp:90
bool SupportsShutdownBlockReason()
Whether or not the window supports setting a shutdown block reason.
Definition unix/app.cpp:79
#define _HKI(x)
Definition page_info.cpp:44
@ ID_FPEDIT_SAVE_PNG
Definition pcbnew_id.h:77
SETTINGS_MANAGER * GetSettingsManager()
BOARD * GetBoard()
PGM_BASE & Pgm()
The global program "get" accessor.
Definition pgm_base.cpp:913
see class PGM_BASE
#define DEFAULT_THEME
T * GetToolbarSettings(const wxString &aFilename)
T * GetAppSettings(const char *aFilename)
KIWAY Kiway(KFCTL_STANDALONE)
wxString UnescapeString(const wxString &aSource)
wxString From_UTF8(const char *cstring)
#define EDIT_TOOL(tool)
#define ENVVARS_CHANGED
@ 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
Definition of file extensions used in Kicad.
void SetAuiPaneSize(wxAuiManager &aManager, wxAuiPaneInfo &aPane, int aWidth, int aHeight)
Sets the size of an AUI pane, working around http://trac.wxwidgets.org/ticket/13180.
#define PR_CAN_ABORT