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 bool	AreArbitraryColorsAllowed () override
	Subclasses can override this to provide logic for allowing arbitrary color selection via wxColourPicker instead of DisplayColorFrame. More...

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

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_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 109 of file 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 ),
         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 );
 }

Member Function Documentation

void PCB_LAYER_WIDGET::AddRightClickMenuItems ( wxMenu & menu )

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

Definition at line 167 of file pcb_layer_widget.cpp.

References AddMenuItem(), ID_ALWAYS_SHOW_NO_COPPER_LAYERS_BUT_ACTIVE, ID_HIDE_ALL_NON_COPPER, ID_SHOW_ALL_BACK, ID_SHOW_ALL_COPPER_LAYERS, ID_SHOW_ALL_FRONT, ID_SHOW_ALL_LAYERS, ID_SHOW_ALL_NON_COPPER, ID_SHOW_NO_COPPER_LAYERS, ID_SHOW_NO_COPPER_LAYERS_BUT_ACTIVE, ID_SHOW_NO_LAYERS, and KiBitmap().

Referenced by OnLayerRightClick(), and onRightDownLayers().

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

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.

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

References LAYER_WIDGET::AppendLayerRow(), LAYER_WIDGET::AppendRenderRow(), and LAYER_WIDGET::ClearLayerRows().

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

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

Referenced by LAYER_WIDGET::AppendLayerRows(), 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 330 of file layer_widget.h.

References LAYER_WIDGET::AppendRenderRow(), LAYER_WIDGET::ClearRenderRows(), LAYER_WIDGET::GetLayerColor(), LAYER_WIDGET::GetRenderState(), LAYER_WIDGET::GetSelectedLayer(), LAYER_WIDGET::IsLayerVisible(), LAYER_WIDGET::OnLayerColorChange(), LAYER_WIDGET::OnLayerRightClick(), LAYER_WIDGET::OnLayerSelect(), LAYER_WIDGET::OnLayerVisible(), LAYER_WIDGET::OnRenderColorChange(), LAYER_WIDGET::OnRenderEnable(), LAYER_WIDGET::SelectLayer(), LAYER_WIDGET::SelectLayerRow(), LAYER_WIDGET::SetLayerColor(), LAYER_WIDGET::SetLayerVisible(), LAYER_WIDGET::SetRenderState(), LAYER_WIDGET::UpdateLayerIcons(), and LAYER_WIDGET::UpdateLayouts().

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

References LAYER_WIDGET::m_LayersFlexGridSizer.

Referenced by LAYER_WIDGET::AppendLayerRows(), 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 631 of file layer_widget.cpp.

References LAYER_WIDGET::m_RenderFlexGridSizer.

Referenced by LAYER_WIDGET::AppendRenderRows(), 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 63 of file layer_widget.cpp.

References LYR_COLUMN_COUNT.

Referenced by LAYER_WIDGET::getBackgroundLayerColor(), 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 265 of file layer_widget.cpp.

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

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

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

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

Referenced by LAYER_WIDGET::getBackgroundLayerColor(), 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;
 }

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

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

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

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.

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(), 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 += 32;
 
 
     /* 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 += 32;
 
     // 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 70 of file layer_widget.cpp.

References LYR_COLUMN_COUNT.

Referenced by LAYER_WIDGET::findLayerRow(), LAYER_WIDGET::findRenderRow(), LAYER_WIDGET::getBackgroundLayerColor(), 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().

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

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

Referenced by LAYER_WIDGET::AppendRenderRows().

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

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.

References LYR_COLUMN_COUNT, and LAYER_WIDGET::m_LayersFlexGridSizer.

Referenced by LAYER_WIDGET::findLayerRow(), LAYER_WIDGET::getBackgroundLayerColor(), 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().

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

References LYR_COLUMN_COUNT, and LAYER_WIDGET::m_LayersFlexGridSizer.

Referenced by LAYER_WIDGET::AppendLayerRow(), LAYER_WIDGET::findLayerRow(), LAYER_WIDGET::OnLeftDownLayers(), GERBER_LAYER_WIDGET::onPopupSelection(), onPopupSelection(), LAYER_WIDGET::OnRenderSwatchChanged(), ReFill(), SyncLayerAlphaIndicators(), 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 283 of file layer_widget.cpp.

References LAYER_WIDGET::m_RenderFlexGridSizer, and RND_COLUMN_COUNT.

Referenced by LAYER_WIDGET::findRenderRow(), LAYER_WIDGET::getBackgroundLayerColor(), LAYER_WIDGET::GetRenderState(), LAYER_WIDGET::OnRenderSwatchChanged(), 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 602 of file layer_widget.cpp.

References LAYER_WIDGET::m_RenderFlexGridSizer, and RND_COLUMN_COUNT.

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

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

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

Referenced by LAYER_WIDGET::AppendRenderRows().

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

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

Referenced by LAYER_WIDGET::AppendRenderRows().

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

References LAYER_WIDGET::AreArbitraryColorsAllowed(), LAYER_WIDGET::ROW::color, COLUMN_ALPHA_INDICATOR, COLUMN_COLOR_LYR_CB, COLUMN_COLOR_LYRNAME, COLUMN_COLORBM, COLUMN_ICON_ACTIVE, 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(), and LAYER_WIDGET::getBackgroundLayerColor().

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

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

protectedinherited

Definition at line 377 of file layer_widget.cpp.

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

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

void PCB_LAYER_WIDGET::installRightLayerClickHandler ( )

protected

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

bool PCB_LAYER_WIDGET::isAllowedInFpMode ( int aId )

protected

Function isAllowedInFpMode.

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

Definition at line 147 of file pcb_layer_widget.cpp.

References DIM.

Referenced by ReFillRender().

 {
     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 157 of file 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 707 of file layer_widget.cpp.

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

Referenced by LAYER_WIDGET::AppendRenderRows(), and 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 168 of file layer_widget.cpp.

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

Referenced by LAYER_WIDGET::getBackgroundLayerColor(), and 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 580 of file 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_FRAME::ReCreateHToolbar(), EDA_DRAW_PANEL::Refresh(), COLORS_DESIGN_SETTINGS::SetLayerColor(), PCB_BASE_FRAME::Settings(), 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( aLayer );
         aColor.a = oldColor.a;
     }
 
     myframe->Settings().Colors().SetLayerColor( 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->ReCreateHToolbar();
 
     myframe->GetCanvas()->Refresh();
 }

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

References AddRightClickMenuItems().

 {
     AddRightClickMenuItems( aMenu );
 }

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

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

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

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 628 of file 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 149 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::getBackgroundLayerColor(), and 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 643 of file pcb_layer_widget.cpp.

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

Referenced by onPopupSelection().

 {
     BOARD* brd = myframe->GetBoard();
 
     LSET visibleLayers = brd->GetVisibleLayers();
 
     if( visibleLayers.test( aLayer ) != isVisible )
     {
         visibleLayers.set( aLayer, isVisible );
 
         brd->SetVisibleLayers( visibleLayers );
 
         myframe->OnModify();
 
         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 77 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::getBackgroundLayerColor(), and 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 221 of file 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 236 of file layer_widget.cpp.

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

Referenced by LAYER_WIDGET::getBackgroundLayerColor(), and 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 674 of file pcb_layer_widget.cpp.

References PCB_GENERAL_SETTINGS::Colors(), EDA_DRAW_PANEL_GAL::ForceRefresh(), GAL_LAYER_ID_END, GAL_LAYER_ID_START, EDA_DRAW_FRAME::GetCanvas(), EDA_DRAW_PANEL_GAL::GetGAL(), EDA_DRAW_FRAME::GetGalCanvas(), KIGFX::VIEW::GetPainter(), KIGFX::PAINTER::GetSettings(), EDA_DRAW_PANEL_GAL::GetView(), KIGFX::RENDER_SETTINGS::ImportLegacyColors(), EDA_DRAW_FRAME::IsGalCanvasActive(), LAYER_GRID, LAYER_PADS_PLATEDHOLES, KIGFX::VIEW::MarkTargetDirty(), myframe, EDA_DRAW_FRAME::ReCreateHToolbar(), EDA_DRAW_PANEL::Refresh(), KIGFX::GAL::SetGridColor(), 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() )
     {
         if( aId == LAYER_GRID )
             galCanvas->GetGAL()->SetGridColor( aColor );
 
         KIGFX::VIEW* view = galCanvas->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 );
 
         galCanvas->ForceRefresh();
     }
 
     myframe->ReCreateHToolbar();
 
     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 705 of file pcb_layer_widget.cpp.

References FRAME_PCB, 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(), EDA_BASE_FRAME::IsType(), 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 );
 
     if( myframe->IsType( FRAME_PCB ) )
     {
         // 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 198 of file layer_widget.cpp.

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::getBackgroundLayerColor(), and LAYER_WIDGET::insertRenderRow().

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

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.

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

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

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

void PCB_LAYER_WIDGET::onRightDownLayers ( wxMouseEvent & event )

protected

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

Definition at line 210 of file pcb_layer_widget.cpp.

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

Referenced by PCB_LAYER_WIDGET().

 {
     wxMenu menu;
 
     AddRightClickMenuItems( menu );
     PopupMenu( &menu );
 
     passOnFocus();
 }

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.

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

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

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

void LAYER_WIDGET::OnTabChange ( wxNotebookEvent & event )

protectedinherited

Definition at line 245 of file layer_widget.cpp.

References LAYER_WIDGET::passOnFocus().

Referenced by LAYER_WIDGET::getBackgroundLayerColor(), and 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 442 of file layer_widget.cpp.

References LAYER_WIDGET::m_FocusOwner.

Referenced by LAYER_WIDGET::getBackgroundLayerColor(), 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().

 {
     m_FocusOwner->SetFocus();
 }

void PCB_LAYER_WIDGET::ReFill ( )

Definition at line 488 of file 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(), i, 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 );
         }
     }
 }

void PCB_LAYER_WIDGET::ReFillRender ( )

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

Definition at line 389 of file pcb_layer_widget.cpp.

References LAYER_WIDGET::AppendRenderRow(), LAYER_WIDGET::ClearRenderRows(), LAYER_WIDGET::ROW::color, PCB_GENERAL_SETTINGS::Colors(), DIM, PCB_BASE_FRAME::GetBoard(), BOARD::GetDesignSettings(), COLORS_DESIGN_SETTINGS::GetItemColor(), LAYER_WIDGET::ROW::id, isAllowedInFpMode(), BOARD::IsElementVisible(), 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, and LAYER_WIDGET::ROW::tooltip.

Referenced by PCB_LAYER_WIDGET().

 {
     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<DIM(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.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 671 of file layer_widget.cpp.

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

Referenced by LAYER_WIDGET::AppendRenderRows(), 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 637 of file layer_widget.cpp.

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

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

protectedinherited

Definition at line 695 of file layer_widget.cpp.

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

Referenced by LAYER_WIDGET::getBackgroundLayerColor(), LAYER_WIDGET::SetLayerVisible(), and 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::SetLayerColor	(	LAYER_NUM	aLayer,
		COLOR4D	aColor
	)

inherited

Function SetLayerColor changes the color of aLayer.

Definition at line 720 of file layer_widget.cpp.

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

Referenced by LAYER_WIDGET::AppendRenderRows().

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

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

References LAYER_WIDGET::m_notebook.

Referenced by PCB_LAYER_WIDGET().

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

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

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

Referenced by LAYER_WIDGET::AppendRenderRows(), and ROUTER_TOOL::prepareInteractive().

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

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

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

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

 {
     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::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 454 of file pcb_layer_widget.cpp.

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

Referenced by FOOTPRINT_EDIT_FRAME::OnUpdateLayerAlpha().

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

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

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

References BLUE, BROWN, COLUMN_ICON_ACTIVE, DIM, LAYER_WIDGET::getLayerComp(), LAYER_WIDGET::GetLayerRowCount(), GREEN, LAYER_WIDGET::LAYER_WIDGET(), LAYER_WIDGET::m_CurrentRow, OFF, ON, LAYER_WIDGET::OnLayerColorChange(), LAYER_WIDGET::OnLayerSelect(), LAYER_WIDGET::OnLayerVisible(), LAYER_WIDGET::OnRenderColorChange(), LAYER_WIDGET::OnRenderEnable(), RED, INDICATOR_ICON::SetIndicatorState(), LAYER_WIDGET::useAlternateBitmap(), and YELLOW.

Referenced by LAYER_WIDGET::AppendRenderRows(), GERBVIEW_FRAME::LoadExcellonFiles(), GERBVIEW_FRAME::loadListOfGerberFiles(), 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 )
         {
             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 );
         }
     }
 }

void LAYER_WIDGET::UpdateLayouts ( )

inherited

Definition at line 780 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(), LAYER_WIDGET::AppendRenderRow(), and LAYER_WIDGET::AppendRenderRows().

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

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

145 { return false; }