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     void OnLinkClicked(const wxHtmlLinkInfo& link);
 447     void base_OnLinkClicked(const wxHtmlLinkInfo& link);
 448
 449      wxHtmlOpeningStatus OnOpeningURL(wxHtmlURLType type,
 450                                       const wxString& url,
 451                                       wxString *redirect) const;
 452
 453     DEC_PYCALLBACK__STRING(OnSetTitle);
 454     DEC_PYCALLBACK__CELLINTINT(OnCellMouseHover);
 455     DEC_PYCALLBACK__CELLINTINTME(OnCellClicked);
 456 //     DEC_PYCALLBACK_BOOL_STRING(OnOpeningURL);
 457     PYPRIVATE;
 458 };
 459
 460 IMPLEMENT_ABSTRACT_CLASS( wxPyHtmlWindow, wxHtmlWindow );
 461 IMP_PYCALLBACK__STRING(wxPyHtmlWindow, wxHtmlWindow, OnSetTitle);
 462 IMP_PYCALLBACK__CELLINTINT(wxPyHtmlWindow, wxHtmlWindow, OnCellMouseHover);
 463 IMP_PYCALLBACK__CELLINTINTME(wxPyHtmlWindow, wxHtmlWindow, OnCellClicked);
 464 // IMP_PYCALLBACK_BOOL_STRING(wxPyHtmlWindow, wxHtmlWindow, OnOpeningURL);
 465
 466
 467 void wxPyHtmlWindow::OnLinkClicked(const wxHtmlLinkInfo& link) {
 468     bool found;
 469     wxPyBeginBlockThreads();
 470     if ((found = wxPyCBH_findCallback(m_myInst, "OnLinkClicked"))) {
 471         PyObject* obj = wxPyConstructObject((void*)&link, "wxHtmlLinkInfo", 0);
 472         wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));
 473         Py_DECREF(obj);
 474     }
 475     wxPyEndBlockThreads();
 476     if (! found)
 477         wxHtmlWindow::OnLinkClicked(link);
 478 }
 479 void wxPyHtmlWindow::base_OnLinkClicked(const wxHtmlLinkInfo& link) {
 480     wxHtmlWindow::OnLinkClicked(link);
 481 }
 482
 483
 484 wxHtmlOpeningStatus wxPyHtmlWindow::OnOpeningURL(wxHtmlURLType type,
 485                                                  const wxString& url,
 486                                                  wxString *redirect) const {
 487     bool found;
 488     wxHtmlOpeningStatus rval;
 489     wxPyBeginBlockThreads();
 490     if ((found = wxPyCBH_findCallback(m_myInst, "OnOpeningURL"))) {
 491         PyObject* ro;
 492         ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(is)", type, url.c_str()));
 493         if (PyString_Check(ro)
 494 #if PYTHON_API_VERSION >= 1009
 495             || PyUnicode_Check(ro)
 496 #endif
 497             ) {
 498             PyObject* str = PyObject_Str(ro);
 499             *redirect = PyString_AsString(str);
 500             Py_DECREF(str);
 501             rval = wxHTML_REDIRECT;
 502         }
 503         else {
 504             PyObject* num = PyNumber_Int(ro);
 505             rval = (wxHtmlOpeningStatus)PyInt_AsLong(num);
 506             Py_DECREF(num);
 507         }
 508         Py_DECREF(ro);
 509     }
 510     wxPyEndBlockThreads();
 511     if (! found)
 512         rval = wxHtmlWindow::OnOpeningURL(type, url, redirect);
 513     return rval;
 514 }
 515
 516
 517 %}
 518
 519
 520
 521 %name(wxHtmlWindow) class wxPyHtmlWindow : public wxScrolledWindow {
 522 public:
 523     wxPyHtmlWindow(wxWindow *parent, int id = -1,
 524                  wxPoint& pos = wxDefaultPosition,
 525                  wxSize& size = wxDefaultSize,
 526                  int flags=wxHW_SCROLLBAR_AUTO,
 527                  char* name = "htmlWindow");
 528     %name(wxPreHtmlWindow)wxPyHtmlWindow();
 529
 530     bool Create(wxWindow *parent, int id = -1,
 531                 wxPoint& pos = wxDefaultPosition,
 532                 wxSize& size = wxDefaultSize,
 533                 int flags=wxHW_SCROLLBAR_AUTO,
 534                 char* name = "htmlWindow");
 535
 536
 537     void _setCallbackInfo(PyObject* self, PyObject* _class);
 538     %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxHtmlWindow)"
 539     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 540     %pragma(python) addtomethod = "wxPreHtmlWindow:val._setOORInfo(val)"
 541
 542     bool SetPage(const wxString& source);
 543     bool LoadPage(const wxString& location);
 544     bool AppendToPage(const wxString& source);
 545     wxString GetOpenedPage();
 546     wxString GetOpenedAnchor();
 547     wxString GetOpenedPageTitle();
 548
 549     void SetRelatedFrame(wxFrame* frame, const char* format);
 550     wxFrame* GetRelatedFrame();
 551     void SetRelatedStatusBar(int bar);
 552
 553     //void SetFonts(wxString normal_face, wxString fixed_face, int *LIST);
 554     %addmethods {
 555         void SetFonts(wxString normal_face, wxString fixed_face, PyObject* sizes) {
 556             int* temp = int_LIST_helper(sizes);
 557             if (temp) {
 558                 self->SetFonts(normal_face, fixed_face, temp);
 559                 delete [] temp;
 560             }
 561         }
 562     }
 563
 564     void SetTitle(const wxString& title);
 565     void SetBorders(int b);
 566     void ReadCustomization(wxConfigBase *cfg, wxString path = wxEmptyString);
 567     void WriteCustomization(wxConfigBase *cfg, wxString path = wxEmptyString);
 568     bool HistoryBack();
 569     bool HistoryForward();
 570     bool HistoryCanBack();
 571     bool HistoryCanForward();
 572     void HistoryClear();
 573     wxHtmlContainerCell* GetInternalRepresentation();
 574     wxHtmlWinParser* GetParser();
 575
 576     void base_OnLinkClicked(const wxHtmlLinkInfo& link);
 577     void base_OnSetTitle(const char* title);
 578     void base_OnCellMouseHover(wxHtmlCell *cell, wxCoord x, wxCoord y);
 579     void base_OnCellClicked(wxHtmlCell *cell,
 580                             wxCoord x, wxCoord y,
 581                             const wxMouseEvent& event);
 582 };
 583
 584 // Static methods are mapped to stand-alone functions
 585 %inline %{
 586     void wxHtmlWindow_AddFilter(wxHtmlFilter *filter) {
 587         wxHtmlWindow::AddFilter(filter);
 588     }
 589 %}
 590
 591
 592 //---------------------------------------------------------------------------
 593 //---------------------------------------------------------------------------
 594
 595
 596 class wxHtmlDCRenderer : public wxObject {
 597 public:
 598     wxHtmlDCRenderer();
 599     ~wxHtmlDCRenderer();
 600
 601     void SetDC(wxDC *dc, int maxwidth);
 602     void SetSize(int width, int height);
 603     void SetHtmlText(const wxString& html,
 604                      const wxString& basepath = wxEmptyString,
 605                      bool isdir = TRUE);
 606     int Render(int x, int y, int from = 0, int dont_render = FALSE);
 607     int GetTotalHeight();
 608                 // returns total height of the html document
 609                 // (compare Render's return value with this)
 610 };
 611
 612 enum {
 613     wxPAGE_ODD,
 614     wxPAGE_EVEN,
 615     wxPAGE_ALL
 616 };
 617
 618
 619 class wxHtmlPrintout : public wxPyPrintout {
 620 public:
 621     wxHtmlPrintout(const char* title = "Printout");
 622     //~wxHtmlPrintout();   wxPrintPreview object takes ownership...
 623
 624     void SetHtmlText(const wxString& html,
 625                      const wxString &basepath = wxEmptyString,
 626                      bool isdir = TRUE);
 627     void SetHtmlFile(const wxString &htmlfile);
 628     void SetHeader(const wxString& header, int pg = wxPAGE_ALL);
 629     void SetFooter(const wxString& footer, int pg = wxPAGE_ALL);
 630     void SetMargins(float top = 25.2, float bottom = 25.2,
 631                     float left = 25.2, float right = 25.2,
 632                     float spaces = 5);
 633 };
 634
 635
 636
 637 class wxHtmlEasyPrinting : public wxObject {
 638 public:
 639     wxHtmlEasyPrinting(const char* name = "Printing",
 640                        wxFrame *parent_frame = NULL);
 641     ~wxHtmlEasyPrinting();
 642
 643     void PreviewFile(const wxString &htmlfile);
 644     void PreviewText(const wxString &htmltext, const wxString& basepath = wxEmptyString);
 645     void PrintFile(const wxString &htmlfile);
 646     void PrintText(const wxString &htmltext, const wxString& basepath = wxEmptyString);
 647     void PrinterSetup();
 648     void PageSetup();
 649     void SetHeader(const wxString& header, int pg = wxPAGE_ALL);
 650     void SetFooter(const wxString& footer, int pg = wxPAGE_ALL);
 651
 652     wxPrintData *GetPrintData() {return m_PrintData;}
 653     wxPageSetupDialogData *GetPageSetupData() {return m_PageSetupData;}
 654
 655 };
 656
 657
 658
 659 //---------------------------------------------------------------------------
 660 //---------------------------------------------------------------------------
 661
 662 %{
 663     extern "C" SWIGEXPORT(void) inithtmlhelpc();
 664 %}
 665
 666
 667 %init %{
 668
 669     inithtmlhelpc();
 670
 671     wxClassInfo::CleanUpClasses();
 672     wxClassInfo::InitializeClasses();
 673
 674     wxPyPtrTypeMap_Add("wxHtmlTagHandler", "wxPyHtmlTagHandler");
 675     wxPyPtrTypeMap_Add("wxHtmlWinTagHandler", "wxPyHtmlWinTagHandler");
 676     wxPyPtrTypeMap_Add("wxHtmlWindow", "wxPyHtmlWindow");
 677 %}
 678
 679 //----------------------------------------------------------------------
 680 // And this gets appended to the shadow class file.
 681 //----------------------------------------------------------------------
 682
 683 %pragma(python) include="_htmlextras.py";
 684
 685 //---------------------------------------------------------------------------