kicad/pcbnew/plotps.cpp

796 lines
24 KiB
C++

/*************************************/
/**** 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 );
}
// 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 )
{
case - 1:
Plot_Layer_PS( dest, layer_mask, 0, 1, modetrace );
break;
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_PS( dest, layer_mask, 0, 1, modetrace );
break;
case SILKSCREEN_N_CU:
case SILKSCREEN_N_CMP:
Plot_Serigraphie( PLOT_FORMAT_POST, dest, layer_mask );
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, layer_mask, 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, layer_mask, 0, 0, modetrace );
break;
default:
Plot_Serigraphie( PLOT_FORMAT_POST, dest, layer_mask );
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;
BOARD_ITEM* PtStruct;
wxString msg;
// (Following command has been superceded by new command on line 173.)
// 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->Next() )
{
switch( PtStruct->Type() )
{
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 TYPEMARKER:
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->Next() )
{
switch( PtStruct->Type() )
{
case TYPEEDGEMODULE:
if( masque_layer & g_TabOneLayerMask[ PtStruct->GetLayer() ] )
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 PAD_CIRCLE:
trace_1_pastille_RONDE_POST( pos, size.x, modetrace );
break;
case PAD_OVAL:
trace_1_pastille_OVALE_POST( pos, size, PtPad->m_Orient, modetrace );
break;
case PAD_TRAPEZOID:
{
wxSize delta;
delta = PtPad->m_DeltaSize;
trace_1_pad_TRAPEZE_POST( pos, size, delta,
PtPad->m_Orient, modetrace );
break;
}
case PAD_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->Type() != 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->Type() == TYPEVIA )
continue;
if( (g_TabOneLayerMask[pts->GetLayer()] & 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->GetLayer()] & 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->Type() != 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 PAD_OVAL 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" );
}