wxPython/src/html.i

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        html.i
   3 // Purpose:     SWIG definitions of html classes
   4 //
   5 // Author:      Robin Dunn
   6 //
   7 // Created:     25-nov-1998
   8 // RCS-ID:      $Id$
   9 // Copyright:   (c) 1998 by Total Control Software
  10 // Licence:     wxWindows license
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13
  14 %module html
  15
  16 %{
  17 #include "export.h"
  18 #include <wx/html/htmlwin.h>
  19 #include <wx/html/htmprint.h>
  20 #include <wx/image.h>
  21 #include <wx/fs_zip.h>
  22 #include <wx/fs_inet.h>
  23 #include <wx/wfstream.h>
  24
  25 #include "printfw.h"
  26 %}
  27
  28 //---------------------------------------------------------------------------
  29
  30 %include typemaps.i
  31 %include my_typemaps.i
  32
  33 %extern wx.i
  34 %extern windows.i
  35 %extern _defs.i
  36 %extern events.i
  37 %extern controls.i
  38 %extern controls2.i
  39 %extern printfw.i
  40
  41 %extern utils.i
  42
  43 %pragma(python) code = "import wx"
  44
  45
  46 //---------------------------------------------------------------------------
  47
  48 enum {
  49     wxHTML_ALIGN_LEFT,
  50     wxHTML_ALIGN_CENTER,
  51     wxHTML_ALIGN_RIGHT,
  52     wxHTML_ALIGN_BOTTOM,
  53     wxHTML_ALIGN_TOP,
  54
  55     wxHTML_CLR_FOREGROUND,
  56     wxHTML_CLR_BACKGROUND,
  57
  58     wxHTML_UNITS_PIXELS,
  59     wxHTML_UNITS_PERCENT,
  60
  61     wxHTML_INDENT_LEFT,
  62     wxHTML_INDENT_RIGHT,
  63     wxHTML_INDENT_TOP,
  64     wxHTML_INDENT_BOTTOM,
  65
  66     wxHTML_INDENT_HORIZONTAL,
  67     wxHTML_INDENT_VERTICAL,
  68     wxHTML_INDENT_ALL,
  69
  70     wxHTML_COND_ISANCHOR,
  71     wxHTML_COND_ISIMAGEMAP,
  72     wxHTML_COND_USER,
  73 };
  74
  75
  76 enum {
  77     wxHW_SCROLLBAR_NEVER,
  78     wxHW_SCROLLBAR_AUTO,
  79 };
  80
  81
  82 // enums for wxHtmlWindow::OnOpeningURL
  83 enum wxHtmlOpeningStatus
  84 {
  85     wxHTML_OPEN,
  86     wxHTML_BLOCK,
  87     wxHTML_REDIRECT
  88 };
  89
  90 enum wxHtmlURLType
  91 {
  92     wxHTML_URL_PAGE,
  93     wxHTML_URL_IMAGE,
  94     wxHTML_URL_OTHER
  95 };
  96
  97 //---------------------------------------------------------------------------
  98
  99 class wxHtmlLinkInfo : public wxObject {
 100 public:
 101     wxHtmlLinkInfo(const wxString& href, const wxString& target = wxEmptyString);
 102     wxString GetHref();
 103     wxString GetTarget();
 104     wxMouseEvent* GetEvent();
 105     wxHtmlCell* GetHtmlCell();
 106
 107     void SetEvent(const wxMouseEvent *e);
 108     void SetHtmlCell(const wxHtmlCell * e);
 109 };
 110
 111 //---------------------------------------------------------------------------
 112
 113 class wxHtmlTag : public wxObject {
 114 public:
 115     // Never need to create a new tag from Python...
 116     //wxHtmlTag(const wxString& source, int pos, int end_pos, wxHtmlTagsCache* cache);
 117
 118     wxString GetName();
 119     bool HasParam(const wxString& par);
 120     wxString GetParam(const wxString& par, int with_commas = FALSE);
 121
 122     // Can't do this one as-is, but GetParam should be enough...
 123     //int ScanParam(const wxString& par, const char *format, void* param);
 124
 125     wxString GetAllParams();
 126     bool HasEnding();
 127     int GetBeginPos();
 128     int GetEndPos1();
 129     int GetEndPos2();
 130 };
 131
 132
 133 //---------------------------------------------------------------------------
 134
 135 class wxHtmlParser : public wxObject {
 136 public:
 137     // wxHtmlParser();  This is an abstract base class...
 138
 139     void SetFS(wxFileSystem *fs);
 140     wxFileSystem* GetFS();
 141     wxObject* Parse(const wxString& source);
 142     void InitParser(const wxString& source);
 143     void DoneParser();
 144     void DoParsing(int begin_pos, int end_pos);
 145     // wxObject* GetProduct();
 146     void AddTagHandler(wxHtmlTagHandler *handler);
 147     wxString* GetSource();
 148     void PushTagHandler(wxHtmlTagHandler* handler, wxString tags);
 149     void PopTagHandler();
 150
 151     // virtual wxFSFile *OpenURL(wxHtmlURLType type, const wxString& url) const;
 152
 153     // void AddText(const char* txt) = 0;
 154     // void AddTag(const wxHtmlTag& tag);
 155 };
 156
 157
 158 //---------------------------------------------------------------------------
 159
 160 class wxHtmlWinParser : public wxHtmlParser {
 161 public:
 162     wxHtmlWinParser(wxHtmlWindow *wnd = NULL);
 163
 164     void SetDC(wxDC *dc);
 165     wxDC* GetDC();
 166     int GetCharHeight();
 167     int GetCharWidth();
 168     wxHtmlWindow* GetWindow();
 169     //void SetFonts(wxString normal_face, wxString fixed_face, int *LIST);
 170     %addmethods {
 171         void SetFonts(wxString normal_face, wxString fixed_face, PyObject* sizes) {
 172             int* temp = int_LIST_helper(sizes);
 173             if (temp) {
 174                 self->SetFonts(normal_face, fixed_face, temp);
 175                 delete [] temp;
 176             }
 177         }
 178     }
 179
 180     wxHtmlContainerCell* GetContainer();
 181     wxHtmlContainerCell* OpenContainer();
 182     wxHtmlContainerCell *SetContainer(wxHtmlContainerCell *c);
 183     wxHtmlContainerCell* CloseContainer();
 184
 185     int GetFontSize();
 186     void SetFontSize(int s);
 187     int GetFontBold();
 188     void SetFontBold(int x);
 189     int GetFontItalic();
 190     void SetFontItalic(int x);
 191     int GetFontUnderlined();
 192     void SetFontUnderlined(int x);
 193     int GetFontFixed();
 194     void SetFontFixed(int x);
 195     int GetAlign();
 196     void SetAlign(int a);
 197     wxColour GetLinkColor();
 198     void SetLinkColor(const wxColour& clr);
 199     wxColour GetActualColor();
 200     void SetActualColor(const wxColour& clr);
 201     void SetLink(const wxString& link);
 202     wxFont* CreateCurrentFont();
 203     wxHtmlLinkInfo GetLink();
 204
 205 };
 206
 207
 208
 209 //---------------------------------------------------------------------------
 210
 211 %{
 212 class wxPyHtmlTagHandler : public wxHtmlTagHandler {
 213     DECLARE_DYNAMIC_CLASS(wxPyHtmlTagHandler);
 214 public:
 215     wxPyHtmlTagHandler() : wxHtmlTagHandler() {};
 216
 217     wxHtmlParser* GetParser() { return m_Parser; }
 218     void ParseInner(const wxHtmlTag& tag) { wxHtmlTagHandler::ParseInner(tag); }
 219
 220     DEC_PYCALLBACK_STRING__pure(GetSupportedTags);
 221     DEC_PYCALLBACK_BOOL_TAG_pure(HandleTag);
 222
 223     PYPRIVATE;
 224 };
 225
 226 IMPLEMENT_DYNAMIC_CLASS(wxPyHtmlTagHandler, wxHtmlTagHandler);
 227
 228 IMP_PYCALLBACK_STRING__pure(wxPyHtmlTagHandler, wxHtmlTagHandler, GetSupportedTags);
 229 IMP_PYCALLBACK_BOOL_TAG_pure(wxPyHtmlTagHandler, wxHtmlTagHandler, HandleTag);
 230 %}
 231
 232
 233 %name(wxHtmlTagHandler) class wxPyHtmlTagHandler : public wxObject {
 234 public:
 235     wxPyHtmlTagHandler();
 236
 237     void _setCallbackInfo(PyObject* self, PyObject* _class);
 238     %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxHtmlTagHandler)"
 239
 240     void SetParser(wxHtmlParser *parser);
 241     wxHtmlParser* GetParser();
 242     void ParseInner(const wxHtmlTag& tag);
 243 };
 244
 245
 246 //---------------------------------------------------------------------------
 247
 248 %{
 249 class wxPyHtmlWinTagHandler : public wxHtmlWinTagHandler {
 250     DECLARE_DYNAMIC_CLASS(wxPyHtmlWinTagHandler);
 251 public:
 252     wxPyHtmlWinTagHandler() : wxHtmlWinTagHandler() {};
 253
 254     wxHtmlWinParser* GetParser() { return m_WParser; }
 255     void ParseInner(const wxHtmlTag& tag)
 256         { wxHtmlWinTagHandler::ParseInner(tag); }
 257
 258     DEC_PYCALLBACK_STRING__pure(GetSupportedTags);
 259     DEC_PYCALLBACK_BOOL_TAG_pure(HandleTag);
 260
 261     PYPRIVATE;
 262 };
 263
 264 IMPLEMENT_DYNAMIC_CLASS( wxPyHtmlWinTagHandler, wxHtmlWinTagHandler);
 265
 266 IMP_PYCALLBACK_STRING__pure(wxPyHtmlWinTagHandler, wxHtmlWinTagHandler, GetSupportedTags);
 267 IMP_PYCALLBACK_BOOL_TAG_pure(wxPyHtmlWinTagHandler, wxHtmlWinTagHandler, HandleTag);
 268 %}
 269
 270
 271 %name(wxHtmlWinTagHandler) class wxPyHtmlWinTagHandler : public wxPyHtmlTagHandler {
 272 public:
 273     wxPyHtmlWinTagHandler();
 274
 275     void _setCallbackInfo(PyObject* self, PyObject* _class);
 276     %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxHtmlWinTagHandler)"
 277
 278     void SetParser(wxHtmlParser *parser);
 279     wxHtmlWinParser* GetParser();
 280     void ParseInner(const wxHtmlTag& tag);
 281 };
 282
 283
 284 //---------------------------------------------------------------------------
 285
 286 %{
 287
 288 class wxPyHtmlTagsModule : public wxHtmlTagsModule {
 289 public:
 290     wxPyHtmlTagsModule(PyObject* thc) : wxHtmlTagsModule() {
 291         m_tagHandlerClass = thc;
 292         Py_INCREF(m_tagHandlerClass);
 293         RegisterModule(this);
 294         wxHtmlWinParser::AddModule(this);
 295     }
 296
 297     void OnExit() {
 298         wxPyBeginBlockThreads();
 299         Py_DECREF(m_tagHandlerClass);
 300         m_tagHandlerClass = NULL;
 301         for (size_t x=0; x < m_objArray.GetCount(); x++) {
 302             PyObject* obj = (PyObject*)m_objArray.Item(x);
 303             Py_DECREF(obj);
 304         }
 305         wxPyEndBlockThreads();
 306     };
 307
 308     void FillHandlersTable(wxHtmlWinParser *parser) {
 309         // Wave our magic wand...  (if it works it's a miracle!  ;-)
 310
 311         // First, make a new instance of the tag handler
 312         wxPyBeginBlockThreads();
 313         PyObject* arg = Py_BuildValue("()");
 314         PyObject* obj = PyInstance_New(m_tagHandlerClass, arg, NULL);
 315         Py_DECREF(arg);
 316         wxPyEndBlockThreads();
 317
 318         // now figure out where it's C++ object is...
 319         wxPyHtmlWinTagHandler* thPtr;
 320         if (SWIG_GetPtrObj(obj, (void **)&thPtr, "_wxPyHtmlWinTagHandler_p"))
 321             return;
 322
 323         // add it,
 324         parser->AddTagHandler(thPtr);
 325
 326         // and track it.
 327         m_objArray.Add(obj);
 328     }
 329
 330 private:
 331     PyObject*           m_tagHandlerClass;
 332     wxArrayPtrVoid      m_objArray;
 333
 334 };
 335 %}
 336
 337
 338
 339 %inline %{
 340     void wxHtmlWinParser_AddTagHandler(PyObject* tagHandlerClass) {
 341         // Dynamically create a new wxModule.  Refcounts tagHandlerClass
 342         // and adds itself to the wxModules list and to the wxHtmlWinParser.
 343         new wxPyHtmlTagsModule(tagHandlerClass);
 344     }
 345 %}
 346
 347
 348 //---------------------------------------------------------------------------
 349 //---------------------------------------------------------------------------
 350
 351 class wxHtmlCell : public wxObject {
 352 public:
 353     wxHtmlCell();
 354
 355     int GetPosX();
 356     int GetPosY();
 357     int GetWidth();
 358     int GetHeight();
 359     int GetDescent();
 360     wxHtmlLinkInfo* GetLink(int x = 0, int y = 0);
 361     wxHtmlCell* GetNext();
 362     wxHtmlContainerCell* GetParent();
 363     void SetLink(const wxHtmlLinkInfo& link);
 364     void SetNext(wxHtmlCell *cell);
 365     void SetParent(wxHtmlContainerCell *p);
 366     void SetPos(int x, int y);
 367     void Layout(int w);
 368     void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2);
 369     void DrawInvisible(wxDC& dc, int x, int y);
 370     const wxHtmlCell* Find(int condition, const void* param);
 371
 372     bool AdjustPagebreak(int * pagebreak);
 373     void SetCanLiveOnPagebreak(bool can);
 374
 375 };
 376
 377
 378 class  wxHtmlWordCell : public wxHtmlCell
 379 {
 380 public:
 381     wxHtmlWordCell(const wxString& word, wxDC& dc);
 382 };
 383
 384
 385 class wxHtmlContainerCell : public wxHtmlCell {
 386 public:
 387     wxHtmlContainerCell(wxHtmlContainerCell *parent);
 388
 389     void InsertCell(wxHtmlCell *cell);
 390     void SetAlignHor(int al);
 391     int GetAlignHor();
 392     void SetAlignVer(int al);
 393     int GetAlignVer();
 394     void SetIndent(int i, int what, int units = wxHTML_UNITS_PIXELS);
 395     int GetIndent(int ind);
 396     int GetIndentUnits(int ind);
 397     void SetAlign(const wxHtmlTag& tag);
 398     void SetWidthFloat(int w, int units);
 399     %name(SetWidthFloatFromTag)void SetWidthFloat(const wxHtmlTag& tag);
 400     void SetMinHeight(int h, int align = wxHTML_ALIGN_TOP);
 401     void SetBackgroundColour(const wxColour& clr);
 402     void SetBorder(const wxColour& clr1, const wxColour& clr2);
 403     wxHtmlCell* GetFirstCell();
 404 };
 405
 406
 407
 408 class wxHtmlColourCell : public wxHtmlCell {
 409 public:
 410     wxHtmlColourCell(wxColour clr, int flags = wxHTML_CLR_FOREGROUND);
 411
 412 };
 413
 414
 415 class  wxHtmlFontCell : public wxHtmlCell
 416 {
 417 public:
 418     wxHtmlFontCell(wxFont *font);
 419 };
 420
 421
 422 class wxHtmlWidgetCell : public wxHtmlCell {
 423 public:
 424     wxHtmlWidgetCell(wxWindow* wnd, int w = 0);
 425
 426 };
 427
 428
 429
 430 //---------------------------------------------------------------------------
 431 //---------------------------------------------------------------------------
 432 //---------------------------------------------------------------------------
 433
 434 %{
 435 class wxPyHtmlWindow : public wxHtmlWindow {
 436     DECLARE_ABSTRACT_CLASS(wxPyHtmlWindow);
 437 public:
 438     wxPyHtmlWindow(wxWindow *parent, wxWindowID id = -1,
 439                    const wxPoint& pos = wxDefaultPosition,
 440                    const wxSize& size = wxDefaultSize,
 441                    long style = wxHW_SCROLLBAR_AUTO,
 442                    const wxString& name = "htmlWindow")
 443         : wxHtmlWindow(parent, id, pos, size, style, name)  {};
 444     wxPyHtmlWindow() : wxHtmlWindow() {};
 445
 446     bool ScrollToAnchor(const wxString& anchor) {
 447         return wxHtmlWindow::ScrollToAnchor(anchor);
 448     }
 449
 450     bool HasAnchor(const wxString& anchor) {
 451         const wxHtmlCell *c = m_Cell->Find(wxHTML_COND_ISANCHOR, &anchor);
 452         return c!=NULL;
 453     }
 454
 455     void OnLinkClicked(const wxHtmlLinkInfo& link);
 456     void base_OnLinkClicked(const wxHtmlLinkInfo& link);
 457
 458     wxHtmlOpeningStatus OnOpeningURL(wxHtmlURLType type,
 459                                       const wxString& url,
 460                                       wxString *redirect) const;
 461
 462     DEC_PYCALLBACK__STRING(OnSetTitle);
 463     DEC_PYCALLBACK__CELLINTINT(OnCellMouseHover);
 464     DEC_PYCALLBACK__CELLINTINTME(OnCellClicked);
 465 //     DEC_PYCALLBACK_BOOL_STRING(OnOpeningURL);
 466     PYPRIVATE;
 467 };
 468
 469 IMPLEMENT_ABSTRACT_CLASS( wxPyHtmlWindow, wxHtmlWindow );
 470 IMP_PYCALLBACK__STRING(wxPyHtmlWindow, wxHtmlWindow, OnSetTitle);
 471 IMP_PYCALLBACK__CELLINTINT(wxPyHtmlWindow, wxHtmlWindow, OnCellMouseHover);
 472 IMP_PYCALLBACK__CELLINTINTME(wxPyHtmlWindow, wxHtmlWindow, OnCellClicked);
 473 // IMP_PYCALLBACK_BOOL_STRING(wxPyHtmlWindow, wxHtmlWindow, OnOpeningURL);
 474
 475
 476 void wxPyHtmlWindow::OnLinkClicked(const wxHtmlLinkInfo& link) {
 477     bool found;
 478     wxPyBeginBlockThreads();
 479     if ((found = wxPyCBH_findCallback(m_myInst, "OnLinkClicked"))) {
 480         PyObject* obj = wxPyConstructObject((void*)&link, "wxHtmlLinkInfo", 0);
 481         wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));
 482         Py_DECREF(obj);
 483     }
 484     wxPyEndBlockThreads();
 485     if (! found)
 486         wxHtmlWindow::OnLinkClicked(link);
 487 }
 488 void wxPyHtmlWindow::base_OnLinkClicked(const wxHtmlLinkInfo& link) {
 489     wxHtmlWindow::OnLinkClicked(link);
 490 }
 491
 492
 493 wxHtmlOpeningStatus wxPyHtmlWindow::OnOpeningURL(wxHtmlURLType type,
 494                                                  const wxString& url,
 495                                                  wxString *redirect) const {
 496     bool found;
 497     wxHtmlOpeningStatus rval;
 498     wxPyBeginBlockThreads();
 499     if ((found = wxPyCBH_findCallback(m_myInst, "OnOpeningURL"))) {
 500         PyObject* ro;
 501         ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(iO)", type, wx2PyString(url)));
 502         if (PyString_Check(ro)
 503 #if PYTHON_API_VERSION >= 1009
 504             || PyUnicode_Check(ro)
 505 #endif
 506             ) {
 507             *redirect = Py2wxString(ro);
 508             rval = wxHTML_REDIRECT;
 509         }
 510         else {
 511             PyObject* num = PyNumber_Int(ro);
 512             rval = (wxHtmlOpeningStatus)PyInt_AsLong(num);
 513             Py_DECREF(num);
 514         }
 515         Py_DECREF(ro);
 516     }
 517     wxPyEndBlockThreads();
 518     if (! found)
 519         rval = wxHtmlWindow::OnOpeningURL(type, url, redirect);
 520     return rval;
 521 }
 522
 523
 524 %}
 525
 526
 527
 528 %name(wxHtmlWindow) class wxPyHtmlWindow : public wxScrolledWindow {
 529 public:
 530     wxPyHtmlWindow(wxWindow *parent, int id = -1,
 531                  wxPoint& pos = wxDefaultPosition,
 532                  wxSize& size = wxDefaultSize,
 533                  int flags=wxHW_SCROLLBAR_AUTO,
 534                  char* name = "htmlWindow");
 535     %name(wxPreHtmlWindow)wxPyHtmlWindow();
 536
 537     bool Create(wxWindow *parent, int id = -1,
 538                 wxPoint& pos = wxDefaultPosition,
 539                 wxSize& size = wxDefaultSize,
 540                 int flags=wxHW_SCROLLBAR_AUTO,
 541                 char* name = "htmlWindow");
 542
 543
 544     void _setCallbackInfo(PyObject* self, PyObject* _class);
 545     %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxHtmlWindow)"
 546     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 547     %pragma(python) addtomethod = "wxPreHtmlWindow:val._setOORInfo(val)"
 548
 549     bool SetPage(const wxString& source);
 550     bool LoadPage(const wxString& location);
 551     bool AppendToPage(const wxString& source);
 552     wxString GetOpenedPage();
 553     wxString GetOpenedAnchor();
 554     wxString GetOpenedPageTitle();
 555
 556     void SetRelatedFrame(wxFrame* frame, const char* format);
 557     wxFrame* GetRelatedFrame();
 558     void SetRelatedStatusBar(int bar);
 559
 560     //void SetFonts(wxString normal_face, wxString fixed_face, int *LIST);
 561     %addmethods {
 562         void SetFonts(wxString normal_face, wxString fixed_face, PyObject* sizes) {
 563             int* temp = int_LIST_helper(sizes);
 564             if (temp) {
 565                 self->SetFonts(normal_face, fixed_face, temp);
 566                 delete [] temp;
 567             }
 568         }
 569     }
 570
 571     void SetTitle(const wxString& title);
 572     void SetBorders(int b);
 573     void ReadCustomization(wxConfigBase *cfg, wxString path = wxEmptyString);
 574     void WriteCustomization(wxConfigBase *cfg, wxString path = wxEmptyString);
 575     bool HistoryBack();
 576     bool HistoryForward();
 577     bool HistoryCanBack();
 578     bool HistoryCanForward();
 579     void HistoryClear();
 580     wxHtmlContainerCell* GetInternalRepresentation();
 581     wxHtmlWinParser* GetParser();
 582
 583     bool ScrollToAnchor(const wxString& anchor);
 584     bool HasAnchor(const wxString& anchor);
 585
 586     void base_OnLinkClicked(const wxHtmlLinkInfo& link);
 587     void base_OnSetTitle(const char* title);
 588     void base_OnCellMouseHover(wxHtmlCell *cell, wxCoord x, wxCoord y);
 589     void base_OnCellClicked(wxHtmlCell *cell,
 590                             wxCoord x, wxCoord y,
 591                             const wxMouseEvent& event);
 592 };
 593
 594 // Static methods are mapped to stand-alone functions
 595 %inline %{
 596     void wxHtmlWindow_AddFilter(wxHtmlFilter *filter) {
 597         wxHtmlWindow::AddFilter(filter);
 598     }
 599 %}
 600
 601
 602 //---------------------------------------------------------------------------
 603 //---------------------------------------------------------------------------
 604
 605
 606 class wxHtmlDCRenderer : public wxObject {
 607 public:
 608     wxHtmlDCRenderer();
 609     ~wxHtmlDCRenderer();
 610
 611     void SetDC(wxDC *dc, int maxwidth);
 612     void SetSize(int width, int height);
 613     void SetHtmlText(const wxString& html,
 614                      const wxString& basepath = wxEmptyString,
 615                      bool isdir = TRUE);
 616     int Render(int x, int y, int from = 0, int dont_render = FALSE);
 617     int GetTotalHeight();
 618                 // returns total height of the html document
 619                 // (compare Render's return value with this)
 620 };
 621
 622 enum {
 623     wxPAGE_ODD,
 624     wxPAGE_EVEN,
 625     wxPAGE_ALL
 626 };
 627
 628
 629 class wxHtmlPrintout : public wxPyPrintout {
 630 public:
 631     wxHtmlPrintout(const char* title = "Printout");
 632     //~wxHtmlPrintout();   wxPrintPreview object takes ownership...
 633
 634     void SetHtmlText(const wxString& html,
 635                      const wxString &basepath = wxEmptyString,
 636                      bool isdir = TRUE);
 637     void SetHtmlFile(const wxString &htmlfile);
 638     void SetHeader(const wxString& header, int pg = wxPAGE_ALL);
 639     void SetFooter(const wxString& footer, int pg = wxPAGE_ALL);
 640     void SetMargins(float top = 25.2, float bottom = 25.2,
 641                     float left = 25.2, float right = 25.2,
 642                     float spaces = 5);
 643 };
 644
 645
 646
 647 class wxHtmlEasyPrinting : public wxObject {
 648 public:
 649     wxHtmlEasyPrinting(const char* name = "Printing",
 650                        wxFrame *parent_frame = NULL);
 651     ~wxHtmlEasyPrinting();
 652
 653     void PreviewFile(const wxString &htmlfile);
 654     void PreviewText(const wxString &htmltext, const wxString& basepath = wxEmptyString);
 655     void PrintFile(const wxString &htmlfile);
 656     void PrintText(const wxString &htmltext, const wxString& basepath = wxEmptyString);
 657     void PrinterSetup();
 658     void PageSetup();
 659     void SetHeader(const wxString& header, int pg = wxPAGE_ALL);
 660     void SetFooter(const wxString& footer, int pg = wxPAGE_ALL);
 661
 662     wxPrintData *GetPrintData() {return m_PrintData;}
 663     wxPageSetupDialogData *GetPageSetupData() {return m_PageSetupData;}
 664
 665 };
 666
 667
 668
 669 //---------------------------------------------------------------------------
 670 //---------------------------------------------------------------------------
 671
 672 %{
 673     extern "C" SWIGEXPORT(void) inithtmlhelpc();
 674 %}
 675
 676
 677 %init %{
 678
 679     inithtmlhelpc();
 680
 681     wxClassInfo::CleanUpClasses();
 682     wxClassInfo::InitializeClasses();
 683
 684     wxPyPtrTypeMap_Add("wxHtmlTagHandler", "wxPyHtmlTagHandler");
 685     wxPyPtrTypeMap_Add("wxHtmlWinTagHandler", "wxPyHtmlWinTagHandler");
 686     wxPyPtrTypeMap_Add("wxHtmlWindow", "wxPyHtmlWindow");
 687 %}
 688
 689 //----------------------------------------------------------------------
 690 // And this gets appended to the shadow class file.
 691 //----------------------------------------------------------------------
 692
 693 %pragma(python) include="_htmlextras.py";
 694
 695 //---------------------------------------------------------------------------