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

65
common/common.cpp
View File

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

3
common/projet_config.cpp
View File

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

30
cvpcb/cfg.cpp
View File

@ -20,13 +20,14 @@
/**************************************************/
void Read_Config( const wxString& FileName )
/**************************************************/
/* lit la configuration
1 - lit cvpcb.cnf
2 - si non trouve lit <chemin de cvpcb.exe>/cvpcb.cnf
3 - si non trouve: init des variables aux valeurs par defaut
Remarque:
le chemin de l'executable cvpcb.exe doit etre dans BinDir
/* lit la configuration
* 1 - lit cvpcb.cnf
* 2 - si non trouve lit <chemin de cvpcb.exe>/cvpcb.cnf
* 3 - si non trouve: init des variables aux valeurs par defaut
*
* Remarque:
* le chemin de l'executable cvpcb.exe doit etre dans BinDir
*/
{
wxString FullFileName = FileName;
@ -38,8 +39,11 @@ wxString FullFileName = FileName ;
g_EDA_Appl->ReadProjectConfig( FullFileName,
GROUP, ParamCfgList, FALSE );
if ( PkgInExtBuffer.IsEmpty() ) PkgInExtBuffer = wxT(".pkg");
if ( NetInExtBuffer.IsEmpty() ) NetInExtBuffer = wxT(".net"),
if( PkgInExtBuffer.IsEmpty() )
PkgInExtBuffer = wxT( ".pkg" );
if( NetInExtBuffer.IsEmpty() )
NetInExtBuffer = wxT( ".net" );
/* Inits autres variables */
SetRealLibraryPath( wxT( "modules" ) );
@ -49,19 +53,22 @@ wxString FullFileName = FileName ;
/************************************************************/
void WinEDA_CvpcbFrame::Update_Config( wxCommandEvent& event )
/************************************************************/
/* fonction relai d'appel a Save_Config,
la vraie fonction de sauvegarde de la config
* la vraie fonction de sauvegarde de la config
*/
{
Save_Config( this );
}
/************************************/
void Save_Config( wxWindow* parent )
/************************************/
/* enregistrement de la config */
{
wxString path, FullFileName;
wxString mask( wxT( "*" ) );
FullFileName = FFileName;
@ -77,9 +84,10 @@ wxString mask( wxT("*"));
wxFD_SAVE,
TRUE
);
if ( FullFileName.IsEmpty()) return;
if( FullFileName.IsEmpty() )
return;
/* ecriture de la configuration */
g_EDA_Appl->WriteProjectConfig( FullFileName, GROUP, ParamCfgList );
}

2
gerbview/gerbview.cpp
View File

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

12
gerbview/gerbview_config.cpp
View File

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

3
gerbview/select_layers_to_pcb.cpp
View File

@ -14,6 +14,7 @@
/* Variables locales */
#define LAYER_UNSELECTED NB_LAYERS
static int ButtonTable[32]; // Indexes buttons to Gerber layers
static int LayerLookUpTable[32]; // Indexes Gerber layers to PCB file layers
wxStaticText* layer_list[32]; // Indexes text strings to buttons
@ -75,6 +76,7 @@ int * InstallDialogLayerPairChoice(WinEDA_GerberFrame * parent)
*/
{
WinEDA_SwapLayerFrame * frame = new WinEDA_SwapLayerFrame(parent);
int ii = frame->ShowModal();
frame->Destroy();
if( ii >= 0 )
@ -138,7 +140,6 @@ WinEDA_SwapLayerFrame::WinEDA_SwapLayerFrame(WinEDA_GerberFrame *parent) :
int pcb_layer_number = 0;
for( nb_items = 0, ii = 0; ii < 32; ii++ )
{
if( g_GERBER_Descr_List[ii] == NULL )
continue;

34
include/pcbstruct.h
View File

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

8
include/wxPcbStruct.h
View File

@ -74,6 +74,14 @@ public:
~WinEDA_BasePcbFrame();
/**
* Function SetBOARD
* sets the m_Pcb member in such as way as to ensure deleting any previous
* BOARD.
* @param aBoard The BOARD to put into the frame.
*/
void SetBOARD( BOARD* aBoard );
// General
virtual void OnCloseWindow( wxCloseEvent& Event ) = 0;
virtual void Process_Special_Functions( wxCommandEvent& event ) = 0;

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 )
/**************************************/

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

44
pcbnew/class_board.h
View File

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

5
pcbnew/class_drawsegment.cpp
View File

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

28
pcbnew/class_module.cpp
View File

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

11
pcbnew/class_module.h
View File

@ -197,6 +197,17 @@ public:
return m_Value->m_Text;
}
/**
* Function FindPadByName
* returns a D_PAD* with a matching name. Note that names may not be
* unique, depending on how the foot print was created.
* @param
* @return D_PAD* - The first matching name is returned, or NULL if not found.
*/
D_PAD* FindPadByName( const wxString& aPadName ) const;
/**
* Function Visit
* should be re-implemented for each derived class in order to handle

5
pcbnew/class_pcb_text.cpp
View File

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

7
pcbnew/class_text_mod.cpp
View File

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

6
pcbnew/class_zone.cpp
View File

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

3
pcbnew/classpcb.cpp
View File

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

6
pcbnew/cotation.cpp
View File

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

6
pcbnew/cross-probing.cpp
View File

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

17
pcbnew/dialog_zones_by_polygon.cpp
View File

@ -133,6 +133,8 @@ bool WinEDA_ZoneFrame::Create( wxWindow* parent,
void WinEDA_ZoneFrame::CreateControls()
{
BOARD* board = m_Parent->m_Pcb;
SetFont( *g_DialogFont );
////@begin WinEDA_ZoneFrame content construction
@ -310,18 +312,22 @@ void WinEDA_ZoneFrame::CreateControls()
break;
}
int layer_cnt = g_DesignSettings.m_CopperLayerCount;
for( int ii = 0; ii < g_DesignSettings.m_CopperLayerCount; ii++ )
int layer_cnt = board->GetCopperLayerCount();
for( int ii = 0; ii < board->GetCopperLayerCount(); ii++ )
{
wxString msg;
int layer_number = COPPER_LAYER_N;
if( layer_cnt == 0 || ii < layer_cnt - 1 )
layer_number = ii;
else if( ii == layer_cnt - 1 )
layer_number = LAYER_CMP_N;
m_LayerId[ii] = layer_number;
msg = ReturnPcbLayerName( layer_number ).Trim();
msg = board->GetLayerName( layer_number ).Trim();
m_LayerSelectionCtrl->InsertItems( 1, &msg, ii );
if( m_Zone_Container )
{
if( m_Zone_Container->GetLayer() == layer_number )
@ -335,15 +341,18 @@ void WinEDA_ZoneFrame::CreateControls()
}
m_NetSortingOption->SetSelection(m_NetSorting == BOARD::ALPHA_SORT ? 0 : 1 );
wxString NetNameFilter;
if( m_Parent->m_Parent->m_EDA_Config )
{
NetNameFilter = m_Parent->m_Parent->m_EDA_Config->Read( ZONE_NET_FILTER_STRING_KEY, wxT("N_0*") );
}
m_NetNameFilter->SetValue(NetNameFilter);
wxArrayString ListNetName;
m_Parent->m_Pcb->ReturnSortedNetnamesList( ListNetName,
m_NetSorting == 0 ? BOARD::ALPHA_SORT : BOARD::PAD_CNT_SORT );
if ( m_NetSorting != 0 )
{
wxString Filter = m_NetNameFilter->GetValue();
@ -363,6 +372,7 @@ void WinEDA_ZoneFrame::CreateControls()
int net_select = g_HightLigth_NetCode;
if( m_Zone_Container )
net_select = m_Zone_Container->GetNet();
if( net_select > 0 )
{
EQUIPOT* equipot = m_Parent->m_Pcb->FindNet( net_select );
@ -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_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;
}
wxString msg = _( "Delete Layer " ) + ReturnPcbLayerName( layer );
wxString msg = _( "Delete Layer " ) + m_Pcb->GetLayerName( layer );
if( !IsOK( this, msg ) )
return;

47
pcbnew/initpcb.cpp
View File

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

42
pcbnew/ioascii.cpp
View File

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

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 )
/*******************************************************************/

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
SetBOARD( new BOARD( NULL, this ) );
m_DisplayPcbTrackFill = DisplayOpt.DisplayPcbTrackFill;
m_DisplayPadFill = DisplayOpt.DisplayPadFill;
m_DisplayPadNum = DisplayOpt.DisplayPadNum;
@ -247,6 +249,7 @@ WinEDA_PcbFrame::~WinEDA_PcbFrame()
m_Parent->m_PcbFrame = NULL;
m_CurrentScreen = ScreenPcb;
delete m_drc;
delete m_Pcb;
}

1
pcbnew/pcbnew.cpp
View File

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

108
pcbnew/pcbplot.cpp
View File

@ -28,8 +28,7 @@ static bool s_PlotOriginIsAuxAxis = FALSE;
// Routines Locales
enum id_plotps
{
enum id_plotps {
ID_CLOSE_PLOT = 8020,
ID_DRILL_SHAPE_OPT,
ID_SCALE_OPT,
@ -99,6 +98,7 @@ private:
void SetCommands( wxCommandEvent& event );
void SaveOptPlot( wxCommandEvent& event );
void CreateDrillFile( wxCommandEvent& event );
DECLARE_EVENT_TABLE()
};
@ -126,30 +126,45 @@ wxButton * Button;
int ii;
m_Parent = parent;
BOARD* board = parent->m_Pcb;
SetFont( *g_DialogFont );
Centre();
m_PlotFormat = format_plot;
m_Plot_Sheet_Ref = NULL;
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 );
LeftBoxSizer->Add( LayersBoxSizer, 0, wxGROW | wxALL, 5 );
wxString fmtmsg[4] = { wxT("HPGL"), wxT("Gerber"), wxT("Postscript"), wxT("Postscript A4") };
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:
@ -174,32 +189,42 @@ wxString fmtmsg[4] = { wxT("HPGL"), wxT("Gerber"), wxT("Postscript"), wxT("Posts
// Creation des menus d'option du format GERBER
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
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
m_HPGLPenSpeedOpt = new WinEDA_ValueCtrl( this, _( "Pen Speed (cm/s)" ),
g_HPGL_Pen_Speed, CENTIMETRE, MidRightBoxSizer, 1);
g_HPGL_Pen_Speed, CENTIMETRE, MidRightBoxSizer,
1 );
m_HPGLPenSpeedOpt->SetToolTip( _( "Set pen speed in cm/s" ) );
m_HPGLPenOverlayOpt = new WinEDA_ValueCtrl( this, _( "Pen Ovr" ),
g_HPGL_Pen_Recouvrement, g_UnitMetric, MidRightBoxSizer, UNITS_MILS);
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" ),
g_PlotLine_Width, g_UnitMetric, MidRightBoxSizer, PCB_INTERNAL_UNIT);
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
wxString choice_plot_offset_msg[] =
static const wxString choice_plot_offset_msg[] =
{ _( "Absolute" ), _( "Auxiliary axis" ) };
m_Choice_Plot_Offset = new wxRadioBox( this, ID_SEL_PLOT_OFFSET_OPTION,
_( "Plot Origin" ),
wxDefaultPosition, wxSize( -1, -1 ),
2, choice_plot_offset_msg, 1, wxRA_SPECIFY_COLS );
if( s_PlotOriginIsAuxAxis )
m_Choice_Plot_Offset->SetSelection( 1 );
RightBoxSizer->Add( m_Choice_Plot_Offset, 0, wxGROW | wxALL, 5 );
@ -208,18 +233,22 @@ wxString choice_plot_offset_msg[] =
/* Create the command buttons */
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( *wxBLUE );
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 );
@ -231,28 +260,39 @@ wxString choice_plot_offset_msg[] =
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_FineAdjustXscaleOpt = new WinEDA_DFloatValueCtrl(this, _("X Scale Adjust"), m_XScaleAdjust, RightBoxSizer);
m_FineAdjustXscaleOpt = new WinEDA_DFloatValueCtrl( this, _(
"X Scale Adjust" ), m_XScaleAdjust,
RightBoxSizer );
m_FineAdjustXscaleOpt->SetToolTip( _( "Set X scale adjust for exact scale plotting" ) );
m_FineAdjustYscaleOpt = new WinEDA_DFloatValueCtrl(this, _("Y Scale Adjust"), m_YScaleAdjust, RightBoxSizer);
m_FineAdjustYscaleOpt = new WinEDA_DFloatValueCtrl( this, _(
"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
int mask = 1;
wxBoxSizer* OneColonLayerBoxSizer = new wxBoxSizer( wxVERTICAL );
LayersBoxSizer->Add( OneColonLayerBoxSizer, 0, wxGROW | wxALL, 5 );
for( ii = 0; ii < NB_LAYERS; ii++, mask <<= 1 )
{
if( ii == 16 )
{
OneColonLayerBoxSizer = new wxBoxSizer( wxVERTICAL );
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 )
m_BoxSelecLayer[ii]->SetValue( true );
OneColonLayerBoxSizer->Add( m_BoxSelecLayer[ii], 0, wxGROW | wxALL, 1 );
@ -262,6 +302,7 @@ wxString choice_plot_offset_msg[] =
m_Exclude_Edges_Pcb = new wxCheckBox( this,
ID_EXCLUDE_EDGES_PCB, _( "Exclude Edges Pcb Layer" ) );
m_Exclude_Edges_Pcb->SetValue( g_Exclude_Edges_Pcb );
m_Exclude_Edges_Pcb->SetToolTip(
_( "Exclude contents of Edges Pcb layer from all other layers" ) );
@ -271,6 +312,7 @@ wxString choice_plot_offset_msg[] =
if( m_Parent->m_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 );
}
@ -279,7 +321,9 @@ wxString choice_plot_offset_msg[] =
// Option d'impression des pads sur toutes les couches
m_Plot_Pads_on_Silkscreen = new wxCheckBox( this,
ID_PRINT_PAD_ON_SILKSCREEN, _("Print Pads on Silkscreen") );
ID_PRINT_PAD_ON_SILKSCREEN, _(
"Print Pads on Silkscreen" ) );
m_Plot_Pads_on_Silkscreen->SetValue( PlotPadsOnSilkLayer );
m_Plot_Pads_on_Silkscreen->SetToolTip(
_( "Enable/disable print/plot pads on Silkscreen layers" ) );
@ -287,18 +331,21 @@ wxString choice_plot_offset_msg[] =
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
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->SetToolTip(
_( "Enable/disable print/plot module value on Silkscreen layers" ) );
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->SetValue( Sel_Texte_Reference );
m_Plot_Text_Ref->SetToolTip(
_( "Enable/disable print/plot module reference on Silkscreen layers" ) );
@ -306,48 +353,57 @@ wxString choice_plot_offset_msg[] =
m_Plot_Text_Div = new wxCheckBox( this, ID_PRINT_MODULE_TEXTS,
_( "Print other Module texts" ) );
m_Plot_Text_Div->SetValue( Sel_Texte_Divers );
m_Plot_Text_Div->SetToolTip(
_( "Enable/disable print/plot module field texts on Silkscreen layers" ) );
LeftBoxSizer->Add( m_Plot_Text_Div, 0, wxGROW | wxALL, 1 );
m_Plot_Invisible_Text = new wxCheckBox( this,
ID_FORCE_PRINT_INVISIBLE_TEXT, _("Force Print Invisible Texts") );
ID_FORCE_PRINT_INVISIBLE_TEXT, _(
"Force Print Invisible Texts" ) );
m_Plot_Invisible_Text->SetValue( Sel_Texte_Invisible );
m_Plot_Invisible_Text->SetToolTip(
_( "Force print/plot module invisible texts on Silkscreen layers" ) );
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,
_( "Pads Drill Opt" ), wxDefaultPosition, wxSize( -1, -1 ),
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] =
static const wxString scalemsg[5] =
{ _( "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 );
wxString list_opt3[3] = {_("Line"), _("Filled"), _("Sketch") };
static const wxString list_opt3[3] = { _( "Line" ), _( "Filled" ), _( "Sketch" ) };
m_PlotModeOpt = new wxRadioBox( this, ID_PLOT_MODE_OPT, _( "Plot Mode" ),
wxDefaultPosition, wxDefaultSize,
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,
_( "Plot Mirror" ) );
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(
_( "Print/plot vias on mask layers. They are in this case not protected" ) );
@ -355,9 +411,11 @@ wxString list_opt3[3] = {_("Line"), _("Filled"), _("Sketch") };
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:
wxCommandEvent event;
SetCommands( event );
@ -408,8 +466,10 @@ void WinEDA_PlotFrame::SetCommands(wxCommandEvent & event)
*/
{
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()];
@ -479,6 +539,7 @@ int format_list[] =
m_Plot_PS_Negative->Enable( false );
break;
}
format_plot = m_PlotFormat;
}
@ -540,6 +601,8 @@ int layer_to_plot;
wxString FullFileName, BaseFileName;
wxString ext;
BOARD* board = m_Parent->m_Pcb;
SaveOptPlot( event );
switch( g_PlotScaleOpt )
@ -590,8 +653,10 @@ wxString ext;
if( m_BoxSelecLayer[layer_to_plot]->GetValue() )
{
s_SelectedLayers |= mask;
// Calcul du nom du fichier
FullFileName = BaseFileName + ReturnPcbLayerName(layer_to_plot, true) + ext;
FullFileName = BaseFileName + board->GetLayerName( layer_to_plot ) + ext;
switch( m_PlotFormat )
{
case PLOT_FORMAT_POST:
@ -608,6 +673,7 @@ wxString ext;
}
}
}
// Close(true);
}
@ -617,6 +683,6 @@ void WinEDA_BasePcbFrame::ToPlotter(wxCommandEvent& event)
/***************************************************************/
{
WinEDA_PlotFrame* frame = new WinEDA_PlotFrame( this );
frame->ShowModal(); frame->Destroy();
}

