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

Inheritance diagram for PCB_LAYER_WIDGET:

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

Static Public Attributes
static const wxEventType	EVT_LAYER_COLOR_CHANGE = wxNewEventType()

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

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

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

Protected Attributes
bool	m_alwaysShowActiveCopperLayer
bool	m_fp_editor_mode
PCB_BASE_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
ROW_ICON_PROVIDER *	m_IconProvider

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

Detailed Description

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

Member Enumeration Documentation

POPUP_ID

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 125 of file pcb_layer_widget.h.

    {
        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
    };

Constructor & Destructor Documentation

PCB_LAYER_WIDGET()

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

Constructor.

Parameters

aParent	is the parent window
aFocusOwner	is the window that should be sent the focus after
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 102 of file pcb_layer_widget.cpp.

                                                         :
        LAYER_WIDGET( aParent, aFocusOwner ),
        myframe( aParent )
{
    m_alwaysShowActiveCopperLayer = false;
    m_fp_editor_mode = aFpEditorMode;

    // 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 );
}

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

Member Function Documentation

AddRightClickMenuItems()

void PCB_LAYER_WIDGET::AddRightClickMenuItems

(

wxMenu &

menu

)

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

Definition at line 151 of file pcb_layer_widget.cpp.

{
    // 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 ) );
}

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

AppendLayerRow()

void LAYER_WIDGET::AppendLayerRow ( const ROW &  aRow )

inherited

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

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

Definition at line 609 of file layer_widget.cpp.

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

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

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

AppendLayerRows()

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

inlineinherited

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

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

Definition at line 304 of file layer_widget.h.

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

        UpdateLayouts();
    }

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

AppendRenderRow()

void LAYER_WIDGET::AppendRenderRow ( const ROW &  aRow )

inherited

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

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

Definition at line 622 of file layer_widget.cpp.

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

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

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

AppendRenderRows()

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

inlineinherited

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

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

Definition at line 330 of file layer_widget.h.

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

        UpdateLayouts();
    }

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

Referenced by GERBER_LAYER_WIDGET::ReFillRender().

ClearLayerRows()

void LAYER_WIDGET::ClearLayerRows ( )

inherited

Function ClearLayerRows empties out the layer rows.

Definition at line 616 of file layer_widget.cpp.

{
    m_LayersFlexGridSizer->Clear( true );
}

References LAYER_WIDGET::m_LayersFlexGridSizer.

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

ClearRenderRows()

void LAYER_WIDGET::ClearRenderRows ( )

inherited

Function ClearRenderRows empties out the render rows.

Definition at line 629 of file layer_widget.cpp.

{
    m_RenderFlexGridSizer->Clear( true );
}

References LAYER_WIDGET::m_RenderFlexGridSizer.

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

encodeId()

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

staticprotectedinherited

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

See also

getDecodedId()

Definition at line 63 of file layer_widget.cpp.

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

References LYR_COLUMN_COUNT.

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

findLayerRow()

int LAYER_WIDGET::findLayerRow ( LAYER_NUM  aLayer ) const

protectedinherited

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

Definition at line 265 of file layer_widget.cpp.

{
    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;
}

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

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

findRenderRow()

int LAYER_WIDGET::findRenderRow ( int  aId ) const

protectedinherited

Definition at line 294 of file layer_widget.cpp.

{
    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;
}

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

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

getBackgroundLayerColor()

COLOR4D PCB_LAYER_WIDGET::getBackgroundLayerColor ( )

overrideprotectedvirtual

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

Reimplemented from LAYER_WIDGET.

Definition at line 127 of file pcb_layer_widget.cpp.

{
    return myframe->Settings().Colors().GetLayerColor( LAYER_PCB_BACKGROUND );
}

References PCB_GENERAL_SETTINGS::Colors(), COLORS_DESIGN_SETTINGS::GetLayerColor(), LAYER_PCB_BACKGROUND, myframe, and PCB_BASE_FRAME::Settings().

GetBestSize()

wxSize LAYER_WIDGET::GetBestSize ( ) const

inherited

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

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

Definition at line 540 of file layer_widget.cpp.

{
    // 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 += 15;


    /* 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 += 15;

    // 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;
}

References i, 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(), FOOTPRINT_EDIT_FRAME::ReFillLayerWidget(), and GERBVIEW_FRAME::ReFillLayerWidget().

getDecodedId()

LAYER_NUM LAYER_WIDGET::getDecodedId ( int  aControlId )

staticprotectedinherited

Function getDecodedId decodes aControlId to original un-encoded value.

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

Definition at line 70 of file layer_widget.cpp.

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

References LYR_COLUMN_COUNT.

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

GetLayerColor()

COLOR4D LAYER_WIDGET::GetLayerColor ( LAYER_NUM  aLayer ) const

inherited

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

Definition at line 732 of file layer_widget.cpp.

{
    int row = findLayerRow( aLayer );
    if( row >= 0 )
    {
        int col = 1;    // bitmap button is column 1
        auto swatch = static_cast<COLOR_SWATCH*>( getLayerComp( row, col ) );
        wxASSERT( swatch );

        return swatch->GetSwatchColor();
    }

    return COLOR4D::UNSPECIFIED;   // it's caller fault, gave me a bad layer
}

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

getLayerComp()

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

protectedinherited

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

Parameters

aRow	is the row index
aColumn	is the column

Returns

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

Definition at line 254 of file layer_widget.cpp.

{
    unsigned ndx = aRow * LYR_COLUMN_COUNT + aColumn;

    if( ndx < m_LayersFlexGridSizer->GetChildren().GetCount() )
        return m_LayersFlexGridSizer->GetChildren()[ndx]->GetWindow();

    return NULL;
}

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(), LAYER_WIDGET::OnRenderSwatchChanged(), ReFill(), LAYER_WIDGET::SelectLayerRow(), LAYER_WIDGET::setLayerCheckbox(), LAYER_WIDGET::SetLayerColor(), SyncLayerAlphaIndicators(), SyncLayerVisibilities(), and LAYER_WIDGET::UpdateLayerIcons().

GetLayerRowCount()

int LAYER_WIDGET::GetLayerRowCount ( ) const

inherited

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

Definition at line 595 of file layer_widget.cpp.

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

References LYR_COLUMN_COUNT, and LAYER_WIDGET::m_LayersFlexGridSizer.

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

getRenderComp()

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

protectedinherited

Definition at line 283 of file layer_widget.cpp.

{
    int ndx = aRow * RND_COLUMN_COUNT + aColumn;

    if( (unsigned) ndx < m_RenderFlexGridSizer->GetChildren().GetCount() )
        return m_RenderFlexGridSizer->GetChildren()[ndx]->GetWindow();

    return NULL;
}

References LAYER_WIDGET::m_RenderFlexGridSizer, and RND_COLUMN_COUNT.

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

GetRenderRowCount()

int LAYER_WIDGET::GetRenderRowCount ( ) const

inherited

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

Definition at line 602 of file layer_widget.cpp.

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

References LAYER_WIDGET::m_RenderFlexGridSizer, and RND_COLUMN_COUNT.

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

GetRenderState()

bool LAYER_WIDGET::GetRenderState ( int  aId )

inherited

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

Returns

bool - true if checked, else false.

Definition at line 762 of file layer_widget.cpp.

{
    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
}

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

GetSelectedLayer()

LAYER_NUM LAYER_WIDGET::GetSelectedLayer ( )

inherited

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

Definition at line 676 of file layer_widget.cpp.

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

    return UNDEFINED_LAYER;
}

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

insertLayerRow()

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

protectedinherited

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

Definition at line 312 of file layer_widget.cpp.

{
    wxASSERT( aRow >= 0 );

    int         col;
    int         index = aRow * LYR_COLUMN_COUNT;
    const int   flags = wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT;

    // column 0
    col = COLUMN_ICON_ACTIVE;
    auto sbm = new INDICATOR_ICON( m_LayerScrolledWindow, *m_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 ),
                                 getBackgroundLayerColor(), aSpec.defaultColor );
    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 );

    // column 4 (COLUMN_ALPHA_INDICATOR)
    col = COLUMN_ALPHA_INDICATOR;
    sbm = new INDICATOR_ICON( m_LayerScrolledWindow, *m_IconProvider,
                              ROW_ICON_PROVIDER::STATE::OFF, wxID_ANY );
    m_LayersFlexGridSizer->wxSizer::Insert( index+col, sbm, 0, flags );

    // Bind right click eventhandler to all columns
    wxString layerName( aSpec.rowName );

    sbm->Bind( wxEVT_RIGHT_DOWN, [this, bmb, layerName] ( wxMouseEvent& aEvt ) {
        OnRightDownLayer( aEvt, bmb, layerName );
    } );
    bmb->Bind( wxEVT_RIGHT_DOWN, [this, bmb, layerName] ( wxMouseEvent& aEvt ) {
        OnRightDownLayer( aEvt, bmb, layerName );
    } );
    cb->Bind( wxEVT_RIGHT_DOWN, [this, bmb, layerName] ( wxMouseEvent& aEvt ) {
        OnRightDownLayer( aEvt, bmb, layerName );
    } );
    st->Bind( wxEVT_RIGHT_DOWN, [this, bmb, layerName] ( wxMouseEvent& aEvt ) {
        OnRightDownLayer( aEvt, bmb, layerName );
    } );
}

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

Referenced by LAYER_WIDGET::AppendLayerRow().

insertRenderRow()

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

protectedinherited

Definition at line 377 of file layer_widget.cpp.

{
    wxASSERT( aRow >= 0 );

    int         col;
    int         index = aRow * RND_COLUMN_COUNT;
    const int   flags = wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT;

    wxString renderName( aSpec.rowName );
    wxCheckBox* cb = nullptr;

    // column 1
    if( !aSpec.spacer )
    {
        col = 1;
        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 );
    }

    // column 0
    col = 0;
    if( aSpec.color != COLOR4D::UNSPECIFIED )
    {
        auto bmb = new COLOR_SWATCH( m_RenderScrolledWindow, aSpec.color, encodeId( col, aSpec.id ),
                                     getBackgroundLayerColor(), aSpec.defaultColor );
        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 );

        bmb->Bind( wxEVT_RIGHT_DOWN, [this, bmb, renderName] ( wxMouseEvent& aEvt ) {
            OnRightDownRender( aEvt, bmb, renderName );
        } );
        cb->Bind( wxEVT_RIGHT_DOWN, [this, bmb, renderName] ( wxMouseEvent& aEvt ) {
            OnRightDownRender( aEvt, bmb, renderName );
        } );

        // 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 );
    }

    // Items have to be inserted in order
    col = 1;

    if( aSpec.spacer )
    {
        wxPanel* invisible = new wxPanel( m_RenderScrolledWindow, wxID_ANY );
        m_RenderFlexGridSizer->wxSizer::Insert( index+col, invisible, 0, flags );
    }
    else
    {
        m_RenderFlexGridSizer->wxSizer::Insert( index+col, cb, 0, flags );
    }
}

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

Referenced by LAYER_WIDGET::AppendRenderRow().

installRightLayerClickHandler()

void PCB_LAYER_WIDGET::installRightLayerClickHandler ( )

protected

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

isAllowedInFpMode()

bool PCB_LAYER_WIDGET::isAllowedInFpMode ( int  aId )

protected

Function isAllowedInFpMode.

Returns

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

Definition at line 133 of file pcb_layer_widget.cpp.

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

    return false;
}

References arrayDim(), and s_allowed_in_FpEditor.

Referenced by ReFillRender().

isLayerAllowedInFpMode()

bool PCB_LAYER_WIDGET::isLayerAllowedInFpMode ( PCB_LAYER_ID  aLayer )

protected

Function isLayerAllowedInFpMode.

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

Parameters

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 143 of file pcb_layer_widget.cpp.

{
    static LSET allowed = LSET::AllTechMask();
    allowed.set( F_Cu ).set( B_Cu );
    return allowed.test( aLayer );
}

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

IsLayerVisible()

bool LAYER_WIDGET::IsLayerVisible ( LAYER_NUM  aLayer )

inherited

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

Definition at line 705 of file layer_widget.cpp.

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

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

Referenced by GERBVIEW_FRAME::IsLayerVisible().

OnLayerCheckBox()

void LAYER_WIDGET::OnLayerCheckBox ( wxCommandEvent &  event )

protectedinherited

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

Definition at line 168 of file layer_widget.cpp.

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

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

Referenced by LAYER_WIDGET::insertLayerRow().

OnLayerColorChange()

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

overridevirtual

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

Derived classes will handle this accordingly.

Parameters

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

Implements LAYER_WIDGET.

Definition at line 575 of file pcb_layer_widget.cpp.

{
    myframe->Settings().Colors().SetLayerColor( aLayer, aColor );

    KIGFX::VIEW* view = myframe->GetCanvas()->GetView();
    view->GetPainter()->GetSettings()->ImportLegacyColors( &myframe->Settings().Colors() );
    view->UpdateLayerColor( aLayer );
    view->UpdateLayerColor( GetNetnameLayer( aLayer ) );

    myframe->ReCreateHToolbar();

    myframe->GetCanvas()->Refresh();

    if( aLayer == LAYER_PCB_BACKGROUND )
        myframe->SetDrawBgColor( aColor );
}

References PCB_GENERAL_SETTINGS::Colors(), PCB_BASE_FRAME::GetCanvas(), GetNetnameLayer(), KIGFX::VIEW::GetPainter(), KIGFX::PAINTER::GetSettings(), PCB_DRAW_PANEL_GAL::GetView(), KIGFX::RENDER_SETTINGS::ImportLegacyColors(), LAYER_PCB_BACKGROUND, myframe, EDA_DRAW_FRAME::ReCreateHToolbar(), EDA_DRAW_PANEL_GAL::Refresh(), PCB_BASE_FRAME::SetDrawBgColor(), COLORS_DESIGN_SETTINGS::SetLayerColor(), PCB_BASE_FRAME::Settings(), and KIGFX::VIEW::UpdateLayerColor().

OnLayerRightClick()

void PCB_LAYER_WIDGET::OnLayerRightClick ( wxMenu &  aMenu )

overridevirtual

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

Parameters

aMenu

is 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 654 of file pcb_layer_widget.cpp.

{
    AddRightClickMenuItems( aMenu );
}

References AddRightClickMenuItems().

OnLayerSelect()

bool PCB_LAYER_WIDGET::OnLayerSelect ( int  aLayer )

overridevirtual

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

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

Parameters

aLayer

is the board layer to select

Implements LAYER_WIDGET.

Definition at line 593 of file pcb_layer_widget.cpp.

{
    // 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 && LSET::ForbiddenFootprintLayers().test( layer ) )
        return false;

    myframe->SetActiveLayer( layer );
    PCB_DISPLAY_OPTIONS* displ_opts = (PCB_DISPLAY_OPTIONS*)myframe->GetDisplayOptions();

    if( m_alwaysShowActiveCopperLayer )
        OnLayerSelected();
    else if( displ_opts->m_ContrastModeDisplay )
        myframe->GetCanvas()->Refresh();

    return true;
}

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

OnLayerSelected()

bool PCB_LAYER_WIDGET::OnLayerSelected

(

)

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

Returns

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

Definition at line 614 of file pcb_layer_widget.cpp.

{
    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;
}

References ID_ALWAYS_SHOW_NO_COPPER_LAYERS_BUT_ACTIVE, m_alwaysShowActiveCopperLayer, and onPopupSelection().

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

OnLayerSwatchChanged()

void LAYER_WIDGET::OnLayerSwatchChanged ( wxCommandEvent &  aEvent )

protectedinherited

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

Definition at line 149 of file layer_widget.cpp.

{
    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();
}

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

Referenced by LAYER_WIDGET::insertLayerRow().

OnLayerVisible()

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

overridevirtual

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

Parameters

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 629 of file pcb_layer_widget.cpp.

{
    BOARD* brd = myframe->GetBoard();

    LSET visibleLayers = brd->GetVisibleLayers();

    if( visibleLayers.test( aLayer ) != isVisible )
    {
        visibleLayers.set( aLayer, isVisible );

        brd->SetVisibleLayers( visibleLayers );

        // Layer visibility is not stored in .kicad_mod files
        if( !m_fp_editor_mode )
            myframe->OnModify();

        if( myframe->GetCanvas() )
            myframe->GetCanvas()->GetView()->SetLayerVisible( aLayer, isVisible );
    }

    if( isFinal )
        myframe->GetCanvas()->Refresh();
}

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

Referenced by onPopupSelection().

OnLeftDownLayers()

void LAYER_WIDGET::OnLeftDownLayers ( wxMouseEvent &  event )

protectedinherited

Definition at line 77 of file layer_widget.cpp.

{
    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();
}

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

Referenced by LAYER_WIDGET::insertLayerRow().

onPopupSelection()

void PCB_LAYER_WIDGET::onPopupSelection ( wxCommandEvent &  event )

protected

Definition at line 205 of file pcb_layer_widget.cpp.

{
    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;
            }
    }
}

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

Referenced by OnLayerSelected(), and PCB_LAYER_WIDGET().

OnRenderCheckBox()

void LAYER_WIDGET::OnRenderCheckBox ( wxCommandEvent &  event )

protectedinherited

Definition at line 236 of file layer_widget.cpp.

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

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

Referenced by LAYER_WIDGET::insertRenderRow().

OnRenderColorChange()

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

overridevirtual

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

Parameters

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 660 of file pcb_layer_widget.cpp.

{
    wxASSERT( aId > GAL_LAYER_ID_START && aId < GAL_LAYER_ID_END );

    myframe->Settings().Colors().SetItemColor( static_cast<GAL_LAYER_ID>( aId ), aColor );

    if( aId == LAYER_GRID )
        myframe->GetCanvas()->GetGAL()->SetGridColor( aColor );

    KIGFX::VIEW* view = myframe->GetCanvas()->GetView();
    view->GetPainter()->GetSettings()->ImportLegacyColors( &myframe->Settings().Colors() );
    view->MarkTargetDirty( KIGFX::TARGET_NONCACHED );   // useful to update rastnest
    view->UpdateLayerColor( aId );

    // plated-through-holes don't have their own color; they use the background color
    if( aId == LAYER_PCB_BACKGROUND )
        view->UpdateLayerColor( LAYER_PADS_PLATEDHOLES );

    myframe->ReCreateHToolbar();
    myframe->GetCanvas()->ForceRefresh();
    myframe->GetCanvas()->Refresh();
}

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

OnRenderEnable()

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

overridevirtual

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

Parameters

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 684 of file pcb_layer_widget.cpp.

{
    BOARD*  brd = myframe->GetBoard();
    wxASSERT( aId > GAL_LAYER_ID_START && aId < GAL_LAYER_ID_END );

    if( myframe->IsType( FRAME_PCB_EDITOR ) )
    {
        // 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 );

    if( aId == LAYER_GRID )
    {
        myframe->GetCanvas()->GetGAL()->SetGridVisibility( myframe->IsGridVisible() );
        myframe->GetCanvas()->GetView()->MarkTargetDirty( KIGFX::TARGET_NONCACHED );
    }
    else if( aId == LAYER_RATSNEST )
    {
        // don't touch the layers. ratsnest is enabled on per-item basis.
        myframe->GetCanvas()->GetView()->MarkTargetDirty( KIGFX::TARGET_NONCACHED );
        myframe->GetCanvas()->GetView()->SetLayerVisible( aId, true );

        if( myframe->IsType( FRAME_PCB_EDITOR ) )
        {
            auto opt = static_cast<PCB_DISPLAY_OPTIONS*>( myframe->GetDisplayOptions() );
            opt->m_ShowGlobalRatsnest = isEnabled;
            myframe->GetCanvas()->GetView()->UpdateDisplayOptions( opt );
        }
    }
    else
        myframe->GetCanvas()->GetView()->SetLayerVisible( aId, isEnabled );

    myframe->GetCanvas()->Refresh();
    myframe->GetCanvas()->Refresh();
}

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

OnRenderSwatchChanged()

void LAYER_WIDGET::OnRenderSwatchChanged ( wxCommandEvent &  aEvent )

protectedinherited

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

Definition at line 198 of file layer_widget.cpp.

{
    auto eventSource = static_cast<COLOR_SWATCH*>( aEvent.GetEventObject() );

    COLOR4D newColor = eventSource->GetSwatchColor();

    LAYER_NUM id = getDecodedId( eventSource->GetId() );

    if( id == LAYER_PCB_BACKGROUND )
    {
        // Update all swatch backgrounds
        int count = GetLayerRowCount();
        int row;
        int col = 1;    // bitmap button is column 1 in layers tab
        for( row = 0; row < count; ++row )
        {
            COLOR_SWATCH* swatch = dynamic_cast<COLOR_SWATCH*>( getLayerComp( row, col ) );
            if( swatch )
                swatch->SetSwatchBackground( newColor );
        }

        count = GetRenderRowCount();
        col = 0;    // bitmap button is column 0 in render tab
        for( row = 0; row < count; ++row )
        {
            COLOR_SWATCH* swatch = dynamic_cast<COLOR_SWATCH*>( getRenderComp( row, col ) );
            if( swatch )
                swatch->SetSwatchBackground( newColor );
        }
    }

    // tell the client code.
    OnRenderColorChange( id, newColor );

    passOnFocus();
}

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

Referenced by LAYER_WIDGET::insertRenderRow().

OnRightDownLayer()

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

protectedinherited

Function OnRightDownLayer Called when user right-clicks a layer.

Definition at line 125 of file layer_widget.cpp.

{
    wxMenu menu;

    AddMenuItem( &menu, ID_CHANGE_LAYER_COLOR,
                 _( "Change Layer Color for " ) + aLayerName,
                 KiBitmap( setcolor_copper_xpm ) );
    menu.AppendSeparator();

    OnLayerRightClick( menu );

    menu.Bind( wxEVT_COMMAND_MENU_SELECTED, [aColorSwatch]( wxCommandEvent& event ) {
        if ( event.GetId() == ID_CHANGE_LAYER_COLOR ) {
            aColorSwatch->GetNewSwatchColor();
        } else {
            event.Skip();
        }
    } );

    PopupMenu( &menu );
    passOnFocus();
}

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

Referenced by LAYER_WIDGET::insertLayerRow().

onRightDownLayers()

void PCB_LAYER_WIDGET::onRightDownLayers ( wxMouseEvent &  event )

protected

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

Definition at line 194 of file pcb_layer_widget.cpp.

{
    wxMenu menu;

    AddRightClickMenuItems( menu );
    PopupMenu( &menu );

    passOnFocus();
}

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

Referenced by PCB_LAYER_WIDGET().

OnRightDownRender()

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

protectedinherited

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

Definition at line 177 of file layer_widget.cpp.

{
    wxMenu menu;

    AddMenuItem( &menu, ID_CHANGE_RENDER_COLOR,
                 _( "Change Render Color for " ) + aRenderName,
                 KiBitmap( setcolor_board_body_xpm ) );

    menu.Bind( wxEVT_COMMAND_MENU_SELECTED, [aColorSwatch]( wxCommandEvent& event ) {
        if ( event.GetId() == ID_CHANGE_RENDER_COLOR ) {
            aColorSwatch->GetNewSwatchColor();
        } else {
            event.Skip();
        }
    } );

    PopupMenu( &menu );
    passOnFocus();
}

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

Referenced by LAYER_WIDGET::insertRenderRow().

OnTabChange()

void LAYER_WIDGET::OnTabChange ( wxNotebookEvent &  event )

protectedinherited

Definition at line 245 of file layer_widget.cpp.

{
//    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.
}

References LAYER_WIDGET::passOnFocus().

Referenced by LAYER_WIDGET::LAYER_WIDGET().

passOnFocus()

void LAYER_WIDGET::passOnFocus ( )

protectedinherited

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

Definition at line 442 of file layer_widget.cpp.

{
    m_FocusOwner->SetFocus();
}

References LAYER_WIDGET::m_FocusOwner.

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

ReFill()

void PCB_LAYER_WIDGET::ReFill

(

)

Definition at line 482 of file pcb_layer_widget.cpp.

{
    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, true,
                myframe->Settings().Colors().GetDefaultLayerColor( layer ) ) );

        if( m_fp_editor_mode && LSET::ForbiddenFootprintLayers().test( layer ) )
        {
            getLayerComp( GetLayerRowCount()-1, COLUMN_COLOR_LYRNAME )->Enable( false );
            getLayerComp( GetLayerRowCount()-1, COLUMN_COLORBM )->SetToolTip( wxEmptyString );
        }
    }

    UpdateLayouts();


    // 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<arrayDim( 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, true,
                myframe->Settings().Colors().GetDefaultLayerColor( layer ) ) );

        if( m_fp_editor_mode && LSET::ForbiddenFootprintLayers().test( layer ) )
        {
            getLayerComp( GetLayerRowCount()-1, COLUMN_COLOR_LYRNAME )->Enable( false );
            getLayerComp( GetLayerRowCount()-1, COLUMN_COLORBM )->SetToolTip( wxEmptyString );
        }
    }
}

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

Referenced by FOOTPRINT_EDIT_FRAME::ReFillLayerWidget().

ReFillRender()

void PCB_LAYER_WIDGET::ReFillRender

(

)

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

Definition at line 373 of file pcb_layer_widget.cpp.

{
    BOARD* board = myframe->GetBoard();
    auto settings = board->GetDesignSettings();

    ClearRenderRows();

    // Add "Items" 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<arrayDim(s_render_rows);  ++row )
    {
        LAYER_WIDGET::ROW renderRow = s_render_rows[row];

        if( m_fp_editor_mode && !isAllowedInFpMode( renderRow.id ) )
            continue;

        if( renderRow.id == LAYER_VIA_MICROVIA && !settings.m_MicroViasAllowed )
            continue;

        if( renderRow.id == LAYER_VIA_BBLIND && !settings.m_BlindBuriedViaAllowed )
            continue;

        if( !renderRow.spacer )
        {
            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.defaultColor = myframe->Settings().Colors().GetDefaultItemColor(
                        static_cast<GAL_LAYER_ID>( renderRow.id ) );
            }

            if( renderRow.id == LAYER_RATSNEST )
                renderRow.state =
                        static_cast<PCB_DISPLAY_OPTIONS*>( myframe->GetDisplayOptions() )->m_ShowGlobalRatsnest;
            else
                renderRow.state = board->IsElementVisible(
                        static_cast<GAL_LAYER_ID>( renderRow.id ) );
        }

        AppendRenderRow( renderRow );
    }

    UpdateLayouts();
}

References LAYER_WIDGET::AppendRenderRow(), arrayDim(), LAYER_WIDGET::ClearRenderRows(), LAYER_WIDGET::ROW::color, PCB_GENERAL_SETTINGS::Colors(), LAYER_WIDGET::ROW::defaultColor, PCB_BASE_FRAME::GetBoard(), COLORS_DESIGN_SETTINGS::GetDefaultItemColor(), BOARD::GetDesignSettings(), PCB_BASE_FRAME::GetDisplayOptions(), COLORS_DESIGN_SETTINGS::GetItemColor(), LAYER_WIDGET::ROW::id, isAllowedInFpMode(), BOARD::IsElementVisible(), LAYER_RATSNEST, LAYER_VIA_BBLIND, LAYER_VIA_MICROVIA, m_fp_editor_mode, myframe, LAYER_WIDGET::ROW::rowName, s_render_rows, PCB_BASE_FRAME::Settings(), LAYER_WIDGET::ROW::spacer, LAYER_WIDGET::ROW::state, LAYER_WIDGET::ROW::tooltip, and LAYER_WIDGET::UpdateLayouts().

Referenced by FOOTPRINT_EDIT_FRAME::UpdateUserInterface().

SelectLayer()

void LAYER_WIDGET::SelectLayer ( LAYER_NUM  aLayer )

inherited

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

Definition at line 669 of file layer_widget.cpp.

{
    int row = findLayerRow( aLayer );
    SelectLayerRow( row );
}

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

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

SelectLayerRow()

void LAYER_WIDGET::SelectLayerRow ( int  aRow )

inherited

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

Definition at line 635 of file layer_widget.cpp.

{
    // enable the layer tab at index 0
    m_notebook->SetSelection( 0 );

    INDICATOR_ICON* oldIndicator = (INDICATOR_ICON*) getLayerComp( m_CurrentRow, 0 );
    if( oldIndicator )
    {
        if( useAlternateBitmap( m_CurrentRow ) )
            oldIndicator->SetIndicatorState( ROW_ICON_PROVIDER::STATE::DIMMED );
        else
            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();
}

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

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

setLayerCheckbox()

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

protectedinherited

Definition at line 693 of file layer_widget.cpp.

{
    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
    }
}

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

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

SetLayerColor()

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

inherited

Function SetLayerColor changes the color of aLayer.

Definition at line 718 of file layer_widget.cpp.

{
    int row = findLayerRow( aLayer );
    if( row >= 0 )
    {
        int col = 1;    // bitmap button is column 1
        auto swatch = static_cast<COLOR_SWATCH*>( getLayerComp( row, col ) );
        wxASSERT( swatch );

        swatch->SetSwatchColor( aColor, false );
    }
}

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

SetLayersManagerTabsText()

void PCB_LAYER_WIDGET::SetLayersManagerTabsText

(

)

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

Definition at line 366 of file pcb_layer_widget.cpp.

{
    m_notebook->SetPageText( 0, _( "Layers" ) );
    m_notebook->SetPageText( 1, _( "Items" ) );
}

References _, and LAYER_WIDGET::m_notebook.

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

SetLayerVisible()

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

inherited

Function SetLayerVisible sets aLayer visible or not.

This does not invoke OnLayerVisible().

Definition at line 686 of file layer_widget.cpp.

{
    setLayerCheckbox( aLayer, isVisible );
    OnLayerVisible( aLayer, isVisible );
}

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

Referenced by ROUTER_TOOL::prepareInteractive().

SetRenderState()

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

inherited

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

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

Parameters

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

Definition at line 748 of file layer_widget.cpp.

{
    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
    }
}

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

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

SyncLayerAlphaIndicators()

void PCB_LAYER_WIDGET::SyncLayerAlphaIndicators

(

)

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

Definition at line 448 of file pcb_layer_widget.cpp.

{
    int count = GetLayerRowCount();
    TOOL_MANAGER* mgr = myframe->GetToolManager();
    KIGFX::PCB_PAINTER* painter = static_cast<KIGFX::PCB_PAINTER*>( mgr->GetView()->GetPainter() );
    KIGFX::PCB_RENDER_SETTINGS* settings = painter->GetSettings();

    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() ) );
        KIGFX::COLOR4D screenColor = settings->GetLayerColor( layerId );

        COLOR_SWATCH* swatch = static_cast<COLOR_SWATCH*>( getLayerComp( row, COLUMN_COLORBM ) );
        KIGFX::COLOR4D layerColor = swatch->GetSwatchColor();

        INDICATOR_ICON* indicator = static_cast<INDICATOR_ICON*>( getLayerComp( row, COLUMN_ALPHA_INDICATOR ) );

        if( std::abs( screenColor.a - layerColor.a ) > ALPHA_EPSILON )
        {
            if( screenColor.a < layerColor.a )
                indicator->SetIndicatorState( ROW_ICON_PROVIDER::STATE::DOWN );
            else
                indicator->SetIndicatorState( ROW_ICON_PROVIDER::STATE::UP );
        }
        else
            indicator->SetIndicatorState( ROW_ICON_PROVIDER::STATE::OFF );
    }
}

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

Referenced by FOOTPRINT_EDIT_FRAME::OnUpdateLayerAlpha().

SyncLayerVisibilities()

void PCB_LAYER_WIDGET::SyncLayerVisibilities

(

)

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

Definition at line 426 of file pcb_layer_widget.cpp.

{
    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
        setLayerCheckbox( layerId, board->IsLayerVisible( layerId ) );
    }
}

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

Referenced by FOOTPRINT_EDIT_FRAME::UpdateUserInterface().

UpdateLayerIcons()

void LAYER_WIDGET::UpdateLayerIcons ( )

inherited

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

Definition at line 788 of file layer_widget.cpp.

{
    int rowCount = GetLayerRowCount();

    for( int row = 0; row < rowCount ; row++ )
    {
        INDICATOR_ICON* indicator = (INDICATOR_ICON*) getLayerComp( row, COLUMN_ICON_ACTIVE );

        if( indicator )
        {
            ROW_ICON_PROVIDER::STATE state;

            if( row == m_CurrentRow )
                state = ROW_ICON_PROVIDER::STATE::ON;
            else if( useAlternateBitmap( row ) )
                state = ROW_ICON_PROVIDER::STATE::DIMMED;
            else
                state = ROW_ICON_PROVIDER::STATE::OFF;

            indicator->SetIndicatorState( state );
        }
    }
}

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

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

UpdateLayouts()

void LAYER_WIDGET::UpdateLayouts ( )

inherited

Definition at line 778 of file layer_widget.cpp.

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

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

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

useAlternateBitmap()

virtual bool LAYER_WIDGET::useAlternateBitmap ( int  aRow )

inlineprotectedvirtualinherited

Virtual Function useAlternateBitmap.

Returns

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

Reimplemented in GERBER_LAYER_WIDGET.

Definition at line 149 of file layer_widget.h.

{ return false; }

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

Member Data Documentation

EVT_LAYER_COLOR_CHANGE

const wxEventType LAYER_WIDGET::EVT_LAYER_COLOR_CHANGE = wxNewEventType()

staticinherited

Definition at line 123 of file layer_widget.h.

Referenced by LAYER_WIDGET::OnLayerSwatchChanged().

m_alwaysShowActiveCopperLayer

bool PCB_LAYER_WIDGET::m_alwaysShowActiveCopperLayer

protected

Definition at line 118 of file pcb_layer_widget.h.

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

m_CurrentRow

int LAYER_WIDGET::m_CurrentRow

protectedinherited

selected row of layer list

Definition at line 136 of file layer_widget.h.

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

m_FocusOwner

wxWindow* LAYER_WIDGET::m_FocusOwner

protectedinherited

Definition at line 135 of file layer_widget.h.

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

m_fp_editor_mode

bool PCB_LAYER_WIDGET::m_fp_editor_mode

protected

Definition at line 120 of file pcb_layer_widget.h.

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

m_IconProvider

ROW_ICON_PROVIDER* LAYER_WIDGET::m_IconProvider

protectedinherited

Definition at line 139 of file layer_widget.h.

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

m_LayerPanel

wxPanel* LAYER_WIDGET::m_LayerPanel

protectedinherited

Definition at line 128 of file layer_widget.h.

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

m_LayerScrolledWindow

wxScrolledWindow* LAYER_WIDGET::m_LayerScrolledWindow

protectedinherited

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

m_LayersFlexGridSizer

wxFlexGridSizer* LAYER_WIDGET::m_LayersFlexGridSizer

protectedinherited

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

m_notebook

wxAuiNotebook* LAYER_WIDGET::m_notebook

protectedinherited

Definition at line 127 of file layer_widget.h.

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

m_PointSize

int LAYER_WIDGET::m_PointSize

protectedinherited

Definition at line 137 of file layer_widget.h.

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

m_RenderFlexGridSizer

wxFlexGridSizer* LAYER_WIDGET::m_RenderFlexGridSizer

protectedinherited

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

m_RenderingPanel

wxPanel* LAYER_WIDGET::m_RenderingPanel

protectedinherited

Definition at line 131 of file layer_widget.h.

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

m_RenderScrolledWindow

wxScrolledWindow* LAYER_WIDGET::m_RenderScrolledWindow

protectedinherited

Definition at line 132 of file layer_widget.h.

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

myframe

PCB_BASE_FRAME* PCB_LAYER_WIDGET::myframe

protected

Definition at line 122 of file pcb_layer_widget.h.

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

s_render_rows

const LAYER_WIDGET::ROW PCB_LAYER_WIDGET::s_render_rows

staticprotected

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

Definition at line 117 of file pcb_layer_widget.h.

Referenced by ReFillRender().

---

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

• pcb_layer_widget.h
• pcb_layer_widget.cpp