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) 2003 by Total Control Software
  10 // Licence:     wxWindows license
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 %define DOCSTRING
  14 "Classes for a simple HTML rendering window, HTML Help Window, etc."
  15 %enddef
  16
  17 %module(package="wx", docstring=DOCSTRING) html
  18
  19 %{
  20 #include "wx/wxPython/wxPython.h"
  21 #include "wx/wxPython/pyclasses.h"
  22 #include "wx/wxPython/pyistream.h"
  23 #include "wx/wxPython/printfw.h"
  24
  25 #include <wx/html/htmlwin.h>
  26 #include <wx/html/htmprint.h>
  27 #include <wx/html/helpctrl.h>
  28 #include <wx/html/helpwnd.h>
  29 #include <wx/html/helpfrm.h>
  30 #include <wx/html/helpdlg.h>
  31
  32 %}
  33
  34
  35 //---------------------------------------------------------------------------
  36
  37 %import windows.i
  38 %pythoncode { wx = _core }
  39 %pythoncode { __docfilter__ = wx.__DocFilter(globals()) }
  40
  41 %include _html_rename.i
  42
  43
  44 MAKE_CONST_WXSTRING_NOSWIG(EmptyString);
  45 MAKE_CONST_WXSTRING2(HtmlWindowNameStr,    wxT("htmlWindow"))
  46 MAKE_CONST_WXSTRING2(HtmlPrintoutTitleStr, wxT("Printout"))
  47 MAKE_CONST_WXSTRING2(HtmlPrintingTitleStr, wxT("Printing"))
  48
  49
  50 // TODO: Split this file into multiple %included files that coresponds to the
  51 // wx/html include files (more or less.)
  52
  53 //---------------------------------------------------------------------------
  54 %newgroup
  55
  56
  57 enum {
  58     wxHTML_ALIGN_LEFT,
  59     wxHTML_ALIGN_CENTER,
  60     wxHTML_ALIGN_RIGHT,
  61     wxHTML_ALIGN_BOTTOM,
  62     wxHTML_ALIGN_TOP,
  63
  64     wxHTML_CLR_FOREGROUND,
  65     wxHTML_CLR_BACKGROUND,
  66
  67     wxHTML_UNITS_PIXELS,
  68     wxHTML_UNITS_PERCENT,
  69
  70     wxHTML_INDENT_LEFT,
  71     wxHTML_INDENT_RIGHT,
  72     wxHTML_INDENT_TOP,
  73     wxHTML_INDENT_BOTTOM,
  74
  75     wxHTML_INDENT_HORIZONTAL,
  76     wxHTML_INDENT_VERTICAL,
  77     wxHTML_INDENT_ALL,
  78
  79     wxHTML_COND_ISANCHOR,
  80     wxHTML_COND_ISIMAGEMAP,
  81     wxHTML_COND_USER,
  82
  83
  84     wxHTML_FONT_SIZE_1,
  85     wxHTML_FONT_SIZE_2,
  86     wxHTML_FONT_SIZE_3,
  87     wxHTML_FONT_SIZE_4,
  88     wxHTML_FONT_SIZE_5,
  89     wxHTML_FONT_SIZE_6,
  90     wxHTML_FONT_SIZE_7,
  91 };
  92
  93
  94 enum {
  95     wxHW_SCROLLBAR_NEVER,
  96     wxHW_SCROLLBAR_AUTO,
  97     wxHW_NO_SELECTION,
  98     wxHW_DEFAULT_STYLE,
  99 };
 100
 101
 102 // enums for wxHtmlWindow::OnOpeningURL
 103 enum wxHtmlOpeningStatus
 104 {
 105     wxHTML_OPEN,
 106     wxHTML_BLOCK,
 107     wxHTML_REDIRECT
 108 };
 109
 110 enum wxHtmlURLType
 111 {
 112     wxHTML_URL_PAGE,
 113     wxHTML_URL_IMAGE,
 114     wxHTML_URL_OTHER
 115 };
 116
 117
 118
 119 //---------------------------------------------------------------------------
 120
 121 class wxHtmlLinkInfo : public wxObject {
 122 public:
 123     wxHtmlLinkInfo(const wxString& href, const wxString& target = wxPyEmptyString);
 124     wxString GetHref();
 125     wxString GetTarget();
 126     wxMouseEvent* GetEvent();
 127     wxHtmlCell* GetHtmlCell();
 128
 129     void SetEvent(const wxMouseEvent *e);
 130     void SetHtmlCell(const wxHtmlCell * e);
 131 };
 132
 133 //---------------------------------------------------------------------------
 134
 135 class wxHtmlTag : public wxObject {
 136 public:
 137     // Never need to create a new tag from Python...
 138     //wxHtmlTag(const wxString& source, int pos, int end_pos, wxHtmlTagsCache* cache);
 139
 140     wxString GetName();
 141     bool HasParam(const wxString& par);
 142     wxString GetParam(const wxString& par, int with_commas = false);
 143
 144     // Can't do this one as-is, but GetParam should be enough...
 145     //int ScanParam(const wxString& par, const char *format, void* param);
 146
 147     wxString GetAllParams();
 148     bool HasEnding();
 149     int GetBeginPos();
 150     int GetEndPos1();
 151     int GetEndPos2();
 152 };
 153
 154 //---------------------------------------------------------------------------
 155
 156 class wxHtmlParser : public wxObject {
 157 public:
 158     // wxHtmlParser();  This is an abstract base class...
 159
 160     void SetFS(wxFileSystem *fs);
 161     wxFileSystem* GetFS();
 162     wxObject* Parse(const wxString& source);
 163     void InitParser(const wxString& source);
 164     void DoneParser();
 165     void DoParsing(int begin_pos, int end_pos);
 166     void StopParsing();
 167     // wxObject* GetProduct();
 168
 169     void AddTagHandler(wxHtmlTagHandler *handler);
 170     wxString* GetSource();
 171     void PushTagHandler(wxHtmlTagHandler* handler, wxString tags);
 172     void PopTagHandler();
 173
 174     // virtual wxFSFile *OpenURL(wxHtmlURLType type, const wxString& url) const;
 175
 176     // void AddText(const char* txt) = 0;
 177     // void AddTag(const wxHtmlTag& tag);
 178 };
 179
 180
 181 //---------------------------------------------------------------------------
 182
 183 class wxHtmlWinParser : public wxHtmlParser {
 184 public:
 185     wxHtmlWinParser(wxPyHtmlWindow *wnd = NULL);
 186
 187     void SetDC(wxDC *dc);
 188     wxDC* GetDC();
 189     int GetCharHeight();
 190     int GetCharWidth();
 191     wxPyHtmlWindow* GetWindow();
 192
 193     // Sets fonts to be used when displaying HTML page. (if size null then default sizes used).
 194     %extend {
 195         void SetFonts(wxString normal_face, wxString fixed_face, PyObject* sizes=NULL) {
 196             int* temp = NULL;
 197             if (sizes) temp = int_LIST_helper(sizes);
 198             self->SetFonts(normal_face, fixed_face, temp);
 199             if (temp)
 200                 delete [] temp;
 201         }
 202     }
 203
 204     // Sets font sizes to be relative to the given size or the system
 205     // default size; use either specified or default font
 206     void SetStandardFonts(int size = -1,
 207                           const wxString& normal_face = wxPyEmptyString,
 208                           const wxString& fixed_face = wxPyEmptyString);
 209
 210
 211     wxHtmlContainerCell* GetContainer();
 212     wxHtmlContainerCell* OpenContainer();
 213     wxHtmlContainerCell *SetContainer(wxHtmlContainerCell *c);
 214     wxHtmlContainerCell* CloseContainer();
 215
 216     int GetFontSize();
 217     void SetFontSize(int s);
 218     int GetFontBold();
 219     void SetFontBold(int x);
 220     int GetFontItalic();
 221     void SetFontItalic(int x);
 222     int GetFontUnderlined();
 223     void SetFontUnderlined(int x);
 224     int GetFontFixed();
 225     void SetFontFixed(int x);
 226     int GetAlign();
 227     void SetAlign(int a);
 228     wxColour GetLinkColor();
 229     void SetLinkColor(const wxColour& clr);
 230     wxColour GetActualColor();
 231     void SetActualColor(const wxColour& clr);
 232     %pythoncode {
 233         GetActualColour = GetActualColor
 234         SetActualColour = SetActualColor
 235     }
 236     void SetLink(const wxString& link);
 237     wxFont* CreateCurrentFont();
 238     wxHtmlLinkInfo GetLink();
 239
 240 };
 241
 242
 243 //---------------------------------------------------------------------------
 244
 245 %{
 246 class wxPyHtmlTagHandler : public wxHtmlTagHandler {
 247     DECLARE_DYNAMIC_CLASS(wxPyHtmlTagHandler)
 248 public:
 249     wxPyHtmlTagHandler() : wxHtmlTagHandler() {};
 250
 251     wxHtmlParser* GetParser() { return m_Parser; }
 252     void ParseInner(const wxHtmlTag& tag) { wxHtmlTagHandler::ParseInner(tag); }
 253
 254     DEC_PYCALLBACK_STRING__pure(GetSupportedTags);
 255     DEC_PYCALLBACK_BOOL_TAG_pure(HandleTag);
 256
 257     PYPRIVATE;
 258 };
 259
 260 IMPLEMENT_DYNAMIC_CLASS(wxPyHtmlTagHandler, wxHtmlTagHandler);
 261
 262 IMP_PYCALLBACK_STRING__pure(wxPyHtmlTagHandler, wxHtmlTagHandler, GetSupportedTags);
 263 IMP_PYCALLBACK_BOOL_TAG_pure(wxPyHtmlTagHandler, wxHtmlTagHandler, HandleTag);
 264 %}
 265
 266
 267 %rename(HtmlTagHandler) wxPyHtmlTagHandler;
 268 class wxPyHtmlTagHandler : public wxObject {
 269 public:
 270     %pythonAppend wxPyHtmlTagHandler   "self._setCallbackInfo(self, HtmlTagHandler)"
 271     wxPyHtmlTagHandler();
 272
 273     void _setCallbackInfo(PyObject* self, PyObject* _class);
 274
 275     void SetParser(wxHtmlParser *parser);
 276     wxHtmlParser* GetParser();
 277     void ParseInner(const wxHtmlTag& tag);
 278 };
 279
 280
 281 //---------------------------------------------------------------------------
 282
 283 %{
 284 class wxPyHtmlWinTagHandler : public wxHtmlWinTagHandler {
 285     DECLARE_DYNAMIC_CLASS(wxPyHtmlWinTagHandler)
 286 public:
 287     wxPyHtmlWinTagHandler() : wxHtmlWinTagHandler() {};
 288
 289     wxHtmlWinParser* GetParser() { return m_WParser; }
 290     void ParseInner(const wxHtmlTag& tag)
 291         { wxHtmlWinTagHandler::ParseInner(tag); }
 292
 293     DEC_PYCALLBACK_STRING__pure(GetSupportedTags);
 294     DEC_PYCALLBACK_BOOL_TAG_pure(HandleTag);
 295
 296     PYPRIVATE;
 297 };
 298
 299 IMPLEMENT_DYNAMIC_CLASS( wxPyHtmlWinTagHandler, wxHtmlWinTagHandler);
 300
 301 IMP_PYCALLBACK_STRING__pure(wxPyHtmlWinTagHandler, wxHtmlWinTagHandler, GetSupportedTags);
 302 IMP_PYCALLBACK_BOOL_TAG_pure(wxPyHtmlWinTagHandler, wxHtmlWinTagHandler, HandleTag);
 303 %}
 304
 305
 306 %rename(HtmlWinTagHandler) wxPyHtmlWinTagHandler;
 307 class wxPyHtmlWinTagHandler : public wxPyHtmlTagHandler {
 308 public:
 309     %pythonAppend wxPyHtmlWinTagHandler    "self._setCallbackInfo(self, HtmlWinTagHandler)"
 310     wxPyHtmlWinTagHandler();
 311
 312     void _setCallbackInfo(PyObject* self, PyObject* _class);
 313
 314     void SetParser(wxHtmlParser *parser);
 315     wxHtmlWinParser* GetParser();
 316     void ParseInner(const wxHtmlTag& tag);
 317 };
 318
 319
 320 //---------------------------------------------------------------------------
 321
 322 %{
 323
 324 class wxPyHtmlTagsModule : public wxHtmlTagsModule {
 325 public:
 326     wxPyHtmlTagsModule(PyObject* thc) : wxHtmlTagsModule() {
 327         m_tagHandlerClass = thc;
 328         Py_INCREF(m_tagHandlerClass);
 329         RegisterModule(this);
 330         wxHtmlWinParser::AddModule(this);
 331     }
 332
 333     void OnExit() {
 334         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 335         Py_DECREF(m_tagHandlerClass);
 336         m_tagHandlerClass = NULL;
 337         for (size_t x=0; x < m_objArray.GetCount(); x++) {
 338             PyObject* obj = (PyObject*)m_objArray.Item(x);
 339             Py_DECREF(obj);
 340         }
 341         wxPyEndBlockThreads(blocked);
 342     };
 343
 344     void FillHandlersTable(wxHtmlWinParser *parser) {
 345         // Wave our magic wand...  (if it works it's a miracle!  ;-)
 346
 347         // First, make a new instance of the tag handler
 348         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 349         PyObject* arg = PyTuple_New(0);
 350         PyObject* obj = PyObject_CallObject(m_tagHandlerClass, arg);
 351         Py_DECREF(arg);
 352
 353         // now figure out where it's C++ object is...
 354         wxPyHtmlWinTagHandler* thPtr;
 355         if (! wxPyConvertSwigPtr(obj, (void **)&thPtr, wxT("wxPyHtmlWinTagHandler"))) {
 356             wxPyEndBlockThreads(blocked);
 357             return;
 358         }
 359         wxPyEndBlockThreads(blocked);
 360
 361         // add it,
 362         parser->AddTagHandler(thPtr);
 363
 364         // and track it.
 365         m_objArray.Add(obj);
 366     }
 367
 368 private:
 369     PyObject*           m_tagHandlerClass;
 370     wxArrayPtrVoid      m_objArray;
 371
 372 };
 373 %}
 374
 375
 376
 377 %inline %{
 378     void wxHtmlWinParser_AddTagHandler(PyObject* tagHandlerClass) {
 379         // Dynamically create a new wxModule.  Refcounts tagHandlerClass
 380         // and adds itself to the wxModules list and to the wxHtmlWinParser.
 381         new wxPyHtmlTagsModule(tagHandlerClass);
 382     }
 383 %}
 384
 385
 386 //---------------------------------------------------------------------------
 387
 388 %typemap(out) wxHtmlCell*         { $result = wxPyMake_wxObject($1, $owner); }
 389 %typemap(out) const wxHtmlCell*   { $result = wxPyMake_wxObject($1, $owner); }
 390
 391 //---------------------------------------------------------------------------
 392 %newgroup
 393
 394
 395 // wxHtmlSelection is data holder with information about text selection.
 396 // Selection is defined by two positions (beginning and end of the selection)
 397 // and two leaf(!) cells at these positions.
 398 class wxHtmlSelection
 399 {
 400 public:
 401     wxHtmlSelection();
 402     ~wxHtmlSelection();
 403
 404     void Set(const wxPoint& fromPos, const wxHtmlCell *fromCell,
 405              const wxPoint& toPos, const wxHtmlCell *toCell);
 406     %Rename(SetCells, void, Set(const wxHtmlCell *fromCell, const wxHtmlCell *toCell));
 407
 408     const wxHtmlCell *GetFromCell() const;
 409     const wxHtmlCell *GetToCell() const;
 410
 411     // these values are in absolute coordinates:
 412     const wxPoint& GetFromPos() const;
 413     const wxPoint& GetToPos() const;
 414
 415     // these are From/ToCell's private data
 416     const wxPoint& GetFromPrivPos() const;
 417     const wxPoint& GetToPrivPos() const;
 418     void SetFromPrivPos(const wxPoint& pos);
 419     void SetToPrivPos(const wxPoint& pos);
 420     void ClearPrivPos();
 421
 422     const bool IsEmpty() const;
 423
 424 };
 425
 426
 427 enum wxHtmlSelectionState
 428 {
 429     wxHTML_SEL_OUT,     // currently rendered cell is outside the selection
 430     wxHTML_SEL_IN,      // ... is inside selection
 431     wxHTML_SEL_CHANGING // ... is the cell on which selection state changes
 432 };
 433
 434
 435
 436 // Selection state is passed to wxHtmlCell::Draw so that it can render itself
 437 // differently e.g. when inside text selection or outside it.
 438 class wxHtmlRenderingState
 439 {
 440 public:
 441     wxHtmlRenderingState();
 442     ~wxHtmlRenderingState();
 443
 444     void SetSelectionState(wxHtmlSelectionState s);
 445     wxHtmlSelectionState GetSelectionState() const;
 446
 447     void SetFgColour(const wxColour& c);
 448     const wxColour& GetFgColour() const;
 449     void SetBgColour(const wxColour& c);
 450     const wxColour& GetBgColour() const;
 451 };
 452
 453
 454
 455 // HTML rendering customization. This class is used when rendering wxHtmlCells
 456 // as a callback:
 457 class wxHtmlRenderingStyle
 458 {
 459 public:
 460     virtual wxColour GetSelectedTextColour(const wxColour& clr) = 0;
 461     virtual wxColour GetSelectedTextBgColour(const wxColour& clr) = 0;
 462 };
 463
 464 // Standard style:
 465 class wxDefaultHtmlRenderingStyle : public wxHtmlRenderingStyle
 466 {
 467 public:
 468     virtual wxColour GetSelectedTextColour(const wxColour& clr);
 469     virtual wxColour GetSelectedTextBgColour(const wxColour& clr);
 470 };
 471
 472
 473
 474 // Information given to cells when drawing them. Contains rendering state,
 475 // selection information and rendering style object that can be used to
 476 // customize the output.
 477 class wxHtmlRenderingInfo
 478 {
 479 public:
 480     wxHtmlRenderingInfo();
 481     ~wxHtmlRenderingInfo();
 482
 483     void SetSelection(wxHtmlSelection *s);
 484     wxHtmlSelection *GetSelection() const;
 485
 486     void SetStyle(wxHtmlRenderingStyle *style);
 487     wxHtmlRenderingStyle& GetStyle();
 488
 489     wxHtmlRenderingState& GetState();
 490 };
 491
 492 //---------------------------------------------------------------------------
 493 %newgroup
 494
 495
 496 enum
 497 {
 498     wxHTML_FIND_EXACT             = 1,
 499     wxHTML_FIND_NEAREST_BEFORE    = 2,
 500     wxHTML_FIND_NEAREST_AFTER     = 4
 501 };
 502
 503
 504 class wxHtmlCell : public wxObject {
 505 public:
 506     %typemap(out) wxHtmlCell*;    // turn off this typemap
 507
 508     wxHtmlCell();
 509
 510     // Turn it back on again
 511     %typemap(out) wxHtmlCell* { $result = wxPyMake_wxObject($1, $owner); }
 512
 513     int GetPosX();
 514     int GetPosY();
 515     int GetWidth();
 516     int GetHeight();
 517     int GetDescent();
 518
 519     // Returns the maximum possible length of the cell.
 520     // Call Layout at least once before using GetMaxTotalWidth()
 521     int GetMaxTotalWidth() const;
 522
 523     const wxString& GetId() const;
 524     void SetId(const wxString& id);
 525     wxHtmlLinkInfo* GetLink(int x = 0, int y = 0);
 526     wxHtmlCell* GetNext();
 527     wxHtmlContainerCell* GetParent();
 528     wxHtmlCell* GetFirstChild() const;
 529
 530     // Returns cursor to be used when mouse is over the cell:
 531     wxCursor GetCursor() const;
 532
 533     // Formatting cells are not visible on the screen, they only alter
 534     // renderer's state.
 535     bool IsFormattingCell() const;
 536
 537
 538     void SetLink(const wxHtmlLinkInfo& link);
 539     void SetNext(wxHtmlCell *cell);
 540     void SetParent(wxHtmlContainerCell *p);
 541     void SetPos(int x, int y);
 542     void Layout(int w);
 543     void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2,
 544               wxHtmlRenderingInfo& info);
 545     void DrawInvisible(wxDC& dc, int x, int y,
 546               wxHtmlRenderingInfo& info);
 547     const wxHtmlCell* Find(int condition, const void* param);
 548
 549     bool AdjustPagebreak(int* INOUT);
 550     void SetCanLiveOnPagebreak(bool can);
 551
 552     // Can the line be broken before this cell?
 553     bool IsLinebreakAllowed() const;
 554
 555     // Returns True for simple == terminal cells, i.e. not composite ones.
 556     // This if for internal usage only and may disappear in future versions!
 557     bool IsTerminalCell() const;
 558
 559     // Find a cell inside this cell positioned at the given coordinates
 560     // (relative to this's positions). Returns NULL if no such cell exists.
 561     // The flag can be used to specify whether to look for terminal or
 562     // nonterminal cells or both. In either case, returned cell is deepest
 563     // cell in cells tree that contains [x,y].
 564     wxHtmlCell *FindCellByPos(wxCoord x, wxCoord y,
 565                                   unsigned flags = wxHTML_FIND_EXACT) const;
 566
 567     // Returns absolute position of the cell on HTML canvas
 568     wxPoint GetAbsPos() const;
 569
 570     // Returns first (last) terminal cell inside this cell. It may return NULL,
 571     // but it is rare -- only if there are no terminals in the tree.
 572     wxHtmlCell *GetFirstTerminal() const ;
 573     wxHtmlCell *GetLastTerminal() const ;
 574
 575     // Returns cell's depth, i.e. how far under the root cell it is
 576     // (if it is the root, depth is 0)
 577     unsigned GetDepth() const;
 578
 579     // Returns True if the cell appears before 'cell' in natural order of
 580     // cells (= as they are read). If cell A is (grand)parent of cell B,
 581     // then both A.IsBefore(B) and B.IsBefore(A) always return True.
 582     bool IsBefore(wxHtmlCell *cell) const;
 583
 584     // Converts the cell into text representation. If sel != NULL then
 585     // only part of the cell inside the selection is converted.
 586     wxString ConvertToText(wxHtmlSelection *sel) const;
 587 };
 588
 589
 590 class  wxHtmlWordCell : public wxHtmlCell
 591 {
 592 public:
 593     wxHtmlWordCell(const wxString& word, wxDC& dc);
 594     wxString ConvertToText(wxHtmlSelection *sel) const;
 595     bool IsLinebreakAllowed() const;
 596     void SetPreviousWord(wxHtmlWordCell *cell);
 597 };
 598
 599
 600 class wxHtmlContainerCell : public wxHtmlCell {
 601 public:
 602     wxHtmlContainerCell(wxHtmlContainerCell *parent);
 603
 604     void InsertCell(wxHtmlCell *cell);
 605     void SetAlignHor(int al);
 606     int GetAlignHor();
 607     void SetAlignVer(int al);
 608     int GetAlignVer();
 609     void SetIndent(int i, int what, int units = wxHTML_UNITS_PIXELS);
 610     int GetIndent(int ind);
 611     int GetIndentUnits(int ind);
 612     void SetAlign(const wxHtmlTag& tag);
 613     void SetWidthFloat(int w, int units);
 614     %Rename(SetWidthFloatFromTag, void,  SetWidthFloat(const wxHtmlTag& tag));
 615     void SetMinHeight(int h, int align = wxHTML_ALIGN_TOP);
 616     void SetBackgroundColour(const wxColour& clr);
 617     wxColour GetBackgroundColour();
 618     void SetBorder(const wxColour& clr1, const wxColour& clr2);
 619     wxHtmlCell* GetFirstChild();
 620     %pragma(python) addtoclass = "GetFirstCell = GetFirstChild"
 621 };
 622
 623
 624
 625 class wxHtmlColourCell : public wxHtmlCell {
 626 public:
 627     wxHtmlColourCell(const wxColour& clr, int flags = wxHTML_CLR_FOREGROUND);
 628
 629 };
 630
 631
 632 class  wxHtmlFontCell : public wxHtmlCell
 633 {
 634 public:
 635     wxHtmlFontCell(wxFont *font);
 636 };
 637
 638
 639 class wxHtmlWidgetCell : public wxHtmlCell {
 640 public:
 641     wxHtmlWidgetCell(wxWindow* wnd, int w = 0);
 642
 643 };
 644
 645
 646
 647
 648 //---------------------------------------------------------------------------
 649 // wxHtmlFilter
 650 //---------------------------------------------------------------------------
 651 %newgroup
 652
 653
 654 %{ // here's the C++ version
 655 class wxPyHtmlFilter : public wxHtmlFilter {
 656     DECLARE_ABSTRACT_CLASS(wxPyHtmlFilter)
 657 public:
 658     wxPyHtmlFilter() : wxHtmlFilter() {}
 659
 660     // returns True if this filter is able to open&read given file
 661     virtual bool CanRead(const wxFSFile& file) const {
 662         bool rval = false;
 663         bool found;
 664         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 665         if ((found = wxPyCBH_findCallback(m_myInst, "CanRead"))) {
 666             PyObject* obj = wxPyMake_wxObject((wxFSFile*)&file,false);  // cast away const
 667             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));
 668             Py_DECREF(obj);
 669         }
 670         wxPyEndBlockThreads(blocked);
 671         return rval;
 672     }
 673
 674
 675     // Reads given file and returns HTML document.
 676     // Returns empty string if opening failed
 677     virtual wxString ReadFile(const wxFSFile& file) const {
 678         wxString rval;
 679         bool found;
 680         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 681         if ((found = wxPyCBH_findCallback(m_myInst, "ReadFile"))) {
 682             PyObject* obj = wxPyMake_wxObject((wxFSFile*)&file,false);  // cast away const
 683             PyObject* ro;
 684             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(O)", obj));
 685             Py_DECREF(obj);
 686             if (ro) {
 687                 rval = Py2wxString(ro);
 688                 Py_DECREF(ro);
 689             }
 690         }
 691         wxPyEndBlockThreads(blocked);
 692         return rval;
 693     }
 694
 695     PYPRIVATE;
 696 };
 697
 698 IMPLEMENT_ABSTRACT_CLASS(wxPyHtmlFilter, wxHtmlFilter);
 699 %}
 700
 701
 702 // And now the version seen by SWIG
 703
 704 %rename(HtmlFilter) wxPyHtmlFilter;
 705 class wxPyHtmlFilter : public wxObject {
 706 public:
 707     %pythonAppend wxPyHtmlFilter   "self._setCallbackInfo(self, HtmlFilter)"
 708     wxPyHtmlFilter();
 709
 710     void _setCallbackInfo(PyObject* self, PyObject* _class);
 711 };
 712
 713
 714 // TODO: wxHtmlFilterHTML
 715
 716
 717 //---------------------------------------------------------------------------
 718 // wxHtmlWindow
 719 //---------------------------------------------------------------------------
 720 %newgroup
 721
 722 %{
 723 class wxPyHtmlWindow : public wxHtmlWindow {
 724     DECLARE_ABSTRACT_CLASS(wxPyHtmlWindow)
 725 public:
 726     wxPyHtmlWindow(wxWindow *parent, wxWindowID id = -1,
 727                    const wxPoint& pos = wxDefaultPosition,
 728                    const wxSize& size = wxDefaultSize,
 729                    long style = wxHW_DEFAULT_STYLE,
 730                    const wxString& name = wxPyHtmlWindowNameStr)
 731         : wxHtmlWindow(parent, id, pos, size, style, name)  {};
 732     wxPyHtmlWindow() : wxHtmlWindow() {};
 733
 734     bool ScrollToAnchor(const wxString& anchor) {
 735         return wxHtmlWindow::ScrollToAnchor(anchor);
 736     }
 737
 738     bool HasAnchor(const wxString& anchor) {
 739         const wxHtmlCell *c = m_Cell->Find(wxHTML_COND_ISANCHOR, &anchor);
 740         return c!=NULL;
 741     }
 742
 743     void OnLinkClicked(const wxHtmlLinkInfo& link);
 744
 745     wxHtmlOpeningStatus OnOpeningURL(wxHtmlURLType type,
 746                                       const wxString& url,
 747                                       wxString *redirect) const;
 748
 749     DEC_PYCALLBACK__STRING(OnSetTitle);
 750     DEC_PYCALLBACK__CELLINTINT(OnCellMouseHover);
 751     DEC_PYCALLBACK__CELLINTINTME(OnCellClicked);
 752     PYPRIVATE;
 753 };
 754
 755 IMPLEMENT_ABSTRACT_CLASS( wxPyHtmlWindow, wxHtmlWindow );
 756 IMP_PYCALLBACK__STRING(wxPyHtmlWindow, wxHtmlWindow, OnSetTitle);
 757 IMP_PYCALLBACK__CELLINTINT(wxPyHtmlWindow, wxHtmlWindow, OnCellMouseHover);
 758 IMP_PYCALLBACK__CELLINTINTME(wxPyHtmlWindow, wxHtmlWindow, OnCellClicked);
 759
 760
 761 void wxPyHtmlWindow::OnLinkClicked(const wxHtmlLinkInfo& link) {
 762     bool found;
 763     wxPyBlock_t blocked = wxPyBeginBlockThreads();
 764     if ((found = wxPyCBH_findCallback(m_myInst, "OnLinkClicked"))) {
 765         PyObject* obj = wxPyConstructObject((void*)&link, wxT("wxHtmlLinkInfo"), 0);
 766         wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));
 767         Py_DECREF(obj);
 768     }
 769     wxPyEndBlockThreads(blocked);
 770     if (! found)
 771         wxHtmlWindow::OnLinkClicked(link);
 772 }
 773
 774
 775 wxHtmlOpeningStatus wxPyHtmlWindow::OnOpeningURL(wxHtmlURLType type,
 776                                                  const wxString& url,
 777                                                  wxString *redirect) const {
 778     bool found;
 779     wxHtmlOpeningStatus rval;
 780     wxPyBlock_t blocked = wxPyBeginBlockThreads();
 781     if ((found = wxPyCBH_findCallback(m_myInst, "OnOpeningURL"))) {
 782         PyObject* ro;
 783         PyObject* s = wx2PyString(url);
 784         ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(iO)", type, s));
 785         Py_DECREF(s);
 786         if (PyString_Check(ro)
 787 #if PYTHON_API_VERSION >= 1009
 788             || PyUnicode_Check(ro)
 789 #endif
 790             ) {
 791             *redirect = Py2wxString(ro);
 792             rval = wxHTML_REDIRECT;
 793         }
 794         else {
 795             PyObject* num = PyNumber_Int(ro);
 796             rval = (wxHtmlOpeningStatus)PyInt_AsLong(num);
 797             Py_DECREF(num);
 798         }
 799         Py_DECREF(ro);
 800     }
 801     wxPyEndBlockThreads(blocked);
 802     if (! found)
 803         rval = wxHtmlWindow::OnOpeningURL(type, url, redirect);
 804     return rval;
 805 }
 806
 807
 808 %}
 809
 810
 811
 812 MustHaveApp(wxPyHtmlWindow);
 813
 814 %rename(HtmlWindow) wxPyHtmlWindow;
 815 class wxPyHtmlWindow : public wxScrolledWindow {
 816 public:
 817     %pythonAppend wxPyHtmlWindow      "self._setCallbackInfo(self, HtmlWindow); self._setOORInfo(self)"
 818     %pythonAppend wxPyHtmlWindow()    ""
 819     %typemap(out) wxPyHtmlWindow*;    // turn off this typemap
 820
 821     wxPyHtmlWindow(wxWindow *parent, int id = -1,
 822                  const wxPoint& pos = wxDefaultPosition,
 823                  const wxSize& size = wxDefaultSize,
 824                  int style=wxHW_DEFAULT_STYLE,
 825                  const wxString& name = wxPyHtmlWindowNameStr);
 826     %RenameCtor(PreHtmlWindow, wxPyHtmlWindow());
 827
 828     // Turn it back on again
 829     %typemap(out) wxPyHtmlWindow* { $result = wxPyMake_wxObject($1, $owner); }
 830
 831     bool Create(wxWindow *parent, int id = -1,
 832                 const wxPoint& pos = wxDefaultPosition,
 833                 const wxSize& size = wxDefaultSize,
 834                 int style=wxHW_SCROLLBAR_AUTO,
 835                 const wxString& name = wxPyHtmlWindowNameStr);
 836
 837
 838     void _setCallbackInfo(PyObject* self, PyObject* _class);
 839
 840
 841     // Set HTML page and display it. !! source is HTML document itself,
 842     // it is NOT address/filename of HTML document. If you want to
 843     // specify document location, use LoadPage() istead
 844     // Return value : False if an error occurred, True otherwise
 845     bool SetPage(const wxString& source);
 846
 847     // Load HTML page from given location. Location can be either
 848     // a) /usr/wxGTK2/docs/html/wx.htm
 849     // b) http://www.somewhere.uk/document.htm
 850     // c) ftp://ftp.somesite.cz/pub/something.htm
 851     // In case there is no prefix (http:,ftp:), the method
 852     // will try to find it itself (1. local file, then http or ftp)
 853     // After the page is loaded, the method calls SetPage() to display it.
 854     // Note : you can also use path relative to previously loaded page
 855     // Return value : same as SetPage
 856     bool LoadPage(const wxString& location);
 857
 858     // Loads HTML page from file
 859     bool LoadFile(const wxString& filename);
 860
 861     // Append to current page
 862     bool AppendToPage(const wxString& source);
 863
 864      // Returns full location of opened page
 865     wxString GetOpenedPage();
 866
 867     // Returns anchor within opened page
 868     wxString GetOpenedAnchor();
 869
 870     // Returns <TITLE> of opened page or empty string otherwise
 871     wxString GetOpenedPageTitle();
 872
 873     // Sets frame in which page title will  be displayed. Format is format of
 874     // frame title, e.g. "HtmlHelp : %s". It must contain exactly one %s
 875     void SetRelatedFrame(wxFrame* frame, const wxString& format);
 876     wxFrame* GetRelatedFrame();
 877
 878     // After(!) calling SetRelatedFrame, this sets statusbar slot where messages
 879     // will be displayed. Default is -1 = no messages.
 880     void SetRelatedStatusBar(int bar);
 881
 882     // Sets fonts to be used when displaying HTML page.
 883     %extend {
 884         void SetFonts(wxString normal_face, wxString fixed_face, PyObject* sizes=NULL) {
 885             int* temp = NULL;
 886             if (sizes) temp = int_LIST_helper(sizes);
 887             self->SetFonts(normal_face, fixed_face, temp);
 888             if (temp)
 889                 delete [] temp;
 890         }
 891     }
 892
 893     // Sets font sizes to be relative to the given size or the system
 894     // default size; use either specified or default font
 895     void SetStandardFonts(int size = -1,
 896                           const wxString& normal_face = wxPyEmptyString,
 897                           const wxString& fixed_face = wxPyEmptyString);
 898
 899     DocDeclStr(
 900         void, SetLabel(const wxString& title),
 901         "", "");
 902
 903     // Sets space between text and window borders.
 904     void SetBorders(int b);
 905
 906     // Sets the bitmap to use for background (currnetly it will be tiled,
 907     // when/if we have CSS support we could add other possibilities...)
 908     void SetBackgroundImage(const wxBitmap& bmpBg);
 909
 910     // Saves custom settings into cfg config. it will use the path 'path'
 911     // if given, otherwise it will save info into currently selected path.
 912     // saved values : things set by SetFonts, SetBorders.
 913     void ReadCustomization(wxConfigBase *cfg, wxString path = wxPyEmptyString);
 914     void WriteCustomization(wxConfigBase *cfg, wxString path = wxPyEmptyString);
 915
 916     // Goes to previous/next page (in browsing history)
 917     // Returns True if successful, False otherwise
 918     bool HistoryBack();
 919     bool HistoryForward();
 920     bool HistoryCanBack();
 921     bool HistoryCanForward();
 922
 923     // Resets History
 924     void HistoryClear();
 925
 926     // Returns pointer to conteiners/cells structure.
 927     wxHtmlContainerCell* GetInternalRepresentation();
 928
 929     // Returns a pointer to the parser.
 930     wxHtmlWinParser* GetParser();
 931
 932     bool ScrollToAnchor(const wxString& anchor);
 933     bool HasAnchor(const wxString& anchor);
 934
 935     //Adds input filter
 936     static void AddFilter(wxPyHtmlFilter *filter);
 937
 938     // Helper functions to select parts of page:
 939     void SelectWord(const wxPoint& pos);
 940     void SelectLine(const wxPoint& pos);
 941     void SelectAll();
 942
 943     // Convert selection to text:
 944     wxString SelectionToText();
 945
 946     // Converts current page to text:
 947     wxString ToText();
 948
 949     void OnLinkClicked(const wxHtmlLinkInfo& link);
 950     void OnSetTitle(const wxString& title);
 951     void OnCellMouseHover(wxHtmlCell *cell, wxCoord x, wxCoord y);
 952     void OnCellClicked(wxHtmlCell *cell,
 953                        wxCoord x, wxCoord y,
 954                        const wxMouseEvent& event);
 955     %MAKE_BASE_FUNC(HtmlWindow, OnLinkClicked);
 956     %MAKE_BASE_FUNC(HtmlWindow, OnSetTitle);
 957     %MAKE_BASE_FUNC(HtmlWindow, OnCellMouseHover);
 958     %MAKE_BASE_FUNC(HtmlWindow, OnCellClicked);
 959
 960     static wxVisualAttributes
 961     GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
 962 };
 963
 964
 965
 966
 967 //---------------------------------------------------------------------------
 968 //---------------------------------------------------------------------------
 969 %newgroup
 970
 971
 972 MustHaveApp(wxHtmlDCRenderer);
 973
 974 class wxHtmlDCRenderer : public wxObject {
 975 public:
 976     wxHtmlDCRenderer();
 977     ~wxHtmlDCRenderer();
 978
 979     void SetDC(wxDC *dc, int maxwidth);
 980     void SetSize(int width, int height);
 981     void SetHtmlText(const wxString& html,
 982                      const wxString& basepath = wxPyEmptyString,
 983                      bool isdir = true);
 984     // Sets fonts to be used when displaying HTML page. (if size null then default sizes used).
 985     %extend {
 986         void SetFonts(wxString normal_face, wxString fixed_face, PyObject* sizes=NULL) {
 987             int* temp = NULL;
 988             if (sizes) temp = int_LIST_helper(sizes);
 989             self->SetFonts(normal_face, fixed_face, temp);
 990             if (temp)
 991                 delete [] temp;
 992         }
 993     }
 994
 995     // Sets font sizes to be relative to the given size or the system
 996     // default size; use either specified or default font
 997     void SetStandardFonts(int size = -1,
 998                           const wxString& normal_face = wxPyEmptyString,
 999                           const wxString& fixed_face = wxPyEmptyString);
1000
1001     int Render(int x, int y, int from = 0, int dont_render = false, int maxHeight = INT_MAX,
1002                //int *known_pagebreaks = NULL, int number_of_pages = 0
1003                int* choices=NULL, int LCOUNT = 0
1004                );
1005     int GetTotalHeight();
1006                 // returns total height of the html document
1007                 // (compare Render's return value with this)
1008 };
1009
1010
1011 enum {
1012     wxPAGE_ODD,
1013     wxPAGE_EVEN,
1014     wxPAGE_ALL
1015 };
1016
1017
1018 MustHaveApp(wxHtmlPrintout);
1019
1020 class wxHtmlPrintout : public wxPyPrintout {
1021 public:
1022     wxHtmlPrintout(const wxString& title = wxPyHtmlPrintoutTitleStr);
1023     //~wxHtmlPrintout();   wxPrintPreview object takes ownership...
1024
1025     void SetHtmlText(const wxString& html,
1026                      const wxString &basepath = wxPyEmptyString,
1027                      bool isdir = true);
1028     void SetHtmlFile(const wxString &htmlfile);
1029     void SetHeader(const wxString& header, int pg = wxPAGE_ALL);
1030     void SetFooter(const wxString& footer, int pg = wxPAGE_ALL);
1031
1032     // Sets fonts to be used when displaying HTML page. (if size null then default sizes used).
1033     %extend {
1034         void SetFonts(wxString normal_face, wxString fixed_face, PyObject* sizes=NULL) {
1035             int* temp = NULL;
1036             if (sizes) temp = int_LIST_helper(sizes);
1037             self->SetFonts(normal_face, fixed_face, temp);
1038             if (temp)
1039                 delete [] temp;
1040         }
1041     }
1042
1043     // Sets font sizes to be relative to the given size or the system
1044     // default size; use either specified or default font
1045     void SetStandardFonts(int size = -1,
1046                           const wxString& normal_face = wxPyEmptyString,
1047                           const wxString& fixed_face = wxPyEmptyString);
1048
1049     void SetMargins(float top = 25.2, float bottom = 25.2,
1050                     float left = 25.2, float right = 25.2,
1051                     float spaces = 5);
1052
1053     // Adds input filter
1054     static void AddFilter(wxHtmlFilter *filter);
1055
1056     // Cleanup
1057     static void CleanUpStatics();
1058 };
1059
1060
1061
1062 MustHaveApp(wxHtmlEasyPrinting);
1063
1064 class wxHtmlEasyPrinting : public wxObject {
1065 public:
1066     wxHtmlEasyPrinting(const wxString& name = wxPyHtmlPrintingTitleStr,
1067                        wxWindow *parentWindow = NULL);
1068     ~wxHtmlEasyPrinting();
1069
1070     void PreviewFile(const wxString &htmlfile);
1071     void PreviewText(const wxString &htmltext, const wxString& basepath = wxPyEmptyString);
1072     void PrintFile(const wxString &htmlfile);
1073     void PrintText(const wxString &htmltext, const wxString& basepath = wxPyEmptyString);
1074 //    void PrinterSetup();
1075     void PageSetup();
1076     void SetHeader(const wxString& header, int pg = wxPAGE_ALL);
1077     void SetFooter(const wxString& footer, int pg = wxPAGE_ALL);
1078
1079     %extend {
1080         void SetFonts(wxString normal_face, wxString fixed_face, PyObject* sizes=NULL) {
1081             int* temp = NULL;
1082             if (sizes) temp = int_LIST_helper(sizes);
1083             self->SetFonts(normal_face, fixed_face, temp);
1084             if (temp)
1085                 delete [] temp;
1086         }
1087     }
1088
1089     // Sets font sizes to be relative to the given size or the system
1090     // default size; use either specified or default font
1091     void SetStandardFonts(int size = -1,
1092                           const wxString& normal_face = wxPyEmptyString,
1093                           const wxString& fixed_face = wxPyEmptyString);
1094
1095     wxPrintData *GetPrintData() {return m_PrintData;}
1096     wxPageSetupDialogData *GetPageSetupData() {return m_PageSetupData;}
1097
1098 };
1099
1100
1101 //---------------------------------------------------------------------------
1102 //---------------------------------------------------------------------------
1103 %newgroup
1104
1105
1106 class wxHtmlBookRecord {
1107 public:
1108     wxHtmlBookRecord(const wxString& bookfile, const wxString& basepath,
1109                      const wxString& title, const wxString& start);
1110
1111     wxString GetBookFile();
1112     wxString GetTitle();
1113     wxString GetStart();
1114     wxString GetBasePath();
1115
1116     void SetContentsRange(int start, int end);
1117     int GetContentsStart();
1118     int GetContentsEnd();
1119
1120     void SetTitle(const wxString& title);
1121     void SetBasePath(const wxString& path);
1122     void SetStart(const wxString& start);
1123
1124     wxString GetFullPath(const wxString &page) const;
1125 };
1126
1127 //---------------------------------------------------------------------------
1128 // WXWIN_COMPATIBILITY_2_4
1129 #if 0
1130 struct wxHtmlContentsItem
1131 {
1132     %extend {
1133         int GetLevel() { return self->m_Level; }
1134         int GetID() { return self->m_ID; }
1135         wxString GetName() { return self->m_Name; }
1136         wxString GetPage() { return self->m_Page; }
1137         wxHtmlBookRecord* GetBook() { return self->m_Book; }
1138     }
1139 };
1140 #endif
1141 //---------------------------------------------------------------------------
1142
1143 class wxHtmlSearchStatus
1144 {
1145 public:
1146     //wxHtmlSearchStatus(wxHtmlHelpData* base, const wxString& keyword,
1147     //                   const wxString& book = wxPyEmptyString);
1148     bool Search();
1149     bool IsActive();
1150     int GetCurIndex();
1151     int GetMaxIndex();
1152     const wxString& GetName();
1153 };
1154
1155 //---------------------------------------------------------------------------
1156
1157 class wxHtmlHelpData {
1158 public:
1159     wxHtmlHelpData();
1160     ~wxHtmlHelpData();
1161
1162     void SetTempDir(const wxString& path);
1163     bool AddBook(const wxString& book);
1164 //      bool AddBookParam(const wxString& title, const wxString& contfile,
1165 //                    const wxString& indexfile=wxPyEmptyString,
1166 //                    const wxString& deftopic=wxPyEmptyString,
1167 //                    const wxString& path=wxPyEmptyString);
1168
1169     wxString FindPageByName(const wxString& page);
1170     wxString FindPageById(int id);
1171
1172     // TODO: this one needs fixed...
1173     const wxHtmlBookRecArray& GetBookRecArray();
1174
1175 };
1176
1177 //---------------------------------------------------------------------------
1178
1179 enum {
1180     wxHF_TOOLBAR,
1181     wxHF_CONTENTS,
1182     wxHF_INDEX,
1183     wxHF_SEARCH,
1184     wxHF_BOOKMARKS,
1185     wxHF_OPEN_FILES,
1186     wxHF_PRINT,
1187     wxHF_FLAT_TOOLBAR,
1188     wxHF_MERGE_BOOKS,
1189     wxHF_ICONS_BOOK,
1190     wxHF_ICONS_BOOK_CHAPTER,
1191     wxHF_ICONS_FOLDER,
1192     wxHF_DEFAULT_STYLE,
1193
1194     wxHF_EMBEDDED,
1195     wxHF_DIALOG,
1196     wxHF_FRAME,
1197     wxHF_MODAL,
1198 };
1199
1200 enum {
1201     wxID_HTML_PANEL,
1202     wxID_HTML_BACK,
1203     wxID_HTML_FORWARD,
1204     wxID_HTML_UPNODE,
1205     wxID_HTML_UP,
1206     wxID_HTML_DOWN,
1207     wxID_HTML_PRINT,
1208     wxID_HTML_OPENFILE,
1209     wxID_HTML_OPTIONS,
1210     wxID_HTML_BOOKMARKSLIST,
1211     wxID_HTML_BOOKMARKSADD,
1212     wxID_HTML_BOOKMARKSREMOVE,
1213     wxID_HTML_TREECTRL,
1214     wxID_HTML_INDEXPAGE,
1215     wxID_HTML_INDEXLIST,
1216     wxID_HTML_INDEXTEXT,
1217     wxID_HTML_INDEXBUTTON,
1218     wxID_HTML_INDEXBUTTONALL,
1219     wxID_HTML_NOTEBOOK,
1220     wxID_HTML_SEARCHPAGE,
1221     wxID_HTML_SEARCHTEXT,
1222     wxID_HTML_SEARCHLIST,
1223     wxID_HTML_SEARCHBUTTON,
1224     wxID_HTML_SEARCHCHOICE,
1225     wxID_HTML_COUNTINFO
1226 };
1227
1228
1229
1230 MustHaveApp(wxHtmlHelpWindow);
1231
1232 class wxHtmlHelpWindow : public wxWindow
1233 {
1234 public:
1235     %pythonAppend wxHtmlHelpWindow    "self._setOORInfo(self)"
1236     %pythonAppend wxHtmlHelpWindow()       ""
1237     %typemap(out) wxHtmlHelpWindow*;    // turn off this typemap
1238
1239     wxHtmlHelpWindow(wxWindow* parent, wxWindowID wxWindowID,
1240                      const wxPoint& pos = wxDefaultPosition,
1241                      const wxSize& size = wxDefaultSize,
1242                      int style = wxTAB_TRAVERSAL|wxNO_BORDER,
1243                      int helpStyle = wxHF_DEFAULT_STYLE,
1244                      wxHtmlHelpData* data = NULL);
1245     %RenameCtor(PreHtmlHelpWindow, wxHtmlHelpWindow(wxHtmlHelpData* data = NULL));
1246
1247     // Turn it back on again
1248     %typemap(out) wxHtmlHelpWindow* { $result = wxPyMake_wxObject($1, $owner); }
1249
1250     bool Create(wxWindow* parent, wxWindowID id,
1251                 const wxPoint& pos = wxDefaultPosition,
1252                 const wxSize& size = wxDefaultSize,
1253                 int style = wxTAB_TRAVERSAL|wxNO_BORDER,
1254                 int helpStyle = wxHF_DEFAULT_STYLE);
1255
1256     wxHtmlHelpData* GetData();
1257     wxHtmlHelpController* GetController() const;
1258
1259     %disownarg( wxHtmlHelpController* controller );
1260     void SetController(wxHtmlHelpController* controller);
1261     %cleardisown( wxHtmlHelpController* controller );
1262
1263     // Displays page x. If not found it will offect the user a choice of
1264     // searching books.
1265     // Looking for the page runs in these steps:
1266     // 1. try to locate file named x (if x is for example "doc/howto.htm")
1267     // 2. try to open starting page of book x
1268     // 3. try to find x in contents (if x is for example "How To ...")
1269     // 4. try to find x in index (if x is for example "How To ...")
1270     bool Display(const wxString& x);
1271
1272     // Alternative version that works with numeric ID.
1273     // (uses extension to MS format, <param name="ID" value=id>, see docs)
1274     %Rename(DisplayID,  bool,  Display(int id));
1275
1276     // Displays help window and focuses contents.
1277     bool DisplayContents();
1278
1279     // Displays help window and focuses index.
1280     bool DisplayIndex();
1281
1282     // Searches for keyword. Returns true and display page if found, return
1283     // false otherwise
1284     // Syntax of keyword is Altavista-like:
1285     // * words are separated by spaces
1286     //   (but "\"hello world\"" is only one world "hello world")
1287     // * word may be pretended by + or -
1288     //   (+ : page must contain the word ; - : page can't contain the word)
1289     // * if there is no + or - before the word, + is default
1290     bool KeywordSearch(const wxString& keyword,
1291                        wxHelpSearchMode mode = wxHELP_SEARCH_ALL);
1292
1293     void UseConfig(wxConfigBase *config, const wxString& rootpath = wxEmptyString);
1294
1295     // Saves custom settings into cfg config. it will use the path 'path'
1296     // if given, otherwise it will save info into currently selected path.
1297     // saved values : things set by SetFonts, SetBorders.
1298     void ReadCustomization(wxConfigBase *cfg, const wxString& path = wxEmptyString);
1299     void WriteCustomization(wxConfigBase *cfg, const wxString& path = wxEmptyString);
1300
1301     // call this to let wxHtmlHelpWindow know page changed
1302     void NotifyPageChanged();
1303
1304     // Refreshes Contents and Index tabs
1305     void RefreshLists();
1306
1307     // Gets the HTML window
1308     wxHtmlWindow* GetHtmlWindow() const;
1309
1310     // Gets the splitter window
1311     wxSplitterWindow* GetSplitterWindow();
1312
1313     // Gets the toolbar
1314     wxToolBar* GetToolBar() const;
1315
1316     // Gets the configuration data
1317     wxHtmlHelpFrameCfg& GetCfgData();
1318
1319     // Gets the tree control
1320     wxTreeCtrl *GetTreeCtrl() const;
1321
1322 };
1323
1324
1325 class wxHtmlWindowEvent: public wxNotifyEvent
1326 {
1327 public:
1328     wxHtmlWindowEvent(wxEventType commandType = wxEVT_NULL, int id = 0):
1329         wxNotifyEvent(commandType, id);
1330
1331     void SetURL(const wxString& url);
1332     const wxString& GetURL() const;
1333 };
1334
1335
1336
1337 MustHaveApp(wxHtmlHelpFrame);
1338
1339 class wxHtmlHelpFrame : public wxFrame {
1340 public:
1341     %pythonAppend wxHtmlHelpFrame    "self._setOORInfo(self)"
1342     %pythonAppend wxHtmlHelpFrame()       ""
1343     %typemap(out) wxHtmlHelpFrame*;    // turn off this typemap
1344
1345     wxHtmlHelpFrame(wxWindow* parent, int wxWindowID,
1346                     const wxString& title = wxPyEmptyString,
1347                     int style = wxHF_DEFAULTSTYLE, wxHtmlHelpData* data = NULL);
1348     %RenameCtor(PreHtmlHelpFrame, wxHtmlHelpFrame(wxHtmlHelpData* data = NULL));
1349
1350     // Turn it back on again
1351     %typemap(out) wxHtmlHelpFrame* { $result = wxPyMake_wxObject($1, $owner); }
1352
1353     bool Create(wxWindow* parent, wxWindowID id,
1354                 const wxString& title = wxPyEmptyString,
1355                 int style = wxHF_DEFAULT_STYLE);
1356
1357     wxHtmlHelpData* GetData();
1358     void SetTitleFormat(const wxString& format);
1359
1360     void AddGrabIfNeeded();
1361
1362     /// Returns the help controller associated with the window.
1363     wxHtmlHelpController* GetController() const;
1364
1365     /// Sets the help controller associated with the window.
1366     %disownarg( wxHtmlHelpController* controller );
1367     void SetController(wxHtmlHelpController* controller);
1368     %cleardisown( wxHtmlHelpController* controller );
1369
1370     /// Returns the help window.
1371     wxHtmlHelpWindow* GetHelpWindow() const;
1372
1373     %pythoncode {
1374         %# For compatibility from before the refactor
1375         def Display(self, x):
1376             return self.GetHelpWindow().Display(x)
1377         def DisplayID(self, x):
1378             return self.GetHelpWindow().DisplayID(id)
1379         def DisplayContents(self):
1380             return self.GetHelpWindow().DisplayContents()
1381         def DisplayIndex(self):
1382             return self.GetHelpWindow().DisplayIndex()
1383
1384         def KeywordSearch(self, keyword):
1385             return self.GetHelpWindow().KeywordSearch(keyword)
1386
1387         def UseConfig(self, config, rootpath=""):
1388             return self.GetHelpWindow().UseConfig(config, rootpath)
1389         def ReadCustomization(self, config, rootpath=""):
1390             return self.GetHelpWindow().ReadCustomization(config, rootpath)
1391         def WriteCustomization(self, config, rootpath=""):
1392             return self.GetHelpWindow().WriteCustomization(config, rootpath)
1393      %}
1394 };
1395
1396
1397
1398 MustHaveApp(wxHtmlHelpDialog);
1399
1400 class wxHtmlHelpDialog : public wxDialog
1401 {
1402 public:
1403     %pythonAppend wxHtmlHelpDialog    "self._setOORInfo(self)"
1404     %pythonAppend wxHtmlHelpDialog()       ""
1405     %typemap(out) wxHtmlHelpDialog*;    // turn off this typemap
1406
1407     wxHtmlHelpDialog(wxWindow* parent, wxWindowID wxWindowID,
1408                     const wxString& title = wxPyEmptyString,
1409                     int style = wxHF_DEFAULT_STYLE, wxHtmlHelpData* data = NULL);
1410     %RenameCtor(PreHtmlHelpDialog, wxHtmlHelpDialog(wxHtmlHelpData* data = NULL));
1411
1412     // Turn it back on again
1413     %typemap(out) wxHtmlHelpDialog* { $result = wxPyMake_wxObject($1, $owner); }
1414
1415     bool Create(wxWindow* parent, wxWindowID id, const wxString& title = wxPyEmptyString,
1416                 int style = wxHF_DEFAULT_STYLE);
1417
1418     /// Returns the data associated with this dialog.
1419     wxHtmlHelpData* GetData();
1420
1421     /// Returns the controller that created this dialog.
1422     wxHtmlHelpController* GetController() const;
1423
1424     /// Sets the controller associated with this dialog.
1425     %disownarg( wxHtmlHelpController* controller );
1426     void SetController(wxHtmlHelpController* controller);
1427     %cleardisown( wxHtmlHelpController* controller );
1428
1429     /// Returns the help window.
1430     wxHtmlHelpWindow* GetHelpWindow() const;
1431
1432     // Sets format of title of the frame. Must contain exactly one "%s"
1433     // (for title of displayed HTML page)
1434     void SetTitleFormat(const wxString& format);
1435
1436     // Override to add custom buttons to the toolbar
1437 //    virtual void AddToolbarButtons(wxToolBar* WXUNUSED(toolBar), int WXUNUSED(style)) {};
1438
1439 };
1440
1441
1442 //---------------------------------------------------------------------------
1443
1444
1445 // TODO: Make virtual methods of this class overridable in Python.
1446
1447 MustHaveApp(wxHelpControllerBase);
1448
1449 class wxHelpControllerBase: public wxObject
1450 {
1451 public:
1452 //    wxHelpControllerBase(wxWindow* parentWindow = NULL);
1453 //    ~wxHelpControllerBase();
1454
1455     %nokwargs Initialize;
1456     virtual bool Initialize(const wxString& file, int server );
1457     virtual bool Initialize(const wxString& file);
1458
1459     virtual void SetViewer(const wxString& viewer, long flags = 0);
1460
1461     // If file is "", reloads file given  in Initialize
1462     virtual bool LoadFile(const wxString& file = wxEmptyString) /* = 0 */;
1463
1464     // Displays the contents
1465     virtual bool DisplayContents(void) /* = 0 */;
1466
1467     %nokwargs DisplaySection;
1468
1469     // Display the given section
1470     virtual bool DisplaySection(int sectionNo) /* = 0 */;
1471
1472     // Display the section using a context id
1473     virtual bool DisplayContextPopup(int contextId);
1474
1475     // Display the text in a popup, if possible
1476     virtual bool DisplayTextPopup(const wxString& text, const wxPoint& pos);
1477
1478     // By default, uses KeywordSection to display a topic. Implementations
1479     // may override this for more specific behaviour.
1480     virtual bool DisplaySection(const wxString& section);
1481
1482     virtual bool DisplayBlock(long blockNo) /* = 0 */;
1483     virtual bool KeywordSearch(const wxString& k,
1484                                wxHelpSearchMode mode = wxHELP_SEARCH_ALL) /* = 0 */;
1485
1486     /// Allows one to override the default settings for the help frame.
1487     virtual void SetFrameParameters(const wxString& title,
1488                                     const wxSize& size,
1489                                     const wxPoint& pos = wxDefaultPosition,
1490                                     bool newFrameEachTime = false);
1491
1492     /// Obtains the latest settings used by the help frame and the help
1493     /// frame.
1494     virtual wxFrame *GetFrameParameters(wxSize *size = NULL,
1495                                         wxPoint *pos = NULL,
1496                                         bool *newFrameEachTime = NULL);
1497
1498     virtual bool Quit() /* = 0 */;
1499
1500     virtual void OnQuit();
1501
1502     /// Set the window that can optionally be used for the help window's parent.
1503     virtual void SetParentWindow(wxWindow* win);
1504
1505     /// Get the window that can optionally be used for the help window's parent.
1506     virtual wxWindow* GetParentWindow() const;
1507
1508 };
1509
1510
1511
1512
1513 MustHaveApp(wxHtmlHelpController);
1514
1515 class wxHtmlHelpController : public wxHelpControllerBase
1516 {
1517 public:
1518 //    %pythonAppend wxHtmlHelpController "self._setOORInfo(self)"
1519
1520     wxHtmlHelpController(int style = wxHF_DEFAULT_STYLE, wxWindow* parentWindow = NULL);
1521     ~wxHtmlHelpController();
1522
1523     wxHtmlHelpWindow* GetHelpWindow();
1524     void SetHelpWindow(wxHtmlHelpWindow* helpWindow);
1525
1526     wxHtmlHelpFrame* GetFrame();
1527     wxHtmlHelpDialog* GetDialog();
1528
1529     void SetTitleFormat(const wxString& format);
1530     void SetTempDir(const wxString& path);
1531     bool AddBook(const wxString& book, int show_wait_msg = false);
1532     void Display(const wxString& x);
1533     %Rename(DisplayID,  void,  Display(int id));
1534     void DisplayContents();
1535     void DisplayIndex();
1536     bool KeywordSearch(const wxString& keyword);
1537     void UseConfig(wxConfigBase *config, const wxString& rootpath = wxPyEmptyString);
1538     void ReadCustomization(wxConfigBase *cfg, wxString path = wxPyEmptyString);
1539     void WriteCustomization(wxConfigBase *cfg, wxString path = wxPyEmptyString);
1540
1541     void MakeModalIfNeeded();
1542     wxWindow* FindTopLevelWindow();
1543 };
1544
1545
1546 /*
1547  * wxHtmlModalHelp
1548  * A convenience class particularly for use on wxMac,
1549  * where you can only show modal dialogs from a modal
1550  * dialog.
1551  *
1552  * Use like this:
1553  *
1554  * wxHtmlModalHelp help(parent, filename, topic);
1555  *
1556  * If topic is empty, the help contents is displayed.
1557  */
1558
1559 class wxHtmlModalHelp
1560 {
1561 public:
1562     wxHtmlModalHelp(wxWindow* parent, const wxString& helpFile,
1563                     const wxString& topic = wxEmptyString,
1564                     int style = wxHF_DEFAULT_STYLE | wxHF_DIALOG | wxHF_MODAL);
1565 };
1566
1567
1568 //---------------------------------------------------------------------------
1569 %init %{
1570     wxPyPtrTypeMap_Add("wxHtmlTagHandler",    "wxPyHtmlTagHandler");
1571     wxPyPtrTypeMap_Add("wxHtmlWinTagHandler", "wxPyHtmlWinTagHandler");
1572     wxPyPtrTypeMap_Add("wxHtmlWindow",        "wxPyHtmlWindow");
1573     wxPyPtrTypeMap_Add("wxHtmlFilter",        "wxPyHtmlFilter");
1574 %}
1575 //---------------------------------------------------------------------------
1576 //---------------------------------------------------------------------------
1577
1578
1579