git.saurik.com Git - wxWidgets.git/blame_incremental

... / ...

Commit	Line	Data
	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	wxDECLARE_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 = 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	wxDECLARE_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 = 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	wxDECLARE_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	wxDECLARE_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	wxDECLARE_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 \| wxFRAME_FLOAT_ON_PARENT,
	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	wxDECLARE_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	wxDECLARE_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 = NULL,
	501	wxPrintDialogData *data = 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	wxDECLARE_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 = NULL,
	612	wxPrintDialogData *data = 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	wxDECLARE_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	wxDECLARE_NO_COPY_CLASS(wxPrintAbortDialog);
	678	};
	679
	680	#endif // wxUSE_PRINTING_ARCHITECTURE
	681
	682	#endif
	683	// _WX_PRNTBASEH__