include/wx/prntbase.h

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