]> git.saurik.com Git - wxWidgets.git/blame - wxPython/src/html.i
Add a set for wxMac too
[wxWidgets.git] / wxPython / src / html.i
CommitLineData
4b123bb9
HH
1/////////////////////////////////////////////////////////////////////////////
2// Name: html.i
3// Purpose: SWIG definitions of html classes
4//
5// Author: Robin Dunn
6//
d14a1e28 7// Created: 25-Nov-1998
4b123bb9 8// RCS-ID: $Id$
d14a1e28 9// Copyright: (c) 2003 by Total Control Software
4b123bb9
HH
10// Licence: wxWindows license
11/////////////////////////////////////////////////////////////////////////////
12
13
14%module html
15
16%{
d14a1e28
RD
17#include "wx/wxPython/wxPython.h"
18#include "wx/wxPython/pyclasses.h"
19#include "wx/wxPython/pyistream.h"
20#include "wx/wxPython/printfw.h"
21
4b123bb9 22#include <wx/html/htmlwin.h>
dc2f8a65 23#include <wx/html/htmprint.h>
d14a1e28 24#include <wx/html/helpctrl.h>
4b123bb9 25
137b5242
RD
26%}
27
b2dc1044 28
0f66a9f3 29//---------------------------------------------------------------------------
e166644c 30
d14a1e28
RD
31%import windows.i
32%pythoncode { wx = core }
33
34%include _html_rename.i
35
36
b2dc1044 37MAKE_CONST_WXSTRING_NOSWIG(EmptyString);
089142a5
RD
38MAKE_CONST_WXSTRING2(HtmlWindowNameStr, wxT("htmlWindow"))
39MAKE_CONST_WXSTRING2(HtmlPrintoutTitleStr, wxT("Printout"))
40MAKE_CONST_WXSTRING2(HtmlPrintingTitleStr, wxT("Printing"))
b2dc1044
RD
41
42
d14a1e28
RD
43// TODO: Split this file into multiple %included files that coresponds to the
44// wx/html include files (more or less.)
45
46//---------------------------------------------------------------------------
47//---------------------------------------------------------------------------
48%newgroup
49
50
e166644c 51enum {
9d8bd15f
RD
52 wxHTML_ALIGN_LEFT,
53 wxHTML_ALIGN_CENTER,
54 wxHTML_ALIGN_RIGHT,
55 wxHTML_ALIGN_BOTTOM,
56 wxHTML_ALIGN_TOP,
57
58 wxHTML_CLR_FOREGROUND,
59 wxHTML_CLR_BACKGROUND,
60
61 wxHTML_UNITS_PIXELS,
62 wxHTML_UNITS_PERCENT,
63
64 wxHTML_INDENT_LEFT,
65 wxHTML_INDENT_RIGHT,
66 wxHTML_INDENT_TOP,
67 wxHTML_INDENT_BOTTOM,
68
69 wxHTML_INDENT_HORIZONTAL,
70 wxHTML_INDENT_VERTICAL,
71 wxHTML_INDENT_ALL,
72
73 wxHTML_COND_ISANCHOR,
74 wxHTML_COND_ISIMAGEMAP,
75 wxHTML_COND_USER,
4eeb5705
RD
76
77
78 wxHTML_FONT_SIZE_1,
79 wxHTML_FONT_SIZE_2,
80 wxHTML_FONT_SIZE_3,
81 wxHTML_FONT_SIZE_4,
82 wxHTML_FONT_SIZE_5,
83 wxHTML_FONT_SIZE_6,
84 wxHTML_FONT_SIZE_7,
e166644c
RD
85};
86
87
c6c593e8
RD
88enum {
89 wxHW_SCROLLBAR_NEVER,
90 wxHW_SCROLLBAR_AUTO,
3ef86e32
RD
91 wxHW_NO_SELECTION,
92 wxHW_DEFAULT_STYLE,
c6c593e8
RD
93};
94
95
96// enums for wxHtmlWindow::OnOpeningURL
97enum wxHtmlOpeningStatus
98{
99 wxHTML_OPEN,
100 wxHTML_BLOCK,
101 wxHTML_REDIRECT
102};
103
104enum wxHtmlURLType
105{
106 wxHTML_URL_PAGE,
107 wxHTML_URL_IMAGE,
108 wxHTML_URL_OTHER
109};
110
d14a1e28
RD
111
112
9c00cfa3
RD
113//---------------------------------------------------------------------------
114
9416aa89 115class wxHtmlLinkInfo : public wxObject {
9c00cfa3 116public:
137b5242 117 wxHtmlLinkInfo(const wxString& href, const wxString& target = wxPyEmptyString);
9c00cfa3
RD
118 wxString GetHref();
119 wxString GetTarget();
c8bc03c3
RD
120 wxMouseEvent* GetEvent();
121 wxHtmlCell* GetHtmlCell();
7a446686
RD
122
123 void SetEvent(const wxMouseEvent *e);
124 void SetHtmlCell(const wxHtmlCell * e);
9c00cfa3
RD
125};
126
0f66a9f3
RD
127//---------------------------------------------------------------------------
128
9416aa89 129class wxHtmlTag : public wxObject {
0f66a9f3 130public:
e166644c 131 // Never need to create a new tag from Python...
0f66a9f3
RD
132 //wxHtmlTag(const wxString& source, int pos, int end_pos, wxHtmlTagsCache* cache);
133
134 wxString GetName();
135 bool HasParam(const wxString& par);
dd9f7fea 136 wxString GetParam(const wxString& par, int with_commas = False);
0f66a9f3
RD
137
138 // Can't do this one as-is, but GetParam should be enough...
139 //int ScanParam(const wxString& par, const char *format, void* param);
140
141 wxString GetAllParams();
0f66a9f3
RD
142 bool HasEnding();
143 int GetBeginPos();
144 int GetEndPos1();
145 int GetEndPos2();
146};
147
0f66a9f3
RD
148//---------------------------------------------------------------------------
149
9416aa89 150class wxHtmlParser : public wxObject {
0f66a9f3
RD
151public:
152 // wxHtmlParser(); This is an abstract base class...
153
154 void SetFS(wxFileSystem *fs);
155 wxFileSystem* GetFS();
156 wxObject* Parse(const wxString& source);
157 void InitParser(const wxString& source);
158 void DoneParser();
159 void DoParsing(int begin_pos, int end_pos);
1e4a197e 160 void StopParsing();
0f66a9f3 161 // wxObject* GetProduct();
1e4a197e 162
0f66a9f3
RD
163 void AddTagHandler(wxHtmlTagHandler *handler);
164 wxString* GetSource();
dc2f8a65
RD
165 void PushTagHandler(wxHtmlTagHandler* handler, wxString tags);
166 void PopTagHandler();
0f66a9f3 167
c6c593e8 168 // virtual wxFSFile *OpenURL(wxHtmlURLType type, const wxString& url) const;
0f66a9f3
RD
169
170 // void AddText(const char* txt) = 0;
171 // void AddTag(const wxHtmlTag& tag);
172};
173
174
175//---------------------------------------------------------------------------
176
177class wxHtmlWinParser : public wxHtmlParser {
178public:
1fded56b 179 wxHtmlWinParser(wxPyHtmlWindow *wnd = NULL);
0f66a9f3
RD
180
181 void SetDC(wxDC *dc);
182 wxDC* GetDC();
183 int GetCharHeight();
184 int GetCharWidth();
1fded56b 185 wxPyHtmlWindow* GetWindow();
d14a1e28 186
1fded56b 187 // Sets fonts to be used when displaying HTML page. (if size null then default sizes used).
d14a1e28 188 %extend {
9cbf6f6e
RD
189 void SetFonts(wxString normal_face, wxString fixed_face, PyObject* sizes=NULL) {
190 int* temp = NULL;
191 if (sizes) temp = int_LIST_helper(sizes);
192 self->SetFonts(normal_face, fixed_face, temp);
193 if (temp)
f6bcfd97 194 delete [] temp;
f6bcfd97
BP
195 }
196 }
0f66a9f3
RD
197
198 wxHtmlContainerCell* GetContainer();
199 wxHtmlContainerCell* OpenContainer();
dc2f8a65 200 wxHtmlContainerCell *SetContainer(wxHtmlContainerCell *c);
0f66a9f3 201 wxHtmlContainerCell* CloseContainer();
dc2f8a65 202
0f66a9f3
RD
203 int GetFontSize();
204 void SetFontSize(int s);
205 int GetFontBold();
206 void SetFontBold(int x);
207 int GetFontItalic();
208 void SetFontItalic(int x);
209 int GetFontUnderlined();
210 void SetFontUnderlined(int x);
211 int GetFontFixed();
212 void SetFontFixed(int x);
213 int GetAlign();
214 void SetAlign(int a);
c5943253 215 wxColour GetLinkColor();
0f66a9f3 216 void SetLinkColor(const wxColour& clr);
c5943253 217 wxColour GetActualColor();
0f66a9f3 218 void SetActualColor(const wxColour& clr);
0f66a9f3
RD
219 void SetLink(const wxString& link);
220 wxFont* CreateCurrentFont();
9c00cfa3
RD
221 wxHtmlLinkInfo GetLink();
222
0f66a9f3
RD
223};
224
225
0f66a9f3
RD
226//---------------------------------------------------------------------------
227
228%{
229class wxPyHtmlTagHandler : public wxHtmlTagHandler {
9416aa89 230 DECLARE_DYNAMIC_CLASS(wxPyHtmlTagHandler);
0f66a9f3
RD
231public:
232 wxPyHtmlTagHandler() : wxHtmlTagHandler() {};
233
234 wxHtmlParser* GetParser() { return m_Parser; }
235 void ParseInner(const wxHtmlTag& tag) { wxHtmlTagHandler::ParseInner(tag); }
236
237 DEC_PYCALLBACK_STRING__pure(GetSupportedTags);
238 DEC_PYCALLBACK_BOOL_TAG_pure(HandleTag);
239
240 PYPRIVATE;
241};
242
9416aa89
RD
243IMPLEMENT_DYNAMIC_CLASS(wxPyHtmlTagHandler, wxHtmlTagHandler);
244
0f66a9f3
RD
245IMP_PYCALLBACK_STRING__pure(wxPyHtmlTagHandler, wxHtmlTagHandler, GetSupportedTags);
246IMP_PYCALLBACK_BOOL_TAG_pure(wxPyHtmlTagHandler, wxHtmlTagHandler, HandleTag);
0f66a9f3
RD
247%}
248
249
d14a1e28 250%name(HtmlTagHandler) class wxPyHtmlTagHandler : public wxObject {
0f66a9f3 251public:
2b9048c5 252 %pythonAppend wxPyHtmlTagHandler "self._setCallbackInfo(self, HtmlTagHandler)"
0f66a9f3
RD
253 wxPyHtmlTagHandler();
254
0122b7e3 255 void _setCallbackInfo(PyObject* self, PyObject* _class);
0f66a9f3
RD
256
257 void SetParser(wxHtmlParser *parser);
258 wxHtmlParser* GetParser();
259 void ParseInner(const wxHtmlTag& tag);
260};
261
262
263//---------------------------------------------------------------------------
264
265%{
266class wxPyHtmlWinTagHandler : public wxHtmlWinTagHandler {
9416aa89 267 DECLARE_DYNAMIC_CLASS(wxPyHtmlWinTagHandler);
0f66a9f3
RD
268public:
269 wxPyHtmlWinTagHandler() : wxHtmlWinTagHandler() {};
270
271 wxHtmlWinParser* GetParser() { return m_WParser; }
272 void ParseInner(const wxHtmlTag& tag)
273 { wxHtmlWinTagHandler::ParseInner(tag); }
274
275 DEC_PYCALLBACK_STRING__pure(GetSupportedTags);
276 DEC_PYCALLBACK_BOOL_TAG_pure(HandleTag);
277
278 PYPRIVATE;
279};
280
9416aa89
RD
281IMPLEMENT_DYNAMIC_CLASS( wxPyHtmlWinTagHandler, wxHtmlWinTagHandler);
282
0f66a9f3
RD
283IMP_PYCALLBACK_STRING__pure(wxPyHtmlWinTagHandler, wxHtmlWinTagHandler, GetSupportedTags);
284IMP_PYCALLBACK_BOOL_TAG_pure(wxPyHtmlWinTagHandler, wxHtmlWinTagHandler, HandleTag);
0f66a9f3
RD
285%}
286
287
d14a1e28 288%name(HtmlWinTagHandler) class wxPyHtmlWinTagHandler : public wxPyHtmlTagHandler {
0f66a9f3 289public:
2b9048c5 290 %pythonAppend wxPyHtmlWinTagHandler "self._setCallbackInfo(self, HtmlWinTagHandler)"
0f66a9f3
RD
291 wxPyHtmlWinTagHandler();
292
0122b7e3 293 void _setCallbackInfo(PyObject* self, PyObject* _class);
0f66a9f3
RD
294
295 void SetParser(wxHtmlParser *parser);
296 wxHtmlWinParser* GetParser();
297 void ParseInner(const wxHtmlTag& tag);
298};
299
300
301//---------------------------------------------------------------------------
302
303%{
304
305class wxPyHtmlTagsModule : public wxHtmlTagsModule {
306public:
307 wxPyHtmlTagsModule(PyObject* thc) : wxHtmlTagsModule() {
308 m_tagHandlerClass = thc;
309 Py_INCREF(m_tagHandlerClass);
310 RegisterModule(this);
311 wxHtmlWinParser::AddModule(this);
312 }
313
314 void OnExit() {
da32eb53 315 bool blocked = wxPyBeginBlockThreads();
0f66a9f3
RD
316 Py_DECREF(m_tagHandlerClass);
317 m_tagHandlerClass = NULL;
dc2f8a65 318 for (size_t x=0; x < m_objArray.GetCount(); x++) {
0f66a9f3
RD
319 PyObject* obj = (PyObject*)m_objArray.Item(x);
320 Py_DECREF(obj);
321 }
da32eb53 322 wxPyEndBlockThreads(blocked);
0f66a9f3
RD
323 };
324
325 void FillHandlersTable(wxHtmlWinParser *parser) {
326 // Wave our magic wand... (if it works it's a miracle! ;-)
327
328 // First, make a new instance of the tag handler
da32eb53 329 bool blocked = wxPyBeginBlockThreads();
fb757066
RD
330 PyObject* arg = PyTuple_New(0);
331 PyObject* obj = PyObject_CallObject(m_tagHandlerClass, arg);
0f66a9f3 332 Py_DECREF(arg);
fb757066 333
0f66a9f3
RD
334 // now figure out where it's C++ object is...
335 wxPyHtmlWinTagHandler* thPtr;
fb757066 336 if (! wxPyConvertSwigPtr(obj, (void **)&thPtr, wxT("wxPyHtmlWinTagHandler"))) {
da32eb53 337 wxPyEndBlockThreads(blocked);
0f66a9f3 338 return;
fb757066 339 }
da32eb53 340 wxPyEndBlockThreads(blocked);
0f66a9f3
RD
341
342 // add it,
343 parser->AddTagHandler(thPtr);
344
345 // and track it.
346 m_objArray.Add(obj);
347 }
348
349private:
350 PyObject* m_tagHandlerClass;
351 wxArrayPtrVoid m_objArray;
352
353};
354%}
355
356
357
358%inline %{
359 void wxHtmlWinParser_AddTagHandler(PyObject* tagHandlerClass) {
360 // Dynamically create a new wxModule. Refcounts tagHandlerClass
361 // and adds itself to the wxModules list and to the wxHtmlWinParser.
362 new wxPyHtmlTagsModule(tagHandlerClass);
363 }
364%}
365
dc2f8a65 366
e166644c
RD
367//---------------------------------------------------------------------------
368//---------------------------------------------------------------------------
d14a1e28 369%newgroup
e166644c 370
dd116e73
RD
371
372// wxHtmlSelection is data holder with information about text selection.
373// Selection is defined by two positions (beginning and end of the selection)
374// and two leaf(!) cells at these positions.
375class wxHtmlSelection
376{
377public:
378 wxHtmlSelection();
379 ~wxHtmlSelection();
380
381 void Set(const wxPoint& fromPos, const wxHtmlCell *fromCell,
382 const wxPoint& toPos, const wxHtmlCell *toCell);
383 %name(SetCells)void Set(const wxHtmlCell *fromCell, const wxHtmlCell *toCell);
384
385 const wxHtmlCell *GetFromCell() const;
386 const wxHtmlCell *GetToCell() const;
387
388 // these values are in absolute coordinates:
389 const wxPoint& GetFromPos() const;
390 const wxPoint& GetToPos() const;
391
392 // these are From/ToCell's private data
393 const wxPoint& GetFromPrivPos() const;
394 const wxPoint& GetToPrivPos() const;
395 void SetFromPrivPos(const wxPoint& pos);
396 void SetToPrivPos(const wxPoint& pos);
397 void ClearPrivPos();
398
399 const bool IsEmpty() const;
400
401};
402
403
404enum wxHtmlSelectionState
405{
406 wxHTML_SEL_OUT, // currently rendered cell is outside the selection
407 wxHTML_SEL_IN, // ... is inside selection
408 wxHTML_SEL_CHANGING // ... is the cell on which selection state changes
409};
410
d14a1e28
RD
411
412
dd116e73
RD
413// Selection state is passed to wxHtmlCell::Draw so that it can render itself
414// differently e.g. when inside text selection or outside it.
415class wxHtmlRenderingState
416{
417public:
418 wxHtmlRenderingState();
419 ~wxHtmlRenderingState();
420
421 void SetSelectionState(wxHtmlSelectionState s);
422 wxHtmlSelectionState GetSelectionState() const;
423
424 void SetFgColour(const wxColour& c);
425 const wxColour& GetFgColour() const;
426 void SetBgColour(const wxColour& c);
427 const wxColour& GetBgColour() const;
428};
429
430
d14a1e28 431
dd116e73
RD
432// HTML rendering customization. This class is used when rendering wxHtmlCells
433// as a callback:
434class wxHtmlRenderingStyle
435{
436public:
437 virtual wxColour GetSelectedTextColour(const wxColour& clr) = 0;
438 virtual wxColour GetSelectedTextBgColour(const wxColour& clr) = 0;
439};
440
441// Standard style:
442class wxDefaultHtmlRenderingStyle : public wxHtmlRenderingStyle
443{
444public:
445 virtual wxColour GetSelectedTextColour(const wxColour& clr);
446 virtual wxColour GetSelectedTextBgColour(const wxColour& clr);
447};
448
449
450
451// Information given to cells when drawing them. Contains rendering state,
452// selection information and rendering style object that can be used to
453// customize the output.
454class wxHtmlRenderingInfo
455{
456public:
457 wxHtmlRenderingInfo();
458 ~wxHtmlRenderingInfo();
459
460 void SetSelection(wxHtmlSelection *s);
461 wxHtmlSelection *GetSelection() const;
462
463 void SetStyle(wxHtmlRenderingStyle *style);
464 wxHtmlRenderingStyle& GetStyle();
465
466 wxHtmlRenderingState& GetState();
467};
468
469//---------------------------------------------------------------------------
d14a1e28 470%newgroup
dd116e73 471
3ef86e32
RD
472
473enum
474{
475 wxHTML_FIND_EXACT = 1,
476 wxHTML_FIND_NEAREST_BEFORE = 2,
477 wxHTML_FIND_NEAREST_AFTER = 4
478};
479
480
9416aa89 481class wxHtmlCell : public wxObject {
e166644c
RD
482public:
483 wxHtmlCell();
484
e166644c
RD
485 int GetPosX();
486 int GetPosY();
487 int GetWidth();
488 int GetHeight();
489 int GetDescent();
0d267606
RD
490
491 // Returns the maximum possible length of the cell.
492 // Call Layout at least once before using GetMaxTotalWidth()
493 int GetMaxTotalWidth() const;
494
2678dd26
RD
495 const wxString& GetId() const;
496 void SetId(const wxString& id);
9c00cfa3 497 wxHtmlLinkInfo* GetLink(int x = 0, int y = 0);
e166644c 498 wxHtmlCell* GetNext();
9c00cfa3 499 wxHtmlContainerCell* GetParent();
3ef86e32
RD
500 wxHtmlCell* GetFirstChild() const;
501
502 // Returns cursor to be used when mouse is over the cell:
503 wxCursor GetCursor() const;
504
505 // Formatting cells are not visible on the screen, they only alter
506 // renderer's state.
507 bool IsFormattingCell() const;
508
509
9c00cfa3 510 void SetLink(const wxHtmlLinkInfo& link);
e166644c 511 void SetNext(wxHtmlCell *cell);
9c00cfa3
RD
512 void SetParent(wxHtmlContainerCell *p);
513 void SetPos(int x, int y);
e166644c 514 void Layout(int w);
dd116e73
RD
515 void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2,
516 wxHtmlRenderingInfo& info);
517 void DrawInvisible(wxDC& dc, int x, int y,
518 wxHtmlRenderingInfo& info);
e166644c 519 const wxHtmlCell* Find(int condition, const void* param);
dc2f8a65 520
1fded56b 521 bool AdjustPagebreak(int* INOUT);
dc2f8a65 522 void SetCanLiveOnPagebreak(bool can);
9c00cfa3 523
3ef86e32
RD
524 // Can the line be broken before this cell?
525 bool IsLinebreakAllowed() const;
526
dd9f7fea 527 // Returns True for simple == terminal cells, i.e. not composite ones.
3ef86e32
RD
528 // This if for internal usage only and may disappear in future versions!
529 bool IsTerminalCell() const;
530
531 // Find a cell inside this cell positioned at the given coordinates
532 // (relative to this's positions). Returns NULL if no such cell exists.
533 // The flag can be used to specify whether to look for terminal or
534 // nonterminal cells or both. In either case, returned cell is deepest
535 // cell in cells tree that contains [x,y].
536 wxHtmlCell *FindCellByPos(wxCoord x, wxCoord y,
537 unsigned flags = wxHTML_FIND_EXACT) const;
538
539 // Returns absolute position of the cell on HTML canvas
540 wxPoint GetAbsPos() const;
541
542 // Returns first (last) terminal cell inside this cell. It may return NULL,
543 // but it is rare -- only if there are no terminals in the tree.
544 wxHtmlCell *GetFirstTerminal() const ;
545 wxHtmlCell *GetLastTerminal() const ;
546
547 // Returns cell's depth, i.e. how far under the root cell it is
548 // (if it is the root, depth is 0)
549 unsigned GetDepth() const;
550
dd9f7fea 551 // Returns True if the cell appears before 'cell' in natural order of
3ef86e32 552 // cells (= as they are read). If cell A is (grand)parent of cell B,
dd9f7fea 553 // then both A.IsBefore(B) and B.IsBefore(A) always return True.
3ef86e32
RD
554 bool IsBefore(wxHtmlCell *cell) const;
555
556 // Converts the cell into text representation. If sel != NULL then
557 // only part of the cell inside the selection is converted.
558 wxString ConvertToText(wxHtmlSelection *sel) const;
e166644c
RD
559};
560
561
9416aa89
RD
562class wxHtmlWordCell : public wxHtmlCell
563{
564public:
565 wxHtmlWordCell(const wxString& word, wxDC& dc);
566};
567
568
e166644c
RD
569class wxHtmlContainerCell : public wxHtmlCell {
570public:
571 wxHtmlContainerCell(wxHtmlContainerCell *parent);
572
573 void InsertCell(wxHtmlCell *cell);
574 void SetAlignHor(int al);
575 int GetAlignHor();
576 void SetAlignVer(int al);
577 int GetAlignVer();
9d8bd15f 578 void SetIndent(int i, int what, int units = wxHTML_UNITS_PIXELS);
e166644c
RD
579 int GetIndent(int ind);
580 int GetIndentUnits(int ind);
581 void SetAlign(const wxHtmlTag& tag);
582 void SetWidthFloat(int w, int units);
583 %name(SetWidthFloatFromTag)void SetWidthFloat(const wxHtmlTag& tag);
9d8bd15f 584 void SetMinHeight(int h, int align = wxHTML_ALIGN_TOP);
e166644c 585 void SetBackgroundColour(const wxColour& clr);
1e4a197e 586 wxColour GetBackgroundColour();
e166644c 587 void SetBorder(const wxColour& clr1, const wxColour& clr2);
dd116e73
RD
588 wxHtmlCell* GetFirstChild();
589 %pragma(python) addtoclass = "GetFirstCell = GetFirstChild"
e166644c
RD
590};
591
592
593
9c00cfa3
RD
594class wxHtmlColourCell : public wxHtmlCell {
595public:
596 wxHtmlColourCell(wxColour clr, int flags = wxHTML_CLR_FOREGROUND);
597
598};
599
600
9416aa89
RD
601class wxHtmlFontCell : public wxHtmlCell
602{
603public:
604 wxHtmlFontCell(wxFont *font);
605};
606
e166644c
RD
607
608class wxHtmlWidgetCell : public wxHtmlCell {
609public:
610 wxHtmlWidgetCell(wxWindow* wnd, int w = 0);
611
612};
613
0f66a9f3 614
d14a1e28
RD
615
616
0f66a9f3 617//---------------------------------------------------------------------------
1e4a197e
RD
618// wxHtmlFilter
619//---------------------------------------------------------------------------
d14a1e28 620%newgroup
1e4a197e
RD
621
622
623%{ // here's the C++ version
624class wxPyHtmlFilter : public wxHtmlFilter {
625 DECLARE_ABSTRACT_CLASS(wxPyHtmlFilter);
626public:
627 wxPyHtmlFilter() : wxHtmlFilter() {}
628
dd9f7fea 629 // returns True if this filter is able to open&read given file
1e4a197e 630 virtual bool CanRead(const wxFSFile& file) const {
dd9f7fea 631 bool rval = False;
1e4a197e 632 bool found;
da32eb53 633 bool blocked = wxPyBeginBlockThreads();
1e4a197e
RD
634 if ((found = wxPyCBH_findCallback(m_myInst, "CanRead"))) {
635 PyObject* obj = wxPyMake_wxObject((wxFSFile*)&file); // cast away const
636 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));
637 Py_DECREF(obj);
638 }
da32eb53 639 wxPyEndBlockThreads(blocked);
1e4a197e
RD
640 return rval;
641 }
642
643
644 // Reads given file and returns HTML document.
645 // Returns empty string if opening failed
646 virtual wxString ReadFile(const wxFSFile& file) const {
647 wxString rval;
648 bool found;
da32eb53 649 bool blocked = wxPyBeginBlockThreads();
1e4a197e
RD
650 if ((found = wxPyCBH_findCallback(m_myInst, "ReadFile"))) {
651 PyObject* obj = wxPyMake_wxObject((wxFSFile*)&file); // cast away const
652 PyObject* ro;
653 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(O)", obj));
654 Py_DECREF(obj);
655 if (ro) {
656 rval = Py2wxString(ro);
657 Py_DECREF(ro);
658 }
659 }
da32eb53 660 wxPyEndBlockThreads(blocked);
1e4a197e
RD
661 return rval;
662 }
663
664 PYPRIVATE;
665};
666
667IMPLEMENT_ABSTRACT_CLASS(wxPyHtmlFilter, wxHtmlFilter);
668%}
669
670
671// And now the version seen by SWIG
672
d14a1e28 673%name(HtmlFilter) class wxPyHtmlFilter : public wxObject {
1e4a197e 674public:
2b9048c5 675 %pythonAppend wxPyHtmlFilter "self._setCallbackInfo(self, HtmlFilter)"
1e4a197e
RD
676 wxPyHtmlFilter();
677
678 void _setCallbackInfo(PyObject* self, PyObject* _class);
1e4a197e
RD
679};
680
681
682// TODO: wxHtmlFilterHTML
683
684
0f66a9f3 685//---------------------------------------------------------------------------
1e4a197e 686// wxHtmlWindow
4b123bb9 687//---------------------------------------------------------------------------
d14a1e28 688%newgroup
4b123bb9 689
0f66a9f3
RD
690%{
691class wxPyHtmlWindow : public wxHtmlWindow {
cdf14688 692 DECLARE_ABSTRACT_CLASS(wxPyHtmlWindow);
0f66a9f3
RD
693public:
694 wxPyHtmlWindow(wxWindow *parent, wxWindowID id = -1,
695 const wxPoint& pos = wxDefaultPosition,
696 const wxSize& size = wxDefaultSize,
3ef86e32 697 long style = wxHW_DEFAULT_STYLE,
1e4a197e 698 const wxString& name = wxPyHtmlWindowNameStr)
0f66a9f3 699 : wxHtmlWindow(parent, id, pos, size, style, name) {};
7b7ac0ab 700 wxPyHtmlWindow() : wxHtmlWindow() {};
0f66a9f3 701
e5d41db0
RD
702 bool ScrollToAnchor(const wxString& anchor) {
703 return wxHtmlWindow::ScrollToAnchor(anchor);
704 }
705
706 bool HasAnchor(const wxString& anchor) {
707 const wxHtmlCell *c = m_Cell->Find(wxHTML_COND_ISANCHOR, &anchor);
708 return c!=NULL;
709 }
710
c8bc03c3
RD
711 void OnLinkClicked(const wxHtmlLinkInfo& link);
712 void base_OnLinkClicked(const wxHtmlLinkInfo& link);
9c00cfa3 713
e5d41db0 714 wxHtmlOpeningStatus OnOpeningURL(wxHtmlURLType type,
c6c593e8
RD
715 const wxString& url,
716 wxString *redirect) const;
717
9c00cfa3 718 DEC_PYCALLBACK__STRING(OnSetTitle);
0122b7e3
RD
719 DEC_PYCALLBACK__CELLINTINT(OnCellMouseHover);
720 DEC_PYCALLBACK__CELLINTINTME(OnCellClicked);
0f66a9f3
RD
721 PYPRIVATE;
722};
723
cdf14688 724IMPLEMENT_ABSTRACT_CLASS( wxPyHtmlWindow, wxHtmlWindow );
9c00cfa3 725IMP_PYCALLBACK__STRING(wxPyHtmlWindow, wxHtmlWindow, OnSetTitle);
0122b7e3
RD
726IMP_PYCALLBACK__CELLINTINT(wxPyHtmlWindow, wxHtmlWindow, OnCellMouseHover);
727IMP_PYCALLBACK__CELLINTINTME(wxPyHtmlWindow, wxHtmlWindow, OnCellClicked);
728
0f66a9f3 729
9416aa89 730void wxPyHtmlWindow::OnLinkClicked(const wxHtmlLinkInfo& link) {
19a97bd6 731 bool found;
da32eb53 732 bool blocked = wxPyBeginBlockThreads();
0122b7e3 733 if ((found = wxPyCBH_findCallback(m_myInst, "OnLinkClicked"))) {
1e4a197e 734 PyObject* obj = wxPyConstructObject((void*)&link, wxT("wxHtmlLinkInfo"), 0);
1e7ecb7b 735 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));
de20db99 736 Py_DECREF(obj);
9c00cfa3 737 }
da32eb53 738 wxPyEndBlockThreads(blocked);
19a97bd6 739 if (! found)
9c00cfa3 740 wxHtmlWindow::OnLinkClicked(link);
9c00cfa3 741}
c8bc03c3 742void wxPyHtmlWindow::base_OnLinkClicked(const wxHtmlLinkInfo& link) {
9c00cfa3
RD
743 wxHtmlWindow::OnLinkClicked(link);
744}
0122b7e3 745
c6c593e8
RD
746
747wxHtmlOpeningStatus wxPyHtmlWindow::OnOpeningURL(wxHtmlURLType type,
748 const wxString& url,
749 wxString *redirect) const {
750 bool found;
751 wxHtmlOpeningStatus rval;
da32eb53 752 bool blocked = wxPyBeginBlockThreads();
c6c593e8
RD
753 if ((found = wxPyCBH_findCallback(m_myInst, "OnOpeningURL"))) {
754 PyObject* ro;
a66212dc
RD
755 PyObject* s = wx2PyString(url);
756 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(iO)", type, s));
757 Py_DECREF(s);
c6c593e8
RD
758 if (PyString_Check(ro)
759#if PYTHON_API_VERSION >= 1009
760 || PyUnicode_Check(ro)
761#endif
762 ) {
a541c325 763 *redirect = Py2wxString(ro);
c6c593e8
RD
764 rval = wxHTML_REDIRECT;
765 }
766 else {
767 PyObject* num = PyNumber_Int(ro);
768 rval = (wxHtmlOpeningStatus)PyInt_AsLong(num);
769 Py_DECREF(num);
770 }
771 Py_DECREF(ro);
772 }
da32eb53 773 wxPyEndBlockThreads(blocked);
c6c593e8
RD
774 if (! found)
775 rval = wxHtmlWindow::OnOpeningURL(type, url, redirect);
776 return rval;
777}
778
779
0f66a9f3
RD
780%}
781
782
95837b4d 783
d14a1e28 784%name(HtmlWindow) class wxPyHtmlWindow : public wxScrolledWindow {
0f66a9f3 785public:
2b9048c5
RD
786 %pythonAppend wxPyHtmlWindow "self._setCallbackInfo(self, HtmlWindow); self._setOORInfo(self)"
787 %pythonAppend wxPyHtmlWindow() ""
d14a1e28 788
0f66a9f3 789 wxPyHtmlWindow(wxWindow *parent, int id = -1,
d14a1e28
RD
790 const wxPoint& pos = wxDefaultPosition,
791 const wxSize& size = wxDefaultSize,
3ef86e32 792 int style=wxHW_DEFAULT_STYLE,
137b5242 793 const wxString& name = wxPyHtmlWindowNameStr);
d14a1e28 794 %name(PreHtmlWindow)wxPyHtmlWindow();
7b7ac0ab
RD
795
796 bool Create(wxWindow *parent, int id = -1,
d14a1e28
RD
797 const wxPoint& pos = wxDefaultPosition,
798 const wxSize& size = wxDefaultSize,
fc51b8c3 799 int style=wxHW_SCROLLBAR_AUTO,
137b5242 800 const wxString& name = wxPyHtmlWindowNameStr);
7b7ac0ab 801
0f66a9f3 802
0122b7e3 803 void _setCallbackInfo(PyObject* self, PyObject* _class);
0f66a9f3 804
d14a1e28 805
1e4a197e
RD
806 // Set HTML page and display it. !! source is HTML document itself,
807 // it is NOT address/filename of HTML document. If you want to
808 // specify document location, use LoadPage() istead
dd9f7fea 809 // Return value : False if an error occured, True otherwise
7a446686 810 bool SetPage(const wxString& source);
1e4a197e
RD
811
812 // Load HTML page from given location. Location can be either
813 // a) /usr/wxGTK2/docs/html/wx.htm
814 // b) http://www.somewhere.uk/document.htm
815 // c) ftp://ftp.somesite.cz/pub/something.htm
816 // In case there is no prefix (http:,ftp:), the method
817 // will try to find it itself (1. local file, then http or ftp)
818 // After the page is loaded, the method calls SetPage() to display it.
819 // Note : you can also use path relative to previously loaded page
820 // Return value : same as SetPage
7a446686 821 bool LoadPage(const wxString& location);
1e4a197e 822
9cbf6f6e 823 // Loads HTML page from file
1fded56b 824 bool LoadFile(const wxString& filename);
9cbf6f6e 825
1e4a197e 826 // Append to current page
de112a55 827 bool AppendToPage(const wxString& source);
1e4a197e
RD
828
829 // Returns full location of opened page
0f66a9f3 830 wxString GetOpenedPage();
1e4a197e
RD
831
832 // Returns anchor within opened page
7a446686 833 wxString GetOpenedAnchor();
1e4a197e
RD
834
835 // Returns <TITLE> of opened page or empty string otherwise
7a446686
RD
836 wxString GetOpenedPageTitle();
837
1e4a197e
RD
838 // Sets frame in which page title will be displayed. Format is format of
839 // frame title, e.g. "HtmlHelp : %s". It must contain exactly one %s
137b5242 840 void SetRelatedFrame(wxFrame* frame, const wxString& format);
0f66a9f3 841 wxFrame* GetRelatedFrame();
1e4a197e
RD
842
843 // After(!) calling SetRelatedFrame, this sets statusbar slot where messages
844 // will be displayed. Default is -1 = no messages.
0f66a9f3 845 void SetRelatedStatusBar(int bar);
f6bcfd97 846
1e4a197e 847 // Sets fonts to be used when displaying HTML page.
d14a1e28 848 %extend {
9cbf6f6e
RD
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)
f6bcfd97 854 delete [] temp;
f6bcfd97
BP
855 }
856 }
857
36c8c471
RD
858 DocDeclStr(
859 void, SetTitle(const wxString& title),
860 "");
1e4a197e
RD
861
862 // Sets space between text and window borders.
0f66a9f3 863 void SetBorders(int b);
1e4a197e
RD
864
865 // Saves custom settings into cfg config. it will use the path 'path'
866 // if given, otherwise it will save info into currently selected path.
867 // saved values : things set by SetFonts, SetBorders.
137b5242
RD
868 void ReadCustomization(wxConfigBase *cfg, wxString path = wxPyEmptyString);
869 void WriteCustomization(wxConfigBase *cfg, wxString path = wxPyEmptyString);
1e4a197e
RD
870
871 // Goes to previous/next page (in browsing history)
dd9f7fea 872 // Returns True if successful, False otherwise
0f66a9f3
RD
873 bool HistoryBack();
874 bool HistoryForward();
7a446686
RD
875 bool HistoryCanBack();
876 bool HistoryCanForward();
1e4a197e
RD
877
878 // Resets History
0f66a9f3 879 void HistoryClear();
1e4a197e
RD
880
881 // Returns pointer to conteiners/cells structure.
a65c6e14 882 wxHtmlContainerCell* GetInternalRepresentation();
1e4a197e
RD
883
884 // Returns a pointer to the parser.
e166644c
RD
885 wxHtmlWinParser* GetParser();
886
e5d41db0
RD
887 bool ScrollToAnchor(const wxString& anchor);
888 bool HasAnchor(const wxString& anchor);
889
1e4a197e
RD
890 //Adds input filter
891 static void AddFilter(wxPyHtmlFilter *filter);
892
927d7cfa
RD
893 // Helper functions to select parts of page:
894 void SelectWord(const wxPoint& pos);
895 void SelectLine(const wxPoint& pos);
896 void SelectAll();
1e4a197e 897
927d7cfa 898
c8bc03c3 899 void base_OnLinkClicked(const wxHtmlLinkInfo& link);
137b5242 900 void base_OnSetTitle(const wxString& title);
0122b7e3
RD
901 void base_OnCellMouseHover(wxHtmlCell *cell, wxCoord x, wxCoord y);
902 void base_OnCellClicked(wxHtmlCell *cell,
903 wxCoord x, wxCoord y,
904 const wxMouseEvent& event);
4b123bb9
HH
905};
906
5ca24bf4 907
5ca24bf4 908
d14a1e28 909
dc2f8a65
RD
910//---------------------------------------------------------------------------
911//---------------------------------------------------------------------------
d14a1e28 912%newgroup
dc2f8a65
RD
913
914
9416aa89 915class wxHtmlDCRenderer : public wxObject {
dc2f8a65
RD
916public:
917 wxHtmlDCRenderer();
918 ~wxHtmlDCRenderer();
919
920 void SetDC(wxDC *dc, int maxwidth);
921 void SetSize(int width, int height);
922 void SetHtmlText(const wxString& html,
137b5242 923 const wxString& basepath = wxPyEmptyString,
dd9f7fea 924 bool isdir = True);
1fded56b 925 // Sets fonts to be used when displaying HTML page. (if size null then default sizes used).
d14a1e28 926 %extend {
9cbf6f6e
RD
927 void SetFonts(wxString normal_face, wxString fixed_face, PyObject* sizes=NULL) {
928 int* temp = NULL;
929 if (sizes) temp = int_LIST_helper(sizes);
930 self->SetFonts(normal_face, fixed_face, temp);
931 if (temp)
932 delete [] temp;
933 }
934 }
dd9f7fea 935 int Render(int x, int y, int from = 0, int dont_render = False, int to = INT_MAX,
3ef86e32
RD
936 //int *known_pagebreaks = NULL, int number_of_pages = 0
937 int* choices=NULL, int LCOUNT = 0
938 );
dc2f8a65
RD
939 int GetTotalHeight();
940 // returns total height of the html document
941 // (compare Render's return value with this)
942};
943
d14a1e28 944
dc2f8a65
RD
945enum {
946 wxPAGE_ODD,
947 wxPAGE_EVEN,
948 wxPAGE_ALL
949};
950
951
952class wxHtmlPrintout : public wxPyPrintout {
953public:
137b5242 954 wxHtmlPrintout(const wxString& title = wxPyHtmlPrintoutTitleStr);
f3d9dc1d 955 //~wxHtmlPrintout(); wxPrintPreview object takes ownership...
dc2f8a65
RD
956
957 void SetHtmlText(const wxString& html,
137b5242 958 const wxString &basepath = wxPyEmptyString,
dd9f7fea 959 bool isdir = True);
dc2f8a65
RD
960 void SetHtmlFile(const wxString &htmlfile);
961 void SetHeader(const wxString& header, int pg = wxPAGE_ALL);
962 void SetFooter(const wxString& footer, int pg = wxPAGE_ALL);
d14a1e28 963
1fded56b 964 // Sets fonts to be used when displaying HTML page. (if size null then default sizes used).
d14a1e28 965 %extend {
9cbf6f6e
RD
966 void SetFonts(wxString normal_face, wxString fixed_face, PyObject* sizes=NULL) {
967 int* temp = NULL;
968 if (sizes) temp = int_LIST_helper(sizes);
969 self->SetFonts(normal_face, fixed_face, temp);
970 if (temp)
971 delete [] temp;
972 }
973 }
dc2f8a65
RD
974 void SetMargins(float top = 25.2, float bottom = 25.2,
975 float left = 25.2, float right = 25.2,
976 float spaces = 5);
3ef86e32
RD
977
978 // Adds input filter
979 static void AddFilter(wxHtmlFilter *filter);
980
981 // Cleanup
982 static void CleanUpStatics();
dc2f8a65
RD
983};
984
985
986
9416aa89 987class wxHtmlEasyPrinting : public wxObject {
dc2f8a65 988public:
137b5242 989 wxHtmlEasyPrinting(const wxString& name = wxPyHtmlPrintingTitleStr,
3ef86e32 990 wxWindow *parentWindow = NULL);
dc2f8a65
RD
991 ~wxHtmlEasyPrinting();
992
993 void PreviewFile(const wxString &htmlfile);
137b5242 994 void PreviewText(const wxString &htmltext, const wxString& basepath = wxPyEmptyString);
dc2f8a65 995 void PrintFile(const wxString &htmlfile);
137b5242 996 void PrintText(const wxString &htmltext, const wxString& basepath = wxPyEmptyString);
dc2f8a65
RD
997 void PrinterSetup();
998 void PageSetup();
999 void SetHeader(const wxString& header, int pg = wxPAGE_ALL);
1000 void SetFooter(const wxString& footer, int pg = wxPAGE_ALL);
1001
d14a1e28 1002 %extend {
9cbf6f6e
RD
1003 void SetFonts(wxString normal_face, wxString fixed_face, PyObject* sizes=NULL) {
1004 int* temp = NULL;
1005 if (sizes) temp = int_LIST_helper(sizes);
1006 self->SetFonts(normal_face, fixed_face, temp);
1007 if (temp)
1008 delete [] temp;
1009 }
1010 }
1011
dc2f8a65
RD
1012 wxPrintData *GetPrintData() {return m_PrintData;}
1013 wxPageSetupDialogData *GetPageSetupData() {return m_PageSetupData;}
1014
1015};
1016
1017
0f66a9f3
RD
1018//---------------------------------------------------------------------------
1019//---------------------------------------------------------------------------
d14a1e28 1020%newgroup
5ca24bf4 1021
4b123bb9 1022
d14a1e28
RD
1023class wxHtmlBookRecord {
1024public:
1025 wxHtmlBookRecord(const wxString& bookfile, const wxString& basepath,
1026 const wxString& title, const wxString& start);
4b123bb9 1027
d14a1e28
RD
1028 wxString GetBookFile();
1029 wxString GetTitle();
1030 wxString GetStart();
1031 wxString GetBasePath();
1032
1033 void SetContentsRange(int start, int end);
1034 int GetContentsStart();
1035 int GetContentsEnd();
4b123bb9 1036
d14a1e28
RD
1037 void SetTitle(const wxString& title);
1038 void SetBasePath(const wxString& path);
1039 void SetStart(const wxString& start);
1040
1041 wxString GetFullPath(const wxString &page) const;
1042};
1043
1044//---------------------------------------------------------------------------
0f66a9f3 1045
d14a1e28
RD
1046struct wxHtmlContentsItem
1047{
1048 %extend {
1049 int GetLevel() { return self->m_Level; }
1050 int GetID() { return self->m_ID; }
1051 wxString GetName() { return self->m_Name; }
1052 wxString GetPage() { return self->m_Page; }
1053 wxHtmlBookRecord* GetBook() { return self->m_Book; }
1054 }
1055};
1056
1057//---------------------------------------------------------------------------
1058
1059class wxHtmlSearchStatus
1060{
1061public:
1062 //wxHtmlSearchStatus(wxHtmlHelpData* base, const wxString& keyword,
1063 // const wxString& book = wxPyEmptyString);
1064 bool Search();
1065 bool IsActive();
1066 int GetCurIndex();
1067 int GetMaxIndex();
1068 const wxString& GetName();
1069 wxHtmlContentsItem* GetContentsItem();
1070};
1071
1072//---------------------------------------------------------------------------
1073
1074class wxHtmlHelpData {
1075public:
1076 wxHtmlHelpData();
1077 ~wxHtmlHelpData();
1078
1079 void SetTempDir(const wxString& path);
1080 bool AddBook(const wxString& book);
1081// bool AddBookParam(const wxString& title, const wxString& contfile,
1082// const wxString& indexfile=wxPyEmptyString,
1083// const wxString& deftopic=wxPyEmptyString,
1084// const wxString& path=wxPyEmptyString);
1085
1086 wxString FindPageByName(const wxString& page);
1087 wxString FindPageById(int id);
1088
1089 // TODO: this one needs fixed...
1090 const wxHtmlBookRecArray& GetBookRecArray();
1091
1092 wxHtmlContentsItem* GetContents();
1093 int GetContentsCnt();
1094 wxHtmlContentsItem* GetIndex();
1095 int GetIndexCnt();
1096};
1097
1098//---------------------------------------------------------------------------
1099
1100class wxHtmlHelpFrame : public wxFrame {
1101public:
2b9048c5 1102 %pythonAppend wxHtmlHelpFrame "self._setOORInfo(self)"
d14a1e28
RD
1103
1104 wxHtmlHelpFrame(wxWindow* parent, int wxWindowID,
1105 const wxString& title = wxPyEmptyString,
1106 int style = wxHF_DEFAULTSTYLE, wxHtmlHelpData* data = NULL);
1107
1108 wxHtmlHelpData* GetData();
1109 void SetTitleFormat(const wxString& format);
1110 void Display(const wxString& x);
1111 %name(DisplayID) void Display(int id);
1112 void DisplayContents();
1113 void DisplayIndex();
1114 bool KeywordSearch(const wxString& keyword);
1115 void UseConfig(wxConfigBase *config, const wxString& rootpath = wxPyEmptyString);
1116 void ReadCustomization(wxConfigBase *cfg, wxString path = wxPyEmptyString);
1117 void WriteCustomization(wxConfigBase *cfg, wxString path = wxPyEmptyString);
1118};
1119
1120
1121//---------------------------------------------------------------------------
1122
1123
1124enum {
1125 wxHF_TOOLBAR,
1126 wxHF_FLATTOOLBAR,
1127 wxHF_CONTENTS,
1128 wxHF_INDEX,
1129 wxHF_SEARCH,
1130 wxHF_BOOKMARKS,
1131 wxHF_OPENFILES,
1132 wxHF_PRINT,
1133 wxHF_DEFAULTSTYLE,
1134};
1135
1136
1137class wxHtmlHelpController : public wxEvtHandler {
1138public:
2b9048c5 1139 %pythonAppend wxHtmlHelpController "self._setOORInfo(self)"
d14a1e28
RD
1140
1141 wxHtmlHelpController(int style = wxHF_DEFAULTSTYLE);
1142 ~wxHtmlHelpController();
1143
1144 void SetTitleFormat(const wxString& format);
1145 void SetTempDir(const wxString& path);
dd9f7fea 1146 bool AddBook(const wxString& book, int show_wait_msg = False);
d14a1e28
RD
1147 void Display(const wxString& x);
1148 %name(DisplayID) void Display(int id);
1149 void DisplayContents();
1150 void DisplayIndex();
1151 bool KeywordSearch(const wxString& keyword);
1152 void UseConfig(wxConfigBase *config, const wxString& rootpath = wxPyEmptyString);
1153 void ReadCustomization(wxConfigBase *cfg, wxString path = wxPyEmptyString);
1154 void WriteCustomization(wxConfigBase *cfg, wxString path = wxPyEmptyString);
1155 wxHtmlHelpFrame* GetFrame();
1156};
1157
1158
1159
1160
1161//---------------------------------------------------------------------------
1162%init %{
1163 wxPyPtrTypeMap_Add("wxHtmlTagHandler", "wxPyHtmlTagHandler");
9416aa89 1164 wxPyPtrTypeMap_Add("wxHtmlWinTagHandler", "wxPyHtmlWinTagHandler");
d14a1e28
RD
1165 wxPyPtrTypeMap_Add("wxHtmlWindow", "wxPyHtmlWindow");
1166 wxPyPtrTypeMap_Add("wxHtmlFilter", "wxPyHtmlFilter");
4b123bb9 1167%}
d14a1e28
RD
1168//---------------------------------------------------------------------------
1169//---------------------------------------------------------------------------
4b123bb9 1170
e166644c 1171
e166644c 1172