src/common/cmndata.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        cmndata.cpp
   3 // Purpose:     Common GDI data
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     01/02/97
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart and Markus Holzem
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21     #pragma implementation "cmndata.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #ifndef WX_PRECOMP
  32     #include <stdio.h>
  33     #include "wx/string.h"
  34     #include "wx/utils.h"
  35     #include "wx/app.h"
  36 #endif
  37
  38 #include "wx/gdicmn.h"
  39 #include "wx/cmndata.h"
  40 #include "wx/log.h"
  41
  42 #if wxUSE_FONTDLG
  43     #include "wx/fontdlg.h"
  44 #endif // wxUSE_FONTDLG
  45
  46 #if wxUSE_PRINTING_ARCHITECTURE
  47     #include "wx/paper.h"
  48 #endif // wxUSE_PRINTING_ARCHITECTURE
  49
  50 #ifdef __WXMSW__
  51     #include <windows.h>
  52     #include "wx/msw/private.h"
  53
  54     #if !defined(__WIN32__)
  55         #include <print.h>
  56         #include <commdlg.h>
  57     #endif // Win16
  58
  59     #if defined(__WATCOMC__) || defined(__SC__) || defined(__SALFORDC__)
  60         #include <windowsx.h>
  61         #include <commdlg.h>
  62     #endif
  63 #endif // MSW
  64
  65     #if wxUSE_PRINTING_ARCHITECTURE
  66         IMPLEMENT_DYNAMIC_CLASS(wxPrintData, wxObject)
  67         IMPLEMENT_DYNAMIC_CLASS(wxPrintDialogData, wxObject)
  68         IMPLEMENT_DYNAMIC_CLASS(wxPageSetupDialogData, wxObject)
  69     #endif // wxUSE_PRINTING_ARCHITECTURE
  70
  71     IMPLEMENT_DYNAMIC_CLASS(wxFontData, wxObject)
  72     IMPLEMENT_DYNAMIC_CLASS(wxColourData, wxObject)
  73
  74 #ifdef __WXMAC__
  75     #include "wx/mac/uma.h"
  76
  77 #if defined(TARGET_CARBON) && !defined(__DARWIN__)
  78 #  if PM_USE_SESSION_APIS
  79 #    include <PMCore.h>
  80 #  endif
  81 #  include <PMApplication.h>
  82 #endif
  83
  84 #ifndef __DARWIN__
  85     #include "Printing.h"
  86 #endif
  87     #define mm2pt            2.83464566929
  88     #define pt2mm            0.352777777778
  89 #endif // Mac
  90
  91 #ifndef DMPAPER_USER
  92      #define DMPAPER_USER                256
  93 #endif
  94
  95 // ============================================================================
  96 // implementation
  97 // ============================================================================
  98
  99 // ----------------------------------------------------------------------------
 100 // wxColourData
 101 // ----------------------------------------------------------------------------
 102
 103 wxColourData::wxColourData()
 104 {
 105     int i;
 106     for (i = 0; i < 16; i++)
 107         custColours[i].Set(255, 255, 255);
 108
 109     chooseFull = FALSE;
 110     dataColour.Set(0,0,0);
 111 }
 112
 113 wxColourData::wxColourData(const wxColourData& data)
 114     : wxObject()
 115 {
 116     (*this) = data;
 117 }
 118
 119 wxColourData::~wxColourData()
 120 {
 121 }
 122
 123 void wxColourData::SetCustomColour(int i, const wxColour& colour)
 124 {
 125     if (i > 15 || i < 0)
 126         return;
 127
 128     custColours[i] = colour;
 129 }
 130
 131 wxColour wxColourData::GetCustomColour(int i)
 132 {
 133     if (i > 15 || i < 0)
 134         return wxColour(0,0,0);
 135
 136     return custColours[i];
 137 }
 138
 139 void wxColourData::operator=(const wxColourData& data)
 140 {
 141     int i;
 142     for (i = 0; i < 16; i++)
 143         custColours[i] = data.custColours[i];
 144
 145     dataColour = (wxColour&)data.dataColour;
 146     chooseFull = data.chooseFull;
 147 }
 148
 149 // ----------------------------------------------------------------------------
 150 // Font data
 151 // ----------------------------------------------------------------------------
 152
 153 wxFontData::wxFontData()
 154 {
 155     // Intialize colour to black.
 156     fontColour = wxNullColour;
 157
 158     showHelp = FALSE;
 159     allowSymbols = TRUE;
 160     enableEffects = TRUE;
 161     minSize = 0;
 162     maxSize = 0;
 163
 164     m_encoding = wxFONTENCODING_SYSTEM;
 165 }
 166
 167 wxFontData::~wxFontData()
 168 {
 169 }
 170
 171 #if wxUSE_FONTDLG
 172
 173 wxFontDialogBase::~wxFontDialogBase()
 174 {
 175 }
 176
 177 #endif // wxUSE_FONTDLG
 178
 179 #if wxUSE_PRINTING_ARCHITECTURE
 180 // ----------------------------------------------------------------------------
 181 // Print data
 182 // ----------------------------------------------------------------------------
 183
 184 wxPrintData::wxPrintData()
 185 {
 186 #ifdef __WXMSW__
 187     m_devMode = (void*) NULL;
 188     m_devNames = (void*) NULL;
 189 #elif defined( __WXMAC__ )
 190 #if TARGET_CARBON
 191     m_macPageFormat = kPMNoPageFormat;
 192     m_macPrintSettings = kPMNoPrintSettings;
 193     m_macPrintSession = kPMNoReference ;
 194
 195   #if PM_USE_SESSION_APIS
 196     OSStatus       err;
 197
 198         err = PMCreateSession((PMPrintSession *)&m_macPrintSession) ;
 199
 200     if ( err == noErr )
 201     {
 202         err = PMCreatePageFormat((PMPageFormat *)&m_macPageFormat);
 203
 204         //  Note that PMPageFormat is not session-specific, but calling
 205         //  PMSessionDefaultPageFormat assigns values specific to the printer
 206         //  associated with the current printing session.
 207         if ((err == noErr) && (m_macPageFormat != kPMNoPageFormat))
 208         {
 209             err = PMSessionDefaultPageFormat((PMPrintSession)m_macPrintSession,
 210                                              (PMPageFormat)m_macPageFormat);
 211         }
 212
 213         err = PMCreatePrintSettings((PMPrintSettings *)&m_macPrintSettings);
 214
 215         //  Note that PMPrintSettings is not session-specific, but calling
 216         //  PMSessionDefaultPrintSettings assigns values specific to the printer
 217         //  associated with the current printing session.
 218         if ((err == noErr) && (m_macPrintSettings != kPMNoPrintSettings))
 219         {
 220             err = PMSessionDefaultPrintSettings((PMPrintSession)m_macPrintSession,
 221                                                 (PMPrintSettings)m_macPrintSettings);
 222         }
 223     }
 224
 225   #endif
 226 #else
 227     m_macPrintSettings = (THPrint) NewHandleClear( sizeof( TPrint ) );
 228     (**(THPrint)m_macPrintSettings).iPrVersion = 0;                    // something invalid
 229
 230     (**(THPrint)m_macPrintSettings).prInfo.iHRes = 72;
 231     (**(THPrint)m_macPrintSettings).prInfo.iVRes = 72;
 232     Rect r1 = { 0, 0, 8*72 - 2 * 18, 11*72 - 2 * 36 };
 233     (**(THPrint)m_macPrintSettings).prInfo.rPage = r1;// must have its top left & (0,0)
 234
 235     Rect r2 = { -18, -36, 8*72 - 18, 11*72 - 36  };
 236     (**(THPrint)m_macPrintSettings).rPaper = r2;
 237     (**(THPrint)m_macPrintSettings).prStl.iPageV = 11 * 120 ;                // 11 inches in 120th of an inch
 238     (**(THPrint)m_macPrintSettings).prStl.iPageH = 8 * 120 ;                // 8 inches in 120th of an inch
 239 #endif
 240 #endif
 241     m_printOrientation = wxPORTRAIT;
 242     m_printNoCopies = 1;
 243     m_printCollate = FALSE;
 244
 245     // New, 24/3/99
 246     m_printerName = wxT("");
 247     m_colour = TRUE;
 248     m_duplexMode = wxDUPLEX_SIMPLEX;
 249     m_printQuality = wxPRINT_QUALITY_HIGH;
 250     m_paperId = wxPAPER_A4;
 251     m_paperSize = wxSize(210, 297);
 252
 253     // PostScript-specific data
 254     m_previewCommand = wxT("");
 255     m_filename = wxT("");
 256 #ifdef __VMS__
 257     m_printerCommand = wxT("print");
 258     m_printerOptions = wxT("/nonotify/queue=psqueue");
 259     m_afmPath = wxT("sys$ps_font_metrics:");
 260 #endif
 261
 262 #ifdef __WXMSW__
 263     m_printerCommand = wxT("print");
 264     m_printerOptions = wxT("");
 265     m_afmPath = wxT("c:\\windows\\system\\");
 266 #endif
 267
 268 #if !defined(__VMS__) && !defined(__WXMSW__)
 269     m_printerCommand = wxT("lpr");
 270     m_printerOptions = wxT("");
 271     m_afmPath = wxT("");
 272 #endif
 273
 274     m_printerScaleX = 1.0;
 275     m_printerScaleY = 1.0;
 276     m_printerTranslateX = 0;
 277     m_printerTranslateY = 0;
 278     m_printMode = wxPRINT_MODE_FILE;
 279 }
 280
 281 wxPrintData::wxPrintData(const wxPrintData& printData)
 282     : wxObject()
 283 {
 284 #ifdef __WXMSW__
 285     m_devMode = (void*) NULL;
 286     m_devNames = (void*) NULL;
 287 #elif defined( __WXMAC__ )
 288 #if TARGET_CARBON
 289     m_macPageFormat    = kPMNoPageFormat;
 290     m_macPrintSettings = kPMNoPrintSettings;
 291     m_macPrintSession = kPMNoReference ;
 292 #else
 293     m_macPrintSettings = NULL;
 294 #endif
 295 #endif
 296     (*this) = printData;
 297 }
 298
 299 wxPrintData::~wxPrintData()
 300 {
 301 #ifdef __WXMSW__
 302     HGLOBAL hDevMode = (HGLOBAL)(DWORD) m_devMode;
 303     if ( hDevMode )
 304         GlobalFree(hDevMode);
 305     HGLOBAL hDevNames = (HGLOBAL)(DWORD) m_devNames;
 306     if ( hDevNames )
 307         GlobalFree(hDevNames);
 308 #elif defined(__WXMAC__)
 309 #if TARGET_CARBON
 310     if (m_macPageFormat != kPMNoPageFormat)
 311     {
 312   #if PM_USE_SESSION_APIS
 313         (void)PMRelease(m_macPageFormat);
 314   #else
 315         (void)PMDisposePageFormat(m_macPageFormat);
 316   #endif
 317         m_macPageFormat = kPMNoPageFormat;
 318     }
 319
 320     if (m_macPrintSettings != kPMNoPrintSettings)
 321     {
 322   #if PM_USE_SESSION_APIS
 323         (void)PMRelease(m_macPrintSettings);
 324   #else
 325         (void)PMDisposePrintSettings(m_macPrintSettings);
 326   #endif
 327         m_macPrintSettings = kPMNoPrintSettings;
 328     }
 329
 330     if ( m_macPrintSession != kPMNoReference )
 331     {
 332   #if PM_USE_SESSION_APIS
 333         (void)PMRelease(m_macPrintSession);
 334   #else
 335         (void)PMDisposePrintSession(m_macPrintSession);
 336   #endif
 337         m_macPrintSession = kPMNoReference;
 338     }
 339 #else
 340     wxASSERT( m_macPrintSettings );
 341     // we should perhaps delete
 342 #endif
 343 #endif
 344 }
 345
 346 #if defined(__WXMSW__) // && defined(__WIN32__)
 347
 348 #if defined(__WXDEBUG__) && defined(__WIN32__)
 349 static wxString wxGetPrintDlgError()
 350 {
 351     DWORD err = CommDlgExtendedError();
 352     wxString msg = wxT("Unknown");
 353     switch (err)
 354     {
 355         case CDERR_FINDRESFAILURE: msg = wxT("CDERR_FINDRESFAILURE"); break;
 356         case CDERR_INITIALIZATION: msg = wxT("CDERR_INITIALIZATION"); break;
 357         case CDERR_LOADRESFAILURE: msg = wxT("CDERR_LOADRESFAILURE"); break;
 358         case CDERR_LOADSTRFAILURE: msg = wxT("CDERR_LOADSTRFAILURE"); break;
 359         case CDERR_LOCKRESFAILURE: msg = wxT("CDERR_LOCKRESFAILURE"); break;
 360         case CDERR_MEMALLOCFAILURE: msg = wxT("CDERR_MEMALLOCFAILURE"); break;
 361         case CDERR_MEMLOCKFAILURE: msg = wxT("CDERR_MEMLOCKFAILURE"); break;
 362         case CDERR_NOHINSTANCE: msg = wxT("CDERR_NOHINSTANCE"); break;
 363         case CDERR_NOHOOK: msg = wxT("CDERR_NOHOOK"); break;
 364         case CDERR_NOTEMPLATE: msg = wxT("CDERR_NOTEMPLATE"); break;
 365         case CDERR_STRUCTSIZE: msg = wxT("CDERR_STRUCTSIZE"); break;
 366         case  PDERR_RETDEFFAILURE: msg = wxT("PDERR_RETDEFFAILURE"); break;
 367         case  PDERR_PRINTERNOTFOUND: msg = wxT("PDERR_PRINTERNOTFOUND"); break;
 368         case  PDERR_PARSEFAILURE: msg = wxT("PDERR_PARSEFAILURE"); break;
 369         case  PDERR_NODEVICES: msg = wxT("PDERR_NODEVICES"); break;
 370         case  PDERR_NODEFAULTPRN: msg = wxT("PDERR_NODEFAULTPRN"); break;
 371         case  PDERR_LOADDRVFAILURE: msg = wxT("PDERR_LOADDRVFAILURE"); break;
 372         case  PDERR_INITFAILURE: msg = wxT("PDERR_INITFAILURE"); break;
 373         case  PDERR_GETDEVMODEFAIL: msg = wxT("PDERR_GETDEVMODEFAIL"); break;
 374         case  PDERR_DNDMMISMATCH: msg = wxT("PDERR_DNDMMISMATCH"); break;
 375         case  PDERR_DEFAULTDIFFERENT: msg = wxT("PDERR_DEFAULTDIFFERENT"); break;
 376         case  PDERR_CREATEICFAILURE: msg = wxT("PDERR_CREATEICFAILURE"); break;
 377         default: break;
 378     }
 379     return msg;
 380 }
 381 #endif
 382
 383 static HGLOBAL wxCreateDevNames(const wxString& driverName, const wxString& printerName, const wxString& portName)
 384 {
 385     HGLOBAL hDev = NULL;
 386     // if (!driverName.IsEmpty() && !printerName.IsEmpty() && !portName.IsEmpty())
 387     if (driverName.IsEmpty() && printerName.IsEmpty() && portName.IsEmpty())
 388     {
 389     }
 390     else
 391     {
 392         hDev = GlobalAlloc(GPTR, 4*sizeof(WORD)+
 393                            ( driverName.Length() + 1 +
 394             printerName.Length() + 1 +
 395                              portName.Length()+1 ) * sizeof(wxChar) );
 396         LPDEVNAMES lpDev = (LPDEVNAMES)GlobalLock(hDev);
 397         lpDev->wDriverOffset = sizeof(WORD)*4;
 398         wxStrcpy((wxChar*)((char*)lpDev + lpDev->wDriverOffset ), driverName);
 399
 400         lpDev->wDeviceOffset = (WORD)( lpDev->wDriverOffset +
 401                                        sizeof(wxChar) * ( driverName.Length() + 1 ) );
 402         wxStrcpy((wxChar*)((char*)lpDev + lpDev->wDeviceOffset ), printerName);
 403
 404         lpDev->wOutputOffset = (WORD)( lpDev->wDeviceOffset +
 405                                        sizeof(wxChar) * ( printerName.Length() + 1 ) );
 406         wxStrcpy((wxChar*)((char*) lpDev + lpDev->wOutputOffset ), portName);
 407
 408         lpDev->wDefault = 0;
 409
 410         GlobalUnlock(hDev);
 411     }
 412
 413     return hDev;
 414 }
 415
 416 void wxPrintData::ConvertToNative()
 417 {
 418     HGLOBAL hDevMode = (HGLOBAL)(DWORD) m_devMode;
 419     HGLOBAL hDevNames = (HGLOBAL)(DWORD) m_devNames;
 420     if (!hDevMode)
 421     {
 422         // Use PRINTDLG as a way of creating a DEVMODE object
 423         PRINTDLG pd;
 424
 425         // GNU-WIN32 has the wrong size PRINTDLG - can't work out why.
 426 #ifdef __GNUWIN32__
 427         memset(&pd, 0, 66);
 428         pd.lStructSize    = 66;
 429 #else
 430         memset(&pd, 0, sizeof(PRINTDLG));
 431         pd.lStructSize    = sizeof(PRINTDLG);
 432 #endif
 433
 434         pd.hwndOwner      = (HWND)NULL;
 435         pd.hDevMode       = NULL; // Will be created by PrintDlg
 436         pd.hDevNames      = NULL; // Ditto
 437         //pd.hInstance      = (HINSTANCE) wxGetInstance();
 438
 439         pd.Flags          = PD_RETURNDEFAULT;
 440         pd.nCopies        = 1;
 441
 442         // Fill out the DEVMODE structure
 443         // so we can use it as input in the 'real' PrintDlg
 444         if (!PrintDlg(&pd))
 445         {
 446             if ( pd.hDevMode )
 447                 GlobalFree(pd.hDevMode);
 448             if ( pd.hDevNames )
 449                 GlobalFree(pd.hDevNames);
 450             pd.hDevMode = NULL;
 451             pd.hDevNames = NULL;
 452
 453 #if defined(__WXDEBUG__) && defined(__WIN32__)
 454             wxString str(wxT("Printing error: "));
 455             str += wxGetPrintDlgError();
 456             wxLogDebug(str);
 457 #endif
 458         }
 459         else
 460         {
 461             hDevMode = pd.hDevMode;
 462             m_devMode = (void*)(long) hDevMode;
 463             pd.hDevMode = NULL;
 464
 465             // We'll create a new DEVNAMEs structure below.
 466             if ( pd.hDevNames )
 467                 GlobalFree(pd.hDevNames);
 468             pd.hDevNames = NULL;
 469
 470             // hDevNames = pd->hDevNames;
 471             // m_devNames = (void*)(long) hDevNames;
 472             // pd->hDevnames = NULL;
 473
 474         }
 475     }
 476
 477     if ( hDevMode )
 478     {
 479         LPDEVMODE devMode = (LPDEVMODE) GlobalLock(hDevMode);
 480
 481         //// Orientation
 482
 483         devMode->dmOrientation = m_printOrientation;
 484
 485         //// Collation
 486
 487 #ifndef __WIN16__
 488         devMode->dmCollate = (m_printCollate ? DMCOLLATE_TRUE : DMCOLLATE_FALSE);
 489         devMode->dmFields |= DM_COLLATE;
 490 #endif
 491
 492         //// Number of copies
 493
 494         devMode->dmCopies = m_printNoCopies;
 495         devMode->dmFields |= DM_COPIES;
 496
 497         //// Printer name
 498
 499         if (m_printerName != wxT(""))
 500         {
 501             //int len = wxMin(31, m_printerName.Len());
 502             wxStrncpy((wxChar*)devMode->dmDeviceName,m_printerName.c_str(),31);
 503             devMode->dmDeviceName[31] = wxT('\0');
 504         }
 505
 506         //// Colour
 507
 508         if (m_colour)
 509             devMode->dmColor = DMCOLOR_COLOR;
 510         else
 511             devMode->dmColor = DMCOLOR_MONOCHROME;
 512
 513         devMode->dmFields |= DM_COLOR;
 514
 515         //// Paper size
 516
 517         if (m_paperId == wxPAPER_NONE)
 518         {
 519             // DEVMODE is in tenths of a milimeter
 520             devMode->dmPaperWidth = m_paperSize.x * 10;
 521             devMode->dmPaperLength = m_paperSize.y * 10;
 522             devMode->dmPaperSize = DMPAPER_USER;
 523             devMode->dmFields |= DM_PAPERWIDTH;
 524             devMode->dmFields |= DM_PAPERLENGTH;
 525         }
 526         else
 527         {
 528             if (wxThePrintPaperDatabase)
 529             {
 530                 wxPrintPaperType* paper = wxThePrintPaperDatabase->FindPaperType(m_paperId);
 531                 if (paper)
 532                 {
 533                     devMode->dmPaperSize = paper->GetPlatformId();
 534                     devMode->dmFields |= DM_PAPERSIZE;
 535                 }
 536             }
 537         }
 538
 539         //// Duplex
 540
 541         int duplex;
 542         switch (m_duplexMode)
 543         {
 544         case wxDUPLEX_HORIZONTAL: {
 545             duplex = DMDUP_HORIZONTAL; break;
 546                                   }
 547         case wxDUPLEX_VERTICAL: {
 548             duplex = DMDUP_VERTICAL; break;
 549                                 }
 550         default:
 551         case wxDUPLEX_SIMPLEX: {
 552             duplex = DMDUP_SIMPLEX; break;
 553                                }
 554         }
 555         devMode->dmDuplex = duplex;
 556         devMode->dmFields |= DM_DUPLEX;
 557
 558         //// Quality
 559
 560         int quality;
 561         switch (m_printQuality)
 562         {
 563         case wxPRINT_QUALITY_MEDIUM: {
 564             quality = DMRES_MEDIUM; break;
 565                                      }
 566         case wxPRINT_QUALITY_LOW: {
 567             quality = DMRES_LOW; break;
 568                                   }
 569         case wxPRINT_QUALITY_DRAFT: {
 570             quality = DMRES_DRAFT; break;
 571                                     }
 572         case wxPRINT_QUALITY_HIGH: {
 573             quality = DMRES_HIGH; break;
 574                                    }
 575         default: {
 576             quality = m_printQuality; break;
 577                  }
 578         }
 579         devMode->dmPrintQuality = quality;
 580         devMode->dmFields |= DM_PRINTQUALITY;
 581
 582         GlobalUnlock(hDevMode);
 583     }
 584
 585     if ( hDevNames )
 586     {
 587         GlobalFree(hDevNames);
 588     }
 589
 590     // TODO: I hope it's OK to pass some empty strings to DEVNAMES.
 591     m_devNames = (void*) (long) wxCreateDevNames(wxT(""), m_printerName, wxT(""));
 592 }
 593
 594 void wxPrintData::ConvertFromNative()
 595 {
 596     HGLOBAL hDevMode = (HGLOBAL)(DWORD) m_devMode;
 597     HGLOBAL hDevNames = (HGLOBAL)(DWORD) m_devNames;
 598
 599     if (!hDevMode)
 600         return;
 601
 602     if ( hDevMode )
 603     {
 604         LPDEVMODE devMode = (LPDEVMODE)GlobalLock(hDevMode);
 605
 606         //// Orientation
 607
 608         if (devMode->dmFields & DM_ORIENTATION)
 609             m_printOrientation = devMode->dmOrientation;
 610
 611         //// Collation
 612
 613 #ifndef __WIN16__
 614         if (devMode->dmFields & DM_COLLATE)
 615         {
 616             if (devMode->dmCollate == DMCOLLATE_TRUE)
 617                 m_printCollate = TRUE;
 618             else
 619                 m_printCollate = FALSE;
 620         }
 621 #endif
 622
 623         //// Number of copies
 624
 625         if (devMode->dmFields & DM_COPIES)
 626         {
 627             m_printNoCopies = devMode->dmCopies;
 628         }
 629
 630         //// Printer name
 631
 632         if (devMode->dmDeviceName[0] != 0)
 633         {
 634             m_printerName = devMode->dmDeviceName;
 635         }
 636
 637         //// Colour
 638
 639         if (devMode->dmFields & DM_COLOR)
 640         {
 641             if (devMode->dmColor == DMCOLOR_COLOR)
 642                 m_colour = TRUE;
 643             else
 644                 m_colour = FALSE;
 645         }
 646         else
 647             m_colour = TRUE;
 648
 649         //// Paper size
 650
 651         // We don't know size of user defined paper and some buggy drivers
 652         // set both DM_PAPERSIZE and DM_PAPERWIDTH & DM_PAPERLENGTH. Since
 653         // dmPaperSize >= DMPAPER_USER wouldn't be in wxWin's database, this
 654         // code wouldn't set m_paperSize correctly.
 655         if ((devMode->dmFields & DM_PAPERSIZE) && (devMode->dmPaperSize < DMPAPER_USER))
 656         {
 657             if (wxThePrintPaperDatabase)
 658             {
 659                 wxPrintPaperType* paper = wxThePrintPaperDatabase->FindPaperTypeByPlatformId(devMode->dmPaperSize);
 660                 if (paper)
 661                 {
 662                     m_paperId = paper->GetId();
 663                     m_paperSize.x = paper->GetWidth() / 10;
 664                     m_paperSize.y = paper->GetHeight() / 10;
 665                 }
 666                 else
 667                 {
 668                     // Shouldn't really get here
 669                     wxFAIL_MSG(wxT("Couldn't find paper size in paper database."));
 670
 671                     m_paperId = wxPAPER_NONE;
 672                     m_paperSize.x = 0;
 673                     m_paperSize.y = 0;
 674                 }
 675             }
 676             else
 677             {
 678                 // Shouldn't really get here
 679                 wxFAIL_MSG(wxT("Paper database wasn't initialized in wxPrintData::ConvertFromNative."));
 680
 681                 m_paperId = wxPAPER_NONE;
 682                 m_paperSize.x = 0;
 683                 m_paperSize.y = 0;
 684             }
 685         }
 686         else if ((devMode->dmFields & DM_PAPERWIDTH) && (devMode->dmFields & DM_PAPERLENGTH))
 687         {
 688             // DEVMODE is in tenths of a milimeter
 689             m_paperSize.x = devMode->dmPaperWidth / 10;
 690             m_paperSize.y = devMode->dmPaperLength / 10;
 691             m_paperId = wxPAPER_NONE;
 692         }
 693         else
 694         {
 695             // Shouldn't really get here
 696             wxFAIL_MSG(wxT("Couldn't find paper size from DEVMODE."));
 697
 698             m_paperSize.x = 0;
 699             m_paperSize.y = 0;
 700             m_paperId = wxPAPER_NONE;
 701         }
 702
 703         //// Duplex
 704
 705         if (devMode->dmFields & DM_DUPLEX)
 706         {
 707             switch (devMode->dmDuplex)
 708             {
 709             case DMDUP_HORIZONTAL: {
 710                 m_duplexMode = wxDUPLEX_HORIZONTAL; break;
 711                                    }
 712             case DMDUP_VERTICAL: {
 713                 m_duplexMode = wxDUPLEX_VERTICAL; break;
 714                                  }
 715             default:
 716             case DMDUP_SIMPLEX: {
 717                 m_duplexMode = wxDUPLEX_SIMPLEX; break;
 718                                 }
 719             }
 720         }
 721         else
 722             m_duplexMode = wxDUPLEX_SIMPLEX;
 723
 724         //// Quality
 725
 726         if (devMode->dmFields & DM_PRINTQUALITY)
 727         {
 728             switch (devMode->dmPrintQuality)
 729             {
 730             case DMRES_MEDIUM: {
 731                 m_printQuality = wxPRINT_QUALITY_MEDIUM; break;
 732                                }
 733             case DMRES_LOW: {
 734                 m_printQuality = wxPRINT_QUALITY_LOW; break;
 735                             }
 736             case DMRES_DRAFT: {
 737                 m_printQuality = wxPRINT_QUALITY_DRAFT; break;
 738                               }
 739             case DMRES_HIGH: {
 740                 m_printQuality = wxPRINT_QUALITY_HIGH; break;
 741                              }
 742             default:
 743                 {
 744                     // TODO: if the printer fills in the resolution in DPI, how
 745                     // will the application know if it's high, low, draft etc.??
 746                     //                    wxFAIL_MSG("Warning: DM_PRINTQUALITY was not one of the standard values.");
 747                     m_printQuality = devMode->dmPrintQuality; break;
 748
 749                 }
 750             }
 751         }
 752         else
 753             m_printQuality = wxPRINT_QUALITY_HIGH;
 754
 755         GlobalUnlock(hDevMode);
 756     }
 757
 758     if (hDevNames)
 759     {
 760         LPDEVNAMES lpDevNames = (LPDEVNAMES)GlobalLock(hDevNames);
 761         if (lpDevNames)
 762         {
 763             // TODO: Unicode-ification
 764
 765             // Get the port name
 766             // port is obsolete in WIN32
 767             // m_printData.SetPortName((LPSTR)lpDevNames + lpDevNames->wDriverOffset);
 768
 769             // Get the printer name
 770             wxString printerName = (LPTSTR)lpDevNames + lpDevNames->wDeviceOffset;
 771
 772             // Not sure if we should check for this mismatch
 773 //            wxASSERT_MSG( (m_printerName == "" || (devName == m_printerName)), "Printer name obtained from DEVMODE and DEVNAMES were different!");
 774
 775             if (printerName != wxT(""))
 776                 m_printerName = printerName;
 777
 778             GlobalUnlock(hDevNames);
 779         }
 780     }
 781 }
 782
 783 #endif
 784
 785 #ifdef __WXMAC__
 786 void wxPrintData::ConvertToNative()
 787 {
 788 #if TARGET_CARBON
 789 #else
 790     (**(THPrint)m_macPrintSettings).prJob.iCopies = m_printNoCopies;
 791 #endif
 792 }
 793
 794 void wxPrintData::ConvertFromNative()
 795 {
 796 #if TARGET_CARBON
 797 #else
 798     m_printNoCopies = (**(THPrint)m_macPrintSettings).prJob.iCopies;
 799 #endif
 800 }
 801 #endif
 802
 803 void wxPrintData::operator=(const wxPrintData& data)
 804 {
 805 #ifdef __WXMAC__
 806 #if TARGET_CARBON
 807         if ( m_macPrintSettings != kPMNoPrintSettings )
 808         {
 809                 PMRelease( m_macPrintSettings ) ;
 810                 m_macPrintSettings = kPMNoPrintSettings ;
 811         }
 812         if ( data.m_macPrintSettings != kPMNoPrintSettings )
 813         {
 814                 m_macPrintSettings = data.m_macPrintSettings ;
 815                 PMRetain( m_macPrintSettings ) ;
 816         }
 817         if ( m_macPageFormat != kPMNoPageFormat )
 818         {
 819                 PMRelease( m_macPageFormat ) ;
 820                 m_macPageFormat = kPMNoPageFormat ;
 821         }
 822         if ( data.m_macPageFormat != kPMNoPageFormat )
 823         {
 824                 m_macPageFormat = data.m_macPageFormat ;
 825                 PMRetain( m_macPageFormat ) ;
 826         }
 827 #else
 828     m_macPrintSettings = data.m_macPrintSettings;
 829     HandToHand( (Handle*) &m_macPrintSettings );
 830 #endif
 831 #endif
 832     m_printNoCopies = data.m_printNoCopies;
 833     m_printCollate = data.m_printCollate;
 834     m_printOrientation = data.m_printOrientation;
 835     m_printerName = data.m_printerName;
 836     m_colour = data.m_colour;
 837     m_duplexMode = data.m_duplexMode;
 838     m_printQuality = data.m_printQuality;
 839     m_paperId = data.m_paperId;
 840     m_paperSize = data.m_paperSize;
 841
 842     // PostScript-specific data
 843     m_printerCommand = data.m_printerCommand;
 844     m_previewCommand = data.m_previewCommand;
 845     m_printerOptions = data.m_printerOptions;
 846     m_filename = data.m_filename;
 847     m_afmPath = data.m_afmPath;
 848     m_printerScaleX = data.m_printerScaleX;
 849     m_printerScaleY = data.m_printerScaleY;
 850     m_printerTranslateX = data.m_printerTranslateX;
 851     m_printerTranslateY = data.m_printerTranslateY;
 852     m_printMode = data.m_printMode;
 853 }
 854
 855 // Is this data OK for showing the print dialog?
 856 bool wxPrintData::Ok() const
 857 {
 858 #ifdef __WXMSW__
 859     ((wxPrintData*)this)->ConvertToNative();
 860     return (m_devMode != NULL) ;
 861 #else
 862     return TRUE;
 863 #endif
 864 }
 865
 866 // ----------------------------------------------------------------------------
 867 // Print dialog data
 868 // ----------------------------------------------------------------------------
 869
 870 wxPrintDialogData::wxPrintDialogData()
 871 {
 872 #ifdef __WXMSW__
 873     m_printDlgData = NULL;
 874 #endif
 875     m_printFromPage = 0;
 876     m_printToPage = 0;
 877     m_printMinPage = 0;
 878     m_printMaxPage = 0;
 879     m_printNoCopies = 1;
 880     m_printAllPages = FALSE;
 881     m_printCollate = FALSE;
 882     m_printToFile = FALSE;
 883     m_printSelection = FALSE;
 884     m_printEnableSelection = FALSE;
 885     m_printEnablePageNumbers = TRUE;
 886     m_printEnablePrintToFile = TRUE;
 887     m_printEnableHelp = FALSE;
 888     m_printSetupDialog = FALSE;
 889 }
 890
 891 wxPrintDialogData::wxPrintDialogData(const wxPrintDialogData& dialogData)
 892     : wxObject()
 893 {
 894 #ifdef __WXMSW__
 895     m_printDlgData = NULL;
 896 #endif
 897     (*this) = dialogData;
 898 }
 899
 900 wxPrintDialogData::wxPrintDialogData(const wxPrintData& printData)
 901 {
 902 #ifdef __WXMSW__
 903     m_printDlgData = NULL;
 904 #endif
 905     m_printFromPage = 0;
 906     m_printToPage = 0;
 907     m_printMinPage = 0;
 908     m_printMaxPage = 0;
 909     m_printNoCopies = 1;
 910     m_printAllPages = FALSE;
 911     m_printCollate = FALSE;
 912     m_printToFile = FALSE;
 913     m_printSelection = FALSE;
 914     m_printEnableSelection = FALSE;
 915     m_printEnablePageNumbers = TRUE;
 916     m_printEnablePrintToFile = TRUE;
 917     m_printEnableHelp = FALSE;
 918     m_printSetupDialog = FALSE;
 919
 920     m_printData = printData;
 921 }
 922
 923 wxPrintDialogData::~wxPrintDialogData()
 924 {
 925 #ifdef __WXMSW__
 926     PRINTDLG *pd = (PRINTDLG *) m_printDlgData;
 927     if ( pd && pd->hDevMode )
 928         GlobalFree(pd->hDevMode);
 929     if ( pd )
 930         delete pd;
 931 #endif
 932 }
 933
 934 #ifdef __WXMSW__
 935 void wxPrintDialogData::ConvertToNative()
 936 {
 937     m_printData.ConvertToNative();
 938
 939     PRINTDLG *pd = (PRINTDLG*) m_printDlgData;
 940
 941     if (!pd)
 942     {
 943         pd = new PRINTDLG;
 944         memset( pd, 0, sizeof(PRINTDLG) );
 945         m_printDlgData = (void*) pd;
 946
 947         // GNU-WIN32 has the wrong size PRINTDLG - can't work out why.
 948 #ifdef __GNUWIN32__
 949         pd->lStructSize    = 66;
 950 #else
 951         pd->lStructSize    = sizeof(PRINTDLG);
 952 #endif
 953         pd->hwndOwner      = (HWND)NULL;
 954         pd->hDevMode       = NULL; // Will be created by PrintDlg
 955         pd->hDevNames      = NULL; // Ditto
 956
 957         pd->Flags          = PD_RETURNDEFAULT;
 958         pd->nCopies        = 1;
 959     }
 960
 961     // Pass the devmode data to the PRINTDLG structure, since it'll
 962     // be needed when PrintDlg is called.
 963     if (pd->hDevMode)
 964     {
 965         GlobalFree(pd->hDevMode);
 966     }
 967
 968     // Pass the devnames data to the PRINTDLG structure, since it'll
 969     // be needed when PrintDlg is called.
 970     if (pd->hDevNames)
 971     {
 972         GlobalFree(pd->hDevNames);
 973     }
 974
 975     pd->hDevMode = (HGLOBAL)(DWORD) m_printData.GetNativeData();
 976
 977     m_printData.SetNativeData((void*) NULL);
 978
 979     // Shouldn't assert; we should be able to test Ok-ness at a higher level
 980     //wxASSERT_MSG( (pd->hDevMode), wxT("hDevMode must be non-NULL in ConvertToNative!"));
 981
 982     pd->hDevNames = (HGLOBAL)(DWORD) m_printData.GetNativeDataDevNames();
 983
 984     m_printData.SetNativeDataDevNames((void*) NULL);
 985
 986     pd->hDC = (HDC) NULL;
 987     pd->nFromPage = (WORD)m_printFromPage;
 988     pd->nToPage = (WORD)m_printToPage;
 989     pd->nMinPage = (WORD)m_printMinPage;
 990     pd->nMaxPage = (WORD)m_printMaxPage;
 991     pd->nCopies = (WORD)m_printNoCopies;
 992
 993     pd->Flags = PD_RETURNDC;
 994
 995 #ifdef __GNUWIN32__
 996     pd->lStructSize = 66;
 997 #else
 998     pd->lStructSize = sizeof( PRINTDLG );
 999 #endif
1000
1001     pd->hwndOwner=(HWND)NULL;
1002 //    pd->hDevNames=(HANDLE)NULL;
1003     pd->hInstance=(HINSTANCE)NULL;
1004     pd->lCustData = (LPARAM) NULL;
1005     pd->lpfnPrintHook = NULL;
1006     pd->lpfnSetupHook = NULL;
1007     pd->lpPrintTemplateName = NULL;
1008     pd->lpSetupTemplateName = NULL;
1009     pd->hPrintTemplate = (HGLOBAL) NULL;
1010     pd->hSetupTemplate = (HGLOBAL) NULL;
1011
1012     if ( m_printAllPages )
1013         pd->Flags |= PD_ALLPAGES;
1014     if ( m_printSelection )
1015         pd->Flags |= PD_SELECTION;
1016     if ( m_printCollate )
1017         pd->Flags |= PD_COLLATE;
1018     if ( m_printToFile )
1019         pd->Flags |= PD_PRINTTOFILE;
1020     if ( !m_printEnablePrintToFile )
1021         pd->Flags |= PD_DISABLEPRINTTOFILE;
1022     if ( !m_printEnableSelection )
1023         pd->Flags |= PD_NOSELECTION;
1024     if ( !m_printEnablePageNumbers )
1025         pd->Flags |= PD_NOPAGENUMS;
1026     if ( m_printEnableHelp )
1027         pd->Flags |= PD_SHOWHELP;
1028     if ( m_printSetupDialog )
1029         pd->Flags |= PD_PRINTSETUP;
1030 }
1031
1032 void wxPrintDialogData::ConvertFromNative()
1033 {
1034     PRINTDLG *pd = (PRINTDLG*) m_printDlgData;
1035     if ( pd == NULL )
1036         return;
1037
1038     // Pass the devmode data back to the wxPrintData structure where it really belongs.
1039     if (pd->hDevMode)
1040     {
1041         if (m_printData.GetNativeData())
1042         {
1043             // Make sure we don't leak memory
1044             GlobalFree((HGLOBAL)(DWORD) m_printData.GetNativeData());
1045         }
1046         m_printData.SetNativeData((void*)(long) pd->hDevMode);
1047         pd->hDevMode = NULL;
1048     }
1049
1050     // Pass the devnames data back to the wxPrintData structure where it really belongs.
1051     if (pd->hDevNames)
1052     {
1053         if (m_printData.GetNativeDataDevNames())
1054         {
1055             // Make sure we don't leak memory
1056             GlobalFree((HGLOBAL)(DWORD) m_printData.GetNativeDataDevNames());
1057         }
1058         m_printData.SetNativeDataDevNames((void*)(long) pd->hDevNames);
1059         pd->hDevNames = NULL;
1060     }
1061
1062     // Now convert the DEVMODE object, passed down from the PRINTDLG object,
1063     // into wxWindows form.
1064     m_printData.ConvertFromNative();
1065
1066     m_printFromPage = pd->nFromPage;
1067     m_printToPage = pd->nToPage;
1068     m_printMinPage = pd->nMinPage;
1069     m_printMaxPage = pd->nMaxPage;
1070     m_printNoCopies = pd->nCopies;
1071
1072     m_printAllPages = ((pd->Flags & PD_ALLPAGES) == PD_ALLPAGES);
1073     m_printSelection = ((pd->Flags & PD_SELECTION) == PD_SELECTION);
1074     m_printCollate = ((pd->Flags & PD_COLLATE) == PD_COLLATE);
1075     m_printToFile = ((pd->Flags & PD_PRINTTOFILE) == PD_PRINTTOFILE);
1076     m_printEnablePrintToFile = ((pd->Flags & PD_DISABLEPRINTTOFILE) != PD_DISABLEPRINTTOFILE);
1077     m_printEnableSelection = ((pd->Flags & PD_NOSELECTION) != PD_NOSELECTION);
1078     m_printEnablePageNumbers = ((pd->Flags & PD_NOPAGENUMS) != PD_NOPAGENUMS);
1079     m_printEnableHelp = ((pd->Flags & PD_SHOWHELP) == PD_SHOWHELP);
1080     m_printSetupDialog = ((pd->Flags & PD_PRINTSETUP) == PD_PRINTSETUP);
1081
1082 /* port is obsolete in WIN32
1083     // Get the port name
1084     if (pd->hDevNames)
1085     {
1086         LPDEVNAMES lpDevNames = (LPDEVNAMES)GlobalLock(pd->hDevNames);
1087         if (lpDevNames) {
1088             m_printData.SetPortName((LPSTR)lpDevNames + lpDevNames->wDriverOffset);
1089             wxString devName = (LPSTR)lpDevNames + lpDevNames->wDeviceOffset;
1090             GlobalUnlock(pd->hDevNames);
1091
1092 //            wxASSERT_MSG( (m_printerName == "" || (devName == m_printerName)), "Printer name obtained from DEVMODE and DEVNAMES were different!");
1093         }
1094     }
1095 */
1096 }
1097
1098 void wxPrintDialogData::SetOwnerWindow(wxWindow* win)
1099 {
1100     if ( m_printDlgData == NULL )
1101         ConvertToNative();
1102
1103     if ( m_printDlgData != NULL && win != NULL)
1104     {
1105         PRINTDLG *pd = (PRINTDLG *) m_printDlgData;
1106         pd->hwndOwner=(HWND) win->GetHWND();
1107     }
1108 }
1109 #endif // MSW
1110
1111 #ifdef __WXMAC__
1112 void wxPrintDialogData::ConvertToNative()
1113 {
1114 #if TARGET_CARBON
1115 #else
1116     (**(THPrint)m_printData.m_macPrintSettings).prJob.iFstPage = m_printFromPage;
1117     (**(THPrint)m_printData.m_macPrintSettings).prJob.iLstPage = m_printToPage;
1118     m_printData.ConvertToNative();
1119 #endif
1120 }
1121
1122 void wxPrintDialogData::ConvertFromNative()
1123 {
1124 #if TARGET_CARBON
1125 #else
1126     m_printData.ConvertFromNative();
1127     m_printFromPage = (**(THPrint)m_printData.m_macPrintSettings).prJob.iFstPage;
1128     m_printToPage = (**(THPrint)m_printData.m_macPrintSettings).prJob.iLstPage;
1129 #endif
1130 }
1131 #endif
1132
1133
1134 void wxPrintDialogData::operator=(const wxPrintDialogData& data)
1135 {
1136     m_printFromPage = data.m_printFromPage;
1137     m_printToPage = data.m_printToPage;
1138     m_printMinPage = data.m_printMinPage;
1139     m_printMaxPage = data.m_printMaxPage;
1140     m_printNoCopies = data.m_printNoCopies;
1141     m_printAllPages = data.m_printAllPages;
1142     m_printCollate = data.m_printCollate;
1143     m_printToFile = data.m_printToFile;
1144     m_printSelection = data.m_printSelection;
1145     m_printEnableSelection = data.m_printEnableSelection;
1146     m_printEnablePageNumbers = data.m_printEnablePageNumbers;
1147     m_printEnableHelp = data.m_printEnableHelp;
1148     m_printEnablePrintToFile = data.m_printEnablePrintToFile;
1149     m_printSetupDialog = data.m_printSetupDialog;
1150
1151     m_printData = data.m_printData;
1152 }
1153
1154 void wxPrintDialogData::operator=(const wxPrintData& data)
1155 {
1156     m_printData = data;
1157 }
1158
1159 // ----------------------------------------------------------------------------
1160 // wxPageSetupDialogData
1161 // ----------------------------------------------------------------------------
1162
1163 wxPageSetupDialogData::wxPageSetupDialogData()
1164 {
1165 #if defined(__WIN95__)
1166     m_pageSetupData = NULL;
1167 #endif
1168     m_paperSize = wxSize(0, 0);
1169
1170     CalculatePaperSizeFromId();
1171
1172     m_minMarginTopLeft = wxPoint(0, 0);
1173     m_minMarginBottomRight = wxPoint(0, 0);
1174     m_marginTopLeft = wxPoint(0, 0);
1175     m_marginBottomRight = wxPoint(0, 0);
1176
1177     // Flags
1178     m_defaultMinMargins = FALSE;
1179     m_enableMargins = TRUE;
1180     m_enableOrientation = TRUE;
1181     m_enablePaper = TRUE;
1182     m_enablePrinter = TRUE;
1183     m_enableHelp = FALSE;
1184     m_getDefaultInfo = FALSE;
1185 }
1186
1187 wxPageSetupDialogData::wxPageSetupDialogData(const wxPageSetupDialogData& dialogData)
1188     : wxObject()
1189 {
1190 #if defined(__WIN95__)
1191     m_pageSetupData = NULL;
1192 #endif
1193     (*this) = dialogData;
1194 }
1195
1196 wxPageSetupDialogData::wxPageSetupDialogData(const wxPrintData& printData)
1197 {
1198 #if defined(__WIN95__)
1199     m_pageSetupData = NULL;
1200 #endif
1201     m_paperSize = wxSize(0, 0);
1202     m_minMarginTopLeft = wxPoint(0, 0);
1203     m_minMarginBottomRight = wxPoint(0, 0);
1204     m_marginTopLeft = wxPoint(0, 0);
1205     m_marginBottomRight = wxPoint(0, 0);
1206
1207     // Flags
1208     m_defaultMinMargins = FALSE;
1209     m_enableMargins = TRUE;
1210     m_enableOrientation = TRUE;
1211     m_enablePaper = TRUE;
1212     m_enablePrinter = TRUE;
1213     m_enableHelp = FALSE;
1214     m_getDefaultInfo = FALSE;
1215
1216     m_printData = printData;
1217
1218     // The wxPrintData paper size overrides these values, unless the size cannot
1219     // be found.
1220     CalculatePaperSizeFromId();
1221 }
1222
1223 wxPageSetupDialogData::~wxPageSetupDialogData()
1224 {
1225 #if defined(__WIN95__) && defined(__WXMSW__)
1226     PAGESETUPDLG *pd = (PAGESETUPDLG *)m_pageSetupData;
1227     if ( pd && pd->hDevMode )
1228         GlobalFree(pd->hDevMode);
1229     if ( pd && pd->hDevNames )
1230         GlobalFree(pd->hDevNames);
1231     if ( pd )
1232         delete pd;
1233 #endif
1234 }
1235
1236 wxPageSetupDialogData& wxPageSetupDialogData::operator=(const wxPageSetupDialogData& data)
1237 {
1238     m_paperSize = data.m_paperSize;
1239     m_minMarginTopLeft = data.m_minMarginTopLeft;
1240     m_minMarginBottomRight = data.m_minMarginBottomRight;
1241     m_marginTopLeft = data.m_marginTopLeft;
1242     m_marginBottomRight = data.m_marginBottomRight;
1243     m_defaultMinMargins = data.m_defaultMinMargins;
1244     m_enableMargins = data.m_enableMargins;
1245     m_enableOrientation = data.m_enableOrientation;
1246     m_enablePaper = data.m_enablePaper;
1247     m_enablePrinter = data.m_enablePrinter;
1248     m_getDefaultInfo = data.m_getDefaultInfo;;
1249     m_enableHelp = data.m_enableHelp;
1250
1251     m_printData = data.m_printData;
1252
1253     return *this;
1254 }
1255
1256 wxPageSetupDialogData& wxPageSetupDialogData::operator=(const wxPrintData& data)
1257 {
1258     m_printData = data;
1259
1260     return *this;
1261 }
1262
1263 #if defined(__WIN95__)
1264 void wxPageSetupDialogData::ConvertToNative()
1265 {
1266     m_printData.ConvertToNative();
1267
1268     PAGESETUPDLG *pd = (PAGESETUPDLG*) m_pageSetupData;
1269
1270     if ( m_pageSetupData == NULL )
1271     {
1272         pd = new PAGESETUPDLG;
1273         pd->hDevMode = NULL;
1274         pd->hDevNames = NULL;
1275         m_pageSetupData = (void *)pd;
1276     }
1277
1278     // Pass the devmode data (created in m_printData.ConvertToNative)
1279     // to the PRINTDLG structure, since it'll
1280     // be needed when PrintDlg is called.
1281
1282     if (pd->hDevMode)
1283     {
1284         GlobalFree(pd->hDevMode);
1285         pd->hDevMode = NULL;
1286     }
1287
1288     pd->hDevMode = (HGLOBAL) m_printData.GetNativeData();
1289
1290     m_printData.SetNativeData((void*) NULL);
1291
1292     // Shouldn't assert; we should be able to test Ok-ness at a higher level
1293     //wxASSERT_MSG( (pd->hDevMode), wxT("hDevMode must be non-NULL in ConvertToNative!"));
1294
1295     // Pass the devnames data (created in m_printData.ConvertToNative)
1296     // to the PRINTDLG structure, since it'll
1297     // be needed when PrintDlg is called.
1298
1299     if (pd->hDevNames)
1300     {
1301         GlobalFree(pd->hDevNames);
1302         pd->hDevNames = NULL;
1303     }
1304
1305     pd->hDevNames = (HGLOBAL) m_printData.GetNativeDataDevNames();
1306
1307     m_printData.SetNativeDataDevNames((void*) NULL);
1308
1309 //        pd->hDevMode = GlobalAlloc(GMEM_MOVEABLE, sizeof(DEVMODE));
1310
1311     pd->Flags = PSD_MARGINS|PSD_MINMARGINS;
1312
1313     if ( m_defaultMinMargins )
1314         pd->Flags |= PSD_DEFAULTMINMARGINS;
1315     if ( !m_enableMargins )
1316         pd->Flags |= PSD_DISABLEMARGINS;
1317     if ( !m_enableOrientation )
1318         pd->Flags |= PSD_DISABLEORIENTATION;
1319     if ( !m_enablePaper )
1320         pd->Flags |= PSD_DISABLEPAPER;
1321     if ( !m_enablePrinter )
1322         pd->Flags |= PSD_DISABLEPRINTER;
1323     if ( m_getDefaultInfo )
1324         pd->Flags |= PSD_RETURNDEFAULT;
1325     if ( m_enableHelp )
1326         pd->Flags |= PSD_SHOWHELP;
1327
1328     // We want the units to be in hundredths of a millimetre
1329     pd->Flags |= PSD_INHUNDREDTHSOFMILLIMETERS;
1330
1331     pd->lStructSize = sizeof( PAGESETUPDLG );
1332     pd->hwndOwner=(HWND)NULL;
1333 //    pd->hDevNames=(HWND)NULL;
1334     pd->hInstance=(HINSTANCE)NULL;
1335     //   PAGESETUPDLG is in hundreds of a mm
1336     pd->ptPaperSize.x = m_paperSize.x * 100;
1337     pd->ptPaperSize.y = m_paperSize.y * 100;
1338
1339     pd->rtMinMargin.left = m_minMarginTopLeft.x * 100;
1340     pd->rtMinMargin.top = m_minMarginTopLeft.y * 100;
1341     pd->rtMinMargin.right = m_minMarginBottomRight.x * 100;
1342     pd->rtMinMargin.bottom = m_minMarginBottomRight.y * 100;
1343
1344     pd->rtMargin.left = m_marginTopLeft.x * 100;
1345     pd->rtMargin.top = m_marginTopLeft.y * 100;
1346     pd->rtMargin.right = m_marginBottomRight.x * 100;
1347     pd->rtMargin.bottom = m_marginBottomRight.y * 100;
1348
1349     pd->lCustData = 0;
1350     pd->lpfnPageSetupHook = NULL;
1351     pd->lpfnPagePaintHook = NULL;
1352     pd->hPageSetupTemplate = NULL;
1353     pd->lpPageSetupTemplateName = NULL;
1354
1355 /*
1356     if ( pd->hDevMode )
1357     {
1358         DEVMODE *devMode = (DEVMODE*) GlobalLock(pd->hDevMode);
1359         memset(devMode, 0, sizeof(DEVMODE));
1360         devMode->dmSize = sizeof(DEVMODE);
1361         devMode->dmOrientation = m_orientation;
1362         devMode->dmFields = DM_ORIENTATION;
1363         GlobalUnlock(pd->hDevMode);
1364     }
1365 */
1366 }
1367
1368 void wxPageSetupDialogData::ConvertFromNative()
1369 {
1370     PAGESETUPDLG *pd = (PAGESETUPDLG *) m_pageSetupData;
1371     if ( !pd )
1372         return;
1373
1374     // Pass the devmode data back to the wxPrintData structure where it really belongs.
1375     if (pd->hDevMode)
1376     {
1377         if (m_printData.GetNativeData())
1378         {
1379             // Make sure we don't leak memory
1380             GlobalFree((HGLOBAL) m_printData.GetNativeData());
1381         }
1382         m_printData.SetNativeData((void*) pd->hDevMode);
1383         pd->hDevMode = NULL;
1384     }
1385
1386     m_printData.ConvertFromNative();
1387
1388     // Pass the devnames data back to the wxPrintData structure where it really belongs.
1389     if (pd->hDevNames)
1390     {
1391         if (m_printData.GetNativeDataDevNames())
1392         {
1393             // Make sure we don't leak memory
1394             GlobalFree((HGLOBAL) m_printData.GetNativeDataDevNames());
1395         }
1396         m_printData.SetNativeDataDevNames((void*) pd->hDevNames);
1397         pd->hDevNames = NULL;
1398     }
1399
1400     m_printData.ConvertFromNative();
1401
1402     pd->Flags = PSD_MARGINS|PSD_MINMARGINS;
1403
1404     m_defaultMinMargins = ((pd->Flags & PSD_DEFAULTMINMARGINS) == PSD_DEFAULTMINMARGINS);
1405     m_enableMargins = ((pd->Flags & PSD_DISABLEMARGINS) != PSD_DISABLEMARGINS);
1406     m_enableOrientation = ((pd->Flags & PSD_DISABLEORIENTATION) != PSD_DISABLEORIENTATION);
1407     m_enablePaper = ((pd->Flags & PSD_DISABLEPAPER) != PSD_DISABLEPAPER);
1408     m_enablePrinter = ((pd->Flags & PSD_DISABLEPRINTER) != PSD_DISABLEPRINTER);
1409     m_getDefaultInfo = ((pd->Flags & PSD_RETURNDEFAULT) == PSD_RETURNDEFAULT);
1410     m_enableHelp = ((pd->Flags & PSD_SHOWHELP) == PSD_SHOWHELP);
1411
1412     //   PAGESETUPDLG is in hundreds of a mm
1413     m_paperSize.x = pd->ptPaperSize.x / 100;
1414     m_paperSize.y = pd->ptPaperSize.y / 100;
1415
1416     m_minMarginTopLeft.x = pd->rtMinMargin.left / 100;
1417     m_minMarginTopLeft.y = pd->rtMinMargin.top / 100;
1418     m_minMarginBottomRight.x = pd->rtMinMargin.right / 100;
1419     m_minMarginBottomRight.y = pd->rtMinMargin.bottom / 100;
1420
1421     m_marginTopLeft.x = pd->rtMargin.left / 100;
1422     m_marginTopLeft.y = pd->rtMargin.top / 100;
1423     m_marginBottomRight.x = pd->rtMargin.right / 100;
1424     m_marginBottomRight.y = pd->rtMargin.bottom / 100;
1425 }
1426
1427 void wxPageSetupDialogData::SetOwnerWindow(wxWindow* win)
1428 {
1429     if ( m_pageSetupData == NULL )
1430         ConvertToNative();
1431
1432     if ( m_pageSetupData != NULL && win != NULL)
1433     {
1434         PAGESETUPDLG *pd = (PAGESETUPDLG *) m_pageSetupData;
1435         pd->hwndOwner=(HWND) win->GetHWND();
1436     }
1437 }
1438 #endif // Win95
1439
1440 #ifdef __WXMAC__
1441 void wxPageSetupDialogData::ConvertToNative()
1442 {
1443     m_printData.ConvertToNative();
1444     // on mac the paper rect has a negative top left corner, because the page rect (printable area) is at 0,0
1445 #if TARGET_CARBON
1446 #else
1447     (**(THPrint)m_printData.m_macPrintSettings).rPaper.left = int( ((double) m_minMarginTopLeft.x)*mm2pt );
1448     (**(THPrint)m_printData.m_macPrintSettings).rPaper.top = int( ((double) m_minMarginTopLeft.y)*mm2pt );
1449
1450     (**(THPrint)m_printData.m_macPrintSettings).rPaper.right = int( ((double) m_paperSize.x - m_minMarginTopLeft.x)*mm2pt );
1451     (**(THPrint)m_printData.m_macPrintSettings).rPaper.bottom = int( ((double) m_paperSize.y - m_minMarginTopLeft.y)*mm2pt );
1452
1453     (**(THPrint)m_printData.m_macPrintSettings).prInfo.rPage.left = 0;
1454     (**(THPrint)m_printData.m_macPrintSettings).prInfo.rPage.top = 0;
1455     (**(THPrint)m_printData.m_macPrintSettings).prInfo.rPage.right =  int( ((double) m_paperSize.x - m_minMarginTopLeft.x - m_minMarginBottomRight.x)*mm2pt );
1456     (**(THPrint)m_printData.m_macPrintSettings).prInfo.rPage.bottom =  int( ((double) m_paperSize.y - m_minMarginTopLeft.y - m_minMarginBottomRight.y)*mm2pt );
1457 #endif
1458 }
1459
1460 void wxPageSetupDialogData::ConvertFromNative()
1461 {
1462     m_printData.ConvertFromNative ();
1463
1464 #if TARGET_CARBON
1465         PMRect rPaper;
1466
1467         OSStatus err = PMGetAdjustedPaperRect((PMPageFormat)m_printData.m_macPageFormat, &rPaper);
1468     if ( err == noErr )
1469     {
1470             m_paperSize.x = (int)(((double) rPaper.right - rPaper.left ) * pt2mm);
1471             m_paperSize.y = (int)(((double) rPaper.bottom - rPaper.top ) * pt2mm);
1472
1473             m_minMarginTopLeft.x = (int)(((double) - rPaper.left ) * pt2mm);
1474             m_minMarginTopLeft.y = (int)(((double) - rPaper.top ) * pt2mm);
1475
1476 //          m_minMarginBottomRight.x = ((double) rPaper.right - (**(THPrint)m_printData.m_macPrintSettings).prInfo.rPage.right ) * pt2mm;
1477 //          m_minMarginBottomRight.y = ((double)(**(THPrint)m_printData.m_macPrintSettings).rPaper.bottom - (**(THPrint)m_printData.m_macPrintSettings).prInfo.rPage.bottom ) * pt2mm;
1478     }
1479 #else
1480     m_paperSize.x = ((double) (**(THPrint)m_printData.m_macPrintSettings).rPaper.right - (**(THPrint)m_printData.m_macPrintSettings).rPaper.left ) * pt2mm;
1481     m_paperSize.y = ((double) (**(THPrint)m_printData.m_macPrintSettings).rPaper.bottom - (**(THPrint)m_printData.m_macPrintSettings).rPaper.top ) * pt2mm;
1482
1483     m_minMarginTopLeft.x = ((double) -(**(THPrint)m_printData.m_macPrintSettings).rPaper.left ) * pt2mm;
1484     m_minMarginTopLeft.y = ((double) -(**(THPrint)m_printData.m_macPrintSettings).rPaper.top ) * pt2mm;
1485
1486     m_minMarginBottomRight.x = ((double) (**(THPrint)m_printData.m_macPrintSettings).rPaper.right - (**(THPrint)m_printData.m_macPrintSettings).prInfo.rPage.right ) * pt2mm;
1487     m_minMarginBottomRight.y = ((double)(**(THPrint)m_printData.m_macPrintSettings).rPaper.bottom - (**(THPrint)m_printData.m_macPrintSettings).prInfo.rPage.bottom ) * pt2mm;
1488 #endif
1489     // adjust minimal values
1490     //TODO add custom fields in dialog for margins
1491
1492     if ( m_marginTopLeft.x < m_minMarginTopLeft.x )
1493         m_marginTopLeft.x = m_minMarginTopLeft.x;
1494
1495     if ( m_marginBottomRight.x < m_minMarginBottomRight.x )
1496         m_marginBottomRight.x = m_minMarginBottomRight.x;
1497
1498     if ( m_marginTopLeft.y < m_minMarginTopLeft.y )
1499         m_marginTopLeft.y = m_minMarginTopLeft.y;
1500
1501     if ( m_marginBottomRight.y < m_minMarginBottomRight.y )
1502         m_marginBottomRight.y = m_minMarginBottomRight.y;
1503 }
1504 #endif
1505
1506
1507 // If a corresponding paper type is found in the paper database, will set the m_printData
1508 // paper size id member as well.
1509 void wxPageSetupDialogData::SetPaperSize(const wxSize& sz)
1510 {
1511     m_paperSize = sz;
1512
1513     CalculateIdFromPaperSize();
1514 }
1515
1516 // Sets the wxPrintData id, plus the paper width/height if found in the paper database.
1517 void wxPageSetupDialogData::SetPaperSize(wxPaperSize id)
1518 {
1519     m_printData.SetPaperId(id);
1520
1521     CalculatePaperSizeFromId();
1522 }
1523
1524 // Use paper size defined in this object to set the wxPrintData
1525 // paper id
1526 void wxPageSetupDialogData::CalculateIdFromPaperSize()
1527 {
1528     wxASSERT_MSG( (wxThePrintPaperDatabase != (wxPrintPaperDatabase*) NULL),
1529                   wxT("wxThePrintPaperDatabase should not be NULL. Do not create global print dialog data objects.") );
1530
1531     wxSize sz = GetPaperSize();
1532
1533     wxPaperSize id = wxThePrintPaperDatabase->GetSize(wxSize(sz.x* 10, sz.y * 10));
1534     if (id != wxPAPER_NONE)
1535     {
1536         m_printData.SetPaperId(id);
1537     }
1538 }
1539
1540 // Use paper id in wxPrintData to set this object's paper size
1541 void wxPageSetupDialogData::CalculatePaperSizeFromId()
1542 {
1543     wxASSERT_MSG( (wxThePrintPaperDatabase != (wxPrintPaperDatabase*) NULL),
1544                   wxT("wxThePrintPaperDatabase should not be NULL. Do not create global print dialog data objects.") );
1545
1546     wxSize sz = wxThePrintPaperDatabase->GetSize(m_printData.GetPaperId());
1547
1548     // sz is in 10ths of a mm, while paper size is in mm
1549     m_paperSize.x = sz.x / 10;
1550     m_paperSize.y = sz.y / 10;
1551 }
1552
1553 #endif // wxUSE_PRINTING_ARCHITECTURE