haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Pcbnew: Redesign layer selection and layer pair selection (give them a look near the Layer selector in toolbarr)

This commit is contained in:
jean-pierre charras 2013-08-30 21:28:31 +02:00
parent 51eaeccf03
commit 6c14eee672
6 changed files with 502 additions and 344 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
common/class_layer_box_selector.cpp
View File

@ -11,6 +11,46 @@
#include <class_layer_box_selector.h>
LAYER_SELECTOR::LAYER_SELECTOR()
{
m_layerorder = true;
m_layerhotkeys = true;
m_hotkeys = NULL;
}
bool LAYER_SELECTOR::SetLayersOrdered( bool value )
{
m_layerorder = value;
return m_layerorder;
}
bool LAYER_SELECTOR::SetLayersHotkeys( bool value )
{
m_layerhotkeys = value;
return m_layerhotkeys;
}
void LAYER_SELECTOR::SetBitmapLayer( wxBitmap& aLayerbmp, LAYER_NUM aLayer )
{
wxMemoryDC bmpDC;
wxBrush brush;
// Prepare Bitmap
bmpDC.SelectObject( aLayerbmp );
brush.SetColour( MakeColour( GetLayerColor( aLayer ) ) );
brush.SetStyle( wxSOLID );
bmpDC.SetBrush( brush );
bmpDC.DrawRectangle( 0, 0, aLayerbmp.GetWidth(), aLayerbmp.GetHeight() );
bmpDC.SetBrush( *wxTRANSPARENT_BRUSH );
bmpDC.SetPen( *wxBLACK_PEN );
bmpDC.DrawRectangle( 0, 0, aLayerbmp.GetWidth(), aLayerbmp.GetHeight() );
}
/* class to display a layer list.
*
*/
@ -18,12 +58,9 @@
LAYER_BOX_SELECTOR::LAYER_BOX_SELECTOR( wxAuiToolBar* parent, wxWindowID id,
const wxPoint& pos, const wxSize& size,
int n, const wxString choices[] ) :
LAYER_SELECTOR(),
wxBitmapComboBox( parent, id, wxEmptyString, pos, size, n, choices, wxCB_READONLY )
{
m_layerorder = true;
m_layerhotkeys = true;
m_hotkeys = NULL;
if( choices != NULL )
ResyncBitmapOnly();
}
@ -32,31 +69,14 @@ LAYER_BOX_SELECTOR::LAYER_BOX_SELECTOR( wxAuiToolBar* parent, wxWindowID id,
LAYER_BOX_SELECTOR::LAYER_BOX_SELECTOR( wxAuiToolBar* parent, wxWindowID id,
const wxPoint& pos, const wxSize& size,
const wxArrayString& choices ) :
LAYER_SELECTOR(),
wxBitmapComboBox( parent, id, wxEmptyString, pos, size, choices, wxCB_READONLY )
{
m_layerorder = true;
m_layerhotkeys = true;
m_hotkeys = NULL;
if( !choices.IsEmpty() )
ResyncBitmapOnly();
}
bool LAYER_BOX_SELECTOR::SetLayersOrdered( bool value )
{
m_layerorder = value;
return m_layerorder;
}
bool LAYER_BOX_SELECTOR::SetLayersHotkeys( bool value )
{
m_layerhotkeys = value;
return m_layerhotkeys;
}
// Get Current Item #
int LAYER_BOX_SELECTOR::GetChoice()
{
@ -104,21 +124,3 @@ void LAYER_BOX_SELECTOR::ResyncBitmapOnly()
SetBitmapLayer( layerbmp, i );
}
}
void LAYER_BOX_SELECTOR::SetBitmapLayer( wxBitmap& aLayerbmp, LAYER_NUM aLayer )
{
wxMemoryDC bmpDC;
wxBrush brush;
// Prepare Bitmap
bmpDC.SelectObject( aLayerbmp );
brush.SetColour( MakeColour( GetLayerColor( aLayer ) ) );
brush.SetStyle( wxSOLID );
bmpDC.SetBrush( brush );
bmpDC.DrawRectangle( 0, 0, aLayerbmp.GetWidth(), aLayerbmp.GetHeight() );
bmpDC.SetBrush( *wxTRANSPARENT_BRUSH );
bmpDC.SetPen( *wxBLACK_PEN );
bmpDC.DrawRectangle( 0, 0, aLayerbmp.GetWidth(), aLayerbmp.GetHeight() );
}

58
include/class_layer_box_selector.h
View File

@ -9,11 +9,11 @@
class wxAuiToolBar;
/* class to display a layer list.
*
/* Basic class to build a layer list.
* this is an basic abstract class to build a layer list selector.
* To display this list, you should therefore derive this class
*/
class LAYER_BOX_SELECTOR : public wxBitmapComboBox
class LAYER_SELECTOR
{
protected:
bool m_layerhotkeys;
@ -23,6 +23,37 @@ public:
// Hotkey Info
struct EDA_HOTKEY_CONFIG* m_hotkeys;
public:
LAYER_SELECTOR();
// Returns a color index from the layer id
// Virtual function because GerbView uses its own functions in a derived class
virtual EDA_COLOR_T GetLayerColor( LAYER_NUM aLayer ) const = 0;
// Returns the name of the layer id
// Virtual pure function because GerbView uses its own functions in a derived class
virtual wxString GetLayerName( LAYER_NUM aLayer ) const = 0;
// Returns true if the layer id is enabled (i.e. is it should be displayed)
// Virtual function pure because GerbView uses its own functions in a derived class
virtual bool IsLayerEnabled( LAYER_NUM aLayer ) const = 0;
bool SetLayersOrdered(bool value);
bool SetLayersHotkeys(bool value);
protected:
// Fills the layer bitmap aLayerbmp with the layer color
void SetBitmapLayer( wxBitmap& aLayerbmp, LAYER_NUM aLayer );
};
/* class to display a layer list in a wxBitmapComboBox.
*/
class LAYER_BOX_SELECTOR : public LAYER_SELECTOR, public wxBitmapComboBox
{
public:
// Hotkey Info
struct EDA_HOTKEY_CONFIG* m_hotkeys;
public:
LAYER_BOX_SELECTOR( wxAuiToolBar* parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
@ -33,18 +64,6 @@ public:
const wxPoint& pos, const wxSize& size,
const wxArrayString& choices );
// Returns a color index from the layer id
// Virtual function because GerbView uses its own functions in a derived class
virtual EDA_COLOR_T GetLayerColor( LAYER_NUM aLayer ) const = 0;
// Returns the name of the layer id
// Virtual pure function because GerbView uses its own functions in a derived class
virtual wxString GetLayerName( LAYER_NUM aLayer ) const = 0;
// Returns true if the layer id is enabled (i.e. is it should be displayed)
// Virtual function pure because GerbView uses its own functions in a derived class
virtual bool IsLayerEnabled( LAYER_NUM aLayer ) const = 0;
// Get Current Item #
int GetChoice();
@ -60,13 +79,6 @@ public:
// Reload the Layers bitmaps colors
void ResyncBitmapOnly();
bool SetLayersOrdered(bool value);
bool SetLayersHotkeys(bool value);
protected:
// Fills the layer bitmap aLayerbmp with the layer color
void SetBitmapLayer( wxBitmap& aLayerbmp, LAYER_NUM aLayer );
};
#define DECLARE_LAYERS_HOTKEY(list) int list[NB_LAYERS] = \

9
pagelayout_editor/files.cpp
View File

