KiCad PCB EDA Suite
PCB_LAYER_WIDGET Class Reference

PCB_LAYER_WIDGET is here to implement the abstract functions of LAYER_WIDGET so they may be tied into the PCB_EDIT_FRAME's data and so we can add a popup menu which is specific to PCBNEW's needs. More...

#include <pcb_layer_widget.h>

Inheritance diagram for PCB_LAYER_WIDGET:
LAYER_WIDGET

Public Member Functions

 PCB_LAYER_WIDGET (PCB_BASE_FRAME *aParent, wxWindow *aFocusOwner, bool aFpEditorMode=false)
 Constructor. More...
 
void ReFill ()
 
void ReFillRender ()
 Function ReFillRender rebuilds Render for instance after the config is read. More...
 
void SyncLayerVisibilities ()
 Function SyncLayerVisibilities updates each "Layer" checkbox in this layer widget according to each layer's current visibility determined by IsLayerVisible(), and is helpful immediately after loading a BOARD which may have state information in it. More...
 
void SyncLayerAlphaIndicators ()
 Function SyncLayerAlphaIndicators updates each "Layer"s alpha indicator to show if the board is currently being rendered with more transparency or less. More...
 
void SetLayersManagerTabsText ()
 Function SetLayersManagerTabsText Update the layer manager tabs labels Useful when changing Language or to set labels to a non default value. More...
 
void OnLayerColorChange (int aLayer, COLOR4D aColor) override
 Function OnLayerColorChange is called to notify client code about a layer color change. More...
 
bool OnLayerSelect (int aLayer) override
 Function OnLayerSelect is called to notify client code whenever the user selects a different layer. More...
 
void OnLayerVisible (int aLayer, bool isVisible, bool isFinal) override
 Function OnLayerVisible is called to notify client code about a layer visibility change. More...
 
void OnLayerRightClick (wxMenu &aMenu) override
 Function OnLayerRightClick is called to notify client code about a layer being right-clicked. More...
 
void OnRenderColorChange (int aId, COLOR4D aColor) override
 Function OnRenderColorChange is called to notify client code whenever the user changes a rendering color. More...
 
void OnRenderEnable (int aId, bool isEnabled) override
 Function OnRenderEnable is called to notify client code whenever the user changes an rendering enable in one of the rendering checkboxes. More...
 
bool OnLayerSelected ()
 Function OnLayerSelected ensure the active layer is visible, and other layers not visible when m_alwaysShowActiveLayer is true Otherwise do nothing. More...
 
void AddRightClickMenuItems (wxMenu &menu)
 Function addRightClickMenuItems add menu items to a menu that should be shown when right-clicking the PCB layer widget. More...
 
wxSize GetBestSize () const
 Function GetBestSize returns the preferred minimum size, taking into consideration the dynamic content. More...
 
int GetLayerRowCount () const
 Function GetLayerRowCount returns the number of rows in the layer tab. More...
 
int GetRenderRowCount () const
 Function GetRenderRowCount returns the number of rows in the render tab. More...
 
void AppendLayerRow (const ROW &aRow)
 Function AppendLayerRow appends a new row in the layer portion of the widget. More...
 
void AppendLayerRows (const ROW *aRowsArray, int aRowCount)
 Function AppendLayerRows appends new rows in the layer portion of the widget. More...
 
void ClearLayerRows ()
 Function ClearLayerRows empties out the layer rows. More...
 
void AppendRenderRow (const ROW &aRow)
 Function AppendRenderRow appends a new row in the render portion of the widget. More...
 
void AppendRenderRows (const ROW *aRowsArray, int aRowCount)
 Function AppendRenderRows appends new rows in the render portion of the widget. More...
 
void ClearRenderRows ()
 Function ClearRenderRows empties out the render rows. More...
 
void SelectLayerRow (int aRow)
 Function SelectLayerRow changes the row selection in the layer list to the given row. More...
 
void SelectLayer (LAYER_NUM aLayer)
 Function SelectLayer changes the row selection in the layer list to aLayer provided. More...
 
LAYER_NUM GetSelectedLayer ()
 Function GetSelectedLayer returns the selected layer or -1 if none. More...
 
void SetLayerVisible (LAYER_NUM aLayer, bool isVisible)
 Function SetLayerVisible sets aLayer visible or not. More...
 
bool IsLayerVisible (LAYER_NUM aLayer)
 Function IsLayerVisible returns the visible state of the layer ROW associated with aLayer id. More...
 
void SetLayerColor (LAYER_NUM aLayer, COLOR4D aColor)
 Function SetLayerColor changes the color of aLayer. More...
 
COLOR4D GetLayerColor (LAYER_NUM aLayer) const
 Function GetLayerColor returns the color of the layer ROW associated with aLayer id. More...
 
void SetRenderState (int aId, bool isSet)
 Function SetRenderState sets the state of the checkbox associated with aId within the Render tab group of the widget. More...
 
bool GetRenderState (int aId)
 Function GetRenderState returns the state of the checkbox associated with aId. More...
 
void UpdateLayouts ()
 
void UpdateLayerIcons ()
 Function UpdateLayerIcons Update all layer manager icons (layers only) Useful when loading a file or clearing a layer because they change, and the indicator arrow icon needs to be updated. More...
 

Static Public Attributes

static const wxEventType EVT_LAYER_COLOR_CHANGE = wxNewEventType()
 

Protected Types

enum  POPUP_ID {
  ID_SHOW_ALL_COPPER_LAYERS = LAYER_WIDGET::ID_LAST_VALUE, ID_SHOW_NO_COPPER_LAYERS, ID_SHOW_NO_COPPER_LAYERS_BUT_ACTIVE, ID_ALWAYS_SHOW_NO_COPPER_LAYERS_BUT_ACTIVE,
  ID_SHOW_NO_LAYERS, ID_SHOW_ALL_LAYERS, ID_SHOW_ALL_FRONT, ID_SHOW_ALL_BACK,
  ID_HIDE_ALL_NON_COPPER, ID_SHOW_ALL_NON_COPPER, ID_LAST_VALUE
}
 

Protected Member Functions

virtual COLOR4D getBackgroundLayerColor () override
 Subclasses can override this to provide accurate representation of transparent colour swatches. More...
 
bool isAllowedInFpMode (int aId)
 Function isAllowedInFpMode. More...
 
bool isLayerAllowedInFpMode (PCB_LAYER_ID aLayer)
 Function isLayerAllowedInFpMode. More...
 
void onRightDownLayers (wxMouseEvent &event)
 Function OnRightDownLayers puts up a popup menu for the layer panel. More...
 
void onPopupSelection (wxCommandEvent &event)
 
void installRightLayerClickHandler ()
 this is for the popup menu, the right click handler has to be installed on every child control within the layer panel. More...
 
virtual bool useAlternateBitmap (int aRow)
 Virtual Function useAlternateBitmap. More...
 
void OnLeftDownLayers (wxMouseEvent &event)
 
void OnRightDownLayer (wxMouseEvent &event, COLOR_SWATCH *aColorSwatch, const wxString &aLayerName)
 Function OnRightDownLayer Called when user right-clicks a layer. More...
 
void OnLayerSwatchChanged (wxCommandEvent &aEvent)
 Function OnSwatchChanged() is called when a user changes a swatch color. More...
 
void OnLayerCheckBox (wxCommandEvent &event)
 Function OnLayerCheckBox handles the "is layer visible" checkbox and propogates the event to the client's notification function. More...
 
void OnRightDownRender (wxMouseEvent &aEvent, COLOR_SWATCH *aColorSwatch, const wxString &aRenderName)
 Function OnRightDownRender Called when user right-clicks a render option. More...
 
void OnRenderSwatchChanged (wxCommandEvent &aEvent)
 Function OnRenderSwatchChanged Called when user has changed the swatch color of a render entry. More...
 
void OnRenderCheckBox (wxCommandEvent &event)
 
void OnTabChange (wxNotebookEvent &event)
 
wxWindow * getLayerComp (int aRow, int aColumn) const
 Function getLayerComp returns the component within the m_LayersFlexGridSizer at aRow and aCol or NULL if these parameters are out of range. More...
 
wxWindow * getRenderComp (int aRow, int aColumn) const
 
int findLayerRow (LAYER_NUM aLayer) const
 Function findLayerRow returns the row index that aLayer resides in, or -1 if not found. More...
 
int findRenderRow (int aId) const
 
void insertLayerRow (int aRow, const ROW &aSpec)
 Function insertLayerRow appends or inserts a new row in the layer portion of the widget. More...
 
void insertRenderRow (int aRow, const ROW &aSpec)
 
void setLayerCheckbox (LAYER_NUM aLayer, bool isVisible)
 
void passOnFocus ()
 Function passOnFocus gives away the keyboard focus up to the main parent window. More...
 

Static Protected Member Functions

static int encodeId (int aColumn, int aId)
 Function encodeId is here to allow saving a layer index within a control as its wxControl id, but to do so in a way that all child wxControl ids within a wxWindow are unique, since this is required by Windows. More...
 
static LAYER_NUM getDecodedId (int aControlId)
 Function getDecodedId decodes aControlId to original un-encoded value. More...
 

Protected Attributes

bool m_alwaysShowActiveCopperLayer
 
bool m_fp_editor_mode
 
PCB_BASE_FRAMEmyframe
 
wxAuiNotebook * m_notebook
 
wxPanel * m_LayerPanel
 
wxScrolledWindow * m_LayerScrolledWindow
 
wxFlexGridSizer * m_LayersFlexGridSizer
 
wxPanel * m_RenderingPanel
 
wxScrolledWindow * m_RenderScrolledWindow
 
wxFlexGridSizer * m_RenderFlexGridSizer
 
wxWindow * m_FocusOwner
 
int m_CurrentRow
 selected row of layer list More...
 
int m_PointSize
 
ROW_ICON_PROVIDERm_IconProvider
 

Static Protected Attributes

static const LAYER_WIDGET::ROW s_render_rows []
 This is a read only template that is copied and modified before adding to LAYER_WIDGET. More...
 

Detailed Description

PCB_LAYER_WIDGET is here to implement the abstract functions of LAYER_WIDGET so they may be tied into the PCB_EDIT_FRAME's data and so we can add a popup menu which is specific to PCBNEW's needs.

Definition at line 42 of file pcb_layer_widget.h.

Member Enumeration Documentation

◆ POPUP_ID

Enumerator
ID_SHOW_ALL_COPPER_LAYERS 
ID_SHOW_NO_COPPER_LAYERS 
ID_SHOW_NO_COPPER_LAYERS_BUT_ACTIVE 
ID_ALWAYS_SHOW_NO_COPPER_LAYERS_BUT_ACTIVE 
ID_SHOW_NO_LAYERS 
ID_SHOW_ALL_LAYERS 
ID_SHOW_ALL_FRONT 
ID_SHOW_ALL_BACK 
ID_HIDE_ALL_NON_COPPER 
ID_SHOW_ALL_NON_COPPER 
ID_LAST_VALUE 

Definition at line 125 of file pcb_layer_widget.h.

Constructor & Destructor Documentation

◆ PCB_LAYER_WIDGET()

PCB_LAYER_WIDGET::PCB_LAYER_WIDGET ( PCB_BASE_FRAME aParent,
wxWindow *  aFocusOwner,
bool  aFpEditorMode = false 
)

Constructor.

Parameters
aParentis the parent window
aFocusOwneris the window that should be sent the focus after
aFpEditorModefalse for the board editor (default), true for fp editor when true, some options or layers which cannot be used in editor mode are not displayed

Definition at line 98 of file pcb_layer_widget.cpp.

99  :
100  LAYER_WIDGET( aParent, aFocusOwner ),
101  myframe( aParent )
102 {
104  m_fp_editor_mode = aFpEditorMode;
105 
106  // Update default tabs labels
108 
109  //-----<Popup menu>-------------------------------------------------
110  // handle the popup menu over the layer window.
111  m_LayerScrolledWindow->Connect( wxEVT_RIGHT_DOWN,
112  wxMouseEventHandler( PCB_LAYER_WIDGET::onRightDownLayers ), NULL, this );
113 
114  // since Popupmenu() calls this->ProcessEvent() we must call this->Connect()
115  // and not m_LayerScrolledWindow->Connect()
116 
118  wxEVT_COMMAND_MENU_SELECTED,
119  wxCommandEventHandler( PCB_LAYER_WIDGET::onPopupSelection ), NULL, this );
120 }
PCB_BASE_FRAME * myframe
void SetLayersManagerTabsText()
Function SetLayersManagerTabsText Update the layer manager tabs labels Useful when changing Language ...
#define NULL
wxScrolledWindow * m_LayerScrolledWindow
Definition: layer_widget.h:129
void onRightDownLayers(wxMouseEvent &event)
Function OnRightDownLayers puts up a popup menu for the layer panel.
bool m_alwaysShowActiveCopperLayer
LAYER_WIDGET(wxWindow *aParent, wxWindow *aFocusOwner, wxWindowID id=wxID_ANY, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=wxTAB_TRAVERSAL)
Constructor.
void onPopupSelection(wxCommandEvent &event)

References ID_LAST_VALUE, ID_SHOW_ALL_COPPER_LAYERS, m_alwaysShowActiveCopperLayer, m_fp_editor_mode, LAYER_WIDGET::m_LayerScrolledWindow, NULL, onPopupSelection(), onRightDownLayers(), and SetLayersManagerTabsText().

Member Function Documentation

◆ AddRightClickMenuItems()

void PCB_LAYER_WIDGET::AddRightClickMenuItems ( wxMenu &  menu)

Function addRightClickMenuItems add menu items to a menu that should be shown when right-clicking the PCB layer widget.

Definition at line 149 of file pcb_layer_widget.cpp.

