From: buliabyak Date: Mon, 13 Nov 2006 22:05:28 +0000 (+0000) Subject: patch for emf export on win32 X-Git-Url: https://git.tokkee.org/?a=commitdiff_plain;h=1e65babae29f5d489b28a25fbc75de615912bb98;p=inkscape.git patch for emf export on win32 --- diff --git a/src/extension/init.cpp b/src/extension/init.cpp index a10f21913..ddbf308ee 100644 --- a/src/extension/init.cpp +++ b/src/extension/init.cpp @@ -33,6 +33,8 @@ #endif #ifdef WIN32 # include "internal/win32.h" +# include "internal/emf-win32-inout.h" +# include "internal/emf-win32-print.h" #endif #include "internal/ps-out.h" #ifdef HAVE_CAIRO_PDF @@ -125,6 +127,8 @@ init() #endif #ifdef WIN32 Internal::PrintWin32::init(); + Internal::PrintEmfWin32::init(); + Internal::EmfWin32::init(); #endif Internal::PovOutput::init(); Internal::OdfOutput::init(); diff --git a/src/extension/internal/Makefile_insert b/src/extension/internal/Makefile_insert index eff097c95..c89c1e77f 100644 --- a/src/extension/internal/Makefile_insert +++ b/src/extension/internal/Makefile_insert @@ -11,6 +11,16 @@ extension_internal_gnome_print_sources = \ extension/internal/gnome.h endif +if WIN32 +extension_internal_win32_sources = \ + extension/internal/win32.cpp \ + extension/internal/win32.h \ + extension/internal/emf-win32-inout.cpp \ + extension/internal/emf-win32-inout.h \ + extension/internal/emf-win32-print.cpp \ + extension/internal/emf-win32-print.h +endif + extension_internal_libinternal_a_SOURCES = \ extension/internal/bluredge.h \ extension/internal/bluredge.cpp \ @@ -53,5 +63,5 @@ extension_internal_libinternal_a_SOURCES = \ extension/internal/latex-pstricks-out.h \ extension/internal/wpg-input.cpp \ extension/internal/wpg-input.h \ - $(extension_internal_gnome_print_sources) - + $(extension_internal_gnome_print_sources) \ + $(extension_internal_win32_sources) diff --git a/src/extension/internal/emf-win32-inout.cpp b/src/extension/internal/emf-win32-inout.cpp new file mode 100644 index 000000000..a39d1fb1d --- /dev/null +++ b/src/extension/internal/emf-win32-inout.cpp @@ -0,0 +1,1430 @@ +/** \file + * Enhanced Metafile Input and Output. + */ +/* + * Authors: + * Ulf Erikson + * + * Copyright (C) 2006 Authors + * + * Released under GNU GPL, read the file 'COPYING' for more information + */ +/* + * References: + * - How to Create & Play Enhanced Metafiles in Win32 + * 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 WIN32 + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "win32.h" +#include "emf-win32-print.h" +#include "emf-win32-inout.h" +#include "inkscape.h" +#include "sp-path.h" +#include "style.h" +#include "color.h" +#include "display/curve.h" +#include "libnr/n-art-bpath.h" +#include "libnr/nr-point-matrix-ops.h" +#include "gtk/gtk.h" +#include "print.h" +#include "glibmm/i18n.h" +#include "extension/extension.h" +#include "extension/system.h" +#include "extension/print.h" +#include "extension/db.h" +#include "extension/output.h" +#include "document.h" +#include "display/nr-arena.h" +#include "display/nr-arena-item.h" + +#include "libnr/nr-rect.h" +#include "libnr/nr-matrix.h" +#include "libnr/nr-pixblock.h" + +#include +#include + +#include +#include + +#include "io/sys.h" + +#include "unit-constants.h" + +#include "clear-n_.h" + + +#define PRINT_EMF_WIN32 "org.inkscape.print.emf.win32" + +#ifndef PS_JOIN_MASK +#define PS_JOIN_MASK (PS_JOIN_BEVEL|PS_JOIN_MITER|PS_JOIN_ROUND) +#endif + + +namespace Inkscape { +namespace Extension { +namespace Internal { + + +EmfWin32::EmfWin32 (void) // The null constructor +{ + return; +} + + +EmfWin32::~EmfWin32 (void) //The destructor +{ + return; +} + + +bool +EmfWin32::check (Inkscape::Extension::Extension * module) +{ + if (NULL == Inkscape::Extension::db.get(PRINT_EMF_WIN32)) + 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; + + sp_document_ensure_up_to_date(doc); + + mod = Inkscape::Extension::get_print(PRINT_EMF_WIN32); + oldconst = mod->get_param_string("destination"); + oldoutput = g_strdup(oldconst); + mod->set_param_string("destination", (gchar *)filename); + +/* Start */ + context.module = mod; + /* fixme: This has to go into module constructor somehow */ + /* Create new arena */ + mod->base = SP_ITEM(sp_document_root(doc)); + mod->arena = NRArena::create(); + mod->dkey = sp_item_display_key_new(1); + mod->root = sp_item_invoke_show(mod->base, mod->arena, mod->dkey, SP_ITEM_SHOW_DISPLAY); + /* Print document */ + ret = mod->begin(doc); + if (ret) { + throw Inkscape::Extension::Output::save_failed(); + } + sp_item_invoke_print(mod->base, &context); + ret = mod->finish(); + /* Release arena */ + sp_item_invoke_hide(mod->base, mod->dkey); + mod->base = NULL; + nr_arena_item_unref(mod->root); + mod->root = NULL; + nr_object_unref((NRObject *) mod->arena); + mod->arena = NULL; +/* end */ + + mod->set_param_string("destination", oldoutput); + g_free(oldoutput); + + return; +} + + +void +EmfWin32::save (Inkscape::Extension::Output *mod, SPDocument *doc, const gchar *uri) +{ + Inkscape::Extension::Extension * ext; + + ext = Inkscape::Extension::db.get(PRINT_EMF_WIN32); + if (ext == NULL) + return; + +// bool old_textToPath = ext->get_param_bool("textToPath"); +// bool new_val = mod->get_param_bool("textToPath"); +// ext->set_param_bool("textToPath", new_val); + + gchar * final_name; + final_name = g_strdup_printf("%s", uri); + emf_print_document_to_file(doc, final_name); + g_free(final_name); + +// ext->set_param_bool("textToPath", old_textToPath); + + return; +} + + + +typedef struct { + int type; + ENHMETARECORD *lpEMFR; +} EMF_OBJECT, *PEMF_OBJECT; + +typedef struct emf_callback_data { + Glib::ustring *outsvg; + Glib::ustring *path; + struct SPStyle style; + bool stroke_set; + bool fill_set; + double xDPI, yDPI; + + SIZEL sizeWnd; + SIZEL sizeView; + float PixelsX; + float PixelsY; + float MMX; + float MMY; + float dwInchesX; + float dwInchesY; + POINTL winorg; + POINTL vieworg; + double ScaleX, ScaleY; + + int n_obj; + PEMF_OBJECT emf_obj; +} EMF_CALLBACK_DATA, *PEMF_CALLBACK_DATA; + + +static void +output_style(PEMF_CALLBACK_DATA d, int iType) +{ + SVGOStringStream tmp_style; + char tmp[1024] = {0}; + + *(d->outsvg) += "\n\tstyle=\""; + if (iType == EMR_STROKEPATH || !d->fill_set) { + tmp_style << "fill:none;"; + } else { + float rgb[3]; + sp_color_get_rgb_floatv( &(d->style.fill.value.color), rgb ); + snprintf(tmp, 1023, + "fill:#%02x%02x%02x;", + SP_COLOR_F_TO_U(rgb[0]), + SP_COLOR_F_TO_U(rgb[1]), + SP_COLOR_F_TO_U(rgb[2])); + tmp_style << tmp; + snprintf(tmp, 1023, + "fill-rule:%s;", + d->style.fill_rule.value != 0 ? "evenodd" : "nonzero"); + tmp_style << tmp; + tmp_style << "fill-opacity:1;"; + } + + if (iType == EMR_FILLPATH || !d->stroke_set) { + tmp_style << "stroke:none;"; + } else { + float rgb[3]; + sp_color_get_rgb_floatv(&(d->style.stroke.value.color), rgb); + snprintf(tmp, 1023, + "stroke:#%02x%02x%02x;", + SP_COLOR_F_TO_U(rgb[0]), + SP_COLOR_F_TO_U(rgb[1]), + SP_COLOR_F_TO_U(rgb[2])); + tmp_style << tmp; + + tmp_style << "stroke-width:" << + MAX( 0.001, d->style.stroke_width.value ) << "px;"; + + tmp_style << "stroke-linejoin:" << + (d->style.stroke_linejoin.computed == 0 ? "miter" : + d->style.stroke_linejoin.computed == 1 ? "round" : + d->style.stroke_linejoin.computed == 2 ? "bevel" : + "unknown") << ";"; + + if (d->style.stroke_linejoin.computed == 0) { + tmp_style << "stroke-miterlimit:" << + MAX( 0.01, d->style.stroke_miterlimit.value ) << ";"; + } + + if (d->style.stroke_dasharray_set && + d->style.stroke_dash.n_dash && d->style.stroke_dash.dash) + { + tmp_style << "stroke-dasharray:"; + for (int i=0; istyle.stroke_dash.n_dash; i++) { + if (i) + tmp_style << ","; + tmp_style << d->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 << "\" "; + + *(d->outsvg) += tmp_style.str().c_str(); +} + + +static double +pix_x_to_point(PEMF_CALLBACK_DATA d, double px) +{ + double tmp = px - d->winorg.x; + tmp *= (double) PX_PER_IN / d->ScaleX; + tmp += d->vieworg.x; + return tmp; +} + + +static double +pix_y_to_point(PEMF_CALLBACK_DATA d, double px) +{ + double tmp = px - d->winorg.y; + tmp *= (double) PX_PER_IN / d->ScaleY; + tmp += d->vieworg.y; + return tmp; +} + + +static double +pix_size_to_point(PEMF_CALLBACK_DATA d, double px) +{ + double tmp = px; + tmp *= (double) PX_PER_IN / d->ScaleX; + return tmp; +} + + +static void +select_pen(PEMF_CALLBACK_DATA d, int index) +{ + PEMRCREATEPEN pEmr = NULL; + + if (index >= 0 && index < d->n_obj) + pEmr = (PEMRCREATEPEN) d->emf_obj[index].lpEMFR; + + if (!pEmr) + return; + + switch (pEmr->lopn.lopnStyle) { + default: + { + d->style.stroke_dasharray_set = 0; + break; + } + } + + if (pEmr->lopn.lopnWidth.x) { + d->style.stroke_width.value = pix_size_to_point( d, pEmr->lopn.lopnWidth.x ); + } else { // this stroke should always be rendered as 1 pixel wide, independent of zoom level (can that be done in SVG?) + d->style.stroke_width.value = 1.0; + } + + double r, g, b; + r = SP_COLOR_U_TO_F( GetRValue(pEmr->lopn.lopnColor) ); + g = SP_COLOR_U_TO_F( GetGValue(pEmr->lopn.lopnColor) ); + b = SP_COLOR_U_TO_F( GetBValue(pEmr->lopn.lopnColor) ); + sp_color_set_rgb_float( &(d->style.stroke.value.color), r,g,b ); + + d->style.stroke_linejoin.computed = 1; + + d->stroke_set = true; +} + + +static void +select_extpen(PEMF_CALLBACK_DATA d, int index) +{ + PEMREXTCREATEPEN pEmr = NULL; + + if (index >= 0 && index < d->n_obj) + pEmr = (PEMREXTCREATEPEN) d->emf_obj[index].lpEMFR; + + if (!pEmr) + return; + + switch (pEmr->elp.elpPenStyle & PS_STYLE_MASK) { + case PS_USERSTYLE: + { + if (pEmr->elp.elpNumEntries) { + d->style.stroke_dash.n_dash = pEmr->elp.elpNumEntries; + if (d->style.stroke_dash.dash) + delete[] d->style.stroke_dash.dash; + d->style.stroke_dash.dash = new double[pEmr->elp.elpNumEntries]; + for (unsigned int i=0; ielp.elpNumEntries; i++) { + d->style.stroke_dash.dash[i] = pix_size_to_point( d, pEmr->elp.elpStyleEntry[i] ); + } + d->style.stroke_dasharray_set = 1; + } else { + d->style.stroke_dasharray_set = 0; + } + break; + } + default: + { + d->style.stroke_dasharray_set = 0; + break; + } + } + + switch (pEmr->elp.elpPenStyle & PS_ENDCAP_MASK) { + case PS_ENDCAP_ROUND: + { + d->style.stroke_linecap.computed = 1; + break; + } + case PS_ENDCAP_SQUARE: + { + d->style.stroke_linecap.computed = 2; + break; + } + case PS_ENDCAP_FLAT: + default: + { + d->style.stroke_linecap.computed = 0; + break; + } + } + + switch (pEmr->elp.elpPenStyle & PS_JOIN_MASK) { + case PS_JOIN_BEVEL: + { + d->style.stroke_linejoin.computed = 2; + break; + } + case PS_JOIN_MITER: + { + d->style.stroke_linejoin.computed = 0; + break; + } + case PS_JOIN_ROUND: + default: + { + d->style.stroke_linejoin.computed = 1; + break; + } + } + + d->style.stroke_width.value = pix_size_to_point( d, pEmr->elp.elpWidth ); + + double r, g, b; + r = SP_COLOR_U_TO_F( GetRValue(pEmr->elp.elpColor) ); + g = SP_COLOR_U_TO_F( GetGValue(pEmr->elp.elpColor) ); + b = SP_COLOR_U_TO_F( GetBValue(pEmr->elp.elpColor) ); + + sp_color_set_rgb_float( &(d->style.stroke.value.color), r,g,b ); + + d->stroke_set = true; +} + + +static void +select_brush(PEMF_CALLBACK_DATA d, int index) +{ + PEMRCREATEBRUSHINDIRECT pEmr = NULL; + + if (index >= 0 && index < d->n_obj) + pEmr = (PEMRCREATEBRUSHINDIRECT) d->emf_obj[index].lpEMFR; + + if (!pEmr) + return; + + if (pEmr->lb.lbStyle == BS_SOLID) { + double r, g, b; + r = SP_COLOR_U_TO_F( GetRValue(pEmr->lb.lbColor) ); + g = SP_COLOR_U_TO_F( GetGValue(pEmr->lb.lbColor) ); + b = SP_COLOR_U_TO_F( GetBValue(pEmr->lb.lbColor) ); + sp_color_set_rgb_float( &(d->style.fill.value.color), r,g,b ); + } + + d->fill_set = true; +} + + +static void +delete_object(PEMF_CALLBACK_DATA d, int index) +{ + if (index >= 0 && index < d->n_obj) { + d->emf_obj[index].type = 0; + 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, ENHMETARECORD *pObj) +{ + if (index >= 0 && index < d->n_obj) { + delete_object(d, index); + d->emf_obj[index].type = type; + d->emf_obj[index].lpEMFR = pObj; + } +} + + +static int CALLBACK +myEnhMetaFileProc(HDC hDC, HANDLETABLE *lpHTable, ENHMETARECORD *lpEMFR, int nObj, LPARAM lpData) +{ + PEMF_CALLBACK_DATA d; + SVGOStringStream tmp_outsvg; + SVGOStringStream tmp_path; + SVGOStringStream tmp_str; + + d = (PEMF_CALLBACK_DATA) lpData; + + switch (lpEMFR->iType) + { + case EMR_HEADER: + { + ENHMETAHEADER *pEmr = (ENHMETAHEADER *) lpEMFR; + tmp_outsvg << "xDPI = 2540; + d->yDPI = 2540; + + d->PixelsX = pEmr->rclFrame.right - pEmr->rclFrame.left; + d->PixelsY = pEmr->rclFrame.bottom - pEmr->rclFrame.top; + + d->MMX = d->PixelsX / 100.0; + d->MMY = d->PixelsY / 100.0; + + tmp_outsvg << + " width=\"" << d->MMX << "mm\"\n" << + " height=\"" << d->MMY << "mm\">\n"; + + if (pEmr->nHandles) { + d->n_obj = pEmr->nHandles; + d->emf_obj = new EMF_OBJECT[d->n_obj]; + } else { + d->emf_obj = NULL; + } + + break; + } + case EMR_POLYBEZIER: + { + PEMRPOLYBEZIER pEmr = (PEMRPOLYBEZIER) lpEMFR; + DWORD i,j; + + if (pEmr->cptl<4) + break; + + *(d->outsvg) += " outsvg) += "\n\td=\""; + + tmp_str << + "\n\tM " << + pix_x_to_point( d, pEmr->aptl[0].x ) << " " << + pix_x_to_point( d, pEmr->aptl[0].y) << " "; + + for (i=1; icptl; ) { + tmp_str << "\n\tC "; + for (j=0; j<3 && icptl; j++,i++) { + tmp_str << + pix_x_to_point( d, pEmr->aptl[i].x ) << " " << + pix_y_to_point( d, pEmr->aptl[i].y ) << " "; + } + } + + *(d->outsvg) += tmp_str.str().c_str(); + *(d->outsvg) += " \" /> \n"; + + break; + } + case EMR_POLYGON: + { + EMRPOLYGON *pEmr = (EMRPOLYGON *) lpEMFR; + DWORD i; + + if (pEmr->cptl < 2) + break; + + *(d->outsvg) += " outsvg) += "\n\td=\""; + + tmp_str << + "\n\tM " << + pix_x_to_point( d, pEmr->aptl[0].x ) << " " << + pix_y_to_point( d, pEmr->aptl[0].y ) << " "; + + for (i=1; icptl; i++) { + tmp_str << + "\n\tL " << + pix_x_to_point( d, pEmr->aptl[i].x ) << " " << + pix_y_to_point( d, pEmr->aptl[i].y ) << " "; + } + + *(d->outsvg) += tmp_str.str().c_str(); + *(d->outsvg) += " z \" /> \n"; + + break; + } + case EMR_POLYLINE: + { + EMRPOLYLINE *pEmr = (EMRPOLYLINE *) lpEMFR; + DWORD i; + + if (pEmr->cptl<2) + break; + + *(d->outsvg) += " outsvg) += "\n\td=\""; + + tmp_str << + "\n\tM " << + pix_x_to_point( d, pEmr->aptl[0].x ) << " " << + pix_y_to_point( d, pEmr->aptl[0].y ) << " "; + + for (i=1; icptl; i++) { + tmp_str << + "\n\tL " << + pix_x_to_point( d, pEmr->aptl[i].x ) << " " << + pix_y_to_point( d, pEmr->aptl[i].y ) << " "; + } + + *(d->outsvg) += tmp_str.str().c_str(); + *(d->outsvg) += " \" /> \n"; + + break; + } + case EMR_POLYBEZIERTO: + { + PEMRPOLYBEZIERTO pEmr = (PEMRPOLYBEZIERTO) lpEMFR; + DWORD i,j; + + for (i=0; icptl;) { + tmp_path << "\n\tC "; + for (j=0; j<3 && icptl; j++,i++) { + tmp_path << + pix_x_to_point( d, pEmr->aptl[i].x ) << " " << + pix_y_to_point( d, pEmr->aptl[i].y ) << " "; + } + } + + break; + } + case EMR_POLYLINETO: + { + PEMRPOLYLINETO pEmr = (PEMRPOLYLINETO) lpEMFR; + DWORD i; + + for (i=0; icptl;i++) { + tmp_path << + "\n\tL " << + pix_x_to_point( d, pEmr->aptl[i].x ) << " " << + pix_y_to_point( d, pEmr->aptl[i].y ) << " "; + } + + break; + } + case EMR_POLYPOLYLINE: + break; + case EMR_POLYPOLYGON: + break; + case EMR_SETWINDOWEXTEX: + { + PEMRSETWINDOWEXTEX pEmr = (PEMRSETWINDOWEXTEX) lpEMFR; + + d->sizeWnd = pEmr->szlExtent; + d->PixelsX = d->sizeWnd.cx; + d->PixelsY = d->sizeWnd.cy; + + d->ScaleX = d->xDPI / (100*d->MMX / d->PixelsX); + d->ScaleY = d->yDPI / (100*d->MMY / d->PixelsY); + + break; + } + case EMR_SETWINDOWORGEX: + { + PEMRSETWINDOWORGEX pEmr = (PEMRSETWINDOWORGEX) lpEMFR; + d->winorg = pEmr->ptlOrigin; + break; + } + case EMR_SETVIEWPORTEXTEX: + { + PEMRSETVIEWPORTEXTEX pEmr = (PEMRSETVIEWPORTEXTEX) lpEMFR; + + d->sizeView = pEmr->szlExtent; + + if (d->sizeWnd.cx && d->sizeWnd.cy) { + HDC hScreenDC = GetDC( NULL ); + + float scrPixelsX = (float)GetDeviceCaps( hScreenDC, HORZRES ); + float scrPixelsY = (float)GetDeviceCaps( hScreenDC, VERTRES ); + float scrMMX = (float)GetDeviceCaps( hScreenDC, HORZSIZE ); + float scrMMY = (float)GetDeviceCaps( hScreenDC, VERTSIZE ); + + ReleaseDC( NULL, hScreenDC ); + + d->dwInchesX = d->sizeView.cx / (25.4f*scrPixelsX/scrMMX); + d->dwInchesY = d->sizeView.cy / (25.4f*scrPixelsY/scrMMY); + d->xDPI = d->sizeWnd.cx / d->dwInchesX; + d->yDPI = d->sizeWnd.cy / d->dwInchesY; + + if (1) { + d->xDPI = 2540; + d->yDPI = 2540; + d->dwInchesX = d->PixelsX / d->xDPI; + d->dwInchesY = d->PixelsY / d->yDPI; + d->ScaleX = d->xDPI; + d->ScaleY = d->yDPI; + } + + d->MMX = d->dwInchesX * MM_PER_IN; + d->MMY = d->dwInchesY * MM_PER_IN; + } + + break; + } + case EMR_SETVIEWPORTORGEX: + { + PEMRSETVIEWPORTORGEX pEmr = (PEMRSETVIEWPORTORGEX) lpEMFR; + d->vieworg = pEmr->ptlOrigin; + break; + } + case EMR_SETBRUSHORGEX: + break; + case EMR_EOF: + { + tmp_outsvg << "\n"; + break; + } + case EMR_SETPIXELV: + break; + case EMR_SETMAPPERFLAGS: + break; + case EMR_SETMAPMODE: + break; + case EMR_SETBKMODE: + break; + case EMR_SETPOLYFILLMODE: + { + PEMRSETPOLYFILLMODE pEmr = (PEMRSETPOLYFILLMODE) lpEMFR; + d->style.fill_rule.value = + (pEmr->iMode == WINDING ? 0 : + pEmr->iMode == ALTERNATE ? 1 : 0); + break; + } + case EMR_SETROP2: + break; + case EMR_SETSTRETCHBLTMODE: + break; + case EMR_SETTEXTALIGN: + break; + case EMR_SETCOLORADJUSTMENT: + break; + case EMR_SETTEXTCOLOR: + break; + case EMR_SETBKCOLOR: + break; + case EMR_OFFSETCLIPRGN: + break; + case EMR_MOVETOEX: + { + PEMRMOVETOEX pEmr = (PEMRMOVETOEX) lpEMFR; + tmp_path << + "\n\tM " << + pix_x_to_point( d, pEmr->ptl.x ) << " " << + pix_y_to_point( d, pEmr->ptl.y ) << " "; + break; + } + case EMR_SETMETARGN: + break; + case EMR_EXCLUDECLIPRECT: + break; + case EMR_INTERSECTCLIPRECT: + break; + case EMR_SCALEVIEWPORTEXTEX: + break; + case EMR_SCALEWINDOWEXTEX: + break; + case EMR_SAVEDC: + break; + case EMR_RESTOREDC: + break; + case EMR_SETWORLDTRANSFORM: + break; + case EMR_MODIFYWORLDTRANSFORM: + break; + case EMR_SELECTOBJECT: + { + PEMRSELECTOBJECT pEmr = (PEMRSELECTOBJECT) lpEMFR; + unsigned int index = pEmr->ihObject; + + if (index >= ENHMETA_STOCK_OBJECT) { + index -= ENHMETA_STOCK_OBJECT; + switch (index) { + case NULL_BRUSH: + d->fill_set = false; + break; + case BLACK_BRUSH: + case DKGRAY_BRUSH: + case GRAY_BRUSH: + case LTGRAY_BRUSH: + case WHITE_BRUSH: + { + float val = 0; + switch (index) { + case BLACK_BRUSH: + val = 0.0 / 255.0; + break; + case DKGRAY_BRUSH: + val = 64.0 / 255.0; + break; + case GRAY_BRUSH: + val = 128.0 / 255.0; + break; + case LTGRAY_BRUSH: + val = 192.0 / 255.0; + break; + case WHITE_BRUSH: + val = 255.0 / 255.0; + break; + } + sp_color_set_rgb_float( &(d->style.fill.value.color), val,val,val ); + + d->fill_set = true; + break; + } + case NULL_PEN: + d->stroke_set = false; + break; + case BLACK_PEN: + case WHITE_PEN: + { + float val = index == BLACK_PEN ? 0 : 1; + d->style.stroke_dasharray_set = 0; + d->style.stroke_width.value = 1.0; + sp_color_set_rgb_float( &(d->style.stroke.value.color), val,val,val ); + + d->stroke_set = true; + + break; + } + } + } else { + if (index >= 0 && index < d->n_obj) { + switch (d->emf_obj[index].type) + { + case EMR_CREATEPEN: + select_pen(d, index); + break; + case EMR_CREATEBRUSHINDIRECT: + select_brush(d, index); + break; + case EMR_EXTCREATEPEN: + select_extpen(d, index); + break; + } + } + } + break; + } + case EMR_CREATEPEN: + { + PEMRCREATEPEN pEmr = (PEMRCREATEPEN) lpEMFR; + int index = pEmr->ihPen; + + EMRCREATEPEN *pPen = + (EMRCREATEPEN *) malloc( sizeof(EMREXTCREATEPEN) ); + pPen->lopn = pEmr->lopn; + insert_object(d, index, EMR_CREATEPEN, (ENHMETARECORD *) pPen); + + break; + } + case EMR_CREATEBRUSHINDIRECT: + { + PEMRCREATEBRUSHINDIRECT pEmr = (PEMRCREATEBRUSHINDIRECT) lpEMFR; + int index = pEmr->ihBrush; + + EMRCREATEBRUSHINDIRECT *pBrush = + (EMRCREATEBRUSHINDIRECT *) malloc( sizeof(EMRCREATEBRUSHINDIRECT) ); + pBrush->lb = pEmr->lb; + insert_object(d, index, EMR_CREATEBRUSHINDIRECT, (ENHMETARECORD *) pBrush); + + break; + } + case EMR_DELETEOBJECT: + break; + case EMR_ANGLEARC: + break; + case EMR_ELLIPSE: + break; + case EMR_RECTANGLE: + break; + case EMR_ROUNDRECT: + break; + case EMR_ARC: + break; + case EMR_CHORD: + break; + case EMR_PIE: + break; + case EMR_SELECTPALETTE: + break; + case EMR_CREATEPALETTE: + break; + case EMR_SETPALETTEENTRIES: + break; + case EMR_RESIZEPALETTE: + break; + case EMR_REALIZEPALETTE: + break; + case EMR_EXTFLOODFILL: + break; + case EMR_LINETO: + { + PEMRLINETO pEmr = (PEMRLINETO) lpEMFR; + tmp_path << + "\n\tL " << + pix_x_to_point( d, pEmr->ptl.x ) << " " << + pix_y_to_point( d, pEmr->ptl.y ) << " "; + break; + } + case EMR_ARCTO: + break; + case EMR_POLYDRAW: + break; + case EMR_SETARCDIRECTION: + break; + case EMR_SETMITERLIMIT: + { + PEMRSETMITERLIMIT pEmr = (PEMRSETMITERLIMIT) lpEMFR; + d->style.stroke_miterlimit.value = pix_size_to_point( d, pEmr->eMiterLimit ); + + if (d->style.stroke_miterlimit.value < 1) + d->style.stroke_miterlimit.value = 1.0; + + break; + } + case EMR_BEGINPATH: + { + tmp_path << " d=\""; + *(d->path) = ""; + break; + } + case EMR_ENDPATH: + { + tmp_path << "\""; + break; + } + case EMR_CLOSEFIGURE: + { + tmp_path << "\n\tz"; + break; + } + case EMR_FILLPATH: + case EMR_STROKEANDFILLPATH: + case EMR_STROKEPATH: + { + *(d->outsvg) += " iType); + *(d->outsvg) += "\n\t"; + *(d->outsvg) += *(d->path); + *(d->outsvg) += " /> \n"; + break; + } + case EMR_FLATTENPATH: + break; + case EMR_WIDENPATH: + break; + case EMR_SELECTCLIPPATH: + break; + case EMR_ABORTPATH: + break; + case EMR_GDICOMMENT: + break; + case EMR_FILLRGN: + break; + case EMR_FRAMERGN: + break; + case EMR_INVERTRGN: + break; + case EMR_PAINTRGN: + break; + case EMR_EXTSELECTCLIPRGN: + break; + case EMR_BITBLT: + break; + case EMR_STRETCHBLT: + break; + case EMR_MASKBLT: + break; + case EMR_PLGBLT: + break; + case EMR_SETDIBITSTODEVICE: + break; + case EMR_STRETCHDIBITS: + break; + case EMR_EXTCREATEFONTINDIRECTW: + break; + case EMR_EXTTEXTOUTA: + break; + case EMR_EXTTEXTOUTW: + break; + case EMR_POLYBEZIER16: + { + PEMRPOLYBEZIER16 pEmr = (PEMRPOLYBEZIER16) lpEMFR; + POINTS *apts = (POINTS *) pEmr->apts; // Bug in MinGW wingdi.h ? + DWORD i,j; + + if (pEmr->cpts<4) + break; + + *(d->outsvg) += " outsvg) += "\n\td=\""; + + tmp_str << + "\n\tM " << + pix_x_to_point( d, apts[0].x ) << " " << + pix_y_to_point( d, apts[0].y ) << " "; + + for (i=1; icpts; ) { + tmp_str << "\n\tC "; + for (j=0; j<3 && icpts; j++,i++) { + tmp_str << + pix_x_to_point( d, apts[i].x ) << " " << + pix_y_to_point( d, apts[i].y ) << " "; + } + } + + *(d->outsvg) += tmp_str.str().c_str(); + *(d->outsvg) += " \" /> \n"; + + break; + } + case EMR_POLYGON16: + { + PEMRPOLYGON16 pEmr = (PEMRPOLYGON16) lpEMFR; + POINTS *apts = (POINTS *) pEmr->apts; // Bug in MinGW wingdi.h ? + unsigned int i; + + *(d->outsvg) += "outsvg) += "\n\td=\""; + + // skip the first point? + tmp_path << "\n\tM " << + pix_x_to_point( d, apts[1].x ) << " " << + pix_y_to_point( d, apts[1].y ) << " "; + + for (i=2; icpts; i++) { + tmp_path << "\n\tL " << + pix_x_to_point( d, apts[i].x ) << " " << + pix_y_to_point( d, apts[i].y ) << " "; + } + + *(d->outsvg) += tmp_path.str().c_str(); + *(d->outsvg) += " z \" /> \n"; + + break; + } + case EMR_POLYLINE16: + { + EMRPOLYLINE16 *pEmr = (EMRPOLYLINE16 *) lpEMFR; + POINTS *apts = (POINTS *) pEmr->apts; // Bug in MinGW wingdi.h ? + DWORD i; + + if (pEmr->cpts<2) + break; + + *(d->outsvg) += " outsvg) += "\n\td=\""; + + tmp_str << + "\n\tM " << + pix_x_to_point( d, apts[0].x ) << " " << + pix_y_to_point( d, apts[0].y ) << " "; + + for (i=1; icpts; i++) { + tmp_str << + "\n\tL " << + pix_x_to_point( d, apts[i].x ) << " " << + pix_y_to_point( d, apts[i].y ) << " "; + } + + *(d->outsvg) += tmp_str.str().c_str(); + *(d->outsvg) += " \" /> \n"; + + break; + } + case EMR_POLYBEZIERTO16: + { + PEMRPOLYBEZIERTO16 pEmr = (PEMRPOLYBEZIERTO16) lpEMFR; + POINTS *apts = (POINTS *) pEmr->apts; // Bug in MinGW wingdi.h ? + DWORD i,j; + + for (i=0; icpts;) { + tmp_path << "\n\tC "; + for (j=0; j<3 && icpts; j++,i++) { + tmp_path << + pix_x_to_point( d, apts[i].x ) << " " << + pix_y_to_point( d, apts[i].y ) << " "; + } + } + + break; + } + case EMR_POLYLINETO16: + { + PEMRPOLYLINETO16 pEmr = (PEMRPOLYLINETO16) lpEMFR; + POINTS *apts = (POINTS *) pEmr->apts; // Bug in MinGW wingdi.h ? + DWORD i; + + for (i=0; icpts;i++) { + tmp_path << + "\n\tL " << + pix_x_to_point( d, apts[i].x ) << " " << + pix_y_to_point( d, apts[i].y ) << " "; + } + + break; + } + case EMR_POLYPOLYLINE16: + break; + case EMR_POLYPOLYGON16: + { + PEMRPOLYPOLYGON16 pEmr = (PEMRPOLYPOLYGON16) lpEMFR; + unsigned int n, i, j; + + *(d->outsvg) += "outsvg) += "\n\td=\""; + + i = pEmr->nPolys-1; // ??? + for (n=0; nnPolys /*&& icpts*/; n++) { + SVGOStringStream poly_path; + + poly_path << "\n\tM " << + pix_x_to_point( d, pEmr->apts[i].x ) << " " << + pix_y_to_point( d, pEmr->apts[i].y ) << " "; + i++; + + for (j=1; jaPolyCounts[n] /*&& icpts*/; j++) { + poly_path << "\n\tL " << + pix_x_to_point( d, pEmr->apts[i].x ) << " " << + pix_y_to_point( d, pEmr->apts[i].y ) << " "; + i++; + } + + *(d->outsvg) += poly_path.str().c_str(); + *(d->outsvg) += " z \n"; + } + + *(d->outsvg) += " \" /> \n"; + break; + } + case EMR_POLYDRAW16: + break; + case EMR_CREATEMONOBRUSH: + break; + case EMR_CREATEDIBPATTERNBRUSHPT: + break; + case EMR_EXTCREATEPEN: + { + PEMREXTCREATEPEN pEmr = (PEMREXTCREATEPEN) lpEMFR; + int index = pEmr->ihPen; + + EMREXTCREATEPEN *pPen = + (EMREXTCREATEPEN *) malloc( sizeof(EMREXTCREATEPEN) + + sizeof(DWORD) * pEmr->elp.elpNumEntries ); + pPen->ihPen = pEmr->ihPen; + pPen->offBmi = pEmr->offBmi; + pPen->cbBmi = pEmr->cbBmi; + pPen->offBits = pEmr->offBits; + pPen->cbBits = pEmr->cbBits; + pPen->elp = pEmr->elp; + for (unsigned int i=0; ielp.elpNumEntries; i++) { + pPen->elp.elpStyleEntry[i] = pEmr->elp.elpStyleEntry[i]; + } + insert_object(d, index, EMR_EXTCREATEPEN, (ENHMETARECORD *) pPen); + + break; + } + case EMR_POLYTEXTOUTA: + break; + case EMR_POLYTEXTOUTW: + break; + case EMR_SETICMMODE: + break; + case EMR_CREATECOLORSPACE: + break; + case EMR_SETCOLORSPACE: + break; + case EMR_DELETECOLORSPACE: + break; + case EMR_GLSRECORD: + break; + case EMR_GLSBOUNDEDRECORD: + break; + case EMR_PIXELFORMAT: + break; + } + + *(d->outsvg) += tmp_outsvg.str().c_str(); + *(d->path) += tmp_path.str().c_str(); + + 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 WORD for the hmf handle, and a SMALL_RECT +// for the bbox rectangle. +#pragma pack( push ) +#pragma pack( 2 ) +typedef struct +{ + DWORD dwKey; + WORD hmf; + SMALL_RECT bbox; + WORD wInch; + DWORD dwReserved; + WORD wCheckSum; +} APMHEADER, *PAPMHEADER; +#pragma pack( pop ) + + +SPDocument * +EmfWin32::open( Inkscape::Extension::Input *mod, const gchar *uri ) +{ + EMF_CALLBACK_DATA d = {0}; + + gsize bytesRead = 0; + gsize bytesWritten = 0; + GError* error = NULL; + gchar *local_fn = + g_filename_from_utf8( uri, -1, &bytesRead, &bytesWritten, &error ); + + if (local_fn == NULL) { + return NULL; + } + + d.outsvg = new Glib::ustring(""); + d.path = new Glib::ustring(""); + + CHAR *ansi_uri = (CHAR *) local_fn; + gunichar2 *unicode_fn = g_utf8_to_utf16( local_fn, -1, NULL, NULL, NULL ); + WCHAR *unicode_uri = (WCHAR *) unicode_fn; + + // Try open as Enhanced Metafile + HENHMETAFILE hemf; + if (PrintWin32::is_os_wide()) + hemf = GetEnhMetaFileW(unicode_uri); + else + hemf = GetEnhMetaFileA(ansi_uri); + + if (!hemf) { + // Try open as Windows Metafile + HMETAFILE hmf; + if (PrintWin32::is_os_wide()) + hmf = GetMetaFileW(unicode_uri); + else + hmf = GetMetaFileA(ansi_uri); + + METAFILEPICT mp; + HDC hDC; + + if (!hmf) { + if (PrintWin32::is_os_wide()) { + WCHAR szTemp[MAX_PATH]; + + DWORD dw = GetShortPathNameW( unicode_uri, szTemp, MAX_PATH ); + if (dw) { + hmf = GetMetaFileW( szTemp ); + } + } else { + CHAR szTemp[MAX_PATH]; + + DWORD dw = GetShortPathNameA( ansi_uri, szTemp, MAX_PATH ); + if (dw) { + hmf = GetMetaFileA( szTemp ); + } + } + } + + if (hmf) { + DWORD nSize = GetMetaFileBitsEx( hmf, 0, NULL ); + if (nSize) { + BYTE *lpvData = new BYTE[nSize]; + if (lpvData) { + DWORD dw = GetMetaFileBitsEx( hmf, nSize, lpvData ); + if (dw) { + // Fill out a METAFILEPICT structure + mp.mm = MM_ANISOTROPIC; + mp.xExt = 1000; + mp.yExt = 1000; + mp.hMF = NULL; + // Get a reference DC + hDC = GetDC( NULL ); + // Make an enhanced metafile from the windows metafile + hemf = SetWinMetaFileBits( nSize, lpvData, hDC, &mp ); + // Clean up + ReleaseDC( NULL, hDC ); + } + delete[] lpvData; + } + DeleteMetaFile( hmf ); + } + } else { + // Try open as Aldus Placeable Metafile + HANDLE hFile; + if (PrintWin32::is_os_wide()) + hFile = CreateFileW( unicode_uri, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL ); + else + hFile = CreateFileA( ansi_uri, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL ); + if (hFile != INVALID_HANDLE_VALUE) { + DWORD nSize = GetFileSize( hFile, NULL ); + if (nSize) { + BYTE *lpvData = new BYTE[nSize]; + if (lpvData) { + DWORD dw = ReadFile( hFile, lpvData, nSize, &nSize, NULL ); + if (dw) { + if ( ((PAPMHEADER)lpvData)->dwKey == 0x9ac6cdd7l ) { + // Fill out a METAFILEPICT structure + mp.mm = MM_ANISOTROPIC; + mp.xExt = ((PAPMHEADER)lpvData)->bbox.Right - ((PAPMHEADER)lpvData)->bbox.Left; + mp.xExt = ( mp.xExt * 2540l ) / (DWORD)(((PAPMHEADER)lpvData)->wInch); + mp.yExt = ((PAPMHEADER)lpvData)->bbox.Bottom - ((PAPMHEADER)lpvData)->bbox.Top; + mp.yExt = ( mp.yExt * 2540l ) / (DWORD)(((PAPMHEADER)lpvData)->wInch); + mp.hMF = NULL; + // Get a reference DC + hDC = GetDC( NULL ); + // Create an enhanced metafile from the bits + hemf = SetWinMetaFileBits( nSize, lpvData+sizeof(APMHEADER), hDC, &mp ); + // Clean up + ReleaseDC( NULL, hDC ); + } + } + delete[] lpvData; + } + } + CloseHandle( hFile ); + } + } + } + + if (!hemf || !d.outsvg || !d.path) { + if (d.outsvg) + delete d.outsvg; + if (d.path) + delete d.path; + if (local_fn) + g_free(local_fn); + if (unicode_fn) + g_free(unicode_fn); + return NULL; + } + + EnumEnhMetaFile(NULL, hemf, myEnhMetaFileProc, (LPVOID) &d, NULL); + DeleteEnhMetaFile(hemf); + +// std::cout << "SVG Output: " << std::endl << *(d.outsvg) << std::endl; + + SPDocument *doc = sp_document_new_from_mem(d.outsvg->c_str(), d.outsvg->length(), TRUE); + + delete d.outsvg; + delete d.path; + + if (d.emf_obj) { + int i; + for (i=0; i\n" + "" N_("EMF Input") "\n" + "org.inkscape.input.emf.win32\n" + "\n" + ".emf\n" + "image/x-emf\n" + "" N_("Enhanced Metafiles (*.emf)") "\n" + "" N_("Enhanced Metafiles") "\n" + "org.inkscape.output.emf.win32\n" + "\n" + "", new EmfWin32()); + + /* WMF in */ + ext = Inkscape::Extension::build_from_mem( + "\n" + "" N_("WMF Input") "\n" + "org.inkscape.input.wmf.win32\n" + "\n" + ".wmf\n" + "image/x-wmf\n" + "" N_("Windows Metafiles (*.wmf)") "\n" + "" N_("Windows Metafiles") "\n" + "org.inkscape.output.emf.win32\n" + "\n" + "", new EmfWin32()); + + /* EMF out */ + ext = Inkscape::Extension::build_from_mem( + "\n" + "" N_("EMF Output") "\n" + "org.inkscape.output.emf.win32\n" + "\n" + ".emf\n" + "image/x-emf\n" + "" N_("Enhanced Metafile (*.emf)") "\n" + "" N_("Enhanced Metafile") "\n" + "\n" + "", new EmfWin32()); + + return; +} + + +} } } /* namespace Inkscape, Extension, Implementation */ + + +#endif /* WIN32 */ + + +/* + Local Variables: + mode:cpp + c-file-style:"stroustrup" + c-file-offsets:((innamespace . 0)(inline-open . 0)) + indent-tabs-mode:nil + fill-column:99 + End: +*/ +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 : diff --git a/src/extension/internal/emf-win32-inout.h b/src/extension/internal/emf-win32-inout.h new file mode 100644 index 000000000..eff850049 --- /dev/null +++ b/src/extension/internal/emf-win32-inout.h @@ -0,0 +1,60 @@ +/* + * Enhanced Metafile Input/Output. + * + * Authors: + * Ulf Erikson + * + * Copyright (C) 2006 Authors + * + * Released under GNU GPL, read the file 'COPYING' for more information + */ + +#ifndef EXTENSION_INTERNAL_EMF_WIN32_H +#define EXTENSION_INTERNAL_EMF_WIN32_H + +#ifdef WIN32 + +#include "extension/implementation/implementation.h" +#include "style.h" + +namespace Inkscape { +namespace Extension { +namespace Internal { + +class EmfWin32 : Inkscape::Extension::Implementation::Implementation { //This is a derived class + +public: + EmfWin32(); // Empty constructor + + virtual ~EmfWin32();//Destructor + + bool check(Inkscape::Extension::Extension *module); //Can this module load (always yes for now) + + void save(Inkscape::Extension::Output *mod, // Save the given document to the given filename + SPDocument *doc, + gchar const *uri); + + virtual SPDocument *open( Inkscape::Extension::Input *mod, + const gchar *uri ); + + static void init(void);//Initialize the class + +private: +}; + +} } } /* namespace Inkscape, Extension, Implementation */ + +#endif /* WIN32 */ + +#endif /* EXTENSION_INTERNAL_EMF_WIN32_H */ + +/* + 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 : diff --git a/src/extension/internal/emf-win32-print.cpp b/src/extension/internal/emf-win32-print.cpp new file mode 100644 index 000000000..b40eec462 --- /dev/null +++ b/src/extension/internal/emf-win32-print.cpp @@ -0,0 +1,629 @@ +/** \file + * Enhanced Metafile Printing. + */ +/* + * Authors: + * Ulf Erikson + * + * Copyright (C) 2006 Authors + * + * Released under GNU GPL, read the file 'COPYING' for more information + */ +/* + * References: + * - How to Create & Play Enhanced Metafiles in Win32 + * 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 WIN32 + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include +#include +#include + +#include "libnr/n-art-bpath.h" +#include "libnr/nr-point-matrix-ops.h" +#include "libnr/nr-rect.h" +#include "libnr/nr-matrix.h" +#include "libnr/nr-matrix-fns.h" +#include "libnr/nr-path.h" +#include "libnr/nr-pixblock.h" +#include "display/canvas-bpath.h" +#include "sp-item.h" + +#include "glib.h" +#include "gtk/gtkdialog.h" +#include "gtk/gtkbox.h" +#include "gtk/gtkstock.h" + +#include "glibmm/i18n.h" +#include "enums.h" +#include "document.h" +#include "style.h" +#include "sp-paint-server.h" +#include "inkscape_version.h" + +#include "win32.h" +#include "emf-win32-print.h" + +#include "unit-constants.h" + +#include "extension/extension.h" +#include "extension/system.h" +#include "extension/print.h" + +#include "io/sys.h" + +#include "macros.h" + +#define WIN32_LEAN_AND_MEAN +#include + +namespace Inkscape { +namespace Extension { +namespace Internal { + +static float dwDPI = 2540; + + +PrintEmfWin32::PrintEmfWin32 (void): + hdc(NULL), + hbrush(NULL), + hpen(NULL), + fill_path(NULL) +{ +} + + +PrintEmfWin32::~PrintEmfWin32 (void) +{ + if (hdc) { + HENHMETAFILE metafile = CloseEnhMetaFile( hdc ); + if ( metafile ) { + DeleteEnhMetaFile( metafile ); + } + DeleteDC( hdc ); + } + + /* restore default signal handling for SIGPIPE */ +#if !defined(_WIN32) && !defined(__WIN32__) + (void) signal(SIGPIPE, SIG_DFL); +#endif + return; +} + + +unsigned int +PrintEmfWin32::setup (Inkscape::Extension::Print *mod) +{ + return TRUE; +} + + +unsigned int +PrintEmfWin32::begin (Inkscape::Extension::Print *mod, SPDocument *doc) +{ + gchar const *utf8_fn = mod->get_param_string("destination"); + + gsize bytesRead = 0; + gsize bytesWritten = 0; + GError* error = NULL; + gchar *local_fn = + g_filename_from_utf8( utf8_fn, -1, &bytesRead, &bytesWritten, &error ); + + if (local_fn == NULL) { + return 1; + } + + CHAR *ansi_uri = (CHAR *) local_fn; + gunichar2 *unicode_fn = g_utf8_to_utf16( local_fn, -1, NULL, NULL, NULL ); + WCHAR *unicode_uri = (WCHAR *) unicode_fn; + + // width and height in px + _width = sp_document_width(doc); + _height = sp_document_height(doc); + + NRRect d; + bool pageBoundingBox; + pageBoundingBox = mod->get_param_bool("pageBoundingBox"); + if (pageBoundingBox) { + d.x0 = d.y0 = 0; + d.x1 = _width; + d.y1 = _height; + } else { + SPItem* doc_item = SP_ITEM(sp_document_root(doc)); + sp_item_invoke_bbox(doc_item, &d, sp_item_i2r_affine(doc_item), TRUE); + } + + d.x0 *= IN_PER_PX; + d.y0 *= IN_PER_PX; + d.x1 *= IN_PER_PX; + d.y1 *= IN_PER_PX; + + float dwInchesX = (d.x1 - d.x0); + float dwInchesY = (d.y1 - d.y0); + + // dwInchesX x dwInchesY in .01mm units + SetRect( &rc, 0, 0, (int) ceil(dwInchesX*2540), (int) ceil(dwInchesY*2540) ); + + // Get a Reference DC + HDC hScreenDC = GetDC( NULL ); + + // Get the physical characteristics of the reference DC + float PixelsX = (float) GetDeviceCaps( hScreenDC, HORZRES ); + float PixelsY = (float) GetDeviceCaps( hScreenDC, VERTRES ); + float MMX = (float) GetDeviceCaps( hScreenDC, HORZSIZE ); + float MMY = (float) GetDeviceCaps( hScreenDC, VERTSIZE ); + + // Create the Metafile + if (PrintWin32::is_os_wide()) + hdc = CreateEnhMetaFileW( hScreenDC, unicode_uri, &rc, NULL ); + else + hdc = CreateEnhMetaFileA( hScreenDC, ansi_uri, &rc, NULL ); + + // Release the reference DC + ReleaseDC( NULL, hScreenDC ); + + // Did we get a good metafile? + if (hdc == NULL) + { + g_free(local_fn); + g_free(unicode_fn); + return 1; + } + + // Anisotropic mapping mode + SetMapMode( hdc, MM_ANISOTROPIC ); + + // Set the Windows extent + SetWindowExtEx( hdc, (int) (dwInchesX*dwDPI), (int) (dwInchesY*dwDPI), NULL ); + + // Set the viewport extent to reflect + // dwInchesX" x dwInchesY" in device units + SetViewportExtEx( hdc, + (int) ((float) dwInchesX*25.4f*PixelsX/MMX), + (int) ((float) dwInchesY*25.4f*PixelsY/MMY), + NULL ); + + SetRect( &rc, 0, 0, (int) ceil(dwInchesX*dwDPI), (int) ceil(dwInchesY*dwDPI) ); + + g_free(local_fn); + g_free(unicode_fn); + + return 0; +} + + +unsigned int +PrintEmfWin32::finish (Inkscape::Extension::Print *mod) +{ + if (!hdc) return 0; + + flush_fill(); // flush any pending fills + + HENHMETAFILE metafile = CloseEnhMetaFile( hdc ); + if ( metafile ) { + DeleteEnhMetaFile( metafile ); + } + DeleteDC( hdc ); + + hdc = NULL; + + return 0; +} + + +unsigned int +PrintEmfWin32::comment (Inkscape::Extension::Print * module, + const char *comment) +{ + if (!hdc) return 0; + + flush_fill(); // flush any pending fills + + return 0; +} + + +void +PrintEmfWin32::create_brush(SPStyle const *style) +{ + float rgb[3]; + + if (style) { + sp_color_get_rgb_floatv( &style->fill.value.color, rgb ); + hbrush = CreateSolidBrush( RGB(255*rgb[0], 255*rgb[1], 255*rgb[2]) ); + hbrushOld = (HBRUSH) SelectObject( hdc, hbrush ); + + SetPolyFillMode( hdc, + style->fill_rule.computed == 0 ? WINDING : + style->fill_rule.computed == 2 ? ALTERNATE : ALTERNATE ); + } else { // if (!style) + hbrush = CreateSolidBrush( RGB(255, 255, 255) ); + hbrushOld = (HBRUSH) SelectObject( hdc, hbrush ); + SetPolyFillMode( hdc, ALTERNATE ); + } +} + + +void +PrintEmfWin32::destroy_brush() +{ + SelectObject( hdc, hbrushOld ); + if (hbrush) + DeleteObject( hbrush ); + hbrush = NULL; +} + + +void +PrintEmfWin32::create_pen(SPStyle const *style) +{ + if (style) { + float rgb[3]; + + sp_color_get_rgb_floatv(&style->stroke.value.color, rgb); + + LOGBRUSH lb = {0}; + lb.lbStyle = BS_SOLID; + lb.lbColor = RGB( 255*rgb[0], 255*rgb[1], 255*rgb[2] ); + + int linestyle = PS_SOLID; + int linecap = 0; + int linejoin = 0; + DWORD n_dash = 0; + DWORD *dash = NULL; + float oldmiterlimit; + + DWORD linewidth = MAX( 1, (DWORD) (style->stroke_width.computed * IN_PER_PX * dwDPI) ); + + if (style->stroke_linecap.computed == 0) { + linecap = PS_ENDCAP_FLAT; + } + else if (style->stroke_linecap.computed == 1) { + linecap = PS_ENDCAP_ROUND; + } + else if (style->stroke_linecap.computed == 2) { + linecap = PS_ENDCAP_SQUARE; + } + + if (style->stroke_linejoin.computed == 0) { + linejoin = PS_JOIN_MITER; + } + else if (style->stroke_linejoin.computed == 1) { + linejoin = PS_JOIN_ROUND; + } + else if (style->stroke_linejoin.computed == 2) { + linejoin = PS_JOIN_BEVEL; + } + + if (style->stroke_dash.n_dash && + style->stroke_dash.dash ) + { + int i = 0; + while (linestyle != PS_USERSTYLE && + (i < style->stroke_dash.n_dash)) { + if (style->stroke_dash.dash[i] > 0.00000001) + linestyle = PS_USERSTYLE; + i++; + } + + if (linestyle == PS_USERSTYLE) { + n_dash = style->stroke_dash.n_dash; + dash = new DWORD[n_dash]; + for (i = 0; i < style->stroke_dash.n_dash; i++) { + dash[i] = (DWORD) (style->stroke_dash.dash[i] * IN_PER_PX * dwDPI); + } + } + } + + hpen = ExtCreatePen( + PS_GEOMETRIC | linestyle | linecap | linejoin, + linewidth, + &lb, + n_dash, + dash ); + + if ( !hpen && linestyle == PS_USERSTYLE ) { + hpen = ExtCreatePen( + PS_GEOMETRIC | PS_SOLID | linecap | linejoin, + linewidth, + &lb, + 0, + NULL ); + } + + if ( !hpen ) { + hpen = CreatePen( + PS_SOLID, + linewidth, + lb.lbColor ); + } + + hpenOld = (HPEN) SelectObject( hdc, hpen ); + + if (linejoin == PS_JOIN_MITER) { + float miterlimit = style->stroke_miterlimit.value; + if (miterlimit < 1) + miterlimit = 4.0; + SetMiterLimit( + hdc, + miterlimit * IN_PER_PX * dwDPI, + &oldmiterlimit ); + } + + if (n_dash) { + delete[] dash; + } + } + else { // if (!style) + hpen = CreatePen( PS_SOLID, 1, RGB(0, 0, 0) ); + hpenOld = (HPEN) SelectObject( hdc, hpen ); + } +} + + +void +PrintEmfWin32::destroy_pen() +{ + SelectObject( hdc, hpenOld ); + if (hpen) + DeleteObject( hpen ); + hpen = NULL; +} + + +void +PrintEmfWin32::flush_fill() +{ + if (fill_path) { + print_bpath(fill_path, &fill_transform, &fill_pbox); + FillPath( hdc ); + destroy_brush(); + delete[] fill_path; + fill_path = NULL; + } +} + + +NArtBpath * +PrintEmfWin32::copy_bpath(const NArtBpath *bp) +{ + NArtBpath *tmp = (NArtBpath *) bp; + int num = 1; + + while (tmp->code != NR_END) { + num++; + tmp += 1; + } + + tmp = new NArtBpath[num]; + while (num--) { + tmp[num] = bp[num]; + } + + return tmp; +} + + +int +PrintEmfWin32::cmp_bpath(const NArtBpath *bp1, const NArtBpath *bp2) +{ + if (!bp1 || !bp2) { + return 1; + } + + while (bp1->code != NR_END && bp2->code != NR_END) { + if (bp1->code != bp2->code) { + return 1; + } + + if ( fabs(bp1->x1 - bp2->x1) > 0.00000001 || + fabs(bp1->y1 - bp2->y1) > 0.00000001 || + fabs(bp1->x2 - bp2->x2) > 0.00000001 || + fabs(bp1->y2 - bp2->y2) > 0.00000001 || + fabs(bp1->x3 - bp2->x3) > 0.00000001 || + fabs(bp1->y3 - bp2->y3) > 0.00000001 ) + { + return 1; + } + + bp1 += 1; + bp2 += 1; + } + + return bp1->code != NR_END || bp2->code != NR_END; +} + + +unsigned int +PrintEmfWin32::fill(Inkscape::Extension::Print *mod, + NRBPath const *bpath, NRMatrix const *transform, SPStyle const *style, + NRRect const *pbox, NRRect const *dbox, NRRect const *bbox) +{ + if (!hdc) return 0; + + flush_fill(); // flush any pending fills + + if (style->fill.type == SP_PAINT_TYPE_COLOR) { + create_brush(style); + } else { + // create_brush(NULL); + return 0; + } + + fill_path = copy_bpath( bpath->path ); + fill_transform = *transform; + fill_pbox = *pbox; + + // postpone fill in case of stroke-and-fill + + return 0; +} + + +unsigned int +PrintEmfWin32::stroke (Inkscape::Extension::Print *mod, + const NRBPath *bpath, const NRMatrix *transform, const SPStyle *style, + const NRRect *pbox, const NRRect *dbox, const NRRect *bbox) +{ + if (!hdc) return 0; + + bool stroke_and_fill = ( cmp_bpath( bpath->path, fill_path ) == 0 ); + + if (!stroke_and_fill) { + flush_fill(); // flush any pending fills + } + + if (style->stroke.type == SP_PAINT_TYPE_COLOR) { + create_pen(style); + } else { + // create_pen(NULL); + return 0; + } + + print_bpath(bpath->path, transform, pbox); + + if (stroke_and_fill) { + StrokeAndFillPath( hdc ); + destroy_brush(); + delete[] fill_path; + fill_path = NULL; + } else { + StrokePath( hdc ); + } + + destroy_pen(); + + return 0; +} + + +unsigned int +PrintEmfWin32::print_bpath(const NArtBpath *bp, const NRMatrix *transform, NRRect const *pbox) +{ + unsigned int closed; + NR::Matrix tf = *transform; + + BeginPath( hdc ); + closed = FALSE; + while (bp->code != NR_END) { + using NR::X; + using NR::Y; + + NR::Point p1(bp->c(1) * tf); + NR::Point p2(bp->c(2) * tf); + NR::Point p3(bp->c(3) * tf); + + p1[X] = (p1[X] * IN_PER_PX * dwDPI); + p2[X] = (p2[X] * IN_PER_PX * dwDPI); + p3[X] = (p3[X] * IN_PER_PX * dwDPI); + p1[Y] = (p1[Y] * IN_PER_PX * dwDPI); + p2[Y] = (p2[Y] * IN_PER_PX * dwDPI); + p3[Y] = (p3[Y] * IN_PER_PX * dwDPI); + + LONG const x1 = (LONG) round(p1[X]); + LONG const y1 = (LONG) round(rc.bottom-p1[Y]); + LONG const x2 = (LONG) round(p2[X]); + LONG const y2 = (LONG) round(rc.bottom-p2[Y]); + LONG const x3 = (LONG) round(p3[X]); + LONG const y3 = (LONG) round(rc.bottom-p3[Y]); + + switch (bp->code) { + case NR_MOVETO: + if (closed) { + CloseFigure( hdc ); + } + closed = TRUE; + MoveToEx( hdc, x3, y3, NULL ); + break; + case NR_MOVETO_OPEN: + if (closed) { + CloseFigure( hdc ); + } + closed = FALSE; + MoveToEx( hdc, x3, y3, NULL ); + break; + case NR_LINETO: + LineTo( hdc, x3, y3 ); + break; + case NR_CURVETO: + { + POINT pt[3]; + pt[0].x = x1; + pt[0].y = y1; + pt[1].x = x2; + pt[1].y = y2; + pt[2].x = x3; + pt[2].y = y3; + + PolyBezierTo( hdc, pt, 3 ); + break; + } + default: + break; + } + bp += 1; + } + if (closed) { + CloseFigure( hdc ); + } + EndPath( hdc ); + + return closed; +} + + +bool +PrintEmfWin32::textToPath(Inkscape::Extension::Print * ext) +{ + return ext->get_param_bool("textToPath"); +} + + +void +PrintEmfWin32::init (void) +{ + Inkscape::Extension::Extension * ext; + + /* EMF print */ + ext = Inkscape::Extension::build_from_mem( + "\n" + "Enhanced Metafile Print\n" + "org.inkscape.print.emf.win32\n" + "\n" + "TRUE\n" + "TRUE\n" + "\n" + "", new PrintEmfWin32()); + + return; +} + + +} /* namespace Internal */ +} /* namespace Extension */ +} /* namespace Inkscape */ + +#endif /* WIN32 */ + +/* + 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:encoding=utf-8:textwidth=99 : diff --git a/src/extension/internal/emf-win32-print.h b/src/extension/internal/emf-win32-print.h new file mode 100644 index 000000000..d1ac81939 --- /dev/null +++ b/src/extension/internal/emf-win32-print.h @@ -0,0 +1,107 @@ +#ifndef __INKSCAPE_EXTENSION_INTERNAL_PRINT_EMF_WIN32_H__ +#define __INKSCAPE_EXTENSION_INTERNAL_PRINT_EMF_WIN32_H__ + +/* + * Enhanced Metafile Printing. + * + * Author: + * Ulf Erikson + * + * Copyright (C) 2006 Authors + * + * Released under GNU GPL, read the file 'COPYING' for more information + */ + +#ifdef WIN32 + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "extension/implementation/implementation.h" +#include "extension/extension.h" + +#include "svg/stringstream.h" +#include "libnr/nr-matrix.h" +#include "libnr/nr-rect.h" + +#define WIN32_LEAN_AND_MEAN +#include + +namespace Inkscape { +namespace Extension { +namespace Internal { + +class PrintEmfWin32 : public Inkscape::Extension::Implementation::Implementation +{ + double _width; + double _height; + HDC hdc; + RECT rc; + + HBRUSH hbrush, hbrushOld; + HPEN hpen, hpenOld; + + NArtBpath *fill_path; + NArtBpath *fill_path_copy; + NRMatrix fill_transform; + NRRect fill_pbox; + + unsigned int print_bpath (const NArtBpath *bp, const NRMatrix *transform, NRRect const *pbox); + +public: + PrintEmfWin32 (void); + virtual ~PrintEmfWin32 (void); + + /* Print functions */ + virtual unsigned int setup (Inkscape::Extension::Print * module); + + virtual unsigned int begin (Inkscape::Extension::Print * module, SPDocument *doc); + virtual unsigned int finish (Inkscape::Extension::Print * module); + + /* Rendering methods */ + virtual unsigned int fill (Inkscape::Extension::Print * module, + const NRBPath *bpath, const NRMatrix *ctm, const SPStyle *style, + const NRRect *pbox, const NRRect *dbox, const NRRect *bbox); + virtual unsigned int stroke (Inkscape::Extension::Print * module, + const NRBPath *bpath, const NRMatrix *transform, const SPStyle *style, + const NRRect *pbox, const NRRect *dbox, const NRRect *bbox); + virtual unsigned int comment(Inkscape::Extension::Print *module, const char * comment); + bool textToPath (Inkscape::Extension::Print * ext); + + static void init (void); + +protected: + void create_brush(SPStyle const *style); + + void destroy_brush(); + + void create_pen(SPStyle const *style); + + void destroy_pen(); + + void flush_fill(); + + NArtBpath *copy_bpath(const NArtBpath *bp); + int cmp_bpath(const NArtBpath *bp1, const NArtBpath *bp2); + +}; + +} /* namespace Internal */ +} /* namespace Extension */ +} /* namespace Inkscape */ + +#endif /* WIN32 */ + +#endif /* __INKSCAPE_EXTENSION_INTERNAL_PRINT_EMF_WIN32_H__ */ + +/* + Local Variables: + mode:cpp + c-file-style:"stroustrup" + c-file-offsets:((innamespace . 0)(inline-open . 0)) + indent-tabs-mode:nil + fill-column:99 + End: +*/ +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :