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/msgdlg.h"
  31     #include "wx/layout.h"
  32     #include "wx/choice.h"
  33     #include "wx/button.h"
  34     #include "wx/settings.h"
  35     #include "wx/dcmemory.h"
  36     #include "wx/stattext.h"
  37     #include "wx/intl.h"
  38     #include "wx/textdlg.h"
  39     #include "wx/sizer.h"
  40     #include "wx/module.h"
  41 #endif // !WX_PRECOMP
  42
  43 #include "wx/prntbase.h"
  44 #include "wx/printdlg.h"
  45 #include "wx/print.h"
  46 #include "wx/dcprint.h"
  47
  48 #include <stdlib.h>
  49 #include <string.h>
  50
  51 #if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
  52 #include "wx/msw/printdlg.h"
  53 #elif defined(__WXMAC__)
  54 #include "wx/mac/printdlg.h"
  55 #include "wx/mac/private/print.h"
  56 #else
  57 #include "wx/generic/prntdlgg.h"
  58 #include "wx/dcps.h"
  59 #endif
  60
  61 #ifdef __WXMSW__
  62     #ifndef __WIN32__
  63         #include <print.h>
  64     #endif
  65 #endif // __WXMSW__
  66
  67 //----------------------------------------------------------------------------
  68 // wxPrintFactory
  69 //----------------------------------------------------------------------------
  70
  71 wxPrintFactory *wxPrintFactory::m_factory = NULL;
  72
  73 void wxPrintFactory::SetPrintFactory( wxPrintFactory *factory )
  74 {
  75     if (wxPrintFactory::m_factory)
  76         delete wxPrintFactory::m_factory;
  77
  78     wxPrintFactory::m_factory = factory;
  79 }
  80
  81 wxPrintFactory *wxPrintFactory::GetFactory()
  82 {
  83     if (!wxPrintFactory::m_factory)
  84         wxPrintFactory::m_factory = new wxNativePrintFactory;
  85
  86     return wxPrintFactory::m_factory;
  87 }
  88
  89 //----------------------------------------------------------------------------
  90 // wxNativePrintFactory
  91 //----------------------------------------------------------------------------
  92
  93 wxPrinterBase *wxNativePrintFactory::CreatePrinter( wxPrintDialogData *data )
  94 {
  95 #if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
  96     return new wxWindowsPrinter( data );
  97 #elif defined(__WXMAC__)
  98     return new wxMacPrinter( data );
  99 #elif defined(__WXPM__)
 100     return new wxOS2Printer( data );
 101 #else
 102     return new wxPostScriptPrinter( data );
 103 #endif
 104 }
 105
 106 wxPrintPreviewBase *wxNativePrintFactory::CreatePrintPreview( wxPrintout *preview,
 107     wxPrintout *printout, wxPrintDialogData *data )
 108 {
 109 #if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 110     return new wxWindowsPrintPreview( preview, printout, data );
 111 #elif defined(__WXMAC__)
 112     return new wxMacPrintPreview( preview, printout, data );
 113 #elif defined(__WXPM__)
 114     return new wxOS2PrintPreview( preview, printout, data );
 115 #else
 116     return new wxPostScriptPrintPreview( preview, printout, data );
 117 #endif
 118 }
 119
 120 wxPrintPreviewBase *wxNativePrintFactory::CreatePrintPreview( wxPrintout *preview,
 121     wxPrintout *printout, wxPrintData *data )
 122 {
 123 #if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 124     return new wxWindowsPrintPreview( preview, printout, data );
 125 #elif defined(__WXMAC__)
 126     return new wxMacPrintPreview( preview, printout, data );
 127 #elif defined(__WXPM__)
 128     return new wxOS2PrintPreview( preview, printout, data );
 129 #else
 130     return new wxPostScriptPrintPreview( preview, printout, data );
 131 #endif
 132 }
 133
 134 wxPrintDialogBase *wxNativePrintFactory::CreatePrintDialog( wxWindow *parent,
 135                                                   wxPrintDialogData *data )
 136 {
 137 #if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 138     return new wxWindowsPrintDialog( parent, data );
 139 #elif defined(__WXMAC__)
 140     return new wxMacPrintDialog( parent, data );
 141 #else
 142     return new wxGenericPrintDialog( parent, data );
 143 #endif
 144 }
 145
 146 wxPrintDialogBase *wxNativePrintFactory::CreatePrintDialog( wxWindow *parent,
 147                                                   wxPrintData *data )
 148 {
 149 #if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 150     return new wxWindowsPrintDialog( parent, data );
 151 #elif defined(__WXMAC__)
 152     return new wxMacPrintDialog( parent, data );
 153 #else
 154     return new wxGenericPrintDialog( parent, data );
 155 #endif
 156 }
 157
 158 wxPageSetupDialogBase *wxNativePrintFactory::CreatePageSetupDialog( wxWindow *parent,
 159                                                   wxPageSetupDialogData *data )
 160 {
 161 #if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 162     return new wxWindowsPageSetupDialog( parent, data );
 163 #elif defined(__WXMAC__)
 164     return new wxMacPageSetupDialog( parent, data );
 165 #else
 166     return new wxGenericPageSetupDialog( parent, data );
 167 #endif
 168 }
 169
 170 bool wxNativePrintFactory::HasPrintSetupDialog()
 171 {
 172 #if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 173     return false;
 174 #elif defined(__WXMAC__)
 175     return false;
 176 #else
 177     // Only here do we need to provide the print setup
 178     // dialog ourselves, the other platforms either have
 179     // none, don't make it accessible or let you configure
 180     // the printer from the wxPrintDialog anyway.
 181     return true;
 182 #endif
 183
 184 }
 185
 186 wxDialog *wxNativePrintFactory::CreatePrintSetupDialog( wxWindow *parent,
 187                                                         wxPrintData *data )
 188 {
 189 #if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 190     wxUnusedVar(parent);
 191     wxUnusedVar(data);
 192     return NULL;
 193 #elif defined(__WXMAC__)
 194     wxUnusedVar(parent);
 195     wxUnusedVar(data);
 196     return NULL;
 197 #else
 198     // Only here do we need to provide the print setup
 199     // dialog ourselves, the other platforms either have
 200     // none, don't make it accessible or let you configure
 201     // the printer from the wxPrintDialog anyway.
 202     return new wxGenericPrintSetupDialog( parent, data );
 203 #endif
 204 }
 205
 206 wxDC* wxNativePrintFactory::CreatePrinterDC( const wxPrintData& data )
 207 {
 208 #if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 209     return new wxPrinterDC(data);
 210 #elif defined(__WXMAC__)
 211     return new wxPrinterDC(data);
 212 #else
 213     return new wxPrinterDC(data);
 214 #endif
 215 }
 216
 217 bool wxNativePrintFactory::HasOwnPrintToFile()
 218 {
 219     // Only relevant for PostScript and here the
 220     // setup dialog provides no "print to file"
 221     // option. In the GNOME setup dialog, the
 222     // setup dialog has its own print to file.
 223     return false;
 224 }
 225
 226 bool wxNativePrintFactory::HasPrinterLine()
 227 {
 228     // Only relevant for PostScript for now
 229     return true;
 230 }
 231
 232 wxString wxNativePrintFactory::CreatePrinterLine()
 233 {
 234     // Only relevant for PostScript for now
 235
 236     // We should query "lpstat -d" here
 237     return _("Generic PostScript");
 238 }
 239
 240 bool wxNativePrintFactory::HasStatusLine()
 241 {
 242     // Only relevant for PostScript for now
 243     return true;
 244 }
 245
 246 wxString wxNativePrintFactory::CreateStatusLine()
 247 {
 248     // Only relevant for PostScript for now
 249
 250     // We should query "lpstat -r" or "lpstat -p" here
 251     return _("Ready");
 252 }
 253
 254 wxPrintNativeDataBase *wxNativePrintFactory::CreatePrintNativeData()
 255 {
 256 #if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 257     return new wxWindowsPrintNativeData;
 258 #elif defined(__WXMAC__)
 259     return new wxMacCarbonPrintData;
 260 #else
 261     return new wxPostScriptPrintNativeData;
 262 #endif
 263 }
 264
 265 //----------------------------------------------------------------------------
 266 // wxPrintNativeDataBase
 267 //----------------------------------------------------------------------------
 268
 269 IMPLEMENT_ABSTRACT_CLASS(wxPrintNativeDataBase, wxObject)
 270
 271 wxPrintNativeDataBase::wxPrintNativeDataBase()
 272 {
 273     m_ref = 1;
 274 }
 275
 276 //----------------------------------------------------------------------------
 277 // wxPrintFactoryModule
 278 //----------------------------------------------------------------------------
 279
 280 class wxPrintFactoryModule: public wxModule
 281 {
 282 public:
 283     wxPrintFactoryModule() {}
 284     bool OnInit() { return true; }
 285     void OnExit() { wxPrintFactory::SetPrintFactory( NULL ); }
 286
 287 private:
 288     DECLARE_DYNAMIC_CLASS(wxPrintFactoryModule)
 289 };
 290
 291 IMPLEMENT_DYNAMIC_CLASS(wxPrintFactoryModule, wxModule)
 292
 293 //----------------------------------------------------------------------------
 294 // wxPrinterBase
 295 //----------------------------------------------------------------------------
 296
 297 IMPLEMENT_CLASS(wxPrinterBase, wxObject)
 298
 299 wxPrinterBase::wxPrinterBase(wxPrintDialogData *data)
 300 {
 301     m_currentPrintout = (wxPrintout *) NULL;
 302     sm_abortWindow = (wxWindow *) NULL;
 303     sm_abortIt = false;
 304     if (data)
 305         m_printDialogData = (*data);
 306     sm_lastError = wxPRINTER_NO_ERROR;
 307 }
 308
 309 wxWindow *wxPrinterBase::sm_abortWindow = (wxWindow *) NULL;
 310 bool wxPrinterBase::sm_abortIt = false;
 311 wxPrinterError wxPrinterBase::sm_lastError = wxPRINTER_NO_ERROR;
 312
 313 wxPrinterBase::~wxPrinterBase()
 314 {
 315 }
 316
 317 wxWindow *wxPrinterBase::CreateAbortWindow(wxWindow *parent, wxPrintout * printout)
 318 {
 319     wxPrintAbortDialog *dialog = new wxPrintAbortDialog(parent, _("Printing ") , wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE);
 320
 321     wxBoxSizer *button_sizer = new wxBoxSizer( wxVERTICAL );
 322     button_sizer->Add( new wxStaticText(dialog, wxID_ANY, _("Please wait while printing\n") + printout->GetTitle() ), 0, wxALL, 10 );
 323     button_sizer->Add( new wxButton( dialog, wxID_CANCEL, wxT("Cancel") ), 0, wxALL | wxALIGN_CENTER, 10 );
 324
 325     dialog->SetAutoLayout( true );
 326     dialog->SetSizer( button_sizer );
 327
 328     button_sizer->Fit(dialog);
 329     button_sizer->SetSizeHints (dialog) ;
 330
 331     return dialog;
 332 }
 333
 334 void wxPrinterBase::ReportError(wxWindow *parent, wxPrintout *WXUNUSED(printout), const wxString& message)
 335 {
 336     wxMessageBox(message, _("Printing Error"), wxOK, parent);
 337 }
 338
 339 wxPrintDialogData& wxPrinterBase::GetPrintDialogData() const
 340 {
 341     return (wxPrintDialogData&) m_printDialogData;
 342 }
 343
 344 //----------------------------------------------------------------------------
 345 // wxPrinter
 346 //----------------------------------------------------------------------------
 347
 348 IMPLEMENT_CLASS(wxPrinter, wxPrinterBase)
 349
 350 wxPrinter::wxPrinter(wxPrintDialogData *data)
 351 {
 352     m_pimpl = wxPrintFactory::GetFactory()->CreatePrinter( data );
 353 }
 354
 355 wxPrinter::~wxPrinter()
 356 {
 357     delete m_pimpl;
 358 }
 359
 360 wxWindow *wxPrinter::CreateAbortWindow(wxWindow *parent, wxPrintout *printout)
 361 {
 362     return m_pimpl->CreateAbortWindow( parent, printout );
 363 }
 364
 365 void wxPrinter::ReportError(wxWindow *parent, wxPrintout *printout, const wxString& message)
 366 {
 367     m_pimpl->ReportError( parent, printout, message );
 368 }
 369
 370 bool wxPrinter::Setup(wxWindow *parent)
 371 {
 372     return m_pimpl->Setup( parent );
 373 }
 374
 375 bool wxPrinter::Print(wxWindow *parent, wxPrintout *printout, bool prompt)
 376 {
 377     return m_pimpl->Print( parent, printout, prompt );
 378 }
 379
 380 wxDC* wxPrinter::PrintDialog(wxWindow *parent)
 381 {
 382     return m_pimpl->PrintDialog( parent );
 383 }
 384
 385 wxPrintDialogData& wxPrinter::GetPrintDialogData() const
 386 {
 387     return m_pimpl->GetPrintDialogData();
 388 }
 389
 390 // ---------------------------------------------------------------------------
 391 // wxPrintDialogBase: the dialog for printing.
 392 // ---------------------------------------------------------------------------
 393
 394 IMPLEMENT_ABSTRACT_CLASS(wxPrintDialogBase, wxDialog)
 395
 396 wxPrintDialogBase::wxPrintDialogBase(wxWindow *parent,
 397                                      wxWindowID id,
 398                                      const wxString &title,
 399                                      const wxPoint &pos,
 400                                      const wxSize &size,
 401                                      long style)
 402     : wxDialog( parent, id, title.empty() ? wxString(_("Print")) : title,
 403                 pos, size, style )
 404 {
 405 }
 406
 407 // ---------------------------------------------------------------------------
 408 // wxPrintDialog: the dialog for printing
 409 // ---------------------------------------------------------------------------
 410
 411 IMPLEMENT_CLASS(wxPrintDialog, wxObject)
 412
 413 wxPrintDialog::wxPrintDialog(wxWindow *parent, wxPrintDialogData* data)
 414 {
 415     m_pimpl = wxPrintFactory::GetFactory()->CreatePrintDialog( parent, data );
 416 }
 417
 418 wxPrintDialog::wxPrintDialog(wxWindow *parent, wxPrintData* data)
 419 {
 420     m_pimpl = wxPrintFactory::GetFactory()->CreatePrintDialog( parent, data );
 421 }
 422
 423 wxPrintDialog::~wxPrintDialog()
 424 {
 425     delete m_pimpl;
 426 }
 427
 428 int wxPrintDialog::ShowModal()
 429 {
 430     return m_pimpl->ShowModal();
 431 }
 432
 433 wxPrintDialogData& wxPrintDialog::GetPrintDialogData()
 434 {
 435     return m_pimpl->GetPrintDialogData();
 436 }
 437
 438 wxPrintData& wxPrintDialog::GetPrintData()
 439 {
 440     return m_pimpl->GetPrintData();
 441 }
 442
 443 wxDC *wxPrintDialog::GetPrintDC()
 444 {
 445     return m_pimpl->GetPrintDC();
 446 }
 447
 448 // ---------------------------------------------------------------------------
 449 // wxPageSetupDialogBase: the page setup dialog
 450 // ---------------------------------------------------------------------------
 451
 452 IMPLEMENT_ABSTRACT_CLASS(wxPageSetupDialogBase, wxDialog)
 453
 454 wxPageSetupDialogBase::wxPageSetupDialogBase(wxWindow *parent,
 455                                      wxWindowID id,
 456                                      const wxString &title,
 457                                      const wxPoint &pos,
 458                                      const wxSize &size,
 459                                      long style)
 460     : wxDialog( parent, id, title.empty() ? wxString(_("Page setup")) : title,
 461                 pos, size, style )
 462 {
 463 }
 464
 465 // ---------------------------------------------------------------------------
 466 // wxPageSetupDialog: the page setup dialog
 467 // ---------------------------------------------------------------------------
 468
 469 IMPLEMENT_CLASS(wxPageSetupDialog, wxObject)
 470
 471 wxPageSetupDialog::wxPageSetupDialog(wxWindow *parent, wxPageSetupDialogData *data )
 472 {
 473     m_pimpl = wxPrintFactory::GetFactory()->CreatePageSetupDialog( parent, data );
 474 }
 475
 476 wxPageSetupDialog::~wxPageSetupDialog()
 477 {
 478     delete m_pimpl;
 479 }
 480
 481 int wxPageSetupDialog::ShowModal()
 482 {
 483     return m_pimpl->ShowModal();
 484 }
 485
 486 wxPageSetupDialogData& wxPageSetupDialog::GetPageSetupDialogData()
 487 {
 488     return m_pimpl->GetPageSetupDialogData();
 489 }
 490
 491 // old name
 492 wxPageSetupDialogData& wxPageSetupDialog::GetPageSetupData()
 493 {
 494     return m_pimpl->GetPageSetupDialogData();
 495 }
 496
 497 //----------------------------------------------------------------------------
 498 // wxPrintAbortDialog
 499 //----------------------------------------------------------------------------
 500
 501 BEGIN_EVENT_TABLE(wxPrintAbortDialog, wxDialog)
 502     EVT_BUTTON(wxID_CANCEL, wxPrintAbortDialog::OnCancel)
 503 END_EVENT_TABLE()
 504
 505 void wxPrintAbortDialog::OnCancel(wxCommandEvent& WXUNUSED(event))
 506 {
 507     wxPrinterBase::sm_abortIt = true;
 508     wxPrinterBase::sm_abortWindow->Show(false);
 509     wxPrinterBase::sm_abortWindow->Close(true);
 510     wxPrinterBase::sm_abortWindow = (wxWindow *) NULL;
 511 }
 512
 513 //----------------------------------------------------------------------------
 514 // wxPrintout
 515 //----------------------------------------------------------------------------
 516
 517 IMPLEMENT_ABSTRACT_CLASS(wxPrintout, wxObject)
 518
 519 wxPrintout::wxPrintout(const wxString& title)
 520 {
 521     m_printoutTitle = title ;
 522     m_printoutDC = (wxDC *) NULL;
 523     m_pageWidthMM = 0;
 524     m_pageHeightMM = 0;
 525     m_pageWidthPixels = 0;
 526     m_pageHeightPixels = 0;
 527     m_PPIScreenX = 0;
 528     m_PPIScreenY = 0;
 529     m_PPIPrinterX = 0;
 530     m_PPIPrinterY = 0;
 531     m_isPreview = false;
 532 }
 533
 534 wxPrintout::~wxPrintout()
 535 {
 536 }
 537
 538 bool wxPrintout::OnBeginDocument(int WXUNUSED(startPage), int WXUNUSED(endPage))
 539 {
 540     return GetDC()->StartDoc(_("Printing ") + m_printoutTitle);
 541 }
 542
 543 void wxPrintout::OnEndDocument()
 544 {
 545     GetDC()->EndDoc();
 546 }
 547
 548 void wxPrintout::OnBeginPrinting()
 549 {
 550 }
 551
 552 void wxPrintout::OnEndPrinting()
 553 {
 554 }
 555
 556 bool wxPrintout::HasPage(int page)
 557 {
 558     return (page == 1);
 559 }
 560
 561 void wxPrintout::GetPageInfo(int *minPage, int *maxPage, int *fromPage, int *toPage)
 562 {
 563     *minPage = 1;
 564     *maxPage = 32000;
 565     *fromPage = 1;
 566     *toPage = 1;
 567 }
 568
 569 //----------------------------------------------------------------------------
 570 // wxPreviewCanvas
 571 //----------------------------------------------------------------------------
 572
 573 IMPLEMENT_CLASS(wxPreviewCanvas, wxWindow)
 574
 575 BEGIN_EVENT_TABLE(wxPreviewCanvas, wxScrolledWindow)
 576     EVT_PAINT(wxPreviewCanvas::OnPaint)
 577     EVT_CHAR(wxPreviewCanvas::OnChar)
 578     EVT_SYS_COLOUR_CHANGED(wxPreviewCanvas::OnSysColourChanged)
 579 #if wxUSE_MOUSEWHEEL
 580     EVT_MOUSEWHEEL(wxPreviewCanvas::OnMouseWheel)
 581 #endif
 582 END_EVENT_TABLE()
 583
 584 // VZ: the current code doesn't refresh properly without
 585 //     wxFULL_REPAINT_ON_RESIZE, this must be fixed as otherwise we have
 586 //     really horrible flicker when resizing the preview frame, but without
 587 //     this style it simply doesn't work correctly at all...
 588 wxPreviewCanvas::wxPreviewCanvas(wxPrintPreviewBase *preview, wxWindow *parent,
 589                                  const wxPoint& pos, const wxSize& size, long style, const wxString& name):
 590 wxScrolledWindow(parent, wxID_ANY, pos, size, style | wxFULL_REPAINT_ON_RESIZE, name)
 591 {
 592     m_printPreview = preview;
 593 #ifdef __WXMAC__
 594     // The app workspace colour is always white, but we should have
 595     // a contrast with the page.
 596     wxSystemColour colourIndex = wxSYS_COLOUR_3DDKSHADOW;
 597 #else
 598     wxSystemColour colourIndex = wxSYS_COLOUR_APPWORKSPACE;
 599 #endif
 600     SetBackgroundColour(wxSystemSettings::GetColour(colourIndex));
 601
 602     SetScrollbars(10, 10, 100, 100);
 603 }
 604
 605 wxPreviewCanvas::~wxPreviewCanvas()
 606 {
 607 }
 608
 609 void wxPreviewCanvas::OnPaint(wxPaintEvent& WXUNUSED(event))
 610 {
 611     wxPaintDC dc(this);
 612     PrepareDC( dc );
 613
 614 /*
 615 #ifdef __WXGTK__
 616     if (!GetUpdateRegion().IsEmpty())
 617         dc.SetClippingRegion( GetUpdateRegion() );
 618 #endif
 619 */
 620
 621     if (m_printPreview)
 622     {
 623         m_printPreview->PaintPage(this, dc);
 624     }
 625 }
 626
 627 // Responds to colour changes, and passes event on to children.
 628 void wxPreviewCanvas::OnSysColourChanged(wxSysColourChangedEvent& event)
 629 {
 630 #ifdef __WXMAC__
 631     // The app workspace colour is always white, but we should have
 632     // a contrast with the page.
 633     wxSystemColour colourIndex = wxSYS_COLOUR_3DDKSHADOW;
 634 #else
 635     wxSystemColour colourIndex = wxSYS_COLOUR_APPWORKSPACE;
 636 #endif
 637     SetBackgroundColour(wxSystemSettings::GetColour(colourIndex));
 638     Refresh();
 639
 640     // Propagate the event to the non-top-level children
 641     wxWindow::OnSysColourChanged(event);
 642 }
 643
 644 void wxPreviewCanvas::OnChar(wxKeyEvent &event)
 645 {
 646     wxPreviewControlBar* controlBar = ((wxPreviewFrame*) GetParent())->GetControlBar();
 647     if (event.GetKeyCode() == WXK_ESCAPE)
 648     {
 649         ((wxPreviewFrame*) GetParent())->Close(true);
 650         return;
 651     }
 652     else if (event.GetKeyCode() == WXK_TAB)
 653     {
 654         controlBar->OnGoto();
 655         return;
 656     }
 657     else if (event.GetKeyCode() == WXK_RETURN)
 658     {
 659         controlBar->OnPrint();
 660         return;
 661     }
 662
 663     if (!event.ControlDown())
 664     {
 665         event.Skip();
 666         return;
 667     }
 668
 669     switch(event.GetKeyCode())
 670     {
 671         case WXK_PAGEDOWN:
 672             controlBar->OnNext(); break;
 673         case WXK_PAGEUP:
 674             controlBar->OnPrevious(); break;
 675         case WXK_HOME:
 676             controlBar->OnFirst(); break;
 677         case WXK_END:
 678             controlBar->OnLast(); break;
 679         default:
 680             event.Skip();
 681     }
 682 }
 683
 684 #if wxUSE_MOUSEWHEEL
 685
 686 void wxPreviewCanvas::OnMouseWheel(wxMouseEvent& event)
 687 {
 688     wxPreviewControlBar *
 689         controlBar = wxStaticCast(GetParent(), wxPreviewFrame)->GetControlBar();
 690
 691     if ( controlBar )
 692     {
 693         if ( event.ControlDown() && event.GetWheelRotation() != 0 )
 694         {
 695             int currentZoom = controlBar->GetZoomControl();
 696
 697             int delta;
 698             if ( currentZoom < 100 )
 699                 delta = 5;
 700             else if ( currentZoom <= 120 )
 701                 delta = 10;
 702             else
 703                 delta = 50;
 704
 705             if ( event.GetWheelRotation() > 0 )
 706                 delta = -delta;
 707
 708             int newZoom = currentZoom + delta;
 709             if ( newZoom < 10 )
 710                 newZoom = 10;
 711             if ( newZoom > 200 )
 712                 newZoom = 200;
 713             if ( newZoom != currentZoom )
 714             {
 715                 controlBar->SetZoomControl(newZoom);
 716                 m_printPreview->SetZoom(newZoom);
 717                 Refresh();
 718             }
 719             return;
 720         }
 721     }
 722
 723     event.Skip();
 724 }
 725
 726 #endif // wxUSE_MOUSEWHEEL
 727
 728 //----------------------------------------------------------------------------
 729 // wxPreviewControlBar
 730 //----------------------------------------------------------------------------
 731
 732 IMPLEMENT_CLASS(wxPreviewControlBar, wxWindow)
 733
 734 BEGIN_EVENT_TABLE(wxPreviewControlBar, wxPanel)
 735     EVT_BUTTON(wxID_PREVIEW_CLOSE,    wxPreviewControlBar::OnWindowClose)
 736     EVT_BUTTON(wxID_PREVIEW_PRINT,    wxPreviewControlBar::OnPrintButton)
 737     EVT_BUTTON(wxID_PREVIEW_PREVIOUS, wxPreviewControlBar::OnPreviousButton)
 738     EVT_BUTTON(wxID_PREVIEW_NEXT,     wxPreviewControlBar::OnNextButton)
 739     EVT_BUTTON(wxID_PREVIEW_FIRST,    wxPreviewControlBar::OnFirstButton)
 740     EVT_BUTTON(wxID_PREVIEW_LAST,     wxPreviewControlBar::OnLastButton)
 741     EVT_BUTTON(wxID_PREVIEW_GOTO,     wxPreviewControlBar::OnGotoButton)
 742     EVT_CHOICE(wxID_PREVIEW_ZOOM,     wxPreviewControlBar::OnZoom)
 743     EVT_PAINT(wxPreviewControlBar::OnPaint)
 744 END_EVENT_TABLE()
 745
 746 wxPreviewControlBar::wxPreviewControlBar(wxPrintPreviewBase *preview, long buttons,
 747                                          wxWindow *parent, const wxPoint& pos, const wxSize& size,
 748                                          long style, const wxString& name):
 749 wxPanel(parent, wxID_ANY, pos, size, style, name)
 750 {
 751     m_printPreview = preview;
 752     m_closeButton = (wxButton *) NULL;
 753     m_nextPageButton = (wxButton *) NULL;
 754     m_previousPageButton = (wxButton *) NULL;
 755     m_printButton = (wxButton *) NULL;
 756     m_zoomControl = (wxChoice *) NULL;
 757     m_buttonFlags = buttons;
 758 }
 759
 760 wxPreviewControlBar::~wxPreviewControlBar()
 761 {
 762 }
 763
 764 void wxPreviewControlBar::OnPaint(wxPaintEvent& WXUNUSED(event))
 765 {
 766     wxPaintDC dc(this);
 767
 768     int w, h;
 769     GetSize(&w, &h);
 770     dc.SetPen(*wxBLACK_PEN);
 771     dc.SetBrush(*wxTRANSPARENT_BRUSH);
 772     dc.DrawLine( 0, h-1, w, h-1 );
 773 }
 774
 775 void wxPreviewControlBar::OnWindowClose(wxCommandEvent& WXUNUSED(event))
 776 {
 777     wxPreviewFrame *frame = (wxPreviewFrame *)GetParent();
 778     frame->Close(true);
 779 }
 780
 781 void wxPreviewControlBar::OnPrint(void)
 782 {
 783     wxPrintPreviewBase *preview = GetPrintPreview();
 784     preview->Print(true);
 785 }
 786
 787 void wxPreviewControlBar::OnNext(void)
 788 {
 789     wxPrintPreviewBase *preview = GetPrintPreview();
 790     if (preview)
 791     {
 792         int currentPage = preview->GetCurrentPage();
 793         if ((preview->GetMaxPage() > 0) &&
 794             (currentPage < preview->GetMaxPage()) &&
 795             preview->GetPrintout()->HasPage(currentPage + 1))
 796         {
 797             preview->SetCurrentPage(currentPage + 1);
 798         }
 799     }
 800 }
 801
 802 void wxPreviewControlBar::OnPrevious(void)
 803 {
 804     wxPrintPreviewBase *preview = GetPrintPreview();
 805     if (preview)
 806     {
 807         int currentPage = preview->GetCurrentPage();
 808         if ((preview->GetMinPage() > 0) &&
 809             (currentPage > preview->GetMinPage()) &&
 810             preview->GetPrintout()->HasPage(currentPage - 1))
 811         {
 812             preview->SetCurrentPage(currentPage - 1);
 813         }
 814     }
 815 }
 816
 817 void wxPreviewControlBar::OnFirst(void)
 818 {
 819     wxPrintPreviewBase *preview = GetPrintPreview();
 820     if (preview)
 821     {
 822         int currentPage = preview->GetMinPage();
 823         if (preview->GetPrintout()->HasPage(currentPage))
 824         {
 825             preview->SetCurrentPage(currentPage);
 826         }
 827     }
 828 }
 829
 830 void wxPreviewControlBar::OnLast(void)
 831 {
 832     wxPrintPreviewBase *preview = GetPrintPreview();
 833     if (preview)
 834     {
 835         int currentPage = preview->GetMaxPage();
 836         if (preview->GetPrintout()->HasPage(currentPage))
 837         {
 838             preview->SetCurrentPage(currentPage);
 839         }
 840     }
 841 }
 842
 843 void wxPreviewControlBar::OnGoto(void)
 844 {
 845     wxPrintPreviewBase *preview = GetPrintPreview();
 846     if (preview)
 847     {
 848         long currentPage;
 849
 850         if (preview->GetMinPage() > 0)
 851         {
 852             wxString strPrompt;
 853             wxString strPage;
 854
 855             strPrompt.Printf( _("Enter a page number between %d and %d:"),
 856                 preview->GetMinPage(), preview->GetMaxPage());
 857             strPage.Printf( wxT("%d"), preview->GetCurrentPage() );
 858
 859             strPage =
 860                 wxGetTextFromUser( strPrompt, _("Goto Page"), strPage, GetParent());
 861
 862             if ( strPage.ToLong( &currentPage ) )
 863                 if (preview->GetPrintout()->HasPage(currentPage))
 864                 {
 865                     preview->SetCurrentPage(currentPage);
 866                 }
 867         }
 868     }
 869 }
 870
 871 void wxPreviewControlBar::OnZoom(wxCommandEvent& WXUNUSED(event))
 872 {
 873     int zoom = GetZoomControl();
 874     if (GetPrintPreview())
 875         GetPrintPreview()->SetZoom(zoom);
 876 }
 877
 878 void wxPreviewControlBar::CreateButtons()
 879 {
 880     SetSize(0, 0, 400, 40);
 881
 882     wxBoxSizer *item0 = new wxBoxSizer( wxHORIZONTAL );
 883
 884     m_closeButton = new wxButton( this, wxID_PREVIEW_CLOSE, _("&Close"), wxDefaultPosition, wxDefaultSize, 0 );
 885     item0->Add( m_closeButton, 0, wxALIGN_CENTRE|wxALL, 5 );
 886
 887     if (m_buttonFlags & wxPREVIEW_PRINT)
 888     {
 889         m_printButton = new wxButton( this, wxID_PREVIEW_PRINT, _("&Print..."), wxDefaultPosition, wxDefaultSize, 0 );
 890         item0->Add( m_printButton, 0, wxALIGN_CENTRE|wxALL, 5 );
 891     }
 892
 893     if (m_buttonFlags & wxPREVIEW_FIRST)
 894     {
 895         m_firstPageButton = new wxButton( this, wxID_PREVIEW_FIRST, _("|<<"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT );
 896         item0->Add( m_firstPageButton, 0, wxALIGN_CENTRE|wxALL, 5 );
 897     }
 898
 899     if (m_buttonFlags & wxPREVIEW_PREVIOUS)
 900     {
 901         m_previousPageButton = new wxButton( this, wxID_PREVIEW_PREVIOUS, _("<<"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT );
 902         item0->Add( m_previousPageButton, 0, wxALIGN_CENTRE|wxRIGHT|wxTOP|wxBOTTOM, 5 );
 903     }
 904
 905     if (m_buttonFlags & wxPREVIEW_NEXT)
 906     {
 907         m_nextPageButton = new wxButton( this, wxID_PREVIEW_NEXT, _(">>"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT );
 908         item0->Add( m_nextPageButton, 0, wxALIGN_CENTRE|wxRIGHT|wxTOP|wxBOTTOM, 5 );
 909     }
 910
 911     if (m_buttonFlags & wxPREVIEW_LAST)
 912     {
 913         m_lastPageButton = new wxButton( this, wxID_PREVIEW_LAST, _(">>|"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT );
 914         item0->Add( m_lastPageButton, 0, wxALIGN_CENTRE|wxRIGHT|wxTOP|wxBOTTOM, 5 );
 915     }
 916
 917     if (m_buttonFlags & wxPREVIEW_GOTO)
 918     {
 919         m_gotoPageButton = new wxButton( this, wxID_PREVIEW_GOTO, _("&Goto..."), wxDefaultPosition, wxDefaultSize, 0 );
 920         item0->Add( m_gotoPageButton, 0, wxALIGN_CENTRE|wxALL, 5 );
 921     }
 922
 923     if (m_buttonFlags & wxPREVIEW_ZOOM)
 924     {
 925         wxString choices[] =
 926         {
 927             wxT("10%"), wxT("15%"), wxT("20%"), wxT("25%"), wxT("30%"), wxT("35%"), wxT("40%"), wxT("45%"), wxT("50%"), wxT("55%"),
 928                 wxT("60%"), wxT("65%"), wxT("70%"), wxT("75%"), wxT("80%"), wxT("85%"), wxT("90%"), wxT("95%"), wxT("100%"), wxT("110%"),
 929                 wxT("120%"), wxT("150%"), wxT("200%")
 930         };
 931         int n = WXSIZEOF(choices);
 932
 933         m_zoomControl = new wxChoice( this, wxID_PREVIEW_ZOOM, wxDefaultPosition, wxSize(70,wxDefaultCoord), n, choices, 0 );
 934         item0->Add( m_zoomControl, 0, wxALIGN_CENTRE|wxALL, 5 );
 935         SetZoomControl(m_printPreview->GetZoom());
 936     }
 937
 938     SetSizer(item0);
 939     item0->Fit(this);
 940 }
 941
 942 void wxPreviewControlBar::SetZoomControl(int zoom)
 943 {
 944     if (m_zoomControl)
 945     {
 946         int n, count = m_zoomControl->GetCount();
 947         long val;
 948         for (n=0; n<count; n++)
 949         {
 950             if (m_zoomControl->GetString(n).BeforeFirst(wxT('%')).ToLong(&val) &&
 951                 (val >= long(zoom)))
 952             {
 953                 m_zoomControl->SetSelection(n);
 954                 return;
 955             }
 956         }
 957
 958         m_zoomControl->SetSelection(count-1);
 959     }
 960 }
 961
 962 int wxPreviewControlBar::GetZoomControl()
 963 {
 964     if (m_zoomControl && (m_zoomControl->GetStringSelection() != wxEmptyString))
 965     {
 966         long val;
 967         if (m_zoomControl->GetStringSelection().BeforeFirst(wxT('%')).ToLong(&val))
 968             return int(val);
 969     }
 970
 971     return 0;
 972 }
 973
 974
 975 /*
 976 * Preview frame
 977 */
 978
 979 IMPLEMENT_CLASS(wxPreviewFrame, wxFrame)
 980
 981 BEGIN_EVENT_TABLE(wxPreviewFrame, wxFrame)
 982     EVT_CLOSE(wxPreviewFrame::OnCloseWindow)
 983 END_EVENT_TABLE()
 984
 985 wxPreviewFrame::wxPreviewFrame(wxPrintPreviewBase *preview, wxWindow *parent, const wxString& title,
 986                                const wxPoint& pos, const wxSize& size, long style, const wxString& name):
 987 wxFrame(parent, wxID_ANY, title, pos, size, style, name)
 988 {
 989     m_printPreview = preview;
 990     m_controlBar = NULL;
 991     m_previewCanvas = NULL;
 992     m_windowDisabler = NULL;
 993
 994     // Give the application icon
 995 #ifdef __WXMSW__
 996     wxFrame* topFrame = wxDynamicCast(wxTheApp->GetTopWindow(), wxFrame);
 997     if (topFrame)
 998         SetIcon(topFrame->GetIcon());
 999 #endif
1000 }
1001
1002 wxPreviewFrame::~wxPreviewFrame()
1003 {
1004 }
1005
1006 void wxPreviewFrame::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
1007 {
1008     if (m_windowDisabler)
1009         delete m_windowDisabler;
1010
1011     // Need to delete the printout and the print preview
1012     wxPrintout *printout = m_printPreview->GetPrintout();
1013     if (printout)
1014     {
1015         delete printout;
1016         m_printPreview->SetPrintout(NULL);
1017         m_printPreview->SetCanvas(NULL);
1018         m_printPreview->SetFrame(NULL);
1019     }
1020     delete m_printPreview;
1021
1022     Destroy();
1023 }
1024
1025 void wxPreviewFrame::Initialize()
1026 {
1027 #if wxUSE_STATUSBAR
1028     CreateStatusBar();
1029 #endif
1030     CreateCanvas();
1031     CreateControlBar();
1032
1033     m_printPreview->SetCanvas(m_previewCanvas);
1034     m_printPreview->SetFrame(this);
1035
1036     wxBoxSizer *item0 = new wxBoxSizer( wxVERTICAL );
1037
1038     item0->Add( m_controlBar, 0, wxGROW|wxALIGN_CENTER_VERTICAL, 5 );
1039     item0->Add( m_previewCanvas, 1, wxGROW|wxALIGN_CENTER_VERTICAL, 5 );
1040
1041     SetAutoLayout( true );
1042     SetSizer( item0 );
1043
1044     m_windowDisabler = new wxWindowDisabler(this);
1045
1046     Layout();
1047
1048     m_printPreview->AdjustScrollbars(m_previewCanvas);
1049     m_previewCanvas->SetFocus();
1050     m_controlBar->SetFocus();
1051 }
1052
1053 void wxPreviewFrame::CreateCanvas()
1054 {
1055     m_previewCanvas = new wxPreviewCanvas(m_printPreview, this);
1056 }
1057
1058 void wxPreviewFrame::CreateControlBar()
1059 {
1060     long buttons = wxPREVIEW_DEFAULT;
1061     if (m_printPreview->GetPrintoutForPrinting())
1062         buttons |= wxPREVIEW_PRINT;
1063
1064     m_controlBar = new wxPreviewControlBar(m_printPreview, buttons, this, wxPoint(0,0), wxSize(400, 40));
1065     m_controlBar->CreateButtons();
1066 }
1067
1068 /*
1069 * Print preview
1070 */
1071
1072 IMPLEMENT_CLASS(wxPrintPreviewBase, wxObject)
1073
1074 wxPrintPreviewBase::wxPrintPreviewBase(wxPrintout *printout,
1075                                        wxPrintout *printoutForPrinting,
1076                                        wxPrintData *data)
1077 {
1078     if (data)
1079         m_printDialogData = (*data);
1080
1081     Init(printout, printoutForPrinting);
1082 }
1083
1084 wxPrintPreviewBase::wxPrintPreviewBase(wxPrintout *printout,
1085                                        wxPrintout *printoutForPrinting,
1086                                        wxPrintDialogData *data)
1087 {
1088     if (data)
1089         m_printDialogData = (*data);
1090
1091     Init(printout, printoutForPrinting);
1092 }
1093
1094 void wxPrintPreviewBase::Init(wxPrintout *printout,
1095                               wxPrintout *printoutForPrinting)
1096 {
1097     m_isOk = true;
1098     m_previewPrintout = printout;
1099     if (m_previewPrintout)
1100         m_previewPrintout->SetIsPreview(true);
1101
1102     m_printPrintout = printoutForPrinting;
1103
1104     m_previewCanvas = NULL;
1105     m_previewFrame = NULL;
1106     m_previewBitmap = NULL;
1107     m_currentPage = 1;
1108     m_currentZoom = 70;
1109     m_topMargin = 40;
1110     m_leftMargin = 40;
1111     m_pageWidth = 0;
1112     m_pageHeight = 0;
1113     m_printingPrepared = false;
1114     m_minPage = 1;
1115     m_maxPage = 1;
1116 }
1117
1118 wxPrintPreviewBase::~wxPrintPreviewBase()
1119 {
1120     if (m_previewPrintout)
1121         delete m_previewPrintout;
1122     if (m_previewBitmap)
1123         delete m_previewBitmap;
1124     if (m_printPrintout)
1125         delete m_printPrintout;
1126 }
1127
1128 bool wxPrintPreviewBase::SetCurrentPage(int pageNum)
1129 {
1130     if (m_currentPage == pageNum)
1131         return true;
1132
1133     m_currentPage = pageNum;
1134     if (m_previewBitmap)
1135     {
1136         delete m_previewBitmap;
1137         m_previewBitmap = NULL;
1138     }
1139
1140     if (m_previewCanvas)
1141     {
1142         AdjustScrollbars(m_previewCanvas);
1143
1144         if (!RenderPage(pageNum))
1145             return false;
1146         m_previewCanvas->Refresh();
1147         m_previewCanvas->SetFocus();
1148     }
1149     return true;
1150 }
1151
1152 int wxPrintPreviewBase::GetCurrentPage() const
1153     { return m_currentPage; }
1154 void wxPrintPreviewBase::SetPrintout(wxPrintout *printout)
1155     { m_previewPrintout = printout; }
1156 wxPrintout *wxPrintPreviewBase::GetPrintout() const
1157     { return m_previewPrintout; }
1158 wxPrintout *wxPrintPreviewBase::GetPrintoutForPrinting() const
1159     { return m_printPrintout; }
1160 void wxPrintPreviewBase::SetFrame(wxFrame *frame)
1161     { m_previewFrame = frame; }
1162 void wxPrintPreviewBase::SetCanvas(wxPreviewCanvas *canvas)
1163     { m_previewCanvas = canvas; }
1164 wxFrame *wxPrintPreviewBase::GetFrame() const
1165     { return m_previewFrame; }
1166 wxPreviewCanvas *wxPrintPreviewBase::GetCanvas() const
1167     { return m_previewCanvas; }
1168
1169 bool wxPrintPreviewBase::PaintPage(wxPreviewCanvas *canvas, wxDC& dc)
1170 {
1171     DrawBlankPage(canvas, dc);
1172
1173     if (!m_previewBitmap)
1174         if (!RenderPage(m_currentPage))
1175             return false;
1176
1177     if (!m_previewBitmap)
1178         return false;
1179
1180     if (!canvas)
1181         return false;
1182
1183     int canvasWidth, canvasHeight;
1184     canvas->GetSize(&canvasWidth, &canvasHeight);
1185
1186     double zoomScale = ((float)m_currentZoom/(float)100);
1187     double actualWidth = (zoomScale*m_pageWidth*m_previewScale);
1188     //  float actualHeight = (float)(zoomScale*m_pageHeight*m_previewScale);
1189
1190     int x = (int) ((canvasWidth - actualWidth)/2.0);
1191     if (x < m_leftMargin)
1192         x = m_leftMargin;
1193     int y = m_topMargin;
1194
1195     wxMemoryDC temp_dc;
1196     temp_dc.SelectObject(*m_previewBitmap);
1197
1198     dc.Blit(x, y, m_previewBitmap->GetWidth(), m_previewBitmap->GetHeight(), &temp_dc, 0, 0);
1199
1200     temp_dc.SelectObject(wxNullBitmap);
1201
1202     return true;
1203 }
1204
1205 // Adjusts the scrollbars for the current scale
1206 void wxPrintPreviewBase::AdjustScrollbars(wxPreviewCanvas *canvas)
1207 {
1208     if (!canvas)
1209         return ;
1210
1211     int canvasWidth, canvasHeight;
1212     canvas->GetSize(&canvasWidth, &canvasHeight);
1213
1214     double zoomScale = ((float)m_currentZoom/(float)100);
1215     double actualWidth = (zoomScale*m_pageWidth*m_previewScale);
1216     double actualHeight = (zoomScale*m_pageHeight*m_previewScale);
1217
1218     // Set the scrollbars appropriately
1219     int totalWidth = (int)(actualWidth + 2*m_leftMargin);
1220     int totalHeight = (int)(actualHeight + 2*m_topMargin);
1221     int scrollUnitsX = totalWidth/10;
1222     int scrollUnitsY = totalHeight/10;
1223     wxSize virtualSize = canvas->GetVirtualSize();
1224     if (virtualSize.GetWidth() != totalWidth || virtualSize.GetHeight() != totalHeight)
1225         canvas->SetScrollbars(10, 10, scrollUnitsX, scrollUnitsY, 0, 0, true);
1226 }
1227
1228 bool wxPrintPreviewBase::RenderPage(int pageNum)
1229 {
1230     wxBusyCursor busy;
1231
1232     int canvasWidth, canvasHeight;
1233
1234     if (!m_previewCanvas)
1235     {
1236         wxFAIL_MSG(_T("wxPrintPreviewBase::RenderPage: must use wxPrintPreviewBase::SetCanvas to let me know about the canvas!"));
1237
1238         return false;
1239     }
1240     m_previewCanvas->GetSize(&canvasWidth, &canvasHeight);
1241
1242     double zoomScale = (m_currentZoom/100.0);
1243     int actualWidth = (int)(zoomScale*m_pageWidth*m_previewScale);
1244     int actualHeight = (int)(zoomScale*m_pageHeight*m_previewScale);
1245
1246     if (!m_previewBitmap)
1247     {
1248         m_previewBitmap = new wxBitmap((int)actualWidth, (int)actualHeight);
1249         if (!m_previewBitmap || !m_previewBitmap->Ok())
1250         {
1251             if (m_previewBitmap) {
1252                 delete m_previewBitmap;
1253                 m_previewBitmap = NULL;
1254             }
1255             wxMessageBox(_("Sorry, not enough memory to create a preview."), _("Print Preview Failure"), wxOK);
1256             return false;
1257         }
1258     }
1259
1260     wxMemoryDC memoryDC;
1261     memoryDC.SelectObject(*m_previewBitmap);
1262
1263     memoryDC.Clear();
1264
1265     m_previewPrintout->SetDC(&memoryDC);
1266     m_previewPrintout->SetPageSizePixels(m_pageWidth, m_pageHeight);
1267
1268     // Need to delay OnPreparePrinting until here, so we have enough information.
1269     if (!m_printingPrepared)
1270     {
1271         m_previewPrintout->OnPreparePrinting();
1272         int selFrom, selTo;
1273         m_previewPrintout->GetPageInfo(&m_minPage, &m_maxPage, &selFrom, &selTo);
1274         m_printingPrepared = true;
1275     }
1276
1277     m_previewPrintout->OnBeginPrinting();
1278
1279     if (!m_previewPrintout->OnBeginDocument(m_printDialogData.GetFromPage(), m_printDialogData.GetToPage()))
1280     {
1281         wxMessageBox(_("Could not start document preview."), _("Print Preview Failure"), wxOK);
1282
1283         memoryDC.SelectObject(wxNullBitmap);
1284
1285         delete m_previewBitmap;
1286         m_previewBitmap = NULL;
1287         return false;
1288     }
1289
1290     m_previewPrintout->OnPrintPage(pageNum);
1291     m_previewPrintout->OnEndDocument();
1292     m_previewPrintout->OnEndPrinting();
1293
1294     m_previewPrintout->SetDC(NULL);
1295
1296     memoryDC.SelectObject(wxNullBitmap);
1297
1298 #if wxUSE_STATUSBAR
1299     wxString status;
1300     if (m_maxPage != 0)
1301         status = wxString::Format(_("Page %d of %d"), pageNum, m_maxPage);
1302     else
1303         status = wxString::Format(_("Page %d"), pageNum);
1304
1305     if (m_previewFrame)
1306         m_previewFrame->SetStatusText(status);
1307 #endif
1308
1309     return true;
1310 }
1311
1312
1313 bool wxPrintPreviewBase::DrawBlankPage(wxPreviewCanvas *canvas, wxDC& dc)
1314 {
1315     int canvasWidth, canvasHeight;
1316     canvas->GetSize(&canvasWidth, &canvasHeight);
1317
1318     float zoomScale = (float)((float)m_currentZoom/(float)100);
1319     float actualWidth = zoomScale*m_pageWidth*m_previewScale;
1320     float actualHeight = zoomScale*m_pageHeight*m_previewScale;
1321
1322     float x = (float)((canvasWidth - actualWidth)/2.0);
1323     if (x < m_leftMargin)
1324         x = (float)m_leftMargin;
1325     float y = (float)m_topMargin;
1326
1327     // Draw shadow, allowing for 1-pixel border AROUND the actual page
1328     int shadowOffset = 4;
1329     dc.SetPen(*wxBLACK_PEN);
1330     dc.SetBrush(*wxBLACK_BRUSH);
1331     /*
1332     dc.DrawRectangle((int)(x-1 + shadowOffset), (int)(y-1 + shadowOffset), (int)(actualWidth+2), (int)(actualHeight+2));
1333     */
1334     dc.DrawRectangle((int)(x + shadowOffset), (int)(y + actualHeight+1), (int)(actualWidth), shadowOffset);
1335     dc.DrawRectangle((int)(x + actualWidth), (int)(y + shadowOffset), shadowOffset, (int)(actualHeight));
1336
1337     // Draw blank page allowing for 1-pixel border AROUND the actual page
1338     dc.SetPen(*wxBLACK_PEN);
1339     dc.SetBrush(*wxWHITE_BRUSH);
1340
1341     /*
1342     wxRegion update_region = canvas->GetUpdateRegion();
1343     wxRect r = update_region.GetBox();
1344
1345       printf( "x: %d y: %d w: %d h: %d.\n", (int)r.x, (int)r.y, (int)r.width, (int)r.height );
1346     */
1347
1348     dc.DrawRectangle((int)(x-2), (int)(y-1), (int)(actualWidth+3), (int)(actualHeight+2));
1349
1350     return true;
1351 }
1352
1353 void wxPrintPreviewBase::SetZoom(int percent)
1354 {
1355     if (m_currentZoom == percent)
1356         return;
1357
1358     m_currentZoom = percent;
1359     if (m_previewBitmap)
1360     {
1361         delete m_previewBitmap;
1362         m_previewBitmap = NULL;
1363     }
1364
1365     if (m_previewCanvas)
1366     {
1367         AdjustScrollbars(m_previewCanvas);
1368         RenderPage(m_currentPage);
1369         ((wxScrolledWindow *) m_previewCanvas)->Scroll(0, 0);
1370         m_previewCanvas->ClearBackground();
1371         m_previewCanvas->Refresh();
1372         m_previewCanvas->SetFocus();
1373     }
1374 }
1375
1376 wxPrintDialogData& wxPrintPreviewBase::GetPrintDialogData()
1377 {
1378     return m_printDialogData;
1379 }
1380
1381 int wxPrintPreviewBase::GetZoom() const
1382 { return m_currentZoom; }
1383 int wxPrintPreviewBase::GetMaxPage() const
1384 { return m_maxPage; }
1385 int wxPrintPreviewBase::GetMinPage() const
1386 { return m_minPage; }
1387 bool wxPrintPreviewBase::IsOk() const
1388 { return m_isOk; }
1389 void wxPrintPreviewBase::SetOk(bool ok)
1390 { m_isOk = ok; }
1391 //----------------------------------------------------------------------------
1392 // wxPrintPreview
1393 //----------------------------------------------------------------------------
1394
1395 IMPLEMENT_CLASS(wxPrintPreview, wxPrintPreviewBase)
1396
1397 wxPrintPreview::wxPrintPreview(wxPrintout *printout,
1398                    wxPrintout *printoutForPrinting,
1399                    wxPrintDialogData *data) :
1400     wxPrintPreviewBase( printout, printoutForPrinting, data )
1401 {
1402     m_pimpl = wxPrintFactory::GetFactory()->
1403         CreatePrintPreview( printout, printoutForPrinting, data );
1404 }
1405
1406 wxPrintPreview::wxPrintPreview(wxPrintout *printout,
1407                    wxPrintout *printoutForPrinting,
1408                    wxPrintData *data ) :
1409     wxPrintPreviewBase( printout, printoutForPrinting, data )
1410 {
1411     m_pimpl = wxPrintFactory::GetFactory()->
1412         CreatePrintPreview( printout, printoutForPrinting, data );
1413 }
1414
1415 wxPrintPreview::~wxPrintPreview()
1416 {
1417     delete m_pimpl;
1418
1419     // don't delete twice
1420     m_printPrintout = NULL;
1421     m_previewPrintout = NULL;
1422     m_previewBitmap = NULL;
1423 }
1424
1425 bool wxPrintPreview::SetCurrentPage(int pageNum)
1426 {
1427     return m_pimpl->SetCurrentPage( pageNum );
1428 }
1429
1430 int wxPrintPreview::GetCurrentPage() const
1431 {
1432     return m_pimpl->GetCurrentPage();
1433 }
1434
1435 void wxPrintPreview::SetPrintout(wxPrintout *printout)
1436 {
1437     m_pimpl->SetPrintout( printout );
1438 }
1439
1440 wxPrintout *wxPrintPreview::GetPrintout() const
1441 {
1442     return m_pimpl->GetPrintout();
1443 }
1444
1445 wxPrintout *wxPrintPreview::GetPrintoutForPrinting() const
1446 {
1447     return m_pimpl->GetPrintoutForPrinting();
1448 }
1449
1450 void wxPrintPreview::SetFrame(wxFrame *frame)
1451 {
1452     m_pimpl->SetFrame( frame );
1453 }
1454
1455 void wxPrintPreview::SetCanvas(wxPreviewCanvas *canvas)
1456 {
1457     m_pimpl->SetCanvas( canvas );
1458 }
1459
1460 wxFrame *wxPrintPreview::GetFrame() const
1461 {
1462     return m_pimpl->GetFrame();
1463 }
1464
1465 wxPreviewCanvas *wxPrintPreview::GetCanvas() const
1466 {
1467     return m_pimpl->GetCanvas();
1468 }
1469
1470 bool wxPrintPreview::PaintPage(wxPreviewCanvas *canvas, wxDC& dc)
1471 {
1472     return m_pimpl->PaintPage( canvas, dc );
1473 }
1474
1475 bool wxPrintPreview::DrawBlankPage(wxPreviewCanvas *canvas, wxDC& dc)
1476 {
1477     return m_pimpl->DrawBlankPage( canvas, dc );
1478 }
1479
1480 void wxPrintPreview::AdjustScrollbars(wxPreviewCanvas *canvas)
1481 {
1482     m_pimpl->AdjustScrollbars( canvas );
1483 }
1484
1485 bool wxPrintPreview::RenderPage(int pageNum)
1486 {
1487     return m_pimpl->RenderPage( pageNum );
1488 }
1489
1490 void wxPrintPreview::SetZoom(int percent)
1491 {
1492     m_pimpl->SetZoom( percent );
1493 }
1494
1495 int wxPrintPreview::GetZoom() const
1496 {
1497     return m_pimpl->GetZoom();
1498 }
1499
1500 wxPrintDialogData& wxPrintPreview::GetPrintDialogData()
1501 {
1502     return m_pimpl->GetPrintDialogData();
1503 }
1504
1505 int wxPrintPreview::GetMaxPage() const
1506 {
1507     return m_pimpl->GetMaxPage();
1508 }
1509
1510 int wxPrintPreview::GetMinPage() const
1511 {
1512     return m_pimpl->GetMinPage();
1513 }
1514
1515 bool wxPrintPreview::IsOk() const
1516 {
1517     return m_pimpl->Ok();
1518 }
1519
1520 void wxPrintPreview::SetOk(bool ok)
1521 {
1522     m_pimpl->SetOk( ok );
1523 }
1524
1525 bool wxPrintPreview::Print(bool interactive)
1526 {
1527     return m_pimpl->Print( interactive );
1528 }
1529
1530 void wxPrintPreview::DetermineScaling()
1531 {
1532     m_pimpl->DetermineScaling();
1533 }
1534
1535 #endif // wxUSE_PRINTING_ARCHITECTURE