/*******************************/
/**** Routine de trace HPGL ****/
/*******************************/
#include "fctsys.h"
#include "common.h"
#include "plot_common.h"
#include "confirm.h"
#include "pcbnew.h"
#include "pcbplot.h"
#include "trigo.h"
#include "protos.h"
/* Variables locales : */
static int pen_rayon; /* Rayon de la plume en unites pcb */
static int pen_diam; /* Diametre de la plume en unites pcb */
static int pen_recouvrement; /* recouvrement en remplissage en unites pcb */
static int s_Nb_Plot_Errors; // Error count (errors when a line thichness is less than pen width
/* Routines Locales */
/*****************************************************************************/
void WinEDA_BasePcbFrame::Genere_HPGL( const wxString& FullFileName, int Layer )
/*****************************************************************************/
{
int modetrace;
wxSize SheetSize;
wxSize BoardSize;
wxPoint BoardCenter;
double scale_x, scale_y;
int marge = 0 * U_PCB; // Extra margin (set to 0)
bool Center = FALSE;
modetrace = g_Plot_Mode;
/* Calcul des echelles de conversion */
scale_x = Scale_X * SCALE_HPGL;
scale_y = Scale_Y * SCALE_HPGL;
// calcul en unites internes des dimensions de la feuille ( connues en 1/1000 pouce )
SheetSize.x = GetScreen()->m_CurrentSheetDesc->m_Size.x * U_PCB;
SheetSize.y = GetScreen()->m_CurrentSheetDesc->m_Size.y * U_PCB;
g_PlotOffset.x = 0;
g_PlotOffset.y = (int) (SheetSize.y * scale_y);
// Compute pen_dim (from g_HPGL_Pen_Diam in mils) in pcb units,
// with plot scale (if Scale is 2, pen diametre is always g_HPGL_Pen_Diam
// so apparent pen diam is real pen diam / Scale
pen_diam = wxRound( (g_HPGL_Pen_Diam * U_PCB) / Scale_X ); // Assume Scale_X # Scale_Y
pen_rayon = pen_diam / 2;
s_Nb_Plot_Errors = 0;
// compute pen_recouvrement (from g_HPGL_Pen_Recouvrement in mils)
// with plot scale
if( g_HPGL_Pen_Recouvrement < 0 )
g_HPGL_Pen_Recouvrement = 0;
if( g_HPGL_Pen_Recouvrement >= g_HPGL_Pen_Diam )
g_HPGL_Pen_Recouvrement = g_HPGL_Pen_Diam - 1;
pen_recouvrement = wxRound( g_HPGL_Pen_Recouvrement * 10.0 / Scale_X );
dest = wxFopen( FullFileName, wxT( "wt" ) );
if( dest == NULL )
{
wxString msg = _( "Unable to create " ) + FullFileName;
DisplayError( this, msg );
return;
}
SetLocaleTo_C_standard();
Affiche_1_Parametre( this, 0, _( "File" ), FullFileName, CYAN );
PrintHeaderHPGL( dest, g_HPGL_Pen_Speed, g_HPGL_Pen_Num );
if( g_Plot_Frame_Ref && (g_PlotScaleOpt == 1) )
{
int tmp = g_PlotOrient; g_PlotOrient = 0;
InitPlotParametresHPGL( g_PlotOffset, scale_x, scale_y, g_PlotOrient );
PlotWorkSheet( PLOT_FORMAT_HPGL, GetScreen() );
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();
if( g_PlotScaleOpt == 0 ) // Optimum scale
{
float Xscale, Yscale;
Xscale = (float) ( SheetSize.x - ( 2 * marge) ) / BoardSize.x;
Yscale = (float) ( SheetSize.y - ( 2 * marge) ) / BoardSize.y;
scale_x = scale_y = MIN( Xscale, Yscale ) * SCALE_HPGL;
}
BoardCenter.x = (int) (BoardCenter.x * scale_x);
BoardCenter.y = (int) (BoardCenter.y * scale_y);
if( g_PlotScaleOpt != 1 )
Center = TRUE; // Echelle != 1
/* Calcul du cadrage */
marge = (int) (marge * SCALE_HPGL);
if( Center )
g_PlotOffset.x = (int) (-SheetSize.x / 2 * SCALE_HPGL) +
BoardCenter.x + marge;
switch( g_PlotOrient )
{
default:
if( Center )
{
g_PlotOffset.y = (int) (SheetSize.y / 2 * SCALE_HPGL) +
BoardCenter.y + marge;
}
break;
case PLOT_MIROIR:
if( Center )
g_PlotOffset.y = (int) (-SheetSize.y / 2 * SCALE_HPGL) + BoardCenter.y;
else
g_PlotOffset.y = (int) ( ( -SheetSize.y +
m_Pcb->m_BoundaryBox.GetBottom() +
m_Pcb->m_BoundaryBox.GetY() ) * SCALE_HPGL );
break;
}
InitPlotParametresHPGL( g_PlotOffset, scale_x, scale_y, g_PlotOrient );
// 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 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_HPGL( dest, layer_mask, 0, 1, modetrace );
break;
case SILKSCREEN_N_CU:
case SILKSCREEN_N_CMP:
Plot_Serigraphie( PLOT_FORMAT_HPGL, dest, layer_mask );
break;
case SOLDERMASK_N_CU:
case SOLDERMASK_N_CMP: /* Trace du vernis epargne */
{
int tracevia;
if( g_DrawViaOnMaskLayer )
tracevia = 1;
else
tracevia = 0;
Plot_Layer_HPGL( 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_HPGL( dest, layer_mask, 0, 0, modetrace );
break;
default: /* Trace des autres couches (dessin, adhesives,eco,comment) */
Plot_Serigraphie( PLOT_FORMAT_HPGL, dest, layer_mask );
break;
}
/* fin */
CloseFileHPGL( dest );
SetLocaleTo_Default();
}
/*********************************************************************/
void WinEDA_BasePcbFrame::Plot_Layer_HPGL( FILE* File, int masque_layer,
int garde, int tracevia, int modetrace )
/*********************************************************************/
/* Trace en format HPGL. d'une couche cuivre ou masque
* 1 unite HPGL = 0.98 mils ( 1 mil = 1.02041 unite HPGL ) .
*/
{
wxSize size;
wxPoint start, end;
MODULE* Module;
D_PAD* PtPad;
TRACK* pts;
BOARD_ITEM* PtStruct;
wxString msg;
/* trace des elements type Drawings Pcb : */
PtStruct = m_Pcb->m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtStruct->Next() )
{
switch( PtStruct->Type() )
{
case TYPE_DRAWSEGMENT:
PlotDrawSegment( (DRAWSEGMENT*) PtStruct, PLOT_FORMAT_HPGL,
masque_layer );
break;
case TYPE_TEXTE:
PlotTextePcb( (TEXTE_PCB*) PtStruct, PLOT_FORMAT_HPGL,
masque_layer );
break;
case TYPE_COTATION:
PlotCotation( (COTATION*) PtStruct, PLOT_FORMAT_HPGL,
masque_layer );
break;
case TYPE_MIRE:
PlotMirePcb( (MIREPCB*) PtStruct, PLOT_FORMAT_HPGL,
masque_layer );
break;
case TYPE_MARKER:
break;
default:
DisplayError( this, wxT( "Type Draw non gere" ) );
break;
}
}
/* Trace des Elements des modules autres que pads */
Module = m_Pcb->m_Modules;
for( ; Module != NULL; Module = Module->Next() )
{
PtStruct = Module->m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtStruct->Next() )
{
switch( PtStruct->Type() )
{
case TYPE_EDGE_MODULE:
if( masque_layer &
g_TabOneLayerMask[ PtStruct->GetLayer() ] )
Plot_1_EdgeModule( PLOT_FORMAT_HPGL, (EDGE_MODULE*) PtStruct );
break;
default:
break;
}
}
}
/* Trace des Elements des modules : Pastilles */
Module = m_Pcb->m_Modules;
for( ; Module != NULL; Module = Module->Next() )
{
PtPad = (D_PAD*) Module->m_Pads;
for( ; PtPad != NULL; PtPad = (D_PAD*) PtPad->Next() )
{
wxPoint shape_pos;
if( (PtPad->m_Masque_Layer & masque_layer) == 0 )
continue;
shape_pos = PtPad->ReturnShapePos();
start = shape_pos;
size = PtPad->m_Size;
size.x += garde * 2; size.y += garde * 2;
switch( PtPad->m_PadShape & 0x7F )
{
case PAD_CIRCLE:
trace_1_pastille_RONDE_HPGL( start, size.x, modetrace );
break;
case PAD_OVAL:
{
trace_1_pastille_OVALE_HPGL( start, size, PtPad->m_Orient, modetrace );
break;
}
case PAD_TRAPEZOID:
{
wxSize delta;
delta = PtPad->m_DeltaSize;
trace_1_pad_TRAPEZE_HPGL( start, size, delta,
PtPad->m_Orient, modetrace );
break;
}
case PAD_RECT:
default:
PlotRectangularPad_HPGL( start, size,
PtPad->m_Orient, modetrace );
break;
}
}
}
/* trace des VIAS : */
if( tracevia )
{
TRACK* pts;
for( pts = m_Pcb->m_Track; pts != NULL; pts = pts->Next() )
{
if( pts->Type() != TYPE_VIA )
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;
start = Via->m_Start;
size.x = Via->m_Width + (garde * 2);
trace_1_pastille_RONDE_HPGL( start, size.x, modetrace );
}
fputs( "PU;\n", dest );
}
/* trace des segments pistes */
for( pts = m_Pcb->m_Track; pts != NULL; pts = pts->Next() )
{
if( pts->Type() == TYPE_VIA )
continue;
if( (g_TabOneLayerMask[pts->GetLayer()] & masque_layer) )
Plot_Filled_Segment_HPGL( pts->m_Start, pts->m_End, pts->m_Width, (GRFillMode)g_Plot_Mode );
}
/* trace des segments pistes et zones */
for( pts = m_Pcb->m_Zone; pts != NULL; pts = pts->Next() )
{
if( (g_TabOneLayerMask[pts->GetLayer()] & masque_layer) )
Plot_Filled_Segment_HPGL( pts->m_Start, pts->m_End, pts->m_Width, (GRFillMode)g_Plot_Mode );
}
/* Plot filled ares */
for( int ii = 0; ii < m_Pcb->GetAreaCount(); ii++ )
{
ZONE_CONTAINER* zone = m_Pcb->GetArea( ii );
if( ( ( 1 << zone->GetLayer() ) & masque_layer ) == 0 )
continue;
PlotFilledAreas( zone, PLOT_FORMAT_HPGL );
}
}
/*********************************************************************************************/
bool Plot_Filled_Segment_HPGL( wxPoint aStart, wxPoint aEnd, int aWidth, GRFillMode aPlotMode )
/*********************************************************************************************/
/** Function Plot a filled segment (track)
* @param aStart = starting point
* @param aEnd = ending point
* @param aWidth = segment width (thickness)
* @param aPlotMode = FILLED, SKETCH ..
* @return true if Ok, false if aWidth > pen size (the segment is always plotted)
*/
{
wxPoint center;
wxSize size;
int orient;
if( (pen_diam >= aWidth) || (g_Plot_Mode == FILAIRE) ) /* just a line is Ok */
{
Move_Plume_HPGL( aStart, 'U' );
Move_Plume_HPGL( aEnd, 'D' );
Plume_HPGL( 'U' );
return pen_diam <= aWidth;;
}
// A segment is like an oval pal, so use trace_1_pastille_OVALE_HPGL to do the work.
center.x = (aStart.x + aEnd.x) / 2;
center.y = (aStart.y + aEnd.y) / 2;
size.x = aEnd.x - aStart.x;
size.y = aEnd.y - aStart.y;
if ( size.y == 0 )
orient = 0;
else if ( size.x == 0 )
orient = 900;
else orient = - (int) (atan2( (double)size.y, (double)size.x ) * 1800.0 / M_PI);
size.x = (int) sqrt( ((double)size.x * size.x) + ((double)size.y * size.y) ) + aWidth; // module.
size.y = aWidth;
trace_1_pastille_OVALE_HPGL( center, size, orient, aPlotMode );
return pen_diam <= aWidth;
}
/************************************************************************************/
void trace_1_pastille_OVALE_HPGL( wxPoint pos, wxSize size, int aOrient, int modetrace )
/************************************************************************************/
/* Trace 1 pastille PAD_OVAL en position pos_X,Y , de dim size.x, size.y */
{
int rayon, deltaxy, cx, cy;
/* la pastille est ramenee a une pastille ovale avec size.y > size.x
* ( ovale vertical en orientation 0 ) */
if( size.x > size.y )
{
EXCHG( size.x, size.y ); aOrient += 900;
if( aOrient >= 3600 )
aOrient -= 3600;
}
deltaxy = size.y - size.x; /* = distance entre centres de l'ovale */
rayon = size.x / 2;
if( modetrace == FILLED )
{
PlotRectangularPad_HPGL( pos, wxSize( size.x, deltaxy+pen_diam ),
aOrient, modetrace );
cx = 0; cy = deltaxy / 2;
RotatePoint( &cx, &cy, aOrient );
trace_1_pastille_RONDE_HPGL( wxPoint( cx + pos.x, cy + pos.y ), size.x, modetrace );
Plume_HPGL( 'U' );
cx = 0; cy = -deltaxy / 2;
RotatePoint( &cx, &cy, aOrient );
trace_1_pastille_RONDE_HPGL( wxPoint( cx + pos.x, cy + pos.y ), size.x, modetrace );
}
else /* Trace en mode SKETCH */
{
cx = -rayon; cy = -deltaxy / 2;
RotatePoint( &cx, &cy, aOrient );
Move_Plume_HPGL( wxPoint( cx + pos.x, cy + pos.y ), 'U' );
cx = -rayon; cy = deltaxy / 2;
RotatePoint( &cx, &cy, aOrient );
Move_Plume_HPGL( wxPoint( cx + pos.x, cy + pos.y ), 'D' );
cx = rayon; cy = -deltaxy / 2;
RotatePoint( &cx, &cy, aOrient );
Move_Plume_HPGL( wxPoint( cx + pos.x, cy + pos.y ), 'U' );
cx = rayon; cy = deltaxy / 2;
RotatePoint( &cx, &cy, aOrient );
Move_Plume_HPGL( wxPoint( cx + pos.x, cy + pos.y ), 'D' );
Plume_HPGL( 'U' );
cx = 0; cy = deltaxy / 2;
RotatePoint( &cx, &cy, aOrient );
PlotArc( PLOT_FORMAT_HPGL, wxPoint( cx + pos.x, cy + pos.y ),
-aOrient, -aOrient - 1800,
size.x / 2, pen_diam );
cx = 0; cy = -deltaxy / 2;
RotatePoint( &cx, &cy, aOrient );
PlotArc( PLOT_FORMAT_HPGL, wxPoint( cx + pos.x, cy + pos.y ),
-aOrient - 1800, -aOrient,
size.x / 2, pen_diam );
}
Plume_HPGL( 'U' );
}
/**************************************************************************/
void trace_1_pastille_RONDE_HPGL( wxPoint pos, int diametre, int modetrace )
/**************************************************************************/
/* Trace 1 pastille RONDE (via,pad rond) en position pos */
{
char cbuf[1024];
int rayon, delta;
UserToDeviceCoordinate( pos );
delta = pen_diam - pen_recouvrement;
rayon = diametre / 2;
if( modetrace != FILAIRE )
{
rayon = (diametre - pen_diam ) / 2;
}
if( rayon < 0 )
{
rayon = 0; s_Nb_Plot_Errors++;
}
wxSize rsize( rayon, rayon );
UserToDeviceSize( rsize );
Plume_HPGL( 'U' );
sprintf( cbuf, "PA %d,%d;CI %d;\n", pos.x, pos.y, rsize.x );
fputs( cbuf, dest );
if( modetrace == FILLED ) /* Trace en mode Remplissage */
{
if( delta > 0 )
{
while( (rayon -= delta ) >= 0 )
{
rsize.x = rsize.y = rayon;
UserToDeviceSize( rsize );
sprintf( cbuf, "PA %d,%d; CI %d;\n", pos.x, pos.y, rsize.x );
fputs( cbuf, dest );
}
}
}
Plume_HPGL( 'U' ); return;
}
/***************************************************************/
void PlotRectangularPad_HPGL( wxPoint padpos, wxSize padsize,
int orient, int modetrace )
/****************************************************************/
/*
* Trace 1 pad rectangulaire vertical ou horizontal ( Pad rectangulaire )
* donne par son centre et ses dimensions X et Y
* Units are user units
*/
{
wxSize size;
int delta;
int ox, oy, fx, fy;
size.x = padsize.x / 2; size.y = padsize.y / 2;
if( modetrace != FILAIRE )
{
size.x = (padsize.x - (int) pen_diam) / 2;
size.y = (padsize.y - (int) pen_diam) / 2;
}
if( (size.x < 0 ) || (size.y < 0) )
{
s_Nb_Plot_Errors++;
}
if( size.x < 0 )
size.x = 0;if( size.y < 0 )
size.y = 0;
/* Si une des dimensions est nulle, le trace se reduit a 1 trait */
if( size.x == 0 )
{
ox = padpos.x; oy = padpos.y - size.y;
RotatePoint( &ox, &oy, padpos.x, padpos.y, orient );
fx = padpos.x; fy = padpos.y + size.y;
RotatePoint( &fx, &fy, padpos.x, padpos.y, orient );
Move_Plume_HPGL( wxPoint( ox, oy ), 'U' );
Move_Plume_HPGL( wxPoint( fx, fy ), 'D' );
Plume_HPGL( 'U' ); return;
}
if( size.y == 0 )
{
ox = padpos.x - size.x; oy = padpos.y;
RotatePoint( &ox, &oy, padpos.x, padpos.y, orient );
fx = padpos.x + size.x; fy = padpos.y;
RotatePoint( &fx, &fy, padpos.x, padpos.y, orient );
Move_Plume_HPGL( wxPoint( ox, oy ), 'U' );
Move_Plume_HPGL( wxPoint( fx, fy ), 'D' );
Plume_HPGL( 'U' ); return;
}
ox = padpos.x - size.x; oy = padpos.y - size.y;
RotatePoint( &ox, &oy, padpos.x, padpos.y, orient );
Move_Plume_HPGL( wxPoint( ox, oy ), 'U' );
fx = padpos.x - size.x; fy = padpos.y + size.y;
RotatePoint( &fx, &fy, padpos.x, padpos.y, orient );
Move_Plume_HPGL( wxPoint( fx, fy ), 'D' );
fx = padpos.x + size.x; fy = padpos.y + size.y;
RotatePoint( &fx, &fy, padpos.x, padpos.y, orient );
Move_Plume_HPGL( wxPoint( fx, fy ), 'D' );
fx = padpos.x + size.x; fy = padpos.y - size.y;
RotatePoint( &fx, &fy, padpos.x, padpos.y, orient );
Move_Plume_HPGL( wxPoint( fx, fy ), 'D' );
Move_Plume_HPGL( wxPoint( ox, oy ), 'D' );
if( modetrace != FILLED )
{
Plume_HPGL( 'U' ); return;
}
/* Trace en mode Remplissage */
delta = (int) (pen_diam - pen_recouvrement);
if( delta > 0 )
while( (size.x > 0) && (size.y > 0) )
{
size.x -= delta; size.y -= delta;
if( size.x < 0 )
size.x = 0;if( size.y < 0 )
size.y = 0;
ox = padpos.x - size.x; oy = padpos.y - size.y;
RotatePoint( &ox, &oy, padpos.x, padpos.y, orient );
Move_Plume_HPGL( wxPoint( ox, oy ), 'D' );
fx = padpos.x - size.x; fy = padpos.y + size.y;
RotatePoint( &fx, &fy, padpos.x, padpos.y, orient );
Move_Plume_HPGL( wxPoint( fx, fy ), 'D' );
fx = padpos.x + size.x; fy = padpos.y + size.y;
RotatePoint( &fx, &fy, padpos.x, padpos.y, orient );
Move_Plume_HPGL( wxPoint( fx, fy ), 'D' );
fx = padpos.x + size.x; fy = padpos.y - size.y;
RotatePoint( &fx, &fy, padpos.x, padpos.y, orient );
Move_Plume_HPGL( wxPoint( fx, fy ), 'D' );
Move_Plume_HPGL( wxPoint( ox, oy ), 'D' );
}
Plume_HPGL( 'U' );
}
/********************************************************************/
void trace_1_pad_TRAPEZE_HPGL( wxPoint padpos, wxSize size, wxSize delta,
int orient, int modetrace )
/********************************************************************/
/*
* Trace 1 pad trapezoidal donne par :
* son centre padpos.x,padpos.y
* ses dimensions dimX et dimY
* les variations deltaX et deltaY
* son orientation orient et 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
* . .
* . .
* . .
* 1 --- 2
*/
{
int ii, jj;
wxPoint polygone[4]; /* coord des sommets / centre du pad */
wxPoint coord[4]; /* coord reelles des sommets du trapeze a tracer */
float fangle; /* angle d'inclinaison des cotes du trapeze */
int rayon; /* rayon de la plume */
int moveX, moveY; /* variation de position plume selon axe X et Y , lors
* du remplissage du trapeze */
rayon = (int) pen_rayon; if( modetrace == FILAIRE )
rayon = 0;
moveX = moveY = rayon;
size.x /= 2; size.y /= 2;
delta.x /= 2; delta.y /= 2;
polygone[0].x = -size.x - delta.y; polygone[0].y = +size.y + delta.x;
polygone[1].x = -size.x + delta.y; polygone[1].y = -size.y - delta.x;
polygone[2].x = +size.x - delta.y; polygone[2].y = -size.y + delta.x;
polygone[3].x = +size.x + delta.y; polygone[3].y = +size.y - delta.x;
/* Calcul du demi angle d'inclinaison des cotes du trapeze */
if( delta.y ) /* Trapeze horizontal */
{
fangle = atan2( (double) (polygone[1].y - polygone[0].y),
(double) (polygone[1].x - polygone[0].x) ) / 2;
}
else
{
fangle = atan2( (double) (polygone[3].y - polygone[0].y),
(double) (polygone[3].x - polygone[0].x) ) / 2;
}
/* Trace du contour */
polygone[0].x += moveX; polygone[0].y -= moveY;
polygone[1].x += moveX; polygone[1].y += moveY;
polygone[2].x -= moveX; polygone[2].y += moveY;
polygone[3].x -= moveX; polygone[3].y -= moveY;
for( ii = 0; ii < 4; ii++ )
{
coord[ii].x = polygone[ii].x + padpos.x;
coord[ii].y = polygone[ii].y + padpos.y;
RotatePoint( &coord[ii], padpos, orient );
}
// Plot edge:
Move_Plume_HPGL( coord[0], 'U' );
Move_Plume_HPGL( coord[1], 'D' );
Move_Plume_HPGL( coord[2], 'D' );
Move_Plume_HPGL( coord[3], 'D' );
Move_Plume_HPGL( coord[0], 'D' );
if( modetrace != FILLED )
{
Plume_HPGL( 'U' ); return;
}
/* Fill the shape */
moveX = moveY = pen_diam - pen_recouvrement;
/* calcul de jj = hauteur du remplissage */
if( delta.y ) /* Trapeze horizontal */
{
jj = size.y - (int) ( pen_diam + (2 * pen_recouvrement) );
}
else
{
jj = size.x - (int) ( pen_diam + (2 * pen_recouvrement) );
}
/* Calcul de jj = nombre de segments a tracer pour le remplissage */
jj = jj / (int) (pen_diam - pen_recouvrement);
/* Trace du contour */
for( ; jj > 0; jj-- )
{
polygone[0].x += moveX; polygone[0].y -= moveY;
polygone[1].x += moveX; polygone[1].y += moveY;
polygone[2].x -= moveX; polygone[2].y += moveY;
polygone[3].x -= moveX; polygone[3].y -= moveY;
/* Test de limitation de variation des dimensions :
* si les sommets se "croisent", il ne faut plus modifier les
* coordonnees correspondantes */
if( polygone[0].x > polygone[3].x )
{ /* croisement sur axe X des 2 sommets 0 et 3 */
polygone[0].x = polygone[3].x = 0;
}
if( polygone[1].x > polygone[2].x )
{ /* croisement sur axe X des 2 sommets 1 et 2 */
polygone[1].x = polygone[2].x = 0;
}
if( polygone[1].y > polygone[0].y )
{ /* croisement sur axe Y des 2 sommets 0 et 1 */
polygone[0].y = polygone[1].y = 0;
}
if( polygone[2].y > polygone[3].y )
{ /* croisement sur axe Y des 2 sommets 2 et 3 */
polygone[2].y = polygone[3].y = 0;
}
for( ii = 0; ii < 4; ii++ )
{
coord[ii].x = polygone[ii].x + padpos.x;
coord[ii].y = polygone[ii].y + padpos.y;
RotatePoint( &coord[ii], padpos, orient );
}
Move_Plume_HPGL( coord[0], 'U' );
Move_Plume_HPGL( coord[1], 'D' );
Move_Plume_HPGL( coord[2], 'D' );
Move_Plume_HPGL( coord[3], 'D' );
Move_Plume_HPGL( coord[0], 'D' );
}
Plume_HPGL( 'U' );
}