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:

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

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 = wxID_HIGHEST, 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	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	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_FRAME *	myframe

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

enum PCB_LAYER_WIDGET::POPUP_ID

protected

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

     {
         ID_SHOW_ALL_COPPER_LAYERS                    = wxID_HIGHEST,
         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
     };

Constructor & Destructor Documentation

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

Constructor.

Parameters

aParent	is the parent window
aFocusOwner	is the window that should be sent the focus after
aPointSize	is 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.
aFpEditorMode	false 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 94 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().

                                                                          :
         LAYER_WIDGET( aParent, aFocusOwner, aPointSize ),
         myframe( aParent )
 {
     m_alwaysShowActiveCopperLayer = false;
     m_fp_editor_mode = aFpEditorMode;
     ReFillRender();
 
     // Update default tabs labels
     SetLayersManagerTabsText();
 
     //-----<Popup menu>-------------------------------------------------
     // handle the popup menu over the layer window.
     m_LayerScrolledWindow->Connect( wxEVT_RIGHT_DOWN,
         wxMouseEventHandler( PCB_LAYER_WIDGET::onRightDownLayers ), NULL, this );
 
     // since Popupmenu() calls this->ProcessEvent() we must call this->Connect()
     // and not m_LayerScrolledWindow->Connect()
 
     Connect( ID_SHOW_ALL_COPPER_LAYERS, ID_LAST_VALUE - 1,
         wxEVT_COMMAND_MENU_SELECTED,
         wxCommandEventHandler( PCB_LAYER_WIDGET::onPopupSelection ), NULL, this );
     // install the right click handler into each control at end of ReFill()
     // using installRightLayerClickHandler
 }

Member Function Documentation

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

 {
     int nextRow = GetLayerRowCount();
     insertLayerRow( nextRow, aRow );
     UpdateLayouts();
 }

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 265 of file layer_widget.h.

References LAYER_WIDGET::AppendLayerRow().

     {
         for( int row=0;  row<aRowCount;  ++row )
             AppendLayerRow( aRowsArray[row] );
     }

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 512 of file layer_widget.cpp.

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

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

 {
     int nextRow = GetRenderRowCount();
     insertRenderRow( nextRow, aRow );
     UpdateLayouts();
 }

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 289 of file layer_widget.h.

References LAYER_WIDGET::AppendRenderRow().

Referenced by GERBER_LAYER_WIDGET::ReFillRender().

     {
         for( int row=0;  row<aRowCount;  ++row )
             AppendRenderRow( aRowsArray[row] );
     }

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.

 {
     return myframe->IsGalCanvasActive();
 }

void LAYER_WIDGET::ClearLayerRows ( )

inherited

Function ClearLayerRows empties out the layer rows.

Definition at line 506 of file layer_widget.cpp.

References LAYER_WIDGET::m_LayersFlexGridSizer.

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

 {
     m_LayersFlexGridSizer->Clear( true );
 }

void LAYER_WIDGET::ClearRenderRows ( )

inherited

Function ClearRenderRows empties out the render rows.

Definition at line 520 of file layer_widget.cpp.

References LAYER_WIDGET::m_RenderFlexGridSizer.

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

 {
     m_RenderFlexGridSizer->Clear( true );
 }

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 67 of file layer_widget.cpp.

References LYR_COLUMN_COUNT.

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

 {
     int id = aId * LYR_COLUMN_COUNT + aColumn;
     return id;
 }

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

 {
     int count = GetLayerRowCount();
 
     for( int row = 0; row < count; ++row )
     {
         // column 0 in the layer scroll window has a wxStaticBitmap, get its ID.
         wxWindow* w = getLayerComp( row, 0 );
         wxASSERT( w );
 
         if( aLayer == getDecodedId( w->GetId() ))
             return row;
     }
 
     return -1;
 }

int LAYER_WIDGET::findRenderRow ( int aId ) const

protectedinherited

Definition at line 230 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().

 {
     int count = GetRenderRowCount();
 
     for( int row = 0; row < count; ++row )
     {
         // column 0 in the layer scroll window has a wxStaticBitmap, get its ID.
         wxWindow* w = getRenderComp( row, 0 );
         wxASSERT( w );
 
         if( aId == getDecodedId( w->GetId() ))
             return row;
     }
 
     return -1;
 }

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

 {
     // size of m_LayerScrolledWindow --------------
     wxArrayInt widths = m_LayersFlexGridSizer->GetColWidths();
     int totWidth = 0;
 
     if( widths.GetCount() )
     {
         for( int i = 0; i < LYR_COLUMN_COUNT; ++i )
         {
             totWidth += widths[i] + m_LayersFlexGridSizer->GetHGap();
             // printf("widths[%d]:%d\n", i, widths[i] );
         }
     }
 
     // Account for the parent's frame:
     totWidth += 10;
 
 
     /* The minimum height is a small size to properly force computation
      * of the panel's scrollbars (otherwise it will assume it *has* all
      * this space) */
     unsigned totHeight = 32;
 
     wxSize layerz( totWidth, totHeight );
 
     layerz += m_LayerPanel->GetWindowBorderSize();
 
 
     // size of m_RenderScrolledWindow --------------
     widths = m_RenderFlexGridSizer->GetColWidths();
     totWidth = 0;
 
     if( widths.GetCount() )
     {
         for( int i = 0; i < RND_COLUMN_COUNT; ++i )
         {
             totWidth += widths[i] + m_RenderFlexGridSizer->GetHGap();
             // printf("widths[%d]:%d\n", i, widths[i] );
         }
     }
     // account for the parent's frame, this one has void space of 10 PLUS a border:
     totWidth += 20;
 
     // For totHeight re-use the previous small one
     wxSize renderz( totWidth, totHeight );
 
     renderz += m_RenderingPanel->GetWindowBorderSize();
 
     wxSize clientz( std::max(renderz.x,layerz.x), std::max(renderz.y,layerz.y) );
 
     return clientz;
 }

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

 {
     int id = aControlId / LYR_COLUMN_COUNT;    // rounding is OK.
     return id;
 }

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 611 of file layer_widget.cpp.

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

 {
     int row = findLayerRow( aLayer );
     if( row >= 0 )
     {
         int col = 1;    // bitmap button is column 1
         wxBitmapButton* bmb = (wxBitmapButton*) getLayerComp( row, col );
         wxASSERT( bmb );
 
         wxString colorTxt = bmb->GetName();
         return ColorFromInt( strtoul( TO_UTF8(colorTxt), NULL, 0 ) );
     }
 
     return COLOR4D::UNSPECIFIED;   // it's caller fault, gave me a bad layer
 }

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

aRow	is the row index
aColumn	is the column

Returns: wxWindow - the component installed within the sizer at given grid coordinate.

Definition at line 190 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(), GERBER_LAYER_WIDGET::installRightLayerClickHandler(), installRightLayerClickHandler(), 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().

 {
     unsigned ndx = aRow * LYR_COLUMN_COUNT + aColumn;
 
     if( ndx < m_LayersFlexGridSizer->GetChildren().GetCount() )
         return m_LayersFlexGridSizer->GetChildren()[ndx]->GetWindow();
 
     return NULL;
 }

int LAYER_WIDGET::GetLayerRowCount ( ) const

inherited

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

Definition at line 484 of file layer_widget.cpp.

References LYR_COLUMN_COUNT, and LAYER_WIDGET::m_LayersFlexGridSizer.

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

 {
     int controlCount = m_LayersFlexGridSizer->GetChildren().GetCount();
     return controlCount / LYR_COLUMN_COUNT;
 }

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

protectedinherited

Definition at line 219 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().

 {
     int ndx = aRow * RND_COLUMN_COUNT + aColumn;
 
     if( (unsigned) ndx < m_RenderFlexGridSizer->GetChildren().GetCount() )
         return m_RenderFlexGridSizer->GetChildren()[ndx]->GetWindow();
 
     return NULL;
 }

int LAYER_WIDGET::GetRenderRowCount ( ) const

inherited

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

Definition at line 491 of file layer_widget.cpp.

References LAYER_WIDGET::m_RenderFlexGridSizer, and RND_COLUMN_COUNT.

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

 {
     int controlCount = m_RenderFlexGridSizer->GetChildren().GetCount();
     return controlCount / RND_COLUMN_COUNT;
 }

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 642 of file layer_widget.cpp.

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

 {
     int row = findRenderRow( aId );
 
     if( row >= 0 )
     {
         int col = 1;    // checkbox is column 1
         wxCheckBox* cb = (wxCheckBox*) getRenderComp( row, col );
         wxASSERT( cb );
         return cb->GetValue();
     }
 
     return false;   // the value of a non-existent row
 }

LAYER_NUM LAYER_WIDGET::GetSelectedLayer ( )

inherited

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

Definition at line 562 of file layer_widget.cpp.

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

 {
     wxWindow* w = getLayerComp( m_CurrentRow, 0 );
     if( w )
         return getDecodedId( w->GetId() );
 
     return UNDEFINED_LAYER;
 }

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 248 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::ROW::rowName, shrinkFont(), LAYER_WIDGET::ROW::state, LAYER_WIDGET::ROW::tooltip, and LAYER_WIDGET::useAlternateBitmap().

Referenced by LAYER_WIDGET::AppendLayerRow().

 {
     wxASSERT( aRow >= 0 );
 
     int         col;
     int         index = aRow * LYR_COLUMN_COUNT;
     const int   flags = wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT;
 
     auto& iconProvider = useAlternateBitmap(aRow) ? alternativeRowIcons : defaultRowIcons;
 
     // column 0
     col = COLUMN_ICON_ACTIVE;
     auto sbm = new INDICATOR_ICON( m_LayerScrolledWindow, iconProvider,
                                    ROW_ICON_PROVIDER::STATE::OFF,
                                    encodeId( col, aSpec.id ) );
     sbm->Bind( wxEVT_LEFT_DOWN, &LAYER_WIDGET::OnLeftDownLayers, this );
     m_LayersFlexGridSizer->wxSizer::Insert( index+col, sbm, 0, flags );
 
     // column 1 (COLUMN_COLORBM)
     col = COLUMN_COLORBM;
 
     auto bmb = new COLOR_SWATCH( m_LayerScrolledWindow, aSpec.color, encodeId( col, aSpec.id ),
                                  AreArbitraryColorsAllowed() );
     bmb->Bind( wxEVT_LEFT_DOWN, &LAYER_WIDGET::OnLeftDownLayers, this );
     bmb->Bind( COLOR_SWATCH_CHANGED, &LAYER_WIDGET::OnLayerSwatchChanged, this );
     bmb->SetToolTip( _("Left double click or middle click for color change, right click for menu" ) );
     m_LayersFlexGridSizer->wxSizer::Insert( index+col, bmb, 0, flags );
 
     // column 2 (COLUMN_COLOR_LYR_CB)
     col = COLUMN_COLOR_LYR_CB;
     wxCheckBox* cb = new wxCheckBox( m_LayerScrolledWindow, encodeId( col, aSpec.id ), wxEmptyString );
     cb->SetValue( aSpec.state );
     cb->Bind( wxEVT_COMMAND_CHECKBOX_CLICKED, &LAYER_WIDGET::OnLayerCheckBox, this );
     cb->SetToolTip( _( "Enable this for visibility" ) );
     m_LayersFlexGridSizer->wxSizer::Insert( index+col, cb, 0, flags );
 
     // column 3 (COLUMN_COLOR_LYRNAME)
     col = COLUMN_COLOR_LYRNAME;
     wxStaticText* st = new wxStaticText( m_LayerScrolledWindow, encodeId( col, aSpec.id ), aSpec.rowName );
     shrinkFont( st, m_PointSize );
     st->Bind( wxEVT_LEFT_DOWN, &LAYER_WIDGET::OnLeftDownLayers, this );
     st->SetToolTip( aSpec.tooltip );
     m_LayersFlexGridSizer->wxSizer::Insert( index+col, st, 0, flags );
 }

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

protectedinherited

Definition at line 294 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(), RND_COLUMN_COUNT, LAYER_WIDGET::ROW::rowName, shrinkFont(), LAYER_WIDGET::ROW::state, and LAYER_WIDGET::ROW::tooltip.

Referenced by LAYER_WIDGET::AppendRenderRow().

 {
     wxASSERT( aRow >= 0 );
 
     int         col;
     int         index = aRow * RND_COLUMN_COUNT;
     const int   flags = wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT;
 
     // column 0
     col = 0;
     if( aSpec.color != COLOR4D::UNSPECIFIED )
     {
         auto bmb = new COLOR_SWATCH( m_RenderScrolledWindow, aSpec.color, encodeId( col, aSpec.id ),
                                      AreArbitraryColorsAllowed() );
         bmb->Bind( COLOR_SWATCH_CHANGED, &LAYER_WIDGET::OnRenderSwatchChanged, this );
         bmb->SetToolTip( _( "Left double click or middle click for color change" ) );
         m_RenderFlexGridSizer->wxSizer::Insert( index+col, bmb, 0, flags );
 
         // could add a left click handler on the color button that toggles checkbox.
     }
     else    // == -1, no color selection wanted
     {
         // need a place holder within the sizer to keep grid full.
         wxPanel* invisible = new wxPanel( m_RenderScrolledWindow, encodeId( col, aSpec.id ) );
         m_RenderFlexGridSizer->wxSizer::Insert( index+col, invisible, 0, flags );
     }
 
     // column 1
     col = 1;
     wxCheckBox* cb = new wxCheckBox( m_RenderScrolledWindow, encodeId( col, aSpec.id ),
                         aSpec.rowName, wxDefaultPosition, wxDefaultSize, wxALIGN_LEFT );
     shrinkFont( cb, m_PointSize );
     cb->SetValue( aSpec.state );
     cb->Enable( aSpec.changeable );
     cb->Bind( wxEVT_COMMAND_CHECKBOX_CLICKED, &LAYER_WIDGET::OnRenderCheckBox, this );
     cb->SetToolTip( aSpec.tooltip );
     m_RenderFlexGridSizer->wxSizer::Insert( index+col, cb, 0, flags );
 }

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.

