KiCad PCB EDA Suite
PCB_LAYER_WIDGET Class Reference

Class 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 <class_pcb_layer_widget.h>

Inheritance diagram for PCB_LAYER_WIDGET:
LAYER_WIDGET

Public Member Functions

 PCB_LAYER_WIDGET (PCB_BASE_FRAME *aParent, wxWindow *aFocusOwner, int aPointSize=10, bool aFpEditorMode=false)
 Constructor. More...
 
void ReFill ()
 
void ReFillRender ()
 Function ReFillRender rebuilds Render for instance after the config is read. More...
 
void SyncRenderStates ()
 Function SyncRenderStates updates the checkboxes (checked or not) to be consistent with the current state of the visibility of the visible rendering elements. 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 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 bool AreArbitraryColorsAllowed () override
 Subclasses can override this to provide logic for allowing arbitrary color selection via wxColourPicker instead of DisplayColorFrame. 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 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
 

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

Class 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 class_pcb_layer_widget.h.

Member Enumeration Documentation

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 129 of file class_pcb_layer_widget.h.

Constructor & Destructor Documentation

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

Constructor.

Parameters
aParentis the parent window
aFocusOwneris the window that should be sent the focus after
aPointSizeis the font point size to use within the widget. This effectively sets the overall size of the widget via the row height and bitmap button sizes.
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 96 of file class_pcb_layer_widget.cpp.

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

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

Member Function Documentation

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 148 of file class_pcb_layer_widget.cpp.

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, and KiBitmap().

Referenced by OnLayerRightClick(), and onRightDownLayers().

149 {
150  // menu text is capitalized:
151  // http://library.gnome.org/devel/hig-book/2.20/design-text-labels.html.en#layout-capitalization
153  _( "Show All Copper Layers" ),
154  KiBitmap( select_layer_pair_xpm ) );
156  _( "Hide All Copper Layers But Active" ),
157  KiBitmap( select_w_layer_xpm ) );
159  _( "Always Hide All Copper Layers But Active" ),
160  KiBitmap( select_w_layer_xpm ) );
162  _( "Hide All Copper Layers" ),
163  KiBitmap( show_no_copper_layers_xpm ) );
164 
165  menu.AppendSeparator();
166 
168  _( "Show All Non Copper Layers" ),
169  KiBitmap( select_w_layer_xpm ) );
171  _( "Hide All Non Copper Layers" ),
172  KiBitmap( show_no_copper_layers_xpm ) );
173 
174  menu.AppendSeparator();
175 
176  AddMenuItem( &menu, ID_SHOW_NO_LAYERS, _( "Hide All Layers" ),
177  KiBitmap( show_no_layers_xpm ) );
178  AddMenuItem( &menu, ID_SHOW_ALL_LAYERS, _( "Show All Layers" ),
179  KiBitmap( show_all_layers_xpm ) );
180 
181  menu.AppendSeparator();
182 
183  AddMenuItem( &menu, ID_SHOW_ALL_FRONT, _( "Show All Front Layers" ),
184  KiBitmap( show_no_layers_xpm ) );
185 
186  AddMenuItem( &menu, ID_SHOW_ALL_BACK, _( "Show All Back Layers" ),
187  KiBitmap( show_all_layers_xpm ) );
188 }
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:55
wxBitmap KiBitmap(BITMAP_DEF aBitmap)
Function KiBitmap constructs a wxBitmap from a memory record, held in a BITMAP_DEF.
Definition: bitmap.cpp:36
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 572 of file layer_widget.cpp.

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

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

573 {
574  int nextRow = GetLayerRowCount();
575  insertLayerRow( nextRow, aRow );
576  UpdateLayouts();
577 }
void UpdateLayouts()
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.
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 286 of file layer_widget.h.

References LAYER_WIDGET::AppendLayerRow().

287  {
288  for( int row=0; row<aRowCount; ++row )
289  AppendLayerRow( aRowsArray[row] );
290  }
void AppendLayerRow(const ROW &aRow)
Function AppendLayerRow appends a new row in the layer portion of the widget.
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 586 of file layer_widget.cpp.

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

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

587 {
588  int nextRow = GetRenderRowCount();
589  insertRenderRow( nextRow, aRow );
590  UpdateLayouts();
591 }
void insertRenderRow(int aRow, const ROW &aSpec)
void UpdateLayouts()
int GetRenderRowCount() const
Function GetRenderRowCount returns the number of rows in the render tab.
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 310 of file layer_widget.h.

References LAYER_WIDGET::AppendRenderRow().

Referenced by GERBER_LAYER_WIDGET::ReFillRender().

311  {
312  for( int row=0; row<aRowCount; ++row )
313  AppendRenderRow( aRowsArray[row] );
314  }
void AppendRenderRow(const ROW &aRow)
Function AppendRenderRow appends a new row in the render portion of the widget.
bool PCB_LAYER_WIDGET::AreArbitraryColorsAllowed ( )
overrideprotectedvirtual

Subclasses can override this to provide logic for allowing arbitrary color selection via wxColourPicker instead of DisplayColorFrame.

Reimplemented from LAYER_WIDGET.

Definition at line 122 of file class_pcb_layer_widget.cpp.

References EDA_DRAW_FRAME::IsGalCanvasActive(), and myframe.

123 {
124  return myframe->IsGalCanvasActive();
125 }
PCB_BASE_FRAME * myframe
bool IsGalCanvasActive() const
Function IsGalCanvasActive is used to check which canvas (GAL-based or standard) is currently in use...
Definition: draw_frame.h:856
void LAYER_WIDGET::ClearLayerRows ( )
inherited

Function ClearLayerRows empties out the layer rows.

Definition at line 580 of file layer_widget.cpp.

References LAYER_WIDGET::m_LayersFlexGridSizer.

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

581 {
582  m_LayersFlexGridSizer->Clear( true );
583 }
wxFlexGridSizer * m_LayersFlexGridSizer
Definition: layer_widget.h:113
void LAYER_WIDGET::ClearRenderRows ( )
inherited

Function ClearRenderRows empties out the render rows.

Definition at line 594 of file layer_widget.cpp.

References LAYER_WIDGET::m_RenderFlexGridSizer.

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

595 {
596  m_RenderFlexGridSizer->Clear( true );
597 }
wxFlexGridSizer * m_RenderFlexGridSizer
Definition: layer_widget.h:116
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 68 of file layer_widget.cpp.

References LYR_COLUMN_COUNT.

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

69 {
70  int id = aId * LYR_COLUMN_COUNT + aColumn;
71  return id;
72 }
#define LYR_COLUMN_COUNT
Layer tab column count.
Definition: layer_widget.h:48
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 247 of file layer_widget.cpp.

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::SetLayerColor(), and LAYER_WIDGET::SetLayerVisible().

248 {
249  int count = GetLayerRowCount();
250 
251  for( int row = 0; row < count; ++row )
252  {
253  // column 0 in the layer scroll window has a wxStaticBitmap, get its ID.
254  wxWindow* w = getLayerComp( row, 0 );
255  wxASSERT( w );
256 
257  if( aLayer == getDecodedId( w->GetId() ))
258  return row;
259  }
260 
261  return -1;
262 }
wxWindow * getLayerComp(int aRow, int aColumn) const
Function getLayerComp returns the component within the m_LayersFlexGridSizer at aRow and aCol or NULL...
int GetLayerRowCount() const
Function GetLayerRowCount returns the number of rows in the layer tab.
static LAYER_NUM getDecodedId(int aControlId)
Function getDecodedId decodes aControlId to original un-encoded value.
int LAYER_WIDGET::findRenderRow ( int  aId) const
protectedinherited

Definition at line 276 of file layer_widget.cpp.

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

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

277 {
278  int count = GetRenderRowCount();
279 
280  for( int row = 0; row < count; ++row )
281  {
282  // column 0 in the layer scroll window has a wxStaticBitmap, get its ID.
283  wxWindow* w = getRenderComp( row, 0 );
284  wxASSERT( w );
285 
286  if( aId == getDecodedId( w->GetId() ))
287  return row;
288  }
289 
290  return -1;
291 }
int GetRenderRowCount() const
Function GetRenderRowCount returns the number of rows in the render tab.
static LAYER_NUM getDecodedId(int aControlId)
Function getDecodedId decodes aControlId to original un-encoded value.
wxWindow * getRenderComp(int aRow, int aColumn) const
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 503 of file layer_widget.cpp.

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

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

504 {
505  // size of m_LayerScrolledWindow --------------
506  wxArrayInt widths = m_LayersFlexGridSizer->GetColWidths();
507  int totWidth = 0;
508 
509  if( widths.GetCount() )
510  {
511  for( int i = 0; i < LYR_COLUMN_COUNT; ++i )
512  {
513  totWidth += widths[i] + m_LayersFlexGridSizer->GetHGap();
514  // printf("widths[%d]:%d\n", i, widths[i] );
515  }
516  }
517 
518  // Account for the parent's frame:
519  totWidth += 10;
520 
521 
522  /* The minimum height is a small size to properly force computation
523  * of the panel's scrollbars (otherwise it will assume it *has* all
524  * this space) */
525  unsigned totHeight = 32;
526 
527  wxSize layerz( totWidth, totHeight );
528 
529  layerz += m_LayerPanel->GetWindowBorderSize();
530 
531 
532  // size of m_RenderScrolledWindow --------------
533  widths = m_RenderFlexGridSizer->GetColWidths();
534  totWidth = 0;
535 
536  if( widths.GetCount() )
537  {
538  for( int i = 0; i < RND_COLUMN_COUNT; ++i )
539  {
540  totWidth += widths[i] + m_RenderFlexGridSizer->GetHGap();
541  // printf("widths[%d]:%d\n", i, widths[i] );
542  }
543  }
544  // account for the parent's frame, this one has void space of 10 PLUS a border:
545  totWidth += 20;
546 
547  // For totHeight re-use the previous small one
548  wxSize renderz( totWidth, totHeight );
549 
550  renderz += m_RenderingPanel->GetWindowBorderSize();
551 
552  wxSize clientz( std::max(renderz.x,layerz.x), std::max(renderz.y,layerz.y) );
553 
554  return clientz;
555 }
#define LYR_COLUMN_COUNT
Layer tab column count.
Definition: layer_widget.h:48
wxFlexGridSizer * m_LayersFlexGridSizer
Definition: layer_widget.h:113
#define RND_COLUMN_COUNT
Rendering tab column count.
Definition: layer_widget.h:49
wxFlexGridSizer * m_RenderFlexGridSizer
Definition: layer_widget.h:116
wxPanel * m_RenderingPanel
Definition: layer_widget.h:114
#define max(a, b)
Definition: auxiliary.h:86
wxPanel * m_LayerPanel
Definition: layer_widget.h:111
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 75 of file layer_widget.cpp.

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(), and SyncLayerVisibilities().

76 {
77  int id = aControlId / LYR_COLUMN_COUNT; // rounding is OK.
78  return id;
79 }
#define LYR_COLUMN_COUNT
Layer tab column count.
Definition: layer_widget.h:48
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 685 of file layer_widget.cpp.

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

Referenced by GERBER_LAYER_WIDGET::onPopupSelection().

686 {
687  int row = findLayerRow( aLayer );
688  if( row >= 0 )
689  {
690  int col = 1; // bitmap button is column 1
691  auto swatch = static_cast<COLOR_SWATCH*>( getLayerComp( row, col ) );
692  wxASSERT( swatch );
693 
694  return swatch->GetSwatchColor();
695  }
696 
697  return COLOR4D::UNSPECIFIED; // it's caller fault, gave me a bad layer
698 }
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...
Class representing a simple color swatch, of the kind used to set layer colors.
Definition: color_swatch.h:38
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 236 of file layer_widget.cpp.

References LYR_COLUMN_COUNT, and LAYER_WIDGET::m_LayersFlexGridSizer.

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

237 {
238  unsigned ndx = aRow * LYR_COLUMN_COUNT + aColumn;
239 
240  if( ndx < m_LayersFlexGridSizer->GetChildren().GetCount() )
241  return m_LayersFlexGridSizer->GetChildren()[ndx]->GetWindow();
242 
243  return NULL;
244 }
#define LYR_COLUMN_COUNT
Layer tab column count.
Definition: layer_widget.h:48
wxFlexGridSizer * m_LayersFlexGridSizer
Definition: layer_widget.h:113
int LAYER_WIDGET::GetLayerRowCount ( ) const
inherited

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

Definition at line 558 of file layer_widget.cpp.

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(), ReFill(), SyncLayerVisibilities(), and LAYER_WIDGET::UpdateLayerIcons().

559 {
560  int controlCount = m_LayersFlexGridSizer->GetChildren().GetCount();
561  return controlCount / LYR_COLUMN_COUNT;
562 }
#define LYR_COLUMN_COUNT
Layer tab column count.
Definition: layer_widget.h:48
wxFlexGridSizer * m_LayersFlexGridSizer
Definition: layer_widget.h:113
wxWindow * LAYER_WIDGET::getRenderComp ( int  aRow,
int  aColumn 
) const
protectedinherited

Definition at line 265 of file layer_widget.cpp.

References LAYER_WIDGET::m_RenderFlexGridSizer, and RND_COLUMN_COUNT.

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

266 {
267  int ndx = aRow * RND_COLUMN_COUNT + aColumn;
268 
269  if( (unsigned) ndx < m_RenderFlexGridSizer->GetChildren().GetCount() )
270  return m_RenderFlexGridSizer->GetChildren()[ndx]->GetWindow();
271 
272  return NULL;
273 }
#define RND_COLUMN_COUNT
Rendering tab column count.
Definition: layer_widget.h:49
wxFlexGridSizer * m_RenderFlexGridSizer
Definition: layer_widget.h:116
int LAYER_WIDGET::GetRenderRowCount ( ) const
inherited

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

Definition at line 565 of file layer_widget.cpp.

References LAYER_WIDGET::m_RenderFlexGridSizer, and RND_COLUMN_COUNT.

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

566 {
567  int controlCount = m_RenderFlexGridSizer->GetChildren().GetCount();
568  return controlCount / RND_COLUMN_COUNT;
569 }
#define RND_COLUMN_COUNT
Rendering tab column count.
Definition: layer_widget.h:49
wxFlexGridSizer * m_RenderFlexGridSizer
Definition: layer_widget.h:116
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 715 of file layer_widget.cpp.

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

716 {
717  int row = findRenderRow( aId );
718 
719  if( row >= 0 )
720  {
721  int col = 1; // checkbox is column 1
722  wxCheckBox* cb = (wxCheckBox*) getRenderComp( row, col );
723  wxASSERT( cb );
724  return cb->GetValue();
725  }
726 
727  return false; // the value of a non-existent row
728 }
int findRenderRow(int aId) const
wxWindow * getRenderComp(int aRow, int aColumn) const
LAYER_NUM LAYER_WIDGET::GetSelectedLayer ( )
inherited

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

Definition at line 636 of file layer_widget.cpp.

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

637 {
638  wxWindow* w = getLayerComp( m_CurrentRow, 0 );
639  if( w )
640  return getDecodedId( w->GetId() );
641 
642  return UNDEFINED_LAYER;
643 }
int m_CurrentRow
selected row of layer list
Definition: layer_widget.h:119
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.
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 294 of file layer_widget.cpp.

References alternativeRowIcons, LAYER_WIDGET::AreArbitraryColorsAllowed(), LAYER_WIDGET::ROW::color, COLUMN_COLOR_LYR_CB, COLUMN_COLOR_LYRNAME, COLUMN_COLORBM, COLUMN_ICON_ACTIVE, defaultRowIcons, LAYER_WIDGET::encodeId(), LAYER_WIDGET::ROW::id, LYR_COLUMN_COUNT, 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, LAYER_WIDGET::ROW::tooltip, and LAYER_WIDGET::useAlternateBitmap().

Referenced by LAYER_WIDGET::AppendLayerRow().

295 {
296  wxASSERT( aRow >= 0 );
297 
298  int col;
299  int index = aRow * LYR_COLUMN_COUNT;
300  const int flags = wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT;
301 
302  auto& iconProvider = useAlternateBitmap(aRow) ? alternativeRowIcons : defaultRowIcons;
303 
304  // column 0
305  col = COLUMN_ICON_ACTIVE;
306  auto sbm = new INDICATOR_ICON( m_LayerScrolledWindow, iconProvider,
308  encodeId( col, aSpec.id ) );
309  sbm->Bind( wxEVT_LEFT_DOWN, &LAYER_WIDGET::OnLeftDownLayers, this );
310  m_LayersFlexGridSizer->wxSizer::Insert( index+col, sbm, 0, flags );
311 
312  // column 1 (COLUMN_COLORBM)
313  col = COLUMN_COLORBM;
314 
315  auto bmb = new COLOR_SWATCH( m_LayerScrolledWindow, aSpec.color, encodeId( col, aSpec.id ),
317  bmb->Bind( wxEVT_LEFT_DOWN, &LAYER_WIDGET::OnLeftDownLayers, this );
318  bmb->Bind( COLOR_SWATCH_CHANGED, &LAYER_WIDGET::OnLayerSwatchChanged, this );
319  bmb->SetToolTip( _("Left double click or middle click for color change, right click for menu" ) );
320  m_LayersFlexGridSizer->wxSizer::Insert( index+col, bmb, 0, flags );
321 
322  // column 2 (COLUMN_COLOR_LYR_CB)
323  col = COLUMN_COLOR_LYR_CB;
324  wxCheckBox* cb = new wxCheckBox( m_LayerScrolledWindow, encodeId( col, aSpec.id ), wxEmptyString );
325  cb->SetValue( aSpec.state );
326  cb->Bind( wxEVT_COMMAND_CHECKBOX_CLICKED, &LAYER_WIDGET::OnLayerCheckBox, this );
327  cb->SetToolTip( _( "Enable this for visibility" ) );
328  m_LayersFlexGridSizer->wxSizer::Insert( index+col, cb, 0, flags );
329 
330  // column 3 (COLUMN_COLOR_LYRNAME)
331  col = COLUMN_COLOR_LYRNAME;
332  wxStaticText* st = new wxStaticText( m_LayerScrolledWindow, encodeId( col, aSpec.id ), aSpec.rowName );
333  shrinkFont( st, m_PointSize );
334  st->Bind( wxEVT_LEFT_DOWN, &LAYER_WIDGET::OnLeftDownLayers, this );
335  st->SetToolTip( aSpec.tooltip );
336  m_LayersFlexGridSizer->wxSizer::Insert( index+col, st, 0, flags );
337 
338  // Bind right click eventhandler to all columns
339  wxString layerName( aSpec.rowName );
340 
341  sbm->Bind( wxEVT_RIGHT_DOWN, [this, bmb, layerName] ( wxMouseEvent& aEvt ) {
342  OnRightDownLayer( aEvt, bmb, layerName );
343  } );
344  bmb->Bind( wxEVT_RIGHT_DOWN, [this, bmb, layerName] ( wxMouseEvent& aEvt ) {
345  OnRightDownLayer( aEvt, bmb, layerName );
346  } );
347  cb->Bind( wxEVT_RIGHT_DOWN, [this, bmb, layerName] ( wxMouseEvent& aEvt ) {
348  OnRightDownLayer( aEvt, bmb, layerName );
349  } );
350  st->Bind( wxEVT_RIGHT_DOWN, [this, bmb, layerName] ( wxMouseEvent& aEvt ) {
351  OnRightDownLayer( aEvt, bmb, layerName );
352  } );
353 }
#define COLUMN_COLOR_LYRNAME
Definition: layer_widget.h:54
void OnLeftDownLayers(wxMouseEvent &event)
#define LYR_COLUMN_COUNT
Layer tab column count.
Definition: layer_widget.h:48
#define OFF
wxFlexGridSizer * m_LayersFlexGridSizer
Definition: layer_widget.h:113
virtual bool useAlternateBitmap(int aRow)
Virtual Function useAlternateBitmap.
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...
Class representing a row indicator icon for use in places like the layer widget.
#define COLUMN_ICON_ACTIVE
Definition: layer_widget.h:51
#define COLUMN_COLORBM
Definition: layer_widget.h:52
static ROW_ICON_PROVIDER alternativeRowIcons(true)
virtual bool AreArbitraryColorsAllowed()
Subclasses can override this to provide logic for allowing arbitrary color selection via wxColourPick...
Definition: layer_widget.h:136
wxScrolledWindow * m_LayerScrolledWindow
Definition: layer_widget.h:112
static ROW_ICON_PROVIDER defaultRowIcons(false)
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:53
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.
void LAYER_WIDGET::insertRenderRow ( int  aRow,
const ROW aSpec 
)
protectedinherited

Definition at line 356 of file layer_widget.cpp.

References LAYER_WIDGET::AreArbitraryColorsAllowed(), LAYER_WIDGET::ROW::changeable, LAYER_WIDGET::ROW::color, LAYER_WIDGET::encodeId(), 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::state, and LAYER_WIDGET::ROW::tooltip.

Referenced by LAYER_WIDGET::AppendRenderRow().

357 {
358  wxASSERT( aRow >= 0 );
359 
360  int col;
361  int index = aRow * RND_COLUMN_COUNT;
362  const int flags = wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT;
363 
364  wxString renderName( aSpec.rowName );
365 
366  // column 1
367  col = 1;
368  wxCheckBox* cb = new wxCheckBox( m_RenderScrolledWindow, encodeId( col, aSpec.id ),
369  aSpec.rowName, wxDefaultPosition, wxDefaultSize, wxALIGN_LEFT );
370  shrinkFont( cb, m_PointSize );
371  cb->SetValue( aSpec.state );
372  cb->Enable( aSpec.changeable );
373  cb->Bind( wxEVT_COMMAND_CHECKBOX_CLICKED, &LAYER_WIDGET::OnRenderCheckBox, this );
374  cb->SetToolTip( aSpec.tooltip );
375 
376  // column 0
377  col = 0;
378  if( aSpec.color != COLOR4D::UNSPECIFIED )
379  {
380  auto bmb = new COLOR_SWATCH( m_RenderScrolledWindow, aSpec.color, encodeId( col, aSpec.id ),
382  bmb->Bind( COLOR_SWATCH_CHANGED, &LAYER_WIDGET::OnRenderSwatchChanged, this );
383  bmb->SetToolTip( _( "Left double click or middle click for color change" ) );
384  m_RenderFlexGridSizer->wxSizer::Insert( index+col, bmb, 0, flags );
385 
386  bmb->Bind( wxEVT_RIGHT_DOWN, [this, bmb, renderName] ( wxMouseEvent& aEvt ) {
387  OnRightDownRender( aEvt, bmb, renderName );
388  } );
389  cb->Bind( wxEVT_RIGHT_DOWN, [this, bmb, renderName] ( wxMouseEvent& aEvt ) {
390  OnRightDownRender( aEvt, bmb, renderName );
391  } );
392 
393  // could add a left click handler on the color button that toggles checkbox.
394  }
395  else // == -1, no color selection wanted
396  {
397  // need a place holder within the sizer to keep grid full.
398  wxPanel* invisible = new wxPanel( m_RenderScrolledWindow, encodeId( col, aSpec.id ) );
399  m_RenderFlexGridSizer->wxSizer::Insert( index+col, invisible, 0, flags );
400  }
401 
402  // Items have to be inserted in order
403  col = 1;
404  m_RenderFlexGridSizer->wxSizer::Insert( index+col, cb, 0, flags );
405 }
wxScrolledWindow * m_RenderScrolledWindow
Definition: layer_widget.h:115
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:49
wxFlexGridSizer * m_RenderFlexGridSizer
Definition: layer_widget.h:116
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.
virtual bool AreArbitraryColorsAllowed()
Subclasses can override this to provide logic for allowing arbitrary color selection via wxColourPick...
Definition: layer_widget.h:136
void OnRenderSwatchChanged(wxCommandEvent &aEvent)
Function OnRenderSwatchChanged Called when user has changed the swatch color of a render entry...
Class representing a simple color swatch, of the kind used to set layer colors.
Definition: color_swatch.h:38
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.

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 128 of file class_pcb_layer_widget.cpp.

References DIM.

Referenced by ReFillRender(), and SyncRenderStates().

129 {
130  for( unsigned ii = 0; ii < DIM( s_allowed_in_FpEditor ); ii++ )
131  if( s_allowed_in_FpEditor[ii] == aId )
132  return true;
133 
134  return false;
135 }
#define DIM(x)
of elements in an array
Definition: macros.h:98
static int s_allowed_in_FpEditor[]
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 138 of file class_pcb_layer_widget.cpp.

References LSET::AllTechMask().

Referenced by OnLayerSelect(), and ReFill().

139 {
140  static LSET allowed = LSET::AllTechMask();
141  // Currently not in use because putting a graphic item on a copper layer
142  // is not currently supported by DRC.
143  // allowed.set( F_Cu ).set( B_Cu );
144  return allowed.test( aLayer );
145 }
static LSET AllTechMask()
Function AllTechMask returns a mask holding all technical layers (no CU layer) on both side...
Definition: lset.cpp:716
Class LSET is a set of PCB_LAYER_IDs.
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 658 of file layer_widget.cpp.

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

Referenced by GERBVIEW_FRAME::IsLayerVisible().

659 {
660  int row = findLayerRow( aLayer );
661  if( row >= 0 )
662  {
663  wxCheckBox* cb = (wxCheckBox*) getLayerComp( row, COLUMN_COLOR_LYR_CB );
664  wxASSERT( cb );
665  return cb->GetValue();
666  }
667  return false;
668 }
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:53
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 173 of file layer_widget.cpp.

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

Referenced by LAYER_WIDGET::insertLayerRow().

174 {
175  wxCheckBox* eventSource = (wxCheckBox*) event.GetEventObject();
176  LAYER_NUM layer = getDecodedId( eventSource->GetId() );
177  OnLayerVisible( layer, eventSource->IsChecked() );
178  passOnFocus();
179 }
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.
void PCB_LAYER_WIDGET::OnLayerColorChange ( int  aLayer,
COLOR4D  aColor 
)
overridevirtual

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

Derived classes will handle this accordingly.

Parameters
aLayeris the board layer to change
aColoris the new color

Implements LAYER_WIDGET.

Definition at line 531 of file class_pcb_layer_widget.cpp.

References KIGFX::COLOR4D::a, PCB_GENERAL_SETTINGS::Colors(), EDA_DRAW_FRAME::GetCanvas(), EDA_DRAW_FRAME::GetGalCanvas(), COLORS_DESIGN_SETTINGS::GetLayerColor(), GetNetnameLayer(), KIGFX::VIEW::GetPainter(), KIGFX::PAINTER::GetSettings(), EDA_DRAW_PANEL_GAL::GetView(), KIGFX::RENDER_SETTINGS::ImportLegacyColors(), EDA_DRAW_FRAME::IsGalCanvasActive(), myframe, EDA_DRAW_PANEL::Refresh(), COLORS_DESIGN_SETTINGS::SetLayerColor(), PCB_BASE_FRAME::Settings(), ToLAYER_ID(), and KIGFX::VIEW::UpdateLayerColor().

532 {
533  // Avoid setting the alpha channel, when we are in legacy mode,
534  // because in legacy mode the alpha channel is not used, but changing it
535  // destroys the GAL color setup
536  if( !myframe->IsGalCanvasActive() )
537  {
538  COLOR4D oldColor = myframe->Settings().Colors().GetLayerColor( ToLAYER_ID( aLayer ) );
539  aColor.a = oldColor.a;
540  }
541 
542  myframe->Settings().Colors().SetLayerColor( ToLAYER_ID( aLayer ), aColor );
543 
544  if( myframe->IsGalCanvasActive() )
545  {
546  KIGFX::VIEW* view = myframe->GetGalCanvas()->GetView();
548  view->UpdateLayerColor( aLayer );
549  view->UpdateLayerColor( GetNetnameLayer( aLayer ) );
550  }
551 
552  myframe->GetCanvas()->Refresh();
553 }
virtual void Refresh(bool eraseBackground=true, const wxRect *rect=NULL) override
Update the board display after modifying it bu a python script (note: it is automatically called by a...
Definition: draw_panel.cpp:325
int GetNetnameLayer(int aLayer)
Returns a netname layer corresponding to the given layer.
EDA_DRAW_PANEL * GetCanvas()
Definition: draw_frame.h:331
PCB_BASE_FRAME * myframe
void SetLayerColor(LAYER_NUM aLayer, COLOR4D aColor)
Function SetLayerColor sets the color for aLayer.
KIGFX::VIEW * GetView() const
Function GetView() Returns a pointer to the VIEW instance used in the panel.
double a
Alpha component.
Definition: color4d.h:294
PCB_GENERAL_SETTINGS & Settings()
bool IsGalCanvasActive() const
Function IsGalCanvasActive is used to check which canvas (GAL-based or standard) is currently in use...
Definition: draw_frame.h:856
PAINTER * GetPainter() const
Function GetPainter() Returns the painter object used by the view for drawing VIEW_ITEMS.
Definition: view.h:196
COLORS_DESIGN_SETTINGS & Colors()
virtual void ImportLegacyColors(const COLORS_DESIGN_SETTINGS *aSettings)=0
Function ImportLegacyColors Loads a list of color settings for layers.
void UpdateLayerColor(int aLayer)
Function UpdateLayerColor() Applies the new coloring scheme held by RENDER_SETTINGS in case that it h...
Definition: view.cpp:657
virtual RENDER_SETTINGS * GetSettings()=0
Function GetSettings Returns pointer to current settings that are going to be used when drawing items...
COLOR4D GetLayerColor(LAYER_NUM aLayer) const
Function GetLayerColor.
EDA_DRAW_PANEL_GAL * GetGalCanvas() const
Function GetGalCanvas returns a pointer to GAL-based canvas of given EDA draw frame.
Definition: draw_frame.h:864
Class VIEW.
Definition: view.h:58
PCB_LAYER_ID ToLAYER_ID(int aLayer)
Definition: lset.cpp:774
Class COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:39
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 614 of file class_pcb_layer_widget.cpp.

References AddRightClickMenuItems().

615 {
616  AddRightClickMenuItems( aMenu );
617 }
void AddRightClickMenuItems(wxMenu &menu)
Function addRightClickMenuItems add menu items to a menu that should be shown when right-clicking the...
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 556 of file class_pcb_layer_widget.cpp.

References EDA_DRAW_FRAME::GetCanvas(), PCB_BASE_FRAME::GetDisplayOptions(), isLayerAllowedInFpMode(), m_alwaysShowActiveCopperLayer, PCB_DISPLAY_OPTIONS::m_ContrastModeDisplay, m_fp_editor_mode, myframe, OnLayerSelected(), EDA_DRAW_PANEL::Refresh(), PCB_BASE_FRAME::SetActiveLayer(), and ToLAYER_ID().

557 {
558  // the layer change from the PCB_LAYER_WIDGET can be denied by returning
559  // false from this function.
560  PCB_LAYER_ID layer = ToLAYER_ID( aLayer );
561 
562  if( m_fp_editor_mode && !isLayerAllowedInFpMode( layer ) )
563  return false;
564 
565  myframe->SetActiveLayer( layer );
567 
569  OnLayerSelected();
570  else if( displ_opts->m_ContrastModeDisplay )
571  myframe->GetCanvas()->Refresh();
572 
573  return true;
574 }
virtual void Refresh(bool eraseBackground=true, const wxRect *rect=NULL) override
Update the board display after modifying it bu a python script (note: it is automatically called by a...
Definition: draw_panel.cpp:325
EDA_DRAW_PANEL * GetCanvas()
Definition: draw_frame.h:331
bool isLayerAllowedInFpMode(PCB_LAYER_ID aLayer)
Function isLayerAllowedInFpMode.
PCB_BASE_FRAME * myframe
bool OnLayerSelected()
Function OnLayerSelected ensure the active layer is visible, and other layers not visible when m_alwa...
void * GetDisplayOptions() override
Function GetDisplayOptions returns the display options current in use Display options are relative to...
Class PCB_DISPLAY_OPTIONS handles display options like enable/disable some optional drawings...
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.
PCB_LAYER_ID ToLAYER_ID(int aLayer)
Definition: lset.cpp:774
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 577 of file class_pcb_layer_widget.cpp.

References ID_ALWAYS_SHOW_NO_COPPER_LAYERS_BUT_ACTIVE, m_alwaysShowActiveCopperLayer, and onPopupSelection().

Referenced by OnLayerSelect().

578 {
580  return false;
581 
582  // postprocess after an active layer selection
583  // ensure active layer visible
584  wxCommandEvent event;
586  onPopupSelection( event );
587 
588  return true;
589 }
void onPopupSelection(wxCommandEvent &event)
void LAYER_WIDGET::OnLayerSwatchChanged ( wxCommandEvent &  aEvent)
protectedinherited

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

Definition at line 154 of file layer_widget.cpp.

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

Referenced by LAYER_WIDGET::insertLayerRow().

155 {
156  auto eventSource = static_cast<COLOR_SWATCH*>( aEvent.GetEventObject() );
157 
158  COLOR4D newColor = eventSource->GetSwatchColor();
159 
160  LAYER_NUM layer = getDecodedId( eventSource->GetId() );
161 
162  // tell the client code.
163  OnLayerColorChange( layer, newColor );
164 
165  // notify others
166  wxCommandEvent event( EVT_LAYER_COLOR_CHANGE );
167  wxPostEvent( this, event );
168 
169  passOnFocus();
170 }
static const wxEventType EVT_LAYER_COLOR_CHANGE
Definition: layer_widget.h:106
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.
Class representing a simple color swatch, of the kind used to set layer colors.
Definition: color_swatch.h:38
Class COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:39
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 592 of file class_pcb_layer_widget.cpp.

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

Referenced by onPopupSelection().

593 {
594  BOARD* brd = myframe->GetBoard();
595 
596  LSET visibleLayers = brd->GetVisibleLayers();
597 
598  visibleLayers.set( aLayer, isVisible );
599 
600  brd->SetVisibleLayers( visibleLayers );
601 
602  myframe->OnModify();
603 
604  EDA_DRAW_PANEL_GAL* galCanvas = myframe->GetGalCanvas();
605 
606  if( galCanvas )
607  galCanvas->GetView()->SetLayerVisible( aLayer, isVisible );
608 
609  if( isFinal )
610  myframe->GetCanvas()->Refresh();
611 }
virtual void Refresh(bool eraseBackground=true, const wxRect *rect=NULL) override
Update the board display after modifying it bu a python script (note: it is automatically called by a...
Definition: draw_panel.cpp:325
EDA_DRAW_PANEL * GetCanvas()
Definition: draw_frame.h:331
PCB_BASE_FRAME * myframe
BOARD * GetBoard() const
KIGFX::VIEW * GetView() const
Function GetView() Returns a pointer to the VIEW instance used in the panel.
Class 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:387
virtual void OnModify()
Function OnModify Virtual Must be called after a change in order to set the "modify" flag of the curr...
Class BOARD holds information pertinent to a Pcbnew printed circuit board.
Definition: class_board.h:169
LSET GetVisibleLayers() const
Function GetVisibleLayers is a proxy function that calls the correspondent function in m_BoardSetting...
EDA_DRAW_PANEL_GAL * GetGalCanvas() const
Function GetGalCanvas returns a pointer to GAL-based canvas of given EDA draw frame.
Definition: draw_frame.h:864
void LAYER_WIDGET::OnLeftDownLayers ( wxMouseEvent &  event)
protectedinherited

Definition at line 82 of file layer_widget.cpp.

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().

83 {
84  int row;
85  LAYER_NUM layer;
86 
87  wxWindow* eventSource = (wxWindow*) event.GetEventObject();
88 
89  // if mouse event is coming from the m_LayerScrolledWindow and not one
90  // of its children, we have to find the row manually based on y coord.
91  if( eventSource == m_LayerScrolledWindow )
92  {
93  int y = event.GetY();
94 
95  wxArrayInt heights = m_LayersFlexGridSizer->GetRowHeights();
96 
97  int height = 0;
98 
99  int rowCount = GetLayerRowCount();
100  for( row = 0; row<rowCount; ++row )
101  {
102  if( y < height + heights[row] )
103  break;
104 
105  height += heights[row];
106  }
107 
108  if( row >= rowCount )
109  row = rowCount - 1;
110 
111  layer = getDecodedId( getLayerComp( row, 0 )->GetId() );
112  }
113 
114  else
115  {
116  // all nested controls on a given row will have their ID encoded with
117  // encodeId(), and the corresponding decoding is getDecodedId()
118  int id = eventSource->GetId();
119  layer = getDecodedId( id );
120  row = findLayerRow( layer );
121  }
122 
123  if( OnLayerSelect( layer ) ) // if client allows this change.
124  SelectLayerRow( row );
125 
126  passOnFocus();
127 }
wxFlexGridSizer * m_LayersFlexGridSizer
Definition: layer_widget.h:113
int findLayerRow(LAYER_NUM aLayer) const
Function findLayerRow returns the row index that aLayer resides in, or -1 if not found.
wxScrolledWindow * m_LayerScrolledWindow
Definition: layer_widget.h:112
wxWindow * getLayerComp(int aRow, int aColumn) const
Function getLayerComp returns the component within the m_LayersFlexGridSizer at aRow and aCol or NULL...
int GetLayerRowCount() const
Function GetLayerRowCount returns the number of rows in the layer tab.
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.
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...
void PCB_LAYER_WIDGET::onPopupSelection ( wxCommandEvent &  event)
protected

Definition at line 202 of file class_pcb_layer_widget.cpp.

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().

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

Definition at line 218 of file layer_widget.cpp.

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

Referenced by LAYER_WIDGET::insertRenderRow().

219 {
220  wxCheckBox* eventSource = (wxCheckBox*) event.GetEventObject();
221  LAYER_NUM id = getDecodedId( eventSource->GetId() );
222  OnRenderEnable( id, eventSource->IsChecked() );
223  passOnFocus();
224 }
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.
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 620 of file class_pcb_layer_widget.cpp.

References PCB_GENERAL_SETTINGS::Colors(), GAL_LAYER_ID_END, GAL_LAYER_ID_START, EDA_DRAW_FRAME::GetCanvas(), EDA_DRAW_PANEL_GAL::GetGAL(), EDA_DRAW_FRAME::GetGalCanvas(), KIGFX::VIEW::GetPainter(), KIGFX::PAINTER::GetSettings(), EDA_DRAW_PANEL_GAL::GetView(), KIGFX::RENDER_SETTINGS::ImportLegacyColors(), EDA_DRAW_FRAME::IsGalCanvasActive(), LAYER_GRID, KIGFX::VIEW::MarkTargetDirty(), myframe, EDA_DRAW_PANEL_GAL::Refresh(), EDA_DRAW_PANEL::Refresh(), KIGFX::GAL::SetGridColor(), COLORS_DESIGN_SETTINGS::SetItemColor(), PCB_BASE_FRAME::Settings(), KIGFX::TARGET_NONCACHED, and KIGFX::VIEW::UpdateLayerColor().

621 {
622  wxASSERT( aId > GAL_LAYER_ID_START && aId < GAL_LAYER_ID_END );
623 
624  myframe->Settings().Colors().SetItemColor( static_cast<GAL_LAYER_ID>( aId ), aColor );
625 
626  EDA_DRAW_PANEL_GAL* galCanvas = myframe->GetGalCanvas();
627 
628  if( galCanvas && myframe->IsGalCanvasActive() )
629  {
630  if( aId == LAYER_GRID )
631  galCanvas->GetGAL()->SetGridColor( aColor );
632 
633  KIGFX::VIEW* view = galCanvas->GetView();
635  view->MarkTargetDirty( KIGFX::TARGET_NONCACHED ); // useful to update rastnest
636  view->UpdateLayerColor( aId );
637  galCanvas->Refresh();
638  }
639 
640  myframe->GetCanvas()->Refresh();
641 }
void SetItemColor(int aItemIdx, COLOR4D aColor)
Function SetItemColor sets the color for an item which is one of the item indices given in enum PCB_L...
virtual void Refresh(bool eraseBackground=true, const wxRect *rect=NULL) override
Update the board display after modifying it bu a python script (note: it is automatically called by a...
Definition: draw_panel.cpp:325
EDA_DRAW_PANEL * GetCanvas()
Definition: draw_frame.h:331
PCB_BASE_FRAME * myframe
KIGFX::VIEW * GetView() const
Function GetView() Returns a pointer to the VIEW instance used in the panel.
Add new GAL layers here.
Auxiliary rendering target (noncached)
Definition: definitions.h:42
void SetGridColor(const COLOR4D &aGridColor)
Set the grid color.
KIGFX::GAL * GetGAL() const
Function GetGAL() Returns a pointer to the GAL instance used in the panel.
void MarkTargetDirty(int aTarget)
Function MarkTargetDirty() Sets or clears target 'dirty' flag.
Definition: view.h:568
PCB_GENERAL_SETTINGS & Settings()
bool IsGalCanvasActive() const
Function IsGalCanvasActive is used to check which canvas (GAL-based or standard) is currently in use...
Definition: draw_frame.h:856
PAINTER * GetPainter() const
Function GetPainter() Returns the painter object used by the view for drawing VIEW_ITEMS.
Definition: view.h:196
void Refresh(bool aEraseBackground=true, const wxRect *aRect=NULL) override
Update the board display after modifying it bu a python script (note: it is automatically called by a...
COLORS_DESIGN_SETTINGS & Colors()
virtual void ImportLegacyColors(const COLORS_DESIGN_SETTINGS *aSettings)=0
Function ImportLegacyColors Loads a list of color settings for layers.
void UpdateLayerColor(int aLayer)
Function UpdateLayerColor() Applies the new coloring scheme held by RENDER_SETTINGS in case that it h...
Definition: view.cpp:657
virtual RENDER_SETTINGS * GetSettings()=0
Function GetSettings Returns pointer to current settings that are going to be used when drawing items...
EDA_DRAW_PANEL_GAL * GetGalCanvas() const
Function GetGalCanvas returns a pointer to GAL-based canvas of given EDA draw frame.
Definition: draw_frame.h:864
Class VIEW.
Definition: view.h:58
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 644 of file class_pcb_layer_widget.cpp.

References GAL_LAYER_ID_END, GAL_LAYER_ID_START, PCB_BASE_FRAME::GetBoard(), EDA_DRAW_FRAME::GetCanvas(), EDA_DRAW_PANEL_GAL::GetGAL(), EDA_DRAW_FRAME::GetGalCanvas(), EDA_DRAW_PANEL_GAL::GetView(), BOARD::IsElementVisible(), EDA_DRAW_FRAME::IsGalCanvasActive(), EDA_DRAW_FRAME::IsGridVisible(), LAYER_GRID, LAYER_RATSNEST, KIGFX::VIEW::MarkTargetDirty(), myframe, PCB_BASE_FRAME::OnModify(), EDA_DRAW_PANEL_GAL::Refresh(), EDA_DRAW_PANEL::Refresh(), BOARD::SetElementVisibility(), KIGFX::GAL::SetGridVisibility(), KIGFX::VIEW::SetLayerVisible(), and KIGFX::TARGET_NONCACHED.

645 {
646  BOARD* brd = myframe->GetBoard();
647  wxASSERT( aId > GAL_LAYER_ID_START && aId < GAL_LAYER_ID_END );
648 
649  // The layer visibility status is saved in the board file so set the board modified
650  // state so the user has the option to save the changes.
651  if( brd->IsElementVisible( static_cast<GAL_LAYER_ID>( aId ) ) != isEnabled )
652  myframe->OnModify();
653 
654  brd->SetElementVisibility( static_cast<GAL_LAYER_ID>( aId ), isEnabled );
655 
656  EDA_DRAW_PANEL_GAL* galCanvas = myframe->GetGalCanvas();
657 
658  if( galCanvas && myframe->IsGalCanvasActive() )
659  {
660  if( aId == LAYER_GRID )
661  {
662  galCanvas->GetGAL()->SetGridVisibility( myframe->IsGridVisible() );
664  }
665  else if ( aId == LAYER_RATSNEST )
666  {
667  // don't touch the layers. ratsnest is enabled on per-item basis.
669  galCanvas->GetView()->SetLayerVisible( aId, true );
670  }
671  else
672  galCanvas->GetView()->SetLayerVisible( aId, isEnabled );
673 
674  galCanvas->Refresh();
675  }
676 
677  myframe->GetCanvas()->Refresh();
678 }
void SetElementVisibility(GAL_LAYER_ID aLayer, bool aNewState)
Function SetElementVisibility changes the visibility of an element category.
virtual void Refresh(bool eraseBackground=true, const wxRect *rect=NULL) override
Update the board display after modifying it bu a python script (note: it is automatically called by a...
Definition: draw_panel.cpp:325
EDA_DRAW_PANEL * GetCanvas()
Definition: draw_frame.h:331
PCB_BASE_FRAME * myframe
BOARD * GetBoard() const
KIGFX::VIEW * GetView() const
Function GetView() Returns a pointer to the VIEW instance used in the panel.
Add new GAL layers here.
virtual bool IsGridVisible() const
Function IsGridVisible() , virtual.
Definition: draw_frame.h:475
Auxiliary rendering target (noncached)
Definition: definitions.h:42
KIGFX::GAL * GetGAL() const
Function GetGAL() Returns a pointer to the GAL instance used in the panel.
void MarkTargetDirty(int aTarget)
Function MarkTargetDirty() Sets or clears target 'dirty' flag.
Definition: view.h:568
bool IsGalCanvasActive() const
Function IsGalCanvasActive is used to check which canvas (GAL-based or standard) is currently in use...
Definition: draw_frame.h:856
void SetLayerVisible(int aLayer, bool aVisible=true)
Function SetLayerVisible() Controls the visibility of a particular layer.
Definition: view.h:387
void Refresh(bool aEraseBackground=true, const wxRect *aRect=NULL) override
Update the board display after modifying it bu 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...
bool IsElementVisible(GAL_LAYER_ID aLayer) const
Function IsElementVisible tests whether a given element category is visible.
Class BOARD holds information pertinent to a Pcbnew printed circuit board.
Definition: class_board.h:169
void SetGridVisibility(bool aVisibility)
Sets the visibility setting of the grid.
EDA_DRAW_PANEL_GAL * GetGalCanvas() const
Function GetGalCanvas returns a pointer to GAL-based canvas of given EDA draw frame.
Definition: draw_frame.h:864
void LAYER_WIDGET::OnRenderSwatchChanged ( wxCommandEvent &  aEvent)
protectedinherited

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

Definition at line 203 of file layer_widget.cpp.

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

Referenced by LAYER_WIDGET::insertRenderRow().

204 {
205  auto eventSource = static_cast<COLOR_SWATCH*>( aEvent.GetEventObject() );
206 
207  COLOR4D newColor = eventSource->GetSwatchColor();
208 
209  LAYER_NUM id = getDecodedId( eventSource->GetId() );
210 
211  // tell the client code.
212  OnRenderColorChange( id, newColor );
213 
214  passOnFocus();
215 }
virtual void OnRenderColorChange(int aId, COLOR4D aColor)=0
Function OnRenderColorChange is called to notify client code whenever the user changes a rendering co...
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.
Class representing a simple color swatch, of the kind used to set layer colors.
Definition: color_swatch.h:38
Class COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:39
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 130 of file layer_widget.cpp.

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

Referenced by LAYER_WIDGET::insertLayerRow().

131 {
132  wxMenu menu;
133 
135  _( "Change Layer Color for " ) + aLayerName,
136  KiBitmap( setcolor_copper_xpm ) );
137  menu.AppendSeparator();
138 
139  OnLayerRightClick( menu );
140 
141  menu.Bind( wxEVT_COMMAND_MENU_SELECTED, [this, aColorSwatch]( wxCommandEvent& event ) {
142  if ( event.GetId() == ID_CHANGE_LAYER_COLOR ) {
143  aColorSwatch->GetNewSwatchColor();
144  } else {
145  event.Skip();
146  }
147  } );
148 
149  PopupMenu( &menu );
150  passOnFocus();
151 }
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:55
wxBitmap KiBitmap(BITMAP_DEF aBitmap)
Function KiBitmap constructs a wxBitmap from a memory record, held in a BITMAP_DEF.
Definition: bitmap.cpp:36
void passOnFocus()
Function passOnFocus gives away the keyboard focus up to the main parent window.
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.
void PCB_LAYER_WIDGET::onRightDownLayers ( wxMouseEvent &  event)
protected

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

Definition at line 191 of file class_pcb_layer_widget.cpp.

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

Referenced by PCB_LAYER_WIDGET().

192 {
193  wxMenu menu;
194 
195  AddRightClickMenuItems( menu );
196  PopupMenu( &menu );
197 
198  passOnFocus();
199 }
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.
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 182 of file layer_widget.cpp.

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

Referenced by LAYER_WIDGET::insertRenderRow().

183 {
184  wxMenu menu;
185 
187  _( "Change Render Color for " ) + aRenderName,
188  KiBitmap( setcolor_board_body_xpm ) );
189 
190  menu.Bind( wxEVT_COMMAND_MENU_SELECTED, [this, aColorSwatch]( wxCommandEvent& event ) {
191  if ( event.GetId() == ID_CHANGE_RENDER_COLOR ) {
192  aColorSwatch->GetNewSwatchColor();
193  } else {
194  event.Skip();
195  }
196  } );
197 
198  PopupMenu( &menu );
199  passOnFocus();
200 }
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:55
wxBitmap KiBitmap(BITMAP_DEF aBitmap)
Function KiBitmap constructs a wxBitmap from a memory record, held in a BITMAP_DEF.
Definition: bitmap.cpp:36
void passOnFocus()
Function passOnFocus gives away the keyboard focus up to the main parent window.
void GetNewSwatchColor()
Prompt for a new colour, using the colour picker dialog.
void LAYER_WIDGET::OnTabChange ( wxNotebookEvent &  event)
protectedinherited

Definition at line 227 of file layer_widget.cpp.

References LAYER_WIDGET::passOnFocus().

Referenced by LAYER_WIDGET::LAYER_WIDGET().

228 {
229 // wxFocusEvent event( wxEVT_SET_FOCUS );
230 // m_FocusOwner->AddPendingEvent( event );
231 
232  passOnFocus(); // does not work in this context, probably because we have receive control here too early.
233 }
void passOnFocus()
Function passOnFocus gives away the keyboard focus up to the main parent window.
void PCB_LAYER_WIDGET::ReFill ( )

Definition at line 439 of file class_pcb_layer_widget.cpp.

References LAYER_WIDGET::AppendLayerRow(), B_Adhes, B_CrtYd, B_Cu, B_Fab, B_Mask, B_Paste, B_SilkS, LAYER_WIDGET::ClearLayerRows(), Cmts_User, PCB_GENERAL_SETTINGS::Colors(), COLUMN_COLOR_LYRNAME, COLUMN_COLORBM, LSET::CuStack(), DIM, Dwgs_User, Eco1_User, Eco2_User, Edge_Cuts, F_Adhes, F_CrtYd, F_Cu, F_Fab, F_Mask, F_Paste, F_SilkS, PCB_BASE_FRAME::GetBoard(), BOARD::GetEnabledLayers(), COLORS_DESIGN_SETTINGS::GetLayerColor(), LAYER_WIDGET::getLayerComp(), BOARD::GetLayerName(), LAYER_WIDGET::GetLayerRowCount(), isLayerAllowedInFpMode(), m_fp_editor_mode, Margin, myframe, and PCB_BASE_FRAME::Settings().

440 {
441  BOARD* brd = myframe->GetBoard();
442  LSET enabled = brd->GetEnabledLayers();
443 
444  ClearLayerRows();
445 
446  wxString dsc;
447 
448  // show all coppers first, with front on top, back on bottom, then technical layers
449  for( LSEQ cu_stack = enabled.CuStack(); cu_stack; ++cu_stack )
450  {
451  PCB_LAYER_ID layer = *cu_stack;
452 
453  switch( layer )
454  {
455  case F_Cu:
456  dsc = _( "Front copper layer" );
457  break;
458 
459  case B_Cu:
460  dsc = _( "Back copper layer" );
461  break;
462 
463  default:
464  dsc = _( "Inner copper layer" );
465  break;
466  }
467 
469  brd->GetLayerName( layer ), layer, myframe->Settings().Colors().GetLayerColor( layer ),
470  dsc, true ) );
471 
472  if( m_fp_editor_mode && !isLayerAllowedInFpMode( layer ) )
473  {
474  getLayerComp( GetLayerRowCount()-1, COLUMN_COLOR_LYRNAME )->Enable( false );
476  COLUMN_COLORBM )->SetToolTip( wxEmptyString );
477  }
478  }
479 
480 
481  // technical layers are shown in this order:
482  // Because they are static, wxGetTranslation must be explicitly
483  // called for tooltips.
484  static const struct {
485  PCB_LAYER_ID layerId;
486  wxString tooltip;
487  } non_cu_seq[] = {
488  { F_Adhes, _( "Adhesive on board's front" ) },
489  { B_Adhes, _( "Adhesive on board's back" ) },
490  { F_Paste, _( "Solder paste on board's front" ) },
491  { B_Paste, _( "Solder paste on board's back" ) },
492  { F_SilkS, _( "Silkscreen on board's front" ) },
493  { B_SilkS, _( "Silkscreen on board's back" ) },
494  { F_Mask, _( "Solder mask on board's front" ) },
495  { B_Mask, _( "Solder mask on board's back" ) },
496  { Dwgs_User, _( "Explanatory drawings" ) },
497  { Cmts_User, _( "Explanatory comments" ) },
498  { Eco1_User, _( "User defined meaning" ) },
499  { Eco2_User, _( "User defined meaning" ) },
500  { Edge_Cuts, _( "Board's perimeter definition" ) },
501  { Margin, _( "Board's edge setback outline" ) },
502  { F_CrtYd, _( "Footprint courtyards on board's front" ) },
503  { B_CrtYd, _( "Footprint courtyards on board's back" ) },
504  { F_Fab, _( "Footprint assembly on board's front" ) },
505  { B_Fab, _( "Footprint assembly on board's back" ) }
506  };
507 
508  for( unsigned i=0; i<DIM( non_cu_seq ); ++i )
509  {
510  PCB_LAYER_ID layer = non_cu_seq[i].layerId;
511 
512  if( !enabled[layer] )
513  continue;
514 
516  brd->GetLayerName( layer ), layer, myframe->Settings().Colors().GetLayerColor( layer ),
517  wxGetTranslation( non_cu_seq[i].tooltip ), true ) );
518 
519  if( m_fp_editor_mode && !isLayerAllowedInFpMode( layer ) )
520  {
521  getLayerComp( GetLayerRowCount()-1, COLUMN_COLOR_LYRNAME )->Enable( false );
523  COLUMN_COLORBM )->SetToolTip( wxEmptyString );
524  }
525  }
526 }
#define COLUMN_COLOR_LYRNAME
Definition: layer_widget.h:54
#define DIM(x)
of elements in an array
Definition: macros.h:98
Struct ROW provides all the data needed to add a row to a LAYER_WIDGET.
Definition: layer_widget.h:85
LSEQ CuStack() const
Function CuStack returns a sequence of copper layers in starting from the front/top and extending to ...
Definition: lset.cpp:147
bool isLayerAllowedInFpMode(PCB_LAYER_ID aLayer)
Function isLayerAllowedInFpMode.
PCB_BASE_FRAME * myframe
BOARD * GetBoard() const
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:
Class LSET is a set of PCB_LAYER_IDs.
#define COLUMN_COLORBM
Definition: layer_widget.h:52
PCB_GENERAL_SETTINGS & Settings()
const wxString GetLayerName(PCB_LAYER_ID aLayer) const
Function GetLayerName returns the name of a layer given by aLayer.
void AppendLayerRow(const ROW &aRow)
Function AppendLayerRow appends a new row in the layer portion of the widget.
wxWindow * getLayerComp(int aRow, int aColumn) const
Function getLayerComp returns the component within the m_LayersFlexGridSizer at aRow and aCol or NULL...
int GetLayerRowCount() const
Function GetLayerRowCount returns the number of rows in the layer tab.
Class LSEQ is a sequence (and therefore also a set) of PCB_LAYER_IDs.
COLORS_DESIGN_SETTINGS & Colors()
Class BOARD holds information pertinent to a Pcbnew printed circuit board.
Definition: class_board.h:169
COLOR4D GetLayerColor(LAYER_NUM aLayer) const
Function GetLayerColor.
void PCB_LAYER_WIDGET::ReFillRender ( )

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

Definition at line 370 of file class_pcb_layer_widget.cpp.

References LAYER_WIDGET::AppendRenderRow(), LAYER_WIDGET::ClearRenderRows(), LAYER_WIDGET::ROW::color, PCB_GENERAL_SETTINGS::Colors(), DIM, PCB_BASE_FRAME::GetBoard(), COLORS_DESIGN_SETTINGS::GetItemColor(), LAYER_WIDGET::ROW::id, isAllowedInFpMode(), BOARD::IsElementVisible(), m_fp_editor_mode, myframe, LAYER_WIDGET::ROW::rowName, s_render_rows, PCB_BASE_FRAME::Settings(), LAYER_WIDGET::ROW::state, and LAYER_WIDGET::ROW::tooltip.

Referenced by PCB_LAYER_WIDGET().

371 {
372  BOARD* board = myframe->GetBoard();
373  ClearRenderRows();
374 
375  // Add "Render" tab rows to LAYER_WIDGET, after setting color and checkbox state.
376  // Because s_render_rows is created static, we must explicitly call
377  // wxGetTranslation for texts which are internationalized (tool tips
378  // and item names)
379  for( unsigned row=0; row<DIM(s_render_rows); ++row )
380  {
381  LAYER_WIDGET::ROW renderRow = s_render_rows[row];
382 
383  if( m_fp_editor_mode && !isAllowedInFpMode( renderRow.id ) )
384  continue;
385 
386  renderRow.tooltip = wxGetTranslation( s_render_rows[row].tooltip );
387  renderRow.rowName = wxGetTranslation( s_render_rows[row].rowName );
388 
389  if( renderRow.color != COLOR4D::UNSPECIFIED ) // does this row show a color?
390  {
391  // this window frame must have an established BOARD, i.e. after SetBoard()
392  renderRow.color = myframe->Settings().Colors().GetItemColor( static_cast<GAL_LAYER_ID>( renderRow.id ) );
393  }
394 
395  renderRow.state = board->IsElementVisible( static_cast<GAL_LAYER_ID>( renderRow.id ) );
396 
397  AppendRenderRow( renderRow );
398  }
399 }
#define DIM(x)
of elements in an array
Definition: macros.h:98
Struct ROW provides all the data needed to add a row to a LAYER_WIDGET.
Definition: layer_widget.h:85
PCB_BASE_FRAME * myframe
BOARD * GetBoard() const
void ClearRenderRows()
Function ClearRenderRows empties out the render rows.
bool state
initial wxCheckBox state
Definition: layer_widget.h:90
wxString tooltip
if not empty, use this tooltip on row
Definition: layer_widget.h:91
COLOR4D GetItemColor(int aItemIdx) const
Function GetItemColor.
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:89
bool isAllowedInFpMode(int aId)
Function isAllowedInFpMode.
PCB_GENERAL_SETTINGS & Settings()
COLORS_DESIGN_SETTINGS & Colors()
static const LAYER_WIDGET::ROW s_render_rows[]
This is a read only template that is copied and modified before adding to LAYER_WIDGET.
bool IsElementVisible(GAL_LAYER_ID aLayer) const
Function IsElementVisible tests whether a given element category is visible.
Class BOARD holds information pertinent to a Pcbnew printed circuit board.
Definition: class_board.h:169
wxString rowName
the prompt or layername
Definition: layer_widget.h:87
int id
either a layer or "visible element" id
Definition: layer_widget.h:88
void LAYER_WIDGET::SelectLayer ( LAYER_NUM  aLayer)
inherited

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

Definition at line 629 of file layer_widget.cpp.

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

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

630 {
631  int row = findLayerRow( aLayer );
632  SelectLayerRow( row );
633 }
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.
void LAYER_WIDGET::SelectLayerRow ( int  aRow)
inherited

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

Definition at line 600 of file layer_widget.cpp.

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

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

601 {
602  // enable the layer tab at index 0
603  m_notebook->SetSelection( 0 );
604 
605  INDICATOR_ICON* oldIndicator = (INDICATOR_ICON*) getLayerComp( m_CurrentRow, 0 );
606  if( oldIndicator )
608 
609  INDICATOR_ICON* newIndicator = (INDICATOR_ICON*) getLayerComp( aRow, 0 );
610  if( newIndicator )
611  {
613 
614  // Make sure the desired layer row is visible.
615  // It seems that as of 2.8.2, setting the focus does this.
616  // I don't expect the scrolling to be needed at all because
617  // the minimum window size may end up being established so that the
618  // scroll bars will not be visible.
619  getLayerComp( aRow, 1 )->SetFocus();
620  }
621 
622  m_CurrentRow = aRow;
623 
624  // give the focus back to the app.
625  passOnFocus();
626 }
void SetIndicatorState(ICON_ID aIconId)
Sets the row indiciator to the given state.
wxAuiNotebook * m_notebook
Definition: layer_widget.h:110
int m_CurrentRow
selected row of layer list
Definition: layer_widget.h:119
#define OFF
Class representing a row indicator icon for use in places like the layer widget.
wxWindow * getLayerComp(int aRow, int aColumn) const
Function getLayerComp returns the component within the m_LayersFlexGridSizer at aRow and aCol or NULL...
void passOnFocus()
Function passOnFocus gives away the keyboard focus up to the main parent window.
#define ON
void LAYER_WIDGET::SetLayerColor ( LAYER_NUM  aLayer,
COLOR4D  aColor 
)
inherited

Function SetLayerColor changes the color of aLayer.

Definition at line 671 of file layer_widget.cpp.

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

672 {
673  int row = findLayerRow( aLayer );
674  if( row >= 0 )
675  {
676  int col = 1; // bitmap button is column 1
677  auto swatch = static_cast<COLOR_SWATCH*>( getLayerComp( row, col ) );
678  wxASSERT( swatch );
679 
680  swatch->SetSwatchColor( aColor, false );
681  }
682 }
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...
Class representing a simple color swatch, of the kind used to set layer colors.
Definition: color_swatch.h:38
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 363 of file class_pcb_layer_widget.cpp.

References LAYER_WIDGET::m_notebook.

Referenced by PCB_LAYER_WIDGET().

364 {
365  m_notebook->SetPageText( 0, _( "Layer" ) );
366  m_notebook->SetPageText( 1, _( "Render" ) );
367 }
wxAuiNotebook * m_notebook
Definition: layer_widget.h:110
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 646 of file layer_widget.cpp.

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

Referenced by SyncLayerVisibilities().

647 {
648  int row = findLayerRow( aLayer );
649  if( row >= 0 )
650  {
651  wxCheckBox* cb = (wxCheckBox*) getLayerComp( row, COLUMN_COLOR_LYR_CB );
652  wxASSERT( cb );
653  cb->SetValue( isVisible ); // does not fire an event
654  }
655 }
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:53
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 701 of file layer_widget.cpp.

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

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

