include/wx/prntbase.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/prntbase.h
   3 // Purpose:     Base classes for printing framework
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     01/02/97
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifndef _WX_PRNTBASEH__
  13 #define _WX_PRNTBASEH__
  14
  15 #include "wx/defs.h"
  16
  17 #if wxUSE_PRINTING_ARCHITECTURE
  18
  19 #include "wx/event.h"
  20 #include "wx/cmndata.h"
  21 #include "wx/panel.h"
  22 #include "wx/scrolwin.h"
  23 #include "wx/dialog.h"
  24 #include "wx/frame.h"
  25
  26 class WXDLLIMPEXP_FWD_CORE wxDC;
  27 class WXDLLIMPEXP_FWD_CORE wxButton;
  28 class WXDLLIMPEXP_FWD_CORE wxChoice;
  29 class WXDLLIMPEXP_FWD_CORE wxPrintout;
  30 class WXDLLIMPEXP_FWD_CORE wxPrinterBase;
  31 class WXDLLIMPEXP_FWD_CORE wxPrintDialogBase;
  32 class WXDLLIMPEXP_FWD_CORE wxPrintDialog;
  33 class WXDLLIMPEXP_FWD_CORE wxPageSetupDialogBase;
  34 class WXDLLIMPEXP_FWD_CORE wxPageSetupDialog;
  35 class WXDLLIMPEXP_FWD_CORE wxPrintPreviewBase;
  36 class WXDLLIMPEXP_FWD_CORE wxPreviewCanvas;
  37 class WXDLLIMPEXP_FWD_CORE wxPreviewControlBar;
  38 class WXDLLIMPEXP_FWD_CORE wxPreviewFrame;
  39 class WXDLLIMPEXP_FWD_CORE wxPrintFactory;
  40 class WXDLLIMPEXP_FWD_CORE wxPrintNativeDataBase;
  41
  42 //----------------------------------------------------------------------------
  43 // error consts
  44 //----------------------------------------------------------------------------
  45
  46 enum wxPrinterError
  47 {
  48     wxPRINTER_NO_ERROR = 0,
  49     wxPRINTER_CANCELLED,
  50     wxPRINTER_ERROR
  51 };
  52
  53 //----------------------------------------------------------------------------
  54 // wxPrintFactory
  55 //----------------------------------------------------------------------------
  56
  57 class WXDLLEXPORT wxPrintFactory
  58 {
  59 public:
  60     wxPrintFactory() {}
  61     virtual ~wxPrintFactory() {}
  62
  63     virtual wxPrinterBase *CreatePrinter( wxPrintDialogData* data ) = 0;
  64
  65     virtual wxPrintPreviewBase *CreatePrintPreview( wxPrintout *preview,
  66                                                     wxPrintout *printout = NULL,
  67                                                     wxPrintDialogData *data = NULL ) = 0;
  68     virtual wxPrintPreviewBase *CreatePrintPreview( wxPrintout *preview,
  69                                                     wxPrintout *printout,
  70                                                     wxPrintData *data ) = 0;
  71
  72     virtual wxPrintDialogBase *CreatePrintDialog( wxWindow *parent,
  73                                                   wxPrintDialogData *data = NULL ) = 0;
  74     virtual wxPrintDialogBase *CreatePrintDialog( wxWindow *parent,
  75                                                   wxPrintData *data ) = 0;
  76
  77     virtual wxPageSetupDialogBase *CreatePageSetupDialog( wxWindow *parent,
  78                                                           wxPageSetupDialogData * data = NULL ) = 0;
  79
  80     virtual wxDC* CreatePrinterDC( const wxPrintData& data ) = 0;
  81
  82     // What to do and what to show in the wxPrintDialog
  83     // a) Use the generic print setup dialog or a native one?
  84     virtual bool HasPrintSetupDialog() = 0;
  85     virtual wxDialog *CreatePrintSetupDialog( wxWindow *parent, wxPrintData *data ) = 0;
  86     // b) Provide the "print to file" option ourselves or via print setup?
  87     virtual bool HasOwnPrintToFile() = 0;
  88     // c) Show current printer
  89     virtual bool HasPrinterLine() = 0;
  90     virtual wxString CreatePrinterLine() = 0;
  91     // d) Show Status line for current printer?
  92     virtual bool HasStatusLine() = 0;
  93     virtual wxString CreateStatusLine() = 0;
  94
  95
  96     virtual wxPrintNativeDataBase *CreatePrintNativeData() = 0;
  97
  98     static void SetPrintFactory( wxPrintFactory *factory );
  99     static wxPrintFactory *GetFactory();
 100 private:
 101     static wxPrintFactory *m_factory;
 102 };
 103
 104 class WXDLLEXPORT wxNativePrintFactory: public wxPrintFactory
 105 {
 106 public:
 107     virtual wxPrinterBase *CreatePrinter( wxPrintDialogData *data );
 108
 109     virtual wxPrintPreviewBase *CreatePrintPreview( wxPrintout *preview,
 110                                                     wxPrintout *printout = NULL,
 111                                                     wxPrintDialogData *data = NULL );
 112     virtual wxPrintPreviewBase *CreatePrintPreview( wxPrintout *preview,
 113                                                     wxPrintout *printout,
 114                                                     wxPrintData *data );
 115
 116     virtual wxPrintDialogBase *CreatePrintDialog( wxWindow *parent,
 117                                                   wxPrintDialogData *data = NULL );
 118     virtual wxPrintDialogBase *CreatePrintDialog( wxWindow *parent,
 119                                                   wxPrintData *data );
 120
 121     virtual wxPageSetupDialogBase *CreatePageSetupDialog( wxWindow *parent,
 122                                                           wxPageSetupDialogData * data = NULL );
 123
 124     virtual wxDC* CreatePrinterDC( const wxPrintData& data );
 125
 126     virtual bool HasPrintSetupDialog();
 127     virtual wxDialog *CreatePrintSetupDialog( wxWindow *parent, wxPrintData *data );
 128     virtual bool HasOwnPrintToFile();
 129     virtual bool HasPrinterLine();
 130     virtual wxString CreatePrinterLine();
 131     virtual bool HasStatusLine();
 132     virtual wxString CreateStatusLine();
 133
 134     virtual wxPrintNativeDataBase *CreatePrintNativeData();
 135 };
 136
 137 //----------------------------------------------------------------------------
 138 // wxPrintNativeDataBase
 139 //----------------------------------------------------------------------------
 140
 141 class WXDLLEXPORT wxPrintNativeDataBase: public wxObject
 142 {
 143 public:
 144     wxPrintNativeDataBase();
 145     virtual ~wxPrintNativeDataBase() {}
 146
 147     virtual bool TransferTo( wxPrintData &data ) = 0;
 148     virtual bool TransferFrom( const wxPrintData &data ) = 0;
 149
 150     virtual bool Ok() const { return IsOk(); }
 151     virtual bool IsOk() const = 0;
 152
 153     int  m_ref;
 154
 155 private:
 156     DECLARE_CLASS(wxPrintNativeDataBase)
 157     DECLARE_NO_COPY_CLASS(wxPrintNativeDataBase)
 158 };
 159
 160 //----------------------------------------------------------------------------
 161 // wxPrinterBase
 162 //----------------------------------------------------------------------------
 163
 164 /*
 165  * Represents the printer: manages printing a wxPrintout object
 166  */
 167
 168 class WXDLLEXPORT wxPrinterBase: public wxObject
 169 {
 170 public:
 171     wxPrinterBase(wxPrintDialogData *data = (wxPrintDialogData *) NULL);
 172     virtual ~wxPrinterBase();
 173
 174     virtual wxWindow *CreateAbortWindow(wxWindow *parent, wxPrintout *printout);
 175     virtual void ReportError(wxWindow *parent, wxPrintout *printout, const wxString& message);
 176
 177     virtual wxPrintDialogData& GetPrintDialogData() const;
 178     bool GetAbort() const { return sm_abortIt; }
 179
 180     static wxPrinterError GetLastError() { return sm_lastError; }
 181
 182     ///////////////////////////////////////////////////////////////////////////
 183     // OVERRIDES
 184
 185     virtual bool Setup(wxWindow *parent) = 0;
 186     virtual bool Print(wxWindow *parent, wxPrintout *printout, bool prompt = true) = 0;
 187     virtual wxDC* PrintDialog(wxWindow *parent) = 0;
 188
 189 protected:
 190     wxPrintDialogData     m_printDialogData;
 191     wxPrintout*           m_currentPrintout;
 192
 193     static wxPrinterError sm_lastError;
 194
 195 public:
 196     static wxWindow*      sm_abortWindow;
 197     static bool           sm_abortIt;
 198
 199 private:
 200     DECLARE_CLASS(wxPrinterBase)
 201     DECLARE_NO_COPY_CLASS(wxPrinterBase)
 202 };
 203
 204 //----------------------------------------------------------------------------
 205 // wxPrinter
 206 //----------------------------------------------------------------------------
 207
 208 class WXDLLEXPORT wxPrinter: public wxPrinterBase
 209 {
 210 public:
 211     wxPrinter(wxPrintDialogData *data = (wxPrintDialogData *) NULL);
 212     virtual ~wxPrinter();
 213
 214     virtual wxWindow *CreateAbortWindow(wxWindow *parent, wxPrintout *printout);
 215     virtual void ReportError(wxWindow *parent, wxPrintout *printout, const wxString& message);
 216
 217     virtual bool Setup(wxWindow *parent);
 218     virtual bool Print(wxWindow *parent, wxPrintout *printout, bool prompt = true);
 219     virtual wxDC* PrintDialog(wxWindow *parent);
 220
 221     virtual wxPrintDialogData& GetPrintDialogData() const;
 222
 223 protected:
 224     wxPrinterBase    *m_pimpl;
 225
 226 private:
 227     DECLARE_CLASS(wxPrinter)
 228     DECLARE_NO_COPY_CLASS(wxPrinter)
 229 };
 230
 231 //----------------------------------------------------------------------------
 232 // wxPrintout
 233 //----------------------------------------------------------------------------
 234
 235 /*
 236  * Represents an object via which a document may be printed.
 237  * The programmer derives from this, overrides (at least) OnPrintPage,
 238  * and passes it to a wxPrinter object for printing, or a wxPrintPreview
 239  * object for previewing.
 240  */
 241
 242 class WXDLLEXPORT wxPrintout: public wxObject
 243 {
 244 public:
 245     wxPrintout(const wxString& title = wxT("Printout"));
 246     virtual ~wxPrintout();
 247
 248     virtual bool OnBeginDocument(int startPage, int endPage);
 249     virtual void OnEndDocument();
 250     virtual void OnBeginPrinting();
 251     virtual void OnEndPrinting();
 252
 253     // Guaranteed to be before any other functions are called
 254     virtual void OnPreparePrinting() { }
 255
 256     virtual bool HasPage(int page);
 257     virtual bool OnPrintPage(int page) = 0;
 258     virtual void GetPageInfo(int *minPage, int *maxPage, int *pageFrom, int *pageTo);
 259
 260     virtual wxString GetTitle() const { return m_printoutTitle; }
 261
 262     wxDC *GetDC() const { return m_printoutDC; }
 263     void SetDC(wxDC *dc) { m_printoutDC = dc; }
 264
 265     void FitThisSizeToPaper(const wxSize& imageSize);
 266     void FitThisSizeToPage(const wxSize& imageSize);
 267     void FitThisSizeToPageMargins(const wxSize& imageSize, const wxPageSetupDialogData& pageSetupData);
 268     void MapScreenSizeToPaper();
 269     void MapScreenSizeToPage();
 270     void MapScreenSizeToPageMargins(const wxPageSetupDialogData& pageSetupData);
 271     void MapScreenSizeToDevice();
 272
 273     wxRect GetLogicalPaperRect() const;
 274     wxRect GetLogicalPageRect() const;
 275     wxRect GetLogicalPageMarginsRect(const wxPageSetupDialogData& pageSetupData) const;
 276
 277     void SetLogicalOrigin(wxCoord x, wxCoord y);
 278     void OffsetLogicalOrigin(wxCoord xoff, wxCoord yoff);
 279
 280     void SetPageSizePixels(int w, int  h) { m_pageWidthPixels = w; m_pageHeightPixels = h; }
 281     void GetPageSizePixels(int *w, int  *h) const { *w = m_pageWidthPixels; *h = m_pageHeightPixels; }
 282     void SetPageSizeMM(int w, int  h) { m_pageWidthMM = w; m_pageHeightMM = h; }
 283     void GetPageSizeMM(int *w, int  *h) const { *w = m_pageWidthMM; *h = m_pageHeightMM; }
 284
 285     void SetPPIScreen(int x, int y) { m_PPIScreenX = x; m_PPIScreenY = y; }
 286     void GetPPIScreen(int *x, int *y) const { *x = m_PPIScreenX; *y = m_PPIScreenY; }
 287     void SetPPIPrinter(int x, int y) { m_PPIPrinterX = x; m_PPIPrinterY = y; }
 288     void GetPPIPrinter(int *x, int *y) const { *x = m_PPIPrinterX; *y = m_PPIPrinterY; }
 289
 290     void SetPaperRectPixels(const wxRect& paperRectPixels) { m_paperRectPixels = paperRectPixels; }
 291     wxRect GetPaperRectPixels() const { return m_paperRectPixels; }
 292
 293     virtual bool IsPreview() const { return m_isPreview; }
 294
 295     virtual void SetIsPreview(bool p) { m_isPreview = p; }
 296
 297 private:
 298     wxString         m_printoutTitle;
 299     wxDC*            m_printoutDC;
 300
 301     int              m_pageWidthPixels;
 302     int              m_pageHeightPixels;
 303
 304     int              m_pageWidthMM;
 305     int              m_pageHeightMM;
 306
 307     int              m_PPIScreenX;
 308     int              m_PPIScreenY;
 309     int              m_PPIPrinterX;
 310     int              m_PPIPrinterY;
 311
 312     wxRect           m_paperRectPixels;
 313
 314     bool             m_isPreview;
 315
 316 private:
 317     DECLARE_ABSTRACT_CLASS(wxPrintout)
 318     DECLARE_NO_COPY_CLASS(wxPrintout)
 319 };
 320
 321 //----------------------------------------------------------------------------
 322 // wxPreviewCanvas
 323 //----------------------------------------------------------------------------
 324
 325 /*
 326  * Canvas upon which a preview is drawn.
 327  */
 328
 329 class WXDLLEXPORT wxPreviewCanvas: public wxScrolledWindow
 330 {
 331 public:
 332     wxPreviewCanvas(wxPrintPreviewBase *preview,
 333                     wxWindow *parent,
 334                     const wxPoint& pos = wxDefaultPosition,
 335                     const wxSize& size = wxDefaultSize,
 336                     long style = 0,
 337                     const wxString& name = wxT("canvas"));
 338     virtual ~wxPreviewCanvas();
 339
 340     void OnPaint(wxPaintEvent& event);
 341     void OnChar(wxKeyEvent &event);
 342     // Responds to colour changes
 343     void OnSysColourChanged(wxSysColourChangedEvent& event);
 344
 345 private:
 346 #if wxUSE_MOUSEWHEEL
 347     void OnMouseWheel(wxMouseEvent& event);
 348 #endif // wxUSE_MOUSEWHEEL
 349
 350     wxPrintPreviewBase* m_printPreview;
 351
 352     DECLARE_CLASS(wxPreviewCanvas)
 353     DECLARE_EVENT_TABLE()
 354     DECLARE_NO_COPY_CLASS(wxPreviewCanvas)
 355 };
 356
 357 //----------------------------------------------------------------------------
 358 // wxPreviewFrame
 359 //----------------------------------------------------------------------------
 360
 361 /*
 362  * Default frame for showing preview.
 363  */
 364
 365 class WXDLLEXPORT wxPreviewFrame: public wxFrame
 366 {
 367 public:
 368     wxPreviewFrame(wxPrintPreviewBase *preview,
 369                    wxWindow *parent,
 370                    const wxString& title = wxT("Print Preview"),
 371                    const wxPoint& pos = wxDefaultPosition,
 372                    const wxSize& size = wxDefaultSize,
 373                    long style = wxDEFAULT_FRAME_STYLE,
 374                    const wxString& name = wxT("frame"));
 375     virtual ~wxPreviewFrame();
 376
 377     void OnCloseWindow(wxCloseEvent& event);
 378     virtual void Initialize();
 379     virtual void CreateCanvas();
 380     virtual void CreateControlBar();
 381
 382     inline wxPreviewControlBar* GetControlBar() const { return m_controlBar; }
 383
 384 protected:
 385     wxPreviewCanvas*      m_previewCanvas;
 386     wxPreviewControlBar*  m_controlBar;
 387     wxPrintPreviewBase*   m_printPreview;
 388     wxWindowDisabler*     m_windowDisabler;
 389
 390 private:
 391     void OnChar(wxKeyEvent& event);
 392
 393     DECLARE_EVENT_TABLE()
 394     DECLARE_CLASS(wxPreviewFrame)
 395     DECLARE_NO_COPY_CLASS(wxPreviewFrame)
 396 };
 397
 398 //----------------------------------------------------------------------------
 399 // wxPreviewControlBar
 400 //----------------------------------------------------------------------------
 401
 402 /*
 403  * A panel with buttons for controlling a print preview.
 404  * The programmer may wish to use other means for controlling
 405  * the print preview.
 406  */
 407
 408 #define wxPREVIEW_PRINT        1
 409 #define wxPREVIEW_PREVIOUS     2
 410 #define wxPREVIEW_NEXT         4
 411 #define wxPREVIEW_ZOOM         8
 412 #define wxPREVIEW_FIRST       16
 413 #define wxPREVIEW_LAST        32
 414 #define wxPREVIEW_GOTO        64
 415
 416 #define wxPREVIEW_DEFAULT  (wxPREVIEW_PREVIOUS|wxPREVIEW_NEXT|wxPREVIEW_ZOOM\
 417                             |wxPREVIEW_FIRST|wxPREVIEW_GOTO|wxPREVIEW_LAST)
 418
 419 // Ids for controls
 420 #define wxID_PREVIEW_CLOSE      1
 421 #define wxID_PREVIEW_NEXT       2
 422 #define wxID_PREVIEW_PREVIOUS   3
 423 #define wxID_PREVIEW_PRINT      4
 424 #define wxID_PREVIEW_ZOOM       5
 425 #define wxID_PREVIEW_FIRST      6
 426 #define wxID_PREVIEW_LAST       7
 427 #define wxID_PREVIEW_GOTO       8
 428
 429 class WXDLLEXPORT wxPreviewControlBar: public wxPanel
 430 {
 431     DECLARE_CLASS(wxPreviewControlBar)
 432
 433 public:
 434     wxPreviewControlBar(wxPrintPreviewBase *preview,
 435                         long buttons,
 436                         wxWindow *parent,
 437                         const wxPoint& pos = wxDefaultPosition,
 438                         const wxSize& size = wxDefaultSize,
 439                         long style = wxTAB_TRAVERSAL,
 440                         const wxString& name = wxT("panel"));
 441     virtual ~wxPreviewControlBar();
 442
 443     virtual void CreateButtons();
 444     virtual void SetZoomControl(int zoom);
 445     virtual int GetZoomControl();
 446     virtual wxPrintPreviewBase *GetPrintPreview() const
 447         { return m_printPreview; }
 448
 449     void OnWindowClose(wxCommandEvent& event);
 450     void OnNext();
 451     void OnPrevious();
 452     void OnFirst();
 453     void OnLast();
 454     void OnGoto();
 455     void OnPrint();
 456     void OnPrintButton(wxCommandEvent& WXUNUSED(event)) { OnPrint(); }
 457     void OnNextButton(wxCommandEvent & WXUNUSED(event)) { OnNext(); }
 458     void OnPreviousButton(wxCommandEvent & WXUNUSED(event)) { OnPrevious(); }
 459     void OnFirstButton(wxCommandEvent & WXUNUSED(event)) { OnFirst(); }
 460     void OnLastButton(wxCommandEvent & WXUNUSED(event)) { OnLast(); }
 461     void OnGotoButton(wxCommandEvent & WXUNUSED(event)) { OnGoto(); }
 462     void OnZoom(wxCommandEvent& event);
 463     void OnPaint(wxPaintEvent& event);
 464
 465 protected:
 466     wxPrintPreviewBase*   m_printPreview;
 467     wxButton*             m_closeButton;
 468     wxButton*             m_nextPageButton;
 469     wxButton*             m_previousPageButton;
 470     wxButton*             m_printButton;
 471     wxChoice*             m_zoomControl;
 472     wxButton*             m_firstPageButton;
 473     wxButton*             m_lastPageButton;
 474     wxButton*             m_gotoPageButton;
 475     long                  m_buttonFlags;
 476
 477 private:
 478     DECLARE_EVENT_TABLE()
 479     DECLARE_NO_COPY_CLASS(wxPreviewControlBar)
 480 };
 481
 482 //----------------------------------------------------------------------------
 483 // wxPrintPreviewBase
 484 //----------------------------------------------------------------------------
 485
 486 /*
 487  * Programmer creates an object of this class to preview a wxPrintout.
 488  */
 489
 490 class WXDLLEXPORT wxPrintPreviewBase: public wxObject
 491 {
 492 public:
 493     wxPrintPreviewBase(wxPrintout *printout,
 494                        wxPrintout *printoutForPrinting = (wxPrintout *) NULL,
 495                        wxPrintDialogData *data = (wxPrintDialogData *) NULL);
 496     wxPrintPreviewBase(wxPrintout *printout,
 497                        wxPrintout *printoutForPrinting,
 498                        wxPrintData *data);
 499     virtual ~wxPrintPreviewBase();
 500
 501     virtual bool SetCurrentPage(int pageNum);
 502     virtual int GetCurrentPage() const;
 503
 504     virtual void SetPrintout(wxPrintout *printout);
 505     virtual wxPrintout *GetPrintout() const;
 506     virtual wxPrintout *GetPrintoutForPrinting() const;
 507
 508     virtual void SetFrame(wxFrame *frame);
 509     virtual void SetCanvas(wxPreviewCanvas *canvas);
 510
 511     virtual wxFrame *GetFrame() const;
 512     virtual wxPreviewCanvas *GetCanvas() const;
 513
 514     // This is a helper routine, used by the next 4 routines.
 515
 516     virtual void CalcRects(wxPreviewCanvas *canvas, wxRect& printableAreaRect, wxRect& paperRect);
 517
 518     // The preview canvas should call this from OnPaint
 519     virtual bool PaintPage(wxPreviewCanvas *canvas, wxDC& dc);
 520
 521     // This draws a blank page onto the preview canvas
 522     virtual bool DrawBlankPage(wxPreviewCanvas *canvas, wxDC& dc);
 523
 524     // Adjusts the scrollbars for the current scale
 525     virtual void AdjustScrollbars(wxPreviewCanvas *canvas);
 526
 527     // This is called by wxPrintPreview to render a page into a wxMemoryDC.
 528     virtual bool RenderPage(int pageNum);
 529
 530
 531     virtual void SetZoom(int percent);
 532     virtual int GetZoom() const;
 533
 534     virtual wxPrintDialogData& GetPrintDialogData();
 535
 536     virtual int GetMaxPage() const;
 537     virtual int GetMinPage() const;
 538
 539     virtual bool Ok() const { return IsOk(); }
 540     virtual bool IsOk() const;
 541     virtual void SetOk(bool ok);
 542
 543     ///////////////////////////////////////////////////////////////////////////
 544     // OVERRIDES
 545
 546     // If we own a wxPrintout that can be used for printing, this
 547     // will invoke the actual printing procedure. Called
 548     // by the wxPreviewControlBar.
 549     virtual bool Print(bool interactive) = 0;
 550
 551     // Calculate scaling that needs to be done to get roughly
 552     // the right scaling for the screen pretending to be
 553     // the currently selected printer.
 554     virtual void DetermineScaling() = 0;
 555
 556 protected:
 557     wxPrintDialogData m_printDialogData;
 558     wxPreviewCanvas*  m_previewCanvas;
 559     wxFrame*          m_previewFrame;
 560     wxBitmap*         m_previewBitmap;
 561     wxPrintout*       m_previewPrintout;
 562     wxPrintout*       m_printPrintout;
 563     int               m_currentPage;
 564     int               m_currentZoom;
 565     float             m_previewScaleX;
 566     float             m_previewScaleY;
 567     int               m_topMargin;
 568     int               m_leftMargin;
 569     int               m_pageWidth;
 570     int               m_pageHeight;
 571     int               m_minPage;
 572     int               m_maxPage;
 573
 574     bool              m_isOk;
 575     bool              m_printingPrepared; // Called OnPreparePrinting?
 576
 577 private:
 578     void Init(wxPrintout *printout, wxPrintout *printoutForPrinting);
 579
 580     DECLARE_NO_COPY_CLASS(wxPrintPreviewBase)
 581     DECLARE_CLASS(wxPrintPreviewBase)
 582 };
 583
 584 //----------------------------------------------------------------------------
 585 // wxPrintPreview
 586 //----------------------------------------------------------------------------
 587
 588 class WXDLLEXPORT wxPrintPreview: public wxPrintPreviewBase
 589 {
 590 public:
 591     wxPrintPreview(wxPrintout *printout,
 592                    wxPrintout *printoutForPrinting = (wxPrintout *) NULL,
 593                    wxPrintDialogData *data = (wxPrintDialogData *) NULL);
 594     wxPrintPreview(wxPrintout *printout,
 595                    wxPrintout *printoutForPrinting,
 596                    wxPrintData *data);
 597     virtual ~wxPrintPreview();
 598
 599     virtual bool SetCurrentPage(int pageNum);
 600     virtual int GetCurrentPage() const;
 601     virtual void SetPrintout(wxPrintout *printout);
 602     virtual wxPrintout *GetPrintout() const;
 603     virtual wxPrintout *GetPrintoutForPrinting() const;
 604     virtual void SetFrame(wxFrame *frame);
 605     virtual void SetCanvas(wxPreviewCanvas *canvas);
 606
 607     virtual wxFrame *GetFrame() const;
 608     virtual wxPreviewCanvas *GetCanvas() const;
 609     virtual bool PaintPage(wxPreviewCanvas *canvas, wxDC& dc);
 610     virtual bool DrawBlankPage(wxPreviewCanvas *canvas, wxDC& dc);
 611     virtual void AdjustScrollbars(wxPreviewCanvas *canvas);
 612     virtual bool RenderPage(int pageNum);
 613     virtual void SetZoom(int percent);
 614     virtual int GetZoom() const;
 615
 616     virtual bool Print(bool interactive);
 617     virtual void DetermineScaling();
 618
 619     virtual wxPrintDialogData& GetPrintDialogData();
 620
 621     virtual int GetMaxPage() const;
 622     virtual int GetMinPage() const;
 623
 624     virtual bool Ok() const { return IsOk(); }
 625     virtual bool IsOk() const;
 626     virtual void SetOk(bool ok);
 627
 628 private:
 629     wxPrintPreviewBase *m_pimpl;
 630
 631 private:
 632     DECLARE_CLASS(wxPrintPreview)
 633     DECLARE_NO_COPY_CLASS(wxPrintPreview)
 634 };
 635
 636 //----------------------------------------------------------------------------
 637 // wxPrintAbortDialog
 638 //----------------------------------------------------------------------------
 639
 640 class WXDLLEXPORT wxPrintAbortDialog: public wxDialog
 641 {
 642 public:
 643     wxPrintAbortDialog(wxWindow *parent,
 644                        const wxString& title,
 645                        const wxPoint& pos = wxDefaultPosition,
 646                        const wxSize& size = wxDefaultSize,
 647                        long style = 0,
 648                        const wxString& name = wxT("dialog"))
 649         : wxDialog(parent, wxID_ANY, title, pos, size, style, name)
 650         {
 651         }
 652
 653     void OnCancel(wxCommandEvent& event);
 654
 655 private:
 656     DECLARE_EVENT_TABLE()
 657     DECLARE_NO_COPY_CLASS(wxPrintAbortDialog)
 658 };
 659
 660 #endif // wxUSE_PRINTING_ARCHITECTURE
 661
 662 #endif
 663     // _WX_PRNTBASEH__