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

see change_log.txt for 2007-Aug-22

This commit is contained in:
dickelbeck 2007-08-23 04:28:46 +00:00
parent 4da2971dcc
commit cc62305777
88 changed files with 9860 additions and 8580 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
3d-viewer/3d_draw.cpp
View File

@ -202,13 +202,14 @@ void Pcb3D_GLCanvas::Draw3D_Track(TRACK * track)
/************************************************/ /************************************************/
{ {
double zpos; double zpos;
int color = g_Parm_3D_Visu.m_BoardSettings->m_LayerColor[track->m_Layer]; int layer = track->GetLayer();
int layer = track->m_Layer; int color = g_Parm_3D_Visu.m_BoardSettings->m_LayerColor[layer];
double ox, oy, fx, fy; double ox, oy, fx, fy;
double w; double w;
if ( color & ITEM_NOT_SHOW ) return; if ( color & ITEM_NOT_SHOW ) return;
if ( track->m_Layer == CMP_N ) layer = g_Parm_3D_Visu.m_Layers -1; if ( layer == CMP_N )
layer = g_Parm_3D_Visu.m_Layers -1;
zpos = g_Parm_3D_Visu.m_LayerZcoord[layer]; zpos = g_Parm_3D_Visu.m_LayerZcoord[layer];
SetGLColor(color); SetGLColor(color);
@ -268,7 +269,7 @@ void Pcb3D_GLCanvas::Draw3D_DrawSegment(DRAWSEGMENT * segment)
int layer; int layer;
double x, y, xf, yf; double x, y, xf, yf;
double zpos, w; double zpos, w;
int color = g_Parm_3D_Visu.m_BoardSettings->m_LayerColor[segment->m_Layer]; int color = g_Parm_3D_Visu.m_BoardSettings->m_LayerColor[segment->GetLayer()];
if ( color & ITEM_NOT_SHOW ) return; if ( color & ITEM_NOT_SHOW ) return;
@ -279,7 +280,7 @@ int color = g_Parm_3D_Visu.m_BoardSettings->m_LayerColor[segment->m_Layer];
xf = segment->m_End.x * g_Parm_3D_Visu.m_BoardScale; xf = segment->m_End.x * g_Parm_3D_Visu.m_BoardScale;
yf = segment->m_End.y * g_Parm_3D_Visu.m_BoardScale; yf = segment->m_End.y * g_Parm_3D_Visu.m_BoardScale;
if ( segment->m_Layer == EDGE_N) if ( segment->GetLayer() == EDGE_N)
{ {
for ( layer = 0; layer < g_Parm_3D_Visu.m_Layers; layer++ ) for ( layer = 0; layer < g_Parm_3D_Visu.m_Layers; layer++ )
{ {
@ -291,7 +292,7 @@ int color = g_Parm_3D_Visu.m_BoardSettings->m_LayerColor[segment->m_Layer];
else else
{ {
zpos = g_Parm_3D_Visu.m_LayerZcoord[segment->m_Layer]; zpos = g_Parm_3D_Visu.m_LayerZcoord[segment->GetLayer()];
Draw3D_FilledSegment( x, -y, xf, -yf, w, zpos); Draw3D_FilledSegment( x, -y, xf, -yf, w, zpos);
} }
} }

30
change_log.txt
View File

@ -5,16 +5,36 @@ Please add newer entries at the top, list the date and your name with
email address. email address.
2007-Aug-23 UPDATE Dick Hollenbeck <dick@softplc.com>
================================================================================
@todo add constructor initializers for classes that were derived from
EDA_BaseLineStruct but are now not. Its late, will do tomorrow.
@todo test yesterday's changes, it builds, may not run right yet.
2007-Aug-22 UPDATE Dick Hollenbeck <dick@softplc.com> 2007-Aug-22 UPDATE Dick Hollenbeck <dick@softplc.com>
================================================================================ ================================================================================
+ eeschema & pcbnew + eeschema & pcbnew
Things are still pretty transient, should be stable a day or two:
* Fixed a filename case sensitivity problem that would show up on Linux * Fixed a filename case sensitivity problem that would show up on Linux
but probably not on Windows: bitmap/Reload.xpm needed uppercase R. but probably not on Windows: bitmap/Reload.xpm needed uppercase R.
* Since so many classes introduced m_Layer, I moved m_Layer into * Wedged a new class BOARD_ITEM underneath all PCB drawable classes, this is
EDA_BaseStruct so all classes can inherit it and that way we can test a big change and may introduce a bug or two, but it is worth it for the
layer using a general, polymorphic test, i.e. don't have to cast a future, because we can introduce virtual functions there that do not impact
EDA_BaseStruct* to a class specific pointer to test layer. Could also have the entire project (since everything is derived from EDA_BaseStruct).
used a virtual function but too many places use m_Layer directly. The corresponding class in EESCHEMA seems to be DrawPartStruct, so we had
nothing in PCBNEW like that.
BOARD_ITEM::GetLayer() and SetLayer() introduced, more functions to come.
Much of this work is geared towards making collectors.cpp's ARROWCOLLECTOR::Inspect()
very very simple, and that can be model for future work.
* Changed min() and max() macros to MIN() and MAX() because min() and max()
are actually reserved according to the C++ standard! (and their usage prevented
the use of #include <vector>).
* Added files class_collector.h, collectors.h, and collectors.cpp.
File collectors.cpp is still unfinished.
* Started using a function and class comment style that will make sense to the
Doxygen source code documenter program.
* Beautified more un-beautified files.
2007-aug-21 UPDATE Jean-Pierre Charras <jean-pierre.charras@inpg.fr> 2007-aug-21 UPDATE Jean-Pierre Charras <jean-pierre.charras@inpg.fr>

2
common/base_struct.cpp
View File

@ -106,7 +106,6 @@ void EDA_BaseStruct::InitVars( void )
m_TimeStamp = 0; // Time stamp used for logical links m_TimeStamp = 0; // Time stamp used for logical links
m_Status = 0; m_Status = 0;
m_Selected = 0; /* Used by block commands, and selective editing */ m_Selected = 0; /* Used by block commands, and selective editing */
m_Layer = 0;
} }
@ -283,6 +282,7 @@ std::ostream& EDA_BaseStruct::NestedSpace( int nestLevel, std::ostream& os )
#endif #endif
/**********************************************************************************************/ /**********************************************************************************************/
EDA_BaseLineStruct::EDA_BaseLineStruct( EDA_BaseStruct* StructFather, DrawStructureType idtype ) : EDA_BaseLineStruct::EDA_BaseLineStruct( EDA_BaseStruct* StructFather, DrawStructureType idtype ) :
EDA_BaseStruct( StructFather, idtype ) EDA_BaseStruct( StructFather, idtype )

42
eeschema/class_hierarchy_sheet.cpp
View File

@ -1,4 +1,5 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: sheet.cpp // Name: sheet.cpp
// Purpose: // Purpose:
// Author: jean-pierre Charras // Author: jean-pierre Charras
@ -45,8 +46,9 @@ DrawSheetStruct::DrawSheetStruct(const wxPoint & pos) :
m_StructType = DRAW_SHEET_STRUCT_TYPE; m_StructType = DRAW_SHEET_STRUCT_TYPE;
} }
/**************************************/ /**************************************/
DrawSheetStruct::~DrawSheetStruct(void) DrawSheetStruct::~DrawSheetStruct()
/**************************************/ /**************************************/
{ {
DrawSheetLabelStruct* label = m_Label, * next_label; DrawSheetLabelStruct* label = m_Label, * next_label;
@ -63,11 +65,13 @@ DrawSheetLabelStruct * label = m_Label, * next_label;
/***********************************************/ /***********************************************/
DrawSheetStruct* DrawSheetStruct::GenCopy( void ) DrawSheetStruct* DrawSheetStruct::GenCopy( void )
/***********************************************/ /***********************************************/
/* creates a copy of a sheet /* creates a copy of a sheet
The linked data itself (EEDrawList) is not duplicated * The linked data itself (EEDrawList) is not duplicated
*/ */
{ {
DrawSheetStruct* newitem = new DrawSheetStruct( m_Pos ); DrawSheetStruct* newitem = new DrawSheetStruct( m_Pos );
DrawSheetLabelStruct* Slabel = NULL, * label = m_Label; DrawSheetLabelStruct* Slabel = NULL, * label = m_Label;
newitem->m_Size = m_Size; newitem->m_Size = m_Size;
@ -129,8 +133,9 @@ DrawSheetLabelStruct * Slabel = NULL, * label = m_Label;
/**********************************************************/ /**********************************************************/
void DrawSheetStruct::SwapData( DrawSheetStruct* copyitem ) void DrawSheetStruct::SwapData( DrawSheetStruct* copyitem )
/**********************************************************/ /**********************************************************/
/* Used if undo / redo command: /* Used if undo / redo command:
swap data between this and copyitem * swap data between this and copyitem
*/ */
{ {
EXCHG( m_Pos, copyitem->m_Pos ); EXCHG( m_Pos, copyitem->m_Pos );
@ -142,6 +147,7 @@ void DrawSheetStruct::SwapData(DrawSheetStruct * copyitem)
EXCHG( m_NbLabel, copyitem->m_NbLabel ); EXCHG( m_NbLabel, copyitem->m_NbLabel );
} }
/**************************************************************************************/ /**************************************************************************************/
void DrawSheetStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset, void DrawSheetStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset,
int DrawMode, int Color ) int DrawMode, int Color )
@ -155,16 +161,20 @@ int color;
wxPoint pos = m_Pos + offset; wxPoint pos = m_Pos + offset;
int LineWidth = g_DrawMinimunLineWidth; int LineWidth = g_DrawMinimunLineWidth;
if( Color >= 0 ) color = Color; if( Color >= 0 )
else color = ReturnLayerColor(m_Layer); color = Color;
else
color = ReturnLayerColor( m_Layer );
GRSetDrawMode( DC, DrawMode ); GRSetDrawMode( DC, DrawMode );
GRRect( &panel->m_ClipBox, DC, pos.x, pos.y, GRRect( &panel->m_ClipBox, DC, pos.x, pos.y,
pos.x + m_Size.x, pos.y + m_Size.y, LineWidth, color ); pos.x + m_Size.x, pos.y + m_Size.y, LineWidth, color );
/* Draw text : SheetName */ /* Draw text : SheetName */
if( Color > 0 ) txtcolor = Color; if( Color > 0 )
else txtcolor = ReturnLayerColor(LAYER_SHEETNAME); txtcolor = Color;
else
txtcolor = ReturnLayerColor( LAYER_SHEETNAME );
Text = wxT( "Sheet: " ) + m_SheetName; Text = wxT( "Sheet: " ) + m_SheetName;
DrawGraphicText( panel, DC, DrawGraphicText( panel, DC,
@ -173,8 +183,10 @@ int LineWidth = g_DrawMinimunLineWidth;
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_BOTTOM, LineWidth ); GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_BOTTOM, LineWidth );
/* Draw text : FileName */ /* Draw text : FileName */
if( Color >= 0 ) txtcolor = Color; if( Color >= 0 )
else txtcolor = ReturnLayerColor(LAYER_SHEETFILENAME); txtcolor = Color;
else
txtcolor = ReturnLayerColor( LAYER_SHEETFILENAME );
Text = wxT( "File: " ) + m_FileName; Text = wxT( "File: " ) + m_FileName;
DrawGraphicText( panel, DC, DrawGraphicText( panel, DC,
wxPoint( pos.x, pos.y + m_Size.y + 4 ), wxPoint( pos.x, pos.y + m_Size.y + 4 ),
@ -212,6 +224,7 @@ DrawSheetLabelStruct::DrawSheetLabelStruct(DrawSheetStruct * parent,
m_IsDangling = TRUE; m_IsDangling = TRUE;
} }
/***********************************************************/ /***********************************************************/
DrawSheetLabelStruct* DrawSheetLabelStruct::GenCopy( void ) DrawSheetLabelStruct* DrawSheetLabelStruct::GenCopy( void )
/***********************************************************/ /***********************************************************/
@ -226,7 +239,6 @@ DrawSheetLabelStruct * newitem =
} }
/********************************************************************************************/ /********************************************************************************************/
void DrawSheetLabelStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset, void DrawSheetLabelStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset,
int DrawMode, int Color ) int DrawMode, int Color )
@ -239,8 +251,10 @@ wxSize size;
int NbSegm, coord[20]; int NbSegm, coord[20];
int LineWidth = g_DrawMinimunLineWidth; int LineWidth = g_DrawMinimunLineWidth;
if( Color >= 0 ) txtcolor = Color; if( Color >= 0 )
else txtcolor = ReturnLayerColor(m_Layer); txtcolor = Color;
else
txtcolor = ReturnLayerColor( m_Layer );
GRSetDrawMode( DC, DrawMode ); GRSetDrawMode( DC, DrawMode );
posx = m_Pos.x + offset.x; posy = m_Pos.y + offset.y; size = m_Size; posx = m_Pos.x + offset.x; posy = m_Pos.y + offset.y; size = m_Size;
@ -270,6 +284,7 @@ int LineWidth = g_DrawMinimunLineWidth;
coord[0] = posx; coord[1] = posy; size2 = size.x / 2; coord[0] = posx; coord[1] = posy; size2 = size.x / 2;
NbSegm = 0; NbSegm = 0;
switch( m_Shape ) switch( m_Shape )
{ {
case 0: /* input |> */ case 0: /* input |> */
@ -309,8 +324,7 @@ int LineWidth = g_DrawMinimunLineWidth;
NbSegm = 6; NbSegm = 6;
break; break;
} }
int FillShape = FALSE; int FillShape = FALSE;
GRPoly( &panel->m_ClipBox, DC, NbSegm, coord, FillShape, LineWidth, txtcolor, txtcolor ); /* Poly Non rempli */ GRPoly( &panel->m_ClipBox, DC, NbSegm, coord, FillShape, LineWidth, txtcolor, txtcolor ); /* Poly Non rempli */
} }

5
eeschema/class_screen.h
View File

@ -107,10 +107,10 @@ public:
}; };
class DrawSheetLabelStruct : public EDA_BaseStruct class DrawSheetLabelStruct : public EDA_BaseStruct, public EDA_TextStruct
, public EDA_TextStruct
{ {
public: public:
int m_Layer;
int m_Edge, m_Shape; int m_Edge, m_Shape;
bool m_IsDangling; // TRUE si non connecté bool m_IsDangling; // TRUE si non connecté
@ -141,6 +141,7 @@ public:
int m_FileNameSize; int m_FileNameSize;
wxPoint m_Pos; wxPoint m_Pos;
wxSize m_Size; /* Position and Size of sheet symbol */ wxSize m_Size; /* Position and Size of sheet symbol */
int m_Layer;
DrawSheetLabelStruct* m_Label; /* Points de connection */ DrawSheetLabelStruct* m_Label; /* Points de connection */
int m_NbLabel; /* Nombre de points de connexion */ int m_NbLabel; /* Nombre de points de connexion */

33
eeschema/cmpclass.cpp
View File

@ -14,13 +14,11 @@
#include "protos.h" #include "protos.h"
/*******************************************************************/ /*******************************************************************/
DrawBusEntryStruct::DrawBusEntryStruct( const wxPoint& pos, int shape, int id ) : DrawBusEntryStruct::DrawBusEntryStruct( const wxPoint& pos, int shape, int id ) :
EDA_BaseStruct( DRAW_BUSENTRY_STRUCT_TYPE ) EDA_BaseStruct( DRAW_BUSENTRY_STRUCT_TYPE )
/*******************************************************************/ /*******************************************************************/
{ {
m_Pos = pos; m_Pos = pos;
m_Size.x = 100; m_Size.x = 100;
m_Size.y = 100; m_Size.y = 100;
@ -33,19 +31,21 @@ DrawBusEntryStruct::DrawBusEntryStruct(const wxPoint & pos, int shape, int id) :
m_Width = 1; m_Width = 1;
} }
if(shape == '/' ) m_Size.y = - 100; if( shape == '/' )
m_Size.y = -100;
} }
/*************************************/ /*************************************/
wxPoint DrawBusEntryStruct::m_End( void ) wxPoint DrawBusEntryStruct::m_End( void )
/*************************************/ /*************************************/
// retourne la coord de fin du raccord // retourne la coord de fin du raccord
{ {
return ( wxPoint(m_Pos.x + m_Size.x, m_Pos.y + m_Size.y) ); return wxPoint( m_Pos.x + m_Size.x, m_Pos.y + m_Size.y );
} }
/***************************************************/ /***************************************************/
DrawBusEntryStruct* DrawBusEntryStruct::GenCopy( void ) DrawBusEntryStruct* DrawBusEntryStruct::GenCopy( void )
/***************************************************/ /***************************************************/
@ -74,6 +74,7 @@ DrawJunctionStruct::DrawJunctionStruct(const wxPoint & pos) :
m_Layer = LAYER_JUNCTION; m_Layer = LAYER_JUNCTION;
} }
DrawJunctionStruct* DrawJunctionStruct::GenCopy( void ) DrawJunctionStruct* DrawJunctionStruct::GenCopy( void )
{ {
DrawJunctionStruct* newitem = new DrawJunctionStruct( m_Pos ); DrawJunctionStruct* newitem = new DrawJunctionStruct( m_Pos );
@ -95,6 +96,7 @@ DrawNoConnectStruct::DrawNoConnectStruct(const wxPoint & pos) :
m_Pos = pos; m_Pos = pos;
} }
DrawNoConnectStruct* DrawNoConnectStruct::GenCopy( void ) DrawNoConnectStruct* DrawNoConnectStruct::GenCopy( void )
{ {
DrawNoConnectStruct* newitem = new DrawNoConnectStruct( m_Pos ); DrawNoConnectStruct* newitem = new DrawNoConnectStruct( m_Pos );
@ -118,13 +120,16 @@ DrawMarkerStruct::DrawMarkerStruct( const wxPoint & pos, const wxString & text):
m_Comment = text; m_Comment = text;
} }
DrawMarkerStruct::~DrawMarkerStruct( void ) DrawMarkerStruct::~DrawMarkerStruct( void )
{ {
} }
DrawMarkerStruct* DrawMarkerStruct::GenCopy( void ) DrawMarkerStruct* DrawMarkerStruct::GenCopy( void )
{ {
DrawMarkerStruct* newitem = new DrawMarkerStruct( m_Pos, m_Comment ); DrawMarkerStruct* newitem = new DrawMarkerStruct( m_Pos, m_Comment );
newitem->m_Type = m_Type; newitem->m_Type = m_Type;
newitem->m_MarkFlags = m_MarkFlags; newitem->m_MarkFlags = m_MarkFlags;
@ -160,6 +165,7 @@ EDA_DrawLineStruct::EDA_DrawLineStruct(const wxPoint & pos, int layer ):
m_Layer = LAYER_WIRE; m_Layer = LAYER_WIRE;
m_Width = GR_NORM_WIDTH; m_Width = GR_NORM_WIDTH;
break; break;
case LAYER_BUS: case LAYER_BUS:
m_Layer = LAYER_BUS; m_Layer = LAYER_BUS;
m_Width = GR_THICK_WIDTH; m_Width = GR_THICK_WIDTH;
@ -167,6 +173,7 @@ EDA_DrawLineStruct::EDA_DrawLineStruct(const wxPoint & pos, int layer ):
} }
} }
/***************************************************/ /***************************************************/
EDA_DrawLineStruct* EDA_DrawLineStruct::GenCopy( void ) EDA_DrawLineStruct* EDA_DrawLineStruct::GenCopy( void )
/***************************************************/ /***************************************************/
@ -178,17 +185,22 @@ EDA_DrawLineStruct * newitem = new EDA_DrawLineStruct(m_Start, m_Layer);
return newitem; return newitem;
} }
/************************************************************/ /************************************************************/
bool EDA_DrawLineStruct::IsOneEndPointAt( const wxPoint& pos ) bool EDA_DrawLineStruct::IsOneEndPointAt( const wxPoint& pos )
/************************************************************/ /************************************************************/
/* Return TRUE if the start or the end point is in position pos /* Return TRUE if the start or the end point is in position pos
*/ */
{ {
if ( (pos.x == m_Start.x) && (pos.y == m_Start.y) ) return TRUE; if( (pos.x == m_Start.x) && (pos.y == m_Start.y) )
if ( (pos.x == m_End.x) && (pos.y == m_End.y) ) return TRUE; return TRUE;
if( (pos.x == m_End.x) && (pos.y == m_End.y) )
return TRUE;
return FALSE; return FALSE;
} }
/****************************/ /****************************/
/* Class DrawPolylineStruct */ /* Class DrawPolylineStruct */
/****************************/ /****************************/
@ -225,9 +237,11 @@ DrawPolylineStruct::DrawPolylineStruct(int layer):
DrawPolylineStruct::~DrawPolylineStruct( void ) DrawPolylineStruct::~DrawPolylineStruct( void )
/*********************************************/ /*********************************************/
{ {
if ( m_Points ) free ( m_Points ); if( m_Points )
free( m_Points );
} }
/*****************************************************/ /*****************************************************/
DrawPolylineStruct* DrawPolylineStruct::GenCopy( void ) DrawPolylineStruct* DrawPolylineStruct::GenCopy( void )
/*****************************************************/ /*****************************************************/
@ -244,6 +258,3 @@ DrawPolylineStruct * newitem =
return newitem; return newitem;
} }

3
eeschema/component_class.h
View File

@ -39,6 +39,7 @@ typedef enum
class PartTextStruct: public EDA_BaseStruct, public EDA_TextStruct class PartTextStruct: public EDA_BaseStruct, public EDA_TextStruct
{ {
public: public:
int m_Layer;
int m_FieldId; int m_FieldId;
wxString m_Name; /* Field name (ref, value,pcb, sheet, filed 1.. wxString m_Name; /* Field name (ref, value,pcb, sheet, filed 1..
and for fields 1 to 8 the name is editable */ and for fields 1 to 8 the name is editable */
@ -54,6 +55,7 @@ public:
void SwapData(PartTextStruct * copyitem); void SwapData(PartTextStruct * copyitem);
}; };
/* the class DrawPartStruct describes a basic virtual component /* the class DrawPartStruct describes a basic virtual component
Not used directly: Not used directly:
used classes are EDA_SchComponentStruct (the "classic" schematic component used classes are EDA_SchComponentStruct (the "classic" schematic component
@ -62,6 +64,7 @@ public:
class DrawPartStruct: public EDA_BaseStruct class DrawPartStruct: public EDA_BaseStruct
{ {
public: public:
int m_Layer;
wxString m_ChipName; /* Key to look for in the library, i.e. "74LS00". */ wxString m_ChipName; /* Key to look for in the library, i.e. "74LS00". */
PartTextStruct m_Field[NUMBER_OF_FIELDS]; PartTextStruct m_Field[NUMBER_OF_FIELDS];
wxPoint m_Pos; /* Exact position of part. */ wxPoint m_Pos; /* Exact position of part. */

6
eeschema/program.h
View File

@ -106,6 +106,7 @@ class DrawBusEntryStruct: public EDA_BaseStruct /* Struct de descr 1 raccord
a 45 degres de BUS ou WIRE */ a 45 degres de BUS ou WIRE */
{ {
public: public:
int m_Layer;
int m_Width; int m_Width;
wxPoint m_Pos; wxPoint m_Pos;
wxSize m_Size; wxSize m_Size;
@ -121,6 +122,7 @@ public:
class DrawPolylineStruct: public EDA_BaseStruct /* Polyligne (serie de segments) */ class DrawPolylineStruct: public EDA_BaseStruct /* Polyligne (serie de segments) */
{ {
public: public:
int m_Layer;
int m_Width; int m_Width;
int m_NumOfPoints; /* Number of XY pairs in Points array. */ int m_NumOfPoints; /* Number of XY pairs in Points array. */
int *m_Points; /* XY pairs that forms the polyline. */ int *m_Points; /* XY pairs that forms the polyline. */
@ -135,6 +137,7 @@ public:
class DrawJunctionStruct: public EDA_BaseStruct class DrawJunctionStruct: public EDA_BaseStruct
{ {
public: public:
int m_Layer;
wxPoint m_Pos; /* XY coordinates of connection. */ wxPoint m_Pos; /* XY coordinates of connection. */
public: public:
@ -147,6 +150,7 @@ public:
class DrawTextStruct: public EDA_BaseStruct, public EDA_TextStruct class DrawTextStruct: public EDA_BaseStruct, public EDA_TextStruct
{ {
public: public:
int m_Layer;
int m_Shape; int m_Shape;
bool m_IsDangling; // TRUE si non connecté bool m_IsDangling; // TRUE si non connecté
@ -163,6 +167,7 @@ private:
void DrawAsGlobalLabel(WinEDA_DrawPanel * panel, wxDC * DC, const wxPoint & offset, int draw_mode, int Color); void DrawAsGlobalLabel(WinEDA_DrawPanel * panel, wxDC * DC, const wxPoint & offset, int draw_mode, int Color);
}; };
class DrawLabelStruct: public DrawTextStruct class DrawLabelStruct: public DrawTextStruct
{ {
public: public:
@ -170,6 +175,7 @@ public:
~DrawLabelStruct(void) {} ~DrawLabelStruct(void) {}
}; };
class DrawGlobalLabelStruct: public DrawTextStruct class DrawGlobalLabelStruct: public DrawTextStruct
{ {
public: public:

28
gerbview/affiche.cpp
View File

@ -15,9 +15,10 @@
/****************************************************************************/ /****************************************************************************/
void Affiche_Infos_PCB_Texte( WinEDA_BasePcbFrame* frame, TEXTE_PCB* pt_texte ) void Affiche_Infos_PCB_Texte( WinEDA_BasePcbFrame* frame, TEXTE_PCB* pt_texte )
/****************************************************************************/ /****************************************************************************/
/* Affiche en bas d'ecran les caract du texte sur PCB /* Affiche en bas d'ecran les caract du texte sur PCB
Entree : * Entree :
pointeur de la description du texte * pointeur de la description du texte
*/ */
{ {
wxString Line; wxString Line;
@ -30,13 +31,18 @@ wxString Line;
else else
Affiche_1_Parametre( frame, 1, _( "PCB Text" ), pt_texte->m_Text, DARKGREEN ); Affiche_1_Parametre( frame, 1, _( "PCB Text" ), pt_texte->m_Text, DARKGREEN );
Line = _("Layer "); Line << pt_texte->m_Layer + 1; Line = _( "Layer " );
Affiche_1_Parametre(frame, 28, _("Layer:"), Line, g_DesignSettings.m_LayerColor[pt_texte->m_Layer] ); Line << pt_texte->GetLayer() + 1;
Affiche_1_Parametre( frame, 28, _( "Layer:" ), Line,
g_DesignSettings.m_LayerColor[pt_texte->GetLayer()] );
Affiche_1_Parametre( frame, 36, _( "Mirror" ), wxEmptyString, GREEN ); Affiche_1_Parametre( frame, 36, _( "Mirror" ), wxEmptyString, GREEN );
if( (pt_texte->m_Miroir & 1) ) if( (pt_texte->m_Miroir & 1) )
Affiche_1_Parametre( frame, -1, wxEmptyString, _( "No" ), DARKGREEN ); Affiche_1_Parametre( frame, -1, wxEmptyString, _( "No" ), DARKGREEN );
else Affiche_1_Parametre(frame, -1,wxEmptyString, _("Yes"), DARKGREEN) ; else
Affiche_1_Parametre( frame, -1, wxEmptyString, _( "Yes" ), DARKGREEN );
Line.Printf( wxT( "%.1f" ), (float) pt_texte->m_Orient / 10 ); Line.Printf( wxT( "%.1f" ), (float) pt_texte->m_Orient / 10 );
@ -50,11 +56,9 @@ wxString Line;
valeur_param( pt_texte->m_Size.y, Line ); valeur_param( pt_texte->m_Size.y, Line );
Affiche_1_Parametre( frame, 70, _( "V Size" ), Line, RED ); Affiche_1_Parametre( frame, 70, _( "V Size" ), Line, RED );
} }
/*********************************************************************/ /*********************************************************************/
void Affiche_Infos_Piste( WinEDA_BasePcbFrame* frame, TRACK* pt_piste ) void Affiche_Infos_Piste( WinEDA_BasePcbFrame* frame, TRACK* pt_piste )
/*********************************************************************/ /*********************************************************************/
@ -73,8 +77,10 @@ wxString msg;
switch( pt_piste->m_StructType ) switch( pt_piste->m_StructType )
{ {
case TYPETRACK: case TYPETRACK:
if ( pt_piste->m_Shape < S_SPOT_CIRCLE ) msg = wxT("LINE"); if( pt_piste->m_Shape < S_SPOT_CIRCLE )
else msg = wxT("FLASH"); msg = wxT( "LINE" );
else
msg = wxT( "FLASH" );
break; break;
case TYPEZONE: case TYPEZONE:
@ -83,6 +89,7 @@ wxString msg;
default: default:
msg = wxT( "????" ); break; msg = wxT( "????" ); break;
} }
Affiche_1_Parametre( frame, 1, _( "Type" ), msg, DARKCYAN ); Affiche_1_Parametre( frame, 1, _( "Type" ), msg, DARKCYAN );
msg.Printf( wxT( "%d" ), ii + 1 ); msg.Printf( wxT( "%d" ), ii + 1 );
@ -98,11 +105,10 @@ wxString msg;
BLUE ); BLUE );
} }
msg.Printf( wxT("%d"),pt_piste->m_Layer + 1); msg.Printf( wxT( "%d" ), pt_piste->GetLayer() + 1 );
Affiche_1_Parametre( frame, 40, _( "Layer" ), msg, BROWN ); Affiche_1_Parametre( frame, 40, _( "Layer" ), msg, BROWN );
/* Affiche Epaisseur */ /* Affiche Epaisseur */
valeur_param( (unsigned) (pt_piste->m_Width), msg ); valeur_param( (unsigned) (pt_piste->m_Width), msg );
Affiche_1_Parametre( frame, 50, _( "Width" ), msg, DARKCYAN ); Affiche_1_Parametre( frame, 50, _( "Width" ), msg, DARKCYAN );
} }

6
gerbview/dcode.cpp
View File

@ -340,7 +340,7 @@ D_CODE * pt_Dcode; /* Pointeur sur le D code*/
track = m_Pcb->m_Track; track = m_Pcb->m_Track;
for ( ; track != NULL ; track = (TRACK*) track->Pnext ) for ( ; track != NULL ; track = (TRACK*) track->Pnext )
{ {
pt_Dcode = ReturnToolDescr(track->m_Layer, track->m_NetCode); pt_Dcode = ReturnToolDescr(track->GetLayer(), track->m_NetCode);
pt_Dcode->m_InUse = TRUE; pt_Dcode->m_InUse = TRUE;
if ( // Line Item if ( // Line Item
@ -359,8 +359,8 @@ D_CODE * pt_Dcode; /* Pointeur sur le D code*/
int width, len; int width, len;
wxSize size = pt_Dcode->m_Size; wxSize size = pt_Dcode->m_Size;
width = min( size.x, size.y ); width = MIN( size.x, size.y );
len = max( size.x, size.y ) - width; len = MAX( size.x, size.y ) - width;
track->m_Width = width; track->m_Width = width;

2
gerbview/deltrack.cpp
View File

@ -30,7 +30,7 @@ void WinEDA_GerberFrame::Delete_DCode_Items( wxDC* DC, int dcode_value, int laye
next_track = track->Next(); next_track = track->Next();
if( dcode_value != track->m_NetCode ) if( dcode_value != track->m_NetCode )
continue; continue;
if( layer_number >= 0 && layer_number != track->m_Layer ) if( layer_number >= 0 && layer_number != track->GetLayer() )
continue; continue;
Delete_Segment( DC, track ); Delete_Segment( DC, track );
} }

59
gerbview/export_to_pcbnew.cpp
View File

@ -1,6 +1,7 @@
/* export_to_pcbnew.cpp */ /* export_to_pcbnew.cpp */
/* /*
Export des couches vers pcbnew * Export des couches vers pcbnew
*/ */
#include "fctsys.h" #include "fctsys.h"
@ -20,11 +21,14 @@ static int SavePcbFormatAscii(WinEDA_GerberFrame * frame,
/************************************************************************/ /************************************************************************/
void WinEDA_GerberFrame::ExportDataInPcbnewFormat( wxCommandEvent& event ) void WinEDA_GerberFrame::ExportDataInPcbnewFormat( wxCommandEvent& event )
/************************************************************************/ /************************************************************************/
/* Export data in pcbnew format /* Export data in pcbnew format
*/ */
{ {
wxString FullFileName, msg; wxString FullFileName, msg;
wxString PcbExt( wxT( ".brd" ) ); wxString PcbExt( wxT( ".brd" ) );
FILE* dest; FILE* dest;
msg = wxT( "*" ) + PcbExt; msg = wxT( "*" ) + PcbExt;
@ -37,7 +41,8 @@ FILE * dest;
wxFD_SAVE, wxFD_SAVE,
FALSE FALSE
); );
if ( FullFileName == wxEmptyString ) return; if( FullFileName == wxEmptyString )
return;
int* LayerLookUpTable; int* LayerLookUpTable;
if( ( LayerLookUpTable = InstallDialogLayerPairChoice( this ) ) != NULL ) if( ( LayerLookUpTable = InstallDialogLayerPairChoice( this ) ) != NULL )
@ -75,9 +80,10 @@ char text[1024];
fprintf( File, "Layers %d\n", g_DesignSettings.m_CopperLayerCount ); fprintf( File, "Layers %d\n", g_DesignSettings.m_CopperLayerCount );
fprintf( File, "$EndSETUP\n\n" ); fprintf( File, "$EndSETUP\n\n" );
return(1); return 1;
} }
/******************************************************/ /******************************************************/
static bool WriteGeneralDescrPcb( BOARD* Pcb, FILE* File ) static bool WriteGeneralDescrPcb( BOARD* Pcb, FILE* File )
/******************************************************/ /******************************************************/
@ -105,15 +111,17 @@ int NbLayers;
static int SavePcbFormatAscii( WinEDA_GerberFrame* frame, FILE* File, static int SavePcbFormatAscii( WinEDA_GerberFrame* frame, FILE* File,
int* LayerLookUpTable ) int* LayerLookUpTable )
/*******************************************************************/ /*******************************************************************/
/* Routine de sauvegarde du PCB courant sous format ASCII /* Routine de sauvegarde du PCB courant sous format ASCII
retourne * retourne
1 si OK * 1 si OK
0 si sauvegarde non faite * 0 si sauvegarde non faite
*/ */
{ {
char Line[256]; char Line[256];
TRACK* track, * next_track; TRACK* track, * next_track;
EDA_BaseStruct * PtStruct, *NextStruct; BOARD_ITEM* PtStruct;
BOARD_ITEM* NextStruct;
BOARD* GerberPcb = frame->m_Pcb; BOARD* GerberPcb = frame->m_Pcb;
BOARD* Pcb; BOARD* Pcb;
@ -121,15 +129,18 @@ BOARD * Pcb;
/* Create an image of gerber data */ /* Create an image of gerber data */
Pcb = new BOARD( NULL, frame ); Pcb = new BOARD( NULL, frame );
for( track = GerberPcb->m_Track; track != NULL; track = (TRACK*) track->Pnext ) for( track = GerberPcb->m_Track; track != NULL; track = (TRACK*) track->Pnext )
{ {
int layer = track->m_Layer; int layer = track->GetLayer();
int pcb_layer_number = LayerLookUpTable[layer]; int pcb_layer_number = LayerLookUpTable[layer];
if ( pcb_layer_number < 0 ) continue; if( pcb_layer_number < 0 )
continue;
if( pcb_layer_number > CMP_N ) if( pcb_layer_number > CMP_N )
{ {
DRAWSEGMENT* drawitem = new DRAWSEGMENT( NULL, TYPEDRAWSEGMENT ); DRAWSEGMENT* drawitem = new DRAWSEGMENT( NULL, TYPEDRAWSEGMENT );
drawitem->m_Layer = pcb_layer_number;
drawitem->SetLayer( pcb_layer_number );
drawitem->m_Start = track->m_Start; drawitem->m_Start = track->m_Start;
drawitem->m_End = track->m_End; drawitem->m_End = track->m_End;
drawitem->m_Width = track->m_Width; drawitem->m_Width = track->m_Width;
@ -139,7 +150,8 @@ BOARD * Pcb;
else else
{ {
TRACK* newtrack = new TRACK( * track ); TRACK* newtrack = new TRACK( * track );
newtrack->m_Layer = pcb_layer_number;
newtrack->SetLayer( pcb_layer_number );
newtrack->Insert( Pcb, NULL ); newtrack->Insert( Pcb, NULL );
} }
} }
@ -147,37 +159,42 @@ BOARD * Pcb;
/* replace spots by vias when possible */ /* replace spots by vias when possible */
for( track = Pcb->m_Track; track != NULL; track = (TRACK*) track->Pnext ) for( track = Pcb->m_Track; track != NULL; track = (TRACK*) track->Pnext )
{ {
if( (track->m_Shape != S_SPOT_CIRCLE) && (track->m_Shape != S_SPOT_RECT) && (track->m_Shape != S_SPOT_OVALE) ) if( (track->m_Shape != S_SPOT_CIRCLE) && (track->m_Shape != S_SPOT_RECT) &&
(track->m_Shape != S_SPOT_OVALE) )
continue; continue;
/* A spot is found, and can be a via: change it for via, and delete others /* A spot is found, and can be a via: change it for via, and delete others
spots at same location */ * spots at same location */
track->m_Shape = VIA_NORMALE; track->m_Shape = VIA_NORMALE;
track->m_StructType = TYPEVIA; track->m_StructType = TYPEVIA;
track->m_Layer = 0x0F; // Layers are 0 to 15 (Cu/Cmp) track->SetLayer( 0x0F ); // Layers are 0 to 15 (Cu/Cmp)
track->m_Drill = -1; track->m_Drill = -1;
/* Compute the via position from track position ( Via position is the position of the middle of the track segment */ /* Compute the via position from track position ( Via position is the position of the middle of the track segment */
track->m_Start.x = (track->m_Start.x + track->m_End.x) / 2; track->m_Start.x = (track->m_Start.x + track->m_End.x) / 2;
track->m_Start.y = (track->m_Start.y + track->m_End.y) / 2; track->m_Start.y = (track->m_Start.y + track->m_End.y) / 2;
track->m_End = track->m_Start; track->m_End = track->m_Start;
} }
/* delete redundant vias */ /* delete redundant vias */
for( track = Pcb->m_Track; track != NULL; track = track->Next() ) for( track = Pcb->m_Track; track != NULL; track = track->Next() )
{ {
if( track->m_Shape != VIA_NORMALE ) continue; if( track->m_Shape != VIA_NORMALE )
continue;
/* Search and delete others vias*/ /* Search and delete others vias*/
TRACK* alt_track = track->Next(); TRACK* alt_track = track->Next();
for( ; alt_track != NULL; alt_track = next_track ) for( ; alt_track != NULL; alt_track = next_track )
{ {
next_track = (TRACK*) alt_track->Pnext; next_track = (TRACK*) alt_track->Pnext;
if( alt_track->m_Shape != VIA_NORMALE ) continue; if( alt_track->m_Shape != VIA_NORMALE )
if ( alt_track->m_Start != track->m_Start ) continue; continue;
if( alt_track->m_Start != track->m_Start )
continue;
/* delete track */ /* delete track */
alt_track->UnLink(); alt_track->UnLink();
delete alt_track; delete alt_track;
} }
} }
// Switch the locale to standard C (needed to print floating point numbers like 1.3) // Switch the locale to standard C (needed to print floating point numbers like 1.3)
setlocale( LC_NUMERIC, "C" ); setlocale( LC_NUMERIC, "C" );
/* Ecriture de l'entete PCB : */ /* Ecriture de l'entete PCB : */
@ -188,7 +205,7 @@ BOARD * Pcb;
/* Ecriture des donnes utiles du pcb */ /* Ecriture des donnes utiles du pcb */
PtStruct = Pcb->m_Drawings; PtStruct = Pcb->m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext ) for( ; PtStruct != NULL; PtStruct = PtStruct->Next() )
{ {
switch( PtStruct->m_StructType ) switch( PtStruct->m_StructType )
{ {
@ -218,14 +235,16 @@ BOARD * Pcb;
/* Delete the copy */ /* Delete the copy */
for( PtStruct = Pcb->m_Drawings; PtStruct != NULL; PtStruct = NextStruct ) for( PtStruct = Pcb->m_Drawings; PtStruct != NULL; PtStruct = NextStruct )
{ {
NextStruct = PtStruct->Pnext; NextStruct = PtStruct->Next();
delete PtStruct; delete PtStruct;
} }
for( track = Pcb->m_Track; track != NULL; track = next_track ) for( track = Pcb->m_Track; track != NULL; track = next_track )
{ {
next_track = (TRACK*) track->Pnext; next_track = (TRACK*) track->Pnext;
delete track; delete track;
} }
delete Pcb; delete Pcb;
setlocale( LC_NUMERIC, "" ); // revert to the current locale setlocale( LC_NUMERIC, "" ); // revert to the current locale

88
gerbview/initpcb.cpp
View File

@ -14,23 +14,25 @@
/* Routines Locales */ /* Routines Locales */
/********************************************************/ /********************************************************/
bool WinEDA_GerberFrame::Clear_Pcb( wxDC* DC, bool query ) bool WinEDA_GerberFrame::Clear_Pcb( wxDC* DC, bool query )
/********************************************************/ /********************************************************/
/* Realise les init des pointeurs et variables /* Realise les init des pointeurs et variables
Si Item == NULL, il n'y aura pas de confirmation * Si Item == NULL, il n'y aura pas de confirmation
*/ */
{ {
int layer; int layer;
if( m_Pcb == NULL ) return FALSE; if( m_Pcb == NULL )
return FALSE;
if( query ) if( query )
{ {
if( m_Pcb->m_Drawings || m_Pcb->m_Track || m_Pcb->m_Zone ) if( m_Pcb->m_Drawings || m_Pcb->m_Track || m_Pcb->m_Zone )
{ {
if( ! IsOK(this, _("Current Data will be lost ?")) ) return FALSE; if( !IsOK( this, _( "Current Data will be lost ?" ) ) )
return FALSE;
} }
} }
@ -78,12 +80,13 @@ int layer;
return TRUE; return TRUE;
} }
/*********************************************************/ /*********************************************************/
void WinEDA_GerberFrame::Erase_Zones( wxDC* DC, bool query ) void WinEDA_GerberFrame::Erase_Zones( wxDC* DC, bool query )
/*********************************************************/ /*********************************************************/
{ {
if( query && !IsOK( this, _( "Delete zones ?" ) ) )
if( query && !IsOK(this, _("Delete zones ?") ) ) return ; return;
if( m_Pcb->m_Zone ) if( m_Pcb->m_Zone )
{ {
@ -100,38 +103,25 @@ void WinEDA_GerberFrame::Erase_Segments_Pcb(wxDC * DC,
bool all_layers, bool query ) bool all_layers, bool query )
/*****************************************************/ /*****************************************************/
{ {
EDA_BaseStruct * PtStruct, *PtNext; BOARD_ITEM* PtStruct;
BOARD_ITEM* PtNext;
int layer = GetScreen()->m_Active_Layer; int layer = GetScreen()->m_Active_Layer;
if ( all_layers ) layer = -1; if( all_layers )
layer = -1;
PtStruct = (EDA_BaseStruct *) m_Pcb->m_Drawings; PtStruct = m_Pcb->m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtNext ) for( ; PtStruct != NULL; PtStruct = PtNext )
{ {
PtNext = PtStruct->Pnext; PtNext = PtStruct->Next();
switch( PtStruct->m_StructType ) switch( PtStruct->m_StructType )
{ {
case TYPEDRAWSEGMENT: case TYPEDRAWSEGMENT:
if( (((DRAWSEGMENT*)PtStruct)->m_Layer == layer)
|| layer < 0)
DeleteStructure(PtStruct);
break;
case TYPETEXTE: case TYPETEXTE:
if( (((TEXTE_PCB*)PtStruct)->m_Layer == layer)
|| layer < 0)
DeleteStructure(PtStruct);
break;
case TYPECOTATION: case TYPECOTATION:
if( (((COTATION*)PtStruct)->m_Layer == layer)
|| layer < 0)
DeleteStructure(PtStruct);
break;
case TYPEMIRE: case TYPEMIRE:
if( (((MIREPCB*)PtStruct)->m_Layer == layer) if( PtStruct->GetLayer() == layer || layer < 0 )
|| layer < 0)
DeleteStructure( PtStruct ); DeleteStructure( PtStruct );
break; break;
@ -149,22 +139,25 @@ int layer = GetScreen()->m_Active_Layer;
void WinEDA_GerberFrame::Erase_Pistes( wxDC* DC, int masque_type, void WinEDA_GerberFrame::Erase_Pistes( wxDC* DC, int masque_type,
bool query ) bool query )
/****************************************************************/ /****************************************************************/
/* Efface les segments de piste, selon les autorisations affichees /* Efface les segments de piste, selon les autorisations affichees
masque_type = masque des options de selection: * masque_type = masque des options de selection:
SEGM_FIXE, SEGM_AR * SEGM_FIXE, SEGM_AR
Si un des bits est a 1, il n'y a pas effacement du segment de meme bit a 1 * Si un des bits est a 1, il n'y a pas effacement du segment de meme bit a 1
*/ */
{ {
TRACK* pt_segm; TRACK* pt_segm;
EDA_BaseStruct * PtNext; BOARD_ITEM* PtNext;
if( query && ! IsOK(this, _("Delete Tracks?")) ) return; if( query && !IsOK( this, _( "Delete Tracks?" ) ) )
return;
/* Marquage des pistes a effacer */ /* Marquage des pistes a effacer */
for( pt_segm = m_Pcb->m_Track; pt_segm != NULL; pt_segm = (TRACK*) PtNext ) for( pt_segm = m_Pcb->m_Track; pt_segm != NULL; pt_segm = (TRACK*) PtNext )
{ {
PtNext = pt_segm->Pnext; PtNext = pt_segm->Next();
if( pt_segm->GetState(SEGM_FIXE|SEGM_AR) & masque_type) continue; if( pt_segm->GetState( SEGM_FIXE | SEGM_AR ) & masque_type )
continue;
DeleteStructure( pt_segm ); DeleteStructure( pt_segm );
} }
@ -176,43 +169,46 @@ EDA_BaseStruct * PtNext;
void WinEDA_GerberFrame::Erase_Textes_Pcb( wxDC* DC, bool query ) void WinEDA_GerberFrame::Erase_Textes_Pcb( wxDC* DC, bool query )
/*****************************************************************/ /*****************************************************************/
{ {
EDA_BaseStruct * PtStruct, *PtNext; BOARD_ITEM* PtStruct;
BOARD_ITEM* PtNext;
if( query && ! IsOK(this, _("Delete Pcb Texts") ) ) return; if( query && !IsOK( this, _( "Delete Pcb Texts" ) ) )
return;
PtStruct = (EDA_BaseStruct*) m_Pcb->m_Drawings; PtStruct = m_Pcb->m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtNext ) for( ; PtStruct != NULL; PtStruct = PtNext )
{ {
PtNext = PtStruct->Pnext; PtNext = PtStruct->Next();
if(PtStruct->m_StructType == TYPETEXTE ) DeleteStructure(PtStruct); if( PtStruct->m_StructType == TYPETEXTE )
DeleteStructure( PtStruct );
} }
ScreenPcb->SetModify(); ScreenPcb->SetModify();
} }
/*******************************************************************/ /*******************************************************************/
void WinEDA_GerberFrame::Erase_Current_Layer( wxDC* DC, bool query ) void WinEDA_GerberFrame::Erase_Current_Layer( wxDC* DC, bool query )
/*******************************************************************/ /*******************************************************************/
{ {
TRACK* pt_segm; TRACK* pt_segm;
EDA_BaseStruct * PtNext; BOARD_ITEM* PtNext;
int layer = GetScreen()->m_Active_Layer; int layer = GetScreen()->m_Active_Layer;
wxString msg; wxString msg;
msg.Printf( _( "Delete Layer %d" ), layer + 1 ); msg.Printf( _( "Delete Layer %d" ), layer + 1 );
if( query && ! IsOK(this, msg) ) return; if( query && !IsOK( this, msg ) )
return;
/* Marquage des pistes a effacer */ /* Marquage des pistes a effacer */
for( pt_segm = m_Pcb->m_Track; pt_segm != NULL; pt_segm = (TRACK*) PtNext ) for( pt_segm = m_Pcb->m_Track; pt_segm != NULL; pt_segm = (TRACK*) PtNext )
{ {
PtNext = pt_segm->Pnext; PtNext = pt_segm->Next();
if( pt_segm->m_Layer != layer) continue; if( pt_segm->GetLayer() != layer )
continue;
DeleteStructure( pt_segm ); DeleteStructure( pt_segm );
} }
ScreenPcb->SetModify(); ScreenPcb->SetModify();
ScreenPcb->SetRefreshReq(); ScreenPcb->SetRefreshReq();
} }

10
gerbview/locate.cpp
View File

@ -102,7 +102,7 @@ DRAWSEGMENT* Locate_Segment_Pcb( BOARD* Pcb, int typeloc )
* NULL si rien trouve * NULL si rien trouve
*/ */
{ {
EDA_BaseStruct* PtStruct; BOARD_ITEM* PtStruct;
DRAWSEGMENT* pts; DRAWSEGMENT* pts;
wxPoint ref; wxPoint ref;
PCB_SCREEN* screen = (PCB_SCREEN*) ActiveScreen; PCB_SCREEN* screen = (PCB_SCREEN*) ActiveScreen;
@ -110,7 +110,7 @@ DRAWSEGMENT* Locate_Segment_Pcb( BOARD* Pcb, int typeloc )
SET_REF_POS( ref ); SET_REF_POS( ref );
PtStruct = Pcb->m_Drawings; PtStruct = Pcb->m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext ) for( ; PtStruct != NULL; PtStruct = PtStruct->Next() )
{ {
if( PtStruct->m_StructType != TYPEDRAWSEGMENT ) if( PtStruct->m_StructType != TYPEDRAWSEGMENT )
continue; continue;
@ -121,7 +121,7 @@ DRAWSEGMENT* Locate_Segment_Pcb( BOARD* Pcb, int typeloc )
spot_cX = ref.x - ux0; spot_cY = ref.y - uy0; spot_cX = ref.x - ux0; spot_cY = ref.y - uy0;
/* detection : */ /* detection : */
if( pts->m_Layer != screen->m_Active_Layer ) if( pts->GetLayer() != screen->m_Active_Layer )
continue; continue;
if( (pts->m_Shape == S_CIRCLE) || (pts->m_Shape == S_ARC) ) if( (pts->m_Shape == S_CIRCLE) || (pts->m_Shape == S_ARC) )
@ -208,7 +208,7 @@ TRACK* Locate_Pistes( TRACK* start_adresse, wxPoint ref, int Layer )
} }
if( Layer >= 0 ) if( Layer >= 0 )
if( Track->m_Layer != Layer ) if( Track->GetLayer() != Layer )
continue;/* Segments sur couches differentes */ continue;/* Segments sur couches differentes */
if( distance( l_piste ) ) if( distance( l_piste ) )
return Track; return Track;
@ -260,7 +260,7 @@ TRACK* Locate_Zone( TRACK* start_adresse, wxPoint ref, int layer )
dx -= ux0; dy -= uy0; dx -= ux0; dy -= uy0;
spot_cX = ref.x - ux0; spot_cY = ref.y - uy0; spot_cX = ref.x - ux0; spot_cY = ref.y - uy0;
if( (layer != -1) && (Zone->m_Layer != layer) ) if( (layer != -1) && (Zone->GetLayer() != layer) )
continue; continue;
if( distance( l_segm ) ) if( distance( l_segm ) )
return Zone; return Zone;

14
gerbview/rs274d.cpp
View File

@ -105,7 +105,7 @@ TRACK * track;
track = new TRACK(frame->m_Pcb); track = new TRACK(frame->m_Pcb);
track->Insert(frame->m_Pcb, NULL); track->Insert(frame->m_Pcb, NULL);
track->m_Layer = frame->GetScreen()->m_Active_Layer; track->SetLayer( frame->GetScreen()->m_Active_Layer );
track->m_Width = diametre ; track->m_Width = diametre ;
track->m_Start = track->m_End = pos; track->m_Start = track->m_End = pos;
NEGATE(track->m_Start.y); NEGATE(track->m_Start.y);
@ -129,13 +129,13 @@ static void Append_1_Flash_GERBER(int Dcode_index,
TRACK * track; TRACK * track;
int width, len; int width, len;
width = min( size.x, size.y ); width = MIN( size.x, size.y );
len = max( size.x, size.y ) - width; len = MAX( size.x, size.y ) - width;
track = new TRACK(frame->m_Pcb); track = new TRACK(frame->m_Pcb);
track->Insert(frame->m_Pcb, NULL); track->Insert(frame->m_Pcb, NULL);
track->m_Layer = frame->GetScreen()->m_Active_Layer; track->SetLayer( frame->GetScreen()->m_Active_Layer );
track->m_Width = width; track->m_Width = width;
track->m_Start = track->m_End = pos; track->m_Start = track->m_End = pos;
NEGATE(track->m_Start.y); NEGATE(track->m_Start.y);
@ -176,7 +176,7 @@ TRACK * track;
track = new TRACK( frame->m_Pcb ); track = new TRACK( frame->m_Pcb );
track->Insert(frame->m_Pcb, NULL); track->Insert(frame->m_Pcb, NULL);
track->m_Layer = frame->GetScreen()->m_Active_Layer ; track->SetLayer( frame->GetScreen()->m_Active_Layer );
track->m_Width = largeur ; track->m_Width = largeur ;
track->m_Start = startpoint; track->m_Start = startpoint;
NEGATE(track->m_Start.y); NEGATE(track->m_Start.y);
@ -213,7 +213,7 @@ wxPoint center, delta;
track->Insert(frame->m_Pcb, NULL); track->Insert(frame->m_Pcb, NULL);
track->m_Shape = S_ARC; track->m_Shape = S_ARC;
track->m_Layer = frame->GetScreen()->m_Active_Layer ; track->SetLayer( frame->GetScreen()->m_Active_Layer );
track->m_Width = largeur ; track->m_Width = largeur ;
if ( multiquadrant ) if ( multiquadrant )
@ -643,7 +643,7 @@ wxString msg;
if ( last ) while (last->Pnext ) last = (SEGZONE*)last->Pnext; if ( last ) while (last->Pnext ) last = (SEGZONE*)last->Pnext;
edge_poly->Insert(frame->m_Pcb, last); edge_poly->Insert(frame->m_Pcb, last);
edge_poly->m_Layer = frame->GetScreen()->m_Active_Layer ; edge_poly->SetLayer( frame->GetScreen()->m_Active_Layer );
edge_poly->m_Width = 1; edge_poly->m_Width = 1;
edge_poly->m_Start = m_PreviousPos; edge_poly->m_Start = m_PreviousPos;
NEGATE(edge_poly->m_Start.y); NEGATE(edge_poly->m_Start.y);

4
gerbview/tracepcb.cpp
View File

@ -116,7 +116,7 @@ void WinEDA_GerberFrame::Trace_Gerber( wxDC* DC, int draw_mode, int printmasklay
{ {
if( nbpoints ) if( nbpoints )
{ {
int Color = g_DesignSettings.m_LayerColor[track->m_Layer]; int Color = g_DesignSettings.m_LayerColor[track->GetLayer()];
GRClosedPoly( &DrawPanel->m_ClipBox, DC, nbpoints, coord, GRClosedPoly( &DrawPanel->m_ClipBox, DC, nbpoints, coord,
1, Color, Color ); 1, Color, Color );
} }
@ -141,7 +141,7 @@ void WinEDA_GerberFrame::Trace_Gerber( wxDC* DC, int draw_mode, int printmasklay
} }
if( track->Next() == NULL ) // Last point if( track->Next() == NULL ) // Last point
{ {
int Color = g_DesignSettings.m_LayerColor[track->m_Layer]; int Color = g_DesignSettings.m_LayerColor[track->GetLayer()];
GRClosedPoly( &DrawPanel->m_ClipBox, DC, nbpoints, coord, GRClosedPoly( &DrawPanel->m_ClipBox, DC, nbpoints, coord,
1, Color, Color ); 1, Color, Color );
} }

73
gerbview/trpiste.cpp
View File

@ -17,10 +17,12 @@
/* variables locales : */ /* variables locales : */
/***************************************************************************************************/ /***************************************************************************************************/
void Draw_Track_Buffer(WinEDA_DrawPanel * panel, wxDC * DC, BOARD * Pcb, int draw_mode, int printmasklayer) void Draw_Track_Buffer( WinEDA_DrawPanel* panel, wxDC* DC, BOARD* Pcb, int draw_mode,
int printmasklayer )
/***************************************************************************************************/ /***************************************************************************************************/
/* Function to draw the tracks (i.e Sports or lines) in gerbview /* Function to draw the tracks (i.e Sports or lines) in gerbview
Polygons are not handled here (there are in Pcb->m_Zone) * Polygons are not handled here (there are in Pcb->m_Zone)
* @param DC = device context to draw * @param DC = device context to draw
* @param Pcb = Board to draw (only Pcb->m_Track is used) * @param Pcb = Board to draw (only Pcb->m_Track is used)
* @param draw_mode = draw mode for the device context (GR_COPY, GR_OR, GR_XOR ..) * @param draw_mode = draw mode for the device context (GR_COPY, GR_OR, GR_XOR ..)
@ -39,12 +41,14 @@ int dcode_hightlight = 0;
for( ; Track != NULL; Track = (TRACK*) Track->Pnext ) for( ; Track != NULL; Track = (TRACK*) Track->Pnext )
{ {
if( printmasklayer != -1 ) if( printmasklayer != -1 )
if ( (Track->ReturnMaskLayer() & printmasklayer) == 0 ) continue; if( (Track->ReturnMaskLayer() & printmasklayer) == 0 )
continue;
if ( (dcode_hightlight == Track->m_NetCode) && if( (dcode_hightlight == Track->m_NetCode)
(Track->m_Layer == layer) ) && (Track->GetLayer() == layer) )
Trace_Segment( panel, DC, Track, draw_mode | GR_SURBRILL ); Trace_Segment( panel, DC, Track, draw_mode | GR_SURBRILL );
else Trace_Segment(panel, DC, Track, draw_mode ); else
Trace_Segment( panel, DC, Track, draw_mode );
} }
} }
@ -52,10 +56,11 @@ int dcode_hightlight = 0;
/***********************************************************************************/ /***********************************************************************************/
void Trace_Segment( WinEDA_DrawPanel* panel, wxDC* DC, TRACK* track, int draw_mode ) void Trace_Segment( WinEDA_DrawPanel* panel, wxDC* DC, TRACK* track, int draw_mode )
/***********************************************************************************/ /***********************************************************************************/
/* routine de trace de 1 segment de piste. /* routine de trace de 1 segment de piste.
Parametres : * Parametres :
track = adresse de la description de la piste en buflib * track = adresse de la description de la piste en buflib
draw_mode = mode ( GR_XOR, GR_OR..) * draw_mode = mode ( GR_XOR, GR_OR..)
*/ */
{ {
int l_piste; int l_piste;
@ -65,16 +70,19 @@ int rayon;
int fillopt; int fillopt;
static bool show_err; static bool show_err;
color = g_DesignSettings.m_LayerColor[track->m_Layer]; color = g_DesignSettings.m_LayerColor[track->GetLayer()];
if(color & ITEM_NOT_SHOW ) return ; if( color & ITEM_NOT_SHOW )
return;
zoom = panel->GetZoom(); zoom = panel->GetZoom();
GRSetDrawMode( DC, draw_mode ); GRSetDrawMode( DC, draw_mode );
if( draw_mode & GR_SURBRILL ) if( draw_mode & GR_SURBRILL )
{ {
if( draw_mode & GR_AND) color &= ~HIGHT_LIGHT_FLAG; if( draw_mode & GR_AND )
else color |= HIGHT_LIGHT_FLAG; color &= ~HIGHT_LIGHT_FLAG;
else
color |= HIGHT_LIGHT_FLAG;
} }
if( color & HIGHT_LIGHT_FLAG ) if( color & HIGHT_LIGHT_FLAG )
color = ColorRefs[color & MASKCOLOR].m_LightColor; color = ColorRefs[color & MASKCOLOR].m_LightColor;
@ -133,7 +141,6 @@ static bool show_err;
GRCircle( &panel->m_ClipBox, DC, track->m_Start.x, track->m_Start.y, GRCircle( &panel->m_ClipBox, DC, track->m_Start.x, track->m_Start.y,
rayon, 0, color ); rayon, 0, color );
} }
else if( fillopt == SKETCH ) else if( fillopt == SKETCH )
{ {
GRCircle( &panel->m_ClipBox, DC, track->m_Start.x, track->m_Start.y, GRCircle( &panel->m_ClipBox, DC, track->m_Start.x, track->m_Start.y,
@ -176,6 +183,7 @@ static bool show_err;
case S_SPOT_OVALE: case S_SPOT_OVALE:
fillopt = DisplayOpt.DisplayPadFill ? FILLED : SKETCH; fillopt = DisplayOpt.DisplayPadFill ? FILLED : SKETCH;
case S_SEGMENT: case S_SEGMENT:
if( (l_piste / zoom) < L_MIN_DESSIN ) if( (l_piste / zoom) < L_MIN_DESSIN )
{ {
@ -208,17 +216,19 @@ static bool show_err;
} }
} }
/**************************************************************************/ /**************************************************************************/
void Trace_DrawSegmentPcb( WinEDA_DrawPanel* panel, wxDC* DC, void Trace_DrawSegmentPcb( WinEDA_DrawPanel* panel, wxDC* DC,
DRAWSEGMENT* PtDrawSegment, int draw_mode ) DRAWSEGMENT* PtDrawSegment, int draw_mode )
/**************************************************************************/ /**************************************************************************/
/* Affichage d'un segment type drawing PCB: /* Affichage d'un segment type drawing PCB:
Entree : ox, oy = offset de trace * Entree : ox, oy = offset de trace
draw_mode = mode de trace ( GR_OR, GR_XOR, GrAND) * draw_mode = mode de trace ( GR_OR, GR_XOR, GrAND)
Les contours sont de differents type: * Les contours sont de differents type:
segment * segment
cercle * cercle
arc * arc
*/ */
{ {
int ux0, uy0, dx, dy; int ux0, uy0, dx, dy;
@ -227,8 +237,9 @@ int color, mode;
int zoom = panel->GetZoom(); int zoom = panel->GetZoom();
int rayon; int rayon;
color = g_DesignSettings.m_LayerColor[PtDrawSegment->m_Layer]; color = g_DesignSettings.m_LayerColor[PtDrawSegment->GetLayer()];
if(color & ITEM_NOT_SHOW ) return ; if( color & ITEM_NOT_SHOW )
return;
GRSetDrawMode( DC, draw_mode ); GRSetDrawMode( DC, draw_mode );
l_piste = PtDrawSegment->m_Width >> 1; /* l_piste = demi largeur piste */ l_piste = PtDrawSegment->m_Width >> 1; /* l_piste = demi largeur piste */
@ -242,8 +253,10 @@ int rayon;
mode = DisplayOpt.DisplayPcbTrackFill ? FILLED : SKETCH; mode = DisplayOpt.DisplayPcbTrackFill ? FILLED : SKETCH;
if(PtDrawSegment->m_Flags & FORCE_SKETCH) mode = SKETCH; if( PtDrawSegment->m_Flags & FORCE_SKETCH )
if ( l_piste < (L_MIN_DESSIN * zoom) ) mode = FILAIRE; mode = SKETCH;
if( l_piste < (L_MIN_DESSIN * zoom) )
mode = FILAIRE;
switch( PtDrawSegment->m_Shape ) switch( PtDrawSegment->m_Shape )
{ {
@ -319,14 +332,13 @@ wxString Line;
track = Pcb->m_Track; track = Pcb->m_Track;
for( ; track != NULL; track = (TRACK*) track->Pnext ) for( ; track != NULL; track = (TRACK*) track->Pnext )
{ {
if ( (track->m_Shape == S_ARC) || if( (track->m_Shape == S_ARC)
(track->m_Shape == S_CIRCLE) || || (track->m_Shape == S_CIRCLE)
(track->m_Shape == S_ARC_RECT) ) || (track->m_Shape == S_ARC_RECT) )
{ {
pos.x = track->m_Start.x; pos.x = track->m_Start.x;
pos.y = track->m_Start.y; pos.y = track->m_Start.y;
} }
else else
{ {
pos.x = (track->m_Start.x + track->m_End.x) / 2; pos.x = (track->m_Start.x + track->m_End.x) / 2;
@ -339,13 +351,13 @@ wxString Line;
{ {
width /= 3; width /= 3;
} }
else // lines else // lines
{ {
int dx, dy; int dx, dy;
dx = track->m_Start.x - track->m_End.x; dx = track->m_Start.x - track->m_End.x;
dy = track->m_Start.y - track->m_End.y; dy = track->m_Start.y - track->m_End.y;
if ( abs(dx) < abs(dy) ) orient = TEXT_ORIENT_VERT; if( abs( dx ) < abs( dy ) )
orient = TEXT_ORIENT_VERT;
width /= 2; width /= 2;
} }
@ -355,4 +367,3 @@ wxString Line;
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER ); GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER );
} }
} }

68
include/base_struct.h
View File

@ -110,7 +110,7 @@ public:
* *
* @param testItem An EDA_BaseStruct to examine. * @param testItem An EDA_BaseStruct to examine.
* @param testData is arbitrary data needed by the inspector to determine * @param testData is arbitrary data needed by the inspector to determine
* if the EDA_BaseStruct under test meets its match criteria. * if the BOARD_ITEM under test meets its match criteria.
* @return SEARCH_RESULT - SEARCH_QUIT if the Iterator is to stop the scan, * @return SEARCH_RESULT - SEARCH_QUIT if the Iterator is to stop the scan,
* else SCAN_CONTINUE; * else SCAN_CONTINUE;
*/ */
@ -154,7 +154,7 @@ public:
unsigned long m_TimeStamp; // Time stamp used for logical links unsigned long m_TimeStamp; // Time stamp used for logical links
int m_Selected; /* Used by block commands, and selective editing */ int m_Selected; /* Used by block commands, and selective editing */
int m_Layer; ///< used by many derived classes, so make common // int m_Layer; ///< used by many derived classes, so make common
private: private:
int m_Status; int m_Status;
@ -298,21 +298,6 @@ public:
**/ **/
static std::ostream& NestedSpace( int nestLevel, std::ostream& os ); static std::ostream& NestedSpace( int nestLevel, std::ostream& os );
/**
* Function ListHas
* scans the given array and detects if the given type t is present.
* @param list An array of KICAD_T, terminated with EOT.
* @param t A KICAD_T to check for.
* @return bool - true if present, else false.
*/
static bool ListHas( const KICAD_T list[], KICAD_T t )
{
for( const KICAD_T* p = list; *p != EOT; ++p )
if( *p == t )
return true;
return false;
}
#endif #endif
}; };
@ -383,12 +368,59 @@ public:
}; };
/* Basic class for build items like lines, which have 1 start point and 1 end point. /**
* Class BOARD_ITEM
* is an abstract base class for any item which can be embedded within the BOARD
* container class, and therefore instances of derived classes should only be
* found in PCBNEW or other programs that use class BOARD and its contents.
* The corresponding class in EESCHEMA seems to be DrawPartStruct.
*/
class BOARD_ITEM : public EDA_BaseStruct
{
protected:
int m_Layer;
public:
BOARD_ITEM( BOARD_ITEM* StructFather, DrawStructureType idtype ) :
EDA_BaseStruct( StructFather, idtype ),
m_Layer(0)
{
}
BOARD_ITEM( const BOARD_ITEM& src ) :
EDA_BaseStruct( src.m_Parent, src.m_StructType ),
m_Layer( src.m_Layer )
{
}
BOARD_ITEM* Next() { return (BOARD_ITEM*) Pnext; }
/**
* Function GetLayer
* returns the layer this item is on.
*/
int GetLayer() const { return m_Layer; }
/**
* Function SetLayer
* sets the layer this item is on.
* @param aLayer The layer number.
*/
void SetLayer( int aLayer ) { m_Layer = aLayer; }
};
/* Base class for building items like lines, which have 1 start point and 1 end point.
* Arc and circles can use this class. * Arc and circles can use this class.
*/ */
class EDA_BaseLineStruct : public EDA_BaseStruct class EDA_BaseLineStruct : public EDA_BaseStruct
{ {
public: public:
int m_Layer; // Layer number
int m_Width; // 0 = line, > 0 = tracks, bus ... int m_Width; // 0 = line, > 0 = tracks, bus ...
wxPoint m_Start; // Line start point wxPoint m_Start; // Line start point
wxPoint m_End; // Line end point wxPoint m_End; // Line end point

242
include/class_collector.h Normal file
View File

@ -0,0 +1,242 @@
/*
* This program source code file is part of KICAD, a free EDA CAD application.
*
* Copyright (C) 2007 Dick Hollenbeck, dick@softplc.com
* Copyright (C) 2004-2007 Kicad Developers, see change_log.txt for contributors.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, you may find one here:
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
* or you may search the http://www.gnu.org website for the version 2 license,
* or you may write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef COLLECTOR_H
#define COLLECTOR_H
#include <vector>
//#include <cstdlib> // abs()
#include "fctsys.h"
#include "base_struct.h" // SEARCH_RESULT
#include "common.h" // GetTimeStamp()
class EDA_BaseStruct;
class BOARD;
/**
* Class COLLECTOR
* is an abstract class that will find and hold all the objects according to
* an inspection done by the Inspect() function which must be implemented by
* any derived class. When Inspect() finds an object that it wants to collect,
* i.e. one that it "likes", then it only has to do an Append( testItem )
* on it to add it to its collection, but in all cases for the scan to continue,
* Inspect() must return SEARCH_CONTINUE.
*
* Later, after collection, the user can iterate through all the objects
* in the remembered collection using GetCount() and the [int] operator.
*
* Philosophy: this class knows nothing of the context in which as BOARD is used
* and that means it knows nothing about which layers are visible or current,
* but can handle those concerns by the SetPreferredLayer() function.
*/
class COLLECTOR : public INSPECTOR
{
protected:
// int m_Type;
/// Which object types to scan
const KICAD_T* m_ScanTypes;
/// The layer that is desired as a primary search criterion
int m_PreferredLayer;
/// A place to hold collected objects without taking ownership of their memory.
std::vector<EDA_BaseStruct*> list;
/// The point at which the snapshot was taken.
wxPoint m_RefPos;
/// The time at which the collection was made.
int m_TimeAtCollection;
public:
COLLECTOR()
{
m_PreferredLayer = 0;
m_ScanTypes = 0;
}
virtual ~COLLECTOR()
{
// empty the list so that ~list() does not try and delete all
// the objects that it holds. list is not the owner of such objects
// and this prevents a double free()ing.
Empty();
}
/**
* Function Type
* returns the type of the collector.
int Type() const { return m_Type; }
*/
void SetPreferredLayer( int aPreferredLayer )
{
m_PreferredLayer = aPreferredLayer;
}
/**
* Function GetCount
* returns the number of objects in the list
*/
int GetCount() const
{
return list.size();
}
/**
* Function Empty
* sets the list to empty
*/
void Empty()
{
list.clear();
}
/**
* Function Append
* adds an item to the end of the list.
* @param item An EDA_BaseStruct* to add.
*/
void Append( EDA_BaseStruct* item )
{
list.push_back( item );
}
/**
* Function operator[int]
* is used for read only access and returns the object at index ndx.
* @param ndx The index into the list.
* @return EDA_BaseStruct* - or something derived from it, or NULL.
*/
EDA_BaseStruct* operator[]( int ndx ) const
{
if( (unsigned)ndx < (unsigned)GetCount() )
return list[ ndx ];
return NULL;
}
void SetScanTypes( const KICAD_T* scanTypes )
{
m_ScanTypes = scanTypes;
}
wxPoint GetRefPos() const { return m_RefPos; }
void SetRefPos( const wxPoint& arefPos )
{
m_RefPos = arefPos;
}
void SetTimeNow()
{
m_TimeAtCollection = GetTimeStamp();
}
int GetTime()
{
return m_TimeAtCollection;
}
/**
* Function IsSimilarPointAndTime
* returns true if the given reference point is "similar" (defined here)
* to the internal reference point and the current time is within a few
* seconds of the internal m_TimeAtCollection.
*
* @param aRefPos A wxPoint to compare to.
* @return bool - true if the point and time are similar, else false.
*/
bool IsSimilarPointAndTime( const wxPoint& aRefPos )
{
const int distMax = 2; // adjust these here
const int timeMax = 3; // seconds, I think
int dx = abs( aRefPos.x - m_RefPos.x );
int dy = abs( aRefPos.y - m_RefPos.y );
if( dx <= distMax && dy <= distMax
&& GetTimeStamp()-m_TimeAtCollection <= timeMax )
return true;
else
return false;
}
/**
* Function Inspect
* is the examining function within the INSPECTOR which is passed to the
* Iterate function. It is used primarily for searching, but not limited to
* that. It can also collect or modify the scanned objects.
*
* @param testItem An EDA_BaseStruct to examine.
* @param testData is arbitrary data needed by the inspector to determine
* if the EDA_BaseStruct under test meets its match criteria.
* @return SEARCH_RESULT - SEARCH_QUIT if the Iterator is to stop the scan,
* else SCAN_CONTINUE;
*
* implement in derived class:
SEARCH_RESULT virtual Inspect( EDA_BaseStruct* testItem,
const void* testData ) = 0;
*/
/**
* Function Scan
* scans a BOARD using this class's Inspector method, which does the collection.
* @param board A BOARD to scan.
* @param refPos A wxPoint to use in hit-testing.
*
* example implementation, in derived class:
*
virtual void Scan( BOARD* board, const wxPoint& refPos )
{
example implementation:
SetRefPos( refPos ); // remember where the snapshot was taken from
Empty(); // empty the collection
// visit the board with the INSPECTOR (me).
board->Visit( this, // INSPECTOR* inspector
NULL, // const void* testData,
m_ScanTypes);
SetTimeNow(); // when it was taken
}
*/
};
#endif // COLLECTOR_H

6
include/macros.h
View File

@ -11,12 +11,14 @@
#define CONV_FROM_UTF8(utf8string) (utf8string) #define CONV_FROM_UTF8(utf8string) (utf8string)
#endif #endif
/* violation of C++ standard, cannot use MIN() and MAX()
#ifndef min #ifndef min
#define min(x, y) ((x) > (y) ? (y) : (x)) #define MIN(x, y) ((x) > (y) ? (y) : (x))
#endif #endif
#ifndef max #ifndef max
#define max(x, y) ((x) > (y) ? (x) : (y)) #define MAX(x, y) ((x) > (y) ? (x) : (y))
#endif #endif
*/
#ifndef MIN #ifndef MIN
#define MIN(x, y) ((x) > (y) ? (y) : (x)) #define MIN(x, y) ((x) > (y) ? (y) : (x))

18
include/pcbstruct.h
View File

@ -187,7 +187,7 @@ enum DisplayViaMode {
}; };
class BOARD : public EDA_BaseStruct class BOARD : public BOARD_ITEM
{ {
public: public:
WinEDA_BasePcbFrame* m_PcbFrame; // Window de visualisation WinEDA_BasePcbFrame* m_PcbFrame; // Window de visualisation
@ -204,7 +204,7 @@ public:
int m_NbSegmTrack; // nombre d'elements de type segments de piste int m_NbSegmTrack; // nombre d'elements de type segments de piste
int m_NbSegmZone; // nombre d'elements de type segments de zone int m_NbSegmZone; // nombre d'elements de type segments de zone
EDA_BaseStruct* m_Drawings; // pointeur sur liste drawings BOARD_ITEM* m_Drawings; // pointeur sur liste drawings
MODULE* m_Modules; // pointeur sur liste zone modules MODULE* m_Modules; // pointeur sur liste zone modules
EQUIPOT* m_Equipots; // pointeur liste zone equipot EQUIPOT* m_Equipots; // pointeur liste zone equipot
TRACK* m_Track; // pointeur relatif zone piste TRACK* m_Track; // pointeur relatif zone piste
@ -339,15 +339,19 @@ public:
/* Description des elements du PCB */ /* Description des elements du PCB */
/***********************************/ /***********************************/
class DRAWSEGMENT : public EDA_BaseLineStruct class DRAWSEGMENT : public BOARD_ITEM
{ {
public: public:
int m_Width; // 0 = line, > 0 = tracks, bus ...
wxPoint m_Start; // Line start point
wxPoint m_End; // Line end point
int m_Shape; // forme: Segment , Cercle.. int m_Shape; // forme: Segment , Cercle..
int m_Type; // numero de sous type ( cotation.. ) int m_Type; // numero de sous type ( cotation.. )
int m_Angle; // pour les arcs: "longueur" de l'arc en 1/10 deg int m_Angle; // pour les arcs: "longueur" de l'arc en 1/10 deg
public: public:
DRAWSEGMENT( EDA_BaseStruct* StructFather, DrawStructureType idtype = TYPEDRAWSEGMENT ); DRAWSEGMENT( BOARD_ITEM* StructFather, DrawStructureType idtype = TYPEDRAWSEGMENT );
~DRAWSEGMENT( void ); ~DRAWSEGMENT( void );
// Read/write data // Read/write data
@ -405,7 +409,7 @@ public:
class EDGE_ZONE : public DRAWSEGMENT class EDGE_ZONE : public DRAWSEGMENT
{ {
public: public:
EDGE_ZONE( EDA_BaseStruct* StructFather ); EDGE_ZONE( BOARD_ITEM* StructFather );
EDGE_ZONE( const EDGE_ZONE& edgezone ); EDGE_ZONE( const EDGE_ZONE& edgezone );
~EDGE_ZONE( void ); ~EDGE_ZONE( void );
}; };
@ -415,7 +419,7 @@ public:
/* Gestion des marqueurs sur le PCB */ /* Gestion des marqueurs sur le PCB */
/************************************/ /************************************/
class MARQUEUR : public EDA_BaseStruct class MARQUEUR : public BOARD_ITEM
{ {
/* Description d'un marqueur */ /* Description d'un marqueur */
public: public:
@ -426,7 +430,7 @@ public:
wxString m_Diag; /* Associated text (comment) */ wxString m_Diag; /* Associated text (comment) */
public: public:
MARQUEUR( EDA_BaseStruct* StructFather ); MARQUEUR( BOARD_ITEM* StructFather );
~MARQUEUR( void ); ~MARQUEUR( void );
void UnLink( void ); void UnLink( void );
void Draw( WinEDA_DrawPanel* panel, wxDC* DC, int DrawMode ); void Draw( WinEDA_DrawPanel* panel, wxDC* DC, int DrawMode );

7
include/wxstruct.h
View File

@ -11,8 +11,6 @@
#define eda_global extern #define eda_global extern
#endif #endif
#include <vector>
#include <wx/socket.h> #include <wx/socket.h>
#include "wx/log.h" #include "wx/log.h"
#include "wx/config.h" #include "wx/config.h"
@ -98,6 +96,7 @@ class WinEDA3D_DrawFrame;
class PARAM_CFG_BASE; class PARAM_CFG_BASE;
class Ki_PageDescr; class Ki_PageDescr;
class Ki_HotkeyInfo; class Ki_HotkeyInfo;
class ARROWCOLLECTOR;
enum id_librarytype { enum id_librarytype {
@ -519,9 +518,7 @@ private:
wxMenu* m_FilesMenu; wxMenu* m_FilesMenu;
#if defined(DEBUG) #if defined(DEBUG)
class COLLECTOR; ARROWCOLLECTOR* m_ArrowCollector; ///< while arrow icon tool
COLLECTOR* m_GeneralCollector; ///< while arrow icon tool
COLLECTOR* m_RatsModuleCollector; ///< while find1rats icon tool
#endif #endif

42
pcbnew/autoplac.cpp
View File

@ -448,7 +448,7 @@ int WinEDA_PcbFrame::GenPlaceBoard( void )
PtStruct = m_Pcb->m_Drawings; PtStruct = m_Pcb->m_Drawings;
TRACK TmpSegm( NULL ); TRACK TmpSegm( NULL );
TmpSegm.m_Layer = -1; TmpSegm.SetLayer( -1 );
TmpSegm.m_NetCode = -1; TmpSegm.m_NetCode = -1;
TmpSegm.m_Width = g_GridRoutingSize / 2; TmpSegm.m_Width = g_GridRoutingSize / 2;
for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext ) for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext )
@ -459,7 +459,7 @@ int WinEDA_PcbFrame::GenPlaceBoard( void )
{ {
case TYPEDRAWSEGMENT: case TYPEDRAWSEGMENT:
DrawSegm = (DRAWSEGMENT*) PtStruct; DrawSegm = (DRAWSEGMENT*) PtStruct;
if( DrawSegm->m_Layer != EDGE_N ) if( DrawSegm->GetLayer() != EDGE_N )
break; break;
TmpSegm.m_Start = DrawSegm->m_Start; TmpSegm.m_Start = DrawSegm->m_Start;
@ -536,9 +536,9 @@ void WinEDA_PcbFrame::GenModuleOnBoard( MODULE* Module )
fy = m_Pcb->m_BoundaryBox.GetBottom(); fy = m_Pcb->m_BoundaryBox.GetBottom();
masque_layer = 0; masque_layer = 0;
if( Module->m_Layer == CMP_N ) if( Module->GetLayer() == CMP_N )
masque_layer = CMP_LAYER; masque_layer = CMP_LAYER;
if( Module->m_Layer == CUIVRE_N ) if( Module->GetLayer() == CUIVRE_N )
masque_layer = CUIVRE_LAYER; masque_layer = CUIVRE_LAYER;
TraceFilledRectangle( m_Pcb, ox, oy, fx, fy, masque_layer, TraceFilledRectangle( m_Pcb, ox, oy, fx, fy, masque_layer,
@ -615,7 +615,7 @@ int WinEDA_PcbFrame::RecherchePlacementModule( MODULE* Module, wxDC* DC )
{ {
D_PAD* Pad; int masque_otherlayer; D_PAD* Pad; int masque_otherlayer;
masque_otherlayer = CUIVRE_LAYER; masque_otherlayer = CUIVRE_LAYER;
if( Module->m_Layer == CUIVRE_N ) if( Module->GetLayer() == CUIVRE_N )
masque_otherlayer = CMP_LAYER; masque_otherlayer = CMP_LAYER;
for( Pad = Module->m_Pads; Pad != NULL; Pad = (D_PAD*) Pad->Pnext ) for( Pad = Module->m_Pads; Pad != NULL; Pad = (D_PAD*) Pad->Pnext )
@ -823,7 +823,7 @@ int TstModuleOnBoard( BOARD* Pcb, MODULE* Module, bool TstOtherSide )
int error, Penalite, marge, side, otherside; int error, Penalite, marge, side, otherside;
side = TOP; otherside = BOTTOM; side = TOP; otherside = BOTTOM;
if( Module->m_Layer == CUIVRE_N ) if( Module->GetLayer() == CUIVRE_N )
{ {
side = BOTTOM; otherside = TOP; side = BOTTOM; otherside = TOP;
} }
@ -1064,7 +1064,7 @@ static void TracePenaliteRectangle( BOARD* Pcb, int ux0, int uy0, int ux1, int u
if( trace & 2 ) if( trace & 2 )
{ {
data = GetDist( row, col, TOP ); data = GetDist( row, col, TOP );
data = max( data, LocalPenalite ); data = MAX( data, LocalPenalite );
SetDist( row, col, TOP, data ); SetDist( row, col, TOP, data );
} }
} }
@ -1193,7 +1193,7 @@ bool WinEDA_PcbFrame::SetBoardBoundaryBoxFromEdgesOnly( void )
{ {
int rayon, cx, cy, d; int rayon, cx, cy, d;
int xmax, ymax; int xmax, ymax;
EDA_BaseStruct* PtStruct; BOARD_ITEM* PtStruct;
DRAWSEGMENT* ptr; DRAWSEGMENT* ptr;
bool succes = FALSE; bool succes = FALSE;
@ -1205,7 +1205,7 @@ bool WinEDA_PcbFrame::SetBoardBoundaryBoxFromEdgesOnly( void )
/* Analyse des Contours PCB */ /* Analyse des Contours PCB */
PtStruct = m_Pcb->m_Drawings; PtStruct = m_Pcb->m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext ) for( ; PtStruct != NULL; PtStruct = PtStruct->Next() )
{ {
if( PtStruct->m_StructType != TYPEDRAWSEGMENT ) if( PtStruct->m_StructType != TYPEDRAWSEGMENT )
continue; continue;
@ -1217,21 +1217,21 @@ bool WinEDA_PcbFrame::SetBoardBoundaryBoxFromEdgesOnly( void )
cx = ptr->m_Start.x; cy = ptr->m_Start.y; cx = ptr->m_Start.x; cy = ptr->m_Start.y;
rayon = (int) hypot( (double) (ptr->m_End.x - cx), (double) (ptr->m_End.y - cy) ); rayon = (int) hypot( (double) (ptr->m_End.x - cx), (double) (ptr->m_End.y - cy) );
rayon += d; rayon += d;
m_Pcb->m_BoundaryBox.m_Pos.x = min( m_Pcb->m_BoundaryBox.m_Pos.x, cx - rayon ); m_Pcb->m_BoundaryBox.m_Pos.x = MIN( m_Pcb->m_BoundaryBox.m_Pos.x, cx - rayon );
m_Pcb->m_BoundaryBox.m_Pos.y = min( m_Pcb->m_BoundaryBox.m_Pos.y, cy - rayon ); m_Pcb->m_BoundaryBox.m_Pos.y = MIN( m_Pcb->m_BoundaryBox.m_Pos.y, cy - rayon );
xmax = max( xmax, cx + rayon ); xmax = MAX( xmax, cx + rayon );
ymax = max( ymax, cy + rayon ); ymax = MAX( ymax, cy + rayon );
} }
else else
{ {
cx = min( ptr->m_Start.x, ptr->m_End.x ); cx = MIN( ptr->m_Start.x, ptr->m_End.x );
cy = min( ptr->m_Start.y, ptr->m_End.y ); cy = MIN( ptr->m_Start.y, ptr->m_End.y );
m_Pcb->m_BoundaryBox.m_Pos.x = min( m_Pcb->m_BoundaryBox.m_Pos.x, cx - d ); m_Pcb->m_BoundaryBox.m_Pos.x = MIN( m_Pcb->m_BoundaryBox.m_Pos.x, cx - d );
m_Pcb->m_BoundaryBox.m_Pos.y = min( m_Pcb->m_BoundaryBox.m_Pos.y, cy - d ); m_Pcb->m_BoundaryBox.m_Pos.y = MIN( m_Pcb->m_BoundaryBox.m_Pos.y, cy - d );
cx = max( ptr->m_Start.x, ptr->m_End.x ); cx = MAX( ptr->m_Start.x, ptr->m_End.x );
cy = max( ptr->m_Start.y, ptr->m_End.y ); cy = MAX( ptr->m_Start.y, ptr->m_End.y );
xmax = max( xmax, cx + d ); xmax = MAX( xmax, cx + d );
ymax = max( ymax, cy + d ); ymax = MAX( ymax, cy + d );
} }
} }

57
pcbnew/block.cpp
View File

@ -430,7 +430,7 @@ void WinEDA_BasePcbFrame::Block_Delete( wxDC* DC )
* routine d'effacement du block deja selectionne * routine d'effacement du block deja selectionne
*/ */
{ {
EDA_BaseStruct* PtStruct, * NextS; BOARD_ITEM* PtStruct, * NextS;
int masque_layer; int masque_layer;
if( !InstallBlockCmdFrame( this, _( "Delete Block" ) ) ) if( !InstallBlockCmdFrame( this, _( "Delete Block" ) ) )
@ -448,7 +448,7 @@ void WinEDA_BasePcbFrame::Block_Delete( wxDC* DC )
module = m_Pcb->m_Modules; module = m_Pcb->m_Modules;
for( ; module != NULL; module = (MODULE*) NextS ) for( ; module != NULL; module = (MODULE*) NextS )
{ {
NextS = module->Pnext; NextS = module->Next();
if( IsModuleInBox( GetScreen()->BlockLocate, module ) == NULL ) if( IsModuleInBox( GetScreen()->BlockLocate, module ) == NULL )
continue; continue;
/* le module est ici bon a etre efface */ /* le module est ici bon a etre efface */
@ -467,9 +467,10 @@ void WinEDA_BasePcbFrame::Block_Delete( wxDC* DC )
Affiche_Message( _( "Delete tracks" ) ); Affiche_Message( _( "Delete tracks" ) );
for( pt_segm = m_Pcb->m_Track; pt_segm != NULL; pt_segm = (TRACK*) NextS ) for( pt_segm = m_Pcb->m_Track; pt_segm != NULL; pt_segm = (TRACK*) NextS )
{ {
NextS = pt_segm->Pnext; NextS = pt_segm->Next();
if( IsSegmentInBox( GetScreen()->BlockLocate, pt_segm ) ) if( IsSegmentInBox( GetScreen()->BlockLocate, pt_segm ) )
{ /* la piste est ici bonne a etre efface */ {
/* la piste est ici bonne a etre efface */
pt_segm->Draw( DrawPanel, DC, GR_XOR ); pt_segm->Draw( DrawPanel, DC, GR_XOR );
DeleteStructure( pt_segm ); DeleteStructure( pt_segm );
} }
@ -487,14 +488,14 @@ void WinEDA_BasePcbFrame::Block_Delete( wxDC* DC )
PtStruct = m_Pcb->m_Drawings; PtStruct = m_Pcb->m_Drawings;
for( ; PtStruct != NULL; PtStruct = NextS ) for( ; PtStruct != NULL; PtStruct = NextS )
{ {
NextS = PtStruct->Pnext; NextS = PtStruct->Next();
switch( PtStruct->m_StructType ) switch( PtStruct->m_StructType )
{ {
case TYPEDRAWSEGMENT: case TYPEDRAWSEGMENT:
#undef STRUCT #undef STRUCT
#define STRUCT ( (DRAWSEGMENT*) PtStruct ) #define STRUCT ( (DRAWSEGMENT*) PtStruct )
if( (g_TabOneLayerMask[STRUCT->m_Layer] & masque_layer) == 0 ) if( (g_TabOneLayerMask[STRUCT->GetLayer()] & masque_layer) == 0 )
break; break;
if( IsStructInBox( GetScreen()->BlockLocate, PtStruct ) == NULL ) if( IsStructInBox( GetScreen()->BlockLocate, PtStruct ) == NULL )
break; break;
@ -517,7 +518,7 @@ void WinEDA_BasePcbFrame::Block_Delete( wxDC* DC )
case TYPEMIRE: case TYPEMIRE:
#undef STRUCT #undef STRUCT
#define STRUCT ( (MIREPCB*) PtStruct ) #define STRUCT ( (MIREPCB*) PtStruct )
if( (g_TabOneLayerMask[STRUCT->m_Layer] & masque_layer) == 0 ) if( (g_TabOneLayerMask[STRUCT->GetLayer()] & masque_layer) == 0 )
break; break;
if( IsStructInBox( GetScreen()->BlockLocate, PtStruct ) == NULL ) if( IsStructInBox( GetScreen()->BlockLocate, PtStruct ) == NULL )
break; break;
@ -529,7 +530,7 @@ void WinEDA_BasePcbFrame::Block_Delete( wxDC* DC )
case TYPECOTATION: case TYPECOTATION:
#undef STRUCT #undef STRUCT
#define STRUCT ( (COTATION*) PtStruct ) #define STRUCT ( (COTATION*) PtStruct )
if( (g_TabOneLayerMask[STRUCT->m_Layer] & masque_layer) == 0 ) if( (g_TabOneLayerMask[STRUCT->GetLayer()] & masque_layer) == 0 )
break; break;
if( IsStructInBox( GetScreen()->BlockLocate, PtStruct ) == NULL ) if( IsStructInBox( GetScreen()->BlockLocate, PtStruct ) == NULL )
break; break;
@ -551,7 +552,7 @@ void WinEDA_BasePcbFrame::Block_Delete( wxDC* DC )
Affiche_Message( _( "Delete zones" ) ); Affiche_Message( _( "Delete zones" ) );
for( pt_segm = m_Pcb->m_Zone; pt_segm != NULL; pt_segm = (TRACK*) NextS ) for( pt_segm = m_Pcb->m_Zone; pt_segm != NULL; pt_segm = (TRACK*) NextS )
{ {
NextS = pt_segm->Pnext; NextS = pt_segm->Next();
if( IsSegmentInBox( GetScreen()->BlockLocate, pt_segm ) ) if( IsSegmentInBox( GetScreen()->BlockLocate, pt_segm ) )
{ /* la piste est ici bonne a etre efface */ { /* la piste est ici bonne a etre efface */
pt_segm->Draw( DrawPanel, DC, GR_XOR ); pt_segm->Draw( DrawPanel, DC, GR_XOR );
@ -682,7 +683,7 @@ void WinEDA_BasePcbFrame::Block_Rotate( wxDC* DC )
case TYPEDRAWSEGMENT: case TYPEDRAWSEGMENT:
#undef STRUCT #undef STRUCT
#define STRUCT ( (DRAWSEGMENT*) PtStruct ) #define STRUCT ( (DRAWSEGMENT*) PtStruct )
if( (g_TabOneLayerMask[STRUCT->m_Layer] & masque_layer) == 0 ) if( (g_TabOneLayerMask[STRUCT->GetLayer()] & masque_layer) == 0 )
break; break;
if( IsStructInBox( GetScreen()->BlockLocate, PtStruct ) == NULL ) if( IsStructInBox( GetScreen()->BlockLocate, PtStruct ) == NULL )
break; break;
@ -715,7 +716,7 @@ void WinEDA_BasePcbFrame::Block_Rotate( wxDC* DC )
case TYPEMIRE: case TYPEMIRE:
#undef STRUCT #undef STRUCT
#define STRUCT ( (MIREPCB*) PtStruct ) #define STRUCT ( (MIREPCB*) PtStruct )
if( (g_TabOneLayerMask[STRUCT->m_Layer] & masque_layer) == 0 ) if( (g_TabOneLayerMask[STRUCT->GetLayer()] & masque_layer) == 0 )
break; break;
if( IsStructInBox( GetScreen()->BlockLocate, PtStruct ) == NULL ) if( IsStructInBox( GetScreen()->BlockLocate, PtStruct ) == NULL )
break; break;
@ -728,7 +729,7 @@ void WinEDA_BasePcbFrame::Block_Rotate( wxDC* DC )
case TYPECOTATION: case TYPECOTATION:
#undef STRUCT #undef STRUCT
#define STRUCT ( (COTATION*) PtStruct ) #define STRUCT ( (COTATION*) PtStruct )
if( (g_TabOneLayerMask[STRUCT->m_Layer] & masque_layer) == 0 ) if( (g_TabOneLayerMask[STRUCT->GetLayer()] & masque_layer) == 0 )
break; break;
if( IsStructInBox( GetScreen()->BlockLocate, PtStruct ) == NULL ) if( IsStructInBox( GetScreen()->BlockLocate, PtStruct ) == NULL )
break; break;
@ -852,7 +853,7 @@ void WinEDA_BasePcbFrame::Block_Invert( wxDC* DC )
INVERT( track->m_End.y ); INVERT( track->m_End.y );
if( track->m_StructType != TYPEVIA ) if( track->m_StructType != TYPEVIA )
{ {
track->m_Layer = ChangeSideNumLayer( track->m_Layer ); track->SetLayer( ChangeSideNumLayer( track->GetLayer() ) );
} }
track->Draw( DrawPanel, DC, GR_OR ); // reaffichage track->Draw( DrawPanel, DC, GR_OR ); // reaffichage
@ -875,7 +876,7 @@ void WinEDA_BasePcbFrame::Block_Invert( wxDC* DC )
track->Draw( DrawPanel, DC, GR_XOR ); // effacement track->Draw( DrawPanel, DC, GR_XOR ); // effacement
INVERT( track->m_Start.y ); INVERT( track->m_Start.y );
INVERT( track->m_End.y ); INVERT( track->m_End.y );
track->m_Layer = ChangeSideNumLayer( track->m_Layer ); track->SetLayer( ChangeSideNumLayer( track->GetLayer() ) );
track->Draw( DrawPanel, DC, GR_OR ); // reaffichage track->Draw( DrawPanel, DC, GR_OR ); // reaffichage
} }
track = (TRACK*) track->Pnext; track = (TRACK*) track->Pnext;
@ -897,7 +898,7 @@ void WinEDA_BasePcbFrame::Block_Invert( wxDC* DC )
case TYPEDRAWSEGMENT: case TYPEDRAWSEGMENT:
#undef STRUCT #undef STRUCT
#define STRUCT ( (DRAWSEGMENT*) PtStruct ) #define STRUCT ( (DRAWSEGMENT*) PtStruct )
if( (g_TabOneLayerMask[STRUCT->m_Layer] & masque_layer) == 0 ) if( (g_TabOneLayerMask[STRUCT->GetLayer()] & masque_layer) == 0 )
break; break;
if( IsStructInBox( GetScreen()->BlockLocate, PtStruct ) == NULL ) if( IsStructInBox( GetScreen()->BlockLocate, PtStruct ) == NULL )
break; break;
@ -909,7 +910,7 @@ void WinEDA_BasePcbFrame::Block_Invert( wxDC* DC )
} }
INVERT( STRUCT->m_Start.y ); INVERT( STRUCT->m_Start.y );
INVERT( STRUCT->m_End.y ); INVERT( STRUCT->m_End.y );
STRUCT->m_Layer = ChangeSideNumLayer( STRUCT->m_Layer ); STRUCT->SetLayer( ChangeSideNumLayer( STRUCT->GetLayer() ) );
Trace_DrawSegmentPcb( DrawPanel, DC, (DRAWSEGMENT*) PtStruct, GR_OR ); Trace_DrawSegmentPcb( DrawPanel, DC, (DRAWSEGMENT*) PtStruct, GR_OR );
break; break;
@ -925,11 +926,11 @@ void WinEDA_BasePcbFrame::Block_Invert( wxDC* DC )
/* Redessin du Texte */ /* Redessin du Texte */
INVERT( STRUCT->m_Pos.y ); INVERT( STRUCT->m_Pos.y );
INVERT_ANGLE( STRUCT->m_Orient ); INVERT_ANGLE( STRUCT->m_Orient );
if( (STRUCT->m_Layer == CUIVRE_N) || (STRUCT->m_Layer == CMP_N) ) if( (STRUCT->GetLayer() == CUIVRE_N) || (STRUCT->GetLayer() == CMP_N) )
{ {
STRUCT->m_Miroir ^= 1; /* inverse miroir */ STRUCT->m_Miroir ^= 1; /* inverse miroir */
} }
STRUCT->m_Layer = ChangeSideNumLayer( STRUCT->m_Layer ); STRUCT->SetLayer( ChangeSideNumLayer( STRUCT->GetLayer() ) );
STRUCT->CreateDrawData(); STRUCT->CreateDrawData();
( (TEXTE_PCB*) PtStruct )->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR ); ( (TEXTE_PCB*) PtStruct )->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
break; break;
@ -937,21 +938,21 @@ void WinEDA_BasePcbFrame::Block_Invert( wxDC* DC )
case TYPEMIRE: case TYPEMIRE:
#undef STRUCT #undef STRUCT
#define STRUCT ( (MIREPCB*) PtStruct ) #define STRUCT ( (MIREPCB*) PtStruct )
if( (g_TabOneLayerMask[STRUCT->m_Layer] & masque_layer) == 0 ) if( (g_TabOneLayerMask[STRUCT->GetLayer()] & masque_layer) == 0 )
break; break;
if( IsStructInBox( GetScreen()->BlockLocate, PtStruct ) == NULL ) if( IsStructInBox( GetScreen()->BlockLocate, PtStruct ) == NULL )
break; break;
/* l'element est ici bon a etre modifie */ /* l'element est ici bon a etre modifie */
( (MIREPCB*) PtStruct )->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR ); ( (MIREPCB*) PtStruct )->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
INVERT( STRUCT->m_Pos.y ); INVERT( STRUCT->m_Pos.y );
STRUCT->m_Layer = ChangeSideNumLayer( STRUCT->m_Layer ); STRUCT->SetLayer( ChangeSideNumLayer( STRUCT->GetLayer() ) );
( (MIREPCB*) PtStruct )->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR ); ( (MIREPCB*) PtStruct )->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
break; break;
case TYPECOTATION: case TYPECOTATION:
#undef STRUCT #undef STRUCT
#define STRUCT ( (COTATION*) PtStruct ) #define STRUCT ( (COTATION*) PtStruct )
if( (g_TabOneLayerMask[STRUCT->m_Layer] & masque_layer) == 0 ) if( (g_TabOneLayerMask[STRUCT->GetLayer()] & masque_layer) == 0 )
break; break;
if( IsStructInBox( GetScreen()->BlockLocate, PtStruct ) == NULL ) if( IsStructInBox( GetScreen()->BlockLocate, PtStruct ) == NULL )
break; break;
@ -982,7 +983,7 @@ void WinEDA_BasePcbFrame::Block_Invert( wxDC* DC )
INVERT( STRUCT->FlecheD2_oy ); INVERT( STRUCT->FlecheD2_oy );
INVERT( STRUCT->FlecheD2_fy ); INVERT( STRUCT->FlecheD2_fy );
STRUCT->m_Layer = ChangeSideNumLayer( STRUCT->m_Layer ); STRUCT->SetLayer( ChangeSideNumLayer( STRUCT->GetLayer() ) );
( (COTATION*) PtStruct )->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR ); ( (COTATION*) PtStruct )->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
break; break;
@ -1111,7 +1112,7 @@ void WinEDA_BasePcbFrame::Block_Move( wxDC* DC )
case TYPEDRAWSEGMENT: case TYPEDRAWSEGMENT:
#undef STRUCT #undef STRUCT
#define STRUCT ( (DRAWSEGMENT*) PtStruct ) #define STRUCT ( (DRAWSEGMENT*) PtStruct )
if( (g_TabOneLayerMask[STRUCT->m_Layer] & masque_layer) == 0 ) if( (g_TabOneLayerMask[STRUCT->GetLayer()] & masque_layer) == 0 )
break; break;
if( IsStructInBox( GetScreen()->BlockLocate, PtStruct ) == NULL ) if( IsStructInBox( GetScreen()->BlockLocate, PtStruct ) == NULL )
break; break;
@ -1139,7 +1140,7 @@ void WinEDA_BasePcbFrame::Block_Move( wxDC* DC )
case TYPEMIRE: case TYPEMIRE:
#undef STRUCT #undef STRUCT
#define STRUCT ( (MIREPCB*) PtStruct ) #define STRUCT ( (MIREPCB*) PtStruct )
if( (g_TabOneLayerMask[STRUCT->m_Layer] & masque_layer) == 0 ) if( (g_TabOneLayerMask[STRUCT->GetLayer()] & masque_layer) == 0 )
break; break;
if( IsStructInBox( GetScreen()->BlockLocate, PtStruct ) == NULL ) if( IsStructInBox( GetScreen()->BlockLocate, PtStruct ) == NULL )
break; break;
@ -1152,7 +1153,7 @@ void WinEDA_BasePcbFrame::Block_Move( wxDC* DC )
case TYPECOTATION: case TYPECOTATION:
#undef STRUCT #undef STRUCT
#define STRUCT ( (COTATION*) PtStruct ) #define STRUCT ( (COTATION*) PtStruct )
if( (g_TabOneLayerMask[STRUCT->m_Layer] & masque_layer) == 0 ) if( (g_TabOneLayerMask[STRUCT->GetLayer()] & masque_layer) == 0 )
break; break;
if( IsStructInBox( GetScreen()->BlockLocate, PtStruct ) == NULL ) if( IsStructInBox( GetScreen()->BlockLocate, PtStruct ) == NULL )
break; break;
@ -1315,7 +1316,7 @@ void WinEDA_BasePcbFrame::Block_Duplicate( wxDC* DC )
{ {
#undef STRUCT #undef STRUCT
#define STRUCT ( (DRAWSEGMENT*) PtStruct ) #define STRUCT ( (DRAWSEGMENT*) PtStruct )
if( (g_TabOneLayerMask[STRUCT->m_Layer] & masque_layer) == 0 ) if( (g_TabOneLayerMask[STRUCT->GetLayer()] & masque_layer) == 0 )
break; break;
if( IsStructInBox( GetScreen()->BlockLocate, PtStruct ) == NULL ) if( IsStructInBox( GetScreen()->BlockLocate, PtStruct ) == NULL )
break; break;
@ -1357,7 +1358,7 @@ void WinEDA_BasePcbFrame::Block_Duplicate( wxDC* DC )
{ {
#undef STRUCT #undef STRUCT
#define STRUCT ( (MIREPCB*) PtStruct ) #define STRUCT ( (MIREPCB*) PtStruct )
if( (g_TabOneLayerMask[STRUCT->m_Layer] & masque_layer) == 0 ) if( (g_TabOneLayerMask[STRUCT->GetLayer()] & masque_layer) == 0 )
break; break;
if( IsStructInBox( GetScreen()->BlockLocate, PtStruct ) == NULL ) if( IsStructInBox( GetScreen()->BlockLocate, PtStruct ) == NULL )
break; break;
@ -1377,7 +1378,7 @@ void WinEDA_BasePcbFrame::Block_Duplicate( wxDC* DC )
{ {
#undef STRUCT #undef STRUCT
#define STRUCT ( (COTATION*) PtStruct ) #define STRUCT ( (COTATION*) PtStruct )
if( (g_TabOneLayerMask[STRUCT->m_Layer] & masque_layer) == 0 ) if( (g_TabOneLayerMask[STRUCT->GetLayer()] & masque_layer) == 0 )
break; break;
if( IsStructInBox( GetScreen()->BlockLocate, PtStruct ) == NULL ) if( IsStructInBox( GetScreen()->BlockLocate, PtStruct ) == NULL )
break; break;

4
pcbnew/block_module_editor.cpp
View File

@ -395,8 +395,8 @@ void CopyMarkedItems( MODULE* module, wxPoint offset )
/* Copy marked items, at new position = old position + offset /* Copy marked items, at new position = old position + offset
*/ */
{ {
EDA_BaseStruct* item; BOARD_ITEM* item;
EDA_BaseStruct* NewStruct; BOARD_ITEM* NewStruct;
if( module == NULL ) if( module == NULL )
return; return;

24
pcbnew/board.cpp
View File

@ -186,7 +186,7 @@ void PlaceCells( BOARD* Pcb, int net_code, int flag )
TRACK* pt_segm; TRACK* pt_segm;
TEXTE_PCB* PtText; TEXTE_PCB* PtText;
DRAWSEGMENT* DrawSegm; DRAWSEGMENT* DrawSegm;
EDA_BaseStruct* PtStruct; BOARD_ITEM* PtStruct;
int ux0 = 0, uy0 = 0, ux1, uy1, dx, dy; int ux0 = 0, uy0 = 0, ux1, uy1, dx, dy;
int marge, via_marge; int marge, via_marge;
int masque_layer; int masque_layer;
@ -211,19 +211,19 @@ void PlaceCells( BOARD* Pcb, int net_code, int flag )
// Placement des elements de modules sur PCB // // Placement des elements de modules sur PCB //
/////////////////////////////////////////////// ///////////////////////////////////////////////
PtStruct = Pcb->m_Modules; PtStruct = Pcb->m_Modules;
for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext ) for( ; PtStruct != NULL; PtStruct = PtStruct->Next() )
{ {
EDA_BaseStruct* PtModStruct = ( (MODULE*) PtStruct )->m_Drawings; BOARD_ITEM* PtModStruct = ( (MODULE*) PtStruct )->m_Drawings;
for( ; PtModStruct != NULL; PtModStruct = PtModStruct->Pnext ) for( ; PtModStruct != NULL; PtModStruct = PtModStruct->Next() )
{ {
switch( PtModStruct->m_StructType ) switch( PtModStruct->m_StructType )
{ {
case TYPEEDGEMODULE: case TYPEEDGEMODULE:
{ {
TRACK* TmpSegm = new TRACK( NULL ); TRACK* TmpSegm = new TRACK( NULL );
TmpSegm->m_Layer = ( (EDGE_MODULE*) PtModStruct )->m_Layer; TmpSegm->SetLayer( ( (EDGE_MODULE*) PtModStruct )->GetLayer() );
if( TmpSegm->m_Layer == EDGE_N ) if( TmpSegm->GetLayer() == EDGE_N )
TmpSegm->m_Layer = -1; TmpSegm->SetLayer( -1 );
TmpSegm->m_Start = ( (EDGE_MODULE*) PtModStruct )->m_Start; TmpSegm->m_Start = ( (EDGE_MODULE*) PtModStruct )->m_Start;
TmpSegm->m_End = ( (EDGE_MODULE*) PtModStruct )->m_End; TmpSegm->m_End = ( (EDGE_MODULE*) PtModStruct )->m_End;
@ -249,7 +249,7 @@ void PlaceCells( BOARD* Pcb, int net_code, int flag )
// Placement des contours et segments PCB // // Placement des contours et segments PCB //
//////////////////////////////////////////// ////////////////////////////////////////////
PtStruct = Pcb->m_Drawings; PtStruct = Pcb->m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext ) for( ; PtStruct != NULL; PtStruct = PtStruct->Next() )
{ {
switch( PtStruct->m_StructType ) switch( PtStruct->m_StructType )
{ {
@ -258,10 +258,10 @@ void PlaceCells( BOARD* Pcb, int net_code, int flag )
int type_cell = HOLE; int type_cell = HOLE;
TRACK* TmpSegm = new TRACK( NULL ); TRACK* TmpSegm = new TRACK( NULL );
DrawSegm = (DRAWSEGMENT*) PtStruct; DrawSegm = (DRAWSEGMENT*) PtStruct;
TmpSegm->m_Layer = DrawSegm->m_Layer; TmpSegm->SetLayer( DrawSegm->GetLayer() );
if( DrawSegm->m_Layer == EDGE_N ) if( DrawSegm->GetLayer() == EDGE_N )
{ {
TmpSegm->m_Layer = -1; TmpSegm->SetLayer( -1 );
type_cell |= CELL_is_EDGE; type_cell |= CELL_is_EDGE;
} }
@ -293,7 +293,7 @@ void PlaceCells( BOARD* Pcb, int net_code, int flag )
ux1 = ux0 + dx; uy1 = uy0 + dy; ux1 = ux0 + dx; uy1 = uy0 + dy;
ux0 -= dx; uy0 -= dy; ux0 -= dx; uy0 -= dy;
masque_layer = g_TabOneLayerMask[PtText->m_Layer]; masque_layer = g_TabOneLayerMask[PtText->GetLayer()];
TraceFilledRectangle( Pcb, ux0 - marge, uy0 - marge, ux1 + marge, uy1 + marge, TraceFilledRectangle( Pcb, ux0 - marge, uy0 - marge, ux1 + marge, uy1 + marge,
(int) (PtText->m_Orient), (int) (PtText->m_Orient),

99
pcbnew/class_board.cpp
View File

@ -15,7 +15,7 @@
/* Constructor */ /* Constructor */
BOARD::BOARD( EDA_BaseStruct* parent, WinEDA_BasePcbFrame* frame ) : BOARD::BOARD( EDA_BaseStruct* parent, WinEDA_BasePcbFrame* frame ) :
EDA_BaseStruct( parent, TYPEPCB ) BOARD_ITEM( (BOARD_ITEM*) parent, TYPEPCB )
{ {
m_PcbFrame = frame; m_PcbFrame = frame;
m_Status_Pcb = 0; // Mot d'etat: Bit 1 = Chevelu calcule m_Status_Pcb = 0; // Mot d'etat: Bit 1 = Chevelu calcule
@ -160,22 +160,22 @@ bool BOARD::ComputeBoundaryBox( void )
cx = ptr->m_Start.x; cy = ptr->m_Start.y; cx = ptr->m_Start.x; cy = ptr->m_Start.y;
rayon = (int) hypot( (double) (ptr->m_End.x - cx), (double) (ptr->m_End.y - cy) ); rayon = (int) hypot( (double) (ptr->m_End.x - cx), (double) (ptr->m_End.y - cy) );
rayon += d; rayon += d;
xmin = min( xmin, cx - rayon ); xmin = MIN( xmin, cx - rayon );
ymin = min( ymin, cy - rayon ); ymin = MIN( ymin, cy - rayon );
xmax = max( xmax, cx + rayon ); xmax = MAX( xmax, cx + rayon );
ymax = max( ymax, cy + rayon ); ymax = MAX( ymax, cy + rayon );
Has_Items = TRUE; Has_Items = TRUE;
} }
else else
{ {
cx = min( ptr->m_Start.x, ptr->m_End.x ); cx = MIN( ptr->m_Start.x, ptr->m_End.x );
cy = min( ptr->m_Start.y, ptr->m_End.y ); cy = MIN( ptr->m_Start.y, ptr->m_End.y );
xmin = min( xmin, cx - d ); xmin = MIN( xmin, cx - d );
ymin = min( ymin, cy - d ); ymin = MIN( ymin, cy - d );
cx = max( ptr->m_Start.x, ptr->m_End.x ); cx = MAX( ptr->m_Start.x, ptr->m_End.x );
cy = max( ptr->m_Start.y, ptr->m_End.y ); cy = MAX( ptr->m_Start.y, ptr->m_End.y );
xmax = max( xmax, cx + d ); xmax = MAX( xmax, cx + d );
ymax = max( ymax, cy + d ); ymax = MAX( ymax, cy + d );
Has_Items = TRUE; Has_Items = TRUE;
} }
} }
@ -185,19 +185,19 @@ bool BOARD::ComputeBoundaryBox( void )
for( ; module != NULL; module = (MODULE*) module->Pnext ) for( ; module != NULL; module = (MODULE*) module->Pnext )
{ {
Has_Items = TRUE; Has_Items = TRUE;
xmin = min( xmin, ( module->m_Pos.x + module->m_BoundaryBox.GetX() ) ); xmin = MIN( xmin, ( module->m_Pos.x + module->m_BoundaryBox.GetX() ) );
ymin = min( ymin, ( module->m_Pos.y + module->m_BoundaryBox.GetY() ) ); ymin = MIN( ymin, ( module->m_Pos.y + module->m_BoundaryBox.GetY() ) );
xmax = max( xmax, module->m_Pos.x + module->m_BoundaryBox.GetRight() ); xmax = MAX( xmax, module->m_Pos.x + module->m_BoundaryBox.GetRight() );
ymax = max( ymax, module->m_Pos.y + module->m_BoundaryBox.GetBottom() ); ymax = MAX( ymax, module->m_Pos.y + module->m_BoundaryBox.GetBottom() );
D_PAD* pt_pad = module->m_Pads; D_PAD* pt_pad = module->m_Pads;
for( ; pt_pad != NULL; pt_pad = (D_PAD*) pt_pad->Pnext ) for( ; pt_pad != NULL; pt_pad = (D_PAD*) pt_pad->Pnext )
{ {
d = pt_pad->m_Rayon; d = pt_pad->m_Rayon;
xmin = min( xmin, pt_pad->m_Pos.x - d ); xmin = MIN( xmin, pt_pad->m_Pos.x - d );
ymin = min( ymin, pt_pad->m_Pos.y - d ); ymin = MIN( ymin, pt_pad->m_Pos.y - d );
xmax = max( xmax, pt_pad->m_Pos.x + d ); xmax = MAX( xmax, pt_pad->m_Pos.x + d );
ymax = max( ymax, pt_pad->m_Pos.y + d ); ymax = MAX( ymax, pt_pad->m_Pos.y + d );
} }
} }
@ -205,28 +205,28 @@ bool BOARD::ComputeBoundaryBox( void )
for( Track = m_Track; Track != NULL; Track = (TRACK*) Track->Pnext ) for( Track = m_Track; Track != NULL; Track = (TRACK*) Track->Pnext )
{ {
d = (Track->m_Width / 2) + 1; d = (Track->m_Width / 2) + 1;
cx = min( Track->m_Start.x, Track->m_End.x ); cx = MIN( Track->m_Start.x, Track->m_End.x );
cy = min( Track->m_Start.y, Track->m_End.y ); cy = MIN( Track->m_Start.y, Track->m_End.y );
xmin = min( xmin, cx - d ); xmin = MIN( xmin, cx - d );
ymin = min( ymin, cy - d ); ymin = MIN( ymin, cy - d );
cx = max( Track->m_Start.x, Track->m_End.x ); cx = MAX( Track->m_Start.x, Track->m_End.x );
cy = max( Track->m_Start.y, Track->m_End.y ); cy = MAX( Track->m_Start.y, Track->m_End.y );
xmax = max( xmax, cx + d ); xmax = MAX( xmax, cx + d );
ymax = max( ymax, cy + d ); ymax = MAX( ymax, cy + d );
Has_Items = TRUE; Has_Items = TRUE;
} }
for( Track = m_Zone; Track != NULL; Track = (TRACK*) Track->Pnext ) for( Track = m_Zone; Track != NULL; Track = (TRACK*) Track->Pnext )
{ {
d = (Track->m_Width / 2) + 1; d = (Track->m_Width / 2) + 1;
cx = min( Track->m_Start.x, Track->m_End.x ); cx = MIN( Track->m_Start.x, Track->m_End.x );
cy = min( Track->m_Start.y, Track->m_End.y ); cy = MIN( Track->m_Start.y, Track->m_End.y );
xmin = min( xmin, cx - d ); xmin = MIN( xmin, cx - d );
ymin = min( ymin, cy - d ); ymin = MIN( ymin, cy - d );
cx = max( Track->m_Start.x, Track->m_End.x ); cx = MAX( Track->m_Start.x, Track->m_End.x );
cy = max( Track->m_Start.y, Track->m_End.y ); cy = MAX( Track->m_Start.y, Track->m_End.y );
xmax = max( xmax, cx + d ); xmax = MAX( xmax, cx + d );
ymax = max( ymax, cy + d ); ymax = MAX( ymax, cy + d );
Has_Items = TRUE; Has_Items = TRUE;
} }
@ -378,7 +378,7 @@ EDA_BaseStruct* BOARD::FindPadOrModule( const wxPoint& refPos, int layer )
class PadOrModule : public INSPECTOR class PadOrModule : public INSPECTOR
{ {
public: public:
EDA_BaseStruct* found; BOARD_ITEM* found;
int layer; int layer;
int layer_mask; int layer_mask;
@ -388,46 +388,47 @@ EDA_BaseStruct* BOARD::FindPadOrModule( const wxPoint& refPos, int layer )
SEARCH_RESULT Inspect( EDA_BaseStruct* testItem, const void* testData ) SEARCH_RESULT Inspect( EDA_BaseStruct* testItem, const void* testData )
{ {
BOARD_ITEM* item = (BOARD_ITEM*) testItem;
const wxPoint& refPos = *(const wxPoint*) testData; const wxPoint& refPos = *(const wxPoint*) testData;
if( testItem->m_StructType == TYPEPAD ) if( item->m_StructType == TYPEPAD )
{ {
D_PAD* pad = (D_PAD*) testItem; D_PAD* pad = (D_PAD*) item;
if( pad->HitTest( refPos ) ) if( pad->HitTest( refPos ) )
{ {
if( layer_mask & pad->m_Masque_Layer ) if( layer_mask & pad->m_Masque_Layer )
{ {
found = testItem; found = item;
return SEARCH_QUIT; return SEARCH_QUIT;
} }
else if( !found ) else if( !found )
{ {
MODULE* parent = (MODULE*) pad->m_Parent; MODULE* parent = (MODULE*) pad->m_Parent;
if( IsModuleLayerVisible( parent->m_Layer ) ) if( IsModuleLayerVisible( parent->GetLayer() ) )
found = testItem; found = item;
} }
} }
} }
else if( testItem->m_StructType == TYPEMODULE ) else if( item->m_StructType == TYPEMODULE )
{ {
MODULE* module = (MODULE*) testItem; MODULE* module = (MODULE*) item;
// consider only visible modules // consider only visible modules
if( IsModuleLayerVisible( module->m_Layer ) ) if( IsModuleLayerVisible( module->GetLayer() ) )
{ {
if( module->HitTest( refPos ) ) if( module->HitTest( refPos ) )
{ {
if( layer == module->m_Layer ) if( layer == module->GetLayer() )
{ {
found = testItem; found = item;
return SEARCH_QUIT; return SEARCH_QUIT;
} }
// layer mismatch, save in case we don't find a // layer mismatch, save in case we don't find a
// future layer match hit. // future layer match hit.
if( !found ) if( !found )
found = testItem; found = item;
} }
} }
} }

25
pcbnew/class_cotation.cpp
View File

@ -11,8 +11,8 @@
#include "wxstruct.h" #include "wxstruct.h"
COTATION::COTATION( EDA_BaseStruct* StructFather ) : COTATION::COTATION( BOARD_ITEM* StructFather ) :
EDA_BaseStruct( StructFather, TYPECOTATION ) BOARD_ITEM( StructFather, TYPECOTATION )
{ {
m_Layer = DRAW_LAYER; m_Layer = DRAW_LAYER;
m_Width = 50; m_Width = 50;
@ -24,7 +24,7 @@ COTATION::COTATION( EDA_BaseStruct* StructFather ) :
/* Effacement memoire de la structure */ /* Effacement memoire de la structure */
COTATION::~COTATION( void ) COTATION::~COTATION()
{ {
delete m_Text; delete m_Text;
} }
@ -44,7 +44,7 @@ void COTATION::UnLink( void )
} }
else /* Le chainage arriere pointe sur la structure "Pere" */ else /* Le chainage arriere pointe sur la structure "Pere" */
{ {
( (BOARD*) Pback )->m_Drawings = Pnext; ( (BOARD*) Pback )->m_Drawings = (BOARD_ITEM*) Pnext;
} }
} }
@ -68,7 +68,7 @@ void COTATION::Copy( COTATION* source )
/*************************************/ /*************************************/
{ {
m_Value = source->m_Value; m_Value = source->m_Value;
m_Layer = source->m_Layer; SetLayer( source->GetLayer() );
m_Width = source->m_Width; m_Width = source->m_Width;
m_Pos = source->m_Pos; m_Pos = source->m_Pos;
m_Shape = source->m_Shape; m_Shape = source->m_Shape;
@ -112,15 +112,18 @@ bool COTATION::ReadCotationDescr( FILE* File, int* LineNum )
if( Line[0] == 'G' ) if( Line[0] == 'G' )
{ {
sscanf( Line + 2, " %d %d %lX", &m_Shape, &m_Layer, &m_TimeStamp ); int layer;
sscanf( Line + 2, " %d %d %lX", &m_Shape, &layer, &m_TimeStamp );
/* Mise a jour des param .layer des sous structures */ /* Mise a jour des param .layer des sous structures */
if( m_Layer < FIRST_NO_COPPER_LAYER ) if( layer < FIRST_NO_COPPER_LAYER )
m_Layer = FIRST_NO_COPPER_LAYER; layer = FIRST_NO_COPPER_LAYER;
if( m_Layer > LAST_NO_COPPER_LAYER ) if( layer > LAST_NO_COPPER_LAYER )
m_Layer = LAST_NO_COPPER_LAYER; layer = LAST_NO_COPPER_LAYER;
m_Text->m_Layer = m_Layer; SetLayer( layer );
m_Text->SetLayer( layer );
continue; continue;
} }

6
pcbnew/class_cotation.h
View File

@ -6,7 +6,7 @@
#include "base_struct.h" #include "base_struct.h"
class COTATION : public EDA_BaseStruct class COTATION : public BOARD_ITEM
{ {
public: public:
int m_Width; int m_Width;
@ -25,8 +25,8 @@ public:
int FlecheG2_ox, FlecheG2_oy, FlecheG2_fx, FlecheG2_fy; int FlecheG2_ox, FlecheG2_oy, FlecheG2_fx, FlecheG2_fy;
public: public:
COTATION( EDA_BaseStruct* StructFather ); COTATION( BOARD_ITEM* StructFather );
~COTATION( void ); ~COTATION();
bool ReadCotationDescr( FILE* File, int* LineNum ); bool ReadCotationDescr( FILE* File, int* LineNum );
bool WriteCotationDescr( FILE* File ); bool WriteCotationDescr( FILE* File );

8
pcbnew/class_edge_mod.cpp
View File

@ -29,7 +29,7 @@
/******************************************/ /******************************************/
EDGE_MODULE::EDGE_MODULE( MODULE* parent ) : EDGE_MODULE::EDGE_MODULE( MODULE* parent ) :
EDA_BaseLineStruct( parent, TYPEEDGEMODULE ) BOARD_ITEM( parent, TYPEEDGEMODULE )
{ {
m_Shape = S_SEGMENT; m_Shape = S_SEGMENT;
m_Angle = 0; m_Angle = 0;
@ -91,7 +91,7 @@ void EDGE_MODULE::UnLink( void )
} }
else /* Le chainage arriere pointe sur la structure "Pere" */ else /* Le chainage arriere pointe sur la structure "Pere" */
{ {
( (MODULE*) Pback )->m_Drawings = Pnext; ( (MODULE*) Pback )->m_Drawings = (BOARD_ITEM*) Pnext;
} }
} }
@ -287,10 +287,10 @@ void EDGE_MODULE::Display_Infos( WinEDA_DrawFrame* frame )
Affiche_1_Parametre( frame, 24, _( "TimeStamp" ), bufcar, BROWN ); Affiche_1_Parametre( frame, 24, _( "TimeStamp" ), bufcar, BROWN );
Affiche_1_Parametre( frame, 34, _( "Mod Layer" ), ReturnPcbLayerName( module->m_Layer ), RED ); Affiche_1_Parametre( frame, 34, _( "Mod Layer" ), ReturnPcbLayerName( module->GetLayer() ), RED );
Affiche_1_Parametre( frame, 44, _( "Seg Layer" ), Affiche_1_Parametre( frame, 44, _( "Seg Layer" ),
ReturnPcbLayerName( module->m_Layer ), RED ); ReturnPcbLayerName( module->GetLayer() ), RED );
valeur_param( m_Width, bufcar ); valeur_param( m_Width, bufcar );
Affiche_1_Parametre( frame, 54, _( "Width" ), bufcar, BLUE ); Affiche_1_Parametre( frame, 54, _( "Width" ), bufcar, BLUE );

6
pcbnew/class_edge_mod.h
View File

@ -7,9 +7,13 @@ class Pcb3D_GLCanvas;
/* description des contours (empreintes ) et TYPES des CONTOURS : */ /* description des contours (empreintes ) et TYPES des CONTOURS : */
class EDGE_MODULE : public EDA_BaseLineStruct class EDGE_MODULE : public BOARD_ITEM
{ {
public: public:
int m_Width; // 0 = line, > 0 = tracks, bus ...
wxPoint m_Start; // Line start point
wxPoint m_End; // Line end point
int m_Shape; // voir "enum Track_Shapes" int m_Shape; // voir "enum Track_Shapes"
wxPoint m_Start0; // coord relatives a l'ancre du point de depart(Orient 0) wxPoint m_Start0; // coord relatives a l'ancre du point de depart(Orient 0)
wxPoint m_End0; // coord relatives a l'ancre du point de fin (Orient 0) wxPoint m_End0; // coord relatives a l'ancre du point de fin (Orient 0)

6
pcbnew/class_equipot.cpp
View File

@ -22,8 +22,8 @@
/*********************************************************/ /*********************************************************/
/* Constructeur de la classe EQUIPOT */ /* Constructeur de la classe EQUIPOT */
EQUIPOT::EQUIPOT( EDA_BaseStruct* StructFather ) : EQUIPOT::EQUIPOT( BOARD_ITEM* StructFather ) :
EDA_BaseStruct( StructFather, PCB_EQUIPOT_STRUCT_TYPE ) BOARD_ITEM( StructFather, PCB_EQUIPOT_STRUCT_TYPE )
{ {
m_NetCode = 0; m_NetCode = 0;
m_NbNodes = m_NbLink = m_NbNoconn = 0; m_NbNodes = m_NbLink = m_NbNoconn = 0;
@ -39,7 +39,7 @@ EQUIPOT::EQUIPOT( EDA_BaseStruct* StructFather ) :
/* destructeut */ /* destructeut */
EQUIPOT::~EQUIPOT( void ) EQUIPOT::~EQUIPOT()
{ {
} }

6
pcbnew/class_equipot.h
View File

@ -5,7 +5,7 @@
/* Representation des descriptions des equipotentielles */ /* Representation des descriptions des equipotentielles */
class EQUIPOT : public EDA_BaseStruct class EQUIPOT : public BOARD_ITEM
{ {
public: public:
wxString m_Netname; // nom du net wxString m_Netname; // nom du net
@ -22,8 +22,8 @@ public:
CHEVELU* m_RatsnestStart; // pointeur sur debut de liste ratsnests du net CHEVELU* m_RatsnestStart; // pointeur sur debut de liste ratsnests du net
CHEVELU* m_RatsnestEnd; // pointeur sur fin de liste ratsnests du net CHEVELU* m_RatsnestEnd; // pointeur sur fin de liste ratsnests du net
EQUIPOT( EDA_BaseStruct* StructFather ); EQUIPOT( BOARD_ITEM* StructFather );
~EQUIPOT( void ); ~EQUIPOT();
/* Effacement memoire de la structure */ /* Effacement memoire de la structure */
void UnLink( void ); void UnLink( void );

8
pcbnew/class_mire.cpp
View File

@ -9,15 +9,15 @@
#include "pcbnew.h" #include "pcbnew.h"
MIREPCB::MIREPCB( EDA_BaseStruct* StructFather ) : MIREPCB::MIREPCB( BOARD_ITEM* StructFather ) :
EDA_BaseStruct( StructFather, TYPEMIRE ) BOARD_ITEM( StructFather, TYPEMIRE )
{ {
m_Shape = 0; m_Shape = 0;
m_Size = 5000; m_Size = 5000;
} }
MIREPCB::~MIREPCB( void ) MIREPCB::~MIREPCB()
{ {
} }
@ -39,7 +39,7 @@ void MIREPCB::UnLink( void )
} }
else /* Le chainage arriere pointe sur la structure "Pere" */ else /* Le chainage arriere pointe sur la structure "Pere" */
{ {
( (BOARD*) Pback )->m_Drawings = Pnext; ( (BOARD*) Pback )->m_Drawings = (BOARD_ITEM*) Pnext;
} }
} }

6
pcbnew/class_mire.h
View File

@ -7,7 +7,7 @@
#include "base_struct.h" #include "base_struct.h"
class MIREPCB : public EDA_BaseStruct class MIREPCB : public BOARD_ITEM
{ {
public: public:
int m_Width; int m_Width;
@ -16,8 +16,8 @@ public:
int m_Size; int m_Size;
public: public:
MIREPCB( EDA_BaseStruct* StructFather ); MIREPCB( BOARD_ITEM* StructFather );
~MIREPCB( void ); ~MIREPCB();
bool WriteMirePcbDescr( FILE* File ); bool WriteMirePcbDescr( FILE* File );
bool ReadMirePcbDescr( FILE* File, int* LineNum ); bool ReadMirePcbDescr( FILE* File, int* LineNum );

96
pcbnew/class_module.cpp
View File

@ -58,7 +58,8 @@ void MODULE::DrawAncre( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset
/*************************************************/ /*************************************************/
/* Constructeur de la classe MODULE */ /* Constructeur de la classe MODULE */
MODULE::MODULE( BOARD* parent ) : EDA_BaseStruct( parent, TYPEMODULE ) MODULE::MODULE( BOARD* parent ) :
BOARD_ITEM( parent, TYPEMODULE )
{ {
m_Pads = NULL; m_Pads = NULL;
m_Drawings = NULL; m_Drawings = NULL;
@ -168,9 +169,9 @@ void MODULE::Copy( MODULE* Module )
} }
/* Copy des structures auxiliaires: Drawings */ /* Copy des structures auxiliaires: Drawings */
EDA_BaseStruct* OldStruct = (EDA_BaseStruct*) Module->m_Drawings; BOARD_ITEM* OldStruct = Module->m_Drawings;
EDA_BaseStruct* NewStruct, * LastStruct = NULL; BOARD_ITEM* NewStruct, * LastStruct = NULL;
for( ; OldStruct; OldStruct = OldStruct->Pnext ) for( ; OldStruct; OldStruct = OldStruct->Next() )
{ {
NewStruct = NULL; NewStruct = NULL;
@ -423,7 +424,7 @@ int MODULE::WriteDescr( FILE* File )
m_Reference->m_Size.y, m_Reference->m_Size.x, m_Reference->m_Size.y, m_Reference->m_Size.x,
m_Reference->m_Orient + m_Orient, m_Reference->m_Width, m_Reference->m_Orient + m_Orient, m_Reference->m_Width,
m_Reference->m_Miroir ? 'N' : 'M', m_Reference->m_NoShow ? 'I' : 'V', m_Reference->m_Miroir ? 'N' : 'M', m_Reference->m_NoShow ? 'I' : 'V',
m_Reference->m_Layer, m_Reference->GetLayer(),
CONV_TO_UTF8( m_Reference->m_Text ) ); CONV_TO_UTF8( m_Reference->m_Text ) );
NbLigne++; NbLigne++;
@ -434,7 +435,7 @@ int MODULE::WriteDescr( FILE* File )
m_Value->m_Size.y, m_Value->m_Size.x, m_Value->m_Size.y, m_Value->m_Size.x,
m_Value->m_Orient + m_Orient, m_Value->m_Width, m_Value->m_Orient + m_Orient, m_Value->m_Width,
m_Value->m_Miroir ? 'N' : 'M', m_Value->m_NoShow ? 'I' : 'V', m_Value->m_Miroir ? 'N' : 'M', m_Value->m_NoShow ? 'I' : 'V',
m_Value->m_Layer, m_Value->GetLayer(),
CONV_TO_UTF8( m_Value->m_Text ) ); CONV_TO_UTF8( m_Value->m_Text ) );
NbLigne++; NbLigne++;
@ -453,7 +454,7 @@ int MODULE::WriteDescr( FILE* File )
PtText->m_Orient + m_Orient, PtText->m_Width, PtText->m_Orient + m_Orient, PtText->m_Width,
PtText->m_Miroir ? 'N' : 'M', PtText->m_Miroir ? 'N' : 'M',
PtText->m_NoShow ? 'I' : 'V', PtText->m_NoShow ? 'I' : 'V',
PtText->m_Layer, CONV_TO_UTF8( PtText->m_Text ) ); PtText->GetLayer(), CONV_TO_UTF8( PtText->m_Text ) );
NbLigne++; NbLigne++;
break; break;
@ -720,22 +721,23 @@ int MODULE::ReadDescr( FILE* File, int* LineNum )
if( LastModStruct == NULL ) if( LastModStruct == NULL )
{ {
DrawText->Pback = this; DrawText->Pback = this;
m_Drawings = (EDA_BaseStruct*) DrawText; m_Drawings = DrawText;
} }
else else
{ {
DrawText->Pback = LastModStruct; DrawText->Pback = LastModStruct;
LastModStruct->Pnext = DrawText; LastModStruct->Pnext = DrawText;
} }
LastModStruct = (EDA_BaseStruct*) DrawText; LastModStruct = DrawText;
} }
int layer;
sscanf( Line + 1, "%d %d %d %d %d %d %d %s %s %d", sscanf( Line + 1, "%d %d %d %d %d %d %d %s %s %d",
&itmp1, &itmp1,
&DrawText->m_Pos0.x, &DrawText->m_Pos0.y, &DrawText->m_Pos0.x, &DrawText->m_Pos0.y,
&DrawText->m_Size.y, &DrawText->m_Size.x, &DrawText->m_Size.y, &DrawText->m_Size.x,
&DrawText->m_Orient, &DrawText->m_Width, &DrawText->m_Orient, &DrawText->m_Width,
BufCar1, BufCar2, &DrawText->m_Layer ); BufCar1, BufCar2, &layer );
DrawText->m_Type = itmp1; DrawText->m_Type = itmp1;
DrawText->m_Orient -= m_Orient; // m_Orient texte relative au module DrawText->m_Orient -= m_Orient; // m_Orient texte relative au module
@ -748,10 +750,12 @@ int MODULE::ReadDescr( FILE* File, int* LineNum )
else else
DrawText->m_NoShow = 0; DrawText->m_NoShow = 0;
if( m_Layer == CUIVRE_N ) if( layer == CUIVRE_N )
DrawText->m_Layer = SILKSCREEN_N_CU; layer = SILKSCREEN_N_CU;
if( m_Layer == CMP_N ) else if( layer == CMP_N )
DrawText->m_Layer = SILKSCREEN_N_CMP; layer = SILKSCREEN_N_CMP;
DrawText->SetLayer( layer );
/* calcul de la position vraie */ /* calcul de la position vraie */
DrawText->SetDrawCoord(); DrawText->SetDrawCoord();
@ -961,22 +965,22 @@ void MODULE::Set_Rectangle_Encadrement( void )
uxf = pt_edge_mod->m_End0.x; uyf = pt_edge_mod->m_End0.y; uxf = pt_edge_mod->m_End0.x; uyf = pt_edge_mod->m_End0.y;
rayon = (int) hypot( (double) (cx - uxf), (double) (cy - uyf) ); rayon = (int) hypot( (double) (cx - uxf), (double) (cy - uyf) );
rayon += width; rayon += width;
m_BoundaryBox.m_Pos.x = min( m_BoundaryBox.m_Pos.x, cx - rayon ); m_BoundaryBox.m_Pos.x = MIN( m_BoundaryBox.m_Pos.x, cx - rayon );
m_BoundaryBox.m_Pos.y = min( m_BoundaryBox.m_Pos.y, cy - rayon ); m_BoundaryBox.m_Pos.y = MIN( m_BoundaryBox.m_Pos.y, cy - rayon );
xmax = max( xmax, cx + rayon ); xmax = MAX( xmax, cx + rayon );
ymax = max( ymax, cy + rayon ); ymax = MAX( ymax, cy + rayon );
break; break;
} }
default: default:
m_BoundaryBox.m_Pos.x = min( m_BoundaryBox.m_Pos.x, pt_edge_mod->m_Start0.x - width ); m_BoundaryBox.m_Pos.x = MIN( m_BoundaryBox.m_Pos.x, pt_edge_mod->m_Start0.x - width );
m_BoundaryBox.m_Pos.x = min( m_BoundaryBox.m_Pos.x, pt_edge_mod->m_End0.x - width ); m_BoundaryBox.m_Pos.x = MIN( m_BoundaryBox.m_Pos.x, pt_edge_mod->m_End0.x - width );
m_BoundaryBox.m_Pos.y = min( m_BoundaryBox.m_Pos.y, pt_edge_mod->m_Start0.y - width ); m_BoundaryBox.m_Pos.y = MIN( m_BoundaryBox.m_Pos.y, pt_edge_mod->m_Start0.y - width );
m_BoundaryBox.m_Pos.y = min( m_BoundaryBox.m_Pos.y, pt_edge_mod->m_End0.y - width ); m_BoundaryBox.m_Pos.y = MIN( m_BoundaryBox.m_Pos.y, pt_edge_mod->m_End0.y - width );
xmax = max( xmax, pt_edge_mod->m_Start0.x + width ); xmax = MAX( xmax, pt_edge_mod->m_Start0.x + width );
xmax = max( xmax, pt_edge_mod->m_End0.x + width ); xmax = MAX( xmax, pt_edge_mod->m_End0.x + width );
ymax = max( ymax, pt_edge_mod->m_Start0.y + width ); ymax = MAX( ymax, pt_edge_mod->m_Start0.y + width );
ymax = max( ymax, pt_edge_mod->m_End0.y + width ); ymax = MAX( ymax, pt_edge_mod->m_End0.y + width );
break; break;
} }
} }
@ -986,10 +990,10 @@ void MODULE::Set_Rectangle_Encadrement( void )
{ {
rayon = pad->m_Rayon; rayon = pad->m_Rayon;
cx = pad->m_Pos0.x; cy = pad->m_Pos0.y; cx = pad->m_Pos0.x; cy = pad->m_Pos0.y;
m_BoundaryBox.m_Pos.x = min( m_BoundaryBox.m_Pos.x, cx - rayon ); m_BoundaryBox.m_Pos.x = MIN( m_BoundaryBox.m_Pos.x, cx - rayon );
m_BoundaryBox.m_Pos.y = min( m_BoundaryBox.m_Pos.y, cy - rayon ); m_BoundaryBox.m_Pos.y = MIN( m_BoundaryBox.m_Pos.y, cy - rayon );
xmax = max( xmax, cx + rayon ); xmax = MAX( xmax, cx + rayon );
ymax = max( ymax, cy + rayon ); ymax = MAX( ymax, cy + rayon );
} }
m_BoundaryBox.SetWidth( xmax - m_BoundaryBox.m_Pos.x ); m_BoundaryBox.SetWidth( xmax - m_BoundaryBox.m_Pos.x );
@ -1035,22 +1039,22 @@ void MODULE::SetRectangleExinscrit( void )
uxf = EdgeMod->m_End.x; uyf = EdgeMod->m_End.y; uxf = EdgeMod->m_End.x; uyf = EdgeMod->m_End.y;
rayon = (int) hypot( (double) (cx - uxf), (double) (cy - uyf) ); rayon = (int) hypot( (double) (cx - uxf), (double) (cy - uyf) );
rayon += width; rayon += width;
m_RealBoundaryBox.m_Pos.x = min( m_RealBoundaryBox.m_Pos.x, cx - rayon ); m_RealBoundaryBox.m_Pos.x = MIN( m_RealBoundaryBox.m_Pos.x, cx - rayon );
m_RealBoundaryBox.m_Pos.y = min( m_RealBoundaryBox.m_Pos.y, cy - rayon ); m_RealBoundaryBox.m_Pos.y = MIN( m_RealBoundaryBox.m_Pos.y, cy - rayon );
xmax = max( xmax, cx + rayon ); xmax = MAX( xmax, cx + rayon );
ymax = max( ymax, cy + rayon ); ymax = MAX( ymax, cy + rayon );
break; break;
} }
default: default:
m_RealBoundaryBox.m_Pos.x = min( m_RealBoundaryBox.m_Pos.x, EdgeMod->m_Start.x - width ); m_RealBoundaryBox.m_Pos.x = MIN( m_RealBoundaryBox.m_Pos.x, EdgeMod->m_Start.x - width );
m_RealBoundaryBox.m_Pos.x = min( m_RealBoundaryBox.m_Pos.x, EdgeMod->m_End.x - width ); m_RealBoundaryBox.m_Pos.x = MIN( m_RealBoundaryBox.m_Pos.x, EdgeMod->m_End.x - width );
m_RealBoundaryBox.m_Pos.y = min( m_RealBoundaryBox.m_Pos.y, EdgeMod->m_Start.y - width ); m_RealBoundaryBox.m_Pos.y = MIN( m_RealBoundaryBox.m_Pos.y, EdgeMod->m_Start.y - width );
m_RealBoundaryBox.m_Pos.y = min( m_RealBoundaryBox.m_Pos.y, EdgeMod->m_End.y - width ); m_RealBoundaryBox.m_Pos.y = MIN( m_RealBoundaryBox.m_Pos.y, EdgeMod->m_End.y - width );
xmax = max( xmax, EdgeMod->m_Start.x + width ); xmax = MAX( xmax, EdgeMod->m_Start.x + width );
xmax = max( xmax, EdgeMod->m_End.x + width ); xmax = MAX( xmax, EdgeMod->m_End.x + width );
ymax = max( ymax, EdgeMod->m_Start.y + width ); ymax = MAX( ymax, EdgeMod->m_Start.y + width );
ymax = max( ymax, EdgeMod->m_End.y + width ); ymax = MAX( ymax, EdgeMod->m_End.y + width );
break; break;
} }
} }
@ -1060,10 +1064,10 @@ void MODULE::SetRectangleExinscrit( void )
{ {
rayon = Pad->m_Rayon; rayon = Pad->m_Rayon;
cx = Pad->m_Pos.x; cy = Pad->m_Pos.y; cx = Pad->m_Pos.x; cy = Pad->m_Pos.y;
m_RealBoundaryBox.m_Pos.x = min( m_RealBoundaryBox.m_Pos.x, cx - rayon ); m_RealBoundaryBox.m_Pos.x = MIN( m_RealBoundaryBox.m_Pos.x, cx - rayon );
m_RealBoundaryBox.m_Pos.y = min( m_RealBoundaryBox.m_Pos.y, cy - rayon ); m_RealBoundaryBox.m_Pos.y = MIN( m_RealBoundaryBox.m_Pos.y, cy - rayon );
xmax = max( xmax, cx + rayon ); xmax = MAX( xmax, cx + rayon );
ymax = max( ymax, cy + rayon ); ymax = MAX( ymax, cy + rayon );
} }
m_RealBoundaryBox.SetWidth( xmax - m_RealBoundaryBox.m_Pos.x ); m_RealBoundaryBox.SetWidth( xmax - m_RealBoundaryBox.m_Pos.x );

6
pcbnew/class_module.h
View File

@ -35,12 +35,12 @@ enum Mod_Attribut /* Attributs d'un module */
#define MODULE_is_PLACED 0x02 /* In autoplace: module automatically placed */ #define MODULE_is_PLACED 0x02 /* In autoplace: module automatically placed */
#define MODULE_to_PLACE 0x04 /* In autoplace: module waiting for autoplace */ #define MODULE_to_PLACE 0x04 /* In autoplace: module waiting for autoplace */
class MODULE : public EDA_BaseStruct class MODULE : public BOARD_ITEM
{ {
public: public:
wxPoint m_Pos; // Real coord on board wxPoint m_Pos; // Real coord on board
D_PAD* m_Pads; /* Pad list (linked list) */ D_PAD* m_Pads; /* Pad list (linked list) */
EDA_BaseStruct* m_Drawings; /* Graphic items list (linked list) */ BOARD_ITEM* m_Drawings; /* Graphic items list (linked list) */
Struct3D_Master* m_3D_Drawings; /* Pointeur sur la liste des elements de trace 3D*/ Struct3D_Master* m_3D_Drawings; /* Pointeur sur la liste des elements de trace 3D*/
TEXTE_MODULE* m_Reference; // texte reference du composant (U34, R18..) TEXTE_MODULE* m_Reference; // texte reference du composant (U34, R18..)
TEXTE_MODULE* m_Value; // texte valeur du composant (74LS00, 22K..) TEXTE_MODULE* m_Value; // texte valeur du composant (74LS00, 22K..)
@ -74,7 +74,7 @@ public:
void Copy( MODULE* Module ); // Copy structure void Copy( MODULE* Module ); // Copy structure
MODULE* Next( void ) { return (MODULE*) Pnext; } MODULE* Next() { return (MODULE*) Pnext; }
void Set_Rectangle_Encadrement( void );/* mise a jour du rect d'encadrement void Set_Rectangle_Encadrement( void );/* mise a jour du rect d'encadrement
* en coord locales (orient 0 et origine = pos module) */ * en coord locales (orient 0 et origine = pos module) */

7
pcbnew/class_pad.cpp
View File

@ -25,7 +25,8 @@
/* classe D_PAD : constructeur */ /* classe D_PAD : constructeur */
/*******************************/ /*******************************/
D_PAD::D_PAD( MODULE* parent ) : EDA_BaseStruct( parent, TYPEPAD ) D_PAD::D_PAD( MODULE* parent ) :
BOARD_ITEM( parent, TYPEPAD )
{ {
m_NumPadName = 0; m_NumPadName = 0;
m_Masque_Layer = CUIVRE_LAYER; m_Masque_Layer = CUIVRE_LAYER;
@ -520,7 +521,7 @@ void D_PAD::Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset, int
/* Trace du symbole "No connect" ( / ou \ ou croix en X) si necessaire : */ /* Trace du symbole "No connect" ( / ou \ ou croix en X) si necessaire : */
if( m_Netname.IsEmpty() && DisplayOpt.DisplayPadNoConn ) if( m_Netname.IsEmpty() && DisplayOpt.DisplayPadNoConn )
{ {
dx0 = min( dx0, dy0 ); dx0 = MIN( dx0, dy0 );
int nc_color = BLUE; int nc_color = BLUE;
if( m_Masque_Layer & CMP_LAYER ) /* Trace forme \ */ if( m_Masque_Layer & CMP_LAYER ) /* Trace forme \ */
GRLine( &panel->m_ClipBox, DC, cx0 - dx0, cy0 - dx0, GRLine( &panel->m_ClipBox, DC, cx0 - dx0, cy0 - dx0,
@ -535,7 +536,7 @@ void D_PAD::Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset, int
if( !frame->m_DisplayPadNum ) if( !frame->m_DisplayPadNum )
return; return;
dx = min( m_Size.x, m_Size.y ); /* dx = text size */ dx = MIN( m_Size.x, m_Size.y ); /* dx = text size */
if( (dx / zoom) > 12 ) /* size must be enought to draw 2 chars */ if( (dx / zoom) > 12 ) /* size must be enought to draw 2 chars */
{ {
wxString buffer; wxString buffer;

2
pcbnew/class_pad.h
View File

@ -20,7 +20,7 @@ class Pcb3D_GLCanvas;
#define PAD_STACK 0x80 // bit 7 de .attrib (flag) #define PAD_STACK 0x80 // bit 7 de .attrib (flag)
/* Definition type Structure d'un pad */ /* Definition type Structure d'un pad */
class D_PAD : public EDA_BaseStruct class D_PAD : public BOARD_ITEM
{ {
public: public:
union union

8
pcbnew/class_pcb_text.cpp
View File

@ -15,15 +15,15 @@
/* class TEXTE_PCB */ /* class TEXTE_PCB */
/*******************/ /*******************/
TEXTE_PCB::TEXTE_PCB( EDA_BaseStruct* parent ) : TEXTE_PCB::TEXTE_PCB( BOARD_ITEM* parent ) :
EDA_BaseStruct( parent, TYPETEXTE ), BOARD_ITEM( parent, TYPETEXTE ),
EDA_TextStruct() EDA_TextStruct()
{ {
} }
/* Destructeur */ /* Destructeur */
TEXTE_PCB:: ~TEXTE_PCB( void ) TEXTE_PCB:: ~TEXTE_PCB()
{ {
} }
@ -59,7 +59,7 @@ void TEXTE_PCB::UnLink( void )
} }
else /* Le chainage arriere pointe sur la structure "Pere" */ else /* Le chainage arriere pointe sur la structure "Pere" */
{ {
( (BOARD*) Pback )->m_Drawings = Pnext; ( (BOARD*) Pback )->m_Drawings = (BOARD_ITEM*) Pnext;
} }
} }

6
pcbnew/class_pcb_text.h
View File

@ -6,12 +6,12 @@
#include "base_struct.h" #include "base_struct.h"
class TEXTE_PCB : public EDA_BaseStruct, public EDA_TextStruct class TEXTE_PCB : public BOARD_ITEM, public EDA_TextStruct
{ {
public: public:
TEXTE_PCB(EDA_BaseStruct * parent); TEXTE_PCB( BOARD_ITEM* parent );
TEXTE_PCB( TEXTE_PCB* textepcb ); TEXTE_PCB( TEXTE_PCB* textepcb );
~TEXTE_PCB(void); ~TEXTE_PCB();
/* supprime du chainage la structure Struct */ /* supprime du chainage la structure Struct */
void UnLink( void ); void UnLink( void );

38
pcbnew/class_text_mod.cpp
View File

@ -28,7 +28,7 @@
/* Constructeur de TEXTE_MODULE */ /* Constructeur de TEXTE_MODULE */
TEXTE_MODULE::TEXTE_MODULE( MODULE* parent, int text_type ) : TEXTE_MODULE::TEXTE_MODULE( MODULE* parent, int text_type ) :
EDA_BaseStruct( parent, TYPETEXTEMODULE ) BOARD_ITEM( parent, TYPETEXTEMODULE )
{ {
MODULE* Module = (MODULE*) m_Parent; MODULE* Module = (MODULE*) m_Parent;
@ -41,20 +41,29 @@ TEXTE_MODULE::TEXTE_MODULE( MODULE* parent, int text_type ) :
m_Orient = 0; /* en 1/10 degre */ m_Orient = 0; /* en 1/10 degre */
m_Miroir = 1; // Mode normal (pas de miroir) m_Miroir = 1; // Mode normal (pas de miroir)
m_Unused = 0; m_Unused = 0;
m_Layer = SILKSCREEN_N_CMP;
SetLayer( SILKSCREEN_N_CMP );
if( Module && (Module->m_StructType == TYPEMODULE) ) if( Module && (Module->m_StructType == TYPEMODULE) )
{ {
m_Pos = Module->m_Pos; m_Pos = Module->m_Pos;
m_Layer = Module->m_Layer;
if( Module->m_Layer == CUIVRE_N ) int moduleLayer = Module->GetLayer();
m_Layer = SILKSCREEN_N_CU;
if( Module->m_Layer == CMP_N ) if( moduleLayer == CUIVRE_N )
m_Layer = SILKSCREEN_N_CMP; SetLayer( SILKSCREEN_N_CU );
if( (Module->m_Layer == SILKSCREEN_N_CU) else if( moduleLayer == CMP_N )
|| (Module->m_Layer == ADHESIVE_N_CU) || (Module->m_Layer == CUIVRE_N) ) SetLayer( SILKSCREEN_N_CMP );
else
SetLayer( moduleLayer );
if( moduleLayer == SILKSCREEN_N_CU
|| moduleLayer == ADHESIVE_N_CU
|| moduleLayer == CUIVRE_N )
{
m_Miroir = 0; m_Miroir = 0;
} }
} }
}
TEXTE_MODULE::~TEXTE_MODULE( void ) TEXTE_MODULE::~TEXTE_MODULE( void )
@ -68,7 +77,7 @@ void TEXTE_MODULE::Copy( TEXTE_MODULE* source ) // copy structure
return; return;
m_Pos = source->m_Pos; m_Pos = source->m_Pos;
m_Layer = source->m_Layer; SetLayer( source->GetLayer() );
m_Miroir = source->m_Miroir; // vue normale / miroir m_Miroir = source->m_Miroir; // vue normale / miroir
m_NoShow = source->m_NoShow; // 0: visible 1: invisible m_NoShow = source->m_NoShow; // 0: visible 1: invisible
@ -97,7 +106,7 @@ void TEXTE_MODULE::UnLink( void )
} }
else /* Le chainage arriere pointe sur la structure "Pere" */ else /* Le chainage arriere pointe sur la structure "Pere" */
{ {
( (MODULE*) Pback )->m_Drawings = Pnext; ( (MODULE*) Pback )->m_Drawings = (BOARD_ITEM*) Pnext;
} }
} }
@ -245,11 +254,12 @@ void TEXTE_MODULE::Draw( WinEDA_DrawPanel* panel, wxDC* DC, wxPoint offset, int
pos.x, pos.y + anchor_size, 0, g_AnchorColor ); pos.x, pos.y + anchor_size, 0, g_AnchorColor );
} }
color = g_DesignSettings.m_LayerColor[Module->m_Layer]; color = g_DesignSettings.m_LayerColor[Module->GetLayer()];
if( Module && Module->m_Layer == CUIVRE_N ) if( Module && Module->GetLayer() == CUIVRE_N )
color = g_ModuleTextCUColor; color = g_ModuleTextCUColor;
if( Module && Module->m_Layer == CMP_N )
else if( Module && Module->GetLayer() == CMP_N )
color = g_ModuleTextCMPColor; color = g_ModuleTextCMPColor;
if( (color & ITEM_NOT_SHOW) != 0 ) if( (color & ITEM_NOT_SHOW) != 0 )

2
pcbnew/class_text_mod.h
View File

@ -13,7 +13,7 @@
#define TEXT_is_DIVERS 2 #define TEXT_is_DIVERS 2
class TEXTE_MODULE : public EDA_BaseStruct class TEXTE_MODULE : public BOARD_ITEM
{ {
public: public:
int m_Width; int m_Width;

18
pcbnew/class_track.cpp
View File

@ -22,8 +22,8 @@
/* Constructeur des classes type pistes, vias et zones */ /* Constructeur des classes type pistes, vias et zones */
TRACK::TRACK( EDA_BaseStruct* StructFather, DrawStructureType idtype ) : TRACK::TRACK( BOARD_ITEM* StructFather, DrawStructureType idtype ) :
EDA_BaseLineStruct( StructFather, idtype ) BOARD_ITEM( StructFather, idtype )
{ {
m_Shape = S_SEGMENT; m_Shape = S_SEGMENT;
start = end = NULL; start = end = NULL;
@ -35,13 +35,13 @@ TRACK::TRACK( EDA_BaseStruct* StructFather, DrawStructureType idtype ) :
SEGZONE::SEGZONE( EDA_BaseStruct* StructFather ) : SEGZONE::SEGZONE( BOARD_ITEM* StructFather ) :
TRACK( StructFather, TYPEZONE ) TRACK( StructFather, TYPEZONE )
{ {
} }
SEGVIA::SEGVIA( EDA_BaseStruct* StructFather ) : SEGVIA::SEGVIA( BOARD_ITEM* StructFather ) :
TRACK( StructFather, TYPEVIA ) TRACK( StructFather, TYPEVIA )
{ {
} }
@ -50,7 +50,7 @@ SEGVIA::SEGVIA( EDA_BaseStruct* StructFather ) :
/* Copy constructor */ /* Copy constructor */
TRACK::TRACK( const TRACK& Source ) : TRACK::TRACK( const TRACK& Source ) :
EDA_BaseLineStruct( Source.m_Parent, (DrawStructureType)Source.m_StructType ) BOARD_ITEM( (const BOARD_ITEM&) Source )
{ {
m_StructType = Source.m_StructType; m_StructType = Source.m_StructType;
m_Shape = Source.m_Shape; m_Shape = Source.m_Shape;
@ -235,14 +235,6 @@ void SEGVIA::ReturnLayerPair( int* top_layer, int* bottom_layer )
} }
/************************/
TRACK* TRACK::Next( void )
/************************/
{
return (TRACK*) Pnext;
}
/* supprime du chainage la structure Struct /* supprime du chainage la structure Struct
* les structures arrieres et avant sont chainees directement * les structures arrieres et avant sont chainees directement
*/ */

24
pcbnew/class_track.h
View File

@ -19,12 +19,19 @@
/***/ /***/
class TRACK : public EDA_BaseLineStruct class TRACK : public BOARD_ITEM
{ {
public: public:
int m_Width; // 0 = line, > 0 = tracks, bus ...
wxPoint m_Start; // Line start point
wxPoint m_End; // Line end point
int m_Shape; // vias: shape and type, Track = shape.. int m_Shape; // vias: shape and type, Track = shape..
int m_Drill; // for vias: via drill (- 1 for default value) int m_Drill; // for vias: via drill (- 1 for default value)
EDA_BaseStruct* start, * end; // pointers on a connected item (pad or track)
BOARD_ITEM* start; // pointers on a connected item (pad or track)
BOARD_ITEM* end;
int m_NetCode; // Net number int m_NetCode; // Net number
int m_Sous_Netcode; /* In rastnest routines : for the current net, int m_Sous_Netcode; /* In rastnest routines : for the current net,
* block number (number common to the current connected items found) */ * block number (number common to the current connected items found) */
@ -33,15 +40,12 @@ public:
int m_Param; // Auxiliary variable ( used in some computations ) int m_Param; // Auxiliary variable ( used in some computations )
public: public:
TRACK( EDA_BaseStruct* StructFather, DrawStructureType idtype = TYPETRACK ); TRACK( BOARD_ITEM* StructFather, DrawStructureType idtype = TYPETRACK );
TRACK( const TRACK& track ); TRACK( const TRACK& track );
TRACK* Next( void ); // Retourne le chainage avant TRACK* Next() { return (TRACK*) Pnext; }
TRACK* Back( void ) // Retourne le chainage avant TRACK* Back() { return (TRACK*) Pback; }
{
return (TRACK*) Pback;
}
/* supprime du chainage la structure Struct */ /* supprime du chainage la structure Struct */
@ -122,7 +126,7 @@ public:
class SEGZONE : public TRACK class SEGZONE : public TRACK
{ {
public: public:
SEGZONE( EDA_BaseStruct* StructFather ); SEGZONE( BOARD_ITEM* StructFather );
#if defined(DEBUG) #if defined(DEBUG)
/** /**
@ -141,7 +145,7 @@ public:
class SEGVIA : public TRACK class SEGVIA : public TRACK
{ {
public: public:
SEGVIA( EDA_BaseStruct* StructFather ); SEGVIA( BOARD_ITEM* StructFather );
bool IsViaOnLayer( int layer ); bool IsViaOnLayer( int layer );
void SetLayerPair( int top_layer, int bottom_layer ); void SetLayerPair( int top_layer, int bottom_layer );
void ReturnLayerPair( int* top_layer, int* bottom_layer ); void ReturnLayerPair( int* top_layer, int* bottom_layer );

14
pcbnew/classpcb.cpp
View File

@ -35,7 +35,7 @@ void EDA_BaseStruct::Place( WinEDA_DrawFrame* frame, wxDC* DC )
/**********************/ /**********************/
/* Classe EDGE_ZONE: constructeur */ /* Classe EDGE_ZONE: constructeur */
EDGE_ZONE::EDGE_ZONE( EDA_BaseStruct* parent ) : EDGE_ZONE::EDGE_ZONE( BOARD_ITEM* parent ) :
DRAWSEGMENT( parent, TYPEEDGEZONE ) DRAWSEGMENT( parent, TYPEEDGEZONE )
{ {
} }
@ -52,8 +52,8 @@ EDGE_ZONE:: ~EDGE_ZONE( void )
/**********************/ /**********************/
/* Classe DRAWSEGMENT: constructeur */ /* Classe DRAWSEGMENT: constructeur */
DRAWSEGMENT::DRAWSEGMENT( EDA_BaseStruct* StructFather, DrawStructureType idtype ) : DRAWSEGMENT::DRAWSEGMENT( BOARD_ITEM* StructFather, DrawStructureType idtype ) :
EDA_BaseLineStruct( StructFather, idtype ) BOARD_ITEM( StructFather, idtype )
{ {
m_Flags = m_Shape = m_Type = m_Angle = 0; m_Flags = m_Shape = m_Type = m_Angle = 0;
} }
@ -76,7 +76,7 @@ void DRAWSEGMENT::UnLink( void )
} }
else /* Le chainage arriere pointe sur la structure "Pere" */ else /* Le chainage arriere pointe sur la structure "Pere" */
{ {
( (BOARD*) Pback )->m_Drawings = Pnext; ( (BOARD*) Pback )->m_Drawings = (BOARD_ITEM*) Pnext;
} }
} }
@ -262,8 +262,8 @@ bool DRAWSEGMENT::HitTest( const wxPoint& ref_pos )
/* Classe MARQUEUR */ /* Classe MARQUEUR */
/*******************/ /*******************/
MARQUEUR::MARQUEUR( EDA_BaseStruct* StructFather ) : MARQUEUR::MARQUEUR( BOARD_ITEM* StructFather ) :
EDA_BaseStruct( StructFather, TYPEMARQUEUR ) BOARD_ITEM( StructFather, TYPEMARQUEUR )
{ {
m_Bitmap = NULL; m_Bitmap = NULL;
m_Type = 0; m_Type = 0;
@ -291,7 +291,7 @@ void MARQUEUR::UnLink( void )
} }
else /* Le chainage arriere pointe sur la structure "Pere" */ else /* Le chainage arriere pointe sur la structure "Pere" */
{ {
( (BOARD*) Pback )->m_Drawings = Pnext; ( (BOARD*) Pback )->m_Drawings = (BOARD_ITEM*) Pnext;
} }
} }

6
pcbnew/clean.cpp
View File

@ -379,7 +379,7 @@ static int clean_segments( WinEDA_PcbFrame* frame, wxDC* DC )
if( PtSegm->m_StructType != pt_aux->m_StructType ) if( PtSegm->m_StructType != pt_aux->m_StructType )
continue; continue;
if( PtSegm->m_Layer != pt_aux->m_Layer ) if( PtSegm->GetLayer() != pt_aux->GetLayer() )
continue; continue;
if( PtSegm->m_NetCode != pt_aux->m_NetCode ) if( PtSegm->m_NetCode != pt_aux->m_NetCode )
break; break;
@ -587,7 +587,7 @@ static TRACK* AlignSegment( BOARD* Pcb, TRACK* pt_ref, TRACK* pt_segm, int extre
{ {
/* Ce ne doit pas etre sur un pad */ /* Ce ne doit pas etre sur un pad */
if( Fast_Locate_Pad_Connecte( Pcb, pt_ref->m_Start, if( Fast_Locate_Pad_Connecte( Pcb, pt_ref->m_Start,
g_TabOneLayerMask[pt_ref->m_Layer] ) ) g_TabOneLayerMask[pt_ref->GetLayer()] ) )
return NULL; return NULL;
if( (pt_ref->m_Start.x == pt_segm->m_Start.x) if( (pt_ref->m_Start.x == pt_segm->m_Start.x)
@ -605,7 +605,7 @@ static TRACK* AlignSegment( BOARD* Pcb, TRACK* pt_ref, TRACK* pt_segm, int extre
else /* extremite == END */ else /* extremite == END */
{ {
/* Ce ne doit pas etre sur un pad */ /* Ce ne doit pas etre sur un pad */
if( Fast_Locate_Pad_Connecte( Pcb, pt_ref->m_End, g_TabOneLayerMask[pt_ref->m_Layer] ) ) if( Fast_Locate_Pad_Connecte( Pcb, pt_ref->m_End, g_TabOneLayerMask[pt_ref->GetLayer()] ) )
return NULL; return NULL;
if( pt_ref->m_End == pt_segm->m_Start ) if( pt_ref->m_End == pt_segm->m_Start )

134
pcbnew/collectors.cpp Normal file
View File

@ -0,0 +1,134 @@
/*
* This program source code file is part of KICAD, a free EDA CAD application.
*
* Copyright (C) 2007 Dick Hollenbeck, dick@softplc.com
* Copyright (C) 2004-2007 Kicad Developers, see change_log.txt for contributors.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, you may find one here:
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
* or you may search the http://www.gnu.org website for the version 2 license,
* or you may write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#if defined(DEBUG)
#include "collectors.h"
#include "pcbnew.h" // class BOARD
/* This module contains out of line member functions for classes given in
collectors.h. Those classes augment the functionality of class WinEDA_PcbFrame.
*/
// see collectors.h
const KICAD_T ARROWCOLLECTOR::AllBoardItems[] = {
TYPETEXTE,
TYPEDRAWSEGMENT,
TYPECOTATION,
TYPEVIA,
TYPETRACK,
TYPEPAD,
TYPETEXTEMODULE,
TYPEMODULE,
EOT
};
/**
* Function Inspect
* is the examining function within the INSPECTOR which is passed to the
* Iterate function. Searches and collects all the objects that the old
* function PcbGeneralLocateAndDisplay() would find, except that it keeps all
* that it finds and does not do any displaying.
*
* @param testItem An EDA_BaseStruct to examine.
* @param notUsed The const void* testData.
* @return SEARCH_RESULT - SEARCH_QUIT if the Iterator is to stop the scan,
* else SCAN_CONTINUE;
*/
SEARCH_RESULT ARROWCOLLECTOR::Inspect( EDA_BaseStruct* testItem, const void* notUsed )
{
BOARD_ITEM* item = (BOARD_ITEM*) testItem;
switch( item->m_StructType )
{
case TYPEPAD:
case TYPEVIA:
/*
if( item->IsOnOneOfTheseLayers( m_LayerMask ) )
{
if( item->HitTest( refPos ) )
Append2nd( testItem );
}
*/
break;
case TYPETRACK:
case TYPETEXTE:
case TYPEDRAWSEGMENT:
case TYPECOTATION:
case TYPETEXTEMODULE:
case TYPEMODULE:
if( item->GetLayer() == m_PreferredLayer )
{
if( item->HitTest( m_RefPos ) )
Append( item );
}
/*
else if( item->IsOnOneOfTheseLayers( m_LayerMask ) )
{
if( item->HitTest( m_RefPos ) )
Append2nd( item );
}
*/
break;
default:
; // nothing
}
return SEARCH_CONTINUE;
}
// see collectors.h
void ARROWCOLLECTOR::Scan( BOARD* board, const wxPoint& refPos,
int aPreferredLayer, int aLayerMask )
{
Empty(); // empty the collection, primary criteria list
Empty2nd(); // empty the collection, secondary criteria list
/* remember where the snapshot was taken from and pass refPos to
the Inspect() function.
*/
SetRefPos( refPos );
// visit the board with the INSPECTOR (me).
board->Visit( this, // INSPECTOR* inspector
NULL, // const void* testData, not used here
m_ScanTypes);
SetTimeNow(); // when snapshot was taken
// @todo: append 2nd list onto end of the first "list"
Empty2nd();
}
#endif // DEBUG
//EOF

141
pcbnew/collectors.h Normal file
View File

@ -0,0 +1,141 @@
/*
* This program source code file is part of KICAD, a free EDA CAD application.
*
* Copyright (C) 2007 Dick Hollenbeck, dick@softplc.com
* Copyright (C) 2004-2007 Kicad Developers, see change_log.txt for contributors.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, you may find one here:
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
* or you may search the http://www.gnu.org website for the version 2 license,
* or you may write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef COLLECTORS_H
#define COLLECTORS_H
/* This module contains a number of COLLECTOR implementations which are used
to augment the functionality of class WinEDA_PcbFrame.
*/
#include "class_collector.h"
class RAT1COLLECTOR : public COLLECTOR
{
;
};
/**
* Class ARROWCOLLECTOR
* is intended for use when the right click button is pressed, or when the
* plain "arrow" tool is in effect. This class can be used by window classes
* such as WinEDA_PcbFrame.
*
* Philosophy: this class knows nothing of the context in which as BOARD is used
* and that means it knows nothing about which layers are visible or current,
* but can handle those concerns by the SetPreferredLayer() function and the
* SetLayerMask() fuction.
*/
class ARROWCOLLECTOR : public COLLECTOR
{
/**
* A place to hold collected objects which don't match precisely the search
* criteria, but would be acceptable if nothing else is found.
* "2nd" choice, which will be appended to the end of COLLECTOR's prime
* "list" at the end of the search.
*/
std::vector<EDA_BaseStruct*> list2nd;
/**
* A bit-mapped layer mask that defines any layers which are acceptable
* on a secondary search criterion basis.
*/
int m_LayerMask;
public:
/// A scan list for all editable board items, like PcbGeneralLocateAndDisplay()
static const KICAD_T AllBoardItems[];
/**
* Constructor ARROWCOLLECTOR
*/
ARROWCOLLECTOR()
{
m_LayerMask = 0;
SetScanTypes( AllBoardItems );
}
void Empty2nd()
{
list2nd.clear();
}
void Append2nd( EDA_BaseStruct* item )
{
list2nd.push_back( item );
}
/**
* Function SetLayerMask
* takes a bit-mapped layer mask and records it. During the scan/search,
* this is used as a secondary criterion. That is, if there is no direct
* layer match with COLLECTOR::m_PreferredLayer (the primary criterion),
* then an object on any layer given in this bit-map is recorded as a
* second choice object if it also HitTest()s true.
*
* @param aLayerMask A layer mask which has bits in it indicating which
* layers are acceptable. Caller must pay attention to which layers are
* visible, selected, etc. All those concerns are handled outside this
* class, as stated in the class Philosophy above.
*/
void SetLayerMask( int aLayerMask )
{
m_LayerMask = aLayerMask;
}
/**
* Function Inspect
* is the examining function within the INSPECTOR which is passed to the
* Iterate function.
*
* @param testItem An EDA_BaseStruct to examine.
* @param testData is not used in this class.
* @return SEARCH_RESULT - SEARCH_QUIT if the Iterator is to stop the scan,
* else SCAN_CONTINUE;
*/
SEARCH_RESULT Inspect( EDA_BaseStruct* testItem, const void* testData );
/**
* Function Scan
* scans a BOARD using this class's Inspector method, which does the collection.
* @param board A BOARD to scan.
* @param refPos A wxPoint to use in hit-testing.
*/
void Scan( BOARD* board, const wxPoint& refPos, int aPreferredLayer, int aLayerMask );
};
#endif // COLLECTORS_H

305
pcbnew/connect.cpp
View File

@ -31,26 +31,30 @@ static int tri_par_netcode(TRACK ** pt_ref, TRACK ** pt_compare);
static int change_equipot( TRACK* pt_start_conn, TRACK* pt_end_conn, static int change_equipot( TRACK* pt_start_conn, TRACK* pt_end_conn,
int old_val, int new_val ) int old_val, int new_val )
/*****************************************************************/ /*****************************************************************/
/* /*
Change les num locaux d'equipot old valeur en new valeur * Change les num locaux d'equipot old valeur en new valeur
retourne le nombre de changements * retourne le nombre de changements
si pt_end_conn = NULL: recherche jusqu'a fin de chaine * si pt_end_conn = NULL: recherche jusqu'a fin de chaine
*/ */
{ {
TRACK* pt_conn; TRACK* pt_conn;
int nb_change = 0; int nb_change = 0;
D_PAD* pt_pad; D_PAD* pt_pad;
if( old_val == new_val) return(0) ; if( old_val == new_val )
return 0;
if( (old_val > 0) && (old_val < new_val) ) EXCHG(old_val,new_val) ; if( (old_val > 0) && (old_val < new_val) )
EXCHG( old_val, new_val );
pt_conn = pt_start_conn; pt_conn = pt_start_conn;
for( ; pt_conn != NULL; pt_conn = (TRACK*) pt_conn->Pnext ) for( ; pt_conn != NULL; pt_conn = (TRACK*) pt_conn->Pnext )
{ {
if( pt_conn->m_Sous_Netcode != old_val ) if( pt_conn->m_Sous_Netcode != old_val )
{ {
if(pt_conn == pt_end_conn) break; if( pt_conn == pt_end_conn )
break;
continue; continue;
} }
@ -70,28 +74,32 @@ D_PAD * pt_pad;
if( pt_pad->m_physical_connexion == old_val ) if( pt_pad->m_physical_connexion == old_val )
pt_pad->m_physical_connexion = pt_conn->m_Sous_Netcode; pt_pad->m_physical_connexion = pt_conn->m_Sous_Netcode;
} }
if(pt_conn == pt_end_conn) break; if( pt_conn == pt_end_conn )
break;
} }
return(nb_change);
return nb_change;
} }
/******************************************************************/ /******************************************************************/
static void propage_equipot( TRACK* pt_start_conn, TRACK* pt_end_conn ) static void propage_equipot( TRACK* pt_start_conn, TRACK* pt_end_conn )
/******************************************************************/ /******************************************************************/
/* balaye la liste des SEGMENTS de PISTE /* balaye la liste des SEGMENTS de PISTE
- debut = pt_start_conn * - debut = pt_start_conn
- fin = pt_end_conn (pointe le dernier segment a analyser) * - fin = pt_end_conn (pointe le dernier segment a analyser)
pour attribuer ou propager un numero d'equipotentielle par * pour attribuer ou propager un numero d'equipotentielle par
blocs de connexions existantes * blocs de connexions existantes
la zone balayee est supposee appartenir au meme net, c'est a dire que * la zone balayee est supposee appartenir au meme net, c'est a dire que
les segments de pistes sont tries par net_code * les segments de pistes sont tries par net_code
*/ */
{ {
TRACK* pt_conn; TRACK* pt_conn;
int sous_net_code; int sous_net_code;
D_PAD* pt_pad; D_PAD* pt_pad;
TRACK* pt_autre_piste; TRACK* pt_autre_piste;
EDA_BaseStruct * PtStruct; BOARD_ITEM* PtStruct;
/* Initialisations prealables */ /* Initialisations prealables */
pt_conn = pt_start_conn; pt_conn = pt_start_conn;
@ -106,9 +114,12 @@ EDA_BaseStruct * PtStruct;
if( PtStruct && (PtStruct->m_StructType == TYPEPAD) ) if( PtStruct && (PtStruct->m_StructType == TYPEPAD) )
( (D_PAD*) PtStruct )->m_physical_connexion = 0; ( (D_PAD*) PtStruct )->m_physical_connexion = 0;
if (pt_conn == pt_end_conn) break; if( pt_conn == pt_end_conn )
break;
} }
sous_net_code = 1 ; pt_start_conn->m_Sous_Netcode = sous_net_code;
sous_net_code = 1;
pt_start_conn->m_Sous_Netcode = sous_net_code;
/* debut du calcul de propagation */ /* debut du calcul de propagation */
pt_conn = pt_start_conn; pt_conn = pt_start_conn;
@ -127,7 +138,8 @@ EDA_BaseStruct * PtStruct;
change_equipot( pt_start_conn, pt_end_conn, change_equipot( pt_start_conn, pt_end_conn,
pt_pad->m_physical_connexion, pt_conn->m_Sous_Netcode ); pt_pad->m_physical_connexion, pt_conn->m_Sous_Netcode );
} }
else pt_pad->m_physical_connexion = pt_conn->m_Sous_Netcode; else
pt_pad->m_physical_connexion = pt_conn->m_Sous_Netcode;
} }
else /* la connexion ne fait pas partie encore d'une chaine */ else /* la connexion ne fait pas partie encore d'une chaine */
{ {
@ -137,7 +149,8 @@ EDA_BaseStruct * PtStruct;
} }
else else
{ {
sous_net_code++ ; pt_conn->m_Sous_Netcode = sous_net_code; sous_net_code++;
pt_conn->m_Sous_Netcode = sous_net_code;
pt_pad->m_physical_connexion = pt_conn->m_Sous_Netcode; pt_pad->m_physical_connexion = pt_conn->m_Sous_Netcode;
} }
} }
@ -155,7 +168,8 @@ EDA_BaseStruct * PtStruct;
change_equipot( pt_start_conn, pt_end_conn, change_equipot( pt_start_conn, pt_end_conn,
pt_pad->m_physical_connexion, pt_conn->m_Sous_Netcode ); pt_pad->m_physical_connexion, pt_conn->m_Sous_Netcode );
} }
else pt_pad->m_physical_connexion = pt_conn->m_Sous_Netcode; else
pt_pad->m_physical_connexion = pt_conn->m_Sous_Netcode;
} }
else else
{ {
@ -175,7 +189,8 @@ EDA_BaseStruct * PtStruct;
/* traitement des connexions entre segments */ /* traitement des connexions entre segments */
PtStruct = pt_conn->start; PtStruct = pt_conn->start;
if( PtStruct && (PtStruct->m_StructType != TYPEPAD) ) if( PtStruct && (PtStruct->m_StructType != TYPEPAD) )
{ /* debut sur une autre piste */ {
/* debut sur une autre piste */
pt_autre_piste = (TRACK*) PtStruct; pt_autre_piste = (TRACK*) PtStruct;
if( pt_conn->m_Sous_Netcode ) /* La connexion fait deja partie d'un block */ if( pt_conn->m_Sous_Netcode ) /* La connexion fait deja partie d'un block */
@ -190,7 +205,6 @@ EDA_BaseStruct * PtStruct;
pt_autre_piste->m_Sous_Netcode = pt_conn->m_Sous_Netcode; pt_autre_piste->m_Sous_Netcode = pt_conn->m_Sous_Netcode;
} }
} }
else /* La connexion ne fait partie d'aucun block */ else /* La connexion ne fait partie d'aucun block */
{ {
if( pt_autre_piste->m_Sous_Netcode ) if( pt_autre_piste->m_Sous_Netcode )
@ -207,8 +221,10 @@ EDA_BaseStruct * PtStruct;
PtStruct = pt_conn->end; PtStruct = pt_conn->end;
if( PtStruct && (PtStruct->m_StructType != TYPEPAD) ) if( PtStruct && (PtStruct->m_StructType != TYPEPAD) )
{ /* fin connectee a une autre piste */ {
/* fin connectee a une autre piste */
pt_autre_piste = (TRACK*) PtStruct; pt_autre_piste = (TRACK*) PtStruct;
if( pt_conn->m_Sous_Netcode ) /* La connexion fait deja partie d'un block */ if( pt_conn->m_Sous_Netcode ) /* La connexion fait deja partie d'un block */
{ {
if( pt_autre_piste->m_Sous_Netcode ) if( pt_autre_piste->m_Sous_Netcode )
@ -216,7 +232,8 @@ EDA_BaseStruct * PtStruct;
change_equipot( pt_start_conn, pt_end_conn, change_equipot( pt_start_conn, pt_end_conn,
pt_autre_piste->m_Sous_Netcode, pt_conn->m_Sous_Netcode ); pt_autre_piste->m_Sous_Netcode, pt_conn->m_Sous_Netcode );
} }
else pt_autre_piste->m_Sous_Netcode = pt_conn->m_Sous_Netcode; else
pt_autre_piste->m_Sous_Netcode = pt_conn->m_Sous_Netcode;
} }
else /* La connexion ne fait partie d'aucun block */ else /* La connexion ne fait partie d'aucun block */
{ {
@ -231,17 +248,20 @@ EDA_BaseStruct * PtStruct;
} }
} }
} }
if (pt_conn == pt_end_conn) break; if( pt_conn == pt_end_conn )
break;
} }
} }
/***************************************************/ /***************************************************/
void WinEDA_BasePcbFrame::test_connexions( wxDC* DC ) void WinEDA_BasePcbFrame::test_connexions( wxDC* DC )
/***************************************************/ /***************************************************/
/* /*
Routine recherchant les connexions deja faites et mettant a jour * Routine recherchant les connexions deja faites et mettant a jour
le status du chevelu ( Bit CH_ACTIF mis a 0 si connexion trouvee * le status du chevelu ( Bit CH_ACTIF mis a 0 si connexion trouvee
Les pistes sont supposees etre triees par ordre de net_code croissant * Les pistes sont supposees etre triees par ordre de net_code croissant
*/ */
{ {
TRACK* pt_start_conn, * pt_end_conn; TRACK* pt_start_conn, * pt_end_conn;
@ -261,7 +281,7 @@ int current_net_code;
//////////////////////////// ////////////////////////////
/* Les pointeurs .start et .end sont mis a jour, si la /* Les pointeurs .start et .end sont mis a jour, si la
connexion est du type segment a segment * connexion est du type segment a segment
*/ */
pt_start_conn = m_Pcb->m_Track; pt_start_conn = m_Pcb->m_Track;
@ -279,25 +299,30 @@ int current_net_code;
return; return;
} }
/**************************************************************/ /**************************************************************/
void WinEDA_BasePcbFrame::Recalcule_all_net_connexion( wxDC* DC ) void WinEDA_BasePcbFrame::Recalcule_all_net_connexion( wxDC* DC )
/**************************************************************/ /**************************************************************/
/* /*
Routine Recalculant les pointeurs sur connexions types piste a piste * Routine Recalculant les pointeurs sur connexions types piste a piste
relatives a tous les nets. * relatives a tous les nets.
Cette routine est utilisee apres reclassement des segments de piste par * Cette routine est utilisee apres reclassement des segments de piste par
ordre de net_code, puisque des pointeurs sur connexions deviennent faux * ordre de net_code, puisque des pointeurs sur connexions deviennent faux
( les pointeurs type pad restent bons ) * ( les pointeurs type pad restent bons )
*/ */
{ {
TRACK* EndConn; TRACK* EndConn;
int net_code, net_code_max; int net_code, net_code_max;
if(m_Pcb->m_Track == NULL ) return; if( m_Pcb->m_Track == NULL )
return;
/* calcul du net_code max */ /* calcul du net_code max */
EndConn = m_Pcb->m_Track; EndConn = m_Pcb->m_Track;
while( EndConn->Pnext) EndConn = (TRACK*)EndConn->Pnext; while( EndConn->Pnext )
EndConn = (TRACK*) EndConn->Pnext;
net_code_max = EndConn->m_NetCode; net_code_max = EndConn->m_NetCode;
for( net_code = 0; net_code <= net_code_max; net_code++ ) for( net_code = 0; net_code <= net_code_max; net_code++ )
@ -306,11 +331,13 @@ int net_code, net_code_max;
} }
} }
/*************************************************************************/ /*************************************************************************/
void WinEDA_BasePcbFrame::test_1_net_connexion( wxDC* DC, int net_code ) void WinEDA_BasePcbFrame::test_1_net_connexion( wxDC* DC, int net_code )
/*************************************************************************/ /*************************************************************************/
/* /*
Routine recherchant les connexions deja faites relatives a 1 net * Routine recherchant les connexions deja faites relatives a 1 net
*/ */
{ {
TRACK* pt_start_conn, * pt_end_conn; TRACK* pt_start_conn, * pt_end_conn;
@ -318,7 +345,8 @@ int ii, nb_net_noconnect = 0;
LISTE_PAD* pt_pad; LISTE_PAD* pt_pad;
wxString msg; wxString msg;
if(net_code == 0) return; if( net_code == 0 )
return;
if( (m_Pcb->m_Status_Pcb & LISTE_CHEVELU_OK) == 0 ) if( (m_Pcb->m_Status_Pcb & LISTE_CHEVELU_OK) == 0 )
Compile_Ratsnest( DC, TRUE ); Compile_Ratsnest( DC, TRUE );
@ -327,8 +355,10 @@ wxString msg;
for( ii = 0; ii < m_Pcb->m_NbPads; ii++, pt_pad++ ) for( ii = 0; ii < m_Pcb->m_NbPads; ii++, pt_pad++ )
{ {
int pad_net_code = (*pt_pad)->m_NetCode; int pad_net_code = (*pt_pad)->m_NetCode;
if(pad_net_code < net_code) continue; if( pad_net_code < net_code )
if(pad_net_code > net_code) break; continue;
if( pad_net_code > net_code )
break;
(*pt_pad)->m_physical_connexion = 0; (*pt_pad)->m_physical_connexion = 0;
} }
@ -360,34 +390,37 @@ wxString msg;
} }
/***************************************************************************/ /***************************************************************************/
static void calcule_connexite_1_net( TRACK* pt_start_conn, TRACK* pt_end_conn ) static void calcule_connexite_1_net( TRACK* pt_start_conn, TRACK* pt_end_conn )
/***************************************************************************/ /***************************************************************************/
/* calcule la connexite d'un net constitue de segments de piste consecutifs. /* calcule la connexite d'un net constitue de segments de piste consecutifs.
Entree: * Entree:
pt_start_conn = adresse du 1er segment ( debut du net ) * pt_start_conn = adresse du 1er segment ( debut du net )
pt_end_conn = adr de fin (dernier segment) * pt_end_conn = adr de fin (dernier segment)
Les connexions relatives aux pads doivent etre deja calculees, car elles * Les connexions relatives aux pads doivent etre deja calculees, car elles
ne sont pas ici recalculees ( pour des raisons de temps de calcul, et * ne sont pas ici recalculees ( pour des raisons de temps de calcul, et
du fait que lors des modif de pistes, les pads ne sont pas touches * du fait que lors des modif de pistes, les pads ne sont pas touches
*/ */
{ {
TRACK* Track; TRACK* Track;
/* Les pointeurs .start et .end sont mis a jour, si la /* Les pointeurs .start et .end sont mis a jour, si la
connexion est du type segment a segment. * connexion est du type segment a segment.
la connexion sur pads est supposee etre deja calculee */ * la connexion sur pads est supposee etre deja calculee */
/* Raz des pointeurs sur pistes */ /* Raz des pointeurs sur pistes */
for( Track = pt_start_conn; Track != NULL; Track = (TRACK*) Track->Pnext ) for( Track = pt_start_conn; Track != NULL; Track = (TRACK*) Track->Pnext )
{ {
Track->m_Sous_Netcode = 0; Track->m_Sous_Netcode = 0;
if( Track->GetState(BEGIN_ONPAD) == 0 ) Track->start = NULL; if( Track->GetState( BEGIN_ONPAD ) == 0 )
if( Track->GetState(END_ONPAD) == 0 ) Track->end = NULL; Track->start = NULL;
if( Track->GetState( END_ONPAD ) == 0 )
Track->end = NULL;
if (Track == pt_end_conn) break; if( Track == pt_end_conn )
break;
} }
/* calcul des connexions */ /* calcul des connexions */
@ -400,17 +433,18 @@ TRACK * Track;
for( pt_segm = pt_start_conn; pt_segm != NULL; pt_segm = (TRACK*) pt_segm->Pnext ) for( pt_segm = pt_start_conn; pt_segm != NULL; pt_segm = (TRACK*) pt_segm->Pnext )
{ {
int curlayermask = pt_segm->ReturnMaskLayer(); int curlayermask = pt_segm->ReturnMaskLayer();
if( !pt_segm->start && (pt_segm->m_Start == Track->m_Start) && if( !pt_segm->start && (pt_segm->m_Start == Track->m_Start)
( layermask & curlayermask ) ) && ( layermask & curlayermask ) )
{ {
pt_segm->start = Track; pt_segm->start = Track;
} }
if( !pt_segm->end && (pt_segm->m_End == Track->m_Start) && if( !pt_segm->end && (pt_segm->m_End == Track->m_Start)
(layermask & curlayermask) ) && (layermask & curlayermask) )
{ {
pt_segm->end = Track; pt_segm->end = Track;
} }
if( pt_segm == pt_end_conn ) break; if( pt_segm == pt_end_conn )
break;
} }
} }
@ -423,45 +457,46 @@ TRACK * Track;
{ {
Track->end = Locate_Piste_Connectee( Track, Track, pt_end_conn, END ); Track->end = Locate_Piste_Connectee( Track, Track, pt_end_conn, END );
} }
if (Track == pt_end_conn) break; if( Track == pt_end_conn )
break;
} }
/* Generation des sous equipots du net */ /* Generation des sous equipots du net */
propage_equipot( pt_start_conn, pt_end_conn ); propage_equipot( pt_start_conn, pt_end_conn );
} }
/********************************************/ /********************************************/
/* Reattribution des net_codes de reference */ /* Reattribution des net_codes de reference */
/********************************************/ /********************************************/
/*
reattribution des net_codes aux segments de pistes.
Routine utilisee apres modification generale des noms de nets (apres
lecrure netliste ou edition de nets sur pads, effacement /ajout de
modules...)
Elle se fait en 2 passes: /*
1 - reattribution des segments commencant ( et/ou finissant ) sur 1 pad * reattribution des net_codes aux segments de pistes.
les autres segments sont mis a reference NULLE * Routine utilisee apres modification generale des noms de nets (apres
2 - reattribution des segments restantes a ref NULLE * lecrure netliste ou edition de nets sur pads, effacement /ajout de
* modules...)
*
* Elle se fait en 2 passes:
* 1 - reattribution des segments commencant ( et/ou finissant ) sur 1 pad
* les autres segments sont mis a reference NULLE
* 2 - reattribution des segments restantes a ref NULLE
*/ */
#define POS_AFF_CHREF 62 #define POS_AFF_CHREF 62
/* recherche le pad connecte a l'extremite de la piste de coord px, py
parametres d'appel:
px, py = coord du point tst
masque_layer = couche(s) de connexion
pt_liste = adresse de la liste des pointeurs de pads, tels que
apparaissant apres build_liste_pad, mais classee par position X
de pads croissantes.
retourne : pointeur sur le pad connecte
la routine travaille par dichotomie sur la liste des pads tries par pos X
croissante, elle est donc beaucoup plus rapide que Fast_Locate_Pad_connecte,
mais implique le calcul de cette liste.
(la liste placee en m_Pcb->m_Pads et elle triee par netcodes croissants) /* recherche le pad connecte a l'extremite de la piste de coord px, py
* parametres d'appel:
* px, py = coord du point tst
* masque_layer = couche(s) de connexion
* pt_liste = adresse de la liste des pointeurs de pads, tels que
* apparaissant apres build_liste_pad, mais classee par position X
* de pads croissantes.
* retourne : pointeur sur le pad connecte
* la routine travaille par dichotomie sur la liste des pads tries par pos X
* croissante, elle est donc beaucoup plus rapide que Fast_Locate_Pad_connecte,
* mais implique le calcul de cette liste.
*
* (la liste placee en m_Pcb->m_Pads et elle triee par netcodes croissants)
*/ */
static D_PAD* SuperFast_Locate_Pad_Connecte( BOARD* pcb, LISTE_PAD* pt_liste, static D_PAD* SuperFast_Locate_Pad_Connecte( BOARD* pcb, LISTE_PAD* pt_liste,
@ -471,22 +506,26 @@ D_PAD * pad ;
LISTE_PAD* ptr_pad, * lim; LISTE_PAD* ptr_pad, * lim;
int nb_pad = pcb->m_NbPads; int nb_pad = pcb->m_NbPads;
int ii; int ii;
lim = pt_liste + (pcb->m_NbPads - 1 ); lim = pt_liste + (pcb->m_NbPads - 1 );
ptr_pad = pt_liste; ptr_pad = pt_liste;
while( nb_pad ) while( nb_pad )
{ {
pad = *ptr_pad; pad = *ptr_pad;
ii = nb_pad; ii = nb_pad;
nb_pad >>= 1; if( (ii & 1) && ( ii > 1 ) ) nb_pad++; nb_pad >>= 1; if( (ii & 1) && ( ii > 1 ) )
nb_pad++;
if( pad->m_Pos.x < px ) /* on doit chercher plus loin */ if( pad->m_Pos.x < px ) /* on doit chercher plus loin */
{ {
ptr_pad += nb_pad; if(ptr_pad > lim) ptr_pad = lim; ptr_pad += nb_pad; if( ptr_pad > lim )
ptr_pad = lim;
continue; continue;
} }
if( pad->m_Pos.x > px ) /* on doit chercher moins loin */ if( pad->m_Pos.x > px ) /* on doit chercher moins loin */
{ {
ptr_pad -= nb_pad; ptr_pad -= nb_pad;
if(ptr_pad < pt_liste) ptr_pad = pt_liste; if( ptr_pad < pt_liste )
ptr_pad = pt_liste;
continue; continue;
} }
@ -496,50 +535,64 @@ int ii;
while( ptr_pad >= pt_liste ) while( ptr_pad >= pt_liste )
{ {
pad = *ptr_pad; pad = *ptr_pad;
if(pad->m_Pos.x == px) ptr_pad--; if( pad->m_Pos.x == px )
else break; ptr_pad--;
else
break;
} }
ptr_pad++; /* pointe depart de zone a pad->m_Pos.x = px */ ptr_pad++; /* pointe depart de zone a pad->m_Pos.x = px */
for( ; ; ptr_pad++ ) for( ; ; ptr_pad++ )
{ {
if(ptr_pad > lim) return(NULL); /* hors zone */ if( ptr_pad > lim )
return NULL; /* hors zone */
pad = *ptr_pad; pad = *ptr_pad;
if( pad->m_Pos.x != px ) return(NULL); /* hors zone */ if( pad->m_Pos.x != px )
if( pad->m_Pos.y != py ) continue ; return NULL; /* hors zone */
if( pad->m_Pos.y != py )
continue;
/* Pad peut-etre trouve ici: il doit etre sur la bonne couche */ /* Pad peut-etre trouve ici: il doit etre sur la bonne couche */
if (pad->m_Masque_Layer & masque_layer) return(pad) ; if( pad->m_Masque_Layer & masque_layer )
return pad;
} }
} }
} }
return(NULL);
return NULL;
} }
static int SortPadsByXCoord( void* pt_ref, void* pt_comp ) static int SortPadsByXCoord( void* pt_ref, void* pt_comp )
/* used to Sort a pad list by x coordinate value /* used to Sort a pad list by x coordinate value
*/ */
{ {
D_PAD* ref = *(LISTE_PAD*) pt_ref; D_PAD* ref = *(LISTE_PAD*) pt_ref;
D_PAD* comp = *(LISTE_PAD*) pt_comp; D_PAD* comp = *(LISTE_PAD*) pt_comp;
return( ref->m_Pos.x - comp->m_Pos.x );
return ref->m_Pos.x - comp->m_Pos.x;
} }
/****************************************************/ /****************************************************/
LISTE_PAD* CreateSortedPadListByXCoord( BOARD* pcb ) LISTE_PAD* CreateSortedPadListByXCoord( BOARD* pcb )
/****************************************************/ /****************************************************/
/* Create a sorted list of pointers to pads. /* Create a sorted list of pointers to pads.
This list is sorted by X ccordinate value. * This list is sorted by X ccordinate value.
The list must be freed bu user * The list must be freed bu user
*/ */
{ {
LISTE_PAD* pad_list = (LISTE_PAD*) MyMalloc( pcb->m_NbPads * sizeof( D_PAD *) ); LISTE_PAD* pad_list = (LISTE_PAD*) MyMalloc( pcb->m_NbPads * sizeof( D_PAD *) );
memcpy( pad_list, pcb->m_Pads, pcb->m_NbPads * sizeof( D_PAD *) ); memcpy( pad_list, pcb->m_Pads, pcb->m_NbPads * sizeof( D_PAD *) );
qsort( pad_list, pcb->m_NbPads, sizeof( D_PAD *), qsort( pad_list, pcb->m_NbPads, sizeof( D_PAD *),
( int( * ) ( const void*, const void* ) )SortPadsByXCoord ); ( int( * ) ( const void*, const void* ) )SortPadsByXCoord );
return pad_list; return pad_list;
} }
/******************************************************************/ /******************************************************************/
void WinEDA_BasePcbFrame::reattribution_reference_piste( int affiche ) void WinEDA_BasePcbFrame::reattribution_reference_piste( int affiche )
/******************************************************************/ /******************************************************************/
@ -549,18 +602,20 @@ TRACK * pt_piste,
int a_color; int a_color;
char new_passe_request = 1, flag; char new_passe_request = 1, flag;
LISTE_PAD* pt_mem; LISTE_PAD* pt_mem;
EDA_BaseStruct * PtStruct; BOARD_ITEM* PtStruct;
int masque_layer; int masque_layer;
wxString msg; wxString msg;
if( m_Pcb->m_NbPads == 0 ) return; if( m_Pcb->m_NbPads == 0 )
return;
a_color = CYAN; a_color = CYAN;
if( affiche ) if( affiche )
Affiche_1_Parametre( this, POS_AFF_CHREF, wxT( "DataBase" ), wxT( "Netcodes" ), a_color ); Affiche_1_Parametre( this, POS_AFF_CHREF, wxT( "DataBase" ), wxT( "Netcodes" ), a_color );
recalcule_pad_net_code(); recalcule_pad_net_code();
if(affiche) Affiche_1_Parametre(this, -1,wxEmptyString, wxT("Gen Pads "),a_color); if( affiche )
Affiche_1_Parametre( this, -1, wxEmptyString, wxT( "Gen Pads " ), a_color );
////////////////////////////////////////////////////// //////////////////////////////////////////////////////
// Connexion des pistes accrochees a 1 pad au moins // // Connexion des pistes accrochees a 1 pad au moins //
@ -582,27 +637,33 @@ wxString msg;
for( ; pt_piste != NULL; pt_piste = (TRACK*) pt_piste->Pnext ) for( ; pt_piste != NULL; pt_piste = (TRACK*) pt_piste->Pnext )
{ {
flag = 0; flag = 0;
masque_layer = g_TabOneLayerMask[pt_piste->m_Layer]; masque_layer = g_TabOneLayerMask[pt_piste->GetLayer()];
/* y a t-il une pastille sur une extremite */ /* y a t-il une pastille sur une extremite */
pt_piste->start = SuperFast_Locate_Pad_Connecte(m_Pcb, pt_mem, pt_piste->start = SuperFast_Locate_Pad_Connecte( m_Pcb,
pt_piste->m_Start.x, pt_piste->m_Start.y, masque_layer); pt_mem,
pt_piste->m_Start.x,
pt_piste->m_Start.y,
masque_layer );
if( pt_piste->start != NULL ) if( pt_piste->start != NULL )
{ {
pt_piste->SetState( BEGIN_ONPAD, ON ); pt_piste->SetState( BEGIN_ONPAD, ON );
pt_piste->m_NetCode = ( (D_PAD*) (pt_piste->start) )->m_NetCode; pt_piste->m_NetCode = ( (D_PAD*) (pt_piste->start) )->m_NetCode;
} }
pt_piste->end = SuperFast_Locate_Pad_Connecte(m_Pcb, pt_mem, pt_piste->end = SuperFast_Locate_Pad_Connecte( m_Pcb,
pt_piste->m_End.x, pt_piste->m_End.y, masque_layer); pt_mem,
pt_piste->m_End.x,
pt_piste->m_End.y,
masque_layer );
if( pt_piste->end != NULL ) if( pt_piste->end != NULL )
{ {
pt_piste->SetState( END_ONPAD, ON ); pt_piste->SetState( END_ONPAD, ON );
pt_piste->m_NetCode = ( (D_PAD*) (pt_piste->end) )->m_NetCode; pt_piste->m_NetCode = ( (D_PAD*) (pt_piste->end) )->m_NetCode;
} }
} }
MyFree( pt_mem ); MyFree( pt_mem );
//////////////////////////////////////////////////// ////////////////////////////////////////////////////
@ -610,7 +671,7 @@ wxString msg;
//////////////////////////////////////////////////// ////////////////////////////////////////////////////
/* Les pointeurs .start et .end sont mis a jour, s'ils etaient NULLs. /* Les pointeurs .start et .end sont mis a jour, s'ils etaient NULLs.
La connexion est alors du type segment a segment * La connexion est alors du type segment a segment
*/ */
if( affiche ) if( affiche )
Affiche_1_Parametre( this, POS_AFF_CHREF, wxEmptyString, wxT( "Conn Segm" ), a_color ); Affiche_1_Parametre( this, POS_AFF_CHREF, wxEmptyString, wxT( "Conn Segm" ), a_color );
@ -647,8 +708,10 @@ wxString msg;
/* look for vias which could be connect many tracks */ /* look for vias which could be connect many tracks */
for( TRACK* via = m_Pcb->m_Track; via != NULL; via = via->Next() ) for( TRACK* via = m_Pcb->m_Track; via != NULL; via = via->Next() )
{ {
if ( via->m_StructType != TYPEVIA ) continue; if( via->m_StructType != TYPEVIA )
if ( via->m_NetCode > 0 ) continue; // Netcode already known continue;
if( via->m_NetCode > 0 )
continue; // Netcode already known
// Lock for a connection to a track with a known netcode // Lock for a connection to a track with a known netcode
pt_next = m_Pcb->m_Track; pt_next = m_Pcb->m_Track;
while( ( pt_next = Locate_Piste_Connectee( via, pt_next, NULL, START ) ) != NULL ) while( ( pt_next = Locate_Piste_Connectee( via, pt_next, NULL, START ) ) != NULL )
@ -663,7 +726,8 @@ wxString msg;
} }
} }
if ( reset_flag ) for ( pt_piste = m_Pcb->m_Track; pt_piste != NULL; pt_piste = pt_piste->Next()) if( reset_flag )
for( pt_piste = m_Pcb->m_Track; pt_piste != NULL; pt_piste = pt_piste->Next() )
{ {
pt_piste->SetState( BUSY, OFF ); pt_piste->SetState( BUSY, OFF );
} }
@ -671,7 +735,7 @@ wxString msg;
for( pt_piste = m_Pcb->m_Track; pt_piste != NULL; pt_piste = pt_piste->Next() ) for( pt_piste = m_Pcb->m_Track; pt_piste != NULL; pt_piste = pt_piste->Next() )
{ {
/* Traitement du point de debut */ /* Traitement du point de debut */
PtStruct = (EDA_BaseStruct*)pt_piste->start; PtStruct = (BOARD_ITEM*) pt_piste->start;
if( PtStruct && (PtStruct->m_StructType != TYPEPAD) ) if( PtStruct && (PtStruct->m_StructType != TYPEPAD) )
{ // Begin on an other track segment { // Begin on an other track segment
pt_next = (TRACK*) PtStruct; pt_next = (TRACK*) PtStruct;
@ -683,7 +747,6 @@ wxString msg;
pt_next->m_NetCode = pt_piste->m_NetCode; pt_next->m_NetCode = pt_piste->m_NetCode;
} }
} }
else else
{ {
if( pt_next->m_NetCode != 0 ) if( pt_next->m_NetCode != 0 )
@ -720,30 +783,34 @@ wxString msg;
} }
/* Reclassemment des pistes par numero de net: */ /* Reclassemment des pistes par numero de net: */
if( affiche ) Affiche_1_Parametre(this, -1,wxEmptyString, wxT("Reorder "),a_color); if( affiche )
Affiche_1_Parametre( this, -1, wxEmptyString, wxT( "Reorder " ), a_color );
RebuildTrackChain( m_Pcb ); RebuildTrackChain( m_Pcb );
if( affiche ) Affiche_1_Parametre(this, -1,wxEmptyString, wxT(" "),a_color); if( affiche )
Affiche_1_Parametre( this, -1, wxEmptyString, wxT( " " ), a_color );
} }
/* /*
routine de tri de connexion utilisee par la fonction QSORT * routine de tri de connexion utilisee par la fonction QSORT
le tri est fait par numero de net * le tri est fait par numero de net
*/ */
int tri_par_netcode( TRACK** pt_ref, TRACK** pt_compare ) int tri_par_netcode( TRACK** pt_ref, TRACK** pt_compare )
{ {
int ii; int ii;
ii = (*pt_ref)->m_NetCode -(* pt_compare)->m_NetCode ;
return(ii) ;
}
ii = (*pt_ref)->m_NetCode - (*pt_compare)->m_NetCode;
return ii;
}
/*****************************************/ /*****************************************/
static void RebuildTrackChain( BOARD* pcb ) static void RebuildTrackChain( BOARD* pcb )
/*****************************************/ /*****************************************/
/* Recalcule le chainage des pistes pour que le chainage soit fait par /* Recalcule le chainage des pistes pour que le chainage soit fait par
netcodes croissants * netcodes croissants
*/ */
{ {
TRACK* Track, ** Liste; TRACK* Track, ** Liste;
@ -751,7 +818,8 @@ int ii, nbsegm;
/* Count segments */ /* Count segments */
nbsegm = pcb->GetNumSegmTrack(); nbsegm = pcb->GetNumSegmTrack();
if( pcb->m_Track == NULL ) return; if( pcb->m_Track == NULL )
return;
Liste = (TRACK**) MyZMalloc( (nbsegm + 1) * sizeof(TRACK *) ); Liste = (TRACK**) MyZMalloc( (nbsegm + 1) * sizeof(TRACK *) );
@ -778,4 +846,3 @@ int ii, nbsegm;
MyFree( Liste ); MyFree( Liste );
} }

13
pcbnew/cotation.cpp
View File

@ -147,7 +147,7 @@ WinEDA_CotationPropertiesFrame::WinEDA_CotationPropertiesFrame( WinEDA_PcbFrame*
m_SelLayerBox->Append( ReturnPcbLayerName( ii ) ); m_SelLayerBox->Append( ReturnPcbLayerName( ii ) );
} }
m_SelLayerBox->SetSelection( Cotation->m_Layer - (CMP_N + 1) ); m_SelLayerBox->SetSelection( Cotation->GetLayer() - (CMP_N + 1) );
GetSizer()->Fit( this ); GetSizer()->Fit( this );
GetSizer()->SetSizeHints( this ); GetSizer()->SetSizeHints( this );
@ -180,8 +180,9 @@ void WinEDA_CotationPropertiesFrame::CotationPropertiesAccept( wxCommandEvent& e
CurrentCotation->m_Text->m_Width = CurrentCotation->m_Width = CurrentCotation->m_Text->m_Width = CurrentCotation->m_Width =
m_TxtWidthCtrl->GetValue(); m_TxtWidthCtrl->GetValue();
CurrentCotation->m_Text->m_Miroir = (m_Mirror->GetSelection() == 0) ? 1 : 0; CurrentCotation->m_Text->m_Miroir = (m_Mirror->GetSelection() == 0) ? 1 : 0;
CurrentCotation->m_Layer = CurrentCotation->m_Text->m_Layer =
m_SelLayerBox->GetChoice() + CMP_N + 1; CurrentCotation->SetLayer( m_SelLayerBox->GetChoice() + CMP_N + 1 );
CurrentCotation->m_Text->SetLayer( m_SelLayerBox->GetChoice() + CMP_N + 1 );
CurrentCotation->m_Text->CreateDrawData(); CurrentCotation->m_Text->CreateDrawData();
@ -236,7 +237,7 @@ COTATION* WinEDA_PcbFrame::Begin_Cotation( COTATION* Cotation, wxDC* DC )
Cotation = new COTATION( m_Pcb ); Cotation = new COTATION( m_Pcb );
Cotation->m_Flags = IS_NEW; Cotation->m_Flags = IS_NEW;
Cotation->m_Layer = GetScreen()->m_Active_Layer; Cotation->SetLayer( GetScreen()->m_Active_Layer );
Cotation->m_Width = g_DesignSettings.m_DrawSegmentWidth; Cotation->m_Width = g_DesignSettings.m_DrawSegmentWidth;
Cotation->m_Text->m_Width = Cotation->m_Width; Cotation->m_Text->m_Width = Cotation->m_Width;
@ -317,7 +318,7 @@ static void Montre_Position_New_Cotation( WinEDA_DrawPanel* panel, wxDC* DC, boo
Cotation->Draw( panel, DC, wxPoint( 0, 0 ), GR_XOR ); Cotation->Draw( panel, DC, wxPoint( 0, 0 ), GR_XOR );
} }
Cotation->m_Layer = screen->m_Active_Layer; Cotation->SetLayer( screen->m_Active_Layer );
if( status_cotation == 1 ) if( status_cotation == 1 )
{ {
Cotation->TraitD_ox = pos.x; Cotation->TraitD_ox = pos.x;
@ -399,7 +400,7 @@ static void Ajuste_Details_Cotation( COTATION* Cotation )
wxString msg; wxString msg;
/* Init des couches : */ /* Init des couches : */
Cotation->m_Text->m_Layer = Cotation->m_Layer; Cotation->m_Text->SetLayer( Cotation->GetLayer() );
/* calcul de la hauteur du texte + trait de cotation */ /* calcul de la hauteur du texte + trait de cotation */
ii = Cotation->m_Text->m_Size.y + ii = Cotation->m_Text->m_Size.y +

2
pcbnew/deltrack.cpp
View File

@ -68,7 +68,7 @@ TRACK* WinEDA_PcbFrame::Delete_Segment( wxDC* DC, TRACK* Track )
delete Track; delete Track;
g_TrackSegmentCount--; g_TrackSegmentCount--;
if( g_CurrentTrackSegment && (g_CurrentTrackSegment->m_StructType != TYPEVIA) ) if( g_CurrentTrackSegment && (g_CurrentTrackSegment->m_StructType != TYPEVIA) )
previous_layer = g_CurrentTrackSegment->m_Layer; previous_layer = g_CurrentTrackSegment->GetLayer();
} }
if( g_CurrentTrackSegment ) if( g_CurrentTrackSegment )

6
pcbnew/dialog_edit_module.cpp
View File

@ -236,7 +236,7 @@ void WinEDA_ModulePropertiesFrame::BuildPanelModuleProperties( bool FullOptions
wxString layer_list[2] = { _( "Component" ), _( "Copper" ) }; wxString layer_list[2] = { _( "Component" ), _( "Copper" ) };
m_LayerCtrl = new wxRadioBox( m_PanelProperties, -1, _( "Layer" ), wxDefaultPosition, m_LayerCtrl = new wxRadioBox( m_PanelProperties, -1, _( "Layer" ), wxDefaultPosition,
wxSize( -1, -1 ), 2, layer_list, 1 ); wxSize( -1, -1 ), 2, layer_list, 1 );
m_LayerCtrl->SetSelection( (m_CurrentModule->m_Layer == CUIVRE_N) ? 1 : 0 ); m_LayerCtrl->SetSelection( (m_CurrentModule->GetLayer() == CUIVRE_N) ? 1 : 0 );
PropLeftSizer->Add( m_LayerCtrl, 0, wxGROW | wxALL, 5 ); PropLeftSizer->Add( m_LayerCtrl, 0, wxGROW | wxALL, 5 );
bool select = FALSE; bool select = FALSE;
@ -518,10 +518,10 @@ void WinEDA_ModulePropertiesFrame::ModulePropertiesAccept( wxCommandEvent& event
{ {
if( m_LayerCtrl->GetSelection() == 0 ) // layer req = COMPONENT if( m_LayerCtrl->GetSelection() == 0 ) // layer req = COMPONENT
{ {
if( m_CurrentModule->m_Layer == CUIVRE_N ) if( m_CurrentModule->GetLayer() == CUIVRE_N )
change_layer = TRUE; change_layer = TRUE;
} }
else if( m_CurrentModule->m_Layer == CMP_N ) else if( m_CurrentModule->GetLayer() == CMP_N )
change_layer = TRUE; change_layer = TRUE;
} }

14
pcbnew/edgemod.cpp
View File

@ -200,11 +200,11 @@ void WinEDA_ModuleEditFrame::Edit_Edge_Layer( EDGE_MODULE* Edge, wxDC* DC )
{ {
if( Edge->m_StructType != TYPEEDGEMODULE ) if( Edge->m_StructType != TYPEEDGEMODULE )
continue; continue;
Edge->m_Layer = new_layer; Edge->SetLayer( new_layer );
} }
} }
else else
Edge->m_Layer = new_layer; Edge->SetLayer( new_layer );
GetScreen()->SetModify(); GetScreen()->SetModify();
Module->Set_Rectangle_Encadrement(); Module->Set_Rectangle_Encadrement();
@ -336,11 +336,11 @@ EDGE_MODULE* WinEDA_ModuleEditFrame::Begin_Edge_Module( EDGE_MODULE* Edge,
if( Edge->m_Shape == S_ARC ) if( Edge->m_Shape == S_ARC )
Edge->m_Angle = ArcValue; Edge->m_Angle = ArcValue;
Edge->m_Width = ModuleSegmentWidth; Edge->m_Width = ModuleSegmentWidth;
Edge->m_Layer = Module->m_Layer; Edge->SetLayer( Module->GetLayer() );
if( Module->m_Layer == CMP_N ) if( Module->GetLayer() == CMP_N )
Edge->m_Layer = SILKSCREEN_N_CMP; Edge->SetLayer( SILKSCREEN_N_CMP );
if( Module->m_Layer == CUIVRE_N ) if( Module->GetLayer() == CUIVRE_N )
Edge->m_Layer = SILKSCREEN_N_CU; Edge->SetLayer( SILKSCREEN_N_CU );
/* Mise a jour du point de depart du segment ou de l'arc */ /* Mise a jour du point de depart du segment ou de l'arc */
Edge->m_Start = GetScreen()->m_Curseur; Edge->m_Start = GetScreen()->m_Curseur;
/* Mise a jour de la fin du segment , rectangle ou de l'arc*/ /* Mise a jour de la fin du segment , rectangle ou de l'arc*/

14
pcbnew/editedge.cpp
View File

@ -138,7 +138,7 @@ void WinEDA_PcbFrame::Drawing_SetNewWidth( DRAWSEGMENT* DrawSegm, wxDC* DC )
Trace_DrawSegmentPcb( DrawPanel, DC, DrawSegm, GR_XOR ); Trace_DrawSegmentPcb( DrawPanel, DC, DrawSegm, GR_XOR );
if( DrawSegm->m_Layer == EDGE_N ) if( DrawSegm->GetLayer() == EDGE_N )
DrawSegm->m_Width = g_DesignSettings.m_EdgeSegmentWidth; DrawSegm->m_Width = g_DesignSettings.m_EdgeSegmentWidth;
else else
DrawSegm->m_Width = g_DesignSettings.m_DrawSegmentWidth; DrawSegm->m_Width = g_DesignSettings.m_DrawSegmentWidth;
@ -159,7 +159,7 @@ void WinEDA_PcbFrame::Delete_Drawings_All_Layer( DRAWSEGMENT* Segment, wxDC* DC
TEXTE_PCB* pt_txt; TEXTE_PCB* pt_txt;
EDA_BaseStruct* PtStruct, * PtNext; EDA_BaseStruct* PtStruct, * PtNext;
COTATION* Cotation; COTATION* Cotation;
int layer = Segment->m_Layer; int layer = Segment->GetLayer();
if( layer <= CMP_N ) if( layer <= CMP_N )
{ {
@ -187,7 +187,7 @@ void WinEDA_PcbFrame::Delete_Drawings_All_Layer( DRAWSEGMENT* Segment, wxDC* DC
{ {
case TYPEDRAWSEGMENT: case TYPEDRAWSEGMENT:
pt_segm = (DRAWSEGMENT*) PtStruct; pt_segm = (DRAWSEGMENT*) PtStruct;
if( pt_segm->m_Layer == layer ) if( pt_segm->GetLayer() == layer )
{ {
Trace_DrawSegmentPcb( DrawPanel, DC, pt_segm, GR_XOR ); Trace_DrawSegmentPcb( DrawPanel, DC, pt_segm, GR_XOR );
DeleteStructure( PtStruct ); DeleteStructure( PtStruct );
@ -196,7 +196,7 @@ void WinEDA_PcbFrame::Delete_Drawings_All_Layer( DRAWSEGMENT* Segment, wxDC* DC
case TYPETEXTE: case TYPETEXTE:
pt_txt = (TEXTE_PCB*) PtStruct; pt_txt = (TEXTE_PCB*) PtStruct;
if( pt_txt->m_Layer == layer ) if( pt_txt->GetLayer() == layer )
{ {
pt_txt->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR ); pt_txt->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
DeleteStructure( PtStruct ); DeleteStructure( PtStruct );
@ -206,7 +206,7 @@ void WinEDA_PcbFrame::Delete_Drawings_All_Layer( DRAWSEGMENT* Segment, wxDC* DC
case TYPECOTATION: case TYPECOTATION:
Cotation = (COTATION*) PtStruct; Cotation = (COTATION*) PtStruct;
if( Cotation->m_Layer == layer ) if( Cotation->GetLayer() == layer )
{ {
Cotation->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR ); Cotation->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
DeleteStructure( PtStruct ); DeleteStructure( PtStruct );
@ -276,7 +276,7 @@ DRAWSEGMENT* WinEDA_PcbFrame::Begin_DrawSegment( DRAWSEGMENT* Segment,
{ {
GetScreen()->SetCurItem( Segment = new DRAWSEGMENT( m_Pcb ) ); GetScreen()->SetCurItem( Segment = new DRAWSEGMENT( m_Pcb ) );
Segment->m_Flags = IS_NEW; Segment->m_Flags = IS_NEW;
Segment->m_Layer = GetScreen()->m_Active_Layer; Segment->SetLayer( GetScreen()->m_Active_Layer );
Segment->m_Width = s_large; Segment->m_Width = s_large;
Segment->m_Shape = shape; Segment->m_Shape = shape;
Segment->m_Angle = 900; Segment->m_Angle = 900;
@ -307,7 +307,7 @@ DRAWSEGMENT* WinEDA_PcbFrame::Begin_DrawSegment( DRAWSEGMENT* Segment,
GetScreen()->SetCurItem( Segment = new DRAWSEGMENT( m_Pcb ) ); GetScreen()->SetCurItem( Segment = new DRAWSEGMENT( m_Pcb ) );
Segment->m_Flags = IS_NEW; Segment->m_Flags = IS_NEW;
Segment->m_Layer = DrawItem->m_Layer; Segment->SetLayer( DrawItem->GetLayer() );
Segment->m_Width = s_large; Segment->m_Width = s_large;
Segment->m_Shape = DrawItem->m_Shape; Segment->m_Shape = DrawItem->m_Shape;
Segment->m_Type = DrawItem->m_Type; Segment->m_Type = DrawItem->m_Type;

26
pcbnew/editrack-part2.cpp
View File

@ -108,7 +108,7 @@ void WinEDA_PcbFrame::ExChange_Track_Layer( TRACK* pt_segm, wxDC* DC )
for( ; ii > 0; ii--, pt_segm = (TRACK*) pt_segm->Pnext ) for( ; ii > 0; ii--, pt_segm = (TRACK*) pt_segm->Pnext )
{ {
pt_segm->SetState( BUSY, OFF ); pt_segm->SetState( BUSY, OFF );
pt_segm->m_Param = pt_segm->m_Layer; /* pour sauvegarde */ pt_segm->m_Param = pt_segm->GetLayer(); /* pour sauvegarde */
} }
ii = 0; pt_segm = pt_track; ii = 0; pt_segm = pt_track;
@ -118,17 +118,17 @@ void WinEDA_PcbFrame::ExChange_Track_Layer( TRACK* pt_segm, wxDC* DC )
continue; continue;
/* inversion des couches */ /* inversion des couches */
if( pt_segm->m_Layer == l1 ) if( pt_segm->GetLayer() == l1 )
pt_segm->m_Layer = l2; pt_segm->SetLayer( l2 );
else if( pt_segm->m_Layer == l2 ) else if( pt_segm->GetLayer() == l2 )
pt_segm->m_Layer = l1; pt_segm->SetLayer( l1 );
if( (Drc_On) && ( Drc( this, DC, pt_segm, m_Pcb->m_Track, 1 ) == BAD_DRC ) ) if( (Drc_On) && ( Drc( this, DC, pt_segm, m_Pcb->m_Track, 1 ) == BAD_DRC ) )
{ /* Annulation du changement */ { /* Annulation du changement */
ii = 0; pt_segm = pt_track; ii = 0; pt_segm = pt_track;
for( ; ii < nb_segm; ii++, pt_segm = (TRACK*) pt_segm->Pnext ) for( ; ii < nb_segm; ii++, pt_segm = (TRACK*) pt_segm->Pnext )
{ {
pt_segm->m_Layer = pt_segm->m_Param; pt_segm->SetLayer( pt_segm->m_Param );
} }
Trace_Une_Piste( DrawPanel, DC, pt_track, nb_segm, GR_OR ); Trace_Une_Piste( DrawPanel, DC, pt_track, nb_segm, GR_OR );
@ -178,7 +178,7 @@ void WinEDA_PcbFrame::Other_Layer_Route( TRACK* track, wxDC* DC )
} }
/* Les vias ne doivent pas etre inutilement empilees: */ /* Les vias ne doivent pas etre inutilement empilees: */
if( Locate_Via( m_Pcb, g_CurrentTrackSegment->m_End, g_CurrentTrackSegment->m_Layer ) ) if( Locate_Via( m_Pcb, g_CurrentTrackSegment->m_End, g_CurrentTrackSegment->GetLayer() ) )
return; return;
pt_segm = g_FirstTrackSegment; pt_segm = g_FirstTrackSegment;
for( ii = 0; ii < g_TrackSegmentCount - 1; ii++, pt_segm = (TRACK*) pt_segm->Pnext ) for( ii = 0; ii < g_TrackSegmentCount - 1; ii++, pt_segm = (TRACK*) pt_segm->Pnext )
@ -206,7 +206,7 @@ void WinEDA_PcbFrame::Other_Layer_Route( TRACK* track, wxDC* DC )
Via->m_NetCode = g_HightLigth_NetCode; Via->m_NetCode = g_HightLigth_NetCode;
Via->m_Start = Via->m_End = g_CurrentTrackSegment->m_End; Via->m_Start = Via->m_End = g_CurrentTrackSegment->m_End;
Via->m_Layer = GetScreen()->m_Active_Layer; Via->SetLayer( GetScreen()->m_Active_Layer );
// Provisoirement. indicate the first layer (?) // Provisoirement. indicate the first layer (?)
@ -218,19 +218,19 @@ void WinEDA_PcbFrame::Other_Layer_Route( TRACK* track, wxDC* DC )
if( (Via->m_Shape & 15) == VIA_ENTERREE ) if( (Via->m_Shape & 15) == VIA_ENTERREE )
{ {
Via->m_Layer |= GetScreen()->m_Active_Layer << 4; Via->SetLayer( Via->GetLayer() | GetScreen()->m_Active_Layer << 4 );
} }
else if( (Via->m_Shape & 15) == VIA_BORGNE ) //blind via else if( (Via->m_Shape & 15) == VIA_BORGNE ) //blind via
{ // A revoir! ( la via devrait deboucher sur 1 cote ) { // A revoir! ( la via devrait deboucher sur 1 cote )
Via->m_Layer |= GetScreen()->m_Active_Layer << 4; Via->SetLayer( Via->GetLayer() | GetScreen()->m_Active_Layer << 4 );
} }
else else
Via->m_Layer = 0x0F; Via->SetLayer( 0x0F );
if( Drc_On &&( Drc( this, DC, Via, m_Pcb->m_Track, 1 ) == BAD_DRC ) ) if( Drc_On &&( Drc( this, DC, Via, m_Pcb->m_Track, 1 ) == BAD_DRC ) )
{ /* Via impossible a placer ici */ { /* Via impossible a placer ici */
delete Via; delete Via;
GetScreen()->m_Active_Layer = g_CurrentTrackSegment->m_Layer; GetScreen()->m_Active_Layer = g_CurrentTrackSegment->GetLayer();
DrawPanel->ManageCurseur( DrawPanel, DC, FALSE ); DrawPanel->ManageCurseur( DrawPanel, DC, FALSE );
return; return;
} }
@ -240,7 +240,7 @@ void WinEDA_PcbFrame::Other_Layer_Route( TRACK* track, wxDC* DC )
g_CurrentTrackSegment->Pnext = Via; g_CurrentTrackSegment->Pnext = Via;
g_TrackSegmentCount++; g_TrackSegmentCount++;
g_CurrentTrackSegment = new TRACK( *g_CurrentTrackSegment ); g_CurrentTrackSegment = new TRACK( *g_CurrentTrackSegment );
g_CurrentTrackSegment->m_Layer = GetScreen()->m_Active_Layer; g_CurrentTrackSegment->SetLayer( GetScreen()->m_Active_Layer );
g_CurrentTrackSegment->m_Start = g_CurrentTrackSegment->m_End = Via->m_Start; g_CurrentTrackSegment->m_Start = g_CurrentTrackSegment->m_End = Via->m_Start;
g_TrackSegmentCount++; g_TrackSegmentCount++;
g_CurrentTrackSegment->Pback = Via; g_CurrentTrackSegment->Pback = Via;

18
pcbnew/editrack.cpp
View File

@ -130,7 +130,7 @@ TRACK* WinEDA_PcbFrame::Begin_Route( TRACK* track, wxDC* DC )
Hight_Light( DC ); Hight_Light( DC );
g_CurrentTrackSegment->m_Flags = IS_NEW; g_CurrentTrackSegment->m_Flags = IS_NEW;
g_CurrentTrackSegment->m_Layer = GetScreen()->m_Active_Layer; g_CurrentTrackSegment->SetLayer( GetScreen()->m_Active_Layer );
g_CurrentTrackSegment->m_Width = g_DesignSettings.m_CurrentTrackWidth; g_CurrentTrackSegment->m_Width = g_DesignSettings.m_CurrentTrackWidth;
g_CurrentTrackSegment->m_Start = pos; g_CurrentTrackSegment->m_Start = pos;
g_CurrentTrackSegment->m_End = g_CurrentTrackSegment->m_Start; g_CurrentTrackSegment->m_End = g_CurrentTrackSegment->m_Start;
@ -211,7 +211,7 @@ TRACK* WinEDA_PcbFrame::Begin_Route( TRACK* track, wxDC* DC )
g_CurrentTrackSegment->m_Flags = IS_NEW; g_CurrentTrackSegment->m_Flags = IS_NEW;
g_TrackSegmentCount++; g_TrackSegmentCount++;
g_CurrentTrackSegment->m_Start = g_CurrentTrackSegment->m_End; g_CurrentTrackSegment->m_Start = g_CurrentTrackSegment->m_End;
g_CurrentTrackSegment->m_Layer = GetScreen()->m_Active_Layer; g_CurrentTrackSegment->SetLayer( GetScreen()->m_Active_Layer );
g_CurrentTrackSegment->m_Width = g_DesignSettings.m_CurrentTrackWidth; g_CurrentTrackSegment->m_Width = g_DesignSettings.m_CurrentTrackWidth;
/* Show the new position */ /* Show the new position */
ShowNewTrackWhenMovingCursor( DrawPanel, DC, FALSE ); ShowNewTrackWhenMovingCursor( DrawPanel, DC, FALSE );
@ -269,9 +269,9 @@ int Add_45_degrees_Segment( WinEDA_BasePcbFrame* frame, wxDC* DC, TRACK* pt_segm
dy1 = pt_segm->m_End.y - pt_segm->m_Start.y; dy1 = pt_segm->m_End.y - pt_segm->m_Start.y;
// les segments doivent etre de longueur suffisante: // les segments doivent etre de longueur suffisante:
if( max( abs( dx0 ), abs( dy0 ) ) < (pas_45 * 2) ) if( MAX( abs( dx0 ), abs( dy0 ) ) < (pas_45 * 2) )
return 0; return 0;
if( max( abs( dx1 ), abs( dy1 ) ) < (pas_45 * 2) ) if( MAX( abs( dx1 ), abs( dy1 ) ) < (pas_45 * 2) )
return 0; return 0;
/* creation du nouveau segment, raccordant des 2 segm: */ /* creation du nouveau segment, raccordant des 2 segm: */
@ -502,14 +502,14 @@ void ShowNewTrackWhenMovingCursor( WinEDA_DrawPanel* panel, wxDC* DC, bool erase
} }
/* dessin de la nouvelle piste : mise a jour du point d'arrivee */ /* dessin de la nouvelle piste : mise a jour du point d'arrivee */
g_CurrentTrackSegment->m_Layer = screen->m_Active_Layer; g_CurrentTrackSegment->SetLayer( screen->m_Active_Layer );
g_CurrentTrackSegment->m_Width = g_DesignSettings.m_CurrentTrackWidth; g_CurrentTrackSegment->m_Width = g_DesignSettings.m_CurrentTrackWidth;
if( g_TwoSegmentTrackBuild ) if( g_TwoSegmentTrackBuild )
{ {
TRACK* previous_track = (TRACK*) g_CurrentTrackSegment->Pback; TRACK* previous_track = (TRACK*) g_CurrentTrackSegment->Pback;
if( previous_track && (previous_track->m_StructType == TYPETRACK) ) if( previous_track && (previous_track->m_StructType == TYPETRACK) )
{ {
previous_track->m_Layer = screen->m_Active_Layer; previous_track->SetLayer( screen->m_Active_Layer );
previous_track->m_Width = g_DesignSettings.m_CurrentTrackWidth; previous_track->m_Width = g_DesignSettings.m_CurrentTrackWidth;
} }
} }
@ -584,7 +584,7 @@ void Calcule_Coord_Extremite_45( int ox, int oy, int* fx, int* fy )
break; break;
case 45: case 45:
deltax = min( deltax, deltay ); deltay = deltax; deltax = MIN( deltax, deltay ); deltay = deltax;
/* recalcul des signes de deltax et deltay */ /* recalcul des signes de deltax et deltay */
if( (ActiveScreen->m_Curseur.x - ox) < 0 ) if( (ActiveScreen->m_Curseur.x - ox) < 0 )
deltax = -deltax; deltax = -deltax;
@ -666,7 +666,7 @@ void ComputeBreakPoint( TRACK* track, int SegmentCount )
break; break;
case 45: case 45:
iDx = min( iDx, iDy ); iDx = MIN( iDx, iDy );
iDy = iDx; iDy = iDx;
/* recalcul des signes de deltax et deltay */ /* recalcul des signes de deltax et deltay */
if( (ActiveScreen->m_Curseur.x - track->m_Start.x) < 0 ) if( (ActiveScreen->m_Curseur.x - track->m_Start.x) < 0 )
@ -707,7 +707,7 @@ TRACK* DeleteNullTrackSegments( BOARD* pcb, TRACK* track, int* segmcount )
TRACK* firsttrack = track; TRACK* firsttrack = track;
TRACK* oldtrack; TRACK* oldtrack;
int nn = 0; int nn = 0;
EDA_BaseStruct* LockPoint; BOARD_ITEM* LockPoint;
if( track == 0 ) if( track == 0 )
return NULL; return NULL;

279
pcbnew/export_gencad.cpp
View File

@ -23,8 +23,8 @@ static void CreateShapesSection(FILE * file, BOARD * pcb);
static void CreatePadsShapesSection( FILE* file, BOARD* pcb ); static void CreatePadsShapesSection( FILE* file, BOARD* pcb );
static void ModuleWriteShape( FILE* File, MODULE* module ); static void ModuleWriteShape( FILE* File, MODULE* module );
wxString GenCAD_Layer_Name[32] // layer name pour extensions fichiers de trace // layer name pour extensions fichiers de tracewxString
= { static const wxString GenCAD_Layer_Name[32] = {
wxT( "BOTTOM" ), wxT( "INNER1" ), wxT( "INNER2" ), wxT("INNER3" ), wxT( "BOTTOM" ), wxT( "INNER1" ), wxT( "INNER2" ), wxT("INNER3" ),
wxT( "INNER4" ), wxT( "INNER5" ), wxT( "INNER6" ), wxT("INNER7" ), wxT( "INNER4" ), wxT( "INNER5" ), wxT( "INNER6" ), wxT("INNER7" ),
wxT( "INNER8" ), wxT( "INNER9" ), wxT( "INNER10" ), wxT("INNER11" ), wxT( "INNER8" ), wxT( "INNER9" ), wxT( "INNER10" ), wxT("INNER11" ),
@ -43,6 +43,8 @@ static int mapXto(int x)
{ {
return x - offsetX; return x - offsetX;
} }
static int mapYto( int y ) static int mapYto( int y )
{ {
return offsetY - y; return offsetY - y;
@ -52,8 +54,9 @@ static int mapYto(int y)
/***********************************************************/ /***********************************************************/
void WinEDA_PcbFrame::ExportToGenCAD( wxCommandEvent& event ) void WinEDA_PcbFrame::ExportToGenCAD( wxCommandEvent& event )
/***********************************************************/ /***********************************************************/
/* /*
Exporte le board au format GenCAD 1.4 * Exporte le board au format GenCAD 1.4
*/ */
{ {
wxString FullFileName = GetScreen()->m_FileName; wxString FullFileName = GetScreen()->m_FileName;
@ -72,7 +75,8 @@ FILE * file;
wxFD_SAVE, wxFD_SAVE,
FALSE FALSE
); );
if ( FullFileName == wxEmptyString ) return; if( FullFileName == wxEmptyString )
return;
if( ( file = wxFopen( FullFileName, wxT( "wt" ) ) ) == NULL ) if( ( file = wxFopen( FullFileName, wxT( "wt" ) ) ) == NULL )
{ {
@ -86,32 +90,34 @@ FILE * file;
offsetX = m_Auxiliary_Axis_Position.x; offsetX = m_Auxiliary_Axis_Position.x;
offsetY = m_Auxiliary_Axis_Position.y; offsetY = m_Auxiliary_Axis_Position.y;
wxClientDC dc( DrawPanel ); wxClientDC dc( DrawPanel );
DrawPanel->PrepareGraphicContext( &dc ); DrawPanel->PrepareGraphicContext( &dc );
Compile_Ratsnest( &dc, TRUE ); Compile_Ratsnest( &dc, TRUE );
/* Mise des modules vus en miroir en position "normale" /* Mise des modules vus en miroir en position "normale"
(necessaire pour decrire les formes sous GenCAD, * (necessaire pour decrire les formes sous GenCAD,
qui sont decrites en vue normale, orientation 0)) */ * qui sont decrites en vue normale, orientation 0)) */
MODULE* module; MODULE* module;
for( module = m_Pcb->m_Modules; module != NULL; module = module->Next() ) for( module = m_Pcb->m_Modules; module != NULL; module = module->Next() )
{ {
module->flag = 0; module->flag = 0;
if ( module->m_Layer == CUIVRE_N ) if( module->GetLayer() == CUIVRE_N )
{ {
Change_Side_Module( module, NULL ); Change_Side_Module( module, NULL );
module->flag = 1; module->flag = 1;
} }
} }
// Creation de l'entete: // Creation de l'entete:
CreateHeaderInfoData( file, this ); CreateHeaderInfoData( file, this );
CreateBoardSection( file, m_Pcb ); CreateBoardSection( file, m_Pcb );
/* Creation liste des TRACKS /* Creation liste des TRACKS
(section $TRACK) id liste des outils de tracage de pistes */ * (section $TRACK) id liste des outils de tracage de pistes */
CreateTracksInfoData( file, m_Pcb ); CreateTracksInfoData( file, m_Pcb );
/* Creation de la liste des formes utilisees /* Creation de la liste des formes utilisees
(formes des composants principalement */ * (formes des composants principalement */
CreatePadsShapesSection( file, m_Pcb ); // doit etre appele avant CreateShapesSection() CreatePadsShapesSection( file, m_Pcb ); // doit etre appele avant CreateShapesSection()
CreateShapesSection( file, m_Pcb ); CreateShapesSection( file, m_Pcb );
@ -139,8 +145,9 @@ MODULE * module;
/**************************************************************************/ /**************************************************************************/
static int Pad_list_Sort_by_Shapes( const void* refptr, const void* objptr ) static int Pad_list_Sort_by_Shapes( const void* refptr, const void* objptr )
/**************************************************************************/ /**************************************************************************/
/* /*
Routine de tri de la liste des pads par type, puis pa taille * Routine de tri de la liste des pads par type, puis pa taille
*/ */
{ {
const D_PAD* padref, * padcmp; const D_PAD* padref, * padcmp;
@ -148,23 +155,32 @@ int diff;
padref = *( (D_PAD**) refptr ); padref = *( (D_PAD**) refptr );
padcmp = *( (D_PAD**) objptr ); padcmp = *( (D_PAD**) objptr );
if( (diff = padref->m_PadShape - padcmp->m_PadShape) ) return diff; if( (diff = padref->m_PadShape - padcmp->m_PadShape) )
if( (diff = padref->m_Size.x - padcmp->m_Size.x) ) return diff; return diff;
if( (diff = padref->m_Size.y - padcmp->m_Size.y) ) return diff; if( (diff = padref->m_Size.x - padcmp->m_Size.x) )
if( (diff = padref->m_Offset.x - padcmp->m_Offset.x) ) return diff; return diff;
if( (diff = padref->m_Offset.y - padcmp->m_Offset.y) ) return diff; if( (diff = padref->m_Size.y - padcmp->m_Size.y) )
if( (diff = padref->m_DeltaSize.x - padcmp->m_DeltaSize.x) ) return diff; return diff;
if( (diff = padref->m_DeltaSize.y - padcmp->m_DeltaSize.y) ) return diff; if( (diff = padref->m_Offset.x - padcmp->m_Offset.x) )
return diff;
if( (diff = padref->m_Offset.y - padcmp->m_Offset.y) )
return diff;
if( (diff = padref->m_DeltaSize.x - padcmp->m_DeltaSize.x) )
return diff;
if( (diff = padref->m_DeltaSize.y - padcmp->m_DeltaSize.y) )
return diff;
return 0; return 0;
} }
/*****************************************************/ /*****************************************************/
void CreatePadsShapesSection( FILE* file, BOARD* pcb ) void CreatePadsShapesSection( FILE* file, BOARD* pcb )
/*****************************************************/ /*****************************************************/
/* Cree la liste des formes des pads ( 1 forme par pad ) /* Cree la liste des formes des pads ( 1 forme par pad )
initialise le membre .m_logical_connexion de la struct pad, la valeur 1 ..n * initialise le membre .m_logical_connexion de la struct pad, la valeur 1 ..n
pour les formes de pad PAD1 a PADn * pour les formes de pad PAD1 a PADn
*/ */
{ {
D_PAD* pad, ** padlist, ** pad_list_base; D_PAD* pad, ** padlist, ** pad_list_base;
@ -187,14 +203,14 @@ int pad_name_number;
pad = *padlist; pad = *padlist;
pad->m_logical_connexion = pad_name_number; pad->m_logical_connexion = pad_name_number;
if ( old_pad && if( old_pad
(old_pad->m_PadShape == pad->m_PadShape) && && (old_pad->m_PadShape == pad->m_PadShape)
(old_pad->m_Size.x == pad->m_Size.x) && && (old_pad->m_Size.x == pad->m_Size.x)
(old_pad->m_Size.y == pad->m_Size.y) && && (old_pad->m_Size.y == pad->m_Size.y)
(old_pad->m_Offset.x == pad->m_Offset.x) && && (old_pad->m_Offset.x == pad->m_Offset.x)
(old_pad->m_Offset.y == pad->m_Offset.y) && && (old_pad->m_Offset.y == pad->m_Offset.y)
(old_pad->m_DeltaSize.x == pad->m_DeltaSize.x) && && (old_pad->m_DeltaSize.x == pad->m_DeltaSize.x)
(old_pad->m_DeltaSize.y == pad->m_DeltaSize.y) && (old_pad->m_DeltaSize.y == pad->m_DeltaSize.y)
) )
continue; // Forme deja generee continue; // Forme deja generee
@ -286,21 +302,22 @@ int pad_name_number;
/**************************************************/ /**************************************************/
void CreateShapesSection( FILE* file, BOARD* pcb ) void CreateShapesSection( FILE* file, BOARD* pcb )
/**************************************************/ /**************************************************/
/* Creation de la liste des formes des composants. /* Creation de la liste des formes des composants.
Comme la forme de base (module de librairie peut etre modifiee, * Comme la forme de base (module de librairie peut etre modifiee,
une forme est creee par composant * une forme est creee par composant
La forme est donnee normalisee, c'est a dire orientation 0, position 0 non miroir * La forme est donnee normalisee, c'est a dire orientation 0, position 0 non miroir
Il y aura donc des formes indentiques redondantes * Il y aura donc des formes indentiques redondantes
*
Syntaxe: * Syntaxe:
$SHAPES * $SHAPES
SHAPE <shape_name> * SHAPE <shape_name>
shape_descr (line, arc ..) * shape_descr (line, arc ..)
PIN <pin_name> <pad_name> <x_y_ref> <layer> <rot> <mirror> * PIN <pin_name> <pad_name> <x_y_ref> <layer> <rot> <mirror>
*
SHAPE <shape_name> * SHAPE <shape_name>
.. * ..
$ENDSHAPES * $ENDSHAPES
*/ */
{ {
MODULE* module; MODULE* module;
@ -320,17 +337,22 @@ char * mirror = "0";
layer = "ALL"; layer = "ALL";
if( (pad->m_Masque_Layer & ALL_CU_LAYERS) == CUIVRE_LAYER ) if( (pad->m_Masque_Layer & ALL_CU_LAYERS) == CUIVRE_LAYER )
{ {
if ( module->m_Layer == CMP_N ) layer = "BOTTOM"; if( module->GetLayer() == CMP_N )
else layer = "TOP"; layer = "BOTTOM";
else
layer = "TOP";
} }
else if( (pad->m_Masque_Layer & ALL_CU_LAYERS) == CMP_LAYER ) else if( (pad->m_Masque_Layer & ALL_CU_LAYERS) == CMP_LAYER )
{ {
if ( module->m_Layer == CMP_N ) layer = "TOP"; if( module->GetLayer() == CMP_N )
else layer = "BOTTOM"; layer = "TOP";
else
layer = "BOTTOM";
} }
pad->ReturnStringPadName( pinname ); pad->ReturnStringPadName( pinname );
if( pinname.IsEmpty() ) pinname = wxT("noname"); if( pinname.IsEmpty() )
pinname = wxT( "noname" );
orient = pad->m_Orient - module->m_Orient; orient = pad->m_Orient - module->m_Orient;
NORMALIZE_ANGLE_POS( orient ); NORMALIZE_ANGLE_POS( orient );
@ -338,7 +360,8 @@ char * mirror = "0";
CONV_TO_UTF8( pinname ), pad->m_logical_connexion, CONV_TO_UTF8( pinname ), pad->m_logical_connexion,
pad->m_Pos0.x, -pad->m_Pos0.y, pad->m_Pos0.x, -pad->m_Pos0.y,
layer, orient / 10, mirror ); layer, orient / 10, mirror );
if ( orient % 10 ) fprintf(file, " .%d", orient % 10 ); if( orient % 10 )
fprintf( file, " .%d", orient % 10 );
fprintf( file, "\n" ); fprintf( file, "\n" );
} }
} }
@ -346,14 +369,16 @@ char * mirror = "0";
fputs( "$ENDSHAPES\n\n", file ); fputs( "$ENDSHAPES\n\n", file );
} }
/******************************************************/ /******************************************************/
void CreateComponentsSection( FILE* file, BOARD* pcb ) void CreateComponentsSection( FILE* file, BOARD* pcb )
/******************************************************/ /******************************************************/
/* Creation de la section $COMPONENTS (Placement des composants /* Creation de la section $COMPONENTS (Placement des composants
Composants cote CUIVRE: * Composants cote CUIVRE:
Les formes sont donnees avec l'option "FLIP", c.a.d.: * Les formes sont donnees avec l'option "FLIP", c.a.d.:
- ils sont decrits en vue normale (comme s'ils etaient sur cote COMPOSANT) * - ils sont decrits en vue normale (comme s'ils etaient sur cote COMPOSANT)
- leur orientation est donnée comme s'ils etaient cote composant. * - leur orientation est donnée comme s'ils etaient cote composant.
*/ */
{ {
MODULE* module = pcb->m_Modules; MODULE* module = pcb->m_Modules;
@ -385,7 +410,8 @@ int ii;
fprintf( file, "LAYER %s\n", (module->flag) ? "BOTTOM" : "TOP" ); fprintf( file, "LAYER %s\n", (module->flag) ? "BOTTOM" : "TOP" );
fprintf( file, "ROTATION %d", orient / 10 ); fprintf( file, "ROTATION %d", orient / 10 );
if (orient%10 ) fprintf(file, ".%d", orient%10 ); if( orient % 10 )
fprintf( file, ".%d", orient % 10 );
fputs( "\n", file ); fputs( "\n", file );
fprintf( file, "SHAPE %s %s %s\n", fprintf( file, "SHAPE %s %s %s\n",
@ -416,22 +442,23 @@ int ii;
// commentaire: // commentaire:
fprintf( file, "SHEET Part %s %s\n", CONV_TO_UTF8( module->m_Reference->m_Text ), fprintf( file, "SHEET Part %s %s\n", CONV_TO_UTF8( module->m_Reference->m_Text ),
CONV_TO_UTF8( module->m_Value->m_Text ) ); CONV_TO_UTF8( module->m_Value->m_Text ) );
} }
fputs( "$ENDCOMPONENTS\n\n", file ); fputs( "$ENDCOMPONENTS\n\n", file );
} }
/***************************************************/ /***************************************************/
void CreateSignalsSection( FILE* file, BOARD* pcb ) void CreateSignalsSection( FILE* file, BOARD* pcb )
/***************************************************/ /***************************************************/
/* Creation de la liste des equipotentielles: /* Creation de la liste des equipotentielles:
$SIGNALS * $SIGNALS
SIGNAL <equipot name> * SIGNAL <equipot name>
NODE <component name> <pin name> * NODE <component name> <pin name>
... * ...
NODE <component name> <pin name> * NODE <component name> <pin name>
$ENDSIGNALS * $ENDSIGNALS
*/ */
{ {
wxString msg; wxString msg;
@ -460,7 +487,8 @@ int NbNoConn = 1;
for( pad = module->m_Pads; pad != NULL; pad = (D_PAD*) pad->Pnext ) for( pad = module->m_Pads; pad != NULL; pad = (D_PAD*) pad->Pnext )
{ {
wxString padname; wxString padname;
if ( pad->m_NetCode != equipot->m_NetCode ) continue; if( pad->m_NetCode != equipot->m_NetCode )
continue;
pad->ReturnStringPadName( padname ); pad->ReturnStringPadName( padname );
msg.Printf( wxT( "NODE %s %.4s" ), msg.Printf( wxT( "NODE %s %.4s" ),
module->m_Reference->m_Text.GetData(), padname.GetData() ); module->m_Reference->m_Text.GetData(), padname.GetData() );
@ -470,12 +498,13 @@ int NbNoConn = 1;
} }
fputs( "$ENDSIGNALS\n\n", file ); fputs( "$ENDSIGNALS\n\n", file );
} }
/*************************************************************/ /*************************************************************/
bool CreateHeaderInfoData( FILE* file, WinEDA_PcbFrame* frame ) bool CreateHeaderInfoData( FILE* file, WinEDA_PcbFrame* frame )
/*************************************************************/ /*************************************************************/
/* Creation de la section $HEADER ... $ENDHEADER /* Creation de la section $HEADER ... $ENDHEADER
*/ */
{ {
@ -505,9 +534,10 @@ PCB_SCREEN * screen = frame->GetScreen();
/**************************************************************************/ /**************************************************************************/
static int Track_list_Sort_by_Netcode( const void* refptr, const void* objptr ) static int Track_list_Sort_by_Netcode( const void* refptr, const void* objptr )
/**************************************************************************/ /**************************************************************************/
/* /*
Routine de tri de la liste des piste par netcode, * Routine de tri de la liste des piste par netcode,
puis par largeur puis par layer * puis par largeur puis par layer
*/ */
{ {
const TRACK* ref, * cmp; const TRACK* ref, * cmp;
@ -515,21 +545,27 @@ int diff;
ref = *( (TRACK**) refptr ); ref = *( (TRACK**) refptr );
cmp = *( (TRACK**) objptr ); cmp = *( (TRACK**) objptr );
if( (diff = ref->m_NetCode - cmp->m_NetCode) ) return diff; if( (diff = ref->m_NetCode - cmp->m_NetCode) )
if( (diff = ref->m_Width - cmp->m_Width) ) return diff; return diff;
if( (diff = ref->m_Layer - cmp->m_Layer) ) return diff; if( (diff = ref->m_Width - cmp->m_Width) )
return diff;
if( (diff = ref->GetLayer() - cmp->GetLayer()) )
return diff;
return 0; return 0;
} }
/*************************************************/ /*************************************************/
void CreateRoutesSection( FILE* file, BOARD* pcb ) void CreateRoutesSection( FILE* file, BOARD* pcb )
/*************************************************/ /*************************************************/
/* Creation de la liste des pistes, vias et zones /* Creation de la liste des pistes, vias et zones
section: * section:
$ROUTE * $ROUTE
... * ...
$ENROUTE * $ENROUTE
Les segments de piste doivent etre regroupes par nets * Les segments de piste doivent etre regroupes par nets
*/ */
{ {
TRACK* track, ** tracklist; TRACK* track, ** tracklist;
@ -539,20 +575,27 @@ int nbitems, ii;
// Calcul du nombre de segments a ecrire // Calcul du nombre de segments a ecrire
nbitems = 0; nbitems = 0;
for( track = pcb->m_Track; track != NULL; track = (TRACK*) track->Pnext ) nbitems++; for( track = pcb->m_Track; track != NULL; track = (TRACK*) track->Pnext )
nbitems++;
for( track = pcb->m_Zone; track != NULL; track = (TRACK*) track->Pnext ) for( track = pcb->m_Zone; track != NULL; track = (TRACK*) track->Pnext )
{ {
if ( track->m_StructType == TYPEZONE ) nbitems++; if( track->m_StructType == TYPEZONE )
nbitems++;
} }
tracklist = (TRACK**) MyMalloc( (nbitems + 1) * sizeof(TRACK *) ); tracklist = (TRACK**) MyMalloc( (nbitems + 1) * sizeof(TRACK *) );
nbitems = 0; nbitems = 0;
for( track = pcb->m_Track; track != NULL; track = (TRACK*) track->Pnext ) for( track = pcb->m_Track; track != NULL; track = (TRACK*) track->Pnext )
tracklist[nbitems++] = track; tracklist[nbitems++] = track;
for( track = pcb->m_Zone; track != NULL; track = (TRACK*) track->Pnext ) for( track = pcb->m_Zone; track != NULL; track = (TRACK*) track->Pnext )
{ {
if ( track->m_StructType == TYPEZONE ) tracklist[nbitems++] = track; if( track->m_StructType == TYPEZONE )
tracklist[nbitems++] = track;
} }
tracklist[nbitems] = NULL; tracklist[nbitems] = NULL;
qsort( tracklist, nbitems, sizeof(TRACK *), Track_list_Sort_by_Netcode ); qsort( tracklist, nbitems, sizeof(TRACK *), Track_list_Sort_by_Netcode );
@ -570,7 +613,8 @@ int nbitems, ii;
wxString netname; wxString netname;
if( equipot && (equipot->m_Netname != wxEmptyString) ) if( equipot && (equipot->m_Netname != wxEmptyString) )
netname = equipot->m_Netname; netname = equipot->m_Netname;
else netname = wxT("_noname_" ); else
netname = wxT( "_noname_" );
fprintf( file, "\nROUTE %s\n", CONV_TO_UTF8( netname ) ); fprintf( file, "\nROUTE %s\n", CONV_TO_UTF8( netname ) );
} }
@ -582,11 +626,11 @@ int nbitems, ii;
if( (track->m_StructType == TYPETRACK) || (track->m_StructType == TYPEZONE) ) if( (track->m_StructType == TYPETRACK) || (track->m_StructType == TYPEZONE) )
{ {
if ( old_layer != track->m_Layer ) if( old_layer != track->GetLayer() )
{ {
old_layer = track->m_Layer; old_layer = track->GetLayer();
fprintf( file, "LAYER %s\n", fprintf( file, "LAYER %s\n",
CONV_TO_UTF8(GenCAD_Layer_Name[track->m_Layer & 0x1F])); CONV_TO_UTF8( GenCAD_Layer_Name[track->GetLayer() & 0x1F] ) );
} }
fprintf( file, "LINE %d %d %d %d\n", fprintf( file, "LINE %d %d %d %d\n",
@ -611,8 +655,9 @@ int nbitems, ii;
/***************************************************/ /***************************************************/
void CreateDevicesSection( FILE* file, BOARD* pcb ) void CreateDevicesSection( FILE* file, BOARD* pcb )
/***************************************************/ /***************************************************/
/* Creation de la section de description des proprietes des composants /* Creation de la section de description des proprietes des composants
( la forme des composants est dans la section shape ) * ( la forme des composants est dans la section shape )
*/ */
{ {
MODULE* module; MODULE* module;
@ -628,9 +673,12 @@ D_PAD * pad;
for( pad = module->m_Pads; pad != NULL; pad = (D_PAD*) pad->Pnext ) for( pad = module->m_Pads; pad != NULL; pad = (D_PAD*) pad->Pnext )
{ {
fprintf( file, "PINDESCR %.4s", pad->m_Padname ); fprintf( file, "PINDESCR %.4s", pad->m_Padname );
if ( pad->m_Netname == wxEmptyString ) fputs(" NoConn\n", file); if( pad->m_Netname == wxEmptyString )
else fprintf(file, " %.4s\n", pad->m_Padname); fputs( " NoConn\n", file );
else
fprintf( file, " %.4s\n", pad->m_Padname );
} }
fprintf( file, "ATTRIBUTE %s\n", CONV_TO_UTF8( module->m_Value->m_Text ) ); fprintf( file, "ATTRIBUTE %s\n", CONV_TO_UTF8( module->m_Value->m_Text ) );
} }
@ -641,8 +689,9 @@ D_PAD * pad;
/*************************************************/ /*************************************************/
void CreateBoardSection( FILE* file, BOARD* pcb ) void CreateBoardSection( FILE* file, BOARD* pcb )
/*************************************************/ /*************************************************/
/* Creation de la section $BOARD. /* Creation de la section $BOARD.
On ne cree ici que le rectangle d'encadrement du Board * On ne cree ici que le rectangle d'encadrement du Board
*/ */
{ {
fputs( "$BOARD\n", file ); fputs( "$BOARD\n", file );
@ -666,15 +715,16 @@ On ne cree ici que le rectangle d'encadrement du Board
/****************************************************/ /****************************************************/
int* CreateTracksInfoData( FILE* file, BOARD* pcb ) int* CreateTracksInfoData( FILE* file, BOARD* pcb )
/****************************************************/ /****************************************************/
/* Creation de la section "$TRACKS"
Cette section definit les largeurs de pistes utilsees
format:
$TRACK
TRACK <name> <width>
$ENDTRACK
on attribut ici comme nom l'epaisseur des traits precede de "TRACK": ex /* Creation de la section "$TRACKS"
pour une largeur de 120 : nom = "TRACK120". * Cette section definit les largeurs de pistes utilsees
* format:
* $TRACK
* TRACK <name> <width>
* $ENDTRACK
*
* on attribut ici comme nom l'epaisseur des traits precede de "TRACK": ex
* pour une largeur de 120 : nom = "TRACK120".
*/ */
{ {
TRACK* track; TRACK* track;
@ -692,9 +742,12 @@ int * trackinfo, * ptinfo;
ptinfo = (int*) adr_lowmem; ptinfo = (int*) adr_lowmem;
while( *ptinfo >= 0 ) while( *ptinfo >= 0 )
{ {
if ( *ptinfo != track->m_Width ) ptinfo ++; if( *ptinfo != track->m_Width )
else break; ptinfo++;
else
break;
} }
trackinfo = ptinfo; trackinfo = ptinfo;
if( *ptinfo < 0 ) if( *ptinfo < 0 )
{ {
@ -703,6 +756,7 @@ int * trackinfo, * ptinfo;
} }
} }
} }
for( track = pcb->m_Zone; track != NULL; track = (TRACK*) track->Pnext ) for( track = pcb->m_Zone; track != NULL; track = (TRACK*) track->Pnext )
{ {
if( *trackinfo != track->m_Width ) // recherche d'une epaisseur deja utilisee if( *trackinfo != track->m_Width ) // recherche d'une epaisseur deja utilisee
@ -710,9 +764,12 @@ int * trackinfo, * ptinfo;
ptinfo = (int*) adr_lowmem; ptinfo = (int*) adr_lowmem;
while( *ptinfo >= 0 ) while( *ptinfo >= 0 )
{ {
if ( *ptinfo != track->m_Width ) ptinfo ++; if( *ptinfo != track->m_Width )
else break; ptinfo++;
else
break;
} }
trackinfo = ptinfo; trackinfo = ptinfo;
if( *ptinfo < 0 ) if( *ptinfo < 0 )
{ {
@ -728,6 +785,7 @@ int * trackinfo, * ptinfo;
{ {
fprintf( file, "TRACK TRACK%d %d\n", *trackinfo, *trackinfo ); fprintf( file, "TRACK TRACK%d %d\n", *trackinfo, *trackinfo );
} }
fputs( "$ENDTRACKS\n\n", file ); fputs( "$ENDTRACKS\n\n", file );
return (int*) adr_lowmem; return (int*) adr_lowmem;
@ -737,14 +795,15 @@ int * trackinfo, * ptinfo;
/***************************************************/ /***************************************************/
void ModuleWriteShape( FILE* file, MODULE* module ) void ModuleWriteShape( FILE* file, MODULE* module )
/***************************************************/ /***************************************************/
/* Sauvegarde de la forme d'un MODULE (section SHAPE) /* Sauvegarde de la forme d'un MODULE (section SHAPE)
La forme est donnee "normalisee" (Orient 0, vue normale ( non miroir) * La forme est donnee "normalisee" (Orient 0, vue normale ( non miroir)
Syntaxe: * Syntaxe:
SHAPE <shape_name> * SHAPE <shape_name>
shape_descr (line, arc ..): * shape_descr (line, arc ..):
LINE startX startY endX endY * LINE startX startY endX endY
ARC startX startY endX endY centreX scentreY * ARC startX startY endX endY centreX scentreY
CIRCLE centreX scentreY radius * CIRCLE centreX scentreY radius
*/ */
{ {
EDGE_MODULE* PtEdge; EDGE_MODULE* PtEdge;
@ -759,8 +818,10 @@ int Yaxis_sign = -1; // Controle changement signe axe Y (selon module normal/mir
if( module->m_Attributs != MOD_DEFAULT ) if( module->m_Attributs != MOD_DEFAULT )
{ {
fprintf( file, "ATTRIBUTE" ); fprintf( file, "ATTRIBUTE" );
if( module->m_Attributs & MOD_CMS ) fprintf(file," SMD"); if( module->m_Attributs & MOD_CMS )
if( module->m_Attributs & MOD_VIRTUAL ) fprintf(file," VIRTUAL"); fprintf( file, " SMD" );
if( module->m_Attributs & MOD_VIRTUAL )
fprintf( file, " VIRTUAL" );
fprintf( file, "\n" ); fprintf( file, "\n" );
} }
@ -776,6 +837,7 @@ int Yaxis_sign = -1; // Controle changement signe axe Y (selon module normal/mir
case TYPEEDGEMODULE: case TYPEEDGEMODULE:
PtEdge = (EDGE_MODULE*) PtStruct; PtEdge = (EDGE_MODULE*) PtStruct;
switch( PtEdge->m_Shape ) switch( PtEdge->m_Shape )
{ {
case S_SEGMENT: case S_SEGMENT:
@ -783,6 +845,7 @@ int Yaxis_sign = -1; // Controle changement signe axe Y (selon module normal/mir
PtEdge->m_Start0.x, Yaxis_sign * PtEdge->m_Start0.y, PtEdge->m_Start0.x, Yaxis_sign * PtEdge->m_Start0.y,
PtEdge->m_End0.x, Yaxis_sign * PtEdge->m_End0.y ); PtEdge->m_End0.x, Yaxis_sign * PtEdge->m_End0.y );
break; break;
case S_CIRCLE: case S_CIRCLE:
{ {
int rayon = (int) hypot( int rayon = (int) hypot(
@ -806,15 +869,19 @@ int Yaxis_sign = -1; // Controle changement signe axe Y (selon module normal/mir
PtEdge->m_Start0.x, Yaxis_sign * PtEdge->m_Start0.y ); PtEdge->m_Start0.x, Yaxis_sign * PtEdge->m_Start0.y );
break; break;
} }
default: default:
DisplayError( NULL, wxT( "Type Edge Module inconnu" ) ); DisplayError( NULL, wxT( "Type Edge Module inconnu" ) );
break; break;
} /* Fin switch type edge */ }
/* Fin switch type edge */
break; break;
default: default:
break; break;
} /* Fin switch gestion des Items draw */
}
} }
/* Fin switch gestion des Items draw */
}
}

96
pcbnew/gen_modules_placefile.cpp
View File

@ -3,8 +3,8 @@
/*************************************/ /*************************************/
/* /*
1 - create ascii files for automatic placement of smd components * 1 - create ascii files for automatic placement of smd components
2 - create a module report (pos and module descr) (ascii file) * 2 - create a module report (pos and module descr) (ascii file)
*/ */
#include "fctsys.h" #include "fctsys.h"
@ -30,16 +30,16 @@ static void WriteDrawSegmentPcb(DRAWSEGMENT * PtDrawSegment, FILE * rptfile);
/* Routine de tri utilisee par GenereModulesPosition() */ /* Routine de tri utilisee par GenereModulesPosition() */
static int ListeModCmp( LIST_MOD* Ref, LIST_MOD* Cmp ) static int ListeModCmp( LIST_MOD* Ref, LIST_MOD* Cmp )
{ {
return ( StrLenNumCmp(Ref->m_Reference, Cmp->m_Reference, 16) ); return StrLenNumCmp( Ref->m_Reference, Cmp->m_Reference, 16 );
} }
/**************************************************************/ /**************************************************************/
void WinEDA_PcbFrame::GenModulesPosition( wxCommandEvent& event ) void WinEDA_PcbFrame::GenModulesPosition( wxCommandEvent& event )
/**************************************************************/ /**************************************************************/
/* Routine de generation du fichier de positionnement des modules, /* Routine de generation du fichier de positionnement des modules,
utilisé pour les machines de placement de composants * utilisé pour les machines de placement de composants
*/ */
{ {
float conv_unit; float conv_unit;
@ -53,6 +53,7 @@ FILE * LayerCu = NULL, *LayerCmp = NULL;
/* Calcul des echelles de conversion */ /* Calcul des echelles de conversion */
conv_unit = 0.0001; /* unites = INCHES */ conv_unit = 0.0001; /* unites = INCHES */
// if(IF_DRILL_METRIC) conv_unit = 0.000254; /* unites = mm */ // if(IF_DRILL_METRIC) conv_unit = 0.000254; /* unites = mm */
File_Place_Offset = m_Auxiliary_Axis_Position; File_Place_Offset = m_Auxiliary_Axis_Position;
@ -61,11 +62,15 @@ FILE * LayerCu = NULL, *LayerCmp = NULL;
NbMod = 0; Module = m_Pcb->m_Modules; NbMod = 0; Module = m_Pcb->m_Modules;
for( ; Module != NULL; Module = (MODULE*) Module->Pnext ) for( ; Module != NULL; Module = (MODULE*) Module->Pnext )
{ {
if( Module->m_Attributs & MOD_VIRTUAL ) continue; if( Module->m_Attributs & MOD_VIRTUAL )
if( (Module->m_Attributs & MOD_CMS) == 0 ) continue; continue;
if( Module->m_Layer == CUIVRE_N) GenCu = TRUE; if( (Module->m_Attributs & MOD_CMS) == 0 )
continue;
if( Module->GetLayer() == CUIVRE_N )
GenCu = TRUE;
NbMod++; NbMod++;
} }
if( NbMod == 0 ) if( NbMod == 0 )
{ {
DisplayError( this, _( "No Modules for Automated Placement" ), 20 ); return; DisplayError( this, _( "No Modules for Automated Placement" ), 20 ); return;
@ -117,8 +122,10 @@ FILE * LayerCu = NULL, *LayerCmp = NULL;
Module = (MODULE*) m_Pcb->m_Modules; Module = (MODULE*) m_Pcb->m_Modules;
for( ii = 0; Module != NULL; Module = Module->Next() ) for( ii = 0; Module != NULL; Module = Module->Next() )
{ {
if( Module->m_Attributs & MOD_VIRTUAL ) continue; if( Module->m_Attributs & MOD_VIRTUAL )
if( (Module->m_Attributs & MOD_CMS) == 0 ) continue; continue;
if( (Module->m_Attributs & MOD_CMS) == 0 )
continue;
Liste[ii].m_Module = Module; Liste[ii].m_Module = Module;
Liste[ii].m_Reference = Module->m_Reference->m_Text; Liste[ii].m_Reference = Module->m_Reference->m_Text;
@ -134,16 +141,19 @@ FILE * LayerCu = NULL, *LayerCmp = NULL;
sprintf( Line, "### Module positions - created on %s ###\n", sprintf( Line, "### Module positions - created on %s ###\n",
DateAndTime( Buff ) ); DateAndTime( Buff ) );
fputs( Line, LayerCmp ); fputs( Line, LayerCmp );
if( GenCu ) fputs(Line,LayerCu); if( GenCu )
fputs( Line, LayerCu );
wxString Title = g_Main_Title + wxT( " " ) + GetBuildVersion(); wxString Title = g_Main_Title + wxT( " " ) + GetBuildVersion();
sprintf( Line, "### Printed by PcbNew version %s\n", CONV_TO_UTF8( Title ) ); sprintf( Line, "### Printed by PcbNew version %s\n", CONV_TO_UTF8( Title ) );
fputs( Line, LayerCmp ); fputs( Line, LayerCmp );
if( GenCu ) fputs(Line,LayerCu); if( GenCu )
fputs( Line, LayerCu );
sprintf( Line, "## Unit = inches, Angle = deg.\n" ); sprintf( Line, "## Unit = inches, Angle = deg.\n" );
fputs( Line, LayerCmp ); fputs( Line, LayerCmp );
if( GenCu ) fputs(Line,LayerCu); if( GenCu )
fputs( Line, LayerCu );
sprintf( Line, "## Side : Components\n" ); sprintf( Line, "## Side : Components\n" );
fputs( Line, LayerCmp ); fputs( Line, LayerCmp );
@ -157,7 +167,8 @@ FILE * LayerCu = NULL, *LayerCmp = NULL;
sprintf( Line, sprintf( Line,
"# Ref Val PosX PosY Rot Side\n" ); "# Ref Val PosX PosY Rot Side\n" );
fputs( Line, LayerCmp ); fputs( Line, LayerCmp );
if( GenCu ) fputs(Line,LayerCu); if( GenCu )
fputs( Line, LayerCu );
/* Generation lignes utiles du fichier */ /* Generation lignes utiles du fichier */
for( ii = 0; ii < NbMod; ii++ ) for( ii = 0; ii < NbMod; ii++ )
@ -177,13 +188,12 @@ FILE * LayerCu = NULL, *LayerCmp = NULL;
(float) module_pos.y * conv_unit, (float) module_pos.y * conv_unit,
(float) Liste[ii].m_Module->m_Orient / 10 ); (float) Liste[ii].m_Module->m_Orient / 10 );
if (Liste[ii].m_Module->m_Layer == CMP_N) if( Liste[ii].m_Module->GetLayer() == CMP_N )
{ {
strcat( Line, "Cmp.\n" ); strcat( Line, "Cmp.\n" );
fputs( Line, LayerCmp ); fputs( Line, LayerCmp );
} }
else if( Liste[ii].m_Module->GetLayer() == CUIVRE_N )
else if (Liste[ii].m_Module->m_Layer == CUIVRE_N)
{ {
strcat( Line, "Cu\n" ); strcat( Line, "Cu\n" );
fputs( Line, LayerCu ); fputs( Line, LayerCu );
@ -202,16 +212,17 @@ FILE * LayerCu = NULL, *LayerCmp = NULL;
setlocale( LC_NUMERIC, "" ); // revert to the current locale setlocale( LC_NUMERIC, "" ); // revert to the current locale
msg = wxT( "Cmp File: " ) + NameLayerCmp; msg = wxT( "Cmp File: " ) + NameLayerCmp;
if( GenCu ) msg += wxT("\nCu File: ") + NameLayerCu; if( GenCu )
msg += wxT( "\nCu File: " ) + NameLayerCu;
DisplayInfo( this, msg ); DisplayInfo( this, msg );
} }
/**************************************************************/ /**************************************************************/
void WinEDA_PcbFrame::GenModuleReport( wxCommandEvent& event ) void WinEDA_PcbFrame::GenModuleReport( wxCommandEvent& event )
/**************************************************************/ /**************************************************************/
/* Print a module report. /* Print a module report.
*/ */
{ {
@ -225,6 +236,7 @@ wxPoint module_pos;
/* Calcul des echelles de conversion */ /* Calcul des echelles de conversion */
conv_unit = 0.0001; /* unites = INCHES */ conv_unit = 0.0001; /* unites = INCHES */
// if(IF_DRILL_METRIC) conv_unit = 0.000254; /* unites = mm */ // if(IF_DRILL_METRIC) conv_unit = 0.000254; /* unites = mm */
File_Place_Offset = wxPoint( 0, 0 ); File_Place_Offset = wxPoint( 0, 0 );
@ -285,8 +297,10 @@ wxPoint module_pos;
fputs( Line, rptfile ); fputs( Line, rptfile );
msg = wxT( "attribut" ); msg = wxT( "attribut" );
if ( Module->m_Attributs & MOD_VIRTUAL ) msg += wxT(" virtual"); if( Module->m_Attributs & MOD_VIRTUAL )
if ( Module->m_Attributs & MOD_CMS ) msg += wxT(" smd"); msg += wxT( " virtual" );
if( Module->m_Attributs & MOD_CMS )
msg += wxT( " smd" );
if( ( Module->m_Attributs & (MOD_VIRTUAL | MOD_CMS) ) == 0 ) if( ( Module->m_Attributs & (MOD_VIRTUAL | MOD_CMS) ) == 0 )
msg += wxT( " none" ); msg += wxT( " none" );
msg += wxT( "\n" ); msg += wxT( "\n" );
@ -301,9 +315,12 @@ wxPoint module_pos;
fputs( Line, rptfile ); fputs( Line, rptfile );
sprintf( Line, "orientation %.2f\n", (float) Module->m_Orient / 10 ); sprintf( Line, "orientation %.2f\n", (float) Module->m_Orient / 10 );
if (Module->m_Layer == CMP_N) strcat(Line,"layer component\n"); if( Module->GetLayer() == CMP_N )
else if (Module->m_Layer == CUIVRE_N) strcat(Line,"layer copper\n"); strcat( Line, "layer component\n" );
else strcat(Line,"layer other\n"); else if( Module->GetLayer() == CUIVRE_N )
strcat( Line, "layer copper\n" );
else
strcat( Line, "layer other\n" );
fputs( Line, rptfile ); fputs( Line, rptfile );
Module->Write_3D_Descr( rptfile ); Module->Write_3D_Descr( rptfile );
@ -334,23 +351,28 @@ char *shape_name[6] = {"??? ","Circ","Rect","Oval","trap","spec"} ;
fputs( Line, rptfile ); fputs( Line, rptfile );
int layer = 0; int layer = 0;
if(pad->m_Masque_Layer & CUIVRE_LAYER) layer = 1; if( pad->m_Masque_Layer & CUIVRE_LAYER )
if(pad->m_Masque_Layer & CMP_LAYER) layer |= 2; layer = 1;
if( pad->m_Masque_Layer & CMP_LAYER )
layer |= 2;
char* layer_name[4] = { "??? ", "copper", "component", "all" }; char* layer_name[4] = { "??? ", "copper", "component", "all" };
sprintf( Line, "Layer %s\n", layer_name[layer] ); sprintf( Line, "Layer %s\n", layer_name[layer] );
fputs( Line, rptfile ); fputs( Line, rptfile );
fprintf( rptfile, "$EndPAD\n" ); fprintf( rptfile, "$EndPAD\n" );
} }
fprintf( rptfile,"$EndMODULE %s\n\n", (const char*) Module->m_Reference->m_Text.GetData() ); fprintf( rptfile, "$EndMODULE %s\n\n",
(const char*) Module->m_Reference->m_Text.GetData() );
} }
/* Write board Edges */ /* Write board Edges */
EDA_BaseStruct* PtStruct; EDA_BaseStruct* PtStruct;
for( PtStruct = m_Pcb->m_Drawings; PtStruct != NULL; PtStruct = PtStruct->Pnext ) for( PtStruct = m_Pcb->m_Drawings; PtStruct != NULL; PtStruct = PtStruct->Pnext )
{ {
if( PtStruct->m_StructType != TYPEDRAWSEGMENT ) continue; if( PtStruct->m_StructType != TYPEDRAWSEGMENT )
if( ((DRAWSEGMENT *) PtStruct)->m_Layer != EDGE_N ) continue; continue;
if( ( (DRAWSEGMENT*) PtStruct )->GetLayer() != EDGE_N )
continue;
WriteDrawSegmentPcb( (DRAWSEGMENT*) PtStruct, rptfile ); WriteDrawSegmentPcb( (DRAWSEGMENT*) PtStruct, rptfile );
} }
@ -364,11 +386,12 @@ EDA_BaseStruct * PtStruct;
/*******************************************************************/ /*******************************************************************/
void WriteDrawSegmentPcb( DRAWSEGMENT* PtDrawSegment, FILE* rptfile ) void WriteDrawSegmentPcb( DRAWSEGMENT* PtDrawSegment, FILE* rptfile )
/*******************************************************************/ /*******************************************************************/
/* Sortie dsur rptfile d'un segment type drawing PCB: /* Sortie dsur rptfile d'un segment type drawing PCB:
Les contours sont de differents type: * Les contours sont de differents type:
segment * segment
cercle * cercle
arc * arc
*/ */
{ {
double conv_unit, ux0, uy0, dx, dy; double conv_unit, ux0, uy0, dx, dy;
@ -402,7 +425,11 @@ char Line[1024];
{ {
int endx = PtDrawSegment->m_End.x, endy = PtDrawSegment->m_End.y; int endx = PtDrawSegment->m_End.x, endy = PtDrawSegment->m_End.y;
rayon = hypot( dx - ux0, dy - uy0 ); rayon = hypot( dx - ux0, dy - uy0 );
RotatePoint(&endx, &endy, PtDrawSegment->m_Start.x, PtDrawSegment->m_Start.y,PtDrawSegment->m_Angle); RotatePoint( &endx,
&endy,
PtDrawSegment->m_Start.x,
PtDrawSegment->m_Start.y,
PtDrawSegment->m_Angle );
sprintf( Line, "$ARC \n" ); fputs( Line, rptfile ); sprintf( Line, "$ARC \n" ); fputs( Line, rptfile );
sprintf( Line, "centre %.6lf %.6lf\n", ux0, uy0 ); sprintf( Line, "centre %.6lf %.6lf\n", ux0, uy0 );
sprintf( Line, "start %.6lf %.6lf\n", endx * conv_unit, endy * conv_unit ); sprintf( Line, "start %.6lf %.6lf\n", endx * conv_unit, endy * conv_unit );
@ -424,4 +451,3 @@ char Line[1024];
break; break;
} }
} }

6
pcbnew/gen_self.h
View File

@ -245,7 +245,7 @@ MODULE* WinEDA_PcbFrame::Genere_Self( wxDC* DC )
Mself.m_Size.x = Mself.m_Size.y / 2; Mself.m_Size.x = Mself.m_Size.y / 2;
// Choix d'une Valeur de depart raisonnable pour le rayon des arcs de cercle // Choix d'une Valeur de depart raisonnable pour le rayon des arcs de cercle
Mself.rayon = min( Mself.m_Width * 5, Mself.m_Size.x / 4 ); Mself.rayon = MIN( Mself.m_Width * 5, Mself.m_Size.x / 4 );
/* Calcul des parametres */ /* Calcul des parametres */
for( Mself.nbrin = 2; ; Mself.nbrin++ ) for( Mself.nbrin = 2; ; Mself.nbrin++ )
@ -307,7 +307,7 @@ MODULE* WinEDA_PcbFrame::Genere_Self( wxDC* DC )
PtSegm->m_End.x = Mself.m_Start.x; PtSegm->m_End.x = Mself.m_Start.x;
PtSegm->m_End.y = PtSegm->m_Start.y + Mself.delta; PtSegm->m_End.y = PtSegm->m_Start.y + Mself.delta;
PtSegm->m_Width = Mself.m_Width; PtSegm->m_Width = Mself.m_Width;
PtSegm->m_Layer = Module->m_Layer; PtSegm->SetLayer( Module->GetLayer() );
PtSegm->m_Shape = S_SEGMENT; PtSegm->m_Shape = S_SEGMENT;
newedge = new EDGE_MODULE( Module ); newedge = new EDGE_MODULE( Module );
@ -432,7 +432,7 @@ MODULE* WinEDA_PcbFrame::Genere_Self( wxDC* DC )
PtPad->m_Pos0.x = PtPad->m_Pos.x - Module->m_Pos.x; PtPad->m_Pos0.x = PtPad->m_Pos.x - Module->m_Pos.x;
PtPad->m_Pos0.y = PtPad->m_Pos.y - Module->m_Pos.y; PtPad->m_Pos0.y = PtPad->m_Pos.y - Module->m_Pos.y;
PtPad->m_Size.x = PtPad->m_Size.y = LastSegm->m_Width; PtPad->m_Size.x = PtPad->m_Size.y = LastSegm->m_Width;
PtPad->m_Masque_Layer = g_TabOneLayerMask[LastSegm->m_Layer]; PtPad->m_Masque_Layer = g_TabOneLayerMask[LastSegm->GetLayer()];
PtPad->m_Attribut = SMD; PtPad->m_Attribut = SMD;
PtPad->m_PadShape = CIRCLE; PtPad->m_PadShape = CIRCLE;
PtPad->m_Rayon = PtPad->m_Size.x / 2; PtPad->m_Rayon = PtPad->m_Size.x / 2;

2
pcbnew/gendrill.cpp
View File

@ -915,7 +915,7 @@ wxString msg;
float Xscale = (float) (SheetSize.x - (marge*2)) / dX; float Xscale = (float) (SheetSize.x - (marge*2)) / dX;
float Yscale = (float) (SheetSize.y * 0.6 - (marge*2)) / dY; float Yscale = (float) (SheetSize.y * 0.6 - (marge*2)) / dY;
scale_x = scale_y = min(Xscale, Yscale); scale_x = scale_y = MIN(Xscale, Yscale);
g_PlotOffset.x = - (SheetSize.x/2) + g_PlotOffset.x = - (SheetSize.x/2) +
(int)(BoardCentre.x * scale_x) + marge; (int)(BoardCentre.x * scale_x) + marge;

479
pcbnew/graphpcb.cpp
View File

@ -35,26 +35,30 @@ void TraceArc(int ux0,int uy0,int ux1,int uy1,int ArcAngle, int lg,int layer,
#define OP_CELL( layer, dy, dx ) { if( layer < 0 ) \ #define OP_CELL( layer, dy, dx ) { if( layer < 0 ) \
{ \ { \
WriteCell( dy, dx, BOTTOM, color ); \ WriteCell( dy, dx, BOTTOM, color ); \
if(Nb_Sides) WriteCell(dy,dx,TOP,color);\ if( Nb_Sides ) \
WriteCell( dy, dx, TOP, color );\
} \ } \
else { \ else { \
if(layer == Route_Layer_BOTTOM) WriteCell(dy,dx,BOTTOM,color);\ if( layer == Route_Layer_BOTTOM ) \
WriteCell( dy, dx, BOTTOM, color );\
if( Nb_Sides ) \ if( Nb_Sides ) \
if(layer == Route_Layer_TOP) WriteCell(dy,dx,TOP,color);\ if( layer == Route_Layer_TOP ) \
WriteCell( dy, dx, TOP, color );\
} } } }
/******************************************************************************/ /******************************************************************************/
void Place_1_Pad_Board( BOARD* Pcb, D_PAD* pt_pad, int color, int marge, int op_logique ) void Place_1_Pad_Board( BOARD* Pcb, D_PAD* pt_pad, int color, int marge, int op_logique )
/******************************************************************************/ /******************************************************************************/
/* Initialise a la valeur color, les cellules du Board comprises dans la /* Initialise a la valeur color, les cellules du Board comprises dans la
surface du pad pointe par pt_pad, avec la marge reservee pour l'isolement * surface du pad pointe par pt_pad, avec la marge reservee pour l'isolement
et la demi largeur de la piste * et la demi largeur de la piste
Parametres: * Parametres:
pt_pad : pointeur sur la description du pad * pt_pad : pointeur sur la description du pad
color : masque a ecrire dans les cellules * color : masque a ecrire dans les cellules
marge : valeur a ajouter au rayon ou demi cote du pad * marge : valeur a ajouter au rayon ou demi cote du pad
op_logique: type d'ecriture dans la cellule ( WRITE, OR ) * op_logique: type d'ecriture dans la cellule ( WRITE, OR )
*/ */
{ {
int dx, dy; int dx, dy;
@ -80,7 +84,6 @@ wxPoint shape_pos = pt_pad->ReturnShapePos();;
if( (pt_pad->m_Orient % 900) == 0 ) if( (pt_pad->m_Orient % 900) == 0 )
{ /* Le pad est un rectangle horizontal ou vertical */ { /* Le pad est un rectangle horizontal ou vertical */
if( (pt_pad->m_Orient == 900 ) || (pt_pad->m_Orient == 2700) ) if( (pt_pad->m_Orient == 900 ) || (pt_pad->m_Orient == 2700) )
{ /* orient tournee de 90 deg */ { /* orient tournee de 90 deg */
EXCHG( dx, dy ); EXCHG( dx, dy );
@ -90,7 +93,6 @@ wxPoint shape_pos = pt_pad->ReturnShapePos();;
shape_pos.x + dx, shape_pos.y + dy, shape_pos.x + dx, shape_pos.y + dy,
pt_pad->m_Masque_Layer, color, op_logique ); pt_pad->m_Masque_Layer, color, op_logique );
} }
else else
{ {
TraceFilledRectangle( Pcb, shape_pos.x - dx, shape_pos.y - dy, TraceFilledRectangle( Pcb, shape_pos.x - dx, shape_pos.y - dy,
@ -105,13 +107,14 @@ wxPoint shape_pos = pt_pad->ReturnShapePos();;
void TraceFilledCercle( BOARD* Pcb, int cx, int cy, int rayon, int masque_layer, void TraceFilledCercle( BOARD* Pcb, int cx, int cy, int rayon, int masque_layer,
int color, int op_logique ) int color, int op_logique )
/************************************************************************/ /************************************************************************/
/* Initialise a la valeur color, les cellules du Board comprises dans la /* Initialise a la valeur color, les cellules du Board comprises dans la
surface du cercle de centre cx,cy. * surface du cercle de centre cx,cy.
Parametres: * Parametres:
rayon : valeur a ajouter au rayon ou demi cote du pad * rayon : valeur a ajouter au rayon ou demi cote du pad
masque_layer = couches occupees * masque_layer = couches occupees
color : masque a ecrire dans les cellules * color : masque a ecrire dans les cellules
op_logique: type d'ecriture dans la cellule ( WRITE, OR ) * op_logique: type d'ecriture dans la cellule ( WRITE, OR )
*/ */
{ {
int row, col; int row, col;
@ -119,6 +122,7 @@ int ux0 , uy0 , ux1, uy1;
int row_max, col_max, row_min, col_min; int row_max, col_max, row_min, col_min;
int trace = 0; int trace = 0;
float fdistmin, fdistx, fdisty; float fdistmin, fdistx, fdisty;
void (*WriteCell)( int, int, int, BoardCell ); void (*WriteCell)( int, int, int, BoardCell );
int tstwrite = 0; int tstwrite = 0;
int distmin; int distmin;
@ -126,7 +130,7 @@ int distmin;
/* Determination des couches occupees : */ /* Determination des couches occupees : */
/* routage sur 1 seule couche: /* routage sur 1 seule couche:
sur bitmap BOTTOM et Route_Layer_B = Route_Layer_A*/ * sur bitmap BOTTOM et Route_Layer_B = Route_Layer_A*/
if( masque_layer & g_TabOneLayerMask[Route_Layer_BOTTOM] ) if( masque_layer & g_TabOneLayerMask[Route_Layer_BOTTOM] )
trace = 1; /* Trace sur BOTTOM */ trace = 1; /* Trace sur BOTTOM */
@ -135,16 +139,26 @@ int distmin;
if( Nb_Sides ) if( Nb_Sides )
trace |= 2;/* Trace sur TOP */ trace |= 2;/* Trace sur TOP */
if( trace == 0) return; if( trace == 0 )
return;
switch( op_logique ) switch( op_logique )
{ {
default: default:
case WRITE_CELL: WriteCell = SetCell; break; case WRITE_CELL:
case WRITE_OR_CELL: WriteCell = OrCell; break; WriteCell = SetCell; break;
case WRITE_XOR_CELL: WriteCell = XorCell; break;
case WRITE_AND_CELL: WriteCell = AndCell; break; case WRITE_OR_CELL:
case WRITE_ADD_CELL: WriteCell = AddCell; break; WriteCell = OrCell; break;
case WRITE_XOR_CELL:
WriteCell = XorCell; break;
case WRITE_AND_CELL:
WriteCell = AndCell; break;
case WRITE_ADD_CELL:
WriteCell = AddCell; break;
} }
cx -= Pcb->m_BoundaryBox.m_Pos.x; cy -= Pcb->m_BoundaryBox.m_Pos.y; cx -= Pcb->m_BoundaryBox.m_Pos.x; cy -= Pcb->m_BoundaryBox.m_Pos.y;
@ -161,14 +175,20 @@ int distmin;
row_min = uy0 / g_GridRoutingSize; // if (uy0 > row_min*g_GridRoutingSize ) row_min++; row_min = uy0 / g_GridRoutingSize; // if (uy0 > row_min*g_GridRoutingSize ) row_min++;
col_min = ux0 / g_GridRoutingSize; // if (ux0 > col_min*g_GridRoutingSize ) col_min++; col_min = ux0 / g_GridRoutingSize; // if (ux0 > col_min*g_GridRoutingSize ) col_min++;
if( row_min < 0 ) row_min = 0; if( row_min < 0 )
if( row_max >= (Nrows-1)) row_max = Nrows-1; row_min = 0;
if( col_min < 0 ) col_min = 0; if( row_max >= (Nrows - 1) )
if( col_max >= (Ncols-1)) col_max = Ncols-1; row_max = Nrows - 1;
if( col_min < 0 )
col_min = 0;
if( col_max >= (Ncols - 1) )
col_max = Ncols - 1;
/* On s'assure que l'on place toujours au moins une cellule */ /* On s'assure que l'on place toujours au moins une cellule */
if( row_min > row_max ) row_max = row_min; if( row_min > row_max )
if( col_min > col_max ) col_max = col_min; row_max = row_min;
if( col_min > col_max )
col_max = col_min;
fdistmin = (float) distmin * distmin; fdistmin = (float) distmin * distmin;
@ -181,18 +201,22 @@ int distmin;
fdistx = (float) ( cx - (col * g_GridRoutingSize) ); fdistx = (float) ( cx - (col * g_GridRoutingSize) );
fdistx *= fdistx; fdistx *= fdistx;
if( fdistmin <= (fdistx + fdisty) ) continue; if( fdistmin <= (fdistx + fdisty) )
continue;
if(trace & 1) WriteCell(row,col,BOTTOM,color); if( trace & 1 )
if(trace & 2) WriteCell(row,col,TOP,color); WriteCell( row, col, BOTTOM, color );
if( trace & 2 )
WriteCell( row, col, TOP, color );
tstwrite = 1; tstwrite = 1;
} }
} }
if (tstwrite) return; if( tstwrite )
return;
/* Si aucune cellule n'a ete ecrite, on touche les 4 voisins diagonaux /* Si aucune cellule n'a ete ecrite, on touche les 4 voisins diagonaux
(cas defavorable: pad hors grille, au centre des 4 voisins diagonaux) */ * (cas defavorable: pad hors grille, au centre des 4 voisins diagonaux) */
distmin = g_GridRoutingSize / 2 + 1; distmin = g_GridRoutingSize / 2 + 1;
fdistmin = ( (float) distmin * distmin ) * 2; /* = dist centre au point diagonal*/ fdistmin = ( (float) distmin * distmin ) * 2; /* = dist centre au point diagonal*/
@ -206,25 +230,28 @@ if (tstwrite) return;
fdistx = (float) ( cx - (col * g_GridRoutingSize) ); fdistx = (float) ( cx - (col * g_GridRoutingSize) );
fdistx *= fdistx; fdistx *= fdistx;
if( fdistmin <= (fdistx + fdisty) ) continue; if( fdistmin <= (fdistx + fdisty) )
continue;
if(trace & 1) WriteCell(row,col,BOTTOM,color); if( trace & 1 )
if(trace & 2) WriteCell(row,col,TOP,color); WriteCell( row, col, BOTTOM, color );
if( trace & 2 )
WriteCell( row, col, TOP, color );
} }
} }
} }
/******************************************************************************/ /******************************************************************************/
void TraceSegmentPcb( BOARD* Pcb, TRACK* pt_segm, int color, int marge, int op_logique ) void TraceSegmentPcb( BOARD* Pcb, TRACK* pt_segm, int color, int marge, int op_logique )
/******************************************************************************/ /******************************************************************************/
/* trace un Segment de piste sur le BOARD de routage /* trace un Segment de piste sur le BOARD de routage
*/ */
{ {
int demi_pas, demi_largeur; int demi_pas, demi_largeur;
int ux0, uy0, ux1, uy1; int ux0, uy0, ux1, uy1;
int layer = pt_segm->m_Layer; int layer = pt_segm->GetLayer();
demi_pas = g_GridRoutingSize / 2; demi_pas = g_GridRoutingSize / 2;
@ -235,7 +262,8 @@ int layer = pt_segm->m_Layer;
ux1 = pt_segm->m_End.x - Pcb->m_BoundaryBox.m_Pos.x; ux1 = pt_segm->m_End.x - Pcb->m_BoundaryBox.m_Pos.x;
uy1 = pt_segm->m_End.y - Pcb->m_BoundaryBox.m_Pos.y; uy1 = pt_segm->m_End.y - Pcb->m_BoundaryBox.m_Pos.y;
if ( color == VIA_IMPOSSIBLE ) layer = -1; if( color == VIA_IMPOSSIBLE )
layer = -1;
/* Test si VIA (cercle plein a tracer) */ /* Test si VIA (cercle plein a tracer) */
if( pt_segm->m_StructType == TYPEVIA ) if( pt_segm->m_StructType == TYPEVIA )
@ -269,75 +297,99 @@ int layer = pt_segm->m_Layer;
// DrawHVSegment(ux0,uy0,ux1,uy1,demi_largeur,layer,color,op_logique); //F4EXB 051018-01 // DrawHVSegment(ux0,uy0,ux1,uy1,demi_largeur,layer,color,op_logique); //F4EXB 051018-01
DrawSegmentQcq( ux0, uy0, ux1, uy1, demi_largeur, layer, color, op_logique ); //F4EXB 051018-01 DrawSegmentQcq( ux0, uy0, ux1, uy1, demi_largeur, layer, color, op_logique ); //F4EXB 051018-01
return; //F4EXB 051018-01 return; //F4EXB 051018-01
} }
/******************************************************************************************/ /******************************************************************************************/
void TraceLignePcb( int x0, int y0, int x1, int y1, int layer, int color, int op_logique ) void TraceLignePcb( int x0, int y0, int x1, int y1, int layer, int color, int op_logique )
/******************************************************************************************/ /******************************************************************************************/
/* trace une ligne; si layer = -1 sur toutes les couches /* trace une ligne; si layer = -1 sur toutes les couches
*/ */
{ {
int dx, dy, lim; int dx, dy, lim;
int cumul, inc, il, delta; int cumul, inc, il, delta;
void (*WriteCell)( int, int, int, BoardCell ); void (*WriteCell)( int, int, int, BoardCell );
switch( op_logique ) switch( op_logique )
{ {
default: default:
case WRITE_CELL: WriteCell = SetCell; break; case WRITE_CELL:
case WRITE_OR_CELL: WriteCell = OrCell; break; WriteCell = SetCell; break;
case WRITE_XOR_CELL: WriteCell = XorCell; break;
case WRITE_AND_CELL: WriteCell = AndCell; break; case WRITE_OR_CELL:
case WRITE_ADD_CELL: WriteCell = AddCell; break; WriteCell = OrCell; break;
case WRITE_XOR_CELL:
WriteCell = XorCell; break;
case WRITE_AND_CELL:
WriteCell = AndCell; break;
case WRITE_ADD_CELL:
WriteCell = AddCell; break;
} }
if( x0 == x1 ) // ligne verticale if( x0 == x1 ) // ligne verticale
{ {
if(y1 < y0 ) EXCHG (y0,y1); if( y1 < y0 )
EXCHG( y0, y1 );
dy = y0 / g_GridRoutingSize; lim = y1 / g_GridRoutingSize; dy = y0 / g_GridRoutingSize; lim = y1 / g_GridRoutingSize;
dx = x0 / g_GridRoutingSize; dx = x0 / g_GridRoutingSize;
/* Clipping aux limites du board */ /* Clipping aux limites du board */
if( (dx < 0) || (dx >= Ncols) ) return; if( (dx < 0) || (dx >= Ncols) )
if( dy < 0 ) dy = 0; return;
if( lim >= Nrows ) lim = Nrows-1; if( dy < 0 )
dy = 0;
if( lim >= Nrows )
lim = Nrows - 1;
for( ; dy <= lim; dy++ ) for( ; dy <= lim; dy++ )
{ {
OP_CELL( layer, dy, dx ); OP_CELL( layer, dy, dx );
} }
return; return;
} }
if( y0 == y1 ) // ligne horizontale if( y0 == y1 ) // ligne horizontale
{ {
if(x1 < x0 ) EXCHG (x0,x1); if( x1 < x0 )
EXCHG( x0, x1 );
dx = x0 / g_GridRoutingSize; lim = x1 / g_GridRoutingSize; dx = x0 / g_GridRoutingSize; lim = x1 / g_GridRoutingSize;
dy = y0 / g_GridRoutingSize; dy = y0 / g_GridRoutingSize;
/* Clipping aux limites du board */ /* Clipping aux limites du board */
if( (dy < 0) || (dy >= Nrows) ) return; if( (dy < 0) || (dy >= Nrows) )
if( dx < 0 ) dx = 0; return;
if( lim >= Ncols ) lim = Ncols-1; if( dx < 0 )
dx = 0;
if( lim >= Ncols )
lim = Ncols - 1;
for( ; dx <= lim; dx++ ) for( ; dx <= lim; dx++ )
{ {
OP_CELL( layer, dy, dx ); OP_CELL( layer, dy, dx );
} }
return; return;
} }
/* Ici l'angle est quelconque: on utilise l'algorithme de LUCAS */ /* Ici l'angle est quelconque: on utilise l'algorithme de LUCAS */
if( abs( x1 - x0 ) >= abs( y1 - y0 ) ) /* segment peu incline */ if( abs( x1 - x0 ) >= abs( y1 - y0 ) ) /* segment peu incline */
{ {
if(x1 < x0) {EXCHG(x1,x0); EXCHG(y1,y0) ;} if( x1 < x0 )
{
EXCHG( x1, x0 ); EXCHG( y1, y0 );
}
dx = x0 / g_GridRoutingSize; lim = x1 / g_GridRoutingSize; dx = x0 / g_GridRoutingSize; lim = x1 / g_GridRoutingSize;
dy = y0 / g_GridRoutingSize; dy = y0 / g_GridRoutingSize;
inc = 1; if( y1 < y0) inc = -1; inc = 1; if( y1 < y0 )
inc = -1;
il = lim - dx; cumul = il / 2; delta = abs( y1 - y0 ) / g_GridRoutingSize; il = lim - dx; cumul = il / 2; delta = abs( y1 - y0 ) / g_GridRoutingSize;
for( ; dx <= lim; ) for( ; dx <= lim; )
{ {
if( (dx >= 0) && (dy >= 0) && if( (dx >= 0) && (dy >= 0)
(dx < Ncols) && (dy < Nrows) ) && (dx < Ncols) && (dy < Nrows) )
{ {
OP_CELL( layer, dy, dx ); OP_CELL( layer, dy, dx );
} }
@ -350,16 +402,20 @@ void (*WriteCell)(int,int,int,BoardCell);
} }
else else
{ {
if(y1 < y0) {EXCHG(x1,x0); EXCHG(y1,y0) ;} if( y1 < y0 )
{
EXCHG( x1, x0 ); EXCHG( y1, y0 );
}
dy = y0 / g_GridRoutingSize; lim = y1 / g_GridRoutingSize; dy = y0 / g_GridRoutingSize; lim = y1 / g_GridRoutingSize;
dx = x0 / g_GridRoutingSize; dx = x0 / g_GridRoutingSize;
inc = 1; if( x1 < x0) inc = -1; inc = 1; if( x1 < x0 )
inc = -1;
il = lim - dy; cumul = il / 2; delta = abs( x1 - x0 ) / g_GridRoutingSize; il = lim - dy; cumul = il / 2; delta = abs( x1 - x0 ) / g_GridRoutingSize;
for( ; dy <= lim; ) for( ; dy <= lim; )
{ {
if( (dx >= 0) && (dy >= 0) && if( (dx >= 0) && (dy >= 0)
(dx < Ncols) && (dy < Nrows) ) && (dx < Ncols) && (dy < Nrows) )
{ {
OP_CELL( layer, dy, dx ); OP_CELL( layer, dy, dx );
} }
@ -372,23 +428,26 @@ void (*WriteCell)(int,int,int,BoardCell);
} }
} }
/*****************************************************************/ /*****************************************************************/
void TraceFilledRectangle( BOARD* Pcb, void TraceFilledRectangle( BOARD* Pcb,
int ux0, int uy0, int ux1, int uy1, int ux0, int uy0, int ux1, int uy1,
int masque_layer, int color, int op_logique ) int masque_layer, int color, int op_logique )
/*****************************************************************/ /*****************************************************************/
/* Fonction Surchargee.
Met a la valeur color l'ensemble des cellules du board inscrites dans /* Fonction Surchargee.
le rectangle de coord ux0,uy0 ( angle haut a gauche ) *
a ux1,uy1 ( angle bas a droite ) * Met a la valeur color l'ensemble des cellules du board inscrites dans
Le rectangle est horizontal ( ou vertical ) * le rectangle de coord ux0,uy0 ( angle haut a gauche )
Coordonnees PCB. * a ux1,uy1 ( angle bas a droite )
* Le rectangle est horizontal ( ou vertical )
* Coordonnees PCB.
*/ */
{ {
int row, col; int row, col;
int row_min, row_max, col_min, col_max; int row_min, row_max, col_min, col_max;
int trace = 0; int trace = 0;
void (*WriteCell)( int, int, int, BoardCell ); void (*WriteCell)( int, int, int, BoardCell );
if( masque_layer & g_TabOneLayerMask[Route_Layer_BOTTOM] ) if( masque_layer & g_TabOneLayerMask[Route_Layer_BOTTOM] )
@ -397,16 +456,26 @@ void (*WriteCell)(int,int,int,BoardCell);
if( (masque_layer & g_TabOneLayerMask[Route_Layer_TOP] ) && Nb_Sides ) if( (masque_layer & g_TabOneLayerMask[Route_Layer_TOP] ) && Nb_Sides )
trace |= 2; /* Trace sur TOP */ trace |= 2; /* Trace sur TOP */
if(trace == 0) return; if( trace == 0 )
return;
switch( op_logique ) switch( op_logique )
{ {
default: default:
case WRITE_CELL: WriteCell = SetCell; break; case WRITE_CELL:
case WRITE_OR_CELL: WriteCell = OrCell; break; WriteCell = SetCell; break;
case WRITE_XOR_CELL: WriteCell = XorCell; break;
case WRITE_AND_CELL: WriteCell = AndCell; break; case WRITE_OR_CELL:
case WRITE_ADD_CELL: WriteCell = AddCell; break; WriteCell = OrCell; break;
case WRITE_XOR_CELL:
WriteCell = XorCell; break;
case WRITE_AND_CELL:
WriteCell = AndCell; break;
case WRITE_ADD_CELL:
WriteCell = AddCell; break;
} }
ux0 -= Pcb->m_BoundaryBox.m_Pos.x; uy0 -= Pcb->m_BoundaryBox.m_Pos.y; ux0 -= Pcb->m_BoundaryBox.m_Pos.x; uy0 -= Pcb->m_BoundaryBox.m_Pos.y;
@ -415,20 +484,28 @@ void (*WriteCell)(int,int,int,BoardCell);
/* Calcul des coord limites des cellules appartenant au rectangle */ /* Calcul des coord limites des cellules appartenant au rectangle */
row_max = uy1 / g_GridRoutingSize; row_max = uy1 / g_GridRoutingSize;
col_max = ux1 / g_GridRoutingSize; col_max = ux1 / g_GridRoutingSize;
row_min = uy0 / g_GridRoutingSize; if (uy0 > row_min*g_GridRoutingSize ) row_min++; row_min = uy0 / g_GridRoutingSize; if( uy0 > row_min * g_GridRoutingSize )
col_min = ux0 / g_GridRoutingSize; if (ux0 > col_min*g_GridRoutingSize ) col_min++; row_min++;
col_min = ux0 / g_GridRoutingSize; if( ux0 > col_min * g_GridRoutingSize )
col_min++;
if( row_min < 0 ) row_min = 0; if( row_min < 0 )
if( row_max >= (Nrows-1)) row_max = Nrows-1; row_min = 0;
if( col_min < 0 ) col_min = 0; if( row_max >= (Nrows - 1) )
if( col_max >= (Ncols-1)) col_max = Ncols-1; row_max = Nrows - 1;
if( col_min < 0 )
col_min = 0;
if( col_max >= (Ncols - 1) )
col_max = Ncols - 1;
for( row = row_min; row <= row_max; row++ ) for( row = row_min; row <= row_max; row++ )
{ {
for( col = col_min; col <= col_max; col++ ) for( col = col_min; col <= col_max; col++ )
{ {
if(trace & 1) WriteCell(row,col,BOTTOM,color); if( trace & 1 )
if(trace & 2) WriteCell(row,col,TOP,color); WriteCell( row, col, BOTTOM, color );
if( trace & 2 )
WriteCell( row, col, TOP, color );
} }
} }
} }
@ -440,12 +517,12 @@ void TraceFilledRectangle(BOARD * Pcb, int ux0, int uy0, int ux1, int uy1, int a
/***********************************************************************************/ /***********************************************************************************/
/* Fonction Surchargee. /* Fonction Surchargee.
*
Met a la valeur color l'ensemble des cellules du board inscrites dans * Met a la valeur color l'ensemble des cellules du board inscrites dans
le rectangle de coord ux0,uy0 ( angle haut a droite ) * le rectangle de coord ux0,uy0 ( angle haut a droite )
a ux1,uy1 ( angle bas a gauche ) * a ux1,uy1 ( angle bas a gauche )
Le rectangle est tourne de la valeur angle (en 0,1 degres) * Le rectangle est tourne de la valeur angle (en 0,1 degres)
Coordonnees PCB. * Coordonnees PCB.
*/ */
{ {
int row, col; int row, col;
@ -454,6 +531,7 @@ int rayon; /* rayon du cercle exinscrit */
int row_min, row_max, col_min, col_max; int row_min, row_max, col_min, col_max;
int rotrow, rotcol; int rotrow, rotcol;
int trace = 0; int trace = 0;
void (*WriteCell)( int, int, int, BoardCell ); void (*WriteCell)( int, int, int, BoardCell );
if( masque_layer & g_TabOneLayerMask[Route_Layer_BOTTOM] ) if( masque_layer & g_TabOneLayerMask[Route_Layer_BOTTOM] )
@ -463,16 +541,26 @@ void (*WriteCell)(int,int,int,BoardCell);
if( Nb_Sides ) if( Nb_Sides )
trace |= 2;/* Trace sur TOP */ trace |= 2;/* Trace sur TOP */
if(trace == 0) return; if( trace == 0 )
return;
switch( op_logique ) switch( op_logique )
{ {
default: default:
case WRITE_CELL: WriteCell = SetCell; break; case WRITE_CELL:
case WRITE_OR_CELL: WriteCell = OrCell; break; WriteCell = SetCell; break;
case WRITE_XOR_CELL: WriteCell = XorCell; break;
case WRITE_AND_CELL: WriteCell = AndCell; break; case WRITE_OR_CELL:
case WRITE_ADD_CELL: WriteCell = AddCell; break; WriteCell = OrCell; break;
case WRITE_XOR_CELL:
WriteCell = XorCell; break;
case WRITE_AND_CELL:
WriteCell = AndCell; break;
case WRITE_ADD_CELL:
WriteCell = AddCell; break;
} }
ux0 -= Pcb->m_BoundaryBox.m_Pos.x; uy0 -= Pcb->m_BoundaryBox.m_Pos.y; ux0 -= Pcb->m_BoundaryBox.m_Pos.x; uy0 -= Pcb->m_BoundaryBox.m_Pos.y;
@ -485,13 +573,19 @@ void (*WriteCell)(int,int,int,BoardCell);
/* Calcul des coord limites des cellules appartenant au rectangle */ /* Calcul des coord limites des cellules appartenant au rectangle */
row_max = (cy + rayon) / g_GridRoutingSize; row_max = (cy + rayon) / g_GridRoutingSize;
col_max = (cx + rayon) / g_GridRoutingSize; col_max = (cx + rayon) / g_GridRoutingSize;
row_min = (cy - rayon) / g_GridRoutingSize; if (uy0 > row_min*g_GridRoutingSize ) row_min++; row_min = (cy - rayon) / g_GridRoutingSize; if( uy0 > row_min * g_GridRoutingSize )
col_min = (cx - rayon) / g_GridRoutingSize; if (ux0 > col_min*g_GridRoutingSize ) col_min++; row_min++;
col_min = (cx - rayon) / g_GridRoutingSize; if( ux0 > col_min * g_GridRoutingSize )
col_min++;
if( row_min < 0 ) row_min = 0; if( row_min < 0 )
if( row_max >= (Nrows-1)) row_max = Nrows-1; row_min = 0;
if( col_min < 0 ) col_min = 0; if( row_max >= (Nrows - 1) )
if( col_max >= (Ncols-1)) col_max = Ncols-1; row_max = Nrows - 1;
if( col_min < 0 )
col_min = 0;
if( col_max >= (Ncols - 1) )
col_max = Ncols - 1;
for( row = row_min; row <= row_max; row++ ) for( row = row_min; row <= row_max; row++ )
{ {
@ -499,31 +593,38 @@ void (*WriteCell)(int,int,int,BoardCell);
{ {
rotrow = row * g_GridRoutingSize; rotcol = col * g_GridRoutingSize; rotrow = row * g_GridRoutingSize; rotcol = col * g_GridRoutingSize;
RotatePoint( &rotcol, &rotrow, cx, cy, -angle ); RotatePoint( &rotcol, &rotrow, cx, cy, -angle );
if( rotrow <= uy0 ) continue; if( rotrow <= uy0 )
if( rotrow >= uy1 ) continue; continue;
if( rotcol <= ux0 ) continue; if( rotrow >= uy1 )
if( rotcol >= ux1 ) continue; continue;
if(trace & 1) WriteCell(row,col,BOTTOM,color); if( rotcol <= ux0 )
if(trace & 2) WriteCell(row,col,TOP,color); continue;
if( rotcol >= ux1 )
continue;
if( trace & 1 )
WriteCell( row, col, BOTTOM, color );
if( trace & 2 )
WriteCell( row, col, TOP, color );
} }
} }
} }
/*****************************************************************/ /*****************************************************************/
void DrawSegmentQcq( int ux0, int uy0, int ux1, int uy1, int lg, int layer, void DrawSegmentQcq( int ux0, int uy0, int ux1, int uy1, int lg, int layer,
int color, int op_logique ) int color, int op_logique )
/*****************************************************************/ /*****************************************************************/
/* Remplit toutes les cellules du BOARD contenues dans le segment /* Remplit toutes les cellules du BOARD contenues dans le segment
de demi-largeur lg, org ux,y0 fin ux,y1 a la valeur color . * de demi-largeur lg, org ux,y0 fin ux,y1 a la valeur color .
coord en unites PCB (0.1 mil) relatives a l'origine pt_pcb->m_PcbBox.m_Xmin,Y du board. * coord en unites PCB (0.1 mil) relatives a l'origine pt_pcb->m_PcbBox.m_Xmin,Y du board.
*/ */
{ {
int row, col; int row, col;
int inc; int inc;
int row_max, col_max, row_min, col_min; int row_max, col_max, row_min, col_min;
int demi_pas; int demi_pas;
void (*WriteCell)( int, int, int, BoardCell ); void (*WriteCell)( int, int, int, BoardCell );
int angle; int angle;
int cx, cy, dx, dy; int cx, cy, dx, dy;
@ -531,46 +632,71 @@ int cx, cy, dx, dy;
switch( op_logique ) switch( op_logique )
{ {
default: default:
case WRITE_CELL: WriteCell = SetCell; break; case WRITE_CELL:
case WRITE_OR_CELL: WriteCell = OrCell; break; WriteCell = SetCell; break;
case WRITE_XOR_CELL: WriteCell = XorCell; break;
case WRITE_AND_CELL: WriteCell = AndCell; break; case WRITE_OR_CELL:
case WRITE_ADD_CELL: WriteCell = AddCell; break; WriteCell = OrCell; break;
case WRITE_XOR_CELL:
WriteCell = XorCell; break;
case WRITE_AND_CELL:
WriteCell = AndCell; break;
case WRITE_ADD_CELL:
WriteCell = AddCell; break;
} }
/* on rend la coordonnee ux1 tj > ux0 , pour simplifier les calculs */ /* on rend la coordonnee ux1 tj > ux0 , pour simplifier les calculs */
if( ux1 < ux0 ) { EXCHG(ux1,ux0); EXCHG(uy1,uy0);} if( ux1 < ux0 )
{
EXCHG( ux1, ux0 ); EXCHG( uy1, uy0 );
}
/* calcul de l'increment selon axe Y */ /* calcul de l'increment selon axe Y */
inc = 1; if(uy1 < uy0) inc = -1; inc = 1; if( uy1 < uy0 )
inc = -1;
/* Calcul de l'encadrement : */ /* Calcul de l'encadrement : */
demi_pas = g_GridRoutingSize / 2; demi_pas = g_GridRoutingSize / 2;
col_min = (ux0 - lg) / g_GridRoutingSize; col_min = (ux0 - lg) / g_GridRoutingSize;
if (col_min < 0 ) col_min = 0; if( col_min < 0 )
col_min = 0;
col_max = (ux1 + lg + demi_pas) / g_GridRoutingSize; col_max = (ux1 + lg + demi_pas) / g_GridRoutingSize;
if (col_max > (Ncols-1) ) col_max = Ncols-1; if( col_max > (Ncols - 1) )
col_max = Ncols - 1;
if( inc > 0 ) if( inc > 0 )
{ {
row_min = (uy0 - lg) / g_GridRoutingSize; row_min = (uy0 - lg) / g_GridRoutingSize;
row_max = (uy1 + lg + demi_pas) / g_GridRoutingSize; row_max = (uy1 + lg + demi_pas) / g_GridRoutingSize;
} }
else{ else
{
row_min = (uy1 - lg) / g_GridRoutingSize; row_min = (uy1 - lg) / g_GridRoutingSize;
row_max = (uy0 + lg + demi_pas) / g_GridRoutingSize; row_max = (uy0 + lg + demi_pas) / g_GridRoutingSize;
} }
if (row_min < 0 ) row_min = 0; if( row_min < 0 )
if (row_min > (Nrows-1) ) row_min = Nrows-1; row_min = 0;
if (row_max < 0 ) row_max = 0; if( row_min > (Nrows - 1) )
if (row_max > (Nrows-1) ) row_max = Nrows-1; row_min = Nrows - 1;
if( row_max < 0 )
row_max = 0;
if( row_max > (Nrows - 1) )
row_max = Nrows - 1;
dx = ux1 - ux0; dy = uy1 - uy0; dx = ux1 - ux0; dy = uy1 - uy0;
if (dx) angle = (int)(atan2(dy,dx) * 1800 / M_PI); if( dx )
else { angle = 900; if (dy < 0) angle = -900; } angle = (int) (atan2( dy, dx ) * 1800 / M_PI);
else
{
angle = 900; if( dy < 0 )
angle = -900;
}
RotatePoint( &dx, &dy, angle ); /* dx = longueur, dy = 0 */ RotatePoint( &dx, &dy, angle ); /* dx = longueur, dy = 0 */
for( col = col_min; col <= col_max; col++ ) for( col = col_min; col <= col_max; col++ )
@ -582,10 +708,11 @@ int cx, cy, dx, dy;
cy = (row * g_GridRoutingSize) - uy0; cy = (row * g_GridRoutingSize) - uy0;
cx = cxr; cx = cxr;
RotatePoint( &cx, &cy, angle ); RotatePoint( &cx, &cy, angle );
if( abs(cy) > lg) continue; /* Le point est trop loin sur l'axe Y */ if( abs( cy ) > lg )
continue; /* Le point est trop loin sur l'axe Y */
/* ici le point a tester est proche du segment: la position /* ici le point a tester est proche du segment: la position
selon l'axe X doit etre testee */ * selon l'axe X doit etre testee */
if( (cx >= 0) && (cx <= dx) ) if( (cx >= 0) && (cx <= dx) )
{ {
OP_CELL( layer, row, col ); OP_CELL( layer, row, col );
@ -608,31 +735,45 @@ int cx, cy, dx, dy;
} }
} }
/********************************************************************/ /********************************************************************/
void DrawHVSegment( int ux0, int uy0, int ux1, int uy1, int demi_largeur, int layer, void DrawHVSegment( int ux0, int uy0, int ux1, int uy1, int demi_largeur, int layer,
int color, int op_logique ) int color, int op_logique )
/********************************************************************/ /********************************************************************/
/* Draw a horizontal or vertical segment. /* Draw a horizontal or vertical segment.
same as DrawSegmentQcq, but faster * same as DrawSegmentQcq, but faster
*/ */
{ {
int row, col; int row, col;
int row_max, col_max, row_min, col_min; int row_max, col_max, row_min, col_min;
void (*WriteCell)( int, int, int, BoardCell ); void (*WriteCell)( int, int, int, BoardCell );
switch( op_logique ) switch( op_logique )
{ {
default: default:
case WRITE_CELL: WriteCell = SetCell; break; case WRITE_CELL:
case WRITE_OR_CELL: WriteCell = OrCell; break; WriteCell = SetCell; break;
case WRITE_XOR_CELL: WriteCell = XorCell; break;
case WRITE_AND_CELL: WriteCell = AndCell; break; case WRITE_OR_CELL:
case WRITE_ADD_CELL: WriteCell = AddCell; break; WriteCell = OrCell; break;
case WRITE_XOR_CELL:
WriteCell = XorCell; break;
case WRITE_AND_CELL:
WriteCell = AndCell; break;
case WRITE_ADD_CELL:
WriteCell = AddCell; break;
} }
// Modif des coord pour que les coord de fin soient > coord de debut // Modif des coord pour que les coord de fin soient > coord de debut
if( uy1 < uy0 ) EXCHG(uy0,uy1) ; // ceci n'est vrai que parce que if( uy1 < uy0 )
if( ux1 < ux0 ) EXCHG(ux0,ux1) ; // dx ou dy ou les 2 sonts nuls EXCHG( uy0, uy1 ); // ceci n'est vrai que parce que
if( ux1 < ux0 )
EXCHG( ux0, ux1 ); // dx ou dy ou les 2 sonts nuls
// Le segment est assimile a un rectangle. // Le segment est assimile a un rectangle.
// TODO: traiter correctement les extremites arrondies // TODO: traiter correctement les extremites arrondies
@ -640,6 +781,7 @@ void (*WriteCell)(int,int,int,BoardCell);
{ {
ux0 -= demi_largeur; ux1 += demi_largeur; ux0 -= demi_largeur; ux1 += demi_largeur;
} }
// else // Horizontal segment // else // Horizontal segment
{ {
uy0 -= demi_largeur; uy1 += demi_largeur; uy0 -= demi_largeur; uy1 += demi_largeur;
@ -650,18 +792,26 @@ void (*WriteCell)(int,int,int,BoardCell);
col_max = ux1 / g_GridRoutingSize; col_max = ux1 / g_GridRoutingSize;
row_min = uy0 / g_GridRoutingSize; row_min = uy0 / g_GridRoutingSize;
if (uy0 > row_min*g_GridRoutingSize ) row_min++; // Traitement de l'arrondi par defaut if( uy0 > row_min * g_GridRoutingSize )
row_min++; // Traitement de l'arrondi par defaut
col_min = ux0 / g_GridRoutingSize; col_min = ux0 / g_GridRoutingSize;
if (ux0 > col_min*g_GridRoutingSize ) col_min++; if( ux0 > col_min * g_GridRoutingSize )
col_min++;
if( row_min < 0 ) row_min = 0; if( row_min < 0 )
if( row_max >= (Nrows-1)) row_max = Nrows-1; row_min = 0;
if( col_min < 0 ) col_min = 0; if( row_max >= (Nrows - 1) )
if( col_max >= (Ncols-1)) col_max = Ncols-1; row_max = Nrows - 1;
if( col_min < 0 )
col_min = 0;
if( col_max >= (Ncols - 1) )
col_max = Ncols - 1;
if( row_min > row_max ) row_max = row_min; if( row_min > row_max )
if( col_min > col_max ) col_max = col_min; row_max = row_min;
if( col_min > col_max )
col_max = col_min;
for( row = row_min; row <= row_max; row++ ) for( row = row_min; row <= row_max; row++ )
{ {
@ -672,13 +822,15 @@ void (*WriteCell)(int,int,int,BoardCell);
} }
} }
/*****************************************************************/ /*****************************************************************/
void TraceCercle( int ux0, int uy0, int ux1, int uy1, int lg, int layer, void TraceCercle( int ux0, int uy0, int ux1, int uy1, int lg, int layer,
int color, int op_logique ) int color, int op_logique )
/*****************************************************************/ /*****************************************************************/
/* Remplit toutes les cellules du BOARD contenues dans le cercle /* Remplit toutes les cellules du BOARD contenues dans le cercle
de demi-largeur lg, centre ux,y0 passant par ux,y1 a la valeur color . * de demi-largeur lg, centre ux,y0 passant par ux,y1 a la valeur color .
coord en unites PCB (0.1 mil) relatives a l'origine pt_pcb->m_PcbBox.m_Xmin,Y du board. * coord en unites PCB (0.1 mil) relatives a l'origine pt_pcb->m_PcbBox.m_Xmin,Y du board.
*/ */
{ {
int rayon, nb_segm; int rayon, nb_segm;
@ -690,10 +842,13 @@ int angle;
rayon = (int) hypot( (double) (ux1 - ux0), (double) (uy1 - uy0) ); rayon = (int) hypot( (double) (ux1 - ux0), (double) (uy1 - uy0) );
x0 = x1 = rayon; y0 = y1 = 0; x0 = x1 = rayon; y0 = y1 = 0;
if( lg < 1 ) lg = 1; if( lg < 1 )
lg = 1;
nb_segm = (2 * rayon) / lg; nb_segm = (2 * rayon) / lg;
if(nb_segm < 5) nb_segm = 5; if( nb_segm < 5 )
if(nb_segm > 100) nb_segm = 100; nb_segm = 5;
if( nb_segm > 100 )
nb_segm = 100;
for( ii = 1; ii < nb_segm; ii++ ) for( ii = 1; ii < nb_segm; ii++ )
{ {
angle = (3600 * ii) / nb_segm; angle = (3600 * ii) / nb_segm;
@ -706,15 +861,16 @@ int angle;
DrawSegmentQcq( x1 + ux0, y1 + uy0, ux0 + rayon, uy0, lg, layer, color, op_logique ); DrawSegmentQcq( x1 + ux0, y1 + uy0, ux0 + rayon, uy0, lg, layer, color, op_logique );
} }
/****************************************************************************/ /****************************************************************************/
void TraceArc( int ux0, int uy0, int ux1, int uy1, int ArcAngle, int lg, int layer, void TraceArc( int ux0, int uy0, int ux1, int uy1, int ArcAngle, int lg, int layer,
int color, int op_logique ) int color, int op_logique )
/****************************************************************************/ /****************************************************************************/
/* Remplit toutes les cellules du BOARD contenues dans l'arc de "longueur" angle /* Remplit toutes les cellules du BOARD contenues dans l'arc de "longueur" angle
de demi-largeur lg, centre ux,y0 commencant en ux,y1 a la valeur color . * de demi-largeur lg, centre ux,y0 commencant en ux,y1 a la valeur color .
coord en unites PCB (0.1 mil) relatives a l'origine * coord en unites PCB (0.1 mil) relatives a l'origine
pt_pcb->m_PcbBox.m_Xmin,Y du board. * pt_pcb->m_PcbBox.m_Xmin,Y du board.
*/ */
{ {
int rayon, nb_segm; int rayon, nb_segm;
@ -729,19 +885,25 @@ int angle, StAngle;
x0 = ux1 - ux0; x0 = ux1 - ux0;
y0 = uy1 - uy0; y0 = uy1 - uy0;
StAngle = ArcTangente( uy1 - uy0, ux1 - ux0 ); StAngle = ArcTangente( uy1 - uy0, ux1 - ux0 );
if( lg < 1 ) lg = 1; if( lg < 1 )
lg = 1;
nb_segm = (2 * rayon) / lg; nb_segm = (2 * rayon) / lg;
nb_segm = ( nb_segm * abs( ArcAngle ) ) / 3600; nb_segm = ( nb_segm * abs( ArcAngle ) ) / 3600;
if(nb_segm < 5) nb_segm = 5; if( nb_segm < 5 )
if(nb_segm > 100) nb_segm = 100; nb_segm = 5;
if( nb_segm > 100 )
nb_segm = 100;
for( ii = 1; ii <= nb_segm; ii++ ) for( ii = 1; ii <= nb_segm; ii++ )
{ {
angle = (ArcAngle * ii) / nb_segm; angle = (ArcAngle * ii) / nb_segm;
angle += StAngle; angle += StAngle;
while ( angle >= 3600 ) angle -= 3600; while( angle >= 3600 )
while ( angle < 0 ) angle += 3600; angle -= 3600;
while( angle < 0 )
angle += 3600;
x1 = (int) (rayon * fcosinus[angle]); x1 = (int) (rayon * fcosinus[angle]);
y1 = (int) (rayon * fsinus[angle]); y1 = (int) (rayon * fsinus[angle]);
@ -751,4 +913,3 @@ int angle, StAngle;
// DrawSegmentQcq(x1+ux0,y1+uy0, ux0+rayon, uy0,lg,layer, color, op_logique); // DrawSegmentQcq(x1+ux0,y1+uy0, ux0+rayon, uy0,lg,layer, color, op_logique);
} }

21
pcbnew/initpcb.cpp
View File

@ -229,7 +229,8 @@ void WinEDA_PcbFrame::Erase_Zones( wxDC* DC, bool query )
void WinEDA_PcbFrame::Erase_Segments_Pcb( wxDC* DC, bool is_edges, bool query ) void WinEDA_PcbFrame::Erase_Segments_Pcb( wxDC* DC, bool is_edges, bool query )
/*****************************************************************************/ /*****************************************************************************/
{ {
EDA_BaseStruct* PtStruct, * PtNext; BOARD_ITEM* PtStruct;
BOARD_ITEM* PtNext;
int masque_layer = (~EDGE_LAYER) & 0x1FFF0000; int masque_layer = (~EDGE_LAYER) & 0x1FFF0000;
if( is_edges ) if( is_edges )
@ -244,30 +245,18 @@ void WinEDA_PcbFrame::Erase_Segments_Pcb( wxDC* DC, bool is_edges, bool query )
return; return;
} }
PtStruct = (EDA_BaseStruct*) m_Pcb->m_Drawings; PtStruct = m_Pcb->m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtNext ) for( ; PtStruct != NULL; PtStruct = PtNext )
{ {
PtNext = PtStruct->Pnext; PtNext = PtStruct->Next();
switch( PtStruct->m_StructType ) switch( PtStruct->m_StructType )
{ {
case TYPEDRAWSEGMENT: case TYPEDRAWSEGMENT:
if( g_TabOneLayerMask[( (DRAWSEGMENT*) PtStruct )->m_Layer] & masque_layer )
DeleteStructure( PtStruct );
break;
case TYPETEXTE: case TYPETEXTE:
if( g_TabOneLayerMask[( (TEXTE_PCB*) PtStruct )->m_Layer] & masque_layer )
DeleteStructure( PtStruct );
break;
case TYPECOTATION: case TYPECOTATION:
if( g_TabOneLayerMask[( (COTATION*) PtStruct )->m_Layer] & masque_layer )
DeleteStructure( PtStruct );
break;
case TYPEMIRE: case TYPEMIRE:
if( g_TabOneLayerMask[( (MIREPCB*) PtStruct )->m_Layer] & masque_layer ) if( g_TabOneLayerMask[ PtStruct->GetLayer()] & masque_layer )
DeleteStructure( PtStruct ); DeleteStructure( PtStruct );
break; break;

11
pcbnew/ioascii.cpp
View File

@ -154,7 +154,8 @@ int WinEDA_BasePcbFrame::ReadListeSegmentDescr( wxDC* DC, FILE* File,
&PtSegm->m_TimeStamp, &flags ); &PtSegm->m_TimeStamp, &flags );
if( type == 1 ) if( type == 1 )
PtSegm->m_StructType = TYPEVIA; PtSegm->m_StructType = TYPEVIA;
PtSegm->m_Layer = layer;
PtSegm->SetLayer( layer );
PtSegm->m_NetCode = net_code; PtSegm->SetState( flags, ON ); PtSegm->m_NetCode = net_code; PtSegm->SetState( flags, ON );
#ifdef PCBNEW #ifdef PCBNEW
PtSegm->Draw( DrawPanel, DC, GR_OR ); PtSegm->Draw( DrawPanel, DC, GR_OR );
@ -249,7 +250,7 @@ int WinEDA_BasePcbFrame::ReadGeneralDescrPcb( wxDC* DC, FILE* File, int* LineNum
screensize = DrawPanel->GetClientSize(); screensize = DrawPanel->GetClientSize();
ii = pcbsize.x / screensize.x; ii = pcbsize.x / screensize.x;
jj = pcbsize.y / screensize.y; jj = pcbsize.y / screensize.y;
bestzoom = max( ii, jj ); bestzoom = MAX( ii, jj );
screen->m_Curseur = m_Pcb->m_BoundaryBox.Centre(); screen->m_Curseur = m_Pcb->m_BoundaryBox.Centre();
screen->SetZoom( bestzoom ); screen->SetZoom( bestzoom );
@ -779,7 +780,7 @@ int WinEDA_PcbFrame::ReadPcbFile( wxDC* DC, FILE* File, bool Append )
char Line[1024]; char Line[1024];
int LineNum = 0; int LineNum = 0;
int nbsegm, nbmod; int nbsegm, nbmod;
EDA_BaseStruct* LastStructPcb = NULL, * StructPcb; BOARD_ITEM* LastStructPcb = NULL, * StructPcb;
MODULE* LastModule = NULL, * Module; MODULE* LastModule = NULL, * Module;
EQUIPOT* LastEquipot = NULL, * Equipot; EQUIPOT* LastEquipot = NULL, * Equipot;
@ -803,7 +804,7 @@ int WinEDA_PcbFrame::ReadPcbFile( wxDC* DC, FILE* File, bool Append )
} }
LastStructPcb = m_Pcb->m_Drawings; LastStructPcb = m_Pcb->m_Drawings;
for( ; LastStructPcb != NULL; LastStructPcb = LastStructPcb->Pnext ) for( ; LastStructPcb != NULL; LastStructPcb = LastStructPcb->Next() )
{ {
if( LastStructPcb->Pnext == NULL ) if( LastStructPcb->Pnext == NULL )
break; break;
@ -901,7 +902,7 @@ int WinEDA_PcbFrame::ReadPcbFile( wxDC* DC, FILE* File, bool Append )
if( strnicmp( Line, "$TEXTPCB", 8 ) == 0 ) if( strnicmp( Line, "$TEXTPCB", 8 ) == 0 )
{ {
TEXTE_PCB* pcbtxt = new TEXTE_PCB( m_Pcb ); TEXTE_PCB* pcbtxt = new TEXTE_PCB( m_Pcb );
StructPcb = (EDA_BaseStruct*) pcbtxt; StructPcb = pcbtxt;
pcbtxt->ReadTextePcbDescr( File, &LineNum ); pcbtxt->ReadTextePcbDescr( File, &LineNum );
if( LastStructPcb == NULL ) if( LastStructPcb == NULL )
{ {

75
pcbnew/lay2plot.cpp
View File

@ -22,13 +22,14 @@ static void Plot_Module(WinEDA_DrawPanel * panel, wxDC * DC, MODULE * Module,
/**********************************************************************************/ /**********************************************************************************/
void WinEDA_DrawPanel::PrintPage( wxDC* DC, bool Print_Sheet_Ref, int printmasklayer ) void WinEDA_DrawPanel::PrintPage( wxDC* DC, bool Print_Sheet_Ref, int printmasklayer )
/**********************************************************************************/ /**********************************************************************************/
/* Used to print the board. /* Used to print the board.
Draw the board, but only layers allowed by printmasklayer * Draw the board, but only layers allowed by printmasklayer
( printmasklayer is a 32 bits mask: bit n = 1 -> layer n is printed) * ( printmasklayer is a 32 bits mask: bit n = 1 -> layer n is printed)
*/ */
{ {
MODULE* Module; MODULE* Module;
EDA_BaseStruct * PtStruct; BOARD_ITEM* PtStruct;
int drawmode = GR_COPY; int drawmode = GR_COPY;
DISPLAY_OPTIONS save_opt; DISPLAY_OPTIONS save_opt;
TRACK* pt_piste; TRACK* pt_piste;
@ -36,8 +37,10 @@ WinEDA_BasePcbFrame * frame = (WinEDA_BasePcbFrame *) m_Parent;
BOARD* Pcb = frame->m_Pcb; BOARD* Pcb = frame->m_Pcb;
save_opt = DisplayOpt; save_opt = DisplayOpt;
if( printmasklayer & ALL_CU_LAYERS ) DisplayOpt.DisplayPadFill = FILLED; if( printmasklayer & ALL_CU_LAYERS )
else DisplayOpt.DisplayPadFill = SKETCH; DisplayOpt.DisplayPadFill = FILLED;
else
DisplayOpt.DisplayPadFill = SKETCH;
frame->m_DisplayPadFill = DisplayOpt.DisplayPadFill; frame->m_DisplayPadFill = DisplayOpt.DisplayPadFill;
frame->m_DisplayPadNum = DisplayOpt.DisplayPadNum = FALSE; frame->m_DisplayPadNum = DisplayOpt.DisplayPadNum = FALSE;
DisplayOpt.DisplayPadNoConn = FALSE; DisplayOpt.DisplayPadNoConn = FALSE;
@ -53,39 +56,41 @@ BOARD * Pcb = frame->m_Pcb;
/* Draw the pcb graphic items (texts, ...) */ /* Draw the pcb graphic items (texts, ...) */
PtStruct = Pcb->m_Drawings; PtStruct = Pcb->m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext ) for( ; PtStruct != NULL; PtStruct = PtStruct->Next() )
{ {
switch( PtStruct->m_StructType ) switch( PtStruct->m_StructType )
{ {
case TYPEDRAWSEGMENT: case TYPEDRAWSEGMENT:
if( (g_TabOneLayerMask[((DRAWSEGMENT*)PtStruct)->m_Layer] & printmasklayer) == 0 ) if( (g_TabOneLayerMask[ PtStruct->GetLayer()] & printmasklayer) == 0 )
break; break;
Trace_DrawSegmentPcb( this, DC, (DRAWSEGMENT*) PtStruct, drawmode ); Trace_DrawSegmentPcb( this, DC, (DRAWSEGMENT*) PtStruct, drawmode );
break; break;
case TYPECOTATION: case TYPECOTATION:
if( (g_TabOneLayerMask[((COTATION*)PtStruct)->m_Layer] & printmasklayer) == 0 ) if( (g_TabOneLayerMask[ PtStruct->GetLayer()] & printmasklayer) == 0 )
break; break;
( (COTATION*) PtStruct )->Draw( this, DC, wxPoint( 0, 0 ), drawmode ); ( (COTATION*) PtStruct )->Draw( this, DC, wxPoint( 0, 0 ), drawmode );
break; break;
case TYPETEXTE: case TYPETEXTE:
{ {
if( (g_TabOneLayerMask[((TEXTE_PCB *)PtStruct)->m_Layer] & printmasklayer) == 0 ) if( (g_TabOneLayerMask[ PtStruct->GetLayer()] & printmasklayer) == 0 )
break; break;
( (TEXTE_PCB*) PtStruct )->Draw( this, DC, wxPoint( 0, 0 ), drawmode ); ( (TEXTE_PCB*) PtStruct )->Draw( this, DC, wxPoint( 0, 0 ), drawmode );
break; break;
} }
case TYPEMIRE: case TYPEMIRE:
if( (g_TabOneLayerMask[((MIREPCB*)PtStruct)->m_Layer] & printmasklayer) == 0 ) break; if( (g_TabOneLayerMask[ PtStruct->GetLayer()] & printmasklayer) == 0 )
break;
( (MIREPCB*) PtStruct )->Draw( this, DC, wxPoint( 0, 0 ), drawmode ); ( (MIREPCB*) PtStruct )->Draw( this, DC, wxPoint( 0, 0 ), drawmode );
break; break;
case TYPEMARQUEUR: /* Trace des marqueurs */ case TYPEMARQUEUR: /* Trace des marqueurs */
break; break;
default: break; default:
break;
} }
} }
@ -93,7 +98,8 @@ BOARD * Pcb = frame->m_Pcb;
pt_piste = Pcb->m_Track; pt_piste = Pcb->m_Track;
for( ; pt_piste != NULL; pt_piste = (TRACK*) pt_piste->Pnext ) for( ; pt_piste != NULL; pt_piste = (TRACK*) pt_piste->Pnext )
{ {
if( (printmasklayer & pt_piste->ReturnMaskLayer() ) == 0 ) continue; if( ( printmasklayer & pt_piste->ReturnMaskLayer() ) == 0 )
continue;
if( pt_piste->m_StructType == TYPEVIA ) /* VIA rencontree */ if( pt_piste->m_StructType == TYPEVIA ) /* VIA rencontree */
{ {
int rayon = pt_piste->m_Width >> 1; int rayon = pt_piste->m_Width >> 1;
@ -102,13 +108,15 @@ BOARD * Pcb = frame->m_Pcb;
GRFilledCircle( &m_ClipBox, DC, pt_piste->m_Start.x, pt_piste->m_Start.y, GRFilledCircle( &m_ClipBox, DC, pt_piste->m_Start.x, pt_piste->m_Start.y,
rayon, 0, color, color ); rayon, 0, color, color );
} }
else pt_piste->Draw(this, DC, drawmode); else
pt_piste->Draw( this, DC, drawmode );
} }
pt_piste = Pcb->m_Zone; pt_piste = Pcb->m_Zone;
for( ; pt_piste != NULL; pt_piste = (TRACK*) pt_piste->Pnext ) for( ; pt_piste != NULL; pt_piste = (TRACK*) pt_piste->Pnext )
{ {
if( (printmasklayer & pt_piste->ReturnMaskLayer() ) == 0 ) continue ; if( ( printmasklayer & pt_piste->ReturnMaskLayer() ) == 0 )
continue;
pt_piste->Draw( this, DC, drawmode ); pt_piste->Draw( this, DC, drawmode );
} }
@ -126,7 +134,8 @@ BOARD * Pcb = frame->m_Pcb;
int color = WHITE; int color = WHITE;
for( ; pt_piste != NULL; pt_piste = (TRACK*) pt_piste->Pnext ) for( ; pt_piste != NULL; pt_piste = (TRACK*) pt_piste->Pnext )
{ {
if( (printmasklayer & pt_piste->ReturnMaskLayer() ) == 0 ) continue; if( ( printmasklayer & pt_piste->ReturnMaskLayer() ) == 0 )
continue;
if( pt_piste->m_StructType == TYPEVIA ) /* VIA rencontree */ if( pt_piste->m_StructType == TYPEVIA ) /* VIA rencontree */
{ {
GRSetDrawMode( DC, drawmode ); GRSetDrawMode( DC, drawmode );
@ -159,22 +168,28 @@ int mlayer;
pt_pad = Module->m_Pads; pt_pad = Module->m_Pads;
for( ; pt_pad != NULL; pt_pad = (D_PAD*) pt_pad->Pnext ) for( ; pt_pad != NULL; pt_pad = (D_PAD*) pt_pad->Pnext )
{ {
if( (pt_pad->m_Masque_Layer & masklayer ) == 0 ) continue; if( (pt_pad->m_Masque_Layer & masklayer ) == 0 )
continue;
pt_pad->Draw( panel, DC, wxPoint( 0, 0 ), draw_mode ); pt_pad->Draw( panel, DC, wxPoint( 0, 0 ), draw_mode );
} }
/* draw footprint graphic shapes */ /* draw footprint graphic shapes */
PtStruct = Module->m_Drawings; PtStruct = Module->m_Drawings;
mlayer = g_TabOneLayerMask[Module->m_Layer]; mlayer = g_TabOneLayerMask[Module->GetLayer()];
if( Module->m_Layer == CUIVRE_N) mlayer = SILKSCREEN_LAYER_CU; if( Module->GetLayer() == CUIVRE_N )
if( Module->m_Layer == CMP_N) mlayer = SILKSCREEN_LAYER_CMP; mlayer = SILKSCREEN_LAYER_CU;
else if( Module->GetLayer() == CMP_N )
mlayer = SILKSCREEN_LAYER_CMP;
if( mlayer & masklayer ) if( mlayer & masklayer )
{ {
/* Analyse des autorisations de trace pour les textes VALEUR et REF */ /* Analyse des autorisations de trace pour les textes VALEUR et REF */
bool trace_val, trace_ref; bool trace_val, trace_ref;
trace_val = trace_ref = TRUE; // les 2 autorisations de tracer sont donnees trace_val = trace_ref = TRUE; // les 2 autorisations de tracer sont donnees
if(Module->m_Reference->m_NoShow) trace_ref = FALSE; if( Module->m_Reference->m_NoShow )
if(Module->m_Value->m_NoShow) trace_val = FALSE; trace_ref = FALSE;
if( Module->m_Value->m_NoShow )
trace_val = FALSE;
if( trace_ref ) if( trace_ref )
Module->m_Reference->Draw( panel, DC, wxPoint( 0, 0 ), draw_mode ); Module->m_Reference->Draw( panel, DC, wxPoint( 0, 0 ), draw_mode );
@ -182,12 +197,13 @@ int mlayer;
Module->m_Value->Draw( panel, DC, wxPoint( 0, 0 ), draw_mode ); Module->m_Value->Draw( panel, DC, wxPoint( 0, 0 ), draw_mode );
} }
for( ;PtStruct != NULL; PtStruct = PtStruct->Pnext ) for( ; PtStruct != NULL; PtStruct = PtStruct->Next() )
{ {
switch( PtStruct->m_StructType ) switch( PtStruct->m_StructType )
{ {
case TYPETEXTEMODULE: case TYPETEXTEMODULE:
if( (mlayer & masklayer ) == 0) break; if( (mlayer & masklayer ) == 0 )
break;
TextMod = (TEXTE_MODULE*) PtStruct; TextMod = (TEXTE_MODULE*) PtStruct;
TextMod->Draw( panel, DC, wxPoint( 0, 0 ), draw_mode ); TextMod->Draw( panel, DC, wxPoint( 0, 0 ), draw_mode );
@ -196,13 +212,14 @@ int mlayer;
case TYPEEDGEMODULE: case TYPEEDGEMODULE:
{ {
EDGE_MODULE* edge = (EDGE_MODULE*) PtStruct; EDGE_MODULE* edge = (EDGE_MODULE*) PtStruct;
if( (g_TabOneLayerMask[edge->m_Layer] & masklayer ) == 0) break; if( (g_TabOneLayerMask[edge->GetLayer()] & masklayer ) == 0 )
break;
edge->Draw( panel, DC, wxPoint( 0, 0 ), draw_mode ); edge->Draw( panel, DC, wxPoint( 0, 0 ), draw_mode );
break; break;
} }
default: break;
}
}
}
default:
break;
}
}
}

2
pcbnew/loadcmp.cpp
View File

@ -79,7 +79,7 @@ void WinEDA_ModuleEditFrame::Load_Module_Module_From_BOARD( MODULE* Module )
m_CurrentScreen->m_Curseur.x = m_CurrentScreen->m_Curseur.y = 0; m_CurrentScreen->m_Curseur.x = m_CurrentScreen->m_Curseur.y = 0;
Place_Module( Module, NULL ); Place_Module( Module, NULL );
if( Module->m_Layer != CMP_N ) if( Module->GetLayer() != CMP_N )
Change_Side_Module( Module, NULL ); Change_Side_Module( Module, NULL );
Rotate_Module( NULL, Module, 0, FALSE ); Rotate_Module( NULL, Module, 0, FALSE );
m_CurrentScreen->ClrModify(); m_CurrentScreen->ClrModify();

34
pcbnew/locate.cpp
View File

@ -169,7 +169,7 @@ EDA_BaseStruct* WinEDA_BasePcbFrame::Locate( int typeloc, int LayerSearch )
MODULE* module = m_Pcb->m_Modules; MODULE* module = m_Pcb->m_Modules;
for( ; module != NULL; module = (MODULE*) module->Pnext ) for( ; module != NULL; module = (MODULE*) module->Pnext )
{ {
if( module->m_Layer != LayerSearch ) if( module->GetLayer() != LayerSearch )
continue; continue;
item = LocateTexteModule( m_Pcb, &module, typeloc | VISIBLE_ONLY ); item = LocateTexteModule( m_Pcb, &module, typeloc | VISIBLE_ONLY );
@ -266,7 +266,7 @@ D_PAD* Locate_Pad_Connecte( BOARD* Pcb, TRACK* ptr_piste, int extr )
MODULE* module; MODULE* module;
wxPoint ref_pos; wxPoint ref_pos;
masque_layer = g_TabOneLayerMask[ptr_piste->m_Layer]; masque_layer = g_TabOneLayerMask[ptr_piste->GetLayer()];
if( extr == START ) if( extr == START )
{ {
ref_pos = ptr_piste->m_Start; ref_pos = ptr_piste->m_Start;
@ -374,14 +374,14 @@ DRAWSEGMENT* Locate_Segment_Pcb( BOARD* Pcb, int LayerSearch, int typeloc )
DRAWSEGMENT* pts = (DRAWSEGMENT*) PtStruct; DRAWSEGMENT* pts = (DRAWSEGMENT*) PtStruct;
if( (pts->m_Layer != LayerSearch) && (LayerSearch != -1) ) if( (pts->GetLayer() != LayerSearch) && (LayerSearch != -1) )
continue; continue;
if( pts->HitTest( ref_pos ) ) if( pts->HitTest( ref_pos ) )
{ {
// return this hit if layer matches, else remember in // return this hit if layer matches, else remember in
// case no layer match is found. // case no layer match is found.
if( pts->m_Layer == screen->m_Active_Layer ) if( pts->GetLayer() == screen->m_Active_Layer )
return pts; return pts;
else if( !locate_segm ) else if( !locate_segm )
@ -394,8 +394,8 @@ DRAWSEGMENT* Locate_Segment_Pcb( BOARD* Pcb, int LayerSearch, int typeloc )
/************************************************* /*************************************************
* D_PAD * Locate_Any_Pad(int typeloc, bool OnlyCurrentLayer) * D_PAD * Locate_Any_Pad( BOARD* Pcb, int typeloc, bool OnlyCurrentLayer)
* D_PAD* Locate_Any_Pad(int ref_pos, bool OnlyCurrentLayer) * D_PAD* Locate_Any_Pad( BOARD* Pcb, int ref_pos, bool OnlyCurrentLayer)
*************************************************/ *************************************************/
/* /*
@ -522,7 +522,7 @@ MODULE* Locate_Prefered_Module( BOARD* Pcb, int typeloc )
* d'appartenance du module et a la couche cuivre si le module * d'appartenance du module et a la couche cuivre si le module
* est sur couche serigr,adhesive cuivre, a la couche cmp si le module * est sur couche serigr,adhesive cuivre, a la couche cmp si le module
* est sur couche serigr,adhesive composant */ * est sur couche serigr,adhesive composant */
layer = pt_module->m_Layer; layer = pt_module->GetLayer();
if( layer==ADHESIVE_N_CU || layer==SILKSCREEN_N_CU ) if( layer==ADHESIVE_N_CU || layer==SILKSCREEN_N_CU )
layer = CUIVRE_N; layer = CUIVRE_N;
@ -538,21 +538,21 @@ MODULE* Locate_Prefered_Module( BOARD* Pcb, int typeloc )
if( ( (PCB_SCREEN*) ActiveScreen )->m_Active_Layer == layer ) if( ( (PCB_SCREEN*) ActiveScreen )->m_Active_Layer == layer )
{ {
if( min( lx, ly ) <= min_dim ) if( MIN( lx, ly ) <= min_dim )
{ {
/* meilleure empreinte localisee sur couche active */ /* meilleure empreinte localisee sur couche active */
module = pt_module; module = pt_module;
min_dim = min( lx, ly ); min_dim = MIN( lx, ly );
} }
} }
else if( !(typeloc & MATCH_LAYER) else if( !(typeloc & MATCH_LAYER)
&& ( !(typeloc & VISIBLE_ONLY) || IsModuleLayerVisible( layer ) ) ) && ( !(typeloc & VISIBLE_ONLY) || IsModuleLayerVisible( layer ) ) )
{ {
if( min( lx, ly ) <= alt_min_dim ) if( MIN( lx, ly ) <= alt_min_dim )
{ {
/* meilleure empreinte localisee sur autres couches */ /* meilleure empreinte localisee sur autres couches */
Altmodule = pt_module; Altmodule = pt_module;
alt_min_dim = min( lx, ly ); alt_min_dim = MIN( lx, ly );
} }
} }
} }
@ -603,7 +603,7 @@ TEXTE_MODULE* LocateTexteModule( BOARD* Pcb, MODULE** PtModule, int typeloc )
for( ; module != NULL; module = (MODULE*) module->Pnext ) for( ; module != NULL; module = (MODULE*) module->Pnext )
{ {
int layer = module->m_Layer; int layer = module->GetLayer();
if( layer==ADHESIVE_N_CU || layer==SILKSCREEN_N_CU ) if( layer==ADHESIVE_N_CU || layer==SILKSCREEN_N_CU )
layer = CUIVRE_N; layer = CUIVRE_N;
else if( layer==ADHESIVE_N_CMP || layer==SILKSCREEN_N_CMP ) else if( layer==ADHESIVE_N_CMP || layer==SILKSCREEN_N_CMP )
@ -817,7 +817,7 @@ TRACK* Locate_Pistes( TRACK* start_adresse, const wxPoint& ref_pos, int MasqueLa
if( Track->GetState( BUSY | DELETED ) ) if( Track->GetState( BUSY | DELETED ) )
continue; continue;
if( (g_DesignSettings.m_LayerColor[Track->m_Layer] & ITEM_NOT_SHOW) ) if( (g_DesignSettings.m_LayerColor[Track->GetLayer()] & ITEM_NOT_SHOW) )
continue; continue;
if( Track->m_StructType == TYPEVIA ) /* VIA rencontree */ if( Track->m_StructType == TYPEVIA ) /* VIA rencontree */
@ -828,7 +828,7 @@ TRACK* Locate_Pistes( TRACK* start_adresse, const wxPoint& ref_pos, int MasqueLa
else else
{ {
if( MasqueLayer != -1 ) if( MasqueLayer != -1 )
if( (g_TabOneLayerMask[Track->m_Layer] & MasqueLayer) == 0 ) if( (g_TabOneLayerMask[Track->GetLayer()] & MasqueLayer) == 0 )
continue; /* Segments sur couches differentes */ continue; /* Segments sur couches differentes */
if( Track->HitTest( ref_pos ) ) if( Track->HitTest( ref_pos ) )
@ -869,7 +869,7 @@ TRACK* Locate_Zone( TRACK* start_adresse, const wxPoint& ref_pos, int layer )
{ {
for( TRACK* Zone = start_adresse; Zone; Zone = (TRACK*) Zone->Pnext ) for( TRACK* Zone = start_adresse; Zone; Zone = (TRACK*) Zone->Pnext )
{ {
if( (layer != -1) && (Zone->m_Layer != layer) ) if( (layer != -1) && (Zone->GetLayer() != layer) )
continue; continue;
if( Zone->HitTest( ref_pos ) ) if( Zone->HitTest( ref_pos ) )
@ -898,7 +898,7 @@ TEXTE_PCB* Locate_Texte_Pcb( EDA_BaseStruct* PtStruct, int LayerSearch, int type
TEXTE_PCB* pt_txt_pcb = (TEXTE_PCB*) PtStruct; TEXTE_PCB* pt_txt_pcb = (TEXTE_PCB*) PtStruct;
if( pt_txt_pcb->m_Layer == LayerSearch ) if( pt_txt_pcb->GetLayer() == LayerSearch )
{ {
if( pt_txt_pcb->HitTest( ref ) ) if( pt_txt_pcb->HitTest( ref ) )
{ {
@ -1048,7 +1048,7 @@ EDA_BaseStruct* Locate_MirePcb( EDA_BaseStruct* PtStruct, int LayerSearch,
continue; continue;
item = (MIREPCB*) PtStruct; item = (MIREPCB*) PtStruct;
if( LayerSearch != -1 && item->m_Layer != LayerSearch ) if( LayerSearch != -1 && item->GetLayer() != LayerSearch )
continue; continue;
if( item->HitTest( ref_pos ) ) if( item->HitTest( ref_pos ) )

4
pcbnew/makefile.include
View File

@ -101,7 +101,8 @@ OBJECTS= $(TARGET).o classpcb.o\
gen_modules_placefile.o\ gen_modules_placefile.o\
modedit.o\ modedit.o\
export_gencad.o\ export_gencad.o\
hotkeys.o hotkeys.o \
collectors.o
setpage.o: ../share/setpage.cpp setpage.o: ../share/setpage.cpp
$(CC) -c $(EDACPPFLAGS) -o $@ ../share/$*.cpp $(CC) -c $(EDACPPFLAGS) -o $@ ../share/$*.cpp
@ -289,3 +290,4 @@ dragsegm.o: dragsegm.cpp drag.h $(COMMON)
router.o: router.cpp $(COMMON) router.o: router.cpp $(COMMON)
collectors.o: collectors.cpp collectors.h $(COMMON)

2
pcbnew/mirepcb.cpp
View File

@ -218,7 +218,7 @@ MIREPCB* WinEDA_PcbFrame::Create_Mire( wxDC* DC )
m_Pcb->m_Drawings->Pback = MirePcb; m_Pcb->m_Drawings->Pback = MirePcb;
m_Pcb->m_Drawings = MirePcb; m_Pcb->m_Drawings = MirePcb;
MirePcb->m_Layer = EDGE_N; MirePcb->SetLayer( EDGE_N );
MirePcb->m_Width = g_DesignSettings.m_EdgeSegmentWidth; MirePcb->m_Width = g_DesignSettings.m_EdgeSegmentWidth;
MirePcb->m_Size = MireDefaultSize; MirePcb->m_Size = MireDefaultSize;
MirePcb->m_Pos = GetScreen()->m_Curseur; MirePcb->m_Pos = GetScreen()->m_Curseur;

61
pcbnew/modules.cpp
View File

@ -104,7 +104,7 @@ void WinEDA_PcbFrame::StartMove_Module( MODULE* module, wxDC* DC )
m_Pcb->m_Status_Pcb &= ~CHEVELU_LOCAL_OK; m_Pcb->m_Status_Pcb &= ~CHEVELU_LOCAL_OK;
module->m_Flags |= IS_MOVED; module->m_Flags |= IS_MOVED;
ModuleInitOrient = module->m_Orient; ModuleInitOrient = module->m_Orient;
ModuleInitLayer = module->m_Layer; ModuleInitLayer = module->GetLayer();
/* Effacement chevelu general si necessaire */ /* Effacement chevelu general si necessaire */
if( g_Show_Ratsnest ) if( g_Show_Ratsnest )
@ -192,7 +192,7 @@ void Exit_Module( WinEDA_DrawPanel* Panel, wxDC* DC )
{ {
if( ModuleInitOrient != module->m_Orient ) if( ModuleInitOrient != module->m_Orient )
pcbframe->Rotate_Module( NULL, module, ModuleInitOrient, FALSE ); pcbframe->Rotate_Module( NULL, module, ModuleInitOrient, FALSE );
if( ModuleInitLayer != module->m_Layer ) if( ModuleInitLayer != module->GetLayer() )
pcbframe->Change_Side_Module( module, NULL ); pcbframe->Change_Side_Module( module, NULL );
module->Draw( Panel, DC, wxPoint( 0, 0 ), GR_OR ); module->Draw( Panel, DC, wxPoint( 0, 0 ), GR_OR );
} }
@ -337,7 +337,7 @@ void WinEDA_BasePcbFrame::Change_Side_Module( MODULE* Module, wxDC* DC )
if( Module == NULL ) if( Module == NULL )
return; return;
if( (Module->m_Layer != CMP_N) && (Module->m_Layer != CUIVRE_N) ) if( (Module->GetLayer() != CMP_N) && (Module->GetLayer() != CUIVRE_N) )
return; return;
m_CurrentScreen->SetModify(); m_CurrentScreen->SetModify();
@ -367,7 +367,7 @@ void WinEDA_BasePcbFrame::Change_Side_Module( MODULE* Module, wxDC* DC )
} }
/* mise a jour du Flag de l'empreinte et des couches des contours et textes */ /* mise a jour du Flag de l'empreinte et des couches des contours et textes */
Module->m_Layer = ChangeSideNumLayer( Module->m_Layer ); Module->SetLayer( ChangeSideNumLayer( Module->GetLayer() ) );
/* Inversion miroir de l'orientation */ /* Inversion miroir de l'orientation */
Module->m_Orient = -Module->m_Orient; Module->m_Orient = -Module->m_Orient;
@ -397,17 +397,17 @@ void WinEDA_BasePcbFrame::Change_Side_Module( MODULE* Module, wxDC* DC )
pt_texte->m_Pos0.y = pt_texte->m_Pos0.y; pt_texte->m_Pos0.y = pt_texte->m_Pos0.y;
pt_texte->m_Miroir = 1; pt_texte->m_Miroir = 1;
NEGATE_AND_NORMALIZE_ANGLE_POS( pt_texte->m_Orient ); NEGATE_AND_NORMALIZE_ANGLE_POS( pt_texte->m_Orient );
pt_texte->m_Layer = Module->m_Layer; pt_texte->SetLayer( Module->GetLayer() );
pt_texte->m_Layer = ChangeSideNumLayer( pt_texte->m_Layer ); pt_texte->SetLayer( ChangeSideNumLayer( pt_texte->GetLayer() ) );
if( Module->m_Layer == CUIVRE_N ) if( Module->GetLayer() == CUIVRE_N )
pt_texte->m_Layer = SILKSCREEN_N_CU; pt_texte->SetLayer( SILKSCREEN_N_CU );
if( Module->m_Layer == CMP_N ) if( Module->GetLayer() == CMP_N )
pt_texte->m_Layer = SILKSCREEN_N_CMP; pt_texte->SetLayer( SILKSCREEN_N_CMP );
if( (Module->m_Layer == SILKSCREEN_N_CU) if( (Module->GetLayer() == SILKSCREEN_N_CU)
|| (Module->m_Layer == ADHESIVE_N_CU) || (Module->m_Layer == CUIVRE_N) ) || (Module->GetLayer() == ADHESIVE_N_CU) || (Module->GetLayer() == CUIVRE_N) )
pt_texte->m_Miroir = 0; pt_texte->m_Miroir = 0;
/* Inversion miroir de la Valeur et mise en miroir : */ /* Inversion miroir de la Valeur et mise en miroir : */
@ -418,17 +418,17 @@ void WinEDA_BasePcbFrame::Change_Side_Module( MODULE* Module, wxDC* DC )
pt_texte->m_Pos0.y = pt_texte->m_Pos0.y; pt_texte->m_Pos0.y = pt_texte->m_Pos0.y;
pt_texte->m_Miroir = 1; pt_texte->m_Miroir = 1;
NEGATE_AND_NORMALIZE_ANGLE_POS( pt_texte->m_Orient ); NEGATE_AND_NORMALIZE_ANGLE_POS( pt_texte->m_Orient );
pt_texte->m_Layer = Module->m_Layer; pt_texte->SetLayer( Module->GetLayer() );
pt_texte->m_Layer = ChangeSideNumLayer( pt_texte->m_Layer ); pt_texte->SetLayer( ChangeSideNumLayer( pt_texte->GetLayer() ) );
if( Module->m_Layer == CUIVRE_N ) if( Module->GetLayer() == CUIVRE_N )
pt_texte->m_Layer = SILKSCREEN_N_CU; pt_texte->SetLayer( SILKSCREEN_N_CU );
if( Module->m_Layer == CMP_N ) if( Module->GetLayer() == CMP_N )
pt_texte->m_Layer = SILKSCREEN_N_CMP; pt_texte->SetLayer( SILKSCREEN_N_CMP );
if( (Module->m_Layer == SILKSCREEN_N_CU) if( (Module->GetLayer() == SILKSCREEN_N_CU)
|| (Module->m_Layer == ADHESIVE_N_CU) || (Module->m_Layer == CUIVRE_N) ) || (Module->GetLayer() == ADHESIVE_N_CU) || (Module->GetLayer() == CUIVRE_N) )
pt_texte->m_Miroir = 0; pt_texte->m_Miroir = 0;
/* Inversion miroir des dessins de l'empreinte : */ /* Inversion miroir des dessins de l'empreinte : */
@ -453,7 +453,7 @@ void WinEDA_BasePcbFrame::Change_Side_Module( MODULE* Module, wxDC* DC )
pt_edgmod->m_Angle = -pt_edgmod->m_Angle; pt_edgmod->m_Angle = -pt_edgmod->m_Angle;
} }
pt_edgmod->m_Layer = ChangeSideNumLayer( pt_edgmod->m_Layer ); pt_edgmod->SetLayer( ChangeSideNumLayer( pt_edgmod->GetLayer() ) );
break; break;
case TYPETEXTEMODULE: case TYPETEXTEMODULE:
@ -466,18 +466,21 @@ void WinEDA_BasePcbFrame::Change_Side_Module( MODULE* Module, wxDC* DC )
pt_texte->m_Miroir = 1; pt_texte->m_Miroir = 1;
NEGATE_AND_NORMALIZE_ANGLE_POS( pt_texte->m_Orient ); NEGATE_AND_NORMALIZE_ANGLE_POS( pt_texte->m_Orient );
pt_texte->m_Layer = Module->m_Layer; pt_texte->SetLayer( Module->GetLayer() );
pt_texte->m_Layer = ChangeSideNumLayer( pt_texte->m_Layer ); pt_texte->SetLayer( ChangeSideNumLayer( pt_texte->GetLayer() ) );
if( Module->m_Layer == CUIVRE_N ) if( Module->GetLayer() == CUIVRE_N )
pt_texte->m_Layer = SILKSCREEN_N_CU; pt_texte->SetLayer( SILKSCREEN_N_CU );
if( Module->m_Layer == CMP_N ) if( Module->GetLayer() == CMP_N )
pt_texte->m_Layer = SILKSCREEN_N_CMP; pt_texte->SetLayer( SILKSCREEN_N_CMP );
if( (Module->m_Layer == SILKSCREEN_N_CU) if( Module->GetLayer() == SILKSCREEN_N_CU
|| (Module->m_Layer == ADHESIVE_N_CU) || (Module->m_Layer == CUIVRE_N) ) || Module->GetLayer() == ADHESIVE_N_CU
|| Module->GetLayer() == CUIVRE_N )
{
pt_texte->m_Miroir = 0; pt_texte->m_Miroir = 0;
}
break; break;

2
pcbnew/move_or_drag_track.cpp
View File

@ -815,7 +815,7 @@ bool WinEDA_PcbFrame::PlaceDraggedTrackSegment( TRACK* Track, wxDC* DC )
/* Test the connections modified by the move /* Test the connections modified by the move
* (only pad connection must be tested, track connection will be tested by test_1_net_connexion() ) */ * (only pad connection must be tested, track connection will be tested by test_1_net_connexion() ) */
int masque_layer = g_TabOneLayerMask[Track->m_Layer]; int masque_layer = g_TabOneLayerMask[Track->GetLayer()];
Track->start = Fast_Locate_Pad_Connecte( m_Pcb, Track->m_Start, masque_layer ); Track->start = Fast_Locate_Pad_Connecte( m_Pcb, Track->m_Start, masque_layer );
Track->end = Fast_Locate_Pad_Connecte( m_Pcb, Track->m_End, masque_layer ); Track->end = Fast_Locate_Pad_Connecte( m_Pcb, Track->m_End, masque_layer );
} }

4
pcbnew/muonde.cpp
View File

@ -243,7 +243,7 @@ MODULE* WinEDA_PcbFrame::Create_MuWaveComponent( wxDC* DC, int shape_type )
Module->m_Drawings = edge; Module->m_Drawings = edge;
edge->Pback = Module; edge->Pback = Module;
edge->m_Shape = S_POLYGON; edge->m_Shape = S_POLYGON;
edge->m_Layer = LAYER_CMP_N; edge->SetLayer( LAYER_CMP_N );
edge->m_PolyCount = ii + 3; edge->m_PolyCount = ii + 3;
edge->m_PolyList = (int*) MyMalloc( edge->m_PolyCount * 2 * sizeof(int) ); edge->m_PolyList = (int*) MyMalloc( edge->m_PolyCount * 2 * sizeof(int) );
ptr = edge->m_PolyList; ptr = edge->m_PolyList;
@ -574,7 +574,7 @@ MODULE* WinEDA_PcbFrame::Create_MuWavePolygonShape( wxDC* DC )
Module->m_Drawings = edge; Module->m_Drawings = edge;
edge->Pback = Module; edge->Pback = Module;
edge->m_Shape = S_POLYGON; edge->m_Shape = S_POLYGON;
edge->m_Layer = LAYER_CMP_N; edge->SetLayer( LAYER_CMP_N );
npoints = PolyEdgesCount; npoints = PolyEdgesCount;
switch( PolyShapeType ) switch( PolyShapeType )

4
pcbnew/pcbcfg.cpp
View File

@ -120,9 +120,7 @@ bool Read_Hotkey_Config( WinEDA_DrawFrame * frame, bool verbose )
FullFileName = DEFAULT_HOTKEY_FILENAME_PATH; FullFileName = DEFAULT_HOTKEY_FILENAME_PATH;
FullFileName += wxT("module_edit"); FullFileName += wxT("module_edit");
FullFileName += DEFAULT_HOTKEY_FILENAME_EXT; FullFileName += DEFAULT_HOTKEY_FILENAME_EXT;
frame->ReadHotkeyConfigFile(FullFileName, s_module_edit_Hotkey_List, verbose); return frame->ReadHotkeyConfigFile(FullFileName, s_module_edit_Hotkey_List, verbose);
return TRUE;
} }

80
pcbnew/pcbframe.cpp
View File

@ -12,7 +12,7 @@
#include "id.h" #include "id.h"
#if defined(DEBUG) #if defined(DEBUG)
#include "class_collector.h" #include "collectors.h"
#endif #endif
@ -169,77 +169,6 @@ END_EVENT_TABLE()
#if defined(DEBUG)
class RAT1COLLECTOR : public COLLECTOR
{
;
};
class ARROWCOLLECTOR : public COLLECTOR
{
const KICAD_T* m_ScanTypes;
/**
* A place to hold collected objects which don't match precisely the search
* criteria, but would be acceptable if nothing else is found.
* "2nd" choice, which will be appended to the end of COLLECTOR's prime
* "list" at the end of the search.
*/
std::vector<EDA_BaseStruct*> list2nd;
public:
ARROWCOLLECTOR() :
COLLECTOR(0),
m_ScanTypes(0)
{
}
void Empty2nd()
{
list2nd.clear();
}
/**
* Function Inspect
* is the examining function within the INSPECTOR which is passed to the
* Iterate function. It is used primarily for searching, but not limited to
* that. It can also collect or modify the scanned objects.
*
* @param testItem An EDA_BaseStruct to examine.
* @param testData is arbitrary data needed by the inspector to determine
* if the EDA_BaseStruct under test meets its match criteria.
* @return SEARCH_RESULT - SEARCH_QUIT if the Iterator is to stop the scan,
* else SCAN_CONTINUE;
*/
SEARCH_RESULT Inspect( EDA_BaseStruct* testItem, const void* testData )
{
const wxPoint& refPos = *(const wxPoint*) testData;
switch( testItem->m_StructType )
{
case TYPEMODULE:
if( testItem->HitTest( refPos ) )
Append( testItem );
break;
}
return SEARCH_CONTINUE;
}
void SetScanTypes( const KICAD_T* scanTypes )
{
m_ScanTypes = scanTypes;
}
};
#endif
///////****************************///////////: ///////****************************///////////:
/****************/ /****************/
@ -264,8 +193,7 @@ WinEDA_PcbFrame::WinEDA_PcbFrame( wxWindow* father, WinEDA_App* parent,
m_SelViaSizeBox_Changed = FALSE; m_SelViaSizeBox_Changed = FALSE;
#if defined(DEBUG) #if defined(DEBUG)
m_GeneralCollector = NULL; m_ArrowCollector = new ARROWCOLLECTOR();
m_RatsModuleCollector = NULL;
#endif #endif
m_DisplayPcbTrackFill = DisplayOpt.DisplayPcbTrackFill; m_DisplayPcbTrackFill = DisplayOpt.DisplayPcbTrackFill;
@ -313,6 +241,10 @@ WinEDA_PcbFrame::~WinEDA_PcbFrame( void )
{ {
m_Parent->m_PcbFrame = NULL; m_Parent->m_PcbFrame = NULL;
m_CurrentScreen = ScreenPcb; m_CurrentScreen = ScreenPcb;
#if defined(DEBUG)
delete m_ArrowCollector;
#endif
} }

10
pcbnew/pcbtexte.cpp
View File

@ -148,7 +148,7 @@ WinEDA_TextPCBPropertiesFrame::WinEDA_TextPCBPropertiesFrame( WinEDA_PcbFrame* p
m_SelLayerBox->Append( ReturnPcbLayerName( ii ) ); m_SelLayerBox->Append( ReturnPcbLayerName( ii ) );
} }
m_SelLayerBox->SetSelection( TextPCB->m_Layer ); m_SelLayerBox->SetSelection( TextPCB->GetLayer() );
wxString orient_msg[4] = { wxT( "0" ), wxT( "90" ), wxT( "180" ), wxT( "-90" ) }; wxString orient_msg[4] = { wxT( "0" ), wxT( "90" ), wxT( "180" ), wxT( "-90" ) };
@ -216,7 +216,7 @@ void WinEDA_TextPCBPropertiesFrame::TextPCBPropertiesAccept( wxCommandEvent& eve
CurrentTextPCB->m_Width = m_TxtWidthCtlr->GetValue(); CurrentTextPCB->m_Width = m_TxtWidthCtlr->GetValue();
CurrentTextPCB->m_Miroir = (m_Mirror->GetSelection() == 0) ? 1 : 0; CurrentTextPCB->m_Miroir = (m_Mirror->GetSelection() == 0) ? 1 : 0;
CurrentTextPCB->m_Orient = m_Orient->GetSelection() * 900; CurrentTextPCB->m_Orient = m_Orient->GetSelection() * 900;
CurrentTextPCB->m_Layer = m_SelLayerBox->GetChoice(); CurrentTextPCB->SetLayer( m_SelLayerBox->GetChoice() );
CurrentTextPCB->CreateDrawData(); CurrentTextPCB->CreateDrawData();
if( m_DC ) // Affichage nouveau texte if( m_DC ) // Affichage nouveau texte
{ {
@ -349,13 +349,13 @@ TEXTE_PCB* WinEDA_PcbFrame::Create_Texte_Pcb( wxDC* DC )
TextePcb->Pback = (EDA_BaseStruct*) m_Pcb; TextePcb->Pback = (EDA_BaseStruct*) m_Pcb;
if( m_Pcb->m_Drawings ) if( m_Pcb->m_Drawings )
m_Pcb->m_Drawings->Pback = (EDA_BaseStruct*) TextePcb; m_Pcb->m_Drawings->Pback = (EDA_BaseStruct*) TextePcb;
m_Pcb->m_Drawings = (EDA_BaseStruct*) TextePcb; m_Pcb->m_Drawings = TextePcb;
/* Mise a jour des caracteristiques */ /* Mise a jour des caracteristiques */
TextePcb->m_Flags = IS_NEW; TextePcb->m_Flags = IS_NEW;
TextePcb->m_Layer = GetScreen()->m_Active_Layer; TextePcb->SetLayer( GetScreen()->m_Active_Layer );
TextePcb->m_Miroir = 1; TextePcb->m_Miroir = 1;
if( TextePcb->m_Layer == CUIVRE_N ) if( TextePcb->GetLayer() == CUIVRE_N )
TextePcb->m_Miroir = 0; TextePcb->m_Miroir = 0;
TextePcb->m_Size = g_DesignSettings.m_PcbTextSize; TextePcb->m_Size = g_DesignSettings.m_PcbTextSize;

20
pcbnew/plot_rtn.cpp
View File

@ -203,12 +203,12 @@ wxString msg;
trace_val = Sel_Texte_Valeur; trace_val = Sel_Texte_Valeur;
trace_ref = Sel_Texte_Reference; // les 2 autorisations de tracer sont donnees trace_ref = Sel_Texte_Reference; // les 2 autorisations de tracer sont donnees
if( (g_TabOneLayerMask[Module->m_Reference->m_Layer] & masque_layer) == 0) if( (g_TabOneLayerMask[Module->m_Reference->GetLayer()] & masque_layer) == 0)
trace_ref = FALSE; trace_ref = FALSE;
if(Module->m_Reference->m_NoShow && !Sel_Texte_Invisible) if(Module->m_Reference->m_NoShow && !Sel_Texte_Invisible)
trace_ref = FALSE; trace_ref = FALSE;
if( (g_TabOneLayerMask[Module->m_Value->m_Layer] & masque_layer) == 0) if( (g_TabOneLayerMask[Module->m_Value->GetLayer()] & masque_layer) == 0)
trace_val = FALSE; trace_val = FALSE;
if(Module->m_Value->m_NoShow && !Sel_Texte_Invisible) if(Module->m_Value->m_NoShow && !Sel_Texte_Invisible)
trace_val = FALSE; trace_val = FALSE;
@ -238,7 +238,7 @@ wxString msg;
if( !Sel_Texte_Divers ) continue; if( !Sel_Texte_Divers ) continue;
if( (pt_texte->m_NoShow) && !Sel_Texte_Invisible ) if( (pt_texte->m_NoShow) && !Sel_Texte_Invisible )
continue; continue;
if( (g_TabOneLayerMask[pt_texte->m_Layer] & masque_layer) == 0) if( (g_TabOneLayerMask[pt_texte->GetLayer()] & masque_layer) == 0)
continue; continue;
PlotTextModule(pt_texte); PlotTextModule(pt_texte);
nb_items++ ; nb_items++ ;
@ -281,13 +281,13 @@ void PlotCotation( COTATION * Cotation, int format_plot,int masque_layer)
{ {
DRAWSEGMENT *DrawTmp; DRAWSEGMENT *DrawTmp;
if( (g_TabOneLayerMask[Cotation->m_Layer] & masque_layer) == 0) return; if( (g_TabOneLayerMask[Cotation->GetLayer()] & masque_layer) == 0) return;
DrawTmp = new DRAWSEGMENT(NULL); DrawTmp = new DRAWSEGMENT(NULL);
masque_layer |= EDGE_LAYER; masque_layer |= EDGE_LAYER;
DrawTmp->m_Width = Cotation->m_Width; DrawTmp->m_Width = Cotation->m_Width;
DrawTmp->m_Layer = Cotation->m_Layer; DrawTmp->SetLayer( Cotation->GetLayer() );
PlotTextePcb( Cotation->m_Text,format_plot, masque_layer); PlotTextePcb( Cotation->m_Text,format_plot, masque_layer);
@ -330,13 +330,13 @@ void PlotMirePcb( MIREPCB* Mire, int format_plot,int masque_layer)
DRAWSEGMENT *DrawTmp; DRAWSEGMENT *DrawTmp;
int dx1,dx2, dy1, dy2, rayon; int dx1,dx2, dy1, dy2, rayon;
if( (g_TabOneLayerMask[Mire->m_Layer] & masque_layer) == 0) return; if( (g_TabOneLayerMask[Mire->GetLayer()] & masque_layer) == 0) return;
DrawTmp = new DRAWSEGMENT(NULL); DrawTmp = new DRAWSEGMENT(NULL);
masque_layer |= EDGE_LAYER; masque_layer |= EDGE_LAYER;
DrawTmp->m_Width = Mire->m_Width; DrawTmp->m_Width = Mire->m_Width;
DrawTmp->m_Layer = Mire->m_Layer; DrawTmp->SetLayer( Mire->GetLayer() );
DrawTmp->m_Start.x = Mire->m_Pos.x; DrawTmp->m_Start.y = Mire->m_Pos.y; DrawTmp->m_Start.x = Mire->m_Pos.x; DrawTmp->m_Start.y = Mire->m_Pos.y;
DrawTmp->m_End.x = DrawTmp->m_Start.x + (Mire->m_Size / 4); DrawTmp->m_End.x = DrawTmp->m_Start.x + (Mire->m_Size / 4);
@ -384,7 +384,7 @@ wxString msg;
for ( ;PtEdge != NULL; PtEdge = (EDGE_MODULE*)PtEdge->Pnext) for ( ;PtEdge != NULL; PtEdge = (EDGE_MODULE*)PtEdge->Pnext)
{ {
if(PtEdge->m_StructType != TYPEEDGEMODULE) continue; if(PtEdge->m_StructType != TYPEEDGEMODULE) continue;
if( (g_TabOneLayerMask[PtEdge->m_Layer] & masque_layer) == 0) continue; if( (g_TabOneLayerMask[PtEdge->GetLayer()] & masque_layer) == 0) continue;
Plot_1_EdgeModule(format_plot, PtEdge); Plot_1_EdgeModule(format_plot, PtEdge);
} }
/* Affichage du nombre de modules traites */ /* Affichage du nombre de modules traites */
@ -488,7 +488,7 @@ wxPoint pos;
wxSize size; wxSize size;
if( pt_texte->m_Text.IsEmpty() ) return; if( pt_texte->m_Text.IsEmpty() ) return;
if( (g_TabOneLayerMask[pt_texte->m_Layer] & masque_layer) == 0 ) return ; if( (g_TabOneLayerMask[pt_texte->GetLayer()] & masque_layer) == 0 ) return ;
/* calcul des parametres du texte :*/ /* calcul des parametres du texte :*/
size = pt_texte->m_Size; size = pt_texte->m_Size;
@ -615,7 +615,7 @@ wxPoint start, end;
int epaisseur; int epaisseur;
int rayon = 0, StAngle = 0, EndAngle = 0; int rayon = 0, StAngle = 0, EndAngle = 0;
if( (g_TabOneLayerMask[pt_segm->m_Layer] & masque_layer) == 0) return; if( (g_TabOneLayerMask[pt_segm->GetLayer()] & masque_layer) == 0) return;
epaisseur = pt_segm->m_Width; epaisseur = pt_segm->m_Width;
if ( Plot_Mode == FILAIRE) epaisseur = g_PlotLine_Width; if ( Plot_Mode == FILAIRE) epaisseur = g_PlotLine_Width;

6
pcbnew/plotgerb.cpp
View File

@ -194,7 +194,7 @@ wxString msg;
switch( PtStruct->m_StructType ) switch( PtStruct->m_StructType )
{ {
case TYPEEDGEMODULE: case TYPEEDGEMODULE:
if( masque_layer & g_TabOneLayerMask[((EDGE_MODULE*)PtStruct)->m_Layer] ) if( masque_layer & g_TabOneLayerMask[((EDGE_MODULE*)PtStruct)->GetLayer()] )
Plot_1_EdgeModule(PLOT_FORMAT_GERBER, (EDGE_MODULE*) PtStruct); Plot_1_EdgeModule(PLOT_FORMAT_GERBER, (EDGE_MODULE*) PtStruct);
break; break;
@ -289,7 +289,7 @@ wxString msg;
wxPoint end; wxPoint end;
if ( track->m_StructType == TYPEVIA ) continue ; if ( track->m_StructType == TYPEVIA ) continue ;
if( (g_TabOneLayerMask[track->m_Layer] & masque_layer) == 0 ) continue; if( (g_TabOneLayerMask[track->GetLayer()] & masque_layer) == 0 ) continue;
size.x = size.y = track->m_Width; size.x = size.y = track->m_Width;
pos = track->m_Start; end = track->m_End; pos = track->m_Start; end = track->m_End;
@ -308,7 +308,7 @@ wxString msg;
{ {
wxPoint end; wxPoint end;
if( (g_TabOneLayerMask[track->m_Layer] & masque_layer) == 0 ) continue; if( (g_TabOneLayerMask[track->GetLayer()] & masque_layer) == 0 ) continue;
size.x = size.y = track->m_Width; size.x = size.y = track->m_Width;
pos = track->m_Start; end = track->m_End; pos = track->m_Start; end = track->m_End;

167
pcbnew/plothpgl.cpp
View File

@ -52,9 +52,11 @@ bool Center = FALSE;
pen_rayon = pen_diam / 2; pen_rayon = pen_diam / 2;
nb_plot_erreur = 0; nb_plot_erreur = 0;
// compute pen_recouvrement (from g_HPGL_Pen_Recouvrement in mils) // compute pen_recouvrement (from g_HPGL_Pen_Recouvrement in mils)
// with plot scale // with plot scale
if(g_HPGL_Pen_Recouvrement < 0 ) g_HPGL_Pen_Recouvrement = 0 ; if( g_HPGL_Pen_Recouvrement < 0 )
g_HPGL_Pen_Recouvrement = 0;
if( g_HPGL_Pen_Recouvrement >= g_HPGL_Pen_Diam ) if( g_HPGL_Pen_Recouvrement >= g_HPGL_Pen_Diam )
g_HPGL_Pen_Recouvrement = g_HPGL_Pen_Diam - 1; g_HPGL_Pen_Recouvrement = g_HPGL_Pen_Diam - 1;
pen_recouvrement = (int) round( g_HPGL_Pen_Recouvrement * 10.0 / Scale_X ); pen_recouvrement = (int) round( g_HPGL_Pen_Recouvrement * 10.0 / Scale_X );
@ -91,19 +93,21 @@ bool Center = FALSE;
float Xscale, Yscale; float Xscale, Yscale;
Xscale = (float) ( SheetSize.x - ( 2 * marge) ) / BoardSize.x; Xscale = (float) ( SheetSize.x - ( 2 * marge) ) / BoardSize.x;
Yscale = (float) ( SheetSize.y - ( 2 * marge) ) / BoardSize.y; Yscale = (float) ( SheetSize.y - ( 2 * marge) ) / BoardSize.y;
scale_x = scale_y = min( Xscale, Yscale) * SCALE_HPGL; scale_x = scale_y = MIN( Xscale, Yscale ) * SCALE_HPGL;
} }
BoardCenter.x = (int) (BoardCenter.x * scale_x); BoardCenter.x = (int) (BoardCenter.x * scale_x);
BoardCenter.y = (int) (BoardCenter.y * scale_y); BoardCenter.y = (int) (BoardCenter.y * scale_y);
if( g_PlotScaleOpt != 1 ) Center = TRUE; // Echelle != 1 if( g_PlotScaleOpt != 1 )
Center = TRUE; // Echelle != 1
/* Calcul du cadrage */ /* Calcul du cadrage */
marge = (int) (marge * SCALE_HPGL); marge = (int) (marge * SCALE_HPGL);
if( Center ) if( Center )
g_PlotOffset.x = (int) (-SheetSize.x / 2 * SCALE_HPGL) + g_PlotOffset.x = (int) (-SheetSize.x / 2 * SCALE_HPGL) +
BoardCenter.x + marge; BoardCenter.x + marge;
switch( g_PlotOrient ) switch( g_PlotOrient )
{ {
default: default:
@ -117,12 +121,15 @@ bool Center = FALSE;
case PLOT_MIROIR: case PLOT_MIROIR:
if( Center ) if( Center )
g_PlotOffset.y = (int) (-SheetSize.y / 2 * SCALE_HPGL) + BoardCenter.y; g_PlotOffset.y = (int) (-SheetSize.y / 2 * SCALE_HPGL) + BoardCenter.y;
else g_PlotOffset.y = (int)((- SheetSize.y + else
m_Pcb->m_BoundaryBox.GetBottom() + m_Pcb->m_BoundaryBox.GetY()) * SCALE_HPGL); g_PlotOffset.y = (int) ( ( -SheetSize.y +
m_Pcb->m_BoundaryBox.GetBottom() +
m_Pcb->m_BoundaryBox.GetY() ) * SCALE_HPGL );
break; break;
} }
InitPlotParametresHPGL( g_PlotOffset, scale_x, scale_y, g_PlotOrient ); InitPlotParametresHPGL( g_PlotOffset, scale_x, scale_y, g_PlotOrient );
switch( Layer ) switch( Layer )
{ {
case CUIVRE_N: case CUIVRE_N:
@ -140,7 +147,8 @@ bool Center = FALSE;
case LAYER_N_13: case LAYER_N_13:
case LAYER_N_14: case LAYER_N_14:
case LAYER_N_15: case LAYER_N_15:
case CMP_N : Plot_Layer_HPGL(dest,g_TabOneLayerMask[Layer], 0, 1, modetrace); case CMP_N:
Plot_Layer_HPGL( dest, g_TabOneLayerMask[Layer], 0, 1, modetrace );
break; break;
case SILKSCREEN_N_CU: case SILKSCREEN_N_CU:
@ -152,8 +160,10 @@ bool Center = FALSE;
case SOLDERMASK_N_CMP: /* Trace du vernis epargne */ case SOLDERMASK_N_CMP: /* Trace du vernis epargne */
{ {
int tracevia; int tracevia;
if (g_DrawViaOnMaskLayer) tracevia = 1; if( g_DrawViaOnMaskLayer )
else tracevia = 0; tracevia = 1;
else
tracevia = 0;
Plot_Layer_HPGL( dest, g_TabOneLayerMask[Layer], Plot_Layer_HPGL( dest, g_TabOneLayerMask[Layer],
g_DesignSettings.m_MaskMargin, tracevia, modetrace ); g_DesignSettings.m_MaskMargin, tracevia, modetrace );
} }
@ -168,10 +178,10 @@ bool Center = FALSE;
Plot_Serigraphie( PLOT_FORMAT_HPGL, dest, g_TabOneLayerMask[Layer] ); Plot_Serigraphie( PLOT_FORMAT_HPGL, dest, g_TabOneLayerMask[Layer] );
break; break;
} }
/* fin */ /* fin */
CloseFileHPGL( dest ); CloseFileHPGL( dest );
setlocale( LC_NUMERIC, "" ); setlocale( LC_NUMERIC, "" );
} }
@ -181,7 +191,7 @@ void WinEDA_BasePcbFrame::Plot_Layer_HPGL(FILE * File,int masque_layer,
/*********************************************************************/ /*********************************************************************/
/* Trace en format HPGL. d'une couche cuivre ou masque /* Trace en format HPGL. d'une couche cuivre ou masque
1 unite HPGL = 0.98 mils ( 1 mil = 1.02041 unite HPGL ) . * 1 unite HPGL = 0.98 mils ( 1 mil = 1.02041 unite HPGL ) .
*/ */
{ {
wxSize size; wxSize size;
@ -189,14 +199,14 @@ wxPoint start, end;
MODULE* Module; MODULE* Module;
D_PAD* PtPad; D_PAD* PtPad;
TRACK* pts; TRACK* pts;
EDA_BaseStruct * PtStruct; BOARD_ITEM* PtStruct;
wxString msg; wxString msg;
masque_layer |= EDGE_LAYER; /* Les elements de la couche EDGE sont tj traces */ masque_layer |= EDGE_LAYER; /* Les elements de la couche EDGE sont tj traces */
/* trace des elements type Drawings Pcb : */ /* trace des elements type Drawings Pcb : */
PtStruct = m_Pcb->m_Drawings; PtStruct = m_Pcb->m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext ) for( ; PtStruct != NULL; PtStruct = PtStruct->Next() )
{ {
switch( PtStruct->m_StructType ) switch( PtStruct->m_StructType )
{ {
@ -229,7 +239,6 @@ wxString msg;
} }
} }
/* Trace des Elements des modules autres que pads */ /* Trace des Elements des modules autres que pads */
nb_items = 0; nb_items = 0;
Affiche_1_Parametre( this, 48, wxT( "DrawMod" ), wxEmptyString, GREEN ); Affiche_1_Parametre( this, 48, wxT( "DrawMod" ), wxEmptyString, GREEN );
@ -237,17 +246,18 @@ wxString msg;
for( ; Module != NULL; Module = (MODULE*) Module->Pnext ) for( ; Module != NULL; Module = (MODULE*) Module->Pnext )
{ {
PtStruct = Module->m_Drawings; PtStruct = Module->m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext ) for( ; PtStruct != NULL; PtStruct = PtStruct->Next() )
{ {
switch( PtStruct->m_StructType ) switch( PtStruct->m_StructType )
{ {
case TYPEEDGEMODULE: case TYPEEDGEMODULE:
if( masque_layer & if( masque_layer &
g_TabOneLayerMask[((EDGE_MODULE*)PtStruct)->m_Layer] ) g_TabOneLayerMask[ PtStruct->GetLayer() ] )
Plot_1_EdgeModule( PLOT_FORMAT_HPGL, (EDGE_MODULE*) PtStruct ); Plot_1_EdgeModule( PLOT_FORMAT_HPGL, (EDGE_MODULE*) PtStruct );
break; break;
default: break; default:
break;
} }
} }
} }
@ -271,6 +281,7 @@ wxString msg;
size.x += garde * 2; size.y += garde * 2; size.x += garde * 2; size.y += garde * 2;
nb_items++; nb_items++;
switch( PtPad->m_PadShape & 0x7F ) switch( PtPad->m_PadShape & 0x7F )
{ {
case CIRCLE: case CIRCLE:
@ -298,6 +309,7 @@ wxString msg;
PtPad->m_Orient, modetrace ); PtPad->m_Orient, modetrace );
break; break;
} }
msg.Printf( wxT( "%d" ), nb_items ); msg.Printf( wxT( "%d" ), nb_items );
Affiche_1_Parametre( this, 48, wxT( "Pads" ), msg, GREEN ); Affiche_1_Parametre( this, 48, wxT( "Pads" ), msg, GREEN );
} }
@ -313,16 +325,21 @@ wxString msg;
for( pts = m_Pcb->m_Track; pts != NULL; pts = (TRACK*) pts->Pnext ) for( pts = m_Pcb->m_Track; pts != NULL; pts = (TRACK*) pts->Pnext )
{ {
if( pts->m_StructType != TYPEVIA ) continue; if( pts->m_StructType != TYPEVIA )
continue;
SEGVIA* Via = (SEGVIA*) pts; SEGVIA* Via = (SEGVIA*) pts;
/* vias not plotted if not on selected layer, but if layer /* vias not plotted if not on selected layer, but if layer
== SOLDERMASK_LAYER_CU or SOLDERMASK_LAYER_CMP, vias are drawn , * == SOLDERMASK_LAYER_CU or SOLDERMASK_LAYER_CMP, vias are drawn ,
if they are on a external copper layer * if they are on a external copper layer
*/ */
int via_mask_layer = Via->ReturnMaskLayer(); int via_mask_layer = Via->ReturnMaskLayer();
if ( (via_mask_layer & CUIVRE_LAYER ) ) via_mask_layer |= SOLDERMASK_LAYER_CU; if( (via_mask_layer & CUIVRE_LAYER ) )
if ( (via_mask_layer & CMP_LAYER ) ) via_mask_layer |= SOLDERMASK_LAYER_CMP; via_mask_layer |= SOLDERMASK_LAYER_CU;
if( (via_mask_layer & masque_layer) == 0 ) continue; if( (via_mask_layer & CMP_LAYER ) )
via_mask_layer |= SOLDERMASK_LAYER_CMP;
if( (via_mask_layer & masque_layer) == 0 )
continue;
start = Via->m_Start; start = Via->m_Start;
size.x = Via->m_Width + (garde * 2); size.x = Via->m_Width + (garde * 2);
@ -331,6 +348,7 @@ wxString msg;
nb_items++; msg.Printf( wxT( "%d" ), nb_items ); nb_items++; msg.Printf( wxT( "%d" ), nb_items );
Affiche_1_Parametre( this, 56, wxT( "Vias" ), msg, RED ); Affiche_1_Parametre( this, 56, wxT( "Vias" ), msg, RED );
} }
fputs( "PU;\n", dest ); fputs( "PU;\n", dest );
} }
@ -339,9 +357,11 @@ wxString msg;
Affiche_1_Parametre( this, 64, wxT( "Tracks " ), wxEmptyString, YELLOW ); Affiche_1_Parametre( this, 64, wxT( "Tracks " ), wxEmptyString, YELLOW );
for( pts = m_Pcb->m_Track; pts != NULL; pts = (TRACK*) pts->Pnext ) for( pts = m_Pcb->m_Track; pts != NULL; pts = (TRACK*) pts->Pnext )
{ {
if ( pts->m_StructType == TYPEVIA ) continue ; if( pts->m_StructType == TYPEVIA )
continue;
if( (g_TabOneLayerMask[pts->m_Layer] & masque_layer) == 0 ) continue; if( (g_TabOneLayerMask[pts->GetLayer()] & masque_layer) == 0 )
continue;
size.x = size.y = pts->m_Width; size.x = size.y = pts->m_Width;
start = pts->m_Start; start = pts->m_Start;
@ -358,7 +378,7 @@ wxString msg;
while( ( size.x -= (int) ( (pen_rayon - pen_recouvrement) * 2 ) ) > 0 ) while( ( size.x -= (int) ( (pen_rayon - pen_recouvrement) * 2 ) ) > 0 )
{ {
trace_1_segment_HPGL( start.x, start.y, end.x, end.y, trace_1_segment_HPGL( start.x, start.y, end.x, end.y,
max(size.x,pen_diam) ) ; MAX( size.x, pen_diam ) );
} }
} }
@ -374,7 +394,7 @@ wxString msg;
Affiche_1_Parametre( this, 64, wxT( "Zones " ), wxEmptyString, YELLOW ); Affiche_1_Parametre( this, 64, wxT( "Zones " ), wxEmptyString, YELLOW );
for( pts = m_Pcb->m_Zone; pts != NULL; pts = (TRACK*) pts->Pnext ) for( pts = m_Pcb->m_Zone; pts != NULL; pts = (TRACK*) pts->Pnext )
{ {
if( g_TabOneLayerMask[pts->m_Layer] & masque_layer) if( g_TabOneLayerMask[pts->GetLayer()] & masque_layer )
{ {
size.x = size.y = pts->m_Width; size.x = size.y = pts->m_Width;
start = pts->m_Start; start = pts->m_Start;
@ -391,7 +411,7 @@ wxString msg;
while( ( size.x -= (int) ( (pen_rayon - pen_recouvrement) * 2 ) ) > 0 ) while( ( size.x -= (int) ( (pen_rayon - pen_recouvrement) * 2 ) ) > 0 )
{ {
trace_1_segment_HPGL( start.x, start.y, end.x, end.y, trace_1_segment_HPGL( start.x, start.y, end.x, end.y,
max(size.x,pen_diam)) ; MAX( size.x, pen_diam ) );
} }
} }
@ -414,11 +434,12 @@ int rayon, deltaxy , cx, cy;
int trace_orient = orient; int trace_orient = orient;
/* la pastille est ramenee a une pastille ovale avec size.y > size.x /* la pastille est ramenee a une pastille ovale avec size.y > size.x
( ovale vertical en orientation 0 ) */ * ( ovale vertical en orientation 0 ) */
if( size.x > size.y ) if( size.x > size.y )
{ {
EXCHG( size.x, size.y ); trace_orient += 900; EXCHG( size.x, size.y ); trace_orient += 900;
if ( orient >= 3600 ) trace_orient -= 3600; if( orient >= 3600 )
trace_orient -= 3600;
} }
deltaxy = size.y - size.x; /* = distance entre centres de l'ovale */ deltaxy = size.y - size.x; /* = distance entre centres de l'ovale */
rayon = size.x / 2; rayon = size.x / 2;
@ -435,7 +456,6 @@ int trace_orient = orient;
RotatePoint( &cx, &cy, trace_orient ); RotatePoint( &cx, &cy, trace_orient );
trace_1_pastille_RONDE_HPGL( wxPoint( cx + pos.x, cy + pos.y ), size.x, modetrace ); trace_1_pastille_RONDE_HPGL( wxPoint( cx + pos.x, cy + pos.y ), size.x, modetrace );
} }
else /* Trace en mode FILAIRE */ else /* Trace en mode FILAIRE */
{ {
cx = -rayon; cy = -deltaxy / 2; cx = -rayon; cy = -deltaxy / 2;
@ -490,6 +510,7 @@ int rayon, delta;
rayon = 0; nb_plot_erreur++; Affiche_erreur( nb_plot_erreur ); rayon = 0; nb_plot_erreur++; Affiche_erreur( nb_plot_erreur );
} }
wxSize rsize( rayon, rayon ); wxSize rsize( rayon, rayon );
UserToDeviceSize( rsize ); UserToDeviceSize( rsize );
Plume_HPGL( 'U' ); Plume_HPGL( 'U' );
@ -511,14 +532,16 @@ int rayon, delta;
Plume_HPGL( 'U' ); return; Plume_HPGL( 'U' ); return;
} }
/***************************************************************/ /***************************************************************/
void PlotRectangularPad_HPGL( wxPoint padpos, wxSize padsize, void PlotRectangularPad_HPGL( wxPoint padpos, wxSize padsize,
int orient, int modetrace ) int orient, int modetrace )
/****************************************************************/ /****************************************************************/
/* /*
Trace 1 pad rectangulaire vertical ou horizontal ( Pad rectangulaire ) * Trace 1 pad rectangulaire vertical ou horizontal ( Pad rectangulaire )
donne par son centre et ses dimensions X et Y * donne par son centre et ses dimensions X et Y
Units are user units * Units are user units
*/ */
{ {
wxSize size; wxSize size;
@ -536,7 +559,9 @@ int ox, oy, fx, fy;
{ {
nb_plot_erreur++; Affiche_erreur( nb_plot_erreur ); nb_plot_erreur++; Affiche_erreur( nb_plot_erreur );
} }
if ( size.x < 0 ) size.x = 0 ; if ( size.y < 0 ) size.y = 0 ; if( size.x < 0 )
size.x = 0;if( size.y < 0 )
size.y = 0;
/* Si une des dimensions est nulle, le trace se reduit a 1 trait */ /* Si une des dimensions est nulle, le trace se reduit a 1 trait */
if( size.x == 0 ) if( size.x == 0 )
@ -589,7 +614,9 @@ int ox, oy, fx, fy;
while( (size.x > 0) && (size.y > 0) ) while( (size.x > 0) && (size.y > 0) )
{ {
size.x -= delta; size.y -= delta; size.x -= delta; size.y -= delta;
if ( size.x < 0 ) size.x = 0 ; if ( size.y < 0 ) size.y = 0 ; if( size.x < 0 )
size.x = 0;if( size.y < 0 )
size.y = 0;
ox = padpos.x - size.x; oy = padpos.y - size.y; ox = padpos.x - size.x; oy = padpos.y - size.y;
RotatePoint( &ox, &oy, padpos.x, padpos.y, orient ); RotatePoint( &ox, &oy, padpos.x, padpos.y, orient );
@ -609,6 +636,7 @@ int ox, oy, fx, fy;
Move_Plume_HPGL( wxPoint( ox, oy ), 'D' ); Move_Plume_HPGL( wxPoint( ox, oy ), 'D' );
} }
Plume_HPGL( 'U' ); Plume_HPGL( 'U' );
} }
@ -617,22 +645,23 @@ int ox, oy, fx, fy;
void trace_1_pad_TRAPEZE_HPGL( wxPoint padpos, wxSize size, wxSize delta, void trace_1_pad_TRAPEZE_HPGL( wxPoint padpos, wxSize size, wxSize delta,
int orient, int modetrace ) int orient, int modetrace )
/********************************************************************/ /********************************************************************/
/*
Trace 1 pad trapezoidal donne par :
son centre padpos.x,padpos.y
ses dimensions dimX et dimY
les variations deltaX et deltaY
son orientation orient et 0.1 degres
le mode de trace (FILLED, SKETCH, FILAIRE)
Le trace n'est fait que pour un trapeze, c.a.d que deltaX ou deltaY
= 0.
les notation des sommets sont ( vis a vis de la table tracante ) /*
0 ------------- 3 * Trace 1 pad trapezoidal donne par :
. . * son centre padpos.x,padpos.y
. . * ses dimensions dimX et dimY
. . * les variations deltaX et deltaY
1 --- 2 * son orientation orient et 0.1 degres
* le mode de trace (FILLED, SKETCH, FILAIRE)
* Le trace n'est fait que pour un trapeze, c.a.d que deltaX ou deltaY
* = 0.
*
* les notation des sommets sont ( vis a vis de la table tracante )
* 0 ------------- 3
* . .
* . .
* . .
* 1 --- 2
*/ */
{ {
int ii, jj; int ii, jj;
@ -641,9 +670,10 @@ wxPoint coord[4]; /* coord reelles des sommets du trapeze a tracer */
float fangle; /* angle d'inclinaison des cotes du trapeze */ float fangle; /* angle d'inclinaison des cotes du trapeze */
int rayon; /* rayon de la plume */ int rayon; /* rayon de la plume */
int moveX, moveY;/* variation de position plume selon axe X et Y , lors int moveX, moveY;/* variation de position plume selon axe X et Y , lors
du remplissage du trapeze */ * du remplissage du trapeze */
rayon = (int) pen_rayon; if (modetrace == FILAIRE) rayon = 0; rayon = (int) pen_rayon; if( modetrace == FILAIRE )
rayon = 0;
moveX = moveY = rayon; moveX = moveY = rayon;
size.x /= 2; size.y /= 2; size.x /= 2; size.y /= 2;
@ -660,7 +690,6 @@ int moveX, moveY; /* variation de position plume selon axe X et Y , lors
fangle = atan2( (float) (polygone[1].y - polygone[0].y), fangle = atan2( (float) (polygone[1].y - polygone[0].y),
(float) (polygone[1].x - polygone[0].x) ) / 2; (float) (polygone[1].x - polygone[0].x) ) / 2;
} }
else else
{ {
fangle = atan2( (float) (polygone[3].y - polygone[0].y), fangle = atan2( (float) (polygone[3].y - polygone[0].y),
@ -718,8 +747,8 @@ int moveX, moveY; /* variation de position plume selon axe X et Y , lors
polygone[3].x -= moveX; polygone[3].y -= moveY; polygone[3].x -= moveX; polygone[3].y -= moveY;
/* Test de limitation de variation des dimensions : /* Test de limitation de variation des dimensions :
si les sommets se "croisent", il ne faut plus modifier les * si les sommets se "croisent", il ne faut plus modifier les
coordonnees correspondantes */ * coordonnees correspondantes */
if( polygone[0].x > polygone[3].x ) if( polygone[0].x > polygone[3].x )
{ /* croisement sur axe X des 2 sommets 0 et 3 */ { /* croisement sur axe X des 2 sommets 0 et 3 */
polygone[0].x = polygone[3].x = 0; polygone[0].x = polygone[3].x = 0;
@ -761,13 +790,13 @@ void trace_1_segment_HPGL(int pos_X0,int pos_Y0,int pos_X1,int pos_Y1,
/********************************************************************/ /********************************************************************/
/* Trace 1 rectangle donne par son axe et son epaisseur (piste rectangulaire) /* Trace 1 rectangle donne par son axe et son epaisseur (piste rectangulaire)
en mode SKETCH * en mode SKETCH
*/ */
{ {
float alpha; /* angle de l'axe du rectangle */ float alpha; /* angle de l'axe du rectangle */
wxSize size; /* coord relatives a l'origine du segment de sa fin */ wxSize size; /* coord relatives a l'origine du segment de sa fin */
int dh; /* demi epaisseur du segment compte tenu de la int dh; /* demi epaisseur du segment compte tenu de la
largeur de la plume */ * largeur de la plume */
int dx_rot; /* coord du segment en repere modifie ( size.y_rot etant nul )*/ int dx_rot; /* coord du segment en repere modifie ( size.y_rot etant nul )*/
float sin_alpha, cos_alpha; float sin_alpha, cos_alpha;
@ -802,7 +831,8 @@ float sin_alpha, cos_alpha ;
} }
else if( size.x == 0 ) /* vertical */ else if( size.x == 0 ) /* vertical */
{ {
if( size.y < 0 ) dh = -dh ; if( size.y < 0 )
dh = -dh;
Move_Plume_HPGL( wxPoint( pos_X0 - dh, pos_Y0 ), 'U' ); Move_Plume_HPGL( wxPoint( pos_X0 - dh, pos_Y0 ), 'U' );
Move_Plume_HPGL( wxPoint( pos_X1 - dh, pos_Y1 ), 'D' ); Move_Plume_HPGL( wxPoint( pos_X1 - dh, pos_Y1 ), 'D' );
Move_Plume_HPGL( wxPoint( pos_X1 + dh, pos_Y1 ), 'D' ); Move_Plume_HPGL( wxPoint( pos_X1 + dh, pos_Y1 ), 'D' );
@ -812,15 +842,15 @@ float sin_alpha, cos_alpha ;
else /* piste inclinee */ else /* piste inclinee */
{ {
/* On calcule les coord des extremites du rectangle dans le repere /* On calcule les coord des extremites du rectangle dans le repere
a axe x confondu avec l'axe du rect. puis on revient dans le repere * a axe x confondu avec l'axe du rect. puis on revient dans le repere
de trace par 2 rotations inverses * de trace par 2 rotations inverses
coord : xrot = x*cos + y*sin * coord : xrot = x*cos + y*sin
yrot = y*cos - x*sin * yrot = y*cos - x*sin
*
avec ici yrot = 0 puisque le segment est horizontal dans le nouveau repere * avec ici yrot = 0 puisque le segment est horizontal dans le nouveau repere
Transformee inverse : * Transformee inverse :
coord : x = xrot*cos - yrot*sin * coord : x = xrot*cos - yrot*sin
y = yrot*cos + xrot*sin * y = yrot*cos + xrot*sin
*/ */
int dx0, dy0, dx1, dy1; int dx0, dy0, dx1, dy1;
@ -868,6 +898,3 @@ float sin_alpha, cos_alpha ;
} }
Plume_HPGL( 'U' ); Plume_HPGL( 'U' );
} }

28
pcbnew/plotps.cpp
View File

@ -17,6 +17,7 @@
// Routines Locales // Routines Locales
static void PrintDrillMark( BOARD* Pcb ); static void PrintDrillMark( BOARD* Pcb );
static Ki_PageDescr* SheetPS; static Ki_PageDescr* SheetPS;
// variables locales: // variables locales:
@ -60,6 +61,7 @@ int PlotMarge_in_mils = 0;
Center = TRUE; // Echelle != 1 donc trace centree du PCB Center = TRUE; // Echelle != 1 donc trace centree du PCB
modetrace = Plot_Mode; modetrace = Plot_Mode;
scale_format = 1.0; scale_format = 1.0;
// Set default line width // Set default line width
if( g_PlotLine_Width < 1 ) if( g_PlotLine_Width < 1 )
g_PlotLine_Width = 1; g_PlotLine_Width = 1;
@ -83,6 +85,7 @@ int PlotMarge_in_mils = 0;
// calcul de l'offset de trace: // calcul de l'offset de trace:
// calcul du cadrage horizontal du mode paysage ( val algebr. plus grande = decalage a gauche ) // calcul du cadrage horizontal du mode paysage ( val algebr. plus grande = decalage a gauche )
g_PlotOffset.x = PlotMarge_in_mils * U_PCB; g_PlotOffset.x = PlotMarge_in_mils * U_PCB;
// cadrage vertical du mode paysage ( val algebr. plus grande = decalage vers le haut ) // cadrage vertical du mode paysage ( val algebr. plus grande = decalage vers le haut )
g_PlotOffset.y = PaperSize.y - PlotMarge_in_mils * U_PCB; g_PlotOffset.y = PaperSize.y - PlotMarge_in_mils * U_PCB;
@ -119,7 +122,7 @@ int PlotMarge_in_mils = 0;
noprint_size += 500 * U_PCB; noprint_size += 500 * U_PCB;
Xscale = (float) ( PaperSize.x - noprint_size ) / BoardSize.x; Xscale = (float) ( PaperSize.x - noprint_size ) / BoardSize.x;
Yscale = (float) ( PaperSize.y - noprint_size ) / BoardSize.y; Yscale = (float) ( PaperSize.y - noprint_size ) / BoardSize.y;
scale_x = scale_y = min( Xscale, Yscale ); scale_x = scale_y = MIN( Xscale, Yscale );
} }
BoardCenter.x = (int) (BoardCenter.x * scale_x); BoardCenter.x = (int) (BoardCenter.x * scale_x);
@ -214,6 +217,7 @@ int PlotMarge_in_mils = 0;
Plot_Serigraphie( PLOT_FORMAT_POST, dest, g_TabOneLayerMask[Layer] ); Plot_Serigraphie( PLOT_FORMAT_POST, dest, g_TabOneLayerMask[Layer] );
break; break;
} }
// fin // fin
CloseFilePS( dest ); CloseFilePS( dest );
setlocale( LC_NUMERIC, "" ); setlocale( LC_NUMERIC, "" );
@ -233,14 +237,14 @@ wxSize size;
MODULE* Module; MODULE* Module;
D_PAD* PtPad; D_PAD* PtPad;
TRACK* pts; TRACK* pts;
EDA_BaseStruct * PtStruct; BOARD_ITEM* PtStruct;
wxString msg; wxString msg;
masque_layer |= EDGE_LAYER; // Les elements de la couche EDGE sont tj traces masque_layer |= EDGE_LAYER; // Les elements de la couche EDGE sont tj traces
// trace des elements type Drawings Pcb : // trace des elements type Drawings Pcb :
PtStruct = m_Pcb->m_Drawings; PtStruct = m_Pcb->m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext ) for( ; PtStruct != NULL; PtStruct = PtStruct->Next() )
{ {
switch( PtStruct->m_StructType ) switch( PtStruct->m_StructType )
{ {
@ -268,7 +272,8 @@ wxString msg;
break; break;
default: default:
DisplayError(this, wxT("WinEDA_BasePcbFrame::Plot_Layer_PS() : Unexpected Draw Type")); DisplayError( this,
wxT( "WinEDA_BasePcbFrame::Plot_Layer_PS() : Unexpected Draw Type" ) );
break; break;
} }
} }
@ -280,12 +285,12 @@ wxString msg;
for( ; Module != NULL; Module = (MODULE*) Module->Pnext ) for( ; Module != NULL; Module = (MODULE*) Module->Pnext )
{ {
PtStruct = Module->m_Drawings; PtStruct = Module->m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext ) for( ; PtStruct != NULL; PtStruct = PtStruct->Next() )
{ {
switch( PtStruct->m_StructType ) switch( PtStruct->m_StructType )
{ {
case TYPEEDGEMODULE: case TYPEEDGEMODULE:
if( masque_layer & g_TabOneLayerMask[((EDGE_MODULE*)PtStruct)->m_Layer] ) if( masque_layer & g_TabOneLayerMask[ PtStruct->GetLayer() ] )
Plot_1_EdgeModule( PLOT_FORMAT_POST, (EDGE_MODULE*) PtStruct ); Plot_1_EdgeModule( PLOT_FORMAT_POST, (EDGE_MODULE*) PtStruct );
break; break;
@ -338,10 +343,12 @@ wxString msg;
trace_1_pad_rectangulaire_POST( pos, size, PtPad->m_Orient, modetrace ); trace_1_pad_rectangulaire_POST( pos, size, PtPad->m_Orient, modetrace );
break; break;
} }
msg.Printf( wxT( "%d" ), nb_items ); msg.Printf( wxT( "%d" ), nb_items );
Affiche_1_Parametre( this, 48, wxT( "Pads" ), msg, GREEN ); Affiche_1_Parametre( this, 48, wxT( "Pads" ), msg, GREEN );
} }
} }
// trace des VIAS : // trace des VIAS :
if( tracevia ) if( tracevia )
{ {
@ -352,6 +359,7 @@ wxString msg;
if( pts->m_StructType != TYPEVIA ) if( pts->m_StructType != TYPEVIA )
continue; continue;
SEGVIA* Via = (SEGVIA*) pts; SEGVIA* Via = (SEGVIA*) pts;
// vias not plotted if not on selected layer, but if layer // vias not plotted if not on selected layer, but if layer
// == SOLDERMASK_LAYER_CU or SOLDERMASK_LAYER_CMP, vias are drawn, // == SOLDERMASK_LAYER_CU or SOLDERMASK_LAYER_CMP, vias are drawn,
// if they are on a external copper layer // if they are on a external copper layer
@ -371,6 +379,7 @@ wxString msg;
Affiche_1_Parametre( this, 56, wxEmptyString, msg, RED ); Affiche_1_Parametre( this, 56, wxEmptyString, msg, RED );
} }
} }
// trace des pistes et zones: // trace des pistes et zones:
nb_items = 0; nb_items = 0;
Affiche_1_Parametre( this, 64, _( "Tracks" ), wxEmptyString, YELLOW ); Affiche_1_Parametre( this, 64, _( "Tracks" ), wxEmptyString, YELLOW );
@ -380,7 +389,7 @@ wxString msg;
if( pts->m_StructType == TYPEVIA ) if( pts->m_StructType == TYPEVIA )
continue; continue;
if( (g_TabOneLayerMask[pts->m_Layer] & masque_layer) == 0 ) if( (g_TabOneLayerMask[pts->GetLayer()] & masque_layer) == 0 )
continue; continue;
size.x = size.y = pts->m_Width; size.x = size.y = pts->m_Width;
pos = pts->m_Start; pos = pts->m_Start;
@ -398,7 +407,7 @@ wxString msg;
for( pts = m_Pcb->m_Zone; pts != NULL; pts = (TRACK*) pts->Pnext ) for( pts = m_Pcb->m_Zone; pts != NULL; pts = (TRACK*) pts->Pnext )
{ {
if( (g_TabOneLayerMask[pts->m_Layer] & masque_layer) == 0 ) if( (g_TabOneLayerMask[pts->GetLayer()] & masque_layer) == 0 )
continue; continue;
size.x = size.y = pts->m_Width; size.x = size.y = pts->m_Width;
pos = pts->m_Start; pos = pts->m_Start;
@ -555,6 +564,7 @@ void trace_1_pastille_RONDE_POST(wxPoint centre, int diametre, int modetrace)
*/ */
{ {
int rayon, w; int rayon, w;
wxSize diam( diametre, diametre ); wxSize diam( diametre, diametre );
UserToDeviceCoordinate( centre ); UserToDeviceCoordinate( centre );
@ -735,6 +745,7 @@ int l_pen; // diam spot (plume)
if( modetrace == FILAIRE || Plot_Mode == FILAIRE ) if( modetrace == FILAIRE || Plot_Mode == FILAIRE )
{ {
wxSize lsize( g_PlotLine_Width, g_PlotLine_Width ); wxSize lsize( g_PlotLine_Width, g_PlotLine_Width );
UserToDeviceSize( lsize ); UserToDeviceSize( lsize );
l_pen = lsize.x; l_pen = lsize.x;
} }
@ -777,4 +788,3 @@ int l_pen; // diam spot (plume)
fprintf( dest, "fill " ); fprintf( dest, "fill " );
fprintf( dest, "stroke\n" ); fprintf( dest, "stroke\n" );
} }

572
pcbnew/ratsnest.cpp
View File

File diff suppressed because it is too large Load Diff

143
pcbnew/router.cpp
View File

@ -1,6 +1,7 @@
/****************************************/ /****************************************/
/* EDITEUR de PCB: Menus d'AUTOROUTAGE: */ /* EDITEUR de PCB: Menus d'AUTOROUTAGE: */
/****************************************/ /****************************************/
// #define ROUTER // #define ROUTER
#include "fctsys.h" #include "fctsys.h"
@ -27,7 +28,6 @@ static void ReturnNbViasAndTracks(BOARD * Pcb, int netcode, int * nb_vias, int *
static int min_layer, max_layer; static int min_layer, max_layer;
/******************************************/ /******************************************/
void WinEDA_PcbFrame::GlobalRoute( wxDC* DC ) void WinEDA_PcbFrame::GlobalRoute( wxDC* DC )
/******************************************/ /******************************************/
@ -120,7 +120,8 @@ int net_number;
{ {
int dir; int dir;
dir = 3; /* horizontal */ dir = 3; /* horizontal */
if (ii & 1 ) dir = 1; /* vertical */ if( ii & 1 )
dir = 1; /* vertical */
fprintf( outfile, "l %d %d\n", ii, dir ); /* layer direction record */ fprintf( outfile, "l %d %d\n", ii, dir ); /* layer direction record */
} }
@ -146,18 +147,20 @@ static void Out_Pads(BOARD * Pcb, FILE * outfile)
/************************************************/ /************************************************/
{ {
D_PAD* pt_pad; D_PAD* pt_pad;
//MODULE * Module; //MODULE * Module;
int netcode, mod_num, nb_pads, plink; int netcode, mod_num, nb_pads, plink;
LISTE_PAD* pt_liste_pad, * pt_start_liste, LISTE_PAD* pt_liste_pad, * pt_start_liste,
* pt_end_liste, * pt_liste_pad_limite; * pt_end_liste, * pt_liste_pad_limite;
int pin_min_layer, pin_max_layer; int pin_min_layer, pin_max_layer;
int no_conn = Pcb->m_NbPads + 1;/* valeur incrementee pour indiquer int no_conn = Pcb->m_NbPads + 1;/* valeur incrementee pour indiquer
que le pad n'est pas deja connecte a une piste*/ * que le pad n'est pas deja connecte a une piste*/
pt_liste_pad = pt_start_liste = Pcb->m_Pads; pt_liste_pad = pt_start_liste = Pcb->m_Pads;
pt_liste_pad_limite = pt_start_liste + Pcb->m_NbPads; pt_liste_pad_limite = pt_start_liste + Pcb->m_NbPads;
if( pt_liste_pad == NULL ) return; if( pt_liste_pad == NULL )
return;
netcode = (*pt_liste_pad)->m_NetCode; netcode = (*pt_liste_pad)->m_NetCode;
nb_pads = 1; plink = 0; nb_pads = 1; plink = 0;
@ -166,8 +169,10 @@ int no_conn = Pcb->m_NbPads+1; /* valeur incrementee pour indiquer
/* Recherche de la fin de la liste des pads du net courant */ /* Recherche de la fin de la liste des pads du net courant */
for( pt_end_liste = pt_liste_pad + 1; ; pt_end_liste++ ) for( pt_end_liste = pt_liste_pad + 1; ; pt_end_liste++ )
{ {
if (pt_end_liste >= pt_liste_pad_limite ) break ; if( pt_end_liste >= pt_liste_pad_limite )
if ((*pt_end_liste)->m_NetCode != netcode ) break ; break;
if( (*pt_end_liste)->m_NetCode != netcode )
break;
nb_pads++; nb_pads++;
} }
@ -195,7 +200,8 @@ int no_conn = Pcb->m_NbPads+1; /* valeur incrementee pour indiquer
netcode = pt_pad->m_NetCode; netcode = pt_pad->m_NetCode;
plink = pt_pad->m_physical_connexion; plink = pt_pad->m_physical_connexion;
/* plink = numero unique si pad non deja connecte a une piste */ /* plink = numero unique si pad non deja connecte a une piste */
if (plink <= 0 ) plink = no_conn++; if( plink <= 0 )
plink = no_conn++;
if( netcode <= 0 ) /* pad non connecte */ if( netcode <= 0 ) /* pad non connecte */
fprintf( outfile, "u 0" ); fprintf( outfile, "u 0" );
@ -226,8 +232,11 @@ int no_conn = Pcb->m_NbPads+1; /* valeur incrementee pour indiquer
case SMD: case SMD:
fprintf( outfile, " %d", 1 ); fprintf( outfile, " %d", 1 );
break; break;
case CONN: fprintf(outfile," %d", 2);
case CONN:
fprintf( outfile, " %d", 2 );
break; break;
case P_HOLE: case P_HOLE:
case MECA: case MECA:
fprintf( outfile, " %d", 4 ); fprintf( outfile, " %d", 4 );
@ -252,6 +261,7 @@ int no_conn = Pcb->m_NbPads+1; /* valeur incrementee pour indiquer
/* output layer size record */ /* output layer size record */
fprintf( outfile, "q" ); fprintf( outfile, "q" );
switch( pt_pad->m_PadShape ) /* out type, dims */ switch( pt_pad->m_PadShape ) /* out type, dims */
{ {
case CIRCLE: case CIRCLE:
@ -265,22 +275,29 @@ int no_conn = Pcb->m_NbPads+1; /* valeur incrementee pour indiquer
int lmax = pt_pad->m_Size.x; int lmax = pt_pad->m_Size.x;
int lmin = pt_pad->m_Size.y; int lmin = pt_pad->m_Size.y;
int angle = pt_pad->m_Orient / 10; int angle = pt_pad->m_Orient / 10;
while (angle < 0 ) angle += 180; while( angle < 0 )
while (angle > 180 ) angle -= 180; angle += 180;
while( angle > 180 )
angle -= 180;
while( angle > 135 ) while( angle > 135 )
{ {
angle -= 90; angle -= 90;
EXCHG( lmax, lmin ); EXCHG( lmax, lmin );
} }
fprintf( outfile, " r %d %d %d", fprintf( outfile, " r %d %d %d",
angle, angle,
lmax / PSCALE, lmin / PSCALE ); lmax / PSCALE, lmin / PSCALE );
break; break;
} }
/* layers */ /* layers */
fprintf( outfile, " %d %d\n", pin_min_layer, pin_max_layer ); fprintf( outfile, " %d %d\n", pin_min_layer, pin_max_layer );
}
} /* fin generation liste pads pour 1 net */ /* fin generation liste pads pour 1 net */
if( netcode ) if( netcode )
{ {
@ -300,6 +317,7 @@ int no_conn = Pcb->m_NbPads+1; /* valeur incrementee pour indiquer
static void ReturnNbViasAndTracks( BOARD* Pcb, int netcode, int* nb_vias, static void ReturnNbViasAndTracks( BOARD* Pcb, int netcode, int* nb_vias,
int* nb_tracks ) int* nb_tracks )
/**************************************************************************/ /**************************************************************************/
/* calcule le nombre de vias et segments de pistes pour le net netcode /* calcule le nombre de vias et segments de pistes pour le net netcode
*/ */
{ {
@ -309,17 +327,23 @@ TRACK * track;
*nb_tracks = 0; *nb_tracks = 0;
track = Pcb->m_Track; track = Pcb->m_Track;
if( track == NULL ) return; if( track == NULL )
return;
for( ; track != NULL; track = (TRACK*) track->Pnext ) for( ; track != NULL; track = (TRACK*) track->Pnext )
{ {
if( track->m_NetCode > netcode ) return; if( track->m_NetCode > netcode )
if( track->m_NetCode != netcode ) continue; return;
if(track->m_StructType == TYPEVIA ) (*nb_vias)++; if( track->m_NetCode != netcode )
if(track->m_StructType == TYPETRACK ) (*nb_tracks)++; continue;
if( track->m_StructType == TYPEVIA )
(*nb_vias)++;
if( track->m_StructType == TYPETRACK )
(*nb_tracks)++;
} }
} }
/*************************************************************/ /*************************************************************/
static void GenExistantTracks( BOARD* Pcb, FILE* outfile, static void GenExistantTracks( BOARD* Pcb, FILE* outfile,
int current_net_code, int type ) int current_net_code, int type )
@ -332,38 +356,46 @@ TRACK * track;
track = Pcb->m_Track; track = Pcb->m_Track;
if( track == NULL ) return; if( track == NULL )
return;
for( ; track != NULL; track = (TRACK*) track->Pnext ) for( ; track != NULL; track = (TRACK*) track->Pnext )
{ {
netcode = track->m_NetCode; netcode = track->m_NetCode;
if( netcode > current_net_code ) return; if( netcode > current_net_code )
if( netcode != current_net_code ) continue; return;
if( netcode != current_net_code )
continue;
plink = track->m_Sous_Netcode; plink = track->m_Sous_Netcode;
via_min_layer = track->m_Layer; via_min_layer = track->GetLayer();
if(track->m_StructType != type ) continue; if( track->m_StructType != type )
continue;
if( track->m_StructType == TYPEVIA ) if( track->m_StructType == TYPEVIA )
{ {
via_min_layer &= 15; via_min_layer &= 15;
via_max_layer = (track->m_Layer >> 4) & 15; via_max_layer = (track->GetLayer() >> 4) & 15;
if( via_min_layer == via_max_layer ) if( via_min_layer == via_max_layer )
{ {
track->m_Layer = 0xF; track->SetLayer( 0xF );
via_min_layer = 0; via_max_layer = 15; via_min_layer = 0; via_max_layer = 15;
} }
if( via_max_layer < via_min_layer ) if( via_max_layer < via_min_layer )
EXCHG( via_max_layer, via_min_layer ); EXCHG( via_max_layer, via_min_layer );
if(via_max_layer == CMP_N) via_max_layer = max_layer; if( via_max_layer == CMP_N )
else via_max_layer++; via_max_layer = max_layer;
else
via_max_layer++;
if(via_min_layer == CUIVRE_N) via_min_layer = min_layer; if( via_min_layer == CUIVRE_N )
else via_min_layer++; via_min_layer = min_layer;
else
via_min_layer++;
fprintf( outfile, "v 0 " ); fprintf( outfile, "v 0 " );
fprintf( outfile, " %d %d", track->m_Start.x / PSCALE, track->m_Start.y / PSCALE ); fprintf( outfile, " %d %d", track->m_Start.x / PSCALE, track->m_Start.y / PSCALE );
@ -380,8 +412,10 @@ TRACK * track;
fprintf( outfile, " %d %d", track->m_Start.x / PSCALE, track->m_Start.y / PSCALE ); fprintf( outfile, " %d %d", track->m_Start.x / PSCALE, track->m_Start.y / PSCALE );
fprintf( outfile, " %d %d", track->m_End.x / PSCALE, track->m_End.y / PSCALE ); fprintf( outfile, " %d %d", track->m_End.x / PSCALE, track->m_End.y / PSCALE );
if(via_min_layer == CMP_N) via_min_layer = max_layer; if( via_min_layer == CMP_N )
else via_min_layer++; via_min_layer = max_layer;
else
via_min_layer++;
fprintf( outfile, " %d", via_min_layer ); fprintf( outfile, " %d", via_min_layer );
fprintf( outfile, " %d\n", 1 ); /*Number of corners */ fprintf( outfile, " %d\n", 1 ); /*Number of corners */
@ -393,11 +427,13 @@ TRACK * track;
} }
} }
/***********************************************/ /***********************************************/
static int GenEdges( BOARD* Pcb, FILE* outfile ) static int GenEdges( BOARD* Pcb, FILE* outfile )
/***********************************************/ /***********************************************/
/* Generation des contours (edges). /* Generation des contours (edges).
Il sont générés comme des segments de piste placés sur chaque couche routable. * Il sont générés comme des segments de piste placés sur chaque couche routable.
*/ */
{ {
#define NB_CORNERS 4 #define NB_CORNERS 4
@ -413,23 +449,27 @@ int NbItems = 0;
/* impression des contours */ /* impression des contours */
for( PtStruct = Pcb->m_Drawings; PtStruct != NULL; PtStruct = PtStruct->Pnext ) for( PtStruct = Pcb->m_Drawings; PtStruct != NULL; PtStruct = PtStruct->Pnext )
{ {
if( PtStruct->m_StructType != TYPEDRAWSEGMENT ) continue; if( PtStruct->m_StructType != TYPEDRAWSEGMENT )
continue;
PtDrawSegment = (DRAWSEGMENT*) PtStruct; PtDrawSegment = (DRAWSEGMENT*) PtStruct;
if( PtDrawSegment->m_Layer != EDGE_N) continue; if( PtDrawSegment->GetLayer() != EDGE_N )
continue;
fx = PtDrawSegment->m_End.x; ox = PtDrawSegment->m_Start.x; fx = PtDrawSegment->m_End.x; ox = PtDrawSegment->m_Start.x;
fy = PtDrawSegment->m_End.y; oy = PtDrawSegment->m_Start.y; fy = PtDrawSegment->m_End.y; oy = PtDrawSegment->m_Start.y;
dx = fx - ox; dy = fy - oy; dx = fx - ox; dy = fy - oy;
if( (dx == 0) && (dy == 0) ) continue; if( (dx == 0) && (dy == 0) )
continue;
/* elimination des segments non horizontaux, verticaux ou 45 degres, /* elimination des segments non horizontaux, verticaux ou 45 degres,
non gérés par l'autorouteur */ * non gérés par l'autorouteur */
if( (dx != 0) && (dy != 0) && ( abs( dx ) != abs( dy ) ) ) if( (dx != 0) && (dy != 0) && ( abs( dx ) != abs( dy ) ) )
continue; continue;
NbItems++; NbItems++;
if( outfile == NULL ) continue; /* car simple decompte des items */ if( outfile == NULL )
continue; /* car simple decompte des items */
/* generation de la zone interdite */ /* generation de la zone interdite */
@ -540,6 +580,7 @@ int max_layer = m_Pcb->m_BoardSettings->m_CopperLayerCount;
while( GetLine( File, Line, &LineNum ) != NULL ) while( GetLine( File, Line, &LineNum ) != NULL )
{ {
char ident = Line[0]; char ident = Line[0];
switch( ident ) switch( ident )
{ {
case 'j': // Header, not used case 'j': // Header, not used
@ -553,15 +594,19 @@ int max_layer = m_Pcb->m_BoardSettings->m_CopperLayerCount;
sscanf( Line + 2, "%d %d %d %d %d", &image, sscanf( Line + 2, "%d %d %d %d %d", &image,
&track_start.x, &track_start.y, &via_layer1, &via_layer2 ); &track_start.x, &track_start.y, &via_layer1, &via_layer2 );
via_layer1--; via_layer2--; via_layer1--; via_layer2--;
if ( via_layer1 == max_layer-1 ) via_layer1 = CMP_N; if( via_layer1 == max_layer - 1 )
if ( via_layer2 == max_layer-1 ) via_layer2 = CMP_N; via_layer1 = CMP_N;
if( via_layer2 == max_layer - 1 )
via_layer2 = CMP_N;
NewVia = new SEGVIA( m_Pcb ); NewVia = new SEGVIA( m_Pcb );
NewVia->m_Start = NewVia->m_End = track_start; NewVia->m_Start = NewVia->m_End = track_start;
NewVia->m_Width = via_size; NewVia->m_Width = via_size;
NewVia->m_Layer = via_layer1 + (via_layer2<<4); NewVia->SetLayer( via_layer1 + (via_layer2 << 4) );
if ( NewVia->m_Layer == 0x0F || NewVia->m_Layer == 0xF0) if( NewVia->GetLayer() == 0x0F || NewVia->GetLayer() == 0xF0 )
NewVia->m_Shape = VIA_NORMALE; NewVia->m_Shape = VIA_NORMALE;
else NewVia->m_Shape = VIA_ENTERREE; else
NewVia->m_Shape = VIA_ENTERREE;
NewVia->Insert( m_Pcb, NULL ); NewVia->Insert( m_Pcb, NULL );
NbTrack++; NbTrack++;
break; break;
@ -571,20 +616,23 @@ int max_layer = m_Pcb->m_BoardSettings->m_CopperLayerCount;
track_layer--; track_layer--;
if( (track_layer != CUIVRE_N) && (track_layer == max_layer - 1) ) if( (track_layer != CUIVRE_N) && (track_layer == max_layer - 1) )
track_layer = CMP_N; track_layer = CMP_N;
// Read corners: fmt = C x_pos y_pos // Read corners: fmt = C x_pos y_pos
for( int ii = 0; ii < track_count; ii++ ) for( int ii = 0; ii < track_count; ii++ )
{ {
if( GetLine( File, Line, &LineNum ) != NULL ) if( GetLine( File, Line, &LineNum ) != NULL )
{ {
if ( Line[0] != 'C' ) break; if( Line[0] != 'C' )
break;
if( ii == 0 ) if( ii == 0 )
sscanf( Line + 2, "%d %d", &track_start.x, &track_start.y ); sscanf( Line + 2, "%d %d", &track_start.x, &track_start.y );
else else
{ {
sscanf( Line + 2, "%d %d", &track_end.x, &track_end.y ); sscanf( Line + 2, "%d %d", &track_end.x, &track_end.y );
NewTrack = new TRACK( m_Pcb ); NewTrack = new TRACK( m_Pcb );
NewTrack->m_Width = track_width; NewTrack->m_Width = track_width;
NewTrack->m_Layer = track_layer; NewTrack->SetLayer( track_layer );
NewTrack->m_Start = track_start; NewTrack->m_Start = track_start;
NewTrack->m_End = track_end; NewTrack->m_End = track_end;
track_start = track_end; track_start = track_end;
@ -592,8 +640,10 @@ int max_layer = m_Pcb->m_BoardSettings->m_CopperLayerCount;
NbTrack++; NbTrack++;
} }
} }
else break; else
break;
} }
break; break;
default: default:
@ -605,7 +655,8 @@ int max_layer = m_Pcb->m_BoardSettings->m_CopperLayerCount;
setlocale( LC_NUMERIC, "" ); setlocale( LC_NUMERIC, "" );
if( NbTrack == 0 ) DisplayError(this, wxT("Warning: No tracks"), 10); if( NbTrack == 0 )
DisplayError( this, wxT( "Warning: No tracks" ), 10 );
else else
{ {
m_Pcb->m_Status_Pcb = 0; m_Pcb->m_Status_Pcb = 0;
@ -613,6 +664,6 @@ int max_layer = m_Pcb->m_BoardSettings->m_CopperLayerCount;
} }
Compile_Ratsnest( DC, TRUE ); Compile_Ratsnest( DC, TRUE );
if( NbTrack ) m_CurrentScreen->SetRefreshReq(); if( NbTrack )
m_CurrentScreen->SetRefreshReq();
} }

387
pcbnew/solve.cpp
View File

@ -17,7 +17,8 @@
#include "cell.h" #include "cell.h"
/* Routines definies ici : */ /* Routines definies ici : */
static int Route_1_Trace(WinEDA_PcbFrame * pcbframe, wxDC * DC, int two_sides, int row_source,int col_source, static int Route_1_Trace( WinEDA_PcbFrame* pcbframe, wxDC* DC, int two_sides, int row_source,
int col_source,
int row_target, int col_target, CHEVELU* pt_chevelu ); int row_target, int col_target, CHEVELU* pt_chevelu );
static int Retrace( WinEDA_PcbFrame* pcbframe, wxDC* DC, int, int, int, int, int, int net_code ); static int Retrace( WinEDA_PcbFrame* pcbframe, wxDC* DC, int, int, int, int, int, int net_code );
static void OrCell_Trace( BOARD* pcb, int col, int row, int side, int orient, int current_net_code ); static void OrCell_Trace( BOARD* pcb, int col, int row, int side, int orient, int current_net_code );
@ -49,8 +50,8 @@ static int Ncurrent; /* measures of progress */
*/ */
/* for visiting neighbors on the same side: increments/decrements des coord /* for visiting neighbors on the same side: increments/decrements des coord
[][0] = row, []{1] = col a ajouter aux coord du point central pour * [][0] = row, []{1] = col a ajouter aux coord du point central pour
obtenir les coord des 8 points voisins */ * obtenir les coord des 8 points voisins */
static int delta[8][2] = { static int delta[8][2] = {
{ 1, -1 }, /* northwest */ { 1, -1 }, /* northwest */
{ 1, 0 }, /* north */ { 1, 0 }, /* north */
@ -114,26 +115,43 @@ static int ndir[8] = { /* for building paths back to source */
| SHARP_WtoSW | SHARP_WtoNW \ | SHARP_WtoSW | SHARP_WtoNW \
| SHARP_NtoNW | SHARP_StoSW | HOLE ) | SHARP_NtoNW | SHARP_StoSW | HOLE )
struct block { struct block
{
int r1, c1; int r1, c1;
long b1; long b1;
int r2, c2; int r2, c2;
long b2; long b2;
}; };
static struct block blocking[8] = { /* blocking masks for diagonal traces */ static struct block blocking[8] = /* blocking masks for diagonal traces */
{ 0, -1, BLOCK_NORTHEAST, 1, 0, BLOCK_SOUTHWEST }, { { 0, -1,
{ 0, 0, 0, 0, 0, 0 }, BLOCK_NORTHEAST,
{ 1, 0, BLOCK_SOUTHEAST, 0, 1, BLOCK_NORTHWEST }, 1, 0,
{ 0, 0, 0, 0, 0, 0 }, BLOCK_SOUTHWEST },
{ 0, 0, 0, 0, 0, 0 }, { 0, 0, 0,
{ 0, -1, BLOCK_SOUTHEAST, -1, 0, BLOCK_NORTHWEST }, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0 }, { 1, 0,
{ -1, 0, BLOCK_NORTHEAST, 0, 1, BLOCK_SOUTHWEST } BLOCK_SOUTHEAST,
}; 0, 1,
BLOCK_NORTHWEST },
{ 0, 0, 0,
0, 0, 0 },
{ 0, 0, 0,
0, 0, 0 },
{ 0, -1,
BLOCK_SOUTHEAST,
-1, 0,
BLOCK_NORTHWEST },
{ 0, 0, 0,
0, 0, 0 },
{ -1, 0,
BLOCK_NORTHEAST,
0, 1,
BLOCK_SOUTHWEST } };
/* mask for hole-related blocking effects */ /* mask for hole-related blocking effects */
static struct { static struct
{
long trace; long trace;
int present; int present;
} selfok2[8] = { } selfok2[8] = {
@ -173,9 +191,9 @@ static long newmask[8] = { /* patterns to mask out in neighbor cells */
/********************************************************/ /********************************************************/
/* route all traces /* route all traces
Return: 1 si OK * Return: 1 si OK
-1 si Escape (arret en cours de routage) demande * -1 si Escape (arret en cours de routage) demande
-2 si defaut alloc memoire * -2 si defaut alloc memoire
*/ */
int WinEDA_PcbFrame::Solve( wxDC* DC, int two_sides ) int WinEDA_PcbFrame::Solve( wxDC* DC, int two_sides )
@ -201,7 +219,8 @@ wxString msg;
&row_target, &col_target, &pt_cur_ch ); // 1er chevelu a router &row_target, &col_target, &pt_cur_ch ); // 1er chevelu a router
for( ; row_source != ILLEGAL; GetWork( &row_source, &col_source, for( ; row_source != ILLEGAL; GetWork( &row_source, &col_source,
&current_net_code, &row_target, &col_target, &pt_cur_ch )) &current_net_code, &row_target, &col_target,
&pt_cur_ch ) )
{ {
/* Tst demande d'arret de routage ( key ESCAPE actionnee ) */ /* Tst demande d'arret de routage ( key ESCAPE actionnee ) */
wxYield(); wxYield();
@ -213,7 +232,8 @@ wxString msg;
stop = TRUE; stop = TRUE;
break; break;
} }
else DrawPanel->m_AbortRequest = 0; else
DrawPanel->m_AbortRequest = 0;
} }
Ncurrent++; Ncurrent++;
@ -239,6 +259,7 @@ wxString msg;
success = Route_1_Trace( this, DC, two_sides, row_source, col_source, success = Route_1_Trace( this, DC, two_sides, row_source, col_source,
row_target, col_target, pt_cur_ch ); row_target, col_target, pt_cur_ch );
switch( success ) switch( success )
{ {
case NOSUCCESS: case NOSUCCESS:
@ -270,32 +291,34 @@ wxString msg;
pt_cur_ch->pad_start->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_AND ); pt_cur_ch->pad_start->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_AND );
pt_cur_ch->pad_end->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_AND ); pt_cur_ch->pad_end->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_AND );
if ( stop ) break; if( stop )
break;
} }
DrawPanel->m_AbortEnable = FALSE; DrawPanel->m_AbortEnable = FALSE;
return(SUCCESS); return SUCCESS;
} }
/**************************/ /**************************/
/* int Route_1_Trace(xxx) */ /* int Route_1_Trace(xxx) */
/**************************/ /**************************/
/* Route une piste du BOARD. /* Route une piste du BOARD.
Parametres: * Parametres:
1 face / 2 faces ( 0 / 1) * 1 face / 2 faces ( 0 / 1)
coord source (row,col) * coord source (row,col)
coord destination (row,col) * coord destination (row,col)
net_code * net_code
pointeur sur le chevelu de reference * pointeur sur le chevelu de reference
*
Retourne : * Retourne :
SUCCESS si route trouvee * SUCCESS si route trouvee
TRIVIAL_SUCCESS si pads connectes par superposition ( pas de piste a tirer) * TRIVIAL_SUCCESS si pads connectes par superposition ( pas de piste a tirer)
NOSUCCESS si echec * NOSUCCESS si echec
STOP_FROM_ESC si Escape demande * STOP_FROM_ESC si Escape demande
ERR_MEMORY defaut alloc RAM * ERR_MEMORY defaut alloc RAM
*/ */
static int Route_1_Trace( WinEDA_PcbFrame* pcbframe, wxDC* DC, static int Route_1_Trace( WinEDA_PcbFrame* pcbframe, wxDC* DC,
int two_sides, int row_source, int col_source, int two_sides, int row_source, int col_source,
@ -315,7 +338,7 @@ int masque_layer_TOP = g_TabOneLayerMask[Route_Layer_TOP];
int masque_layer_BOTTOM = g_TabOneLayerMask[Route_Layer_BOTTOM]; int masque_layer_BOTTOM = g_TabOneLayerMask[Route_Layer_BOTTOM];
int masque_layers; /* Masque des 2 couches de routage */ int masque_layers; /* Masque des 2 couches de routage */
int tab_mask[2];/* permet le calcul du Masque de la couche en cours int tab_mask[2];/* permet le calcul du Masque de la couche en cours
de tst (side = TOP ou BOTTOM)*/ * de tst (side = TOP ou BOTTOM)*/
int start_mask_layer = 0; int start_mask_layer = 0;
wxString msg; wxString msg;
@ -343,13 +366,15 @@ wxString msg;
pad_masque_layer_e = pt_cur_ch->pad_end->m_Masque_Layer; pad_masque_layer_e = pt_cur_ch->pad_end->m_Masque_Layer;
/* Test 1 Si routage possible c.a.d si les pads sont accessibles /* Test 1 Si routage possible c.a.d si les pads sont accessibles
sur les couches de routage */ * sur les couches de routage */
if( (masque_layers & pad_masque_layer_s) == 0 ) goto end_of_route; if( (masque_layers & pad_masque_layer_s) == 0 )
if( (masque_layers & pad_masque_layer_e) == 0 ) goto end_of_route; goto end_of_route;
if( (masque_layers & pad_masque_layer_e) == 0 )
goto end_of_route;
/* Test 2 Si routage possible c.a.d si les pads sont accessibles /* Test 2 Si routage possible c.a.d si les pads sont accessibles
sur la grille de routage ( 1 point de grille doit etre dans le pad)*/ * sur la grille de routage ( 1 point de grille doit etre dans le pad)*/
{ {
int cX = (g_GridRoutingSize * col_source) + pcbframe->m_Pcb->m_BoundaryBox.m_Pos.x; int cX = (g_GridRoutingSize * col_source) + pcbframe->m_Pcb->m_BoundaryBox.m_Pos.x;
int cY = (g_GridRoutingSize * row_source) + pcbframe->m_Pcb->m_BoundaryBox.m_Pos.y; int cY = (g_GridRoutingSize * row_source) + pcbframe->m_Pcb->m_BoundaryBox.m_Pos.y;
@ -358,8 +383,10 @@ wxString msg;
int px = pt_cur_ch->pad_start->m_Pos.x; int px = pt_cur_ch->pad_start->m_Pos.x;
int py = pt_cur_ch->pad_start->m_Pos.y; int py = pt_cur_ch->pad_start->m_Pos.y;
if ( ((pt_cur_ch->pad_start->m_Orient/900)&1) != 0 ) EXCHG(dx,dy) ; if( ( (pt_cur_ch->pad_start->m_Orient / 900) & 1 ) != 0 )
if ( (abs(cX - px) > dx ) || (abs(cY - py) > dy) ) goto end_of_route; EXCHG( dx, dy );
if( (abs( cX - px ) > dx ) || (abs( cY - py ) > dy) )
goto end_of_route;
cX = (g_GridRoutingSize * col_target) + pcbframe->m_Pcb->m_BoundaryBox.m_Pos.x; cX = (g_GridRoutingSize * col_target) + pcbframe->m_Pcb->m_BoundaryBox.m_Pos.x;
cY = (g_GridRoutingSize * row_target) + pcbframe->m_Pcb->m_BoundaryBox.m_Pos.y; cY = (g_GridRoutingSize * row_target) + pcbframe->m_Pcb->m_BoundaryBox.m_Pos.y;
@ -367,21 +394,23 @@ wxString msg;
dy = pt_cur_ch->pad_end->m_Size.y / 2; dy = pt_cur_ch->pad_end->m_Size.y / 2;
px = pt_cur_ch->pad_end->m_Pos.x; px = pt_cur_ch->pad_end->m_Pos.x;
py = pt_cur_ch->pad_end->m_Pos.y; py = pt_cur_ch->pad_end->m_Pos.y;
if ( ((pt_cur_ch->pad_end->m_Orient/900)&1) != 0 ) EXCHG(dx,dy) ; if( ( (pt_cur_ch->pad_end->m_Orient / 900) & 1 ) != 0 )
EXCHG( dx, dy );
if ( (abs(cX - px) > dx ) || (abs(cY - py) > dy) ) goto end_of_route; if( (abs( cX - px ) > dx ) || (abs( cY - py ) > dy) )
goto end_of_route;
} }
/* Test du cas trivial: connection directe par superposition des pads */ /* Test du cas trivial: connection directe par superposition des pads */
if( (row_source == row_target) && (col_source == col_target) if( (row_source == row_target) && (col_source == col_target)
&& ( pad_masque_layer_e & pad_masque_layer_s & g_TabAllCopperLayerMask[g_DesignSettings.m_CopperLayerCount-1]) ) && ( pad_masque_layer_e & pad_masque_layer_s &
g_TabAllCopperLayerMask[g_DesignSettings.m_CopperLayerCount - 1]) )
{ {
result = TRIVIAL_SUCCESS; result = TRIVIAL_SUCCESS;
goto end_of_route; goto end_of_route;
} }
/* Placement du bit de suppression d'obstacle relative aux 2 pads a relier */ /* Placement du bit de suppression d'obstacle relative aux 2 pads a relier */
pcbframe->Affiche_Message( wxT( "Gen Cells" ) ); pcbframe->Affiche_Message( wxT( "Gen Cells" ) );
@ -389,7 +418,7 @@ wxString msg;
Place_1_Pad_Board( pcbframe->m_Pcb, pt_cur_ch->pad_end, CURRENT_PAD, marge, WRITE_OR_CELL ); Place_1_Pad_Board( pcbframe->m_Pcb, pt_cur_ch->pad_end, CURRENT_PAD, marge, WRITE_OR_CELL );
/* Regenere les barrieres restantes (qui peuvent empieter sur le placement /* Regenere les barrieres restantes (qui peuvent empieter sur le placement
des bits precedents) */ * des bits precedents) */
ptr = (LISTE_PAD*) pcbframe->m_Pcb->m_Pads; i = pcbframe->m_Pcb->m_NbPads; ptr = (LISTE_PAD*) pcbframe->m_Pcb->m_Pads; i = pcbframe->m_Pcb->m_NbPads;
for( ; i > 0; i--, ptr++ ) for( ; i > 0; i--, ptr++ )
{ {
@ -413,7 +442,7 @@ wxString msg;
if( SetQueue( row_source, col_source, TOP, 0, apx_dist, if( SetQueue( row_source, col_source, TOP, 0, apx_dist,
row_target, col_target ) == 0 ) row_target, col_target ) == 0 )
{ {
return(ERR_MEMORY); return ERR_MEMORY;
} }
} }
if( pad_masque_layer_s & masque_layer_BOTTOM ) if( pad_masque_layer_s & masque_layer_BOTTOM )
@ -423,7 +452,7 @@ wxString msg;
if( SetQueue( row_source, col_source, BOTTOM, 0, apx_dist, if( SetQueue( row_source, col_source, BOTTOM, 0, apx_dist,
row_target, col_target ) == 0 ) row_target, col_target ) == 0 )
{ {
return(ERR_MEMORY); return ERR_MEMORY;
} }
} }
} }
@ -435,7 +464,7 @@ wxString msg;
if( SetQueue( row_source, col_source, BOTTOM, 0, apx_dist, if( SetQueue( row_source, col_source, BOTTOM, 0, apx_dist,
row_target, col_target ) == 0 ) row_target, col_target ) == 0 )
{ {
return(ERR_MEMORY); return ERR_MEMORY;
} }
} }
if( pad_masque_layer_s & masque_layer_TOP ) if( pad_masque_layer_s & masque_layer_TOP )
@ -445,21 +474,19 @@ wxString msg;
if( SetQueue( row_source, col_source, TOP, 0, apx_dist, if( SetQueue( row_source, col_source, TOP, 0, apx_dist,
row_target, col_target ) == 0 ) row_target, col_target ) == 0 )
{ {
return(ERR_MEMORY); return ERR_MEMORY;
} }
} }
} }
} }
else if( pad_masque_layer_s & masque_layer_BOTTOM )
else
if( pad_masque_layer_s & masque_layer_BOTTOM )
{ {
start_mask_layer = 1; start_mask_layer = 1;
if( SetQueue( row_source, col_source, BOTTOM, 0, apx_dist, if( SetQueue( row_source, col_source, BOTTOM, 0, apx_dist,
row_target, col_target ) == 0 ) row_target, col_target ) == 0 )
{ {
return(ERR_MEMORY); return ERR_MEMORY;
} }
} }
@ -468,13 +495,21 @@ wxString msg;
for( ; r != ILLEGAL; GetQueue( &r, &c, &side, &d, &apx_dist ) ) for( ; r != ILLEGAL; GetQueue( &r, &c, &side, &d, &apx_dist ) )
{ {
curcell = GetCell( r, c, side ); curcell = GetCell( r, c, side );
if(curcell & CURRENT_PAD) curcell &= ~HOLE ; if( curcell & CURRENT_PAD )
curcell &= ~HOLE;
if( (r == row_target) && (c == col_target) /* success si layer OK */ if( (r == row_target) && (c == col_target) /* success si layer OK */
&& ( tab_mask[side] & pad_masque_layer_e) ) && ( tab_mask[side] & pad_masque_layer_e) )
{ {
/* Efface Liaison */ /* Efface Liaison */
GRSetDrawMode( DC, GR_XOR ); GRSetDrawMode( DC, GR_XOR );
GRLine(&pcbframe->DrawPanel->m_ClipBox, DC, segm_oX, segm_oY, segm_fX, segm_fY, 0, WHITE); GRLine( &pcbframe->DrawPanel->m_ClipBox,
DC,
segm_oX,
segm_oY,
segm_fX,
segm_fY,
0,
WHITE );
/* Generation de la trace */ /* Generation de la trace */
if( Retrace( pcbframe, DC, row_source, col_source, if( Retrace( pcbframe, DC, row_source, col_source,
@ -485,7 +520,8 @@ wxString msg;
break; /* Fin du routage */ break; /* Fin du routage */
} }
/* report every 300 new nodes or so */ /* report every 300 new nodes or so */
if( (OpenNodes-lastopen > 300) || (ClosNodes-lastclos > 300) || (MoveNodes - lastmove > 300)) if( (OpenNodes - lastopen > 300) || (ClosNodes - lastclos > 300) ||
(MoveNodes - lastmove > 300) )
{ {
lastopen = (OpenNodes / 300) * 300; lastclos = (ClosNodes / 300) * 300; lastopen = (OpenNodes / 300) * 300; lastclos = (ClosNodes / 300) * 300;
lastmove = (MoveNodes / 300) * 300; lastmove = (MoveNodes / 300) * 300;
@ -505,7 +541,8 @@ wxString msg;
for( i = 0; i < 8; i++ ) for( i = 0; i < 8; i++ )
{ {
selfok2[i].present = 0; selfok2[i].present = 0;
if( (curcell & selfok2[i].trace) ) selfok2[i].present = 1; if( (curcell & selfok2[i].trace) )
selfok2[i].present = 1;
} }
} }
@ -517,37 +554,48 @@ wxString msg;
if( nr < 0 || nr >= Nrows || nc < 0 || nc >= Ncols ) if( nr < 0 || nr >= Nrows || nc < 0 || nc >= Ncols )
continue;/* off the edge */ continue;/* off the edge */
if (_self == 5 && selfok2[i].present) continue; if( _self == 5 && selfok2[i].present )
continue;
newcell = GetCell( nr, nc, side ); newcell = GetCell( nr, nc, side );
if(newcell & CURRENT_PAD) newcell &= ~HOLE; if( newcell & CURRENT_PAD )
newcell &= ~HOLE;
/* check for non-target hole */ /* check for non-target hole */
if( newcell & HOLE ) if( newcell & HOLE )
{ {
if (nr != row_target || nc != col_target) continue; if( nr != row_target || nc != col_target )
continue;
} }
/* check for traces */ /* check for traces */
else if (newcell & HOLE & ~(newmask[i])) continue; else if( newcell & HOLE & ~(newmask[i]) )
continue;
/* check blocking on corner neighbors */ /* check blocking on corner neighbors */
if( delta[i][0] && delta[i][1] ) if( delta[i][0] && delta[i][1] )
{ {
/* check first buddy */ /* check first buddy */
buddy = GetCell( r + blocking[i].r1, c + blocking[i].c1, side ); buddy = GetCell( r + blocking[i].r1, c + blocking[i].c1, side );
if(buddy & CURRENT_PAD) buddy &= ~HOLE; if( buddy & CURRENT_PAD )
if (buddy & HOLE) continue; buddy &= ~HOLE;
if( buddy & HOLE )
continue;
// if (buddy & (blocking[i].b1)) continue; // if (buddy & (blocking[i].b1)) continue;
/* check second buddy */ /* check second buddy */
buddy = GetCell( r + blocking[i].r2, c + blocking[i].c2, side ); buddy = GetCell( r + blocking[i].r2, c + blocking[i].c2, side );
if(buddy & CURRENT_PAD) buddy &= ~HOLE; if( buddy & CURRENT_PAD )
if (buddy & HOLE) continue; buddy &= ~HOLE;
if( buddy & HOLE )
continue;
// if (buddy & (blocking[i].b2)) continue; // if (buddy & (blocking[i].b2)) continue;
} }
olddir = GetDir( r, c, side ); olddir = GetDir( r, c, side );
newdist = d + CalcDist( ndir[i], olddir, newdist = d + CalcDist( ndir[i], olddir,
(olddir == FROM_OTHERSIDE) ? GetDir( r, c, 1-side ) : 0 , side); (olddir == FROM_OTHERSIDE) ? GetDir( r,
c,
1 - side ) : 0, side );
/* if (a) not visited yet, or (b) we have */ /* if (a) not visited yet, or (b) we have */
/* found a better path, add it to queue */ /* found a better path, add it to queue */
@ -559,10 +607,9 @@ wxString msg;
GetApxDist( nr, nc, row_target, col_target ), GetApxDist( nr, nc, row_target, col_target ),
row_target, col_target ) == 0 ) row_target, col_target ) == 0 )
{ {
return(ERR_MEMORY); return ERR_MEMORY;
} }
} }
else if( newdist < GetDist( nr, nc, side ) ) else if( newdist < GetDist( nr, nc, side ) )
{ {
SetDir( nr, nc, side, ndir[i] ); SetDir( nr, nc, side, ndir[i] );
@ -611,8 +658,8 @@ wxString msg;
newdist = d + CalcDist( FROM_OTHERSIDE, olddir, 0, side ); newdist = d + CalcDist( FROM_OTHERSIDE, olddir, 0, side );
/* if (a) not visited yet, /* if (a) not visited yet,
or (b) we have found a better path, * or (b) we have found a better path,
add it to queue */ * add it to queue */
if( !GetDir( r, c, 1 - side ) ) if( !GetDir( r, c, 1 - side ) )
{ {
SetDir( r, c, 1 - side, FROM_OTHERSIDE ); SetDir( r, c, 1 - side, FROM_OTHERSIDE );
@ -620,7 +667,7 @@ wxString msg;
if( SetQueue( r, c, 1 - side, newdist, apx_dist, row_target, if( SetQueue( r, c, 1 - side, newdist, apx_dist, row_target,
col_target ) == 0 ) col_target ) == 0 )
{ {
return(ERR_MEMORY); return ERR_MEMORY;
} }
} }
else if( newdist < GetDist( r, c, 1 - side ) ) else if( newdist < GetDist( r, c, 1 - side ) )
@ -637,9 +684,10 @@ end_of_route:
Place_1_Pad_Board( pcbframe->m_Pcb, pt_cur_ch->pad_end, ~CURRENT_PAD, marge, WRITE_AND_CELL ); Place_1_Pad_Board( pcbframe->m_Pcb, pt_cur_ch->pad_end, ~CURRENT_PAD, marge, WRITE_AND_CELL );
AFFICHE_ACTIVITE_ROUTE; AFFICHE_ACTIVITE_ROUTE;
return(result); return result;
} }
static long bit[8][9] = { /* OT=Otherside */ static long bit[8][9] = { /* OT=Otherside */
/* N, NE, E, SE, S, SW, W, NW, OT */ /* N, NE, E, SE, S, SW, W, NW, OT */
/* N */ { LINE_VERTICAL, BENT_StoNE, CORNER_SOUTHEAST, SHARP_StoSE, 0, /* N */ { LINE_VERTICAL, BENT_StoNE, CORNER_SOUTHEAST, SHARP_StoSE, 0,
@ -652,7 +700,8 @@ static long bit[8][9] = { /* OT=Otherside */
ANGLE_SWtoNW, SHARP_WtoNW, 0, (HOLE | HOLE_NORTHWEST) }, ANGLE_SWtoNW, SHARP_WtoNW, 0, (HOLE | HOLE_NORTHWEST) },
/* S */ { 0, SHARP_NtoNE, CORNER_NORTHEAST, BENT_NtoSE, LINE_VERTICAL, /* S */ { 0, SHARP_NtoNE, CORNER_NORTHEAST, BENT_NtoSE, LINE_VERTICAL,
BENT_NtoSW, CORNER_NORTHWEST, SHARP_NtoNW, (HOLE | HOLE_NORTH) }, BENT_NtoSW, CORNER_NORTHWEST, SHARP_NtoNW, (HOLE | HOLE_NORTH) },
/* SW */ { SHARP_NtoNE, 0, SHARP_EtoNE, ANGLE_NEtoSE, BENT_StoNE, DIAG_NEtoSW, /* SW */ { SHARP_NtoNE, 0, SHARP_EtoNE, ANGLE_NEtoSE, BENT_StoNE,
DIAG_NEtoSW,
BENT_WtoNE, ANGLE_NWtoNE, (HOLE | HOLE_NORTHEAST) }, BENT_WtoNE, ANGLE_NWtoNE, (HOLE | HOLE_NORTHEAST) },
/* W */ { CORNER_NORTHEAST, SHARP_EtoNE, 0, SHARP_EtoSE, CORNER_SOUTHEAST, /* W */ { CORNER_NORTHEAST, SHARP_EtoNE, 0, SHARP_EtoSE, CORNER_SOUTHEAST,
BENT_EtoSW, LINE_HORIZONTAL, BENT_EtoNW, (HOLE | HOLE_EAST) }, BENT_EtoSW, LINE_HORIZONTAL, BENT_EtoNW, (HOLE | HOLE_EAST) },
@ -667,19 +716,19 @@ static long bit[8][9] = { /* OT=Otherside */
/*****************************************************************/ /*****************************************************************/
/* work from target back to source, actually laying the traces /* work from target back to source, actually laying the traces
Parametres: * Parametres:
start on side target_side, aux coordonnees row_target, col_target. * start on side target_side, aux coordonnees row_target, col_target.
arrivee sur side masque_layer_start, coord row_source, col_source * arrivee sur side masque_layer_start, coord row_source, col_source
La recherche se fait en sens inverse du routage, * La recherche se fait en sens inverse du routage,
c.a.d du point d'arrivee (target) vers le point de depart (source) * c.a.d du point d'arrivee (target) vers le point de depart (source)
du routeur. * du routeur.
*
target_side = cote (TOP / BOTTOM) de depart * target_side = cote (TOP / BOTTOM) de depart
mask_layer_source = masque des couches d'arrivee * mask_layer_source = masque des couches d'arrivee
*
Retourne: * Retourne:
0 si erreur * 0 si erreur
> 0 si Ok * > 0 si Ok
*/ */
static int Retrace( WinEDA_PcbFrame* pcbframe, wxDC* DC, static int Retrace( WinEDA_PcbFrame* pcbframe, wxDC* DC,
@ -705,67 +754,96 @@ long b;
/* find where we came from to get here */ /* find where we came from to get here */
r2 = r1; c2 = c1; s2 = s1; r2 = r1; c2 = c1; s2 = s1;
x = GetDir( r1, c1, s1 ); x = GetDir( r1, c1, s1 );
switch( x ) switch( x )
{ {
case FROM_NORTH: r2++; break; case FROM_NORTH:
case FROM_EAST: c2++; break; r2++; break;
case FROM_SOUTH: r2--; break;
case FROM_WEST: c2--; break; case FROM_EAST:
case FROM_NORTHEAST: r2++; c2++; break; c2++; break;
case FROM_SOUTHEAST: r2--; c2++; break;
case FROM_SOUTHWEST: r2--; c2--; break; case FROM_SOUTH:
case FROM_NORTHWEST: r2++; c2--; break; r2--; break;
case FROM_OTHERSIDE: s2 = 1-s2; break;
case FROM_WEST:
c2--; break;
case FROM_NORTHEAST:
r2++; c2++; break;
case FROM_SOUTHEAST:
r2--; c2++; break;
case FROM_SOUTHWEST:
r2--; c2--; break;
case FROM_NORTHWEST:
r2++; c2--; break;
case FROM_OTHERSIDE:
s2 = 1 - s2; break;
default: default:
DisplayError( pcbframe, wxT( "Retrace: internal error: no way back" ) ); DisplayError( pcbframe, wxT( "Retrace: internal error: no way back" ) );
return(0); return 0;
} }
if (r0 != ILLEGAL) y = GetDir( r0, c0, s0 ); if( r0 != ILLEGAL )
y = GetDir( r0, c0, s0 );
/* see if target or hole */ /* see if target or hole */
if( ( (r1 == row_target) && (c1 == col_target) ) if( ( (r1 == row_target) && (c1 == col_target) )
|| (s1 != s0) ) || (s1 != s0) )
{ {
int p_dir; int p_dir;
switch( x ) switch( x )
{ {
case FROM_NORTH: case FROM_NORTH:
p_dir = HOLE_NORTH; break; p_dir = HOLE_NORTH; break;
case FROM_EAST: case FROM_EAST:
p_dir = HOLE_EAST; break; p_dir = HOLE_EAST; break;
case FROM_SOUTH: case FROM_SOUTH:
p_dir = HOLE_SOUTH; break; p_dir = HOLE_SOUTH; break;
case FROM_WEST: case FROM_WEST:
p_dir = HOLE_WEST; break; p_dir = HOLE_WEST; break;
case FROM_NORTHEAST: case FROM_NORTHEAST:
p_dir = HOLE_NORTHEAST; break; p_dir = HOLE_NORTHEAST; break;
case FROM_SOUTHEAST: case FROM_SOUTHEAST:
p_dir = HOLE_SOUTHEAST; break; p_dir = HOLE_SOUTHEAST; break;
case FROM_SOUTHWEST: case FROM_SOUTHWEST:
p_dir = HOLE_SOUTHWEST; break; p_dir = HOLE_SOUTHWEST; break;
case FROM_NORTHWEST: case FROM_NORTHWEST:
p_dir = HOLE_NORTHWEST; break; p_dir = HOLE_NORTHWEST; break;
case FROM_OTHERSIDE: case FROM_OTHERSIDE:
default: default:
DisplayError( pcbframe, wxT( "Retrace: error 1" ) ); DisplayError( pcbframe, wxT( "Retrace: error 1" ) );
return(0); return 0;
}
OrCell_Trace(pcbframe->m_Pcb, r1, c1, s1, p_dir, current_net_code );
} }
else { OrCell_Trace( pcbframe->m_Pcb, r1, c1, s1, p_dir, current_net_code );
}
else
{
if( (y == FROM_NORTH || y == FROM_NORTHEAST if( (y == FROM_NORTH || y == FROM_NORTHEAST
|| y == FROM_EAST || y == FROM_SOUTHEAST || y == FROM_EAST || y == FROM_SOUTHEAST
|| y == FROM_SOUTH || y == FROM_SOUTHWEST || y == FROM_SOUTH || y == FROM_SOUTHWEST
|| y == FROM_WEST || y == FROM_NORTHWEST) && || y == FROM_WEST || y == FROM_NORTHWEST)
(x == FROM_NORTH || x == FROM_NORTHEAST && (x == FROM_NORTH || x == FROM_NORTHEAST
|| x == FROM_EAST || x == FROM_SOUTHEAST || x == FROM_EAST || x == FROM_SOUTHEAST
|| x == FROM_SOUTH || x == FROM_SOUTHWEST || x == FROM_SOUTH || x == FROM_SOUTHWEST
|| x == FROM_WEST || x == FROM_NORTHWEST || x == FROM_WEST || x == FROM_NORTHWEST
|| x == FROM_OTHERSIDE) && || x == FROM_OTHERSIDE)
((b = bit[y-1][x-1]) != 0) ) && ( (b = bit[y - 1][x - 1]) != 0 ) )
{ {
OrCell_Trace( pcbframe->m_Pcb, r1, c1, s1, b, current_net_code ); OrCell_Trace( pcbframe->m_Pcb, r1, c1, s1, b, current_net_code );
if( b & HOLE ) if( b & HOLE )
@ -774,29 +852,46 @@ long b;
else else
{ {
DisplayError( pcbframe, wxT( "Retrace: error 2" ) ); DisplayError( pcbframe, wxT( "Retrace: error 2" ) );
return(0); return 0;
} }
} }
if( (r2 == row_source) && (c2 == col_source) ) if( (r2 == row_source) && (c2 == col_source) )
{ /* see if source */ { /* see if source */
int p_dir; int p_dir;
switch( x ) switch( x )
{ {
case FROM_NORTH: p_dir = HOLE_SOUTH; break; case FROM_NORTH:
case FROM_EAST: p_dir = HOLE_WEST; break; p_dir = HOLE_SOUTH; break;
case FROM_SOUTH: p_dir = HOLE_NORTH; break;
case FROM_WEST: p_dir = HOLE_EAST; break; case FROM_EAST:
case FROM_NORTHEAST: p_dir = HOLE_SOUTHWEST; break; p_dir = HOLE_WEST; break;
case FROM_SOUTHEAST: p_dir = HOLE_NORTHWEST; break;
case FROM_SOUTHWEST: p_dir = HOLE_NORTHEAST; break; case FROM_SOUTH:
case FROM_NORTHWEST: p_dir = HOLE_SOUTHEAST; break; p_dir = HOLE_NORTH; break;
case FROM_WEST:
p_dir = HOLE_EAST; break;
case FROM_NORTHEAST:
p_dir = HOLE_SOUTHWEST; break;
case FROM_SOUTHEAST:
p_dir = HOLE_NORTHWEST; break;
case FROM_SOUTHWEST:
p_dir = HOLE_NORTHEAST; break;
case FROM_NORTHWEST:
p_dir = HOLE_SOUTHEAST; break;
case FROM_OTHERSIDE: case FROM_OTHERSIDE:
default: default:
DisplayError( pcbframe, wxT( "Retrace: error 3" ) ); DisplayError( pcbframe, wxT( "Retrace: error 3" ) );
return(0); return 0;
} }
OrCell_Trace( pcbframe->m_Pcb, r2, c2, s2, p_dir, current_net_code ); OrCell_Trace( pcbframe->m_Pcb, r2, c2, s2, p_dir, current_net_code );
} }
/* move to next cell */ /* move to next cell */
@ -805,7 +900,7 @@ long b;
} while( !( (r2 == row_source) && (c2 == col_source) ) ); } while( !( (r2 == row_source) && (c2 == col_source) ) );
Place_Piste_en_Buffer( pcbframe, DC ); Place_Piste_en_Buffer( pcbframe, DC );
return(1); return 1;
} }
@ -821,36 +916,44 @@ TRACK * NewTrack, *OldTrack;
if( orient == HOLE ) /* Placement d'une VIA */ if( orient == HOLE ) /* Placement d'une VIA */
{ {
NewTrack = new SEGVIA( pcb ); NewTrack = new SEGVIA( pcb );
g_TrackSegmentCount++; g_TrackSegmentCount++;
NewTrack->Pback = g_CurrentTrackSegment; NewTrack->Pback = g_CurrentTrackSegment;
if( g_CurrentTrackSegment) g_CurrentTrackSegment->Pnext = NewTrack; if( g_CurrentTrackSegment )
else g_FirstTrackSegment = NewTrack; g_CurrentTrackSegment->Pnext = NewTrack;
else
g_FirstTrackSegment = NewTrack;
g_CurrentTrackSegment = NewTrack; g_CurrentTrackSegment = NewTrack;
g_CurrentTrackSegment->SetState( SEGM_AR, ON ); g_CurrentTrackSegment->SetState( SEGM_AR, ON );
g_CurrentTrackSegment->m_Layer = 0x0F; g_CurrentTrackSegment->SetLayer( 0x0F );
g_CurrentTrackSegment->m_Start.x = g_CurrentTrackSegment->m_End.x = g_CurrentTrackSegment->m_Start.x = g_CurrentTrackSegment->m_End.x =
pcb->m_BoundaryBox.m_Pos.x + (g_GridRoutingSize * row); pcb->m_BoundaryBox.m_Pos.x +
(g_GridRoutingSize * row);
g_CurrentTrackSegment->m_Start.y = g_CurrentTrackSegment->m_End.y = g_CurrentTrackSegment->m_Start.y = g_CurrentTrackSegment->m_End.y =
pcb->m_BoundaryBox.m_Pos.y + (g_GridRoutingSize * col); pcb->m_BoundaryBox.m_Pos.y +
(g_GridRoutingSize * col);
g_CurrentTrackSegment->m_Width = g_DesignSettings.m_CurrentViaSize; g_CurrentTrackSegment->m_Width = g_DesignSettings.m_CurrentViaSize;
g_CurrentTrackSegment->m_Shape = g_DesignSettings.m_CurrentViaType; g_CurrentTrackSegment->m_Shape = g_DesignSettings.m_CurrentViaType;
g_CurrentTrackSegment->m_NetCode = current_net_code; g_CurrentTrackSegment->m_NetCode = current_net_code;
} }
else /* Placement d'un segment standard */ else /* Placement d'un segment standard */
{ {
NewTrack = new TRACK( pcb ); NewTrack = new TRACK( pcb );
g_TrackSegmentCount++; g_TrackSegmentCount++;
NewTrack->Pback = g_CurrentTrackSegment; NewTrack->Pback = g_CurrentTrackSegment;
if( g_CurrentTrackSegment) g_CurrentTrackSegment->Pnext = NewTrack; if( g_CurrentTrackSegment )
else g_FirstTrackSegment = NewTrack; g_CurrentTrackSegment->Pnext = NewTrack;
else
g_FirstTrackSegment = NewTrack;
g_CurrentTrackSegment = NewTrack; g_CurrentTrackSegment = NewTrack;
g_CurrentTrackSegment->m_Layer = Route_Layer_BOTTOM; g_CurrentTrackSegment->SetLayer( Route_Layer_BOTTOM );
if (side == TOP) g_CurrentTrackSegment->m_Layer = Route_Layer_TOP; if( side == TOP )
g_CurrentTrackSegment->SetLayer( Route_Layer_TOP );
g_CurrentTrackSegment->SetState( SEGM_AR, ON ); g_CurrentTrackSegment->SetState( SEGM_AR, ON );
g_CurrentTrackSegment->m_End.x = pcb->m_BoundaryBox.m_Pos.x + (g_GridRoutingSize * row); g_CurrentTrackSegment->m_End.x = pcb->m_BoundaryBox.m_Pos.x + (g_GridRoutingSize * row);
@ -874,7 +977,6 @@ TRACK * NewTrack, *OldTrack;
g_CurrentTrackSegment->m_Start.x = pt_cur_ch->pad_end->m_Pos.x; g_CurrentTrackSegment->m_Start.x = pt_cur_ch->pad_end->m_Pos.x;
g_CurrentTrackSegment->m_Start.y = pt_cur_ch->pad_end->m_Pos.y; g_CurrentTrackSegment->m_Start.y = pt_cur_ch->pad_end->m_Pos.y;
} }
else /* Creation d'un segment suppl raccord */ else /* Creation d'un segment suppl raccord */
{ {
NewTrack = g_CurrentTrackSegment->Copy(); NewTrack = g_CurrentTrackSegment->Copy();
@ -893,14 +995,16 @@ TRACK * NewTrack, *OldTrack;
{ {
if( g_CurrentTrackSegment->Pback ) if( g_CurrentTrackSegment->Pback )
{ {
g_CurrentTrackSegment->m_Start.x = ((TRACK*)g_CurrentTrackSegment->Pback)->m_End.x; g_CurrentTrackSegment->m_Start.x = ( (TRACK*) g_CurrentTrackSegment->Pback )->
g_CurrentTrackSegment->m_Start.y = ((TRACK*)g_CurrentTrackSegment->Pback)->m_End.y; m_End.x;
g_CurrentTrackSegment->m_Start.y = ( (TRACK*) g_CurrentTrackSegment->Pback )->
m_End.y;
} }
} }
g_CurrentTrackSegment->m_Width = g_DesignSettings.m_CurrentTrackWidth; g_CurrentTrackSegment->m_Width = g_DesignSettings.m_CurrentTrackWidth;
if ( (g_CurrentTrackSegment->m_Start.x != g_CurrentTrackSegment->m_End.x) || if( (g_CurrentTrackSegment->m_Start.x != g_CurrentTrackSegment->m_End.x)
(g_CurrentTrackSegment->m_Start.y != g_CurrentTrackSegment->m_End.y) ) || (g_CurrentTrackSegment->m_Start.y != g_CurrentTrackSegment->m_End.y) )
{ {
/* Reduction des segments alignes a 1 seul */ /* Reduction des segments alignes a 1 seul */
OldTrack = (TRACK*) g_CurrentTrackSegment->Pback; OldTrack = (TRACK*) g_CurrentTrackSegment->Pback;
@ -924,13 +1028,14 @@ TRACK * NewTrack, *OldTrack;
} }
} }
/*******************************************/ /*******************************************/
/* static void Place_Piste_en_Buffer(void) */ /* static void Place_Piste_en_Buffer(void) */
/*******************************************/ /*******************************************/
/* Insere la nouvelle piste creee dans la liste standard des pistes. /* Insere la nouvelle piste creee dans la liste standard des pistes.
Modifie les points de debut et fin de piste pour qu'ils soient relies * Modifie les points de debut et fin de piste pour qu'ils soient relies
au centre des pads corresponadants, meme hors grille * au centre des pads corresponadants, meme hors grille
*/ */
static void Place_Piste_en_Buffer( WinEDA_PcbFrame* pcbframe, wxDC* DC ) static void Place_Piste_en_Buffer( WinEDA_PcbFrame* pcbframe, wxDC* DC )
{ {
@ -972,10 +1077,12 @@ WinEDA_DrawPanel * panel = pcbframe->DrawPanel;
g_FirstTrackSegment->start = Locate_Pad_Connecte( pcbframe->m_Pcb, g_FirstTrackSegment, START ); g_FirstTrackSegment->start = Locate_Pad_Connecte( pcbframe->m_Pcb, g_FirstTrackSegment, START );
if(g_FirstTrackSegment->start) g_FirstTrackSegment->SetState(BEGIN_ONPAD,ON); if( g_FirstTrackSegment->start )
g_FirstTrackSegment->SetState( BEGIN_ONPAD, ON );
g_CurrentTrackSegment->end = Locate_Pad_Connecte( pcbframe->m_Pcb, g_CurrentTrackSegment, END ); g_CurrentTrackSegment->end = Locate_Pad_Connecte( pcbframe->m_Pcb, g_CurrentTrackSegment, END );
if(g_CurrentTrackSegment->end) g_CurrentTrackSegment->SetState(END_ONPAD,ON); if( g_CurrentTrackSegment->end )
g_CurrentTrackSegment->SetState( END_ONPAD, ON );
/* recherche de la zone de rangement et insertion de la nouvelle piste */ /* recherche de la zone de rangement et insertion de la nouvelle piste */
pt_track = g_FirstTrackSegment->GetBestInsertPoint( pcbframe->m_Pcb ); pt_track = g_FirstTrackSegment->GetBestInsertPoint( pcbframe->m_Pcb );
@ -990,9 +1097,9 @@ WinEDA_DrawPanel * panel = pcbframe->DrawPanel;
{ {
TraceSegmentPcb( pcbframe->m_Pcb, pt_track, HOLE, marge, WRITE_CELL ); TraceSegmentPcb( pcbframe->m_Pcb, pt_track, HOLE, marge, WRITE_CELL );
TraceSegmentPcb( pcbframe->m_Pcb, pt_track, VIA_IMPOSSIBLE, via_marge, WRITE_OR_CELL ); TraceSegmentPcb( pcbframe->m_Pcb, pt_track, VIA_IMPOSSIBLE, via_marge, WRITE_OR_CELL );
if(pt_track == g_CurrentTrackSegment ) break; if( pt_track == g_CurrentTrackSegment )
break;
} }
ActiveScreen->SetModify(); ActiveScreen->SetModify();
} }

47
pcbnew/swap_layers.cpp
View File

@ -42,8 +42,8 @@ private:
void Sel_Layer( wxCommandEvent& event ); void Sel_Layer( wxCommandEvent& event );
void Cancel( wxCommandEvent& event ); void Cancel( wxCommandEvent& event );
void Execute( wxCommandEvent& event ); void Execute( wxCommandEvent& event );
DECLARE_EVENT_TABLE()
DECLARE_EVENT_TABLE()
}; };
/* Table des evenements pour WinEDA_SwapLayerFrame */ /* Table des evenements pour WinEDA_SwapLayerFrame */
BEGIN_EVENT_TABLE( WinEDA_SwapLayerFrame, wxDialog ) BEGIN_EVENT_TABLE( WinEDA_SwapLayerFrame, wxDialog )
@ -75,39 +75,44 @@ wxSize winsize;
{ {
g_Layer_Name_Pair[ii] = ReturnPcbLayerName( ii ) + wxT( " -> " ) + _( "No Change" ); g_Layer_Name_Pair[ii] = ReturnPcbLayerName( ii ) + wxT( " -> " ) + _( "No Change" );
} }
pos.x = 5; pos.y = START_Y; pos.x = 5; pos.y = START_Y;
m_LayerList = new wxRadioBox( this, ID_SWAP_LAYER_SELECT, _( "Layers" ), m_LayerList = new wxRadioBox( this, ID_SWAP_LAYER_SELECT, _( "Layers" ),
pos, wxSize(-1,-1), 29, g_Layer_Name_Pair, 16, wxRA_SPECIFY_ROWS); pos,
wxSize( -1, -1 ), 29, g_Layer_Name_Pair, 16, wxRA_SPECIFY_ROWS );
winsize.y = m_LayerList->GetRect().GetBottom(); winsize.y = m_LayerList->GetRect().GetBottom();
pos.x = m_LayerList->GetRect().GetRight() + 12; pos.x = m_LayerList->GetRect().GetRight() + 12;
Button = new wxButton( this, ID_SWAP_LAYER_CANCEL, Button = new wxButton( this, ID_SWAP_LAYER_CANCEL,
_( "Cancel" ), pos ); _( "Cancel" ), pos );
Button->SetForegroundColour( *wxRED ); Button->SetForegroundColour( *wxRED );
winsize.x = MAX( winsize.x, Button->GetRect().GetRight() ); winsize.x = MAX( winsize.x, Button->GetRect().GetRight() );
pos.y += Button->GetSize().y + 5; pos.y += Button->GetSize().y + 5;
Button = new wxButton( this, ID_SWAP_LAYER_EXECUTE, Button = new wxButton( this, ID_SWAP_LAYER_EXECUTE,
_( "OK" ), pos ); _( "OK" ), pos );
Button->SetForegroundColour( *wxBLUE ); Button->SetForegroundColour( *wxBLUE );
winsize.x = MAX( winsize.x, Button->GetRect().GetRight() ); winsize.x = MAX( winsize.x, Button->GetRect().GetRight() );
pos.y += Button->GetSize().y + 15; pos.y += Button->GetSize().y + 15;
Button = new wxButton( this, ID_SWAP_LAYER_DESELECT, Button = new wxButton( this, ID_SWAP_LAYER_DESELECT,
_( "Deselect" ), pos ); _( "Deselect" ), pos );
Button->SetForegroundColour( wxColour( 0, 100, 0 ) ); Button->SetForegroundColour( wxColour( 0, 100, 0 ) );
winsize.x = MAX( winsize.x, Button->GetRect().GetRight() ); winsize.x = MAX( winsize.x, Button->GetRect().GetRight() );
pos.y += Button->GetSize().y + 5; pos.y += Button->GetSize().y + 5;
Button = new wxButton( this, ID_SWAP_LAYER_BUTTON_SELECT, Button = new wxButton( this, ID_SWAP_LAYER_BUTTON_SELECT,
_( "Select" ), pos ); _( "Select" ), pos );
Button->SetForegroundColour( wxColour( 0, 100, 100 ) ); Button->SetForegroundColour( wxColour( 0, 100, 100 ) );
winsize.x = MAX( winsize.x, Button->GetRect().GetRight() ); winsize.x = MAX( winsize.x, Button->GetRect().GetRight() );
winsize.x += 10; winsize.y += 10; winsize.x += 10; winsize.y += 10;
SetClientSize( winsize ); SetClientSize( winsize );
} }
@ -133,18 +138,21 @@ void WinEDA_SwapLayerFrame::Sel_Layer(wxCommandEvent& event)
case ID_SWAP_LAYER_BUTTON_SELECT: case ID_SWAP_LAYER_BUTTON_SELECT:
case ID_SWAP_LAYER_SELECT: case ID_SWAP_LAYER_SELECT:
jj = m_Parent->SelectLayer( ii, -1, -1 ); jj = m_Parent->SelectLayer( ii, -1, -1 );
if ( (jj < 0) || (jj >= 29) ) return; if( (jj < 0) || (jj >= 29) )
return;
if( ii != jj ) if( ii != jj )
{ {
New_Layer[ii] = jj; New_Layer[ii] = jj;
m_LayerList->SetString( ii, m_LayerList->SetString( ii,
ReturnPcbLayerName(ii) + wxT(" -> ") + ReturnPcbLayerName(jj) ); ReturnPcbLayerName( ii ) + wxT( " -> " ) +
ReturnPcbLayerName( jj ) );
} }
break; break;
} }
} }
/*********************************************************/ /*********************************************************/
void WinEDA_SwapLayerFrame::Cancel( wxCommandEvent& event ) void WinEDA_SwapLayerFrame::Cancel( wxCommandEvent& event )
/*********************************************************/ /*********************************************************/
@ -152,6 +160,7 @@ void WinEDA_SwapLayerFrame::Cancel(wxCommandEvent& event)
EndModal( -1 ); EndModal( -1 );
} }
/*********************************************************/ /*********************************************************/
void WinEDA_SwapLayerFrame::Execute( wxCommandEvent& event ) void WinEDA_SwapLayerFrame::Execute( wxCommandEvent& event )
/*********************************************************/ /*********************************************************/
@ -172,12 +181,15 @@ EDA_BaseStruct * PtStruct;
/* Init default values */ /* Init default values */
for ( ii = 0 ; ii < 32 ; ii++ ) New_Layer[ii] = -1 ; for( ii = 0; ii < 32; ii++ )
New_Layer[ii] = -1;
WinEDA_SwapLayerFrame* frame = new WinEDA_SwapLayerFrame( this ); WinEDA_SwapLayerFrame* frame = new WinEDA_SwapLayerFrame( this );
ii = frame->ShowModal(); frame->Destroy(); ii = frame->ShowModal(); frame->Destroy();
if ( ii != 1 ) return; if( ii != 1 )
return;
/* Modifications des pistes */ /* Modifications des pistes */
pt_segm = (TRACK*) m_Pcb->m_Track; pt_segm = (TRACK*) m_Pcb->m_Track;
@ -187,7 +199,8 @@ WinEDA_SwapLayerFrame * frame = new WinEDA_SwapLayerFrame(this);
if( pt_segm->m_StructType == TYPEVIA ) if( pt_segm->m_StructType == TYPEVIA )
{ {
SEGVIA* Via = (SEGVIA*) pt_segm; SEGVIA* Via = (SEGVIA*) pt_segm;
if ( Via->Shape() == VIA_NORMALE ) continue; if( Via->Shape() == VIA_NORMALE )
continue;
int top_layer, bottom_layer; int top_layer, bottom_layer;
Via->ReturnLayerPair( &top_layer, &bottom_layer ); Via->ReturnLayerPair( &top_layer, &bottom_layer );
if( New_Layer[bottom_layer] >= 0 ) if( New_Layer[bottom_layer] >= 0 )
@ -198,8 +211,9 @@ WinEDA_SwapLayerFrame * frame = new WinEDA_SwapLayerFrame(this);
} }
else else
{ {
jj = pt_segm->m_Layer; jj = pt_segm->GetLayer();
if( New_Layer[jj] >= 0) pt_segm->m_Layer = New_Layer[jj]; if( New_Layer[jj] >= 0 )
pt_segm->SetLayer( New_Layer[jj] );
} }
} }
@ -208,8 +222,9 @@ WinEDA_SwapLayerFrame * frame = new WinEDA_SwapLayerFrame(this);
for( ; pt_segm != NULL; pt_segm = (TRACK*) pt_segm->Pnext ) for( ; pt_segm != NULL; pt_segm = (TRACK*) pt_segm->Pnext )
{ {
m_CurrentScreen->SetModify(); m_CurrentScreen->SetModify();
jj = pt_segm->m_Layer; jj = pt_segm->GetLayer();
if( New_Layer[jj] >= 0) pt_segm->m_Layer = New_Layer[jj]; if( New_Layer[jj] >= 0 )
pt_segm->SetLayer( New_Layer[jj] );
} }
/* Modifications des autres segments */ /* Modifications des autres segments */
@ -220,11 +235,11 @@ WinEDA_SwapLayerFrame * frame = new WinEDA_SwapLayerFrame(this);
{ {
m_CurrentScreen->SetModify(); m_CurrentScreen->SetModify();
pt_drawsegm = (DRAWSEGMENT*) PtStruct; pt_drawsegm = (DRAWSEGMENT*) PtStruct;
jj = pt_drawsegm->m_Layer; jj = pt_drawsegm->GetLayer();
if( New_Layer[jj] >= 0) pt_drawsegm->m_Layer = New_Layer[jj]; if( New_Layer[jj] >= 0 )
pt_drawsegm->SetLayer( New_Layer[jj] );
} }
} }
DrawPanel->Refresh( TRUE ); DrawPanel->Refresh( TRUE );
} }

4
pcbnew/tracepcb.cpp
View File

@ -123,13 +123,13 @@ void WinEDA_PcbFrame::Trace_Pcb( wxDC* DC, int mode )
if( !DisplayOpt.Show_Modules_Cmp ) if( !DisplayOpt.Show_Modules_Cmp )
{ {
if( Module->m_Layer == CMP_N ) if( Module->GetLayer() == CMP_N )
display = FALSE; display = FALSE;
MaskLay &= ~CMP_LAYER; MaskLay &= ~CMP_LAYER;
} }
if( !DisplayOpt.Show_Modules_Cu ) if( !DisplayOpt.Show_Modules_Cu )
{ {
if( Module->m_Layer == CUIVRE_N ) if( Module->GetLayer() == CUIVRE_N )
display = FALSE; display = FALSE;
MaskLay &= ~CUIVRE_LAYER; MaskLay &= ~CUIVRE_LAYER;
} }

119
pcbnew/track.cpp
View File

@ -17,8 +17,7 @@ public:
TRACK* RefTrack; TRACK* RefTrack;
public: public:
TSTSEGM(TRACK * Father) TSTSEGM( TRACK * Father ) {
{
Pback = Pnext = NULL; Pback = Pnext = NULL;
RefTrack = Father; RefTrack = Father;
} }
@ -38,14 +37,15 @@ TSTSEGM * ListSegm = NULL;
TRACK* Marque_Une_Piste( WinEDA_BasePcbFrame* frame, wxDC* DC, TRACK* Marque_Une_Piste( WinEDA_BasePcbFrame* frame, wxDC* DC,
TRACK* pt_segm, int* nb_segm, int flagcolor ) TRACK* pt_segm, int* nb_segm, int flagcolor )
/****************************************************************************/ /****************************************************************************/
/* Routine de Marquage de 1 piste, a partir du segment pointe par pt_segm. /* Routine de Marquage de 1 piste, a partir du segment pointe par pt_segm.
le segment pointe est marque puis les segments connectes * le segment pointe est marque puis les segments connectes
jusqu'a un pad ou un point de jonction de plus de 2 segments * jusqu'a un pad ou un point de jonction de plus de 2 segments
le marquage est la mise a 1 du bit BUSY * le marquage est la mise a 1 du bit BUSY
Les segments sont ensuite reclasses pour etre contigus en liste chainee * Les segments sont ensuite reclasses pour etre contigus en liste chainee
Retourne: * Retourne:
adresse du 1er segment de la chaine creee * adresse du 1er segment de la chaine creee
nombre de segments * nombre de segments
*/ */
{ {
int NbSegmBusy, masque_layer; int NbSegmBusy, masque_layer;
@ -53,18 +53,20 @@ TRACK *Track, *FirstTrack, *NextTrack;
TSTSEGM* Segm, * NextSegm; TSTSEGM* Segm, * NextSegm;
*nb_segm = 0; *nb_segm = 0;
if (pt_segm == NULL ) return(NULL) ; if( pt_segm == NULL )
return NULL;
/* Marquage du segment pointe */ /* Marquage du segment pointe */
if(flagcolor) pt_segm->Draw(frame->DrawPanel, DC, flagcolor); if( flagcolor )
pt_segm->Draw( frame->DrawPanel, DC, flagcolor );
pt_segm->SetState( BUSY, ON ); pt_segm->SetState( BUSY, ON );
masque_layer = pt_segm->ReturnMaskLayer(); masque_layer = pt_segm->ReturnMaskLayer();
ListSegm = new TSTSEGM( pt_segm ); ListSegm = new TSTSEGM( pt_segm );
/* Traitement du segment pointe : si c'est un segment, le cas est simple. /* Traitement du segment pointe : si c'est un segment, le cas est simple.
Si c'est une via, on doit examiner le nombre de segments connectes. * Si c'est une via, on doit examiner le nombre de segments connectes.
Si <=2, on doit detecter une piste, si > 2 seule la via est marquee * Si <=2, on doit detecter une piste, si > 2 seule la via est marquee
*/ */
if( pt_segm->m_StructType == TYPEVIA ) if( pt_segm->m_StructType == TYPEVIA )
{ {
@ -83,7 +85,7 @@ TSTSEGM * Segm, * NextSegm;
} }
if( Segm3 ) if( Segm3 )
{ {
*nb_segm = 1; return (pt_segm); *nb_segm = 1; return pt_segm;
} }
if( Segm1 ) if( Segm1 )
{ {
@ -106,21 +108,24 @@ TSTSEGM * Segm, * NextSegm;
for( Segm = ListSegm; Segm != NULL; Segm = Segm->Pnext ) for( Segm = ListSegm; Segm != NULL; Segm = Segm->Pnext )
{ {
int layer; int layer;
if( Segm->RefTrack->m_StructType != TYPEVIA ) continue; if( Segm->RefTrack->m_StructType != TYPEVIA )
if( Segm->RefTrack == pt_segm ) continue; continue;
if( Segm->RefTrack == pt_segm )
continue;
Segm->RefTrack->SetState( BUSY, ON ); Segm->RefTrack->SetState( BUSY, ON );
masque_layer = Segm->RefTrack->ReturnMaskLayer(); masque_layer = Segm->RefTrack->ReturnMaskLayer();
Track = Fast_Locate_Piste( frame->m_Pcb->m_Track, NULL, Track = Fast_Locate_Piste( frame->m_Pcb->m_Track, NULL,
Segm->RefTrack->m_Start, Segm->RefTrack->m_Start,
masque_layer ); masque_layer );
if( Track == NULL ) continue; if( Track == NULL )
continue;
/* Test des connexions: si via utile: suppression marquage */ /* Test des connexions: si via utile: suppression marquage */
layer = Track->m_Layer; layer = Track->GetLayer();
while( ( Track = Fast_Locate_Piste( (TRACK*) Track->Pnext, NULL, while( ( Track = Fast_Locate_Piste( (TRACK*) Track->Pnext, NULL,
Segm->RefTrack->m_Start, Segm->RefTrack->m_Start,
masque_layer ) ) != NULL ) masque_layer ) ) != NULL )
{ {
if( layer != Track->m_Layer ) if( layer != Track->GetLayer() )
{ {
Segm->RefTrack->SetState( BUSY, OFF ); Segm->RefTrack->SetState( BUSY, OFF );
break; break;
@ -133,6 +138,7 @@ TSTSEGM * Segm, * NextSegm;
{ {
NextSegm = Segm->Pnext; delete Segm; NextSegm = Segm->Pnext; delete Segm;
} }
ListSegm = NULL; ListSegm = NULL;
/* Reclassement des segments marques en une chaine */ /* Reclassement des segments marques en une chaine */
@ -146,7 +152,7 @@ TSTSEGM * Segm, * NextSegm;
} }
/* Reclassement de la chaine debutant a FirstTrack et finissant /* Reclassement de la chaine debutant a FirstTrack et finissant
au dernier segment marque. FirstTrack n'est pas modifie */ * au dernier segment marque. FirstTrack n'est pas modifie */
Track = (TRACK*) FirstTrack->Pnext; Track = (TRACK*) FirstTrack->Pnext;
for( ; Track != NULL; Track = NextTrack ) for( ; Track != NULL; Track = NextTrack )
{ {
@ -161,22 +167,24 @@ TSTSEGM * Segm, * NextSegm;
*nb_segm = NbSegmBusy; *nb_segm = NbSegmBusy;
if(flagcolor) Trace_Une_Piste(frame->DrawPanel, DC, FirstTrack,NbSegmBusy,flagcolor); if( flagcolor )
Trace_Une_Piste( frame->DrawPanel, DC, FirstTrack, NbSegmBusy, flagcolor );
return(FirstTrack); return FirstTrack;
} }
/********************************************************************************/ /********************************************************************************/
static void Marque_Chaine_segments( BOARD* Pcb, wxPoint ref_pos, int masque_layer ) static void Marque_Chaine_segments( BOARD* Pcb, wxPoint ref_pos, int masque_layer )
/********************************************************************************/ /********************************************************************************/
/*
routine utilisee par Supprime_1_Piste()
Positionne le bit BUSY dans la chaine de segments commencant
au point ox, oy sur la couche layer
Les vias sont mises en liste des segments traites mais ne sont pas /*
marquees. * routine utilisee par Supprime_1_Piste()
* Positionne le bit BUSY dans la chaine de segments commencant
* au point ox, oy sur la couche layer
*
* Les vias sont mises en liste des segments traites mais ne sont pas
* marquees.
*/ */
{ {
TRACK* pt_segm, // Pointe le segment courant analyse TRACK* pt_segm, // Pointe le segment courant analyse
@ -185,29 +193,33 @@ TRACK *pt_segm, // Pointe le segment courant analyse
int NbSegm; int NbSegm;
TSTSEGM* Segm; TSTSEGM* Segm;
if(Pcb->m_Track == NULL) return; if( Pcb->m_Track == NULL )
return;
/* Marquage de la chaine */ /* Marquage de la chaine */
for( ; ; ) for( ; ; )
{ {
if( Fast_Locate_Pad_Connecte(Pcb, ref_pos,masque_layer) != NULL ) return; if( Fast_Locate_Pad_Connecte( Pcb, ref_pos, masque_layer ) != NULL )
return;
/* Localisation d'une via (car elle connecte plusieurs segments) */ /* Localisation d'une via (car elle connecte plusieurs segments) */
pt_via = Fast_Locate_Via( Pcb->m_Track, NULL, ref_pos, masque_layer ); pt_via = Fast_Locate_Via( Pcb->m_Track, NULL, ref_pos, masque_layer );
if( pt_via ) if( pt_via )
{ {
if(pt_via->GetState(EDIT)) return; if( pt_via->GetState( EDIT ) )
return;
masque_layer = pt_via->ReturnMaskLayer(); masque_layer = pt_via->ReturnMaskLayer();
Segm = new TSTSEGM( pt_via ); Segm = new TSTSEGM( pt_via );
Segm->Pnext = ListSegm; Segm->Pnext = ListSegm;
ListSegm->Pback = Segm; ListSegm->Pback = Segm;
ListSegm = Segm; ListSegm = Segm;
} }
/* Recherche des segments connectes au point ref_pos /* Recherche des segments connectes au point ref_pos
si 1 segment: peut etre marque * si 1 segment: peut etre marque
si > 1 segment: * si > 1 segment:
le segment ne peut etre marque * le segment ne peut etre marque
*/ */
pt_segm = Pcb->m_Track; MarqSegm = NULL; pt_segm = Pcb->m_Track; MarqSegm = NULL;
NbSegm = 0; NbSegm = 0;
@ -249,7 +261,8 @@ TSTSEGM * Segm;
{ {
ref_pos = MarqSegm->m_End; ref_pos = MarqSegm->m_End;
} }
else { else
{
ref_pos = MarqSegm->m_Start; ref_pos = MarqSegm->m_Start;
} }
@ -257,12 +270,14 @@ TSTSEGM * Segm;
/* Marquage et mise en liste du segment */ /* Marquage et mise en liste du segment */
Segm = new TSTSEGM( MarqSegm ); Segm = new TSTSEGM( MarqSegm );
Segm->Pnext = ListSegm; Segm->Pnext = ListSegm;
ListSegm->Pback = Segm; ListSegm->Pback = Segm;
ListSegm = Segm; ListSegm = Segm;
MarqSegm->SetState( BUSY, ON ); MarqSegm->SetState( BUSY, ON );
} }
else return; else
return;
} }
} }
@ -271,12 +286,13 @@ TSTSEGM * Segm;
int ReturnEndsTrack( TRACK* RefTrack, int NbSegm, int ReturnEndsTrack( TRACK* RefTrack, int NbSegm,
TRACK** StartTrack, TRACK** EndTrack ) TRACK** StartTrack, TRACK** EndTrack )
/**********************************************************/ /**********************************************************/
/* Calcule les coordonnes des extremites d'une piste /* Calcule les coordonnes des extremites d'une piste
retourne 1 si OK, 0 si piste bouclee * retourne 1 si OK, 0 si piste bouclee
Retourne dans *StartTrack en *EndTrack les segments de debut et fin * Retourne dans *StartTrack en *EndTrack les segments de debut et fin
Les coord StartTrack->m_Start.x, m_Start.y contiennent le debut de la piste * Les coord StartTrack->m_Start.x, m_Start.y contiennent le debut de la piste
Les coord EndTrack->m_End.x, m_End.y contiennent le debut de la piste * Les coord EndTrack->m_End.x, m_End.y contiennent le debut de la piste
Les segments sont supposes chaines de facon consecutive * Les segments sont supposes chaines de facon consecutive
*/ */
{ {
TRACK* Track, * via, * segm, * TrackListEnd; TRACK* Track, * via, * segm, * TrackListEnd;
@ -285,7 +301,7 @@ int NbEnds, masque_layer, ii, ok = 0;
if( NbSegm <= 1 ) if( NbSegm <= 1 )
{ {
*StartTrack = *EndTrack = RefTrack; *StartTrack = *EndTrack = RefTrack;
return(1); /* cas trivial */ return 1; /* cas trivial */
} }
/* calcul de la limite d'analyse */ /* calcul de la limite d'analyse */
@ -301,7 +317,8 @@ int NbEnds, masque_layer, ii, ok = 0;
NbEnds = 0; Track = RefTrack; ii = 0; NbEnds = 0; Track = RefTrack; ii = 0;
for( ; (Track != NULL) && (ii < NbSegm); ii++, Track = (TRACK*) Track->Pnext ) for( ; (Track != NULL) && (ii < NbSegm); ii++, Track = (TRACK*) Track->Pnext )
{ {
if(Track->m_StructType == TYPEVIA) continue; if( Track->m_StructType == TYPEVIA )
continue;
masque_layer = Track->ReturnMaskLayer(); masque_layer = Track->ReturnMaskLayer();
via = Fast_Locate_Via( RefTrack, TrackListEnd, via = Fast_Locate_Via( RefTrack, TrackListEnd,
@ -316,7 +333,8 @@ int NbEnds, masque_layer, ii, ok = 0;
segm = Fast_Locate_Piste( RefTrack, TrackListEnd, segm = Fast_Locate_Piste( RefTrack, TrackListEnd,
Track->m_Start, masque_layer ); Track->m_Start, masque_layer );
Track->SetState( BUSY, OFF ); Track->SetState( BUSY, OFF );
if(via) via->SetState(BUSY,OFF); if( via )
via->SetState( BUSY, OFF );
if( segm == NULL ) if( segm == NULL )
{ {
@ -339,7 +357,7 @@ int NbEnds, masque_layer, ii, ok = 0;
Track->SetState( BEGIN_ONPAD, ON ); Track->SetState( BEGIN_ONPAD, ON );
EXCHG( Track->m_Start, Track->m_End ); EXCHG( Track->m_Start, Track->m_End );
EXCHG( Track->start, Track->end ); EXCHG( Track->start, Track->end );
ok = 1; return(ok); ok = 1; return ok;
} }
} }
@ -356,7 +374,8 @@ int NbEnds, masque_layer, ii, ok = 0;
segm = Fast_Locate_Piste( RefTrack, TrackListEnd, segm = Fast_Locate_Piste( RefTrack, TrackListEnd,
Track->m_End, masque_layer ); Track->m_End, masque_layer );
Track->SetState( BUSY, OFF ); Track->SetState( BUSY, OFF );
if (via) via->SetState(BUSY,OFF); if( via )
via->SetState( BUSY, OFF );
if( segm == NULL ) if( segm == NULL )
{ {
switch( NbEnds ) switch( NbEnds )
@ -378,22 +397,24 @@ int NbEnds, masque_layer, ii, ok = 0;
case 1: case 1:
*EndTrack = Track; *EndTrack = Track;
ok = 1; return(ok); ok = 1; return ok;
} }
} }
} }
return(ok); return ok;
} }
/***************************************************************************/ /***************************************************************************/
void ListSetState( EDA_BaseStruct* Start, int NbItem, int State, int onoff ) void ListSetState( EDA_BaseStruct* Start, int NbItem, int State, int onoff )
/***************************************************************************/ /***************************************************************************/
/* Met a jour le membre .state d'une chaine de structures /* Met a jour le membre .state d'une chaine de structures
*/ */
{ {
if(Start == NULL ) return; if( Start == NULL )
return;
for( ; (Start != NULL) && (NbItem > 0); NbItem--, Start = Start->Pnext ) for( ; (Start != NULL) && (NbItem > 0); NbItem--, Start = Start->Pnext )
{ {
Start->SetState( State, onoff ); Start->SetState( State, onoff );

60
pcbnew/trpiste.cpp
View File

@ -16,6 +16,7 @@
/*********************************************************************************/ /*********************************************************************************/
void Trace_Pistes( WinEDA_DrawPanel* panel, BOARD* Pcb, wxDC* DC, int drawmode ) void Trace_Pistes( WinEDA_DrawPanel* panel, BOARD* Pcb, wxDC* DC, int drawmode )
/********************************************************************************/ /********************************************************************************/
/* Draw all tracks and zones. /* Draw all tracks and zones.
*/ */
{ {
@ -35,41 +36,45 @@ TRACK * track;
} }
/************************************************************************/ /************************************************************************/
void Trace_Une_Piste( WinEDA_DrawPanel* panel, wxDC* DC, TRACK* Track, void Trace_Une_Piste( WinEDA_DrawPanel* panel, wxDC* DC, TRACK* Track,
int nbsegment, int draw_mode ) int nbsegment, int draw_mode )
/************************************************************************/ /************************************************************************/
/* routine de trace de n segments consecutifs en memoire. /* routine de trace de n segments consecutifs en memoire.
Utile pour monter une piste en cours de trace car les segments de cette * Utile pour monter une piste en cours de trace car les segments de cette
piste sont alors contigus en memoire * piste sont alors contigus en memoire
Parametres : * Parametres :
pt_start_piste = adresse de depart de la liste des segments * pt_start_piste = adresse de depart de la liste des segments
nbsegment = nombre de segments a tracer * nbsegment = nombre de segments a tracer
draw_mode = mode ( GR_XOR, GR_OR..) * draw_mode = mode ( GR_XOR, GR_OR..)
ATTENTION: * ATTENTION:
le point de depart d'une piste suivante DOIT exister: peut etre * le point de depart d'une piste suivante DOIT exister: peut etre
donc mis a 0 avant appel a la routine si la piste a tracer est la derniere * donc mis a 0 avant appel a la routine si la piste a tracer est la derniere
*/ */
{ {
if ( Track == NULL ) return; if( Track == NULL )
return;
for( ; nbsegment > 0; nbsegment--, Track = (TRACK*) Track->Pnext ) for( ; nbsegment > 0; nbsegment--, Track = (TRACK*) Track->Pnext )
{ {
if ( Track == NULL ) break; if( Track == NULL )
break;
Track->Draw( panel, DC, draw_mode ); Track->Draw( panel, DC, draw_mode );
} }
} }
/*************************************************************/ /*************************************************************/
void Trace_DrawSegmentPcb( WinEDA_DrawPanel* panel, wxDC* DC, void Trace_DrawSegmentPcb( WinEDA_DrawPanel* panel, wxDC* DC,
DRAWSEGMENT* PtDrawSegment, int draw_mode ) DRAWSEGMENT* PtDrawSegment, int draw_mode )
/*************************************************************/ /*************************************************************/
/* Affichage d'un segment type drawing PCB: /* Affichage d'un segment type drawing PCB:
draw_mode = mode de trace ( GR_OR, GR_XOR, GrAND) * draw_mode = mode de trace ( GR_OR, GR_XOR, GrAND)
Les contours sont de differents type: * Les contours sont de differents type:
segment * segment
cercle * cercle
arc * arc
*/ */
{ {
int ux0, uy0, dx, dy; int ux0, uy0, dx, dy;
@ -78,11 +83,14 @@ int color, mode;
int zoom; int zoom;
int rayon; int rayon;
color = g_DesignSettings.m_LayerColor[PtDrawSegment->m_Layer]; color = g_DesignSettings.m_LayerColor[PtDrawSegment->GetLayer()];
if(color & ITEM_NOT_SHOW ) return ; if( color & ITEM_NOT_SHOW )
return;
if ( panel ) zoom = panel->GetZoom(); if( panel )
else zoom = ActiveScreen->GetZoom(); zoom = panel->GetZoom();
else
zoom = ActiveScreen->GetZoom();
GRSetDrawMode( DC, draw_mode ); GRSetDrawMode( DC, draw_mode );
l_piste = PtDrawSegment->m_Width >> 1; /* l_piste = demi largeur piste */ l_piste = PtDrawSegment->m_Width >> 1; /* l_piste = demi largeur piste */
@ -96,8 +104,10 @@ int rayon;
mode = DisplayOpt.DisplayDrawItems; mode = DisplayOpt.DisplayDrawItems;
if(PtDrawSegment->m_Flags & FORCE_SKETCH) mode = SKETCH; if( PtDrawSegment->m_Flags & FORCE_SKETCH )
if ( l_piste < (L_MIN_DESSIN * zoom) ) mode = FILAIRE; mode = SKETCH;
if( l_piste < (L_MIN_DESSIN * zoom) )
mode = FILAIRE;
switch( PtDrawSegment->m_Shape ) switch( PtDrawSegment->m_Shape )
{ {
@ -124,7 +134,8 @@ int rayon;
rayon = (int) hypot( (double) (dx - ux0), (double) (dy - uy0) ); rayon = (int) hypot( (double) (dx - ux0), (double) (dy - uy0) );
StAngle = (int) ArcTangente( dy - uy0, dx - ux0 ); StAngle = (int) ArcTangente( dy - uy0, dx - ux0 );
EndAngle = StAngle + PtDrawSegment->m_Angle; EndAngle = StAngle + PtDrawSegment->m_Angle;
if ( StAngle > EndAngle) EXCHG (StAngle, EndAngle); if( StAngle > EndAngle )
EXCHG( StAngle, EndAngle );
if( mode == FILAIRE ) if( mode == FILAIRE )
GRArc( &panel->m_ClipBox, DC, ux0, uy0, StAngle, EndAngle, rayon, color ); GRArc( &panel->m_ClipBox, DC, ux0, uy0, StAngle, EndAngle, rayon, color );
else if( mode == SKETCH ) else if( mode == SKETCH )
@ -158,4 +169,3 @@ int rayon;
break; break;
} }
} }

183
pcbnew/xchgmod.cpp
View File

@ -14,8 +14,7 @@
/* variables locales */ /* variables locales */
enum id_ExchangeModule enum id_ExchangeModule {
{
ID_EXEC_EXCHANGE_MODULE = 1900, ID_EXEC_EXCHANGE_MODULE = 1900,
ID_EXEC_EXCHANGE_ID_MODULES, ID_EXEC_EXCHANGE_ID_MODULES,
ID_EXEC_EXCHANGE_ID_MODULE_AND_VALUE, ID_EXEC_EXCHANGE_ID_MODULE_AND_VALUE,
@ -41,6 +40,7 @@ private:
wxTextCtrl* m_WinMsg; wxTextCtrl* m_WinMsg;
public: public:
// Constructor and destructor // Constructor and destructor
WinEDA_ExchangeModuleFrame( WinEDA_BasePcbFrame * parent, WinEDA_ExchangeModuleFrame( WinEDA_BasePcbFrame * parent,
MODULE * Module, wxDC * DC, const wxPoint &pos ); MODULE * Module, wxDC * DC, const wxPoint &pos );
@ -90,53 +90,67 @@ wxButton * Button;
m_CurrentModule = Module; m_CurrentModule = Module;
wxBoxSizer* MainBoxSizer = new wxBoxSizer( wxVERTICAL ); wxBoxSizer* MainBoxSizer = new wxBoxSizer( wxVERTICAL );
SetSizer( MainBoxSizer ); SetSizer( MainBoxSizer );
wxBoxSizer* UpperBoxSizer = new wxBoxSizer( wxHORIZONTAL ); wxBoxSizer* UpperBoxSizer = new wxBoxSizer( wxHORIZONTAL );
MainBoxSizer->Add( UpperBoxSizer, 0, wxGROW | wxALL, 5 ); MainBoxSizer->Add( UpperBoxSizer, 0, wxGROW | wxALL, 5 );
wxBoxSizer* LeftBoxSizer = new wxBoxSizer( wxVERTICAL ); wxBoxSizer* LeftBoxSizer = new wxBoxSizer( wxVERTICAL );
wxBoxSizer* RightBoxSizer = new wxBoxSizer( wxVERTICAL ); wxBoxSizer* RightBoxSizer = new wxBoxSizer( wxVERTICAL );
UpperBoxSizer->Add( LeftBoxSizer, 0, wxGROW | wxALL, 5 ); UpperBoxSizer->Add( LeftBoxSizer, 0, wxGROW | wxALL, 5 );
UpperBoxSizer->Add( RightBoxSizer, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5 ); UpperBoxSizer->Add( RightBoxSizer, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5 );
/* Creation des boutons de commande */ /* Creation des boutons de commande */
Button = new wxButton( this, ID_EXEC_EXCHANGE_MODULE, Button = new wxButton( this, ID_EXEC_EXCHANGE_MODULE,
_( "Change module" ) ); _( "Change module" ) );
Button->SetForegroundColour( *wxBLUE ); Button->SetForegroundColour( *wxBLUE );
RightBoxSizer->Add( Button, 0, wxGROW | wxLEFT | wxRIGHT | wxTOP, 5 ); RightBoxSizer->Add( Button, 0, wxGROW | wxLEFT | wxRIGHT | wxTOP, 5 );
Button = new wxButton( this, ID_EXEC_EXCHANGE_ID_MODULES, Button = new wxButton( this, ID_EXEC_EXCHANGE_ID_MODULES,
_( "Change same modules" ) ); _( "Change same modules" ) );
Button->SetForegroundColour( *wxRED ); Button->SetForegroundColour( *wxRED );
RightBoxSizer->Add( Button, 0, wxGROW | wxLEFT | wxRIGHT, 5 ); RightBoxSizer->Add( Button, 0, wxGROW | wxLEFT | wxRIGHT, 5 );
Button = new wxButton( this, ID_EXEC_EXCHANGE_ID_MODULE_AND_VALUE, Button = new wxButton( this, ID_EXEC_EXCHANGE_ID_MODULE_AND_VALUE,
_( "Ch. same module+value" ) ); _( "Ch. same module+value" ) );
Button->SetForegroundColour( *wxRED ); Button->SetForegroundColour( *wxRED );
RightBoxSizer->Add( Button, 0, wxGROW | wxLEFT | wxRIGHT, 5 ); RightBoxSizer->Add( Button, 0, wxGROW | wxLEFT | wxRIGHT, 5 );
Button = new wxButton( this, ID_EXEC_EXCHANGE_ALL_MODULES, Button = new wxButton( this, ID_EXEC_EXCHANGE_ALL_MODULES,
_( "Change all" ) ); _( "Change all" ) );
Button->SetForegroundColour( *wxRED ); Button->SetForegroundColour( *wxRED );
RightBoxSizer->Add( Button, 0, wxGROW | wxLEFT | wxRIGHT, 5 ); RightBoxSizer->Add( Button, 0, wxGROW | wxLEFT | wxRIGHT, 5 );
Button = new wxButton( this, ID_BROWSE_LIB_MODULES, Button = new wxButton( this, ID_BROWSE_LIB_MODULES,
_( "Browse Libs modules" ) ); _( "Browse Libs modules" ) );
Button->SetForegroundColour( wxColour( 0, 100, 0 ) ); Button->SetForegroundColour( wxColour( 0, 100, 0 ) );
RightBoxSizer->Add( Button, 0, wxGROW | wxLEFT | wxRIGHT, 5 ); RightBoxSizer->Add( Button, 0, wxGROW | wxLEFT | wxRIGHT, 5 );
Button = new wxButton( this, ID_CLOSE_EXCHANGE_MODULE, Button = new wxButton( this, ID_CLOSE_EXCHANGE_MODULE,
_( "Close" ) ); _( "Close" ) );
Button->SetForegroundColour( *wxBLUE ); Button->SetForegroundColour( *wxBLUE );
RightBoxSizer->Add( Button, 0, wxGROW | wxLEFT | wxRIGHT | wxBOTTOM, 5 ); RightBoxSizer->Add( Button, 0, wxGROW | wxLEFT | wxRIGHT | wxBOTTOM, 5 );
m_OldModule = new WinEDA_EnterText( this, _( "Current Module" ), m_OldModule = new WinEDA_EnterText( this, _( "Current Module" ),
m_CurrentModule ? m_CurrentModule->m_LibRef.GetData() :wxEmptyString, m_CurrentModule ?
m_CurrentModule->m_LibRef.GetData () : wxEmptyString,
LeftBoxSizer, wxSize( 150, -1 ) ); LeftBoxSizer, wxSize( 150, -1 ) );
m_OldModule->Enable( FALSE ); m_OldModule->Enable( FALSE );
m_OldValue = new WinEDA_EnterText( this, _( "Current Value" ), m_OldValue = new WinEDA_EnterText( this, _( "Current Value" ),
m_CurrentModule ? m_CurrentModule->m_Value->m_Text.GetData() :wxEmptyString, m_CurrentModule ?
m_CurrentModule->m_Value->m_Text.GetData () : wxEmptyString,
LeftBoxSizer, wxSize( 150, -1 ) ); LeftBoxSizer, wxSize( 150, -1 ) );
m_OldValue->Enable( FALSE ); m_OldValue->Enable( FALSE );
m_NewModule = new WinEDA_EnterText( this, _( "New Module" ), m_NewModule = new WinEDA_EnterText( this, _( "New Module" ),
@ -144,6 +158,7 @@ wxButton * Button;
m_WinMsg = new wxTextCtrl( this, -1, wxEmptyString, wxDefaultPosition, wxSize( 340, 230 ), m_WinMsg = new wxTextCtrl( this, -1, wxEmptyString, wxDefaultPosition, wxSize( 340, 230 ),
wxTE_READONLY | wxTE_MULTILINE ); wxTE_READONLY | wxTE_MULTILINE );
MainBoxSizer->Add( m_WinMsg, 0, wxGROW | wxALL, 5 ); MainBoxSizer->Add( m_WinMsg, 0, wxGROW | wxALL, 5 );
GetSizer()->Fit( this ); GetSizer()->Fit( this );
@ -158,6 +173,7 @@ void WinEDA_BasePcbFrame::InstallExchangeModuleFrame( MODULE * Module,
{ {
WinEDA_ExchangeModuleFrame* frame = new WinEDA_ExchangeModuleFrame( this, WinEDA_ExchangeModuleFrame* frame = new WinEDA_ExchangeModuleFrame( this,
Module, DC, pos ); Module, DC, pos );
frame->ShowModal(); frame->Destroy(); frame->ShowModal(); frame->Destroy();
} }
@ -170,20 +186,20 @@ void WinEDA_ExchangeModuleFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
} }
/************************************************************************/ /************************************************************************/
int WinEDA_ExchangeModuleFrame::Maj_ListeCmp( int WinEDA_ExchangeModuleFrame::Maj_ListeCmp(
const wxString& reference, const wxString& reference,
const wxString& old_name, const wxString& old_name,
const wxString& new_name, bool ShowError ) const wxString& new_name, bool ShowError )
/************************************************************************/ /************************************************************************/
/*
Met a jour le fichier name.CMP (s'il existe) apres un echange de module
(par la commande changeMod), si les modules sont geres par ce fichier
Si ShowError != 0 affiche message d'erreur si le fichier .cmp n'est pas /*
trouve. * Met a jour le fichier name.CMP (s'il existe) apres un echange de module
Retoure 1 si erreur * (par la commande changeMod), si les modules sont geres par ce fichier
*
* Si ShowError != 0 affiche message d'erreur si le fichier .cmp n'est pas
* trouve.
* Retoure 1 si erreur
*/ */
{ {
wxString FileNameCmp, tmpfile; wxString FileNameCmp, tmpfile;
@ -191,12 +207,14 @@ FILE * FichCmp, *NewFile;
char Line[1024]; char Line[1024];
wxString msg; wxString msg;
if ( old_name == new_name ) return(0); /* pas de changement de nom */ if( old_name == new_name )
return 0; /* pas de changement de nom */
/* Calcul nom fichier CMP par changement de l'extension du nom netliste */ /* Calcul nom fichier CMP par changement de l'extension du nom netliste */
if( NetNameBuffer == wxEmptyString ) if( NetNameBuffer == wxEmptyString )
FileNameCmp = m_Parent->m_CurrentScreen->m_FileName; FileNameCmp = m_Parent->m_CurrentScreen->m_FileName;
else FileNameCmp = NetNameBuffer; else
FileNameCmp = NetNameBuffer;
ChangeFileNameExt( FileNameCmp, NetCmpExtBuffer ); ChangeFileNameExt( FileNameCmp, NetCmpExtBuffer );
// Modification du fichier .cmp correcpondant // Modification du fichier .cmp correcpondant
@ -208,7 +226,7 @@ wxString msg;
msg.Printf( _( "file %s not found" ), FileNameCmp.GetData() ); msg.Printf( _( "file %s not found" ), FileNameCmp.GetData() );
m_WinMsg->WriteText( msg ); m_WinMsg->WriteText( msg );
} }
return(1); return 1;
} }
/* Analyse du fichier et modif */ /* Analyse du fichier et modif */
@ -222,7 +240,7 @@ wxString msg;
msg.Printf( _( "Unable to create file %s" ), tmpfile.GetData() ); msg.Printf( _( "Unable to create file %s" ), tmpfile.GetData() );
m_WinMsg->WriteText( msg ); m_WinMsg->WriteText( msg );
} }
return(1); return 1;
} }
fgets( Line, sizeof(Line), FichCmp ); fgets( Line, sizeof(Line), FichCmp );
@ -242,8 +260,8 @@ wxString msg;
} }
} }
if ( (strnicmp( Line, "Begin", 5 ) == 0) || if( (strnicmp( Line, "Begin", 5 ) == 0)
(strnicmp( Line, "End", 3) == 0) ) || (strnicmp( Line, "End", 3 ) == 0) )
{ {
start_descr = FALSE; start_descr = FALSE;
} }
@ -264,26 +282,26 @@ wxString msg;
fclose( NewFile ); fclose( NewFile );
wxRemoveFile( FileNameCmp ); wxRemoveFile( FileNameCmp );
wxRenameFile( tmpfile, FileNameCmp ); wxRenameFile( tmpfile, FileNameCmp );
return(0); return 0;
} }
/********************************************************************/ /********************************************************************/
void WinEDA_ExchangeModuleFrame::Change_Module( wxCommandEvent& event ) void WinEDA_ExchangeModuleFrame::Change_Module( wxCommandEvent& event )
/********************************************************************/ /********************************************************************/
/* Routine de changement d'un module: /* Routine de changement d'un module:
Change le module pointe par la souris, par un autre en conservant * Change le module pointe par la souris, par un autre en conservant
- meme orientation * - meme orientation
- meme position * - meme position
- memes textes valeur et ref * - memes textes valeur et ref
- memes netnames pour pads de meme nom * - memes netnames pour pads de meme nom
*/ */
{ {
wxString newmodulename = m_NewModule->GetValue(); wxString newmodulename = m_NewModule->GetValue();
if( newmodulename == wxEmptyString ) return; if( newmodulename == wxEmptyString )
return;
if( Change_1_Module( m_CurrentModule, newmodulename, TRUE ) ) if( Change_1_Module( m_CurrentModule, newmodulename, TRUE ) )
{ {
@ -292,19 +310,20 @@ wxString newmodulename = m_NewModule->GetValue();
} }
} }
/*********************************************************************/ /*********************************************************************/
void WinEDA_ExchangeModuleFrame::Change_ModuleId( wxCommandEvent& event ) void WinEDA_ExchangeModuleFrame::Change_ModuleId( wxCommandEvent& event )
/**********************************************************************/ /**********************************************************************/
/* Routine de changement de tous les modules de meme nom lib que celui /* Routine de changement de tous les modules de meme nom lib que celui
selectionne, en conservant * selectionne, en conservant
- meme orientation * - meme orientation
- meme position * - meme position
- memes textes valeur et ref * - memes textes valeur et ref
- memes netnames pour pads de meme nom * - memes netnames pour pads de meme nom
et en remplacant l'ancien module par le noveau module * et en remplacant l'ancien module par le noveau module
Attention: m_CurrentModule ne pointe plus sur le module de reference * Attention: m_CurrentModule ne pointe plus sur le module de reference
puisque celui ci a ete change!! * puisque celui ci a ete change!!
*/ */
{ {
wxString msg; wxString msg;
@ -315,8 +334,10 @@ wxString value, lib_reference; // pour memo Reflib et value de reference
bool check_module_value = FALSE; bool check_module_value = FALSE;
int ShowErr = 5; // Affiche 5 messages d'err maxi int ShowErr = 5; // Affiche 5 messages d'err maxi
if( m_Parent->m_Pcb->m_Modules == NULL ) return; if( m_Parent->m_Pcb->m_Modules == NULL )
if( newmodulename == wxEmptyString ) return; return;
if( newmodulename == wxEmptyString )
return;
lib_reference = m_CurrentModule->m_LibRef; lib_reference = m_CurrentModule->m_LibRef;
if( event.GetId() == ID_EXEC_EXCHANGE_ID_MODULE_AND_VALUE ) if( event.GetId() == ID_EXEC_EXCHANGE_ID_MODULE_AND_VALUE )
@ -328,23 +349,24 @@ int ShowErr = 5; // Affiche 5 messages d'err maxi
newmodulename.GetData(), newmodulename.GetData(),
m_CurrentModule->m_Value->m_Text.GetData() ); m_CurrentModule->m_Value->m_Text.GetData() );
} }
else else
{ {
msg.Printf( _( "Change modules <%s> -> <%s> ?" ), msg.Printf( _( "Change modules <%s> -> <%s> ?" ),
lib_reference.GetData(), newmodulename.GetData() ); lib_reference.GetData(), newmodulename.GetData() );
} }
if( !IsOK(this, msg) ) return; if( !IsOK( this, msg ) )
return;
/* Le changement s'effectue a partir du dernier module car la routine /* Le changement s'effectue a partir du dernier module car la routine
Change_1_Module() modifie le dernier module de la liste * Change_1_Module() modifie le dernier module de la liste
*/ */
PtModule = m_Parent->m_Pcb->m_Modules; PtModule = m_Parent->m_Pcb->m_Modules;
for( ; PtModule != NULL; PtModule = (MODULE*) PtModule->Pnext ) for( ; PtModule != NULL; PtModule = (MODULE*) PtModule->Pnext )
{ {
if(PtModule->Pnext == NULL) break; if( PtModule->Pnext == NULL )
break;
} }
/* Ici PtModule pointe le dernier module de la liste */ /* Ici PtModule pointe le dernier module de la liste */
@ -360,9 +382,12 @@ int ShowErr = 5; // Affiche 5 messages d'err maxi
continue; continue;
} }
module = Change_1_Module( PtModule, newmodulename.GetData(), ShowErr ); module = Change_1_Module( PtModule, newmodulename.GetData(), ShowErr );
if ( module ) change = TRUE; if( module )
else if (ShowErr) ShowErr--; change = TRUE;
else if( ShowErr )
ShowErr--;
} }
if( change ) if( change )
{ {
m_Parent->m_Pcb->m_Status_Pcb = 0; m_Parent->m_Pcb->m_Status_Pcb = 0;
@ -370,33 +395,38 @@ int ShowErr = 5; // Affiche 5 messages d'err maxi
} }
} }
/***********************************************************************/ /***********************************************************************/
void WinEDA_ExchangeModuleFrame::Change_ModuleAll( wxCommandEvent& event ) void WinEDA_ExchangeModuleFrame::Change_ModuleAll( wxCommandEvent& event )
/***********************************************************************/ /***********************************************************************/
/* Routine de changement de tous les modules par les modules de meme nom lib: /* Routine de changement de tous les modules par les modules de meme nom lib:
en conservant * en conservant
- meme orientation * - meme orientation
- meme position * - meme position
- memes textes valeur et ref * - memes textes valeur et ref
- memes netnames pour pads de meme nom * - memes netnames pour pads de meme nom
*/ */
{ {
MODULE* PtModule, * PtBack; MODULE* PtModule, * PtBack;
bool change = FALSE; bool change = FALSE;
int ShowErr = 5; // Affiche 5 messages d'err maxi int ShowErr = 5; // Affiche 5 messages d'err maxi
if(m_Parent->m_Pcb->m_Modules == NULL) return; if( m_Parent->m_Pcb->m_Modules == NULL )
return;
if( !IsOK(this, _("Change ALL modules ?")) ) return; if( !IsOK( this, _( "Change ALL modules ?" ) ) )
return;
/* Le changement s'effectue a partir du dernier module car la routine /* Le changement s'effectue a partir du dernier module car la routine
Change_1_Module() modifie le dernier module de la liste * Change_1_Module() modifie le dernier module de la liste
*/ */
PtModule = (MODULE*) m_Parent->m_Pcb->m_Modules; PtModule = (MODULE*) m_Parent->m_Pcb->m_Modules;
for( ; PtModule != NULL; PtModule = (MODULE*) PtModule->Pnext ) for( ; PtModule != NULL; PtModule = (MODULE*) PtModule->Pnext )
{ {
if(PtModule->Pnext == NULL) break; if( PtModule->Pnext == NULL )
break;
} }
/* Ici PtModule pointe le dernier module de la liste */ /* Ici PtModule pointe le dernier module de la liste */
@ -405,7 +435,8 @@ int ShowErr = 5; // Affiche 5 messages d'err maxi
PtBack = (MODULE*) PtModule->Pback; PtBack = (MODULE*) PtModule->Pback;
if( Change_1_Module( PtModule, PtModule->m_LibRef.GetData(), ShowErr ) ) if( Change_1_Module( PtModule, PtModule->m_LibRef.GetData(), ShowErr ) )
change = TRUE; change = TRUE;
else if (ShowErr) ShowErr--; else if( ShowErr )
ShowErr--;
} }
if( change ) if( change )
@ -415,26 +446,29 @@ int ShowErr = 5; // Affiche 5 messages d'err maxi
} }
} }
/******************************************************************/ /******************************************************************/
MODULE* WinEDA_ExchangeModuleFrame::Change_1_Module( MODULE* PtModule, MODULE* WinEDA_ExchangeModuleFrame::Change_1_Module( MODULE* PtModule,
const wxString& new_module, bool ShowError ) const wxString& new_module, bool ShowError )
/*******************************************************************/ /*******************************************************************/
/* Routine de changement d'un module: /* Routine de changement d'un module:
Change le module de numero empr, avec le module de nom new_module * Change le module de numero empr, avec le module de nom new_module
- meme orientation * - meme orientation
- meme position * - meme position
- memes textes valeur et ref * - memes textes valeur et ref
- memes netnames pour pads de meme nom * - memes netnames pour pads de meme nom
Retourne : * Retourne :
0 si pas de changement ( si le nouveau module n'est pas en libr) * 0 si pas de changement ( si le nouveau module n'est pas en libr)
1 si OK * 1 si OK
*/ */
{ {
wxString namecmp, oldnamecmp; wxString namecmp, oldnamecmp;
MODULE* NewModule; MODULE* NewModule;
wxString Line; wxString Line;
if(PtModule == NULL) return(NULL); if( PtModule == NULL )
return NULL;
wxBusyCursor dummy; wxBusyCursor dummy;
@ -453,10 +487,11 @@ wxBusyCursor dummy;
if( NewModule == NULL ) /* Nouveau module NON trouve, reaffichage de l'ancien */ if( NewModule == NULL ) /* Nouveau module NON trouve, reaffichage de l'ancien */
{ {
m_WinMsg->WriteText( wxT( "No\n" ) ); m_WinMsg->WriteText( wxT( "No\n" ) );
return(NULL); return NULL;
} }
if ( PtModule == m_CurrentModule ) m_CurrentModule = NewModule; if( PtModule == m_CurrentModule )
m_CurrentModule = NewModule;
m_WinMsg->WriteText( wxT( "Ok\n" ) ); m_WinMsg->WriteText( wxT( "Ok\n" ) );
/* Effacement a l'ecran de l'ancien module */ /* Effacement a l'ecran de l'ancien module */
@ -469,16 +504,18 @@ wxBusyCursor dummy;
Maj_ListeCmp( NewModule->m_Reference->m_Text, oldnamecmp, namecmp, ShowError ); Maj_ListeCmp( NewModule->m_Reference->m_Text, oldnamecmp, namecmp, ShowError );
return(NewModule); return NewModule;
} }
/***********************************************************************************/ /***********************************************************************************/
MODULE* WinEDA_BasePcbFrame::Exchange_Module( wxWindow* winaff, MODULE* WinEDA_BasePcbFrame::Exchange_Module( wxWindow* winaff,
MODULE* OldModule, MODULE* NewModule ) MODULE* OldModule, MODULE* NewModule )
/***********************************************************************************/ /***********************************************************************************/
/* /*
Remplace le module OldModule par le module NewModule (en conservant position, orientation..) * Remplace le module OldModule par le module NewModule (en conservant position, orientation..)
OldModule est supprimé de la memoire. * OldModule est supprimé de la memoire.
*/ */
{ {
wxPoint oldpos;/* memorisation temporaire pos curseur */ wxPoint oldpos;/* memorisation temporaire pos curseur */
@ -499,7 +536,7 @@ D_PAD * pt_pad, * pt_old_pad;
m_CurrentScreen->m_Curseur = oldpos; m_CurrentScreen->m_Curseur = oldpos;
/* Changement eventuel de couche */ /* Changement eventuel de couche */
if( OldModule->m_Layer != NewModule->m_Layer) if( OldModule->GetLayer() != NewModule->GetLayer() )
{ {
Change_Side_Module( NewModule, NULL ); Change_Side_Module( NewModule, NULL );
} }
@ -526,7 +563,8 @@ D_PAD * pt_pad, * pt_old_pad;
pt_old_pad = OldModule->m_Pads; pt_old_pad = OldModule->m_Pads;
for( ; pt_old_pad != NULL; pt_old_pad = (D_PAD*) pt_old_pad->Pnext ) for( ; pt_old_pad != NULL; pt_old_pad = (D_PAD*) pt_old_pad->Pnext )
{ {
if(strnicmp( pt_pad->m_Padname, pt_old_pad->m_Padname,sizeof(pt_pad->m_Padname)) == 0) if( strnicmp( pt_pad->m_Padname, pt_old_pad->m_Padname,
sizeof(pt_pad->m_Padname) ) == 0 )
{ {
pt_pad->m_Netname = pt_old_pad->m_Netname; pt_pad->m_Netname = pt_old_pad->m_Netname;
pt_pad->m_NetCode = pt_old_pad->m_NetCode; pt_pad->m_NetCode = pt_old_pad->m_NetCode;
@ -552,7 +590,10 @@ void WinEDA_ExchangeModuleFrame::Sel_NewMod_By_Liste(wxCommandEvent& event)
{ {
wxString newname; wxString newname;
newname = m_Parent->Select_1_Module_From_List( m_Parent, wxEmptyString, wxEmptyString, wxEmptyString); newname = m_Parent->Select_1_Module_From_List( m_Parent,
wxEmptyString,
wxEmptyString,
wxEmptyString );
if( newname != wxEmptyString ) if( newname != wxEmptyString )
m_NewModule->SetValue( newname ); m_NewModule->SetValue( newname );
} }
@ -577,7 +618,8 @@ wxString msg;
/* Calcul nom fichier CMP par changement de l'extension du nom netliste */ /* Calcul nom fichier CMP par changement de l'extension du nom netliste */
if( NetNameBuffer == wxEmptyString ) if( NetNameBuffer == wxEmptyString )
FullFileNameCmp = m_CurrentScreen->m_FileName; FullFileNameCmp = m_CurrentScreen->m_FileName;
else FullFileNameCmp = NetNameBuffer; else
FullFileNameCmp = NetNameBuffer;
ChangeFileNameExt( FullFileNameCmp, NetCmpExtBuffer ); ChangeFileNameExt( FullFileNameCmp, NetCmpExtBuffer );
mask = wxT( "*" ) + NetCmpExtBuffer; mask = wxT( "*" ) + NetCmpExtBuffer;
@ -590,7 +632,8 @@ wxString msg;
wxFD_SAVE, wxFD_SAVE,
FALSE FALSE
); );
if ( FullFileNameCmp.IsEmpty() ) return FALSE; if( FullFileNameCmp.IsEmpty() )
return FALSE;
FichCmp = wxFopen( FullFileNameCmp, wxT( "wt" ) ); FichCmp = wxFopen( FullFileNameCmp, wxT( "wt" ) );

16
pcbnew/zones.cpp
View File

@ -683,7 +683,7 @@ EDGE_ZONE* WinEDA_PcbFrame::Begin_Zone( void )
newedge->Pback = oldedge; newedge->Pback = oldedge;
if( oldedge ) if( oldedge )
oldedge->Pnext = newedge; oldedge->Pnext = newedge;
newedge->m_Layer = GetScreen()->m_Active_Layer; newedge->SetLayer( GetScreen()->m_Active_Layer );
newedge->m_Width = 2; /* Largeur minimum tracable */ newedge->m_Width = 2; /* Largeur minimum tracable */
newedge->m_Start = newedge->m_End = GetScreen()->m_Curseur; newedge->m_Start = newedge->m_End = GetScreen()->m_Curseur;
@ -702,7 +702,7 @@ EDGE_ZONE* WinEDA_PcbFrame::Begin_Zone( void )
oldedge->Pnext = newedge; oldedge->Pnext = newedge;
newedge->m_Flags = IS_NEW | IS_MOVED; newedge->m_Flags = IS_NEW | IS_MOVED;
newedge->m_Start = newedge->m_End = oldedge->m_End; newedge->m_Start = newedge->m_End = oldedge->m_End;
newedge->m_Layer = GetScreen()->m_Active_Layer; newedge->SetLayer( GetScreen()->m_Active_Layer );
m_Pcb->m_CurrentLimitZone = newedge; m_Pcb->m_CurrentLimitZone = newedge;
} }
} }
@ -777,7 +777,7 @@ static void Show_Zone_Edge_While_MoveMouse( WinEDA_DrawPanel* panel, wxDC* DC, b
edgezone = PtLim = pcbframe->m_Pcb->m_CurrentLimitZone; edgezone = PtLim = pcbframe->m_Pcb->m_CurrentLimitZone;
for( ; PtLim != NULL; PtLim = (EDGE_ZONE*) PtLim->Pback ) for( ; PtLim != NULL; PtLim = (EDGE_ZONE*) PtLim->Pback )
{ {
PtLim->m_Layer = pcbframe->GetScreen()->m_Active_Layer; PtLim->SetLayer( pcbframe->GetScreen()->m_Active_Layer );
} }
/* dessin de la nouvelle piste : mise a jour du point d'arrivee */ /* dessin de la nouvelle piste : mise a jour du point d'arrivee */
@ -849,7 +849,7 @@ void WinEDA_PcbFrame::Fill_Zone( wxDC* DC )
for( ; PtLim != NULL; PtLim = (EDGE_ZONE*) PtLim->Pback ) for( ; PtLim != NULL; PtLim = (EDGE_ZONE*) PtLim->Pback )
{ {
Trace_DrawSegmentPcb( DrawPanel, DC, PtLim, GR_XOR ); Trace_DrawSegmentPcb( DrawPanel, DC, PtLim, GR_XOR );
PtLim->m_Layer = GetScreen()->m_Active_Layer; PtLim->SetLayer( GetScreen()->m_Active_Layer );
Trace_DrawSegmentPcb( DrawPanel, DC, PtLim, GR_XOR ); Trace_DrawSegmentPcb( DrawPanel, DC, PtLim, GR_XOR );
} }
@ -922,7 +922,7 @@ void WinEDA_PcbFrame::Fill_Zone( wxDC* DC )
{ {
if( g_HightLigth_NetCode != pt_segm->m_NetCode ) if( g_HightLigth_NetCode != pt_segm->m_NetCode )
continue; continue;
if( pt_segm->m_Layer != GetScreen()->m_Active_Layer ) if( pt_segm->GetLayer() != GetScreen()->m_Active_Layer )
continue; continue;
if( pt_segm->m_StructType != TYPETRACK ) if( pt_segm->m_StructType != TYPETRACK )
continue; continue;
@ -1086,7 +1086,7 @@ static void Genere_Segments_Zone( WinEDA_PcbFrame* frame, wxDC* DC, int net_code
{ {
/* un segment avait debute de longueur > 0 */ /* un segment avait debute de longueur > 0 */
pt_track = new SEGZONE( frame->m_Pcb ); pt_track = new SEGZONE( frame->m_Pcb );
pt_track->m_Layer = layer; pt_track->SetLayer( layer );
pt_track->m_NetCode = net_code; pt_track->m_NetCode = net_code;
pt_track->m_Width = g_GridRoutingSize; pt_track->m_Width = g_GridRoutingSize;
pt_track->m_Start.x = ux0; pt_track->m_Start.y = uy0; pt_track->m_Start.x = ux0; pt_track->m_Start.y = uy0;
@ -1124,7 +1124,7 @@ static void Genere_Segments_Zone( WinEDA_PcbFrame* frame, wxDC* DC, int net_code
{ {
/* un segment avait debute de longueur > 0 */ /* un segment avait debute de longueur > 0 */
pt_track = new SEGZONE( frame->m_Pcb ); pt_track = new SEGZONE( frame->m_Pcb );
pt_track->m_Layer = layer; pt_track->SetLayer( layer );
pt_track->m_Width = g_GridRoutingSize; pt_track->m_Width = g_GridRoutingSize;
pt_track->m_NetCode = net_code; pt_track->m_NetCode = net_code;
pt_track->m_Start.x = ux0; pt_track->m_Start.y = uy0; pt_track->m_Start.x = ux0; pt_track->m_Start.y = uy0;
@ -1363,7 +1363,7 @@ static bool Genere_Pad_Connexion( WinEDA_PcbFrame* frame, wxDC* DC, int layer )
pt_track = new SEGZONE( frame->m_Pcb ); pt_track = new SEGZONE( frame->m_Pcb );
pt_track->m_Layer = layer; pt_track->SetLayer( layer );
pt_track->m_Width = g_DesignSettings.m_CurrentTrackWidth; pt_track->m_Width = g_DesignSettings.m_CurrentTrackWidth;
pt_track->m_NetCode = g_HightLigth_NetCode; pt_track->m_NetCode = g_HightLigth_NetCode;
pt_track->start = pt_pad; pt_track->start = pt_pad;