@ -186,9 +186,14 @@ void PL_EDITOR_FRAME::Files_io( wxCommandEvent& event )
filename = openFileDialog.GetPath();
// Ensure the file has the right extension:
// because a name like name.subname.subsubname is legal,
// add the right extension without replacing the wxFileName
// extension
wxFileName fn(filename);
fn.SetExt( PageLayoutDescrFileExtension );
filename = fn.GetFullPath();
if( fn.GetExt() != PageLayoutDescrFileExtension )
filename << wxT(".") << PageLayoutDescrFileExtension;
if( !SavePageLayoutDescrFile( filename ) )
{
wxString msg;

1
pcbnew/CMakeLists.txt
View File

@ -76,6 +76,7 @@ set( PCBNEW_DIALOGS
dialogs/dialog_global_deletion_base.cpp
dialogs/dialog_keepout_area_properties.cpp
dialogs/dialog_keepout_area_properties_base.cpp
dialogs/dialog_layer_selection_base.cpp
dialogs/dialog_layers_setup.cpp
dialogs/dialog_layers_setup_base.cpp
dialogs/dialog_netlist.cpp

8
pcbnew/edit.cpp
View File

@ -925,7 +925,15 @@ void PCB_EDIT_FRAME::Process_Special_Functions( wxCommandEvent& event )
itmp = SelectLayer( getActiveLayer(), UNDEFINED_LAYER, UNDEFINED_LAYER );
if( itmp >= 0 )
{
// if user changed colors and we are in high contrast mode, then redraw
// because the PAD_SMD pads may change color.
if( DisplayOpt.ContrastModeDisplay && getActiveLayer() != itmp )
{
m_canvas->Refresh();
}
setActiveLayer( itmp );
}
m_canvas->MoveCursorToCrossHair();
break;

686
pcbnew/sel_layer.cpp
View File

@ -1,7 +1,31 @@
/**
* @file sel_layer.cpp
* @brief Set up the basic primitives for Layer control.
* @brief dialogs for one layer selection and a layer pair selection.
*/
/*
* This program source code file is part of KiCad, a free EDA CAD application.
*
* Copyright (C) 2013 Jean-Pierre Charras, jp.charras at wanadoo.fr
* Copyright (C) 1992-2013 KiCad Developers, see AUTHORS.txt for contributors.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, you may find one here:
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
* or you may search the http://www.gnu.org website for the version 2 license,
* or you may write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <fctsys.h>
#include <common.h>
@ -9,340 +33,446 @@
#include <confirm.h>
#include <wxBasePcbFrame.h>
#include <pcbcommon.h>
#include <class_layer_box_selector.h>
#include <class_board.h>
#include <dialogs/dialog_layer_selection_base.h>
enum layer_sel_id {
ID_LAYER_SELECT_TOP = 1800,
ID_LAYER_SELECT_BOTTOM,
ID_LAYER_SELECT
};
class SELECT_LAYER_DIALOG : public wxDialog
/* classes to display a layer list using a wxGrid.
*/
class PCB_LAYER_SELECTOR: public LAYER_SELECTOR
{
private:
PCB_BASE_FRAME* m_Parent;
wxRadioBox* m_LayerList;
LAYER_NUM m_LayerId[int(NB_PCB_LAYERS) + 1]; // One extra element for "(Deselect)" radiobutton
BOARD * m_brd;
public:
// Constructor and destructor
SELECT_LAYER_DIALOG( PCB_BASE_FRAME* parent, LAYER_NUM default_layer,
LAYER_NUM min_layer, LAYER_NUM max_layer, bool null_layer );
~SELECT_LAYER_DIALOG() { };
PCB_LAYER_SELECTOR( BOARD* aBrd ):LAYER_SELECTOR()
{
m_brd = aBrd;
}
private:
void OnLayerSelected( wxCommandEvent& event );
void OnCancelClick( wxCommandEvent& event );
protected:
// Returns true if the layer id is enabled (i.e. is it should be displayed)
bool IsLayerEnabled( LAYER_NUM aLayer ) const
{
return m_brd->IsLayerEnabled( aLayer );
}
// Returns a color index from the layer id
// Virtual function
EDA_COLOR_T GetLayerColor( LAYER_NUM aLayer ) const
{
return m_brd->GetLayerColor( aLayer );
}
// Returns the name of the layer id
// Virtual function
wxString GetLayerName( LAYER_NUM aLayer ) const
{
return m_brd->GetLayerName( aLayer );
}
DECLARE_EVENT_TABLE()
};
/*
* This class display a pcb layers list in adialog,
* to select one layer from this list
*/
class PCB_ONE_LAYER_SELECTOR : public PCB_LAYER_SELECTOR,
public DIALOG_LAYER_SELECTION_BASE
{
LAYER_NUM m_layerSelected;
LAYER_NUM m_minLayer;
LAYER_NUM m_maxLayer;
BEGIN_EVENT_TABLE( SELECT_LAYER_DIALOG, wxDialog )
EVT_BUTTON( wxID_OK, SELECT_LAYER_DIALOG::OnLayerSelected )
EVT_BUTTON( wxID_CANCEL, SELECT_LAYER_DIALOG::OnCancelClick )
EVT_RADIOBOX( ID_LAYER_SELECT, SELECT_LAYER_DIALOG::OnLayerSelected )
END_EVENT_TABLE()
public:
PCB_ONE_LAYER_SELECTOR( wxWindow* aParent, BOARD * aBrd,
LAYER_NUM aDefaultLayer,
LAYER_NUM aMinLayer = -1, LAYER_NUM aMaxLayer = -1,
bool aClearTool = false )
:PCB_LAYER_SELECTOR( aBrd ), DIALOG_LAYER_SELECTION_BASE( aParent )
{
m_layerSelected = (int) aDefaultLayer;
// When not needed, remove the "Clear" button
m_buttonClear->Show( aClearTool );
m_minLayer = aMinLayer;
m_maxLayer = aMaxLayer;
BuildList();
Layout();
GetSizer()->SetSizeHints(this);
SetFocus();
}
LAYER_NUM GetLayerSelection() { return m_layerSelected; }
private:
// Event handlers
void OnLeftGridClick( wxGridEvent& event );
void OnRightGridClick( wxGridEvent& event );
void OnClearSelection( wxCommandEvent& event )
{
m_layerSelected = NB_PCB_LAYERS;
EndModal( NB_PCB_LAYERS );
}
void BuildList();
};
// Build the layers list
// Column position by function:
#define SELECT_COLNUM 0
#define COLOR_COLNUM 1
#define LAYERNAME_COLNUM 2
#define LAYERID_COLNUM 3
static DECLARE_LAYERS_ORDER_LIST( layertranscode );
void PCB_ONE_LAYER_SELECTOR::BuildList()
{
m_leftGridLayers->SetColFormatNumber( LAYERID_COLNUM );
m_rightGridLayers->SetColFormatNumber( LAYERID_COLNUM );
m_leftGridLayers->HideCol( LAYERID_COLNUM );
m_rightGridLayers->HideCol( LAYERID_COLNUM );
m_leftGridLayers->SetColSize( COLOR_COLNUM, 20 );
m_rightGridLayers->SetColSize( COLOR_COLNUM, 20 );
// Select a not show cell, to avoid a wrong cell selection for user
m_leftGridLayers->GoToCell( 0, LAYERID_COLNUM );
m_rightGridLayers->GoToCell( 0, LAYERID_COLNUM );
int left_row = 0;
int right_row = 0;
wxString layernum;
wxString layername;
for( LAYER_NUM i = FIRST_LAYER; i < NB_LAYERS; ++i )
{
LAYER_NUM layerid = i;
if( m_layerorder )
layerid = layertranscode[i];
if( ! IsLayerEnabled( layerid ) )
continue;
if( m_minLayer >= 0 && layerid < m_minLayer )
continue;
if( m_maxLayer >= 0 && layerid > m_maxLayer )
continue;
wxColour color = MakeColour( GetLayerColor( layerid ) );
layername = GetLayerName( layerid );
layernum.Printf( wxT("%d"), layerid );
if( layerid <= LAST_COPPER_LAYER )
{
if( left_row )
m_leftGridLayers->AppendRows( 1 );
m_leftGridLayers->SetCellBackgroundColour ( left_row, COLOR_COLNUM,
color );
m_leftGridLayers->SetCellValue( left_row, LAYERNAME_COLNUM,
layername );
m_leftGridLayers->SetCellValue( left_row, LAYERID_COLNUM,
layernum );
if( m_layerSelected == layerid )
{
m_leftGridLayers->SetCellValue( left_row, SELECT_COLNUM,
wxT("X") );
m_leftGridLayers->SetCellBackgroundColour ( left_row, SELECT_COLNUM,
color );
}
left_row++;
}
else
{
if( right_row )
m_rightGridLayers->AppendRows( 1 );
m_rightGridLayers->SetCellBackgroundColour ( right_row, COLOR_COLNUM,
color );
m_rightGridLayers->SetCellValue( right_row, LAYERNAME_COLNUM,
layername );
m_rightGridLayers->SetCellValue( right_row, LAYERID_COLNUM,
layernum );
if( m_layerSelected == layerid )
{
m_rightGridLayers->SetCellValue( right_row, SELECT_COLNUM,
wxT("X") );
m_rightGridLayers->SetCellBackgroundColour ( right_row, SELECT_COLNUM,
color );
}
right_row++;
}
}
// Show only populated lists:
if( left_row <= 0 )
m_leftGridLayers->Show( false );
if( right_row <= 0 )
m_rightGridLayers->Show( false );
m_leftGridLayers->AutoSizeColumn(LAYERNAME_COLNUM);
m_rightGridLayers->AutoSizeColumn(LAYERNAME_COLNUM);
m_leftGridLayers->AutoSizeColumn(SELECT_COLNUM);
m_rightGridLayers->AutoSizeColumn(SELECT_COLNUM);
}
void PCB_ONE_LAYER_SELECTOR::OnLeftGridClick( wxGridEvent& event )
{
wxString text = m_leftGridLayers->GetCellValue(event.GetRow(), LAYERID_COLNUM);
long layer;
text.ToLong( &layer );
m_layerSelected = layer;
EndModal( 1 );
}
void PCB_ONE_LAYER_SELECTOR::OnRightGridClick( wxGridEvent& event )
{
wxString text = m_rightGridLayers->GetCellValue(event.GetRow(), LAYERID_COLNUM);
long layer;
text.ToLong( &layer );
m_layerSelected = layer;
EndModal( 2 );
}
/** Install the dialog box for layer selection
* @param default_layer = Preselection (NB_PCB_LAYERS for "(Deselect)" layer)
* @param min_layer = min layer value (-1 if no min value)
* @param max_layer = max layer value (-1 if no max value)
* @param null_layer = display a "(Deselect)" radiobutton (when set to true)
* @param aDefaultLayer = Preselection (NB_PCB_LAYERS for "(Deselect)" layer)
* @param aMinlayer = min layer id value (-1 if no min value)
* @param aMaxLayer = max layer id value (-1 if no max value)
* @param aDeselectTool = display a "Clear" button when true
* @return new layer value (NB_PCB_LAYERS when "(Deselect)" radiobutton selected),
* or -1 if canceled
*
* Providing the option to also display a "(Deselect)" radiobutton makes the
* "Swap Layers" command (and GerbView's "Export to Pcbnew" command) more "user
* friendly", by permitting any layer to be "deselected" immediately after its
* Providing the option to also display a "Clear" button makes the
* "Swap Layers" command more "user friendly",
* by permitting any layer to be "deselected" immediately after its
* corresponding radiobutton has been clicked on. (It would otherwise be
* necessary to first cancel the "Select Layer:" dialog box (invoked after a
* different radiobutton is clicked on) prior to then clicking on the
* "Deselect"
* button provided within the "Swap Layers:" or "Layer selection:" dialog box).
* "Clear" button provided within the "Swap Layers:"
* or "Layer selection:" dialog box).
*/
LAYER_NUM PCB_BASE_FRAME::SelectLayer( LAYER_NUM default_layer,
LAYER_NUM min_layer,
LAYER_NUM max_layer,
bool null_layer )
LAYER_NUM PCB_BASE_FRAME::SelectLayer( LAYER_NUM aDefaultLayer,
LAYER_NUM aMinlayer,
LAYER_NUM aMaxLayer,
bool aDeselectTool )
{
SELECT_LAYER_DIALOG* frame = new SELECT_LAYER_DIALOG( this,
default_layer,
min_layer,
max_layer,
null_layer );
LAYER_NUM layer = frame->ShowModal();
frame->Destroy();
PCB_ONE_LAYER_SELECTOR dlg( this, GetBoard(),
aDefaultLayer, aMinlayer, aMaxLayer,
aDeselectTool );
dlg.ShowModal();
LAYER_NUM layer = dlg.GetLayerSelection();
return layer;
}
/*
* The "OK" and "Cancel" buttons are positioned (in a horizontal line)
* beneath the "Layer" radiobox, unless that contains only one column of
* radiobuttons, in which case they are positioned (in a vertical line)
* to the right of that radiobox.
* This class display a double pcb copper layers list in a dialog,
* to select a layer pair from this list
*/
SELECT_LAYER_DIALOG::SELECT_LAYER_DIALOG( PCB_BASE_FRAME* parent,
LAYER_NUM default_layer, LAYER_NUM min_layer,
LAYER_NUM max_layer, bool null_layer ) :
wxDialog( parent, -1, _( "Select Layer:" ), wxPoint( -1, -1 ),
wxSize( 470, 250 ),
DIALOG_STYLE )
{
BOARD* board = parent->GetBoard();
wxButton* Button;
LAYER_NUM ii;
wxString LayerList[NB_PCB_LAYERS + 1]; // One extra element for "(Deselect)"
// radiobutton
int LayerCount, LayerSelect = -1;
m_Parent = parent;
// Build the layer list
LayerCount = 0;
LAYER_MSK Masque_Layer = g_TabAllCopperLayerMask[board->GetCopperLayerCount() - 1];
Masque_Layer |= ALL_NO_CU_LAYERS;
for( ii = FIRST_LAYER; ii < NB_PCB_LAYERS; ++ii )
{
m_LayerId[ii] = FIRST_LAYER;
if( GetLayerMask( ii ) & Masque_Layer )
{
if( min_layer > ii )
continue;
if( ( max_layer >= 0 ) && ( max_layer < ii ) )
break;
LayerList[LayerCount] = board->GetLayerName( ii );
if( ii == default_layer )
LayerSelect = LayerCount;
m_LayerId[LayerCount] = ii;
LayerCount++;
}
}
// When appropriate, also provide a "(Deselect)" radiobutton
if( null_layer )
{
LayerList[LayerCount] = _( "(Deselect)" );
if( NB_PCB_LAYERS == default_layer )
LayerSelect = LayerCount;
m_LayerId[LayerCount] = NB_PCB_LAYERS;
LayerCount++;
}
m_LayerList = new wxRadioBox( this, ID_LAYER_SELECT, _( "Layer" ),
wxPoint( -1, -1 ), wxSize( -1, -1 ),
LayerCount, LayerList,
(LayerCount < 8) ? LayerCount : 8,
wxRA_SPECIFY_ROWS );
if( LayerSelect >= 0 )
m_LayerList->SetSelection( LayerSelect );
wxBoxSizer* FrameBoxSizer = new wxBoxSizer( wxHORIZONTAL );
SetSizer( FrameBoxSizer );
FrameBoxSizer->Add( m_LayerList, 0, wxALIGN_TOP | wxALL, 5 );
wxBoxSizer* ButtonBoxSizer = new wxBoxSizer( wxVERTICAL );
FrameBoxSizer->Add( ButtonBoxSizer, 0, wxALIGN_BOTTOM | wxALL, 0 );
Button = new wxButton( this, wxID_OK, _( "OK" ) );
Button->SetDefault();
ButtonBoxSizer->Add( Button, 0, wxGROW | wxALL, 5 );
Button = new wxButton( this, wxID_CANCEL, _( "Cancel" ) );
ButtonBoxSizer->Add( Button, 0, wxGROW | wxALL, 5 );
SetFocus();
GetSizer()->SetSizeHints( this );
Center();
}
void SELECT_LAYER_DIALOG::OnLayerSelected( wxCommandEvent& event )
{
int ii = m_LayerId[m_LayerList->GetSelection()];
EndModal( ii );
}
void SELECT_LAYER_DIALOG::OnCancelClick( wxCommandEvent& event )
{
EndModal( -1 );
}
/*********************************************/
/* Dialog for the selecting pairs of layers. */
/*********************************************/
class SELECT_LAYERS_PAIR_DIALOG : public wxDialog
class SELECT_COPPER_LAYERS_PAIR_DIALOG: public PCB_LAYER_SELECTOR,
public DIALOG_COPPER_LAYER_PAIR_SELECTION_BASE
{
private:
PCB_BASE_FRAME* m_Parent;
wxRadioBox* m_LayerListTOP;
wxRadioBox* m_LayerListBOTTOM;
LAYER_NUM m_LayerId[NB_COPPER_LAYERS];
BOARD* m_brd;
LAYER_NUM m_frontLayer;
LAYER_NUM m_backLayer;
int m_leftRowSelected;
int m_rightRowSelected;
public: SELECT_LAYERS_PAIR_DIALOG( PCB_BASE_FRAME* parent );
~SELECT_LAYERS_PAIR_DIALOG() { };
public:
SELECT_COPPER_LAYERS_PAIR_DIALOG( wxWindow* aParent, BOARD * aPcb,
LAYER_NUM aFrontLayer, LAYER_NUM aBackLayer );
void GetLayerPair( LAYER_NUM& aFrontLayer, LAYER_NUM& aBackLayer )
{
aFrontLayer = m_frontLayer;
aBackLayer = m_backLayer;
}
private:
void OnOkClick( wxCommandEvent& event );
void OnCancelClick( wxCommandEvent& event );
void OnLeftGridClick( wxGridEvent& event );
void OnRightGridClick( wxGridEvent& event );
void OnOkClick( wxCommandEvent& event )
{
EndModal( wxID_OK );
}
void OnCancelClick( wxCommandEvent& event )
{
EndModal( wxID_CANCEL );
}
void BuildList();
DECLARE_EVENT_TABLE()
};
BEGIN_EVENT_TABLE( SELECT_LAYERS_PAIR_DIALOG, wxDialog )
EVT_BUTTON( wxID_OK, SELECT_LAYERS_PAIR_DIALOG::OnOkClick )
EVT_BUTTON( wxID_CANCEL, SELECT_LAYERS_PAIR_DIALOG::OnCancelClick )
END_EVENT_TABLE()
/* Display a list of two copper layers for selection of a pair of layers
/* Display a list of two copper layers to choose a pair of layers
* for auto-routing, vias ...
*/
void PCB_BASE_FRAME::SelectLayerPair()
{
// Check whether more than one copper layer has been enabled for the
// current PCB file, as Layer Pairs can only meaningfully be defined
// within PCB files which contain at least two copper layers.
if( GetBoard()->GetCopperLayerCount() < 2 )
PCB_SCREEN* screen = GetScreen();
SELECT_COPPER_LAYERS_PAIR_DIALOG dlg( this, GetBoard(),
screen->m_Route_Layer_TOP,
screen->m_Route_Layer_BOTTOM );
if( dlg.ShowModal() == wxID_OK )
{
wxString InfoMsg;
InfoMsg = _( "Less than two copper layers are being used." );
InfoMsg << wxT( "\n" ) << _( "Hence layer pairs cannot be specified." );
DisplayInfoMessage( this, InfoMsg );
return;
dlg.GetLayerPair( screen->m_Route_Layer_TOP, screen->m_Route_Layer_BOTTOM );
// select the same layer for both layers is allowed (normal in some boards)
// but could be a mistake. So display an info message
if( screen->m_Route_Layer_TOP == screen->m_Route_Layer_BOTTOM )
DisplayInfoMessage( this,
_( "Warning: The Top Layer and Bottom Layer are same." ) );
}
SELECT_LAYERS_PAIR_DIALOG* frame = new SELECT_LAYERS_PAIR_DIALOG( this );
int result = frame->ShowModal();
frame->Destroy();
m_canvas->MoveCursorToCrossHair();
// if user changed colors and we are in high contrast mode, then redraw
// because the PAD_SMD pads may change color.
if( result >= 0 && DisplayOpt.ContrastModeDisplay )
{
m_canvas->Refresh();
}
}
SELECT_LAYERS_PAIR_DIALOG::SELECT_LAYERS_PAIR_DIALOG( PCB_BASE_FRAME* parent ) :
wxDialog( parent, -1, _( "Select Layer Pair:" ), wxPoint( -1, -1 ),
wxSize( 470, 250 ), DIALOG_STYLE )
SELECT_COPPER_LAYERS_PAIR_DIALOG::
SELECT_COPPER_LAYERS_PAIR_DIALOG( wxWindow* aParent, BOARD * aPcb,
LAYER_NUM aFrontLayer, LAYER_NUM aBackLayer) :
PCB_LAYER_SELECTOR( aPcb ),
DIALOG_COPPER_LAYER_PAIR_SELECTION_BASE( aParent )
{
BOARD* board = parent->GetBoard();
wxButton* Button;
wxString LayerList[NB_COPPER_LAYERS];
LAYER_NUM LayerTopSelect = FIRST_LAYER, LayerBottomSelect = FIRST_LAYER;
m_Parent = parent;
PCB_SCREEN* screen = (PCB_SCREEN*) m_Parent->GetScreen();
LAYER_MSK Masque_Layer = g_TabAllCopperLayerMask[board->GetCopperLayerCount() - 1];
Masque_Layer |= ALL_NO_CU_LAYERS;
LAYER_NUM LayerCount = FIRST_LAYER;
for( LAYER_NUM ii = FIRST_COPPER_LAYER; ii < NB_COPPER_LAYERS; ++ii )
{
m_LayerId[ii] = FIRST_LAYER;
if( (GetLayerMask( ii ) & Masque_Layer) )
{
LayerList[LayerCount] = board->GetLayerName( ii );
if( ii == screen->m_Route_Layer_TOP )
LayerTopSelect = LayerCount;
if( ii == screen->m_Route_Layer_BOTTOM )
LayerBottomSelect = LayerCount;
m_LayerId[LayerCount] = ii;
++LayerCount;
}
}
m_LayerListTOP = new wxRadioBox( this, ID_LAYER_SELECT_TOP,
_( "Top Layer" ),
wxPoint( -1, -1 ), wxSize( -1, -1 ),
LayerCount, LayerList,
(LayerCount < 8) ? LayerCount : 8,
wxRA_SPECIFY_ROWS );
m_LayerListTOP->SetSelection( LayerTopSelect );
m_LayerListBOTTOM = new wxRadioBox( this, ID_LAYER_SELECT_BOTTOM,
_( "Bottom Layer" ),
wxPoint( -1, -1 ), wxSize( -1, -1 ),
LayerCount, LayerList,
(LayerCount < 8) ? LayerCount : 8,
wxRA_SPECIFY_ROWS );
m_LayerListBOTTOM->SetSelection( LayerBottomSelect );
wxBoxSizer* FrameBoxSizer = new wxBoxSizer( wxVERTICAL );
SetSizer( FrameBoxSizer );
wxBoxSizer* RadioBoxSizer = new wxBoxSizer( wxHORIZONTAL );
FrameBoxSizer->Add( RadioBoxSizer, 0, wxALIGN_LEFT | wxALL, 0 );
wxBoxSizer* ButtonBoxSizer = new wxBoxSizer( wxHORIZONTAL );
FrameBoxSizer->Add( ButtonBoxSizer, 0, wxALIGN_RIGHT | wxALL, 0 );
RadioBoxSizer->Add( m_LayerListTOP, 0, wxALIGN_TOP | wxALL, 5 );
RadioBoxSizer->Add( m_LayerListBOTTOM, 0, wxALIGN_TOP | wxALL, 5 );
Button = new wxButton( this, wxID_OK, _( "OK" ) );
Button->SetDefault();
ButtonBoxSizer->Add( Button, 0, wxGROW | wxALL, 5 );
Button = new wxButton( this, wxID_CANCEL, _( "Cancel" ) );
ButtonBoxSizer->Add( Button, 0, wxGROW | wxALL, 5 );
m_frontLayer = aFrontLayer;
m_backLayer = aBackLayer;
m_leftRowSelected = 0;
m_rightRowSelected = 0;
BuildList();
SetFocus();
GetSizer()->SetSizeHints( this );
Center();
}
void SELECT_LAYERS_PAIR_DIALOG::OnOkClick( wxCommandEvent& event )
void SELECT_COPPER_LAYERS_PAIR_DIALOG::BuildList()
{
// select the same layer for top and bottom is allowed (normal in some
// boards)
// but could be a mistake. So display an info message
if( m_LayerId[m_LayerListTOP->GetSelection()] == m_LayerId[m_LayerListBOTTOM->GetSelection()] )
DisplayInfoMessage( this,
_( "Warning: The Top Layer and Bottom Layer are same." ) );
m_leftGridLayers->SetColFormatNumber( LAYERID_COLNUM );
m_rightGridLayers->SetColFormatNumber( LAYERID_COLNUM );
m_leftGridLayers->HideCol( LAYERID_COLNUM );
m_rightGridLayers->HideCol( LAYERID_COLNUM );
m_leftGridLayers->SetColSize( COLOR_COLNUM, 20 );
m_rightGridLayers->SetColSize( COLOR_COLNUM, 20 );
PCB_SCREEN* screen = (PCB_SCREEN*) m_Parent->GetScreen();
// Select a not show cell, to avoid a wrong cell selection for user
m_leftGridLayers->GoToCell( 0, LAYERID_COLNUM );
m_rightGridLayers->GoToCell( 0, LAYERID_COLNUM );
screen->m_Route_Layer_TOP = m_LayerId[m_LayerListTOP->GetSelection()];
screen->m_Route_Layer_BOTTOM = m_LayerId[m_LayerListBOTTOM->GetSelection()];
int row = 0;
wxString layernum;
wxString layername;
for( LAYER_NUM i = FIRST_LAYER; i < NB_LAYERS; ++i )
{
LAYER_NUM layerid = i;
EndModal( 0 );
if( m_layerorder )
layerid = layertranscode[i];
if( ! IsLayerEnabled( layerid ) )
continue;
if( layerid > LAST_COPPER_LAYER )
continue;
wxColour color = MakeColour( GetLayerColor( layerid ) );
layername = GetLayerName( layerid );
layernum.Printf( wxT("%d"), layerid );
if( row )
m_leftGridLayers->AppendRows( 1 );
m_leftGridLayers->SetCellBackgroundColour ( row, COLOR_COLNUM,
color );
m_leftGridLayers->SetCellValue( row, LAYERNAME_COLNUM,
layername );
m_leftGridLayers->SetCellValue( row, LAYERID_COLNUM,
layernum );
if( m_frontLayer == layerid )
{
m_leftGridLayers->SetCellValue( row, SELECT_COLNUM,
wxT("X") );
m_leftGridLayers->SetCellBackgroundColour( row, SELECT_COLNUM,
color );
m_leftRowSelected = row;
}
if( row )
m_rightGridLayers->AppendRows( 1 );
m_rightGridLayers->SetCellBackgroundColour ( row, COLOR_COLNUM,
color );
m_rightGridLayers->SetCellValue( row, LAYERNAME_COLNUM,
layername );
m_rightGridLayers->SetCellValue( row, LAYERID_COLNUM,
layernum );
if( m_backLayer == layerid )
{
m_rightGridLayers->SetCellValue( row, SELECT_COLNUM,
wxT("X") );
m_rightGridLayers->SetCellBackgroundColour ( row, SELECT_COLNUM,
color );
m_rightRowSelected = row;
}
row++;
}
m_leftGridLayers->AutoSizeColumn(LAYERNAME_COLNUM);
m_rightGridLayers->AutoSizeColumn(LAYERNAME_COLNUM);
m_leftGridLayers->AutoSizeColumn(SELECT_COLNUM);
m_rightGridLayers->AutoSizeColumn(SELECT_COLNUM);
}
void SELECT_LAYERS_PAIR_DIALOG::OnCancelClick( wxCommandEvent& event )
void SELECT_COPPER_LAYERS_PAIR_DIALOG::OnLeftGridClick( wxGridEvent& event )
{
EndModal( -1 );
int row = event.GetRow();
wxString text = m_leftGridLayers->GetCellValue( row, LAYERID_COLNUM );
long layer;
text.ToLong( &layer );
if( m_frontLayer == layer )
return;
m_leftGridLayers->SetCellValue( m_leftRowSelected, SELECT_COLNUM,
wxEmptyString );
m_leftGridLayers->SetCellBackgroundColour ( m_leftRowSelected, SELECT_COLNUM,
m_leftGridLayers->GetDefaultCellBackgroundColour() );
m_frontLayer = layer;
m_leftRowSelected = row;
m_leftGridLayers->SetCellValue( row, SELECT_COLNUM,
wxT("X") );
m_leftGridLayers->SetCellBackgroundColour( row, SELECT_COLNUM,
MakeColour( GetLayerColor( layer ) ) );
}
void SELECT_COPPER_LAYERS_PAIR_DIALOG::OnRightGridClick( wxGridEvent& event )
{
int row = event.GetRow();
wxString text = m_rightGridLayers->GetCellValue( row, LAYERID_COLNUM );
long layer;
text.ToLong( &layer );
if( m_backLayer == layer )
return;
m_rightGridLayers->SetCellValue( m_rightRowSelected, SELECT_COLNUM,
wxEmptyString );
m_rightGridLayers->SetCellBackgroundColour ( m_rightRowSelected, SELECT_COLNUM,
m_rightGridLayers->GetDefaultCellBackgroundColour() );
m_backLayer = layer;
m_rightRowSelected = row;
m_rightGridLayers->SetCellValue( row, SELECT_COLNUM,
wxT("X") );
m_rightGridLayers->SetCellBackgroundColour ( row, SELECT_COLNUM,
MakeColour( GetLayerColor( layer ) ) );
}