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