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

layer names in *.brd file

This commit is contained in:
dickelbeck 2008-03-04 04:22:27 +00:00
parent 7c482f68b3
commit 10e13ae50a
39 changed files with 1703 additions and 1547 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
change_log.txt
View File

@ -5,16 +5,27 @@ Started 2007-June-11
Please add newer entries at the top, list the date and your name with
email address.
2008-Mar-3 UPDATE Dick Hollenbeck <dick@softplc.com>
================================================================================
+pcbnew
Completed transision to BOARD::GetLayerName() and away from ReturnPcbLayerName().
LayerNames and LAYER_T are saved int the *.brd file and may be edited
there with a text editor until the UI is in place to edit them in PCBNEW.
To understand the strategy, see BOARD::GetLayerName() in class_board.cpp
and see WinEDA_BasePcbFrame::ReadSetup(). I will be adding "Board" menu
item to Preferences, but there is more to come before the UI gets done:
net classes.
2008-mars-03 UPDATE Jean-Pierre Charras <jean-pierre.charras@inpg.fr>
================================================================================
3d display:
Added Jonas Diemer's patch (enhanced movings from mouse and tools)
Added Jonas Diemer's patch (enhanced movings from mouse and tools)
2008-Mar-1 UPDATE Dick Hollenbeck <dick@softplc.com>
================================================================================
+pcbnew
Changed ioascii.cpp to save and load board specific layer names, for DEBUG
build only. I want to add class LAYER, see below. Added
BOARD::SetLayerName(), BOARD::SetLayerType(), and BOARD::GetLayerType().

65
common/common.cpp
View File

@ -265,8 +265,6 @@ void MyFree( void* pt_mem )
}
/**************************************************************/
wxString ReturnPcbLayerName( int layer_number, bool omitSpacePadding )
/**************************************************************/
@ -276,32 +274,11 @@ wxString ReturnPcbLayerName( int layer_number, bool omitSpacePadding )
* (not internatinalized, no space)
*/
{
#if 1 && defined(DEBUG)
// Dick: this code is working fine, but we have no place to store the layer names yet.
const unsigned LAYER_LIMIT = 29;
// @todo: these layer names should be configurable on a per project basis.
// In anticipation of that enhancement, here is a different strategy for
// deriving the file names from the "configured" layer names.
// The main idea is to use a single array of names, and then remove
// spaces on the fly from the names when writing to disk.
// These are only default layer names. For PCBNEW, the copper names
// may be over-ridden in the BOARD file *.brd.
#if 1 // my specific layer names
static const wxString layer_name_list[] = {
_( "H2 Bottom" ), _( "Power" ), _( "V2 Signal" ), _( "H1 Signal" ),
_( "Ground" ), _( "Inner L5" ), _( "Inner L6" ), _( "Inner L7" ),
_( "Inner L8" ), _( "Inner L9" ), _( "Inner L10" ), _( "Inner L11" ),
_( "Inner L12" ), _( "Inner L13" ), _( "Inner L14" ), _( "Component" ),
_( "Adhes Cop" ), _( "Adhes Cmp" ), _( "SoldP Cop" ), _( "SoldP Cmp" ),
_( "SilkS Cop" ), _( "SilkS Cmp" ), _( "Mask Cop" ), _( "Mask Cmp" ),
_( "Drawings " ), _( "Comments" ), _( "Eco1" ), _( "Eco2" ),
_( "Edges Pcb" ), _( "BAD INDEX" ),
};
#else
static const wxString layer_name_list[] = {
_( "Copper " ), _( "Inner L1 " ), _( "Inner L2 " ), _( "Inner L3 " ),
_( "Inner L4 " ), _( "Inner L5 " ), _( "Inner L6 " ), _( "Inner L7 " ),
@ -313,8 +290,6 @@ wxString ReturnPcbLayerName( int layer_number, bool omitSpacePadding )
_( "Edges Pcb" ), _( "BAD INDEX" ),
};
#endif
if( (unsigned) layer_number > LAYER_LIMIT )
layer_number = LAYER_LIMIT;
@ -332,42 +307,6 @@ wxString ReturnPcbLayerName( int layer_number, bool omitSpacePadding )
}
else
return *p;
#else // long standing established code:
static const wxString layer_name_list[] = {
_( "Copper " ), _( "Inner L1 " ), _( "Inner L2 " ), _( "Inner L3 " ),
_( "Inner L4 " ), _( "Inner L5 " ), _( "Inner L6 " ), _( "Inner L7 " ),
_( "Inner L8 " ), _( "Inner L9 " ), _( "Inner L10" ), _( "Inner L11" ),
_( "Inner L12" ), _( "Inner L13" ), _( "Inner L14" ), _( "Component" ),
_( "Adhes Cop" ), _( "Adhes Cmp" ), _( "SoldP Cop" ), _( "SoldP Cmp" ),
_( "SilkS Cop" ), _( "SilkS Cmp" ), _( "Mask Cop " ), _( "Mask Cmp " ),
_( "Drawings " ), _( "Comments " ), _( "Eco1 " ), _( "Eco2 " ),
_( "Edges Pcb" ), _( "--- " ), _( "--- " ), _( "--- " )
};
// Same as layer_name_list, without space, not internationalized
static const wxString layer_name_list_for_filename[] = {
wxT( "Copper" ), wxT( "InnerL1" ), wxT( "InnerL2" ), wxT( "InnerL3" ),
wxT( "InnerL4" ), wxT( "InnerL5" ), wxT( "InnerL6" ), wxT( "InnerL7" ),
wxT( "InnerL8" ), wxT( "InnerL9" ), wxT( "InnerL10" ), wxT( "InnerL11" ),
wxT( "InnerL12" ), wxT( "InnerL13" ), wxT( "InnerL14" ), wxT( "Component" ),
wxT( "AdhesCop" ), wxT( "AdhesCmp" ), wxT( "SoldPCop" ), wxT( "SoldPCmp" ),
wxT( "SilkSCop" ), wxT( "SilkSCmp" ), wxT( "MaskCop" ), wxT( "MaskCmp" ),
wxT( "Drawings" ), wxT( "Comments" ), wxT( "Eco1" ), wxT( "Eco2" ),
wxT( "EdgesPcb" ), wxT( "---" ), wxT( "---" ), wxT( "---" )
};
if( (unsigned) layer_number >= 31u )
layer_number = 31;
return omitSpacePadding ?
layer_name_list_for_filename[layer_number] :
layer_name_list[layer_number];
#endif
}

7
common/projet_config.cpp
View File

@ -125,8 +125,8 @@ void WinEDA_App::WriteProjectConfig( const wxString& local_config_filename,
switch( pt_cfg->m_Type )
{
case PARAM_INT:
#undef PTCFG
#define PTCFG ( (PARAM_CFG_INT*) pt_cfg )
#undef PTCFG
#define PTCFG ( (PARAM_CFG_INT*) pt_cfg )
if( PTCFG->m_Pt_param == NULL )
break;
@ -319,7 +319,8 @@ bool WinEDA_App::ReadProjectConfig( const wxString& local_config_filename,
{
#undef PTCFG
#define PTCFG ( (PARAM_CFG_DOUBLE*) pt_cfg )
double ftmp = 0; wxString msg;
double ftmp = 0;
wxString msg;
if( pt_cfg->m_Setup )
msg = m_EDA_Config->Read( pt_cfg->m_Ident, wxT( "" ) );
else

96
cvpcb/cfg.cpp
View File

@ -1,6 +1,6 @@
/***************************************/
/** cfg.cpp : configuration de CVPCB **/
/***************************************/
/***************************************/
/** cfg.cpp : configuration de CVPCB **/
/***************************************/
/* lit ou met a jour la configuration de CVPCB */
@ -18,68 +18,76 @@
/**************************************************/
void Read_Config( const wxString & FileName )
void Read_Config( const wxString& FileName )
/**************************************************/
/* lit la configuration
1 - lit cvpcb.cnf
2 - si non trouve lit <chemin de cvpcb.exe>/cvpcb.cnf
3 - si non trouve: init des variables aux valeurs par defaut
Remarque:
le chemin de l'executable cvpcb.exe doit etre dans BinDir
*/
* 1 - lit cvpcb.cnf
* 2 - si non trouve lit <chemin de cvpcb.exe>/cvpcb.cnf
* 3 - si non trouve: init des variables aux valeurs par defaut
*
* Remarque:
* le chemin de l'executable cvpcb.exe doit etre dans BinDir
*/
{
wxString FullFileName = FileName ;
wxString FullFileName = FileName;
/* Init des valeurs par defaut */
g_LibName_List.Clear();
g_ListName_Equ.Clear();
/* Init des valeurs par defaut */
g_LibName_List.Clear();
g_ListName_Equ.Clear();
g_EDA_Appl->ReadProjectConfig(FullFileName,
GROUP, ParamCfgList, FALSE);
g_EDA_Appl->ReadProjectConfig( FullFileName,
GROUP, ParamCfgList, FALSE );
if ( PkgInExtBuffer.IsEmpty() ) PkgInExtBuffer = wxT(".pkg");
if ( NetInExtBuffer.IsEmpty() ) NetInExtBuffer = wxT(".net"),
if( PkgInExtBuffer.IsEmpty() )
PkgInExtBuffer = wxT( ".pkg" );
/* Inits autres variables */
SetRealLibraryPath( wxT("modules"));
if( NetInExtBuffer.IsEmpty() )
NetInExtBuffer = wxT( ".net" );
/* Inits autres variables */
SetRealLibraryPath( wxT( "modules" ) );
}
/************************************************************/
void WinEDA_CvpcbFrame::Update_Config(wxCommandEvent& event)
void WinEDA_CvpcbFrame::Update_Config( wxCommandEvent& event )
/************************************************************/
/* fonction relai d'appel a Save_Config,
la vraie fonction de sauvegarde de la config
*/
* la vraie fonction de sauvegarde de la config
*/
{
Save_Config(this);
Save_Config( this );
}
/************************************/
void Save_Config(wxWindow * parent)
void Save_Config( wxWindow* parent )
/************************************/
/* enregistrement de la config */
{
wxString path, FullFileName;
wxString mask( wxT("*"));
wxString path, FullFileName;
FullFileName = FFileName;
ChangeFileNameExt( FullFileName, g_Prj_Config_Filename_ext );
wxString mask( wxT( "*" ) );
path = wxGetCwd();
FullFileName = EDA_FileSelector(_("Save preferences"),
path, /* Chemin par defaut */
FullFileName, /* nom fichier par defaut */
g_Prj_Config_Filename_ext, /* extension par defaut */
mask, /* Masque d'affichage */
parent,
wxFD_SAVE,
TRUE
);
if ( FullFileName.IsEmpty()) return;
FullFileName = FFileName;
ChangeFileNameExt( FullFileName, g_Prj_Config_Filename_ext );
/* ecriture de la configuration */
g_EDA_Appl->WriteProjectConfig(FullFileName, GROUP, ParamCfgList);
path = wxGetCwd();
FullFileName = EDA_FileSelector( _( "Save preferences" ),
path, /* Chemin par defaut */
FullFileName, /* nom fichier par defaut */
g_Prj_Config_Filename_ext, /* extension par defaut */
mask, /* Masque d'affichage */
parent,
wxFD_SAVE,
TRUE
);
if( FullFileName.IsEmpty() )
return;
/* ecriture de la configuration */
g_EDA_Appl->WriteProjectConfig( FullFileName, GROUP, ParamCfgList );
}

2
cvpcb/displayframe.cpp
View File

@ -51,7 +51,7 @@ WinEDA_DisplayFrame::WinEDA_DisplayFrame( wxWindow* father, WinEDA_App* parent,
#endif
SetTitle( title );
m_Pcb = new BOARD( NULL, this );
m_Pcb = new BOARD( NULL, this );
m_CurrentScreen = new PCB_SCREEN( CVPCB_DISPLAY_FRAME );

2
gerbview/gerbview.cpp
View File

@ -55,8 +55,6 @@ bool WinEDA_App::OnInit()
SetTopWindow( m_GerberFrame );
m_GerberFrame->Show( TRUE );
m_GerberFrame->m_Pcb = new BOARD( NULL, m_GerberFrame );
m_GerberFrame->Zoom_Automatique( TRUE );
if( argc > 1 )

14
gerbview/gerbview_config.cpp
View File

@ -16,13 +16,16 @@
#include "protos.h"
/* Routines Locales */
/* Variables locales */
#define HOTKEY_FILENAME wxT( "gerbview" )
/* Routines Locales */
/* Variables locales */
/*************************************************************/
void WinEDA_GerberFrame::Process_Config( wxCommandEvent& event )
/*************************************************************/
@ -32,7 +35,8 @@ void WinEDA_GerberFrame::Process_Config( wxCommandEvent& event )
wxString FullFileName;
pos = GetPosition();
pos.x += 20; pos.y += 20;
pos.x += 20;
pos.y += 20;
switch( id )
{
@ -69,7 +73,7 @@ void WinEDA_GerberFrame::Process_Config( wxCommandEvent& event )
case ID_PREFERENCES_HOTKEY_PATH_IS_HOME:
case ID_PREFERENCES_HOTKEY_PATH_IS_KICAD:
HandleHotkeyConfigMenuSelection( this, id );
HandleHotkeyConfigMenuSelection( this, id );
break;
default:

27
gerbview/select_layers_to_pcb.cpp
View File

@ -13,10 +13,11 @@
#include "wx/statline.h"
/* Variables locales */
#define LAYER_UNSELECTED NB_LAYERS
static int ButtonTable[32]; // Indexes buttons to Gerber layers
static int LayerLookUpTable[32]; // Indexes Gerber layers to PCB file layers
wxStaticText* layer_list[32]; // Indexes text strings to buttons
#define LAYER_UNSELECTED NB_LAYERS
static int ButtonTable[32]; // Indexes buttons to Gerber layers
static int LayerLookUpTable[32]; // Indexes Gerber layers to PCB file layers
wxStaticText* layer_list[32]; // Indexes text strings to buttons
enum swap_layer_id {
ID_WINEDA_SWAPLAYERFRAME = 1800,
@ -75,12 +76,13 @@ int * InstallDialogLayerPairChoice(WinEDA_GerberFrame * parent)
*/
{
WinEDA_SwapLayerFrame * frame = new WinEDA_SwapLayerFrame(parent);
int ii = frame->ShowModal();
frame->Destroy();
if( ii >= 0 )
return LayerLookUpTable;
else
return NULL;
int ii = frame->ShowModal();
frame->Destroy();
if( ii >= 0 )
return LayerLookUpTable;
else
return NULL;
}
@ -138,7 +140,6 @@ WinEDA_SwapLayerFrame::WinEDA_SwapLayerFrame(WinEDA_GerberFrame *parent) :
int pcb_layer_number = 0;
for( nb_items = 0, ii = 0; ii < 32; ii++ )
{
if( g_GERBER_Descr_List[ii] == NULL )
continue;
@ -353,8 +354,8 @@ void WinEDA_SwapLayerFrame::OnCancelClick(wxCommandEvent& event)
void WinEDA_SwapLayerFrame::OnOkClick(wxCommandEvent& event)
/*********************************************************/
{
int ii;
bool AsCmpLayer = false;
int ii;
bool AsCmpLayer = false;
/* Compute the number of copper layers
* this is the max layer number + 1 (if some internal layers exist)

34
include/pcbstruct.h
View File

@ -148,38 +148,6 @@ struct CHEVELU;
/* Class to handle a board */
#include "class_board.h"
/**
* Class LAYER
* holds information pertinent to a layer of a BOARD.
*/
class LAYER
{
wxString m_Name;
LAYER_T m_Type;
int m_Color;
bool m_Visible; // ? use flags in m_Color instead ?
public:
bool SetName( const wxString& aLayerName );
const wxString& GetName();
bool SetType( LAYER_T aLayerType );
LAYER_T GetType();
int GetColor() { return m_Color; }
void SetColor( int aColor ) { m_Color = aColor; }
bool IsVisible();
void SetVisible( bool isVisible );
};
// Class for handle current printed board design settings
#define HISTORY_NUMBER 8
class EDA_BoardDesignSettings
@ -207,7 +175,9 @@ public:
// Color options for screen display of the Printed Board:
int m_PcbGridColor; // Grid color
int m_LayerColor[32]; // Layer colors (tracks and graphic items)
int m_ViaColor[4]; // Via color (depending on is type)
int m_ModuleTextCMPColor; // Text module color for modules on the COMPONENT layer
int m_ModuleTextCUColor; // Text module color for modules on the COPPER layer

46
include/wxPcbStruct.h
View File

@ -74,6 +74,14 @@ public:
~WinEDA_BasePcbFrame();
/**
* Function SetBOARD
* sets the m_Pcb member in such as way as to ensure deleting any previous
* BOARD.
* @param aBoard The BOARD to put into the frame.
*/
void SetBOARD( BOARD* aBoard );
// General
virtual void OnCloseWindow( wxCloseEvent& Event ) = 0;
virtual void Process_Special_Functions( wxCommandEvent& event ) = 0;
@ -499,12 +507,12 @@ public:
/** Function Delete_LastCreatedCorner
* Used only while creating a new zone outline
* Remove and delete the current outline segment in progress
* @return 0 if no corner in list, or corner number
*/
int Delete_LastCreatedCorner( wxDC* DC);
/** Function Delete_LastCreatedCorner
* Used only while creating a new zone outline
* Remove and delete the current outline segment in progress
* @return 0 if no corner in list, or corner number
*/
int Delete_LastCreatedCorner( wxDC* DC);
/**
* Function Begin_Zone
@ -517,7 +525,7 @@ public:
* Function End_Zone
* terminates (if no DRC error ) the zone edge creation process
* @param DC = current Device Context
* @return true if Ok, false if DRC error
* @return true if Ok, false if DRC error
*/
bool End_Zone( wxDC* DC );
@ -586,11 +594,11 @@ public:
ZONE_CONTAINER* zone_container,
int corner_id );
/**
* Function End_Move_Zone_Corner_Or_Outlines
* Terminates a move corner in a zone outline, or a move zone outlines
* @param DC = current Device Context (can be NULL)
* @param zone_container: the given zone
/**
* Function End_Move_Zone_Corner_Or_Outlines
* Terminates a move corner in a zone outline, or a move zone outlines
* @param DC = current Device Context (can be NULL)
* @param zone_container: the given zone
*/
void End_Move_Zone_Corner_Or_Outlines( wxDC* DC, ZONE_CONTAINER* zone_container );
@ -612,13 +620,13 @@ public:
*/
void Delete_Zone_Contour( wxDC* DC, ZONE_CONTAINER* zone_container );
/**
* Function Start_Move_Zone_Outlines
* Initialise parametres to move an existing zone outlines.
/**
* Function Start_Move_Zone_Outlines
* Initialise parametres to move an existing zone outlines.
* @param DC = current Device Context (can be NULL)
* @param zone_container: the given zone to move
*/
void Start_Move_Zone_Outlines( wxDC* DC, ZONE_CONTAINER* zone_container );
* @param zone_container: the given zone to move
*/
void Start_Move_Zone_Outlines( wxDC* DC, ZONE_CONTAINER* zone_container );
// Target handling
MIREPCB* Create_Mire( wxDC* DC );
@ -725,7 +733,7 @@ public:
int BestZoom(); // Retourne le meilleur zoom
void OnSelectOptionToolbar( wxCommandEvent& event );
void OnHotKey( wxDC* DC, int hotkey, EDA_BaseStruct* DrawStruct );
PCB_SCREEN* GetPCBScreen(){ return (PCB_SCREEN*)GetScreen(); }
PCB_SCREEN* GetPCBScreen(){ return (PCB_SCREEN*)GetScreen(); }
EDA_BaseStruct* GerberGeneralLocateAndDisplay();
EDA_BaseStruct* Locate( int typeloc );

9
pcbnew/basepcbframe.cpp
View File

@ -66,6 +66,13 @@ WinEDA_BasePcbFrame::~WinEDA_BasePcbFrame( void )
}
void WinEDA_BasePcbFrame::SetBOARD( BOARD* aBoard )
{
delete m_Pcb;
m_Pcb = aBoard;
}
/**************************************/
int WinEDA_BasePcbFrame::BestZoom( void )
/**************************************/
@ -102,7 +109,7 @@ void WinEDA_BasePcbFrame::CursorGoto( const wxPoint& aPos )
{
// factored out of pcbnew/find.cpp
PCB_SCREEN* screen = (PCB_SCREEN*)GetScreen();
PCB_SCREEN* screen = (PCB_SCREEN*)GetScreen();
wxClientDC dc( DrawPanel );

84
pcbnew/class_board.cpp
View File

@ -38,6 +38,12 @@ BOARD::BOARD( EDA_BaseStruct* parent, WinEDA_BasePcbFrame* frame ) :
m_LocalRatsnest = NULL; // pointeur liste rats local
m_CurrentZoneContour = NULL; // This ZONE_CONTAINER handle the zone contour cuurently in progress
// de determination des contours de zone
for( int layer=0; layer<NB_COPPER_LAYERS; ++layer )
{
m_Layer[layer].m_Name = ReturnPcbLayerName( layer );
m_Layer[layer].m_Type = LT_SIGNAL;
}
}
@ -80,28 +86,96 @@ BOARD::~BOARD()
wxString BOARD::GetLayerName( int aLayerIndex ) const
{
// copper layer names are stored in the BOARD.
if( (unsigned) aLayerIndex < (unsigned) GetCopperLayerCount() )
{
// default names were set in BOARD::BOARD() but they may be
// over-ridden by BOARD::SetLayerName()
return m_Layer[aLayerIndex].m_Name;
}
return ReturnPcbLayerName( aLayerIndex, true );
}
bool BOARD::SetLayerName( int aLayerIndex, const wxString& aLayerName )
{
// a dummy temporarily.
D(printf("SetLayerName( %d, %s )\n", aLayerIndex, CONV_TO_UTF8(aLayerName) );)
return true;
if( (unsigned) aLayerIndex < (unsigned) GetCopperLayerCount() )
{
if( aLayerName == wxEmptyString || aLayerName.Len() > 20 )
return false;
// no quote chars in the name allowed
if( aLayerName.Find( wxChar('"') ) != wxNOT_FOUND )
return false;
// ensure unique-ness of layer names
for( int layer=0; layer<GetCopperLayerCount(); ++layer )
{
if( layer!=aLayerIndex && aLayerName == m_Layer[layer].m_Name )
return false;
}
m_Layer[aLayerIndex].m_Name = aLayerName;
// replace any spaces with underscores
m_Layer[aLayerIndex].m_Name.Replace( wxT(" "), wxT("_") );
return true;
}
return false;
}
LAYER_T BOARD::GetLayerType( int aLayerIndex ) const
{
if( (unsigned) aLayerIndex < (unsigned) GetCopperLayerCount() )
return m_Layer[aLayerIndex].m_Type;
return LT_SIGNAL;
}
bool BOARD::SetLayerType( int aLayerIndex, LAYER_T aLayerType )
{
// a dummy temporarily.
return true;
if( (unsigned) aLayerIndex < (unsigned) GetCopperLayerCount() )
{
m_Layer[aLayerIndex].m_Type = aLayerType;
return true;
}
return false;
}
const char* LAYER::ShowType( LAYER_T aType )
{
const char* cp;
switch( aType )
{
default:
case LT_SIGNAL: cp = "signal"; break;
case LT_POWER: cp = "power"; break;
case LT_MIXED: cp = "mixed"; break;
case LT_JUMPER: cp = "jumper"; break;
}
return cp;
}
LAYER_T LAYER::ParseType( const char* aType )
{
if( strcmp( aType, "signal" ) == 0 )
return LT_SIGNAL;
else if( strcmp( aType, "power" ) == 0 )
return LT_POWER;
else if( strcmp( aType, "mixed" ) == 0 )
return LT_MIXED;
else if( strcmp( aType, "jumper" ) == 0 )
return LT_JUMPER;
else
return LAYER_T(-1);
}

44
pcbnew/class_board.h
View File

@ -18,14 +18,49 @@ enum LAYER_T
LT_SIGNAL,
LT_POWER,
LT_MIXED,
LT_JUMPER,
};
/***********************************************/
/* class BOARD : handle datas to build a board */
/***********************************************/
/**
* Struct LAYER
* holds information pertinent to a layer of a BOARD.
*/
struct LAYER
{
/** The name of the layer, there should be no spaces in this name. */
wxString m_Name;
/** The type of the layer */
LAYER_T m_Type;
// int m_Color;
// bool m_Visible; // ? use flags in m_Color instead ?
/**
* Function ShowType
* converts a LAYER_T enum to a const char*
* @param aType The LAYER_T to convert
* @return const char* - The string representation of the layer type.
*/
static const char* ShowType( LAYER_T aType );
/**
* Function ParseType
* converts a string to a LAYER_T
* @param aType The const char* to convert
* @return LAYER_T - The binary representation of the layer type, or
* LAYER_T(-1) if the string is invalid
*/
static LAYER_T ParseType( const char* aType );
};
/**
* Class BOARD
* holds information pertinent to a PCBNEW printed circuit board.
*/
class BOARD : public BOARD_ITEM
{
friend class WinEDA_PcbFrame;
@ -37,6 +72,8 @@ private:
typedef std::vector<ZONE_CONTAINER*> ZONE_CONTAINERS; // @todo: switch to boost::ptr_vector, and change ~BOARD()
ZONE_CONTAINERS m_ZoneDescriptorList; ///< edge zone descriptors, owned by pointer
LAYER m_Layer[NB_COPPER_LAYERS];
public:
WinEDA_BasePcbFrame* m_PcbFrame; // Window de visualisation
EDA_Rect m_BoundaryBox; // Board size and position
@ -294,6 +331,7 @@ public:
return wxT( "BOARD" );
}
#if defined(DEBUG)
/**
* Function Show

5
pcbnew/class_drawsegment.cpp
View File

@ -150,6 +150,9 @@ void DRAWSEGMENT::Display_Infos( WinEDA_DrawFrame* frame )
int itype;
wxString msg;
BOARD* board = (BOARD*) m_Parent;
wxASSERT( board );
frame->MsgPanel->EraseMsgBox();
itype = m_Type & 0x0F;
@ -173,7 +176,7 @@ void DRAWSEGMENT::Display_Infos( WinEDA_DrawFrame* frame )
Affiche_1_Parametre( frame, -1, wxEmptyString, _( "Segment" ), RED );
Affiche_1_Parametre( frame, 48, _( "Layer" ),
ReturnPcbLayerName( m_Layer ), BROWN );
board->GetLayerName( m_Layer ), BROWN );
valeur_param( (unsigned) m_Width, msg );
Affiche_1_Parametre( frame, 60, _( "Width" ), msg, DARKCYAN );

28
pcbnew/class_module.cpp
View File

@ -1135,15 +1135,6 @@ bool MODULE::HitTest( const wxPoint& refPos )
if( m_BoundaryBox.Inside( spot_cX, spot_cY ) )
return true;
/* no
// The GENERAL_COLLECTOR needs these two tests in order to find a MODULE
// when the user clicks on its text. Keep these 2, needed in OnRightClick().
if( m_Reference->HitTest( refPos ) )
return true;
if( m_Value->HitTest( refPos ) )
return true;
*/
return false;
}
@ -1173,6 +1164,25 @@ bool MODULE::HitTest( EDA_Rect& refArea )
}
D_PAD* MODULE::FindPadByName( const wxString& aPadName ) const
{
wxString buf;
for( D_PAD* pad = m_Pads; pad; pad = pad->Next() )
{
pad->ReturnStringPadName( buf );
#if 1
if( buf.CmpNoCase( aPadName ) == 0 ) // why case insensitive?
#else
if( buf == aPadName )
#endif
return pad;
}
return NULL;
}
// see class_module.h
SEARCH_RESULT MODULE::Visit( INSPECTOR* inspector, const void* testData,
const KICAD_T scanTypes[] )

13
pcbnew/class_module.h
View File

@ -65,7 +65,7 @@ public:
unsigned long m_Link; // variable temporaire ( pour editions, ...)
long m_LastEdit_Time; // Date de la derniere modification du module (gestion de librairies)
wxString m_Path;
wxString m_Path;
wxString m_Doc; // Texte de description du module
wxString m_KeyWord; // Liste des mots cles relatifs au module
@ -197,6 +197,17 @@ public:
return m_Value->m_Text;
}
/**
* Function FindPadByName
* returns a D_PAD* with a matching name. Note that names may not be
* unique, depending on how the foot print was created.
* @param
* @return D_PAD* - The first matching name is returned, or NULL if not found.
*/
D_PAD* FindPadByName( const wxString& aPadName ) const;
/**
* Function Visit
* should be re-implemented for each derived class in order to handle

5
pcbnew/class_pcb_text.cpp
View File

@ -167,6 +167,9 @@ void TEXTE_PCB::Display_Infos( WinEDA_DrawFrame* frame )
{
wxString msg;
BOARD* board = (BOARD*) m_Parent;
wxASSERT( board );
frame->MsgPanel->EraseMsgBox();
if( m_Parent && m_Parent->Type() == TYPECOTATION )
@ -175,7 +178,7 @@ void TEXTE_PCB::Display_Infos( WinEDA_DrawFrame* frame )
Affiche_1_Parametre( frame, 1, _( "PCB Text" ), m_Text, DARKGREEN );
Affiche_1_Parametre( frame, 28, _( "Layer" ),
ReturnPcbLayerName( m_Layer ),
board->GetLayerName( m_Layer ),
g_DesignSettings.m_LayerColor[m_Layer] & MASKCOLOR );
Affiche_1_Parametre( frame, 36, _( "Mirror" ), wxEmptyString, GREEN );

7
pcbnew/class_text_mod.cpp
View File

@ -338,9 +338,14 @@ void TEXTE_MODULE::Display_Infos( WinEDA_DrawFrame* frame )
MODULE* module = (MODULE*) m_Parent;
wxASSERT( module );
if( !module )
return;
BOARD* board = (BOARD*) module->m_Parent;
wxASSERT( board );
static const wxString text_type_msg[3] = {
_( "Ref." ), _( "Value" ), _( "Text" ) };
@ -366,7 +371,7 @@ void TEXTE_MODULE::Display_Infos( WinEDA_DrawFrame* frame )
ii = m_Layer;
if( ii < NB_LAYERS )
Affiche_1_Parametre( frame, 28, _( "Layer" ), ReturnPcbLayerName( ii ), DARKGREEN );
Affiche_1_Parametre( frame, 28, _( "Layer" ), board->GetLayerName( ii ), DARKGREEN );
else
{
msg.Printf( wxT( "%d" ), ii );

60
pcbnew/class_zone.cpp
View File

@ -248,7 +248,7 @@ void ZONE_CONTAINER::Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& off
if( DC == NULL )
return;
wxPoint seg_start, seg_end;
wxPoint seg_start, seg_end;
int curr_layer = ( (PCB_SCREEN*) panel->GetScreen() )->m_Active_Layer;
int color = g_DesignSettings.m_LayerColor[m_Layer];
@ -319,9 +319,9 @@ void ZONE_CONTAINER::DrawWhileCreateOutline( WinEDA_DrawPanel* panel, wxDC* DC,
* @param draw_mode = draw mode: OR, XOR ..
*/
{
int current_gr_mode = draw_mode;
bool is_close_segment = false;
wxPoint seg_start, seg_end;
int current_gr_mode = draw_mode;
bool is_close_segment = false;
wxPoint seg_start, seg_end;
if( DC == NULL )
return;
@ -339,7 +339,7 @@ void ZONE_CONTAINER::DrawWhileCreateOutline( WinEDA_DrawPanel* panel, wxDC* DC,
// draw the lines
wxPoint start_contour_pos = GetCornerPosition(0);
wxPoint start_contour_pos = GetCornerPosition(0);
for( int ic = 0; ic < GetNumCorners(); ic++ )
{
int xi = GetCornerPosition(ic).x;
@ -347,27 +347,27 @@ void ZONE_CONTAINER::DrawWhileCreateOutline( WinEDA_DrawPanel* panel, wxDC* DC,
int xf, yf;
if( m_Poly->corner[ic].end_contour == FALSE && ic < GetNumCorners() - 1 )
{
is_close_segment = false;
is_close_segment = false;
xf = GetCornerPosition(ic + 1).x;
yf = GetCornerPosition(ic + 1).y;
if ( (m_Poly->corner[ic + 1].end_contour) || (ic == GetNumCorners() - 2) )
current_gr_mode = GR_XOR;
else
current_gr_mode = draw_mode;
if ( (m_Poly->corner[ic + 1].end_contour) || (ic == GetNumCorners() - 2) )
current_gr_mode = GR_XOR;
else
current_gr_mode = draw_mode;
}
else
{
is_close_segment = true;
current_gr_mode = GR_XOR;
is_close_segment = true;
current_gr_mode = GR_XOR;
xf = start_contour_pos.x;
yf = start_contour_pos.y;
start_contour_pos = GetCornerPosition(ic + 1);
}
GRSetDrawMode( DC, current_gr_mode );
if ( is_close_segment )
GRLine( &panel->m_ClipBox, DC, xi, yi, xf, yf, 0, WHITE );
else
GRLine( &panel->m_ClipBox, DC, xi, yi, xf, yf, 0, color );
GRSetDrawMode( DC, current_gr_mode );
if ( is_close_segment )
GRLine( &panel->m_ClipBox, DC, xi, yi, xf, yf, 0, WHITE );
else
GRLine( &panel->m_ClipBox, DC, xi, yi, xf, yf, 0, color );
}
}
@ -514,6 +514,10 @@ void ZONE_CONTAINER::Display_Infos( WinEDA_DrawFrame* frame )
wxString msg;
int text_pos;
BOARD* board = (BOARD*) m_Parent;
wxASSERT( board );
frame->MsgPanel->EraseMsgBox();
msg = _( "Zone Outline" );
@ -551,7 +555,7 @@ void ZONE_CONTAINER::Display_Infos( WinEDA_DrawFrame* frame )
Affiche_1_Parametre( frame, text_pos, _( "NetCode" ), msg, RED );
text_pos += 8;
msg = ReturnPcbLayerName( m_Layer );
msg = board->GetLayerName( m_Layer );
Affiche_1_Parametre( frame, text_pos, _( "Layer" ), msg, BROWN );
text_pos += 8;
@ -588,19 +592,19 @@ void ZONE_CONTAINER::Move( const wxPoint& offset )
*/
void ZONE_CONTAINER::MoveEdge( const wxPoint& offset )
{
int ii = m_CornerSelection;
int ii = m_CornerSelection;
// Move the start point of the selected edge:
// Move the start point of the selected edge:
SetCornerPosition(ii, GetCornerPosition(ii) + offset);
// Move the end point of the selected edge:
if ( m_Poly->corner[ii].end_contour || ii == GetNumCorners() - 1)
{
int icont = m_Poly->GetContour( ii );
ii = m_Poly->GetContourStart( icont );
}
else
ii++;
// Move the end point of the selected edge:
if ( m_Poly->corner[ii].end_contour || ii == GetNumCorners() - 1)
{
int icont = m_Poly->GetContour( ii );
ii = m_Poly->GetContourStart( icont );
}
else
ii++;
SetCornerPosition(ii, GetCornerPosition(ii) + offset);
m_Poly->Hatch();

3
pcbnew/classpcb.cpp
View File

@ -156,6 +156,7 @@ EDA_BoardDesignSettings::EDA_BoardDesignSettings()
m_MicroViaDrill = 50; // micro via drill (for the entire board)
m_CurrentMicroViaSize = 150; // Current micro via size
m_MicroViasAllowed = false; // true to allow micro vias
for( ii = 0; ii < HISTORY_NUMBER; ii++ )
{
m_TrackWidthHistory[ii] = 0; // Last HISTORY_NUMBER used track widths
@ -171,6 +172,7 @@ EDA_BoardDesignSettings::EDA_BoardDesignSettings()
m_MaskMargin = 150; // Solder mask margin
/* Color options for screen display of the Printed Board: */
m_PcbGridColor = DARKGRAY; // Grid color
for( ii = 0; ii < 32; ii++ )
m_LayerColor[ii] = default_layer_color[ii];
@ -179,6 +181,7 @@ EDA_BoardDesignSettings::EDA_BoardDesignSettings()
m_ViaColor[VIA_MICROVIA] = CYAN;
m_ViaColor[VIA_BLIND_BURIED] = BROWN;
m_ViaColor[VIA_THROUGH] = WHITE;
m_ModuleTextCMPColor = LIGHTGRAY; // Text module color for modules on the COMPONENT layer
m_ModuleTextCUColor = MAGENTA; // Text module color for modules on the COPPER layer
m_ModuleTextNOVColor = DARKGRAY; // Text module color for "invisible" texts (must be BLACK if really not displayed)

6
pcbnew/cotation.cpp
View File

@ -135,10 +135,10 @@ WinEDA_CotationPropertiesFrame::WinEDA_CotationPropertiesFrame( WinEDA_PcbFrame*
m_SelLayerBox = new WinEDAChoiceBox( this, ID_TEXTPCB_SELECT_LAYER,
wxDefaultPosition, wxDefaultSize );
LeftBoxSizer->Add( m_SelLayerBox, 0, wxGROW | wxLEFT | wxRIGHT | wxBOTTOM, 5 );
int ii;
for( ii = FIRST_NO_COPPER_LAYER; ii < NB_LAYERS; ii++ )
for( int layer = FIRST_NO_COPPER_LAYER; layer<NB_LAYERS; layer++ )
{
m_SelLayerBox->Append( ReturnPcbLayerName( ii ) );
m_SelLayerBox->Append( parent->m_Pcb->GetLayerName( layer ) );
}
m_SelLayerBox->SetSelection( Cotation->GetLayer() - FIRST_NO_COPPER_LAYER );

6
pcbnew/cross-probing.cpp
View File

@ -48,7 +48,7 @@ void RemoteCommand( const char* cmdline )
{
modName = CONV_FROM_UTF8( text );
module = ReturnModule( frame->m_Pcb, modName );
module = frame->m_Pcb->FindModuleByReference( modName );
if( module )
msg.Printf( _( "%s found" ), modName.GetData() );
@ -86,9 +86,9 @@ void RemoteCommand( const char* cmdline )
modName = CONV_FROM_UTF8( text );
module = ReturnModule( frame->m_Pcb, modName );
module = frame->m_Pcb->FindModuleByReference( modName );
if( module )
pad = ReturnPad( module, pinName );
pad = module->FindPadByName( pinName );
if( pad )
netcode = pad->GetNet();

181
pcbnew/dialog_zones_by_polygon.cpp
View File

@ -68,7 +68,7 @@ WinEDA_ZoneFrame::WinEDA_ZoneFrame()
WinEDA_ZoneFrame::WinEDA_ZoneFrame( WinEDA_PcbFrame* parent,
ZONE_CONTAINER * zone_container,
ZONE_CONTAINER * zone_container,
wxWindowID id,
const wxString& caption,
const wxPoint& pos,
@ -76,14 +76,14 @@ WinEDA_ZoneFrame::WinEDA_ZoneFrame( WinEDA_PcbFrame* parent,
long style )
{
m_Parent = parent;
m_Zone_Container = zone_container;
if( m_Parent->m_Parent->m_EDA_Config )
m_Zone_Container = zone_container;
if( m_Parent->m_Parent->m_EDA_Config )
{
m_NetSorting = m_Parent->m_Parent->m_EDA_Config->Read( ZONE_NET_SORT_OPTION_KEY, (long) BOARD::PAD_CNT_SORT );
}
}
Create( parent, id, caption, pos, size, style );
SetReturnCode(ZONE_ABORT); // Will be changed on buttons click
SetReturnCode(ZONE_ABORT); // Will be changed on buttons click
}
@ -133,6 +133,8 @@ bool WinEDA_ZoneFrame::Create( wxWindow* parent,
void WinEDA_ZoneFrame::CreateControls()
{
BOARD* board = m_Parent->m_Pcb;
SetFont( *g_DialogFont );
////@begin WinEDA_ZoneFrame content construction
@ -244,8 +246,8 @@ void WinEDA_ZoneFrame::CreateControls()
m_NetSortingOption->SetValidator( wxGenericValidator(& m_NetSorting) );
////@end WinEDA_ZoneFrame content construction
// Initialise options
wxString title = _( "Zone clearance value:" ) + ReturnUnitSymbol( g_UnitMetric );
// Initialise options
wxString title = _( "Zone clearance value:" ) + ReturnUnitSymbol( g_UnitMetric );
m_ClearanceValueTitle->SetLabel( title );
title = _( "Grid :" ) + ReturnUnitSymbol( g_UnitMetric );;
@ -280,89 +282,97 @@ void WinEDA_ZoneFrame::CreateControls()
{
case ZONE_CONTAINER::PAD_NOT_IN_ZONE: // Pads are not covered
m_FillOpt->SetSelection( 2 );
break;
case ZONE_CONTAINER::THERMAL_PAD: // Use thermal relief for pads
break;
case ZONE_CONTAINER::THERMAL_PAD: // Use thermal relief for pads
m_FillOpt->SetSelection( 1 );
break;
case ZONE_CONTAINER::PAD_IN_ZONE: // pads are covered by copper
break;
case ZONE_CONTAINER::PAD_IN_ZONE: // pads are covered by copper
m_FillOpt->SetSelection( 0 );
break;
break;
}
if ( m_Zone_Container )
s_Zone_Hatching = m_Zone_Container->m_Poly->GetHatchStyle();
else
if ( m_Zone_Container )
s_Zone_Hatching = m_Zone_Container->m_Poly->GetHatchStyle();
else
s_Zone_Hatching = m_Parent->m_Parent->m_EDA_Config->Read( ZONE_NET_OUTLINES_HATCH_OPTION_KEY,
(long) CPolyLine::DIAGONAL_EDGE );
(long) CPolyLine::DIAGONAL_EDGE );
switch( s_Zone_Hatching )
{
case CPolyLine::NO_HATCH:
m_OutlineAppearanceCtrl->SetSelection(0);
break;
case CPolyLine::NO_HATCH:
m_OutlineAppearanceCtrl->SetSelection(0);
break;
case CPolyLine::DIAGONAL_EDGE:
m_OutlineAppearanceCtrl->SetSelection(1);
break;
case CPolyLine::DIAGONAL_EDGE:
m_OutlineAppearanceCtrl->SetSelection(1);
break;
case CPolyLine::DIAGONAL_FULL:
m_OutlineAppearanceCtrl->SetSelection(2);
break;
}
case CPolyLine::DIAGONAL_FULL:
m_OutlineAppearanceCtrl->SetSelection(2);
break;
}
int layer_cnt = g_DesignSettings.m_CopperLayerCount;
for( int ii = 0; ii < g_DesignSettings.m_CopperLayerCount; ii++ )
int layer_cnt = board->GetCopperLayerCount();
for( int ii = 0; ii < board->GetCopperLayerCount(); ii++ )
{
wxString msg;
int layer_number = COPPER_LAYER_N;
if( layer_cnt == 0 || ii < layer_cnt - 1 )
layer_number = ii;
else if( ii == layer_cnt - 1 )
else if( ii == layer_cnt - 1 )
layer_number = LAYER_CMP_N;
m_LayerId[ii] = layer_number;
msg = ReturnPcbLayerName( layer_number ).Trim();
msg = board->GetLayerName( layer_number ).Trim();
m_LayerSelectionCtrl->InsertItems( 1, &msg, ii );
if ( m_Zone_Container )
{
if( m_Zone_Container->GetLayer() == layer_number )
m_LayerSelectionCtrl->SetSelection( ii );
}
else
{
if( ((PCB_SCREEN*)(m_Parent->GetScreen()))->m_Active_Layer == layer_number )
m_LayerSelectionCtrl->SetSelection( ii );
}
if( m_Zone_Container )
{
if( m_Zone_Container->GetLayer() == layer_number )
m_LayerSelectionCtrl->SetSelection( ii );
}
else
{
if( ((PCB_SCREEN*)(m_Parent->GetScreen()))->m_Active_Layer == layer_number )
m_LayerSelectionCtrl->SetSelection( ii );
}
}
m_NetSortingOption->SetSelection(m_NetSorting == BOARD::ALPHA_SORT ? 0 : 1 );
wxString NetNameFilter;
if( m_Parent->m_Parent->m_EDA_Config )
m_NetSortingOption->SetSelection(m_NetSorting == BOARD::ALPHA_SORT ? 0 : 1 );
wxString NetNameFilter;
if( m_Parent->m_Parent->m_EDA_Config )
{
NetNameFilter = m_Parent->m_Parent->m_EDA_Config->Read( ZONE_NET_FILTER_STRING_KEY, wxT("N_0*") );
}
m_NetNameFilter->SetValue(NetNameFilter);
NetNameFilter = m_Parent->m_Parent->m_EDA_Config->Read( ZONE_NET_FILTER_STRING_KEY, wxT("N_0*") );
}
m_NetNameFilter->SetValue(NetNameFilter);
wxArrayString ListNetName;
m_Parent->m_Pcb->ReturnSortedNetnamesList( ListNetName,
m_NetSorting == 0 ? BOARD::ALPHA_SORT : BOARD::PAD_CNT_SORT );
if ( m_NetSorting != 0 )
{
wxString Filter = m_NetNameFilter->GetValue();
for (unsigned ii = 0; ii < ListNetName.GetCount(); ii ++ )
{
if ( ListNetName[ii].Matches(Filter.GetData() ) )
{
ListNetName. RemoveAt(ii);
ii--;
}
}
}
m_NetSorting == 0 ? BOARD::ALPHA_SORT : BOARD::PAD_CNT_SORT );
if ( m_NetSorting != 0 )
{
wxString Filter = m_NetNameFilter->GetValue();
for( unsigned ii = 0; ii < ListNetName.GetCount(); ii++ )
{
if( ListNetName[ii].Matches(Filter.GetData() ) )
{
ListNetName. RemoveAt(ii);
ii--;
}
}
}
m_ListNetNameSelection->InsertItems( ListNetName, 0 );
// Select net:
int net_select = g_HightLigth_NetCode;
if ( m_Zone_Container )
net_select = m_Zone_Container->GetNet();
int net_select = g_HightLigth_NetCode;
if( m_Zone_Container )
net_select = m_Zone_Container->GetNet();
if( net_select > 0 )
{
EQUIPOT* equipot = m_Parent->m_Pcb->FindNet( net_select );
@ -468,8 +478,8 @@ bool WinEDA_ZoneFrame::AcceptOptions(bool aPromptForErrors)
if( m_Parent->m_Parent->m_EDA_Config )
{
m_Parent->m_Parent->m_EDA_Config->Write( ZONE_NET_OUTLINES_HATCH_OPTION_KEY, (long)s_Zone_Hatching);
}
m_Parent->m_Parent->m_EDA_Config->Write( ZONE_NET_OUTLINES_HATCH_OPTION_KEY, (long)s_Zone_Hatching);
}
switch( m_GridCtrl->GetSelection() )
{
@ -481,7 +491,7 @@ bool WinEDA_ZoneFrame::AcceptOptions(bool aPromptForErrors)
g_GridRoutingSize = 50;
break;
default:
default:
case 2:
g_GridRoutingSize = 100;
break;
@ -521,7 +531,7 @@ bool WinEDA_ZoneFrame::AcceptOptions(bool aPromptForErrors)
/* Search net_code for this net */
EQUIPOT* net;
s_NetcodeSelection = 0;
for( net = m_Parent->m_Pcb->m_Equipots; net; net = net->Next() )
for( net = m_Parent->m_Pcb->m_Equipots; net; net = net->Next() )
{
if( net->m_Netname == net_name )
{
@ -530,7 +540,7 @@ bool WinEDA_ZoneFrame::AcceptOptions(bool aPromptForErrors)
}
}
return true;
return true;
}
@ -541,29 +551,28 @@ bool WinEDA_ZoneFrame::AcceptOptions(bool aPromptForErrors)
void WinEDA_ZoneFrame::OnNetSortingOptionSelected( wxCommandEvent& event )
{
wxArrayString ListNetName;
m_NetSorting = m_NetSortingOption->GetSelection();
m_NetSorting = m_NetSortingOption->GetSelection();
m_Parent->m_Pcb->ReturnSortedNetnamesList( ListNetName,
m_NetSorting == 0 ? BOARD::ALPHA_SORT : BOARD::PAD_CNT_SORT );
if ( m_NetSorting != 0 )
{
wxString Filter = m_NetNameFilter->GetValue();
for (unsigned ii = 0; ii < ListNetName.GetCount(); ii ++ )
{
if ( ListNetName[ii].Matches(Filter.GetData() ) )
{
ListNetName. RemoveAt(ii);
ii--;
}
}
}
m_ListNetNameSelection->Clear();
m_NetSorting == 0 ? BOARD::ALPHA_SORT : BOARD::PAD_CNT_SORT );
if ( m_NetSorting != 0 )
{
wxString Filter = m_NetNameFilter->GetValue();
for (unsigned ii = 0; ii < ListNetName.GetCount(); ii ++ )
{
if ( ListNetName[ii].Matches(Filter.GetData() ) )
{
ListNetName. RemoveAt(ii);
ii--;
}
}
}
m_ListNetNameSelection->Clear();
m_ListNetNameSelection->InsertItems( ListNetName, 0 );
if( m_Parent->m_Parent->m_EDA_Config )
{
m_Parent->m_Parent->m_EDA_Config->Write( ZONE_NET_SORT_OPTION_KEY, (long) m_NetSorting );
m_Parent->m_Parent->m_EDA_Config->Write( ZONE_NET_FILTER_STRING_KEY, m_NetNameFilter->GetValue() );
}
}
}
@ -573,7 +582,7 @@ void WinEDA_ZoneFrame::OnNetSortingOptionSelected( wxCommandEvent& event )
void WinEDA_ZoneFrame::OnOkClick( wxCommandEvent& event )
{
if ( AcceptOptions(true) )
EndModal( ZONE_OK );
if ( AcceptOptions(true) )
EndModal( ZONE_OK );
}

2
pcbnew/editedge.cpp
View File

@ -174,7 +174,7 @@ void WinEDA_PcbFrame::Delete_Drawings_All_Layer( DRAWSEGMENT* Segment, wxDC* DC
return;
}
wxString msg = _( "Delete Layer " ) + ReturnPcbLayerName( layer );
wxString msg = _( "Delete Layer " ) + m_Pcb->GetLayerName( layer );
if( !IsOK( this, msg ) )
return;

49
pcbnew/initpcb.cpp
View File

@ -127,26 +127,9 @@ bool WinEDA_BasePcbFrame::Clear_Pcb( bool query )
}
}
/* Suppression des listes chainees */
m_Pcb->m_Equipots->DeleteStructList();
m_Pcb->m_Equipots = NULL;
m_Pcb->m_Drawings->DeleteStructList();
m_Pcb->m_Drawings = NULL;
m_Pcb->m_Modules->DeleteStructList();
m_Pcb->m_Modules = NULL;
m_Pcb->m_Track->DeleteStructList();
m_Pcb->m_Track = NULL;
m_Pcb->m_NbSegmTrack = 0;
m_Pcb->m_Zone->DeleteStructList();
m_Pcb->m_Zone = NULL;
m_Pcb->m_NbSegmZone = 0;
m_Pcb->DeleteMARKERs();
m_Pcb->DeleteZONEOutlines();
// delete the old BOARD and create a new BOARD so that the default
// layer names are put into the BOARD.
SetBOARD( new BOARD( NULL, this ) );
for( ; g_UnDeleteStackPtr != 0; )
{
@ -159,30 +142,6 @@ bool WinEDA_BasePcbFrame::Clear_Pcb( bool query )
memset( buf_work, 0, BUFMEMSIZE );
adr_lowmem = adr_max = buf_work;
if( m_Pcb->m_Pads )
{
MyFree( m_Pcb->m_Pads );
m_Pcb->m_Pads = NULL;
}
if( m_Pcb->m_Ratsnest )
MyFree( m_Pcb->m_Ratsnest );
if( m_Pcb->m_LocalRatsnest )
MyFree( m_Pcb->m_LocalRatsnest );
m_Pcb->m_Ratsnest = NULL;
m_Pcb->m_LocalRatsnest = NULL;
/* remise a 0 ou a une valeur initiale des variables de la structure */
m_Pcb->m_BoundaryBox.SetOrigin( wxPoint( 0, 0 ) );
m_Pcb->m_BoundaryBox.SetSize( wxSize( 0, 0 ) );
m_Pcb->m_Status_Pcb = 0;
m_Pcb->m_NbLoclinks = 0;
m_Pcb->m_NbLinks = 0;
m_Pcb->m_NbPads = 0;
m_Pcb->m_NbNets = 0;
m_Pcb->m_NbNodes = 0;
m_Pcb->m_NbNoconnect = 0;
m_Pcb->m_NbSegmTrack = 0;
m_Pcb->m_NbSegmZone = 0;
SetCurItem( NULL );
/* Init parametres de gestion */
@ -220,7 +179,7 @@ void WinEDA_PcbFrame::Erase_Zones( bool query )
m_Pcb->m_NbSegmZone = 0;
}
m_Pcb->DeleteZONEOutlines();
m_Pcb->DeleteZONEOutlines();
GetScreen()->SetModify();
}

46
pcbnew/ioascii.cpp
View File

@ -308,11 +308,25 @@ int WinEDA_BasePcbFrame::ReadSetup( FILE* File, int* LineNum )
if( strncmp( Line, "Layer[", LAYERKEYZ ) == 0 )
{
const char* cp = Line + LAYERKEYZ;
// parse:
// Layer[n] "a Layer name" <LAYER_T>
char* cp = Line + LAYERKEYZ;
int layer = atoi(cp);
wxString layerName = CONV_FROM_UTF8( data );
m_Pcb->SetLayerName( layer, layerName );
if( data )
{
wxString layerName = CONV_FROM_UTF8( data );
m_Pcb->SetLayerName( layer, layerName );
data = strtok( NULL, " " );
if( data )
{
LAYER_T type = LAYER::ParseType( data );
m_Pcb->SetLayerType( layer, type );
}
}
continue;
}
@ -500,13 +514,9 @@ int WinEDA_BasePcbFrame::ReadSetup( FILE* File, int* LineNum )
#ifdef PCBNEW
/***************************************************************/
static int WriteSetup( FILE* aFile, WinEDA_BasePcbFrame* aFrame
#if defined(DEBUG)
, BOARD* aBoard
#endif
)
/***************************************************************/
/******************************************************************************/
static int WriteSetup( FILE* aFile, WinEDA_BasePcbFrame* aFrame, BOARD* aBoard )
/******************************************************************************/
{
char text[1024];
int ii, jj;
@ -533,18 +543,14 @@ static int WriteSetup( FILE* aFile, WinEDA_BasePcbFrame* aFrame
fprintf( aFile, "ZoneGridSize %d\n", g_GridRoutingSize );
#if defined(DEBUG)
fprintf( aFile, "Layers %d\n", aBoard->GetCopperLayerCount() );
for( int layer=0; layer<aBoard->GetCopperLayerCount(); ++layer )
{
fprintf( aFile, "Layer[%d] %s\n", layer, CONV_TO_UTF8( aBoard->GetLayerName(layer) ) );
fprintf( aFile, "Layer[%d] %s %s\n", layer,
CONV_TO_UTF8( aBoard->GetLayerName(layer) ),
LAYER::ShowType( aBoard->GetLayerType( layer ) ) );
}
#else
fprintf( aFile, "Layers %d\n", g_DesignSettings.m_CopperLayerCount );
#endif
fprintf( aFile, "TrackWidth %d\n", g_DesignSettings.m_CurrentTrackWidth );
for( ii = 0; ii < HISTORY_NUMBER; ii++ )
{
@ -1057,11 +1063,7 @@ int WinEDA_PcbFrame::SavePcbFormatAscii( FILE* aFile )
WriteGeneralDescrPcb( aFile );
WriteSheetDescr( m_CurrentScreen, aFile );
WriteSetup( aFile, this
#if defined(DEBUG)
, m_Pcb
#endif
);
WriteSetup( aFile, this, m_Pcb );
rc = m_Pcb->Save( aFile );

95
pcbnew/locate.cpp
View File

@ -27,55 +27,6 @@ wxPoint inline RefPos( int typeloc )
}
/*************************************************************/
MODULE* ReturnModule( BOARD* pcb, const wxString& reference )
/*************************************************************/
/*
* Recherche d'un module par sa reference
* Retourne:
* un pointeur sur le module
* Null si pas localis<EFBFBD>
*/
{
MODULE* Module = pcb->m_Modules;
for( ; Module != NULL; Module = (MODULE*) Module->Pnext )
{
if( reference.CmpNoCase( Module->m_Reference->m_Text ) == 0 )
return Module;
}
return NULL;
}
/********************************************************/
D_PAD* ReturnPad( MODULE* module, const wxString& name )
/********************************************************/
/* Recherche d'un pad par son nom, pour le module Module
*/
{
D_PAD* pt_pad;
wxString buf;
if( module == NULL )
return NULL;
pt_pad = module->m_Pads;
for( ; pt_pad != NULL; pt_pad = (D_PAD*) pt_pad->Pnext )
{
pt_pad->ReturnStringPadName( buf );
if( buf.CmpNoCase( name ) == 0 )
return pt_pad;
}
return NULL;
}
/*******************************************************************/
TRACK* Locate_Via( BOARD* Pcb, const wxPoint& pos, int layer )
/*******************************************************************/
@ -317,17 +268,17 @@ MODULE* Locate_Prefered_Module( BOARD* Pcb, int typeloc )
/* Localisation: test des dimensions minimales, choix du meilleur candidat */
/* calcul des dimensions du cadre :*/
int offx = pt_module->m_BoundaryBox.m_Size.x/2 +
pt_module->m_BoundaryBox.m_Pos.x +
pt_module->m_Pos.x;
int offy = pt_module->m_BoundaryBox.m_Size.y/2
+ pt_module->m_BoundaryBox.m_Pos.y
+ pt_module->m_Pos.y;
//off x & offy point to the middle of the box.
int dist = abs(ref_pos.x - offx) + abs(ref_pos.y - offy);
lx = pt_module->m_BoundaryBox.GetWidth();
ly = pt_module->m_BoundaryBox.GetHeight();
//int dist = MIN(lx, ly); // to pick the smallest module (kinda screwy with same-sized modules -- this is bad!)
int offx = pt_module->m_BoundaryBox.m_Size.x/2 +
pt_module->m_BoundaryBox.m_Pos.x +
pt_module->m_Pos.x;
int offy = pt_module->m_BoundaryBox.m_Size.y/2
+ pt_module->m_BoundaryBox.m_Pos.y
+ pt_module->m_Pos.y;
//off x & offy point to the middle of the box.
int dist = abs(ref_pos.x - offx) + abs(ref_pos.y - offy);
lx = pt_module->m_BoundaryBox.GetWidth();
ly = pt_module->m_BoundaryBox.GetHeight();
//int dist = MIN(lx, ly); // to pick the smallest module (kinda screwy with same-sized modules -- this is bad!)
if( ( (PCB_SCREEN*) ActiveScreen )->m_Active_Layer == layer ){
if( dist <= min_dim ){
@ -372,15 +323,15 @@ Currently in test (currently rasnest algos work only if p1 == p2)
#if 0 // Do not change it: does not work
{
int dist;
dist = abs(p1.x - p2.x) + abs (p1.y - p2.y);
dist *= 7;
dist /= 10;
if ( dist < max_dist ) return true;
dist = abs(p1.x - p2.x) + abs (p1.y - p2.y);
dist *= 7;
dist /= 10;
if ( dist < max_dist ) return true;
}
#else
if ( p1 == p2 ) return true;
if ( p1 == p2 ) return true;
#endif
return false;
return false;
}
/**************************************************************/
@ -406,12 +357,12 @@ TRACK* Locate_Piste_Connectee( TRACK* PtRefSegm, TRACK* pt_base,
* @param extr = START or END = end of ref track segment to use in tests
*/
{
#define NEIGHTBOUR_COUNT_MAX 50
#define NEIGHTBOUR_COUNT_MAX 50
TRACK* PtSegmB, * PtSegmN;
int Reflayer;
wxPoint pos_ref;
int ii;
int max_dist;
int max_dist;
if( extr == START )
pos_ref = PtRefSegm->m_Start;
@ -435,8 +386,8 @@ TRACK* Locate_Piste_Connectee( TRACK* PtRefSegm, TRACK* pt_base,
if( PtSegmN == PtRefSegm )
goto suite;
/* max_dist is the max distance between 2 tack ends which ensure a copper continuty */
max_dist = (PtSegmN->m_Width + PtRefSegm->m_Width)/2;
/* max_dist is the max distance between 2 tack ends which ensure a copper continuty */
max_dist = (PtSegmN->m_Width + PtRefSegm->m_Width)/2;
if( IsPointsAreNear(pos_ref, PtSegmN->m_Start, max_dist) )
{ /* Test des couches */
@ -463,7 +414,7 @@ suite:
if( PtSegmB == PtRefSegm )
goto suite1;
max_dist = (PtSegmB->m_Width + PtRefSegm->m_Width)/2;
max_dist = (PtSegmB->m_Width + PtRefSegm->m_Width)/2;
if( IsPointsAreNear(pos_ref, PtSegmB->m_Start, max_dist) )
{ /* Test des couches */
@ -503,7 +454,7 @@ suite1:
}
max_dist = (PtSegmN->m_Width + PtRefSegm->m_Width)/2;
max_dist = (PtSegmN->m_Width + PtRefSegm->m_Width)/2;
if( IsPointsAreNear(pos_ref,PtSegmN->m_Start, max_dist) )
{ /* Test des couches */

11
pcbnew/pcbframe.cpp
View File

@ -69,8 +69,8 @@ BEGIN_EVENT_TABLE( WinEDA_PcbFrame, WinEDA_BasePcbFrame )
EVT_MENU( ID_EXIT, WinEDA_PcbFrame::Process_Special_Functions )
// menu Config
EVT_MENU_RANGE(ID_CONFIG_AND_PREFERENCES_START, ID_CONFIG_AND_PREFERENCES_END,
WinEDA_PcbFrame::Process_Config)
EVT_MENU_RANGE(ID_CONFIG_AND_PREFERENCES_START, ID_CONFIG_AND_PREFERENCES_END,
WinEDA_PcbFrame::Process_Config)
EVT_MENU( ID_COLORS_SETUP, WinEDA_PcbFrame::Process_Config )
EVT_MENU( ID_OPTIONS_SETUP, WinEDA_PcbFrame::Process_Config )
@ -81,7 +81,7 @@ BEGIN_EVENT_TABLE( WinEDA_PcbFrame, WinEDA_BasePcbFrame )
EVT_MENU( ID_CONFIG_SAVE, WinEDA_PcbFrame::Process_Config )
EVT_MENU( ID_CONFIG_READ, WinEDA_PcbFrame::Process_Config )
EVT_MENU( ID_PCB_USER_GRID_SETUP, WinEDA_PcbFrame::Process_Special_Functions )
EVT_MENU( ID_PCB_USER_GRID_SETUP, WinEDA_PcbFrame::Process_Special_Functions )
EVT_MENU_RANGE( ID_LANGUAGE_CHOICE, ID_LANGUAGE_CHOICE_END,
WinEDA_DrawFrame::SetLanguage )
@ -183,7 +183,7 @@ END_EVENT_TABLE()
WinEDA_PcbFrame::WinEDA_PcbFrame( wxWindow* father, WinEDA_App* parent,
const wxString& title,
const wxPoint& pos, const wxSize& size,
long style) :
long style) :
WinEDA_BasePcbFrame( father, parent, PCB_FRAME, title, pos, size, style )
{
m_FrameName = wxT( "PcbFrame" );
@ -201,6 +201,8 @@ WinEDA_PcbFrame::WinEDA_PcbFrame( wxWindow* father, WinEDA_App* parent,
m_drc = new DRC( this ); // these 2 objects point to each other
SetBOARD( new BOARD( NULL, this ) );
m_DisplayPcbTrackFill = DisplayOpt.DisplayPcbTrackFill;
m_DisplayPadFill = DisplayOpt.DisplayPadFill;
m_DisplayPadNum = DisplayOpt.DisplayPadNum;
@ -247,6 +249,7 @@ WinEDA_PcbFrame::~WinEDA_PcbFrame()
m_Parent->m_PcbFrame = NULL;
m_CurrentScreen = ScreenPcb;
delete m_drc;
delete m_Pcb;
}

1
pcbnew/pcbnew.cpp
View File

@ -75,7 +75,6 @@ bool WinEDA_App::OnInit()
wxString Title = g_Main_Title + wxT( " " ) + GetBuildVersion();
m_PcbFrame->SetTitle( Title );
ActiveScreen = ScreenPcb;
m_PcbFrame->m_Pcb = new BOARD( NULL, m_PcbFrame );
SetTopWindow( m_PcbFrame );
m_PcbFrame->Show( TRUE );

988
pcbnew/pcbplot.cpp
View File

File diff suppressed because it is too large Load Diff

14
pcbnew/pcbtexte.cpp
View File

@ -89,9 +89,12 @@ WinEDA_TextPCBPropertiesFrame::WinEDA_TextPCBPropertiesFrame( WinEDA_PcbFrame* p
DIALOG_STYLE )
/************************************************************************************/
{
wxButton* Button;
wxButton* Button;
BOARD* board = parent->m_Pcb;
m_Parent = parent;
SetFont( *g_DialogFont );
m_DC = DC;
Centre();
@ -139,16 +142,17 @@ WinEDA_TextPCBPropertiesFrame::WinEDA_TextPCBPropertiesFrame( WinEDA_PcbFrame* p
wxDefaultPosition, wxDefaultSize );
MiddleBoxSizer->Add( m_SelLayerBox, 0, wxGROW | wxALL, 5 );
int ii;
for( ii = 0; ii < NB_LAYERS; ii++ )
for( int layer=0; layer<NB_LAYERS; ++layer )
{
m_SelLayerBox->Append( ReturnPcbLayerName( ii ) );
m_SelLayerBox->Append( board->GetLayerName( layer ) );
}
m_SelLayerBox->SetSelection( TextPCB->GetLayer() );
wxString orient_msg[4] = { wxT( "0" ), wxT( "90" ), wxT( "180" ), wxT( "-90" ) };
static const wxString orient_msg[4] = {
wxT( "0" ), wxT( "90" ), wxT( "180" ), wxT( "-90" ) };
m_Orient = new wxRadioBox( this, -1, _( "Orientation" ),
wxDefaultPosition, wxSize( -1, -1 ), 4, orient_msg,
1, wxRA_SPECIFY_COLS );

6
pcbnew/protos.h
View File

@ -71,12 +71,8 @@ void Trace_Pads_Only( WinEDA_DrawPanel* panel, wxDC* DC, MODULE* Module, int ox,
/* LOCATE.CPP : */
/****************/
MODULE* ReturnModule( BOARD* Pcb, const wxString& name );
/* Recherche d'une empreinte par son nom */
D_PAD* ReturnPad( MODULE* Module, const wxString& name );
/* Recherche d'un pad par son nom, pour le module Module */
TRACK* Locate_Via( BOARD* Pcb, const wxPoint& pos, int layer = -1 );
@ -417,7 +413,7 @@ MODULE* ListAndSelectModuleName( COMMAND* Cmd );
/*****************/
/* SET_COLOR.CPP */
/*****************/
void DisplayColorSetupFrame( WinEDA_DrawFrame* parent,
void DisplayColorSetupFrame( WinEDA_PcbFrame* parent,
const wxPoint& framepos );

20
pcbnew/sel_layer.cpp
View File

@ -40,15 +40,15 @@ public:
private:
void Sel_Layer( wxCommandEvent& event );
void OnCancelClick( wxCommandEvent& event );
void OnCancelClick( wxCommandEvent& event );
DECLARE_EVENT_TABLE()
};
/* Table des evenements pour WinEDA_SelLayerFrame */
BEGIN_EVENT_TABLE( WinEDA_SelLayerFrame, wxDialog )
EVT_BUTTON( wxID_OK, WinEDA_SelLayerFrame::Sel_Layer )
EVT_BUTTON( wxID_CANCEL, WinEDA_SelLayerFrame::OnCancelClick )
EVT_BUTTON( wxID_OK, WinEDA_SelLayerFrame::Sel_Layer )
EVT_BUTTON( wxID_CANCEL, WinEDA_SelLayerFrame::OnCancelClick )
EVT_RADIOBOX( ID_LAYER_SELECT, WinEDA_SelLayerFrame::Sel_Layer )
END_EVENT_TABLE()
@ -101,6 +101,7 @@ WinEDA_SelLayerFrame::WinEDA_SelLayerFrame( WinEDA_BasePcbFrame* parent,
* to the right of that radiobox.
*/
{
BOARD* board = parent->m_Pcb;
wxButton* Button;
int ii;
wxString LayerList[NB_LAYERS + 1]; // One extra element for "(Deselect)" radiobutton
@ -123,7 +124,7 @@ WinEDA_SelLayerFrame::WinEDA_SelLayerFrame( WinEDA_BasePcbFrame* parent,
if( (max_layer >= 0) && (max_layer < ii) )
break;
LayerList[LayerCount] = ReturnPcbLayerName( ii );
LayerList[LayerCount] = board->GetLayerName( ii );
if( ii == default_layer )
LayerSelect = LayerCount;
@ -207,8 +208,8 @@ public:
~WinEDA_SelLayerPairFrame() { };
private:
void OnOkClick( wxCommandEvent& event );
void OnCancelClick( wxCommandEvent& event );
void OnOkClick( wxCommandEvent& event );
void OnCancelClick( wxCommandEvent& event );
DECLARE_EVENT_TABLE()
};
@ -216,8 +217,8 @@ private:
/* Table des evenements pour WinEDA_SelLayerPairFrame */
BEGIN_EVENT_TABLE( WinEDA_SelLayerPairFrame, wxDialog )
EVT_BUTTON( wxID_OK, WinEDA_SelLayerPairFrame::OnOkClick )
EVT_BUTTON( wxID_CANCEL, WinEDA_SelLayerPairFrame::OnCancelClick )
EVT_BUTTON( wxID_OK, WinEDA_SelLayerPairFrame::OnOkClick )
EVT_BUTTON( wxID_CANCEL, WinEDA_SelLayerPairFrame::OnCancelClick )
END_EVENT_TABLE()
@ -264,6 +265,7 @@ WinEDA_SelLayerPairFrame::WinEDA_SelLayerPairFrame( WinEDA_BasePcbFrame* parent
wxSize( 470, 250 ), DIALOG_STYLE )
/*******************************************************************************/
{
BOARD* board = parent->m_Pcb;
wxButton* Button;
int ii, LayerCount;
wxString LayerList[NB_COPPER_LAYERS];
@ -281,7 +283,7 @@ WinEDA_SelLayerPairFrame::WinEDA_SelLayerPairFrame( WinEDA_BasePcbFrame* parent
m_LayerId[ii] = 0;
if( (g_TabOneLayerMask[ii] & Masque_Layer) )
{
LayerList[LayerCount] = ReturnPcbLayerName( ii );
LayerList[LayerCount] = board->GetLayerName( ii );
if( ii == screen->m_Route_Layer_TOP )
LayerTopSelect = LayerCount;
if( ii == screen->m_Route_Layer_BOTTOM )

6
pcbnew/set_color.cpp
View File

@ -51,7 +51,7 @@ END_EVENT_TABLE()
/*****************************************************/
void DisplayColorSetupFrame( WinEDA_DrawFrame* parent,
void DisplayColorSetupFrame( WinEDA_PcbFrame* parent,
const wxPoint& framepos )
/*****************************************************/
{
@ -72,7 +72,7 @@ WinEDA_SetColorsFrame::WinEDA_SetColorsFrame()
// Standard Constructor
WinEDA_SetColorsFrame::WinEDA_SetColorsFrame( WinEDA_DrawFrame* parent,
WinEDA_SetColorsFrame::WinEDA_SetColorsFrame( WinEDA_PcbFrame* parent,
const wxPoint& framepos )
{
m_Parent = parent;
@ -225,7 +225,7 @@ void WinEDA_SetColorsFrame::CreateControls()
if( laytool_list[lyr]->m_Title == wxT( "*" ) )
msg = g_ViaType_Name[laytool_list[lyr]->m_LayerNumber];
else
msg = ReturnPcbLayerName( laytool_list[lyr]->m_LayerNumber );
msg = m_Parent->m_Pcb->GetLayerName( laytool_list[lyr]->m_LayerNumber );
}
else
msg = wxGetTranslation( laytool_list[lyr]->m_Title.GetData() );

6
pcbnew/set_color.h
View File

@ -492,7 +492,7 @@ static ColorButton* laytool_list[] = {
&VIA_THROUGH_Butt,
&VIA_BLIND_BURIED_Butt,
&MICRO_VIA_Butt,
&MICRO_VIA_Butt,
&Ratsnest_Butt,
&Pad_Cu_Butt,
&Pad_Cmp_Butt,
@ -526,7 +526,7 @@ private:
DECLARE_DYNAMIC_CLASS( WinEDA_SetColorsFrame )
DECLARE_EVENT_TABLE()
WinEDA_DrawFrame* m_Parent;
WinEDA_PcbFrame* m_Parent;
wxBoxSizer* OuterBoxSizer;
wxBoxSizer* MainBoxSizer;
wxFlexGridSizer* FlexColumnBoxSizer;
@ -566,7 +566,7 @@ private:
public:
// Constructors and destructor
WinEDA_SetColorsFrame();
WinEDA_SetColorsFrame( WinEDA_DrawFrame* parent, const wxPoint& framepos );
WinEDA_SetColorsFrame( WinEDA_PcbFrame* parent, const wxPoint& framepos );
~WinEDA_SetColorsFrame();
};

11
pcbnew/specctra_export.cpp
View File

@ -826,6 +826,17 @@ void SPECCTRA_DB::FromBOARD( BOARD* aBoard ) throw( IOError )
layer->name = layerIds[pcbNdx];
DSN_T layerType;
switch( aBoard->GetLayerType( pcbLayer2kicad[pcbNdx] ) )
{
default:
case LT_SIGNAL: layerType = T_signal; break;
case LT_POWER: layerType = T_power; break;
case LT_MIXED: layerType = T_mixed; break;
}
layer->layer_type = layerType;
layer->properties.push_back( PROPERTY() );
PROPERTY* property = &layer->properties.back();
property->name = "index";

11
pcbnew/swap_layers.cpp
View File

@ -71,6 +71,8 @@ WinEDA_SwapLayerFrame::WinEDA_SwapLayerFrame( WinEDA_BasePcbFrame* parent ) :
wxDefaultSize, wxDEFAULT_DIALOG_STYLE|MAYBE_RESIZE_BORDER )
/*************************************************************************/
{
BOARD* board = parent->m_Pcb;
OuterBoxSizer = NULL;
MainBoxSizer = NULL;
FlexColumnBoxSizer = NULL;
@ -154,7 +156,8 @@ WinEDA_SwapLayerFrame::WinEDA_SwapLayerFrame( WinEDA_BasePcbFrame* parent ) :
}
// Provide a text string to identify this layer (with trailing spaces within that string being purged)
label = new wxStaticText( this, wxID_STATIC, ReturnPcbLayerName( ii ).Trim(), wxDefaultPosition, wxDefaultSize, wxALIGN_RIGHT );
label = new wxStaticText( this, wxID_STATIC, board->GetLayerName( ii ),
wxDefaultPosition, wxDefaultSize, wxALIGN_RIGHT );
FlexColumnBoxSizer->Add(label, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxBOTTOM, 5);
// Provide a button for this layer (which will invoke a child dialog box)
@ -177,11 +180,11 @@ WinEDA_SwapLayerFrame::WinEDA_SwapLayerFrame( WinEDA_BasePcbFrame* parent ) :
// strings to be truncated after different layers are selected.)
if( ii == 0 )
{
text = new wxStaticText( this, item_ID, ReturnPcbLayerName( 0 ), wxDefaultPosition, wxDefaultSize, 0 );
text = new wxStaticText( this, item_ID, board->GetLayerName( 0 ), wxDefaultPosition, wxDefaultSize, 0 );
goodSize = text->GetSize();
for( int jj = 1; jj < NB_LAYERS; jj++ )
{
text->SetLabel( ReturnPcbLayerName( jj ) );
text->SetLabel( board->GetLayerName( jj ) );
if( goodSize.x < text->GetSize().x )
goodSize.x = text->GetSize().x;
}
@ -280,7 +283,7 @@ void WinEDA_SwapLayerFrame::Sel_Layer( wxCommandEvent& event )
}
else
{
layer_list[ii]->SetLabel( ReturnPcbLayerName( jj ) );
layer_list[ii]->SetLabel( m_Parent->m_Pcb->GetLayerName( jj ) );
// Change the text color to fushia (to highlight
// that this layer *is* being swapped)
layer_list[ii]->SetForegroundColour( wxColour(255, 0, 128) );

2
pcbnew/tool_pcb.cpp
View File

@ -691,7 +691,7 @@ WinEDAChoiceBox* WinEDA_PcbFrame::ReCreateLayerBox( WinEDA_Toolbar* parent )
if( (g_TabOneLayerMask[ii] & Masque_Layer) )
{
wxString msg = ReturnPcbLayerName( ii, false );
wxString msg = m_Pcb->GetLayerName( ii );
msg = AddHotkeyName( msg, s_Board_Editor_Hokeys_Descr, HK_SwitchLayer[ii] );
m_SelLayerBox->Append( msg );
m_SelLayerBox->SetClientData( jj, (void*) ii );

949
share/wxprint.cpp
View File

File diff suppressed because it is too large Load Diff