PANEL_SETUP_BOARD_STACKUP Class Reference

#include <panel_board_stackup.h>

Inheritance diagram for PANEL_SETUP_BOARD_STACKUP:

Public Member Functions
	PANEL_SETUP_BOARD_STACKUP (PAGED_DIALOG *aParent, PCB_EDIT_FRAME *aFrame, PANEL_SETUP_LAYERS *aPanelLayers)
	~PANEL_SETUP_BOARD_STACKUP ()
void	ImportSettingsFrom (BOARD *aBoard)
void	OnLayersOptionsChanged (LSET aNewLayerSet)
	Must be called if the copper layers count has changed or solder mask, solder paste or silkscreen layers are enabled or disabled Rebuild the Layer Stack Panel if the new layer set differs from the current layet set. More...
int	GetCopperLayerCount () const
BOARD_STACKUP_ITEM *	GetStackupItem (int aRow)
int	GetSublayerId (int aRow)
wxColor	GetSelectedColor (int aRow) const
	Return the color currently selected for the row aRow. More...
BOARD_STACKUP &	GetStackup ()
bool	TransferDataFromWindow () override

Protected Attributes
wxStaticText *	m_lblCopperLayers
wxChoice *	m_choiceCopperLayers
wxCheckBox *	m_impedanceControlled
wxButton *	m_buttonAddDielectricLayer
wxButton *	m_buttonRemoveDielectricLayer
wxScrolledWindow *	m_scGridWin
wxFlexGridSizer *	m_fgGridSizer
wxStaticText *	m_staticTextLayer
wxStaticText *	m_staticTextLayerId
wxStaticText *	m_staticTextType
wxStaticText *	m_staticTextMaterial
wxStaticText *	m_staticTextThickness
wxStaticBitmap *	m_bitmapLockThickness
wxStaticText *	m_staticTextColor
wxStaticText *	m_staticTextEpsilonR
wxStaticText *	m_staticTextLossTg
wxStaticText *	m_staticTextCT
wxTextCtrl *	m_tcCTValue
wxButton *	m_buttonAdjust
wxButton *	m_buttonExport

Private Member Functions
BOARD_STACKUP_ROW_UI_ITEM	createRowData (int aRow, BOARD_STACKUP_ITEM *aStackupItem, int aSublayerIdx)
	Creates a BOARD_STACKUP_ROW_UI_ITEM relative to the aStackupItem. More...
wxControl *	addSpacer ()
	add a Spacer in m_fgGridSizer when a empty cell is needed More...
void	addMaterialChooser (wxWindowID aId, const wxString *aMaterialName, BOARD_STACKUP_ROW_UI_ITEM &aUiRowItem)
	add a control (a wxTextCtrl + a button) in m_fgGridSizer to select a material More...
void	buildLayerStackPanel (bool aCreatedInitialStackup)
	Populate m_fgGridSizer with items to handle stackup parameters This is a full list: all copper layers and all tech layers that are supported by the stackup items not in the current board stackup will be not shown, but they are existing in list. More...
void	synchronizeWithBoard (bool aFullSync)
	Synchronize the full stackup shown in m_fgGridSizer according to the stackup of the current board and optionally update the stackup params (thickness, color ... ) More...
void	showOnlyActiveLayers ()
	Show or do not show items in m_fgGridSizer according to the stackup of the current board. More...
void	rebuildLayerStackPanel ()
	Populate m_fgGridSizer with items to handle stackup parameters If previous items are in list, remove old items New prms are added must be called after adding or deleting a dielectric parameter set. More...
bool	transferDataFromUIToStackup ()
	Transfer current UI settings to m_stackup but not to the board. More...
void	updateCopperLayerCount ()
	Updates the enabled copper layers when the dropdown is changed. More...
int	computeBoardThickness ()
	Recompute the board thickness and update the textbox. More...
void	setDefaultLayerWidths (int targetThickness)
	Set the widths of dielectric layers to sensible defaults. More...
void	onColorSelected (wxCommandEvent &event)
void	onMaterialChange (wxCommandEvent &event)
void	onThicknessChange (wxCommandEvent &event)
void	onExportToClipboard (wxCommandEvent &event) override
void	onAddDielectricLayer (wxCommandEvent &event) override
void	onRemoveDielectricLayer (wxCommandEvent &event) override
void	onRemoveDielUI (wxUpdateUIEvent &event) override
void	onCopperLayersSelCount (wxCommandEvent &event) override
void	onAdjustDielectricThickness (wxCommandEvent &event) override
void	updateIconColor (int aRow=-1)
	Update the icons color (swatches in first grid column) More...
wxColor	getColorIconItem (int aRow)
wxBitmapComboBox *	createColorBox (BOARD_STACKUP_ITEM *aStackupItem, int aRow)
	creates a bitmap combobox to select a layer color More...
void	disconnectEvents ()
	disconnect event handlers connected to wxControl items found in list m_controlItemsList More...

Private Attributes
BOARD_STACKUP	m_stackup
PANEL_SETUP_LAYERS *	m_panelLayers
LSET	m_enabledLayers
DIELECTRIC_SUBSTRATE_LIST	m_delectricMatList
DIELECTRIC_SUBSTRATE_LIST	m_solderMaskMatList
DIELECTRIC_SUBSTRATE_LIST	m_silkscreenMatList
std::vector< BOARD_STACKUP_ROW_UI_ITEM >	m_rowUiItemsList
PAGED_DIALOG *	m_parentDialog
BOARD *	m_board
BOARD_DESIGN_SETTINGS *	m_brdSettings
PCB_EDIT_FRAME *	m_frame
wxSize	m_numericTextCtrlSize
wxSize	m_numericFieldsSize
wxArrayString	m_core_prepreg_choice
wxSize	m_colorSwatchesSize
wxSize	m_colorIconsSize
std::vector< wxControl * >	m_controlItemsList

Detailed Description

Definition at line 87 of file panel_board_stackup.h.

Constructor & Destructor Documentation

PANEL_SETUP_BOARD_STACKUP()

PANEL_SETUP_BOARD_STACKUP::PANEL_SETUP_BOARD_STACKUP	(	PAGED_DIALOG *	aParent,
		PCB_EDIT_FRAME *	aFrame,
		PANEL_SETUP_LAYERS *	aPanelLayers
	)

Definition at line 76 of file panel_board_stackup.cpp.

 :
 PANEL_SETUP_BOARD_STACKUP_BASE( aParent->GetTreebook() ),
 m_delectricMatList( DIELECTRIC_SUBSTRATE_LIST::DL_MATERIAL_DIELECTRIC ),
 m_solderMaskMatList( DIELECTRIC_SUBSTRATE_LIST::DL_MATERIAL_SOLDERMASK ),
 m_silkscreenMatList( DIELECTRIC_SUBSTRATE_LIST::DL_MATERIAL_SILKSCREEN )
{
 m_parentDialog = aParent;
 m_frame = aFrame;
 m_panelLayers = aPanelLayers;
 m_board = m_frame->GetBoard();
 m_brdSettings = &m_board->GetDesignSettings();
 
 m_panelLayers->SetPhysicalStackupPanel( this );
 
 m_enabledLayers = m_board->GetEnabledLayers() & BOARD_STACKUP::StackupAllowedBrdLayers();
 
 // Calculates a good size for color swatches (icons) in this dialog
 wxClientDC dc( this );
 m_colorSwatchesSize = dc.GetTextExtent( wxT( "XX" ) );
 m_colorIconsSize = dc.GetTextExtent( wxT( "XXXX" ) );
 
 // Calculates a good size for wxTextCtrl to enter Epsilon R and Loss tan
 // ("0.0000000" + margins)
 m_numericFieldsSize = dc.GetTextExtent( wxT( "X.XXXXXXX" ) );
 m_numericFieldsSize.y = -1; // Use default for the vertical size
 
 // Calculates a minimal size for wxTextCtrl to enter a dim with units
 // ("000.0000000 mils" + margins)
 m_numericTextCtrlSize = dc.GetTextExtent( wxT( "XXX.XXXXXXX mils" ) );
 m_numericTextCtrlSize.y = -1; // Use default for the vertical size
 
 // The grid column containing the lock checkbox is kept to a minimal
 // size. So we use a wxStaticBitmap: set the bitmap itself
 m_bitmapLockThickness->SetBitmap( KiScaledBitmap( BITMAPS::locked, aFrame ) );
 
 // Gives a minimal size of wxTextCtrl showing dimensions+units
 m_tcCTValue->SetMinSize( m_numericTextCtrlSize );
 
 // Prepare dielectric layer type: layer type keyword is "core" or "prepreg"
 m_core_prepreg_choice.Add( _( "Core" ) );
 m_core_prepreg_choice.Add( _( "PrePreg" ) );
 
 buildLayerStackPanel( true );
 synchronizeWithBoard( true );
 computeBoardThickness();
}

References _, buildLayerStackPanel(), computeBoardThickness(), PCB_BASE_FRAME::GetBoard(), BOARD::GetDesignSettings(), BOARD::GetEnabledLayers(), KiScaledBitmap(), locked, PANEL_SETUP_BOARD_STACKUP_BASE::m_bitmapLockThickness, m_board, m_brdSettings, m_colorIconsSize, m_colorSwatchesSize, m_core_prepreg_choice, m_enabledLayers, m_frame, m_numericFieldsSize, m_numericTextCtrlSize, m_panelLayers, m_parentDialog, PANEL_SETUP_BOARD_STACKUP_BASE::m_tcCTValue, PANEL_SETUP_LAYERS::SetPhysicalStackupPanel(), BOARD_STACKUP::StackupAllowedBrdLayers(), and synchronizeWithBoard().

~PANEL_SETUP_BOARD_STACKUP()

PANEL_SETUP_BOARD_STACKUP::~PANEL_SETUP_BOARD_STACKUP

(

)

Definition at line 125 of file panel_board_stackup.cpp.

{
 disconnectEvents();
}

References disconnectEvents().

Member Function Documentation

addMaterialChooser()

void PANEL_SETUP_BOARD_STACKUP::addMaterialChooser ( wxWindowID  aId, const wxString *  aMaterialName, BOARD_STACKUP_ROW_UI_ITEM &  aUiRowItem  )

private

add a control (a wxTextCtrl + a button) in m_fgGridSizer to select a material

Parameters

aId	is the wxControl id, used to know the event source
aMaterialName	is the name of the currently selected material (can be null)
aUiRowItem	is the BOARD_STACKUP_ROW_UI_ITEM to store the controls created

Definition at line 739 of file panel_board_stackup.cpp.

{
 wxBoxSizer* bSizerMat = new wxBoxSizer( wxHORIZONTAL );
 m_fgGridSizer->Add( bSizerMat, 1, wxRIGHT|wxEXPAND, 4 );
 wxTextCtrl* textCtrl = new wxTextCtrl( m_scGridWin, wxID_ANY );
 
 if( aMaterialName )
 {
 if( IsPrmSpecified( *aMaterialName ) )
 textCtrl->ChangeValue( *aMaterialName );
 else
 textCtrl->ChangeValue( wxGetTranslation( NotSpecifiedPrm() ) );
 }
 
 textCtrl->SetMinSize( m_numericTextCtrlSize );
 bSizerMat->Add( textCtrl, 0, wxALIGN_CENTER_VERTICAL|wxLEFT, 5 );
 
 wxButton* m_buttonMat = new wxButton( m_scGridWin, aId, _( "..." ), wxDefaultPosition,
 wxDefaultSize, wxBU_EXACTFIT );
 bSizerMat->Add( m_buttonMat, 0, wxALIGN_CENTER_VERTICAL, 2 );
 
 m_buttonMat->Connect( wxEVT_COMMAND_BUTTON_CLICKED,
 wxCommandEventHandler( PANEL_SETUP_BOARD_STACKUP::onMaterialChange ),
 nullptr, this );
 m_controlItemsList.push_back( m_buttonMat );
 
 aUiRowItem.m_MaterialCtrl = textCtrl;
 aUiRowItem.m_MaterialButt = m_buttonMat;
}

References _, IsPrmSpecified(), m_controlItemsList, PANEL_SETUP_BOARD_STACKUP_BASE::m_fgGridSizer, BOARD_STACKUP_ROW_UI_ITEM::m_MaterialButt, BOARD_STACKUP_ROW_UI_ITEM::m_MaterialCtrl, m_numericTextCtrlSize, PANEL_SETUP_BOARD_STACKUP_BASE::m_scGridWin, NotSpecifiedPrm(), and onMaterialChange().

Referenced by createRowData().

addSpacer()

wxControl * PANEL_SETUP_BOARD_STACKUP::addSpacer ( )

private

add a Spacer in m_fgGridSizer when a empty cell is needed

Definition at line 771 of file panel_board_stackup.cpp.

{
 wxStaticText* emptyText = new wxStaticText( m_scGridWin, wxID_ANY, wxEmptyString );
 m_fgGridSizer->Add( emptyText, 0, wxALIGN_CENTER_VERTICAL );
 return emptyText;
}

References PANEL_SETUP_BOARD_STACKUP_BASE::m_fgGridSizer, and PANEL_SETUP_BOARD_STACKUP_BASE::m_scGridWin.

Referenced by createRowData().

buildLayerStackPanel()

void PANEL_SETUP_BOARD_STACKUP::buildLayerStackPanel ( bool  aCreatedInitialStackup )

private

Populate m_fgGridSizer with items to handle stackup parameters This is a full list: all copper layers and all tech layers that are supported by the stackup items not in the current board stackup will be not shown, but they are existing in list.

Parameters

aCreatedInitialStackup

= true to create a initial stackup list for the dialog false to build the stackup panel from the existing stackup list.

