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