src/common/prntbase.cpp

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