src/common/prntbase.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/prntbase.cpp
   3 // Purpose:     Printing framework base class implementation
   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 // For compilers that support precompilation, includes "wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #ifdef __BORLANDC__
  16     #pragma hdrstop
  17 #endif
  18
  19 #if wxUSE_PRINTING_ARCHITECTURE
  20
  21 #include "wx/dcprint.h"
  22
  23 #ifndef WX_PRECOMP
  24     #if defined(__WXMSW__)
  25         #include "wx/msw/wrapcdlg.h"
  26     #endif // MSW
  27     #include "wx/utils.h"
  28     #include "wx/dc.h"
  29     #include "wx/app.h"
  30     #include "wx/math.h"
  31     #include "wx/msgdlg.h"
  32     #include "wx/layout.h"
  33     #include "wx/choice.h"
  34     #include "wx/button.h"
  35     #include "wx/settings.h"
  36     #include "wx/dcmemory.h"
  37     #include "wx/dcclient.h"
  38     #include "wx/stattext.h"
  39     #include "wx/intl.h"
  40     #include "wx/textdlg.h"
  41     #include "wx/sizer.h"
  42     #include "wx/module.h"
  43 #endif // !WX_PRECOMP
  44
  45 #include "wx/prntbase.h"
  46 #include "wx/printdlg.h"
  47 #include "wx/print.h"
  48 #include "wx/dcprint.h"
  49 #include "wx/artprov.h"
  50
  51 #include <stdlib.h>
  52 #include <string.h>
  53
  54 #if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
  55 #include "wx/msw/printdlg.h"
  56 #include "wx/msw/dcprint.h"
  57 #elif defined(__WXMAC__)
  58 #include "wx/osx/printdlg.h"
  59 #include "wx/osx/private/print.h"
  60 #include "wx/osx/dcprint.h"
  61 #elif defined(__WXPM__)
  62 #include "wx/os2/dcprint.h"
  63 #include "wx/generic/prntdlgg.h"
  64 #else
  65 #include "wx/generic/prntdlgg.h"
  66 #include "wx/dcps.h"
  67 #endif
  68
  69 #ifdef __WXMSW__
  70     #ifndef __WIN32__
  71         #include <print.h>
  72     #endif
  73 #endif // __WXMSW__
  74
  75 //----------------------------------------------------------------------------
  76 // wxPrintFactory
  77 //----------------------------------------------------------------------------
  78
  79 wxPrintFactory *wxPrintFactory::m_factory = NULL;
  80
  81 void wxPrintFactory::SetPrintFactory( wxPrintFactory *factory )
  82 {
  83     if (wxPrintFactory::m_factory)
  84         delete wxPrintFactory::m_factory;
  85
  86     wxPrintFactory::m_factory = factory;
  87 }
  88
  89 wxPrintFactory *wxPrintFactory::GetFactory()
  90 {
  91     if (!wxPrintFactory::m_factory)
  92         wxPrintFactory::m_factory = new wxNativePrintFactory;
  93
  94     return wxPrintFactory::m_factory;
  95 }
  96
  97 //----------------------------------------------------------------------------
  98 // wxNativePrintFactory
  99 //----------------------------------------------------------------------------
 100
 101 wxPrinterBase *wxNativePrintFactory::CreatePrinter( wxPrintDialogData *data )
 102 {
 103 #if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 104     return new wxWindowsPrinter( data );
 105 #elif defined(__WXMAC__)
 106     return new wxMacPrinter( data );
 107 #elif defined(__WXPM__)
 108     return new wxOS2Printer( data );
 109 #else
 110     return new wxPostScriptPrinter( data );
 111 #endif
 112 }
 113
 114 wxPrintPreviewBase *wxNativePrintFactory::CreatePrintPreview( wxPrintout *preview,
 115     wxPrintout *printout, wxPrintDialogData *data )
 116 {
 117 #if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 118     return new wxWindowsPrintPreview( preview, printout, data );
 119 #elif defined(__WXMAC__)
 120     return new wxMacPrintPreview( preview, printout, data );
 121 #elif defined(__WXPM__)
 122     return new wxOS2PrintPreview( preview, printout, data );
 123 #else
 124     return new wxPostScriptPrintPreview( preview, printout, data );
 125 #endif
 126 }
 127
 128 wxPrintPreviewBase *wxNativePrintFactory::CreatePrintPreview( wxPrintout *preview,
 129     wxPrintout *printout, wxPrintData *data )
 130 {
 131 #if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 132     return new wxWindowsPrintPreview( preview, printout, data );
 133 #elif defined(__WXMAC__)
 134     return new wxMacPrintPreview( preview, printout, data );
 135 #elif defined(__WXPM__)
 136     return new wxOS2PrintPreview( preview, printout, data );
 137 #else
 138     return new wxPostScriptPrintPreview( preview, printout, data );
 139 #endif
 140 }
 141
 142 wxPrintDialogBase *wxNativePrintFactory::CreatePrintDialog( wxWindow *parent,
 143                                                   wxPrintDialogData *data )
 144 {
 145 #if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 146     return new wxWindowsPrintDialog( parent, data );
 147 #elif defined(__WXMAC__)
 148     return new wxMacPrintDialog( parent, data );
 149 #else
 150     return new wxGenericPrintDialog( parent, data );
 151 #endif
 152 }
 153
 154 wxPrintDialogBase *wxNativePrintFactory::CreatePrintDialog( wxWindow *parent,
 155                                                   wxPrintData *data )
 156 {
 157 #if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 158     return new wxWindowsPrintDialog( parent, data );
 159 #elif defined(__WXMAC__)
 160     return new wxMacPrintDialog( parent, data );
 161 #else
 162     return new wxGenericPrintDialog( parent, data );
 163 #endif
 164 }
 165
 166 wxPageSetupDialogBase *wxNativePrintFactory::CreatePageSetupDialog( wxWindow *parent,
 167                                                   wxPageSetupDialogData *data )
 168 {
 169 #if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 170     return new wxWindowsPageSetupDialog( parent, data );
 171 #elif defined(__WXMAC__)
 172     return new wxMacPageSetupDialog( parent, data );
 173 #else
 174     return new wxGenericPageSetupDialog( parent, data );
 175 #endif
 176 }
 177
 178 bool wxNativePrintFactory::HasPrintSetupDialog()
 179 {
 180 #if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 181     return false;
 182 #elif defined(__WXMAC__)
 183     return false;
 184 #else
 185     // Only here do we need to provide the print setup
 186     // dialog ourselves, the other platforms either have
 187     // none, don't make it accessible or let you configure
 188     // the printer from the wxPrintDialog anyway.
 189     return true;
 190 #endif
 191
 192 }
 193
 194 wxDialog *wxNativePrintFactory::CreatePrintSetupDialog( wxWindow *parent,
 195                                                         wxPrintData *data )
 196 {
 197 #if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 198     wxUnusedVar(parent);
 199     wxUnusedVar(data);
 200     return NULL;
 201 #elif defined(__WXMAC__)
 202     wxUnusedVar(parent);
 203     wxUnusedVar(data);
 204     return NULL;
 205 #else
 206     // Only here do we need to provide the print setup
 207     // dialog ourselves, the other platforms either have
 208     // none, don't make it accessible or let you configure
 209     // the printer from the wxPrintDialog anyway.
 210     return new wxGenericPrintSetupDialog( parent, data );
 211 #endif
 212 }
 213
 214 wxDCImpl* wxNativePrintFactory::CreatePrinterDCImpl( wxPrinterDC *owner, const wxPrintData& data )
 215 {
 216 #if defined(__WXGTK__) || defined(__WXMOTIF__) || ( defined(__WXUNIVERSAL__) && !defined(__WXMAC__) )
 217     return new wxPostScriptDCImpl( owner, data );
 218 #else
 219     return new wxPrinterDCImpl( owner, data );
 220 #endif
 221 }
 222
 223 bool wxNativePrintFactory::HasOwnPrintToFile()
 224 {
 225     // Only relevant for PostScript and here the
 226     // setup dialog provides no "print to file"
 227     // option. In the GNOME setup dialog, the
 228     // setup dialog has its own print to file.
 229     return false;
 230 }
 231
 232 bool wxNativePrintFactory::HasPrinterLine()
 233 {
 234     // Only relevant for PostScript for now
 235     return true;
 236 }
 237
 238 wxString wxNativePrintFactory::CreatePrinterLine()
 239 {
 240     // Only relevant for PostScript for now
 241
 242     // We should query "lpstat -d" here
 243     return _("Generic PostScript");
 244 }
 245
 246 bool wxNativePrintFactory::HasStatusLine()
 247 {
 248     // Only relevant for PostScript for now
 249     return true;
 250 }
 251
 252 wxString wxNativePrintFactory::CreateStatusLine()
 253 {
 254     // Only relevant for PostScript for now
 255
 256     // We should query "lpstat -r" or "lpstat -p" here
 257     return _("Ready");
 258 }
 259
 260 wxPrintNativeDataBase *wxNativePrintFactory::CreatePrintNativeData()
 261 {
 262 #if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 263     return new wxWindowsPrintNativeData;
 264 #elif defined(__WXMAC__)
 265     return wxOSXCreatePrintData();
 266 #else
 267     return new wxPostScriptPrintNativeData;
 268 #endif
 269 }
 270
 271 //----------------------------------------------------------------------------
 272 // wxPrintNativeDataBase
 273 //----------------------------------------------------------------------------
 274
 275 IMPLEMENT_ABSTRACT_CLASS(wxPrintNativeDataBase, wxObject)
 276
 277 wxPrintNativeDataBase::wxPrintNativeDataBase()
 278 {
 279     m_ref = 1;
 280 }
 281
 282 //----------------------------------------------------------------------------
 283 // wxPrintFactoryModule
 284 //----------------------------------------------------------------------------
 285
 286 class wxPrintFactoryModule: public wxModule
 287 {
 288 public:
 289     wxPrintFactoryModule() {}
 290     bool OnInit() { return true; }
 291     void OnExit() { wxPrintFactory::SetPrintFactory( NULL ); }
 292
 293 private:
 294     DECLARE_DYNAMIC_CLASS(wxPrintFactoryModule)
 295 };
 296
 297 IMPLEMENT_DYNAMIC_CLASS(wxPrintFactoryModule, wxModule)
 298
 299 //----------------------------------------------------------------------------
 300 // wxPrinterBase
 301 //----------------------------------------------------------------------------
 302
 303 IMPLEMENT_CLASS(wxPrinterBase, wxObject)
 304
 305 wxPrinterBase::wxPrinterBase(wxPrintDialogData *data)
 306 {
 307     m_currentPrintout = NULL;
 308     sm_abortWindow = NULL;
 309     sm_abortIt = false;
 310     if (data)
 311         m_printDialogData = (*data);
 312     sm_lastError = wxPRINTER_NO_ERROR;
 313 }
 314
 315 wxWindow *wxPrinterBase::sm_abortWindow = NULL;
 316 bool wxPrinterBase::sm_abortIt = false;
 317 wxPrinterError wxPrinterBase::sm_lastError = wxPRINTER_NO_ERROR;
 318
 319 wxPrinterBase::~wxPrinterBase()
 320 {
 321 }
 322
 323 wxWindow *wxPrinterBase::CreateAbortWindow(wxWindow *parent, wxPrintout * printout)
 324 {
 325     wxPrintAbortDialog *dialog = new wxPrintAbortDialog(parent, _("Printing ") , wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE);
 326
 327     wxBoxSizer *button_sizer = new wxBoxSizer( wxVERTICAL );
 328     button_sizer->Add( new wxStaticText(dialog, wxID_ANY, _("Please wait while printing\n") + printout->GetTitle() ), 0, wxALL, 10 );
 329     button_sizer->Add( new wxButton( dialog, wxID_CANCEL, wxT("Cancel") ), 0, wxALL | wxALIGN_CENTER, 10 );
 330
 331     dialog->SetAutoLayout( true );
 332     dialog->SetSizer( button_sizer );
 333
 334     button_sizer->Fit(dialog);
 335     button_sizer->SetSizeHints (dialog) ;
 336
 337     return dialog;
 338 }
 339
 340 void wxPrinterBase::ReportError(wxWindow *parent, wxPrintout *WXUNUSED(printout), const wxString& message)
 341 {
 342     wxMessageBox(message, _("Printing Error"), wxOK, parent);
 343 }
 344
 345 wxPrintDialogData& wxPrinterBase::GetPrintDialogData() const
 346 {
 347     return (wxPrintDialogData&) m_printDialogData;
 348 }
 349
 350 //----------------------------------------------------------------------------
 351 // wxPrinter
 352 //----------------------------------------------------------------------------
 353
 354 IMPLEMENT_CLASS(wxPrinter, wxPrinterBase)
 355
 356 wxPrinter::wxPrinter(wxPrintDialogData *data)
 357 {
 358     m_pimpl = wxPrintFactory::GetFactory()->CreatePrinter( data );
 359 }
 360
 361 wxPrinter::~wxPrinter()
 362 {
 363     delete m_pimpl;
 364 }
 365
 366 wxWindow *wxPrinter::CreateAbortWindow(wxWindow *parent, wxPrintout *printout)
 367 {
 368     return m_pimpl->CreateAbortWindow( parent, printout );
 369 }
 370
 371 void wxPrinter::ReportError(wxWindow *parent, wxPrintout *printout, const wxString& message)
 372 {
 373     m_pimpl->ReportError( parent, printout, message );
 374 }
 375
 376 bool wxPrinter::Setup(wxWindow *parent)
 377 {
 378     return m_pimpl->Setup( parent );
 379 }
 380
 381 bool wxPrinter::Print(wxWindow *parent, wxPrintout *printout, bool prompt)
 382 {
 383     return m_pimpl->Print( parent, printout, prompt );
 384 }
 385
 386 wxDC* wxPrinter::PrintDialog(wxWindow *parent)
 387 {
 388     return m_pimpl->PrintDialog( parent );
 389 }
 390
 391 wxPrintDialogData& wxPrinter::GetPrintDialogData() const
 392 {
 393     return m_pimpl->GetPrintDialogData();
 394 }
 395
 396 // ---------------------------------------------------------------------------
 397 // wxPrintDialogBase: the dialog for printing.
 398 // ---------------------------------------------------------------------------
 399
 400 IMPLEMENT_ABSTRACT_CLASS(wxPrintDialogBase, wxDialog)
 401
 402 wxPrintDialogBase::wxPrintDialogBase(wxWindow *parent,
 403                                      wxWindowID id,
 404                                      const wxString &title,
 405                                      const wxPoint &pos,
 406                                      const wxSize &size,
 407                                      long style)
 408     : wxDialog( parent, id, title.empty() ? wxString(_("Print")) : title,
 409                 pos, size, style )
 410 {
 411 }
 412
 413 // ---------------------------------------------------------------------------
 414 // wxPrintDialog: the dialog for printing
 415 // ---------------------------------------------------------------------------
 416
 417 IMPLEMENT_CLASS(wxPrintDialog, wxObject)
 418
 419 wxPrintDialog::wxPrintDialog(wxWindow *parent, wxPrintDialogData* data)
 420 {
 421     m_pimpl = wxPrintFactory::GetFactory()->CreatePrintDialog( parent, data );
 422 }
 423
 424 wxPrintDialog::wxPrintDialog(wxWindow *parent, wxPrintData* data)
 425 {
 426     m_pimpl = wxPrintFactory::GetFactory()->CreatePrintDialog( parent, data );
 427 }
 428
 429 wxPrintDialog::~wxPrintDialog()
 430 {
 431     delete m_pimpl;
 432 }
 433
 434 int wxPrintDialog::ShowModal()
 435 {
 436     return m_pimpl->ShowModal();
 437 }
 438
 439 wxPrintDialogData& wxPrintDialog::GetPrintDialogData()
 440 {
 441     return m_pimpl->GetPrintDialogData();
 442 }
 443
 444 wxPrintData& wxPrintDialog::GetPrintData()
 445 {
 446     return m_pimpl->GetPrintData();
 447 }
 448
 449 wxDC *wxPrintDialog::GetPrintDC()
 450 {
 451     return m_pimpl->GetPrintDC();
 452 }
 453
 454 // ---------------------------------------------------------------------------
 455 // wxPageSetupDialogBase: the page setup dialog
 456 // ---------------------------------------------------------------------------
 457
 458 IMPLEMENT_ABSTRACT_CLASS(wxPageSetupDialogBase, wxDialog)
 459
 460 wxPageSetupDialogBase::wxPageSetupDialogBase(wxWindow *parent,
 461                                      wxWindowID id,
 462                                      const wxString &title,
 463                                      const wxPoint &pos,
 464                                      const wxSize &size,
 465                                      long style)
 466     : wxDialog( parent, id, title.empty() ? wxString(_("Page setup")) : title,
 467                 pos, size, style )
 468 {
 469 }
 470
 471 // ---------------------------------------------------------------------------
 472 // wxPageSetupDialog: the page setup dialog
 473 // ---------------------------------------------------------------------------
 474
 475 IMPLEMENT_CLASS(wxPageSetupDialog, wxObject)
 476
 477 wxPageSetupDialog::wxPageSetupDialog(wxWindow *parent, wxPageSetupDialogData *data )
 478 {
 479     m_pimpl = wxPrintFactory::GetFactory()->CreatePageSetupDialog( parent, data );
 480 }
 481
 482 wxPageSetupDialog::~wxPageSetupDialog()
 483 {
 484     delete m_pimpl;
 485 }
 486
 487 int wxPageSetupDialog::ShowModal()
 488 {
 489     return m_pimpl->ShowModal();
 490 }
 491
 492 wxPageSetupDialogData& wxPageSetupDialog::GetPageSetupDialogData()
 493 {
 494     return m_pimpl->GetPageSetupDialogData();
 495 }
 496
 497 // old name
 498 wxPageSetupDialogData& wxPageSetupDialog::GetPageSetupData()
 499 {
 500     return m_pimpl->GetPageSetupDialogData();
 501 }
 502
 503 //----------------------------------------------------------------------------
 504 // wxPrintAbortDialog
 505 //----------------------------------------------------------------------------
 506
 507 BEGIN_EVENT_TABLE(wxPrintAbortDialog, wxDialog)
 508     EVT_BUTTON(wxID_CANCEL, wxPrintAbortDialog::OnCancel)
 509 END_EVENT_TABLE()
 510
 511 void wxPrintAbortDialog::OnCancel(wxCommandEvent& WXUNUSED(event))
 512 {
 513     wxPrinterBase::sm_abortIt = true;
 514     wxPrinterBase::sm_abortWindow->Show(false);
 515     wxPrinterBase::sm_abortWindow->Close(true);
 516     wxPrinterBase::sm_abortWindow->Destroy();
 517     wxPrinterBase::sm_abortWindow = NULL;
 518 }
 519
 520 //----------------------------------------------------------------------------
 521 // wxPrintout
 522 //----------------------------------------------------------------------------
 523
 524 IMPLEMENT_ABSTRACT_CLASS(wxPrintout, wxObject)
 525
 526 wxPrintout::wxPrintout(const wxString& title)
 527 {
 528     m_printoutTitle = title ;
 529     m_printoutDC = NULL;
 530     m_pageWidthMM = 0;
 531     m_pageHeightMM = 0;
 532     m_pageWidthPixels = 0;
 533     m_pageHeightPixels = 0;
 534     m_PPIScreenX = 0;
 535     m_PPIScreenY = 0;
 536     m_PPIPrinterX = 0;
 537     m_PPIPrinterY = 0;
 538     m_preview = NULL;
 539 }
 540
 541 wxPrintout::~wxPrintout()
 542 {
 543 }
 544
 545 bool wxPrintout::OnBeginDocument(int WXUNUSED(startPage), int WXUNUSED(endPage))
 546 {
 547     return GetDC()->StartDoc(_("Printing ") + m_printoutTitle);
 548 }
 549
 550 void wxPrintout::OnEndDocument()
 551 {
 552     GetDC()->EndDoc();
 553 }
 554
 555 void wxPrintout::OnBeginPrinting()
 556 {
 557 }
 558
 559 void wxPrintout::OnEndPrinting()
 560 {
 561 }
 562
 563 bool wxPrintout::HasPage(int page)
 564 {
 565     return (page == 1);
 566 }
 567
 568 void wxPrintout::GetPageInfo(int *minPage, int *maxPage, int *fromPage, int *toPage)
 569 {
 570     *minPage = 1;
 571     *maxPage = 32000;
 572     *fromPage = 1;
 573     *toPage = 1;
 574 }
 575
 576 void wxPrintout::FitThisSizeToPaper(const wxSize& imageSize)
 577 {
 578     // Set the DC scale and origin so that the given image size fits within the
 579     // entire page and the origin is at the top left corner of the page. Note
 580     // that with most printers, portions of the page will be non-printable. Use
 581     // this if you're managing your own page margins.
 582     if (!m_printoutDC) return;
 583     wxRect paperRect = GetPaperRectPixels();
 584     wxCoord pw, ph;
 585     GetPageSizePixels(&pw, &ph);
 586     wxCoord w, h;
 587     m_printoutDC->GetSize(&w, &h);
 588     float scaleX = ((float(paperRect.width) * w) / (float(pw) * imageSize.x));
 589     float scaleY = ((float(paperRect.height) * h) / (float(ph) * imageSize.y));
 590     float actualScale = wxMin(scaleX, scaleY);
 591     m_printoutDC->SetUserScale(actualScale, actualScale);
 592     m_printoutDC->SetDeviceOrigin(0, 0);
 593     wxRect logicalPaperRect = GetLogicalPaperRect();
 594     SetLogicalOrigin(logicalPaperRect.x, logicalPaperRect.y);
 595 }
 596
 597 void wxPrintout::FitThisSizeToPage(const wxSize& imageSize)
 598 {
 599     // Set the DC scale and origin so that the given image size fits within the
 600     // printable area of the page and the origin is at the top left corner of
 601     // the printable area.
 602     if (!m_printoutDC) return;
 603     int w, h;
 604     m_printoutDC->GetSize(&w, &h);
 605     float scaleX = float(w) / imageSize.x;
 606     float scaleY = float(h) / imageSize.y;
 607     float actualScale = wxMin(scaleX, scaleY);
 608     m_printoutDC->SetUserScale(actualScale, actualScale);
 609     m_printoutDC->SetDeviceOrigin(0, 0);
 610 }
 611
 612 void wxPrintout::FitThisSizeToPageMargins(const wxSize& imageSize, const wxPageSetupDialogData& pageSetupData)
 613 {
 614     // Set the DC scale and origin so that the given image size fits within the
 615     // page margins defined in the given wxPageSetupDialogData object and the
 616     // origin is at the top left corner of the page margins.
 617     if (!m_printoutDC) return;
 618     wxRect paperRect = GetPaperRectPixels();
 619     wxCoord pw, ph;
 620     GetPageSizePixels(&pw, &ph);
 621     wxPoint topLeft = pageSetupData.GetMarginTopLeft();
 622     wxPoint bottomRight = pageSetupData.GetMarginBottomRight();
 623     wxCoord mw, mh;
 624     GetPageSizeMM(&mw, &mh);
 625     float mmToDeviceX = float(pw) / mw;
 626     float mmToDeviceY = float(ph) / mh;
 627     wxRect pageMarginsRect(paperRect.x + wxRound(mmToDeviceX * topLeft.x),
 628         paperRect.y + wxRound(mmToDeviceY * topLeft.y),
 629         paperRect.width - wxRound(mmToDeviceX * (topLeft.x + bottomRight.x)),
 630         paperRect.height - wxRound(mmToDeviceY * (topLeft.y + bottomRight.y)));
 631     wxCoord w, h;
 632     m_printoutDC->GetSize(&w, &h);
 633     float scaleX = (float(pageMarginsRect.width) * w) / (float(pw) * imageSize.x);
 634     float scaleY = (float(pageMarginsRect.height) * h) / (float(ph) * imageSize.y);
 635     float actualScale = wxMin(scaleX, scaleY);
 636     m_printoutDC->SetUserScale(actualScale, actualScale);
 637     m_printoutDC->SetDeviceOrigin(0, 0);
 638     wxRect logicalPageMarginsRect = GetLogicalPageMarginsRect(pageSetupData);
 639     SetLogicalOrigin(logicalPageMarginsRect.x, logicalPageMarginsRect.y);
 640 }
 641
 642 void wxPrintout::MapScreenSizeToPaper()
 643 {
 644     // Set the DC scale so that an image on the screen is the same size on the
 645     // paper and the origin is at the top left of the paper. Note that with most
 646     // printers, portions of the page will be cut off. Use this if you're
 647     // managing your own page margins.
 648     if (!m_printoutDC) return;
 649     MapScreenSizeToPage();
 650     wxRect logicalPaperRect = GetLogicalPaperRect();
 651     SetLogicalOrigin(logicalPaperRect.x, logicalPaperRect.y);
 652 }
 653
 654 void wxPrintout::MapScreenSizeToPage()
 655 {
 656     // Set the DC scale and origin so that an image on the screen is the same
 657     // size on the paper and the origin is at the top left of the printable area.
 658     if (!m_printoutDC) return;
 659     int ppiScreenX, ppiScreenY;
 660     GetPPIScreen(&ppiScreenX, &ppiScreenY);
 661     int ppiPrinterX, ppiPrinterY;
 662     GetPPIPrinter(&ppiPrinterX, &ppiPrinterY);
 663     int w, h;
 664     m_printoutDC->GetSize(&w, &h);
 665     int pageSizePixelsX, pageSizePixelsY;
 666     GetPageSizePixels(&pageSizePixelsX, &pageSizePixelsY);
 667     float userScaleX = (float(ppiPrinterX) * w) / (float(ppiScreenX) * pageSizePixelsX);
 668     float userScaleY = (float(ppiPrinterY) * h) / (float(ppiScreenY) * pageSizePixelsY);
 669     m_printoutDC->SetUserScale(userScaleX, userScaleY);
 670     m_printoutDC->SetDeviceOrigin(0, 0);
 671 }
 672
 673 void wxPrintout::MapScreenSizeToPageMargins(const wxPageSetupDialogData& pageSetupData)
 674 {
 675     // Set the DC scale so that an image on the screen is the same size on the
 676     // paper and the origin is at the top left of the page margins defined by
 677     // the given wxPageSetupDialogData object.
 678     if (!m_printoutDC) return;
 679     MapScreenSizeToPage();
 680     wxRect logicalPageMarginsRect = GetLogicalPageMarginsRect(pageSetupData);
 681     SetLogicalOrigin(logicalPageMarginsRect.x, logicalPageMarginsRect.y);
 682 }
 683
 684 void wxPrintout::MapScreenSizeToDevice()
 685 {
 686     // Set the DC scale so that a screen pixel is the same size as a device
 687     // pixel and the origin is at the top left of the printable area.
 688     if (!m_printoutDC) return;
 689     int w, h;
 690     m_printoutDC->GetSize(&w, &h);
 691     int pageSizePixelsX, pageSizePixelsY;
 692     GetPageSizePixels(&pageSizePixelsX, &pageSizePixelsY);
 693     float userScaleX = float(w) / pageSizePixelsX;
 694     float userScaleY = float(h) / pageSizePixelsY;
 695     m_printoutDC->SetUserScale(userScaleX, userScaleY);
 696     m_printoutDC->SetDeviceOrigin(0, 0);
 697 }
 698
 699 wxRect wxPrintout::GetLogicalPaperRect() const
 700 {
 701     // Return the rectangle in logical units that corresponds to the paper
 702     // rectangle.
 703     wxRect paperRect = GetPaperRectPixels();
 704     wxCoord pw, ph;
 705     GetPageSizePixels(&pw, &ph);
 706     wxCoord w, h;
 707     m_printoutDC->GetSize(&w, &h);
 708     if (w == pw && h == ph) {
 709         // this DC matches the printed page, so no scaling
 710         return wxRect(m_printoutDC->DeviceToLogicalX(paperRect.x),
 711             m_printoutDC->DeviceToLogicalY(paperRect.y),
 712             m_printoutDC->DeviceToLogicalXRel(paperRect.width),
 713             m_printoutDC->DeviceToLogicalYRel(paperRect.height));
 714     }
 715     // This DC doesn't match the printed page, so we have to scale.
 716     float scaleX = float(w) / pw;
 717     float scaleY = float(h) / ph;
 718     return wxRect(m_printoutDC->DeviceToLogicalX(wxRound(paperRect.x * scaleX)),
 719         m_printoutDC->DeviceToLogicalY(wxRound(paperRect.y * scaleY)),
 720         m_printoutDC->DeviceToLogicalXRel(wxRound(paperRect.width * scaleX)),
 721         m_printoutDC->DeviceToLogicalYRel(wxRound(paperRect.height * scaleY)));
 722 }
 723
 724 wxRect wxPrintout::GetLogicalPageRect() const
 725 {
 726     // Return the rectangle in logical units that corresponds to the printable
 727     // area.
 728     int w, h;
 729     m_printoutDC->GetSize(&w, &h);
 730     return wxRect(m_printoutDC->DeviceToLogicalX(0),
 731         m_printoutDC->DeviceToLogicalY(0),
 732         m_printoutDC->DeviceToLogicalXRel(w),
 733         m_printoutDC->DeviceToLogicalYRel(h));
 734 }
 735
 736 wxRect wxPrintout::GetLogicalPageMarginsRect(const wxPageSetupDialogData& pageSetupData) const
 737 {
 738     // Return the rectangle in logical units that corresponds to the region
 739     // within the page margins as specified by the given wxPageSetupDialogData
 740     // object.
 741
 742     // We get the paper size in device units and the margins in mm,
 743     // so we need to calculate the conversion with this trick
 744     wxCoord pw, ph;
 745     GetPageSizePixels(&pw, &ph);
 746     wxCoord mw, mh;
 747     GetPageSizeMM(&mw, &mh);
 748     float mmToDeviceX = float(pw) / mw;
 749     float mmToDeviceY = float(ph) / mh;
 750
 751     // paper size in device units
 752     wxRect paperRect = GetPaperRectPixels();
 753
 754     // margins in mm
 755     wxPoint topLeft = pageSetupData.GetMarginTopLeft();
 756     wxPoint bottomRight = pageSetupData.GetMarginBottomRight();
 757
 758     // calculate margins in device units
 759     wxRect pageMarginsRect(
 760         paperRect.x      + wxRound(mmToDeviceX * topLeft.x),
 761         paperRect.y      + wxRound(mmToDeviceY * topLeft.y),
 762         paperRect.width  - wxRound(mmToDeviceX * (topLeft.x + bottomRight.x)),
 763         paperRect.height - wxRound(mmToDeviceY * (topLeft.y + bottomRight.y)));
 764
 765     wxCoord w, h;
 766     m_printoutDC->GetSize(&w, &h);
 767     if (w == pw && h == ph)
 768     {
 769         // this DC matches the printed page, so no scaling
 770         return wxRect(
 771             m_printoutDC->DeviceToLogicalX(pageMarginsRect.x),
 772             m_printoutDC->DeviceToLogicalY(pageMarginsRect.y),
 773             m_printoutDC->DeviceToLogicalXRel(pageMarginsRect.width),
 774             m_printoutDC->DeviceToLogicalYRel(pageMarginsRect.height));
 775     }
 776
 777     // This DC doesn't match the printed page, so we have to scale.
 778     float scaleX = float(w) / pw;
 779     float scaleY = float(h) / ph;
 780     return wxRect(m_printoutDC->DeviceToLogicalX(wxRound(pageMarginsRect.x * scaleX)),
 781         m_printoutDC->DeviceToLogicalY(wxRound(pageMarginsRect.y * scaleY)),
 782         m_printoutDC->DeviceToLogicalXRel(wxRound(pageMarginsRect.width * scaleX)),
 783         m_printoutDC->DeviceToLogicalYRel(wxRound(pageMarginsRect.height * scaleY)));
 784 }
 785
 786 void wxPrintout::SetLogicalOrigin(wxCoord x, wxCoord y)
 787 {
 788     // Set the device origin by specifying a point in logical coordinates.
 789     m_printoutDC->SetDeviceOrigin(
 790         m_printoutDC->LogicalToDeviceX(x),
 791         m_printoutDC->LogicalToDeviceY(y) );
 792 }
 793
 794 void wxPrintout::OffsetLogicalOrigin(wxCoord xoff, wxCoord yoff)
 795 {
 796     // Offset the device origin by a specified distance in device coordinates.
 797     wxPoint dev_org = m_printoutDC->GetDeviceOrigin();
 798     m_printoutDC->SetDeviceOrigin(
 799         dev_org.x + m_printoutDC->LogicalToDeviceXRel(xoff),
 800         dev_org.y + m_printoutDC->LogicalToDeviceYRel(yoff) );
 801 }
 802
 803
 804 //----------------------------------------------------------------------------
 805 // wxPreviewCanvas
 806 //----------------------------------------------------------------------------
 807
 808 IMPLEMENT_CLASS(wxPreviewCanvas, wxWindow)
 809
 810 BEGIN_EVENT_TABLE(wxPreviewCanvas, wxScrolledWindow)
 811     EVT_PAINT(wxPreviewCanvas::OnPaint)
 812     EVT_CHAR(wxPreviewCanvas::OnChar)
 813     EVT_IDLE(wxPreviewCanvas::OnIdle)
 814     EVT_SYS_COLOUR_CHANGED(wxPreviewCanvas::OnSysColourChanged)
 815 #if wxUSE_MOUSEWHEEL
 816     EVT_MOUSEWHEEL(wxPreviewCanvas::OnMouseWheel)
 817 #endif
 818 END_EVENT_TABLE()
 819
 820 // VZ: the current code doesn't refresh properly without
 821 //     wxFULL_REPAINT_ON_RESIZE, this must be fixed as otherwise we have
 822 //     really horrible flicker when resizing the preview frame, but without
 823 //     this style it simply doesn't work correctly at all...
 824 wxPreviewCanvas::wxPreviewCanvas(wxPrintPreviewBase *preview, wxWindow *parent,
 825                                  const wxPoint& pos, const wxSize& size, long style, const wxString& name):
 826 wxScrolledWindow(parent, wxID_ANY, pos, size, style | wxFULL_REPAINT_ON_RESIZE, name)
 827 {
 828     m_printPreview = preview;
 829 #ifdef __WXMAC__
 830     // The app workspace colour is always white, but we should have
 831     // a contrast with the page.
 832     wxSystemColour colourIndex = wxSYS_COLOUR_3DDKSHADOW;
 833 #elif defined(__WXGTK__)
 834     wxSystemColour colourIndex = wxSYS_COLOUR_BTNFACE;
 835 #else
 836     wxSystemColour colourIndex = wxSYS_COLOUR_APPWORKSPACE;
 837 #endif
 838     SetBackgroundColour(wxSystemSettings::GetColour(colourIndex));
 839
 840     SetScrollbars(10, 10, 100, 100);
 841 }
 842
 843 wxPreviewCanvas::~wxPreviewCanvas()
 844 {
 845 }
 846
 847 void wxPreviewCanvas::OnPaint(wxPaintEvent& WXUNUSED(event))
 848 {
 849     wxPaintDC dc(this);
 850     PrepareDC( dc );
 851
 852 /*
 853 #ifdef __WXGTK__
 854     if (!GetUpdateRegion().IsEmpty())
 855         dc.SetClippingRegion( GetUpdateRegion() );
 856 #endif
 857 */
 858
 859     if (m_printPreview)
 860     {
 861         m_printPreview->PaintPage(this, dc);
 862     }
 863 }
 864
 865 void wxPreviewCanvas::OnIdle(wxIdleEvent& event)
 866 {
 867     event.Skip();
 868
 869     // prevent UpdatePageRendering() from being called recursively:
 870     static bool s_inIdle = false;
 871     if ( s_inIdle )
 872         return;
 873     s_inIdle = true;
 874
 875     if ( m_printPreview )
 876     {
 877         if ( m_printPreview->UpdatePageRendering() )
 878             Refresh();
 879     }
 880
 881     s_inIdle = false;
 882 }
 883
 884 // Responds to colour changes, and passes event on to children.
 885 void wxPreviewCanvas::OnSysColourChanged(wxSysColourChangedEvent& event)
 886 {
 887 #ifdef __WXMAC__
 888     // The app workspace colour is always white, but we should have
 889     // a contrast with the page.
 890     wxSystemColour colourIndex = wxSYS_COLOUR_3DDKSHADOW;
 891 #elif defined(__WXGTK__)
 892     wxSystemColour colourIndex = wxSYS_COLOUR_BTNFACE;
 893 #else
 894     wxSystemColour colourIndex = wxSYS_COLOUR_APPWORKSPACE;
 895 #endif
 896     SetBackgroundColour(wxSystemSettings::GetColour(colourIndex));
 897     Refresh();
 898
 899     // Propagate the event to the non-top-level children
 900     wxWindow::OnSysColourChanged(event);
 901 }
 902
 903 void wxPreviewCanvas::OnChar(wxKeyEvent &event)
 904 {
 905     wxPreviewControlBar* controlBar = ((wxPreviewFrame*) GetParent())->GetControlBar();
 906     switch (event.GetKeyCode())
 907     {
 908         case WXK_RETURN:
 909             controlBar->OnPrint();
 910             return;
 911         case (int)'+':
 912         case WXK_NUMPAD_ADD:
 913         case WXK_ADD:
 914             controlBar->DoZoomIn();
 915             return;
 916         case (int)'-':
 917         case WXK_NUMPAD_SUBTRACT:
 918         case WXK_SUBTRACT:
 919             controlBar->DoZoomOut();
 920             return;
 921     }
 922
 923     if (!event.ControlDown())
 924     {
 925         event.Skip();
 926         return;
 927     }
 928
 929     switch(event.GetKeyCode())
 930     {
 931         case WXK_PAGEDOWN:
 932             controlBar->OnNext(); break;
 933         case WXK_PAGEUP:
 934             controlBar->OnPrevious(); break;
 935         case WXK_HOME:
 936             controlBar->OnFirst(); break;
 937         case WXK_END:
 938             controlBar->OnLast(); break;
 939         default:
 940             event.Skip();
 941     }
 942 }
 943
 944 #if wxUSE_MOUSEWHEEL
 945
 946 void wxPreviewCanvas::OnMouseWheel(wxMouseEvent& event)
 947 {
 948     wxPreviewControlBar *
 949         controlBar = wxStaticCast(GetParent(), wxPreviewFrame)->GetControlBar();
 950
 951     if ( controlBar )
 952     {
 953         if ( event.ControlDown() && event.GetWheelRotation() != 0 )
 954         {
 955             int currentZoom = controlBar->GetZoomControl();
 956
 957             int delta;
 958             if ( currentZoom < 100 )
 959                 delta = 5;
 960             else if ( currentZoom <= 120 )
 961                 delta = 10;
 962             else
 963                 delta = 50;
 964
 965             if ( event.GetWheelRotation() > 0 )
 966                 delta = -delta;
 967
 968             int newZoom = currentZoom + delta;
 969             if ( newZoom < 10 )
 970                 newZoom = 10;
 971             if ( newZoom > 200 )
 972                 newZoom = 200;
 973             if ( newZoom != currentZoom )
 974             {
 975                 controlBar->SetZoomControl(newZoom);
 976                 m_printPreview->SetZoom(newZoom);
 977                 Refresh();
 978             }
 979             return;
 980         }
 981     }
 982
 983     event.Skip();
 984 }
 985
 986 #endif // wxUSE_MOUSEWHEEL
 987
 988 // ----------------------------------------------------------------------------
 989 // wxPrintPageTextCtrl
 990 // ----------------------------------------------------------------------------
 991
 992 // This text control contains the page number in the interval specified during
 993 // its construction. Invalid pages are not accepted and the control contents is
 994 // validated when it loses focus. Conversely, if the user changes the page to
 995 // another valid one or presses Enter, OnGotoPage() method of the preview object
 996 // will be called.
 997 class wxPrintPageTextCtrl : public wxTextCtrl
 998 {
 999 public:
1000     wxPrintPageTextCtrl(wxPreviewControlBar *preview, int minPage, int maxPage)
1001         : wxTextCtrl(preview,
1002                      wxID_PREVIEW_GOTO,
1003                      PageAsString(minPage),
1004                      wxDefaultPosition,
1005                      // We use hardcoded 99999 for the width instead of fitting
1006                      // it to the values we can show because the control looks
1007                      // uncomfortably narrow if the real page number is just
1008                      // one or two digits.
1009                      wxSize(preview->GetTextExtent("99999").x, wxDefaultCoord),
1010                      wxTE_PROCESS_ENTER
1011 #if wxUSE_VALIDATORS
1012                      , wxTextValidator(wxFILTER_DIGITS)
1013 #endif // wxUSE_VALIDATORS
1014                     ),
1015           m_preview(preview),
1016           m_minPage(minPage),
1017           m_maxPage(maxPage)
1018     {
1019         m_page = minPage;
1020
1021         Connect(wxEVT_KILL_FOCUS,
1022                 wxFocusEventHandler(wxPrintPageTextCtrl::OnKillFocus));
1023         Connect(wxEVT_COMMAND_TEXT_ENTER,
1024                 wxCommandEventHandler(wxPrintPageTextCtrl::OnTextEnter));
1025     }
1026
1027     // Helpers to conveniently set or get the current page number. Return value
1028     // is 0 if the current controls contents is invalid.
1029     void SetPageNumber(int page)
1030     {
1031         wxASSERT( IsValidPage(page) );
1032
1033         SetValue(PageAsString(page));
1034     }
1035
1036     int GetPageNumber() const
1037     {
1038         long value;
1039         if ( !GetValue().ToLong(&value) || !IsValidPage(value) )
1040             return 0;
1041
1042         // Cast is safe because the value is less than (int) m_maxPage.
1043         return static_cast<int>(value);
1044     }
1045
1046 private:
1047     static wxString PageAsString(int page)
1048     {
1049         return wxString::Format("%d", page);
1050     }
1051
1052     bool IsValidPage(int page) const
1053     {
1054         return page >= m_minPage && page <= m_maxPage;
1055     }
1056
1057     bool DoChangePage()
1058     {
1059         const int page = GetPageNumber();
1060
1061         if ( !page )
1062             return false;
1063
1064         if ( page != m_page )
1065         {
1066             // We have a valid page, remember it.
1067             m_page = page;
1068
1069             // And notify the owner about the change.
1070             m_preview->OnGotoPage();
1071         }
1072         //else: Nothing really changed.
1073
1074         return true;
1075     }
1076
1077     void OnKillFocus(wxFocusEvent& event)
1078     {
1079         if ( !DoChangePage() )
1080         {
1081             // The current contents is invalid so reset it back to the last
1082             // known good page index.
1083             SetPageNumber(m_page);
1084         }
1085
1086         event.Skip();
1087     }
1088
1089     void OnTextEnter(wxCommandEvent& WXUNUSED(event))
1090     {
1091         DoChangePage();
1092     }
1093
1094
1095     wxPreviewControlBar * const m_preview;
1096
1097     const int m_minPage,
1098               m_maxPage;
1099
1100     // This is the last valid page value that we had, we revert to it if an
1101     // invalid page is entered.
1102     int m_page;
1103
1104     wxDECLARE_NO_COPY_CLASS(wxPrintPageTextCtrl);
1105 };
1106
1107 //----------------------------------------------------------------------------
1108 // wxPreviewControlBar
1109 //----------------------------------------------------------------------------
1110
1111 IMPLEMENT_CLASS(wxPreviewControlBar, wxWindow)
1112
1113 BEGIN_EVENT_TABLE(wxPreviewControlBar, wxPanel)
1114     EVT_BUTTON(wxID_PREVIEW_CLOSE,    wxPreviewControlBar::OnWindowClose)
1115     EVT_BUTTON(wxID_PREVIEW_PRINT,    wxPreviewControlBar::OnPrintButton)
1116     EVT_BUTTON(wxID_PREVIEW_PREVIOUS, wxPreviewControlBar::OnPreviousButton)
1117     EVT_BUTTON(wxID_PREVIEW_NEXT,     wxPreviewControlBar::OnNextButton)
1118     EVT_BUTTON(wxID_PREVIEW_FIRST,    wxPreviewControlBar::OnFirstButton)
1119     EVT_BUTTON(wxID_PREVIEW_LAST,     wxPreviewControlBar::OnLastButton)
1120     EVT_BUTTON(wxID_PREVIEW_ZOOM_IN,  wxPreviewControlBar::OnZoomInButton)
1121     EVT_BUTTON(wxID_PREVIEW_ZOOM_OUT, wxPreviewControlBar::OnZoomOutButton)
1122
1123     EVT_UPDATE_UI(wxID_PREVIEW_PREVIOUS, wxPreviewControlBar::OnUpdatePreviousButton)
1124     EVT_UPDATE_UI(wxID_PREVIEW_NEXT,     wxPreviewControlBar::OnUpdateNextButton)
1125     EVT_UPDATE_UI(wxID_PREVIEW_FIRST,    wxPreviewControlBar::OnUpdateFirstButton)
1126     EVT_UPDATE_UI(wxID_PREVIEW_LAST,     wxPreviewControlBar::OnUpdateLastButton)
1127     EVT_UPDATE_UI(wxID_PREVIEW_ZOOM_IN,  wxPreviewControlBar::OnUpdateZoomInButton)
1128     EVT_UPDATE_UI(wxID_PREVIEW_ZOOM_OUT, wxPreviewControlBar::OnUpdateZoomOutButton)
1129
1130     EVT_CHOICE(wxID_PREVIEW_ZOOM,     wxPreviewControlBar::OnZoomChoice)
1131     EVT_PAINT(wxPreviewControlBar::OnPaint)
1132
1133 END_EVENT_TABLE()
1134
1135 wxPreviewControlBar::wxPreviewControlBar(wxPrintPreviewBase *preview, long buttons,
1136                                          wxWindow *parent, const wxPoint& pos, const wxSize& size,
1137                                          long style, const wxString& name):
1138 wxPanel(parent, wxID_ANY, pos, size, style, name)
1139 {
1140     m_printPreview = preview;
1141     m_closeButton = NULL;
1142     m_zoomControl = NULL;
1143     m_currentPageText = NULL;
1144     m_buttonFlags = buttons;
1145 }
1146
1147 wxPreviewControlBar::~wxPreviewControlBar()
1148 {
1149 }
1150
1151 void wxPreviewControlBar::OnPaint(wxPaintEvent& WXUNUSED(event))
1152 {
1153     wxPaintDC dc(this);
1154
1155     int w, h;
1156     GetSize(&w, &h);
1157     dc.SetPen(*wxBLACK_PEN);
1158     dc.SetBrush(*wxTRANSPARENT_BRUSH);
1159     dc.DrawLine( 0, h-1, w, h-1 );
1160 }
1161
1162 void wxPreviewControlBar::OnWindowClose(wxCommandEvent& WXUNUSED(event))
1163 {
1164     wxPreviewFrame *frame = (wxPreviewFrame *)GetParent();
1165     frame->Close(true);
1166 }
1167
1168 void wxPreviewControlBar::OnPrint(void)
1169 {
1170     wxPrintPreviewBase *preview = GetPrintPreview();
1171     preview->Print(true);
1172 }
1173
1174 void wxPreviewControlBar::OnNext()
1175 {
1176     if ( IsNextEnabled() )
1177         DoGotoPage(GetPrintPreview()->GetCurrentPage() + 1);
1178 }
1179
1180 void wxPreviewControlBar::OnPrevious()
1181 {
1182     if ( IsPreviousEnabled() )
1183         DoGotoPage(GetPrintPreview()->GetCurrentPage() - 1);
1184 }
1185
1186 void wxPreviewControlBar::OnFirst()
1187 {
1188     if ( IsFirstEnabled() )
1189         DoGotoPage(GetPrintPreview()->GetMinPage());
1190 }
1191
1192 void wxPreviewControlBar::OnLast()
1193 {
1194     if ( IsLastEnabled() )
1195         DoGotoPage(GetPrintPreview()->GetMaxPage());
1196 }
1197
1198 bool wxPreviewControlBar::IsNextEnabled() const
1199 {
1200     wxPrintPreviewBase *preview = GetPrintPreview();
1201     if ( !preview )
1202         return false;
1203
1204     const int currentPage = preview->GetCurrentPage();
1205     return currentPage < preview->GetMaxPage() &&
1206                 preview->GetPrintout()->HasPage(currentPage + 1);
1207 }
1208
1209 bool wxPreviewControlBar::IsPreviousEnabled() const
1210 {
1211     wxPrintPreviewBase *preview = GetPrintPreview();
1212     if ( !preview )
1213         return false;
1214
1215     const int currentPage = preview->GetCurrentPage();
1216     return currentPage > preview->GetMinPage() &&
1217                 preview->GetPrintout()->HasPage(currentPage - 1);
1218 }
1219
1220 bool wxPreviewControlBar::IsFirstEnabled() const
1221 {
1222     wxPrintPreviewBase *preview = GetPrintPreview();
1223     if (!preview)
1224         return false;
1225
1226     return preview->GetPrintout()->HasPage(preview->GetMinPage());
1227 }
1228
1229 bool wxPreviewControlBar::IsLastEnabled() const
1230 {
1231     wxPrintPreviewBase *preview = GetPrintPreview();
1232     if (!preview)
1233         return false;
1234
1235     return preview->GetPrintout()->HasPage(preview->GetMaxPage());
1236 }
1237
1238 void wxPreviewControlBar::DoGotoPage(int page)
1239 {
1240     wxPrintPreviewBase *preview = GetPrintPreview();
1241     wxCHECK_RET( preview, "Shouldn't be called if there is no preview." );
1242
1243     preview->SetCurrentPage(page);
1244
1245     if ( m_currentPageText )
1246         m_currentPageText->SetPageNumber(page);
1247 }
1248
1249 void wxPreviewControlBar::OnGotoPage()
1250 {
1251     wxPrintPreviewBase *preview = GetPrintPreview();
1252     if (preview)
1253     {
1254         if (preview->GetMinPage() > 0)
1255         {
1256             long currentPage = m_currentPageText->GetPageNumber();
1257             if ( currentPage )
1258             {
1259                 if (preview->GetPrintout()->HasPage(currentPage))
1260                 {
1261                     preview->SetCurrentPage(currentPage);
1262                 }
1263             }
1264         }
1265     }
1266 }
1267
1268 void wxPreviewControlBar::DoZoom()
1269 {
1270     int zoom = GetZoomControl();
1271     if (GetPrintPreview())
1272         GetPrintPreview()->SetZoom(zoom);
1273 }
1274
1275 bool wxPreviewControlBar::IsZoomInEnabled() const
1276 {
1277     if ( !m_zoomControl )
1278         return false;
1279
1280     const unsigned sel = m_zoomControl->GetSelection();
1281     return sel < m_zoomControl->GetCount() - 1;
1282 }
1283
1284 bool wxPreviewControlBar::IsZoomOutEnabled() const
1285 {
1286     return m_zoomControl && m_zoomControl->GetSelection() > 0;
1287 }
1288
1289 void wxPreviewControlBar::DoZoomIn()
1290 {
1291     if (IsZoomInEnabled())
1292     {
1293         m_zoomControl->SetSelection(m_zoomControl->GetSelection() + 1);
1294         DoZoom();
1295     }
1296 }
1297
1298 void wxPreviewControlBar::DoZoomOut()
1299 {
1300     if (IsZoomOutEnabled())
1301     {
1302         m_zoomControl->SetSelection(m_zoomControl->GetSelection() - 1);
1303         DoZoom();
1304     }
1305 }
1306
1307 namespace
1308 {
1309
1310 // Helper class used by wxPreviewControlBar::CreateButtons() to add buttons
1311 // sequentially to it in the simplest way possible.
1312 class SizerWithButtons
1313 {
1314 public:
1315     // Constructor creates the sizer that will hold the buttons and stores the
1316     // parent that will be used for their creation.
1317     SizerWithButtons(wxWindow *parent)
1318         : m_sizer(new wxBoxSizer(wxHORIZONTAL)),
1319           m_parent(parent)
1320     {
1321         m_hasContents =
1322         m_needsSeparator = false;
1323     }
1324
1325     // Destructor associates the sizer with the parent window.
1326     ~SizerWithButtons()
1327     {
1328         m_parent->SetSizer(m_sizer);
1329         m_sizer->Fit(m_parent);
1330     }
1331
1332
1333     // Add an arbitrary window to the sizer.
1334     void Add(wxWindow *win)
1335     {
1336         if ( m_needsSeparator )
1337         {
1338             m_needsSeparator = false;
1339
1340             m_sizer->AddSpacer(2*wxSizerFlags::GetDefaultBorder());
1341         }
1342
1343         m_hasContents = true;
1344
1345         m_sizer->Add(win,
1346                      wxSizerFlags().Border(wxLEFT | wxTOP | wxBOTTOM).Center());
1347     }
1348
1349     // Add a button with the specified id, bitmap and tooltip.
1350     void AddButton(wxWindowID btnId,
1351                    const wxArtID& artId,
1352                    const wxString& tooltip)
1353     {
1354         // We don't use (smaller) images inside a button with a text label but
1355         // rather toolbar-like bitmap buttons hence use wxART_TOOLBAR and not
1356         // wxART_BUTTON here.
1357         wxBitmap bmp = wxArtProvider::GetBitmap(artId, wxART_TOOLBAR);
1358         wxBitmapButton * const btn = new wxBitmapButton(m_parent, btnId, bmp);
1359         btn->SetToolTip(tooltip);
1360
1361         Add(btn);
1362     }
1363
1364     // Add a control at the right end of the window. This should be called last
1365     // as everything else added after it will be added on the right side too.
1366     void AddAtEnd(wxWindow *win)
1367     {
1368         m_sizer->AddStretchSpacer();
1369         m_sizer->Add(win,
1370                      wxSizerFlags().Border(wxTOP | wxBOTTOM | wxRIGHT).Center());
1371     }
1372
1373     // Indicates the end of a group of buttons, a separator will be added after
1374     // it.
1375     void EndOfGroup()
1376     {
1377         if ( m_hasContents )
1378         {
1379             m_needsSeparator = true;
1380             m_hasContents = false;
1381         }
1382     }
1383
1384 private:
1385     wxSizer * const m_sizer;
1386     wxWindow * const m_parent;
1387
1388     // If true, we have some controls since the last group beginning. This is
1389     // used to avoid inserting two consecutive separators if EndOfGroup() is
1390     // called twice.
1391     bool m_hasContents;
1392
1393     // If true, a separator should be inserted before adding the next button.
1394     bool m_needsSeparator;
1395
1396     wxDECLARE_NO_COPY_CLASS(SizerWithButtons);
1397 };
1398
1399 } // anonymous namespace
1400
1401 void wxPreviewControlBar::CreateButtons()
1402 {
1403     SetSize(0, 0, 400, 40);
1404
1405     SizerWithButtons sizer(this);
1406
1407     // Print button group (a single button).
1408     if (m_buttonFlags & wxPREVIEW_PRINT)
1409     {
1410         sizer.AddButton(wxID_PREVIEW_PRINT, wxART_PRINT, _("Print"));
1411         sizer.EndOfGroup();
1412     }
1413
1414     // Page selection buttons group.
1415     if (m_buttonFlags & wxPREVIEW_FIRST)
1416     {
1417         sizer.AddButton(wxID_PREVIEW_FIRST, wxART_GOTO_FIRST, _("First page"));
1418     }
1419
1420     if (m_buttonFlags & wxPREVIEW_PREVIOUS)
1421     {
1422         sizer.AddButton(wxID_PREVIEW_PREVIOUS, wxART_GO_BACK, _("Previous page"));
1423     }
1424
1425     if (m_buttonFlags & wxPREVIEW_GOTO)
1426     {
1427         int minPage, maxPage, pageFrom, pageTo;
1428         m_printPreview->GetPrintout()->GetPageInfo(&minPage, &maxPage,
1429                                                    &pageFrom, &pageTo);
1430
1431         m_currentPageText = new wxPrintPageTextCtrl(this, minPage, maxPage);
1432         sizer.Add(m_currentPageText);
1433
1434         wxStaticText *
1435             maxPageText = new wxStaticText(this, wxID_ANY,
1436                                            wxString::Format("/ %d", maxPage));
1437
1438         sizer.Add(maxPageText);
1439     }
1440
1441     if (m_buttonFlags & wxPREVIEW_NEXT)
1442     {
1443         sizer.AddButton(wxID_PREVIEW_NEXT, wxART_GO_FORWARD, _("Next page"));
1444     }
1445
1446     if (m_buttonFlags & wxPREVIEW_LAST)
1447     {
1448         sizer.AddButton(wxID_PREVIEW_LAST, wxART_GOTO_LAST, _("Last page"));
1449     }
1450
1451     sizer.EndOfGroup();
1452
1453     // Zoom controls group.
1454     if (m_buttonFlags & wxPREVIEW_ZOOM)
1455     {
1456         sizer.AddButton(wxID_PREVIEW_ZOOM_OUT, wxART_MINUS, _("Zoom Out"));
1457
1458         wxString choices[] =
1459         {
1460             wxT("10%"), wxT("15%"), wxT("20%"), wxT("25%"), wxT("30%"), wxT("35%"), wxT("40%"), wxT("45%"), wxT("50%"), wxT("55%"),
1461                 wxT("60%"), wxT("65%"), wxT("70%"), wxT("75%"), wxT("80%"), wxT("85%"), wxT("90%"), wxT("95%"), wxT("100%"), wxT("110%"),
1462                 wxT("120%"), wxT("150%"), wxT("200%")
1463         };
1464         int n = WXSIZEOF(choices);
1465
1466         m_zoomControl = new wxChoice( this, wxID_PREVIEW_ZOOM, wxDefaultPosition, wxSize(70,wxDefaultCoord), n, choices, 0 );
1467         sizer.Add(m_zoomControl);
1468         SetZoomControl(m_printPreview->GetZoom());
1469
1470         sizer.AddButton(wxID_PREVIEW_ZOOM_IN, wxART_PLUS, _("Zoom In"));
1471
1472         sizer.EndOfGroup();
1473     }
1474
1475     // Close button group (single button again).
1476     m_closeButton = new wxButton(this, wxID_PREVIEW_CLOSE, _("&Close"));
1477     sizer.AddAtEnd(m_closeButton);
1478 }
1479
1480 void wxPreviewControlBar::SetZoomControl(int zoom)
1481 {
1482     if (m_zoomControl)
1483     {
1484         int n, count = m_zoomControl->GetCount();
1485         long val;
1486         for (n=0; n<count; n++)
1487         {
1488             if (m_zoomControl->GetString(n).BeforeFirst(wxT('%')).ToLong(&val) &&
1489                 (val >= long(zoom)))
1490             {
1491                 m_zoomControl->SetSelection(n);
1492                 return;
1493             }
1494         }
1495
1496         m_zoomControl->SetSelection(count-1);
1497     }
1498 }
1499
1500 int wxPreviewControlBar::GetZoomControl()
1501 {
1502     if (m_zoomControl && (m_zoomControl->GetStringSelection() != wxEmptyString))
1503     {
1504         long val;
1505         if (m_zoomControl->GetStringSelection().BeforeFirst(wxT('%')).ToLong(&val))
1506             return int(val);
1507     }
1508
1509     return 0;
1510 }
1511
1512
1513 /*
1514 * Preview frame
1515 */
1516
1517 IMPLEMENT_CLASS(wxPreviewFrame, wxFrame)
1518
1519 BEGIN_EVENT_TABLE(wxPreviewFrame, wxFrame)
1520     EVT_CHAR_HOOK(wxPreviewFrame::OnChar)
1521     EVT_CLOSE(wxPreviewFrame::OnCloseWindow)
1522 END_EVENT_TABLE()
1523
1524 void wxPreviewFrame::OnChar(wxKeyEvent &event)
1525 {
1526     if ( event.GetKeyCode() == WXK_ESCAPE )
1527     {
1528         Close(true);
1529     }
1530     else
1531     {
1532         event.Skip();
1533     }
1534 }
1535
1536 wxPreviewFrame::wxPreviewFrame(wxPrintPreviewBase *preview, wxWindow *parent, const wxString& title,
1537                                const wxPoint& pos, const wxSize& size, long style, const wxString& name):
1538 wxFrame(parent, wxID_ANY, title, pos, size, style, name)
1539 {
1540     m_printPreview = preview;
1541     m_controlBar = NULL;
1542     m_previewCanvas = NULL;
1543     m_windowDisabler = NULL;
1544
1545     // Give the application icon
1546 #ifdef __WXMSW__
1547     wxFrame* topFrame = wxDynamicCast(wxTheApp->GetTopWindow(), wxFrame);
1548     if (topFrame)
1549         SetIcons(topFrame->GetIcons());
1550 #endif
1551 }
1552
1553 wxPreviewFrame::~wxPreviewFrame()
1554 {
1555 }
1556
1557 void wxPreviewFrame::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
1558 {
1559     if (m_windowDisabler)
1560         delete m_windowDisabler;
1561
1562     // Need to delete the printout and the print preview
1563     wxPrintout *printout = m_printPreview->GetPrintout();
1564     if (printout)
1565     {
1566         delete printout;
1567         m_printPreview->SetPrintout(NULL);
1568         m_printPreview->SetCanvas(NULL);
1569         m_printPreview->SetFrame(NULL);
1570     }
1571
1572     m_previewCanvas->SetPreview(NULL);
1573     wxDELETE(m_printPreview);
1574
1575     Destroy();
1576 }
1577
1578 void wxPreviewFrame::Initialize()
1579 {
1580 #if wxUSE_STATUSBAR
1581     CreateStatusBar();
1582 #endif
1583     CreateCanvas();
1584     CreateControlBar();
1585
1586     m_printPreview->SetCanvas(m_previewCanvas);
1587     m_printPreview->SetFrame(this);
1588
1589     wxBoxSizer *item0 = new wxBoxSizer( wxVERTICAL );
1590
1591     item0->Add( m_controlBar, 0, wxGROW|wxALIGN_CENTER_VERTICAL, 5 );
1592     item0->Add( m_previewCanvas, 1, wxGROW|wxALIGN_CENTER_VERTICAL, 5 );
1593
1594     SetAutoLayout( true );
1595     SetSizer( item0 );
1596
1597     m_windowDisabler = new wxWindowDisabler(this);
1598
1599     Layout();
1600
1601     m_printPreview->AdjustScrollbars(m_previewCanvas);
1602     m_previewCanvas->SetFocus();
1603     m_controlBar->SetFocus();
1604 }
1605
1606 void wxPreviewFrame::CreateCanvas()
1607 {
1608     m_previewCanvas = new wxPreviewCanvas(m_printPreview, this);
1609 }
1610
1611 void wxPreviewFrame::CreateControlBar()
1612 {
1613     long buttons = wxPREVIEW_DEFAULT;
1614     if (m_printPreview->GetPrintoutForPrinting())
1615         buttons |= wxPREVIEW_PRINT;
1616
1617     m_controlBar = new wxPreviewControlBar(m_printPreview, buttons, this, wxPoint(0,0), wxSize(400, 40));
1618     m_controlBar->CreateButtons();
1619 }
1620
1621 /*
1622 * Print preview
1623 */
1624
1625 IMPLEMENT_CLASS(wxPrintPreviewBase, wxObject)
1626
1627 wxPrintPreviewBase::wxPrintPreviewBase(wxPrintout *printout,
1628                                        wxPrintout *printoutForPrinting,
1629                                        wxPrintData *data)
1630 {
1631     if (data)
1632         m_printDialogData = (*data);
1633
1634     Init(printout, printoutForPrinting);
1635 }
1636
1637 wxPrintPreviewBase::wxPrintPreviewBase(wxPrintout *printout,
1638                                        wxPrintout *printoutForPrinting,
1639                                        wxPrintDialogData *data)
1640 {
1641     if (data)
1642         m_printDialogData = (*data);
1643
1644     Init(printout, printoutForPrinting);
1645 }
1646
1647 void wxPrintPreviewBase::Init(wxPrintout *printout,
1648                               wxPrintout *printoutForPrinting)
1649 {
1650     m_isOk = true;
1651     m_previewPrintout = printout;
1652     if (m_previewPrintout)
1653         m_previewPrintout->SetPreview(static_cast<wxPrintPreview *>(this));
1654
1655     m_printPrintout = printoutForPrinting;
1656
1657     m_previewCanvas = NULL;
1658     m_previewFrame = NULL;
1659     m_previewBitmap = NULL;
1660     m_previewFailed = false;
1661     m_currentPage = 1;
1662     m_currentZoom = 70;
1663     m_topMargin = 40;
1664     m_leftMargin = 40;
1665     m_pageWidth = 0;
1666     m_pageHeight = 0;
1667     m_printingPrepared = false;
1668     m_minPage = 1;
1669     m_maxPage = 1;
1670 }
1671
1672 wxPrintPreviewBase::~wxPrintPreviewBase()
1673 {
1674     if (m_previewPrintout)
1675         delete m_previewPrintout;
1676     if (m_previewBitmap)
1677         delete m_previewBitmap;
1678     if (m_printPrintout)
1679         delete m_printPrintout;
1680 }
1681
1682 bool wxPrintPreviewBase::SetCurrentPage(int pageNum)
1683 {
1684     if (m_currentPage == pageNum)
1685         return true;
1686
1687     m_currentPage = pageNum;
1688
1689     InvalidatePreviewBitmap();
1690
1691     if (m_previewCanvas)
1692     {
1693         AdjustScrollbars(m_previewCanvas);
1694
1695         m_previewCanvas->Refresh();
1696         m_previewCanvas->SetFocus();
1697     }
1698     return true;
1699 }
1700
1701 int wxPrintPreviewBase::GetCurrentPage() const
1702     { return m_currentPage; }
1703 void wxPrintPreviewBase::SetPrintout(wxPrintout *printout)
1704     { m_previewPrintout = printout; }
1705 wxPrintout *wxPrintPreviewBase::GetPrintout() const
1706     { return m_previewPrintout; }
1707 wxPrintout *wxPrintPreviewBase::GetPrintoutForPrinting() const
1708     { return m_printPrintout; }
1709 void wxPrintPreviewBase::SetFrame(wxFrame *frame)
1710     { m_previewFrame = frame; }
1711 void wxPrintPreviewBase::SetCanvas(wxPreviewCanvas *canvas)
1712     { m_previewCanvas = canvas; }
1713 wxFrame *wxPrintPreviewBase::GetFrame() const
1714     { return m_previewFrame; }
1715 wxPreviewCanvas *wxPrintPreviewBase::GetCanvas() const
1716     { return m_previewCanvas; }
1717
1718 void wxPrintPreviewBase::CalcRects(wxPreviewCanvas *canvas, wxRect& pageRect, wxRect& paperRect)
1719 {
1720     // Calculate the rectangles for the printable area of the page and the
1721     // entire paper as they appear on the canvas on-screen.
1722     int canvasWidth, canvasHeight;
1723     canvas->GetSize(&canvasWidth, &canvasHeight);
1724
1725     float zoomScale = float(m_currentZoom) / 100;
1726     float screenPrintableWidth = zoomScale * m_pageWidth * m_previewScaleX;
1727     float screenPrintableHeight = zoomScale * m_pageHeight * m_previewScaleY;
1728
1729     wxRect devicePaperRect = m_previewPrintout->GetPaperRectPixels();
1730     wxCoord devicePrintableWidth, devicePrintableHeight;
1731     m_previewPrintout->GetPageSizePixels(&devicePrintableWidth, &devicePrintableHeight);
1732     float scaleX = screenPrintableWidth / devicePrintableWidth;
1733     float scaleY = screenPrintableHeight / devicePrintableHeight;
1734     paperRect.width = wxCoord(scaleX * devicePaperRect.width);
1735     paperRect.height = wxCoord(scaleY * devicePaperRect.height);
1736
1737     paperRect.x = wxCoord((canvasWidth - paperRect.width)/ 2.0);
1738     if (paperRect.x < m_leftMargin)
1739         paperRect.x = m_leftMargin;
1740     paperRect.y = wxCoord((canvasHeight - paperRect.height)/ 2.0);
1741     if (paperRect.y < m_topMargin)
1742         paperRect.y = m_topMargin;
1743
1744     pageRect.x = paperRect.x - wxCoord(scaleX * devicePaperRect.x);
1745     pageRect.y = paperRect.y - wxCoord(scaleY * devicePaperRect.y);
1746     pageRect.width = wxCoord(screenPrintableWidth);
1747     pageRect.height = wxCoord(screenPrintableHeight);
1748 }
1749
1750
1751 void wxPrintPreviewBase::InvalidatePreviewBitmap()
1752 {
1753     wxDELETE(m_previewBitmap);
1754     // if there was a problem with rendering the preview, try again now
1755     // that it changed in some way (less memory may be needed, for example):
1756     m_previewFailed = false;
1757 }
1758
1759 bool wxPrintPreviewBase::UpdatePageRendering()
1760 {
1761     if ( m_previewBitmap )
1762         return false;
1763
1764     if ( m_previewFailed )
1765         return false;
1766
1767     if ( !RenderPage(m_currentPage) )
1768     {
1769         m_previewFailed = true; // don't waste time failing again
1770         return false;
1771     }
1772
1773     return true;
1774 }
1775
1776 bool wxPrintPreviewBase::PaintPage(wxPreviewCanvas *canvas, wxDC& dc)
1777 {
1778     DrawBlankPage(canvas, dc);
1779
1780     if (!m_previewBitmap)
1781         return false;
1782     if (!canvas)
1783         return false;
1784
1785     wxRect pageRect, paperRect;
1786     CalcRects(canvas, pageRect, paperRect);
1787     wxMemoryDC temp_dc;
1788     temp_dc.SelectObject(*m_previewBitmap);
1789
1790     dc.Blit(pageRect.x, pageRect.y,
1791         m_previewBitmap->GetWidth(), m_previewBitmap->GetHeight(), &temp_dc, 0, 0);
1792
1793     temp_dc.SelectObject(wxNullBitmap);
1794     return true;
1795 }
1796
1797 // Adjusts the scrollbars for the current scale
1798 void wxPrintPreviewBase::AdjustScrollbars(wxPreviewCanvas *canvas)
1799 {
1800     if (!canvas)
1801         return ;
1802
1803     wxRect pageRect, paperRect;
1804     CalcRects(canvas, pageRect, paperRect);
1805      int totalWidth = paperRect.width + 2 * m_leftMargin;
1806     int totalHeight = paperRect.height + 2 * m_topMargin;
1807     int scrollUnitsX = totalWidth / 10;
1808     int scrollUnitsY = totalHeight / 10;
1809     wxSize virtualSize = canvas->GetVirtualSize();
1810     if (virtualSize.GetWidth() != totalWidth || virtualSize.GetHeight() != totalHeight)
1811         canvas->SetScrollbars(10, 10, scrollUnitsX, scrollUnitsY, 0, 0, true);
1812 }
1813
1814 bool wxPrintPreviewBase::RenderPageIntoDC(wxDC& dc, int pageNum)
1815 {
1816     m_previewPrintout->SetDC(&dc);
1817     m_previewPrintout->SetPageSizePixels(m_pageWidth, m_pageHeight);
1818
1819     // Need to delay OnPreparePrinting() until here, so we have enough
1820     // information.
1821     if (!m_printingPrepared)
1822     {
1823         m_previewPrintout->OnPreparePrinting();
1824         int selFrom, selTo;
1825         m_previewPrintout->GetPageInfo(&m_minPage, &m_maxPage, &selFrom, &selTo);
1826         m_printingPrepared = true;
1827     }
1828
1829     m_previewPrintout->OnBeginPrinting();
1830
1831     if (!m_previewPrintout->OnBeginDocument(m_printDialogData.GetFromPage(), m_printDialogData.GetToPage()))
1832     {
1833         wxMessageBox(_("Could not start document preview."), _("Print Preview Failure"), wxOK);
1834         return false;
1835     }
1836
1837     m_previewPrintout->OnPrintPage(pageNum);
1838     m_previewPrintout->OnEndDocument();
1839     m_previewPrintout->OnEndPrinting();
1840
1841     m_previewPrintout->SetDC(NULL);
1842
1843     return true;
1844 }
1845
1846 bool wxPrintPreviewBase::RenderPageIntoBitmap(wxBitmap& bmp, int pageNum)
1847 {
1848     wxMemoryDC memoryDC;
1849     memoryDC.SelectObject(bmp);
1850     memoryDC.Clear();
1851
1852     return RenderPageIntoDC(memoryDC, pageNum);
1853 }
1854
1855 bool wxPrintPreviewBase::RenderPage(int pageNum)
1856 {
1857     wxBusyCursor busy;
1858
1859     if (!m_previewCanvas)
1860     {
1861         wxFAIL_MSG(wxT("wxPrintPreviewBase::RenderPage: must use wxPrintPreviewBase::SetCanvas to let me know about the canvas!"));
1862         return false;
1863     }
1864
1865     wxRect pageRect, paperRect;
1866     CalcRects(m_previewCanvas, pageRect, paperRect);
1867
1868     if (!m_previewBitmap)
1869     {
1870         m_previewBitmap = new wxBitmap(pageRect.width, pageRect.height);
1871
1872         if (!m_previewBitmap || !m_previewBitmap->Ok())
1873         {
1874             InvalidatePreviewBitmap();
1875             wxMessageBox(_("Sorry, not enough memory to create a preview."), _("Print Preview Failure"), wxOK);
1876             return false;
1877         }
1878     }
1879
1880     if ( !RenderPageIntoBitmap(*m_previewBitmap, pageNum) )
1881     {
1882         InvalidatePreviewBitmap();
1883         wxMessageBox(_("Sorry, not enough memory to create a preview."), _("Print Preview Failure"), wxOK);
1884         return false;
1885     }
1886
1887 #if wxUSE_STATUSBAR
1888     wxString status;
1889     if (m_maxPage != 0)
1890         status = wxString::Format(_("Page %d of %d"), pageNum, m_maxPage);
1891     else
1892         status = wxString::Format(_("Page %d"), pageNum);
1893
1894     if (m_previewFrame)
1895         m_previewFrame->SetStatusText(status);
1896 #endif
1897
1898     return true;
1899 }
1900
1901 bool wxPrintPreviewBase::DrawBlankPage(wxPreviewCanvas *canvas, wxDC& dc)
1902 {
1903     wxRect pageRect, paperRect;
1904
1905     CalcRects(canvas, pageRect, paperRect);
1906
1907     // Draw shadow, allowing for 1-pixel border AROUND the actual paper
1908     wxCoord shadowOffset = 4;
1909
1910     dc.SetPen(*wxBLACK_PEN);
1911     dc.SetBrush(*wxBLACK_BRUSH);
1912     dc.DrawRectangle(paperRect.x + shadowOffset, paperRect.y + paperRect.height + 1,
1913         paperRect.width, shadowOffset);
1914
1915     dc.DrawRectangle(paperRect.x + paperRect.width, paperRect.y + shadowOffset,
1916         shadowOffset, paperRect.height);
1917
1918     // Draw blank page allowing for 1-pixel border AROUND the actual paper
1919     dc.SetPen(*wxBLACK_PEN);
1920     dc.SetBrush(*wxWHITE_BRUSH);
1921     dc.DrawRectangle(paperRect.x - 2, paperRect.y - 1,
1922         paperRect.width + 3, paperRect.height + 2);
1923
1924     return true;
1925 }
1926
1927 void wxPrintPreviewBase::SetZoom(int percent)
1928 {
1929     if (m_currentZoom == percent)
1930         return;
1931
1932     m_currentZoom = percent;
1933
1934     InvalidatePreviewBitmap();
1935
1936     if (m_previewCanvas)
1937     {
1938         AdjustScrollbars(m_previewCanvas);
1939         ((wxScrolledWindow *) m_previewCanvas)->Scroll(0, 0);
1940         m_previewCanvas->ClearBackground();
1941         m_previewCanvas->Refresh();
1942         m_previewCanvas->SetFocus();
1943     }
1944 }
1945
1946 wxPrintDialogData& wxPrintPreviewBase::GetPrintDialogData()
1947 {
1948     return m_printDialogData;
1949 }
1950
1951 int wxPrintPreviewBase::GetZoom() const
1952 { return m_currentZoom; }
1953 int wxPrintPreviewBase::GetMaxPage() const
1954 { return m_maxPage; }
1955 int wxPrintPreviewBase::GetMinPage() const
1956 { return m_minPage; }
1957 bool wxPrintPreviewBase::IsOk() const
1958 { return m_isOk; }
1959 void wxPrintPreviewBase::SetOk(bool ok)
1960 { m_isOk = ok; }
1961
1962 //----------------------------------------------------------------------------
1963 // wxPrintPreview
1964 //----------------------------------------------------------------------------
1965
1966 IMPLEMENT_CLASS(wxPrintPreview, wxPrintPreviewBase)
1967
1968 wxPrintPreview::wxPrintPreview(wxPrintout *printout,
1969                    wxPrintout *printoutForPrinting,
1970                    wxPrintDialogData *data) :
1971     wxPrintPreviewBase( printout, printoutForPrinting, data )
1972 {
1973     m_pimpl = wxPrintFactory::GetFactory()->
1974         CreatePrintPreview( printout, printoutForPrinting, data );
1975 }
1976
1977 wxPrintPreview::wxPrintPreview(wxPrintout *printout,
1978                    wxPrintout *printoutForPrinting,
1979                    wxPrintData *data ) :
1980     wxPrintPreviewBase( printout, printoutForPrinting, data )
1981 {
1982     m_pimpl = wxPrintFactory::GetFactory()->
1983         CreatePrintPreview( printout, printoutForPrinting, data );
1984 }
1985
1986 wxPrintPreview::~wxPrintPreview()
1987 {
1988     delete m_pimpl;
1989
1990     // don't delete twice
1991     m_printPrintout = NULL;
1992     m_previewPrintout = NULL;
1993     m_previewBitmap = NULL;
1994 }
1995
1996 bool wxPrintPreview::SetCurrentPage(int pageNum)
1997 {
1998     return m_pimpl->SetCurrentPage( pageNum );
1999 }
2000
2001 int wxPrintPreview::GetCurrentPage() const
2002 {
2003     return m_pimpl->GetCurrentPage();
2004 }
2005
2006 void wxPrintPreview::SetPrintout(wxPrintout *printout)
2007 {
2008     m_pimpl->SetPrintout( printout );
2009 }
2010
2011 wxPrintout *wxPrintPreview::GetPrintout() const
2012 {
2013     return m_pimpl->GetPrintout();
2014 }
2015
2016 wxPrintout *wxPrintPreview::GetPrintoutForPrinting() const
2017 {
2018     return m_pimpl->GetPrintoutForPrinting();
2019 }
2020
2021 void wxPrintPreview::SetFrame(wxFrame *frame)
2022 {
2023     m_pimpl->SetFrame( frame );
2024 }
2025
2026 void wxPrintPreview::SetCanvas(wxPreviewCanvas *canvas)
2027 {
2028     m_pimpl->SetCanvas( canvas );
2029 }
2030
2031 wxFrame *wxPrintPreview::GetFrame() const
2032 {
2033     return m_pimpl->GetFrame();
2034 }
2035
2036 wxPreviewCanvas *wxPrintPreview::GetCanvas() const
2037 {
2038     return m_pimpl->GetCanvas();
2039 }
2040
2041 bool wxPrintPreview::PaintPage(wxPreviewCanvas *canvas, wxDC& dc)
2042 {
2043     return m_pimpl->PaintPage( canvas, dc );
2044 }
2045
2046 bool wxPrintPreview::UpdatePageRendering()
2047 {
2048     return m_pimpl->UpdatePageRendering();
2049 }
2050
2051 bool wxPrintPreview::DrawBlankPage(wxPreviewCanvas *canvas, wxDC& dc)
2052 {
2053     return m_pimpl->DrawBlankPage( canvas, dc );
2054 }
2055
2056 void wxPrintPreview::AdjustScrollbars(wxPreviewCanvas *canvas)
2057 {
2058     m_pimpl->AdjustScrollbars( canvas );
2059 }
2060
2061 bool wxPrintPreview::RenderPage(int pageNum)
2062 {
2063     return m_pimpl->RenderPage( pageNum );
2064 }
2065
2066 void wxPrintPreview::SetZoom(int percent)
2067 {
2068     m_pimpl->SetZoom( percent );
2069 }
2070
2071 int wxPrintPreview::GetZoom() const
2072 {
2073     return m_pimpl->GetZoom();
2074 }
2075
2076 wxPrintDialogData& wxPrintPreview::GetPrintDialogData()
2077 {
2078     return m_pimpl->GetPrintDialogData();
2079 }
2080
2081 int wxPrintPreview::GetMaxPage() const
2082 {
2083     return m_pimpl->GetMaxPage();
2084 }
2085
2086 int wxPrintPreview::GetMinPage() const
2087 {
2088     return m_pimpl->GetMinPage();
2089 }
2090
2091 bool wxPrintPreview::IsOk() const
2092 {
2093     return m_pimpl->Ok();
2094 }
2095
2096 void wxPrintPreview::SetOk(bool ok)
2097 {
2098     m_pimpl->SetOk( ok );
2099 }
2100
2101 bool wxPrintPreview::Print(bool interactive)
2102 {
2103     return m_pimpl->Print( interactive );
2104 }
2105
2106 void wxPrintPreview::DetermineScaling()
2107 {
2108     m_pimpl->DetermineScaling();
2109 }
2110
2111 #endif // wxUSE_PRINTING_ARCHITECTURE