Definition at line 148 of file class_pcb_layer_widget.cpp.

References LAYER_WIDGET::getLayerComp(), LAYER_WIDGET::GetLayerRowCount(), LYR_COLUMN_COUNT, and onRightDownLayers().

Referenced by ReFill().

 {
     int rowCount = GetLayerRowCount();
 
     for( int row=0; row < rowCount; ++row )
     {
         for( int col=0; col<LYR_COLUMN_COUNT; ++col )
         {
             wxWindow* w = getLayerComp( row, col );
 
             w->Connect( wxEVT_RIGHT_DOWN, wxMouseEventHandler(
                 PCB_LAYER_WIDGET::onRightDownLayers ), NULL, this );
         }
     }
 }

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

 {
     for( unsigned ii = 0; ii < DIM( s_allowed_in_FpEditor ); ii++ )
         if( s_allowed_in_FpEditor[ii] == aId )
             return true;
 
     return false;
 }

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

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

 {
     static LSET allowed = LSET::AllTechMask();
     // Currently not in use because putting a graphic item on a copper layer
     // is not currently supported by DRC.
     // allowed.set( F_Cu ).set( B_Cu );
     return allowed.test( aLayer );
 }

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 584 of file layer_widget.cpp.

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

Referenced by GERBVIEW_FRAME::IsLayerVisible().

 {
     int row = findLayerRow( aLayer );
     if( row >= 0 )
     {
         wxCheckBox* cb = (wxCheckBox*) getLayerComp( row, COLUMN_COLOR_LYR_CB );
         wxASSERT( cb );
         return cb->GetValue();
     }
     return false;
 }

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

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

Referenced by LAYER_WIDGET::insertLayerRow().

 {
     wxCheckBox* eventSource = (wxCheckBox*) event.GetEventObject();
     LAYER_NUM layer = getDecodedId( eventSource->GetId() );
     OnLayerVisible( layer, eventSource->IsChecked() );
     passOnFocus();
 }

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

aLayer	is the board layer to change
aColor	is the new color

Implements LAYER_WIDGET.

Definition at line 546 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().

 {
     // Avoid setting the alpha channel, when we are in legacy mode,
     // because in legacy mode the alpha channel is not used, but changing it
     // destroys the GAL color setup
     if( !myframe->IsGalCanvasActive() )
     {
         COLOR4D oldColor = myframe->Settings().Colors().GetLayerColor( ToLAYER_ID( aLayer ) );
         aColor.a = oldColor.a;
     }
 
     myframe->Settings().Colors().SetLayerColor( ToLAYER_ID( aLayer ), aColor );
 
     if( myframe->IsGalCanvasActive() )
     {
         KIGFX::VIEW* view = myframe->GetGalCanvas()->GetView();
         view->GetPainter()->GetSettings()->ImportLegacyColors( &myframe->Settings().Colors() );
         view->UpdateLayerColor( aLayer );
         view->UpdateLayerColor( GetNetnameLayer( aLayer ) );
     }
 
     myframe->GetCanvas()->Refresh();
 }

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

aLayer is the board layer to select

Implements LAYER_WIDGET.

Definition at line 571 of file class_pcb_layer_widget.cpp.

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

 {
     // the layer change from the PCB_LAYER_WIDGET can be denied by returning
     // false from this function.
     PCB_LAYER_ID layer = ToLAYER_ID( aLayer );
 
     if( m_fp_editor_mode && !isLayerAllowedInFpMode( layer ) )
         return false;
 
     myframe->SetActiveLayer( layer );
     DISPLAY_OPTIONS* displ_opts = (DISPLAY_OPTIONS*)myframe->GetDisplayOptions();
 
     if( m_alwaysShowActiveCopperLayer )
         OnLayerSelected();
     else if( displ_opts->m_ContrastModeDisplay )
         myframe->GetCanvas()->Refresh();
 
     return true;
 }

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

References ID_ALWAYS_SHOW_NO_COPPER_LAYERS_BUT_ACTIVE, m_alwaysShowActiveCopperLayer, and onPopupSelection().

Referenced by OnLayerSelect().

 {
     if( !m_alwaysShowActiveCopperLayer )
         return false;
 
     // postprocess after an active layer selection
     // ensure active layer visible
     wxCommandEvent event;
     event.SetId( ID_ALWAYS_SHOW_NO_COPPER_LAYERS_BUT_ACTIVE );
     onPopupSelection( event );
 
     return true;
 }

void LAYER_WIDGET::OnLayerSwatchChanged ( wxCommandEvent & aEvent )

protectedinherited

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

Definition at line 129 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().

 {
     auto eventSource = static_cast<COLOR_SWATCH*>( aEvent.GetEventObject() );
 
     COLOR4D newColor = eventSource->GetSwatchColor();
 
     LAYER_NUM layer = getDecodedId( eventSource->GetId() );
 
     // tell the client code.
     OnLayerColorChange( layer, newColor );
 
     // notify others
     wxCommandEvent event( EVT_LAYER_COLOR_CHANGE );
     wxPostEvent( this, event );
 
     passOnFocus();
 }

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

aLayer	is the board layer to select
isVisible	is the new visible state
isFinal	is 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 607 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, EDA_DRAW_PANEL::Refresh(), KIGFX::VIEW::SetLayerVisible(), and BOARD::SetVisibleLayers().

Referenced by onPopupSelection().

 {
     BOARD* brd = myframe->GetBoard();
 
     LSET visibleLayers = brd->GetVisibleLayers();
 
     visibleLayers.set( aLayer, isVisible );
 
     brd->SetVisibleLayers( visibleLayers );
 
     EDA_DRAW_PANEL_GAL* galCanvas = myframe->GetGalCanvas();
 
     if( galCanvas )
         galCanvas->GetView()->SetLayerVisible( aLayer, isVisible );
 
     if( isFinal )
         myframe->GetCanvas()->Refresh();
 }

