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