Skip to content

K
kicad-source-mirror
Commit afedb361 authored by dickelbeck's avatar dickelbeck
Browse files
Options

gerberview & pcbnew fixes

parent 9c5b539e
Hide whitespace changes
Inline Side-by-side
Showing with 783 additions and 684 deletions
change_log.txt
View file @ afedb361
...@@ -7,15 +7,17 @@ email address. ...@@ -7,15 +7,17 @@ email address.
2007-Sep-25 UPDATE Dick Hollenbeck <dick@softplc.com> 2007-Sep-25 UPDATE Dick Hollenbeck <dick@softplc.com>
================================================================================ ================================================================================
+ pcbnew + pcbnew
* got rid of reference to global display options DisplayOpt.DisplayZones from * removed reference to global display options DisplayOpt.DisplayZones in
collectors.cpp so collectors.cpp can continue to be used in multiple future collectors.cpp so collectors.cpp can continue to be used in multiple future
(non-display related) general contexts. (non-display related) general contexts. I don't want unnecessary dependencies
in there. The way to completely ignore a type is to exclude it from scanList.
The way to sometimes ignore a type is to add support for this in COLLECTORS_GUIDE.
* Moved TYPEZONE to end of AllBoardItems, added GENERAL_COLLECTOR::AllButZones to * Moved TYPEZONE to end of AllBoardItems, added GENERAL_COLLECTOR::AllButZones to
provide support of DisplayOpt.DisplayZones. provide support for DisplayOpt.DisplayZones.
* Added aHotKeyCode to PcbGeneralLocateAndDisplay() * Added aHotKeyCode to PcbGeneralLocateAndDisplay()
+ gerbview + gerbview
* viewer was getting stuck in a loop when loading a bad gerber file. Fixed * viewer was getting stuck in a loop when loading a bad gerber file. Fixed
the bug, but line 223 through 225 of readgerb.cpp need review. the bug, but line 223 through 225 of readgerb.cpp needs review.
* beautified a few files with uncrustify, (any I had to look at). * beautified a few files with uncrustify, (any I had to look at).
......
gerbview/rs274d.cpp
View file @ afedb361
/********************************************************/ /********************************************************/
/**** Routine de lecture et visu d'un fichier GERBER ****/ /**** Routine de lecture et visu d'un fichier GERBER ****/
/********************************************************/ /********************************************************/
#include "fctsys.h" #include "fctsys.h"
...@@ -10,758 +10,854 @@ ...@@ -10,758 +10,854 @@
#include "protos.h" #include "protos.h"
#define IsNumber(x) ( ( ((x) >= '0') && ((x) <='9') ) ||\ #define IsNumber( x ) ( ( ( (x) >= '0' ) && ( (x) <='9' ) ) \
((x) == '-') || ((x) == '+') || ((x) == '.')) || ( (x) == '-' ) || ( (x) == '+' ) || ( (x) == '.' ) )
/* Format Gerber : NOTES : /* Format Gerber : NOTES :
Fonctions preparatoires: * Fonctions preparatoires:
Gn = * Gn =
G01 interpolation lineaire ( trace de droites ) * G01 interpolation lineaire ( trace de droites )
G02,G20,G21 Interpolation circulaire , sens trigo < 0 * G02,G20,G21 Interpolation circulaire , sens trigo < 0
G03,G30,G31 Interpolation circulaire , sens trigo > 0 * G03,G30,G31 Interpolation circulaire , sens trigo > 0
G04 commentaire * G04 commentaire
G06 Interpolation parabolique * G06 Interpolation parabolique
G07 Interpolation cubique * G07 Interpolation cubique
G10 interpolation lineaire ( echelle 10x ) * G10 interpolation lineaire ( echelle 10x )
G11 interpolation lineaire ( echelle 0.1x ) * G11 interpolation lineaire ( echelle 0.1x )
G12 interpolation lineaire ( echelle 0.01x ) * G12 interpolation lineaire ( echelle 0.01x )
G52 plot symbole reference par Dnn code * G52 plot symbole reference par Dnn code
G53 plot symbole reference par Dnn ; symbole tourne de -90 degres * G53 plot symbole reference par Dnn ; symbole tourne de -90 degres
G54 Selection d'outil * G54 Selection d'outil
G55 Mode exposition photo * G55 Mode exposition photo
G56 plot symbole reference par Dnn A code * G56 plot symbole reference par Dnn A code
G57 affiche le symbole reference sur la console * G57 affiche le symbole reference sur la console
G58 plot et affiche le symbole reference sur la console * G58 plot et affiche le symbole reference sur la console
G60 interpolation lineaire ( echelle 100x ) * G60 interpolation lineaire ( echelle 100x )
G70 Unites = Inches * G70 Unites = Inches
G71 Unites = Millimetres * G71 Unites = Millimetres
G74 supprime interpolation circulaire sur 360 degre, revient a G01 * G74 supprime interpolation circulaire sur 360 degre, revient a G01
G75 Active interpolation circulaire sur 360 degre * G75 Active interpolation circulaire sur 360 degre
G90 Mode Coordonnees absolues * G90 Mode Coordonnees absolues
G91 Mode Coordonnees Relatives * G91 Mode Coordonnees Relatives
*
Coordonnees X,Y * Coordonnees X,Y
X,Y sont suivies de + ou - et de m+n chiffres (non separes) * X,Y sont suivies de + ou - et de m+n chiffres (non separes)
m = partie entiere * m = partie entiere
n = partie apres la virgule * n = partie apres la virgule
formats classiques : m = 2, n = 3 (format 2.3) * formats classiques : m = 2, n = 3 (format 2.3)
m = 3, n = 4 (format 3.4) * m = 3, n = 4 (format 3.4)
ex: * ex:
G__ X00345Y-06123 D__* * G__ X00345Y-06123 D__*
*
Outils et D_CODES * Outils et D_CODES
numero d'outil ( identification des formes ) * numero d'outil ( identification des formes )
1 a 99 (classique) * 1 a 99 (classique)
1 a 999 * 1 a 999
D_CODES: * D_CODES:
*
D01 ... D9 = codes d'action: * D01 ... D9 = codes d'action:
D01 = activation de lumiere (baisser de plume) lors du dplacement * D01 = activation de lumiere (baisser de plume) lors du dplacement
D02 = extinction de lumiere (lever de plume) lors du dplacement * D02 = extinction de lumiere (lever de plume) lors du dplacement
D03 = Flash * D03 = Flash
D09 = VAPE Flash * D09 = VAPE Flash
D51 = precede par G54 -> Select VAPE * D51 = precede par G54 -> Select VAPE
*
D10 ... D255 = Indentification d'outils ( d'ouvertures ) * D10 ... D255 = Indentification d'outils ( d'ouvertures )
Ne sont pas tj dans l'ordre ( voir tableau dans PCBPLOT.H) * Ne sont pas tj dans l'ordre ( voir tableau dans PCBPLOT.H)
*/ */
// Type d'action du phototraceur: // Type d'action du phototraceur:
#define GERB_ACTIVE_DRAW 1 // activation de lumiere ( baisser de plume) #define GERB_ACTIVE_DRAW 1 // activation de lumiere ( baisser de plume)
#define GERB_STOP_DRAW 2 // extinction de lumiere ( lever de plume) #define GERB_STOP_DRAW 2 // extinction de lumiere ( lever de plume)
#define GERB_FLASH 3 // Flash #define GERB_FLASH 3 // Flash
#define NEGATE(nb) (nb) = -(nb) #define NEGATE( nb ) (nb) = -(nb)
/* Variables locales : */ /* Variables locales : */
static wxPoint LastPosition; static wxPoint LastPosition;
/* Routines Locales */ /* Routines Locales */
static void Append_1_Line_GERBER(int Dcode_index, WinEDA_GerberFrame * frame, wxDC * DC, static void Append_1_Line_GERBER( int Dcode_index, WinEDA_GerberFrame* frame, wxDC* DC,
const wxPoint & startpoint,const wxPoint & endpoint, const wxPoint& startpoint, const wxPoint& endpoint,
int largeur); int largeur );
static void Append_1_Flash_GERBER(int Dcode_index, WinEDA_GerberFrame * frame, wxDC * DC, static void Append_1_Flash_GERBER( int Dcode_index, WinEDA_GerberFrame* frame, wxDC* DC,
const wxPoint & pos,const wxSize & size, int forme); const wxPoint& pos, const wxSize& size, int forme );
static void Append_1_Flash_ROND_GERBER(int Dcode_index, WinEDA_GerberFrame * frame, wxDC * DC, static void Append_1_Flash_ROND_GERBER( int Dcode_index, WinEDA_GerberFrame* frame, wxDC* DC,
const wxPoint & pos, int diametre); const wxPoint& pos, int diametre );
static void Append_1_SEG_ARC_GERBER(int Dcode_index, static void Append_1_SEG_ARC_GERBER( int Dcode_index,
WinEDA_GerberFrame * frame, wxDC * DC, WinEDA_GerberFrame* frame, wxDC* DC,
const wxPoint & startpoint, const wxPoint & endpoint, const wxPoint& startpoint, const wxPoint& endpoint,
const wxPoint & rel_center, int largeur, const wxPoint& rel_center, int largeur,
bool trigo_sens, bool multiquadrant); bool trigo_sens, bool multiquadrant );
/****************************************************************/ /****************************************************************/
static void Append_1_Flash_ROND_GERBER(int Dcode_tool, static void Append_1_Flash_ROND_GERBER( int Dcode_tool,
WinEDA_GerberFrame * frame, WinEDA_GerberFrame* frame,
wxDC * DC, const wxPoint & pos,int diametre) wxDC* DC, const wxPoint& pos, int diametre )
/****************************************************************/ /****************************************************************/
/* Trace 1 flash ROND en position pos /* Trace 1 flash ROND en position pos
*/ */
{ {
TRACK * track; TRACK* track;
track = new TRACK(frame->m_Pcb); track = new TRACK( frame->m_Pcb );
track->Insert(frame->m_Pcb, NULL);
track->SetLayer( frame->GetScreen()->m_Active_Layer ); track->Insert( frame->m_Pcb, NULL );
track->m_Width = diametre ;
track->m_Start = track->m_End = pos;
NEGATE(track->m_Start.y);
NEGATE(track->m_End.y);
track->m_NetCode = Dcode_tool;
track->m_Shape = S_SPOT_CIRCLE;
Trace_Segment(frame->DrawPanel, DC, track, GR_OR) ; track->SetLayer( frame->GetScreen()->m_Active_Layer );
track->m_Width = diametre;
track->m_Start = track->m_End = pos;
NEGATE( track->m_Start.y );
NEGATE( track->m_End.y );
track->m_NetCode = Dcode_tool;
track->m_Shape = S_SPOT_CIRCLE;
Trace_Segment( frame->DrawPanel, DC, track, GR_OR );
} }
/**********************************************************************/ /**********************************************************************/
static void Append_1_Flash_GERBER(int Dcode_index, static void Append_1_Flash_GERBER( int Dcode_index,
WinEDA_GerberFrame * frame, wxDC * DC, WinEDA_GerberFrame* frame, wxDC* DC,
const wxPoint & pos,const wxSize & size,int forme) const wxPoint& pos, const wxSize& size, int forme )
/*********************************************************************/ /*********************************************************************/
/* /*
Trace 1 flash rectangulaire ou ovale vertical ou horizontal * Trace 1 flash rectangulaire ou ovale vertical ou horizontal
donne par son centre et ses dimensions X et Y * donne par son centre et ses dimensions X et Y
*/ */
{ {
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->SetLayer( frame->GetScreen()->m_Active_Layer );
track->m_Width = width; track->SetLayer( frame->GetScreen()->m_Active_Layer );
track->m_Start = track->m_End = pos; track->m_Width = width;
NEGATE(track->m_Start.y); track->m_Start = track->m_End = pos;
NEGATE(track->m_End.y); NEGATE( track->m_Start.y );
track->m_NetCode = Dcode_index; NEGATE( track->m_End.y );
track->m_NetCode = Dcode_index;
if ( forme == OVALE )
track->m_Shape = S_SPOT_OVALE; if( forme == OVALE )
else track->m_Shape = S_SPOT_OVALE;
track->m_Shape = S_SPOT_RECT; // donc rectangle ou carr else
track->m_Shape = S_SPOT_RECT; // donc rectangle ou carr
len >>= 1;
if ( size.x > size.y ) // ovale / rect horizontal len >>= 1;
{ if( size.x > size.y ) // ovale / rect horizontal
track->m_Start.x -= len ; {
track->m_End.x += len; track->m_Start.x -= len;
} track->m_End.x += len;
}
else // ovale / rect vertical else // ovale / rect vertical
{ {
track->m_Start.y -= len; track->m_Start.y -= len;
track->m_End.y += len; track->m_End.y += len;
} }
Trace_Segment(frame->DrawPanel, DC, track, GR_OR) ; Trace_Segment( frame->DrawPanel, DC, track, GR_OR );
} }
/******************************************************************/ /******************************************************************/
static void Append_1_Line_GERBER(int Dcode_index, static void Append_1_Line_GERBER( int Dcode_index,
WinEDA_GerberFrame * frame, wxDC * DC, WinEDA_GerberFrame* frame, wxDC* DC,
const wxPoint & startpoint, const wxPoint & endpoint, const wxPoint& startpoint, const wxPoint& endpoint,
int largeur) int largeur )
/********************************************************************/ /********************************************************************/
{ {
TRACK * track; TRACK* track;
track = new TRACK( frame->m_Pcb ); track = new TRACK( frame->m_Pcb );
track->Insert(frame->m_Pcb, NULL);
track->SetLayer( frame->GetScreen()->m_Active_Layer ); track->Insert( frame->m_Pcb, NULL );
track->m_Width = largeur ;
track->m_Start = startpoint;
NEGATE(track->m_Start.y);
track->m_End = endpoint;
NEGATE(track->m_End.y);
track->m_NetCode = Dcode_index;
Trace_Segment(frame->DrawPanel, DC, track,GR_OR) ; track->SetLayer( frame->GetScreen()->m_Active_Layer );
track->m_Width = largeur;
track->m_Start = startpoint;
NEGATE( track->m_Start.y );
track->m_End = endpoint;
NEGATE( track->m_End.y );
track->m_NetCode = Dcode_index;
Trace_Segment( frame->DrawPanel, DC, track, GR_OR );
} }
/*****************************************************************/ /*****************************************************************/
static void Append_1_SEG_ARC_GERBER(int Dcode_index, static void Append_1_SEG_ARC_GERBER( int Dcode_index,
WinEDA_GerberFrame * frame, wxDC * DC, WinEDA_GerberFrame* frame, wxDC* DC,
const wxPoint & startpoint, const wxPoint & endpoint, const wxPoint& startpoint, const wxPoint& endpoint,
const wxPoint & rel_center, int largeur, const wxPoint& rel_center, int largeur,
bool trigo_sens, bool multiquadrant) bool trigo_sens, bool multiquadrant )
/*****************************************************************/ /*****************************************************************/
/* creation d'un arc: /* creation d'un arc:
si multiquadrant == TRUE arc de 0 a 360 degres * si multiquadrant == TRUE arc de 0 a 360 degres
et rel_center est la coordonne du centre relativement au startpoint * et rel_center est la coordonne du centre relativement au startpoint
*
si multiquadrant == FALSE arc de 0 90 entierement contenu dans le meme quadrant * si multiquadrant == FALSE arc de 0 90 entierement contenu dans le meme quadrant
et rel_center est la coordonne du centre relativement au startpoint, * et rel_center est la coordonne du centre relativement au startpoint,
mais en VALEUR ABSOLUE et le signe des valeurs x et y de rel_center doit * mais en VALEUR ABSOLUE et le signe des valeurs x et y de rel_center doit
etre deduit de cette limite de 90 degres * etre deduit de cette limite de 90 degres
*
*/ */
{ {
TRACK * track; TRACK* track;
wxPoint center, delta; wxPoint center, delta;
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_Shape = S_ARC;
track->SetLayer( frame->GetScreen()->m_Active_Layer ); track->m_Shape = S_ARC;
track->m_Width = largeur ; track->SetLayer( frame->GetScreen()->m_Active_Layer );
track->m_Width = largeur;
if ( multiquadrant )
{ if( multiquadrant )
center.x = startpoint.x + rel_center.x; {
center.y = startpoint.y - rel_center.y; center.x = startpoint.x + rel_center.x;
center.y = startpoint.y - rel_center.y;
if ( !trigo_sens )
{ if( !trigo_sens )
track->m_Start = startpoint; {
track->m_End = endpoint; track->m_Start = startpoint;
} track->m_End = endpoint;
else }
{ else
track->m_Start = endpoint; {
track->m_End = startpoint; track->m_Start = endpoint;
} track->m_End = startpoint;
} }
else }
{ else
center = rel_center; {
delta.x = endpoint.x - startpoint.x; center = rel_center;
delta.y = endpoint.y - startpoint.y; delta.x = endpoint.x - startpoint.x;
// il faut corriger de signe de rel_center.x et rel_center.y delta.y = endpoint.y - startpoint.y;
// selon le quadrant ou on se trouve
if ( (delta.x >= 0) && (delta.y >= 0) ) // 1er quadrant // il faut corriger de signe de rel_center.x et rel_center.y
{ // selon le quadrant ou on se trouve
center.x = - center.x; if( (delta.x >= 0) && (delta.y >= 0) ) // 1er quadrant
} {
center.x = -center.x;
else if ( (delta.x < 0) && (delta.y >= 0) ) // 2eme quadrant }
{ else if( (delta.x < 0) && (delta.y >= 0) ) // 2eme quadrant
center.x = - center.x; {
center.y = - center.y; center.x = -center.x;
} center.y = -center.y;
}
else if ( (delta.x < 0) && (delta.y < 0) ) // 3eme quadrant else if( (delta.x < 0) && (delta.y < 0) ) // 3eme quadrant
{ {
center.y = - center.y; center.y = -center.y;
} }
else // 4eme qadrant: les 2 coord sont >= 0! else // 4eme qadrant: les 2 coord sont >= 0!
{ {
} }
center.x += startpoint.x; center.x += startpoint.x;
center.y = startpoint.y + center.y ; center.y = startpoint.y + center.y;
if ( trigo_sens ) if( trigo_sens )
{ {
track->m_Start = startpoint; track->m_Start = startpoint;
track->m_End = endpoint; track->m_End = endpoint;
} }
else else
{ {
track->m_Start = endpoint; track->m_Start = endpoint;
track->m_End = startpoint; track->m_End = startpoint;
} }
} }
track->m_NetCode = Dcode_index; track->m_NetCode = Dcode_index;
track->m_Param = center.x; track->m_Param = center.x;
track->m_Sous_Netcode = center.y; track->m_Sous_Netcode = center.y;
NEGATE(track->m_Start.y); NEGATE( track->m_Start.y );
NEGATE(track->m_End.y); NEGATE( track->m_End.y );
NEGATE(track->m_Sous_Netcode); NEGATE( track->m_Sous_Netcode );
Trace_Segment(frame->DrawPanel, DC, track,GR_OR); Trace_Segment( frame->DrawPanel, DC, track, GR_OR );
} }
/**************************************************/ /**************************************************/
/* Routines utilises en lecture de ficher gerber */ /* Routines utilises en lecture de ficher gerber */
/**************************************************/ /**************************************************/
/* ces routines lisent la chaine de texte pointe par Text. /* ces routines lisent la chaine de texte pointe par Text.
Apres appel, Text pointe le debut de la sequence non lue * Apres appel, Text pointe le debut de la sequence non lue
*/ */
/***********************************************/ /***********************************************/
wxPoint GERBER_Descr::ReadXYCoord(char * &Text) wxPoint GERBER_Descr::ReadXYCoord( char*& Text )
/***********************************************/ /***********************************************/
/* Retourne la coord courante pointee par Text (XnnnnYmmmm) /* Retourne la coord courante pointee par Text (XnnnnYmmmm)
*/ */
{ {
wxPoint pos = m_CurrentPos; wxPoint pos = m_CurrentPos;
int type_coord = 0, current_coord, nbchar; int type_coord = 0, current_coord, nbchar;
bool is_float = FALSE; bool is_float = FALSE;
char * text; char* text;
char line[256]; char line[256];
if ( m_Relative ) pos.x = pos.y = 0; if( m_Relative )
else pos = m_CurrentPos; pos.x = pos.y = 0;
else
if ( Text == NULL ) return pos; pos = m_CurrentPos;
text = line; if( Text == NULL )
while ( * Text ) return pos;
{
if ( (* Text == 'X') || (* Text == 'Y') ) text = line;
{ while( *Text )
type_coord = * Text; {
Text++; if( (*Text == 'X') || (*Text == 'Y') )
text = line; nbchar = 0; {
while( IsNumber(*Text) ) type_coord = *Text;
{ Text++;
if ( *Text == '.' ) is_float = TRUE; text = line; nbchar = 0;
*(text++) = *(Text++); while( IsNumber( *Text ) )
if ( (*Text >= '0') && (*Text <='9') ) nbchar++; {
} if( *Text == '.' )
*text = 0; is_float = TRUE;
if ( is_float ) *(text++) = *(Text++);
{ if( (*Text >= '0') && (*Text <='9') )
if ( m_GerbMetric ) nbchar++;
current_coord = (int) round(atof(line) / 0.00254); }
else
current_coord = (int) round(atof(line) * PCB_INTERNAL_UNIT); *text = 0;
} if( is_float )
else {
{ if( m_GerbMetric )
int fmt_scale = (type_coord == 'X') ? m_FmtScale.x : m_FmtScale.y; current_coord = (int) round( atof( line ) / 0.00254 );
if ( m_NoTrailingZeros ) else
{ current_coord = (int) round( atof( line ) * PCB_INTERNAL_UNIT );
int min_digit = (type_coord == 'X') ? m_FmtLen.x : m_FmtLen.y; }
while (nbchar < min_digit) { *(text++) ='0'; nbchar++; } else
*text=0; {
} int fmt_scale = (type_coord == 'X') ? m_FmtScale.x : m_FmtScale.y;
current_coord = atoi(line); if( m_NoTrailingZeros )
double real_scale = 1.0; {
switch( fmt_scale) int min_digit = (type_coord == 'X') ? m_FmtLen.x : m_FmtLen.y;
{ while( nbchar < min_digit )
case 0: real_scale = 10000.0; {
break; *(text++) = '0'; nbchar++;
case 1: real_scale = 1000.0; }
break;
case 2: real_scale = 100.0; *text = 0;
break; }
case 3: real_scale = 10.0; current_coord = atoi( line );
break; double real_scale = 1.0;
case 4:
break; switch( fmt_scale )
case 5: real_scale = 0.1; {
break; case 0:
case 6: real_scale = 0.01; real_scale = 10000.0;
break; break;
case 7: real_scale = 0.001;
break; case 1:
case 8: real_scale = 0.0001; real_scale = 1000.0;
break; break;
case 9: real_scale = 0.00001;
break; case 2:
} real_scale = 100.0;
if ( m_GerbMetric ) real_scale = real_scale / 25.4; break;
current_coord = (int) round(current_coord * real_scale);
} case 3:
if ( type_coord == 'X' ) pos.x = current_coord; real_scale = 10.0;
else if ( type_coord == 'Y' ) pos.y = current_coord; break;
continue;
} case 4:
else break; break;
}
case 5:
if ( m_Relative ) real_scale = 0.1;
{ break;
pos.x += m_CurrentPos.x;
pos.y += m_CurrentPos.y; case 6:
} real_scale = 0.01;
break;
m_CurrentPos = pos;
return pos; case 7:
real_scale = 0.001;
break;
case 8:
real_scale = 0.0001;
break;
case 9:
real_scale = 0.00001;
break;
}
if( m_GerbMetric )
real_scale = real_scale / 25.4;
current_coord = (int) round( current_coord * real_scale );
}
if( type_coord == 'X' )
pos.x = current_coord;
else if( type_coord == 'Y' )
pos.y = current_coord;
continue;
}
else
break;
}
if( m_Relative )
{
pos.x += m_CurrentPos.x;
pos.y += m_CurrentPos.y;
}
m_CurrentPos = pos;
return pos;
} }
/************************************************/ /************************************************/
wxPoint GERBER_Descr::ReadIJCoord(char * &Text) wxPoint GERBER_Descr::ReadIJCoord( char*& Text )
/************************************************/ /************************************************/
/* Retourne la coord type InnJnn courante pointee par Text (InnnnJmmmm) /* Retourne la coord type InnJnn courante pointee par Text (InnnnJmmmm)
Ces coordonnes sont relatives, donc si une coord est absente, sa valeur * Ces coordonnes sont relatives, donc si une coord est absente, sa valeur
par defaut est 0 * par defaut est 0
*/ */
{ {
wxPoint pos(0,0); wxPoint pos( 0, 0 );
int type_coord = 0, current_coord, nbchar;
bool is_float = FALSE; int type_coord = 0, current_coord, nbchar;
char * text; bool is_float = FALSE;
char line[256]; char* text;
char line[256];
if ( Text == NULL ) return pos;
if( Text == NULL )
text = line; return pos;
while ( * Text )
{ text = line;
if ( (* Text == 'I') || (* Text == 'J') ) while( *Text )
{ {
type_coord = * Text; if( (*Text == 'I') || (*Text == 'J') )
Text++; {
text = line; nbchar = 0; type_coord = *Text;
while( IsNumber(*Text) ) Text++;
{ text = line; nbchar = 0;
if ( *Text == '.' ) is_float = TRUE; while( IsNumber( *Text ) )
*(text++) = *(Text++); {
if ( (*Text >= '0') && (*Text <='9') ) nbchar++; if( *Text == '.' )
} is_float = TRUE;
*text = 0; *(text++) = *(Text++);
if ( is_float ) if( (*Text >= '0') && (*Text <='9') )
{ nbchar++;
if ( m_GerbMetric ) }
current_coord = (int) round(atof(line) / 0.00254);
else *text = 0;
current_coord = (int) round(atof(line) * PCB_INTERNAL_UNIT); if( is_float )
} {
else if( m_GerbMetric )
{ current_coord = (int) round( atof( line ) / 0.00254 );
int fmt_scale = (type_coord == 'I') ? m_FmtScale.x : m_FmtScale.y; else
if ( m_NoTrailingZeros ) current_coord = (int) round( atof( line ) * PCB_INTERNAL_UNIT );
{ }
int min_digit = (type_coord == 'I') ? m_FmtLen.x : m_FmtLen.y; else
while (nbchar < min_digit) { *(text++) ='0'; nbchar++; } {
*text=0; int fmt_scale = (type_coord == 'I') ? m_FmtScale.x : m_FmtScale.y;
} if( m_NoTrailingZeros )
current_coord = atoi(line); {
double real_scale = 1.0; int min_digit = (type_coord == 'I') ? m_FmtLen.x : m_FmtLen.y;
switch( fmt_scale) while( nbchar < min_digit )
{ {
case 0: real_scale = 10000.0; *(text++) = '0'; nbchar++;
break; }
case 1: real_scale = 1000.0;
break; *text = 0;
case 2: real_scale = 100.0; }
break; current_coord = atoi( line );
case 3: real_scale = 10.0; double real_scale = 1.0;
break;
case 4: switch( fmt_scale )
break; {
case 5: real_scale = 0.1; case 0:
break; real_scale = 10000.0;
case 6: real_scale = 0.01; break;
break;
case 7: real_scale = 0.001; case 1:
break; real_scale = 1000.0;
case 8: real_scale = 0.0001; break;
break;
case 9: real_scale = 0.00001; case 2:
break; real_scale = 100.0;
} break;
if ( m_GerbMetric ) real_scale = real_scale / 25.4;
current_coord = (int) round(current_coord * real_scale); case 3:
} real_scale = 10.0;
if ( type_coord == 'I' ) pos.x = current_coord; break;
else if ( type_coord == 'J' ) pos.y = current_coord;
continue; case 4:
} break;
else break;
} case 5:
m_IJPos = pos; real_scale = 0.1;
return pos; break;
case 6:
real_scale = 0.01;
break;
case 7:
real_scale = 0.001;
break;
case 8:
real_scale = 0.0001;
break;
case 9:
real_scale = 0.00001;
break;
}
if( m_GerbMetric )
real_scale = real_scale / 25.4;
current_coord = (int) round( current_coord * real_scale );
}
if( type_coord == 'I' )
pos.x = current_coord;
else if( type_coord == 'J' )
pos.y = current_coord;
continue;
}
else
break;
}
m_IJPos = pos;
return pos;
} }
/*****************************************************/ /*****************************************************/
int GERBER_Descr::ReturnGCodeNumber(char * &Text) int GERBER_Descr::ReturnGCodeNumber( char*& Text )
/*****************************************************/ /*****************************************************/
/* Lit la sequence Gnn et retourne la valeur nn /* Lit la sequence Gnn et retourne la valeur nn
*/ */
{ {
int ii = 0; int ii = 0;
char * text; char* text;
char line[1024]; char line[1024];
if ( Text == NULL ) return 0; if( Text == NULL )
Text++; return 0;
text = line; Text++;
while( IsNumber(*Text) ) text = line;
{ while( IsNumber( *Text ) )
*(text++) = *(Text++); {
} *(text++) = *(Text++);
*text = 0; }
ii = atoi(line);
return ii; *text = 0;
ii = atoi( line );
return ii;
} }
/**************************************************/ /**************************************************/
int GERBER_Descr::ReturnDCodeNumber(char * &Text) int GERBER_Descr::ReturnDCodeNumber( char*& Text )
/**************************************************/ /**************************************************/
/* Lit la sequence Dnn et retourne la valeur nn /* Lit la sequence Dnn et retourne la valeur nn
*/ */
{ {
int ii = 0; int ii = 0;
char * text; char* text;
char line[1024]; char line[1024];
if ( Text == NULL ) return 0; if( Text == NULL )
Text ++; return 0;
text = line; Text++;
while( IsNumber(*Text) ) *(text++) = *(Text++); text = line;
*text = 0; while( IsNumber( *Text ) )
ii = atoi(line); *(text++) = *(Text++);
return ii;
*text = 0;
ii = atoi( line );
return ii;
} }
/******************************************************************/ /******************************************************************/
bool GERBER_Descr::Execute_G_Command(char * &text, int G_commande) bool GERBER_Descr::Execute_G_Command( char*& text, int G_commande )
/******************************************************************/ /******************************************************************/
{ {
switch (G_commande) switch( G_commande )
{ {
case GC_LINEAR_INTERPOL_1X: case GC_LINEAR_INTERPOL_1X:
m_Iterpolation = GERB_INTERPOL_LINEAR_1X; m_Iterpolation = GERB_INTERPOL_LINEAR_1X;
break; break;
case GC_CIRCLE_NEG_INTERPOL: case GC_CIRCLE_NEG_INTERPOL:
m_Iterpolation = GERB_INTERPOL_ARC_NEG; m_Iterpolation = GERB_INTERPOL_ARC_NEG;
break; break;
case GC_CIRCLE_POS_INTERPOL: case GC_CIRCLE_POS_INTERPOL:
m_Iterpolation = GERB_INTERPOL_ARC_POS; m_Iterpolation = GERB_INTERPOL_ARC_POS;
break; break;
case GC_COMMENT: case GC_COMMENT:
text = NULL; text = NULL;
break ; break;
case GC_LINEAR_INTERPOL_10X: case GC_LINEAR_INTERPOL_10X:
m_Iterpolation = GERB_INTERPOL_LINEAR_10X; m_Iterpolation = GERB_INTERPOL_LINEAR_10X;
break; break;
case GC_LINEAR_INTERPOL_0P1X: case GC_LINEAR_INTERPOL_0P1X:
m_Iterpolation = GERB_INTERPOL_LINEAR_01X; m_Iterpolation = GERB_INTERPOL_LINEAR_01X;
break; break;
case GC_LINEAR_INTERPOL_0P01X: case GC_LINEAR_INTERPOL_0P01X:
m_Iterpolation = GERB_INTERPOL_LINEAR_001X; m_Iterpolation = GERB_INTERPOL_LINEAR_001X;
break; break;
case GC_SELECT_TOOL: case GC_SELECT_TOOL:
{ {
int D_commande = ReturnDCodeNumber(text); int D_commande = ReturnDCodeNumber( text );
if ( D_commande < FIRST_DCODE) return FALSE; if( D_commande < FIRST_DCODE )
if (D_commande > (MAX_TOOLS-1)) D_commande = MAX_TOOLS-1; return FALSE;
m_Current_Tool = D_commande; if( D_commande > (MAX_TOOLS - 1) )
D_CODE * pt_Dcode = ReturnToolDescr( m_Layer, D_commande ); D_commande = MAX_TOOLS - 1;
if ( pt_Dcode ) pt_Dcode->m_InUse = TRUE; m_Current_Tool = D_commande;
break; D_CODE* pt_Dcode = ReturnToolDescr( m_Layer, D_commande );
} if( pt_Dcode )
pt_Dcode->m_InUse = TRUE;
case GC_SPECIFY_INCHES: break;
m_GerbMetric = FALSE; // FALSE = Inches, TRUE = metric }
break;
case GC_SPECIFY_INCHES:
case GC_SPECIFY_MILLIMETERS: m_GerbMetric = FALSE; // FALSE = Inches, TRUE = metric
m_GerbMetric = TRUE; // FALSE = Inches, TRUE = metric break;
break;
case GC_SPECIFY_MILLIMETERS:
case GC_TURN_OFF_360_INTERPOL: m_GerbMetric = TRUE; // FALSE = Inches, TRUE = metric
m_360Arc_enbl = FALSE; break;
break;
case GC_TURN_OFF_360_INTERPOL:
case GC_TURN_ON_360_INTERPOL: m_360Arc_enbl = FALSE;
m_360Arc_enbl = TRUE; break;
break;
case GC_TURN_ON_360_INTERPOL:
case GC_SPECIFY_ABSOLUES_COORD: m_360Arc_enbl = TRUE;
m_Relative = FALSE; // FALSE = absolute Coord, RUE = relative Coord break;
break;
case GC_SPECIFY_ABSOLUES_COORD:
case GC_SPECIFY_RELATIVEES_COORD: m_Relative = FALSE; // FALSE = absolute Coord, RUE = relative Coord
m_Relative = TRUE; // FALSE = absolute Coord, RUE = relative Coord break;
break;
case GC_SPECIFY_RELATIVEES_COORD:
case GC_TURN_ON_POLY_FILL: m_Relative = TRUE; // FALSE = absolute Coord, RUE = relative Coord
m_PolygonFillMode = TRUE; break;
break;
case GC_TURN_ON_POLY_FILL:
case GC_TURN_OFF_POLY_FILL: m_PolygonFillMode = TRUE;
m_PolygonFillMode = FALSE; break;
m_PolygonFillModeState = 0;
break; case GC_TURN_OFF_POLY_FILL:
m_PolygonFillMode = FALSE;
case GC_MOVE: // Non existant m_PolygonFillModeState = 0;
default: break;
{
wxString msg; msg.Printf( wxT("G%.2d command not handled"),G_commande); case GC_MOVE: // Non existant
DisplayError(NULL, msg); default:
return FALSE; {
} wxString msg; msg.Printf( wxT( "G%.2d command not handled" ), G_commande );
} DisplayError( NULL, msg );
return FALSE;
}
return TRUE; }
return TRUE;
} }
/*****************************************************************************/ /*****************************************************************************/
bool GERBER_Descr::Execute_DCODE_Command(WinEDA_GerberFrame * frame, wxDC * DC, bool GERBER_Descr::Execute_DCODE_Command( WinEDA_GerberFrame* frame, wxDC* DC,
char * &text, int D_commande) char*& text, int D_commande )
/*****************************************************************************/ /*****************************************************************************/
{ {
wxSize size(15, 15); wxSize size( 15, 15 );
int shape = 1, dcode = 0;
D_CODE * pt_Tool = NULL; int shape = 1, dcode = 0;
wxString msg; D_CODE* pt_Tool = NULL;
wxString msg;
if(D_commande >= FIRST_DCODE ) // This is a "Set tool" command
{ if( D_commande >= FIRST_DCODE ) // This is a "Set tool" command
if (D_commande > (MAX_TOOLS-1)) D_commande = MAX_TOOLS-1; {
m_Current_Tool = D_commande; if( D_commande > (MAX_TOOLS - 1) )
D_CODE * pt_Dcode = ReturnToolDescr(m_Layer, D_commande); D_commande = MAX_TOOLS - 1;
if ( pt_Dcode ) pt_Dcode->m_InUse = TRUE; m_Current_Tool = D_commande;
return TRUE; D_CODE* pt_Dcode = ReturnToolDescr( m_Layer, D_commande );
} if( pt_Dcode )
pt_Dcode->m_InUse = TRUE;
else // D_commande = 0..9: this is a pen command (usualy D1, D2 or D3) return TRUE;
{ }
m_Last_Pen_Command = D_commande; else // D_commande = 0..9: this is a pen command (usualy D1, D2 or D3)
} {
m_Last_Pen_Command = D_commande;
if ( m_PolygonFillMode ) // Enter a polygon description: }
{
switch ( D_commande ) if( m_PolygonFillMode ) // Enter a polygon description:
{ {
case 1: //code D01 Draw line, exposure ON switch( D_commande )
{ {
SEGZONE * edge_poly, *last; case 1: //code D01 Draw line, exposure ON
{
edge_poly = new SEGZONE( frame->m_Pcb ); SEGZONE* edge_poly, * last;
last = (SEGZONE*)frame->m_Pcb->m_Zone;
if ( last ) while (last->Pnext ) last = (SEGZONE*)last->Pnext; edge_poly = new SEGZONE( frame->m_Pcb );
edge_poly->Insert(frame->m_Pcb, last);
last = (SEGZONE*) frame->m_Pcb->m_Zone;
edge_poly->SetLayer( frame->GetScreen()->m_Active_Layer ); if( last )
edge_poly->m_Width = 1; while( last->Pnext )
edge_poly->m_Start = m_PreviousPos; last = (SEGZONE*) last->Pnext;
NEGATE(edge_poly->m_Start.y);
edge_poly->m_End = m_CurrentPos; edge_poly->Insert( frame->m_Pcb, last );
NEGATE(edge_poly->m_End.y);
edge_poly->m_NetCode = m_PolygonFillModeState; edge_poly->SetLayer( frame->GetScreen()->m_Active_Layer );
m_PreviousPos = m_CurrentPos; edge_poly->m_Width = 1;
m_PolygonFillModeState = 1; edge_poly->m_Start = m_PreviousPos;
break; NEGATE( edge_poly->m_Start.y );
} edge_poly->m_End = m_CurrentPos;
NEGATE( edge_poly->m_End.y );
case 2: //code D2: exposure OFF (i.e. "move to") edge_poly->m_NetCode = m_PolygonFillModeState;
m_PreviousPos = m_CurrentPos; m_PreviousPos = m_CurrentPos;
m_PolygonFillModeState = 0; m_PolygonFillModeState = 1;
break; break;
}
default:
return FALSE; case 2: //code D2: exposure OFF (i.e. "move to")
} m_PreviousPos = m_CurrentPos;
} m_PolygonFillModeState = 0;
break;
else switch ( D_commande ) default:
{ return FALSE;
case 1: //code D01 Draw line, exposure ON }
pt_Tool = ReturnToolDescr(m_Layer, m_Current_Tool); }
if ( pt_Tool ) else
{ switch( D_commande )
size = pt_Tool->m_Size; {
dcode = pt_Tool->m_Num_Dcode; case 1: //code D01 Draw line, exposure ON
shape = pt_Tool->m_Shape; pt_Tool = ReturnToolDescr( m_Layer, m_Current_Tool );
} if( pt_Tool )
switch ( m_Iterpolation ) {
{ size = pt_Tool->m_Size;
case GERB_INTERPOL_LINEAR_1X: dcode = pt_Tool->m_Num_Dcode;
Append_1_Line_GERBER(dcode, shape = pt_Tool->m_Shape;
frame, DC, }
m_PreviousPos, m_CurrentPos,
size.x); switch( m_Iterpolation )
break; {
case GERB_INTERPOL_LINEAR_1X:
case GERB_INTERPOL_LINEAR_01X: Append_1_Line_GERBER( dcode,
case GERB_INTERPOL_LINEAR_001X: frame, DC,
case GERB_INTERPOL_LINEAR_10X: m_PreviousPos, m_CurrentPos,
wxBell(); size.x );
break; break;
case GERB_INTERPOL_ARC_NEG: case GERB_INTERPOL_LINEAR_01X:
Append_1_SEG_ARC_GERBER(dcode, case GERB_INTERPOL_LINEAR_001X:
frame, DC, case GERB_INTERPOL_LINEAR_10X:
m_PreviousPos, m_CurrentPos, m_IJPos, wxBell();
size.x, FALSE, m_360Arc_enbl); break;
break;
case GERB_INTERPOL_ARC_NEG:
case GERB_INTERPOL_ARC_POS: Append_1_SEG_ARC_GERBER( dcode,
Append_1_SEG_ARC_GERBER(dcode, frame, DC,
frame, DC, m_PreviousPos, m_CurrentPos, m_IJPos,
m_PreviousPos, m_CurrentPos, m_IJPos, size.x, FALSE, m_360Arc_enbl );
size.x, TRUE, m_360Arc_enbl); break;
break;
case GERB_INTERPOL_ARC_POS:
default: Append_1_SEG_ARC_GERBER( dcode,
msg.Printf( wxT("Execute_DCODE_Command: interpol error (type %X)"), frame, DC,
m_Iterpolation); m_PreviousPos, m_CurrentPos, m_IJPos,
DisplayError(frame, msg); size.x, TRUE, m_360Arc_enbl );
break; break;
}
m_PreviousPos = m_CurrentPos; default:
break; msg.Printf( wxT( "Execute_DCODE_Command: interpol error (type %X)" ),
m_Iterpolation );
case 2: //code D2: exposure OFF (i.e. "move to") DisplayError( frame, msg );
m_PreviousPos = m_CurrentPos; break;
break; }
case 3: // code D3: flash aperture m_PreviousPos = m_CurrentPos;
pt_Tool = ReturnToolDescr(m_Layer, m_Current_Tool); break;
if ( pt_Tool )
{ case 2: //code D2: exposure OFF (i.e. "move to")
size = pt_Tool->m_Size; m_PreviousPos = m_CurrentPos;
dcode = pt_Tool->m_Num_Dcode; break;
shape = pt_Tool->m_Shape;
} case 3: // code D3: flash aperture
pt_Tool = ReturnToolDescr( m_Layer, m_Current_Tool );
switch (shape) if( pt_Tool )
{ {
case GERB_LINE: size = pt_Tool->m_Size;
case GERB_CIRCLE : dcode = pt_Tool->m_Num_Dcode;
Append_1_Flash_ROND_GERBER(dcode, shape = pt_Tool->m_Shape;
frame, DC, }
m_CurrentPos,
size.x); switch( shape )
break ; {
case GERB_LINE:
case GERB_OVALE : case GERB_CIRCLE:
Append_1_Flash_GERBER( dcode, Append_1_Flash_ROND_GERBER( dcode,
frame, DC, m_CurrentPos, frame, DC,
size, m_CurrentPos,
OVALE); size.x );
break ; break;
case GERB_RECT: case GERB_OVALE:
Append_1_Flash_GERBER( dcode, Append_1_Flash_GERBER( dcode,
frame, DC, m_CurrentPos, frame, DC, m_CurrentPos,
size, size,
RECT); OVALE );
break ; break;
default: // Special (Macro) : Non implant case GERB_RECT:
break; Append_1_Flash_GERBER( dcode,
frame, DC, m_CurrentPos,
} size,
m_PreviousPos = m_CurrentPos; RECT );
break; break;
default: default: // Special (Macro) : Non implant
return FALSE; break;
} }
return TRUE; m_PreviousPos = m_CurrentPos;
break;
default:
return FALSE;
}
return TRUE;
} }
pcbnew/class_track.cpp
View file @ afedb361
...@@ -246,7 +246,8 @@ void SEGVIA::SetLayerPair( int top_layer, int bottom_layer ) ...@@ -246,7 +246,8 @@ void SEGVIA::SetLayerPair( int top_layer, int bottom_layer )
if( via_type == VIA_NORMALE ) if( via_type == VIA_NORMALE )
{ {
top_layer = LAYER_CMP_N; bottom_layer = LAYER_CUIVRE_N; top_layer = LAYER_CMP_N;
bottom_layer = LAYER_CUIVRE_N;
} }
if( bottom_layer > top_layer ) if( bottom_layer > top_layer )
...@@ -695,12 +696,12 @@ void TRACK::Display_Infos( WinEDA_DrawFrame* frame ) ...@@ -695,12 +696,12 @@ void TRACK::Display_Infos( WinEDA_DrawFrame* frame )
|| Type() == TYPEVIA ) || Type() == TYPEVIA )
{ {
EQUIPOT* equipot = ((WinEDA_PcbFrame*)frame)->m_Pcb->FindNet( m_NetCode ); EQUIPOT* equipot = ((WinEDA_PcbFrame*)frame)->m_Pcb->FindNet( m_NetCode );
if( equipot ) if( equipot )
{
msg = equipot->m_Netname; msg = equipot->m_Netname;
}
else else
msg = wxT( "<noname>" ); msg = wxT( "<noname>" );
Affiche_1_Parametre( frame, text_pos, _( "NetName" ), msg, RED ); Affiche_1_Parametre( frame, text_pos, _( "NetName" ), msg, RED );
/* Affiche net code :*/ /* Affiche net code :*/
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment