src/common/prntbase.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/prntbase.cpp
   3 // Purpose:     Printing framework base class implementation
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // For compilers that support precompilation, includes "wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #ifdef __BORLANDC__
  16     #pragma hdrstop
  17 #endif
  18
  19 #if wxUSE_PRINTING_ARCHITECTURE
  20
  21 #include "wx/dcprint.h"
  22
  23 #ifndef WX_PRECOMP
  24     #if defined(__WXMSW__)
  25         #include "wx/msw/wrapcdlg.h"
  26     #endif // MSW
  27     #include "wx/utils.h"
  28     #include "wx/dc.h"
  29     #include "wx/app.h"
  30     #include "wx/math.h"
  31     #include "wx/msgdlg.h"
  32     #include "wx/layout.h"
  33     #include "wx/choice.h"
  34     #include "wx/button.h"
  35     #include "wx/settings.h"
  36     #include "wx/dcmemory.h"
  37     #include "wx/dcclient.h"
  38     #include "wx/stattext.h"
  39     #include "wx/intl.h"
  40     #include "wx/textdlg.h"
  41     #include "wx/sizer.h"
  42     #include "wx/module.h"
  43 #endif // !WX_PRECOMP
  44
  45 #include "wx/prntbase.h"
  46 #include "wx/printdlg.h"
  47 #include "wx/print.h"
  48 #include "wx/dcprint.h"
  49
  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 #include "wx/dcps.h"
  61 #endif
  62
  63 #ifdef __WXMSW__
  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 wxDC* wxNativePrintFactory::CreatePrinterDC( const wxPrintData& data )
 209 {
 210 #if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 211     return new wxPrinterDC(data);
 212 #elif defined(__WXMAC__)
 213     return new wxPrinterDC(data);
 214 #else
 215     return new wxPostScriptDC(data);
 216 #endif
 217 }
 218
 219 bool wxNativePrintFactory::HasOwnPrintToFile()
 220 {
 221     // Only relevant for PostScript and here the
 222     // setup dialog provides no "print to file"
 223     // option. In the GNOME setup dialog, the
 224     // setup dialog has its own print to file.
 225     return false;
 226 }
 227
 228 bool wxNativePrintFactory::HasPrinterLine()
 229 {
 230     // Only relevant for PostScript for now
 231     return true;
 232 }
 233
 234 wxString wxNativePrintFactory::CreatePrinterLine()
 235 {
 236     // Only relevant for PostScript for now
 237
 238     // We should query "lpstat -d" here
 239     return _("Generic PostScript");
 240 }
 241
 242 bool wxNativePrintFactory::HasStatusLine()
 243 {
 244     // Only relevant for PostScript for now
 245     return true;
 246 }
 247
 248 wxString wxNativePrintFactory::CreateStatusLine()
 249 {
 250     // Only relevant for PostScript for now
 251
 252     // We should query "lpstat -r" or "lpstat -p" here
 253     return _("Ready");
 254 }
 255
 256 wxPrintNativeDataBase *wxNativePrintFactory::CreatePrintNativeData()
 257 {
 258 #if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 259     return new wxWindowsPrintNativeData;
 260 #elif defined(__WXMAC__)
 261     return new wxMacCarbonPrintData;
 262 #else
 263     return new wxPostScriptPrintNativeData;
 264 #endif
 265 }
 266
 267 //----------------------------------------------------------------------------
 268 // wxPrintNativeDataBase
 269 //----------------------------------------------------------------------------
 270
 271 IMPLEMENT_ABSTRACT_CLASS(wxPrintNativeDataBase, wxObject)
 272
 273 wxPrintNativeDataBase::wxPrintNativeDataBase()
 274 {
 275     m_ref = 1;
 276 }
 277
 278 //----------------------------------------------------------------------------
 279 // wxPrintFactoryModule
 280 //----------------------------------------------------------------------------
 281
 282 class wxPrintFactoryModule: public wxModule
 283 {
 284 public:
 285     wxPrintFactoryModule() {}
 286     bool OnInit() { return true; }
 287     void OnExit() { wxPrintFactory::SetPrintFactory( NULL ); }
 288
 289 private:
 290     DECLARE_DYNAMIC_CLASS(wxPrintFactoryModule)
 291 };
 292
 293 IMPLEMENT_DYNAMIC_CLASS(wxPrintFactoryModule, wxModule)
 294
 295 //----------------------------------------------------------------------------
 296 // wxPrinterBase
 297 //----------------------------------------------------------------------------
 298
 299 IMPLEMENT_CLASS(wxPrinterBase, wxObject)
 300
 301 wxPrinterBase::wxPrinterBase(wxPrintDialogData *data)
 302 {
 303     m_currentPrintout = (wxPrintout *) NULL;
 304     sm_abortWindow = (wxWindow *) NULL;
 305     sm_abortIt = false;
 306     if (data)
 307         m_printDialogData = (*data);
 308     sm_lastError = wxPRINTER_NO_ERROR;
 309 }
 310
 311 wxWindow *wxPrinterBase::sm_abortWindow = (wxWindow *) NULL;
 312 bool wxPrinterBase::sm_abortIt = false;
 313 wxPrinterError wxPrinterBase::sm_lastError = wxPRINTER_NO_ERROR;
 314
 315 wxPrinterBase::~wxPrinterBase()
 316 {
 317 }
 318
 319 wxWindow *wxPrinterBase::CreateAbortWindow(wxWindow *parent, wxPrintout * printout)
 320 {
 321     wxPrintAbortDialog *dialog = new wxPrintAbortDialog(parent, _("Printing ") , wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE);
 322
 323     wxBoxSizer *button_sizer = new wxBoxSizer( wxVERTICAL );
 324     button_sizer->Add( new wxStaticText(dialog, wxID_ANY, _("Please wait while printing\n") + printout->GetTitle() ), 0, wxALL, 10 );
 325     button_sizer->Add( new wxButton( dialog, wxID_CANCEL, wxT("Cancel") ), 0, wxALL | wxALIGN_CENTER, 10 );
 326
 327     dialog->SetAutoLayout( true );
 328     dialog->SetSizer( button_sizer );
 329
 330     button_sizer->Fit(dialog);
 331     button_sizer->SetSizeHints (dialog) ;
 332
 333     return dialog;
 334 }
 335
 336 void wxPrinterBase::ReportError(wxWindow *parent, wxPrintout *WXUNUSED(printout), const wxString& message)
 337 {
 338     wxMessageBox(message, _("Printing Error"), wxOK, parent);
 339 }
 340
 341 wxPrintDialogData& wxPrinterBase::GetPrintDialogData() const
 342 {
 343     return (wxPrintDialogData&) m_printDialogData;
 344 }
 345
 346 //----------------------------------------------------------------------------
 347 // wxPrinter
 348 //----------------------------------------------------------------------------
 349
 350 IMPLEMENT_CLASS(wxPrinter, wxPrinterBase)
 351
 352 wxPrinter::wxPrinter(wxPrintDialogData *data)
 353 {
 354     m_pimpl = wxPrintFactory::GetFactory()->CreatePrinter( data );
 355 }
 356
 357 wxPrinter::~wxPrinter()
 358 {
 359     delete m_pimpl;
 360 }
 361
 362 wxWindow *wxPrinter::CreateAbortWindow(wxWindow *parent, wxPrintout *printout)
 363 {
 364     return m_pimpl->CreateAbortWindow( parent, printout );
 365 }
 366
 367 void wxPrinter::ReportError(wxWindow *parent, wxPrintout *printout, const wxString& message)
 368 {
 369     m_pimpl->ReportError( parent, printout, message );
 370 }
 371
 372 bool wxPrinter::Setup(wxWindow *parent)
 373 {
 374     return m_pimpl->Setup( parent );
 375 }
 376
 377 bool wxPrinter::Print(wxWindow *parent, wxPrintout *printout, bool prompt)
 378 {
 379     return m_pimpl->Print( parent, printout, prompt );
 380 }
 381
 382 wxDC* wxPrinter::PrintDialog(wxWindow *parent)
 383 {
 384     return m_pimpl->PrintDialog( parent );
 385 }
 386
 387 wxPrintDialogData& wxPrinter::GetPrintDialogData() const
 388 {
 389     return m_pimpl->GetPrintDialogData();
 390 }
 391
 392 // ---------------------------------------------------------------------------
 393 // wxPrintDialogBase: the dialog for printing.
 394 // ---------------------------------------------------------------------------
 395
 396 IMPLEMENT_ABSTRACT_CLASS(wxPrintDialogBase, wxDialog)
 397
 398 wxPrintDialogBase::wxPrintDialogBase(wxWindow *parent,
 399                                      wxWindowID id,
 400                                      const wxString &title,
 401                                      const wxPoint &pos,
 402                                      const wxSize &size,
 403                                      long style)
 404     : wxDialog( parent, id, title.empty() ? wxString(_("Print")) : title,
 405                 pos, size, style )
 406 {
 407 }
 408
 409 // ---------------------------------------------------------------------------
 410 // wxPrintDialog: the dialog for printing
 411 // ---------------------------------------------------------------------------
 412
 413 IMPLEMENT_CLASS(wxPrintDialog, wxObject)
 414
 415 wxPrintDialog::wxPrintDialog(wxWindow *parent, wxPrintDialogData* data)
 416 {
 417     m_pimpl = wxPrintFactory::GetFactory()->CreatePrintDialog( parent, data );
 418 }
 419
 420 wxPrintDialog::wxPrintDialog(wxWindow *parent, wxPrintData* data)
 421 {
 422     m_pimpl = wxPrintFactory::GetFactory()->CreatePrintDialog( parent, data );
 423 }
 424
 425 wxPrintDialog::~wxPrintDialog()
 426 {
 427     delete m_pimpl;
 428 }
 429
 430 int wxPrintDialog::ShowModal()
 431 {
 432     return m_pimpl->ShowModal();
 433 }
 434
 435 wxPrintDialogData& wxPrintDialog::GetPrintDialogData()
 436 {
 437     return m_pimpl->GetPrintDialogData();
 438 }
 439
 440 wxPrintData& wxPrintDialog::GetPrintData()
 441 {
 442     return m_pimpl->GetPrintData();
 443 }
 444
 445 wxDC *wxPrintDialog::GetPrintDC()
 446 {
 447     return m_pimpl->GetPrintDC();
 448 }
 449
 450 // ---------------------------------------------------------------------------
 451 // wxPageSetupDialogBase: the page setup dialog
 452 // ---------------------------------------------------------------------------
 453
 454 IMPLEMENT_ABSTRACT_CLASS(wxPageSetupDialogBase, wxDialog)
 455
 456 wxPageSetupDialogBase::wxPageSetupDialogBase(wxWindow *parent,
 457                                      wxWindowID id,
 458                                      const wxString &title,
 459                                      const wxPoint &pos,
 460                                      const wxSize &size,
 461                                      long style)
 462     : wxDialog( parent, id, title.empty() ? wxString(_("Page setup")) : title,
 463                 pos, size, style )
 464 {
 465 }
 466
 467 // ---------------------------------------------------------------------------
 468 // wxPageSetupDialog: the page setup dialog
 469 // ---------------------------------------------------------------------------
 470
 471 IMPLEMENT_CLASS(wxPageSetupDialog, wxObject)
 472
 473 wxPageSetupDialog::wxPageSetupDialog(wxWindow *parent, wxPageSetupDialogData *data )
 474 {
 475     m_pimpl = wxPrintFactory::GetFactory()->CreatePageSetupDialog( parent, data );
 476 }
 477
 478 wxPageSetupDialog::~wxPageSetupDialog()
 479 {
 480     delete m_pimpl;
 481 }
 482
 483 int wxPageSetupDialog::ShowModal()
 484 {
 485     return m_pimpl->ShowModal();
 486 }
 487
 488 wxPageSetupDialogData& wxPageSetupDialog::GetPageSetupDialogData()
 489 {
 490     return m_pimpl->GetPageSetupDialogData();
 491 }
 492
 493 // old name
 494 wxPageSetupDialogData& wxPageSetupDialog::GetPageSetupData()
 495 {
 496     return m_pimpl->GetPageSetupDialogData();
 497 }
 498
 499 //----------------------------------------------------------------------------
 500 // wxPrintAbortDialog
 501 //----------------------------------------------------------------------------
 502
 503 BEGIN_EVENT_TABLE(wxPrintAbortDialog, wxDialog)
 504     EVT_BUTTON(wxID_CANCEL, wxPrintAbortDialog::OnCancel)
 505 END_EVENT_TABLE()
 506
 507 void wxPrintAbortDialog::OnCancel(wxCommandEvent& WXUNUSED(event))
 508 {
 509     wxPrinterBase::sm_abortIt = true;
 510     wxPrinterBase::sm_abortWindow->Show(false);
 511     wxPrinterBase::sm_abortWindow->Close(true);
 512     wxPrinterBase::sm_abortWindow = (wxWindow *) NULL;
 513 }
 514
 515 //----------------------------------------------------------------------------
 516 // wxPrintout
 517 //----------------------------------------------------------------------------
 518
 519 IMPLEMENT_ABSTRACT_CLASS(wxPrintout, wxObject)
 520
 521 wxPrintout::wxPrintout(const wxString& title)
 522 {
 523     m_printoutTitle = title ;
 524     m_printoutDC = (wxDC *) NULL;
 525     m_pageWidthMM = 0;
 526     m_pageHeightMM = 0;
 527     m_pageWidthPixels = 0;
 528     m_pageHeightPixels = 0;
 529     m_PPIScreenX = 0;
 530     m_PPIScreenY = 0;
 531     m_PPIPrinterX = 0;
 532     m_PPIPrinterY = 0;
 533     m_isPreview = false;
 534 }
 535
 536 wxPrintout::~wxPrintout()
 537 {
 538 }
 539
 540 bool wxPrintout::OnBeginDocument(int WXUNUSED(startPage), int WXUNUSED(endPage))
 541 {
 542     return GetDC()->StartDoc(_("Printing ") + m_printoutTitle);
 543 }
 544
 545 void wxPrintout::OnEndDocument()
 546 {
 547     GetDC()->EndDoc();
 548 }
 549
 550 void wxPrintout::OnBeginPrinting()
 551 {
 552 }
 553
 554 void wxPrintout::OnEndPrinting()
 555 {
 556 }
 557
 558 bool wxPrintout::HasPage(int page)
 559 {
 560     return (page == 1);
 561 }
 562
 563 void wxPrintout::GetPageInfo(int *minPage, int *maxPage, int *fromPage, int *toPage)
 564 {
 565     *minPage = 1;
 566     *maxPage = 32000;
 567     *fromPage = 1;
 568     *toPage = 1;
 569 }
 570
 571 void wxPrintout::FitThisSizeToPaper(const wxSize& imageSize)
 572 {
 573     // Set the DC scale and origin so that the given image size fits within the
 574     // entire page and the origin is at the top left corner of the page. Note
 575     // that with most printers, portions of the page will be non-printable. Use
 576     // this if you're managing your own page margins.
 577     if (!m_printoutDC) return;
 578     wxRect paperRect = GetPaperRectPixels();
 579     wxCoord pw, ph;
 580     GetPageSizePixels(&pw, &ph);
 581     wxCoord w, h;
 582     m_printoutDC->GetSize(&w, &h);
 583     float scaleX = ((float(paperRect.width) * w) / (float(pw) * imageSize.x));
 584     float scaleY = ((float(paperRect.height) * h) / (float(ph) * imageSize.y));
 585     float actualScale = wxMin(scaleX, scaleY);
 586     m_printoutDC->SetUserScale(actualScale, actualScale);
 587     m_printoutDC->SetDeviceOrigin(0, 0);
 588     wxRect logicalPaperRect = GetLogicalPaperRect();
 589     SetLogicalOrigin(logicalPaperRect.x, logicalPaperRect.y);
 590 }
 591
 592 void wxPrintout::FitThisSizeToPage(const wxSize& imageSize)
 593 {
 594     // Set the DC scale and origin so that the given image size fits within the
 595     // printable area of the page and the origin is at the top left corner of
 596     // the printable area.
 597     if (!m_printoutDC) return;
 598     int w, h;
 599     m_printoutDC->GetSize(&w, &h);
 600     float scaleX = float(w) / imageSize.x;
 601     float scaleY = float(h) / imageSize.y;
 602     float actualScale = wxMin(scaleX, scaleY);
 603     m_printoutDC->SetUserScale(actualScale, actualScale);
 604     m_printoutDC->SetDeviceOrigin(0, 0);
 605 }
 606
 607 void wxPrintout::FitThisSizeToPageMargins(const wxSize& imageSize, const wxPageSetupDialogData& pageSetupData)
 608 {
 609     // Set the DC scale and origin so that the given image size fits within the
 610     // page margins defined in the given wxPageSetupDialogData object and the
 611     // origin is at the top left corner of the page margins.
 612     if (!m_printoutDC) return;
 613     wxRect paperRect = GetPaperRectPixels();
 614     wxCoord pw, ph;
 615     GetPageSizePixels(&pw, &ph);
 616     wxPoint topLeft = pageSetupData.GetMarginTopLeft();
 617     wxPoint bottomRight = pageSetupData.GetMarginBottomRight();
 618     wxCoord mw, mh;
 619     GetPageSizeMM(&mw, &mh);
 620     float mmToDeviceX = float(pw) / mw;
 621     float mmToDeviceY = float(ph) / mh;
 622     wxRect pageMarginsRect(paperRect.x + wxRound(mmToDeviceX * topLeft.x),
 623         paperRect.y + wxRound(mmToDeviceY * topLeft.y),
 624         paperRect.width - wxRound(mmToDeviceX * (topLeft.x + bottomRight.x)),
 625         paperRect.height - wxRound(mmToDeviceY * (topLeft.y + bottomRight.y)));
 626     wxCoord w, h;
 627     m_printoutDC->GetSize(&w, &h);
 628     float scaleX = (float(pageMarginsRect.width) * w) / (float(pw) * imageSize.x);
 629     float scaleY = (float(pageMarginsRect.height) * h) / (float(ph) * imageSize.y);
 630     float actualScale = wxMin(scaleX, scaleY);
 631     m_printoutDC->SetUserScale(actualScale, actualScale);
 632     m_printoutDC->SetDeviceOrigin(0, 0);
 633     wxRect logicalPageMarginsRect = GetLogicalPageMarginsRect(pageSetupData);
 634     SetLogicalOrigin(logicalPageMarginsRect.x, logicalPageMarginsRect.y);
 635 }
 636
 637 void wxPrintout::MapScreenSizeToPaper()
 638 {
 639     // Set the DC scale so that an image on the screen is the same size on the
 640     // paper and the origin is at the top left of the paper. Note that with most
 641     // printers, portions of the page will be cut off. Use this if you're
 642     // managing your own page margins.
 643     if (!m_printoutDC) return;
 644     MapScreenSizeToPage();
 645     wxRect logicalPaperRect = GetLogicalPaperRect();
 646     SetLogicalOrigin(logicalPaperRect.x, logicalPaperRect.y);
 647 }
 648
 649 void wxPrintout::MapScreenSizeToPage()
 650 {
 651     // Set the DC scale and origin so that an image on the screen is the same
 652     // size on the paper and the origin is at the top left of the printable area.
 653     if (!m_printoutDC) return;
 654     int ppiScreenX, ppiScreenY;
 655     GetPPIScreen(&ppiScreenX, &ppiScreenY);
 656     int ppiPrinterX, ppiPrinterY;
 657     GetPPIPrinter(&ppiPrinterX, &ppiPrinterY);
 658     int w, h;
 659     m_printoutDC->GetSize(&w, &h);
 660     int pageSizePixelsX, pageSizePixelsY;
 661     GetPageSizePixels(&pageSizePixelsX, &pageSizePixelsY);
 662     float userScaleX = (float(ppiPrinterX) * w) / (float(ppiScreenX) * pageSizePixelsX);
 663     float userScaleY = (float(ppiPrinterY) * h) / (float(ppiScreenY) * pageSizePixelsY);
 664     m_printoutDC->SetUserScale(userScaleX, userScaleY);
 665     m_printoutDC->SetDeviceOrigin(0, 0);
 666 }
 667
 668 void wxPrintout::MapScreenSizeToPageMargins(const wxPageSetupDialogData& pageSetupData)
 669 {
 670     // Set the DC scale so that an image on the screen is the same size on the
 671     // paper and the origin is at the top left of the page margins defined by
 672     // the given wxPageSetupDialogData object.
 673     if (!m_printoutDC) return;
 674     MapScreenSizeToPage();
 675     wxRect logicalPageMarginsRect = GetLogicalPageMarginsRect(pageSetupData);
 676     SetLogicalOrigin(logicalPageMarginsRect.x, logicalPageMarginsRect.y);
 677 }
 678
 679 void wxPrintout::MapScreenSizeToDevice()
 680 {
 681     // Set the DC scale so that a screen pixel is the same size as a device
 682     // pixel and the origin is at the top left of the printable area.
 683     if (!m_printoutDC) return;
 684     int w, h;
 685     m_printoutDC->GetSize(&w, &h);
 686     int pageSizePixelsX, pageSizePixelsY;
 687     GetPageSizePixels(&pageSizePixelsX, &pageSizePixelsY);
 688     float userScaleX = float(w) / pageSizePixelsX;
 689     float userScaleY = float(h) / pageSizePixelsY;
 690     m_printoutDC->SetUserScale(userScaleX, userScaleY);
 691     m_printoutDC->SetDeviceOrigin(0, 0);
 692 }
 693
 694 wxRect wxPrintout::GetLogicalPaperRect() const
 695 {
 696     // Return the rectangle in logical units that corresponds to the paper
 697     // rectangle.
 698     wxRect paperRect = GetPaperRectPixels();
 699     wxCoord pw, ph;
 700     GetPageSizePixels(&pw, &ph);
 701     wxCoord w, h;
 702     m_printoutDC->GetSize(&w, &h);
 703     if (w == pw && h == ph) {
 704         // this DC matches the printed page, so no scaling
 705         return wxRect(m_printoutDC->DeviceToLogicalX(paperRect.x),
 706             m_printoutDC->DeviceToLogicalY(paperRect.y),
 707             m_printoutDC->DeviceToLogicalXRel(paperRect.width),
 708             m_printoutDC->DeviceToLogicalYRel(paperRect.height));
 709     }
 710     // This DC doesn't match the printed page, so we have to scale.
 711     float scaleX = float(w) / pw;
 712     float scaleY = float(h) / ph;
 713     return wxRect(m_printoutDC->DeviceToLogicalX(wxRound(paperRect.x * scaleX)),
 714         m_printoutDC->DeviceToLogicalY(wxRound(paperRect.y * scaleY)),
 715         m_printoutDC->DeviceToLogicalXRel(wxRound(paperRect.width * scaleX)),
 716         m_printoutDC->DeviceToLogicalYRel(wxRound(paperRect.height * scaleY)));
 717 }
 718
 719 wxRect wxPrintout::GetLogicalPageRect() const
 720 {
 721     // Return the rectangle in logical units that corresponds to the printable
 722     // area.
 723     int w, h;
 724     m_printoutDC->GetSize(&w, &h);
 725     return wxRect(m_printoutDC->DeviceToLogicalX(0),
 726         m_printoutDC->DeviceToLogicalY(0),
 727         m_printoutDC->DeviceToLogicalXRel(w),
 728         m_printoutDC->DeviceToLogicalYRel(h));
 729 }
 730
 731 wxRect wxPrintout::GetLogicalPageMarginsRect(const wxPageSetupDialogData& pageSetupData) const
 732 {
 733     // Return the rectangle in logical units that corresponds to the region
 734     // within the page margins as specified by the given wxPageSetupDialogData
 735     // object.
 736
 737     // We get the paper size in device units and the margins in mm,
 738     // so we need to calculate the conversion with this trick
 739     wxCoord pw, ph;
 740     GetPageSizePixels(&pw, &ph);
 741     wxCoord mw, mh;
 742     GetPageSizeMM(&mw, &mh);
 743     float mmToDeviceX = float(pw) / mw;
 744     float mmToDeviceY = float(ph) / mh;
 745
 746     // paper size in device units
 747     wxRect paperRect = GetPaperRectPixels();
 748
 749     // margins in mm
 750     wxPoint topLeft = pageSetupData.GetMarginTopLeft();
 751     wxPoint bottomRight = pageSetupData.GetMarginBottomRight();
 752
 753     // calculate margins in device units
 754     wxRect pageMarginsRect(
 755         paperRect.x      + wxRound(mmToDeviceX * topLeft.x),
 756         paperRect.y      + wxRound(mmToDeviceY * topLeft.y),
 757         paperRect.width  - wxRound(mmToDeviceX * (topLeft.x + bottomRight.x)),
 758         paperRect.height - wxRound(mmToDeviceY * (topLeft.y + bottomRight.y)));
 759
 760     wxCoord w, h;
 761     m_printoutDC->GetSize(&w, &h);
 762     if (w == pw && h == ph)
 763     {
 764         // this DC matches the printed page, so no scaling
 765         return wxRect(
 766             m_printoutDC->DeviceToLogicalX(pageMarginsRect.x),
 767             m_printoutDC->DeviceToLogicalY(pageMarginsRect.y),
 768             m_printoutDC->DeviceToLogicalXRel(pageMarginsRect.width),
 769             m_printoutDC->DeviceToLogicalYRel(pageMarginsRect.height));
 770     }
 771
 772     // This DC doesn't match the printed page, so we have to scale.
 773     float scaleX = float(w) / pw;
 774     float scaleY = float(h) / ph;
 775     return wxRect(m_printoutDC->DeviceToLogicalX(wxRound(pageMarginsRect.x * scaleX)),
 776         m_printoutDC->DeviceToLogicalY(wxRound(pageMarginsRect.y * scaleY)),
 777         m_printoutDC->DeviceToLogicalXRel(wxRound(pageMarginsRect.width * scaleX)),
 778         m_printoutDC->DeviceToLogicalYRel(wxRound(pageMarginsRect.height * scaleY)));
 779 }
 780
 781 void wxPrintout::SetLogicalOrigin(wxCoord x, wxCoord y)
 782 {
 783     // Set the device origin by specifying a point in logical coordinates.
 784     m_printoutDC->SetDeviceOrigin(
 785         m_printoutDC->LogicalToDeviceX(x),
 786         m_printoutDC->LogicalToDeviceY(y) );
 787 }
 788
 789 void wxPrintout::OffsetLogicalOrigin(wxCoord xoff, wxCoord yoff)
 790 {
 791     // Offset the device origin by a specified distance in device coordinates.
 792     wxPoint dev_org = m_printoutDC->GetDeviceOrigin();
 793     m_printoutDC->SetDeviceOrigin(
 794         dev_org.x + m_printoutDC->LogicalToDeviceXRel(xoff),
 795         dev_org.y + m_printoutDC->LogicalToDeviceYRel(yoff) );
 796 }
 797
 798
 799 //----------------------------------------------------------------------------
 800 // wxPreviewCanvas
 801 //----------------------------------------------------------------------------
 802
 803 IMPLEMENT_CLASS(wxPreviewCanvas, wxWindow)
 804
 805 BEGIN_EVENT_TABLE(wxPreviewCanvas, wxScrolledWindow)
 806     EVT_PAINT(wxPreviewCanvas::OnPaint)
 807     EVT_CHAR(wxPreviewCanvas::OnChar)
 808     EVT_SYS_COLOUR_CHANGED(wxPreviewCanvas::OnSysColourChanged)
 809 #if wxUSE_MOUSEWHEEL
 810     EVT_MOUSEWHEEL(wxPreviewCanvas::OnMouseWheel)
 811 #endif
 812 END_EVENT_TABLE()
 813
 814 // VZ: the current code doesn't refresh properly without
 815 //     wxFULL_REPAINT_ON_RESIZE, this must be fixed as otherwise we have
 816 //     really horrible flicker when resizing the preview frame, but without
 817 //     this style it simply doesn't work correctly at all...
 818 wxPreviewCanvas::wxPreviewCanvas(wxPrintPreviewBase *preview, wxWindow *parent,
 819                                  const wxPoint& pos, const wxSize& size, long style, const wxString& name):
 820 wxScrolledWindow(parent, wxID_ANY, pos, size, style | wxFULL_REPAINT_ON_RESIZE, name)
 821 {
 822     m_printPreview = preview;
 823 #ifdef __WXMAC__
 824     // The app workspace colour is always white, but we should have
 825     // a contrast with the page.
 826     wxSystemColour colourIndex = wxSYS_COLOUR_3DDKSHADOW;
 827 #elif defined(__WXGTK__)
 828     wxSystemColour colourIndex = wxSYS_COLOUR_BTNFACE;
 829 #else
 830     wxSystemColour colourIndex = wxSYS_COLOUR_APPWORKSPACE;
 831 #endif
 832     SetBackgroundColour(wxSystemSettings::GetColour(colourIndex));
 833
 834     SetScrollbars(10, 10, 100, 100);
 835 }
 836
 837 wxPreviewCanvas::~wxPreviewCanvas()
 838 {
 839 }
 840
 841 void wxPreviewCanvas::OnPaint(wxPaintEvent& WXUNUSED(event))
 842 {
 843     wxPaintDC dc(this);
 844     PrepareDC( dc );
 845
 846 /*
 847 #ifdef __WXGTK__
 848     if (!GetUpdateRegion().IsEmpty())
 849         dc.SetClippingRegion( GetUpdateRegion() );
 850 #endif
 851 */
 852
 853     if (m_printPreview)
 854     {
 855         m_printPreview->PaintPage(this, dc);
 856     }
 857 }
 858
 859 // Responds to colour changes, and passes event on to children.
 860 void wxPreviewCanvas::OnSysColourChanged(wxSysColourChangedEvent& event)
 861 {
 862 #ifdef __WXMAC__
 863     // The app workspace colour is always white, but we should have
 864     // a contrast with the page.
 865     wxSystemColour colourIndex = wxSYS_COLOUR_3DDKSHADOW;
 866 #elif defined(__WXGTK__)
 867     wxSystemColour colourIndex = wxSYS_COLOUR_BTNFACE;
 868 #else
 869     wxSystemColour colourIndex = wxSYS_COLOUR_APPWORKSPACE;
 870 #endif
 871     SetBackgroundColour(wxSystemSettings::GetColour(colourIndex));
 872     Refresh();
 873
 874     // Propagate the event to the non-top-level children
 875     wxWindow::OnSysColourChanged(event);
 876 }
 877
 878 void wxPreviewCanvas::OnChar(wxKeyEvent &event)
 879 {
 880     wxPreviewControlBar* controlBar = ((wxPreviewFrame*) GetParent())->GetControlBar();
 881     switch (event.GetKeyCode())
 882     {
 883         case WXK_TAB:
 884             controlBar->OnGoto();
 885             return;
 886         case WXK_RETURN:
 887             controlBar->OnPrint();
 888             return;
 889     }
 890
 891     if (!event.ControlDown())
 892     {
 893         event.Skip();
 894         return;
 895     }
 896
 897     switch(event.GetKeyCode())
 898     {
 899         case WXK_PAGEDOWN:
 900             controlBar->OnNext(); break;
 901         case WXK_PAGEUP:
 902             controlBar->OnPrevious(); break;
 903         case WXK_HOME:
 904             controlBar->OnFirst(); break;
 905         case WXK_END:
 906             controlBar->OnLast(); break;
 907         default:
 908             event.Skip();
 909     }
 910 }
 911
 912 #if wxUSE_MOUSEWHEEL
 913
 914 void wxPreviewCanvas::OnMouseWheel(wxMouseEvent& event)
 915 {
 916     wxPreviewControlBar *
 917         controlBar = wxStaticCast(GetParent(), wxPreviewFrame)->GetControlBar();
 918
 919     if ( controlBar )
 920     {
 921         if ( event.ControlDown() && event.GetWheelRotation() != 0 )
 922         {
 923             int currentZoom = controlBar->GetZoomControl();
 924
 925             int delta;
 926             if ( currentZoom < 100 )
 927                 delta = 5;
 928             else if ( currentZoom <= 120 )
 929                 delta = 10;
 930             else
 931                 delta = 50;
 932
 933             if ( event.GetWheelRotation() > 0 )
 934                 delta = -delta;
 935
 936             int newZoom = currentZoom + delta;
 937             if ( newZoom < 10 )
 938                 newZoom = 10;
 939             if ( newZoom > 200 )
 940                 newZoom = 200;
 941             if ( newZoom != currentZoom )
 942             {
 943                 controlBar->SetZoomControl(newZoom);
 944                 m_printPreview->SetZoom(newZoom);
 945                 Refresh();
 946             }
 947             return;
 948         }
 949     }
 950
 951     event.Skip();
 952 }
 953
 954 #endif // wxUSE_MOUSEWHEEL
 955
 956 //----------------------------------------------------------------------------
 957 // wxPreviewControlBar
 958 //----------------------------------------------------------------------------
 959
 960 IMPLEMENT_CLASS(wxPreviewControlBar, wxWindow)
 961
 962 BEGIN_EVENT_TABLE(wxPreviewControlBar, wxPanel)
 963     EVT_BUTTON(wxID_PREVIEW_CLOSE,    wxPreviewControlBar::OnWindowClose)
 964     EVT_BUTTON(wxID_PREVIEW_PRINT,    wxPreviewControlBar::OnPrintButton)
 965     EVT_BUTTON(wxID_PREVIEW_PREVIOUS, wxPreviewControlBar::OnPreviousButton)
 966     EVT_BUTTON(wxID_PREVIEW_NEXT,     wxPreviewControlBar::OnNextButton)
 967     EVT_BUTTON(wxID_PREVIEW_FIRST,    wxPreviewControlBar::OnFirstButton)
 968     EVT_BUTTON(wxID_PREVIEW_LAST,     wxPreviewControlBar::OnLastButton)
 969     EVT_BUTTON(wxID_PREVIEW_GOTO,     wxPreviewControlBar::OnGotoButton)
 970     EVT_CHOICE(wxID_PREVIEW_ZOOM,     wxPreviewControlBar::OnZoom)
 971     EVT_PAINT(wxPreviewControlBar::OnPaint)
 972 END_EVENT_TABLE()
 973
 974 wxPreviewControlBar::wxPreviewControlBar(wxPrintPreviewBase *preview, long buttons,
 975                                          wxWindow *parent, const wxPoint& pos, const wxSize& size,
 976                                          long style, const wxString& name):
 977 wxPanel(parent, wxID_ANY, pos, size, style, name)
 978 {
 979     m_printPreview = preview;
 980     m_closeButton = (wxButton *) NULL;
 981     m_nextPageButton = (wxButton *) NULL;
 982     m_previousPageButton = (wxButton *) NULL;
 983     m_printButton = (wxButton *) NULL;
 984     m_zoomControl = (wxChoice *) NULL;
 985     m_buttonFlags = buttons;
 986 }
 987
 988 wxPreviewControlBar::~wxPreviewControlBar()
 989 {
 990 }
 991
 992 void wxPreviewControlBar::OnPaint(wxPaintEvent& WXUNUSED(event))
 993 {
 994     wxPaintDC dc(this);
 995
 996     int w, h;
 997     GetSize(&w, &h);
 998     dc.SetPen(*wxBLACK_PEN);
 999     dc.SetBrush(*wxTRANSPARENT_BRUSH);
1000     dc.DrawLine( 0, h-1, w, h-1 );
1001 }
1002
1003 void wxPreviewControlBar::OnWindowClose(wxCommandEvent& WXUNUSED(event))
1004 {
1005     wxPreviewFrame *frame = (wxPreviewFrame *)GetParent();
1006     frame->Close(true);
1007 }
1008
1009 void wxPreviewControlBar::OnPrint(void)
1010 {
1011     wxPrintPreviewBase *preview = GetPrintPreview();
1012     preview->Print(true);
1013 }
1014
1015 void wxPreviewControlBar::OnNext(void)
1016 {
1017     wxPrintPreviewBase *preview = GetPrintPreview();
1018     if (preview)
1019     {
1020         int currentPage = preview->GetCurrentPage();
1021         if ((preview->GetMaxPage() > 0) &&
1022             (currentPage < preview->GetMaxPage()) &&
1023             preview->GetPrintout()->HasPage(currentPage + 1))
1024         {
1025             preview->SetCurrentPage(currentPage + 1);
1026         }
1027     }
1028 }
1029
1030 void wxPreviewControlBar::OnPrevious(void)
1031 {
1032     wxPrintPreviewBase *preview = GetPrintPreview();
1033     if (preview)
1034     {
1035         int currentPage = preview->GetCurrentPage();
1036         if ((preview->GetMinPage() > 0) &&
1037             (currentPage > preview->GetMinPage()) &&
1038             preview->GetPrintout()->HasPage(currentPage - 1))
1039         {
1040             preview->SetCurrentPage(currentPage - 1);
1041         }
1042     }
1043 }
1044
1045 void wxPreviewControlBar::OnFirst(void)
1046 {
1047     wxPrintPreviewBase *preview = GetPrintPreview();
1048     if (preview)
1049     {
1050         int currentPage = preview->GetMinPage();
1051         if (preview->GetPrintout()->HasPage(currentPage))
1052         {
1053             preview->SetCurrentPage(currentPage);
1054         }
1055     }
1056 }
1057
1058 void wxPreviewControlBar::OnLast(void)
1059 {
1060     wxPrintPreviewBase *preview = GetPrintPreview();
1061     if (preview)
1062     {
1063         int currentPage = preview->GetMaxPage();
1064         if (preview->GetPrintout()->HasPage(currentPage))
1065         {
1066             preview->SetCurrentPage(currentPage);
1067         }
1068     }
1069 }
1070
1071 void wxPreviewControlBar::OnGoto(void)
1072 {
1073     wxPrintPreviewBase *preview = GetPrintPreview();
1074     if (preview)
1075     {
1076         long currentPage;
1077
1078         if (preview->GetMinPage() > 0)
1079         {
1080             wxString strPrompt;
1081             wxString strPage;
1082
1083             strPrompt.Printf( _("Enter a page number between %d and %d:"),
1084                 preview->GetMinPage(), preview->GetMaxPage());
1085             strPage.Printf( wxT("%d"), preview->GetCurrentPage() );
1086
1087             strPage =
1088                 wxGetTextFromUser( strPrompt, _("Goto Page"), strPage, GetParent());
1089
1090             if ( strPage.ToLong( &currentPage ) )
1091                 if (preview->GetPrintout()->HasPage(currentPage))
1092                 {
1093                     preview->SetCurrentPage(currentPage);
1094                 }
1095         }
1096     }
1097 }
1098
1099 void wxPreviewControlBar::OnZoom(wxCommandEvent& WXUNUSED(event))
1100 {
1101     int zoom = GetZoomControl();
1102     if (GetPrintPreview())
1103         GetPrintPreview()->SetZoom(zoom);
1104 }
1105
1106 void wxPreviewControlBar::CreateButtons()
1107 {
1108     SetSize(0, 0, 400, 40);
1109
1110     wxBoxSizer *item0 = new wxBoxSizer( wxHORIZONTAL );
1111
1112     m_closeButton = new wxButton( this, wxID_PREVIEW_CLOSE, _("&Close"), wxDefaultPosition, wxDefaultSize, 0 );
1113     item0->Add( m_closeButton, 0, wxALIGN_CENTRE|wxALL, 5 );
1114
1115     if (m_buttonFlags & wxPREVIEW_PRINT)
1116     {
1117         m_printButton = new wxButton( this, wxID_PREVIEW_PRINT, _("&Print..."), wxDefaultPosition, wxDefaultSize, 0 );
1118         item0->Add( m_printButton, 0, wxALIGN_CENTRE|wxALL, 5 );
1119     }
1120
1121     // Exact-fit buttons are too tiny on wxUniversal
1122     int navButtonStyle;
1123     wxSize navButtonSize;
1124 #ifdef __WXUNIVERSAL__
1125     navButtonStyle = 0;
1126     navButtonSize = wxSize(40, m_closeButton->GetSize().y);
1127 #else
1128     navButtonStyle = wxBU_EXACTFIT;
1129     navButtonSize = wxDefaultSize;
1130 #endif
1131
1132     if (m_buttonFlags & wxPREVIEW_FIRST)
1133     {
1134         m_firstPageButton = new wxButton( this, wxID_PREVIEW_FIRST, _("|<<"), wxDefaultPosition, navButtonSize, navButtonStyle );
1135         item0->Add( m_firstPageButton, 0, wxALIGN_CENTRE|wxALL, 5 );
1136     }
1137
1138     if (m_buttonFlags & wxPREVIEW_PREVIOUS)
1139     {
1140         m_previousPageButton = new wxButton( this, wxID_PREVIEW_PREVIOUS, _("<<"), wxDefaultPosition, navButtonSize, navButtonStyle );
1141         item0->Add( m_previousPageButton, 0, wxALIGN_CENTRE|wxRIGHT|wxTOP|wxBOTTOM, 5 );
1142     }
1143
1144     if (m_buttonFlags & wxPREVIEW_NEXT)
1145     {
1146         m_nextPageButton = new wxButton( this, wxID_PREVIEW_NEXT, _(">>"), wxDefaultPosition, navButtonSize, navButtonStyle );
1147         item0->Add( m_nextPageButton, 0, wxALIGN_CENTRE|wxRIGHT|wxTOP|wxBOTTOM, 5 );
1148     }
1149
1150     if (m_buttonFlags & wxPREVIEW_LAST)
1151     {
1152         m_lastPageButton = new wxButton( this, wxID_PREVIEW_LAST, _(">>|"), wxDefaultPosition, navButtonSize, navButtonStyle );
1153         item0->Add( m_lastPageButton, 0, wxALIGN_CENTRE|wxRIGHT|wxTOP|wxBOTTOM, 5 );
1154     }
1155
1156     if (m_buttonFlags & wxPREVIEW_GOTO)
1157     {
1158         m_gotoPageButton = new wxButton( this, wxID_PREVIEW_GOTO, _("&Goto..."), wxDefaultPosition, wxDefaultSize, 0 );
1159         item0->Add( m_gotoPageButton, 0, wxALIGN_CENTRE|wxALL, 5 );
1160     }
1161
1162     if (m_buttonFlags & wxPREVIEW_ZOOM)
1163     {
1164         wxString choices[] =
1165         {
1166             wxT("10%"), wxT("15%"), wxT("20%"), wxT("25%"), wxT("30%"), wxT("35%"), wxT("40%"), wxT("45%"), wxT("50%"), wxT("55%"),
1167                 wxT("60%"), wxT("65%"), wxT("70%"), wxT("75%"), wxT("80%"), wxT("85%"), wxT("90%"), wxT("95%"), wxT("100%"), wxT("110%"),
1168                 wxT("120%"), wxT("150%"), wxT("200%")
1169         };
1170         int n = WXSIZEOF(choices);
1171
1172         m_zoomControl = new wxChoice( this, wxID_PREVIEW_ZOOM, wxDefaultPosition, wxSize(70,wxDefaultCoord), n, choices, 0 );
1173         item0->Add( m_zoomControl, 0, wxALIGN_CENTRE|wxALL, 5 );
1174         SetZoomControl(m_printPreview->GetZoom());
1175     }
1176
1177     SetSizer(item0);
1178     item0->Fit(this);
1179 }
1180
1181 void wxPreviewControlBar::SetZoomControl(int zoom)
1182 {
1183     if (m_zoomControl)
1184     {
1185         int n, count = m_zoomControl->GetCount();
1186         long val;
1187         for (n=0; n<count; n++)
1188         {
1189             if (m_zoomControl->GetString(n).BeforeFirst(wxT('%')).ToLong(&val) &&
1190                 (val >= long(zoom)))
1191             {
1192                 m_zoomControl->SetSelection(n);
1193                 return;
1194             }
1195         }
1196
1197         m_zoomControl->SetSelection(count-1);
1198     }
1199 }
1200
1201 int wxPreviewControlBar::GetZoomControl()
1202 {
1203     if (m_zoomControl && (m_zoomControl->GetStringSelection() != wxEmptyString))
1204     {
1205         long val;
1206         if (m_zoomControl->GetStringSelection().BeforeFirst(wxT('%')).ToLong(&val))
1207             return int(val);
1208     }
1209
1210     return 0;
1211 }
1212
1213
1214 /*
1215 * Preview frame
1216 */
1217
1218 IMPLEMENT_CLASS(wxPreviewFrame, wxFrame)
1219
1220 BEGIN_EVENT_TABLE(wxPreviewFrame, wxFrame)
1221     EVT_CHAR_HOOK(wxPreviewFrame::OnChar)
1222     EVT_CLOSE(wxPreviewFrame::OnCloseWindow)
1223 END_EVENT_TABLE()
1224
1225 void wxPreviewFrame::OnChar(wxKeyEvent &event)
1226 {
1227     if ( event.GetKeyCode() == WXK_ESCAPE )
1228     {
1229         Close(true);
1230     }
1231     else
1232     {
1233         event.Skip();
1234     }
1235 }
1236
1237 wxPreviewFrame::wxPreviewFrame(wxPrintPreviewBase *preview, wxWindow *parent, const wxString& title,
1238                                const wxPoint& pos, const wxSize& size, long style, const wxString& name):
1239 wxFrame(parent, wxID_ANY, title, pos, size, style, name)
1240 {
1241     m_printPreview = preview;
1242     m_controlBar = NULL;
1243     m_previewCanvas = NULL;
1244     m_windowDisabler = NULL;
1245
1246     // Give the application icon
1247 #ifdef __WXMSW__
1248     wxFrame* topFrame = wxDynamicCast(wxTheApp->GetTopWindow(), wxFrame);
1249     if (topFrame)
1250         SetIcon(topFrame->GetIcon());
1251 #endif
1252 }
1253
1254 wxPreviewFrame::~wxPreviewFrame()
1255 {
1256 }
1257
1258 void wxPreviewFrame::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
1259 {
1260     if (m_windowDisabler)
1261         delete m_windowDisabler;
1262
1263     // Need to delete the printout and the print preview
1264     wxPrintout *printout = m_printPreview->GetPrintout();
1265     if (printout)
1266     {
1267         delete printout;
1268         m_printPreview->SetPrintout(NULL);
1269         m_printPreview->SetCanvas(NULL);
1270         m_printPreview->SetFrame(NULL);
1271     }
1272     delete m_printPreview;
1273
1274     Destroy();
1275 }
1276
1277 void wxPreviewFrame::Initialize()
1278 {
1279 #if wxUSE_STATUSBAR
1280     CreateStatusBar();
1281 #endif
1282     CreateCanvas();
1283     CreateControlBar();
1284
1285     m_printPreview->SetCanvas(m_previewCanvas);
1286     m_printPreview->SetFrame(this);
1287
1288     wxBoxSizer *item0 = new wxBoxSizer( wxVERTICAL );
1289
1290     item0->Add( m_controlBar, 0, wxGROW|wxALIGN_CENTER_VERTICAL, 5 );
1291     item0->Add( m_previewCanvas, 1, wxGROW|wxALIGN_CENTER_VERTICAL, 5 );
1292
1293     SetAutoLayout( true );
1294     SetSizer( item0 );
1295
1296     m_windowDisabler = new wxWindowDisabler(this);
1297
1298     Layout();
1299
1300     m_printPreview->AdjustScrollbars(m_previewCanvas);
1301     m_previewCanvas->SetFocus();
1302     m_controlBar->SetFocus();
1303 }
1304
1305 void wxPreviewFrame::CreateCanvas()
1306 {
1307     m_previewCanvas = new wxPreviewCanvas(m_printPreview, this);
1308 }
1309
1310 void wxPreviewFrame::CreateControlBar()
1311 {
1312     long buttons = wxPREVIEW_DEFAULT;
1313     if (m_printPreview->GetPrintoutForPrinting())
1314         buttons |= wxPREVIEW_PRINT;
1315
1316     m_controlBar = new wxPreviewControlBar(m_printPreview, buttons, this, wxPoint(0,0), wxSize(400, 40));
1317     m_controlBar->CreateButtons();
1318 }
1319
1320 /*
1321 * Print preview
1322 */
1323
1324 IMPLEMENT_CLASS(wxPrintPreviewBase, wxObject)
1325
1326 wxPrintPreviewBase::wxPrintPreviewBase(wxPrintout *printout,
1327                                        wxPrintout *printoutForPrinting,
1328                                        wxPrintData *data)
1329 {
1330     if (data)
1331         m_printDialogData = (*data);
1332
1333     Init(printout, printoutForPrinting);
1334 }
1335
1336 wxPrintPreviewBase::wxPrintPreviewBase(wxPrintout *printout,
1337                                        wxPrintout *printoutForPrinting,
1338                                        wxPrintDialogData *data)
1339 {
1340     if (data)
1341         m_printDialogData = (*data);
1342
1343     Init(printout, printoutForPrinting);
1344 }
1345
1346 void wxPrintPreviewBase::Init(wxPrintout *printout,
1347                               wxPrintout *printoutForPrinting)
1348 {
1349     m_isOk = true;
1350     m_previewPrintout = printout;
1351     if (m_previewPrintout)
1352         m_previewPrintout->SetIsPreview(true);
1353
1354     m_printPrintout = printoutForPrinting;
1355
1356     m_previewCanvas = NULL;
1357     m_previewFrame = NULL;
1358     m_previewBitmap = NULL;
1359     m_currentPage = 1;
1360     m_currentZoom = 70;
1361     m_topMargin = 40;
1362     m_leftMargin = 40;
1363     m_pageWidth = 0;
1364     m_pageHeight = 0;
1365     m_printingPrepared = false;
1366     m_minPage = 1;
1367     m_maxPage = 1;
1368 }
1369
1370 wxPrintPreviewBase::~wxPrintPreviewBase()
1371 {
1372     if (m_previewPrintout)
1373         delete m_previewPrintout;
1374     if (m_previewBitmap)
1375         delete m_previewBitmap;
1376     if (m_printPrintout)
1377         delete m_printPrintout;
1378 }
1379
1380 bool wxPrintPreviewBase::SetCurrentPage(int pageNum)
1381 {
1382     if (m_currentPage == pageNum)
1383         return true;
1384
1385     m_currentPage = pageNum;
1386     if (m_previewBitmap)
1387     {
1388         delete m_previewBitmap;
1389         m_previewBitmap = NULL;
1390     }
1391
1392     if (m_previewCanvas)
1393     {
1394         AdjustScrollbars(m_previewCanvas);
1395
1396         if (!RenderPage(pageNum))
1397             return false;
1398         m_previewCanvas->Refresh();
1399         m_previewCanvas->SetFocus();
1400     }
1401     return true;
1402 }
1403
1404 int wxPrintPreviewBase::GetCurrentPage() const
1405     { return m_currentPage; }
1406 void wxPrintPreviewBase::SetPrintout(wxPrintout *printout)
1407     { m_previewPrintout = printout; }
1408 wxPrintout *wxPrintPreviewBase::GetPrintout() const
1409     { return m_previewPrintout; }
1410 wxPrintout *wxPrintPreviewBase::GetPrintoutForPrinting() const
1411     { return m_printPrintout; }
1412 void wxPrintPreviewBase::SetFrame(wxFrame *frame)
1413     { m_previewFrame = frame; }
1414 void wxPrintPreviewBase::SetCanvas(wxPreviewCanvas *canvas)
1415     { m_previewCanvas = canvas; }
1416 wxFrame *wxPrintPreviewBase::GetFrame() const
1417     { return m_previewFrame; }
1418 wxPreviewCanvas *wxPrintPreviewBase::GetCanvas() const
1419     { return m_previewCanvas; }
1420
1421 void wxPrintPreviewBase::CalcRects(wxPreviewCanvas *canvas, wxRect& pageRect, wxRect& paperRect)
1422 {
1423     // Calculate the rectangles for the printable area of the page and the
1424     // entire paper as they appear on the canvas on-screen.
1425     int canvasWidth, canvasHeight;
1426     canvas->GetSize(&canvasWidth, &canvasHeight);
1427
1428     float zoomScale = float(m_currentZoom) / 100;
1429     float screenPrintableWidth = zoomScale * m_pageWidth * m_previewScaleX;
1430     float screenPrintableHeight = zoomScale * m_pageHeight * m_previewScaleY;
1431
1432     wxRect devicePaperRect = m_previewPrintout->GetPaperRectPixels();
1433     wxCoord devicePrintableWidth, devicePrintableHeight;
1434     m_previewPrintout->GetPageSizePixels(&devicePrintableWidth, &devicePrintableHeight);
1435     float scaleX = screenPrintableWidth / devicePrintableWidth;
1436     float scaleY = screenPrintableHeight / devicePrintableHeight;
1437     paperRect.width = wxCoord(scaleX * devicePaperRect.width);
1438     paperRect.height = wxCoord(scaleY * devicePaperRect.height);
1439
1440     paperRect.x = wxCoord((canvasWidth - paperRect.width)/ 2.0);
1441     if (paperRect.x < m_leftMargin)
1442         paperRect.x = m_leftMargin;
1443     paperRect.y = wxCoord((canvasHeight - paperRect.height)/ 2.0);
1444     if (paperRect.y < m_topMargin)
1445         paperRect.y = m_topMargin;
1446
1447     pageRect.x = paperRect.x - wxCoord(scaleX * devicePaperRect.x);
1448     pageRect.y = paperRect.y - wxCoord(scaleY * devicePaperRect.y);
1449     pageRect.width = wxCoord(screenPrintableWidth);
1450     pageRect.height = wxCoord(screenPrintableHeight);
1451 }
1452
1453
1454 bool wxPrintPreviewBase::PaintPage(wxPreviewCanvas *canvas, wxDC& dc)
1455 {
1456     DrawBlankPage(canvas, dc);
1457
1458     if (!m_previewBitmap)
1459         if (!RenderPage(m_currentPage))
1460             return false;
1461     if (!m_previewBitmap)
1462         return false;
1463     if (!canvas)
1464         return false;
1465
1466     wxRect pageRect, paperRect;
1467     CalcRects(canvas, pageRect, paperRect);
1468     wxMemoryDC temp_dc;
1469     temp_dc.SelectObject(*m_previewBitmap);
1470
1471     dc.Blit(pageRect.x, pageRect.y,
1472         m_previewBitmap->GetWidth(), m_previewBitmap->GetHeight(), &temp_dc, 0, 0);
1473
1474     temp_dc.SelectObject(wxNullBitmap);
1475     return true;
1476 }
1477
1478 // Adjusts the scrollbars for the current scale
1479 void wxPrintPreviewBase::AdjustScrollbars(wxPreviewCanvas *canvas)
1480 {
1481     if (!canvas)
1482         return ;
1483
1484     wxRect pageRect, paperRect;
1485     CalcRects(canvas, pageRect, paperRect);
1486      int totalWidth = paperRect.width + 2 * m_leftMargin;
1487     int totalHeight = paperRect.height + 2 * m_topMargin;
1488     int scrollUnitsX = totalWidth / 10;
1489     int scrollUnitsY = totalHeight / 10;
1490     wxSize virtualSize = canvas->GetVirtualSize();
1491     if (virtualSize.GetWidth() != totalWidth || virtualSize.GetHeight() != totalHeight)
1492         canvas->SetScrollbars(10, 10, scrollUnitsX, scrollUnitsY, 0, 0, true);
1493 }
1494
1495 bool wxPrintPreviewBase::RenderPage(int pageNum)
1496 {
1497     wxBusyCursor busy;
1498
1499     if (!m_previewCanvas)
1500     {
1501         wxFAIL_MSG(_T("wxPrintPreviewBase::RenderPage: must use wxPrintPreviewBase::SetCanvas to let me know about the canvas!"));
1502         return false;
1503     }
1504
1505     wxRect pageRect, paperRect;
1506     CalcRects(m_previewCanvas, pageRect, paperRect);
1507
1508     if (!m_previewBitmap)
1509     {
1510         m_previewBitmap = new wxBitmap(pageRect.width, pageRect.height);
1511
1512         if (!m_previewBitmap || !m_previewBitmap->Ok())
1513         {
1514             if (m_previewBitmap) {
1515                 delete m_previewBitmap;
1516                 m_previewBitmap = NULL;
1517             }
1518             wxMessageBox(_("Sorry, not enough memory to create a preview."), _("Print Preview Failure"), wxOK);
1519             return false;
1520         }
1521     }
1522
1523     wxMemoryDC memoryDC;
1524     memoryDC.SelectObject(*m_previewBitmap);
1525
1526     memoryDC.Clear();
1527
1528     m_previewPrintout->SetDC(&memoryDC);
1529     m_previewPrintout->SetPageSizePixels(m_pageWidth, m_pageHeight);
1530
1531     // Need to delay OnPreparePrinting until here, so we have enough information.
1532     if (!m_printingPrepared)
1533     {
1534         m_previewPrintout->OnPreparePrinting();
1535         int selFrom, selTo;
1536         m_previewPrintout->GetPageInfo(&m_minPage, &m_maxPage, &selFrom, &selTo);
1537         m_printingPrepared = true;
1538     }
1539
1540     m_previewPrintout->OnBeginPrinting();
1541
1542     if (!m_previewPrintout->OnBeginDocument(m_printDialogData.GetFromPage(), m_printDialogData.GetToPage()))
1543     {
1544         wxMessageBox(_("Could not start document preview."), _("Print Preview Failure"), wxOK);
1545
1546         memoryDC.SelectObject(wxNullBitmap);
1547
1548         delete m_previewBitmap;
1549         m_previewBitmap = NULL;
1550         return false;
1551     }
1552
1553     m_previewPrintout->OnPrintPage(pageNum);
1554     m_previewPrintout->OnEndDocument();
1555     m_previewPrintout->OnEndPrinting();
1556
1557     m_previewPrintout->SetDC(NULL);
1558
1559     memoryDC.SelectObject(wxNullBitmap);
1560
1561 #if wxUSE_STATUSBAR
1562     wxString status;
1563     if (m_maxPage != 0)
1564         status = wxString::Format(_("Page %d of %d"), pageNum, m_maxPage);
1565     else
1566         status = wxString::Format(_("Page %d"), pageNum);
1567
1568     if (m_previewFrame)
1569         m_previewFrame->SetStatusText(status);
1570 #endif
1571
1572     return true;
1573 }
1574
1575 bool wxPrintPreviewBase::DrawBlankPage(wxPreviewCanvas *canvas, wxDC& dc)
1576 {
1577     wxRect pageRect, paperRect;
1578
1579     CalcRects(canvas, pageRect, paperRect);
1580
1581     // Draw shadow, allowing for 1-pixel border AROUND the actual paper
1582     wxCoord shadowOffset = 4;
1583
1584     dc.SetPen(*wxBLACK_PEN);
1585     dc.SetBrush(*wxBLACK_BRUSH);
1586     dc.DrawRectangle(paperRect.x + shadowOffset, paperRect.y + paperRect.height + 1,
1587         paperRect.width, shadowOffset);
1588
1589     dc.DrawRectangle(paperRect.x + paperRect.width, paperRect.y + shadowOffset,
1590         shadowOffset, paperRect.height);
1591
1592     // Draw blank page allowing for 1-pixel border AROUND the actual paper
1593     dc.SetPen(*wxBLACK_PEN);
1594     dc.SetBrush(*wxWHITE_BRUSH);
1595     dc.DrawRectangle(paperRect.x - 2, paperRect.y - 1,
1596         paperRect.width + 3, paperRect.height + 2);
1597
1598     return true;
1599 }
1600
1601 void wxPrintPreviewBase::SetZoom(int percent)
1602 {
1603     if (m_currentZoom == percent)
1604         return;
1605
1606     m_currentZoom = percent;
1607     if (m_previewBitmap)
1608     {
1609         delete m_previewBitmap;
1610         m_previewBitmap = NULL;
1611     }
1612
1613     if (m_previewCanvas)
1614     {
1615         AdjustScrollbars(m_previewCanvas);
1616         RenderPage(m_currentPage);
1617         ((wxScrolledWindow *) m_previewCanvas)->Scroll(0, 0);
1618         m_previewCanvas->ClearBackground();
1619         m_previewCanvas->Refresh();
1620         m_previewCanvas->SetFocus();
1621     }
1622 }
1623
1624 wxPrintDialogData& wxPrintPreviewBase::GetPrintDialogData()
1625 {
1626     return m_printDialogData;
1627 }
1628
1629 int wxPrintPreviewBase::GetZoom() const
1630 { return m_currentZoom; }
1631 int wxPrintPreviewBase::GetMaxPage() const
1632 { return m_maxPage; }
1633 int wxPrintPreviewBase::GetMinPage() const
1634 { return m_minPage; }
1635 bool wxPrintPreviewBase::IsOk() const
1636 { return m_isOk; }
1637 void wxPrintPreviewBase::SetOk(bool ok)
1638 { m_isOk = ok; }
1639
1640 //----------------------------------------------------------------------------
1641 // wxPrintPreview
1642 //----------------------------------------------------------------------------
1643
1644 IMPLEMENT_CLASS(wxPrintPreview, wxPrintPreviewBase)
1645
1646 wxPrintPreview::wxPrintPreview(wxPrintout *printout,
1647                    wxPrintout *printoutForPrinting,
1648                    wxPrintDialogData *data) :
1649     wxPrintPreviewBase( printout, printoutForPrinting, data )
1650 {
1651     m_pimpl = wxPrintFactory::GetFactory()->
1652         CreatePrintPreview( printout, printoutForPrinting, data );
1653 }
1654
1655 wxPrintPreview::wxPrintPreview(wxPrintout *printout,
1656                    wxPrintout *printoutForPrinting,
1657                    wxPrintData *data ) :
1658     wxPrintPreviewBase( printout, printoutForPrinting, data )
1659 {
1660     m_pimpl = wxPrintFactory::GetFactory()->
1661         CreatePrintPreview( printout, printoutForPrinting, data );
1662 }
1663
1664 wxPrintPreview::~wxPrintPreview()
1665 {
1666     delete m_pimpl;
1667
1668     // don't delete twice
1669     m_printPrintout = NULL;
1670     m_previewPrintout = NULL;
1671     m_previewBitmap = NULL;
1672 }
1673
1674 bool wxPrintPreview::SetCurrentPage(int pageNum)
1675 {
1676     return m_pimpl->SetCurrentPage( pageNum );
1677 }
1678
1679 int wxPrintPreview::GetCurrentPage() const
1680 {
1681     return m_pimpl->GetCurrentPage();
1682 }
1683
1684 void wxPrintPreview::SetPrintout(wxPrintout *printout)
1685 {
1686     m_pimpl->SetPrintout( printout );
1687 }
1688
1689 wxPrintout *wxPrintPreview::GetPrintout() const
1690 {
1691     return m_pimpl->GetPrintout();
1692 }
1693
1694 wxPrintout *wxPrintPreview::GetPrintoutForPrinting() const
1695 {
1696     return m_pimpl->GetPrintoutForPrinting();
1697 }
1698
1699 void wxPrintPreview::SetFrame(wxFrame *frame)
1700 {
1701     m_pimpl->SetFrame( frame );
1702 }
1703
1704 void wxPrintPreview::SetCanvas(wxPreviewCanvas *canvas)
1705 {
1706     m_pimpl->SetCanvas( canvas );
1707 }
1708
1709 wxFrame *wxPrintPreview::GetFrame() const
1710 {
1711     return m_pimpl->GetFrame();
1712 }
1713
1714 wxPreviewCanvas *wxPrintPreview::GetCanvas() const
1715 {
1716     return m_pimpl->GetCanvas();
1717 }
1718
1719 bool wxPrintPreview::PaintPage(wxPreviewCanvas *canvas, wxDC& dc)
1720 {
1721     return m_pimpl->PaintPage( canvas, dc );
1722 }
1723
1724 bool wxPrintPreview::DrawBlankPage(wxPreviewCanvas *canvas, wxDC& dc)
1725 {
1726     return m_pimpl->DrawBlankPage( canvas, dc );
1727 }
1728
1729 void wxPrintPreview::AdjustScrollbars(wxPreviewCanvas *canvas)
1730 {
1731     m_pimpl->AdjustScrollbars( canvas );
1732 }
1733
1734 bool wxPrintPreview::RenderPage(int pageNum)
1735 {
1736     return m_pimpl->RenderPage( pageNum );
1737 }
1738
1739 void wxPrintPreview::SetZoom(int percent)
1740 {
1741     m_pimpl->SetZoom( percent );
1742 }
1743
1744 int wxPrintPreview::GetZoom() const
1745 {
1746     return m_pimpl->GetZoom();
1747 }
1748
1749 wxPrintDialogData& wxPrintPreview::GetPrintDialogData()
1750 {
1751     return m_pimpl->GetPrintDialogData();
1752 }
1753
1754 int wxPrintPreview::GetMaxPage() const
1755 {
1756     return m_pimpl->GetMaxPage();
1757 }
1758
1759 int wxPrintPreview::GetMinPage() const
1760 {
1761     return m_pimpl->GetMinPage();
1762 }
1763
1764 bool wxPrintPreview::IsOk() const
1765 {
1766     return m_pimpl->Ok();
1767 }
1768
1769 void wxPrintPreview::SetOk(bool ok)
1770 {
1771     m_pimpl->SetOk( ok );
1772 }
1773
1774 bool wxPrintPreview::Print(bool interactive)
1775 {
1776     return m_pimpl->Print( interactive );
1777 }
1778
1779 void wxPrintPreview::DetermineScaling()
1780 {
1781     m_pimpl->DetermineScaling();
1782 }
1783
1784 #endif // wxUSE_PRINTING_ARCHITECTURE