wxPython/src/printfw.i

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        printfw.i
   3 // Purpose:     Printing Framework classes
   4 //
   5 // Author:      Robin Dunn
   6 //
   7 // Created:     7-May-1999
   8 // RCS-ID:      $Id$
   9 // Copyright:   (c) 1998 by Total Control Software
  10 // Licence:     wxWindows license
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 %module printfw
  14
  15 %{
  16 #include "helpers.h"
  17 #include <wx/print.h>
  18 #include <wx/printdlg.h>
  19 #include <wx/dcps.h>
  20
  21 #include "printfw.h"
  22 %}
  23
  24 //----------------------------------------------------------------------
  25
  26 %{
  27     // Put some wx default wxChar* values into wxStrings.
  28     static const wxChar* wxPrintoutTitleStr = wxT("Printout");
  29     DECLARE_DEF_STRING(PrintoutTitleStr);
  30     static const wxChar* wxPreviewCanvasNameStr = wxT("previewcanvas");
  31     DECLARE_DEF_STRING(PreviewCanvasNameStr);
  32
  33     DECLARE_DEF_STRING(FrameNameStr);
  34     DECLARE_DEF_STRING(PanelNameStr);
  35     DECLARE_DEF_STRING(DialogNameStr);
  36
  37 %}
  38
  39 //----------------------------------------------------------------------
  40
  41 %include typemaps.i
  42 %include my_typemaps.i
  43
  44 // Import some definitions of other classes, etc.
  45 %import _defs.i
  46 %import misc.i
  47 %import windows.i
  48 %import gdi.i
  49 %import cmndlgs.i
  50 %import frames.i
  51
  52
  53 %pragma(python) code = "import wx"
  54
  55
  56 //----------------------------------------------------------------------
  57
  58 enum wxPrintMode
  59 {
  60     wxPRINT_MODE_NONE =    0,
  61     wxPRINT_MODE_PREVIEW = 1,   // Preview in external application
  62     wxPRINT_MODE_FILE =    2,   // Print to file
  63     wxPRINT_MODE_PRINTER = 3    // Send to printer
  64 };
  65
  66
  67
  68 class wxPrintData : public wxObject {
  69 public:
  70     wxPrintData();
  71     ~wxPrintData();
  72
  73     int GetNoCopies();
  74     bool GetCollate();
  75     int  GetOrientation();
  76
  77     bool Ok();
  78
  79     const wxString& GetPrinterName();
  80     bool GetColour();
  81     wxDuplexMode GetDuplex();
  82     wxPaperSize GetPaperId();
  83     const wxSize& GetPaperSize();
  84
  85     wxPrintQuality GetQuality();
  86
  87     void SetNoCopies(int v);
  88     void SetCollate(bool flag);
  89     void SetOrientation(int orient);
  90
  91     void SetPrinterName(const wxString& name);
  92     void SetColour(bool colour);
  93     void SetDuplex(wxDuplexMode duplex);
  94     void SetPaperId(wxPaperSize sizeId);
  95     void SetPaperSize(const wxSize& sz);
  96     void SetQuality(wxPrintQuality quality);
  97
  98     // PostScript-specific data
  99     const wxString& GetPrinterCommand();
 100     const wxString& GetPrinterOptions();
 101     const wxString& GetPreviewCommand();
 102     const wxString& GetFilename();
 103     const wxString& GetFontMetricPath();
 104     double GetPrinterScaleX();
 105     double GetPrinterScaleY();
 106     long GetPrinterTranslateX();
 107     long GetPrinterTranslateY();
 108     wxPrintMode GetPrintMode();
 109
 110     void SetPrinterCommand(const wxString& command);
 111     void SetPrinterOptions(const wxString& options);
 112     void SetPreviewCommand(const wxString& command);
 113     void SetFilename(const wxString& filename);
 114     void SetFontMetricPath(const wxString& path);
 115     void SetPrinterScaleX(double x);
 116     void SetPrinterScaleY(double y);
 117     void SetPrinterScaling(double x, double y);
 118     void SetPrinterTranslateX(long x);
 119     void SetPrinterTranslateY(long y);
 120     void SetPrinterTranslation(long x, long y);
 121     void SetPrintMode(wxPrintMode printMode);
 122
 123     %pragma(python) addtoclass = "def __nonzero__(self): return self.Ok()"
 124 };
 125
 126 //----------------------------------------------------------------------
 127
 128 #ifdef __WXMSW__
 129 class  wxPrinterDC : public wxDC {
 130 public:
 131     wxPrinterDC(const wxPrintData& printData);
 132     %name(wxPrinterDC2) wxPrinterDC(const wxString& driver,
 133                                     const wxString& device,
 134                                     const wxString& output,
 135                                     bool interactive = TRUE,
 136                                     int orientation = wxPORTRAIT);
 137 };
 138 #endif
 139
 140 //---------------------------------------------------------------------------
 141
 142 class wxPostScriptDC : public wxDC {
 143 public:
 144     wxPostScriptDC(const wxPrintData& printData);
 145 //     %name(wxPostScriptDC2)wxPostScriptDC(const wxString& output,
 146 //                                          bool interactive = TRUE,
 147 //                                          wxWindow* parent = NULL);
 148
 149     wxPrintData& GetPrintData();
 150     void SetPrintData(const wxPrintData& data);
 151
 152     static void SetResolution(int ppi);
 153     static int GetResolution();
 154 };
 155
 156 //---------------------------------------------------------------------------
 157
 158 class wxPageSetupDialogData : public wxObject {
 159 public:
 160     wxPageSetupDialogData();
 161     ~wxPageSetupDialogData();
 162
 163     void EnableHelp(bool flag);
 164     void EnableMargins(bool flag);
 165     void EnableOrientation(bool flag);
 166     void EnablePaper(bool flag);
 167     void EnablePrinter(bool flag);
 168     bool GetDefaultMinMargins();
 169     bool GetEnableMargins();
 170     bool GetEnableOrientation();
 171     bool GetEnablePaper();
 172     bool GetEnablePrinter();
 173     bool GetEnableHelp();
 174     bool GetDefaultInfo();
 175     wxPoint GetMarginTopLeft();
 176     wxPoint GetMarginBottomRight();
 177     wxPoint GetMinMarginTopLeft();
 178     wxPoint GetMinMarginBottomRight();
 179     wxPaperSize GetPaperId();
 180     wxSize GetPaperSize();
 181     %addmethods {
 182         %new wxPrintData* GetPrintData() {
 183             return new wxPrintData(self->GetPrintData());  // force a copy
 184         }
 185     }
 186
 187     bool Ok();
 188
 189     void SetDefaultInfo(bool flag);
 190     void SetDefaultMinMargins(bool flag);
 191     void SetMarginTopLeft(const wxPoint& pt);
 192     void SetMarginBottomRight(const wxPoint& pt);
 193     void SetMinMarginTopLeft(const wxPoint& pt);
 194     void SetMinMarginBottomRight(const wxPoint& pt);
 195     void SetPaperId(wxPaperSize id);
 196     void SetPaperSize(const wxSize& size);
 197     void SetPrintData(const wxPrintData& printData);
 198
 199     %pragma(python) addtoclass = "def __nonzero__(self): return self.Ok()"
 200 };
 201
 202
 203 class wxPageSetupDialog : public wxDialog {
 204 public:
 205     wxPageSetupDialog(wxWindow* parent, wxPageSetupDialogData* data = NULL);
 206
 207     %pragma(python) addtomethod = "__init__:#wx._StdDialogCallbacks(self)"
 208
 209     wxPageSetupDialogData& GetPageSetupData();
 210     int ShowModal();
 211 };
 212
 213 //----------------------------------------------------------------------
 214
 215
 216 class wxPrintDialogData : public wxObject {
 217 public:
 218     wxPrintDialogData();
 219     ~wxPrintDialogData();
 220
 221     int GetFromPage() const;
 222     int GetToPage() const;
 223     int GetMinPage() const;
 224     int GetMaxPage() const;
 225     int GetNoCopies() const;
 226     bool GetAllPages() const;
 227     bool GetSelection() const;
 228     bool GetCollate() const;
 229     bool GetPrintToFile() const;
 230     bool GetSetupDialog() const;
 231
 232     void SetFromPage(int v);
 233     void SetToPage(int v);
 234     void SetMinPage(int v);
 235     void SetMaxPage(int v);
 236     void SetNoCopies(int v);
 237     void SetAllPages(bool flag);
 238     void SetSelection(bool flag);
 239     void SetCollate(bool flag);
 240     void SetPrintToFile(bool flag);
 241     void SetSetupDialog(bool flag);
 242
 243     void EnablePrintToFile(bool flag);
 244     void EnableSelection(bool flag);
 245     void EnablePageNumbers(bool flag);
 246     void EnableHelp(bool flag);
 247
 248     bool GetEnablePrintToFile() const;
 249     bool GetEnableSelection() const;
 250     bool GetEnablePageNumbers() const;
 251     bool GetEnableHelp() const;
 252
 253     // Is this data OK for showing the print dialog?
 254     bool Ok() const;
 255
 256     %addmethods {
 257         %new wxPrintData* GetPrintData() {
 258             return new wxPrintData(self->GetPrintData());  // force a copy
 259         }
 260     }
 261     void SetPrintData(const wxPrintData& printData);
 262
 263     %pragma(python) addtoclass = "def __nonzero__(self): return self.Ok()"
 264 };
 265
 266
 267 class wxPrintDialog : public wxDialog {
 268 public:
 269     wxPrintDialog(wxWindow* parent, wxPrintDialogData* data = NULL);
 270
 271     %pragma(python) addtomethod = "__init__:#wx._StdDialogCallbacks(self)"
 272
 273     wxPrintDialogData& GetPrintDialogData();
 274     %new wxDC* GetPrintDC();
 275     int ShowModal();
 276 };
 277
 278 //----------------------------------------------------------------------
 279 //----------------------------------------------------------------------
 280 // Custom wxPrintout class that knows how to call python
 281 %{
 282
 283
 284 // Since this one would be tough and ugly to do with the Macros...
 285 void wxPyPrintout::GetPageInfo(int *minPage, int *maxPage, int *pageFrom, int *pageTo) {
 286     bool hadErr = FALSE;
 287     bool found;
 288
 289     wxPyBeginBlockThreads();
 290     if ((found = m_myInst.findCallback("GetPageInfo"))) {
 291         PyObject* result = m_myInst.callCallbackObj(Py_BuildValue("()"));
 292         if (result && PyTuple_Check(result) && PyTuple_Size(result) == 4) {
 293             PyObject* val;
 294
 295             val = PyTuple_GetItem(result, 0);
 296             if (PyInt_Check(val))    *minPage = PyInt_AsLong(val);
 297             else hadErr = TRUE;
 298
 299             val = PyTuple_GetItem(result, 1);
 300             if (PyInt_Check(val))    *maxPage = PyInt_AsLong(val);
 301             else hadErr = TRUE;
 302
 303             val = PyTuple_GetItem(result, 2);
 304             if (PyInt_Check(val))    *pageFrom = PyInt_AsLong(val);
 305             else hadErr = TRUE;
 306
 307             val = PyTuple_GetItem(result, 3);
 308             if (PyInt_Check(val))    *pageTo = PyInt_AsLong(val);
 309             else hadErr = TRUE;
 310         }
 311         else
 312             hadErr = TRUE;
 313
 314         if (hadErr) {
 315             PyErr_SetString(PyExc_TypeError, "GetPageInfo should return a tuple of 4 integers.");
 316             PyErr_Print();
 317         }
 318         Py_DECREF(result);
 319     }
 320     wxPyEndBlockThreads();
 321     if (! found)
 322         wxPrintout::GetPageInfo(minPage, maxPage, pageFrom, pageTo);
 323 }
 324
 325 void wxPyPrintout::base_GetPageInfo(int *minPage, int *maxPage, int *pageFrom, int *pageTo) {
 326     wxPrintout::GetPageInfo(minPage, maxPage, pageFrom, pageTo);
 327 }
 328
 329
 330 IMP_PYCALLBACK_BOOL_INTINT(wxPyPrintout, wxPrintout, OnBeginDocument);
 331 IMP_PYCALLBACK__(wxPyPrintout, wxPrintout, OnEndDocument);
 332 IMP_PYCALLBACK__(wxPyPrintout, wxPrintout, OnBeginPrinting);
 333 IMP_PYCALLBACK__(wxPyPrintout, wxPrintout, OnEndPrinting);
 334 IMP_PYCALLBACK__(wxPyPrintout, wxPrintout, OnPreparePrinting);
 335 IMP_PYCALLBACK_BOOL_INT_pure(wxPyPrintout, wxPrintout, OnPrintPage);
 336 IMP_PYCALLBACK_BOOL_INT(wxPyPrintout, wxPrintout, HasPage);
 337
 338
 339 %}
 340
 341
 342 // Now define the custom class for SWIGging
 343 %name(wxPrintout) class wxPyPrintout  : public wxObject {
 344 public:
 345     wxPyPrintout(const wxString& title = wxPyPrintoutTitleStr);
 346
 347     void _setCallbackInfo(PyObject* self, PyObject* _class);
 348     %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxPrintout)"
 349
 350     %addmethods {
 351         void Destroy() { delete self; }
 352     }
 353
 354     wxDC* GetDC();
 355     void GetPageSizeMM(int *OUTPUT, int *OUTPUT);
 356     void GetPageSizePixels(int *OUTPUT, int *OUTPUT);
 357     void GetPPIPrinter(int *OUTPUT, int *OUTPUT);
 358     void GetPPIScreen(int *OUTPUT, int *OUTPUT);
 359     bool IsPreview();
 360
 361     bool base_OnBeginDocument(int startPage, int endPage);
 362     void base_OnEndDocument();
 363     void base_OnBeginPrinting();
 364     void base_OnEndPrinting();
 365     void base_OnPreparePrinting();
 366     void base_GetPageInfo(int *OUTPUT, int *OUTPUT, int *OUTPUT, int *OUTPUT);
 367     bool base_HasPage(int page);
 368 };
 369
 370 //----------------------------------------------------------------------
 371
 372 enum wxPrinterError
 373 {
 374     wxPRINTER_NO_ERROR = 0,
 375     wxPRINTER_CANCELLED,
 376     wxPRINTER_ERROR
 377 };
 378
 379
 380 class wxPrinter : public wxObject {
 381 public:
 382     wxPrinter(wxPrintDialogData* data = NULL);
 383     ~wxPrinter();
 384
 385     void CreateAbortWindow(wxWindow* parent, wxPyPrintout* printout);
 386     wxPrintDialogData& GetPrintDialogData();
 387     bool Print(wxWindow *parent, wxPyPrintout *printout, int prompt=TRUE);
 388     wxDC* PrintDialog(wxWindow *parent);
 389     void ReportError(wxWindow *parent, wxPyPrintout *printout, const wxString& message);
 390     bool Setup(wxWindow *parent);
 391     bool GetAbort();
 392
 393     static wxPrinterError GetLastError();
 394 };
 395
 396 //----------------------------------------------------------------------
 397
 398 class wxPrintAbortDialog: public wxDialog
 399 {
 400 public:
 401     wxPrintAbortDialog(wxWindow *parent,
 402                        const wxString& title,
 403                        const wxPoint& pos = wxDefaultPosition,
 404                        const wxSize& size = wxDefaultSize,
 405                        long style = 0,
 406                        const wxString& name = wxPyDialogNameStr);
 407
 408 };
 409
 410 //----------------------------------------------------------------------
 411
 412 class wxPrintPreview : public wxObject {
 413 public:
 414     wxPrintPreview(wxPyPrintout* printout,
 415                    wxPyPrintout* printoutForPrinting,
 416                    wxPrintData* data=NULL);
 417
 418     virtual bool SetCurrentPage(int pageNum);
 419     int GetCurrentPage();
 420
 421     void SetPrintout(wxPyPrintout *printout);
 422     wxPyPrintout *GetPrintout();
 423     wxPyPrintout *GetPrintoutForPrinting();
 424
 425     void SetFrame(wxFrame *frame);
 426     void SetCanvas(wxPreviewCanvas *canvas);
 427
 428     virtual wxFrame *GetFrame();
 429     virtual wxPreviewCanvas *GetCanvas();
 430
 431     // The preview canvas should call this from OnPaint
 432     virtual bool PaintPage(wxPreviewCanvas *canvas, wxDC& dc);
 433
 434     // This draws a blank page onto the preview canvas
 435     virtual bool DrawBlankPage(wxPreviewCanvas *canvas, wxDC& dc);
 436
 437     // This is called by wxPrintPreview to render a page into a wxMemoryDC.
 438     virtual bool RenderPage(int pageNum);
 439
 440     // Adjusts the scrollbars for the current scale
 441     virtual void AdjustScrollbars(wxPreviewCanvas *canvas);
 442
 443     wxPrintDialogData& GetPrintDialogData();
 444
 445     virtual void SetZoom(int percent);
 446     int GetZoom();
 447
 448     int GetMaxPage();
 449     int GetMinPage();
 450
 451     bool Ok();
 452     void SetOk(bool ok);
 453
 454     virtual bool Print(bool interactive);
 455     virtual void DetermineScaling();
 456
 457     %pragma(python) addtoclass = "def __nonzero__(self): return self.Ok()"
 458 };
 459
 460
 461 class wxPreviewFrame : public wxFrame {
 462 public:
 463     wxPreviewFrame(wxPrintPreview* preview, wxFrame* parent, const wxString& title,
 464                    const wxPoint& pos = wxDefaultPosition,
 465                    const wxSize&  size = wxDefaultSize,
 466                    long style = wxDEFAULT_FRAME_STYLE,
 467                    const wxString& name = wxPyFrameNameStr);
 468
 469     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 470
 471     void Initialize();
 472     void CreateControlBar();
 473     void CreateCanvas();
 474
 475     wxPreviewControlBar* GetControlBar() const;
 476 };
 477
 478
 479 class wxPreviewCanvas: public wxScrolledWindow
 480 {
 481 public:
 482     wxPreviewCanvas(wxPrintPreview *preview,
 483                     wxWindow *parent,
 484                     const wxPoint& pos = wxDefaultPosition,
 485                     const wxSize& size = wxDefaultSize,
 486                     long style = 0,
 487                     const wxString& name = wxPyPreviewCanvasNameStr);
 488     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 489 };
 490
 491
 492
 493 enum {
 494     wxPREVIEW_PRINT,
 495     wxPREVIEW_PREVIOUS,
 496     wxPREVIEW_NEXT,
 497     wxPREVIEW_ZOOM,
 498     wxPREVIEW_FIRST,
 499     wxPREVIEW_LAST,
 500     wxPREVIEW_GOTO,
 501     wxPREVIEW_DEFAULT,
 502
 503     wxID_PREVIEW_CLOSE,
 504     wxID_PREVIEW_NEXT,
 505     wxID_PREVIEW_PREVIOUS,
 506     wxID_PREVIEW_PRINT,
 507     wxID_PREVIEW_ZOOM,
 508     wxID_PREVIEW_FIRST,
 509     wxID_PREVIEW_LAST,
 510     wxID_PREVIEW_GOTO
 511 };
 512
 513 class wxPreviewControlBar: public wxPanel
 514 {
 515 public:
 516     wxPreviewControlBar(wxPrintPreview *preview,
 517                         long buttons,
 518                         wxWindow *parent,
 519                         const wxPoint& pos = wxDefaultPosition,
 520                         const wxSize& size = wxDefaultSize,
 521                         long style = wxTAB_TRAVERSAL,
 522                         const wxString& name = wxPyPanelNameStr);
 523     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 524
 525     int GetZoomControl();
 526     void SetZoomControl(int zoom);
 527     wxPrintPreview* GetPrintPreview();
 528
 529     void OnNext();
 530     void OnPrevious();
 531     void OnFirst();
 532     void OnLast();
 533     void OnGoto();
 534 };
 535
 536
 537 //----------------------------------------------------------------------
 538 // Python-derivable versions of the above preview classes
 539
 540 %{
 541
 542 #define DEC_PYCALLBACK_BOOL_PREWINDC(CBNAME)                                    \
 543     bool CBNAME(wxPreviewCanvas* a, wxDC& b);                                   \
 544     bool base_##CBNAME(wxPreviewCanvas* a, wxDC& b)
 545
 546
 547 #define IMP_PYCALLBACK_BOOL_PREWINDC(CLASS, PCLASS, CBNAME)                     \
 548     bool CLASS::CBNAME(wxPreviewCanvas* a, wxDC& b) {                           \
 549         bool rval=FALSE;                                                        \
 550         bool found;                                                             \
 551         wxPyBeginBlockThreads();                                                \
 552         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 553             PyObject* win = wxPyMake_wxObject(a);                               \
 554             PyObject* dc  = wxPyMake_wxObject(&b);                              \
 555             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", win, dc));\
 556             Py_DECREF(win);                                                     \
 557             Py_DECREF(dc);                                                      \
 558         }                                                                       \
 559         wxPyEndBlockThreads();                                                  \
 560         if (! found)                                                            \
 561             rval = PCLASS::CBNAME(a, b);                                        \
 562         return rval;                                                            \
 563     }                                                                           \
 564     bool CLASS::base_##CBNAME(wxPreviewCanvas* a, wxDC& b) {                    \
 565         return PCLASS::CBNAME(a, b);                                            \
 566     }
 567
 568
 569
 570
 571 class wxPyPrintPreview : public wxPrintPreview
 572 {
 573     DECLARE_CLASS(wxPyPrintPreview)
 574 public:
 575     wxPyPrintPreview(wxPyPrintout* printout,
 576                      wxPyPrintout* printoutForPrinting,
 577                      wxPrintData* data=NULL)
 578         : wxPrintPreview(printout, printoutForPrinting, data)
 579     {}
 580
 581     DEC_PYCALLBACK_BOOL_INT(SetCurrentPage);
 582     DEC_PYCALLBACK_BOOL_PREWINDC(PaintPage);
 583     DEC_PYCALLBACK_BOOL_PREWINDC(DrawBlankPage);
 584     DEC_PYCALLBACK_BOOL_INT(RenderPage);
 585     DEC_PYCALLBACK_VOID_INT(SetZoom);
 586     DEC_PYCALLBACK_BOOL_BOOL(Print);
 587     DEC_PYCALLBACK_VOID_(DetermineScaling);
 588
 589     PYPRIVATE;
 590 };
 591
 592 // Stupid renamed classes...  Fix this in 2.5...
 593 #if defined(__WXMSW__)
 594 IMPLEMENT_CLASS( wxPyPrintPreview, wxWindowsPrintPreview );
 595 #elif defined(__WXMAC__)
 596 IMPLEMENT_CLASS( wxPyPrintPreview, wxMacPrintPreview );
 597 #else
 598 IMPLEMENT_CLASS( wxPyPrintPreview, wxPostScriptPrintPreview );
 599 #endif
 600
 601 IMP_PYCALLBACK_BOOL_INT     (wxPyPrintPreview, wxPrintPreview, SetCurrentPage);
 602 IMP_PYCALLBACK_BOOL_PREWINDC(wxPyPrintPreview, wxPrintPreview, PaintPage);
 603 IMP_PYCALLBACK_BOOL_PREWINDC(wxPyPrintPreview, wxPrintPreview, DrawBlankPage);
 604 IMP_PYCALLBACK_BOOL_INT     (wxPyPrintPreview, wxPrintPreview, RenderPage);
 605 IMP_PYCALLBACK_VOID_INT     (wxPyPrintPreview, wxPrintPreview, SetZoom);
 606 IMP_PYCALLBACK_BOOL_BOOL    (wxPyPrintPreview, wxPrintPreview, Print);
 607 IMP_PYCALLBACK_VOID_        (wxPyPrintPreview, wxPrintPreview, DetermineScaling);
 608 %}
 609
 610
 611 class wxPyPrintPreview : public wxPrintPreview
 612 {
 613 public:
 614     wxPyPrintPreview(wxPyPrintout* printout,
 615                      wxPyPrintout* printoutForPrinting,
 616                      wxPrintData* data=NULL);
 617
 618     void _setCallbackInfo(PyObject* self, PyObject* _class);
 619     %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxPyPrintPreview)"
 620
 621     bool base_SetCurrentPage(int pageNum);
 622     bool base_PaintPage(wxPreviewCanvas *canvas, wxDC& dc);
 623     bool base_DrawBlankPage(wxPreviewCanvas *canvas, wxDC& dc);
 624     bool base_RenderPage(int pageNum);
 625     void base_SetZoom(int percent);
 626     bool base_Print(bool interactive);
 627     void base_DetermineScaling();
 628 };
 629
 630
 631
 632
 633 %{
 634 class wxPyPreviewFrame : public wxPreviewFrame
 635 {
 636     DECLARE_CLASS(wxPyPreviewFrame);
 637 public:
 638     wxPyPreviewFrame(wxPrintPreview* preview, wxFrame* parent,
 639                      const wxString& title,
 640                      const wxPoint& pos = wxDefaultPosition,
 641                      const wxSize&  size = wxDefaultSize,
 642                      long style = wxDEFAULT_FRAME_STYLE,
 643                      const wxString& name = wxPyFrameNameStr)
 644         : wxPreviewFrame(preview, parent, title, pos, size, style, name)
 645     {}
 646
 647     void SetPreviewCanvas(wxPreviewCanvas* canvas) { m_previewCanvas = canvas; }
 648     void SetControlBar(wxPreviewControlBar* bar) { m_controlBar = bar; }
 649
 650     DEC_PYCALLBACK_VOID_(Initialize);
 651     DEC_PYCALLBACK_VOID_(CreateCanvas);
 652     DEC_PYCALLBACK_VOID_(CreateControlBar);
 653
 654     PYPRIVATE;
 655 };
 656
 657 IMPLEMENT_CLASS(wxPyPreviewFrame, wxPreviewFrame);
 658
 659 IMP_PYCALLBACK_VOID_(wxPyPreviewFrame, wxPreviewFrame, Initialize);
 660 IMP_PYCALLBACK_VOID_(wxPyPreviewFrame, wxPreviewFrame, CreateCanvas);
 661 IMP_PYCALLBACK_VOID_(wxPyPreviewFrame, wxPreviewFrame, CreateControlBar);
 662 %}
 663
 664 class wxPyPreviewFrame : public wxPreviewFrame
 665 {
 666 public:
 667     wxPyPreviewFrame(wxPrintPreview* preview, wxFrame* parent,
 668                      const wxString& title,
 669                      const wxPoint& pos = wxDefaultPosition,
 670                      const wxSize&  size = wxDefaultSize,
 671                      long style = wxDEFAULT_FRAME_STYLE,
 672                      const wxString& name = wxPyFrameNameStr);
 673
 674     void _setCallbackInfo(PyObject* self, PyObject* _class);
 675     %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxPyPreviewFrame)"
 676     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 677
 678     void SetPreviewCanvas(wxPreviewCanvas* canvas);
 679     void SetControlBar(wxPreviewControlBar* bar);
 680
 681     void base_Initialize();
 682     void base_CreateCanvas();
 683     void base_CreateControlBar();
 684 };
 685
 686
 687
 688
 689 %{
 690 class wxPyPreviewControlBar : public wxPreviewControlBar
 691 {
 692     DECLARE_CLASS(wxPyPreviewControlBar);
 693 public:
 694     wxPyPreviewControlBar(wxPrintPreview *preview,
 695                           long buttons,
 696                           wxWindow *parent,
 697                           const wxPoint& pos = wxDefaultPosition,
 698                           const wxSize& size = wxDefaultSize,
 699                           long style = 0,
 700                           const wxString& name = wxPyPanelNameStr)
 701         : wxPreviewControlBar(preview, buttons, parent, pos, size, style, name)
 702     {}
 703
 704     void SetPrintPreview(wxPrintPreview* preview) { m_printPreview = preview; }
 705
 706     DEC_PYCALLBACK_VOID_(CreateButtons);
 707     DEC_PYCALLBACK_VOID_INT(SetZoomControl);
 708
 709     PYPRIVATE;
 710 };
 711
 712 IMPLEMENT_CLASS(wxPyPreviewControlBar, wxPreviewControlBar);
 713 IMP_PYCALLBACK_VOID_(wxPyPreviewControlBar, wxPreviewControlBar, CreateButtons);
 714 IMP_PYCALLBACK_VOID_INT(wxPyPreviewControlBar, wxPreviewControlBar, SetZoomControl);
 715 %}
 716
 717 class wxPyPreviewControlBar : public wxPreviewControlBar
 718 {
 719 public:
 720     wxPyPreviewControlBar(wxPrintPreview *preview,
 721                           long buttons,
 722                           wxWindow *parent,
 723                           const wxPoint& pos = wxDefaultPosition,
 724                           const wxSize& size = wxDefaultSize,
 725                           long style = 0,
 726                           const wxString& name = wxPyPanelNameStr);
 727
 728     void _setCallbackInfo(PyObject* self, PyObject* _class);
 729     %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxPyPreviewControlBar)"
 730     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 731
 732     void SetPrintPreview(wxPrintPreview* preview);
 733
 734     void base_CreateButtons();
 735     void base_SetZoomControl(int zoom);
 736 };
 737
 738
 739 //----------------------------------------------------------------------
 740
 741 %init %{
 742     wxPyPtrTypeMap_Add("wxPrintout", "wxPyPrintout");
 743 %}
 744
 745 //----------------------------------------------------------------------
 746 //----------------------------------------------------------------------
 747
 748
 749
 750