src/generic/dcpsg.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        dcpsg.cpp
   3 // Purpose:     Generic wxPostScriptDC implementation
   4 // Author:      Julian Smart, Robert Roebling, Markus Holzhem
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart and Markus Holzem
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13 #pragma implementation "dcpsg.h"
  14 #endif
  15
  16 #include "wx/wxprec.h"
  17
  18 #ifdef __BORLANDC__
  19     #pragma hdrstop
  20 #endif
  21
  22 #ifndef WX_PRECOMP
  23 #endif // WX_PRECOMP
  24
  25 #if wxUSE_PRINTING_ARCHITECTURE
  26
  27 #if wxUSE_POSTSCRIPT
  28
  29 #include "wx/setup.h"
  30
  31 #include "wx/window.h"
  32 #include "wx/dcmemory.h"
  33 #include "wx/utils.h"
  34 #include "wx/intl.h"
  35 #include "wx/filedlg.h"
  36 #include "wx/app.h"
  37 #include "wx/msgdlg.h"
  38 #include "wx/image.h"
  39 #include "wx/log.h"
  40 #include "wx/generic/dcpsg.h"
  41 #include "wx/printdlg.h"
  42 #include "wx/button.h"
  43 #include "wx/stattext.h"
  44 #include "wx/radiobox.h"
  45 #include "wx/textctrl.h"
  46 #include "wx/prntbase.h"
  47 #include "wx/paper.h"
  48 #include "wx/filefn.h"
  49
  50 #include <math.h>
  51
  52 #ifdef __WXMSW__
  53
  54 #ifdef DrawText
  55 #undef DrawText
  56 #endif
  57
  58 #ifdef StartDoc
  59 #undef StartDoc
  60 #endif
  61
  62 #ifdef GetCharWidth
  63 #undef GetCharWidth
  64 #endif
  65
  66 #ifdef FindWindow
  67 #undef FindWindow
  68 #endif
  69
  70 #endif
  71
  72 //-----------------------------------------------------------------------------
  73 // start and end of document/page
  74 //-----------------------------------------------------------------------------
  75
  76 static const char *wxPostScriptHeaderConicTo = "\
  77 /conicto {\n\
  78     /to_y exch def\n\
  79     /to_x exch def\n\
  80     /conic_cntrl_y exch def\n\
  81     /conic_cntrl_x exch def\n\
  82     currentpoint\n\
  83     /p0_y exch def\n\
  84     /p0_x exch def\n\
  85     /p1_x p0_x conic_cntrl_x p0_x sub 2 3 div mul add def\n\
  86     /p1_y p0_y conic_cntrl_y p0_y sub 2 3 div mul add def\n\
  87     /p2_x p1_x to_x p0_x sub 1 3 div mul add def\n\
  88     /p2_y p1_y to_y p0_y sub 1 3 div mul add def\n\
  89     p1_x p1_y p2_x p2_y to_x to_y curveto\n\
  90 }  bind def\n\
  91 ";
  92
  93 static const char *wxPostScriptHeaderEllipse = "\
  94 /ellipsedict 8 dict def\n\
  95 ellipsedict /mtrx matrix put\n\
  96 /ellipse {\n\
  97     ellipsedict begin\n\
  98     /endangle exch def\n\
  99     /startangle exch def\n\
 100     /yrad exch def\n\
 101     /xrad exch def\n\
 102     /y exch def\n\
 103     /x exch def\n\
 104     /savematrix mtrx currentmatrix def\n\
 105     x y translate\n\
 106     xrad yrad scale\n\
 107     0 0 1 startangle endangle arc\n\
 108     savematrix setmatrix\n\
 109     end\n\
 110     } def\n\
 111 ";
 112
 113 static const char *wxPostScriptHeaderEllipticArc= "\
 114 /ellipticarcdict 8 dict def\n\
 115 ellipticarcdict /mtrx matrix put\n\
 116 /ellipticarc\n\
 117 { ellipticarcdict begin\n\
 118   /do_fill exch def\n\
 119   /endangle exch def\n\
 120   /startangle exch def\n\
 121   /yrad exch def\n\
 122   /xrad exch def \n\
 123   /y exch def\n\
 124   /x exch def\n\
 125   /savematrix mtrx currentmatrix def\n\
 126   x y translate\n\
 127   xrad yrad scale\n\
 128   do_fill { 0 0 moveto } if\n\
 129   0 0 1 startangle endangle arc\n\
 130   savematrix setmatrix\n\
 131   do_fill { fill }{ stroke } ifelse\n\
 132   end\n\
 133 } def\n";
 134
 135 static const char *wxPostScriptHeaderSpline = "\
 136 /DrawSplineSection {\n\
 137     /y3 exch def\n\
 138     /x3 exch def\n\
 139     /y2 exch def\n\
 140     /x2 exch def\n\
 141     /y1 exch def\n\
 142     /x1 exch def\n\
 143     /xa x1 x2 x1 sub 0.666667 mul add def\n\
 144     /ya y1 y2 y1 sub 0.666667 mul add def\n\
 145     /xb x3 x2 x3 sub 0.666667 mul add def\n\
 146     /yb y3 y2 y3 sub 0.666667 mul add def\n\
 147     x1 y1 lineto\n\
 148     xa ya xb yb x3 y3 curveto\n\
 149     } def\n\
 150 ";
 151
 152 static const char *wxPostScriptHeaderColourImage = "\
 153 %% define 'colorimage' if it isn't defined\n\
 154 %%   ('colortogray' and 'mergeprocs' come from xwd2ps\n\
 155 %%     via xgrab)\n\
 156 /colorimage where   %% do we know about 'colorimage'?\n\
 157   { pop }           %% yes: pop off the 'dict' returned\n\
 158   {                 %% no:  define one\n\
 159     /colortogray {  %% define an RGB->I function\n\
 160       /rgbdata exch store    %% call input 'rgbdata'\n\
 161       rgbdata length 3 idiv\n\
 162       /npixls exch store\n\
 163       /rgbindx 0 store\n\
 164       0 1 npixls 1 sub {\n\
 165         grays exch\n\
 166         rgbdata rgbindx       get 20 mul    %% Red\n\
 167         rgbdata rgbindx 1 add get 32 mul    %% Green\n\
 168         rgbdata rgbindx 2 add get 12 mul    %% Blue\n\
 169         add add 64 idiv      %% I = .5G + .31R + .18B\n\
 170         put\n\
 171         /rgbindx rgbindx 3 add store\n\
 172       } for\n\
 173       grays 0 npixls getinterval\n\
 174     } bind def\n\
 175 \n\
 176     %% Utility procedure for colorimage operator.\n\
 177     %% This procedure takes two procedures off the\n\
 178     %% stack and merges them into a single procedure.\n\
 179 \n\
 180     /mergeprocs { %% def\n\
 181       dup length\n\
 182       3 -1 roll\n\
 183       dup\n\
 184       length\n\
 185       dup\n\
 186       5 1 roll\n\
 187       3 -1 roll\n\
 188       add\n\
 189       array cvx\n\
 190       dup\n\
 191       3 -1 roll\n\
 192       0 exch\n\
 193       putinterval\n\
 194       dup\n\
 195       4 2 roll\n\
 196       putinterval\n\
 197     } bind def\n\
 198 \n\
 199     /colorimage { %% def\n\
 200       pop pop     %% remove 'false 3' operands\n\
 201       {colortogray} mergeprocs\n\
 202       image\n\
 203     } bind def\n\
 204   } ifelse          %% end of 'false' case\n\
 205 ";
 206
 207 #ifndef __WXGTK20__
 208 static char wxPostScriptHeaderReencodeISO1[] =
 209     "\n/reencodeISO {\n"
 210 "dup dup findfont dup length dict begin\n"
 211 "{ 1 index /FID ne { def }{ pop pop } ifelse } forall\n"
 212 "/Encoding ISOLatin1Encoding def\n"
 213 "currentdict end definefont\n"
 214 "} def\n"
 215 "/ISOLatin1Encoding [\n"
 216 "/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef\n"
 217 "/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef\n"
 218 "/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef\n"
 219 "/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef\n"
 220 "/space/exclam/quotedbl/numbersign/dollar/percent/ampersand/quoteright\n"
 221 "/parenleft/parenright/asterisk/plus/comma/minus/period/slash\n"
 222 "/zero/one/two/three/four/five/six/seven/eight/nine/colon/semicolon\n"
 223 "/less/equal/greater/question/at/A/B/C/D/E/F/G/H/I/J/K/L/M/N\n"
 224 "/O/P/Q/R/S/T/U/V/W/X/Y/Z/bracketleft/backslash/bracketright\n"
 225 "/asciicircum/underscore/quoteleft/a/b/c/d/e/f/g/h/i/j/k/l/m\n"
 226 "/n/o/p/q/r/s/t/u/v/w/x/y/z/braceleft/bar/braceright/asciitilde\n"
 227 "/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef\n"
 228 "/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef\n"
 229 "/.notdef/dotlessi/grave/acute/circumflex/tilde/macron/breve\n"
 230 "/dotaccent/dieresis/.notdef/ring/cedilla/.notdef/hungarumlaut\n";
 231
 232 static char wxPostScriptHeaderReencodeISO2[] =
 233 "/ogonek/caron/space/exclamdown/cent/sterling/currency/yen/brokenbar\n"
 234 "/section/dieresis/copyright/ordfeminine/guillemotleft/logicalnot\n"
 235 "/hyphen/registered/macron/degree/plusminus/twosuperior/threesuperior\n"
 236 "/acute/mu/paragraph/periodcentered/cedilla/onesuperior/ordmasculine\n"
 237 "/guillemotright/onequarter/onehalf/threequarters/questiondown\n"
 238 "/Agrave/Aacute/Acircumflex/Atilde/Adieresis/Aring/AE/Ccedilla\n"
 239 "/Egrave/Eacute/Ecircumflex/Edieresis/Igrave/Iacute/Icircumflex\n"
 240 "/Idieresis/Eth/Ntilde/Ograve/Oacute/Ocircumflex/Otilde/Odieresis\n"
 241 "/multiply/Oslash/Ugrave/Uacute/Ucircumflex/Udieresis/Yacute\n"
 242 "/Thorn/germandbls/agrave/aacute/acircumflex/atilde/adieresis\n"
 243 "/aring/ae/ccedilla/egrave/eacute/ecircumflex/edieresis/igrave\n"
 244 "/iacute/icircumflex/idieresis/eth/ntilde/ograve/oacute/ocircumflex\n"
 245 "/otilde/odieresis/divide/oslash/ugrave/uacute/ucircumflex/udieresis\n"
 246 "/yacute/thorn/ydieresis\n"
 247         "] def\n\n";
 248 #endif
 249
 250 //-------------------------------------------------------------------------------
 251 // wxPostScriptDC
 252 //-------------------------------------------------------------------------------
 253
 254 IMPLEMENT_DYNAMIC_CLASS(wxPostScriptDC, wxDC)
 255
 256 float wxPostScriptDC::ms_PSScaleFactor = 10.0;
 257
 258 void wxPostScriptDC::SetResolution(int ppi)
 259 {
 260     ms_PSScaleFactor = (float)ppi / 72.0;
 261 }
 262
 263 int wxPostScriptDC::GetResolution()
 264 {
 265     return (int)(ms_PSScaleFactor * 72.0);
 266 }
 267
 268 //-------------------------------------------------------------------------------
 269
 270 wxPostScriptDC::wxPostScriptDC ()
 271 {
 272     m_pstream = (FILE*) NULL;
 273
 274     m_currentRed = 0;
 275     m_currentGreen = 0;
 276     m_currentBlue = 0;
 277
 278     m_pageNumber = 0;
 279
 280     m_clipping = FALSE;
 281
 282     m_underlinePosition = 0.0;
 283     m_underlineThickness = 0.0;
 284
 285     m_signX =  1;  // default x-axis left to right
 286     m_signY = -1;  // default y-axis bottom up -> top down
 287 }
 288
 289 wxPostScriptDC::wxPostScriptDC (const wxPrintData& printData)
 290 {
 291     m_pstream = (FILE*) NULL;
 292
 293     m_currentRed = 0;
 294     m_currentGreen = 0;
 295     m_currentBlue = 0;
 296
 297     m_pageNumber = 0;
 298
 299     m_clipping = FALSE;
 300
 301     m_underlinePosition = 0.0;
 302     m_underlineThickness = 0.0;
 303
 304     m_signX =  1;  // default x-axis left to right
 305     m_signY = -1;  // default y-axis bottom up -> top down
 306
 307     m_printData = printData;
 308
 309     m_ok = TRUE;
 310 }
 311
 312 wxPostScriptDC::~wxPostScriptDC ()
 313 {
 314     if (m_pstream)
 315     {
 316         fclose( m_pstream );
 317         m_pstream = (FILE*) NULL;
 318     }
 319 }
 320
 321 bool wxPostScriptDC::Ok() const
 322 {
 323   return m_ok;
 324 }
 325
 326 void wxPostScriptDC::DoSetClippingRegion (wxCoord x, wxCoord y, wxCoord w, wxCoord h)
 327 {
 328     wxCHECK_RET( m_ok && m_pstream, wxT("invalid postscript dc") );
 329
 330     if (m_clipping) DestroyClippingRegion();
 331
 332     wxDC::DoSetClippingRegion(x, y, w, h);
 333
 334     m_clipping = TRUE;
 335     fprintf( m_pstream,
 336             "gsave\n newpath\n"
 337             "%d %d moveto\n"
 338             "%d %d lineto\n"
 339             "%d %d lineto\n"
 340             "%d %d lineto\n"
 341             "closepath clip newpath\n",
 342             LogicalToDeviceX(x),   LogicalToDeviceY(y),
 343             LogicalToDeviceX(x+w), LogicalToDeviceY(y),
 344             LogicalToDeviceX(x+w), LogicalToDeviceY(y+h),
 345             LogicalToDeviceX(x),   LogicalToDeviceY(y+h) );
 346 }
 347
 348
 349 void wxPostScriptDC::DestroyClippingRegion()
 350 {
 351     wxCHECK_RET( m_ok && m_pstream, wxT("invalid postscript dc") );
 352
 353     if (m_clipping)
 354     {
 355         m_clipping = FALSE;
 356         fprintf( m_pstream, "grestore\n" );
 357     }
 358
 359     wxDC::DestroyClippingRegion();
 360 }
 361
 362 void wxPostScriptDC::Clear()
 363 {
 364     wxFAIL_MSG( wxT("wxPostScriptDC::Clear not implemented.") );
 365 }
 366
 367 bool wxPostScriptDC::DoFloodFill (wxCoord WXUNUSED(x), wxCoord WXUNUSED(y), const wxColour &WXUNUSED(col), int WXUNUSED(style))
 368 {
 369     wxFAIL_MSG( wxT("wxPostScriptDC::FloodFill not implemented.") );
 370     return FALSE;
 371 }
 372
 373 bool wxPostScriptDC::DoGetPixel (wxCoord WXUNUSED(x), wxCoord WXUNUSED(y), wxColour * WXUNUSED(col)) const
 374 {
 375     wxFAIL_MSG( wxT("wxPostScriptDC::GetPixel not implemented.") );
 376     return FALSE;
 377 }
 378
 379 void wxPostScriptDC::DoCrossHair (wxCoord WXUNUSED(x), wxCoord WXUNUSED(y))
 380 {
 381     wxFAIL_MSG( wxT("wxPostScriptDC::CrossHair not implemented.") );
 382 }
 383
 384 void wxPostScriptDC::DoDrawLine (wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
 385 {
 386     wxCHECK_RET( m_ok && m_pstream, wxT("invalid postscript dc") );
 387
 388     if  (m_pen.GetStyle() == wxTRANSPARENT) return;
 389
 390     SetPen( m_pen );
 391
 392     fprintf( m_pstream,
 393             "newpath\n"
 394             "%d %d moveto\n"
 395             "%d %d lineto\n"
 396             "stroke\n",
 397             LogicalToDeviceX(x1), LogicalToDeviceY(y1),
 398             LogicalToDeviceX(x2), LogicalToDeviceY (y2) );
 399
 400     CalcBoundingBox( x1, y1 );
 401     CalcBoundingBox( x2, y2 );
 402 }
 403
 404 #define RAD2DEG 57.29577951308
 405
 406 void wxPostScriptDC::DoDrawArc (wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord xc, wxCoord yc)
 407 {
 408     wxCHECK_RET( m_ok && m_pstream, wxT("invalid postscript dc") );
 409
 410     wxCoord dx = x1 - xc;
 411     wxCoord dy = y1 - yc;
 412     wxCoord radius = (wxCoord) sqrt( (double)(dx*dx+dy*dy) );
 413     double alpha1, alpha2;
 414
 415     if (x1 == x2 && y1 == y2)
 416     {
 417         alpha1 = 0.0;
 418         alpha2 = 360.0;
 419     }
 420     else if (radius == 0.0)
 421     {
 422         alpha1 = alpha2 = 0.0;
 423     }
 424     else
 425     {
 426         alpha1 = (x1 - xc == 0) ?
 427             (y1 - yc < 0) ? 90.0 : -90.0 :
 428                 -atan2(double(y1-yc), double(x1-xc)) * RAD2DEG;
 429         alpha2 = (x2 - xc == 0) ?
 430             (y2 - yc < 0) ? 90.0 : -90.0 :
 431                 -atan2(double(y2-yc), double(x2-xc)) * RAD2DEG;
 432     }
 433     while (alpha1 <= 0)   alpha1 += 360;
 434     while (alpha2 <= 0)   alpha2 += 360; // adjust angles to be between
 435     while (alpha1 > 360)  alpha1 -= 360; // 0 and 360 degree
 436     while (alpha2 > 360)  alpha2 -= 360;
 437
 438     if (m_brush.GetStyle() != wxTRANSPARENT)
 439     {
 440         SetBrush( m_brush );
 441
 442         fprintf( m_pstream,
 443                 "newpath\n"
 444                 "%d %d %d %d %d %d ellipse\n"
 445                 "%d %d lineto\n"
 446                 "closepath\n"
 447                 "fill\n",
 448                 LogicalToDeviceX(xc), LogicalToDeviceY(yc), LogicalToDeviceXRel(radius), LogicalToDeviceYRel(radius), (wxCoord)alpha1, (wxCoord) alpha2,
 449                 LogicalToDeviceX(xc), LogicalToDeviceY(yc) );
 450
 451         CalcBoundingBox( xc-radius, yc-radius );
 452         CalcBoundingBox( xc+radius, yc+radius );
 453     }
 454
 455     if (m_pen.GetStyle() != wxTRANSPARENT)
 456     {
 457         SetPen( m_pen );
 458
 459         fprintf( m_pstream,
 460                 "newpath\n"
 461                 "%d %d %d %d %d %d ellipse\n"
 462                 "%d %d lineto\n"
 463                 "stroke\n"
 464                 "fill\n",
 465                 LogicalToDeviceX(xc), LogicalToDeviceY(yc), LogicalToDeviceXRel(radius), LogicalToDeviceYRel(radius), (wxCoord)alpha1, (wxCoord) alpha2,
 466                 LogicalToDeviceX(xc), LogicalToDeviceY(yc) );
 467
 468         CalcBoundingBox( xc-radius, yc-radius );
 469         CalcBoundingBox( xc+radius, yc+radius );
 470     }
 471 }
 472
 473 void wxPostScriptDC::DoDrawEllipticArc(wxCoord x,wxCoord y,wxCoord w,wxCoord h,double sa,double ea)
 474 {
 475     wxCHECK_RET( m_ok && m_pstream, wxT("invalid postscript dc") );
 476
 477     if (sa>=360 || sa<=-360) sa=sa-int(sa/360)*360;
 478     if (ea>=360 || ea<=-360) ea=ea-int(ea/360)*360;
 479     if (sa<0) sa+=360;
 480     if (ea<0) ea+=360;
 481
 482     if (sa==ea)
 483     {
 484         DrawEllipse(x,y,w,h);
 485         return;
 486     }
 487
 488     if (m_brush.GetStyle () != wxTRANSPARENT)
 489     {
 490         SetBrush( m_brush );
 491
 492         fprintf( m_pstream,
 493                 "newpath\n"
 494                 "%d %d %d %d %d %d true ellipticarc\n",
 495                 LogicalToDeviceX(x+w/2), LogicalToDeviceY(y+h/2), LogicalToDeviceXRel(w/2), LogicalToDeviceYRel(h/2), (wxCoord)sa, (wxCoord)ea );
 496
 497         CalcBoundingBox( x ,y );
 498         CalcBoundingBox( x+w, y+h );
 499     }
 500
 501     if (m_pen.GetStyle () != wxTRANSPARENT)
 502     {
 503         SetPen( m_pen );
 504
 505         fprintf(m_pstream,
 506                 "newpath\n"
 507                 "%d %d %d %d %d %d false ellipticarc\n",
 508                 LogicalToDeviceX(x+w/2), LogicalToDeviceY(y+h/2), LogicalToDeviceXRel(w/2), LogicalToDeviceYRel(h/2), (wxCoord)sa, (wxCoord)ea );
 509
 510         CalcBoundingBox( x ,y );
 511         CalcBoundingBox( x+w, y+h );
 512     }
 513 }
 514
 515 void wxPostScriptDC::DoDrawPoint (wxCoord x, wxCoord y)
 516 {
 517     wxCHECK_RET( m_ok && m_pstream, wxT("invalid postscript dc") );
 518
 519     if (m_pen.GetStyle() == wxTRANSPARENT) return;
 520
 521     SetPen (m_pen);
 522
 523     fprintf( m_pstream,
 524             "newpath\n"
 525             "%d %d moveto\n"
 526             "%d %d lineto\n"
 527             "stroke\n",
 528             LogicalToDeviceX(x),   LogicalToDeviceY(y),
 529             LogicalToDeviceX(x+1), LogicalToDeviceY(y) );
 530
 531     CalcBoundingBox( x, y );
 532 }
 533
 534 void wxPostScriptDC::DoDrawPolygon (int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset, int WXUNUSED(fillStyle))
 535 {
 536     wxCHECK_RET( m_ok && m_pstream, wxT("invalid postscript dc") );
 537
 538     if (n <= 0) return;
 539
 540     if (m_brush.GetStyle () != wxTRANSPARENT)
 541     {
 542         SetBrush( m_brush );
 543
 544         fprintf( m_pstream, "newpath\n" );
 545
 546         wxCoord xx = LogicalToDeviceX(points[0].x + xoffset);
 547         wxCoord yy = LogicalToDeviceY(points[0].y + yoffset);
 548
 549         fprintf( m_pstream, "%d %d moveto\n", xx, yy );
 550
 551         CalcBoundingBox( points[0].x + xoffset, points[0].y + yoffset );
 552
 553         for (int i = 1; i < n; i++)
 554         {
 555             xx = LogicalToDeviceX(points[i].x + xoffset);
 556             yy = LogicalToDeviceY(points[i].y + yoffset);
 557
 558             fprintf( m_pstream, "%d %d lineto\n", xx, yy );
 559
 560             CalcBoundingBox( points[i].x + xoffset, points[i].y + yoffset);
 561         }
 562
 563         fprintf( m_pstream, "fill\n" );
 564     }
 565
 566     if (m_pen.GetStyle () != wxTRANSPARENT)
 567     {
 568         SetPen( m_pen );
 569
 570         fprintf( m_pstream, "newpath\n" );
 571
 572         wxCoord xx = LogicalToDeviceX(points[0].x + xoffset);
 573         wxCoord yy = LogicalToDeviceY(points[0].y + yoffset);
 574
 575         fprintf( m_pstream, "%d %d moveto\n", xx, yy );
 576
 577         CalcBoundingBox( points[0].x + xoffset, points[0].y + yoffset );
 578
 579         for (int i = 1; i < n; i++)
 580         {
 581             xx = LogicalToDeviceX(points[i].x + xoffset);
 582             yy = LogicalToDeviceY(points[i].y + yoffset);
 583
 584             fprintf( m_pstream, "%d %d lineto\n", xx, yy );
 585
 586             CalcBoundingBox( points[i].x + xoffset, points[i].y + yoffset);
 587         }
 588
 589         fprintf( m_pstream, "closepath\n" );
 590         fprintf( m_pstream, "stroke\n" );
 591     }
 592 }
 593
 594 void wxPostScriptDC::DoDrawLines (int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset)
 595 {
 596     wxCHECK_RET( m_ok && m_pstream, wxT("invalid postscript dc") );
 597
 598     if (m_pen.GetStyle() == wxTRANSPARENT) return;
 599
 600     if (n <= 0) return;
 601
 602     SetPen (m_pen);
 603
 604     int i;
 605     for ( i =0; i<n ; i++ )
 606     {
 607         CalcBoundingBox( LogicalToDeviceX(points[i].x+xoffset), LogicalToDeviceY(points[i].y+yoffset));
 608     }
 609
 610     fprintf( m_pstream,
 611             "newpath\n"
 612             "%d %d moveto\n",
 613             LogicalToDeviceX(points[0].x+xoffset), LogicalToDeviceY(points[0].y+yoffset) );
 614
 615     for (i = 1; i < n; i++)
 616     {
 617         fprintf( m_pstream,
 618                 "%d %d lineto\n",
 619                 LogicalToDeviceX(points[i].x+xoffset), LogicalToDeviceY(points[i].y+yoffset) );
 620     }
 621
 622     fprintf( m_pstream, "stroke\n" );
 623 }
 624
 625 void wxPostScriptDC::DoDrawRectangle (wxCoord x, wxCoord y, wxCoord width, wxCoord height)
 626 {
 627     wxCHECK_RET( m_ok && m_pstream, wxT("invalid postscript dc") );
 628
 629     if (m_brush.GetStyle () != wxTRANSPARENT)
 630     {
 631         SetBrush( m_brush );
 632
 633         fprintf( m_pstream,
 634                 "newpath\n"
 635                 "%d %d moveto\n"
 636                 "%d %d lineto\n"
 637                 "%d %d lineto\n"
 638                 "%d %d lineto\n"
 639                 "closepath\n"
 640                 "fill\n",
 641                 LogicalToDeviceX(x),         LogicalToDeviceY(y),
 642                 LogicalToDeviceX(x + width), LogicalToDeviceY(y),
 643                 LogicalToDeviceX(x + width), LogicalToDeviceY(y + height),
 644                 LogicalToDeviceX(x),         LogicalToDeviceY(y + height) );
 645
 646         CalcBoundingBox( x, y );
 647         CalcBoundingBox( x + width, y + height );
 648     }
 649
 650     if (m_pen.GetStyle () != wxTRANSPARENT)
 651     {
 652         SetPen (m_pen);
 653
 654         fprintf( m_pstream,
 655                 "newpath\n"
 656                 "%d %d moveto\n"
 657                 "%d %d lineto\n"
 658                 "%d %d lineto\n"
 659                 "%d %d lineto\n"
 660                 "closepath\n"
 661                 "stroke\n",
 662                 LogicalToDeviceX(x),         LogicalToDeviceY(y),
 663                 LogicalToDeviceX(x + width), LogicalToDeviceY(y),
 664                 LogicalToDeviceX(x + width), LogicalToDeviceY(y + height),
 665                 LogicalToDeviceX(x),         LogicalToDeviceY(y + height) );
 666
 667         CalcBoundingBox( x, y );
 668         CalcBoundingBox( x + width, y + height );
 669     }
 670 }
 671
 672 void wxPostScriptDC::DoDrawRoundedRectangle (wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius)
 673 {
 674     wxCHECK_RET( m_ok && m_pstream, wxT("invalid postscript dc") );
 675
 676     if (radius < 0.0)
 677     {
 678         // Now, a negative radius is interpreted to mean
 679         // 'the proportion of the smallest X or Y dimension'
 680         double smallest = 0.0;
 681         if (width < height)
 682         smallest = width;
 683         else
 684         smallest = height;
 685         radius =  (-radius * smallest);
 686     }
 687
 688     wxCoord rad = (wxCoord) radius;
 689
 690     if (m_brush.GetStyle () != wxTRANSPARENT)
 691     {
 692         SetBrush( m_brush );
 693
 694         /* Draw rectangle anticlockwise */
 695         fprintf( m_pstream,
 696                 "newpath\n"
 697                 "%d %d %d 90 180 arc\n"
 698                 "%d %d moveto\n"
 699                 "%d %d %d 180 270 arc\n"
 700                 "%d %d lineto\n"
 701                 "%d %d %d 270 0 arc\n"
 702                 "%d %d lineto\n"
 703                 "%d %d %d 0 90 arc\n"
 704                 "%d %d lineto\n"
 705                 "closepath\n"
 706                 "fill\n",
 707                 LogicalToDeviceX(x + rad), LogicalToDeviceY(y + rad), LogicalToDeviceXRel(rad),
 708                 LogicalToDeviceX(x), LogicalToDeviceY(y + rad),
 709                 LogicalToDeviceX(x + rad), LogicalToDeviceY(y + height - rad), LogicalToDeviceXRel(rad),
 710                 LogicalToDeviceX(x + width - rad), LogicalToDeviceY(y + height),
 711                 LogicalToDeviceX(x + width - rad), LogicalToDeviceY(y + height - rad), LogicalToDeviceXRel(rad),
 712                 LogicalToDeviceX(x + width), LogicalToDeviceY(y + rad),
 713                 LogicalToDeviceX(x + width - rad), LogicalToDeviceY(y + rad), LogicalToDeviceXRel(rad),
 714                 LogicalToDeviceX(x + rad), LogicalToDeviceY(y) );
 715
 716         CalcBoundingBox( x, y );
 717         CalcBoundingBox( x + width, y + height );
 718     }
 719
 720     if (m_pen.GetStyle () != wxTRANSPARENT)
 721     {
 722         SetPen (m_pen);
 723
 724         /* Draw rectangle anticlockwise */
 725         fprintf( m_pstream,
 726                 "newpath\n"
 727                 "%d %d %d 90 180 arc\n"
 728                 "%d %d moveto\n"
 729                 "%d %d %d 180 270 arc\n"
 730                 "%d %d lineto\n"
 731                 "%d %d %d 270 0 arc\n"
 732                 "%d %d lineto\n"
 733                 "%d %d %d 0 90 arc\n"
 734                 "%d %d lineto\n"
 735                 "closepath\n"
 736                 "stroke\n",
 737                 LogicalToDeviceX(x + rad), LogicalToDeviceY(y + rad), LogicalToDeviceXRel(rad),
 738                 LogicalToDeviceX(x), LogicalToDeviceY(y + rad),
 739                 LogicalToDeviceX(x + rad), LogicalToDeviceY(y + height - rad), LogicalToDeviceXRel(rad),
 740                 LogicalToDeviceX(x + width - rad), LogicalToDeviceY(y + height),
 741                 LogicalToDeviceX(x + width - rad), LogicalToDeviceY(y + height - rad), LogicalToDeviceXRel(rad),
 742                 LogicalToDeviceX(x + width), LogicalToDeviceY(y + rad),
 743                 LogicalToDeviceX(x + width - rad), LogicalToDeviceY(y + rad), LogicalToDeviceXRel(rad),
 744                 LogicalToDeviceX(x + rad), LogicalToDeviceY(y) );
 745
 746         CalcBoundingBox( x, y );
 747         CalcBoundingBox( x + width, y + height );
 748     }
 749 }
 750
 751 void wxPostScriptDC::DoDrawEllipse (wxCoord x, wxCoord y, wxCoord width, wxCoord height)
 752 {
 753     wxCHECK_RET( m_ok && m_pstream, wxT("invalid postscript dc") );
 754
 755     if (m_brush.GetStyle () != wxTRANSPARENT)
 756     {
 757         SetBrush (m_brush);
 758
 759         fprintf( m_pstream,
 760                 "newpath\n"
 761                 "%d %d %d %d 0 360 ellipse\n"
 762                 "fill\n",
 763                 LogicalToDeviceX(x + width / 2), LogicalToDeviceY(y + height / 2),
 764                 LogicalToDeviceXRel(width / 2), LogicalToDeviceYRel(height / 2) );
 765
 766         CalcBoundingBox( x - width, y - height );
 767         CalcBoundingBox( x + width, y + height );
 768     }
 769
 770     if (m_pen.GetStyle () != wxTRANSPARENT)
 771     {
 772         SetPen (m_pen);
 773
 774         fprintf( m_pstream,
 775                 "newpath\n"
 776                 "%d %d %d %d 0 360 ellipse\n"
 777                 "stroke\n",
 778                 LogicalToDeviceX(x + width / 2), LogicalToDeviceY(y + height / 2),
 779                 LogicalToDeviceXRel(width / 2), LogicalToDeviceYRel(height / 2) );
 780
 781         CalcBoundingBox( x - width, y - height );
 782         CalcBoundingBox( x + width, y + height );
 783     }
 784 }
 785
 786 void wxPostScriptDC::DoDrawIcon( const wxIcon& icon, wxCoord x, wxCoord y )
 787 {
 788     DrawBitmap( icon, x, y, TRUE );
 789 }
 790
 791 /* this has to be char, not wxChar */
 792 static char hexArray[] = "0123456789ABCDEF";
 793 static void LocalDecToHex( int dec, char *buf )
 794 {
 795     int firstDigit = (int)(dec/16.0);
 796     int secondDigit = (int)(dec - (firstDigit*16.0));
 797     buf[0] = hexArray[firstDigit];
 798     buf[1] = hexArray[secondDigit];
 799     buf[2] = 0;
 800 }
 801
 802 void wxPostScriptDC::DoDrawBitmap( const wxBitmap& bitmap, wxCoord x, wxCoord y, bool WXUNUSED(useMask) )
 803 {
 804     wxCHECK_RET( m_ok && m_pstream, wxT("invalid postscript dc") );
 805
 806     if (!bitmap.Ok()) return;
 807
 808     wxImage image = bitmap.ConvertToImage();
 809
 810     if (!image.Ok()) return;
 811
 812     wxCoord w = image.GetWidth();
 813     wxCoord h = image.GetHeight();
 814
 815     wxCoord ww = LogicalToDeviceXRel(image.GetWidth());
 816     wxCoord hh = LogicalToDeviceYRel(image.GetHeight());
 817
 818     wxCoord xx = LogicalToDeviceX(x);
 819     wxCoord yy = LogicalToDeviceY(y + bitmap.GetHeight());
 820
 821     fprintf( m_pstream,
 822             "/origstate save def\n"
 823             "20 dict begin\n"
 824             "/pix %d string def\n"
 825             "/grays %d string def\n"
 826             "/npixels 0 def\n"
 827             "/rgbindx 0 def\n"
 828             "%d %d translate\n"
 829             "%d %d scale\n"
 830             "%d %d 8\n"
 831             "[%d 0 0 %d 0 %d]\n"
 832             "{currentfile pix readhexstring pop}\n"
 833             "false 3 colorimage\n",
 834             w, w, xx, yy, ww, hh, w, h, w, -h, h );
 835
 836
 837     for (int j = 0; j < h; j++)
 838     {
 839         for (int i = 0; i < w; i++)
 840         {
 841             char buffer[5];
 842             LocalDecToHex( image.GetRed(i,j), buffer );
 843             fprintf( m_pstream, buffer );
 844             LocalDecToHex( image.GetGreen(i,j), buffer );
 845             fprintf( m_pstream, buffer );
 846             LocalDecToHex( image.GetBlue(i,j), buffer );
 847             fprintf( m_pstream, buffer );
 848         }
 849         fprintf( m_pstream, "\n" );
 850     }
 851
 852     fprintf( m_pstream, "end\n" );
 853     fprintf( m_pstream, "origstate restore\n" );
 854 }
 855
 856 void wxPostScriptDC::SetFont( const wxFont& font )
 857 {
 858     wxCHECK_RET( m_ok && m_pstream, wxT("invalid postscript dc") );
 859
 860     if (!font.Ok())  return;
 861
 862     m_font = font;
 863
 864 #ifndef __WXGTK20__
 865     int Style = m_font.GetStyle();
 866     int Weight = m_font.GetWeight();
 867
 868     const char *name;
 869     switch (m_font.GetFamily())
 870     {
 871         case wxTELETYPE:
 872         case wxMODERN:
 873         {
 874             if (Style == wxITALIC)
 875             {
 876                 if (Weight == wxBOLD)
 877                     name = "/Courier-BoldOblique";
 878                 else
 879                     name = "/Courier-Oblique";
 880             }
 881             else
 882             {
 883                 if (Weight == wxBOLD)
 884                     name = "/Courier-Bold";
 885                 else
 886                     name = "/Courier";
 887             }
 888             break;
 889         }
 890         case wxROMAN:
 891         {
 892             if (Style == wxITALIC)
 893             {
 894                 if (Weight == wxBOLD)
 895                     name = "/Times-BoldItalic";
 896                 else
 897                     name = "/Times-Italic";
 898             }
 899             else
 900             {
 901                 if (Weight == wxBOLD)
 902                     name = "/Times-Bold";
 903                 else
 904                     name = "/Times-Roman";
 905             }
 906             break;
 907         }
 908         case wxSCRIPT:
 909         {
 910             name = "/ZapfChancery-MediumItalic";
 911             Style  = wxNORMAL;
 912             Weight = wxNORMAL;
 913             break;
 914         }
 915         case wxSWISS:
 916         default:
 917         {
 918             if (Style == wxITALIC)
 919             {
 920                 if (Weight == wxBOLD)
 921                     name = "/Helvetica-BoldOblique";
 922                 else
 923                     name = "/Helvetica-Oblique";
 924             }
 925             else
 926             {
 927                 if (Weight == wxBOLD)
 928                     name = "/Helvetica-Bold";
 929                 else
 930                     name = "/Helvetica";
 931             }
 932             break;
 933         }
 934     }
 935
 936     fprintf( m_pstream, name );
 937     fprintf( m_pstream, " reencodeISO def\n" );
 938     fprintf( m_pstream, name );
 939     fprintf( m_pstream, " findfont\n" );
 940
 941     char buffer[100];
 942     sprintf( buffer, "%f scalefont setfont\n", LogicalToDeviceYRel(m_font.GetPointSize() * 1000) / 1000.0F);
 943                 // this is a hack - we must scale font size (in pts) according to m_scaleY but
 944                 // LogicalToDeviceYRel works with wxCoord type (int or longint). Se we first convert font size
 945                 // to 1/1000th of pt and then back.
 946     for (int i = 0; i < 100; i++)
 947         if (buffer[i] == ',') buffer[i] = '.';
 948     fprintf( m_pstream, buffer );
 949 #endif
 950 }
 951
 952 void wxPostScriptDC::SetPen( const wxPen& pen )
 953 {
 954     wxCHECK_RET( m_ok && m_pstream, wxT("invalid postscript dc") );
 955
 956     if (!pen.Ok()) return;
 957
 958     int oldStyle = m_pen.GetStyle();
 959
 960     m_pen = pen;
 961
 962     {
 963         char buffer[100];
 964         #ifdef __WXMSW__
 965         sprintf( buffer, "%f setlinewidth\n", LogicalToDeviceXRel(1000 * m_pen.GetWidth()) / 1000.0f );
 966         #else
 967         sprintf( buffer, "%f setlinewidth\n", LogicalToDeviceXRel(1000 * m_pen.GetWidth()) / 1000.0f );
 968         #endif
 969         for (int i = 0; i < 100; i++)
 970             if (buffer[i] == ',') buffer[i] = '.';
 971         fprintf( m_pstream, buffer );
 972     }
 973
 974 /*
 975      Line style - WRONG: 2nd arg is OFFSET
 976
 977      Here, I'm afraid you do not conceive meaning of parameters of 'setdash'
 978      operator correctly. You should look-up this in the Red Book: the 2nd parame-
 979      ter is not number of values in the array of the first one, but an offset
 980      into this description of the pattern. I mean a real *offset* not index
 981      into array. I.e. If the command is [3 4] 1 setdash   is used, then there
 982      will be first black line *2* units wxCoord, then space 4 units, then the
 983      pattern of *3* units black, 4 units space will be repeated.
 984 */
 985
 986     static const char *dotted = "[2 5] 2";
 987     static const char *short_dashed = "[4 4] 2";
 988     static const char *wxCoord_dashed = "[4 8] 2";
 989     static const char *dotted_dashed = "[6 6 2 6] 4";
 990
 991     const char *psdash = (char *) NULL;
 992     switch (m_pen.GetStyle())
 993     {
 994         case wxDOT:           psdash = dotted;         break;
 995         case wxSHORT_DASH:    psdash = short_dashed;   break;
 996         case wxLONG_DASH:     psdash = wxCoord_dashed;    break;
 997         case wxDOT_DASH:      psdash = dotted_dashed;  break;
 998         case wxSOLID:
 999         case wxTRANSPARENT:
1000         default:              psdash = "[] 0";         break;
1001     }
1002
1003     if (oldStyle != m_pen.GetStyle())
1004     {
1005         fprintf( m_pstream, psdash );
1006         fprintf( m_pstream," setdash\n" );
1007     }
1008
1009     // Line colour
1010     unsigned char red = m_pen.GetColour().Red();
1011     unsigned char blue = m_pen.GetColour().Blue();
1012     unsigned char green = m_pen.GetColour().Green();
1013
1014     if (!m_colour)
1015     {
1016         // Anything not white is black
1017         if (! (red == (unsigned char) 255 &&
1018                blue == (unsigned char) 255 &&
1019                green == (unsigned char) 255) )
1020         {
1021             red = (unsigned char) 0;
1022             green = (unsigned char) 0;
1023             blue = (unsigned char) 0;
1024         }
1025         // setgray here ?
1026     }
1027
1028     if (!(red == m_currentRed && green == m_currentGreen && blue == m_currentBlue))
1029     {
1030         double redPS = (double)(red) / 255.0;
1031         double bluePS = (double)(blue) / 255.0;
1032         double greenPS = (double)(green) / 255.0;
1033
1034         char buffer[100];
1035         sprintf( buffer,
1036                 "%.8f %.8f %.8f setrgbcolor\n",
1037                 redPS, greenPS, bluePS );
1038         for (int i = 0; i < 100; i++)
1039             if (buffer[i] == ',') buffer[i] = '.';
1040         fprintf( m_pstream, buffer );
1041
1042         m_currentRed = red;
1043         m_currentBlue = blue;
1044         m_currentGreen = green;
1045     }
1046 }
1047
1048 void wxPostScriptDC::SetBrush( const wxBrush& brush )
1049 {
1050     wxCHECK_RET( m_ok && m_pstream, wxT("invalid postscript dc") );
1051
1052     if (!brush.Ok()) return;
1053
1054     m_brush = brush;
1055
1056     // Brush colour
1057     unsigned char red = m_brush.GetColour().Red();
1058     unsigned char blue = m_brush.GetColour().Blue();
1059     unsigned char green = m_brush.GetColour().Green();
1060
1061     if (!m_colour)
1062     {
1063         // Anything not white is black
1064         if (! (red == (unsigned char) 255 &&
1065                blue == (unsigned char) 255 &&
1066                green == (unsigned char) 255) )
1067         {
1068             red = (unsigned char) 0;
1069             green = (unsigned char) 0;
1070             blue = (unsigned char) 0;
1071         }
1072         // setgray here ?
1073     }
1074
1075     if (!(red == m_currentRed && green == m_currentGreen && blue == m_currentBlue))
1076     {
1077         double redPS = (double)(red) / 255.0;
1078         double bluePS = (double)(blue) / 255.0;
1079         double greenPS = (double)(green) / 255.0;
1080
1081         char buffer[100];
1082         sprintf( buffer,
1083                 "%.8f %.8f %.8f setrgbcolor\n",
1084                 redPS, greenPS, bluePS );
1085         for (int i = 0; i < 100; i++)
1086             if (buffer[i] == ',') buffer[i] = '.';
1087         fprintf( m_pstream, buffer );
1088
1089         m_currentRed = red;
1090         m_currentBlue = blue;
1091         m_currentGreen = green;
1092     }
1093 }
1094
1095 #ifdef __WXGTK20__
1096
1097 #define PANGO_ENABLE_ENGINE
1098
1099 #include "wx/gtk/private.h"
1100 #include "wx/fontutil.h"
1101 #include "gtk/gtk.h"
1102 #include <pango/pangoft2.h>
1103 #include <freetype/ftglyph.h>
1104
1105 #ifndef FT_Outline_Decompose
1106   FT_EXPORT( FT_Error )  FT_Outline_Decompose(
1107                            FT_Outline*              outline,
1108                            const FT_Outline_Funcs*  interface,
1109                            void*                    user );
1110 #endif
1111
1112 typedef struct _OutlineInfo OutlineInfo;
1113 struct _OutlineInfo {
1114   FILE *file;
1115 };
1116
1117 static int paps_move_to( FT_Vector* to,
1118                          void *user_data)
1119 {
1120   OutlineInfo *outline_info = (OutlineInfo*)user_data;
1121   fprintf(outline_info->file, "%d %d moveto\n",
1122           (int)to->x ,
1123           (int)to->y );
1124   return 0;
1125 }
1126
1127 static int paps_line_to( FT_Vector*  to,
1128                          void *user_data)
1129 {
1130   OutlineInfo *outline_info = (OutlineInfo*)user_data;
1131   fprintf(outline_info->file, "%d %d lineto\n",
1132           (int)to->x ,
1133           (int)to->y );
1134   return 0;
1135 }
1136
1137 static int paps_conic_to( FT_Vector*  control,
1138                           FT_Vector*  to,
1139                           void *user_data)
1140 {
1141   OutlineInfo *outline_info = (OutlineInfo*)user_data;
1142   fprintf(outline_info->file, "%d %d %d %d conicto\n",
1143           (int)control->x  ,
1144           (int)control->y  ,
1145           (int)to->x   ,
1146           (int)to->y  );
1147   return 0;
1148 }
1149
1150 static int paps_cubic_to( FT_Vector*  control1,
1151                           FT_Vector*  control2,
1152                           FT_Vector*  to,
1153                           void *user_data)
1154 {
1155   OutlineInfo *outline_info = (OutlineInfo*)user_data;
1156   fprintf(outline_info->file,
1157           "%d %d %d %d %d %d curveto\n",
1158           (int)control1->x ,
1159           (int)control1->y ,
1160           (int)control2->x ,
1161           (int)control2->y ,
1162           (int)to->x ,
1163           (int)to->y );
1164   return 0;
1165 }
1166
1167 void draw_bezier_outline(FILE *file,
1168                          FT_Face face,
1169                          FT_UInt glyph_index,
1170                          int pos_x,
1171                          int pos_y,
1172              int scale_x,
1173              int scale_y )
1174 {
1175   FT_Int load_flags = FT_LOAD_NO_BITMAP;
1176   FT_Glyph glyph;
1177
1178   FT_Outline_Funcs outlinefunc =
1179   {
1180     paps_move_to,
1181     paps_line_to,
1182     paps_conic_to,
1183     paps_cubic_to
1184   };
1185
1186   OutlineInfo outline_info;
1187   outline_info.file = file;
1188
1189   fprintf(file, "gsave\n");
1190   fprintf(file, "%d %d translate\n", pos_x, pos_y );
1191   // FT2 scales outlines to 26.6 pixels so the code below
1192   // should read 26600 instead of the 60000.
1193   fprintf(file, "%d 60000 div %d 60000 div scale\n", scale_x, scale_y );
1194   fprintf(file, "0 0 0 setrgbcolor\n");
1195
1196   FT_Load_Glyph(face, glyph_index, load_flags);
1197   FT_Get_Glyph (face->glyph, &glyph);
1198   FT_Outline_Decompose (&(((FT_OutlineGlyph)glyph)->outline),
1199                         &outlinefunc, &outline_info);
1200   fprintf(file, "closepath fill grestore \n");
1201
1202   FT_Done_Glyph (glyph);
1203 }
1204
1205 #endif
1206
1207 void wxPostScriptDC::DoDrawText( const wxString& text, wxCoord x, wxCoord y )
1208 {
1209     wxCHECK_RET( m_ok && m_pstream, wxT("invalid postscript dc") );
1210
1211 #ifdef __WXGTK20__
1212     int dpi = GetResolution();
1213     dpi = 300;
1214     PangoContext *context = pango_ft2_get_context ( dpi, dpi );
1215
1216     pango_context_set_language (context, pango_language_from_string ("en_US"));
1217     pango_context_set_base_dir (context, PANGO_DIRECTION_LTR );
1218
1219     pango_context_set_font_description (context, m_font.GetNativeFontInfo()->description );
1220
1221     PangoLayout *layout = pango_layout_new (context);
1222 #if wxUSE_UNICODE
1223     wxCharBuffer buffer = wxConvUTF8.cWC2MB( text );
1224 #else
1225     wxCharBuffer buffer = wxConvUTF8.cWC2MB( wxConvLocal.cWX2WC( text ) );
1226 #endif
1227         pango_layout_set_text( layout, (const char*) buffer, strlen(buffer) );
1228
1229     PangoRectangle rect;
1230     pango_layout_get_extents(layout, NULL, &rect);
1231
1232     int xx = x * PANGO_SCALE;
1233     int yy = y * PANGO_SCALE + (rect.height*2/3);
1234
1235     int scale_x = LogicalToDeviceXRel( 1000 );
1236     int scale_y = LogicalToDeviceYRel( 1000 );
1237
1238     // Loop over lines in layout
1239     int num_lines = pango_layout_get_line_count( layout );
1240     for (int i = 0; i < num_lines; i++)
1241     {
1242         PangoLayoutLine *line = pango_layout_get_line( layout, i );
1243
1244         // Loop over runs in line
1245         GSList *runs_list = line->runs;
1246         while (runs_list)
1247         {
1248             PangoLayoutRun *run = (PangoLayoutRun*) runs_list->data;
1249             PangoItem *item = run->item;
1250             PangoGlyphString *glyphs = run->glyphs;
1251             PangoAnalysis *analysis = &item->analysis;
1252             PangoFont *font = analysis->font;
1253             FT_Face ft_face = pango_ft2_font_get_face(font);
1254
1255             int num_glyphs = glyphs->num_glyphs;
1256             for (int glyph_idx = 0; glyph_idx < num_glyphs; glyph_idx++)
1257             {
1258                 PangoGlyphGeometry geometry = glyphs->glyphs[glyph_idx].geometry;
1259                 int pos_x = xx + geometry.x_offset;
1260                 int pos_y = yy - geometry.y_offset;
1261                 xx += geometry.width;
1262
1263                 draw_bezier_outline( m_pstream, ft_face,
1264                               (FT_UInt)(glyphs->glyphs[glyph_idx].glyph),
1265                               LogicalToDeviceX( pos_x / PANGO_SCALE ),
1266                   LogicalToDeviceY( pos_y / PANGO_SCALE ),
1267                   scale_x, scale_y );
1268             }
1269             runs_list = runs_list->next;
1270         }
1271         }
1272
1273     g_object_unref( G_OBJECT( layout ) );
1274 #else
1275     wxCoord text_w, text_h, text_descent;
1276
1277     GetTextExtent(text, &text_w, &text_h, &text_descent);
1278
1279     // VZ: this seems to be unnecessary, so taking it out for now, if it
1280     //     doesn't create any problems, remove this comment entirely
1281     //SetFont( m_font );
1282
1283     if (m_textForegroundColour.Ok())
1284     {
1285         unsigned char red = m_textForegroundColour.Red();
1286         unsigned char blue = m_textForegroundColour.Blue();
1287         unsigned char green = m_textForegroundColour.Green();
1288
1289         if (!m_colour)
1290         {
1291             // Anything not white is black
1292             if (! (red == (unsigned char) 255 &&
1293                         blue == (unsigned char) 255 &&
1294                         green == (unsigned char) 255))
1295             {
1296                 red = (unsigned char) 0;
1297                 green = (unsigned char) 0;
1298                 blue = (unsigned char) 0;
1299             }
1300         }
1301
1302         // maybe setgray here ?
1303         if (!(red == m_currentRed && green == m_currentGreen && blue == m_currentBlue))
1304         {
1305             double redPS = (double)(red) / 255.0;
1306             double bluePS = (double)(blue) / 255.0;
1307             double greenPS = (double)(green) / 255.0;
1308
1309             char buffer[100];
1310             sprintf( buffer,
1311                 "%.8f %.8f %.8f setrgbcolor\n",
1312                 redPS, greenPS, bluePS );
1313             for (int i = 0; i < 100; i++)
1314                 if (buffer[i] == ',') buffer[i] = '.';
1315             fprintf( m_pstream, buffer );
1316
1317             m_currentRed = red;
1318             m_currentBlue = blue;
1319             m_currentGreen = green;
1320         }
1321     }
1322
1323     int size = m_font.GetPointSize();
1324
1325 //    wxCoord by = y + (wxCoord)floor( double(size) * 2.0 / 3.0 ); // approximate baseline
1326 //    commented by V. Slavik and replaced by accurate version
1327 //        - note that there is still rounding error in text_descent!
1328     wxCoord by = y + size - text_descent; // baseline
1329     fprintf( m_pstream, "%d %d moveto\n", LogicalToDeviceX(x), LogicalToDeviceY(by) );
1330
1331     fprintf( m_pstream, "(" );
1332     const wxWX2MBbuf textbuf = text.mb_str();
1333     size_t len = strlen(textbuf);
1334     size_t i;
1335     for (i = 0; i < len; i++)
1336     {
1337         int c = (unsigned char) textbuf[i];
1338         if (c == ')' || c == '(' || c == '\\')
1339         {
1340             /* Cope with special characters */
1341             fprintf( m_pstream, "\\" );
1342             fputc(c, m_pstream);
1343         }
1344         else if ( c >= 128 )
1345         {
1346             /* Cope with character codes > 127 */
1347             fprintf(m_pstream, "\\%o", c);
1348         }
1349         else
1350         {
1351             fputc(c, m_pstream);
1352         }
1353     }
1354
1355     fprintf( m_pstream, ") show\n" );
1356
1357     if (m_font.GetUnderlined())
1358     {
1359         wxCoord uy = (wxCoord)(y + size - m_underlinePosition);
1360         char buffer[100];
1361
1362         sprintf( buffer,
1363                 "gsave\n"
1364                 "%d %d moveto\n"
1365                 "%f setlinewidth\n"
1366                 "%d %d lineto\n"
1367                 "stroke\n"
1368                 "grestore\n",
1369                 LogicalToDeviceX(x), LogicalToDeviceY(uy),
1370                 m_underlineThickness,
1371                 LogicalToDeviceX(x + text_w), LogicalToDeviceY(uy) );
1372         for (i = 0; i < 100; i++)
1373             if (buffer[i] == ',') buffer[i] = '.';
1374         fprintf( m_pstream, buffer );
1375     }
1376
1377     CalcBoundingBox( x, y );
1378     CalcBoundingBox( x + size * text.Length() * 2/3 , y );
1379 #endif
1380 }
1381
1382 void wxPostScriptDC::DoDrawRotatedText( const wxString& text, wxCoord x, wxCoord y, double angle )
1383 {
1384     if (angle == 0.0)
1385     {
1386         DoDrawText(text, x, y);
1387         return;
1388     }
1389
1390     wxCHECK_RET( m_ok && m_pstream, wxT("invalid postscript dc") );
1391
1392     SetFont( m_font );
1393
1394     if (m_textForegroundColour.Ok())
1395     {
1396         unsigned char red = m_textForegroundColour.Red();
1397         unsigned char blue = m_textForegroundColour.Blue();
1398         unsigned char green = m_textForegroundColour.Green();
1399
1400         if (!m_colour)
1401         {
1402             // Anything not white is black
1403             if (! (red == (unsigned char) 255 &&
1404                    blue == (unsigned char) 255 &&
1405                    green == (unsigned char) 255))
1406             {
1407                 red = (unsigned char) 0;
1408                 green = (unsigned char) 0;
1409                 blue = (unsigned char) 0;
1410             }
1411         }
1412
1413         // maybe setgray here ?
1414         if (!(red == m_currentRed && green == m_currentGreen && blue == m_currentBlue))
1415         {
1416             double redPS = (double)(red) / 255.0;
1417             double bluePS = (double)(blue) / 255.0;
1418             double greenPS = (double)(green) / 255.0;
1419
1420             char buffer[100];
1421             sprintf( buffer,
1422                 "%.8f %.8f %.8f setrgbcolor\n",
1423                 redPS, greenPS, bluePS );
1424             for (int i = 0; i < 100; i++)
1425                 if (buffer[i] == ',') buffer[i] = '.';
1426             fprintf( m_pstream, buffer );
1427
1428             m_currentRed = red;
1429             m_currentBlue = blue;
1430             m_currentGreen = green;
1431         }
1432     }
1433
1434     int size = m_font.GetPointSize();
1435
1436     long by = y + (long)floor( double(size) * 2.0 / 3.0 ); // approximate baseline
1437
1438     // FIXME only correct for 90 degrees
1439     fprintf(m_pstream, "%d %d moveto\n",
1440             LogicalToDeviceX((wxCoord)(x + size)), LogicalToDeviceY((wxCoord)by) );
1441
1442     char buffer[100];
1443     sprintf(buffer, "%.8f rotate\n", angle);
1444     size_t i;
1445     for (i = 0; i < 100; i++)
1446         if (buffer[i] == ',') buffer[i] = '.';
1447     fprintf(m_pstream, buffer);
1448
1449     fprintf( m_pstream, "(" );
1450     const wxWX2MBbuf textbuf = text.mb_str();
1451     size_t len = strlen(textbuf);
1452     for (i = 0; i < len; i++)
1453     {
1454         int c = (unsigned char) textbuf[i];
1455         if (c == ')' || c == '(' || c == '\\')
1456         {
1457             /* Cope with special characters */
1458             fprintf( m_pstream, "\\" );
1459             fputc(c, m_pstream);
1460         }
1461         else if ( c >= 128 )
1462         {
1463             /* Cope with character codes > 127 */
1464             fprintf(m_pstream, "\\%o", c);
1465         }
1466         else
1467         {
1468             fputc(c, m_pstream);
1469         }
1470     }
1471
1472     fprintf( m_pstream, ") show\n" );
1473
1474     sprintf( buffer, "%.8f rotate\n", -angle );
1475     for (i = 0; i < 100; i++)
1476         if (buffer[i] == ',') buffer[i] = '.';
1477     fprintf( m_pstream, buffer );
1478
1479     if (m_font.GetUnderlined())
1480     {
1481         wxCoord uy = (wxCoord)(y + size - m_underlinePosition);
1482         wxCoord w, h;
1483         char buffer[100];
1484         GetTextExtent(text, &w, &h);
1485
1486         sprintf( buffer,
1487                  "gsave\n"
1488                  "%d %d moveto\n"
1489                  "%f setlinewidth\n"
1490                  "%d %d lineto\n"
1491                  "stroke\n"
1492                  "grestore\n",
1493                  LogicalToDeviceX(x), LogicalToDeviceY(uy),
1494                  m_underlineThickness,
1495                  LogicalToDeviceX(x + w), LogicalToDeviceY(uy) );
1496         for (i = 0; i < 100; i++)
1497             if (buffer[i] == ',') buffer[i] = '.';
1498         fprintf( m_pstream, buffer );
1499     }
1500
1501     CalcBoundingBox( x, y );
1502     CalcBoundingBox( x + size * text.Length() * 2/3 , y );
1503 }
1504
1505 void wxPostScriptDC::SetBackground (const wxBrush& brush)
1506 {
1507     m_backgroundBrush = brush;
1508 }
1509
1510 void wxPostScriptDC::SetLogicalFunction (int WXUNUSED(function))
1511 {
1512     wxFAIL_MSG( wxT("wxPostScriptDC::SetLogicalFunction not implemented.") );
1513 }
1514
1515 void wxPostScriptDC::DoDrawSpline( wxList *points )
1516 {
1517     wxCHECK_RET( m_ok && m_pstream, wxT("invalid postscript dc") );
1518
1519     SetPen( m_pen );
1520
1521     double a, b, c, d, x1, y1, x2, y2, x3, y3;
1522     wxPoint *p, *q;
1523
1524     wxNode *node = points->First();
1525     p = (wxPoint *)node->Data();
1526     x1 = p->x;
1527     y1 = p->y;
1528
1529     node = node->Next();
1530     p = (wxPoint *)node->Data();
1531     c = p->x;
1532     d = p->y;
1533     x3 = a = (double)(x1 + c) / 2;
1534     y3 = b = (double)(y1 + d) / 2;
1535
1536     fprintf( m_pstream,
1537             "newpath\n"
1538             "%d %d moveto\n"
1539             "%d %d lineto\n",
1540             LogicalToDeviceX((wxCoord)x1), LogicalToDeviceY((wxCoord)y1),
1541             LogicalToDeviceX((wxCoord)x3), LogicalToDeviceY((wxCoord)y3) );
1542
1543     CalcBoundingBox( (wxCoord)x1, (wxCoord)y1 );
1544     CalcBoundingBox( (wxCoord)x3, (wxCoord)y3 );
1545
1546     while ((node = node->Next()) != NULL)
1547     {
1548         q = (wxPoint *)node->Data();
1549
1550         x1 = x3;
1551         y1 = y3;
1552         x2 = c;
1553         y2 = d;
1554         c = q->x;
1555         d = q->y;
1556         x3 = (double)(x2 + c) / 2;
1557         y3 = (double)(y2 + d) / 2;
1558
1559         fprintf( m_pstream,
1560                 "%d %d %d %d %d %d DrawSplineSection\n",
1561                 LogicalToDeviceX((wxCoord)x1), LogicalToDeviceY((wxCoord)y1),
1562                 LogicalToDeviceX((wxCoord)x2), LogicalToDeviceY((wxCoord)y2),
1563                 LogicalToDeviceX((wxCoord)x3), LogicalToDeviceY((wxCoord)y3) );
1564
1565         CalcBoundingBox( (wxCoord)x1, (wxCoord)y1 );
1566         CalcBoundingBox( (wxCoord)x3, (wxCoord)y3 );
1567     }
1568
1569     /*
1570        At this point, (x2,y2) and (c,d) are the position of the
1571        next-to-last and last point respectively, in the point list
1572      */
1573
1574     fprintf( m_pstream,
1575             "%d %d lineto\n"
1576             "stroke\n",
1577             LogicalToDeviceX((wxCoord)c), LogicalToDeviceY((wxCoord)d) );
1578 }
1579
1580 wxCoord wxPostScriptDC::GetCharWidth() const
1581 {
1582     // Chris Breeze: reasonable approximation using wxMODERN/Courier
1583     return (wxCoord) (GetCharHeight() * 72.0 / 120.0);
1584 }
1585
1586
1587 void wxPostScriptDC::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
1588 {
1589     wxCHECK_RET( m_ok && m_pstream, wxT("invalid postscript dc") );
1590
1591     m_signX = (xLeftRight ? 1 : -1);
1592     m_signY = (yBottomUp  ? 1 : -1);
1593
1594     // FIXME there is no such function in MSW nor in OS2/PM
1595 #if !defined(__WXMSW__) && !defined(__WXPM__)
1596     ComputeScaleAndOrigin();
1597 #endif
1598 }
1599
1600 void wxPostScriptDC::SetDeviceOrigin( wxCoord x, wxCoord y )
1601 {
1602     wxCHECK_RET( m_ok && m_pstream, wxT("invalid postscript dc") );
1603
1604     int h = 0;
1605     int w = 0;
1606     GetSize( &w, &h );
1607
1608     wxDC::SetDeviceOrigin( x, h-y );
1609 }
1610
1611 void wxPostScriptDC::DoGetSize(int* width, int* height) const
1612 {
1613     wxPaperSize id = m_printData.GetPaperId();
1614
1615     wxPrintPaperType *paper = wxThePrintPaperDatabase->FindPaperType(id);
1616
1617     if (!paper) paper = wxThePrintPaperDatabase->FindPaperType(wxPAPER_A4);
1618
1619     int w = 595;
1620     int h = 842;
1621     if (paper)
1622     {
1623         w = paper->GetSizeDeviceUnits().x;
1624         h = paper->GetSizeDeviceUnits().y;
1625     }
1626
1627     if (m_printData.GetOrientation() == wxLANDSCAPE)
1628     {
1629         int tmp = w;
1630         w = h;
1631         h = tmp;
1632     }
1633
1634     if (width) *width = (int)(w * ms_PSScaleFactor);
1635     if (height) *height = (int)(h * ms_PSScaleFactor);
1636 }
1637
1638 void wxPostScriptDC::DoGetSizeMM(int *width, int *height) const
1639 {
1640     wxPaperSize id = m_printData.GetPaperId();
1641
1642     wxPrintPaperType *paper = wxThePrintPaperDatabase->FindPaperType(id);
1643
1644     if (!paper) paper = wxThePrintPaperDatabase->FindPaperType(wxPAPER_A4);
1645
1646     int w = 210;
1647     int h = 297;
1648     if (paper)
1649     {
1650         w = paper->GetWidth() / 10;
1651         h = paper->GetHeight() / 10;
1652     }
1653
1654     if (m_printData.GetOrientation() == wxLANDSCAPE)
1655     {
1656         int tmp = w;
1657         w = h;
1658         h = tmp;
1659     }
1660
1661     if (width) *width = w;
1662     if (height) *height = h;
1663 }
1664
1665 // Resolution in pixels per logical inch
1666 wxSize wxPostScriptDC::GetPPI(void) const
1667 {
1668     return wxSize((int)(72 * ms_PSScaleFactor),
1669                   (int)(72 * ms_PSScaleFactor));
1670 }
1671
1672
1673 bool wxPostScriptDC::StartDoc( const wxString& message )
1674 {
1675     wxCHECK_MSG( m_ok, FALSE, wxT("invalid postscript dc") );
1676
1677     if (m_printData.GetFilename() == "")
1678     {
1679         wxString filename = wxGetTempFileName("ps");
1680         m_printData.SetFilename(filename);
1681     }
1682
1683     m_pstream = wxFopen( m_printData.GetFilename().c_str(), wxT("w+") );  // FIXME: use fn_str() here under Unicode?
1684
1685     if (!m_pstream)
1686     {
1687         wxLogError( _("Cannot open file for PostScript printing!"));
1688         m_ok = FALSE;
1689         return FALSE;
1690     }
1691
1692     m_ok = TRUE;
1693
1694     fprintf( m_pstream, "%%!PS-Adobe-2.0\n" );
1695     fprintf( m_pstream, "%%%%Title: %s\n", (const char *) m_title.ToAscii() );
1696     fprintf( m_pstream, "%%%%Creator: wxWindows PostScript renderer\n" );
1697     fprintf( m_pstream, "%%%%CreationDate: %s\n", (const char *) wxNow().ToAscii() );
1698     if (m_printData.GetOrientation() == wxLANDSCAPE)
1699         fprintf( m_pstream, "%%%%Orientation: Landscape\n" );
1700     else
1701         fprintf( m_pstream, "%%%%Orientation: Portrait\n" );
1702
1703     // fprintf( m_pstream, "%%%%Pages: %d\n", (wxPageNumber - 1) );
1704
1705     char *paper = "A4";
1706     switch (m_printData.GetPaperId())
1707     {
1708        case wxPAPER_LETTER: paper = "Letter"; break;             // Letter: paper ""; 8 1/2 by 11 inches
1709        case wxPAPER_LEGAL: paper = "Legal"; break;              // Legal, 8 1/2 by 14 inches
1710        case wxPAPER_A4: paper = "A4"; break;          // A4 Sheet, 210 by 297 millimeters
1711        case wxPAPER_TABLOID: paper = "Tabloid"; break;     // Tabloid, 11 by 17 inches
1712        case wxPAPER_LEDGER: paper = "Ledger"; break;      // Ledger, 17 by 11 inches
1713        case wxPAPER_STATEMENT: paper = "Statement"; break;   // Statement, 5 1/2 by 8 1/2 inches
1714        case wxPAPER_EXECUTIVE: paper = "Executive"; break;   // Executive, 7 1/4 by 10 1/2 inches
1715        case wxPAPER_A3: paper = "A3"; break;          // A3 sheet, 297 by 420 millimeters
1716        case wxPAPER_A5: paper = "A5"; break;          // A5 sheet, 148 by 210 millimeters
1717        case wxPAPER_B4: paper = "B4"; break;          // B4 sheet, 250 by 354 millimeters
1718        case wxPAPER_B5: paper = "B5"; break;          // B5 sheet, 182-by-257-millimeter paper
1719        case wxPAPER_FOLIO: paper = "Folio"; break;       // Folio, 8-1/2-by-13-inch paper
1720        case wxPAPER_QUARTO: paper = "Quaro"; break;      // Quarto, 215-by-275-millimeter paper
1721        case wxPAPER_10X14: paper = "10x14"; break;       // 10-by-14-inch sheet
1722        default: paper = "A4";
1723     }
1724     fprintf( m_pstream, "%%%%DocumentPaperSizes: %s\n", paper );
1725     fprintf( m_pstream, "%%%%EndComments\n\n" );
1726
1727     fprintf( m_pstream, "%%%%BeginProlog\n" );
1728     fprintf( m_pstream, wxPostScriptHeaderConicTo );
1729     fprintf( m_pstream, wxPostScriptHeaderEllipse );
1730     fprintf( m_pstream, wxPostScriptHeaderEllipticArc );
1731     fprintf( m_pstream, wxPostScriptHeaderColourImage );
1732 #ifndef __WXGTK20__
1733     fprintf( m_pstream, wxPostScriptHeaderReencodeISO1 );
1734     fprintf( m_pstream, wxPostScriptHeaderReencodeISO2 );
1735 #endif
1736     if (wxPostScriptHeaderSpline)
1737         fprintf( m_pstream, wxPostScriptHeaderSpline );
1738     fprintf( m_pstream, "%%%%EndProlog\n" );
1739
1740     SetBrush( *wxBLACK_BRUSH );
1741     SetPen( *wxBLACK_PEN );
1742     SetBackground( *wxWHITE_BRUSH );
1743     SetTextForeground( *wxBLACK );
1744
1745     // set origin according to paper size
1746     SetDeviceOrigin( 0,0 );
1747
1748     wxPageNumber = 1;
1749     m_pageNumber = 1;
1750     m_title = message;
1751     return TRUE;
1752 }
1753
1754 void wxPostScriptDC::EndDoc ()
1755 {
1756     wxCHECK_RET( m_ok && m_pstream, wxT("invalid postscript dc") );
1757
1758     if (m_clipping)
1759     {
1760         m_clipping = FALSE;
1761         fprintf( m_pstream, "grestore\n" );
1762     }
1763
1764     fclose( m_pstream );
1765     m_pstream = (FILE *) NULL;
1766
1767 #if 0
1768     // THE FOLLOWING HAS BEEN CONTRIBUTED BY Andy Fyfe <andy@hyperparallel.com>
1769     wxCoord wx_printer_translate_x, wx_printer_translate_y;
1770     double wx_printer_scale_x, wx_printer_scale_y;
1771
1772     wx_printer_translate_x = (wxCoord)m_printData.GetPrinterTranslateX();
1773     wx_printer_translate_y = (wxCoord)m_printData.GetPrinterTranslateY();
1774
1775     wx_printer_scale_x = m_printData.GetPrinterScaleX();
1776     wx_printer_scale_y = m_printData.GetPrinterScaleY();
1777
1778     // Compute the bounding box.  Note that it is in the default user
1779     // coordinate system, thus we have to convert the values.
1780     wxCoord minX = (wxCoord) LogicalToDeviceX(m_minX);
1781     wxCoord minY = (wxCoord) LogicalToDeviceY(m_minY);
1782     wxCoord maxX = (wxCoord) LogicalToDeviceX(m_maxX);
1783     wxCoord maxY = (wxCoord) LogicalToDeviceY(m_maxY);
1784
1785     // LOG2DEV may have changed the minimum to maximum vice versa
1786     if ( minX > maxX ) { wxCoord tmp = minX; minX = maxX; maxX = tmp; }
1787     if ( minY > maxY ) { wxCoord tmp = minY; minY = maxY; maxY = tmp; }
1788
1789     // account for used scaling (boundingbox is before scaling in ps-file)
1790     double scale_x = m_printData.GetPrinterScaleX() / ms_PSScaleFactor;
1791     double scale_y = m_printData.GetPrinterScaleY() / ms_PSScaleFactor;
1792
1793     wxCoord llx, lly, urx, ury;
1794     llx = (wxCoord) ((minX+wx_printer_translate_x)*scale_x);
1795     lly = (wxCoord) ((minY+wx_printer_translate_y)*scale_y);
1796     urx = (wxCoord) ((maxX+wx_printer_translate_x)*scale_x);
1797     ury = (wxCoord) ((maxY+wx_printer_translate_y)*scale_y);
1798     // (end of bounding box computation)
1799
1800
1801     // If we're landscape, our sense of "x" and "y" is reversed.
1802     if (m_printData.GetOrientation() == wxLANDSCAPE)
1803     {
1804         wxCoord tmp;
1805         tmp = llx; llx = lly; lly = tmp;
1806         tmp = urx; urx = ury; ury = tmp;
1807
1808         // We need either the two lines that follow, or we need to subtract
1809         // min_x from real_translate_y, which is commented out below.
1810         llx = llx - (wxCoord)(m_minX*wx_printer_scale_y);
1811         urx = urx - (wxCoord)(m_minX*wx_printer_scale_y);
1812     }
1813
1814     // The Adobe specifications call for integers; we round as to make
1815     // the bounding larger.
1816     fprintf( m_pstream,
1817             "%%%%BoundingBox: %d %d %d %d\n",
1818             (wxCoord)floor((double)llx), (wxCoord)floor((double)lly),
1819             (wxCoord)ceil((double)urx), (wxCoord)ceil((double)ury) );
1820
1821     // To check the correctness of the bounding box, postscript commands
1822     // to draw a box corresponding to the bounding box are generated below.
1823     // But since we typically don't want to print such a box, the postscript
1824     // commands are generated within comments.  These lines appear before any
1825     // adjustment of scale, rotation, or translation, and hence are in the
1826     // default user coordinates.
1827     fprintf( m_pstream, "%% newpath\n" );
1828     fprintf( m_pstream, "%% %d %d moveto\n", llx, lly );
1829     fprintf( m_pstream, "%% %d %d lineto\n", urx, lly );
1830     fprintf( m_pstream, "%% %d %d lineto\n", urx, ury );
1831     fprintf( m_pstream, "%% %d %d lineto closepath stroke\n", llx, ury );
1832 #endif
1833
1834 #if defined(__X__) || defined(__WXGTK__)
1835     if (m_ok && (m_printData.GetPrintMode() == wxPRINT_MODE_PRINTER))
1836     {
1837         wxString command;
1838         command += m_printData.GetPrinterCommand();
1839         command += wxT(" ");
1840         command += m_printData.GetFilename();
1841
1842         wxExecute( command, TRUE );
1843         wxRemoveFile( m_printData.GetFilename() );
1844     }
1845 #endif
1846 }
1847
1848 void wxPostScriptDC::StartPage()
1849 {
1850     wxCHECK_RET( m_ok && m_pstream, wxT("invalid postscript dc") );
1851
1852     fprintf( m_pstream, "%%%%Page: %d\n", wxPageNumber++ );
1853
1854     //  What is this one supposed to do? RR.
1855 //  *m_pstream << "matrix currentmatrix\n";
1856
1857     // Added by Chris Breeze
1858
1859     // Each page starts with an "initgraphics" which resets the
1860     // transformation and so we need to reset the origin
1861     // (and rotate the page for landscape printing)
1862
1863     // Output scaling
1864     wxCoord translate_x, translate_y;
1865     double scale_x, scale_y;
1866
1867     translate_x = (wxCoord)m_printData.GetPrinterTranslateX();
1868     translate_y = (wxCoord)m_printData.GetPrinterTranslateY();
1869
1870     scale_x = m_printData.GetPrinterScaleX();
1871     scale_y = m_printData.GetPrinterScaleY();
1872
1873     if (m_printData.GetOrientation() == wxLANDSCAPE)
1874     {
1875         int h;
1876         GetSize( (int*) NULL, &h );
1877         translate_y -= h;
1878         fprintf( m_pstream, "90 rotate\n" );
1879
1880         // I copied this one from a PostScript tutorial, but to no avail. RR.
1881         // fprintf( m_pstream, "90 rotate llx neg ury nef translate\n" );
1882     }
1883
1884     char buffer[100];
1885     sprintf( buffer, "%.8f %.8f scale\n", scale_x / ms_PSScaleFactor,
1886                                           scale_y / ms_PSScaleFactor);
1887     for (int i = 0; i < 100; i++)
1888         if (buffer[i] == ',') buffer[i] = '.';
1889     fprintf( m_pstream, buffer );
1890
1891     fprintf( m_pstream, "%d %d translate\n", translate_x, translate_y );
1892 }
1893
1894 void wxPostScriptDC::EndPage ()
1895 {
1896     wxCHECK_RET( m_ok && m_pstream, wxT("invalid postscript dc") );
1897
1898     fprintf( m_pstream, "showpage\n" );
1899 }
1900
1901 bool wxPostScriptDC::DoBlit( wxCoord xdest, wxCoord ydest,
1902                            wxCoord fwidth, wxCoord fheight,
1903                            wxDC *source,
1904                            wxCoord xsrc, wxCoord ysrc,
1905                            int rop, bool WXUNUSED(useMask), wxCoord WXUNUSED(xsrcMask), wxCoord WXUNUSED(ysrcMask) )
1906 {
1907     wxCHECK_MSG( m_ok && m_pstream, FALSE, wxT("invalid postscript dc") );
1908
1909     wxCHECK_MSG( source, FALSE, wxT("invalid source dc") );
1910
1911     /* blit into a bitmap */
1912     wxBitmap bitmap( (int)fwidth, (int)fheight );
1913     wxMemoryDC memDC;
1914     memDC.SelectObject(bitmap);
1915     memDC.Blit(0, 0, fwidth, fheight, source, xsrc, ysrc, rop); /* TODO: Blit transparently? */
1916     memDC.SelectObject(wxNullBitmap);
1917
1918     /* draw bitmap. scaling and positioning is done there */
1919     DrawBitmap( bitmap, xdest, ydest );
1920
1921     return TRUE;
1922 }
1923
1924 wxCoord wxPostScriptDC::GetCharHeight() const
1925 {
1926     if (m_font.Ok())
1927         return m_font.GetPointSize();
1928     else
1929         return 12;
1930 }
1931
1932 void wxPostScriptDC::DoGetTextExtent(const wxString& string,
1933                                      wxCoord *x, wxCoord *y,
1934                                      wxCoord *descent, wxCoord *externalLeading,
1935                                      wxFont *theFont ) const
1936 {
1937     wxFont *fontToUse = theFont;
1938
1939     if (!fontToUse) fontToUse = (wxFont*) &m_font;
1940
1941     wxCHECK_RET( fontToUse, wxT("GetTextExtent: no font defined") );
1942
1943     if (string.IsEmpty())
1944     {
1945         if (x) (*x) = 0;
1946         if (y) (*y) = 0;
1947         return;
1948     }
1949
1950 #ifdef __WXGTK20__
1951     int dpi = GetResolution();
1952     PangoContext *context = pango_ft2_get_context ( dpi, dpi );
1953
1954     pango_context_set_language (context, pango_language_from_string ("en_US"));
1955     pango_context_set_base_dir (context, PANGO_DIRECTION_LTR );
1956
1957     PangoLayout *layout = pango_layout_new (context);
1958
1959     PangoFontDescription *desc = fontToUse->GetNativeFontInfo()->description;
1960     pango_layout_set_font_description(layout, desc);
1961 #if wxUSE_UNICODE
1962         const wxCharBuffer data = wxConvUTF8.cWC2MB( string );
1963         pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));
1964 #else
1965         const wxWCharBuffer wdata = wxConvLocal.cMB2WC( string );
1966         const wxCharBuffer data = wxConvUTF8.cWC2MB( wdata );
1967         pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));
1968 #endif
1969     PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
1970
1971     PangoRectangle rect;
1972     pango_layout_line_get_extents(line, NULL, &rect);
1973
1974     if (x) (*x) = (wxCoord) ( m_scaleX * rect.width / PANGO_SCALE );
1975     if (y) (*y) = (wxCoord) ( m_scaleY * rect.height / PANGO_SCALE );
1976     if (descent)
1977     {
1978         // Do something about metrics here
1979         (*descent) = 0;
1980     }
1981     if (externalLeading) (*externalLeading) = 0;  // ??
1982
1983     g_object_unref( G_OBJECT( layout ) );
1984 #else
1985    // GTK 2.0
1986
1987     const wxWX2MBbuf strbuf = string.mb_str();
1988
1989 #if !wxUSE_AFM_FOR_POSTSCRIPT
1990     /* Provide a VERY rough estimate (avoid using it).
1991      * Produces accurate results for mono-spaced font
1992      * such as Courier (aka wxMODERN) */
1993
1994     int height = 12;
1995     if (fontToUse)
1996     {
1997         height = fontToUse->GetPointSize();
1998     }
1999     if ( x )
2000         *x = strlen (strbuf) * height * 72 / 120;
2001     if ( y )
2002         *y = (wxCoord) (height * 1.32);    /* allow for descender */
2003     if (descent) *descent = 0;
2004     if (externalLeading) *externalLeading = 0;
2005 #else
2006
2007     /* method for calculating string widths in postscript:
2008     /  read in the AFM (adobe font metrics) file for the
2009     /  actual font, parse it and extract the character widths
2010     /  and also the descender. this may be improved, but for now
2011     /  it works well. the AFM file is only read in if the
2012     /  font is changed. this may be chached in the future.
2013     /  calls to GetTextExtent with the font unchanged are rather
2014     /  efficient!!!
2015     /
2016     /  for each font and style used there is an AFM file necessary.
2017     /  currently i have only files for the roman font family.
2018     /  I try to get files for the other ones!
2019     /
2020     /  CAVE: the size of the string is currently always calculated
2021     /        in 'points' (1/72 of an inch). this should later on be
2022     /        changed to depend on the mapping mode.
2023     /  CAVE: the path to the AFM files must be set before calling this
2024     /        function. this is usually done by a call like the following:
2025     /        wxSetAFMPath("d:\\wxw161\\afm\\");
2026     /
2027     /  example:
2028     /
2029     /    wxPostScriptDC dc(NULL, TRUE);
2030     /    if (dc.Ok()){
2031     /      wxSetAFMPath("d:\\wxw161\\afm\\");
2032     /      dc.StartDoc("Test");
2033     /      dc.StartPage();
2034     /      wxCoord w,h;
2035     /      dc.SetFont(new wxFont(10, wxROMAN, wxNORMAL, wxNORMAL));
2036     /      dc.GetTextExtent("Hallo",&w,&h);
2037     /      dc.EndPage();
2038     /      dc.EndDoc();
2039     /    }
2040     /
2041     /  by steve (stefan.hammes@urz.uni-heidelberg.de)
2042     /  created: 10.09.94
2043     /  updated: 14.05.95 */
2044
2045     /* these static vars are for storing the state between calls */
2046     static int lastFamily= INT_MIN;
2047     static int lastSize= INT_MIN;
2048     static int lastStyle= INT_MIN;
2049     static int lastWeight= INT_MIN;
2050     static int lastDescender = INT_MIN;
2051     static int lastWidths[256]; /* widths of the characters */
2052
2053     double UnderlinePosition = 0.0;
2054     double UnderlineThickness = 0.0;
2055
2056     // Get actual parameters
2057     int Family = fontToUse->GetFamily();
2058     int Size =   fontToUse->GetPointSize();
2059     int Style =  fontToUse->GetStyle();
2060     int Weight = fontToUse->GetWeight();
2061
2062     // If we have another font, read the font-metrics
2063     if (Family!=lastFamily || Size!=lastSize || Style!=lastStyle || Weight!=lastWeight)
2064     {
2065         // Store actual values
2066         lastFamily = Family;
2067         lastSize =   Size;
2068         lastStyle =  Style;
2069         lastWeight = Weight;
2070
2071         const char *name = NULL;
2072
2073         switch (Family)
2074         {
2075             case wxMODERN:
2076             case wxTELETYPE:
2077             {
2078                 if ((Style == wxITALIC) && (Weight == wxBOLD)) name = "CourBoO.afm";
2079                 else if ((Style != wxITALIC) && (Weight == wxBOLD)) name = "CourBo.afm";
2080                 else if ((Style == wxITALIC) && (Weight != wxBOLD)) name = "CourO.afm";
2081                 else name = "Cour.afm";
2082                 break;
2083             }
2084             case wxROMAN:
2085             {
2086                 if ((Style == wxITALIC) && (Weight == wxBOLD)) name = "TimesBoO.afm";
2087                 else if ((Style != wxITALIC) && (Weight == wxBOLD)) name = "TimesBo.afm";
2088                 else if ((Style == wxITALIC) && (Weight != wxBOLD)) name = "TimesO.afm";
2089                 else name = "TimesRo.afm";
2090                 break;
2091             }
2092             case wxSCRIPT:
2093             {
2094                 name = "Zapf.afm";
2095                 Style = wxNORMAL;
2096                 Weight = wxNORMAL;
2097             }
2098             case wxSWISS:
2099             default:
2100             {
2101                 if ((Style == wxITALIC) && (Weight == wxBOLD)) name = "HelvBoO.afm";
2102                 else if ((Style != wxITALIC) && (Weight == wxBOLD)) name = "HelvBo.afm";
2103                 else if ((Style == wxITALIC) && (Weight != wxBOLD)) name = "HelvO.afm";
2104                 else name = "Helv.afm";
2105                 break;
2106             }
2107         }
2108
2109         FILE *afmFile = NULL;
2110
2111         // Get the directory of the AFM files
2112         wxString afmName;
2113         if (!m_printData.GetFontMetricPath().IsEmpty())
2114         {
2115             afmName = m_printData.GetFontMetricPath();
2116             afmName << wxFILE_SEP_PATH << name;
2117             afmFile = wxFopen(afmName,wxT("r"));
2118         }
2119
2120 #if defined(__UNIX__) && !defined(__VMS__)
2121         if (afmFile==NULL)
2122         {
2123            afmName = wxGetDataDir();
2124            afmName <<  wxFILE_SEP_PATH
2125 #if defined(__LINUX__) || defined(__FREEBSD__)
2126                    << wxT("gs_afm") << wxFILE_SEP_PATH
2127 #else
2128                    << wxT("afm") << wxFILE_SEP_PATH
2129 #endif
2130                    << name;
2131            afmFile = wxFopen(afmName,wxT("r"));
2132         }
2133 #endif
2134
2135         /* 2. open and process the file
2136            /  a short explanation of the AFM format:
2137            /  we have for each character a line, which gives its size
2138            /  e.g.:
2139            /
2140            /    C 63 ; WX 444 ; N question ; B 49 -14 395 676 ;
2141            /
2142            /  that means, we have a character with ascii code 63, and width
2143            /  (444/1000 * fontSize) points.
2144            /  the other data is ignored for now!
2145            /
2146            /  when the font has changed, we read in the right AFM file and store the
2147            /  character widths in an array, which is processed below (see point 3.). */
2148         if (afmFile==NULL)
2149         {
2150             wxLogDebug( wxT("GetTextExtent: can't open AFM file '%s'"), afmName.c_str() );
2151             wxLogDebug( wxT("               using approximate values"));
2152             for (int i=0; i<256; i++) lastWidths[i] = 500; /* an approximate value */
2153             lastDescender = -150; /* dito. */
2154         }
2155         else
2156         {
2157             /* init the widths array */
2158             for(int i=0; i<256; i++) lastWidths[i] = INT_MIN;
2159             /* some variables for holding parts of a line */
2160             char cString[10],semiString[10],WXString[10],descString[20];
2161             char upString[30], utString[30], encString[50];
2162             char line[256];
2163             int ascii,cWidth;
2164             /* read in the file and parse it */
2165             while(fgets(line,sizeof(line),afmFile)!=NULL)
2166             {
2167                 /* A.) check for descender definition */
2168                 if (strncmp(line,"Descender",9)==0)
2169                 {
2170                     if ((sscanf(line,"%s%d",descString,&lastDescender)!=2) ||
2171                             (strcmp(descString,"Descender")!=0))
2172                     {
2173                         wxLogDebug( wxT("AFM-file '%s': line '%s' has error (bad descender)"), afmName.c_str(),line );
2174                     }
2175                 }
2176                 /* JC 1.) check for UnderlinePosition */
2177                 else if(strncmp(line,"UnderlinePosition",17)==0)
2178                 {
2179                     if ((sscanf(line,"%s%lf",upString,&UnderlinePosition)!=2) ||
2180                             (strcmp(upString,"UnderlinePosition")!=0))
2181                     {
2182                         wxLogDebug( wxT("AFM-file '%s': line '%s' has error (bad UnderlinePosition)"), afmName.c_str(), line );
2183                     }
2184                 }
2185                 /* JC 2.) check for UnderlineThickness */
2186                 else if(strncmp(line,"UnderlineThickness",18)==0)
2187                 {
2188                     if ((sscanf(line,"%s%lf",utString,&UnderlineThickness)!=2) ||
2189                             (strcmp(utString,"UnderlineThickness")!=0))
2190                     {
2191                         wxLogDebug( wxT("AFM-file '%s': line '%s' has error (bad UnderlineThickness)"), afmName.c_str(), line );
2192                     }
2193                 }
2194                 /* JC 3.) check for EncodingScheme */
2195                 else if(strncmp(line,"EncodingScheme",14)==0)
2196                 {
2197                     if ((sscanf(line,"%s%s",utString,encString)!=2) ||
2198                             (strcmp(utString,"EncodingScheme")!=0))
2199                     {
2200                         wxLogDebug( wxT("AFM-file '%s': line '%s' has error (bad EncodingScheme)"), afmName.c_str(), line );
2201                     }
2202                     else if (strncmp(encString, "AdobeStandardEncoding", 21))
2203                     {
2204                         wxLogDebug( wxT("AFM-file '%s': line '%s' has error (unsupported EncodingScheme %s)"),
2205                                 afmName.c_str(),line, encString);
2206                     }
2207                 }
2208                 /* B.) check for char-width */
2209                 else if(strncmp(line,"C ",2)==0)
2210                 {
2211                     if (sscanf(line,"%s%d%s%s%d",cString,&ascii,semiString,WXString,&cWidth)!=5)
2212                     {
2213                         wxLogDebug(wxT("AFM-file '%s': line '%s' has an error (bad character width)"),afmName.c_str(),line);
2214                     }
2215                     if(strcmp(cString,"C")!=0 || strcmp(semiString,";")!=0 || strcmp(WXString,"WX")!=0)
2216                     {
2217                         wxLogDebug(wxT("AFM-file '%s': line '%s' has a format error"),afmName.c_str(),line);
2218                     }
2219                     /* printf("            char '%c'=%d has width '%d'\n",ascii,ascii,cWidth); */
2220                     if (ascii>=0 && ascii<256)
2221                     {
2222                         lastWidths[ascii] = cWidth; /* store width */
2223                     }
2224                     else
2225                     {
2226                         /* MATTHEW: this happens a lot; don't print an error */
2227                         /* wxLogDebug("AFM-file '%s': ASCII value %d out of range",afmName.c_str(),ascii); */
2228                     }
2229                 }
2230                 /* C.) ignore other entries. */
2231             }
2232             fclose(afmFile);
2233         }
2234         /* hack to compute correct values for german 'Umlaute'
2235            /  the correct way would be to map the character names
2236            /  like 'adieresis' to corresp. positions of ISOEnc and read
2237            /  these values from AFM files, too. Maybe later ... */
2238         lastWidths[196] = lastWidths['A'];  // Ä
2239         lastWidths[228] = lastWidths['a'];  // ä
2240         lastWidths[214] = lastWidths['O'];  // Ö
2241         lastWidths[246] = lastWidths['o'];  // ö
2242         lastWidths[220] = lastWidths['U'];  // Ü
2243         lastWidths[252] = lastWidths['u'];  // ü
2244         lastWidths[223] = lastWidths[251];  // ß
2245
2246         /* JC: calculate UnderlineThickness/UnderlinePosition */
2247
2248         // VS: dirty, but is there any better solution?
2249         double *pt;
2250         pt = (double*) &m_underlinePosition;
2251         *pt = LogicalToDeviceYRel((wxCoord)(UnderlinePosition * fontToUse->GetPointSize())) / 1000.0f;
2252         pt = (double*) &m_underlineThickness;
2253         *pt = LogicalToDeviceYRel((wxCoord)(UnderlineThickness * fontToUse->GetPointSize())) / 1000.0f;
2254
2255     }
2256
2257
2258     /* 3. now the font metrics are read in, calc size this
2259        /  is done by adding the widths of the characters in the
2260        /  string. they are given in 1/1000 of the size! */
2261
2262     long sum=0;
2263     wxCoord height=Size; /* by default */
2264     unsigned char *p;
2265     for(p=(unsigned char *)wxMBSTRINGCAST strbuf; *p; p++)
2266     {
2267         if(lastWidths[*p]== INT_MIN)
2268         {
2269             wxLogDebug(wxT("GetTextExtent: undefined width for character '%c' (%d)"), *p,*p);
2270             sum += lastWidths[' ']; /* assume space */
2271         }
2272         else
2273         {
2274             sum += lastWidths[*p];
2275         }
2276     }
2277
2278     double widthSum = sum;
2279     widthSum *= Size;
2280     widthSum /= 1000.0F;
2281
2282     /* add descender to height (it is usually a negative value) */
2283     //if (lastDescender != INT_MIN)
2284     //{
2285     //    height += (wxCoord)(((-lastDescender)/1000.0F) * Size); /* MATTHEW: forgot scale */
2286     //}
2287     // - commented by V. Slavik - height already contains descender in it
2288     //   (judging from few experiments)
2289
2290     /* return size values */
2291     if ( x )
2292         *x = (wxCoord)widthSum;
2293     if ( y )
2294         *y = height;
2295
2296     /* return other parameters */
2297     if (descent)
2298     {
2299         if(lastDescender!=INT_MIN)
2300         {
2301             *descent = (wxCoord)(((-lastDescender)/1000.0F) * Size); /* MATTHEW: forgot scale */
2302         }
2303         else
2304         {
2305             *descent = 0;
2306         }
2307     }
2308
2309     /* currently no idea how to calculate this! */
2310     if (externalLeading) *externalLeading = 0;
2311 #endif
2312     // Use AFM
2313
2314 #endif
2315     // GTK 2.0
2316 }
2317
2318 #endif
2319   // wxUSE_POSTSCRIPT
2320
2321 #endif
2322   // wxUSE_PRINTING_ARCHITECTURE