Use wmain() if supported by the compiler/CRT instead of main().

[wxWidgets.git] / include / wx / prntbase.h

diff --git a/include/wx/prntbase.h b/include/wx/prntbase.h
index 42e04bf85f49d4f04d28498170057e22f806ae08..3faa87fab6e3e4c9f249701b8bbca59547dc0c17 100644 (file)
--- a/include/wx/prntbase.h
+++ b/include/wx/prntbase.h
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        prntbase.h
+// Name:        wx/prntbase.h

 // Purpose:     Base classes for printing framework
 // Author:      Julian Smart
 // Modified by:
 // Purpose:     Base classes for printing framework
 // Author:      Julian Smart
 // Modified by:


@@ -12,10 +12,6 @@
 #ifndef _WX_PRNTBASEH__
 #define _WX_PRNTBASEH__
 
 #ifndef _WX_PRNTBASEH__
 #define _WX_PRNTBASEH__
 

-#if defined(__GNUG__) && !defined(__APPLE__)
-    #pragma interface "prntbase.h"
-#endif
-

 #include "wx/defs.h"
 
 #if wxUSE_PRINTING_ARCHITECTURE
 #include "wx/defs.h"
 
 #if wxUSE_PRINTING_ARCHITECTURE


@@ -26,18 +22,32 @@
 #include "wx/scrolwin.h"
 #include "wx/dialog.h"
 #include "wx/frame.h"
 #include "wx/scrolwin.h"
 #include "wx/dialog.h"
 #include "wx/frame.h"

-
-class WXDLLEXPORT wxDC;
-class WXDLLEXPORT wxButton;
-class WXDLLEXPORT wxChoice;
-class WXDLLEXPORT wxPrintout;
-class WXDLLEXPORT wxPrinterBase;
-class WXDLLEXPORT wxPrintDialog;
-class WXDLLEXPORT wxPrintPreviewBase;
-class WXDLLEXPORT wxPreviewCanvas;
-class WXDLLEXPORT wxPreviewControlBar;
-class WXDLLEXPORT wxPreviewFrame;
-
+#include "wx/dc.h"
+
+class WXDLLIMPEXP_FWD_CORE wxDC;
+class WXDLLIMPEXP_FWD_CORE wxButton;
+class WXDLLIMPEXP_FWD_CORE wxChoice;
+class WXDLLIMPEXP_FWD_CORE wxPrintout;
+class WXDLLIMPEXP_FWD_CORE wxPrinterBase;
+class WXDLLIMPEXP_FWD_CORE wxPrintDialogBase;
+class WXDLLIMPEXP_FWD_CORE wxPrintDialog;
+class WXDLLIMPEXP_FWD_CORE wxPageSetupDialogBase;
+class WXDLLIMPEXP_FWD_CORE wxPageSetupDialog;
+class WXDLLIMPEXP_FWD_CORE wxPrintPreviewBase;
+class WXDLLIMPEXP_FWD_CORE wxPreviewCanvas;
+class WXDLLIMPEXP_FWD_CORE wxPreviewControlBar;
+class WXDLLIMPEXP_FWD_CORE wxPreviewFrame;
+class WXDLLIMPEXP_FWD_CORE wxPrintFactory;
+class WXDLLIMPEXP_FWD_CORE wxPrintNativeDataBase;
+class WXDLLIMPEXP_FWD_CORE wxPrintPreview;
+class WXDLLIMPEXP_FWD_CORE wxPrintAbortDialog;
+class WXDLLIMPEXP_FWD_CORE wxStaticText;
+class wxPrintPageMaxCtrl;
+class wxPrintPageTextCtrl;
+
+//----------------------------------------------------------------------------
+// error consts
+//----------------------------------------------------------------------------

 
 enum wxPrinterError
 {
 
 enum wxPrinterError
 {


@@ -46,60 +56,212 @@ enum wxPrinterError
     wxPRINTER_ERROR
 };
 
     wxPRINTER_ERROR
 };
 

