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

13
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 Please add newer entries at the top, list the date and your name with
email address. 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> 2008-mars-03 UPDATE Jean-Pierre Charras <jean-pierre.charras@inpg.fr>
================================================================================ ================================================================================
3d display: 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> 2008-Mar-1 UPDATE Dick Hollenbeck <dick@softplc.com>
================================================================================ ================================================================================
+pcbnew +pcbnew
Changed ioascii.cpp to save and load board specific layer names, for DEBUG Changed ioascii.cpp to save and load board specific layer names, for DEBUG
build only. I want to add class LAYER, see below. Added build only. I want to add class LAYER, see below. Added
BOARD::SetLayerName(), BOARD::SetLayerType(), and BOARD::GetLayerType(). 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 ) wxString ReturnPcbLayerName( int layer_number, bool omitSpacePadding )
/**************************************************************/ /**************************************************************/
@ -276,32 +274,11 @@ wxString ReturnPcbLayerName( int layer_number, bool omitSpacePadding )
* (not internatinalized, no space) * (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; const unsigned LAYER_LIMIT = 29;
// @todo: these layer names should be configurable on a per project basis. // These are only default layer names. For PCBNEW, the copper names
// In anticipation of that enhancement, here is a different strategy for // may be over-ridden in the BOARD file *.brd.
// 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.
#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[] = { static const wxString layer_name_list[] = {
_( "Copper " ), _( "Inner L1 " ), _( "Inner L2 " ), _( "Inner L3 " ), _( "Copper " ), _( "Inner L1 " ), _( "Inner L2 " ), _( "Inner L3 " ),
_( "Inner L4 " ), _( "Inner L5 " ), _( "Inner L6 " ), _( "Inner L7 " ), _( "Inner L4 " ), _( "Inner L5 " ), _( "Inner L6 " ), _( "Inner L7 " ),
@ -313,8 +290,6 @@ wxString ReturnPcbLayerName( int layer_number, bool omitSpacePadding )
_( "Edges Pcb" ), _( "BAD INDEX" ), _( "Edges Pcb" ), _( "BAD INDEX" ),
}; };
#endif
if( (unsigned) layer_number > LAYER_LIMIT ) if( (unsigned) layer_number > LAYER_LIMIT )
layer_number = LAYER_LIMIT; layer_number = LAYER_LIMIT;
@ -332,42 +307,6 @@ wxString ReturnPcbLayerName( int layer_number, bool omitSpacePadding )
} }
else else
return *p; 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
} }

3
common/projet_config.cpp
View File

@ -319,7 +319,8 @@ bool WinEDA_App::ReadProjectConfig( const wxString& local_config_filename,
{ {
#undef PTCFG #undef PTCFG
#define PTCFG ( (PARAM_CFG_DOUBLE*) pt_cfg ) #define PTCFG ( (PARAM_CFG_DOUBLE*) pt_cfg )
double ftmp = 0; wxString msg; double ftmp = 0;
wxString msg;
if( pt_cfg->m_Setup ) if( pt_cfg->m_Setup )
msg = m_EDA_Config->Read( pt_cfg->m_Ident, wxT( "" ) ); msg = m_EDA_Config->Read( pt_cfg->m_Ident, wxT( "" ) );
else else

64
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 */ /* lit ou met a jour la configuration de CVPCB */
@ -18,57 +18,64 @@
/**************************************************/ /**************************************************/
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: /* lit la configuration
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 */ /* Init des valeurs par defaut */
g_LibName_List.Clear(); g_LibName_List.Clear();
g_ListName_Equ.Clear(); g_ListName_Equ.Clear();
g_EDA_Appl->ReadProjectConfig(FullFileName, g_EDA_Appl->ReadProjectConfig( FullFileName,
GROUP, ParamCfgList, FALSE); GROUP, ParamCfgList, FALSE );
if ( PkgInExtBuffer.IsEmpty() ) PkgInExtBuffer = wxT(".pkg"); if( PkgInExtBuffer.IsEmpty() )
if ( NetInExtBuffer.IsEmpty() ) NetInExtBuffer = wxT(".net"), PkgInExtBuffer = wxT( ".pkg" );
if( NetInExtBuffer.IsEmpty() )
NetInExtBuffer = wxT( ".net" );
/* Inits autres variables */ /* Inits autres variables */
SetRealLibraryPath( wxT("modules")); SetRealLibraryPath( wxT( "modules" ) );
} }
/************************************************************/ /************************************************************/
void WinEDA_CvpcbFrame::Update_Config(wxCommandEvent& event) void WinEDA_CvpcbFrame::Update_Config( wxCommandEvent& event )
/************************************************************/ /************************************************************/
/* fonction relai d'appel a Save_Config, /* 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 */ /* enregistrement de la config */
{ {
wxString path, FullFileName; wxString path, FullFileName;
wxString mask( wxT("*"));
wxString mask( wxT( "*" ) );
FullFileName = FFileName; FullFileName = FFileName;
ChangeFileNameExt( FullFileName, g_Prj_Config_Filename_ext ); ChangeFileNameExt( FullFileName, g_Prj_Config_Filename_ext );
path = wxGetCwd(); path = wxGetCwd();
FullFileName = EDA_FileSelector(_("Save preferences"), FullFileName = EDA_FileSelector( _( "Save preferences" ),
path, /* Chemin par defaut */ path, /* Chemin par defaut */
FullFileName, /* nom fichier par defaut */ FullFileName, /* nom fichier par defaut */
g_Prj_Config_Filename_ext, /* extension par defaut */ g_Prj_Config_Filename_ext, /* extension par defaut */
@ -77,9 +84,10 @@ wxString mask( wxT("*"));
wxFD_SAVE, wxFD_SAVE,
TRUE TRUE
); );
if ( FullFileName.IsEmpty()) return;
if( FullFileName.IsEmpty() )
return;
/* ecriture de la configuration */ /* ecriture de la configuration */
g_EDA_Appl->WriteProjectConfig(FullFileName, GROUP, ParamCfgList); g_EDA_Appl->WriteProjectConfig( FullFileName, GROUP, ParamCfgList );
} }

2
gerbview/gerbview.cpp
View File

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

12
gerbview/gerbview_config.cpp
View File

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

7
gerbview/select_layers_to_pcb.cpp
View File

@ -14,6 +14,7 @@
/* Variables locales */ /* Variables locales */
#define LAYER_UNSELECTED NB_LAYERS #define LAYER_UNSELECTED NB_LAYERS
static int ButtonTable[32]; // Indexes buttons to Gerber layers static int ButtonTable[32]; // Indexes buttons to Gerber layers
static int LayerLookUpTable[32]; // Indexes Gerber layers to PCB file layers static int LayerLookUpTable[32]; // Indexes Gerber layers to PCB file layers
wxStaticText* layer_list[32]; // Indexes text strings to buttons wxStaticText* layer_list[32]; // Indexes text strings to buttons
@ -75,6 +76,7 @@ int * InstallDialogLayerPairChoice(WinEDA_GerberFrame * parent)
*/ */
{ {
WinEDA_SwapLayerFrame * frame = new WinEDA_SwapLayerFrame(parent); WinEDA_SwapLayerFrame * frame = new WinEDA_SwapLayerFrame(parent);
int ii = frame->ShowModal(); int ii = frame->ShowModal();
frame->Destroy(); frame->Destroy();
if( ii >= 0 ) if( ii >= 0 )
@ -138,7 +140,6 @@ WinEDA_SwapLayerFrame::WinEDA_SwapLayerFrame(WinEDA_GerberFrame *parent) :
int pcb_layer_number = 0; int pcb_layer_number = 0;
for( nb_items = 0, ii = 0; ii < 32; ii++ ) for( nb_items = 0, ii = 0; ii < 32; ii++ )
{ {
if( g_GERBER_Descr_List[ii] == NULL ) if( g_GERBER_Descr_List[ii] == NULL )
continue; continue;
@ -353,8 +354,8 @@ void WinEDA_SwapLayerFrame::OnCancelClick(wxCommandEvent& event)
void WinEDA_SwapLayerFrame::OnOkClick(wxCommandEvent& event) void WinEDA_SwapLayerFrame::OnOkClick(wxCommandEvent& event)
/*********************************************************/ /*********************************************************/
{ {
int ii; int ii;
bool AsCmpLayer = false; bool AsCmpLayer = false;
/* Compute the number of copper layers /* Compute the number of copper layers
* this is the max layer number + 1 (if some internal layers exist) * 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 */ /* Class to handle a board */
#include "class_board.h" #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 // Class for handle current printed board design settings
#define HISTORY_NUMBER 8 #define HISTORY_NUMBER 8
class EDA_BoardDesignSettings class EDA_BoardDesignSettings
@ -207,7 +175,9 @@ public:
// Color options for screen display of the Printed Board: // Color options for screen display of the Printed Board:
int m_PcbGridColor; // Grid color int m_PcbGridColor; // Grid color
int m_LayerColor[32]; // Layer colors (tracks and graphic items) int m_LayerColor[32]; // Layer colors (tracks and graphic items)
int m_ViaColor[4]; // Via color (depending on is type) int m_ViaColor[4]; // Via color (depending on is type)
int m_ModuleTextCMPColor; // Text module color for modules on the COMPONENT layer int m_ModuleTextCMPColor; // Text module color for modules on the COMPONENT layer
int m_ModuleTextCUColor; // Text module color for modules on the COPPER layer int m_ModuleTextCUColor; // Text module color for modules on the COPPER layer

8
include/wxPcbStruct.h
View File

@ -74,6 +74,14 @@ public:
~WinEDA_BasePcbFrame(); ~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 // General
virtual void OnCloseWindow( wxCloseEvent& Event ) = 0; virtual void OnCloseWindow( wxCloseEvent& Event ) = 0;
virtual void Process_Special_Functions( wxCommandEvent& event ) = 0; virtual void Process_Special_Functions( wxCommandEvent& event ) = 0;

7
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 ) int WinEDA_BasePcbFrame::BestZoom( void )
/**************************************/ /**************************************/

80
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_LocalRatsnest = NULL; // pointeur liste rats local
m_CurrentZoneContour = NULL; // This ZONE_CONTAINER handle the zone contour cuurently in progress m_CurrentZoneContour = NULL; // This ZONE_CONTAINER handle the zone contour cuurently in progress
// de determination des contours de zone // 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 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 ); return ReturnPcbLayerName( aLayerIndex, true );
} }
bool BOARD::SetLayerName( int aLayerIndex, const wxString& aLayerName ) bool BOARD::SetLayerName( int aLayerIndex, const wxString& aLayerName )
{ {
// a dummy temporarily. if( (unsigned) aLayerIndex < (unsigned) GetCopperLayerCount() )
D(printf("SetLayerName( %d, %s )\n", aLayerIndex, CONV_TO_UTF8(aLayerName) );) {
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 true;
}
return false;
} }
LAYER_T BOARD::GetLayerType( int aLayerIndex ) const LAYER_T BOARD::GetLayerType( int aLayerIndex ) const
{ {
if( (unsigned) aLayerIndex < (unsigned) GetCopperLayerCount() )
return m_Layer[aLayerIndex].m_Type;
return LT_SIGNAL; return LT_SIGNAL;
} }
bool BOARD::SetLayerType( int aLayerIndex, LAYER_T aLayerType ) bool BOARD::SetLayerType( int aLayerIndex, LAYER_T aLayerType )
{ {
// a dummy temporarily. if( (unsigned) aLayerIndex < (unsigned) GetCopperLayerCount() )
{
m_Layer[aLayerIndex].m_Type = aLayerType;
return true; 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_SIGNAL,
LT_POWER, LT_POWER,
LT_MIXED, 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 class BOARD : public BOARD_ITEM
{ {
friend class WinEDA_PcbFrame; 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() 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 ZONE_CONTAINERS m_ZoneDescriptorList; ///< edge zone descriptors, owned by pointer
LAYER m_Layer[NB_COPPER_LAYERS];
public: public:
WinEDA_BasePcbFrame* m_PcbFrame; // Window de visualisation WinEDA_BasePcbFrame* m_PcbFrame; // Window de visualisation
EDA_Rect m_BoundaryBox; // Board size and position EDA_Rect m_BoundaryBox; // Board size and position
@ -294,6 +331,7 @@ public:
return wxT( "BOARD" ); return wxT( "BOARD" );
} }
#if defined(DEBUG) #if defined(DEBUG)
/** /**
* Function Show * Function Show

5
pcbnew/class_drawsegment.cpp
View File

@ -150,6 +150,9 @@ void DRAWSEGMENT::Display_Infos( WinEDA_DrawFrame* frame )
int itype; int itype;
wxString msg; wxString msg;
BOARD* board = (BOARD*) m_Parent;
wxASSERT( board );
frame->MsgPanel->EraseMsgBox(); frame->MsgPanel->EraseMsgBox();
itype = m_Type & 0x0F; 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, -1, wxEmptyString, _( "Segment" ), RED );
Affiche_1_Parametre( frame, 48, _( "Layer" ), Affiche_1_Parametre( frame, 48, _( "Layer" ),
ReturnPcbLayerName( m_Layer ), BROWN ); board->GetLayerName( m_Layer ), BROWN );
valeur_param( (unsigned) m_Width, msg ); valeur_param( (unsigned) m_Width, msg );
Affiche_1_Parametre( frame, 60, _( "Width" ), msg, DARKCYAN ); 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 ) ) if( m_BoundaryBox.Inside( spot_cX, spot_cY ) )
return true; 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; 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 // see class_module.h
SEARCH_RESULT MODULE::Visit( INSPECTOR* inspector, const void* testData, SEARCH_RESULT MODULE::Visit( INSPECTOR* inspector, const void* testData,
const KICAD_T scanTypes[] ) const KICAD_T scanTypes[] )

11
pcbnew/class_module.h
View File

@ -197,6 +197,17 @@ public:
return m_Value->m_Text; 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 * Function Visit
* should be re-implemented for each derived class in order to handle * 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; wxString msg;
BOARD* board = (BOARD*) m_Parent;
wxASSERT( board );
frame->MsgPanel->EraseMsgBox(); frame->MsgPanel->EraseMsgBox();
if( m_Parent && m_Parent->Type() == TYPECOTATION ) 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, 1, _( "PCB Text" ), m_Text, DARKGREEN );
Affiche_1_Parametre( frame, 28, _( "Layer" ), Affiche_1_Parametre( frame, 28, _( "Layer" ),
ReturnPcbLayerName( m_Layer ), board->GetLayerName( m_Layer ),
g_DesignSettings.m_LayerColor[m_Layer] & MASKCOLOR ); g_DesignSettings.m_LayerColor[m_Layer] & MASKCOLOR );
Affiche_1_Parametre( frame, 36, _( "Mirror" ), wxEmptyString, GREEN ); 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; MODULE* module = (MODULE*) m_Parent;
wxASSERT( module );
if( !module ) if( !module )
return; return;
BOARD* board = (BOARD*) module->m_Parent;
wxASSERT( board );
static const wxString text_type_msg[3] = { static const wxString text_type_msg[3] = {
_( "Ref." ), _( "Value" ), _( "Text" ) }; _( "Ref." ), _( "Value" ), _( "Text" ) };
@ -366,7 +371,7 @@ void TEXTE_MODULE::Display_Infos( WinEDA_DrawFrame* frame )
ii = m_Layer; ii = m_Layer;
if( ii < NB_LAYERS ) if( ii < NB_LAYERS )
Affiche_1_Parametre( frame, 28, _( "Layer" ), ReturnPcbLayerName( ii ), DARKGREEN ); Affiche_1_Parametre( frame, 28, _( "Layer" ), board->GetLayerName( ii ), DARKGREEN );
else else
{ {
msg.Printf( wxT( "%d" ), ii ); msg.Printf( wxT( "%d" ), ii );

6
pcbnew/class_zone.cpp
View File

@ -514,6 +514,10 @@ void ZONE_CONTAINER::Display_Infos( WinEDA_DrawFrame* frame )
wxString msg; wxString msg;
int text_pos; int text_pos;
BOARD* board = (BOARD*) m_Parent;
wxASSERT( board );
frame->MsgPanel->EraseMsgBox(); frame->MsgPanel->EraseMsgBox();
msg = _( "Zone Outline" ); msg = _( "Zone Outline" );
@ -551,7 +555,7 @@ void ZONE_CONTAINER::Display_Infos( WinEDA_DrawFrame* frame )
Affiche_1_Parametre( frame, text_pos, _( "NetCode" ), msg, RED ); Affiche_1_Parametre( frame, text_pos, _( "NetCode" ), msg, RED );
text_pos += 8; text_pos += 8;
msg = ReturnPcbLayerName( m_Layer ); msg = board->GetLayerName( m_Layer );
Affiche_1_Parametre( frame, text_pos, _( "Layer" ), msg, BROWN ); Affiche_1_Parametre( frame, text_pos, _( "Layer" ), msg, BROWN );
text_pos += 8; text_pos += 8;

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_MicroViaDrill = 50; // micro via drill (for the entire board)
m_CurrentMicroViaSize = 150; // Current micro via size m_CurrentMicroViaSize = 150; // Current micro via size
m_MicroViasAllowed = false; // true to allow micro vias m_MicroViasAllowed = false; // true to allow micro vias
for( ii = 0; ii < HISTORY_NUMBER; ii++ ) for( ii = 0; ii < HISTORY_NUMBER; ii++ )
{ {
m_TrackWidthHistory[ii] = 0; // Last HISTORY_NUMBER used track widths m_TrackWidthHistory[ii] = 0; // Last HISTORY_NUMBER used track widths
@ -171,6 +172,7 @@ EDA_BoardDesignSettings::EDA_BoardDesignSettings()
m_MaskMargin = 150; // Solder mask margin m_MaskMargin = 150; // Solder mask margin
/* Color options for screen display of the Printed Board: */ /* Color options for screen display of the Printed Board: */
m_PcbGridColor = DARKGRAY; // Grid color m_PcbGridColor = DARKGRAY; // Grid color
for( ii = 0; ii < 32; ii++ ) for( ii = 0; ii < 32; ii++ )
m_LayerColor[ii] = default_layer_color[ii]; m_LayerColor[ii] = default_layer_color[ii];
@ -179,6 +181,7 @@ EDA_BoardDesignSettings::EDA_BoardDesignSettings()
m_ViaColor[VIA_MICROVIA] = CYAN; m_ViaColor[VIA_MICROVIA] = CYAN;
m_ViaColor[VIA_BLIND_BURIED] = BROWN; m_ViaColor[VIA_BLIND_BURIED] = BROWN;
m_ViaColor[VIA_THROUGH] = WHITE; m_ViaColor[VIA_THROUGH] = WHITE;
m_ModuleTextCMPColor = LIGHTGRAY; // Text module color for modules on the COMPONENT layer 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_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) 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, m_SelLayerBox = new WinEDAChoiceBox( this, ID_TEXTPCB_SELECT_LAYER,
wxDefaultPosition, wxDefaultSize ); wxDefaultPosition, wxDefaultSize );
LeftBoxSizer->Add( m_SelLayerBox, 0, wxGROW | wxLEFT | wxRIGHT | wxBOTTOM, 5 ); 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 ); 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 ); modName = CONV_FROM_UTF8( text );
module = ReturnModule( frame->m_Pcb, modName ); module = frame->m_Pcb->FindModuleByReference( modName );
if( module ) if( module )
msg.Printf( _( "%s found" ), modName.GetData() ); msg.Printf( _( "%s found" ), modName.GetData() );
@ -86,9 +86,9 @@ void RemoteCommand( const char* cmdline )
modName = CONV_FROM_UTF8( text ); modName = CONV_FROM_UTF8( text );
module = ReturnModule( frame->m_Pcb, modName ); module = frame->m_Pcb->FindModuleByReference( modName );
if( module ) if( module )
pad = ReturnPad( module, pinName ); pad = module->FindPadByName( pinName );
if( pad ) if( pad )
netcode = pad->GetNet(); netcode = pad->GetNet();

25
pcbnew/dialog_zones_by_polygon.cpp
View File

@ -133,6 +133,8 @@ bool WinEDA_ZoneFrame::Create( wxWindow* parent,
void WinEDA_ZoneFrame::CreateControls() void WinEDA_ZoneFrame::CreateControls()
{ {
BOARD* board = m_Parent->m_Pcb;
SetFont( *g_DialogFont ); SetFont( *g_DialogFont );
////@begin WinEDA_ZoneFrame content construction ////@begin WinEDA_ZoneFrame content construction
@ -310,19 +312,23 @@ void WinEDA_ZoneFrame::CreateControls()
break; break;
} }
int layer_cnt = g_DesignSettings.m_CopperLayerCount; int layer_cnt = board->GetCopperLayerCount();
for( int ii = 0; ii < g_DesignSettings.m_CopperLayerCount; ii++ ) for( int ii = 0; ii < board->GetCopperLayerCount(); ii++ )
{ {
wxString msg; wxString msg;
int layer_number = COPPER_LAYER_N; int layer_number = COPPER_LAYER_N;
if( layer_cnt == 0 || ii < layer_cnt - 1 ) if( layer_cnt == 0 || ii < layer_cnt - 1 )
layer_number = ii; layer_number = ii;
else if( ii == layer_cnt - 1 ) else if( ii == layer_cnt - 1 )
layer_number = LAYER_CMP_N; layer_number = LAYER_CMP_N;
m_LayerId[ii] = layer_number; m_LayerId[ii] = layer_number;
msg = ReturnPcbLayerName( layer_number ).Trim();
msg = board->GetLayerName( layer_number ).Trim();
m_LayerSelectionCtrl->InsertItems( 1, &msg, ii ); m_LayerSelectionCtrl->InsertItems( 1, &msg, ii );
if ( m_Zone_Container )
if( m_Zone_Container )
{ {
if( m_Zone_Container->GetLayer() == layer_number ) if( m_Zone_Container->GetLayer() == layer_number )
m_LayerSelectionCtrl->SetSelection( ii ); m_LayerSelectionCtrl->SetSelection( ii );
@ -335,21 +341,24 @@ void WinEDA_ZoneFrame::CreateControls()
} }
m_NetSortingOption->SetSelection(m_NetSorting == BOARD::ALPHA_SORT ? 0 : 1 ); m_NetSortingOption->SetSelection(m_NetSorting == BOARD::ALPHA_SORT ? 0 : 1 );
wxString NetNameFilter; wxString NetNameFilter;
if( m_Parent->m_Parent->m_EDA_Config ) 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*") ); NetNameFilter = m_Parent->m_Parent->m_EDA_Config->Read( ZONE_NET_FILTER_STRING_KEY, wxT("N_0*") );
} }
m_NetNameFilter->SetValue(NetNameFilter); m_NetNameFilter->SetValue(NetNameFilter);
wxArrayString ListNetName; wxArrayString ListNetName;
m_Parent->m_Pcb->ReturnSortedNetnamesList( ListNetName, m_Parent->m_Pcb->ReturnSortedNetnamesList( ListNetName,
m_NetSorting == 0 ? BOARD::ALPHA_SORT : BOARD::PAD_CNT_SORT ); m_NetSorting == 0 ? BOARD::ALPHA_SORT : BOARD::PAD_CNT_SORT );
if ( m_NetSorting != 0 ) if ( m_NetSorting != 0 )
{ {
wxString Filter = m_NetNameFilter->GetValue(); wxString Filter = m_NetNameFilter->GetValue();
for (unsigned ii = 0; ii < ListNetName.GetCount(); ii ++ ) for( unsigned ii = 0; ii < ListNetName.GetCount(); ii++ )
{ {
if ( ListNetName[ii].Matches(Filter.GetData() ) ) if( ListNetName[ii].Matches(Filter.GetData() ) )
{ {
ListNetName. RemoveAt(ii); ListNetName. RemoveAt(ii);
ii--; ii--;
@ -361,8 +370,9 @@ void WinEDA_ZoneFrame::CreateControls()
// Select net: // Select net:
int net_select = g_HightLigth_NetCode; int net_select = g_HightLigth_NetCode;
if ( m_Zone_Container ) if( m_Zone_Container )
net_select = m_Zone_Container->GetNet(); net_select = m_Zone_Container->GetNet();
if( net_select > 0 ) if( net_select > 0 )
{ {
EQUIPOT* equipot = m_Parent->m_Pcb->FindNet( net_select ); EQUIPOT* equipot = m_Parent->m_Pcb->FindNet( net_select );
@ -563,7 +573,6 @@ void WinEDA_ZoneFrame::OnNetSortingOptionSelected( wxCommandEvent& event )
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_SORT_OPTION_KEY, (long) m_NetSorting );
m_Parent->m_Parent->m_EDA_Config->Write( ZONE_NET_FILTER_STRING_KEY, m_NetNameFilter->GetValue() ); m_Parent->m_Parent->m_EDA_Config->Write( ZONE_NET_FILTER_STRING_KEY, m_NetNameFilter->GetValue() );
} }
} }

2
pcbnew/editedge.cpp
View File

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

47
pcbnew/initpcb.cpp
View File

@ -127,26 +127,9 @@ bool WinEDA_BasePcbFrame::Clear_Pcb( bool query )
} }
} }
/* Suppression des listes chainees */ // delete the old BOARD and create a new BOARD so that the default
m_Pcb->m_Equipots->DeleteStructList(); // layer names are put into the BOARD.
m_Pcb->m_Equipots = NULL; SetBOARD( new BOARD( NULL, this ) );
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();
for( ; g_UnDeleteStackPtr != 0; ) for( ; g_UnDeleteStackPtr != 0; )
{ {
@ -159,30 +142,6 @@ bool WinEDA_BasePcbFrame::Clear_Pcb( bool query )
memset( buf_work, 0, BUFMEMSIZE ); memset( buf_work, 0, BUFMEMSIZE );
adr_lowmem = adr_max = buf_work; 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 ); SetCurItem( NULL );
/* Init parametres de gestion */ /* Init parametres de gestion */

42
pcbnew/ioascii.cpp
View File

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

49
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 ) TRACK* Locate_Via( BOARD* Pcb, const wxPoint& pos, int layer )
/*******************************************************************/ /*******************************************************************/

3
pcbnew/pcbframe.cpp
View File

@ -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 m_drc = new DRC( this ); // these 2 objects point to each other
SetBOARD( new BOARD( NULL, this ) );
m_DisplayPcbTrackFill = DisplayOpt.DisplayPcbTrackFill; m_DisplayPcbTrackFill = DisplayOpt.DisplayPcbTrackFill;
m_DisplayPadFill = DisplayOpt.DisplayPadFill; m_DisplayPadFill = DisplayOpt.DisplayPadFill;
m_DisplayPadNum = DisplayOpt.DisplayPadNum; m_DisplayPadNum = DisplayOpt.DisplayPadNum;
@ -247,6 +249,7 @@ WinEDA_PcbFrame::~WinEDA_PcbFrame()
m_Parent->m_PcbFrame = NULL; m_Parent->m_PcbFrame = NULL;
m_CurrentScreen = ScreenPcb; m_CurrentScreen = ScreenPcb;
delete m_drc; 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(); wxString Title = g_Main_Title + wxT( " " ) + GetBuildVersion();
m_PcbFrame->SetTitle( Title ); m_PcbFrame->SetTitle( Title );
ActiveScreen = ScreenPcb; ActiveScreen = ScreenPcb;
m_PcbFrame->m_Pcb = new BOARD( NULL, m_PcbFrame );
SetTopWindow( m_PcbFrame ); SetTopWindow( m_PcbFrame );
m_PcbFrame->Show( TRUE ); m_PcbFrame->Show( TRUE );

638
pcbnew/pcbplot.cpp
View File

@ -1,6 +1,6 @@
/***********************/ /***********************/
/* fichier pcbplot.cpp */ /* fichier pcbplot.cpp */
/***********************/ /***********************/
#include "fctsys.h" #include "fctsys.h"
#include "gr_basic.h" #include "gr_basic.h"
@ -17,9 +17,9 @@
#define PLOT_DEFAULT_MARGE 300 // mils #define PLOT_DEFAULT_MARGE 300 // mils
/* Keywords to r/w options in config */ /* Keywords to r/w options in config */
#define EDGELAYER_GERBER_OPT_KEY wxT("EdgeLayerGerberOpt") #define EDGELAYER_GERBER_OPT_KEY wxT( "EdgeLayerGerberOpt" )
#define PLOT_XFINESCALE_ADJ_KEY wxT("PlotXFineScaleAdj") #define PLOT_XFINESCALE_ADJ_KEY wxT( "PlotXFineScaleAdj" )
#define PLOT_YFINESCALE_ADJ_KEY wxT("PlotYFineScaleAdj") #define PLOT_YFINESCALE_ADJ_KEY wxT( "PlotYFineScaleAdj" )
// variables locale : // variables locale :
static long s_SelectedLayers = CUIVRE_LAYER | CMP_LAYER | static long s_SelectedLayers = CUIVRE_LAYER | CMP_LAYER |
@ -28,8 +28,7 @@ static bool s_PlotOriginIsAuxAxis = FALSE;
// Routines Locales // Routines Locales
enum id_plotps enum id_plotps {
{
ID_CLOSE_PLOT = 8020, ID_CLOSE_PLOT = 8020,
ID_DRILL_SHAPE_OPT, ID_DRILL_SHAPE_OPT,
ID_SCALE_OPT, ID_SCALE_OPT,
@ -54,61 +53,62 @@ enum id_plotps
}; };
/*******************************/ /*******************************/
/* Dialog box for plot control */ /* Dialog box for plot control */
/*******************************/ /*******************************/
class WinEDA_PlotFrame: public wxDialog class WinEDA_PlotFrame : public wxDialog
{ {
public: public:
WinEDA_BasePcbFrame * m_Parent; WinEDA_BasePcbFrame* m_Parent;
wxButton * m_MergePlotButton; wxButton* m_MergePlotButton;
wxCheckBox * m_BoxSelecLayer[32]; wxCheckBox* m_BoxSelecLayer[32];
wxRadioBox * m_PlotFormatOpt; wxRadioBox* m_PlotFormatOpt;
wxRadioBox * m_Choice_Plot_Offset; wxRadioBox* m_Choice_Plot_Offset;
wxRadioBox * m_Drill_Shape_Opt; wxRadioBox* m_Drill_Shape_Opt;
wxRadioBox * m_Scale_Opt; wxRadioBox* m_Scale_Opt;
wxRadioBox * m_PlotModeOpt; wxRadioBox* m_PlotModeOpt;
wxCheckBox * m_PlotMirorOpt; wxCheckBox* m_PlotMirorOpt;
wxCheckBox * m_PlotNoViaOnMaskOpt; wxCheckBox* m_PlotNoViaOnMaskOpt;
wxCheckBox * m_HPGL_PlotCenter_Opt; wxCheckBox* m_HPGL_PlotCenter_Opt;
wxCheckBox * m_Exclude_Edges_Pcb; wxCheckBox* m_Exclude_Edges_Pcb;
wxCheckBox * m_Plot_Sheet_Ref; wxCheckBox* m_Plot_Sheet_Ref;
wxCheckBox * m_Plot_Invisible_Text; wxCheckBox* m_Plot_Invisible_Text;
wxCheckBox * m_Plot_Text_Value; wxCheckBox* m_Plot_Text_Value;
wxCheckBox * m_Plot_Text_Ref; wxCheckBox* m_Plot_Text_Ref;
wxCheckBox * m_Plot_Text_Div; wxCheckBox* m_Plot_Text_Div;
wxCheckBox * m_Plot_Pads_on_Silkscreen; wxCheckBox* m_Plot_Pads_on_Silkscreen;
wxCheckBox * m_Force_Plot_Pads; wxCheckBox* m_Force_Plot_Pads;
wxCheckBox * m_Plot_PS_Negative; wxCheckBox* m_Plot_PS_Negative;
WinEDA_ValueCtrl * m_GerbSpotSizeMinOpt; WinEDA_ValueCtrl* m_GerbSpotSizeMinOpt;
WinEDA_ValueCtrl * m_LinesWidth; WinEDA_ValueCtrl* m_LinesWidth;
WinEDA_ValueCtrl * m_HPGLPenSizeOpt; WinEDA_ValueCtrl* m_HPGLPenSizeOpt;
WinEDA_ValueCtrl * m_HPGLPenSpeedOpt; WinEDA_ValueCtrl* m_HPGLPenSpeedOpt;
WinEDA_ValueCtrl * m_HPGLPenOverlayOpt; WinEDA_ValueCtrl* m_HPGLPenOverlayOpt;
WinEDA_DFloatValueCtrl * m_FineAdjustXscaleOpt, * m_FineAdjustYscaleOpt; WinEDA_DFloatValueCtrl* m_FineAdjustXscaleOpt, * m_FineAdjustYscaleOpt;
double m_XScaleAdjust, m_YScaleAdjust; double m_XScaleAdjust, m_YScaleAdjust;
int m_PlotFormat; int m_PlotFormat;
public: public:
WinEDA_PlotFrame(WinEDA_BasePcbFrame * parent); WinEDA_PlotFrame( WinEDA_BasePcbFrame * parent );
private: private:
void Plot(wxCommandEvent & event); void Plot( wxCommandEvent& event );
void OnQuit(wxCommandEvent & event); void OnQuit( wxCommandEvent& event );
void OnClose(wxCloseEvent & event); void OnClose( wxCloseEvent& event );
void SetCommands(wxCommandEvent & event); void SetCommands( wxCommandEvent& event );
void SaveOptPlot(wxCommandEvent & event); void SaveOptPlot( wxCommandEvent& event );
void CreateDrillFile(wxCommandEvent & event); void CreateDrillFile( wxCommandEvent& event );
DECLARE_EVENT_TABLE() DECLARE_EVENT_TABLE()
}; };
BEGIN_EVENT_TABLE(WinEDA_PlotFrame, wxDialog) BEGIN_EVENT_TABLE( WinEDA_PlotFrame, wxDialog )
EVT_CLOSE(WinEDA_PlotFrame::OnClose) EVT_CLOSE( WinEDA_PlotFrame::OnClose )
EVT_BUTTON(ID_CLOSE_PLOT, WinEDA_PlotFrame::OnQuit) EVT_BUTTON( ID_CLOSE_PLOT, WinEDA_PlotFrame::OnQuit )
EVT_BUTTON(ID_EXEC_PLOT, WinEDA_PlotFrame::Plot) EVT_BUTTON( ID_EXEC_PLOT, WinEDA_PlotFrame::Plot )
EVT_BUTTON(ID_SAVE_OPT_PLOT, WinEDA_PlotFrame::SaveOptPlot) EVT_BUTTON( ID_SAVE_OPT_PLOT, WinEDA_PlotFrame::SaveOptPlot )
EVT_BUTTON(ID_CREATE_DRILL_FILE, WinEDA_PlotFrame::CreateDrillFile) EVT_BUTTON( ID_CREATE_DRILL_FILE, WinEDA_PlotFrame::CreateDrillFile )
EVT_RADIOBOX(ID_SEL_PLOT_FORMAT, WinEDA_PlotFrame::SetCommands) EVT_RADIOBOX( ID_SEL_PLOT_FORMAT, WinEDA_PlotFrame::SetCommands )
END_EVENT_TABLE() END_EVENT_TABLE()
@ -116,48 +116,63 @@ const int UNITS_MILS = 1000;
/********************************************************************/ /********************************************************************/
WinEDA_PlotFrame::WinEDA_PlotFrame(WinEDA_BasePcbFrame * parent): WinEDA_PlotFrame::WinEDA_PlotFrame( WinEDA_BasePcbFrame* parent ) :
wxDialog(parent, -1, _("Plot"), wxDialog( parent, -1, _( "Plot" ),
wxPoint(-1,-1), wxDefaultSize, wxPoint( -1, -1 ), wxDefaultSize,
wxDEFAULT_DIALOG_STYLE) wxDEFAULT_DIALOG_STYLE )
/********************************************************************/ /********************************************************************/
{ {
wxButton * Button; wxButton* Button;
int ii; int ii;
m_Parent = parent; m_Parent = parent;
SetFont(*g_DialogFont);
BOARD* board = parent->m_Pcb;
SetFont( *g_DialogFont );
Centre(); Centre();
m_PlotFormat = format_plot; m_PlotFormat = format_plot;
m_Plot_Sheet_Ref = NULL; m_Plot_Sheet_Ref = NULL;
wxBoxSizer * MainBoxSizer = new wxBoxSizer(wxHORIZONTAL); wxBoxSizer* MainBoxSizer = new wxBoxSizer( wxHORIZONTAL );
SetSizer(MainBoxSizer);
wxBoxSizer * RightBoxSizer = new wxBoxSizer(wxVERTICAL);
wxBoxSizer * MidRightBoxSizer = new wxBoxSizer(wxVERTICAL);
wxBoxSizer * MidLeftBoxSizer = new wxBoxSizer(wxVERTICAL);
wxBoxSizer * LeftBoxSizer = new wxBoxSizer(wxVERTICAL);
MainBoxSizer->Add(LeftBoxSizer, 0, wxGROW|wxALL, 5);
MainBoxSizer->Add(MidLeftBoxSizer, 0, wxGROW|wxALL, 5);
MainBoxSizer->Add(MidRightBoxSizer, 0, wxGROW|wxALL, 5);
MainBoxSizer->Add(RightBoxSizer, 0, wxGROW|wxALL, 5);
wxBoxSizer * LayersBoxSizer = new wxBoxSizer(wxHORIZONTAL); SetSizer( MainBoxSizer );
LeftBoxSizer->Add(LayersBoxSizer, 0, wxGROW|wxALL, 5); wxBoxSizer* RightBoxSizer = new wxBoxSizer( wxVERTICAL );
wxString fmtmsg[4] = { wxT("HPGL"), wxT("Gerber"), wxT("Postscript"), wxT("Postscript A4") }; wxBoxSizer* MidRightBoxSizer = new wxBoxSizer( wxVERTICAL );
m_PlotFormatOpt = new wxRadioBox(this, ID_SEL_PLOT_FORMAT,
_("Plot Format"), wxDefaultPosition, wxSize(-1,-1), wxBoxSizer* MidLeftBoxSizer = new wxBoxSizer( wxVERTICAL );
4, fmtmsg, 1, wxRA_SPECIFY_COLS);
MidRightBoxSizer->Add(m_PlotFormatOpt, 0, wxGROW|wxALL, 5); wxBoxSizer* LeftBoxSizer = new wxBoxSizer( wxVERTICAL );
switch ( m_PlotFormat )
MainBoxSizer->Add( LeftBoxSizer, 0, wxGROW | wxALL, 5 );
MainBoxSizer->Add( MidLeftBoxSizer, 0, wxGROW | wxALL, 5 );
MainBoxSizer->Add( MidRightBoxSizer, 0, wxGROW | wxALL, 5 );
MainBoxSizer->Add( RightBoxSizer, 0, wxGROW | wxALL, 5 );
wxBoxSizer* LayersBoxSizer = new wxBoxSizer( wxHORIZONTAL );
LeftBoxSizer->Add( LayersBoxSizer, 0, wxGROW | wxALL, 5 );
static const wxString fmtmsg[4] = {
wxT( "HPGL" ), wxT( "Gerber" ), wxT( "Postscript" ), wxT( "Postscript A4" )
};
m_PlotFormatOpt = new wxRadioBox( this, ID_SEL_PLOT_FORMAT,
_( "Plot Format" ), wxDefaultPosition, wxSize( -1, -1 ),
4, fmtmsg, 1, wxRA_SPECIFY_COLS );
MidRightBoxSizer->Add( m_PlotFormatOpt, 0, wxGROW | wxALL, 5 );
switch( m_PlotFormat )
{ {
case PLOT_FORMAT_HPGL: case PLOT_FORMAT_HPGL:
m_PlotFormatOpt->SetSelection(0); m_PlotFormatOpt->SetSelection( 0 );
break; break;
case PLOT_FORMAT_GERBER: case PLOT_FORMAT_GERBER:
m_PlotFormatOpt->SetSelection(1); m_PlotFormatOpt->SetSelection( 1 );
break; break;
default: // ( PLOT_FORMAT_POST or PLOT_FORMAT_POST_A4 ) default: // ( PLOT_FORMAT_POST or PLOT_FORMAT_POST_A4 )
@ -166,250 +181,295 @@ wxString fmtmsg[4] = { wxT("HPGL"), wxT("Gerber"), wxT("Postscript"), wxT("Posts
// "Postscript" or "Postscipt A4" radiobutton had been selected // "Postscript" or "Postscipt A4" radiobutton had been selected
// previously (and thus which button should be reselected now). // previously (and thus which button should be reselected now).
if( g_ForcePlotPS_On_A4 ) if( g_ForcePlotPS_On_A4 )
m_PlotFormatOpt->SetSelection(3); m_PlotFormatOpt->SetSelection( 3 );
else else
m_PlotFormatOpt->SetSelection(2); m_PlotFormatOpt->SetSelection( 2 );
break; break;
} }
// Creation des menus d'option du format GERBER // Creation des menus d'option du format GERBER
m_GerbSpotSizeMinOpt = new WinEDA_ValueCtrl(this, _("Spot min"), m_GerbSpotSizeMinOpt = new WinEDA_ValueCtrl( this, _( "Spot min" ),
spot_mini, g_UnitMetric, MidRightBoxSizer, UNITS_MILS); spot_mini, g_UnitMetric, MidRightBoxSizer,
UNITS_MILS );
// Creation des menus d'option du format HPGL // Creation des menus d'option du format HPGL
m_HPGLPenSizeOpt = new WinEDA_ValueCtrl(this, _("Pen Size"), m_HPGLPenSizeOpt = new WinEDA_ValueCtrl( this, _( "Pen Size" ),
g_HPGL_Pen_Diam, g_UnitMetric, MidRightBoxSizer, UNITS_MILS); g_HPGL_Pen_Diam, g_UnitMetric, MidRightBoxSizer,
UNITS_MILS );
// unites standards = cm pour vitesse plume en HPGL // unites standards = cm pour vitesse plume en HPGL
m_HPGLPenSpeedOpt = new WinEDA_ValueCtrl(this, _("Pen Speed (cm/s)"), m_HPGLPenSpeedOpt = new WinEDA_ValueCtrl( this, _( "Pen Speed (cm/s)" ),
g_HPGL_Pen_Speed, CENTIMETRE, MidRightBoxSizer, 1); g_HPGL_Pen_Speed, CENTIMETRE, MidRightBoxSizer,
m_HPGLPenSpeedOpt->SetToolTip(_("Set pen speed in cm/s")); 1 );
m_HPGLPenOverlayOpt = new WinEDA_ValueCtrl(this, _("Pen Ovr"), m_HPGLPenSpeedOpt->SetToolTip( _( "Set pen speed in cm/s" ) );
g_HPGL_Pen_Recouvrement, g_UnitMetric, MidRightBoxSizer, UNITS_MILS);
m_HPGLPenOverlayOpt->SetToolTip(_("Set plot overlay for filling"));
m_LinesWidth = new WinEDA_ValueCtrl(this, _("Lines Width"), m_HPGLPenOverlayOpt = new WinEDA_ValueCtrl( this, _( "Pen Ovr" ),
g_PlotLine_Width, g_UnitMetric, MidRightBoxSizer, PCB_INTERNAL_UNIT); g_HPGL_Pen_Recouvrement, g_UnitMetric,
m_LinesWidth->SetToolTip(_("Set width for lines in Line plot mode")); MidRightBoxSizer, UNITS_MILS );
m_HPGLPenOverlayOpt->SetToolTip( _( "Set plot overlay for filling" ) );
m_LinesWidth = new WinEDA_ValueCtrl( this, _( "Lines Width" ),
g_PlotLine_Width, g_UnitMetric, MidRightBoxSizer,
PCB_INTERNAL_UNIT );
m_LinesWidth->SetToolTip( _( "Set width for lines in Line plot mode" ) );
// Create the right column commands // Create the right column commands
wxString choice_plot_offset_msg[] = static const wxString choice_plot_offset_msg[] =
{_("Absolute"), _("Auxiliary axis")}; { _( "Absolute" ), _( "Auxiliary axis" ) };
m_Choice_Plot_Offset = new wxRadioBox(this, ID_SEL_PLOT_OFFSET_OPTION,
_("Plot Origin"), m_Choice_Plot_Offset = new wxRadioBox( this, ID_SEL_PLOT_OFFSET_OPTION,
wxDefaultPosition,wxSize(-1,-1), _( "Plot Origin" ),
2,choice_plot_offset_msg,1,wxRA_SPECIFY_COLS); wxDefaultPosition, wxSize( -1, -1 ),
2, choice_plot_offset_msg, 1, wxRA_SPECIFY_COLS );
if( s_PlotOriginIsAuxAxis ) if( s_PlotOriginIsAuxAxis )
m_Choice_Plot_Offset->SetSelection(1); m_Choice_Plot_Offset->SetSelection( 1 );
RightBoxSizer->Add(m_Choice_Plot_Offset, 0, wxGROW|wxALL, 5); RightBoxSizer->Add( m_Choice_Plot_Offset, 0, wxGROW | wxALL, 5 );
/* Add a spacer for a better look */ /* Add a spacer for a better look */
RightBoxSizer->Add(5, 5, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 20); RightBoxSizer->Add( 5, 5, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 20 );
/* Create the command buttons */ /* Create the command buttons */
Button = new wxButton(this, ID_EXEC_PLOT, _("Plot")); Button = new wxButton( this, ID_EXEC_PLOT, _( "Plot" ) );
Button->SetForegroundColour(*wxRED);
RightBoxSizer->Add(Button, 0, wxGROW|wxALL, 5);
Button = new wxButton(this, ID_CLOSE_PLOT, _("Close")); Button->SetForegroundColour( *wxRED );
Button->SetForegroundColour(*wxBLUE); RightBoxSizer->Add( Button, 0, wxGROW | wxALL, 5 );
RightBoxSizer->Add(Button, 0, wxGROW|wxALL, 5);
Button = new wxButton(this, ID_SAVE_OPT_PLOT, _("Save options")); Button = new wxButton( this, ID_CLOSE_PLOT, _( "Close" ) );
Button->SetForegroundColour(wxColour(0,80,0) );
RightBoxSizer->Add(Button, 0, wxGROW|wxALL, 5);
Button = new wxButton(this, ID_CREATE_DRILL_FILE, _("Create Drill File")); Button->SetForegroundColour( *wxBLUE );
Button->SetForegroundColour(wxColour(0,80,80) ); RightBoxSizer->Add( Button, 0, wxGROW | wxALL, 5 );
RightBoxSizer->Add(Button, 0, wxGROW|wxALL, 5);
Button = new wxButton( this, ID_SAVE_OPT_PLOT, _( "Save options" ) );
Button->SetForegroundColour( wxColour( 0, 80, 0 ) );
RightBoxSizer->Add( Button, 0, wxGROW | wxALL, 5 );
Button = new wxButton( this, ID_CREATE_DRILL_FILE, _( "Create Drill File" ) );
Button->SetForegroundColour( wxColour( 0, 80, 80 ) );
RightBoxSizer->Add( Button, 0, wxGROW | wxALL, 5 );
// Create scale adjust option // Create scale adjust option
m_XScaleAdjust = m_YScaleAdjust = 1.0; m_XScaleAdjust = m_YScaleAdjust = 1.0;
if( m_Parent->m_Parent->m_EDA_Config ) if( m_Parent->m_Parent->m_EDA_Config )
{ {
m_Parent->m_Parent->m_EDA_Config->Read( EDGELAYER_GERBER_OPT_KEY, &g_Exclude_Edges_Pcb); m_Parent->m_Parent->m_EDA_Config->Read( EDGELAYER_GERBER_OPT_KEY, &g_Exclude_Edges_Pcb );
m_Parent->m_Parent->m_EDA_Config->Read( PLOT_XFINESCALE_ADJ_KEY, &m_XScaleAdjust); m_Parent->m_Parent->m_EDA_Config->Read( PLOT_XFINESCALE_ADJ_KEY, &m_XScaleAdjust );
m_Parent->m_Parent->m_EDA_Config->Read( PLOT_XFINESCALE_ADJ_KEY, &m_YScaleAdjust); m_Parent->m_Parent->m_EDA_Config->Read( PLOT_XFINESCALE_ADJ_KEY, &m_YScaleAdjust );
} }
m_FineAdjustXscaleOpt = new WinEDA_DFloatValueCtrl(this, _("X Scale Adjust"), m_XScaleAdjust, RightBoxSizer); m_FineAdjustXscaleOpt = new WinEDA_DFloatValueCtrl( this, _(
m_FineAdjustXscaleOpt->SetToolTip(_("Set X scale adjust for exact scale plotting")); "X Scale Adjust" ), m_XScaleAdjust,
m_FineAdjustYscaleOpt = new WinEDA_DFloatValueCtrl(this, _("Y Scale Adjust"), m_YScaleAdjust, RightBoxSizer); RightBoxSizer );
m_FineAdjustYscaleOpt->SetToolTip(_("Set Y scale adjust for exact scale plotting"));
m_Plot_PS_Negative = new wxCheckBox(this, -1, _("Plot Negative") ); m_FineAdjustXscaleOpt->SetToolTip( _( "Set X scale adjust for exact scale plotting" ) );
m_Plot_PS_Negative->SetValue(g_Plot_PS_Negative); m_FineAdjustYscaleOpt = new WinEDA_DFloatValueCtrl( this, _(
RightBoxSizer->Add(m_Plot_PS_Negative, 0, wxGROW|wxALL, 5); "Y Scale Adjust" ), m_YScaleAdjust,
RightBoxSizer );
m_FineAdjustYscaleOpt->SetToolTip( _( "Set Y scale adjust for exact scale plotting" ) );
m_Plot_PS_Negative = new wxCheckBox( this, -1, _( "Plot Negative" ) );
m_Plot_PS_Negative->SetValue( g_Plot_PS_Negative );
RightBoxSizer->Add( m_Plot_PS_Negative, 0, wxGROW | wxALL, 5 );
// Creation de la liste des layers // Creation de la liste des layers
int mask = 1; int mask = 1;
wxBoxSizer * OneColonLayerBoxSizer = new wxBoxSizer(wxVERTICAL); wxBoxSizer* OneColonLayerBoxSizer = new wxBoxSizer( wxVERTICAL );
LayersBoxSizer->Add(OneColonLayerBoxSizer, 0, wxGROW|wxALL, 5);
for ( ii = 0; ii < NB_LAYERS; ii++, mask <<= 1 ) LayersBoxSizer->Add( OneColonLayerBoxSizer, 0, wxGROW | wxALL, 5 );
for( ii = 0; ii < NB_LAYERS; ii++, mask <<= 1 )
{ {
if( ii == 16 ) if( ii == 16 )
{ {
OneColonLayerBoxSizer = new wxBoxSizer(wxVERTICAL); OneColonLayerBoxSizer = new wxBoxSizer( wxVERTICAL );
LayersBoxSizer->Add(OneColonLayerBoxSizer, 0, wxGROW|wxALL, 5);
LayersBoxSizer->Add( OneColonLayerBoxSizer, 0, wxGROW | wxALL, 5 );
} }
m_BoxSelecLayer[ii] = new wxCheckBox(this, -1, ReturnPcbLayerName(ii)); m_BoxSelecLayer[ii] = new wxCheckBox( this, -1, board->GetLayerName (ii) );
if( mask & s_SelectedLayers ) if( mask & s_SelectedLayers )
m_BoxSelecLayer[ii]->SetValue(true); m_BoxSelecLayer[ii]->SetValue( true );
OneColonLayerBoxSizer->Add(m_BoxSelecLayer[ii], 0, wxGROW|wxALL, 1); OneColonLayerBoxSizer->Add( m_BoxSelecLayer[ii], 0, wxGROW | wxALL, 1 );
} }
// Option for excluding contents of "Edges Pcb" layer // Option for excluding contents of "Edges Pcb" layer
m_Exclude_Edges_Pcb = new wxCheckBox(this, m_Exclude_Edges_Pcb = new wxCheckBox( this,
ID_EXCLUDE_EDGES_PCB, _("Exclude Edges Pcb Layer") ); ID_EXCLUDE_EDGES_PCB, _( "Exclude Edges Pcb Layer" ) );
m_Exclude_Edges_Pcb->SetValue(g_Exclude_Edges_Pcb);
m_Exclude_Edges_Pcb->SetValue( g_Exclude_Edges_Pcb );
m_Exclude_Edges_Pcb->SetToolTip( m_Exclude_Edges_Pcb->SetToolTip(
_("Exclude contents of Edges Pcb layer from all other layers") ); _( "Exclude contents of Edges Pcb layer from all other layers" ) );
LeftBoxSizer->Add(m_Exclude_Edges_Pcb, 0, wxGROW|wxALL, 1); LeftBoxSizer->Add( m_Exclude_Edges_Pcb, 0, wxGROW | wxALL, 1 );
// Option d'impression du cartouche: // Option d'impression du cartouche:
if( m_Parent->m_Print_Sheet_Ref ) if( m_Parent->m_Print_Sheet_Ref )
{ {
m_Plot_Sheet_Ref = new wxCheckBox(this, ID_PRINT_REF, _("Print Sheet Ref") ); m_Plot_Sheet_Ref = new wxCheckBox( this, ID_PRINT_REF, _( "Print Sheet Ref" ) );
m_Plot_Sheet_Ref->SetValue(Plot_Sheet_Ref);
LeftBoxSizer->Add(m_Plot_Sheet_Ref, 0, wxGROW|wxALL, 1); m_Plot_Sheet_Ref->SetValue( Plot_Sheet_Ref );
LeftBoxSizer->Add( m_Plot_Sheet_Ref, 0, wxGROW | wxALL, 1 );
} }
else else
Plot_Sheet_Ref = false; Plot_Sheet_Ref = false;
// Option d'impression des pads sur toutes les couches // Option d'impression des pads sur toutes les couches
m_Plot_Pads_on_Silkscreen = new wxCheckBox(this, m_Plot_Pads_on_Silkscreen = new wxCheckBox( this,
ID_PRINT_PAD_ON_SILKSCREEN, _("Print Pads on Silkscreen") ); ID_PRINT_PAD_ON_SILKSCREEN, _(
m_Plot_Pads_on_Silkscreen->SetValue(PlotPadsOnSilkLayer); "Print Pads on Silkscreen" ) );
m_Plot_Pads_on_Silkscreen->SetToolTip(
_("Enable/disable print/plot pads on Silkscreen layers") );
LeftBoxSizer->Add(m_Plot_Pads_on_Silkscreen, 0, wxGROW|wxALL, 1);
m_Force_Plot_Pads = new wxCheckBox(this, ID_FORCE_PRINT_PAD, m_Plot_Pads_on_Silkscreen->SetValue( PlotPadsOnSilkLayer );
_("Always Print Pads") ); m_Plot_Pads_on_Silkscreen->SetToolTip(
m_Force_Plot_Pads->SetValue(Plot_Pads_All_Layers); _( "Enable/disable print/plot pads on Silkscreen layers" ) );
m_Force_Plot_Pads->SetToolTip(_("Force print/plot pads on ALL layers") ); LeftBoxSizer->Add( m_Plot_Pads_on_Silkscreen, 0, wxGROW | wxALL, 1 );
LeftBoxSizer->Add(m_Force_Plot_Pads, 0, wxGROW|wxALL, 1);
m_Force_Plot_Pads = new wxCheckBox( this, ID_FORCE_PRINT_PAD,
_( "Always Print Pads" ) );
m_Force_Plot_Pads->SetValue( Plot_Pads_All_Layers );
m_Force_Plot_Pads->SetToolTip( _( "Force print/plot pads on ALL layers" ) );
LeftBoxSizer->Add( m_Force_Plot_Pads, 0, wxGROW | wxALL, 1 );
// Options d'impression des textes modules // Options d'impression des textes modules
m_Plot_Text_Value = new wxCheckBox(this, ID_PRINT_VALUE, _("Print Module Value") ); m_Plot_Text_Value = new wxCheckBox( this, ID_PRINT_VALUE, _( "Print Module Value" ) );
m_Plot_Text_Value->SetValue(Sel_Texte_Valeur);
m_Plot_Text_Value->SetValue( Sel_Texte_Valeur );
m_Plot_Text_Value->SetToolTip( m_Plot_Text_Value->SetToolTip(
_("Enable/disable print/plot module value on Silkscreen layers") ); _( "Enable/disable print/plot module value on Silkscreen layers" ) );
LeftBoxSizer->Add(m_Plot_Text_Value, 0, wxGROW|wxALL, 1); LeftBoxSizer->Add( m_Plot_Text_Value, 0, wxGROW | wxALL, 1 );
m_Plot_Text_Ref = new wxCheckBox(this, ID_PRINT_REF, _("Print Module Reference")); m_Plot_Text_Ref = new wxCheckBox( this, ID_PRINT_REF, _( "Print Module Reference" ) );
m_Plot_Text_Ref->SetValue(Sel_Texte_Reference);
m_Plot_Text_Ref->SetValue( Sel_Texte_Reference );
m_Plot_Text_Ref->SetToolTip( m_Plot_Text_Ref->SetToolTip(
_("Enable/disable print/plot module reference on Silkscreen layers") ); _( "Enable/disable print/plot module reference on Silkscreen layers" ) );
LeftBoxSizer->Add(m_Plot_Text_Ref, 0, wxGROW|wxALL, 1); LeftBoxSizer->Add( m_Plot_Text_Ref, 0, wxGROW | wxALL, 1 );
m_Plot_Text_Div = new wxCheckBox(this, ID_PRINT_MODULE_TEXTS, m_Plot_Text_Div = new wxCheckBox( this, ID_PRINT_MODULE_TEXTS,
_("Print other Module texts") ); _( "Print other Module texts" ) );
m_Plot_Text_Div->SetValue(Sel_Texte_Divers);
m_Plot_Text_Div->SetValue( Sel_Texte_Divers );
m_Plot_Text_Div->SetToolTip( m_Plot_Text_Div->SetToolTip(
_("Enable/disable print/plot module field texts on Silkscreen layers") ); _( "Enable/disable print/plot module field texts on Silkscreen layers" ) );
LeftBoxSizer->Add(m_Plot_Text_Div, 0, wxGROW|wxALL, 1); LeftBoxSizer->Add( m_Plot_Text_Div, 0, wxGROW | wxALL, 1 );
m_Plot_Invisible_Text = new wxCheckBox(this, m_Plot_Invisible_Text = new wxCheckBox( this,
ID_FORCE_PRINT_INVISIBLE_TEXT, _("Force Print Invisible Texts") ); ID_FORCE_PRINT_INVISIBLE_TEXT, _(
m_Plot_Invisible_Text->SetValue(Sel_Texte_Invisible); "Force Print Invisible Texts" ) );
m_Plot_Invisible_Text->SetValue( Sel_Texte_Invisible );
m_Plot_Invisible_Text->SetToolTip( m_Plot_Invisible_Text->SetToolTip(
_("Force print/plot module invisible texts on Silkscreen layers") ); _( "Force print/plot module invisible texts on Silkscreen layers" ) );
LeftBoxSizer->Add(m_Plot_Invisible_Text, 0, wxGROW|wxALL, 1); LeftBoxSizer->Add( m_Plot_Invisible_Text, 0, wxGROW | wxALL, 1 );
wxString drillmsg[3] = { _("No Drill mark"), _("Small mark"), _("Real Drill") }; static const wxString drillmsg[3] = { _( "No Drill mark" ), _( "Small mark" ), _( "Real Drill" ) };
m_Drill_Shape_Opt = new wxRadioBox(this, ID_DRILL_SHAPE_OPT, m_Drill_Shape_Opt = new wxRadioBox( this, ID_DRILL_SHAPE_OPT,
_("Pads Drill Opt"), wxDefaultPosition, wxSize(-1,-1), _( "Pads Drill Opt" ), wxDefaultPosition, wxSize( -1, -1 ),
3, drillmsg, 1, wxRA_SPECIFY_COLS); 3, drillmsg, 1, wxRA_SPECIFY_COLS );
m_Drill_Shape_Opt->SetSelection(g_DrillShapeOpt);
MidLeftBoxSizer->Add(m_Drill_Shape_Opt, 0, wxGROW|wxALL, 5);
wxString scalemsg[5] = m_Drill_Shape_Opt->SetSelection( g_DrillShapeOpt );
{ _("Auto scale"), _("Scale 1"), _("Scale 1.5"), _("Scale 2"), _("Scale 3") }; MidLeftBoxSizer->Add( m_Drill_Shape_Opt, 0, wxGROW | wxALL, 5 );
m_Scale_Opt = new wxRadioBox(this, ID_SCALE_OPT,
_("Scale Opt"), wxDefaultPosition, wxSize(-1,-1),
5, scalemsg, 1, wxRA_SPECIFY_COLS);
m_Scale_Opt->SetSelection(g_PlotScaleOpt);
MidLeftBoxSizer->Add(m_Scale_Opt, 0, wxGROW|wxALL, 5);
wxString list_opt3[3] = {_("Line"), _("Filled"), _("Sketch") }; static const wxString scalemsg[5] =
m_PlotModeOpt = new wxRadioBox(this, ID_PLOT_MODE_OPT, _("Plot Mode"), { _( "Auto scale" ), _( "Scale 1" ), _( "Scale 1.5" ), _( "Scale 2" ), _( "Scale 3" ) };
m_Scale_Opt = new wxRadioBox( this, ID_SCALE_OPT,
_( "Scale Opt" ), wxDefaultPosition, wxSize( -1, -1 ),
5, scalemsg, 1, wxRA_SPECIFY_COLS );
m_Scale_Opt->SetSelection( g_PlotScaleOpt );
MidLeftBoxSizer->Add( m_Scale_Opt, 0, wxGROW | wxALL, 5 );
static const wxString list_opt3[3] = { _( "Line" ), _( "Filled" ), _( "Sketch" ) };
m_PlotModeOpt = new wxRadioBox( this, ID_PLOT_MODE_OPT, _( "Plot Mode" ),
wxDefaultPosition, wxDefaultSize, wxDefaultPosition, wxDefaultSize,
3, list_opt3, 1); 3, list_opt3, 1 );
m_PlotModeOpt->SetSelection(Plot_Mode);
MidLeftBoxSizer->Add(m_PlotModeOpt, 0, wxGROW|wxALL, 5);
m_PlotMirorOpt = new wxCheckBox(this, ID_MIROR_OPT, m_PlotModeOpt->SetSelection( Plot_Mode );
_("Plot Mirror")); MidLeftBoxSizer->Add( m_PlotModeOpt, 0, wxGROW | wxALL, 5 );
m_PlotMirorOpt->SetValue(Plot_Set_MIROIR);
MidLeftBoxSizer->Add(m_PlotMirorOpt, 0, wxGROW|wxALL, 5);
m_PlotNoViaOnMaskOpt = new wxCheckBox(this, ID_MASKVIA_OPT, m_PlotMirorOpt = new wxCheckBox( this, ID_MIROR_OPT,
_("Vias on Mask")); _( "Plot Mirror" ) );
m_PlotNoViaOnMaskOpt->SetValue(g_DrawViaOnMaskLayer);
m_PlotMirorOpt->SetValue( Plot_Set_MIROIR );
MidLeftBoxSizer->Add( m_PlotMirorOpt, 0, wxGROW | wxALL, 5 );
m_PlotNoViaOnMaskOpt = new wxCheckBox( this, ID_MASKVIA_OPT,
_( "Vias on Mask" ) );
m_PlotNoViaOnMaskOpt->SetValue( g_DrawViaOnMaskLayer );
m_PlotNoViaOnMaskOpt->SetToolTip( m_PlotNoViaOnMaskOpt->SetToolTip(
_("Print/plot vias on mask layers. They are in this case not protected") ); _( "Print/plot vias on mask layers. They are in this case not protected" ) );
MidLeftBoxSizer->Add(m_PlotNoViaOnMaskOpt, 0, wxGROW|wxALL, 5); MidLeftBoxSizer->Add( m_PlotNoViaOnMaskOpt, 0, wxGROW | wxALL, 5 );
m_HPGL_PlotCenter_Opt = new wxCheckBox( this, ID_PLOT_CENTRE_OPT,
_( "Org = Centre" ) );
m_HPGL_PlotCenter_Opt->SetValue( HPGL_Org_Centre );
m_HPGL_PlotCenter_Opt->SetToolTip( _( "Draw origin ( 0,0 ) in sheet center" ) );
MidLeftBoxSizer->Add( m_HPGL_PlotCenter_Opt, 0, wxGROW | wxALL, 5 );
m_HPGL_PlotCenter_Opt = new wxCheckBox(this, ID_PLOT_CENTRE_OPT,
_("Org = Centre"));
m_HPGL_PlotCenter_Opt->SetValue(HPGL_Org_Centre);
m_HPGL_PlotCenter_Opt->SetToolTip(_("Draw origin ( 0,0 ) in sheet center") );
MidLeftBoxSizer->Add(m_HPGL_PlotCenter_Opt, 0, wxGROW|wxALL, 5);
// Mise a jour des activations des menus: // Mise a jour des activations des menus:
wxCommandEvent event; wxCommandEvent event;
SetCommands(event); SetCommands( event );
GetSizer()->Fit(this); GetSizer()->Fit( this );
GetSizer()->SetSizeHints(this); GetSizer()->SetSizeHints( this );
} }
/***************************************************************/ /***************************************************************/
void WinEDA_PlotFrame::OnQuit(wxCommandEvent& WXUNUSED(event)) void WinEDA_PlotFrame::OnQuit( wxCommandEvent& WXUNUSED (event) )
/***************************************************************/ /***************************************************************/
/* Called by the close button /* Called by the close button
*/ */
{ {
Close(true); // true is to force the frame to close Close( true ); // true is to force the frame to close
} }
/****************************************************/ /****************************************************/
void WinEDA_PlotFrame::OnClose(wxCloseEvent & event) void WinEDA_PlotFrame::OnClose( wxCloseEvent& event )
/****************************************************/ /****************************************************/
/* Called when WinEDA_PlotFrame is closed /* Called when WinEDA_PlotFrame is closed
*/ */
{ {
EndModal(0); EndModal( 0 );
} }
/*********************************************************/ /*********************************************************/
void WinEDA_PlotFrame::CreateDrillFile(wxCommandEvent & event) void WinEDA_PlotFrame::CreateDrillFile( wxCommandEvent& event )
/*********************************************************/ /*********************************************************/
/* Create the board drill file used with gerber documents /* Create the board drill file used with gerber documents
*/ */
{ {
((WinEDA_PcbFrame * )m_Parent)->InstallDrillFrame(event); ( (WinEDA_PcbFrame*) m_Parent )->InstallDrillFrame( event );
} }
/*********************************************************/ /*********************************************************/
void WinEDA_PlotFrame::SetCommands(wxCommandEvent & event) void WinEDA_PlotFrame::SetCommands( wxCommandEvent& event )
/*********************************************************/ /*********************************************************/
/* active ou désactive les différents menus d'option selon le standard choisi /* active ou désactive les différents menus d'option selon le standard choisi
*/ */
{ {
int format; int format;
int format_list[] =
{PLOT_FORMAT_HPGL, PLOT_FORMAT_GERBER, PLOT_FORMAT_POST, PLOT_FORMAT_POST_A4 static const int format_list[] = {
PLOT_FORMAT_HPGL, PLOT_FORMAT_GERBER,
PLOT_FORMAT_POST, PLOT_FORMAT_POST_A4
}; };
format = format_list[m_PlotFormatOpt->GetSelection()]; format = format_list[m_PlotFormatOpt->GetSelection()];
@ -419,72 +479,73 @@ int format_list[] =
case PLOT_FORMAT_POST_A4: case PLOT_FORMAT_POST_A4:
case PLOT_FORMAT_POST: case PLOT_FORMAT_POST:
default: default:
m_Drill_Shape_Opt->Enable(true); m_Drill_Shape_Opt->Enable( true );
m_PlotModeOpt->Enable(true); m_PlotModeOpt->Enable( true );
m_PlotMirorOpt->Enable(true); m_PlotMirorOpt->Enable( true );
m_GerbSpotSizeMinOpt->Enable(false); m_GerbSpotSizeMinOpt->Enable( false );
m_Choice_Plot_Offset->Enable(false); m_Choice_Plot_Offset->Enable( false );
m_LinesWidth->Enable(true); m_LinesWidth->Enable( true );
m_HPGLPenSizeOpt->Enable(false); m_HPGLPenSizeOpt->Enable( false );
m_HPGLPenSpeedOpt->Enable(false); m_HPGLPenSpeedOpt->Enable( false );
m_HPGLPenOverlayOpt->Enable(false); m_HPGLPenOverlayOpt->Enable( false );
m_HPGL_PlotCenter_Opt->Enable(false); m_HPGL_PlotCenter_Opt->Enable( false );
m_Exclude_Edges_Pcb->Enable(false); m_Exclude_Edges_Pcb->Enable( false );
m_Plot_Sheet_Ref->Enable(true); m_Plot_Sheet_Ref->Enable( true );
m_Scale_Opt->Enable(true); m_Scale_Opt->Enable( true );
m_FineAdjustXscaleOpt->Enable(true); m_FineAdjustXscaleOpt->Enable( true );
m_FineAdjustYscaleOpt->Enable(true); m_FineAdjustYscaleOpt->Enable( true );
m_PlotFormat = PLOT_FORMAT_POST; m_PlotFormat = PLOT_FORMAT_POST;
g_ForcePlotPS_On_A4 = (format == PLOT_FORMAT_POST_A4); g_ForcePlotPS_On_A4 = (format == PLOT_FORMAT_POST_A4);
m_Plot_PS_Negative->Enable(true); m_Plot_PS_Negative->Enable( true );
break; break;
case PLOT_FORMAT_GERBER: case PLOT_FORMAT_GERBER:
m_Drill_Shape_Opt->Enable(false); m_Drill_Shape_Opt->Enable( false );
m_PlotModeOpt->Enable(false); m_PlotModeOpt->Enable( false );
m_PlotMirorOpt->Enable(false); m_PlotMirorOpt->Enable( false );
m_GerbSpotSizeMinOpt->Enable(true); m_GerbSpotSizeMinOpt->Enable( true );
m_Choice_Plot_Offset->Enable(true); m_Choice_Plot_Offset->Enable( true );
m_LinesWidth->Enable(true); m_LinesWidth->Enable( true );
m_HPGLPenSizeOpt->Enable(false); m_HPGLPenSizeOpt->Enable( false );
m_HPGLPenSpeedOpt->Enable(false); m_HPGLPenSpeedOpt->Enable( false );
m_HPGLPenOverlayOpt->Enable(false); m_HPGLPenOverlayOpt->Enable( false );
m_HPGL_PlotCenter_Opt->Enable(false); m_HPGL_PlotCenter_Opt->Enable( false );
m_Exclude_Edges_Pcb->Enable(true); m_Exclude_Edges_Pcb->Enable( true );
m_Plot_Sheet_Ref->Enable(false); m_Plot_Sheet_Ref->Enable( false );
m_Scale_Opt->Enable(false); m_Scale_Opt->Enable( false );
m_FineAdjustXscaleOpt->Enable(false); m_FineAdjustXscaleOpt->Enable( false );
m_FineAdjustYscaleOpt->Enable(false); m_FineAdjustYscaleOpt->Enable( false );
m_PlotFormat = PLOT_FORMAT_GERBER; m_PlotFormat = PLOT_FORMAT_GERBER;
m_Plot_PS_Negative->Enable(false); m_Plot_PS_Negative->Enable( false );
break; break;
case PLOT_FORMAT_HPGL: case PLOT_FORMAT_HPGL:
m_PlotMirorOpt->Enable(true); m_PlotMirorOpt->Enable( true );
m_Drill_Shape_Opt->Enable(false); m_Drill_Shape_Opt->Enable( false );
m_PlotModeOpt->Enable(true); m_PlotModeOpt->Enable( true );
m_GerbSpotSizeMinOpt->Enable(false); m_GerbSpotSizeMinOpt->Enable( false );
m_Choice_Plot_Offset->Enable(false); m_Choice_Plot_Offset->Enable( false );
m_LinesWidth->Enable(false); m_LinesWidth->Enable( false );
m_HPGLPenSizeOpt->Enable(true); m_HPGLPenSizeOpt->Enable( true );
m_HPGLPenSpeedOpt->Enable(true); m_HPGLPenSpeedOpt->Enable( true );
m_HPGLPenOverlayOpt->Enable(true); m_HPGLPenOverlayOpt->Enable( true );
m_HPGL_PlotCenter_Opt->Enable(true); m_HPGL_PlotCenter_Opt->Enable( true );
m_Exclude_Edges_Pcb->Enable(false); m_Exclude_Edges_Pcb->Enable( false );
m_Plot_Sheet_Ref->Enable(true); m_Plot_Sheet_Ref->Enable( true );
m_Scale_Opt->Enable(true); m_Scale_Opt->Enable( true );
m_FineAdjustXscaleOpt->Enable(false); m_FineAdjustXscaleOpt->Enable( false );
m_FineAdjustYscaleOpt->Enable(false); m_FineAdjustYscaleOpt->Enable( false );
m_PlotFormat = PLOT_FORMAT_HPGL; m_PlotFormat = PLOT_FORMAT_HPGL;
m_Plot_PS_Negative->Enable(false); m_Plot_PS_Negative->Enable( false );
break; break;
} }
format_plot = m_PlotFormat; format_plot = m_PlotFormat;
} }
/*********************************************************/ /*********************************************************/
void WinEDA_PlotFrame::SaveOptPlot(wxCommandEvent & event) void WinEDA_PlotFrame::SaveOptPlot( wxCommandEvent& event )
/*********************************************************/ /*********************************************************/
{ {
g_Exclude_Edges_Pcb = m_Exclude_Edges_Pcb->GetValue(); g_Exclude_Edges_Pcb = m_Exclude_Edges_Pcb->GetValue();
@ -523,9 +584,9 @@ void WinEDA_PlotFrame::SaveOptPlot(wxCommandEvent & event)
if( m_Parent->m_Parent->m_EDA_Config ) if( m_Parent->m_Parent->m_EDA_Config )
{ {
m_Parent->m_Parent->m_EDA_Config->Write( EDGELAYER_GERBER_OPT_KEY, g_Exclude_Edges_Pcb); m_Parent->m_Parent->m_EDA_Config->Write( EDGELAYER_GERBER_OPT_KEY, g_Exclude_Edges_Pcb );
m_Parent->m_Parent->m_EDA_Config->Write( PLOT_XFINESCALE_ADJ_KEY, m_XScaleAdjust); m_Parent->m_Parent->m_EDA_Config->Write( PLOT_XFINESCALE_ADJ_KEY, m_XScaleAdjust );
m_Parent->m_Parent->m_EDA_Config->Write( PLOT_YFINESCALE_ADJ_KEY, m_YScaleAdjust); m_Parent->m_Parent->m_EDA_Config->Write( PLOT_YFINESCALE_ADJ_KEY, m_YScaleAdjust );
} }
g_Plot_PS_Negative = m_Plot_PS_Negative->GetValue(); g_Plot_PS_Negative = m_Plot_PS_Negative->GetValue();
@ -533,14 +594,16 @@ void WinEDA_PlotFrame::SaveOptPlot(wxCommandEvent & event)
/***************************************************/ /***************************************************/
void WinEDA_PlotFrame::Plot(wxCommandEvent & event) void WinEDA_PlotFrame::Plot( wxCommandEvent& event )
/***************************************************/ /***************************************************/
{ {
int layer_to_plot; int layer_to_plot;
wxString FullFileName, BaseFileName; wxString FullFileName, BaseFileName;
wxString ext; wxString ext;
SaveOptPlot(event); BOARD* board = m_Parent->m_Pcb;
SaveOptPlot( event );
switch( g_PlotScaleOpt ) switch( g_PlotScaleOpt )
{ {
@ -565,20 +628,20 @@ wxString ext;
Scale_Y *= m_YScaleAdjust; Scale_Y *= m_YScaleAdjust;
BaseFileName = m_Parent->GetScreen()->m_FileName; BaseFileName = m_Parent->GetScreen()->m_FileName;
ChangeFileNameExt( BaseFileName, wxT("-") ); ChangeFileNameExt( BaseFileName, wxT( "-" ) );
switch( m_PlotFormat) switch( m_PlotFormat )
{ {
case PLOT_FORMAT_POST: case PLOT_FORMAT_POST:
ext = wxT(".ps"); ext = wxT( ".ps" );
break; break;
case PLOT_FORMAT_GERBER: case PLOT_FORMAT_GERBER:
ext = wxT(".pho"); ext = wxT( ".pho" );
break; break;
case PLOT_FORMAT_HPGL: case PLOT_FORMAT_HPGL:
ext = wxT(".plt"); ext = wxT( ".plt" );
break; break;
} }
@ -590,33 +653,36 @@ wxString ext;
if( m_BoxSelecLayer[layer_to_plot]->GetValue() ) if( m_BoxSelecLayer[layer_to_plot]->GetValue() )
{ {
s_SelectedLayers |= mask; s_SelectedLayers |= mask;
// Calcul du nom du fichier // Calcul du nom du fichier
FullFileName = BaseFileName + ReturnPcbLayerName(layer_to_plot, true) + ext; FullFileName = BaseFileName + board->GetLayerName( layer_to_plot ) + ext;
switch ( m_PlotFormat)
switch( m_PlotFormat )
{ {
case PLOT_FORMAT_POST: case PLOT_FORMAT_POST:
m_Parent->Genere_PS(FullFileName, layer_to_plot); m_Parent->Genere_PS( FullFileName, layer_to_plot );
break; break;
case PLOT_FORMAT_GERBER: case PLOT_FORMAT_GERBER:
m_Parent->Genere_GERBER(FullFileName, layer_to_plot, s_PlotOriginIsAuxAxis); m_Parent->Genere_GERBER( FullFileName, layer_to_plot, s_PlotOriginIsAuxAxis );
break; break;
case PLOT_FORMAT_HPGL: case PLOT_FORMAT_HPGL:
m_Parent->Genere_HPGL(FullFileName, layer_to_plot); m_Parent->Genere_HPGL( FullFileName, layer_to_plot );
break; break;
} }
} }
} }
// Close(true); // Close(true);
} }
/**************************************************************/ /**************************************************************/
void WinEDA_BasePcbFrame::ToPlotter(wxCommandEvent& event) void WinEDA_BasePcbFrame::ToPlotter( wxCommandEvent& event )
/***************************************************************/ /***************************************************************/
{ {
WinEDA_PlotFrame * frame = new WinEDA_PlotFrame(this); WinEDA_PlotFrame* frame = new WinEDA_PlotFrame( this );
frame->ShowModal(); frame->Destroy(); frame->ShowModal(); frame->Destroy();
} }

12
pcbnew/pcbtexte.cpp
View File

@ -90,8 +90,11 @@ WinEDA_TextPCBPropertiesFrame::WinEDA_TextPCBPropertiesFrame( WinEDA_PcbFrame* p
/************************************************************************************/ /************************************************************************************/
{ {
wxButton* Button; wxButton* Button;
BOARD* board = parent->m_Pcb;
m_Parent = parent; m_Parent = parent;
SetFont( *g_DialogFont ); SetFont( *g_DialogFont );
m_DC = DC; m_DC = DC;
Centre(); Centre();
@ -139,16 +142,17 @@ WinEDA_TextPCBPropertiesFrame::WinEDA_TextPCBPropertiesFrame( WinEDA_PcbFrame* p
wxDefaultPosition, wxDefaultSize ); wxDefaultPosition, wxDefaultSize );
MiddleBoxSizer->Add( m_SelLayerBox, 0, wxGROW | wxALL, 5 ); MiddleBoxSizer->Add( m_SelLayerBox, 0, wxGROW | wxALL, 5 );
int ii; for( int layer=0; layer<NB_LAYERS; ++layer )
for( ii = 0; ii < NB_LAYERS; ii++ )
{ {
m_SelLayerBox->Append( ReturnPcbLayerName( ii ) ); m_SelLayerBox->Append( board->GetLayerName( layer ) );
} }
m_SelLayerBox->SetSelection( TextPCB->GetLayer() ); 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" ), m_Orient = new wxRadioBox( this, -1, _( "Orientation" ),
wxDefaultPosition, wxSize( -1, -1 ), 4, orient_msg, wxDefaultPosition, wxSize( -1, -1 ), 4, orient_msg,
1, wxRA_SPECIFY_COLS ); 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 : */ /* LOCATE.CPP : */
/****************/ /****************/
MODULE* ReturnModule( BOARD* Pcb, const wxString& name );
/* Recherche d'une empreinte par son nom */ /* 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 */ /* Recherche d'un pad par son nom, pour le module Module */
TRACK* Locate_Via( BOARD* Pcb, const wxPoint& pos, int layer = -1 ); TRACK* Locate_Via( BOARD* Pcb, const wxPoint& pos, int layer = -1 );
@ -417,7 +413,7 @@ MODULE* ListAndSelectModuleName( COMMAND* Cmd );
/*****************/ /*****************/
/* SET_COLOR.CPP */ /* SET_COLOR.CPP */
/*****************/ /*****************/
void DisplayColorSetupFrame( WinEDA_DrawFrame* parent, void DisplayColorSetupFrame( WinEDA_PcbFrame* parent,
const wxPoint& framepos ); const wxPoint& framepos );

6
pcbnew/sel_layer.cpp
View File

@ -101,6 +101,7 @@ WinEDA_SelLayerFrame::WinEDA_SelLayerFrame( WinEDA_BasePcbFrame* parent,
* to the right of that radiobox. * to the right of that radiobox.
*/ */
{ {
BOARD* board = parent->m_Pcb;
wxButton* Button; wxButton* Button;
int ii; int ii;
wxString LayerList[NB_LAYERS + 1]; // One extra element for "(Deselect)" radiobutton 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) ) if( (max_layer >= 0) && (max_layer < ii) )
break; break;
LayerList[LayerCount] = ReturnPcbLayerName( ii ); LayerList[LayerCount] = board->GetLayerName( ii );
if( ii == default_layer ) if( ii == default_layer )
LayerSelect = LayerCount; LayerSelect = LayerCount;
@ -264,6 +265,7 @@ WinEDA_SelLayerPairFrame::WinEDA_SelLayerPairFrame( WinEDA_BasePcbFrame* parent
wxSize( 470, 250 ), DIALOG_STYLE ) wxSize( 470, 250 ), DIALOG_STYLE )
/*******************************************************************************/ /*******************************************************************************/
{ {
BOARD* board = parent->m_Pcb;
wxButton* Button; wxButton* Button;
int ii, LayerCount; int ii, LayerCount;
wxString LayerList[NB_COPPER_LAYERS]; wxString LayerList[NB_COPPER_LAYERS];
@ -281,7 +283,7 @@ WinEDA_SelLayerPairFrame::WinEDA_SelLayerPairFrame( WinEDA_BasePcbFrame* parent
m_LayerId[ii] = 0; m_LayerId[ii] = 0;
if( (g_TabOneLayerMask[ii] & Masque_Layer) ) if( (g_TabOneLayerMask[ii] & Masque_Layer) )
{ {
LayerList[LayerCount] = ReturnPcbLayerName( ii ); LayerList[LayerCount] = board->GetLayerName( ii );
if( ii == screen->m_Route_Layer_TOP ) if( ii == screen->m_Route_Layer_TOP )
LayerTopSelect = LayerCount; LayerTopSelect = LayerCount;
if( ii == screen->m_Route_Layer_BOTTOM ) 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 ) const wxPoint& framepos )
/*****************************************************/ /*****************************************************/
{ {
@ -72,7 +72,7 @@ WinEDA_SetColorsFrame::WinEDA_SetColorsFrame()
// Standard Constructor // Standard Constructor
WinEDA_SetColorsFrame::WinEDA_SetColorsFrame( WinEDA_DrawFrame* parent, WinEDA_SetColorsFrame::WinEDA_SetColorsFrame( WinEDA_PcbFrame* parent,
const wxPoint& framepos ) const wxPoint& framepos )
{ {
m_Parent = parent; m_Parent = parent;
@ -225,7 +225,7 @@ void WinEDA_SetColorsFrame::CreateControls()
if( laytool_list[lyr]->m_Title == wxT( "*" ) ) if( laytool_list[lyr]->m_Title == wxT( "*" ) )
msg = g_ViaType_Name[laytool_list[lyr]->m_LayerNumber]; msg = g_ViaType_Name[laytool_list[lyr]->m_LayerNumber];
else else
msg = ReturnPcbLayerName( laytool_list[lyr]->m_LayerNumber ); msg = m_Parent->m_Pcb->GetLayerName( laytool_list[lyr]->m_LayerNumber );
} }
else else
msg = wxGetTranslation( laytool_list[lyr]->m_Title.GetData() ); msg = wxGetTranslation( laytool_list[lyr]->m_Title.GetData() );

4
pcbnew/set_color.h
View File

@ -526,7 +526,7 @@ private:
DECLARE_DYNAMIC_CLASS( WinEDA_SetColorsFrame ) DECLARE_DYNAMIC_CLASS( WinEDA_SetColorsFrame )
DECLARE_EVENT_TABLE() DECLARE_EVENT_TABLE()
WinEDA_DrawFrame* m_Parent; WinEDA_PcbFrame* m_Parent;
wxBoxSizer* OuterBoxSizer; wxBoxSizer* OuterBoxSizer;
wxBoxSizer* MainBoxSizer; wxBoxSizer* MainBoxSizer;
wxFlexGridSizer* FlexColumnBoxSizer; wxFlexGridSizer* FlexColumnBoxSizer;
@ -566,7 +566,7 @@ private:
public: public:
// Constructors and destructor // Constructors and destructor
WinEDA_SetColorsFrame(); WinEDA_SetColorsFrame();
WinEDA_SetColorsFrame( WinEDA_DrawFrame* parent, const wxPoint& framepos ); WinEDA_SetColorsFrame( WinEDA_PcbFrame* parent, const wxPoint& framepos );
~WinEDA_SetColorsFrame(); ~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]; 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() ); layer->properties.push_back( PROPERTY() );
PROPERTY* property = &layer->properties.back(); PROPERTY* property = &layer->properties.back();
property->name = "index"; 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 ) wxDefaultSize, wxDEFAULT_DIALOG_STYLE|MAYBE_RESIZE_BORDER )
/*************************************************************************/ /*************************************************************************/
{ {
BOARD* board = parent->m_Pcb;
OuterBoxSizer = NULL; OuterBoxSizer = NULL;
MainBoxSizer = NULL; MainBoxSizer = NULL;
FlexColumnBoxSizer = 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) // 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); 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) // 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.) // strings to be truncated after different layers are selected.)
if( ii == 0 ) 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(); goodSize = text->GetSize();
for( int jj = 1; jj < NB_LAYERS; jj++ ) for( int jj = 1; jj < NB_LAYERS; jj++ )
{ {
text->SetLabel( ReturnPcbLayerName( jj ) ); text->SetLabel( board->GetLayerName( jj ) );
if( goodSize.x < text->GetSize().x ) if( goodSize.x < text->GetSize().x )
goodSize.x = text->GetSize().x; goodSize.x = text->GetSize().x;
} }
@ -280,7 +283,7 @@ void WinEDA_SwapLayerFrame::Sel_Layer( wxCommandEvent& event )
} }
else 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 // Change the text color to fushia (to highlight
// that this layer *is* being swapped) // that this layer *is* being swapped)
layer_list[ii]->SetForegroundColour( wxColour(255, 0, 128) ); 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) ) 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] ); msg = AddHotkeyName( msg, s_Board_Editor_Hokeys_Descr, HK_SwitchLayer[ii] );
m_SelLayerBox->Append( msg ); m_SelLayerBox->Append( msg );
m_SelLayerBox->SetClientData( jj, (void*) ii ); m_SelLayerBox->SetClientData( jj, (void*) ii );

555
share/wxprint.cpp
View File

@ -55,7 +55,7 @@ extern float Scale_X, Scale_Y;
static long s_SelectedLayers = CUIVRE_LAYER | CMP_LAYER | static long s_SelectedLayers = CUIVRE_LAYER | CMP_LAYER |
SILKSCREEN_LAYER_CMP | SILKSCREEN_LAYER_CU; SILKSCREEN_LAYER_CMP | SILKSCREEN_LAYER_CU;
static double s_ScaleList[] = static double s_ScaleList[] =
{ 0, 0.5, 0.7, 0.999, 1.0, 1.4, 2.0, 3.0, 4.0 }; { 0, 0.5, 0.7, 0.999, 1.0, 1.4, 2.0, 3.0, 4.0 };
#endif #endif
#include "protos.h" #include "protos.h"
@ -70,7 +70,7 @@ static double s_ScaleList[] =
#define WIDTH_MIN_VALUE 1 #define WIDTH_MIN_VALUE 1
// static print data and page setup data, to remember settings during the session // static print data and page setup data, to remember settings during the session
static wxPrintData * g_PrintData; static wxPrintData* g_PrintData;
// Variables locales // Variables locales
static int s_PrintPenMinWidth = 6; /* Minimum pen width (in internal units) for printing */ static int s_PrintPenMinWidth = 6; /* Minimum pen width (in internal units) for printing */
@ -82,76 +82,82 @@ static int s_Scale_Select = 3; // default selected scale = ScaleList[3] = 1
static bool s_PrintMirror; static bool s_PrintMirror;
static bool s_Print_Sheet_Ref = TRUE; static bool s_Print_Sheet_Ref = TRUE;
/****************************************************************/ /****************************************************************/
/* frame de Preparation de l'impression (options, selections... */ /* frame de Preparation de l'impression (options, selections... */
/****************************************************************/ /****************************************************************/
#include "dialog_print.cpp" #include "dialog_print.cpp"
/***************************/ /***************************/
/* Gestion de l'impression */ /* Gestion de l'impression */
/***************************/ /***************************/
class EDA_Printout: public wxPrintout class EDA_Printout : public wxPrintout
{ {
public: public:
bool m_Print_Sheet_Ref; bool m_Print_Sheet_Ref;
public: public:
WinEDA_DrawFrame * m_Parent; WinEDA_DrawFrame* m_Parent;
WinEDA_PrintFrame * m_PrintFrame; WinEDA_PrintFrame* m_PrintFrame;
EDA_Printout(WinEDA_PrintFrame * print_frame, WinEDA_DrawFrame * parent, const wxString & title, bool print_ref): EDA_Printout( WinEDA_PrintFrame * print_frame,
wxPrintout(title) WinEDA_DrawFrame * parent,
{ const wxString &title,
bool print_ref ) :
wxPrintout( title ) {
m_PrintFrame = print_frame; m_PrintFrame = print_frame;
m_Parent = parent; m_Parent = parent;
s_PrintMaskLayer = 0xFFFFFFFF; s_PrintMaskLayer = 0xFFFFFFFF;
m_Print_Sheet_Ref = print_ref; m_Print_Sheet_Ref = print_ref;
} }
bool OnPrintPage(int page); bool OnPrintPage( int page );
bool HasPage(int page); bool HasPage( int page );
bool OnBeginDocument(int startPage, int endPage); bool OnBeginDocument( int startPage, int endPage );
void GetPageInfo(int *minPage, int *maxPage, int *selPageFrom, int *selPageTo); void GetPageInfo( int* minPage, int* maxPage, int* selPageFrom, int* selPageTo );
void DrawPage(); void DrawPage();
}; };
/*******************************************************/ /*******************************************************/
void WinEDA_DrawFrame::ToPrinter(wxCommandEvent& event) void WinEDA_DrawFrame::ToPrinter( wxCommandEvent& event )
/*******************************************************/ /*******************************************************/
/* Prepare les structures de donn<6E>es de gestion de l'impression /* Prepare les structures de donn<6E>es de gestion de l'impression
et affiche la fenetre de dialogue de gestion de l'impression des feuilles * et affiche la fenetre de dialogue de gestion de l'impression des feuilles
*/ */
{ {
wxPoint pos = GetPosition(); wxPoint pos = GetPosition();
bool PrinterError = FALSE; bool PrinterError = FALSE;
// Stop the pending comand (if any...) // Stop the pending comand (if any...)
if( DrawPanel->ManageCurseur && DrawPanel->ForceCloseManageCurseur ) if( DrawPanel->ManageCurseur && DrawPanel->ForceCloseManageCurseur )
{ {
wxClientDC dc(DrawPanel); wxClientDC dc( DrawPanel );
DrawPanel->PrepareDC(dc);
DrawPanel->ForceCloseManageCurseur(DrawPanel, &dc);
}
SetToolID(0, wxCURSOR_ARROW,wxEmptyString);
if ( g_PrintData == NULL ) // First print DrawPanel->PrepareDC( dc );
DrawPanel->ForceCloseManageCurseur( DrawPanel, &dc );
}
SetToolID( 0, wxCURSOR_ARROW, wxEmptyString );
if( g_PrintData == NULL ) // First print
{ {
g_PrintData = new wxPrintData(); g_PrintData = new wxPrintData();
if ( ! g_PrintData->Ok() )
if( !g_PrintData->Ok() )
{ {
PrinterError = TRUE; PrinterError = TRUE;
DisplayError( this, _("Error Init Printer info") ); DisplayError( this, _( "Error Init Printer info" ) );
} }
g_PrintData->SetQuality(wxPRINT_QUALITY_HIGH); // Default resolution = HIGHT; g_PrintData->SetQuality( wxPRINT_QUALITY_HIGH ); // Default resolution = HIGHT;
g_PrintData->SetOrientation(DEFAULT_ORIENTATION_PAPER); g_PrintData->SetOrientation( DEFAULT_ORIENTATION_PAPER );
} }
pos.x += 10; pos.y += 10; pos.x += 10; pos.y += 10;
WinEDA_PrintFrame * frame = new WinEDA_PrintFrame(this); WinEDA_PrintFrame* frame = new WinEDA_PrintFrame( this );
frame->ShowModal(); frame->Destroy(); frame->ShowModal(); frame->Destroy();
#ifdef EESCHEMA #ifdef EESCHEMA
g_PrintFillMask = 0; g_PrintFillMask = 0;
@ -164,220 +170,246 @@ void WinEDA_PrintFrame::SetOthersDatas()
/*******************************************/ /*******************************************/
{ {
#ifndef PCBNEW #ifndef PCBNEW
m_Print_Mirror->Enable(false); m_Print_Mirror->Enable( false );
#endif #endif
m_FineAdjustXscaleOpt->SetToolTip(_("Set X scale adjust for exact scale plotting")); m_FineAdjustXscaleOpt->SetToolTip( _( "Set X scale adjust for exact scale plotting" ) );
m_FineAdjustYscaleOpt->SetToolTip(_("Set Y scale adjust for exact scale plotting")); m_FineAdjustYscaleOpt->SetToolTip( _( "Set Y scale adjust for exact scale plotting" ) );
if ( s_Print_Black_and_White ) m_ColorOption->SetSelection(1); if( s_Print_Black_and_White )
m_ColorOption->SetSelection( 1 );
#ifdef PCBNEW #ifdef PCBNEW
m_PagesOptionEeschema->Show(false); m_PagesOptionEeschema->Show( false );
m_PagesOption = m_PagesOptionPcb; m_PagesOption = m_PagesOptionPcb;
/* Create layer list */ /* Create layer list */
int mask = 1, ii; int mask = 1, ii;
for ( ii = 0; ii < NB_LAYERS; ii++, mask <<= 1 ) for( ii = 0; ii < NB_LAYERS; ii++, mask <<= 1 )
{ {
m_BoxSelecLayer[ii] = new wxCheckBox(this, -1, m_BoxSelecLayer[ii] = new wxCheckBox( this, -1,
ReturnPcbLayerName(ii)); #if defined(PCBNEW)
if ( mask & s_SelectedLayers) m_BoxSelecLayer[ii]->SetValue(TRUE); ((WinEDA_PcbFrame*)m_Parent)->m_Pcb->GetLayerName(ii) );
if ( ii < 16 ) #else
m_CopperLayersBoxSizer->Add(m_BoxSelecLayer[ii], ReturnLayerName( ii ) );
wxGROW|wxLEFT|wxRIGHT|wxTOP|wxADJUST_MINSIZE); #endif
if( mask & s_SelectedLayers )
m_BoxSelecLayer[ii]->SetValue( TRUE );
if( ii < 16 )
m_CopperLayersBoxSizer->Add( m_BoxSelecLayer[ii],
wxGROW | wxLEFT | wxRIGHT | wxTOP | wxADJUST_MINSIZE );
else else
m_TechLayersBoxSizer->Add(m_BoxSelecLayer[ii], m_TechLayersBoxSizer->Add( m_BoxSelecLayer[ii],
wxGROW|wxLEFT|wxRIGHT|wxTOP|wxADJUST_MINSIZE); wxGROW | wxLEFT | wxRIGHT | wxTOP | wxADJUST_MINSIZE );
}
// Read the scale adjust option
if ( m_Parent->m_Parent->m_EDA_Config )
{
m_Parent->m_Parent->m_EDA_Config->Read( wxT("PrintXFineScaleAdj"), &m_XScaleAdjust);
m_Parent->m_Parent->m_EDA_Config->Read( wxT("PrintYFineScaleAdj"), &m_YScaleAdjust);
m_Parent->m_Parent->m_EDA_Config->Read( wxT("PrintScale"), &s_Scale_Select);
} }
m_ScaleOption->SetSelection(s_Scale_Select); // Read the scale adjust option
if( m_Parent->m_Parent->m_EDA_Config )
{
m_Parent->m_Parent->m_EDA_Config->Read( wxT( "PrintXFineScaleAdj" ), &m_XScaleAdjust );
m_Parent->m_Parent->m_EDA_Config->Read( wxT( "PrintYFineScaleAdj" ), &m_YScaleAdjust );
m_Parent->m_Parent->m_EDA_Config->Read( wxT( "PrintScale" ), &s_Scale_Select );
}
m_ScaleOption->SetSelection( s_Scale_Select );
// Create scale adjust option // Create scale adjust option
wxString msg; wxString msg;
msg.Printf(wxT("%lf"), m_XScaleAdjust); msg.Printf( wxT( "%lf" ), m_XScaleAdjust );
m_FineAdjustXscaleOpt->SetValue(msg); m_FineAdjustXscaleOpt->SetValue( msg );
msg.Printf(wxT("%lf"), m_YScaleAdjust); msg.Printf( wxT( "%lf" ), m_YScaleAdjust );
m_FineAdjustYscaleOpt->SetValue(msg); m_FineAdjustYscaleOpt->SetValue( msg );
#else #else
m_PagesOption = m_PagesOptionEeschema; m_PagesOption = m_PagesOptionEeschema;
m_PagesOptionPcb->Show(false); m_PagesOptionPcb->Show( false );
m_ScaleOption->Show(false); m_ScaleOption->Show( false );
m_FineAdjustXscaleTitle->Show(false); m_FineAdjustXscaleTitle->Show( false );
m_FineAdjustXscaleOpt->Show(false); m_FineAdjustXscaleOpt->Show( false );
m_FineAdjustYscaleTitle->Show(false); m_FineAdjustYscaleTitle->Show( false );
m_FineAdjustYscaleOpt->Show(false); m_FineAdjustYscaleOpt->Show( false );
#endif #endif
} }
/**********************************************************/ /**********************************************************/
int WinEDA_PrintFrame::SetLayerMaskFromListSelection() int WinEDA_PrintFrame::SetLayerMaskFromListSelection()
/**********************************************************/ /**********************************************************/
{ {
int page_count; int page_count;
s_PrintMaskLayer = 0; s_PrintMaskLayer = 0;
#ifdef PCBNEW #ifdef PCBNEW
int ii; int ii;
for ( ii = 0, page_count = 0; ii < NB_LAYERS; ii++ ) for( ii = 0, page_count = 0; ii < NB_LAYERS; ii++ )
{ {
if ( m_BoxSelecLayer[ii]->IsChecked() ) if( m_BoxSelecLayer[ii]->IsChecked() )
{ {
page_count++; page_count++;
s_PrintMaskLayer |= 1 << ii; s_PrintMaskLayer |= 1 << ii;
} }
} }
#else #else
page_count = 1; page_count = 1;
#endif #endif
return page_count; return page_count;
} }
/************************************************************/ /************************************************************/
void WinEDA_PrintFrame::SetColorOrBlack(wxCommandEvent& event) void WinEDA_PrintFrame::SetColorOrBlack( wxCommandEvent& event )
/************************************************************/ /************************************************************/
{ {
s_Print_Black_and_White = m_ColorOption->GetSelection(); s_Print_Black_and_White = m_ColorOption->GetSelection();
} }
/****************************************************/ /****************************************************/
void WinEDA_PrintFrame::OnClosePrintDialog() void WinEDA_PrintFrame::OnClosePrintDialog()
/****************************************************/ /****************************************************/
/* called when WinEDA_PrintFrame is closed /* called when WinEDA_PrintFrame is closed
*/ */
{ {
wxConfig * Config = m_Parent->m_Parent->m_EDA_Config; wxConfig* Config = m_Parent->m_Parent->m_EDA_Config;
if ( Config )
if( Config )
{ {
Config->Write(wxT("PrintPenWidth"), s_PrintPenMinWidth); Config->Write( wxT( "PrintPenWidth" ), s_PrintPenMinWidth );
} }
if ( m_FineAdjustXscaleOpt ) if( m_FineAdjustXscaleOpt )
m_FineAdjustXscaleOpt->GetValue().ToDouble(&m_XScaleAdjust); m_FineAdjustXscaleOpt->GetValue().ToDouble( &m_XScaleAdjust );
if ( m_FineAdjustYscaleOpt ) if( m_FineAdjustYscaleOpt )
m_FineAdjustYscaleOpt->GetValue().ToDouble(&m_YScaleAdjust); m_FineAdjustYscaleOpt->GetValue().ToDouble( &m_YScaleAdjust );
SetPenWidth(); SetPenWidth();
#ifdef PCBNEW #ifdef PCBNEW
if ( Config ) if( Config )
{ {
Config->Write(wxT("PrintXFineScaleAdj"), m_XScaleAdjust); Config->Write( wxT( "PrintXFineScaleAdj" ), m_XScaleAdjust );
Config->Write(wxT("PrintYFineScaleAdj"), m_YScaleAdjust); Config->Write( wxT( "PrintYFineScaleAdj" ), m_YScaleAdjust );
Config->Write(wxT("PrintScale"), s_Scale_Select); Config->Write( wxT( "PrintScale" ), s_Scale_Select );
} }
#endif #endif
EndModal(0); EndModal( 0 );
} }
/************************************************/ /************************************************/
wxString WinEDA_PrintFrame::BuildPrintTitle() wxString WinEDA_PrintFrame::BuildPrintTitle()
/************************************************/ /************************************************/
/* return a valid filename to create a print file
*/
{
wxString name, ext;
wxFileName::SplitPath(m_Parent->GetScreen()->m_FileName, /* return a valid filename to create a print file
(wxString*) NULL, & name, & ext); */
name += wxT("-") + ext; {
wxString name, ext;
wxFileName::SplitPath( m_Parent->GetScreen()->m_FileName,
(wxString*) NULL, &name, &ext );
name += wxT( "-" ) + ext;
return name; return name;
} }
/******************************************************/ /******************************************************/
void WinEDA_PrintFrame::SetScale(wxCommandEvent& event) void WinEDA_PrintFrame::SetScale( wxCommandEvent& event )
/******************************************************/ /******************************************************/
{ {
#ifdef PCBNEW #ifdef PCBNEW
s_Scale_Select = m_ScaleOption->GetSelection(); s_Scale_Select = m_ScaleOption->GetSelection();
Scale_X = Scale_Y = s_ScaleList[s_Scale_Select]; Scale_X = Scale_Y = s_ScaleList[s_Scale_Select];
if ( m_FineAdjustXscaleOpt ) if( m_FineAdjustXscaleOpt )
m_FineAdjustXscaleOpt->GetValue().ToDouble(&m_XScaleAdjust); m_FineAdjustXscaleOpt->GetValue().ToDouble( &m_XScaleAdjust );
if ( m_FineAdjustYscaleOpt ) if( m_FineAdjustYscaleOpt )
m_FineAdjustYscaleOpt->GetValue().ToDouble(&m_YScaleAdjust); m_FineAdjustYscaleOpt->GetValue().ToDouble( &m_YScaleAdjust );
Scale_X *= m_XScaleAdjust; Scale_X *= m_XScaleAdjust;
Scale_Y *= m_YScaleAdjust; Scale_Y *= m_YScaleAdjust;
#endif #endif
} }
/****************************************/ /****************************************/
void WinEDA_PrintFrame::SetPenWidth() void WinEDA_PrintFrame::SetPenWidth()
/****************************************/ /****************************************/
/* Get the new pen width value, and verify min et max value /* Get the new pen width value, and verify min et max value
NOTE: s_PrintPenMinWidth is in internal units * NOTE: s_PrintPenMinWidth is in internal units
*/ */
{ {
s_PrintPenMinWidth = m_DialogPenWidth->GetValue(); s_PrintPenMinWidth = m_DialogPenWidth->GetValue();
if ( s_PrintPenMinWidth > WIDTH_MAX_VALUE ) if( s_PrintPenMinWidth > WIDTH_MAX_VALUE )
{ {
s_PrintPenMinWidth = WIDTH_MAX_VALUE; s_PrintPenMinWidth = WIDTH_MAX_VALUE;
} }
if ( s_PrintPenMinWidth < WIDTH_MIN_VALUE ) if( s_PrintPenMinWidth < WIDTH_MIN_VALUE )
{ {
s_PrintPenMinWidth = WIDTH_MIN_VALUE; s_PrintPenMinWidth = WIDTH_MIN_VALUE;
} }
m_DialogPenWidth->SetValue(s_PrintPenMinWidth); m_DialogPenWidth->SetValue( s_PrintPenMinWidth );
} }
/**********************************************************/ /**********************************************************/
void WinEDA_PrintFrame::OnPrintSetup(wxCommandEvent& event) void WinEDA_PrintFrame::OnPrintSetup( wxCommandEvent& event )
/**********************************************************/ /**********************************************************/
/* Open a dialog box for printer setup (printer options, page size ...) /* Open a dialog box for printer setup (printer options, page size ...)
*/ */
{ {
wxPrintDialogData printDialogData(*g_PrintData); wxPrintDialogData printDialogData( * g_PrintData );
if ( printDialogData.Ok() )
if( printDialogData.Ok() )
{ {
wxPrintDialog printerDialog(this, & printDialogData); wxPrintDialog printerDialog( this,& printDialogData );
printerDialog.ShowModal(); printerDialog.ShowModal();
* g_PrintData = printerDialog.GetPrintDialogData().GetPrintData(); *g_PrintData = printerDialog.GetPrintDialogData().GetPrintData();
} }
else DisplayError(this, _("Printer Problem!") ); else
DisplayError( this, _( "Printer Problem!" ) );
} }
/************************************************************/ /************************************************************/
void WinEDA_PrintFrame::OnPrintPreview(wxCommandEvent& event) void WinEDA_PrintFrame::OnPrintPreview( wxCommandEvent& event )
/************************************************************/ /************************************************************/
/* Open and display a previewer frame for printing
*/
{
wxSize WSize;
wxPoint WPos;
int x, y;
bool print_ref = TRUE;
SetScale(event); /* Open and display a previewer frame for printing
*/
{
wxSize WSize;
wxPoint WPos;
int x, y;
bool print_ref = TRUE;
SetScale( event );
SetPenWidth(); SetPenWidth();
if ( m_PagesOption ) if( m_PagesOption )
s_OptionPrintPage = m_PagesOption->GetSelection(); s_OptionPrintPage = m_PagesOption->GetSelection();
if ( (m_Print_Sheet_Ref == NULL) || (m_Print_Sheet_Ref->GetValue() == FALSE) ) if( (m_Print_Sheet_Ref == NULL) || (m_Print_Sheet_Ref->GetValue() == FALSE) )
print_ref = FALSE; print_ref = FALSE;
// Pass two printout objects: for preview, and possible printing. // Pass two printout objects: for preview, and possible printing.
wxString title = BuildPrintTitle(); wxString title = BuildPrintTitle();
wxPrintPreview *preview = wxPrintPreview* preview =
new wxPrintPreview(new EDA_Printout(this, m_Parent, title, print_ref), new wxPrintPreview( new EDA_Printout (this, m_Parent, title, print_ref),
new EDA_Printout(this, m_Parent, title, print_ref), g_PrintData); new EDA_Printout (this, m_Parent, title, print_ref), g_PrintData );
if ( preview == NULL )
if( preview == NULL )
{ {
DisplayError(this, _("There was a problem previewing")); DisplayError( this, _( "There was a problem previewing" ) );
return; return;
} }
#ifdef PCBNEW #ifdef PCBNEW
if ( s_OptionPrintPage ) SetLayerMaskFromListSelection(); if( s_OptionPrintPage )
SetLayerMaskFromListSelection();
#endif #endif
m_Parent->GetPosition(&x, &y); m_Parent->GetPosition( &x, &y );
WPos.x = x + 4; WPos.x = x + 4;
WPos.y = y + 25; WPos.y = y + 25;
@ -385,83 +417,86 @@ wxString title = BuildPrintTitle();
WSize.x -= 3; WSize.x -= 3;
WSize.y += 6; WSize.y += 6;
wxPreviewFrame *frame = new wxPreviewFrame(preview, this, wxPreviewFrame* frame = new wxPreviewFrame( preview, this,
title, WPos, WSize); title, WPos, WSize );
frame->Initialize(); frame->Initialize();
frame->Show(TRUE); frame->Show( TRUE );
} }
/**********************************************************/ /**********************************************************/
void WinEDA_PrintFrame::EDA_PrintPage(wxCommandEvent& event) void WinEDA_PrintFrame::EDA_PrintPage( wxCommandEvent& event )
/**********************************************************/ /**********************************************************/
/* Called on activate "Print CURRENT" button
*/
{
bool print_ref = TRUE;
SetScale(event); /* Called on activate "Print CURRENT" button
*/
{
bool print_ref = TRUE;
SetScale( event );
s_OptionPrintPage = 0; s_OptionPrintPage = 0;
if ( m_PagesOption ) if( m_PagesOption )
s_OptionPrintPage = m_PagesOption->GetSelection(); s_OptionPrintPage = m_PagesOption->GetSelection();
if ( (m_Print_Sheet_Ref == NULL) || (m_Print_Sheet_Ref->GetValue() == FALSE) ) if( (m_Print_Sheet_Ref == NULL) || (m_Print_Sheet_Ref->GetValue() == FALSE) )
print_ref = FALSE; print_ref = FALSE;
#ifdef PCBNEW #ifdef PCBNEW
if ( s_OptionPrintPage ) SetLayerMaskFromListSelection(); if( s_OptionPrintPage )
SetLayerMaskFromListSelection();
#endif #endif
SetPenWidth(); SetPenWidth();
wxPrintDialogData printDialogData( * g_PrintData); wxPrintDialogData printDialogData( * g_PrintData );
wxPrinter printer(& printDialogData); wxPrinter printer(& printDialogData );
wxString title = BuildPrintTitle(); wxString title = BuildPrintTitle();
EDA_Printout printout(this, m_Parent, title, print_ref); EDA_Printout printout( this, m_Parent, title, print_ref );
#ifndef __WINDOWS__ #ifndef __WINDOWS__
wxDC * dc = printout.GetDC(); wxDC* dc = printout.GetDC();
((wxPostScriptDC*)dc)->SetResolution(600); // Postscript DC resolution is 600 ppi ( (wxPostScriptDC*) dc )->SetResolution( 600 ); // Postscript DC resolution is 600 ppi
#endif #endif
if (!printer.Print(this, &printout, TRUE)) if( !printer.Print( this, &printout, TRUE ) )
{ {
if (wxPrinter::GetLastError() == wxPRINTER_ERROR) if( wxPrinter::GetLastError() == wxPRINTER_ERROR )
DisplayError(this, _("There was a problem printing") ); DisplayError( this, _( "There was a problem printing" ) );
return; return;
} }
else else
{ {
* g_PrintData = printer.GetPrintDialogData().GetPrintData(); *g_PrintData = printer.GetPrintDialogData().GetPrintData();
} }
} }
/***************************************/ /***************************************/
bool EDA_Printout::OnPrintPage(int page) bool EDA_Printout::OnPrintPage( int page )
/***************************************/ /***************************************/
{ {
wxString msg; wxString msg;
msg.Printf(_("Print page %d"), page); msg.Printf( _( "Print page %d" ), page );
m_Parent->Affiche_Message(msg); m_Parent->Affiche_Message( msg );
#ifdef EESCHEMA #ifdef EESCHEMA
BASE_SCREEN * screen = m_Parent->GetScreen(); BASE_SCREEN* screen = m_Parent->GetScreen();
BASE_SCREEN *oldscreen = screen; BASE_SCREEN* oldscreen = screen;
if( s_OptionPrintPage == 1 ) if( s_OptionPrintPage == 1 )
{ {
EDA_ScreenList ScreenList; EDA_ScreenList ScreenList;
screen = ScreenList.GetScreen(page -1); screen = ScreenList.GetScreen( page - 1 );
} }
if (screen == NULL) return FALSE; if( screen == NULL )
return FALSE;
ActiveScreen = (SCH_SCREEN*) screen; ActiveScreen = (SCH_SCREEN*) screen;
DrawPage(); DrawPage();
ActiveScreen = (SCH_SCREEN*) oldscreen; ActiveScreen = (SCH_SCREEN*) oldscreen;
@ -469,24 +504,27 @@ BASE_SCREEN *oldscreen = screen;
#endif #endif
#ifdef PCBNEW #ifdef PCBNEW
if ( (m_Parent->m_Ident == PCB_FRAME) || (m_Parent->m_Ident == GERBER_FRAME) ) if( (m_Parent->m_Ident == PCB_FRAME) || (m_Parent->m_Ident == GERBER_FRAME) )
{ {
m_PrintFrame->SetLayerMaskFromListSelection(); m_PrintFrame->SetLayerMaskFromListSelection();
if ( s_OptionPrintPage == 0 ) if( s_OptionPrintPage == 0 )
{ {
// compute layer mask from page number // compute layer mask from page number
int ii, jj, mask = 1; int ii, jj, mask = 1;
for ( ii = 0, jj = 0; ii < NB_LAYERS; ii++) for( ii = 0, jj = 0; ii < NB_LAYERS; ii++ )
{ {
if ( s_PrintMaskLayer & mask ) jj++; if( s_PrintMaskLayer & mask )
if ( jj == page ) jj++;
if( jj == page )
{ {
s_PrintMaskLayer = mask; s_PrintMaskLayer = mask;
break; break;
} }
mask <<= 1; mask <<= 1;
} }
if ( ii == NB_LAYERS ) return FALSE;
if( ii == NB_LAYERS )
return FALSE;
} }
} }
DrawPage(); DrawPage();
@ -495,12 +533,14 @@ BASE_SCREEN *oldscreen = screen;
return TRUE; return TRUE;
} }
/*********************************************************/ /*********************************************************/
void EDA_Printout::GetPageInfo(int *minPage, int *maxPage, void EDA_Printout::GetPageInfo( int* minPage, int* maxPage,
int *selPageFrom, int *selPageTo) int* selPageFrom, int* selPageTo )
/*********************************************************/ /*********************************************************/
{ {
int ii = 1; int ii = 1;
*minPage = 1; *minPage = 1;
*selPageFrom = 1; *selPageFrom = 1;
@ -513,15 +553,18 @@ int ii = 1;
#endif #endif
#ifdef PCBNEW #ifdef PCBNEW
switch( s_OptionPrintPage ) switch( s_OptionPrintPage )
{ {
case 0 :ii = m_PrintFrame->SetLayerMaskFromListSelection(); case 0:
ii = m_PrintFrame->SetLayerMaskFromListSelection();
break; break;
case 1: case 1:
ii = 1; ii = 1;
break; break;
} }
#endif #endif
*maxPage = ii; *maxPage = ii;
@ -530,15 +573,16 @@ int ii = 1;
/**************************************/ /**************************************/
bool EDA_Printout::HasPage(int pageNum) bool EDA_Printout::HasPage( int pageNum )
/**************************************/ /**************************************/
{ {
#ifdef EESCHEMA #ifdef EESCHEMA
int PageCount; int PageCount;
EDA_ScreenList ScreenList; EDA_ScreenList ScreenList;
PageCount = ScreenList.GetCount(); PageCount = ScreenList.GetCount();
if( PageCount >= pageNum ) return TRUE; if( PageCount >= pageNum )
return TRUE;
return FALSE; return FALSE;
#endif #endif
@ -548,47 +592,50 @@ int PageCount;
#endif #endif
} }
/*************************************************************/ /*************************************************************/
bool EDA_Printout::OnBeginDocument(int startPage, int endPage) bool EDA_Printout::OnBeginDocument( int startPage, int endPage )
/*************************************************************/ /*************************************************************/
{ {
if (!wxPrintout::OnBeginDocument(startPage, endPage)) if( !wxPrintout::OnBeginDocument( startPage, endPage ) )
return FALSE; return FALSE;
return TRUE; return TRUE;
} }
/********************************/ /********************************/
void EDA_Printout::DrawPage() void EDA_Printout::DrawPage()
/********************************/ /********************************/
/* /*
This is the real print function: print the active screen * This is the real print function: print the active screen
*/ */
{ {
int tmpzoom; int tmpzoom;
wxPoint tmp_startvisu; wxPoint tmp_startvisu;
wxSize PageSize_in_mm; wxSize PageSize_in_mm;
wxSize SheetSize; // Page size in internal units wxSize SheetSize; // Page size in internal units
wxSize PlotAreaSize; // plot area size in pixels wxSize PlotAreaSize; // plot area size in pixels
double scaleX, scaleY, scale; double scaleX, scaleY, scale;
wxPoint old_org; wxPoint old_org;
wxPoint DrawOffset; // Offset de trace wxPoint DrawOffset; // Offset de trace
double userscale; double userscale;
int DrawZoom = 1; int DrawZoom = 1;
wxDC * dc = GetDC(); wxDC* dc = GetDC();
s_PrintMirror = m_PrintFrame->m_Print_Mirror->GetValue(); s_PrintMirror = m_PrintFrame->m_Print_Mirror->GetValue();
wxBusyCursor dummy; wxBusyCursor dummy;
GetPageSizeMM(&PageSize_in_mm.x, &PageSize_in_mm.y); GetPageSizeMM( &PageSize_in_mm.x, &PageSize_in_mm.y );
/* Save old draw scale and draw offset */ /* Save old draw scale and draw offset */
tmp_startvisu = ActiveScreen->m_StartVisu; tmp_startvisu = ActiveScreen->m_StartVisu;
tmpzoom = ActiveScreen->GetZoom(); tmpzoom = ActiveScreen->GetZoom();
old_org = ActiveScreen->m_DrawOrg; old_org = ActiveScreen->m_DrawOrg;
/* Change draw scale and offset to draw the whole page */ /* Change draw scale and offset to draw the whole page */
ActiveScreen->SetZoom(DrawZoom); ActiveScreen->SetZoom( DrawZoom );
ActiveScreen->m_DrawOrg.x = ActiveScreen->m_DrawOrg.y = 0; ActiveScreen->m_DrawOrg.x = ActiveScreen->m_DrawOrg.y = 0;
ActiveScreen->m_StartVisu.x = ActiveScreen->m_StartVisu.y = 0; ActiveScreen->m_StartVisu.x = ActiveScreen->m_StartVisu.y = 0;
@ -597,14 +644,14 @@ wxDC * dc = GetDC();
SheetSize.y *= m_Parent->m_InternalUnits / 1000; // size in pixels SheetSize.y *= m_Parent->m_InternalUnits / 1000; // size in pixels
// Get the size of the DC in pixels // Get the size of the DC in pixels
dc->GetSize(&PlotAreaSize.x, &PlotAreaSize.y); dc->GetSize( &PlotAreaSize.x, &PlotAreaSize.y );
#ifdef PCBNEW #ifdef PCBNEW
WinEDA_BasePcbFrame * pcbframe = (WinEDA_BasePcbFrame*) m_Parent; WinEDA_BasePcbFrame* pcbframe = (WinEDA_BasePcbFrame*) m_Parent;
pcbframe->m_Pcb->ComputeBoundaryBox(); pcbframe->m_Pcb->ComputeBoundaryBox();
/* Compute the PCB size in internal units*/ /* Compute the PCB size in internal units*/
userscale = s_ScaleList[s_Scale_Select]; userscale = s_ScaleList[s_Scale_Select];
if (userscale == 0) // fit in page if( userscale == 0 ) // fit in page
{ {
int extra_margin = 8000; // Margin = 8000/2 units pcb = 0,4 inch int extra_margin = 8000; // Margin = 8000/2 units pcb = 0,4 inch
SheetSize.x = pcbframe->m_Pcb->m_BoundaryBox.GetWidth() + extra_margin; SheetSize.x = pcbframe->m_Pcb->m_BoundaryBox.GetWidth() + extra_margin;
@ -612,8 +659,8 @@ wxDC * dc = GetDC();
userscale = 0.99; userscale = 0.99;
} }
if ( (s_ScaleList[s_Scale_Select] > 1.0) || // scale > 1 -> Recadrage if( (s_ScaleList[s_Scale_Select] > 1.0) // scale > 1 -> Recadrage
(s_ScaleList[s_Scale_Select] == 0) ) // fit in page || (s_ScaleList[s_Scale_Select] == 0) ) // fit in page
{ {
DrawOffset.x += pcbframe->m_Pcb->m_BoundaryBox.Centre().x; DrawOffset.x += pcbframe->m_Pcb->m_BoundaryBox.Centre().x;
DrawOffset.y += pcbframe->m_Pcb->m_BoundaryBox.Centre().y; DrawOffset.y += pcbframe->m_Pcb->m_BoundaryBox.Centre().y;
@ -623,26 +670,27 @@ wxDC * dc = GetDC();
#endif #endif
// Calculate a suitable scaling factor // Calculate a suitable scaling factor
scaleX = (double)SheetSize.x / PlotAreaSize.x; scaleX = (double) SheetSize.x / PlotAreaSize.x;
scaleY = (double)SheetSize.y / PlotAreaSize.y; scaleY = (double) SheetSize.y / PlotAreaSize.y;
scale = wxMax(scaleX,scaleY) / userscale; // Use x or y scaling factor, whichever fits on the DC scale = wxMax( scaleX, scaleY ) / userscale; // Use x or y scaling factor, whichever fits on the DC
// ajust the real draw scale // ajust the real draw scale
#ifdef PCBNEW #ifdef PCBNEW
double accurate_Xscale, accurate_Yscale; double accurate_Xscale, accurate_Yscale;
dc->SetUserScale(DrawZoom / scale * m_PrintFrame->m_XScaleAdjust, dc->SetUserScale( DrawZoom / scale * m_PrintFrame->m_XScaleAdjust,
DrawZoom / scale * m_PrintFrame->m_YScaleAdjust); DrawZoom / scale * m_PrintFrame->m_YScaleAdjust );
// Compute Accurate scale 1 // Compute Accurate scale 1
{ {
int w, h; int w, h;
GetPPIPrinter(&w, &h); GetPPIPrinter( &w, &h );
accurate_Xscale = ((double)(DrawZoom * w))/ PCB_INTERNAL_UNIT; accurate_Xscale = ( (double) (DrawZoom * w) ) / PCB_INTERNAL_UNIT;
accurate_Yscale = ((double)(DrawZoom * h))/ PCB_INTERNAL_UNIT; accurate_Yscale = ( (double) (DrawZoom * h) ) / PCB_INTERNAL_UNIT;
if ( IsPreview() ) // Scale must take in account the DC size in Preview if( IsPreview() ) // Scale must take in account the DC size in Preview
{ {
// Get the size of the DC in pixels // Get the size of the DC in pixels
dc->GetSize(&PlotAreaSize.x, &PlotAreaSize.y); dc->GetSize( &PlotAreaSize.x, &PlotAreaSize.y );
GetPageSizePixels(&w, &h); GetPageSizePixels( &w, &h );
accurate_Xscale *= PlotAreaSize.x; accurate_Xscale /= w; accurate_Xscale *= PlotAreaSize.x; accurate_Xscale /= w;
accurate_Yscale *= PlotAreaSize.y; accurate_Yscale /= h; accurate_Yscale *= PlotAreaSize.y; accurate_Yscale /= h;
} }
@ -650,46 +698,49 @@ double accurate_Xscale, accurate_Yscale;
accurate_Yscale *= m_PrintFrame->m_YScaleAdjust; accurate_Yscale *= m_PrintFrame->m_YScaleAdjust;
} }
#else #else
dc->SetUserScale(DrawZoom / scale, DrawZoom / scale); dc->SetUserScale( DrawZoom / scale, DrawZoom / scale );
#endif #endif
#ifdef PCBNEW #ifdef PCBNEW
if ( (s_ScaleList[s_Scale_Select] > 1.0) || // scale > 1 -> Recadrage if( (s_ScaleList[s_Scale_Select] > 1.0) // scale > 1 -> Recadrage
(s_ScaleList[s_Scale_Select] == 0) ) // fit in page || (s_ScaleList[s_Scale_Select] == 0) ) // fit in page
{ {
DrawOffset.x -= (int)( (PlotAreaSize.x/2) * scale); DrawOffset.x -= (int) ( (PlotAreaSize.x / 2) * scale );
DrawOffset.y -= (int)( (PlotAreaSize.y/3) * scale); DrawOffset.y -= (int) ( (PlotAreaSize.y / 3) * scale );
} }
DrawOffset.x += (int)( (SheetSize.x/2) * (m_PrintFrame->m_XScaleAdjust -1.0)); DrawOffset.x += (int) ( (SheetSize.x / 2) * (m_PrintFrame->m_XScaleAdjust - 1.0) );
DrawOffset.y += (int)( (SheetSize.y/2) * (m_PrintFrame->m_YScaleAdjust -1.0)); DrawOffset.y += (int) ( (SheetSize.y / 2) * (m_PrintFrame->m_YScaleAdjust - 1.0) );
#endif #endif
ActiveScreen->m_DrawOrg = DrawOffset; ActiveScreen->m_DrawOrg = DrawOffset;
GRResetPenAndBrush(dc); GRResetPenAndBrush( dc );
if( s_Print_Black_and_White ) GRForceBlackPen(TRUE); if( s_Print_Black_and_White )
GRForceBlackPen( TRUE );
#ifdef EESCHEMA #ifdef EESCHEMA
/* set Pen min width */ /* set Pen min width */
double ftmp, xdcscale, ydcscale; double ftmp, xdcscale, ydcscale;
// s_PrintPenMinWidth is in internal units ( 1/1000 inch), and must be converted in pixels // s_PrintPenMinWidth is in internal units ( 1/1000 inch), and must be converted in pixels
ftmp = (float)s_PrintPenMinWidth * 25.4 / EESCHEMA_INTERNAL_UNIT; // ftmp est en mm ftmp = (float) s_PrintPenMinWidth * 25.4 / EESCHEMA_INTERNAL_UNIT; // ftmp est en mm
ftmp *= (float)PlotAreaSize.x / PageSize_in_mm.x; /* ftmp is in pixels */ ftmp *= (float) PlotAreaSize.x / PageSize_in_mm.x; /* ftmp is in pixels */
/* because the pen size will be scaled by the dc scale, we modify the size /* because the pen size will be scaled by the dc scale, we modify the size
in order to keep the requested value */ * in order to keep the requested value */
dc->GetUserScale(&xdcscale, &ydcscale); dc->GetUserScale( &xdcscale, &ydcscale );
ftmp /= xdcscale; ftmp /= xdcscale;
SetPenMinWidth((int)round(ftmp)); SetPenMinWidth( (int) round( ftmp ) );
#else #else
SetPenMinWidth(1); // min width = 1 pixel SetPenMinWidth( 1 ); // min width = 1 pixel
#endif #endif
WinEDA_DrawPanel * panel = m_Parent->DrawPanel; WinEDA_DrawPanel* panel = m_Parent->DrawPanel;
EDA_Rect tmp = panel->m_ClipBox; EDA_Rect tmp = panel->m_ClipBox;
panel->m_ClipBox.SetOrigin(wxPoint(0,0)); panel->m_ClipBox.SetOrigin( wxPoint( 0, 0 ) );
panel->m_ClipBox.SetSize(wxSize(0x7FFFFF0, 0x7FFFFF0)); panel->m_ClipBox.SetSize( wxSize( 0x7FFFFF0, 0x7FFFFF0 ) );
g_IsPrinting = TRUE; g_IsPrinting = TRUE;
#ifdef EESCHEMA #ifdef EESCHEMA
@ -697,47 +748,50 @@ EDA_Rect tmp = panel->m_ClipBox;
g_PrintFillMask = FILLED_WITH_BG_BODYCOLOR; g_PrintFillMask = FILLED_WITH_BG_BODYCOLOR;
#endif #endif
#ifdef PCBNEW #ifdef PCBNEW
if ( m_Print_Sheet_Ref ) if( m_Print_Sheet_Ref )
m_Parent->TraceWorkSheet( dc, ActiveScreen, 0); m_Parent->TraceWorkSheet( dc, ActiveScreen, 0 );
if ( userscale == 1.0 ) // Draw the Sheet refs at optimum scale, and board at 1.0 scale if( userscale == 1.0 ) // Draw the Sheet refs at optimum scale, and board at 1.0 scale
{ {
m_Print_Sheet_Ref = FALSE; m_Print_Sheet_Ref = FALSE;
dc->SetUserScale( accurate_Yscale, accurate_Yscale); dc->SetUserScale( accurate_Yscale, accurate_Yscale );
} }
if ( s_PrintMirror ) if( s_PrintMirror )
{ // To plot mirror, we revere the y axis, and modify the plot y origin { // To plot mirror, we revere the y axis, and modify the plot y origin
double sx, sy; double sx, sy;
dc->GetUserScale(&sx, &sy); dc->GetUserScale( &sx, &sy );
dc->SetAxisOrientation(TRUE, TRUE); dc->SetAxisOrientation( TRUE, TRUE );
if ( userscale < 1.0 ) sy /= userscale; if( userscale < 1.0 )
sy /= userscale;
/* Plot offset y is moved by the y plot area size in order to have /* Plot offset y is moved by the y plot area size in order to have
the old draw area in the new draw area, because the draw origin has not moved * the old draw area in the new draw area, because the draw origin has not moved
(this is the upper left corner) but the Y axis is reversed, therefore the plotting area * (this is the upper left corner) but the Y axis is reversed, therefore the plotting area
is the y coordinate values from - PlotAreaSize.y to 0 */ * is the y coordinate values from - PlotAreaSize.y to 0 */
int ysize = (int)( PlotAreaSize.y / sy ); int ysize = (int) ( PlotAreaSize.y / sy );
DrawOffset.y += ysize; DrawOffset.y += ysize;
/* in order to keep the board position in the sheet /* in order to keep the board position in the sheet
(when user scale <= 1) the y offset in moved by the distance between * (when user scale <= 1) the y offset in moved by the distance between
the middle of the page and the middle of the board * the middle of the page and the middle of the board
This is equivalent to put the mirror axis to the board centre * This is equivalent to put the mirror axis to the board centre
for scales > 1, the DrawOffset was already computed to have the board centre * for scales > 1, the DrawOffset was already computed to have the board centre
to the middle of the page. * to the middle of the page.
*/ */
wxPoint pcb_centre = pcbframe->m_Pcb->m_BoundaryBox.Centre(); wxPoint pcb_centre = pcbframe->m_Pcb->m_BoundaryBox.Centre();
if ( userscale <= 1.0 ) if( userscale <= 1.0 )
DrawOffset.y += pcb_centre.y - (ysize/2); DrawOffset.y += pcb_centre.y - (ysize / 2);
ActiveScreen->m_DrawOrg = DrawOffset; ActiveScreen->m_DrawOrg = DrawOffset;
panel->m_ClipBox.SetOrigin(wxPoint(-0x7FFFFF,-0x7FFFFF)); panel->m_ClipBox.SetOrigin( wxPoint( -0x7FFFFF, -0x7FFFFF ) );
} }
panel->PrintPage(dc, 0, s_PrintMaskLayer); panel->PrintPage( dc, 0, s_PrintMaskLayer );
#else #else
panel->PrintPage(dc, m_Print_Sheet_Ref, s_PrintMaskLayer); panel->PrintPage( dc, m_Print_Sheet_Ref, s_PrintMaskLayer );
#endif #endif
#ifdef EESCHEMA #ifdef EESCHEMA
@ -747,11 +801,10 @@ EDA_Rect tmp = panel->m_ClipBox;
g_IsPrinting = FALSE; g_IsPrinting = FALSE;
panel->m_ClipBox = tmp; panel->m_ClipBox = tmp;
SetPenMinWidth(1); SetPenMinWidth( 1 );
GRForceBlackPen(FALSE); GRForceBlackPen( FALSE );
ActiveScreen->m_StartVisu = tmp_startvisu; ActiveScreen->m_StartVisu = tmp_startvisu;
ActiveScreen->m_DrawOrg = old_org; ActiveScreen->m_DrawOrg = old_org;
ActiveScreen->SetZoom(tmpzoom); ActiveScreen->SetZoom( tmpzoom );
} }