src/msw/printdlg.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        printdlg.cpp
   3 // Purpose:     wxPrintDialog, wxPageSetupDialog
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ===========================================================================
  13 // declarations
  14 // ===========================================================================
  15
  16 // ---------------------------------------------------------------------------
  17 // headers
  18 // ---------------------------------------------------------------------------
  19
  20 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  21     #pragma implementation "printdlg.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 // Don't use the Windows print dialog if we're in wxUniv mode and using
  32 // the PostScript architecture
  33 #if wxUSE_PRINTING_ARCHITECTURE && (!defined(__WXUNIVERSAL__) || !wxUSE_POSTSCRIPT_ARCHITECTURE_IN_MSW)
  34
  35 #ifndef WX_PRECOMP
  36     #include "wx/app.h"
  37 #endif
  38
  39 #include "wx/cmndata.h"
  40 #include "wx/printdlg.h"
  41 #include "wx/msw/printdlg.h"
  42 #include "wx/dcprint.h"
  43 #include "wx/paper.h"
  44
  45 #include <stdlib.h>
  46
  47 #include "wx/msw/wrapcdlg.h"
  48
  49 #ifndef __WIN32__
  50     #include <print.h>
  51 #endif
  52
  53 //----------------------------------------------------------------------------
  54 // wxWindowsPrintNativeData
  55 //----------------------------------------------------------------------------
  56
  57 #ifdef __WXDEBUG__
  58 static wxString wxGetPrintDlgError()
  59 {
  60     DWORD err = CommDlgExtendedError();
  61     wxString msg = wxT("Unknown");
  62     switch (err)
  63     {
  64         case CDERR_FINDRESFAILURE: msg = wxT("CDERR_FINDRESFAILURE"); break;
  65         case CDERR_INITIALIZATION: msg = wxT("CDERR_INITIALIZATION"); break;
  66         case CDERR_LOADRESFAILURE: msg = wxT("CDERR_LOADRESFAILURE"); break;
  67         case CDERR_LOADSTRFAILURE: msg = wxT("CDERR_LOADSTRFAILURE"); break;
  68         case CDERR_LOCKRESFAILURE: msg = wxT("CDERR_LOCKRESFAILURE"); break;
  69         case CDERR_MEMALLOCFAILURE: msg = wxT("CDERR_MEMALLOCFAILURE"); break;
  70         case CDERR_MEMLOCKFAILURE: msg = wxT("CDERR_MEMLOCKFAILURE"); break;
  71         case CDERR_NOHINSTANCE: msg = wxT("CDERR_NOHINSTANCE"); break;
  72         case CDERR_NOHOOK: msg = wxT("CDERR_NOHOOK"); break;
  73         case CDERR_NOTEMPLATE: msg = wxT("CDERR_NOTEMPLATE"); break;
  74         case CDERR_STRUCTSIZE: msg = wxT("CDERR_STRUCTSIZE"); break;
  75         case  PDERR_RETDEFFAILURE: msg = wxT("PDERR_RETDEFFAILURE"); break;
  76         case  PDERR_PRINTERNOTFOUND: msg = wxT("PDERR_PRINTERNOTFOUND"); break;
  77         case  PDERR_PARSEFAILURE: msg = wxT("PDERR_PARSEFAILURE"); break;
  78         case  PDERR_NODEVICES: msg = wxT("PDERR_NODEVICES"); break;
  79         case  PDERR_NODEFAULTPRN: msg = wxT("PDERR_NODEFAULTPRN"); break;
  80         case  PDERR_LOADDRVFAILURE: msg = wxT("PDERR_LOADDRVFAILURE"); break;
  81         case  PDERR_INITFAILURE: msg = wxT("PDERR_INITFAILURE"); break;
  82         case  PDERR_GETDEVMODEFAIL: msg = wxT("PDERR_GETDEVMODEFAIL"); break;
  83         case  PDERR_DNDMMISMATCH: msg = wxT("PDERR_DNDMMISMATCH"); break;
  84         case  PDERR_DEFAULTDIFFERENT: msg = wxT("PDERR_DEFAULTDIFFERENT"); break;
  85         case  PDERR_CREATEICFAILURE: msg = wxT("PDERR_CREATEICFAILURE"); break;
  86         default: break;
  87     }
  88     return msg;
  89 }
  90 #endif
  91
  92 static HGLOBAL wxCreateDevNames(const wxString& driverName, const wxString& printerName, const wxString& portName)
  93 {
  94     HGLOBAL hDev = NULL;
  95     // if (!driverName.empty() && !printerName.empty() && !portName.empty())
  96     if (driverName.empty() && printerName.empty() && portName.empty())
  97     {
  98     }
  99     else
 100     {
 101         hDev = GlobalAlloc(GPTR, 4*sizeof(WORD)+
 102                            ( driverName.Length() + 1 +
 103             printerName.Length() + 1 +
 104                              portName.Length()+1 ) * sizeof(wxChar) );
 105         LPDEVNAMES lpDev = (LPDEVNAMES)GlobalLock(hDev);
 106         lpDev->wDriverOffset = sizeof(WORD) * 4 / sizeof(wxChar);
 107         wxStrcpy((wxChar*)lpDev + lpDev->wDriverOffset, driverName);
 108
 109         lpDev->wDeviceOffset = (WORD)( lpDev->wDriverOffset +
 110                                        driverName.Length() + 1 );
 111         wxStrcpy((wxChar*)lpDev + lpDev->wDeviceOffset, printerName);
 112
 113         lpDev->wOutputOffset = (WORD)( lpDev->wDeviceOffset +
 114                                        printerName.Length() + 1 );
 115         wxStrcpy((wxChar*)lpDev + lpDev->wOutputOffset, portName);
 116
 117         lpDev->wDefault = 0;
 118
 119         GlobalUnlock(hDev);
 120     }
 121
 122     return hDev;
 123 }
 124
 125 IMPLEMENT_CLASS(wxWindowsPrintNativeData, wxPrintNativeDataBase)
 126
 127 wxWindowsPrintNativeData::wxWindowsPrintNativeData()
 128 {
 129     m_devMode = (void*) NULL;
 130     m_devNames = (void*) NULL;
 131 }
 132
 133 wxWindowsPrintNativeData::~wxWindowsPrintNativeData()
 134 {
 135     HGLOBAL hDevMode = (HGLOBAL)(DWORD) m_devMode;
 136     if ( hDevMode )
 137         GlobalFree(hDevMode);
 138     HGLOBAL hDevNames = (HGLOBAL)(DWORD) m_devNames;
 139     if ( hDevNames )
 140         GlobalFree(hDevNames);
 141 }
 142
 143 bool wxWindowsPrintNativeData::Ok() const
 144 {
 145     return (m_devMode != NULL) ;
 146 }
 147
 148 bool wxWindowsPrintNativeData::TransferTo( wxPrintData &data )
 149 {
 150     HGLOBAL hDevMode = (HGLOBAL)(DWORD) m_devMode;
 151     HGLOBAL hDevNames = (HGLOBAL)(DWORD) m_devNames;
 152
 153     if (!hDevMode)
 154         return false;
 155
 156     if ( hDevMode )
 157     {
 158         LPDEVMODE devMode = (LPDEVMODE)GlobalLock(hDevMode);
 159
 160         //// Orientation
 161         if (devMode->dmFields & DM_ORIENTATION)
 162             data.SetOrientation( devMode->dmOrientation );
 163
 164         //// Collation
 165         if (devMode->dmFields & DM_COLLATE)
 166         {
 167             if (devMode->dmCollate == DMCOLLATE_TRUE)
 168                 data.SetCollate( true );
 169             else
 170                 data.SetCollate( false );
 171         }
 172
 173         //// Number of copies
 174         if (devMode->dmFields & DM_COPIES)
 175             data.SetNoCopies( devMode->dmCopies );
 176
 177         if (devMode->dmFields & DM_DEFAULTSOURCE)
 178             data.SetBin( (wxPrintBin)devMode->dmDefaultSource );
 179
 180         //// Printer name
 181         if (devMode->dmDeviceName[0] != 0)
 182             data.SetPrinterName( devMode->dmDeviceName );
 183
 184         //// Colour
 185         if (devMode->dmFields & DM_COLOR)
 186         {
 187             if (devMode->dmColor == DMCOLOR_COLOR)
 188                 data.SetColour( true );
 189             else
 190                 data.SetColour( false );
 191         }
 192         else
 193             data.SetColour( true );
 194
 195         //// Paper size
 196
 197         // We don't know size of user defined paper and some buggy drivers
 198         // set both DM_PAPERSIZE and DM_PAPERWIDTH & DM_PAPERLENGTH. Since
 199         // dmPaperSize >= DMPAPER_USER wouldn't be in wxWin's database, this
 200         // code wouldn't set m_paperSize correctly.
 201         if ((devMode->dmFields & DM_PAPERSIZE) && (devMode->dmPaperSize < DMPAPER_USER))
 202         {
 203             if (wxThePrintPaperDatabase)
 204             {
 205                 wxPrintPaperType* paper = wxThePrintPaperDatabase->FindPaperTypeByPlatformId(devMode->dmPaperSize);
 206                 if (paper)
 207                 {
 208                     data.SetPaperId( paper->GetId() );
 209                     data.SetPaperSize( wxSize(paper->GetWidth() / 10,paper->GetHeight() / 10) );
 210                 }
 211                 else
 212                 {
 213                     // Shouldn't really get here
 214                     wxFAIL_MSG(wxT("Couldn't find paper size in paper database."));
 215                     data.SetPaperId( wxPAPER_NONE );
 216                     data.SetPaperSize( wxSize(0,0) );
 217                 }
 218             }
 219             else
 220             {
 221                 // Shouldn't really get here
 222                 wxFAIL_MSG(wxT("Paper database wasn't initialized in wxPrintData::ConvertFromNative."));
 223                 data.SetPaperId( wxPAPER_NONE );
 224                 data.SetPaperSize( wxSize(0,0) );
 225             }
 226         }
 227         else if ((devMode->dmFields & DM_PAPERWIDTH) && (devMode->dmFields & DM_PAPERLENGTH))
 228         {
 229             // DEVMODE is in tenths of a milimeter
 230             data.SetPaperId( wxPAPER_NONE );
 231             data.SetPaperSize( wxSize(devMode->dmPaperWidth / 10, devMode->dmPaperLength / 10) );
 232         }
 233         else
 234         {
 235             // Shouldn't really get here
 236             wxFAIL_MSG(wxT("Couldn't find paper size from DEVMODE."));
 237             data.SetPaperId( wxPAPER_NONE );
 238             data.SetPaperSize( wxSize(0,0) );
 239         }
 240
 241         //// Duplex
 242
 243         if (devMode->dmFields & DM_DUPLEX)
 244         {
 245             switch (devMode->dmDuplex)
 246             {
 247                 case DMDUP_HORIZONTAL:   data.SetDuplex( wxDUPLEX_HORIZONTAL ); break;
 248                 case DMDUP_VERTICAL:     data.SetDuplex( wxDUPLEX_VERTICAL ); break;
 249                 default:
 250                 case DMDUP_SIMPLEX:      data.SetDuplex( wxDUPLEX_SIMPLEX ); break;
 251             }
 252         }
 253         else
 254             data.SetDuplex( wxDUPLEX_SIMPLEX );
 255
 256         //// Quality
 257
 258         if (devMode->dmFields & DM_PRINTQUALITY)
 259         {
 260             switch (devMode->dmPrintQuality)
 261             {
 262                 case DMRES_MEDIUM:  data.SetQuality( wxPRINT_QUALITY_MEDIUM ); break;
 263                 case DMRES_LOW:     data.SetQuality( wxPRINT_QUALITY_LOW ); break;
 264                 case DMRES_DRAFT:   data.SetQuality( wxPRINT_QUALITY_DRAFT ); break;
 265                 case DMRES_HIGH:    data.SetQuality( wxPRINT_QUALITY_HIGH ); break;
 266                 default:
 267                 {
 268                     // TODO: if the printer fills in the resolution in DPI, how
 269                     // will the application know if it's high, low, draft etc.??
 270                     //                    wxFAIL_MSG("Warning: DM_PRINTQUALITY was not one of the standard values.");
 271                     data.SetQuality( devMode->dmPrintQuality );
 272                     break;
 273
 274                 }
 275             }
 276         }
 277         else
 278             data.SetQuality( wxPRINT_QUALITY_HIGH );
 279
 280         if (devMode->dmDriverExtra > 0)
 281             data.SetPrivData( (char *)devMode+devMode->dmSize, devMode->dmDriverExtra );
 282         else
 283             data.SetPrivData( NULL, 0 );
 284
 285         GlobalUnlock(hDevMode);
 286     }
 287
 288     if (hDevNames)
 289     {
 290         LPDEVNAMES lpDevNames = (LPDEVNAMES)GlobalLock(hDevNames);
 291         if (lpDevNames)
 292         {
 293             // TODO: Unicode-ification
 294
 295             // Get the port name
 296             // port is obsolete in WIN32
 297             // m_printData.SetPortName((LPSTR)lpDevNames + lpDevNames->wDriverOffset);
 298
 299             // Get the printer name
 300             wxString printerName = (LPTSTR)lpDevNames + lpDevNames->wDeviceOffset;
 301
 302             // Not sure if we should check for this mismatch
 303 //            wxASSERT_MSG( (m_printerName.empty() || (devName == m_printerName)), "Printer name obtained from DEVMODE and DEVNAMES were different!");
 304
 305             if (!printerName.empty())
 306                 data.SetPrinterName( printerName );
 307
 308             GlobalUnlock(hDevNames);
 309         }
 310     }
 311
 312     return true;
 313 }
 314
 315 bool wxWindowsPrintNativeData::TransferFrom( const wxPrintData &data )
 316 {
 317     HGLOBAL hDevMode = (HGLOBAL)(DWORD) m_devMode;
 318     HGLOBAL hDevNames = (HGLOBAL)(DWORD) m_devNames;
 319     if (!hDevMode)
 320     {
 321         // Use PRINTDLG as a way of creating a DEVMODE object
 322         PRINTDLG pd;
 323
 324         // GNU-WIN32 has the wrong size PRINTDLG - can't work out why.
 325 #ifdef __GNUWIN32__
 326         memset(&pd, 0, 66);
 327         pd.lStructSize    = 66;
 328 #else
 329         memset(&pd, 0, sizeof(PRINTDLG));
 330 #ifdef __WXWINCE__
 331         pd.cbStruct    = sizeof(PRINTDLG);
 332 #else
 333         pd.lStructSize    = sizeof(PRINTDLG);
 334 #endif
 335 #endif
 336
 337         pd.hwndOwner      = (HWND)NULL;
 338         pd.hDevMode       = NULL; // Will be created by PrintDlg
 339         pd.hDevNames      = NULL; // Ditto
 340         //pd.hInstance      = (HINSTANCE) wxGetInstance();
 341
 342         pd.Flags          = PD_RETURNDEFAULT;
 343         pd.nCopies        = 1;
 344
 345         // Fill out the DEVMODE structure
 346         // so we can use it as input in the 'real' PrintDlg
 347         if (!PrintDlg(&pd))
 348         {
 349             if ( pd.hDevMode )
 350                 GlobalFree(pd.hDevMode);
 351             if ( pd.hDevNames )
 352                 GlobalFree(pd.hDevNames);
 353             pd.hDevMode = NULL;
 354             pd.hDevNames = NULL;
 355
 356 #if defined(__WXDEBUG__) && defined(__WIN32__)
 357             wxString str(wxT("Printing error: "));
 358             str += wxGetPrintDlgError();
 359             wxLogDebug(str);
 360 #endif
 361         }
 362         else
 363         {
 364             hDevMode = pd.hDevMode;
 365             m_devMode = (void*)(long) hDevMode;
 366             pd.hDevMode = NULL;
 367
 368             // We'll create a new DEVNAMEs structure below.
 369             if ( pd.hDevNames )
 370                 GlobalFree(pd.hDevNames);
 371             pd.hDevNames = NULL;
 372
 373             // hDevNames = pd->hDevNames;
 374             // m_devNames = (void*)(long) hDevNames;
 375             // pd->hDevnames = NULL;
 376
 377         }
 378     }
 379
 380     if ( hDevMode )
 381     {
 382         LPDEVMODE devMode = (LPDEVMODE) GlobalLock(hDevMode);
 383
 384         //// Orientation
 385         devMode->dmOrientation = (short)data.GetOrientation();
 386
 387         //// Collation
 388         devMode->dmCollate = (data.GetCollate() ? DMCOLLATE_TRUE : DMCOLLATE_FALSE);
 389         devMode->dmFields |= DM_COLLATE;
 390
 391         //// Number of copies
 392         devMode->dmCopies = (short)data.GetNoCopies();
 393         devMode->dmFields |= DM_COPIES;
 394
 395         //// Printer name
 396         wxString name = data.GetPrinterName();
 397         if (!name.empty())
 398         {
 399             //int len = wxMin(31, m_printerName.Len());
 400             wxStrncpy((wxChar*)devMode->dmDeviceName,name.c_str(),31);
 401             devMode->dmDeviceName[31] = wxT('\0');
 402         }
 403
 404         //// Colour
 405         if (data.GetColour())
 406             devMode->dmColor = DMCOLOR_COLOR;
 407         else
 408             devMode->dmColor = DMCOLOR_MONOCHROME;
 409         devMode->dmFields |= DM_COLOR;
 410
 411         //// Paper size
 412         if (data.GetPaperId() == wxPAPER_NONE)
 413         {
 414             // DEVMODE is in tenths of a milimeter
 415             devMode->dmPaperWidth = (short)(data.GetPaperSize().x * 10);
 416             devMode->dmPaperLength = (short)(data.GetPaperSize().y * 10);
 417             devMode->dmPaperSize = DMPAPER_USER;
 418             devMode->dmFields |= DM_PAPERWIDTH;
 419             devMode->dmFields |= DM_PAPERLENGTH;
 420         }
 421         else
 422         {
 423             if (wxThePrintPaperDatabase)
 424             {
 425                 wxPrintPaperType* paper = wxThePrintPaperDatabase->FindPaperType( data.GetPaperId() );
 426                 if (paper)
 427                 {
 428                     devMode->dmPaperSize = (short)paper->GetPlatformId();
 429                     devMode->dmFields |= DM_PAPERSIZE;
 430                 }
 431             }
 432         }
 433
 434         //// Duplex
 435         short duplex;
 436         switch (data.GetDuplex())
 437         {
 438             case wxDUPLEX_HORIZONTAL:
 439                 duplex = DMDUP_HORIZONTAL;
 440                 break;
 441             case wxDUPLEX_VERTICAL:
 442                 duplex = DMDUP_VERTICAL;
 443                 break;
 444             default:
 445             // in fact case wxDUPLEX_SIMPLEX:
 446                 duplex = DMDUP_SIMPLEX;
 447                 break;
 448         }
 449         devMode->dmDuplex = duplex;
 450         devMode->dmFields |= DM_DUPLEX;
 451
 452         //// Quality
 453
 454         short quality;
 455         switch (data.GetQuality())
 456         {
 457             case wxPRINT_QUALITY_MEDIUM:
 458                 quality = DMRES_MEDIUM;
 459                 break;
 460             case wxPRINT_QUALITY_LOW:
 461                 quality = DMRES_LOW;
 462                 break;
 463             case wxPRINT_QUALITY_DRAFT:
 464                 quality = DMRES_DRAFT;
 465                 break;
 466             case wxPRINT_QUALITY_HIGH:
 467                 quality = DMRES_HIGH;
 468                 break;
 469             default:
 470                 quality = (short)data.GetQuality();
 471                 break;
 472         }
 473         devMode->dmPrintQuality = quality;
 474         devMode->dmFields |= DM_PRINTQUALITY;
 475
 476         if (data.GetPrivDataLen() > 0)
 477         {
 478             memcpy( (char *)devMode+devMode->dmSize, data.GetPrivData(), data.GetPrivDataLen() );
 479             devMode->dmDriverExtra = (WXWORD)data.GetPrivDataLen();
 480         }
 481
 482         if (data.GetBin() != wxPRINTBIN_DEFAULT)
 483         {
 484             switch (data.GetBin())
 485             {
 486                 case wxPRINTBIN_ONLYONE:        devMode->dmDefaultSource = DMBIN_ONLYONE;       break;
 487                 case wxPRINTBIN_LOWER:          devMode->dmDefaultSource = DMBIN_LOWER;         break;
 488                 case wxPRINTBIN_MIDDLE:         devMode->dmDefaultSource = DMBIN_MIDDLE;        break;
 489                 case wxPRINTBIN_MANUAL:         devMode->dmDefaultSource = DMBIN_MANUAL;        break;
 490                 case wxPRINTBIN_ENVELOPE:       devMode->dmDefaultSource = DMBIN_ENVELOPE;      break;
 491                 case wxPRINTBIN_ENVMANUAL:      devMode->dmDefaultSource = DMBIN_ENVMANUAL;     break;
 492                 case wxPRINTBIN_AUTO:           devMode->dmDefaultSource = DMBIN_AUTO;          break;
 493                 case wxPRINTBIN_TRACTOR:        devMode->dmDefaultSource = DMBIN_TRACTOR;       break;
 494                 case wxPRINTBIN_SMALLFMT:       devMode->dmDefaultSource = DMBIN_SMALLFMT;      break;
 495                 case wxPRINTBIN_LARGEFMT:       devMode->dmDefaultSource = DMBIN_LARGEFMT;      break;
 496                 case wxPRINTBIN_LARGECAPACITY:  devMode->dmDefaultSource = DMBIN_LARGECAPACITY; break;
 497                 case wxPRINTBIN_CASSETTE:       devMode->dmDefaultSource = DMBIN_CASSETTE;      break;
 498                 case wxPRINTBIN_FORMSOURCE:     devMode->dmDefaultSource = DMBIN_FORMSOURCE;    break;
 499
 500                 default:
 501                     devMode->dmDefaultSource = (short)(DMBIN_USER + data.GetBin() - wxPRINTBIN_USER);
 502                     break;
 503             }
 504
 505             devMode->dmFields |= DM_DEFAULTSOURCE;
 506         }
 507
 508         GlobalUnlock(hDevMode);
 509     }
 510
 511     if ( hDevNames )
 512     {
 513         GlobalFree(hDevNames);
 514     }
 515
 516     // TODO: I hope it's OK to pass some empty strings to DEVNAMES.
 517     m_devNames = (void*) (long) wxCreateDevNames(wxEmptyString, data.GetPrinterName(), wxEmptyString);
 518
 519     return true;
 520 }
 521
 522 // ---------------------------------------------------------------------------
 523 // wxPrintDialog
 524 // ---------------------------------------------------------------------------
 525
 526 IMPLEMENT_CLASS(wxWindowsPrintDialog, wxPrintDialogBase)
 527
 528 wxWindowsPrintDialog::wxWindowsPrintDialog(wxWindow *p, wxPrintDialogData* data)
 529 {
 530     Create(p, data);
 531 }
 532
 533 wxWindowsPrintDialog::wxWindowsPrintDialog(wxWindow *p, wxPrintData* data)
 534 {
 535     wxPrintDialogData data2;
 536     if ( data )
 537         data2 = *data;
 538
 539     Create(p, &data2);
 540 }
 541
 542 bool wxWindowsPrintDialog::Create(wxWindow *p, wxPrintDialogData* data)
 543 {
 544     m_dialogParent = p;
 545     m_printerDC = NULL;
 546     m_destroyDC = true;
 547
 548     // MSW handle
 549     m_printDlg = NULL;
 550
 551     if ( data )
 552         m_printDialogData = *data;
 553
 554     return true;
 555 }
 556
 557 wxWindowsPrintDialog::~wxWindowsPrintDialog()
 558 {
 559     PRINTDLG *pd = (PRINTDLG *) m_printDlg;
 560     if (pd && pd->hDevMode)
 561         GlobalFree(pd->hDevMode);
 562     if ( pd )
 563         delete pd;
 564
 565     if (m_destroyDC && m_printerDC)
 566         delete m_printerDC;
 567 }
 568
 569 int wxWindowsPrintDialog::ShowModal()
 570 {
 571     ConvertToNative( m_printDialogData );
 572
 573     PRINTDLG *pd = (PRINTDLG*) m_printDlg;
 574
 575     if (m_dialogParent)
 576         pd->hwndOwner = (HWND) m_dialogParent->GetHWND();
 577     else if (wxTheApp->GetTopWindow())
 578         pd->hwndOwner = (HWND) wxTheApp->GetTopWindow()->GetHWND();
 579     else
 580         pd->hwndOwner = 0;
 581
 582     bool ret = (PrintDlg( pd ) != 0);
 583
 584     pd->hwndOwner = 0;
 585
 586     if ( ret != false && (pd->hDC) )
 587     {
 588         wxPrinterDC *pdc = new wxPrinterDC( (WXHDC) pd->hDC );
 589         m_printerDC = pdc;
 590         ConvertFromNative( m_printDialogData );
 591         return wxID_OK;
 592     }
 593     else
 594     {
 595         return wxID_CANCEL;
 596     }
 597 }
 598
 599 wxDC *wxWindowsPrintDialog::GetPrintDC()
 600 {
 601     if (m_printerDC)
 602     {
 603         m_destroyDC = false;
 604         return m_printerDC;
 605     }
 606     else
 607         return (wxDC*) NULL;
 608 }
 609
 610 bool wxWindowsPrintDialog::ConvertToNative( wxPrintDialogData &data )
 611 {
 612     wxWindowsPrintNativeData *native_data =
 613         (wxWindowsPrintNativeData *) data.GetPrintData().GetNativeData();
 614     data.GetPrintData().ConvertToNative();
 615
 616     PRINTDLG *pd = (PRINTDLG*) m_printDlg;
 617
 618     // Shouldn't have been defined anywhere
 619     if (pd)
 620         return false;
 621
 622     pd = new PRINTDLG;
 623     memset( pd, 0, sizeof(PRINTDLG) );
 624     m_printDlg = (void*) pd;
 625
 626     // GNU-WIN32 has the wrong size PRINTDLG - can't work out why.
 627 #ifdef __GNUWIN32__
 628     pd->lStructSize    = 66;
 629 #else
 630     pd->lStructSize    = sizeof(PRINTDLG);
 631 #endif
 632     pd->hwndOwner      = (HWND)NULL;
 633     pd->hDevMode       = NULL; // Will be created by PrintDlg
 634     pd->hDevNames      = NULL; // Ditto
 635
 636     pd->Flags          = PD_RETURNDEFAULT;
 637     pd->nCopies        = 1;
 638
 639     // Pass the devmode data to the PRINTDLG structure, since it'll
 640     // be needed when PrintDlg is called.
 641     if (pd->hDevMode)
 642         GlobalFree(pd->hDevMode);
 643
 644     // Pass the devnames data to the PRINTDLG structure, since it'll
 645     // be needed when PrintDlg is called.
 646     if (pd->hDevNames)
 647         GlobalFree(pd->hDevNames);
 648
 649     pd->hDevMode = (HGLOBAL)(DWORD) native_data->GetDevMode();
 650     native_data->SetDevMode( (void*) NULL);
 651
 652     // Shouldn't assert; we should be able to test Ok-ness at a higher level
 653     //wxASSERT_MSG( (pd->hDevMode), wxT("hDevMode must be non-NULL in ConvertToNative!"));
 654
 655     pd->hDevNames = (HGLOBAL)(DWORD) native_data->GetDevNames();
 656     native_data->SetDevNames( (void*) NULL);
 657
 658
 659     pd->hDC = (HDC) NULL;
 660     pd->nFromPage = (WORD)data.GetFromPage();
 661     pd->nToPage = (WORD)data.GetToPage();
 662     pd->nMinPage = (WORD)data.GetMinPage();
 663     pd->nMaxPage = (WORD)data.GetMaxPage();
 664     pd->nCopies = (WORD)data.GetNoCopies();
 665
 666     pd->Flags = PD_RETURNDC;
 667
 668 #ifdef __GNUWIN32__
 669     pd->lStructSize = 66;
 670 #else
 671     pd->lStructSize = sizeof( PRINTDLG );
 672 #endif
 673
 674     pd->hwndOwner=(HWND)NULL;
 675 //    pd->hDevNames=(HANDLE)NULL;
 676     pd->hInstance=(HINSTANCE)NULL;
 677     pd->lCustData = (LPARAM) NULL;
 678     pd->lpfnPrintHook = NULL;
 679     pd->lpfnSetupHook = NULL;
 680     pd->lpPrintTemplateName = NULL;
 681     pd->lpSetupTemplateName = NULL;
 682     pd->hPrintTemplate = (HGLOBAL) NULL;
 683     pd->hSetupTemplate = (HGLOBAL) NULL;
 684
 685     if ( data.GetAllPages() )
 686         pd->Flags |= PD_ALLPAGES;
 687     if ( data.GetSelection() )
 688         pd->Flags |= PD_SELECTION;
 689     if ( data.GetCollate() )
 690         pd->Flags |= PD_COLLATE;
 691     if ( data.GetPrintToFile() )
 692         pd->Flags |= PD_PRINTTOFILE;
 693     if ( !data.GetEnablePrintToFile() )
 694         pd->Flags |= PD_DISABLEPRINTTOFILE;
 695     if ( !data.GetEnableSelection() )
 696         pd->Flags |= PD_NOSELECTION;
 697     if ( !data.GetEnablePageNumbers() )
 698         pd->Flags |= PD_NOPAGENUMS;
 699     else if ( (!data.GetAllPages()) && (!data.GetSelection()) && (data.GetFromPage() != 0) && (data.GetToPage() != 0))
 700         pd->Flags |= PD_PAGENUMS;
 701     if ( data.GetEnableHelp() )
 702         pd->Flags |= PD_SHOWHELP;
 703 #if WXWIN_COMPATIBILITY_2_4
 704     if ( data.GetSetupDialog() )
 705         pd->Flags |= PD_PRINTSETUP;
 706 #endif
 707
 708     return true;
 709 }
 710
 711 bool wxWindowsPrintDialog::ConvertFromNative( wxPrintDialogData &data )
 712 {
 713     PRINTDLG *pd = (PRINTDLG*) m_printDlg;
 714     if ( pd == NULL )
 715         return false;
 716
 717     wxWindowsPrintNativeData *native_data =
 718         (wxWindowsPrintNativeData *) data.GetPrintData().GetNativeData();
 719
 720     // Pass the devmode data back to the wxPrintData structure where it really belongs.
 721     if (pd->hDevMode)
 722     {
 723         if (native_data->GetDevMode())
 724         {
 725             // Make sure we don't leak memory
 726             GlobalFree( (HGLOBAL)(DWORD) native_data->GetDevMode() );
 727         }
 728         native_data->SetDevMode( (void*)(long) pd->hDevMode );
 729         pd->hDevMode = NULL;
 730     }
 731
 732     // Pass the devnames data back to the wxPrintData structure where it really belongs.
 733     if (pd->hDevNames)
 734     {
 735         if (native_data->GetDevNames())
 736         {
 737             // Make sure we don't leak memory
 738             GlobalFree((HGLOBAL)(DWORD) native_data->GetDevNames());
 739         }
 740         native_data->SetDevNames((void*)(long) pd->hDevNames);
 741         pd->hDevNames = NULL;
 742     }
 743
 744     // Now convert the DEVMODE object, passed down from the PRINTDLG object,
 745     // into wxWidgets form.
 746     native_data->TransferTo( data.GetPrintData() );
 747
 748     data.SetFromPage( pd->nFromPage );
 749     data.SetToPage( pd->nToPage );
 750     data.SetMinPage( pd->nMinPage );
 751     data.SetMaxPage( pd->nMaxPage );
 752     data.SetNoCopies( pd->nCopies );
 753
 754     data.SetAllPages( (((pd->Flags & PD_PAGENUMS) != PD_PAGENUMS) && ((pd->Flags & PD_SELECTION) != PD_SELECTION)) );
 755     data.SetSelection( ((pd->Flags & PD_SELECTION) == PD_SELECTION) );
 756     data.SetCollate( ((pd->Flags & PD_COLLATE) == PD_COLLATE) );
 757     data.SetPrintToFile( ((pd->Flags & PD_PRINTTOFILE) == PD_PRINTTOFILE) );
 758     data.EnablePrintToFile( ((pd->Flags & PD_DISABLEPRINTTOFILE) != PD_DISABLEPRINTTOFILE) );
 759     data.EnableSelection( ((pd->Flags & PD_NOSELECTION) != PD_NOSELECTION) );
 760     data.EnablePageNumbers( ((pd->Flags & PD_NOPAGENUMS) != PD_NOPAGENUMS) );
 761     data.EnableHelp( ((pd->Flags & PD_SHOWHELP) == PD_SHOWHELP) );
 762 #if WXWIN_COMPATIBILITY_2_4
 763     data.SetSetupDialog( ((pd->Flags & PD_PRINTSETUP) == PD_PRINTSETUP) );
 764 #endif
 765     return true;
 766 }
 767
 768 // ---------------------------------------------------------------------------
 769 // wxWidnowsPageSetupDialog
 770 // ---------------------------------------------------------------------------
 771
 772 IMPLEMENT_CLASS(wxWindowsPageSetupDialog, wxPageSetupDialogBase)
 773
 774 wxWindowsPageSetupDialog::wxWindowsPageSetupDialog()
 775 {
 776     m_dialogParent = NULL;
 777     m_pageDlg = NULL;
 778 }
 779
 780 wxWindowsPageSetupDialog::wxWindowsPageSetupDialog(wxWindow *p, wxPageSetupDialogData *data)
 781 {
 782     Create(p, data);
 783 }
 784
 785 bool wxWindowsPageSetupDialog::Create(wxWindow *p, wxPageSetupDialogData *data)
 786 {
 787     m_dialogParent = p;
 788     m_pageDlg = NULL;
 789
 790     if (data)
 791         m_pageSetupData = (*data);
 792
 793     return true;
 794 }
 795
 796 wxWindowsPageSetupDialog::~wxWindowsPageSetupDialog()
 797 {
 798     PAGESETUPDLG *pd = (PAGESETUPDLG *)m_pageDlg;
 799     if ( pd && pd->hDevMode )
 800         GlobalFree(pd->hDevMode);
 801     if ( pd && pd->hDevNames )
 802         GlobalFree(pd->hDevNames);
 803     if ( pd )
 804         delete pd;
 805 }
 806
 807 int wxWindowsPageSetupDialog::ShowModal()
 808 {
 809     ConvertToNative( m_pageSetupData );
 810
 811     PAGESETUPDLG *pd = (PAGESETUPDLG *) m_pageDlg;
 812     if (m_dialogParent)
 813         pd->hwndOwner = (HWND) m_dialogParent->GetHWND();
 814     else if (wxTheApp->GetTopWindow())
 815         pd->hwndOwner = (HWND) wxTheApp->GetTopWindow()->GetHWND();
 816     else
 817         pd->hwndOwner = 0;
 818     BOOL retVal = PageSetupDlg( pd ) ;
 819     pd->hwndOwner = 0;
 820     if (retVal)
 821     {
 822         ConvertFromNative( m_pageSetupData );
 823         return wxID_OK;
 824     }
 825     else
 826         return wxID_CANCEL;
 827 }
 828
 829 bool wxWindowsPageSetupDialog::ConvertToNative( wxPageSetupDialogData &data )
 830 {
 831     wxWindowsPrintNativeData *native_data =
 832         (wxWindowsPrintNativeData *) data.GetPrintData().GetNativeData();
 833     data.GetPrintData().ConvertToNative();
 834
 835     PAGESETUPDLG *pd = (PAGESETUPDLG*) m_pageDlg;
 836
 837     // Shouldn't have been defined anywhere
 838     if (pd)
 839         return false;
 840
 841     pd = new PAGESETUPDLG;
 842     pd->hDevMode = NULL;
 843     pd->hDevNames = NULL;
 844     m_pageDlg = (void *)pd;
 845
 846     // Pass the devmode data (created in m_printData.ConvertToNative)
 847     // to the PRINTDLG structure, since it'll
 848     // be needed when PrintDlg is called.
 849
 850     if (pd->hDevMode)
 851     {
 852         GlobalFree(pd->hDevMode);
 853         pd->hDevMode = NULL;
 854     }
 855     pd->hDevMode = (HGLOBAL) native_data->GetDevMode();
 856     native_data->SetDevMode( (void*) NULL );
 857
 858     // Shouldn't assert; we should be able to test Ok-ness at a higher level
 859     //wxASSERT_MSG( (pd->hDevMode), wxT("hDevMode must be non-NULL in ConvertToNative!"));
 860
 861     // Pass the devnames data (created in m_printData.ConvertToNative)
 862     // to the PRINTDLG structure, since it'll
 863     // be needed when PrintDlg is called.
 864
 865     if (pd->hDevNames)
 866     {
 867         GlobalFree(pd->hDevNames);
 868         pd->hDevNames = NULL;
 869     }
 870     pd->hDevNames = (HGLOBAL) native_data->GetDevNames();
 871     native_data->SetDevNames((void*) NULL);
 872
 873 //        pd->hDevMode = GlobalAlloc(GMEM_MOVEABLE, sizeof(DEVMODE));
 874
 875     pd->Flags = PSD_MARGINS|PSD_MINMARGINS;
 876
 877     if ( data.GetDefaultMinMargins() )
 878         pd->Flags |= PSD_DEFAULTMINMARGINS;
 879     if ( !data.GetEnableMargins() )
 880         pd->Flags |= PSD_DISABLEMARGINS;
 881     if ( !data.GetEnableOrientation() )
 882         pd->Flags |= PSD_DISABLEORIENTATION;
 883     if ( !data.GetEnablePaper() )
 884         pd->Flags |= PSD_DISABLEPAPER;
 885     if ( !data.GetEnablePrinter() )
 886         pd->Flags |= PSD_DISABLEPRINTER;
 887     if ( data.GetDefaultInfo() )
 888         pd->Flags |= PSD_RETURNDEFAULT;
 889     if ( data.GetEnableHelp() )
 890         pd->Flags |= PSD_SHOWHELP;
 891
 892     // We want the units to be in hundredths of a millimetre
 893     pd->Flags |= PSD_INHUNDREDTHSOFMILLIMETERS;
 894
 895     pd->lStructSize = sizeof( PAGESETUPDLG );
 896     pd->hwndOwner=(HWND)NULL;
 897 //    pd->hDevNames=(HWND)NULL;
 898     pd->hInstance=(HINSTANCE)NULL;
 899     //   PAGESETUPDLG is in hundreds of a mm
 900     pd->ptPaperSize.x = data.GetPaperSize().x * 100;
 901     pd->ptPaperSize.y = data.GetPaperSize().y * 100;
 902
 903     pd->rtMinMargin.left = data.GetMinMarginTopLeft().x * 100;
 904     pd->rtMinMargin.top = data.GetMinMarginTopLeft().y * 100;
 905     pd->rtMinMargin.right = data.GetMinMarginBottomRight().x * 100;
 906     pd->rtMinMargin.bottom = data.GetMinMarginBottomRight().y * 100;
 907
 908     pd->rtMargin.left = data.GetMarginTopLeft().x * 100;
 909     pd->rtMargin.top = data.GetMarginTopLeft().y * 100;
 910     pd->rtMargin.right = data.GetMarginBottomRight().x * 100;
 911     pd->rtMargin.bottom = data.GetMarginBottomRight().y * 100;
 912
 913     pd->lCustData = 0;
 914     pd->lpfnPageSetupHook = NULL;
 915     pd->lpfnPagePaintHook = NULL;
 916     pd->hPageSetupTemplate = NULL;
 917     pd->lpPageSetupTemplateName = NULL;
 918
 919 /*
 920     if ( pd->hDevMode )
 921     {
 922         DEVMODE *devMode = (DEVMODE*) GlobalLock(pd->hDevMode);
 923         memset(devMode, 0, sizeof(DEVMODE));
 924         devMode->dmSize = sizeof(DEVMODE);
 925         devMode->dmOrientation = m_orientation;
 926         devMode->dmFields = DM_ORIENTATION;
 927         GlobalUnlock(pd->hDevMode);
 928     }
 929 */
 930     return true;
 931 }
 932
 933 bool wxWindowsPageSetupDialog::ConvertFromNative( wxPageSetupDialogData &data )
 934 {
 935     PAGESETUPDLG *pd = (PAGESETUPDLG *) m_pageDlg;
 936     if ( !pd )
 937         return false;
 938
 939     wxWindowsPrintNativeData *native_data =
 940         (wxWindowsPrintNativeData *) data.GetPrintData().GetNativeData();
 941
 942     // Pass the devmode data back to the wxPrintData structure where it really belongs.
 943     if (pd->hDevMode)
 944     {
 945         if (native_data->GetDevMode())
 946         {
 947             // Make sure we don't leak memory
 948             GlobalFree((HGLOBAL) native_data->GetDevMode());
 949         }
 950         native_data->SetDevMode( (void*) pd->hDevMode );
 951         pd->hDevMode = NULL;
 952     }
 953
 954     // Isn't this superfluous? It's called again below.
 955     // data.GetPrintData().ConvertFromNative();
 956
 957     // Pass the devnames data back to the wxPrintData structure where it really belongs.
 958     if (pd->hDevNames)
 959     {
 960         if (native_data->GetDevNames())
 961         {
 962             // Make sure we don't leak memory
 963             GlobalFree((HGLOBAL) native_data->GetDevNames());
 964         }
 965         native_data->SetDevNames((void*) pd->hDevNames);
 966         pd->hDevNames = NULL;
 967     }
 968
 969     data.GetPrintData().ConvertFromNative();
 970
 971     pd->Flags = PSD_MARGINS|PSD_MINMARGINS;
 972
 973     data.SetDefaultMinMargins( ((pd->Flags & PSD_DEFAULTMINMARGINS) == PSD_DEFAULTMINMARGINS) );
 974     data.EnableMargins( ((pd->Flags & PSD_DISABLEMARGINS) != PSD_DISABLEMARGINS) );
 975     data.EnableOrientation( ((pd->Flags & PSD_DISABLEORIENTATION) != PSD_DISABLEORIENTATION) );
 976     data.EnablePaper( ((pd->Flags & PSD_DISABLEPAPER) != PSD_DISABLEPAPER) );
 977     data.EnablePrinter( ((pd->Flags & PSD_DISABLEPRINTER) != PSD_DISABLEPRINTER) );
 978     data.SetDefaultInfo( ((pd->Flags & PSD_RETURNDEFAULT) == PSD_RETURNDEFAULT) );
 979     data.EnableHelp( ((pd->Flags & PSD_SHOWHELP) == PSD_SHOWHELP) );
 980
 981     //   PAGESETUPDLG is in hundreds of a mm
 982     data.SetPaperSize( wxSize(pd->ptPaperSize.x / 100, pd->ptPaperSize.y / 100) );
 983
 984     data.SetMinMarginTopLeft( wxPoint(pd->rtMinMargin.left / 100, pd->rtMinMargin.top / 100) );
 985     data.SetMinMarginBottomRight( wxPoint(pd->rtMinMargin.right / 100, pd->rtMinMargin.bottom / 100) );
 986
 987     data.SetMarginTopLeft( wxPoint(pd->rtMargin.left / 100, pd->rtMargin.top / 100) );
 988     data.SetMarginBottomRight( wxPoint(pd->rtMargin.right / 100, pd->rtMargin.bottom / 100) );
 989
 990     return true;
 991 }
 992
 993 #endif
 994     // wxUSE_PRINTING_ARCHITECTURE