+// Preview frame modality kind used with wxPreviewFrame::Initialize()
+enum wxPreviewFrameModalityKind
+{
+    // Disable all the other top level windows while the preview is shown.
+    wxPreviewFrame_AppModal,
+
+    // Disable only the parent window while the preview is shown.
+    wxPreviewFrame_WindowModal,
+
+    // Don't disable any windows.
+    wxPreviewFrame_NonModal
+};
+
+//----------------------------------------------------------------------------
+// wxPrintFactory
+//----------------------------------------------------------------------------
+
+class WXDLLIMPEXP_CORE wxPrintFactory
+{
+public:
+    wxPrintFactory() {}
+    virtual ~wxPrintFactory() {}
+
+    virtual wxPrinterBase *CreatePrinter( wxPrintDialogData* data ) = 0;
+
+    virtual wxPrintPreviewBase *CreatePrintPreview( wxPrintout *preview,
+                                                    wxPrintout *printout = NULL,
+                                                    wxPrintDialogData *data = NULL ) = 0;
+    virtual wxPrintPreviewBase *CreatePrintPreview( wxPrintout *preview,
+                                                    wxPrintout *printout,
+                                                    wxPrintData *data ) = 0;
+
+    virtual wxPrintDialogBase *CreatePrintDialog( wxWindow *parent,
+                                                  wxPrintDialogData *data = NULL ) = 0;
+    virtual wxPrintDialogBase *CreatePrintDialog( wxWindow *parent,
+                                                  wxPrintData *data ) = 0;
+
+    virtual wxPageSetupDialogBase *CreatePageSetupDialog( wxWindow *parent,
+                                                          wxPageSetupDialogData * data = NULL ) = 0;
+
+    virtual wxDCImpl* CreatePrinterDCImpl( wxPrinterDC *owner, const wxPrintData& data ) = 0;
+
+    // What to do and what to show in the wxPrintDialog
+    // a) Use the generic print setup dialog or a native one?
+    virtual bool HasPrintSetupDialog() = 0;
+    virtual wxDialog *CreatePrintSetupDialog( wxWindow *parent, wxPrintData *data ) = 0;
+    // b) Provide the "print to file" option ourselves or via print setup?
+    virtual bool HasOwnPrintToFile() = 0;
+    // c) Show current printer
+    virtual bool HasPrinterLine() = 0;
+    virtual wxString CreatePrinterLine() = 0;
+    // d) Show Status line for current printer?
+    virtual bool HasStatusLine() = 0;
+    virtual wxString CreateStatusLine() = 0;
+
+
+    virtual wxPrintNativeDataBase *CreatePrintNativeData() = 0;
+
+    static void SetPrintFactory( wxPrintFactory *factory );
+    static wxPrintFactory *GetFactory();
+private:
+    static wxPrintFactory *m_factory;
+};
+
+class WXDLLIMPEXP_CORE wxNativePrintFactory: public wxPrintFactory
+{
+public:
+    virtual wxPrinterBase *CreatePrinter( wxPrintDialogData *data );
+
+    virtual wxPrintPreviewBase *CreatePrintPreview( wxPrintout *preview,
+                                                    wxPrintout *printout = NULL,
+                                                    wxPrintDialogData *data = NULL );
+    virtual wxPrintPreviewBase *CreatePrintPreview( wxPrintout *preview,
+                                                    wxPrintout *printout,
+                                                    wxPrintData *data );
+
+    virtual wxPrintDialogBase *CreatePrintDialog( wxWindow *parent,
+                                                  wxPrintDialogData *data = NULL );
+    virtual wxPrintDialogBase *CreatePrintDialog( wxWindow *parent,
+                                                  wxPrintData *data );
+
+    virtual wxPageSetupDialogBase *CreatePageSetupDialog( wxWindow *parent,
+                                                          wxPageSetupDialogData * data = NULL );
+
+    virtual wxDCImpl* CreatePrinterDCImpl( wxPrinterDC *owner, const wxPrintData& data );
+
+    virtual bool HasPrintSetupDialog();
+    virtual wxDialog *CreatePrintSetupDialog( wxWindow *parent, wxPrintData *data );
+    virtual bool HasOwnPrintToFile();
+    virtual bool HasPrinterLine();
+    virtual wxString CreatePrinterLine();
+    virtual bool HasStatusLine();
+    virtual wxString CreateStatusLine();
+
+    virtual wxPrintNativeDataBase *CreatePrintNativeData();
+};
+
+//----------------------------------------------------------------------------
+// wxPrintNativeDataBase
+//----------------------------------------------------------------------------
+
+class WXDLLIMPEXP_CORE wxPrintNativeDataBase: public wxObject
+{
+public:
+    wxPrintNativeDataBase();
+    virtual ~wxPrintNativeDataBase() {}
+
+    virtual bool TransferTo( wxPrintData &data ) = 0;
+    virtual bool TransferFrom( const wxPrintData &data ) = 0;
+
+    virtual bool Ok() const { return IsOk(); }
+    virtual bool IsOk() const = 0;
+
+    int  m_ref;
+
+private:
+    DECLARE_CLASS(wxPrintNativeDataBase)
+    wxDECLARE_NO_COPY_CLASS(wxPrintNativeDataBase);
+};
+
+//----------------------------------------------------------------------------
+// wxPrinterBase
+//----------------------------------------------------------------------------

 
 /*
  * Represents the printer: manages printing a wxPrintout object
  */
 
 
 /*
  * Represents the printer: manages printing a wxPrintout object
  */
 