Definition at line 1029 of file panel_board_stackup.cpp.

{
 // Build a full stackup for the dialog, with a active copper layer count
 // = current board layer count to calculate a reasonable default stackup:
 if( aCreatedInitialStackup )
 {
 // Creates a full BOARD_STACKUP with 32 copper layers.
 // extra layers will be hidden later.
 // but if the number of layer is changed in the dialog, the corresponding
 // widgets will be available with their previous values.
 m_stackup.BuildDefaultStackupList( nullptr, m_brdSettings->GetCopperLayerCount() );
 const BOARD_STACKUP& brd_stackup = m_brdSettings->GetStackupDescriptor();
 
 // Now initialize all stackup items to the board values, when exist
 for( BOARD_STACKUP_ITEM* item: m_stackup.GetList() )
 {
 // Search for board settings:
 for( BOARD_STACKUP_ITEM* board_item: brd_stackup.GetList() )
 {
 if( item->GetBrdLayerId() != UNDEFINED_LAYER )
 {
 if( item->GetBrdLayerId() == board_item->GetBrdLayerId() )
 {
 *item = *board_item;
  break;
 }
 }
 else // dielectric layer: see m_DielectricLayerId for identification
 {
 // Compare dielectric layer with dielectric layer
 if( board_item->GetBrdLayerId() != UNDEFINED_LAYER )
 continue;
 
 if( item->GetDielectricLayerId() == board_item->GetDielectricLayerId() )
 {
 *item = *board_item;
 break;
 }
 }
 }
 }
 }
 
 int row = 0;
 
 for( BOARD_STACKUP_ITEM* item : m_stackup.GetList() )
 {
 for( int sub_idx = 0; sub_idx < item->GetSublayersCount(); sub_idx++ )
 {
 BOARD_STACKUP_ROW_UI_ITEM ui_row_item = createRowData( row, item, sub_idx );
 m_rowUiItemsList.emplace_back( ui_row_item );
 
 row++;
 }
 }
 
 updateIconColor();
}

References BOARD_STACKUP::BuildDefaultStackupList(), createRowData(), BOARD_DESIGN_SETTINGS::GetCopperLayerCount(), BOARD_STACKUP::GetList(), BOARD_DESIGN_SETTINGS::GetStackupDescriptor(), m_brdSettings, m_rowUiItemsList, m_stackup, UNDEFINED_LAYER, and updateIconColor().

Referenced by PANEL_SETUP_BOARD_STACKUP(), and rebuildLayerStackPanel().

computeBoardThickness()

int PANEL_SETUP_BOARD_STACKUP::computeBoardThickness ( )

private

Recompute the board thickness and update the textbox.

Returns

the computed value

Definition at line 530 of file panel_board_stackup.cpp.

{
 int thickness = 0;
 
 for( BOARD_STACKUP_ROW_UI_ITEM& ui_item : m_rowUiItemsList )
 {
 BOARD_STACKUP_ITEM* item = ui_item.m_Item;
 
 if( !item->IsThicknessEditable() || !ui_item.m_isEnabled )
 continue;
 
 wxTextCtrl* textCtrl = static_cast<wxTextCtrl*>( ui_item.m_ThicknessCtrl );
 int item_thickness = m_frame->ValueFromString( textCtrl->GetValue() );
 
 thickness += item_thickness;
 }
 
 wxString thicknessStr = m_frame->StringFromValue( thickness, true );
 
 // The text in the event will translate to the value for the text control
 // and is only updated if it changed
 m_tcCTValue->ChangeValue( thicknessStr );
 
 return thickness;
}

References BOARD_STACKUP_ITEM::IsThicknessEditable(), m_frame, m_rowUiItemsList, PANEL_SETUP_BOARD_STACKUP_BASE::m_tcCTValue, UNITS_PROVIDER::StringFromValue(), and UNITS_PROVIDER::ValueFromString().

Referenced by ImportSettingsFrom(), onAddDielectricLayer(), onAdjustDielectricThickness(), onCopperLayersSelCount(), onRemoveDielectricLayer(), onThicknessChange(), and PANEL_SETUP_BOARD_STACKUP().

createColorBox()

wxBitmapComboBox * PANEL_SETUP_BOARD_STACKUP::createColorBox ( BOARD_STACKUP_ITEM *  aStackupItem, int  aRow  )

private

creates a bitmap combobox to select a layer color

Returns

the created wxBitmapComboBox

Parameters

aStackupItem	= the BOARD_STACKUP_ITEM related to the bitmap combobox (to set the user color, if any) can be nullptr
aRow	= the row index in the wxFlexGridSizer (used to build a wxWidget unique id)

Definition at line 1580 of file panel_board_stackup.cpp.

{
 wxBitmapComboBox* combo = new wxBitmapComboBox( m_scGridWin, ID_ITEM_COLOR + aRow,
 wxEmptyString, wxDefaultPosition,
 wxDefaultSize, 0, nullptr, wxCB_READONLY );
 
 // Fills the combo box with choice list + bitmaps
 BOARD_STACKUP_ITEM_TYPE itemType = aStackupItem ? aStackupItem->GetType()
 : BS_ITEM_TYPE_SILKSCREEN;
 
 for( int ii = 0; ii < GetStandardColorCount( itemType ); ii++ )
 {
 wxString label;
 COLOR4D curr_color;
 
 // Defined colors have a name, the user color uses HTML notation ( i.e. #FF000080)
 if( IsCustomColorIdx( itemType, ii )
 && aStackupItem && aStackupItem->GetColor().StartsWith( wxT( "#" ) ) )
 {
 label = aStackupItem->GetColor();
 curr_color = COLOR4D( label );
 }
 else
 {
 label = wxGetTranslation( GetStandardColorName( itemType, ii ) );
 curr_color = GetStandardColor( itemType, ii );
 }
 
 wxBitmap layerbmp( m_colorSwatchesSize.x, m_colorSwatchesSize.y );
 LAYER_SELECTOR::DrawColorSwatch( layerbmp, COLOR4D( 0, 0, 0, 0 ), curr_color );
 
 combo->Append( label, layerbmp );
 }
 
 // Ensure the size of the widget is enough to show the text and the icon
 // We have to have a selected item when doing this, because otherwise GTK
 // will just choose a random size that might not fit the actual data
 // (such as in cases where the font size is very large). So we select
 // the longest item (which should be the last item), and size it that way.
 int sel = combo->GetSelection();
 combo->SetSelection( combo->GetCount() - 1 );
 
 combo->SetMinSize( wxSize( -1, -1 ) );
 wxSize bestSize = combo->GetBestSize();
 
 bestSize.x = bestSize.x + m_colorSwatchesSize.x;
 combo->SetMinSize( bestSize );
 combo->SetSelection( sel );
 
 // add the wxBitmapComboBox to wxControl list, to be able to disconnect the event
 // on exit
 m_controlItemsList.push_back( combo );
 
 combo->Connect( wxEVT_COMMAND_COMBOBOX_SELECTED,
 wxCommandEventHandler( PANEL_SETUP_BOARD_STACKUP::onColorSelected ),
 nullptr, this );
 
 combo->Bind( wxEVT_COMBOBOX_DROPDOWN,
 [combo]( wxCommandEvent& aEvent )
 {
 combo->SetString( combo->GetCount() - 1, _( "Custom..." ) );
 } );
 
 return combo;
}

References _, BS_ITEM_TYPE_SILKSCREEN, LAYER_SELECTOR::DrawColorSwatch(), BOARD_STACKUP_ITEM::GetColor(), GetStandardColor(), GetStandardColorCount(), GetStandardColorName(), BOARD_STACKUP_ITEM::GetType(), ID_ITEM_COLOR, IsCustomColorIdx(), m_colorSwatchesSize, m_controlItemsList, PANEL_SETUP_BOARD_STACKUP_BASE::m_scGridWin, and onColorSelected().

Referenced by createRowData().

createRowData()

BOARD_STACKUP_ROW_UI_ITEM PANEL_SETUP_BOARD_STACKUP::createRowData ( int  aRow, BOARD_STACKUP_ITEM *  aStackupItem, int  aSublayerIdx  )

private

Creates a BOARD_STACKUP_ROW_UI_ITEM relative to the aStackupItem.

Returns

a BOARD_STACKUP_ROW_UI_ITEM filled with corresponding widgets

Parameters

aRow	is the row index in the row list
aStackupItem	is the stackup item controlled by the created BOARD_STACKUP_ROW_UI_ITEM.
aSublayerIdx	is used only for BS_ITEM_TYPE_DIELECTRIC stackup items. this is the index of the sublayer to used inside aStackupItem (from 0 to sub layer count - 1)

Definition at line 779 of file panel_board_stackup.cpp.

{
 wxASSERT( aStackupItem );
 wxASSERT( aSublayerIdx >= 0 && aSublayerIdx < aStackupItem->GetSublayersCount() );
 
 BOARD_STACKUP_ROW_UI_ITEM ui_row_item( aStackupItem, aSublayerIdx );
 BOARD_STACKUP_ITEM* item = aStackupItem;
 int row = aRow;
 
 // Add color swatch icon. The color will be updated later,
 // when all widgets are initialized
 wxStaticBitmap* bitmap = new wxStaticBitmap( m_scGridWin, wxID_ANY, wxNullBitmap );
 m_fgGridSizer->Add( bitmap, 0, wxRIGHT|wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT, 4 );
 ui_row_item.m_Icon = bitmap;
 
 ui_row_item.m_isEnabled = true;
 
 if( item->GetType() == BS_ITEM_TYPE_DIELECTRIC )
 {
 wxString lname = item->FormatDielectricLayerName();
 
 if( item->GetSublayersCount() > 1 )
 {
 lname << wxT( " (" ) << aSublayerIdx+1 << wxT( "/" )
 << item->GetSublayersCount() << wxT( ")" );
 }
 
 wxStaticText* st_text = new wxStaticText( m_scGridWin, wxID_ANY, lname );
 m_fgGridSizer->Add( st_text, 0, wxRIGHT|wxALIGN_CENTER_VERTICAL, 2 );
 ui_row_item.m_LayerName = st_text;
 
 // For a dielectric layer, the layer type choice is not for each sublayer,
 // only for the first (aSublayerIdx = 0), and is common to all sublayers
 if( aSublayerIdx == 0 )
 {
 wxChoice* choice = new wxChoice( m_scGridWin, wxID_ANY, wxDefaultPosition,
 wxDefaultSize, m_core_prepreg_choice );
 choice->SetSelection( item->GetTypeName() == KEY_CORE ? 0 : 1 );
 m_fgGridSizer->Add( choice, 1, wxEXPAND|wxLEFT|wxRIGHT|wxALIGN_CENTER_VERTICAL, 2 );
 
 ui_row_item.m_LayerTypeCtrl = choice;
 }
 else
 {
 ui_row_item.m_LayerTypeCtrl = addSpacer();
 }
 }
 else
 {
 item->SetLayerName( m_board->GetLayerName( item->GetBrdLayerId() ) );
 wxStaticText* st_text = new wxStaticText( m_scGridWin, wxID_ANY, item->GetLayerName() );
 m_fgGridSizer->Add( st_text, 0, wxLEFT|wxRIGHT|wxALIGN_CENTER_VERTICAL, 1 );
 st_text->Show( true );
 ui_row_item.m_LayerName = st_text;
 
 wxString lname;
 
 if( item->GetTypeName() == KEY_COPPER )
 lname = _( "Copper" );
 else
 lname = wxGetTranslation( item->GetTypeName() );
 
 st_text = new wxStaticText( m_scGridWin, wxID_ANY, lname );
 m_fgGridSizer->Add( st_text, 0, wxLEFT|wxRIGHT|wxALIGN_CENTER_VERTICAL, 2 );
 ui_row_item.m_LayerTypeCtrl = st_text;
 }
 
 if( item->IsMaterialEditable() )
 {
 wxString matName = item->GetMaterial( aSublayerIdx );
 addMaterialChooser( ID_ITEM_MATERIAL+row, &matName, ui_row_item );
 }
 else
 {
 ui_row_item.m_MaterialCtrl = addSpacer();
 }
 
 if( item->IsThicknessEditable() )
 {
 wxTextCtrl* textCtrl = new wxTextCtrl( m_scGridWin, ID_ITEM_THICKNESS+row );
 textCtrl->SetMinSize( m_numericTextCtrlSize );
 textCtrl->ChangeValue( m_frame->StringFromValue( item->GetThickness( aSublayerIdx ), true ) );
 m_fgGridSizer->Add( textCtrl, 0, wxLEFT|wxRIGHT|wxALIGN_CENTER_VERTICAL, 2 );
 m_controlItemsList.push_back( textCtrl );
 textCtrl->Connect( wxEVT_COMMAND_TEXT_UPDATED,
 wxCommandEventHandler( PANEL_SETUP_BOARD_STACKUP::onThicknessChange ),
 nullptr, this );
 ui_row_item.m_ThicknessCtrl = textCtrl;
 
 if( item->GetType() == BS_ITEM_TYPE_DIELECTRIC )
 {
 wxCheckBox* cb_box = new wxCheckBox( m_scGridWin, ID_ITEM_THICKNESS_LOCKED+row,
 wxEmptyString );
 cb_box->SetValue( item->IsThicknessLocked( aSublayerIdx ) );
 m_fgGridSizer->Add( cb_box, 0, wxALIGN_CENTER_VERTICAL, 2 );
 ui_row_item.m_ThicknessLockCtrl = cb_box;
 }
 else
 {
 ui_row_item.m_ThicknessLockCtrl = addSpacer();
 }
 }
 else
 {
 ui_row_item.m_ThicknessCtrl = addSpacer();
 ui_row_item.m_ThicknessLockCtrl = addSpacer();
 }
 
 if( item->IsColorEditable() )
 {
 if( item->GetColor( aSublayerIdx ).StartsWith( wxT( "#" ) ) ) // User defined color
 {
 ui_row_item.m_UserColor = COLOR4D( item->GetColor( aSublayerIdx ) ).ToColour();
 }
 else
 ui_row_item.m_UserColor = GetDefaultUserColor( item->GetType() );
 
 wxBitmapComboBox* bm_combo = createColorBox( item, row );
 int selected = 0; // The "not specified" item
 
 m_fgGridSizer->Add( bm_combo, 1, wxLEFT|wxRIGHT|wxALIGN_CENTER_VERTICAL|wxEXPAND, 2 );
 
 if( item->GetColor( aSublayerIdx ).StartsWith( wxT( "#" ) ) )
 {
 selected = GetColorUserDefinedListIdx( item->GetType() );
 bm_combo->SetString( selected, item->GetColor( aSublayerIdx ) );
 }
 else
 {
 // Note: don't use bm_combo->FindString() because the combo strings are translated.
 for( int ii = 0; ii < GetStandardColorCount( item->GetType()); ii++ )
 {
 if( GetStandardColorName( item->GetType(), ii ) == item->GetColor( aSublayerIdx ) )
 {
 selected = ii;
 break;
 }
 }
 }
 
 bm_combo->SetSelection( selected );
 ui_row_item.m_ColorCtrl = bm_combo;
 }
 else
 {
 ui_row_item.m_ColorCtrl = addSpacer();
 }
 
 if( item->HasEpsilonRValue() )
 {
 wxString txt = UIDouble2Str( item->GetEpsilonR( aSublayerIdx ) );
 wxTextCtrl* textCtrl = new wxTextCtrl( m_scGridWin, wxID_ANY, wxEmptyString,
 wxDefaultPosition, m_numericFieldsSize );
 textCtrl->ChangeValue( txt );
 m_fgGridSizer->Add( textCtrl, 0, wxLEFT|wxRIGHT|wxALIGN_CENTER_VERTICAL, 2 );
 ui_row_item.m_EpsilonCtrl = textCtrl;
 }
 else
 {
 ui_row_item.m_EpsilonCtrl = addSpacer();
 }
 
 if( item->HasLossTangentValue() )
 {
 wxString txt = UIDouble2Str( item->GetLossTangent( aSublayerIdx ) );;
 wxTextCtrl* textCtrl = new wxTextCtrl( m_scGridWin, wxID_ANY, wxEmptyString,
 wxDefaultPosition, m_numericFieldsSize );
 textCtrl->ChangeValue( txt );
 m_fgGridSizer->Add( textCtrl, 0, wxLEFT|wxRIGHT|wxALIGN_CENTER_VERTICAL, 2 );
 ui_row_item.m_LossTgCtrl = textCtrl;
 }
 else
 {
 ui_row_item.m_LossTgCtrl = addSpacer();
 }
 
 return ui_row_item;
}

References _, addMaterialChooser(), addSpacer(), BS_ITEM_TYPE_DIELECTRIC, createColorBox(), BOARD_STACKUP_ITEM::FormatDielectricLayerName(), BOARD_STACKUP_ITEM::GetBrdLayerId(), BOARD_STACKUP_ITEM::GetColor(), GetColorUserDefinedListIdx(), GetDefaultUserColor(), BOARD_STACKUP_ITEM::GetEpsilonR(), BOARD_STACKUP_ITEM::GetLayerName(), BOARD::GetLayerName(), BOARD_STACKUP_ITEM::GetLossTangent(), BOARD_STACKUP_ITEM::GetMaterial(), GetStandardColorCount(), GetStandardColorName(), BOARD_STACKUP_ITEM::GetSublayersCount(), BOARD_STACKUP_ITEM::GetThickness(), BOARD_STACKUP_ITEM::GetType(), BOARD_STACKUP_ITEM::GetTypeName(), BOARD_STACKUP_ITEM::HasEpsilonRValue(), BOARD_STACKUP_ITEM::HasLossTangentValue(), ID_ITEM_MATERIAL, ID_ITEM_THICKNESS, ID_ITEM_THICKNESS_LOCKED, BOARD_STACKUP_ITEM::IsColorEditable(), BOARD_STACKUP_ITEM::IsMaterialEditable(), BOARD_STACKUP_ITEM::IsThicknessEditable(), BOARD_STACKUP_ITEM::IsThicknessLocked(), KEY_COPPER, KEY_CORE, m_board, BOARD_STACKUP_ROW_UI_ITEM::m_ColorCtrl, m_controlItemsList, m_core_prepreg_choice, BOARD_STACKUP_ROW_UI_ITEM::m_EpsilonCtrl, PANEL_SETUP_BOARD_STACKUP_BASE::m_fgGridSizer, m_frame, BOARD_STACKUP_ROW_UI_ITEM::m_Icon, BOARD_STACKUP_ROW_UI_ITEM::m_isEnabled, BOARD_STACKUP_ROW_UI_ITEM::m_LayerName, BOARD_STACKUP_ROW_UI_ITEM::m_LayerTypeCtrl, BOARD_STACKUP_ROW_UI_ITEM::m_LossTgCtrl, BOARD_STACKUP_ROW_UI_ITEM::m_MaterialCtrl, m_numericFieldsSize, m_numericTextCtrlSize, PANEL_SETUP_BOARD_STACKUP_BASE::m_scGridWin, BOARD_STACKUP_ROW_UI_ITEM::m_ThicknessCtrl, BOARD_STACKUP_ROW_UI_ITEM::m_ThicknessLockCtrl, BOARD_STACKUP_ROW_UI_ITEM::m_UserColor, onThicknessChange(), BOARD_STACKUP_ITEM::SetLayerName(), UNITS_PROVIDER::StringFromValue(), and UIDouble2Str().

Referenced by buildLayerStackPanel().

disconnectEvents()

void PANEL_SETUP_BOARD_STACKUP::disconnectEvents ( )

private

disconnect event handlers connected to wxControl items found in list m_controlItemsList

Definition at line 215 of file panel_board_stackup.cpp.

{
 // Disconnect Events connected to items in m_controlItemsList
 for( wxControl* item: m_controlItemsList )
 {
 wxBitmapComboBox* cb = dynamic_cast<wxBitmapComboBox*>( item );
 
 if( cb )
 {
 cb->Disconnect( wxEVT_COMMAND_COMBOBOX_SELECTED,
 wxCommandEventHandler( PANEL_SETUP_BOARD_STACKUP::onColorSelected ),
 nullptr, this );
 }
 
 wxButton* matButt = dynamic_cast<wxButton*>( item );
 
 if( matButt )
 {
 matButt->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED,
 wxCommandEventHandler( PANEL_SETUP_BOARD_STACKUP::onMaterialChange ),
 nullptr, this );
 }
 
 wxTextCtrl* textCtrl = dynamic_cast<wxTextCtrl*>( item );
 
 if( textCtrl )
 {
 textCtrl->Disconnect( wxEVT_COMMAND_TEXT_UPDATED,
 wxCommandEventHandler( PANEL_SETUP_BOARD_STACKUP::onThicknessChange ),
 nullptr, this );
 }
 }
}

References m_controlItemsList, onColorSelected(), onMaterialChange(), and onThicknessChange().

Referenced by rebuildLayerStackPanel(), and ~PANEL_SETUP_BOARD_STACKUP().

getColorIconItem()

wxColor PANEL_SETUP_BOARD_STACKUP::getColorIconItem ( int  aRow )

private

Returns

the color of the BOARD_STACKUP_ITEM at row aRow, to draw a bitmap color according to the selected color or the best default color (for dielectric or copper item)

Parameters

aRow	is the row index to find the color.

Definition at line 1526 of file panel_board_stackup.cpp.

{
 BOARD_STACKUP_ITEM* st_item = dynamic_cast<BOARD_STACKUP_ITEM*>( GetStackupItem( aRow ) );
 
 wxASSERT( st_item );
 wxColor color;
 
 if( ! st_item )
 return color;
 
 switch( st_item->GetType() )
 {
 case BS_ITEM_TYPE_COPPER: color = copperColor; break;
 case BS_ITEM_TYPE_DIELECTRIC: color = dielectricColor; break;
 case BS_ITEM_TYPE_SOLDERMASK: color = GetSelectedColor( aRow ); break;
 case BS_ITEM_TYPE_SILKSCREEN: color = GetSelectedColor( aRow ); break;
 case BS_ITEM_TYPE_SOLDERPASTE: color = pasteColor; break;
 
 default:
 case BS_ITEM_TYPE_UNDEFINED:
 wxFAIL_MSG( wxT( "PANEL_SETUP_BOARD_STACKUP::getColorIconItem: unrecognized item type" ) );
 break;
 }
 
 wxASSERT_MSG( color.IsOk(), wxT( "Invalid color in PCB stackup" ) );
 
 return color;
}

References BS_ITEM_TYPE_COPPER, BS_ITEM_TYPE_DIELECTRIC, BS_ITEM_TYPE_SILKSCREEN, BS_ITEM_TYPE_SOLDERMASK, BS_ITEM_TYPE_SOLDERPASTE, BS_ITEM_TYPE_UNDEFINED, color, copperColor(), dielectricColor(), GetSelectedColor(), GetStackupItem(), BOARD_STACKUP_ITEM::GetType(), and pasteColor().

Referenced by updateIconColor().

GetCopperLayerCount()

int PANEL_SETUP_BOARD_STACKUP::GetCopperLayerCount

(

)

const

Returns

the number of copper layers configured for the board stackup

Definition at line 557 of file panel_board_stackup.cpp.

{
 return ( m_choiceCopperLayers->GetSelection() + 1 ) * 2;
}

References PANEL_SETUP_BOARD_STACKUP_BASE::m_choiceCopperLayers.

Referenced by DIALOG_BOARD_SETUP::onPageChanged(), setDefaultLayerWidths(), PANEL_SETUP_LAYERS::TransferDataFromWindow(), and updateCopperLayerCount().

GetSelectedColor()

wxColor PANEL_SETUP_BOARD_STACKUP::GetSelectedColor

(

int

aRow

)

const

Return the color currently selected for the row aRow.

Definition at line 408 of file panel_board_stackup.cpp.

{
 const BOARD_STACKUP_ROW_UI_ITEM& row = m_rowUiItemsList[aRow];
 const BOARD_STACKUP_ITEM* item = row.m_Item;
 const wxBitmapComboBox* choice = dynamic_cast<wxBitmapComboBox*>( row.m_ColorCtrl );
 wxASSERT( choice );
 
 int idx = choice ? choice->GetSelection() : 0;
 
 if( IsCustomColorIdx( item->GetType(), idx ) )
 return m_rowUiItemsList[aRow].m_UserColor.ToColour();
 else
 return GetStandardColor( item->GetType(), idx ).ToColour();
}

References GetStandardColor(), BOARD_STACKUP_ITEM::GetType(), IsCustomColorIdx(), BOARD_STACKUP_ROW_UI_ITEM::m_ColorCtrl, BOARD_STACKUP_ROW_UI_ITEM::m_Item, and m_rowUiItemsList.

Referenced by getColorIconItem().

GetStackup()

BOARD_STACKUP & PANEL_SETUP_BOARD_STACKUP::GetStackup ( )

inline

Definition at line 115 of file panel_board_stackup.h.

{ return m_stackup; }

References m_stackup.

GetStackupItem()

BOARD_STACKUP_ITEM * PANEL_SETUP_BOARD_STACKUP::GetStackupItem

(

int

aRow

)

Returns

the BOARD_STACKUP_ITEM managed by the row aRow

Definition at line 1514 of file panel_board_stackup.cpp.

{
 return m_rowUiItemsList[aRow].m_Item;
}

References m_rowUiItemsList.

Referenced by getColorIconItem(), and onThicknessChange().

GetSublayerId()

int PANEL_SETUP_BOARD_STACKUP::GetSublayerId

(

int

aRow

)

Returns

the BOARD_STACKUP_ITEM sublayermanaged by the row aRow

Definition at line 1520 of file panel_board_stackup.cpp.

{
 return m_rowUiItemsList[aRow].m_SubItem;
}

References m_rowUiItemsList.

Referenced by onThicknessChange().

ImportSettingsFrom()

void PANEL_SETUP_BOARD_STACKUP::ImportSettingsFrom

(

BOARD *

aBoard

)

Definition at line 1294 of file panel_board_stackup.cpp.

{
 BOARD* savedBrd = m_board;
 m_board = aBoard;
 
 BOARD_DESIGN_SETTINGS* savedSettings = m_brdSettings;
 m_brdSettings = &aBoard->GetDesignSettings();
 
 m_enabledLayers = m_board->GetEnabledLayers() & BOARD_STACKUP::StackupAllowedBrdLayers();
 
 rebuildLayerStackPanel();
 synchronizeWithBoard( true );
 computeBoardThickness();
 
 m_brdSettings = savedSettings;
 m_board = savedBrd;
}

References computeBoardThickness(), BOARD::GetDesignSettings(), BOARD::GetEnabledLayers(), m_board, m_brdSettings, m_enabledLayers, rebuildLayerStackPanel(), BOARD_STACKUP::StackupAllowedBrdLayers(), and synchronizeWithBoard().

Referenced by DIALOG_BOARD_SETUP::onAuxiliaryAction().

onAddDielectricLayer()

void PANEL_SETUP_BOARD_STACKUP::onAddDielectricLayer ( wxCommandEvent &  event )

overrideprivatevirtual