void LAYER_WIDGET::OnLeftDownLayers ( wxMouseEvent & event )

protectedinherited

Definition at line 81 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().

 {
     int row;
     LAYER_NUM layer;
 
     wxWindow* eventSource = (wxWindow*) event.GetEventObject();
 
     // if mouse event is coming from the m_LayerScrolledWindow and not one
     // of its children, we have to find the row manually based on y coord.
     if( eventSource == m_LayerScrolledWindow )
     {
         int y = event.GetY();
 
         wxArrayInt heights = m_LayersFlexGridSizer->GetRowHeights();
 
         int height = 0;
 
         int rowCount = GetLayerRowCount();
         for( row = 0;  row<rowCount;  ++row )
         {
             if( y < height + heights[row] )
                 break;
 
             height += heights[row];
         }
 
         if( row >= rowCount )
             row = rowCount - 1;
 
         layer = getDecodedId( getLayerComp( row, 0 )->GetId() );
     }
 
     else
     {
         // all nested controls on a given row will have their ID encoded with
         // encodeId(), and the corresponding decoding is getDecodedId()
         int id = eventSource->GetId();
         layer  = getDecodedId( id );
         row    = findLayerRow( layer );
     }
 
     if( OnLayerSelect( layer ) )    // if client allows this change.
         SelectLayerRow( row );
 
     passOnFocus();
 }

void PCB_LAYER_WIDGET::onPopupSelection ( wxCommandEvent & event )

protected

Definition at line 214 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().

 {
     int     rowCount;
     int     menuId = event.GetId();
     bool    visible;
     bool    force_active_layer_visible;
 
     m_alwaysShowActiveCopperLayer = ( menuId == ID_ALWAYS_SHOW_NO_COPPER_LAYERS_BUT_ACTIVE );
     force_active_layer_visible = ( menuId == ID_SHOW_NO_COPPER_LAYERS_BUT_ACTIVE ||
             menuId == ID_ALWAYS_SHOW_NO_COPPER_LAYERS_BUT_ACTIVE );
 
     switch( menuId )
     {
 
         case ID_SHOW_NO_LAYERS:
         case ID_SHOW_ALL_LAYERS:
             {
                 visible = ( menuId == ID_SHOW_ALL_LAYERS );
                 rowCount = GetLayerRowCount();
 
                 for( int row=0;  row<rowCount;  ++row )
                 {
                     bool isLast;
                     wxCheckBox* cb = (wxCheckBox*) getLayerComp( row, COLUMN_COLOR_LYR_CB );
                     PCB_LAYER_ID    layer = ToLAYER_ID( getDecodedId( cb->GetId() ) );
                     cb->SetValue( visible );
 
                     isLast = row == rowCount-1;
 
                     OnLayerVisible( layer, visible, isLast );
 
                     if( isLast )
                         break;
                 }
                 break;
             }
 
         case ID_SHOW_ALL_COPPER_LAYERS:
         case ID_ALWAYS_SHOW_NO_COPPER_LAYERS_BUT_ACTIVE:
         case ID_SHOW_NO_COPPER_LAYERS_BUT_ACTIVE:
         case ID_SHOW_NO_COPPER_LAYERS:
         case ID_HIDE_ALL_NON_COPPER:
         case ID_SHOW_ALL_NON_COPPER:
             {
 
                 // Search the last copper layer row index:
                 int lastCu = -1;
                 rowCount = GetLayerRowCount();
                 for( int row = rowCount-1; row>=0; --row )
                 {
                     wxCheckBox* cb = (wxCheckBox*) getLayerComp( row, COLUMN_COLOR_LYR_CB );
                     PCB_LAYER_ID    layer = ToLAYER_ID( getDecodedId( cb->GetId() ) );
 
                     if( IsCopperLayer( layer ) )
                     {
                         lastCu = row;
                         break;
                     }
                 }
 
                 // Enable/disable the copper layers visibility:
                 int startrow = 0;
 
                 if(     ( menuId == ID_SHOW_ALL_NON_COPPER ) ||
                         ( menuId == ID_HIDE_ALL_NON_COPPER ) )
                 {
                     startrow = lastCu + 1;
                 }
 
                 for( int row = startrow;  row<rowCount;  ++row )
                 {
                     wxCheckBox* cb = (wxCheckBox*) getLayerComp( row, COLUMN_COLOR_LYR_CB );
                     PCB_LAYER_ID    layer = ToLAYER_ID( getDecodedId( cb->GetId() ) );
 
                     visible = ( ( menuId == ID_SHOW_ALL_COPPER_LAYERS ) || ( menuId == ID_SHOW_ALL_NON_COPPER ) );
 
                     if( force_active_layer_visible && (layer == myframe->GetActiveLayer() ) )
                         visible = true;
 
                     cb->SetValue( visible );
 
                     bool isLastLayer = (row == lastCu);
 
                     if(     ( menuId == ID_SHOW_ALL_NON_COPPER ) ||
                             ( menuId == ID_HIDE_ALL_NON_COPPER ) )
                     {
                         isLastLayer = false;
                     }
                     OnLayerVisible( layer, visible, isLastLayer );
 
                     if( isLastLayer )
                         break;
                 }
                 break;
             }
 
         case ID_SHOW_ALL_FRONT:
             {
                 visible = false;
                 rowCount = GetLayerRowCount();
 
                 for( int row=0;  row<rowCount;  ++row )
                 {
                     bool isLast;
                     wxCheckBox* cb = (wxCheckBox*) getLayerComp( row, COLUMN_COLOR_LYR_CB );
                     PCB_LAYER_ID    layer = ToLAYER_ID( getDecodedId( cb->GetId() ) );
                     isLast = ( row == rowCount-1 );
 
                     if(  layer == F_Paste || layer == F_SilkS ||
                          layer == F_Mask  || layer == F_Cu ||
                          layer == F_Fab || layer == F_CrtYd  || layer == Edge_Cuts )
                     {
                         visible = true;
                     }
                     else
                     {
                         visible = false;
                     }
 
                     cb->SetValue( visible );
                     OnLayerVisible( layer, visible, isLast );
 
                     if( isLast )
                         break;
                 }
                 break;
             }
         case ID_SHOW_ALL_BACK:
             {
                 visible = false;
                 rowCount = GetLayerRowCount();
 
                 for( int row=0;  row<rowCount;  ++row )
                 {
                     bool isLast;
                     wxCheckBox* cb = (wxCheckBox*) getLayerComp( row, COLUMN_COLOR_LYR_CB );
                     PCB_LAYER_ID    layer = ToLAYER_ID( getDecodedId( cb->GetId() ) );
                     isLast = ( row == rowCount-1 );
 
                     if( layer == B_Paste || layer == B_SilkS ||
                         layer == B_Mask  || layer == B_Cu ||
                         layer == B_Fab || layer == B_CrtYd || layer == Edge_Cuts )
                     {
                         visible = true;
                     }
                     else
                     {
                         visible = false;
                     }
 
                     cb->SetValue( visible );
                     OnLayerVisible( layer, visible, isLast );
 
                     if( isLast )
                         break;
                 }
                 break;
             }
     }
 }

