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