-class WXDLLEXPORT wxPrinterBase: public wxObject
+class WXDLLIMPEXP_CORE wxPrinterBase: public wxObject

 {
 public:
 {
 public:

-    wxPrinterBase(wxPrintDialogData *data = (wxPrintDialogData *) NULL);
+    wxPrinterBase(wxPrintDialogData *data = NULL);

     virtual ~wxPrinterBase();
 
     virtual ~wxPrinterBase();
 

-    virtual wxWindow *CreateAbortWindow(wxWindow *parent, wxPrintout *printout);
+    virtual wxPrintAbortDialog *CreateAbortWindow(wxWindow *parent, wxPrintout *printout);

     virtual void ReportError(wxWindow *parent, wxPrintout *printout, const wxString& message);
 
     virtual void ReportError(wxWindow *parent, wxPrintout *printout, const wxString& message);
 

-    wxPrintDialogData& GetPrintDialogData() const
-        { return (wxPrintDialogData&) m_printDialogData; }
+    virtual wxPrintDialogData& GetPrintDialogData() const;

     bool GetAbort() const { return sm_abortIt; }
     bool GetAbort() const { return sm_abortIt; }

-    
+

     static wxPrinterError GetLastError() { return sm_lastError; }
 
     ///////////////////////////////////////////////////////////////////////////
     // OVERRIDES
 
     virtual bool Setup(wxWindow *parent) = 0;
     static wxPrinterError GetLastError() { return sm_lastError; }
 
     ///////////////////////////////////////////////////////////////////////////
     // OVERRIDES
 
     virtual bool Setup(wxWindow *parent) = 0;

-    virtual bool Print(wxWindow *parent, wxPrintout *printout, bool prompt = TRUE) = 0;
+    virtual bool Print(wxWindow *parent, wxPrintout *printout, bool prompt = true) = 0;

     virtual wxDC* PrintDialog(wxWindow *parent) = 0;
 
 protected:
     wxPrintDialogData     m_printDialogData;
     wxPrintout*           m_currentPrintout;
     virtual wxDC* PrintDialog(wxWindow *parent) = 0;
 
 protected:
     wxPrintDialogData     m_printDialogData;
     wxPrintout*           m_currentPrintout;

-    
+

     static wxPrinterError sm_lastError;
     static wxPrinterError sm_lastError;

-    
+

 public:
     static wxWindow*      sm_abortWindow;
     static bool           sm_abortIt;
 
 private:
     DECLARE_CLASS(wxPrinterBase)
 public:
     static wxWindow*      sm_abortWindow;
     static bool           sm_abortIt;
 
 private:
     DECLARE_CLASS(wxPrinterBase)

-    DECLARE_NO_COPY_CLASS(wxPrinterBase)
+    wxDECLARE_NO_COPY_CLASS(wxPrinterBase);
+};
+
+//----------------------------------------------------------------------------
+// wxPrinter
+//----------------------------------------------------------------------------
+
+class WXDLLIMPEXP_CORE wxPrinter: public wxPrinterBase
+{
+public:
+    wxPrinter(wxPrintDialogData *data = NULL);
+    virtual ~wxPrinter();
+
+    virtual wxPrintAbortDialog *CreateAbortWindow(wxWindow *parent, wxPrintout *printout);
+    virtual void ReportError(wxWindow *parent, wxPrintout *printout, const wxString& message);
+
+    virtual bool Setup(wxWindow *parent);
+    virtual bool Print(wxWindow *parent, wxPrintout *printout, bool prompt = true);
+    virtual wxDC* PrintDialog(wxWindow *parent);
+
+    virtual wxPrintDialogData& GetPrintDialogData() const;
+
+protected:
+    wxPrinterBase    *m_pimpl;
+
+private:
+    DECLARE_CLASS(wxPrinter)
+    wxDECLARE_NO_COPY_CLASS(wxPrinter);

 };
 
 };
 

+//----------------------------------------------------------------------------
+// wxPrintout
+//----------------------------------------------------------------------------
+

 /*
 /*

- * wxPrintout

  * Represents an object via which a document may be printed.
  * The programmer derives from this, overrides (at least) OnPrintPage,
  * and passes it to a wxPrinter object for printing, or a wxPrintPreview
  * object for previewing.
  */
 
  * Represents an object via which a document may be printed.
  * The programmer derives from this, overrides (at least) OnPrintPage,
  * and passes it to a wxPrinter object for printing, or a wxPrintPreview
  * object for previewing.
  */
 

-class WXDLLEXPORT wxPrintout: public wxObject
+class WXDLLIMPEXP_CORE wxPrintout: public wxObject

 {
 public:
 {
 public:

-    wxPrintout(const wxString& title = wxT("Printout"));
+    wxPrintout(const wxString& title = _("Printout"));

     virtual ~wxPrintout();
 
     virtual bool OnBeginDocument(int startPage, int endPage);
     virtual ~wxPrintout();
 
     virtual bool OnBeginDocument(int startPage, int endPage);


@@ -118,23 +280,48 @@ public:
 
     wxDC *GetDC() const { return m_printoutDC; }
     void SetDC(wxDC *dc) { m_printoutDC = dc; }
 
     wxDC *GetDC() const { return m_printoutDC; }
     void SetDC(wxDC *dc) { m_printoutDC = dc; }

+
+    void FitThisSizeToPaper(const wxSize& imageSize);
+    void FitThisSizeToPage(const wxSize& imageSize);
+    void FitThisSizeToPageMargins(const wxSize& imageSize, const wxPageSetupDialogData& pageSetupData);
+    void MapScreenSizeToPaper();
+    void MapScreenSizeToPage();
+    void MapScreenSizeToPageMargins(const wxPageSetupDialogData& pageSetupData);
+    void MapScreenSizeToDevice();
+
+    wxRect GetLogicalPaperRect() const;
+    wxRect GetLogicalPageRect() const;
+    wxRect GetLogicalPageMarginsRect(const wxPageSetupDialogData& pageSetupData) const;
+
+    void SetLogicalOrigin(wxCoord x, wxCoord y);
+    void OffsetLogicalOrigin(wxCoord xoff, wxCoord yoff);
+

     void SetPageSizePixels(int w, int  h) { m_pageWidthPixels = w; m_pageHeightPixels = h; }
     void GetPageSizePixels(int *w, int  *h) const { *w = m_pageWidthPixels; *h = m_pageHeightPixels; }
     void SetPageSizeMM(int w, int  h) { m_pageWidthMM = w; m_pageHeightMM = h; }
     void GetPageSizeMM(int *w, int  *h) const { *w = m_pageWidthMM; *h = m_pageHeightMM; }
 
     void SetPPIScreen(int x, int y) { m_PPIScreenX = x; m_PPIScreenY = y; }
     void SetPageSizePixels(int w, int  h) { m_pageWidthPixels = w; m_pageHeightPixels = h; }
     void GetPageSizePixels(int *w, int  *h) const { *w = m_pageWidthPixels; *h = m_pageHeightPixels; }
     void SetPageSizeMM(int w, int  h) { m_pageWidthMM = w; m_pageHeightMM = h; }
     void GetPageSizeMM(int *w, int  *h) const { *w = m_pageWidthMM; *h = m_pageHeightMM; }
 
     void SetPPIScreen(int x, int y) { m_PPIScreenX = x; m_PPIScreenY = y; }

+    void SetPPIScreen(const wxSize& ppi) { SetPPIScreen(ppi.x, ppi.y); }

     void GetPPIScreen(int *x, int *y) const { *x = m_PPIScreenX; *y = m_PPIScreenY; }
     void SetPPIPrinter(int x, int y) { m_PPIPrinterX = x; m_PPIPrinterY = y; }
     void GetPPIScreen(int *x, int *y) const { *x = m_PPIScreenX; *y = m_PPIScreenY; }
     void SetPPIPrinter(int x, int y) { m_PPIPrinterX = x; m_PPIPrinterY = y; }

+    void SetPPIPrinter(const wxSize& ppi) { SetPPIPrinter(ppi.x, ppi.y); }

     void GetPPIPrinter(int *x, int *y) const { *x = m_PPIPrinterX; *y = m_PPIPrinterY; }
 
     void GetPPIPrinter(int *x, int *y) const { *x = m_PPIPrinterX; *y = m_PPIPrinterY; }
 

-    virtual bool IsPreview() const { return m_isPreview; }
+    void SetPaperRectPixels(const wxRect& paperRectPixels) { m_paperRectPixels = paperRectPixels; }
+    wxRect GetPaperRectPixels() const { return m_paperRectPixels; }

 
 

-    virtual void SetIsPreview(bool p) { m_isPreview = p; }
+    // This must be called by wxPrintPreview to associate itself with the
+    // printout it uses.
+    virtual void SetPreview(wxPrintPreview *preview) { m_preview = preview; }
+
+    wxPrintPreview *GetPreview() const { return m_preview; }
+    virtual bool IsPreview() const { return GetPreview() != NULL; }

 
 private:
     wxString         m_printoutTitle;
     wxDC*            m_printoutDC;
 
 private:
     wxString         m_printoutTitle;
     wxDC*            m_printoutDC;

+    wxPrintPreview  *m_preview;

 
     int              m_pageWidthPixels;
     int              m_pageHeightPixels;
 
     int              m_pageWidthPixels;
     int              m_pageHeightPixels;


@@ -147,19 +334,22 @@ private:
     int              m_PPIPrinterX;
     int              m_PPIPrinterY;
 
     int              m_PPIPrinterX;
     int              m_PPIPrinterY;
 

-    bool             m_isPreview;
+    wxRect           m_paperRectPixels;

 
 private:
     DECLARE_ABSTRACT_CLASS(wxPrintout)
 
 private:
     DECLARE_ABSTRACT_CLASS(wxPrintout)

-    DECLARE_NO_COPY_CLASS(wxPrintout)
+    wxDECLARE_NO_COPY_CLASS(wxPrintout);

 };
 
 };
 

+//----------------------------------------------------------------------------
+// wxPreviewCanvas
+//----------------------------------------------------------------------------
+

 /*
 /*

- * wxPreviewCanvas

  * Canvas upon which a preview is drawn.
  */
 
  * Canvas upon which a preview is drawn.
  */
 

-class WXDLLEXPORT wxPreviewCanvas: public wxScrolledWindow
+class WXDLLIMPEXP_CORE wxPreviewCanvas: public wxScrolledWindow

 {
 public:
     wxPreviewCanvas(wxPrintPreviewBase *preview,
 {
 public:
     wxPreviewCanvas(wxPrintPreviewBase *preview,


@@ -168,41 +358,68 @@ public:
                     const wxSize& size = wxDefaultSize,
                     long style = 0,
                     const wxString& name = wxT("canvas"));
                     const wxSize& size = wxDefaultSize,
                     long style = 0,
                     const wxString& name = wxT("canvas"));

-    ~wxPreviewCanvas();
+    virtual ~wxPreviewCanvas();
+
+    void SetPreview(wxPrintPreviewBase *preview) { m_printPreview = preview; }

 
     void OnPaint(wxPaintEvent& event);
     void OnChar(wxKeyEvent &event);
 
     void OnPaint(wxPaintEvent& event);
     void OnChar(wxKeyEvent &event);

-

     // Responds to colour changes
     void OnSysColourChanged(wxSysColourChangedEvent& event);
 
 private:
     // Responds to colour changes
     void OnSysColourChanged(wxSysColourChangedEvent& event);
 
 private:

+#if wxUSE_MOUSEWHEEL
+    void OnMouseWheel(wxMouseEvent& event);
+#endif // wxUSE_MOUSEWHEEL
+    void OnIdle(wxIdleEvent& event);
+

     wxPrintPreviewBase* m_printPreview;
 
     DECLARE_CLASS(wxPreviewCanvas)
     DECLARE_EVENT_TABLE()
     wxPrintPreviewBase* m_printPreview;
 
     DECLARE_CLASS(wxPreviewCanvas)
     DECLARE_EVENT_TABLE()

-    DECLARE_NO_COPY_CLASS(wxPreviewCanvas)
+    wxDECLARE_NO_COPY_CLASS(wxPreviewCanvas);

 };
 
 };
 

+//----------------------------------------------------------------------------
+// wxPreviewFrame
+//----------------------------------------------------------------------------
+

 /*
 /*

- * wxPreviewFrame

  * Default frame for showing preview.
  */
 
  * Default frame for showing preview.
  */
 

-class WXDLLEXPORT wxPreviewFrame: public wxFrame
+class WXDLLIMPEXP_CORE wxPreviewFrame: public wxFrame

 {
 public:
     wxPreviewFrame(wxPrintPreviewBase *preview,
                    wxWindow *parent,
 {
 public:
     wxPreviewFrame(wxPrintPreviewBase *preview,
                    wxWindow *parent,

-                   const wxString& title = wxT("Print Preview"),
+                   const wxString& title = _("Print Preview"),

                    const wxPoint& pos = wxDefaultPosition,
                    const wxSize& size = wxDefaultSize,
                    const wxPoint& pos = wxDefaultPosition,
                    const wxSize& size = wxDefaultSize,

-                   long style = wxDEFAULT_FRAME_STYLE,
-                   const wxString& name = wxT("frame"));
-    ~wxPreviewFrame();
+                   long style = wxDEFAULT_FRAME_STYLE | wxFRAME_FLOAT_ON_PARENT,
+                   const wxString& name = wxFrameNameStr);
+    virtual ~wxPreviewFrame();
+
+    // Either Initialize() or InitializeWithModality() must be called before
+    // showing the preview frame, the former being just a particular case of
+    // the latter initializing the frame for being showing app-modally.
+
+    // Notice that we must keep Initialize() with its existing signature to
+    // avoid breaking the old code that overrides it and we can't reuse the
+    // same name for the other functions to avoid virtual function hiding
+    // problem and the associated warnings given by some compilers (e.g. from
+    // g++ with -Woverloaded-virtual).
+    virtual void Initialize()
+    {
+        InitializeWithModality(wxPreviewFrame_AppModal);
+    }
+
+    // Also note that this method is not virtual as it doesn't need to be
+    // overridden: it's never called by wxWidgets (of course, the same is true
+    // for Initialize() but, again, it must remain virtual for compatibility).
+    void InitializeWithModality(wxPreviewFrameModalityKind kind);

 
     void OnCloseWindow(wxCloseEvent& event);
 
     void OnCloseWindow(wxCloseEvent& event);

-    virtual void Initialize();

     virtual void CreateCanvas();
     virtual void CreateControlBar();
 
     virtual void CreateCanvas();
     virtual void CreateControlBar();
 


@@ -212,15 +429,24 @@ protected:
     wxPreviewCanvas*      m_previewCanvas;
     wxPreviewControlBar*  m_controlBar;
     wxPrintPreviewBase*   m_printPreview;
     wxPreviewCanvas*      m_previewCanvas;
     wxPreviewControlBar*  m_controlBar;
     wxPrintPreviewBase*   m_printPreview;

+    wxWindowDisabler*     m_windowDisabler;
+
+    wxPreviewFrameModalityKind m_modalityKind;
+

 
 private:
 
 private:

-    DECLARE_CLASS(wxPreviewFrame)
+    void OnChar(wxKeyEvent& event);
+

     DECLARE_EVENT_TABLE()
     DECLARE_EVENT_TABLE()

-    DECLARE_NO_COPY_CLASS(wxPreviewFrame)
+    DECLARE_CLASS(wxPreviewFrame)
+    wxDECLARE_NO_COPY_CLASS(wxPreviewFrame);

 };
 
 };
 

+//----------------------------------------------------------------------------
+// wxPreviewControlBar
+//----------------------------------------------------------------------------
+

 /*
 /*

- * wxPreviewControlBar

  * A panel with buttons for controlling a print preview.
  * The programmer may wish to use other means for controlling
  * the print preview.
  * A panel with buttons for controlling a print preview.
  * The programmer may wish to use other means for controlling
  * the print preview.


@@ -234,8 +460,8 @@ private:
 #define wxPREVIEW_LAST        32
 #define wxPREVIEW_GOTO        64
 
 #define wxPREVIEW_LAST        32
 #define wxPREVIEW_GOTO        64
 

-#define wxPREVIEW_DEFAULT  wxPREVIEW_PREVIOUS|wxPREVIEW_NEXT|wxPREVIEW_ZOOM\
-                          |wxPREVIEW_FIRST|wxPREVIEW_GOTO|wxPREVIEW_LAST
+#define wxPREVIEW_DEFAULT  (wxPREVIEW_PREVIOUS|wxPREVIEW_NEXT|wxPREVIEW_ZOOM\
+                            |wxPREVIEW_FIRST|wxPREVIEW_GOTO|wxPREVIEW_LAST)

 
 // Ids for controls
 #define wxID_PREVIEW_CLOSE      1
 
 // Ids for controls
 #define wxID_PREVIEW_CLOSE      1


@@ -246,8 +472,10 @@ private:
 #define wxID_PREVIEW_FIRST      6
 #define wxID_PREVIEW_LAST       7
 #define wxID_PREVIEW_GOTO       8
 #define wxID_PREVIEW_FIRST      6
 #define wxID_PREVIEW_LAST       7
 #define wxID_PREVIEW_GOTO       8

+#define wxID_PREVIEW_ZOOM_IN    9
+#define wxID_PREVIEW_ZOOM_OUT   10

 
 

-class WXDLLEXPORT wxPreviewControlBar: public wxPanel
+class WXDLLIMPEXP_CORE wxPreviewControlBar: public wxPanel

 {
     DECLARE_CLASS(wxPreviewControlBar)
 
 {
     DECLARE_CLASS(wxPreviewControlBar)
 


@@ -259,80 +487,121 @@ public:
                         const wxSize& size = wxDefaultSize,
                         long style = wxTAB_TRAVERSAL,
                         const wxString& name = wxT("panel"));
                         const wxSize& size = wxDefaultSize,
                         long style = wxTAB_TRAVERSAL,
                         const wxString& name = wxT("panel"));

-    ~wxPreviewControlBar();
+    virtual ~wxPreviewControlBar();

 
     virtual void CreateButtons();
 
     virtual void CreateButtons();

+    virtual void SetPageInfo(int minPage, int maxPage);

     virtual void SetZoomControl(int zoom);
     virtual int GetZoomControl();
     virtual wxPrintPreviewBase *GetPrintPreview() const
         { return m_printPreview; }
 
     virtual void SetZoomControl(int zoom);
     virtual int GetZoomControl();
     virtual wxPrintPreviewBase *GetPrintPreview() const
         { return m_printPreview; }
 

-    void OnPrint(wxCommandEvent& event);
+
+    // Implementation only from now on.

     void OnWindowClose(wxCommandEvent& event);
     void OnNext();
     void OnPrevious();
     void OnFirst();
     void OnLast();
     void OnWindowClose(wxCommandEvent& event);
     void OnNext();
     void OnPrevious();
     void OnFirst();
     void OnLast();

-    void OnGoto();
+    void OnGotoPage();
+    void OnPrint();
+
+    void OnPrintButton(wxCommandEvent& WXUNUSED(event)) { OnPrint(); }

     void OnNextButton(wxCommandEvent & WXUNUSED(event)) { OnNext(); }
     void OnPreviousButton(wxCommandEvent & WXUNUSED(event)) { OnPrevious(); }
     void OnFirstButton(wxCommandEvent & WXUNUSED(event)) { OnFirst(); }
     void OnLastButton(wxCommandEvent & WXUNUSED(event)) { OnLast(); }
     void OnNextButton(wxCommandEvent & WXUNUSED(event)) { OnNext(); }
     void OnPreviousButton(wxCommandEvent & WXUNUSED(event)) { OnPrevious(); }
     void OnFirstButton(wxCommandEvent & WXUNUSED(event)) { OnFirst(); }
     void OnLastButton(wxCommandEvent & WXUNUSED(event)) { OnLast(); }

-    void OnGotoButton(wxCommandEvent & WXUNUSED(event)) { OnGoto(); }
-    void OnZoom(wxCommandEvent& event);

     void OnPaint(wxPaintEvent& event);
 
     void OnPaint(wxPaintEvent& event);
 

+    void OnUpdateNextButton(wxUpdateUIEvent& event)
+        { event.Enable(IsNextEnabled()); }
+    void OnUpdatePreviousButton(wxUpdateUIEvent& event)
+        { event.Enable(IsPreviousEnabled()); }
+    void OnUpdateFirstButton(wxUpdateUIEvent& event)
+        { event.Enable(IsFirstEnabled()); }
+    void OnUpdateLastButton(wxUpdateUIEvent& event)
+        { event.Enable(IsLastEnabled()); }
+    void OnUpdateZoomInButton(wxUpdateUIEvent& event)
+        { event.Enable(IsZoomInEnabled()); }
+    void OnUpdateZoomOutButton(wxUpdateUIEvent& event)
+        { event.Enable(IsZoomOutEnabled()); }
+
+    // These methods are not private because they are called by wxPreviewCanvas.
+    void DoZoomIn();
+    void DoZoomOut();
+

 protected:
     wxPrintPreviewBase*   m_printPreview;
     wxButton*             m_closeButton;
 protected:
     wxPrintPreviewBase*   m_printPreview;
     wxButton*             m_closeButton;

-    wxButton*             m_nextPageButton;
-    wxButton*             m_previousPageButton;
-    wxButton*             m_printButton;

     wxChoice*             m_zoomControl;
     wxChoice*             m_zoomControl;

-    wxButton*             m_firstPageButton;
-    wxButton*             m_lastPageButton;
-    wxButton*             m_gotoPageButton;
+    wxPrintPageTextCtrl*  m_currentPageText;
+    wxPrintPageMaxCtrl*   m_maxPageText;
+

     long                  m_buttonFlags;
 
 private:
     long                  m_buttonFlags;
 
 private:

+    void DoGotoPage(int page);
+
+    void DoZoom();
+
+    bool IsNextEnabled() const;
+    bool IsPreviousEnabled() const;
+    bool IsFirstEnabled() const;
+    bool IsLastEnabled() const;
+    bool IsZoomInEnabled() const;
+    bool IsZoomOutEnabled() const;
+
+    void OnZoomInButton(wxCommandEvent & WXUNUSED(event)) { DoZoomIn(); }
+    void OnZoomOutButton(wxCommandEvent & WXUNUSED(event)) { DoZoomOut(); }
+    void OnZoomChoice(wxCommandEvent& WXUNUSED(event)) { DoZoom(); }
+

     DECLARE_EVENT_TABLE()
     DECLARE_EVENT_TABLE()

-    DECLARE_NO_COPY_CLASS(wxPreviewControlBar)
+    wxDECLARE_NO_COPY_CLASS(wxPreviewControlBar);

 };
 
 };
 

+//----------------------------------------------------------------------------
+// wxPrintPreviewBase
+//----------------------------------------------------------------------------
+

 /*
 /*

- * wxPrintPreview

  * Programmer creates an object of this class to preview a wxPrintout.
  */
 
  * Programmer creates an object of this class to preview a wxPrintout.
  */
 

-class WXDLLEXPORT wxPrintPreviewBase: public wxObject
+class WXDLLIMPEXP_CORE wxPrintPreviewBase: public wxObject

 {
 {

-    DECLARE_CLASS(wxPrintPreviewBase)
-

 public:
     wxPrintPreviewBase(wxPrintout *printout,
 public:
     wxPrintPreviewBase(wxPrintout *printout,

-                       wxPrintout *printoutForPrinting = (wxPrintout *) NULL,
-                       wxPrintDialogData *data = (wxPrintDialogData *) NULL);
+                       wxPrintout *printoutForPrinting = NULL,
+                       wxPrintDialogData *data = NULL);

     wxPrintPreviewBase(wxPrintout *printout,
                        wxPrintout *printoutForPrinting,
                        wxPrintData *data);
     virtual ~wxPrintPreviewBase();
 
     virtual bool SetCurrentPage(int pageNum);
     wxPrintPreviewBase(wxPrintout *printout,
                        wxPrintout *printoutForPrinting,
                        wxPrintData *data);
     virtual ~wxPrintPreviewBase();
 
     virtual bool SetCurrentPage(int pageNum);

-    int GetCurrentPage() const { return m_currentPage; };
+    virtual int GetCurrentPage() const;

 
 

-    void SetPrintout(wxPrintout *printout) { m_previewPrintout = printout; };
-    wxPrintout *GetPrintout() const { return m_previewPrintout; };
-    wxPrintout *GetPrintoutForPrinting() const { return m_printPrintout; };
+    virtual void SetPrintout(wxPrintout *printout);
+    virtual wxPrintout *GetPrintout() const;
+    virtual wxPrintout *GetPrintoutForPrinting() const;

 
 

-    void SetFrame(wxFrame *frame) { m_previewFrame = frame; };
-    void SetCanvas(wxPreviewCanvas *canvas) { m_previewCanvas = canvas; };
+    virtual void SetFrame(wxFrame *frame);
+    virtual void SetCanvas(wxPreviewCanvas *canvas);

 
 

-    virtual wxFrame *GetFrame() const { return m_previewFrame; }
-    virtual wxPreviewCanvas *GetCanvas() const { return m_previewCanvas; }
+    virtual wxFrame *GetFrame() const;
+    virtual wxPreviewCanvas *GetCanvas() const;
+
+    // This is a helper routine, used by the next 4 routines.
+
+    virtual void CalcRects(wxPreviewCanvas *canvas, wxRect& printableAreaRect, wxRect& paperRect);

 
     // The preview canvas should call this from OnPaint
     virtual bool PaintPage(wxPreviewCanvas *canvas, wxDC& dc);
 
 
     // The preview canvas should call this from OnPaint
     virtual bool PaintPage(wxPreviewCanvas *canvas, wxDC& dc);
 

+    // Updates rendered page by calling RenderPage() if needed, returns true
+    // if there was some change. Preview canvas should call it at idle time
+    virtual bool UpdatePageRendering();
+

     // This draws a blank page onto the preview canvas
     virtual bool DrawBlankPage(wxPreviewCanvas *canvas, wxDC& dc);
 
     // This draws a blank page onto the preview canvas
     virtual bool DrawBlankPage(wxPreviewCanvas *canvas, wxDC& dc);
 


@@ -342,16 +611,18 @@ public:
     // This is called by wxPrintPreview to render a page into a wxMemoryDC.
     virtual bool RenderPage(int pageNum);
 
     // This is called by wxPrintPreview to render a page into a wxMemoryDC.
     virtual bool RenderPage(int pageNum);
 

-    wxPrintDialogData& GetPrintDialogData() { return m_printDialogData; }

 
     virtual void SetZoom(int percent);
 
     virtual void SetZoom(int percent);

-    int GetZoom() const { return m_currentZoom; };
+    virtual int GetZoom() const;

 
 

-    int GetMaxPage() const { return m_maxPage; }
-    int GetMinPage() const { return m_minPage; }
+    virtual wxPrintDialogData& GetPrintDialogData();

 
 

-    bool Ok() const { return m_isOk; }
-    void SetOk(bool ok) { m_isOk = ok; }
+    virtual int GetMaxPage() const;
+    virtual int GetMinPage() const;
+
+    virtual bool Ok() const { return IsOk(); }
+    virtual bool IsOk() const;
+    virtual void SetOk(bool ok);

 
     ///////////////////////////////////////////////////////////////////////////
     // OVERRIDES
 
     ///////////////////////////////////////////////////////////////////////////
     // OVERRIDES


@@ -366,16 +637,26 @@ public:
     // the currently selected printer.
     virtual void DetermineScaling() = 0;
 
     // the currently selected printer.
     virtual void DetermineScaling() = 0;
 

+protected:
+    // helpers for RenderPage():
+    virtual bool RenderPageIntoDC(wxDC& dc, int pageNum);
+    // renders preview into m_previewBitmap
+    virtual bool RenderPageIntoBitmap(wxBitmap& bmp, int pageNum);
+
+    void InvalidatePreviewBitmap();
+

 protected:
     wxPrintDialogData m_printDialogData;
     wxPreviewCanvas*  m_previewCanvas;
     wxFrame*          m_previewFrame;
     wxBitmap*         m_previewBitmap;
 protected:
     wxPrintDialogData m_printDialogData;
     wxPreviewCanvas*  m_previewCanvas;
     wxFrame*          m_previewFrame;
     wxBitmap*         m_previewBitmap;

+    bool              m_previewFailed;

     wxPrintout*       m_previewPrintout;
     wxPrintout*       m_printPrintout;
     int               m_currentPage;
     int               m_currentZoom;
     wxPrintout*       m_previewPrintout;
     wxPrintout*       m_printPrintout;
     int               m_currentPage;
     int               m_currentZoom;

-    float             m_previewScale;
+    float             m_previewScaleX;
+    float             m_previewScaleY;

     int               m_topMargin;
     int               m_leftMargin;
     int               m_pageWidth;
     int               m_topMargin;
     int               m_leftMargin;
     int               m_pageWidth;


@@ -389,31 +670,87 @@ protected:
 private:
     void Init(wxPrintout *printout, wxPrintout *printoutForPrinting);
 
 private:
     void Init(wxPrintout *printout, wxPrintout *printoutForPrinting);
 

-    DECLARE_NO_COPY_CLASS(wxPrintPreviewBase)
+    wxDECLARE_NO_COPY_CLASS(wxPrintPreviewBase);
+    DECLARE_CLASS(wxPrintPreviewBase)

 };
 
 };
 

