emf-inout.cpp revision 00d0240eaf3986ebaeedcbeabbdb727b73a5934b
4070N/A/** @file
4070N/A * @brief Windows-only Enhanced Metafile input and output.
4070N/A */
4070N/A/* Authors:
4070N/A * Ulf Erikson <ulferikson@users.sf.net>
4070N/A * Jon A. Cruz <jon@joncruz.org>
4070N/A * Abhishek Sharma
4070N/A *
4070N/A * Copyright (C) 2006-2008 Authors
4070N/A *
4070N/A * Released under GNU GPL, read the file 'COPYING' for more information
4070N/A *
4070N/A * References:
4070N/A * - How to Create & Play Enhanced Metafiles in Win32
4070N/A * http://support.microsoft.com/kb/q145999/
* - INFO: Windows Metafile Functions & Aldus Placeable Metafiles
* http://support.microsoft.com/kb/q66949/
* - Metafile Functions
* http://msdn.microsoft.com/library/en-us/gdi/metafile_0whf.asp
* - Metafile Structures
* http://msdn.microsoft.com/library/en-us/gdi/metafile_5hkj.asp
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#define EMF_DRIVER
#include "sp-root.h"
#include "sp-path.h"
#include "style.h"
#include "print.h"
#include "extension/system.h"
#include "extension/print.h"
#include "extension/db.h"
#include "extension/input.h"
#include "extension/output.h"
#include "display/drawing.h"
#include "display/drawing-item.h"
#include "unit-constants.h"
#include "clear-n_.h"
#include "document.h"
#include "libunicode-convert/unicode-convert.h"
#include "emf-print.h"
#include "emf-inout.h"
#include "uemf.h"
#define PRINT_EMF "org.inkscape.print.emf"
#ifndef U_PS_JOIN_MASK
#define U_PS_JOIN_MASK (U_PS_JOIN_BEVEL|U_PS_JOIN_MITER|U_PS_JOIN_ROUND)
#endif
namespace Inkscape {
namespace Extension {
namespace Internal {
static float device_scale = DEVICESCALE;
static U_RECTL rc_old;
static bool clipset = false;
static uint32_t ICMmode=0;
static uint32_t BLTmode=0;
/** Construct a PNG in memory from an RGB from the EMF file
from:
http://www.lemoda.net/c/write-png/
which was based on:
http://stackoverflow.com/questions/1821806/how-to-encode-png-to-buffer-using-libpng
gcc -Wall -o testpng testpng.c -lpng
*/
#include <png.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
/* A coloured pixel. */
typedef struct {
uint8_t red;
uint8_t green;
uint8_t blue;
uint8_t opacity;
} pixel_t;
/* A picture. */
typedef struct {
pixel_t *pixels;
size_t width;
size_t height;
} bitmap_t;
/* structure to store PNG image bytes */
typedef struct {
char *buffer;
size_t size;
} MEMPNG, *PMEMPNG;
/* Given "bitmap", this returns the pixel of bitmap at the point
("x", "y"). */
static pixel_t * pixel_at (bitmap_t * bitmap, int x, int y)
{
return bitmap->pixels + bitmap->width * y + x;
}
/* Write "bitmap" to a PNG file specified by "path"; returns 0 on
success, non-zero on error. */
void
my_png_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
{
/* with libpng15 next line causes pointer deference error; use libpng12 */
PMEMPNG p=(PMEMPNG)png_ptr->io_ptr;
size_t nsize = p->size + length;
/* allocate or grow buffer */
if(p->buffer)
p->buffer = (char *) realloc(p->buffer, nsize);
else
p->buffer = (char *) malloc(nsize);
if(!p->buffer)
png_error(png_ptr, "Write Error");
/* copy new bytes to end of buffer */
memcpy(p->buffer + p->size, data, length);
p->size += length;
}
void toPNG(PMEMPNG accum, int width, int height, char *px, uint32_t cbPx){
bitmap_t bmstore;
bitmap_t *bitmap=&bmstore;
accum->buffer=NULL; // PNG constructed in memory will end up here, caller must free().
accum->size=0;
bitmap->pixels=(pixel_t *)px;
bitmap->width = width;
bitmap->height = height;
png_structp png_ptr = NULL;
png_infop info_ptr = NULL;
size_t x, y;
png_byte ** row_pointers = NULL;
/* The following number is set by trial and error only. I cannot
see where it it is documented in the libpng manual.
*/
int pixel_size = 3;
int depth = 8;
png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (png_ptr == NULL){
accum->buffer=NULL;
return;
}
info_ptr = png_create_info_struct (png_ptr);
if (info_ptr == NULL){
png_destroy_write_struct (&png_ptr, &info_ptr);
accum->buffer=NULL;
return;
}
/* Set up error handling. */
if (setjmp (png_jmpbuf (png_ptr))) {
png_destroy_write_struct (&png_ptr, &info_ptr);
accum->buffer=NULL;
return;
}
/* Set image attributes. */
png_set_IHDR (png_ptr,
info_ptr,
bitmap->width,
bitmap->height,
depth,
PNG_COLOR_TYPE_RGB,
PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_DEFAULT,
PNG_FILTER_TYPE_DEFAULT);
/* Initialize rows of PNG. */
row_pointers = (png_byte **) png_malloc (png_ptr, bitmap->height * sizeof (png_byte *));
for (y = 0; y < bitmap->height; ++y) {
png_byte *row =
(png_byte *) png_malloc (png_ptr, sizeof (uint8_t) * bitmap->width * pixel_size);
row_pointers[bitmap->height - y - 1] = row; // Row order in EMF is reversed.
for (x = 0; x < bitmap->width; ++x) {
pixel_t * pixel = pixel_at (bitmap, x, y);
*row++ = pixel->red; // R & B channels were set correctly by DIB_to_RGB
*row++ = pixel->green;
*row++ = pixel->blue;
}
}
/* Write the image data to memory */
png_set_rows (png_ptr, info_ptr, row_pointers);
png_set_write_fn(png_ptr, accum, my_png_write_data, NULL);
png_write_png (png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, NULL);
for (y = 0; y < bitmap->height; y++) {
png_free (png_ptr, row_pointers[y]);
}
png_free (png_ptr, row_pointers);
png_destroy_write_struct(&png_ptr, &info_ptr);
}
/* Given "value" and "max", the maximum value which we expect "value"
to take, this returns an integer between 0 and 255 proportional to
"value" divided by "max". */
static int pix (int value, int max)
{
if (value < 0)
return 0;
return (int) (256.0 *((double) (value)/(double) max));
}
/* convert an EMF RGB(A) color to 0RGB
inverse of gethexcolor() in emf-print.cpp
*/
uint32_t sethexcolor(U_COLORREF color){
uint32_t out;
out = (U_RGBAGetR(color) << 16) +
(U_RGBAGetG(color) << 8 ) +
(U_RGBAGetB(color) );
return(out);
}
Emf::Emf (void) // The null constructor
{
return;
}
Emf::~Emf (void) //The destructor
{
return;
}
bool
Emf::check (Inkscape::Extension::Extension * /*module*/)
{
if (NULL == Inkscape::Extension::db.get(PRINT_EMF))
return FALSE;
return TRUE;
}
static void
emf_print_document_to_file(SPDocument *doc, gchar const *filename)
{
Inkscape::Extension::Print *mod;
SPPrintContext context;
gchar const *oldconst;
gchar *oldoutput;
unsigned int ret;
doc->ensureUpToDate();
mod = Inkscape::Extension::get_print(PRINT_EMF);
oldconst = mod->get_param_string("destination");
oldoutput = g_strdup(oldconst);
mod->set_param_string("destination", filename);
/* Start */
context.module = mod;
/* fixme: This has to go into module constructor somehow */
/* Create new arena */
mod->base = doc->getRoot();
Inkscape::Drawing drawing;
mod->dkey = SPItem::display_key_new(1);
mod->root = mod->base->invoke_show(drawing, mod->dkey, SP_ITEM_SHOW_DISPLAY);
drawing.setRoot(mod->root);
/* Print document */
ret = mod->begin(doc);
if (ret) {
g_free(oldoutput);
throw Inkscape::Extension::Output::save_failed();
}
mod->base->invoke_print(&context);
ret = mod->finish();
/* Release arena */
mod->base->invoke_hide(mod->dkey);
mod->base = NULL;
mod->root = NULL; // deleted by invoke_hide
/* end */
mod->set_param_string("destination", oldoutput);
g_free(oldoutput);
return;
}
void
Emf::save(Inkscape::Extension::Output *mod, SPDocument *doc, gchar const *filename)
{
Inkscape::Extension::Extension * ext;
ext = Inkscape::Extension::db.get(PRINT_EMF);
if (ext == NULL)
return;
bool new_val = mod->get_param_bool("textToPath");
bool new_FixPPTCharPos = mod->get_param_bool("FixPPTCharPos"); // character position bug
// reserve FixPPT2 for opacity bug. Currently EMF does not export opacity values
bool new_FixPPTDashLine = mod->get_param_bool("FixPPTDashLine"); // dashed line bug
bool new_FixPPTGrad2Polys = mod->get_param_bool("FixPPTGrad2Polys"); // gradient bug
bool new_FixPPTPatternAsHatch = mod->get_param_bool("FixPPTPatternAsHatch"); // force all patterns as standard EMF hatch
TableGen( //possibly regenerate the unicode-convert tables
mod->get_param_bool("TnrToSymbol"),
mod->get_param_bool("TnrToWingdings"),
mod->get_param_bool("TnrToZapfDingbats"),
mod->get_param_bool("UsePUA")
);
ext->set_param_bool("FixPPTCharPos",new_FixPPTCharPos); // Remember to add any new ones to PrintEmf::init or a mysterious failure will result!
ext->set_param_bool("FixPPTDashLine",new_FixPPTDashLine);
ext->set_param_bool("FixPPTGrad2Polys",new_FixPPTGrad2Polys);
ext->set_param_bool("FixPPTPatternAsHatch",new_FixPPTPatternAsHatch);
ext->set_param_bool("textToPath", new_val);
emf_print_document_to_file(doc, filename);
return;
}
enum drawmode {DRAW_PAINT, DRAW_PATTERN, DRAW_IMAGE}; // apply to either fill or stroke
typedef struct {
int type;
int level;
char *lpEMFR;
} EMF_OBJECT, *PEMF_OBJECT;
typedef struct {
int size; // number of slots allocated in strings
int count; // number of slots used in strings
char **strings; // place to store strings
} EMF_STRINGS, *PEMF_STRINGS;
typedef struct emf_device_context {
struct SPStyle style;
class SPTextStyle tstyle;
bool stroke_set;
int stroke_mode; // enumeration from drawmode, not used if fill_set is not True
int stroke_idx; // used with DRAW_PATTERN and DRAW_IMAGE to return the appropriate fill
bool fill_set;
int fill_mode; // enumeration from drawmode, not used if fill_set is not True
int fill_idx; // used with DRAW_PATTERN and DRAW_IMAGE to return the appropriate fill
U_SIZEL sizeWnd;
U_SIZEL sizeView;
float PixelsInX, PixelsInY;
float PixelsOutX, PixelsOutY;
U_POINTL winorg;
U_POINTL vieworg;
double ScaleInX, ScaleInY;
double ScaleOutX, ScaleOutY;
U_COLORREF textColor;
bool textColorSet;
U_COLORREF bkColor;
bool bkColorSet;
uint32_t textAlign;
U_XFORM worldTransform;
U_POINTL cur;
} EMF_DEVICE_CONTEXT, *PEMF_DEVICE_CONTEXT;
#define EMF_MAX_DC 128
typedef struct emf_callback_data {
Glib::ustring *outsvg;
Glib::ustring *path;
Glib::ustring *outdef;
Glib::ustring *defs;
EMF_DEVICE_CONTEXT dc[EMF_MAX_DC+1]; // FIXME: This should be dynamic..
int level;
double xDPI, yDPI;
uint32_t mask; // Draw properties
int arcdir; //U_AD_COUNTERCLOCKWISE 1 or U_AD_CLOCKWISE 2
uint32_t dwRop2; // Binary raster operation, 0 if none (use brush/pen unmolested)
uint32_t dwRop3; // Ternary raster operation, 0 if none (use brush/pen unmolested)
float MMX;
float MMY;
float dwInchesX;
float dwInchesY;
unsigned int id;
unsigned int drawtype; // one of 0 or U_EMR_FILLPATH, U_EMR_STROKEPATH, U_EMR_STROKEANDFILLPATH
char *pDesc;
// both of these end up in <defs> under the names shown here. These structures allow duplicates to be avoided.
EMF_STRINGS hatches; // hold pattern names, all like EMFhatch#_$$$$$$ where # is the EMF hatch code and $$$$$$ is the color
EMF_STRINGS images; // hold images, all like Image#, where # is the slot the image lives.
int n_obj;
PEMF_OBJECT emf_obj;
} EMF_CALLBACK_DATA, *PEMF_CALLBACK_DATA;
/* Add another 100 blank slots to the hatches array.
*/
void enlarge_hatches(PEMF_CALLBACK_DATA d){
d->hatches.size += 100;
d->hatches.strings = (char **) realloc(d->hatches.strings,d->hatches.size + sizeof(char *));
}
/* See if the pattern name is already in the list. If it is return its position (1->n, not 1-n-1)
*/
int in_hatches(PEMF_CALLBACK_DATA d, char *test){
int i;
for(i=0; i<d->hatches.count; i++){
if(strcmp(test,d->hatches.strings[i])==0)return(i+1);
}
return(0);
}
/* (Conditionally) add a hatch. If a matching hatch already exists nothing happens. If one
does not exist it is added to the hatches list and also entered into <defs>.
*/
uint32_t add_hatch(PEMF_CALLBACK_DATA d, uint32_t hatchType, U_COLORREF hatchColor){
char hatchname[64]; // big enough
char tmpcolor[8];
uint32_t idx;
if(hatchType==U_HS_DIAGCROSS){ // This is the only one with dependencies on others
(void) add_hatch(d,U_HS_FDIAGONAL,hatchColor);
(void) add_hatch(d,U_HS_BDIAGONAL,hatchColor);
}
sprintf(tmpcolor,"%6.6X",sethexcolor(hatchColor));
switch(hatchType){
case U_HS_SOLIDTEXTCLR:
case U_HS_DITHEREDTEXTCLR:
if(d->dc[d->level].textColorSet){
sprintf(tmpcolor,"%6.6X",sethexcolor(d->dc[d->level].textColor));
}
break;
case U_HS_SOLIDBKCLR:
case U_HS_DITHEREDBKCLR:
if(d->dc[d->level].bkColorSet){
sprintf(tmpcolor,"%6.6X",sethexcolor(d->dc[d->level].bkColor));
}
break;
default:
break;
}
// EMF can take solid colors from background or the default text color but on conversion to inkscape
// these need to go to a defined color. Consequently the hatchType also has to go to a solid color, otherwise
// on export the background/text might not match at the time this is written, and the colors will shift.
if(hatchType > U_HS_SOLIDCLR)hatchType = U_HS_SOLIDCLR;
sprintf(hatchname,"EMFhatch%d_%s",hatchType,tmpcolor);
idx = in_hatches(d,hatchname);
if(!idx){ // add it if not already present
if(d->hatches.count == d->hatches.size){ enlarge_hatches(d); }
d->hatches.strings[d->hatches.count++]=strdup(hatchname);
*(d->defs) += "\n";
*(d->defs) += " <pattern id=\"";
*(d->defs) += hatchname;
*(d->defs) += "\"\n";
switch(hatchType){
case U_HS_HORIZONTAL:
*(d->defs) += " patternUnits=\"userSpaceOnUse\" width=\"6\" height=\"6\" x=\"0\" y=\"0\" >\n";
*(d->defs) += " <path d=\"M 0 0 6 0\" style=\"fill:none;stroke:#";
*(d->defs) += tmpcolor;
*(d->defs) += "\" />\n";
*(d->defs) += " </pattern>\n";
break;
case U_HS_VERTICAL:
*(d->defs) += " patternUnits=\"userSpaceOnUse\" width=\"6\" height=\"6\" x=\"0\" y=\"0\" >\n";
*(d->defs) += " <path d=\"M 0 0 0 6\" style=\"fill:none;stroke:#";
*(d->defs) += tmpcolor;
*(d->defs) += "\" />\n";
*(d->defs) += " </pattern>\n";
break;
case U_HS_FDIAGONAL:
*(d->defs) += " patternUnits=\"userSpaceOnUse\" width=\"6\" height=\"6\" x=\"0\" y=\"0\" viewBox=\"0 0 6 6\" preserveAspectRatio=\"none\" >\n";
*(d->defs) += " <line x1=\"-1\" y1=\"-1\" x2=\"7\" y2=\"7\" stroke=\"#";
*(d->defs) += tmpcolor;
*(d->defs) += "\" id=\"sub";
*(d->defs) += hatchname;
*(d->defs) += "\"/>\n";
*(d->defs) += " <use xlink:href=\"#sub";
*(d->defs) += hatchname;
*(d->defs) += "\" transform=\"translate(6,0)\"/>\n";
*(d->defs) += " <use xlink:href=\"#sub";
*(d->defs) += hatchname;
*(d->defs) += "\" transform=\"translate(-6,0)\"/>\n";
*(d->defs) += " </pattern>\n";
break;
case U_HS_BDIAGONAL:
*(d->defs) += " patternUnits=\"userSpaceOnUse\" width=\"6\" height=\"6\" x=\"0\" y=\"0\" viewBox=\"0 0 6 6\" preserveAspectRatio=\"none\" >\n";
*(d->defs) += " <line x1=\"-1\" y1=\"7\" x2=\"7\" y2=\"-1\" stroke=\"#";
*(d->defs) += tmpcolor;
*(d->defs) += "\" id=\"sub";
*(d->defs) += hatchname;
*(d->defs) += "\"/>\n";
*(d->defs) += " <use xlink:href=\"#sub";
*(d->defs) += hatchname;
*(d->defs) += "\" transform=\"translate(6,0)\"/>\n";
*(d->defs) += " <use xlink:href=\"#sub";
*(d->defs) += hatchname;
*(d->defs) += "\" transform=\"translate(-6,0)\"/>\n";
*(d->defs) += " </pattern>\n";
break;
case U_HS_CROSS:
*(d->defs) += " patternUnits=\"userSpaceOnUse\" width=\"6\" height=\"6\" x=\"0\" y=\"0\" >\n";
*(d->defs) += " <path d=\"M 0 0 6 0 M 0 0 0 6\" style=\"fill:none;stroke:#";
*(d->defs) += tmpcolor;
*(d->defs) += "\" />\n";
*(d->defs) += " </pattern>\n";
break;
case U_HS_DIAGCROSS:
*(d->defs) += " patternUnits=\"userSpaceOnUse\" width=\"6\" height=\"6\" x=\"0\" y=\"0\" viewBox=\"0 0 6 6\" preserveAspectRatio=\"none\" >\n";
*(d->defs) += " <use xlink:href=\"#sub";
sprintf(hatchname,"EMFhatch%d_%6.6X",U_HS_FDIAGONAL,sethexcolor(hatchColor));
*(d->defs) += hatchname;
*(d->defs) += "\" transform=\"translate(0,0)\"/>\n";
*(d->defs) += " <use xlink:href=\"#sub";
sprintf(hatchname,"EMFhatch%d_%6.6X",U_HS_BDIAGONAL,sethexcolor(hatchColor));
*(d->defs) += hatchname;
*(d->defs) += "\" transform=\"translate(0,0)\"/>\n";
*(d->defs) += " </pattern>\n";
break;
case U_HS_SOLIDCLR:
case U_HS_DITHEREDCLR:
case U_HS_SOLIDTEXTCLR:
case U_HS_DITHEREDTEXTCLR:
case U_HS_SOLIDBKCLR:
case U_HS_DITHEREDBKCLR:
default:
*(d->defs) += " patternUnits=\"userSpaceOnUse\" width=\"6\" height=\"6\" x=\"0\" y=\"0\" >\n";
*(d->defs) += " <path d=\"M 0 0 6 0 6 6 0 6 z\" style=\"fill:#";
*(d->defs) += tmpcolor;
*(d->defs) += ";stroke:none";
*(d->defs) += "\" />\n";
*(d->defs) += " </pattern>\n";
break;
}
idx = d->hatches.count;
}
return(idx-1);
}
/* Add another 100 blank slots to the images array.
*/
void enlarge_images(PEMF_CALLBACK_DATA d){
d->images.size += 100;
d->images.strings = (char **) realloc(d->images.strings,d->images.size + sizeof(char *));
}
/* See if the image string is already in the list. If it is return its position (1->n, not 1-n-1)
*/
int in_images(PEMF_CALLBACK_DATA d, char *test){
int i;
for(i=0; i<d->images.count; i++){
if(strcmp(test,d->images.strings[i])==0)return(i+1);
}
return(0);
}
/* (Conditionally) add an image. If a matching image already exists nothing happens. If one
does not exist it is added to the images list and also entered into <defs>.
U_EMRCREATEMONOBRUSH records only work when the bitmap is monochrome. If we hit one that isn't
set idx to 2^32-1 and let the caller handle it.
*/
uint32_t add_image(PEMF_CALLBACK_DATA d, void *pEmr, uint32_t cbBits, uint32_t cbBmi, uint32_t iUsage, uint32_t offBits, uint32_t offBmi){
uint32_t idx;
char imagename[64]; // big enough
char xywh[64]; // big enough
MEMPNG mempng; // PNG in memory comes back in this
mempng.buffer = NULL;
char *rgba_px=NULL; // RGBA pixels
char *px=NULL; // DIB pixels
uint32_t width, height, colortype, numCt, invert;
PU_RGBQUAD ct = NULL;
if(!cbBits ||
!cbBmi ||
(iUsage != U_DIB_RGB_COLORS) ||
!get_DIB_params( // this returns pointers and values, but allocates no memory
pEmr,
offBits,
offBmi,
&px,
&ct,
&numCt,
&width,
&height,
&colortype,
&invert
)){
// U_EMRCREATEMONOBRUSH uses text/bk colors instead of what is in the color map.
if(((PU_EMR)pEmr)->iType == U_EMR_CREATEMONOBRUSH){
if(numCt==2){
ct[0] = U_RGB2BGR(d->dc[d->level].textColor);
ct[1] = U_RGB2BGR(d->dc[d->level].bkColor);
}
else { // createmonobrush renders on other platforms this way
return(0xFFFFFFFF);
}
}
if(!DIB_to_RGBA(
px, // DIB pixel array
ct, // DIB color table
numCt, // DIB color table number of entries
&rgba_px, // U_RGBA pixel array (32 bits), created by this routine, caller must free.
width, // Width of pixel array
height, // Height of pixel array
colortype, // DIB BitCount Enumeration
numCt, // Color table used if not 0
invert // If DIB rows are in opposite order from RGBA rows
) &&
rgba_px)
{
toPNG( // Get the image from the RGBA px into mempng
&mempng,
width, height,
rgba_px,
4 * width * height);
free(rgba_px);
}
}
gchar *base64String;
if(mempng.buffer){
base64String = g_base64_encode((guchar*) mempng.buffer, mempng.size );
free(mempng.buffer);
idx = in_images(d, (char *) base64String);
}
else {
// insert a random 3x4 blotch otherwise
width = 3;
height = 4;
base64String = strdup("iVBORw0KGgoAAAANSUhEUgAAAAQAAAADCAIAAAA7ljmRAAAAA3NCSVQICAjb4U/gAAAALElEQVQImQXBQQ2AMAAAsUJQMSWI2H8qME1yMshojwrvGB8XcHKvR1XtOTc/8HENumHCsOMAAAAASUVORK5CYII=");
idx = in_images(d, (char *) base64String);
}
if(!idx){ // add it if not already present
if(d->images.count == d->images.size){ enlarge_images(d); }
idx = d->images.count;
d->images.strings[d->images.count++]=strdup(base64String);
sprintf(imagename,"EMFimage%d",idx++);
sprintf(xywh," x=\"0\" y=\"0\" width=\"%d\" height=\"%d\" ",width,height); // reuse this buffer
*(d->defs) += "\n";
*(d->defs) += " <image id=\"";
*(d->defs) += imagename;
*(d->defs) += "\"\n ";
*(d->defs) += xywh;
*(d->defs) += "\n";
*(d->defs) += " xlink:href=\"data:image/png;base64,";
*(d->defs) += base64String;
*(d->defs) += "\"\n";
*(d->defs) += " />\n";
*(d->defs) += "\n";
*(d->defs) += " <pattern id=\"";
*(d->defs) += imagename;
*(d->defs) += "_ref\"\n ";
*(d->defs) += xywh;
*(d->defs) += "\n patternUnits=\"userSpaceOnUse\"";
*(d->defs) += " >\n";
*(d->defs) += " <use id=\"";
*(d->defs) += imagename;
*(d->defs) += "_ign\" ";
*(d->defs) += " xlink:href=\"#";
*(d->defs) += imagename;
*(d->defs) += "\" />\n";
*(d->defs) += " </pattern>\n";
}
g_free(base64String);
return(idx-1);
}
static void
output_style(PEMF_CALLBACK_DATA d, int iType)
{
// SVGOStringStream tmp_id;
SVGOStringStream tmp_style;
char tmp[1024] = {0};
float fill_rgb[3];
sp_color_get_rgb_floatv( &(d->dc[d->level].style.fill.value.color), fill_rgb );
float stroke_rgb[3];
sp_color_get_rgb_floatv(&(d->dc[d->level].style.stroke.value.color), stroke_rgb);
// for U_EMR_BITBLT with no image, try to approximate some of these operations/
// Assume src color is "white"
if(d->dwRop3){
switch(d->dwRop3){
case U_PATINVERT: // treat all of these as black
case U_SRCINVERT:
case U_DSTINVERT:
case U_BLACKNESS:
case U_SRCERASE:
case U_NOTSRCCOPY:
fill_rgb[0]=fill_rgb[1]=fill_rgb[2]=0.0;
break;
case U_SRCCOPY: // treat all of these as white
case U_NOTSRCERASE:
case U_PATCOPY:
case U_WHITENESS:
fill_rgb[0]=fill_rgb[1]=fill_rgb[2]=1.0;
break;
case U_SRCPAINT: // use the existing color
case U_SRCAND:
case U_MERGECOPY:
case U_MERGEPAINT:
case U_PATPAINT:
default:
break;
}
d->dwRop3 = 0; // might as well reset it here, it must be set for each BITBLT
}
// Implement some of these, the ones where the original screen color does not matter.
// The options that merge screen and pen colors cannot be done correctly because we
// have no way of knowing what color is already on the screen. For those just pass the
// pen color through.
switch(d->dwRop2){
case U_R2_BLACK:
fill_rgb[0] = fill_rgb[1] = fill_rgb[2] = 0.0;
stroke_rgb[0]= stroke_rgb[1]= stroke_rgb[2] = 0.0;
break;
case U_R2_NOTMERGEPEN:
case U_R2_MASKNOTPEN:
break;
case U_R2_NOTCOPYPEN:
fill_rgb[0] = 1.0 - fill_rgb[0];
fill_rgb[1] = 1.0 - fill_rgb[1];
fill_rgb[2] = 1.0 - fill_rgb[2];
stroke_rgb[0] = 1.0 - stroke_rgb[0];
stroke_rgb[1] = 1.0 - stroke_rgb[1];
stroke_rgb[2] = 1.0 - stroke_rgb[2];
break;
case U_R2_MASKPENNOT:
case U_R2_NOT:
case U_R2_XORPEN:
case U_R2_NOTMASKPEN:
case U_R2_NOTXORPEN:
case U_R2_NOP:
case U_R2_MERGENOTPEN:
case U_R2_COPYPEN:
case U_R2_MASKPEN:
case U_R2_MERGEPENNOT:
case U_R2_MERGEPEN:
break;
case U_R2_WHITE:
fill_rgb[0] = fill_rgb[1] = fill_rgb[2] = 1.0;
stroke_rgb[0]= stroke_rgb[1]= stroke_rgb[2] = 1.0;
break;
default:
break;
}
// tmp_id << "\n\tid=\"" << (d->id++) << "\"";
// *(d->outsvg) += tmp_id.str().c_str();
*(d->outsvg) += "\n\tstyle=\"";
if (iType == U_EMR_STROKEPATH || !d->dc[d->level].fill_set) {
tmp_style << "fill:none;";
} else {
switch(d->dc[d->level].fill_mode){
// both of these use the url(#) method
case DRAW_PATTERN:
snprintf(tmp, 1023, "fill:url(#%s); ",d->hatches.strings[d->dc[d->level].fill_idx]);
tmp_style << tmp;
break;
case DRAW_IMAGE:
snprintf(tmp, 1023, "fill:url(#EMFimage%d_ref); ",d->dc[d->level].fill_idx);
tmp_style << tmp;
break;
case DRAW_PAINT:
default: // <-- this should never happen, but just in case...
snprintf(tmp, 1023,
"fill:#%02x%02x%02x;",
SP_COLOR_F_TO_U(fill_rgb[0]),
SP_COLOR_F_TO_U(fill_rgb[1]),
SP_COLOR_F_TO_U(fill_rgb[2]));
tmp_style << tmp;
break;
}
snprintf(tmp, 1023,
"fill-rule:%s;",
d->dc[d->level].style.fill_rule.value == 0 ? "evenodd" : "nonzero");
tmp_style << tmp;
tmp_style << "fill-opacity:1;";
if (d->dc[d->level].fill_set && d->dc[d->level].stroke_set && d->dc[d->level].style.stroke_width.value == 1 &&
fill_rgb[0]==stroke_rgb[0] && fill_rgb[1]==stroke_rgb[1] && fill_rgb[2]==stroke_rgb[2])
{
d->dc[d->level].stroke_set = false;
}
}
if (iType == U_EMR_FILLPATH || !d->dc[d->level].stroke_set) {
tmp_style << "stroke:none;";
} else {
switch(d->dc[d->level].stroke_mode){
// both of these use the url(#) method
case DRAW_PATTERN:
snprintf(tmp, 1023, "stroke:url(#%s); ",d->hatches.strings[d->dc[d->level].stroke_idx]);
tmp_style << tmp;
break;
case DRAW_IMAGE:
snprintf(tmp, 1023, "stroke:url(#EMFimage%d_ref); ",d->dc[d->level].stroke_idx);
tmp_style << tmp;
break;
case DRAW_PAINT:
default: // <-- this should never happen, but just in case...
snprintf(tmp, 1023,
"stroke:#%02x%02x%02x;",
SP_COLOR_F_TO_U(stroke_rgb[0]),
SP_COLOR_F_TO_U(stroke_rgb[1]),
SP_COLOR_F_TO_U(stroke_rgb[2]));
tmp_style << tmp;
break;
}
tmp_style << "stroke-width:" <<
MAX( 0.001, d->dc[d->level].style.stroke_width.value ) << "px;";
tmp_style << "stroke-linecap:" <<
(d->dc[d->level].style.stroke_linecap.computed == 0 ? "butt" :
d->dc[d->level].style.stroke_linecap.computed == 1 ? "round" :
d->dc[d->level].style.stroke_linecap.computed == 2 ? "square" :
"unknown") << ";";
tmp_style << "stroke-linejoin:" <<
(d->dc[d->level].style.stroke_linejoin.computed == 0 ? "miter" :
d->dc[d->level].style.stroke_linejoin.computed == 1 ? "round" :
d->dc[d->level].style.stroke_linejoin.computed == 2 ? "bevel" :
"unknown") << ";";
// Set miter limit if known, even if it is not needed immediately (not miter)
tmp_style << "stroke-miterlimit:" <<
MAX( 2.0, d->dc[d->level].style.stroke_miterlimit.value ) << ";";
if (d->dc[d->level].style.stroke_dasharray_set &&
d->dc[d->level].style.stroke_dash.n_dash && d->dc[d->level].style.stroke_dash.dash)
{
tmp_style << "stroke-dasharray:";
for (int i=0; i<d->dc[d->level].style.stroke_dash.n_dash; i++) {
if (i)
tmp_style << ",";
tmp_style << d->dc[d->level].style.stroke_dash.dash[i];
}
tmp_style << ";";
tmp_style << "stroke-dashoffset:0;";
} else {
tmp_style << "stroke-dasharray:none;";
}
tmp_style << "stroke-opacity:1;";
}
tmp_style << "\" ";
if (clipset)
tmp_style << "\n\tclip-path=\"url(#clipEmfPath" << d->id << ")\" ";
clipset = false;
*(d->outsvg) += tmp_style.str().c_str();
}
static double
_pix_x_to_point(PEMF_CALLBACK_DATA d, double px)
{
double tmp = px - d->dc[d->level].winorg.x;
tmp *= d->dc[d->level].ScaleInX ? d->dc[d->level].ScaleInX : 1.0;
tmp += d->dc[d->level].vieworg.x;
return tmp;
}
static double
_pix_y_to_point(PEMF_CALLBACK_DATA d, double px)
{
double tmp = px - d->dc[d->level].winorg.y;
tmp *= d->dc[d->level].ScaleInY ? d->dc[d->level].ScaleInY : 1.0;
tmp += d->dc[d->level].vieworg.y;
return tmp;
}
static double
pix_to_x_point(PEMF_CALLBACK_DATA d, double px, double py)
{
double ppx = _pix_x_to_point(d, px);
double ppy = _pix_y_to_point(d, py);
double x = ppx * d->dc[d->level].worldTransform.eM11 + ppy * d->dc[d->level].worldTransform.eM21 + d->dc[d->level].worldTransform.eDx;
x *= device_scale;
return x;
}
static double
pix_to_y_point(PEMF_CALLBACK_DATA d, double px, double py)
{
double ppx = _pix_x_to_point(d, px);
double ppy = _pix_y_to_point(d, py);
double y = ppx * d->dc[d->level].worldTransform.eM12 + ppy * d->dc[d->level].worldTransform.eM22 + d->dc[d->level].worldTransform.eDy;
y *= device_scale;
return y;
}
static double
pix_to_size_point(PEMF_CALLBACK_DATA d, double px)
{
double ppx = px * (d->dc[d->level].ScaleInX ? d->dc[d->level].ScaleInX : 1.0);
double ppy = 0;
double dx = ppx * d->dc[d->level].worldTransform.eM11 + ppy * d->dc[d->level].worldTransform.eM21;
dx *= device_scale;
double dy = ppx * d->dc[d->level].worldTransform.eM12 + ppy * d->dc[d->level].worldTransform.eM22;
dy *= device_scale;
double tmp = sqrt(dx * dx + dy * dy);
return tmp;
}
static void
select_pen(PEMF_CALLBACK_DATA d, int index)
{
PU_EMRCREATEPEN pEmr = NULL;
if (index >= 0 && index < d->n_obj)
pEmr = (PU_EMRCREATEPEN) d->emf_obj[index].lpEMFR;
if (!pEmr)
return;
switch (pEmr->lopn.lopnStyle & U_PS_STYLE_MASK) {
case U_PS_DASH:
case U_PS_DOT:
case U_PS_DASHDOT:
case U_PS_DASHDOTDOT:
{
int i = 0;
int penstyle = (pEmr->lopn.lopnStyle & U_PS_STYLE_MASK);
d->dc[d->level].style.stroke_dash.n_dash =
penstyle == U_PS_DASHDOTDOT ? 6 : penstyle == U_PS_DASHDOT ? 4 : 2;
if (d->dc[d->level].style.stroke_dash.dash && (d->level==0 || (d->level>0 && d->dc[d->level].style.stroke_dash.dash!=d->dc[d->level-1].style.stroke_dash.dash)))
delete[] d->dc[d->level].style.stroke_dash.dash;
d->dc[d->level].style.stroke_dash.dash = new double[d->dc[d->level].style.stroke_dash.n_dash];
if (penstyle==U_PS_DASH || penstyle==U_PS_DASHDOT || penstyle==U_PS_DASHDOTDOT) {
d->dc[d->level].style.stroke_dash.dash[i++] = 3;
d->dc[d->level].style.stroke_dash.dash[i++] = 1;
}
if (penstyle==U_PS_DOT || penstyle==U_PS_DASHDOT || penstyle==U_PS_DASHDOTDOT) {
d->dc[d->level].style.stroke_dash.dash[i++] = 1;
d->dc[d->level].style.stroke_dash.dash[i++] = 1;
}
if (penstyle==U_PS_DASHDOTDOT) {
d->dc[d->level].style.stroke_dash.dash[i++] = 1;
d->dc[d->level].style.stroke_dash.dash[i++] = 1;
}
d->dc[d->level].style.stroke_dasharray_set = 1;
break;
}
case U_PS_SOLID:
default:
{
d->dc[d->level].style.stroke_dasharray_set = 0;
break;
}
}
switch (pEmr->lopn.lopnStyle & U_PS_ENDCAP_MASK) {
case U_PS_ENDCAP_ROUND:
{
d->dc[d->level].style.stroke_linecap.computed = 1;
break;
}
case U_PS_ENDCAP_SQUARE:
{
d->dc[d->level].style.stroke_linecap.computed = 2;
break;
}
case U_PS_ENDCAP_FLAT:
default:
{
d->dc[d->level].style.stroke_linecap.computed = 0;
break;
}
}
switch (pEmr->lopn.lopnStyle & U_PS_JOIN_MASK) {
case U_PS_JOIN_BEVEL:
{
d->dc[d->level].style.stroke_linejoin.computed = 2;
break;
}
case U_PS_JOIN_MITER:
{
d->dc[d->level].style.stroke_linejoin.computed = 0;
break;
}
case U_PS_JOIN_ROUND:
default:
{
d->dc[d->level].style.stroke_linejoin.computed = 1;
break;
}
}
d->dc[d->level].stroke_set = true;
if (pEmr->lopn.lopnStyle == U_PS_NULL) {
d->dc[d->level].style.stroke_width.value = 0;
d->dc[d->level].stroke_set = false;
} else if (pEmr->lopn.lopnWidth.x) {
int cur_level = d->level;
d->level = d->emf_obj[index].level;
double pen_width = pix_to_size_point( d, pEmr->lopn.lopnWidth.x );
d->level = cur_level;
d->dc[d->level].style.stroke_width.value = pen_width;
} else { // this stroke should always be rendered as 1 pixel wide, independent of zoom level (can that be done in SVG?)
//d->dc[d->level].style.stroke_width.value = 1.0;
int cur_level = d->level;
d->level = d->emf_obj[index].level;
double pen_width = pix_to_size_point( d, 1 );
d->level = cur_level;
d->dc[d->level].style.stroke_width.value = pen_width;
}
double r, g, b;
r = SP_COLOR_U_TO_F( U_RGBAGetR(pEmr->lopn.lopnColor) );
g = SP_COLOR_U_TO_F( U_RGBAGetG(pEmr->lopn.lopnColor) );
b = SP_COLOR_U_TO_F( U_RGBAGetB(pEmr->lopn.lopnColor) );
d->dc[d->level].style.stroke.value.color.set( r, g, b );
}
static void
select_extpen(PEMF_CALLBACK_DATA d, int index)
{
PU_EMREXTCREATEPEN pEmr = NULL;
if (index >= 0 && index < d->n_obj)
pEmr = (PU_EMREXTCREATEPEN) d->emf_obj[index].lpEMFR;
if (!pEmr)
return;
switch (pEmr->elp.elpPenStyle & U_PS_STYLE_MASK) {
case U_PS_USERSTYLE:
{
if (pEmr->elp.elpNumEntries) {
d->dc[d->level].style.stroke_dash.n_dash = pEmr->elp.elpNumEntries;
if (d->dc[d->level].style.stroke_dash.dash && (d->level==0 || (d->level>0 && d->dc[d->level].style.stroke_dash.dash!=d->dc[d->level-1].style.stroke_dash.dash)))
delete[] d->dc[d->level].style.stroke_dash.dash;
d->dc[d->level].style.stroke_dash.dash = new double[pEmr->elp.elpNumEntries];
for (unsigned int i=0; i<pEmr->elp.elpNumEntries; i++) {
int cur_level = d->level;
d->level = d->emf_obj[index].level;
// Doing it this way typically results in a pattern that is tiny, better to assume the array
// is the same scale as for dot/dash below, that is, no scaling should be applied
// double dash_length = pix_to_size_point( d, pEmr->elp.elpStyleEntry[i] );
double dash_length = pEmr->elp.elpStyleEntry[i];
d->level = cur_level;
d->dc[d->level].style.stroke_dash.dash[i] = dash_length;
}
d->dc[d->level].style.stroke_dasharray_set = 1;
} else {
d->dc[d->level].style.stroke_dasharray_set = 0;
}
break;
}
case U_PS_DASH:
case U_PS_DOT:
case U_PS_DASHDOT:
case U_PS_DASHDOTDOT:
{
int i = 0;
int penstyle = (pEmr->elp.elpPenStyle & U_PS_STYLE_MASK);
d->dc[d->level].style.stroke_dash.n_dash =
penstyle == U_PS_DASHDOTDOT ? 6 : penstyle == U_PS_DASHDOT ? 4 : 2;
if (d->dc[d->level].style.stroke_dash.dash && (d->level==0 || (d->level>0 && d->dc[d->level].style.stroke_dash.dash!=d->dc[d->level-1].style.stroke_dash.dash)))
delete[] d->dc[d->level].style.stroke_dash.dash;
d->dc[d->level].style.stroke_dash.dash = new double[d->dc[d->level].style.stroke_dash.n_dash];
if (penstyle==U_PS_DASH || penstyle==U_PS_DASHDOT || penstyle==U_PS_DASHDOTDOT) {
d->dc[d->level].style.stroke_dash.dash[i++] = 3;
d->dc[d->level].style.stroke_dash.dash[i++] = 2;
}
if (penstyle==U_PS_DOT || penstyle==U_PS_DASHDOT || penstyle==U_PS_DASHDOTDOT) {
d->dc[d->level].style.stroke_dash.dash[i++] = 1;
d->dc[d->level].style.stroke_dash.dash[i++] = 2;
}
if (penstyle==U_PS_DASHDOTDOT) {
d->dc[d->level].style.stroke_dash.dash[i++] = 1;
d->dc[d->level].style.stroke_dash.dash[i++] = 2;
}
d->dc[d->level].style.stroke_dasharray_set = 1;
break;
}
case U_PS_SOLID:
default:
{
d->dc[d->level].style.stroke_dasharray_set = 0;
break;
}
}
switch (pEmr->elp.elpPenStyle & U_PS_ENDCAP_MASK) {
case U_PS_ENDCAP_ROUND:
{
d->dc[d->level].style.stroke_linecap.computed = 1;
break;
}
case U_PS_ENDCAP_SQUARE:
{
d->dc[d->level].style.stroke_linecap.computed = 2;
break;
}
case U_PS_ENDCAP_FLAT:
default:
{
d->dc[d->level].style.stroke_linecap.computed = 0;
break;
}
}
switch (pEmr->elp.elpPenStyle & U_PS_JOIN_MASK) {
case U_PS_JOIN_BEVEL:
{
d->dc[d->level].style.stroke_linejoin.computed = 2;
break;
}
case U_PS_JOIN_MITER:
{
d->dc[d->level].style.stroke_linejoin.computed = 0;
break;
}
case U_PS_JOIN_ROUND:
default:
{
d->dc[d->level].style.stroke_linejoin.computed = 1;
break;
}
}
d->dc[d->level].stroke_set = true;
if (pEmr->elp.elpPenStyle == U_PS_NULL) {
d->dc[d->level].style.stroke_width.value = 0;
d->dc[d->level].stroke_set = false;
} else if (pEmr->elp.elpWidth) {
int cur_level = d->level;
d->level = d->emf_obj[index].level;
double pen_width = pix_to_size_point( d, pEmr->elp.elpWidth );
d->level = cur_level;
d->dc[d->level].style.stroke_width.value = pen_width;
} else { // this stroke should always be rendered as 1 pixel wide, independent of zoom level (can that be done in SVG?)
//d->dc[d->level].style.stroke_width.value = 1.0;
int cur_level = d->level;
d->level = d->emf_obj[index].level;
double pen_width = pix_to_size_point( d, 1 );
d->level = cur_level;
d->dc[d->level].style.stroke_width.value = pen_width;
}
if( pEmr->elp.elpBrushStyle == U_BS_SOLID){
double r, g, b;
r = SP_COLOR_U_TO_F( U_RGBAGetR(pEmr->elp.elpColor) );
g = SP_COLOR_U_TO_F( U_RGBAGetG(pEmr->elp.elpColor) );
b = SP_COLOR_U_TO_F( U_RGBAGetB(pEmr->elp.elpColor) );
d->dc[d->level].style.stroke.value.color.set( r, g, b );
d->dc[d->level].stroke_mode = DRAW_PAINT;
d->dc[d->level].stroke_set = true;
}
else if(pEmr->elp.elpBrushStyle == U_BS_HATCHED){
d->dc[d->level].stroke_idx = add_hatch(d, pEmr->elp.elpHatch, pEmr->elp.elpColor);
d->dc[d->level].stroke_mode = DRAW_PATTERN;
d->dc[d->level].stroke_set = true;
}
else if(pEmr->elp.elpBrushStyle == U_BS_DIBPATTERN || pEmr->elp.elpBrushStyle == U_BS_DIBPATTERNPT){
d->dc[d->level].stroke_idx = add_image(d, pEmr, pEmr->cbBits, pEmr->cbBmi, *(uint32_t *) &(pEmr->elp.elpColor), pEmr->offBits, pEmr->offBmi);
d->dc[d->level].stroke_mode = DRAW_IMAGE;
d->dc[d->level].stroke_set = true;
}
else { // U_BS_PATTERN and anything strange that falls in, stroke is solid textColor
double r, g, b;
r = SP_COLOR_U_TO_F( U_RGBAGetR(d->dc[d->level].textColor));
g = SP_COLOR_U_TO_F( U_RGBAGetG(d->dc[d->level].textColor));
b = SP_COLOR_U_TO_F( U_RGBAGetB(d->dc[d->level].textColor));
d->dc[d->level].style.stroke.value.color.set( r, g, b );
d->dc[d->level].stroke_mode = DRAW_PAINT;
d->dc[d->level].stroke_set = true;
}
}
static void
select_brush(PEMF_CALLBACK_DATA d, int index)
{
uint32_t tidx;
uint32_t iType;
if (index >= 0 && index < d->n_obj){
iType = ((PU_EMR) (d->emf_obj[index].lpEMFR))->iType;
if(iType == U_EMR_CREATEBRUSHINDIRECT){
PU_EMRCREATEBRUSHINDIRECT pEmr = (PU_EMRCREATEBRUSHINDIRECT) d->emf_obj[index].lpEMFR;
if( pEmr->lb.lbStyle == U_BS_SOLID){
double r, g, b;
r = SP_COLOR_U_TO_F( U_RGBAGetR(pEmr->lb.lbColor) );
g = SP_COLOR_U_TO_F( U_RGBAGetG(pEmr->lb.lbColor) );
b = SP_COLOR_U_TO_F( U_RGBAGetB(pEmr->lb.lbColor) );
d->dc[d->level].style.fill.value.color.set( r, g, b );
d->dc[d->level].fill_mode = DRAW_PAINT;
d->dc[d->level].fill_set = true;
}
else if(pEmr->lb.lbStyle == U_BS_HATCHED){
d->dc[d->level].fill_idx = add_hatch(d, pEmr->lb.lbHatch, pEmr->lb.lbColor);
d->dc[d->level].fill_mode = DRAW_PATTERN;
d->dc[d->level].fill_set = true;
}
}
else if(iType == U_EMR_CREATEDIBPATTERNBRUSHPT || iType == U_EMR_CREATEMONOBRUSH){
PU_EMRCREATEDIBPATTERNBRUSHPT pEmr = (PU_EMRCREATEDIBPATTERNBRUSHPT) d->emf_obj[index].lpEMFR;
tidx = add_image(d, (void *) pEmr, pEmr->cbBits, pEmr->cbBmi, pEmr->iUsage, pEmr->offBits, pEmr->offBmi);
if(tidx == 0xFFFFFFFF){ // This happens if createmonobrush has a DIB that isn't monochrome
double r, g, b;
r = SP_COLOR_U_TO_F( U_RGBAGetR(d->dc[d->level].textColor));
g = SP_COLOR_U_TO_F( U_RGBAGetG(d->dc[d->level].textColor));
b = SP_COLOR_U_TO_F( U_RGBAGetB(d->dc[d->level].textColor));
d->dc[d->level].style.fill.value.color.set( r, g, b );
d->dc[d->level].fill_mode = DRAW_PAINT;
}
else {
d->dc[d->level].fill_idx = tidx;
d->dc[d->level].fill_mode = DRAW_IMAGE;
}
d->dc[d->level].fill_set = true;
}
}
}
static void
select_font(PEMF_CALLBACK_DATA d, int index)
{
PU_EMREXTCREATEFONTINDIRECTW pEmr = NULL;
if (index >= 0 && index < d->n_obj)
pEmr = (PU_EMREXTCREATEFONTINDIRECTW) d->emf_obj[index].lpEMFR;
if (!pEmr)return;
/* The logfont information always starts with a U_LOGFONT structure but the U_EMREXTCREATEFONTINDIRECTW
is defined as U_LOGFONT_PANOSE so it can handle one of those if that is actually present. Currently only logfont
is supported, and the remainder, it it really is a U_LOGFONT_PANOSE record, is ignored
*/
int cur_level = d->level;
d->level = d->emf_obj[index].level;
double font_size = pix_to_size_point( d, pEmr->elfw.elfLogFont.lfHeight );
/* snap the font_size to the nearest .01.
See the notes where device_scale is set for the reason why.
Typically this will set the font to the desired exact size. If some peculiar size
was intended this will, at worst, make it 1% off, which is unlikely to be a problem. */
font_size = round(100.0 * font_size)/100.0;
d->level = cur_level;
d->dc[d->level].style.font_size.computed = font_size;
d->dc[d->level].style.font_weight.value =
pEmr->elfw.elfLogFont.lfWeight == U_FW_THIN ? SP_CSS_FONT_WEIGHT_100 :
pEmr->elfw.elfLogFont.lfWeight == U_FW_EXTRALIGHT ? SP_CSS_FONT_WEIGHT_200 :
pEmr->elfw.elfLogFont.lfWeight == U_FW_LIGHT ? SP_CSS_FONT_WEIGHT_300 :
pEmr->elfw.elfLogFont.lfWeight == U_FW_NORMAL ? SP_CSS_FONT_WEIGHT_400 :
pEmr->elfw.elfLogFont.lfWeight == U_FW_MEDIUM ? SP_CSS_FONT_WEIGHT_500 :
pEmr->elfw.elfLogFont.lfWeight == U_FW_SEMIBOLD ? SP_CSS_FONT_WEIGHT_600 :
pEmr->elfw.elfLogFont.lfWeight == U_FW_BOLD ? SP_CSS_FONT_WEIGHT_700 :
pEmr->elfw.elfLogFont.lfWeight == U_FW_EXTRABOLD ? SP_CSS_FONT_WEIGHT_800 :
pEmr->elfw.elfLogFont.lfWeight == U_FW_HEAVY ? SP_CSS_FONT_WEIGHT_900 :
pEmr->elfw.elfLogFont.lfWeight == U_FW_NORMAL ? SP_CSS_FONT_WEIGHT_NORMAL :
pEmr->elfw.elfLogFont.lfWeight == U_FW_BOLD ? SP_CSS_FONT_WEIGHT_BOLD :
pEmr->elfw.elfLogFont.lfWeight == U_FW_EXTRALIGHT ? SP_CSS_FONT_WEIGHT_LIGHTER :
pEmr->elfw.elfLogFont.lfWeight == U_FW_EXTRABOLD ? SP_CSS_FONT_WEIGHT_BOLDER :
U_FW_NORMAL;
d->dc[d->level].style.font_style.value = (pEmr->elfw.elfLogFont.lfItalic ? SP_CSS_FONT_STYLE_ITALIC : SP_CSS_FONT_STYLE_NORMAL);
d->dc[d->level].style.text_decoration.underline = pEmr->elfw.elfLogFont.lfUnderline;
d->dc[d->level].style.text_decoration.line_through = pEmr->elfw.elfLogFont.lfStrikeOut;
if (d->dc[d->level].tstyle.font_family.value){ free(d->dc[d->level].tstyle.font_family.value); }
d->dc[d->level].tstyle.font_family.value =
U_Utf16leToUtf8((uint16_t *) (pEmr->elfw.elfLogFont.lfFaceName), U_LF_FACESIZE, NULL);
d->dc[d->level].style.baseline_shift.value = ((pEmr->elfw.elfLogFont.lfEscapement + 3600) % 3600) / 10; // use baseline_shift instead of text_transform to avoid overflow
}
static void
delete_object(PEMF_CALLBACK_DATA d, int index)
{
if (index >= 0 && index < d->n_obj) {
d->emf_obj[index].type = 0;
// We are keeping a copy of the EMR rather than just a structure. Currently that is not necessary as the entire
// EMF is read in at once and is stored in a big malloc. However, in past versions it was handled
// reord by record, and we might need to do that again at some point in the future if we start running into EMF
// files too big to fit into memory.
if (d->emf_obj[index].lpEMFR)
free(d->emf_obj[index].lpEMFR);
d->emf_obj[index].lpEMFR = NULL;
}
}
static void
insert_object(PEMF_CALLBACK_DATA d, int index, int type, PU_ENHMETARECORD pObj)
{
if (index >= 0 && index < d->n_obj) {
delete_object(d, index);
d->emf_obj[index].type = type;
d->emf_obj[index].level = d->level;
d->emf_obj[index].lpEMFR = emr_dup((char *) pObj);
}
}
/**
\fn create a UTF-32LE buffer and fill it with UNICODE unknown character
\param count number of copies of the Unicode unknown character to fill with
*/
uint32_t *unknown_chars(size_t count){
uint32_t *res = (uint32_t *) malloc(sizeof(uint32_t) * (count + 1));
if(!res)throw "Inkscape fatal memory allocation error - cannot continue";
for(uint32_t i=0; i<count; i++){ res[i] = 0xFFFD; }
res[count]=0;
return res;
}
/**
\fn myEnhMetaFileProc(char *contents, unsigned int length, PEMF_CALLBACK_DATA lpData)
\param contents binary contents of an EMF file
\param length length in bytes of contents
\param d Inkscape data structures returned by this call
*/
//THis was a callback, just build it into a normal function
int myEnhMetaFileProc(char *contents, unsigned int length, PEMF_CALLBACK_DATA d)
{
uint32_t off=0;
uint32_t emr_mask;
int OK =1;
PU_ENHMETARECORD lpEMFR;
while(OK){
if(off>=length)return(0); //normally should exit from while after EMREOF sets OK to false.
lpEMFR = (PU_ENHMETARECORD)(contents + off);
// std::cout << "record type: " << lpEMFR->iType << " length: " << lpEMFR->nSize << "offset: " << off <<std::endl;
off += lpEMFR->nSize;
SVGOStringStream tmp_outsvg;
SVGOStringStream tmp_path;
SVGOStringStream tmp_str;
SVGOStringStream dbg_str;
emr_mask = emr_properties(lpEMFR->iType);
// std::cout << "BEFORE DRAW logic d->mask: " << std::hex << d->mask << " emr_mask: " << emr_mask << std::dec << std::endl;
/*
std::cout << "BEFORE DRAW"
<< " test0 " << ( d->mask & U_DRAW_VISIBLE)
<< " test1 " << ( d->mask & U_DRAW_FORCE)
<< " test2 " << (emr_mask & U_DRAW_ALTERS)
<< " test3 " << (emr_mask & U_DRAW_VISIBLE)
<< " test4 " << !(d->mask & U_DRAW_ONLYTO)
<< " test5 " << ((d->mask & U_DRAW_ONLYTO) && !(emr_mask & U_DRAW_ONLYTO) )
<< std::endl;
*/
if ( (emr_mask != 0xFFFFFFFF) && // next record is valid type
(d->mask & U_DRAW_VISIBLE) && // This record is drawable
( (d->mask & U_DRAW_FORCE) || // This draw is forced by STROKE/FILL/STROKEANDFILL PATH
(emr_mask & U_DRAW_ALTERS) || // Next record would alter the drawing environment in some way
( (emr_mask & U_DRAW_VISIBLE) // Next record is visible...
&&
(
( !(d->mask & U_DRAW_ONLYTO) ) // Non *TO records cannot be followed by any Visible
||
((d->mask & U_DRAW_ONLYTO) && !(emr_mask & U_DRAW_ONLYTO) ) // *TO records can only be followed by other *TO records
)
)
)
){
// std::cout << "PATH DRAW at TOP" << std::endl;
*(d->outsvg) += " <path "; // this is the ONLY place <path should be used!!!!
if(d->drawtype){ // explicit draw type EMR record
output_style(d, d->drawtype);
}
else if(d->mask & U_DRAW_CLOSED){ // implicit draw type
output_style(d, U_EMR_STROKEANDFILLPATH);
}
else {
output_style(d, U_EMR_STROKEPATH);
}
*(d->outsvg) += "\n\t";
*(d->outsvg) += "\n\td=\""; // this is the ONLY place d=" should be used!!!!
*(d->outsvg) += *(d->path);
*(d->outsvg) += " \" /> \n";
*(d->path) = "";
// reset the flags
d->mask = 0;
d->drawtype = 0;
}
// std::cout << "AFTER DRAW logic d->mask: " << std::hex << d->mask << " emr_mask: " << emr_mask << std::dec << std::endl;
switch (lpEMFR->iType)
{
case U_EMR_HEADER:
{
dbg_str << "<!-- U_EMR_HEADER -->\n";
*(d->outdef) += "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n";
if (d->pDesc) {
*(d->outdef) += "<!-- ";
*(d->outdef) += d->pDesc;
*(d->outdef) += " -->\n";
}
PU_EMRHEADER pEmr = (PU_EMRHEADER) lpEMFR;
SVGOStringStream tmp_outdef;
tmp_outdef << "<svg\n";
tmp_outdef << " xmlns:svg=\"http://www.w3.org/2000/svg\"\n";
tmp_outdef << " xmlns=\"http://www.w3.org/2000/svg\"\n";
tmp_outdef << " xmlns:xlink=\"http://www.w3.org/1999/xlink\"\n"; //mathog
tmp_outdef << " version=\"1.0\"\n";
d->xDPI = 2540;
d->yDPI = 2540;
d->dc[d->level].PixelsInX = pEmr->rclFrame.right; // - pEmr->rclFrame.left;
d->dc[d->level].PixelsInY = pEmr->rclFrame.bottom; // - pEmr->rclFrame.top;
d->MMX = d->dc[d->level].PixelsInX / 100.0;
d->MMY = d->dc[d->level].PixelsInY / 100.0;
d->dc[d->level].PixelsOutX = d->MMX * PX_PER_MM;
d->dc[d->level].PixelsOutY = d->MMY * PX_PER_MM;
/*
calculate ratio of Inkscape dpi/device dpi
This can cause problems later due to accuracy limits in the EMF. A super high resolution
EMF might have a final device_scale of 0.074998, and adjusting the (integer) device size
by 1 will still not get it exactly to 0.075. Later when the font size is calculated it
can end up as 29.9992 or 22.4994 instead of the intended 30 or 22.5. This is handled by
snapping font sizes to the nearest .01.
*/
if (pEmr->szlMillimeters.cx && pEmr->szlDevice.cx)
device_scale = PX_PER_MM*pEmr->szlMillimeters.cx/pEmr->szlDevice.cx;
tmp_outdef <<
" width=\"" << d->MMX << "mm\"\n" <<
" height=\"" << d->MMY << "mm\">\n";
*(d->outdef) += tmp_outdef.str().c_str();
*(d->outdef) += "<defs>"; // temporary end of header
// d->defs holds any defines which are read in.
tmp_outsvg << "\n</defs>\n<g>\n"; // start of main body
if (pEmr->nHandles) {
d->n_obj = pEmr->nHandles;
d->emf_obj = new EMF_OBJECT[d->n_obj];
// Init the new emf_obj list elements to null, provided the
// dynamic allocation succeeded.
if ( d->emf_obj != NULL )
{
for( int i=0; i < d->n_obj; ++i )
d->emf_obj[i].lpEMFR = NULL;
} //if
} else {
d->emf_obj = NULL;
}
break;
}
case U_EMR_POLYBEZIER:
{
dbg_str << "<!-- U_EMR_POLYBEZIER -->\n";
PU_EMRPOLYBEZIER pEmr = (PU_EMRPOLYBEZIER) lpEMFR;
uint32_t i,j;
if (pEmr->cptl<4)
break;
d->mask |= emr_mask;
tmp_str <<
"\n\tM " <<
pix_to_x_point( d, pEmr->aptl[0].x, pEmr->aptl[0].y ) << " " <<
pix_to_y_point( d, pEmr->aptl[0].x, pEmr->aptl[0].y) << " ";
for (i=1; i<pEmr->cptl; ) {
tmp_str << "\n\tC ";
for (j=0; j<3 && i<pEmr->cptl; j++,i++) {
tmp_str <<
pix_to_x_point( d, pEmr->aptl[i].x, pEmr->aptl[i].y ) << " " <<
pix_to_y_point( d, pEmr->aptl[i].x, pEmr->aptl[i].y ) << " ";
}
}
tmp_path << tmp_str.str().c_str();
break;
}
case U_EMR_POLYGON:
{
dbg_str << "<!-- U_EMR_POLYGON -->\n";
PU_EMRPOLYGON pEmr = (PU_EMRPOLYGON) lpEMFR;
uint32_t i;
if (pEmr->cptl < 2)
break;
d->mask |= emr_mask;
tmp_str <<
"\n\tM " <<
pix_to_x_point( d, pEmr->aptl[0].x, pEmr->aptl[0].y ) << " " <<
pix_to_y_point( d, pEmr->aptl[0].x, pEmr->aptl[0].y ) << " ";
for (i=1; i<pEmr->cptl; i++) {
tmp_str <<
"\n\tL " <<
pix_to_x_point( d, pEmr->aptl[i].x, pEmr->aptl[i].y ) << " " <<
pix_to_y_point( d, pEmr->aptl[i].x, pEmr->aptl[i].y ) << " ";
}
tmp_path << tmp_str.str().c_str();
tmp_path << " z";
break;
}
case U_EMR_POLYLINE:
{
dbg_str << "<!-- U_EMR_POLYLINE -->\n";
PU_EMRPOLYLINE pEmr = (PU_EMRPOLYLINE) lpEMFR;
uint32_t i;
if (pEmr->cptl<2)
break;
d->mask |= emr_mask;
tmp_str <<
"\n\tM " <<
pix_to_x_point( d, pEmr->aptl[0].x, pEmr->aptl[0].y ) << " " <<
pix_to_y_point( d, pEmr->aptl[0].x, pEmr->aptl[0].y ) << " ";
for (i=1; i<pEmr->cptl; i++) {
tmp_str <<
"\n\tL " <<
pix_to_x_point( d, pEmr->aptl[i].x, pEmr->aptl[i].y ) << " " <<
pix_to_y_point( d, pEmr->aptl[i].x, pEmr->aptl[i].y ) << " ";
}
tmp_path << tmp_str.str().c_str();
break;
}
case U_EMR_POLYBEZIERTO:
{
dbg_str << "<!-- U_EMR_POLYBEZIERTO -->\n";
PU_EMRPOLYBEZIERTO pEmr = (PU_EMRPOLYBEZIERTO) lpEMFR;
uint32_t i,j;
d->mask |= emr_mask;
for (i=0; i<pEmr->cptl;) {
tmp_path << "\n\tC ";
for (j=0; j<3 && i<pEmr->cptl; j++,i++) {
tmp_path <<
pix_to_x_point( d, pEmr->aptl[i].x, pEmr->aptl[i].y ) << " " <<
pix_to_y_point( d, pEmr->aptl[i].x, pEmr->aptl[i].y ) << " ";
}
}
break;
}
case U_EMR_POLYLINETO:
{
dbg_str << "<!-- U_EMR_POLYLINETO -->\n";
PU_EMRPOLYLINETO pEmr = (PU_EMRPOLYLINETO) lpEMFR;
uint32_t i;
d->mask |= emr_mask;
for (i=0; i<pEmr->cptl;i++) {
tmp_path <<
"\n\tL " <<
pix_to_x_point( d, pEmr->aptl[i].x, pEmr->aptl[i].y ) << " " <<
pix_to_y_point( d, pEmr->aptl[i].x, pEmr->aptl[i].y ) << " ";
}
break;
}
case U_EMR_POLYPOLYLINE:
case U_EMR_POLYPOLYGON:
{
if (lpEMFR->iType == U_EMR_POLYPOLYLINE)
dbg_str << "<!-- U_EMR_POLYPOLYLINE -->\n";
if (lpEMFR->iType == U_EMR_POLYPOLYGON)
dbg_str << "<!-- U_EMR_POLYPOLYGON -->\n";
PU_EMRPOLYPOLYGON pEmr = (PU_EMRPOLYPOLYGON) lpEMFR;
unsigned int n, i, j;
d->mask |= emr_mask;
U_POINTL *aptl = (PU_POINTL) &pEmr->aPolyCounts[pEmr->nPolys];
i = 0;
for (n=0; n<pEmr->nPolys && i<pEmr->cptl; n++) {
SVGOStringStream poly_path;
poly_path << "\n\tM " <<
pix_to_x_point( d, aptl[i].x, aptl[i].y ) << " " <<
pix_to_y_point( d, aptl[i].x, aptl[i].y ) << " ";
i++;
for (j=1; j<pEmr->aPolyCounts[n] && i<pEmr->cptl; j++) {
poly_path << "\n\tL " <<
pix_to_x_point( d, aptl[i].x, aptl[i].y ) << " " <<
pix_to_y_point( d, aptl[i].x, aptl[i].y ) << " ";
i++;
}
tmp_str << poly_path.str().c_str();
if (lpEMFR->iType == U_EMR_POLYPOLYGON)
tmp_str << " z";
tmp_str << " \n";
}
tmp_path << tmp_str.str().c_str();
break;
}
case U_EMR_SETWINDOWEXTEX:
{
dbg_str << "<!-- U_EMR_SETWINDOWEXTEX -->\n";
PU_EMRSETWINDOWEXTEX pEmr = (PU_EMRSETWINDOWEXTEX) lpEMFR;
d->dc[d->level].sizeWnd = pEmr->szlExtent;
if (!d->dc[d->level].sizeWnd.cx || !d->dc[d->level].sizeWnd.cy) {
d->dc[d->level].sizeWnd = d->dc[d->level].sizeView;
if (!d->dc[d->level].sizeWnd.cx || !d->dc[d->level].sizeWnd.cy) {
d->dc[d->level].sizeWnd.cx = d->dc[d->level].PixelsOutX;
d->dc[d->level].sizeWnd.cy = d->dc[d->level].PixelsOutY;
}
}
if (!d->dc[d->level].sizeView.cx || !d->dc[d->level].sizeView.cy) {
d->dc[d->level].sizeView = d->dc[d->level].sizeWnd;
}
d->dc[d->level].PixelsInX = d->dc[d->level].sizeWnd.cx;
d->dc[d->level].PixelsInY = d->dc[d->level].sizeWnd.cy;
if (d->dc[d->level].PixelsInX && d->dc[d->level].PixelsInY) {
d->dc[d->level].ScaleInX = (double) d->dc[d->level].sizeView.cx / (double) d->dc[d->level].PixelsInX;
d->dc[d->level].ScaleInY = (double) d->dc[d->level].sizeView.cy / (double) d->dc[d->level].PixelsInY;
}
else {
d->dc[d->level].ScaleInX = 1;
d->dc[d->level].ScaleInY = 1;
}
break;
}
case U_EMR_SETWINDOWORGEX:
{
dbg_str << "<!-- U_EMR_SETWINDOWORGEX -->\n";
PU_EMRSETWINDOWORGEX pEmr = (PU_EMRSETWINDOWORGEX) lpEMFR;
d->dc[d->level].winorg = pEmr->ptlOrigin;
break;
}
case U_EMR_SETVIEWPORTEXTEX:
{
dbg_str << "<!-- U_EMR_SETVIEWPORTEXTEX -->\n";
PU_EMRSETVIEWPORTEXTEX pEmr = (PU_EMRSETVIEWPORTEXTEX) lpEMFR;
d->dc[d->level].sizeView = pEmr->szlExtent;
if (!d->dc[d->level].sizeView.cx || !d->dc[d->level].sizeView.cy) {
d->dc[d->level].sizeView = d->dc[d->level].sizeWnd;
if (!d->dc[d->level].sizeView.cx || !d->dc[d->level].sizeView.cy) {
d->dc[d->level].sizeView.cx = d->dc[d->level].PixelsOutX;
d->dc[d->level].sizeView.cy = d->dc[d->level].PixelsOutY;
}
}
if (!d->dc[d->level].sizeWnd.cx || !d->dc[d->level].sizeWnd.cy) {
d->dc[d->level].sizeWnd = d->dc[d->level].sizeView;
}
d->dc[d->level].PixelsInX = d->dc[d->level].sizeWnd.cx;
d->dc[d->level].PixelsInY = d->dc[d->level].sizeWnd.cy;
if (d->dc[d->level].PixelsInX && d->dc[d->level].PixelsInY) {
d->dc[d->level].ScaleInX = (double) d->dc[d->level].sizeView.cx / (double) d->dc[d->level].PixelsInX;
d->dc[d->level].ScaleInY = (double) d->dc[d->level].sizeView.cy / (double) d->dc[d->level].PixelsInY;
}
else {
d->dc[d->level].ScaleInX = 1;
d->dc[d->level].ScaleInY = 1;
}
break;
}
case U_EMR_SETVIEWPORTORGEX:
{
dbg_str << "<!-- U_EMR_SETVIEWPORTORGEX -->\n";
PU_EMRSETVIEWPORTORGEX pEmr = (PU_EMRSETVIEWPORTORGEX) lpEMFR;
d->dc[d->level].vieworg = pEmr->ptlOrigin;
break;
}
case U_EMR_SETBRUSHORGEX: dbg_str << "<!-- U_EMR_SETBRUSHORGEX -->\n"; break;
case U_EMR_EOF:
{
dbg_str << "<!-- U_EMR_EOF -->\n";
tmp_outsvg << "</g>\n";
tmp_outsvg << "</svg>\n";
*(d->outsvg) = *(d->outdef) + *(d->defs) + *(d->outsvg);
OK=0;
break;
}
case U_EMR_SETPIXELV: dbg_str << "<!-- U_EMR_SETPIXELV -->\n"; break;
case U_EMR_SETMAPPERFLAGS: dbg_str << "<!-- U_EMR_SETMAPPERFLAGS -->\n"; break;
case U_EMR_SETMAPMODE: dbg_str << "<!-- U_EMR_SETMAPMODE -->\n"; break;
case U_EMR_SETBKMODE: dbg_str << "<!-- U_EMR_SETBKMODE -->\n"; break;
case U_EMR_SETPOLYFILLMODE:
{
dbg_str << "<!-- U_EMR_SETPOLYFILLMODE -->\n";
PU_EMRSETPOLYFILLMODE pEmr = (PU_EMRSETPOLYFILLMODE) lpEMFR;
d->dc[d->level].style.fill_rule.value =
(pEmr->iMode == U_ALTERNATE ? 0 :
pEmr->iMode == U_WINDING ? 1 : 0);
break;
}
case U_EMR_SETROP2:
{
dbg_str << "<!-- U_EMR_SETROP2 -->\n";
PU_EMRSETROP2 pEmr = (PU_EMRSETROP2) lpEMFR;
d->dwRop2 = pEmr->iMode;
break;
}
case U_EMR_SETSTRETCHBLTMODE:
{
PU_EMRSETSTRETCHBLTMODE pEmr = (PU_EMRSETSTRETCHBLTMODE) lpEMFR; // from wingdi.h
BLTmode = pEmr->iMode;
dbg_str << "<!-- U_EMR_SETSTRETCHBLTMODE -->\n";
break;
}
case U_EMR_SETTEXTALIGN:
{
dbg_str << "<!-- U_EMR_SETTEXTALIGN -->\n";
PU_EMRSETTEXTALIGN pEmr = (PU_EMRSETTEXTALIGN) lpEMFR;
d->dc[d->level].textAlign = pEmr->iMode;
break;
}
case U_EMR_SETCOLORADJUSTMENT:
dbg_str << "<!-- U_EMR_SETCOLORADJUSTMENT -->\n";
break;
case U_EMR_SETTEXTCOLOR:
{
dbg_str << "<!-- U_EMR_SETTEXTCOLOR -->\n";
PU_EMRSETTEXTCOLOR pEmr = (PU_EMRSETTEXTCOLOR) lpEMFR;
d->dc[d->level].textColor = pEmr->crColor;
d->dc[d->level].textColorSet = true;
break;
}
case U_EMR_SETBKCOLOR:
{
dbg_str << "<!-- U_EMR_SETBKCOLOR -->\n";
PU_EMRSETBKCOLOR pEmr = (PU_EMRSETBKCOLOR) lpEMFR;
d->dc[d->level].bkColor = pEmr->crColor;
d->dc[d->level].bkColorSet = true;
break;
}
case U_EMR_OFFSETCLIPRGN: dbg_str << "<!-- U_EMR_OFFSETCLIPRGN -->\n"; break;
case U_EMR_MOVETOEX:
{
dbg_str << "<!-- U_EMR_MOVETOEX -->\n";
PU_EMRMOVETOEX pEmr = (PU_EMRMOVETOEX) lpEMFR;
d->mask |= emr_mask;
d->dc[d->level].cur = pEmr->ptl;
tmp_path <<
"\n\tM " <<
pix_to_x_point( d, pEmr->ptl.x, pEmr->ptl.y ) << " " <<
pix_to_y_point( d, pEmr->ptl.x, pEmr->ptl.y ) << " ";
break;
}
case U_EMR_SETMETARGN: dbg_str << "<!-- U_EMR_SETMETARGN -->\n"; break;
case U_EMR_EXCLUDECLIPRECT: dbg_str << "<!-- U_EMR_EXCLUDECLIPRECT -->\n"; break;
case U_EMR_INTERSECTCLIPRECT:
{
dbg_str << "<!-- U_EMR_INTERSECTCLIPRECT -->\n";
PU_EMRINTERSECTCLIPRECT pEmr = (PU_EMRINTERSECTCLIPRECT) lpEMFR;
U_RECTL rc = pEmr->rclClip;
clipset = true;
if ((rc.left == rc_old.left) && (rc.top == rc_old.top) && (rc.right == rc_old.right) && (rc.bottom == rc_old.bottom))
break;
rc_old = rc;
double l = pix_to_x_point( d, rc.left, rc.top );
double t = pix_to_y_point( d, rc.left, rc.top );
double r = pix_to_x_point( d, rc.right, rc.bottom );
double b = pix_to_y_point( d, rc.right, rc.bottom );
SVGOStringStream tmp_rectangle;
tmp_rectangle << "\n<clipPath\n\tclipPathUnits=\"userSpaceOnUse\" ";
tmp_rectangle << "\n\tid=\"clipEmfPath" << ++(d->id) << "\" >";
tmp_rectangle << "\n<rect ";
tmp_rectangle << "\n\tx=\"" << l << "\" ";
tmp_rectangle << "\n\ty=\"" << t << "\" ";
tmp_rectangle << "\n\twidth=\"" << r-l << "\" ";
tmp_rectangle << "\n\theight=\"" << b-t << "\" />";
tmp_rectangle << "\n</clipPath>";
*(d->outdef) += tmp_rectangle.str().c_str();
*(d->path) = "";
break;
}
case U_EMR_SCALEVIEWPORTEXTEX: dbg_str << "<!-- U_EMR_SCALEVIEWPORTEXTEX -->\n"; break;
case U_EMR_SCALEWINDOWEXTEX: dbg_str << "<!-- U_EMR_SCALEWINDOWEXTEX -->\n"; break;
case U_EMR_SAVEDC:
dbg_str << "<!-- U_EMR_SAVEDC -->\n";
if (d->level < EMF_MAX_DC) {
d->dc[d->level + 1] = d->dc[d->level];
d->level = d->level + 1;
}
break;
case U_EMR_RESTOREDC:
{
dbg_str << "<!-- U_EMR_RESTOREDC -->\n";
PU_EMRRESTOREDC pEmr = (PU_EMRRESTOREDC) lpEMFR;
int old_level = d->level;
if (pEmr->iRelative >= 0) {
if (pEmr->iRelative < d->level)
d->level = pEmr->iRelative;
}
else {
if (d->level + pEmr->iRelative >= 0)
d->level = d->level + pEmr->iRelative;
}
while (old_level > d->level) {
if (d->dc[old_level].style.stroke_dash.dash && (old_level==0 || (old_level>0 && d->dc[old_level].style.stroke_dash.dash!=d->dc[old_level-1].style.stroke_dash.dash)))
delete[] d->dc[old_level].style.stroke_dash.dash;
old_level--;
}
break;
}
case U_EMR_SETWORLDTRANSFORM:
{
dbg_str << "<!-- U_EMR_SETWORLDTRANSFORM -->\n";
PU_EMRSETWORLDTRANSFORM pEmr = (PU_EMRSETWORLDTRANSFORM) lpEMFR;
d->dc[d->level].worldTransform = pEmr->xform;
break;
}
case U_EMR_MODIFYWORLDTRANSFORM:
{
dbg_str << "<!-- U_EMR_MODIFYWORLDTRANSFORM -->\n";
PU_EMRMODIFYWORLDTRANSFORM pEmr = (PU_EMRMODIFYWORLDTRANSFORM) lpEMFR;
switch (pEmr->iMode)
{
case U_MWT_IDENTITY:
d->dc[d->level].worldTransform.eM11 = 1.0;
d->dc[d->level].worldTransform.eM12 = 0.0;
d->dc[d->level].worldTransform.eM21 = 0.0;
d->dc[d->level].worldTransform.eM22 = 1.0;
d->dc[d->level].worldTransform.eDx = 0.0;
d->dc[d->level].worldTransform.eDy = 0.0;
break;
case U_MWT_LEFTMULTIPLY:
{
// d->dc[d->level].worldTransform = pEmr->xform * worldTransform;
float a11 = pEmr->xform.eM11;
float a12 = pEmr->xform.eM12;
float a13 = 0.0;
float a21 = pEmr->xform.eM21;
float a22 = pEmr->xform.eM22;
float a23 = 0.0;
float a31 = pEmr->xform.eDx;
float a32 = pEmr->xform.eDy;
float a33 = 1.0;
float b11 = d->dc[d->level].worldTransform.eM11;
float b12 = d->dc[d->level].worldTransform.eM12;
//float b13 = 0.0;
float b21 = d->dc[d->level].worldTransform.eM21;
float b22 = d->dc[d->level].worldTransform.eM22;
//float b23 = 0.0;
float b31 = d->dc[d->level].worldTransform.eDx;
float b32 = d->dc[d->level].worldTransform.eDy;
//float b33 = 1.0;
float c11 = a11*b11 + a12*b21 + a13*b31;;
float c12 = a11*b12 + a12*b22 + a13*b32;;
//float c13 = a11*b13 + a12*b23 + a13*b33;;
float c21 = a21*b11 + a22*b21 + a23*b31;;
float c22 = a21*b12 + a22*b22 + a23*b32;;
//float c23 = a21*b13 + a22*b23 + a23*b33;;
float c31 = a31*b11 + a32*b21 + a33*b31;;
float c32 = a31*b12 + a32*b22 + a33*b32;;
//float c33 = a31*b13 + a32*b23 + a33*b33;;
d->dc[d->level].worldTransform.eM11 = c11;;
d->dc[d->level].worldTransform.eM12 = c12;;
d->dc[d->level].worldTransform.eM21 = c21;;
d->dc[d->level].worldTransform.eM22 = c22;;
d->dc[d->level].worldTransform.eDx = c31;
d->dc[d->level].worldTransform.eDy = c32;
break;
}
case U_MWT_RIGHTMULTIPLY:
{
// d->dc[d->level].worldTransform = worldTransform * pEmr->xform;
float a11 = d->dc[d->level].worldTransform.eM11;
float a12 = d->dc[d->level].worldTransform.eM12;
float a13 = 0.0;
float a21 = d->dc[d->level].worldTransform.eM21;
float a22 = d->dc[d->level].worldTransform.eM22;
float a23 = 0.0;
float a31 = d->dc[d->level].worldTransform.eDx;
float a32 = d->dc[d->level].worldTransform.eDy;
float a33 = 1.0;
float b11 = pEmr->xform.eM11;
float b12 = pEmr->xform.eM12;
//float b13 = 0.0;
float b21 = pEmr->xform.eM21;
float b22 = pEmr->xform.eM22;
//float b23 = 0.0;
float b31 = pEmr->xform.eDx;
float b32 = pEmr->xform.eDy;
//float b33 = 1.0;
float c11 = a11*b11 + a12*b21 + a13*b31;;
float c12 = a11*b12 + a12*b22 + a13*b32;;
//float c13 = a11*b13 + a12*b23 + a13*b33;;
float c21 = a21*b11 + a22*b21 + a23*b31;;
float c22 = a21*b12 + a22*b22 + a23*b32;;
//float c23 = a21*b13 + a22*b23 + a23*b33;;
float c31 = a31*b11 + a32*b21 + a33*b31;;
float c32 = a31*b12 + a32*b22 + a33*b32;;
//float c33 = a31*b13 + a32*b23 + a33*b33;;
d->dc[d->level].worldTransform.eM11 = c11;;
d->dc[d->level].worldTransform.eM12 = c12;;
d->dc[d->level].worldTransform.eM21 = c21;;
d->dc[d->level].worldTransform.eM22 = c22;;
d->dc[d->level].worldTransform.eDx = c31;
d->dc[d->level].worldTransform.eDy = c32;
break;
}
// case MWT_SET:
default:
d->dc[d->level].worldTransform = pEmr->xform;
break;
}
break;
}
case U_EMR_SELECTOBJECT:
{
dbg_str << "<!-- U_EMR_SELECTOBJECT -->\n";
PU_EMRSELECTOBJECT pEmr = (PU_EMRSELECTOBJECT) lpEMFR;
unsigned int index = pEmr->ihObject;
if (index & U_STOCK_OBJECT) {
switch (index) {
case U_NULL_BRUSH:
d->dc[d->level].fill_mode = DRAW_PAINT;
d->dc[d->level].fill_set = false;
break;
case U_BLACK_BRUSH:
case U_DKGRAY_BRUSH:
case U_GRAY_BRUSH:
case U_LTGRAY_BRUSH:
case U_WHITE_BRUSH:
{
float val = 0;
switch (index) {
case U_BLACK_BRUSH:
val = 0.0 / 255.0;
break;
case U_DKGRAY_BRUSH:
val = 64.0 / 255.0;
break;
case U_GRAY_BRUSH:
val = 128.0 / 255.0;
break;
case U_LTGRAY_BRUSH:
val = 192.0 / 255.0;
break;
case U_WHITE_BRUSH:
val = 255.0 / 255.0;
break;
}
d->dc[d->level].style.fill.value.color.set( val, val, val );
d->dc[d->level].fill_mode = DRAW_PAINT;
d->dc[d->level].fill_set = true;
break;
}
case U_NULL_PEN:
d->dc[d->level].stroke_mode = DRAW_PAINT;
d->dc[d->level].stroke_set = false;
break;
case U_BLACK_PEN:
case U_WHITE_PEN:
{
float val = index == U_BLACK_PEN ? 0 : 1;
d->dc[d->level].style.stroke_dasharray_set = 0;
d->dc[d->level].style.stroke_width.value = 1.0;
d->dc[d->level].style.stroke.value.color.set( val, val, val );
d->dc[d->level].stroke_mode = DRAW_PAINT;
d->dc[d->level].stroke_set = true;
break;
}
}
} else {
if ( /*index >= 0 &&*/ index < (unsigned int) d->n_obj) {
switch (d->emf_obj[index].type)
{
case U_EMR_CREATEPEN:
select_pen(d, index);
break;
case U_EMR_CREATEBRUSHINDIRECT:
case U_EMR_CREATEDIBPATTERNBRUSHPT:
case U_EMR_CREATEMONOBRUSH:
select_brush(d, index);
break;
case U_EMR_EXTCREATEPEN:
select_extpen(d, index);
break;
case U_EMR_EXTCREATEFONTINDIRECTW:
select_font(d, index);
break;
}
}
}
break;
}
case U_EMR_CREATEPEN:
{
dbg_str << "<!-- U_EMR_CREATEPEN -->\n";
PU_EMRCREATEPEN pEmr = (PU_EMRCREATEPEN) lpEMFR;
insert_object(d, pEmr->ihPen, U_EMR_CREATEPEN, lpEMFR);
break;
}
case U_EMR_CREATEBRUSHINDIRECT:
{
dbg_str << "<!-- U_EMR_CREATEBRUSHINDIRECT -->\n";
PU_EMRCREATEBRUSHINDIRECT pEmr = (PU_EMRCREATEBRUSHINDIRECT) lpEMFR;
insert_object(d, pEmr->ihBrush, U_EMR_CREATEBRUSHINDIRECT, lpEMFR);
break;
}
case U_EMR_DELETEOBJECT:
dbg_str << "<!-- U_EMR_DELETEOBJECT -->\n";
break;
case U_EMR_ANGLEARC:
dbg_str << "<!-- U_EMR_ANGLEARC -->\n";
break;
case U_EMR_ELLIPSE:
{
dbg_str << "<!-- U_EMR_ELLIPSE -->\n";
PU_EMRELLIPSE pEmr = (PU_EMRELLIPSE) lpEMFR;
U_RECTL rclBox = pEmr->rclBox;
double l = pix_to_x_point( d, rclBox.left, rclBox.top );
double t = pix_to_y_point( d, rclBox.left, rclBox.top );
double r = pix_to_x_point( d, rclBox.right, rclBox.bottom );
double b = pix_to_y_point( d, rclBox.right, rclBox.bottom );
double cx = (l + r) / 2.0;
double cy = (t + b) / 2.0;
double rx = fabs(l - r) / 2.0;
double ry = fabs(t - b) / 2.0;
SVGOStringStream tmp_ellipse;
tmp_ellipse << "cx=\"" << cx << "\" ";
tmp_ellipse << "cy=\"" << cy << "\" ";
tmp_ellipse << "rx=\"" << rx << "\" ";
tmp_ellipse << "ry=\"" << ry << "\" ";
d->mask |= emr_mask;
*(d->outsvg) += " <ellipse ";
output_style(d, lpEMFR->iType); //
*(d->outsvg) += "\n\t";
*(d->outsvg) += tmp_ellipse.str().c_str();
*(d->outsvg) += "/> \n";
*(d->path) = "";
break;
}
case U_EMR_RECTANGLE:
{
dbg_str << "<!-- U_EMR_RECTANGLE -->\n";
PU_EMRRECTANGLE pEmr = (PU_EMRRECTANGLE) lpEMFR;
U_RECTL rc = pEmr->rclBox;
double l = pix_to_x_point( d, rc.left, rc.top );
double t = pix_to_y_point( d, rc.left, rc.top );
double r = pix_to_x_point( d, rc.right, rc.bottom );
double b = pix_to_y_point( d, rc.right, rc.bottom );
SVGOStringStream tmp_rectangle;
tmp_rectangle << "\n\tM " << l << " " << t << " ";
tmp_rectangle << "\n\tL " << r << " " << t << " ";
tmp_rectangle << "\n\tL " << r << " " << b << " ";
tmp_rectangle << "\n\tL " << l << " " << b << " ";
tmp_rectangle << "\n\tz";
d->mask |= emr_mask;
tmp_path << tmp_rectangle.str().c_str();
break;
}
case U_EMR_ROUNDRECT:
{
dbg_str << "<!-- U_EMR_ROUNDRECT -->\n";
PU_EMRROUNDRECT pEmr = (PU_EMRROUNDRECT) lpEMFR;
U_RECTL rc = pEmr->rclBox;
U_SIZEL corner = pEmr->szlCorner;
double f = 4.*(sqrt(2) - 1)/3;
double l = pix_to_x_point(d, rc.left, rc.top);
double t = pix_to_y_point(d, rc.left, rc.top);
double r = pix_to_x_point(d, rc.right, rc.bottom);
double b = pix_to_y_point(d, rc.right, rc.bottom);
double cnx = pix_to_size_point(d, corner.cx/2);
double cny = pix_to_size_point(d, corner.cy/2);
SVGOStringStream tmp_rectangle;
tmp_rectangle << "\n\tM " << l << ", " << t + cny << " ";
tmp_rectangle << "\n\tC " << l << ", " << t + (1-f)*cny << " " << l + (1-f)*cnx << ", " << t << " " << l + cnx << ", " << t << " ";
tmp_rectangle << "\n\tL " << r - cnx << ", " << t << " ";
tmp_rectangle << "\n\tC " << r - (1-f)*cnx << ", " << t << " " << r << ", " << t + (1-f)*cny << " " << r << ", " << t + cny << " ";
tmp_rectangle << "\n\tL " << r << ", " << b - cny << " ";
tmp_rectangle << "\n\tC " << r << ", " << b - (1-f)*cny << " " << r - (1-f)*cnx << ", " << b << " " << r - cnx << ", " << b << " ";
tmp_rectangle << "\n\tL " << l + cnx << ", " << b << " ";
tmp_rectangle << "\n\tC " << l + (1-f)*cnx << ", " << b << " " << l << ", " << b - (1-f)*cny << " " << l << ", " << b - cny << " ";
tmp_rectangle << "\n\tz";
d->mask |= emr_mask;
tmp_path << tmp_rectangle.str().c_str();
break;
}
case U_EMR_ARC:
{
dbg_str << "<!-- U_EMR_ARC -->\n";
U_PAIRF center,start,end,size;
int f1;
int f2 = (d->arcdir == U_AD_COUNTERCLOCKWISE ? 0 : 1);
if(!emr_arc_points( lpEMFR, &f1, f2, &center, &start, &end, &size)){
tmp_path << "\n\tM " << pix_to_x_point(d, start.x, start.y) << "," << pix_to_y_point(d, start.x, start.y);
tmp_path << " A " << pix_to_x_point(d, size.x, size.y)/2.0 << "," << pix_to_y_point(d, size.x, size.y)/2.0 ;
tmp_path << " 0 ";
tmp_path << " " << f1 << "," << f2 << " ";
tmp_path << pix_to_x_point(d, end.x, end.y) << "," << pix_to_y_point(d, end.x, end.y)<< " ";
d->mask |= emr_mask;
}
else {
dbg_str << "<!-- ARC record is invalid -->\n";
}
break;
}
case U_EMR_CHORD:
{
dbg_str << "<!-- U_EMR_CHORD -->\n";
U_PAIRF center,start,end,size;
int f1;
int f2 = (d->arcdir == U_AD_COUNTERCLOCKWISE ? 0 : 1);
if(!emr_arc_points( lpEMFR, &f1, f2, &center, &start, &end, &size)){
tmp_path << "\n\tM " << pix_to_x_point(d, start.x, start.y) << "," << pix_to_y_point(d, start.x, start.y);
tmp_path << " A " << pix_to_x_point(d, size.x, size.y)/2.0 << "," << pix_to_y_point(d, size.x, size.y)/2.0 ;
tmp_path << " 0 ";
tmp_path << " " << f1 << "," << f2 << " ";
tmp_path << pix_to_x_point(d, end.x, end.y) << "," << pix_to_y_point(d, end.x, end.y);
tmp_path << " z ";
d->mask |= emr_mask;
}
else {
dbg_str << "<!-- CHORD record is invalid -->\n";
}
break;
}
case U_EMR_PIE:
{
dbg_str << "<!-- U_EMR_PIE -->\n";
U_PAIRF center,start,end,size;
int f1;
int f2 = (d->arcdir == U_AD_COUNTERCLOCKWISE ? 0 : 1);
if(!emr_arc_points( lpEMFR, &f1, f2, &center, &start, &end, &size)){
tmp_path << "\n\tM " << pix_to_x_point(d, center.x, center.y) << "," << pix_to_y_point(d, center.x, center.y);
tmp_path << "\n\tL " << pix_to_x_point(d, start.x, start.y) << "," << pix_to_y_point(d, start.x, start.y);
tmp_path << " A " << pix_to_x_point(d, size.x, size.y)/2.0 << "," << pix_to_y_point(d, size.x, size.y)/2.0;
tmp_path << " 0 ";
tmp_path << " " << f1 << "," << f2 << " ";
tmp_path << pix_to_x_point(d, end.x, end.y) << "," << pix_to_y_point(d, end.x, end.y);
tmp_path << " z ";
d->mask |= emr_mask;
}
else {
dbg_str << "<!-- PIE record is invalid -->\n";
}
break;
}
case U_EMR_SELECTPALETTE: dbg_str << "<!-- U_EMR_SELECTPALETTE -->\n"; break;
case U_EMR_CREATEPALETTE: dbg_str << "<!-- U_EMR_CREATEPALETTE -->\n"; break;
case U_EMR_SETPALETTEENTRIES: dbg_str << "<!-- U_EMR_SETPALETTEENTRIES -->\n"; break;
case U_EMR_RESIZEPALETTE: dbg_str << "<!-- U_EMR_RESIZEPALETTE -->\n"; break;
case U_EMR_REALIZEPALETTE: dbg_str << "<!-- U_EMR_REALIZEPALETTE -->\n"; break;
case U_EMR_EXTFLOODFILL: dbg_str << "<!-- U_EMR_EXTFLOODFILL -->\n"; break;
case U_EMR_LINETO:
{
dbg_str << "<!-- U_EMR_LINETO -->\n";
PU_EMRLINETO pEmr = (PU_EMRLINETO) lpEMFR;
d->mask |= emr_mask;
tmp_path <<
"\n\tL " <<
pix_to_x_point( d, pEmr->ptl.x, pEmr->ptl.y ) << " " <<
pix_to_y_point( d, pEmr->ptl.x, pEmr->ptl.y ) << " ";
break;
}
case U_EMR_ARCTO:
{
dbg_str << "<!-- U_EMR_ARCTO -->\n";
U_PAIRF center,start,end,size;
int f1;
int f2 = (d->arcdir == U_AD_COUNTERCLOCKWISE ? 0 : 1);
if(!emr_arc_points( lpEMFR, &f1, f2, &center, &start, &end, &size)){
// draw a line from current position to start
tmp_path << "\n\tL " << pix_to_x_point(d, start.x, start.y) << "," << pix_to_y_point(d, start.x, start.y);
tmp_path << "\n\tM " << pix_to_x_point(d, start.x, start.y) << "," << pix_to_y_point(d, start.x, start.y);
tmp_path << " A " << pix_to_x_point(d, size.x, size.y)/2.0 << "," << pix_to_y_point(d, size.x, size.y)/2.0 ;
tmp_path << " 0 ";
tmp_path << " " << f1 << "," << f2 << " ";
tmp_path << pix_to_x_point(d, end.x, end.y) << "," << pix_to_y_point(d, end.x, end.y)<< " ";
d->mask |= emr_mask;
}
else {
dbg_str << "<!-- ARCTO record is invalid -->\n";
}
break;
}
case U_EMR_POLYDRAW: dbg_str << "<!-- U_EMR_POLYDRAW -->\n"; break;
case U_EMR_SETARCDIRECTION:
{
dbg_str << "<!-- U_EMR_SETARCDIRECTION -->\n";
PU_EMRSETARCDIRECTION pEmr = (PU_EMRSETARCDIRECTION) lpEMFR;
if(d->arcdir == U_AD_CLOCKWISE || d->arcdir == U_AD_COUNTERCLOCKWISE){ // EMF file could be corrupt
d->arcdir = pEmr->iArcDirection;
}
break;
}
case U_EMR_SETMITERLIMIT:
{
dbg_str << "<!-- U_EMR_SETMITERLIMIT -->\n";
PU_EMRSETMITERLIMIT pEmr = (PU_EMRSETMITERLIMIT) lpEMFR;
//The function takes a float but saves a 32 bit int in the U_EMR_SETMITERLIMIT record.
float miterlimit = *((int32_t *) &(pEmr->eMiterLimit));
d->dc[d->level].style.stroke_miterlimit.value = miterlimit; //ratio, not a pt size
if (d->dc[d->level].style.stroke_miterlimit.value < 2)
d->dc[d->level].style.stroke_miterlimit.value = 2.0;
break;
}
case U_EMR_BEGINPATH:
{
dbg_str << "<!-- U_EMR_BEGINPATH -->\n";
// The next line should never be needed, should have been handled before main switch
*(d->path) = "";
d->mask |= emr_mask;
break;
}
case U_EMR_ENDPATH:
{
dbg_str << "<!-- U_EMR_ENDPATH -->\n";
d->mask &= (0xFFFFFFFF - U_DRAW_ONLYTO); // clear the OnlyTo bit (it might not have been set), prevents any further path extension
break;
}
case U_EMR_CLOSEFIGURE:
{
dbg_str << "<!-- U_EMR_CLOSEFIGURE -->\n";
// EMF may contain multiple closefigures on one path
tmp_path << "\n\tz";
d->mask |= U_DRAW_CLOSED;
break;
}
case U_EMR_FILLPATH:
{
dbg_str << "<!-- U_EMR_FILLPATH -->\n";
if(d->mask & U_DRAW_PATH){ // Operation only effects declared paths
if(!(d->mask & U_DRAW_CLOSED)){ // Close a path not explicitly closed by an EMRCLOSEFIGURE, otherwise fill makes no sense
tmp_path << "\n\tz";
d->mask |= U_DRAW_CLOSED;
}
d->mask |= emr_mask;
d->drawtype = U_EMR_FILLPATH;
}
break;
}
case U_EMR_STROKEANDFILLPATH:
{
dbg_str << "<!-- U_EMR_STROKEANDFILLPATH -->\n";
if(d->mask & U_DRAW_PATH){ // Operation only effects declared paths
if(!(d->mask & U_DRAW_CLOSED)){ // Close a path not explicitly closed by an EMRCLOSEFIGURE, otherwise fill makes no sense
tmp_path << "\n\tz";
d->mask |= U_DRAW_CLOSED;
}
d->mask |= emr_mask;
d->drawtype = U_EMR_STROKEANDFILLPATH;
}
break;
}
case U_EMR_STROKEPATH:
{
dbg_str << "<!-- U_EMR_STROKEPATH -->\n";
if(d->mask & U_DRAW_PATH){ // Operation only effects declared paths
d->mask |= emr_mask;
d->drawtype = U_EMR_STROKEPATH;
}
break;
}
case U_EMR_FLATTENPATH: dbg_str << "<!-- U_EMR_FLATTENPATH -->\n"; break;
case U_EMR_WIDENPATH: dbg_str << "<!-- U_EMR_WIDENPATH -->\n"; break;
case U_EMR_SELECTCLIPPATH: dbg_str << "<!-- U_EMR_SELECTCLIPPATH -->\n"; break;
case U_EMR_ABORTPATH:
{
dbg_str << "<!-- U_EMR_ABORTPATH -->\n";
*(d->path) = "";
d->drawtype = 0;
break;
}
case U_EMR_UNDEF69: dbg_str << "<!-- U_EMR_UNDEF69 -->\n"; break;
case U_EMR_COMMENT:
{
dbg_str << "<!-- U_EMR_COMMENT -->\n";
PU_EMRCOMMENT pEmr = (PU_EMRCOMMENT) lpEMFR;
char *szTxt = (char *) pEmr->Data;
for (uint32_t i = 0; i < pEmr->cbData; i++) {
if ( *szTxt) {
if ( *szTxt >= ' ' && *szTxt < 'z' && *szTxt != '<' && *szTxt != '>' ) {
tmp_str << *szTxt;
}
szTxt++;
}
}
if (0 && strlen(tmp_str.str().c_str())) {
tmp_outsvg << " <!-- \"";
tmp_outsvg << tmp_str.str().c_str();
tmp_outsvg << "\" -->\n";
}
break;
}
case U_EMR_FILLRGN: dbg_str << "<!-- U_EMR_FILLRGN -->\n"; break;
case U_EMR_FRAMERGN: dbg_str << "<!-- U_EMR_FRAMERGN -->\n"; break;
case U_EMR_INVERTRGN: dbg_str << "<!-- U_EMR_INVERTRGN -->\n"; break;
case U_EMR_PAINTRGN: dbg_str << "<!-- U_EMR_PAINTRGN -->\n"; break;
case U_EMR_EXTSELECTCLIPRGN:
{
dbg_str << "<!-- U_EMR_EXTSELECTCLIPRGN -->\n";
PU_EMREXTSELECTCLIPRGN pEmr = (PU_EMREXTSELECTCLIPRGN) lpEMFR;
if (pEmr->iMode == U_RGN_COPY)
clipset = false;
break;
}
case U_EMR_BITBLT:
{
dbg_str << "<!-- U_EMR_BITBLT -->\n";
PU_EMRBITBLT pEmr = (PU_EMRBITBLT) lpEMFR;
// Treat all nonImage bitblts as a rectangular write. Definitely not correct, but at
// least it leaves objects where the operations should have been.
if (!pEmr->cbBmiSrc) {
// should be an application of a DIBPATTERNBRUSHPT, use a solid color instead
double l = pix_to_x_point( d, pEmr->Dest.x, pEmr->Dest.y);
double t = pix_to_y_point( d, pEmr->Dest.x, pEmr->Dest.y);
double r = pix_to_x_point( d, pEmr->Dest.x + pEmr->cDest.x, pEmr->Dest.y + pEmr->cDest.y);
double b = pix_to_y_point( d, pEmr->Dest.x + pEmr->cDest.x, pEmr->Dest.y + pEmr->cDest.y);
SVGOStringStream tmp_rectangle;
tmp_rectangle << "\n\tM " << l << " " << t << " ";
tmp_rectangle << "\n\tL " << r << " " << t << " ";
tmp_rectangle << "\n\tL " << r << " " << b << " ";
tmp_rectangle << "\n\tL " << l << " " << b << " ";
tmp_rectangle << "\n\tz";
d->mask |= emr_mask;
d->dwRop3 = pEmr->dwRop; // we will try to approximate SOME of these
d->mask |= U_DRAW_CLOSED; // Bitblit is not really open or closed, but we need it to fill, and this is the flag for that
tmp_path << tmp_rectangle.str().c_str();
}
break;
}
case U_EMR_STRETCHBLT: dbg_str << "<!-- U_EMR_STRETCHBLT -->\n"; break;
case U_EMR_MASKBLT: dbg_str << "<!-- U_EMR_MASKBLT -->\n"; break;
case U_EMR_PLGBLT: dbg_str << "<!-- U_EMR_PLGBLT -->\n"; break;
case U_EMR_SETDIBITSTODEVICE: dbg_str << "<!-- U_EMR_SETDIBITSTODEVICE -->\n"; break;
case U_EMR_STRETCHDIBITS:
{
// Some applications use multiple EMF operations, including multiple STRETCHDIBITS to create
// images with transparent regions. PowerPoint does this with rotated images, for instance.
// Parsing all of that to derive a single resultant image object is left for a later version
// of this code. In the meantime, every STRETCHDIBITS goes directly to an image. The Inkscape
// user can sort out transparency later using Gimp, if need be.
PU_EMRSTRETCHDIBITS pEmr = (PU_EMRSTRETCHDIBITS) lpEMFR;
double l = pix_to_x_point( d, pEmr->Dest.x, pEmr->Dest.y );
double t = pix_to_y_point( d, pEmr->Dest.x, pEmr->Dest.y );
double r = pix_to_x_point( d, pEmr->Dest.x + pEmr->cDest.x, pEmr->Dest.y + pEmr->cDest.y );
double b = pix_to_y_point( d, pEmr->Dest.x + pEmr->cDest.x, pEmr->Dest.y + pEmr->cDest.y );
SVGOStringStream tmp_image;
tmp_image << " y=\"" << t << "\"\n x=\"" << l <<"\"\n ";
// The image ID is filled in much later when tmp_image is converted
tmp_image << " xlink:href=\"data:image/png;base64,";
MEMPNG mempng; // PNG in memory comes back in this
mempng.buffer = NULL;
char *rgba_px=NULL; // RGBA pixels
char *px=NULL; // DIB pixels
uint32_t width, height, colortype, numCt, invert;
PU_RGBQUAD ct = NULL;
if(!pEmr->cbBitsSrc ||
!pEmr->cbBmiSrc ||
(pEmr->iUsageSrc != U_DIB_RGB_COLORS) ||
!get_DIB_params( // this returns pointers and values, but allocates no memory
pEmr,
pEmr->offBitsSrc,
pEmr->offBmiSrc,
&px,
&ct,
&numCt,
&width,
&height,
&colortype,
&invert
)){
if(!DIB_to_RGBA(
px, // DIB pixel array
ct, // DIB color table
numCt, // DIB color table number of entries
&rgba_px, // U_RGBA pixel array (32 bits), created by this routine, caller must free.
width, // Width of pixel array
height, // Height of pixel array
colortype, // DIB BitCount Enumeration
numCt, // Color table used if not 0
invert // If DIB rows are in opposite order from RGBA rows
) &&
rgba_px)
{
toPNG( // Get the image from the RGBA px into mempng
&mempng,
width, height,
rgba_px,
4 * width * height);
free(rgba_px);
}
}
if(mempng.buffer){
gchar *base64String = g_base64_encode((guchar*) mempng.buffer, mempng.size );
free(mempng.buffer);
tmp_image << base64String ;
g_free(base64String);
}
else {
// insert a random 3x4 blotch otherwise
tmp_image << "iVBORw0KGgoAAAANSUhEUgAAAAQAAAADCAIAAAA7ljmRAAAAA3NCSVQICAjb4U/gAAAALElEQVQImQXBQQ2AMAAAsUJQMSWI2H8qME1yMshojwrvGB8XcHKvR1XtOTc/8HENumHCsOMAAAAASUVORK5CYII=";
}
tmp_image << "\"\n height=\"" << b-t+1 << "\"\n width=\"" << r-l+1 << "\"\n";
*(d->outsvg) += "\n\t <image\n";
*(d->outsvg) += tmp_image.str().c_str();
*(d->outsvg) += "/> \n";
*(d->path) = "";
dbg_str << "<!-- U_EMR_STRETCHDIBITS -->\n";
break;
}
case U_EMR_EXTCREATEFONTINDIRECTW:
{
dbg_str << "<!-- U_EMR_EXTCREATEFONTINDIRECTW -->\n";
PU_EMREXTCREATEFONTINDIRECTW pEmr = (PU_EMREXTCREATEFONTINDIRECTW) lpEMFR;
insert_object(d, pEmr->ihFont, U_EMR_EXTCREATEFONTINDIRECTW, lpEMFR);
break;
}
case U_EMR_EXTTEXTOUTA:
case U_EMR_EXTTEXTOUTW:
case U_EMR_SMALLTEXTOUT:
{
dbg_str << "<!-- U_EMR_EXTTEXTOUTA/W -->\n";
PU_EMREXTTEXTOUTW pEmr = (PU_EMREXTTEXTOUTW) lpEMFR;
PU_EMRSMALLTEXTOUT pEmrS = (PU_EMRSMALLTEXTOUT) lpEMFR;
double x1,y1;
int roff = sizeof(U_EMRSMALLTEXTOUT); //offset to the start of the variable fields, only used with U_EMR_SMALLTEXTOUT
int cChars;
if(lpEMFR->iType==U_EMR_SMALLTEXTOUT){
x1 = pEmrS->Dest.x;
y1 = pEmrS->Dest.y;
cChars = pEmrS->cChars;
if(!(pEmrS->fuOptions & U_ETO_NO_RECT)){ roff += sizeof(U_RECTL); }
}
else {
x1 = pEmr->emrtext.ptlReference.x;
y1 = pEmr->emrtext.ptlReference.y;
cChars = 0;
}
if (d->dc[d->level].textAlign & U_TA_UPDATECP) {
x1 = d->dc[d->level].cur.x;
y1 = d->dc[d->level].cur.y;
}
double x = pix_to_x_point(d, x1, y1);
double y = pix_to_y_point(d, x1, y1);
double dfact;
if (d->dc[d->level].textAlign & U_TA_BASEBIT){ dfact = 0.00; } // alignments 0x10 to U_TA_BASELINE 0x18
else if(d->dc[d->level].textAlign & U_TA_BOTTOM){ dfact = -0.35; } // alignments U_TA_BOTTOM 0x08 to 0x0E, factor is approximate
else { dfact = 0.85; } // alignments U_TA_TOP 0x00 to 0x07, factor is approximate
if (d->dc[d->level].style.baseline_shift.value) {
x += dfact * std::sin(d->dc[d->level].style.baseline_shift.value*M_PI/180.0)*fabs(d->dc[d->level].style.font_size.computed);
y += dfact * std::cos(d->dc[d->level].style.baseline_shift.value*M_PI/180.0)*fabs(d->dc[d->level].style.font_size.computed);
}
else {
y += dfact * fabs(d->dc[d->level].style.font_size.computed);
}
uint32_t *dup_wt = NULL;
if( lpEMFR->iType==U_EMR_EXTTEXTOUTA){
/* These should be JUST ASCII, but they might not be...
If it holds Utf-8 or plain ASCII the first call will succeed.
If not, assume that it holds Latin1.
If that fails then someting is really screwed up!
*/
dup_wt = U_Utf8ToUtf32le((char *) pEmr + pEmr->emrtext.offString, pEmr->emrtext.nChars, NULL);
if(!dup_wt)dup_wt = U_Latin1ToUtf32le((char *) pEmr + pEmr->emrtext.offString, pEmr->emrtext.nChars, NULL);
if(!dup_wt)dup_wt = unknown_chars(pEmr->emrtext.nChars);
}
else if( lpEMFR->iType==U_EMR_EXTTEXTOUTW){
dup_wt = U_Utf16leToUtf32le((uint16_t *)((char *) pEmr + pEmr->emrtext.offString), pEmr->emrtext.nChars, NULL);
if(!dup_wt)dup_wt = unknown_chars(pEmr->emrtext.nChars);
}
else { // U_EMR_SMALLTEXTOUT
if(pEmrS->fuOptions & U_ETO_SMALL_CHARS){
dup_wt = U_Utf8ToUtf32le((char *) pEmrS + roff, cChars, NULL);
}
else {
dup_wt = U_Utf16leToUtf32le((uint16_t *)((char *) pEmrS + roff), cChars, NULL);
}
if(!dup_wt)dup_wt = unknown_chars(cChars);
}
msdepua(dup_wt); //convert everything in Microsoft's private use area. For Symbol, Wingdings, Dingbats
if(NonToUnicode(dup_wt, d->dc[d->level].tstyle.font_family.value)){
g_free(d->dc[d->level].tstyle.font_family.value);
d->dc[d->level].tstyle.font_family.value = g_strdup("Times New Roman");
}
char *ansi_text;
ansi_text = (char *) U_Utf32leToUtf8((uint32_t *)dup_wt, 0, NULL);
free(dup_wt);
if (ansi_text) {
// gchar *p = ansi_text;
// while (*p) {
// if (*p < 32 || *p >= 127) {
// g_free(ansi_text);
// ansi_text = g_strdup("");
// break;
// }
// p++;
// }
SVGOStringStream ts;
gchar *escaped_text = g_markup_escape_text(ansi_text, -1);
// float text_rgb[3];
// sp_color_get_rgb_floatv( &(d->dc[d->level].style.fill.value.color), text_rgb );
// if (!d->dc[d->level].textColorSet) {
// d->dc[d->level].textColor = RGB(SP_COLOR_F_TO_U(text_rgb[0]),
// SP_COLOR_F_TO_U(text_rgb[1]),
// SP_COLOR_F_TO_U(text_rgb[2]));
// }
char tmp[128];
snprintf(tmp, 127,
"fill:#%02x%02x%02x;",
U_RGBAGetR(d->dc[d->level].textColor),
U_RGBAGetG(d->dc[d->level].textColor),
U_RGBAGetB(d->dc[d->level].textColor));
bool i = (d->dc[d->level].style.font_style.value == SP_CSS_FONT_STYLE_ITALIC);
//bool o = (d->dc[d->level].style.font_style.value == SP_CSS_FONT_STYLE_OBLIQUE);
bool b = (d->dc[d->level].style.font_weight.value == SP_CSS_FONT_WEIGHT_BOLD) ||
(d->dc[d->level].style.font_weight.value >= SP_CSS_FONT_WEIGHT_500 && d->dc[d->level].style.font_weight.value <= SP_CSS_FONT_WEIGHT_900);
// EMF textalignment is a bit strange: 0x6 is center, 0x2 is right, 0x0 is left, the value 0x4 is also drawn left
int lcr = ((d->dc[d->level].textAlign & U_TA_CENTER) == U_TA_CENTER) ? 2 : ((d->dc[d->level].textAlign & U_TA_CENTER) == U_TA_LEFT) ? 0 : 1;
ts << " <text\n";
// ts << " id=\"" << (d->id++) << "\"\n";
ts << " xml:space=\"preserve\"\n";
ts << " x=\"" << x << "\"\n";
ts << " y=\"" << y << "\"\n";
if (d->dc[d->level].style.baseline_shift.value) {
ts << " transform=\""
<< "rotate(-" << d->dc[d->level].style.baseline_shift.value
<< " " << x << " " << y << ")"
<< "\"\n";
}
ts << " style=\""
<< "font-size:" << fabs(d->dc[d->level].style.font_size.computed) << "px;"
<< tmp
<< "font-style:" << (i ? "italic" : "normal") << ";"
<< "font-weight:" << (b ? "bold" : "normal") << ";"
<< "text-align:" << (lcr==2 ? "center" : lcr==1 ? "end" : "start") << ";"
<< "text-anchor:" << (lcr==2 ? "middle" : lcr==1 ? "end" : "start") << ";"
<< "font-family:" << d->dc[d->level].tstyle.font_family.value << ";"
<< "\"\n";
ts << " >";
ts << escaped_text;
ts << "</text>\n";
*(d->outsvg) += ts.str().c_str();
g_free(escaped_text);
free(ansi_text);
}
break;
}
case U_EMR_POLYBEZIER16:
{
dbg_str << "<!-- U_EMR_POLYBEZIER16 -->\n";
PU_EMRPOLYBEZIER16 pEmr = (PU_EMRPOLYBEZIER16) lpEMFR;
PU_POINT16 apts = (PU_POINT16) pEmr->apts; // Bug in MinGW wingdi.h ?
uint32_t i,j;
if (pEmr->cpts<4)
break;
d->mask |= emr_mask;
tmp_str <<
"\n\tM " <<
pix_to_x_point( d, apts[0].x, apts[0].y ) << " " <<
pix_to_y_point( d, apts[0].x, apts[0].y ) << " ";
for (i=1; i<pEmr->cpts; ) {
tmp_str << "\n\tC ";
for (j=0; j<3 && i<pEmr->cpts; j++,i++) {
tmp_str <<
pix_to_x_point( d, apts[i].x, apts[i].y ) << " " <<
pix_to_y_point( d, apts[i].x, apts[i].y ) << " ";
}
}
tmp_path << tmp_str.str().c_str();
break;
}
case U_EMR_POLYGON16:
{
dbg_str << "<!-- U_EMR_POLYGON16 -->\n";
PU_EMRPOLYGON16 pEmr = (PU_EMRPOLYGON16) lpEMFR;
PU_POINT16 apts = (PU_POINT16) pEmr->apts; // Bug in MinGW wingdi.h ?
SVGOStringStream tmp_poly;
unsigned int i;
unsigned int first = 0;
d->mask |= emr_mask;
// skip the first point?
tmp_poly << "\n\tM " <<
pix_to_x_point( d, apts[first].x, apts[first].y ) << " " <<
pix_to_y_point( d, apts[first].x, apts[first].y ) << " ";
for (i=first+1; i<pEmr->cpts; i++) {
tmp_poly << "\n\tL " <<
pix_to_x_point( d, apts[i].x, apts[i].y ) << " " <<
pix_to_y_point( d, apts[i].x, apts[i].y ) << " ";
}
tmp_path << tmp_poly.str().c_str();
tmp_path << "\n\tz";
d->mask |= U_DRAW_CLOSED;
break;
}
case U_EMR_POLYLINE16:
{
dbg_str << "<!-- U_EMR_POLYLINE16 -->\n";
PU_EMRPOLYLINE16 pEmr = (PU_EMRPOLYLINE16) lpEMFR;
PU_POINT16 apts = (PU_POINT16) pEmr->apts; // Bug in MinGW wingdi.h ?
uint32_t i;
if (pEmr->cpts<2)
break;
d->mask |= emr_mask;
tmp_str <<
"\n\tM " <<
pix_to_x_point( d, apts[0].x, apts[0].y ) << " " <<
pix_to_y_point( d, apts[0].x, apts[0].y ) << " ";
for (i=1; i<pEmr->cpts; i++) {
tmp_str <<
"\n\tL " <<
pix_to_x_point( d, apts[i].x, apts[i].y ) << " " <<
pix_to_y_point( d, apts[i].x, apts[i].y ) << " ";
}
tmp_path << tmp_str.str().c_str();
break;
}
case U_EMR_POLYBEZIERTO16:
{
dbg_str << "<!-- U_EMR_POLYBEZIERTO16 -->\n";
PU_EMRPOLYBEZIERTO16 pEmr = (PU_EMRPOLYBEZIERTO16) lpEMFR;
PU_POINT16 apts = (PU_POINT16) pEmr->apts; // Bug in MinGW wingdi.h ?
uint32_t i,j;
d->mask |= emr_mask;
for (i=0; i<pEmr->cpts;) {
tmp_path << "\n\tC ";
for (j=0; j<3 && i<pEmr->cpts; j++,i++) {
tmp_path <<
pix_to_x_point( d, apts[i].x, apts[i].y ) << " " <<
pix_to_y_point( d, apts[i].x, apts[i].y ) << " ";
}
}
break;
}
case U_EMR_POLYLINETO16:
{
dbg_str << "<!-- U_EMR_POLYLINETO16 -->\n";
PU_EMRPOLYLINETO16 pEmr = (PU_EMRPOLYLINETO16) lpEMFR;
PU_POINT16 apts = (PU_POINT16) pEmr->apts; // Bug in MinGW wingdi.h ?
uint32_t i;
d->mask |= emr_mask;
for (i=0; i<pEmr->cpts;i++) {
tmp_path <<
"\n\tL " <<
pix_to_x_point( d, apts[i].x, apts[i].y ) << " " <<
pix_to_y_point( d, apts[i].x, apts[i].y ) << " ";
}
break;
}
case U_EMR_POLYPOLYLINE16:
case U_EMR_POLYPOLYGON16:
{
if (lpEMFR->iType == U_EMR_POLYPOLYLINE16)
dbg_str << "<!-- U_EMR_POLYPOLYLINE16 -->\n";
if (lpEMFR->iType == U_EMR_POLYPOLYGON16)
dbg_str << "<!-- U_EMR_POLYPOLYGON16 -->\n";
PU_EMRPOLYPOLYGON16 pEmr = (PU_EMRPOLYPOLYGON16) lpEMFR;
unsigned int n, i, j;
d->mask |= emr_mask;
PU_POINT16 apts = (PU_POINT16) &pEmr->aPolyCounts[pEmr->nPolys];
i = 0;
for (n=0; n<pEmr->nPolys && i<pEmr->cpts; n++) {
SVGOStringStream poly_path;
poly_path << "\n\tM " <<
pix_to_x_point( d, apts[i].x, apts[i].y ) << " " <<
pix_to_y_point( d, apts[i].x, apts[i].y ) << " ";
i++;
for (j=1; j<pEmr->aPolyCounts[n] && i<pEmr->cpts; j++) {
poly_path << "\n\tL " <<
pix_to_x_point( d, apts[i].x, apts[i].y ) << " " <<
pix_to_y_point( d, apts[i].x, apts[i].y ) << " ";
i++;
}
tmp_str << poly_path.str().c_str();
if (lpEMFR->iType == U_EMR_POLYPOLYGON16)
tmp_str << " z";
tmp_str << " \n";
}
tmp_path << tmp_str.str().c_str();
break;
}
case U_EMR_POLYDRAW16: dbg_str << "<!-- U_EMR_POLYDRAW16 -->\n"; break;
case U_EMR_CREATEMONOBRUSH:
{
dbg_str << "<!-- U_EMR_CREATEDIBPATTERNBRUSHPT -->\n";
PU_EMRCREATEMONOBRUSH pEmr = (PU_EMRCREATEMONOBRUSH) lpEMFR;
insert_object(d, pEmr->ihBrush, U_EMR_CREATEMONOBRUSH, lpEMFR);
break;
}
case U_EMR_CREATEDIBPATTERNBRUSHPT:
{
dbg_str << "<!-- U_EMR_CREATEDIBPATTERNBRUSHPT -->\n";
PU_EMRCREATEDIBPATTERNBRUSHPT pEmr = (PU_EMRCREATEDIBPATTERNBRUSHPT) lpEMFR;
insert_object(d, pEmr->ihBrush, U_EMR_CREATEDIBPATTERNBRUSHPT, lpEMFR);
break;
}
case U_EMR_EXTCREATEPEN:
{
dbg_str << "<!-- U_EMR_EXTCREATEPEN -->\n";
PU_EMREXTCREATEPEN pEmr = (PU_EMREXTCREATEPEN) lpEMFR;
insert_object(d, pEmr->ihPen, U_EMR_EXTCREATEPEN, lpEMFR);
break;
}
case U_EMR_POLYTEXTOUTA: dbg_str << "<!-- U_EMR_POLYTEXTOUTA -->\n"; break;
case U_EMR_POLYTEXTOUTW: dbg_str << "<!-- U_EMR_POLYTEXTOUTW -->\n"; break;
case U_EMR_SETICMMODE:
{
dbg_str << "<!-- U_EMR_SETICMMODE -->\n";
#if 0
PU_EMRENABLEICM pEmr = (PU_EMRENABLEICM) lpEMFR;
ICMmode= pEmr->iMode;
#endif //0
break;
}
case U_EMR_CREATECOLORSPACE: dbg_str << "<!-- U_EMR_CREATECOLORSPACE -->\n"; break;
case U_EMR_SETCOLORSPACE: dbg_str << "<!-- U_EMR_SETCOLORSPACE -->\n"; break;
case U_EMR_DELETECOLORSPACE: dbg_str << "<!-- U_EMR_DELETECOLORSPACE -->\n"; break;
case U_EMR_GLSRECORD: dbg_str << "<!-- U_EMR_GLSRECORD -->\n"; break;
case U_EMR_GLSBOUNDEDRECORD: dbg_str << "<!-- U_EMR_GLSBOUNDEDRECORD -->\n"; break;
case U_EMR_PIXELFORMAT: dbg_str << "<!-- U_EMR_PIXELFORMAT -->\n"; break;
case U_EMR_DRAWESCAPE: dbg_str << "<!-- U_EMR_DRAWESCAPE -->\n"; break;
case U_EMR_EXTESCAPE: dbg_str << "<!-- U_EMR_EXTESCAPE -->\n"; break;
case U_EMR_UNDEF107: dbg_str << "<!-- U_EMR_UNDEF107 -->\n"; break;
// U_EMR_SMALLTEXTOUT is handled with U_EMR_EXTTEXTOUTA/W above
case U_EMR_FORCEUFIMAPPING: dbg_str << "<!-- U_EMR_FORCEUFIMAPPING -->\n"; break;
case U_EMR_NAMEDESCAPE: dbg_str << "<!-- U_EMR_NAMEDESCAPE -->\n"; break;
case U_EMR_COLORCORRECTPALETTE: dbg_str << "<!-- U_EMR_COLORCORRECTPALETTE -->\n"; break;
case U_EMR_SETICMPROFILEA: dbg_str << "<!-- U_EMR_SETICMPROFILEA -->\n"; break;
case U_EMR_SETICMPROFILEW: dbg_str << "<!-- U_EMR_SETICMPROFILEW -->\n"; break;
case U_EMR_ALPHABLEND: dbg_str << "<!-- U_EMR_ALPHABLEND -->\n"; break;
case U_EMR_SETLAYOUT: dbg_str << "<!-- U_EMR_SETLAYOUT -->\n"; break;
case U_EMR_TRANSPARENTBLT: dbg_str << "<!-- U_EMR_TRANSPARENTBLT -->\n"; break;
case U_EMR_UNDEF117: dbg_str << "<!-- U_EMR_UNDEF117 -->\n"; break;
case U_EMR_GRADIENTFILL: dbg_str << "<!-- U_EMR_GRADIENTFILL -->\n"; break;
/* Gradient fill is doable for rectangles because those correspond to linear gradients. However,
the general case for the triangle fill, with a different color in each corner of the triangle,
has no SVG equivalent and cannot be easily emulated with SVG gradients. Except that so far
I (DM) have not been able to make an EMF with a rectangular gradientfill record which is not
completely toxic to other EMF readers. So far now, do nothing.
*/
case U_EMR_SETLINKEDUFIS: dbg_str << "<!-- U_EMR_SETLINKEDUFIS -->\n"; break;
case U_EMR_SETTEXTJUSTIFICATION: dbg_str << "<!-- U_EMR_SETTEXTJUSTIFICATION -->\n"; break;
case U_EMR_COLORMATCHTOTARGETW: dbg_str << "<!-- U_EMR_COLORMATCHTOTARGETW -->\n"; break;
case U_EMR_CREATECOLORSPACEW: dbg_str << "<!-- U_EMR_CREATECOLORSPACEW -->\n"; break;
default:
dbg_str << "<!-- U_EMR_??? -->\n";
break;
} //end of switch
// When testing, uncomment the following to place a comment for each processed EMR record in the SVG
// *(d->outsvg) += dbg_str.str().c_str();
*(d->outsvg) += tmp_outsvg.str().c_str();
*(d->path) += tmp_path.str().c_str();
} //end of while
// When testing, uncomment the following to show the final SVG derived from the EMF
// std::cout << *(d->outsvg) << std::endl;
return 1;
}
// Aldus Placeable Header ===================================================
// Since we are a 32bit app, we have to be sure this structure compiles to
// be identical to a 16 bit app's version. To do this, we use the #pragma
// to adjust packing, we use a uint16_t for the hmf handle, and a SMALL_RECT
// for the bbox rectangle.
#pragma pack( push )
#pragma pack( 2 )
typedef struct _SMALL_RECT {
int16_t Left;
int16_t Top;
int16_t Right;
int16_t Bottom;
} SMALL_RECT, *PSMALL_RECT;
typedef struct
{
uint32_t dwKey;
uint16_t hmf;
SMALL_RECT bbox;
uint16_t wInch;
uint32_t dwReserved;
uint16_t wCheckSum;
} APMHEADER, *PAPMHEADER;
#pragma pack( pop )
SPDocument *
Emf::open( Inkscape::Extension::Input * /*mod*/, const gchar *uri )
{
EMF_CALLBACK_DATA d;
memset(&d, 0, sizeof(d));
d.dc[0].worldTransform.eM11 = 1.0;
d.dc[0].worldTransform.eM12 = 0.0;
d.dc[0].worldTransform.eM21 = 0.0;
d.dc[0].worldTransform.eM22 = 1.0;
d.dc[0].worldTransform.eDx = 0.0;
d.dc[0].worldTransform.eDy = 0.0;
if (uri == NULL) {
return NULL;
}
d.outsvg = new Glib::ustring("");
d.path = new Glib::ustring("");
d.outdef = new Glib::ustring("");
d.defs = new Glib::ustring("");
d.mask = 0;
d.drawtype = 0;
d.arcdir = U_AD_COUNTERCLOCKWISE;
d.dwRop2 = U_R2_COPYPEN;
d.dwRop3 = 0;
d.hatches.size = 0;
d.hatches.count = 0;
d.hatches.strings = NULL;
d.images.size = 0;
d.images.count = 0;
d.images.strings = NULL;
size_t length;
char *contents;
if(emf_readdata(uri, &contents, &length))return(NULL);
d.pDesc = NULL;
(void) myEnhMetaFileProc(contents,length, &d);
free(contents);
if (d.pDesc)
free( d.pDesc );
// std::cout << "SVG Output: " << std::endl << *(d.outsvg) << std::endl;
SPDocument *doc = SPDocument::createNewDocFromMem(d.outsvg->c_str(), strlen(d.outsvg->c_str()), TRUE);
delete d.outsvg;
delete d.path;
delete d.outdef;
delete d.defs;
if(d.hatches.count){ free(d.hatches.strings); }
if(d.images.count){ free(d.images.strings); }
if (d.emf_obj) {
int i;
for (i=0; i<d.n_obj; i++)
delete_object(&d, i);
delete[] d.emf_obj;
}
if (d.dc[0].style.stroke_dash.dash)
delete[] d.dc[0].style.stroke_dash.dash;
return doc;
}
void
Emf::init (void)
{
/* EMF in */
Inkscape::Extension::build_from_mem(
"<inkscape-extension xmlns=\"" INKSCAPE_EXTENSION_URI "\">\n"
"<name>" N_("EMF Input") "</name>\n"
"<id>org.inkscape.input.emf</id>\n"
"<input>\n"
"<extension>.emf</extension>\n"
"<mimetype>image/x-emf</mimetype>\n"
"<filetypename>" N_("Enhanced Metafiles (*.emf)") "</filetypename>\n"
"<filetypetooltip>" N_("Enhanced Metafiles") "</filetypetooltip>\n"
"<output_extension>org.inkscape.output.emf</output_extension>\n"
"</input>\n"
"</inkscape-extension>", new Emf());
/* EMF out */
Inkscape::Extension::build_from_mem(
"<inkscape-extension xmlns=\"" INKSCAPE_EXTENSION_URI "\">\n"
"<name>" N_("EMF Output") "</name>\n"
"<id>org.inkscape.output.emf</id>\n"
"<param name=\"textToPath\" gui-text=\"" N_("Convert texts to paths") "\" type=\"boolean\">true</param>\n"
"<param name=\"TnrToSymbol\" gui-text=\"" N_("Map Unicode to Symbol font") "\" type=\"boolean\">true</param>\n"
"<param name=\"TnrToWingdings\" gui-text=\"" N_("Map Unicode to Wingdings") "\" type=\"boolean\">true</param>\n"
"<param name=\"TnrToZapfDingbats\" gui-text=\"" N_("Map Unicode to Zapf Dingbats") "\" type=\"boolean\">true</param>\n"
"<param name=\"UsePUA\" gui-text=\"" N_("Use MS Unicode PUA (0xF020-0xF0FF) for converted characters") "\" type=\"boolean\">false</param>\n"
"<param name=\"FixPPTCharPos\" gui-text=\"" N_("Compensate for PPT font bug") "\" type=\"boolean\">false</param>\n"
"<param name=\"FixPPTDashLine\" gui-text=\"" N_("Convert dashed/dotted lines to single lines") "\" type=\"boolean\">false</param>\n"
"<param name=\"FixPPTGrad2Polys\" gui-text=\"" N_("Convert gradients to colored polygon series") "\" type=\"boolean\">false</param>\n"
"<param name=\"FixPPTPatternAsHatch\" gui-text=\"" N_("Map all fill patterns to standard EMF hatches") "\" type=\"boolean\">false</param>\n"
"<output>\n"
"<extension>.emf</extension>\n"
"<mimetype>image/x-emf</mimetype>\n"
"<filetypename>" N_("Enhanced Metafile (*.emf)") "</filetypename>\n"
"<filetypetooltip>" N_("Enhanced Metafile") "</filetypetooltip>\n"
"</output>\n"
"</inkscape-extension>", new Emf());
return;
}
} } } /* namespace Inkscape, Extension, Implementation */
/*
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 :