KiCad PCB EDA Suite
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages Concepts
appearance_controls_3D.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) 2023 CERN
5 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
6 *
7 * This program is free software: you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation, either version 3 of the License, or (at your
10 * option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License along
18 * with this program. If not, see <http://www.gnu.org/licenses/>.
19 */
20
22
23#include <bitmaps.h>
24#include <confirm.h>
25#include <pgm_base.h>
26#include <dpi_scaling_common.h>
27#include <eda_list_dialog.h>
28#include <pcb_display_options.h>
29#include <eda_3d_viewer_frame.h>
30#include <pcbnew_settings.h>
31#include <project.h>
32#include <board.h>
33#include <tool/tool_manager.h>
34#include <tools/pcb_actions.h>
40#include <wx/bmpbuttn.h>
41#include <wx/sizer.h>
42#include <wx/textdlg.h>
43#include <wx/checkbox.h>
44
45#include <../3d_rendering/opengl/render_3d_opengl.h>
46
48#define RR APPEARANCE_CONTROLS_3D::APPEARANCE_SETTING_3D
49
52
53 // text id tooltip
54 RR( _HKI( "Board Body" ), LAYER_3D_BOARD, _HKI( "Show board body" ) ),
55 RR( _HKI( "F.Cu" ), LAYER_3D_COPPER_TOP, _HKI( "Show front copper / surface finish color" ) ),
56 RR( _HKI( "B.Cu" ), LAYER_3D_COPPER_BOTTOM, _HKI( "Show back copper / surface finish color" ) ),
57 RR( _HKI( "Adhesive" ), LAYER_3D_ADHESIVE, _HKI( "Show adhesive" ) ),
58 RR( _HKI( "Solder Paste" ), LAYER_3D_SOLDERPASTE, _HKI( "Show solder paste" ) ),
59 RR( _HKI( "F.Silkscreen" ), LAYER_3D_SILKSCREEN_TOP, _HKI( "Show front silkscreen" ) ),
60 RR( _HKI( "B.Silkscreen" ), LAYER_3D_SILKSCREEN_BOTTOM, _HKI( "Show back silkscreen" ) ),
61 RR( _HKI( "F.Mask" ), LAYER_3D_SOLDERMASK_TOP, _HKI( "Show front solder mask" ) ),
62 RR( _HKI( "B.Mask" ), LAYER_3D_SOLDERMASK_BOTTOM, _HKI( "Show back solder mask" ) ),
63 RR( _HKI( "User.Drawings" ), LAYER_3D_USER_DRAWINGS, _HKI( "Show user drawings layer" ) ),
64 RR( _HKI( "User.Comments" ), LAYER_3D_USER_COMMENTS, _HKI( "Show user comments layer" ) ),
65 RR( _HKI( "User.Eco1" ), LAYER_3D_USER_ECO1, _HKI( "Show user ECO1 layer" ) ),
66 RR( _HKI( "User.Eco2" ), LAYER_3D_USER_ECO2, _HKI( "Show user ECO2 layer" ) ),
67 RR( _HKI( "User.1" ), LAYER_3D_USER_1, _HKI( "Show user defined layer 1" ) ),
68 RR( _HKI( "User.2" ), LAYER_3D_USER_2, _HKI( "Show user defined layer 2" ) ),
69 RR( _HKI( "User.3" ), LAYER_3D_USER_3, _HKI( "Show user defined layer 3" ) ),
70 RR( _HKI( "User.4" ), LAYER_3D_USER_4, _HKI( "Show user defined layer 4" ) ),
71 RR( _HKI( "User.5" ), LAYER_3D_USER_5, _HKI( "Show user defined layer 5" ) ),
72 RR( _HKI( "User.6" ), LAYER_3D_USER_6, _HKI( "Show user defined layer 6" ) ),
73 RR( _HKI( "User.7" ), LAYER_3D_USER_7, _HKI( "Show user defined layer 7" ) ),
74 RR( _HKI( "User.8" ), LAYER_3D_USER_8, _HKI( "Show user defined layer 8" ) ),
75 RR( _HKI( "User.9" ), LAYER_3D_USER_9, _HKI( "Show user defined layer 9" ) ),
76 RR( _HKI( "User.10" ), LAYER_3D_USER_10, _HKI( "Show user defined layer 10" ) ),
77 RR( _HKI( "User.11" ), LAYER_3D_USER_11, _HKI( "Show user defined layer 11" ) ),
78 RR( _HKI( "User.12" ), LAYER_3D_USER_12, _HKI( "Show user defined layer 12" ) ),
79 RR( _HKI( "User.13" ), LAYER_3D_USER_13, _HKI( "Show user defined layer 13" ) ),
80 RR( _HKI( "User.14" ), LAYER_3D_USER_14, _HKI( "Show user defined layer 14" ) ),
81 RR( _HKI( "User.15" ), LAYER_3D_USER_15, _HKI( "Show user defined layer 15" ) ),
82 RR( _HKI( "User.16" ), LAYER_3D_USER_16, _HKI( "Show user defined layer 16" ) ),
83 RR( _HKI( "User.17" ), LAYER_3D_USER_17, _HKI( "Show user defined layer 17" ) ),
84 RR( _HKI( "User.18" ), LAYER_3D_USER_18, _HKI( "Show user defined layer 18" ) ),
85 RR( _HKI( "User.19" ), LAYER_3D_USER_19, _HKI( "Show user defined layer 19" ) ),
86 RR( _HKI( "User.20" ), LAYER_3D_USER_20, _HKI( "Show user defined layer 20" ) ),
87 RR( _HKI( "User.21" ), LAYER_3D_USER_21, _HKI( "Show user defined layer 21" ) ),
88 RR( _HKI( "User.22" ), LAYER_3D_USER_22, _HKI( "Show user defined layer 22" ) ),
89 RR( _HKI( "User.23" ), LAYER_3D_USER_23, _HKI( "Show user defined layer 23" ) ),
90 RR( _HKI( "User.24" ), LAYER_3D_USER_24, _HKI( "Show user defined layer 24" ) ),
91 RR( _HKI( "User.25" ), LAYER_3D_USER_25, _HKI( "Show user defined layer 25" ) ),
92 RR( _HKI( "User.26" ), LAYER_3D_USER_26, _HKI( "Show user defined layer 26" ) ),
93 RR( _HKI( "User.27" ), LAYER_3D_USER_27, _HKI( "Show user defined layer 27" ) ),
94 RR( _HKI( "User.28" ), LAYER_3D_USER_28, _HKI( "Show user defined layer 28" ) ),
95 RR( _HKI( "User.29" ), LAYER_3D_USER_29, _HKI( "Show user defined layer 29" ) ),
96 RR( _HKI( "User.30" ), LAYER_3D_USER_30, _HKI( "Show user defined layer 30" ) ),
97 RR( _HKI( "User.31" ), LAYER_3D_USER_31, _HKI( "Show user defined layer 31" ) ),
98 RR( _HKI( "User.32" ), LAYER_3D_USER_32, _HKI( "Show user defined layer 32" ) ),
99 RR( _HKI( "User.33" ), LAYER_3D_USER_33, _HKI( "Show user defined layer 33" ) ),
100 RR( _HKI( "User.34" ), LAYER_3D_USER_34, _HKI( "Show user defined layer 34" ) ),
101 RR( _HKI( "User.35" ), LAYER_3D_USER_35, _HKI( "Show user defined layer 35" ) ),
102 RR( _HKI( "User.36" ), LAYER_3D_USER_36, _HKI( "Show user defined layer 36" ) ),
103 RR( _HKI( "User.37" ), LAYER_3D_USER_37, _HKI( "Show user defined layer 37" ) ),
104 RR( _HKI( "User.38" ), LAYER_3D_USER_38, _HKI( "Show user defined layer 38" ) ),
105 RR( _HKI( "User.39" ), LAYER_3D_USER_39, _HKI( "Show user defined layer 39" ) ),
106 RR( _HKI( "User.40" ), LAYER_3D_USER_40, _HKI( "Show user defined layer 40" ) ),
107 RR( _HKI( "User.41" ), LAYER_3D_USER_41, _HKI( "Show user defined layer 41" ) ),
108 RR( _HKI( "User.42" ), LAYER_3D_USER_42, _HKI( "Show user defined layer 42" ) ),
109 RR( _HKI( "User.43" ), LAYER_3D_USER_43, _HKI( "Show user defined layer 43" ) ),
110 RR( _HKI( "User.44" ), LAYER_3D_USER_44, _HKI( "Show user defined layer 44" ) ),
111 RR( _HKI( "User.45" ), LAYER_3D_USER_45, _HKI( "Show user defined layer 45" ) ),
112 RR(),
113 RR( _HKI( "Through-hole Models" ), LAYER_3D_TH_MODELS, EDA_3D_ACTIONS::showTHT ),
117 RR( _HKI( "Models marked DNP" ), LAYER_3D_MODELS_MARKED_DNP, EDA_3D_ACTIONS::showDNP ),
118 RR( _HKI( "Model Bounding Boxes" ), LAYER_3D_BOUNDING_BOXES, EDA_3D_ACTIONS::showBBoxes ),
119 RR(),
120 RR( _HKI( "Values" ), LAYER_FP_VALUES, _HKI( "Show footprint values" ) ),
121 RR( _HKI( "References" ), LAYER_FP_REFERENCES, _HKI( "Show footprint references" ) ),
122 RR( _HKI( "Footprint Text" ), LAYER_FP_TEXT, _HKI( "Show all footprint text" ) ),
123 RR( _HKI( "Off-board Silkscreen" ), LAYER_3D_OFF_BOARD_SILK, _HKI( "Do not clip silk layers to board outline" ) ),
124 RR(),
126 RR( _HKI( "Background Start" ), LAYER_3D_BACKGROUND_TOP, _HKI( "Background gradient start color" ) ),
127 RR( _HKI( "Background End" ), LAYER_3D_BACKGROUND_BOTTOM, _HKI( "Background gradient end color" ) ),
128};
129
130// The list of IDs that can have colors coming from the board stackup, and cannot be
131// modified if use colors from stackup is activated
132static std::vector<int> inStackupColors{ LAYER_3D_BOARD,
137 };
138
141 m_frame( aParent ),
142 m_focusOwner( aFocusOwner ),
143 m_lastSelectedViewport( nullptr )
144{
145 DPI_SCALING_COMMON dpi( nullptr, m_frame );
146
147 int screenHeight = wxSystemSettings::GetMetric( wxSYS_SCREEN_Y );
148 m_pointSize = wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT ).GetPointSize();
149
150 m_layerPanelColour = m_panelLayers->GetBackgroundColour().ChangeLightness( 110 );
151 SetBorders( true, false, false, false );
152
153 m_layersOuterSizer = new wxBoxSizer( wxVERTICAL );
155 m_windowLayers->SetScrollRate( 0, 5 );
156 m_windowLayers->Bind( wxEVT_SET_FOCUS, &APPEARANCE_CONTROLS_3D::OnSetFocus, this );
157
158 m_envOuterSizer = new wxBoxSizer( wxVERTICAL );
159
160 wxFont infoFont = KIUI::GetInfoFont( this );
161 m_panelLayers->SetFont( infoFont );
162 m_windowLayers->SetFont( infoFont );
163 m_presetsLabel->SetFont( infoFont );
164 m_viewportsLabel->SetFont( infoFont );
165
166 // Create display options
167 m_cbUseBoardStackupColors = new wxCheckBox( m_panelLayers, wxID_ANY,
168 _( "Use board stackup colors" ) );
169 m_cbUseBoardStackupColors->SetFont( infoFont );
170
171 m_cbUseBoardStackupColors->Bind( wxEVT_CHECKBOX,
172 [this]( wxCommandEvent& aEvent )
173 {
175 cfg->m_UseStackupColors = aEvent.IsChecked();
176
178 m_frame->NewDisplay( true );
179 } );
180
181 m_cbUseBoardEditorCopperColors = new wxCheckBox( m_panelLayers, wxID_ANY,
182 _( "Use PCB editor copper colors" ) );
183 m_cbUseBoardEditorCopperColors->SetFont( infoFont );
184 m_cbUseBoardEditorCopperColors->SetToolTip( _( "Use the board editor layer colors for copper "
185 "layers (realtime renderer only)" ) );
186
187 m_cbUseBoardEditorCopperColors->Bind( wxEVT_CHECKBOX,
188 [this]( wxCommandEvent& aEvent )
189 {
191 cfg->m_Render.use_board_editor_copper_colors = aEvent.IsChecked();
192
194 m_frame->NewDisplay( true );
195 } );
196
197 m_panelLayersSizer->Add( m_cbUseBoardStackupColors, 0, wxEXPAND | wxTOP | wxLEFT | wxRIGHT, 5 );
199 wxEXPAND | wxALL, 5 );
200
201 m_cbLayerPresets->SetToolTip( wxString::Format( _( "Save and restore color and visibility combinations.\n"
202 "Use %s+Tab to activate selector.\n"
203 "Successive Tabs while holding %s down will cycle through "
204 "presets in the popup." ),
207
208 m_cbViewports->SetToolTip( wxString::Format( _( "Save and restore camera position and zoom.\n"
209 "Use %s+Tab to activate selector.\n"
210 "Successive Tabs while holding %s down will cycle through "
211 "viewports in the popup." ),
214
215 if( screenHeight <= 900 && m_pointSize >= FromDIP( KIUI::c_IndicatorSizeDIP ) )
216 m_pointSize = m_pointSize * 8 / 10;
217
219
221 KiBitmapBundle( BITMAPS::visibility ), KiBitmapBundle( BITMAPS::visibility_off ) );
222
223 m_frame->Bind( EDA_LANG_CHANGED, &APPEARANCE_CONTROLS_3D::OnLanguageChanged, this );
224}
225
226
228{
229 m_frame->Unbind( EDA_LANG_CHANGED, &APPEARANCE_CONTROLS_3D::OnLanguageChanged, this );
230}
231
232
234{
235 DPI_SCALING_COMMON dpi( nullptr, m_frame );
236 wxSize size( 220 * dpi.GetScaleFactor(), 480 * dpi.GetScaleFactor() );
237 return size;
238}
239
240
241void APPEARANCE_CONTROLS_3D::OnSetFocus( wxFocusEvent& aEvent )
242{
243#ifdef __WXMSW__
244 // In wxMSW, buttons won't process events unless they have focus, so we'll let it take the
245 // focus and give it back to the parent in the button event handler.
246 if( wxBitmapButton* btn = dynamic_cast<wxBitmapButton*>( aEvent.GetEventObject() ) )
247 {
248 wxCommandEvent evt( wxEVT_BUTTON );
249 wxPostEvent( btn, evt );
250 }
251#endif
252
253 passOnFocus();
254 aEvent.Skip();
255}
256
257
258void APPEARANCE_CONTROLS_3D::OnSize( wxSizeEvent& aEvent )
259{
260 aEvent.Skip();
261}
262
263
265{
266 Freeze();
267
269 m_cbUseBoardStackupColors->SetLabel( _( "Use board stackup colors" ) );
272
273 Thaw();
274 Refresh();
275}
276
277
278void APPEARANCE_CONTROLS_3D::OnLanguageChanged( wxCommandEvent& aEvent )
279{
281
282 aEvent.Skip();
283}
284
285
287{
288 // This is essentially a list of hacks because DarkMode isn't yet implemented inside
289 // wxWidgets.
290 //
291 // The individual wxPanels, COLOR_SWATCHes and GRID_CELL_COLOR_RENDERERs should really be
292 // overriding some virtual method or responding to some wxWidgets event so that the parent
293 // doesn't have to know what it contains. But, that's not where we are, so... :shrug:
294
295 m_layerPanelColour = m_panelLayers->GetBackgroundColour().ChangeLightness( 110 );
296
297 m_windowLayers->SetBackgroundColour( m_layerPanelColour );
298
299 for( wxSizerItem* child : m_layersOuterSizer->GetChildren() )
300 {
301 if( child && child->GetWindow() )
302 child->GetWindow()->SetBackgroundColour( m_layerPanelColour );
303 }
304}
305
306
308{
310
312
313 const wxString& currentPreset = m_frame->GetAdapter().m_Cfg->m_CurrentPreset;
314
315 if( currentPreset == FOLLOW_PCB || currentPreset == FOLLOW_PLOT_SETTINGS )
316 updateLayerPresetWidget( currentPreset );
317 else
319}
320
321
322void APPEARANCE_CONTROLS_3D::ApplyLayerPreset( const wxString& aPresetName )
323{
324 doApplyLayerPreset( aPresetName );
325
326 // Move to front of MRU list
327 if( m_presetMRU.Index( aPresetName ) != wxNOT_FOUND )
328 m_presetMRU.Remove( aPresetName );
329
330 m_presetMRU.Insert( aPresetName, 0 );
331
332 updateLayerPresetWidget( aPresetName );
333}
334
335
336std::vector<VIEWPORT3D> APPEARANCE_CONTROLS_3D::GetUserViewports() const
337{
338 std::vector<VIEWPORT3D> ret;
339
340 for( const auto& [name, viewport] : m_viewports )
341 ret.emplace_back( viewport );
342
343 return ret;
344}
345
346
347void APPEARANCE_CONTROLS_3D::SetUserViewports( std::vector<VIEWPORT3D>& aViewportList )
348{
349 m_viewports.clear();
350
351 for( const VIEWPORT3D& viewport : aViewportList )
352 {
353 if( m_viewports.count( viewport.name ) )
354 continue;
355
356 m_viewports[viewport.name] = viewport;
357
358 m_viewportMRU.Add( viewport.name );
359 }
360
362
363 // Now is as good a time as any to initialize the layer presets as well.
365
366 m_presetMRU.Add( FOLLOW_PCB );
368
369 for( const LAYER_PRESET_3D& preset : m_frame->GetAdapter().m_Cfg->m_LayerPresets )
370 m_presetMRU.Add( preset.name );
371}
372
373
374void APPEARANCE_CONTROLS_3D::ApplyViewport( const wxString& aViewportName )
375{
376 int idx = m_cbViewports->FindString( aViewportName );
377
378 if( idx >= 0 && idx < (int)m_cbViewports->GetCount() - 3 /* separator */ )
379 {
380 m_cbViewports->SetSelection( idx );
381 m_lastSelectedViewport = static_cast<VIEWPORT3D*>( m_cbViewports->GetClientData( idx ) );
382 }
383 else
384 {
385 m_cbViewports->SetSelection( m_cbViewports->GetCount() - 3 ); // separator
386 m_lastSelectedViewport = nullptr;
387 }
388
391}
392
393
394void APPEARANCE_CONTROLS_3D::OnLayerVisibilityChanged( int aLayer, bool isVisible )
395{
396 std::bitset<LAYER_3D_END> visibleLayers = m_frame->GetAdapter().GetVisibleLayers();
397 const std::map<int, COLOR4D>& colors = m_frame->GetAdapter().GetLayerColors();
398 bool killFollow = false;
399 bool doFastRefresh = false; // true to just refresh the display
400
401 // Special-case controls
402 switch( aLayer )
403 {
404 case LAYER_FP_TEXT:
405 // Because Footprint Text is a meta-control that also can disable values/references,
406 // drag them along here so that the user is less likely to be confused.
407 if( !isVisible )
408 {
409 visibleLayers.set( LAYER_FP_REFERENCES, false );
410 visibleLayers.set( LAYER_FP_VALUES, false );
411 }
412
413 visibleLayers.set( LAYER_FP_TEXT, isVisible );
414 killFollow = true;
415 break;
416
418 case LAYER_FP_VALUES:
419 // In case that user changes Footprint Value/References when the Footprint Text
420 // meta-control is disabled, we should put it back on.
421 if( isVisible )
422 visibleLayers.set( LAYER_FP_TEXT, true );
423
424 visibleLayers.set( aLayer, isVisible );
425 killFollow = true;
426 break;
427
428 case LAYER_3D_BOARD:
441 visibleLayers.set( aLayer, isVisible );
442 killFollow = true;
443 break;
444
450 doFastRefresh = true;
451 visibleLayers.set( aLayer, isVisible );
452 break;
453
454 default:
455 visibleLayers.set( aLayer, isVisible );
456
457 if( aLayer >= LAYER_3D_USER_1 && aLayer <= LAYER_3D_USER_45 )
458 killFollow = true;
459
460 break;
461 }
462
463 m_frame->GetAdapter().SetVisibleLayers( visibleLayers );
464 m_frame->GetAdapter().SetLayerColors( colors );
465
466 const wxString& currentPreset = m_frame->GetAdapter().m_Cfg->m_CurrentPreset;
467
468 if( ( currentPreset != FOLLOW_PCB && currentPreset != FOLLOW_PLOT_SETTINGS ) || killFollow )
470
472
473 if( doFastRefresh && m_frame->GetAdapter().m_Cfg->m_Render.engine == RENDER_ENGINE::OPENGL )
474 {
475 RENDER_3D_OPENGL* renderer = static_cast<RENDER_3D_OPENGL*>( m_frame->GetCanvas()->GetCurrentRender() );
476 renderer->Load3dModelsIfNeeded();
478 }
479 else
480 {
481 m_frame->NewDisplay( true );
482 }
483}
484
485
487{
488 std::bitset<LAYER_3D_END> visibleLayers = m_frame->GetAdapter().GetVisibleLayers();
489 std::map<int, COLOR4D> colors = m_frame->GetAdapter().GetLayerColors();
490
491 m_frame->GetAdapter().SetVisibleLayers( visibleLayers );
492
493 int layer = aSwatch->GetId();
494 COLOR4D newColor = aSwatch->GetSwatchColor();
495
496 colors[ layer ] = newColor;
497
498 if( layer == LAYER_3D_COPPER_TOP )
499 colors[ LAYER_3D_COPPER_BOTTOM ] = newColor;
500 else if( layer == LAYER_3D_COPPER_BOTTOM )
501 colors[ LAYER_3D_COPPER_TOP ] = newColor;
502
503 m_frame->GetAdapter().SetLayerColors( colors );
504
505 const wxString& currentPreset = m_frame->GetAdapter().m_Cfg->m_CurrentPreset;
506
507 if( currentPreset == FOLLOW_PCB || currentPreset == FOLLOW_PLOT_SETTINGS )
508 updateLayerPresetWidget( currentPreset );
509 else
511
512 m_frame->NewDisplay( true );
513}
514
515
517{
518 int swatchWidth = m_windowLayers->ConvertDialogToPixels( wxSize( 8, 0 ) ).x;
519
520 std::bitset<LAYER_3D_END> visibleLayers = m_frame->GetAdapter().GetVisibleLayers();
521 std::map<int, COLOR4D> colors = m_frame->GetAdapter().GetLayerColors();
522 std::map<int, COLOR4D> defaultColors = m_frame->GetAdapter().GetDefaultColors();
523 LSET enabled = m_frame->GetBoard()->GetEnabledLayers();
524
525 m_layerSettings.clear();
526 m_layersOuterSizer->Clear( true );
527 m_layersOuterSizer->AddSpacer( 5 );
528
529 m_envOuterSizer->Clear( true );
530
531 auto appendLayer =
532 [&]( const std::unique_ptr<APPEARANCE_SETTING_3D>& aSetting )
533 {
534 wxBoxSizer* sizer = new wxBoxSizer( wxHORIZONTAL );
535 int layer = aSetting->m_Id;
536
537 aSetting->m_Visible = visibleLayers.test( layer );
538
539 if( colors.count( layer ) )
540 {
541 COLOR_SWATCH* swatch = new COLOR_SWATCH( m_windowLayers, colors[ layer ], layer,
542 COLOR4D::WHITE, defaultColors[ layer ],
543 SWATCH_SMALL );
544 swatch->SetToolTip( _( "Left double click or middle click to change color" ) );
545
546 swatch->SetReadOnlyCallback(
547 [this]()
548 {
549 WX_INFOBAR* infobar = m_frame->GetInfoBar();
550
551 infobar->RemoveAllButtons();
552 infobar->AddCloseButton();
553
554 infobar->ShowMessageFor( _( "Uncheck 'Use board stackup colors' to "
555 "allow color editing." ),
556 10000, wxICON_INFORMATION );
557 } );
558
559 sizer->Add( swatch, 0, wxALIGN_CENTER_VERTICAL, 0 );
560 aSetting->m_Ctl_color = swatch;
561
562 swatch->Bind( COLOR_SWATCH_CHANGED,
563 [this]( wxCommandEvent& event )
564 {
565 auto swatch = static_cast<COLOR_SWATCH*>( event.GetEventObject() );
566 onColorSwatchChanged( swatch );
567
568 passOnFocus();
569 } );
570 }
571 else
572 {
573 sizer->AddSpacer( swatchWidth );
574 }
575
576 sizer->AddSpacer( 5 );
577
578 wxString layerName = aSetting->GetLabel();
579 PCB_LAYER_ID boardLayer = Map3DLayerToPCBLayer( layer );
580
581 if( boardLayer != UNDEFINED_LAYER )
582 layerName = m_frame->GetBoard()->GetLayerName( boardLayer );
583
584 wxStaticText* label = new wxStaticText( m_windowLayers, layer, layerName );
585 label->Wrap( -1 );
586 label->SetToolTip( aSetting->GetTooltip() );
587
588 if( layer == LAYER_3D_BACKGROUND_TOP || layer == LAYER_3D_BACKGROUND_BOTTOM )
589 {
590 sizer->AddSpacer( swatchWidth );
591 }
592 else
593 {
594 BITMAP_TOGGLE* btn_visible = new BITMAP_TOGGLE( m_windowLayers, layer,
595 KiBitmapBundle( BITMAPS::visibility ),
596 KiBitmapBundle( BITMAPS::visibility_off ),
597 aSetting->m_Visible );
598
599 btn_visible->Bind( TOGGLE_CHANGED,
600 [this]( wxCommandEvent& aEvent )
601 {
602 int id = static_cast<wxWindow*>( aEvent.GetEventObject() )->GetId();
603 bool isVisible = aEvent.GetInt();
604 OnLayerVisibilityChanged( id, isVisible );
605
606 passOnFocus();
607 } );
608
609 wxString tip;
610 tip.Printf( _( "Show or hide %s" ), aSetting->GetLabel().Lower() );
611 btn_visible->SetToolTip( tip );
612
613 aSetting->m_Ctl_visibility = btn_visible;
614 sizer->Add( btn_visible, 0, wxALIGN_CENTER_VERTICAL, 0 );
615 }
616
617 sizer->AddSpacer( 5 );
618 sizer->Add( label, 0, wxALIGN_CENTER_VERTICAL, 0 );
619
620 m_layersOuterSizer->Add( sizer, 0, wxEXPAND | wxLEFT | wxRIGHT, 5 );
621 m_layersOuterSizer->AddSpacer( 2 );
622 };
623
624 for( const APPEARANCE_SETTING_3D& s_setting : s_layerSettings )
625 {
626 m_layerSettings.emplace_back( std::make_unique<APPEARANCE_SETTING_3D>( s_setting ) );
627 std::unique_ptr<APPEARANCE_SETTING_3D>& setting = m_layerSettings.back();
628
629 if( setting->m_Spacer )
630 {
631 m_layersOuterSizer->AddSpacer( m_pointSize );
632 }
633 else if( setting->m_Id >= LAYER_3D_USER_1 && setting->m_Id <= LAYER_3D_USER_45 )
634 {
635 if( enabled.test( Map3DLayerToPCBLayer( setting->m_Id ) ) )
636 appendLayer( setting );
637 }
638 else
639 {
640 appendLayer( setting );
641 }
642
643 m_layerSettingsMap[setting->m_Id] = setting.get();
644 }
645
646 m_sizerOuter->Layout();
647}
648
649
651{
653 std::bitset<LAYER_3D_END> visibleLayers = m_frame->GetAdapter().GetVisibleLayers();
654 std::map<int, COLOR4D> colors = m_frame->GetAdapter().GetLayerColors();
655
656 for( std::unique_ptr<APPEARANCE_SETTING_3D>& setting : m_layerSettings )
657 {
658 if( setting->m_Spacer )
659 continue;
660
661 if( setting->m_Ctl_visibility )
662 setting->m_Ctl_visibility->SetValue( visibleLayers.test( setting->m_Id ) );
663
664 if( setting->m_Ctl_color )
665 {
666 setting->m_Ctl_color->SetSwatchColor( colors[ setting->m_Id ], false );
667
668 // if cfg->m_UseStackupColors is set, board colors cannot be modified locally, but
669 // other colors can be
670 if( alg::contains( inStackupColors, setting->m_Id ) && cfg )
671 setting->m_Ctl_color->SetReadOnly( cfg->m_UseStackupColors );
672 }
673 }
674
675 if( cfg )
676 {
679 }
680}
681
682
684{
685 m_presetsLabel->SetLabel( wxString::Format( _( "Presets (%s+Tab):" ),
687
688 m_cbLayerPresets->Clear();
689
690 // Build the layers preset list.
691
692 m_cbLayerPresets->Append( _( "Follow PCB Editor" ) );
693 m_cbLayerPresets->Append( _( "Follow PCB Plot Settings" ) );
694
695 for( const LAYER_PRESET_3D& preset : m_frame->GetAdapter().m_Cfg->m_LayerPresets )
696 m_cbLayerPresets->Append( preset.name );
697
698 m_cbLayerPresets->Append( wxT( "---" ) );
699 m_cbLayerPresets->Append( _( "Save preset..." ) );
700 m_cbLayerPresets->Append( _( "Delete preset..." ) );
701
703}
704
705
707{
708 m_frame->GetAdapter().m_Cfg->m_CurrentPreset = wxEmptyString;
709
710 std::vector<LAYER_PRESET_3D>& presets = m_frame->GetAdapter().m_Cfg->m_LayerPresets;
711 std::bitset<LAYER_3D_END> visibleLayers = m_frame->GetAdapter().GetVisibleLayers();
712 std::map<int, COLOR4D> colors = m_frame->GetAdapter().GetLayerColors();
713
714 auto it = std::find_if(
715 presets.begin(), presets.end(),
716 [&]( const LAYER_PRESET_3D& aPreset )
717 {
718 if( aPreset.name.Lower() == _( "legacy colors" ) && m_cbUseBoardStackupColors->GetValue() )
719 return false;
720
721 for( int layer = LAYER_3D_BOARD; layer < LAYER_3D_END; ++layer )
722 {
723 if( aPreset.layers.test( layer ) != visibleLayers.test( layer ) )
724 return false;
725 }
726
727 for( int layer : { LAYER_FP_REFERENCES, LAYER_FP_VALUES, LAYER_FP_TEXT } )
728 {
729 if( aPreset.layers.test( layer ) != visibleLayers.test( layer ) )
730 return false;
731 }
732
733 for( int layer = LAYER_3D_START + 1; layer < LAYER_3D_END; ++layer )
734 {
735 auto it1 = aPreset.colors.find( layer );
736 auto it2 = colors.find( layer );
737
738 if( it1 != aPreset.colors.end() && it2 != colors.end() && *it1 != *it2 )
739 return false;
740 }
741
742 return true;
743 } );
744
745 if( it != presets.end() )
746 {
747 m_frame->GetAdapter().m_Cfg->m_CurrentPreset = it->name;
748 m_cbLayerPresets->SetStringSelection( it->name );
749 }
750 else
751 {
752 m_cbLayerPresets->SetSelection( m_cbLayerPresets->GetCount() - 3 ); // separator
753 }
754}
755
756
758{
759 if( aName == FOLLOW_PCB )
760 m_cbLayerPresets->SetSelection( 0 );
761 else if( aName == FOLLOW_PLOT_SETTINGS )
762 m_cbLayerPresets->SetSelection( 1 );
763 else if( !m_cbLayerPresets->SetStringSelection( aName ) )
764 m_cbLayerPresets->SetSelection( m_cbLayerPresets->GetCount() - 3 ); // separator
765}
766
767
769{
771 int count = m_cbLayerPresets->GetCount();
772 int index = m_cbLayerPresets->GetSelection();
773 wxString name;
774
775 auto resetSelection =
776 [&]()
777 {
779 };
780
781 if( index == 0 )
782 {
784 }
785 else if( index == 1 )
786 {
788 }
789 else if( index == count - 3 )
790 {
791 // Separator: reject the selection
792 resetSelection();
793 return;
794 }
795 else if( index == count - 2 )
796 {
797 wxTextEntryDialog dlg( wxGetTopLevelParent( this ), _( "Layer preset name:" ),
798 _( "Save Layer Preset" ) );
799
800 if( dlg.ShowModal() != wxID_OK )
801 {
802 resetSelection();
803 return;
804 }
805
806 std::bitset<LAYER_3D_END> visibleLayers = m_frame->GetAdapter().GetVisibleLayers();
807 std::map<int, COLOR4D> colors = m_frame->GetAdapter().GetLayerColors();
808
809 name = dlg.GetValue();
810
811 if( LAYER_PRESET_3D* preset = cfg->FindPreset( name ) )
812 {
813 if( !IsOK( wxGetTopLevelParent( this ), _( "Overwrite existing preset?" ) ) )
814 {
815 resetSelection();
816 return;
817 }
818
819 preset->layers = visibleLayers;
820 preset->colors = colors;
821 m_cbLayerPresets->SetSelection( m_cbLayerPresets->FindString( name ) );
822 }
823 else
824 {
825 cfg->m_LayerPresets.emplace_back( name, visibleLayers, colors );
826 m_cbLayerPresets->SetSelection( m_cbLayerPresets->Insert( name, index - 1 ) );
827 }
828
829 cfg->m_CurrentPreset = name;
830 m_presetMRU.Insert( name, 0 );
831
832 return;
833 }
834 else if( index == count - 1 )
835 {
836 wxArrayString headers;
837 std::vector<wxArrayString> items;
838
839 headers.Add( _( "Presets" ) );
840
841 for( LAYER_PRESET_3D& preset : cfg->m_LayerPresets )
842 {
843 wxArrayString item;
844 item.Add( preset.name );
845 items.emplace_back( item );
846 }
847
848 EDA_LIST_DIALOG dlg( m_frame, _( "Delete Preset" ), headers, items );
849 dlg.SetListLabel( _( "Select preset:" ) );
850
851 if( dlg.ShowModal() == wxID_OK )
852 {
853 name = dlg.GetTextSelection();
854
855 if( m_cbLayerPresets->FindString( name ) != wxNOT_FOUND )
856 m_cbLayerPresets->Delete( m_cbLayerPresets->FindString( name ) );
857
859 [name]( const LAYER_PRESET_3D& preset )
860 {
861 return preset.name == name;
862 } );
863
864 if( cfg->m_CurrentPreset == name )
865 cfg->m_CurrentPreset = wxEmptyString;
866
867 m_presetMRU.Remove( name );
868 }
869
870 resetSelection();
871 return;
872 }
873 else
874 {
875 doApplyLayerPreset( m_cbLayerPresets->GetStringSelection() );
876 }
877
878 // Move to front of MRU list
879 if( m_presetMRU.Index( name ) != wxNOT_FOUND )
880 m_presetMRU.Remove( name );
881
882 m_presetMRU.Insert( name, 0 );
883
884 passOnFocus();
885}
886
887
888void APPEARANCE_CONTROLS_3D::doApplyLayerPreset( const wxString& aPresetName )
889{
890 BOARD_ADAPTER& adapter = m_frame->GetAdapter();
891
892 if( aPresetName == FOLLOW_PCB || aPresetName == FOLLOW_PLOT_SETTINGS )
893 {
894 adapter.m_Cfg->m_CurrentPreset = aPresetName;
895 adapter.SetVisibleLayers( adapter.GetVisibleLayers() );
896 }
897 else if( LAYER_PRESET_3D* preset = adapter.m_Cfg->FindPreset( aPresetName ) )
898 {
899 adapter.m_Cfg->m_CurrentPreset = aPresetName;
900 adapter.SetVisibleLayers( preset->layers );
901 adapter.SetLayerColors( preset->colors );
902
903 if( preset->name.Lower() == _( "legacy colors" ) )
904 adapter.m_Cfg->m_UseStackupColors = false;
905 }
906 else
907 {
908 return;
909 }
910
912 m_frame->NewDisplay( true );
913}
914
915
917{
918 m_viewportsLabel->SetLabel( wxString::Format( _( "Viewports (%s+Tab):" ),
920
921 m_cbViewports->Clear();
922
923 for( std::pair<const wxString, VIEWPORT3D>& pair : m_viewports )
924 m_cbViewports->Append( pair.first, static_cast<void*>( &pair.second ) );
925
926 m_cbViewports->Append( wxT( "---" ) );
927 m_cbViewports->Append( _( "Save viewport..." ) );
928 m_cbViewports->Append( _( "Delete viewport..." ) );
929
930 m_cbViewports->SetSelection( m_cbViewports->GetCount() - 3 );
931 m_lastSelectedViewport = nullptr;
932}
933
934
935void APPEARANCE_CONTROLS_3D::onViewportChanged( wxCommandEvent& aEvent )
936{
937 int count = m_cbViewports->GetCount();
938 int index = m_cbViewports->GetSelection();
939
940 if( index >= 0 && index < count - 3 )
941 {
942 VIEWPORT3D* viewport = static_cast<VIEWPORT3D*>( m_cbViewports->GetClientData( index ) );
943
944 wxCHECK( viewport, /* void */ );
945
946 doApplyViewport( *viewport );
947
948 if( !viewport->name.IsEmpty() )
949 {
950 m_viewportMRU.Remove( viewport->name );
951 m_viewportMRU.Insert( viewport->name, 0 );
952 }
953 }
954 else if( index == count - 2 )
955 {
956 // Save current state to new preset
957 wxString name;
958
959 wxTextEntryDialog dlg( wxGetTopLevelParent( this ), _( "Viewport name:" ),
960 _( "Save Viewport" ), name );
961
962 if( dlg.ShowModal() != wxID_OK )
963 {
965 m_cbViewports->SetStringSelection( m_lastSelectedViewport->name );
966 else
967 m_cbViewports->SetSelection( m_cbViewports->GetCount() - 3 );
968
969 return;
970 }
971
972 name = dlg.GetValue();
973 bool exists = m_viewports.count( name );
974
975 if( !exists )
976 {
978
979 index = m_cbViewports->Insert( name, index-1, static_cast<void*>( &m_viewports[name] ) );
980 }
981 else
982 {
984 index = m_cbViewports->FindString( name );
985 m_viewportMRU.Remove( name );
986 }
987
988 m_cbViewports->SetSelection( index );
989 m_viewportMRU.Insert( name, 0 );
990
991 return;
992 }
993 else if( index == count - 1 )
994 {
995 // Delete an existing viewport
996 wxArrayString headers;
997 std::vector<wxArrayString> items;
998
999 headers.Add( _( "Viewports" ) );
1000
1001 for( std::pair<const wxString, VIEWPORT3D>& pair : m_viewports )
1002 {
1003 wxArrayString item;
1004 item.Add( pair.first );
1005 items.emplace_back( item );
1006 }
1007
1008 EDA_LIST_DIALOG dlg( m_frame, _( "Delete Viewport" ), headers, items );
1009 dlg.SetListLabel( _( "Select viewport:" ) );
1010
1011 if( dlg.ShowModal() == wxID_OK )
1012 {
1013 wxString viewportName = dlg.GetTextSelection();
1014 int idx = m_cbViewports->FindString( viewportName );
1015
1016 if( idx != wxNOT_FOUND )
1017 {
1018 m_viewports.erase( viewportName );
1019 m_cbViewports->Delete( idx );
1020 m_viewportMRU.Remove( viewportName );
1021 }
1022 }
1023
1025 m_cbViewports->SetStringSelection( m_lastSelectedViewport->name );
1026 else
1027 m_cbViewports->SetSelection( m_cbViewports->GetCount() - 3 );
1028
1029 return;
1030 }
1031
1032 passOnFocus();
1033}
1034
1035
1036void APPEARANCE_CONTROLS_3D::onUpdateViewportsCb( wxUpdateUIEvent& aEvent )
1037{
1038 int count = m_cbViewports->GetCount();
1039 int index = m_cbViewports->GetSelection();
1040
1041 if( index >= 0 && index < count - 3 )
1042 {
1043 VIEWPORT3D* viewport = static_cast<VIEWPORT3D*>( m_cbViewports->GetClientData( index ) );
1044
1045 wxCHECK( viewport, /* void */ );
1046
1047 if( m_frame->GetCurrentCamera().GetViewMatrix() != viewport->matrix )
1048 m_cbViewports->SetSelection( -1 );
1049 }
1050}
1051
1052
1054{
1056
1057 if( m_frame->GetAdapter().m_Cfg->m_Render.engine == RENDER_ENGINE::OPENGL )
1059 else
1061}
1062
1063
1065{
1066 m_focusOwner->SetFocus();
1067}
1068
1069
const char * name
Definition: DXF_plotter.cpp:59
static std::vector< int > inStackupColors
#define RR
Render Row abbreviation to reduce source width.
wxBitmapBundle KiBitmapBundle(BITMAPS aBitmap, int aMinHeight)
Definition: bitmap.cpp:110
Container for an appearance setting (can control a layer class, object type, etc.)
Class APPEARANCE_CONTROLS_3D_BASE.
void OnLanguageChanged(wxCommandEvent &aEvent)
GRID_BITMAP_TOGGLE_RENDERER * m_toggleGridRenderer
void onLayerPresetChanged(wxCommandEvent &aEvent) override
void updateLayerPresetWidget(const wxString &aName)
std::vector< VIEWPORT3D > GetUserViewports() const
Return a list of viewports created by the user.
void ApplyViewport(const wxString &aPresetName)
void onColorSwatchChanged(COLOR_SWATCH *aSwatch)
APPEARANCE_CONTROLS_3D(EDA_3D_VIEWER_FRAME *aParent, wxWindow *aFocusOwner)
std::vector< std::unique_ptr< APPEARANCE_SETTING_3D > > m_layerSettings
std::map< int, APPEARANCE_SETTING_3D * > m_layerSettingsMap
static const APPEARANCE_SETTING_3D s_layerSettings[]
Template for object appearance settings.
void doApplyLayerPreset(const wxString &aPresetName)
EDA_3D_VIEWER_FRAME * m_frame
void onUpdateViewportsCb(wxUpdateUIEvent &aEvent) override
void OnSetFocus(wxFocusEvent &aEvent) override
void OnLayerVisibilityChanged(int aLayer, bool isVisible)
void OnSize(wxSizeEvent &aEvent) override
void doApplyViewport(const VIEWPORT3D &aViewport)
std::map< wxString, VIEWPORT3D > m_viewports
wxCheckBox * m_cbUseBoardEditorCopperColors
void ApplyLayerPreset(const wxString &aPresetName)
void onViewportChanged(wxCommandEvent &aEvent) override
void SetUserViewports(std::vector< VIEWPORT3D > &aPresetList)
Update the current viewports from those saved in the project file.
A checkbox control except with custom bitmaps for the checked and unchecked states.
Definition: bitmap_toggle.h:45
Helper class to handle information needed to display 3D board.
Definition: board_adapter.h:73
void SetVisibleLayers(const std::bitset< LAYER_3D_END > &aLayers)
std::map< int, COLOR4D > GetLayerColors() const
Build a color list which is used to store colors layers.
std::bitset< LAYER_3D_END > GetVisibleLayers() const
void SetLayerColors(const std::map< int, COLOR4D > &aColors)
EDA_3D_VIEWER_SETTINGS * m_Cfg
std::map< int, COLOR4D > GetDefaultColors() const
LSET GetEnabledLayers() const
A proxy function that calls the corresponding function in m_BoardSettings.
Definition: board.cpp:829
const wxString GetLayerName(PCB_LAYER_ID aLayer) const
Return the name of a aLayer.
Definition: board.cpp:614
const glm::mat4 & GetViewMatrix() const
Definition: camera.cpp:510
void SetViewMatrix(glm::mat4 aViewMatrix)
Set the affine matrix to be applied to a transformation camera.
Definition: camera.cpp:516
A simple color swatch of the kind used to set layer colors.
Definition: color_swatch.h:57
KIGFX::COLOR4D GetSwatchColor() const
void SetReadOnlyCallback(std::function< void()> aCallback)
Register a handler for when the user tries to interact with a read-only swatch.
Definition: color_swatch.h:126
int ShowModal() override
Class to handle configuration and automatic determination of the DPI scale to use for canvases.
double GetScaleFactor() const override
Get the DPI scale from all known sources in order:
static TOOL_ACTION showNotInPosFile
static TOOL_ACTION showTHT
static TOOL_ACTION showDNP
static TOOL_ACTION showSMD
static TOOL_ACTION showVirtual
static TOOL_ACTION showBBoxes
static TOOL_ACTION showAxis
RENDER_3D_BASE * GetCurrentRender() const
void RenderRaytracingRequest()
Request to render the current view in Raytracing mode.
void Request_refresh(bool aRedrawImmediately=true)
Schedule a refresh update of the canvas.
Create and handle a window for the 3d viewer connected to a Kiway and a pcbboard.
void NewDisplay(bool aForceImmediateRedraw=false)
Reload and refresh (rebuild) the 3D scene.
EDA_3D_CANVAS * GetCanvas()
BOARD_ADAPTER & GetAdapter()
LAYER_PRESET_3D * FindPreset(const wxString &aName)
std::vector< LAYER_PRESET_3D > m_LayerPresets
WX_INFOBAR * GetInfoBar()
A dialog which shows:
wxString GetTextSelection(int aColumn=0)
Return the selected text from aColumn in the wxListCtrl in the dialog.
void SetListLabel(const wxString &aLabel)
A toggle button renderer for a wxGrid, similar to BITMAP_TOGGLE.
A color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:104
LSET is a set of PCB_LAYER_IDs.
Definition: lset.h:37
Object to render the board using openGL.
void Load3dModelsIfNeeded()
Load footprint models if they are not already loaded, i.e.
A modified version of the wxInfoBar class that allows us to:
Definition: wx_infobar.h:76
void RemoveAllButtons()
Remove all the buttons that have been added by the user.
Definition: wx_infobar.cpp:353
void ShowMessageFor(const wxString &aMessage, int aTime, int aFlags=wxICON_INFORMATION, MESSAGE_TYPE aType=WX_INFOBAR::MESSAGE_TYPE::GENERIC)
Show the infobar with the provided message and icon for a specific period of time.
Definition: wx_infobar.cpp:140
void AddCloseButton(const wxString &aTooltip=_("Hide this message."))
Add the default close button to the infobar on the right side.
Definition: wx_infobar.cpp:343
void SetBorders(bool aLeft, bool aRight, bool aTop, bool aBottom)
Definition: wx_panel.h:39
@ SWATCH_SMALL
Definition: color_swatch.h:40
bool IsOK(wxWindow *aParent, const wxString &aMessage)
Display a yes/no dialog with aMessage and returns the user response.
Definition: confirm.cpp:249
This file is part of the common library.
#define _HKI(x)
#define _(s)
Declaration of the eda_3d_viewer class.
#define FOLLOW_PLOT_SETTINGS
#define FOLLOW_PCB
#define VIEWPORT_SWITCH_KEY
#define PRESET_SWITCH_KEY
wxString KeyNameFromKeyCode(int aKeycode, bool *aIsFound)
Return the key name from the key code.
PCB_LAYER_ID Map3DLayerToPCBLayer(int aLayer)
Definition: layer_id.cpp:265
@ LAYER_3D_USER_1
Definition: layer_ids.h:554
@ LAYER_3D_SOLDERMASK_TOP
Definition: layer_ids.h:547
@ LAYER_3D_USER_8
Definition: layer_ids.h:561
@ LAYER_3D_USER_22
Definition: layer_ids.h:575
@ LAYER_3D_USER_44
Definition: layer_ids.h:597
@ LAYER_3D_USER_23
Definition: layer_ids.h:576
@ LAYER_3D_USER_28
Definition: layer_ids.h:581
@ LAYER_3D_BOUNDING_BOXES
Definition: layer_ids.h:605
@ LAYER_3D_START
Definition: layer_ids.h:537
@ LAYER_3D_USER_32
Definition: layer_ids.h:585
@ LAYER_3D_USER_19
Definition: layer_ids.h:572
@ LAYER_3D_USER_25
Definition: layer_ids.h:578
@ LAYER_3D_ADHESIVE
Definition: layer_ids.h:549
@ LAYER_3D_USER_3
Definition: layer_ids.h:556
@ LAYER_3D_USER_21
Definition: layer_ids.h:574
@ LAYER_3D_USER_26
Definition: layer_ids.h:579
@ LAYER_3D_SMD_MODELS
Definition: layer_ids.h:600
@ LAYER_3D_USER_24
Definition: layer_ids.h:577
@ LAYER_3D_USER_43
Definition: layer_ids.h:596
@ LAYER_3D_BACKGROUND_TOP
Definition: layer_ids.h:540
@ LAYER_3D_USER_COMMENTS
Definition: layer_ids.h:550
@ LAYER_3D_SOLDERMASK_BOTTOM
Definition: layer_ids.h:546
@ LAYER_3D_USER_11
Definition: layer_ids.h:564
@ LAYER_3D_USER_41
Definition: layer_ids.h:594
@ LAYER_3D_USER_17
Definition: layer_ids.h:570
@ LAYER_3D_BOARD
Definition: layer_ids.h:541
@ LAYER_3D_USER_ECO1
Definition: layer_ids.h:552
@ LAYER_3D_USER_20
Definition: layer_ids.h:573
@ LAYER_3D_USER_31
Definition: layer_ids.h:584
@ LAYER_3D_USER_ECO2
Definition: layer_ids.h:553
@ LAYER_3D_TH_MODELS
Definition: layer_ids.h:599
@ LAYER_3D_USER_15
Definition: layer_ids.h:568
@ LAYER_3D_USER_38
Definition: layer_ids.h:591
@ LAYER_3D_USER_13
Definition: layer_ids.h:566
@ LAYER_3D_USER_33
Definition: layer_ids.h:586
@ LAYER_3D_USER_35
Definition: layer_ids.h:588
@ LAYER_3D_USER_29
Definition: layer_ids.h:582
@ LAYER_3D_AXES
Definition: layer_ids.h:604
@ LAYER_3D_USER_40
Definition: layer_ids.h:593
@ LAYER_3D_SILKSCREEN_TOP
Definition: layer_ids.h:545
@ LAYER_3D_VIRTUAL_MODELS
Definition: layer_ids.h:601
@ LAYER_3D_MODELS_MARKED_DNP
Definition: layer_ids.h:603
@ LAYER_3D_USER_7
Definition: layer_ids.h:560
@ LAYER_3D_COPPER_TOP
Definition: layer_ids.h:542
@ LAYER_3D_USER_12
Definition: layer_ids.h:565
@ LAYER_3D_SOLDERPASTE
Definition: layer_ids.h:548
@ LAYER_3D_USER_30
Definition: layer_ids.h:583
@ LAYER_3D_USER_36
Definition: layer_ids.h:589
@ LAYER_3D_USER_2
Definition: layer_ids.h:555
@ LAYER_3D_USER_18
Definition: layer_ids.h:571
@ LAYER_3D_OFF_BOARD_SILK
Definition: layer_ids.h:606
@ LAYER_3D_USER_14
Definition: layer_ids.h:567
@ LAYER_3D_USER_5
Definition: layer_ids.h:558
@ LAYER_3D_USER_37
Definition: layer_ids.h:590
@ LAYER_3D_USER_10
Definition: layer_ids.h:563
@ LAYER_3D_MODELS_NOT_IN_POS
Definition: layer_ids.h:602
@ LAYER_3D_USER_42
Definition: layer_ids.h:595
@ LAYER_3D_USER_45
Definition: layer_ids.h:598
@ LAYER_3D_USER_6
Definition: layer_ids.h:559
@ LAYER_3D_USER_4
Definition: layer_ids.h:557
@ LAYER_3D_USER_27
Definition: layer_ids.h:580
@ LAYER_3D_USER_DRAWINGS
Definition: layer_ids.h:551
@ LAYER_3D_COPPER_BOTTOM
Definition: layer_ids.h:543
@ LAYER_3D_USER_39
Definition: layer_ids.h:592
@ LAYER_3D_USER_9
Definition: layer_ids.h:562
@ LAYER_3D_BACKGROUND_BOTTOM
Definition: layer_ids.h:539
@ LAYER_3D_USER_16
Definition: layer_ids.h:569
@ LAYER_3D_SILKSCREEN_BOTTOM
Definition: layer_ids.h:544
@ LAYER_3D_USER_34
Definition: layer_ids.h:587
@ LAYER_3D_END
Definition: layer_ids.h:608
@ LAYER_FP_REFERENCES
Show footprints references (when texts are visible).
Definition: layer_ids.h:265
@ LAYER_FP_TEXT
Definition: layer_ids.h:239
@ LAYER_FP_VALUES
Show footprints values (when texts are visible).
Definition: layer_ids.h:262
PCB_LAYER_ID
A quick note on layer IDs:
Definition: layer_ids.h:60
@ UNDEFINED_LAYER
Definition: layer_ids.h:61
KICOMMON_API wxFont GetInfoFont(wxWindow *aWindow)
Definition: ui_common.cpp:156
const int c_IndicatorSizeDIP
Definition: ui_common.h:52
void delete_if(_Container &__c, _Function &&__f)
Deletes all values from __c for which __f returns true.
Definition: kicad_algo.h:174
bool contains(const _Container &__container, _Value __value)
Returns true if the container contains the given value.
Definition: kicad_algo.h:100
void Refresh()
Update the board display after modifying it by a python script (note: it is automatically called by a...
see class PGM_BASE
wxString name
A name for this layer set.