-/*
- * Abort dialog
- */
+//----------------------------------------------------------------------------
+// wxPrintPreview
+//----------------------------------------------------------------------------
+
+class WXDLLIMPEXP_CORE wxPrintPreview: public wxPrintPreviewBase
+{
+public:
+    wxPrintPreview(wxPrintout *printout,
+                   wxPrintout *printoutForPrinting = NULL,
+                   wxPrintDialogData *data = NULL);
+    wxPrintPreview(wxPrintout *printout,
+                   wxPrintout *printoutForPrinting,
+                   wxPrintData *data);
+    virtual ~wxPrintPreview();
+
+    virtual bool SetCurrentPage(int pageNum);
+    virtual int GetCurrentPage() const;
+    virtual void SetPrintout(wxPrintout *printout);
+    virtual wxPrintout *GetPrintout() const;
+    virtual wxPrintout *GetPrintoutForPrinting() const;
+    virtual void SetFrame(wxFrame *frame);
+    virtual void SetCanvas(wxPreviewCanvas *canvas);
+
+    virtual wxFrame *GetFrame() const;
+    virtual wxPreviewCanvas *GetCanvas() const;
+    virtual bool PaintPage(wxPreviewCanvas *canvas, wxDC& dc);
+    virtual bool UpdatePageRendering();
+    virtual bool DrawBlankPage(wxPreviewCanvas *canvas, wxDC& dc);
+    virtual void AdjustScrollbars(wxPreviewCanvas *canvas);
+    virtual bool RenderPage(int pageNum);
+    virtual void SetZoom(int percent);
+    virtual int GetZoom() const;
+
+    virtual bool Print(bool interactive);
+    virtual void DetermineScaling();
+
+    virtual wxPrintDialogData& GetPrintDialogData();
+
+    virtual int GetMaxPage() const;
+    virtual int GetMinPage() const;
+
+    virtual bool Ok() const { return IsOk(); }
+    virtual bool IsOk() const;
+    virtual void SetOk(bool ok);
+
+private:
+    wxPrintPreviewBase *m_pimpl;

 
 

-class WXDLLEXPORT wxPrintAbortDialog: public wxDialog
+private:
+    DECLARE_CLASS(wxPrintPreview)
+    wxDECLARE_NO_COPY_CLASS(wxPrintPreview);
+};
+
+//----------------------------------------------------------------------------
+// wxPrintAbortDialog
+//----------------------------------------------------------------------------
+
+class WXDLLIMPEXP_CORE wxPrintAbortDialog: public wxDialog

 {
 public:
     wxPrintAbortDialog(wxWindow *parent,
 {
 public:
     wxPrintAbortDialog(wxWindow *parent,

-                       const wxString& title,
+                       const wxString& documentTitle,

                        const wxPoint& pos = wxDefaultPosition,
                        const wxSize& size = wxDefaultSize,
                        const wxPoint& pos = wxDefaultPosition,
                        const wxSize& size = wxDefaultSize,

-                       long style = 0,
-                       const wxString& name = wxT("dialog"))
-        : wxDialog(parent, -1, title, pos, size, style, name)
-        {
-        }
+                       long style = wxDEFAULT_DIALOG_STYLE,
+                       const wxString& name = wxT("dialog"));
+
+    void SetProgress(int currentPage, int totalPages,
+                     int currentCopy, int totalCopies);

 
     void OnCancel(wxCommandEvent& event);
 
 private:
 
     void OnCancel(wxCommandEvent& event);
 
 private:

+    wxStaticText *m_progress;
+

     DECLARE_EVENT_TABLE()
     DECLARE_EVENT_TABLE()

-    DECLARE_NO_COPY_CLASS(wxPrintAbortDialog)
+    wxDECLARE_NO_COPY_CLASS(wxPrintAbortDialog);

 };
 
 #endif // wxUSE_PRINTING_ARCHITECTURE
 };
 
 #endif // wxUSE_PRINTING_ARCHITECTURE