wxPython/src/_printfw.i

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