mirror of
https://gitlab.com/kicad/code/kicad.git
synced 2025-09-14 10:13:19 +02:00
b650e4568b
We output a 0 opacity text in the SVG plotter to allow searching. When this text is changed to 100 opacity, it can show up on the user screen and so needs to be mirrored to match the stroke font output Fixes https://gitlab.com/kicad/code/kicad/issues/5001
866 lines
26 KiB
C++
866 lines
26 KiB
C++
/**
|
|
* @file SVG_plotter.cpp
|
|
* @brief Kicad: specialized plotter for SVG files format
|
|
*/
|
|
|
|
/*
|
|
* This program source code file is part of KiCad, a free EDA CAD application.
|
|
*
|
|
* Copyright (C) 2020 Jean-Pierre Charras, jp.charras at wanadoo.fr
|
|
* Copyright (C) 1992-2020 KiCad Developers, see AUTHORS.txt for contributors.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, you may find one here:
|
|
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
|
|
* or you may search the http://www.gnu.org website for the version 2 license,
|
|
* or you may write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
/* Some info on basic items SVG format, used here:
|
|
* The root element of all SVG files is the <svg> element.
|
|
*
|
|
* The <g> element is used to group SVG shapes together.
|
|
* Once grouped you can transform the whole group of shapes as if it was a single shape.
|
|
* This is an advantage compared to a nested <svg> element
|
|
* which cannot be the target of transformation by itself.
|
|
*
|
|
* The <rect> element represents a rectangle.
|
|
* Using this element you can draw rectangles of various width, height,
|
|
* with different stroke (outline) and fill colors, with sharp or rounded corners etc.
|
|
*
|
|
* <svg xmlns="http://www.w3.org/2000/svg"
|
|
* xmlns:xlink="http://www.w3.org/1999/xlink">
|
|
*
|
|
* <rect x="10" y="10" height="100" width="100"
|
|
* style="stroke:#006600; fill: #00cc00"/>
|
|
*
|
|
* </svg>
|
|
*
|
|
* The <circle> element is used to draw circles.
|
|
* <circle cx="40" cy="40" r="24" style="stroke:#006600; fill:#00cc00"/>
|
|
*
|
|
* The <ellipse> element is used to draw ellipses.
|
|
* An ellipse is a circle that does not have equal height and width.
|
|
* Its radius in the x and y directions are different, in other words.
|
|
* <ellipse cx="40" cy="40" rx="30" ry="15"
|
|
* style="stroke:#006600; fill:#00cc00"/>
|
|
*
|
|
* The <line> element is used to draw lines.
|
|
*
|
|
* <line x1="0" y1="10" x2="0" y2="100" style="stroke:#006600;"/>
|
|
* <line x1="10" y1="10" x2="100" y2="100" style="stroke:#006600;"/>
|
|
*
|
|
* The <polyline> element is used to draw multiple connected lines
|
|
* Here is a simple example:
|
|
*
|
|
* <polyline points="0,0 30,0 15,30" style="stroke:#006600;"/>
|
|
*
|
|
* The <polygon> element is used to draw with multiple (3 or more) sides / edges.
|
|
* Here is a simple example:
|
|
*
|
|
* <polygon points="0,0 50,0 25,50" style="stroke:#660000; fill:#cc3333;"/>
|
|
*
|
|
* The <path> element is used to draw advanced shapes combined from lines and arcs,
|
|
* with or without fill.
|
|
* It is probably the most advanced and versatile SVG shape of them all.
|
|
* It is probably also the hardest element to master.
|
|
* <path d="M50,50
|
|
* A30,30 0 0,1 35,20
|
|
* L100,100
|
|
* M110,110
|
|
* L100,0"
|
|
* style="stroke:#660000; fill:none;"/>
|
|
*
|
|
* Draw an elliptic arc: it is one of basic path command:
|
|
* <path d="M(startx,starty) A(radiusx,radiusy)
|
|
* rotation-axe-x
|
|
* flag_arc_large,flag_sweep endx,endy">
|
|
* flag_arc_large: 0 = small arc > 180 deg, 1 = large arc > 180 deg
|
|
* flag_sweep : 0 = CCW, 1 = CW
|
|
* The center of ellipse is automatically calculated.
|
|
*/
|
|
|
|
#include <base64.h>
|
|
#include <fctsys.h>
|
|
#include <trigo.h>
|
|
#include <eda_base_frame.h>
|
|
#include <eda_rect.h>
|
|
#include <base_struct.h>
|
|
#include <common.h>
|
|
#include <plotter.h>
|
|
#include <macros.h>
|
|
#include <kicad_string.h>
|
|
|
|
#include <cstdint>
|
|
#include <wx/mstream.h>
|
|
|
|
/**
|
|
* Function XmlEsc
|
|
* translates '<' to "<", '>' to ">" and so on, according to the spec:
|
|
* http://www.w3.org/TR/2000/WD-xml-c14n-20000119.html#charescaping
|
|
* May be moved to a library if needed generally, but not expecting that.
|
|
*/
|
|
static wxString XmlEsc( const wxString& aStr, bool isAttribute = false )
|
|
{
|
|
wxString escaped;
|
|
|
|
escaped.reserve( aStr.length() );
|
|
|
|
for( wxString::const_iterator it = aStr.begin(); it != aStr.end(); ++it )
|
|
{
|
|
const wxChar c = *it;
|
|
|
|
switch( c )
|
|
{
|
|
case wxS( '<' ):
|
|
escaped.append( wxS( "<" ) );
|
|
break;
|
|
case wxS( '>' ):
|
|
escaped.append( wxS( ">" ) );
|
|
break;
|
|
case wxS( '&' ):
|
|
escaped.append( wxS( "&" ) );
|
|
break;
|
|
case wxS( '\r' ):
|
|
escaped.append( wxS( "
" ) );
|
|
break;
|
|
default:
|
|
if( isAttribute )
|
|
{
|
|
switch( c )
|
|
{
|
|
case wxS( '"' ):
|
|
escaped.append( wxS( """ ) );
|
|
break;
|
|
case wxS( '\t' ):
|
|
escaped.append( wxS( "	" ) );
|
|
break;
|
|
case wxS( '\n' ):
|
|
escaped.append( wxS( "
" ));
|
|
break;
|
|
default:
|
|
escaped.append(c);
|
|
}
|
|
}
|
|
else
|
|
escaped.append(c);
|
|
}
|
|
}
|
|
|
|
return escaped;
|
|
}
|
|
|
|
|
|
SVG_PLOTTER::SVG_PLOTTER()
|
|
{
|
|
m_graphics_changed = true;
|
|
SetTextMode( PLOT_TEXT_MODE::STROKE );
|
|
m_fillMode = NO_FILL; // or FILLED_SHAPE or FILLED_WITH_BG_BODYCOLOR
|
|
m_pen_rgb_color = 0; // current color value (black)
|
|
m_brush_rgb_color = 0; // current color value (black)
|
|
m_dashed = PLOT_DASH_TYPE::SOLID;
|
|
m_useInch = true; // decimils is the default
|
|
m_precision = 4; // because there where used before it was changable
|
|
}
|
|
|
|
|
|
void SVG_PLOTTER::SetViewport( const wxPoint& aOffset, double aIusPerDecimil,
|
|
double aScale, bool aMirror )
|
|
{
|
|
m_plotMirror = aMirror;
|
|
m_yaxisReversed = true; // unlike other plotters, SVG has Y axis reversed
|
|
plotOffset = aOffset;
|
|
plotScale = aScale;
|
|
m_IUsPerDecimil = aIusPerDecimil;
|
|
|
|
/* Compute the paper size in IUs */
|
|
paperSize = pageInfo.GetSizeMils();
|
|
paperSize.x *= 10.0 * aIusPerDecimil;
|
|
paperSize.y *= 10.0 * aIusPerDecimil;
|
|
|
|
// set iuPerDeviceUnit, in 0.1mils ( 2.54um )
|
|
// this was used before the format was changable, so we set is as default
|
|
SetSvgCoordinatesFormat( 4, true );
|
|
}
|
|
|
|
void SVG_PLOTTER::SetSvgCoordinatesFormat( unsigned aResolution, bool aUseInches )
|
|
{
|
|
m_useInch = aUseInches;
|
|
m_precision = aResolution;
|
|
|
|
// gives now a default value to iuPerDeviceUnit (because the units of the caller is now known)
|
|
double iusPerMM = m_IUsPerDecimil / 2.54 * 1000;
|
|
iuPerDeviceUnit = pow( 10.0, m_precision ) / ( iusPerMM );
|
|
|
|
if( m_useInch )
|
|
iuPerDeviceUnit /= 25.4; // convert to inch
|
|
}
|
|
|
|
|
|
void SVG_PLOTTER::SetColor( COLOR4D color )
|
|
{
|
|
PSLIKE_PLOTTER::SetColor( color );
|
|
|
|
if( m_graphics_changed )
|
|
setSVGPlotStyle();
|
|
}
|
|
|
|
|
|
void SVG_PLOTTER::setFillMode( FILL_T fill )
|
|
{
|
|
if( m_fillMode != fill )
|
|
{
|
|
m_graphics_changed = true;
|
|
m_fillMode = fill;
|
|
}
|
|
}
|
|
|
|
|
|
void SVG_PLOTTER::setSVGPlotStyle( bool aIsGroup, const std::string& aExtraStyle )
|
|
{
|
|
if( aIsGroup )
|
|
fputs( "</g>\n<g ", outputFile );
|
|
|
|
// output the background fill color
|
|
fprintf( outputFile, "style=\"fill:#%6.6lX; ", m_brush_rgb_color );
|
|
|
|
switch( m_fillMode )
|
|
{
|
|
case NO_FILL:
|
|
fputs( "fill-opacity:0.0; ", outputFile );
|
|
break;
|
|
|
|
case FILLED_SHAPE:
|
|
fputs( "fill-opacity:1.0; ", outputFile );
|
|
break;
|
|
|
|
case FILLED_WITH_BG_BODYCOLOR:
|
|
fputs( "fill-opacity:0.6; ", outputFile );
|
|
break;
|
|
|
|
case FILLED_WITH_COLOR:
|
|
wxFAIL_MSG( "FILLED_WITH_COLOR not implemented" );
|
|
break;
|
|
}
|
|
|
|
double pen_w = userToDeviceSize( GetCurrentLineWidth() );
|
|
|
|
if( pen_w < 0.0 ) // Ensure pen width validity
|
|
pen_w = 0.0;
|
|
|
|
fprintf( outputFile, "\nstroke:#%6.6lX; stroke-width:%f; stroke-opacity:1; \n",
|
|
m_pen_rgb_color, pen_w );
|
|
fputs( "stroke-linecap:round; stroke-linejoin:round;", outputFile );
|
|
|
|
//set any extra attributes for non-solid lines
|
|
switch( m_dashed )
|
|
{
|
|
case PLOT_DASH_TYPE::DASH:
|
|
fprintf( outputFile, "stroke-dasharray:%f,%f;", GetDashMarkLenIU(), GetDashGapLenIU() );
|
|
break;
|
|
case PLOT_DASH_TYPE::DOT:
|
|
fprintf( outputFile, "stroke-dasharray:%f,%f;", GetDotMarkLenIU(), GetDashGapLenIU() );
|
|
break;
|
|
case PLOT_DASH_TYPE::DASHDOT:
|
|
fprintf( outputFile, "stroke-dasharray:%f,%f,%f,%f;", GetDashMarkLenIU(), GetDashGapLenIU(),
|
|
GetDotMarkLenIU(), GetDashGapLenIU() );
|
|
break;
|
|
case PLOT_DASH_TYPE::DEFAULT:
|
|
case PLOT_DASH_TYPE::SOLID:
|
|
default:
|
|
//do nothing
|
|
break;
|
|
}
|
|
|
|
if( aExtraStyle.length() )
|
|
{
|
|
fputs( aExtraStyle.c_str(), outputFile );
|
|
}
|
|
|
|
fputs( "\"", outputFile );
|
|
|
|
if( aIsGroup )
|
|
{
|
|
fputs( ">", outputFile );
|
|
m_graphics_changed = false;
|
|
}
|
|
|
|
fputs( "\n", outputFile );
|
|
}
|
|
|
|
/* Set the current line width (in IUs) for the next plot
|
|
*/
|
|
void SVG_PLOTTER::SetCurrentLineWidth( int aWidth, void* aData )
|
|
{
|
|
if( aWidth == DO_NOT_SET_LINE_WIDTH )
|
|
return;
|
|
else if( aWidth == USE_DEFAULT_LINE_WIDTH )
|
|
aWidth = m_renderSettings->GetDefaultPenWidth();
|
|
else if( aWidth == 0 )
|
|
aWidth = 1;
|
|
|
|
wxASSERT_MSG( aWidth > 0, "Plotter called to set negative pen width" );
|
|
|
|
if( aWidth != currentPenWidth )
|
|
{
|
|
m_graphics_changed = true;
|
|
currentPenWidth = aWidth;
|
|
}
|
|
|
|
if( m_graphics_changed )
|
|
setSVGPlotStyle();
|
|
}
|
|
|
|
|
|
void SVG_PLOTTER::StartBlock( void* aData )
|
|
{
|
|
std::string* idstr = reinterpret_cast<std::string*>( aData );
|
|
|
|
fputs( "<g ", outputFile );
|
|
if( idstr )
|
|
fprintf( outputFile, "id=\"%s\"", idstr->c_str() );
|
|
|
|
fprintf( outputFile, ">\n" );
|
|
}
|
|
|
|
|
|
void SVG_PLOTTER::EndBlock( void* aData )
|
|
{
|
|
fprintf( outputFile, "</g>\n" );
|
|
|
|
m_graphics_changed = true;
|
|
}
|
|
|
|
|
|
/* initialize m_red, m_green, m_blue ( 0 ... 255)
|
|
* from reduced values r, g ,b ( 0.0 to 1.0 )
|
|
*/
|
|
void SVG_PLOTTER::emitSetRGBColor( double r, double g, double b )
|
|
{
|
|
int red = (int) ( 255.0 * r );
|
|
int green = (int) ( 255.0 * g );
|
|
int blue = (int) ( 255.0 * b );
|
|
long rgb_color = (red << 16) | (green << 8) | blue;
|
|
|
|
if( m_pen_rgb_color != rgb_color )
|
|
{
|
|
m_graphics_changed = true;
|
|
m_pen_rgb_color = rgb_color;
|
|
|
|
// Currently, use the same color for brush and pen
|
|
// (i.e. to draw and fill a contour)
|
|
m_brush_rgb_color = rgb_color;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* SVG supports dashed lines
|
|
*/
|
|
void SVG_PLOTTER::SetDash( PLOT_DASH_TYPE dashed )
|
|
{
|
|
if( m_dashed != dashed )
|
|
{
|
|
m_graphics_changed = true;
|
|
m_dashed = dashed;
|
|
}
|
|
|
|
if( m_graphics_changed )
|
|
setSVGPlotStyle();
|
|
}
|
|
|
|
|
|
void SVG_PLOTTER::Rect( const wxPoint& p1, const wxPoint& p2, FILL_T fill, int width )
|
|
{
|
|
EDA_RECT rect( p1, wxSize( p2.x -p1.x, p2.y -p1.y ) );
|
|
rect.Normalize();
|
|
DPOINT org_dev = userToDeviceCoordinates( rect.GetOrigin() );
|
|
DPOINT end_dev = userToDeviceCoordinates( rect.GetEnd() );
|
|
DSIZE size_dev = end_dev - org_dev;
|
|
// Ensure size of rect in device coordinates is > 0
|
|
// I don't know if this is a SVG issue or a Inkscape issue, but
|
|
// Inkscape has problems with negative or null values for width and/or height, so avoid them
|
|
DBOX rect_dev( org_dev, size_dev);
|
|
rect_dev.Normalize();
|
|
|
|
setFillMode( fill );
|
|
SetCurrentLineWidth( width );
|
|
|
|
// Rectangles having a 0 size value for height or width are just not drawn on Inscape,
|
|
// so use a line when happens.
|
|
if( rect_dev.GetSize().x == 0.0 || rect_dev.GetSize().y == 0.0 ) // Draw a line
|
|
fprintf( outputFile,
|
|
"<line x1=\"%f\" y1=\"%f\" x2=\"%f\" y2=\"%f\" />\n",
|
|
rect_dev.GetPosition().x, rect_dev.GetPosition().y,
|
|
rect_dev.GetEnd().x, rect_dev.GetEnd().y
|
|
);
|
|
|
|
else
|
|
fprintf( outputFile,
|
|
"<rect x=\"%f\" y=\"%f\" width=\"%f\" height=\"%f\" rx=\"%f\" />\n",
|
|
rect_dev.GetPosition().x, rect_dev.GetPosition().y,
|
|
rect_dev.GetSize().x, rect_dev.GetSize().y,
|
|
0.0 // radius of rounded corners
|
|
);
|
|
}
|
|
|
|
|
|
void SVG_PLOTTER::Circle( const wxPoint& pos, int diametre, FILL_T fill, int width )
|
|
{
|
|
DPOINT pos_dev = userToDeviceCoordinates( pos );
|
|
double radius = userToDeviceSize( diametre / 2.0 );
|
|
|
|
setFillMode( fill );
|
|
SetCurrentLineWidth( width );
|
|
|
|
// If diameter is less than width, switch to filled mode
|
|
if( fill == NO_FILL && diametre < width )
|
|
{
|
|
setFillMode( FILLED_SHAPE );
|
|
SetCurrentLineWidth( 0 );
|
|
|
|
radius = userToDeviceSize( ( diametre / 2.0 ) + ( width / 2.0 ) );
|
|
}
|
|
|
|
fprintf( outputFile,
|
|
"<circle cx=\"%f\" cy=\"%f\" r=\"%f\" /> \n",
|
|
pos_dev.x, pos_dev.y, radius );
|
|
}
|
|
|
|
|
|
void SVG_PLOTTER::Arc( const wxPoint& centre, double StAngle, double EndAngle, int radius,
|
|
FILL_T fill, int width )
|
|
{
|
|
/* Draws an arc of a circle, centred on (xc,yc), with starting point
|
|
* (x1, y1) and ending at (x2, y2). The current pen is used for the outline
|
|
* and the current brush for filling the shape.
|
|
*
|
|
* The arc is drawn in an anticlockwise direction from the start point to
|
|
* the end point
|
|
*/
|
|
|
|
if( radius <= 0 )
|
|
{
|
|
Circle( centre, width, FILLED_SHAPE, 0 );
|
|
return;
|
|
}
|
|
|
|
if( StAngle > EndAngle )
|
|
std::swap( StAngle, EndAngle );
|
|
|
|
// Calculate start point.
|
|
DPOINT centre_dev = userToDeviceCoordinates( centre );
|
|
double radius_dev = userToDeviceSize( radius );
|
|
|
|
if( !m_yaxisReversed ) // Should be never the case
|
|
{
|
|
double tmp = StAngle;
|
|
StAngle = -EndAngle;
|
|
EndAngle = -tmp;
|
|
}
|
|
|
|
if( m_plotMirror )
|
|
{
|
|
if( m_mirrorIsHorizontal )
|
|
{
|
|
StAngle = 1800.0 -StAngle;
|
|
EndAngle = 1800.0 -EndAngle;
|
|
std::swap( StAngle, EndAngle );
|
|
}
|
|
else
|
|
{
|
|
StAngle = -StAngle;
|
|
EndAngle = -EndAngle;
|
|
}
|
|
}
|
|
|
|
DPOINT start;
|
|
start.x = radius_dev;
|
|
RotatePoint( &start.x, &start.y, StAngle );
|
|
DPOINT end;
|
|
end.x = radius_dev;
|
|
RotatePoint( &end.x, &end.y, EndAngle );
|
|
start += centre_dev;
|
|
end += centre_dev;
|
|
|
|
double theta1 = DECIDEG2RAD( StAngle );
|
|
|
|
if( theta1 < 0 )
|
|
theta1 = theta1 + M_PI * 2;
|
|
|
|
double theta2 = DECIDEG2RAD( EndAngle );
|
|
|
|
if( theta2 < 0 )
|
|
theta2 = theta2 + M_PI * 2;
|
|
|
|
if( theta2 < theta1 )
|
|
theta2 = theta2 + M_PI * 2;
|
|
|
|
int flg_arc = 0; // flag for large or small arc. 0 means less than 180 degrees
|
|
|
|
if( fabs( theta2 - theta1 ) > M_PI )
|
|
flg_arc = 1;
|
|
|
|
int flg_sweep = 0; // flag for sweep always 0
|
|
|
|
// Draw a single arc: an arc is one of 3 curve commands (2 other are 2 bezier curves)
|
|
// params are start point, radius1, radius2, X axe rotation,
|
|
// flag arc size (0 = small arc > 180 deg, 1 = large arc > 180 deg),
|
|
// sweep arc ( 0 = CCW, 1 = CW),
|
|
// end point
|
|
if( fill != NO_FILL )
|
|
{
|
|
// Filled arcs (in eeschema) consist of the pie wedge and a stroke only on the arc
|
|
// This needs to be drawn in two steps.
|
|
setFillMode( fill );
|
|
SetCurrentLineWidth( 0 );
|
|
|
|
fprintf( outputFile, "<path d=\"M%f %f A%f %f 0.0 %d %d %f %f L %f %f Z\" />\n",
|
|
start.x, start.y, radius_dev, radius_dev,
|
|
flg_arc, flg_sweep,
|
|
end.x, end.y, centre_dev.x, centre_dev.y );
|
|
}
|
|
|
|
setFillMode( NO_FILL );
|
|
SetCurrentLineWidth( width );
|
|
fprintf( outputFile, "<path d=\"M%f %f A%f %f 0.0 %d %d %f %f\" />\n",
|
|
start.x, start.y, radius_dev, radius_dev,
|
|
flg_arc, flg_sweep,
|
|
end.x, end.y );
|
|
}
|
|
|
|
|
|
void SVG_PLOTTER::BezierCurve( const wxPoint& aStart, const wxPoint& aControl1,
|
|
const wxPoint& aControl2, const wxPoint& aEnd,
|
|
int aTolerance, int aLineThickness )
|
|
{
|
|
#if 1
|
|
setFillMode( NO_FILL );
|
|
SetCurrentLineWidth( aLineThickness );
|
|
|
|
DPOINT start = userToDeviceCoordinates( aStart );
|
|
DPOINT ctrl1 = userToDeviceCoordinates( aControl1 );
|
|
DPOINT ctrl2 = userToDeviceCoordinates( aControl2 );
|
|
DPOINT end = userToDeviceCoordinates( aEnd );
|
|
|
|
// Generate a cubic curve: start point and 3 other control points.
|
|
fprintf( outputFile, "<path d=\"M%f,%f C%f,%f %f,%f %f,%f\" />\n",
|
|
start.x, start.y, ctrl1.x, ctrl1.y,
|
|
ctrl2.x, ctrl2.y, end.x, end.y );
|
|
#else
|
|
PLOTTER::BezierCurve( aStart, aControl1,aControl2, aEnd,aTolerance, aLineThickness );
|
|
#endif
|
|
}
|
|
|
|
|
|
void SVG_PLOTTER::PlotPoly( const std::vector<wxPoint>& aCornerList,
|
|
FILL_T aFill, int aWidth, void * aData )
|
|
{
|
|
if( aCornerList.size() <= 1 )
|
|
return;
|
|
|
|
setFillMode( aFill );
|
|
SetCurrentLineWidth( aWidth );
|
|
fprintf( outputFile, "<path ");
|
|
|
|
switch( aFill )
|
|
{
|
|
case NO_FILL:
|
|
setSVGPlotStyle( false, "fill:none" );
|
|
break;
|
|
|
|
case FILLED_WITH_BG_BODYCOLOR:
|
|
case FILLED_SHAPE:
|
|
setSVGPlotStyle( false, "fill-rule:evenodd;" );
|
|
break;
|
|
|
|
case FILLED_WITH_COLOR:
|
|
wxFAIL_MSG( "FILLED_WITH_COLOR not implemented" );
|
|
break;
|
|
}
|
|
|
|
DPOINT pos = userToDeviceCoordinates( aCornerList[0] );
|
|
fprintf( outputFile, "d=\"M %f,%f\n", pos.x, pos.y );
|
|
|
|
for( unsigned ii = 1; ii < aCornerList.size() - 1; ii++ )
|
|
{
|
|
pos = userToDeviceCoordinates( aCornerList[ii] );
|
|
fprintf( outputFile, "%f,%f\n", pos.x, pos.y );
|
|
}
|
|
|
|
// If the cornerlist ends where it begins, then close the poly
|
|
if( aCornerList.front() == aCornerList.back() )
|
|
fprintf( outputFile, "Z\" /> \n" );
|
|
else
|
|
{
|
|
pos = userToDeviceCoordinates( aCornerList.back() );
|
|
fprintf( outputFile, "%f,%f\n\" /> \n", pos.x, pos.y );
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Postscript-likes at the moment are the only plot engines supporting bitmaps...
|
|
*/
|
|
void SVG_PLOTTER::PlotImage( const wxImage& aImage, const wxPoint& aPos,
|
|
double aScaleFactor )
|
|
{
|
|
wxSize pix_size( aImage.GetWidth(), aImage.GetHeight() );
|
|
|
|
// Requested size (in IUs)
|
|
DPOINT drawsize( aScaleFactor * pix_size.x,
|
|
aScaleFactor * pix_size.y );
|
|
|
|
// calculate the bitmap start position
|
|
wxPoint start( aPos.x - drawsize.x / 2,
|
|
aPos.y - drawsize.y / 2);
|
|
|
|
// Rectangles having a 0 size value for height or width are just not drawn on Inscape,
|
|
// so use a line when happens.
|
|
if( drawsize.x == 0.0 || drawsize.y == 0.0 ) // Draw a line
|
|
{
|
|
PLOTTER::PlotImage( aImage, aPos, aScaleFactor );
|
|
}
|
|
else
|
|
{
|
|
wxMemoryOutputStream img_stream;
|
|
|
|
aImage.SaveFile( img_stream, wxBITMAP_TYPE_PNG );
|
|
size_t input_len = img_stream.GetOutputStreamBuffer()->GetBufferSize();
|
|
std::vector<uint8_t> buffer( input_len );
|
|
std::vector<uint8_t> encoded;
|
|
|
|
img_stream.CopyTo( buffer.data(), buffer.size() );
|
|
base64::encode( buffer, encoded );
|
|
|
|
fprintf( outputFile,
|
|
"<image x=\"%f\" y=\"%f\" xlink:href=\"data:image/png;base64,",
|
|
userToDeviceSize( start.x ), userToDeviceSize( start.y )
|
|
);
|
|
|
|
for( size_t i = 0; i < encoded.size(); i++ )
|
|
{
|
|
fprintf( outputFile, "%c", static_cast<char>( encoded[i] ) );
|
|
|
|
if( ( i % 64 ) == 63 )
|
|
fprintf( outputFile, "\n" );
|
|
}
|
|
|
|
fprintf( outputFile, "\"\npreserveAspectRatio=\"none\" width=\"%f\" height=\"%f\" />",
|
|
userToDeviceSize( drawsize.x ), userToDeviceSize( drawsize.y ) );
|
|
}
|
|
}
|
|
|
|
|
|
void SVG_PLOTTER::PenTo( const wxPoint& pos, char plume )
|
|
{
|
|
if( plume == 'Z' )
|
|
{
|
|
if( penState != 'Z' )
|
|
{
|
|
fputs( "\" />\n", outputFile );
|
|
penState = 'Z';
|
|
penLastpos.x = -1;
|
|
penLastpos.y = -1;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if( penState == 'Z' ) // here plume = 'D' or 'U'
|
|
{
|
|
DPOINT pos_dev = userToDeviceCoordinates( pos );
|
|
|
|
// Ensure we do not use a fill mode when moving tne pen,
|
|
// in SVG mode (i;e. we are plotting only basic lines, not a filled area
|
|
if( m_fillMode != NO_FILL )
|
|
{
|
|
setFillMode( NO_FILL );
|
|
setSVGPlotStyle();
|
|
}
|
|
|
|
fprintf( outputFile, "<path d=\"M%d %d\n",
|
|
(int) pos_dev.x, (int) pos_dev.y );
|
|
}
|
|
else if( penState != plume || pos != penLastpos )
|
|
{
|
|
DPOINT pos_dev = userToDeviceCoordinates( pos );
|
|
fprintf( outputFile, "L%d %d\n",
|
|
(int) pos_dev.x, (int) pos_dev.y );
|
|
}
|
|
|
|
penState = plume;
|
|
penLastpos = pos;
|
|
}
|
|
|
|
|
|
/**
|
|
* The code within this function
|
|
* creates SVG files header
|
|
*/
|
|
bool SVG_PLOTTER::StartPlot()
|
|
{
|
|
wxASSERT( outputFile );
|
|
wxString msg;
|
|
|
|
static const char* header[] =
|
|
{
|
|
"<?xml version=\"1.0\" standalone=\"no\"?>\n",
|
|
" <!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \n",
|
|
" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\"> \n",
|
|
"<svg\n"
|
|
" xmlns:svg=\"http://www.w3.org/2000/svg\"\n"
|
|
" xmlns=\"http://www.w3.org/2000/svg\"\n",
|
|
" xmlns:xlink=\"http://www.w3.org/1999/xlink\"\n",
|
|
" version=\"1.1\"\n",
|
|
NULL
|
|
};
|
|
|
|
// Write header.
|
|
for( int ii = 0; header[ii] != NULL; ii++ )
|
|
{
|
|
fputs( header[ii], outputFile );
|
|
}
|
|
|
|
// Write viewport pos and size
|
|
wxPoint origin; // TODO set to actual value
|
|
fprintf( outputFile, " width=\"%fcm\" height=\"%fcm\" viewBox=\"%d %d %d %d\">\n",
|
|
(double) paperSize.x / m_IUsPerDecimil * 2.54 / 10000,
|
|
(double) paperSize.y / m_IUsPerDecimil * 2.54 / 10000, origin.x, origin.y,
|
|
(int) ( paperSize.x * iuPerDeviceUnit ), (int) ( paperSize.y * iuPerDeviceUnit) );
|
|
|
|
// Write title
|
|
char date_buf[250];
|
|
time_t ltime = time( NULL );
|
|
strftime( date_buf, 250, "%Y/%m/%d %H:%M:%S",
|
|
localtime( <ime ) );
|
|
|
|
fprintf( outputFile,
|
|
"<title>SVG Picture created as %s date %s </title>\n",
|
|
TO_UTF8( XmlEsc( wxFileName( filename ).GetFullName() ) ), date_buf );
|
|
// End of header
|
|
fprintf( outputFile, " <desc>Picture generated by %s </desc>\n",
|
|
TO_UTF8( XmlEsc( creator ) ) );
|
|
|
|
// output the pen and brush color (RVB values in hex) and opacity
|
|
double opacity = 1.0; // 0.0 (transparent to 1.0 (solid)
|
|
fprintf( outputFile,
|
|
"<g style=\"fill:#%6.6lX; fill-opacity:%f;stroke:#%6.6lX; stroke-opacity:%f;\n",
|
|
m_brush_rgb_color, opacity, m_pen_rgb_color, opacity );
|
|
|
|
// output the pen cap and line joint
|
|
fputs( "stroke-linecap:round; stroke-linejoin:round;\"\n", outputFile );
|
|
fputs( " transform=\"translate(0 0) scale(1 1)\">\n", outputFile );
|
|
return true;
|
|
}
|
|
|
|
|
|
bool SVG_PLOTTER::EndPlot()
|
|
{
|
|
fputs( "</g> \n</svg>\n", outputFile );
|
|
fclose( outputFile );
|
|
outputFile = NULL;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
void SVG_PLOTTER::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,
|
|
void* aData )
|
|
{
|
|
setFillMode( NO_FILL );
|
|
SetColor( aColor );
|
|
SetCurrentLineWidth( aWidth );
|
|
|
|
wxPoint text_pos = aPos;
|
|
const char *hjust = "start";
|
|
|
|
switch( aH_justify )
|
|
{
|
|
case GR_TEXT_HJUSTIFY_CENTER:
|
|
hjust = "middle";
|
|
break;
|
|
|
|
case GR_TEXT_HJUSTIFY_RIGHT:
|
|
hjust = "end";
|
|
break;
|
|
|
|
case GR_TEXT_HJUSTIFY_LEFT:
|
|
hjust = "start";
|
|
break;
|
|
}
|
|
|
|
switch( aV_justify )
|
|
{
|
|
case GR_TEXT_VJUSTIFY_CENTER:
|
|
text_pos.y += aSize.y / 2;
|
|
break;
|
|
|
|
case GR_TEXT_VJUSTIFY_TOP:
|
|
text_pos.y += aSize.y;
|
|
break;
|
|
|
|
case GR_TEXT_VJUSTIFY_BOTTOM:
|
|
break;
|
|
}
|
|
|
|
wxSize text_size;
|
|
// aSize.x or aSize.y is < 0 for mirrored texts.
|
|
// The actual text size value is the absolue value
|
|
text_size.x = std::abs( GraphicTextWidth( aText, aSize, aItalic, aWidth ) );
|
|
text_size.y = std::abs( aSize.x * 4/3 ); // Hershey font height to em size conversion
|
|
DPOINT anchor_pos_dev = userToDeviceCoordinates( aPos );
|
|
DPOINT text_pos_dev = userToDeviceCoordinates( text_pos );
|
|
DPOINT sz_dev = userToDeviceSize( text_size );
|
|
|
|
if( aOrient != 0 ) {
|
|
fprintf( outputFile,
|
|
"<g transform=\"rotate(%f %f %f)\">\n",
|
|
- aOrient * 0.1, anchor_pos_dev.x, anchor_pos_dev.y );
|
|
}
|
|
|
|
fprintf( outputFile,
|
|
"<text x=\"%f\" y=\"%f\"\n", text_pos_dev.x, text_pos_dev.y );
|
|
|
|
/// If the text is mirrored, we should also mirror the hidden text to match
|
|
if( aSize.x < 0 )
|
|
fprintf( outputFile, "transform=\"scale(-1 1) translate(%f 0)\"\n", -2 * text_pos_dev.x );
|
|
|
|
fprintf( outputFile,
|
|
"textLength=\"%f\" font-size=\"%f\" lengthAdjust=\"spacingAndGlyphs\"\n"
|
|
"text-anchor=\"%s\" opacity=\"0\">%s</text>\n",
|
|
sz_dev.x, sz_dev.y,
|
|
hjust, TO_UTF8( XmlEsc( aText ) ) );
|
|
|
|
if( aOrient != 0 )
|
|
fputs( "</g>\n", outputFile );
|
|
|
|
fprintf( outputFile,
|
|
"<g class=\"stroked-text\"><desc>%s</desc>\n",
|
|
TO_UTF8( XmlEsc( aText ) ) );
|
|
PLOTTER::Text( aPos, aColor, aText, aOrient, aSize, aH_justify, aV_justify,
|
|
aWidth, aItalic, aBold, aMultilineAllowed );
|
|
fputs( "</g>", outputFile );
|
|
}
|