Skip to content

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

plot fix, beautification

parent 11d8f51b
Hide whitespace changes
Inline Side-by-side
Showing with 2168 additions and 2078 deletions
common/common_plotHPGL_functions.cpp
View file @ 2da432b2
/******************************************/ /******************************************/
/* Kicad: Common plot HPGL Routines */ /* Kicad: Common plot HPGL Routines */
/******************************************/ /******************************************/
#include "fctsys.h" #include "fctsys.h"
#include "gr_basic.h" #include "gr_basic.h"
...@@ -17,191 +17,199 @@ ...@@ -17,191 +17,199 @@
// Variables partagees avec Common plot Postscript Routines // Variables partagees avec Common plot Postscript Routines
extern wxPoint LastPenPosition; extern wxPoint LastPenPosition;
extern wxPoint PlotOffset; extern wxPoint PlotOffset;
extern FILE * PlotOutputFile; extern FILE* PlotOutputFile;
extern double XScale, YScale; extern double XScale, YScale;
extern int g_DefaultPenWidth, g_CurrentPenWidth; extern int g_DefaultPenWidth, g_CurrentPenWidth;
extern int PlotOrientOptions, etat_plume; extern int PlotOrientOptions, etat_plume;
//Variables locales //Variables locales
void Move_Plume_HPGL( wxPoint pos, int plume ); void Move_Plume_HPGL( wxPoint pos, int plume );
void Plume_HPGL( int plume ); void Plume_HPGL( int plume );
/***********************************************************************************/ /***********************************************************************************/
void InitPlotParametresHPGL(wxPoint offset, double xscale, double yscale, int orient) void InitPlotParametresHPGL( wxPoint offset, double xscale, double yscale, int orient )
/***********************************************************************************/ /***********************************************************************************/
/* Set the plot offset for the current plotting /* Set the plot offset for the current plotting
xscale,yscale = coordinate scale (scale coefficient for coordinates) * xscale,yscale = coordinate scale (scale coefficient for coordinates)
device_xscale,device_yscale = device coordinate scale (i.e scale used by plot device) * device_xscale,device_yscale = device coordinate scale (i.e scale used by plot device)
*/ */
{ {
PlotOffset = offset; PlotOffset = offset;
XScale = xscale; XScale = xscale;
YScale = yscale; YScale = yscale;
g_DefaultPenWidth = 6; /* epaisseur du trait standard en 1/1000 pouce */ g_DefaultPenWidth = 6; /* epaisseur du trait standard en 1/1000 pouce */
PlotOrientOptions = orient; PlotOrientOptions = orient;
g_CurrentPenWidth = -1; g_CurrentPenWidth = -1;
} }
/*****************************************************************/ /*****************************************************************/
bool PrintHeaderHPGL(FILE * plot_file, int pen_speed, int pen_num) bool PrintHeaderHPGL( FILE* plot_file, int pen_speed, int pen_num )
/*****************************************************************/ /*****************************************************************/
{ {
char Line[256]; char Line[256];
PlotOutputFile = plot_file; PlotOutputFile = plot_file;
etat_plume = 'U'; etat_plume = 'U';
sprintf(Line,"IN;VS%d;PU;PA;SP%d;\n",pen_speed,pen_num); sprintf( Line, "IN;VS%d;PU;PA;SP%d;\n", pen_speed, pen_num );
fputs(Line,plot_file); fputs( Line, plot_file );
return TRUE; return TRUE;
} }
/**********************************/ /**********************************/
bool CloseFileHPGL(FILE * plot_file) bool CloseFileHPGL( FILE* plot_file )
/**********************************/ /**********************************/
{ {
fputs("PU;PA;SP0;\n",plot_file); fputs( "PU;PA;SP0;\n", plot_file );
fclose(plot_file); fclose( plot_file );
return TRUE; return TRUE;
} }
/************************************************************/ /************************************************************/
void PlotCircle_HPGL(wxPoint centre, int diameter, int width) void PlotCircle_HPGL( wxPoint centre, int diameter, int width )
/************************************************************/ /************************************************************/
{ {
int rayon; int rayon;
char Line[256]; char Line[256];
UserToDeviceCoordinate(centre); UserToDeviceCoordinate( centre );
rayon = (int)(diameter / 2 * XScale); rayon = (int) (diameter / 2 * XScale);
if(rayon < 0 ) rayon = 0 ; if( rayon < 0 )
rayon = 0;
Plume_HPGL('U'); Plume_HPGL( 'U' );
sprintf(Line,"PA %d,%d;CI %d,%d;\n", centre.x, centre.y, rayon , CHORD_ANGLE); sprintf( Line, "PA %d,%d;CI %d,%d;\n", centre.x, centre.y, rayon, CHORD_ANGLE );
fputs(Line,PlotOutputFile) ; fputs( Line, PlotOutputFile );
Plume_HPGL('U'); return ; Plume_HPGL( 'U' ); return;
} }
/********************************************************************/ /********************************************************************/
void PlotArcHPGL(wxPoint centre, int StAngle, int EndAngle, int rayon, int width) void PlotArcHPGL( wxPoint centre, int StAngle, int EndAngle, int rayon, int width )
/********************************************************************/ /********************************************************************/
/* trace d'un arc de cercle: /* trace d'un arc de cercle:
centre = coord du centre * centre = coord du centre
StAngle, EndAngle = angle de debut et fin * StAngle, EndAngle = angle de debut et fin
rayon = rayon de l'arc * rayon = rayon de l'arc
commande * commande
PU;PA x,y;PD;AA start_arc_X, start_arc_Y, angle, NbSegm; PU; * PU;PA x,y;PD;AA start_arc_X, start_arc_Y, angle, NbSegm; PU;
ou PU;PA x,y;PD;AA start_arc_X, start_arc_Y, angle; PU; * ou PU;PA x,y;PD;AA start_arc_X, start_arc_Y, angle; PU;
*/ */
{ {
char Line[256]; char Line[256];
wxPoint cmap; /* point de depart */ wxPoint cmap; /* point de depart */
wxPoint cpos; /* centre */ wxPoint cpos; /* centre */
float angle; /* angle de l'arc*/ float angle; /* angle de l'arc*/
if(rayon <= 0 ) return ; if( rayon <= 0 )
return;
cpos = centre; UserToDeviceCoordinate(cpos);
cpos = centre; UserToDeviceCoordinate( cpos );
if( PlotOrientOptions == PLOT_MIROIR)
{ if( PlotOrientOptions == PLOT_MIROIR )
EndAngle = - EndAngle; {
StAngle = - StAngle; EndAngle = -EndAngle;
EXCHG (StAngle, EndAngle); StAngle = -StAngle;
} EXCHG( StAngle, EndAngle );
angle = (EndAngle - StAngle) /10.0; }
/* Calcul des coord du point de depart : */ angle = (EndAngle - StAngle) / 10.0;
cmap.x = (int)( centre.x + ( rayon * cos(StAngle * M_PI / 1800 ) ) ); /* Calcul des coord du point de depart : */
cmap.y = (int)(centre.y + ( rayon * sin(StAngle * M_PI / 1800 ) ) ); cmap.x = (int) ( centre.x + ( rayon * cos( StAngle * M_PI / 1800 ) ) );
UserToDeviceCoordinate(cmap); cmap.y = (int) ( centre.y + ( rayon * sin( StAngle * M_PI / 1800 ) ) );
UserToDeviceCoordinate( cmap );
Plume_HPGL('U');
sprintf(Line,"PU;PA %d,%d;PD;AA %d,%d, ", cmap.x, cmap.y, cpos.x, cpos.y); Plume_HPGL( 'U' );
fputs(Line,PlotOutputFile) ; sprintf( Line, "PU;PA %d,%d;PD;AA %d,%d, ", cmap.x, cmap.y, cpos.x, cpos.y );
sprintf(Line,"%f", - angle); to_point(Line); // Transforme , et . du separateur fputs( Line, PlotOutputFile );
fputs(Line,PlotOutputFile) ; sprintf( Line, "%f", -angle ); to_point( Line ); // Transforme , et . du separateur
sprintf(Line,", %d", CHORD_ANGLE); fputs(Line,PlotOutputFile) ; fputs( Line, PlotOutputFile );
sprintf(Line,";PU;\n"); fputs(Line,PlotOutputFile) ; sprintf( Line, ", %d", CHORD_ANGLE ); fputs( Line, PlotOutputFile );
Plume_HPGL('U'); sprintf( Line, ";PU;\n" ); fputs( Line, PlotOutputFile );
Plume_HPGL( 'U' );
} }
/*****************************************************/ /*****************************************************/
void PlotPolyHPGL( int nb, int * coord, int fill, int width) void PlotPolyHPGL( int nb, int* coord, int fill, int width )
/*****************************************************/ /*****************************************************/
/* Trace un polygone (ferme si rempli) en format HPGL /* Trace un polygone (ferme si rempli) en format HPGL
coord = tableau des coord des sommets * coord = tableau des coord des sommets
nb = nombre de coord ( 1 coord = 2 elements: X et Y du tableau ) * nb = nombre de coord ( 1 coord = 2 elements: X et Y du tableau )
fill : si != 0 polygone rempli * fill : si != 0 polygone rempli
*/ */
{ {
int ii; int ii;
if( nb <= 1 ) return;
if( nb <= 1 )
Move_Plume_HPGL( wxPoint(coord[0],coord[1]), 'U'); return;
for( ii = 1; ii < nb ; ii ++ )
{ Move_Plume_HPGL( wxPoint( coord[0], coord[1] ), 'U' );
Move_Plume_HPGL( wxPoint(coord[ii * 2],coord[(ii*2) +1]), 'D'); for( ii = 1; ii < nb; ii++ )
} {
Move_Plume_HPGL( wxPoint( coord[ii * 2], coord[(ii * 2) + 1] ), 'D' );
/* Fermeture eventuelle du polygone */ }
if ( fill )
{ /* Fermeture eventuelle du polygone */
ii = (nb - 1) * 2; if( fill )
if( (coord[ii] != coord[0] ) || (coord[ii+1] != coord[0]) ) {
Move_Plume_HPGL( wxPoint(coord[0],coord[1]), 'D'); ii = (nb - 1) * 2;
} if( (coord[ii] != coord[0] ) || (coord[ii + 1] != coord[0]) )
Plume_HPGL('U'); Move_Plume_HPGL( wxPoint( coord[0], coord[1] ), 'D' );
}
Plume_HPGL( 'U' );
} }
/**********************************************/ /**********************************************/
void Move_Plume_HPGL( wxPoint pos, int plume ) void Move_Plume_HPGL( wxPoint pos, int plume )
/**********************************************/ /**********************************************/
/* /*
deplace la plume levee (plume = 'U') ou baissee (plume = 'D') * deplace la plume levee (plume = 'U') ou baissee (plume = 'D')
en position x,y * en position x,y
Unites en Unites DESSIN * Unites en Unites DESSIN
Si plume = 'Z' lever de plume sans deplacement * Si plume = 'Z' lever de plume sans deplacement
*/ */
{ {
char Line[256]; char Line[256];
if ( plume == 'Z') if( plume == 'Z' )
{ {
Plume_HPGL('U'); Plume_HPGL( 'U' );
return; return;
} }
Plume_HPGL(plume); Plume_HPGL( plume );
UserToDeviceCoordinate(pos); UserToDeviceCoordinate( pos );
sprintf(Line,"PA %d,%d;\n",pos.x,pos.y) ; fputs(Line,PlotOutputFile) ; sprintf( Line, "PA %d,%d;\n", pos.x, pos.y ); fputs( Line, PlotOutputFile );
} }
/***************************/ /***************************/
void Plume_HPGL( int plume ) void Plume_HPGL( int plume )
/***************************/ /***************************/
/* leve (plume = 'U') ou baisse (plume = 'D') la plume /* leve (plume = 'U') ou baisse (plume = 'D') la plume
*/ */
{ {
if ( plume == 'U') if( plume == 'U' )
{ {
if(etat_plume != 'U' ) fputs("PU;",PlotOutputFile) ; if( etat_plume != 'U' )
etat_plume = 'U'; fputs( "PU;", PlotOutputFile );
} etat_plume = 'U';
else }
{ else
if(etat_plume != 'D' )fputs("PD;",PlotOutputFile) ; {
etat_plume = 'D'; if( etat_plume != 'D' )
} fputs( "PD;", PlotOutputFile );
etat_plume = 'D';
}
} }
common/common_plotPS_functions.cpp
View file @ 2da432b2
/******************************************/ /******************************************/
/* Kicad: Common plot Postscript Routines */ /* Kicad: Common plot Postscript Routines */
/******************************************/ /******************************************/
#include "fctsys.h" #include "fctsys.h"
#include "gr_basic.h" #include "gr_basic.h"
...@@ -14,20 +14,20 @@ ...@@ -14,20 +14,20 @@
#include "wx/defs.h" #include "wx/defs.h"
// Variables partagees avec Common plot Postscript Routines // Variables partagees avec Common plot Postscript Routines
extern wxPoint LastPenPosition; extern wxPoint LastPenPosition;
extern wxPoint PlotOffset; extern wxPoint PlotOffset;
extern FILE * PlotOutputFile; extern FILE* PlotOutputFile;
extern double XScale, YScale; extern double XScale, YScale;
extern int g_DefaultPenWidth, g_CurrentPenWidth; extern int g_DefaultPenWidth, g_CurrentPenWidth;
extern int PlotOrientOptions, etat_plume; extern int PlotOrientOptions, etat_plume;
// Locales // Locales
static Ki_PageDescr * SheetPS; static Ki_PageDescr* SheetPS;
/*************************************************************************************/ /*************************************************************************************/
void InitPlotParametresPS(wxPoint offset, Ki_PageDescr * sheet, void InitPlotParametresPS( wxPoint offset, Ki_PageDescr* sheet,
double xscale, double yscale, int orient) double xscale, double yscale, int orient )
/*************************************************************************************/ /*************************************************************************************/
/* Set the plot offset for the current plotting /* Set the plot offset for the current plotting
...@@ -35,50 +35,52 @@ void InitPlotParametresPS(wxPoint offset, Ki_PageDescr * sheet, ...@@ -35,50 +35,52 @@ void InitPlotParametresPS(wxPoint offset, Ki_PageDescr * sheet,
* device_xscale,device_yscale = device coordinate scale (i.e scale used by plot device) * device_xscale,device_yscale = device coordinate scale (i.e scale used by plot device)
*/ */
{ {
PlotOrientOptions = orient; PlotOrientOptions = orient;
PlotOffset = offset; PlotOffset = offset;
SheetPS = sheet; SheetPS = sheet;
XScale = xscale; XScale = xscale;
YScale = yscale; YScale = yscale;
g_CurrentPenWidth = -1; g_CurrentPenWidth = -1;
} }
/*************************************************************************************/ /*************************************************************************************/
void SetDefaultLineWidthPS(int width) void SetDefaultLineWidthPS( int width )
/*************************************************************************************/ /*************************************************************************************/
/* Set the default line width (in 1/1000 inch) for the current plotting /* Set the default line width (in 1/1000 inch) for the current plotting
*/ */
{ {
g_DefaultPenWidth = width; // epaisseur du trait standard en 1/1000 pouce g_DefaultPenWidth = width; // epaisseur du trait standard en 1/1000 pouce
g_CurrentPenWidth = -1; g_CurrentPenWidth = -1;
} }
/***************************************/ /***************************************/
void SetCurrentLineWidthPS(int width) void SetCurrentLineWidthPS( int width )
/***************************************/ /***************************************/
/* Set the Current line width (in 1/1000 inch) for the next plot /* Set the Current line width (in 1/1000 inch) for the next plot
*/ */
{ {
int pen_width; D(printf( "PlotOutputFile = %p\n", PlotOutputFile );)
int pen_width;
if( width > 0 ) if( width > 0 )
pen_width = width; pen_width = width;
else else
pen_width = g_DefaultPenWidth; pen_width = g_DefaultPenWidth;
if( pen_width != g_CurrentPenWidth ) if( pen_width != g_CurrentPenWidth )
fprintf(PlotOutputFile, "%d setlinewidth\n", (int)(XScale * pen_width) ); fprintf( PlotOutputFile, "%d setlinewidth\n", (int) (XScale * pen_width) );
g_CurrentPenWidth = pen_width; g_CurrentPenWidth = pen_width;
} }
/******************************/ /******************************/
void SetColorMapPS(int color) void SetColorMapPS( int color )
/******************************/ /******************************/
/* Print the postscript set color command: /* Print the postscript set color command:
...@@ -88,82 +90,92 @@ void SetColorMapPS(int color) ...@@ -88,82 +90,92 @@ void SetColorMapPS(int color)
* color = color index in ColorRefs[] * color = color index in ColorRefs[]
*/ */
{ {
char Line[1024]; D(printf( "PlotOutputFile = %p\n", PlotOutputFile );)
sprintf( Line, "%.3f %.3f %.3f setrgbcolor\n", char Line[1024];
(float)ColorRefs[color].m_Red / 255,
(float)ColorRefs[color].m_Green / 255, sprintf( Line, "%.3f %.3f %.3f setrgbcolor\n",
(float)ColorRefs[color].m_Blue / 255 ); (float) ColorRefs[color].m_Red / 255,
to_point(Line); (float) ColorRefs[color].m_Green / 255,
fputs( Line, PlotOutputFile ); (float) ColorRefs[color].m_Blue / 255 );
to_point( Line );
fputs( Line, PlotOutputFile );
} }
/***************************************************************/ /***************************************************************/
void PlotFilledSegmentPS(wxPoint start, wxPoint end, int width) void PlotFilledSegmentPS( wxPoint start, wxPoint end, int width )
/***************************************************************/ /***************************************************************/
/* Plot 1 segment like a track segment /* Plot 1 segment like a track segment
*/ */
{ {
UserToDeviceCoordinate(start); D(printf( "PlotOutputFile = %p\n", PlotOutputFile );)
UserToDeviceCoordinate(end);
UserToDeviceCoordinate( start );
UserToDeviceCoordinate( end );
SetCurrentLineWidthPS(width); SetCurrentLineWidthPS( width );
fprintf(PlotOutputFile,"%d %d %d %d line\n", start.x, start.y, end.x, end.y); fprintf( PlotOutputFile, "%d %d %d %d line\n", start.x, start.y, end.x, end.y );
} }
/******************************************************/ /******************************************************/
void PlotCircle_PS(wxPoint pos, int diametre, int width) void PlotCircle_PS( wxPoint pos, int diametre, int width )
/******************************************************/ /******************************************************/
{ {
int rayon; D(printf( "PlotOutputFile = %p\n", PlotOutputFile );)
char Line[256];
UserToDeviceCoordinate(pos); int rayon;
rayon = (int)(XScale * diametre / 2); char Line[256];
if( rayon < 0 ) UserToDeviceCoordinate( pos );
rayon = 0; rayon = (int) (XScale * diametre / 2);
SetCurrentLineWidthPS(width); if( rayon < 0 )
sprintf(Line, "newpath %d %d %d 0 360 arc stroke\n", pos.x, pos.y, rayon); rayon = 0;
fputs(Line, PlotOutputFile);
SetCurrentLineWidthPS( width );
sprintf( Line, "newpath %d %d %d 0 360 arc stroke\n", pos.x, pos.y, rayon );
fputs( Line, PlotOutputFile );
} }
/**************************************************************************************/ /**************************************************************************************/
void PlotArcPS(wxPoint centre, int StAngle, int EndAngle, int rayon, int width) void PlotArcPS( wxPoint centre, int StAngle, int EndAngle, int rayon, int width )
/**************************************************************************************/ /**************************************************************************************/
/* Plot an arc: /* Plot an arc:
* StAngle, EndAngle = start and end arc in 0.1 degree * StAngle, EndAngle = start and end arc in 0.1 degree
*/ */
{ {
char Line[256]; D(printf( "PlotOutputFile = %p\n", PlotOutputFile );)
if( rayon <= 0 ) char Line[256];
return;
if( rayon <= 0 )
SetCurrentLineWidthPS(width); return;
// Calcul des coord du point de depart :
UserToDeviceCoordinate(centre); SetCurrentLineWidthPS( width );
if( PlotOrientOptions == PLOT_MIROIR ) // Calcul des coord du point de depart :
sprintf( Line, "newpath %d %d %d %f %f arc stroke\n", centre.x, centre.y, UserToDeviceCoordinate( centre );
(int)(rayon * XScale), (float)StAngle / 10, (float)EndAngle / 10 );
else if( PlotOrientOptions == PLOT_MIROIR )
sprintf( Line, "newpath %d %d %d %f %f arc stroke\n", centre.x, centre.y, sprintf( Line, "newpath %d %d %d %f %f arc stroke\n", centre.x, centre.y,
(int)(rayon * XScale), -(float)EndAngle / 10, -(float)StAngle / 10 ); (int) (rayon * XScale), (float) StAngle / 10, (float) EndAngle / 10 );
// Undo internationalization printf (float x.y printed x,y) else
to_point(Line); sprintf( Line, "newpath %d %d %d %f %f arc stroke\n", centre.x, centre.y,
fputs(Line, PlotOutputFile); (int) (rayon * XScale), -(float) EndAngle / 10, -(float) StAngle / 10 );
// Undo internationalization printf (float x.y printed x,y)
to_point( Line );
fputs( Line, PlotOutputFile );
} }
/*****************************************************************/ /*****************************************************************/
void PlotPolyPS(int nb_segm, int * coord, int fill, int width) void PlotPolyPS( int nb_segm, int* coord, int fill, int width )
/*****************************************************************/ /*****************************************************************/
/* Draw a polygon ( a filled polygon if fill == 1 ) in POSTSCRIPT format /* Draw a polygon ( a filled polygon if fill == 1 ) in POSTSCRIPT format
...@@ -173,211 +185,226 @@ void PlotPolyPS(int nb_segm, int * coord, int fill, int width) ...@@ -173,211 +185,226 @@ void PlotPolyPS(int nb_segm, int * coord, int fill, int width)
* @param width = line width * @param width = line width
*/ */
{ {
int ii; D(printf( "PlotOutputFile = %p\n", PlotOutputFile );)
wxPoint pos;
int ii;
if( nb_segm <= 1 ) wxPoint pos;
return;
if( nb_segm <= 1 )
SetCurrentLineWidthPS(width); return;
pos.x = coord[0]; SetCurrentLineWidthPS( width );
pos.y = coord[1];
UserToDeviceCoordinate(pos); pos.x = coord[0];
fprintf(PlotOutputFile, "newpath %d %d moveto\n", pos.x, pos.y); pos.y = coord[1];
UserToDeviceCoordinate( pos );
for( ii = 1; ii < nb_segm; ii ++ ) fprintf( PlotOutputFile, "newpath %d %d moveto\n", pos.x, pos.y );
{
pos.x = coord[2 * ii]; for( ii = 1; ii < nb_segm; ii++ )
pos.y = coord[2 * ii + 1]; {
UserToDeviceCoordinate(pos); pos.x = coord[2 * ii];
fprintf(PlotOutputFile, "%d %d lineto\n", pos.x, pos.y); pos.y = coord[2 * ii + 1];
} UserToDeviceCoordinate( pos );
fprintf( PlotOutputFile, "%d %d lineto\n", pos.x, pos.y );
// Fermeture du polygone }
if( fill )
fprintf(PlotOutputFile, "closepath "); // Fermeture du polygone
if( fill == 1 ) if( fill )
fprintf(PlotOutputFile, "fill "); fprintf( PlotOutputFile, "closepath " );
fprintf(PlotOutputFile, "stroke\n"); if( fill == 1 )
fprintf( PlotOutputFile, "fill " );
fprintf( PlotOutputFile, "stroke\n" );
} }
/*************************************/ /*************************************/
void LineTo_PS(wxPoint pos, int plume) void LineTo_PS( wxPoint pos, int plume )
/*************************************/ /*************************************/
/* Routine to draw to a new position /* Routine to draw to a new position
*/ */
{ {
if( plume == 'Z' ) D(printf( "PlotOutputFile = %p\n", PlotOutputFile );)
return;
if( plume == 'Z' )
UserToDeviceCoordinate(pos); return;
if( plume == 'D' )
{ UserToDeviceCoordinate( pos );
char Line[256]; if( plume == 'D' )
sprintf(Line, "%d %d %d %d line\n", {
LastPenPosition.x, LastPenPosition.y, pos.x, pos.y); char Line[256];
fputs(Line, PlotOutputFile); sprintf( Line, "%d %d %d %d line\n",
} LastPenPosition.x, LastPenPosition.y, pos.x, pos.y );
LastPenPosition = pos; fputs( Line, PlotOutputFile );
}
LastPenPosition = pos;
} }
/***********************************************************/ /***********************************************************/
void PrintHeaderPS(FILE * file, const wxString & Creator, void PrintHeaderPS( FILE* file, const wxString& Creator,
const wxString & FileName, int PageCount, const wxString& FileName, int PageCount,
int BBox[4], int PaperOrientation) int BBox[4], int PaperOrientation )
/***********************************************************/ /***********************************************************/
/* The code within this function (and the CloseFilePS function) /* The code within this function (and the CloseFilePS function)
* creates postscript files whose contents comply with Adobe's * creates postscript files whose contents comply with Adobe's
* Document Structuring Convention, as documented by assorted * Document Structuring Convention, as documented by assorted
* details described within the following URLs: * details described within the following URLs:
* *
* http://en.wikipedia.org/wiki/Document_Structuring_Conventions * http://en.wikipedia.org/wiki/Document_Structuring_Conventions
* http://partners.adobe.com/public/developer/en/ps/5001.DSC_Spec.pdf * http://partners.adobe.com/public/developer/en/ps/5001.DSC_Spec.pdf
* *
* *
* The PageCount and PaperOrientation parameters have been provided to * The PageCount and PaperOrientation parameters have been provided to
* respectively cater for the production of multiple-page postscript * respectively cater for the production of multiple-page postscript
* files, and postscript files having either a portrait orientation * files, and postscript files having either a portrait orientation
* or a landscape orientation. * or a landscape orientation.
* *
* BBox is the boundary box (position and size of the "client rectangle" * BBox is the boundary box (position and size of the "client rectangle"
* for drawings (page - margins) in mils (0.001 inch) * for drawings (page - margins) in mils (0.001 inch)
*/ */
{ {
wxString msg; wxString msg;
char Line[1024]; char Line[1024];
const char *PSMacro[] = {
"/line {\n", static const char* PSMacro[] = {
" newpath\n", "/line {\n",
" moveto\n", " newpath\n",
" lineto\n", " moveto\n",
" stroke\n", " lineto\n",
"} def\n", " stroke\n",
"gsave\n", "} def\n",
"72 72 scale\t\t\t% Talk inches\n", "gsave\n",
"1 setlinecap\n", "72 72 scale\t\t\t% Talk inches\n",
"1 setlinejoin\n", "1 setlinecap\n",
"1 setlinewidth\n", "1 setlinejoin\n",
NULL "1 setlinewidth\n",
}; NULL
const double MIL_TO_INCH = 0.001; };
int ii;
time_t time1970 = time(NULL); const double MIL_TO_INCH = 0.001;
int ii;
PlotOutputFile = file; time_t time1970 = time( NULL );
fputs("%!PS-Adobe-3.0\n", PlotOutputFile); // Print header PlotOutputFile = file;
sprintf( Line, "%%%%Creator: %s\n", CONV_TO_UTF8(Creator) ); D(printf( "PrintHeaderPS PlotOutputFile = %p\n", PlotOutputFile );)
fputs(Line, PlotOutputFile);
// A "newline" character ("\n") is not included in the following string, fputs( "%!PS-Adobe-3.0\n", PlotOutputFile ); // Print header
// because it is provided by the ctime() function.
sprintf( Line, "%%%%CreationDate: %s", ctime(&time1970) ); sprintf( Line, "%%%%Creator: %s\n", CONV_TO_UTF8( Creator ) );
fputs(Line, PlotOutputFile); fputs( Line, PlotOutputFile );
sprintf( Line, "%%%%Title: %s\n", CONV_TO_UTF8(FileName) ); // A "newline" character ("\n") is not included in the following string,
fputs(Line, PlotOutputFile); // because it is provided by the ctime() function.
sprintf( Line, "%%%%CreationDate: %s", ctime( &time1970 ) );
sprintf( Line, "%%%%Pages: %d\n", PageCount ); fputs( Line, PlotOutputFile );
fputs(Line, PlotOutputFile);
sprintf( Line, "%%%%Title: %s\n", CONV_TO_UTF8( FileName ) );
sprintf( Line, "%%%%PageOrder: Ascend\n" ); fputs( Line, PlotOutputFile );
fputs(Line, PlotOutputFile);
sprintf( Line, "%%%%Pages: %d\n", PageCount );
// Print boundary box en 1/72 pouce, box is in mils fputs( Line, PlotOutputFile );
const double CONV_SCALE = MIL_TO_INCH * 72;
// The coordinates of the lower left corner of the boundary sprintf( Line, "%%%%PageOrder: Ascend\n" );
// box need to be "rounded down", but the coordinates of its fputs( Line, PlotOutputFile );
// upper right corner need to be "rounded up" instead.
sprintf( Line, "%%%%BoundingBox: %d %d %d %d\n", // Print boundary box en 1/72 pouce, box is in mils
(int)floor((BBox[1] * CONV_SCALE)), (int)floor((BBox[0] * CONV_SCALE)), const double CONV_SCALE = MIL_TO_INCH * 72;
(int)ceil((BBox[3] * CONV_SCALE)), (int)ceil((BBox[2] * CONV_SCALE)) );
fputs(Line, PlotOutputFile); // The coordinates of the lower left corner of the boundary
// box need to be "rounded down", but the coordinates of its
// Specify the size of the sheet and the name associated with that size. // upper right corner need to be "rounded up" instead.
// (If the "User size" option has been selected for the sheet size, sprintf( Line, "%%%%BoundingBox: %d %d %d %d\n",
// identify the sheet size as "Custom" (rather than as "User"), but (int) floor( (BBox[1] * CONV_SCALE) ), (int) floor( (BBox[0] * CONV_SCALE) ),
// otherwise use the name assigned by KiCad for each sheet size.) (int) ceil( (BBox[3] * CONV_SCALE) ), (int) ceil( (BBox[2] * CONV_SCALE) ) );
//
// (The Document Structuring Convention also supports sheet weight, fputs( Line, PlotOutputFile );
// sheet colour, and sheet type properties being specified within a
// %%DocumentMedia comment, but they are not being specified here; // Specify the size of the sheet and the name associated with that size.
// a zero and two null strings are subsequently provided instead.) // (If the "User size" option has been selected for the sheet size,
// // identify the sheet size as "Custom" (rather than as "User"), but
// (NOTE: m_Size.y is *supposed* to be listed before m_Size.x; // otherwise use the name assigned by KiCad for each sheet size.)
// the order in which they are specified is not wrong!) //
if( SheetPS->m_Name.Cmp( wxT("User") ) == 0 ) // (The Document Structuring Convention also supports sheet weight,
sprintf( Line, "%%%%DocumentMedia: Custom %d %d 0 () ()\n", // sheet colour, and sheet type properties being specified within a
(int)round( SheetPS->m_Size.y * CONV_SCALE ), // %%DocumentMedia comment, but they are not being specified here;
(int)round( SheetPS->m_Size.x * CONV_SCALE ) ); // a zero and two null strings are subsequently provided instead.)
else // ( if SheetPS->m_Name does not equal "User" ) //
sprintf( Line, "%%%%DocumentMedia: %s %d %d 0 () ()\n", // (NOTE: m_Size.y is *supposed* to be listed before m_Size.x;
CONV_TO_UTF8( SheetPS->m_Name ), // the order in which they are specified is not wrong!)
(int)round( SheetPS->m_Size.y * CONV_SCALE ), if( SheetPS->m_Name.Cmp( wxT( "User" ) ) == 0 )
(int)round( SheetPS->m_Size.x * CONV_SCALE ) ); sprintf( Line, "%%%%DocumentMedia: Custom %d %d 0 () ()\n",
fputs(Line, PlotOutputFile); (int) round( SheetPS->m_Size.y * CONV_SCALE ),
(int) round( SheetPS->m_Size.x * CONV_SCALE ) );
if( PaperOrientation == wxPORTRAIT )
sprintf( Line, "%%%%Orientation: Portrait\n" ); else // ( if SheetPS->m_Name does not equal "User" )
else sprintf( Line, "%%%%DocumentMedia: %s %d %d 0 () ()\n",
sprintf( Line, "%%%%Orientation: Landscape\n" ); CONV_TO_UTF8( SheetPS->m_Name ),
fputs(Line, PlotOutputFile); (int) round( SheetPS->m_Size.y * CONV_SCALE ),
(int) round( SheetPS->m_Size.x * CONV_SCALE ) );
sprintf( Line, "%%%%EndComments\n" ); fputs( Line, PlotOutputFile );
fputs(Line, PlotOutputFile);
if( PaperOrientation == wxPORTRAIT )
// Now specify various other details. sprintf( Line, "%%%%Orientation: Portrait\n" );
else
// The following string has been specified here (rather than within sprintf( Line, "%%%%Orientation: Landscape\n" );
// PSMacro[]) to highlight that it has been provided to ensure that the
// contents of the postscript file comply with the details specified fputs( Line, PlotOutputFile );
// within the Document Structuring Convention.
sprintf( Line, "%%%%Page: 1 1\n" ); sprintf( Line, "%%%%EndComments\n" );
fputs(Line, PlotOutputFile); fputs( Line, PlotOutputFile );
for ( ii = 0; PSMacro[ii] != NULL; ii++ ) // Now specify various other details.
{
fputs(PSMacro[ii], PlotOutputFile); // The following string has been specified here (rather than within
} // PSMacro[]) to highlight that it has been provided to ensure that the
// contents of the postscript file comply with the details specified
if( PaperOrientation == wxLANDSCAPE ) // within the Document Structuring Convention.
sprintf(Line, "%f %f translate 90 rotate\n", sprintf( Line, "%%%%Page: 1 1\n" );
(float)BBox[3] * MIL_TO_INCH, (float)BBox[0] * MIL_TO_INCH); fputs( Line, PlotOutputFile );
// (If support for creating postscript files with a portrait orientation
// is ever provided, determine whether it would be necessary to provide for( ii = 0; PSMacro[ii] != NULL; ii++ )
// an "else" command and then an appropriate "sprintf" command here.) {
fputs( PSMacro[ii], PlotOutputFile );
// compensation internationalisation printf (float x.y gnr x,y) }
to_point(Line);
if( PaperOrientation == wxLANDSCAPE )
fputs(Line, PlotOutputFile); sprintf( Line, "%f %f translate 90 rotate\n",
(float) BBox[3] * MIL_TO_INCH, (float) BBox[0] * MIL_TO_INCH );
sprintf(Line, "%f %f scale\t\t%% Move to User coordinates\n",
XScale, YScale); // (If support for creating postscript files with a portrait orientation
to_point(Line); // is ever provided, determine whether it would be necessary to provide
fputs(Line, PlotOutputFile); // an "else" command and then an appropriate "sprintf" command here.)
// Set default line width ( g_DefaultPenWidth is in user units ) // compensation internationalisation printf (float x.y gnr x,y)
fprintf(PlotOutputFile, "%d setlinewidth\n", g_DefaultPenWidth); to_point( Line );
fputs( Line, PlotOutputFile );
sprintf( Line, "%f %f scale\t\t%% Move to User coordinates\n",
XScale, YScale );
to_point( Line );
fputs( Line, PlotOutputFile );
// Set default line width ( g_DefaultPenWidth is in user units )
fprintf( PlotOutputFile, "%d setlinewidth\n", g_DefaultPenWidth );
} }
/******************************************/ /******************************************/
bool CloseFilePS(FILE * plot_file) bool CloseFilePS( FILE* plot_file )
/******************************************/ /******************************************/
{ {
fputs("showpage\n", plot_file); D(printf( "CloseFilePS\n" );)
fputs("grestore\n", plot_file);
fputs("%%EOF\n", plot_file);
fclose(plot_file); fputs( "showpage\n", plot_file );
fputs( "grestore\n", plot_file );
fputs( "%%EOF\n", plot_file );
return TRUE; fclose( plot_file );
}
return TRUE;
}
common/common_plot_functions.cpp
View file @ 2da432b2
/******************************************/ /******************************************/
/* Kicad: Common plot Postscript Routines */ /* Kicad: Common plot Postscript Routines */
/******************************************/ /******************************************/
#include "fctsys.h" #include "fctsys.h"
#include "gr_basic.h" #include "gr_basic.h"
...@@ -16,343 +16,358 @@ ...@@ -16,343 +16,358 @@
// Variables partagees avec Common plot Postscript et HPLG Routines // Variables partagees avec Common plot Postscript et HPLG Routines
wxPoint LastPenPosition; wxPoint LastPenPosition;
wxPoint PlotOffset; wxPoint PlotOffset;
FILE * PlotOutputFile; FILE* PlotOutputFile;
double XScale, YScale; double XScale, YScale;
int g_DefaultPenWidth; int g_DefaultPenWidth;
int g_CurrentPenWidth = -1; int g_CurrentPenWidth = -1;
int PlotOrientOptions, etat_plume; int PlotOrientOptions, etat_plume;
// Locales // Locales
static Ki_PageDescr * SheetPS; static Ki_PageDescr* SheetPS;
/*************************/ /*************************/
void ForcePenReinit() void ForcePenReinit()
/*************************/ /*************************/
/* set the flag g_CurrentPenWidth to -1 in order to force a pen width redefinition /* set the flag g_CurrentPenWidth to -1 in order to force a pen width redefinition
for the next draw command * for the next draw command
*/ */
{ {
g_CurrentPenWidth = -1; g_CurrentPenWidth = -1;
} }
/**********************************************/ /**********************************************/
void SetPlotScale(double xscale, double yscale) void SetPlotScale( double xscale, double yscale )
/**********************************************/ /**********************************************/
/* Set the plot scale for the current plotting) /* Set the plot scale for the current plotting)
*/ */
{ {
XScale = xscale; XScale = xscale;
YScale = yscale; YScale = yscale;
} }
/*********************************/ /*********************************/
void SetPlotOffset(wxPoint offset) void SetPlotOffset( wxPoint offset )
/*********************************/ /*********************************/
/* Set the plot offset for the current plotting) /* Set the plot offset for the current plotting)
*/ */
{ {
PlotOffset = offset; PlotOffset = offset;
} }
/***************************************************************************/ /***************************************************************************/
void InitPlotParametresGERBER(wxPoint offset, double xscale, double yscale) void InitPlotParametresGERBER( wxPoint offset, double xscale, double yscale )
/***************************************************************************/ /***************************************************************************/
/* Set the plot offset for the current plotting /* Set the plot offset for the current plotting
xscale,yscale = coordinate scale (scale coefficient for coordinates) * xscale,yscale = coordinate scale (scale coefficient for coordinates)
*/ */
{ {
PlotOrientOptions = 0; PlotOrientOptions = 0;
PlotOffset = offset; PlotOffset = offset;
SheetPS = NULL; SheetPS = NULL;
XScale = xscale; XScale = xscale;
YScale = yscale; YScale = yscale;
g_DefaultPenWidth = 120; /* epaisseur du trait standard en 1/1000 pouce */ g_DefaultPenWidth = 120; /* epaisseur du trait standard en 1/1000 pouce */
g_CurrentPenWidth = -1; g_CurrentPenWidth = -1;
} }
/*******************************************************/ /*******************************************************/
void PlotWorkSheet(int format_plot, BASE_SCREEN * screen) void PlotWorkSheet( int format_plot, BASE_SCREEN* screen )
/*******************************************************/ /*******************************************************/
/* Plot sheet references /* Plot sheet references
margin is in mils (1/1000 inch) * margin is in mils (1/1000 inch)
*/ */
{ {
#define WSTEXTSIZE 50 // Text size in mils #define WSTEXTSIZE 50 // Text size in mils
Ki_PageDescr * Sheet = screen->m_CurrentSheetDesc; Ki_PageDescr* Sheet = screen->m_CurrentSheetDesc;
int ii, jj, xg , yg, ipas, gxpas, gypas; int ii, jj, xg, yg, ipas, gxpas, gypas;
wxSize PageSize; wxSize PageSize;
wxPoint pos, ref; wxPoint pos, ref;
int color; int color;
Ki_WorkSheetData * WsItem; Ki_WorkSheetData* WsItem;
int conv_unit = screen->GetInternalUnits()/1000; /* Scale to convert dimension in 1/1000 in into internal units int conv_unit = screen->GetInternalUnits() / 1000; /* Scale to convert dimension in 1/1000 in into internal units
(1/1000 inc for EESchema, 1/10000 for pcbnew */ * (1/1000 inc for EESchema, 1/10000 for pcbnew */
wxString msg; wxString msg;
wxSize text_size; wxSize text_size;
void (*FctPlume)(wxPoint pos, int state); void (*FctPlume)( wxPoint pos, int state );
int UpperLimit = VARIABLE_BLOCK_START_POSITION; int UpperLimit = VARIABLE_BLOCK_START_POSITION;
switch ( format_plot) switch( format_plot )
{ {
case PLOT_FORMAT_POST: case PLOT_FORMAT_POST:
FctPlume = LineTo_PS; FctPlume = LineTo_PS;
break; break;
case PLOT_FORMAT_HPGL: case PLOT_FORMAT_HPGL:
FctPlume = Move_Plume_HPGL; FctPlume = Move_Plume_HPGL;
break; break;
case PLOT_FORMAT_GERBER: case PLOT_FORMAT_GERBER:
default: default:
return; return;
} }
color = BLACK; color = BLACK;
PageSize.x = Sheet->m_Size.x; PageSize.x = Sheet->m_Size.x;
PageSize.y = Sheet->m_Size.y; PageSize.y = Sheet->m_Size.y;
/* trace de la bordure */ /* trace de la bordure */
ref.x = Sheet->m_LeftMargin * conv_unit; ref.x = Sheet->m_LeftMargin * conv_unit;
ref.y = Sheet->m_TopMargin * conv_unit; /* Upper left corner */ ref.y = Sheet->m_TopMargin * conv_unit; /* Upper left corner */
xg = (PageSize.x - Sheet->m_RightMargin) * conv_unit; xg = (PageSize.x - Sheet->m_RightMargin) * conv_unit;
yg = (PageSize.y - Sheet->m_BottomMargin) * conv_unit; /* lower right corner */ yg = (PageSize.y - Sheet->m_BottomMargin) * conv_unit; /* lower right corner */
for ( ii = 0; ii < 2 ; ii++ ) for( ii = 0; ii < 2; ii++ )
{ {
FctPlume(ref,'U'); FctPlume( ref, 'U' );
pos.x = xg; pos.y = ref.y; pos.x = xg; pos.y = ref.y;
FctPlume(pos,'D'); FctPlume( pos, 'D' );
pos.x = xg; pos.y = yg; pos.x = xg; pos.y = yg;
FctPlume(pos,'D'); FctPlume( pos, 'D' );
pos.x = ref.x; pos.y = yg; pos.x = ref.x; pos.y = yg;
FctPlume( pos,'D' ); FctPlume( pos, 'D' );
FctPlume(ref,'D'); FctPlume( ref, 'D' );
ref.x += GRID_REF_W * conv_unit; ref.y += GRID_REF_W * conv_unit; ref.x += GRID_REF_W * conv_unit; ref.y += GRID_REF_W * conv_unit;
xg -= GRID_REF_W * conv_unit; yg -= GRID_REF_W * conv_unit; xg -= GRID_REF_W * conv_unit; yg -= GRID_REF_W * conv_unit;
} }
/* trace des reperes */ /* trace des reperes */
text_size.x = WSTEXTSIZE * conv_unit; text_size.x = WSTEXTSIZE * conv_unit;
text_size.y = WSTEXTSIZE * conv_unit; text_size.y = WSTEXTSIZE * conv_unit;
ref.x = Sheet->m_LeftMargin; ref.x = Sheet->m_LeftMargin;
ref.y = Sheet->m_TopMargin; /* Upper left corner in 1/1000 inch */ ref.y = Sheet->m_TopMargin; /* Upper left corner in 1/1000 inch */
xg = (PageSize.x - Sheet->m_RightMargin); xg = (PageSize.x - Sheet->m_RightMargin);
yg = (PageSize.y - Sheet->m_BottomMargin); /* lower right corner in 1/1000 inch */ yg = (PageSize.y - Sheet->m_BottomMargin); /* lower right corner in 1/1000 inch */
/* Trace des reperes selon l'axe X */ /* Trace des reperes selon l'axe X */
ipas = (xg - ref.x) / PAS_REF; ipas = (xg - ref.x) / PAS_REF;
gxpas = ( xg - ref.x) / ipas; gxpas = ( xg - ref.x) / ipas;
for ( ii = ref.x + gxpas, jj = 1; ipas > 0 ; ii += gxpas , jj++, ipas--) for( ii = ref.x + gxpas, jj = 1; ipas > 0; ii += gxpas, jj++, ipas-- )
{ {
msg.Empty(); msg << jj; msg.Empty(); msg << jj;
if( ii < xg - PAS_REF/2 ) if( ii < xg - PAS_REF / 2 )
{ {
pos.x = ii * conv_unit; pos.y = ref.y * conv_unit; pos.x = ii * conv_unit; pos.y = ref.y * conv_unit;
FctPlume(pos, 'U'); FctPlume( pos, 'U' );
pos.x = ii * conv_unit; pos.y = (ref.y + GRID_REF_W) * conv_unit; pos.x = ii * conv_unit; pos.y = (ref.y + GRID_REF_W) * conv_unit;
FctPlume(pos,'D'); FctPlume( pos, 'D' );
} }
pos.x = (ii - gxpas/2) * conv_unit; pos.x = (ii - gxpas / 2) * conv_unit;
pos.y = (ref.y + GRID_REF_W/2) * conv_unit; pos.y = (ref.y + GRID_REF_W / 2) * conv_unit;
PlotGraphicText(format_plot, pos, color, PlotGraphicText( format_plot, pos, color,
msg, TEXT_ORIENT_HORIZ,text_size, msg, TEXT_ORIENT_HORIZ, text_size,
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER); GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER );
if( ii < xg - PAS_REF/2 ) if( ii < xg - PAS_REF / 2 )
{ {
pos.x = ii * conv_unit; pos.y = yg * conv_unit; pos.x = ii * conv_unit; pos.y = yg * conv_unit;
FctPlume(pos,'U'); FctPlume( pos, 'U' );
pos.x = ii * conv_unit; pos.y = (yg - GRID_REF_W) * conv_unit; pos.x = ii * conv_unit; pos.y = (yg - GRID_REF_W) * conv_unit;
FctPlume(pos,'D'); FctPlume( pos, 'D' );
} }
pos.x = (ii - gxpas/2) * conv_unit; pos.x = (ii - gxpas / 2) * conv_unit;
pos.y = (yg - GRID_REF_W/2) * conv_unit; pos.y = (yg - GRID_REF_W / 2) * conv_unit;
PlotGraphicText(format_plot, pos, color, PlotGraphicText( format_plot, pos, color,
msg, TEXT_ORIENT_HORIZ,text_size, msg, TEXT_ORIENT_HORIZ, text_size,
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER); GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER );
} }
/* Trace des reperes selon l'axe Y */ /* Trace des reperes selon l'axe Y */
ipas = (yg - ref.y) / PAS_REF; ipas = (yg - ref.y) / PAS_REF;
gypas = ( yg - ref.y) / ipas; gypas = ( yg - ref.y) / ipas;
for ( ii = ref.y + gypas, jj = 0; ipas > 0 ; ii += gypas , jj++, ipas--) for( ii = ref.y + gypas, jj = 0; ipas > 0; ii += gypas, jj++, ipas-- )
{ {
msg.Empty(); msg << jj; msg.Empty(); msg << jj;
if( ii < yg - PAS_REF/2 ) if( ii < yg - PAS_REF / 2 )
{ {
pos.x = ref.x * conv_unit; pos.y = ii * conv_unit; pos.x = ref.x * conv_unit; pos.y = ii * conv_unit;
FctPlume(pos,'U'); FctPlume( pos, 'U' );
pos.x = (ref.x + GRID_REF_W) * conv_unit; pos.y = ii * conv_unit; pos.x = (ref.x + GRID_REF_W) * conv_unit; pos.y = ii * conv_unit;
FctPlume(pos, 'D'); FctPlume( pos, 'D' );
} }
pos.x = (ref.x + GRID_REF_W/2) * conv_unit; pos.x = (ref.x + GRID_REF_W / 2) * conv_unit;
pos.y = (ii - gypas/2) * conv_unit; pos.y = (ii - gypas / 2) * conv_unit;
PlotGraphicText(format_plot, pos, color, PlotGraphicText( format_plot, pos, color,
msg, TEXT_ORIENT_HORIZ,text_size, msg, TEXT_ORIENT_HORIZ, text_size,
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER); GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER );
if( ii < yg - PAS_REF/2 ) if( ii < yg - PAS_REF / 2 )
{ {
pos.x = xg * conv_unit; pos.y = ii * conv_unit; pos.x = xg * conv_unit; pos.y = ii * conv_unit;
FctPlume(pos,'U'); FctPlume( pos, 'U' );
pos.x = (xg - GRID_REF_W) * conv_unit; pos.y = ii * conv_unit; pos.x = (xg - GRID_REF_W) * conv_unit; pos.y = ii * conv_unit;
FctPlume(pos,'D'); FctPlume( pos, 'D' );
} }
pos.x = (xg - GRID_REF_W/2) * conv_unit; pos.x = (xg - GRID_REF_W / 2) * conv_unit;
pos.y = (ii - gypas/2) * conv_unit; pos.y = (ii - gypas / 2) * conv_unit;
PlotGraphicText(format_plot, pos, color, msg, TEXT_ORIENT_HORIZ,text_size, PlotGraphicText( format_plot, pos, color, msg, TEXT_ORIENT_HORIZ, text_size,
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER); GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER );
} }
/* Trace du cartouche */ /* Trace du cartouche */
text_size.x = SIZETEXT * conv_unit; text_size.x = SIZETEXT * conv_unit;
text_size.y = SIZETEXT * conv_unit; text_size.y = SIZETEXT * conv_unit;
ref.x = PageSize.x - GRID_REF_W - Sheet->m_RightMargin; ref.x = PageSize.x - GRID_REF_W - Sheet->m_RightMargin;
ref.y = PageSize.y - GRID_REF_W - Sheet->m_BottomMargin; ref.y = PageSize.y - GRID_REF_W - Sheet->m_BottomMargin;
for( WsItem = &WS_Date; WsItem != NULL; WsItem = WsItem->Pnext ) for( WsItem = &WS_Date; WsItem != NULL; WsItem = WsItem->Pnext )
{ {
pos.x = (ref.x - WsItem->m_Posx) * conv_unit; pos.x = (ref.x - WsItem->m_Posx) * conv_unit;
pos.y = (ref.y - WsItem->m_Posy) * conv_unit; pos.y = (ref.y - WsItem->m_Posy) * conv_unit;
if(WsItem->m_Legende) msg = WsItem->m_Legende; if( WsItem->m_Legende )
else msg.Empty(); msg = WsItem->m_Legende;
switch( WsItem->m_Type ) else
{ msg.Empty();
case WS_DATE:
msg += screen->m_Date; switch( WsItem->m_Type )
break; {
case WS_DATE:
case WS_REV: msg += screen->m_Date;
msg += screen->m_Revision; break;
break;
case WS_REV:
case WS_KICAD_VERSION: msg += screen->m_Revision;
msg += g_ProductName; break;
break;
case WS_KICAD_VERSION:
case WS_SIZESHEET: msg += g_ProductName;
msg += screen->m_CurrentSheetDesc->m_Name; break;
break;
case WS_SIZESHEET:
case WS_IDENTSHEET: msg += screen->m_CurrentSheetDesc->m_Name;
msg << screen->m_ScreenNumber << wxT("/") << screen->m_NumberOfScreen; break;
break;
case WS_IDENTSHEET:
case WS_FILENAME: msg << screen->m_ScreenNumber << wxT( "/" ) << screen->m_NumberOfScreen;
{ break;
wxString fname, fext;
wxFileName::SplitPath(screen->m_FileName, (wxString*)NULL, &fname, &fext); case WS_FILENAME:
msg << fname << wxT(".") << fext; {
} wxString fname, fext;
break; wxFileName::SplitPath( screen->m_FileName, (wxString*) NULL, &fname, &fext );
msg << fname << wxT( "." ) << fext;
case WS_FULLSHEETNAME: }
// msg += GetScreenDesc(); break;
break;
case WS_FULLSHEETNAME:
case WS_COMPANY_NAME:
msg += screen->m_Company; // msg += GetScreenDesc();
if ( ! msg.IsEmpty() ) break;
UpperLimit = MAX(UpperLimit, WsItem->m_Posy+SIZETEXT);
break; case WS_COMPANY_NAME:
msg += screen->m_Company;
case WS_TITLE: if( !msg.IsEmpty() )
msg += screen->m_Title; UpperLimit = MAX( UpperLimit, WsItem->m_Posy + SIZETEXT );
break; break;
case WS_COMMENT1: case WS_TITLE:
msg += screen->m_Commentaire1; msg += screen->m_Title;
if ( ! msg.IsEmpty() ) break;
UpperLimit = MAX(UpperLimit, WsItem->m_Posy+SIZETEXT);
break; case WS_COMMENT1:
msg += screen->m_Commentaire1;
case WS_COMMENT2: if( !msg.IsEmpty() )
msg += screen->m_Commentaire2; UpperLimit = MAX( UpperLimit, WsItem->m_Posy + SIZETEXT );
if ( ! msg.IsEmpty() ) break;
UpperLimit = MAX(UpperLimit, WsItem->m_Posy+SIZETEXT);
break; case WS_COMMENT2:
msg += screen->m_Commentaire2;
case WS_COMMENT3: if( !msg.IsEmpty() )
msg += screen->m_Commentaire3; UpperLimit = MAX( UpperLimit, WsItem->m_Posy + SIZETEXT );
if ( ! msg.IsEmpty() ) break;
UpperLimit = MAX(UpperLimit, WsItem->m_Posy+SIZETEXT);
break; case WS_COMMENT3:
msg += screen->m_Commentaire3;
case WS_COMMENT4: if( !msg.IsEmpty() )
msg += screen->m_Commentaire4; UpperLimit = MAX( UpperLimit, WsItem->m_Posy + SIZETEXT );
if ( ! msg.IsEmpty() ) break;
UpperLimit = MAX(UpperLimit, WsItem->m_Posy+SIZETEXT);
break; case WS_COMMENT4:
msg += screen->m_Commentaire4;
case WS_UPPER_SEGMENT: if( !msg.IsEmpty() )
if (UpperLimit == 0 ) break; UpperLimit = MAX( UpperLimit, WsItem->m_Posy + SIZETEXT );
case WS_LEFT_SEGMENT: break;
WS_MostUpperLine.m_Posy =
WS_MostUpperLine.m_Endy = case WS_UPPER_SEGMENT:
WS_MostLeftLine.m_Posy = UpperLimit; if( UpperLimit == 0 )
pos.y = (ref.y - WsItem->m_Posy) * conv_unit; break;
case WS_SEGMENT:
{ case WS_LEFT_SEGMENT:
wxPoint auxpos; WS_MostUpperLine.m_Posy =
auxpos.x = (ref.x - WsItem->m_Endx) * conv_unit;; WS_MostUpperLine.m_Endy =
auxpos.y = (ref.y - WsItem->m_Endy) * conv_unit;; WS_MostLeftLine.m_Posy = UpperLimit;
FctPlume(pos, 'U'); pos.y = (ref.y - WsItem->m_Posy) * conv_unit;
FctPlume(auxpos, 'D');
} case WS_SEGMENT:
break; {
wxPoint auxpos;
} auxpos.x = (ref.x - WsItem->m_Endx) * conv_unit;;
if ( ! msg.IsEmpty() ) auxpos.y = (ref.y - WsItem->m_Endy) * conv_unit;;
{ FctPlume( pos, 'U' );
PlotGraphicText(format_plot, pos, color, FctPlume( auxpos, 'D' );
msg.GetData(), TEXT_ORIENT_HORIZ,text_size, }
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER); break;
} }
}
if( !msg.IsEmpty() )
switch ( format_plot ) {
{ PlotGraphicText( format_plot, pos, color,
case PLOT_FORMAT_HPGL: msg.GetData(), TEXT_ORIENT_HORIZ, text_size,
Plume_HPGL('U'); GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER );
break; }
case PLOT_FORMAT_POST: }
break;
} switch( format_plot )
{
case PLOT_FORMAT_HPGL:
Plume_HPGL( 'U' );
break;
case PLOT_FORMAT_POST:
break;
}
} }
/******************************************/ /******************************************/
void UserToDeviceCoordinate(wxPoint & pos ) void UserToDeviceCoordinate( wxPoint& pos )
/******************************************/ /******************************************/
/* modifie les coord pos.x et pos.y pour le trace selon l'orientation, /* modifie les coord pos.x et pos.y pour le trace selon l'orientation,
l'echelle, les offsets de trace */ * l'echelle, les offsets de trace */
{ {
pos.x = (int) (pos.x * XScale);
pos.x = (int) (pos.x * XScale); pos.y = (int) (pos.y * YScale);
pos.y = (int) (pos.y * YScale);
switch( PlotOrientOptions ) /* Calcul du cadrage */
switch ( PlotOrientOptions) /* Calcul du cadrage */ {
{ default:
default : pos.x -= PlotOffset.x; pos.y = PlotOffset.y - pos.y;
pos.x -= PlotOffset.x ; pos.y = PlotOffset.y - pos.y; break;
break ;
case PLOT_MIROIR:
case PLOT_MIROIR : pos.x -= PlotOffset.x; pos.y = -PlotOffset.y + pos.y;
pos.x -= PlotOffset.x ; pos.y = - PlotOffset.y + pos.y; break;
break ; }
}
} }
/************************************/ /************************************/
void UserToDeviceSize(wxSize & size ) void UserToDeviceSize( wxSize& size )
/************************************/ /************************************/
/* modifie les dimension size.x et size.y pour le trace selon l'echelle */ /* modifie les dimension size.x et size.y pour le trace selon l'echelle */
{ {
size.x = (int) (size.x * XScale); size.x = (int) (size.x * XScale);
size.y = (int) (size.y * YScale); size.y = (int) (size.y * YScale);
} }
common/drawtxt.cpp
View file @ 2da432b2
...@@ -62,7 +62,7 @@ void DrawGraphicText( WinEDA_DrawPanel* panel, wxDC* DC, ...@@ -62,7 +62,7 @@ void DrawGraphicText( WinEDA_DrawPanel* panel, wxDC* DC,
width = -width; width = -width;
sketch_mode = TRUE; sketch_mode = TRUE;
} }
kk = 0; kk = 0;
ptr = 0; /* ptr = text index */ ptr = 0; /* ptr = text index */
nbchar = Text.Len(); nbchar = Text.Len();
...@@ -70,7 +70,7 @@ void DrawGraphicText( WinEDA_DrawPanel* panel, wxDC* DC, ...@@ -70,7 +70,7 @@ void DrawGraphicText( WinEDA_DrawPanel* panel, wxDC* DC,
return; return;
espacement = (10 * size_h ) / 9; // this is the pitch between chars espacement = (10 * size_h ) / 9; // this is the pitch between chars
ox = cX = Pos.x; ox = cX = Pos.x;
oy = cY = Pos.y; oy = cY = Pos.y;
/* Do not draw the text if out of draw area! */ /* Do not draw the text if out of draw area! */
...@@ -79,15 +79,15 @@ void DrawGraphicText( WinEDA_DrawPanel* panel, wxDC* DC, ...@@ -79,15 +79,15 @@ void DrawGraphicText( WinEDA_DrawPanel* panel, wxDC* DC,
int xm, ym, ll, xc, yc; int xm, ym, ll, xc, yc;
int textsize = ABS( espacement ); int textsize = ABS( espacement );
ll = (textsize * nbchar) / zoom; ll = (textsize * nbchar) / zoom;
xc = GRMapX( cX ); xc = GRMapX( cX );
yc = GRMapY( cY ); yc = GRMapY( cY );
x0 = panel->m_ClipBox.GetX() - ll; x0 = panel->m_ClipBox.GetX() - ll;
y0 = panel->m_ClipBox.GetY() - ll; y0 = panel->m_ClipBox.GetY() - ll;
xm = panel->m_ClipBox.GetRight() + ll; xm = panel->m_ClipBox.GetRight() + ll;
ym = panel->m_ClipBox.GetBottom() + ll; ym = panel->m_ClipBox.GetBottom() + ll;
if( xc < x0 ) if( xc < x0 )
return; return;
if( yc < y0 ) if( yc < y0 )
...@@ -165,10 +165,10 @@ void DrawGraphicText( WinEDA_DrawPanel* panel, wxDC* DC, ...@@ -165,10 +165,10 @@ void DrawGraphicText( WinEDA_DrawPanel* panel, wxDC* DC,
break; break;
} }
} }
cX += ux0; cX += ux0;
cY += uy0; cY += uy0;
ox = cX - dx; ox = cX - dx;
oy = cY + dy; oy = cY + dy;
...@@ -180,15 +180,15 @@ void DrawGraphicText( WinEDA_DrawPanel* panel, wxDC* DC, ...@@ -180,15 +180,15 @@ void DrawGraphicText( WinEDA_DrawPanel* panel, wxDC* DC,
dx = (espacement * nbchar) / 2; dx = (espacement * nbchar) / 2;
dy = size_v / 2; /* Decalage du debut du texte / centre */ dy = size_v / 2; /* Decalage du debut du texte / centre */
ux0 = cX - dx; ux0 = cX - dx;
uy0 = cY; uy0 = cY;
dx += cX; dx += cX;
dy = cY; dy = cY;
RotatePoint( &ux0, &uy0, cX, cY, orient ); RotatePoint( &ux0, &uy0, cX, cY, orient );
RotatePoint( &dx, &dy, cX, cY, orient ); RotatePoint( &dx, &dy, cX, cY, orient );
GRLine( &panel->m_ClipBox, DC, ux0, uy0, dx, dy, width, gcolor ); GRLine( &panel->m_ClipBox, DC, ux0, uy0, dx, dy, width, gcolor );
return; return;
...@@ -197,21 +197,21 @@ void DrawGraphicText( WinEDA_DrawPanel* panel, wxDC* DC, ...@@ -197,21 +197,21 @@ void DrawGraphicText( WinEDA_DrawPanel* panel, wxDC* DC,
#if 0 #if 0
dx = (espacement * nbchar) / 2; dx = (espacement * nbchar) / 2;
dy = size_v / 2;/* Decalage du debut du texte / centre */ dy = size_v / 2;/* Decalage du debut du texte / centre */
ux0 = cX - dx; ux0 = cX - dx;
uy0 = cY; uy0 = cY;
dx += cX; dx += cX;
dy = cY; dy = cY;
RotatePoint( &ux0, &uy0, cX, cY, orient ); RotatePoint( &ux0, &uy0, cX, cY, orient );
RotatePoint( &dx, &dy, cX, cY, orient ); RotatePoint( &dx, &dy, cX, cY, orient );
DC->SetTextForeground( wxColour( DC->SetTextForeground( wxColour(
ColorRefs[gcolor].r, ColorRefs[gcolor].r,
ColorRefs[gcolor].g, ColorRefs[gcolor].g,
ColorRefs[gcolor].b ) ); ColorRefs[gcolor].b ) );
DC->DrawRotatedText( Text, GRMapX( ux0 ), GRMapY( uy0 ), (double) orient / 10.0 ); DC->DrawRotatedText( Text, GRMapX( ux0 ), GRMapY( uy0 ), (double) orient / 10.0 );
return; return;
#endif #endif
...@@ -256,24 +256,24 @@ void DrawGraphicText( WinEDA_DrawPanel* panel, wxDC* DC, ...@@ -256,24 +256,24 @@ void DrawGraphicText( WinEDA_DrawPanel* panel, wxDC* DC,
break; break;
case 'D': case 'D':
plume = f_cod; plume = f_cod;
break; break;
default: default:
{ {
k1 = f_cod; /* trace sur axe V */ k1 = f_cod; /* trace sur axe V */
k1 = -( (k1 * size_v) / 9 ); k1 = -( (k1 * size_v) / 9 );
ptcar++; ptcar++;
f_cod = *ptcar; f_cod = *ptcar;
k2 = f_cod; /* trace sur axe H */ k2 = f_cod; /* trace sur axe H */
k2 = (k2 * size_h) / 9; k2 = (k2 * size_h) / 9;
dx = k2 + ox; dy = k1 + oy; dx = k2 + ox; dy = k1 + oy;
RotatePoint( &dx, &dy, cX, cY, orient ); RotatePoint( &dx, &dy, cX, cY, orient );
coord[ii++] = dx; coord[ii++] = dx;
coord[ii++] = dy; coord[ii++] = dy;
break; break;
} }
} }
...@@ -326,7 +326,7 @@ void PlotGraphicText( int format_plot, const wxPoint& Pos, int gcolor, ...@@ -326,7 +326,7 @@ void PlotGraphicText( int format_plot, const wxPoint& Pos, int gcolor,
return; return;
} }
if( (gcolor >= 0) && (format_plot == PLOT_FORMAT_POST) ) if( gcolor >= 0 && IsPostScript( format_plot ) )
SetColorMapPS( gcolor ); SetColorMapPS( gcolor );
size_h = Size.x; size_h = Size.x;
...@@ -336,14 +336,14 @@ void PlotGraphicText( int format_plot, const wxPoint& Pos, int gcolor, ...@@ -336,14 +336,14 @@ void PlotGraphicText( int format_plot, const wxPoint& Pos, int gcolor,
if( size_v == 0 ) if( size_v == 0 )
size_v = DEFAULT_SIZE_TEXT; size_v = DEFAULT_SIZE_TEXT;
kk = 0; kk = 0;
ptr = 0; /* ptr = text index */ ptr = 0; /* ptr = text index */
/* calcul de la position du debut des textes: ox et oy */ /* calcul de la position du debut des textes: ox et oy */
nbchar = Text.Len(); nbchar = Text.Len();
espacement = (10 * size_h ) / 9; espacement = (10 * size_h ) / 9;
ox = cX = Pos.x; ox = cX = Pos.x;
oy = cY = Pos.y; oy = cY = Pos.y;
/* Calcul du cadrage du texte */ /* Calcul du cadrage du texte */
...@@ -412,11 +412,11 @@ void PlotGraphicText( int format_plot, const wxPoint& Pos, int gcolor, ...@@ -412,11 +412,11 @@ void PlotGraphicText( int format_plot, const wxPoint& Pos, int gcolor,
break; break;
} }
} }
cX += ux0; cX += ux0;
cY += uy0; /* cX, cY = coord du centre du texte */ cY += uy0; /* cX, cY = coord du centre du texte */
ox = -dx; ox = -dx;
oy = +dy; /* ox, oy = coord debut texte, relativement au centre */ oy = +dy; /* ox, oy = coord debut texte, relativement au centre */
FctPlume( wxPoint( 0, 0 ), 'Z' ); FctPlume( wxPoint( 0, 0 ), 'Z' );
...@@ -446,17 +446,17 @@ void PlotGraphicText( int format_plot, const wxPoint& Pos, int gcolor, ...@@ -446,17 +446,17 @@ void PlotGraphicText( int format_plot, const wxPoint& Pos, int gcolor,
k1 = -(k1 * size_v) / 9; k1 = -(k1 * size_v) / 9;
ptcar++; ptcar++;
f_cod = *ptcar; f_cod = *ptcar;
k2 = f_cod; /* trace sur axe H */ k2 = f_cod; /* trace sur axe H */
k2 = (k2 * size_h) / 9; k2 = (k2 * size_h) / 9;
dx = k2 + ox; dx = k2 + ox;
dy = k1 + oy; dy = k1 + oy;
RotatePoint( &dx, &dy, orient ); RotatePoint( &dx, &dy, orient );
FctPlume( wxPoint( cX + dx, cY + dy ), plume ); FctPlume( wxPoint( cX + dx, cY + dy ), plume );
x0 = k2; x0 = k2;
y0 = k1; y0 = k1;
break; break;
} }
......
eeschema/eestring.cpp
View file @ 2da432b2
/**************************************/ /**************************************/
/* Module to handle screen printing. */ /* Module to handle screen printing. */
/**************************************/ /**************************************/
#include "fctsys.h" #include "fctsys.h"
#include "gr_basic.h" #include "gr_basic.h"
...@@ -17,248 +17,259 @@ extern void Move_Plume( wxPoint pos, int plume ); // see plot.cpp ...@@ -17,248 +17,259 @@ extern void Move_Plume( wxPoint pos, int plume ); // see plot.cpp
/***************************************************************************** /*****************************************************************************
Put out pin number and pin text info, given the pin line coordinates. * Put out pin number and pin text info, given the pin line coordinates.
The line must be vertical or horizontal. * The line must be vertical or horizontal.
If PinText == NULL nothing is printed. If PinNum = 0 no number is printed. * If PinText == NULL nothing is printed. If PinNum = 0 no number is printed.
Current Zoom factor is taken into account. * Current Zoom factor is taken into account.
If TextInside then the text is been put inside,otherwise all is drawn outside. * If TextInside then the text is been put inside,otherwise all is drawn outside.
Pin Name: substring beteween '~' is negated * Pin Name: substring beteween '~' is negated
*****************************************************************************/ *****************************************************************************/
void LibDrawPin::DrawPinTexts(WinEDA_DrawPanel * panel, wxDC * DC, void LibDrawPin::DrawPinTexts( WinEDA_DrawPanel* panel, wxDC* DC,
wxPoint & pin_pos, int orient, wxPoint& pin_pos, int orient,
int TextInside, bool DrawPinNum, bool DrawPinName, int TextInside, bool DrawPinNum, bool DrawPinName,
int Color, int DrawMode) int Color, int DrawMode )
/* DrawMode = GR_OR, XOR ... */ /* DrawMode = GR_OR, XOR ... */
{ {
int ii, x, y, x1, y1, dx, dy, len; int ii, x, y, x1, y1, dx, dy, len;
wxString StringPinNum; wxString StringPinNum;
wxString PinText; wxString PinText;
int PinTextBarPos[256]; int PinTextBarPos[256];
int PinTextBarCount; int PinTextBarCount;
int NameColor, NumColor; int NameColor, NumColor;
int PinTxtLen; int PinTxtLen;
wxSize PinNameSize(m_PinNameSize,m_PinNameSize);
wxSize PinNumSize(m_PinNumSize,m_PinNumSize); wxSize PinNameSize( m_PinNameSize, m_PinNameSize );
int LineWidth = g_DrawMinimunLineWidth; wxSize PinNumSize( m_PinNumSize, m_PinNumSize );
GRSetDrawMode(DC, DrawMode); int LineWidth = g_DrawMinimunLineWidth;
/* Get the num and name colors */ GRSetDrawMode( DC, DrawMode );
NameColor = Color == - 1 ? ReturnLayerColor(LAYER_PINNAM) : Color;
NumColor = Color == - 1 ? ReturnLayerColor(LAYER_PINNUM) : Color; /* Get the num and name colors */
NameColor = Color == -1 ? ReturnLayerColor( LAYER_PINNAM ) : Color;
/* Create the pin num string */ NumColor = Color == -1 ? ReturnLayerColor( LAYER_PINNUM ) : Color;
ReturnPinStringNum(StringPinNum);
/* Create the pin num string */
x1 = pin_pos.x; y1 = pin_pos.y; ReturnPinStringNum( StringPinNum );
switch(orient)
{ x1 = pin_pos.x; y1 = pin_pos.y;
case PIN_UP: y1 -= m_PinLen; break;
case PIN_DOWN: y1 += m_PinLen; break; switch( orient )
case PIN_LEFT: x1 -= m_PinLen; break; {
case PIN_RIGHT: x1 += m_PinLen; break; case PIN_UP:
} y1 -= m_PinLen; break;
const wxChar * textsrc = m_PinName.GetData(); case PIN_DOWN:
float fPinTextPitch = PinNameSize.x * 1.1; y1 += m_PinLen; break;
/* Do we need to invert the string? Is this string has only "~"? */
PinTextBarCount = 0; PinTxtLen = 0; case PIN_LEFT:
ii = 0; x1 -= m_PinLen; break;
while ( * textsrc )
{ case PIN_RIGHT:
if ( * textsrc == '~' ) x1 += m_PinLen; break;
{ }
PinTextBarPos[PinTextBarCount++] = (int)(PinTxtLen * fPinTextPitch);
} const wxChar* textsrc = m_PinName.GetData();
else float fPinTextPitch = PinNameSize.x * 1.1;
{ /* Do we need to invert the string? Is this string has only "~"? */
PinText.Append(* textsrc); PinTextBarCount = 0; PinTxtLen = 0;
PinTxtLen ++; ii = 0;
} while( *textsrc )
{
textsrc++; if( *textsrc == '~' )
} {
PinTextBarPos[PinTextBarCount++] = (int) (PinTxtLen * fPinTextPitch);
PinTxtLen = (int) (fPinTextPitch * PinTxtLen); }
PinTextBarPos[PinTextBarCount] = PinTxtLen; // Needed if no end '~' else
{
if (PinText[0] == 0) DrawPinName = FALSE; PinText.Append( *textsrc );
PinTxtLen++;
if( TextInside ) /* Draw the text inside, but the pin numbers outside. */ }
{
if( (orient == PIN_LEFT) || (orient == PIN_RIGHT) ) textsrc++;
// It is an horizontal line }
{
if (PinText && DrawPinName) PinTxtLen = (int) (fPinTextPitch * PinTxtLen);
{ PinTextBarPos[PinTextBarCount] = PinTxtLen; // Needed if no end '~'
if( orient == PIN_RIGHT)
{ if( PinText[0] == 0 )
x = x1 + TextInside; DrawPinName = FALSE;
DrawGraphicText(panel, DC, wxPoint(x, y1), NameColor, PinText,
TEXT_ORIENT_HORIZ, if( TextInside ) /* Draw the text inside, but the pin numbers outside. */
PinNameSize, {
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, LineWidth); if( (orient == PIN_LEFT) || (orient == PIN_RIGHT) )
for ( ii = 0; ii < PinTextBarCount; ) // It is an horizontal line
{ {
GRMoveTo(x, y1 - TXTMARGE); if( PinText && DrawPinName )
dy = -PinNameSize.y / 2; {
GRMoveRel(0, dy); if( orient == PIN_RIGHT )
dx = PinTextBarPos[ii++]; // Get the line pos {
GRMoveRel(dx, 0); x = x1 + TextInside;
len = PinTextBarPos[ii++] - dx; // Get the line length DrawGraphicText( panel, DC, wxPoint( x, y1 ), NameColor, PinText,
GRLineRel(&panel->m_ClipBox, DC, len, 0, LineWidth, NameColor); TEXT_ORIENT_HORIZ,
} PinNameSize,
} GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, LineWidth );
else // Orient == PIN_LEFT
{ for( ii = 0; ii < PinTextBarCount; )
x = x1 - TextInside; {
DrawGraphicText(panel, DC, wxPoint(x, y1) , NameColor, PinText, GRMoveTo( x, y1 - TXTMARGE );
TEXT_ORIENT_HORIZ, dy = -PinNameSize.y / 2;
PinNameSize, GRMoveRel( 0, dy );
GR_TEXT_HJUSTIFY_RIGHT, GR_TEXT_VJUSTIFY_CENTER, LineWidth); dx = PinTextBarPos[ii++]; // Get the line pos
GRMoveRel( dx, 0 );
for ( ii = 0; ii < PinTextBarCount; ) len = PinTextBarPos[ii++] - dx; // Get the line length
{ GRLineRel( &panel->m_ClipBox, DC, len, 0, LineWidth, NameColor );
GRMoveTo(x, y1 - TXTMARGE); }
dy = -PinNameSize.y / 2; }
GRMoveRel(0, dy); else // Orient == PIN_LEFT
dx = PinTextBarPos[ii++]; // Get the line pos {
GRMoveRel(dx - PinTxtLen, 0); x = x1 - TextInside;
len = PinTextBarPos[ii++] - dx; // Get the line length DrawGraphicText( panel, DC, wxPoint( x, y1 ), NameColor, PinText,
GRLineRel(&panel->m_ClipBox, DC, len, 0, LineWidth, NameColor); TEXT_ORIENT_HORIZ,
} PinNameSize,
} GR_TEXT_HJUSTIFY_RIGHT, GR_TEXT_VJUSTIFY_CENTER, LineWidth );
}
for( ii = 0; ii < PinTextBarCount; )
if ( DrawPinNum) {
{ GRMoveTo( x, y1 - TXTMARGE );
DrawGraphicText(panel, DC, dy = -PinNameSize.y / 2;
wxPoint((x1 + pin_pos.x) / 2, y1 - TXTMARGE), NumColor, StringPinNum, GRMoveRel( 0, dy );
TEXT_ORIENT_HORIZ, PinNumSize, dx = PinTextBarPos[ii++]; // Get the line pos
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_BOTTOM, LineWidth); GRMoveRel( dx - PinTxtLen, 0 );
} len = PinTextBarPos[ii++] - dx; // Get the line length
} GRLineRel( &panel->m_ClipBox, DC, len, 0, LineWidth, NameColor );
}
else /* Its a vertical line. */ }
{ // Text is drawn from bottom to top (i.e. to negative value for Y axis) }
if (PinText && DrawPinName)
{ if( DrawPinNum )
if ( orient == PIN_DOWN ) {
{ DrawGraphicText( panel, DC,
y = y1 + TextInside; wxPoint( (x1 + pin_pos.x) / 2, y1 - TXTMARGE ), NumColor, StringPinNum,
TEXT_ORIENT_HORIZ, PinNumSize,
DrawGraphicText(panel, DC, wxPoint(x1, y), NameColor, PinText, GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_BOTTOM, LineWidth );
TEXT_ORIENT_VERT, PinNameSize, }
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_TOP, LineWidth); }
else /* Its a vertical line. */
for ( ii = 0; ii < PinTextBarCount; ) {
{ // Text is drawn from bottom to top (i.e. to negative value for Y axis)
GRMoveTo(x1 - TXTMARGE, y); if( PinText && DrawPinName )
dy = -PinNameSize.y / 2; {
GRMoveRel(dy , 0); if( orient == PIN_DOWN )
dx = PinTextBarPos[ii++]; // Get the line pos {
GRMoveRel(0, PinTxtLen - dx); y = y1 + TextInside;
len = PinTextBarPos[ii++] - dx; // Get the line length
GRLineRel(&panel->m_ClipBox, DC, 0, -len, LineWidth, NameColor); DrawGraphicText( panel, DC, wxPoint( x1, y ), NameColor, PinText,
} TEXT_ORIENT_VERT, PinNameSize,
} GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_TOP, LineWidth );
else /* PIN_UP */ for( ii = 0; ii < PinTextBarCount; )
{ {
y = y1 - TextInside; GRMoveTo( x1 - TXTMARGE, y );
dy = -PinNameSize.y / 2;
DrawGraphicText(panel, DC, wxPoint(x1, y), NameColor, PinText, GRMoveRel( dy, 0 );
TEXT_ORIENT_VERT, PinNameSize, dx = PinTextBarPos[ii++]; // Get the line pos
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_BOTTOM, LineWidth); GRMoveRel( 0, PinTxtLen - dx );
len = PinTextBarPos[ii++] - dx; // Get the line length
for ( ii = 0; ii < PinTextBarCount; ) GRLineRel( &panel->m_ClipBox, DC, 0, -len, LineWidth, NameColor );
{ }
GRMoveTo(x1 - TXTMARGE, y); }
dy = -PinNameSize.y / 2; else /* PIN_UP */
GRMoveRel(dy, 0); {
dx = PinTextBarPos[ii++]; // Get the line pos y = y1 - TextInside;
GRMoveRel(0, - dx);
len = PinTextBarPos[ii++] - dx; // Get the line length DrawGraphicText( panel, DC, wxPoint( x1, y ), NameColor, PinText,
GRLineRel(&panel->m_ClipBox, DC, 0, -len, LineWidth, NameColor); TEXT_ORIENT_VERT, PinNameSize,
} GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_BOTTOM, LineWidth );
}
} for( ii = 0; ii < PinTextBarCount; )
{
if(DrawPinNum) GRMoveTo( x1 - TXTMARGE, y );
{ dy = -PinNameSize.y / 2;
DrawGraphicText(panel, DC, GRMoveRel( dy, 0 );
wxPoint(x1 - TXTMARGE, (y1 + pin_pos.y) / 2) , NumColor, StringPinNum, dx = PinTextBarPos[ii++]; // Get the line pos
TEXT_ORIENT_VERT, PinNumSize, GRMoveRel( 0, -dx );
GR_TEXT_HJUSTIFY_RIGHT, GR_TEXT_VJUSTIFY_CENTER, LineWidth); len = PinTextBarPos[ii++] - dx; // Get the line length
} GRLineRel( &panel->m_ClipBox, DC, 0, -len, LineWidth, NameColor );
} }
} }
}
else /**** Draw num & text pin outside ****/
{ if( DrawPinNum )
if( (orient == PIN_LEFT) || (orient == PIN_RIGHT) ) {
/* Its an horizontal line. */ DrawGraphicText( panel, DC,
{ wxPoint( x1 - TXTMARGE, (y1 + pin_pos.y) / 2 ), NumColor, StringPinNum,
if (PinText && DrawPinName) TEXT_ORIENT_VERT, PinNumSize,
{ GR_TEXT_HJUSTIFY_RIGHT, GR_TEXT_VJUSTIFY_CENTER, LineWidth );
x = (x1 + pin_pos.x) / 2; }
DrawGraphicText(panel, DC, wxPoint(x , y1 - TXTMARGE), }
NameColor, PinText, }
TEXT_ORIENT_HORIZ, PinNameSize, else /**** Draw num & text pin outside ****/
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_BOTTOM, LineWidth); {
if( (orient == PIN_LEFT) || (orient == PIN_RIGHT) )
for ( ii = 0; ii < PinTextBarCount; ) /* Its an horizontal line. */
{ {
GRMoveTo(x, y1 - TXTMARGE*2); if( PinText && DrawPinName )
GRMoveRel(-PinTxtLen / 2, -PinNameSize.y ); {
dx = PinTextBarPos[ii++]; // Get the line pos x = (x1 + pin_pos.x) / 2;
GRMoveRel(dx, 0); DrawGraphicText( panel, DC, wxPoint( x, y1 - TXTMARGE ),
len = PinTextBarPos[ii++] - dx; // Get the line length NameColor, PinText,
GRLineRel(&panel->m_ClipBox, DC, len, 0, LineWidth, NameColor); TEXT_ORIENT_HORIZ, PinNameSize,
} GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_BOTTOM, LineWidth );
}
if(DrawPinNum) for( ii = 0; ii < PinTextBarCount; )
{ {
x = (x1 + pin_pos.x) / 2; GRMoveTo( x, y1 - TXTMARGE * 2 );
DrawGraphicText(panel, DC, wxPoint(x, y1 + TXTMARGE), GRMoveRel( -PinTxtLen / 2, -PinNameSize.y );
NumColor, StringPinNum, dx = PinTextBarPos[ii++]; // Get the line pos
TEXT_ORIENT_HORIZ, PinNumSize, GRMoveRel( dx, 0 );
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_TOP, LineWidth); len = PinTextBarPos[ii++] - dx; // Get the line length
} GRLineRel( &panel->m_ClipBox, DC, len, 0, LineWidth, NameColor );
} }
else /* Its a vertical line. */ }
{ if( DrawPinNum )
if (PinText && DrawPinName) {
{ x = (x1 + pin_pos.x) / 2;
y = (y1 + pin_pos.y) / 2; DrawGraphicText( panel, DC, wxPoint( x, y1 + TXTMARGE ),
DrawGraphicText(panel, DC, wxPoint(x1 - TXTMARGE , y ), NumColor, StringPinNum,
NameColor, PinText, TEXT_ORIENT_HORIZ, PinNumSize,
TEXT_ORIENT_VERT, PinNameSize, GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_TOP, LineWidth );
GR_TEXT_HJUSTIFY_RIGHT, GR_TEXT_VJUSTIFY_CENTER, LineWidth); }
}
for ( ii = 0; ii < PinTextBarCount; ) else /* Its a vertical line. */
{ {
GRMoveTo(x1 - (TXTMARGE * 2), y); if( PinText && DrawPinName )
GRMoveRel(-PinNameSize.y, -PinTxtLen / 2); {
dx = PinTextBarPos[ii++]; // Get the line pos y = (y1 + pin_pos.y) / 2;
GRMoveRel(0, PinTxtLen - dx); DrawGraphicText( panel, DC, wxPoint( x1 - TXTMARGE, y ),
len = PinTextBarPos[ii++] - dx; // Get the line length NameColor, PinText,
GRLineRel(&panel->m_ClipBox, DC, 0, - len, LineWidth, NameColor); TEXT_ORIENT_VERT, PinNameSize,
} GR_TEXT_HJUSTIFY_RIGHT, GR_TEXT_VJUSTIFY_CENTER, LineWidth );
}
for( ii = 0; ii < PinTextBarCount; )
if(DrawPinNum) {
{ GRMoveTo( x1 - (TXTMARGE * 2), y );
DrawGraphicText(panel, DC, wxPoint(x1 + TXTMARGE , (y1 + pin_pos.y) / 2), GRMoveRel( -PinNameSize.y, -PinTxtLen / 2 );
NumColor, StringPinNum, dx = PinTextBarPos[ii++]; // Get the line pos
TEXT_ORIENT_VERT, PinNumSize, GRMoveRel( 0, PinTxtLen - dx );
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, LineWidth); len = PinTextBarPos[ii++] - dx; // Get the line length
} GRLineRel( &panel->m_ClipBox, DC, 0, -len, LineWidth, NameColor );
} }
} }
if( DrawPinNum )
{
DrawGraphicText( panel, DC, wxPoint( x1 + TXTMARGE, (y1 + pin_pos.y) / 2 ),
NumColor, StringPinNum,
TEXT_ORIENT_VERT, PinNumSize,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER, LineWidth );
}
}
}
} }
/***************************************************************************** /*****************************************************************************
* Plot pin number and pin text info, given the pin line coordinates. * * Plot pin number and pin text info, given the pin line coordinates. *
* Same as DrawPinTexts((), but output is the plotter * Same as DrawPinTexts((), but output is the plotter
...@@ -268,224 +279,229 @@ int LineWidth = g_DrawMinimunLineWidth; ...@@ -268,224 +279,229 @@ int LineWidth = g_DrawMinimunLineWidth;
* If TextInside then the text is been put inside (moving from x1, y1 in * * If TextInside then the text is been put inside (moving from x1, y1 in *
* the opposite direction to x2,y2), otherwise all is drawn outside. * * the opposite direction to x2,y2), otherwise all is drawn outside. *
*****************************************************************************/ *****************************************************************************/
void LibDrawPin::PlotPinTexts(wxPoint & pin_pos, int orient, void LibDrawPin::PlotPinTexts( wxPoint& pin_pos, int orient,
int TextInside, bool DrawPinNum, bool DrawPinName) int TextInside, bool DrawPinNum, bool DrawPinName )
{ {
int dx, len, start; int dx, len, start;
int ii , x, y, x1, y1, cte; int ii, x, y, x1, y1, cte;
wxString StringPinNum; wxString StringPinNum;
wxString PinText; wxString PinText;
int PinTextBarPos[256]; int PinTextBarPos[256];
int PinTextBarCount; int PinTextBarCount;
int NameColor, NumColor; int NameColor, NumColor;
int PinTxtLen = 0; int PinTxtLen = 0;
wxSize PinNameSize = wxSize(m_PinNameSize,m_PinNameSize); wxSize PinNameSize = wxSize( m_PinNameSize, m_PinNameSize );
wxSize PinNumSize = wxSize(m_PinNumSize,m_PinNumSize); wxSize PinNumSize = wxSize( m_PinNumSize, m_PinNumSize );
bool plot_color = (g_PlotFormat == PLOT_FORMAT_POST) && g_PlotPSColorOpt; bool plot_color = (g_PlotFormat == PLOT_FORMAT_POST) && g_PlotPSColorOpt;
/* Get the num and name colors */ /* Get the num and name colors */
NameColor = plot_color ? ReturnLayerColor(LAYER_PINNAM) : -1; NameColor = plot_color ? ReturnLayerColor( LAYER_PINNAM ) : -1;
NumColor = plot_color ? ReturnLayerColor(LAYER_PINNUM) : -1; NumColor = plot_color ? ReturnLayerColor( LAYER_PINNUM ) : -1;
/* Create the pin num string */ /* Create the pin num string */
ReturnPinStringNum(StringPinNum); ReturnPinStringNum( StringPinNum );
x1 = pin_pos.x; y1 = pin_pos.y; x1 = pin_pos.x; y1 = pin_pos.y;
switch(orient)
{ switch( orient )
case PIN_UP: y1 -= m_PinLen; break; {
case PIN_DOWN: y1 += m_PinLen; break; case PIN_UP:
case PIN_LEFT: x1 -= m_PinLen; break; y1 -= m_PinLen; break;
case PIN_RIGHT: x1 += m_PinLen; break;
} case PIN_DOWN:
y1 += m_PinLen; break;
const wxChar * textsrc = m_PinName.GetData();
float fPinTextPitch = PinNameSize.x * 1.1; case PIN_LEFT:
/* Do we need to invert the string? Is this string has only "~"? */ x1 -= m_PinLen; break;
PinTextBarCount = 0; PinTxtLen = 0;
ii = 0; case PIN_RIGHT:
while ( * textsrc ) x1 += m_PinLen; break;
{ }
if ( * textsrc == '~' )
{ const wxChar* textsrc = m_PinName.GetData();
PinTextBarPos[PinTextBarCount++] = (int) (fPinTextPitch * PinTxtLen); float fPinTextPitch = PinNameSize.x * 1.1;
} /* Do we need to invert the string? Is this string has only "~"? */
else PinTextBarCount = 0; PinTxtLen = 0;
{ ii = 0;
PinText.Append(* textsrc); while( *textsrc )
PinTxtLen ++; {
} if( *textsrc == '~' )
{
textsrc++; PinTextBarPos[PinTextBarCount++] = (int) (fPinTextPitch * PinTxtLen);
} }
else
PinTxtLen = (int) (fPinTextPitch * PinTxtLen); {
PinTextBarPos[PinTextBarCount] = PinTxtLen; // Needed if no end '~' PinText.Append( *textsrc );
PinTxtLen++;
if (PinText[0] == 0) DrawPinName = FALSE; }
if (TextInside) /* Draw the text inside, but the pin numbers outside. */ textsrc++;
{ }
if( (orient == PIN_LEFT) || (orient == PIN_RIGHT) )
{ /* Its an horizontal line. */ PinTxtLen = (int) (fPinTextPitch * PinTxtLen);
if (PinText && DrawPinName) PinTextBarPos[PinTextBarCount] = PinTxtLen; // Needed if no end '~'
{
if( orient == PIN_RIGHT) if( PinText[0] == 0 )
{ DrawPinName = FALSE;
x = x1 + TextInside;
PlotGraphicText(g_PlotFormat, wxPoint(x, y1), NameColor, PinText, if( TextInside ) /* Draw the text inside, but the pin numbers outside. */
TEXT_ORIENT_HORIZ, {
PinNameSize, if( (orient == PIN_LEFT) || (orient == PIN_RIGHT) )
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER); { /* Its an horizontal line. */
if( PinText && DrawPinName )
for ( ii = 0; ii < PinTextBarCount; ) {
{ if( orient == PIN_RIGHT )
cte = y1 - PinNameSize.y/2 - TXTMARGE; {
dx = PinTextBarPos[ii++]; // Get the line pos x = x1 + TextInside;
Move_Plume( wxPoint(x+dx, cte), 'U'); PlotGraphicText( g_PlotFormat, wxPoint( x, y1 ), NameColor, PinText,
len = PinTextBarPos[ii++]; // Get the line end TEXT_ORIENT_HORIZ,
Move_Plume( wxPoint(x + len, cte), 'D'); PinNameSize,
} GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER );
}
else // orient == PIN_LEFT for( ii = 0; ii < PinTextBarCount; )
{ {
x = x1 - TextInside; cte = y1 - PinNameSize.y / 2 - TXTMARGE;
PlotGraphicText(g_PlotFormat, wxPoint(x, y1), dx = PinTextBarPos[ii++]; // Get the line pos
NameColor, PinText, TEXT_ORIENT_HORIZ, Move_Plume( wxPoint( x + dx, cte ), 'U' );
PinNameSize, len = PinTextBarPos[ii++]; // Get the line end
GR_TEXT_HJUSTIFY_RIGHT, GR_TEXT_VJUSTIFY_CENTER); Move_Plume( wxPoint( x + len, cte ), 'D' );
}
for ( ii = 0; ii < PinTextBarCount; ) }
{ else // orient == PIN_LEFT
cte = y1 - PinNameSize.y/2 - TXTMARGE; {
dx = PinTextBarPos[ii++]; // Get the line pos x = x1 - TextInside;
Move_Plume( wxPoint(x+dx - PinTxtLen, cte), 'U'); PlotGraphicText( g_PlotFormat, wxPoint( x, y1 ),
len = PinTextBarPos[ii++]; // Get the line end NameColor, PinText, TEXT_ORIENT_HORIZ,
Move_Plume(wxPoint(x + len - PinTxtLen, cte), 'D'); PinNameSize,
} GR_TEXT_HJUSTIFY_RIGHT, GR_TEXT_VJUSTIFY_CENTER );
}
} for( ii = 0; ii < PinTextBarCount; )
{
if (DrawPinNum) cte = y1 - PinNameSize.y / 2 - TXTMARGE;
{ dx = PinTextBarPos[ii++]; // Get the line pos
PlotGraphicText( g_PlotFormat, wxPoint((x1 + pin_pos.x) / 2, y1 - TXTMARGE), Move_Plume( wxPoint( x + dx - PinTxtLen, cte ), 'U' );
NumColor, StringPinNum, len = PinTextBarPos[ii++]; // Get the line end
TEXT_ORIENT_HORIZ, PinNumSize, Move_Plume( wxPoint( x + len - PinTxtLen, cte ), 'D' );
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_BOTTOM); }
} }
} }
else /* Its a vertical line. */ if( DrawPinNum )
{ {
if (PinText && DrawPinName) PlotGraphicText( g_PlotFormat, wxPoint( (x1 + pin_pos.x) / 2, y1 - TXTMARGE ),
{ NumColor, StringPinNum,
if ( orient == PIN_DOWN ) TEXT_ORIENT_HORIZ, PinNumSize,
{ GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_BOTTOM );
y = y1 + TextInside; }
}
PlotGraphicText( g_PlotFormat, wxPoint(x1, y), NameColor, PinText, else /* Its a vertical line. */
TEXT_ORIENT_VERT, PinNameSize, {
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_TOP); if( PinText && DrawPinName )
{
for ( ii = 0; ii < PinTextBarCount; ) if( orient == PIN_DOWN )
{ {
cte = x1 - PinNameSize.y/2 - TXTMARGE; y = y1 + TextInside;
dx = PinTextBarPos[ii++]; // Get the line pos
Move_Plume( wxPoint(cte, y + PinTxtLen - dx), 'U'); PlotGraphicText( g_PlotFormat, wxPoint( x1, y ), NameColor, PinText,
len = PinTextBarPos[ii++]; // Get the line end TEXT_ORIENT_VERT, PinNameSize,
Move_Plume( wxPoint(cte , y + PinTxtLen - len), 'D'); GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_TOP );
}
} for( ii = 0; ii < PinTextBarCount; )
{
else /* PIN_UP */ cte = x1 - PinNameSize.y / 2 - TXTMARGE;
{ dx = PinTextBarPos[ii++]; // Get the line pos
y = y1 - TextInside; Move_Plume( wxPoint( cte, y + PinTxtLen - dx ), 'U' );
len = PinTextBarPos[ii++]; // Get the line end
PlotGraphicText( g_PlotFormat, wxPoint(x1, y), NameColor, PinText, Move_Plume( wxPoint( cte, y + PinTxtLen - len ), 'D' );
TEXT_ORIENT_VERT, PinNameSize, }
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_BOTTOM); }
else /* PIN_UP */
for ( ii = 0; ii < PinTextBarCount; ) {
{ y = y1 - TextInside;
cte = x1 - PinNameSize.y/2 - TXTMARGE;
dx = PinTextBarPos[ii++]; // Get the line pos PlotGraphicText( g_PlotFormat, wxPoint( x1, y ), NameColor, PinText,
Move_Plume( wxPoint(cte, y -dx), 'U'); TEXT_ORIENT_VERT, PinNameSize,
len = PinTextBarPos[ii++]; // Get the line end GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_BOTTOM );
Move_Plume(wxPoint(cte, y - len), 'D');
} for( ii = 0; ii < PinTextBarCount; )
} {
} cte = x1 - PinNameSize.y / 2 - TXTMARGE;
dx = PinTextBarPos[ii++]; // Get the line pos
if (DrawPinNum) Move_Plume( wxPoint( cte, y - dx ), 'U' );
{ len = PinTextBarPos[ii++]; // Get the line end
PlotGraphicText( g_PlotFormat, wxPoint(x1 - TXTMARGE, (y1 + pin_pos.y) / 2), Move_Plume( wxPoint( cte, y - len ), 'D' );
NumColor, StringPinNum, }
TEXT_ORIENT_VERT, PinNumSize, }
GR_TEXT_HJUSTIFY_RIGHT, GR_TEXT_VJUSTIFY_CENTER); }
}
} if( DrawPinNum )
} {
PlotGraphicText( g_PlotFormat, wxPoint( x1 - TXTMARGE, (y1 + pin_pos.y) / 2 ),
else /* Draw num & text pin outside */ NumColor, StringPinNum,
{ TEXT_ORIENT_VERT, PinNumSize,
if( (orient == PIN_LEFT) || (orient == PIN_RIGHT) ) GR_TEXT_HJUSTIFY_RIGHT, GR_TEXT_VJUSTIFY_CENTER );
/* Its an horizontal line. */ }
{ }
if (PinText && DrawPinName) }
{ else /* Draw num & text pin outside */
x = (x1 + pin_pos.x) / 2; {
PlotGraphicText( g_PlotFormat, wxPoint(x, y1 - TXTMARGE), if( (orient == PIN_LEFT) || (orient == PIN_RIGHT) )
NameColor, PinText, /* Its an horizontal line. */
TEXT_ORIENT_HORIZ, PinNameSize, {
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_BOTTOM); if( PinText && DrawPinName )
{
for ( ii = 0; ii < PinTextBarCount; ) x = (x1 + pin_pos.x) / 2;
{ PlotGraphicText( g_PlotFormat, wxPoint( x, y1 - TXTMARGE ),
cte = y1 - PinNameSize.y - TXTMARGE*2; NameColor, PinText,
start = x - (PinTxtLen / 2); TEXT_ORIENT_HORIZ, PinNameSize,
dx = PinTextBarPos[ii++]; // Get the line pos GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_BOTTOM );
Move_Plume( wxPoint(start + dx, cte), 'U');
len = PinTextBarPos[ii++]; // Get the line end for( ii = 0; ii < PinTextBarCount; )
Move_Plume(wxPoint(start + len, cte), 'D'); {
} cte = y1 - PinNameSize.y - TXTMARGE * 2;
} start = x - (PinTxtLen / 2);
if (DrawPinNum) dx = PinTextBarPos[ii++]; // Get the line pos
{ Move_Plume( wxPoint( start + dx, cte ), 'U' );
x = (x1 + pin_pos.x) / 2; len = PinTextBarPos[ii++]; // Get the line end
PlotGraphicText(g_PlotFormat, wxPoint(x, y1 + TXTMARGE), Move_Plume( wxPoint( start + len, cte ), 'D' );
NumColor, StringPinNum, }
TEXT_ORIENT_HORIZ, PinNumSize, }
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_TOP); if( DrawPinNum )
} {
} x = (x1 + pin_pos.x) / 2;
else /* Its a vertical line. */ PlotGraphicText( g_PlotFormat, wxPoint( x, y1 + TXTMARGE ),
{ NumColor, StringPinNum,
if (PinText && DrawPinName) TEXT_ORIENT_HORIZ, PinNumSize,
{ GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_TOP );
y = (y1 + pin_pos.y) / 2; }
PlotGraphicText( g_PlotFormat, wxPoint(x1 - TXTMARGE,y), }
NameColor, PinText, else /* Its a vertical line. */
TEXT_ORIENT_VERT, PinNameSize, {
GR_TEXT_HJUSTIFY_RIGHT, GR_TEXT_VJUSTIFY_CENTER); if( PinText && DrawPinName )
{
for ( ii = 0; ii < PinTextBarCount; ) y = (y1 + pin_pos.y) / 2;
{ PlotGraphicText( g_PlotFormat, wxPoint( x1 - TXTMARGE, y ),
cte = x1 - PinNameSize.y - TXTMARGE*2; NameColor, PinText,
start = y + (PinTxtLen / 2); TEXT_ORIENT_VERT, PinNameSize,
dx = PinTextBarPos[ii++]; // Get the line pos GR_TEXT_HJUSTIFY_RIGHT, GR_TEXT_VJUSTIFY_CENTER );
Move_Plume( wxPoint(cte, start - dx), 'U');
len = PinTextBarPos[ii++]; // Get the line end for( ii = 0; ii < PinTextBarCount; )
Move_Plume( wxPoint(cte, start - len), 'D'); {
} cte = x1 - PinNameSize.y - TXTMARGE * 2;
} start = y + (PinTxtLen / 2);
dx = PinTextBarPos[ii++]; // Get the line pos
if (DrawPinNum) Move_Plume( wxPoint( cte, start - dx ), 'U' );
{ len = PinTextBarPos[ii++]; // Get the line end
PlotGraphicText( g_PlotFormat, wxPoint(x1 + TXTMARGE, (y1 + pin_pos.y) / 2), Move_Plume( wxPoint( cte, start - len ), 'D' );
NumColor, StringPinNum, }
TEXT_ORIENT_VERT, PinNumSize, }
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER);
} if( DrawPinNum )
} {
} PlotGraphicText( g_PlotFormat, wxPoint( x1 + TXTMARGE, (y1 + pin_pos.y) / 2 ),
NumColor, StringPinNum,
TEXT_ORIENT_VERT, PinNumSize,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER );
}
}
}
} }
eeschema/plot.cpp
View file @ 2da432b2
...@@ -54,7 +54,6 @@ void Move_Plume( wxPoint pos, int plume ) ...@@ -54,7 +54,6 @@ void Move_Plume( wxPoint pos, int plume )
break; break;
case PLOT_FORMAT_POST: case PLOT_FORMAT_POST:
case PLOT_FORMAT_POST_A4:
LineTo_PS( pos, plume ); LineTo_PS( pos, plume );
break; break;
} }
...@@ -69,7 +68,6 @@ void SetCurrentLineWidth( int width ) ...@@ -69,7 +68,6 @@ void SetCurrentLineWidth( int width )
break; break;
case PLOT_FORMAT_POST: case PLOT_FORMAT_POST:
case PLOT_FORMAT_POST_A4:
SetCurrentLineWidthPS( width ); SetCurrentLineWidthPS( width );
break; break;
} }
......
include/plot_common.h
View file @ 2da432b2
/********************/ /********************/
/* plot_common.h */ /* plot_common.h */
/********************/ /********************/
#ifndef PLOT_COMMON_H #ifndef PLOT_COMMON_H
#define PLOT_COMMON_H #define PLOT_COMMON_H
...@@ -12,12 +12,22 @@ ...@@ -12,12 +12,22 @@
#endif #endif
typedef enum { /**
PLOT_FORMAT_HPGL, * Enum PlotFormat
PLOT_FORMAT_POST, * must be kept in order of the radio buttons in the plot panel/window.
PLOT_FORMAT_GERBER, */
PLOT_FORMAT_POST_A4 enum PlotFormat {
} PlotFormat; PLOT_FORMAT_HPGL,
PLOT_FORMAT_GERBER,
PLOT_FORMAT_POST,
};
static inline bool IsPostScript( int aFormat )
{
return aFormat==PLOT_FORMAT_POST;
}
const int PLOT_MIROIR = 1; const int PLOT_MIROIR = 1;
...@@ -25,47 +35,59 @@ const int PLOT_MIROIR = 1; ...@@ -25,47 +35,59 @@ const int PLOT_MIROIR = 1;
/*******************************/ /*******************************/
/* common_plot_functions.cpp */ /* common_plot_functions.cpp */
/*******************************/ /*******************************/
void SetPlotScale(double xscale, double yscale); // Set the plot scale for the current plotting) void SetPlotScale( double xscale, double yscale ); // Set the plot scale for the current plotting)
void SetPlotOffset(wxPoint offset); // Set the plot offset for the current plotting) void SetPlotOffset( wxPoint offset ); // Set the plot offset for the current plotting)
void InitPlotParametresGERBER(wxPoint offset, double xscale, double yscale); void InitPlotParametresGERBER( wxPoint offset, double xscale, double yscale );
void PlotWorkSheet(int format_plot, BASE_SCREEN * screen); void PlotWorkSheet( int format_plot, BASE_SCREEN* screen );
void UserToDeviceCoordinate(wxPoint & pos ); void UserToDeviceCoordinate( wxPoint& pos );
// modifie les coord pos.x et pos.y pour le trace selon l'orientation, l'echelle, les offsets de trace
void UserToDeviceSize(wxSize & size ); // modifie les coord pos.x et pos.y pour le trace selon l'orientation, l'echelle, les offsets de trace
// modifie les dimension size.x et size.y pour le trace selon l'echelle void UserToDeviceSize( wxSize& size );
void ForcePenReinit();
// set the flag g_CurrentPenWidth to -1 in order // modifie les dimension size.x et size.y pour le trace selon l'echelle
// to force a pen width redefinition for the next draw command void ForcePenReinit();
// set the flag g_CurrentPenWidth to -1 in order
// to force a pen width redefinition for the next draw command
/*******************************/ /*******************************/
/* common_plotPS_functions.cpp */ /* common_plotPS_functions.cpp */
/*******************************/ /*******************************/
void SetCurrentLineWidthPS( int width); void SetCurrentLineWidthPS( int width );
void InitPlotParametresPS( wxPoint offset, Ki_PageDescr * sheet, double xscale, double yscale, int orient = 0); void InitPlotParametresPS( wxPoint offset,
void SetDefaultLineWidthPS( int width); Ki_PageDescr* sheet,
void PlotCircle_PS(wxPoint pos, int diametre, int width = -1); double xscale,
void PlotArcPS(wxPoint centre, int StAngle, int EndAngle, int rayon, int width = -1); double yscale,
// Plot an arc: StAngle, EndAngle = start and end arc in 0.1 degree int orient = 0 );
void PlotPolyPS( int nb_segm, int * coord, int fill, int width = -1); void SetDefaultLineWidthPS( int width );
void PlotFilledSegmentPS(wxPoint start , wxPoint end, int width); void PlotCircle_PS( wxPoint pos, int diametre, int width = -1 );
void LineTo_PS(wxPoint pos, int plume); void PlotArcPS( wxPoint centre, int StAngle, int EndAngle, int rayon, int width = -1 );
void PrintHeaderPS(FILE * file, const wxString & Creator, const wxString & FileName, int PageCount, int BBox[4], int PaperOrientation);
bool CloseFilePS(FILE * plot_file); // Plot an arc: StAngle, EndAngle = start and end arc in 0.1 degree
void SetColorMapPS(int color); void PlotPolyPS( int nb_segm, int* coord, int fill, int width = -1 );
void PlotFilledSegmentPS( wxPoint start, wxPoint end, int width );
void LineTo_PS( wxPoint pos, int plume );
void PrintHeaderPS( FILE* file,
const wxString& Creator,
const wxString& FileName,
int PageCount,
int BBox[4],
int PaperOrientation );
bool CloseFilePS( FILE* plot_file );
void SetColorMapPS( int color );
/*********************************/ /*********************************/
/* common_plotHPGL_functions.cpp */ /* common_plotHPGL_functions.cpp */
/*********************************/ /*********************************/
void InitPlotParametresHPGL(wxPoint offset, double xscale, double yscale, int orient = 0); void InitPlotParametresHPGL( wxPoint offset, double xscale, double yscale, int orient = 0 );
bool PrintHeaderHPGL(FILE * plot_file, int pen_speed, int pen_num); bool PrintHeaderHPGL( FILE* plot_file, int pen_speed, int pen_num );
bool CloseFileHPGL(FILE * plot_file); bool CloseFileHPGL( FILE* plot_file );
void PlotCircle_HPGL(wxPoint centre, int diameter, int width = -1); void PlotCircle_HPGL( wxPoint centre, int diameter, int width = -1 );
void PlotArcHPGL(wxPoint centre, int StAngle, int EndAngle, int rayon, int width = -1); void PlotArcHPGL( wxPoint centre, int StAngle, int EndAngle, int rayon, int width = -1 );
void PlotPolyHPGL( int nb, int * coord, int fill, int width = -1); void PlotPolyHPGL( int nb, int* coord, int fill, int width = -1 );
void Move_Plume_HPGL( wxPoint pos, int plume ); void Move_Plume_HPGL( wxPoint pos, int plume );
void Plume_HPGL( int plume ); void Plume_HPGL( int plume );
#endif // PLOT_COMMON_H
#endif // PLOT_COMMON_H
include/wxPcbStruct.h
View file @ 2da432b2
...@@ -258,7 +258,7 @@ public: ...@@ -258,7 +258,7 @@ public:
void Genere_GERBER( const wxString& FullFileName, int Layer, void Genere_GERBER( const wxString& FullFileName, int Layer,
bool PlotOriginIsAuxAxis ); bool PlotOriginIsAuxAxis );
void Genere_HPGL( const wxString& FullFileName, int Layer ); void Genere_HPGL( const wxString& FullFileName, int Layer );
void Genere_PS( const wxString& FullFileName, int Layer ); void Genere_PS( const wxString& FullFileName, int Layer, bool useA4 );
void Plot_Layer_HPGL( FILE* File, int masque_layer, void Plot_Layer_HPGL( FILE* File, int masque_layer,
int garde, int tracevia, int modetrace ); int garde, int tracevia, int modetrace );
void Plot_Layer_GERBER( FILE* File, int masque_layer, void Plot_Layer_GERBER( FILE* File, int masque_layer,
...@@ -413,13 +413,13 @@ public: ...@@ -413,13 +413,13 @@ public:
*/ */
void ImportSpecctraDesign( wxCommandEvent& event ); void ImportSpecctraDesign( wxCommandEvent& event );
/** /**
* Function Access_to_External_Tool * Function Access_to_External_Tool
* Run an external tool (like freeroute ) * Run an external tool (like freeroute )
*/ */
void Access_to_External_Tool( wxCommandEvent& event ); void Access_to_External_Tool( wxCommandEvent& event );
/* Fonctions specifiques */ /* Fonctions specifiques */
MODULE* ListAndSelectModuleName(); MODULE* ListAndSelectModuleName();
void Liste_Equipot( wxCommandEvent& event ); void Liste_Equipot( wxCommandEvent& event );
void Swap_Layers( wxCommandEvent& event ); void Swap_Layers( wxCommandEvent& event );
......
pcbnew/gen_drill_report_files.cpp
View file @ 2da432b2
...@@ -158,7 +158,7 @@ void GenDrillMapFile( BOARD* aPcb, FILE* aFile, const wxString& aFullFileName, w ...@@ -158,7 +158,7 @@ void GenDrillMapFile( BOARD* aPcb, FILE* aFile, const wxString& aFullFileName, w
TextWidth = 50; // Set Drill Symbols width in 1/10000 mils TextWidth = 50; // Set Drill Symbols width in 1/10000 mils
if( format == PLOT_FORMAT_POST ) if( IsPostScript( format ) )
{ {
sprintf( line, "%d setlinewidth\n", TextWidth ); sprintf( line, "%d setlinewidth\n", TextWidth );
fputs( line, aFile ); fputs( line, aFile );
...@@ -429,7 +429,7 @@ void PlotDrillSymbol( const wxPoint& position, int diametre, int aShapeId, int f ...@@ -429,7 +429,7 @@ void PlotDrillSymbol( const wxPoint& position, int diametre, int aShapeId, int f
x0 = position.x; y0 = position.y; x0 = position.x; y0 = position.y;
FctPlume = Move_Plume_HPGL; FctPlume = Move_Plume_HPGL;
if( format == PLOT_FORMAT_POST ) if( IsPostScript( format ) )
FctPlume = LineTo_PS; FctPlume = LineTo_PS;
switch( aShapeId ) switch( aShapeId )
...@@ -444,7 +444,7 @@ void PlotDrillSymbol( const wxPoint& position, int diametre, int aShapeId, int f ...@@ -444,7 +444,7 @@ void PlotDrillSymbol( const wxPoint& position, int diametre, int aShapeId, int f
case 1: /* Cercle */ case 1: /* Cercle */
if( format == PLOT_FORMAT_HPGL ) if( format == PLOT_FORMAT_HPGL )
trace_1_pastille_RONDE_HPGL( wxPoint( x0, y0 ), diametre, FILAIRE ); trace_1_pastille_RONDE_HPGL( wxPoint( x0, y0 ), diametre, FILAIRE );
if( format == PLOT_FORMAT_POST ) if( IsPostScript( format ) )
trace_1_pastille_RONDE_POST( wxPoint( x0, y0 ), diametre, FILAIRE ); trace_1_pastille_RONDE_POST( wxPoint( x0, y0 ), diametre, FILAIRE );
break; break;
...@@ -462,7 +462,7 @@ void PlotDrillSymbol( const wxPoint& position, int diametre, int aShapeId, int f ...@@ -462,7 +462,7 @@ void PlotDrillSymbol( const wxPoint& position, int diametre, int aShapeId, int f
FctPlume( wxPoint( x0 - rayon, y0 + rayon ), 'D' ); FctPlume( wxPoint( x0 - rayon, y0 + rayon ), 'D' );
if( format == PLOT_FORMAT_HPGL ) if( format == PLOT_FORMAT_HPGL )
trace_1_pastille_RONDE_HPGL( wxPoint( x0, y0 ), diametre, FILAIRE ); trace_1_pastille_RONDE_HPGL( wxPoint( x0, y0 ), diametre, FILAIRE );
if( format == PLOT_FORMAT_POST ) if( IsPostScript( format ) )
trace_1_pastille_RONDE_POST( wxPoint( x0, y0 ), diametre, FILAIRE ); trace_1_pastille_RONDE_POST( wxPoint( x0, y0 ), diametre, FILAIRE );
break; break;
...@@ -471,7 +471,7 @@ void PlotDrillSymbol( const wxPoint& position, int diametre, int aShapeId, int f ...@@ -471,7 +471,7 @@ void PlotDrillSymbol( const wxPoint& position, int diametre, int aShapeId, int f
FctPlume( wxPoint( x0 + rayon, y0 ), 'D' ); FctPlume( wxPoint( x0 + rayon, y0 ), 'D' );
if( format == PLOT_FORMAT_HPGL ) if( format == PLOT_FORMAT_HPGL )
trace_1_pastille_RONDE_HPGL( wxPoint( x0, y0 ), diametre, FILAIRE ); trace_1_pastille_RONDE_HPGL( wxPoint( x0, y0 ), diametre, FILAIRE );
if( format == PLOT_FORMAT_POST ) if( IsPostScript( format ) )
trace_1_pastille_RONDE_POST( wxPoint( x0, y0 ), diametre, FILAIRE ); trace_1_pastille_RONDE_POST( wxPoint( x0, y0 ), diametre, FILAIRE );
break; break;
...@@ -480,7 +480,7 @@ void PlotDrillSymbol( const wxPoint& position, int diametre, int aShapeId, int f ...@@ -480,7 +480,7 @@ void PlotDrillSymbol( const wxPoint& position, int diametre, int aShapeId, int f
FctPlume( wxPoint( x0, y0 + rayon ), 'D' ); FctPlume( wxPoint( x0, y0 + rayon ), 'D' );
if( format == PLOT_FORMAT_HPGL ) if( format == PLOT_FORMAT_HPGL )
trace_1_pastille_RONDE_HPGL( wxPoint( x0, y0 ), diametre, FILAIRE ); trace_1_pastille_RONDE_HPGL( wxPoint( x0, y0 ), diametre, FILAIRE );
if( format == PLOT_FORMAT_POST ) if( IsPostScript( format ) )
trace_1_pastille_RONDE_POST( wxPoint( x0, y0 ), diametre, FILAIRE ); trace_1_pastille_RONDE_POST( wxPoint( x0, y0 ), diametre, FILAIRE );
break; break;
...@@ -489,7 +489,7 @@ void PlotDrillSymbol( const wxPoint& position, int diametre, int aShapeId, int f ...@@ -489,7 +489,7 @@ void PlotDrillSymbol( const wxPoint& position, int diametre, int aShapeId, int f
trace_1_pad_TRAPEZE_HPGL( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0, trace_1_pad_TRAPEZE_HPGL( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0,
0 ), 0, 0 ), 0,
FILAIRE ); FILAIRE );
if( format == PLOT_FORMAT_POST ) if( IsPostScript( format ) )
trace_1_pad_TRAPEZE_POST( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0, trace_1_pad_TRAPEZE_POST( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0,
0 ), 0, 0 ), 0,
FILAIRE ); FILAIRE );
...@@ -500,7 +500,7 @@ void PlotDrillSymbol( const wxPoint& position, int diametre, int aShapeId, int f ...@@ -500,7 +500,7 @@ void PlotDrillSymbol( const wxPoint& position, int diametre, int aShapeId, int f
trace_1_pad_TRAPEZE_HPGL( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0, trace_1_pad_TRAPEZE_HPGL( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0,
0 ), 450, 0 ), 450,
FILAIRE ); FILAIRE );
if( format == PLOT_FORMAT_POST ) if( IsPostScript( format ) )
trace_1_pad_TRAPEZE_POST( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0, trace_1_pad_TRAPEZE_POST( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0,
0 ), 450, 0 ), 450,
FILAIRE ); FILAIRE );
...@@ -515,7 +515,7 @@ void PlotDrillSymbol( const wxPoint& position, int diametre, int aShapeId, int f ...@@ -515,7 +515,7 @@ void PlotDrillSymbol( const wxPoint& position, int diametre, int aShapeId, int f
trace_1_pad_TRAPEZE_HPGL( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0, trace_1_pad_TRAPEZE_HPGL( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0,
0 ), 0, 0 ), 0,
FILAIRE ); FILAIRE );
if( format == PLOT_FORMAT_POST ) if( IsPostScript( format ) )
trace_1_pad_TRAPEZE_POST( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0, trace_1_pad_TRAPEZE_POST( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0,
0 ), 0, 0 ), 0,
FILAIRE ); FILAIRE );
...@@ -530,7 +530,7 @@ void PlotDrillSymbol( const wxPoint& position, int diametre, int aShapeId, int f ...@@ -530,7 +530,7 @@ void PlotDrillSymbol( const wxPoint& position, int diametre, int aShapeId, int f
trace_1_pad_TRAPEZE_HPGL( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0, trace_1_pad_TRAPEZE_HPGL( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0,
0 ), 450, 0 ), 450,
FILAIRE ); FILAIRE );
if( format == PLOT_FORMAT_POST ) if( IsPostScript( format ) )
trace_1_pad_TRAPEZE_POST( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0, trace_1_pad_TRAPEZE_POST( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0,
0 ), 450, 0 ), 450,
FILAIRE ); FILAIRE );
...@@ -543,7 +543,7 @@ void PlotDrillSymbol( const wxPoint& position, int diametre, int aShapeId, int f ...@@ -543,7 +543,7 @@ void PlotDrillSymbol( const wxPoint& position, int diametre, int aShapeId, int f
trace_1_pad_TRAPEZE_HPGL( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0, trace_1_pad_TRAPEZE_HPGL( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0,
0 ), 0, 0 ), 0,
FILAIRE ); FILAIRE );
if( format == PLOT_FORMAT_POST ) if( IsPostScript( format ) )
trace_1_pad_TRAPEZE_POST( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0, trace_1_pad_TRAPEZE_POST( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0,
0 ), 0, 0 ), 0,
FILAIRE ); FILAIRE );
...@@ -556,7 +556,7 @@ void PlotDrillSymbol( const wxPoint& position, int diametre, int aShapeId, int f ...@@ -556,7 +556,7 @@ void PlotDrillSymbol( const wxPoint& position, int diametre, int aShapeId, int f
trace_1_pad_TRAPEZE_HPGL( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0, trace_1_pad_TRAPEZE_HPGL( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0,
0 ), 450, 0 ), 450,
FILAIRE ); FILAIRE );
if( format == PLOT_FORMAT_POST ) if( IsPostScript( format ) )
trace_1_pad_TRAPEZE_POST( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0, trace_1_pad_TRAPEZE_POST( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0,
0 ), 450, 0 ), 450,
FILAIRE ); FILAIRE );
...@@ -569,7 +569,7 @@ void PlotDrillSymbol( const wxPoint& position, int diametre, int aShapeId, int f ...@@ -569,7 +569,7 @@ void PlotDrillSymbol( const wxPoint& position, int diametre, int aShapeId, int f
trace_1_pad_TRAPEZE_HPGL( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0, trace_1_pad_TRAPEZE_HPGL( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0,
0 ), 450, 0 ), 450,
FILAIRE ); FILAIRE );
if( format == PLOT_FORMAT_POST ) if( IsPostScript( format ) )
trace_1_pad_TRAPEZE_POST( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0, trace_1_pad_TRAPEZE_POST( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0,
0 ), 450, 0 ), 450,
FILAIRE ); FILAIRE );
...@@ -578,7 +578,7 @@ void PlotDrillSymbol( const wxPoint& position, int diametre, int aShapeId, int f ...@@ -578,7 +578,7 @@ void PlotDrillSymbol( const wxPoint& position, int diametre, int aShapeId, int f
default: default:
if( format == PLOT_FORMAT_HPGL ) if( format == PLOT_FORMAT_HPGL )
trace_1_pastille_RONDE_HPGL( wxPoint( x0, y0 ), diametre, FILAIRE ); trace_1_pastille_RONDE_HPGL( wxPoint( x0, y0 ), diametre, FILAIRE );
if( format == PLOT_FORMAT_POST ) if( IsPostScript( format ) )
trace_1_pastille_RONDE_POST( wxPoint( x0, y0 ), diametre, FILAIRE ); trace_1_pastille_RONDE_POST( wxPoint( x0, y0 ), diametre, FILAIRE );
break; break;
} }
...@@ -654,21 +654,21 @@ void GenDrillReportFile( FILE* aFile, BOARD* aPcb, const wxString& aBoardFilenam ...@@ -654,21 +654,21 @@ void GenDrillReportFile( FILE* aFile, BOARD* aPcb, const wxString& aBoardFilenam
TotalHoleCount = 0; TotalHoleCount = 0;
if( gen_through_holes ) if( gen_through_holes )
{ {
sprintf( line, "Drill report for through holes :\n" ); sprintf( line, "Drill report for through holes :\n" );
} }
else else
{ {
if ( layer1 == COPPER_LAYER_N ) // First partial hole list if ( layer1 == COPPER_LAYER_N ) // First partial hole list
{ {
sprintf( line, "Drill report for buried and blind vias :\n\n"); sprintf( line, "Drill report for buried and blind vias :\n\n");
fputs( line, aFile ); fputs( line, aFile );
} }
sprintf( line, "Drill report for holes from layer %s to layer %s\n", sprintf( line, "Drill report for holes from layer %s to layer %s\n",
CONV_TO_UTF8 (aPcb->GetLayerName(layer1) ), CONV_TO_UTF8 (aPcb->GetLayerName(layer1) ),
CONV_TO_UTF8 (aPcb->GetLayerName(layer2) ) ); CONV_TO_UTF8 (aPcb->GetLayerName(layer2) ) );
} }
fputs( line, aFile ); fputs( line, aFile );
......
pcbnew/gendrill.cpp
View file @ 2da432b2
...@@ -287,64 +287,64 @@ void WinEDA_DrillFrame::GenDrillFiles( wxCommandEvent& event ) ...@@ -287,64 +287,64 @@ void WinEDA_DrillFrame::GenDrillFiles( wxCommandEvent& event )
Build_Holes_List( m_Parent->m_Pcb, s_HoleListBuffer, s_ToolListBuffer, Build_Holes_List( m_Parent->m_Pcb, s_HoleListBuffer, s_ToolListBuffer,
layer1, layer2, gen_through_holes ? false : true ); layer1, layer2, gen_through_holes ? false : true );
if( s_ToolListBuffer.size() > 0 ) //holes? if( s_ToolListBuffer.size() > 0 ) //holes?
{ {
FullFileName = m_Parent->m_CurrentScreen->m_FileName; FullFileName = m_Parent->m_CurrentScreen->m_FileName;
layer_extend.Empty(); layer_extend.Empty();
if( !gen_through_holes ) if( !gen_through_holes )
{ {
if( layer1 == COPPER_LAYER_N ) if( layer1 == COPPER_LAYER_N )
layer_extend << wxT( "-copper" ); layer_extend << wxT( "-copper" );
else else
layer_extend << wxT( "-inner" ) << layer1; layer_extend << wxT( "-inner" ) << layer1;
if( layer2 == LAYER_CMP_N ) if( layer2 == LAYER_CMP_N )
layer_extend << wxT( "-cmp" ); layer_extend << wxT( "-cmp" );
else else
layer_extend << wxT( "-inner" ) << layer2; layer_extend << wxT( "-inner" ) << layer2;
} }
layer_extend << Ext; layer_extend << Ext;
ChangeFileNameExt( FullFileName, layer_extend ); ChangeFileNameExt( FullFileName, layer_extend );
FullFileName = EDA_FileSelector( _( "Drill file" ), FullFileName = EDA_FileSelector( _( "Drill file" ),
wxEmptyString, /* Chemin par defaut */ wxEmptyString, /* Chemin par defaut */
FullFileName, /* nom fichier par defaut */ FullFileName, /* nom fichier par defaut */
Ext, /* extension par defaut */ Ext, /* extension par defaut */
Mask, /* Masque d'affichage */ Mask, /* Masque d'affichage */
this, this,
wxFD_SAVE, wxFD_SAVE,
TRUE TRUE
); );
if( FullFileName != wxEmptyString ) if( FullFileName != wxEmptyString )
{ {
dest = wxFopen( FullFileName, wxT( "w" ) ); dest = wxFopen( FullFileName, wxT( "w" ) );
if( dest == 0 ) if( dest == 0 )
{ {
msg = _( "Unable to create file " ) + FullFileName; msg = _( "Unable to create file " ) + FullFileName;
DisplayError( this, msg ); DisplayError( this, msg );
EndModal( 0 ); EndModal( 0 );
return; return;
} }
Create_Drill_File_EXCELLON( s_HoleListBuffer, s_ToolListBuffer ); Create_Drill_File_EXCELLON( s_HoleListBuffer, s_ToolListBuffer );
} }
switch( m_Choice_Drill_Map->GetSelection() ) switch( m_Choice_Drill_Map->GetSelection() )
{ {
case 0: case 0:
break; break;
case 1: case 1:
GenDrillMap( FullFileName, s_HoleListBuffer, s_ToolListBuffer, PLOT_FORMAT_HPGL ); GenDrillMap( FullFileName, s_HoleListBuffer, s_ToolListBuffer, PLOT_FORMAT_HPGL );
break; break;
case 2: case 2:
GenDrillMap( FullFileName, s_HoleListBuffer, s_ToolListBuffer, PLOT_FORMAT_POST ); GenDrillMap( FullFileName, s_HoleListBuffer, s_ToolListBuffer, PLOT_FORMAT_POST );
break; break;
} }
if( !ExistsBuriedVias ) if( !ExistsBuriedVias )
break; break;
} }
if( gen_through_holes ) if( gen_through_holes )
layer2 = layer1 + 1; layer2 = layer1 + 1;
else else
......
pcbnew/pcbplot.cpp
View file @ 2da432b2
...@@ -90,7 +90,29 @@ public: ...@@ -90,7 +90,29 @@ public:
WinEDA_ValueCtrl* m_HPGLPenOverlayOpt; WinEDA_ValueCtrl* m_HPGLPenOverlayOpt;
WinEDA_DFloatValueCtrl* m_FineAdjustXscaleOpt, * m_FineAdjustYscaleOpt; WinEDA_DFloatValueCtrl* m_FineAdjustXscaleOpt, * m_FineAdjustYscaleOpt;
double m_XScaleAdjust, m_YScaleAdjust; double m_XScaleAdjust, m_YScaleAdjust;
int m_PlotFormat;
bool useA4()
{
return m_PlotFormatOpt->GetSelection() == 3;
}
/**
* Function getFormat
* returns one of the values from the PlotFormat enum. If the 4th
* radio button is selected, map this back to postscript.
*/
PlotFormat getFormat()
{
int radioNdx = m_PlotFormatOpt->GetSelection();
// change the A4 to the simple postscript, according to the PlotFormat enum
if( radioNdx == 3 )
radioNdx = 2;
return PlotFormat( radioNdx );
}
public: public:
WinEDA_PlotFrame( WinEDA_BasePcbFrame * parent ); WinEDA_PlotFrame( WinEDA_BasePcbFrame * parent );
...@@ -137,7 +159,6 @@ WinEDA_PlotFrame::WinEDA_PlotFrame( WinEDA_BasePcbFrame* parent ) : ...@@ -137,7 +159,6 @@ WinEDA_PlotFrame::WinEDA_PlotFrame( WinEDA_BasePcbFrame* parent ) :
SetFont( *g_DialogFont ); SetFont( *g_DialogFont );
Centre(); Centre();
m_PlotFormat = format_plot;
m_Plot_Sheet_Ref = NULL; m_Plot_Sheet_Ref = NULL;
wxBoxSizer* MainBoxSizer = new wxBoxSizer( wxHORIZONTAL ); wxBoxSizer* MainBoxSizer = new wxBoxSizer( wxHORIZONTAL );
...@@ -169,33 +190,16 @@ WinEDA_PlotFrame::WinEDA_PlotFrame( WinEDA_BasePcbFrame* parent ) : ...@@ -169,33 +190,16 @@ WinEDA_PlotFrame::WinEDA_PlotFrame( WinEDA_BasePcbFrame* parent ) :
4, fmtmsg, 1, wxRA_SPECIFY_COLS ); 4, fmtmsg, 1, wxRA_SPECIFY_COLS );
MidRightBoxSizer->Add( m_PlotFormatOpt, 0, wxGROW | wxALL, 5 ); MidRightBoxSizer->Add( m_PlotFormatOpt, 0, wxGROW | wxALL, 5 );
if( config && config->Read( OPTKEY_OUTPUT_FORMAT, &m_PlotFormat ) ) int myFormatIndex = format_plot;
m_PlotFormatOpt->SetSelection( m_PlotFormat );
else if( config )
{ {
switch( m_PlotFormat ) config->Read( OPTKEY_OUTPUT_FORMAT, &myFormatIndex );
{
case PLOT_FORMAT_HPGL:
m_PlotFormatOpt->SetSelection( 0 );
break;
case PLOT_FORMAT_GERBER:
m_PlotFormatOpt->SetSelection( 1 );
break;
default: // ( PLOT_FORMAT_POST or PLOT_FORMAT_POST_A4 )
// As m_PlotFormat is never set to a value of PLOT_FORMAT_POST_A4,
// use the value of g_ForcePlotPS_On_A4 to determine whether the
// "Postscript" or "Postscipt A4" radiobutton had been selected
// previously (and thus which button should be reselected now).
if( g_ForcePlotPS_On_A4 )
m_PlotFormatOpt->SetSelection( 3 );
else
m_PlotFormatOpt->SetSelection( 2 );
break;
}
} }
m_PlotFormatOpt->SetSelection( myFormatIndex );
// Creation des menus d'option du format GERBER // Creation des menus d'option du format GERBER
m_GerbSpotSizeMinOpt = new WinEDA_ValueCtrl( this, _( "Spot min" ), m_GerbSpotSizeMinOpt = new WinEDA_ValueCtrl( this, _( "Spot min" ),
spot_mini, g_UnitMetric, MidRightBoxSizer, spot_mini, g_UnitMetric, MidRightBoxSizer,
...@@ -490,18 +494,10 @@ void WinEDA_PlotFrame::SetCommands( wxCommandEvent& event ) ...@@ -490,18 +494,10 @@ void WinEDA_PlotFrame::SetCommands( wxCommandEvent& event )
/* active ou dsactive les diffrents menus d'option selon le standard choisi /* active ou dsactive les diffrents menus d'option selon le standard choisi
*/ */
{ {
int format; int format = getFormat();
static const int format_list[] = {
PLOT_FORMAT_HPGL, PLOT_FORMAT_GERBER,
PLOT_FORMAT_POST, PLOT_FORMAT_POST_A4
};
format = format_list[m_PlotFormatOpt->GetSelection()];
switch( format ) switch( format )
{ {
case PLOT_FORMAT_POST_A4:
case PLOT_FORMAT_POST: case PLOT_FORMAT_POST:
default: default:
m_Drill_Shape_Opt->Enable( true ); m_Drill_Shape_Opt->Enable( true );
...@@ -519,8 +515,6 @@ void WinEDA_PlotFrame::SetCommands( wxCommandEvent& event ) ...@@ -519,8 +515,6 @@ void WinEDA_PlotFrame::SetCommands( wxCommandEvent& event )
m_Scale_Opt->Enable( true ); m_Scale_Opt->Enable( true );
m_FineAdjustXscaleOpt->Enable( true ); m_FineAdjustXscaleOpt->Enable( true );
m_FineAdjustYscaleOpt->Enable( true ); m_FineAdjustYscaleOpt->Enable( true );
m_PlotFormat = PLOT_FORMAT_POST;
g_ForcePlotPS_On_A4 = (format == PLOT_FORMAT_POST_A4);
m_Plot_PS_Negative->Enable( true ); m_Plot_PS_Negative->Enable( true );
break; break;
...@@ -540,7 +534,6 @@ void WinEDA_PlotFrame::SetCommands( wxCommandEvent& event ) ...@@ -540,7 +534,6 @@ void WinEDA_PlotFrame::SetCommands( wxCommandEvent& event )
m_Scale_Opt->Enable( false ); m_Scale_Opt->Enable( false );
m_FineAdjustXscaleOpt->Enable( false ); m_FineAdjustXscaleOpt->Enable( false );
m_FineAdjustYscaleOpt->Enable( false ); m_FineAdjustYscaleOpt->Enable( false );
m_PlotFormat = PLOT_FORMAT_GERBER;
m_Plot_PS_Negative->Enable( false ); m_Plot_PS_Negative->Enable( false );
break; break;
...@@ -560,12 +553,11 @@ void WinEDA_PlotFrame::SetCommands( wxCommandEvent& event ) ...@@ -560,12 +553,11 @@ void WinEDA_PlotFrame::SetCommands( wxCommandEvent& event )
m_Scale_Opt->Enable( true ); m_Scale_Opt->Enable( true );
m_FineAdjustXscaleOpt->Enable( false ); m_FineAdjustXscaleOpt->Enable( false );
m_FineAdjustYscaleOpt->Enable( false ); m_FineAdjustYscaleOpt->Enable( false );
m_PlotFormat = PLOT_FORMAT_HPGL;
m_Plot_PS_Negative->Enable( false ); m_Plot_PS_Negative->Enable( false );
break; break;
} }
format_plot = m_PlotFormat; format_plot = format;
} }
...@@ -616,8 +608,8 @@ void WinEDA_PlotFrame::SaveOptPlot( wxCommandEvent& event ) ...@@ -616,8 +608,8 @@ void WinEDA_PlotFrame::SaveOptPlot( wxCommandEvent& event )
config->Write( OPTKEY_PADS_ON_SILKSCREEN, PlotPadsOnSilkLayer ); config->Write( OPTKEY_PADS_ON_SILKSCREEN, PlotPadsOnSilkLayer );
config->Write( OPTKEY_ALWAYS_PRINT_PADS, Plot_Pads_All_Layers ); config->Write( OPTKEY_ALWAYS_PRINT_PADS, Plot_Pads_All_Layers );
m_PlotFormat = m_PlotFormatOpt->GetSelection(); int formatNdx = m_PlotFormatOpt->GetSelection();
config->Write( OPTKEY_OUTPUT_FORMAT, m_PlotFormat ); config->Write( OPTKEY_OUTPUT_FORMAT, formatNdx );
wxString layerKey; wxString layerKey;
for( int layer=0; layer<NB_LAYERS; ++layer ) for( int layer=0; layer<NB_LAYERS; ++layer )
...@@ -668,12 +660,15 @@ void WinEDA_PlotFrame::Plot( wxCommandEvent& event ) ...@@ -668,12 +660,15 @@ void WinEDA_PlotFrame::Plot( wxCommandEvent& event )
BaseFileName = m_Parent->GetScreen()->m_FileName; BaseFileName = m_Parent->GetScreen()->m_FileName;
ChangeFileNameExt( BaseFileName, wxT( "-" ) ); ChangeFileNameExt( BaseFileName, wxT( "-" ) );
switch( m_PlotFormat ) int format = getFormat();
switch( format )
{ {
case PLOT_FORMAT_POST: case PLOT_FORMAT_POST:
ext = wxT( ".ps" ); ext = wxT( ".ps" );
break; break;
default:
case PLOT_FORMAT_GERBER: case PLOT_FORMAT_GERBER:
ext = wxT( ".pho" ); ext = wxT( ".pho" );
break; break;
...@@ -695,12 +690,13 @@ void WinEDA_PlotFrame::Plot( wxCommandEvent& event ) ...@@ -695,12 +690,13 @@ void WinEDA_PlotFrame::Plot( wxCommandEvent& event )
// Calcul du nom du fichier // Calcul du nom du fichier
FullFileName = BaseFileName + board->GetLayerName( layer_to_plot ) + ext; FullFileName = BaseFileName + board->GetLayerName( layer_to_plot ) + ext;
switch( m_PlotFormat ) switch( format )
{ {
case PLOT_FORMAT_POST: case PLOT_FORMAT_POST:
m_Parent->Genere_PS( FullFileName, layer_to_plot ); m_Parent->Genere_PS( FullFileName, layer_to_plot, useA4() );
break; break;
default:
case PLOT_FORMAT_GERBER: case PLOT_FORMAT_GERBER:
m_Parent->Genere_GERBER( FullFileName, layer_to_plot, s_PlotOriginIsAuxAxis ); m_Parent->Genere_GERBER( FullFileName, layer_to_plot, s_PlotOriginIsAuxAxis );
break; break;
......
pcbnew/pcbplot.h
View file @ 2da432b2
/************/ /************/
/* pcbplot.h*/ /* pcbplot.h*/
/************/ /************/
#ifndef PCBPLOT_H #ifndef PCBPLOT_H
#define PCBPLOT_H #define PCBPLOT_H
...@@ -60,9 +60,9 @@ eda_global bool PlotPadsOnSilkLayer /* Plot pads sur couche serigraphie */ ...@@ -60,9 +60,9 @@ eda_global bool PlotPadsOnSilkLayer /* Plot pads sur couche serigraphie */
#endif #endif
; ;
eda_global bool Plot_Pads_All_Layers; /* Plot pads meme n'appartenant pas a la eda_global bool Plot_Pads_All_Layers; /* Plot pads meme n'appartenant pas a la
couche ( utile pour serigraphie) */ couche ( utile pour serigraphie) */
/* Variables utiles */ /* Variables utiles */
eda_global FILE * dest; eda_global FILE * dest;
...@@ -90,19 +90,18 @@ eda_global wxPoint g_PlotOffset; /* Offset de trace modifies par l'echelle */ ...@@ -90,19 +90,18 @@ eda_global wxPoint g_PlotOffset; /* Offset de trace modifies par l'echelle */
eda_global int nb_plot_erreur ; eda_global int nb_plot_erreur ;
eda_global int nb_items; /* utilise pour decompter les objets traces */ eda_global int nb_items; /* utilise pour decompter les objets traces */
eda_global int g_PlotLine_Width; /* Largeur du trait en mode filaire (utilise en serigraphie, eda_global int g_PlotLine_Width; /* Largeur du trait en mode filaire (utilise en serigraphie,
pour traces en mode sketch et filaire) */ pour traces en mode sketch et filaire) */
eda_global int format_plot; /* numero de code du format de sortie */ eda_global int format_plot; /* numero de code du format de sortie */
eda_global int g_PlotOrient; /* numero de code de l'orientation du trace ( voir eda_global int g_PlotOrient; /* numero de code de l'orientation du trace ( voir
defines precedents): defines precedents):
0 = normal 0 = normal
PLOT_MIROIR = MIROIR PLOT_MIROIR = MIROIR
*/ */
eda_global int g_PlotScaleOpt // 0 = automatique, >=1 echelle specifiee eda_global int g_PlotScaleOpt // 0 = automatique, >=1 echelle specifiee
#ifdef MAIN #ifdef MAIN
= 1 = 1
#endif #endif
; ;
eda_global bool g_ForcePlotPS_On_A4; // Force la selection de la feuille A4 pour le plot POSTSCRIPT
eda_global int g_DrillShapeOpt eda_global int g_DrillShapeOpt
#ifdef MAIN #ifdef MAIN
...@@ -111,9 +110,9 @@ eda_global int g_DrillShapeOpt ...@@ -111,9 +110,9 @@ eda_global int g_DrillShapeOpt
; ;
/*************************************/ /*************************************/
/* Constantes utiles en trace GERBER */ /* Constantes utiles en trace GERBER */
/*************************************/ /*************************************/
/* codes de type de forme d'outils */ /* codes de type de forme d'outils */
#define GERB_CIRCLE 1 #define GERB_CIRCLE 1
...@@ -123,34 +122,34 @@ eda_global int g_DrillShapeOpt ...@@ -123,34 +122,34 @@ eda_global int g_DrillShapeOpt
#define GERB_DONUT 5 #define GERB_DONUT 5
/* liste des D_CODES en fonction de leur numero d'ordre (numero d'outil) /* liste des D_CODES en fonction de leur numero d'ordre (numero d'outil)
(l'ordre 0 n'est pas utilise) ; (l'ordre 0 n'est pas utilise) ;
Tools have D_CODES >= 10 Tools have D_CODES >= 10
D_CODES <= 9 are used for commands only: D_CODES <= 9 are used for commands only:
D01 ... D9 = command codes for photo plotting: D01 ... D9 = command codes for photo plotting:
D01 = Light on D01 = Light on
D02 = Light off D02 = Light off
D03 = Flash D03 = Flash
D04 .. D08 = ? D04 .. D08 = ?
D09 = VAPE Flash D09 = VAPE Flash
*/ */
/* Routines generales de trace : */ /* Routines generales de trace : */
/* PLOT_RTN.CC */ /* PLOT_RTN.CC */
void PlotTextePcb( TEXTE_PCB * pt_texte,int format_plot,int masque_layer); void PlotTextePcb( TEXTE_PCB * pt_texte,int format_plot,int masque_layer);
/* Trace 1 Texte type PCB , c.a.d autre que les textes sur modules, /* Trace 1 Texte type PCB , c.a.d autre que les textes sur modules,
prepare les parametres de trace de Plot_1_texte */ prepare les parametres de trace de Plot_1_texte */
void PlotArc(int format_plot, wxPoint centre, int start_angle,int end_angle, void PlotArc(int format_plot, wxPoint centre, int start_angle,int end_angle,
int rayon,int width); int rayon,int width);
void PlotCircle(int format_plot,int width, wxPoint centre, int rayon); void PlotCircle(int format_plot,int width, wxPoint centre, int rayon);
void PlotPolygon(int format_plot, bool filled, int nbpoints, int * coord); void PlotPolygon(int format_plot, bool filled, int nbpoints, int * coord);
void Plot_1_texte( int format_plot, void Plot_1_texte( int format_plot,
const wxString & Text, int t_orient, const wxString & Text, int t_orient,
int width, int ox,int oy,int size_h,int size_v, int width, int ox,int oy,int size_h,int size_v,
bool centreX = TRUE, bool centreY = TRUE); bool centreX = TRUE, bool centreY = TRUE);
/* Routine de base de trace de 1 chaine de caracteres */ /* Routine de base de trace de 1 chaine de caracteres */
void PlotDrawSegment( DRAWSEGMENT* PtSegm, int format_plot,int masque_layer ); void PlotDrawSegment( DRAWSEGMENT* PtSegm, int format_plot,int masque_layer );
...@@ -165,17 +164,17 @@ void PlotGERBERLine(wxPoint start, wxPoint end, int hauteur); ...@@ -165,17 +164,17 @@ void PlotGERBERLine(wxPoint start, wxPoint end, int hauteur);
void PlotCircle_GERBER( wxPoint centre, int rayon, int width); void PlotCircle_GERBER( wxPoint centre, int rayon, int width);
void PlotPolygon_GERBER(int nb_segm, int * coord, bool fill); void PlotPolygon_GERBER(int nb_segm, int * coord, bool fill);
void trace_1_contour_GERBER(wxPoint pos, wxSize size, wxSize delta, void trace_1_contour_GERBER(wxPoint pos, wxSize size, wxSize delta,
int penwidth, int orient); int penwidth, int orient);
/* Trace 1 contour rectangulaire ou trapezoidal d'orientation quelconque /* Trace 1 contour rectangulaire ou trapezoidal d'orientation quelconque
donne par son centre, ses dimensions, donne par son centre, ses dimensions,
ses variations, l'epaisseur du trait et son orientation orient */ ses variations, l'epaisseur du trait et son orientation orient */
/* PLOTHPGL.CC */ /* PLOTHPGL.CC */
void trace_1_segment_HPGL(int pos_X0,int pos_Y0,int pos_X1,int pos_Y1, void trace_1_segment_HPGL(int pos_X0,int pos_Y0,int pos_X1,int pos_Y1,
int hauteur); int hauteur);
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);
void trace_1_pastille_RONDE_HPGL(wxPoint padpos, int diametre,int modetrace) ; void trace_1_pastille_RONDE_HPGL(wxPoint padpos, int diametre,int modetrace) ;
void trace_1_pastille_OVALE_HPGL(wxPoint padpos, wxSize size, int orient, int modetrace); void trace_1_pastille_OVALE_HPGL(wxPoint padpos, wxSize size, int orient, int modetrace);
...@@ -187,11 +186,11 @@ void PlotRectangularPad_HPGL(wxPoint padpos, wxSize padsize, int orient,int mode ...@@ -187,11 +186,11 @@ void PlotRectangularPad_HPGL(wxPoint padpos, wxSize padsize, int orient,int mode
void trace_1_pastille_OVALE_POST(wxPoint centre, wxSize size, int orient, int modetrace); void trace_1_pastille_OVALE_POST(wxPoint centre, wxSize size, int orient, int modetrace);
void trace_1_pastille_RONDE_POST(wxPoint centre, int diametre, int modetrace); void trace_1_pastille_RONDE_POST(wxPoint centre, int diametre, int modetrace);
void trace_1_pad_rectangulaire_POST(wxPoint centre, wxSize size,int orient, void trace_1_pad_rectangulaire_POST(wxPoint centre, wxSize size,int orient,
int modetrace); int modetrace);
void trace_1_contour_POST(wxPoint centre, wxSize size, wxSize delta, void trace_1_contour_POST(wxPoint centre, wxSize size, wxSize delta,
int dim_trait, int orient); int dim_trait, int orient);
void trace_1_pad_TRAPEZE_POST(wxPoint centre, wxSize size, wxSize delta, void trace_1_pad_TRAPEZE_POST(wxPoint centre, wxSize size, wxSize delta,
int orient,int modetrace); int orient,int modetrace);
#endif /* #define PCBPLOT_H */ #endif /* #define PCBPLOT_H */
......
pcbnew/plot_rtn.cpp
View file @ 2da432b2
...@@ -33,7 +33,6 @@ void WinEDA_BasePcbFrame::Plot_Serigraphie( int format_plot, ...@@ -33,7 +33,6 @@ void WinEDA_BasePcbFrame::Plot_Serigraphie( int format_plot,
wxPoint pos, shape_pos; wxPoint pos, shape_pos;
wxSize size; wxSize size;
bool trace_val, trace_ref; bool trace_val, trace_ref;
MODULE* Module;
D_PAD* pt_pad; D_PAD* pt_pad;
TEXTE_MODULE* pt_texte; TEXTE_MODULE* pt_texte;
EDA_BaseStruct* PtStruct; EDA_BaseStruct* PtStruct;
...@@ -87,8 +86,8 @@ void WinEDA_BasePcbFrame::Plot_Serigraphie( int format_plot, ...@@ -87,8 +86,8 @@ void WinEDA_BasePcbFrame::Plot_Serigraphie( int format_plot,
{ {
nb_items = 0; nb_items = 0;
Affiche_1_Parametre( this, 56, wxT( "Pads" ), wxEmptyString, GREEN ); Affiche_1_Parametre( this, 56, wxT( "Pads" ), wxEmptyString, GREEN );
Module = m_Pcb->m_Modules;
for( ; Module != NULL; Module = (MODULE*) Module->Pnext ) for( MODULE* Module = m_Pcb->m_Modules; Module; Module = Module->Next() )
{ {
pt_pad = (D_PAD*) Module->m_Pads; pt_pad = (D_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 )
...@@ -121,7 +120,6 @@ void WinEDA_BasePcbFrame::Plot_Serigraphie( int format_plot, ...@@ -121,7 +120,6 @@ void WinEDA_BasePcbFrame::Plot_Serigraphie( int format_plot,
trace_1_pastille_RONDE_POST( pos, size.x, FILAIRE ); trace_1_pastille_RONDE_POST( pos, size.x, FILAIRE );
break; break;
} }
break; break;
case PAD_OVAL: case PAD_OVAL:
...@@ -144,7 +142,6 @@ void WinEDA_BasePcbFrame::Plot_Serigraphie( int format_plot, ...@@ -144,7 +142,6 @@ void WinEDA_BasePcbFrame::Plot_Serigraphie( int format_plot,
pt_pad->m_Orient, FILAIRE ); pt_pad->m_Orient, FILAIRE );
break; break;
} }
break; break;
case PAD_TRAPEZOID: case PAD_TRAPEZOID:
...@@ -172,7 +169,6 @@ void WinEDA_BasePcbFrame::Plot_Serigraphie( int format_plot, ...@@ -172,7 +169,6 @@ void WinEDA_BasePcbFrame::Plot_Serigraphie( int format_plot,
FILAIRE ); FILAIRE );
break; break;
} }
break; break;
} }
...@@ -196,7 +192,6 @@ void WinEDA_BasePcbFrame::Plot_Serigraphie( int format_plot, ...@@ -196,7 +192,6 @@ void WinEDA_BasePcbFrame::Plot_Serigraphie( int format_plot,
(int) pt_pad->m_Orient, FILAIRE ); (int) pt_pad->m_Orient, FILAIRE );
break; break;
} }
break; break;
} }
...@@ -209,8 +204,7 @@ void WinEDA_BasePcbFrame::Plot_Serigraphie( int format_plot, ...@@ -209,8 +204,7 @@ void WinEDA_BasePcbFrame::Plot_Serigraphie( int format_plot,
/* Trace Textes MODULES */ /* Trace Textes MODULES */
nb_items = 0; Affiche_1_Parametre( this, 64, wxT( "TxtMod" ), wxEmptyString, LIGHTBLUE ); nb_items = 0; Affiche_1_Parametre( this, 64, wxT( "TxtMod" ), wxEmptyString, LIGHTBLUE );
Module = m_Pcb->m_Modules; for( MODULE* Module = m_Pcb->m_Modules; Module; Module = Module->Next() )
for( ; Module != NULL; Module = (MODULE*) Module->Pnext )
{ {
/* Analyse des autorisations de trace pour les textes VALEUR et REF */ /* Analyse des autorisations de trace pour les textes VALEUR et REF */
trace_val = Sel_Texte_Valeur; trace_val = Sel_Texte_Valeur;
...@@ -831,7 +825,7 @@ void PlotArc( int format_plot, wxPoint centre, int start_angle, int end_angle, ...@@ -831,7 +825,7 @@ void PlotArc( int format_plot, wxPoint centre, int start_angle, int end_angle,
if( Plot_Mode == FILAIRE ) if( Plot_Mode == FILAIRE )
epaisseur = g_PlotLine_Width; epaisseur = g_PlotLine_Width;
if( format_plot == PLOT_FORMAT_POST ) if( IsPostScript( format_plot ) )
{ {
PlotArcPS( centre, start_angle, end_angle, rayon, epaisseur ); PlotArcPS( centre, start_angle, end_angle, rayon, epaisseur );
return; return;
......
pcbnew/plotgerb.cpp
View file @ 2da432b2
...@@ -15,343 +15,348 @@ ...@@ -15,343 +15,348 @@
/* Variables locales : */ /* Variables locales : */
static int s_Last_D_code; static int s_Last_D_code;
static float Gerb_scale_plot; // Coeff de conversion d'unites des traces static float Gerb_scale_plot; // Coeff de conversion d'unites des traces
static int scale_spot_mini; // Ouverture mini (pour remplissages) static int scale_spot_mini; // Ouverture mini (pour remplissages)
static D_CODE * s_DCodeList; // Pointeur sur la zone de stockage des D_CODES static D_CODE* s_DCodeList; // Pointeur sur la zone de stockage des D_CODES
wxString GerberFullFileName; wxString GerberFullFileName;
static double scale_x, scale_y; // echelles de convertion en X et Y (compte tenu static double scale_x, scale_y; // echelles de convertion en X et Y (compte tenu
// des unites relatives du PCB et des traceurs // des unites relatives du PCB et des traceurs
static bool ShowDcodeError = TRUE; static bool ShowDcodeError = TRUE;
/* Routines Locales */ /* Routines Locales */
static void Init_Trace_GERBER(WinEDA_BasePcbFrame * frame, FILE * gerbfile); static void Init_Trace_GERBER( WinEDA_BasePcbFrame* frame, FILE* gerbfile );
static void Init_ApertureList(); static void Init_ApertureList();
static void Fin_Trace_GERBER(WinEDA_BasePcbFrame * frame, FILE * gerbfile); static void Fin_Trace_GERBER( WinEDA_BasePcbFrame* frame, FILE* gerbfile );
static void Plot_1_CIRCLE_pad_GERBER(wxPoint pos, int diametre); static void Plot_1_CIRCLE_pad_GERBER( wxPoint pos, int diametre );
static void trace_1_pastille_OVALE_GERBER(wxPoint pos, wxSize size, int orient); static void trace_1_pastille_OVALE_GERBER( wxPoint pos, wxSize size, int orient );
static void PlotRectangularPad_GERBER(wxPoint pos, wxSize size, int orient); static void PlotRectangularPad_GERBER( wxPoint pos, wxSize size, int orient );
static D_CODE * get_D_code(int dx, int dy, int type, int drill); static D_CODE* get_D_code( int dx, int dy, int type, int drill );
static void trace_1_pad_TRAPEZE_GERBER(wxPoint pos, wxSize size, wxSize delta, static void trace_1_pad_TRAPEZE_GERBER( wxPoint pos, wxSize size, wxSize delta,
int orient, int modetrace); int orient, int modetrace );
/********************************************************************************/ /********************************************************************************/
void WinEDA_BasePcbFrame::Genere_GERBER(const wxString & FullFileName, int Layer, void WinEDA_BasePcbFrame::Genere_GERBER( const wxString& FullFileName, int Layer,
bool PlotOriginIsAuxAxis) bool PlotOriginIsAuxAxis )
/********************************************************************************/ /********************************************************************************/
/* Genere les divers fichiers de trace: /* Genere les divers fichiers de trace:
* Pour chaque couche 1 fichier xxxc.PHO au format RS274X * Pour chaque couche 1 fichier xxxc.PHO au format RS274X
*/ */
{ {
int tracevia = 1; int tracevia = 1;
EraseMsgBox(); EraseMsgBox();
GerberFullFileName = FullFileName; GerberFullFileName = FullFileName;
g_PlotOrient = 0; g_PlotOrient = 0;
if( Plot_Set_MIROIR ) if( Plot_Set_MIROIR )
g_PlotOrient |= PLOT_MIROIR; g_PlotOrient |= PLOT_MIROIR;
/* Calcul des echelles de conversion */ /* Calcul des echelles de conversion */
Gerb_scale_plot = 1.0; /* pour unites gerber en 0,1 Mils, format 3.4 */ Gerb_scale_plot = 1.0; /* pour unites gerber en 0,1 Mils, format 3.4 */
scale_spot_mini = (int)(10 * spot_mini * Gerb_scale_plot); scale_spot_mini = (int) (10 * spot_mini * Gerb_scale_plot);
scale_x = Scale_X * Gerb_scale_plot; scale_x = Scale_X * Gerb_scale_plot;
scale_y = Scale_Y * Gerb_scale_plot; scale_y = Scale_Y * Gerb_scale_plot;
g_PlotOffset.x = 0; g_PlotOffset.x = 0;
g_PlotOffset.y = 0; g_PlotOffset.y = 0;
if( PlotOriginIsAuxAxis ) if( PlotOriginIsAuxAxis )
g_PlotOffset = m_Auxiliary_Axis_Position; g_PlotOffset = m_Auxiliary_Axis_Position;
dest = wxFopen( FullFileName, wxT("wt") ); dest = wxFopen( FullFileName, wxT( "wt" ) );
if( dest == NULL ) if( dest == NULL )
{ {
wxString msg = _("unable to create file ") + FullFileName; wxString msg = _( "unable to create file " ) + FullFileName;
DisplayError(this, msg); DisplayError( this, msg );
return; return;
} }
setlocale(LC_NUMERIC, "C"); setlocale( LC_NUMERIC, "C" );
InitPlotParametresGERBER(g_PlotOffset, scale_x, scale_y); InitPlotParametresGERBER( g_PlotOffset, scale_x, scale_y );
/* Clear the memory used for handle the D_CODE (aperture) list */ /* Clear the memory used for handle the D_CODE (aperture) list */
Init_ApertureList(); Init_ApertureList();
Affiche_1_Parametre(this, 0, _("File"), FullFileName, CYAN); Affiche_1_Parametre( this, 0, _( "File" ), FullFileName, CYAN );
Init_Trace_GERBER(this, dest); Init_Trace_GERBER( this, dest );
nb_plot_erreur = 0; nb_plot_erreur = 0;
int layer_mask = g_TabOneLayerMask[Layer]; int layer_mask = g_TabOneLayerMask[Layer];
// Specify that the contents of the "Edges Pcb" layer are also to be
// plotted, unless the option of excluding that layer has been selected. // Specify that the contents of the "Edges Pcb" layer are also to be
if( ! g_Exclude_Edges_Pcb ) // plotted, unless the option of excluding that layer has been selected.
layer_mask |= EDGE_LAYER; if( !g_Exclude_Edges_Pcb )
layer_mask |= EDGE_LAYER;
switch( Layer )
{ switch( Layer )
case FIRST_COPPER_LAYER: {
case LAYER_N_2: case FIRST_COPPER_LAYER:
case LAYER_N_3: case LAYER_N_2:
case LAYER_N_4: case LAYER_N_3:
case LAYER_N_5: case LAYER_N_4:
case LAYER_N_6: case LAYER_N_5:
case LAYER_N_7: case LAYER_N_6:
case LAYER_N_8: case LAYER_N_7:
case LAYER_N_9: case LAYER_N_8:
case LAYER_N_10: case LAYER_N_9:
case LAYER_N_11: case LAYER_N_10:
case LAYER_N_12: case LAYER_N_11:
case LAYER_N_13: case LAYER_N_12:
case LAYER_N_14: case LAYER_N_13:
case LAYER_N_15: case LAYER_N_14:
case LAST_COPPER_LAYER: case LAYER_N_15:
Plot_Layer_GERBER(dest, layer_mask, 0, 1); case LAST_COPPER_LAYER:
break; Plot_Layer_GERBER( dest, layer_mask, 0, 1 );
break;
case SOLDERMASK_N_CU:
case SOLDERMASK_N_CMP: /* Trace du vernis epargne */ case SOLDERMASK_N_CU:
if( g_DrawViaOnMaskLayer ) case SOLDERMASK_N_CMP: /* Trace du vernis epargne */
tracevia = 1; if( g_DrawViaOnMaskLayer )
else tracevia = 1;
tracevia = 0; else
Plot_Layer_GERBER(dest, layer_mask, g_DesignSettings.m_MaskMargin, tracevia); tracevia = 0;
break; Plot_Layer_GERBER( dest, layer_mask, g_DesignSettings.m_MaskMargin, tracevia );
break;
case SOLDERPASTE_N_CU:
case SOLDERPASTE_N_CMP: /* Trace du masque de pate de soudure */ case SOLDERPASTE_N_CU:
Plot_Layer_GERBER(dest, layer_mask, 0, 0); case SOLDERPASTE_N_CMP: /* Trace du masque de pate de soudure */
break; Plot_Layer_GERBER( dest, layer_mask, 0, 0 );
break;
default:
Plot_Serigraphie(PLOT_FORMAT_GERBER, dest, layer_mask); default:
break; Plot_Serigraphie( PLOT_FORMAT_GERBER, dest, layer_mask );
} break;
}
Fin_Trace_GERBER( this, dest );
setlocale( LC_NUMERIC, "" ); Fin_Trace_GERBER( this, dest );
setlocale( LC_NUMERIC, "" );
} }
/***********************************************************************/ /***********************************************************************/
void WinEDA_BasePcbFrame::Plot_Layer_GERBER(FILE * File,int masque_layer, void WinEDA_BasePcbFrame::Plot_Layer_GERBER( FILE* File, int masque_layer,
int garde, int tracevia) int garde, int tracevia )
/***********************************************************************/ /***********************************************************************/
/* Trace en format GERBER. d'une couche cuivre ou masque /* Trace en format GERBER. d'une couche cuivre ou masque
*/ */
{ {
wxPoint pos; wxPoint pos;
wxSize size; wxSize size;
MODULE * Module; MODULE* Module;
D_PAD * PtPad; D_PAD* PtPad;
TRACK * track ; TRACK* track;
EDA_BaseStruct * PtStruct; EDA_BaseStruct* PtStruct;
wxString msg; wxString msg;
// (Following command has been superceded by new command on lines 93 and 94.) // (Following command has been superceded by new command on lines 93 and 94.)
// 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->Pnext )
{ {
switch( PtStruct->Type() ) switch( PtStruct->Type() )
{ {
case TYPEDRAWSEGMENT: case TYPEDRAWSEGMENT:
PlotDrawSegment( (DRAWSEGMENT*) PtStruct, PLOT_FORMAT_GERBER, PlotDrawSegment( (DRAWSEGMENT*) PtStruct, PLOT_FORMAT_GERBER,
masque_layer ); masque_layer );
break; break;
case TYPETEXTE: case TYPETEXTE:
PlotTextePcb( (TEXTE_PCB*) PtStruct, PLOT_FORMAT_GERBER, PlotTextePcb( (TEXTE_PCB*) PtStruct, PLOT_FORMAT_GERBER,
masque_layer ); masque_layer );
break; break;
case TYPECOTATION: case TYPECOTATION:
PlotCotation( (COTATION*) PtStruct, PLOT_FORMAT_GERBER, PlotCotation( (COTATION*) PtStruct, PLOT_FORMAT_GERBER,
masque_layer ); masque_layer );
break; break;
case TYPEMIRE: case TYPEMIRE:
PlotMirePcb( (MIREPCB*) PtStruct, PLOT_FORMAT_GERBER, PlotMirePcb( (MIREPCB*) PtStruct, PLOT_FORMAT_GERBER,
masque_layer ); masque_layer );
break; break;
case TYPEMARKER: case TYPEMARKER:
break; break;
default: default:
DisplayError( this, wxT("Type Draw non gere") ); DisplayError( this, wxT( "Type Draw non gere" ) );
break; break;
} }
} }
/* 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, 38, wxT("DrawMod"), wxEmptyString, GREEN); Affiche_1_Parametre( this, 38, wxT( "DrawMod" ), wxEmptyString, GREEN );
Module = m_Pcb->m_Modules; Module = m_Pcb->m_Modules;
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->Pnext )
{ {
switch( PtStruct->Type() ) switch( PtStruct->Type() )
{ {
case TYPEEDGEMODULE: case TYPEEDGEMODULE:
if( masque_layer & g_TabOneLayerMask[((EDGE_MODULE*)PtStruct)->GetLayer()] ) 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;
default: default:
break; break;
} }
} }
} }
/* Trace des Elements des modules : Pastilles */ /* Trace des Elements des modules : Pastilles */
nb_items = 0; nb_items = 0;
Affiche_1_Parametre(this, 48, wxT("Pads"), wxEmptyString, GREEN); Affiche_1_Parametre( this, 48, wxT( "Pads" ), wxEmptyString, GREEN );
Module = m_Pcb->m_Modules; Module = m_Pcb->m_Modules;
for( ; Module != NULL; Module = (MODULE *)Module->Pnext ) for( ; Module != NULL; Module = (MODULE*) Module->Pnext )
{ {
PtPad = (D_PAD*) Module->m_Pads; PtPad = (D_PAD*) Module->m_Pads;
for( ; PtPad != NULL; PtPad = (D_PAD*)PtPad->Pnext ) for( ; PtPad != NULL; PtPad = (D_PAD*) PtPad->Pnext )
{ {
wxPoint shape_pos; wxPoint shape_pos;
if( (PtPad->m_Masque_Layer & masque_layer) == 0 ) if( (PtPad->m_Masque_Layer & masque_layer) == 0 )
continue;
shape_pos = PtPad->ReturnShapePos();
pos = shape_pos;
size.x = PtPad->m_Size.x + 2 * garde;
size.y = PtPad->m_Size.y + 2 * garde;
/* Don't draw a null size item : */
if( size.x <= 0 || size.y <= 0 )
continue;
nb_items++;
switch( PtPad->m_PadShape )
{
case PAD_CIRCLE:
Plot_1_CIRCLE_pad_GERBER(pos, size.x);
break;
case PAD_OVAL:
// Check whether the pad really has a circular shape instead
if( size.x == size.y )
Plot_1_CIRCLE_pad_GERBER(pos, size.x);
else
trace_1_pastille_OVALE_GERBER(pos, size, PtPad->m_Orient);
break;
case PAD_TRAPEZOID:
{
wxSize delta = PtPad->m_DeltaSize;
trace_1_pad_TRAPEZE_GERBER(pos, size,
delta, PtPad->m_Orient, FILLED);
}
break;
case PAD_RECT:
default:
PlotRectangularPad_GERBER(pos, size, PtPad->m_Orient);
break;
}
msg.Printf( wxT("%d"), nb_items );
Affiche_1_Parametre(this, 48, wxEmptyString, msg, GREEN);
}
}
/* trace des VIAS : */
if( tracevia )
{
nb_items = 0;
Affiche_1_Parametre(this, 56, wxT("Vias"), wxEmptyString, RED);
for( track = m_Pcb->m_Track; track != NULL; track = (TRACK*) track->Pnext )
{
if( track->Type() != TYPEVIA )
continue;
SEGVIA * Via = (SEGVIA *) track;
// vias not plotted if not on selected layer, but if layer
// == SOLDERMASK_LAYER_CU or SOLDERMASK_LAYER_CMP, vias are drawn,
// if they are on a external copper layer
int via_mask_layer = Via->ReturnMaskLayer();
if( via_mask_layer & CUIVRE_LAYER )
via_mask_layer |= SOLDERMASK_LAYER_CU;
if( via_mask_layer & CMP_LAYER )
via_mask_layer |= SOLDERMASK_LAYER_CMP;
if( ( via_mask_layer & masque_layer) == 0 )
continue;
pos = Via->m_Start;
size.x = size.y = Via->m_Width + 2 * garde;
/* Don't draw a null size item : */
if( size.x <= 0 )
continue; continue;
Plot_1_CIRCLE_pad_GERBER(pos, size.x); shape_pos = PtPad->ReturnShapePos();
nb_items++; pos = shape_pos;
msg.Printf( wxT("%d"), nb_items );
Affiche_1_Parametre(this, 56, wxEmptyString, msg, RED); size.x = PtPad->m_Size.x + 2 * garde;
} size.y = PtPad->m_Size.y + 2 * garde;
}
/* trace des pistes : */ /* Don't draw a null size item : */
nb_items = 0; if( size.x <= 0 || size.y <= 0 )
Affiche_1_Parametre(this, 64, wxT("Tracks"), wxEmptyString, YELLOW); continue;
for( track = m_Pcb->m_Track; track != NULL; track = (TRACK*) track->Pnext ) nb_items++;
{
wxPoint end; switch( PtPad->m_PadShape )
{
if( track->Type() == TYPEVIA ) case PAD_CIRCLE:
continue; Plot_1_CIRCLE_pad_GERBER( pos, size.x );
if( (g_TabOneLayerMask[track->GetLayer()] & masque_layer) == 0 ) break;
continue;
case PAD_OVAL:
size.x = size.y = track->m_Width;
pos = track->m_Start; // Check whether the pad really has a circular shape instead
end = track->m_End; if( size.x == size.y )
Plot_1_CIRCLE_pad_GERBER( pos, size.x );
PlotGERBERLine(pos, end, size.x); else
trace_1_pastille_OVALE_GERBER( pos, size, PtPad->m_Orient );
nb_items++; break;
msg.Printf( wxT("%d"), nb_items );
Affiche_1_Parametre(this, 64, wxEmptyString, msg, YELLOW); case PAD_TRAPEZOID:
} {
wxSize delta = PtPad->m_DeltaSize;
/* trace des zones: */ trace_1_pad_TRAPEZE_GERBER( pos, size,
nb_items = 0; delta, PtPad->m_Orient, FILLED );
if( m_Pcb->m_Zone ) }
Affiche_1_Parametre(this, 72, wxT("Zones "), wxEmptyString, YELLOW); break;
for( track = m_Pcb->m_Zone; track != NULL; track = (TRACK*) track->Pnext ) case PAD_RECT:
{ default:
wxPoint end; PlotRectangularPad_GERBER( pos, size, PtPad->m_Orient );
break;
if( (g_TabOneLayerMask[track->GetLayer()] & masque_layer) == 0 ) }
continue;
msg.Printf( wxT( "%d" ), nb_items );
size.x = size.y = track->m_Width; Affiche_1_Parametre( this, 48, wxEmptyString, msg, GREEN );
pos = track->m_Start; }
end = track->m_End; }
PlotGERBERLine(pos, end, size.x); /* trace des VIAS : */
if( tracevia )
nb_items++; {
msg.Printf( wxT("%d"), nb_items ); nb_items = 0;
Affiche_1_Parametre(this, 72, wxEmptyString, msg, YELLOW); Affiche_1_Parametre( this, 56, wxT( "Vias" ), wxEmptyString, RED );
} for( track = m_Pcb->m_Track; track != NULL; track = (TRACK*) track->Pnext )
{
if( track->Type() != TYPEVIA )
continue;
SEGVIA* Via = (SEGVIA*) track;
// vias not plotted if not on selected layer, but if layer
// == SOLDERMASK_LAYER_CU or SOLDERMASK_LAYER_CMP, vias are drawn,
// if they are on a external copper layer
int via_mask_layer = Via->ReturnMaskLayer();
if( via_mask_layer & CUIVRE_LAYER )
via_mask_layer |= SOLDERMASK_LAYER_CU;
if( via_mask_layer & CMP_LAYER )
via_mask_layer |= SOLDERMASK_LAYER_CMP;
if( ( via_mask_layer & masque_layer) == 0 )
continue;
pos = Via->m_Start;
size.x = size.y = Via->m_Width + 2 * garde;
/* Don't draw a null size item : */
if( size.x <= 0 )
continue;
Plot_1_CIRCLE_pad_GERBER( pos, size.x );
nb_items++;
msg.Printf( wxT( "%d" ), nb_items );
Affiche_1_Parametre( this, 56, wxEmptyString, msg, RED );
}
}
/* trace des pistes : */
nb_items = 0;
Affiche_1_Parametre( this, 64, wxT( "Tracks" ), wxEmptyString, YELLOW );
for( track = m_Pcb->m_Track; track != NULL; track = (TRACK*) track->Pnext )
{
wxPoint end;
if( track->Type() == TYPEVIA )
continue;
if( (g_TabOneLayerMask[track->GetLayer()] & masque_layer) == 0 )
continue;
size.x = size.y = track->m_Width;
pos = track->m_Start;
end = track->m_End;
PlotGERBERLine( pos, end, size.x );
nb_items++;
msg.Printf( wxT( "%d" ), nb_items );
Affiche_1_Parametre( this, 64, wxEmptyString, msg, YELLOW );
}
/* trace des zones: */
nb_items = 0;
if( m_Pcb->m_Zone )
Affiche_1_Parametre( this, 72, wxT( "Zones " ), wxEmptyString, YELLOW );
for( track = m_Pcb->m_Zone; track != NULL; track = (TRACK*) track->Pnext )
{
wxPoint end;
if( (g_TabOneLayerMask[track->GetLayer()] & masque_layer) == 0 )
continue;
size.x = size.y = track->m_Width;
pos = track->m_Start;
end = track->m_End;
PlotGERBERLine( pos, end, size.x );
nb_items++;
msg.Printf( wxT( "%d" ), nb_items );
Affiche_1_Parametre( this, 72, wxEmptyString, msg, YELLOW );
}
} }
/**********************************************************************/ /**********************************************************************/
void trace_1_pastille_OVALE_GERBER(wxPoint pos, wxSize size, int orient) void trace_1_pastille_OVALE_GERBER( wxPoint pos, wxSize size, int orient )
/**********************************************************************/ /**********************************************************************/
/* Trace 1 pastille PAD_OVAL en position pos_X,Y: /* Trace 1 pastille PAD_OVAL en position pos_X,Y:
...@@ -361,81 +366,81 @@ void trace_1_pastille_OVALE_GERBER(wxPoint pos, wxSize size, int orient) ...@@ -361,81 +366,81 @@ void trace_1_pastille_OVALE_GERBER(wxPoint pos, wxSize size, int orient)
* Pour une orientation quelconque la forme est tracee comme un segment * Pour une orientation quelconque la forme est tracee comme un segment
*/ */
{ {
D_CODE * dcode_ptr; D_CODE* dcode_ptr;
int x0, y0, x1, y1, delta; int x0, y0, x1, y1, delta;
if( orient == 900 || orient == 2700 ) /* orient tournee de 90 deg */ if( orient == 900 || orient == 2700 ) /* orient tournee de 90 deg */
EXCHG(size.x, size.y); EXCHG( size.x, size.y );
/* Trace de la forme flashee */ /* Trace de la forme flashee */
if( orient == 0 || orient == 900 || orient == 1800 || orient == 2700 ) if( orient == 0 || orient == 900 || orient == 1800 || orient == 2700 )
{ {
UserToDeviceCoordinate(pos); UserToDeviceCoordinate( pos );
UserToDeviceSize(size); UserToDeviceSize( size );
dcode_ptr = get_D_code(size.x, size.y, GERB_OVALE, 0); dcode_ptr = get_D_code( size.x, size.y, GERB_OVALE, 0 );
if( dcode_ptr->m_NumDcode != s_Last_D_code ) if( dcode_ptr->m_NumDcode != s_Last_D_code )
{ {
sprintf(cbuf, "G54D%d*\n", dcode_ptr->m_NumDcode); sprintf( cbuf, "G54D%d*\n", dcode_ptr->m_NumDcode );
fputs(cbuf, dest); fputs( cbuf, dest );
s_Last_D_code = dcode_ptr->m_NumDcode; s_Last_D_code = dcode_ptr->m_NumDcode;
} }
sprintf(cbuf, "X%5.5dY%5.5dD03*\n", pos.x, pos.y); sprintf( cbuf, "X%5.5dY%5.5dD03*\n", pos.x, pos.y );
fputs(cbuf, dest); fputs( cbuf, dest );
} }
else /* Forme tracee comme un segment */
else /* Forme tracee comme un segment */ {
{ if( size.x > size.y )
if( size.x > size.y ) {
{ EXCHG( size.x, size.y );
EXCHG(size.x, size.y); if( orient < 2700 )
if( orient < 2700 ) orient += 900;
orient += 900; else
else orient -= 2700;
orient -= 2700; }
} /* la pastille est ramenee a une pastille ovale avec dy > dx */
/* la pastille est ramenee a une pastille ovale avec dy > dx */ delta = size.y - size.x;
delta = size.y - size.x; x0 = 0;
x0 = 0; y0 = -delta / 2;
y0 = -delta / 2; x1 = 0;
x1 = 0; y1 = delta / 2;
y1 = delta / 2; RotatePoint( &x0, &y0, orient );
RotatePoint(&x0, &y0, orient); RotatePoint( &x1, &y1, orient );
RotatePoint(&x1, &y1, orient); PlotGERBERLine( wxPoint( pos.x + x0, pos.y + y0 ),
PlotGERBERLine( wxPoint(pos.x + x0, pos.y + y0), wxPoint( pos.x + x1, pos.y + y1 ), size.x );
wxPoint(pos.x + x1, pos.y + y1), size.x ); }
}
} }
/******************************************************************/ /******************************************************************/
void Plot_1_CIRCLE_pad_GERBER(wxPoint pos,int diametre) void Plot_1_CIRCLE_pad_GERBER( wxPoint pos, int diametre )
/******************************************************************/ /******************************************************************/
/* Plot a circular pad or via at the user position pos /* Plot a circular pad or via at the user position pos
*/ */
{ {
D_CODE * dcode_ptr; D_CODE* dcode_ptr;
wxSize size(diametre, diametre);
wxSize size( diametre, diametre );
UserToDeviceCoordinate(pos);
UserToDeviceSize(size); UserToDeviceCoordinate( pos );
UserToDeviceSize( size );
dcode_ptr = get_D_code(size.x, size.x, GERB_CIRCLE, 0);
if( dcode_ptr->m_NumDcode != s_Last_D_code ) dcode_ptr = get_D_code( size.x, size.x, GERB_CIRCLE, 0 );
{ if( dcode_ptr->m_NumDcode != s_Last_D_code )
sprintf(cbuf, "G54D%d*\n", dcode_ptr->m_NumDcode); {
fputs(cbuf, dest); sprintf( cbuf, "G54D%d*\n", dcode_ptr->m_NumDcode );
s_Last_D_code = dcode_ptr->m_NumDcode; fputs( cbuf, dest );
} s_Last_D_code = dcode_ptr->m_NumDcode;
}
sprintf(cbuf, "X%5.5dY%5.5dD03*\n", pos.x, pos.y);
fputs(cbuf, dest); sprintf( cbuf, "X%5.5dY%5.5dD03*\n", pos.x, pos.y );
fputs( cbuf, dest );
} }
/**************************************************************************/ /**************************************************************************/
void PlotRectangularPad_GERBER(wxPoint pos, wxSize size, int orient) void PlotRectangularPad_GERBER( wxPoint pos, wxSize size, int orient )
/**************************************************************************/ /**************************************************************************/
/* Trace 1 pad rectangulaire d'orientation quelconque /* Trace 1 pad rectangulaire d'orientation quelconque
...@@ -445,42 +450,43 @@ void PlotRectangularPad_GERBER(wxPoint pos, wxSize size, int orient) ...@@ -445,42 +450,43 @@ void PlotRectangularPad_GERBER(wxPoint pos, wxSize size, int orient)
* de largeur 1/2 largeur pad * de largeur 1/2 largeur pad
*/ */
{ {
D_CODE * dcode_ptr; D_CODE* dcode_ptr;
/* Trace de la forme flashee */ /* Trace de la forme flashee */
switch( orient ) switch( orient )
{ {
case 900: case 900:
case 2700: /* la rotation de 90 ou 270 degres revient a permutter des dimensions */ case 2700: /* la rotation de 90 ou 270 degres revient a permutter des dimensions */
EXCHG(size.x, size.y); EXCHG( size.x, size.y );
// Pass through
// Pass through
case 0:
case 1800: case 0:
UserToDeviceCoordinate(pos); case 1800:
UserToDeviceSize(size); UserToDeviceCoordinate( pos );
UserToDeviceSize( size );
dcode_ptr = get_D_code(size.x, size.y, GERB_RECT, 0);
if( dcode_ptr->m_NumDcode != s_Last_D_code ) dcode_ptr = get_D_code( size.x, size.y, GERB_RECT, 0 );
{ if( dcode_ptr->m_NumDcode != s_Last_D_code )
sprintf(cbuf, "G54D%d*\n", dcode_ptr->m_NumDcode); {
fputs(cbuf, dest); sprintf( cbuf, "G54D%d*\n", dcode_ptr->m_NumDcode );
s_Last_D_code = dcode_ptr->m_NumDcode; fputs( cbuf, dest );
} s_Last_D_code = dcode_ptr->m_NumDcode;
sprintf(cbuf, "X%5.5dY%5.5dD03*\n", pos.x, pos.y); }
fputs(cbuf, dest); sprintf( cbuf, "X%5.5dY%5.5dD03*\n", pos.x, pos.y );
break; fputs( cbuf, dest );
break;
default: /* Forme tracee par remplissage */
trace_1_pad_TRAPEZE_GERBER(pos, size, wxSize(0, 0), orient, FILLED); default: /* Forme tracee par remplissage */
break; trace_1_pad_TRAPEZE_GERBER( pos, size, wxSize( 0, 0 ), orient, FILLED );
} break;
}
} }
/*****************************************************************/ /*****************************************************************/
void trace_1_contour_GERBER(wxPoint pos, wxSize size, wxSize delta, void trace_1_contour_GERBER( wxPoint pos, wxSize size, wxSize delta,
int penwidth, int orient) int penwidth, int orient )
/*****************************************************************/ /*****************************************************************/
/* Trace 1 contour rectangulaire ou trapezoidal d'orientation quelconque /* Trace 1 contour rectangulaire ou trapezoidal d'orientation quelconque
...@@ -491,41 +497,41 @@ void trace_1_contour_GERBER(wxPoint pos, wxSize size, wxSize delta, ...@@ -491,41 +497,41 @@ void trace_1_contour_GERBER(wxPoint pos, wxSize size, wxSize delta,
* et son orientation orient * et son orientation orient
*/ */
{ {
int ii; int ii;
wxPoint coord[4]; wxPoint coord[4];
size.x /= 2; size.x /= 2;
size.y /= 2; size.y /= 2;
delta.x /= 2; delta.x /= 2;
delta.y /= 2; /* demi dim dx et dy */ delta.y /= 2; /* demi dim dx et dy */
coord[0].x = pos.x - size.x - delta.y; coord[0].x = pos.x - size.x - delta.y;
coord[0].y = pos.y + size.y + delta.x; coord[0].y = pos.y + size.y + delta.x;
coord[1].x = pos.x - size.x + delta.y; coord[1].x = pos.x - size.x + delta.y;
coord[1].y = pos.y - size.y - delta.x; coord[1].y = pos.y - size.y - delta.x;
coord[2].x = pos.x + size.x - delta.y; coord[2].x = pos.x + size.x - delta.y;
coord[2].y = pos.y - size.y + delta.x; coord[2].y = pos.y - size.y + delta.x;
coord[3].x = pos.x + size.x + delta.y; coord[3].x = pos.x + size.x + delta.y;
coord[3].y = pos.y + size.y - delta.x; coord[3].y = pos.y + size.y - delta.x;
for( ii = 0; ii < 4; ii++ ) for( ii = 0; ii < 4; ii++ )
{ {
RotatePoint(&coord[ii].x, &coord[ii].y, pos.x, pos.y, orient); RotatePoint( &coord[ii].x, &coord[ii].y, pos.x, pos.y, orient );
} }
PlotGERBERLine( coord[0], coord[1], penwidth ); PlotGERBERLine( coord[0], coord[1], penwidth );
PlotGERBERLine( coord[1], coord[2], penwidth ); PlotGERBERLine( coord[1], coord[2], penwidth );
PlotGERBERLine( coord[2], coord[3], penwidth ); PlotGERBERLine( coord[2], coord[3], penwidth );
PlotGERBERLine( coord[3], coord[0], penwidth ); PlotGERBERLine( coord[3], coord[0], penwidth );
} }
/*******************************************************************/ /*******************************************************************/
void trace_1_pad_TRAPEZE_GERBER(wxPoint pos, wxSize size,wxSize delta, void trace_1_pad_TRAPEZE_GERBER( wxPoint pos, wxSize size, wxSize delta,
int orient,int modetrace) int orient, int modetrace )
/*******************************************************************/ /*******************************************************************/
/* Trace 1 pad trapezoidal donne par : /* Trace 1 pad trapezoidal donne par :
...@@ -569,77 +575,76 @@ void trace_1_pad_TRAPEZE_GERBER(wxPoint pos, wxSize size,wxSize delta, ...@@ -569,77 +575,76 @@ void trace_1_pad_TRAPEZE_GERBER(wxPoint pos, wxSize size,wxSize delta,
* " 1 " * " 1 "
*/ */
{ {
int ii, jj; int ii, jj;
int dx, dy; int dx, dy;
wxPoint polygone[4]; /* coord sommets */ wxPoint polygone[4]; /* coord sommets */
int coord[8]; int coord[8];
int ddx, ddy; int ddx, ddy;
/* calcul des dimensions optimales du spot choisi = 1/4 plus petite dim */ /* calcul des dimensions optimales du spot choisi = 1/4 plus petite dim */
dx = size.x - abs(delta.y); dx = size.x - abs( delta.y );
dy = size.y - abs(delta.x); dy = size.y - abs( delta.x );
dx = size.x / 2; dx = size.x / 2;
dy = size.y / 2; dy = size.y / 2;
ddx = delta.x / 2; ddx = delta.x / 2;
ddy = delta.y / 2; ddy = delta.y / 2;
polygone[0].x = - dx - ddy; polygone[0].x = -dx - ddy;
polygone[0].y = + dy + ddx; polygone[0].y = +dy + ddx;
polygone[1].x = - dx + ddy; polygone[1].x = -dx + ddy;
polygone[1].y = - dy - ddx; polygone[1].y = -dy - ddx;
polygone[2].x = + dx - ddy; polygone[2].x = +dx - ddy;
polygone[2].y = - dy + ddx; polygone[2].y = -dy + ddx;
polygone[3].x = + dx + ddy; polygone[3].x = +dx + ddy;
polygone[3].y = + dy - ddx; polygone[3].y = +dy - ddx;
/* Dessin du polygone et Remplissage eventuel de l'interieur */ /* Dessin du polygone et Remplissage eventuel de l'interieur */
for( ii = 0, jj = 0; ii < 4; ii++ ) for( ii = 0, jj = 0; ii < 4; ii++ )
{ {
RotatePoint(&polygone[ii].x, &polygone[ii].y, orient); RotatePoint( &polygone[ii].x, &polygone[ii].y, orient );
coord[jj] = polygone[ii].x += pos.x; coord[jj] = polygone[ii].x += pos.x;
jj++; jj++;
coord[jj] = polygone[ii].y += pos.y; coord[jj] = polygone[ii].y += pos.y;
jj++; jj++;
} }
if( modetrace != FILLED ) if( modetrace != FILLED )
{ {
PlotGERBERLine( polygone[0], polygone[1], scale_spot_mini ); PlotGERBERLine( polygone[0], polygone[1], scale_spot_mini );
PlotGERBERLine( polygone[1], polygone[2], scale_spot_mini ); PlotGERBERLine( polygone[1], polygone[2], scale_spot_mini );
PlotGERBERLine( polygone[2], polygone[3], scale_spot_mini ); PlotGERBERLine( polygone[2], polygone[3], scale_spot_mini );
PlotGERBERLine( polygone[3], polygone[0], scale_spot_mini ); PlotGERBERLine( polygone[3], polygone[0], scale_spot_mini );
} }
else
else PlotPolygon_GERBER( 4, coord, TRUE );
PlotPolygon_GERBER(4, coord, TRUE);
} }
/**********************************************************/ /**********************************************************/
void PlotGERBERLine(wxPoint start, wxPoint end, int large) void PlotGERBERLine( wxPoint start, wxPoint end, int large )
/**********************************************************/ /**********************************************************/
/* Trace 1 segment de piste : /* Trace 1 segment de piste :
*/ */
{ {
D_CODE * dcode_ptr; D_CODE* dcode_ptr;
UserToDeviceCoordinate(start); UserToDeviceCoordinate( start );
UserToDeviceCoordinate(end); UserToDeviceCoordinate( end );
dcode_ptr = get_D_code(large, large, GERB_LINE, 0); dcode_ptr = get_D_code( large, large, GERB_LINE, 0 );
if(dcode_ptr->m_NumDcode != s_Last_D_code ) if( dcode_ptr->m_NumDcode != s_Last_D_code )
{ {
sprintf(cbuf, "G54D%d*\n", dcode_ptr->m_NumDcode); sprintf( cbuf, "G54D%d*\n", dcode_ptr->m_NumDcode );
fputs(cbuf, dest); fputs( cbuf, dest );
s_Last_D_code = dcode_ptr->m_NumDcode; s_Last_D_code = dcode_ptr->m_NumDcode;
} }
sprintf(cbuf, "X%5.5dY%5.5dD02*\n", start.x, start.y); sprintf( cbuf, "X%5.5dY%5.5dD02*\n", start.x, start.y );
fputs(cbuf, dest); fputs( cbuf, dest );
sprintf(cbuf, "X%5.5dY%5.5dD01*\n", end.x, end.y); sprintf( cbuf, "X%5.5dY%5.5dD01*\n", end.x, end.y );
fputs(cbuf, dest); fputs( cbuf, dest );
} }
...@@ -650,131 +655,132 @@ void PlotCircle_GERBER( wxPoint centre, int rayon, int epaisseur ) ...@@ -650,131 +655,132 @@ void PlotCircle_GERBER( wxPoint centre, int rayon, int epaisseur )
/* routine de trace de 1 cercle de centre centre par approximation de segments /* routine de trace de 1 cercle de centre centre par approximation de segments
*/ */
{ {
int ii; int ii;
int ox, oy, fx, fy; int ox, oy, fx, fy;
int delta; /* increment (en 0.1 degres) angulaire pour trace de cercles */ int delta; /* increment (en 0.1 degres) angulaire pour trace de cercles */
delta = 120; /* un cercle sera trace en 3600/delta segments */ delta = 120; /* un cercle sera trace en 3600/delta segments */
/* Correction pour petits cercles par rapport a l'epaisseur du trait */ /* Correction pour petits cercles par rapport a l'epaisseur du trait */
if( rayon < (epaisseur * 10) ) if( rayon < (epaisseur * 10) )
delta = 225; /* 16 segm pour 360 deg */ delta = 225; /* 16 segm pour 360 deg */
if( rayon < (epaisseur * 5) ) if( rayon < (epaisseur * 5) )
delta = 300; /* 12 segm pour 360 deg */ delta = 300; /* 12 segm pour 360 deg */
if( rayon < (epaisseur * 2) ) if( rayon < (epaisseur * 2) )
delta = 600; /* 6 segm pour 360 deg */ delta = 600; /* 6 segm pour 360 deg */
ox = centre.x + rayon; ox = centre.x + rayon;
oy = centre.y; oy = centre.y;
for( ii = delta; ii < 3600; ii += delta ) for( ii = delta; ii < 3600; ii += delta )
{ {
fx = centre.x + (int)(rayon * fcosinus[ii]); fx = centre.x + (int) (rayon * fcosinus[ii]);
fy = centre.y + (int)(rayon * fsinus[ii]); fy = centre.y + (int) (rayon * fsinus[ii]);
PlotGERBERLine(wxPoint(ox, oy), wxPoint(fx, fy), epaisseur); PlotGERBERLine( wxPoint( ox, oy ), wxPoint( fx, fy ), epaisseur );
ox = fx; ox = fx;
oy = fy; oy = fy;
} }
fx = centre.x + rayon; fx = centre.x + rayon;
fy = centre.y; fy = centre.y;
PlotGERBERLine(wxPoint(ox ,oy), wxPoint(fx, fy), epaisseur); PlotGERBERLine( wxPoint( ox, oy ), wxPoint( fx, fy ), epaisseur );
} }
/***************************************************************/ /***************************************************************/
void PlotPolygon_GERBER(int nb_segm, int * coord, bool fill) void PlotPolygon_GERBER( int nb_segm, int* coord, bool fill )
/***************************************************************/ /***************************************************************/
{ {
int ii; int ii;
wxPoint pos; wxPoint pos;
fputs("G36*\n", dest); fputs( "G36*\n", dest );
pos.x = *coord; pos.x = *coord;
coord++; coord++;
pos.y = *coord; pos.y = *coord;
coord++; coord++;
UserToDeviceCoordinate(pos); UserToDeviceCoordinate( pos );
fprintf( dest, "X%5.5dY%5.5dD02*\n", pos.x, pos.y ); fprintf( dest, "X%5.5dY%5.5dD02*\n", pos.x, pos.y );
for( ii = 1; ii < nb_segm; ii++ ) for( ii = 1; ii < nb_segm; ii++ )
{ {
pos.x = *coord; pos.x = *coord;
coord++; coord++;
pos.y = *coord; pos.y = *coord;
coord++; coord++;
UserToDeviceCoordinate(pos); UserToDeviceCoordinate( pos );
fprintf( dest, "X%5.5dY%5.5dD01*\n", pos.x, pos.y ); fprintf( dest, "X%5.5dY%5.5dD01*\n", pos.x, pos.y );
} }
fputs("G37*\n", dest); fputs( "G37*\n", dest );
} }
/*******************************************************/ /*******************************************************/
D_CODE * get_D_code( int dx, int dy, int type, int drill ) D_CODE* get_D_code( int dx, int dy, int type, int drill )
/*******************************************************/ /*******************************************************/
/* Fonction Recherchant et Creant eventuellement la description /* Fonction Recherchant et Creant eventuellement la description
* du D_CODE du type et dimensions demandees * du D_CODE du type et dimensions demandees
*/ */
{ {
D_CODE * ptr_tool, * last_dcode_ptr; D_CODE* ptr_tool, * last_dcode_ptr;
int num_new_D_code = FIRST_DCODE_VALUE; int num_new_D_code = FIRST_DCODE_VALUE;
ptr_tool = last_dcode_ptr = s_DCodeList; ptr_tool = last_dcode_ptr = s_DCodeList;
while( ptr_tool && ptr_tool->m_Type >= 0 ) while( ptr_tool && ptr_tool->m_Type >= 0 )
{ {
if( ( ptr_tool->m_Size.x == dx ) && if( ( ptr_tool->m_Size.x == dx )
( ptr_tool->m_Size.y == dy ) && && ( ptr_tool->m_Size.y == dy )
( ptr_tool->m_Type == type ) ) && ( ptr_tool->m_Type == type ) )
return(ptr_tool); /* D_code deja existant */ return ptr_tool; /* D_code deja existant */
last_dcode_ptr = ptr_tool; last_dcode_ptr = ptr_tool;
ptr_tool = ptr_tool->m_Pnext; ptr_tool = ptr_tool->m_Pnext;
num_new_D_code++; num_new_D_code++;
} }
/* At this point, the requested D_CODE does not exist: It will be created */ /* At this point, the requested D_CODE does not exist: It will be created */
if( ptr_tool == NULL ) /* We must create a new data */ if( ptr_tool == NULL ) /* We must create a new data */
{ {
ptr_tool = new D_CODE(); ptr_tool = new D_CODE();
ptr_tool->m_NumDcode = num_new_D_code;
if( last_dcode_ptr ) ptr_tool->m_NumDcode = num_new_D_code;
{ if( last_dcode_ptr )
ptr_tool->m_Pback = last_dcode_ptr; {
last_dcode_ptr->m_Pnext = ptr_tool; ptr_tool->m_Pback = last_dcode_ptr;
} last_dcode_ptr->m_Pnext = ptr_tool;
else }
s_DCodeList = ptr_tool; else
} s_DCodeList = ptr_tool;
ptr_tool->m_Size.x = dx; }
ptr_tool->m_Size.y = dy; ptr_tool->m_Size.x = dx;
ptr_tool->m_Type = type; ptr_tool->m_Size.y = dy;
return(ptr_tool); ptr_tool->m_Type = type;
return ptr_tool;
} }
/******************************************************************/ /******************************************************************/
void Init_Trace_GERBER(WinEDA_BasePcbFrame * frame, FILE * gerbfile) void Init_Trace_GERBER( WinEDA_BasePcbFrame* frame, FILE* gerbfile )
/******************************************************************/ /******************************************************************/
{ {
char Line[1024]; char Line[1024];
s_Last_D_code = 0; s_Last_D_code = 0;
DateAndTime(Line); DateAndTime( Line );
wxString Title = g_Main_Title + wxT(" ") + GetBuildVersion(); wxString Title = g_Main_Title + wxT( " " ) + GetBuildVersion();
fprintf(gerbfile, "G04 (Genere par %s) le %s*\n", CONV_TO_UTF8(Title), Line); fprintf( gerbfile, "G04 (Genere par %s) le %s*\n", CONV_TO_UTF8( Title ), Line );
// Specify linear interpol (G01), unit = INCH (G70), abs format (G90): // Specify linear interpol (G01), unit = INCH (G70), abs format (G90):
fputs("G01*\nG70*\nG90*\n", gerbfile); fputs( "G01*\nG70*\nG90*\n", gerbfile );
fputs("%MOIN*%\n", gerbfile); // set unites = INCHES fputs( "%MOIN*%\n", gerbfile ); // set unites = INCHES
/* Set gerber format to 3.4 */ /* Set gerber format to 3.4 */
strcpy(Line, "G04 Gerber Fmt 3.4, Leading zero omitted, Abs format*\n%FSLAX34Y34*%\n"); strcpy( Line, "G04 Gerber Fmt 3.4, Leading zero omitted, Abs format*\n%FSLAX34Y34*%\n" );
fputs(Line, gerbfile); fputs( Line, gerbfile );
fputs("G04 APERTURE LIST*\n", gerbfile); fputs( "G04 APERTURE LIST*\n", gerbfile );
} }
...@@ -787,69 +793,70 @@ static void Init_ApertureList() ...@@ -787,69 +793,70 @@ static void Init_ApertureList()
* .m_Type < 0 is the first free aperture descr * .m_Type < 0 is the first free aperture descr
*/ */
{ {
D_CODE * ptr_tool; D_CODE* ptr_tool;
ptr_tool = s_DCodeList; ptr_tool = s_DCodeList;
while( ptr_tool ) while( ptr_tool )
{ {
s_DCodeList->m_Type = -1; s_DCodeList->m_Type = -1;
ptr_tool = ptr_tool->m_Pnext; ptr_tool = ptr_tool->m_Pnext;
} }
ShowDcodeError = TRUE;
ShowDcodeError = TRUE;
} }
/*****************************************************************/ /*****************************************************************/
void Fin_Trace_GERBER(WinEDA_BasePcbFrame * frame, FILE * gerbfile) void Fin_Trace_GERBER( WinEDA_BasePcbFrame* frame, FILE* gerbfile )
/*****************************************************************/ /*****************************************************************/
{ {
char line[1024]; char line[1024];
wxString TmpFileName, msg; wxString TmpFileName, msg;
FILE * outfile; FILE* outfile;
fputs("M02*\n", gerbfile); fputs( "M02*\n", gerbfile );
fclose(gerbfile); fclose( gerbfile );
// Reouverture gerbfile pour ajout des Apertures // Reouverture gerbfile pour ajout des Apertures
gerbfile = wxFopen( GerberFullFileName, wxT("rt") ); gerbfile = wxFopen( GerberFullFileName, wxT( "rt" ) );
if( gerbfile == NULL ) if( gerbfile == NULL )
{ {
msg.Printf( _("unable to reopen file <%s>"), GerberFullFileName.GetData() ); msg.Printf( _( "unable to reopen file <%s>" ), GerberFullFileName.GetData() );
DisplayError(frame, msg); DisplayError( frame, msg );
return; return;
} }
// Ouverture tmpfile // Ouverture tmpfile
TmpFileName = GerberFullFileName + wxT(".$$$"); TmpFileName = GerberFullFileName + wxT( ".$$$" );
outfile = wxFopen( TmpFileName, wxT("wt") ); outfile = wxFopen( TmpFileName, wxT( "wt" ) );
if( outfile == NULL ) if( outfile == NULL )
{ {
fclose(gerbfile); fclose( gerbfile );
DisplayError(frame, wxT("Fin_Trace_GERBER(): Can't Open tmp file")); DisplayError( frame, wxT( "Fin_Trace_GERBER(): Can't Open tmp file" ) );
return; return;
} }
// Placement des Apertures en RS274X // Placement des Apertures en RS274X
rewind(gerbfile); rewind( gerbfile );
while( fgets(line, 1024, gerbfile) ) while( fgets( line, 1024, gerbfile ) )
{ {
fputs(line, outfile); fputs( line, outfile );
if( strcmp(strtok(line, "\n\r"), "G04 APERTURE LIST*") == 0 ) if( strcmp( strtok( line, "\n\r" ), "G04 APERTURE LIST*" ) == 0 )
{ {
frame->Gen_D_CODE_File(outfile); frame->Gen_D_CODE_File( outfile );
fputs("G04 APERTURE END LIST*\n", outfile); fputs( "G04 APERTURE END LIST*\n", outfile );
} }
} }
fclose(outfile); fclose( outfile );
fclose(gerbfile); fclose( gerbfile );
wxRemoveFile(GerberFullFileName); wxRemoveFile( GerberFullFileName );
wxRenameFile(TmpFileName, GerberFullFileName); wxRenameFile( TmpFileName, GerberFullFileName );
} }
/******************************************************/ /******************************************************/
int WinEDA_BasePcbFrame::Gen_D_CODE_File(FILE * penfile) int WinEDA_BasePcbFrame::Gen_D_CODE_File( FILE* penfile )
/******************************************************/ /******************************************************/
/* Genere la liste courante des D_CODES /* Genere la liste courante des D_CODES
...@@ -857,49 +864,51 @@ int WinEDA_BasePcbFrame::Gen_D_CODE_File(FILE * penfile) ...@@ -857,49 +864,51 @@ int WinEDA_BasePcbFrame::Gen_D_CODE_File(FILE * penfile)
* Genere une sequence RS274X * Genere une sequence RS274X
*/ */
{ {
D_CODE * ptr_tool; D_CODE* ptr_tool;
int nb_dcodes = 0 ; int nb_dcodes = 0;
/* Init : */ /* Init : */
ptr_tool = s_DCodeList; ptr_tool = s_DCodeList;
while( ptr_tool && ( ptr_tool->m_Type >= 0 ) ) while( ptr_tool && ( ptr_tool->m_Type >= 0 ) )
{ {
float fscale = 0.0001; // For 3.4 format float fscale = 0.0001; // For 3.4 format
char * text; char* text;
sprintf(cbuf, "%%ADD%d", ptr_tool->m_NumDcode); sprintf( cbuf, "%%ADD%d", ptr_tool->m_NumDcode );
text = cbuf + strlen(cbuf); text = cbuf + strlen( cbuf );
switch( ptr_tool->m_Type )
{ switch( ptr_tool->m_Type )
case 1: // Circle (flash ) {
sprintf(text, "C,%f*%%\n", ptr_tool->m_Size.x * fscale); case 1: // Circle (flash )
break; sprintf( text, "C,%f*%%\n", ptr_tool->m_Size.x * fscale );
break;
case 2: // PAD_RECT
sprintf(text, "R,%fX%f*%%\n", ptr_tool->m_Size.x * fscale, case 2: // PAD_RECT
ptr_tool->m_Size.y * fscale); sprintf( text, "R,%fX%f*%%\n", ptr_tool->m_Size.x * fscale,
break; ptr_tool->m_Size.y * fscale );
break;
case 3: // Circle ( lines )
sprintf(text, "C,%f*%%\n", ptr_tool->m_Size.x * fscale); case 3: // Circle ( lines )
break; sprintf( text, "C,%f*%%\n", ptr_tool->m_Size.x * fscale );
break;
case 4: // PAD_OVAL
sprintf(text, "O,%fX%f*%%\n", ptr_tool->m_Size.x * fscale, case 4: // PAD_OVAL
ptr_tool->m_Size.y * fscale); sprintf( text, "O,%fX%f*%%\n", ptr_tool->m_Size.x * fscale,
break; ptr_tool->m_Size.y * fscale );
break;
default:
DisplayError( this, wxT("Gen_D_CODE_File(): Dcode Type err") ); default:
break; DisplayError( this, wxT( "Gen_D_CODE_File(): Dcode Type err" ) );
} break;
// compensation localisation printf (float x.y gnr x,y) }
to_point( text + 2 );
// compensation localisation printf (float x.y gnr x,y)
fputs(cbuf, penfile); to_point( text + 2 );
ptr_tool = ptr_tool->m_Pnext;
nb_dcodes++; fputs( cbuf, penfile );
} ptr_tool = ptr_tool->m_Pnext;
nb_dcodes++;
return( nb_dcodes ); }
return nb_dcodes;
} }
pcbnew/plotps.cpp
View file @ 2da432b2
...@@ -25,7 +25,7 @@ const int DRILL_MARK = 1; ...@@ -25,7 +25,7 @@ const int DRILL_MARK = 1;
/****************************************************************************/ /****************************************************************************/
void WinEDA_BasePcbFrame::Genere_PS( const wxString& FullFileName, int Layer ) void WinEDA_BasePcbFrame::Genere_PS( const wxString& FullFileName, int Layer, bool useA4 )
/****************************************************************************/ /****************************************************************************/
/* Genere un fichier POSTSCRIPT (*.ps) de trace du circuit, couche layer /* Genere un fichier POSTSCRIPT (*.ps) de trace du circuit, couche layer
...@@ -59,6 +59,7 @@ void WinEDA_BasePcbFrame::Genere_PS( const wxString& FullFileName, int Layer ) ...@@ -59,6 +59,7 @@ void WinEDA_BasePcbFrame::Genere_PS( const wxString& FullFileName, int Layer )
if( g_PlotScaleOpt != 1 ) if( g_PlotScaleOpt != 1 )
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;
...@@ -69,7 +70,8 @@ void WinEDA_BasePcbFrame::Genere_PS( const wxString& FullFileName, int Layer ) ...@@ -69,7 +70,8 @@ void WinEDA_BasePcbFrame::Genere_PS( const wxString& FullFileName, int Layer )
// calcul en unites internes des dimensions des feuilles ( connues en 1/1000 pouce ) // calcul en unites internes des dimensions des feuilles ( connues en 1/1000 pouce )
PcbSheetSize.x = currentsheet->m_Size.x * U_PCB; PcbSheetSize.x = currentsheet->m_Size.x * U_PCB;
PcbSheetSize.y = currentsheet->m_Size.y * U_PCB; PcbSheetSize.y = currentsheet->m_Size.y * U_PCB;
if( g_ForcePlotPS_On_A4 )
if( useA4 )
{ {
SheetPS = &g_Sheet_A4; SheetPS = &g_Sheet_A4;
PaperSize.x = g_Sheet_A4.m_Size.x * U_PCB; PaperSize.x = g_Sheet_A4.m_Size.x * U_PCB;
...@@ -168,9 +170,9 @@ void WinEDA_BasePcbFrame::Genere_PS( const wxString& FullFileName, int Layer ) ...@@ -168,9 +170,9 @@ void WinEDA_BasePcbFrame::Genere_PS( const wxString& FullFileName, int Layer )
SetColorMapPS( WHITE ); SetColorMapPS( WHITE );
} }
// Specify that the contents of the "Edges Pcb" layer are to be plotted // Specify that the contents of the "Edges Pcb" layer are to be plotted
// in addition to the contents of the currently specified layer. // in addition to the contents of the currently specified layer.
int layer_mask = g_TabOneLayerMask[Layer] | EDGE_LAYER; int layer_mask = g_TabOneLayerMask[Layer] | EDGE_LAYER;
switch( Layer ) switch( Layer )
{ {
...@@ -464,7 +466,7 @@ static void PrintDrillMark( BOARD* Pcb ) ...@@ -464,7 +466,7 @@ static void PrintDrillMark( BOARD* Pcb )
if( g_DrillShapeOpt == DRILL_MARK ) if( g_DrillShapeOpt == DRILL_MARK )
diam.x = diam.y = SMALL_DRILL; diam.x = diam.y = SMALL_DRILL;
else else
diam.x = diam.y = pts->GetDrillValue(); diam.x = diam.y = pts->GetDrillValue();
trace_1_pastille_RONDE_POST( pos, diam.x, FILLED ); trace_1_pastille_RONDE_POST( pos, diam.x, FILLED );
} }
...@@ -573,7 +575,7 @@ void trace_1_pastille_RONDE_POST( wxPoint centre, int diametre, int modetrace ) ...@@ -573,7 +575,7 @@ void trace_1_pastille_RONDE_POST( wxPoint centre, int diametre, int modetrace )
if( modetrace == FILLED ) if( modetrace == FILLED )
{ {
SetCurrentLineWidthPS(0); SetCurrentLineWidthPS(0);
rayon = diam.x / 2; rayon = diam.x / 2;
if( rayon < 1 ) if( rayon < 1 )
rayon = 1; rayon = 1;
...@@ -588,7 +590,7 @@ void trace_1_pastille_RONDE_POST( wxPoint centre, int diametre, int modetrace ) ...@@ -588,7 +590,7 @@ void trace_1_pastille_RONDE_POST( wxPoint centre, int diametre, int modetrace )
rayon = 1; rayon = 1;
if( rayon < w ) if( rayon < w )
w = rayon; w = rayon;
SetCurrentLineWidthPS(w); SetCurrentLineWidthPS(w);
fprintf( dest, "newpath %d %d %d 0 360 arc stroke\n", fprintf( dest, "newpath %d %d %d 0 360 arc stroke\n",
centre.x, centre.y, rayon ); centre.x, centre.y, rayon );
} }
......
pcbnew/specctra.h
View file @ 2da432b2
...@@ -2707,6 +2707,10 @@ public: ...@@ -2707,6 +2707,10 @@ public:
}; };
/**
* Class CLASS
* corresponds to the &lt;class_descriptor&gt; in the specctra spec.
*/
class CLASS : public ELEM class CLASS : public ELEM
{ {
friend class SPECCTRA_DB; friend class SPECCTRA_DB;
......
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