KiCad PCB EDA Suite
Loading...
Searching...
No Matches
sel_layer.cpp
Go to the documentation of this file.
1
5/*
6 * This program source code file is part of KiCad, a free EDA CAD application.
7 *
8 * Copyright (C) 2013 Jean-Pierre Charras, jp.charras at wanadoo.fr
9 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
10 *
11 * This program is free software: you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License as published by the
13 * Free Software Foundation, either version 3 of the License, or (at your
14 * option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful, but
17 * WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License along
22 * with this program. If not, see <http://www.gnu.org/licenses/>.
23 */
24
25#include <wx/bitmap.h>
26
27#include <kiplatform/ui.h>
28#include <confirm.h>
29#include <lset.h>
30#include <board.h>
31#include <pgm_base.h>
32#include <project.h>
33#include <pcb_base_frame.h>
36#include <layer_pairs.h>
39#include <router/router_tool.h>
42#include <tools/pcb_actions.h>
46#include <widgets/wx_grid.h>
49
50
51// Column position by function:
52#define SELECT_COLNUM 0
53#define COLOR_COLNUM 1
54#define LAYERNAME_COLNUM 2
55#define LAYER_HK_COLUMN 3
56
57
59{
60}
61
63{
64 if( m_boardFrame )
65 {
66 return m_boardFrame->GetColorSettings()->GetColor( aLayer );
67 }
68 else
69 {
70 FOOTPRINT_EDITOR_SETTINGS* cfg = GetAppSettings<FOOTPRINT_EDITOR_SETTINGS>( "fpedit" );
72
73 return current->GetColor( aLayer );
74 }
75}
76
77wxString PCB_LAYER_PRESENTATION::getLayerName( int aLayer ) const
78{
79 if( m_boardFrame )
80 return m_boardFrame->GetBoard()->GetLayerName( ToLAYER_ID( aLayer ) );
81 else
82 return BOARD::GetStandardLayerName( ToLAYER_ID( aLayer ) );
83}
84
86{
88}
89
91{
92 const wxString layerAName = getLayerName( aPair.GetLayerA() );
93 const wxString layerBName = getLayerName( aPair.GetLayerB() );
94
95 return layerAName + wxT( " / " ) + layerBName;
96}
97
98
103{
104public:
105 PCB_ONE_LAYER_SELECTOR( PCB_BASE_FRAME* aParent, PCB_LAYER_ID aDefaultLayer,
106 LSET aNotAllowedLayersMask, bool aHideCheckBoxes = false );
108
110
111private:
112 // Event handlers
113 void OnLeftGridCellClick( wxGridEvent& aEvent ) override;
114 void OnRightGridCellClick( wxGridEvent& aEvent ) override;
115 void OnMouseMove( wxUpdateUIEvent& aEvent ) override;
116
117 // Will close the dialog on ESC key
118 void onCharHook( wxKeyEvent& event );
119
120 wxString getLayerHotKey( PCB_LAYER_ID aLayer ) const
121 {
122 int code = PCB_ACTIONS::LayerIDToAction( aLayer )->GetHotKey();
123 return AddHotkeyName( wxS( "" ), code, IS_COMMENT );
124 }
125
126 void buildList();
127
131 std::vector<PCB_LAYER_ID> m_layersIdLeftColumn;
132 std::vector<PCB_LAYER_ID> m_layersIdRightColumn;
133};
134
135
137 LSET aNotAllowedLayersMask, bool aHideCheckBoxes ) :
138 DIALOG_LAYER_SELECTION_BASE( aParent ), m_layerPresentation( aParent )
139{
140 m_useCalculatedSize = true;
141
142 m_layerSelected = aDefaultLayer;
143 m_notAllowedLayersMask = aNotAllowedLayersMask;
144
145 m_leftGridLayers->SetCellHighlightPenWidth( 0 );
146 m_rightGridLayers->SetCellHighlightPenWidth( 0 );
147 m_leftGridLayers->SetColFormatBool( SELECT_COLNUM );
148 m_rightGridLayers->SetColFormatBool( SELECT_COLNUM );
149
150 m_leftGridLayers->AppendCols( 1 );
151
152 buildList();
153
154 if( aHideCheckBoxes )
155 {
158 }
159
160 Connect( wxEVT_CHAR_HOOK, wxKeyEventHandler( PCB_ONE_LAYER_SELECTOR::onCharHook ) );
161
162 Layout();
163 GetSizer()->SetSizeHints( this );
164 SetFocus();
165}
166
167
169{
170 Disconnect( wxEVT_CHAR_HOOK, wxKeyEventHandler( PCB_ONE_LAYER_SELECTOR::onCharHook ) );
171}
172
173
174void PCB_ONE_LAYER_SELECTOR::OnMouseMove( wxUpdateUIEvent& aEvent )
175{
179
180 wxPoint mouse_pos = KIPLATFORM::UI::GetMousePosition();
181 wxPoint left_pos = m_leftGridLayers->ScreenToClient( mouse_pos );
182 wxPoint right_pos = m_rightGridLayers->ScreenToClient( mouse_pos );
183
184 if( m_leftGridLayers->HitTest( left_pos ) == wxHT_WINDOW_INSIDE )
185 {
186 int row = m_leftGridLayers->YToRow( left_pos.y );
187
188 if( row != wxNOT_FOUND && row < static_cast<int>( m_layersIdLeftColumn.size() ) )
189 {
191 m_leftGridLayers->SelectBlock( row, LAYERNAME_COLNUM, row, LAYER_HK_COLUMN );
192 return;
193 }
194 }
195
196 if( m_rightGridLayers->HitTest( right_pos ) == wxHT_WINDOW_INSIDE )
197 {
198 int row = m_rightGridLayers->YToRow( right_pos.y );
199
200 if( row == wxNOT_FOUND || row >= static_cast<int>( m_layersIdRightColumn.size() ) )
201 return;
202
204 m_rightGridLayers->SelectBlock( row, LAYERNAME_COLNUM, row, LAYERNAME_COLNUM );
205 }
206}
207
208
209void PCB_ONE_LAYER_SELECTOR::onCharHook( wxKeyEvent& event )
210{
211 if( event.GetKeyCode() == WXK_ESCAPE )
212 Close();
213}
214
215
217{
219 int left_row = 0;
220 int right_row = 0;
221 wxString layername;
222
224 {
225 if( m_notAllowedLayersMask[layerid] )
226 continue;
227
228 wxColour fg = m_layerPresentation.getLayerColor( layerid ).ToColour();
229 wxColour color( wxColour::AlphaBlend( fg.Red(), bg.Red(), fg.Alpha() / 255.0 ),
230 wxColour::AlphaBlend( fg.Green(), bg.Green(), fg.Alpha() / 255.0 ),
231 wxColour::AlphaBlend( fg.Blue(), bg.Blue(), fg.Alpha() / 255.0 ) );
232
233 layername = wxT( " " ) + m_layerPresentation.getLayerName( layerid );
234
235 if( IsCopperLayer( layerid ) )
236 {
237 if( left_row )
238 m_leftGridLayers->AppendRows( 1 );
239
240 m_leftGridLayers->SetCellBackgroundColour( left_row, COLOR_COLNUM, color );
241 m_leftGridLayers->SetCellValue( left_row, LAYERNAME_COLNUM, layername );
242 m_leftGridLayers->SetCellValue( left_row, LAYER_HK_COLUMN, getLayerHotKey( layerid ) );
243
244 if( m_layerSelected == layerid )
245 m_leftGridLayers->SetCellValue( left_row, SELECT_COLNUM, wxT( "1" ) );
246
247 m_layersIdLeftColumn.push_back( layerid );
248 left_row++;
249 }
250 else
251 {
252 if( right_row )
253 m_rightGridLayers->AppendRows( 1 );
254
255 m_rightGridLayers->SetCellBackgroundColour( right_row, COLOR_COLNUM, color );
256 m_rightGridLayers->SetCellValue( right_row, LAYERNAME_COLNUM, layername );
257
258 if( m_layerSelected == layerid )
259 m_rightGridLayers->SetCellValue( right_row, SELECT_COLNUM, wxT( "1" ) );
260
261 m_layersIdRightColumn.push_back( layerid );
262 right_row++;
263 }
264 }
265
266 // Show only populated lists:
267 if( left_row <= 0 )
268 m_leftGridLayers->Show( false );
269
270 if( right_row <= 0 )
271 m_rightGridLayers->Show( false );
272
273 // Now fix min grid column size (it also sets a minimal size)
274 m_leftGridLayers->AutoSizeColumns();
275 m_rightGridLayers->AutoSizeColumns();
276}
277
278
280{
281 m_layerSelected = m_layersIdLeftColumn[event.GetRow()];
282
283 if( IsQuasiModal() )
284 EndQuasiModal( 1 );
285 else
286 EndDialog( 1 );
287}
288
289
291{
292 m_layerSelected = m_layersIdRightColumn[event.GetRow()];
293
294 if( IsQuasiModal() )
295 EndQuasiModal( 2 );
296 else
297 EndDialog( 2 );
298}
299
300
302 const LSET& aNotAllowedLayersMask,
303 wxPoint aDlgPosition )
304{
305 PCB_ONE_LAYER_SELECTOR dlg( this, aDefaultLayer, aNotAllowedLayersMask, true );
306
307 if( aDlgPosition != wxDefaultPosition )
308 {
309 wxSize dlgSize = dlg.GetSize();
310 aDlgPosition.x -= dlgSize.x / 2;
311 aDlgPosition.y -= dlgSize.y / 2;
312 dlg.SetPosition( aDlgPosition );
313 }
314
315 if( dlg.ShowModal() != wxID_CANCEL )
316 return ToLAYER_ID( dlg.GetLayerSelection() );
317 else
318 return UNDEFINED_LAYER;
319}
320
321
327{
328 enum class COLNUMS
329 {
330 ENABLED,
331 SWATCH,
333 USERNAME,
334 };
335
336public:
338 LAYER_PAIR_SETTINGS& aLayerPairSettings ) :
339 m_layerPresentation( aPresentation ), m_grid( aGrid ),
340 m_layerPairSettings( aLayerPairSettings )
341 {
342 wxASSERT_MSG( m_grid.GetNumberRows() == 0, "Grid should be empty at controller start" );
343
346
347 m_grid.Bind( wxEVT_GRID_CELL_CHANGED,
348 [this]( wxGridEvent& aEvent )
349 {
350 const int col = aEvent.GetCol();
351 const int row = aEvent.GetRow();
352 if( col == (int) COLNUMS::USERNAME )
353 {
354 onUserNameChanged( row, m_grid.GetCellValue( row, col ) );
355 }
356 else if( col == (int) COLNUMS::ENABLED )
357 {
358 onEnableChanged( row, m_grid.GetCellValue( row, col ) == wxS( "1" ) );
359 }
360 } );
361
362 m_grid.Bind( wxEVT_GRID_CELL_LEFT_DCLICK,
363 [&]( wxGridEvent& aEvent )
364 {
365 const int row = aEvent.GetRow();
366 const int col = aEvent.GetCol();
367
368 if( col == (int) COLNUMS::LAYERNAMES || col == (int) COLNUMS::SWATCH )
369 {
370 onPairActivated( row );
371 }
372 } );
373
375 std::make_unique<WX_GRID_AUTOSIZER>( m_grid,
377 { (int) COLNUMS::LAYERNAMES, 72 },
378 { (int) COLNUMS::USERNAME, 72 },
379 },
380 (int) COLNUMS::USERNAME );
381 }
382
383 void OnLayerPairAdded( const LAYER_PAIR& aLayerPair )
384 {
385 LAYER_PAIR_INFO layerPairInfo{ aLayerPair, true, std::nullopt };
386
387 const bool added = m_layerPairSettings.AddLayerPair( layerPairInfo );
388
389 if( added )
390 {
391 m_grid.AppendRows( 1 );
392 fillRowFromLayerPair( m_grid.GetNumberRows() - 1, layerPairInfo );
393 }
394 }
395
397 {
398 int row = m_grid.GetGridCursorRow();
399
400 const LAYER_PAIR_INFO& layerPairInfo = m_layerPairSettings.GetLayerPairs()[row];
401 const bool removed = m_layerPairSettings.RemoveLayerPair( layerPairInfo.GetLayerPair() );
402
403 if( removed )
404 {
405 m_grid.DeleteRows( row );
406 }
407 }
408
409private:
411 {
412 m_grid.UseNativeColHeader( true );
413
414 m_grid.SetCellHighlightPenWidth( 0 );
415 m_grid.SetColFormatBool( (int) COLNUMS::ENABLED );
416
417 m_grid.SetSelectionMode( wxGrid::wxGridSelectionModes::wxGridSelectRows );
418
419 m_grid.AutoSizeColumn( (int) COLNUMS::USERNAME );
420 }
421
423 {
424 std::span<const LAYER_PAIR_INFO> storePairs = m_layerPairSettings.GetLayerPairs();
425
426 m_grid.AppendRows( storePairs.size() );
427
428 int row = 0;
429 for( const LAYER_PAIR_INFO& layerPairInfo : storePairs )
430 {
431 fillRowFromLayerPair( row, layerPairInfo );
432 row++;
433 }
434 }
435
436 void fillRowFromLayerPair( int aRow, const LAYER_PAIR_INFO& aLayerPairInfo )
437 {
438 wxASSERT_MSG( aRow < m_grid.GetNumberRows(), "Row index out of bounds" );
439
440 const LAYER_PAIR& layerPair = aLayerPairInfo.GetLayerPair();
441
442 const wxString layerNames = m_layerPresentation.getLayerPairName( layerPair );
443
444 m_grid.SetCellValue( aRow, (int) COLNUMS::LAYERNAMES, layerNames );
445
446 const std::optional<wxString> userName = aLayerPairInfo.GetName();
447 if( userName )
448 {
449 m_grid.SetCellValue( aRow, (int) COLNUMS::USERNAME, *userName );
450 }
451
452 m_grid.SetCellValue( aRow, (int) COLNUMS::ENABLED,
453 aLayerPairInfo.IsEnabled() ? wxT( "1" ) : wxT( "0" ) );
454
455 // Set the color swatch
456 std::unique_ptr<wxBitmap>& swatch =
458 layerPair.GetLayerA(), layerPair.GetLayerB(), KiIconScale( &m_grid ) ) );
459
460 m_grid.SetCellRenderer( aRow, (int) COLNUMS::SWATCH,
461 new GRID_CELL_ICON_RENDERER( *swatch ) );
462
463 m_grid.SetReadOnly( aRow, (int) COLNUMS::SWATCH );
464 m_grid.SetReadOnly( aRow, (int) COLNUMS::LAYERNAMES );
465 }
466
467 void onUserNameChanged( int aRow, const wxString& aNewValue )
468 {
470 changedPair.SetName( aNewValue );
471 }
472
473 void onEnableChanged( int aRow, bool aNewValue )
474 {
476 changedPair.SetEnabled( aNewValue );
477 }
478
479 void onPairActivated( int aRow )
480 {
481 const LAYER_PAIR_INFO& layerPairInfo = m_layerPairSettings.GetLayerPairs()[aRow];
482 const LAYER_PAIR& layerPair = layerPairInfo.GetLayerPair();
483
485 }
486
490
491 // Lifetime managment of the swatches
492 std::vector<std::unique_ptr<wxBitmap>> m_swatches;
493
494 std::unique_ptr<WX_GRID_AUTOSIZER> m_autosizer;
495};
496
497
503{
505 {
506 SELECT = 0,
507 COLOR = 1,
508 LAYERNAME = 2,
509 };
510
511public:
512 COPPER_LAYERS_PAIR_SELECTION_UI( wxGrid& aLeftGrid, wxGrid& aRightGrid,
513 PCB_LAYER_PRESENTATION& aPresentation,
514 LAYER_PAIR_SETTINGS& aLayerPairSettings ) :
515 m_layerPresentation( aPresentation ), m_layerPairSettings( aLayerPairSettings ),
516 m_leftGrid( aLeftGrid ), m_rightGrid( aRightGrid )
517 {
520
522 {
523 if( IsCopperLayer( layerId ) )
524 {
525 m_layersId.push_back( layerId );
526 }
527 }
528
531
532 m_leftGrid.Bind( wxEVT_GRID_CELL_LEFT_CLICK,
533 [this]( wxGridEvent& aEvent )
534 {
535 onLeftGridRowSelected( aEvent.GetRow() );
536 } );
537
538 m_rightGrid.Bind( wxEVT_GRID_CELL_LEFT_CLICK,
539 [this]( wxGridEvent& aEvent )
540 {
541 onRightGridRowSelected( aEvent.GetRow() );
542 } );
543
544 m_layerPairSettings.Bind( PCB_CURRENT_LAYER_PAIR_CHANGED,
545 [this]( wxCommandEvent& aEvent )
546 {
547 const LAYER_PAIR& newPair =
550 rowForLayer( newPair.GetLayerB() ) );
551 } );
552 }
553
554private:
555 void configureGrid( wxGrid& aGrid )
556 {
557 aGrid.SetCellHighlightPenWidth( 0 );
558 aGrid.SetColFormatBool( (int) CU_LAYER_COLNUMS::SELECT );
559 }
560
561 void fillLayerGrid( wxGrid& aGrid )
562 {
564
565 aGrid.AppendRows( m_layersId.size() - 1 );
566
567 int row = 0;
568 for( const PCB_LAYER_ID& layerId : m_layersId )
569 {
570 const wxColour fg = m_layerPresentation.getLayerColor( layerId ).ToColour();
571 const wxColour color(
572 wxColour::AlphaBlend( fg.Red(), bg.Red(), fg.Alpha() / 255.0 ),
573 wxColour::AlphaBlend( fg.Green(), bg.Green(), fg.Alpha() / 255.0 ),
574 wxColour::AlphaBlend( fg.Blue(), bg.Blue(), fg.Alpha() / 255.0 ) );
575
576 const wxString layerName = wxT( " " ) + m_layerPresentation.getLayerName( layerId );
577
578 aGrid.SetCellBackgroundColour( row, (int) CU_LAYER_COLNUMS::COLOR, color );
579 aGrid.SetCellValue( row, (int) CU_LAYER_COLNUMS::LAYERNAME, layerName );
580
581 row++;
582 };
583
584 // Now fix min grid layer name column size (it also sets a minimal size)
585 aGrid.AutoSizeColumn( (int) CU_LAYER_COLNUMS::LAYERNAME );
586 }
587
588 PCB_LAYER_ID layerForRow( int aRow ) { return m_layersId.at( aRow ); }
589
590 int rowForLayer( PCB_LAYER_ID aLayerId )
591 {
592 for( unsigned i = 0; i < m_layersId.size(); ++i )
593 {
594 if( m_layersId[i] == aLayerId )
595 {
596 return i;
597 }
598 }
599
600 wxASSERT_MSG( false, wxString::Format( "Unknown layer in grid: %d", aLayerId ) );
601 return 0;
602 }
603
604 void onLeftGridRowSelected( int aRow )
605 {
606 LAYER_PAIR newPair{
607 layerForRow( aRow ),
609 };
612 }
613
614 void onRightGridRowSelected( int aRow )
615 {
616 LAYER_PAIR newPair{
618 layerForRow( aRow ),
619 };
622 }
623
630 void setCurrentSelection( int aLeftRow, int aRightRow )
631 {
632 const auto selectGridRow = []( wxGrid& aGrid, int aRow, bool aSelect )
633 {
634 // At start, there is no old row
635 if( aRow < 0 )
636 {
637 return;
638 }
639 const wxString val = aSelect ? wxT( "1" ) : wxEmptyString;
640 aGrid.SetCellValue( aRow, (int) CU_LAYER_COLNUMS::SELECT, val );
641 aGrid.SetGridCursor( aRow, (int) CU_LAYER_COLNUMS::COLOR );
642 };
643
644 if( m_leftCurrRow != aLeftRow )
645 {
646 selectGridRow( m_leftGrid, m_leftCurrRow, false );
647 selectGridRow( m_leftGrid, aLeftRow, true );
648 m_leftCurrRow = aLeftRow;
649 }
650
651 if( m_rightCurrRow != aRightRow )
652 {
653 selectGridRow( m_rightGrid, m_rightCurrRow, false );
654 selectGridRow( m_rightGrid, aRightRow, true );
655 m_rightCurrRow = aRightRow;
656 }
657 }
658
661 std::vector<PCB_LAYER_ID> m_layersId;
662 wxGrid& m_leftGrid;
663 wxGrid& m_rightGrid;
664
667};
668
669
677{
678public:
680 LAYER_PAIR_SETTINGS& aBoardSettings ) :
682 m_boardPairSettings( aBoardSettings ), m_dialogPairSettings( aBoardSettings ),
683 m_layerPresentation( &aParent ),
687 {
688 m_addToPresetsButton->SetBitmap( KiBitmapBundle( BITMAPS::right ) );
689 m_deleteRowButton->SetBitmap( KiBitmapBundle( BITMAPS::small_trash ) );
690
691 m_addToPresetsButton->Bind( wxEVT_BUTTON,
692 [this]( wxCommandEvent& aEvent )
693 {
694 const LAYER_PAIR newPair =
697 } );
698
699 m_deleteRowButton->Bind( wxEVT_BUTTON,
700 [this]( wxCommandEvent& aEvent )
701 {
703 } );
704
705 SetFocus();
706
707 GetSizer()->SetSizeHints( this );
708 Center();
709 }
710
711 bool TransferDataToWindow() override
712 {
713 m_presetsGrid->Freeze();
714 m_leftGridLayers->Freeze();
715 m_rightGridLayers->Freeze();
716
718
719 m_rightGridLayers->Thaw();
720 m_leftGridLayers->Thaw();
721 m_presetsGrid->Thaw();
722 return true;
723 }
724
726 {
727 // Pull out the dialog's stored pairs
728 std::span<const LAYER_PAIR_INFO> storePairs = m_dialogPairSettings.GetLayerPairs();
729
732
733 return true;
734 }
735
736private:
737 // The BOARD's pair store to be updated
739 // A local copy while we modify it
741 // Information about the layer presentation (colors, etc)
743 // UI controllers
746};
747
748
750{
751 LAYER_PAIR_SETTINGS* const boardSettings = frame()->GetLayerPairSettings();
752
753 if( !boardSettings )
754 {
755 // Should only be used for suitable frame types with layer pairs
756 wxASSERT_MSG( false, "Could not access layer pair settings" );
757 return 0;
758 }
759
760 SELECT_COPPER_LAYERS_PAIR_DIALOG dlg( *frame(), *boardSettings );
761
762 if( dlg.ShowModal() == wxID_OK )
763 {
764 const LAYER_PAIR layerPair = boardSettings->GetCurrentLayerPair();
765
766 // select the same layer for both layers is allowed (normal in some boards)
767 // but could be a mistake. So display an info message
768 if( layerPair.GetLayerA() == layerPair.GetLayerB() )
769 {
770 DisplayInfoMessage( frame(), _( "Warning: top and bottom layers are same." ) );
771 }
772 }
773
774 return 0;
775}
int color
Definition: DXF_plotter.cpp:63
int KiIconScale(wxWindow *aWindow)
Return the automatic scale factor that would be used for a given window by KiScaledBitmap and KiScale...
Definition: bitmap.cpp:122
wxBitmapBundle KiBitmapBundle(BITMAPS aBitmap, int aMinHeight)
Definition: bitmap.cpp:110
wxString m_ColorTheme
Active color theme name.
Definition: app_settings.h:235
static wxString GetStandardLayerName(PCB_LAYER_ID aLayerId)
Return an "English Standard" name of a PCB layer when given aLayerNumber.
Definition: board.h:837
const wxString GetLayerName(PCB_LAYER_ID aLayer) const
Return the name of a aLayer.
Definition: board.cpp:614
const LSET & GetEnabledLayers() const
A proxy function that calls the corresponding function in m_BoardSettings.
Definition: board.cpp:829
Color settings are a bit different than most of the settings objects in that there can be more than o...
COLOR4D GetColor(int aLayer) const
Class that manages the UI for the copper layer pair presets list based on an injected layer pair stor...
Definition: sel_layer.cpp:327
void onPairActivated(int aRow)
Definition: sel_layer.cpp:479
void onUserNameChanged(int aRow, const wxString &aNewValue)
Definition: sel_layer.cpp:467
std::vector< std::unique_ptr< wxBitmap > > m_swatches
Definition: sel_layer.cpp:492
COPPER_LAYERS_PAIR_PRESETS_UI(WX_GRID &aGrid, PCB_LAYER_PRESENTATION &aPresentation, LAYER_PAIR_SETTINGS &aLayerPairSettings)
Definition: sel_layer.cpp:337
LAYER_PAIR_SETTINGS & m_layerPairSettings
Definition: sel_layer.cpp:489
void OnLayerPairAdded(const LAYER_PAIR &aLayerPair)
Definition: sel_layer.cpp:383
void fillRowFromLayerPair(int aRow, const LAYER_PAIR_INFO &aLayerPairInfo)
Definition: sel_layer.cpp:436
void onEnableChanged(int aRow, bool aNewValue)
Definition: sel_layer.cpp:473
std::unique_ptr< WX_GRID_AUTOSIZER > m_autosizer
Definition: sel_layer.cpp:494
PCB_LAYER_PRESENTATION & m_layerPresentation
Definition: sel_layer.cpp:487
Class that manages the UI for the copper layer pair selection (left and right grids).
Definition: sel_layer.cpp:503
void setCurrentSelection(int aLeftRow, int aRightRow)
Set the current layer selection.
Definition: sel_layer.cpp:630
void onRightGridRowSelected(int aRow)
Definition: sel_layer.cpp:614
COPPER_LAYERS_PAIR_SELECTION_UI(wxGrid &aLeftGrid, wxGrid &aRightGrid, PCB_LAYER_PRESENTATION &aPresentation, LAYER_PAIR_SETTINGS &aLayerPairSettings)
Definition: sel_layer.cpp:512
PCB_LAYER_PRESENTATION & m_layerPresentation
Definition: sel_layer.cpp:659
void configureGrid(wxGrid &aGrid)
Definition: sel_layer.cpp:555
void fillLayerGrid(wxGrid &aGrid)
Definition: sel_layer.cpp:561
int rowForLayer(PCB_LAYER_ID aLayerId)
Definition: sel_layer.cpp:590
LAYER_PAIR_SETTINGS & m_layerPairSettings
Definition: sel_layer.cpp:660
PCB_LAYER_ID layerForRow(int aRow)
Definition: sel_layer.cpp:588
std::vector< PCB_LAYER_ID > m_layersId
Definition: sel_layer.cpp:661
void onLeftGridRowSelected(int aRow)
Definition: sel_layer.cpp:604
Class DIALOG_COPPER_LAYER_PAIR_SELECTION_BASE.
Class DIALOG_LAYER_SELECTION_BASE.
bool IsQuasiModal() const
Definition: dialog_shim.h:77
bool m_useCalculatedSize
Definition: dialog_shim.h:198
void EndQuasiModal(int retCode)
void SetPosition(const wxPoint &aNewPosition)
Force the position of the dialog to a new position.
int ShowModal() override
A color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:104
wxColour ToColour() const
Definition: color4d.cpp:220
All information about a layer pair as stored in the layer pair store.
const LAYER_PAIR & GetLayerPair() const
void SetName(const wxString &aNewName)
const std::optional< wxString > & GetName() const
void SetEnabled(bool aNewEnabled)
Management class for layer pairs in a PCB.
Definition: layer_pairs.h:47
bool AddLayerPair(LAYER_PAIR_INFO aPair)
Definition: layer_pairs.cpp:78
std::span< const LAYER_PAIR_INFO > GetLayerPairs() const
Returns a span of all stored layer pairs.
void SetCurrentLayerPair(const LAYER_PAIR &aPair)
Set the "active" layer pair.
void SetLayerPairs(std::span< const LAYER_PAIR_INFO > aPairs)
Replace the stored layer pairs with the given list.
bool RemoveLayerPair(const LAYER_PAIR &aPair)
Remove the matching layer pair from the store, if present.
const LAYER_PAIR & GetCurrentLayerPair() const
Definition: layer_pairs.h:87
PCB_LAYER_ID GetLayerA() const
PCB_LAYER_ID GetLayerB() const
static std::unique_ptr< wxBitmap > CreateLayerPairIcon(const KIGFX::COLOR4D &aBgColor, const KIGFX::COLOR4D &aTopColor, const KIGFX::COLOR4D &aBottomColor, int aScale)
Create a layer pair "side-by-side swatch" icon.
LSEQ is a sequence (and therefore also a set) of PCB_LAYER_IDs.
Definition: lseq.h:47
LSET is a set of PCB_LAYER_IDs.
Definition: lset.h:37
LSEQ UIOrder() const
Return the copper, technical and user layers in the order shown in layer widget.
Definition: lset.cpp:736
static TOOL_ACTION * LayerIDToAction(PCB_LAYER_ID aLayerID)
Translate a layer ID into the action that switches to that layer.
Base PCB main window class for Pcbnew, Gerbview, and CvPcb footprint viewer.
BOARD * GetBoard() const
PCB_LAYER_ID SelectOneLayer(PCB_LAYER_ID aDefaultLayer, const LSET &aNotAllowedLayersMask=LSET(), wxPoint aDlgPosition=wxDefaultPosition)
Show the dialog box for a layer selection.
Definition: sel_layer.cpp:301
virtual COLOR_SETTINGS * GetColorSettings(bool aForceRefresh=false) const override
Helper to retrieve the current color settings.
Class that manages the presentation of PCB layers in a PCB frame.
wxString getLayerName(int aLayer) const override
Definition: sel_layer.cpp:77
PCB_LAYER_PRESENTATION(PCB_BASE_FRAME *aFrame)
Definition: sel_layer.cpp:58
LSEQ getOrderedEnabledLayers() const
Definition: sel_layer.cpp:85
COLOR4D getLayerColor(int aLayer) const override
Definition: sel_layer.cpp:62
wxString getLayerPairName(const LAYER_PAIR &aPair) const
Definition: sel_layer.cpp:90
Display a PCB layers list in a dialog to select one layer from this list.
Definition: sel_layer.cpp:103
void OnLeftGridCellClick(wxGridEvent &aEvent) override
Definition: sel_layer.cpp:279
PCB_LAYER_PRESENTATION m_layerPresentation
Definition: sel_layer.cpp:128
void OnRightGridCellClick(wxGridEvent &aEvent) override
Definition: sel_layer.cpp:290
void onCharHook(wxKeyEvent &event)
Definition: sel_layer.cpp:209
std::vector< PCB_LAYER_ID > m_layersIdLeftColumn
Definition: sel_layer.cpp:131
std::vector< PCB_LAYER_ID > m_layersIdRightColumn
Definition: sel_layer.cpp:132
void OnMouseMove(wxUpdateUIEvent &aEvent) override
Definition: sel_layer.cpp:174
PCB_LAYER_ID m_layerSelected
Definition: sel_layer.cpp:129
PCB_ONE_LAYER_SELECTOR(PCB_BASE_FRAME *aParent, PCB_LAYER_ID aDefaultLayer, LSET aNotAllowedLayersMask, bool aHideCheckBoxes=false)
Definition: sel_layer.cpp:136
wxString getLayerHotKey(PCB_LAYER_ID aLayer) const
Definition: sel_layer.cpp:120
T * frame() const
int SelectCopperLayerPair(const TOOL_EVENT &aEvent)
Definition: sel_layer.cpp:749
Display a pair PCB copper layers list in a dialog to select a layer pair from these lists.
Definition: sel_layer.cpp:677
bool TransferDataToWindow() override
Definition: sel_layer.cpp:711
PCB_LAYER_PRESENTATION m_layerPresentation
Definition: sel_layer.cpp:742
LAYER_PAIR_SETTINGS & m_boardPairSettings
Definition: sel_layer.cpp:738
SELECT_COPPER_LAYERS_PAIR_DIALOG(PCB_BASE_FRAME &aParent, LAYER_PAIR_SETTINGS &aBoardSettings)
Definition: sel_layer.cpp:679
COPPER_LAYERS_PAIR_PRESETS_UI m_presetsGridController
Definition: sel_layer.cpp:745
COPPER_LAYERS_PAIR_SELECTION_UI m_pairSelectionController
Definition: sel_layer.cpp:744
bool TransferDataFromWindow() override
Definition: sel_layer.cpp:725
LAYER_PAIR_SETTINGS m_dialogPairSettings
Definition: sel_layer.cpp:740
void SetBitmap(const wxBitmapBundle &aBmp)
int GetHotKey() const
Return the hotkey keycode which initiates the action.
Definition: tool_action.h:348
Generic, UI-independent tool event.
Definition: tool_event.h:168
std::map< int, int > COL_MIN_WIDTHS
Map of column indices to minimum widths.
void DisplayInfoMessage(wxWindow *aParent, const wxString &aMessage, const wxString &aExtraInfo)
Display an informational message box with aMessage.
Definition: confirm.cpp:231
This file is part of the common library.
#define _(s)
wxString AddHotkeyName(const wxString &aText, int aHotKey, HOTKEY_ACTION_TYPE aStyle)
@ IS_COMMENT
Definition: hotkeys_basic.h:82
bool IsCopperLayer(int aLayerId)
Test whether a layer is a copper layer.
Definition: layer_ids.h:664
@ LAYER_PCB_BACKGROUND
PCB background color.
Definition: layer_ids.h:280
PCB_LAYER_ID
A quick note on layer IDs:
Definition: layer_ids.h:60
@ UNDEFINED_LAYER
Definition: layer_ids.h:61
PCB_LAYER_ID ToLAYER_ID(int aLayer)
Definition: lset.cpp:747
wxPoint GetMousePosition()
Returns the mouse position in screen coordinates.
Definition: wxgtk/ui.cpp:677
see class PGM_BASE
#define LAYER_HK_COLUMN
Definition: sel_layer.cpp:55
#define LAYERNAME_COLNUM
Definition: sel_layer.cpp:54
#define SELECT_COLNUM
Definition: sel_layer.cpp:52
#define COLOR_COLNUM
Definition: sel_layer.cpp:53
#define DEFAULT_THEME
COLOR_SETTINGS * GetColorSettings(const wxString &aName)