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