702 {
703  int row = findRenderRow( aId );
704 
705  if( row >= 0 )
706  {
707  int col = 1; // checkbox is column 1
708  wxCheckBox* cb = (wxCheckBox*) getRenderComp( row, col );
709  wxASSERT( cb );
710  cb->SetValue( isSet ); // does not fire an event
711  }
712 }
int findRenderRow(int aId) const
wxWindow * getRenderComp(int aRow, int aColumn) const
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 419 of file class_pcb_layer_widget.cpp.

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

420 {
421  BOARD* board = myframe->GetBoard();
422  int count = GetLayerRowCount();
423 
424  for( int row=0; row<count; ++row )
425  {
426  // this utilizes more implementation knowledge than ideal, eventually
427  // add member ROW getRow() or similar to base LAYER_WIDGET.
428 
429  wxWindow* w = getLayerComp( row, COLUMN_ICON_ACTIVE );
430 
431  PCB_LAYER_ID layerId = ToLAYER_ID( getDecodedId( w->GetId() ) );
432 
433  // this does not fire a UI event
434  SetLayerVisible( layerId, board->IsLayerVisible( layerId ) );
435  }
436 }
PCB_BASE_FRAME * myframe
BOARD * GetBoard() const
PCB_LAYER_ID
A quick note on layer IDs:
#define COLUMN_ICON_ACTIVE
Definition: layer_widget.h:51
wxWindow * getLayerComp(int aRow, int aColumn) const
Function getLayerComp returns the component within the m_LayersFlexGridSizer at aRow and aCol or NULL...
int GetLayerRowCount() const
Function GetLayerRowCount returns the number of rows in the layer tab.
static LAYER_NUM getDecodedId(int aControlId)
Function getDecodedId decodes aControlId to original un-encoded value.
Class BOARD holds information pertinent to a Pcbnew printed circuit board.
Definition: class_board.h:169
void SetLayerVisible(LAYER_NUM aLayer, bool isVisible)
Function SetLayerVisible sets aLayer visible or not.
PCB_LAYER_ID ToLAYER_ID(int aLayer)
Definition: lset.cpp:774
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:451
void PCB_LAYER_WIDGET::SyncRenderStates ( )