150 {
151  // menu text is capitalized:
152  // http://library.gnome.org/devel/hig-book/2.20/design-text-labels.html.en#layout-capitalization
154  _( "Show All Copper Layers" ),
157  _( "Hide All Copper Layers But Active" ),
160  _( "Always Hide All Copper Layers But Active" ),
163  _( "Hide All Copper Layers" ),
165 
166  menu.AppendSeparator();
167 
169  _( "Show All Non Copper Layers" ),
172  _( "Hide All Non Copper Layers" ),
174 
175  menu.AppendSeparator();
176 
177  AddMenuItem( &menu, ID_SHOW_NO_LAYERS, _( "Hide All Layers" ),
179  AddMenuItem( &menu, ID_SHOW_ALL_LAYERS, _( "Show All Layers" ),
181 
182  menu.AppendSeparator();
183 
184  AddMenuItem( &menu, ID_SHOW_ALL_FRONT, _( "Show All Front Layers" ),
186 
187  AddMenuItem( &menu, ID_SHOW_ALL_BACK, _( "Show All Back Layers" ),
189 }
wxMenuItem * AddMenuItem(wxMenu *aMenu, int aId, const wxString &aText, const wxBitmap &aImage, wxItemKind aType=wxITEM_NORMAL)
Function AddMenuItem is an inline helper function to create and insert a menu item with an icon into ...
Definition: bitmap.cpp:250
const BITMAP_OPAQUE show_no_copper_layers_xpm[1]
const BITMAP_OPAQUE select_layer_pair_xpm[1]
wxBitmap KiBitmap(BITMAP_DEF aBitmap)
Construct a wxBitmap from a memory record, held in a BITMAP_DEF.
Definition: bitmap.cpp:80
const BITMAP_OPAQUE select_w_layer_xpm[1]
const BITMAP_OPAQUE show_all_layers_xpm[1]
#define _(s)
Definition: 3d_actions.cpp:33
const BITMAP_OPAQUE show_no_layers_xpm[1]

References _, AddMenuItem(), ID_ALWAYS_SHOW_NO_COPPER_LAYERS_BUT_ACTIVE, ID_HIDE_ALL_NON_COPPER, ID_SHOW_ALL_BACK, ID_SHOW_ALL_COPPER_LAYERS, ID_SHOW_ALL_FRONT, ID_SHOW_ALL_LAYERS, ID_SHOW_ALL_NON_COPPER, ID_SHOW_NO_COPPER_LAYERS, ID_SHOW_NO_COPPER_LAYERS_BUT_ACTIVE, ID_SHOW_NO_LAYERS, KiBitmap(), select_layer_pair_xpm, select_w_layer_xpm, show_all_layers_xpm, show_no_copper_layers_xpm, and show_no_layers_xpm.

Referenced by OnLayerRightClick(), and onRightDownLayers().

◆ AppendLayerRow()

void LAYER_WIDGET::AppendLayerRow ( const ROW aRow)
inherited

Function AppendLayerRow appends a new row in the layer portion of the widget.

The user must ensure that ROW::id is unique for all existing rows on Windows.

Definition at line 609 of file layer_widget.cpp.

610 {
611  int nextRow = GetLayerRowCount();
612  insertLayerRow( nextRow, aRow );
613 }
int GetLayerRowCount() const
Function GetLayerRowCount returns the number of rows in the layer tab.
void insertLayerRow(int aRow, const ROW &aSpec)
Function insertLayerRow appends or inserts a new row in the layer portion of the widget.

References LAYER_WIDGET::GetLayerRowCount(), and LAYER_WIDGET::insertLayerRow().

Referenced by LAYER_WIDGET::AppendLayerRows(), ReFill(), and GERBER_LAYER_WIDGET::ReFill().

◆ AppendLayerRows()

void LAYER_WIDGET::AppendLayerRows ( const ROW aRowsArray,
int  aRowCount 
)
inlineinherited

Function AppendLayerRows appends new rows in the layer portion of the widget.

The user must ensure that ROW::id is unique for all existing rows on Windows.

Definition at line 304 of file layer_widget.h.

305  {
306  for( int row=0; row<aRowCount; ++row )
307  AppendLayerRow( aRowsArray[row] );
308 
309  UpdateLayouts();
310  }
void UpdateLayouts()
void AppendLayerRow(const ROW &aRow)
Function AppendLayerRow appends a new row in the layer portion of the widget.

References LAYER_WIDGET::AppendLayerRow(), and LAYER_WIDGET::UpdateLayouts().

◆ AppendRenderRow()

void LAYER_WIDGET::AppendRenderRow ( const ROW aRow)
inherited

Function AppendRenderRow appends a new row in the render portion of the widget.

The user must ensure that ROW::id is unique for all existing rows on Windows.

Definition at line 622 of file layer_widget.cpp.

623 {
624  int nextRow = GetRenderRowCount();
625  insertRenderRow( nextRow, aRow );
626 }
void insertRenderRow(int aRow, const ROW &aSpec)
int GetRenderRowCount() const
Function GetRenderRowCount returns the number of rows in the render tab.

References LAYER_WIDGET::GetRenderRowCount(), and LAYER_WIDGET::insertRenderRow().

Referenced by LAYER_WIDGET::AppendRenderRows(), and ReFillRender().

◆ AppendRenderRows()

void LAYER_WIDGET::AppendRenderRows ( const ROW aRowsArray,
int  aRowCount 
)
inlineinherited

Function AppendRenderRows appends new rows in the render portion of the widget.

The user must ensure that ROW::id is unique for all existing rows on Windows.

Definition at line 330 of file layer_widget.h.

331  {
332  for( int row=0; row<aRowCount; ++row )
333  AppendRenderRow( aRowsArray[row] );
334 
335  UpdateLayouts();
336  }
void UpdateLayouts()
void AppendRenderRow(const ROW &aRow)
Function AppendRenderRow appends a new row in the render portion of the widget.

References LAYER_WIDGET::AppendRenderRow(), and LAYER_WIDGET::UpdateLayouts().

Referenced by GERBER_LAYER_WIDGET::ReFillRender().

◆ ClearLayerRows()

void LAYER_WIDGET::ClearLayerRows ( )
inherited

Function ClearLayerRows empties out the layer rows.

Definition at line 616 of file layer_widget.cpp.

617 {
618  m_LayersFlexGridSizer->Clear( true );
619 }
wxFlexGridSizer * m_LayersFlexGridSizer
Definition: layer_widget.h:130

References LAYER_WIDGET::m_LayersFlexGridSizer.

Referenced by ReFill(), and GERBER_LAYER_WIDGET::ReFill().

◆ ClearRenderRows()

void LAYER_WIDGET::ClearRenderRows ( )
inherited

Function ClearRenderRows empties out the render rows.

Definition at line 629 of file layer_widget.cpp.

630 {
631  m_RenderFlexGridSizer->Clear( true );
632 }
wxFlexGridSizer * m_RenderFlexGridSizer
Definition: layer_widget.h:133

References LAYER_WIDGET::m_RenderFlexGridSizer.

Referenced by ReFillRender(), and GERBER_LAYER_WIDGET::ReFillRender().

◆ encodeId()

int LAYER_WIDGET::encodeId ( int  aColumn,
int  aId 
)
staticprotectedinherited

Function encodeId is here to allow saving a layer index within a control as its wxControl id, but to do so in a way that all child wxControl ids within a wxWindow are unique, since this is required by Windows.

See also
getDecodedId()

Definition at line 63 of file layer_widget.cpp.

64 {
65  int id = aId * LYR_COLUMN_COUNT + aColumn;
66  return id;
67 }
#define LYR_COLUMN_COUNT
Layer tab column count.
Definition: layer_widget.h:49

References LYR_COLUMN_COUNT.

Referenced by LAYER_WIDGET::insertLayerRow(), and LAYER_WIDGET::insertRenderRow().

◆ findLayerRow()

int LAYER_WIDGET::findLayerRow ( LAYER_NUM  aLayer) const
protectedinherited

Function findLayerRow returns the row index that aLayer resides in, or -1 if not found.

Definition at line 265 of file layer_widget.cpp.

266 {
267  int count = GetLayerRowCount();
268 
269  for( int row = 0; row < count; ++row )
270  {
271  // column 0 in the layer scroll window has a wxStaticBitmap, get its ID.
272  wxWindow* w = getLayerComp( row, 0 );
273  wxASSERT( w );
274 
275  if( aLayer == getDecodedId( w->GetId() ))
276  return row;
277  }
278 
279  return -1;
280 }
wxWindow * getLayerComp(int aRow, int aColumn) const
Function getLayerComp returns the component within the m_LayersFlexGridSizer at aRow and aCol or NULL...
static LAYER_NUM getDecodedId(int aControlId)
Function getDecodedId decodes aControlId to original un-encoded value.
int GetLayerRowCount() const
Function GetLayerRowCount returns the number of rows in the layer tab.

References LAYER_WIDGET::getDecodedId(), LAYER_WIDGET::getLayerComp(), and LAYER_WIDGET::GetLayerRowCount().

Referenced by LAYER_WIDGET::GetLayerColor(), LAYER_WIDGET::IsLayerVisible(), LAYER_WIDGET::OnLeftDownLayers(), LAYER_WIDGET::SelectLayer(), LAYER_WIDGET::setLayerCheckbox(), and LAYER_WIDGET::SetLayerColor().

◆ findRenderRow()

int LAYER_WIDGET::findRenderRow ( int  aId) const
protectedinherited

Definition at line 294 of file layer_widget.cpp.

295 {
296  int count = GetRenderRowCount();
297 
298  for( int row = 0; row < count; ++row )
299  {
300  // column 0 in the layer scroll window has a wxStaticBitmap, get its ID.
301  wxWindow* w = getRenderComp( row, 0 );
302  wxASSERT( w );
303 
304  if( aId == getDecodedId( w->GetId() ))
305  return row;
306  }
307 
308  return -1;
309 }
wxWindow * getRenderComp(int aRow, int aColumn) const
static LAYER_NUM getDecodedId(int aControlId)
Function getDecodedId decodes aControlId to original un-encoded value.
int GetRenderRowCount() const
Function GetRenderRowCount returns the number of rows in the render tab.

References LAYER_WIDGET::getDecodedId(), LAYER_WIDGET::getRenderComp(), and LAYER_WIDGET::GetRenderRowCount().

Referenced by LAYER_WIDGET::GetRenderState(), and LAYER_WIDGET::SetRenderState().

◆ getBackgroundLayerColor()

COLOR4D PCB_LAYER_WIDGET::getBackgroundLayerColor ( )
overrideprotectedvirtual

Subclasses can override this to provide accurate representation of transparent colour swatches.

Reimplemented from LAYER_WIDGET.

Definition at line 123 of file pcb_layer_widget.cpp.

124 {
128 }
PCB_BASE_FRAME * myframe
void SetColorContext(COLOR_CONTEXT aContext=COLOR_CONTEXT::PCB)
COLOR_SETTINGS * ColorSettings()
Helper to retrieve the current color settings.
COLOR4D GetColor(int aLayer) const

References PCB_BASE_FRAME::ColorSettings(), FOOTPRINT, COLOR_SETTINGS::GetColor(), LAYER_PCB_BACKGROUND, m_fp_editor_mode, myframe, PCB, and COLOR_SETTINGS::SetColorContext().

◆ GetBestSize()

wxSize LAYER_WIDGET::GetBestSize ( ) const
inherited

Function GetBestSize returns the preferred minimum size, taking into consideration the dynamic content.

Nothing in wxWidgets was reliable enough so this overrides one of their functions.

Definition at line 540 of file layer_widget.cpp.

541 {
542  // size of m_LayerScrolledWindow --------------
543  wxArrayInt widths = m_LayersFlexGridSizer->GetColWidths();
544  int totWidth = 0;
545 
546  if( widths.GetCount() )
547  {
548  for( int i = 0; i < LYR_COLUMN_COUNT; ++i )
549  {
550  totWidth += widths[i] + m_LayersFlexGridSizer->GetHGap();
551  // printf("widths[%d]:%d\n", i, widths[i] );
552  }
553  }
554 
555  // Account for the parent's frame:
556  totWidth += 15;
557 
558 
559  /* The minimum height is a small size to properly force computation
560  * of the panel's scrollbars (otherwise it will assume it *has* all
561  * this space) */
562  unsigned totHeight = 32;
563 
564  wxSize layerz( totWidth, totHeight );
565 
566  layerz += m_LayerPanel->GetWindowBorderSize();
567 
568 
569  // size of m_RenderScrolledWindow --------------
570  widths = m_RenderFlexGridSizer->GetColWidths();
571  totWidth = 0;
572 
573  if( widths.GetCount() )
574  {
575  for( int i = 0; i < RND_COLUMN_COUNT; ++i )
576  {
577  totWidth += widths[i] + m_RenderFlexGridSizer->GetHGap();
578  // printf("widths[%d]:%d\n", i, widths[i] );
579  }
580  }
581  // account for the parent's frame, this one has void space of 10 PLUS a border:
582  totWidth += 15;
583 
584  // For totHeight re-use the previous small one
585  wxSize renderz( totWidth, totHeight );
586 
587  renderz += m_RenderingPanel->GetWindowBorderSize();
588 
589  wxSize clientz( std::max(renderz.x,layerz.x), std::max(renderz.y,layerz.y) );
590 
591  return clientz;
592 }
#define LYR_COLUMN_COUNT
Layer tab column count.
Definition: layer_widget.h:49
wxFlexGridSizer * m_LayersFlexGridSizer
Definition: layer_widget.h:130
#define RND_COLUMN_COUNT
Rendering tab column count.
Definition: layer_widget.h:50
wxFlexGridSizer * m_RenderFlexGridSizer
Definition: layer_widget.h:133
wxPanel * m_RenderingPanel
Definition: layer_widget.h:131
wxPanel * m_LayerPanel
Definition: layer_widget.h:128

References LYR_COLUMN_COUNT, LAYER_WIDGET::m_LayerPanel, LAYER_WIDGET::m_LayersFlexGridSizer, LAYER_WIDGET::m_RenderFlexGridSizer, LAYER_WIDGET::m_RenderingPanel, and RND_COLUMN_COUNT.

Referenced by GERBVIEW_FRAME::GERBVIEW_FRAME(), FOOTPRINT_EDIT_FRAME::ReFillLayerWidget(), and GERBVIEW_FRAME::ReFillLayerWidget().

◆ getDecodedId()

LAYER_NUM LAYER_WIDGET::getDecodedId ( int  aControlId)
staticprotectedinherited

Function getDecodedId decodes aControlId to original un-encoded value.

This of course holds iff encodedId was called with a LAYER_NUM (this box is used for other things than layers, too)

Definition at line 70 of file layer_widget.cpp.

71 {
72  int id = aControlId / LYR_COLUMN_COUNT; // rounding is OK.
73  return id;
74 }
#define LYR_COLUMN_COUNT
Layer tab column count.
Definition: layer_widget.h:49

References LYR_COLUMN_COUNT.

Referenced by LAYER_WIDGET::findLayerRow(), LAYER_WIDGET::findRenderRow(), LAYER_WIDGET::GetSelectedLayer(), LAYER_WIDGET::OnLayerCheckBox(), LAYER_WIDGET::OnLayerSwatchChanged(), LAYER_WIDGET::OnLeftDownLayers(), GERBER_LAYER_WIDGET::onPopupSelection(), onPopupSelection(), LAYER_WIDGET::OnRenderCheckBox(), LAYER_WIDGET::OnRenderSwatchChanged(), SyncLayerAlphaIndicators(), and SyncLayerVisibilities().

◆ GetLayerColor()

COLOR4D LAYER_WIDGET::GetLayerColor ( LAYER_NUM  aLayer) const
inherited

Function GetLayerColor returns the color of the layer ROW associated with aLayer id.

Definition at line 732 of file layer_widget.cpp.

733 {
734  int row = findLayerRow( aLayer );
735  if( row >= 0 )
736  {
737  int col = 1; // bitmap button is column 1
738  auto swatch = static_cast<COLOR_SWATCH*>( getLayerComp( row, col ) );
739  wxASSERT( swatch );
740 
741  return swatch->GetSwatchColor();
742  }
743 
744  return COLOR4D::UNSPECIFIED; // it's caller fault, gave me a bad layer
745 }
int findLayerRow(LAYER_NUM aLayer) const
Function findLayerRow returns the row index that aLayer resides in, or -1 if not found.
wxWindow * getLayerComp(int aRow, int aColumn) const
Function getLayerComp returns the component within the m_LayersFlexGridSizer at aRow and aCol or NULL...

References LAYER_WIDGET::findLayerRow(), and LAYER_WIDGET::getLayerComp().

◆ getLayerComp()

wxWindow * LAYER_WIDGET::getLayerComp ( int  aRow,
int  aColumn 
) const
protectedinherited

Function getLayerComp returns the component within the m_LayersFlexGridSizer at aRow and aCol or NULL if these parameters are out of range.

Parameters
aRowis the row index
aColumnis the column
Returns
wxWindow - the component installed within the sizer at given grid coordinate.

Definition at line 254 of file layer_widget.cpp.

255 {
256  unsigned ndx = aRow * LYR_COLUMN_COUNT + aColumn;
257 
258  if( ndx < m_LayersFlexGridSizer->GetChildren().GetCount() )
259  return m_LayersFlexGridSizer->GetChildren()[ndx]->GetWindow();
260 
261  return NULL;
262 }
#define LYR_COLUMN_COUNT
Layer tab column count.
Definition: layer_widget.h:49
wxFlexGridSizer * m_LayersFlexGridSizer
Definition: layer_widget.h:130
#define NULL

References LYR_COLUMN_COUNT, LAYER_WIDGET::m_LayersFlexGridSizer, and NULL.

Referenced by LAYER_WIDGET::findLayerRow(), LAYER_WIDGET::GetLayerColor(), LAYER_WIDGET::GetSelectedLayer(), LAYER_WIDGET::IsLayerVisible(), LAYER_WIDGET::OnLeftDownLayers(), GERBER_LAYER_WIDGET::onPopupSelection(), onPopupSelection(), LAYER_WIDGET::OnRenderSwatchChanged(), ReFill(), LAYER_WIDGET::SelectLayerRow(), LAYER_WIDGET::setLayerCheckbox(), LAYER_WIDGET::SetLayerColor(), SyncLayerAlphaIndicators(), SyncLayerVisibilities(), and LAYER_WIDGET::UpdateLayerIcons().

◆ GetLayerRowCount()

int LAYER_WIDGET::GetLayerRowCount ( ) const
inherited

Function GetLayerRowCount returns the number of rows in the layer tab.

Definition at line 595 of file layer_widget.cpp.

596 {
597  int controlCount = m_LayersFlexGridSizer->GetChildren().GetCount();
598  return controlCount / LYR_COLUMN_COUNT;
599 }
#define LYR_COLUMN_COUNT
Layer tab column count.
Definition: layer_widget.h:49
wxFlexGridSizer * m_LayersFlexGridSizer
Definition: layer_widget.h:130

References LYR_COLUMN_COUNT, and LAYER_WIDGET::m_LayersFlexGridSizer.

Referenced by LAYER_WIDGET::AppendLayerRow(), LAYER_WIDGET::findLayerRow(), LAYER_WIDGET::OnLeftDownLayers(), GERBER_LAYER_WIDGET::onPopupSelection(), onPopupSelection(), LAYER_WIDGET::OnRenderSwatchChanged(), ReFill(), SyncLayerAlphaIndicators(), SyncLayerVisibilities(), and LAYER_WIDGET::UpdateLayerIcons().

◆ getRenderComp()

wxWindow * LAYER_WIDGET::getRenderComp ( int  aRow,
int  aColumn 
) const
protectedinherited

Definition at line 283 of file layer_widget.cpp.

284 {
285  int ndx = aRow * RND_COLUMN_COUNT + aColumn;
286 
287  if( (unsigned) ndx < m_RenderFlexGridSizer->GetChildren().GetCount() )
288  return m_RenderFlexGridSizer->GetChildren()[ndx]->GetWindow();
289 
290  return NULL;
291 }
#define RND_COLUMN_COUNT
Rendering tab column count.
Definition: layer_widget.h:50
wxFlexGridSizer * m_RenderFlexGridSizer
Definition: layer_widget.h:133
#define NULL

References LAYER_WIDGET::m_RenderFlexGridSizer, NULL, and RND_COLUMN_COUNT.

Referenced by LAYER_WIDGET::findRenderRow(), LAYER_WIDGET::GetRenderState(), LAYER_WIDGET::OnRenderSwatchChanged(), and LAYER_WIDGET::SetRenderState().

◆ GetRenderRowCount()

int LAYER_WIDGET::GetRenderRowCount ( ) const
inherited

Function GetRenderRowCount returns the number of rows in the render tab.

Definition at line 602 of file layer_widget.cpp.

603 {
604  int controlCount = m_RenderFlexGridSizer->GetChildren().GetCount();
605  return controlCount / RND_COLUMN_COUNT;
606 }
#define RND_COLUMN_COUNT
Rendering tab column count.
Definition: layer_widget.h:50
wxFlexGridSizer * m_RenderFlexGridSizer
Definition: layer_widget.h:133

References LAYER_WIDGET::m_RenderFlexGridSizer, and RND_COLUMN_COUNT.

Referenced by LAYER_WIDGET::AppendRenderRow(), LAYER_WIDGET::findRenderRow(), and LAYER_WIDGET::OnRenderSwatchChanged().

◆ GetRenderState()

bool LAYER_WIDGET::GetRenderState ( int  aId)
inherited

Function GetRenderState returns the state of the checkbox associated with aId.

Returns
bool - true if checked, else false.

Definition at line 762 of file layer_widget.cpp.

763 {
764  int row = findRenderRow( aId );
765 
766  if( row >= 0 )
767  {
768  int col = 1; // checkbox is column 1
769  wxCheckBox* cb = (wxCheckBox*) getRenderComp( row, col );
770  wxASSERT( cb );
771  return cb->GetValue();
772  }
773 
774  return false; // the value of a non-existent row
775 }
int findRenderRow(int aId) const
wxWindow * getRenderComp(int aRow, int aColumn) const

References LAYER_WIDGET::findRenderRow(), and LAYER_WIDGET::getRenderComp().

◆ GetSelectedLayer()

LAYER_NUM LAYER_WIDGET::GetSelectedLayer ( )
inherited

Function GetSelectedLayer returns the selected layer or -1 if none.

Definition at line 676 of file layer_widget.cpp.

677 {
678  wxWindow* w = getLayerComp( m_CurrentRow, 0 );
679  if( w )
680  return getDecodedId( w->GetId() );
681 
682  return UNDEFINED_LAYER;
683 }
int m_CurrentRow
selected row of layer list
Definition: layer_widget.h:136
wxWindow * getLayerComp(int aRow, int aColumn) const
Function getLayerComp returns the component within the m_LayersFlexGridSizer at aRow and aCol or NULL...
static LAYER_NUM getDecodedId(int aControlId)
Function getDecodedId decodes aControlId to original un-encoded value.

References LAYER_WIDGET::getDecodedId(), LAYER_WIDGET::getLayerComp(), LAYER_WIDGET::m_CurrentRow, and UNDEFINED_LAYER.

◆ insertLayerRow()

void LAYER_WIDGET::insertLayerRow ( int  aRow,
const ROW aSpec 
)
protectedinherited

Function insertLayerRow appends or inserts a new row in the layer portion of the widget.

Definition at line 312 of file layer_widget.cpp.

313 {
314  wxASSERT( aRow >= 0 );
315 
316  int col;
317  int index = aRow * LYR_COLUMN_COUNT;
318  const int flags = wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT;
319 
320  // column 0
321  col = COLUMN_ICON_ACTIVE;
323  ROW_ICON_PROVIDER::STATE::OFF, encodeId( col, aSpec.id ) );
324  sbm->Bind( wxEVT_LEFT_DOWN, &LAYER_WIDGET::OnLeftDownLayers, this );
325  m_LayersFlexGridSizer->wxSizer::Insert( index+col, sbm, 0, flags );
326 
327  // column 1 (COLUMN_COLORBM)
328  col = COLUMN_COLORBM;
329 
330  auto bmb = new COLOR_SWATCH( m_LayerScrolledWindow, aSpec.color, encodeId( col, aSpec.id ),
331  getBackgroundLayerColor(), aSpec.defaultColor );
332  bmb->Bind( wxEVT_LEFT_DOWN, &LAYER_WIDGET::OnLeftDownLayers, this );
333  bmb->Bind( COLOR_SWATCH_CHANGED, &LAYER_WIDGET::OnLayerSwatchChanged, this );
334  bmb->SetToolTip( _("Left double click or middle click for color change, right click for menu" ) );
335  m_LayersFlexGridSizer->wxSizer::Insert( index+col, bmb, 0, flags );
336 
337  // column 2 (COLUMN_COLOR_LYR_CB)
338  col = COLUMN_COLOR_LYR_CB;
339  wxCheckBox* cb = new wxCheckBox( m_LayerScrolledWindow, encodeId( col, aSpec.id ), wxEmptyString );
340  cb->SetValue( aSpec.state );
341  cb->Bind( wxEVT_COMMAND_CHECKBOX_CLICKED, &LAYER_WIDGET::OnLayerCheckBox, this );
342  cb->SetToolTip( _( "Enable this for visibility" ) );
343  m_LayersFlexGridSizer->wxSizer::Insert( index+col, cb, 0, flags );
344 
345  // column 3 (COLUMN_COLOR_LYRNAME)
346  col = COLUMN_COLOR_LYRNAME;
347  wxStaticText* st = new wxStaticText( m_LayerScrolledWindow, encodeId( col, aSpec.id ), aSpec.rowName );
348  shrinkFont( st, m_PointSize );
349  st->Bind( wxEVT_LEFT_DOWN, &LAYER_WIDGET::OnLeftDownLayers, this );
350  st->SetToolTip( aSpec.tooltip );
351  m_LayersFlexGridSizer->wxSizer::Insert( index+col, st, 0, flags );
352 
353  // column 4 (COLUMN_ALPHA_INDICATOR)
356  ROW_ICON_PROVIDER::STATE::OFF, wxID_ANY );
357  m_LayersFlexGridSizer->wxSizer::Insert( index+col, sbm, 0, flags );
358 
359  // Bind right click eventhandler to all columns
360  wxString layerName( aSpec.rowName );
361 
362  sbm->Bind( wxEVT_RIGHT_DOWN, [this, bmb, layerName] ( wxMouseEvent& aEvt ) {
363  OnRightDownLayer( aEvt, bmb, layerName );
364  } );
365  bmb->Bind( wxEVT_RIGHT_DOWN, [this, bmb, layerName] ( wxMouseEvent& aEvt ) {
366  OnRightDownLayer( aEvt, bmb, layerName );
367  } );
368  cb->Bind( wxEVT_RIGHT_DOWN, [this, bmb, layerName] ( wxMouseEvent& aEvt ) {
369  OnRightDownLayer( aEvt, bmb, layerName );
370  } );
371  st->Bind( wxEVT_RIGHT_DOWN, [this, bmb, layerName] ( wxMouseEvent& aEvt ) {
372  OnRightDownLayer( aEvt, bmb, layerName );
373  } );
374 }
#define COLUMN_COLOR_LYRNAME
Definition: layer_widget.h:55
void OnLeftDownLayers(wxMouseEvent &event)
#define LYR_COLUMN_COUNT
Layer tab column count.
Definition: layer_widget.h:49
#define COLUMN_ALPHA_INDICATOR
Definition: layer_widget.h:56
#define OFF
wxFlexGridSizer * m_LayersFlexGridSizer
Definition: layer_widget.h:130
static void shrinkFont(wxWindow *aControl, int aPointSize)
Function shrinkFont reduces the size of the wxFont associated with aControl.
void OnLayerCheckBox(wxCommandEvent &event)
Function OnLayerCheckBox handles the "is layer visible" checkbox and propogates the event to the clie...
static int encodeId(int aColumn, int aId)
Function encodeId is here to allow saving a layer index within a control as its wxControl id,...
representing a row indicator icon for use in places like the layer widget
#define COLUMN_ICON_ACTIVE
Definition: layer_widget.h:52
#define COLUMN_COLORBM
Definition: layer_widget.h:53
wxScrolledWindow * m_LayerScrolledWindow
Definition: layer_widget.h:129
void OnRightDownLayer(wxMouseEvent &event, COLOR_SWATCH *aColorSwatch, const wxString &aLayerName)
Function OnRightDownLayer Called when user right-clicks a layer.
#define COLUMN_COLOR_LYR_CB
Definition: layer_widget.h:54
#define _(s)
Definition: 3d_actions.cpp:33
virtual COLOR4D getBackgroundLayerColor()
Subclasses can override this to provide accurate representation of transparent colour swatches.
Definition: layer_widget.h:155
Class representing a simple color swatch, of the kind used to set layer colors.
Definition: color_swatch.h:38
void OnLayerSwatchChanged(wxCommandEvent &aEvent)
Function OnSwatchChanged() is called when a user changes a swatch color.
ROW_ICON_PROVIDER * m_IconProvider
Definition: layer_widget.h:139

References _, LAYER_WIDGET::ROW::color, COLUMN_ALPHA_INDICATOR, COLUMN_COLOR_LYR_CB, COLUMN_COLOR_LYRNAME, COLUMN_COLORBM, COLUMN_ICON_ACTIVE, LAYER_WIDGET::ROW::defaultColor, LAYER_WIDGET::encodeId(), LAYER_WIDGET::getBackgroundLayerColor(), LAYER_WIDGET::ROW::id, LYR_COLUMN_COUNT, LAYER_WIDGET::m_IconProvider, LAYER_WIDGET::m_LayerScrolledWindow, LAYER_WIDGET::m_LayersFlexGridSizer, LAYER_WIDGET::m_PointSize, OFF, LAYER_WIDGET::OnLayerCheckBox(), LAYER_WIDGET::OnLayerSwatchChanged(), LAYER_WIDGET::OnLeftDownLayers(), LAYER_WIDGET::OnRightDownLayer(), LAYER_WIDGET::ROW::rowName, shrinkFont(), LAYER_WIDGET::ROW::state, and LAYER_WIDGET::ROW::tooltip.

Referenced by LAYER_WIDGET::AppendLayerRow().

◆ insertRenderRow()

void LAYER_WIDGET::insertRenderRow ( int  aRow,
const ROW aSpec 
)
protectedinherited

Definition at line 377 of file layer_widget.cpp.

378 {
379  wxASSERT( aRow >= 0 );
380 
381  int col;
382  int index = aRow * RND_COLUMN_COUNT;
383  const int flags = wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT;
384 
385  wxString renderName( aSpec.rowName );
386  wxCheckBox* cb = nullptr;
387 
388  // column 1
389  if( !aSpec.spacer )
390  {
391  col = 1;
392  cb = new wxCheckBox( m_RenderScrolledWindow, encodeId( col, aSpec.id ),
393  aSpec.rowName, wxDefaultPosition, wxDefaultSize, wxALIGN_LEFT );
394  shrinkFont( cb, m_PointSize );
395  cb->SetValue( aSpec.state );
396  cb->Enable( aSpec.changeable );
397  cb->Bind( wxEVT_COMMAND_CHECKBOX_CLICKED, &LAYER_WIDGET::OnRenderCheckBox, this );
398  cb->SetToolTip( aSpec.tooltip );
399  }
400 
401  // column 0
402  col = 0;
403  if( aSpec.color != COLOR4D::UNSPECIFIED )
404  {
405  auto bmb = new COLOR_SWATCH( m_RenderScrolledWindow, aSpec.color, encodeId( col, aSpec.id ),
406  getBackgroundLayerColor(), aSpec.defaultColor );
407  bmb->Bind( COLOR_SWATCH_CHANGED, &LAYER_WIDGET::OnRenderSwatchChanged, this );
408  bmb->SetToolTip( _( "Left double click or middle click for color change" ) );
409  m_RenderFlexGridSizer->wxSizer::Insert( index+col, bmb, 0, flags );
410 
411  bmb->Bind( wxEVT_RIGHT_DOWN, [this, bmb, renderName] ( wxMouseEvent& aEvt ) {
412  OnRightDownRender( aEvt, bmb, renderName );
413  } );
414  cb->Bind( wxEVT_RIGHT_DOWN, [this, bmb, renderName] ( wxMouseEvent& aEvt ) {
415  OnRightDownRender( aEvt, bmb, renderName );
416  } );
417 
418  // could add a left click handler on the color button that toggles checkbox.
419  }
420  else // == -1, no color selection wanted
421  {
422  // need a place holder within the sizer to keep grid full.
423  wxPanel* invisible = new wxPanel( m_RenderScrolledWindow, encodeId( col, aSpec.id ) );
424  m_RenderFlexGridSizer->wxSizer::Insert( index+col, invisible, 0, flags );
425  }
426 
427  // Items have to be inserted in order
428  col = 1;
429 
430  if( aSpec.spacer )
431  {
432  wxPanel* invisible = new wxPanel( m_RenderScrolledWindow, wxID_ANY );
433  m_RenderFlexGridSizer->wxSizer::Insert( index+col, invisible, 0, flags );
434  }
435  else
436  {
437  m_RenderFlexGridSizer->wxSizer::Insert( index+col, cb, 0, flags );
438  }
439 }
wxScrolledWindow * m_RenderScrolledWindow
Definition: layer_widget.h:132
static void shrinkFont(wxWindow *aControl, int aPointSize)
Function shrinkFont reduces the size of the wxFont associated with aControl.
#define RND_COLUMN_COUNT
Rendering tab column count.
Definition: layer_widget.h:50
wxFlexGridSizer * m_RenderFlexGridSizer
Definition: layer_widget.h:133
void OnRenderCheckBox(wxCommandEvent &event)
static int encodeId(int aColumn, int aId)
Function encodeId is here to allow saving a layer index within a control as its wxControl id,...
void OnRightDownRender(wxMouseEvent &aEvent, COLOR_SWATCH *aColorSwatch, const wxString &aRenderName)
Function OnRightDownRender Called when user right-clicks a render option.
void OnRenderSwatchChanged(wxCommandEvent &aEvent)
Function OnRenderSwatchChanged Called when user has changed the swatch color of a render entry.
#define _(s)
Definition: 3d_actions.cpp:33
virtual COLOR4D getBackgroundLayerColor()
Subclasses can override this to provide accurate representation of transparent colour swatches.
Definition: layer_widget.h:155
Class representing a simple color swatch, of the kind used to set layer colors.
Definition: color_swatch.h:38

References _, LAYER_WIDGET::ROW::changeable, LAYER_WIDGET::ROW::color, LAYER_WIDGET::ROW::defaultColor, LAYER_WIDGET::encodeId(), LAYER_WIDGET::getBackgroundLayerColor(), LAYER_WIDGET::ROW::id, LAYER_WIDGET::m_PointSize, LAYER_WIDGET::m_RenderFlexGridSizer, LAYER_WIDGET::m_RenderScrolledWindow, LAYER_WIDGET::OnRenderCheckBox(), LAYER_WIDGET::OnRenderSwatchChanged(), LAYER_WIDGET::OnRightDownRender(), RND_COLUMN_COUNT, LAYER_WIDGET::ROW::rowName, shrinkFont(), LAYER_WIDGET::ROW::spacer, LAYER_WIDGET::ROW::state, and LAYER_WIDGET::ROW::tooltip.

Referenced by LAYER_WIDGET::AppendRenderRow().

◆ installRightLayerClickHandler()

void PCB_LAYER_WIDGET::installRightLayerClickHandler ( )
protected

this is for the popup menu, the right click handler has to be installed on every child control within the layer panel.

◆ isAllowedInFpMode()

bool PCB_LAYER_WIDGET::isAllowedInFpMode ( int  aId)
protected

Function isAllowedInFpMode.

Returns
true if item aId has meaning in footprint editor mode. and therefore is shown in render panel

Definition at line 131 of file pcb_layer_widget.cpp.

132 {
133  for( unsigned ii = 0; ii < arrayDim( s_allowed_in_FpEditor ); ii++ )
134  if( s_allowed_in_FpEditor[ii] == aId )
135  return true;
136 
137  return false;
138 }
static int s_allowed_in_FpEditor[]
constexpr std::size_t arrayDim(T const (&)[N]) noexcept
Definition: macros.h:108

References arrayDim(), and s_allowed_in_FpEditor.

Referenced by ReFillRender().

◆ isLayerAllowedInFpMode()

bool PCB_LAYER_WIDGET::isLayerAllowedInFpMode ( PCB_LAYER_ID  aLayer)
protected

Function isLayerAllowedInFpMode.

User layers, which are not paired, are not shown in layers manager. However a not listed layer can be reachable in the graphic item properties dialog.

Parameters
aLayeris the layer id to test
Returns
true if PCB_LAYER_ID aLayer has meaning in footprint editor mode. and therefore is shown in render panel

Definition at line 141 of file pcb_layer_widget.cpp.

142 {
143  static LSET allowed = LSET::AllTechMask();
144  allowed.set( F_Cu ).set( B_Cu );
145  return allowed.test( aLayer );
146 }
static LSET AllTechMask()
Function AllTechMask returns a mask holding all technical layers (no CU layer) on both side.
Definition: lset.cpp:756
LSET is a set of PCB_LAYER_IDs.

References LSET::AllTechMask(), B_Cu, and F_Cu.

◆ IsLayerVisible()

bool LAYER_WIDGET::IsLayerVisible ( LAYER_NUM  aLayer)
inherited

Function IsLayerVisible returns the visible state of the layer ROW associated with aLayer id.

Definition at line 705 of file layer_widget.cpp.

706 {
707  int row = findLayerRow( aLayer );
708  if( row >= 0 )
709  {
710  wxCheckBox* cb = (wxCheckBox*) getLayerComp( row, COLUMN_COLOR_LYR_CB );
711  wxASSERT( cb );
712  return cb->GetValue();
713  }
714  return false;
715 }
int findLayerRow(LAYER_NUM aLayer) const
Function findLayerRow returns the row index that aLayer resides in, or -1 if not found.
wxWindow * getLayerComp(int aRow, int aColumn) const
Function getLayerComp returns the component within the m_LayersFlexGridSizer at aRow and aCol or NULL...
#define COLUMN_COLOR_LYR_CB
Definition: layer_widget.h:54

References COLUMN_COLOR_LYR_CB, LAYER_WIDGET::findLayerRow(), and LAYER_WIDGET::getLayerComp().

Referenced by GERBVIEW_FRAME::IsLayerVisible().

◆ OnLayerCheckBox()

void LAYER_WIDGET::OnLayerCheckBox ( wxCommandEvent &  event)
protectedinherited

Function OnLayerCheckBox handles the "is layer visible" checkbox and propogates the event to the client's notification function.

Definition at line 168 of file layer_widget.cpp.

169 {
170  wxCheckBox* eventSource = (wxCheckBox*) event.GetEventObject();
171  LAYER_NUM layer = getDecodedId( eventSource->GetId() );
172  OnLayerVisible( layer, eventSource->IsChecked() );
173  passOnFocus();
174 }
virtual void OnLayerVisible(LAYER_NUM aLayer, bool isVisible, bool isFinal=true)=0
Function OnLayerVisible is called to notify client code about a layer visibility change.
static LAYER_NUM getDecodedId(int aControlId)
Function getDecodedId decodes aControlId to original un-encoded value.
int LAYER_NUM
Type LAYER_NUM can be replaced with int and removed.
void passOnFocus()
Function passOnFocus gives away the keyboard focus up to the main parent window.

References LAYER_WIDGET::getDecodedId(), LAYER_WIDGET::OnLayerVisible(), and LAYER_WIDGET::passOnFocus().

Referenced by LAYER_WIDGET::insertLayerRow().

◆ OnLayerColorChange()

void PCB_LAYER_WIDGET::OnLayerColorChange ( int  aLayer,
COLOR4D  aColor 
)
overridevirtual

Function OnLayerColorChange is called to notify client code about a layer color change.

Derived es will handle this accordingly.

Parameters
aLayeris the board layer to change
aColoris the new color

Implements LAYER_WIDGET.

Definition at line 580 of file pcb_layer_widget.cpp.

581 {
584  myframe->ColorSettings()->SetColor( aLayer, aColor );
586 
587  KIGFX::VIEW* view = myframe->GetCanvas()->GetView();
588  view->UpdateLayerColor( aLayer );
589  view->UpdateLayerColor( GetNetnameLayer( aLayer ) );
590 
592 
593  myframe->GetCanvas()->Refresh();
594 
595  if( aLayer == LAYER_PCB_BACKGROUND )
596  myframe->SetDrawBgColor( aColor );
597 }
int GetNetnameLayer(int aLayer)
Returns a netname layer corresponding to the given layer.
PCB_DRAW_PANEL_GAL * GetCanvas() const override
Return a pointer to GAL-based canvas of given EDA draw frame.
PCB_BASE_FRAME * myframe
void SetColorContext(COLOR_CONTEXT aContext=COLOR_CONTEXT::PCB)
void SetDrawBgColor(COLOR4D aColor) override
COLOR_SETTINGS * ColorSettings()
Helper to retrieve the current color settings.
virtual KIGFX::PCB_VIEW * GetView() const override
Function GetView() Returns a pointer to the VIEW instance used in the panel.
virtual void Refresh(bool aEraseBackground=true, const wxRect *aRect=NULL) override
Update the board display after modifying it by a python script (note: it is automatically called by a...
void UpdateColors()
Updates the color settings in the painter and GAL.
void UpdateLayerColor(int aLayer)
Function UpdateLayerColor() Applies the new coloring scheme held by RENDER_SETTINGS in case that it h...
Definition: view.cpp:777
virtual void ReCreateHToolbar()=0
VIEW.
Definition: view.h:61
void SetColor(int aLayer, COLOR4D aColor)

References PCB_BASE_FRAME::ColorSettings(), FOOTPRINT, PCB_BASE_FRAME::GetCanvas(), GetNetnameLayer(), PCB_DRAW_PANEL_GAL::GetView(), LAYER_PCB_BACKGROUND, m_fp_editor_mode, myframe, PCB, EDA_DRAW_FRAME::ReCreateHToolbar(), EDA_DRAW_PANEL_GAL::Refresh(), COLOR_SETTINGS::SetColor(), COLOR_SETTINGS::SetColorContext(), PCB_BASE_FRAME::SetDrawBgColor(), PCB_DRAW_PANEL_GAL::UpdateColors(), and KIGFX::VIEW::UpdateLayerColor().

◆ OnLayerRightClick()

void PCB_LAYER_WIDGET::OnLayerRightClick ( wxMenu &  aMenu)
overridevirtual

Function OnLayerRightClick is called to notify client code about a layer being right-clicked.

Parameters
aMenuis the right-click menu containing layer-scoped options. It can be used to add extra, wider scoped menu items.

Implements LAYER_WIDGET.

Definition at line 660 of file pcb_layer_widget.cpp.

661 {
662  AddRightClickMenuItems( aMenu );
663 }
void AddRightClickMenuItems(wxMenu &menu)
Function addRightClickMenuItems add menu items to a menu that should be shown when right-clicking the...

References AddRightClickMenuItems().

◆ OnLayerSelect()

bool PCB_LAYER_WIDGET::OnLayerSelect ( int  aLayer)
overridevirtual

Function OnLayerSelect is called to notify client code whenever the user selects a different layer.

Derived classes will handle this accordingly, and can deny the change by returning false.

Parameters
aLayeris the board layer to select

Implements LAYER_WIDGET.

Definition at line 600 of file pcb_layer_widget.cpp.

601 {
602  // the layer change from the PCB_LAYER_WIDGET can be denied by returning
603  // false from this function.
604  PCB_LAYER_ID layer = ToLAYER_ID( aLayer );
605 
606  if( m_fp_editor_mode && LSET::ForbiddenFootprintLayers().test( layer ) )
607  return false;
608 
609  myframe->SetActiveLayer( layer );
610 
612  OnLayerSelected();
614  myframe->GetCanvas()->Refresh();
615 
616  return true;
617 }
static LSET ForbiddenFootprintLayers()
Function ForbiddenFootprintLayers Layers which are not allowed within footprint definitions.
Definition: lset.cpp:799
PCB_DRAW_PANEL_GAL * GetCanvas() const override
Return a pointer to GAL-based canvas of given EDA draw frame.
PCB_BASE_FRAME * myframe
bool OnLayerSelected()
Function OnLayerSelected ensure the active layer is visible, and other layers not visible when m_alwa...
const PCB_DISPLAY_OPTIONS & GetDisplayOptions() const
Function GetDisplayOptions returns the display options current in use Display options are relative to...
PCB_LAYER_ID
A quick note on layer IDs:
virtual void SetActiveLayer(PCB_LAYER_ID aLayer)
Function SetActiveLayer will change the currently active layer to aLayer.
virtual void Refresh(bool aEraseBackground=true, const wxRect *aRect=NULL) override
Update the board display after modifying it by a python script (note: it is automatically called by a...
bool m_alwaysShowActiveCopperLayer
PCB_LAYER_ID ToLAYER_ID(int aLayer)
Definition: lset.cpp:823

References LSET::ForbiddenFootprintLayers(), PCB_BASE_FRAME::GetCanvas(), PCB_BASE_FRAME::GetDisplayOptions(), m_alwaysShowActiveCopperLayer, PCB_DISPLAY_OPTIONS::m_ContrastModeDisplay, m_fp_editor_mode, myframe, OnLayerSelected(), EDA_DRAW_PANEL_GAL::Refresh(), PCB_BASE_FRAME::SetActiveLayer(), and ToLAYER_ID().

◆ OnLayerSelected()

bool PCB_LAYER_WIDGET::OnLayerSelected ( )

Function OnLayerSelected ensure the active layer is visible, and other layers not visible when m_alwaysShowActiveLayer is true Otherwise do nothing.

Returns
true m_alwaysShowActiveLayer is true and the canvas is refreshed, and false if do nothing

Definition at line 620 of file pcb_layer_widget.cpp.

621 {
623  return false;
624 
625  // postprocess after an active layer selection
626  // ensure active layer visible
627  wxCommandEvent event;
629  onPopupSelection( event );
630 
631  return true;
632 }
bool m_alwaysShowActiveCopperLayer
void onPopupSelection(wxCommandEvent &event)

References ID_ALWAYS_SHOW_NO_COPPER_LAYERS_BUT_ACTIVE, m_alwaysShowActiveCopperLayer, and onPopupSelection().

Referenced by OnLayerSelect(), and FOOTPRINT_EDIT_FRAME::UpdateUserInterface().

◆ OnLayerSwatchChanged()

void LAYER_WIDGET::OnLayerSwatchChanged ( wxCommandEvent &  aEvent)
protectedinherited

Function OnSwatchChanged() is called when a user changes a swatch color.

Definition at line 149 of file layer_widget.cpp.

150 {
151  auto eventSource = static_cast<COLOR_SWATCH*>( aEvent.GetEventObject() );
152 
153  COLOR4D newColor = eventSource->GetSwatchColor();
154 
155  LAYER_NUM layer = getDecodedId( eventSource->GetId() );
156 
157  // tell the client code.
158  OnLayerColorChange( layer, newColor );
159 
160  // notify others
161  wxCommandEvent event( EVT_LAYER_COLOR_CHANGE );
162  wxPostEvent( this, event );
163 
164  passOnFocus();
165 }
static const wxEventType EVT_LAYER_COLOR_CHANGE
Definition: layer_widget.h:123
virtual void OnLayerColorChange(int aLayer, COLOR4D aColor)=0
Function OnLayerColorChange is called to notify client code about a layer color change.
static LAYER_NUM getDecodedId(int aControlId)
Function getDecodedId decodes aControlId to original un-encoded value.
int LAYER_NUM
Type LAYER_NUM can be replaced with int and removed.
void passOnFocus()
Function passOnFocus gives away the keyboard focus up to the main parent window.
COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:40

References LAYER_WIDGET::EVT_LAYER_COLOR_CHANGE, LAYER_WIDGET::getDecodedId(), LAYER_WIDGET::OnLayerColorChange(), and LAYER_WIDGET::passOnFocus().

Referenced by LAYER_WIDGET::insertLayerRow().

◆ OnLayerVisible()

void PCB_LAYER_WIDGET::OnLayerVisible ( int  aLayer,
bool  isVisible,
bool  isFinal 
)
overridevirtual

Function OnLayerVisible is called to notify client code about a layer visibility change.

Parameters
aLayeris the board layer to select
isVisibleis the new visible state
isFinalis true when this is the last of potentially several such calls, and can be used to decide when to update the screen only one time instead of several times in the midst of a multiple layer change.

Implements LAYER_WIDGET.

Definition at line 635 of file pcb_layer_widget.cpp.

636 {
637  BOARD* brd = myframe->GetBoard();
638 
639  LSET visibleLayers = brd->GetVisibleLayers();
640 
641  if( visibleLayers.test( aLayer ) != isVisible )
642  {
643  visibleLayers.set( aLayer, isVisible );
644 
645  brd->SetVisibleLayers( visibleLayers );
646 
647  // Layer visibility is not stored in .kicad_mod files
648  if( !m_fp_editor_mode )
649  myframe->OnModify();
650 
651  if( myframe->GetCanvas() )
652  myframe->GetCanvas()->GetView()->SetLayerVisible( aLayer, isVisible );
653  }
654 
655  if( isFinal )
656  myframe->GetCanvas()->Refresh();
657 }
PCB_DRAW_PANEL_GAL * GetCanvas() const override
Return a pointer to GAL-based canvas of given EDA draw frame.
LSET GetVisibleLayers() const
Function GetVisibleLayers is a proxy function that calls the correspondent function in m_BoardSetting...
PCB_BASE_FRAME * myframe
LSET is a set of PCB_LAYER_IDs.
void SetVisibleLayers(LSET aLayerMask)
Function SetVisibleLayers is a proxy function that calls the correspondent function in m_BoardSetting...
void SetLayerVisible(int aLayer, bool aVisible=true)
Function SetLayerVisible() Controls the visibility of a particular layer.
Definition: view.h:399
virtual KIGFX::PCB_VIEW * GetView() const override
Function GetView() Returns a pointer to the VIEW instance used in the panel.
virtual void Refresh(bool aEraseBackground=true, const wxRect *aRect=NULL) override
Update the board display after modifying it by a python script (note: it is automatically called by a...
virtual void OnModify()
Function OnModify Virtual Must be called after a change in order to set the "modify" flag of the curr...
BOARD holds information pertinent to a Pcbnew printed circuit board.
Definition: class_board.h:163
BOARD * GetBoard() const

References PCB_BASE_FRAME::GetBoard(), PCB_BASE_FRAME::GetCanvas(), PCB_DRAW_PANEL_GAL::GetView(), BOARD::GetVisibleLayers(), m_fp_editor_mode, myframe, PCB_BASE_FRAME::OnModify(), EDA_DRAW_PANEL_GAL::Refresh(), KIGFX::VIEW::SetLayerVisible(), and BOARD::SetVisibleLayers().

Referenced by onPopupSelection().

◆ OnLeftDownLayers()

void LAYER_WIDGET::OnLeftDownLayers ( wxMouseEvent &  event)
protectedinherited

Definition at line 77 of file layer_widget.cpp.

78 {
79  int row;
80  LAYER_NUM layer;
81 
82  wxWindow* eventSource = (wxWindow*) event.GetEventObject();
83 
84  // if mouse event is coming from the m_LayerScrolledWindow and not one
85  // of its children, we have to find the row manually based on y coord.
86  if( eventSource == m_LayerScrolledWindow )
87  {
88  int y = event.GetY();
89 
90  wxArrayInt heights = m_LayersFlexGridSizer->GetRowHeights();
91 
92  int height = 0;
93 
94  int rowCount = GetLayerRowCount();
95  for( row = 0; row<rowCount; ++row )
96  {
97  if( y < height + heights[row] )
98  break;
99 
100  height += heights[row];
101  }
102 
103  if( row >= rowCount )
104  row = rowCount - 1;
105 
106  layer = getDecodedId( getLayerComp( row, 0 )->GetId() );
107  }
108 
109  else
110  {
111  // all nested controls on a given row will have their ID encoded with
112  // encodeId(), and the corresponding decoding is getDecodedId()
113  int id = eventSource->GetId();
114  layer = getDecodedId( id );
115  row = findLayerRow( layer );
116  }
117 
118  if( OnLayerSelect( layer ) ) // if client allows this change.
119  SelectLayerRow( row );
120 
121  passOnFocus();
122 }
int findLayerRow(LAYER_NUM aLayer) const
Function findLayerRow returns the row index that aLayer resides in, or -1 if not found.
wxFlexGridSizer * m_LayersFlexGridSizer
Definition: layer_widget.h:130
wxWindow * getLayerComp(int aRow, int aColumn) const
Function getLayerComp returns the component within the m_LayersFlexGridSizer at aRow and aCol or NULL...
wxScrolledWindow * m_LayerScrolledWindow
Definition: layer_widget.h:129
void SelectLayerRow(int aRow)
Function SelectLayerRow changes the row selection in the layer list to the given row.
static LAYER_NUM getDecodedId(int aControlId)
Function getDecodedId decodes aControlId to original un-encoded value.
int LAYER_NUM
Type LAYER_NUM can be replaced with int and removed.
int GetLayerRowCount() const
Function GetLayerRowCount returns the number of rows in the layer tab.
void passOnFocus()
Function passOnFocus gives away the keyboard focus up to the main parent window.
virtual bool OnLayerSelect(int aLayer)=0
Function OnLayerSelect is called to notify client code whenever the user selects a different layer.

References LAYER_WIDGET::findLayerRow(), LAYER_WIDGET::getDecodedId(), LAYER_WIDGET::getLayerComp(), LAYER_WIDGET::GetLayerRowCount(), LAYER_WIDGET::m_LayerScrolledWindow, LAYER_WIDGET::m_LayersFlexGridSizer, LAYER_WIDGET::OnLayerSelect(), LAYER_WIDGET::passOnFocus(), and LAYER_WIDGET::SelectLayerRow().

Referenced by LAYER_WIDGET::insertLayerRow().

◆ onPopupSelection()

void PCB_LAYER_WIDGET::onPopupSelection ( wxCommandEvent &  event)
protected

Definition at line 203 of file pcb_layer_widget.cpp.

204 {
205  int rowCount;
206  int menuId = event.GetId();
207  bool visible;
208  bool force_active_layer_visible;
209 
211  force_active_layer_visible = ( menuId == ID_SHOW_NO_COPPER_LAYERS_BUT_ACTIVE ||
213 
214  switch( menuId )
215  {
216  case ID_SHOW_NO_LAYERS:
217  case ID_SHOW_ALL_LAYERS:
218  {
219  visible = ( menuId == ID_SHOW_ALL_LAYERS );
220  rowCount = GetLayerRowCount();
221 
222  for( int row=0; row<rowCount; ++row )
223  {
224  bool isLast;
225  wxCheckBox* cb = (wxCheckBox*) getLayerComp( row, COLUMN_COLOR_LYR_CB );
226  PCB_LAYER_ID layer = ToLAYER_ID( getDecodedId( cb->GetId() ) );
227  cb->SetValue( visible );
228 
229  isLast = row == rowCount-1;
230 
231  OnLayerVisible( layer, visible, isLast );
232 
233  if( isLast )
234  break;
235  }
236  break;
237  }
238 
245  {
246 
247  // Search the last copper layer row index:
248  int lastCu = -1;
249  rowCount = GetLayerRowCount();
250  for( int row = rowCount-1; row>=0; --row )
251  {
252  wxCheckBox* cb = (wxCheckBox*) getLayerComp( row, COLUMN_COLOR_LYR_CB );
253  PCB_LAYER_ID layer = ToLAYER_ID( getDecodedId( cb->GetId() ) );
254 
255  if( IsCopperLayer( layer ) )
256  {
257  lastCu = row;
258  break;
259  }
260  }
261 
262  // Enable/disable the copper layers visibility:
263  int startrow = 0;
264 
265  if( ( menuId == ID_SHOW_ALL_NON_COPPER ) ||
266  ( menuId == ID_HIDE_ALL_NON_COPPER ) )
267  {
268  startrow = lastCu + 1;
269  }
270 
271  for( int row = startrow; row<rowCount; ++row )
272  {
273  wxCheckBox* cb = (wxCheckBox*) getLayerComp( row, COLUMN_COLOR_LYR_CB );
274  PCB_LAYER_ID layer = ToLAYER_ID( getDecodedId( cb->GetId() ) );
275 
276  visible = ( ( menuId == ID_SHOW_ALL_COPPER_LAYERS ) || ( menuId == ID_SHOW_ALL_NON_COPPER ) );
277 
278  if( force_active_layer_visible && (layer == myframe->GetActiveLayer() ) )
279  visible = true;
280 
281  cb->SetValue( visible );
282 
283  bool isLastLayer = (row == lastCu);
284 
285  if( ( menuId == ID_SHOW_ALL_NON_COPPER ) ||
286  ( menuId == ID_HIDE_ALL_NON_COPPER ) )
287  {
288  isLastLayer = false;
289  }
290  OnLayerVisible( layer, visible, isLastLayer );
291 
292  if( isLastLayer )
293  break;
294  }
295  break;
296  }
297 
298  case ID_SHOW_ALL_FRONT:
299  {
300  visible = false;
301  rowCount = GetLayerRowCount();
302 
303  for( int row=0; row<rowCount; ++row )
304  {
305  bool isLast;
306  wxCheckBox* cb = (wxCheckBox*) getLayerComp( row, COLUMN_COLOR_LYR_CB );
307  PCB_LAYER_ID layer = ToLAYER_ID( getDecodedId( cb->GetId() ) );
308  isLast = ( row == rowCount-1 );
309 
310  if( layer == F_Paste || layer == F_SilkS ||
311  layer == F_Mask || layer == F_Cu ||
312  layer == F_Fab || layer == F_CrtYd || layer == Edge_Cuts )
313  {
314  visible = true;
315  }
316  else
317  {
318  visible = false;
319  }
320 
321  cb->SetValue( visible );
322  OnLayerVisible( layer, visible, isLast );
323 
324  if( isLast )
325  break;
326  }
327  break;
328  }
329  case ID_SHOW_ALL_BACK:
330  {
331  visible = false;
332  rowCount = GetLayerRowCount();
333 
334  for( int row=0; row<rowCount; ++row )
335  {
336  bool isLast;
337  wxCheckBox* cb = (wxCheckBox*) getLayerComp( row, COLUMN_COLOR_LYR_CB );
338  PCB_LAYER_ID layer = ToLAYER_ID( getDecodedId( cb->GetId() ) );
339  isLast = ( row == rowCount-1 );
340 
341  if( layer == B_Paste || layer == B_SilkS ||
342  layer == B_Mask || layer == B_Cu ||
343  layer == B_Fab || layer == B_CrtYd || layer == Edge_Cuts )
344  {
345  visible = true;
346  }
347  else
348  {
349  visible = false;
350  }
351 
352  cb->SetValue( visible );
353  OnLayerVisible( layer, visible, isLast );
354 
355  if( isLast )
356  break;
357  }
358  break;
359  }
360  }
361 }
bool isLast(CPTREE &aTree, CITER it)
Definition: ptree.cpp:122
PCB_BASE_FRAME * myframe
wxWindow * getLayerComp(int aRow, int aColumn) const
Function getLayerComp returns the component within the m_LayersFlexGridSizer at aRow and aCol or NULL...
virtual PCB_LAYER_ID GetActiveLayer() const
Function GetActiveLayer returns the active layer.
PCB_LAYER_ID
A quick note on layer IDs:
static LAYER_NUM getDecodedId(int aControlId)
Function getDecodedId decodes aControlId to original un-encoded value.
bool m_alwaysShowActiveCopperLayer
int GetLayerRowCount() const
Function GetLayerRowCount returns the number of rows in the layer tab.
void OnLayerVisible(int aLayer, bool isVisible, bool isFinal) override
Function OnLayerVisible is called to notify client code about a layer visibility change.
#define COLUMN_COLOR_LYR_CB
Definition: layer_widget.h:54
bool IsCopperLayer(LAYER_NUM aLayerId)
Function IsCopperLayer tests whether a layer is a copper layer.
PCB_LAYER_ID ToLAYER_ID(int aLayer)
Definition: lset.cpp:823

References B_CrtYd, B_Cu, B_Fab, B_Mask, B_Paste, B_SilkS, COLUMN_COLOR_LYR_CB, Edge_Cuts, F_CrtYd, F_Cu, F_Fab, F_Mask, F_Paste, F_SilkS, PCB_BASE_FRAME::GetActiveLayer(), LAYER_WIDGET::getDecodedId(), LAYER_WIDGET::getLayerComp(), LAYER_WIDGET::GetLayerRowCount(), ID_ALWAYS_SHOW_NO_COPPER_LAYERS_BUT_ACTIVE, ID_HIDE_ALL_NON_COPPER, ID_SHOW_ALL_BACK, ID_SHOW_ALL_COPPER_LAYERS, ID_SHOW_ALL_FRONT, ID_SHOW_ALL_LAYERS, ID_SHOW_ALL_NON_COPPER, ID_SHOW_NO_COPPER_LAYERS, ID_SHOW_NO_COPPER_LAYERS_BUT_ACTIVE, ID_SHOW_NO_LAYERS, IsCopperLayer(), isLast(), m_alwaysShowActiveCopperLayer, myframe, OnLayerVisible(), and ToLAYER_ID().

Referenced by OnLayerSelected(), and PCB_LAYER_WIDGET().

◆ OnRenderCheckBox()

void LAYER_WIDGET::OnRenderCheckBox ( wxCommandEvent &  event)
protectedinherited

Definition at line 236 of file layer_widget.cpp.

237 {
238  wxCheckBox* eventSource = (wxCheckBox*) event.GetEventObject();
239  LAYER_NUM id = getDecodedId( eventSource->GetId() );
240  OnRenderEnable( id, eventSource->IsChecked() );
241  passOnFocus();
242 }
virtual void OnRenderEnable(int aId, bool isEnabled)=0
Function OnRenderEnable is called to notify client code whenever the user changes an rendering enable...
static LAYER_NUM getDecodedId(int aControlId)
Function getDecodedId decodes aControlId to original un-encoded value.
int LAYER_NUM
Type LAYER_NUM can be replaced with int and removed.
void passOnFocus()
Function passOnFocus gives away the keyboard focus up to the main parent window.

References LAYER_WIDGET::getDecodedId(), LAYER_WIDGET::OnRenderEnable(), and LAYER_WIDGET::passOnFocus().

Referenced by LAYER_WIDGET::insertRenderRow().

◆ OnRenderColorChange()

void PCB_LAYER_WIDGET::OnRenderColorChange ( int  aId,
COLOR4D  aColor 
)
overridevirtual

Function OnRenderColorChange is called to notify client code whenever the user changes a rendering color.

Parameters
aIdis the same id that was established in a Rendering row via the AddRenderRow() function.
aColoris the new color

Implements LAYER_WIDGET.

Definition at line 666 of file pcb_layer_widget.cpp.

667 {
668  wxASSERT( aId > GAL_LAYER_ID_START && aId < GAL_LAYER_ID_END );
669 
672  myframe->ColorSettings()->SetColor( aId, aColor );
674 
675  KIGFX::VIEW* view = myframe->GetCanvas()->GetView();
676  view->MarkTargetDirty( KIGFX::TARGET_NONCACHED ); // useful to update rastnest
677  view->UpdateLayerColor( aId );
678 
679  // plated-through-holes don't have their own color; they use the background color
680  if( aId == LAYER_PCB_BACKGROUND )
682 
685  myframe->GetCanvas()->Refresh();
686 }
void ForceRefresh()
Function ForceRefresh() Forces a redraw.
PCB_DRAW_PANEL_GAL * GetCanvas() const override
Return a pointer to GAL-based canvas of given EDA draw frame.
PCB_BASE_FRAME * myframe
void SetColorContext(COLOR_CONTEXT aContext=COLOR_CONTEXT::PCB)
Add new GAL layers here.
Auxiliary rendering target (noncached)
Definition: definitions.h:49
void MarkTargetDirty(int aTarget)
Function MarkTargetDirty() Sets or clears target 'dirty' flag.
Definition: view.h:585
COLOR_SETTINGS * ColorSettings()
Helper to retrieve the current color settings.
virtual KIGFX::PCB_VIEW * GetView() const override
Function GetView() Returns a pointer to the VIEW instance used in the panel.
virtual void Refresh(bool aEraseBackground=true, const wxRect *aRect=NULL) override
Update the board display after modifying it by a python script (note: it is automatically called by a...
void UpdateColors()
Updates the color settings in the painter and GAL.
void UpdateLayerColor(int aLayer)
Function UpdateLayerColor() Applies the new coloring scheme held by RENDER_SETTINGS in case that it h...
Definition: view.cpp:777
virtual void ReCreateHToolbar()=0
VIEW.
Definition: view.h:61
void SetColor(int aLayer, COLOR4D aColor)

References PCB_BASE_FRAME::ColorSettings(), FOOTPRINT, EDA_DRAW_PANEL_GAL::ForceRefresh(), GAL_LAYER_ID_END, GAL_LAYER_ID_START, PCB_BASE_FRAME::GetCanvas(), PCB_DRAW_PANEL_GAL::GetView(), LAYER_PADS_PLATEDHOLES, LAYER_PCB_BACKGROUND, m_fp_editor_mode, KIGFX::VIEW::MarkTargetDirty(), myframe, PCB, EDA_DRAW_FRAME::ReCreateHToolbar(), EDA_DRAW_PANEL_GAL::Refresh(), COLOR_SETTINGS::SetColor(), COLOR_SETTINGS::SetColorContext(), KIGFX::TARGET_NONCACHED, PCB_DRAW_PANEL_GAL::UpdateColors(), and KIGFX::VIEW::UpdateLayerColor().

◆ OnRenderEnable()

void PCB_LAYER_WIDGET::OnRenderEnable ( int  aId,
bool  isEnabled 
)
overridevirtual

Function OnRenderEnable is called to notify client code whenever the user changes an rendering enable in one of the rendering checkboxes.

Parameters
aIdis the same id that was established in a Rendering row via the AddRenderRow() function.
isEnabledis the state of the checkbox, true if checked.

Implements LAYER_WIDGET.

Definition at line 689 of file pcb_layer_widget.cpp.

690 {
691  BOARD* brd = myframe->GetBoard();
692  wxASSERT( aId > GAL_LAYER_ID_START && aId < GAL_LAYER_ID_END );
693 
695  {
696  // The layer visibility status is saved in the board file so set the board
697  // modified state so the user has the option to save the changes.
698  if( brd->IsElementVisible( static_cast<GAL_LAYER_ID>( aId ) ) != isEnabled )
699  myframe->OnModify();
700  }
701 
702  // Grid is not set through the board visibility
703  if( aId == LAYER_GRID )
704  myframe->SetGridVisibility( isEnabled );
705  else
706  brd->SetElementVisibility( static_cast<GAL_LAYER_ID>( aId ), isEnabled );
707 
708  if( aId == LAYER_RATSNEST )
709  {
710  // don't touch the layers. ratsnest is enabled on per-item basis.
712  myframe->GetCanvas()->GetView()->SetLayerVisible( aId, true );
713 
715  {
717  opt.m_ShowGlobalRatsnest = isEnabled;
719  }
720  }
721  else if( aId != LAYER_GRID )
722  myframe->GetCanvas()->GetView()->SetLayerVisible( aId, isEnabled );
723 
724  myframe->GetCanvas()->Refresh();
725  myframe->GetCanvas()->Refresh();
726 }
void SetElementVisibility(GAL_LAYER_ID aLayer, bool aNewState)
Function SetElementVisibility changes the visibility of an element category.
PCB_DRAW_PANEL_GAL * GetCanvas() const override
Return a pointer to GAL-based canvas of given EDA draw frame.
PCB_BASE_FRAME * myframe
Add new GAL layers here.
const PCB_DISPLAY_OPTIONS & GetDisplayOptions() const
Function GetDisplayOptions returns the display options current in use Display options are relative to...
Auxiliary rendering target (noncached)
Definition: definitions.h:49
PCB_DISPLAY_OPTIONS handles display options like enable/disable some optional drawings.
void UpdateDisplayOptions(const PCB_DISPLAY_OPTIONS &aOptions)
Definition: pcb_view.cpp:113
void MarkTargetDirty(int aTarget)
Function MarkTargetDirty() Sets or clears target 'dirty' flag.
Definition: view.h:585
void SetLayerVisible(int aLayer, bool aVisible=true)
Function SetLayerVisible() Controls the visibility of a particular layer.
Definition: view.h:399
virtual KIGFX::PCB_VIEW * GetView() const override
Function GetView() Returns a pointer to the VIEW instance used in the panel.
virtual void Refresh(bool aEraseBackground=true, const wxRect *aRect=NULL) override
Update the board display after modifying it by a python script (note: it is automatically called by a...
bool IsElementVisible(GAL_LAYER_ID aLayer) const
Function IsElementVisible tests whether a given element category is visible.
virtual void OnModify()
Function OnModify Virtual Must be called after a change in order to set the "modify" flag of the curr...
bool IsType(FRAME_T aType) const
BOARD holds information pertinent to a Pcbnew printed circuit board.
Definition: class_board.h:163
virtual void SetGridVisibility(bool aVisible) override
Function SetGridVisibility() Turn the display of the canvas grid on/off.
BOARD * GetBoard() const

References FRAME_PCB_EDITOR, GAL_LAYER_ID_END, GAL_LAYER_ID_START, PCB_BASE_FRAME::GetBoard(), PCB_BASE_FRAME::GetCanvas(), PCB_BASE_FRAME::GetDisplayOptions(), PCB_DRAW_PANEL_GAL::GetView(), BOARD::IsElementVisible(), EDA_BASE_FRAME::IsType(), LAYER_GRID, LAYER_RATSNEST, PCB_DISPLAY_OPTIONS::m_ShowGlobalRatsnest, KIGFX::VIEW::MarkTargetDirty(), myframe, PCB_BASE_FRAME::OnModify(), EDA_DRAW_PANEL_GAL::Refresh(), BOARD::SetElementVisibility(), PCB_BASE_FRAME::SetGridVisibility(), KIGFX::VIEW::SetLayerVisible(), KIGFX::TARGET_NONCACHED, and KIGFX::PCB_VIEW::UpdateDisplayOptions().

◆ OnRenderSwatchChanged()

void LAYER_WIDGET::OnRenderSwatchChanged ( wxCommandEvent &  aEvent)
protectedinherited

Function OnRenderSwatchChanged Called when user has changed the swatch color of a render entry.

Definition at line 198 of file layer_widget.cpp.

199 {
200  auto eventSource = static_cast<COLOR_SWATCH*>( aEvent.GetEventObject() );
201 
202  COLOR4D newColor = eventSource->GetSwatchColor();
203 
204  LAYER_NUM id = getDecodedId( eventSource->GetId() );
205 
206  if( id == LAYER_PCB_BACKGROUND )
207  {
208  // Update all swatch backgrounds
209  int count = GetLayerRowCount();
210  int row;
211  int col = 1; // bitmap button is column 1 in layers tab
212  for( row = 0; row < count; ++row )
213  {
214  COLOR_SWATCH* swatch = dynamic_cast<COLOR_SWATCH*>( getLayerComp( row, col ) );
215  if( swatch )
216  swatch->SetSwatchBackground( newColor );
217  }
218 
219  count = GetRenderRowCount();
220  col = 0; // bitmap button is column 0 in render tab
221  for( row = 0; row < count; ++row )
222  {
223  COLOR_SWATCH* swatch = dynamic_cast<COLOR_SWATCH*>( getRenderComp( row, col ) );
224  if( swatch )
225  swatch->SetSwatchBackground( newColor );
226  }
227  }
228 
229  // tell the client code.
230  OnRenderColorChange( id, newColor );
231 
232  passOnFocus();
233 }
virtual void OnRenderColorChange(int aId, COLOR4D aColor)=0
Function OnRenderColorChange is called to notify client code whenever the user changes a rendering co...
wxWindow * getLayerComp(int aRow, int aColumn) const
Function getLayerComp returns the component within the m_LayersFlexGridSizer at aRow and aCol or NULL...
void SetSwatchBackground(KIGFX::COLOR4D aBackground)
Set the swatch background color.
wxWindow * getRenderComp(int aRow, int aColumn) const
static LAYER_NUM getDecodedId(int aControlId)
Function getDecodedId decodes aControlId to original un-encoded value.
int LAYER_NUM
Type LAYER_NUM can be replaced with int and removed.
int GetLayerRowCount() const
Function GetLayerRowCount returns the number of rows in the layer tab.
void passOnFocus()
Function passOnFocus gives away the keyboard focus up to the main parent window.
Class representing a simple color swatch, of the kind used to set layer colors.
Definition: color_swatch.h:38
int GetRenderRowCount() const
Function GetRenderRowCount returns the number of rows in the render tab.
COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:40

References LAYER_WIDGET::getDecodedId(), LAYER_WIDGET::getLayerComp(), LAYER_WIDGET::GetLayerRowCount(), LAYER_WIDGET::getRenderComp(), LAYER_WIDGET::GetRenderRowCount(), LAYER_PCB_BACKGROUND, LAYER_WIDGET::OnRenderColorChange(), LAYER_WIDGET::passOnFocus(), and COLOR_SWATCH::SetSwatchBackground().

Referenced by LAYER_WIDGET::insertRenderRow().

◆ OnRightDownLayer()

void LAYER_WIDGET::OnRightDownLayer ( wxMouseEvent &  event,
COLOR_SWATCH aColorSwatch,
const wxString &  aLayerName 
)
protectedinherited

Function OnRightDownLayer Called when user right-clicks a layer.

Definition at line 125 of file layer_widget.cpp.

126 {
127  wxMenu menu;
128 
130  _( "Change Layer Color for " ) + aLayerName,
132  menu.AppendSeparator();
133 
134  OnLayerRightClick( menu );
135 
136  menu.Bind( wxEVT_COMMAND_MENU_SELECTED, [aColorSwatch]( wxCommandEvent& event ) {
137  if ( event.GetId() == ID_CHANGE_LAYER_COLOR ) {
138  aColorSwatch->GetNewSwatchColor();
139  } else {
140  event.Skip();
141  }
142  } );
143 
144  PopupMenu( &menu );
145  passOnFocus();
146 }
wxMenuItem * AddMenuItem(wxMenu *aMenu, int aId, const wxString &aText, const wxBitmap &aImage, wxItemKind aType=wxITEM_NORMAL)
Function AddMenuItem is an inline helper function to create and insert a menu item with an icon into ...
Definition: bitmap.cpp:250
wxBitmap KiBitmap(BITMAP_DEF aBitmap)
Construct a wxBitmap from a memory record, held in a BITMAP_DEF.
Definition: bitmap.cpp:80
const BITMAP_OPAQUE setcolor_copper_xpm[1]
void passOnFocus()
Function passOnFocus gives away the keyboard focus up to the main parent window.
#define _(s)
Definition: 3d_actions.cpp:33
virtual void OnLayerRightClick(wxMenu &aMenu)=0
Function OnLayerRightClick is called to notify client code about a layer being right-clicked.
void GetNewSwatchColor()
Prompt for a new colour, using the colour picker dialog.

References _, AddMenuItem(), COLOR_SWATCH::GetNewSwatchColor(), LAYER_WIDGET::ID_CHANGE_LAYER_COLOR, KiBitmap(), LAYER_WIDGET::OnLayerRightClick(), LAYER_WIDGET::passOnFocus(), and setcolor_copper_xpm.

Referenced by LAYER_WIDGET::insertLayerRow().

◆ onRightDownLayers()

void PCB_LAYER_WIDGET::onRightDownLayers ( wxMouseEvent &  event)
protected

Function OnRightDownLayers puts up a popup menu for the layer panel.

Definition at line 192 of file pcb_layer_widget.cpp.

193 {
194  wxMenu menu;
195 
196  AddRightClickMenuItems( menu );
197  PopupMenu( &menu );
198 
199  passOnFocus();
200 }
void AddRightClickMenuItems(wxMenu &menu)
Function addRightClickMenuItems add menu items to a menu that should be shown when right-clicking the...
void passOnFocus()
Function passOnFocus gives away the keyboard focus up to the main parent window.

References AddRightClickMenuItems(), and LAYER_WIDGET::passOnFocus().

Referenced by PCB_LAYER_WIDGET().

◆ OnRightDownRender()

void LAYER_WIDGET::OnRightDownRender ( wxMouseEvent &  aEvent,
COLOR_SWATCH aColorSwatch,
const wxString &  aRenderName 
)
protectedinherited

Function OnRightDownRender Called when user right-clicks a render option.

Definition at line 177 of file layer_widget.cpp.

178 {
179  wxMenu menu;
180 
182  _( "Change Render Color for " ) + aRenderName,
184 
185  menu.Bind( wxEVT_COMMAND_MENU_SELECTED, [aColorSwatch]( wxCommandEvent& event ) {
186  if ( event.GetId() == ID_CHANGE_RENDER_COLOR ) {
187  aColorSwatch->GetNewSwatchColor();
188  } else {
189  event.Skip();
190  }
191  } );
192 
193  PopupMenu( &menu );
194  passOnFocus();
195 }
wxMenuItem * AddMenuItem(wxMenu *aMenu, int aId, const wxString &aText, const wxBitmap &aImage, wxItemKind aType=wxITEM_NORMAL)
Function AddMenuItem is an inline helper function to create and insert a menu item with an icon into ...
Definition: bitmap.cpp:250
const BITMAP_OPAQUE setcolor_board_body_xpm[1]
wxBitmap KiBitmap(BITMAP_DEF aBitmap)
Construct a wxBitmap from a memory record, held in a BITMAP_DEF.
Definition: bitmap.cpp:80
void passOnFocus()
Function passOnFocus gives away the keyboard focus up to the main parent window.
#define _(s)
Definition: 3d_actions.cpp:33
void GetNewSwatchColor()
Prompt for a new colour, using the colour picker dialog.

References _, AddMenuItem(), COLOR_SWATCH::GetNewSwatchColor(), LAYER_WIDGET::ID_CHANGE_RENDER_COLOR, KiBitmap(), LAYER_WIDGET::passOnFocus(), and setcolor_board_body_xpm.

Referenced by LAYER_WIDGET::insertRenderRow().

◆ OnTabChange()

void LAYER_WIDGET::OnTabChange ( wxNotebookEvent &  event)
protectedinherited

Definition at line 245 of file layer_widget.cpp.

246 {
247 // wxFocusEvent event( wxEVT_SET_FOCUS );
248 // m_FocusOwner->AddPendingEvent( event );
249 
250  passOnFocus(); // does not work in this context, probably because we have receive control here too early.
251 }
void passOnFocus()
Function passOnFocus gives away the keyboard focus up to the main parent window.

References LAYER_WIDGET::passOnFocus().

Referenced by LAYER_WIDGET::LAYER_WIDGET().

◆ passOnFocus()

◆ ReFill()

void PCB_LAYER_WIDGET::ReFill ( )

Definition at line 484 of file pcb_layer_widget.cpp.

485 {
486  BOARD* brd = myframe->GetBoard();
487  LSET enabled = brd->GetEnabledLayers();
488 
491 
492  ClearLayerRows();
493 
494  wxString dsc;
495 
496  // show all coppers first, with front on top, back on bottom, then technical layers
497  for( LSEQ cu_stack = enabled.CuStack(); cu_stack; ++cu_stack )
498  {
499  PCB_LAYER_ID layer = *cu_stack;
500 
501  switch( layer )
502  {
503  case F_Cu:
504  dsc = _( "Front copper layer" );
505  break;
506 
507  case B_Cu:
508  dsc = _( "Back copper layer" );
509  break;
510 
511  default:
512  dsc = _( "Inner copper layer" );
513  break;
514  }
515 
516  AppendLayerRow( LAYER_WIDGET::ROW( brd->GetLayerName( layer ), layer,
517  myframe->ColorSettings()->GetColor( layer ), dsc, true, true,
518  myframe->ColorSettings()->GetDefaultColor( layer ) ) );
519 
520  if( m_fp_editor_mode && LSET::ForbiddenFootprintLayers().test( layer ) )
521  {
522  getLayerComp( GetLayerRowCount()-1, COLUMN_COLOR_LYRNAME )->Enable( false );
523  getLayerComp( GetLayerRowCount()-1, COLUMN_COLORBM )->SetToolTip( wxEmptyString );
524  }
525  }
526 
527  UpdateLayouts();
528 
529 
530  // technical layers are shown in this order:
531  // Because they are static, wxGetTranslation must be explicitly
532  // called for tooltips.
533  static const struct {
534  PCB_LAYER_ID layerId;
535  wxString tooltip;
536  } non_cu_seq[] = {
537  { F_Adhes, _( "Adhesive on board's front" ) },
538  { B_Adhes, _( "Adhesive on board's back" ) },
539  { F_Paste, _( "Solder paste on board's front" ) },
540  { B_Paste, _( "Solder paste on board's back" ) },
541  { F_SilkS, _( "Silkscreen on board's front" ) },
542  { B_SilkS, _( "Silkscreen on board's back" ) },
543  { F_Mask, _( "Solder mask on board's front" ) },
544  { B_Mask, _( "Solder mask on board's back" ) },
545  { Dwgs_User, _( "Explanatory drawings" ) },
546  { Cmts_User, _( "Explanatory comments" ) },
547  { Eco1_User, _( "User defined meaning" ) },
548  { Eco2_User, _( "User defined meaning" ) },
549  { Edge_Cuts, _( "Board's perimeter definition" ) },
550  { Margin, _( "Board's edge setback outline" ) },
551  { F_CrtYd, _( "Footprint courtyards on board's front" ) },
552  { B_CrtYd, _( "Footprint courtyards on board's back" ) },
553  { F_Fab, _( "Footprint assembly on board's front" ) },
554  { B_Fab, _( "Footprint assembly on board's back" ) }
555  };
556 
557  for( unsigned i=0; i<arrayDim( non_cu_seq ); ++i )
558  {
559  PCB_LAYER_ID layer = non_cu_seq[i].layerId;
560 
561  if( !enabled[layer] )
562  continue;
563 
564  AppendLayerRow( LAYER_WIDGET::ROW( brd->GetLayerName( layer ), layer,
565  myframe->ColorSettings()->GetColor( layer ),
566  wxGetTranslation( non_cu_seq[i].tooltip ), true, true,
567  myframe->ColorSettings()->GetDefaultColor( layer ) ) );
568 
569  if( m_fp_editor_mode && LSET::ForbiddenFootprintLayers().test( layer ) )
570  {
571  getLayerComp( GetLayerRowCount()-1, COLUMN_COLOR_LYRNAME )->Enable( false );
572  getLayerComp( GetLayerRowCount()-1, COLUMN_COLORBM )->SetToolTip( wxEmptyString );
573  }
574  }
575 }
#define COLUMN_COLOR_LYRNAME
Definition: layer_widget.h:55
LSEQ CuStack() const
Function CuStack returns a sequence of copper layers in starting from the front/top and extending to ...
Definition: lset.cpp:155
const wxString GetLayerName(PCB_LAYER_ID aLayer) const
Function GetLayerName returns the name of a layer given by aLayer.
Struct ROW provides all the data needed to add a row to a LAYER_WIDGET.
Definition: layer_widget.h:87
static LSET ForbiddenFootprintLayers()
Function ForbiddenFootprintLayers Layers which are not allowed within footprint definitions.
Definition: lset.cpp:799
void UpdateLayouts()
PCB_BASE_FRAME * myframe
void SetColorContext(COLOR_CONTEXT aContext=COLOR_CONTEXT::PCB)
wxWindow * getLayerComp(int aRow, int aColumn) const
Function getLayerComp returns the component within the m_LayersFlexGridSizer at aRow and aCol or NULL...
LSET GetEnabledLayers() const
Function GetEnabledLayers is a proxy function that calls the corresponding function in m_BoardSetting...
void ClearLayerRows()
Function ClearLayerRows empties out the layer rows.
PCB_LAYER_ID
A quick note on layer IDs:
LSET is a set of PCB_LAYER_IDs.
#define COLUMN_COLORBM
Definition: layer_widget.h:53
COLOR_SETTINGS * ColorSettings()
Helper to retrieve the current color settings.
void AppendLayerRow(const ROW &aRow)
Function AppendLayerRow appends a new row in the layer portion of the widget.
COLOR4D GetDefaultColor(int aLayer)
LSEQ is a sequence (and therefore also a set) of PCB_LAYER_IDs.
constexpr std::size_t arrayDim(T const (&)[N]) noexcept
Definition: macros.h:108
int GetLayerRowCount() const
Function GetLayerRowCount returns the number of rows in the layer tab.
COLOR4D GetColor(int aLayer) const
BOARD holds information pertinent to a Pcbnew printed circuit board.
Definition: class_board.h:163
#define _(s)
Definition: 3d_actions.cpp:33
BOARD * GetBoard() const

References _, LAYER_WIDGET::AppendLayerRow(), arrayDim(), B_Adhes, B_CrtYd, B_Cu, B_Fab, B_Mask, B_Paste, B_SilkS, LAYER_WIDGET::ClearLayerRows(), Cmts_User, PCB_BASE_FRAME::ColorSettings(), COLUMN_COLOR_LYRNAME, COLUMN_COLORBM, LSET::CuStack(), Dwgs_User, Eco1_User, Eco2_User, Edge_Cuts, F_Adhes, F_CrtYd, F_Cu, F_Fab, F_Mask, F_Paste, F_SilkS, FOOTPRINT, LSET::ForbiddenFootprintLayers(), PCB_BASE_FRAME::GetBoard(), COLOR_SETTINGS::GetColor(), COLOR_SETTINGS::GetDefaultColor(), BOARD::GetEnabledLayers(), LAYER_WIDGET::getLayerComp(), BOARD::GetLayerName(), LAYER_WIDGET::GetLayerRowCount(), m_fp_editor_mode, Margin, myframe, PCB, COLOR_SETTINGS::SetColorContext(), and LAYER_WIDGET::UpdateLayouts().

Referenced by FOOTPRINT_EDIT_FRAME::ReFillLayerWidget().

◆ ReFillRender()

void PCB_LAYER_WIDGET::ReFillRender ( )

Function ReFillRender rebuilds Render for instance after the config is read.

Definition at line 371 of file pcb_layer_widget.cpp.

372 {
373  BOARD* board = myframe->GetBoard();
374  auto settings = board->GetDesignSettings();
375 
378 
379  ClearRenderRows();
380 
381  // Add "Items" tab rows to LAYER_WIDGET, after setting color and checkbox state.
382  // Because s_render_rows is created static, we must explicitly call
383  // wxGetTranslation for texts which are internationalized (tool tips
384  // and item names)
385  for( unsigned row=0; row<arrayDim(s_render_rows); ++row )
386  {
387  LAYER_WIDGET::ROW renderRow = s_render_rows[row];
388 
389  if( m_fp_editor_mode && !isAllowedInFpMode( renderRow.id ) )
390  continue;
391 
392  if( renderRow.id == LAYER_VIA_MICROVIA && !settings.m_MicroViasAllowed )
393  continue;
394 
395  if( renderRow.id == LAYER_VIA_BBLIND && !settings.m_BlindBuriedViaAllowed )
396  continue;
397 
398  if( !renderRow.spacer )
399  {
400  renderRow.tooltip = wxGetTranslation( s_render_rows[row].tooltip );
401  renderRow.rowName = wxGetTranslation( s_render_rows[row].rowName );
402 
403  if( renderRow.color != COLOR4D::UNSPECIFIED ) // does this row show a color?
404  {
405  // this window frame must have an established BOARD, i.e. after SetBoard()
406  renderRow.color = myframe->ColorSettings()->GetColor(
407  static_cast<GAL_LAYER_ID>( renderRow.id ) );
409  static_cast<GAL_LAYER_ID>( renderRow.id ) );
410  }
411 
412  if( renderRow.id == LAYER_RATSNEST )
414  else if( renderRow.id == LAYER_GRID )
415  renderRow.state = myframe->IsGridVisible();
416  else
417  renderRow.state = board->IsElementVisible(
418  static_cast<GAL_LAYER_ID>( renderRow.id ) );
419  }
420 
421  AppendRenderRow( renderRow );
422  }
423 
424  UpdateLayouts();
425 }
COLOR4D defaultColor
The default color for the row.
Definition: layer_widget.h:96
to draw blind/buried vias
Struct ROW provides all the data needed to add a row to a LAYER_WIDGET.
Definition: layer_widget.h:87
virtual bool IsGridVisible() const override
Function IsGridVisible()
bool spacer
if true, this row is a spacer
Definition: layer_widget.h:95
void UpdateLayouts()
PCB_BASE_FRAME * myframe
BOARD_DESIGN_SETTINGS & GetDesignSettings() const
Function GetDesignSettings.
Definition: class_board.h:512
void SetColorContext(COLOR_CONTEXT aContext=COLOR_CONTEXT::PCB)
const PCB_DISPLAY_OPTIONS & GetDisplayOptions() const
Function GetDisplayOptions returns the display options current in use Display options are relative to...
void ClearRenderRows()
Function ClearRenderRows empties out the render rows.
bool state
initial wxCheckBox state
Definition: layer_widget.h:92
wxString tooltip
if not empty, use this tooltip on row
Definition: layer_widget.h:93
void AppendRenderRow(const ROW &aRow)
Function AppendRenderRow appends a new row in the render portion of the widget.
COLOR4D color
COLOR4D::UNSPECIFIED if none.
Definition: layer_widget.h:91
bool isAllowedInFpMode(int aId)
Function isAllowedInFpMode.
COLOR_SETTINGS * ColorSettings()
Helper to retrieve the current color settings.
COLOR4D GetDefaultColor(int aLayer)
static const LAYER_WIDGET::ROW s_render_rows[]
This is a read only template that is copied and modified before adding to LAYER_WIDGET.
constexpr std::size_t arrayDim(T const (&)[N]) noexcept
Definition: macros.h:108
bool IsElementVisible(GAL_LAYER_ID aLayer) const
Function IsElementVisible tests whether a given element category is visible.
COLOR4D GetColor(int aLayer) const
BOARD holds information pertinent to a Pcbnew printed circuit board.
Definition: class_board.h:163
wxString rowName
the prompt or layername
Definition: layer_widget.h:89
BOARD * GetBoard() const
int id
either a layer or "visible element" id
Definition: layer_widget.h:90

References LAYER_WIDGET::AppendRenderRow(), arrayDim(), LAYER_WIDGET::ClearRenderRows(), LAYER_WIDGET::ROW::color, PCB_BASE_FRAME::ColorSettings(), LAYER_WIDGET::ROW::defaultColor, FOOTPRINT, PCB_BASE_FRAME::GetBoard(), COLOR_SETTINGS::GetColor(), COLOR_SETTINGS::GetDefaultColor(), BOARD::GetDesignSettings(), PCB_BASE_FRAME::GetDisplayOptions(), LAYER_WIDGET::ROW::id, isAllowedInFpMode(), BOARD::IsElementVisible(), PCB_BASE_FRAME::IsGridVisible(), LAYER_GRID, LAYER_RATSNEST, LAYER_VIA_BBLIND, LAYER_VIA_MICROVIA, m_fp_editor_mode, PCB_DISPLAY_OPTIONS::m_ShowGlobalRatsnest, myframe, PCB, LAYER_WIDGET::ROW::rowName, s_render_rows, COLOR_SETTINGS::SetColorContext(), LAYER_WIDGET::ROW::spacer, LAYER_WIDGET::ROW::state, LAYER_WIDGET::ROW::tooltip, and LAYER_WIDGET::UpdateLayouts().

Referenced by FOOTPRINT_EDIT_FRAME::UpdateUserInterface().

◆ SelectLayer()

void LAYER_WIDGET::SelectLayer ( LAYER_NUM  aLayer)
inherited

Function SelectLayer changes the row selection in the layer list to aLayer provided.

Definition at line 669 of file layer_widget.cpp.

670 {
671  int row = findLayerRow( aLayer );
672  SelectLayerRow( row );
673 }
int findLayerRow(LAYER_NUM aLayer) const
Function findLayerRow returns the row index that aLayer resides in, or -1 if not found.
void SelectLayerRow(int aRow)
Function SelectLayerRow changes the row selection in the layer list to the given row.

References LAYER_WIDGET::findLayerRow(), and LAYER_WIDGET::SelectLayerRow().

Referenced by GERBVIEW_FRAME::SetActiveLayer(), GERBVIEW_FRAME::syncLayerWidget(), and FOOTPRINT_EDIT_FRAME::UpdateUserInterface().

◆ SelectLayerRow()

void LAYER_WIDGET::SelectLayerRow ( int  aRow)
inherited

Function SelectLayerRow changes the row selection in the layer list to the given row.

Definition at line 635 of file layer_widget.cpp.

636 {
637  // enable the layer tab at index 0
638  m_notebook->SetSelection( 0 );
639 
640  INDICATOR_ICON* oldIndicator = (INDICATOR_ICON*) getLayerComp( m_CurrentRow, 0 );
641  if( oldIndicator )
642  {
644  oldIndicator->SetIndicatorState( ROW_ICON_PROVIDER::STATE::DIMMED );
645  else
647  }
648 
649  INDICATOR_ICON* newIndicator = (INDICATOR_ICON*) getLayerComp( aRow, 0 );
650  if( newIndicator )
651  {
653 
654  // Make sure the desired layer row is visible.
655  // It seems that as of 2.8.2, setting the focus does this.
656  // I don't expect the scrolling to be needed at all because
657  // the minimum window size may end up being established so that the
658  // scroll bars will not be visible.
659  getLayerComp( aRow, 1 )->SetFocus();
660  }
661 
662  m_CurrentRow = aRow;
663 
664  // give the focus back to the app.
665  passOnFocus();
666 }
void SetIndicatorState(ICON_ID aIconId)
Sets the row indiciator to the given state.
wxAuiNotebook * m_notebook
Definition: layer_widget.h:127
int m_CurrentRow
selected row of layer list
Definition: layer_widget.h:136
#define OFF
virtual bool useAlternateBitmap(int aRow)
Virtual Function useAlternateBitmap.
Definition: layer_widget.h:149
wxWindow * getLayerComp(int aRow, int aColumn) const
Function getLayerComp returns the component within the m_LayersFlexGridSizer at aRow and aCol or NULL...
representing a row indicator icon for use in places like the layer widget
void passOnFocus()
Function passOnFocus gives away the keyboard focus up to the main parent window.
#define ON

References LAYER_WIDGET::getLayerComp(), LAYER_WIDGET::m_CurrentRow, LAYER_WIDGET::m_notebook, OFF, ON, LAYER_WIDGET::passOnFocus(), INDICATOR_ICON::SetIndicatorState(), and LAYER_WIDGET::useAlternateBitmap().

Referenced by LAYER_WIDGET::OnLeftDownLayers(), and LAYER_WIDGET::SelectLayer().

◆ setLayerCheckbox()

void LAYER_WIDGET::setLayerCheckbox ( LAYER_NUM  aLayer,
bool  isVisible 
)
protectedinherited

Definition at line 693 of file layer_widget.cpp.

694 {
695  int row = findLayerRow( aLayer );
696  if( row >= 0 )
697  {
698  wxCheckBox* cb = (wxCheckBox*) getLayerComp( row, COLUMN_COLOR_LYR_CB );
699  wxASSERT( cb );
700  cb->SetValue( isVisible ); // does not fire an event
701  }
702 }
int findLayerRow(LAYER_NUM aLayer) const
Function findLayerRow returns the row index that aLayer resides in, or -1 if not found.
wxWindow * getLayerComp(int aRow, int aColumn) const
Function getLayerComp returns the component within the m_LayersFlexGridSizer at aRow and aCol or NULL...
#define COLUMN_COLOR_LYR_CB
Definition: layer_widget.h:54

References COLUMN_COLOR_LYR_CB, LAYER_WIDGET::findLayerRow(), and LAYER_WIDGET::getLayerComp().

Referenced by LAYER_WIDGET::SetLayerVisible(), and SyncLayerVisibilities().

◆ SetLayerColor()

void LAYER_WIDGET::SetLayerColor ( LAYER_NUM  aLayer,
COLOR4D  aColor 
)
inherited

Function SetLayerColor changes the color of aLayer.

Definition at line 718 of file layer_widget.cpp.

719 {
720  int row = findLayerRow( aLayer );
721  if( row >= 0 )
722  {
723  int col = 1; // bitmap button is column 1
724  auto swatch = static_cast<COLOR_SWATCH*>( getLayerComp( row, col ) );
725  wxASSERT( swatch );
726 
727  swatch->SetSwatchColor( aColor, false );
728  }
729 }
int findLayerRow(LAYER_NUM aLayer) const
Function findLayerRow returns the row index that aLayer resides in, or -1 if not found.
wxWindow * getLayerComp(int aRow, int aColumn) const
Function getLayerComp returns the component within the m_LayersFlexGridSizer at aRow and aCol or NULL...

References LAYER_WIDGET::findLayerRow(), and LAYER_WIDGET::getLayerComp().

◆ SetLayersManagerTabsText()

void PCB_LAYER_WIDGET::SetLayersManagerTabsText ( )

Function SetLayersManagerTabsText Update the layer manager tabs labels Useful when changing Language or to set labels to a non default value.

Definition at line 364 of file pcb_layer_widget.cpp.

365 {
366  m_notebook->SetPageText( 0, _( "Layers" ) );
367  m_notebook->SetPageText( 1, _( "Items" ) );
368 }
wxAuiNotebook * m_notebook
Definition: layer_widget.h:127
#define _(s)
Definition: 3d_actions.cpp:33

References _, and LAYER_WIDGET::m_notebook.

Referenced by PCB_LAYER_WIDGET(), and FOOTPRINT_EDIT_FRAME::ShowChangedLanguage().

◆ SetLayerVisible()

void LAYER_WIDGET::SetLayerVisible ( LAYER_NUM  aLayer,
bool  isVisible 
)
inherited

Function SetLayerVisible sets aLayer visible or not.

This does not invoke OnLayerVisible().

Definition at line 686 of file layer_widget.cpp.

687 {
688  setLayerCheckbox( aLayer, isVisible );
689  OnLayerVisible( aLayer, isVisible );
690 }
virtual void OnLayerVisible(LAYER_NUM aLayer, bool isVisible, bool isFinal=true)=0
Function OnLayerVisible is called to notify client code about a layer visibility change.
void setLayerCheckbox(LAYER_NUM aLayer, bool isVisible)

References LAYER_WIDGET::OnLayerVisible(), and LAYER_WIDGET::setLayerCheckbox().

Referenced by ROUTER_TOOL::prepareInteractive().

◆ SetRenderState()

void LAYER_WIDGET::SetRenderState ( int  aId,
bool  isSet 
)
inherited

Function SetRenderState sets the state of the checkbox associated with aId within the Render tab group of the widget.

Does not fire an event, i.e. does not invoke OnRenderEnable().

Parameters
aIdis the same unique id used when adding a ROW to the Render tab.
isSet= the new checkbox state

Definition at line 748 of file layer_widget.cpp.

749 {
750  int row = findRenderRow( aId );
751 
752  if( row >= 0 )
753  {
754  int col = 1; // checkbox is column 1
755  wxCheckBox* cb = (wxCheckBox*) getRenderComp( row, col );
756  wxASSERT( cb );
757  cb->SetValue( isSet ); // does not fire an event
758  }
759 }
int findRenderRow(int aId) const
wxWindow * getRenderComp(int aRow, int aColumn) const

References LAYER_WIDGET::findRenderRow(), and LAYER_WIDGET::getRenderComp().

Referenced by FOOTPRINT_EDIT_FRAME::SetElementVisibility(), GERBVIEW_FRAME::SetElementVisibility(), PCB_BASE_EDIT_FRAME::SetGridVisibility(), and GERBVIEW_FRAME::SetGridVisibility().

◆ SyncLayerAlphaIndicators()

void PCB_LAYER_WIDGET::SyncLayerAlphaIndicators ( )

Function SyncLayerAlphaIndicators updates each "Layer"s alpha indicator to show if the board is currently being rendered with more transparency or less.

Definition at line 450 of file pcb_layer_widget.cpp.

451 {
452  int count = GetLayerRowCount();
454  KIGFX::PCB_PAINTER* painter = static_cast<KIGFX::PCB_PAINTER*>( mgr->GetView()->GetPainter() );
455  KIGFX::PCB_RENDER_SETTINGS* settings = painter->GetSettings();
456 
457  for( int row = 0; row < count; ++row )
458  {
459  // this utilizes more implementation knowledge than ideal, eventually
460  // add member ROW getRow() or similar to base LAYER_WIDGET.
461 
462  wxWindow* w = getLayerComp( row, COLUMN_ICON_ACTIVE );
463  PCB_LAYER_ID layerId = ToLAYER_ID( getDecodedId( w->GetId() ) );
464  KIGFX::COLOR4D screenColor = settings->GetLayerColor( layerId );
465 
466  COLOR_SWATCH* swatch = static_cast<COLOR_SWATCH*>( getLayerComp( row, COLUMN_COLORBM ) );
467  KIGFX::COLOR4D layerColor = swatch->GetSwatchColor();
468 
469  INDICATOR_ICON* indicator = static_cast<INDICATOR_ICON*>( getLayerComp( row, COLUMN_ALPHA_INDICATOR ) );
470 
471  if( std::abs( screenColor.a - layerColor.a ) > ALPHA_EPSILON )
472  {
473  if( screenColor.a < layerColor.a )
474  indicator->SetIndicatorState( ROW_ICON_PROVIDER::STATE::DOWN );
475  else
476  indicator->SetIndicatorState( ROW_ICON_PROVIDER::STATE::UP );
477  }
478  else
480  }
481 }
void SetIndicatorState(ICON_ID aIconId)
Sets the row indiciator to the given state.
KIGFX::VIEW * GetView() const
Definition: tool_manager.h:280
#define ALPHA_EPSILON
TOOL_MANAGER * GetToolManager() const
Return the MVC controller.
KIGFX::COLOR4D GetSwatchColor() const
#define COLUMN_ALPHA_INDICATOR
Definition: layer_widget.h:56
PCB_BASE_FRAME * myframe
#define OFF
wxWindow * getLayerComp(int aRow, int aColumn) const
Function getLayerComp returns the component within the m_LayersFlexGridSizer at aRow and aCol or NULL...
PCB_PAINTER Contains methods for drawing PCB-specific items.
Definition: pcb_painter.h:224
PAINTER * GetPainter() const
Function GetPainter() Returns the painter object used by the view for drawing VIEW_ITEMS.
Definition: view.h:199
PCB_RENDER_SETTINGS Stores PCB specific render settings.
Definition: pcb_painter.h:60
TOOL_MANAGER.
Definition: tool_manager.h:50
PCB_LAYER_ID
A quick note on layer IDs:
representing a row indicator icon for use in places like the layer widget
double a
Alpha component.
Definition: color4d.h:305
#define COLUMN_ICON_ACTIVE
Definition: layer_widget.h:52
#define COLUMN_COLORBM
Definition: layer_widget.h:53
virtual PCB_RENDER_SETTINGS * GetSettings() override
Function GetSettings Returns pointer to current settings that are going to be used when drawing items...
Definition: pcb_painter.h:236
static LAYER_NUM getDecodedId(int aControlId)
Function getDecodedId decodes aControlId to original un-encoded value.
int GetLayerRowCount() const
Function GetLayerRowCount returns the number of rows in the layer tab.
Class representing a simple color swatch, of the kind used to set layer colors.
Definition: color_swatch.h:38
PCB_LAYER_ID ToLAYER_ID(int aLayer)
Definition: lset.cpp:823
COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:40

References KIGFX::COLOR4D::a, ALPHA_EPSILON, COLUMN_ALPHA_INDICATOR, COLUMN_COLORBM, COLUMN_ICON_ACTIVE, LAYER_WIDGET::getDecodedId(), LAYER_WIDGET::getLayerComp(), LAYER_WIDGET::GetLayerRowCount(), KIGFX::VIEW::GetPainter(), KIGFX::PCB_PAINTER::GetSettings(), COLOR_SWATCH::GetSwatchColor(), EDA_BASE_FRAME::GetToolManager(), TOOL_MANAGER::GetView(), myframe, OFF, INDICATOR_ICON::SetIndicatorState(), and ToLAYER_ID().

Referenced by FOOTPRINT_EDIT_FRAME::OnUpdateLayerAlpha().

◆ SyncLayerVisibilities()

void PCB_LAYER_WIDGET::SyncLayerVisibilities ( )

Function SyncLayerVisibilities updates each "Layer" checkbox in this layer widget according to each layer's current visibility determined by IsLayerVisible(), and is helpful immediately after loading a BOARD which may have state information in it.

Definition at line 428 of file pcb_layer_widget.cpp.

429 {
430  BOARD* board = myframe->GetBoard();
431  int count = GetLayerRowCount();
432 
433  for( int row=0; row<count; ++row )
434  {
435  // this utilizes more implementation knowledge than ideal, eventually
436  // add member ROW getRow() or similar to base LAYER_WIDGET.
437 
438  wxWindow* w = getLayerComp( row, COLUMN_ICON_ACTIVE );
439 
440  PCB_LAYER_ID layerId = ToLAYER_ID( getDecodedId( w->GetId() ) );
441 
442  // this does not fire a UI event
443  setLayerCheckbox( layerId, board->IsLayerVisible( layerId ) );
444  }
445 }
PCB_BASE_FRAME * myframe
wxWindow * getLayerComp(int aRow, int aColumn) const
Function getLayerComp returns the component within the m_LayersFlexGridSizer at aRow and aCol or NULL...
PCB_LAYER_ID
A quick note on layer IDs:
#define COLUMN_ICON_ACTIVE
Definition: layer_widget.h:52
void setLayerCheckbox(LAYER_NUM aLayer, bool isVisible)
static LAYER_NUM getDecodedId(int aControlId)
Function getDecodedId decodes aControlId to original un-encoded value.
int GetLayerRowCount() const
Function GetLayerRowCount returns the number of rows in the layer tab.
bool IsLayerVisible(PCB_LAYER_ID aLayer) const
Function IsLayerVisible is a proxy function that calls the correspondent function in m_BoardSettings ...
Definition: class_board.h:431
BOARD holds information pertinent to a Pcbnew printed circuit board.
Definition: class_board.h:163
BOARD * GetBoard() const
PCB_LAYER_ID ToLAYER_ID(int aLayer)
Definition: lset.cpp:823

References COLUMN_ICON_ACTIVE, PCB_BASE_FRAME::GetBoard(), LAYER_WIDGET::getDecodedId(), LAYER_WIDGET::getLayerComp(), LAYER_WIDGET::GetLayerRowCount(), BOARD::IsLayerVisible(), myframe, LAYER_WIDGET::setLayerCheckbox(), and ToLAYER_ID().

Referenced by FOOTPRINT_EDIT_FRAME::UpdateUserInterface().

◆ UpdateLayerIcons()

void LAYER_WIDGET::UpdateLayerIcons ( )
inherited

Function UpdateLayerIcons Update all layer manager icons (layers only) Useful when loading a file or clearing a layer because they change, and the indicator arrow icon needs to be updated.

Definition at line 788 of file layer_widget.cpp.

789 {
790  int rowCount = GetLayerRowCount();
791 
792  for( int row = 0; row < rowCount ; row++ )
793  {
795 
796  if( indicator )
797  {
799 
800  if( row == m_CurrentRow )
802  else if( useAlternateBitmap( row ) )
803  state = ROW_ICON_PROVIDER::STATE::DIMMED;
804  else
806 
807  indicator->SetIndicatorState( state );
808  }
809  }
810 }
void SetIndicatorState(ICON_ID aIconId)
Sets the row indiciator to the given state.
int m_CurrentRow
selected row of layer list
Definition: layer_widget.h:136
#define OFF
virtual bool useAlternateBitmap(int aRow)
Virtual Function useAlternateBitmap.
Definition: layer_widget.h:149
wxWindow * getLayerComp(int aRow, int aColumn) const
Function getLayerComp returns the component within the m_LayersFlexGridSizer at aRow and aCol or NULL...
representing a row indicator icon for use in places like the layer widget
#define COLUMN_ICON_ACTIVE
Definition: layer_widget.h:52
int GetLayerRowCount() const
Function GetLayerRowCount returns the number of rows in the layer tab.
STATE
State constants to select the right icons
#define ON

References COLUMN_ICON_ACTIVE, LAYER_WIDGET::getLayerComp(), LAYER_WIDGET::GetLayerRowCount(), LAYER_WIDGET::m_CurrentRow, OFF, ON, INDICATOR_ICON::SetIndicatorState(), and LAYER_WIDGET::useAlternateBitmap().

Referenced by GERBVIEW_FRAME::LoadExcellonFiles(), GERBVIEW_FRAME::loadListOfGerberAndDrillFiles(), and GERBVIEW_FRAME::LoadZipArchiveFile().

◆ UpdateLayouts()

void LAYER_WIDGET::UpdateLayouts ( )
inherited

Definition at line 778 of file layer_widget.cpp.

779 {
780  m_LayersFlexGridSizer->Layout();
781  m_RenderFlexGridSizer->Layout();
782  m_LayerPanel->Layout();
783  m_RenderingPanel->Layout();
784  FitInside();
785 }
wxFlexGridSizer * m_LayersFlexGridSizer
Definition: layer_widget.h:130
wxFlexGridSizer * m_RenderFlexGridSizer
Definition: layer_widget.h:133
wxPanel * m_RenderingPanel
Definition: layer_widget.h:131
wxPanel * m_LayerPanel
Definition: layer_widget.h:128

References LAYER_WIDGET::m_LayerPanel, LAYER_WIDGET::m_LayersFlexGridSizer, LAYER_WIDGET::m_RenderFlexGridSizer, and LAYER_WIDGET::m_RenderingPanel.

Referenced by LAYER_WIDGET::AppendLayerRows(), LAYER_WIDGET::AppendRenderRows(), ReFill(), GERBER_LAYER_WIDGET::ReFill(), and ReFillRender().

◆ useAlternateBitmap()

virtual bool LAYER_WIDGET::useAlternateBitmap ( int  aRow)
inlineprotectedvirtualinherited

Virtual Function useAlternateBitmap.

Returns
true if bitmaps shown in Render layer list are alternate bitmaps, or false if they are "normal" bitmaps This is a virtual function because Pcbnew uses normal bitmaps but GerbView uses both bitmaps (alternate bitmaps to show layers in use, normal fo others)

Reimplemented in GERBER_LAYER_WIDGET.

Definition at line 149 of file layer_widget.h.

149 { return false; }

Referenced by LAYER_WIDGET::SelectLayerRow(), and LAYER_WIDGET::UpdateLayerIcons().

Member Data Documentation

◆ EVT_LAYER_COLOR_CHANGE

const wxEventType LAYER_WIDGET::EVT_LAYER_COLOR_CHANGE = wxNewEventType()
staticinherited

Definition at line 123 of file layer_widget.h.

Referenced by LAYER_WIDGET::OnLayerSwatchChanged().

◆ m_alwaysShowActiveCopperLayer

bool PCB_LAYER_WIDGET::m_alwaysShowActiveCopperLayer
protected

◆ m_CurrentRow

int LAYER_WIDGET::m_CurrentRow
protectedinherited

◆ m_FocusOwner

wxWindow* LAYER_WIDGET::m_FocusOwner
protectedinherited

Definition at line 135 of file layer_widget.h.

Referenced by LAYER_WIDGET::LAYER_WIDGET(), and LAYER_WIDGET::passOnFocus().

◆ m_fp_editor_mode

bool PCB_LAYER_WIDGET::m_fp_editor_mode
protected

◆ m_IconProvider

ROW_ICON_PROVIDER* LAYER_WIDGET::m_IconProvider
protectedinherited

◆ m_LayerPanel

wxPanel* LAYER_WIDGET::m_LayerPanel
protectedinherited

◆ m_LayerScrolledWindow

wxScrolledWindow* LAYER_WIDGET::m_LayerScrolledWindow
protectedinherited

◆ m_LayersFlexGridSizer

◆ m_notebook

wxAuiNotebook* LAYER_WIDGET::m_notebook
protectedinherited

◆ m_PointSize

int LAYER_WIDGET::m_PointSize
protectedinherited

◆ m_RenderFlexGridSizer

◆ m_RenderingPanel

wxPanel* LAYER_WIDGET::m_RenderingPanel
protectedinherited

◆ m_RenderScrolledWindow

wxScrolledWindow* LAYER_WIDGET::m_RenderScrolledWindow
protectedinherited

Definition at line 132 of file layer_widget.h.

Referenced by LAYER_WIDGET::insertRenderRow(), and LAYER_WIDGET::LAYER_WIDGET().

◆ myframe

◆ s_render_rows

const LAYER_WIDGET::ROW PCB_LAYER_WIDGET::s_render_rows
staticprotected

This is a read only template that is copied and modified before adding to LAYER_WIDGET.

Definition at line 117 of file pcb_layer_widget.h.

Referenced by ReFillRender().


The documentation for this class was generated from the following files: