src/extension/internal/emf-win32-print.cpp

   1 /** \file
   2  * Enhanced Metafile Printing.
   3  */
   4 /*
   5  * Authors:
   6  *   Ulf Erikson <ulferikson@users.sf.net>
   7  *
   8  * Copyright (C) 2006-2008 Authors
   9  *
  10  * Released under GNU GPL, read the file 'COPYING' for more information
  11  */
  12 /*
  13  * References:
  14  *  - How to Create & Play Enhanced Metafiles in Win32
  15  *      http://support.microsoft.com/kb/q145999/
  16  *  - INFO: Windows Metafile Functions & Aldus Placeable Metafiles
  17  *      http://support.microsoft.com/kb/q66949/
  18  *  - Metafile Functions
  19  *      http://msdn.microsoft.com/library/en-us/gdi/metafile_0whf.asp
  20  *  - Metafile Structures
  21  *      http://msdn.microsoft.com/library/en-us/gdi/metafile_5hkj.asp
  22  */
  23
  24 #ifdef WIN32
  25
  26 #ifdef HAVE_CONFIG_H
  27 # include "config.h"
  28 #endif
  29
  30 #include <string.h>
  31 #include <signal.h>
  32 #include <errno.h>
  33
  34 #include "libnr/n-art-bpath.h"
  35 #include "libnr/nr-point-matrix-ops.h"
  36 #include "libnr/nr-rect.h"
  37 #include "libnr/nr-matrix.h"
  38 #include "libnr/nr-matrix-ops.h"
  39 #include "libnr/nr-matrix-scale-ops.h"
  40 #include "libnr/nr-matrix-translate-ops.h"
  41 #include "libnr/nr-scale-translate-ops.h"
  42 #include "libnr/nr-translate-scale-ops.h"
  43 #include "libnr/nr-matrix-fns.h"
  44 #include "libnr/nr-path.h"
  45 #include "libnr/nr-pixblock.h"
  46 #include "display/canvas-bpath.h"
  47 #include "sp-item.h"
  48
  49 #include "glib.h"
  50 #include "gtk/gtkdialog.h"
  51 #include "gtk/gtkbox.h"
  52 #include "gtk/gtkstock.h"
  53
  54 #include "glibmm/i18n.h"
  55 #include "enums.h"
  56 #include "document.h"
  57 #include "style.h"
  58 #include "sp-paint-server.h"
  59 #include "inkscape_version.h"
  60
  61 #include "libnrtype/FontFactory.h"
  62 #include "libnrtype/font-instance.h"
  63 #include "libnrtype/font-style-to-pos.h"
  64
  65 #include "win32.h"
  66 #include "emf-win32-print.h"
  67
  68 #include "unit-constants.h"
  69
  70 #include "extension/extension.h"
  71 #include "extension/system.h"
  72 #include "extension/print.h"
  73
  74 #include "io/sys.h"
  75
  76 #include "macros.h"
  77
  78 #define WIN32_LEAN_AND_MEAN
  79 #include <windows.h>
  80
  81 namespace Inkscape {
  82 namespace Extension {
  83 namespace Internal {
  84
  85 static float dwDPI = 2540;
  86
  87
  88 PrintEmfWin32::PrintEmfWin32 (void):
  89     hdc(NULL),
  90     hbrush(NULL),
  91     hbrushOld(NULL),
  92     hpen(NULL),
  93     fill_path(NULL),
  94     stroke_and_fill(false),
  95     fill_only(false),
  96     simple_shape(false)
  97 {
  98 }
  99
 100
 101 PrintEmfWin32::~PrintEmfWin32 (void)
 102 {
 103     if (hdc) {
 104         HENHMETAFILE metafile = CloseEnhMetaFile( hdc );
 105         if ( metafile ) {
 106             DeleteEnhMetaFile( metafile );
 107         }
 108         DeleteDC( hdc );
 109     }
 110
 111     /* restore default signal handling for SIGPIPE */
 112 #if !defined(_WIN32) && !defined(__WIN32__)
 113     (void) signal(SIGPIPE, SIG_DFL);
 114 #endif
 115         return;
 116 }
 117
 118
 119 unsigned int
 120 PrintEmfWin32::setup (Inkscape::Extension::Print *mod)
 121 {
 122     return TRUE;
 123 }
 124
 125
 126 unsigned int
 127 PrintEmfWin32::begin (Inkscape::Extension::Print *mod, SPDocument *doc)
 128 {
 129     gchar const *utf8_fn = mod->get_param_string("destination");
 130
 131     gsize bytesRead = 0;
 132     gsize bytesWritten = 0;
 133     GError* error = NULL;
 134     gchar *local_fn =
 135         g_filename_from_utf8( utf8_fn, -1,  &bytesRead,  &bytesWritten, &error );
 136
 137     if (local_fn == NULL) {
 138         return 1;
 139     }
 140
 141     CHAR *ansi_uri = (CHAR *) local_fn;
 142     gunichar2 *unicode_fn = g_utf8_to_utf16( local_fn, -1, NULL, NULL, NULL );
 143     WCHAR *unicode_uri = (WCHAR *) unicode_fn;
 144
 145     // width and height in px
 146     _width = sp_document_width(doc);
 147     _height = sp_document_height(doc);
 148
 149     NRRect d;
 150     bool pageBoundingBox;
 151     pageBoundingBox = mod->get_param_bool("pageBoundingBox");
 152     if (pageBoundingBox) {
 153         d.x0 = d.y0 = 0;
 154         d.x1 = _width;
 155         d.y1 = _height;
 156     } else {
 157         SPItem* doc_item = SP_ITEM(sp_document_root(doc));
 158         sp_item_invoke_bbox(doc_item, &d, from_2geom(sp_item_i2r_affine(doc_item)), TRUE);
 159     }
 160
 161     d.x0 *= IN_PER_PX;
 162     d.y0 *= IN_PER_PX;
 163     d.x1 *= IN_PER_PX;
 164     d.y1 *= IN_PER_PX;
 165
 166     float dwInchesX = (d.x1 - d.x0);
 167     float dwInchesY = (d.y1 - d.y0);
 168
 169     // dwInchesX x dwInchesY in .01mm units
 170     SetRect( &rc, 0, 0, (int) ceil(dwInchesX*2540), (int) ceil(dwInchesY*2540) );
 171
 172     // Get a Reference DC
 173     HDC hScreenDC = GetDC( NULL );
 174
 175     // Create the Metafile
 176     if (PrintWin32::is_os_wide())
 177         hdc = CreateEnhMetaFileW( hScreenDC, unicode_uri, &rc, NULL );
 178     else
 179         hdc = CreateEnhMetaFileA( hScreenDC, ansi_uri, &rc, NULL );
 180
 181     // Release the reference DC
 182     ReleaseDC( NULL, hScreenDC );
 183
 184     // Did we get a good metafile?
 185     if (hdc == NULL)
 186     {
 187         g_free(local_fn);
 188         g_free(unicode_fn);
 189         return 1;
 190     }
 191
 192     // Anisotropic mapping mode
 193     SetMapMode( hdc, MM_ANISOTROPIC );
 194
 195     // Set the Windows extent
 196     SetWindowExtEx( hdc, (int) (dwInchesX*dwDPI), (int) (dwInchesY*dwDPI), NULL );
 197
 198     // Set the viewport extent to reflect
 199     // dwInchesX" x dwInchesY" in device units
 200     SetViewportExtEx( hdc,
 201                       (int) ((float) dwInchesX*25.4f*PX_PER_MM),
 202                       (int) ((float) dwInchesY*25.4f*PX_PER_MM),
 203                       NULL );
 204
 205     SetRect( &rc, 0, 0, (int) ceil(dwInchesX*dwDPI), (int) ceil(dwInchesY*dwDPI) );
 206
 207     g_free(local_fn);
 208     g_free(unicode_fn);
 209
 210     m_tr_stack.push( NR::scale(1, -1) * NR::translate(0, sp_document_height(doc)));
 211     return 0;
 212 }
 213
 214
 215 unsigned int
 216 PrintEmfWin32::finish (Inkscape::Extension::Print *mod)
 217 {
 218     if (!hdc) return 0;
 219
 220     flush_fill(); // flush any pending fills
 221
 222     HENHMETAFILE metafile = CloseEnhMetaFile( hdc );
 223     if ( metafile ) {
 224         DeleteEnhMetaFile( metafile );
 225     }
 226     DeleteDC( hdc );
 227
 228     hdc = NULL;
 229
 230     return 0;
 231 }
 232
 233
 234 unsigned int
 235 PrintEmfWin32::comment (Inkscape::Extension::Print * module,
 236                                 const char *comment)
 237 {
 238     if (!hdc) return 0;
 239
 240     flush_fill(); // flush any pending fills
 241
 242     return 0;
 243 }
 244
 245
 246 int
 247 PrintEmfWin32::create_brush(SPStyle const *style)
 248 {
 249     float rgb[3];
 250
 251     if (style) {
 252         float opacity = SP_SCALE24_TO_FLOAT(style->fill_opacity.value);
 253         if (opacity <= 0.0)
 254             return 1;
 255
 256         sp_color_get_rgb_floatv( &style->fill.value.color, rgb );
 257         hbrush = CreateSolidBrush( RGB(255*rgb[0], 255*rgb[1], 255*rgb[2]) );
 258         hbrushOld = (HBRUSH) SelectObject( hdc, hbrush );
 259
 260         SetPolyFillMode( hdc,
 261                          style->fill_rule.computed == 0 ? WINDING :
 262                          style->fill_rule.computed == 2 ? ALTERNATE : ALTERNATE );
 263     } else { // if (!style)
 264         hbrush = CreateSolidBrush( RGB(255, 255, 255) );
 265         hbrushOld = (HBRUSH) SelectObject( hdc, hbrush );
 266         SetPolyFillMode( hdc, ALTERNATE );
 267     }
 268
 269     return 0;
 270 }
 271
 272
 273 void
 274 PrintEmfWin32::destroy_brush()
 275 {
 276     SelectObject( hdc, hbrushOld );
 277     if (hbrush)
 278         DeleteObject( hbrush );
 279     hbrush = NULL;
 280     hbrushOld = NULL;
 281 }
 282
 283
 284 void
 285 PrintEmfWin32::create_pen(SPStyle const *style, const NR::Matrix *transform)
 286 {
 287     if (style) {
 288         float rgb[3];
 289
 290         sp_color_get_rgb_floatv(&style->stroke.value.color, rgb);
 291
 292         LOGBRUSH lb = {0};
 293         lb.lbStyle = BS_SOLID;
 294         lb.lbColor = RGB( 255*rgb[0], 255*rgb[1], 255*rgb[2] );
 295
 296         int linestyle = PS_SOLID;
 297         int linecap = 0;
 298         int linejoin = 0;
 299         DWORD n_dash = 0;
 300         DWORD *dash = NULL;
 301         float oldmiterlimit;
 302
 303         using NR::X;
 304         using NR::Y;
 305
 306         NR::Matrix tf = *transform;
 307
 308         NR::Point zero(0, 0);
 309         NR::Point one(1, 1);
 310         NR::Point p0(zero * tf);
 311         NR::Point p1(one * tf);
 312         NR::Point p(p1 - p0);
 313
 314         double scale = sqrt( (p[X]*p[X]) + (p[Y]*p[Y]) ) / sqrt(2);
 315
 316         DWORD linewidth = MAX( 1, (DWORD) (scale * style->stroke_width.computed * IN_PER_PX * dwDPI) );
 317
 318         if (style->stroke_linecap.computed == 0) {
 319             linecap = PS_ENDCAP_FLAT;
 320         }
 321         else if (style->stroke_linecap.computed == 1) {
 322             linecap = PS_ENDCAP_ROUND;
 323         }
 324         else if (style->stroke_linecap.computed == 2) {
 325             linecap = PS_ENDCAP_SQUARE;
 326         }
 327
 328         if (style->stroke_linejoin.computed == 0) {
 329             linejoin = PS_JOIN_MITER;
 330         }
 331         else if (style->stroke_linejoin.computed == 1) {
 332             linejoin = PS_JOIN_ROUND;
 333         }
 334         else if (style->stroke_linejoin.computed == 2) {
 335             linejoin = PS_JOIN_BEVEL;
 336         }
 337
 338         if (style->stroke_dash.n_dash   &&
 339             style->stroke_dash.dash       )
 340         {
 341             int i = 0;
 342             while (linestyle != PS_USERSTYLE &&
 343                    (i < style->stroke_dash.n_dash)) {
 344                 if (style->stroke_dash.dash[i] > 0.00000001)
 345                     linestyle = PS_USERSTYLE;
 346                 i++;
 347             }
 348
 349             if (linestyle == PS_USERSTYLE) {
 350                 n_dash = style->stroke_dash.n_dash;
 351                 dash = new DWORD[n_dash];
 352                 for (i = 0; i < style->stroke_dash.n_dash; i++) {
 353                     dash[i] = (DWORD) (style->stroke_dash.dash[i] * IN_PER_PX * dwDPI);
 354                 }
 355             }
 356         }
 357
 358         hpen = ExtCreatePen(
 359             PS_GEOMETRIC | linestyle | linecap | linejoin,
 360             linewidth,
 361             &lb,
 362             n_dash,
 363             dash );
 364
 365         if ( !hpen && linestyle == PS_USERSTYLE ) {
 366             hpen = ExtCreatePen(
 367                 PS_GEOMETRIC | PS_SOLID | linecap | linejoin,
 368                 linewidth,
 369                 &lb,
 370                 0,
 371                 NULL );
 372         }
 373
 374         if ( !hpen ) {
 375             hpen = CreatePen(
 376                 PS_SOLID,
 377                 linewidth,
 378                 lb.lbColor );
 379         }
 380
 381         hpenOld = (HPEN) SelectObject( hdc, hpen );
 382
 383         if (linejoin == PS_JOIN_MITER) {
 384             float miterlimit = style->stroke_miterlimit.value;
 385             if (miterlimit < 1)
 386                 miterlimit = 4.0;
 387             SetMiterLimit(
 388                 hdc,
 389                 miterlimit * IN_PER_PX * dwDPI,
 390                 &oldmiterlimit );
 391         }
 392
 393         if (n_dash) {
 394             delete[] dash;
 395         }
 396     }
 397     else { // if (!style)
 398         hpen = CreatePen( PS_SOLID, 1, RGB(0, 0, 0) );
 399         hpenOld = (HPEN) SelectObject( hdc, hpen );
 400     }
 401 }
 402
 403
 404 void
 405 PrintEmfWin32::destroy_pen()
 406 {
 407     SelectObject( hdc, hpenOld );
 408     if (hpen)
 409         DeleteObject( hpen );
 410     hpen = NULL;
 411 }
 412
 413
 414 void
 415 PrintEmfWin32::flush_fill()
 416 {
 417     if (fill_path) {
 418         stroke_and_fill = false;
 419         fill_only = true;
 420         print_bpath(fill_path, &fill_transform, &fill_pbox);
 421         fill_only = false;
 422         if (!simple_shape)
 423             FillPath( hdc );
 424         destroy_brush();
 425         delete[] fill_path;
 426         fill_path = NULL;
 427     }
 428 }
 429
 430
 431 NArtBpath *
 432 PrintEmfWin32::copy_bpath(const NArtBpath *bp)
 433 {
 434     NArtBpath *tmp = (NArtBpath *) bp;
 435     int num = 1;
 436
 437     while (tmp->code != NR_END) {
 438         num++;
 439         tmp += 1;
 440     }
 441
 442     tmp = new NArtBpath[num];
 443     while (num--) {
 444         tmp[num] = bp[num];
 445     }
 446
 447     return tmp;
 448 }
 449
 450
 451 int
 452 PrintEmfWin32::cmp_bpath(const NArtBpath *bp1, const NArtBpath *bp2)
 453 {
 454     if (!bp1 || !bp2) {
 455         return 1;
 456     }
 457
 458     while (bp1->code != NR_END && bp2->code != NR_END) {
 459         if (bp1->code != bp2->code) {
 460             return 1;
 461         }
 462
 463         if ( fabs(bp1->x1 - bp2->x1) > 0.00000001 ||
 464              fabs(bp1->y1 - bp2->y1) > 0.00000001 ||
 465              fabs(bp1->x2 - bp2->x2) > 0.00000001 ||
 466              fabs(bp1->y2 - bp2->y2) > 0.00000001 ||
 467              fabs(bp1->x3 - bp2->x3) > 0.00000001 ||
 468              fabs(bp1->y3 - bp2->y3) > 0.00000001 )
 469         {
 470             return 1;
 471         }
 472
 473         bp1 += 1;
 474         bp2 += 1;
 475     }
 476
 477     return bp1->code != NR_END || bp2->code != NR_END;
 478 }
 479
 480 unsigned int
 481 PrintEmfWin32::bind(Inkscape::Extension::Print *mod, NR::Matrix const *transform, float opacity)
 482 {
 483     NR::Matrix tr = *transform;
 484
 485     if (m_tr_stack.size()) {
 486         NR::Matrix tr_top = m_tr_stack.top();
 487         m_tr_stack.push(tr * tr_top);
 488     } else {
 489         m_tr_stack.push(tr);
 490     }
 491
 492     return 1;
 493 }
 494
 495 unsigned int
 496 PrintEmfWin32::release(Inkscape::Extension::Print *mod)
 497 {
 498     m_tr_stack.pop();
 499     return 1;
 500 }
 501
 502 unsigned int
 503 PrintEmfWin32::fill(Inkscape::Extension::Print *mod,
 504                const_NRBPath const *bpath, NR::Matrix const *transform, SPStyle const *style,
 505                NRRect const *pbox, NRRect const *dbox, NRRect const *bbox)
 506 {
 507     if (!hdc) return 0;
 508
 509     NR::Matrix tf = m_tr_stack.top();
 510
 511     flush_fill(); // flush any pending fills
 512
 513     if (style->fill.isColor()) {
 514         if (create_brush(style))
 515             return 0;
 516     } else {
 517         // create_brush(NULL);
 518         return 0;
 519     }
 520
 521     fill_path = copy_bpath( bpath->path );
 522     fill_transform = tf;
 523     fill_pbox = *pbox;
 524
 525     // postpone fill in case of stroke-and-fill
 526
 527     return 0;
 528 }
 529
 530
 531 unsigned int
 532 PrintEmfWin32::stroke (Inkscape::Extension::Print *mod,
 533                   const const_NRBPath *bpath, const NR::Matrix *transform, const SPStyle *style,
 534                   const NRRect *pbox, const NRRect *dbox, const NRRect *bbox)
 535 {
 536     if (!hdc) return 0;
 537
 538     NR::Matrix tf = m_tr_stack.top();
 539
 540     stroke_and_fill = ( cmp_bpath( bpath->path, fill_path ) == 0 );
 541
 542     if (!stroke_and_fill) {
 543         flush_fill(); // flush any pending fills
 544     }
 545
 546     if (style->stroke.isColor()) {
 547         create_pen(style, &tf);
 548     } else {
 549         // create_pen(NULL, &tf);
 550         return 0;
 551     }
 552
 553     print_bpath(bpath->path, &tf, pbox);
 554
 555     if (stroke_and_fill) {
 556         if (!simple_shape)
 557             StrokeAndFillPath( hdc );
 558         destroy_brush();
 559         delete[] fill_path;
 560         fill_path = NULL;
 561     } else {
 562         if (!simple_shape)
 563             StrokePath( hdc );
 564     }
 565
 566     destroy_pen();
 567
 568     return 0;
 569 }
 570
 571
 572 bool
 573 PrintEmfWin32::print_simple_shape(const NArtBpath *bpath, const NR::Matrix *transform, NRRect const *pbox)
 574 {
 575     NR::Matrix tf = *transform;
 576     const NArtBpath *bp = bpath;
 577
 578     int nodes = 0;
 579     int moves = 0;
 580     int lines = 0;
 581     int curves = 0;
 582
 583     while (bp->code != NR_END) {
 584         nodes++;
 585         switch (bp->code) {
 586             case NR_MOVETO:
 587             case NR_MOVETO_OPEN:
 588                 moves++;
 589                 break;
 590             case NR_LINETO:
 591                 lines++;
 592                 break;
 593             case NR_CURVETO:
 594                 curves++;
 595                 break;
 596         }
 597         bp += 1;
 598     }
 599
 600     if (!nodes)
 601         return false;
 602
 603     POINT *lpPoints = new POINT[moves + lines + curves*3];
 604     int i = 0;
 605     bp = bpath;
 606     while (bp->code != NR_END)
 607     {
 608         using NR::X;
 609         using NR::Y;
 610
 611         NR::Point p1(bp->c(1) * tf);
 612         NR::Point p2(bp->c(2) * tf);
 613         NR::Point p3(bp->c(3) * tf);
 614
 615         p1[X] = (p1[X] * IN_PER_PX * dwDPI);
 616         p2[X] = (p2[X] * IN_PER_PX * dwDPI);
 617         p3[X] = (p3[X] * IN_PER_PX * dwDPI);
 618         p1[Y] = (p1[Y] * IN_PER_PX * dwDPI);
 619         p2[Y] = (p2[Y] * IN_PER_PX * dwDPI);
 620         p3[Y] = (p3[Y] * IN_PER_PX * dwDPI);
 621
 622         LONG const x1 = (LONG) round(p1[X]);
 623         LONG const y1 = (LONG) round(rc.bottom-p1[Y]);
 624         LONG const x2 = (LONG) round(p2[X]);
 625         LONG const y2 = (LONG) round(rc.bottom-p2[Y]);
 626         LONG const x3 = (LONG) round(p3[X]);
 627         LONG const y3 = (LONG) round(rc.bottom-p3[Y]);
 628
 629         switch (bp->code) {
 630             case NR_MOVETO:
 631             case NR_MOVETO_OPEN:
 632             case NR_LINETO:
 633                 lpPoints[i].x = x3;
 634                 lpPoints[i].y = y3;
 635                 i = i + 1;
 636                 break;
 637             case NR_CURVETO:
 638                 lpPoints[i].x = x1;
 639                 lpPoints[i].y = y1;
 640                 lpPoints[i+1].x = x2;
 641                 lpPoints[i+1].y = y2;
 642                 lpPoints[i+2].x = x3;
 643                 lpPoints[i+2].y = y3;
 644                 i = i + 3;
 645                 break;
 646         }
 647
 648         bp += 1;
 649     }
 650
 651     bool done = false;
 652     bool circular = (lpPoints[0].x == lpPoints[i-1].x) && (lpPoints[0].y == lpPoints[i-1].y);
 653     bool polygon = false;
 654     bool ellipse = false;
 655
 656     if (moves == 1 && moves+lines == nodes && circular) {
 657         polygon = true;
 658     }
 659     else if (moves == 1 && nodes == 5 && moves+curves == nodes && circular) {
 660         if (lpPoints[0].x == lpPoints[1].x && lpPoints[1].x == lpPoints[11].x &&
 661             lpPoints[5].x == lpPoints[6].x && lpPoints[6].x == lpPoints[7].x &&
 662             lpPoints[2].x == lpPoints[10].x && lpPoints[3].x == lpPoints[9].x && lpPoints[4].x == lpPoints[8].x &&
 663             lpPoints[2].y == lpPoints[3].y && lpPoints[3].y == lpPoints[4].y &&
 664             lpPoints[8].y == lpPoints[9].y && lpPoints[9].y == lpPoints[10].y &&
 665             lpPoints[5].y == lpPoints[1].y && lpPoints[6].y == lpPoints[0].y && lpPoints[7].y == lpPoints[11].y)
 666         {
 667             ellipse = true;
 668         }
 669     }
 670
 671     if (polygon || ellipse) {
 672         HPEN hpenTmp = NULL;
 673         HPEN hpenOld = NULL;
 674         HBRUSH hbrushTmp = NULL;
 675         HBRUSH hbrushOld = NULL;
 676
 677         if (!stroke_and_fill) {
 678             if (fill_only) {
 679                 hpenTmp = (HPEN) GetStockObject(NULL_PEN);
 680                 hpenOld = (HPEN) SelectObject( hdc, hpenTmp );
 681             }
 682             else { // if (stroke_only)
 683                 hbrushTmp = (HBRUSH) GetStockObject(NULL_BRUSH);
 684                 hbrushOld = (HBRUSH) SelectObject( hdc, hbrushTmp );
 685             }
 686         }
 687
 688         if (polygon) {
 689             Polygon( hdc, lpPoints, nodes );
 690         }
 691         else if (ellipse) {
 692             Ellipse( hdc, lpPoints[6].x, lpPoints[3].y, lpPoints[0].x, lpPoints[9].y);
 693         }
 694
 695         done = true;
 696
 697         if (hpenOld)
 698             SelectObject( hdc, hpenOld );
 699         if (hpenTmp)
 700             DeleteObject( hpenTmp );
 701         if (hbrushOld)
 702             SelectObject( hdc, hbrushOld );
 703         if (hbrushTmp)
 704             DeleteObject( hbrushTmp );
 705     }
 706
 707     delete[] lpPoints;
 708
 709     return done;
 710 }
 711
 712 unsigned int
 713 PrintEmfWin32::print_bpath(const NArtBpath *bp, const NR::Matrix *transform, NRRect const *pbox)
 714 {
 715     unsigned int closed;
 716     NR::Matrix tf = *transform;
 717
 718     simple_shape = print_simple_shape(bp, &tf, pbox);
 719
 720     if (simple_shape)
 721         return TRUE;
 722
 723     BeginPath( hdc );
 724     closed = FALSE;
 725     while (bp->code != NR_END) {
 726         using NR::X;
 727         using NR::Y;
 728
 729         NR::Point p1(bp->c(1) * tf);
 730         NR::Point p2(bp->c(2) * tf);
 731         NR::Point p3(bp->c(3) * tf);
 732
 733         p1[X] = (p1[X] * IN_PER_PX * dwDPI);
 734         p2[X] = (p2[X] * IN_PER_PX * dwDPI);
 735         p3[X] = (p3[X] * IN_PER_PX * dwDPI);
 736         p1[Y] = (p1[Y] * IN_PER_PX * dwDPI);
 737         p2[Y] = (p2[Y] * IN_PER_PX * dwDPI);
 738         p3[Y] = (p3[Y] * IN_PER_PX * dwDPI);
 739
 740         LONG const x1 = (LONG) round(p1[X]);
 741         LONG const y1 = (LONG) round(rc.bottom-p1[Y]);
 742         LONG const x2 = (LONG) round(p2[X]);
 743         LONG const y2 = (LONG) round(rc.bottom-p2[Y]);
 744         LONG const x3 = (LONG) round(p3[X]);
 745         LONG const y3 = (LONG) round(rc.bottom-p3[Y]);
 746
 747         switch (bp->code) {
 748             case NR_MOVETO:
 749                 if (closed) {
 750                     CloseFigure( hdc );
 751                 }
 752                 closed = TRUE;
 753                 MoveToEx( hdc, x3, y3, NULL );
 754                 break;
 755             case NR_MOVETO_OPEN:
 756                 if (closed) {
 757                     CloseFigure( hdc );
 758                 }
 759                 closed = FALSE;
 760                 MoveToEx( hdc, x3, y3, NULL );
 761                 break;
 762             case NR_LINETO:
 763                 LineTo( hdc, x3, y3 );
 764                 break;
 765             case NR_CURVETO:
 766             {
 767                 POINT pt[3];
 768                 pt[0].x = x1;
 769                 pt[0].y = y1;
 770                 pt[1].x = x2;
 771                 pt[1].y = y2;
 772                 pt[2].x = x3;
 773                 pt[2].y = y3;
 774
 775                 PolyBezierTo( hdc, pt, 3 );
 776                 break;
 777             }
 778             default:
 779                 break;
 780         }
 781         bp += 1;
 782     }
 783     if (closed) {
 784         CloseFigure( hdc );
 785     }
 786     EndPath( hdc );
 787
 788     return closed;
 789 }
 790
 791
 792 bool
 793 PrintEmfWin32::textToPath(Inkscape::Extension::Print * ext)
 794 {
 795     return ext->get_param_bool("textToPath");
 796 }
 797
 798 unsigned int
 799 PrintEmfWin32::text(Inkscape::Extension::Print *mod, char const *text, NR::Point p,
 800               SPStyle const *const style)
 801 {
 802     if (!hdc) return 0;
 803
 804     HFONT hfont = NULL;
 805
 806 #ifdef USE_PANGO_WIN32
 807 /*
 808     font_instance *tf = (font_factory::Default())->Face(style->text->font_family.value, font_style_to_pos(*style));
 809     if (tf) {
 810         LOGFONT *lf = pango_win32_font_logfont(tf->pFont);
 811         tf->Unref();
 812         hfont = CreateFontIndirect(lf);
 813         g_free(lf);
 814     }
 815 */
 816 #endif
 817
 818     if (!hfont) {
 819         if (PrintWin32::is_os_wide()) {
 820             LOGFONTW *lf = (LOGFONTW*)g_malloc(sizeof(LOGFONTW));
 821             g_assert(lf != NULL);
 822
 823             lf->lfHeight = style->font_size.computed * IN_PER_PX * dwDPI;
 824             lf->lfWidth = 0;
 825             lf->lfEscapement = 0;
 826             lf->lfOrientation = 0;
 827             lf->lfWeight =
 828                 style->font_weight.value == SP_CSS_FONT_WEIGHT_100 ? FW_THIN :
 829                 style->font_weight.value == SP_CSS_FONT_WEIGHT_200 ? FW_EXTRALIGHT :
 830                 style->font_weight.value == SP_CSS_FONT_WEIGHT_300 ? FW_LIGHT :
 831                 style->font_weight.value == SP_CSS_FONT_WEIGHT_400 ? FW_NORMAL :
 832                 style->font_weight.value == SP_CSS_FONT_WEIGHT_500 ? FW_MEDIUM :
 833                 style->font_weight.value == SP_CSS_FONT_WEIGHT_600 ? FW_SEMIBOLD :
 834                 style->font_weight.value == SP_CSS_FONT_WEIGHT_700 ? FW_BOLD :
 835                 style->font_weight.value == SP_CSS_FONT_WEIGHT_800 ? FW_EXTRABOLD :
 836                 style->font_weight.value == SP_CSS_FONT_WEIGHT_900 ? FW_HEAVY :
 837                 style->font_weight.value == SP_CSS_FONT_WEIGHT_NORMAL ? FW_NORMAL :
 838                 style->font_weight.value == SP_CSS_FONT_WEIGHT_BOLD ? FW_BOLD :
 839                 style->font_weight.value == SP_CSS_FONT_WEIGHT_LIGHTER ? FW_EXTRALIGHT :
 840                 style->font_weight.value == SP_CSS_FONT_WEIGHT_BOLDER ? FW_EXTRABOLD :
 841                 FW_NORMAL;
 842             lf->lfItalic = (style->font_style.value == SP_CSS_FONT_STYLE_ITALIC);
 843             lf->lfUnderline = style->text_decoration.underline;
 844             lf->lfStrikeOut = style->text_decoration.line_through;
 845             lf->lfCharSet = DEFAULT_CHARSET;
 846             lf->lfOutPrecision = OUT_DEFAULT_PRECIS;
 847             lf->lfClipPrecision = CLIP_DEFAULT_PRECIS;
 848             lf->lfQuality = DEFAULT_QUALITY;
 849             lf->lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
 850
 851             gunichar2 *unicode_name = g_utf8_to_utf16( style->text->font_family.value, -1, NULL, NULL, NULL );
 852             wcsncpy(lf->lfFaceName, (wchar_t*) unicode_name, LF_FACESIZE-1);
 853             g_free(unicode_name);
 854
 855             hfont = CreateFontIndirectW(lf);
 856
 857             g_free(lf);
 858         }
 859         else {
 860             LOGFONTA *lf = (LOGFONTA*)g_malloc(sizeof(LOGFONTA));
 861             g_assert(lf != NULL);
 862
 863             lf->lfHeight = style->font_size.computed * IN_PER_PX * dwDPI;
 864             lf->lfWidth = 0;
 865             lf->lfEscapement = 0;
 866             lf->lfOrientation = 0;
 867             lf->lfWeight =
 868                 style->font_weight.value == SP_CSS_FONT_WEIGHT_100 ? FW_THIN :
 869                 style->font_weight.value == SP_CSS_FONT_WEIGHT_200 ? FW_EXTRALIGHT :
 870                 style->font_weight.value == SP_CSS_FONT_WEIGHT_300 ? FW_LIGHT :
 871                 style->font_weight.value == SP_CSS_FONT_WEIGHT_400 ? FW_NORMAL :
 872                 style->font_weight.value == SP_CSS_FONT_WEIGHT_500 ? FW_MEDIUM :
 873                 style->font_weight.value == SP_CSS_FONT_WEIGHT_600 ? FW_SEMIBOLD :
 874                 style->font_weight.value == SP_CSS_FONT_WEIGHT_700 ? FW_BOLD :
 875                 style->font_weight.value == SP_CSS_FONT_WEIGHT_800 ? FW_EXTRABOLD :
 876                 style->font_weight.value == SP_CSS_FONT_WEIGHT_900 ? FW_HEAVY :
 877                 style->font_weight.value == SP_CSS_FONT_WEIGHT_NORMAL ? FW_NORMAL :
 878                 style->font_weight.value == SP_CSS_FONT_WEIGHT_BOLD ? FW_BOLD :
 879                 style->font_weight.value == SP_CSS_FONT_WEIGHT_LIGHTER ? FW_EXTRALIGHT :
 880                 style->font_weight.value == SP_CSS_FONT_WEIGHT_BOLDER ? FW_EXTRABOLD :
 881                 FW_NORMAL;
 882             lf->lfItalic = (style->font_style.value == SP_CSS_FONT_STYLE_ITALIC);
 883             lf->lfUnderline = style->text_decoration.underline;
 884             lf->lfStrikeOut = style->text_decoration.line_through;
 885             lf->lfCharSet = DEFAULT_CHARSET;
 886             lf->lfOutPrecision = OUT_DEFAULT_PRECIS;
 887             lf->lfClipPrecision = CLIP_DEFAULT_PRECIS;
 888             lf->lfQuality = DEFAULT_QUALITY;
 889             lf->lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
 890
 891             strncpy(lf->lfFaceName, (char*) style->text->font_family.value, LF_FACESIZE-1);
 892
 893             hfont = CreateFontIndirectA(lf);
 894
 895             g_free(lf);
 896         }
 897     }
 898
 899     HFONT hfontOld = (HFONT) SelectObject(hdc, hfont);
 900
 901     float rgb[3];
 902     sp_color_get_rgb_floatv( &style->fill.value.color, rgb );
 903     SetTextColor(hdc, RGB(255*rgb[0], 255*rgb[1], 255*rgb[2]));
 904
 905     int align =
 906         style->text_align.value == SP_CSS_TEXT_ALIGN_RIGHT ? TA_RIGHT :
 907         style->text_align.value == SP_CSS_TEXT_ALIGN_CENTER ? TA_CENTER : TA_LEFT;
 908     SetTextAlign(hdc, TA_BASELINE | align);
 909     SetBkMode(hdc, TRANSPARENT);
 910
 911     NR::Matrix tf = m_tr_stack.top();
 912
 913     p = p * tf;
 914     p[NR::X] = (p[NR::X] * IN_PER_PX * dwDPI);
 915     p[NR::Y] = (p[NR::Y] * IN_PER_PX * dwDPI);
 916
 917     LONG const xpos = (LONG) round(p[NR::X]);
 918     LONG const ypos = (LONG) round(rc.bottom-p[NR::Y]);
 919
 920     if (PrintWin32::is_os_wide()) {
 921         gunichar2 *unicode_text = g_utf8_to_utf16( text, -1, NULL, NULL, NULL );
 922         TextOutW(hdc, xpos, ypos, (WCHAR*)unicode_text, wcslen((wchar_t*)unicode_text));
 923     }
 924     else {
 925         TextOutA(hdc, xpos, ypos, (CHAR*)text, strlen((char*)text));
 926     }
 927
 928     SelectObject(hdc, hfontOld);
 929     DeleteObject(hfont);
 930
 931     return 0;
 932 }
 933
 934 void
 935 PrintEmfWin32::init (void)
 936 {
 937     Inkscape::Extension::Extension * ext;
 938
 939     /* EMF print */
 940     ext = Inkscape::Extension::build_from_mem(
 941         "<inkscape-extension xmlns=\"" INKSCAPE_EXTENSION_URI "\">\n"
 942         "<name>Enhanced Metafile Print</name>\n"
 943         "<id>org.inkscape.print.emf.win32</id>\n"
 944         "<param name=\"destination\" type=\"string\"></param>\n"
 945         "<param name=\"textToPath\" type=\"boolean\">true</param>\n"
 946         "<param name=\"pageBoundingBox\" type=\"boolean\">true</param>\n"
 947         "<print/>\n"
 948         "</inkscape-extension>", new PrintEmfWin32());
 949
 950     return;
 951 }
 952
 953
 954 }  /* namespace Internal */
 955 }  /* namespace Extension */
 956 }  /* namespace Inkscape */
 957
 958 #endif /* WIN32 */
 959
 960 /*
 961   Local Variables:
 962   mode:c++
 963   c-file-style:"stroustrup"
 964   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 965   indent-tabs-mode:nil
 966   fill-column:99
 967   End:
 968 */
 969 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :