← Back to branch summary

~ubuntu-dev/wxwidgets2.6/upstream-debian

« back to all changes in this revision

Viewing changes to include/wx/prntbase.h

  • Committer: Daniel T Chen
  • Date: 2006-06-26 10:15:11 UTC
  • Revision ID: crimsun@ubuntu.com-20060626101511-a4436cec4c6d9b35
Import Debian 2.6.3.2.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
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: prntbase.h,v 1.45 2005/07/28 22:20:05 VZ Exp $
 
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__