/*************************************/
		/**** Pcbnew: Routine de trace PS ****/
		/*************************************/

#include "fctsys.h"
#include "gr_basic.h"

#include "common.h"
#include "plot_common.h"
#include "pcbnew.h"
#include "pcbplot.h"
#include "trigo.h"

#include "protos.h"

#include "wx/defs.h"

// Routines Locales
static void PrintDrillMark(BOARD * Pcb);
static Ki_PageDescr * SheetPS;

// variables locales:
const int DRILL_MARK = 1;


/****************************************************************************/
void WinEDA_BasePcbFrame::Genere_PS(const wxString & FullFileName, int Layer)
/****************************************************************************/

/* Genere un fichier POSTSCRIPT (*.ps) de trace du circuit, couche layer
 * if layer < 0: all layers
 */
{
int modetrace, tracevia;
wxSize PcbSheetSize;
wxSize PaperSize;
wxSize BoardSize;
wxPoint BoardCenter;
bool Center = FALSE;
Ki_PageDescr * currentsheet = m_CurrentScreen->m_CurrentSheet;
double scale_format;		// Facteur correctif pour conversion forlat Ax->A4
double scale_x, scale_y;
int PlotMarge_in_mils = 0;

	MsgPanel->EraseMsgBox();

	dest = wxFopen( FullFileName, wxT("wt") );
	if( dest == NULL )
	{
		wxString msg = _("Unable to create file ") + FullFileName;
		DisplayError(this, msg);
		return;
	}

	setlocale(LC_NUMERIC, "C");

	Affiche_1_Parametre(this, 0, _("File"), FullFileName, CYAN);

	if( g_PlotScaleOpt != 1 )
		Center = TRUE;	// Echelle != 1 donc trace centree du PCB
	modetrace = Plot_Mode;
	scale_format = 1.0;
	// Set default line width
	if( g_PlotLine_Width < 1 )
		g_PlotLine_Width = 1;

	// 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 )
	{
		SheetPS = &g_Sheet_A4;
		PaperSize.x = g_Sheet_A4.m_Size.x * U_PCB;
		PaperSize.y = g_Sheet_A4.m_Size.y * U_PCB;
		scale_format = (float) PaperSize.x / PcbSheetSize.x;
	}
	else
	{
		SheetPS = currentsheet;
		PaperSize = PcbSheetSize;
	}

	// calcul de l'offset de trace:
	// calcul du cadrage horizontal du mode paysage ( val algebr. plus grande = decalage a gauche )
	g_PlotOffset.x = PlotMarge_in_mils * U_PCB;
	// cadrage vertical du mode paysage ( val algebr. plus grande = decalage vers le haut )
	g_PlotOffset.y = PaperSize.y - PlotMarge_in_mils * U_PCB;

	int BBox[4];
	BBox[0] = BBox[1] = PlotMarge_in_mils;
	BBox[2] = SheetPS->m_Size.x - PlotMarge_in_mils;
	BBox[3] = SheetPS->m_Size.y - PlotMarge_in_mils;
	scale_x = scale_y = 1.0;
	InitPlotParametresPS( g_PlotOffset, SheetPS, 1.0 / m_InternalUnits, 1.0 / m_InternalUnits );
	SetDefaultLineWidthPS(g_PlotLine_Width);
	PrintHeaderPS(dest, wxT("PCBNEW-PS"), FullFileName, 1, BBox, wxLANDSCAPE);

	if( Plot_Sheet_Ref )
	{
		int tmp = g_PlotOrient;
		g_PlotOrient = 0;
		SetPlotScale( 1.0, 1.0 );
		PlotWorkSheet( PLOT_FORMAT_POST, m_CurrentScreen );
		g_PlotOrient = tmp;
	}

	// calcul des dimensions et centre du PCB
	m_Pcb->ComputeBoundaryBox();
	BoardSize = m_Pcb->m_BoundaryBox.GetSize();
	BoardCenter = m_Pcb->m_BoundaryBox.Centre();

	scale_x = Scale_X;
	scale_y = Scale_Y;
	if( g_PlotScaleOpt == 0 )		// Optimum scale
	{
		float Xscale, Yscale;
		int noprint_size = 2 * PlotMarge_in_mils * U_PCB;
		if( Plot_Sheet_Ref )
			noprint_size += 500 * U_PCB;
		Xscale = (float) ( PaperSize.x - noprint_size ) / BoardSize.x;
		Yscale = (float) ( PaperSize.y - noprint_size ) / BoardSize.y;
		scale_x = scale_y = min( Xscale, Yscale );
	}

	BoardCenter.x = (int)(BoardCenter.x * scale_x);
	BoardCenter.y = (int)(BoardCenter.y * scale_y);

	// Calcul du cadrage (echelle != 1 donc recadrage du trace)
	if( Center )
	{
		g_PlotOffset.x -= PaperSize.x / 2 - BoardCenter.x + PlotMarge_in_mils * U_PCB;
		g_PlotOffset.y = PaperSize.y / 2 + BoardCenter.y;	// cadrage horizontal du mode paysage
	}

	if( g_PlotOrient == PLOT_MIROIR )
	{
		if( Center )
			g_PlotOffset.y = - PaperSize.y / 2 + BoardCenter.y;
		else
			g_PlotOffset.y = - PaperSize.y + m_Pcb->m_BoundaryBox.GetBottom()
							 + m_Pcb->m_BoundaryBox.GetY() + PlotMarge_in_mils * U_PCB;
	}

	InitPlotParametresPS( g_PlotOffset, SheetPS, scale_x, scale_y, g_PlotOrient );

	// If plot a negative board:
	// Draw a black rectangle (background for plot board in white)
	// and switch the current color to WHITE
	if( g_Plot_PS_Negative )
	{
		int Rectangle[10];	// Put here the board corners
		int margin = 500;	// Add a 0.1 inch margin around the board
		Rectangle[0] = m_Pcb->m_BoundaryBox.GetX() - margin;
		Rectangle[1] = m_Pcb->m_BoundaryBox.GetY() - margin;
		Rectangle[2] = m_Pcb->m_BoundaryBox.GetRight() + margin;
		Rectangle[3] = Rectangle[1];
		Rectangle[4] = Rectangle[2];
		Rectangle[5] = m_Pcb->m_BoundaryBox.GetBottom() + margin;
		Rectangle[6] = Rectangle[0];
		Rectangle[7] = Rectangle[5];
		Rectangle[8] = Rectangle[0];
		Rectangle[9] = Rectangle[1];
		SetColorMapPS(BLACK);
		PlotPolyPS( 5, Rectangle, TRUE );
		SetColorMapPS(WHITE);
	}
	
	switch(Layer)
	{
	case -1:
		Plot_Layer_PS(dest, g_TabOneLayerMask[Layer], 0, 1, modetrace);
		break;
		
	case CUIVRE_N :
	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 CMP_N  :
		Plot_Layer_PS(dest, g_TabOneLayerMask[Layer], 0, 1, modetrace);
		break;

	case SILKSCREEN_N_CU :
	case SILKSCREEN_N_CMP :
		Plot_Serigraphie(PLOT_FORMAT_POST, dest, g_TabOneLayerMask[Layer]);
		break;

	case SOLDERMASK_N_CU :
	case SOLDERMASK_N_CMP :  // Trace du vernis epargne
		if( g_DrawViaOnMaskLayer )
			tracevia = 1;
		else
			tracevia = 0;
		Plot_Layer_PS(dest, g_TabOneLayerMask[Layer], g_DesignSettings.m_MaskMargin,
					tracevia, modetrace);
		break;

	case SOLDERPASTE_N_CU :
	case SOLDERPASTE_N_CMP :  // Trace du masque de pate de soudure
		Plot_Layer_PS(dest, g_TabOneLayerMask[Layer], 0, 0, modetrace);
		break;

	default:
		Plot_Serigraphie(PLOT_FORMAT_POST, dest, g_TabOneLayerMask[Layer]);
		break;
	}
	// fin
	CloseFilePS(dest);
	setlocale(LC_NUMERIC, "");
}


