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