Updated testconf

[wxWidgets.git] / src / generic / dcpsg.cpp
diff --git a/src/generic/dcpsg.cpp b/src/generic/dcpsg.cpp

index 55ba6d7768e28dfa69ad0bddcf441d62899bfebe..769fe924972d46b1abfa16039bb8b521390560af 100644 (file)
--- a/src/generic/dcpsg.cpp
+++ b/src/generic/dcpsg.cpp
@@ -25,6 +25,8 @@
      #include "wx/defs.h"
  #endif // WX_PRECOMP
  
      #include "wx/defs.h"
  #endif // WX_PRECOMP
  
+#if wxUSE_PRINTING_ARCHITECTURE
+
  #if wxUSE_POSTSCRIPT
  
  #include "wx/dcmemory.h"
  #if wxUSE_POSTSCRIPT
  
  #include "wx/dcmemory.h"
@@ -41,6 +43,8 @@
  #include "wx/stattext.h"
  #include "wx/radiobox.h"
  #include "wx/textctrl.h"
  #include "wx/stattext.h"
  #include "wx/radiobox.h"
  #include "wx/textctrl.h"
+#include "wx/prntbase.h"
+#include "wx/paper.h"
  
  #include <math.h>
  
  
  #include <math.h>
  
@@ -128,34 +132,34 @@ static const char *wxPostScriptHeaderSpline = "\
  ";
  
  static const char *wxPostScriptHeaderColourImage = "\
  ";
  
  static const char *wxPostScriptHeaderColourImage = "\
-% define 'colorimage' if it isn't defined\n\
-%   ('colortogray' and 'mergeprocs' come from xwd2ps\n\
-%     via xgrab)\n\
-/colorimage where   % do we know about 'colorimage'?\n\
-  { pop }           % yes: pop off the 'dict' returned\n\
-  {                 % no:  define one\n\
-    /colortogray {  % define an RGB->I function\n\
-      /rgbdata exch store    % call input 'rgbdata'\n\
+%% define 'colorimage' if it isn't defined\n\
+%%   ('colortogray' and 'mergeprocs' come from xwd2ps\n\
+%%     via xgrab)\n\
+/colorimage where   %% do we know about 'colorimage'?\n\
+  { pop }           %% yes: pop off the 'dict' returned\n\
+  {                 %% no:  define one\n\
+    /colortogray {  %% define an RGB->I function\n\
+      /rgbdata exch store    %% call input 'rgbdata'\n\
        rgbdata length 3 idiv\n\
        /npixls exch store\n\
        /rgbindx 0 store\n\
        0 1 npixls 1 sub {\n\
          grays exch\n\
        rgbdata length 3 idiv\n\
        /npixls exch store\n\
        /rgbindx 0 store\n\
        0 1 npixls 1 sub {\n\
          grays exch\n\
-        rgbdata rgbindx       get 20 mul    % Red\n\
-        rgbdata rgbindx 1 add get 32 mul    % Green\n\
-        rgbdata rgbindx 2 add get 12 mul    % Blue\n\
-        add add 64 idiv      % I = .5G + .31R + .18B\n\
+        rgbdata rgbindx       get 20 mul    %% Red\n\
+        rgbdata rgbindx 1 add get 32 mul    %% Green\n\
+        rgbdata rgbindx 2 add get 12 mul    %% Blue\n\
+        add add 64 idiv      %% I = .5G + .31R + .18B\n\
          put\n\
          /rgbindx rgbindx 3 add store\n\
        } for\n\
        grays 0 npixls getinterval\n\
      } bind def\n\
  \n\
          put\n\
          /rgbindx rgbindx 3 add store\n\
        } for\n\
        grays 0 npixls getinterval\n\
      } bind def\n\
  \n\
-    % Utility procedure for colorimage operator.\n\
-    % This procedure takes two procedures off the\n\
-    % stack and merges them into a single procedure.\n\
+    %% Utility procedure for colorimage operator.\n\
+    %% This procedure takes two procedures off the\n\
+    %% stack and merges them into a single procedure.\n\
  \n\
  \n\
-    /mergeprocs { % def\n\
+    /mergeprocs { %% def\n\
        dup length\n\
        3 -1 roll\n\
        dup\n\
        dup length\n\
        3 -1 roll\n\
        dup\n\
@@ -174,12 +178,12 @@ static const char *wxPostScriptHeaderColourImage = "\
        putinterval\n\
      } bind def\n\
  \n\
        putinterval\n\
      } bind def\n\
  \n\
-    /colorimage { % def\n\
-      pop pop     % remove 'false 3' operands\n\
+    /colorimage { %% def\n\
+      pop pop     %% remove 'false 3' operands\n\
        {colortogray} mergeprocs\n\
        image\n\
      } bind def\n\
        {colortogray} mergeprocs\n\
        image\n\
      } bind def\n\
-  } ifelse          % end of 'false' case\n\
+  } ifelse          %% end of 'false' case\n\
  ";
  
  static char wxPostScriptHeaderReencodeISO1[] =
  ";
  
  static char wxPostScriptHeaderReencodeISO1[] =
@@ -229,35 +233,38 @@ static char wxPostScriptHeaderReencodeISO2[] =
  
  wxPostScriptDC::wxPostScriptDC ()
  {
  
  wxPostScriptDC::wxPostScriptDC ()
  {
-    m_pstream = (ofstream*) NULL;
-    
+    m_pstream = (FILE*) NULL;
+
      m_currentRed = 0;
      m_currentGreen = 0;
      m_currentBlue = 0;
      m_currentRed = 0;
      m_currentGreen = 0;
      m_currentBlue = 0;
-    
+
      m_pageNumber = 0;
      m_pageNumber = 0;
-    
+
      m_clipping = FALSE;
      m_clipping = FALSE;
-    
+
      m_underlinePosition = 0.0;
      m_underlineThickness = 0.0;
  
      m_signX =  1;  // default x-axis left to right
      m_signY = -1;  // default y-axis bottom up -> top down
      m_underlinePosition = 0.0;
      m_underlineThickness = 0.0;
  
      m_signX =  1;  // default x-axis left to right
      m_signY = -1;  // default y-axis bottom up -> top down
+
+    // Compatibility only
+    m_printData = * wxThePrintSetupData;
  }
  
  wxPostScriptDC::wxPostScriptDC (const wxString& file, bool interactive, wxWindow *parent)
  {
  }
  
  wxPostScriptDC::wxPostScriptDC (const wxString& file, bool interactive, wxWindow *parent)
  {
-    m_pstream = (ofstream*) NULL;
-    
+    m_pstream = (FILE*) NULL;
+
      m_currentRed = 0;
      m_currentGreen = 0;
      m_currentBlue = 0;
      m_currentRed = 0;
      m_currentGreen = 0;
      m_currentBlue = 0;
-    
+
      m_pageNumber = 0;
      m_pageNumber = 0;
-    
+
      m_clipping = FALSE;
      m_clipping = FALSE;
-    
+
      m_underlinePosition = 0.0;
      m_underlineThickness = 0.0;
  
      m_underlinePosition = 0.0;
      m_underlineThickness = 0.0;
  
@@ -272,11 +279,11 @@ bool wxPostScriptDC::Create(const wxString& file, bool interactive, wxWindow *pa
      m_isInteractive = interactive;
  
      m_title = "";
      m_isInteractive = interactive;
  
      m_title = "";
-    m_filename = file;
+    m_printData.SetFilename(file);
  
  #ifdef __WXMSW__
      // Can only send to file in Windows
  
  #ifdef __WXMSW__
      // Can only send to file in Windows
-    wxThePrintSetupData->SetPrinterMode(PS_FILE);
+    m_printData.SetPrintMode(wxPRINT_MODE_FILE);
  #endif
  
      if (m_isInteractive)
  #endif
  
      if (m_isInteractive)
@@ -287,63 +294,89 @@ bool wxPostScriptDC::Create(const wxString& file, bool interactive, wxWindow *pa
      {
          m_ok = TRUE;
      }
      {
          m_ok = TRUE;
      }
-    
+
      return m_ok;
  }
  
      return m_ok;
  }
  
+wxPostScriptDC::wxPostScriptDC (const wxPrintData& printData)
+{
+    m_pstream = (FILE*) NULL;
+
+    m_currentRed = 0;
+    m_currentGreen = 0;
+    m_currentBlue = 0;
+
+    m_pageNumber = 0;
+
+    m_clipping = FALSE;
+
+    m_underlinePosition = 0.0;
+    m_underlineThickness = 0.0;
+
+    m_signX =  1;  // default x-axis left to right
+    m_signY = -1;  // default y-axis bottom up -> top down
+
+    m_printData = printData;
+
+    m_ok = TRUE;
+}
+
  wxPostScriptDC::~wxPostScriptDC ()
  {
  wxPostScriptDC::~wxPostScriptDC ()
  {
-    if (m_pstream) delete m_pstream;
+    if (m_pstream)
+    {
+        fclose( m_pstream );
+       m_pstream = (FILE*) NULL;
+    }
  }
  
  bool wxPostScriptDC::Ok() const
  {
    return m_ok;
  }
  }
  
  bool wxPostScriptDC::Ok() const
  {
    return m_ok;
  }
-  
+
+// This dialog is deprecated now: use wxGenericPrintDialog or the printing framework
  bool wxPostScriptDC::PrinterDialog(wxWindow *parent)
  {
  bool wxPostScriptDC::PrinterDialog(wxWindow *parent)
  {
-    wxPostScriptPrintDialog dialog( parent, _("Printer Settings"), wxPoint(150, 150), wxSize(400, 400), 
+    wxPostScriptPrintDialog dialog( parent, _("Printer Settings"), wxPoint(150, 150), wxSize(400, 400),
                                      wxDEFAULT_DIALOG_STYLE | wxDIALOG_MODAL );
      m_ok = (dialog.ShowModal () == wxID_OK);
  
      if (!m_ok) return FALSE;
  
                                      wxDEFAULT_DIALOG_STYLE | wxDIALOG_MODAL );
      m_ok = (dialog.ShowModal () == wxID_OK);
  
      if (!m_ok) return FALSE;
  
-    if ((m_filename == "") && 
-        (wxThePrintSetupData->GetPrinterMode() == PS_PREVIEW  || 
-         wxThePrintSetupData->GetPrinterMode() == PS_PRINTER))
+    if ((m_printData.GetFilename() == "") &&
+        (m_printData.GetPrintMode() == wxPRINT_MODE_PREVIEW  ||
+         m_printData.GetPrintMode() == wxPRINT_MODE_PRINTER))
      {
  // steve, 05.09.94
  #ifdef __VMS__
      {
  // steve, 05.09.94
  #ifdef __VMS__
-      wxThePrintSetupData->SetPrinterFile("preview");
+      m_printData.SetFilename("preview");
  #else
        // For PS_PRINTER action this depends on a Unix-style print spooler
        // since the wx_printer_file can be destroyed during a session
        // @@@ TODO: a Windows-style answer for non-Unix
  #else
        // For PS_PRINTER action this depends on a Unix-style print spooler
        // since the wx_printer_file can be destroyed during a session
        // @@@ TODO: a Windows-style answer for non-Unix
-      char userId[256];
+      wxChar userId[256];
        wxGetUserId (userId, sizeof (userId) / sizeof (char));
        wxGetUserId (userId, sizeof (userId) / sizeof (char));
-      char tmp[256];
-      strcpy (tmp, "/tmp/preview_");
-      strcat (tmp, userId);
-      wxThePrintSetupData->SetPrinterFile(tmp);
+      wxChar tmp[256];
+      wxStrcpy (tmp, _T("/tmp/preview_"));
+      wxStrcat (tmp, userId);
+      m_printData.SetFilename(tmp);
  #endif
  #endif
-      char tmp2[256];
-      strcpy(tmp2, wxThePrintSetupData->GetPrinterFile());
-      strcat (tmp2, ".ps");
-      wxThePrintSetupData->SetPrinterFile(tmp2);
-      m_filename = tmp2;
+      wxChar tmp2[256];
+      wxStrcpy(tmp2, m_printData.GetFilename());
+      wxStrcat (tmp2, _T(".ps"));
+      m_printData.SetFilename(tmp2);
      }
      }
-    else if ((m_filename == "") && (wxThePrintSetupData->GetPrinterMode() == PS_FILE))
+    else if ((m_printData.GetFilename() == _T("")) && (m_printData.GetPrintMode() == wxPRINT_MODE_FILE))
      {
      {
-      wxString file = wxSaveFileSelector (_("PostScript"), "ps");
+      wxString file = wxSaveFileSelector (_("PostScript"), _T("ps"));
        if ( file.IsEmpty() )
        {
          m_ok = FALSE;
          return FALSE;
        }
  
        if ( file.IsEmpty() )
        {
          m_ok = FALSE;
          return FALSE;
        }
  
-      wxThePrintSetupData->SetPrinterFile(file);
-      m_filename = file;
+      m_printData.SetFilename(file);
        m_ok = TRUE;
      }
  
        m_ok = TRUE;
      }
  
@@ -352,151 +385,163 @@ bool wxPostScriptDC::PrinterDialog(wxWindow *parent)
  
  void wxPostScriptDC::SetClippingRegion (long x, long y, long w, long h)
  {
  
  void wxPostScriptDC::SetClippingRegion (long x, long y, long w, long h)
  {
-    wxCHECK_RET( m_ok && m_pstream, "invalid postscript dc" );
-    
+    wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
+
      if (m_clipping) return;
  
      wxDC::SetClippingRegion( x, y, w, h );
      if (m_clipping) return;
  
      wxDC::SetClippingRegion( x, y, w, h );
-    
+
      m_clipping = TRUE;
      m_clipping = TRUE;
-    *m_pstream << "gsave\n" 
-               << "newpath\n" 
-           << XLOG2DEV(x)   << " " << YLOG2DEV(y)   << " moveto\n"
-           << XLOG2DEV(x+w) << " " << YLOG2DEV(y)   << " lineto\n"
-           << XLOG2DEV(x+w) << " " << YLOG2DEV(y+h) << " lineto\n"
-           << XLOG2DEV(x)   << " " << YLOG2DEV(y+h) << " lineto\n"
-               << "closepath clip newpath\n";
+    fprintf( m_pstream, 
+            "gsave\n newpath\n"
+           "%ld %ld moveto\n"
+           "%ld %ld lineto\n"
+           "%ld %ld lineto\n"
+           "%ld %ld lineto\n"
+           "closepath clip newpath\n",
+           XLOG2DEV(x),   YLOG2DEV(y), 
+           XLOG2DEV(x+w), YLOG2DEV(y), 
+           XLOG2DEV(x+w), YLOG2DEV(y+h),
+           XLOG2DEV(x),   YLOG2DEV(y+h) );
  }
  
  void wxPostScriptDC::SetClippingRegion( const wxRegion &WXUNUSED(region) )
  {
  }
  
  void wxPostScriptDC::SetClippingRegion( const wxRegion &WXUNUSED(region) )
  {
+    wxFAIL_MSG( _T("wxPostScriptDC::SetClippingRegion not implemented.") );
  }
  
  void wxPostScriptDC::DestroyClippingRegion()
  {
  }
  
  void wxPostScriptDC::DestroyClippingRegion()
  {
-    wxCHECK_RET( m_ok && m_pstream, "invalid postscript dc" );
-    
+    wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
+
      wxDC::DestroyClippingRegion();
      wxDC::DestroyClippingRegion();
-    
+
      if (m_clipping)
      {
          m_clipping = FALSE;
      if (m_clipping)
      {
          m_clipping = FALSE;
-        *m_pstream << "grestore\n";
+       fprintf( m_pstream, "grestore\n" );
      }
  }
  
  void wxPostScriptDC::Clear()
  {
      }
  }
  
  void wxPostScriptDC::Clear()
  {
-    wxFAIL_MSG( "wxPostScriptDC::Clear not implemented." );
+    wxFAIL_MSG( _T("wxPostScriptDC::Clear not implemented.") );
  }
  
  }
  
-void wxPostScriptDC::FloodFill (long WXUNUSED(x), long WXUNUSED(y), const wxColour &WXUNUSED(col), int WXUNUSED(style))
+void wxPostScriptDC::DoFloodFill (long WXUNUSED(x), long WXUNUSED(y), const wxColour &WXUNUSED(col), int WXUNUSED(style))
  {
  {
-    wxFAIL_MSG( "wxPostScriptDC::FloodFill not implemented." );
+    wxFAIL_MSG( _T("wxPostScriptDC::FloodFill not implemented.") );
  }
  
  }
  
-bool wxPostScriptDC::GetPixel (long WXUNUSED(x), long WXUNUSED(y), wxColour * WXUNUSED(col)) const
+bool wxPostScriptDC::DoGetPixel (long WXUNUSED(x), long WXUNUSED(y), wxColour * WXUNUSED(col)) const
  {
  {
-    wxFAIL_MSG( "wxPostScriptDC::GetPixel not implemented." );
+    wxFAIL_MSG( _T("wxPostScriptDC::GetPixel not implemented.") );
      return FALSE;
  }
  
      return FALSE;
  }
  
-void wxPostScriptDC::CrossHair (long WXUNUSED(x), long WXUNUSED(y))
+void wxPostScriptDC::DoCrossHair (long WXUNUSED(x), long WXUNUSED(y))
  {
  {
-    wxFAIL_MSG( "wxPostScriptDC::CrossHair not implemented." );
+    wxFAIL_MSG( _T("wxPostScriptDC::CrossHair not implemented.") );
  }
  
  }
  
-void wxPostScriptDC::DrawLine (long x1, long y1, long x2, long y2)
+void wxPostScriptDC::DoDrawLine (long x1, long y1, long x2, long y2)
  {
  {
-    wxCHECK_RET( m_ok && m_pstream, "invalid postscript dc" );
-    
+    wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
+
      if  (m_pen.GetStyle() == wxTRANSPARENT) return;
      if  (m_pen.GetStyle() == wxTRANSPARENT) return;
-    
+
      SetPen( m_pen );
      SetPen( m_pen );
-    
-    *m_pstream << "newpath\n"
-           <<  XLOG2DEV(x1) << " " <<  YLOG2DEV (y1) << " moveto\n"
-           <<  XLOG2DEV(x2) << " " <<  YLOG2DEV (y2) << " lineto\n"
-           << "stroke\n";
-           
+
+    fprintf( m_pstream,
+            "newpath\n"
+           "%ld %ld moveto\n"
+           "%ld %ld lineto\n"
+           "stroke\n",
+           XLOG2DEV(x1), YLOG2DEV(y1),
+           XLOG2DEV(x2), YLOG2DEV (y2) );
+
      CalcBoundingBox( x1, y1 );
      CalcBoundingBox( x2, y2 );
  }
  
  #define RAD2DEG 57.29577951308
  
      CalcBoundingBox( x1, y1 );
      CalcBoundingBox( x2, y2 );
  }
  
  #define RAD2DEG 57.29577951308
  
-void wxPostScriptDC::DrawArc (long x1, long y1, long x2, long y2, long xc, long yc)
+void wxPostScriptDC::DoDrawArc (long x1, long y1, long x2, long y2, long xc, long yc)
  {
  {
-    wxCHECK_RET( m_ok && m_pstream, "invalid postscript dc" );
-    
+    wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
+
      long dx = x1 - xc;
      long dy = y1 - yc;
      long radius = (long) sqrt(dx*dx+dy*dy);
      double alpha1, alpha2;
  
      long dx = x1 - xc;
      long dy = y1 - yc;
      long radius = (long) sqrt(dx*dx+dy*dy);
      double alpha1, alpha2;
  
-    if (x1 == x2 && y1 == y2) 
+    if (x1 == x2 && y1 == y2)
      {
      {
-    alpha1 = 0.0;
-    alpha2 = 360.0;
-    } else if (radius == 0.0) 
+        alpha1 = 0.0;
+        alpha2 = 360.0;
+    } 
+    else if (radius == 0.0)
      {
      {
-    alpha1 = alpha2 = 0.0;
-    } else 
+        alpha1 = alpha2 = 0.0;
+    } 
+    else
      {
      {
-    alpha1 = (x1 - xc == 0) ?
-        (y1 - yc < 0) ? 90.0 : -90.0 :
-        -atan2(double(y1-yc), double(x1-xc)) * RAD2DEG;
-    alpha2 = (x2 - xc == 0) ?
-        (y2 - yc < 0) ? 90.0 : -90.0 :
-        -atan2(double(y2-yc), double(x2-xc)) * RAD2DEG;
+        alpha1 = (x1 - xc == 0) ?
+            (y1 - yc < 0) ? 90.0 : -90.0 :
+                -atan2(double(y1-yc), double(x1-xc)) * RAD2DEG;
+        alpha2 = (x2 - xc == 0) ?
+            (y2 - yc < 0) ? 90.0 : -90.0 :
+                -atan2(double(y2-yc), double(x2-xc)) * RAD2DEG;
      }
      while (alpha1 <= 0)   alpha1 += 360;
      while (alpha2 <= 0)   alpha2 += 360; // adjust angles to be between
      while (alpha1 > 360)  alpha1 -= 360; // 0 and 360 degree
      while (alpha2 > 360)  alpha2 -= 360;
  
      }
      while (alpha1 <= 0)   alpha1 += 360;
      while (alpha2 <= 0)   alpha2 += 360; // adjust angles to be between
      while (alpha1 > 360)  alpha1 -= 360; // 0 and 360 degree
      while (alpha2 > 360)  alpha2 -= 360;
  
-    if (m_brush.GetStyle() != wxTRANSPARENT) 
+    if (m_brush.GetStyle() != wxTRANSPARENT)
      {
      {
-    SetBrush( m_brush );
-    *m_pstream << "newpath\n"
-             << XLOG2DEV(xc)        << " "
-         << YLOG2DEV(yc)        << " "
-             << XLOG2DEVREL(radius) << " "
-         << YLOG2DEVREL(radius) << " "
-         << alpha1               << " "
-         << alpha2               << " ellipse\n"
-             << XLOG2DEV(xc)        << " "
-         << YLOG2DEV(yc)        << " lineto\n"
-         << "closepath\n"
-             << "fill\n";
+        SetBrush( m_brush );
+       
+       fprintf( m_pstream,
+               "newpath\n"
+               "%ld %ld %ld %ld %ld %ld ellipse\n"
+               "%ld %ld lineto\n"
+               "closepath\n"
+               "fill\n",
+               XLOG2DEV(xc), YLOG2DEV(yc), XLOG2DEVREL(radius), YLOG2DEVREL(radius), (long)alpha1, (long) alpha2,
+               XLOG2DEV(xc), YLOG2DEV(yc) );
+
+        CalcBoundingBox( xc-radius, yc-radius );
+        CalcBoundingBox( xc+radius, yc+radius );
      }
      }
-    
-    if (m_pen.GetStyle() != wxTRANSPARENT) 
+
+    if (m_pen.GetStyle() != wxTRANSPARENT)
      {
      {
-    SetPen( m_pen );
-    *m_pstream << "newpath\n"
-             << XLOG2DEV(xc)        << " "
-         << YLOG2DEV(yc)        << " "
-             << XLOG2DEVREL(radius) << " "
-         << YLOG2DEVREL(radius) << " "
-         << alpha1               << " "
-         << alpha2               << " ellipse\n"
-             << "stroke\n";
+        SetPen( m_pen );
+       
+       fprintf( m_pstream,
+               "newpath\n"
+               "%ld %ld %ld %ld %ld %ld ellipse\n"
+               "%ld %ld lineto\n"
+               "stroke\n"
+               "fill\n",
+               XLOG2DEV(xc), YLOG2DEV(yc), XLOG2DEVREL(radius), YLOG2DEVREL(radius), (long)alpha1, (long) alpha2,
+               XLOG2DEV(xc), YLOG2DEV(yc) );
+
+        CalcBoundingBox( xc-radius, yc-radius );
+        CalcBoundingBox( xc+radius, yc+radius );
      }
      }
-    
-    CalcBoundingBox( xc-radius, yc-radius );
-    CalcBoundingBox( xc+radius, yc+radius );
  }
  
  }
  
-void wxPostScriptDC::DrawEllipticArc(long x,long y,long w,long h,double sa,double ea)
+void wxPostScriptDC::DoDrawEllipticArc(long x,long y,long w,long h,double sa,double ea)
  {
  {
-    wxCHECK_RET( m_ok && m_pstream, "invalid postscript dc" );
-    
+    wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
+
      if (sa>=360 || sa<=-360) sa=sa-int(sa/360)*360;
      if (ea>=360 || ea<=-360) ea=ea-int(ea/360)*360;
      if (sa<0) sa+=360;
      if (ea<0) ea+=360;
      if (sa>=360 || sa<=-360) sa=sa-int(sa/360)*360;
      if (ea>=360 || ea<=-360) ea=ea-int(ea/360)*360;
      if (sa<0) sa+=360;
      if (ea<0) ea+=360;
-    
+
      if (sa==ea)
      {
          DrawEllipse(x,y,w,h);
      if (sa==ea)
      {
          DrawEllipse(x,y,w,h);
@@ -506,167 +551,190 @@ void wxPostScriptDC::DrawEllipticArc(long x,long y,long w,long h,double sa,doubl
      if (m_brush.GetStyle () != wxTRANSPARENT)
      {
          SetBrush( m_brush );
      if (m_brush.GetStyle () != wxTRANSPARENT)
      {
          SetBrush( m_brush );
-
-        *m_pstream << "newpath\n" 
-               << XLOG2DEV(x+w/2) << " " << YLOG2DEV(y+h/2) << " " 
-           << XLOG2DEVREL(w/2) << " " << YLOG2DEVREL(h/2) << " " 
-           << int(sa) <<" "<< int(ea) << " true ellipticarc\n";
-
+       
+       fprintf( m_pstream,
+               "newpath\n"
+               "%ld %ld %ld %ld %ld %ld true ellipticarc\n",
+               XLOG2DEV(x+w/2), YLOG2DEV(y+h/2), XLOG2DEVREL(w/2), YLOG2DEVREL(h/2), (long)sa, (long)ea );
+    
          CalcBoundingBox( x ,y );
          CalcBoundingBox( x+w, y+h );
          CalcBoundingBox( x ,y );
          CalcBoundingBox( x+w, y+h );
-    }
+    }  
      
      if (m_pen.GetStyle () != wxTRANSPARENT)
      {
          SetPen( m_pen );
  
      
      if (m_pen.GetStyle () != wxTRANSPARENT)
      {
          SetPen( m_pen );
  
-        *m_pstream << "newpath\n" 
-               << XLOG2DEV(x+w/2) << " " << YLOG2DEV(y+h/2) << " " 
-           << XLOG2DEVREL(w/2) << " " << XLOG2DEVREL(h/2) << " " 
-           << int(sa) <<" "<< int(ea) << " false ellipticarc\n";
-
-        CalcBoundingBox( x, y );
+       fprintf( m_pstream,
+               "newpath\n"
+               "%ld %ld %ld %ld %ld %ld false ellipticarc\n",
+               XLOG2DEV(x+w/2), YLOG2DEV(y+h/2), XLOG2DEVREL(w/2), YLOG2DEVREL(h/2), (long)sa, (long)ea );
+    
+        CalcBoundingBox( x ,y );
          CalcBoundingBox( x+w, y+h );
      }
  }
  
          CalcBoundingBox( x+w, y+h );
      }
  }
  
-void wxPostScriptDC::DrawPoint (long x, long y)
+void wxPostScriptDC::DoDrawPoint (long x, long y)
  {
  {
-    wxCHECK_RET( m_ok && m_pstream, "invalid postscript dc" );
-    
+    wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
+
      if (m_pen.GetStyle() == wxTRANSPARENT) return;
      if (m_pen.GetStyle() == wxTRANSPARENT) return;
-    
+
      SetPen (m_pen);
      SetPen (m_pen);
-    
-    *m_pstream << "newpath\n"
-         << XLOG2DEV(x)   << " " << YLOG2DEV (y) << " moveto\n"
-         << XLOG2DEV(x+1) << " " << YLOG2DEV (y) << " lineto\n"
-         << "stroke\n";
-    
+
+    fprintf( m_pstream,
+            "newpath\n"
+           "%ld %ld moveto\n"
+           "%ld %ld lineto\n"
+           "stroke\n",
+           XLOG2DEV(x),   YLOG2DEV(y),
+           XLOG2DEV(x+1), YLOG2DEV(y) );
+
      CalcBoundingBox( x, y );
  }
  
      CalcBoundingBox( x, y );
  }
  
-void wxPostScriptDC::DrawPolygon (int n, wxPoint points[], long xoffset, long yoffset, int WXUNUSED(fillStyle))
+void wxPostScriptDC::DoDrawPolygon (int n, wxPoint points[], long xoffset, long yoffset, int WXUNUSED(fillStyle))
  {
  {
-    wxCHECK_RET( m_ok && m_pstream, "invalid postscript dc" );
-    
+    wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
+
      if (n <= 0) return;
      if (n <= 0) return;
-    
+
      if (m_brush.GetStyle () != wxTRANSPARENT)
      {
      if (m_brush.GetStyle () != wxTRANSPARENT)
      {
-    SetBrush( m_brush );
-      
-    *m_pstream << "newpath\n";
+        SetBrush( m_brush );
  
  
-    long xx = XLOG2DEV(points[0].x + xoffset);
-    long yy = YLOG2DEV(points[0].y + yoffset);
-    *m_pstream << xx << " " << yy << " moveto\n";
-    CalcBoundingBox( points[0].x + xoffset, points[0].y + yoffset );
+        fprintf( m_pstream, "newpath\n" );
  
  
-    for (int i = 1; i < n; i++)
-    {
-        xx = XLOG2DEV(points[i].x + xoffset);
-        yy = YLOG2DEV(points[i].y + yoffset);
-        *m_pstream << xx << " " << yy << " lineto\n";
-        CalcBoundingBox( points[i].x + xoffset, points[i].y + yoffset);
-    }
-    *m_pstream << "fill\n";
+        long xx = XLOG2DEV(points[0].x + xoffset);
+        long yy = YLOG2DEV(points[0].y + yoffset);
+       
+       fprintf( m_pstream, "%ld %ld moveto\n", xx, yy );
+               
+        CalcBoundingBox( points[0].x + xoffset, points[0].y + yoffset );
+
+        for (int i = 1; i < n; i++)
+        {
+            xx = XLOG2DEV(points[i].x + xoffset);
+            yy = YLOG2DEV(points[i].y + yoffset);
+           
+           fprintf( m_pstream, "%ld %ld lineto\n", xx, yy );
+
+            CalcBoundingBox( points[i].x + xoffset, points[i].y + yoffset);
+        }
+       
+       fprintf( m_pstream, "fill\n" );
      }
  
      if (m_pen.GetStyle () != wxTRANSPARENT)
      {
      }
  
      if (m_pen.GetStyle () != wxTRANSPARENT)
      {
-    SetPen( m_pen );
-    
-    *m_pstream << "newpath\n";
+        SetPen( m_pen );
+       
+        fprintf( m_pstream, "newpath\n" );
  
  
-    long xx = XLOG2DEV(points[0].x + xoffset);
-    long yy = YLOG2DEV(points[0].y + yoffset);
-    *m_pstream << xx << " " << yy << " moveto\n";
-    CalcBoundingBox( points[0].x + xoffset, points[0].y + yoffset );
+        long xx = XLOG2DEV(points[0].x + xoffset);
+        long yy = YLOG2DEV(points[0].y + yoffset);
+       
+       fprintf( m_pstream, "%ld %ld moveto\n", xx, yy );
+       
+        CalcBoundingBox( points[0].x + xoffset, points[0].y + yoffset );
  
  
-    for (int i = 1; i < n; i++)
-    {
-        xx = XLOG2DEV(points[i].x + xoffset);
-        yy = YLOG2DEV(points[i].y + yoffset);
-        *m_pstream << xx << " " << yy << " lineto\n";
-        CalcBoundingBox( points[i].x + xoffset, points[i].y + yoffset);
-    }
+        for (int i = 1; i < n; i++)
+        {
+            xx = XLOG2DEV(points[i].x + xoffset);
+            yy = YLOG2DEV(points[i].y + yoffset);
+           
+           fprintf( m_pstream, "%ld %ld lineto\n", xx, yy );
+           
+            CalcBoundingBox( points[i].x + xoffset, points[i].y + yoffset);
+        }
  
  
-    *m_pstream << "stroke\n";
+       fprintf( m_pstream, "fill\n" );
      }
  }
  
      }
  }
  
-void wxPostScriptDC::DrawLines (int n, wxPoint points[], long xoffset, long yoffset)
+void wxPostScriptDC::DoDrawLines (int n, wxPoint points[], long xoffset, long yoffset)
  {
  {
-    wxCHECK_RET( m_ok && m_pstream, "invalid postscript dc" );
-    
-    if (m_pen.GetStyle() == wxTRANSPARENT)
-        return;
-    if (n <= 0)
-        return;
-  
+    wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
+
+    if (m_pen.GetStyle() == wxTRANSPARENT) return;
+       
+    if (n <= 0) return;
+
      SetPen (m_pen);
      SetPen (m_pen);
-    
+
      int i;
      for ( i =0; i<n ; i++ )
      {
          CalcBoundingBox( XLOG2DEV(points[i].x+xoffset), YLOG2DEV(points[i].y+yoffset));
      }
  
      int i;
      for ( i =0; i<n ; i++ )
      {
          CalcBoundingBox( XLOG2DEV(points[i].x+xoffset), YLOG2DEV(points[i].y+yoffset));
      }
  
-    *m_pstream << "newpath\n"
-               << XLOG2DEV(points[0].x+xoffset) << " "
-               << YLOG2DEV(points[0].y+yoffset) << " moveto\n";
-         
-    for (i = 1; i < n; i++) 
+    fprintf( m_pstream,
+            "newpath\n"
+           "%ld %ld moveto\n",
+           XLOG2DEV(points[0].x+xoffset), YLOG2DEV(points[0].y+yoffset) );
+
+    for (i = 1; i < n; i++)
      {
      {
-        *m_pstream << XLOG2DEV(points[i].x+xoffset) << " "
-                   << YLOG2DEV(points[i].y+yoffset) << " lineto\n";
+        fprintf( m_pstream,
+               "%ld %ld lineto\n",
+               XLOG2DEV(points[i].x+xoffset), YLOG2DEV(points[i].y+yoffset) );
      }
      }
-    
-    *m_pstream << "stroke\n";
+
+    fprintf( m_pstream, "stroke\n" );
  }
  
  }
  
-void wxPostScriptDC::DrawRectangle (long x, long y, long width, long height)
+void wxPostScriptDC::DoDrawRectangle (long x, long y, long width, long height)
  {
  {
-    wxCHECK_RET( m_ok && m_pstream, "invalid postscript dc" );
-    
+    wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
+
      if (m_brush.GetStyle () != wxTRANSPARENT)
      {
          SetBrush( m_brush );
      if (m_brush.GetStyle () != wxTRANSPARENT)
      {
          SetBrush( m_brush );
-
-        *m_pstream << "newpath\n"
-                   << XLOG2DEV(x) << " " << YLOG2DEV(y) << " moveto\n"
-                   << XLOG2DEV(x + width) << " " << YLOG2DEV(y) << " lineto\n"
-                   << XLOG2DEV(x + width) << " " << YLOG2DEV(y + height) << " lineto\n"
-                   << XLOG2DEV(x) << " " << YLOG2DEV(y + height) << " lineto\n"
-                   << "closepath\n"
-                   << "fill\n";
+       
+       fprintf( m_pstream,
+               "newpath\n"
+               "%ld %ld moveto\n"
+               "%ld %ld lineto\n"
+               "%ld %ld lineto\n"
+               "%ld %ld lineto\n"
+                "closepath\n"
+                "fill\n",
+               XLOG2DEV(x),         YLOG2DEV(y),
+               XLOG2DEV(x + width), YLOG2DEV(y),
+               XLOG2DEV(x + width), YLOG2DEV(y + height),
+               XLOG2DEV(x),         YLOG2DEV(y + height) );
  
          CalcBoundingBox( x, y );
          CalcBoundingBox( x + width, y + height );
      }
  
          CalcBoundingBox( x, y );
          CalcBoundingBox( x + width, y + height );
      }
-    
+
      if (m_pen.GetStyle () != wxTRANSPARENT)
      {
          SetPen (m_pen);
  
      if (m_pen.GetStyle () != wxTRANSPARENT)
      {
          SetPen (m_pen);
  
-        *m_pstream << "newpath\n"
-                   << XLOG2DEV(x) << " " << YLOG2DEV(y) << " moveto\n"
-                   << XLOG2DEV(x + width) << " " << YLOG2DEV(y) << " lineto\n"
-                   << XLOG2DEV(x + width) << " " << YLOG2DEV(y + height) << " lineto\n"
-                   << XLOG2DEV(x) << " " << YLOG2DEV(y + height) << " lineto\n"
-                   << "closepath\n"
-                   << "stroke\n";
-
+       fprintf( m_pstream,
+               "newpath\n"
+               "%ld %ld moveto\n"
+               "%ld %ld lineto\n"
+               "%ld %ld lineto\n"
+               "%ld %ld lineto\n"
+                "closepath\n"
+                "stroke\n",
+               XLOG2DEV(x),         YLOG2DEV(y),
+               XLOG2DEV(x + width), YLOG2DEV(y),
+               XLOG2DEV(x + width), YLOG2DEV(y + height),
+               XLOG2DEV(x),         YLOG2DEV(y + height) );
+               
          CalcBoundingBox( x, y );
          CalcBoundingBox( x + width, y + height );
      }
  }
  
          CalcBoundingBox( x, y );
          CalcBoundingBox( x + width, y + height );
      }
  }
  
-void wxPostScriptDC::DrawRoundedRectangle (long x, long y, long width, long height, double radius)
+void wxPostScriptDC::DoDrawRoundedRectangle (long x, long y, long width, long height, double radius)
  {
  {
-    wxCHECK_RET( m_ok && m_pstream, "invalid postscript dc" );
-    
+    wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
+
      if (radius < 0.0)
      {
          // Now, a negative radius is interpreted to mean
      if (radius < 0.0)
      {
          // Now, a negative radius is interpreted to mean
@@ -678,148 +746,181 @@ void wxPostScriptDC::DrawRoundedRectangle (long x, long y, long width, long heig
          smallest = height;
          radius =  (-radius * smallest);
      }
          smallest = height;
          radius =  (-radius * smallest);
      }
-    
+
      long rad = (long) radius;
  
      if (m_brush.GetStyle () != wxTRANSPARENT)
      {
          SetBrush( m_brush );
      long rad = (long) radius;
  
      if (m_brush.GetStyle () != wxTRANSPARENT)
      {
          SetBrush( m_brush );
-    
-        // Draw rectangle anticlockwise
-        *m_pstream << "newpath\n"
-                   << XLOG2DEV(x + rad) << " " << YLOG2DEV(y + rad) << " " << XLOG2DEVREL(rad) << " 90 180 arc\n"
-                   << XLOG2DEV(x) << " " << YLOG2DEV(y + rad) << " moveto\n"
-                   << XLOG2DEV(x + rad) << " " << YLOG2DEV(y + height - rad) << " " << XLOG2DEVREL(rad) << " 180 270 arc\n"
-                   << XLOG2DEV(x + width - rad) << " " << YLOG2DEV(y + height) << " lineto\n"
-                   << XLOG2DEV(x + width - rad) << " " << YLOG2DEV(y + height - rad) << " " << XLOG2DEVREL(rad) << " 270 0 arc\n"
-                   << XLOG2DEV(x + width) << " " << YLOG2DEV(y + rad) << " lineto\n"
-                   << XLOG2DEV(x + width - rad) << " " << YLOG2DEV(y + rad) << " " << XLOG2DEVREL(rad) << " 0 90 arc\n"
-                   << XLOG2DEV(x + rad) << " " << YLOG2DEV(y) << " lineto\n"
-                   << "closepath\n"
-                   << "fill\n";
+
+        /* Draw rectangle anticlockwise */
+       fprintf( m_pstream,
+               "newpath\n"
+               "%ld %ld %ld 90 180 arc\n"
+               "%ld %ld moveto\n"
+               "%ld %ld %ld 180 270 arc\n"
+               "%ld %ld lineto\n"
+               "%ld %ld %ld 270 0 arc\n"
+               "%ld %ld lineto\n"
+               "%ld %ld %ld 0 90 arc\n"
+               "%ld %ld lineto\n"
+                "closepath\n"
+                "fill\n",
+               XLOG2DEV(x + rad), YLOG2DEV(y + rad), XLOG2DEVREL(rad),
+               XLOG2DEV(x), YLOG2DEV(y + rad),
+                XLOG2DEV(x + rad), YLOG2DEV(y + height - rad), XLOG2DEVREL(rad),
+                XLOG2DEV(x + width - rad), YLOG2DEV(y + height),
+               XLOG2DEV(x + width - rad), YLOG2DEV(y + height - rad), XLOG2DEVREL(rad),
+               XLOG2DEV(x + width), YLOG2DEV(y + rad),
+               XLOG2DEV(x + width - rad), YLOG2DEV(y + rad), XLOG2DEVREL(rad),
+               XLOG2DEV(x + rad), YLOG2DEV(y) );
  
          CalcBoundingBox( x, y );
          CalcBoundingBox( x + width, y + height );
      }
  
          CalcBoundingBox( x, y );
          CalcBoundingBox( x + width, y + height );
      }
-    
+
      if (m_pen.GetStyle () != wxTRANSPARENT)
      {
          SetPen (m_pen);
      if (m_pen.GetStyle () != wxTRANSPARENT)
      {
          SetPen (m_pen);
-    
-        // Draw rectangle anticlockwise
-        *m_pstream << "newpath\n"
-                   << XLOG2DEV(x + rad) << " " << YLOG2DEV(y + rad) << " " << XLOG2DEVREL(rad) << " 90 180 arc\n"
-                   << XLOG2DEV(x) << " " << YLOG2DEV(y + rad) << " moveto\n"
-                   << XLOG2DEV(x + rad) << " " << YLOG2DEV(y + height - rad) << " " << XLOG2DEVREL(rad) << " 180 270 arc\n"
-                   << XLOG2DEV(x + width - rad) << " " << YLOG2DEV(y + height) << " lineto\n"
-                   << XLOG2DEV(x + width - rad) << " " << YLOG2DEV(y + height - rad) << " " << XLOG2DEVREL(rad) << " 270 0 arc\n"
-                   << XLOG2DEV(x + width) << " " << YLOG2DEV(y + rad) << " lineto\n"
-                   << XLOG2DEV(x + width - rad) << " " << YLOG2DEV(y + rad) << " " << XLOG2DEVREL(rad) << " 0 90 arc\n"
-                   << XLOG2DEV(x + rad) << " " << YLOG2DEV(y) << " lineto\n"
-                   << "closepath\n"
-                   << "stroke\n";
+
+        /* Draw rectangle anticlockwise */
+       fprintf( m_pstream,
+               "newpath\n"
+               "%ld %ld %ld 90 180 arc\n"
+               "%ld %ld moveto\n"
+               "%ld %ld %ld 180 270 arc\n"
+               "%ld %ld lineto\n"
+               "%ld %ld %ld 270 0 arc\n"
+               "%ld %ld lineto\n"
+               "%ld %ld %ld 0 90 arc\n"
+               "%ld %ld lineto\n"
+                "closepath\n"
+                "stroke\n",
+               XLOG2DEV(x + rad), YLOG2DEV(y + rad), XLOG2DEVREL(rad),
+               XLOG2DEV(x), YLOG2DEV(y + rad),
+                XLOG2DEV(x + rad), YLOG2DEV(y + height - rad), XLOG2DEVREL(rad),
+                XLOG2DEV(x + width - rad), YLOG2DEV(y + height),
+               XLOG2DEV(x + width - rad), YLOG2DEV(y + height - rad), XLOG2DEVREL(rad),
+               XLOG2DEV(x + width), YLOG2DEV(y + rad),
+               XLOG2DEV(x + width - rad), YLOG2DEV(y + rad), XLOG2DEVREL(rad),
+               XLOG2DEV(x + rad), YLOG2DEV(y) );
  
          CalcBoundingBox( x, y );
          CalcBoundingBox( x + width, y + height );
      }
  }
  
  
          CalcBoundingBox( x, y );
          CalcBoundingBox( x + width, y + height );
      }
  }
  
-void wxPostScriptDC::DrawEllipse (long x, long y, long width, long height)
+void wxPostScriptDC::DoDrawEllipse (long x, long y, long width, long height)
  {
  {
-    wxCHECK_RET( m_ok && m_pstream, "invalid postscript dc" );
-    
+    wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
+
      if (m_brush.GetStyle () != wxTRANSPARENT)
      {
          SetBrush (m_brush);
  
      if (m_brush.GetStyle () != wxTRANSPARENT)
      {
          SetBrush (m_brush);
  
-        *m_pstream << "newpath\n" 
-                   << XLOG2DEV(x + width / 2) << " " << YLOG2DEV(y + height / 2) << " " 
-                   << XLOG2DEV(width / 2) << " " << YLOG2DEVREL(height / 2) << " 0 360 ellipse\n" 
-                   << "fill\n";
+        fprintf( m_pstream, 
+               "newpath\n"
+               "%ld %ld %ld %ld 0 360 ellipse\n"
+               "fill\n",
+               XLOG2DEV(x + width / 2), YLOG2DEV(y + height / 2), 
+               XLOG2DEV(width / 2), YLOG2DEVREL(height / 2) );
  
          CalcBoundingBox( x - width, y - height );
          CalcBoundingBox( x + width, y + height );
      }
  
          CalcBoundingBox( x - width, y - height );
          CalcBoundingBox( x + width, y + height );
      }
-    
-    if (m_pen.Ok() && m_pen.GetStyle () != wxTRANSPARENT)
+
+    if (m_pen.GetStyle () != wxTRANSPARENT)
      {
          SetPen (m_pen);
  
      {
          SetPen (m_pen);
  
-        *m_pstream << "newpath\n" 
-                   << XLOG2DEV(x + width / 2) << " " << YLOG2DEV(y + height / 2) << " " 
-                   << XLOG2DEV(width / 2) << " " << YLOG2DEVREL(height / 2) << " 0 360 ellipse\n" 
-                   << "stroke\n";
+        fprintf( m_pstream, 
+               "newpath\n"
+               "%ld %ld %ld %ld 0 360 ellipse\n"
+               "stroke\n",
+               XLOG2DEV(x + width / 2), YLOG2DEV(y + height / 2), 
+               XLOG2DEV(width / 2), YLOG2DEVREL(height / 2) );
  
          CalcBoundingBox( x - width, y - height );
          CalcBoundingBox( x + width, y + height );
      }
  }
  
  
          CalcBoundingBox( x - width, y - height );
          CalcBoundingBox( x + width, y + height );
      }
  }
  
-void wxPostScriptDC::DrawIcon( const wxIcon& icon, long x, long y )
+void wxPostScriptDC::DoDrawIcon( const wxIcon& icon, long x, long y )
  {
      DrawBitmap( icon, x, y, TRUE );
  }
  
  {
      DrawBitmap( icon, x, y, TRUE );
  }
  
-void wxPostScriptDC::DrawBitmap( const wxBitmap& bitmap, long x, long y, bool WXUNUSED(useMask) )
+/* this has to be char, not wxChar */
+static char hexArray[] = "0123456789ABCDEF";
+static void LocalDecToHex( int dec, char *buf )
  {
  {
-    wxCHECK_RET( m_ok && m_pstream, "invalid postscript dc" );
+    int firstDigit = (int)(dec/16.0);
+    int secondDigit = (int)(dec - (firstDigit*16.0));
+    buf[0] = hexArray[firstDigit];
+    buf[1] = hexArray[secondDigit];
+    buf[2] = 0;
+}
+
+void wxPostScriptDC::DoDrawBitmap( const wxBitmap& bitmap, long x, long y, bool WXUNUSED(useMask) )
+{
+    wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
  
      if (!bitmap.Ok()) return;
  
      if (!bitmap.Ok()) return;
-    
+
      wxImage image( bitmap );
      wxImage image( bitmap );
-    
+
      if (!image.Ok()) return;
      if (!image.Ok()) return;
-    
-    int ww = XLOG2DEVREL(image.GetWidth());
-    int hh = YLOG2DEVREL(image.GetHeight());
-    
+
+    long ww = XLOG2DEVREL(image.GetWidth());
+    long hh = YLOG2DEVREL(image.GetHeight());
+
      image = image.Scale( ww, hh );
      image = image.Scale( ww, hh );
-    
+
      if (!image.Ok()) return;
      if (!image.Ok()) return;
-    
-    int xx = XLOG2DEV(x);
-    int yy = YLOG2DEV(y + bitmap.GetHeight());
-    
-    *m_pstream << "/origstate save def\n"
-               << "20 dict begin\n"
-               << "/pix " << ww << " string def\n"
-               << "/grays " << ww << " string def\n"
-               << "/npixels 0 def\n"
-               << "/rgbindx 0 def\n"
-               << xx << " " << yy << " translate\n"
-               << ww << " " << hh << " scale\n"
-               << ww << " " << hh << " 8\n"
-               << "[" << ww << " 0 0 " << (-hh) << " 0 " << hh << "]\n"
-               << "{currentfile pix readhexstring pop}\n"
-               << "false 3 colorimage\n";
-  
+
+    long xx = XLOG2DEV(x);
+    long yy = YLOG2DEV(y + bitmap.GetHeight());
+
+    fprintf( m_pstream,
+            "/origstate save def\n"
+           "20 dict begin\n"
+           "/pix %ld string def\n"
+           "/grays %ld string def\n"
+            "/npixels 0 def\n"
+            "/rgbindx 0 def\n"
+           "%ld %ld translate\n"
+           "%ld %ld scale\n"
+           "%ld %ld 8\n"
+           "[%ld 0 0 %ld 0 %ld]\n"
+           "{currentfile pix readhexstring pop}\n"
+           "false 3 colorimage\n",
+           ww, ww, xx, yy, ww, hh, ww, hh, ww, -hh, hh );
+
      for (int j = 0; j < hh; j++)
      {
          for (int i = 0; i < ww; i++)
          {
      for (int j = 0; j < hh; j++)
      {
          for (int i = 0; i < ww; i++)
          {
-        char buffer[5];
-        buffer[2] = 0;
-        wxDecToHex( image.GetRed(i,j), buffer );
-            *m_pstream << buffer;
-        wxDecToHex( image.GetGreen(i,j), buffer );
-            *m_pstream << buffer;
-        wxDecToHex( image.GetBlue(i,j), buffer );
-            *m_pstream << buffer;
-    }
-    *m_pstream << "\n";
+            char buffer[5];
+            LocalDecToHex( image.GetRed(i,j), buffer );
+           fprintf( m_pstream, buffer );
+            LocalDecToHex( image.GetGreen(i,j), buffer );
+           fprintf( m_pstream, buffer );
+           LocalDecToHex( image.GetBlue(i,j), buffer );
+           fprintf( m_pstream, buffer );
+        }
+        fprintf( m_pstream, "\n" );
      }
  
      }
  
-    *m_pstream << "end\n";
-    *m_pstream << "origstate restore\n";
-    
+    fprintf( m_pstream, "end\n" );
+    fprintf( m_pstream, "origstate restore\n" );
  }
  
  void wxPostScriptDC::SetFont( const wxFont& font )
  {
  }
  
  void wxPostScriptDC::SetFont( const wxFont& font )
  {
-    wxCHECK_RET( m_ok && m_pstream, "invalid postscript dc" );
-    
+    wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
+
      if (!font.Ok())  return;
      if (!font.Ok())  return;
-    
+
      m_font = font;
  
      const char *name;
      m_font = font;
  
      const char *name;
@@ -827,7 +928,7 @@ void wxPostScriptDC::SetFont( const wxFont& font )
      int Style = m_font.GetStyle();
      int Weight = m_font.GetWeight();
  
      int Style = m_font.GetStyle();
      int Weight = m_font.GetWeight();
  
-    switch (m_font.GetFamily ())
+    switch (m_font.GetFamily())
      {
          case wxTELETYPE:
          case wxMODERN:
      {
          case wxTELETYPE:
          case wxMODERN:
@@ -852,72 +953,74 @@ void wxPostScriptDC::SetFont( const wxFont& font )
  
      if (Style == wxNORMAL && (Weight == wxNORMAL || Weight == wxLIGHT))
      {
  
      if (Style == wxNORMAL && (Weight == wxNORMAL || Weight == wxLIGHT))
      {
-      if (m_font.GetFamily () == wxROMAN)
-    style = "-Roman";
-      else
-    style = "";
+        if (m_font.GetFamily () == wxROMAN)
+            style = "-Roman";
+        else
+            style = "";
      }
      else if (Style == wxNORMAL && Weight == wxBOLD)
      {
      }
      else if (Style == wxNORMAL && Weight == wxBOLD)
      {
-      style = "-Bold";
+        style = "-Bold";
      }
      else if (Style == wxITALIC && (Weight == wxNORMAL || Weight == wxLIGHT))
      {
      }
      else if (Style == wxITALIC && (Weight == wxNORMAL || Weight == wxLIGHT))
      {
-      if (m_font.GetFamily () == wxROMAN)
-    style = "-Italic";
-      else
-    style = "-Oblique";
+        if (m_font.GetFamily () == wxROMAN)
+            style = "-Italic";
+        else
+            style = "-Oblique";
      }
      else if (Style == wxITALIC && Weight == wxBOLD)
      {
      }
      else if (Style == wxITALIC && Weight == wxBOLD)
      {
-      if (m_font.GetFamily () == wxROMAN)
-    style = "-BoldItalic";
-      else
-    style = "-BoldOblique";
+        if (m_font.GetFamily () == wxROMAN)
+            style = "-BoldItalic";
+        else
+            style = "-BoldOblique";
      }
      else if (Style == wxSLANT && (Weight == wxNORMAL || Weight == wxLIGHT))
      {
      }
      else if (Style == wxSLANT && (Weight == wxNORMAL || Weight == wxLIGHT))
      {
-      if (m_font.GetFamily () == wxROMAN)
-    style = "-Italic";
-      else
-    style = "-Oblique";
+        if (m_font.GetFamily () == wxROMAN)
+            style = "-Italic";
+        else
+            style = "-Oblique";
      }
      else if (Style == wxSLANT && Weight == wxBOLD)
      {
      }
      else if (Style == wxSLANT && Weight == wxBOLD)
      {
-      if (m_font.GetFamily () == wxROMAN)
-    style = "-BoldItalic";
-      else
-    style = "-BoldOblique";
+        if (m_font.GetFamily () == wxROMAN)
+            style = "-BoldItalic";
+        else
+            style = "-BoldOblique";
      }
      else
      {
      }
      else
      {
-      style = "";
+        style = "";
      }
  
      }
  
-    char buf[100];
-    strcpy (buf, name);
-    strcat (buf, style);
-    
-    *m_pstream << buf << " reencodeISO def\n";
-    *m_pstream << buf << " findfont\n";
-    *m_pstream << YLOG2DEVREL(m_font.GetPointSize()) << " scalefont setfont\n";
+    char buffer[100];
+    strcpy( buffer, name );
+    strcat( buffer, style );
+
+    fprintf( m_pstream, buffer );
+    fprintf( m_pstream, " reencodeISO def\n" );
+    fprintf( m_pstream, buffer );
+    fprintf( m_pstream, " findfont\n" );
+    fprintf( m_pstream, "%ld scalefont setfont\n", YLOG2DEVREL(m_font.GetPointSize()) );
  }
  
  void wxPostScriptDC::SetPen( const wxPen& pen )
  {
  }
  
  void wxPostScriptDC::SetPen( const wxPen& pen )
  {
-    wxCHECK_RET( m_ok && m_pstream, "invalid postscript dc" );
-    
+    wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
+
      if (!pen.Ok()) return;
      if (!pen.Ok()) return;
-    
+
      int oldStyle = m_pen.GetStyle();
  
      m_pen = pen;
  
      int oldStyle = m_pen.GetStyle();
  
      m_pen = pen;
  
-    *m_pstream << XLOG2DEVREL(m_pen.GetWidth()) << " setlinewidth\n";
+    fprintf( m_pstream, "%ld setlinewidth\n", XLOG2DEVREL(m_pen.GetWidth()) );
  
  /*
       Line style - WRONG: 2nd arg is OFFSET
  
  /*
       Line style - WRONG: 2nd arg is OFFSET
-     
+
       Here, I'm afraid you do not conceive meaning of parameters of 'setdash'
       operator correctly. You should look-up this in the Red Book: the 2nd parame-
       ter is not number of values in the array of the first one, but an offset
       Here, I'm afraid you do not conceive meaning of parameters of 'setdash'
       operator correctly. You should look-up this in the Red Book: the 2nd parame-
       ter is not number of values in the array of the first one, but an offset
@@ -933,7 +1036,7 @@ void wxPostScriptDC::SetPen( const wxPen& pen )
      static const char *dotted_dashed = "[6 6 2 6] 4";
  
      const char *psdash = (char *) NULL;
      static const char *dotted_dashed = "[6 6 2 6] 4";
  
      const char *psdash = (char *) NULL;
-    switch (m_pen.GetStyle ())
+    switch (m_pen.GetStyle())
      {
          case wxDOT:           psdash = dotted;         break;
          case wxSHORT_DASH:    psdash = short_dashed;   break;
      {
          case wxDOT:           psdash = dotted;         break;
          case wxSHORT_DASH:    psdash = short_dashed;   break;
@@ -943,10 +1046,11 @@ void wxPostScriptDC::SetPen( const wxPen& pen )
          case wxTRANSPARENT:
          default:              psdash = "[] 0";         break;
      }
          case wxTRANSPARENT:
          default:              psdash = "[] 0";         break;
      }
-    
+
      if (oldStyle != m_pen.GetStyle())
      {
      if (oldStyle != m_pen.GetStyle())
      {
-        *m_pstream << psdash << " setdash\n";
+        fprintf( m_pstream, psdash );
+       fprintf( m_pstream," setdash\n" );
      }
  
      // Line colour
      }
  
      // Line colour
@@ -957,103 +1061,112 @@ void wxPostScriptDC::SetPen( const wxPen& pen )
      if (!m_colour)
      {
          // Anything not white is black
      if (!m_colour)
      {
          // Anything not white is black
-        if (!(red == (unsigned char) 255 && blue == (unsigned char) 255
-        && green == (unsigned char) 255))
-    {
-        red = (unsigned char) 0;
-        green = (unsigned char) 0;
-        blue = (unsigned char) 0;
-    }
-    
-    // setgray here ?
+        if (! (red == (unsigned char) 255 && 
+              blue == (unsigned char) 255 &&
+               green == (unsigned char) 255) )
+        {
+            red = (unsigned char) 0;
+            green = (unsigned char) 0;
+            blue = (unsigned char) 0;
+        } 
+        // setgray here ?
      }
  
      if (!(red == m_currentRed && green == m_currentGreen && blue == m_currentBlue))
      {
      }
  
      if (!(red == m_currentRed && green == m_currentGreen && blue == m_currentBlue))
      {
-       long redPS = (long) (((int) red) / 255.0);
-       long bluePS = (long) (((int) blue) / 255.0);
-       long greenPS = (long) (((int) green) / 255.0);
-
-       *m_pstream << redPS << " " << greenPS << " " << bluePS << " setrgbcolor\n";
-
-       m_currentRed = red;
-       m_currentBlue = blue;
-       m_currentGreen = green;
+        double redPS = (double)(red) / 255.0;
+        double bluePS = (double)(blue) / 255.0;
+        double greenPS = (double)(green) / 255.0;
+       
+       fprintf( m_pstream, 
+               "%.8f %.8f %.8f setrgbcolor\n",
+               redPS, greenPS, bluePS );
+               
+        m_currentRed = red;
+        m_currentBlue = blue;
+        m_currentGreen = green;
      }
  }
  
  void wxPostScriptDC::SetBrush( const wxBrush& brush )
  {
      }
  }
  
  void wxPostScriptDC::SetBrush( const wxBrush& brush )
  {
-    wxCHECK_RET( m_ok && m_pstream, "invalid postscript dc" );
-    
+    wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
+
      if (!brush.Ok()) return;
      if (!brush.Ok()) return;
-    
+
      m_brush = brush;
  
      // Brush colour
      m_brush = brush;
  
      // Brush colour
-    unsigned char red = m_brush.GetColour ().Red ();
-    unsigned char blue = m_brush.GetColour ().Blue ();
-    unsigned char green = m_brush.GetColour ().Green ();
+    unsigned char red = m_brush.GetColour().Red();
+    unsigned char blue = m_brush.GetColour().Blue();
+    unsigned char green = m_brush.GetColour().Green();
  
      if (!m_colour)
      {
  
      if (!m_colour)
      {
-        // Anything not black is white
-        if (!(red == (unsigned char) 0 && blue == (unsigned char) 0
-        && green == (unsigned char) 0))
-    {
-        red = (unsigned char) 255;
-        green = (unsigned char) 255;
-        blue = (unsigned char) 255;
+        // Anything not white is black
+        if (! (red == (unsigned char) 255 && 
+              blue == (unsigned char) 255 &&
+               green == (unsigned char) 255) )
+        {
+            red = (unsigned char) 0;
+            green = (unsigned char) 0;
+            blue = (unsigned char) 0;
+        } 
+        // setgray here ?
      }
      
      }
      
-    // setgray here ?
-    }
-
      if (!(red == m_currentRed && green == m_currentGreen && blue == m_currentBlue))
      {
      if (!(red == m_currentRed && green == m_currentGreen && blue == m_currentBlue))
      {
-       long redPS = (long) (((int) red) / 255.0);
-       long bluePS = (long) (((int) blue) / 255.0);
-       long greenPS = (long) (((int) green) / 255.0);
-       *m_pstream << redPS << " " << greenPS << " " << bluePS << " setrgbcolor\n";
-       m_currentRed = red;
-       m_currentBlue = blue;
-       m_currentGreen = green;
+        double redPS = (double)(red) / 255.0;
+        double bluePS = (double)(blue) / 255.0;
+        double greenPS = (double)(green) / 255.0;
+       
+       fprintf( m_pstream, 
+               "%.8f %.8f %.8f setrgbcolor\n",
+               redPS, greenPS, bluePS );
+               
+        m_currentRed = red;
+        m_currentBlue = blue;
+        m_currentGreen = green;
      }
  }
  
      }
  }
  
-void wxPostScriptDC::DrawText( const wxString& text, long x, long y, bool WXUNUSED(use16bit) )
+void wxPostScriptDC::DoDrawText( const wxString& text, long x, long y )
  {
  {
-    wxCHECK_RET( m_ok && m_pstream, "invalid postscript dc" );
-    
+    wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
+
      SetFont( m_font );
  
      SetFont( m_font );
  
-    if (m_textForegroundColour.Ok ())
+    if (m_textForegroundColour.Ok())
      {
      {
-        unsigned char red = m_textForegroundColour.Red ();
-        unsigned char blue = m_textForegroundColour.Blue ();
-        unsigned char green = m_textForegroundColour.Green ();
+        unsigned char red = m_textForegroundColour.Red();
+        unsigned char blue = m_textForegroundColour.Blue();
+        unsigned char green = m_textForegroundColour.Green();
  
          if (!m_colour)
  
          if (!m_colour)
-    {
-      // Anything not white is black
-      if (!(red == (unsigned char) 255 && blue == (unsigned char) 255
-        && green == (unsigned char) 255))
          {
          {
-          red = (unsigned char) 0;
-          green = (unsigned char) 0;
-          blue = (unsigned char) 0;
+            // Anything not white is black
+            if (! (red == (unsigned char) 255 && 
+                  blue == (unsigned char) 255 &&
+                  green == (unsigned char) 255))
+            {
+                red = (unsigned char) 0;
+                green = (unsigned char) 0;
+                blue = (unsigned char) 0;
+            }
          }
          }
-    }
-    
-    // maybe setgray here ?
-    
+
+        // maybe setgray here ?
          if (!(red == m_currentRed && green == m_currentGreen && blue == m_currentBlue))
          {
          if (!(red == m_currentRed && green == m_currentGreen && blue == m_currentBlue))
          {
-            long redPS = (long) (((int) red) / 255.0);
-            long bluePS = (long) (((int) blue) / 255.0);
-            long greenPS = (long) (((int) green) / 255.0);
-            *m_pstream << redPS << " " << greenPS << " " << bluePS << " setrgbcolor\n";
-
+            double redPS = (double)(red) / 255.0;
+            double bluePS = (double)(blue) / 255.0;
+            double greenPS = (double)(green) / 255.0;
+       
+           fprintf( m_pstream, 
+                   "%.8f %.8f %.8f setrgbcolor\n",
+                   redPS, greenPS, bluePS );
+               
              m_currentRed = red;
              m_currentBlue = blue;
              m_currentGreen = green;
              m_currentRed = red;
              m_currentBlue = blue;
              m_currentGreen = green;
@@ -1062,45 +1175,59 @@ void wxPostScriptDC::DrawText( const wxString& text, long x, long y, bool WXUNUS
  
      int size = m_font.GetPointSize();
  
  
      int size = m_font.GetPointSize();
  
-    long by = y + (long)floor( float(size) * 2.0 / 3.0 ); // approximate baseline
-    *m_pstream << XLOG2DEV(x) << " " << YLOG2DEV(by) << " moveto\n";
+    long by = y + (long)floor( double(size) * 2.0 / 3.0 ); // approximate baseline
+    fprintf( m_pstream, "%ld %ld moveto\n", XLOG2DEV(x), YLOG2DEV(by) );
+
+    /* I don't know how to write char to a stream, so I use a mini string */
+    char tmpbuf[2];
+    tmpbuf[1] = 0;
      
      
-    *m_pstream << "(";
-    int len = strlen ((char *)(const char *)text);
+    fprintf( m_pstream, "(" );
+    const wxWX2MBbuf textbuf = text.mb_str();
+    int len = strlen(textbuf);
      int i;
      for (i = 0; i < len; i++)
      {
      int i;
      for (i = 0; i < len; i++)
      {
-        int c = (unsigned char) text[i];
-        if ( c == ')' || c == '(' || c == '\\')
+        int c = (unsigned char) textbuf[i];
+        if (c == ')' || c == '(' || c == '\\')
          {
          {
-            *m_pstream << "\\" << (char) c;
+            /* Cope with special characters */
+           fprintf( m_pstream, "\\" );
+           tmpbuf[0] = (char) c;
+           fprintf( m_pstream, tmpbuf );
          }
          else if ( c >= 128 )
          {
          }
          else if ( c >= 128 )
          {
-            // Cope with character codes > 127
-            char tmp[5];
-            sprintf(tmp, "\\%o", c);
-            *m_pstream << tmp;
+            /* Cope with character codes > 127 */
+           fprintf(m_pstream, "\\%o", c);
          }
          else
          }
          else
-            *m_pstream << (char) c;
+       {
+           tmpbuf[0] = (char) c;
+           fprintf( m_pstream, tmpbuf );
+       }
      }
      }
-
-    *m_pstream << ")" << " show\n";
+    
+    fprintf( m_pstream, ") show\n" );
  
      if (m_font.GetUnderlined())
      {
          long uy = (long)(y + size - m_underlinePosition);
          long w, h;
          GetTextExtent(text, &w, &h);
  
      if (m_font.GetUnderlined())
      {
          long uy = (long)(y + size - m_underlinePosition);
          long w, h;
          GetTextExtent(text, &w, &h);
-      
-        *m_pstream << "gsave " << XLOG2DEV(x) << " " << YLOG2DEV(uy)
-                   << " moveto\n"
-                   << (long)m_underlineThickness << " setlinewidth "
-                   << XLOG2DEV(x + w) << " " << YLOG2DEV(uy)
-                   << " lineto stroke grestore\n";
+
+        fprintf( m_pstream, 
+               "gsave\n"
+               "%ld %ld moveto\n"              
+               "%ld setlinewidth\n"
+               "%ld %ld lineto\n"
+               "stroke\n"
+               "grestore\n", 
+                XLOG2DEV(x), YLOG2DEV(uy),
+               (long)m_underlineThickness,
+               XLOG2DEV(x + w), YLOG2DEV(uy) );
      }
      }
-    
+
      CalcBoundingBox( x, y );
      CalcBoundingBox( x + size * text.Length() * 2/3 , y );
  }
      CalcBoundingBox( x, y );
      CalcBoundingBox( x + size * text.Length() * 2/3 , y );
  }
@@ -1113,13 +1240,13 @@ void wxPostScriptDC::SetBackground (const wxBrush& brush)
  
  void wxPostScriptDC::SetLogicalFunction (int WXUNUSED(function))
  {
  
  void wxPostScriptDC::SetLogicalFunction (int WXUNUSED(function))
  {
-    wxFAIL_MSG( "wxPostScriptDC::SetLogicalFunction not implemented." );
+    wxFAIL_MSG( _T("wxPostScriptDC::SetLogicalFunction not implemented.") );
  }
  
  }
  
-void wxPostScriptDC::DrawSpline( wxList *points )
+void wxPostScriptDC::DoDrawSpline( wxList *points )
  {
  {
-    wxCHECK_RET( m_ok && m_pstream, "invalid postscript dc" );
-    
+    wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
+
      SetPen( m_pen );
  
      double a, b, c, d, x1, y1, x2, y2, x3, y3;
      SetPen( m_pen );
  
      double a, b, c, d, x1, y1, x2, y2, x3, y3;
@@ -1127,20 +1254,23 @@ void wxPostScriptDC::DrawSpline( wxList *points )
  
      wxNode *node = points->First();
      p = (wxPoint *)node->Data();
  
      wxNode *node = points->First();
      p = (wxPoint *)node->Data();
-    x1 = p->x; 
+    x1 = p->x;
      y1 = p->y;
  
      node = node->Next();
      p = (wxPoint *)node->Data();
      y1 = p->y;
  
      node = node->Next();
      p = (wxPoint *)node->Data();
-    c = p->x; 
+    c = p->x;
      d = p->y;
      x3 = a = (double)(x1 + c) / 2;
      y3 = b = (double)(y1 + d) / 2;
  
      d = p->y;
      x3 = a = (double)(x1 + c) / 2;
      y3 = b = (double)(y1 + d) / 2;
  
-    *m_pstream  << "newpath " 
-                << XLOG2DEV((long)x1) << " " << YLOG2DEV((long)y1) << " moveto " 
-        << XLOG2DEV((long)x3) << " " << YLOG2DEV((long)y3) << " lineto\n";
-        
+    fprintf( m_pstream, 
+            "newpath\n"
+           "%ld %ld moveto\n"
+           "%ld %ld lineto\n",
+            XLOG2DEV((long)x1), YLOG2DEV((long)y1),
+            XLOG2DEV((long)x3), YLOG2DEV((long)y3) );
+
      CalcBoundingBox( (long)x1, (long)y1 );
      CalcBoundingBox( (long)x3, (long)y3 );
  
      CalcBoundingBox( (long)x1, (long)y1 );
      CalcBoundingBox( (long)x3, (long)y3 );
  
@@ -1148,31 +1278,37 @@ void wxPostScriptDC::DrawSpline( wxList *points )
      {
          q = (wxPoint *)node->Data();
  
      {
          q = (wxPoint *)node->Data();
  
-    x1 = x3; 
-    y1 = y3;
-    x2 = c;  
-    y2 = d;
-    c = q->x; 
-    d = q->y;
+        x1 = x3;
+        y1 = y3;
+        x2 = c;
+        y2 = d;
+        c = q->x;
+        d = q->y;
          x3 = (double)(x2 + c) / 2;
          y3 = (double)(y2 + d) / 2;
          x3 = (double)(x2 + c) / 2;
          y3 = (double)(y2 + d) / 2;
-        *m_pstream << XLOG2DEV((long)x1) << " " << YLOG2DEV((long)y1) << " " 
-               << XLOG2DEV((long)x2) << " " << YLOG2DEV((long)y2) << " "
-                   << XLOG2DEV((long)x3) << " " << YLOG2DEV((long)y3) << " DrawSplineSection\n";
+       
+       fprintf( m_pstream,
+               "%ld %ld %ld %ld %ld %ld DrawSplineSection\n",
+               XLOG2DEV((long)x1), YLOG2DEV((long)y1),
+               XLOG2DEV((long)x2), YLOG2DEV((long)y2),
+               XLOG2DEV((long)x3), YLOG2DEV((long)y3) );
  
          CalcBoundingBox( (long)x1, (long)y1 );
          CalcBoundingBox( (long)x3, (long)y3 );
      }
  
          CalcBoundingBox( (long)x1, (long)y1 );
          CalcBoundingBox( (long)x3, (long)y3 );
      }
-    
+
  /*
       At this point, (x2,y2) and (c,d) are the position of the
       next-to-last and last point respectively, in the point list
  */
  
  /*
       At this point, (x2,y2) and (c,d) are the position of the
       next-to-last and last point respectively, in the point list
  */
  
-    *m_pstream << XLOG2DEV((long)c) << " " << YLOG2DEV((long)d) << " lineto stroke\n";
+    fprintf( m_pstream,
+            "%ld %ld lineto\n"
+           "stroke\n",
+           XLOG2DEV((long)c), YLOG2DEV((long)d) );
  }
  
  }
  
-long wxPostScriptDC::GetCharWidth ()
+long wxPostScriptDC::GetCharWidth() const
  {
      // Chris Breeze: reasonable approximation using wxMODERN/Courier
      return (long) (GetCharHeight() * 72.0 / 120.0);
  {
      // Chris Breeze: reasonable approximation using wxMODERN/Courier
      return (long) (GetCharHeight() * 72.0 / 120.0);
@@ -1181,11 +1317,11 @@ long wxPostScriptDC::GetCharWidth ()
  
  void wxPostScriptDC::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
  {
  
  void wxPostScriptDC::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
  {
-    wxCHECK_RET( m_ok && m_pstream, "invalid postscript dc" );
-    
+    wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
+
      m_signX = (xLeftRight ? 1 : -1);
      m_signY = (yBottomUp  ? 1 : -1);
      m_signX = (xLeftRight ? 1 : -1);
      m_signY = (yBottomUp  ? 1 : -1);
-    
+
      // FIXME there is no such function in MSW
  #ifndef __WXMSW__
      ComputeScaleAndOrigin();
      // FIXME there is no such function in MSW
  #ifndef __WXMSW__
      ComputeScaleAndOrigin();
@@ -1194,29 +1330,27 @@ void wxPostScriptDC::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
  
  void wxPostScriptDC::SetDeviceOrigin( long x, long y )
  {
  
  void wxPostScriptDC::SetDeviceOrigin( long x, long y )
  {
-    wxCHECK_RET( m_ok && m_pstream, "invalid postscript dc" );
-    
+    wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
+
      int h = 0;
      int w = 0;
      GetSize( &w, &h );
      int h = 0;
      int w = 0;
      GetSize( &w, &h );
-  
+
      wxDC::SetDeviceOrigin( x, h-y );
  }
  
      wxDC::SetDeviceOrigin( x, h-y );
  }
  
-void wxPostScriptDC::GetSize(int* width, int* height) const
+void wxPostScriptDC::DoGetSize(int* width, int* height) const
  {
  {
-    const char *paperType = wxThePrintSetupData->GetPaperName();
-    
-    if (!paperType) paperType = _("A4 210 x 297 mm");
+    wxPaperSize id = m_printData.GetPaperId();
+
+    wxPrintPaperType *paper = wxThePrintPaperDatabase->FindPaperType(id);
+
+    if (!paper) paper = wxThePrintPaperDatabase->FindPaperType(wxPAPER_A4);
  
  
-    wxPrintPaperType *paper = wxThePrintPaperDatabase->FindPaperType(paperType);
-    
-    if (!paper) paper = wxThePrintPaperDatabase->FindPaperType(_("A4 210 x 297 mm"));
-    
      if (paper)
      {
      if (paper)
      {
-        if (width) *width = paper->widthPixels;
-        if (height) *height = paper->heightPixels;
+        if (width) *width = paper->GetSizeDeviceUnits().x;
+        if (height) *height = paper->GetSizeDeviceUnits().y;
      }
      else
      {
      }
      else
      {
@@ -1225,32 +1359,64 @@ void wxPostScriptDC::GetSize(int* width, int* height) const
      }
  }
  
      }
  }
  
-bool wxPostScriptDC::StartDoc (const wxString& message)
+void wxPostScriptDC::DoGetSizeMM(int *width, int *height) const
  {
  {
-    wxCHECK_MSG( m_ok, FALSE, "invalid postscript dc" );
-    
-    if (m_filename == "")
+    wxPaperSize id = m_printData.GetPaperId();
+
+    wxPrintPaperType *paper = wxThePrintPaperDatabase->FindPaperType(id);
+
+    if (!paper) paper = wxThePrintPaperDatabase->FindPaperType(wxPAPER_A4);
+
+    if (paper)
      {
      {
-        m_filename = wxGetTempFileName("ps");
-        wxThePrintSetupData->SetPrinterFile((char *)(const char *)m_filename);
-        m_ok = TRUE;
+        if (width) *width = paper->GetWidth() / 10;
+        if (height) *height = paper->GetHeight() / 10;
      }
      else
      {
      }
      else
      {
-    wxThePrintSetupData->SetPrinterFile((char *)(const char *)m_filename);
+       if (width) *width = 210;
+       if (height) *height = 297;
      }
      }
+}
+
+// Resolution in pixels per logical inch
+wxSize wxPostScriptDC::GetPPI(void) const
+{
+    return wxSize(72, 72);
+}
+
+
+bool wxPostScriptDC::StartDoc( const wxString& message )
+{
+    wxCHECK_MSG( m_ok, FALSE, _T("invalid postscript dc") );
  
  
-    m_pstream = new ofstream (wxThePrintSetupData->GetPrinterFile());
-      
-    if (!m_pstream || !m_pstream->good())
+    if (m_printData.GetFilename() == "")
      {
      {
-    wxMessageBox (_("Cannot open file!"), _("Error"), wxOK);
-    m_ok = FALSE;
-    return FALSE;
+        wxString filename = wxGetTempFileName("ps");
+        m_printData.SetFilename(filename);
      }
      
      }
      
+    m_pstream = fopen( m_printData.GetFilename().fn_str(), "w+" );
+
+    if (!m_pstream)
+    {
+        wxMessageBox( _("Cannot open file for PostScript printing!"), _("Error"), wxOK );
+        m_ok = FALSE;
+        return FALSE;
+    }
+
      m_ok = TRUE;
  
      m_ok = TRUE;
  
+    fprintf( m_pstream, "%%%%BeginProlog\n" );
+    fprintf( m_pstream, wxPostScriptHeaderEllipse );
+    fprintf( m_pstream, wxPostScriptHeaderEllipticArc );
+    fprintf( m_pstream, wxPostScriptHeaderColourImage );
+    fprintf( m_pstream, wxPostScriptHeaderReencodeISO1 );
+    fprintf( m_pstream, wxPostScriptHeaderReencodeISO2 );
+    if (wxPostScriptHeaderSpline)
+        fprintf( m_pstream, wxPostScriptHeaderSpline );
+    fprintf( m_pstream, "%%%%EndProlog\n" );
+
      SetBrush( *wxBLACK_BRUSH );
      SetPen( *wxBLACK_PEN );
      SetBackground( *wxWHITE_BRUSH );
      SetBrush( *wxBLACK_BRUSH );
      SetPen( *wxBLACK_PEN );
      SetBackground( *wxWHITE_BRUSH );
@@ -1258,7 +1424,7 @@ bool wxPostScriptDC::StartDoc (const wxString& message)
  
      // set origin according to paper size
      SetDeviceOrigin( 0,0 );
  
      // set origin according to paper size
      SetDeviceOrigin( 0,0 );
-    
+
      wxPageNumber = 1;
      m_pageNumber = 1;
      m_title = message;
      wxPageNumber = 1;
      m_pageNumber = 1;
      m_title = message;
@@ -1267,58 +1433,55 @@ bool wxPostScriptDC::StartDoc (const wxString& message)
  
  void wxPostScriptDC::EndDoc ()
  {
  
  void wxPostScriptDC::EndDoc ()
  {
-    wxCHECK_RET( m_ok && m_pstream, "invalid postscript dc" );
-    
+    wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
+
      if (m_clipping)
      {
          m_clipping = FALSE;
      if (m_clipping)
      {
          m_clipping = FALSE;
-        *m_pstream << "grestore\n";
+       fprintf( m_pstream, "grestore\n" );
      }
  
      }
  
-    if (m_pstream)
-    {
-        delete m_pstream;
-        m_pstream = (ofstream *) NULL;
-    }
+    fclose( m_pstream );
+    m_pstream = (FILE *) NULL;
  
  
-    char *header_file = wxGetTempFileName("ps");
-    
-    m_pstream = new ofstream( header_file );
+    wxChar *header_file = wxGetTempFileName("ps");
+
+    m_pstream = fopen( wxConvFile.cWX2MB(header_file) , "w+" );
  
  
-    *m_pstream << "%!PS-Adobe-2.0\n";   /* PostScript magic strings */
-    *m_pstream << "%%Title: " << (const char *) m_title << "\n";
-    *m_pstream << "%%Creator: " << wxTheApp->argv[0] << "\n";
-    *m_pstream << "%%CreationDate: " << wxNow() << "\n";
+    fprintf( m_pstream, "%%!PS-Adobe-2.0\n" );                     // PostScript magic strings
+    fprintf( m_pstream, "%%%%Title: %s\n", m_title.mb_str() );
+    fprintf( m_pstream, "%%%%Creator: %s\n", wxTheApp->argv[0] );
+    fprintf( m_pstream, "%%%%CreationDate: %s\n", wxNow().mb_str() );
  
  
-    char userID[256];
+    wxChar userID[256];
      if ( wxGetEmailAddress(userID, sizeof(userID)) )
      {
      if ( wxGetEmailAddress(userID, sizeof(userID)) )
      {
-        *m_pstream << "%%For: " << (char *)userID;
-        char userName[245];
+        fprintf( m_pstream, "%%%%For: %s ", MBSTRINGCAST wxConvCurrent->cWX2MB(userID) );
+        wxChar userName[245];
          if (wxGetUserName(userName, sizeof(userName)))
          if (wxGetUserName(userName, sizeof(userName)))
-            *m_pstream << " (" << (char *)userName << ")";
-        *m_pstream << "\n";
+            fprintf( m_pstream, " (%s)", MBSTRINGCAST wxConvCurrent->cWX2MB(userName) );
+       fprintf( m_pstream, "\n" );
      }
      else if ( wxGetUserName(userID, sizeof(userID)) )
      {
      }
      else if ( wxGetUserName(userID, sizeof(userID)) )
      {
-        *m_pstream << "%%For: " << (char *)userID << "\n";
+        fprintf( m_pstream, "%%%%For: %s\n", MBSTRINGCAST wxConvCurrent->cWX2MB(userID) );;
      }
  
      // THE FOLLOWING HAS BEEN CONTRIBUTED BY Andy Fyfe <andy@hyperparallel.com>
  
      long wx_printer_translate_x, wx_printer_translate_y;
      double wx_printer_scale_x, wx_printer_scale_y;
      }
  
      // THE FOLLOWING HAS BEEN CONTRIBUTED BY Andy Fyfe <andy@hyperparallel.com>
  
      long wx_printer_translate_x, wx_printer_translate_y;
      double wx_printer_scale_x, wx_printer_scale_y;
-    wxThePrintSetupData->GetPrinterTranslation(&wx_printer_translate_x, &wx_printer_translate_y);
-    wxThePrintSetupData->GetPrinterScaling(&wx_printer_scale_x, &wx_printer_scale_y);
  
  
-    if (wxThePrintSetupData->GetPrinterOrientation() == PS_LANDSCAPE)
-    {
-    *m_pstream << "%%Orientation: Landscape\n";
-    }
+    wx_printer_translate_x = m_printData.GetPrinterTranslateX();
+    wx_printer_translate_y = m_printData.GetPrinterTranslateY();
+
+    wx_printer_scale_x = m_printData.GetPrinterScaleX();
+    wx_printer_scale_y = m_printData.GetPrinterScaleY();
+
+    if (m_printData.GetOrientation() == wxLANDSCAPE)
+        fprintf( m_pstream, "%%%%Orientation: Landscape\n" );
      else
      else
-    {
-        *m_pstream << "%%Orientation: Portrait\n";
-    }
+        fprintf( m_pstream, "%%%%Orientation: Portrait\n" );
  
      // Compute the bounding box.  Note that it is in the default user
      // coordinate system, thus we have to convert the values.
  
      // Compute the bounding box.  Note that it is in the default user
      // coordinate system, thus we have to convert the values.
@@ -1328,7 +1491,7 @@ void wxPostScriptDC::EndDoc ()
      long ury = (long) ((YLOG2DEV(m_maxY)+wx_printer_translate_y)*wx_printer_scale_y);
  
      // If we're landscape, our sense of "x" and "y" is reversed.
      long ury = (long) ((YLOG2DEV(m_maxY)+wx_printer_translate_y)*wx_printer_scale_y);
  
      // If we're landscape, our sense of "x" and "y" is reversed.
-    if (wxThePrintSetupData->GetPrinterOrientation() == PS_LANDSCAPE)
+    if (m_printData.GetOrientation() == wxLANDSCAPE)
      {
          long tmp;
          tmp = llx; llx = lly; lly = tmp;
      {
          long tmp;
          tmp = llx; llx = lly; lly = tmp;
@@ -1342,11 +1505,12 @@ void wxPostScriptDC::EndDoc ()
  
      // The Adobe specifications call for integers; we round as to make
      // the bounding larger.
  
      // The Adobe specifications call for integers; we round as to make
      // the bounding larger.
-    *m_pstream << "%%BoundingBox: "
-               << floor((double)llx) << " " << floor((double)lly) << " "
-               << ceil((double)urx)  << " " << ceil((double)ury)  << "\n";
-    *m_pstream << "%%Pages: " << (wxPageNumber - 1) << "\n";
-    *m_pstream << "%%EndComments\n\n";
+    fprintf( m_pstream, 
+            "%%%%BoundingBox: %ld %ld %ld %ld\n",
+           (long)floor((double)llx), (long)floor((double)lly),
+           (long)ceil((double)urx), (long)ceil((double)ury) );
+    fprintf( m_pstream, "%%%%Pages: %d\n", (wxPageNumber - 1) );
+    fprintf( m_pstream, "%%%%EndComments\n\n" );
  
      // To check the correctness of the bounding box, postscript commands
      // to draw a box corresponding to the bounding box are generated below.
  
      // To check the correctness of the bounding box, postscript commands
      // to draw a box corresponding to the bounding box are generated below.
@@ -1354,81 +1518,75 @@ void wxPostScriptDC::EndDoc ()
      // commands are generated within comments.  These lines appear before any
      // adjustment of scale, rotation, or translation, and hence are in the
      // default user coordinates.
      // commands are generated within comments.  These lines appear before any
      // adjustment of scale, rotation, or translation, and hence are in the
      // default user coordinates.
-    *m_pstream << "% newpath\n";
-    *m_pstream << "% " << llx << " " << lly << " moveto\n";
-    *m_pstream << "% " << urx << " " << lly << " lineto\n";
-    *m_pstream << "% " << urx << " " << ury << " lineto\n";
-    *m_pstream << "% " << llx << " " << ury << " lineto closepath stroke\n";
-
-    *m_pstream << "%%BeginProlog\n";
-    *m_pstream << wxPostScriptHeaderEllipse;
-    *m_pstream << wxPostScriptHeaderEllipticArc;
-    *m_pstream << wxPostScriptHeaderColourImage;
-    *m_pstream << wxPostScriptHeaderReencodeISO1;
-    *m_pstream << wxPostScriptHeaderReencodeISO2;
-
-    if (wxPostScriptHeaderSpline)
-        *m_pstream << wxPostScriptHeaderSpline;
-    *m_pstream << "%%EndProlog\n";
+    fprintf( m_pstream, "%% newpath\n" );
+    fprintf( m_pstream, "%% %ld %ld moveto\n", llx, lly );
+    fprintf( m_pstream, "%% %ld %ld lineto\n", urx, lly );
+    fprintf( m_pstream, "%% %ld %ld lineto\n", urx, ury );
+    fprintf( m_pstream, "%% %ld %ld lineto closepath stroke\n", llx, ury );
  
  
-    delete m_pstream;
-    m_pstream = (ofstream *) NULL;
+    fclose( m_pstream );
+    m_pstream = (FILE*) NULL;
  
  
-    char *tmp_file = wxGetTempFileName("ps");
+    wxChar *tmp_file = wxGetTempFileName("ps");
  
      // Paste header Before wx_printer_file
  
      // Paste header Before wx_printer_file
-    wxConcatFiles (header_file, wxThePrintSetupData->GetPrinterFile(), tmp_file);
-    wxRemoveFile (header_file);
-    wxRemoveFile (wxThePrintSetupData->GetPrinterFile());
-    wxRenameFile(tmp_file, wxThePrintSetupData->GetPrinterFile());
+    wxConcatFiles (header_file, m_printData.GetFilename(), tmp_file );
+    wxRemoveFile( header_file );
+    wxRemoveFile( m_printData.GetFilename() );
+    wxRenameFile( tmp_file, m_printData.GetFilename() );
  
  #if defined(__X__) || defined(__WXGTK__)
  
  #if defined(__X__) || defined(__WXGTK__)
-  if (m_ok)
-    {
-      switch (wxThePrintSetupData->GetPrinterMode()) {
-    case PS_PREVIEW:
-    {
-          char *argv[3];
-          argv[0] = wxThePrintSetupData->GetPrintPreviewCommand();
-          argv[1] = wxThePrintSetupData->GetPrinterFile();
-          argv[2] = (char *) NULL;
-      wxExecute (argv, TRUE);
-          wxRemoveFile(wxThePrintSetupData->GetPrinterFile());
-    }
-    break;
-
-    case PS_PRINTER:
+    if (m_ok)
      {
      {
-          char *argv[4];
-          int argc = 0;
-          argv[argc++] = wxThePrintSetupData->GetPrinterCommand();
-
-          // !SM! If we simply assign to argv[1] here, if printer options
-          // are blank, we get an annoying and confusing message from lpr.
-          char * opts = wxThePrintSetupData->GetPrinterOptions();
-          if (opts && *opts)
-              argv[argc++] = opts;
-
-          argv[argc++] = wxThePrintSetupData->GetPrinterFile();
-          argv[argc++] = (char *) NULL;
-      wxExecute (argv, TRUE);
-          wxRemoveFile(wxThePrintSetupData->GetPrinterFile());
-    }
-    break;
+        wxString previewCommand(m_printData.GetPreviewCommand());
+        wxString printerCommand(m_printData.GetPrinterCommand());
+        wxString printerOptions(m_printData.GetPrinterOptions());
+        wxString filename(m_printData.GetFilename());
  
  
-    case PS_FILE:
-      break;
-    }
+        switch (m_printData.GetPrintMode()) 
+       {
+            case wxPRINT_MODE_PREVIEW:
+            {
+                wxChar *argv[3];
+                argv[0] = WXSTRINGCAST previewCommand;
+                argv[1] = WXSTRINGCAST filename;
+                argv[2] = (wxChar*) NULL;
+                wxExecute( argv, TRUE );
+                wxRemoveFile( m_printData.GetFilename() );
+            }
+            break;
+            case wxPRINT_MODE_PRINTER:
+            {
+                wxChar *argv[4];
+                int argc = 0;
+                argv[argc++] = WXSTRINGCAST printerCommand;
+
+                // !SM! If we simply assign to argv[1] here, if printer options
+                // are blank, we get an annoying and confusing message from lpr.
+                wxChar *opts = WXSTRINGCAST printerOptions;
+                if (opts && *opts)
+                    argv[argc++] = opts;
+
+                argv[argc++] = WXSTRINGCAST filename;
+                argv[argc++] = (wxChar *) NULL;
+                wxExecute( argv, TRUE );
+                wxRemoveFile( filename );
+            }
+            break;
+            case wxPRINT_MODE_FILE:
+            case wxPRINT_MODE_NONE:
+            break;
+        }
      }
  #endif
  }
  
      }
  #endif
  }
  
-void wxPostScriptDC::StartPage ()
+void wxPostScriptDC::StartPage()
  {
  {
-    wxCHECK_RET( m_ok && m_pstream, "invalid postscript dc" );
-    
-    *m_pstream << "%%Page: " << (wxPageNumber++) << "\n";
-    
+    wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
+
+    fprintf( m_pstream, "%%%%Page: %d\n", wxPageNumber++ );
+
  //  *m_pstream << "matrix currentmatrix\n";
  
      // Added by Chris Breeze
  //  *m_pstream << "matrix currentmatrix\n";
  
      // Added by Chris Breeze
@@ -1436,49 +1594,67 @@ void wxPostScriptDC::StartPage ()
      // Each page starts with an "initgraphics" which resets the
      // transformation and so we need to reset the origin
      // (and rotate the page for landscape printing)
      // Each page starts with an "initgraphics" which resets the
      // transformation and so we need to reset the origin
      // (and rotate the page for landscape printing)
-    
+
  /*
      m_scaleFactor = 1.0;
      m_logicalOriginX = 0;
      m_logicalOriginY = 0;
  */
  /*
      m_scaleFactor = 1.0;
      m_logicalOriginX = 0;
      m_logicalOriginY = 0;
  */
-       // Output scaling
-       long translate_x, translate_y;
-       double scale_x, scale_y;
-       wxThePrintSetupData->GetPrinterTranslation(&translate_x, &translate_y);
-       wxThePrintSetupData->GetPrinterScaling(&scale_x, &scale_y);
+    // Output scaling
+    long translate_x, translate_y;
+    double scale_x, scale_y;
  
  
-       if (wxThePrintSetupData->GetPrinterOrientation() == PS_LANDSCAPE)
-       {
-               translate_y -= m_maxY;
-               *m_pstream << "90 rotate\n";
-       }
+    translate_x = m_printData.GetPrinterTranslateX();
+    translate_y = m_printData.GetPrinterTranslateY();
+
+    scale_x = m_printData.GetPrinterScaleX();
+    scale_y = m_printData.GetPrinterScaleY();
  
  
-       *m_pstream << scale_x << " " << scale_y << " scale\n";
-       *m_pstream << translate_x << " " << translate_y << " translate\n";
+    if (m_printData.GetOrientation() == wxLANDSCAPE)
+    {
+//        translate_y -= m_maxY;
+//        fprintf( m_pstream, "90 rotate\n" );
+
+        printf( "Hi.\n" );
+       
+       fprintf( m_pstream, "90 rotate llx neg ury nef translate\n" );
+    }
+
+//    fprintf( m_pstream, "%.8f %.8f scale\n", scale_x, scale_y );
+//    fprintf( m_pstream, "%ld %ld translate\n", translate_x, translate_y );
  }
  
  void wxPostScriptDC::EndPage ()
  {
  }
  
  void wxPostScriptDC::EndPage ()
  {
-    wxCHECK_RET( m_ok && m_pstream, "invalid postscript dc" );
-    
-    *m_pstream << "showpage\n";
+    wxCHECK_RET( m_ok && m_pstream, _T("invalid postscript dc") );
+
+    fprintf( m_pstream, "showpage\n" );
  }
  
  }
  
-bool wxPostScriptDC::Blit( long WXUNUSED(xdest), long WXUNUSED(ydest), 
-                           long WXUNUSED(fwidth), long WXUNUSED(fheight),
-                           wxDC *WXUNUSED(source), 
-               long WXUNUSED(xsrc), long WXUNUSED(ysrc), 
-               int WXUNUSED(rop), bool WXUNUSED(useMask) )
+bool wxPostScriptDC::DoBlit( long xdest, long ydest,
+                           long fwidth, long fheight,
+                           wxDC *source,
+                           long xsrc, long ysrc,
+                           int rop, bool WXUNUSED(useMask) )
  {
  {
-    wxCHECK_MSG( m_ok && m_pstream, FALSE, "invalid postscript dc" );
-    
-    wxFAIL_MSG( "wxPostScriptDC::Blit no yet implemented." );
-    
+    wxCHECK_MSG( m_ok && m_pstream, FALSE, _T("invalid postscript dc") );
+
+    wxCHECK_MSG( source, FALSE, _T("invalid source dc") );
+
+    /* blit into a bitmap */
+    wxBitmap bitmap( (int)fwidth, (int)fheight );
+    wxMemoryDC memDC;
+    memDC.SelectObject(bitmap);
+    memDC.Blit(0, 0, fwidth, fheight, source, xsrc, ysrc, rop); /* TODO: Blit transparently? */
+    memDC.SelectObject(wxNullBitmap);
+
+    /* draw bitmap. scaling and positioning is done there */
+    DrawBitmap( bitmap, xdest, ydest );
+
      return TRUE;
  }
  
      return TRUE;
  }
  
-long wxPostScriptDC::GetCharHeight ()
+long wxPostScriptDC::GetCharHeight() const
  {
      if (m_font.Ok())
          return  m_font.GetPointSize();
  {
      if (m_font.Ok())
          return  m_font.GetPointSize();
@@ -1486,71 +1662,72 @@ long wxPostScriptDC::GetCharHeight ()
          return 12;
  }
  
          return 12;
  }
  
-void wxPostScriptDC::GetTextExtent (const wxString& string, long *x, long *y,
-           long *descent, long *externalLeading, wxFont *theFont,
-                    bool WXUNUSED(use16))
+void wxPostScriptDC::GetTextExtent( const wxString& string, long *x, long *y,
+                                    long *descent, long *externalLeading, wxFont *theFont ) const
  {
      wxFont *fontToUse = theFont;
  {
      wxFont *fontToUse = theFont;
-  
+
      if (!fontToUse) fontToUse = (wxFont*) &m_font;
  
      if (!fontToUse) fontToUse = (wxFont*) &m_font;
  
-    wxCHECK_RET( fontToUse, "GetTextExtent: no font defined" );
-    wxCHECK_RET( x, "GetTextExtent: x == NULL" );
-    wxCHECK_RET( y, "GetTextExtent: y == NULL" );
+    wxCHECK_RET( fontToUse, _T("GetTextExtent: no font defined") );
+    wxCHECK_RET( x, _T("GetTextExtent: x == NULL") );
+    wxCHECK_RET( y, _T("GetTextExtent: y == NULL") );
+
+    const wxWX2MBbuf strbuf = string.mb_str();
  
  #if !USE_AFM_FOR_POSTSCRIPT
      /* Provide a VERY rough estimate (avoid using it).
       * Produces accurate results for mono-spaced font
       * such as Courier (aka wxMODERN) */
  
  #if !USE_AFM_FOR_POSTSCRIPT
      /* Provide a VERY rough estimate (avoid using it).
       * Produces accurate results for mono-spaced font
       * such as Courier (aka wxMODERN) */
-     
+
      int height = 12;
      if (fontToUse)
      {
      int height = 12;
      if (fontToUse)
      {
-       height = fontToUse->GetPointSize();
+        height = fontToUse->GetPointSize();
      }
      }
-    *x = strlen (string) * height * 72 / 120;
-    *y = (long) (height * 1.32);       /* allow for descender */
+    *x = strlen (strbuf) * height * 72 / 120;
+    *y = (long) (height * 1.32);    /* allow for descender */
      if (descent) *descent = 0;
      if (externalLeading) *externalLeading = 0;
  #else
  
      if (descent) *descent = 0;
      if (externalLeading) *externalLeading = 0;
  #else
  
-   /* method for calculating string widths in postscript:
-   /  read in the AFM (adobe font metrics) file for the
-   /  actual font, parse it and extract the character widths
-   /  and also the descender. this may be improved, but for now
-   /  it works well. the AFM file is only read in if the
-   /  font is changed. this may be chached in the future.
-   /  calls to GetTextExtent with the font unchanged are rather
-   /  efficient!!!
-   /
-   /  for each font and style used there is an AFM file necessary.
-   /  currently i have only files for the roman font family.
-   /  I try to get files for the other ones!
-   /
-   /  CAVE: the size of the string is currently always calculated
-   /        in 'points' (1/72 of an inch). this should later on be
-   /        changed to depend on the mapping mode.
-   /  CAVE: the path to the AFM files must be set before calling this
-   /        function. this is usually done by a call like the following:
-   /        wxSetAFMPath("d:\\wxw161\\afm\\");
-   /
-   /  example:
-   /
-   /    wxPostScriptDC dc(NULL, TRUE);
-   /    if (dc.Ok()){
-   /      wxSetAFMPath("d:\\wxw161\\afm\\");
-   /      dc.StartDoc("Test");
-   /      dc.StartPage();
-   /      long w,h;
-   /      dc.SetFont(new wxFont(10, wxROMAN, wxNORMAL, wxNORMAL));
-   /      dc.GetTextExtent("Hallo",&w,&h);
-   /      dc.EndPage();
-   /      dc.EndDoc();
-   /    }
-   /
-   /  by steve (stefan.hammes@urz.uni-heidelberg.de)
-   /  created: 10.09.94
-   /  updated: 14.05.95 */
+    /* method for calculating string widths in postscript:
+    /  read in the AFM (adobe font metrics) file for the
+    /  actual font, parse it and extract the character widths
+    /  and also the descender. this may be improved, but for now
+    /  it works well. the AFM file is only read in if the
+    /  font is changed. this may be chached in the future.
+    /  calls to GetTextExtent with the font unchanged are rather
+    /  efficient!!!
+    /
+    /  for each font and style used there is an AFM file necessary.
+    /  currently i have only files for the roman font family.
+    /  I try to get files for the other ones!
+    /
+    /  CAVE: the size of the string is currently always calculated
+    /        in 'points' (1/72 of an inch). this should later on be
+    /        changed to depend on the mapping mode.
+    /  CAVE: the path to the AFM files must be set before calling this
+    /        function. this is usually done by a call like the following:
+    /        wxSetAFMPath("d:\\wxw161\\afm\\");
+    /
+    /  example:
+    /
+    /    wxPostScriptDC dc(NULL, TRUE);
+    /    if (dc.Ok()){
+    /      wxSetAFMPath("d:\\wxw161\\afm\\");
+    /      dc.StartDoc("Test");
+    /      dc.StartPage();
+    /      long w,h;
+    /      dc.SetFont(new wxFont(10, wxROMAN, wxNORMAL, wxNORMAL));
+    /      dc.GetTextExtent("Hallo",&w,&h);
+    /      dc.EndPage();
+    /      dc.EndDoc();
+    /    }
+    /
+    /  by steve (stefan.hammes@urz.uni-heidelberg.de)
+    /  created: 10.09.94
+    /  updated: 14.05.95 */
  
      /* these static vars are for storing the state between calls */
      static int lastFamily= INT_MIN;
  
      /* these static vars are for storing the state between calls */
      static int lastFamily= INT_MIN;
@@ -1578,66 +1755,89 @@ void wxPostScriptDC::GetTextExtent (const wxString& string, long *x, long *y,
          char *name = (char*) NULL;
  
          switch (Family)
          char *name = (char*) NULL;
  
          switch (Family)
-       {
-           case wxMODERN:
-           {
-                    if ((Style == wxITALIC) && (Weight == wxBOLD)) name = "CourBoO";
-               else if ((Style != wxITALIC) && (Weight == wxBOLD)) name = "CourBo";
-               else if ((Style == wxITALIC) && (Weight != wxBOLD)) name = "Cour0";
-               else name = "Cour";
-           }
-           break;
-           case wxROMAN:
-           {
-                    if ((Style == wxITALIC) && (Weight == wxBOLD)) name = "TimesBoO";
-               else if ((Style != wxITALIC) && (Weight == wxBOLD)) name = "TimesBo";
-               else if ((Style == wxITALIC) && (Weight != wxBOLD)) name = "TimesO";
-               else if name = "TimesRo";  /* no typo */
-           }
-           break;
-           default:
-           {
-                    if ((Style == wxITALIC) && (Weight == wxBOLD)) name = "HelvBoO";
-               else if ((Style != wxITALIC) && (Weight == wxBOLD)) name = "HelvBo";
-               else if ((Style == wxITALIC) && (Weight != wxBOLD)) name = "Helv0";
-               else if ((Style != wxITALIC) && (Weight != wxBOLD)) name = "Helv";
-           }
-           break;
-       }
+        {
+            case wxMODERN:
+                {
+                    if ((Style == wxITALIC) && (Weight == wxBOLD)) name = "CourBoO";
+                    else if ((Style != wxITALIC) && (Weight == wxBOLD)) name = "CourBo";
+                    else if ((Style == wxITALIC) && (Weight != wxBOLD)) name = "Cour0";
+                    else name = "Cour";
+                }
+                break;
+            case wxROMAN:
+                {
+                    if ((Style == wxITALIC) && (Weight == wxBOLD)) name = "TimesBoO";
+                    else if ((Style != wxITALIC) && (Weight == wxBOLD)) name = "TimesBo";
+                    else if ((Style == wxITALIC) && (Weight != wxBOLD)) name = "TimesO";
+                    else if name = "TimesRo";  /* no typo */
+                }
+                break;
+            default:
+                {
+                    if ((Style == wxITALIC) && (Weight == wxBOLD)) name = "HelvBoO";
+                    else if ((Style != wxITALIC) && (Weight == wxBOLD)) name = "HelvBo";
+                    else if ((Style == wxITALIC) && (Weight != wxBOLD)) name = "Helv0";
+                    else name = "Helv";
+                }
+                break;
+        }
  
          /* get the directory of the AFM files */
          char afmName[256];
          afmName[0] = 0;
  
          /* get the directory of the AFM files */
          char afmName[256];
          afmName[0] = 0;
-        if (wxGetAFMPath()) strcpy( afmName, wxGetAFMPath() );
-
-    /* 2. open and process the file
-    /  a short explanation of the AFM format:
-    /  we have for each character a line, which gives its size
-    /  e.g.:
-    / 
-    /    C 63 ; WX 444 ; N question ; B 49 -14 395 676 ;
-    / 
-    /  that means, we have a character with ascii code 63, and width
-    /  (444/1000 * fontSize) points.
-    /  the other data is ignored for now!
-    / 
-    /  when the font has changed, we read in the right AFM file and store the
-    /  character widths in an array, which is processed below (see point 3.). */
+       
+       if (!m_printData.GetFontMetricPath().IsEmpty())
+       {
+           strcpy( afmName, m_printData.GetFontMetricPath().fn_str() )
+       }
+
+        /* 2. open and process the file
+           /  a short explanation of the AFM format:
+           /  we have for each character a line, which gives its size
+           /  e.g.:
+           /
+           /    C 63 ; WX 444 ; N question ; B 49 -14 395 676 ;
+           /
+           /  that means, we have a character with ascii code 63, and width
+           /  (444/1000 * fontSize) points.
+           /  the other data is ignored for now!
+           /
+           /  when the font has changed, we read in the right AFM file and store the
+           /  character widths in an array, which is processed below (see point 3.). */
  
          /* new elements JC Sun Aug 25 23:21:44 MET DST 1996 */
  
          strcat(afmName,name);
          strcat(afmName,".afm");
          FILE *afmFile = fopen(afmName,"r");
  
          /* new elements JC Sun Aug 25 23:21:44 MET DST 1996 */
  
          strcat(afmName,name);
          strcat(afmName,".afm");
          FILE *afmFile = fopen(afmName,"r");
-        if ( afmFile==NULL )
+       
+#ifdef __UNIX__
+       if (afmFile==NULL)
+       {
+           strcpy( afmName, "/usr/local/share/wx/gs_afm/" );
+            strcat(afmName,name);
+            strcat(afmName,".afm");
+            FILE *afmFile = fopen(afmName,"r");
+       }
+       
+       if (afmFile==NULL)
+       {
+           strcpy( afmName, "/usr/share/wx/gs_afm/" );
+            strcat(afmName,name);
+            strcat(afmName,".afm");
+            FILE *afmFile = fopen(afmName,"r");
+       }
+#endif
+       
+        if (afmFile==NULL)
          {
              wxLogDebug( "GetTextExtent: can't open AFM file '%s'\n", afmName );
              wxLogDebug( "               using approximate values\n");
              for (int i=0; i<256; i++) lastWidths[i] = 500; /* an approximate value */
              lastDescender = -150; /* dito. */
          }
          {
              wxLogDebug( "GetTextExtent: can't open AFM file '%s'\n", afmName );
              wxLogDebug( "               using approximate values\n");
              for (int i=0; i<256; i++) lastWidths[i] = 500; /* an approximate value */
              lastDescender = -150; /* dito. */
          }
-       else
-       {
+        else
+        {
              /* init the widths array */
              for(int i=0; i<256; i++) lastWidths[i] = INT_MIN;
              /* some variables for holding parts of a line */
              /* init the widths array */
              for(int i=0; i<256; i++) lastWidths[i] = INT_MIN;
              /* some variables for holding parts of a line */
@@ -1647,67 +1847,67 @@ void wxPostScriptDC::GetTextExtent (const wxString& string, long *x, long *y,
              int ascii,cWidth;
              /* read in the file and parse it */
              while(fgets(line,sizeof(line),afmFile)!=NULL)
              int ascii,cWidth;
              /* read in the file and parse it */
              while(fgets(line,sizeof(line),afmFile)!=NULL)
-           {
+            {
                  /* A.) check for descender definition */
                  if (strncmp(line,"Descender",9)==0)
                  /* A.) check for descender definition */
                  if (strncmp(line,"Descender",9)==0)
-               {
+                {
                      if ((sscanf(line,"%s%d",descString,&lastDescender)!=2) ||
                      if ((sscanf(line,"%s%d",descString,&lastDescender)!=2) ||
-                       (strcmp(descString,"Descender")!=0)) 
-                   {
-                       wxLogDebug( "AFM-file '%s': line '%s' has error (bad descender)\n", afmName,line );
+                            (strcmp(descString,"Descender")!=0))
+                    {
+                        wxLogDebug( "AFM-file '%s': line '%s' has error (bad descender)\n", afmName,line );
                      }
                  }
                  /* JC 1.) check for UnderlinePosition */
                  else if(strncmp(line,"UnderlinePosition",17)==0)
                      }
                  }
                  /* JC 1.) check for UnderlinePosition */
                  else if(strncmp(line,"UnderlinePosition",17)==0)
-               {
+                {
                      if ((sscanf(line,"%s%lf",upString,&UnderlinePosition)!=2) ||
                      if ((sscanf(line,"%s%lf",upString,&UnderlinePosition)!=2) ||
-                       (strcmp(upString,"UnderlinePosition")!=0)) 
-                   {
-                       wxLogDebug( "AFM-file '%s': line '%s' has error (bad UnderlinePosition)\n", afmName, line );
+                            (strcmp(upString,"UnderlinePosition")!=0))
+                    {
+                        wxLogDebug( "AFM-file '%s': line '%s' has error (bad UnderlinePosition)\n", afmName, line );
                      }
                  }
                      }
                  }
-               /* JC 2.) check for UnderlineThickness */
+                /* JC 2.) check for UnderlineThickness */
                  else if(strncmp(line,"UnderlineThickness",18)==0)
                  else if(strncmp(line,"UnderlineThickness",18)==0)
-               {
+                {
                      if ((sscanf(line,"%s%lf",utString,&UnderlineThickness)!=2) ||
                      if ((sscanf(line,"%s%lf",utString,&UnderlineThickness)!=2) ||
-                       (strcmp(utString,"UnderlineThickness")!=0)) 
-                   {
-                       wxLogDebug( "AFM-file '%s': line '%s' has error (bad UnderlineThickness)\n", afmName, line );
+                            (strcmp(utString,"UnderlineThickness")!=0))
+                    {
+                        wxLogDebug( "AFM-file '%s': line '%s' has error (bad UnderlineThickness)\n", afmName, line );
                      }
                  }
                      }
                  }
-               /* JC 3.) check for EncodingScheme */
+                /* JC 3.) check for EncodingScheme */
                  else if(strncmp(line,"EncodingScheme",14)==0)
                  else if(strncmp(line,"EncodingScheme",14)==0)
-               {
+                {
                      if ((sscanf(line,"%s%s",utString,encString)!=2) ||
                      if ((sscanf(line,"%s%s",utString,encString)!=2) ||
-                       (strcmp(utString,"EncodingScheme")!=0)) 
-                   {
-                       wxLogDebug("AFM-file '%s': line '%s' has error (bad EncodingScheme)\n", afmName, line );
+                            (strcmp(utString,"EncodingScheme")!=0))
+                    {
+                        wxLogDebug("AFM-file '%s': line '%s' has error (bad EncodingScheme)\n", afmName, line );
                      }
                      else if (strncmp(encString, "AdobeStandardEncoding", 21))
                      {
                      }
                      else if (strncmp(encString, "AdobeStandardEncoding", 21))
                      {
-                       wxLogDebug( "AFM-file '%s': line '%s' has error (unsupported EncodingScheme %s)\n",
-                                   afmName,line, encString);
+                        wxLogDebug( "AFM-file '%s': line '%s' has error (unsupported EncodingScheme %s)\n",
+                                afmName,line, encString);
                      }
                  }
                  /* B.) check for char-width */
                  else if(strncmp(line,"C ",2)==0)
                      }
                  }
                  /* B.) check for char-width */
                  else if(strncmp(line,"C ",2)==0)
-               {
+                {
                      if (sscanf(line,"%s%d%s%s%d",cString,&ascii,semiString,WXString,&cWidth)!=5)
                      if (sscanf(line,"%s%d%s%s%d",cString,&ascii,semiString,WXString,&cWidth)!=5)
-                   {
+                    {
                          wxLogDebug("AFM-file '%s': line '%s' has an error (bad character width)\n",afmName,line);
                      }
                      if(strcmp(cString,"C")!=0 || strcmp(semiString,";")!=0 || strcmp(WXString,"WX")!=0)
                          wxLogDebug("AFM-file '%s': line '%s' has an error (bad character width)\n",afmName,line);
                      }
                      if(strcmp(cString,"C")!=0 || strcmp(semiString,";")!=0 || strcmp(WXString,"WX")!=0)
-                   {
+                    {
                          wxLogDebug("AFM-file '%s': line '%s' has a format error\n",afmName,line);
                      }
                      /* printf("            char '%c'=%d has width '%d'\n",ascii,ascii,cWidth); */
                      if (ascii>=0 && ascii<256)
                          wxLogDebug("AFM-file '%s': line '%s' has a format error\n",afmName,line);
                      }
                      /* printf("            char '%c'=%d has width '%d'\n",ascii,ascii,cWidth); */
                      if (ascii>=0 && ascii<256)
-                   {
+                    {
                          lastWidths[ascii] = cWidth; /* store width */
                      }
                          lastWidths[ascii] = cWidth; /* store width */
                      }
-                   else
-                   {
-                       /* MATTHEW: this happens a lot; don't print an error */
+                    else
+                    {
+                        /* MATTHEW: this happens a lot; don't print an error */
                          /* wxLogDebug("AFM-file '%s': ASCII value %d out of range\n",afmName,ascii); */
                      }
                  }
                          /* wxLogDebug("AFM-file '%s': ASCII value %d out of range\n",afmName,ascii); */
                      }
                  }
@@ -1716,9 +1916,9 @@ void wxPostScriptDC::GetTextExtent (const wxString& string, long *x, long *y,
              fclose(afmFile);
          }
          /* hack to compute correct values for german 'Umlaute'
              fclose(afmFile);
          }
          /* hack to compute correct values for german 'Umlaute'
-        /  the correct way would be to map the character names
-        /  like 'adieresis' to corresp. positions of ISOEnc and read
-        /  these values from AFM files, too. Maybe later ... */
+           /  the correct way would be to map the character names
+           /  like 'adieresis' to corresp. positions of ISOEnc and read
+           /  these values from AFM files, too. Maybe later ... */
          lastWidths[196] = lastWidths['A'];  // Ä
          lastWidths[228] = lastWidths['a'];  // ä
          lastWidths[214] = lastWidths['O'];  // Ö
          lastWidths[196] = lastWidths['A'];  // Ä
          lastWidths[228] = lastWidths['a'];  // ä
          lastWidths[214] = lastWidths['O'];  // Ö
@@ -1733,25 +1933,25 @@ void wxPostScriptDC::GetTextExtent (const wxString& string, long *x, long *y,
      m_underlineThickness = m_underlineThickness * fontToUse->GetPointSize() / 1000.0f * m_scaleFactor;
  
      /* 3. now the font metrics are read in, calc size this
      m_underlineThickness = m_underlineThickness * fontToUse->GetPointSize() / 1000.0f * m_scaleFactor;
  
      /* 3. now the font metrics are read in, calc size this
-    /  is done by adding the widths of the characters in the
-    /  string. they are given in 1/1000 of the size! */
+       /  is done by adding the widths of the characters in the
+       /  string. they are given in 1/1000 of the size! */
  
      long widthSum=0;
      long height=Size; /* by default */
      unsigned char *p;
  
      long widthSum=0;
      long height=Size; /* by default */
      unsigned char *p;
-    for(p=(unsigned char *)(const char *)string; *p; p++)
+    for(p=(unsigned char *)strbuf; *p; p++)
      {
          if(lastWidths[*p]== INT_MIN)
      {
          if(lastWidths[*p]== INT_MIN)
-       {
+        {
              wxLogDebug("GetTextExtent: undefined width for character '%c' (%d)\n", *p,*p);
              widthSum += (long)(lastWidths[' ']/1000.0F * Size); /* assume space */
          }
              wxLogDebug("GetTextExtent: undefined width for character '%c' (%d)\n", *p,*p);
              widthSum += (long)(lastWidths[' ']/1000.0F * Size); /* assume space */
          }
-       else
-       {
+        else
+        {
              widthSum += (long)((lastWidths[*p]/1000.0F)*Size);
          }
      }
              widthSum += (long)((lastWidths[*p]/1000.0F)*Size);
          }
      }
-    
+
      /* add descender to height (it is usually a negative value) */
      if (lastDescender!=INT_MIN)
      {
      /* add descender to height (it is usually a negative value) */
      if (lastDescender!=INT_MIN)
      {
@@ -1766,12 +1966,12 @@ void wxPostScriptDC::GetTextExtent (const wxString& string, long *x, long *y,
      if (descent)
      {
          if(lastDescender!=INT_MIN)
      if (descent)
      {
          if(lastDescender!=INT_MIN)
-       {
+        {
              *descent = (long)(((-lastDescender)/1000.0F) * Size); /* MATTHEW: forgot scale */
          }
              *descent = (long)(((-lastDescender)/1000.0F) * Size); /* MATTHEW: forgot scale */
          }
-       else
-       {
-           *descent = 0;
+        else
+        {
+            *descent = 0;
          }
      }
  
          }
      }
  
@@ -1781,28 +1981,6 @@ void wxPostScriptDC::GetTextExtent (const wxString& string, long *x, long *y,
  #endif
  }
  
  #endif
  }
  
-void wxPostScriptDC::GetSizeMM(long *width, long *height) const
-{
-    const char *paperType = wxThePrintSetupData->GetPaperName();
-  
-    if (!paperType) paperType = _("A4 210 x 297 mm");
-
-    wxPrintPaperType *paper = wxThePrintPaperDatabase->FindPaperType(paperType);
-    
-    if (!paper) paper = wxThePrintPaperDatabase->FindPaperType(_("A4 210 x 297 mm"));
-    
-    if (paper)
-    {
-        if (width) *width = paper->widthMM;
-        if (height) *height = paper->heightMM;
-    }
-    else
-    {
-       if (width) *width = 210;
-       if (height) *height = 297;
-    }
-}
-
  // Determine the Default Postscript Previewer
  // available on the platform
  #if defined(__SUN__) && defined(__XVIEW__)
  // Determine the Default Postscript Previewer
  // available on the platform
  #if defined(__SUN__) && defined(__XVIEW__)
@@ -1825,10 +2003,8 @@ void wxPostScriptDC::GetSizeMM(long *width, long *height) const
  wxPrintSetupData *wxThePrintSetupData = (wxPrintSetupData *) NULL;
  
  #if !USE_SHARED_LIBRARY
  wxPrintSetupData *wxThePrintSetupData = (wxPrintSetupData *) NULL;
  
  #if !USE_SHARED_LIBRARY
-IMPLEMENT_DYNAMIC_CLASS(wxPostScriptModule, wxModule)
  IMPLEMENT_DYNAMIC_CLASS(wxPostScriptDC, wxDC)
  IMPLEMENT_DYNAMIC_CLASS(wxPrintSetupData, wxObject)
  IMPLEMENT_DYNAMIC_CLASS(wxPostScriptDC, wxDC)
  IMPLEMENT_DYNAMIC_CLASS(wxPrintSetupData, wxObject)
-IMPLEMENT_DYNAMIC_CLASS(wxPrintPaperType, wxObject)
  #endif
  
  // Redundant now I think
  #endif
  
  // Redundant now I think
@@ -1858,7 +2034,7 @@ wxPostScriptPrintDialog::wxPostScriptPrintDialog (wxWindow *parent, const wxStri
     print_modes[2] = _("Preview Only");
  
  
     print_modes[2] = _("Preview Only");
  
  
-  
+
     wxButton *okBut = new wxButton (this, wxID_OK, _("OK"), wxPoint(5, 5));
     (void) new wxButton (this, wxID_CANCEL, _("Cancel"), wxPoint(40, 5));
     okBut->SetDefault();
     wxButton *okBut = new wxButton (this, wxID_OK, _("OK"), wxPoint(5, 5));
     (void) new wxButton (this, wxID_CANCEL, _("Cancel"), wxPoint(40, 5));
     okBut->SetDefault();
@@ -1884,18 +2060,18 @@ wxPostScriptPrintDialog::wxPostScriptPrintDialog (wxWindow *parent, const wxStri
     radio0->SetSelection((int)wxThePrintSetupData->GetPrinterOrientation() - 1);
  
    // @@@ Configuration hook
     radio0->SetSelection((int)wxThePrintSetupData->GetPrinterOrientation() - 1);
  
    // @@@ Configuration hook
-   if (wxThePrintSetupData->GetPrintPreviewCommand() == NULL)
+   if ( !wxThePrintSetupData->GetPrintPreviewCommand() )
        wxThePrintSetupData->SetPrintPreviewCommand(PS_VIEWER_PROG);
  
        wxThePrintSetupData->SetPrintPreviewCommand(PS_VIEWER_PROG);
  
-   wxGetResource ("wxWindows", "PSView", &wxThePrintSetupData->previewCommand);
+   //   wxGetResource ("wxWindows", "PSView", &wxThePrintSetupData->m_previewCommand);
  
     features = (wxThePrintSetupData->GetPrintPreviewCommand() &&
  
     features = (wxThePrintSetupData->GetPrintPreviewCommand() &&
-               *wxThePrintSetupData->GetPrintPreviewCommand()) ? 3 : 2; 
-  
+               *wxThePrintSetupData->GetPrintPreviewCommand()) ? 3 : 2;
+
     wxRadioBox *radio1 = new wxRadioBox(this, wxID_PRINTER_MODES, _("PostScript:"),
                                         wxPoint(150, yPos),
                                         wxSize(-1,-1), features,
     wxRadioBox *radio1 = new wxRadioBox(this, wxID_PRINTER_MODES, _("PostScript:"),
                                         wxPoint(150, yPos),
                                         wxSize(-1,-1), features,
-                                       print_modes, features, wxRA_SPECIFY_ROWS); 
+                                       print_modes, features, wxRA_SPECIFY_ROWS);
  
  #ifdef __WXMSW__
     radio1->Enable(0, FALSE);
  
  #ifdef __WXMSW__
     radio1->Enable(0, FALSE);
@@ -1926,7 +2102,7 @@ wxPostScriptPrintDialog::wxPostScriptPrintDialog (wxWindow *parent, const wxStri
     (void) new wxStaticText(this, -1, _("Y Translation"), wxPoint(220, yPos));
     sprintf (buf, "%.2ld", wx_printer_translate_y);
     /* wxTextCtrl *text4 = */ (void) new wxTextCtrl(this, wxID_PRINTER_Y_TRANS, buf, wxPoint(320, yPos), wxSize(100, -1));
     (void) new wxStaticText(this, -1, _("Y Translation"), wxPoint(220, yPos));
     sprintf (buf, "%.2ld", wx_printer_translate_y);
     /* wxTextCtrl *text4 = */ (void) new wxTextCtrl(this, wxID_PRINTER_Y_TRANS, buf, wxPoint(320, yPos), wxSize(100, -1));
-  
+
     Fit ();
  
     delete[] orientation;
     Fit ();
  
     delete[] orientation;
@@ -1948,17 +2124,17 @@ int wxPostScriptPrintDialog::ShowModal ()
        wxRadioBox *radio0 = (wxRadioBox *)FindWindow(wxID_PRINTER_ORIENTATION);
        wxRadioBox *radio1 = (wxRadioBox *)FindWindow(wxID_PRINTER_MODES);
  
        wxRadioBox *radio0 = (wxRadioBox *)FindWindow(wxID_PRINTER_ORIENTATION);
        wxRadioBox *radio1 = (wxRadioBox *)FindWindow(wxID_PRINTER_MODES);
  
-      StringToDouble (WXSTRINGCAST text1->GetValue (), &wxThePrintSetupData->printerScaleX);
-      StringToDouble (WXSTRINGCAST text2->GetValue (), &wxThePrintSetupData->printerScaleY);
-      StringToLong (WXSTRINGCAST text3->GetValue (), &wxThePrintSetupData->printerTranslateX);
-      StringToLong (WXSTRINGCAST text4->GetValue (), &wxThePrintSetupData->printerTranslateY);
+      StringToDouble (WXSTRINGCAST text1->GetValue (), &wxThePrintSetupData->m_printerScaleX);
+      StringToDouble (WXSTRINGCAST text2->GetValue (), &wxThePrintSetupData->m_printerScaleY);
+      StringToLong (WXSTRINGCAST text3->GetValue (), &wxThePrintSetupData->m_printerTranslateX);
+      StringToLong (WXSTRINGCAST text4->GetValue (), &wxThePrintSetupData->m_printerTranslateY);
  
  #ifdef __X__
        //      wxThePrintSetupData->SetPrinterOptions(WXSTRINGCAST text0->GetValue ());
        //      wxThePrintSetupData->SetPrinterCommand(WXSTRINGCAST text_prt->GetValue ());
  #endif
  
  
  #ifdef __X__
        //      wxThePrintSetupData->SetPrinterOptions(WXSTRINGCAST text0->GetValue ());
        //      wxThePrintSetupData->SetPrinterCommand(WXSTRINGCAST text_prt->GetValue ());
  #endif
  
-      wxThePrintSetupData->SetPrinterOrientation((radio0->GetSelection() == 1 ? PS_LANDSCAPE : PS_PORTRAIT));
+      wxThePrintSetupData->SetPrinterOrientation((radio0->GetSelection() == 1 ? wxLANDSCAPE : wxPORTRAIT));
  
        // C++ wants this
        switch ( radio1->GetSelection() ) {
  
        // C++ wants this
        switch ( radio1->GetSelection() ) {
@@ -1975,22 +2151,22 @@ int wxPostScriptPrintDialog::ShowModal ()
  
  // PostScript printer settings
  // RETAINED FOR BACKWARD COMPATIBILITY
  
  // PostScript printer settings
  // RETAINED FOR BACKWARD COMPATIBILITY
-void wxSetPrinterCommand(const char *cmd)
+void wxSetPrinterCommand(const wxString& cmd)
  {
    wxThePrintSetupData->SetPrinterCommand(cmd);
  }
  
  {
    wxThePrintSetupData->SetPrinterCommand(cmd);
  }
  
-void wxSetPrintPreviewCommand(const char *cmd)
+void wxSetPrintPreviewCommand(const wxString& cmd)
  {
    wxThePrintSetupData->SetPrintPreviewCommand(cmd);
  }
  
  {
    wxThePrintSetupData->SetPrintPreviewCommand(cmd);
  }
  
-void wxSetPrinterOptions(const char *flags)
+void wxSetPrinterOptions(const wxString& flags)
  {
    wxThePrintSetupData->SetPrinterOptions(flags);
  }
  
  {
    wxThePrintSetupData->SetPrinterOptions(flags);
  }
  
-void wxSetPrinterFile(const char *f)
+void wxSetPrinterFile(const wxString& f)
  {
    wxThePrintSetupData->SetPrinterFile(f);
  }
  {
    wxThePrintSetupData->SetPrinterFile(f);
  }
@@ -2016,28 +2192,28 @@ void wxSetPrinterMode(int mode)
    wxThePrintSetupData->SetPrinterMode(mode);
  }
  
    wxThePrintSetupData->SetPrinterMode(mode);
  }
  
-void wxSetAFMPath(const char *f)
+void wxSetAFMPath(const wxString& f)
  {
    wxThePrintSetupData->SetAFMPath(f);
  }
  
  // Get current values
  {
    wxThePrintSetupData->SetAFMPath(f);
  }
  
  // Get current values
-char *wxGetPrinterCommand()
+wxString wxGetPrinterCommand()
  {
    return wxThePrintSetupData->GetPrinterCommand();
  }
  
  {
    return wxThePrintSetupData->GetPrinterCommand();
  }
  
-char *wxGetPrintPreviewCommand()
+wxString wxGetPrintPreviewCommand()
  {
    return wxThePrintSetupData->GetPrintPreviewCommand();
  }
  
  {
    return wxThePrintSetupData->GetPrintPreviewCommand();
  }
  
-char *wxGetPrinterOptions()
+wxString wxGetPrinterOptions()
  {
    return wxThePrintSetupData->GetPrinterOptions();
  }
  
  {
    return wxThePrintSetupData->GetPrinterOptions();
  }
  
-char *wxGetPrinterFile()
+wxString wxGetPrinterFile()
  {
    return wxThePrintSetupData->GetPrinterFile();
  }
  {
    return wxThePrintSetupData->GetPrinterFile();
  }
@@ -2062,7 +2238,7 @@ int wxGetPrinterMode()
    return wxThePrintSetupData->GetPrinterMode();
  }
  
    return wxThePrintSetupData->GetPrinterMode();
  }
  
-char *wxGetAFMPath()
+wxString wxGetAFMPath()
  {
    return wxThePrintSetupData->GetAFMPath();
  }
  {
    return wxThePrintSetupData->GetAFMPath();
  }
@@ -2073,200 +2249,17 @@ char *wxGetAFMPath()
  
  wxPrintSetupData::wxPrintSetupData()
  {
  
  wxPrintSetupData::wxPrintSetupData()
  {
-  printerCommand = (char *) NULL;
-  previewCommand = (char *) NULL;
-  printerFlags = (char *) NULL;
-  printerOrient = PS_PORTRAIT;
-  printerScaleX = (double)1.0;
-  printerScaleY = (double)1.0;
-  printerTranslateX = 0;
-  printerTranslateY = 0;
-  // 1 = Preview, 2 = print to file, 3 = send to printer
-  printerMode = 3;
-  afmPath = (char *) NULL;
-  paperName = (char *) NULL;
-  printColour = TRUE;
-  printerFile = (char *) NULL;
+  m_printerOrient = wxPORTRAIT;
+  m_printerScaleX = (double)1.0;
+  m_printerScaleY = (double)1.0;
+  m_printerTranslateX = 0;
+  m_printerTranslateY = 0;
+  m_printerMode = wxPRINT_MODE_FILE;
+  m_printColour = TRUE;
  }
  
  wxPrintSetupData::~wxPrintSetupData()
  {
  }
  
  wxPrintSetupData::~wxPrintSetupData()
  {
-  if (printerCommand)
-    delete[] printerCommand;
-  if (previewCommand)
-    delete[] previewCommand;
-  if (printerFlags)
-    delete[] printerFlags;
-  if (afmPath)
-    delete[] afmPath;
-  if (paperName)
-    delete[] paperName;
-  if (printerFile)
-    delete[] printerFile;
-}
-
-void wxPrintSetupData::SetPrinterCommand(const char *cmd)
-{
-  if (cmd == printerCommand)
-    return;
-
-  if (printerCommand)
-    delete[] printerCommand;
-  if (cmd)
-    printerCommand = copystring(cmd);
-  else
-    printerCommand = (char *) NULL;
-}
-
-void wxPrintSetupData::SetPrintPreviewCommand(const char *cmd)
-{
-  if (cmd == previewCommand)
-    return;
-
-  if (previewCommand)
-    delete[] previewCommand;
-  if (cmd)
-    previewCommand = copystring(cmd);
-  else
-    previewCommand = (char *) NULL;
-}
-
-void wxPrintSetupData::SetPaperName(const char *name)
-{
-  if (name == paperName)
-    return;
-
-  if (paperName)
-    delete[] paperName;
-  if (name)
-    paperName = copystring(name);
-  else
-    paperName = (char *) NULL;
-}
-
-void wxPrintSetupData::SetPrinterOptions(const char *flags)
-{
-  if (printerFlags == flags)
-    return;
-
-  if (printerFlags)
-    delete[] printerFlags;
-  if (flags)
-    printerFlags = copystring(flags);
-  else
-    printerFlags = (char *) NULL;
-}
-
-void wxPrintSetupData::SetPrinterFile(const char *f)
-{
-  if (f == printerFile)
-    return;
-
-  if (printerFile)
-    delete[] printerFile;
-  if (f)
-    printerFile = copystring(f);
-  else
-    printerFile = (char *) NULL;
-}
-
-void wxPrintSetupData::SetPrinterOrientation(int orient)
-{
-  printerOrient = orient;
-}
-
-void wxPrintSetupData::SetPrinterScaling(double x, double y)
-{
-  printerScaleX = x;
-  printerScaleY = y;
-}
-
-void wxPrintSetupData::SetPrinterTranslation(long x, long y)
-{
-  printerTranslateX = x;
-  printerTranslateY = y;
-}
-
-// 1 = Preview, 2 = print to file, 3 = send to printer
-void wxPrintSetupData::SetPrinterMode(int mode)
-{
-  printerMode = mode;
-}
-
-void wxPrintSetupData::SetAFMPath(const char *f)
-{
-  if (f == afmPath)
-    return;
-
-  if (afmPath)
-    delete[] afmPath;
-  if (f)
-    afmPath = copystring(f);
-  else
-    afmPath = (char *) NULL;
-}
-
-void wxPrintSetupData::SetColour(bool col)
-{
-  printColour = col;
-}
-
-// Get current values
-char *wxPrintSetupData::GetPrinterCommand()
-{
-  return printerCommand;
-}
-
-char *wxPrintSetupData::GetPrintPreviewCommand()
-{
-  return previewCommand;
-}
-
-char *wxPrintSetupData::GetPrinterOptions()
-{
-  return printerFlags;
-}
-
-char *wxPrintSetupData::GetPrinterFile()
-{
-  return printerFile;
-}
-
-char *wxPrintSetupData::GetPaperName()
-{
-  return paperName;
-}
-
-int wxPrintSetupData::GetPrinterOrientation()
-{
-  return printerOrient;
-}
-
-void wxPrintSetupData::GetPrinterScaling(double *x, double *y)
-{
-  *x = printerScaleX;
-  *y = printerScaleY;
-}
-
-void wxPrintSetupData::GetPrinterTranslation(long *x, long *y)
-{
-  *x = printerTranslateX;
-  *y = printerTranslateY;
-}
-
-int wxPrintSetupData::GetPrinterMode()
-{
-  return printerMode;
-}
-
-char *wxPrintSetupData::GetAFMPath()
-{
-  return afmPath;
-}
-
-bool wxPrintSetupData::GetColour()
-{
-  return printColour;
  }
  
  void wxPrintSetupData::operator=(wxPrintSetupData& data)
  }
  
  void wxPrintSetupData::operator=(wxPrintSetupData& data)
@@ -2289,6 +2282,22 @@ void wxPrintSetupData::operator=(wxPrintSetupData& data)
    SetColour(data.GetColour());
  }
  
    SetColour(data.GetColour());
  }
  
+// Initialize from a wxPrintData object (wxPrintData should now be used instead of wxPrintSetupData).
+void wxPrintSetupData::operator=(const wxPrintData& data)
+{
+    SetPrinterCommand(data.GetPrinterCommand());
+    SetPrintPreviewCommand(data.GetPreviewCommand());
+    SetPrinterOptions(data.GetPrinterOptions());
+    SetPrinterTranslation(data.GetPrinterTranslateX(), data.GetPrinterTranslateY());
+    SetPrinterScaling(data.GetPrinterScaleX(), data.GetPrinterScaleY());
+    SetPrinterOrientation(data.GetOrientation());
+    SetPrinterMode((int) data.GetPrintMode());
+    SetAFMPath(data.GetFontMetricPath());
+    SetPaperName(wxThePrintPaperDatabase->ConvertIdToName(data.GetPaperId()));
+    SetColour(data.GetColour());
+    SetPrinterFile(data.GetFilename());
+}
+
  void wxInitializePrintSetupData(bool init)
  {
    if (init)
  void wxInitializePrintSetupData(bool init)
  {
    if (init)
@@ -2296,9 +2305,9 @@ void wxInitializePrintSetupData(bool init)
      wxThePrintSetupData = new wxPrintSetupData;
  
      wxThePrintSetupData->SetPrintPreviewCommand(PS_VIEWER_PROG);
      wxThePrintSetupData = new wxPrintSetupData;
  
      wxThePrintSetupData->SetPrintPreviewCommand(PS_VIEWER_PROG);
-    wxThePrintSetupData->SetPrinterOrientation(PS_PORTRAIT);
-    wxThePrintSetupData->SetPrinterMode(PS_PREVIEW);
-    wxThePrintSetupData->SetPaperName(_("A4 210 x 297 mm"));
+    wxThePrintSetupData->SetPrinterOrientation(wxPORTRAIT);
+    wxThePrintSetupData->SetPrinterMode(wxPRINT_MODE_PREVIEW);
+    wxThePrintSetupData->SetPaperName(_("A4 sheet, 210 x 297 mm"));
  
      // Could have a .ini file to read in some defaults
      // - and/or use environment variables, e.g. WXWIN
  
      // Could have a .ini file to read in some defaults
      // - and/or use environment variables, e.g. WXWIN
@@ -2310,12 +2319,12 @@ void wxInitializePrintSetupData(bool init)
  #ifdef __WXMSW__
      wxThePrintSetupData->SetPrinterCommand("print");
      wxThePrintSetupData->SetAFMPath("c:\\windows\\system\\");
  #ifdef __WXMSW__
      wxThePrintSetupData->SetPrinterCommand("print");
      wxThePrintSetupData->SetAFMPath("c:\\windows\\system\\");
-    wxThePrintSetupData->SetPrinterOptions(NULL);
+    wxThePrintSetupData->SetPrinterOptions("");
  #endif
  #if !defined(__VMS__) && !defined(__WXMSW__)
      wxThePrintSetupData->SetPrinterCommand("lpr");
  #endif
  #if !defined(__VMS__) && !defined(__WXMSW__)
      wxThePrintSetupData->SetPrinterCommand("lpr");
-    wxThePrintSetupData->SetPrinterOptions((char *) NULL);
-    wxThePrintSetupData->SetAFMPath((char *) NULL);
+    wxThePrintSetupData->SetPrinterOptions("");
+    wxThePrintSetupData->SetAFMPath("");
  #endif
    }
    else
  #endif
    }
    else
@@ -2326,86 +2335,19 @@ void wxInitializePrintSetupData(bool init)
    }
  }
  
    }
  }
  
-/*
- * Paper size database for PostScript
- */
+// A module to allow initialization/cleanup of PostScript-related
+// things without calling these functions from app.cpp.
  
  
-wxPrintPaperType::wxPrintPaperType(const char *name, int wmm, int hmm, int wp, int hp)
+class WXDLLEXPORT wxPostScriptModule: public wxModule
  {
  {
-  widthMM = wmm;
-  heightMM = hmm;
-  widthPixels = wp;
-  heightPixels = hp;
-  pageName = copystring(name);
-}
-
-wxPrintPaperType::~wxPrintPaperType()
-{
-  delete[] pageName;
-}
+DECLARE_DYNAMIC_CLASS(wxPostScriptModule)
+public:
+    wxPostScriptModule() {}
+    bool OnInit();
+    void OnExit();
+};
  
  
-/*
- * Print paper database for PostScript
- */
-
-#if !USE_SHARED_LIBRARIES
-IMPLEMENT_DYNAMIC_CLASS(wxPrintPaperDatabase, wxList)
-#endif
-
-wxPrintPaperDatabase::wxPrintPaperDatabase():wxList(wxKEY_STRING)
-{
-  DeleteContents(TRUE);
-}
-
-wxPrintPaperDatabase::~wxPrintPaperDatabase()
-{
-}
-
-void wxPrintPaperDatabase::CreateDatabase()
-{
-  // Need correct values for page size in pixels.
-  // Each unit is one 'point' = 1/72 of an inch.
-  // NOTE: WE NEED ALSO TO MAKE ADJUSTMENTS WHEN TRANSLATING
-  // in wxPostScriptDC code, so we can start from top left.
-  // So access this database and translate by appropriate number
-  // of points for this paper size. OR IS IT OK ALREADY?
-  // Can't remember where the PostScript origin is by default.
-  // Heck, someone will know how to make it hunky-dory...
-  // JACS 25/5/95
-
-  AddPaperType(_("A4 210 x 297 mm"), 210, 297,         595, 842);
-  AddPaperType(_("A3 297 x 420 mm"), 297, 420,         842, 1191);
-  AddPaperType(_("Letter 8 1/2 x 11 in"), 216, 279,    612, 791);
-  AddPaperType(_("Legal 8 1/2 x 14 in"), 216, 356,     612, 1009);
-  
-/*
-  This is for 100 ppi
-
-  AddPaperType(_("A4 210 x 297 mm"), 210, 297,         210*4, 297*4 );
-  AddPaperType(_("A3 297 x 420 mm"), 297, 420,         297*4, 420*4 );
-  AddPaperType(_("Letter 8 1/2 x 11 in"), 216, 279,    216*4, 279*4 );
-  AddPaperType(_("Legal 8 1/2 x 14 in"), 216, 356,     216*4, 356*4 );
-*/
-}
-
-void wxPrintPaperDatabase::ClearDatabase()
-{
-  Clear();
-}
-
-void wxPrintPaperDatabase::AddPaperType(const char *name, int wmm, int hmm, int wp, int hp)
-{
-  Append(name, new wxPrintPaperType(name, wmm, hmm, wp, hp));
-}
-
-wxPrintPaperType *wxPrintPaperDatabase::FindPaperType(const char *name)
-{
-  wxNode *node = Find(name);
-  if (node)
-    return (wxPrintPaperType *)node->Data();
-  else
-    return (wxPrintPaperType *) NULL;
-}
+IMPLEMENT_DYNAMIC_CLASS(wxPostScriptModule, wxModule)
  
  /*
   * Initialization/cleanup module
  
  /*
   * Initialization/cleanup module
@@ -2414,8 +2356,6 @@ wxPrintPaperType *wxPrintPaperDatabase::FindPaperType(const char *name)
  bool wxPostScriptModule::OnInit()
  {
      wxInitializePrintSetupData();
  bool wxPostScriptModule::OnInit()
  {
      wxInitializePrintSetupData();
-    wxThePrintPaperDatabase = new wxPrintPaperDatabase;
-    wxThePrintPaperDatabase->CreateDatabase();
  
      return TRUE;
  }
  
      return TRUE;
  }
@@ -2423,9 +2363,10 @@ bool wxPostScriptModule::OnInit()
  void wxPostScriptModule::OnExit()
  {
      wxInitializePrintSetupData(FALSE);
  void wxPostScriptModule::OnExit()
  {
      wxInitializePrintSetupData(FALSE);
-    delete wxThePrintPaperDatabase;
-    wxThePrintPaperDatabase = NULL;
  }
  
  #endif
    // wxUSE_POSTSCRIPT
  }
  
  #endif
    // wxUSE_POSTSCRIPT
+
+#endif 
+  // wxUSE_PRINTING_ARCHITECTURE
+\ No newline at end of file