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 #endif
  15
  16 // For compilers that support precompilation, includes "wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #ifdef __BORLANDC__
  20 #pragma hdrstop
  21 #endif
  22
  23 #include "wx/defs.h"
  24
  25 #if wxUSE_PRINTING_ARCHITECTURE
  26
  27 #ifndef WX_PRECOMP
  28 #include "wx/utils.h"
  29 #include "wx/dc.h"
  30 #include "wx/app.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/stattext.h"
  38 #include "wx/intl.h"
  39 #include "wx/textdlg.h"
  40 #include "wx/sizer.h"
  41 #endif // !WX_PRECOMP
  42
  43 #include "wx/prntbase.h"
  44 #include "wx/dcprint.h"
  45 #include "wx/printdlg.h"
  46 #include "wx/module.h"
  47
  48 #include <stdlib.h>
  49 #include <string.h>
  50
  51 #ifdef __WXMSW__
  52     #include "wx/msw/private.h"
  53     #include <commdlg.h>
  54
  55     #ifndef __WIN32__
  56         #include <print.h>
  57     #endif
  58 #endif // __WXMSW__
  59
  60 IMPLEMENT_CLASS(wxPrinterBase, wxObject)
  61 IMPLEMENT_ABSTRACT_CLASS(wxPrintout, wxObject)
  62 IMPLEMENT_CLASS(wxPreviewCanvas, wxWindow)
  63 IMPLEMENT_CLASS(wxPreviewControlBar, wxWindow)
  64 IMPLEMENT_CLASS(wxPreviewFrame, wxFrame)
  65 IMPLEMENT_CLASS(wxPrintPreviewBase, wxObject)
  66
  67 BEGIN_EVENT_TABLE(wxPrintAbortDialog, wxDialog)
  68     EVT_BUTTON(wxID_CANCEL, wxPrintAbortDialog::OnCancel)
  69 END_EVENT_TABLE()
  70
  71 BEGIN_EVENT_TABLE(wxPreviewCanvas, wxScrolledWindow)
  72     EVT_PAINT(wxPreviewCanvas::OnPaint)
  73     EVT_CHAR(wxPreviewCanvas::OnChar)
  74     EVT_SYS_COLOUR_CHANGED(wxPreviewCanvas::OnSysColourChanged)
  75 END_EVENT_TABLE()
  76
  77 /*
  78 * Printer
  79 */
  80
  81 wxPrinterBase::wxPrinterBase(wxPrintDialogData *data)
  82 {
  83     m_currentPrintout = (wxPrintout *) NULL;
  84     sm_abortWindow = (wxWindow *) NULL;
  85     sm_abortIt = FALSE;
  86     if (data)
  87         m_printDialogData = (*data);
  88     sm_lastError = wxPRINTER_NO_ERROR;
  89 }
  90
  91 wxWindow *wxPrinterBase::sm_abortWindow = (wxWindow *) NULL;
  92 bool wxPrinterBase::sm_abortIt = FALSE;
  93 wxPrinterError wxPrinterBase::sm_lastError = wxPRINTER_NO_ERROR;
  94
  95 wxPrinterBase::~wxPrinterBase()
  96 {
  97 }
  98
  99 void wxPrintAbortDialog::OnCancel(wxCommandEvent& WXUNUSED(event))
 100 {
 101     wxPrinterBase::sm_abortIt = TRUE;
 102     wxPrinterBase::sm_abortWindow->Show(FALSE);
 103     wxPrinterBase::sm_abortWindow->Close(TRUE);
 104     wxPrinterBase::sm_abortWindow = (wxWindow *) NULL;
 105 }
 106
 107 wxWindow *wxPrinterBase::CreateAbortWindow(wxWindow *parent, wxPrintout * printout)
 108 {
 109     wxPrintAbortDialog *dialog = new wxPrintAbortDialog(parent, _("Printing ") , wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE);
 110
 111     wxBoxSizer *button_sizer = new wxBoxSizer( wxVERTICAL );
 112     button_sizer->Add( new wxStaticText(dialog, -1, _("Please wait while printing\n") + printout->GetTitle() ), 0, wxALL, 10 );
 113     button_sizer->Add( new wxButton( dialog, wxID_CANCEL, wxT("Cancel") ), 0, wxALL | wxALIGN_CENTER, 10 );
 114
 115     dialog->SetAutoLayout( TRUE );
 116     dialog->SetSizer( button_sizer );
 117
 118     button_sizer->Fit(dialog);
 119     button_sizer->SetSizeHints (dialog) ;
 120
 121     return dialog;
 122 }
 123
 124 void wxPrinterBase::ReportError(wxWindow *parent, wxPrintout *WXUNUSED(printout), const wxString& message)
 125 {
 126     wxMessageBox(message, _("Printing Error"), wxOK, parent);
 127 }
 128
 129 /*
 130 * Printout class
 131 */
 132
 133 wxPrintout::wxPrintout(const wxString& title)
 134 {
 135     m_printoutTitle = title ;
 136     m_printoutDC = (wxDC *) NULL;
 137     m_pageWidthMM = 0;
 138     m_pageHeightMM = 0;
 139     m_pageWidthPixels = 0;
 140     m_pageHeightPixels = 0;
 141     m_PPIScreenX = 0;
 142     m_PPIScreenY = 0;
 143     m_PPIPrinterX = 0;
 144     m_PPIPrinterY = 0;
 145     m_isPreview = FALSE;
 146 }
 147
 148 wxPrintout::~wxPrintout()
 149 {
 150 }
 151
 152 bool wxPrintout::OnBeginDocument(int WXUNUSED(startPage), int WXUNUSED(endPage))
 153 {
 154     return GetDC()->StartDoc(_("Printing ") + m_printoutTitle);
 155 }
 156
 157 void wxPrintout::OnEndDocument()
 158 {
 159     GetDC()->EndDoc();
 160 }
 161
 162 void wxPrintout::OnBeginPrinting()
 163 {
 164 }
 165
 166 void wxPrintout::OnEndPrinting()
 167 {
 168 }
 169
 170 bool wxPrintout::HasPage(int page)
 171 {
 172     return (page == 1);
 173 }
 174
 175 void wxPrintout::GetPageInfo(int *minPage, int *maxPage, int *fromPage, int *toPage)
 176 {
 177     *minPage = 1;
 178     *maxPage = 32000;
 179     *fromPage = 1;
 180     *toPage = 1;
 181 }
 182
 183 /*
 184 * Preview canvas
 185 */
 186
 187 // VZ: the current code doesn't refresh properly without
 188 //     wxFULL_REPAINT_ON_RESIZE, this must be fixed as otherwise we have
 189 //     really horrible flicker when resizing the preview frame, but without
 190 //     this style it simply doesn't work correctly at all...
 191 wxPreviewCanvas::wxPreviewCanvas(wxPrintPreviewBase *preview, wxWindow *parent,
 192                                  const wxPoint& pos, const wxSize& size, long style, const wxString& name):
 193 wxScrolledWindow(parent, -1, pos, size, style | wxFULL_REPAINT_ON_RESIZE, name)
 194 {
 195     m_printPreview = preview;
 196 #ifdef __WXMAC__
 197     // The app workspace colour is always white, but we should have
 198     // a contrast with the page.
 199     wxSystemColour colourIndex = wxSYS_COLOUR_3DDKSHADOW;
 200 #else
 201     wxSystemColour colourIndex = wxSYS_COLOUR_APPWORKSPACE;
 202 #endif
 203     SetBackgroundColour(wxSystemSettings::GetColour(colourIndex));
 204
 205     SetScrollbars(10, 10, 100, 100);
 206 }
 207
 208 wxPreviewCanvas::~wxPreviewCanvas()
 209 {
 210 }
 211
 212 void wxPreviewCanvas::OnPaint(wxPaintEvent& WXUNUSED(event))
 213 {
 214     wxPaintDC dc(this);
 215     PrepareDC( dc );
 216
 217 /*
 218 #ifdef __WXGTK__
 219     if (!GetUpdateRegion().IsEmpty())
 220         dc.SetClippingRegion( GetUpdateRegion() );
 221 #endif
 222 */
 223
 224     if (m_printPreview)
 225     {
 226         m_printPreview->PaintPage(this, dc);
 227     }
 228 }
 229
 230 // Responds to colour changes, and passes event on to children.
 231 void wxPreviewCanvas::OnSysColourChanged(wxSysColourChangedEvent& event)
 232 {
 233 #ifdef __WXMAC__
 234     // The app workspace colour is always white, but we should have
 235     // a contrast with the page.
 236     wxSystemColour colourIndex = wxSYS_COLOUR_3DDKSHADOW;
 237 #else
 238     wxSystemColour colourIndex = wxSYS_COLOUR_APPWORKSPACE;
 239 #endif
 240     SetBackgroundColour(wxSystemSettings::GetColour(colourIndex));
 241     Refresh();
 242
 243     // Propagate the event to the non-top-level children
 244     wxWindow::OnSysColourChanged(event);
 245 }
 246
 247 void wxPreviewCanvas::OnChar(wxKeyEvent &event)
 248 {
 249     wxPreviewControlBar* controlBar = ((wxPreviewFrame*) GetParent())->GetControlBar();
 250     if (event.GetKeyCode() == WXK_ESCAPE)
 251     {
 252         ((wxPreviewFrame*) GetParent())->Close(TRUE);
 253         return;
 254     }
 255     else if (event.GetKeyCode() == WXK_TAB)
 256     {
 257         controlBar->OnGoto();
 258         return;
 259     }
 260     else if (event.GetKeyCode() == WXK_RETURN)
 261     {
 262         controlBar->OnPrint();
 263         return;
 264     }
 265
 266     if (!event.ControlDown())
 267     {
 268         event.Skip();
 269         return;
 270     }
 271
 272     switch(event.GetKeyCode())
 273     {
 274         case WXK_NEXT:
 275             controlBar->OnNext(); break;
 276         case WXK_PRIOR:
 277             controlBar->OnPrevious(); break;
 278         case WXK_HOME:
 279             controlBar->OnFirst(); break;
 280         case WXK_END:
 281             controlBar->OnLast(); break;
 282         default:
 283             event.Skip();
 284     }
 285 }
 286
 287 /*
 288 * Preview control bar
 289 */
 290
 291 BEGIN_EVENT_TABLE(wxPreviewControlBar, wxPanel)
 292     EVT_BUTTON(wxID_PREVIEW_CLOSE,    wxPreviewControlBar::OnWindowClose)
 293     EVT_BUTTON(wxID_PREVIEW_PRINT,    wxPreviewControlBar::OnPrintButton)
 294     EVT_BUTTON(wxID_PREVIEW_PREVIOUS, wxPreviewControlBar::OnPreviousButton)
 295     EVT_BUTTON(wxID_PREVIEW_NEXT,     wxPreviewControlBar::OnNextButton)
 296     EVT_BUTTON(wxID_PREVIEW_FIRST,    wxPreviewControlBar::OnFirstButton)
 297     EVT_BUTTON(wxID_PREVIEW_LAST,     wxPreviewControlBar::OnLastButton)
 298     EVT_BUTTON(wxID_PREVIEW_GOTO,     wxPreviewControlBar::OnGotoButton)
 299     EVT_CHOICE(wxID_PREVIEW_ZOOM,     wxPreviewControlBar::OnZoom)
 300     EVT_PAINT(wxPreviewControlBar::OnPaint)
 301 END_EVENT_TABLE()
 302
 303 wxPreviewControlBar::wxPreviewControlBar(wxPrintPreviewBase *preview, long buttons,
 304                                          wxWindow *parent, const wxPoint& pos, const wxSize& size,
 305                                          long style, const wxString& name):
 306 wxPanel(parent, -1, pos, size, style, name)
 307 {
 308     m_printPreview = preview;
 309     m_closeButton = (wxButton *) NULL;
 310     m_nextPageButton = (wxButton *) NULL;
 311     m_previousPageButton = (wxButton *) NULL;
 312     m_printButton = (wxButton *) NULL;
 313     m_zoomControl = (wxChoice *) NULL;
 314     m_buttonFlags = buttons;
 315 }
 316
 317 wxPreviewControlBar::~wxPreviewControlBar()
 318 {
 319 }
 320
 321 void wxPreviewControlBar::OnPaint(wxPaintEvent& WXUNUSED(event))
 322 {
 323     wxPaintDC dc(this);
 324
 325     int w, h;
 326     GetSize(&w, &h);
 327     dc.SetPen(*wxBLACK_PEN);
 328     dc.SetBrush(*wxTRANSPARENT_BRUSH);
 329     dc.DrawLine( 0, h-1, w, h-1 );
 330 }
 331
 332 void wxPreviewControlBar::OnWindowClose(wxCommandEvent& WXUNUSED(event))
 333 {
 334     wxPreviewFrame *frame = (wxPreviewFrame *)GetParent();
 335     frame->Close(TRUE);
 336 }
 337
 338 void wxPreviewControlBar::OnPrint(void)
 339 {
 340     wxPrintPreviewBase *preview = GetPrintPreview();
 341     preview->Print(TRUE);
 342 }
 343
 344 void wxPreviewControlBar::OnNext(void)
 345 {
 346     wxPrintPreviewBase *preview = GetPrintPreview();
 347     if (preview)
 348     {
 349         int currentPage = preview->GetCurrentPage();
 350         if ((preview->GetMaxPage() > 0) &&
 351             (currentPage < preview->GetMaxPage()) &&
 352             preview->GetPrintout()->HasPage(currentPage + 1))
 353         {
 354             preview->SetCurrentPage(currentPage + 1);
 355         }
 356     }
 357 }
 358
 359 void wxPreviewControlBar::OnPrevious(void)
 360 {
 361     wxPrintPreviewBase *preview = GetPrintPreview();
 362     if (preview)
 363     {
 364         int currentPage = preview->GetCurrentPage();
 365         if ((preview->GetMinPage() > 0) &&
 366             (currentPage > preview->GetMinPage()) &&
 367             preview->GetPrintout()->HasPage(currentPage - 1))
 368         {
 369             preview->SetCurrentPage(currentPage - 1);
 370         }
 371     }
 372 }
 373
 374 void wxPreviewControlBar::OnFirst(void)
 375 {
 376     wxPrintPreviewBase *preview = GetPrintPreview();
 377     if (preview)
 378     {
 379         int currentPage = preview->GetMinPage();
 380         if (preview->GetPrintout()->HasPage(currentPage))
 381         {
 382             preview->SetCurrentPage(currentPage);
 383         }
 384     }
 385 }
 386
 387 void wxPreviewControlBar::OnLast(void)
 388 {
 389     wxPrintPreviewBase *preview = GetPrintPreview();
 390     if (preview)
 391     {
 392         int currentPage = preview->GetMaxPage();
 393         if (preview->GetPrintout()->HasPage(currentPage))
 394         {
 395             preview->SetCurrentPage(currentPage);
 396         }
 397     }
 398 }
 399
 400 void wxPreviewControlBar::OnGoto(void)
 401 {
 402     wxPrintPreviewBase *preview = GetPrintPreview();
 403     if (preview)
 404     {
 405         long currentPage;
 406
 407         if (preview->GetMinPage() > 0)
 408         {
 409             wxString strPrompt;
 410             wxString strPage;
 411
 412             strPrompt.Printf( _("Enter a page number between %d and %d:"),
 413                 preview->GetMinPage(), preview->GetMaxPage());
 414             strPage.Printf( wxT("%d"), preview->GetCurrentPage() );
 415
 416             strPage =
 417                 wxGetTextFromUser( strPrompt, _("Goto Page"), strPage, GetParent());
 418
 419             if ( strPage.ToLong( &currentPage ) )
 420                 if (preview->GetPrintout()->HasPage(currentPage))
 421                 {
 422                     preview->SetCurrentPage(currentPage);
 423                 }
 424         }
 425     }
 426 }
 427
 428 void wxPreviewControlBar::OnZoom(wxCommandEvent& WXUNUSED(event))
 429 {
 430     int zoom = GetZoomControl();
 431     if (GetPrintPreview())
 432         GetPrintPreview()->SetZoom(zoom);
 433 }
 434
 435 void wxPreviewControlBar::CreateButtons()
 436 {
 437     SetSize(0, 0, 400, 40);
 438
 439     wxBoxSizer *item0 = new wxBoxSizer( wxHORIZONTAL );
 440
 441     int smallButtonWidth = 45;
 442
 443     m_closeButton = new wxButton( this, wxID_PREVIEW_CLOSE, _("&Close"), wxDefaultPosition, wxDefaultSize, 0 );
 444     item0->Add( m_closeButton, 0, wxALIGN_CENTRE|wxALL, 5 );
 445
 446     if (m_buttonFlags & wxPREVIEW_PRINT)
 447     {
 448         m_printButton = new wxButton( this, wxID_PREVIEW_PRINT, _("&Print..."), wxDefaultPosition, wxDefaultSize, 0 );
 449         item0->Add( m_printButton, 0, wxALIGN_CENTRE|wxALL, 5 );
 450     }
 451
 452     if (m_buttonFlags & wxPREVIEW_FIRST)
 453     {
 454         m_firstPageButton = new wxButton( this, wxID_PREVIEW_FIRST, _("|<<"), wxDefaultPosition, wxSize(smallButtonWidth,-1), 0 );
 455         item0->Add( m_firstPageButton, 0, wxALIGN_CENTRE|wxALL, 5 );
 456     }
 457
 458     if (m_buttonFlags & wxPREVIEW_PREVIOUS)
 459     {
 460         m_previousPageButton = new wxButton( this, wxID_PREVIEW_PREVIOUS, _("<<"), wxDefaultPosition, wxSize(smallButtonWidth,-1), 0 );
 461         item0->Add( m_previousPageButton, 0, wxALIGN_CENTRE|wxRIGHT|wxTOP|wxBOTTOM, 5 );
 462     }
 463
 464     if (m_buttonFlags & wxPREVIEW_NEXT)
 465     {
 466         m_nextPageButton = new wxButton( this, wxID_PREVIEW_NEXT, _(">>"), wxDefaultPosition, wxSize(smallButtonWidth,-1), 0 );
 467         item0->Add( m_nextPageButton, 0, wxALIGN_CENTRE|wxRIGHT|wxTOP|wxBOTTOM, 5 );
 468     }
 469
 470     if (m_buttonFlags & wxPREVIEW_LAST)
 471     {
 472         m_lastPageButton = new wxButton( this, wxID_PREVIEW_LAST, _(">>|"), wxDefaultPosition, wxSize(smallButtonWidth,-1), 0 );
 473         item0->Add( m_lastPageButton, 0, wxALIGN_CENTRE|wxRIGHT|wxTOP|wxBOTTOM, 5 );
 474     }
 475
 476     if (m_buttonFlags & wxPREVIEW_GOTO)
 477     {
 478         m_gotoPageButton = new wxButton( this, wxID_PREVIEW_GOTO, _("&Goto..."), wxDefaultPosition, wxDefaultSize, 0 );
 479         item0->Add( m_gotoPageButton, 0, wxALIGN_CENTRE|wxALL, 5 );
 480     }
 481
 482     if (m_buttonFlags & wxPREVIEW_ZOOM)
 483     {
 484         wxString choices[] =
 485         {
 486             wxT("10%"), wxT("15%"), wxT("20%"), wxT("25%"), wxT("30%"), wxT("35%"), wxT("40%"), wxT("45%"), wxT("50%"), wxT("55%"),
 487                 wxT("60%"), wxT("65%"), wxT("70%"), wxT("75%"), wxT("80%"), wxT("85%"), wxT("90%"), wxT("95%"), wxT("100%"), wxT("110%"),
 488                 wxT("120%"), wxT("150%"), wxT("200%")
 489         };
 490         int n = WXSIZEOF(choices);
 491
 492         m_zoomControl = new wxChoice( this, wxID_PREVIEW_ZOOM, wxDefaultPosition, wxSize(70,-1), n, choices, 0 );
 493         item0->Add( m_zoomControl, 0, wxALIGN_CENTRE|wxALL, 5 );
 494         SetZoomControl(m_printPreview->GetZoom());
 495     }
 496
 497     SetSizer(item0);
 498     item0->Fit(this);
 499 }
 500
 501 void wxPreviewControlBar::SetZoomControl(int zoom)
 502 {
 503     if (m_zoomControl)
 504     {
 505         int n, count = m_zoomControl->GetCount();
 506         long val;
 507         for (n=0; n<count; n++)
 508         {
 509             if (m_zoomControl->GetString(n).BeforeFirst(wxT('%')).ToLong(&val) &&
 510                 (val >= long(zoom)))
 511             {
 512                 m_zoomControl->SetSelection(n);
 513                 return;
 514             }
 515         }
 516
 517         m_zoomControl->SetSelection(count-1);
 518     }
 519 }
 520
 521 int wxPreviewControlBar::GetZoomControl()
 522 {
 523     if (m_zoomControl && (m_zoomControl->GetStringSelection() != wxEmptyString))
 524     {
 525         long val;
 526         if (m_zoomControl->GetStringSelection().BeforeFirst(wxT('%')).ToLong(&val))
 527             return int(val);
 528     }
 529
 530     return 0;
 531 }
 532
 533
 534 /*
 535 * Preview frame
 536 */
 537
 538 BEGIN_EVENT_TABLE(wxPreviewFrame, wxFrame)
 539     EVT_CLOSE(wxPreviewFrame::OnCloseWindow)
 540 END_EVENT_TABLE()
 541
 542 wxPreviewFrame::wxPreviewFrame(wxPrintPreviewBase *preview, wxWindow *parent, const wxString& title,
 543                                const wxPoint& pos, const wxSize& size, long style, const wxString& name):
 544 wxFrame(parent, -1, title, pos, size, style, name)
 545 {
 546     m_printPreview = preview;
 547     m_controlBar = NULL;
 548     m_previewCanvas = NULL;
 549
 550     // Give the application icon
 551 #ifdef __WXMSW__
 552     wxFrame* topFrame = wxDynamicCast(wxTheApp->GetTopWindow(), wxFrame);
 553     if (topFrame)
 554         SetIcon(topFrame->GetIcon());
 555 #endif
 556 }
 557
 558 wxPreviewFrame::~wxPreviewFrame()
 559 {
 560 }
 561
 562 void wxPreviewFrame::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
 563 {
 564     // MakeModal doesn't work on wxMac, especially when there
 565     // are multiple top-level windows.
 566 #ifndef __WXMAC__
 567     MakeModal(FALSE);
 568 #endif
 569
 570     // Need to delete the printout and the print preview
 571     wxPrintout *printout = m_printPreview->GetPrintout();
 572     if (printout)
 573     {
 574         delete printout;
 575         m_printPreview->SetPrintout(NULL);
 576         m_printPreview->SetCanvas(NULL);
 577         m_printPreview->SetFrame(NULL);
 578     }
 579     delete m_printPreview;
 580
 581     Destroy();
 582 }
 583
 584 void wxPreviewFrame::Initialize()
 585 {
 586 #if wxUSE_STATUSBAR
 587     CreateStatusBar();
 588 #endif
 589     CreateCanvas();
 590     CreateControlBar();
 591
 592     m_printPreview->SetCanvas(m_previewCanvas);
 593     m_printPreview->SetFrame(this);
 594
 595     wxBoxSizer *item0 = new wxBoxSizer( wxVERTICAL );
 596
 597     item0->Add( m_controlBar, 0, wxGROW|wxALIGN_CENTER_VERTICAL, 5 );
 598     item0->Add( m_previewCanvas, 1, wxGROW|wxALIGN_CENTER_VERTICAL, 5 );
 599
 600     SetAutoLayout( TRUE );
 601     SetSizer( item0 );
 602
 603     // MakeModal doesn't work on wxMac, especially when there
 604     // are multiple top-level windows.
 605 #ifndef __WXMAC__
 606     MakeModal(TRUE);
 607 #endif
 608
 609     Layout();
 610
 611     m_printPreview->AdjustScrollbars(m_previewCanvas);
 612     m_previewCanvas->SetFocus();
 613     m_controlBar->SetFocus();
 614 }
 615
 616 void wxPreviewFrame::CreateCanvas()
 617 {
 618     m_previewCanvas = new wxPreviewCanvas(m_printPreview, this);
 619 }
 620
 621 void wxPreviewFrame::CreateControlBar()
 622 {
 623     long buttons = wxPREVIEW_DEFAULT;
 624     if (m_printPreview->GetPrintoutForPrinting())
 625         buttons |= wxPREVIEW_PRINT;
 626
 627     m_controlBar = new wxPreviewControlBar(m_printPreview, buttons, this, wxPoint(0, 0), wxSize(400, 40));
 628     m_controlBar->CreateButtons();
 629 }
 630
 631 /*
 632 * Print preview
 633 */
 634
 635 wxPrintPreviewBase::wxPrintPreviewBase(wxPrintout *printout,
 636                                        wxPrintout *printoutForPrinting,
 637                                        wxPrintData *data)
 638 {
 639     if (data)
 640         m_printDialogData = (*data);
 641
 642     Init(printout, printoutForPrinting);
 643 }
 644
 645 wxPrintPreviewBase::wxPrintPreviewBase(wxPrintout *printout,
 646                                        wxPrintout *printoutForPrinting,
 647                                        wxPrintDialogData *data)
 648 {
 649     if (data)
 650         m_printDialogData = (*data);
 651
 652     Init(printout, printoutForPrinting);
 653 }
 654
 655 void wxPrintPreviewBase::Init(wxPrintout *printout,
 656                               wxPrintout *printoutForPrinting)
 657 {
 658     m_isOk = TRUE;
 659     m_previewPrintout = printout;
 660     if (m_previewPrintout)
 661         m_previewPrintout->SetIsPreview(TRUE);
 662
 663     m_printPrintout = printoutForPrinting;
 664
 665     m_previewCanvas = NULL;
 666     m_previewFrame = NULL;
 667     m_previewBitmap = NULL;
 668     m_currentPage = 1;
 669     m_currentZoom = 70;
 670     m_topMargin = 40;
 671     m_leftMargin = 40;
 672     m_pageWidth = 0;
 673     m_pageHeight = 0;
 674     m_printingPrepared = FALSE;
 675     m_minPage = 1;
 676     m_maxPage = 1;
 677 }
 678
 679 wxPrintPreviewBase::~wxPrintPreviewBase()
 680 {
 681     if (m_previewPrintout)
 682         delete m_previewPrintout;
 683     if (m_previewBitmap)
 684         delete m_previewBitmap;
 685     if (m_printPrintout)
 686         delete m_printPrintout;
 687 }
 688
 689 bool wxPrintPreviewBase::SetCurrentPage(int pageNum)
 690 {
 691     if (m_currentPage == pageNum)
 692         return TRUE;
 693
 694     m_currentPage = pageNum;
 695     if (m_previewBitmap)
 696     {
 697         delete m_previewBitmap;
 698         m_previewBitmap = NULL;
 699     }
 700
 701     if (m_previewCanvas)
 702     {
 703         AdjustScrollbars(m_previewCanvas);
 704
 705         if (!RenderPage(pageNum))
 706             return FALSE;
 707         m_previewCanvas->Refresh();
 708         m_previewCanvas->SetFocus();
 709     }
 710     return TRUE;
 711 }
 712
 713 bool wxPrintPreviewBase::PaintPage(wxPreviewCanvas *canvas, wxDC& dc)
 714 {
 715     DrawBlankPage(canvas, dc);
 716
 717     if (!m_previewBitmap)
 718         if (!RenderPage(m_currentPage))
 719             return FALSE;
 720
 721     if (!m_previewBitmap)
 722         return FALSE;
 723
 724     if (!canvas)
 725         return FALSE;
 726
 727     int canvasWidth, canvasHeight;
 728     canvas->GetSize(&canvasWidth, &canvasHeight);
 729
 730     double zoomScale = ((float)m_currentZoom/(float)100);
 731     double actualWidth = (zoomScale*m_pageWidth*m_previewScale);
 732     //  float actualHeight = (float)(zoomScale*m_pageHeight*m_previewScale);
 733
 734     int x = (int) ((canvasWidth - actualWidth)/2.0);
 735     if (x < m_leftMargin)
 736         x = m_leftMargin;
 737     int y = m_topMargin;
 738
 739     wxMemoryDC temp_dc;
 740     temp_dc.SelectObject(*m_previewBitmap);
 741
 742     dc.Blit(x, y, m_previewBitmap->GetWidth(), m_previewBitmap->GetHeight(), &temp_dc, 0, 0);
 743
 744     temp_dc.SelectObject(wxNullBitmap);
 745
 746     return TRUE;
 747 }
 748
 749 // Adjusts the scrollbars for the current scale
 750 void wxPrintPreviewBase::AdjustScrollbars(wxPreviewCanvas *canvas)
 751 {
 752     if (!canvas)
 753         return ;
 754
 755     int canvasWidth, canvasHeight;
 756     canvas->GetSize(&canvasWidth, &canvasHeight);
 757
 758     double zoomScale = ((float)m_currentZoom/(float)100);
 759     double actualWidth = (zoomScale*m_pageWidth*m_previewScale);
 760     double actualHeight = (zoomScale*m_pageHeight*m_previewScale);
 761
 762     // Set the scrollbars appropriately
 763     int totalWidth = (int)(actualWidth + 2*m_leftMargin);
 764     int totalHeight = (int)(actualHeight + 2*m_topMargin);
 765     int scrollUnitsX = totalWidth/10;
 766     int scrollUnitsY = totalHeight/10;
 767     wxSize virtualSize = canvas->GetVirtualSize();
 768     if (virtualSize.GetWidth() != totalWidth || virtualSize.GetHeight() != totalHeight)
 769         canvas->SetScrollbars(10, 10, scrollUnitsX, scrollUnitsY, 0, 0, TRUE);
 770 }
 771
 772 bool wxPrintPreviewBase::RenderPage(int pageNum)
 773 {
 774     wxBusyCursor busy;
 775
 776     int canvasWidth, canvasHeight;
 777
 778     if (!m_previewCanvas)
 779     {
 780         wxFAIL_MSG(_T("wxPrintPreviewBase::RenderPage: must use wxPrintPreviewBase::SetCanvas to let me know about the canvas!"));
 781
 782         return FALSE;
 783     }
 784     m_previewCanvas->GetSize(&canvasWidth, &canvasHeight);
 785
 786     double zoomScale = (m_currentZoom/100.0);
 787     int actualWidth = (int)(zoomScale*m_pageWidth*m_previewScale);
 788     int actualHeight = (int)(zoomScale*m_pageHeight*m_previewScale);
 789
 790     if (!m_previewBitmap)
 791     {
 792         m_previewBitmap = new wxBitmap((int)actualWidth, (int)actualHeight);
 793         if (!m_previewBitmap || !m_previewBitmap->Ok())
 794         {
 795             if (m_previewBitmap) {
 796                 delete m_previewBitmap;
 797                 m_previewBitmap = NULL;
 798             }
 799             wxMessageBox(_("Sorry, not enough memory to create a preview."), _("Print Preview Failure"), wxOK);
 800             return FALSE;
 801         }
 802     }
 803
 804     wxMemoryDC memoryDC;
 805     memoryDC.SelectObject(*m_previewBitmap);
 806
 807     memoryDC.Clear();
 808
 809     m_previewPrintout->SetDC(&memoryDC);
 810     m_previewPrintout->SetPageSizePixels(m_pageWidth, m_pageHeight);
 811
 812     // Need to delay OnPreparePrinting until here, so we have enough information.
 813     if (!m_printingPrepared)
 814     {
 815         m_previewPrintout->OnPreparePrinting();
 816         int selFrom, selTo;
 817         m_previewPrintout->GetPageInfo(&m_minPage, &m_maxPage, &selFrom, &selTo);
 818         m_printingPrepared = TRUE;
 819     }
 820
 821     m_previewPrintout->OnBeginPrinting();
 822
 823     if (!m_previewPrintout->OnBeginDocument(m_printDialogData.GetFromPage(), m_printDialogData.GetToPage()))
 824     {
 825         wxMessageBox(_("Could not start document preview."), _("Print Preview Failure"), wxOK);
 826
 827         memoryDC.SelectObject(wxNullBitmap);
 828
 829         delete m_previewBitmap;
 830         m_previewBitmap = NULL;
 831         return FALSE;
 832     }
 833
 834     m_previewPrintout->OnPrintPage(pageNum);
 835     m_previewPrintout->OnEndDocument();
 836     m_previewPrintout->OnEndPrinting();
 837
 838     m_previewPrintout->SetDC(NULL);
 839
 840     memoryDC.SelectObject(wxNullBitmap);
 841
 842 #if wxUSE_STATUSBAR
 843     wxString status;
 844     if (m_maxPage != 0)
 845                 status = wxString::Format(_("Page %d of %d"), pageNum, m_maxPage);
 846     else
 847                 status = wxString::Format(_("Page %d"), pageNum);
 848
 849     if (m_previewFrame)
 850         m_previewFrame->SetStatusText(status);
 851 #endif
 852
 853     return TRUE;
 854 }
 855
 856
 857 bool wxPrintPreviewBase::DrawBlankPage(wxPreviewCanvas *canvas, wxDC& dc)
 858 {
 859     int canvasWidth, canvasHeight;
 860     canvas->GetSize(&canvasWidth, &canvasHeight);
 861
 862     float zoomScale = (float)((float)m_currentZoom/(float)100);
 863     float actualWidth = zoomScale*m_pageWidth*m_previewScale;
 864     float actualHeight = zoomScale*m_pageHeight*m_previewScale;
 865
 866     float x = (float)((canvasWidth - actualWidth)/2.0);
 867     if (x < m_leftMargin)
 868         x = (float)m_leftMargin;
 869     float y = (float)m_topMargin;
 870
 871     // Draw shadow, allowing for 1-pixel border AROUND the actual page
 872     int shadowOffset = 4;
 873     dc.SetPen(*wxBLACK_PEN);
 874     dc.SetBrush(*wxBLACK_BRUSH);
 875     /*
 876     dc.DrawRectangle((int)(x-1 + shadowOffset), (int)(y-1 + shadowOffset), (int)(actualWidth+2), (int)(actualHeight+2));
 877     */
 878     dc.DrawRectangle((int)(x + shadowOffset), (int)(y + actualHeight+1), (int)(actualWidth), shadowOffset);
 879     dc.DrawRectangle((int)(x + actualWidth), (int)(y + shadowOffset), shadowOffset, (int)(actualHeight));
 880
 881     // Draw blank page allowing for 1-pixel border AROUND the actual page
 882     dc.SetPen(*wxBLACK_PEN);
 883     dc.SetBrush(*wxWHITE_BRUSH);
 884
 885     /*
 886     wxRegion update_region = canvas->GetUpdateRegion();
 887     wxRect r = update_region.GetBox();
 888
 889       printf( "x: %d y: %d w: %d h: %d.\n", (int)r.x, (int)r.y, (int)r.width, (int)r.height );
 890     */
 891
 892     dc.DrawRectangle((int)(x-2), (int)(y-1), (int)(actualWidth+3), (int)(actualHeight+2));
 893
 894     return TRUE;
 895 }
 896
 897 void wxPrintPreviewBase::SetZoom(int percent)
 898 {
 899     if (m_currentZoom == percent)
 900         return;
 901
 902     m_currentZoom = percent;
 903     if (m_previewBitmap)
 904     {
 905         delete m_previewBitmap;
 906         m_previewBitmap = NULL;
 907     }
 908
 909     if (m_previewCanvas)
 910     {
 911         AdjustScrollbars(m_previewCanvas);
 912         RenderPage(m_currentPage);
 913         ((wxScrolledWindow *) m_previewCanvas)->Scroll(0, 0);
 914         m_previewCanvas->ClearBackground();
 915         m_previewCanvas->Refresh();
 916         m_previewCanvas->SetFocus();
 917     }
 918 }
 919
 920 #endif // wxUSE_PRINTING_ARCHITECTURE