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


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