Reimplemented from PANEL_SETUP_BOARD_STACKUP_BASE.

Definition at line 250 of file panel_board_stackup.cpp.

{
 wxArrayString headers;
 headers.Add( _( "Layers" ) );
 
 // Build Dielectric layers list:
 std::vector<wxArrayString> d_list;
 std::vector<int> rows; // indexes of row values for each selectable item
 int row = -1;
 
 for( BOARD_STACKUP_ROW_UI_ITEM& item : m_rowUiItemsList )
 {
 row++;
 
 if( !item.m_isEnabled )
 continue;
 
 BOARD_STACKUP_ITEM* brd_stackup_item = item.m_Item;
 
 if( brd_stackup_item->GetType() == BS_ITEM_TYPE_DIELECTRIC )
 {
 wxArrayString d_item;
 
 if( brd_stackup_item->GetSublayersCount() > 1 )
 {
 d_item.Add( wxString::Format( _( "Layer '%s' (sublayer %d/%d)" ),
 brd_stackup_item->FormatDielectricLayerName(),
 item.m_SubItem+1,
 brd_stackup_item->GetSublayersCount() ) );
 }
 else
 {
 d_item.Add( brd_stackup_item->FormatDielectricLayerName() );
 }
 
 d_list.emplace_back( d_item );
 rows.push_back( row );
 }
 }
 
 EDA_LIST_DIALOG dlg( m_parentDialog, _( "Add Dielectric Layer" ), headers, d_list,
 wxEmptyString, false /* do not sort the list: it is **expected** in stack order */);
 dlg.SetListLabel( _( "Select layer to add:" ) );
 dlg.HideFilter();
 
 if( dlg.ShowModal() == wxID_OK && dlg.GetSelection() >= 0 )
 {
 row = rows[ dlg.GetSelection() ];
 
 BOARD_STACKUP_ITEM* brd_stackup_item = m_rowUiItemsList[row].m_Item;
 int new_sublayer = m_rowUiItemsList[row].m_SubItem;
 
 // Insert a new item after the selected item
 brd_stackup_item->AddDielectricPrms( new_sublayer+1 );
 
 rebuildLayerStackPanel();
 computeBoardThickness();
 }
}

References _, BOARD_STACKUP_ITEM::AddDielectricPrms(), BS_ITEM_TYPE_DIELECTRIC, computeBoardThickness(), Format(), BOARD_STACKUP_ITEM::FormatDielectricLayerName(), EDA_LIST_DIALOG::GetSelection(), BOARD_STACKUP_ITEM::GetSublayersCount(), BOARD_STACKUP_ITEM::GetType(), EDA_LIST_DIALOG::HideFilter(), m_parentDialog, m_rowUiItemsList, rebuildLayerStackPanel(), and EDA_LIST_DIALOG::SetListLabel().

onAdjustDielectricThickness()

void PANEL_SETUP_BOARD_STACKUP::onAdjustDielectricThickness ( wxCommandEvent &  event )

overrideprivatevirtual

Reimplemented from PANEL_SETUP_BOARD_STACKUP_BASE.

Definition at line 142 of file panel_board_stackup.cpp.

{
 // The list of items that can be modified:
 std::vector< BOARD_STACKUP_ROW_UI_ITEM* > items_candidate;
 
 // Some dielectric layers can have a locked thickness, so calculate the min
 // acceptable thickness
 int min_thickness = 0;
 
 for( BOARD_STACKUP_ROW_UI_ITEM& ui_item : m_rowUiItemsList )
 {
 BOARD_STACKUP_ITEM* item = ui_item.m_Item;
 
 if( !item->IsThicknessEditable() || !ui_item.m_isEnabled )
 continue;
 
 // We are looking for locked thickness items only:
 wxCheckBox* cb_box = dynamic_cast<wxCheckBox*> ( ui_item.m_ThicknessLockCtrl );
 
 if( cb_box && !cb_box->GetValue() )
 {
 items_candidate.push_back( &ui_item );
 continue;
 }
 
 wxTextCtrl* textCtrl = static_cast<wxTextCtrl*>( ui_item.m_ThicknessCtrl );
 
 int item_thickness = m_frame->ValueFromString( textCtrl->GetValue() );
 min_thickness += item_thickness;
 }
 
 wxString title;
 
 if( min_thickness == 0 )
 {
 title.Printf( _( "Enter board thickness in %s:" ),
 EDA_UNIT_UTILS::GetText( m_frame->GetUserUnits() ).Trim( false ) );
 }
 else
 {
 title.Printf( _( "Enter expected board thickness (min value %s):" ),
 m_frame->StringFromValue( min_thickness, true ) );
 }
 
 wxTextEntryDialog dlg( this, title, _( "Adjust Unlocked Dielectric Layers" ) );
 
 if( dlg.ShowModal() != wxID_OK )
 return;
 
 int iu_thickness = m_frame->ValueFromString( dlg.GetValue() );
 
 if( iu_thickness < min_thickness )
 {
 wxMessageBox( wxString::Format( _("Value too small (min value %s)." ),
 m_frame->StringFromValue( min_thickness, true ) ) );
 return;
 }
 
 // Now adjust not locked dielectric thickness layers:
 
 if( items_candidate.size() )
 {
 setDefaultLayerWidths( iu_thickness );
 }
 else
 {
 wxMessageBox( _( "All dielectric thickness layers are locked" ) );
 }
 
 computeBoardThickness();
}

References _, computeBoardThickness(), Format(), EDA_UNIT_UTILS::GetText(), UNITS_PROVIDER::GetUserUnits(), BOARD_STACKUP_ITEM::IsThicknessEditable(), m_frame, m_rowUiItemsList, setDefaultLayerWidths(), UNITS_PROVIDER::StringFromValue(), and UNITS_PROVIDER::ValueFromString().

onColorSelected()

void PANEL_SETUP_BOARD_STACKUP::onColorSelected ( wxCommandEvent &  event )

private

Definition at line 1335 of file panel_board_stackup.cpp.

{
 int idx = event.GetSelection();
 int item_id = event.GetId();
 int row = item_id - ID_ITEM_COLOR;
 BOARD_STACKUP_ITEM* item = m_rowUiItemsList[row].m_Item;
 
 if( idx == GetStandardColorCount( item->GetType()) - 1 ) // Set user color is the last option in list
 {
 DIALOG_COLOR_PICKER dlg( this, m_rowUiItemsList[row].m_UserColor, true, nullptr,
 GetDefaultUserColor( m_rowUiItemsList[row].m_Item->GetType() ) );
 
#ifdef __WXGTK__
 // Give a time-slice to close the menu before opening the dialog.
 // (Only matters on some versions of GTK.)
 wxSafeYield();
#endif
 
 if( dlg.ShowModal() == wxID_OK )
 {
 wxBitmapComboBox* combo = static_cast<wxBitmapComboBox*>( FindWindowById( item_id ) );
 COLOR4D color = dlg.GetColor();
 
 m_rowUiItemsList[row].m_UserColor = color;
 
 combo->SetString( idx, color.ToHexString() );
 
 wxBitmap layerbmp( m_colorSwatchesSize.x, m_colorSwatchesSize.y );
 LAYER_SELECTOR::DrawColorSwatch( layerbmp, COLOR4D( 0, 0, 0, 0 ), color );
 combo->SetItemBitmap( combo->GetCount() - 1, layerbmp );
 
 combo->SetSelection( idx );
 }
 }
 
 updateIconColor( row );
}

References color, LAYER_SELECTOR::DrawColorSwatch(), DIALOG_COLOR_PICKER::GetColor(), GetDefaultUserColor(), GetStandardColorCount(), BOARD_STACKUP_ITEM::GetType(), ID_ITEM_COLOR, m_colorSwatchesSize, m_rowUiItemsList, and updateIconColor().

Referenced by createColorBox(), and disconnectEvents().

onCopperLayersSelCount()

void PANEL_SETUP_BOARD_STACKUP::onCopperLayersSelCount ( wxCommandEvent &  event )

overrideprivatevirtual

Reimplemented from PANEL_SETUP_BOARD_STACKUP_BASE.

Definition at line 131 of file panel_board_stackup.cpp.

{
 int oldBoardWidth = static_cast<int>( m_frame->ValueFromString( m_tcCTValue->GetValue() ) );
 updateCopperLayerCount();
 showOnlyActiveLayers();
 setDefaultLayerWidths( oldBoardWidth );
 computeBoardThickness();
 Layout();
}

References computeBoardThickness(), m_frame, PANEL_SETUP_BOARD_STACKUP_BASE::m_tcCTValue, setDefaultLayerWidths(), showOnlyActiveLayers(), updateCopperLayerCount(), and UNITS_PROVIDER::ValueFromString().

onExportToClipboard()

void PANEL_SETUP_BOARD_STACKUP::onExportToClipboard ( wxCommandEvent &  event )

overrideprivatevirtual

Reimplemented from PANEL_SETUP_BOARD_STACKUP_BASE.

Definition at line 387 of file panel_board_stackup.cpp.

{
 if( !transferDataFromUIToStackup() )
 return;
 
 // Build a ASCII representation of stackup and copy it in the clipboard
 wxString report = BuildStackupReport( m_stackup, m_frame->GetUserUnits() );
 
 wxLogNull doNotLog; // disable logging of failed clipboard actions
 
 if( wxTheClipboard->Open() )
 {
 // This data objects are held by the clipboard,
 // so do not delete them in the app.
 wxTheClipboard->SetData( new wxTextDataObject( report ) );
 wxTheClipboard->Flush(); // Allow data to be available after closing KiCad
 wxTheClipboard->Close();
 }
}

References BuildStackupReport(), UNITS_PROVIDER::GetUserUnits(), m_frame, m_stackup, and transferDataFromUIToStackup().

OnLayersOptionsChanged()

void PANEL_SETUP_BOARD_STACKUP::OnLayersOptionsChanged

(

LSET

aNewLayerSet

)

Must be called if the copper layers count has changed or solder mask, solder paste or silkscreen layers are enabled or disabled Rebuild the Layer Stack Panel if the new layer set differs from the current layet set.

Definition at line 1313 of file panel_board_stackup.cpp.

{
 // First, verify the list of layers currently in stackup:
 // if it does not mach the list of layers set in PANEL_SETUP_LAYERS
 // rebuild the panel
 
 // the current enabled layers in PANEL_SETUP_LAYERS
 // Note: the number of layer can change, but not the layers properties
 LSET layersList = m_panelLayers->GetUILayerMask() & BOARD_STACKUP::StackupAllowedBrdLayers();
 
 if( m_enabledLayers != layersList )
 {
 m_enabledLayers = layersList;
 
 synchronizeWithBoard( false );
 
  Layout();
 Refresh();
 }
}

References PANEL_SETUP_LAYERS::GetUILayerMask(), m_enabledLayers, m_panelLayers, Refresh(), BOARD_STACKUP::StackupAllowedBrdLayers(), and synchronizeWithBoard().

Referenced by DIALOG_BOARD_SETUP::onPageChanged().

onMaterialChange()

void PANEL_SETUP_BOARD_STACKUP::onMaterialChange ( wxCommandEvent &  event )

private

Definition at line 1374 of file panel_board_stackup.cpp.

{
 // Ensure m_materialList contains all materials already in use in stackup list
 // and add it is missing
 if( !transferDataFromUIToStackup() )
 return;
 
 for( BOARD_STACKUP_ITEM* item : m_stackup.GetList() )
 {
 DIELECTRIC_SUBSTRATE_LIST* mat_list = nullptr;
 
 if( item->GetType() == BS_ITEM_TYPE_DIELECTRIC )
 mat_list = &m_delectricMatList;
 else if( item->GetType() == BS_ITEM_TYPE_SOLDERMASK )
 mat_list = &m_solderMaskMatList;
 else if( item->GetType() == BS_ITEM_TYPE_SILKSCREEN )
 mat_list = &m_silkscreenMatList;
 
 else
 continue;
 
 for( int ii = 0; ii < item->GetSublayersCount(); ii++ )
 {
 int idx = mat_list->FindSubstrate( item->GetMaterial( ii ),
 item->GetEpsilonR( ii ),
 item->GetLossTangent( ii ) );
 
 if( idx < 0 && !item->GetMaterial().IsEmpty() )
 {
 // This material is not in list: add it
 DIELECTRIC_SUBSTRATE new_mat;
 new_mat.m_Name = item->GetMaterial( ii );
 new_mat.m_EpsilonR = item->GetEpsilonR( ii );
 new_mat.m_LossTangent = item->GetLossTangent( ii );
 mat_list->AppendSubstrate( new_mat );
 }
 }
 }
 
 int row = event.GetId() - ID_ITEM_MATERIAL;
 BOARD_STACKUP_ITEM* item = m_rowUiItemsList[row].m_Item;
 int sub_item = m_rowUiItemsList[row].m_SubItem;
 DIELECTRIC_SUBSTRATE_LIST* item_mat_list = nullptr;
 
 switch( item->GetType() )
 {
 case BS_ITEM_TYPE_DIELECTRIC: item_mat_list = &m_delectricMatList; break;
 case BS_ITEM_TYPE_SOLDERMASK: item_mat_list = &m_solderMaskMatList; break;
 case BS_ITEM_TYPE_SILKSCREEN: item_mat_list = &m_silkscreenMatList; break;
 default: item_mat_list = nullptr; break;
 }
 
 wxCHECK( item_mat_list, /* void */ );
 
 DIALOG_DIELECTRIC_MATERIAL dlg( this, *item_mat_list );
 
 if( dlg.ShowModal() != wxID_OK )
 return;
 
 DIELECTRIC_SUBSTRATE substrate = dlg.GetSelectedSubstrate();
 
 if( substrate.m_Name.IsEmpty() ) // No substrate specified
 return;
 
 // Update Name, Epsilon R and Loss tg
 item->SetMaterial( substrate.m_Name, sub_item );
 item->SetEpsilonR( substrate.m_EpsilonR, sub_item );
 item->SetLossTangent( substrate.m_LossTangent, sub_item );
 
 wxTextCtrl* textCtrl = static_cast<wxTextCtrl*>( m_rowUiItemsList[row].m_MaterialCtrl );
 textCtrl->ChangeValue( item->GetMaterial( sub_item ) );
 
 if( item->GetType() == BS_ITEM_TYPE_DIELECTRIC
 && !item->GetColor( sub_item ).StartsWith( "#" ) /* User defined color */ )
 {
 if( substrate.m_Name.IsSameAs( "PTFE" )
 || substrate.m_Name.IsSameAs( "Teflon" ) )
 {
 item->SetColor( "PTFE natural", sub_item );
 }
 else if( substrate.m_Name.IsSameAs( "Polyimide" )
 || substrate.m_Name.IsSameAs( "Kapton" ) )
 {
 item->SetColor( "Polyimide", sub_item );
 }
 else if( substrate.m_Name.IsSameAs( "Al" ) )
 {
 item->SetColor( "Aluminum", sub_item );
 }
 else
 {
 item->SetColor( "FR4 natural", sub_item );
 }
 }
 
 wxBitmapComboBox* picker = static_cast<wxBitmapComboBox*>( m_rowUiItemsList[row].m_ColorCtrl );
 
 for( int ii = 0; ii < GetStandardColorCount( item->GetType()); ii++ )
 {
 if( GetStandardColorName( item->GetType(), ii ) == item->GetColor( sub_item ) )
 {
 picker->SetSelection( ii );
 break;
 }
 }
 
 // some layers have a material choice but not EpsilonR ctrl
 if( item->HasEpsilonRValue() )
 {
 textCtrl = dynamic_cast<wxTextCtrl*>( m_rowUiItemsList[row].m_EpsilonCtrl );
 
 if( textCtrl )
 textCtrl->ChangeValue( item->FormatEpsilonR( sub_item ) );
 }
 
 // some layers have a material choice but not loss tg ctrl
 if( item->HasLossTangentValue() )
 {
 textCtrl = dynamic_cast<wxTextCtrl*>( m_rowUiItemsList[row].m_LossTgCtrl );
 
 if( textCtrl )
 textCtrl->ChangeValue( item->FormatLossTangent( sub_item ) );
 }
}

References DIELECTRIC_SUBSTRATE_LIST::AppendSubstrate(), BS_ITEM_TYPE_DIELECTRIC, BS_ITEM_TYPE_SILKSCREEN, BS_ITEM_TYPE_SOLDERMASK, DIELECTRIC_SUBSTRATE_LIST::FindSubstrate(), BOARD_STACKUP_ITEM::FormatEpsilonR(), BOARD_STACKUP_ITEM::FormatLossTangent(), BOARD_STACKUP_ITEM::GetColor(), BOARD_STACKUP::GetList(), BOARD_STACKUP_ITEM::GetMaterial(), DIALOG_DIELECTRIC_MATERIAL::GetSelectedSubstrate(), GetStandardColorCount(), GetStandardColorName(), BOARD_STACKUP_ITEM::GetType(), BOARD_STACKUP_ITEM::HasEpsilonRValue(), BOARD_STACKUP_ITEM::HasLossTangentValue(), ID_ITEM_MATERIAL, m_delectricMatList, DIELECTRIC_SUBSTRATE::m_EpsilonR, DIELECTRIC_SUBSTRATE::m_LossTangent, DIELECTRIC_SUBSTRATE::m_Name, m_rowUiItemsList, m_silkscreenMatList, m_solderMaskMatList, m_stackup, BOARD_STACKUP_ITEM::SetColor(), BOARD_STACKUP_ITEM::SetEpsilonR(), BOARD_STACKUP_ITEM::SetLossTangent(), BOARD_STACKUP_ITEM::SetMaterial(), and transferDataFromUIToStackup().

Referenced by addMaterialChooser(), and disconnectEvents().

onRemoveDielectricLayer()

void PANEL_SETUP_BOARD_STACKUP::onRemoveDielectricLayer ( wxCommandEvent &  event )

overrideprivatevirtual

Reimplemented from PANEL_SETUP_BOARD_STACKUP_BASE.

Definition at line 311 of file panel_board_stackup.cpp.

{
 wxArrayString headers;
 headers.Add( _( "Layers" ) );
 
 // Build deletable Dielectric layers list.
 // A layer can be deleted if there are 2 (or more) dielectric sub-layers
 // between 2 copper layers
 std::vector<wxArrayString> d_list;
 std::vector<int> rows; // indexes of row values for each selectable item
 int row = 0; // row index in m_rowUiItemsList of items in choice list
 
 // Build the list of dielectric layers:
 for( BOARD_STACKUP_ITEM* item : m_stackup.GetList() )
 {
 if( !item->IsEnabled() || item->GetType() != BS_ITEM_TYPE_DIELECTRIC ||
 item->GetSublayersCount() <= 1 )
 {
 row++;
 continue;
 }
 
 for( int ii = 0; ii < item->GetSublayersCount(); ii++ )
 {
 wxArrayString d_item;
 
 d_item.Add( wxString::Format( _( "Layer '%s' sublayer %d/%d" ),
 item->FormatDielectricLayerName(),
 ii+1,
 item->GetSublayersCount() ) );
 
 d_list.emplace_back( d_item );
 rows.push_back( row++ );
 }
 }
 
 EDA_LIST_DIALOG dlg( m_parentDialog, _( "Remove Dielectric Layer" ), headers, d_list,
 wxEmptyString, false /* do not sort the list: it is **expected** in stack order */ );
 dlg.SetListLabel( _( "Select layer to remove:" ) );
 dlg.HideFilter();
 
 if( dlg.ShowModal() == wxID_OK && dlg.GetSelection() >= 0 )
 {
 row = rows[ dlg.GetSelection() ];
 BOARD_STACKUP_ITEM* brd_stackup_item = m_rowUiItemsList[ row ].m_Item;
 int sublayer = m_rowUiItemsList[ row ].m_SubItem;
 
 // Remove the selected sub item for the selected dielectric layer
 brd_stackup_item->RemoveDielectricPrms( sublayer );
 
 rebuildLayerStackPanel();
 computeBoardThickness();
 }
}

References _, BS_ITEM_TYPE_DIELECTRIC, computeBoardThickness(), Format(), BOARD_STACKUP::GetList(), EDA_LIST_DIALOG::GetSelection(), EDA_LIST_DIALOG::HideFilter(), m_parentDialog, m_rowUiItemsList, m_stackup, rebuildLayerStackPanel(), BOARD_STACKUP_ITEM::RemoveDielectricPrms(), and EDA_LIST_DIALOG::SetListLabel().

onRemoveDielUI()

void PANEL_SETUP_BOARD_STACKUP::onRemoveDielUI ( wxUpdateUIEvent &  event )

overrideprivatevirtual

Reimplemented from PANEL_SETUP_BOARD_STACKUP_BASE.

Definition at line 367 of file panel_board_stackup.cpp.

{
 // The m_buttonRemoveDielectricLayer wxButton is enabled only if a dielectric
 // layer can be removed, i.e. if dielectric layers have sublayers
 for( BOARD_STACKUP_ITEM* item : m_stackup.GetList() )
 {
 if( !item->IsEnabled() || item->GetType() != BS_ITEM_TYPE_DIELECTRIC )
 continue;
 
 if( item->GetSublayersCount() > 1 )
 {
 event.Enable( true );
 return;
 }
 }
 
 event.Enable( false );
}

References BS_ITEM_TYPE_DIELECTRIC, BOARD_STACKUP::GetList(), and m_stackup.

onThicknessChange()

void PANEL_SETUP_BOARD_STACKUP::onThicknessChange ( wxCommandEvent &  event )

private

Definition at line 1500 of file panel_board_stackup.cpp.

{
 int row = event.GetId() - ID_ITEM_THICKNESS;
 wxString value = event.GetString();
 
 BOARD_STACKUP_ITEM* item = GetStackupItem( row );
 int idx = GetSublayerId( row );
 
 item->SetThickness( m_frame->ValueFromString( value ), idx );
 
 computeBoardThickness();
}

References computeBoardThickness(), GetStackupItem(), GetSublayerId(), ID_ITEM_THICKNESS, m_frame, BOARD_STACKUP_ITEM::SetThickness(), and UNITS_PROVIDER::ValueFromString().

Referenced by createRowData(), and disconnectEvents().

rebuildLayerStackPanel()

void PANEL_SETUP_BOARD_STACKUP::rebuildLayerStackPanel ( )

private

Populate m_fgGridSizer with items to handle stackup parameters If previous items are in list, remove old items New prms are added must be called after adding or deleting a dielectric parameter set.

Definition at line 961 of file panel_board_stackup.cpp.

{
 wxWindowUpdateLocker locker( m_scGridWin );
 m_scGridWin->Hide();
 
 // Rebuild the stackup for the dialog, after dielectric parameters list is modified
 // (added/removed):
 
 // First, delete all ui objects, because wxID values will be no longer valid for many widgets
 disconnectEvents();
 m_controlItemsList.clear();
 
 // Delete widgets (handled by the wxPanel parent)
 for( BOARD_STACKUP_ROW_UI_ITEM ui_item: m_rowUiItemsList )
 {
 // This remove and delete the current ui_item.m_MaterialCtrl sizer
 ui_item.m_MaterialCtrl->SetSizer( nullptr );
 
 // Delete other widgets
 delete ui_item.m_Icon; // Color icon in first column (column 1)
 delete ui_item.m_LayerName; // string shown in column 2
 delete ui_item.m_LayerTypeCtrl; // control shown in column 3
 delete ui_item.m_MaterialCtrl; // control shown in column 4, with m_MaterialButt
 delete ui_item.m_MaterialButt; // control shown in column 4, with m_MaterialCtrl
 delete ui_item.m_ThicknessCtrl; // control shown in column 5
 delete ui_item.m_ThicknessLockCtrl;// control shown in column 6
 delete ui_item.m_ColorCtrl; // control shown in column 7
 delete ui_item.m_EpsilonCtrl; // control shown in column 8
 delete ui_item.m_LossTgCtrl; // control shown in column 9
 }
 
 m_rowUiItemsList.clear();
 
 // In order to recreate a clean grid layer list, we have to delete and
 // recreate the sizer m_fgGridSizer (just deleting items in this size is not enough)
 // therefore we also have to add the "old" title items to the newly recreated m_fgGridSizer:
 m_scGridWin->SetSizer( nullptr ); // This remove and delete the current m_fgGridSizer
 
 m_fgGridSizer = new wxFlexGridSizer( 0, 9, 0, 2 );
 m_fgGridSizer->SetFlexibleDirection( wxHORIZONTAL );
 m_fgGridSizer->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );
 m_fgGridSizer->SetHGap( 6 );
 m_scGridWin->SetSizer( m_fgGridSizer );
 
 // Re-add "old" title items:
 const int sizer_flags = wxALIGN_CENTER_VERTICAL | wxALL | wxALIGN_CENTER_HORIZONTAL;
 m_fgGridSizer->Add( m_staticTextLayer, 0, sizer_flags, 2 );
 m_fgGridSizer->Add( m_staticTextType, 0, sizer_flags, 2 );
 m_fgGridSizer->Add( m_staticTextLayerId, 0, sizer_flags, 5 );
 m_fgGridSizer->Add( m_staticTextMaterial, 0, sizer_flags, 2 );
 m_fgGridSizer->Add( m_staticTextThickness, 0, sizer_flags, 2 );
 m_fgGridSizer->Add( m_bitmapLockThickness, 0, sizer_flags, 1 );
 m_fgGridSizer->Add( m_staticTextColor, 0, sizer_flags, 2 );
 m_fgGridSizer->Add( m_staticTextEpsilonR, 0, sizer_flags, 2 );
 m_fgGridSizer->Add( m_staticTextLossTg, 0, sizer_flags, 2 );
 
 
 // Now, rebuild the widget list from the new m_stackup items:
 buildLayerStackPanel( false );
 
 // Now enable/disable stackup items, according to the m_enabledLayers config
 showOnlyActiveLayers();
 
 m_scGridWin->Layout();
 m_scGridWin->Show();
}

References buildLayerStackPanel(), disconnectEvents(), PANEL_SETUP_BOARD_STACKUP_BASE::m_bitmapLockThickness, m_controlItemsList, PANEL_SETUP_BOARD_STACKUP_BASE::m_fgGridSizer, m_rowUiItemsList, PANEL_SETUP_BOARD_STACKUP_BASE::m_scGridWin, PANEL_SETUP_BOARD_STACKUP_BASE::m_staticTextColor, PANEL_SETUP_BOARD_STACKUP_BASE::m_staticTextEpsilonR, PANEL_SETUP_BOARD_STACKUP_BASE::m_staticTextLayer, PANEL_SETUP_BOARD_STACKUP_BASE::m_staticTextLayerId, PANEL_SETUP_BOARD_STACKUP_BASE::m_staticTextLossTg, PANEL_SETUP_BOARD_STACKUP_BASE::m_staticTextMaterial, PANEL_SETUP_BOARD_STACKUP_BASE::m_staticTextThickness, PANEL_SETUP_BOARD_STACKUP_BASE::m_staticTextType, and showOnlyActiveLayers().

Referenced by ImportSettingsFrom(), onAddDielectricLayer(), and onRemoveDielectricLayer().

setDefaultLayerWidths()

void PANEL_SETUP_BOARD_STACKUP::setDefaultLayerWidths ( int  targetThickness )

private

Set the widths of dielectric layers to sensible defaults.

Parameters

targetThickness

target thickness of PCB in IU

Definition at line 424 of file panel_board_stackup.cpp.

{
 // This function tries to set the PCB thickness to the parameter and uses a fixed prepreg thickness
 // of 0.1 mm. The core thickness is calculated accordingly as long as it also stays above 0.1mm.
 // If the core thickness would be smaller than the default pregreg thickness given here,
 // both are reduced towards zero to arrive at the correct PCB width
 const int prePregDefaultThickness = pcbIUScale.mmToIU( 0.1 );
 
 int copperLayerCount = GetCopperLayerCount();
 
 // This code is for a symmetrical PCB stackup with even copper layer count
 // If asymmetric stackups were to be implemented, the following layer count calculations
 // for dielectric/core layers might need adjustments.
 wxASSERT( copperLayerCount % 2 == 0 );
 
 int dielectricLayerCount = copperLayerCount - 1;
 int coreLayerCount = copperLayerCount / 2 - 1;
 
 wxASSERT( dielectricLayerCount > 0 );
 
 bool currentLayerIsCore = false;
 
 // start with prepreg layer on the outside, except when creating two-layer-board
 if( copperLayerCount == 2 )
 {
 coreLayerCount = 1;
 currentLayerIsCore = true;
 }
 
 wxASSERT( coreLayerCount > 0 );
 
 int prePregLayerCount = dielectricLayerCount - coreLayerCount;
 
 int totalWidthOfFixedItems = 0;
 
 for( BOARD_STACKUP_ROW_UI_ITEM& ui_item : m_rowUiItemsList )
 {
 BOARD_STACKUP_ITEM* item = ui_item.m_Item;
 
 if( !item->IsThicknessEditable() || !ui_item.m_isEnabled )
 continue;
 
 wxCheckBox* cbLock = dynamic_cast<wxCheckBox*>( ui_item.m_ThicknessLockCtrl );
 wxChoice* layerType = dynamic_cast<wxChoice*>( ui_item.m_LayerTypeCtrl );
 
 if( ( item->GetType() == BS_ITEM_TYPE_DIELECTRIC && !layerType ) || item->GetType() == BS_ITEM_TYPE_SOLDERMASK
 || item->GetType() == BS_ITEM_TYPE_COPPER || ( cbLock && cbLock->GetValue() ) )
 {
 // secondary dielectric layers, mask and copper layers and locked layers will be counted as fixed width
 wxTextCtrl* textCtrl = static_cast<wxTextCtrl*>( ui_item.m_ThicknessCtrl );
 int item_thickness = m_frame->ValueFromString( textCtrl->GetValue() );
 
 totalWidthOfFixedItems += item_thickness;
 }
 }
 
 // Width that hasn't been allocated by fixed items
 int remainingWidth =
 targetThickness - totalWidthOfFixedItems - ( prePregDefaultThickness * prePregLayerCount );
 
 int prePregThickness = prePregDefaultThickness;
 int coreThickness = remainingWidth / coreLayerCount;
 
 if( coreThickness < prePregThickness )
 {
 // There's not enough room for prepreg and core layers of at least 0.1 mm, so adjust both down
 remainingWidth = targetThickness - totalWidthOfFixedItems;
 prePregThickness = coreThickness = std::max( 0, remainingWidth / dielectricLayerCount );
 }
 
 for( BOARD_STACKUP_ROW_UI_ITEM& ui_item : m_rowUiItemsList )
 {
 BOARD_STACKUP_ITEM* item = ui_item.m_Item;
 
 if( item->GetType() != BS_ITEM_TYPE_DIELECTRIC || !ui_item.m_isEnabled )
 continue;
 
 wxChoice* layerType = dynamic_cast<wxChoice*>( ui_item.m_LayerTypeCtrl );
 
 if( !layerType )
 {
 // ignore secondary dielectric layers
 continue;
 }
 
 wxCheckBox* cbLock = dynamic_cast<wxCheckBox*>( ui_item.m_ThicknessLockCtrl );
 
 if( cbLock && cbLock->GetValue() )
 {
 currentLayerIsCore = !currentLayerIsCore;
 
 // Don't override width of locked layer
 continue;
 }
 
 int layerThickness = currentLayerIsCore ? coreThickness : prePregThickness;
 
 wxTextCtrl* textCtrl = static_cast<wxTextCtrl*>( ui_item.m_ThicknessCtrl );
 layerType->SetSelection( currentLayerIsCore ? 0 : 1 );
 textCtrl->SetValue( m_frame->StringFromValue( layerThickness ) );
 
 currentLayerIsCore = !currentLayerIsCore;
 }
}

References BS_ITEM_TYPE_COPPER, BS_ITEM_TYPE_DIELECTRIC, BS_ITEM_TYPE_SOLDERMASK, GetCopperLayerCount(), BOARD_STACKUP_ITEM::GetType(), BOARD_STACKUP_ITEM::IsThicknessEditable(), m_frame, m_rowUiItemsList, EDA_IU_SCALE::mmToIU(), pcbIUScale, UNITS_PROVIDER::StringFromValue(), and UNITS_PROVIDER::ValueFromString().

Referenced by onAdjustDielectricThickness(), and onCopperLayersSelCount().

showOnlyActiveLayers()

void PANEL_SETUP_BOARD_STACKUP::showOnlyActiveLayers ( )

private

Show or do not show items in m_fgGridSizer according to the stackup of the current board.

The panel stackup stores all possible layers (because the number of layers is set from an other panel), but only some of them must be actually shown on screen

Definition at line 697 of file panel_board_stackup.cpp.

{
 // Now enable/disable stackup items, according to the m_enabledLayers config
 // Calculate copper layer count from m_enabledLayers, and *do not use* brd_stackup
 // for that, because it is not necessary up to date
 // (for instance after modifying the layer count from the panel layers in dialog)
 LSET copperMask = m_enabledLayers & ( LSET::ExternalCuMask() | LSET::InternalCuMask() );
 int copperLayersCount = copperMask.count();
 
 for( BOARD_STACKUP_ROW_UI_ITEM& ui_row_item: m_rowUiItemsList )
 {
 bool show_item;
 BOARD_STACKUP_ITEM* item = ui_row_item.m_Item;
 
 if( item->GetType() == BS_ITEM_TYPE_DIELECTRIC )
 // the m_DielectricLayerId is not a copper layer id, it is a dielectric idx from 1
 show_item = item->GetDielectricLayerId() < copperLayersCount;
 else
 show_item = m_enabledLayers[item->GetBrdLayerId()];
 
 item->SetEnabled( show_item );
 
 ui_row_item.m_isEnabled = show_item;
 
 // Show or not items of this row:
 ui_row_item.m_Icon->Show( show_item );
 ui_row_item.m_LayerName->Show( show_item );
 ui_row_item.m_LayerTypeCtrl->Show( show_item );
 ui_row_item.m_MaterialCtrl->Show( show_item );
 
 if( ui_row_item.m_MaterialButt )
 ui_row_item.m_MaterialButt->Show( show_item );
 
 ui_row_item.m_ThicknessCtrl->Show( show_item );
 ui_row_item.m_ThicknessLockCtrl->Show( show_item );
 ui_row_item.m_ColorCtrl->Show( show_item );
 ui_row_item.m_EpsilonCtrl->Show( show_item );
 ui_row_item.m_LossTgCtrl->Show( show_item );
 }
}

References BS_ITEM_TYPE_DIELECTRIC, LSET::ExternalCuMask(), BOARD_STACKUP_ITEM::GetBrdLayerId(), BOARD_STACKUP_ITEM::GetDielectricLayerId(), BOARD_STACKUP_ITEM::GetType(), LSET::InternalCuMask(), m_enabledLayers, m_rowUiItemsList, and BOARD_STACKUP_ITEM::SetEnabled().

Referenced by onCopperLayersSelCount(), rebuildLayerStackPanel(), and synchronizeWithBoard().

synchronizeWithBoard()

void PANEL_SETUP_BOARD_STACKUP::synchronizeWithBoard ( bool  aFullSync )

private

Synchronize the full stackup shown in m_fgGridSizer according to the stackup of the current board and optionally update the stackup params (thickness, color ... )

Parameters

aFullSync

= true to update stackup params, false to only update the list of shown items

Definition at line 577 of file panel_board_stackup.cpp.

{
 const BOARD_STACKUP& brd_stackup = m_brdSettings->GetStackupDescriptor();
 
 if( aFullSync )
 {
 m_choiceCopperLayers->SetSelection( ( m_board->GetCopperLayerCount() / 2 ) - 1 );
 m_impedanceControlled->SetValue( brd_stackup.m_HasDielectricConstrains );
 }
 
 for( BOARD_STACKUP_ROW_UI_ITEM& ui_row_item : m_rowUiItemsList )
 {
 BOARD_STACKUP_ITEM* item = ui_row_item.m_Item;
 int sub_item = ui_row_item.m_SubItem;
 
 if( item->GetType() == BS_ITEM_TYPE_DIELECTRIC )
 {
 wxChoice* choice = dynamic_cast<wxChoice*>( ui_row_item.m_LayerTypeCtrl );
 
 if( choice )
 choice->SetSelection( item->GetTypeName() == KEY_CORE ? 0 : 1 );
 }
 
 if( item->IsMaterialEditable() )
 {
 wxTextCtrl* matName = dynamic_cast<wxTextCtrl*>( ui_row_item.m_MaterialCtrl );
 
 if( matName )
 {
 if( IsPrmSpecified( item->GetMaterial( sub_item ) ) )
 matName->ChangeValue( item->GetMaterial( sub_item ) );
 else
 matName->ChangeValue( wxGetTranslation( NotSpecifiedPrm() ) );
 }
 }
 
 if( item->IsThicknessEditable() )
 {
 wxTextCtrl* textCtrl = dynamic_cast<wxTextCtrl*>( ui_row_item.m_ThicknessCtrl );
 
 if( textCtrl )
 textCtrl->ChangeValue( m_frame->StringFromValue( item->GetThickness( sub_item ), true ) );
 
 if( item->GetType() == BS_ITEM_TYPE_DIELECTRIC )
 {
 wxCheckBox* cb_box = dynamic_cast<wxCheckBox*> ( ui_row_item.m_ThicknessLockCtrl );
 
 if( cb_box )
 cb_box->SetValue( item->IsThicknessLocked( sub_item ) );
 }
 }
 
 if( item->IsColorEditable() )
 {
 auto bm_combo = dynamic_cast<wxBitmapComboBox*>( ui_row_item.m_ColorCtrl );
 int selected = 0; // The "not specified" item
 
 if( item->GetColor( sub_item ).StartsWith( wxT( "#" ) ) ) // User defined color
 {
 COLOR4D custom_color( item->GetColor( sub_item ) );
 
 ui_row_item.m_UserColor = custom_color;
 
 selected = GetColorUserDefinedListIdx( item->GetType() );
 
 if( bm_combo ) // Update user color shown in the wxBitmapComboBox
 {
 bm_combo->SetString( selected, item->GetColor( sub_item ) );
 wxBitmap layerbmp( m_colorSwatchesSize.x, m_colorSwatchesSize.y );
 LAYER_SELECTOR::DrawColorSwatch( layerbmp, COLOR4D(), custom_color );
 bm_combo->SetItemBitmap( selected, layerbmp );
 }
 }
 else
 {
 if( bm_combo )
 {
 // Note: don't use bm_combo->FindString() because the combo strings are
 // translated.
 for( int ii = 0; ii < GetStandardColorCount( item->GetType()); ii++ )
 {
 if( GetStandardColorName( item->GetType(), ii ) == item->GetColor( sub_item ) )
 {
 selected = ii;
 break;
 }
 }
 }
 }
 
 if( bm_combo )
 bm_combo->SetSelection( selected );
 }
 
 if( item->HasEpsilonRValue() )
 {
 wxString txt = UIDouble2Str( item->GetEpsilonR( sub_item ) );
 wxTextCtrl* textCtrl = dynamic_cast<wxTextCtrl*>( ui_row_item.m_EpsilonCtrl );
 
 if( textCtrl )
 textCtrl->ChangeValue( txt );
 }
 
 if( item->HasLossTangentValue() )
 {
 wxString txt = UIDouble2Str( item->GetLossTangent( sub_item ) );
 wxTextCtrl* textCtrl = dynamic_cast<wxTextCtrl*>( ui_row_item.m_LossTgCtrl );
 
 if( textCtrl )
 textCtrl->ChangeValue( txt );
 }
 }
 
 // Now enable/disable stackup items, according to the m_enabledLayers config
 showOnlyActiveLayers();
 
 updateIconColor();
}

References BS_ITEM_TYPE_DIELECTRIC, LAYER_SELECTOR::DrawColorSwatch(), BOARD_STACKUP_ITEM::GetColor(), GetColorUserDefinedListIdx(), BOARD::GetCopperLayerCount(), BOARD_STACKUP_ITEM::GetEpsilonR(), BOARD_STACKUP_ITEM::GetLossTangent(), BOARD_STACKUP_ITEM::GetMaterial(), BOARD_DESIGN_SETTINGS::GetStackupDescriptor(), GetStandardColorCount(), GetStandardColorName(), BOARD_STACKUP_ITEM::GetThickness(), BOARD_STACKUP_ITEM::GetType(), BOARD_STACKUP_ITEM::GetTypeName(), BOARD_STACKUP_ITEM::HasEpsilonRValue(), BOARD_STACKUP_ITEM::HasLossTangentValue(), BOARD_STACKUP_ITEM::IsColorEditable(), BOARD_STACKUP_ITEM::IsMaterialEditable(), IsPrmSpecified(), BOARD_STACKUP_ITEM::IsThicknessEditable(), BOARD_STACKUP_ITEM::IsThicknessLocked(), KEY_CORE, m_board, m_brdSettings, PANEL_SETUP_BOARD_STACKUP_BASE::m_choiceCopperLayers, m_colorSwatchesSize, m_frame, BOARD_STACKUP::m_HasDielectricConstrains, PANEL_SETUP_BOARD_STACKUP_BASE::m_impedanceControlled, m_rowUiItemsList, NotSpecifiedPrm(), showOnlyActiveLayers(), UNITS_PROVIDER::StringFromValue(), UIDouble2Str(), and updateIconColor().

Referenced by ImportSettingsFrom(), OnLayersOptionsChanged(), and PANEL_SETUP_BOARD_STACKUP().

transferDataFromUIToStackup()

bool PANEL_SETUP_BOARD_STACKUP::transferDataFromUIToStackup ( )

private

Transfer current UI settings to m_stackup but not to the board.

Definition at line 1090 of file panel_board_stackup.cpp.

{
 wxString error_msg;
 bool success = true;
 double value;
 int row = 0;
 
 for( BOARD_STACKUP_ROW_UI_ITEM& ui_item : m_rowUiItemsList )
 {
 // Skip stackup items useless for the current board
 if( !ui_item.m_isEnabled )
 {
 row++;
 continue;
 }
 
 BOARD_STACKUP_ITEM* item = ui_item.m_Item;
 int sub_item = ui_item.m_SubItem;
 
 // Add sub layer if there is a new sub layer:
 while( item->GetSublayersCount() <= sub_item )
 item->AddDielectricPrms( item->GetSublayersCount() );
 
 if( sub_item == 0 ) // Name only main layer
 item->SetLayerName( ui_item.m_LayerName->GetLabel() );
 
 if( item->HasEpsilonRValue() )
 {
 wxTextCtrl* textCtrl = static_cast<wxTextCtrl*>( ui_item.m_EpsilonCtrl );
 wxString txt = textCtrl->GetValue();
 
 if( txt.ToDouble( &value ) && value >= 0.0 )
 item->SetEpsilonR( value, sub_item );
 else if( txt.ToCDouble( &value ) && value >= 0.0 )
 item->SetEpsilonR( value, sub_item );
 else
 {
 success = false;
 error_msg << _( "Incorrect value for Epsilon R (Epsilon R must be positive or "
 "null if not used)" );
 }
 }
 
 if( item->HasLossTangentValue() )
 {
 wxTextCtrl* textCtrl = static_cast<wxTextCtrl*>( ui_item.m_LossTgCtrl );
 wxString txt = textCtrl->GetValue();
 
 if( txt.ToDouble( &value ) && value >= 0.0 )
 item->SetLossTangent( value, sub_item );
 else if( txt.ToCDouble( &value ) && value >= 0.0 )
 item->SetLossTangent( value, sub_item );
 else
 {
 success = false;
 
 if( !error_msg.IsEmpty() )
 error_msg << wxT( "\n" );
 
 error_msg << _( "Incorrect value for Loss tg (Loss tg must be positive or null "
 "if not used)" );
 }
 }
 
 if( item->IsMaterialEditable() )
 {
 wxTextCtrl* textCtrl = static_cast<wxTextCtrl*>( ui_item.m_MaterialCtrl );
 item->SetMaterial( textCtrl->GetValue(), sub_item );
 
 // Ensure the not specified mat name is the keyword, not its translation
 // to avoid any issue is the language setting changes
 if( !IsPrmSpecified( item->GetMaterial( sub_item ) ) )
 item->SetMaterial( NotSpecifiedPrm(), sub_item );
 }
 
 if( item->GetType() == BS_ITEM_TYPE_DIELECTRIC )
 {
 // Choice is Core or Prepreg. Sublayers have no choice:
 wxChoice* choice = dynamic_cast<wxChoice*>( ui_item.m_LayerTypeCtrl );
 
 if( choice )
 {
 int idx = choice->GetSelection();
 
 if( idx == 0 )
 item->SetTypeName( KEY_CORE );
 else
 item->SetTypeName( KEY_PREPREG );
 }
 }
 
 if( item->IsThicknessEditable() )
 {
 wxTextCtrl* textCtrl = static_cast<wxTextCtrl*>( ui_item.m_ThicknessCtrl );
 int new_thickness = m_frame->ValueFromString( textCtrl->GetValue() );
 
 item->SetThickness( new_thickness, sub_item );
 
 if( new_thickness < 0 )
 {
 success = false;
 
 if( !error_msg.IsEmpty() )
 error_msg << wxT( "\n" );
 
 error_msg << _( "A layer thickness is < 0. Fix it" );
 }
 
 if( item->GetType() == BS_ITEM_TYPE_DIELECTRIC )
 {
 // Dielectric thickness layer can have a locked thickness:
 wxCheckBox* cb_box = static_cast<wxCheckBox*>( ui_item.m_ThicknessLockCtrl );
 item->SetThicknessLocked( cb_box && cb_box->GetValue(), sub_item );
 }
 }
 
 if( item->IsColorEditable() )
 {
 wxBitmapComboBox* choice = dynamic_cast<wxBitmapComboBox*>( ui_item.m_ColorCtrl );
 
 if( choice )
 {
 int idx = choice->GetSelection();
 
 if( IsCustomColorIdx( item->GetType(), idx ) )
 item->SetColor( ui_item.m_UserColor.ToHexString(), sub_item );
 else
  item->SetColor( GetStandardColorName( item->GetType(), idx ), sub_item );
 }
 }
 
 row++;
 }
 
 if( !success )
 {
 wxMessageBox( error_msg, _( "Errors" ) );
 return false;
 }
 
 m_stackup.m_HasDielectricConstrains = m_impedanceControlled->GetValue();
 
 return true;
}

References _, BOARD_STACKUP_ITEM::AddDielectricPrms(), BS_ITEM_TYPE_DIELECTRIC, BOARD_STACKUP_ITEM::GetMaterial(), GetStandardColorName(), BOARD_STACKUP_ITEM::GetSublayersCount(), BOARD_STACKUP_ITEM::GetType(), BOARD_STACKUP_ITEM::HasEpsilonRValue(), BOARD_STACKUP_ITEM::HasLossTangentValue(), BOARD_STACKUP_ITEM::IsColorEditable(), IsCustomColorIdx(), BOARD_STACKUP_ITEM::IsMaterialEditable(), IsPrmSpecified(), BOARD_STACKUP_ITEM::IsThicknessEditable(), KEY_CORE, KEY_PREPREG, m_frame, BOARD_STACKUP::m_HasDielectricConstrains, PANEL_SETUP_BOARD_STACKUP_BASE::m_impedanceControlled, m_rowUiItemsList, m_stackup, NotSpecifiedPrm(), BOARD_STACKUP_ITEM::SetColor(), BOARD_STACKUP_ITEM::SetEpsilonR(), BOARD_STACKUP_ITEM::SetLayerName(), BOARD_STACKUP_ITEM::SetLossTangent(), BOARD_STACKUP_ITEM::SetMaterial(), BOARD_STACKUP_ITEM::SetThickness(), BOARD_STACKUP_ITEM::SetThicknessLocked(), BOARD_STACKUP_ITEM::SetTypeName(), and UNITS_PROVIDER::ValueFromString().

Referenced by onExportToClipboard(), onMaterialChange(), and TransferDataFromWindow().

TransferDataFromWindow()

bool PANEL_SETUP_BOARD_STACKUP::TransferDataFromWindow ( )

override

Definition at line 1236 of file panel_board_stackup.cpp.

{
 if( !transferDataFromUIToStackup() )
 return false;
 
 // NOTE: Copper layer count is transferred via PANEL_SETUP_LAYERS even though it is configured
 // on this page, because the logic for confirming deletion of board items on deleted layers is
 // on that panel and it doesn't make sense to split it up.
 
 BOARD_STACKUP& brd_stackup = m_brdSettings->GetStackupDescriptor();
 
 STRING_FORMATTER old_stackup;
 
 // FormatBoardStackup() (using FormatInternalUnits()) expects a "C" locale
 // to execute some tests. So switch to the suitable locale
 LOCALE_IO dummy;
 brd_stackup.FormatBoardStackup( &old_stackup, m_board, 0 );
 
 brd_stackup.m_FinishType = m_stackup.m_FinishType;
 brd_stackup.m_HasDielectricConstrains = m_stackup.m_HasDielectricConstrains;
 brd_stackup.m_EdgeConnectorConstraints = m_stackup.m_EdgeConnectorConstraints;
 brd_stackup.m_CastellatedPads = m_stackup.m_CastellatedPads;
 brd_stackup.m_EdgePlating = m_stackup.m_EdgePlating;
 
 // copy enabled items to the new board stackup
 brd_stackup.RemoveAll();
 
 for( BOARD_STACKUP_ITEM* item : m_stackup.GetList() )
 {
 if( item->IsEnabled() )
 brd_stackup.Add( new BOARD_STACKUP_ITEM( *item ) );
 }
 
 STRING_FORMATTER new_stackup;
 brd_stackup.FormatBoardStackup( &new_stackup, m_board, 0 );
 
 bool modified = old_stackup.GetString() != new_stackup.GetString();
 int thickness = brd_stackup.BuildBoardThicknessFromStackup();
 
 if( m_brdSettings->GetBoardThickness() != thickness )
 {
 m_brdSettings->SetBoardThickness( thickness );
 modified = true;
  }
 
 if( !m_brdSettings->m_HasStackup )
 {
 m_brdSettings->m_HasStackup = true;
 modified = true;
 }
 
 if( modified )
 m_frame->OnModify();
 
 return true;
}

References BOARD_STACKUP::Add(), BOARD_STACKUP::BuildBoardThicknessFromStackup(), dummy(), BOARD_STACKUP::FormatBoardStackup(), BOARD_DESIGN_SETTINGS::GetBoardThickness(), BOARD_STACKUP::GetList(), BOARD_DESIGN_SETTINGS::GetStackupDescriptor(), STRING_FORMATTER::GetString(), m_board, m_brdSettings, BOARD_STACKUP::m_CastellatedPads, BOARD_STACKUP::m_EdgeConnectorConstraints, BOARD_STACKUP::m_EdgePlating, BOARD_STACKUP::m_FinishType, m_frame, BOARD_STACKUP::m_HasDielectricConstrains, BOARD_DESIGN_SETTINGS::m_HasStackup, m_stackup, PCB_EDIT_FRAME::OnModify(), BOARD_STACKUP::RemoveAll(), BOARD_DESIGN_SETTINGS::SetBoardThickness(), and transferDataFromUIToStackup().

updateCopperLayerCount()

void PANEL_SETUP_BOARD_STACKUP::updateCopperLayerCount ( )

private

Updates the enabled copper layers when the dropdown is changed.

Definition at line 563 of file panel_board_stackup.cpp.

{
 int copperCount = GetCopperLayerCount();
 
 wxASSERT( copperCount >= 2 );
 
 m_enabledLayers |= LSET::ExternalCuMask();
 m_enabledLayers &= ~LSET::InternalCuMask();
 
 for( int i = 1; i < copperCount - 1; i++ )
 m_enabledLayers.set( F_Cu + i );
}

References LSET::ExternalCuMask(), F_Cu, GetCopperLayerCount(), and m_enabledLayers.

Referenced by onCopperLayersSelCount().

updateIconColor()

void PANEL_SETUP_BOARD_STACKUP::updateIconColor ( int  aRow = -1 )

private

Update the icons color (swatches in first grid column)

Parameters

aRow	is the row (index in m_rowUiItemsList) that manages the icon to update. if -1 all icons will be updated

Definition at line 1556 of file panel_board_stackup.cpp.

{
 // explicit depth important under MSW. We use R,V,B 24 bits/pixel bitmap
 const int bitmap_depth = 24;
 
 if( aRow >= 0 )
 {
 wxStaticBitmap* st_bitmap = m_rowUiItemsList[aRow].m_Icon;
 
 wxBitmap bmp( m_colorIconsSize.x, m_colorIconsSize.y / 2, bitmap_depth );
 drawBitmap( bmp, getColorIconItem( aRow ) );
 st_bitmap->SetBitmap( bmp );
 return;
 }
 
 for( unsigned row = 0; row < m_rowUiItemsList.size(); row++ )
 {
 wxBitmap bmp( m_colorIconsSize.x, m_colorIconsSize.y / 2, bitmap_depth );
 drawBitmap( bmp, getColorIconItem( row ) );
 m_rowUiItemsList[row].m_Icon->SetBitmap( bmp );
 }
}

References drawBitmap(), getColorIconItem(), m_colorIconsSize, and m_rowUiItemsList.

Referenced by buildLayerStackPanel(), onColorSelected(), and synchronizeWithBoard().

Member Data Documentation

m_bitmapLockThickness

wxStaticBitmap* PANEL_SETUP_BOARD_STACKUP_BASE::m_bitmapLockThickness

protectedinherited

Definition at line 54 of file panel_board_stackup_base.h.

Referenced by PANEL_SETUP_BOARD_STACKUP(), PANEL_SETUP_BOARD_STACKUP_BASE::PANEL_SETUP_BOARD_STACKUP_BASE(), and rebuildLayerStackPanel().

m_board

BOARD* PANEL_SETUP_BOARD_STACKUP::m_board

private

Definition at line 254 of file panel_board_stackup.h.

Referenced by createRowData(), ImportSettingsFrom(), PANEL_SETUP_BOARD_STACKUP(), synchronizeWithBoard(), and TransferDataFromWindow().

m_brdSettings

BOARD_DESIGN_SETTINGS* PANEL_SETUP_BOARD_STACKUP::m_brdSettings

private

Definition at line 255 of file panel_board_stackup.h.

Referenced by buildLayerStackPanel(), ImportSettingsFrom(), PANEL_SETUP_BOARD_STACKUP(), synchronizeWithBoard(), and TransferDataFromWindow().

m_buttonAddDielectricLayer

wxButton* PANEL_SETUP_BOARD_STACKUP_BASE::m_buttonAddDielectricLayer

protectedinherited

Definition at line 45 of file panel_board_stackup_base.h.

Referenced by PANEL_SETUP_BOARD_STACKUP_BASE::PANEL_SETUP_BOARD_STACKUP_BASE(), and PANEL_SETUP_BOARD_STACKUP_BASE::~PANEL_SETUP_BOARD_STACKUP_BASE().

m_buttonAdjust

wxButton* PANEL_SETUP_BOARD_STACKUP_BASE::m_buttonAdjust

protectedinherited

Definition at line 60 of file panel_board_stackup_base.h.

Referenced by PANEL_SETUP_BOARD_STACKUP_BASE::PANEL_SETUP_BOARD_STACKUP_BASE(), and PANEL_SETUP_BOARD_STACKUP_BASE::~PANEL_SETUP_BOARD_STACKUP_BASE().

m_buttonExport

wxButton* PANEL_SETUP_BOARD_STACKUP_BASE::m_buttonExport

protectedinherited

Definition at line 61 of file panel_board_stackup_base.h.

Referenced by PANEL_SETUP_BOARD_STACKUP_BASE::PANEL_SETUP_BOARD_STACKUP_BASE(), and PANEL_SETUP_BOARD_STACKUP_BASE::~PANEL_SETUP_BOARD_STACKUP_BASE().

m_buttonRemoveDielectricLayer

wxButton* PANEL_SETUP_BOARD_STACKUP_BASE::m_buttonRemoveDielectricLayer

protectedinherited

Definition at line 46 of file panel_board_stackup_base.h.

Referenced by PANEL_SETUP_BOARD_STACKUP_BASE::PANEL_SETUP_BOARD_STACKUP_BASE(), and PANEL_SETUP_BOARD_STACKUP_BASE::~PANEL_SETUP_BOARD_STACKUP_BASE().

m_choiceCopperLayers

wxChoice* PANEL_SETUP_BOARD_STACKUP_BASE::m_choiceCopperLayers

protectedinherited

Definition at line 43 of file panel_board_stackup_base.h.

Referenced by GetCopperLayerCount(), PANEL_SETUP_BOARD_STACKUP_BASE::PANEL_SETUP_BOARD_STACKUP_BASE(), synchronizeWithBoard(), and PANEL_SETUP_BOARD_STACKUP_BASE::~PANEL_SETUP_BOARD_STACKUP_BASE().

m_colorIconsSize

wxSize PANEL_SETUP_BOARD_STACKUP::m_colorIconsSize

private

Definition at line 261 of file panel_board_stackup.h.

Referenced by PANEL_SETUP_BOARD_STACKUP(), and updateIconColor().

m_colorSwatchesSize

wxSize PANEL_SETUP_BOARD_STACKUP::m_colorSwatchesSize

private

Definition at line 260 of file panel_board_stackup.h.

Referenced by createColorBox(), onColorSelected(), PANEL_SETUP_BOARD_STACKUP(), and synchronizeWithBoard().

m_controlItemsList

std::vector<wxControl*> PANEL_SETUP_BOARD_STACKUP::m_controlItemsList

private

Definition at line 266 of file panel_board_stackup.h.

Referenced by addMaterialChooser(), createColorBox(), createRowData(), disconnectEvents(), and rebuildLayerStackPanel().

m_core_prepreg_choice

wxArrayString PANEL_SETUP_BOARD_STACKUP::m_core_prepreg_choice

private

Definition at line 259 of file panel_board_stackup.h.

Referenced by createRowData(), and PANEL_SETUP_BOARD_STACKUP().

m_delectricMatList

DIELECTRIC_SUBSTRATE_LIST PANEL_SETUP_BOARD_STACKUP::m_delectricMatList

private

Definition at line 245 of file panel_board_stackup.h.

Referenced by onMaterialChange().

m_enabledLayers

LSET PANEL_SETUP_BOARD_STACKUP::m_enabledLayers

private

Definition at line 240 of file panel_board_stackup.h.

Referenced by ImportSettingsFrom(), OnLayersOptionsChanged(), PANEL_SETUP_BOARD_STACKUP(), showOnlyActiveLayers(), and updateCopperLayerCount().

m_fgGridSizer

wxFlexGridSizer* PANEL_SETUP_BOARD_STACKUP_BASE::m_fgGridSizer

protectedinherited

Definition at line 48 of file panel_board_stackup_base.h.

Referenced by addMaterialChooser(), addSpacer(), createRowData(), PANEL_SETUP_BOARD_STACKUP_BASE::PANEL_SETUP_BOARD_STACKUP_BASE(), and rebuildLayerStackPanel().

m_frame

PCB_EDIT_FRAME* PANEL_SETUP_BOARD_STACKUP::m_frame

private

Definition at line 256 of file panel_board_stackup.h.

Referenced by computeBoardThickness(), createRowData(), onAdjustDielectricThickness(), onCopperLayersSelCount(), onExportToClipboard(), onThicknessChange(), PANEL_SETUP_BOARD_STACKUP(), setDefaultLayerWidths(), synchronizeWithBoard(), transferDataFromUIToStackup(), and TransferDataFromWindow().

m_impedanceControlled

wxCheckBox* PANEL_SETUP_BOARD_STACKUP_BASE::m_impedanceControlled

protectedinherited

Definition at line 44 of file panel_board_stackup_base.h.

Referenced by PANEL_SETUP_BOARD_STACKUP_BASE::PANEL_SETUP_BOARD_STACKUP_BASE(), synchronizeWithBoard(), and transferDataFromUIToStackup().

m_lblCopperLayers

wxStaticText* PANEL_SETUP_BOARD_STACKUP_BASE::m_lblCopperLayers

protectedinherited

Definition at line 42 of file panel_board_stackup_base.h.

Referenced by PANEL_SETUP_BOARD_STACKUP_BASE::PANEL_SETUP_BOARD_STACKUP_BASE().

m_numericFieldsSize

wxSize PANEL_SETUP_BOARD_STACKUP::m_numericFieldsSize

private

Definition at line 258 of file panel_board_stackup.h.

Referenced by createRowData(), and PANEL_SETUP_BOARD_STACKUP().

m_numericTextCtrlSize

wxSize PANEL_SETUP_BOARD_STACKUP::m_numericTextCtrlSize

private

Definition at line 257 of file panel_board_stackup.h.

Referenced by addMaterialChooser(), createRowData(), and PANEL_SETUP_BOARD_STACKUP().

m_panelLayers

PANEL_SETUP_LAYERS* PANEL_SETUP_BOARD_STACKUP::m_panelLayers

private

Definition at line 238 of file panel_board_stackup.h.

Referenced by OnLayersOptionsChanged(), and PANEL_SETUP_BOARD_STACKUP().

m_parentDialog

PAGED_DIALOG* PANEL_SETUP_BOARD_STACKUP::m_parentDialog

private

Definition at line 253 of file panel_board_stackup.h.

Referenced by onAddDielectricLayer(), onRemoveDielectricLayer(), and PANEL_SETUP_BOARD_STACKUP().

m_rowUiItemsList

std::vector<BOARD_STACKUP_ROW_UI_ITEM> PANEL_SETUP_BOARD_STACKUP::m_rowUiItemsList

private

Definition at line 251 of file panel_board_stackup.h.

Referenced by buildLayerStackPanel(), computeBoardThickness(), GetSelectedColor(), GetStackupItem(), GetSublayerId(), onAddDielectricLayer(), onAdjustDielectricThickness(), onColorSelected(), onMaterialChange(), onRemoveDielectricLayer(), rebuildLayerStackPanel(), setDefaultLayerWidths(), showOnlyActiveLayers(), synchronizeWithBoard(), transferDataFromUIToStackup(), and updateIconColor().

m_scGridWin

wxScrolledWindow* PANEL_SETUP_BOARD_STACKUP_BASE::m_scGridWin

protectedinherited

Definition at line 47 of file panel_board_stackup_base.h.

Referenced by addMaterialChooser(), addSpacer(), createColorBox(), createRowData(), PANEL_SETUP_BOARD_STACKUP_BASE::PANEL_SETUP_BOARD_STACKUP_BASE(), and rebuildLayerStackPanel().

m_silkscreenMatList

DIELECTRIC_SUBSTRATE_LIST PANEL_SETUP_BOARD_STACKUP::m_silkscreenMatList

private

Definition at line 249 of file panel_board_stackup.h.

Referenced by onMaterialChange().

m_solderMaskMatList

DIELECTRIC_SUBSTRATE_LIST PANEL_SETUP_BOARD_STACKUP::m_solderMaskMatList

private

Definition at line 247 of file panel_board_stackup.h.

Referenced by onMaterialChange().

m_stackup

BOARD_STACKUP PANEL_SETUP_BOARD_STACKUP::m_stackup

private

Definition at line 237 of file panel_board_stackup.h.

Referenced by buildLayerStackPanel(), GetStackup(), onExportToClipboard(), onMaterialChange(), onRemoveDielectricLayer(), onRemoveDielUI(), transferDataFromUIToStackup(), and TransferDataFromWindow().

m_staticTextColor

wxStaticText* PANEL_SETUP_BOARD_STACKUP_BASE::m_staticTextColor

protectedinherited

Definition at line 55 of file panel_board_stackup_base.h.

Referenced by PANEL_SETUP_BOARD_STACKUP_BASE::PANEL_SETUP_BOARD_STACKUP_BASE(), and rebuildLayerStackPanel().

m_staticTextCT

wxStaticText* PANEL_SETUP_BOARD_STACKUP_BASE::m_staticTextCT

protectedinherited

Definition at line 58 of file panel_board_stackup_base.h.

Referenced by PANEL_SETUP_BOARD_STACKUP_BASE::PANEL_SETUP_BOARD_STACKUP_BASE().

m_staticTextEpsilonR

wxStaticText* PANEL_SETUP_BOARD_STACKUP_BASE::m_staticTextEpsilonR

protectedinherited

Definition at line 56 of file panel_board_stackup_base.h.

Referenced by PANEL_SETUP_BOARD_STACKUP_BASE::PANEL_SETUP_BOARD_STACKUP_BASE(), and rebuildLayerStackPanel().

m_staticTextLayer

wxStaticText* PANEL_SETUP_BOARD_STACKUP_BASE::m_staticTextLayer

protectedinherited

Definition at line 49 of file panel_board_stackup_base.h.

Referenced by PANEL_SETUP_BOARD_STACKUP_BASE::PANEL_SETUP_BOARD_STACKUP_BASE(), and rebuildLayerStackPanel().

m_staticTextLayerId

wxStaticText* PANEL_SETUP_BOARD_STACKUP_BASE::m_staticTextLayerId

protectedinherited

Definition at line 50 of file panel_board_stackup_base.h.

Referenced by PANEL_SETUP_BOARD_STACKUP_BASE::PANEL_SETUP_BOARD_STACKUP_BASE(), and rebuildLayerStackPanel().

m_staticTextLossTg

wxStaticText* PANEL_SETUP_BOARD_STACKUP_BASE::m_staticTextLossTg

protectedinherited

Definition at line 57 of file panel_board_stackup_base.h.

Referenced by PANEL_SETUP_BOARD_STACKUP_BASE::PANEL_SETUP_BOARD_STACKUP_BASE(), and rebuildLayerStackPanel().

m_staticTextMaterial

wxStaticText* PANEL_SETUP_BOARD_STACKUP_BASE::m_staticTextMaterial

protectedinherited

Definition at line 52 of file panel_board_stackup_base.h.

Referenced by PANEL_SETUP_BOARD_STACKUP_BASE::PANEL_SETUP_BOARD_STACKUP_BASE(), and rebuildLayerStackPanel().

m_staticTextThickness

wxStaticText* PANEL_SETUP_BOARD_STACKUP_BASE::m_staticTextThickness

protectedinherited

Definition at line 53 of file panel_board_stackup_base.h.

Referenced by PANEL_SETUP_BOARD_STACKUP_BASE::PANEL_SETUP_BOARD_STACKUP_BASE(), and rebuildLayerStackPanel().

m_staticTextType

wxStaticText* PANEL_SETUP_BOARD_STACKUP_BASE::m_staticTextType

protectedinherited

Definition at line 51 of file panel_board_stackup_base.h.

Referenced by PANEL_SETUP_BOARD_STACKUP_BASE::PANEL_SETUP_BOARD_STACKUP_BASE(), and rebuildLayerStackPanel().

m_tcCTValue

wxTextCtrl* PANEL_SETUP_BOARD_STACKUP_BASE::m_tcCTValue

protectedinherited

Definition at line 59 of file panel_board_stackup_base.h.

Referenced by computeBoardThickness(), onCopperLayersSelCount(), PANEL_SETUP_BOARD_STACKUP(), and PANEL_SETUP_BOARD_STACKUP_BASE::PANEL_SETUP_BOARD_STACKUP_BASE().

---

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

• panel_board_stackup.h
• panel_board_stackup.cpp