Function SyncRenderStates updates the checkboxes (checked or not) to be consistent with the current state of the visibility of the visible rendering elements.

Definition at line 402 of file class_pcb_layer_widget.cpp.

References DIM, PCB_BASE_FRAME::GetBoard(), LAYER_WIDGET::ROW::id, isAllowedInFpMode(), BOARD::IsElementVisible(), m_fp_editor_mode, myframe, s_render_rows, and LAYER_WIDGET::SetRenderState().

403 {
404  BOARD* board = myframe->GetBoard();
405 
406  for( unsigned row=0; row<DIM(s_render_rows); ++row )
407  {
408  int rowId = s_render_rows[row].id;
409 
410  if( m_fp_editor_mode && !isAllowedInFpMode( rowId ) )
411  continue;
412 
413  // this does not fire a UI event
414  SetRenderState( rowId, board->IsElementVisible( static_cast<GAL_LAYER_ID>( rowId ) ) );
415  }
416 }
#define DIM(x)
of elements in an array
Definition: macros.h:98
PCB_BASE_FRAME * myframe
BOARD * GetBoard() const
bool isAllowedInFpMode(int aId)
Function isAllowedInFpMode.
static const LAYER_WIDGET::ROW s_render_rows[]
This is a read only template that is copied and modified before adding to LAYER_WIDGET.
bool IsElementVisible(GAL_LAYER_ID aLayer) const
Function IsElementVisible tests whether a given element category is visible.
Class BOARD holds information pertinent to a Pcbnew printed circuit board.
Definition: class_board.h:169
void SetRenderState(int aId, bool isSet)
Function SetRenderState sets the state of the checkbox associated with aId within the Render tab grou...
int id
either a layer or "visible element" id
Definition: layer_widget.h:88
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 741 of file layer_widget.cpp.

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

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

742 {
743  int rowCount = GetLayerRowCount();
744 
745  for( int row = 0; row < rowCount ; row++ )
746  {
748 
749  if( indicator )
750  {
751  auto state = ( row == m_CurrentRow ) ? ROW_ICON_PROVIDER::STATE::ON
753  indicator->SetIndicatorState( state );
754  }
755  }
756 }
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:119
#define OFF
Class representing a row indicator icon for use in places like the layer widget.
#define COLUMN_ICON_ACTIVE
Definition: layer_widget.h:51
wxWindow * getLayerComp(int aRow, int aColumn) const
Function getLayerComp returns the component within the m_LayersFlexGridSizer at aRow and aCol or NULL...
int GetLayerRowCount() const
Function GetLayerRowCount returns the number of rows in the layer tab.
#define ON
void LAYER_WIDGET::UpdateLayouts ( )
inherited

Definition at line 731 of file layer_widget.cpp.

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

Referenced by LAYER_WIDGET::AppendLayerRow(), and LAYER_WIDGET::AppendRenderRow().

732 {
733  m_LayersFlexGridSizer->Layout();
734  m_RenderFlexGridSizer->Layout();
735  m_LayerPanel->Layout();
736  m_RenderingPanel->Layout();
737  FitInside();
738 }
wxFlexGridSizer * m_LayersFlexGridSizer
Definition: layer_widget.h:113
wxFlexGridSizer * m_RenderFlexGridSizer
Definition: layer_widget.h:116
wxPanel * m_RenderingPanel
Definition: layer_widget.h:114
wxPanel * m_LayerPanel
Definition: layer_widget.h:111
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 130 of file layer_widget.h.

Referenced by LAYER_WIDGET::insertLayerRow().

130 { return false; }

Member Data Documentation

const wxEventType LAYER_WIDGET::EVT_LAYER_COLOR_CHANGE = wxNewEventType()
staticinherited

Definition at line 106 of file layer_widget.h.

Referenced by LAYER_WIDGET::OnLayerSwatchChanged().

bool PCB_LAYER_WIDGET::m_alwaysShowActiveCopperLayer
protected
int LAYER_WIDGET::m_CurrentRow
protectedinherited
wxWindow* LAYER_WIDGET::m_FocusOwner
protectedinherited

Definition at line 118 of file layer_widget.h.

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

bool PCB_LAYER_WIDGET::m_fp_editor_mode
protected
wxPanel* LAYER_WIDGET::m_LayerPanel
protectedinherited
wxScrolledWindow* LAYER_WIDGET::m_LayerScrolledWindow
protectedinherited
wxAuiNotebook* LAYER_WIDGET::m_notebook
protectedinherited
int LAYER_WIDGET::m_PointSize
protectedinherited
wxPanel* LAYER_WIDGET::m_RenderingPanel
protectedinherited
wxScrolledWindow* LAYER_WIDGET::m_RenderScrolledWindow
protectedinherited

Definition at line 115 of file layer_widget.h.

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

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 121 of file class_pcb_layer_widget.h.

Referenced by ReFillRender(), and SyncRenderStates().


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