void LAYER_WIDGET::OnRenderCheckBox ( wxCommandEvent & event )

protectedinherited

Definition at line 172 of file layer_widget.cpp.

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

Referenced by LAYER_WIDGET::insertRenderRow().

 {
     wxCheckBox* eventSource = (wxCheckBox*) event.GetEventObject();
     LAYER_NUM id = getDecodedId( eventSource->GetId() );
     OnRenderEnable( id, eventSource->IsChecked() );
     passOnFocus();
 }

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

aId	is the same id that was established in a Rendering row via the AddRenderRow() function.
aColor	is the new color

Implements LAYER_WIDGET.

Definition at line 627 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_FRAME::GetGalCanvas(), KIGFX::VIEW::GetPainter(), KIGFX::PAINTER::GetSettings(), EDA_DRAW_PANEL_GAL::GetView(), KIGFX::RENDER_SETTINGS::ImportLegacyColors(), EDA_DRAW_FRAME::IsGalCanvasActive(), KIGFX::VIEW::MarkTargetDirty(), myframe, EDA_DRAW_PANEL_GAL::Refresh(), EDA_DRAW_PANEL::Refresh(), COLORS_DESIGN_SETTINGS::SetItemColor(), PCB_BASE_FRAME::Settings(), KIGFX::TARGET_NONCACHED, and KIGFX::VIEW::UpdateLayerColor().

 {
     wxASSERT( aId > GAL_LAYER_ID_START && aId < GAL_LAYER_ID_END );
 
     myframe->Settings().Colors().SetItemColor( static_cast<GAL_LAYER_ID>( aId ), aColor );
 
     EDA_DRAW_PANEL_GAL* galCanvas = myframe->GetGalCanvas();
 
     if( galCanvas && myframe->IsGalCanvasActive() )
     {
         KIGFX::VIEW* view = galCanvas->GetView();
         view->GetPainter()->GetSettings()->ImportLegacyColors( &myframe->Settings().Colors() );
         view->MarkTargetDirty( KIGFX::TARGET_NONCACHED );   // useful to update rastnest
         view->UpdateLayerColor( aId );
         galCanvas->Refresh();
     }
 
     myframe->GetCanvas()->Refresh();
 }

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

aId	is the same id that was established in a Rendering row via the AddRenderRow() function.
isEnabled	is the state of the checkbox, true if checked.

Implements LAYER_WIDGET.

Definition at line 648 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.

 {
     BOARD*  brd = myframe->GetBoard();
     wxASSERT( aId > GAL_LAYER_ID_START && aId < GAL_LAYER_ID_END );
 
     // The layer visibility status is saved in the board file so set the board modified
     // state so the user has the option to save the changes.
     if( brd->IsElementVisible( static_cast<GAL_LAYER_ID>( aId ) ) != isEnabled )
         myframe->OnModify();
 
     brd->SetElementVisibility( static_cast<GAL_LAYER_ID>( aId ), isEnabled );
 
     EDA_DRAW_PANEL_GAL* galCanvas = myframe->GetGalCanvas();
 
     if( galCanvas && myframe->IsGalCanvasActive() )
     {
         if( aId == LAYER_GRID )
         {
             galCanvas->GetGAL()->SetGridVisibility( myframe->IsGridVisible() );
             galCanvas->GetView()->MarkTargetDirty( KIGFX::TARGET_NONCACHED );
         }
         else if ( aId == LAYER_RATSNEST )
         {
             // don't touch the layers. ratsnest is enabled on per-item basis.
             galCanvas->GetView()->MarkTargetDirty( KIGFX::TARGET_NONCACHED );
             galCanvas->GetView()->SetLayerVisible( aId, true );
         }
         else
             galCanvas->GetView()->SetLayerVisible( aId, isEnabled );
 
         galCanvas->Refresh();
     }
 
     myframe->GetCanvas()->Refresh();
 }

void LAYER_WIDGET::OnRenderSwatchChanged ( wxCommandEvent & aEvent )

protectedinherited

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

Definition at line 157 of file layer_widget.cpp.

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

Referenced by LAYER_WIDGET::insertRenderRow().

 {
     auto eventSource = static_cast<COLOR_SWATCH*>( aEvent.GetEventObject() );
 
     COLOR4D newColor = eventSource->GetSwatchColor();
 
     LAYER_NUM id = getDecodedId( eventSource->GetId() );
 
     // tell the client code.
     OnRenderColorChange( id, newColor );
 
     passOnFocus();
 }

void PCB_LAYER_WIDGET::onRightDownLayers ( wxMouseEvent & event )

protected

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

Definition at line 165 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, KiBitmap(), and LAYER_WIDGET::passOnFocus().

Referenced by installRightLayerClickHandler(), and PCB_LAYER_WIDGET().

 {
     wxMenu          menu;
 
     // menu text is capitalized:
     // http://library.gnome.org/devel/hig-book/2.20/design-text-labels.html.en#layout-capitalization
     AddMenuItem( &menu, ID_SHOW_ALL_COPPER_LAYERS,
                  _( "Show All Copper Layers" ),
                  KiBitmap( select_layer_pair_xpm ) );
     AddMenuItem( &menu, ID_SHOW_NO_COPPER_LAYERS_BUT_ACTIVE,
                  _( "Hide All Copper Layers But Active" ),
                  KiBitmap( select_w_layer_xpm ) );
     AddMenuItem( &menu, ID_ALWAYS_SHOW_NO_COPPER_LAYERS_BUT_ACTIVE,
                  _( "Always Hide All Copper Layers But Active" ),
                  KiBitmap( select_w_layer_xpm ) );
     AddMenuItem( &menu, ID_SHOW_NO_COPPER_LAYERS,
                  _( "Hide All Copper Layers" ),
                  KiBitmap( show_no_copper_layers_xpm ) );
 
     menu.AppendSeparator();
 
     AddMenuItem( &menu, ID_SHOW_ALL_NON_COPPER,
                  _( "Show All Non Copper Layers" ),
                  KiBitmap( select_w_layer_xpm ) );
     AddMenuItem( &menu, ID_HIDE_ALL_NON_COPPER,
                  _( "Hide All Non Copper Layers" ),
                  KiBitmap( show_no_copper_layers_xpm ) );
 
     menu.AppendSeparator();
 
     AddMenuItem( &menu, ID_SHOW_NO_LAYERS, _( "Hide All Layers" ),
                  KiBitmap( show_no_layers_xpm ) );
     AddMenuItem( &menu, ID_SHOW_ALL_LAYERS, _( "Show All Layers" ),
                  KiBitmap( show_all_layers_xpm ) );
 
     menu.AppendSeparator();
 
     AddMenuItem( &menu, ID_SHOW_ALL_FRONT, _( "Show All Front Layers" ),
                  KiBitmap( show_no_layers_xpm ) );
 
     AddMenuItem( &menu, ID_SHOW_ALL_BACK, _( "Show All Back Layers" ),
                  KiBitmap( show_all_layers_xpm ) );
 
     PopupMenu( &menu );
 
     passOnFocus();
 }

void LAYER_WIDGET::OnTabChange ( wxNotebookEvent & event )

protectedinherited

Definition at line 181 of file layer_widget.cpp.

References LAYER_WIDGET::passOnFocus().

Referenced by LAYER_WIDGET::LAYER_WIDGET().

 {
 //    wxFocusEvent    event( wxEVT_SET_FOCUS );
 //    m_FocusOwner->AddPendingEvent( event );
 
     passOnFocus();      // does not work in this context, probably because we have receive control here too early.
 }

void LAYER_WIDGET::passOnFocus ( )

protectedinherited

Function passOnFocus gives away the keyboard focus up to the main parent window.

Definition at line 334 of file layer_widget.cpp.

References LAYER_WIDGET::m_FocusOwner.

Referenced by LAYER_WIDGET::OnLayerCheckBox(), LAYER_WIDGET::OnLayerSwatchChanged(), LAYER_WIDGET::OnLeftDownLayers(), LAYER_WIDGET::OnRenderCheckBox(), LAYER_WIDGET::OnRenderSwatchChanged(), GERBER_LAYER_WIDGET::onRightDownLayers(), onRightDownLayers(), LAYER_WIDGET::OnTabChange(), and LAYER_WIDGET::SelectLayerRow().

 {
     m_FocusOwner->SetFocus();
 }

void PCB_LAYER_WIDGET::ReFill ( )

Definition at line 452 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(), installRightLayerClickHandler(), isLayerAllowedInFpMode(), m_fp_editor_mode, Margin, myframe, and PCB_BASE_FRAME::Settings().

 {
     BOARD*  brd = myframe->GetBoard();
     LSET    enabled = brd->GetEnabledLayers();
 
     ClearLayerRows();
 
     wxString dsc;
 
     // show all coppers first, with front on top, back on bottom, then technical layers
     for( LSEQ cu_stack = enabled.CuStack(); cu_stack; ++cu_stack )
     {
         PCB_LAYER_ID layer = *cu_stack;
 
         switch( layer )
         {
         case F_Cu:
             dsc = _( "Front copper layer" );
             break;
 
         case B_Cu:
             dsc = _( "Back copper layer" );
             break;
 
         default:
             dsc = _( "Inner copper layer" );
             break;
         }
 
         AppendLayerRow( LAYER_WIDGET::ROW(
             brd->GetLayerName( layer ), layer, myframe->Settings().Colors().GetLayerColor( layer ),
             dsc, true ) );
 
         if( m_fp_editor_mode && !isLayerAllowedInFpMode( layer ) )
         {
             getLayerComp( GetLayerRowCount()-1, COLUMN_COLOR_LYRNAME )->Enable( false );
             getLayerComp( GetLayerRowCount()-1,
                           COLUMN_COLORBM )->SetToolTip( wxEmptyString );
         }
     }
 
 
     // technical layers are shown in this order:
     // Because they are static, wxGetTranslation must be explicitly
     // called for tooltips.
     static const struct {
         PCB_LAYER_ID    layerId;
         wxString    tooltip;
     } non_cu_seq[] = {
         { F_Adhes,          _( "Adhesive on board's front" ) },
         { B_Adhes,          _( "Adhesive on board's back" ) },
         { F_Paste,          _( "Solder paste on board's front" )  },
         { B_Paste,          _( "Solder paste on board's back" ) },
         { F_SilkS,          _( "Silkscreen on board's front" ) },
         { B_SilkS,          _( "Silkscreen on board's back" )  },
         { F_Mask,           _( "Solder mask on board's front" ) },
         { B_Mask,           _( "Solder mask on board's back" )  },
         { Dwgs_User,        _( "Explanatory drawings" )      },
         { Cmts_User,        _( "Explanatory comments" )         },
         { Eco1_User,        _( "User defined meaning" )         },
         { Eco2_User,        _( "User defined meaning" )         },
         { Edge_Cuts,        _( "Board's perimeter definition" ) },
         { Margin,           _( "Board's edge setback outline" ) },
         { F_CrtYd,          _( "Footprint courtyards on board's front" ) },
         { B_CrtYd,          _( "Footprint courtyards on board's back" ) },
         { F_Fab,            _( "Footprint assembly on board's front" ) },
         { B_Fab,            _( "Footprint assembly on board's back" ) }
     };
 
     for( unsigned i=0;  i<DIM( non_cu_seq );  ++i )
     {
         PCB_LAYER_ID layer = non_cu_seq[i].layerId;
 
         if( !enabled[layer] )
             continue;
 
         AppendLayerRow( LAYER_WIDGET::ROW(
             brd->GetLayerName( layer ), layer,  myframe->Settings().Colors().GetLayerColor( layer ),
             wxGetTranslation( non_cu_seq[i].tooltip ), true ) );
 
         if( m_fp_editor_mode && !isLayerAllowedInFpMode( layer ) )
         {
             getLayerComp( GetLayerRowCount()-1, COLUMN_COLOR_LYRNAME )->Enable( false );
             getLayerComp( GetLayerRowCount()-1,
                           COLUMN_COLORBM )->SetToolTip( wxEmptyString );
         }
     }
 
     installRightLayerClickHandler();
 }

void PCB_LAYER_WIDGET::ReFillRender ( )

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

