wmf-print.cpp revision 0a2eb3db73cd91971ada6cd48256c2592ed29f54
/** @file
* @brief Windows Metafile printing
*/
/* Authors:
* Ulf Erikson <ulferikson@users.sf.net>
* Jon A. Cruz <jon@joncruz.org>
* Abhishek Sharma
* David Mathog
*
* Copyright (C) 2006-2009 Authors
*
* Released under GNU GPL, read the file 'COPYING' for more information
*/
/*
* References:
* - How to Create & Play Enhanced Metafiles in Win32
* - INFO: Windows Metafile Functions & Aldus Placeable Metafiles
* - Metafile Functions
* - Metafile Structures
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "helper/geom-curves.h"
#include "sp-item.h"
#include "style.h"
#include "inkscape-version.h"
#include "sp-root.h"
#include "document.h"
#include "path-prefix.h"
#include "sp-pattern.h"
#include "sp-image.h"
#include "sp-gradient.h"
#include "sp-radial-gradient.h"
#include "sp-linear-gradient.h"
#include "display/cairo-utils.h"
#include "splivarot.h" // pieces for union on shapes
#include "display/canvas-bpath.h" // for SPWindRule
#include "display/cairo-utils.h" // for Inkscape::Pixbuf::PF_CAIRO
#include "wmf-print.h"
#include <string.h>
#include <libuemf/symbol_convert.h>
namespace Inkscape {
namespace Extension {
namespace Internal {
#define PXPERMETER 2835
#define MAXDISP 2.0 // This should be set in the output dialog. This is ok for experimenting, no more than 2 pixel deviation. Not actually used at present
/* globals */
static double PX2WORLD; // value set in begin()
void PrintWmf::smuggle_adxky_out(const char *string, int16_t **adx, double *ky, int *rtl, int *ndx, float scale)
{
float fdx;
int i;
if (!*ndx) {
return; // this could happen with an empty string
}
cptr += 7;
if (!ladx) {
g_error("Out of memory");
}
}
cptr++; // skip 2nd fake terminator
}
{
// all of the class variables are initialized elsewhere, many in PrintWmf::Begin,
}
{
return TRUE;
}
{
char *rec;
// Typically PX2WORLD is 1200/90, using inkscape's default dpi
// WMF header the only things that can be set are the page size in inches (w,h) and the dpi
// width and height in px
// initialize a few global variables
if (nv) {
char *p2;
if (*p2) {
lc = 0;
}
}
bool pageBoundingBox;
if (pageBoundingBox) {
} else {
if (bbox) {
d = *bbox;
}
}
d *= Geom::Scale(Inkscape::Util::Quantity::convert(1, "px", "in")); // 90 dpi inside inkscape, wmf file will be 1200 dpi
/* -1/1200 in next two lines so that WMF read in will write out again at exactly the same size */
#if 0
#endif
if (!rec) {
g_error("Fatal programming error in PrintWmf::begin at WMRSETMAPMODE");
}
g_error("Fatal programming error in PrintWmf::begin at WMRSETWINDOWEXT");
}
g_error("Fatal programming error in PrintWmf::begin at WMRSETWINDOWORG");
}
g_error("Fatal programming error in PrintWmf::begin at WMRSETMAPMODE");
}
/* set some parameters, else the program that reads the WMF may default to other values */
g_error("Fatal programming error in PrintWmf::begin at U_WMRSETBKMODE");
}
g_error("Fatal programming error in PrintWmf::begin at U_WMRSETPOLYFILLMODE");
}
// Text alignment: (only changed if RTL text is encountered )
// - (x,y) coordinates received by this filter are those of the point where the text
// actually starts, and already takes into account the text object's alignment;
// - for this reason, the WMF text alignment must always be TA_BASELINE|TA_LEFT.
g_error("Fatal programming error in PrintWmf::begin at U_WMRSETTEXTALIGN_set");
}
g_error("Fatal programming error in PrintWmf::begin at U_WMRSETTEXTCOLOR_set");
}
g_error("Fatal programming error in PrintWmf::begin at U_WMRSETROP2");
}
hmiterlimit = 5;
g_error("Fatal programming error in PrintWmf::begin at wmiterlimit_set");
}
// create a pen as object 0. We never use it (except by mistake). Its purpose it to make all of the other object indices >=1
g_error("Fatal programming error in PrintWmf::begin at wcreatepenindirect_set");
}
// create a null pen. If no specific pen is set, this is used
g_error("Fatal programming error in PrintWmf::begin at wcreatepenindirect_set");
}
destroy_pen(); // make this pen active
// create a null brush. If no specific brush is set, this is used
g_error("Fatal programming error in PrintWmf::begin at wcreatebrushindirect_set");
}
destroy_brush(); // make this brush active
return 0;
}
{
char *rec;
if (!wt) {
return 0;
}
// get rid of null brush
g_error("Fatal programming error in PrintWmf::finish at wdeleteobject_set null brush");
}
// get rid of null pen
g_error("Fatal programming error in PrintWmf::finish at wdeleteobject_set null pen");
}
// get rid of object 0, which was a pen that was used to shift the other object indices to >=1.
hpen = 0;
g_error("Fatal programming error in PrintWmf::finish at wdeleteobject_set filler object");
}
g_error("Fatal programming error in PrintWmf::finish");
}
return 0;
}
{
if (!wt) {
return 0;
}
// earlier versions had flush of fill here, but it never executed and was removed
return 0;
}
// fcolor is defined when gradients are being expanded, it is the color of one stripe or ring.
{
float rgb[3];
char *rec;
int hatchType;
if (!wt) {
return 0;
}
// set a default fill in case we can't figure out a better way to do it
fmode = U_ALTERNATE;
if (fcolor) {
hatchColor = *fcolor;
} else {
hatchColor = U_RGB(0, 0, 0);
}
/* Dead assignment: Value stored to 'opacity' is never read
float opacity = SP_SCALE24_TO_FLOAT(style->fill_opacity.value);
if (opacity <= 0.0) {
opacity = 0.0; // basically the same as no fill
}
*/
fmode = style->fill_rule.computed == 0 ? U_WINDING : (style->fill_rule.computed == 2 ? U_ALTERNATE : U_ALTERNATE);
if (pixbuf) {
} else { // pattern
}
}
if (FixPPTPatternAsHatch) {
}
}
// currently we do not do anything with gradients, the code below just sets the color to the average of the stops
if (SP_IS_LINEARGRADIENT(paintserver)) {
} else if (SP_IS_RADIALGRADIENT(paintserver)) {
} else {
// default fill
}
if (rg) {
if (FixPPTGrad2Polys) {
} else {
}
} else if (lg) {
if (FixPPTGrad2Polys) {
} else {
}
}
}
} else { // if (!style)
// default fill
}
switch (fill_mode) {
case DRAW_LINEAR_GRADIENT: // fill with average color unless gradients are converted to slices
case DRAW_RADIAL_GRADIENT: // ditto
case DRAW_PAINT:
case DRAW_PATTERN:
// SVG text has no background attribute, so OPAQUE mode ALWAYS cancels after the next draw, otherwise it would mess up future text output.
if (usebk) {
g_error("Fatal programming error in PrintWmf::create_brush at U_WMRSETBKCOLOR_set");
}
g_error("Fatal programming error in PrintWmf::create_brush at U_WMRSETBKMODE_set");
}
}
g_error("Fatal programming error in PrintWmf::create_brush at createbrushindirect_set");
}
break;
case DRAW_IMAGE:
char *px;
char *rgba_px;
int numCt;
// pixbuf can be either PF_CAIRO or PF_GDK, and these have R and B bytes swapped
Bmih = bitmapinfoheader_set(width, height, 1, colortype, U_BI_RGB, 0, PXPERMETER, PXPERMETER, numCt, 0);
g_error("Fatal programming error in PrintWmf::create_brush at createdibpatternbrushpt_set");
}
break;
}
g_error("Fatal programming error in PrintWmf::create_brush at wselectobject_set");
}
if (fmode != hpolyfillmode) {
g_error("Fatal programming error in PrintWmf::create_brush at U_WMRSETPOLYFILLMODE_set");
}
}
return 0;
}
void PrintWmf::destroy_brush()
{
char *rec;
// WMF lets any object be deleted whenever, and the chips fall where they may...
if (hbrush) {
g_error("Fatal programming error in PrintWmf::destroy_brush");
}
hbrush = 0;
}
// (re)select the null brush
g_error("Fatal programming error in PrintWmf::destroy_brush");
}
}
{
int modstyle;
if (!wt) {
return 0;
}
// set a default stroke in case we can't figure out a better way to do it
modstyle = 0;
if (style) { // override some or all of the preceding
float rgb[3];
// WMF does not support hatched, bitmap, or gradient pens, just set the color.
using Geom::X;
using Geom::Y;
return 0; //if width is 0 do not (reset) the pen, it should already be NULL_PEN
}
// most WMF readers will ignore linecap and linejoin, but set them anyway. Inkscape itself can read them back in.
} else {
}
if (miterlimit < 1) {
miterlimit = 1;
}
// most WMF readers will ignore miterlimit, but set it anyway. Inkscape itself can read it back in
g_error("Fatal programming error in PrintWmf::create_pen at wmiterlimit_set");
}
}
} else {
}
if (!FixPPTDashLine) { // if this is set code elsewhere will break dots/dashes into many smaller lines.
penstyle = U_PS_DASH;// userstyle not supported apparently, for now map all Inkscape dot/dash to just dash
}
}
}
g_error("Fatal programming error in PrintWmf::create_pen at wcreatepenindirect_set");
}
g_error("Fatal programming error in PrintWmf::create_pen at wselectobject_set");
}
return 0;
}
// delete the defined pen object
void PrintWmf::destroy_pen()
{
// WMF lets any object be deleted whenever, and the chips fall where they may...
if (hpen) {
g_error("Fatal programming error in PrintWmf::destroy_pen");
}
hpen = 0;
}
// (re)select the null pen
g_error("Fatal programming error in PrintWmf::destroy_pen");
}
}
{
using Geom::X;
using Geom::Y;
use_fill = true;
use_stroke = false;
fill_transform = tf;
/*
Handle gradients. Uses modified livarot as 2geom boolops is currently broken.
Can handle gradients with multiple stops.
The overlap is needed to avoid antialiasing artifacts when edges are not strictly aligned on pixel boundaries.
There is an inevitable loss of accuracy saving through an WMF file because of the integer coordinate system.
Keep the overlap quite large so that loss of accuracy does not remove an overlap.
*/
destroy_pen(); //this sets the NULL_PEN, otherwise gradient slices may display with boundaries, see longer explanation below
float rgb[3];
double divisions = 128.0;
int nstops;
int istop = 1;
float opa; // opacity at stop
doff = 0.0;
doff_base = 0.0;
double start;
double stop;
/* radial gradient might stop part way through the shape, fill with outer color from there to "infinity".
Do this first so that outer colored ring will overlay it.
*/
pathvc = center_elliptical_hole_as_SVG_PathV(gv.p1, rx * (1.0 - overlap / range), ry * (1.0 - overlap / range), asin(xuv[Y]));
}
pathvc = center_elliptical_ring_as_SVG_PathV(gv.p1, rx * start / range, ry * start / range, rx * stop / range, ry * stop / range, asin(xuv[Y]));
istop++;
continue; // could happen on a rounding error
}
}
}
double start;
double stop;
/* before lower end of gradient, overlap first slice position */
/* after high end of gradient, overlap last slice position */
}
Geom::PathVector pathvr = sp_pathvector_boolop(pathvc, pathv, bool_op_inters, (FillRule) fill_nonZero, frb);
istop++;
continue; // could happen on a rounding error
}
}
}
} else {
g_error("Fatal programming error in PrintWmf::fill, invalid gradient type detected");
}
use_fill = false; // gradients handled, be sure stroke does not use stroke and fill
} else {
/*
Inkscape was not calling create_pen for objects with no border.
This was because it never called stroke() (next method).
PPT, and presumably others, pick whatever they want for the border if it is not specified, so no border can
become a visible border.
To avoid this force the pen to NULL_PEN if we can determine that no pen will be needed after the fill.
*/
destroy_pen(); //this sets the NULL_PEN
}
/* postpone fill in case stroke also required AND all stroke paths closed
Dashes converted to line segments will "open" a closed path.
*/
bool all_closed = true;
all_closed = false;
}
}
}
if (
) {
use_fill = false;
}
}
return 0;
}
{
use_stroke = true;
// use_fill was set in ::fill, if it is needed, if not, the null brush is used, it should be already set
return 0;
}
// convert the path, gets its complete length, and then make a new path with parameter length instead of t
Geom::Piecewise<Geom::D2<Geom::SBasis> > tmp_pathpw3; // new (discontinuous) path, composed of dots/dashes
int i = 0; //dash index
double tlength; // length of tmp_pathpw
double elength; // end of gragment
}
// go around the dash array repeatedly until the entire path is consumed (but not beyond).
}
if (slength) {
} else {
}
if (i >= n_dash) {
i = 0;
}
}
} else {
}
use_stroke = false;
use_fill = false;
if (usebk) { // OPAQUE was set, revert to TRANSPARENT
usebk = false;
g_error("Fatal programming error in PrintWmf::stroke at U_WMRSETBKMODE_set");
}
}
return 0;
}
// Draws simple_shapes, those with closed WMR_* primitives, like polygons, rectangles and ellipses.
// These use whatever the current pen/brush are and need not be followed by a FILLPATH or STROKEPATH.
// For other paths it sets a few flags and returns.
{
int nodes = 0;
int moves = 0;
int lines = 0;
int curves = 0;
moves++;
nodes++;
nodes++;
if (is_straight_curve(*cit)) {
lines++;
} else if (&*cit) {
curves++;
}
}
}
if (!nodes) {
return false;
}
int i = 0;
/** For all Subpaths in the <path> */
using Geom::X;
using Geom::Y;
i = i + 1;
/** For all segments in the subpath */
if (is_straight_curve(*cit)) {
//Geom::Point p0 = cit->initialPoint();
//p0[X] = (p0[X] * PX2WORLD);
//p0[Y] = (p0[Y] * PX2WORLD);
//int32_t const x0 = (int32_t) round(p0[X]);
//int32_t const y0 = (int32_t) round(p0[Y]);
i = i + 1;
//Geom::Point p0 = points[0];
//p0[X] = (p0[X] * PX2WORLD);
//p0[Y] = (p0[Y] * PX2WORLD);
//int32_t const x0 = (int32_t) round(p0[X]);
//int32_t const y0 = (int32_t) round(p0[Y]);
i = i + 3;
}
}
}
bool done = false;
bool polygon = false;
bool rectangle = false;
bool ellipse = false;
polygon = true;
// if (nodes==5) { // disable due to LP Bug 407394
// if (lpPoints[0].x == lpPoints[3].x && lpPoints[1].x == lpPoints[2].x &&
// lpPoints[0].y == lpPoints[1].y && lpPoints[2].y == lpPoints[3].y)
// {
// rectangle = true;
// }
// }
// if (lpPoints[0].x == lpPoints[1].x && lpPoints[1].x == lpPoints[11].x &&
// lpPoints[5].x == lpPoints[6].x && lpPoints[6].x == lpPoints[7].x &&
// lpPoints[2].x == lpPoints[10].x && lpPoints[3].x == lpPoints[9].x && lpPoints[4].x == lpPoints[8].x &&
// lpPoints[2].y == lpPoints[3].y && lpPoints[3].y == lpPoints[4].y &&
// lpPoints[8].y == lpPoints[9].y && lpPoints[9].y == lpPoints[10].y &&
// lpPoints[5].y == lpPoints[1].y && lpPoints[6].y == lpPoints[0].y && lpPoints[7].y == lpPoints[11].y)
// { // disable due to LP Bug 407394
// ellipse = true;
// }
}
// pens and brushes already set by caller, do not touch them
if (polygon) {
if (rectangle) {
}, (U_POINT16) {
});
} else {
}
} else if (ellipse) {
}, (U_POINT16) {
});
}
}
done = true;
}
delete[] lpPoints;
return done;
}
/** Some parts based on win32.cpp by Lauris Kaplinski <lauris@kaplinski.com>. Was a part of Inkscape
in the past (or will be in the future?) Not in current trunk. (4/19/2012)
Limitations of this code:
1. Images lose their rotation, one corner stays in the same place.
2. Transparency is lost on export. (A limitation of the WMF format.)
3. Probably messes up if row stride != w*4
4. There is still a small memory leak somewhere, possibly in a pixbuf created in a routine
that calls this one and passes px, but never removes the rest of the pixbuf. The first time
this is called it leaked 5M (in one test) and each subsequent call leaked around 200K more.
If this routine is reduced to
if(1)return(0);
and called for a single 1280 x 1024 image then the program leaks 11M per call, or roughly the
size of two bitmaps.
*/
unsigned char *rgba_px, /** array of pixel values, Gdk::Pixbuf bitmap format */
unsigned int w, /** width of bitmap */
unsigned int h, /** height of bitmap */
unsigned int rs, /** row stride (normally w*4) */
Geom::Affine const &tf_rect, /** affine transform only used for defining location and size of rect, for all other tranforms, use the one from m_tr_stack */
{
g_error("Fatal programming error in PrintWmf::image at EMRHEADER");
}
/* adjust scale of w and h. This works properly when there is no rotation. The values are
a bit strange when there is rotation, but since WMF cannot handle rotation in any case, all
answers are equally wrong.
*/
char *px;
int numCt;
Dest, //! Destination UL corner in logical units
cDest, //! Destination W & H in logical units
Src, //! Source UL corner in logical units
cSrc, //! Source W & H in logical units
U_DIB_RGB_COLORS, //! DIBColors Enumeration
U_SRCCOPY, //! RasterOPeration Enumeration
Bmi, //! (Optional) bitmapbuffer (U_BITMAPINFO section)
h * rs, //! size in bytes of px
px //! (Optional) bitmapbuffer (U_BITMAPINFO section)
);
g_error("Fatal programming error in PrintWmf::image at U_WMRSTRETCHDIB_set");
}
if (numCt) {
}
return 0;
}
// may also be called with a simple_shape or an empty path, whereupon it just returns without doing anything
{
// WMF does not have beziers, need to convert to ONLY linears with something like this:
/** For all Subpaths in the <path> */
/* If the path consists entirely of closed subpaths use one polypolygon.
Otherwise use a mix of polygon or polyline separately on each path.
because WMF has no POLYPOLYLINE.
The former allows path delimited donuts and the like, which
cannot be represented in WMF with polygon or polyline because there is no external way to combine paths
as there is in EMF or SVG.
reading program SHOULD close the path, which allows a conforming program not to, potentially rendering
a closed path as an open one. */
int nPolys = 0;
int totPoints = 0;
totPoints += 1 + pit->size_default(); // big array, will hold all points, for all polygons. Size_default ignores first point in each path.
nPolys++;
} else {
nPolys = 0;
break;
}
}
if (!pt16ptr) {
return(false);
}
if (!n16ptr) {
return(false);
}
using Geom::X;
using Geom::Y;
/** For each segment in the subpath */
}
}
g_error("Fatal programming error in PrintWmf::print_pathv at U_WMRPOLYPOLYGON_set");
}
} else { // one or more polyline or polygons (but not all polygons, that would be the preceding case)
using Geom::X;
using Geom::Y;
/* Malformatted Polylines with a sequence like M L M M L have been seen, the 2nd M does nothing
and that point must not go into the output. */
if (!(pit->size_default())) {
continue;
}
/* Figure out how many points there are, make an array big enough to hold them, and store
all the points. This is the same for open or closed path. This gives the upper bound for
the number of points. The actual number used is calculated on the fly.
*/
if (!pt16ptr) {
break;
}
/** For each segment in the subpath */
nPoints = 1;
}
g_error("Fatal programming error in PrintWmf::print_pathv at U_WMRPOLYGON_set");
}
} else if (nPoints > 2) {
g_error("Fatal programming error in PrintWmf::print_pathv at U_POLYLINE_set");
}
} else if (nPoints == 2) {
g_error("Fatal programming error in PrintWmf::print_pathv at U_WMRMOVETO_set");
}
g_error("Fatal programming error in PrintWmf::print_pathv at U_WMRLINETO_set");
}
}
}
}
}
// clean out brush and pen, but only after all parts of the draw complete
if (use_fill) {
}
if (use_stroke) {
destroy_pen();
}
return TRUE;
}
unsigned int PrintWmf::text(Inkscape::Extension::Print * /*mod*/, char const *text, Geom::Point const &p,
{
return 0;
}
int fix90n = 0;
double rotb = -std::atan2(tf[1], tf[0]); // rotation for baseline offset for superscript/subscript, used below
double ky;
// the dx array is smuggled in like: text<nul>w1 w2 w3 ...wn<nul><nul>, where the widths are floats 7 characters wide, including the space
smuggle_adxky_out(text, &adx, &ky, &rtl, &ndx, PX2WORLD * std::min(tf.expansionX(), tf.expansionY())); // side effect: free() adx
if (rtl > 0) {
} else {
}
if (textalignment != htextalignment) {
g_error("Fatal programming error in PrintWmf::text at U_WMRSETTEXTALIGN_set");
}
}
char *text2 = strdup(text); // because U_Utf8ToUtf16le calls iconv which does not like a const char *
//translates Unicode as Utf16le to NonUnicode, if possible. If any translate, all will, and all to
//the same font, because of code in Layout::print
// The preceding hopefully handled conversions to symbol, wingdings or zapf dingbats. Now slam everything
// else down into latin1, which is all WMF can handle. If the language isn't English expect terrible results.
// in some cases a UTF string may reduce to NO latin1 characters, which returns NULL
if(!latin1_text){ return 0; }
//PPT gets funky with text within +-1 degree of a multiple of 90, but only for SOME fonts.Snap those to the central value
//Some funky ones: Arial, Times New Roman
//Some not funky ones: Symbol and Verdana.
//Without a huge table we cannot catch them all, so just the most common problem ones.
if (FixPPTCharPos) {
switch (newfont) {
case CVTSYM:
break;
case CVTZDG:
break;
case CVTWDG:
break;
default: //also CVTNON
break;
}
fix90n = 2;
}
}
}
}
/*
Note that text font sizes are stored into the WMF as fairly small integers and that limits their precision.
The WMF output files produced here have been designed so that the integer valued pt sizes
land right on an integer value in the WMF file, so those are exact. However, something like 18.1 pt will be
somewhat off, so that when it is read back in it becomes 18.11 pt. (For instance.)
*/
int textheight = round(-style->font_size.computed * PX2WORLD * std::min(tf.expansionX(), tf.expansionY()));
if (!hfont) {
// Get font face name. Use changed font name if unicode mapped to one
// of the special fonts.
char *facename;
if (!newfont) {
} else {
}
// Scale the text to the minimum stretch. (It tends to stay within bounding rectangles even if
// it was streteched asymmetrically.) Few applications support text from WMF which is scaled
0,
facename);
g_error("Fatal programming error in PrintWmf::text at wcreatefontindirect_set");
}
}
g_error("Fatal programming error in PrintWmf::text at wselectobject_set");
}
float rgb[3];
// only change the text color when it needs to be changed
g_error("Fatal programming error in PrintWmf::text at U_WMRSETTEXTCOLOR_set");
}
}
// Text alignment:
// - (x,y) coordinates received by this filter are those of the point where the text
// actually starts, and already takes into account the text object's alignment;
// - for this reason, the WMF text alignment must always be TA_BASELINE|TA_LEFT.
// this is set at the beginning of the file and never changed
// Transparent text background, never changes, set at the beginning of the file
//Handle super/subscripts and vertical kerning
/* Previously used this, but vertical kerning was not supported
p2[Geom::X] -= style->baseline_shift.computed * std::sin( rotb );
p2[Geom::Y] -= style->baseline_shift.computed * std::cos( rotb );
*/
//Conditionally handle compensation for PPT WMF import bug (affects PPT 2003-2010, at least)
if (FixPPTCharPos) {
dx = 0.0;
dy = 0.0;
} else {
}
}
// The number of characters in the string is a bit fuzzy. ndx, the number of entries in adx is
// the number of VISIBLE characters, since some may combine from the UTF (8 originally,
// now 16) encoding. Conversely strlen() or wchar16len() would give the absolute number of
// encoding characters. Unclear if emrtext wants the former or the latter but for now assume the former.
// This is currently being smuggled in from caller as part of text, works
// MUCH better than the fallback hack below
// uint32_t *adx = dx_set(textheight, U_FW_NORMAL, slen); // dx is needed, this makes one up
if (rtl > 0) {
},
} else { // RTL text, U_TA_RTLREADING should be enough, but set this one too just in case
},
}
g_error("Fatal programming error in PrintWmf::text at U_WMREXTTEXTOUTW_set");
}
g_error("Fatal programming error in PrintWmf::text at wdeleteobject_set");
}
return 0;
}
{
/* WMF print */
"<name>Windows Metafile Print</name>\n"
"<id>org.inkscape.print.wmf</id>\n"
"<param name=\"destination\" type=\"string\"></param>\n"
"<param name=\"textToPath\" type=\"boolean\">true</param>\n"
"<param name=\"pageBoundingBox\" type=\"boolean\">true</param>\n"
"<param name=\"FixPPTCharPos\" type=\"boolean\">false</param>\n"
"<param name=\"FixPPTDashLine\" type=\"boolean\">false</param>\n"
"<param name=\"FixPPTGrad2Polys\" type=\"boolean\">false</param>\n"
"<param name=\"FixPPTPatternAsHatch\" type=\"boolean\">false</param>\n"
"<print/>\n"
"</inkscape-extension>", new PrintWmf());
return;
}
} /* namespace Internal */
} /* namespace Extension */
} /* namespace Inkscape */
/*
Local Variables:
mode:c++
c-file-style:"stroustrup"
c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
indent-tabs-mode:nil
fill-column:99
End:
*/
// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :