KiCad PCB EDA Suite
SVG_plotter.cpp
Go to the documentation of this file.
1 
6 /*
7  * This program source code file is part of KiCad, a free EDA CAD application.
8  *
9  * Copyright (C) 2017 Jean-Pierre Charras, jp.charras at wanadoo.fr
10  * Copyright (C) 1992-2017 KiCad Developers, see AUTHORS.txt for contributors.
11  *
12  * This program is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU General Public License
14  * as published by the Free Software Foundation; either version 2
15  * of the License, or (at your option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, you may find one here:
24  * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
25  * or you may search the http://www.gnu.org website for the version 2 license,
26  * or you may write to the Free Software Foundation, Inc.,
27  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
28  */
29 
30 /* Some info on basic items SVG format, used here:
31  * The root element of all SVG files is the <svg> element.
32  *
33  * The <g> element is used to group SVG shapes together.
34  * Once grouped you can transform the whole group of shapes as if it was a single shape.
35  * This is an advantage compared to a nested <svg> element
36  * which cannot be the target of transformation by itself.
37  *
38  * The <rect> element represents a rectangle.
39  * Using this element you can draw rectangles of various width, height,
40  * with different stroke (outline) and fill colors, with sharp or rounded corners etc.
41  *
42  * <svg xmlns="http://www.w3.org/2000/svg"
43  * xmlns:xlink="http://www.w3.org/1999/xlink">
44  *
45  * <rect x="10" y="10" height="100" width="100"
46  * style="stroke:#006600; fill: #00cc00"/>
47  *
48  * </svg>
49  *
50  * The <circle> element is used to draw circles.
51  * <circle cx="40" cy="40" r="24" style="stroke:#006600; fill:#00cc00"/>
52  *
53  * The <ellipse> element is used to draw ellipses.
54  * An ellipse is a circle that does not have equal height and width.
55  * Its radius in the x and y directions are different, in other words.
56  * <ellipse cx="40" cy="40" rx="30" ry="15"
57  * style="stroke:#006600; fill:#00cc00"/>
58  *
59  * The <line> element is used to draw lines.
60  *
61  * <line x1="0" y1="10" x2="0" y2="100" style="stroke:#006600;"/>
62  * <line x1="10" y1="10" x2="100" y2="100" style="stroke:#006600;"/>
63  *
64  * The <polyline> element is used to draw multiple connected lines
65  * Here is a simple example:
66  *
67  * <polyline points="0,0 30,0 15,30" style="stroke:#006600;"/>
68  *
69  * The <polygon> element is used to draw with multiple (3 or more) sides / edges.
70  * Here is a simple example:
71  *
72  * <polygon points="0,0 50,0 25,50" style="stroke:#660000; fill:#cc3333;"/>
73  *
74  * The <path> element is used to draw advanced shapes combined from lines and arcs,
75  * with or without fill.
76  * It is probably the most advanced and versatile SVG shape of them all.
77  * It is probably also the hardest element to master.
78  * <path d="M50,50
79  * A30,30 0 0,1 35,20
80  * L100,100
81  * M110,110
82  * L100,0"
83  * style="stroke:#660000; fill:none;"/>
84  *
85  * Draw an elliptic arc: it is one of basic path command:
86  * <path d="M(startx,starty) A(radiusx,radiusy)
87  * rotation-axe-x
88  * flag_arc_large,flag_sweep endx,endy">
89  * flag_arc_large: 0 = small arc > 180 deg, 1 = large arc > 180 deg
90  * flag_sweep : 0 = CCW, 1 = CW
91  * The center of ellipse is automatically calculated.
92  */
93 #include <fctsys.h>
94 #include <trigo.h>
95 #include <eda_base_frame.h>
96 #include <eda_rect.h>
97 #include <base_struct.h>
98 #include <common.h>
99 #include <plotter.h>
100 #include <macros.h>
101 #include <kicad_string.h>
102 
103 
104 
111 static wxString XmlEsc( const wxString& aStr, bool isAttribute = false )
112 {
113  wxString escaped;
114 
115  escaped.reserve( aStr.length() );
116 
117  for( wxString::const_iterator it = aStr.begin(); it != aStr.end(); ++it )
118  {
119  const wxChar c = *it;
120 
121  switch( c )
122  {
123  case wxS( '<' ):
124  escaped.append( wxS( "&lt;" ) );
125  break;
126  case wxS( '>' ):
127  escaped.append( wxS( "&gt;" ) );
128  break;
129  case wxS( '&' ):
130  escaped.append( wxS( "&amp;" ) );
131  break;
132  case wxS( '\r' ):
133  escaped.append( wxS( "&#xD;" ) );
134  break;
135  default:
136  if( isAttribute )
137  {
138  switch( c )
139  {
140  case wxS( '"' ):
141  escaped.append( wxS( "&quot;" ) );
142  break;
143  case wxS( '\t' ):
144  escaped.append( wxS( "&#x9;" ) );
145  break;
146  case wxS( '\n' ):
147  escaped.append( wxS( "&#xA;" ));
148  break;
149  default:
150  escaped.append(c);
151  }
152  }
153  else
154  escaped.append(c);
155  }
156  }
157 
158  return escaped;
159 }
160 
161 
163 {
164  m_graphics_changed = true;
166  m_fillMode = NO_FILL; // or FILLED_SHAPE or FILLED_WITH_BG_BODYCOLOR
167  m_pen_rgb_color = 0; // current color value (black)
168  m_brush_rgb_color = 0; // current color value (black)
169  m_dashed = false;
170 }
171 
172 
173 void SVG_PLOTTER::SetViewport( const wxPoint& aOffset, double aIusPerDecimil,
174  double aScale, bool aMirror )
175 {
176  m_plotMirror = aMirror;
177  m_yaxisReversed = true; // unlike other plotters, SVG has Y axis reversed
178  plotOffset = aOffset;
179  plotScale = aScale;
180  m_IUsPerDecimil = aIusPerDecimil;
181  iuPerDeviceUnit = 1.0 / aIusPerDecimil;
182  /* Compute the paper size in IUs */
184  paperSize.x *= 10.0 * aIusPerDecimil;
185  paperSize.y *= 10.0 * aIusPerDecimil;
186  SetDefaultLineWidth( 100 * aIusPerDecimil ); // arbitrary default
187 }
188 
189 
191 {
193 
194  if( m_graphics_changed )
195  setSVGPlotStyle();
196 }
197 
198 
200 {
201  if( m_fillMode != fill )
202  {
203  m_graphics_changed = true;
204  m_fillMode = fill;
205  }
206 }
207 
208 
209 void SVG_PLOTTER::setSVGPlotStyle( bool aIsGroup, const std::string& aExtraStyle )
210 {
211  if( aIsGroup )
212  fputs( "</g>\n<g ", outputFile );
213 
214  // output the background fill color
215  fprintf( outputFile, "style=\"fill:#%6.6lX; ", m_brush_rgb_color );
216 
217  switch( m_fillMode )
218  {
219  case NO_FILL:
220  fputs( "fill-opacity:0.0; ", outputFile );
221  break;
222 
223  case FILLED_SHAPE:
224  fputs( "fill-opacity:1.0; ", outputFile );
225  break;
226 
228  fputs( "fill-opacity:0.6; ", outputFile );
229  break;
230  }
231 
232  double pen_w = userToDeviceSize( GetCurrentLineWidth() );
233  fprintf( outputFile, "\nstroke:#%6.6lX; stroke-width:%g; stroke-opacity:1; \n",
234  m_pen_rgb_color, pen_w );
235  fputs( "stroke-linecap:round; stroke-linejoin:round;", outputFile );
236 
237  switch( m_dashed )
238  {
239  case PLOTDASHTYPE_DASH:
240  fprintf( outputFile, "stroke-dasharray:%g,%g;",
242  break;
243  case PLOTDASHTYPE_DOT:
244  fprintf( outputFile, "stroke-dasharray:%g,%g;",
246  break;
248  fprintf( outputFile, "stroke-dasharray:%g,%g,%g,%g;",
250  break;
251  }
252 
253  if( aExtraStyle.length() )
254  {
255  fputs( aExtraStyle.c_str(), outputFile );
256  }
257 
258  fputs( "\"", outputFile );
259 
260  if( aIsGroup )
261  {
262  fputs( ">", outputFile );
263  m_graphics_changed = false;
264  }
265 
266  fputs( "\n", outputFile );
267 }
268 
269 /* Set the current line width (in IUs) for the next plot
270  */
271 void SVG_PLOTTER::SetCurrentLineWidth( int width, void* aData )
272 {
273  int pen_width;
274 
275  if( width >= 0 )
276  pen_width = width;
277  else
278  pen_width = defaultPenWidth;
279 
280  if( pen_width != currentPenWidth )
281  {
282  m_graphics_changed = true;
283  currentPenWidth = pen_width;
284  }
285 
286  if( m_graphics_changed )
287  setSVGPlotStyle();
288 }
289 
290 
291 void SVG_PLOTTER::StartBlock( void* aData )
292 {
293  std::string* idstr = reinterpret_cast<std::string*>( aData );
294 
295  fputs( "<g ", outputFile );
296  if( idstr )
297  fprintf( outputFile, "id=\"%s\"", idstr->c_str() );
298 
299  fprintf( outputFile, ">\n" );
300 }
301 
302 
303 void SVG_PLOTTER::EndBlock( void* aData )
304 {
305  fprintf( outputFile, "</g>\n" );
306 }
307 
308 
309 /* initialize m_red, m_green, m_blue ( 0 ... 255)
310  * from reduced values r, g ,b ( 0.0 to 1.0 )
311  */
312 void SVG_PLOTTER::emitSetRGBColor( double r, double g, double b )
313 {
314  int red = (int) ( 255.0 * r );
315  int green = (int) ( 255.0 * g );
316  int blue = (int) ( 255.0 * b );
317  long rgb_color = (red << 16) | (green << 8) | blue;
318 
319  if( m_pen_rgb_color != rgb_color )
320  {
321  m_graphics_changed = true;
322  m_pen_rgb_color = rgb_color;
323 
324  // Currently, use the same color for brush and pen
325  // (i.e. to draw and fill a contour)
326  m_brush_rgb_color = rgb_color;
327  }
328 }
329 
330 
334 void SVG_PLOTTER::SetDash( int dashed )
335 {
336  if( m_dashed != dashed )
337  {
338  m_graphics_changed = true;
339  m_dashed = dashed;
340  }
341 
342  if( m_graphics_changed )
343  setSVGPlotStyle();
344 }
345 
346 
347 void SVG_PLOTTER::Rect( const wxPoint& p1, const wxPoint& p2, FILL_T fill, int width )
348 {
349  EDA_RECT rect( p1, wxSize( p2.x -p1.x, p2.y -p1.y ) );
350  rect.Normalize();
351  DPOINT org_dev = userToDeviceCoordinates( rect.GetOrigin() );
352  DPOINT end_dev = userToDeviceCoordinates( rect.GetEnd() );
353  DSIZE size_dev = end_dev - org_dev;
354  // Ensure size of rect in device coordinates is > 0
355  // I don't know if this is a SVG issue or a Inkscape issue, but
356  // Inkscape has problems with negative or null values for width and/or height, so avoid them
357  DBOX rect_dev( org_dev, size_dev);
358  rect_dev.Normalize();
359 
360  setFillMode( fill );
362 
363  // Rectangles having a 0 size value for height or width are just not drawn on Inscape,
364  // so use a line when happens.
365  if( rect_dev.GetSize().x == 0.0 || rect_dev.GetSize().y == 0.0 ) // Draw a line
366  fprintf( outputFile,
367  "<line x1=\"%g\" y1=\"%g\" x2=\"%g\" y2=\"%g\" />\n",
368  rect_dev.GetPosition().x, rect_dev.GetPosition().y,
369  rect_dev.GetEnd().x, rect_dev.GetEnd().y
370  );
371 
372  else
373  fprintf( outputFile,
374  "<rect x=\"%g\" y=\"%g\" width=\"%g\" height=\"%g\" rx=\"%g\" />\n",
375  rect_dev.GetPosition().x, rect_dev.GetPosition().y,
376  rect_dev.GetSize().x, rect_dev.GetSize().y,
377  0.0 // radius of rounded corners
378  );
379 }
380 
381 
382 void SVG_PLOTTER::Circle( const wxPoint& pos, int diametre, FILL_T fill, int width )
383 {
384  DPOINT pos_dev = userToDeviceCoordinates( pos );
385  double radius = userToDeviceSize( diametre / 2.0 );
386 
387  setFillMode( fill );
389 
390  // If diameter is less than width, switch to filled mode
391  if( fill == NO_FILL && diametre < width )
392  {
394  SetCurrentLineWidth( 0 );
395 
396  radius = userToDeviceSize( ( diametre / 2.0 ) + ( width / 2.0 ) );
397  }
398 
399  fprintf( outputFile,
400  "<circle cx=\"%g\" cy=\"%g\" r=\"%g\" /> \n",
401  pos_dev.x, pos_dev.y, radius );
402 }
403 
404 
405 void SVG_PLOTTER::Arc( const wxPoint& centre, double StAngle, double EndAngle, int radius,
406  FILL_T fill, int width )
407 {
408  /* Draws an arc of a circle, centred on (xc,yc), with starting point
409  * (x1, y1) and ending at (x2, y2). The current pen is used for the outline
410  * and the current brush for filling the shape.
411  *
412  * The arc is drawn in an anticlockwise direction from the start point to
413  * the end point
414  */
415 
416  if( radius <= 0 )
417  {
418  Circle( centre, width, FILLED_SHAPE, 0 );
419  return;
420  }
421 
422  if( StAngle > EndAngle )
423  std::swap( StAngle, EndAngle );
424 
425  setFillMode( fill );
427 
428  // Calculate start point.
429  DPOINT centre_dev = userToDeviceCoordinates( centre );
430  double radius_dev = userToDeviceSize( radius );
431 
432  if( !m_yaxisReversed ) // Should be never the case
433  {
434  double tmp = StAngle;
435  StAngle = -EndAngle;
436  EndAngle = -tmp;
437  }
438 
439  if( m_plotMirror )
440  {
442  {
443  StAngle = 1800.0 -StAngle;
444  EndAngle = 1800.0 -EndAngle;
445  std::swap( StAngle, EndAngle );
446  }
447  else
448  {
449  StAngle = -StAngle;
450  EndAngle = -EndAngle;
451  }
452  }
453 
454  DPOINT start;
455  start.x = radius_dev;
456  RotatePoint( &start.x, &start.y, StAngle );
457  DPOINT end;
458  end.x = radius_dev;
459  RotatePoint( &end.x, &end.y, EndAngle );
460  start += centre_dev;
461  end += centre_dev;
462 
463  double theta1 = DECIDEG2RAD( StAngle );
464 
465  if( theta1 < 0 )
466  theta1 = theta1 + M_PI * 2;
467 
468  double theta2 = DECIDEG2RAD( EndAngle );
469 
470  if( theta2 < 0 )
471  theta2 = theta2 + M_PI * 2;
472 
473  if( theta2 < theta1 )
474  theta2 = theta2 + M_PI * 2;
475 
476  int flg_arc = 0; // flag for large or small arc. 0 means less than 180 degrees
477 
478  if( fabs( theta2 - theta1 ) > M_PI )
479  flg_arc = 1;
480 
481  int flg_sweep = 0; // flag for sweep always 0
482 
483  // Draw a single arc: an arc is one of 3 curve commands (2 other are 2 bezier curves)
484  // params are start point, radius1, radius2, X axe rotation,
485  // flag arc size (0 = small arc > 180 deg, 1 = large arc > 180 deg),
486  // sweep arc ( 0 = CCW, 1 = CW),
487  // end point
488  fprintf( outputFile, "<path d=\"M%g %g A%g %g 0.0 %d %d %g %g \" />\n",
489  start.x, start.y, radius_dev, radius_dev,
490  flg_arc, flg_sweep,
491  end.x, end.y );
492 }
493 
494 
495 void SVG_PLOTTER::PlotPoly( const std::vector<wxPoint>& aCornerList,
496  FILL_T aFill, int aWidth, void * aData )
497 {
498  if( aCornerList.size() <= 1 )
499  return;
500 
501  setFillMode( aFill );
502  SetCurrentLineWidth( aWidth );
503  fprintf( outputFile, "<path ");
504 
505  switch( aFill )
506  {
507  case NO_FILL:
508  setSVGPlotStyle( false, "fill:none" );
509  break;
510 
512  case FILLED_SHAPE:
513  setSVGPlotStyle( false, "fill-rule:evenodd;" );
514  break;
515  }
516 
517  DPOINT pos = userToDeviceCoordinates( aCornerList[0] );
518  fprintf( outputFile, "d=\"M %d,%d\n", (int) pos.x, (int) pos.y );
519 
520  for( unsigned ii = 1; ii < aCornerList.size(); ii++ )
521  {
522  pos = userToDeviceCoordinates( aCornerList[ii] );
523  fprintf( outputFile, "%d,%d\n", (int) pos.x, (int) pos.y );
524  }
525 
526  fprintf( outputFile, "Z\" /> \n" );
527 }
528 
529 
533 void SVG_PLOTTER::PlotImage( const wxImage& aImage, const wxPoint& aPos,
534  double aScaleFactor )
535 {
536  // in svg file we must insert a link to a png image file to plot an image
537  // the image itself is not included in the svg file.
538  // So we prefer skip the image, and just draw a rectangle,
539  // like other plotters which do not support images
540 
541  PLOTTER::PlotImage( aImage, aPos, aScaleFactor );
542 
543 }
544 
545 
546 void SVG_PLOTTER::PenTo( const wxPoint& pos, char plume )
547 {
548  if( plume == 'Z' )
549  {
550  if( penState != 'Z' )
551  {
552  fputs( "\" />\n", outputFile );
553  penState = 'Z';
554  penLastpos.x = -1;
555  penLastpos.y = -1;
556  }
557 
558  return;
559  }
560 
561  if( penState == 'Z' ) // here plume = 'D' or 'U'
562  {
563  DPOINT pos_dev = userToDeviceCoordinates( pos );
564 
565  // Ensure we do not use a fill mode when moving tne pen,
566  // in SVG mode (i;e. we are plotting only basic lines, not a filled area
567  if( m_fillMode != NO_FILL )
568  {
569  setFillMode( NO_FILL );
570  setSVGPlotStyle();
571  }
572 
573  fprintf( outputFile, "<path d=\"M%d %d\n",
574  (int) pos_dev.x, (int) pos_dev.y );
575  }
576  else if( penState != plume || pos != penLastpos )
577  {
578  DPOINT pos_dev = userToDeviceCoordinates( pos );
579  fprintf( outputFile, "L%d %d\n",
580  (int) pos_dev.x, (int) pos_dev.y );
581  }
582 
583  penState = plume;
584  penLastpos = pos;
585 }
586 
587 
593 {
594  wxASSERT( outputFile );
595  wxString msg;
596 
597  static const char* header[] =
598  {
599  "<?xml version=\"1.0\" standalone=\"no\"?>\n",
600  " <!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \n",
601  " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\"> \n",
602  "<svg xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\" \n",
603  NULL
604  };
605 
606  // Write header.
607  for( int ii = 0; header[ii] != NULL; ii++ )
608  {
609  fputs( header[ii], outputFile );
610  }
611 
612  // Write viewport pos and size
613  wxPoint origin; // TODO set to actual value
614  fprintf( outputFile,
615  " width=\"%gcm\" height=\"%gcm\" viewBox=\"%d %d %d %d \">\n",
616  (double) paperSize.x / m_IUsPerDecimil * 2.54 / 10000,
617  (double) paperSize.y / m_IUsPerDecimil * 2.54 / 10000,
618  origin.x, origin.y,
619  (int) ( paperSize.x / m_IUsPerDecimil ),
620  (int) ( paperSize.y / m_IUsPerDecimil) );
621 
622  // Write title
623  char date_buf[250];
624  time_t ltime = time( NULL );
625  strftime( date_buf, 250, "%Y/%m/%d %H:%M:%S",
626  localtime( &ltime ) );
627 
628  fprintf( outputFile,
629  "<title>SVG Picture created as %s date %s </title>\n",
630  TO_UTF8( XmlEsc( wxFileName( filename ).GetFullName() ) ), date_buf );
631  // End of header
632  fprintf( outputFile, " <desc>Picture generated by %s </desc>\n",
633  TO_UTF8( XmlEsc( creator ) ) );
634 
635  // output the pen and brush color (RVB values in hex) and opacity
636  double opacity = 1.0; // 0.0 (transparent to 1.0 (solid)
637  fprintf( outputFile,
638  "<g style=\"fill:#%6.6lX; fill-opacity:%g;stroke:#%6.6lX; stroke-opacity:%g;\n",
639  m_brush_rgb_color, opacity, m_pen_rgb_color, opacity );
640 
641  // output the pen cap and line joint
642  fputs( "stroke-linecap:round; stroke-linejoin:round; \"\n", outputFile );
643  fputs( " transform=\"translate(0 0) scale(1 1)\">\n", outputFile );
644  return true;
645 }
646 
647 
649 {
650  fputs( "</g> \n</svg>\n", outputFile );
651  fclose( outputFile );
652  outputFile = NULL;
653 
654  return true;
655 }
656 
657 
658 void SVG_PLOTTER::Text( const wxPoint& aPos,
659  const COLOR4D aColor,
660  const wxString& aText,
661  double aOrient,
662  const wxSize& aSize,
663  enum EDA_TEXT_HJUSTIFY_T aH_justify,
664  enum EDA_TEXT_VJUSTIFY_T aV_justify,
665  int aWidth,
666  bool aItalic,
667  bool aBold,
668  bool aMultilineAllowed,
669  void* aData )
670 {
671  setFillMode( NO_FILL );
672  SetColor( aColor );
673  SetCurrentLineWidth( aWidth );
674 
675  // TODO: see if the postscript native text code can be used in SVG plotter
676 
677  PLOTTER::Text( aPos, aColor, aText, aOrient, aSize, aH_justify, aV_justify,
678  aWidth, aItalic, aBold, aMultilineAllowed );
679 }
double GetDotMarkLenIU() const
Definition: plotter.cpp:136
EDA_TEXT_HJUSTIFY_T
Definition: eda_text.h:62
virtual void PlotImage(const wxImage &aImage, const wxPoint &aPos, double aScaleFactor) override
Postscript-likes at the moment are the only plot engines supporting bitmaps...
virtual void SetViewport(const wxPoint &aOffset, double aIusPerDecimil, double aScale, bool aMirror) override
Set the plot offset and scaling for the current plot.
const Vec GetEnd() const
Definition: box2.h:193
FILL_T m_fillMode
Definition: plotter.h:969
void setFillMode(FILL_T fill)
function setFillMode() prepare parameters for setSVGPlotStyle()
int color
Definition: DXF_plotter.cpp:62
virtual void PenTo(const wxPoint &pos, char plume) override
moveto/lineto primitive, moves the 'pen' to the specified direction
void setSVGPlotStyle(bool aIsGroup=true, const std::string &aExtraStyle={})
function setSVGPlotStyle() output the string which define pen and brush color, shape,...
void RotatePoint(int *pX, int *pY, double angle)
Definition: trigo.cpp:216
char penState
Current pen state: 'U', 'D' or 'Z' (see PenTo)
Definition: plotter.h:562
double m_IUsPerDecimil
Definition: plotter.h:539
wxPoint plotOffset
Plot offset (in IUs)
Definition: plotter.h:545
wxPoint penLastpos
Last pen positions; set to -1,-1 when the pen is at rest.
Definition: plotter.h:564
static wxString XmlEsc(const wxString &aStr, bool isAttribute=false)
Function XmlEsc translates '<' to "<", '>' to ">" and so on, according to the spec: http://www....
PAGE_INFO pageInfo
Definition: plotter.h:568
This file contains miscellaneous commonly used macros and functions.
virtual void Rect(const wxPoint &p1, const wxPoint &p2, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH) override
virtual void Text(const wxPoint &aPos, const COLOR4D aColor, const wxString &aText, double aOrient, const wxSize &aSize, enum EDA_TEXT_HJUSTIFY_T aH_justify, enum EDA_TEXT_VJUSTIFY_T aV_justify, int aWidth, bool aItalic, bool aBold, bool aMultilineAllowed=false, void *aData=NULL)
Draws text with the plotter.
double GetDashGapLenIU() const
Definition: plotter.cpp:148
virtual int GetCurrentLineWidth() const
Definition: plotter.h:152
virtual void Text(const wxPoint &aPos, const COLOR4D aColor, const wxString &aText, double aOrient, const wxSize &aSize, enum EDA_TEXT_HJUSTIFY_T aH_justify, enum EDA_TEXT_VJUSTIFY_T aV_justify, int aWidth, bool aItalic, bool aBold, bool aMultilineAllowed=false, void *aData=NULL) override
Draws text with the plotter.
#define TO_UTF8(wxstring)
Macro TO_UTF8 converts a wxString to a UTF8 encoded C string for all wxWidgets build modes.
Definition: macros.h:47
virtual bool EndPlot() override
bool m_yaxisReversed
true to mirror horizontally (else vertically)
Definition: plotter.h:551
const wxPoint GetEnd() const
Definition: eda_rect.h:114
virtual void SetColor(COLOR4D color) override
The SetColor implementation is split with the subclasses: The PSLIKE computes the rgb values,...
bool m_plotMirror
X axis orientation (SVG) and plot mirrored (only for PS, PDF HPGL and SVG)
Definition: plotter.h:549
virtual void SetDefaultLineWidth(int width) override
Set the default line width.
Definition: PS_plotter.cpp:52
long m_pen_rgb_color
Definition: plotter.h:971
const wxPoint GetOrigin() const
Definition: eda_rect.h:112
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.
BOX2< Vec > & Normalize()
Function Normalize ensures that the height ant width are positive.
Definition: box2.h:127
virtual void SetColor(COLOR4D color) override
The SetColor implementation is split with the subclasses: The PSLIKE computes the rgb values,...
Definition: PS_plotter.cpp:59
Base window classes and related definitions.
double plotScale
Plot scale - chosen by the user (even implicitly with 'fit in a4')
Definition: plotter.h:533
virtual bool StartPlot() override
The code within this function creates SVG files header.
const wxSize & GetSizeMils() const
Definition: page_info.h:142
virtual DPOINT userToDeviceSize(const wxSize &size)
Modifies size according to the plotter scale factors (wxSize version, returns a DPOINT)
Definition: plotter.cpp:121
virtual void SetCurrentLineWidth(int width, void *aData=NULL) override
Set the line width for the next drawing.
virtual void Circle(const wxPoint &pos, int diametre, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH) override
EDA_TEXT_VJUSTIFY_T
Definition: eda_text.h:69
const Vec & GetPosition() const
Definition: box2.h:192
virtual DPOINT userToDeviceCoordinates(const wxPoint &aCoordinate)
Modifies coordinates according to the orientation, scale factor, and offsets trace.
Definition: plotter.cpp:96
void Normalize()
Function Normalize ensures that the height ant width are positive.
virtual void PlotImage(const wxImage &aImage, const wxPoint &aPos, double aScaleFactor)
Function PlotImage Only Postscript plotters can plot bitmaps for plotters that cannot plot a bitmap,...
Definition: plotter.cpp:181
virtual void SetTextMode(PlotTextMode mode) override
PS and PDF fully implement native text (for the Latin-1 subset)
Definition: plotter.h:673
int currentPenWidth
Definition: plotter.h:560
int defaultPenWidth
true to generate a negative image (PS mode mainly)
Definition: plotter.h:559
double GetDashMarkLenIU() const
Definition: plotter.cpp:142
bool m_graphics_changed
Definition: plotter.h:977
long m_brush_rgb_color
Definition: plotter.h:975
virtual void EndBlock(void *aData) override
calling this function allows one to define the end of a group of drawing items the group is started b...
FILE * outputFile
true if the Y axis is top to bottom (SVG)
Definition: plotter.h:554
Class EDA_RECT handles the component boundary box.
Definition: eda_rect.h:44
double DECIDEG2RAD(double deg)
Definition: trigo.h:203
virtual void emitSetRGBColor(double r, double g, double b) override
function emitSetRGBColor() initialize m_pen_rgb_color from reduced values r, g ,b ( reduced values ar...
The common library.
FILL_T
Enum FILL_T is the set of fill types used in plotting or drawing enclosed areas.
Definition: base_struct.h:54
virtual void SetDash(int dashed) override
SVG supports dashed lines.
virtual void StartBlock(void *aData) override
calling this function allows one to define the beginning of a group of drawing items (used in SVG for...
const Vec & GetSize() const
Definition: box2.h:187
Basic classes for most KiCad items.
double iuPerDeviceUnit
Device scale (from IUs to plotter device units - usually decimils)
Definition: plotter.h:542
wxString filename
Definition: plotter.h:566
float width
Definition: nanosvg.h:157
wxString creator
Definition: plotter.h:565
wxSize paperSize
Paper size in IU - not in mils.
Definition: plotter.h:570
bool m_mirrorIsHorizontal
Definition: plotter.h:550
int m_dashed
Definition: plotter.h:980
virtual void PlotPoly(const std::vector< wxPoint > &aCornerList, FILL_T aFill, int aWidth=USE_DEFAULT_LINE_WIDTH, void *aData=NULL) override
Function PlotPoly.
Class COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:39