/********************************************************************/
void WinEDA_BasePcbFrame::Plot_Layer_PS(FILE * File,int masque_layer,
						int garde, int tracevia, int modetrace)
/********************************************************************/

/* Trace en format POSTSCRIPT d'une couche cuivre ou masque
 */
{
wxPoint pos, end;
wxSize size;
MODULE * Module;
D_PAD * PtPad;
TRACK * pts ;
EDA_BaseStruct * PtStruct;
wxString msg;
	
	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->m_StructType )
		{
		case TYPEDRAWSEGMENT:
			PlotDrawSegment( (DRAWSEGMENT*) PtStruct, PLOT_FORMAT_POST,
											masque_layer);
			break;

		case TYPETEXTE:
			PlotTextePcb((TEXTE_PCB*) PtStruct,PLOT_FORMAT_POST,
											masque_layer);
			break;

		case TYPECOTATION:
			PlotCotation((COTATION*) PtStruct, PLOT_FORMAT_POST,
											masque_layer);
			break;

		case TYPEMIRE:
			PlotMirePcb((MIREPCB*) PtStruct, PLOT_FORMAT_POST,
											masque_layer);
			break;

		case TYPEMARQUEUR:
			break;

		default:
			DisplayError(this, wxT("WinEDA_BasePcbFrame::Plot_Layer_PS() : Unexpected Draw Type"));
			break;
		}
	}

	// Trace des Elements des modules autres que pads
	nb_items = 0;
	Affiche_1_Parametre(this, 48, 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->m_StructType )
			{
			case TYPEEDGEMODULE:
				if( masque_layer & g_TabOneLayerMask[((EDGE_MODULE*)PtStruct)->m_Layer] )
					Plot_1_EdgeModule(PLOT_FORMAT_POST, (EDGE_MODULE*) PtStruct);
				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 )
		{
			if( (PtPad->m_Masque_Layer & masque_layer) == 0 )
				continue;
			wxPoint shape_pos = PtPad->ReturnShapePos();
			pos = shape_pos;

			size.x = PtPad->m_Size.x + garde * 2;
			size.y = PtPad->m_Size.y + garde * 2;

			nb_items++;

			switch (PtPad->m_PadShape)
			{
			case CIRCLE :
				trace_1_pastille_RONDE_POST(pos, size.x, modetrace);
				break;

			case OVALE :
				trace_1_pastille_OVALE_POST(pos, size, PtPad->m_Orient, modetrace);
				break;

			case TRAPEZE :
				{
				wxSize delta;
				delta = PtPad->m_DeltaSize;
				trace_1_pad_TRAPEZE_POST(pos, size, delta,
									PtPad->m_Orient, modetrace);
				break;
				}

			case RECT:
			default:
				trace_1_pad_rectangulaire_POST(pos, size, PtPad->m_Orient, modetrace);
				break;
			}
			msg.Printf( wxT("%d"), nb_items );
			Affiche_1_Parametre(this, 48, wxT("Pads"), msg, GREEN);
		}
	}
	// trace des VIAS :
	if( tracevia )
	{
		nb_items = 0;
		Affiche_1_Parametre(this, 56,_("Vias"), wxEmptyString, RED);
		for( pts = m_Pcb->m_Track; pts != NULL; pts = pts->Next() )
		{
			if( pts->m_StructType != TYPEVIA )
				continue;
			SEGVIA * Via = (SEGVIA *) pts;
			// 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 + garde * 2;
			trace_1_pastille_RONDE_POST(pos, size.x, modetrace);
			nb_items++;
			msg.Printf( wxT("%d"), nb_items );
			Affiche_1_Parametre(this, 56, wxEmptyString, msg, RED);
		}
	}
	// trace des pistes et zones:
	nb_items = 0;
	Affiche_1_Parametre(this, 64, _("Tracks"), wxEmptyString, YELLOW);

	for( pts = m_Pcb->m_Track; pts != NULL; pts = (TRACK*) pts->Pnext )
	{
		if( pts->m_StructType == TYPEVIA )
			continue;

		if( (g_TabOneLayerMask[pts->m_Layer] & masque_layer) == 0 )
			continue;
		size.x = size.y = pts->m_Width;
		pos = pts->m_Start;
		end = pts->m_End;

		PlotFilledSegmentPS(pos, end, size.x);

		nb_items++;
		msg.Printf( wxT("%d"), nb_items );
		Affiche_1_Parametre(this, 64, wxEmptyString, msg, YELLOW);
	}

	nb_items = 0;
	Affiche_1_Parametre(this, 64, wxT("Zones  "), wxEmptyString, YELLOW);

	for( pts = m_Pcb->m_Zone; pts != NULL; pts = (TRACK*) pts->Pnext )
	{
		if( (g_TabOneLayerMask[pts->m_Layer] & masque_layer) == 0 )
			continue;
		size.x = size.y = pts->m_Width;
		pos = pts->m_Start;
		end = pts->m_End;
		PlotFilledSegmentPS(pos, end, size.x);
		nb_items++;
		msg.Printf( wxT("%d"), nb_items );
		Affiche_1_Parametre(this, 64, wxEmptyString, msg, YELLOW);
	}

	// Trace des trous de percage
	if( modetrace == FILLED )
		PrintDrillMark(m_Pcb);
}


/*************************************/
static void PrintDrillMark(BOARD * Pcb)
/*************************************/

/* Draw a drill mark for pads and vias.
 * Must be called after all drawings, because it
 * redraw the drill mark on a pad or via
 */
{
const int SMALL_DRILL = 150;
wxPoint pos;
wxSize diam;
MODULE * Module;
D_PAD * PtPad;
TRACK * pts ;

	if( g_DrillShapeOpt == 0 )
		return;

	if( g_Plot_PS_Negative )
		fprintf(dest, " 0 setgray\n");
	else
		fprintf(dest, " 1 setgray\n");

	diam.x = diam.y = (g_DrillShapeOpt == DRILL_MARK) ? SMALL_DRILL :
			g_DesignSettings.m_ViaDrill;

	for( pts = Pcb->m_Track; pts != NULL; pts = (TRACK*)pts->Pnext )
	{
		if( pts->m_StructType != TYPEVIA )
			continue;
		pos = pts->m_Start;
		if( g_DrillShapeOpt == DRILL_MARK )
			diam.x = diam.y = SMALL_DRILL;
		else
		{
			if( pts->m_Drill < 0 )
				diam.x = diam.y = g_DesignSettings.m_ViaDrill;
			else
				diam.x = diam.y = pts->m_Drill;
		}
		trace_1_pastille_RONDE_POST(pos, diam.x, FILLED);
	}

	Module = Pcb->m_Modules;
	for( ; Module != NULL; Module = (MODULE *)Module->Pnext )
	{
		PtPad = (D_PAD*) Module->m_Pads;
		for ( ; PtPad != NULL; PtPad = (D_PAD*)PtPad->Pnext )
		{
			if( PtPad->m_Drill.x == 0 )
				continue;

			// calcul de la position des trous, selon echelle
			pos = PtPad->m_Pos;
			diam.x = diam.y = (g_DrillShapeOpt == DRILL_MARK) ? SMALL_DRILL :
					PtPad->m_Drill.x;
			trace_1_pastille_RONDE_POST(pos, diam.x, FILLED);
		}
	}

	fprintf(dest, " 0 setgray\n");
}


