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 "gtk/gdk/gdkx.h"
1103 //#include <pango/pangoxft.h>
1104 #include <pango/pangoft2.h>
1105 #include <freetype/ftglyph.h>
1106
1107 #ifndef FT_Outline_Decompose
1108   FT_EXPORT( FT_Error )  FT_Outline_Decompose(
1109                            FT_Outline*              outline,
1110                            const FT_Outline_Funcs*  interface,
1111                            void*                    user );
1112 #endif
1113
1114 typedef struct _OutlineInfo OutlineInfo;
1115 struct _OutlineInfo {
1116   FILE *OUT;
1117   FT_Vector glyph_origin;
1118   int dpi;
1119 };
1120
1121 static int paps_move_to( FT_Vector* to,
1122                          void *user_data)
1123 {
1124   OutlineInfo *outline_info = (OutlineInfo*)user_data;
1125   fprintf(outline_info->OUT, "%d %d moveto\n",
1126           (int)to->x ,
1127           (int)to->y );
1128   return 0;
1129 }
1130
1131 static int paps_line_to( FT_Vector*  to,
1132                          void *user_data)
1133 {
1134   OutlineInfo *outline_info = (OutlineInfo*)user_data;
1135   fprintf(outline_info->OUT, "%d %d lineto\n",
1136           (int)to->x ,
1137           (int)to->y );
1138   return 0;
1139 }
1140
1141 static int paps_conic_to( FT_Vector*  control,
1142                           FT_Vector*  to,
1143                           void *user_data)
1144 {
1145   OutlineInfo *outline_info = (OutlineInfo*)user_data;
1146   fprintf(outline_info->OUT, "%d %d %d %d conicto\n",
1147           (int)control->x  ,
1148           (int)control->y  ,
1149           (int)to->x   ,
1150           (int)to->y  );
1151   return 0;
1152 }
1153
1154 static int paps_cubic_to( FT_Vector*  control1,
1155                           FT_Vector*  control2,
1156                           FT_Vector*  to,
1157                           void *user_data)
1158 {
1159   OutlineInfo *outline_info = (OutlineInfo*)user_data;
1160   fprintf(outline_info->OUT,
1161           "%d %d %d %d %d %d curveto\n",
1162           (int)control1->x ,
1163           (int)control1->y ,
1164           (int)control2->x ,
1165           (int)control2->y ,
1166           (int)to->x ,
1167           (int)to->y );
1168   return 0;
1169 }
1170
1171 void draw_bezier_outline(FILE *OUT,
1172                          int dpi,
1173                          FT_Face face,
1174                          FT_UInt glyph_index,
1175                          wxCoord pos_x,
1176                          wxCoord pos_y
1177                          )
1178 {
1179   FT_Int load_flags = FT_LOAD_DEFAULT;
1180   FT_Glyph glyph;
1181
1182   /* Output outline */
1183   FT_Outline_Funcs outlinefunc =
1184   {
1185     paps_move_to,
1186     paps_line_to,
1187     paps_conic_to,
1188     paps_cubic_to
1189   };
1190   OutlineInfo outline_info;
1191
1192   outline_info.glyph_origin.x = (FT_Pos) pos_x;
1193   outline_info.glyph_origin.y = (FT_Pos) pos_y;
1194   outline_info.dpi = dpi;
1195   outline_info.OUT = OUT;
1196
1197   fprintf(OUT, "gsave %d %d translate 1.0 72.0 div dup scale 0 0 0 setrgbcolor\n", pos_x, pos_y );
1198
1199   FT_Load_Glyph(face, glyph_index, load_flags);
1200   FT_Get_Glyph (face->glyph, &glyph);
1201   FT_Outline_Decompose (&(((FT_OutlineGlyph)glyph)->outline),
1202                         &outlinefunc, &outline_info);
1203   fprintf(OUT, "closepath fill grestore \n");
1204
1205   FT_Done_Glyph (glyph);
1206 }
1207
1208 #endif
1209
1210 void wxPostScriptDC::DoDrawText( const wxString& text, wxCoord x, wxCoord y )
1211 {
1212     wxCHECK_RET( m_ok && m_pstream, wxT("invalid postscript dc") );
1213
1214 #ifdef __WXGTK20__
1215
1216     int dpi = GetResolution();
1217
1218     PangoContext *context = pango_ft2_get_context ( dpi, dpi );
1219
1220     // What are these for?
1221     pango_context_set_language (context, pango_language_from_string ("en_US"));
1222     pango_context_set_base_dir (context, PANGO_DIRECTION_LTR );
1223
1224     // Set the font
1225     pango_context_set_font_description (context, m_font.GetNativeFontInfo()->description );
1226
1227     // Create layout
1228     PangoLayout *layout = pango_layout_new (context);
1229 #if wxUSE_UNICODE
1230     wxCharBuffer buffer = wxConvUTF8.cWC2MB( text );
1231 #else
1232     wxCharBuffer buffer = wxConvUTF8.cWC2MB( wxConvLocal.cWX2WC( text ) );
1233 #endif
1234         pango_layout_set_text( layout, (const char*) buffer, strlen(buffer) );
1235
1236 #if 1
1237     int xx = LogicalToDeviceX(x);
1238     int yy = LogicalToDeviceY(y /*+ bitmap.GetHeight()*/ );
1239
1240     xx *= PANGO_SCALE;
1241     yy *= PANGO_SCALE;
1242
1243     // Loop over lines in layout
1244     int num_lines = pango_layout_get_line_count( layout );
1245     for (int i = 0; i < num_lines; i++)
1246     {
1247         PangoLayoutLine *line = pango_layout_get_line( layout, i );
1248
1249         // Loop over runs in line
1250         GSList *runs_list = line->runs;
1251         while (runs_list)
1252         {
1253             PangoLayoutRun *run = (PangoLayoutRun*) runs_list->data;
1254             PangoItem *item = run->item;
1255             PangoGlyphString *glyphs = run->glyphs;
1256             PangoAnalysis *analysis = &item->analysis;
1257             PangoFont *font = analysis->font;
1258             FT_Face ft_face = pango_ft2_font_get_face(font);
1259
1260             int num_glyphs = glyphs->num_glyphs;
1261             for (int glyph_idx = 0; glyph_idx < num_glyphs; glyph_idx++)
1262             {
1263                 PangoGlyphGeometry geometry = glyphs->glyphs[glyph_idx].geometry;
1264                 int pos_x = xx + geometry.x_offset;
1265                 int pos_y = yy - geometry.y_offset;
1266                 xx += geometry.width;
1267
1268                 draw_bezier_outline( m_pstream, dpi, ft_face,
1269                               (FT_UInt)(glyphs->glyphs[glyph_idx].glyph),
1270                               (wxCoord)(pos_x / PANGO_SCALE), (wxCoord)(pos_y / PANGO_SCALE) );
1271             }
1272             runs_list = runs_list->next;
1273         }
1274         }
1275 #else
1276     // Find out extent for the bitmap
1277     int height = 0;
1278     int width = 0;
1279     PangoRectangle logical_rect;
1280     pango_layout_get_extents (layout, NULL, &logical_rect);
1281     height = PANGO_PIXELS (logical_rect.height);
1282     width = PANGO_PIXELS (logical_rect.width);
1283
1284     // printf( "h %d w %d lh %d lw %d\n", height, width, logical_rect.height, logical_rect.width );
1285
1286     // Allocate FreeType 2 bitmap
1287     int byte_width = (width + 7)/8 * 8;
1288     FT_Bitmap bitmap;
1289     guchar *buf = (guchar*) g_malloc (byte_width * height);
1290     memset (buf, 0x00, byte_width * height);
1291     bitmap.rows = height;
1292     bitmap.width = byte_width;
1293         bitmap.pitch = byte_width;
1294         bitmap.buffer = buf;
1295         bitmap.num_grays = 256;
1296         bitmap.pixel_mode = ft_pixel_mode_grays;
1297
1298     // Render bitmap
1299         pango_ft2_render_layout (&bitmap, layout, 0, 0);
1300
1301         // Invert bitmap to get black text on white background
1302     for (int pix_idx = 0; pix_idx < width * height; pix_idx++)
1303         buf[pix_idx] = 255-buf[pix_idx];
1304
1305     // Write PS output
1306     wxCoord xx = LogicalToDeviceX(x);
1307     wxCoord yy = LogicalToDeviceY(y /*+ bitmap.GetHeight()*/ );
1308
1309     fprintf(m_pstream, "gsave\n");
1310     fprintf(m_pstream, "%d %d translate\n", xx, yy);
1311     fprintf(m_pstream, "/img_width %d def\n", bitmap.width);
1312     fprintf(m_pstream, "/img_height %d def\n", bitmap.rows);
1313     fprintf(m_pstream, "/picstr img_width 8 idiv string def\n");
1314
1315     fprintf(m_pstream,
1316           "  img_width 72 15 div mul\n"
1317           "  img_height 72 15 div mul scale\n"
1318           "  0 setgray\n"
1319           "  img_width img_height\n"
1320           "  true\n"
1321           "  [img_width 0 0 img_height neg 0 img_height 0.67 mul]\n"
1322           "  { currentfile\n"
1323           "    picstr readhexstring pop }\n"
1324           "  imagemask"
1325           );
1326
1327
1328     for (int b_idx= 0; b_idx < bitmap.width/8 * bitmap.rows; b_idx++)
1329     {
1330       guchar packed_b = 0;
1331       int bit_idx;
1332
1333       if (b_idx % (bitmap.width/8) == 0)
1334         fprintf(m_pstream, "\n");
1335
1336       for (bit_idx = 0; bit_idx < 8; bit_idx++)
1337         {
1338           guchar this_bit = bitmap.buffer[b_idx * 8+bit_idx]<128;
1339           packed_b = (packed_b << 1) + this_bit;
1340         }
1341       fprintf(m_pstream, "%02x", packed_b);
1342     }
1343
1344     fprintf(m_pstream, "\ngrestore\n" );
1345
1346     // Free memory
1347     g_free( buf );
1348 #endif
1349
1350 #else
1351     wxCoord text_w, text_h, text_descent;
1352
1353     GetTextExtent(text, &text_w, &text_h, &text_descent);
1354
1355     // VZ: this seems to be unnecessary, so taking it out for now, if it
1356     //     doesn't create any problems, remove this comment entirely
1357     //SetFont( m_font );
1358
1359     if (m_textForegroundColour.Ok())
1360     {
1361         unsigned char red = m_textForegroundColour.Red();
1362         unsigned char blue = m_textForegroundColour.Blue();
1363         unsigned char green = m_textForegroundColour.Green();
1364
1365         if (!m_colour)
1366         {
1367             // Anything not white is black
1368             if (! (red == (unsigned char) 255 &&
1369                         blue == (unsigned char) 255 &&
1370                         green == (unsigned char) 255))
1371             {
1372                 red = (unsigned char) 0;
1373                 green = (unsigned char) 0;
1374                 blue = (unsigned char) 0;
1375             }
1376         }
1377
1378         // maybe setgray here ?
1379         if (!(red == m_currentRed && green == m_currentGreen && blue == m_currentBlue))
1380         {
1381             double redPS = (double)(red) / 255.0;
1382             double bluePS = (double)(blue) / 255.0;
1383             double greenPS = (double)(green) / 255.0;
1384
1385             char buffer[100];
1386             sprintf( buffer,
1387                 "%.8f %.8f %.8f setrgbcolor\n",
1388                 redPS, greenPS, bluePS );
1389             for (int i = 0; i < 100; i++)
1390                 if (buffer[i] == ',') buffer[i] = '.';
1391             fprintf( m_pstream, buffer );
1392
1393             m_currentRed = red;
1394             m_currentBlue = blue;
1395             m_currentGreen = green;
1396         }
1397     }
1398
1399     int size = m_font.GetPointSize();
1400
1401 //    wxCoord by = y + (wxCoord)floor( double(size) * 2.0 / 3.0 ); // approximate baseline
1402 //    commented by V. Slavik and replaced by accurate version
1403 //        - note that there is still rounding error in text_descent!
1404     wxCoord by = y + size - text_descent; // baseline
1405     fprintf( m_pstream, "%d %d moveto\n", LogicalToDeviceX(x), LogicalToDeviceY(by) );
1406
1407     fprintf( m_pstream, "(" );
1408     const wxWX2MBbuf textbuf = text.mb_str();
1409     size_t len = strlen(textbuf);
1410     size_t i;
1411     for (i = 0; i < len; i++)
1412     {
1413         int c = (unsigned char) textbuf[i];
1414         if (c == ')' || c == '(' || c == '\\')
1415         {
1416             /* Cope with special characters */
1417             fprintf( m_pstream, "\\" );
1418             fputc(c, m_pstream);
1419         }
1420         else if ( c >= 128 )
1421         {
1422             /* Cope with character codes > 127 */
1423             fprintf(m_pstream, "\\%o", c);
1424         }
1425         else
1426         {
1427             fputc(c, m_pstream);
1428         }
1429     }
1430
1431     fprintf( m_pstream, ") show\n" );
1432
1433     if (m_font.GetUnderlined())
1434     {
1435         wxCoord uy = (wxCoord)(y + size - m_underlinePosition);
1436         char buffer[100];
1437
1438         sprintf( buffer,
1439                 "gsave\n"
1440                 "%d %d moveto\n"
1441                 "%f setlinewidth\n"
1442                 "%d %d lineto\n"
1443                 "stroke\n"
1444                 "grestore\n",
1445                 LogicalToDeviceX(x), LogicalToDeviceY(uy),
1446                 m_underlineThickness,
1447                 LogicalToDeviceX(x + text_w), LogicalToDeviceY(uy) );
1448         for (i = 0; i < 100; i++)
1449             if (buffer[i] == ',') buffer[i] = '.';
1450         fprintf( m_pstream, buffer );
1451     }
1452
1453     CalcBoundingBox( x, y );
1454     CalcBoundingBox( x + size * text.Length() * 2/3 , y );
1455 #endif
1456 }
1457
1458 void wxPostScriptDC::DoDrawRotatedText( const wxString& text, wxCoord x, wxCoord y, double angle )
1459 {
1460     if (angle == 0.0)
1461     {
1462         DoDrawText(text, x, y);
1463         return;
1464     }
1465
1466     wxCHECK_RET( m_ok && m_pstream, wxT("invalid postscript dc") );
1467
1468     SetFont( m_font );
1469
1470     if (m_textForegroundColour.Ok())
1471     {
1472         unsigned char red = m_textForegroundColour.Red();
1473         unsigned char blue = m_textForegroundColour.Blue();
1474         unsigned char green = m_textForegroundColour.Green();
1475
1476         if (!m_colour)
1477         {
1478             // Anything not white is black
1479             if (! (red == (unsigned char) 255 &&
1480                    blue == (unsigned char) 255 &&
1481                    green == (unsigned char) 255))
1482             {
1483                 red = (unsigned char) 0;
1484                 green = (unsigned char) 0;
1485                 blue = (unsigned char) 0;
1486             }
1487         }
1488
1489         // maybe setgray here ?
1490         if (!(red == m_currentRed && green == m_currentGreen && blue == m_currentBlue))
1491         {
1492             double redPS = (double)(red) / 255.0;
1493             double bluePS = (double)(blue) / 255.0;
1494             double greenPS = (double)(green) / 255.0;
1495
1496             char buffer[100];
1497             sprintf( buffer,
1498                 "%.8f %.8f %.8f setrgbcolor\n",
1499                 redPS, greenPS, bluePS );
1500             for (int i = 0; i < 100; i++)
1501                 if (buffer[i] == ',') buffer[i] = '.';
1502             fprintf( m_pstream, buffer );
1503
1504             m_currentRed = red;
1505             m_currentBlue = blue;
1506             m_currentGreen = green;
1507         }
1508     }
1509
1510     int size = m_font.GetPointSize();
1511
1512     long by = y + (long)floor( double(size) * 2.0 / 3.0 ); // approximate baseline
1513
1514     // FIXME only correct for 90 degrees
1515     fprintf(m_pstream, "%d %d moveto\n",
1516             LogicalToDeviceX((wxCoord)(x + size)), LogicalToDeviceY((wxCoord)by) );
1517
1518     char buffer[100];
1519     sprintf(buffer, "%.8f rotate\n", angle);
1520     size_t i;
1521     for (i = 0; i < 100; i++)
1522         if (buffer[i] == ',') buffer[i] = '.';
1523     fprintf(m_pstream, buffer);
1524
1525     fprintf( m_pstream, "(" );
1526     const wxWX2MBbuf textbuf = text.mb_str();
1527     size_t len = strlen(textbuf);
1528     for (i = 0; i < len; i++)
1529     {
1530         int c = (unsigned char) textbuf[i];
1531         if (c == ')' || c == '(' || c == '\\')
1532         {
1533             /* Cope with special characters */
1534             fprintf( m_pstream, "\\" );
1535             fputc(c, m_pstream);
1536         }
1537         else if ( c >= 128 )
1538         {
1539             /* Cope with character codes > 127 */
1540             fprintf(m_pstream, "\\%o", c);
1541         }
1542         else
1543         {
1544             fputc(c, m_pstream);
1545         }
1546     }
1547
1548     fprintf( m_pstream, ") show\n" );
1549
1550     sprintf( buffer, "%.8f rotate\n", -angle );
1551     for (i = 0; i < 100; i++)
1552         if (buffer[i] == ',') buffer[i] = '.';
1553     fprintf( m_pstream, buffer );
1554
1555     if (m_font.GetUnderlined())
1556     {
1557         wxCoord uy = (wxCoord)(y + size - m_underlinePosition);
1558         wxCoord w, h;
1559         char buffer[100];
1560         GetTextExtent(text, &w, &h);
1561
1562         sprintf( buffer,
1563                  "gsave\n"
1564                  "%d %d moveto\n"
1565                  "%f setlinewidth\n"
1566                  "%d %d lineto\n"
1567                  "stroke\n"
1568                  "grestore\n",
1569                  LogicalToDeviceX(x), LogicalToDeviceY(uy),
1570                  m_underlineThickness,
1571                  LogicalToDeviceX(x + w), LogicalToDeviceY(uy) );
1572         for (i = 0; i < 100; i++)
1573             if (buffer[i] == ',') buffer[i] = '.';
1574         fprintf( m_pstream, buffer );
1575     }
1576
1577     CalcBoundingBox( x, y );
1578     CalcBoundingBox( x + size * text.Length() * 2/3 , y );
1579 }
1580
1581 void wxPostScriptDC::SetBackground (const wxBrush& brush)
1582 {
1583     m_backgroundBrush = brush;
1584 }
1585
1586 void wxPostScriptDC::SetLogicalFunction (int WXUNUSED(function))
1587 {
1588     wxFAIL_MSG( wxT("wxPostScriptDC::SetLogicalFunction not implemented.") );
1589 }
1590
1591 void wxPostScriptDC::DoDrawSpline( wxList *points )
1592 {
1593     wxCHECK_RET( m_ok && m_pstream, wxT("invalid postscript dc") );
1594
1595     SetPen( m_pen );
1596
1597     double a, b, c, d, x1, y1, x2, y2, x3, y3;
1598     wxPoint *p, *q;
1599
1600     wxNode *node = points->First();
1601     p = (wxPoint *)node->Data();
1602     x1 = p->x;
1603     y1 = p->y;
1604
1605     node = node->Next();
1606     p = (wxPoint *)node->Data();
1607     c = p->x;
1608     d = p->y;
1609     x3 = a = (double)(x1 + c) / 2;
1610     y3 = b = (double)(y1 + d) / 2;
1611
1612     fprintf( m_pstream,
1613             "newpath\n"
1614             "%d %d moveto\n"
1615             "%d %d lineto\n",
1616             LogicalToDeviceX((wxCoord)x1), LogicalToDeviceY((wxCoord)y1),
1617             LogicalToDeviceX((wxCoord)x3), LogicalToDeviceY((wxCoord)y3) );
1618
1619     CalcBoundingBox( (wxCoord)x1, (wxCoord)y1 );
1620     CalcBoundingBox( (wxCoord)x3, (wxCoord)y3 );
1621
1622     while ((node = node->Next()) != NULL)
1623     {
1624         q = (wxPoint *)node->Data();
1625
1626         x1 = x3;
1627         y1 = y3;
1628         x2 = c;
1629         y2 = d;
1630         c = q->x;
1631         d = q->y;
1632         x3 = (double)(x2 + c) / 2;
1633         y3 = (double)(y2 + d) / 2;
1634
1635         fprintf( m_pstream,
1636                 "%d %d %d %d %d %d DrawSplineSection\n",
1637                 LogicalToDeviceX((wxCoord)x1), LogicalToDeviceY((wxCoord)y1),
1638                 LogicalToDeviceX((wxCoord)x2), LogicalToDeviceY((wxCoord)y2),
1639                 LogicalToDeviceX((wxCoord)x3), LogicalToDeviceY((wxCoord)y3) );
1640
1641         CalcBoundingBox( (wxCoord)x1, (wxCoord)y1 );
1642         CalcBoundingBox( (wxCoord)x3, (wxCoord)y3 );
1643     }
1644
1645     /*
1646        At this point, (x2,y2) and (c,d) are the position of the
1647        next-to-last and last point respectively, in the point list
1648      */
1649
1650     fprintf( m_pstream,
1651             "%d %d lineto\n"
1652             "stroke\n",
1653             LogicalToDeviceX((wxCoord)c), LogicalToDeviceY((wxCoord)d) );
1654 }
1655
1656 wxCoord wxPostScriptDC::GetCharWidth() const
1657 {
1658     // Chris Breeze: reasonable approximation using wxMODERN/Courier
1659     return (wxCoord) (GetCharHeight() * 72.0 / 120.0);
1660 }
1661
1662
1663 void wxPostScriptDC::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
1664 {
1665     wxCHECK_RET( m_ok && m_pstream, wxT("invalid postscript dc") );
1666
1667     m_signX = (xLeftRight ? 1 : -1);
1668     m_signY = (yBottomUp  ? 1 : -1);
1669
1670     // FIXME there is no such function in MSW nor in OS2/PM
1671 #if !defined(__WXMSW__) && !defined(__WXPM__)
1672     ComputeScaleAndOrigin();
1673 #endif
1674 }
1675
1676 void wxPostScriptDC::SetDeviceOrigin( wxCoord x, wxCoord y )
1677 {
1678     wxCHECK_RET( m_ok && m_pstream, wxT("invalid postscript dc") );
1679
1680     int h = 0;
1681     int w = 0;
1682     GetSize( &w, &h );
1683
1684     wxDC::SetDeviceOrigin( x, h-y );
1685 }
1686
1687 void wxPostScriptDC::DoGetSize(int* width, int* height) const
1688 {
1689     wxPaperSize id = m_printData.GetPaperId();
1690
1691     wxPrintPaperType *paper = wxThePrintPaperDatabase->FindPaperType(id);
1692
1693     if (!paper) paper = wxThePrintPaperDatabase->FindPaperType(wxPAPER_A4);
1694
1695     int w = 595;
1696     int h = 842;
1697     if (paper)
1698     {
1699         w = paper->GetSizeDeviceUnits().x;
1700         h = paper->GetSizeDeviceUnits().y;
1701     }
1702
1703     if (m_printData.GetOrientation() == wxLANDSCAPE)
1704     {
1705         int tmp = w;
1706         w = h;
1707         h = tmp;
1708     }
1709
1710     if (width) *width = (int)(w * ms_PSScaleFactor);
1711     if (height) *height = (int)(h * ms_PSScaleFactor);
1712 }
1713
1714 void wxPostScriptDC::DoGetSizeMM(int *width, int *height) const
1715 {
1716     wxPaperSize id = m_printData.GetPaperId();
1717
1718     wxPrintPaperType *paper = wxThePrintPaperDatabase->FindPaperType(id);
1719
1720     if (!paper) paper = wxThePrintPaperDatabase->FindPaperType(wxPAPER_A4);
1721
1722     int w = 210;
1723     int h = 297;
1724     if (paper)
1725     {
1726         w = paper->GetWidth() / 10;
1727         h = paper->GetHeight() / 10;
1728     }
1729
1730     if (m_printData.GetOrientation() == wxLANDSCAPE)
1731     {
1732         int tmp = w;
1733         w = h;
1734         h = tmp;
1735     }
1736
1737     if (width) *width = w;
1738     if (height) *height = h;
1739 }
1740
1741 // Resolution in pixels per logical inch
1742 wxSize wxPostScriptDC::GetPPI(void) const
1743 {
1744     return wxSize((int)(72 * ms_PSScaleFactor),
1745                   (int)(72 * ms_PSScaleFactor));
1746 }
1747
1748
1749 bool wxPostScriptDC::StartDoc( const wxString& message )
1750 {
1751     wxCHECK_MSG( m_ok, FALSE, wxT("invalid postscript dc") );
1752
1753     if (m_printData.GetFilename() == "")
1754     {
1755         wxString filename = wxGetTempFileName("ps");
1756         m_printData.SetFilename(filename);
1757     }
1758
1759     m_pstream = wxFopen( m_printData.GetFilename().c_str(), wxT("w+") );  // FIXME: use fn_str() here under Unicode?
1760
1761     if (!m_pstream)
1762     {
1763         wxLogError( _("Cannot open file for PostScript printing!"));
1764         m_ok = FALSE;
1765         return FALSE;
1766     }
1767
1768     m_ok = TRUE;
1769
1770     fprintf( m_pstream, "%%!PS-Adobe-2.0\n" );
1771     fprintf( m_pstream, "%%%%Title: %s\n", (const char *) m_title.ToAscii() );
1772     fprintf( m_pstream, "%%%%Creator: wxWindows PostScript renderer\n" );
1773     fprintf( m_pstream, "%%%%CreationDate: %s\n", (const char *) wxNow().ToAscii() );
1774     if (m_printData.GetOrientation() == wxLANDSCAPE)
1775         fprintf( m_pstream, "%%%%Orientation: Landscape\n" );
1776     else
1777         fprintf( m_pstream, "%%%%Orientation: Portrait\n" );
1778
1779     // wxPaperSize ps = m_printData.GetPaperId();
1780     // if (ps == ...)
1781     fprintf( m_pstream, "%%%%DocumentPaperSizes: %s\n", "A4" );
1782     fprintf( m_pstream, "%%%%EndComments\n\n" );
1783
1784     fprintf( m_pstream, "%%%%BeginProlog\n" );
1785     fprintf( m_pstream, wxPostScriptHeaderConicTo );
1786     fprintf( m_pstream, wxPostScriptHeaderEllipse );
1787     fprintf( m_pstream, wxPostScriptHeaderEllipticArc );
1788     fprintf( m_pstream, wxPostScriptHeaderColourImage );
1789 #ifndef __WXGTK20__
1790     fprintf( m_pstream, wxPostScriptHeaderReencodeISO1 );
1791     fprintf( m_pstream, wxPostScriptHeaderReencodeISO2 );
1792 #endif
1793     if (wxPostScriptHeaderSpline)
1794         fprintf( m_pstream, wxPostScriptHeaderSpline );
1795     fprintf( m_pstream, "%%%%EndProlog\n" );
1796
1797     SetBrush( *wxBLACK_BRUSH );
1798     SetPen( *wxBLACK_PEN );
1799     SetBackground( *wxWHITE_BRUSH );
1800     SetTextForeground( *wxBLACK );
1801
1802     // set origin according to paper size
1803     SetDeviceOrigin( 0,0 );
1804
1805     wxPageNumber = 1;
1806     m_pageNumber = 1;
1807     m_title = message;
1808     return TRUE;
1809 }
1810
1811 void wxPostScriptDC::EndDoc ()
1812 {
1813     wxCHECK_RET( m_ok && m_pstream, wxT("invalid postscript dc") );
1814
1815     if (m_clipping)
1816     {
1817         m_clipping = FALSE;
1818         fprintf( m_pstream, "grestore\n" );
1819     }
1820
1821     fclose( m_pstream );
1822     m_pstream = (FILE *) NULL;
1823
1824 #if 0
1825
1826     // THE FOLLOWING HAS BEEN CONTRIBUTED BY Andy Fyfe <andy@hyperparallel.com>
1827
1828     wxCoord wx_printer_translate_x, wx_printer_translate_y;
1829     double wx_printer_scale_x, wx_printer_scale_y;
1830
1831     wx_printer_translate_x = (wxCoord)m_printData.GetPrinterTranslateX();
1832     wx_printer_translate_y = (wxCoord)m_printData.GetPrinterTranslateY();
1833
1834     wx_printer_scale_x = m_printData.GetPrinterScaleX();
1835     wx_printer_scale_y = m_printData.GetPrinterScaleY();
1836
1837     // Compute the bounding box.  Note that it is in the default user
1838     // coordinate system, thus we have to convert the values.
1839     wxCoord minX = (wxCoord) LogicalToDeviceX(m_minX);
1840     wxCoord minY = (wxCoord) LogicalToDeviceY(m_minY);
1841     wxCoord maxX = (wxCoord) LogicalToDeviceX(m_maxX);
1842     wxCoord maxY = (wxCoord) LogicalToDeviceY(m_maxY);
1843
1844     // LOG2DEV may have changed the minimum to maximum vice versa
1845     if ( minX > maxX ) { wxCoord tmp = minX; minX = maxX; maxX = tmp; }
1846     if ( minY > maxY ) { wxCoord tmp = minY; minY = maxY; maxY = tmp; }
1847
1848     // account for used scaling (boundingbox is before scaling in ps-file)
1849     double scale_x = m_printData.GetPrinterScaleX() / ms_PSScaleFactor;
1850     double scale_y = m_printData.GetPrinterScaleY() / ms_PSScaleFactor;
1851
1852     wxCoord llx, lly, urx, ury;
1853     llx = (wxCoord) ((minX+wx_printer_translate_x)*scale_x);
1854     lly = (wxCoord) ((minY+wx_printer_translate_y)*scale_y);
1855     urx = (wxCoord) ((maxX+wx_printer_translate_x)*scale_x);
1856     ury = (wxCoord) ((maxY+wx_printer_translate_y)*scale_y);
1857     // (end of bounding box computation)
1858
1859
1860     // If we're landscape, our sense of "x" and "y" is reversed.
1861     if (m_printData.GetOrientation() == wxLANDSCAPE)
1862     {
1863         wxCoord tmp;
1864         tmp = llx; llx = lly; lly = tmp;
1865         tmp = urx; urx = ury; ury = tmp;
1866
1867         // We need either the two lines that follow, or we need to subtract
1868         // min_x from real_translate_y, which is commented out below.
1869         llx = llx - (wxCoord)(m_minX*wx_printer_scale_y);
1870         urx = urx - (wxCoord)(m_minX*wx_printer_scale_y);
1871     }
1872
1873     // The Adobe specifications call for integers; we round as to make
1874     // the bounding larger.
1875     fprintf( m_pstream,
1876             "%%%%BoundingBox: %d %d %d %d\n",
1877             (wxCoord)floor((double)llx), (wxCoord)floor((double)lly),
1878             (wxCoord)ceil((double)urx), (wxCoord)ceil((double)ury) );
1879     fprintf( m_pstream, "%%%%Pages: %d\n", (wxPageNumber - 1) );
1880
1881     // To check the correctness of the bounding box, postscript commands
1882     // to draw a box corresponding to the bounding box are generated below.
1883     // But since we typically don't want to print such a box, the postscript
1884     // commands are generated within comments.  These lines appear before any
1885     // adjustment of scale, rotation, or translation, and hence are in the
1886     // default user coordinates.
1887     fprintf( m_pstream, "%% newpath\n" );
1888     fprintf( m_pstream, "%% %d %d moveto\n", llx, lly );
1889     fprintf( m_pstream, "%% %d %d lineto\n", urx, lly );
1890     fprintf( m_pstream, "%% %d %d lineto\n", urx, ury );
1891     fprintf( m_pstream, "%% %d %d lineto closepath stroke\n", llx, ury );
1892
1893 #if defined(__X__) || defined(__WXGTK__)
1894     if (m_ok)
1895     {
1896         wxString previewCommand(m_printData.GetPreviewCommand());
1897         wxString printerCommand(m_printData.GetPrinterCommand());
1898         wxString printerOptions(m_printData.GetPrinterOptions());
1899         wxString filename(m_printData.GetFilename());
1900
1901         switch (m_printData.GetPrintMode())
1902         {
1903             case wxPRINT_MODE_PREVIEW:
1904             {
1905                 wxChar *argv[3];
1906                 argv[0] = WXSTRINGCAST previewCommand;
1907                 argv[1] = WXSTRINGCAST filename;
1908                 argv[2] = (wxChar*) NULL;
1909 #if defined(__WXGTK20__) && wxUSE_UNICODE
1910 #else
1911                 wxExecute( argv, TRUE );
1912 #endif
1913                 wxRemoveFile( m_printData.GetFilename() );
1914             }
1915             break;
1916             case wxPRINT_MODE_PRINTER:
1917             {
1918                 wxChar *argv[4];
1919                 int argc = 0;
1920                 argv[argc++] = WXSTRINGCAST printerCommand;
1921
1922                 // !SM! If we simply assign to argv[1] here, if printer options
1923                 // are blank, we get an annoying and confusing message from lpr.
1924                 wxChar *opts = WXSTRINGCAST printerOptions;
1925                 if (opts && *opts)
1926                     argv[argc++] = opts;
1927
1928                 argv[argc++] = WXSTRINGCAST filename;
1929                 argv[argc++] = (wxChar *) NULL;
1930 #if defined(__WXGTK20__) && wxUSE_UNICODE
1931 #else
1932                 wxExecute( argv, TRUE );
1933 #endif
1934                 wxRemoveFile( filename );
1935             }
1936             break;
1937             case wxPRINT_MODE_FILE:
1938             case wxPRINT_MODE_NONE:
1939             break;
1940         }
1941     }
1942 #endif
1943
1944 #endif
1945 }
1946
1947 void wxPostScriptDC::StartPage()
1948 {
1949     wxCHECK_RET( m_ok && m_pstream, wxT("invalid postscript dc") );
1950
1951     fprintf( m_pstream, "%%%%Page: %d\n", wxPageNumber++ );
1952
1953     //  What is this one supposed to do? RR.
1954 //  *m_pstream << "matrix currentmatrix\n";
1955
1956     // Added by Chris Breeze
1957
1958     // Each page starts with an "initgraphics" which resets the
1959     // transformation and so we need to reset the origin
1960     // (and rotate the page for landscape printing)
1961
1962     // Output scaling
1963     wxCoord translate_x, translate_y;
1964     double scale_x, scale_y;
1965
1966     translate_x = (wxCoord)m_printData.GetPrinterTranslateX();
1967     translate_y = (wxCoord)m_printData.GetPrinterTranslateY();
1968
1969     scale_x = m_printData.GetPrinterScaleX();
1970     scale_y = m_printData.GetPrinterScaleY();
1971
1972     if (m_printData.GetOrientation() == wxLANDSCAPE)
1973     {
1974         int h;
1975         GetSize( (int*) NULL, &h );
1976         translate_y -= h;
1977         fprintf( m_pstream, "90 rotate\n" );
1978
1979         // I copied this one from a PostScript tutorial, but to no avail. RR.
1980         // fprintf( m_pstream, "90 rotate llx neg ury nef translate\n" );
1981     }
1982
1983     char buffer[100];
1984     sprintf( buffer, "%.8f %.8f scale\n", scale_x / ms_PSScaleFactor,
1985                                           scale_y / ms_PSScaleFactor);
1986     for (int i = 0; i < 100; i++)
1987         if (buffer[i] == ',') buffer[i] = '.';
1988     fprintf( m_pstream, buffer );
1989
1990     fprintf( m_pstream, "%d %d translate\n", translate_x, translate_y );
1991 }
1992
1993 void wxPostScriptDC::EndPage ()
1994 {
1995     wxCHECK_RET( m_ok && m_pstream, wxT("invalid postscript dc") );
1996
1997     fprintf( m_pstream, "showpage\n" );
1998 }
1999
2000 bool wxPostScriptDC::DoBlit( wxCoord xdest, wxCoord ydest,
2001                            wxCoord fwidth, wxCoord fheight,
2002                            wxDC *source,
2003                            wxCoord xsrc, wxCoord ysrc,
2004                            int rop, bool WXUNUSED(useMask), wxCoord WXUNUSED(xsrcMask), wxCoord WXUNUSED(ysrcMask) )
2005 {
2006     wxCHECK_MSG( m_ok && m_pstream, FALSE, wxT("invalid postscript dc") );
2007
2008     wxCHECK_MSG( source, FALSE, wxT("invalid source dc") );
2009
2010     /* blit into a bitmap */
2011     wxBitmap bitmap( (int)fwidth, (int)fheight );
2012     wxMemoryDC memDC;
2013     memDC.SelectObject(bitmap);
2014     memDC.Blit(0, 0, fwidth, fheight, source, xsrc, ysrc, rop); /* TODO: Blit transparently? */
2015     memDC.SelectObject(wxNullBitmap);
2016
2017     /* draw bitmap. scaling and positioning is done there */
2018     DrawBitmap( bitmap, xdest, ydest );
2019
2020     return TRUE;
2021 }
2022
2023 wxCoord wxPostScriptDC::GetCharHeight() const
2024 {
2025     if (m_font.Ok())
2026         return m_font.GetPointSize();
2027     else
2028         return 12;
2029 }
2030
2031 void wxPostScriptDC::DoGetTextExtent(const wxString& string,
2032                                      wxCoord *x, wxCoord *y,
2033                                      wxCoord *descent, wxCoord *externalLeading,
2034                                      wxFont *theFont ) const
2035 {
2036     wxFont *fontToUse = theFont;
2037
2038     if (!fontToUse) fontToUse = (wxFont*) &m_font;
2039
2040     wxCHECK_RET( fontToUse, wxT("GetTextExtent: no font defined") );
2041
2042     const wxWX2MBbuf strbuf = string.mb_str();
2043
2044 #if !wxUSE_AFM_FOR_POSTSCRIPT
2045     /* Provide a VERY rough estimate (avoid using it).
2046      * Produces accurate results for mono-spaced font
2047      * such as Courier (aka wxMODERN) */
2048
2049     int height = 12;
2050     if (fontToUse)
2051     {
2052         height = fontToUse->GetPointSize();
2053     }
2054     if ( x )
2055         *x = strlen (strbuf) * height * 72 / 120;
2056     if ( y )
2057         *y = (wxCoord) (height * 1.32);    /* allow for descender */
2058     if (descent) *descent = 0;
2059     if (externalLeading) *externalLeading = 0;
2060 #else
2061
2062     /* method for calculating string widths in postscript:
2063     /  read in the AFM (adobe font metrics) file for the
2064     /  actual font, parse it and extract the character widths
2065     /  and also the descender. this may be improved, but for now
2066     /  it works well. the AFM file is only read in if the
2067     /  font is changed. this may be chached in the future.
2068     /  calls to GetTextExtent with the font unchanged are rather
2069     /  efficient!!!
2070     /
2071     /  for each font and style used there is an AFM file necessary.
2072     /  currently i have only files for the roman font family.
2073     /  I try to get files for the other ones!
2074     /
2075     /  CAVE: the size of the string is currently always calculated
2076     /        in 'points' (1/72 of an inch). this should later on be
2077     /        changed to depend on the mapping mode.
2078     /  CAVE: the path to the AFM files must be set before calling this
2079     /        function. this is usually done by a call like the following:
2080     /        wxSetAFMPath("d:\\wxw161\\afm\\");
2081     /
2082     /  example:
2083     /
2084     /    wxPostScriptDC dc(NULL, TRUE);
2085     /    if (dc.Ok()){
2086     /      wxSetAFMPath("d:\\wxw161\\afm\\");
2087     /      dc.StartDoc("Test");
2088     /      dc.StartPage();
2089     /      wxCoord w,h;
2090     /      dc.SetFont(new wxFont(10, wxROMAN, wxNORMAL, wxNORMAL));
2091     /      dc.GetTextExtent("Hallo",&w,&h);
2092     /      dc.EndPage();
2093     /      dc.EndDoc();
2094     /    }
2095     /
2096     /  by steve (stefan.hammes@urz.uni-heidelberg.de)
2097     /  created: 10.09.94
2098     /  updated: 14.05.95 */
2099
2100     /* these static vars are for storing the state between calls */
2101     static int lastFamily= INT_MIN;
2102     static int lastSize= INT_MIN;
2103     static int lastStyle= INT_MIN;
2104     static int lastWeight= INT_MIN;
2105     static int lastDescender = INT_MIN;
2106     static int lastWidths[256]; /* widths of the characters */
2107
2108     double UnderlinePosition = 0.0;
2109     double UnderlineThickness = 0.0;
2110
2111     // Get actual parameters
2112     int Family = fontToUse->GetFamily();
2113     int Size =   fontToUse->GetPointSize();
2114     int Style =  fontToUse->GetStyle();
2115     int Weight = fontToUse->GetWeight();
2116
2117     // If we have another font, read the font-metrics
2118     if (Family!=lastFamily || Size!=lastSize || Style!=lastStyle || Weight!=lastWeight)
2119     {
2120         // Store actual values
2121         lastFamily = Family;
2122         lastSize =   Size;
2123         lastStyle =  Style;
2124         lastWeight = Weight;
2125
2126         const char *name = NULL;
2127
2128         switch (Family)
2129         {
2130             case wxMODERN:
2131             case wxTELETYPE:
2132             {
2133                 if ((Style == wxITALIC) && (Weight == wxBOLD)) name = "CourBoO.afm";
2134                 else if ((Style != wxITALIC) && (Weight == wxBOLD)) name = "CourBo.afm";
2135                 else if ((Style == wxITALIC) && (Weight != wxBOLD)) name = "CourO.afm";
2136                 else name = "Cour.afm";
2137                 break;
2138             }
2139             case wxROMAN:
2140             {
2141                 if ((Style == wxITALIC) && (Weight == wxBOLD)) name = "TimesBoO.afm";
2142                 else if ((Style != wxITALIC) && (Weight == wxBOLD)) name = "TimesBo.afm";
2143                 else if ((Style == wxITALIC) && (Weight != wxBOLD)) name = "TimesO.afm";
2144                 else name = "TimesRo.afm";
2145                 break;
2146             }
2147             case wxSCRIPT:
2148             {
2149                 name = "Zapf.afm";
2150                 Style = wxNORMAL;
2151                 Weight = wxNORMAL;
2152             }
2153             case wxSWISS:
2154             default:
2155             {
2156                 if ((Style == wxITALIC) && (Weight == wxBOLD)) name = "HelvBoO.afm";
2157                 else if ((Style != wxITALIC) && (Weight == wxBOLD)) name = "HelvBo.afm";
2158                 else if ((Style == wxITALIC) && (Weight != wxBOLD)) name = "HelvO.afm";
2159                 else name = "Helv.afm";
2160                 break;
2161             }
2162         }
2163
2164         FILE *afmFile = NULL;
2165
2166         // Get the directory of the AFM files
2167         wxString afmName;
2168         if (!m_printData.GetFontMetricPath().IsEmpty())
2169         {
2170             afmName = m_printData.GetFontMetricPath();
2171             afmName << wxFILE_SEP_PATH << name;
2172             afmFile = wxFopen(afmName,wxT("r"));
2173         }
2174
2175 #if defined(__UNIX__) && !defined(__VMS__)
2176         if (afmFile==NULL)
2177         {
2178            afmName = wxGetDataDir();
2179            afmName <<  wxFILE_SEP_PATH
2180 #if defined(__LINUX__) || defined(__FREEBSD__)
2181                    << wxT("gs_afm") << wxFILE_SEP_PATH
2182 #else
2183                    << wxT("afm") << wxFILE_SEP_PATH
2184 #endif
2185                    << name;
2186            afmFile = wxFopen(afmName,wxT("r"));
2187         }
2188 #endif
2189
2190         /* 2. open and process the file
2191            /  a short explanation of the AFM format:
2192            /  we have for each character a line, which gives its size
2193            /  e.g.:
2194            /
2195            /    C 63 ; WX 444 ; N question ; B 49 -14 395 676 ;
2196            /
2197            /  that means, we have a character with ascii code 63, and width
2198            /  (444/1000 * fontSize) points.
2199            /  the other data is ignored for now!
2200            /
2201            /  when the font has changed, we read in the right AFM file and store the
2202            /  character widths in an array, which is processed below (see point 3.). */
2203         if (afmFile==NULL)
2204         {
2205             wxLogDebug( wxT("GetTextExtent: can't open AFM file '%s'"), afmName.c_str() );
2206             wxLogDebug( wxT("               using approximate values"));
2207             for (int i=0; i<256; i++) lastWidths[i] = 500; /* an approximate value */
2208             lastDescender = -150; /* dito. */
2209         }
2210         else
2211         {
2212             /* init the widths array */
2213             for(int i=0; i<256; i++) lastWidths[i] = INT_MIN;
2214             /* some variables for holding parts of a line */
2215             char cString[10],semiString[10],WXString[10],descString[20];
2216             char upString[30], utString[30], encString[50];
2217             char line[256];
2218             int ascii,cWidth;
2219             /* read in the file and parse it */
2220             while(fgets(line,sizeof(line),afmFile)!=NULL)
2221             {
2222                 /* A.) check for descender definition */
2223                 if (strncmp(line,"Descender",9)==0)
2224                 {
2225                     if ((sscanf(line,"%s%d",descString,&lastDescender)!=2) ||
2226                             (strcmp(descString,"Descender")!=0))
2227                     {
2228                         wxLogDebug( wxT("AFM-file '%s': line '%s' has error (bad descender)"), afmName.c_str(),line );
2229                     }
2230                 }
2231                 /* JC 1.) check for UnderlinePosition */
2232                 else if(strncmp(line,"UnderlinePosition",17)==0)
2233                 {
2234                     if ((sscanf(line,"%s%lf",upString,&UnderlinePosition)!=2) ||
2235                             (strcmp(upString,"UnderlinePosition")!=0))
2236                     {
2237                         wxLogDebug( wxT("AFM-file '%s': line '%s' has error (bad UnderlinePosition)"), afmName.c_str(), line );
2238                     }
2239                 }
2240                 /* JC 2.) check for UnderlineThickness */
2241                 else if(strncmp(line,"UnderlineThickness",18)==0)
2242                 {
2243                     if ((sscanf(line,"%s%lf",utString,&UnderlineThickness)!=2) ||
2244                             (strcmp(utString,"UnderlineThickness")!=0))
2245                     {
2246                         wxLogDebug( wxT("AFM-file '%s': line '%s' has error (bad UnderlineThickness)"), afmName.c_str(), line );
2247                     }
2248                 }
2249                 /* JC 3.) check for EncodingScheme */
2250                 else if(strncmp(line,"EncodingScheme",14)==0)
2251                 {
2252                     if ((sscanf(line,"%s%s",utString,encString)!=2) ||
2253                             (strcmp(utString,"EncodingScheme")!=0))
2254                     {
2255                         wxLogDebug( wxT("AFM-file '%s': line '%s' has error (bad EncodingScheme)"), afmName.c_str(), line );
2256                     }
2257                     else if (strncmp(encString, "AdobeStandardEncoding", 21))
2258                     {
2259                         wxLogDebug( wxT("AFM-file '%s': line '%s' has error (unsupported EncodingScheme %s)"),
2260                                 afmName.c_str(),line, encString);
2261                     }
2262                 }
2263                 /* B.) check for char-width */
2264                 else if(strncmp(line,"C ",2)==0)
2265                 {
2266                     if (sscanf(line,"%s%d%s%s%d",cString,&ascii,semiString,WXString,&cWidth)!=5)
2267                     {
2268                         wxLogDebug(wxT("AFM-file '%s': line '%s' has an error (bad character width)"),afmName.c_str(),line);
2269                     }
2270                     if(strcmp(cString,"C")!=0 || strcmp(semiString,";")!=0 || strcmp(WXString,"WX")!=0)
2271                     {
2272                         wxLogDebug(wxT("AFM-file '%s': line '%s' has a format error"),afmName.c_str(),line);
2273                     }
2274                     /* printf("            char '%c'=%d has width '%d'\n",ascii,ascii,cWidth); */
2275                     if (ascii>=0 && ascii<256)
2276                     {
2277                         lastWidths[ascii] = cWidth; /* store width */
2278                     }
2279                     else
2280                     {
2281                         /* MATTHEW: this happens a lot; don't print an error */
2282                         /* wxLogDebug("AFM-file '%s': ASCII value %d out of range",afmName.c_str(),ascii); */
2283                     }
2284                 }
2285                 /* C.) ignore other entries. */
2286             }
2287             fclose(afmFile);
2288         }
2289         /* hack to compute correct values for german 'Umlaute'
2290            /  the correct way would be to map the character names
2291            /  like 'adieresis' to corresp. positions of ISOEnc and read
2292            /  these values from AFM files, too. Maybe later ... */
2293         lastWidths[196] = lastWidths['A'];  // Ä
2294         lastWidths[228] = lastWidths['a'];  // ä
2295         lastWidths[214] = lastWidths['O'];  // Ö
2296         lastWidths[246] = lastWidths['o'];  // ö
2297         lastWidths[220] = lastWidths['U'];  // Ü
2298         lastWidths[252] = lastWidths['u'];  // ü
2299         lastWidths[223] = lastWidths[251];  // ß
2300
2301         /* JC: calculate UnderlineThickness/UnderlinePosition */
2302
2303         // VS: dirty, but is there any better solution?
2304         double *pt;
2305         pt = (double*) &m_underlinePosition;
2306         *pt = LogicalToDeviceYRel((wxCoord)(UnderlinePosition * fontToUse->GetPointSize())) / 1000.0f;
2307         pt = (double*) &m_underlineThickness;
2308         *pt = LogicalToDeviceYRel((wxCoord)(UnderlineThickness * fontToUse->GetPointSize())) / 1000.0f;
2309
2310     }
2311
2312
2313     /* 3. now the font metrics are read in, calc size this
2314        /  is done by adding the widths of the characters in the
2315        /  string. they are given in 1/1000 of the size! */
2316
2317     long sum=0;
2318     wxCoord height=Size; /* by default */
2319     unsigned char *p;
2320     for(p=(unsigned char *)wxMBSTRINGCAST strbuf; *p; p++)
2321     {
2322         if(lastWidths[*p]== INT_MIN)
2323         {
2324             wxLogDebug(wxT("GetTextExtent: undefined width for character '%c' (%d)"), *p,*p);
2325             sum += lastWidths[' ']; /* assume space */
2326         }
2327         else
2328         {
2329             sum += lastWidths[*p];
2330         }
2331     }
2332
2333     double widthSum = sum;
2334     widthSum *= Size;
2335     widthSum /= 1000.0F;
2336
2337     /* add descender to height (it is usually a negative value) */
2338     //if (lastDescender != INT_MIN)
2339     //{
2340     //    height += (wxCoord)(((-lastDescender)/1000.0F) * Size); /* MATTHEW: forgot scale */
2341     //}
2342     // - commented by V. Slavik - height already contains descender in it
2343     //   (judging from few experiments)
2344
2345     /* return size values */
2346     if ( x )
2347         *x = (wxCoord)widthSum;
2348     if ( y )
2349         *y = height;
2350
2351     /* return other parameters */
2352     if (descent)
2353     {
2354         if(lastDescender!=INT_MIN)
2355         {
2356             *descent = (wxCoord)(((-lastDescender)/1000.0F) * Size); /* MATTHEW: forgot scale */
2357         }
2358         else
2359         {
2360             *descent = 0;
2361         }
2362     }
2363
2364     /* currently no idea how to calculate this! */
2365     if (externalLeading) *externalLeading = 0;
2366
2367 #endif
2368 }
2369
2370 #endif
2371   // wxUSE_POSTSCRIPT
2372
2373 #endif
2374   // wxUSE_PRINTING_ARCHITECTURE