KiCad PCB EDA Suite
Loading...
Searching...
No Matches
pcb_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) 2018 Jean-Pierre Charras, jp.charras at wanadoo.fr
5 * Copyright (C) 2013 SoftPLC Corporation, Dick Hollenbeck <[email protected]>
6 * Copyright (C) 2013 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
20 * along with this program. If not, see <https://www.gnu.org/licenses/>.
21 */
22
23#include <algorithm>
24#include <type_traits>
25#include <unordered_map>
26#include <unordered_set>
27#include <vector>
28
29#include <wx/log.h>
30#include <wx/filename.h>
31#include <wx/filedlg.h>
32#include <wx/hyperlink.h>
33#include <wx/socket.h>
34#include <wx/wupdlock.h>
35
36#include <advanced_config.h>
38#include <kiface_base.h>
39#include <kiway.h>
42#include <pgm_base.h>
43#include <pcb_edit_frame.h>
47#include <api/api_handler_pcb.h>
49#include <api/api_server.h>
50#include <api/api_utils.h>
52#include <bitmaps.h>
53#include <confirm.h>
54#include <footprint.h>
55#include <footprint_utils.h>
57#include <project_pcb.h>
58#include <lset.h>
59#include <trace_helpers.h>
60#include <pcbnew_id.h>
61#include <pcbnew_settings.h>
64#include <dialog_find.h>
70#include <dialog_board_setup.h>
73#include <pcb_drill_chart.h>
74#include <pcb_drill_map.h>
79#include <pad.h>
80#include <pcb_target.h>
81#include <pcb_point.h>
82#include <pcb_track.h>
83#include <layer_pairs.h>
86#include <text_var_dependency.h>
87#include <view/view.h>
89#include <functional>
90#include <pcb_barcode.h>
91#include <pcb_grid_item.h>
92#include <pcb_painter.h>
97#include <local_history.h>
98#include <tool/tool_manager.h>
100#include <tool/action_toolbar.h>
101#include <tool/common_control.h>
102#include <tool/common_tools.h>
103#include <tool/embed_tool.h>
104#include <tool/properties_tool.h>
105#include <tool/selection.h>
106#include <tool/zoom_tool.h>
107#include <tools/array_tool.h>
112#include <tools/edit_tool.h>
114#include <tools/pcb_group_tool.h>
115#include <tools/generator_tool.h>
118#include <tools/drc_tool.h>
121#include <tools/convert_tool.h>
123#include <tools/drawing_tool.h>
124#include <tools/pcb_control.h>
132#include <tools/pad_tool.h>
134#include <properties/property.h>
141#include <router/router_tool.h>
144#include <dialog_drc.h> // for DIALOG_DRC_WINDOW_NAME definition
150#include <widgets/wx_infobar.h>
155#include <widgets/wx_aui_utils.h>
156#include <kiplatform/app.h>
157#include <kiplatform/ui.h>
158#include <core/profile.h>
159#include <math/box2_minmax.h>
163#include <toolbars_pcb_editor.h>
165
166#include <richio.h>
167
168using namespace std::placeholders;
169
170wxDEFINE_EVENT( EDA_EVT_PCB_LAST_SCH_SHEET_CHANGED, wxCommandEvent );
171
172
173#define INSPECT_DRC_ERROR_DIALOG_NAME wxT( "InspectDrcErrorDialog" )
174#define INSPECT_CLEARANCE_DIALOG_NAME wxT( "InspectClearanceDialog" )
175#define INSPECT_CONSTRAINTS_DIALOG_NAME wxT( "InspectConstraintsDialog" )
176#define FOOTPRINT_DIFF_DIALOG_NAME wxT( "FootprintDiffDialog" )
177
178
179BEGIN_EVENT_TABLE( PCB_EDIT_FRAME, PCB_BASE_FRAME )
182
185
186 EVT_SIZE( PCB_EDIT_FRAME::OnSize )
187
188 // Menu Files:
191
192 EVT_MENU( wxID_EXIT, PCB_EDIT_FRAME::OnQuit )
193 EVT_MENU( wxID_CLOSE, PCB_EDIT_FRAME::OnQuit )
194
195 // Horizontal toolbar
200
201 // Tracks and vias sizes general options
203 PCB_EDIT_FRAME::Tracks_and_Vias_Size_Event )
204
205 // User interface update event handlers.
206 EVT_UPDATE_UI( ID_AUX_TOOLBAR_PCB_TRACK_WIDTH, PCB_EDIT_FRAME::OnUpdateSelectTrackWidth )
207 EVT_UPDATE_UI( ID_AUX_TOOLBAR_PCB_VIA_SIZE, PCB_EDIT_FRAME::OnUpdateSelectViaSize )
209 PCB_EDIT_FRAME::OnUpdateSelectTrackWidth )
211 PCB_EDIT_FRAME::OnUpdateSelectViaSize )
212 // Drop files event
213 EVT_DROP_FILES( PCB_EDIT_FRAME::OnDropFiles )
214END_EVENT_TABLE()
215
216
217PCB_EDIT_FRAME::PCB_EDIT_FRAME( KIWAY* aKiway, wxWindow* aParent ) :
218 PCB_BASE_EDIT_FRAME( aKiway, aParent, FRAME_PCB_EDITOR, _( "PCB Editor" ), wxDefaultPosition, wxDefaultSize,
220 m_exportNetlistAction( nullptr ),
221 m_findDialog( nullptr ),
222 m_findByPropertiesDialog( nullptr ),
223 m_inspectDrcErrorDlg( nullptr ),
224 m_inspectClearanceDlg( nullptr ),
225 m_inspectConstraintsDlg( nullptr ),
226 m_footprintDiffDlg( nullptr ),
227 m_boardSetupDlg( nullptr ),
228 m_footprintFieldsTableDialog( nullptr ),
229 m_designBlocksPane( nullptr ),
230 m_importProperties( nullptr ),
231 m_eventCounterTimer( nullptr )
232{
233 m_maximizeByDefault = true;
234 m_showBorderAndTitleBlock = true; // true to display sheet references
235 m_SelTrackWidthBox = nullptr;
236 m_SelViaSizeBox = nullptr;
237 m_SelViaStackBox = nullptr;
238 m_CurrentVariantCtrl = nullptr;
239 m_ShowLayerManagerTools = true;
240 m_supportsAutoSave = true;
241 m_ProbingSchToPcb = false;
242 m_ShowSearch = false;
243 m_ShowNetInspector = false;
244 // Ensure timer has an owner before binding so it generates events.
245 m_crossProbeFlashTimer.SetOwner( this );
246 Bind( wxEVT_TIMER, &PCB_EDIT_FRAME::OnCrossProbeFlashTimer, this, m_crossProbeFlashTimer.GetId() );
247
248 // We don't know what state board was in when it was last saved, so we have to
249 // assume dirty
250 m_ZoneFillsDirty = true;
251
252 m_aboutTitle = _HKI( "KiCad PCB Editor" );
253
254 // Must be created before the menus are created.
255 if( ADVANCED_CFG::GetCfg().m_ShowPcbnewExportNetlist )
256 {
257 m_exportNetlistAction = new TOOL_ACTION( "pcbnew.EditorControl.exportNetlist",
258 AS_GLOBAL, 0, "", _( "Netlist..." ),
259 _( "Export netlist used to update schematics" ) );
260 }
261
262 // Create GAL canvas
263 PCB_DRAW_PANEL_GAL* canvas = new PCB_DRAW_PANEL_GAL( this, -1, wxPoint( 0, 0 ), m_frameSize,
264 GetGalDisplayOptions(),
266
267 SetCanvas( canvas );
268 SetBoard( new BOARD() );
269
270 wxIcon icon;
271 wxIconBundle icon_bundle;
272
273 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_pcbnew, 48 ) );
274 icon_bundle.AddIcon( icon );
275 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_pcbnew, 128 ) );
276 icon_bundle.AddIcon( icon );
277 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_pcbnew, 256 ) );
278 icon_bundle.AddIcon( icon );
279 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_pcbnew_32 ) );
280 icon_bundle.AddIcon( icon );
281 icon.CopyFromBitmap( KiBitmap( BITMAPS::icon_pcbnew_16 ) );
282 icon_bundle.AddIcon( icon );
283
284 SetIcons( icon_bundle );
285
286 // LoadSettings() *after* creating m_LayersManager, because LoadSettings()
287 // initialize parameters in m_LayersManager
288 LoadSettings( config() );
289
290 SetScreen( new PCB_SCREEN( GetPageSettings().GetSizeIU( pcbIUScale.IU_PER_MILS ) ) );
291
292 // PCB drawings start in the upper left corner.
293 GetScreen()->m_Center = false;
294
295 setupTools();
296 setupUIConditions();
297
298 m_toolbarSettings = GetToolbarSettings<PCB_EDIT_TOOLBAR_SETTINGS>( "pcbnew-toolbars" );
299 configureToolbars();
300 RecreateToolbars();
301 PrepareLayerIndicator( true );
302
303 ReCreateMenuBar();
304
307
308 // Fetch a COPY of the config as a lot of these initializations are going to overwrite our
309 // data.
310 PCBNEW_SETTINGS::AUI_PANELS aui_cfg = GetPcbNewSettings()->m_AuiPanels;
311
312 m_propertiesPanel = new PCB_PROPERTIES_PANEL( this, this );
313 m_propertiesPanel->SetSplitterProportion( aui_cfg.properties_splitter );
314
315 m_selectionFilterPanel = new PANEL_SELECTION_FILTER( this );
316
317 m_appearancePanel = new APPEARANCE_CONTROLS( this, GetCanvas() );
318 m_searchPane = new PCB_SEARCH_PANE( this );
319 m_netInspectorPanel = new PCB_NET_INSPECTOR_PANEL( this, this );
320 m_designBlocksPane = new PCB_DESIGN_BLOCK_PANE( this, nullptr, m_designBlockHistoryList );
321 m_constraintsPanel = new PANEL_CONSTRAINTS( this );
322 m_gitCommitPane = new GIT_COMMIT_PANE( this );
323
324 m_auimgr.SetManagedWindow( this );
325
326 CreateInfoBar();
327
328 // Secondary infobar stacked above the main one. Load-time notices (such as
329 // the WRL -> STEP migration prompt) belong here so they aren't clobbered by
330 // the main infobar's read-only warnings, DRC rule errors, etc.
331 m_loadNoticeInfoBar = new WX_INFOBAR( GetToolCanvas(), wxID_ANY, true );
332
333 unsigned int auiFlags = wxAUI_MGR_DEFAULT;
334#if !defined( _WIN32 )
335 // Windows cannot redraw the UI fast enough during a live resize and may lead to all kinds
336 // of graphical glitches.
337 auiFlags |= wxAUI_MGR_LIVE_RESIZE;
338#endif
339 m_auimgr.SetFlags( auiFlags );
340
341 // Rows; layers 4 - 6
342 m_auimgr.AddPane( m_tbTopMain, EDA_PANE().HToolbar().Name( wxS( "TopMainToolbar" ) )
343 .Top().Layer( 6 ) );
344 m_auimgr.AddPane( m_tbTopAux, EDA_PANE().HToolbar().Name( wxS( "TopAuxToolbar" ) )
345 .Top().Layer( 5 ) );
346 m_auimgr.AddPane( m_messagePanel, EDA_PANE().Messages().Name( wxS( "MsgPanel" ) )
347 .Bottom().Layer( 6 ) );
348
349 // Columns; layers 1 - 3
350 m_auimgr.AddPane( m_tbLeft, EDA_PANE().VToolbar().Name( wxS( "LeftToolbar" ) )
351 .Left().Layer( 3 ) );
352
353 m_auimgr.AddPane( m_tbRight, EDA_PANE().VToolbar().Name( wxS( "RightToolbar" ) )
354 .Right().Layer( 3 ) );
355
356 m_auimgr.AddPane( m_appearancePanel, EDA_PANE().Name( wxS( "LayersManager" ) )
357 .Right().Layer( 4 )
358 .Caption( _( "Appearance" ) ).PaneBorder( false )
359 // Don't use -1 for don't-change-height on a growable panel; it has side-effects.
360 .MinSize( m_appearancePanel->GetMinSize().x, FromDIP( 60 ) )
361#ifdef __WXMAC__
362 // Best size for this pane is calculated larger than necessary on wxMac
363 .BestSize( m_appearancePanel->GetMinSize().x, -1 )
364#else
365 .BestSize( m_appearancePanel->GetBestSize().x, -1 )
366#endif
367 .FloatingSize( m_appearancePanel->GetBestSize() )
368 .CloseButton( false ) );
369
370 m_auimgr.AddPane( m_selectionFilterPanel, EDA_PANE().Name( wxS( "SelectionFilter" ) )
371 .Right().Layer( 4 ).Position( 2 )
372 .Caption( _( "Selection Filter" ) ).PaneBorder( false )
373 // Fixed-size pane; -1 for MinSize height is required
374 .MinSize( m_selectionFilterPanel->GetMinSize().x, -1 )
375 .BestSize( m_selectionFilterPanel->GetBestSize().x, -1 )
376 .FloatingSize( m_selectionFilterPanel->GetBestSize() )
377 .CloseButton( false ) );
378
379 m_auimgr.AddPane( m_designBlocksPane, EDA_PANE().Name( DesignBlocksPaneName() )
380 .Right().Layer( 5 )
381 .Caption( _( "Design Blocks" ) )
382 .CaptionVisible( true )
383 .PaneBorder( true )
384 .TopDockable( false )
385 .BottomDockable( false )
386 .CloseButton( true )
387 .MinSize( FromDIP( wxSize( 240, 60 ) ) )
388 .BestSize( FromDIP( wxSize( 300, 200 ) ) )
389 .FloatingSize( FromDIP( wxSize( 800, 600 ) ) )
390 .FloatingPosition( FromDIP( wxPoint( 50, 200 ) ) )
391 .Show( true ) );
392
393 m_auimgr.AddPane( m_propertiesPanel, EDA_PANE().Name( PropertiesPaneName() )
394 .Left().Layer( 5 )
395 .Caption( _( "Properties" ) ).PaneBorder( false )
396 .MinSize( FromDIP( wxSize( 240, 60 ) ) )
397 .BestSize( FromDIP( wxSize( 300, 200 ) ) )
398 .FloatingSize( wxSize( 300, 200 ) )
399 .CloseButton( true ) );
400
401 // Center
402 m_auimgr.AddPane( GetCanvas(), EDA_PANE().Canvas().Name( wxS( "DrawFrame" ) )
403 .Center() );
404
405 m_auimgr.AddPane( m_netInspectorPanel, EDA_PANE().Name( NetInspectorPanelName() )
406 .Bottom()
407 .Caption( _( "Net Inspector" ) )
408 .PaneBorder( false )
409 .MinSize( FromDIP( wxSize( 240, 60 ) ) )
410 .BestSize( FromDIP( wxSize( 300, 200 ) ) )
411 .FloatingSize( wxSize( 300, 200 ) )
412 .CloseButton( true ) );
413
414 m_auimgr.AddPane( m_searchPane, EDA_PANE().Name( SearchPaneName() )
415 .Bottom()
416 .Caption( _( "Search" ) ).PaneBorder( false )
417 .MinSize( FromDIP( wxSize ( 180, 60 ) ) )
418 .BestSize( FromDIP( wxSize ( 180, 100 ) ) )
419 .FloatingSize( FromDIP( wxSize( 480, 200 ) ) )
420 .DestroyOnClose( false )
421 .CloseButton( true ) );
422
423 m_auimgr.AddPane( m_constraintsPanel, EDA_PANE().Name( ConstraintsPaneName() )
424 .Bottom().Layer( 1 )
425 .Caption( _( "Geometric Constraints" ) ).PaneBorder( false )
426 .MinSize( FromDIP( wxSize( 360, 120 ) ) )
427 .BestSize( FromDIP( wxSize( 600, 200 ) ) )
428 .FloatingSize( FromDIP( wxSize( 600, 240 ) ) )
429 .DestroyOnClose( false )
430 .CloseButton( true )
431 .Hide() );
432
433 m_auimgr.AddPane( m_gitCommitPane,
434 EDA_PANE()
435 .Name( GitCommitPaneName() )
436 .Right()
437 .Layer( 5 )
438 .Caption( _( "Version Control" ) )
439 .PaneBorder( false )
440 .MinSize( wxSize( m_gitCommitPane->GetMinDockWidth(), FromDIP( 120 ) ) )
441 .BestSize( wxSize( std::max( m_gitCommitPane->GetMinDockWidth(), FromDIP( 300 ) ),
442 FromDIP( 300 ) ) )
443 .FloatingSize( FromDIP( wxSize( 300, 400 ) ) )
444 .DestroyOnClose( false )
445 .CloseButton( true )
446 .Hide() );
447
448 RestoreAuiLayout();
449
450 // A saved layout brings its own minimum, so the one the panel needs is set again.
451 m_auimgr.GetPane( GitCommitPaneName() ).min_size.x = m_gitCommitPane->GetMinDockWidth();
452
453 m_auimgr.GetPane( "LayersManager" ).Show( m_ShowLayerManagerTools );
454 m_auimgr.GetPane( "SelectionFilter" ).Show( m_ShowLayerManagerTools );
455 m_auimgr.GetPane( PropertiesPaneName() ).Show( GetPcbNewSettings()->m_AuiPanels.show_properties );
456 m_auimgr.GetPane( NetInspectorPanelName() ).Show( m_ShowNetInspector );
457 m_auimgr.GetPane( SearchPaneName() ).Show( m_ShowSearch );
458 m_auimgr.GetPane( DesignBlocksPaneName() ).Show( GetPcbNewSettings()->m_AuiPanels.design_blocks_show );
459 m_auimgr.GetPane( GitCommitPaneName() ).Show( GetPcbNewSettings()->m_AuiPanels.show_git_commit_pane );
460
461 wxAuiPaneInfo& selectionFilterPane = m_auimgr.GetPane( wxS( "SelectionFilter" ) );
462
463 // The selection filter doesn't need to grow in the vertical direction when docked
464 selectionFilterPane.dock_proportion = 0;
465
466 // wx 3.3.3 turns a -1 min height into 1, and a legacy perspective restores one
467 selectionFilterPane.min_size.y = m_selectionFilterPanel->GetBestSize().y;
468 FinishAUIInitialization();
469
470 if( aui_cfg.right_panel_width > 0 )
471 {
472 wxAuiPaneInfo& layersManager = m_auimgr.GetPane( wxS( "LayersManager" ) );
473 SetAuiPaneSize( m_auimgr, layersManager, aui_cfg.right_panel_width, -1 );
474
475 wxAuiPaneInfo& designBlocksPane = m_auimgr.GetPane( DesignBlocksPaneName() );
476 SetAuiPaneSize( m_auimgr, designBlocksPane, aui_cfg.design_blocks_panel_docked_width, -1 );
477 }
478
479 if( aui_cfg.properties_panel_width > 0 && m_propertiesPanel )
480 {
481 wxAuiPaneInfo& propertiesPanel = m_auimgr.GetPane( PropertiesPaneName() );
482 SetAuiPaneSize( m_auimgr, propertiesPanel, aui_cfg.properties_panel_width, -1 );
483 }
484
485 if( aui_cfg.search_panel_height > 0
486 && ( aui_cfg.search_panel_dock_direction == wxAUI_DOCK_TOP
487 || aui_cfg.search_panel_dock_direction == wxAUI_DOCK_BOTTOM ) )
488 {
489 wxAuiPaneInfo& searchPane = m_auimgr.GetPane( SearchPaneName() );
490 searchPane.Direction( aui_cfg.search_panel_dock_direction );
491 SetAuiPaneSize( m_auimgr, searchPane, -1, aui_cfg.search_panel_height );
492 }
493 else if( aui_cfg.search_panel_width > 0
494 && ( aui_cfg.search_panel_dock_direction == wxAUI_DOCK_LEFT
495 || aui_cfg.search_panel_dock_direction == wxAUI_DOCK_RIGHT ) )
496 {
497 wxAuiPaneInfo& searchPane = m_auimgr.GetPane( SearchPaneName() );
498 searchPane.Direction( aui_cfg.search_panel_dock_direction );
499 SetAuiPaneSize( m_auimgr, searchPane, aui_cfg.search_panel_width, -1 );
500 }
501
502 m_appearancePanel->SetTabIndex( aui_cfg.appearance_panel_tab );
503
504 m_layerPairSettings = std::make_unique<LAYER_PAIR_SETTINGS>();
505
506 m_layerPairSettings->Bind( PCB_LAYER_PAIR_PRESETS_CHANGED,
507 [&]( wxCommandEvent& aEvt )
508 {
509 // Update the project file list
510 std::span<const LAYER_PAIR_INFO> newPairInfos = m_layerPairSettings->GetLayerPairs();
511 Prj().GetProjectFile().m_LayerPairInfos = std::vector<LAYER_PAIR_INFO>{ newPairInfos.begin(),
512 newPairInfos.end() };
513 } );
514
515 m_layerPairSettings->Bind( PCB_CURRENT_LAYER_PAIR_CHANGED,
516 [&]( wxCommandEvent& aEvt )
517 {
518 const LAYER_PAIR& layerPair = m_layerPairSettings->GetCurrentLayerPair();
519 PCB_SCREEN& screen = *GetScreen();
520
521 screen.m_Route_Layer_TOP = layerPair.GetLayerA();
522 screen.m_Route_Layer_BOTTOM = layerPair.GetLayerB();
523
524 // Update the toolbar icon
525 PrepareLayerIndicator();
526 } );
527
528 GetToolManager()->PostAction( ACTIONS::zoomFitScreen );
529
530 Bind( wxEVT_IDLE,
531 [this]( wxIdleEvent& aEvent )
532 {
533 BOX2D viewport = GetCanvas()->GetView()->GetViewport();
534
535 if( viewport != m_lastNetnamesViewport )
536 {
537 redrawNetnames();
538 m_lastNetnamesViewport = viewport;
539 m_lastNetnamesScale = GetCanvas()->GetView()->GetScale();
540 }
541
542 // Do not forget to pass the Idle event to other clients:
543 aEvent.Skip();
544 } );
545
546 setupUnits( config() );
547
548 // Ensure the DRC engine is initialized so that constraints can be resolved even before a
549 // board is loaded or saved
550 try
551 {
552 m_toolManager->GetTool<DRC_TOOL>()->GetDRCEngine()->InitEngine( wxFileName() );
553 }
554 catch( PARSE_ERROR& )
555 {
556 }
557
558 // Sync action plugins in case they changed since the last time the frame opened
559 GetToolManager()->RunAction( ACTIONS::pluginsReload );
560
561 m_apiHandler = std::make_unique<API_HANDLER_PCB>( this );
562 Pgm().GetApiServer().RegisterHandler( m_apiHandler.get() );
563
564 if( Kiface().IsSingle() )
565 {
566 m_apiHandlerCommon = std::make_unique<API_HANDLER_COMMON>();
567 Pgm().GetApiServer().RegisterHandler( m_apiHandlerCommon.get() );
568 m_apiLibrariesHandler = std::make_unique<API_HANDLER_LIBRARIES>( LIBRARY_TABLE_TYPE::DESIGN_BLOCK );
569 Pgm().GetApiServer().RegisterHandler( m_apiLibrariesHandler.get() );
570 }
571
572 resolveCanvasType();
573 ActivateGalCanvas();
574
575 // Default shutdown reason until a file is loaded
576 KIPLATFORM::APP::SetShutdownBlockReason( this, _( "New PCB file is unsaved" ) );
577
578 // disable Export STEP item if kicad2step does not exist
579 wxString strK2S = Pgm().GetExecutablePath();
580
581#ifdef __WXMAC__
582 if( strK2S.Find( wxT( "pcbnew.app" ) ) != wxNOT_FOUND )
583 {
584 // On macOS, we have standalone applications inside the main bundle, so we handle that here:
585 strK2S += wxT( "../../" );
586 }
587
588 strK2S += wxT( "Contents/MacOS/" );
589#endif
590
591 wxFileName appK2S( strK2S, wxT( "kicad2step" ) );
592
593#ifdef _WIN32
594 appK2S.SetExt( wxT( "exe" ) );
595#endif
596
597 // Ensure the window is on top
598 Raise();
599
600// if( !appK2S.FileExists() )
601 // GetMenuBar()->FindItem( ID_GEN_EXPORT_FILE_STEP )->Enable( false );
602
603 // AUI doesn't refresh properly on wxMac after changes in eb7dc6dd, so force it to
604#ifdef __WXMAC__
605 if( Kiface().IsSingle() )
606 {
607 CallAfter( [this]()
608 {
609 m_appearancePanel->OnBoardChanged();
610 } );
611 }
612#endif
613
614 // Register a call to update the toolbar sizes. It can't be done immediately because
615 // it seems to require some sizes calculated that aren't yet (at least on GTK).
616 CallAfter( [this]()
617 {
618 // Ensure the controls on the toolbars all are correctly sized
619 UpdateToolbarControlSizes();
620
621 // Update the angle snap mode toolbar button to reflect the current preference
622 GetToolManager()->RunAction( PCB_ACTIONS::angleSnapModeChanged );
623 } );
624
625 if( ADVANCED_CFG::GetCfg().m_ShowEventCounters )
626 {
627 m_eventCounterTimer = new wxTimer( this );
628
629 Bind( wxEVT_TIMER,
630 [&]( wxTimerEvent& aEvent )
631 {
632 GetCanvas()->m_PaintEventCounter->Show();
633 GetCanvas()->m_PaintEventCounter->Reset();
634
636 static_cast<KIGFX::WX_VIEW_CONTROLS*>( GetCanvas()->GetViewControls() );
639
640 },
641 m_eventCounterTimer->GetId() );
642
643 m_eventCounterTimer->Start( 1000 );
644 }
645
648 m_acceptedExts.emplace( wxS( "dxf" ), &PCB_ACTIONS::ddImportGraphics );
652 m_acceptedExts.emplace( wxS( "jpeg" ), &PCB_ACTIONS::ddPlaceReferenceImage );
653 DragAcceptFiles( true );
654
655 Bind( EDA_EVT_CLOSE_DIALOG_BOOK_REPORTER, &PCB_EDIT_FRAME::onCloseModelessBookReporterDialogs, this );
656 Bind( EDA_EVT_CLOSE_DIALOG_FOOTPRINT_FIELDS_TABLE, &PCB_EDIT_FRAME::onCloseFootprintFieldsTableDialog, this );
657}
658
659
660void PCB_EDIT_FRAME::StartCrossProbeFlash( const std::vector<BOARD_ITEM*>& aItems )
661{
662 if( !GetPcbNewSettings()->m_CrossProbing.flash_selection )
663 {
664 wxLogTrace( traceCrossProbeFlash, "StartCrossProbeFlash(PCB): aborted (setting disabled) items=%zu",
665 aItems.size() );
666 return;
667 }
668
669 if( aItems.empty() )
670 {
671 wxLogTrace( traceCrossProbeFlash, "StartCrossProbeFlash(PCB): aborted (no items)" );
672 return;
673 }
674
675 // Don't start flashing if any of the items are being moved. The flash timer toggles
676 // selection hide/show which corrupts the VIEW overlay state during an active move.
677 for( const BOARD_ITEM* item : aItems )
678 {
679 if( item->IsMoving() )
680 {
681 wxLogTrace( traceCrossProbeFlash,
682 "StartCrossProbeFlash(PCB): aborted (items are moving)" );
683 return;
684 }
685 }
686
688 {
689 wxLogTrace( traceCrossProbeFlash, "StartCrossProbeFlash(PCB): restarting existing flash (phase=%d)",
692 }
693
694 wxLogTrace( traceCrossProbeFlash, "StartCrossProbeFlash(PCB): starting with %zu items", aItems.size() );
695
696 // Store uuids
698 for( BOARD_ITEM* it : aItems )
699 m_crossProbeFlashItems.push_back( it->m_Uuid );
700
703
704 if( !m_crossProbeFlashTimer.GetOwner() )
705 m_crossProbeFlashTimer.SetOwner( this );
706
707 // 0.5s intervals -> 3s total for 6 phases
708 [[maybe_unused]] bool started = m_crossProbeFlashTimer.Start( 500, wxTIMER_CONTINUOUS );
709 wxLogTrace( traceCrossProbeFlash, "StartCrossProbeFlash(PCB): timer start=%d id=%d",
710 (int) started, m_crossProbeFlashTimer.GetId() );
711}
712
713
714void PCB_EDIT_FRAME::OnCrossProbeFlashTimer( wxTimerEvent& aEvent )
715{
716 wxLogTrace( traceCrossProbeFlash, "Timer(PCB) fired: phase=%d running=%d items=%zu",
718
720 {
721 wxLogTrace( traceCrossProbeFlash, "Timer(PCB) fired but not flashing (ignored)" );
722 return;
723 }
724
726
727 if( !selTool )
728 return;
729
730 // Don't manipulate the selection while items are being moved. The move tool holds a
731 // live reference to the selection and toggling hide/show on selected items corrupts
732 // the VIEW overlay state, causing crashes.
733 for( const KIID& id : m_crossProbeFlashItems )
734 {
735 if( EDA_ITEM* item = GetBoard()->ResolveItem( id, true ) )
736 {
737 if( item->IsMoving() )
738 {
739 wxLogTrace( traceCrossProbeFlash, "Timer(PCB) phase=%d: items are moving, stopping flash",
741 m_crossProbeFlashing = false;
743 return;
744 }
745 }
746 }
747
748 // Prevent recursion / IPC during flashing
749 bool prevGuard = m_ProbingSchToPcb;
750 m_ProbingSchToPcb = true;
751
752 if( m_crossProbeFlashPhase % 2 == 0 )
753 {
754 // Hide selection
755 selTool->ClearSelection( true );
756 wxLogTrace( traceCrossProbeFlash, "Phase %d (PCB): cleared selection", m_crossProbeFlashPhase );
757 }
758 else
759 {
760 // Restore selection
761 for( const KIID& id : m_crossProbeFlashItems )
762 {
763 if( EDA_ITEM* item = GetBoard()->ResolveItem( id, true ) )
764 selTool->AddItemToSel( item, true );
765 }
766
767 wxLogTrace( traceCrossProbeFlash, "Phase %d (PCB): restored %zu items",
769 }
770
771 // Force a redraw even if the canvas / frame does not currently have focus (mouse elsewhere)
772 if( GetCanvas() )
773 {
775 wxLogTrace( traceCrossProbeFlash, "Phase %d (PCB): forced canvas refresh", m_crossProbeFlashPhase );
776 }
777
778 m_ProbingSchToPcb = prevGuard;
779
781
782 if( m_crossProbeFlashPhase > 6 )
783 {
784 // Ensure final state (selected)
785 for( const KIID& id : m_crossProbeFlashItems )
786 {
787 if( EDA_ITEM* item = GetBoard()->ResolveItem( id, true ) )
788 selTool->AddItemToSel( item, true );
789 }
790
791 m_crossProbeFlashing = false;
793
794 wxLogTrace( traceCrossProbeFlash, "Flashing complete (PCB). Final selection size=%zu",
795 m_crossProbeFlashItems.size() );
796 }
797}
798
799
801{
802 // Always ensure that we are unregistered even in a close without graceful doCloseWindow()
803 if( GetBoard() )
805
806 // PCB_BASE_FRAME's dtor deletes m_pcb; canvas children outlive it. Drop
807 // every cached TEXT_VAR_TRACKER* before the tracker is freed.
809
810 if( Kiface().IsSingle() )
811 {
814 }
815
816 if( ADVANCED_CFG::GetCfg().m_ShowEventCounters )
817 {
818 // Stop the timer during destruction early to avoid potential event race conditions (that
819 // do happen on windows)
820 m_eventCounterTimer->Stop();
821 delete m_eventCounterTimer;
822 }
823
824 // Close modeless dialogs
825 wxWindow* drcDlg = wxWindow::FindWindowByName( DIALOG_DRC_WINDOW_NAME );
826
827 if( drcDlg )
828 drcDlg->Close( true );
829
830 wxWindow* ruleEditorDlg = wxWindow::FindWindowByName( DIALOG_DRC_RULE_EDITOR_WINDOW_NAME );
831
832 if( ruleEditorDlg )
833 ruleEditorDlg->Close( true );
834
835 // Shutdown all running tools
836 if( m_toolManager )
837 m_toolManager->ShutdownAllTools();
838
839 if( GetBoard() )
841
842 // We passed ownership of these to wxAuiManager.
843 // delete m_selectionFilterPanel;
844 // delete m_appearancePanel;
845 // delete m_propertiesPanel;
846 // delete m_netInspectorPanel;
847
849}
850
851
853{
854 wxAuiPaneInfo& pane = m_auimgr.GetPane( ConstraintsPaneName() );
855
856 if( !pane.IsOk() )
857 return;
858
859 bool show = !pane.IsShown();
860 pane.Show( show );
861
862 if( show && m_constraintsPanel )
863 m_constraintsPanel->RefreshList();
864
865 m_auimgr.Update();
866}
867
868
870{
871 if( GetCanvas() )
872 {
873 if( DS_PROXY_VIEW_ITEM* sheet = GetCanvas()->GetDrawingSheet() )
874 sheet->AttachToTracker( nullptr );
875 }
876
878 {
879 m_textVarListenerTracker->RemoveInvalidateListener( m_textVarListenerHandle );
881 m_textVarListenerTracker = nullptr;
882 }
883}
884
885
886void PCB_EDIT_FRAME::SetBoard( BOARD* aBoard, bool aBuildConnectivity, PROGRESS_REPORTER* aReporter )
887{
888 // PCB_BASE_FRAME::SetBoard() deletes m_pcb; detach tracker consumers first.
889 if( m_pcb )
890 {
892 m_pcb->ClearProject();
894 }
895
896 PCB_BASE_EDIT_FRAME::SetBoard( aBoard, aReporter );
897
898 aBoard->AddListener( this );
899 aBoard->SetProject( &Prj() );
900
901 if( aBuildConnectivity )
902 aBoard->BuildConnectivity();
903
904 // reload the drawing-sheet
905 SetPageSettings( aBoard->GetPageSettings() );
906
908}
909
910
915
916
917std::unique_ptr<GRID_HELPER> PCB_EDIT_FRAME::MakeGridHelper()
918{
919 return std::make_unique<PCB_GRID_HELPER>( m_toolManager, GetMagneticItemsSettings() );
920}
921
922
924{
925 /*
926 * While new items being scrolled into the view will get painted, they will only get
927 * annotated with netname instances currently within the view. Subsequent panning will not
928 * draw newly-visible netname instances because the item has already been drawn.
929 *
930 * This routine, fired on idle if the viewport has changed, looks for visible items that
931 * might have multiple netname instances and redraws them. (It does not need to handle pads
932 * and vias because they only ever have a single netname instance drawn on them.)
933 */
934 PCBNEW_SETTINGS* cfg = dynamic_cast<PCBNEW_SETTINGS*>( Kiface().KifaceSettings() );
935
936 if( !cfg || cfg->m_Display.m_NetNames < 2 )
937 return;
938
939 KIGFX::VIEW* view = GetCanvas()->GetView();
940 BOX2D viewport = view->GetViewport();
941
942 view->SyncLayerVisibilityCache(); // Required for ViewGetLOD() calls.
943
944 if( view->GetGAL()->HasRetainedScene() )
945 {
946 // Labels sit on the visible part of their track. A track wholly inside both the old and new
947 // view keeps its label, so only the others are repainted, and only on net name layers.
948 const BOX2I before = BOX2ISafe( m_lastNetnamesViewport );
949 const BOX2I now = BOX2ISafe( viewport );
950 BOX2D reach = viewport;
951
952 view->RepaintLayers(
953 BOX2ISafe( reach.Inflate( pcbIUScale.mmToIU( 2.0 ) ) ),
954 []( int aLayer )
955 {
956 return IsNetnameLayer( aLayer );
957 },
958 [&]( KIGFX::VIEW_ITEM* aItem, int aLayer )
959 {
960 PCB_TRACK* track = dynamic_cast<PCB_TRACK*>( aItem );
961
962 if( !track || track->Type() == PCB_VIA_T )
963 return false;
964
965 const double lod = track->ViewGetLOD( aLayer, view );
966
967 const BOX2I bbox = track->GetBoundingBox();
968
969 if( lod < m_lastNetnamesScale && before.Contains( bbox ) && now.Contains( bbox ) )
970 return false;
971
972 return lod < view->GetScale();
973 } );
974
975 // Labels are laid out on idle after a zoom's last paint and would otherwise wait for
976 // whatever paints next
977 GetCanvas()->Refresh();
978 return;
979 }
980
981 // Inflate to catch most of the track width
982 BOX2I_MINMAX clipbox( BOX2ISafe( viewport.Inflate( pcbIUScale.mmToIU( 2.0 ) ) ) );
983
984 for( PCB_TRACK* track : GetBoard()->Tracks() )
985 {
986 // Don't need to update vias
987 if( track->Type() == PCB_VIA_T )
988 continue;
989
990 // Don't update invisible tracks
991 if( !clipbox.Intersects( BOX2I_MINMAX( track->GetStart(), track->GetEnd() ) ) )
992 continue;
993
994 if( track->ViewGetLOD( GetNetnameLayer( track->GetLayer() ), view ) < view->GetScale() )
995 view->Update( track, KIGFX::REPAINT );
996 }
997}
998
999
1000void PCB_EDIT_FRAME::SetPageSettings( const PAGE_INFO& aPageSettings )
1001{
1002 PCB_BASE_FRAME::SetPageSettings( aPageSettings );
1003
1004 // Prepare drawing-sheet template
1006 &m_pcb->GetPageSettings(),
1007 m_pcb->GetProject(),
1008 &m_pcb->GetTitleBlock(),
1009 &m_pcb->GetProperties() );
1010
1011 drawingSheet->SetSheetName( std::string( GetScreenDesc().mb_str() ) );
1012 drawingSheet->SetSheetPath( std::string( GetFullScreenDesc().mb_str() ) );
1013
1014 // A board is not like a schematic having a main page and sub sheets.
1015 // So for the drawing sheet, use only the first page option to display items
1016 drawingSheet->SetIsFirstPage( true );
1017
1018 BASE_SCREEN* screen = GetScreen();
1019
1020 if( screen != nullptr )
1021 {
1022 drawingSheet->SetPageNumber(TO_UTF8( screen->GetPageNumber() ) );
1023 drawingSheet->SetSheetCount( screen->GetPageCount() );
1024 }
1025
1026 if( BOARD* board = GetBoard() )
1027 {
1028 drawingSheet->SetFileName( TO_UTF8( board->GetFileName() ) );
1029 wxString currentVariant = board->GetCurrentVariant();
1030 wxString variantDesc = board->GetVariantDescription( currentVariant );
1031 drawingSheet->SetVariantName( TO_UTF8( currentVariant ) );
1032 drawingSheet->SetVariantDesc( TO_UTF8( variantDesc ) );
1033 }
1034
1035 // PCB_DRAW_PANEL_GAL takes ownership of the drawing-sheet
1036 GetCanvas()->SetDrawingSheet( drawingSheet );
1037
1038 // Reactive title-block repaint: register the proxy with the BOARD's
1039 // text-var tracker so source changes fan out to a repaint. The one-time
1040 // listener installation is idempotent; calling AddInvalidateListener
1041 // here each time would accumulate stale listeners across SetPageSettings
1042 // calls, which is why the listener check below is guarded.
1043 if( BOARD* board = GetBoard() )
1044 {
1045 if( BOARD_TEXT_VAR_ADAPTER* adapter = board->GetTextVarAdapter() )
1046 {
1047 TEXT_VAR_TRACKER* tracker = &adapter->Tracker();
1048
1049 drawingSheet->AttachToTracker( tracker );
1050
1051 // Project reload / board swap can point GetBoard() at a new
1052 // tracker; detach from the previous one first so we don't leak
1053 // a stale lambda that still captures `this`.
1054 if( m_textVarListenerTracker != tracker
1056 {
1057 m_textVarListenerTracker->RemoveInvalidateListener( m_textVarListenerHandle );
1059 m_textVarListenerTracker = nullptr;
1060 }
1061
1063 {
1064 KIGFX::VIEW* view = GetCanvas()->GetView();
1065 m_textVarListenerTracker = tracker;
1067 [this, view]( EDA_ITEM* aDep, const TEXT_VAR_REF_KEY& )
1068 {
1069 if( !aDep )
1070 return;
1071
1073
1074 if( aDep == current )
1075 {
1076 view->Update( current, KIGFX::REPAINT );
1077 return;
1078 }
1079
1080 if( aDep->IsBOARD_ITEM() )
1081 {
1082 if( PCB_TEXT* text = dynamic_cast<PCB_TEXT*>( aDep ) )
1083 {
1084 text->ClearRenderCache();
1085 text->ClearBoundingBoxCache();
1086 }
1087
1088 view->Update( aDep, KIGFX::GEOMETRY | KIGFX::REPAINT );
1089 }
1090 } );
1091 }
1092 }
1093 }
1094}
1095
1096
1098{
1099 return GetScreen() && GetScreen()->IsContentModified();
1100}
1101
1102
1104{
1105 return m_toolManager->GetTool<PCB_SELECTION_TOOL>()->GetSelection();
1106}
1107
1108
1110{
1111 // Create the manager and dispatcher & route draw panel events to the dispatcher
1113 m_toolManager->SetEnvironment( m_pcb, GetCanvas()->GetView(),
1114 GetCanvas()->GetViewControls(), config(), this );
1115 m_actions = new PCB_ACTIONS();
1117
1118 // Register tools
1119 m_toolManager->RegisterTool( new COMMON_CONTROL );
1120 m_toolManager->RegisterTool( new COMMON_TOOLS );
1121 m_toolManager->RegisterTool( new PCB_SELECTION_TOOL );
1122 m_toolManager->RegisterTool( new ZOOM_TOOL );
1123 m_toolManager->RegisterTool( new PCB_PICKER_TOOL );
1124 m_toolManager->RegisterTool( new ROUTER_TOOL );
1125 m_toolManager->RegisterTool( new EDIT_TOOL );
1126 m_toolManager->RegisterTool( new PCB_EDIT_TABLE_TOOL );
1127 m_toolManager->RegisterTool( new GLOBAL_EDIT_TOOL );
1128 m_toolManager->RegisterTool( new PAD_TOOL );
1129 m_toolManager->RegisterTool( new DRAWING_TOOL );
1130 m_toolManager->RegisterTool( new PCB_POINT_EDITOR );
1131 m_toolManager->RegisterTool( new PCB_CONTROL );
1132 m_toolManager->RegisterTool( new PCB_DESIGN_BLOCK_CONTROL );
1133 m_toolManager->RegisterTool( new BOARD_EDITOR_CONTROL );
1134 m_toolManager->RegisterTool( new BOARD_INSPECTION_TOOL );
1135 m_toolManager->RegisterTool( new BOARD_REANNOTATE_TOOL );
1136 m_toolManager->RegisterTool( new ALIGN_DISTRIBUTE_TOOL );
1137 m_toolManager->RegisterTool( new MICROWAVE_TOOL );
1138 m_toolManager->RegisterTool( new POSITION_RELATIVE_TOOL );
1139 m_toolManager->RegisterTool( new ARRAY_TOOL );
1140 m_toolManager->RegisterTool( new ZONE_FILLER_TOOL );
1141 m_toolManager->RegisterTool( new AUTOPLACE_TOOL );
1142 m_toolManager->RegisterTool( new DRC_TOOL );
1143 m_toolManager->RegisterTool( new PCB_VIEWER_TOOLS );
1144 m_toolManager->RegisterTool( new CONVERT_TOOL );
1145 m_toolManager->RegisterTool( new PCB_GROUP_TOOL );
1146 m_toolManager->RegisterTool( new CONSTRAINT_EDIT_TOOL );
1147 m_toolManager->RegisterTool( new GENERATOR_TOOL );
1148 m_toolManager->RegisterTool( new VIA_STITCH_TOOL );
1149 m_toolManager->RegisterTool( new PROPERTIES_TOOL );
1150 m_toolManager->RegisterTool( new MULTICHANNEL_TOOL );
1151 m_toolManager->RegisterTool( new MATCH_PROPERTIES_TOOL );
1152 m_toolManager->RegisterTool( new GRAPHIC_EDIT_TOOL );
1153 m_toolManager->RegisterTool( new EMBED_TOOL );
1154 m_toolManager->RegisterTool( new DRC_RULE_EDITOR_TOOL );
1155 m_toolManager->RegisterTool( new DIFF_PHASE_SKEW_TOOL );
1156 m_toolManager->InitTools();
1157
1158 for( TOOL_BASE* tool : m_toolManager->Tools() )
1159 {
1160 if( PCB_TOOL_BASE* pcbTool = dynamic_cast<PCB_TOOL_BASE*>( tool ) )
1161 pcbTool->SetIsBoardEditor( true );
1162 }
1163
1164 // Run the selection tool, it is supposed to be always active
1165 m_toolManager->InvokeTool( "common.InteractiveSelection" );
1166}
1167
1168
1170{
1172
1173 ACTION_MANAGER* mgr = m_toolManager->GetActionManager();
1174 PCB_EDITOR_CONDITIONS cond( this );
1175
1176 auto undoCond =
1177 [ this ] (const SELECTION& aSel )
1178 {
1179 DRAWING_TOOL* drawingTool = m_toolManager->GetTool<DRAWING_TOOL>();
1180
1181 if( drawingTool && drawingTool->GetDrawingMode() != DRAWING_TOOL::MODE::NONE )
1182 return true;
1183
1184 ROUTER_TOOL* routerTool = m_toolManager->GetTool<ROUTER_TOOL>();
1185
1186 if( routerTool && routerTool->RoutingInProgress() )
1187 return true;
1188
1189 return GetUndoCommandCount() > 0;
1190 };
1191
1192 auto groupWithDesignBlockLink =
1193 [] ( const SELECTION& aSel )
1194 {
1195 if( aSel.Size() != 1 )
1196 return false;
1197
1198 if( aSel[0]->Type() != PCB_GROUP_T )
1199 return false;
1200
1201 PCB_GROUP* group = static_cast<PCB_GROUP*>( aSel.GetItem( 0 ) );
1202
1203 return group->HasDesignBlockLink();
1204 };
1205
1206 wxASSERT( mgr );
1207
1208#define ENABLE( x ) ACTION_CONDITIONS().Enable( x )
1209#define CHECK( x ) ACTION_CONDITIONS().Check( x )
1210// clang-format off
1211
1213 mgr->SetConditions( ACTIONS::undo, ENABLE( undoCond ) );
1215
1219
1220 mgr->SetConditions( ACTIONS::cut, ENABLE( cond.HasItems() ) );
1221 mgr->SetConditions( ACTIONS::copy, ENABLE( cond.HasItems() ) );
1228
1229 // Keep immediate-mode dispatch alive while a tool is mid-edit on an empty board, where
1230 // HasItems() is still false but an item is under construction under the cursor.
1231 auto hasElements =
1232 [ this ] ( const SELECTION& aSel )
1233 {
1234 return GetBoard() &&
1235 ( !GetBoard()->IsEmpty() || !SELECTION_CONDITIONS::Idle( aSel ) );
1236 };
1237
1239 ENABLE( SELECTION_CONDITIONS::NotEmpty ).HotkeyEnable( hasElements ) );
1241 ENABLE( SELECTION_CONDITIONS::NotEmpty ).HotkeyEnable( hasElements ) );
1243 ENABLE( SELECTION_CONDITIONS::NotEmpty ).HotkeyEnable( hasElements ) );
1245 ENABLE( SELECTION_CONDITIONS::NotEmpty ).HotkeyEnable( hasElements ) );
1247 ENABLE( SELECTION_CONDITIONS::NotEmpty ).HotkeyEnable( hasElements ) );
1248
1249 static const std::vector<KICAD_T> groupTypes = { PCB_GROUP_T, PCB_GENERATOR_T };
1250
1255
1256 mgr->SetConditions( PCB_ACTIONS::placeLinkedDesignBlock, ENABLE( groupWithDesignBlockLink) );
1257 mgr->SetConditions( PCB_ACTIONS::saveToLinkedDesignBlock, ENABLE( groupWithDesignBlockLink) );
1258
1264
1265 auto enableZoneControlCondition =
1266 [this] ( const SELECTION& )
1267 {
1270 };
1271
1273 ENABLE( enableZoneControlCondition )
1276 ENABLE( enableZoneControlCondition )
1279 ENABLE( enableZoneControlCondition )
1282 ENABLE( enableZoneControlCondition )
1284
1286
1287 auto autoConstraintsCond =
1288 []( const SELECTION& )
1289 {
1291 return cfg && cfg->m_AutoConstraints;
1292 };
1293
1294 mgr->SetConditions( PCB_ACTIONS::toggleAutoConstraints, CHECK( autoConstraintsCond ) );
1295
1296 auto boardFlippedCond =
1297 [this]( const SELECTION& )
1298 {
1300 };
1301
1302 auto layerManagerCond =
1303 [this] ( const SELECTION& )
1304 {
1305 return LayerManagerShown();
1306 };
1307
1308 auto propertiesCond =
1309 [this] ( const SELECTION& )
1310 {
1311 return PropertiesShown();
1312 };
1313
1314 auto netInspectorCond =
1315 [this] ( const SELECTION& )
1316 {
1317 return NetInspectorShown();
1318 };
1319
1320 auto searchPaneCond =
1321 [this] ( const SELECTION& )
1322 {
1323 return m_auimgr.GetPane( SearchPaneName() ).IsShown();
1324 };
1325
1326 auto constraintsPaneCond =
1327 [this] ( const SELECTION& )
1328 {
1329 return m_auimgr.GetPane( ConstraintsPaneName() ).IsShown();
1330 };
1331
1332 auto designBlockCond =
1333 [ this ] (const SELECTION& aSel )
1334 {
1335 return m_auimgr.GetPane( DesignBlocksPaneName() ).IsShown();
1336 };
1337
1338 auto gitCommitPaneCond =
1339 [this] ( const SELECTION& )
1340 {
1341 return IsGitCommitPaneShown();
1342 };
1343
1344 auto highContrastCond =
1345 [this] ( const SELECTION& )
1346 {
1348 };
1349
1350 auto globalRatsnestCond =
1351 [this] (const SELECTION& )
1352 {
1354 return cfg && cfg->m_Display.m_ShowGlobalRatsnest;
1355 };
1356
1357 auto curvedRatsnestCond =
1358 [this] (const SELECTION& )
1359 {
1361 return cfg && cfg->m_Display.m_DisplayRatsnestLinesCurved;
1362 };
1363
1364 auto netHighlightCond =
1365 [this]( const SELECTION& )
1366 {
1367 if( PCB_DRAW_PANEL_GAL* canvas = GetCanvas() )
1368 {
1369 if( KIGFX::PCB_VIEW* view = canvas->GetView() )
1370 {
1371 if( KIGFX::PAINTER* painter = view->GetPainter() )
1372 {
1373 if( RENDER_SETTINGS* settings = painter->GetSettings() )
1374 return !settings->GetHighlightNetCodes().empty();
1375 }
1376 }
1377 }
1378
1379 return false;
1380 };
1381
1382 auto enableNetHighlightCond =
1383 [this]( const SELECTION& )
1384 {
1386 return tool && tool->IsNetHighlightSet();
1387 };
1388
1389 mgr->SetConditions( ACTIONS::highContrastMode, CHECK( highContrastCond ) );
1390 mgr->SetConditions( PCB_ACTIONS::flipBoard, CHECK( boardFlippedCond ) );
1391 mgr->SetConditions( PCB_ACTIONS::showLayersManager, CHECK( layerManagerCond ) );
1392 mgr->SetConditions( PCB_ACTIONS::showRatsnest, CHECK( globalRatsnestCond ) );
1393 mgr->SetConditions( PCB_ACTIONS::ratsnestLineMode, CHECK( curvedRatsnestCond ) );
1394 mgr->SetConditions( PCB_ACTIONS::toggleNetHighlight, CHECK( netHighlightCond )
1395 .Enable( enableNetHighlightCond ) );
1396 mgr->SetConditions( ACTIONS::showProperties, CHECK( propertiesCond ) );
1397 mgr->SetConditions( PCB_ACTIONS::showNetInspector, CHECK( netInspectorCond ) );
1398 mgr->SetConditions( PCB_ACTIONS::showSearch, CHECK( searchPaneCond ) );
1399 mgr->SetConditions( PCB_ACTIONS::showConstraintsPanel, CHECK( constraintsPaneCond ) );
1400 mgr->SetConditions( PCB_ACTIONS::showDesignBlockPanel, CHECK( designBlockCond ) );
1401 mgr->SetConditions( ACTIONS::showGitCommitPane, CHECK( gitCommitPaneCond ) );
1402
1405
1406 const auto isArcKeepCenterMode =
1407 [this]( const SELECTION& )
1408 {
1411 };
1412
1413 const auto isArcKeepEndpointMode =
1414 [this]( const SELECTION& )
1415 {
1418 };
1419
1420 const auto isArcKeepRadiusMode =
1421 [this]( const SELECTION& )
1422 {
1425 };
1426
1427 mgr->SetConditions( ACTIONS::pointEditorArcKeepCenter, CHECK( isArcKeepCenterMode ) );
1428 mgr->SetConditions( ACTIONS::pointEditorArcKeepEndpoint, CHECK( isArcKeepEndpointMode ) );
1429 mgr->SetConditions( ACTIONS::pointEditorArcKeepRadius, CHECK( isArcKeepRadiusMode ) );
1430
1431 auto isHighlightMode =
1432 [this]( const SELECTION& )
1433 {
1434 ROUTER_TOOL* tool = m_toolManager->GetTool<ROUTER_TOOL>();
1435 return tool && tool->GetRouterMode() == PNS::RM_MarkObstacles;
1436 };
1437
1438 auto isShoveMode =
1439 [this]( const SELECTION& )
1440 {
1441 ROUTER_TOOL* tool = m_toolManager->GetTool<ROUTER_TOOL>();
1442 return tool && tool->GetRouterMode() == PNS::RM_Shove;
1443 };
1444
1445 auto isWalkaroundMode =
1446 [this]( const SELECTION& )
1447 {
1448 ROUTER_TOOL* tool = m_toolManager->GetTool<ROUTER_TOOL>();
1449 return tool && tool->GetRouterMode() == PNS::RM_Walkaround;
1450 };
1451
1452 mgr->SetConditions( PCB_ACTIONS::routerHighlightMode, CHECK( isHighlightMode ) );
1453 mgr->SetConditions( PCB_ACTIONS::routerShoveMode, CHECK( isShoveMode ) );
1454 mgr->SetConditions( PCB_ACTIONS::routerWalkaroundMode, CHECK( isWalkaroundMode ) );
1455
1456 auto isAutoTrackWidth =
1457 [this]( const SELECTION& )
1458 {
1460 };
1461
1462 mgr->SetConditions( PCB_ACTIONS::autoTrackWidth, CHECK( isAutoTrackWidth ) );
1463
1464 auto haveNetCond =
1465 [] ( const SELECTION& aSel )
1466 {
1467 for( EDA_ITEM* item : aSel )
1468 {
1469 if( BOARD_CONNECTED_ITEM* bci = dynamic_cast<BOARD_CONNECTED_ITEM*>( item ) )
1470 {
1471 if( bci->GetNetCode() > 0 )
1472 return true;
1473 }
1474 }
1475
1476 return false;
1477 };
1478
1479 auto connectedOrFootprintCond =
1480 [] ( const SELECTION& aSel )
1481 {
1482 if( aSel.Empty() )
1483 return false;
1484
1485 for( EDA_ITEM* item : aSel )
1486 {
1487 if( item->Type() == PCB_FOOTPRINT_T )
1488 continue;
1489
1490 if( !dynamic_cast<BOARD_CONNECTED_ITEM*>( item ) )
1491 return false;
1492 }
1493
1494 return true;
1495 };
1496
1497 mgr->SetConditions( PCB_ACTIONS::showNetInRatsnest, ENABLE( haveNetCond ) );
1498 mgr->SetConditions( PCB_ACTIONS::hideNetInRatsnest, ENABLE( haveNetCond ) );
1501
1502 static const std::vector<KICAD_T> trackTypes = { PCB_TRACE_T, PCB_ARC_T, PCB_VIA_T };
1503 static const std::vector<KICAD_T> padOwnerTypes = { PCB_FOOTPRINT_T, PCB_PAD_T };
1504 static const std::vector<KICAD_T> footprintTypes = { PCB_FOOTPRINT_T };
1505 static const std::vector<KICAD_T> crossProbeTypes = { PCB_PAD_T, PCB_FOOTPRINT_T, PCB_GROUP_T };
1506 static const std::vector<KICAD_T> zoneTypes = { PCB_ZONE_T };
1507
1511 mgr->SetConditions( PCB_ACTIONS::grabUnconnected, ENABLE( connectedOrFootprintCond ) );
1514
1515
1517 && SELECTION_CONDITIONS::OnlyTypes( zoneTypes );
1518
1520 && SELECTION_CONDITIONS::OnlyTypes( zoneTypes );
1521
1522 mgr->SetConditions( PCB_ACTIONS::zoneDuplicate, ENABLE( singleZoneCond ) );
1523 mgr->SetConditions( PCB_ACTIONS::drawZoneCutout, ENABLE( singleZoneCond ) );
1524 mgr->SetConditions( PCB_ACTIONS::drawSimilarZone, ENABLE( singleZoneCond ) );
1525 mgr->SetConditions( PCB_ACTIONS::zoneMerge, ENABLE( zoneMergeCond ) );
1526
1529
1530#define CURRENT_TOOL( action ) mgr->SetConditions( action, CHECK( cond.CurrentTool( action ) ) )
1531
1532 // These tools can be used at any time to inspect the board
1537
1538 auto isDRCIdle =
1539 [this] ( const SELECTION& )
1540 {
1541 DRC_TOOL* tool = m_toolManager->GetTool<DRC_TOOL>();
1542 return !( tool && tool->IsDRCRunning() );
1543 };
1544
1545#define CURRENT_EDIT_TOOL( action ) \
1546 mgr->SetConditions( action, ACTION_CONDITIONS().Check( cond.CurrentTool( action ) ) \
1547 .Enable( isDRCIdle ) )
1548
1549 // These tools edit the board, so they must be disabled during some operations
1587
1606
1612
1613#undef CURRENT_TOOL
1614#undef CURRENT_EDIT_TOOL
1615#undef ENABLE
1616#undef CHECK
1617// clang-format on
1618}
1619
1620
1621void PCB_EDIT_FRAME::OnQuit( wxCommandEvent& event )
1622{
1623 if( event.GetId() == wxID_EXIT )
1624 Kiway().OnKiCadExit();
1625
1626 if( event.GetId() == wxID_CLOSE || Kiface().IsSingle() )
1627 Close( false );
1628}
1629
1630
1631void PCB_EDIT_FRAME::ResolveDRCExclusions( bool aCreateMarkers )
1632{
1633 BOARD_COMMIT commit( this );
1634
1635 for( PCB_MARKER* marker : GetBoard()->ResolveDRCExclusions( aCreateMarkers ) )
1636 {
1637 if( marker->GetMarkerType() == MARKER_BASE::MARKER_DRAWING_SHEET )
1638 marker->GetRCItem()->SetItems( GetCanvas()->GetDrawingSheet() );
1639
1640 commit.Add( marker );
1641 }
1642
1643 commit.Push( wxEmptyString, SKIP_UNDO | SKIP_SET_DIRTY );
1644
1645 for( PCB_MARKER* marker : GetBoard()->Markers() )
1646 {
1647 if( marker->GetSeverity() == RPT_SEVERITY_EXCLUSION )
1648 GetCanvas()->GetView()->Update( marker );
1649 }
1650
1652}
1653
1654
1655bool PCB_EDIT_FRAME::canCloseWindow( wxCloseEvent& aEvent )
1656{
1657 // Shutdown blocks must be determined and vetoed as early as possible
1658 if( KIPLATFORM::APP::SupportsShutdownBlockReason() && aEvent.GetId() == wxEVT_QUERY_END_SESSION
1659 && IsContentModified() )
1660 {
1661 return false;
1662 }
1663
1664 ZONE_FILLER_TOOL* zoneFillerTool = m_toolManager->GetTool<ZONE_FILLER_TOOL>();
1665
1666 if( zoneFillerTool->IsBusy() )
1667 {
1668 wxBell();
1669
1670 if( wxWindow* reporter = dynamic_cast<wxWindow*>( zoneFillerTool->GetProgressReporter() ) )
1671 reporter->ShowWithEffect( wxSHOW_EFFECT_EXPAND );
1672
1673 return false;
1674 }
1675
1676 // Don't allow closing while the modal footprint chooser is open
1677 // Use C-style cast due to Mac's inability to dynamic cast between compile modules
1679
1680 if( chooser && chooser->IsModal() ) // Can close footprint chooser?
1681 return false;
1682
1683 if( Kiface().IsSingle() )
1684 {
1685 // Use C-style cast due to Mac's inability to dynamic cast between compile modules
1687
1688 if( fpEditor )
1689 {
1690 bool cancel = !fpEditor->Close(); // Can close footprint editor?
1691
1692 // If fp editor had unsaved changes it will have been fronted. Bring board editor back to front.
1693 Raise();
1694
1695 if( cancel )
1696 return false;
1697 }
1698
1699 // Use C-style cast due to Mac's inability to dynamic cast between compile modules
1701
1702 if( fpViewer && !fpViewer->Close() ) // Can close footprint viewer?
1703 return false;
1704 }
1705 else
1706 {
1707 // Use C-style cast due to Mac's inability to dynamic cast between compile modules
1709
1710 if( fpEditor )
1711 {
1712 bool cancel = !fpEditor->HandleUnsavedChanges( true );
1713
1714 // If fp editor had unsaved changes it will have been fronted. Bring board editor back to front.
1715 Raise();
1716
1717 if( cancel )
1718 return false;
1719 }
1720 }
1721
1723 return false;
1724
1725 if( IsContentModified() )
1726 {
1727 wxFileName fileName = GetBoard()->GetFileName();
1728 wxString msg = _( "Save changes to '%s' before closing?" );
1729
1730 wxSafeYield( this, true ); // Allow frame to come to front before showing "Save Changes?"
1731
1732 if( !HandleUnsavedChanges( this, wxString::Format( msg, fileName.GetFullName() ),
1733 [&]() -> bool
1734 {
1735 return SaveBoard();
1736 } ) )
1737 {
1738 return false;
1739 }
1740
1741 // If user discarded changes, create a duplicate commit of last saved PCB state and
1742 // advance Last_Save_pcb tag for explicit history event.
1743 if( GetLastUnsavedChangesResponse() == wxID_NO )
1744 {
1745 wxString projPath = Prj().GetProjectPath();
1746
1747 if( !projPath.IsEmpty() && Kiway().LocalHistory().HistoryExists( projPath ) )
1748 {
1749 Kiway().LocalHistory().CommitDuplicateOfLastSave( projPath, wxS( "pcb" ),
1750 wxS( "Discard unsaved pcb changes" ) );
1751 }
1752 }
1753 }
1754
1755 return PCB_BASE_EDIT_FRAME::canCloseWindow( aEvent );
1756}
1757
1758
1760{
1761 // Unregister the autosave saver before any cleanup that might invalidate the board
1762 if( GetBoard() )
1764
1765 // On Windows 7 / 32 bits, on OpenGL mode only, Pcbnew crashes
1766 // when closing this frame if a footprint was selected, and the footprint editor called
1767 // to edit this footprint, and when closing pcbnew if this footprint is still selected
1768 // See https://bugs.launchpad.net/kicad/+bug/1655858
1769 // I think this is certainly a OpenGL event fired after frame deletion, so this workaround
1770 // avoid the crash (JPC)
1771 GetCanvas()->SetEvtHandlerEnabled( false );
1772
1774
1777
1778 // Clean up mode-less dialogs.
1779 Unbind( EDA_EVT_CLOSE_DIALOG_BOOK_REPORTER, &PCB_EDIT_FRAME::onCloseModelessBookReporterDialogs, this );
1780 Unbind( EDA_EVT_CLOSE_DIALOG_FOOTPRINT_FIELDS_TABLE, &PCB_EDIT_FRAME::onCloseFootprintFieldsTableDialog, this );
1781
1782 wxWindow* drcDlg = wxWindow::FindWindowByName( DIALOG_DRC_WINDOW_NAME );
1783
1784 if( drcDlg )
1785 drcDlg->Close( true );
1786
1787 wxWindow* ruleEditorDlg = wxWindow::FindWindowByName( DIALOG_DRC_RULE_EDITOR_WINDOW_NAME );
1788
1789 if( ruleEditorDlg )
1790 ruleEditorDlg->Close( true );
1791
1792 if( m_findDialog )
1793 {
1794 m_findDialog->Destroy();
1795 m_findDialog = nullptr;
1796 }
1797
1799 {
1800 m_findByPropertiesDialog->Destroy();
1801 m_findByPropertiesDialog = nullptr;
1802 }
1803
1805 {
1806 m_inspectDrcErrorDlg->Destroy();
1807 m_inspectDrcErrorDlg = nullptr;
1808 }
1809
1811 {
1812 m_inspectClearanceDlg->Destroy();
1813 m_inspectClearanceDlg = nullptr;
1814 }
1815
1817 {
1818 m_inspectConstraintsDlg->Destroy();
1819 m_inspectConstraintsDlg = nullptr;
1820 }
1821
1822 if( m_footprintDiffDlg )
1823 {
1824 m_footprintDiffDlg->Destroy();
1825 m_footprintDiffDlg = nullptr;
1826 }
1827
1829 {
1832 }
1833
1834 // Delete the auto save file if it exists. Only sweep when the board was actually dirtied in this session;
1835 // otherwise an existing autosave is a previous-session leftover the user explicitly deferred in the recovery
1836 // dialog.
1837 if( !Prj().IsNullProject() && GetBoard() && IsContentModified() )
1838 {
1839 Kiway().LocalHistory().RemoveAutosaveFiles( Prj().GetProjectPath(), { GetBoard()->GetFileName() } );
1840 }
1841
1842 // Make sure local settings are persisted
1843 if( Prj().GetLocalSettings().ShouldAutoSave() )
1844 {
1845 m_netInspectorPanel->SaveSettings();
1847 }
1848 else
1849 {
1850 wxLogTrace( traceAutoSave, wxT( "Skipping auto-save of migrated local settings" ) );
1851 }
1852
1853 // Do not show the layer manager during closing to avoid flicker on some platforms (Windows) that
1854 // generate useless redraw of items in the Layer Manager
1856 {
1857 m_auimgr.GetPane( wxS( "LayersManager" ) ).Show( false );
1858 m_auimgr.GetPane( wxS( "TabbedPanel" ) ).Show( false );
1859 }
1860
1861 // Unlink the old project if needed
1863
1864 // Delete board structs and undo/redo lists, to avoid crash on exit when deleting some structs
1865 // (mainly in undo/redo lists) too late
1866 Clear_Pcb( false, true );
1867
1868 // do not show the window because ScreenPcb will be deleted and we do not want any paint event
1869 Show( false );
1870
1872}
1873
1874
1881
1882
1884{
1885 BOARD* board = GetBoard();
1886 KIGFX::VIEW* view = GetCanvas()->GetView();
1887
1888 board->RefreshDrillSymbolLayers();
1889
1890 for( PCB_TRACK* track : board->Tracks() )
1891 {
1892 if( track->Type() == PCB_VIA_T )
1893 view->Update( track, aUpdateFlags );
1894 }
1895
1896 for( FOOTPRINT* footprint : board->Footprints() )
1897 {
1898 for( PAD* pad : footprint->Pads() )
1899 {
1900 if( pad->HasHole() )
1901 view->Update( pad, aUpdateFlags );
1902 }
1903 }
1904
1905 GetCanvas()->Refresh();
1906}
1907
1908
1909void PCB_EDIT_FRAME::ShowBoardSetupDialog( const wxString& aInitialPage, wxWindow* aParent )
1910{
1911 static std::mutex dialogMutex; // Local static mutex
1912
1913 std::unique_lock<std::mutex> dialogLock( dialogMutex, std::try_to_lock );
1914
1915 // One dialog at a time.
1916 if( !dialogLock.owns_lock() )
1917 {
1918 if( m_boardSetupDlg && m_boardSetupDlg->IsShown() )
1919 {
1920 m_boardSetupDlg->Raise(); // Brings the existing dialog to the front
1921 }
1922
1923 return;
1924 }
1925
1926 // Make sure everything's up-to-date
1928
1929 DIALOG_BOARD_SETUP dlg( this, aParent );
1930
1931 if( !aInitialPage.IsEmpty() )
1932 dlg.SetInitialPage( aInitialPage, wxEmptyString );
1933
1934 // Assign dlg to the m_boardSetupDlg pointer to track its status.
1935 m_boardSetupDlg = &dlg;
1936
1937 // QuasiModal required for Scintilla auto-complete
1938 if( dlg.ShowQuasiModal() == wxID_OK )
1939 {
1940 // Note: We must synchronise time domain properties before nets and classes, otherwise the updates
1941 // called by the board listener events are using stale data
1944
1945 if( !GetBoard()->SynchronizeComponentClasses( std::unordered_set<wxString>() ) )
1946 {
1947 m_infoBar->RemoveAllButtons();
1948 m_infoBar->AddCloseButton();
1949 m_infoBar->ShowMessage( _( "Could not load component class assignment rules" ), wxICON_WARNING,
1950 WX_INFOBAR::MESSAGE_TYPE::GENERIC );
1951 }
1952
1953 // We don't know if anything was modified, so err on the side of requiring a save
1954 OnModify();
1955
1957
1960
1961 // CROSS_REF keys deliberately excluded — those are driven by per-item
1962 // BOARD_COMMIT changes.
1963 if( BOARD_TEXT_VAR_ADAPTER* adapter = GetBoard()->GetTextVarAdapter() )
1964 adapter->Tracker().InvalidateProjectScoped();
1965
1966 PCBNEW_SETTINGS* settings = GetPcbNewSettings();
1967 static LSET maskAndPasteLayers = LSET( { F_Mask, F_Paste, B_Mask, B_Paste } );
1968
1970 [&]( KIGFX::VIEW_ITEM* aItem ) -> int
1971 {
1972 int flags = 0;
1973
1974 if( !aItem->IsBOARD_ITEM() )
1975 return flags;
1976
1977 BOARD_ITEM* item = static_cast<BOARD_ITEM*>( aItem );
1978
1979 if( item->Type() == PCB_VIA_T || item->Type() == PCB_PAD_T )
1980 {
1981 // Note: KIGFX::REPAINT isn't enough for things that go from invisible
1982 // to visible as they won't be found in the view layer's itemset for
1983 // re-painting.
1984 if( ( GetBoard()->GetVisibleLayers() & maskAndPasteLayers ).any() )
1985 flags |= KIGFX::ALL;
1986 }
1987
1988 if( item->Type() == PCB_TRACE_T || item->Type() == PCB_ARC_T || item->Type() == PCB_VIA_T )
1989 {
1991 flags |= KIGFX::REPAINT;
1992 }
1993
1994 if( item->Type() == PCB_PAD_T )
1995 {
1996 if( settings->m_Display.m_PadClearance )
1997 flags |= KIGFX::REPAINT;
1998 }
1999
2000 if( EDA_TEXT* text = dynamic_cast<EDA_TEXT*>( aItem ) )
2001 {
2002 if( text->HasTextVars() )
2003 {
2004 text->ClearRenderCache();
2005 text->ClearBoundingBoxCache();
2007 }
2008 }
2009
2010 return flags;
2011 } );
2012
2013 GetCanvas()->Refresh();
2014
2018
2019 //this event causes the routing tool to reload its design rules information
2021 toolEvent.SetHasPosition( false );
2022 m_toolManager->ProcessEvent( toolEvent );
2023 }
2024
2025 GetCanvas()->SetFocus();
2026
2027 // Reset m_boardSetupDlg after the dialog is closed
2028 m_boardSetupDlg = nullptr;
2029}
2030
2031
2033{
2034 m_searchPane->FocusSearch();
2035}
2036
2037
2039{
2041
2042 PCBNEW_SETTINGS* cfg = dynamic_cast<PCBNEW_SETTINGS*>( aCfg );
2043 wxASSERT( cfg );
2044
2045 if( cfg )
2046 {
2050 }
2051}
2052
2053
2055{
2057
2058 PCBNEW_SETTINGS* cfg = dynamic_cast<PCBNEW_SETTINGS*>( aCfg );
2059 wxASSERT( cfg );
2060
2061 if( cfg )
2062 {
2063 wxAuiPaneInfo& apperancePane = m_auimgr.GetPane( AppearancePanelName() );
2064 cfg->m_AuiPanels.show_layer_manager = apperancePane.IsShown();
2065
2066 if( m_propertiesPanel )
2067 {
2068 cfg->m_AuiPanels.show_properties = m_propertiesPanel->IsShownOnScreen();
2070 cfg->m_AuiPanels.properties_splitter = m_propertiesPanel->SplitterProportion();
2071 }
2072
2073 // ensure m_ShowSearch is up to date (the pane can be closed)
2074 wxAuiPaneInfo& searchPaneInfo = m_auimgr.GetPane( SearchPaneName() );
2075 m_ShowSearch = searchPaneInfo.IsShown();
2077 cfg->m_AuiPanels.search_panel_height = m_searchPane->GetSize().y;
2078 cfg->m_AuiPanels.search_panel_width = m_searchPane->GetSize().x;
2079 cfg->m_AuiPanels.search_panel_dock_direction = searchPaneInfo.dock_direction;
2080
2081 cfg->m_AuiPanels.show_git_commit_pane = m_auimgr.GetPane( GitCommitPaneName() ).IsShown();
2082
2084 {
2085 wxAuiPaneInfo& netInspectorhPaneInfo = m_auimgr.GetPane( NetInspectorPanelName() );
2086 m_ShowNetInspector = netInspectorhPaneInfo.IsShown();
2088 }
2089
2090 if( m_appearancePanel )
2091 {
2094 cfg->m_AuiPanels.appearance_expand_layer_display = m_appearancePanel->IsLayerOptionsExpanded();
2095 cfg->m_AuiPanels.appearance_expand_net_display = m_appearancePanel->IsNetOptionsExpanded();
2096 }
2097
2098 wxAuiPaneInfo& designBlocksPane = m_auimgr.GetPane( DesignBlocksPaneName() );
2099 cfg->m_AuiPanels.design_blocks_show = designBlocksPane.IsShown();
2100
2101 if( designBlocksPane.IsDocked() )
2102 {
2104 }
2105 else
2106 {
2107 cfg->m_AuiPanels.design_blocks_panel_float_height = designBlocksPane.floating_size.y;
2108 cfg->m_AuiPanels.design_blocks_panel_float_width = designBlocksPane.floating_size.x;
2109 }
2110
2111 m_designBlocksPane->SaveSettings();
2112 }
2113}
2114
2115
2117{
2118 PCBNEW_SETTINGS* cfg = dynamic_cast<PCBNEW_SETTINGS*>( config() );
2119
2120 return cfg ? cfg->m_RotationAngle : ANGLE_90;
2121}
2122
2123
2128
2129
2131{
2132
2133 GetColorSettings()->SetColor( LAYER_GRID, aColor );
2134 GetCanvas()->GetGAL()->SetGridColor( aColor );
2135}
2136
2137
2138void PCB_EDIT_FRAME::SetActiveLayer( PCB_LAYER_ID aLayer, bool aForceRedraw )
2139{
2140 const PCB_LAYER_ID oldLayer = GetActiveLayer();
2141
2142 if( oldLayer == aLayer && !aForceRedraw )
2143 return;
2144
2146
2147 m_appearancePanel->OnLayerChanged();
2148
2149 m_toolManager->PostAction( PCB_ACTIONS::layerChanged ); // notify other tools
2150 GetCanvas()->SetFocus(); // allow capture of hotkeys
2151
2152 if( aForceRedraw )
2153 GetCanvas()->SetHighContrastLayer( aLayer );
2154 else
2156
2157 /*
2158 * Only show pad, via and track clearances when a copper layer is active
2159 * and then only show the clearance layer for that copper layer. For
2160 * front/back non-copper layers, show the clearance layer for the outer
2161 * layer on that side.
2162 *
2163 * For pads/vias, this is to avoid clutter when there are pad/via layers
2164 * that vary in flash (i.e. clearance from the hole or pad edge), padstack
2165 * shape on each layer or clearances on each layer.
2166 *
2167 * For tracks, this follows the same logic as pads/vias, but in theory could
2168 * have their own set of independent clearance layers to allow track clearance
2169 * to be shown for more layers.
2170 */
2171 const auto getClearanceLayerForActive =
2172 []( PCB_LAYER_ID aActiveLayer ) -> std::optional<int>
2173 {
2174 if( IsCopperLayer( aActiveLayer ) )
2175 return CLEARANCE_LAYER_FOR( aActiveLayer );
2176
2177 return std::nullopt;
2178 };
2179
2180 if( std::optional<int> oldClearanceLayer = getClearanceLayerForActive( oldLayer ) )
2181 GetCanvas()->GetView()->SetLayerVisible( *oldClearanceLayer, false );
2182
2183 if( std::optional<int> newClearanceLayer = getClearanceLayerForActive( aLayer ) )
2184 GetCanvas()->GetView()->SetLayerVisible( *newClearanceLayer, true );
2185
2186 // per-layer view groups already hold each layer geometry so an active-layer change needs no
2187 // re-tessellation just clearance visibility above and the recolour in SetHighContrastLayer
2188
2189 // idle refresh coalesces mashed hotkeys into one repaint forced redraws stay immediate
2190 if( aForceRedraw )
2191 GetCanvas()->Refresh();
2192 else
2194}
2195
2196
2198{
2199 wxFileName fn( GetBoard()->GetFileName() );
2200
2202
2203 layerEnum.Choices().Clear();
2204 layerEnum.Undefined( UNDEFINED_LAYER );
2205
2206 for( PCB_LAYER_ID layer : LSET::AllLayersMask() )
2207 {
2208 // Canonical name
2209 layerEnum.Map( layer, LSET::Name( layer ) );
2210
2211 // User name
2212 layerEnum.Map( layer, GetBoard()->GetLayerName( layer ) );
2213 }
2214
2215 DRC_TOOL* drcTool = m_toolManager->GetTool<DRC_TOOL>();
2216
2217 try
2218 {
2219 drcTool->GetDRCEngine()->InitEngine( GetBoard()->GetDesignRulesPath() );
2220 }
2221 catch( PARSE_ERROR& )
2222 {
2223 // Not sure this is the best place to tell the user their rules are buggy, so
2224 // we'll stay quiet for now. Feel free to revisit this decision....
2225 }
2226
2228
2229 // Migrate obsolete WRL 3D model references to current STEP models. Only
2230 // runs in the GUI: CLI and scripting load paths must not mutate board
2231 // state on load. The STEP exporter does its own WRL->STEP substitution at
2232 // export time via the --subst-models flag, and the 3D cache quietly falls
2233 // back to sibling STEP files for missing WRLs in headless contexts.
2234 if( Pgm().IsGUI() )
2235 {
2236 // Silently replace references whose filename uniquely identifies a
2237 // STEP sibling. Leaves ambiguous cases for the infobar below.
2239
2240 if( int unresolved = DIALOG_MIGRATE_3D_MODELS::CountUnresolvedWrlReferences( this ) )
2241 {
2242 wxString msg = _( "WRL 3D model could not be matched to equivalent STEP model." );
2243
2244 if( unresolved > 1 )
2245 {
2246 msg = wxString::Format( _( "%d WRL 3D models could not be matched to equivalent STEP models." ),
2247 unresolved );
2248 }
2249
2250 m_loadNoticeInfoBar->RemoveAllButtons();
2251 m_loadNoticeInfoBar->AddLink( _( "Show options" ),
2252 [this]( wxHyperlinkEvent& )
2253 {
2254 DIALOG_MIGRATE_3D_MODELS dlg( this );
2255 dlg.ShowModal();
2256
2257 // Dismiss the infobar if nothing remains to resolve;
2258 // otherwise leave it so the user can try again.
2260 m_loadNoticeInfoBar->Dismiss();
2261 } );
2262 m_loadNoticeInfoBar->AddCloseButton();
2263 m_loadNoticeInfoBar->ShowMessageFor( msg, 10000, wxICON_INFORMATION );
2264 }
2265 }
2266
2267 UpdateTitle();
2268
2269 // Display a warning that the file is read only
2270 if( fn.FileExists() && !fn.IsFileWritable() )
2271 {
2272 m_infoBar->RemoveAllButtons();
2273 m_infoBar->AddCloseButton();
2274 m_infoBar->ShowMessage( _( "Board file is read only." ), wxICON_WARNING,
2275 WX_INFOBAR::MESSAGE_TYPE::OUTDATED_SAVE );
2276 }
2277
2279
2280 // Sync layer and item visibility
2282
2283 SetElementVisibility( LAYER_RATSNEST, GetPcbNewSettings()->m_Display.m_ShowGlobalRatsnest );
2284
2285 m_appearancePanel->OnBoardChanged();
2286
2287 // Apply saved display state to the appearance panel after it has been set up
2288 PROJECT_LOCAL_SETTINGS& localSettings = Prj().GetLocalSettings();
2289
2290 m_appearancePanel->ApplyLayerPreset( localSettings.m_ActiveLayerPreset );
2291
2292 if( GetBoard()->GetDesignSettings().IsLayerEnabled( localSettings.m_ActiveLayer ) )
2293 SetActiveLayer( localSettings.m_ActiveLayer, true );
2294 else
2295 SetActiveLayer( GetActiveLayer(), true ); // Make sure to repaint even if not switching
2296
2297 PROJECT_FILE& projectFile = Prj().GetProjectFile();
2298
2299 m_layerPairSettings->SetLayerPairs( projectFile.m_LayerPairInfos );
2300 m_layerPairSettings->SetCurrentLayerPair( LAYER_PAIR{ F_Cu, B_Cu } );
2301
2302 // Updates any auto dimensions and the auxiliary toolbar tracks/via sizes
2304
2305 // Sync the net inspector now we have connectivity calculated
2307 m_netInspectorPanel->OnBoardChanged();
2308
2309 // Display the loaded board:
2310 Zoom_Automatique( false );
2311
2312 // The DRC engine above makes clearances computable, so only the items that draw a
2313 // clearance outline are stale; marking every item re-tessellates the whole board
2314 {
2315 KIGFX::VIEW* view = GetCanvas()->GetView();
2316 const auto& opts = GetPcbNewSettings()->m_Display;
2317
2318 for( FOOTPRINT* footprint : GetBoard()->Footprints() )
2319 {
2320 for( PAD* pad : footprint->Pads() )
2321 view->Update( pad, KIGFX::REPAINT );
2322 }
2323
2324 if( opts.m_TrackClearance == SHOW_WITH_VIA_ALWAYS )
2325 {
2326 for( PCB_TRACK* track : GetBoard()->Tracks() )
2327 view->Update( track, KIGFX::REPAINT );
2328 }
2329 }
2330
2331 Refresh();
2332
2333 SetMsgPanel( GetBoard() );
2334 SetStatusText( wxEmptyString );
2335
2336 KIPLATFORM::APP::SetShutdownBlockReason( this, _( "PCB file changes are unsaved" ) );
2337}
2338
2339
2341{
2342 m_appearancePanel->UpdateDisplayOptions();
2343}
2344
2345
2347{
2348 return GetBoard()->IsElementVisible( aElement );
2349}
2350
2351
2353{
2354 // Force the RATSNEST visible
2355 if( aElement == LAYER_RATSNEST )
2356 GetCanvas()->GetView()->SetLayerVisible( aElement, true );
2357 else
2358 GetCanvas()->GetView()->SetLayerVisible( aElement , aNewState );
2359
2360 GetBoard()->SetElementVisibility( aElement, aNewState );
2361}
2362
2363
2365{
2366 // call my base class
2368
2369 m_auimgr.GetPane( m_appearancePanel ).Caption( _( "Appearance" ) );
2370 m_auimgr.GetPane( m_selectionFilterPanel ).Caption( _( "Selection Filter" ) );
2371 m_auimgr.GetPane( m_propertiesPanel ).Caption( _( "Properties" ) );
2372 m_auimgr.GetPane( m_netInspectorPanel ).Caption( _( "Net Inspector" ) );
2373 m_auimgr.Update();
2374
2375 UpdateTitle();
2376}
2377
2378
2380{
2382
2383 if( project.m_PcbLastPath[ aType ].IsEmpty() )
2384 return wxEmptyString;
2385
2386 wxFileName absoluteFileName = project.m_PcbLastPath[ aType ];
2387 wxFileName pcbFileName = GetBoard()->GetFileName();
2388
2389 absoluteFileName.MakeAbsolute( pcbFileName.GetPath() );
2390 return absoluteFileName.GetFullPath();
2391}
2392
2393
2394void PCB_EDIT_FRAME::SetLastPath( LAST_PATH_TYPE aType, const wxString& aLastPath )
2395{
2397
2398 wxFileName relativeFileName = aLastPath;
2399 wxFileName pcbFileName = GetBoard()->GetFileName();
2400
2401 relativeFileName.MakeRelativeTo( pcbFileName.GetPath() );
2402
2403 if( relativeFileName.GetFullPath() != project.m_PcbLastPath[ aType ] )
2404 {
2405 project.m_PcbLastPath[ aType ] = relativeFileName.GetFullPath();
2406 OnModify();
2407 }
2408}
2409
2410
2412{
2414 Kiway().LocalHistory().NoteFileChange( GetBoard()->GetFileName() );
2415 m_ZoneFillsDirty = true;
2416
2417 if( m_isClosing )
2418 return;
2419
2420 // A generated table reports the board, so any edit may already have made it wrong
2421 // A drill chart compares a counter but a stackup table regenerates its text, ~100 us at 32 layers
2423
2424 Update3DView( true, GetPcbNewSettings()->m_Display.m_Live3DRefresh );
2425
2426 if( !GetTitle().StartsWith( wxT( "*" ) ) )
2427 UpdateTitle();
2428}
2429
2430
2431void PCB_EDIT_FRAME::OnBoardItemsChanged( BOARD& aBoard, std::vector<BOARD_ITEM*>& aItems )
2432{
2433 bool rebuilt = false;
2434
2435 for( BOARD_ITEM* item : aItems )
2436 {
2437 if( !IsGeneratedTableType( item->Type() ) )
2438 continue;
2439
2440 rebuilt = true;
2441
2442 if( GetCanvas() )
2443 GetCanvas()->GetView()->Update( item );
2444 }
2445
2446 // The rebuild may have freed selected cells, which can no longer be asked what they were
2447 PCB_SELECTION_TOOL* selTool = m_toolManager ? m_toolManager->GetTool<PCB_SELECTION_TOOL>() : nullptr;
2448
2449 if( rebuilt && selTool && !selTool->GetSelection().Empty() )
2450 selTool->RebuildSelection();
2451}
2452
2453
2455{
2456 // The libraries were read once and then cached. A refresh is where they need to be refreshed
2458
2459 Update3DView( true, true );
2460
2461 std::shared_ptr<CONNECTIVITY_DATA> connectivity = GetBoard()->GetConnectivity();
2462 connectivity->RecalculateRatsnest( nullptr );
2464
2465 std::vector<MSG_PANEL_ITEM> msg_list;
2466 GetBoard()->GetMsgPanelInfo( this, msg_list );
2467 SetMsgPanel( msg_list );
2468}
2469
2470
2472{
2473 wxFileName fn = GetBoard()->GetFileName();
2474 bool readOnly = false;
2475 bool unsaved = false;
2476
2477 if( fn.IsOk() && fn.FileExists() )
2478 readOnly = !fn.IsFileWritable();
2479 else
2480 unsaved = true;
2481
2482 wxString title;
2483
2484 if( IsContentModified() )
2485 title = wxT( "*" );
2486
2487 title += fn.GetName();
2488
2489 if( readOnly )
2490 title += wxS( " " ) + _( "[Read Only]" );
2491
2492 if( unsaved )
2493 title += wxS( " " ) + _( "[Unsaved]" );
2494
2495 title += wxT( " \u2014 " ) + _( "PCB Editor" );
2496
2497 SetTitle( title );
2498}
2499
2500
2502{
2503 // Update the layer manager and other widgets from the board setup
2504 // (layer and items visibility, colors ...)
2505
2506 // Rebuild list of nets (full ratsnest rebuild)
2508
2509 // Update info shown by the horizontal toolbars
2511
2512 LSET activeLayers = GetBoard()->GetEnabledLayers();
2513
2514 if( !activeLayers.test( GetActiveLayer() ) )
2515 SetActiveLayer( activeLayers.Seq().front() );
2516
2517 // The layer selector lives on the top auxiliary toolbar. Users can remove every
2518 // entry from that toolbar via Preferences, in which case the control is destroyed
2519 // and m_SelLayerBox is null. Avoid dereferencing it here.
2520 if( m_SelLayerBox )
2521 m_SelLayerBox->SetLayerSelection( GetActiveLayer() );
2522
2524
2525 layerEnum.Choices().Clear();
2526 layerEnum.Undefined( UNDEFINED_LAYER );
2527
2528 for( PCB_LAYER_ID layer : LSET::AllLayersMask() )
2529 {
2530 // Canonical name
2531 layerEnum.Map( layer, LSET::Name( layer ) );
2532
2533 // User name
2534 layerEnum.Map( layer, GetBoard()->GetLayerName( layer ) );
2535 }
2536
2538
2539 // Sync visibility with canvas
2540 for( PCB_LAYER_ID layer : LSET::AllLayersMask() )
2541 GetCanvas()->GetView()->SetLayerVisible( layer, GetBoard()->IsLayerVisible( layer ) );
2542
2543 // Stackup and/or color theme may have changed
2544 m_appearancePanel->OnBoardChanged();
2545 m_netInspectorPanel->OnParentSetupChanged();
2546}
2547
2548
2550{
2551 // switches currently used canvas (Cairo / OpenGL).
2552 PCB_BASE_FRAME::SwitchCanvas( aCanvasType );
2553}
2554
2555
2557{
2558 if( !m_findDialog )
2559 {
2560 m_findDialog = new DIALOG_FIND( this );
2561 m_findDialog->SetCallback( std::bind( &PCB_SELECTION_TOOL::FindItem,
2562 m_toolManager->GetTool<PCB_SELECTION_TOOL>(), _1 ) );
2563 }
2564
2565 wxString findString;
2566
2567 PCB_SELECTION& selection = m_toolManager->GetTool<PCB_SELECTION_TOOL>()->GetSelection();
2568
2569 if( selection.Size() == 1 && selection.Front() != m_findDialog->GetItem() )
2570 {
2571 EDA_ITEM* front = selection.Front();
2572
2573 switch( front->Type() )
2574 {
2575 case PCB_FOOTPRINT_T:
2576 findString = UnescapeString( static_cast<FOOTPRINT*>( front )->GetValue() );
2577 break;
2578
2579 case PCB_FIELD_T:
2580 case PCB_TEXT_T:
2581 findString = UnescapeString( static_cast<PCB_TEXT*>( front )->GetText() );
2582
2583 if( findString.Contains( wxT( "\n" ) ) )
2584 findString = findString.Before( '\n' );
2585
2586 break;
2587
2588 default:
2589 break;
2590 }
2591 }
2592
2593 m_findDialog->Preload( findString );
2594
2595 m_findDialog->Show( true );
2596}
2597
2598
2607
2608
2614
2615
2621
2622
2623void PCB_EDIT_FRAME::FindNext( bool reverse )
2624{
2625 if( !m_findDialog )
2627
2628 m_findDialog->FindNext( reverse );
2629}
2630
2631
2633{
2634 if( Kiface().IsSingle() )
2635 return 0;
2636
2637 // Update PCB requires a netlist. Therefore the schematic editor must be running
2638 // If this is not the case, open the schematic editor
2639 KIWAY_PLAYER* frame = Kiway().Player( FRAME_SCH, true );
2640
2641 // If Kiway() cannot create the eeschema frame, it shows a error message, and
2642 // frame is null
2643 if( !frame )
2644 return -1;
2645
2646 if( !frame->IsShownOnScreen() )
2647 {
2648 wxEventBlocker blocker( this );
2649 wxFileName fn( Prj().GetProjectPath(), Prj().GetProjectName(), FILEEXT::KiCadSchematicFileExtension );
2650
2651 // Maybe the file hasn't been converted to the new s-expression file format so
2652 // see if the legacy schematic file is still in play.
2653 if( !fn.FileExists() )
2654 {
2656
2657 if( !fn.FileExists() )
2658 {
2659 DisplayErrorMessage( this, _( "The schematic for this board cannot be found." ) );
2660 return -2;
2661 }
2662 }
2663
2664 frame->OpenProjectFiles( std::vector<wxString>( 1, fn.GetFullPath() ) );
2665
2666 // we show the schematic editor frame, because do not show is seen as
2667 // a not yet opened schematic by Kicad manager, which is not the case
2668 frame->Show( true );
2669
2670 // bring ourselves back to the front
2671 Raise();
2672 }
2673
2674 return 1; //Success!
2675}
2676
2677
2678bool PCB_EDIT_FRAME::FetchNetlistFromSchematic( NETLIST& aNetlist, const wxString& aAnnotateMessage )
2679{
2680 int standalone = TestStandalone();
2681
2682 if( standalone == 0 )
2683 {
2684 DisplayErrorMessage( this, _( "Cannot update the PCB because PCB editor is opened in stand-alone mode. "
2685 "In order to create or update PCBs from schematics, you must launch the "
2686 "KiCad project manager and create a project." ) );
2687 return false; // Not in standalone mode
2688 }
2689
2690 if( standalone < 0 ) // Problem with Eeschema or the schematic
2691 return false;
2692
2693 Raise(); // Show
2694
2695 std::string payload( aAnnotateMessage );
2696
2697 Kiway().ExpressMail( FRAME_SCH, MAIL_SCH_GET_NETLIST, payload, this );
2698
2699 // Sentinel reply means the user explicitly aborted; silently cancel and return focus to
2700 // the schematic rather than re-showing the annotation error
2701 if( payload == MAIL_SCH_GET_NETLIST_CANCELLED )
2702 {
2703 if( KIWAY_PLAYER* schFrame = Kiway().Player( FRAME_SCH, false ) )
2704 {
2705 if( schFrame->IsIconized() )
2706 schFrame->Iconize( false );
2707
2708 schFrame->Raise();
2709
2710 // Raising the window does not set the focus on Linux. This should work on
2711 // any platform.
2712 if( wxWindow::FindFocus() != schFrame )
2713 schFrame->SetFocus();
2714 }
2715
2716 return false;
2717 }
2718
2719 if( payload == aAnnotateMessage )
2720 {
2721 Raise();
2722 DisplayErrorMessage( this, aAnnotateMessage );
2723 return false;
2724 }
2725
2726 try
2727 {
2728 STRING_LINE_READER* lineReader = new STRING_LINE_READER( payload, _( "Eeschema netlist" ) );
2729 KICAD_NETLIST_READER netlistReader( lineReader, &aNetlist );
2730 netlistReader.LoadNetlist();
2731 }
2732 catch( const IO_ERROR& e )
2733 {
2734 Raise();
2735
2736 // Do not translate extra_info strings. These are for developers
2737 wxString extra_info = e.Problem() + wxT( " : " ) + e.What() + wxT( " at " ) + e.Where();
2738
2739 DisplayErrorMessage( this, _( "Received an error while reading netlist. Please report this issue to "
2740 "the KiCad team using the menu Help->Report Bug." ),
2741 extra_info );
2742 return false;
2743 }
2744
2745 return true;
2746}
2747
2748
2750{
2751 if( aFootprint == nullptr )
2752 return;
2753
2755
2756 /*
2757 * Make sure dlg is destroyed before GetCanvas->Refresh is called
2758 * later or the refresh will try to modify its properties since
2759 * they share a GL context.
2760 */
2761 {
2762 DIALOG_FOOTPRINT_PROPERTIES dlg( this, aFootprint );
2763
2764 dlg.ShowQuasiModal();
2765 retvalue = dlg.GetReturnValue();
2766 }
2767
2768 /*
2769 * retvalue =
2770 * FP_PROPS_UPDATE_FP to show Update Footprints dialog
2771 * FP_PROPS_CHANGE_FP to show Change Footprints dialog
2772 * FP_PROPS_OK for normal edit
2773 * FP_PROPS_CANCEL if aborted
2774 * FP_PROPS_EDIT_BOARD_FP to load board footprint into Footprint Editor
2775 * FP_PROPS_EDIT_LIBRARY_FP to load library footprint into Footprint Editor
2776 */
2777
2779 {
2780 // If something edited, push a refresh request
2781 GetCanvas()->Refresh();
2782 }
2784 {
2785 if( KIWAY_PLAYER* frame = Kiway().Player( FRAME_FOOTPRINT_EDITOR, true ) )
2786 {
2787 FOOTPRINT_EDIT_FRAME* fp_editor = static_cast<FOOTPRINT_EDIT_FRAME*>( frame );
2788
2789 fp_editor->LoadFootprintFromBoard( aFootprint );
2790 fp_editor->Show( true );
2791 fp_editor->Raise(); // Iconize( false );
2792 }
2793 }
2795 {
2796 if( KIWAY_PLAYER* frame = Kiway().Player( FRAME_FOOTPRINT_EDITOR, true ) )
2797 {
2798 FOOTPRINT_EDIT_FRAME* fp_editor = static_cast<FOOTPRINT_EDIT_FRAME*>( frame );
2799
2800 fp_editor->LoadFootprintFromLibrary( aFootprint->GetFPID() );
2801 fp_editor->Show( true );
2802 fp_editor->Raise(); // Iconize( false );
2803 }
2804 }
2806 {
2807 ShowExchangeFootprintsDialog( aFootprint, true, true );
2808 }
2810 {
2811 ShowExchangeFootprintsDialog( aFootprint, false, true );
2812 }
2813}
2814
2815
2817 bool aSelectedMode )
2818{
2819 DIALOG_EXCHANGE_FOOTPRINTS dialog( this, aFootprint, aUpdateMode, aSelectedMode );
2820
2821 return dialog.ShowQuasiModal();
2822}
2823
2824
2826{
2828 m_appearancePanel->CommonSettingsChanged( aFlags );
2829
2831
2833
2834 SetElementVisibility( LAYER_RATSNEST, GetPcbNewSettings()->m_Display.m_ShowGlobalRatsnest );
2835
2837
2838 // Netclass definitions could have changed, either by us or by Eeschema, so we need to
2839 // recompile the implicit rules
2840 DRC_TOOL* drcTool = m_toolManager->GetTool<DRC_TOOL>();
2841 WX_INFOBAR* infobar = GetInfoBar();
2842
2843 try
2844 {
2845 drcTool->GetDRCEngine()->InitEngine( GetBoard()->GetDesignRulesPath() );
2846
2847 if( infobar->GetMessageType() == WX_INFOBAR::MESSAGE_TYPE::DRC_RULES_ERROR )
2848 infobar->Dismiss();
2849 }
2850 catch( PARSE_ERROR& )
2851 {
2852 infobar->RemoveAllButtons();
2853 infobar->AddLink( _( "Edit design rules" ),
2854 [&]( wxHyperlinkEvent& aEvent )
2855 {
2856 ShowBoardSetupDialog( _( "Custom Rules" ) );
2857 } );
2858 infobar->AddCloseButton();
2859 infobar->ShowMessage( _( "Could not compile custom design rules." ), wxICON_ERROR,
2860 WX_INFOBAR::MESSAGE_TYPE::DRC_RULES_ERROR );
2861 }
2862
2865
2866 Layout();
2867 SendSizeEvent();
2868}
2869
2870
2875
2876
2878{
2879 // Register autosave history saver for the board.
2880 // Saver serializes the in-memory BOARD into HISTORY_FILE_DATA. Prettify and
2881 // file I/O happen on a background thread to avoid blocking the UI.
2882 if( GetBoard() )
2883 {
2885 GetBoard(),
2886 [this]( const wxString& aProjectPath, std::vector<HISTORY_FILE_DATA>& aFileData )
2887 {
2888 // See SCHEMATIC::SaveToHistory: the dirty check is only valid in ZIP
2889 // mode. In INCREMENTAL mode the manual-save flow clears the dirty
2890 // flag before the saver runs, so filtering would drop the snapshot.
2891 bool filterClean = !Pgm().GetCommonSettings()->AutosaveUsesLocalHistory();
2892
2893 if( filterClean && !IsContentModified() )
2894 return;
2895
2896 GetBoard()->SaveToHistory( aProjectPath, aFileData );
2897 },
2899 }
2900}
2901
2902
2904{
2906
2907 if( !mgr )
2908 return false;
2909
2910 TOOL_BASE* currentTool = mgr->GetCurrentTool();
2911
2912 // When a single item that can be point-edited is selected, the point editor
2913 // tool will be active instead of the selection tool. It blocks undo/redo
2914 // while the user is actually dragging points around, though, so we can use
2915 // this as an initial check.
2916 if( UndoRedoBlocked() )
2917 return true;
2918
2919 // A tool other than passive selection or point editing is actively modifying
2920 // the model (drawing, dragging, routing, etc.).
2921 if( currentTool != mgr->GetTool<PCB_SELECTION_TOOL>()
2922 && currentTool != mgr->GetTool<PCB_POINT_EDITOR>() )
2923 {
2924 return true;
2925 }
2926
2927 if( ZONE_FILLER_TOOL* zoneFillerTool = mgr->GetTool<ZONE_FILLER_TOOL>();
2928 zoneFillerTool && zoneFillerTool->IsBusy() )
2929 {
2930 return true;
2931 }
2932
2933 if( ROUTER_TOOL* routerTool = mgr->GetTool<ROUTER_TOOL>();
2934 routerTool && routerTool->RoutingInProgress() )
2935 {
2936 return true;
2937 }
2938
2939 return false;
2940}
2941
2942
2944{
2946 return false;
2947
2949}
2950
2951
2953{
2954 // Serializing a large board on the UI thread freezes the editor; never do it while the
2955 // user is mid-operation or the deferred input gets misinterpreted (e.g. a routed track
2956 // ending where the cursor lands once the editor unfreezes).
2958}
2959
2960
2966
2967
2968bool PCB_EDIT_FRAME::GetPluginActionButtonVisible( const wxString& aPluginPath, bool aPluginDefault )
2969{
2970 if( PCBNEW_SETTINGS* cfg = GetAppSettings<PCBNEW_SETTINGS>( "pcbnew" ) )
2971 {
2972 for( const auto& [identifier, visible] : cfg->m_Plugins.actions )
2973 {
2974 if( identifier == aPluginPath )
2975 return visible;
2976 }
2977 }
2978
2979 // Plugin is not in settings, return default.
2980 return aPluginDefault;
2981}
2982
2983
2985{
2986 return GetBoard()->GetFileName();
2987}
2988
2989
2991{
2992 return m_auimgr.GetPane( wxS( "LayersManager" ) ).IsShown();
2993}
2994
2995
2997{
2998 return m_auimgr.GetPane( PropertiesPaneName() ).IsShown();
2999}
3000
3001
3003{
3004 return m_auimgr.GetPane( NetInspectorPanelName() ).IsShown();
3005}
3006
3007
3018
3019
3030
3031
3042
3043
3045{
3046 if( !m_footprintDiffDlg )
3047 {
3049 _( "Compare Footprint with Library" ) );
3050
3051 m_footprintDiffDlg->m_sdbSizerApply->SetLabel( _( "Update Footprint from Library..." ) );
3052 m_footprintDiffDlg->m_sdbSizerApply->PostSizeEventToParent();
3053 m_footprintDiffDlg->m_sdbSizerApply->Show();
3054 }
3055
3056 return m_footprintDiffDlg;
3057}
3058
3059
3061{
3063 {
3064 auto* dlg = new DIALOG_FOOTPRINT_FIELDS_TABLE( this );
3065
3066 if( dlg->WasAborted() )
3067 {
3068 dlg->Destroy();
3069 return nullptr;
3070 }
3071
3073 }
3074
3076}
3077
3078
3080{
3081 if( m_inspectDrcErrorDlg && aEvent.GetString() == INSPECT_DRC_ERROR_DIALOG_NAME )
3082 {
3083 m_inspectDrcErrorDlg->Destroy();
3084 m_inspectDrcErrorDlg = nullptr;
3085 }
3086 else if( m_inspectClearanceDlg && aEvent.GetString() == INSPECT_CLEARANCE_DIALOG_NAME )
3087 {
3088 m_inspectClearanceDlg->Destroy();
3089 m_inspectClearanceDlg = nullptr;
3090 }
3091 else if( m_inspectConstraintsDlg && aEvent.GetString() == INSPECT_CONSTRAINTS_DIALOG_NAME )
3092 {
3093 m_inspectConstraintsDlg->Destroy();
3094 m_inspectConstraintsDlg = nullptr;
3095 }
3096 else if( m_footprintDiffDlg && aEvent.GetString() == FOOTPRINT_DIFF_DIALOG_NAME )
3097 {
3098 if( aEvent.GetId() == wxID_APPLY )
3099 {
3100 KIID fpUUID = m_footprintDiffDlg->GetUserItemID();
3101
3102 CallAfter(
3103 [this, fpUUID]()
3104 {
3105 BOARD_ITEM* item = m_pcb->ResolveItem( fpUUID );
3106
3107 if( FOOTPRINT* footprint = dynamic_cast<FOOTPRINT*>( item ) )
3108 {
3109 m_toolManager->RunAction<EDA_ITEM*>( ACTIONS::selectItem, footprint );
3110
3111 DIALOG_EXCHANGE_FOOTPRINTS dialog( this, footprint, true, true );
3112 dialog.ShowQuasiModal();
3113 }
3114 } );
3115 }
3116
3117 m_footprintDiffDlg->Destroy();
3118 m_footprintDiffDlg = nullptr;
3119 }
3120}
3121
3122
3124{
3126 return true;
3127
3129
3130 if( !dlg->Close( false ) )
3131 return false;
3132
3133 if( m_footprintFieldsTableDialog == dlg )
3134 {
3135 dlg->Destroy();
3137 }
3138
3139 return true;
3140}
3141
3142
3144{
3146 {
3149 }
3150}
3151
3152
3154{
3155 wxLogTrace( traceApi, "PCB frame: EDA_EVT_PLUGIN_AVAILABILITY_CHANGED" );
3158 aEvt.Skip();
3159}
3160
3161
3163{
3164 PCB_LAYER_ID curLayer = GetActiveLayer();
3165 const PCB_DISPLAY_OPTIONS& displ_opts = GetDisplayOptions();
3166
3167 // Check if the specified layer matches the present layer
3168 if( layer == curLayer )
3169 return;
3170
3171 // Copper layers cannot be selected unconditionally; how many of those layers are currently
3172 // enabled needs to be checked.
3173 if( IsCopperLayer( layer ) )
3174 {
3175 if( layer > GetBoard()->GetCopperLayerStackMaxId() )
3176 return;
3177 }
3178
3179 // Is yet more checking required? E.g. when the layer to be selected is a non-copper layer,
3180 // or when switching between a copper layer and a non-copper layer, or vice-versa?
3181
3182 SetActiveLayer( layer );
3183
3185 GetCanvas()->Refresh();
3186}
3187
3188
3190{
3191 switch( aItem->Type() )
3192 {
3195 break;
3196
3197 case PCB_BARCODE_T:
3198 ShowBarcodePropertiesDialog( static_cast<PCB_BARCODE*>( aItem ) );
3199 break;
3200
3201 case PCB_FIELD_T:
3202 case PCB_TEXT_T:
3203 ShowTextPropertiesDialog( static_cast<PCB_TEXT*>( aItem ) );
3204 break;
3205
3206 case PCB_TEXTBOX_T:
3207 ShowTextBoxPropertiesDialog( static_cast<PCB_TEXTBOX*>( aItem ) );
3208 break;
3209
3210 case PCB_TABLE_T:
3211 {
3212 DIALOG_TABLE_PROPERTIES dlg( this, static_cast<PCB_TABLE*>( aItem ) );
3213
3214 //QuasiModal required for Scintilla auto-complete
3215 dlg.ShowQuasiModal();
3216 break;
3217 }
3218
3219 case PCB_DRILL_CHART_T:
3220 {
3221 // Not the generic table dialog, which would offer copper layers and direct editing of
3222 // cells that the next rebuild discards
3223 DIALOG_GENERATED_TABLE_PROPERTIES dlg( this, static_cast<PCB_DRILL_CHART*>( aItem ),
3224 []( wxWindow* aParent )
3225 {
3226 return new PANEL_DRILL_CHART_OPTIONS( aParent );
3227 } );
3228 dlg.ShowModal();
3229 break;
3230 }
3231
3233 {
3234 DIALOG_GENERATED_TABLE_PROPERTIES dlg( this, static_cast<PCB_GENERATED_TABLE*>( aItem ), {} );
3235 dlg.ShowModal();
3236 break;
3237 }
3238
3239 case PCB_PAD_T:
3240 ShowPadPropertiesDialog( static_cast<PAD&>( *aItem ) );
3241 break;
3242
3243 case PCB_FOOTPRINT_T:
3244 ShowFootprintPropertiesDialog( static_cast<FOOTPRINT*>( aItem ) );
3245 break;
3246
3247 case PCB_TARGET_T:
3248 ShowTargetOptionsDialog( static_cast<PCB_TARGET*>( aItem ) );
3249 break;
3250
3251 case PCB_DIM_ALIGNED_T:
3252 case PCB_DIM_CENTER_T:
3253 case PCB_DIM_RADIAL_T:
3255 case PCB_DIM_LEADER_T:
3256 {
3257 DIALOG_DIMENSION_PROPERTIES dlg( this, static_cast<PCB_DIMENSION_BASE*>( aItem ) );
3258
3259 dlg.ShowModal();
3260 break;
3261 }
3262
3263 case PCB_SHAPE_T:
3264 ShowGraphicItemPropertiesDialog( static_cast<PCB_SHAPE*>( aItem ) );
3265 break;
3266
3267 case PCB_GRID_ITEM_T:
3268 ShowGridItemPropertiesDialog( static_cast<PCB_GRID_ITEM*>( aItem ) );
3269 break;
3270
3271 case PCB_ZONE_T:
3272 Edit_Zone_Params( static_cast<ZONE*>( aItem ) );
3273 break;
3274
3275 case PCB_GROUP_T:
3277 static_cast<EDA_GROUP*>( static_cast<PCB_GROUP*>( aItem ) ) );
3278 break;
3279
3280 case PCB_GENERATOR_T:
3281 static_cast<PCB_GENERATOR*>( aItem )->ShowPropertiesDialog( this );
3282 break;
3283
3284 case PCB_MARKER_T:
3285 m_toolManager->GetTool<DRC_TOOL>()->CrossProbe( static_cast<PCB_MARKER*>( aItem ) );
3286 break;
3287
3288 case PCB_POINT_T:
3289 break;
3290
3291 default:
3292 break;
3293 }
3294}
3295
3296
3298{
3299 // For now we just delegate to the base implementation which commits any pending
3300 // local history snapshots. If PCB-specific preconditions are later needed (e.g.
3301 // flushing zone fills or router state) they can be added here before calling the
3302 // base class method.
3304}
const KICOMMON_API wxEventTypeTag< wxCommandEvent > EDA_EVT_PLUGIN_AVAILABILITY_CHANGED
Notifies other parts of KiCad when plugin availability changes.
@ 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:128
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:100
@ NORMAL
Inactive layers are shown normally (no high-contrast mode)
constexpr BOX2I BOX2ISafe(const BOX2D &aInput)
Definition box2.h:924
BOX2< VECTOR2I > BOX2I
Definition box2.h:917
BOX2< VECTOR2D > BOX2D
Definition box2.h:918
static TOOL_ACTION toggleGrid
Definition actions.h:194
static TOOL_ACTION paste
Definition actions.h:76
static TOOL_ACTION unselectAll
Definition actions.h:79
static TOOL_ACTION selectItem
Select an item (specified as the event parameter).
Definition actions.h:223
static TOOL_ACTION togglePolarCoords
Definition actions.h:205
static TOOL_ACTION copy
Definition actions.h:74
static TOOL_ACTION pluginsReload
Definition actions.h:294
static TOOL_ACTION selectSetLasso
Definition actions.h:217
static TOOL_ACTION selectSetRect
Set lasso selection mode.
Definition actions.h:216
static TOOL_ACTION group
Definition actions.h:235
static TOOL_ACTION pasteSpecial
Definition actions.h:77
static TOOL_ACTION groupProperties
Definition actions.h:243
static TOOL_ACTION pointEditorArcKeepCenter
Definition actions.h:273
static TOOL_ACTION ungroup
Definition actions.h:236
static TOOL_ACTION toggleBoundingBoxes
Definition actions.h:153
static TOOL_ACTION pointEditorArcKeepRadius
Definition actions.h:275
static TOOL_ACTION showSearch
Definition actions.h:112
static TOOL_ACTION undo
Definition actions.h:71
static TOOL_ACTION duplicate
Definition actions.h:80
static TOOL_ACTION showGitCommitPane
Definition actions.h:263
static TOOL_ACTION highContrastMode
Definition actions.h:151
static TOOL_ACTION embeddedFiles
Definition actions.h:298
static TOOL_ACTION measureTool
Definition actions.h:248
static TOOL_ACTION doDelete
Definition actions.h:81
static TOOL_ACTION selectionTool
Definition actions.h:247
static TOOL_ACTION save
Definition actions.h:54
static TOOL_ACTION zoomFitScreen
Definition actions.h:138
static TOOL_ACTION redo
Definition actions.h:72
static TOOL_ACTION deleteTool
Definition actions.h:82
static TOOL_ACTION zoomTool
Definition actions.h:142
static TOOL_ACTION showProperties
Definition actions.h:262
static TOOL_ACTION cut
Definition actions.h:73
static TOOL_ACTION gridSetOrigin
Definition actions.h:191
static TOOL_ACTION toggleGridOverrides
Definition actions.h:195
static TOOL_ACTION selectAll
Definition actions.h:78
static TOOL_ACTION pointEditorArcKeepEndpoint
Definition actions.h:274
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...
static const ADVANCED_CFG & GetCfg()
Get the singleton instance's config, which is shared by all consumers.
void OnColorThemeChanged()
Update the colors on all the widgets from the new chosen color theme.
APP_SETTINGS_BASE is a settings class that should be derived for each standalone KiCad application.
The array tool.
Definition array_tool.h:44
Tool responsible for automagic placement of footprints.
Handles how to draw a screen (a board, a schematic ...)
Definition base_screen.h:37
int GetPageCount() const
Definition base_screen.h:68
bool IsContentModified() const
Definition base_screen.h:56
const wxString & GetPageNumber() const
void Push(const wxString &aMessage=wxEmptyString, int aCommitFlags=0) override
Execute the changes.
A base class derived from BOARD_ITEM for items that can be connected and have a net,...
Handle actions specific to the board editor in PcbNew.
Tool for pcb inspection.
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:98
Bridges BOARD's listener stream into the generic TEXT_VAR_TRACKER.
Information pertinent to a Pcbnew printed circuit board.
Definition board.h:411
void BuildListOfNets()
Definition board.h:1180
bool IsElementVisible(GAL_LAYER_ID aLayer) const
Test whether a given element category is visible.
Definition board.cpp:1241
void RemoveAllListeners()
Remove all listeners.
Definition board.cpp:3849
void AddListener(BOARD_LISTENER *aListener)
Add a listener to the board to receive calls whenever something on the board has been modified.
Definition board.cpp:3830
const PAGE_INFO & GetPageSettings() const
Definition board.h:1020
GAL_SET GetVisibleElements() const
Return a set of all the element categories that are visible.
Definition board.cpp:1235
void InitializeClearanceCache()
Initialize the clearance cache for all board items.
Definition board.cpp:1318
void SaveToHistory(const wxString &aProjectPath, std::vector< HISTORY_FILE_DATA > &aFileData)
Serialize board into HISTORY_FILE_DATA for non-blocking history commit.
Definition board.cpp:4367
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:369
void SynchronizeNetsAndNetClasses(bool aResetTrackAndViaSizes)
Copy NETCLASS info to each NET, based on NET membership in a NETCLASS.
Definition board.cpp:3240
std::weak_ptr< void > GetHistoryLifetimeToken() const
Liveness token handed to LOCAL_HISTORY::RegisterSaver so a shared autosave timer skips this board's s...
Definition board.h:1718
void SetProject(PROJECT *aProject, bool aReferenceOnly=false)
Link a board to a given project.
Definition board.cpp:379
const wxString & GetFileName() const
Definition board.h:454
void SetElementVisibility(GAL_LAYER_ID aLayer, bool aNewState)
Change the visibility of an element category.
Definition board.cpp:1247
void ClearProject()
Definition board.cpp:420
bool IsEmpty() const
Definition board.cpp:798
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.
Definition board.cpp:2614
const LSET & GetEnabledLayers() const
A proxy function that calls the corresponding function in m_BoardSettings.
Definition board.cpp:1174
void UpdateRatsnestExclusions()
Update the visibility flags on the current unconnected ratsnest lines.
Definition board.cpp:538
void SynchronizeTuningProfileProperties()
Ensure that all time domain properties providers are in sync with current settings.
Definition board.cpp:3194
std::shared_ptr< CONNECTIVITY_DATA > GetConnectivity() const
Return a list of missing connections between components/tracks.
Definition board.h:758
constexpr BOX2< Vec > & Inflate(coord_type dx, coord_type dy)
Inflates the rectangle horizontally by dx and vertically by dy.
Definition box2.h:556
void SetColor(int aLayer, const COLOR4D &aColor)
COLOR4D GetColor(int aLayer) const
COMMIT & Add(EDA_ITEM *aItem, BASE_SCREEN *aScreen=nullptr)
Add a new item to the model.
Definition commit.h:74
Handle actions that are shared between different applications.
bool AutosaveUsesLocalHistory() const
The backup format is the single switch that selects the autosave mechanism: the incremental format re...
Handles action that are shared between different applications.
Interactive authoring of geometric constraints (issue #2329).
enum FP_PROPS_RETVALUE GetReturnValue()
Dialog that offers to migrate obsolete WRL 3D model references on a loaded board to current STEP mode...
static int AutoMigrateByFilename(PCB_EDIT_FRAME *aFrame)
Silently rewrite unresolvable .wrl/.wrz references to STEP files whose filename stem matches in the s...
static int CountUnresolvedWrlReferences(PCB_EDIT_FRAME *aFrame)
Count of unique unresolvable .wrl/.wrz references on the board (deduplicated by filename).
int ShowModal() override
Tool responsible for displaying an overlay of incremental phase difference between differential pair ...
Tool responsible for drawing graphical elements like lines, arcs, circles, etc.
MODE GetDrawingMode() const
Return the current drawing mode of the DRAWING_TOOL or NONE if not currently in any drawing mode.
void InitEngine(const wxFileName &aRulePath)
Initialize the DRC engine.
std::shared_ptr< DRC_ENGINE > GetDRCEngine()
Definition drc_tool.h:86
bool IsDRCRunning() const
Check to see if the DRC engine is running the tests.
Definition drc_tool.h:73
void SetSheetPath(const std::string &aSheetPath)
Set the sheet path displayed in the title block.
void SetSheetCount(int aSheetCount)
Change the sheet-count number displayed in the title block.
void SetVariantName(const std::string &aVariant)
Set the current variant name and description to be shown on the drawing sheet.
void SetVariantDesc(const std::string &aVariantDesc)
void SetPageNumber(const std::string &aPageNumber)
Change the page number displayed in the title block.
void SetSheetName(const std::string &aSheetName)
Set the sheet name displayed in the title block.
void SetIsFirstPage(bool aIsFirstPage)
Change if this is first page.
void AttachToTracker(TEXT_VAR_TRACKER *aTracker)
Register this proxy with aTracker as a dependent on every title-block source variable its current tem...
void SetFileName(const std::string &aFileName)
Set the file name displayed in the title block.
virtual bool doAutoSave()
This should be overridden by the derived class to handle the auto save feature.
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.
static const wxString GitCommitPaneName()
Named here rather than beside the editors' other panes, because the project manager docks this one to...
virtual void setupUIConditions()
Setup the UI conditions for the various actions and their controls in this frame.
virtual void ThemeChanged()
Process light/dark theme change.
WX_INFOBAR * m_infoBar
wxAuiManager m_auimgr
virtual bool CanAcceptApiCommands()
Check if this frame is ready to accept API commands.
virtual void RecreateToolbars()
virtual void OnSize(wxSizeEvent &aEvent)
virtual bool canCloseWindow(wxCloseEvent &aCloseEvent)
virtual int GetUndoCommandCount() const
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()
static std::vector< const PLUGIN_ACTION * > GetOrderedPluginActions(PLUGIN_ACTION_SCOPE aScope, APP_SETTINGS_BASE *aCfg)
Return ordered list of plugin actions for display in the toolbar.
static const wxString AppearancePanelName()
virtual wxString GetFullScreenDesc() const
void OnSelectGrid(wxCommandEvent &event)
Command event handler for selecting grid sizes.
void SetMsgPanel(const std::vector< MSG_PANEL_ITEM > &aList)
Clear the message panel and populates it with the contents of aList.
void setArcModeConditions(const TOOL_ACTION &aDrawArc, const std::function< bool(const SELECTION &)> &aEnable)
Check each arc mode's tool action while the arc tool runs in that mode.
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.
virtual wxString GetScreenDesc() const
static const wxString PropertiesPaneName()
virtual void Zoom_Automatique(bool aWarpPointer)
Redraw the screen with best zoom level and the best centering that shows all the page or the board.
NET_INSPECTOR_PANEL * m_netInspectorPanel
static const wxString NetInspectorPanelName()
SEARCH_PANE * m_searchPane
static const wxString DesignBlocksPaneName()
PROPERTIES_PANEL * m_propertiesPanel
virtual void UpdateProperties()
void StopDrawing()
Prevent the GAL canvas from further drawing until it is recreated or StartDrawing() is called.
void ForceRefresh()
Force a redraw.
virtual void Refresh(bool aEraseBackground=true, const wxRect *aRect=nullptr) override
@ GAL_TYPE_MODERN
RHI implementation, Vulkan or Metal on macOS.
KIGFX::GAL * GetGAL() const
Return a pointer to the GAL instance used in the panel.
void SetFocus() override
void RequestRefresh()
Make sure a refresh gets done on the next idle event if it hasn't already.
A base class for most all the KiCad significant classes used in schematics and boards.
Definition eda_item.h:98
KICAD_T Type() const
Returns the type of object.
Definition eda_item.h:110
Specialization of the wxAuiPaneInfo class for KiCad panels.
A mix-in class (via multiple inheritance) that handles texts such as labels, parts,...
Definition eda_text.h:94
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.
SELECTION_CONDITION GridVisible()
Create a functor testing if the grid is visible in a frame.
SELECTION_CONDITION PolarCoordinates()
Create a functor testing if polar coordinates are current being used.
SELECTION_CONDITION GridOverrides()
Create a functor testing if the grid overrides wires is enabled in a frame.
The interactive edit tool.
Definition edit_tool.h:54
ENUM_MAP & Map(T aValue, const wxString &aName)
Definition property.h:817
static ENUM_MAP< T > & Instance()
Definition property.h:811
ENUM_MAP & Undefined(T aValue)
Definition property.h:824
wxPGChoices & Choices()
Definition property.h:862
void LoadFootprintFromLibrary(LIB_ID aFPID)
bool HandleUnsavedChanges(bool aFromBoardOnly)
Prompt to save each dirty tab that meets the requirements.
bool LoadFootprintFromBoard(FOOTPRINT *aFootprint)
Load a footprint from the main board into the Footprint Editor.
Component library viewer main window.
const LIB_ID & GetFPID() const
Definition footprint.h:417
void ReadWindowSettings(WINDOW_SETTINGS &aCfg)
Read GAL config options from application-level config.
bool Contains(GAL_LAYER_ID aPos)
Definition layer_ids.h:468
Handle actions specific to filling copper zones.
Docked panel for committing: the branch to commit to, a summary and description, the commit options,...
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()
virtual const wxString Problem() const
what was the problem?
virtual const wxString Where() const
where did the Problem() occur?
void RegisterHandler(API_HANDLER *aHandler)
Adds a new request handler to the server.
void DeregisterHandler(API_HANDLER *aHandler)
Read the new s-expression based KiCad netlist format.
virtual void LoadNetlist() override
Load the contents of the netlist file into aNetlist.
APP_SETTINGS_BASE * KifaceSettings() const
Definition kiface_base.h:92
A color representation with 4 components: red, green, blue, alpha.
Definition color4d.h:101
void SetGridColor(const COLOR4D &aGridColor)
Set the grid color.
virtual bool HasRetainedScene() const
Return true if the backend keeps cached groups in a persistent scene that it patches in place,...
Contains all the knowledge about how to draw graphical object onto any particular output device.
Definition painter.h:55
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:87
Container for all the knowledge about how graphical objects are drawn on any output surface/device.
An abstract base class for deriving all objects that can be added to a VIEW.
Definition view_item.h:82
bool IsBOARD_ITEM() const
Definition view_item.h:98
Hold a (potentially large) number of VIEW_ITEMs and renders them on a graphics device provided by the...
Definition view.h:68
double GetScale() const
Definition view.h:298
BOX2D GetViewport() const
Return the current viewport visible area rectangle.
Definition view.cpp:861
virtual void Update(const VIEW_ITEM *aItem, int aUpdateFlags) const
For dynamic VIEWs, inform the associated VIEW that the graphical representation of this item has chan...
Definition view.cpp:2631
void SetLayerVisible(int aLayer, bool aVisible=true)
Control the visibility of a particular layer.
Definition view.h:431
GAL * GetGAL() const
Return the GAL this view is using to draw graphical primitives.
Definition view.h:224
void SyncLayerVisibilityCache()
Definition view.cpp:2761
void RepaintLayers(const BOX2I &aRect, const std::function< bool(int)> &aLayerFilter, const std::function< bool(VIEW_ITEM *, int)> &aItemFilter)
Re-cache only some layers of the items in aRect.
Definition view.cpp:2656
void MarkTargetDirty(int aTarget)
Set or clear target 'dirty' flag.
Definition view.h:729
void UpdateAllItemsConditionally(int aUpdateFlags, std::function< bool(VIEW_ITEM *)> aCondition)
Update items in the view according to the given flags and condition.
Definition view.cpp:2492
An implementation of class VIEW_CONTROLS for wxWidgets library.
std::unique_ptr< PROF_COUNTER > m_MotionEventCounter
Definition kiid.h:46
A wxFrame capable of the OpenProjectFiles function, meaning it can load a portion of a KiCad project.
virtual bool OpenProjectFiles(const std::vector< wxString > &aFileList, int aCtl=0)
Open a project or set of files given by aFileList.
void OnSockRequestServer(wxSocketEvent &evt)
void OnSockRequest(wxSocketEvent &evt)
bool IsModal() const override
Return true if the frame is shown in our modal mode and false if the frame is shown as an usual frame...
A minimalistic software bus for communications between various DLLs/DSOs (DSOs) within the same KiCad...
Definition kiway.h:348
void OnKiCadExit()
Definition kiway.cpp:803
virtual KIWAY_PLAYER * Player(FRAME_T aFrameType, bool doCreate=true, wxTopLevelWindow *aParent=nullptr)
Return the KIWAY_PLAYER* given a FRAME_T.
Definition kiway.cpp:401
virtual void ExpressMail(FRAME_T aDestination, MAIL_T aCommand, std::string &aPayload, wxWindow *aSource=nullptr, bool aFromOtherThread=false)
Send aPayload to aDestination from aSource.
Definition kiway.cpp:499
LOCAL_HISTORY & LocalHistory()
Return the LOCAL_HISTORY associated with this KIWAY.
Definition kiway.h:457
virtual void CommonSettingsChanged(int aFlags=0)
Call CommonSettingsChanged() on all KIWAY_PLAYERs.
Definition kiway.cpp:593
PCB_LAYER_ID GetLayerA() const
PCB_LAYER_ID GetLayerB() const
bool CommitDuplicateOfLastSave(const wxString &aProjectPath, const wxString &aFileType, const wxString &aMessage)
Create a new commit duplicating the tree pointed to by Last_Save_<fileType> and move the Last_Save_<f...
void NoteFileChange(const wxString &aFile)
Record that a file has been modified and should be included in the next snapshot.
void RegisterSaver(const void *aSaverObject, const std::function< void(const wxString &, std::vector< HISTORY_FILE_DATA > &)> &aSaver, const std::weak_ptr< void > &aLifetime={})
Register a saver callback invoked during autosave history commits.
void UnregisterSaver(const void *aSaverObject)
Unregister a previously registered saver callback.
void RemoveAutosaveFiles(const wxString &aProjectPath) const
Remove every autosave file under the project at aProjectPath regardless of which source it shadowed.
LSET is a set of PCB_LAYER_IDs.
Definition lset.h:37
LSEQ Seq(const LSEQ &aSequence) const
Return an LSEQ from the union of this LSET and a desired sequence.
Definition lset.cpp:309
static const LSET & AllLayersMask()
Definition lset.cpp:637
static wxString Name(PCB_LAYER_ID aLayerId)
Return the fixed name association with aLayerId.
Definition lset.cpp:184
@ MARKER_DRAWING_SHEET
Definition marker_base.h:51
Tool responsible for adding microwave features to PCBs.
Store information read from a netlist along with the flags used to update the NETLIST in the BOARD.
Definition pad.h:61
void SetInitialPage(const wxString &aPage, const wxString &aParentPage=wxEmptyString)
Describe the page size and margins of a paper page on which to eventually print or plot.
Definition page_info.h:75
Dockable panel listing the board's geometric constraints (issue #2329).
DISPLAY_OPTIONS m_Display
EDA_ANGLE m_RotationAngle
ARC_EDIT_MODE m_ArcEditMode
AUI_PANELS m_AuiPanels
Gather all the actions that are shared by tools.
Definition pcb_actions.h:51
static TOOL_ACTION showConstraintsPanel
Toggle the docked constraints pane (board editor).
static TOOL_ACTION drawRuleArea
static TOOL_ACTION microwaveCreateGap
static TOOL_ACTION drawBezier
static TOOL_ACTION placeText
static TOOL_ACTION drawOrthogonalDimension
static TOOL_ACTION drawRectangle
static TOOL_ACTION padDisplayMode
static TOOL_ACTION placeReferenceImage
static TOOL_ACTION showRatsnest
static TOOL_ACTION showLayersManager
static TOOL_ACTION toggleNetHighlight
static TOOL_ACTION addConstraintVertical
static TOOL_ACTION saveSelectionAsDesignBlock
static TOOL_ACTION drawCircle
static TOOL_ACTION mirrorH
Mirroring of selected items.
static TOOL_ACTION routeDiffPair
Activation of the Push and Shove router (differential pair mode)
static TOOL_ACTION tuneDiffPair
static TOOL_ACTION saveToLinkedDesignBlock
static TOOL_ACTION layerChanged
static TOOL_ACTION grabUnconnected
Select and move nearest unconnected footprint from ratsnest of selection.
Definition pcb_actions.h:94
static TOOL_ACTION ddAppendBoard
Drag and drop.
static TOOL_ACTION drawEllipseArc
static TOOL_ACTION highlightNet
static TOOL_ACTION autoTrackWidth
static TOOL_ACTION drawTable
static TOOL_ACTION drawTextBox
static TOOL_ACTION addConstraintPerpendicular
static TOOL_ACTION routerHighlightMode
Actions to enable switching modes via hotkey assignments.
static TOOL_ACTION routerWalkaroundMode
static TOOL_ACTION routerShoveMode
static TOOL_ACTION drawZoneCutout
static TOOL_ACTION drawPolygon
static TOOL_ACTION hideNetInRatsnest
static TOOL_ACTION zoneDisplayFilled
static TOOL_ACTION showNetInRatsnest
static TOOL_ACTION drawRadialDimension
static TOOL_ACTION tuneSingleTrack
static TOOL_ACTION viaDisplayMode
static TOOL_ACTION drawLeader
static TOOL_ACTION addConstraintAngular
static TOOL_ACTION addConstraintArcAngle
static TOOL_ACTION angleSnapModeChanged
Notification event when angle mode changes.
static TOOL_ACTION saveBoardAsDesignBlock
static TOOL_ACTION drillOrigin
static TOOL_ACTION tuneSkew
static TOOL_ACTION addConstraintHorizontal
static TOOL_ACTION trackDisplayMode
static TOOL_ACTION showNetInspector
static TOOL_ACTION microwaveCreateStubArc
static TOOL_ACTION drawEllipse
static TOOL_ACTION placeSubGrid
Grid Item.
static TOOL_ACTION zoneDisplayTriangulated
static TOOL_ACTION placeDesignBlock
static TOOL_ACTION selectUnconnected
Select unconnected footprints from ratsnest of selection.
Definition pcb_actions.h:91
static TOOL_ACTION zoneDisplayFractured
static TOOL_ACTION addConstraintCollinear
static TOOL_ACTION drawVia
static TOOL_ACTION drawArc
static TOOL_ACTION zoneDuplicate
Duplicate zone onto another layer.
static TOOL_ACTION graphicsOutlines
Display footprint graphics as outlines.
static TOOL_ACTION addConstraintEqualRadius
static TOOL_ACTION addConstraintTangent
static TOOL_ACTION drawSimilarZone
static TOOL_ACTION showDesignBlockPanel
static TOOL_ACTION drawCenterDimension
static TOOL_ACTION mirrorInteractive
static TOOL_ACTION selectSameSheet
Select all components on the same sheet as the selected footprint.
static TOOL_ACTION microwaveCreateStub
static TOOL_ACTION selectNet
Select all connections belonging to a single net.
Definition pcb_actions.h:82
static TOOL_ACTION ddImportGraphics
static TOOL_ACTION microwaveCreateLine
static TOOL_ACTION addConstraintFixedLength
static TOOL_ACTION flipBoard
static TOOL_ACTION zoneDisplayOutline
static TOOL_ACTION ratsnestLineMode
static TOOL_ACTION toggleAutoConstraints
Toggle authoring constraints automatically while drawing.
static TOOL_ACTION textOutlines
Display texts as lines.
static TOOL_ACTION highlightNetSelection
static TOOL_ACTION microwaveCreateFunctionShape
static TOOL_ACTION placePoint
static TOOL_ACTION zoneMerge
static TOOL_ACTION addConstraintSymmetric
static TOOL_ACTION addConstraintFixedPosition
Ground a point, and the cluster holding it.
static TOOL_ACTION mirrorV
static TOOL_ACTION unlock
static TOOL_ACTION addConstraintPointOnLine
static TOOL_ACTION placeFootprint
static TOOL_ACTION routeSingleTrack
Activation of the Push and Shove router.
static TOOL_ACTION ddPlaceReferenceImage
static TOOL_ACTION createArray
Tool for creating an array of objects.
static TOOL_ACTION showDiffPhaseSkew
Display of phase skew between differential pair tracks.
static TOOL_ACTION deselectNet
Remove all connections belonging to a single net from the active selection.
Definition pcb_actions.h:85
static TOOL_ACTION addConstraintCoincident
static TOOL_ACTION drawLine
static TOOL_ACTION placeLinkedDesignBlock
static TOOL_ACTION localRatsnestTool
static TOOL_ACTION placeViaStack
static TOOL_ACTION rotateCw
Rotation of selected objects.
static TOOL_ACTION rotateCcw
static TOOL_ACTION addConstraintParallel
static TOOL_ACTION drawAlignedDimension
static TOOL_ACTION addConstraintFixedRadius
static TOOL_ACTION addConstraintEqualLength
static TOOL_ACTION drawZone
static TOOL_ACTION selectOnSchematic
Select symbols/pins on schematic corresponding to selected footprints/pads.
static TOOL_ACTION addConstraintMidpoint
static TOOL_ACTION lock
static TOOL_ACTION addConstraintConcentric
Common, abstract interface for edit frames.
COLOR_SETTINGS * GetColorSettings(bool aForceRefresh=false) const override
Helper to retrieve the current color settings.
int ShowTextBoxPropertiesDialog(PCB_TEXTBOX *aTextBox)
void unitsChangeRefresh() override
Called when when the units setting has changed to allow for any derived classes to handle refreshing ...
bool UndoRedoBlocked() const
Check if the undo and redo operations are currently blocked.
PCB_LAYER_BOX_SELECTOR * m_SelLayerBox
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.
std::unique_ptr< LAYER_PAIR_SETTINGS > m_layerPairSettings
APPEARANCE_CONTROLS * GetAppearancePanel()
APPEARANCE_CONTROLS * m_appearancePanel
void ShowReferenceImagePropertiesDialog(BOARD_ITEM *aBitmap)
PANEL_SELECTION_FILTER * m_selectionFilterPanel
void ShowBarcodePropertiesDialog(PCB_BARCODE *aText)
void ShowGridItemPropertiesDialog(PCB_GRID_ITEM *aGridItem)
void ShowGraphicItemPropertiesDialog(PCB_SHAPE *aShape)
void ActivateGalCanvas() override
Use to start up the GAL drawing canvas.
Base PCB main window class for Pcbnew, Gerbview, and CvPcb footprint viewer.
void ShowPadPropertiesDialog(PAD &aPad)
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.
PCBNEW_SETTINGS * GetPcbNewSettings() const
virtual void SetActiveLayer(PCB_LAYER_ID aLayer)
void OnModify() override
Must be called after a change in order to set the "modify" flag and update other data structures and ...
virtual MAGNETIC_SETTINGS * GetMagneticItemsSettings()
EDA_ITEM * ResolveItem(const KIID &aId, bool aAllowNullptrReturn=false) const override
Fetch an item by KIID.
PCB_DRAW_PANEL_GAL * GetCanvas() const override
Return a pointer to GAL-based canvas of given EDA draw frame.
virtual PCB_LAYER_ID GetActiveLayer() const
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 BOARD_DESIGN_SETTINGS & GetDesignSettings() const
Return the BOARD_DESIGN_SETTINGS for the open project.
virtual void Update3DView(bool aMarkDirty, bool aRefresh, const wxString *aTitle=nullptr)
Update the 3D view, if the viewer is opened by this frame.
Handle actions that are shared between different frames in PcbNew.
Definition pcb_control.h:47
Handle design block actions in the PCB editor.
bool m_FlipBoardView
true if the board is flipped to show the mirrored view
double m_ZoneOpacity
Opacity override for filled zone areas.
HIGH_CONTRAST_MODE m_ContrastModeDisplay
How inactive layers are displayed.
void ChangeHighContrastLayer(PCB_LAYER_ID aLayer)
Follow an active layer change when nothing else that colours items has changed.
void UpdateColors()
Update the color settings in the painter and GAL.
DS_PROXY_VIEW_ITEM * GetDrawingSheet() const
void SetDrawingSheet(DS_PROXY_VIEW_ITEM *aDrawingSheet)
Set or update drawing-sheet used by the draw panel.
virtual KIGFX::PCB_VIEW * GetView() const override
Return a pointer to the KIGFX::VIEW instance used in the panel.
void SyncLayersVisibility(const BOARD *aBoard)
Update "visibility" property of each layer of a given BOARD.
virtual void SetHighContrastLayer(int aLayer) override
Take care of display settings for the given layer to be displayed in high contrast mode.
void RedrawRatsnest()
Force refresh of the ratsnest visual representation.
Group generic conditions for PCB editor states.
SELECTION_CONDITION PadFillDisplay()
Create a functor that tests if the frame fills the pads.
SELECTION_CONDITION TrackFillDisplay()
Create a functor that tests if the frame fills tracks.
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 ZoneDisplayMode(ZONE_DISPLAY_MODE aMode)
Create a functor that tests the current zone display mode in the frame.
SELECTION_CONDITION ViaFillDisplay()
Create a functor that tests if the frame fills vias.
SELECTION_CONDITION TextFillDisplay()
Create a functor that tests if the frame fills text items.
The main frame for Pcbnew.
void HardRedraw() override
Rebuild the GAL and redraws the screen.
void OnDisplayOptionsChanged() override
std::size_t m_textVarListenerHandle
Reactive text-var invalidation listener state.
static bool GetPluginActionButtonVisible(const wxString &aPluginPath, bool aPluginDefault)
Return true if button visibility action plugin setting was set to true or it is unset and plugin defa...
void OnEditItemRequest(BOARD_ITEM *aItem) override
Install the corresponding dialog editor for the given item.
Definition edit.cpp:95
void SelectViaStack_Event(wxCommandEvent &event)
Handle the via stack preset selector on the auxiliary toolbar.
void SetLastPath(LAST_PATH_TYPE aType, const wxString &aLastPath)
Set the path of the last file successfully read.
bool interactiveOperationInProgress() const
Return true when an interactive tool operation (routing, dragging, point editing, zone filling,...
int m_crossProbeFlashPhase
Phase counter.
void FindNext(bool reverse=false)
Find the next item using our existing search parameters.
void ResolveDRCExclusions(bool aCreateMarkers)
If aCreateMarkers then create DRC exclusion markers from the serialized data.
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 SetActiveLayer(PCB_LAYER_ID aLayer) override
Change the currently active layer to aLayer and also update the APPEARANCE_CONTROLS.
void OnModify() override
Must be called after a board change to set the modified flag.
void ThemeChanged() override
Called when light/dark theme is changed.
void SwitchLayer(PCB_LAYER_ID layer) override
Change the active layer in the editor.
Definition edit.cpp:68
wxTimer m_crossProbeFlashTimer
Timer to toggle selection visibility for flash.
void StartCrossProbeFlash(const std::vector< BOARD_ITEM * > &aItems)
void OnCrossProbeFlashTimer(wxTimerEvent &aEvent)
std::unique_ptr< API_HANDLER_PCB > m_apiHandler
bool CloseFootprintFieldsTableDialog()
void setupUIConditions() override
Setup the UI conditions for the various actions and their controls in this frame.
DIALOG_FOOTPRINT_FIELDS_TABLE * m_footprintFieldsTableDialog
void UpdateVariantSelectionCtrl()
Update the variant selection dropdown with the current board's variant names.
bool DoAutoSave()
Perform auto save when the board has been modified and not saved within the auto save interval.
void SetElementVisibility(GAL_LAYER_ID aElement, bool aNewState)
Change the visibility of an element category.
DIALOG_BOOK_REPORTER * m_inspectDrcErrorDlg
void OnClearFileHistory(wxCommandEvent &aEvent)
std::unique_ptr< GRID_HELPER > MakeGridHelper() override
virtual ~PCB_EDIT_FRAME()
void SwitchCanvas(EDA_DRAW_PANEL_GAL::GAL_TYPE aCanvasType) override
Switch currently used canvas (Cairo / OpenGL).
void CommonSettingsChanged(int aFlags) override
Called after the preferences dialog is run.
void ShowFindByPropertiesDialog()
Show the Find by Properties dialog.
BOARD_ITEM_CONTAINER * GetModel() const override
DIALOG_BOOK_REPORTER * GetInspectDrcErrorDialog()
void ShowTargetOptionsDialog(PCB_TARGET *aTarget)
void ShowBoardSetupDialog(const wxString &aInitialPage=wxEmptyString, wxWindow *aParent=nullptr)
std::unique_ptr< API_HANDLER_COMMON > m_apiHandlerCommon
DIALOG_FOOTPRINT_FIELDS_TABLE * GetFootprintFieldsTableDialog()
DIALOG_FIND * m_findDialog
DIALOG_BOOK_REPORTER * m_inspectConstraintsDlg
void SetPageSettings(const PAGE_INFO &aPageSettings) override
void onCloseFootprintFieldsTableDialog(wxCommandEvent &aEvent)
bool IsElementVisible(GAL_LAYER_ID aElement) const
Test whether a given element category is visible.
bool CanAcceptApiCommands() override
Check if this frame is ready to accept API commands.
void UpdateUserInterface()
Update the layer manager and other widgets from the board setup (layer and items visibility,...
void SetGridColor(const COLOR4D &aColor) override
void ProjectChanged() override
Notification event that the project has changed.
static const wxString ConstraintsPaneName()
wxString GetLastPath(LAST_PATH_TYPE aType)
Get the last path for a particular type.
void ShowChangedLanguage() override
Redraw the menus and what not in current language.
void doCloseWindow() override
WX_INFOBAR * m_loadNoticeInfoBar
Secondary infobar that stacks above the main one; reserved for load-time notices (currently the WRL -...
void ReCreateLayerBox(bool aForceResizeToolbar=true)
Recreate the layer box by clearing the old list and building a new one from the new layer names and c...
void SaveProjectLocalSettings() override
Save changes to the project local settings.
static std::vector< const PLUGIN_ACTION * > GetOrderedPluginActions()
Return ordered list of plugins in sequence in which they should appear on toolbar or in settings.
void detachTextVarTracker()
Drop every cached reference into the current BOARD's text-var tracker.
void onPluginAvailabilityChanged(wxCommandEvent &aEvt)
void PrepareLayerIndicator(bool aForceRebuild=false)
void ShowFindDialog()
Show the Find dialog.
int ShowExchangeFootprintsDialog(FOOTPRINT *aFootprint, bool aUpdateMode, bool aSelectedMode)
int TestStandalone()
Test if standalone mode.
void ShowFootprintPropertiesDialog(FOOTPRINT *aFootprint)
void UpdateProperties() override
bool canRunAutoSave() const override
Return true when it is safe to run an autosave snapshot right now.
PANEL_CONSTRAINTS * m_constraintsPanel
Dockable geometric-constraint list (#2329).
bool IsContentModified() const override
Get if the current board has been modified but not saved.
bool Clear_Pcb(bool doAskAboutUnsavedChanges, bool aFinal=false)
Delete all and reinitialize the current board.
Definition initpcb.cpp:38
std::unique_ptr< API_HANDLER_LIBRARIES > m_apiLibrariesHandler
bool m_crossProbeFlashing
Currently flashing guard.
TOOL_ACTION * m_exportNetlistAction
The export board netlist tool action object.
BOX2D m_lastNetnamesViewport
Keep track of viewport so that track net labels can be adjusted when it changes.
void OnBoardLoaded()
Update the state of the GUI after a new board is loaded or created.
void ReCreateAuxiliaryToolbar() override
void Edit_Zone_Params(ZONE *zone_container)
Edit params (layer, clearance, ...) for a zone outline.
bool FetchNetlistFromSchematic(NETLIST &aNetlist, const wxString &aAnnotateMessage)
wxString GetCurrentFileName() const override
Get the full filename + path of the currently opened file in the frame.
void LoadSettings(APP_SETTINGS_BASE *aCfg) override
Load common frame parameters from a configuration file.
void OnBoardItemsChanged(BOARD &aBoard, std::vector< BOARD_ITEM * > &aItems) override
Keep the selection and view in step with generated tables rebuilt outside a commit.
DIALOG_BOOK_REPORTER * GetFootprintDiffDialog()
EDA_ANGLE GetRotationAngle() const override
Return the angle used for rotate operations.
void ToggleConstraintsPanel()
Show/hide the dockable geometric-constraint list pane, refreshing it when shown (#2329).
COLOR4D GetGridColor() override
std::vector< KIID > m_crossProbeFlashItems
Items to flash (by UUID)
void UpdateTitle()
Set the main window title bar text.
void RefreshDrillSymbols(int aUpdateFlags) override
Tell every hole to redraw its drill symbol.
DIALOG_BOOK_REPORTER * m_footprintDiffDlg
void ActivateGalCanvas() override
Use to start up the GAL drawing canvas.
void onVariantSelected(wxCommandEvent &aEvent)
Event handler for variant selection changes in the toolbar.
SELECTION & GetCurrentSelection() override
Get the current selection from the canvas area.
void OnQuit(wxCommandEvent &event)
void NotifyFindByPropertiesDialog()
Notify the Find by Properties dialog that the selection has changed.
void onCloseModelessBookReporterDialogs(wxCommandEvent &aEvent)
PCB_DESIGN_BLOCK_PANE * m_designBlocksPane
bool canCloseWindow(wxCloseEvent &aCloseEvent) override
DIALOG_BOARD_SETUP * m_boardSetupDlg
DIALOG_BOOK_REPORTER * GetInspectClearanceDialog()
wxTimer * m_eventCounterTimer
void Tracks_and_Vias_Size_Event(wxCommandEvent &event)
void SaveSettings(APP_SETTINGS_BASE *aCfg) override
Save common frame parameters to a configuration data file.
static const wxString SearchPaneName()
DIALOG_FIND_BY_PROPERTIES * m_findByPropertiesDialog
DIALOG_BOOK_REPORTER * m_inspectClearanceDlg
void OnFileHistory(wxCommandEvent &event)
DIALOG_BOOK_REPORTER * GetInspectConstraintsDialog()
class TEXT_VAR_TRACKER * m_textVarListenerTracker
A set of BOARD_ITEMs (i.e., without duplicates).
Definition pcb_group.h:51
PCB net inspection panel.
Generic tool for picking an item.
Tool that displays edit points allowing to modify items by dragging the points.
PCB_LAYER_ID m_Route_Layer_TOP
Definition pcb_screen.h:39
PCB_LAYER_ID m_Route_Layer_BOTTOM
Definition pcb_screen.h:40
static bool HasUnlockedItems(const SELECTION &aSelection)
Test if any selected items are unlocked.
static bool HasLockedItems(const SELECTION &aSelection)
Test if any selected items are locked.
The selection tool: currently supports:
int ClearSelection(const TOOL_EVENT &aEvent)
Clear current selection event handler.
PCB_SELECTION & GetSelection()
void RebuildSelection()
Rebuild the selection from the EDA_ITEMs' selection flags.
void FindItem(BOARD_ITEM *aItem)
Take necessary actions to mark an item as found.
Tool useful for viewing footprints.
virtual COMMON_SETTINGS * GetCommonSettings() const
Definition pgm_base.cpp:569
KICAD_API_SERVER & GetApiServer()
Definition pgm_base.h:141
virtual const wxString & GetExecutablePath() const
Definition pgm_base.cpp:895
The interactive edit tool.
void Show(std::ostream &aStream=std::cerr)
Definition profile.h:291
void Reset()
Definition profile.h:281
A progress reporter interface for use in multi-threaded environments.
The backing store for a PROJECT, in JSON format.
std::vector< LAYER_PAIR_INFO > m_LayerPairInfos
List of stored 3D viewports (view matrixes)
The project local settings are things that are attached to a particular project, but also might be pa...
wxString m_ActiveLayerPreset
The name of a LAYER_PRESET that is currently activated (or blank if none)
PCB_LAYER_ID m_ActiveLayer
The current (active) board layer for editing.
static FOOTPRINT_LIBRARY_ADAPTER * FootprintLibAdapter(PROJECT *aProject)
virtual const wxString GetProjectPath() const
Return the full path of the project.
Definition project.cpp:277
virtual PROJECT_LOCAL_SETTINGS & GetLocalSettings() const
Definition project.h:207
void IncrementNetclassesTicker()
Definition project.h:115
virtual PROJECT_FILE & GetProjectFile() const
Definition project.h:201
void IncrementTextVarsTicker()
Definition project.h:112
Action handler for the Properties panel.
PNS::PNS_MODE GetRouterMode()
bool RoutingInProgress()
Returns whether routing is currently active.
static SELECTION_CONDITION HasTypes(std::vector< KICAD_T > aTypes)
Create a functor that tests if among the selected items there is at least one of a given types.
static bool NotEmpty(const SELECTION &aSelection)
Test if there are any items selected.
static SELECTION_CONDITION MoreThan(int aNumber)
Create a functor that tests if the number of selected items is greater than the value given as parame...
static bool Idle(const SELECTION &aSelection)
Test if there no items selected or being edited.
static SELECTION_CONDITION Count(int aNumber)
Create a functor that tests if the number of selected items is equal to the value given as parameter.
static bool ShowAlways(const SELECTION &aSelection)
The default condition function (always returns true).
static SELECTION_CONDITION OnlyTypes(std::vector< KICAD_T > aTypes)
Create a functor that tests if the selected items are only of given types.
int AddItemToSel(const TOOL_EVENT &aEvent)
EDA_ITEM * Front() const
Definition selection.h:176
int Size() const
Returns the number of selected parts.
Definition selection.h:120
bool Empty() const
Checks if there is anything selected.
Definition selection.h:114
Is a LINE_READER that reads from a multiline 8 bit wide std::string.
Definition richio.h:225
Coordinates the dependency index with change notifications.
ListenerHandle AddInvalidateListener(InvalidateCallback aCallback)
Register a listener that fires for every invalidation.
static constexpr ListenerHandle INVALID_LISTENER
TOOL_MANAGER * m_toolManager
TOOL_DISPATCHER * m_toolDispatcher
TOOL_MANAGER * GetToolManager() const
Return the MVC controller.
ACTIONS * m_actions
Represent a single user action.
Base abstract interface for all kinds of tools.
Definition tool_base.h:62
@ MODEL_RELOAD
Model changes (the sheet for a schematic)
Definition tool_base.h:76
Generic, UI-independent tool event.
Definition tool_event.h:167
void SetHasPosition(bool aHasPosition)
Definition tool_event.h:257
Master controller class:
T * GetTool()
Return the tool of given type or nullptr if there is no such tool registered.
bool RunAction(const std::string &aActionName, T aParam)
Run the specified action immediately, pausing the current action to run the new one.
TOOL_BASE * GetCurrentTool() const
Return the tool that is on the top of the active tools stack (was invoked the most recently).
Tool that owns actions specific to via-stitch generators.
A modified version of the wxInfoBar class that allows us to:
Definition wx_infobar.h:76
Handle actions specific to filling copper zones.
PROGRESS_REPORTER * GetProgressReporter()
A type-safe container of any type.
Definition ki_any.h:92
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:146
void DisplayErrorMessage(wxWindow *aParent, const wxString &aText, const wxString &aExtraInfo)
Display an error message with aMessage.
Definition confirm.cpp:217
int GetLastUnsavedChangesResponse()
Return the result code from the last call to HandleUnsavedChanges(): wxID_YES, wxID_NO or wxID_CANCEL...
Definition confirm.cpp:159
This file is part of the common library.
KIFACE_BASE & Kiface()
Global KIFACE_BASE "get" accessor.
Definition cvpcb.cpp:178
#define CHECK(x)
#define ENABLE(x)
#define DIALOG_DRC_WINDOW_NAME
Definition dialog_drc.h:40
#define DIALOG_DRC_RULE_EDITOR_WINDOW_NAME
#define _(s)
Declaration of the eda_3d_viewer class.
static constexpr EDA_ANGLE ANGLE_90
Definition eda_angle.h:474
#define KICAD_DEFAULT_DRAWFRAME_STYLE
#define PCB_EDIT_FRAME_NAME
static const std::vector< KICAD_T > footprintTypes
static const std::vector< KICAD_T > groupTypes
static const std::vector< KICAD_T > trackTypes
EVT_MENU_RANGE(ID_GERBVIEW_DRILL_FILE1, ID_GERBVIEW_DRILL_FILEMAX, GERBVIEW_FRAME::OnDrlFileHistory) EVT_MENU_RANGE(ID_GERBVIEW_ZIP_FILE1
#define CURRENT_EDIT_TOOL(action)
Collection of reusable/testable functions for footprint manipulation and validation.
@ FRAME_PCB_EDITOR
Definition frame_type.h:38
@ FRAME_FOOTPRINT_VIEWER
Definition frame_type.h:41
@ FRAME_SCH
Definition frame_type.h:30
@ FRAME_FOOTPRINT_CHOOSER
Definition frame_type.h:40
@ FRAME_FOOTPRINT_EDITOR
Definition frame_type.h:39
int RefreshGeneratedTables(BOARD &aBoard)
Bring every generated table on the board up to date and return how many were rebuilt.
a few functions useful in geometry calculations.
static const std::string LegacySchematicFileExtension
static const std::string JpegFileExtension
static const std::string PngFileExtension
static const std::string LegacyPcbFileExtension
static const std::string KiCadSchematicFileExtension
static const std::string SVGFileExtension
static const std::string KiCadPcbFileExtension
const wxChar *const traceAutoSave
Flag to enable auto save feature debug tracing.
const wxChar *const traceCrossProbeFlash
Flag to enable debug output for cross-probe flash operations.
const wxChar *const traceApi
Flag to enable debug output related to the IPC API and its plugin system.
Definition api_utils.cpp:33
@ ID_ON_GRID_SELECT
Definition id.h:113
@ ID_FILE_LIST_CLEAR
Definition id.h:58
@ ID_EDA_SOCKET_EVENT
Definition id.h:133
@ ID_EDA_SOCKET_EVENT_SERV
Definition id.h:132
@ ID_ON_ZOOM_SELECT
Definition id.h:112
@ ID_FILEMAX
Definition id.h:56
@ ID_FILE1
Definition id.h:55
PROJECT & Prj()
Definition kicad.cpp:743
EVT_MENU(ID_COMPARE_PROJECT_BRANCHES, KICAD_MANAGER_FRAME::OnCompareProjectBranches) KICAD_MANAGER_FRAME
int GetNetnameLayer(int aLayer)
Return a netname layer corresponding to the given layer.
Definition layer_ids.h:921
bool IsCopperLayer(int aLayerId)
Test whether a layer is a copper layer.
Definition layer_ids.h:744
GAL_LAYER_ID
GAL layers are "virtual" layers, i.e.
Definition layer_ids.h:224
@ LAYER_GRID
Definition layer_ids.h:250
@ LAYER_ZONES
Control for copper zone opacity/visibility (color ignored).
Definition layer_ids.h:291
@ LAYER_RATSNEST
Definition layer_ids.h:249
#define CLEARANCE_LAYER_FOR(boardLayer)
Definition layer_ids.h:399
PCB_LAYER_ID
A quick note on layer IDs:
Definition layer_ids.h:56
@ F_Paste
Definition layer_ids.h:100
@ B_Mask
Definition layer_ids.h:94
@ B_Cu
Definition layer_ids.h:61
@ F_Mask
Definition layer_ids.h:93
@ B_Paste
Definition layer_ids.h:101
@ UNDEFINED_LAYER
Definition layer_ids.h:57
@ F_Cu
Definition layer_ids.h:60
@ MAIL_SCH_GET_NETLIST
Definition mail_type.h:45
#define MAIL_SCH_GET_NETLIST_CANCELLED
Reply payload for MAIL_SCH_GET_NETLIST when the user deliberately aborts netlist generation (for exam...
Definition mail_type.h:77
@ REPAINT
Item needs to be redrawn.
Definition view_item.h:54
@ GEOMETRY
Position or shape has changed.
Definition view_item.h:51
@ ALL
All except INITIAL_ADD.
Definition view_item.h:55
@ TARGET_NONCACHED
Auxiliary rendering target (noncached)
Definition definitions.h:34
void SetShutdownBlockReason(wxWindow *aWindow, const wxString &aReason)
Sets the block reason why the window/application is preventing OS shutdown.
Definition unix/app.cpp:108
bool SupportsShutdownBlockReason()
Whether or not the window supports setting a shutdown block reason.
Definition unix/app.cpp:97
@ RM_MarkObstacles
Ignore collisions, mark obstacles.
@ RM_Walkaround
Only walk around.
@ RM_Shove
Only shove.
#define _HKI(x)
Definition page_info.cpp:40
BARCODE class definition.
wxDEFINE_EVENT(EDA_EVT_PCB_LAST_SCH_SHEET_CHANGED, wxCommandEvent)
#define FOOTPRINT_DIFF_DIALOG_NAME
EVT_MENU_RANGE(ID_POPUP_PCB_SELECT_WIDTH_START_RANGE, ID_POPUP_PCB_SELECT_WIDTH_END_RANGE, PCB_EDIT_FRAME::Tracks_and_Vias_Size_Event) EVT_UPDATE_UI_RANGE(ID_POPUP_PCB_SELECT_WIDTH1
ID_POPUP_PCB_SELECT_WIDTH8
#define INSPECT_CLEARANCE_DIALOG_NAME
PCB_EDIT_FRAME::OnUpdateSelectTrackWidth EVT_UPDATE_UI_RANGE(ID_POPUP_PCB_SELECT_VIASIZE1, ID_POPUP_PCB_SELECT_VIASIZE8, PCB_EDIT_FRAME::OnUpdateSelectViaSize) PCB_EDIT_FRAME
#define INSPECT_DRC_ERROR_DIALOG_NAME
#define INSPECT_CONSTRAINTS_DIALOG_NAME
@ ID_POPUP_PCB_SELECT_WIDTH_START_RANGE
Definition pcbnew_id.h:21
@ ID_POPUP_PCB_SELECT_WIDTH1
Definition pcbnew_id.h:25
@ ID_POPUP_PCB_SELECT_VIASIZE8
Definition pcbnew_id.h:48
@ ID_AUX_TOOLBAR_PCB_VARIANT_SELECT
Definition pcbnew_id.h:20
@ ID_AUX_TOOLBAR_PCB_VIA_SIZE
Definition pcbnew_id.h:17
@ ID_POPUP_PCB_SELECT_WIDTH_END_RANGE
Definition pcbnew_id.h:78
@ ID_POPUP_PCB_SELECT_VIASIZE1
Definition pcbnew_id.h:41
@ ID_AUX_TOOLBAR_PCB_VIA_STACK
Definition pcbnew_id.h:19
@ ID_AUX_TOOLBAR_PCB_TRACK_WIDTH
Definition pcbnew_id.h:18
@ SHOW_WITH_VIA_ALWAYS
PGM_BASE & Pgm()
The global program "get" accessor.
see class PGM_BASE
LAST_PATH_TYPE
For storing PcbNew MRU paths of various types.
@ RPT_SEVERITY_EXCLUSION
#define SKIP_SET_DIRTY
Definition sch_commit.h:40
#define SKIP_UNDO
Definition sch_commit.h:38
#define CURRENT_TOOL(action)
std::function< bool(const SELECTION &)> SELECTION_CONDITION
Functor type that checks a specific condition for selected items.
T * GetToolbarSettings(const wxString &aFilename)
T * GetAppSettings(const char *aFilename)
KIWAY Kiway(KFCTL_STANDALONE)
wxString UnescapeString(const wxString &aSource)
#define TO_UTF8(wxstring)
Convert a wxString to a UTF8 encoded C string for all wxWidgets build modes.
A min-max version of BOX2 for fast intersection checking.
Definition box2_minmax.h:33
bool Intersects(const BOX2I_MINMAX &aOther) const
Definition box2_minmax.h:69
A filename or source description, a problem input line, a line number, a byte offset,...
TRACK_CLEARANCE_MODE m_TrackClearance
Identifies a single resolvable source that a text item's ${...} reference depends on.
else
IbisParser parser & reporter
@ AS_GLOBAL
Global action (toolbar/main menu event, global shortcut)
Definition tool_action.h:45
@ AS_ACTIVE
All active tools.
Definition tool_action.h:44
@ TA_MODEL_CHANGE
Model has changed (partial update).
Definition tool_event.h:117
@ TC_COMMAND
Definition tool_event.h:53
#define TEXTVARS_CHANGED
wxLogTrace helper definitions.
@ PCB_SHAPE_T
class PCB_SHAPE, a segment not on copper layers
Definition typeinfo.h:80
@ PCB_DIM_ORTHOGONAL_T
class PCB_DIM_ORTHOGONAL, a linear dimension constrained to x/y
Definition typeinfo.h:98
@ PCB_DIM_LEADER_T
class PCB_DIM_LEADER, a leader dimension (graphic item)
Definition typeinfo.h:95
@ PCB_GENERATOR_T
class PCB_GENERATOR, generator on a layer
Definition typeinfo.h:83
@ PCB_VIA_T
class PCB_VIA, a via (like a track segment on a copper layer)
Definition typeinfo.h:89
@ PCB_DIM_CENTER_T
class PCB_DIM_CENTER, a center point marking (graphic item)
Definition typeinfo.h:96
@ PCB_GROUP_T
class PCB_GROUP, a set of BOARD_ITEMs
Definition typeinfo.h:103
@ PCB_TEXTBOX_T
class PCB_TEXTBOX, wrapped text on a layer
Definition typeinfo.h:85
@ PCB_ZONE_T
class ZONE, a copper pour area
Definition typeinfo.h:100
@ PCB_TEXT_T
class PCB_TEXT, text on a layer
Definition typeinfo.h:84
@ PCB_REFERENCE_IMAGE_T
class PCB_REFERENCE_IMAGE, bitmap on a layer
Definition typeinfo.h:81
@ PCB_FIELD_T
class PCB_FIELD, text associated with a footprint property
Definition typeinfo.h:82
@ PCB_MARKER_T
class PCB_MARKER, a marker used to show something
Definition typeinfo.h:91
@ PCB_BARCODE_T
class PCB_BARCODE, a barcode (graphic item)
Definition typeinfo.h:93
@ PCB_TARGET_T
class PCB_TARGET, a target (graphic item)
Definition typeinfo.h:99
@ PCB_FOOTPRINT_T
class FOOTPRINT, a footprint
Definition typeinfo.h:78
@ PCB_GRID_ITEM_T
a subgrid placed on a board
Definition typeinfo.h:238
@ PCB_DIM_ALIGNED_T
class PCB_DIM_ALIGNED, a linear dimension (graphic item)
Definition typeinfo.h:94
@ PCB_PAD_T
class PAD, a pad in a footprint
Definition typeinfo.h:79
@ PCB_ARC_T
class PCB_ARC, an arc track segment on a copper layer
Definition typeinfo.h:90
@ PCB_TABLE_T
class PCB_TABLE, table of PCB_TABLECELLs
Definition typeinfo.h:86
@ PCB_STACKUP_TABLE_T
class PCB_STACKUP_TABLE, a live stackup table derived from PCB_TABLE
Definition typeinfo.h:242
@ PCB_POINT_T
class PCB_POINT, a 0-dimensional point
Definition typeinfo.h:105
@ PCB_TRACE_T
class PCB_TRACK, a track segment (segment on a copper layer)
Definition typeinfo.h:88
@ PCB_DIM_RADIAL_T
class PCB_DIM_RADIAL, a radius or diameter dimension
Definition typeinfo.h:97
@ PCB_DRILL_CHART_T
class PCB_DRILL_CHART, a live drill chart derived from PCB_TABLE
Definition typeinfo.h:239
constexpr bool IsGeneratedTableType(const KICAD_T aType)
A PCB_TABLE subclass whose cells are generated from the board rather than typed by the user.
Definition typeinfo.h:328
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.
WX_VIEW_CONTROLS class definition.