/***********************************************************************************/
void trace_1_pastille_OVALE_POST(wxPoint pos, wxSize size, int orient, int modetrace)
/************************************************************************************/

/* Trace 1 pastille OVALE en position pos_X,Y:
 * dimensions dx,dy,
 * orientation orient
 * La forme est tracee comme un segment
 */
{
int x0, y0, x1, y1, delta;
int w, rayon;

	// la pastille est ramenee a une pastille ovale avec dy > dx
	if( size.x > size.y )
	{
		EXCHG(size.x, size.y);
		orient += 900;
		if( orient >= 3600 )
			orient -= 3600;
	}

	delta = size.y - size.x;
	x0 = 0;
	y0 = -delta / 2;
	x1 = 0;
	y1 = delta / 2;
	RotatePoint(&x0, &y0, orient);
	RotatePoint(&x1, &y1, orient);

	if( modetrace == FILLED )
	{
		PlotFilledSegmentPS(wxPoint(pos.x + x0, pos.y + y0),
							wxPoint(pos.x + x1, pos.y + y1), size.x);
	}
	else
	{
		w = g_PlotLine_Width;
		rayon = (size.x - w) / 2;
		if( rayon < 1 )
			rayon = 1;
		if( rayon < w )
			w = rayon;
		PlotArcPS( wxPoint(pos.x + x1, pos.y + y1), -orient, -orient + 1800, rayon, w );
		PlotArcPS( wxPoint(pos.x + x0, pos.y + y0), -orient + 1800, -orient, rayon, w );

		x0 = -rayon;
		y0 = -delta / 2;
		x1 = -rayon;
		y1 = delta / 2;
		RotatePoint(&x0, &y0, orient);
		RotatePoint(&x1, &y1, orient);
		PlotFilledSegmentPS( wxPoint(pos.x + x0, pos.y + y0),
							 wxPoint(pos.x + x1, pos.y + y1), w );

		x0 = rayon;
		y0 = -delta / 2;
		x1 = rayon;
		y1 = delta / 2;
		RotatePoint(&x0, &y0, orient);
		RotatePoint(&x1, &y1, orient);
		PlotFilledSegmentPS( wxPoint(pos.x + x0, pos.y + y0),
							 wxPoint(pos.x + x1, pos.y + y1), w );
	}
}


/*******************************************************************************/
void trace_1_pastille_RONDE_POST(wxPoint centre, int diametre, int modetrace)
/*******************************************************************************/

/* Trace 1 pastille RONDE (via,pad rond) en position pos_X,Y
 */
{
int rayon, w;
wxSize diam(diametre, diametre);

	UserToDeviceCoordinate(centre);
	UserToDeviceSize(diam);

	if( modetrace == FILLED )
	{
		fprintf(dest, "%d setlinewidth\n", g_PlotLine_Width);
		rayon = diam.x / 2;
		if( rayon < 1 )
			rayon = 1;
		fprintf(dest, "newpath %d %d %d 0 360 arc fill stroke\n",
											 centre.x, centre.y, rayon);
	}
	else
	{
		w = g_PlotLine_Width;
		rayon = (diam.x - w) / 2;
		if( rayon < 1 )
			rayon = 1;
		if( rayon < w )
			w = rayon;
		fprintf(dest, "%d setlinewidth\n", w);
		fprintf(dest, "newpath %d %d %d 0 360 arc stroke\n",
											 centre.x, centre.y, rayon);
	}
}


/**************************************************************************/
void trace_1_pad_rectangulaire_POST(wxPoint centre,
							wxSize size, int orient, int modetrace)
/**************************************************************************/

/*
 * Trace 1 pad rectangulaire d'orientation quelconque
 * donne par son centre, ses dimensions,
 * et son orientation orient
 */
{
int x0, y0, x1, y1, w;

	if( modetrace == FILLED )
	{
		x0 = centre.x - size.x / 2;
		x1 = centre.x + size.x / 2;
		y0 = y1 = centre.y;
		w = size.y;

		RotatePoint(&x0, &y0, centre.x, centre.y, orient);
		RotatePoint(&x1, &y1, centre.x, centre.y, orient);

		fprintf(dest, "0 setlinewidth 0 setlinecap 0 setlinejoin\n");
		ForcePenReinit();	// Force init line width for PlotFilledSegmentPS
		PlotFilledSegmentPS(wxPoint(x0, y0), wxPoint(x1, y1), w);
		ForcePenReinit();
		SetCurrentLineWidthPS(0);	// Force init line width to default
		fprintf(dest, "1 setlinecap 1 setlinejoin\n");
	}
	else
	{
		w = g_PlotLine_Width;
		size.x -= w;
		if( size.x < 1 )
			size.x = 1;
		size.y -= w;
		if( size.y < 1 )
			size.y = 1;
		trace_1_contour_POST(centre, size, wxSize(0, 0), w, orient);
	}
}


/**************************************************************/
void trace_1_contour_POST(wxPoint centre, wxSize size, wxSize delta,
									int dim_trait, int orient)
/**************************************************************/

/*
 * Trace 1 contour rectangulaire ou trapezoidal d'orientation quelconque
 * donne par son centre centre,
 * ses dimensions size,
 * ses variations delta
 * epaisseur de trait dim_trait
 * et son orientation orient (en 0.1 degres)
 */
{
int ii;
int dx, dy, lpen;
int ddx, ddy;
wxPoint coord[4];

	lpen = dim_trait;

	dx = size.x / 2;
	dy = size.y / 2;
	ddx = delta.x >> 1;
	ddy = delta.y >> 1; // demi dim  dx et dy

	coord[0].x = centre.x - dx - ddy;
	coord[0].y = centre.y + dy + ddx;

	coord[1].x = centre.x - dx + ddy;
	coord[1].y = centre.y - dy - ddx;

	coord[2].x = centre.x + dx - ddy;
	coord[2].y = centre.y - dy + ddx;

	coord[3].x = centre.x + dx + ddy;
	coord[3].y = centre.y + dy - ddx;

	for( ii = 0; ii < 4; ii++ )
	{
		RotatePoint(&coord[ii], centre, orient);
	}

	PlotFilledSegmentPS( coord[0], coord[1], lpen );
	PlotFilledSegmentPS( coord[1], coord[2], lpen );
	PlotFilledSegmentPS( coord[2], coord[3], lpen );
	PlotFilledSegmentPS( coord[3], coord[0], lpen );
}


/*******************************************************************/
void trace_1_pad_TRAPEZE_POST(wxPoint centre, wxSize size, wxSize delta,
							int orient,int modetrace)
/*******************************************************************/

/*
 * Trace 1 pad trapezoidal donne par :
 * son centre centre
 * ses dimensions size
 * les variations delta ( 1 des deux au moins doit etre nulle)
 * son orientation orient en 0.1 degres
 * le mode de trace (FILLED, SKETCH, FILAIRE)
 *
 * Le trace n'est fait que pour un trapeze, c.a.d que deltaX ou deltaY
 * = 0.
 *
 * les notation des sommets sont ( vis a vis de la table tracante )
 * 
 * "       0 ------------- 3   "
 * "        .             .    "
 * "         .     O     .     "
 * "          .         .      "
 * "           1 ---- 2        "
 *
 *
 * exemple de Disposition pour deltaY > 0, deltaX = 0
 * "           1 ---- 2        "
 * "          .         .      "
 * "         .     O     .     "
 * "        .             .    "
 * "       0 ------------- 3   "
 *
 *
 * exemple de Disposition pour deltaY = 0, deltaX > 0
 * "       0                  "
 * "       . .                "
 * "       .     .            "
 * "       .           3      "
 * "       .           .      "
 * "       .     O     .      "
 * "       .           .      "
 * "       .           2      "
 * "       .     .            "
 * "       . .                "
 * "       1                  "
 */
{
int ii;
int dx, dy;
wxPoint polygone[4]; // coord des sommets / centre du pad
int ddx, ddy;
int l_pen;			// diam spot (plume)

	l_pen = 1;
	if( modetrace == FILAIRE || Plot_Mode == FILAIRE )
	{
		wxSize lsize(g_PlotLine_Width, g_PlotLine_Width);
		UserToDeviceSize(lsize);
		l_pen = lsize.x;
	}

	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;

	for( ii = 0; ii < 4; ii++ )
	{
		RotatePoint(&polygone[ii].x, &polygone[ii].y, orient);
		polygone[ii].x += centre.x;
		polygone[ii].y += centre.y;
	}

	SetCurrentLineWidthPS( l_pen );

	UserToDeviceCoordinate(polygone[0]);
	fprintf(dest, "newpath %d %d moveto\n", polygone[0].x, polygone[0].y);

	for( ii = 1; ii < 4; ii++ )
	{
		UserToDeviceCoordinate(polygone[ii]);
		fprintf(dest, "%d %d lineto\n", polygone[ii].x, polygone[ii].y);
	}

	fprintf(dest, "%d %d lineto ", polygone[0].x, polygone[0].y);

	if( modetrace == FILLED )
		fprintf(dest, "fill ");
	fprintf(dest, "stroke\n");
}