12
pcbnew/pcbtexte.cpp
View File

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

6
pcbnew/protos.h
View File

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

6
pcbnew/sel_layer.cpp
View File

@ -101,6 +101,7 @@ WinEDA_SelLayerFrame::WinEDA_SelLayerFrame( WinEDA_BasePcbFrame* parent,
* to the right of that radiobox.
*/
{
BOARD* board = parent->m_Pcb;
wxButton* Button;
int ii;
wxString LayerList[NB_LAYERS + 1]; // One extra element for "(Deselect)" radiobutton
@ -123,7 +124,7 @@ WinEDA_SelLayerFrame::WinEDA_SelLayerFrame( WinEDA_BasePcbFrame* parent,
if( (max_layer >= 0) && (max_layer < ii) )
break;
LayerList[LayerCount] = ReturnPcbLayerName( ii );
LayerList[LayerCount] = board->GetLayerName( ii );
if( ii == default_layer )
LayerSelect = LayerCount;
@ -264,6 +265,7 @@ WinEDA_SelLayerPairFrame::WinEDA_SelLayerPairFrame( WinEDA_BasePcbFrame* parent
wxSize( 470, 250 ), DIALOG_STYLE )
/*******************************************************************************/
{
BOARD* board = parent->m_Pcb;
wxButton* Button;
int ii, LayerCount;
wxString LayerList[NB_COPPER_LAYERS];
@ -281,7 +283,7 @@ WinEDA_SelLayerPairFrame::WinEDA_SelLayerPairFrame( WinEDA_BasePcbFrame* parent
m_LayerId[ii] = 0;
if( (g_TabOneLayerMask[ii] & Masque_Layer) )
{
LayerList[LayerCount] = ReturnPcbLayerName( ii );
LayerList[LayerCount] = board->GetLayerName( ii );
if( ii == screen->m_Route_Layer_TOP )
LayerTopSelect = LayerCount;
if( ii == screen->m_Route_Layer_BOTTOM )

6
pcbnew/set_color.cpp
View File

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

4
pcbnew/set_color.h
View File

@ -526,7 +526,7 @@ private:
DECLARE_DYNAMIC_CLASS( WinEDA_SetColorsFrame )
DECLARE_EVENT_TABLE()
WinEDA_DrawFrame* m_Parent;
WinEDA_PcbFrame* m_Parent;
wxBoxSizer* OuterBoxSizer;
wxBoxSizer* MainBoxSizer;
wxFlexGridSizer* FlexColumnBoxSizer;
@ -566,7 +566,7 @@ private:
public:
// Constructors and destructor
WinEDA_SetColorsFrame();
WinEDA_SetColorsFrame( WinEDA_DrawFrame* parent, const wxPoint& framepos );
WinEDA_SetColorsFrame( WinEDA_PcbFrame* parent, const wxPoint& framepos );
~WinEDA_SetColorsFrame();
};

11
pcbnew/specctra_export.cpp
View File

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

11
pcbnew/swap_layers.cpp
View File

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

2
pcbnew/tool_pcb.cpp
View File

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

121
share/wxprint.cpp
View File

@ -101,9 +101,11 @@ public:
WinEDA_DrawFrame* m_Parent;
WinEDA_PrintFrame* m_PrintFrame;
EDA_Printout(WinEDA_PrintFrame * print_frame, WinEDA_DrawFrame * parent, const wxString & title, bool print_ref):
wxPrintout(title)
{
EDA_Printout( WinEDA_PrintFrame * print_frame,
WinEDA_DrawFrame * parent,
const wxString &title,
bool print_ref ) :
wxPrintout( title ) {
m_PrintFrame = print_frame;
m_Parent = parent;
s_PrintMaskLayer = 0xFFFFFFFF;
@ -121,8 +123,9 @@ public:
/*******************************************************/
void WinEDA_DrawFrame::ToPrinter( wxCommandEvent& event )
/*******************************************************/
/* 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();
@ -132,6 +135,7 @@ bool PrinterError = FALSE;
if( DrawPanel->ManageCurseur && DrawPanel->ForceCloseManageCurseur )
{
wxClientDC dc( DrawPanel );
DrawPanel->PrepareDC( dc );
DrawPanel->ForceCloseManageCurseur( DrawPanel, &dc );
}
@ -140,6 +144,7 @@ bool PrinterError = FALSE;
if( g_PrintData == NULL ) // First print
{
g_PrintData = new wxPrintData();
if( !g_PrintData->Ok() )
{
PrinterError = TRUE;
@ -152,6 +157,7 @@ bool PrinterError = FALSE;
pos.x += 10; pos.y += 10;
WinEDA_PrintFrame* frame = new WinEDA_PrintFrame( this );
frame->ShowModal(); frame->Destroy();
#ifdef EESCHEMA
g_PrintFillMask = 0;
@ -169,17 +175,25 @@ void WinEDA_PrintFrame::SetOthersDatas()
m_FineAdjustXscaleOpt->SetToolTip( _( "Set X 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
m_PagesOptionEeschema->Show( false );
m_PagesOption = m_PagesOptionPcb;
/* Create layer list */
int mask = 1, ii;
for( ii = 0; ii < NB_LAYERS; ii++, mask <<= 1 )
{
m_BoxSelecLayer[ii] = new wxCheckBox( this, -1,
ReturnPcbLayerName(ii));
if ( mask & s_SelectedLayers) m_BoxSelecLayer[ii]->SetValue(TRUE);
#if defined(PCBNEW)
((WinEDA_PcbFrame*)m_Parent)->m_Pcb->GetLayerName(ii) );
#else
ReturnLayerName( ii ) );
#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 );
@ -187,6 +201,7 @@ void WinEDA_PrintFrame::SetOthersDatas()
m_TechLayersBoxSizer->Add( m_BoxSelecLayer[ii],
wxGROW | wxLEFT | wxRIGHT | wxTOP | wxADJUST_MINSIZE );
}
// Read the scale adjust option
if( m_Parent->m_Parent->m_EDA_Config )
{
@ -215,6 +230,7 @@ void WinEDA_PrintFrame::SetOthersDatas()
#endif
}
/**********************************************************/
int WinEDA_PrintFrame::SetLayerMaskFromListSelection()
/**********************************************************/
@ -232,12 +248,14 @@ int ii;
s_PrintMaskLayer |= 1 << ii;
}
}
#else
page_count = 1;
#endif
return page_count;
}
/************************************************************/
void WinEDA_PrintFrame::SetColorOrBlack( wxCommandEvent& event )
/************************************************************/
@ -245,13 +263,16 @@ void WinEDA_PrintFrame::SetColorOrBlack(wxCommandEvent& event)
s_Print_Black_and_White = m_ColorOption->GetSelection();
}
/****************************************************/
void WinEDA_PrintFrame::OnClosePrintDialog()
/****************************************************/
/* called when WinEDA_PrintFrame is closed
*/
{
wxConfig* Config = m_Parent->m_Parent->m_EDA_Config;
if( Config )
{
Config->Write( wxT( "PrintPenWidth" ), s_PrintPenMinWidth );
@ -278,6 +299,7 @@ void WinEDA_PrintFrame::OnClosePrintDialog()
/************************************************/
wxString WinEDA_PrintFrame::BuildPrintTitle()
/************************************************/
/* return a valid filename to create a print file
*/
{
@ -289,6 +311,7 @@ wxString name, ext;
return name;
}
/******************************************************/
void WinEDA_PrintFrame::SetScale( wxCommandEvent& event )
/******************************************************/
@ -305,11 +328,13 @@ void WinEDA_PrintFrame::SetScale(wxCommandEvent& event)
#endif
}
/****************************************/
void WinEDA_PrintFrame::SetPenWidth()
/****************************************/
/* 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();
@ -328,24 +353,29 @@ void WinEDA_PrintFrame::SetPenWidth()
/**********************************************************/
void WinEDA_PrintFrame::OnPrintSetup( wxCommandEvent& event )
/**********************************************************/
/* Open a dialog box for printer setup (printer options, page size ...)
*/
{
wxPrintDialogData printDialogData( * g_PrintData );
if( printDialogData.Ok() )
{
wxPrintDialog printerDialog( this,& printDialogData );
printerDialog.ShowModal();
*g_PrintData = printerDialog.GetPrintDialogData().GetPrintData();
}
else DisplayError(this, _("Printer Problem!") );
else
DisplayError( this, _( "Printer Problem!" ) );
}
/************************************************************/
void WinEDA_PrintFrame::OnPrintPreview( wxCommandEvent& event )
/************************************************************/
/* Open and display a previewer frame for printing
*/
{
@ -368,13 +398,15 @@ wxString title = BuildPrintTitle();
wxPrintPreview* preview =
new wxPrintPreview( new EDA_Printout (this, m_Parent, title, print_ref),
new EDA_Printout (this, m_Parent, title, print_ref), g_PrintData );
if( preview == NULL )
{
DisplayError( this, _( "There was a problem previewing" ) );
return;
}
#ifdef PCBNEW
if ( s_OptionPrintPage ) SetLayerMaskFromListSelection();
if( s_OptionPrintPage )
SetLayerMaskFromListSelection();
#endif
m_Parent->GetPosition( &x, &y );
@ -387,6 +419,7 @@ wxString title = BuildPrintTitle();
wxPreviewFrame* frame = new wxPreviewFrame( preview, this,
title, WPos, WSize );
frame->Initialize();
frame->Show( TRUE );
}
@ -395,6 +428,7 @@ wxString title = BuildPrintTitle();
/**********************************************************/
void WinEDA_PrintFrame::EDA_PrintPage( wxCommandEvent& event )
/**********************************************************/
/* Called on activate "Print CURRENT" button
*/
{
@ -410,7 +444,8 @@ bool print_ref = TRUE;
print_ref = FALSE;
#ifdef PCBNEW
if ( s_OptionPrintPage ) SetLayerMaskFromListSelection();
if( s_OptionPrintPage )
SetLayerMaskFromListSelection();
#endif
SetPenWidth();
@ -440,7 +475,6 @@ wxString title = BuildPrintTitle();
}
/***************************************/
bool EDA_Printout::OnPrintPage( int page )
/***************************************/
@ -461,7 +495,8 @@ BASE_SCREEN *oldscreen = screen;
screen = ScreenList.GetScreen( page - 1 );
}
if (screen == NULL) return FALSE;
if( screen == NULL )
return FALSE;
ActiveScreen = (SCH_SCREEN*) screen;
DrawPage();
ActiveScreen = (SCH_SCREEN*) oldscreen;
@ -478,7 +513,8 @@ BASE_SCREEN *oldscreen = screen;
int ii, jj, mask = 1;
for( ii = 0, jj = 0; ii < NB_LAYERS; ii++ )
{
if ( s_PrintMaskLayer & mask ) jj++;
if( s_PrintMaskLayer & mask )
jj++;
if( jj == page )
{
s_PrintMaskLayer = mask;
@ -486,7 +522,9 @@ BASE_SCREEN *oldscreen = screen;
}
mask <<= 1;
}
if ( ii == NB_LAYERS ) return FALSE;
if( ii == NB_LAYERS )
return FALSE;
}
}
DrawPage();
@ -495,12 +533,14 @@ BASE_SCREEN *oldscreen = screen;
return TRUE;
}
/*********************************************************/
void EDA_Printout::GetPageInfo( int* minPage, int* maxPage,
int* selPageFrom, int* selPageTo )
/*********************************************************/
{
int ii = 1;
*minPage = 1;
*selPageFrom = 1;
@ -513,15 +553,18 @@ int ii = 1;
#endif
#ifdef PCBNEW
switch( s_OptionPrintPage )
{
case 0 :ii = m_PrintFrame->SetLayerMaskFromListSelection();
case 0:
ii = m_PrintFrame->SetLayerMaskFromListSelection();
break;
case 1:
ii = 1;
break;
}
#endif
*maxPage = ii;
@ -538,7 +581,8 @@ int PageCount;
EDA_ScreenList ScreenList;
PageCount = ScreenList.GetCount();
if( PageCount >= pageNum ) return TRUE;
if( PageCount >= pageNum )
return TRUE;
return FALSE;
#endif
@ -548,6 +592,7 @@ int PageCount;
#endif
}
/*************************************************************/
bool EDA_Printout::OnBeginDocument( int startPage, int endPage )
/*************************************************************/
@ -558,11 +603,13 @@ bool EDA_Printout::OnBeginDocument(int startPage, int endPage)
return TRUE;
}
/********************************/
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;
@ -612,8 +659,8 @@ wxDC * dc = GetDC();
userscale = 0.99;
}
if ( (s_ScaleList[s_Scale_Select] > 1.0) || // scale > 1 -> Recadrage
(s_ScaleList[s_Scale_Select] == 0) ) // fit in page
if( (s_ScaleList[s_Scale_Select] > 1.0) // scale > 1 -> Recadrage
|| (s_ScaleList[s_Scale_Select] == 0) ) // fit in page
{
DrawOffset.x += pcbframe->m_Pcb->m_BoundaryBox.Centre().x;
DrawOffset.y += pcbframe->m_Pcb->m_BoundaryBox.Centre().y;
@ -632,6 +679,7 @@ wxDC * dc = GetDC();
double accurate_Xscale, accurate_Yscale;
dc->SetUserScale( DrawZoom / scale * m_PrintFrame->m_XScaleAdjust,
DrawZoom / scale * m_PrintFrame->m_YScaleAdjust );
// Compute Accurate scale 1
{
int w, h;
@ -654,8 +702,8 @@ double accurate_Xscale, accurate_Yscale;
#endif
#ifdef PCBNEW
if ( (s_ScaleList[s_Scale_Select] > 1.0) || // scale > 1 -> Recadrage
(s_ScaleList[s_Scale_Select] == 0) ) // fit in page
if( (s_ScaleList[s_Scale_Select] > 1.0) // scale > 1 -> Recadrage
|| (s_ScaleList[s_Scale_Select] == 0) ) // fit in page
{
DrawOffset.x -= (int) ( (PlotAreaSize.x / 2) * scale );
DrawOffset.y -= (int) ( (PlotAreaSize.y / 3) * scale );
@ -667,17 +715,20 @@ double accurate_Xscale, accurate_Yscale;
ActiveScreen->m_DrawOrg = DrawOffset;
GRResetPenAndBrush( dc );
if( s_Print_Black_and_White ) GRForceBlackPen(TRUE);
if( s_Print_Black_and_White )
GRForceBlackPen( TRUE );
#ifdef EESCHEMA
/* set Pen min width */
double ftmp, xdcscale, ydcscale;
// 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) 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
in order to keep the requested value */
* in order to keep the requested value */
dc->GetUserScale( &xdcscale, &ydcscale );
ftmp /= xdcscale;
SetPenMinWidth( (int) round( ftmp ) );
@ -713,19 +764,22 @@ EDA_Rect tmp = panel->m_ClipBox;
dc->GetUserScale( &sx, &sy );
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
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
is the y coordinate values from - PlotAreaSize.y to 0 */
* 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
* is the y coordinate values from - PlotAreaSize.y to 0 */
int ysize = (int) ( PlotAreaSize.y / sy );
DrawOffset.y += ysize;
/* in order to keep the board position in the sheet
(when user scale <= 1) the y offset in moved by the distance between
the middle of the page and the middle of the board
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
to the middle of the page.
* (when user scale <= 1) the y offset in moved by the distance between
* the middle of the page and the middle of the board
* 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
* to the middle of the page.
*/
wxPoint pcb_centre = pcbframe->m_Pcb->m_BoundaryBox.Centre();
if( userscale <= 1.0 )
@ -754,4 +808,3 @@ EDA_Rect tmp = panel->m_ClipBox;
ActiveScreen->m_DrawOrg = old_org;
ActiveScreen->SetZoom( tmpzoom );
}