src/common/postscrp.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        postscrp.cpp
   3 // Purpose:     wxPostScriptDC implementation
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart and Markus Holzem
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13 #pragma implementation "postscrp.h"
  14 #pragma implementation
  15 #pragma interface
  16 #endif
  17
  18 // For compilers that support precompilation, includes "wx.h".
  19 #include "wx/wxprec.h"
  20
  21 #ifdef __BORLANDC__
  22 #pragma hdrstop
  23 #endif
  24
  25 #include "wx/defs.h"
  26
  27 #if wxUSE_POSTSCRIPT
  28
  29 #ifndef WX_PRECOMP
  30 #include "wx/intl.h"
  31 #include "wx/frame.h"
  32 #include "wx/postscrp.h"
  33 #include "wx/utils.h"
  34 #include "wx/filedlg.h"
  35 #include "wx/msgdlg.h"
  36 #include "wx/app.h"
  37 #include "wx/button.h"
  38 #include "wx/radiobox.h"
  39 #include "wx/textctrl.h"
  40 #include "wx/stattext.h"
  41 #include "wx/icon.h"
  42 #include "wx/list.h"
  43 #endif
  44
  45 #include "wx/dcmemory.h"
  46
  47 #ifdef __WXMSW__
  48 #include "wx/msw/private.h"
  49 #endif
  50
  51 #if wxUSE_IOSTREAMH
  52 #include <iostream.h>
  53 #else
  54 #include <iostream>
  55 #endif
  56
  57 #include <fstream.h>
  58 #include <math.h>
  59 #include <stdio.h>
  60 #include <stdlib.h>
  61 #include <string.h>
  62 #include <limits.h>
  63 #include <assert.h>
  64
  65 #ifdef __WXGTK__
  66
  67 #include "gdk/gdkx.h"        // GDK_DISPLAY
  68 #include "gdk/gdkprivate.h"  // XImage
  69 #include <X11/Xlib.h>
  70 #include <X11/Xutil.h>
  71
  72 #endif
  73
  74 #ifdef __WXMOTIF__
  75 #include <X11/Xlib.h>
  76 #include <X11/Xutil.h>
  77 #endif
  78
  79 #ifdef __WXMSW__
  80
  81 #ifdef DrawText
  82 #undef DrawText
  83 #endif
  84
  85 #ifdef StartDoc
  86 #undef StartDoc
  87 #endif
  88
  89 #ifdef GetCharWidth
  90 #undef GetCharWidth
  91 #endif
  92
  93 #ifdef FindWindow
  94 #undef FindWindow
  95 #endif
  96
  97 #endif
  98
  99 // Declarations local to this file
 100 #define YSCALE(y) (m_yOrigin / m_scaleFactor - (y))
 101
 102 // Determine the Default Postscript Previewer
 103 // available on the platform
 104 #if defined(__SUN__) && defined(__XVIEW__)
 105 // OpenWindow/NeWS's Postscript Previewer
 106 # define PS_VIEWER_PROG "pageview"
 107 #elif defined(__VMS__)
 108 #define PS_VIEWER_PROG "view/format=ps/select=x_display"
 109 #elif defined(__SGI__)
 110 // SGI's Display Postscript Previewer
 111 //# define PS_VIEWER_PROG "dps"
 112 # define PS_VIEWER_PROG "xpsview"
 113 #elif defined(__X__) || defined(__WXGTK__)
 114 // Front-end to ghostscript
 115 # define PS_VIEWER_PROG "ghostview"
 116 #else
 117 // Windows ghostscript/ghostview
 118 # define PS_VIEWER_PROG NULL
 119 #endif
 120
 121 wxPrintSetupData *wxThePrintSetupData = (wxPrintSetupData *) NULL;
 122
 123 // these should move into wxPostscriptDC:
 124 double UnderlinePosition = 0.0F;
 125 double UnderlineThickness = 0.0F;
 126
 127 #define _MAXPATHLEN 500
 128
 129 /* See "wxspline.inc" and "xfspline.inc" */
 130 #if wxUSE_XFIG_SPLINE_CODE
 131 static const char *wxPostScriptHeaderSpline = " \
 132 /DrawSplineSection {\n\
 133         /y3 exch def\n\
 134         /x3 exch def\n\
 135         /y2 exch def\n\
 136         /x2 exch def\n\
 137         /y1 exch def\n\
 138         /x1 exch def\n\
 139         /xa x1 x2 x1 sub 0.666667 mul add def\n\
 140         /ya y1 y2 y1 sub 0.666667 mul add def\n\
 141         /xb x3 x2 x3 sub 0.666667 mul add def\n\
 142         /yb y3 y2 y3 sub 0.666667 mul add def\n\
 143         x1 y1 lineto\n\
 144         xa ya xb yb x3 y3 curveto\n\
 145         } def\n\
 146 ";
 147 #else
 148 // No extra PS header for this spline implementation.
 149 static const char *wxPostScriptHeaderSpline = (char *) NULL;
 150
 151 #endif /* wxUSE_XFIG_SPLINE_CODE */
 152
 153 // steve, 05.09.94
 154 // VMS has a bug in the ofstream class.
 155 // the buffering doesn't work correctly. therefore
 156 // we will allocate (temporarily) a very big buffer (1MB), so
 157 // that a buffer overflow will not occur.
 158 #ifdef __VMS__
 159 #define VMS_BUFSIZ (1024L*1024L)
 160 static char *fileBuffer = NULL;
 161 #endif
 162
 163 #if !USE_SHARED_LIBRARY
 164 IMPLEMENT_DYNAMIC_CLASS(wxPostScriptModule, wxModule)
 165 IMPLEMENT_DYNAMIC_CLASS(wxPostScriptDC, wxDC)
 166 IMPLEMENT_DYNAMIC_CLASS(wxPrintSetupData, wxObject)
 167 IMPLEMENT_DYNAMIC_CLASS(wxPrintPaperType, wxObject)
 168 IMPLEMENT_DYNAMIC_CLASS(wxPrintPaperDatabase, wxList)
 169 #endif
 170
 171 wxPostScriptDC::wxPostScriptDC (void)
 172 {
 173 //  m_yOrigin = 792;                        // For EPS output
 174   m_yOrigin = 842;                          // For A4 output
 175
 176   m_minX = 1000;
 177   m_minY = 1000;
 178   m_maxX = -1000;
 179   m_maxY = -1000;
 180   m_title = "";
 181
 182   m_pstream = (ofstream *) NULL;
 183
 184 #ifdef __WXMSW__
 185   // Can only send to file in Windows
 186   wxThePrintSetupData->SetPrinterMode(PS_FILE);
 187 #endif
 188
 189   m_currentRed = 255;
 190   m_currentGreen = 255;
 191   m_currentBlue = 0;
 192 }
 193
 194 wxPostScriptDC::wxPostScriptDC (const wxString& file, bool interactive, wxWindow *parent)
 195 {
 196   Create(file, interactive, parent);
 197 }
 198
 199 bool wxPostScriptDC::Create(const wxString& file, bool interactive, wxWindow *parent)
 200 {
 201   m_isInteractive = interactive;
 202
 203   m_yOrigin = 792;                          // For EPS output
 204 //  m_yOrigin = 842;                        // For A4 output
 205
 206   m_minX = 1000;
 207   m_minY = 1000;
 208   m_maxX = -1000;
 209   m_maxY = -1000;
 210   m_title = "";
 211   m_filename = file;
 212   m_pstream = (ofstream *) NULL;
 213
 214 #ifdef __WXMSW__
 215   // Can only send to file in Windows
 216   wxThePrintSetupData->SetPrinterMode(PS_FILE);
 217 #endif
 218
 219   if (m_isInteractive)
 220   {
 221     if ((m_ok = PrinterDialog (parent) ) == FALSE) return FALSE;
 222   }
 223   else
 224     m_ok = TRUE;
 225
 226   m_currentRed = 255;
 227   m_currentGreen = 255;
 228   m_currentBlue = 0;
 229
 230   m_scaleFactor = 1.0;
 231
 232   return m_ok;
 233 }
 234
 235 wxPostScriptDC::~wxPostScriptDC (void)
 236 {
 237   if (m_pstream)
 238     delete m_pstream;
 239 }
 240
 241 bool wxPostScriptDC::PrinterDialog(wxWindow *parent)
 242 {
 243   wxPostScriptPrintDialog dialog (parent, _("Printer Settings"), wxPoint(150, 150), wxSize(400, 400), wxDEFAULT_DIALOG_STYLE | wxDIALOG_MODAL);
 244   m_ok = (dialog.ShowModal () == wxID_OK) ;
 245
 246   if (!m_ok)
 247     return FALSE;
 248
 249   if ((m_filename == "") && (wxThePrintSetupData->GetPrinterMode() == PS_PREVIEW  || wxThePrintSetupData->GetPrinterMode() == PS_PRINTER))
 250     {
 251 // steve, 05.09.94
 252 #ifdef __VMS__
 253       wxThePrintSetupData->SetPrinterFile("preview");
 254 #else
 255       // For PS_PRINTER action this depends on a Unix-style print spooler
 256       // since the wx_printer_file can be destroyed during a session
 257       // @@@ TODO: a Windows-style answer for non-Unix
 258       char userId[256];
 259       wxGetUserId (userId, sizeof (userId) / sizeof (char));
 260       char tmp[256];
 261       strcpy (tmp, "/tmp/preview_");
 262       strcat (tmp, userId);
 263       wxThePrintSetupData->SetPrinterFile(tmp);
 264 #endif
 265       char tmp2[256];
 266       strcpy(tmp2, wxThePrintSetupData->GetPrinterFile());
 267       strcat (tmp2, ".ps");
 268       wxThePrintSetupData->SetPrinterFile(tmp2);
 269       m_filename = tmp2;
 270     }
 271     else if ((m_filename == "") && (wxThePrintSetupData->GetPrinterMode() == PS_FILE))
 272     {
 273       char *file = wxSaveFileSelector (_("PostScript"), "ps");
 274       if (!file)
 275       {
 276         m_ok = FALSE;
 277         return FALSE;
 278       }
 279       wxThePrintSetupData->SetPrinterFile(file);
 280       m_filename = file;
 281       m_ok = TRUE;
 282     }
 283
 284   return m_ok;
 285 }
 286
 287 void wxPostScriptDC::SetClippingRegion (long cx, long cy, long cw, long ch)
 288 {
 289   if (m_clipping)
 290     return;
 291   if (!m_pstream)
 292     return;
 293
 294   m_clipping = TRUE;
 295   *m_pstream << "gsave\n";
 296   *m_pstream << "newpath\n";
 297   *m_pstream << cx << " " << YSCALE (cy) << " moveto\n";
 298   *m_pstream << (cx + cw) << " " << YSCALE (cy) << " lineto\n";
 299   *m_pstream << cx + cw << " " << YSCALE (cy + ch) << " lineto\n";
 300   *m_pstream << cx << " " << YSCALE (cy + ch) << " lineto\n";
 301   *m_pstream << "closepath clip newpath\n";
 302 }
 303
 304 void wxPostScriptDC::DestroyClippingRegion (void)
 305 {
 306   if (!m_pstream)
 307     return;
 308   if (m_clipping)
 309     {
 310       m_clipping = FALSE;
 311       *m_pstream << "grestore\n";
 312     }
 313 }
 314
 315 void wxPostScriptDC::Clear (void)
 316 {
 317 }
 318
 319 void wxPostScriptDC::FloodFill (long WXUNUSED(x), long WXUNUSED(y), wxColour * WXUNUSED(col), int WXUNUSED(style))
 320 {
 321 }
 322
 323 bool wxPostScriptDC::GetPixel (long WXUNUSED(x), long WXUNUSED(y), wxColour * WXUNUSED(col)) const
 324 {
 325   return FALSE;
 326 }
 327
 328 void wxPostScriptDC::CrossHair (long WXUNUSED(x), long WXUNUSED(y))
 329 {
 330 }
 331
 332 void wxPostScriptDC::DrawLine (long x1, long y1, long x2, long y2)
 333 {
 334   if (!m_pstream)
 335     return;
 336   if (m_pen.Ok())
 337     SetPen (m_pen);
 338   *m_pstream << "newpath\n";
 339   *m_pstream << x1 << " " << YSCALE (y1) << " moveto\n";
 340   *m_pstream << x2 << " " << YSCALE (y2) << " lineto\n";
 341   *m_pstream << "stroke\n";
 342   CalcBoundingBox (x1, (long)YSCALE (y1));
 343   CalcBoundingBox (x2, (long)YSCALE (y2));
 344 }
 345
 346 #define RAD2DEG 57.29577951308
 347
 348 void wxPostScriptDC::DrawArc (long x1, long y1, long x2, long y2, long xc, long yc)
 349 {
 350     if (!m_pstream)
 351                 return;
 352
 353     long dx = x1 - xc;
 354     long dy = y1 - yc;
 355     long radius = (long) sqrt((double) (dx*dx+dy*dy));
 356     double alpha1, alpha2;
 357
 358     if (x1 == x2 && y1 == y2) {
 359         alpha1 = 0.0;
 360         alpha2 = 360.0;
 361     } else if (radius == 0.0) {
 362         alpha1 = alpha2 = 0.0;
 363     } else {
 364         alpha1 = (x1 - xc == 0) ?
 365             (y1 - yc < 0) ? 90.0 : -90.0 :
 366             -atan2(double(y1-yc), double(x1-xc)) * RAD2DEG;
 367         alpha2 = (x2 - xc == 0) ?
 368             (y2 - yc < 0) ? 90.0 : -90.0 :
 369             -atan2(double(y2-yc), double(x2-xc)) * RAD2DEG;
 370     }
 371     while (alpha1 <= 0)   alpha1 += 360;
 372     while (alpha2 <= 0)   alpha2 += 360; // adjust angles to be between
 373     while (alpha1 > 360)  alpha1 -= 360; // 0 and 360 degree
 374     while (alpha2 > 360)  alpha2 -= 360;
 375
 376     if (m_brush.Ok() && m_brush.GetStyle() != wxTRANSPARENT) {
 377         SetBrush(m_brush);
 378         *m_pstream << "newpath\n"
 379                  << xc      << " " << YSCALE(yc) << " "
 380                  << radius  << " " << radius     << " "
 381                  << alpha1  << " " << alpha2     << " ellipse\n"
 382                  << xc      << " " << YSCALE(yc) << " lineto\n"
 383                  << "closepath\n"
 384                  << "fill\n";
 385     }
 386     if (m_pen.Ok() && m_pen.GetStyle() != wxTRANSPARENT) {
 387         SetPen(m_pen);
 388         *m_pstream << "newpath\n"
 389                  << xc      << " " << YSCALE(yc) << " "
 390                  << radius  << " " << radius     << " "
 391                  << alpha1  << " " << alpha2     << " ellipse\n"
 392                  << "stroke\n";
 393     }
 394     CalcBoundingBox(x1, (long)YSCALE(y1));
 395     CalcBoundingBox(x2, (long)YSCALE(y2));
 396 }
 397
 398 void wxPostScriptDC::DrawEllipticArc(long x,long y,long w,long h,double sa,double ea)
 399 {
 400   if (!m_pstream)
 401     return;
 402
 403   if (sa>=360 || sa<=-360) sa=sa-int(sa/360)*360;
 404   if (ea>=360 || ea<=-360) ea=ea-int(ea/360)*360;
 405   if (sa<0) sa+=360;
 406   if (ea<0) ea+=360;
 407   if (sa==ea)
 408   {
 409     DrawEllipse(x,y,w,h);
 410     return;
 411   }
 412
 413   if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
 414     {
 415       SetBrush (m_brush);
 416
 417       *m_pstream <<
 418          "newpath\n" <<
 419          (x+w/2) << " " << YSCALE (y+h/2) << " " <<
 420          w/2 << " " << (h/2) << " " <<
 421          int(sa) <<" "<< int(ea)<<" true ellipticarc\n";
 422
 423       CalcBoundingBox (x , (long)YSCALE (y ));
 424       CalcBoundingBox (x+w,(long)YSCALE(y+h));
 425     }
 426   if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
 427     {
 428       SetPen (m_pen);
 429
 430       *m_pstream <<
 431          "newpath\n" <<
 432          (x+w/2) << " " << YSCALE (y+h/2) << " " <<
 433          (w/2) << " " << (h/2) << " " <<
 434          int(sa) <<" "<< int(ea)<<" false ellipticarc\n";
 435
 436       CalcBoundingBox (x , (long)YSCALE (y ));
 437       CalcBoundingBox (x+w,(long)YSCALE(y+h));
 438     }
 439 }
 440
 441 void wxPostScriptDC::DrawPoint (long x, long y)
 442 {
 443   if (!m_pstream)
 444     return;
 445   if (m_pen.Ok())
 446     SetPen (m_pen);
 447   *m_pstream << "newpath\n";
 448   *m_pstream << x << " " << YSCALE (y) << " moveto\n";
 449   *m_pstream << (x+1) << " " << YSCALE (y) << " lineto\n";
 450   *m_pstream << "stroke\n";
 451   CalcBoundingBox (x, (long)YSCALE (y));
 452 }
 453
 454 void wxPostScriptDC::DrawPolygon (int n, wxPoint points[], long xoffset, long yoffset, int WXUNUSED(fillStyle))
 455 {
 456   if (!m_pstream)
 457     return;
 458   if (n > 0)
 459     {
 460       if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
 461         {
 462           SetBrush (m_brush);
 463           *m_pstream << "newpath\n";
 464
 465           long xx = points[0].x + xoffset;
 466           long yy = (long) YSCALE (points[0].y + yoffset);
 467           *m_pstream << xx << " " << yy << " moveto\n";
 468           CalcBoundingBox (xx, yy);
 469
 470           int i;
 471           for (i = 1; i < n; i++)
 472             {
 473               xx = points[i].x + xoffset;
 474               yy = (long) YSCALE (points[i].y + yoffset);
 475               *m_pstream << xx << " " << yy << " lineto\n";
 476               CalcBoundingBox (xx, yy);
 477             }
 478           *m_pstream << "fill\n";
 479         }
 480
 481       if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
 482         {
 483           SetPen (m_pen);
 484           *m_pstream << "newpath\n";
 485
 486           long xx = points[0].x + xoffset;
 487           long yy = (long) YSCALE (points[0].y + yoffset);
 488           *m_pstream << xx << " " << yy << " moveto\n";
 489           CalcBoundingBox (xx, yy);
 490
 491           int i;
 492           for (i = 1; i < n; i++)
 493             {
 494               xx = points[i].x + xoffset;
 495               yy = (long) YSCALE (points[i].y + yoffset);
 496               *m_pstream << xx << " " << yy << " lineto\n";
 497               CalcBoundingBox (xx, yy);
 498             }
 499
 500           // Close the polygon
 501           xx = points[0].x + xoffset;
 502           yy = (long) YSCALE (points[0].y + yoffset);
 503           *m_pstream << xx << " " << yy << " lineto\n";
 504
 505           // Output the line
 506           *m_pstream << "stroke\n";
 507         }
 508     }
 509 }
 510
 511 void wxPostScriptDC::DrawLines (int n, wxPoint points[], long xoffset, long yoffset)
 512 {
 513   if (!m_pstream)
 514     return;
 515   if (n > 0)
 516     {
 517       if (m_pen.Ok())
 518                 SetPen (m_pen);
 519
 520       *m_pstream << "newpath\n";
 521
 522       long xx = points[0].x + xoffset;
 523       long yy = (long) YSCALE (points[0].y + yoffset);
 524       *m_pstream << xx << " " << yy << " moveto\n";
 525       CalcBoundingBox (xx, yy);
 526
 527       int i;
 528       for (i = 1; i < n; i++)
 529         {
 530           xx = points[i].x + xoffset;
 531           yy = (long) YSCALE (points[i].y + yoffset);
 532           *m_pstream << xx << " " << yy << " lineto\n";
 533           CalcBoundingBox (xx, yy);
 534         }
 535       *m_pstream << "stroke\n";
 536     }
 537 }
 538
 539 void wxPostScriptDC::DrawRectangle (long x, long y, long width, long height)
 540 {
 541   if (!m_pstream)
 542     return;
 543   if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
 544     {
 545       SetBrush (m_brush);
 546
 547       *m_pstream << "newpath\n";
 548       *m_pstream << x << " " << YSCALE (y) << " moveto\n";
 549       *m_pstream << (x + width) << " " << YSCALE (y) << " lineto\n";
 550       *m_pstream << (x + width) << " " << YSCALE (y + height) << " lineto\n";
 551       *m_pstream << x << " " << YSCALE (y + height) << " lineto\n";
 552       *m_pstream << "closepath\n";
 553       *m_pstream << "fill\n";
 554
 555       CalcBoundingBox (x, (long)YSCALE (y));
 556       CalcBoundingBox (x + width, (long)YSCALE (y + height));
 557     }
 558   if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
 559     {
 560       SetPen (m_pen);
 561
 562       *m_pstream << "newpath\n";
 563       *m_pstream << x << " " << YSCALE (y) << " moveto\n";
 564       *m_pstream << (x + width) << " " << YSCALE (y) << " lineto\n";
 565       *m_pstream << (x + width) << " " << YSCALE (y + height) << " lineto\n";
 566       *m_pstream << x << " " << YSCALE (y + height) << " lineto\n";
 567       *m_pstream << "closepath\n";
 568       *m_pstream << "stroke\n";
 569
 570       CalcBoundingBox (x, (long)YSCALE (y));
 571       CalcBoundingBox (x + width, (long)YSCALE (y + height));
 572     }
 573 }
 574
 575 void wxPostScriptDC::DrawRoundedRectangle (long x, long y, long width, long height, double radius)
 576 {
 577   if (!m_pstream)
 578     return;
 579
 580   if (radius < 0.0)
 581     {
 582       // Now, a negative radius is interpreted to mean
 583       // 'the proportion of the smallest X or Y dimension'
 584       double smallest = 0.0;
 585       if (width < height)
 586         smallest = width;
 587       else
 588         smallest = height;
 589       radius =  (-radius * smallest);
 590     }
 591
 592   if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
 593     {
 594       SetBrush (m_brush);
 595       // Draw rectangle anticlockwise
 596       *m_pstream << "newpath\n";
 597       *m_pstream << (x + radius) << " " << YSCALE (y + radius) << " " << radius << " 90 180 arc\n";
 598
 599       *m_pstream << x << " " << YSCALE (y + radius) << " moveto\n";
 600
 601       *m_pstream << (x + radius) << " " << YSCALE (y + height - radius) << " " << radius << " 180 270 arc\n";
 602       *m_pstream << (x + width - radius) << " " << YSCALE (y + height) << " lineto\n";
 603
 604       *m_pstream << (x + width - radius) << " " << YSCALE (y + height - radius) << " " << radius << " 270 0 arc\n";
 605       *m_pstream << (x + width) << " " << YSCALE (y + radius) << " lineto\n";
 606
 607       *m_pstream << (x + width - radius) << " " << YSCALE (y + radius) << " " << radius << " 0 90 arc\n";
 608
 609       *m_pstream << (x + radius) << " " << YSCALE (y) << " lineto\n";
 610
 611       *m_pstream << "closepath\n";
 612
 613       *m_pstream << "fill\n";
 614
 615       CalcBoundingBox (x, (long)YSCALE (y));
 616       CalcBoundingBox (x + width, (long)YSCALE (y + height));
 617     }
 618   if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
 619     {
 620       SetPen (m_pen);
 621       // Draw rectangle anticlockwise
 622       *m_pstream << "newpath\n";
 623       *m_pstream << (x + radius) << " " << YSCALE (y + radius) << " " << radius << " 90 180 arc\n";
 624
 625       *m_pstream << x << " " << YSCALE (y + height - radius) << " lineto\n";
 626
 627       *m_pstream << (x + radius) << " " << YSCALE (y + height - radius) << " " << radius << " 180 270 arc\n";
 628       *m_pstream << (x + width - radius) << " " << YSCALE (y + height) << " lineto\n";
 629
 630       *m_pstream << (x + width - radius) << " " << YSCALE (y + height - radius) << " " << radius << " 270 0 arc\n";
 631       *m_pstream << (x + width) << " " << YSCALE (y + radius) << " lineto\n";
 632
 633       *m_pstream << (x + width - radius) << " " << YSCALE (y + radius) << " " << radius << " 0 90 arc\n";
 634
 635       *m_pstream << (x + radius) << " " << YSCALE (y) << " lineto\n";
 636
 637       *m_pstream << "closepath\n";
 638
 639       *m_pstream << "stroke\n";
 640
 641       CalcBoundingBox (x, (long)YSCALE (y));
 642       CalcBoundingBox (x + width, (long)YSCALE (y + height));
 643     }
 644 }
 645
 646 void wxPostScriptDC::DrawEllipse (long x, long y, long width, long height)
 647 {
 648   if (!m_pstream)
 649     return;
 650   if (m_brush.Ok() && m_brush.GetStyle () != wxTRANSPARENT)
 651     {
 652       SetBrush (m_brush);
 653
 654       *m_pstream << "newpath\n";
 655       *m_pstream << (x + width / 2) << " " << YSCALE (y + height / 2) << " ";
 656       *m_pstream << (width / 2) << " " << (height / 2) << " 0 360 ellipse\n";
 657       *m_pstream << "fill\n";
 658
 659       CalcBoundingBox (x - width, (long)YSCALE (y - height));
 660       CalcBoundingBox (x + width, (long)YSCALE (y + height));
 661     }
 662   if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
 663     {
 664       SetPen (m_pen);
 665
 666       *m_pstream << "newpath\n";
 667       *m_pstream << (x + width / 2) << " " << YSCALE (y + height / 2) << " ";
 668       *m_pstream << (width / 2) << " " << (height / 2) << " 0 360 ellipse\n";
 669       *m_pstream << "stroke\n";
 670
 671       CalcBoundingBox (x - width, (long)YSCALE (y - height));
 672       CalcBoundingBox (x + width, (long)YSCALE (y + height));
 673     }
 674 }
 675
 676 void wxPostScriptDC::DrawIcon (const wxIcon& icon, long x, long y)
 677 {
 678 #if defined(__X__) || defined(__WXGTK__)
 679   wxMemoryDC memDC;
 680   memDC.SelectObject(icon);
 681   Blit(x, y, icon.GetWidth(), icon.GetHeight(), &memDC, 0, 0);
 682 #endif
 683 }
 684
 685 void wxPostScriptDC::SetFont (const wxFont& the_font)
 686 {
 687   if (!m_pstream)
 688     return;
 689
 690   if (m_font == the_font)
 691     return;
 692
 693   m_font = the_font;
 694
 695   if ( !m_font.Ok() )
 696         return;
 697
 698   char buf[100];
 699   const char *name;
 700   const char *style = "";
 701   int Style = m_font.GetStyle ();
 702   int Weight = m_font.GetWeight ();
 703
 704   switch (m_font.GetFamily ())
 705     {
 706     case wxTELETYPE:
 707     case wxMODERN:
 708       name = "/Courier";
 709       break;
 710     case wxSWISS:
 711       name = "/Helvetica";
 712       break;
 713     case wxROMAN:
 714 //      name = "/Times-Roman";
 715       name = "/Times"; // Altered by EDZ
 716       break;
 717     case wxSCRIPT:
 718       name = "/Zapf-Chancery-MediumItalic";
 719       Style  = wxNORMAL;
 720       Weight = wxNORMAL;
 721       break;
 722     default:
 723     case wxDEFAULT: // Sans Serif Font
 724       name = "/LucidaSans";
 725     }
 726
 727   if (Style == wxNORMAL && (Weight == wxNORMAL || Weight == wxLIGHT))
 728     {
 729       if (m_font.GetFamily () == wxROMAN)
 730         style = "-Roman";
 731       else
 732         style = "";
 733     }
 734   else if (Style == wxNORMAL && Weight == wxBOLD)
 735     style = "-Bold";
 736
 737   else if (Style == wxITALIC && (Weight == wxNORMAL || Weight == wxLIGHT))
 738     {
 739       if (m_font.GetFamily () == wxROMAN)
 740         style = "-Italic";
 741       else
 742         style = "-Oblique";
 743     }
 744   else if (Style == wxITALIC && Weight == wxBOLD)
 745     {
 746       if (m_font.GetFamily () == wxROMAN)
 747         style = "-BoldItalic";
 748       else
 749         style = "-BoldOblique";
 750     }
 751   else if (Style == wxSLANT && (Weight == wxNORMAL || Weight == wxLIGHT))
 752     {
 753       if (m_font.GetFamily () == wxROMAN)
 754         style = "-Italic";
 755       else
 756         style = "-Oblique";
 757     }
 758   else if (Style == wxSLANT && Weight == wxBOLD)
 759     {
 760       if (m_font.GetFamily () == wxROMAN)
 761         style = "-BoldItalic";
 762       else
 763         style = "-BoldOblique";
 764     }
 765   else
 766     style = "";
 767
 768   strcpy (buf, name);
 769   strcat (buf, style);
 770   *m_pstream << buf << " findfont\n";
 771   *m_pstream << (m_font.GetPointSize() * m_scaleFactor) << " scalefont setfont\n";
 772 }
 773
 774 void wxPostScriptDC::SetPen (const wxPen& pen)
 775 {
 776   if (!m_pstream)
 777     return;
 778
 779   int oldStyle = m_pen.GetStyle();
 780
 781   m_pen = pen;
 782
 783   if (!m_pen.Ok())
 784     return;
 785
 786   // Line width
 787   *m_pstream << m_pen.GetWidth () << " setlinewidth\n";
 788
 789   // Line style - WRONG: 2nd arg is OFFSET
 790   /*
 791      Here, I'm afraid you do not conceive meaning of parameters of 'setdash'
 792      operator correctly. You should look-up this in the Red Book: the 2nd parame-
 793      ter is not number of values in the array of the first one, but an offset
 794      into this description of the pattern. I mean a real *offset* not index
 795      into array. I.e. If the command is [3 4] 1 setdash   is used, then there
 796      will be first black line *2* units long, then space 4 units, then the
 797      pattern of *3* units black, 4 units space will be repeated.
 798    */
 799   static const char *dotted = "[2 5] 2";
 800   static const char *short_dashed = "[4 4] 2";
 801   static const char *long_dashed = "[4 8] 2";
 802   static const char *dotted_dashed = "[6 6 2 6] 4";
 803
 804   const char *psdash = (char *) NULL;
 805   switch (m_pen.GetStyle ())
 806     {
 807     case wxDOT:
 808       psdash = dotted;
 809       break;
 810     case wxSHORT_DASH:
 811       psdash = short_dashed;
 812       break;
 813     case wxLONG_DASH:
 814       psdash = long_dashed;
 815       break;
 816     case wxDOT_DASH:
 817       psdash = dotted_dashed;
 818       break;
 819     case wxSOLID:
 820     case wxTRANSPARENT:
 821     default:
 822       psdash = "[] 0";
 823       break;
 824     }
 825   if (oldStyle != m_pen.GetStyle())
 826     *m_pstream << psdash << " setdash\n";
 827
 828   // Line colour
 829   unsigned char red = m_pen.GetColour ().Red ();
 830   unsigned char blue = m_pen.GetColour ().Blue ();
 831   unsigned char green = m_pen.GetColour ().Green ();
 832
 833   if (!m_colour)
 834     {
 835       // Anything not white is black
 836       if (!(red == (unsigned char) 255 && blue == (unsigned char) 255
 837             && green == (unsigned char) 255))
 838         {
 839           red = (unsigned char) 0;
 840           green = (unsigned char) 0;
 841           blue = (unsigned char) 0;
 842         }
 843     }
 844
 845   if (!(red == m_currentRed && green == m_currentGreen && blue == m_currentBlue))
 846   {
 847     long redPS = (long) (((int) red) / 255.0);
 848     long bluePS = (long) (((int) blue) / 255.0);
 849     long greenPS = (long) (((int) green) / 255.0);
 850
 851     *m_pstream << redPS << " " << greenPS << " " << bluePS << " setrgbcolor\n";
 852
 853     m_currentRed = red;
 854     m_currentBlue = blue;
 855     m_currentGreen = green;
 856   }
 857 }
 858
 859 void wxPostScriptDC::SetBrush (const wxBrush& brush)
 860 {
 861   if (!m_pstream)
 862     return;
 863
 864   m_brush = brush;
 865
 866   if ( !m_brush.Ok() )
 867         return;
 868
 869   // Brush colour
 870   unsigned char red = m_brush.GetColour ().Red ();
 871   unsigned char blue = m_brush.GetColour ().Blue ();
 872   unsigned char green = m_brush.GetColour ().Green ();
 873
 874   if (!m_colour)
 875     {
 876       // Anything not black is white
 877       if (!(red == (unsigned char) 0 && blue == (unsigned char) 0
 878             && green == (unsigned char) 0))
 879         {
 880           red = (unsigned char) 255;
 881           green = (unsigned char) 255;
 882           blue = (unsigned char) 255;
 883         }
 884     }
 885
 886   if (!(red == m_currentRed && green == m_currentGreen && blue == m_currentBlue))
 887   {
 888     long redPS = (long) (((int) red) / 255.0);
 889     long bluePS = (long) (((int) blue) / 255.0);
 890     long greenPS = (long) (((int) green) / 255.0);
 891     *m_pstream << redPS << " " << greenPS << " " << bluePS << " setrgbcolor\n";
 892     m_currentRed = red;
 893     m_currentBlue = blue;
 894     m_currentGreen = green;
 895   }
 896 }
 897
 898 void wxPostScriptDC::DrawText (const wxString& text, long x, long y, bool WXUNUSED(use16bit))
 899 {
 900   if (!m_pstream)
 901     return;
 902
 903   // TODO: SetFont checks for identity so this will always be a NULL operation
 904   if (m_font.Ok())
 905     SetFont (m_font);
 906
 907   if (m_textForegroundColour.Ok ())
 908     {
 909       unsigned char red = m_textForegroundColour.Red ();
 910       unsigned char blue = m_textForegroundColour.Blue ();
 911       unsigned char green = m_textForegroundColour.Green ();
 912
 913       if (!m_colour)
 914         {
 915           // Anything not white is black
 916           if (!(red == (unsigned char) 255 && blue == (unsigned char) 255
 917                 && green == (unsigned char) 255))
 918             {
 919               red = (unsigned char) 0;
 920               green = (unsigned char) 0;
 921               blue = (unsigned char) 0;
 922             }
 923         }
 924       if (!(red == m_currentRed && green == m_currentGreen && blue == m_currentBlue))
 925       {
 926         long redPS = (long) (((int) red) / 255.0);
 927         long bluePS = (long) (((int) blue) / 255.0);
 928         long greenPS = (long) (((int) green) / 255.0);
 929         *m_pstream << redPS << " " << greenPS << " " << bluePS << " setrgbcolor\n";
 930
 931         m_currentRed = red;
 932         m_currentBlue = blue;
 933         m_currentGreen = green;
 934       }
 935     }
 936
 937   int size = 10;
 938   if (m_font.Ok())
 939     size = m_font.GetPointSize ();
 940
 941   *m_pstream << x << " " << YSCALE (y + size) << " moveto\n";
 942
 943 //  *m_pstream << "(" << text << ")" << " show\n";
 944   *m_pstream << "(";
 945   int len = strlen ((char *)(const char *)text);
 946   int i;
 947   for (i = 0; i < len; i++)
 948     {
 949 /*
 950       char ch = text[i];
 951       if (ch == ')' || ch == '(' || ch == '\\')
 952         *m_pstream << "\\";
 953       *m_pstream << ch;
 954 */
 955       int c = (unsigned char) text[i];
 956       if ( c == ')' || c == '(' || c == '\\')
 957       {
 958         *m_pstream << "\\" << (char) c;
 959       }
 960       else if ( c >= 128 )
 961       {
 962         // Cope with character codes > 127
 963         char tmp[5];
 964         sprintf(tmp, "\\%o", c);
 965         *m_pstream << tmp;
 966       }
 967       else
 968         *m_pstream << (char) c;
 969     }
 970
 971   *m_pstream << ")" << " show\n";
 972
 973   if (m_font.GetUnderlined())
 974   {
 975       long w, h;
 976       GetTextExtent(text, &w, &h);
 977       *m_pstream << "gsave " << x << " " << YSCALE (y + size - UnderlinePosition)
 978                << " moveto\n"
 979                << UnderlineThickness << " setlinewidth "
 980                << (x + w) << " " << YSCALE (y + size - UnderlinePosition)
 981                << " lineto stroke grestore\n";
 982   }
 983
 984   CalcBoundingBox (x, (long)YSCALE (y + size));
 985   CalcBoundingBox (x + size * strlen ((char *)(const char *)text), (long)YSCALE (y));
 986 }
 987
 988
 989 void wxPostScriptDC::SetBackground (const wxBrush& brush)
 990 {
 991   m_backgroundBrush = brush;
 992 }
 993
 994 void wxPostScriptDC::SetLogicalFunction (int WXUNUSED(function))
 995 {
 996 }
 997
 998 static const char *wxPostScriptHeaderEllipse = "\
 999 /ellipsedict 8 dict def\n\
1000 ellipsedict /mtrx matrix put\n\
1001 /ellipse\n\
1002 { ellipsedict begin\n\
1003   /endangle exch def\n\
1004   /startangle exch def\n\
1005   /yrad exch def\n\
1006   /xrad exch def\n\
1007   /y exch def\n\
1008   /x exch def\n\
1009   /savematrix mtrx currentmatrix def\n\
1010   x y translate\n\
1011   xrad yrad scale\n\
1012   0 0 1 startangle endangle arc\n\
1013   savematrix setmatrix\n\
1014   end\n\
1015   } def\n\
1016 ";
1017
1018 static const char *wxPostScriptHeaderEllipticArc= "\
1019 /ellipticarcdict 8 dict def\n\
1020 ellipticarcdict /mtrx matrix put\n\
1021 /ellipticarc\n\
1022 { ellipticarcdict begin\n\
1023   /do_fill exch def\n\
1024   /endangle exch def\n\
1025   /startangle exch def\n\
1026   /yrad exch def\n\
1027   /xrad exch def \n\
1028   /y exch def\n\
1029   /x exch def\n\
1030   /savematrix mtrx currentmatrix def\n\
1031   x y translate\n\
1032   xrad yrad scale\n\
1033   do_fill { 0 0 moveto } if\n\
1034   0 0 1 startangle endangle arc\n\
1035   savematrix setmatrix\n\
1036   do_fill { fill }{ stroke } ifelse\n\
1037   end\n\
1038 } def\n";
1039
1040 bool wxPostScriptDC::StartDoc (const wxString& message)
1041 {
1042     if (m_filename == "")
1043         {
1044 #ifdef __VMS__
1045           m_filename = "wxtmp.ps";
1046 #else
1047           m_filename = wxGetTempFileName("ps");
1048 #endif
1049           wxThePrintSetupData->SetPrinterFile((char *)(const char *)m_filename);
1050           m_ok = TRUE;
1051         }
1052       else
1053         wxThePrintSetupData->SetPrinterFile((char *)(const char *)m_filename);
1054
1055 #ifdef __VMS__
1056       // steve, 05.09.94
1057       // VMS is sh*t!
1058       m_pstream = new ofstream;
1059       if(fileBuffer) delete[] fileBuffer;
1060       fileBuffer = new char[VMS_BUFSIZ];
1061       m_pstream->setbuf(fileBuffer,VMS_BUFSIZ);
1062       m_pstream->open(wxThePrintSetupData->GetPrinterFile());
1063 #else
1064       m_pstream = new ofstream (wxThePrintSetupData->GetPrinterFile());
1065 #endif
1066       if (!m_pstream || !m_pstream->good())
1067         {
1068           wxMessageBox (_("Cannot open file!"), _("Error"), wxOK);
1069           m_ok = FALSE;
1070           return FALSE;
1071         }
1072   m_ok = TRUE;
1073
1074   SetBrush (*wxBLACK_BRUSH);
1075   SetPen (*wxBLACK_PEN);
1076
1077   wxPageNumber = 1;
1078   m_title = message;
1079   return TRUE;
1080 }
1081
1082
1083 void wxPostScriptDC::EndDoc (void)
1084 {
1085     static char wxPostScriptHeaderReencodeISO1[] =
1086     "\n/reencodeISO {\n"
1087 "dup dup findfont dup length dict begin\n"
1088 "{ 1 index /FID ne { def }{ pop pop } ifelse } forall\n"
1089 "/Encoding ISOLatin1Encoding def\n"
1090 "currentdict end definefont\n"
1091 "} def\n"
1092 "/ISOLatin1Encoding [\n"
1093 "/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef\n"
1094 "/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef\n"
1095 "/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef\n"
1096 "/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef\n"
1097 "/space/exclam/quotedbl/numbersign/dollar/percent/ampersand/quoteright\n"
1098 "/parenleft/parenright/asterisk/plus/comma/minus/period/slash\n"
1099 "/zero/one/two/three/four/five/six/seven/eight/nine/colon/semicolon\n"
1100 "/less/equal/greater/question/at/A/B/C/D/E/F/G/H/I/J/K/L/M/N\n"
1101 "/O/P/Q/R/S/T/U/V/W/X/Y/Z/bracketleft/backslash/bracketright\n"
1102 "/asciicircum/underscore/quoteleft/a/b/c/d/e/f/g/h/i/j/k/l/m\n"
1103 "/n/o/p/q/r/s/t/u/v/w/x/y/z/braceleft/bar/braceright/asciitilde\n"
1104 "/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef\n"
1105 "/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef\n"
1106 "/.notdef/dotlessi/grave/acute/circumflex/tilde/macron/breve\n"
1107 "/dotaccent/dieresis/.notdef/ring/cedilla/.notdef/hungarumlaut\n";
1108
1109     static char wxPostScriptHeaderReencodeISO2[] =
1110 "/ogonek/caron/space/exclamdown/cent/sterling/currency/yen/brokenbar\n"
1111 "/section/dieresis/copyright/ordfeminine/guillemotleft/logicalnot\n"
1112 "/hyphen/registered/macron/degree/plusminus/twosuperior/threesuperior\n"
1113 "/acute/mu/paragraph/periodcentered/cedilla/onesuperior/ordmasculine\n"
1114 "/guillemotright/onequarter/onehalf/threequarters/questiondown\n"
1115 "/Agrave/Aacute/Acircumflex/Atilde/Adieresis/Aring/AE/Ccedilla\n"
1116 "/Egrave/Eacute/Ecircumflex/Edieresis/Igrave/Iacute/Icircumflex\n"
1117 "/Idieresis/Eth/Ntilde/Ograve/Oacute/Ocircumflex/Otilde/Odieresis\n"
1118 "/multiply/Oslash/Ugrave/Uacute/Ucircumflex/Udieresis/Yacute\n"
1119 "/Thorn/germandbls/agrave/aacute/acircumflex/atilde/adieresis\n"
1120 "/aring/ae/ccedilla/egrave/eacute/ecircumflex/edieresis/igrave\n"
1121 "/iacute/icircumflex/idieresis/eth/ntilde/ograve/oacute/ocircumflex\n"
1122 "/otilde/odieresis/divide/oslash/ugrave/uacute/ucircumflex/udieresis\n"
1123 "/yacute/thorn/ydieresis\n"
1124         "] def\n\n";
1125
1126     if (!m_pstream)
1127         return;
1128   if (m_clipping)
1129     {
1130       m_clipping = FALSE;
1131       *m_pstream << "grestore\n";
1132     }
1133
1134   // Will reuse m_pstream for header
1135 #ifdef __VMS__
1136   // see the definition of fileBuffer for explanation
1137   m_pstream->close(); // steve, 05.09.94
1138   if(fileBuffer) delete[] fileBuffer;
1139 #endif
1140   if (m_pstream)
1141     {
1142       delete m_pstream;
1143       m_pstream = (ofstream *) NULL;
1144     }
1145
1146   // Write header now
1147 // steve, 05.09.94
1148 #ifdef __VMS__
1149   char *header_file = "header.ps";
1150 #else
1151   char *header_file = wxGetTempFileName("ps");
1152 #endif
1153   m_pstream = new ofstream (header_file);
1154
1155   *m_pstream << "%!PS-Adobe-2.0\n";     /* PostScript magic strings */
1156   *m_pstream << "%%Title: " << (const char *) m_title << "\n";
1157   *m_pstream << "%%Creator: " << wxTheApp->argv[0] << "\n";
1158 //  time_t when; time (&when);
1159 //  *m_pstream << "%%CreationDate: " << ctime (&when);
1160   *m_pstream << "%%CreationDate: " << wxNow() << "\n";
1161
1162   // User Id information
1163   char userID[256];
1164   if ( wxGetEmailAddress(userID, sizeof(userID)) )
1165   {
1166     *m_pstream << "%%For: " << (char *)userID;
1167     char userName[245];
1168     if (wxGetUserName(userName, sizeof(userName)))
1169       *m_pstream << " (" << (char *)userName << ")";
1170     *m_pstream << "\n";
1171   }
1172   else if ( wxGetUserName(userID, sizeof(userID)) )
1173   {
1174     *m_pstream << "%%For: " << (char *)userID << "\n";
1175   }
1176
1177   // THE FOLLOWING HAS BEEN CONTRIBUTED BY Andy Fyfe <andy@hyperparallel.com>
1178
1179   long wx_printer_translate_x, wx_printer_translate_y;
1180   double wx_printer_scale_x, wx_printer_scale_y;
1181   wxThePrintSetupData->GetPrinterTranslation(&wx_printer_translate_x, &wx_printer_translate_y);
1182   wxThePrintSetupData->GetPrinterScaling(&wx_printer_scale_x, &wx_printer_scale_y);
1183
1184         if (wxThePrintSetupData->GetPrinterOrientation() == PS_LANDSCAPE)
1185         {
1186                 *m_pstream << "%%Orientation: Landscape\n";
1187         }
1188         else
1189         {
1190                 *m_pstream << "%%Orientation: Portrait\n";
1191         }
1192
1193   // Compute the bounding box.  Note that it is in the default user
1194   // coordinate system, thus we have to convert the values.
1195   long llx = (long) ((m_minX+wx_printer_translate_x)*wx_printer_scale_x);
1196   long lly = (long) ((m_minY+wx_printer_translate_y)*wx_printer_scale_y);
1197   long urx = (long) ((m_maxX+wx_printer_translate_x)*wx_printer_scale_x);
1198   long ury = (long) ((m_maxY+wx_printer_translate_y)*wx_printer_scale_y);
1199
1200 #if 0
1201   // If we're landscape, our sense of "x" and "y" is reversed.
1202   if (wxThePrintSetupData->GetPrinterOrientation() == PS_LANDSCAPE)
1203     {
1204       double tmp;
1205       tmp = llx; llx = lly; lly = tmp;
1206       tmp = urx; urx = ury; ury = tmp;
1207
1208       // We need either the two lines that follow, or we need to subtract
1209       // min_x from real_translate_y, which is commented out below.
1210       llx = llx - m_minX*wx_printer_scale_y;
1211       urx = urx - m_minX*wx_printer_scale_y;
1212     }
1213 #endif
1214
1215   // The Adobe specifications call for integers; we round as to make
1216   // the bounding larger.
1217   *m_pstream << "%%BoundingBox: "
1218       << floor((double)llx) << " " << floor((double)lly) << " "
1219       << ceil((double)urx)  << " " << ceil((double)ury)  << "\n";
1220   *m_pstream << "%%Pages: " << (wxPageNumber - 1) << "\n";
1221   *m_pstream << "%%EndComments\n\n";
1222
1223   // To check the correctness of the bounding box, postscript commands
1224   // to draw a box corresponding to the bounding box are generated below.
1225   // But since we typically don't want to print such a box, the postscript
1226   // commands are generated within comments.  These lines appear before any
1227   // adjustment of scale, rotation, or translation, and hence are in the
1228   // default user coordinates.
1229   *m_pstream << "% newpath\n";
1230   *m_pstream << "% " << llx << " " << lly << " moveto\n";
1231   *m_pstream << "% " << urx << " " << lly << " lineto\n";
1232   *m_pstream << "% " << urx << " " << ury << " lineto\n";
1233   *m_pstream << "% " << llx << " " << ury << " lineto closepath stroke\n";
1234
1235 #if 0
1236   // Output scaling
1237   long real_translate_y = wx_printer_translate_y;
1238   if (wxThePrintSetupData->GetPrinterOrientation() == PS_LANDSCAPE)
1239     {
1240       real_translate_y -= m_maxY;
1241       // The following line can be used instead of the adjustment to
1242       // llx and urx above.
1243       // real_translate_y -= m_minX;
1244       *m_pstream << "90 rotate\n";
1245     }
1246
1247 /* Probably don't want this now we have it in EndPage, below.
1248  * We should rationalise the scaling code to one place. JACS, October 1995
1249  * Do we take the next 2 lines out or not?
1250  */
1251
1252   *m_pstream << wx_printer_scale_x << " " << wx_printer_scale_y << " scale\n";
1253   *m_pstream << wx_printer_translate_x << " " << real_translate_y << " translate\n";
1254 #endif
1255
1256   *m_pstream << "%%BeginProlog\n";
1257   *m_pstream << wxPostScriptHeaderEllipse;
1258   *m_pstream << wxPostScriptHeaderEllipticArc;
1259   *m_pstream << wxPostScriptHeaderReencodeISO1;
1260   *m_pstream << wxPostScriptHeaderReencodeISO2;
1261
1262   if (wxPostScriptHeaderSpline)
1263     *m_pstream << wxPostScriptHeaderSpline;
1264   *m_pstream << "%%EndProlog\n";
1265
1266   delete m_pstream;
1267   m_pstream = (ofstream *) NULL;
1268
1269 #ifdef __VMS__
1270   char *tmp_file = "tmp.ps";
1271 #else
1272   char *tmp_file = wxGetTempFileName("ps");
1273 #endif
1274
1275   // Paste header Before wx_printer_file
1276   wxConcatFiles (header_file, wxThePrintSetupData->GetPrinterFile(), tmp_file);
1277   wxRemoveFile (header_file);
1278   wxRemoveFile (wxThePrintSetupData->GetPrinterFile());
1279   wxRenameFile(tmp_file, wxThePrintSetupData->GetPrinterFile());
1280
1281 #if defined(__X__) || defined(__WXGTK__)
1282   if (m_ok)
1283     {
1284       switch (wxThePrintSetupData->GetPrinterMode()) {
1285         case PS_PREVIEW:
1286         {
1287           char *argv[3];
1288           argv[0] = wxThePrintSetupData->GetPrintPreviewCommand();
1289           argv[1] = wxThePrintSetupData->GetPrinterFile();
1290           argv[2] = (char *) NULL;
1291           wxExecute (argv, TRUE);
1292           wxRemoveFile(wxThePrintSetupData->GetPrinterFile());
1293         }
1294         break;
1295
1296         case PS_PRINTER:
1297         {
1298           char *argv[4];
1299           int argc = 0;
1300           argv[argc++] = wxThePrintSetupData->GetPrinterCommand();
1301
1302           // !SM! If we simply assign to argv[1] here, if printer options
1303           // are blank, we get an annoying and confusing message from lpr.
1304           char * opts = wxThePrintSetupData->GetPrinterOptions();
1305           if (opts && *opts)
1306               argv[argc++] = opts;
1307
1308           argv[argc++] = wxThePrintSetupData->GetPrinterFile();
1309           argv[argc++] = (char *) NULL;
1310           wxExecute (argv, TRUE);
1311           wxRemoveFile(wxThePrintSetupData->GetPrinterFile());
1312         }
1313         break;
1314
1315         case PS_FILE:
1316           break;
1317         }
1318     }
1319 #endif
1320 }
1321
1322 void wxPostScriptDC::StartPage (void)
1323 {
1324   if (!m_pstream)
1325     return;
1326   *m_pstream << "%%Page: " << (wxPageNumber++) << "\n";
1327 //  *m_pstream << "matrix currentmatrix\n";
1328
1329     // Added by Chris Breeze
1330
1331         // Each page starts with an "initgraphics" which resets the
1332         // transformation and so we need to reset the origin
1333         // (and rotate the page for landscape printing)
1334         m_scaleFactor = 1.0;
1335         m_logicalOriginX = 0;
1336         m_logicalOriginY = 0;
1337
1338         // Output scaling
1339         long translate_x, translate_y;
1340         double scale_x, scale_y;
1341         wxThePrintSetupData->GetPrinterTranslation(&translate_x, &translate_y);
1342         wxThePrintSetupData->GetPrinterScaling(&scale_x, &scale_y);
1343
1344         if (wxThePrintSetupData->GetPrinterOrientation() == PS_LANDSCAPE)
1345         {
1346                 translate_y -= GetYOrigin();
1347                 *m_pstream << "90 rotate\n";
1348         }
1349
1350         *m_pstream << scale_x << " " << scale_y << " scale\n";
1351         *m_pstream << translate_x << " " << translate_y << " translate\n";
1352 }
1353
1354 void wxPostScriptDC::EndPage (void)
1355 {
1356   if (!m_pstream)
1357     return;
1358   *m_pstream << "showpage\n";
1359
1360   // Removed by Chris Breeze
1361 #if 0
1362   *m_pstream << "setmatrix\n";
1363
1364   // THE FOLLOWING HAS BEEN CONTRIBUTED BY Andy Fyfe <andy@hyperparallel.com>
1365
1366   long wx_printer_translate_x, wx_printer_translate_y;
1367   double wx_printer_scale_x, wx_printer_scale_y;
1368   wxThePrintSetupData->GetPrinterTranslation(&wx_printer_translate_x, &wx_printer_translate_y);
1369   wxThePrintSetupData->GetPrinterScaling(&wx_printer_scale_x, &wx_printer_scale_y);
1370
1371   // Compute the bounding box.  Note that it is in the default user
1372   // coordinate system, thus we have to convert the values.
1373   long llx = (m_minX+wx_printer_translate_x)*wx_printer_scale_x;
1374   long lly = (m_minY+wx_printer_translate_y)*wx_printer_scale_y;
1375   long urx = (m_maxX+wx_printer_translate_x)*wx_printer_scale_x;
1376   long ury = (m_maxY+wx_printer_translate_y)*wx_printer_scale_y;
1377
1378   // If we're landscape, our sense of "x" and "y" is reversed.
1379   if (wxThePrintSetupData->GetPrinterOrientation() == PS_LANDSCAPE)
1380     {
1381       long tmp;
1382       tmp = llx; llx = lly; lly = tmp;
1383       tmp = urx; urx = ury; ury = tmp;
1384
1385       // We need either the two lines that follow, or we need to subtract
1386       // m_minX from real_translate_y, which is commented out below.
1387       llx = llx - m_minX*wx_printer_scale_y;
1388       urx = urx - m_minX*wx_printer_scale_y;
1389     }
1390
1391   // Output scaling
1392   long real_translate_y = wx_printer_translate_y;
1393   if (wxThePrintSetupData->GetPrinterOrientation() == PS_LANDSCAPE)
1394     {
1395       real_translate_y -= m_maxY;
1396       // The following line can be used instead of the adjustment to
1397       // llx and urx above.
1398       // real_translate_y -= m_minX;
1399       *m_pstream << "90 rotate\n";
1400     }
1401
1402   *m_pstream << wx_printer_scale_x << " " << wx_printer_scale_y << " scale\n";
1403   *m_pstream << wx_printer_translate_x << " " << real_translate_y << " translate\n";
1404 #endif
1405 }
1406
1407 bool wxPostScriptDC::
1408 Blit (long xdest, long ydest, long fwidth, long fheight,
1409       wxDC *source, long xsrc, long ysrc, int WXUNUSED(rop), bool WXUNUSED(useMask))
1410 {
1411   long width, height, x, y;
1412
1413 #if !defined(__X__) && !defined(__WXGTK__)
1414   return FALSE;
1415 #endif
1416
1417   if (!source->IsKindOf(CLASSINFO(wxPaintDC))) return FALSE;
1418
1419   width = (long)floor((double)fwidth);
1420   height = (long)floor((double)fheight);
1421   x = (long)floor((double)xsrc);
1422   y = (long)floor((double)ysrc);
1423
1424   /* PostScript setup: */
1425   *m_pstream << "gsave\n";
1426   *m_pstream << xdest << " " << YSCALE(ydest + fheight) << " translate\n";
1427   *m_pstream << fwidth << " " << fheight << " scale\n";
1428   *m_pstream << "/DataString " << width << " string def\n";
1429   *m_pstream << width << " " << height << " 8 [ ";
1430   *m_pstream << width << " 0 0 " << (-height) << " 0 " << height;
1431   *m_pstream << " ]\n{\n";
1432   *m_pstream << "  currentfile DataString readhexstring pop\n";
1433   *m_pstream << "} bind image\n";
1434
1435 #if defined(__X__) || defined(__WXGTK__)
1436
1437   /* Output data as hex digits: */
1438   Display *d;
1439   Colormap cm;
1440   XImage *image;
1441   long j, i;
1442   char s[3];
1443
1444 #ifdef __WXGTK__
1445
1446   d = gdk_display;
1447   cm = ((GdkColormapPrivate*)gdk_colormap_get_system())->xcolormap;
1448   GdkWindow *gwin = ((wxClientDC*)source)->GetWindow();
1449   image = XGetImage(d, ((GdkWindowPrivate*)gwin)->xwindow, x, y, width, height, AllPlanes, ZPixmap);
1450
1451 #else
1452
1453 #ifdef __WXMOTIF__
1454   // TODO. for now, use global display
1455   //  d = source->display;
1456   d = (Display*) wxGetDisplay();
1457 #else
1458   d = (Display*) wxGetDisplay();
1459 #endif
1460
1461   cm = (Colormap) wxTheApp->GetMainColormap((WXDisplay*) d);
1462   // TODO - implement GetPixmap() and uncomment this line
1463   //  image = XGetImage(d, source->GetPixmap(), x, y, width, height, AllPlanes, ZPixmap);
1464
1465 #endif
1466
1467
1468   s[2] = 0;
1469
1470 #define CM_CACHE_SIZE 256
1471   unsigned long cachesrc[CM_CACHE_SIZE];
1472   int cachedest[CM_CACHE_SIZE], cache_pos = 0, all_cache = FALSE;
1473
1474   for (j = 0; j < height; j++) {
1475     for (i = 0; i < width; i++) {
1476       XColor xcol;
1477       unsigned long spixel;
1478       int pixel, k;
1479       const unsigned short MAX_COLOR = 0xFFFF;
1480
1481       spixel = XGetPixel(image, i, j);
1482
1483       for (k = cache_pos; k--; )
1484         if (cachesrc[k] == spixel) {
1485           pixel = cachedest[k];
1486           goto install;
1487         }
1488       if (all_cache)
1489         for (k = CM_CACHE_SIZE; k-- > cache_pos; )
1490           if (cachesrc[k] == spixel) {
1491             pixel = cachedest[k];
1492             goto install;
1493           }
1494
1495       cachesrc[cache_pos] = xcol.pixel = spixel;
1496       XQueryColor(d, cm, &xcol);
1497
1498       long r, g, b;
1499
1500       r = (long)((double)(xcol.red) / MAX_COLOR);
1501       g = (long)((double)(xcol.green) / MAX_COLOR);
1502       b = (long)((double)(xcol.blue) / MAX_COLOR);
1503
1504       pixel = (int)(255 * sqrt(((r * r) + (g * g) + (b * b)) / 3));
1505
1506       cachedest[cache_pos] = pixel;
1507
1508       if (++cache_pos >= CM_CACHE_SIZE) {
1509         cache_pos = 0;
1510         all_cache = TRUE;
1511       }
1512
1513     install:
1514       int h, l;
1515
1516       h = (pixel >> 4) & 0xF;
1517       l = pixel & 0xF;
1518
1519       if (h <= 9)
1520         s[0] = '0' + h;
1521       else
1522         s[0] = 'a' + (h - 10);
1523       if (l <= 9)
1524         s[1] = '0' + l;
1525       else
1526         s[1] = 'a' + (l - 10);
1527
1528       *m_pstream << s;
1529     }
1530     *m_pstream << "\n";
1531   }
1532
1533   XDestroyImage(image);
1534 #endif
1535
1536   *m_pstream << "grestore\n";
1537
1538   CalcBoundingBox(xdest, (long)YSCALE(ydest));
1539   CalcBoundingBox(xdest + fwidth, (long)YSCALE(ydest + fheight));
1540
1541   return TRUE;
1542 }
1543
1544 long wxPostScriptDC::GetCharHeight (void)
1545 {
1546   if (m_font.Ok())
1547     return  m_font.GetPointSize ();
1548   else
1549     return 12;
1550 }
1551
1552 void wxPostScriptDC::GetTextExtent (const wxString& string, long *x, long *y,
1553                long *descent, long *externalLeading, wxFont *theFont,
1554                                     bool WXUNUSED(use16))
1555 {
1556   wxFont *fontToUse = theFont;
1557   if (!fontToUse)
1558     fontToUse = (wxFont*) &m_font;
1559
1560   if (!m_pstream)
1561     return;
1562 #if !USE_AFM_FOR_POSTSCRIPT
1563   // Provide a VERY rough estimate (avoid using it)
1564         // Chris Breeze 5/11/97: produces accurate results for mono-spaced
1565         // font such as Courier (aka wxMODERN)
1566         int height = 12;
1567         if (fontToUse)
1568         {
1569                 height = fontToUse->GetPointSize();
1570         }
1571         *x = strlen (string) * height * 72 / 120;
1572         *y = (long) (height * 1.32);    // allow for descender
1573
1574   if (descent)
1575     *descent = 0;
1576   if (externalLeading)
1577     *externalLeading = 0;
1578 #else
1579   // +++++ start of contributed code +++++
1580
1581   // ************************************************************
1582   // method for calculating string widths in postscript:
1583   // read in the AFM (adobe font metrics) file for the
1584   // actual font, parse it and extract the character widths
1585   // and also the descender. this may be improved, but for now
1586   // it works well. the AFM file is only read in if the
1587   // font is changed. this may be chached in the future.
1588   // calls to GetTextExtent with the font unchanged are rather
1589   // efficient!!!
1590   //
1591   // for each font and style used there is an AFM file necessary.
1592   // currently i have only files for the roman font family.
1593   // i try to get files for the other ones!
1594   //
1595   // CAVE: the size of the string is currently always calculated
1596   //       in 'points' (1/72 of an inch). this should later on be
1597   //       changed to depend on the mapping mode.
1598   // CAVE: the path to the AFM files must be set before calling this
1599   //       function. this is usually done by a call like the following:
1600   //       wxSetAFMPath("d:\\wxw161\\afm\\");
1601   //
1602   // example:
1603   //
1604   //    wxPostScriptDC dc(NULL, TRUE);
1605   //    if (dc.Ok()){
1606   //      wxSetAFMPath("d:\\wxw161\\afm\\");
1607   //      dc.StartDoc("Test");
1608   //      dc.StartPage();
1609   //      long w,h;
1610   //      dc.SetFont(new wxFont(10, wxROMAN, wxNORMAL, wxNORMAL));
1611   //      dc.GetTextExtent("Hallo",&w,&h);
1612   //      dc.EndPage();
1613   //      dc.EndDoc();
1614   //    }
1615   //
1616   // by steve (stefan.hammes@urz.uni-heidelberg.de)
1617   // created: 10.09.94
1618   // updated: 14.05.95
1619
1620   assert(fontToUse && "void wxPostScriptDC::GetTextExtent: no font defined");
1621   assert(x && "void wxPostScriptDC::GetTextExtent: x == NULL");
1622   assert(y && "void wxPostScriptDC::GetTextExtent: y == NULL");
1623
1624   // these static vars are for storing the state between calls
1625   static int lastFamily= INT_MIN;
1626   static int lastSize= INT_MIN;
1627   static int lastStyle= INT_MIN;
1628   static int lastWeight= INT_MIN;
1629   static int lastDescender = INT_MIN;
1630   static int lastWidths[256]; // widths of the characters
1631
1632   // get actual parameters
1633   const int Family = fontToUse->GetFamily();
1634   const int Size =   fontToUse->GetPointSize();
1635   const int Style =  fontToUse->GetStyle();
1636   const int Weight = fontToUse->GetWeight();
1637
1638   // if we have another font, read the font-metrics
1639   if(Family!=lastFamily||Size!=lastSize||Style!=lastStyle||Weight!=lastWeight){
1640     // store actual values
1641     lastFamily = Family;
1642     lastSize =   Size;
1643     lastStyle =  Style;
1644     lastWeight = Weight;
1645
1646     // read in new font metrics **************************************
1647
1648     // 1. construct filename ******************************************
1649     /* MATTHEW: [2] Use wxTheFontNameDirectory */
1650     const char *name;
1651
1652         // Julian - we'll need to do this a different way now we've removed the
1653         // font directory system. Must find Stefan's original code.
1654
1655     name = wxTheFontNameDirectory->GetAFMName(Family, Weight, Style);
1656     if (!name)
1657       name = "unknown";
1658
1659     // get the directory of the AFM files
1660     char afmName[256];
1661     afmName[0] = 0;
1662     if (wxGetAFMPath())
1663       strcpy(afmName,wxGetAFMPath());
1664
1665     // 2. open and process the file **********************************
1666
1667     // a short explanation of the AFM format:
1668     // we have for each character a line, which gives its size
1669     // e.g.:
1670     //
1671     //   C 63 ; WX 444 ; N question ; B 49 -14 395 676 ;
1672     //
1673     // that means, we have a character with ascii code 63, and width
1674     // (444/1000 * fontSize) points.
1675     // the other data is ignored for now!
1676     //
1677     // when the font has changed, we read in the right AFM file and store the
1678     // character widths in an array, which is processed below (see point 3.).
1679
1680         // new elements JC Sun Aug 25 23:21:44 MET DST 1996
1681
1682
1683     strcat(afmName,name);
1684     strcat(afmName,".afm");
1685     FILE *afmFile = fopen(afmName,"r");
1686     if(afmFile==NULL){
1687       wxDebugMsg("GetTextExtent: can't open AFM file '%s'\n",afmName);
1688       wxDebugMsg("               using approximate values\n");
1689       int i;
1690       for (i=0; i<256; i++) lastWidths[i] = 500; // an approximate value
1691       lastDescender = -150; // dito.
1692     }else{
1693       int i;
1694       // init the widths array
1695       for(i=0; i<256; i++) lastWidths[i]= INT_MIN;
1696       // some variables for holding parts of a line
1697       char cString[10],semiString[10],WXString[10],descString[20];
1698       char upString[30], utString[30], encString[50];
1699       char line[256];
1700       int ascii,cWidth;
1701       // read in the file and parse it
1702       while(fgets(line,sizeof(line),afmFile)!=NULL){
1703         // A.) check for descender definition
1704         if(strncmp(line,"Descender",9)==0){
1705           if((sscanf(line,"%s%d",descString,&lastDescender)!=2)
1706              || (strcmp(descString,"Descender")!=0)) {
1707             wxDebugMsg("AFM-file '%s': line '%s' has error (bad descender)\n",
1708                        afmName,line);
1709           }
1710         }
1711             // JC 1.) check for UnderlinePosition
1712         else if(strncmp(line,"UnderlinePosition",17)==0){
1713           if((sscanf(line,"%s%lf",upString,&UnderlinePosition)!=2)
1714              || (strcmp(upString,"UnderlinePosition")!=0)) {
1715             wxDebugMsg("AFM-file '%s': line '%s' has error (bad UnderlinePosition)\n",
1716                        afmName,line);
1717           }
1718         }
1719         // JC 2.) check for UnderlineThickness
1720         else if(strncmp(line,"UnderlineThickness",18)==0){
1721            if((sscanf(line,"%s%lf",utString,&UnderlineThickness)!=2)
1722              || (strcmp(utString,"UnderlineThickness")!=0)) {
1723             wxDebugMsg("AFM-file '%s': line '%s' has error (bad UnderlineThickness)\n",
1724                        afmName,line);
1725           }
1726         }
1727         // JC 3.) check for EncodingScheme
1728         else if(strncmp(line,"EncodingScheme",14)==0){
1729           if((sscanf(line,"%s%s",utString,encString)!=2)
1730              || (strcmp(utString,"EncodingScheme")!=0)) {
1731             wxDebugMsg("AFM-file '%s': line '%s' has error (bad EncodingScheme)\n",
1732                        afmName,line);
1733           }
1734           else if (strncmp(encString, "AdobeStandardEncoding", 21))
1735           {
1736             wxDebugMsg("AFM-file '%s': line '%s' has error (unsupported EncodingScheme %s)\n",
1737                        afmName,line, encString);
1738           }
1739         }
1740             // B.) check for char-width
1741         else if(strncmp(line,"C ",2)==0){
1742           if(sscanf(line,"%s%d%s%s%d",
1743               cString,&ascii,semiString,WXString,&cWidth)!=5){
1744              wxDebugMsg("AFM-file '%s': line '%s' has an error (bad character width)\n",afmName,line);
1745           }
1746           if(strcmp(cString,"C")!=0 || strcmp(semiString,";")!=0 ||
1747              strcmp(WXString,"WX")!=0){
1748              wxDebugMsg("AFM-file '%s': line '%s' has a format error\n",afmName,line);
1749           }
1750           //printf("            char '%c'=%d has width '%d'\n",ascii,ascii,cWidth);
1751           if(ascii>=0 && ascii<256){
1752             lastWidths[ascii] = cWidth; // store width
1753           }else{
1754             /* MATTHEW: this happens a lot; don't print an error */
1755             // wxDebugMsg("AFM-file '%s': ASCII value %d out of range\n",afmName,ascii);
1756           }
1757         }
1758         // C.) ignore other entries.
1759       }
1760       fclose(afmFile);
1761     }
1762         // hack to compute correct values for german 'Umlaute'
1763         // the correct way would be to map the character names
1764         // like 'adieresis' to corresp. positions of ISOEnc and read
1765         // these values from AFM files, too. Maybe later ...
1766     lastWidths[196] = lastWidths['A'];  // Ä
1767     lastWidths[228] = lastWidths['a'];  // ä
1768     lastWidths[214] = lastWidths['O'];  // Ö
1769     lastWidths[246] = lastWidths['o'];  // ö
1770     lastWidths[220] = lastWidths['U'];  // Ü
1771     lastWidths[252] = lastWidths['u'];  // ü
1772     lastWidths[223] = lastWidths[251];  // ß
1773   }
1774
1775       // JC: calculate UnderlineThickness/UnderlinePosition
1776   UnderlinePosition = UnderlinePosition * fontToUse->GetPointSize() / 1000.0f;
1777   UnderlineThickness = UnderlineThickness * fontToUse->GetPointSize() / 1000.0f * m_scaleFactor;
1778
1779   // 3. now the font metrics are read in, calc size *******************
1780   // this is done by adding the widths of the characters in the
1781   // string. they are given in 1/1000 of the size!
1782
1783   long widthSum=0;
1784   long height=Size; // by default
1785   unsigned char *p;
1786   for(p=(unsigned char *)(const char *)string; *p; p++){
1787     if(lastWidths[*p]== INT_MIN){
1788       wxDebugMsg("GetTextExtent: undefined width for character '%c' (%d)\n",
1789                  *p,*p);
1790       widthSum += (long)(lastWidths[' ']/1000.0F * Size); // assume space
1791     }else{
1792       widthSum += (long)((lastWidths[*p]/1000.0F)*Size);
1793     }
1794   }
1795   // add descender to height (it is usually a negative value)
1796   if(lastDescender!=INT_MIN){
1797     height += (long)(((-lastDescender)/1000.0F) * Size); /* MATTHEW: forgot scale */
1798   }
1799
1800   // return size values
1801   *x = widthSum;
1802   *y = height;
1803
1804   // return other parameters
1805   if (descent){
1806     if(lastDescender!=INT_MIN){
1807       *descent = (long)(((-lastDescender)/1000.0F) * Size); /* MATTHEW: forgot scale */
1808     }else{
1809       *descent = 0;
1810     }
1811   }
1812
1813   // currently no idea how to calculate this!
1814   // if (externalLeading) *externalLeading = 0;
1815   if (externalLeading)
1816     *externalLeading = 0;
1817
1818   // ----- end of contributed code -----
1819 #endif
1820 }
1821
1822 void wxPostScriptDC::DrawSpline( wxList *points )
1823 {
1824         double          a, b, c, d, x1, y1, x2, y2, x3, y3;
1825         wxPoint *p, *q;
1826
1827         wxNode *node = points->First();
1828         p = (wxPoint *)node->Data();
1829
1830         x1 = p->x; y1 = p->y;
1831
1832         node = node->Next();
1833         p = (wxPoint *)node->Data();
1834         c = p->x; d = p->y;
1835         x3 = a = (double)(x1 + c) / 2;
1836         y3 = b = (double)(y1 + d) / 2;
1837
1838         *(GetStream()) << "newpath " << x1 << " " << (GetYOrigin() - y1) << " moveto " << x3 << " " << (GetYOrigin() - y3);
1839         *(GetStream()) << " lineto\n";
1840         CalcBoundingBox( (long)x1, (long)(GetYOrigin() - y1));
1841         CalcBoundingBox( (long)x3, (long)(GetYOrigin() - y3));
1842
1843         while ((node = node->Next()) != NULL)
1844         {
1845           q = (wxPoint *)node->Data();
1846
1847           x1 = x3; y1 = y3;
1848           x2 = c;  y2 = d;
1849           c = q->x; d = q->y;
1850           x3 = (double)(x2 + c) / 2;
1851           y3 = (double)(y2 + d) / 2;
1852           *(GetStream()) << x1 << " " << (GetYOrigin() - y1) << " " << x2 << " " << (GetYOrigin() - y2) << " ";
1853           *(GetStream()) << x3 << " " << (GetYOrigin() - y3) << " DrawSplineSection\n";
1854
1855           CalcBoundingBox( (long)x1, (long)(GetYOrigin() - y1));
1856           CalcBoundingBox( (long)x3, (long)(GetYOrigin() - y3));
1857         }
1858         /*
1859         * At this point, (x2,y2) and (c,d) are the position of the
1860         * next-to-last and last point respectively, in the point list
1861         */
1862         *(GetStream()) << c << " " << (GetYOrigin() - d) << " lineto stroke\n";
1863 }
1864
1865 long wxPostScriptDC::GetCharWidth (void)
1866 {
1867         // Chris Breeze: reasonable approximation using wxMODERN/Courier
1868         return (long) (GetCharHeight() * 72.0 / 120.0);
1869 }
1870
1871
1872 void wxPostScriptDC::SetMapMode (int mode)
1873 {
1874         m_mappingMode = mode;
1875         SetLogicalOrigin(0, 0);
1876         if(m_mappingMode == MM_METRIC)
1877         {
1878                 SetUserScale(72.0f / 25.4f, 72.0f / 25.4f);
1879         }
1880         else
1881         {
1882                 SetUserScale(1.0, 1.0);
1883         }
1884   return;
1885 }
1886
1887 /*
1888  * Set the logical origin.
1889  * Actually we are setting the printer's origin and since
1890  * postscript transformations are cumulative we need to reset
1891  * the previous origin. We also need to allow for the user scale
1892  * factor (which affects printer coords but not logical)
1893  */
1894 void wxPostScriptDC::SetLogicalOrigin(long x, long y)
1895 {
1896         if (m_scaleFactor)
1897         {
1898                 long xOffset = (long) ((m_logicalOriginX - x) / m_scaleFactor);
1899                 long yOffset = (long) ((y - m_logicalOriginY) / m_scaleFactor);
1900
1901                 if (m_pstream)
1902                 {
1903                         *m_pstream << xOffset << " " << yOffset << " translate\n";
1904                 }
1905         }
1906         m_logicalOriginX = x;
1907         m_logicalOriginY = y;
1908 }
1909
1910 /*
1911  * Obsolete - now performed by SetUserScale() and SetLogicalOrigin()
1912  */
1913 void
1914 wxPostScriptDC::SetupCTM()
1915 {
1916 }
1917
1918 /*
1919  * Set the user scale.
1920  * NB: Postscript transformations are cumulative and so we
1921  * need to take into account the current scale. Also, this
1922  * affects the logical origin
1923  */
1924 void wxPostScriptDC::SetUserScale (double x, double y)
1925 {
1926         // reset logical origin
1927         long xOrg = m_logicalOriginX;
1928         long yOrg = m_logicalOriginY;
1929         SetLogicalOrigin(0, 0);
1930
1931         // set new scale factor
1932         double factor = x;
1933         if (m_scaleFactor)
1934         {
1935                 factor /= m_scaleFactor;
1936         }
1937         if (m_pstream)
1938         {
1939                 *m_pstream << factor << " " << factor << " scale\n";
1940         }
1941
1942         // set logical origin at new scale
1943         SetLogicalOrigin(xOrg, yOrg);
1944
1945         m_userScaleX = x;
1946         m_userScaleY = y;
1947
1948         m_scaleFactor = m_userScaleX;
1949 }
1950
1951 long wxPostScriptDC::DeviceToLogicalX (int x) const
1952 {
1953   return  x;
1954 }
1955
1956 long wxPostScriptDC::DeviceToLogicalXRel (int x) const
1957 {
1958   return  x;
1959 }
1960
1961 long wxPostScriptDC::DeviceToLogicalY (int y) const
1962 {
1963   return  y;
1964 }
1965
1966 long wxPostScriptDC::DeviceToLogicalYRel (int y) const
1967 {
1968   return  y;
1969 }
1970
1971 long wxPostScriptDC::LogicalToDeviceX (long x) const
1972 {
1973   return x;
1974 }
1975
1976 long wxPostScriptDC::LogicalToDeviceXRel (long x) const
1977 {
1978   return x;
1979 }
1980
1981 long wxPostScriptDC::LogicalToDeviceY (long y) const
1982 {
1983   return y;
1984 }
1985
1986 long wxPostScriptDC::LogicalToDeviceYRel (long y) const
1987 {
1988   return y;
1989 }
1990
1991 void wxPostScriptDC::GetSize(int* width, int* height) const
1992 {
1993   const char *paperType = wxThePrintSetupData->GetPaperName();
1994   if (!paperType)
1995     paperType = _("A4 210 x 297 mm");
1996
1997   wxPrintPaperType *paper = wxThePrintPaperDatabase->FindPaperType(paperType);
1998   if (!paper)
1999     paper = wxThePrintPaperDatabase->FindPaperType(_("A4 210 x 297 mm"));
2000   if (paper)
2001   {
2002     *width = paper->widthPixels;
2003     *height = paper->heightPixels;
2004   }
2005   else
2006   {
2007     *width = 1000;
2008     *height = 1000;
2009   }
2010 }
2011
2012 void wxPostScriptDC::GetSizeMM(long *width, long *height) const
2013 {
2014   const char *paperType = wxThePrintSetupData->GetPaperName();
2015   if (!paperType)
2016     paperType = _("A4 210 x 297 mm");
2017
2018   wxPrintPaperType *paper = wxThePrintPaperDatabase->FindPaperType(paperType);
2019   if (!paper)
2020     paper = wxThePrintPaperDatabase->FindPaperType(_("A4 210 x 297 mm"));
2021   if (paper)
2022   {
2023     *width = paper->widthMM;
2024     *height = paper->heightMM;
2025   }
2026   else
2027   {
2028     *width = 1000;
2029     *height = 1000;
2030   }
2031 }
2032
2033 void wxPostScriptDC::CalcBoundingBox(long x, long y)
2034 {
2035     long device_x = (long) (x - m_logicalOriginX * m_scaleFactor);
2036     long device_y = (long) (y + m_logicalOriginY * m_scaleFactor);
2037
2038     if (device_x < m_minX) m_minX = device_x;
2039     if (device_y < m_minY) m_minY = device_y;
2040     if (device_x > m_maxX) m_maxX = device_x;
2041     if (device_y > m_maxY) m_maxY = device_y;
2042 }
2043
2044 IMPLEMENT_CLASS(wxPostScriptPrintDialog, wxDialog)
2045
2046 wxPostScriptPrintDialog::wxPostScriptPrintDialog (wxWindow *parent, const wxString& title,
2047                     const wxPoint& pos, const wxSize& size, long style):
2048 wxDialog(parent, -1, title, pos, size, style)
2049 {
2050   wxBeginBusyCursor();
2051   char buf[100];
2052
2053   wxButton *okBut = new wxButton (this, wxID_OK, _("OK"), wxPoint(5, 5));
2054   (void) new wxButton (this, wxID_CANCEL, _("Cancel"), wxPoint(40, 5));
2055   okBut->SetDefault();
2056
2057   int yPos = 40;
2058
2059 #if defined(__WXGTK__) || defined (__WXMOTIF__)
2060   (void) new wxStaticText( this, -1, _("Printer Command: "),
2061                            wxPoint(5, yPos) );
2062   (void) new wxTextCtrl( this, wxID_PRINTER_COMMAND, wxThePrintSetupData->GetPrinterCommand(),
2063                          wxPoint(100, yPos), wxSize(100, -1) );
2064
2065   (void) new wxStaticText( this, -1, _("Printer Options: "),
2066                            wxPoint(210, yPos) );
2067   (void) new wxTextCtrl( this, wxID_PRINTER_OPTIONS, wxThePrintSetupData->GetPrinterOptions(),
2068                          wxPoint(305, yPos), wxSize(150, -1) );
2069
2070   yPos += 40;
2071 #endif
2072
2073   wxString orientation[2];
2074   orientation[0] = _("Portrait");
2075   orientation[1] = _("Landscape");
2076
2077   wxRadioBox *radio0 = new wxRadioBox(this, wxID_PRINTER_ORIENTATION, "Orientation: ", wxPoint(5, yPos), wxSize(-1,-1),
2078                 2,orientation,2,0);
2079   radio0->SetSelection((int)wxThePrintSetupData->GetPrinterOrientation() - 1);
2080
2081   // @@@ Configuration hook
2082   if (wxThePrintSetupData->GetPrintPreviewCommand() == NULL)
2083     wxThePrintSetupData->SetPrintPreviewCommand(PS_VIEWER_PROG);
2084
2085   wxGetResource ("wxWindows", "PSView", &wxThePrintSetupData->previewCommand);
2086
2087   wxString print_modes[3];
2088   print_modes[0] = _("Send to Printer");
2089   print_modes[1] = _("Print to File");
2090   print_modes[2] = _("Preview Only");
2091
2092   int features = (wxThePrintSetupData->GetPrintPreviewCommand() && *wxThePrintSetupData->GetPrintPreviewCommand()) ? 3 : 2;
2093   wxRadioBox *radio1 = new wxRadioBox(this, wxID_PRINTER_MODES, _("PostScript:"),
2094     wxPoint(150, yPos), wxSize(-1,-1), features, print_modes, features, 0);
2095
2096 #ifdef __WXMSW__
2097   radio1->Enable(0, FALSE);
2098   if (wxThePrintSetupData->GetPrintPreviewCommand() && *wxThePrintSetupData->GetPrintPreviewCommand())
2099     radio1->Enable(2, FALSE);
2100 #endif
2101
2102   radio1->SetSelection((int)wxThePrintSetupData->GetPrinterMode());
2103
2104   long wx_printer_translate_x, wx_printer_translate_y;
2105   double wx_printer_scale_x, wx_printer_scale_y;
2106   wxThePrintSetupData->GetPrinterTranslation(&wx_printer_translate_x, &wx_printer_translate_y);
2107   wxThePrintSetupData->GetPrinterScaling(&wx_printer_scale_x, &wx_printer_scale_y);
2108
2109   sprintf (buf, "%.2f", wx_printer_scale_x);
2110
2111   yPos += 90;
2112
2113   (void) new wxStaticText(this, -1, _("X Scaling"), wxPoint(5, yPos));
2114   /* wxTextCtrl *text1 = */ (void) new wxTextCtrl(this, wxID_PRINTER_X_SCALE, buf, wxPoint(100, yPos), wxSize(100, -1));
2115
2116   sprintf (buf, "%.2f", wx_printer_scale_y);
2117   (void) new wxStaticText(this, -1, _("Y Scaling"), wxPoint(220, yPos));
2118   /* wxTextCtrl *text2 = */ (void) new wxTextCtrl(this, wxID_PRINTER_Y_SCALE, buf, wxPoint(320, yPos), wxSize(100, -1));
2119
2120   yPos += 25;
2121
2122   (void) new wxStaticText(this, -1, _("X Translation"), wxPoint(5, yPos));
2123   sprintf (buf, "%.2ld", wx_printer_translate_x);
2124   /* wxTextCtrl *text3 = */ (void) new wxTextCtrl(this, wxID_PRINTER_X_TRANS, buf, wxPoint(100, yPos), wxSize(100, -1));
2125
2126   (void) new wxStaticText(this, -1, _("Y Translation"), wxPoint(220, yPos));
2127   sprintf (buf, "%.2ld", wx_printer_translate_y);
2128   /* wxTextCtrl *text4 = */ (void) new wxTextCtrl(this, wxID_PRINTER_Y_TRANS, buf, wxPoint(320, yPos), wxSize(100, -1));
2129
2130   Fit ();
2131
2132   wxEndBusyCursor();
2133 }
2134
2135 int wxPostScriptPrintDialog::ShowModal (void)
2136 {
2137   if ( wxDialog::ShowModal() == wxID_OK )
2138   {
2139 //        wxTextCtrl *text0 = (wxTextCtrl *)FindWindow(wxID_PRINTER_OPTIONS);
2140           wxTextCtrl *text1 = (wxTextCtrl *)FindWindow(wxID_PRINTER_X_SCALE);
2141           wxTextCtrl *text2 = (wxTextCtrl *)FindWindow(wxID_PRINTER_Y_SCALE);
2142           wxTextCtrl *text3 = (wxTextCtrl *)FindWindow(wxID_PRINTER_X_TRANS);
2143           wxTextCtrl *text4 = (wxTextCtrl *)FindWindow(wxID_PRINTER_Y_TRANS);
2144 //        wxTextCtrl *text_prt = (wxTextCtrl *)FindWindow(wxID_PRINTER_COMMAND);
2145           wxRadioBox *radio0 = (wxRadioBox *)FindWindow(wxID_PRINTER_ORIENTATION);
2146           wxRadioBox *radio1 = (wxRadioBox *)FindWindow(wxID_PRINTER_MODES);
2147
2148       StringToDouble (WXSTRINGCAST text1->GetValue (), &wxThePrintSetupData->printerScaleX);
2149       StringToDouble (WXSTRINGCAST text2->GetValue (), &wxThePrintSetupData->printerScaleY);
2150       StringToLong (WXSTRINGCAST text3->GetValue (), &wxThePrintSetupData->printerTranslateX);
2151       StringToLong (WXSTRINGCAST text4->GetValue (), &wxThePrintSetupData->printerTranslateY);
2152
2153 #ifdef __X__
2154       //      wxThePrintSetupData->SetPrinterOptions(WXSTRINGCAST text0->GetValue ());
2155       //      wxThePrintSetupData->SetPrinterCommand(WXSTRINGCAST text_prt->GetValue ());
2156 #endif
2157
2158       wxThePrintSetupData->SetPrinterOrientation((radio0->GetSelection() == 1 ? PS_LANDSCAPE : PS_PORTRAIT));
2159
2160       // C++ wants this
2161       switch ( radio1->GetSelection() ) {
2162                 case 0: wxThePrintSetupData->SetPrinterMode(PS_PRINTER); break;
2163                 case 1:  wxThePrintSetupData->SetPrinterMode(PS_FILE); break;
2164                 case 2: wxThePrintSetupData->SetPrinterMode(PS_PREVIEW); break;
2165       }
2166           return wxID_OK;
2167   }
2168   return wxID_CANCEL;
2169 }
2170
2171 // PostScript printer settings
2172 // RETAINED FOR BACKWARD COMPATIBILITY
2173 void wxSetPrinterCommand(const char *cmd)
2174 {
2175   wxThePrintSetupData->SetPrinterCommand(cmd);
2176 }
2177
2178 void wxSetPrintPreviewCommand(const char *cmd)
2179 {
2180   wxThePrintSetupData->SetPrintPreviewCommand(cmd);
2181 }
2182
2183 void wxSetPrinterOptions(const char *flags)
2184 {
2185   wxThePrintSetupData->SetPrinterOptions(flags);
2186 }
2187
2188 void wxSetPrinterFile(const char *f)
2189 {
2190   wxThePrintSetupData->SetPrinterFile(f);
2191 }
2192
2193 void wxSetPrinterOrientation(int orient)
2194 {
2195   wxThePrintSetupData->SetPrinterOrientation(orient);
2196 }
2197
2198 void wxSetPrinterScaling(double x, double y)
2199 {
2200   wxThePrintSetupData->SetPrinterScaling(x, y);
2201 }
2202
2203 void wxSetPrinterTranslation(long x, long y)
2204 {
2205   wxThePrintSetupData->SetPrinterTranslation(x, y);
2206 }
2207
2208 // 1 = Preview, 2 = print to file, 3 = send to printer
2209 void wxSetPrinterMode(int mode)
2210 {
2211   wxThePrintSetupData->SetPrinterMode(mode);
2212 }
2213
2214 void wxSetAFMPath(const char *f)
2215 {
2216   wxThePrintSetupData->SetAFMPath(f);
2217 }
2218
2219 // Get current values
2220 char *wxGetPrinterCommand(void)
2221 {
2222   return wxThePrintSetupData->GetPrinterCommand();
2223 }
2224
2225 char *wxGetPrintPreviewCommand(void)
2226 {
2227   return wxThePrintSetupData->GetPrintPreviewCommand();
2228 }
2229
2230 char *wxGetPrinterOptions(void)
2231 {
2232   return wxThePrintSetupData->GetPrinterOptions();
2233 }
2234
2235 char *wxGetPrinterFile(void)
2236 {
2237   return wxThePrintSetupData->GetPrinterFile();
2238 }
2239
2240 int wxGetPrinterOrientation(void)
2241 {
2242   return wxThePrintSetupData->GetPrinterOrientation();
2243 }
2244
2245 void wxGetPrinterScaling(double* x, double* y)
2246 {
2247   wxThePrintSetupData->GetPrinterScaling(x, y);
2248 }
2249
2250 void wxGetPrinterTranslation(long *x, long *y)
2251 {
2252   wxThePrintSetupData->GetPrinterTranslation(x, y);
2253 }
2254
2255 int wxGetPrinterMode(void)
2256 {
2257   return wxThePrintSetupData->GetPrinterMode();
2258 }
2259
2260 char *wxGetAFMPath(void)
2261 {
2262   return wxThePrintSetupData->GetAFMPath();
2263 }
2264
2265 /*
2266  * Print setup data
2267  */
2268
2269 wxPrintSetupData::wxPrintSetupData(void)
2270 {
2271   printerCommand = (char *) NULL;
2272   previewCommand = (char *) NULL;
2273   printerFlags = (char *) NULL;
2274   printerOrient = PS_PORTRAIT;
2275   printerScaleX = (double)1.0;
2276   printerScaleY = (double)1.0;
2277   printerTranslateX = 0;
2278   printerTranslateY = 0;
2279   // 1 = Preview, 2 = print to file, 3 = send to printer
2280   printerMode = 3;
2281   afmPath = (char *) NULL;
2282   paperName = (char *) NULL;
2283   printColour = TRUE;
2284   printerFile = (char *) NULL;
2285 }
2286
2287 wxPrintSetupData::~wxPrintSetupData(void)
2288 {
2289   if (printerCommand)
2290     delete[] printerCommand;
2291   if (previewCommand)
2292     delete[] previewCommand;
2293   if (printerFlags)
2294     delete[] printerFlags;
2295   if (afmPath)
2296     delete[] afmPath;
2297   if (paperName)
2298     delete[] paperName;
2299   if (printerFile)
2300     delete[] printerFile;
2301 }
2302
2303 void wxPrintSetupData::SetPrinterCommand(const char *cmd)
2304 {
2305   if (cmd == printerCommand)
2306     return;
2307
2308   if (printerCommand)
2309     delete[] printerCommand;
2310   if (cmd)
2311     printerCommand = copystring(cmd);
2312   else
2313     printerCommand = (char *) NULL;
2314 }
2315
2316 void wxPrintSetupData::SetPrintPreviewCommand(const char *cmd)
2317 {
2318   if (cmd == previewCommand)
2319     return;
2320
2321   if (previewCommand)
2322     delete[] previewCommand;
2323   if (cmd)
2324     previewCommand = copystring(cmd);
2325   else
2326     previewCommand = (char *) NULL;
2327 }
2328
2329 void wxPrintSetupData::SetPaperName(const char *name)
2330 {
2331   if (name == paperName)
2332     return;
2333
2334   if (paperName)
2335     delete[] paperName;
2336   if (name)
2337     paperName = copystring(name);
2338   else
2339     paperName = (char *) NULL;
2340 }
2341
2342 void wxPrintSetupData::SetPrinterOptions(const char *flags)
2343 {
2344   if (printerFlags == flags)
2345     return;
2346
2347   if (printerFlags)
2348     delete[] printerFlags;
2349   if (flags)
2350     printerFlags = copystring(flags);
2351   else
2352     printerFlags = (char *) NULL;
2353 }
2354
2355 void wxPrintSetupData::SetPrinterFile(const char *f)
2356 {
2357   if (f == printerFile)
2358     return;
2359
2360   if (printerFile)
2361     delete[] printerFile;
2362   if (f)
2363     printerFile = copystring(f);
2364   else
2365     printerFile = (char *) NULL;
2366 }
2367
2368 void wxPrintSetupData::SetPrinterOrientation(int orient)
2369 {
2370   printerOrient = orient;
2371 }
2372
2373 void wxPrintSetupData::SetPrinterScaling(double x, double y)
2374 {
2375   printerScaleX = x;
2376   printerScaleY = y;
2377 }
2378
2379 void wxPrintSetupData::SetPrinterTranslation(long x, long y)
2380 {
2381   printerTranslateX = x;
2382   printerTranslateY = y;
2383 }
2384
2385 // 1 = Preview, 2 = print to file, 3 = send to printer
2386 void wxPrintSetupData::SetPrinterMode(int mode)
2387 {
2388   printerMode = mode;
2389 }
2390
2391 void wxPrintSetupData::SetAFMPath(const char *f)
2392 {
2393   if (f == afmPath)
2394     return;
2395
2396   if (afmPath)
2397     delete[] afmPath;
2398   if (f)
2399     afmPath = copystring(f);
2400   else
2401     afmPath = (char *) NULL;
2402 }
2403
2404 void wxPrintSetupData::SetColour(bool col)
2405 {
2406   printColour = col;
2407 }
2408
2409 // Get current values
2410 char *wxPrintSetupData::GetPrinterCommand(void)
2411 {
2412   return printerCommand;
2413 }
2414
2415 char *wxPrintSetupData::GetPrintPreviewCommand(void)
2416 {
2417   return previewCommand;
2418 }
2419
2420 char *wxPrintSetupData::GetPrinterOptions(void)
2421 {
2422   return printerFlags;
2423 }
2424
2425 char *wxPrintSetupData::GetPrinterFile(void)
2426 {
2427   return printerFile;
2428 }
2429
2430 char *wxPrintSetupData::GetPaperName(void)
2431 {
2432   return paperName;
2433 }
2434
2435 int wxPrintSetupData::GetPrinterOrientation(void)
2436 {
2437   return printerOrient;
2438 }
2439
2440 void wxPrintSetupData::GetPrinterScaling(double *x, double *y)
2441 {
2442   *x = printerScaleX;
2443   *y = printerScaleY;
2444 }
2445
2446 void wxPrintSetupData::GetPrinterTranslation(long *x, long *y)
2447 {
2448   *x = printerTranslateX;
2449   *y = printerTranslateY;
2450 }
2451
2452 int wxPrintSetupData::GetPrinterMode(void)
2453 {
2454   return printerMode;
2455 }
2456
2457 char *wxPrintSetupData::GetAFMPath(void)
2458 {
2459   return afmPath;
2460 }
2461
2462 bool wxPrintSetupData::GetColour(void)
2463 {
2464   return printColour;
2465 }
2466
2467 void wxPrintSetupData::operator=(wxPrintSetupData& data)
2468 {
2469   SetPrinterCommand(data.GetPrinterCommand());
2470   SetPrintPreviewCommand(data.GetPrintPreviewCommand());
2471   SetPrinterOptions(data.GetPrinterOptions());
2472   long x, y;
2473   data.GetPrinterTranslation(&x, &y);
2474   SetPrinterTranslation(x, y);
2475
2476   double x1, y1;
2477   data.GetPrinterScaling(&x1, &y1);
2478   SetPrinterScaling(x1, y1);
2479
2480   SetPrinterOrientation(data.GetPrinterOrientation());
2481   SetPrinterMode(data.GetPrinterMode());
2482   SetAFMPath(data.GetAFMPath());
2483   SetPaperName(data.GetPaperName());
2484   SetColour(data.GetColour());
2485 }
2486
2487 void wxInitializePrintSetupData(bool init)
2488 {
2489   if (init)
2490   {
2491     wxThePrintSetupData = new wxPrintSetupData;
2492
2493     wxThePrintSetupData->SetPrintPreviewCommand(PS_VIEWER_PROG);
2494     wxThePrintSetupData->SetPrinterOrientation(PS_PORTRAIT);
2495     wxThePrintSetupData->SetPrinterMode(PS_PREVIEW);
2496     wxThePrintSetupData->SetPaperName(_("A4 210 x 297 mm"));
2497
2498     // Could have a .ini file to read in some defaults
2499     // - and/or use environment variables, e.g. WXWIN
2500 #ifdef __VMS__
2501     wxThePrintSetupData->SetPrinterCommand("print");
2502     wxThePrintSetupData->SetPrinterOptions("/nonotify/queue=psqueue");
2503     wxThePrintSetupData->SetAFMPath("sys$ps_font_metrics:");
2504 #endif
2505 #ifdef __WXMSW__
2506     wxThePrintSetupData->SetPrinterCommand("print");
2507     wxThePrintSetupData->SetAFMPath("c:\\windows\\system\\");
2508     wxThePrintSetupData->SetPrinterOptions(NULL);
2509 #endif
2510 #if !defined(__VMS__) && !defined(__WXMSW__)
2511     wxThePrintSetupData->SetPrinterCommand("lpr");
2512     wxThePrintSetupData->SetPrinterOptions((char *) NULL);
2513     wxThePrintSetupData->SetAFMPath((char *) NULL);
2514 #endif
2515   }
2516   else
2517   {
2518     if (wxThePrintSetupData)
2519       delete wxThePrintSetupData;
2520      wxThePrintSetupData = (wxPrintSetupData *) NULL;
2521   }
2522 }
2523
2524 /*
2525  * Paper size database for PostScript
2526  */
2527
2528 wxPrintPaperType::wxPrintPaperType(const char *name, int wmm, int hmm, int wp, int hp)
2529 {
2530   widthMM = wmm;
2531   heightMM = hmm;
2532   widthPixels = wp;
2533   heightPixels = hp;
2534   pageName = copystring(name);
2535 }
2536
2537 wxPrintPaperType::~wxPrintPaperType(void)
2538 {
2539   delete[] pageName;
2540 }
2541
2542 wxPrintPaperDatabase::wxPrintPaperDatabase(void):wxList(wxKEY_STRING)
2543 {
2544   DeleteContents(TRUE);
2545 }
2546
2547 wxPrintPaperDatabase::~wxPrintPaperDatabase(void)
2548 {
2549 }
2550
2551 void wxPrintPaperDatabase::CreateDatabase(void)
2552 {
2553   // Need correct values for page size in pixels.
2554   // Each unit is one 'point' = 1/72 of an inch.
2555   // NOTE: WE NEED ALSO TO MAKE ADJUSTMENTS WHEN TRANSLATING
2556   // in wxPostScriptDC code, so we can start from top left.
2557   // So access this database and translate by appropriate number
2558   // of points for this paper size. OR IS IT OK ALREADY?
2559   // Can't remember where the PostScript origin is by default.
2560   // Heck, someone will know how to make it hunky-dory...
2561   // JACS 25/5/95
2562
2563   AddPaperType(_("A4 210 x 297 mm"), 210, 297,         595, 842);
2564   AddPaperType(_("A3 297 x 420 mm"), 297, 420,         842, 1191);
2565   AddPaperType(_("Letter 8 1/2 x 11 in"), 216, 279,    612, 791);
2566   AddPaperType(_("Legal 8 1/2 x 14 in"), 216, 356,     612, 1009);
2567 }
2568
2569 void wxPrintPaperDatabase::ClearDatabase(void)
2570 {
2571   Clear();
2572 }
2573
2574 void wxPrintPaperDatabase::AddPaperType(const char *name, int wmm, int hmm, int wp, int hp)
2575 {
2576   Append(name, new wxPrintPaperType(name, wmm, hmm, wp, hp));
2577 }
2578
2579 wxPrintPaperType *wxPrintPaperDatabase::FindPaperType(const char *name)
2580 {
2581   wxNode *node = Find(name);
2582   if (node)
2583     return (wxPrintPaperType *)node->Data();
2584   else
2585     return (wxPrintPaperType *) NULL;
2586 }
2587
2588 /*
2589  * Initialization/cleanup module
2590  */
2591
2592 bool wxPostScriptModule::OnInit()
2593 {
2594     wxInitializePrintSetupData();
2595     wxThePrintPaperDatabase = new wxPrintPaperDatabase;
2596     wxThePrintPaperDatabase->CreateDatabase();
2597
2598     return TRUE;
2599 }
2600
2601 void wxPostScriptModule::OnExit()
2602 {
2603     wxInitializePrintSetupData(FALSE);
2604     delete wxThePrintPaperDatabase;
2605     wxThePrintPaperDatabase = NULL;
2606 }
2607
2608
2609 #endif