Definition at line 383 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().

 {
     BOARD* board = myframe->GetBoard();
     ClearRenderRows();
 
     // Add "Render" tab rows to LAYER_WIDGET, after setting color and checkbox state.
     // Because s_render_rows is created static, we must explicitly call
     // wxGetTranslation for texts which are internationalized (tool tips
     // and item names)
     for( unsigned row=0;  row<DIM(s_render_rows);  ++row )
     {
         LAYER_WIDGET::ROW renderRow = s_render_rows[row];
 
         if( m_fp_editor_mode && !isAllowedInFpMode( renderRow.id ) )
             continue;
 
         renderRow.tooltip = wxGetTranslation( s_render_rows[row].tooltip );
         renderRow.rowName = wxGetTranslation( s_render_rows[row].rowName );
 
         if( renderRow.color != COLOR4D::UNSPECIFIED )       // does this row show a color?
         {
             // this window frame must have an established BOARD, i.e. after SetBoard()
             renderRow.color = myframe->Settings().Colors().GetItemColor( static_cast<GAL_LAYER_ID>( renderRow.id ) );
         }
 
         renderRow.state = board->IsElementVisible( static_cast<GAL_LAYER_ID>( renderRow.id ) );
 
         AppendRenderRow( renderRow );
     }
 }

void LAYER_WIDGET::SelectLayer ( LAYER_NUM aLayer )

inherited

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

Definition at line 555 of file layer_widget.cpp.

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

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

 {
     int row = findLayerRow( aLayer );
     SelectLayerRow( 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 526 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().

 {
     // enable the layer tab at index 0
     m_notebook->SetSelection( 0 );
 
     INDICATOR_ICON* oldIndicator = (INDICATOR_ICON*) getLayerComp( m_CurrentRow, 0 );
     if( oldIndicator )
         oldIndicator->SetIndicatorState( ROW_ICON_PROVIDER::STATE::OFF );
 
     INDICATOR_ICON* newIndicator = (INDICATOR_ICON*) getLayerComp( aRow, 0 );
     if( newIndicator )
     {
         newIndicator->SetIndicatorState( ROW_ICON_PROVIDER::STATE::ON );
 
         // Make sure the desired layer row is visible.
         // It seems that as of 2.8.2, setting the focus does this.
         // I don't expect the scrolling to be needed at all because
         // the minimum window size may end up being established so that the
         // scroll bars will not be visible.
         getLayerComp( aRow, 1 )->SetFocus();
     }
 
     m_CurrentRow = aRow;
 
     // give the focus back to the app.
     passOnFocus();
 }

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

inherited

Function SetLayerColor changes the color of aLayer.

Definition at line 597 of file layer_widget.cpp.

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

 {
     int row = findLayerRow( aLayer );
     if( row >= 0 )
     {
         int col = 1;    // bitmap button is column 1
         auto bmb = static_cast<COLOR_SWATCH*>( getLayerComp( row, col ) );
         wxASSERT( bmb );
 
         bmb->SetSwatchColor( aColor, false );
     }
 }

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

References LAYER_WIDGET::m_notebook.

Referenced by PCB_LAYER_WIDGET().

 {
     m_notebook->SetPageText( 0, _( "Layer" ) );
     m_notebook->SetPageText( 1, _( "Render" ) );
 }

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 572 of file layer_widget.cpp.

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

Referenced by SyncLayerVisibilities().

 {
     int row = findLayerRow( aLayer );
     if( row >= 0 )
     {
         wxCheckBox* cb = (wxCheckBox*) getLayerComp( row, COLUMN_COLOR_LYR_CB );
         wxASSERT( cb );
         cb->SetValue( isVisible );      // does not fire an event
     }
 }

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

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

Definition at line 628 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().

 {
     int row = findRenderRow( aId );
 
     if( row >= 0 )
     {
         int col = 1;    // checkbox is column 1
         wxCheckBox* cb = (wxCheckBox*) getRenderComp( row, col );
         wxASSERT( cb );
         cb->SetValue( isSet );  // does not fire an event
     }
 }

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

 {
     BOARD*  board = myframe->GetBoard();
     int     count = GetLayerRowCount();
 
     for( int row=0;  row<count;  ++row )
     {
         // this utilizes more implementation knowledge than ideal, eventually
         // add member ROW getRow() or similar to base LAYER_WIDGET.
 
         wxWindow* w = getLayerComp( row, COLUMN_ICON_ACTIVE );
 
         PCB_LAYER_ID layerId = ToLAYER_ID( getDecodedId( w->GetId() ) );
 
         // this does not fire a UI event
         SetLayerVisible( layerId, board->IsLayerVisible( layerId ) );
     }
 }

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

 {
     BOARD*  board = myframe->GetBoard();
 
     for( unsigned row=0;  row<DIM(s_render_rows);  ++row )
     {
         int rowId = s_render_rows[row].id;
 
         if( m_fp_editor_mode && !isAllowedInFpMode( rowId ) )
             continue;
 
         // this does not fire a UI event
         SetRenderState( rowId, board->IsElementVisible( static_cast<GAL_LAYER_ID>( rowId ) ) );
     }
 }

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

 {
     int rowCount = GetLayerRowCount();
 
     for( int row = 0; row < rowCount ; row++ )
     {
         INDICATOR_ICON* indicator = (INDICATOR_ICON*) getLayerComp( row, COLUMN_ICON_ACTIVE );
 
         if( indicator )
         {
             auto state = ( row == m_CurrentRow ) ? ROW_ICON_PROVIDER::STATE::ON
                                                  : ROW_ICON_PROVIDER::STATE::OFF;
             indicator->SetIndicatorState( state );
         }
     }
 }

void LAYER_WIDGET::UpdateLayouts ( )

inherited

Definition at line 658 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().

 {
     m_LayersFlexGridSizer->Layout();
     m_RenderFlexGridSizer->Layout();
     m_LayerPanel->Layout();
     m_RenderingPanel->Layout();
     FitInside();
 }

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

Referenced by LAYER_WIDGET::insertLayerRow().

129 { return false; }

Member Data Documentation

const wxEventType LAYER_WIDGET::EVT_LAYER_COLOR_CHANGE = wxNewEventType()

staticinherited

Definition at line 105 of file layer_widget.h.

Referenced by LAYER_WIDGET::OnLayerSwatchChanged().

bool PCB_LAYER_WIDGET::m_alwaysShowActiveCopperLayer

protected

Definition at line 114 of file class_pcb_layer_widget.h.

Referenced by OnLayerSelect(), OnLayerSelected(), onPopupSelection(), and PCB_LAYER_WIDGET().

int LAYER_WIDGET::m_CurrentRow

protectedinherited

selected row of layer list

Definition at line 118 of file layer_widget.h.

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

wxWindow* LAYER_WIDGET::m_FocusOwner

protectedinherited

Definition at line 117 of file layer_widget.h.

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

bool PCB_LAYER_WIDGET::m_fp_editor_mode

protected

Definition at line 116 of file class_pcb_layer_widget.h.

Referenced by OnLayerSelect(), PCB_LAYER_WIDGET(), ReFill(), ReFillRender(), and SyncRenderStates().

wxPanel* LAYER_WIDGET::m_LayerPanel

protectedinherited

Definition at line 110 of file layer_widget.h.

Referenced by LAYER_WIDGET::GetBestSize(), LAYER_WIDGET::LAYER_WIDGET(), and LAYER_WIDGET::UpdateLayouts().

wxScrolledWindow* LAYER_WIDGET::m_LayerScrolledWindow

protectedinherited

Definition at line 111 of file layer_widget.h.

Referenced by GERBER_LAYER_WIDGET::GERBER_LAYER_WIDGET(), LAYER_WIDGET::insertLayerRow(), LAYER_WIDGET::LAYER_WIDGET(), LAYER_WIDGET::OnLeftDownLayers(), and PCB_LAYER_WIDGET().

wxFlexGridSizer* LAYER_WIDGET::m_LayersFlexGridSizer

protectedinherited

Definition at line 112 of file layer_widget.h.

Referenced by LAYER_WIDGET::ClearLayerRows(), LAYER_WIDGET::GetBestSize(), LAYER_WIDGET::getLayerComp(), LAYER_WIDGET::GetLayerRowCount(), LAYER_WIDGET::insertLayerRow(), LAYER_WIDGET::LAYER_WIDGET(), LAYER_WIDGET::OnLeftDownLayers(), and LAYER_WIDGET::UpdateLayouts().

wxAuiNotebook* LAYER_WIDGET::m_notebook

protectedinherited

Definition at line 109 of file layer_widget.h.

Referenced by LAYER_WIDGET::LAYER_WIDGET(), LAYER_WIDGET::SelectLayerRow(), SetLayersManagerTabsText(), and GERBER_LAYER_WIDGET::SetLayersManagerTabsText().

int LAYER_WIDGET::m_PointSize

protectedinherited

Definition at line 119 of file layer_widget.h.

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

wxFlexGridSizer* LAYER_WIDGET::m_RenderFlexGridSizer

protectedinherited

Definition at line 115 of file layer_widget.h.

Referenced by LAYER_WIDGET::ClearRenderRows(), LAYER_WIDGET::GetBestSize(), LAYER_WIDGET::getRenderComp(), LAYER_WIDGET::GetRenderRowCount(), LAYER_WIDGET::insertRenderRow(), LAYER_WIDGET::LAYER_WIDGET(), and LAYER_WIDGET::UpdateLayouts().

wxPanel* LAYER_WIDGET::m_RenderingPanel

protectedinherited

Definition at line 113 of file layer_widget.h.

Referenced by LAYER_WIDGET::GetBestSize(), LAYER_WIDGET::LAYER_WIDGET(), and LAYER_WIDGET::UpdateLayouts().

wxScrolledWindow* LAYER_WIDGET::m_RenderScrolledWindow

protectedinherited

Definition at line 114 of file layer_widget.h.

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

PCB_BASE_FRAME* PCB_LAYER_WIDGET::myframe

protected

Definition at line 118 of file class_pcb_layer_widget.h.

Referenced by AreArbitraryColorsAllowed(), OnLayerColorChange(), OnLayerSelect(), OnLayerVisible(), onPopupSelection(), OnRenderColorChange(), OnRenderEnable(), ReFill(), ReFillRender(), SyncLayerVisibilities(), and SyncRenderStates().

const LAYER_WIDGET::ROW PCB_LAYER_WIDGET::s_render_rows

staticprotected

Initial value:

= {
#define RR
         
    RR( _( "Through Via" ),     LAYER_VIA_THROUGH,    WHITE,      _( "Show through vias" ) ),
    RR( _( "Bl/Buried Via" ),   LAYER_VIA_BBLIND,     WHITE,      _( "Show blind or buried vias" )  ),
    RR( _( "Micro Via" ),       LAYER_VIA_MICROVIA,   WHITE,      _( "Show micro vias") ),
    RR( _( "Non Plated Holes" ),LAYER_NON_PLATED,     WHITE,      _( "Show non plated holes in specific color") ),
    RR( _( "Ratsnest" ),        LAYER_RATSNEST,       WHITE,      _( "Show unconnected nets as a ratsnest") ),
    RR( _( "Pads Front" ),      LAYER_PAD_FR,         WHITE,      _( "Show footprint pads on board's front" ) ),
    RR( _( "Pads Back" ),       LAYER_PAD_BK,         WHITE,      _( "Show footprint pads on board's back" ) ),
    RR( _( "Text Front" ),      LAYER_MOD_TEXT_FR,        COLOR4D::UNSPECIFIED,  _( "Show footprint text on board's front" ) ),
    RR( _( "Text Back" ),       LAYER_MOD_TEXT_BK,        COLOR4D::UNSPECIFIED,  _( "Show footprint text on board's back" ) ),
    RR( _( "Hidden Text" ),     LAYER_MOD_TEXT_INVISIBLE, WHITE,                 _( "Show footprint text marked as invisible" ) ),
    RR( _( "Anchors" ),         LAYER_ANCHOR,         WHITE,                _( "Show footprint and text origins as a cross" ) ),
    RR( _( "Grid" ),            LAYER_GRID,           WHITE,                _( "Show the (x,y) grid dots" ) ),
    RR( _( "No-Connects" ),     LAYER_NO_CONNECTS,    COLOR4D::UNSPECIFIED, _( "Show a marker on pads which have no net connected" ) ),
    RR( _( "Footprints Front" ),LAYER_MOD_FR,         COLOR4D::UNSPECIFIED, _( "Show footprints that are on board's front") ),
    RR( _( "Footprints Back" ), LAYER_MOD_BK,         COLOR4D::UNSPECIFIED, _( "Show footprints that are on board's back") ),
    RR( _( "Values" ),          LAYER_MOD_VALUES,     COLOR4D::UNSPECIFIED, _( "Show footprint's values") ),
    RR( _( "References" ),      LAYER_MOD_REFERENCES, COLOR4D::UNSPECIFIED, _( "Show footprint's references") ),
    RR( _( "Worksheet" ),       LAYER_WORKSHEET,      DARKRED,              _( "Show worksheet") ),
    RR( _( "Cursor" ),          LAYER_CURSOR,         WHITE,                _( "PCB Cursor" ), true, false ),
    RR( _( "Aux items" ),       LAYER_AUX_ITEMS,      WHITE,                _( "Auxillary items (rulers, assistants, axes, etc.)" ), true, false ),
    RR( _( "Background" ),      LAYER_PCB_BACKGROUND, BLACK,                _( "PCB Background" ), true, false )
}

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

Definition at line 113 of file class_pcb_layer_widget.h.

Referenced by ReFillRender(), and SyncRenderStates().

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

Public Member Functions

Static Public Attributes

Protected Types

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation