KiCad PCB EDA Suite
common_plotHPGL_functions.cpp
Go to the documentation of this file.
1 /*
2  * This program source code file is part of KiCad, a free EDA CAD application.
3  *
4  * Copyright (C) 2016 Jean-Pierre Charras, jp.charras at wanadoo.fr
5  * Copyright (C) 2016 KiCad Developers, see CHANGELOG.TXT for contributors.
6  *
7  * This program is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License
9  * as published by the Free Software Foundation; either version 2
10  * of the License, or (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, you may find one here:
19  * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
20  * or you may search the http://www.gnu.org website for the version 2 license,
21  * or you may write to the Free Software Foundation, Inc.,
22  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
23  */
24 
33 /* Some HPGL commands:
34  * Note: the HPGL unit is 25 micrometers
35  * All commands MUST be terminated by a semi-colon or a linefeed.
36  * Spaces can NOT be substituted for required commas in the syntax of a command.
37  *
38  *
39  * AA (Arc Absolute): Angle is a floating point # (requires non integer value)
40  * Draws an arc with the center at (X,Y).
41  * A positive angle creates a counter-clockwise arc.
42  * If the chord angle is specified,
43  * this will be the number of degrees used for stepping around the arc.
44  * If no value is given then a default value of five degrees is used.
45  * AA x, y, a {,b};
46  *
47  * AR (Arc Relative):
48  * AR Dx, Dy, a {, b};
49  *
50  * CA (Alternate Character Set):
51  * CA {n};
52  *
53  * CI (Circle):
54  * CI r {,b};
55  *
56  * CP (Character Plot):
57  * CP {h, v};
58  * h [-127.9999 .. 127.9999] Anzahl der Zeichen horizontal
59  * v [-127.9999 .. 127.9999] Anzahl der Zeichen vertikal
60  *
61  * CS (Standard Character Set):
62  * CS {n};
63  *
64  * DR (Relative Direction for Label Text):
65  * DR s, a;
66  *
67  * DI (Absolute Direction for Label Text):
68  * DI {s, a};
69  *
70  * DT (Define Terminator - this character becomes unavailable except to terminate a label string.
71  * Default is ^C control-C):
72  * DT t;
73  *
74  * EA (rEctangle Absolute - Unfilled, from current position to diagonal x,y):
75  * EA x, y;
76  *
77  * ER (rEctangle Relative - Unfilled, from current position to diagonal x,y):
78  * ER x,y;
79  *
80  * FT (Fill Type):
81  * FT {s {,l {a}}};
82  *
83  * IM (Input Mask):
84  * IM {f};
85  *
86  * IN (Initialize): This command instructs the controller to begin processing the HPGL plot file.
87  * Without this, the commands in the file are received but never executed.
88  * If multiple IN s are found during execution of the file,
89  * the controller performs a Pause/Cancel operation.
90  * All motion from the previous job, yet to be executed, is lost,
91  * and the new information is executed.
92  * IN;
93  *
94  * IP Input P1 and P2:
95  * IP {P1x, P1y {, P2x, P2y}};
96  *
97  * IW (Input Window):
98  * IW {XUL, YUL, XOR, YOR};
99  *
100  * LB (Label):
101  * LB c1 .. cn t;
102  *
103  * PA (Plot Absolute): Moves to an absolute HPGL position and sets absolute mode for
104  * future PU and PD commands. If no arguments follow the command,
105  * only absolute mode is set.
106  * PA {x1, y1 {{PU|PD|,} ..., ..., xn, yn}};
107  * P1x, P1y, P2x, P2y [Integer in ASCII]
108  *
109  * PD (Pen Down): Executes <current pen> pen then moves to the requested position
110  * if one is specified. This position is dependent on whether absolute
111  * or relative mode is set. This command performs no motion in 3-D mode,
112  * but the outputs and feedrates are affected.
113  * PD {x, y};
114  *
115  * PM Polygon mode
116  * associated commands:
117  * PM2 End polygon mode
118  * FP Fill polygon
119  * EP Draw polygon outline
120  *
121  * PR (Plot Relative): Moves to the relative position specified and sets relative mode
122  * for future PU and PD commands.
123  * If no arguments follow the command, only relative mode is set.
124  * PR {Dx1, Dy1 {{PU|PD|,} ..., ..., Dxn, Dyn}};
125  *
126  * PS (Paper Size):
127  * PS {n};
128  *
129  * PT (Pen Thickness): in mm
130  * PT {l};
131  *
132  * PU (Pen Up): Executes <current pen> pen then moves to the requested position
133  * if one is specified. This position is dependent on whether absolute
134  * or relative mode is set.
135  * This command performs no motion in 3-D mode, but the outputs
136  * and feedrates are affected.
137  * PU {x, y};
138  *
139  * RA (Rectangle Absolute - Filled, from current position to diagonal x,y):
140  * RA x, y;
141  *
142  * RO (Rotate Coordinate System):
143  * RO;
144  *
145  * RR (Rectangle Relative - Filled, from current position to diagonal x,y):
146  * RR x, y;
147  *
148  * SA (Select Alternate Set):
149  * SA;
150  *
151  * SC (Scale):
152  * SC {Xmin, Xmax, Ymin, Ymax};
153  *
154  * SI (Absolute Character Size):
155  * SI b, h;
156  * b [-127.9999 .. 127.9999, keine 0]
157  * h [-127.9999 .. 127.9999, keine 0]
158  *
159  * SL (Character Slant):
160  * SL {a};
161  * a [-3.5 .. -0.5, 0.5 .. 3.5]
162 *
163  * SP (Select Pen): Selects a new pen or tool for use.
164  * If no pen number or a value of zero is given,
165  * the controller performs an EOF (end of file command).
166  * Once an EOF is performed, no motion is executed,
167  * until a new IN command is received.
168  * SP n;
169  *
170  * SR (Relative Character Size):
171  * SR {b, h};
172  * b [-127.9999 .. 127.9999, keine 0]
173  * h [-127.9999 .. 127.9999, keine 0]
174  *
175  * SS (Select Standard Set):
176  * SS;
177  *
178  * TL (Tick Length):
179  * TL {tp {, tm}};
180  *
181  * UC (User Defined Character):
182  * UC {i,} x1, y1, {i,} x2, y2, ... {i,} xn, yn;
183  *
184  * VS (Velocity Select):
185  * VS {v {, n}};
186  * v [1 .. 40] in cm/s
187  * n [1 .. 8]
188  *
189  * XT (X Tick):
190  * XT;
191  *
192  * YT (Y Tick):
193  * YT;
194  */
195 
196 
197 #include <fctsys.h>
198 #include <gr_basic.h>
199 #include <trigo.h>
200 #include <wxstruct.h>
201 #include <base_struct.h>
202 #include <plot_common.h>
203 #include <macros.h>
204 #include <kicad_string.h>
206 
207 // The hpgl command to close a polygon def, fill it and plot outline:
208 // PM 2; ends the polygon definition and closes it if not closed
209 // FP; fills the polygon
210 // EP; draws the polygon outline. It usually gives a better look to the filled polygon
211 static const char hpgl_end_polygon_cmd[] = "PM 2; FP; EP;\n";
212 
213 // HPGL scale factor (1 PLU = 1/40mm = 25 micrometers)
214 static const double PLUsPERDECIMIL = 0.102041;
215 
217 {
218  SetPenSpeed( 40 ); // Default pen speed = 40 cm/s; Pen speed is *always* in cm
219  SetPenNumber( 1 ); // Default pen num = 1
220  SetPenDiameter( 0.0 );
221 }
222 
223 void HPGL_PLOTTER::SetViewport( const wxPoint& aOffset, double aIusPerDecimil,
224  double aScale, bool aMirror )
225 {
226  wxASSERT( !outputFile );
227  plotOffset = aOffset;
228  plotScale = aScale;
229  m_IUsPerDecimil = aIusPerDecimil;
230  iuPerDeviceUnit = PLUsPERDECIMIL / aIusPerDecimil;
231  /* Compute the paper size in IUs */
233  paperSize.x *= 10.0 * aIusPerDecimil;
234  paperSize.y *= 10.0 * aIusPerDecimil;
235  SetDefaultLineWidth( 0 ); // HPGL has pen sizes instead
236  m_plotMirror = aMirror;
237 }
238 
239 
244 {
245  wxASSERT( outputFile );
246  fprintf( outputFile, "IN;VS%d;PU;PA;SP%d;\n", penSpeed, penNumber );
247 
248  // Set HPGL Pen Thickness (in mm) (usefull in polygon fill command)
249  double penThicknessMM = userToDeviceSize( penDiameter )/40;
250  fprintf( outputFile, "PT %.1f;\n", penThicknessMM );
251 
252  return true;
253 }
254 
255 
260 {
261  wxASSERT( outputFile );
262  fputs( "PU;PA;SP0;\n", outputFile );
263  fclose( outputFile );
264  outputFile = NULL;
265  return true;
266 }
267 
268 
269 void HPGL_PLOTTER::SetPenDiameter( double diameter )
270 {
271  penDiameter = diameter;
272 }
273 
277 void HPGL_PLOTTER::Rect( const wxPoint& p1, const wxPoint& p2, FILL_T fill, int width )
278 {
279  wxASSERT( outputFile );
280  DPOINT p2dev = userToDeviceCoordinates( p2 );
281  MoveTo( p1 );
282  fprintf( outputFile, "EA %.0f,%.0f;\n", p2dev.x, p2dev.y );
283  PenFinish();
284 }
285 
286 
287 // HPGL circle
288 void HPGL_PLOTTER::Circle( const wxPoint& centre, int diameter, FILL_T fill,
289  int width )
290 {
291  wxASSERT( outputFile );
292  double radius = userToDeviceSize( diameter / 2 );
293  SetCurrentLineWidth( width );
294 
295  if( fill == FILLED_SHAPE )
296  {
297  // Draw the filled area
298  MoveTo( centre );
299  fprintf( outputFile, "PM 0; CI %g;\n", radius );
300  fprintf( outputFile, hpgl_end_polygon_cmd ); // Close, fill polygon and draw outlines
301  PenFinish();
302  }
303 
304  if( radius > 0 )
305  {
306  MoveTo( centre );
307  fprintf( outputFile, "CI %g;\n", radius );
308  PenFinish();
309  }
310 }
311 
312 
317 void HPGL_PLOTTER::PlotPoly( const std::vector<wxPoint>& aCornerList,
318  FILL_T aFill, int aWidth, void * aData )
319 {
320  if( aCornerList.size() <= 1 )
321  return;
322 
323  SetCurrentLineWidth( aWidth );
324  MoveTo( aCornerList[0] );
325 
326  if( aFill == FILLED_SHAPE )
327  {
328  // Draw the filled area
330  fprintf( outputFile, "PM 0;\n" ); // Start polygon
331 
332  for( unsigned ii = 1; ii < aCornerList.size(); ++ii )
333  LineTo( aCornerList[ii] );
334 
335  int ii = aCornerList.size() - 1;
336 
337  if( aCornerList[ii] != aCornerList[0] )
338  LineTo( aCornerList[0] );
339 
340  fprintf( outputFile, hpgl_end_polygon_cmd ); // Close, fill polygon and draw outlines
341  }
342  else
343  {
344  // Plot only the polygon outline.
345  for( unsigned ii = 1; ii < aCornerList.size(); ii++ )
346  LineTo( aCornerList[ii] );
347 
348  // Always close polygon if filled.
349  if( aFill )
350  {
351  int ii = aCornerList.size() - 1;
352 
353  if( aCornerList[ii] != aCornerList[0] )
354  LineTo( aCornerList[0] );
355  }
356  }
357 
358  PenFinish();
359 }
360 
361 
365 void HPGL_PLOTTER::penControl( char plume )
366 {
367  wxASSERT( outputFile );
368 
369  switch( plume )
370  {
371  case 'U':
372 
373  if( penState != 'U' )
374  {
375  fputs( "PU;", outputFile );
376  penState = 'U';
377  }
378 
379  break;
380 
381  case 'D':
382 
383  if( penState != 'D' )
384  {
385  fputs( "PD;", outputFile );
386  penState = 'D';
387  }
388 
389  break;
390 
391  case 'Z':
392  fputs( "PU;", outputFile );
393  penState = 'U';
394  penLastpos.x = -1;
395  penLastpos.y = -1;
396  break;
397  }
398 }
399 
400 
401 void HPGL_PLOTTER::PenTo( const wxPoint& pos, char plume )
402 {
403  wxASSERT( outputFile );
404 
405  if( plume == 'Z' )
406  {
407  penControl( 'Z' );
408  return;
409  }
410 
411  penControl( plume );
412  DPOINT pos_dev = userToDeviceCoordinates( pos );
413 
414  if( penLastpos != pos )
415  fprintf( outputFile, "PA %.0f,%.0f;\n", pos_dev.x, pos_dev.y );
416 
417  penLastpos = pos;
418 }
419 
420 
424 void HPGL_PLOTTER::SetDash( bool dashed )
425 {
426  wxASSERT( outputFile );
427 
428  if( dashed )
429  fputs( "LI 2;\n", outputFile );
430  else
431  fputs( "LI;\n", outputFile );
432 }
433 
434 
435 void HPGL_PLOTTER::ThickSegment( const wxPoint& start, const wxPoint& end,
436  int width, EDA_DRAW_MODE_T tracemode, void* aData )
437 {
438  wxASSERT( outputFile );
439  wxPoint center;
440  wxSize size;
441 
442  // Suppress overlap if pen is too big
443  if( penDiameter >= width )
444  {
445  MoveTo( start );
446  FinishTo( end );
447  }
448  else
449  segmentAsOval( start, end, width, tracemode );
450 }
451 
452 
453 /* Plot an arc:
454  * Center = center coord
455  * Stangl, endAngle = angle of beginning and end
456  * Radius = radius of the arc
457  * Command
458  * PU PY x, y; PD start_arc_X AA, start_arc_Y, angle, NbSegm; PU;
459  * Or PU PY x, y; PD start_arc_X AA, start_arc_Y, angle, PU;
460  */
461 void HPGL_PLOTTER::Arc( const wxPoint& centre, double StAngle, double EndAngle, int radius,
462  FILL_T fill, int width )
463 {
464  wxASSERT( outputFile );
465  double angle;
466 
467  if( radius <= 0 )
468  return;
469 
470  DPOINT centre_dev = userToDeviceCoordinates( centre );
471 
472  if( m_plotMirror )
473  angle = StAngle - EndAngle;
474  else
475  angle = EndAngle - StAngle;
476 
477  NORMALIZE_ANGLE_180( angle );
478  angle /= 10;
479 
480  // Calculate arc start point:
481  wxPoint cmap;
482  cmap.x = centre.x + KiROUND( cosdecideg( radius, StAngle ) );
483  cmap.y = centre.y - KiROUND( sindecideg( radius, StAngle ) );
484  DPOINT cmap_dev = userToDeviceCoordinates( cmap );
485 
486  fprintf( outputFile,
487  "PU;PA %.0f,%.0f;PD;AA %.0f,%.0f,",
488  cmap_dev.x, cmap_dev.y,
489  centre_dev.x, centre_dev.y );
490  fprintf( outputFile, "%.0f", angle );
491  fprintf( outputFile, ";PU;\n" );
492  PenFinish();
493 }
494 
495 
496 /* Plot oval pad.
497  */
498 void HPGL_PLOTTER::FlashPadOval( const wxPoint& pos, const wxSize& aSize, double orient,
499  EDA_DRAW_MODE_T trace_mode, void* aData )
500 {
501  wxASSERT( outputFile );
502  int deltaxy, cx, cy;
503  wxSize size( aSize );
504 
505  /* The pad will be drawn as an oblong shape with size.y > size.x
506  * (Oval vertical orientation 0)
507  */
508  if( size.x > size.y )
509  {
510  std::swap( size.x, size.y );
511  orient = AddAngles( orient, 900 );
512  }
513 
514  deltaxy = size.y - size.x; // distance between centers of the oval
515 
516  if( trace_mode == FILLED )
517  {
518  FlashPadRect( pos, wxSize( size.x, deltaxy + KiROUND( penDiameter ) ),
519  orient, trace_mode, aData );
520  cx = 0; cy = deltaxy / 2;
521  RotatePoint( &cx, &cy, orient );
522  FlashPadCircle( wxPoint( cx + pos.x, cy + pos.y ), size.x, trace_mode, aData );
523  cx = 0; cy = -deltaxy / 2;
524  RotatePoint( &cx, &cy, orient );
525  FlashPadCircle( wxPoint( cx + pos.x, cy + pos.y ), size.x, trace_mode, aData );
526  }
527  else // Plot in outline mode.
528  {
529  sketchOval( pos, size, orient, KiROUND( penDiameter ) );
530  }
531 }
532 
533 
534 /* Plot round pad or via.
535  */
536 void HPGL_PLOTTER::FlashPadCircle( const wxPoint& pos, int diametre,
537  EDA_DRAW_MODE_T trace_mode, void* aData )
538 {
539  wxASSERT( outputFile );
540  DPOINT pos_dev = userToDeviceCoordinates( pos );
541 
542  int radius = diametre / 2;
543 
544  if( trace_mode == FILLED )
545  {
546  // if filled mode, the pen diameter is removed from diameter
547  // to keep the pad size
548  radius -= KiROUND( penDiameter ) / 2;
549  }
550 
551  if( radius < 0 )
552  radius = 0;
553 
554  double rsize = userToDeviceSize( radius );
555 
556  if( trace_mode == FILLED ) // Plot in filled mode.
557  {
558  // A filled polygon uses always the current point to start the polygon.
559  // Gives a correct current starting point for the circle
560  MoveTo( wxPoint( pos.x+radius, pos.y ) );
561  // Plot filled area and its outline
562  fprintf( outputFile, "PM 0; PA %.0f,%.0f;CI %.0f;%s",
563  pos_dev.x, pos_dev.y, rsize, hpgl_end_polygon_cmd );
564  }
565  else
566  {
567  // Draw outline only:
568  fprintf( outputFile, "PA %.0f,%.0f;CI %.0f;\n",
569  pos_dev.x, pos_dev.y, rsize );
570  }
571 
572  PenFinish();
573 }
574 
575 
576 void HPGL_PLOTTER::FlashPadRect( const wxPoint& pos, const wxSize& padsize,
577  double orient, EDA_DRAW_MODE_T trace_mode, void* aData )
578 {
579  // Build rect polygon:
580  std::vector<wxPoint> corners;
581 
582  int dx = padsize.x / 2;
583  int dy = padsize.y / 2;
584 
585  if( trace_mode == FILLED )
586  {
587  // in filled mode, the pen diameter is removed from size
588  // to compensate the extra size due to this pen size
589  dx -= KiROUND( penDiameter ) / 2;
590  dx = std::max( dx, 0);
591  dy -= KiROUND( penDiameter ) / 2;
592  dy = std::max( dy, 0);
593  }
594 
595 
596  corners.push_back( wxPoint( - dx, - dy ) );
597  corners.push_back( wxPoint( - dx, + dy ) );
598  corners.push_back( wxPoint( + dx, + dy ) );
599  corners.push_back( wxPoint( + dx, - dy ) );
600 
601 
602  for( unsigned ii = 0; ii < corners.size(); ii++ )
603  {
604  RotatePoint( &corners[ii], orient );
605  corners[ii] += pos;
606  }
607 
608  PlotPoly( corners, trace_mode == FILLED ? FILLED_SHAPE : NO_FILL );
609 }
610 
611 
612 void HPGL_PLOTTER::FlashPadRoundRect( const wxPoint& aPadPos, const wxSize& aSize,
613  int aCornerRadius, double aOrient,
614  EDA_DRAW_MODE_T aTraceMode, void* aData )
615 {
616  SHAPE_POLY_SET outline;
617  const int segmentToCircleCount = 32;
618 
619  wxSize size = aSize;
620 
621  if( aTraceMode == FILLED )
622  {
623  // in filled mode, the pen diameter is removed from size
624  // to keep the pad size
625  size.x -= KiROUND( penDiameter ) / 2;
626  size.x = std::max( size.x, 0);
627  size.y -= KiROUND( penDiameter ) / 2;
628  size.y = std::max( size.y, 0);
629 
630  // keep aCornerRadius to a value < min size x,y < 2:
631  aCornerRadius = std::min( aCornerRadius, std::min( size.x, size.y ) /2 );
632  }
633 
634  TransformRoundRectToPolygon( outline, aPadPos, size, aOrient,
635  aCornerRadius, segmentToCircleCount );
636 
637  // TransformRoundRectToPolygon creates only one convex polygon
638  std::vector< wxPoint > cornerList;
639  cornerList.reserve( segmentToCircleCount + 4 );
640  SHAPE_LINE_CHAIN& poly = outline.Outline( 0 );
641 
642  for( int ii = 0; ii < poly.PointCount(); ++ii )
643  cornerList.push_back( wxPoint( poly.Point( ii ).x, poly.Point( ii ).y ) );
644 
645  PlotPoly( cornerList, aTraceMode == FILLED ? FILLED_SHAPE : NO_FILL );
646 }
647 
648 void HPGL_PLOTTER::FlashPadCustom( const wxPoint& aPadPos, const wxSize& aSize,
649  SHAPE_POLY_SET* aPolygons,
650  EDA_DRAW_MODE_T aTraceMode, void* aData )
651 {
652  std::vector< wxPoint > cornerList;
653 
654  for( int cnt = 0; cnt < aPolygons->OutlineCount(); ++cnt )
655  {
656  SHAPE_LINE_CHAIN& poly = aPolygons->Outline( cnt );
657 
658  cornerList.clear();
659  cornerList.reserve( poly.PointCount() );
660 
661  for( int ii = 1; ii < poly.PointCount(); ++ii )
662  cornerList.push_back( wxPoint( poly.Point( ii ).x, poly.Point( ii ).y ) );
663 
664  PlotPoly( cornerList, aTraceMode == FILLED ? FILLED_SHAPE : NO_FILL );
665  }
666 }
667 
668 
669 void HPGL_PLOTTER::FlashPadTrapez( const wxPoint& aPadPos, const wxPoint* aCorners,
670  double aPadOrient, EDA_DRAW_MODE_T aTrace_Mode, void* aData )
671 {
672  std::vector< wxPoint > cornerList;
673  cornerList.reserve( 4 );
674 
675  for( int ii = 0; ii < 4; ii++ )
676  {
677  wxPoint coord( aCorners[ii] );
678  RotatePoint( &coord, aPadOrient );
679  coord += aPadPos;
680  cornerList.push_back( coord );
681  }
682 
683  PlotPoly( cornerList, aTrace_Mode == FILLED ? FILLED_SHAPE : NO_FILL );
684 }
void FinishTo(const wxPoint &pos)
Definition: plot_common.h:241
virtual bool EndPlot() override
HPGL end of plot: pen return and release.
void PenFinish()
Definition: plot_common.h:247
virtual void PlotPoly(const std::vector< wxPoint > &aCornerList, FILL_T aFill, int aWidth=USE_DEFAULT_LINE_WIDTH, void *aData=NULL) override
HPGL polygon:
static int KiROUND(double v)
KiROUND rounds a floating point number to an int using "round halfway cases away from zero"...
Definition: common.h:107
virtual void FlashPadTrapez(const wxPoint &aPadPos, const wxPoint *aCorners, double aPadOrient, EDA_DRAW_MODE_T aTrace_Mode, void *aData) override
virtual function FlashPadTrapez flash a trapezoidal pad
int PointCount() const
Function PointCount()
void TransformRoundRectToPolygon(SHAPE_POLY_SET &aCornerBuffer, const wxPoint &aPosition, const wxSize &aSize, double aRotation, int aCornerRadius, int aCircleToSegmentsCount)
Function TransformRoundRectToPolygon convert a rectangle with rounded corners to a polygon Convert ar...
virtual void SetPenDiameter(double diameter)
virtual void ThickSegment(const wxPoint &start, const wxPoint &end, int width, EDA_DRAW_MODE_T tracemode, void *aData) override
void RotatePoint(int *pX, int *pY, double angle)
Definition: trigo.cpp:317
char penState
Current pen state: 'U', 'D' or 'Z' (see PenTo)
Definition: plot_common.h:542
void NORMALIZE_ANGLE_180(T &Angle)
Definition: trigo.h:292
int OutlineCount() const
Returns the number of outlines in the set
double m_IUsPerDecimil
Definition: plot_common.h:519
virtual void SetDash(bool dashed) override
HPGL supports dashed lines.
virtual bool StartPlot() override
At the start of the HPGL plot pen speed and number are requested.
virtual void SetDefaultLineWidth(int width) override
Set the default line width.
Definition: plot_common.h:581
wxPoint plotOffset
Plot offset (in IUs)
Definition: plot_common.h:525
wxPoint penLastpos
Last pen positions; set to -1,-1 when the pen is at rest.
Definition: plot_common.h:544
PAGE_INFO pageInfo
Definition: plot_common.h:548
static const double PLUsPERDECIMIL
This file contains miscellaneous commonly used macros and functions.
const wxSize & GetSizeMils() const
virtual void SetViewport(const wxPoint &aOffset, double aIusPerDecimil, double aScale, bool aMirror) override
Set the plot offset and scaling for the current plot.
virtual void Rect(const wxPoint &p1, const wxPoint &p2, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH) override
HPGL rectangle: fill not supported.
virtual void FlashPadRoundRect(const wxPoint &aPadPos, const wxSize &aSize, int aCornerRadius, double aOrient, EDA_DRAW_MODE_T aTraceMode, void *aData) override
virtual function FlashPadRoundRect
static const char hpgl_end_polygon_cmd[]
void LineTo(const wxPoint &pos)
Definition: plot_common.h:236
static const int USE_DEFAULT_LINE_WIDTH
Definition: plot_common.h:95
bool m_plotMirror
X axis orientation (SVG) and plot mirrored (only for PS, PDF HPGL and SVG)
Definition: plot_common.h:529
virtual void SetCurrentLineWidth(int width, void *aData=NULL) override
HPGL doesn't handle line thickness or color.
Definition: plot_common.h:575
T AddAngles(T a1, T2 a2)
Add two angles (keeping the result normalized). T2 is here.
Definition: trigo.h:246
Class SHAPE_POLY_SET.
Base window classes and related definitions.
SHAPE_LINE_CHAIN & Outline(int aIndex)
Returns the reference to aIndex-th outline in the set
EDA_DRAW_MODE_T
Definition: eda_text.h:62
virtual void SetPenSpeed(int speed)
Definition: plot_common.h:586
virtual void FlashPadCircle(const wxPoint &pos, int diametre, EDA_DRAW_MODE_T trace_mode, void *aData) override
virtual function FlashPadCircle
double plotScale
Plot scale - chosen by the user (even implicitly with 'fit in a4')
Definition: plot_common.h:513
Common plot library Plot settings, and plotting engines (Postscript, Gerber, HPGL and DXF) ...
virtual void PenTo(const wxPoint &pos, char plume) override
moveto/lineto primitive, moves the 'pen' to the specified direction
virtual void FlashPadRect(const wxPoint &pos, const wxSize &size, double orient, EDA_DRAW_MODE_T trace_mode, void *aData) override
virtual function FlashPadRect
virtual DPOINT userToDeviceSize(const wxSize &size)
Modifies size according to the plotter scale factors (wxSize version, returns a DPOINT) ...
void MoveTo(const wxPoint &pos)
Definition: plot_common.h:231
virtual DPOINT userToDeviceCoordinates(const wxPoint &aCoordinate)
Modifies coordinates according to the orientation, scale factor, and offsets trace.
double cosdecideg(double r, double a)
Circle generation utility: computes r * cos(a) Where a is in decidegrees, not in radians.
Definition: trigo.h:311
double sindecideg(double r, double a)
Circle generation utility: computes r * sin(a) Where a is in decidegrees, not in radians.
Definition: trigo.h:302
#define max(a, b)
Definition: auxiliary.h:86
Class SHAPE_LINE_CHAIN.
static DIRECTION_45::AngleType angle(const VECTOR2I &a, const VECTOR2I &b)
double penDiameter
Definition: plot_common.h:633
virtual void SetPenNumber(int number)
Definition: plot_common.h:591
FILE * outputFile
true if the Y axis is top to bottom (SVG)
Definition: plot_common.h:534
FILL_T
Enum FILL_T is the set of fill types used in plotting or drawing enclosed areas.
Definition: base_struct.h:56
VECTOR2I & Point(int aIndex)
Function Point()
Basic classes for most KiCad items.
void penControl(char plume)
Pen control logic (remove redundant pen activations)
virtual void FlashPadCustom(const wxPoint &aPadPos, const wxSize &aSize, SHAPE_POLY_SET *aPolygons, EDA_DRAW_MODE_T aTraceMode, void *aData) override
virtual function FlashPadCustom
double iuPerDeviceUnit
Device scale (from IUs to plotter device units - usually decimils)
Definition: plot_common.h:522
void segmentAsOval(const wxPoint &start, const wxPoint &end, int width, EDA_DRAW_MODE_T tracemode)
Cdonvert a thick segment and plot it as an oval.
virtual void Circle(const wxPoint &pos, int diametre, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH) override
void sketchOval(const wxPoint &pos, const wxSize &size, double orient, int width)
wxSize paperSize
Paper size in IU - not in mils.
Definition: plot_common.h:550
virtual void FlashPadOval(const wxPoint &pos, const wxSize &size, double orient, EDA_DRAW_MODE_T trace_mode, void *aData) override
virtual function FlashPadOval
#define min(a, b)
Definition: auxiliary.h:85
virtual void Arc(const wxPoint &centre, double StAngle, double EndAngle, int rayon, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH) override
Generic fallback: arc rendered as a polyline.