kicad/common/common_plotHPGL_functions.cpp

/******************************************/
/* Kicad: Common plot HPGL Routines */
/******************************************/

#include "fctsys.h"
#include "gr_basic.h"
#include "trigo.h"
#include "wxstruct.h"
#include "base_struct.h"
#include "common.h"
#include "plot_common.h"
#include "macros.h"

/* parametre HPGL pour trace de cercle: */
#define CHORD_ANGLE 10

// 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;

//Variables locales
void    Move_Plume_HPGL( wxPoint pos, int plume );
void    Plume_HPGL( int plume );


/***********************************************************************************/
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)
 */
{
    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 )
/*****************************************************************/
{
    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;
}


/**********************************/
bool CloseFileHPGL( FILE* plot_file )
/**********************************/
{
    fputs( "PU;PA;SP0;\n", plot_file );
    fclose( plot_file );
    return TRUE;
}


/************************************************************/
void PlotCircle_HPGL( wxPoint centre, int diameter, int width )
/************************************************************/
{
    int  rayon;
    char Line[256];

    UserToDeviceCoordinate( centre );
    rayon = (int) (diameter / 2 * XScale);

    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' ); return;
}


/********************************************************************/
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;
 */
{
    char    Line[256];
    wxPoint cmap;           /* point de depart */
    wxPoint cpos;           /* centre */
    float   angle;          /* angle de l'arc*/

    if( rayon <= 0 )
        return;

    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 );

    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 )
/*****************************************************/

/* 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
 */
{
    int ii;

    if( nb <= 1 )
        return;

    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
 */
{
    char Line[256];

    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 );
}


/***************************/
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';
    }
}