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 "wxPython.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 #include <wx/filesys.h>
  25
  26 #include "printfw.h"
  27 %}
  28
  29 //---------------------------------------------------------------------------
  30
  31 %include typemaps.i
  32 %include my_typemaps.i
  33
  34 %extern wx.i
  35 %extern windows.i
  36 %extern _defs.i
  37 %extern events.i
  38 %extern controls.i
  39 %extern controls2.i
  40 %extern printfw.i
  41 %extern utils.i
  42 %extern filesys.i
  43 %extern streams.i
  44
  45
  46 %pragma(python) code = "import wx"
  47
  48
  49 //----------------------------------------------------------------------
  50
  51 %{
  52     // Put some wx default wxChar* values into wxStrings.
  53     static const wxChar* wxHtmlWindowNameStr = wxT("htmlWindow");
  54     DECLARE_DEF_STRING(HtmlWindowNameStr);
  55
  56     static const wxChar* wxHtmlPrintoutTitleStr = wxT("Printout");
  57     DECLARE_DEF_STRING(HtmlPrintoutTitleStr);
  58
  59     static const wxChar* wxHtmlPrintingTitleStr = wxT("Printing");
  60     DECLARE_DEF_STRING(HtmlPrintingTitleStr);
  61
  62     static const wxString wxPyEmptyString(wxT(""));
  63 %}
  64
  65 //---------------------------------------------------------------------------
  66
  67 enum {
  68     wxHTML_ALIGN_LEFT,
  69     wxHTML_ALIGN_CENTER,
  70     wxHTML_ALIGN_RIGHT,
  71     wxHTML_ALIGN_BOTTOM,
  72     wxHTML_ALIGN_TOP,
  73
  74     wxHTML_CLR_FOREGROUND,
  75     wxHTML_CLR_BACKGROUND,
  76
  77     wxHTML_UNITS_PIXELS,
  78     wxHTML_UNITS_PERCENT,
  79
  80     wxHTML_INDENT_LEFT,
  81     wxHTML_INDENT_RIGHT,
  82     wxHTML_INDENT_TOP,
  83     wxHTML_INDENT_BOTTOM,
  84
  85     wxHTML_INDENT_HORIZONTAL,
  86     wxHTML_INDENT_VERTICAL,
  87     wxHTML_INDENT_ALL,
  88
  89     wxHTML_COND_ISANCHOR,
  90     wxHTML_COND_ISIMAGEMAP,
  91     wxHTML_COND_USER,
  92 };
  93
  94
  95 enum {
  96     wxHW_SCROLLBAR_NEVER,
  97     wxHW_SCROLLBAR_AUTO,
  98 };
  99
 100
 101 // enums for wxHtmlWindow::OnOpeningURL
 102 enum wxHtmlOpeningStatus
 103 {
 104     wxHTML_OPEN,
 105     wxHTML_BLOCK,
 106     wxHTML_REDIRECT
 107 };
 108
 109 enum wxHtmlURLType
 110 {
 111     wxHTML_URL_PAGE,
 112     wxHTML_URL_IMAGE,
 113     wxHTML_URL_OTHER
 114 };
 115
 116 //---------------------------------------------------------------------------
 117
 118 class wxHtmlLinkInfo : public wxObject {
 119 public:
 120     wxHtmlLinkInfo(const wxString& href, const wxString& target = wxPyEmptyString);
 121     wxString GetHref();
 122     wxString GetTarget();
 123     wxMouseEvent* GetEvent();
 124     wxHtmlCell* GetHtmlCell();
 125
 126     void SetEvent(const wxMouseEvent *e);
 127     void SetHtmlCell(const wxHtmlCell * e);
 128 };
 129
 130 //---------------------------------------------------------------------------
 131
 132 class wxHtmlTag : public wxObject {
 133 public:
 134     // Never need to create a new tag from Python...
 135     //wxHtmlTag(const wxString& source, int pos, int end_pos, wxHtmlTagsCache* cache);
 136
 137     wxString GetName();
 138     bool HasParam(const wxString& par);
 139     wxString GetParam(const wxString& par, int with_commas = FALSE);
 140
 141     // Can't do this one as-is, but GetParam should be enough...
 142     //int ScanParam(const wxString& par, const char *format, void* param);
 143
 144     wxString GetAllParams();
 145     bool HasEnding();
 146     int GetBeginPos();
 147     int GetEndPos1();
 148     int GetEndPos2();
 149 };
 150
 151
 152 //---------------------------------------------------------------------------
 153
 154 class wxHtmlParser : public wxObject {
 155 public:
 156     // wxHtmlParser();  This is an abstract base class...
 157
 158     void SetFS(wxFileSystem *fs);
 159     wxFileSystem* GetFS();
 160     wxObject* Parse(const wxString& source);
 161     void InitParser(const wxString& source);
 162     void DoneParser();
 163     void DoParsing(int begin_pos, int end_pos);
 164     void StopParsing();
 165     // wxObject* GetProduct();
 166
 167     void AddTagHandler(wxHtmlTagHandler *handler);
 168     wxString* GetSource();
 169     void PushTagHandler(wxHtmlTagHandler* handler, wxString tags);
 170     void PopTagHandler();
 171
 172     // virtual wxFSFile *OpenURL(wxHtmlURLType type, const wxString& url) const;
 173
 174     // void AddText(const char* txt) = 0;
 175     // void AddTag(const wxHtmlTag& tag);
 176 };
 177
 178
 179 //---------------------------------------------------------------------------
 180
 181 class wxHtmlWinParser : public wxHtmlParser {
 182 public:
 183     wxHtmlWinParser(wxPyHtmlWindow *wnd = NULL);
 184
 185     void SetDC(wxDC *dc);
 186     wxDC* GetDC();
 187     int GetCharHeight();
 188     int GetCharWidth();
 189     wxPyHtmlWindow* GetWindow();
 190     // Sets fonts to be used when displaying HTML page. (if size null then default sizes used).
 191     %addmethods {
 192         void SetFonts(wxString normal_face, wxString fixed_face, PyObject* sizes=NULL) {
 193             int* temp = NULL;
 194             if (sizes) temp = int_LIST_helper(sizes);
 195             self->SetFonts(normal_face, fixed_face, temp);
 196             if (temp)
 197                 delete [] temp;
 198         }
 199     }
 200
 201     wxHtmlContainerCell* GetContainer();
 202     wxHtmlContainerCell* OpenContainer();
 203     wxHtmlContainerCell *SetContainer(wxHtmlContainerCell *c);
 204     wxHtmlContainerCell* CloseContainer();
 205
 206     int GetFontSize();
 207     void SetFontSize(int s);
 208     int GetFontBold();
 209     void SetFontBold(int x);
 210     int GetFontItalic();
 211     void SetFontItalic(int x);
 212     int GetFontUnderlined();
 213     void SetFontUnderlined(int x);
 214     int GetFontFixed();
 215     void SetFontFixed(int x);
 216     int GetAlign();
 217     void SetAlign(int a);
 218     wxColour GetLinkColor();
 219     void SetLinkColor(const wxColour& clr);
 220     wxColour GetActualColor();
 221     void SetActualColor(const wxColour& clr);
 222     void SetLink(const wxString& link);
 223     wxFont* CreateCurrentFont();
 224     wxHtmlLinkInfo GetLink();
 225
 226 };
 227
 228
 229
 230 //---------------------------------------------------------------------------
 231
 232 %{
 233 class wxPyHtmlTagHandler : public wxHtmlTagHandler {
 234     DECLARE_DYNAMIC_CLASS(wxPyHtmlTagHandler);
 235 public:
 236     wxPyHtmlTagHandler() : wxHtmlTagHandler() {};
 237
 238     wxHtmlParser* GetParser() { return m_Parser; }
 239     void ParseInner(const wxHtmlTag& tag) { wxHtmlTagHandler::ParseInner(tag); }
 240
 241     DEC_PYCALLBACK_STRING__pure(GetSupportedTags);
 242     DEC_PYCALLBACK_BOOL_TAG_pure(HandleTag);
 243
 244     PYPRIVATE;
 245 };
 246
 247 IMPLEMENT_DYNAMIC_CLASS(wxPyHtmlTagHandler, wxHtmlTagHandler);
 248
 249 IMP_PYCALLBACK_STRING__pure(wxPyHtmlTagHandler, wxHtmlTagHandler, GetSupportedTags);
 250 IMP_PYCALLBACK_BOOL_TAG_pure(wxPyHtmlTagHandler, wxHtmlTagHandler, HandleTag);
 251 %}
 252
 253
 254 %name(wxHtmlTagHandler) class wxPyHtmlTagHandler : public wxObject {
 255 public:
 256     wxPyHtmlTagHandler();
 257
 258     void _setCallbackInfo(PyObject* self, PyObject* _class);
 259     %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxHtmlTagHandler)"
 260
 261     void SetParser(wxHtmlParser *parser);
 262     wxHtmlParser* GetParser();
 263     void ParseInner(const wxHtmlTag& tag);
 264 };
 265
 266
 267 //---------------------------------------------------------------------------
 268
 269 %{
 270 class wxPyHtmlWinTagHandler : public wxHtmlWinTagHandler {
 271     DECLARE_DYNAMIC_CLASS(wxPyHtmlWinTagHandler);
 272 public:
 273     wxPyHtmlWinTagHandler() : wxHtmlWinTagHandler() {};
 274
 275     wxHtmlWinParser* GetParser() { return m_WParser; }
 276     void ParseInner(const wxHtmlTag& tag)
 277         { wxHtmlWinTagHandler::ParseInner(tag); }
 278
 279     DEC_PYCALLBACK_STRING__pure(GetSupportedTags);
 280     DEC_PYCALLBACK_BOOL_TAG_pure(HandleTag);
 281
 282     PYPRIVATE;
 283 };
 284
 285 IMPLEMENT_DYNAMIC_CLASS( wxPyHtmlWinTagHandler, wxHtmlWinTagHandler);
 286
 287 IMP_PYCALLBACK_STRING__pure(wxPyHtmlWinTagHandler, wxHtmlWinTagHandler, GetSupportedTags);
 288 IMP_PYCALLBACK_BOOL_TAG_pure(wxPyHtmlWinTagHandler, wxHtmlWinTagHandler, HandleTag);
 289 %}
 290
 291
 292 %name(wxHtmlWinTagHandler) class wxPyHtmlWinTagHandler : public wxPyHtmlTagHandler {
 293 public:
 294     wxPyHtmlWinTagHandler();
 295
 296     void _setCallbackInfo(PyObject* self, PyObject* _class);
 297     %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxHtmlWinTagHandler)"
 298
 299     void SetParser(wxHtmlParser *parser);
 300     wxHtmlWinParser* GetParser();
 301     void ParseInner(const wxHtmlTag& tag);
 302 };
 303
 304
 305 //---------------------------------------------------------------------------
 306
 307 %{
 308
 309 class wxPyHtmlTagsModule : public wxHtmlTagsModule {
 310 public:
 311     wxPyHtmlTagsModule(PyObject* thc) : wxHtmlTagsModule() {
 312         m_tagHandlerClass = thc;
 313         Py_INCREF(m_tagHandlerClass);
 314         RegisterModule(this);
 315         wxHtmlWinParser::AddModule(this);
 316     }
 317
 318     void OnExit() {
 319         wxPyBeginBlockThreads();
 320         Py_DECREF(m_tagHandlerClass);
 321         m_tagHandlerClass = NULL;
 322         for (size_t x=0; x < m_objArray.GetCount(); x++) {
 323             PyObject* obj = (PyObject*)m_objArray.Item(x);
 324             Py_DECREF(obj);
 325         }
 326         wxPyEndBlockThreads();
 327     };
 328
 329     void FillHandlersTable(wxHtmlWinParser *parser) {
 330         // Wave our magic wand...  (if it works it's a miracle!  ;-)
 331
 332         // First, make a new instance of the tag handler
 333         wxPyBeginBlockThreads();
 334         PyObject* arg = Py_BuildValue("()");
 335         PyObject* obj = PyInstance_New(m_tagHandlerClass, arg, NULL);
 336         Py_DECREF(arg);
 337         wxPyEndBlockThreads();
 338
 339         // now figure out where it's C++ object is...
 340         wxPyHtmlWinTagHandler* thPtr;
 341         if (SWIG_GetPtrObj(obj, (void **)&thPtr, "_wxPyHtmlWinTagHandler_p"))
 342             return;
 343
 344         // add it,
 345         parser->AddTagHandler(thPtr);
 346
 347         // and track it.
 348         m_objArray.Add(obj);
 349     }
 350
 351 private:
 352     PyObject*           m_tagHandlerClass;
 353     wxArrayPtrVoid      m_objArray;
 354
 355 };
 356 %}
 357
 358
 359
 360 %inline %{
 361     void wxHtmlWinParser_AddTagHandler(PyObject* tagHandlerClass) {
 362         // Dynamically create a new wxModule.  Refcounts tagHandlerClass
 363         // and adds itself to the wxModules list and to the wxHtmlWinParser.
 364         new wxPyHtmlTagsModule(tagHandlerClass);
 365     }
 366 %}
 367
 368
 369 //---------------------------------------------------------------------------
 370 //---------------------------------------------------------------------------
 371
 372
 373 // wxHtmlSelection is data holder with information about text selection.
 374 // Selection is defined by two positions (beginning and end of the selection)
 375 // and two leaf(!) cells at these positions.
 376 class wxHtmlSelection
 377 {
 378 public:
 379     wxHtmlSelection();
 380     ~wxHtmlSelection();
 381
 382     void Set(const wxPoint& fromPos, const wxHtmlCell *fromCell,
 383              const wxPoint& toPos, const wxHtmlCell *toCell);
 384     %name(SetCells)void Set(const wxHtmlCell *fromCell, const wxHtmlCell *toCell);
 385
 386     const wxHtmlCell *GetFromCell() const;
 387     const wxHtmlCell *GetToCell() const;
 388
 389     // these values are in absolute coordinates:
 390     const wxPoint& GetFromPos() const;
 391     const wxPoint& GetToPos() const;
 392
 393     // these are From/ToCell's private data
 394     const wxPoint& GetFromPrivPos() const;
 395     const wxPoint& GetToPrivPos() const;
 396     void SetFromPrivPos(const wxPoint& pos);
 397     void SetToPrivPos(const wxPoint& pos);
 398     void ClearPrivPos();
 399
 400     const bool IsEmpty() const;
 401
 402 };
 403
 404
 405 enum wxHtmlSelectionState
 406 {
 407     wxHTML_SEL_OUT,     // currently rendered cell is outside the selection
 408     wxHTML_SEL_IN,      // ... is inside selection
 409     wxHTML_SEL_CHANGING // ... is the cell on which selection state changes
 410 };
 411
 412 // Selection state is passed to wxHtmlCell::Draw so that it can render itself
 413 // differently e.g. when inside text selection or outside it.
 414 class wxHtmlRenderingState
 415 {
 416 public:
 417     wxHtmlRenderingState();
 418     ~wxHtmlRenderingState();
 419
 420     void SetSelectionState(wxHtmlSelectionState s);
 421     wxHtmlSelectionState GetSelectionState() const;
 422
 423     void SetFgColour(const wxColour& c);
 424     const wxColour& GetFgColour() const;
 425     void SetBgColour(const wxColour& c);
 426     const wxColour& GetBgColour() const;
 427 };
 428
 429
 430 // HTML rendering customization. This class is used when rendering wxHtmlCells
 431 // as a callback:
 432 class wxHtmlRenderingStyle
 433 {
 434 public:
 435     virtual wxColour GetSelectedTextColour(const wxColour& clr) = 0;
 436     virtual wxColour GetSelectedTextBgColour(const wxColour& clr) = 0;
 437 };
 438
 439 // Standard style:
 440 class wxDefaultHtmlRenderingStyle : public wxHtmlRenderingStyle
 441 {
 442 public:
 443     virtual wxColour GetSelectedTextColour(const wxColour& clr);
 444     virtual wxColour GetSelectedTextBgColour(const wxColour& clr);
 445 };
 446
 447
 448
 449 // Information given to cells when drawing them. Contains rendering state,
 450 // selection information and rendering style object that can be used to
 451 // customize the output.
 452 class wxHtmlRenderingInfo
 453 {
 454 public:
 455     wxHtmlRenderingInfo();
 456     ~wxHtmlRenderingInfo();
 457
 458     void SetSelection(wxHtmlSelection *s);
 459     wxHtmlSelection *GetSelection() const;
 460
 461     void SetStyle(wxHtmlRenderingStyle *style);
 462     wxHtmlRenderingStyle& GetStyle();
 463
 464     wxHtmlRenderingState& GetState();
 465 };
 466
 467 //---------------------------------------------------------------------------
 468
 469 class wxHtmlCell : public wxObject {
 470 public:
 471     wxHtmlCell();
 472
 473     int GetPosX();
 474     int GetPosY();
 475     int GetWidth();
 476     int GetHeight();
 477     int GetDescent();
 478     wxHtmlLinkInfo* GetLink(int x = 0, int y = 0);
 479     wxHtmlCell* GetNext();
 480     wxHtmlContainerCell* GetParent();
 481     void SetLink(const wxHtmlLinkInfo& link);
 482     void SetNext(wxHtmlCell *cell);
 483     void SetParent(wxHtmlContainerCell *p);
 484     void SetPos(int x, int y);
 485     void Layout(int w);
 486     void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2,
 487               wxHtmlRenderingInfo& info);
 488     void DrawInvisible(wxDC& dc, int x, int y,
 489               wxHtmlRenderingInfo& info);
 490     const wxHtmlCell* Find(int condition, const void* param);
 491
 492     bool AdjustPagebreak(int* INOUT);
 493     void SetCanLiveOnPagebreak(bool can);
 494
 495 };
 496
 497
 498 class  wxHtmlWordCell : public wxHtmlCell
 499 {
 500 public:
 501     wxHtmlWordCell(const wxString& word, wxDC& dc);
 502 };
 503
 504
 505 class wxHtmlContainerCell : public wxHtmlCell {
 506 public:
 507     wxHtmlContainerCell(wxHtmlContainerCell *parent);
 508
 509     void InsertCell(wxHtmlCell *cell);
 510     void SetAlignHor(int al);
 511     int GetAlignHor();
 512     void SetAlignVer(int al);
 513     int GetAlignVer();
 514     void SetIndent(int i, int what, int units = wxHTML_UNITS_PIXELS);
 515     int GetIndent(int ind);
 516     int GetIndentUnits(int ind);
 517     void SetAlign(const wxHtmlTag& tag);
 518     void SetWidthFloat(int w, int units);
 519     %name(SetWidthFloatFromTag)void SetWidthFloat(const wxHtmlTag& tag);
 520     void SetMinHeight(int h, int align = wxHTML_ALIGN_TOP);
 521     void SetBackgroundColour(const wxColour& clr);
 522     wxColour GetBackgroundColour();
 523     void SetBorder(const wxColour& clr1, const wxColour& clr2);
 524     wxHtmlCell* GetFirstChild();
 525     %pragma(python) addtoclass = "GetFirstCell = GetFirstChild"
 526 };
 527
 528
 529
 530 class wxHtmlColourCell : public wxHtmlCell {
 531 public:
 532     wxHtmlColourCell(wxColour clr, int flags = wxHTML_CLR_FOREGROUND);
 533
 534 };
 535
 536
 537 class  wxHtmlFontCell : public wxHtmlCell
 538 {
 539 public:
 540     wxHtmlFontCell(wxFont *font);
 541 };
 542
 543
 544 class wxHtmlWidgetCell : public wxHtmlCell {
 545 public:
 546     wxHtmlWidgetCell(wxWindow* wnd, int w = 0);
 547
 548 };
 549
 550
 551 //---------------------------------------------------------------------------
 552 // wxHtmlFilter
 553 //---------------------------------------------------------------------------
 554
 555
 556 %{ // here's the C++ version
 557 class wxPyHtmlFilter : public wxHtmlFilter {
 558     DECLARE_ABSTRACT_CLASS(wxPyHtmlFilter);
 559 public:
 560     wxPyHtmlFilter() : wxHtmlFilter() {}
 561
 562     // returns TRUE if this filter is able to open&read given file
 563     virtual bool CanRead(const wxFSFile& file) const {
 564         bool rval = FALSE;
 565         bool found;
 566         wxPyBeginBlockThreads();
 567         if ((found = wxPyCBH_findCallback(m_myInst, "CanRead"))) {
 568             PyObject* obj = wxPyMake_wxObject((wxFSFile*)&file);  // cast away const
 569             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));
 570             Py_DECREF(obj);
 571         }
 572         wxPyEndBlockThreads();
 573         return rval;
 574     }
 575
 576
 577     // Reads given file and returns HTML document.
 578     // Returns empty string if opening failed
 579     virtual wxString ReadFile(const wxFSFile& file) const {
 580         wxString rval;
 581         bool found;
 582         wxPyBeginBlockThreads();
 583         if ((found = wxPyCBH_findCallback(m_myInst, "ReadFile"))) {
 584             PyObject* obj = wxPyMake_wxObject((wxFSFile*)&file);  // cast away const
 585             PyObject* ro;
 586             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(O)", obj));
 587             Py_DECREF(obj);
 588             if (ro) {
 589                 rval = Py2wxString(ro);
 590                 Py_DECREF(ro);
 591             }
 592         }
 593         wxPyEndBlockThreads();
 594         return rval;
 595     }
 596
 597     PYPRIVATE;
 598 };
 599
 600 IMPLEMENT_ABSTRACT_CLASS(wxPyHtmlFilter, wxHtmlFilter);
 601 %}
 602
 603
 604 // And now the version seen by SWIG
 605
 606 %name(wxHtmlFilter) class wxPyHtmlFilter : public wxObject {
 607 public:
 608     wxPyHtmlFilter();
 609
 610     void _setCallbackInfo(PyObject* self, PyObject* _class);
 611     %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxHtmlFilter)"
 612 };
 613
 614
 615 // TODO: wxHtmlFilterHTML
 616
 617
 618 //---------------------------------------------------------------------------
 619 // wxHtmlWindow
 620 //---------------------------------------------------------------------------
 621
 622 %{
 623 class wxPyHtmlWindow : public wxHtmlWindow {
 624     DECLARE_ABSTRACT_CLASS(wxPyHtmlWindow);
 625 public:
 626     wxPyHtmlWindow(wxWindow *parent, wxWindowID id = -1,
 627                    const wxPoint& pos = wxDefaultPosition,
 628                    const wxSize& size = wxDefaultSize,
 629                    long style = wxHW_SCROLLBAR_AUTO,
 630                    const wxString& name = wxPyHtmlWindowNameStr)
 631         : wxHtmlWindow(parent, id, pos, size, style, name)  {};
 632     wxPyHtmlWindow() : wxHtmlWindow() {};
 633
 634     bool ScrollToAnchor(const wxString& anchor) {
 635         return wxHtmlWindow::ScrollToAnchor(anchor);
 636     }
 637
 638     bool HasAnchor(const wxString& anchor) {
 639         const wxHtmlCell *c = m_Cell->Find(wxHTML_COND_ISANCHOR, &anchor);
 640         return c!=NULL;
 641     }
 642
 643     void OnLinkClicked(const wxHtmlLinkInfo& link);
 644     void base_OnLinkClicked(const wxHtmlLinkInfo& link);
 645
 646     wxHtmlOpeningStatus OnOpeningURL(wxHtmlURLType type,
 647                                       const wxString& url,
 648                                       wxString *redirect) const;
 649
 650     DEC_PYCALLBACK__STRING(OnSetTitle);
 651     DEC_PYCALLBACK__CELLINTINT(OnCellMouseHover);
 652     DEC_PYCALLBACK__CELLINTINTME(OnCellClicked);
 653     PYPRIVATE;
 654 };
 655
 656 IMPLEMENT_ABSTRACT_CLASS( wxPyHtmlWindow, wxHtmlWindow );
 657 IMP_PYCALLBACK__STRING(wxPyHtmlWindow, wxHtmlWindow, OnSetTitle);
 658 IMP_PYCALLBACK__CELLINTINT(wxPyHtmlWindow, wxHtmlWindow, OnCellMouseHover);
 659 IMP_PYCALLBACK__CELLINTINTME(wxPyHtmlWindow, wxHtmlWindow, OnCellClicked);
 660
 661
 662 void wxPyHtmlWindow::OnLinkClicked(const wxHtmlLinkInfo& link) {
 663     bool found;
 664     wxPyBeginBlockThreads();
 665     if ((found = wxPyCBH_findCallback(m_myInst, "OnLinkClicked"))) {
 666         PyObject* obj = wxPyConstructObject((void*)&link, wxT("wxHtmlLinkInfo"), 0);
 667         wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));
 668         Py_DECREF(obj);
 669     }
 670     wxPyEndBlockThreads();
 671     if (! found)
 672         wxHtmlWindow::OnLinkClicked(link);
 673 }
 674 void wxPyHtmlWindow::base_OnLinkClicked(const wxHtmlLinkInfo& link) {
 675     wxHtmlWindow::OnLinkClicked(link);
 676 }
 677
 678
 679 wxHtmlOpeningStatus wxPyHtmlWindow::OnOpeningURL(wxHtmlURLType type,
 680                                                  const wxString& url,
 681                                                  wxString *redirect) const {
 682     bool found;
 683     wxHtmlOpeningStatus rval;
 684     wxPyBeginBlockThreads();
 685     if ((found = wxPyCBH_findCallback(m_myInst, "OnOpeningURL"))) {
 686         PyObject* ro;
 687         PyObject* s = wx2PyString(url);
 688         ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(iO)", type, s));
 689         Py_DECREF(s);
 690         if (PyString_Check(ro)
 691 #if PYTHON_API_VERSION >= 1009
 692             || PyUnicode_Check(ro)
 693 #endif
 694             ) {
 695             *redirect = Py2wxString(ro);
 696             rval = wxHTML_REDIRECT;
 697         }
 698         else {
 699             PyObject* num = PyNumber_Int(ro);
 700             rval = (wxHtmlOpeningStatus)PyInt_AsLong(num);
 701             Py_DECREF(num);
 702         }
 703         Py_DECREF(ro);
 704     }
 705     wxPyEndBlockThreads();
 706     if (! found)
 707         rval = wxHtmlWindow::OnOpeningURL(type, url, redirect);
 708     return rval;
 709 }
 710
 711
 712 %}
 713
 714
 715
 716 %name(wxHtmlWindow) class wxPyHtmlWindow : public wxScrolledWindow {
 717 public:
 718     wxPyHtmlWindow(wxWindow *parent, int id = -1,
 719                  wxPoint& pos = wxDefaultPosition,
 720                  wxSize& size = wxDefaultSize,
 721                  int style=wxHW_SCROLLBAR_AUTO,
 722                  const wxString& name = wxPyHtmlWindowNameStr);
 723     %name(wxPreHtmlWindow)wxPyHtmlWindow();
 724
 725     bool Create(wxWindow *parent, int id = -1,
 726                 wxPoint& pos = wxDefaultPosition,
 727                 wxSize& size = wxDefaultSize,
 728                 int style=wxHW_SCROLLBAR_AUTO,
 729                 const wxString& name = wxPyHtmlWindowNameStr);
 730
 731
 732     void _setCallbackInfo(PyObject* self, PyObject* _class);
 733     %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxHtmlWindow)"
 734     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 735     %pragma(python) addtomethod = "wxPreHtmlWindow:val._setOORInfo(val)"
 736
 737     // Set HTML page and display it. !! source is HTML document itself,
 738     // it is NOT address/filename of HTML document. If you want to
 739     // specify document location, use LoadPage() istead
 740     // Return value : FALSE if an error occured, TRUE otherwise
 741     bool SetPage(const wxString& source);
 742
 743     // Load HTML page from given location. Location can be either
 744     // a) /usr/wxGTK2/docs/html/wx.htm
 745     // b) http://www.somewhere.uk/document.htm
 746     // c) ftp://ftp.somesite.cz/pub/something.htm
 747     // In case there is no prefix (http:,ftp:), the method
 748     // will try to find it itself (1. local file, then http or ftp)
 749     // After the page is loaded, the method calls SetPage() to display it.
 750     // Note : you can also use path relative to previously loaded page
 751     // Return value : same as SetPage
 752     bool LoadPage(const wxString& location);
 753
 754     // Loads HTML page from file
 755     bool LoadFile(const wxString& filename);
 756
 757     // Append to current page
 758     bool AppendToPage(const wxString& source);
 759
 760      // Returns full location of opened page
 761     wxString GetOpenedPage();
 762
 763     // Returns anchor within opened page
 764     wxString GetOpenedAnchor();
 765
 766     // Returns <TITLE> of opened page or empty string otherwise
 767     wxString GetOpenedPageTitle();
 768
 769     // Sets frame in which page title will  be displayed. Format is format of
 770     // frame title, e.g. "HtmlHelp : %s". It must contain exactly one %s
 771     void SetRelatedFrame(wxFrame* frame, const wxString& format);
 772     wxFrame* GetRelatedFrame();
 773
 774     // After(!) calling SetRelatedFrame, this sets statusbar slot where messages
 775     // will be displayed. Default is -1 = no messages.
 776     void SetRelatedStatusBar(int bar);
 777
 778     // Sets fonts to be used when displaying HTML page.
 779     %addmethods {
 780         void SetFonts(wxString normal_face, wxString fixed_face, PyObject* sizes=NULL) {
 781             int* temp = NULL;
 782             if (sizes) temp = int_LIST_helper(sizes);
 783             self->SetFonts(normal_face, fixed_face, temp);
 784             if (temp)
 785                 delete [] temp;
 786         }
 787     }
 788
 789     void SetTitle(const wxString& title);
 790
 791     // Sets space between text and window borders.
 792     void SetBorders(int b);
 793
 794     // Saves custom settings into cfg config. it will use the path 'path'
 795     // if given, otherwise it will save info into currently selected path.
 796     // saved values : things set by SetFonts, SetBorders.
 797     void ReadCustomization(wxConfigBase *cfg, wxString path = wxPyEmptyString);
 798     void WriteCustomization(wxConfigBase *cfg, wxString path = wxPyEmptyString);
 799
 800     // Goes to previous/next page (in browsing history)
 801     // Returns TRUE if successful, FALSE otherwise
 802     bool HistoryBack();
 803     bool HistoryForward();
 804     bool HistoryCanBack();
 805     bool HistoryCanForward();
 806
 807     // Resets History
 808     void HistoryClear();
 809
 810     // Returns pointer to conteiners/cells structure.
 811     wxHtmlContainerCell* GetInternalRepresentation();
 812
 813     // Returns a pointer to the parser.
 814     wxHtmlWinParser* GetParser();
 815
 816     bool ScrollToAnchor(const wxString& anchor);
 817     bool HasAnchor(const wxString& anchor);
 818
 819     //Adds input filter
 820     static void AddFilter(wxPyHtmlFilter *filter);
 821
 822
 823     void base_OnLinkClicked(const wxHtmlLinkInfo& link);
 824     void base_OnSetTitle(const wxString& title);
 825     void base_OnCellMouseHover(wxHtmlCell *cell, wxCoord x, wxCoord y);
 826     void base_OnCellClicked(wxHtmlCell *cell,
 827                             wxCoord x, wxCoord y,
 828                             const wxMouseEvent& event);
 829 };
 830
 831
 832
 833 //---------------------------------------------------------------------------
 834 //---------------------------------------------------------------------------
 835
 836
 837 class wxHtmlDCRenderer : public wxObject {
 838 public:
 839     wxHtmlDCRenderer();
 840     ~wxHtmlDCRenderer();
 841
 842     void SetDC(wxDC *dc, int maxwidth);
 843     void SetSize(int width, int height);
 844     void SetHtmlText(const wxString& html,
 845                      const wxString& basepath = wxPyEmptyString,
 846                      bool isdir = TRUE);
 847     // Sets fonts to be used when displaying HTML page. (if size null then default sizes used).
 848     %addmethods {
 849         void SetFonts(wxString normal_face, wxString fixed_face, PyObject* sizes=NULL) {
 850             int* temp = NULL;
 851             if (sizes) temp = int_LIST_helper(sizes);
 852             self->SetFonts(normal_face, fixed_face, temp);
 853             if (temp)
 854                 delete [] temp;
 855         }
 856     }
 857     int Render(int x, int y, int from = 0, int dont_render = FALSE);
 858     int GetTotalHeight();
 859                 // returns total height of the html document
 860                 // (compare Render's return value with this)
 861 };
 862
 863 enum {
 864     wxPAGE_ODD,
 865     wxPAGE_EVEN,
 866     wxPAGE_ALL
 867 };
 868
 869
 870 class wxHtmlPrintout : public wxPyPrintout {
 871 public:
 872     wxHtmlPrintout(const wxString& title = wxPyHtmlPrintoutTitleStr);
 873     //~wxHtmlPrintout();   wxPrintPreview object takes ownership...
 874
 875     void SetHtmlText(const wxString& html,
 876                      const wxString &basepath = wxPyEmptyString,
 877                      bool isdir = TRUE);
 878     void SetHtmlFile(const wxString &htmlfile);
 879     void SetHeader(const wxString& header, int pg = wxPAGE_ALL);
 880     void SetFooter(const wxString& footer, int pg = wxPAGE_ALL);
 881     // Sets fonts to be used when displaying HTML page. (if size null then default sizes used).
 882     %addmethods {
 883         void SetFonts(wxString normal_face, wxString fixed_face, PyObject* sizes=NULL) {
 884             int* temp = NULL;
 885             if (sizes) temp = int_LIST_helper(sizes);
 886             self->SetFonts(normal_face, fixed_face, temp);
 887             if (temp)
 888                 delete [] temp;
 889         }
 890     }
 891     void SetMargins(float top = 25.2, float bottom = 25.2,
 892                     float left = 25.2, float right = 25.2,
 893                     float spaces = 5);
 894 };
 895
 896
 897
 898 class wxHtmlEasyPrinting : public wxObject {
 899 public:
 900     wxHtmlEasyPrinting(const wxString& name = wxPyHtmlPrintingTitleStr,
 901                        wxFrame *parent_frame = NULL);
 902     ~wxHtmlEasyPrinting();
 903
 904     void PreviewFile(const wxString &htmlfile);
 905     void PreviewText(const wxString &htmltext, const wxString& basepath = wxPyEmptyString);
 906     void PrintFile(const wxString &htmlfile);
 907     void PrintText(const wxString &htmltext, const wxString& basepath = wxPyEmptyString);
 908     void PrinterSetup();
 909     void PageSetup();
 910     void SetHeader(const wxString& header, int pg = wxPAGE_ALL);
 911     void SetFooter(const wxString& footer, int pg = wxPAGE_ALL);
 912
 913     %addmethods {
 914         void SetFonts(wxString normal_face, wxString fixed_face, PyObject* sizes=NULL) {
 915             int* temp = NULL;
 916             if (sizes) temp = int_LIST_helper(sizes);
 917             self->SetFonts(normal_face, fixed_face, temp);
 918             if (temp)
 919                 delete [] temp;
 920         }
 921     }
 922
 923     wxPrintData *GetPrintData() {return m_PrintData;}
 924     wxPageSetupDialogData *GetPageSetupData() {return m_PageSetupData;}
 925
 926 };
 927
 928
 929
 930 //---------------------------------------------------------------------------
 931 //---------------------------------------------------------------------------
 932
 933 %{
 934     extern "C" SWIGEXPORT(void) inithtmlhelpc();
 935 %}
 936
 937
 938 %init %{
 939
 940     inithtmlhelpc();
 941
 942     wxClassInfo::CleanUpClasses();
 943     wxClassInfo::InitializeClasses();
 944
 945     wxPyPtrTypeMap_Add("wxHtmlTagHandler", "wxPyHtmlTagHandler");
 946     wxPyPtrTypeMap_Add("wxHtmlWinTagHandler", "wxPyHtmlWinTagHandler");
 947     wxPyPtrTypeMap_Add("wxHtmlWindow", "wxPyHtmlWindow");
 948     wxPyPtrTypeMap_Add("wxHtmlFilter", "wxPyHtmlFilter");
 949 %}
 950
 951 //----------------------------------------------------------------------
 952 // And this gets appended to the shadow class file.
 953 //----------------------------------------------------------------------
 954
 955 %pragma(python) include="_htmlextras.py";
 956
 957 //---------------------------------------------------------------------------