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