]> git.saurik.com Git - wxWidgets.git/blob - src/common/prntbase.cpp
projects / wxWidgets.git / blob
? search:


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