wxPython/src/html.i

/////////////////////////////////////////////////////////////////////////////
// Name:        html.i
// Purpose:     SWIG definitions of html classes
//
// Author:      Robin Dunn
//
// Created:     25-nov-1998
// RCS-ID:      $Id$
// Copyright:   (c) 1998 by Total Control Software
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////


%module html

%{
#include "export.h"
#include <wx/html/htmlwin.h>
#include <wx/html/htmprint.h>
#include <wx/image.h>
#include <wx/fs_zip.h>
#include <wx/fs_inet.h>
#include <wx/wfstream.h>

#include "printfw.h"
%}

//---------------------------------------------------------------------------

%include typemaps.i
%include my_typemaps.i

%extern wx.i
%extern windows.i
%extern _defs.i
%extern events.i
%extern controls.i
%extern controls2.i
%extern printfw.i

%extern utils.i

%pragma(python) code = "import wx"


//----------------------------------------------------------------------

%{
    // Put some wx default wxChar* values into wxStrings.
    static const wxChar* wxHtmlWindowNameStr = wxT("htmlWindow");
    DECLARE_DEF_STRING(HtmlWindowNameStr);

    static const wxChar* wxHtmlPrintoutTitleStr = wxT("Printout");
    DECLARE_DEF_STRING(HtmlPrintoutTitleStr);

    static const wxChar* wxHtmlPrintingTitleStr = wxT("Printing");
    DECLARE_DEF_STRING(HtmlPrintingTitleStr);

    static const wxString wxPyEmptyString(wxT(""));
%}

//---------------------------------------------------------------------------

enum {
    wxHTML_ALIGN_LEFT,
    wxHTML_ALIGN_CENTER,
    wxHTML_ALIGN_RIGHT,
    wxHTML_ALIGN_BOTTOM,
    wxHTML_ALIGN_TOP,

    wxHTML_CLR_FOREGROUND,
    wxHTML_CLR_BACKGROUND,

    wxHTML_UNITS_PIXELS,
    wxHTML_UNITS_PERCENT,

    wxHTML_INDENT_LEFT,
    wxHTML_INDENT_RIGHT,
    wxHTML_INDENT_TOP,
    wxHTML_INDENT_BOTTOM,

    wxHTML_INDENT_HORIZONTAL,
    wxHTML_INDENT_VERTICAL,
    wxHTML_INDENT_ALL,

    wxHTML_COND_ISANCHOR,
    wxHTML_COND_ISIMAGEMAP,
    wxHTML_COND_USER,
};


enum {
    wxHW_SCROLLBAR_NEVER,
    wxHW_SCROLLBAR_AUTO,
};


// enums for wxHtmlWindow::OnOpeningURL
enum wxHtmlOpeningStatus
{
    wxHTML_OPEN,
    wxHTML_BLOCK,
    wxHTML_REDIRECT
};

enum wxHtmlURLType
{
    wxHTML_URL_PAGE,
    wxHTML_URL_IMAGE,
    wxHTML_URL_OTHER
};

//---------------------------------------------------------------------------

class wxHtmlLinkInfo : public wxObject {
public:
    wxHtmlLinkInfo(const wxString& href, const wxString& target = wxPyEmptyString);
    wxString GetHref();
    wxString GetTarget();
    wxMouseEvent* GetEvent();
    wxHtmlCell* GetHtmlCell();

    void SetEvent(const wxMouseEvent *e);
    void SetHtmlCell(const wxHtmlCell * e);
};

//---------------------------------------------------------------------------

class wxHtmlTag : public wxObject {
public:
    // Never need to create a new tag from Python...
    //wxHtmlTag(const wxString& source, int pos, int end_pos, wxHtmlTagsCache* cache);

    wxString GetName();
    bool HasParam(const wxString& par);
    wxString GetParam(const wxString& par, int with_commas = FALSE);

    // Can't do this one as-is, but GetParam should be enough...
    //int ScanParam(const wxString& par, const char *format, void* param);

    wxString GetAllParams();
    bool HasEnding();
    int GetBeginPos();
    int GetEndPos1();
    int GetEndPos2();
};


//---------------------------------------------------------------------------

class wxHtmlParser : public wxObject {
public:
    // wxHtmlParser();  This is an abstract base class...

    void SetFS(wxFileSystem *fs);
    wxFileSystem* GetFS();
    wxObject* Parse(const wxString& source);
    void InitParser(const wxString& source);
    void DoneParser();
    void DoParsing(int begin_pos, int end_pos);
    // wxObject* GetProduct();
    void AddTagHandler(wxHtmlTagHandler *handler);
    wxString* GetSource();
    void PushTagHandler(wxHtmlTagHandler* handler, wxString tags);
    void PopTagHandler();

    // virtual wxFSFile *OpenURL(wxHtmlURLType type, const wxString& url) const;

    // void AddText(const char* txt) = 0;
    // void AddTag(const wxHtmlTag& tag);
};


//---------------------------------------------------------------------------

class wxHtmlWinParser : public wxHtmlParser {
public:
    wxHtmlWinParser(wxHtmlWindow *wnd = NULL);

    void SetDC(wxDC *dc);
    wxDC* GetDC();
    int GetCharHeight();
    int GetCharWidth();
    wxHtmlWindow* GetWindow();
    //void SetFonts(wxString normal_face, wxString fixed_face, int *LIST);
    %addmethods {
        void SetFonts(wxString normal_face, wxString fixed_face, PyObject* sizes) {
            int* temp = int_LIST_helper(sizes);
            if (temp) {
                self->SetFonts(normal_face, fixed_face, temp);
                delete [] temp;
            }
        }
    }

    wxHtmlContainerCell* GetContainer();
    wxHtmlContainerCell* OpenContainer();
    wxHtmlContainerCell *SetContainer(wxHtmlContainerCell *c);
    wxHtmlContainerCell* CloseContainer();

    int GetFontSize();
    void SetFontSize(int s);
    int GetFontBold();
    void SetFontBold(int x);
    int GetFontItalic();
    void SetFontItalic(int x);
    int GetFontUnderlined();
    void SetFontUnderlined(int x);
    int GetFontFixed();
    void SetFontFixed(int x);
    int GetAlign();
    void SetAlign(int a);
    wxColour GetLinkColor();
    void SetLinkColor(const wxColour& clr);
    wxColour GetActualColor();
    void SetActualColor(const wxColour& clr);
    void SetLink(const wxString& link);
    wxFont* CreateCurrentFont();
    wxHtmlLinkInfo GetLink();

};


//---------------------------------------------------------------------------

%{
class wxPyHtmlTagHandler : public wxHtmlTagHandler {
    DECLARE_DYNAMIC_CLASS(wxPyHtmlTagHandler);
public:
    wxPyHtmlTagHandler() : wxHtmlTagHandler() {};

    wxHtmlParser* GetParser() { return m_Parser; }
    void ParseInner(const wxHtmlTag& tag) { wxHtmlTagHandler::ParseInner(tag); }

    DEC_PYCALLBACK_STRING__pure(GetSupportedTags);
    DEC_PYCALLBACK_BOOL_TAG_pure(HandleTag);

    PYPRIVATE;
};

IMPLEMENT_DYNAMIC_CLASS(wxPyHtmlTagHandler, wxHtmlTagHandler);

IMP_PYCALLBACK_STRING__pure(wxPyHtmlTagHandler, wxHtmlTagHandler, GetSupportedTags);
IMP_PYCALLBACK_BOOL_TAG_pure(wxPyHtmlTagHandler, wxHtmlTagHandler, HandleTag);
%}


%name(wxHtmlTagHandler) class wxPyHtmlTagHandler : public wxObject {
public:
    wxPyHtmlTagHandler();

    void _setCallbackInfo(PyObject* self, PyObject* _class);
    %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxHtmlTagHandler)"

    void SetParser(wxHtmlParser *parser);
    wxHtmlParser* GetParser();
    void ParseInner(const wxHtmlTag& tag);
};


//---------------------------------------------------------------------------

%{
class wxPyHtmlWinTagHandler : public wxHtmlWinTagHandler {
    DECLARE_DYNAMIC_CLASS(wxPyHtmlWinTagHandler);
public:
    wxPyHtmlWinTagHandler() : wxHtmlWinTagHandler() {};

    wxHtmlWinParser* GetParser() { return m_WParser; }
    void ParseInner(const wxHtmlTag& tag)
        { wxHtmlWinTagHandler::ParseInner(tag); }

    DEC_PYCALLBACK_STRING__pure(GetSupportedTags);
    DEC_PYCALLBACK_BOOL_TAG_pure(HandleTag);

    PYPRIVATE;
};

IMPLEMENT_DYNAMIC_CLASS( wxPyHtmlWinTagHandler, wxHtmlWinTagHandler);

IMP_PYCALLBACK_STRING__pure(wxPyHtmlWinTagHandler, wxHtmlWinTagHandler, GetSupportedTags);
IMP_PYCALLBACK_BOOL_TAG_pure(wxPyHtmlWinTagHandler, wxHtmlWinTagHandler, HandleTag);
%}


%name(wxHtmlWinTagHandler) class wxPyHtmlWinTagHandler : public wxPyHtmlTagHandler {
public:
    wxPyHtmlWinTagHandler();

    void _setCallbackInfo(PyObject* self, PyObject* _class);
    %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxHtmlWinTagHandler)"

    void SetParser(wxHtmlParser *parser);
    wxHtmlWinParser* GetParser();
    void ParseInner(const wxHtmlTag& tag);
};


//---------------------------------------------------------------------------

%{

class wxPyHtmlTagsModule : public wxHtmlTagsModule {
public:
    wxPyHtmlTagsModule(PyObject* thc) : wxHtmlTagsModule() {
        m_tagHandlerClass = thc;
        Py_INCREF(m_tagHandlerClass);
        RegisterModule(this);
        wxHtmlWinParser::AddModule(this);
    }

    void OnExit() {
        wxPyBeginBlockThreads();
        Py_DECREF(m_tagHandlerClass);
        m_tagHandlerClass = NULL;
        for (size_t x=0; x < m_objArray.GetCount(); x++) {
            PyObject* obj = (PyObject*)m_objArray.Item(x);
            Py_DECREF(obj);
        }
        wxPyEndBlockThreads();
    };

    void FillHandlersTable(wxHtmlWinParser *parser) {
        // Wave our magic wand...  (if it works it's a miracle!  ;-)

        // First, make a new instance of the tag handler
        wxPyBeginBlockThreads();
        PyObject* arg = Py_BuildValue("()");
        PyObject* obj = PyInstance_New(m_tagHandlerClass, arg, NULL);
        Py_DECREF(arg);
        wxPyEndBlockThreads();

        // now figure out where it's C++ object is...
        wxPyHtmlWinTagHandler* thPtr;
        if (SWIG_GetPtrObj(obj, (void **)&thPtr, "_wxPyHtmlWinTagHandler_p"))
            return;

        // add it,
        parser->AddTagHandler(thPtr);

        // and track it.
        m_objArray.Add(obj);
    }

private:
    PyObject*           m_tagHandlerClass;
    wxArrayPtrVoid      m_objArray;

};
%}


%inline %{
    void wxHtmlWinParser_AddTagHandler(PyObject* tagHandlerClass) {
        // Dynamically create a new wxModule.  Refcounts tagHandlerClass
        // and adds itself to the wxModules list and to the wxHtmlWinParser.
        new wxPyHtmlTagsModule(tagHandlerClass);
    }
%}


//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

class wxHtmlCell : public wxObject {
public:
    wxHtmlCell();

    int GetPosX();
    int GetPosY();
    int GetWidth();
    int GetHeight();
    int GetDescent();
    wxHtmlLinkInfo* GetLink(int x = 0, int y = 0);
    wxHtmlCell* GetNext();
    wxHtmlContainerCell* GetParent();
    void SetLink(const wxHtmlLinkInfo& link);
    void SetNext(wxHtmlCell *cell);
    void SetParent(wxHtmlContainerCell *p);
    void SetPos(int x, int y);
    void Layout(int w);
    void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2);
    void DrawInvisible(wxDC& dc, int x, int y);
    const wxHtmlCell* Find(int condition, const void* param);

    bool AdjustPagebreak(int * pagebreak);
    void SetCanLiveOnPagebreak(bool can);

};


class  wxHtmlWordCell : public wxHtmlCell
{
public:
    wxHtmlWordCell(const wxString& word, wxDC& dc);
};


class wxHtmlContainerCell : public wxHtmlCell {
public:
    wxHtmlContainerCell(wxHtmlContainerCell *parent);

    void InsertCell(wxHtmlCell *cell);
    void SetAlignHor(int al);
    int GetAlignHor();
    void SetAlignVer(int al);
    int GetAlignVer();
    void SetIndent(int i, int what, int units = wxHTML_UNITS_PIXELS);
    int GetIndent(int ind);
    int GetIndentUnits(int ind);
    void SetAlign(const wxHtmlTag& tag);
    void SetWidthFloat(int w, int units);
    %name(SetWidthFloatFromTag)void SetWidthFloat(const wxHtmlTag& tag);
    void SetMinHeight(int h, int align = wxHTML_ALIGN_TOP);
    void SetBackgroundColour(const wxColour& clr);
    void SetBorder(const wxColour& clr1, const wxColour& clr2);
    wxHtmlCell* GetFirstCell();
};


class wxHtmlColourCell : public wxHtmlCell {
public:
    wxHtmlColourCell(wxColour clr, int flags = wxHTML_CLR_FOREGROUND);

};


class  wxHtmlFontCell : public wxHtmlCell
{
public:
    wxHtmlFontCell(wxFont *font);
};


class wxHtmlWidgetCell : public wxHtmlCell {
public:
    wxHtmlWidgetCell(wxWindow* wnd, int w = 0);

};


//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

%{
class wxPyHtmlWindow : public wxHtmlWindow {
    DECLARE_ABSTRACT_CLASS(wxPyHtmlWindow);
public:
    wxPyHtmlWindow(wxWindow *parent, wxWindowID id = -1,
                   const wxPoint& pos = wxDefaultPosition,
                   const wxSize& size = wxDefaultSize,
                   long style = wxHW_SCROLLBAR_AUTO,
                   const wxString& name = "htmlWindow")
        : wxHtmlWindow(parent, id, pos, size, style, name)  {};
    wxPyHtmlWindow() : wxHtmlWindow() {};

    bool ScrollToAnchor(const wxString& anchor) {
        return wxHtmlWindow::ScrollToAnchor(anchor);
    }

    bool HasAnchor(const wxString& anchor) {
        const wxHtmlCell *c = m_Cell->Find(wxHTML_COND_ISANCHOR, &anchor);
        return c!=NULL;
    }

    void OnLinkClicked(const wxHtmlLinkInfo& link);
    void base_OnLinkClicked(const wxHtmlLinkInfo& link);

    wxHtmlOpeningStatus OnOpeningURL(wxHtmlURLType type,
                                      const wxString& url,
                                      wxString *redirect) const;

    DEC_PYCALLBACK__STRING(OnSetTitle);
    DEC_PYCALLBACK__CELLINTINT(OnCellMouseHover);
    DEC_PYCALLBACK__CELLINTINTME(OnCellClicked);
//     DEC_PYCALLBACK_BOOL_STRING(OnOpeningURL);
    PYPRIVATE;
};

IMPLEMENT_ABSTRACT_CLASS( wxPyHtmlWindow, wxHtmlWindow );
IMP_PYCALLBACK__STRING(wxPyHtmlWindow, wxHtmlWindow, OnSetTitle);
IMP_PYCALLBACK__CELLINTINT(wxPyHtmlWindow, wxHtmlWindow, OnCellMouseHover);
IMP_PYCALLBACK__CELLINTINTME(wxPyHtmlWindow, wxHtmlWindow, OnCellClicked);
// IMP_PYCALLBACK_BOOL_STRING(wxPyHtmlWindow, wxHtmlWindow, OnOpeningURL);


void wxPyHtmlWindow::OnLinkClicked(const wxHtmlLinkInfo& link) {
    bool found;
    wxPyBeginBlockThreads();
    if ((found = wxPyCBH_findCallback(m_myInst, "OnLinkClicked"))) {
        PyObject* obj = wxPyConstructObject((void*)&link, "wxHtmlLinkInfo", 0);
        wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));
        Py_DECREF(obj);
    }
    wxPyEndBlockThreads();
    if (! found)
        wxHtmlWindow::OnLinkClicked(link);
}
void wxPyHtmlWindow::base_OnLinkClicked(const wxHtmlLinkInfo& link) {
    wxHtmlWindow::OnLinkClicked(link);
}


wxHtmlOpeningStatus wxPyHtmlWindow::OnOpeningURL(wxHtmlURLType type,
                                                 const wxString& url,
                                                 wxString *redirect) const {
    bool found;
    wxHtmlOpeningStatus rval;
    wxPyBeginBlockThreads();
    if ((found = wxPyCBH_findCallback(m_myInst, "OnOpeningURL"))) {
        PyObject* ro;
        ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(iO)", type, wx2PyString(url)));
        if (PyString_Check(ro)
#if PYTHON_API_VERSION >= 1009
            || PyUnicode_Check(ro)
#endif
            ) {
            *redirect = Py2wxString(ro);
            rval = wxHTML_REDIRECT;
        }
        else {
            PyObject* num = PyNumber_Int(ro);
            rval = (wxHtmlOpeningStatus)PyInt_AsLong(num);
            Py_DECREF(num);
        }
        Py_DECREF(ro);
    }
    wxPyEndBlockThreads();
    if (! found)
        rval = wxHtmlWindow::OnOpeningURL(type, url, redirect);
    return rval;
}


%}


%name(wxHtmlWindow) class wxPyHtmlWindow : public wxScrolledWindow {
public:
    wxPyHtmlWindow(wxWindow *parent, int id = -1,
                 wxPoint& pos = wxDefaultPosition,
                 wxSize& size = wxDefaultSize,
                 int style=wxHW_SCROLLBAR_AUTO,
                 const wxString& name = wxPyHtmlWindowNameStr);
    %name(wxPreHtmlWindow)wxPyHtmlWindow();

    bool Create(wxWindow *parent, int id = -1,
                wxPoint& pos = wxDefaultPosition,
                wxSize& size = wxDefaultSize,
                int style=wxHW_SCROLLBAR_AUTO,
                const wxString& name = wxPyHtmlWindowNameStr);


    void _setCallbackInfo(PyObject* self, PyObject* _class);
    %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxHtmlWindow)"
    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
    %pragma(python) addtomethod = "wxPreHtmlWindow:val._setOORInfo(val)"

    bool SetPage(const wxString& source);
    bool LoadPage(const wxString& location);
    bool AppendToPage(const wxString& source);
    wxString GetOpenedPage();
    wxString GetOpenedAnchor();
    wxString GetOpenedPageTitle();

    void SetRelatedFrame(wxFrame* frame, const wxString& format);
    wxFrame* GetRelatedFrame();
    void SetRelatedStatusBar(int bar);

    //void SetFonts(wxString normal_face, wxString fixed_face, int *LIST);
    %addmethods {
        void SetFonts(wxString normal_face, wxString fixed_face, PyObject* sizes) {
            int* temp = int_LIST_helper(sizes);
            if (temp) {
                self->SetFonts(normal_face, fixed_face, temp);
                delete [] temp;
            }
        }
    }

    void SetTitle(const wxString& title);
    void SetBorders(int b);
    void ReadCustomization(wxConfigBase *cfg, wxString path = wxPyEmptyString);
    void WriteCustomization(wxConfigBase *cfg, wxString path = wxPyEmptyString);
    bool HistoryBack();
    bool HistoryForward();
    bool HistoryCanBack();
    bool HistoryCanForward();
    void HistoryClear();
    wxHtmlContainerCell* GetInternalRepresentation();
    wxHtmlWinParser* GetParser();

    bool ScrollToAnchor(const wxString& anchor);
    bool HasAnchor(const wxString& anchor);

    void base_OnLinkClicked(const wxHtmlLinkInfo& link);
    void base_OnSetTitle(const wxString& title);
    void base_OnCellMouseHover(wxHtmlCell *cell, wxCoord x, wxCoord y);
    void base_OnCellClicked(wxHtmlCell *cell,
                            wxCoord x, wxCoord y,
                            const wxMouseEvent& event);
};

// Static methods are mapped to stand-alone functions
%inline %{
    void wxHtmlWindow_AddFilter(wxHtmlFilter *filter) {
        wxHtmlWindow::AddFilter(filter);
    }
%}


//---------------------------------------------------------------------------
//---------------------------------------------------------------------------


class wxHtmlDCRenderer : public wxObject {
public:
    wxHtmlDCRenderer();
    ~wxHtmlDCRenderer();

    void SetDC(wxDC *dc, int maxwidth);
    void SetSize(int width, int height);
    void SetHtmlText(const wxString& html,
                     const wxString& basepath = wxPyEmptyString,
                     bool isdir = TRUE);
    int Render(int x, int y, int from = 0, int dont_render = FALSE);
    int GetTotalHeight();
                // returns total height of the html document
                // (compare Render's return value with this)
};

enum {
    wxPAGE_ODD,
    wxPAGE_EVEN,
    wxPAGE_ALL
};


class wxHtmlPrintout : public wxPyPrintout {
public:
    wxHtmlPrintout(const wxString& title = wxPyHtmlPrintoutTitleStr);
    //~wxHtmlPrintout();   wxPrintPreview object takes ownership...

    void SetHtmlText(const wxString& html,
                     const wxString &basepath = wxPyEmptyString,
                     bool isdir = TRUE);
    void SetHtmlFile(const wxString &htmlfile);
    void SetHeader(const wxString& header, int pg = wxPAGE_ALL);
    void SetFooter(const wxString& footer, int pg = wxPAGE_ALL);
    void SetMargins(float top = 25.2, float bottom = 25.2,
                    float left = 25.2, float right = 25.2,
                    float spaces = 5);
};


class wxHtmlEasyPrinting : public wxObject {
public:
    wxHtmlEasyPrinting(const wxString& name = wxPyHtmlPrintingTitleStr,
                       wxFrame *parent_frame = NULL);
    ~wxHtmlEasyPrinting();

    void PreviewFile(const wxString &htmlfile);
    void PreviewText(const wxString &htmltext, const wxString& basepath = wxPyEmptyString);
    void PrintFile(const wxString &htmlfile);
    void PrintText(const wxString &htmltext, const wxString& basepath = wxPyEmptyString);
    void PrinterSetup();
    void PageSetup();
    void SetHeader(const wxString& header, int pg = wxPAGE_ALL);
    void SetFooter(const wxString& footer, int pg = wxPAGE_ALL);

    wxPrintData *GetPrintData() {return m_PrintData;}
    wxPageSetupDialogData *GetPageSetupData() {return m_PageSetupData;}

};


//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

%{
    extern "C" SWIGEXPORT(void) inithtmlhelpc();
%}


%init %{

    inithtmlhelpc();

    wxClassInfo::CleanUpClasses();
    wxClassInfo::InitializeClasses();

    wxPyPtrTypeMap_Add("wxHtmlTagHandler", "wxPyHtmlTagHandler");
    wxPyPtrTypeMap_Add("wxHtmlWinTagHandler", "wxPyHtmlWinTagHandler");
    wxPyPtrTypeMap_Add("wxHtmlWindow", "wxPyHtmlWindow");
%}

//----------------------------------------------------------------------
// And this gets appended to the shadow class file.
//----------------------------------------------------------------------

%pragma(python) include="_htmlextras.py";

//---------------------------------------------------------------------------
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: html.i
	3	// Purpose: SWIG definitions of html classes
	4	//
	5	// Author: Robin Dunn
	6	//
	7	// Created: 25-nov-1998
	8	// RCS-ID: $Id$
	9	// Copyright: (c) 1998 by Total Control Software
	10	// Licence: wxWindows license
	11	/////////////////////////////////////////////////////////////////////////////
	12
	13
	14	%module html
	15
	16	%{
	17	#include "export.h"
	18	#include <wx/html/htmlwin.h>
	19	#include <wx/html/htmprint.h>
	20	#include <wx/image.h>
	21	#include <wx/fs_zip.h>
	22	#include <wx/fs_inet.h>
	23	#include <wx/wfstream.h>
	24
	25	#include "printfw.h"
	26	%}
	27
	28	//---------------------------------------------------------------------------
	29
	30	%include typemaps.i
	31	%include my_typemaps.i
	32
	33	%extern wx.i
	34	%extern windows.i
	35	%extern _defs.i
	36	%extern events.i
	37	%extern controls.i
	38	%extern controls2.i
	39	%extern printfw.i
	40
	41	%extern utils.i
	42
	43	%pragma(python) code = "import wx"
	44
	45
	46	//----------------------------------------------------------------------
	47
	48	%{
	49	// Put some wx default wxChar* values into wxStrings.
	50	static const wxChar* wxHtmlWindowNameStr = wxT("htmlWindow");
	51	DECLARE_DEF_STRING(HtmlWindowNameStr);
	52
	53	static const wxChar* wxHtmlPrintoutTitleStr = wxT("Printout");
	54	DECLARE_DEF_STRING(HtmlPrintoutTitleStr);
	55
	56	static const wxChar* wxHtmlPrintingTitleStr = wxT("Printing");
	57	DECLARE_DEF_STRING(HtmlPrintingTitleStr);
	58
	59	static const wxString wxPyEmptyString(wxT(""));
	60	%}
	61
	62	//---------------------------------------------------------------------------
	63
	64	enum {
	65	wxHTML_ALIGN_LEFT,
	66	wxHTML_ALIGN_CENTER,
	67	wxHTML_ALIGN_RIGHT,
	68	wxHTML_ALIGN_BOTTOM,
	69	wxHTML_ALIGN_TOP,
	70
	71	wxHTML_CLR_FOREGROUND,
	72	wxHTML_CLR_BACKGROUND,
	73
	74	wxHTML_UNITS_PIXELS,
	75	wxHTML_UNITS_PERCENT,
	76
	77	wxHTML_INDENT_LEFT,
	78	wxHTML_INDENT_RIGHT,
	79	wxHTML_INDENT_TOP,
	80	wxHTML_INDENT_BOTTOM,
	81
	82	wxHTML_INDENT_HORIZONTAL,
	83	wxHTML_INDENT_VERTICAL,
	84	wxHTML_INDENT_ALL,
	85
	86	wxHTML_COND_ISANCHOR,
	87	wxHTML_COND_ISIMAGEMAP,
	88	wxHTML_COND_USER,
	89	};
	90
	91
	92	enum {
	93	wxHW_SCROLLBAR_NEVER,
	94	wxHW_SCROLLBAR_AUTO,
	95	};
	96
	97
	98	// enums for wxHtmlWindow::OnOpeningURL
	99	enum wxHtmlOpeningStatus
	100	{
	101	wxHTML_OPEN,
	102	wxHTML_BLOCK,
	103	wxHTML_REDIRECT
	104	};
	105
	106	enum wxHtmlURLType
	107	{
	108	wxHTML_URL_PAGE,
	109	wxHTML_URL_IMAGE,
	110	wxHTML_URL_OTHER
	111	};
	112
	113	//---------------------------------------------------------------------------
	114
	115	class wxHtmlLinkInfo : public wxObject {
	116	public:
	117	wxHtmlLinkInfo(const wxString& href, const wxString& target = wxPyEmptyString);
	118	wxString GetHref();
	119	wxString GetTarget();
	120	wxMouseEvent* GetEvent();
	121	wxHtmlCell* GetHtmlCell();
	122
	123	void SetEvent(const wxMouseEvent *e);
	124	void SetHtmlCell(const wxHtmlCell * e);
	125	};
	126
	127	//---------------------------------------------------------------------------
	128
	129	class wxHtmlTag : public wxObject {
	130	public:
	131	// Never need to create a new tag from Python...
	132	//wxHtmlTag(const wxString& source, int pos, int end_pos, wxHtmlTagsCache* cache);
	133
	134	wxString GetName();
	135	bool HasParam(const wxString& par);
	136	wxString GetParam(const wxString& par, int with_commas = FALSE);
	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();
	142	bool HasEnding();
	143	int GetBeginPos();
	144	int GetEndPos1();
	145	int GetEndPos2();
	146	};
	147
	148
	149	//---------------------------------------------------------------------------
	150
	151	class wxHtmlParser : public wxObject {
	152	public:
	153	// wxHtmlParser(); This is an abstract base class...
	154
	155	void SetFS(wxFileSystem *fs);
	156	wxFileSystem* GetFS();
	157	wxObject* Parse(const wxString& source);
	158	void InitParser(const wxString& source);
	159	void DoneParser();
	160	void DoParsing(int begin_pos, int end_pos);
	161	// wxObject* GetProduct();
	162	void AddTagHandler(wxHtmlTagHandler *handler);
	163	wxString* GetSource();
	164	void PushTagHandler(wxHtmlTagHandler* handler, wxString tags);
	165	void PopTagHandler();
	166
	167	// virtual wxFSFile *OpenURL(wxHtmlURLType type, const wxString& url) const;
	168
	169	// void AddText(const char* txt) = 0;
	170	// void AddTag(const wxHtmlTag& tag);
	171	};
	172
	173
	174	//---------------------------------------------------------------------------
	175
	176	class wxHtmlWinParser : public wxHtmlParser {
	177	public:
	178	wxHtmlWinParser(wxHtmlWindow *wnd = NULL);
	179
	180	void SetDC(wxDC *dc);
	181	wxDC* GetDC();
	182	int GetCharHeight();
	183	int GetCharWidth();
	184	wxHtmlWindow* GetWindow();
	185	//void SetFonts(wxString normal_face, wxString fixed_face, int *LIST);
	186	%addmethods {
	187	void SetFonts(wxString normal_face, wxString fixed_face, PyObject* sizes) {
	188	int* temp = int_LIST_helper(sizes);
	189	if (temp) {
	190	self->SetFonts(normal_face, fixed_face, temp);
	191	delete [] temp;
	192	}
	193	}
	194	}
	195
	196	wxHtmlContainerCell* GetContainer();
	197	wxHtmlContainerCell* OpenContainer();
	198	wxHtmlContainerCell SetContainer(wxHtmlContainerCell c);
	199	wxHtmlContainerCell* CloseContainer();
	200
	201	int GetFontSize();
	202	void SetFontSize(int s);
	203	int GetFontBold();
	204	void SetFontBold(int x);
	205	int GetFontItalic();
	206	void SetFontItalic(int x);
	207	int GetFontUnderlined();
	208	void SetFontUnderlined(int x);
	209	int GetFontFixed();
	210	void SetFontFixed(int x);
	211	int GetAlign();
	212	void SetAlign(int a);
	213	wxColour GetLinkColor();
	214	void SetLinkColor(const wxColour& clr);
	215	wxColour GetActualColor();
	216	void SetActualColor(const wxColour& clr);
	217	void SetLink(const wxString& link);
	218	wxFont* CreateCurrentFont();
	219	wxHtmlLinkInfo GetLink();
	220
	221	};
	222
	223
	224
	225	//---------------------------------------------------------------------------
	226
	227	%{
	228	class wxPyHtmlTagHandler : public wxHtmlTagHandler {
	229	DECLARE_DYNAMIC_CLASS(wxPyHtmlTagHandler);
	230	public:
	231	wxPyHtmlTagHandler() : wxHtmlTagHandler() {};
	232
	233	wxHtmlParser* GetParser() { return m_Parser; }
	234	void ParseInner(const wxHtmlTag& tag) { wxHtmlTagHandler::ParseInner(tag); }
	235
	236	DEC_PYCALLBACK_STRING__pure(GetSupportedTags);
	237	DEC_PYCALLBACK_BOOL_TAG_pure(HandleTag);
	238
	239	PYPRIVATE;
	240	};
	241
	242	IMPLEMENT_DYNAMIC_CLASS(wxPyHtmlTagHandler, wxHtmlTagHandler);
	243
	244	IMP_PYCALLBACK_STRING__pure(wxPyHtmlTagHandler, wxHtmlTagHandler, GetSupportedTags);
	245	IMP_PYCALLBACK_BOOL_TAG_pure(wxPyHtmlTagHandler, wxHtmlTagHandler, HandleTag);
	246	%}
	247
	248
	249	%name(wxHtmlTagHandler) class wxPyHtmlTagHandler : public wxObject {
	250	public:
	251	wxPyHtmlTagHandler();
	252
	253	void _setCallbackInfo(PyObject* self, PyObject* _class);
	254	%pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxHtmlTagHandler)"
	255
	256	void SetParser(wxHtmlParser *parser);
	257	wxHtmlParser* GetParser();
	258	void ParseInner(const wxHtmlTag& tag);
	259	};
	260
	261
	262	//---------------------------------------------------------------------------
	263
	264	%{
	265	class wxPyHtmlWinTagHandler : public wxHtmlWinTagHandler {
	266	DECLARE_DYNAMIC_CLASS(wxPyHtmlWinTagHandler);
	267	public:
	268	wxPyHtmlWinTagHandler() : wxHtmlWinTagHandler() {};
	269
	270	wxHtmlWinParser* GetParser() { return m_WParser; }
	271	void ParseInner(const wxHtmlTag& tag)
	272	{ wxHtmlWinTagHandler::ParseInner(tag); }
	273
	274	DEC_PYCALLBACK_STRING__pure(GetSupportedTags);
	275	DEC_PYCALLBACK_BOOL_TAG_pure(HandleTag);
	276
	277	PYPRIVATE;
	278	};
	279
	280	IMPLEMENT_DYNAMIC_CLASS( wxPyHtmlWinTagHandler, wxHtmlWinTagHandler);
	281
	282	IMP_PYCALLBACK_STRING__pure(wxPyHtmlWinTagHandler, wxHtmlWinTagHandler, GetSupportedTags);
	283	IMP_PYCALLBACK_BOOL_TAG_pure(wxPyHtmlWinTagHandler, wxHtmlWinTagHandler, HandleTag);
	284	%}
	285
	286
	287	%name(wxHtmlWinTagHandler) class wxPyHtmlWinTagHandler : public wxPyHtmlTagHandler {
	288	public:
	289	wxPyHtmlWinTagHandler();
	290
	291	void _setCallbackInfo(PyObject* self, PyObject* _class);
	292	%pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxHtmlWinTagHandler)"
	293
	294	void SetParser(wxHtmlParser *parser);
	295	wxHtmlWinParser* GetParser();
	296	void ParseInner(const wxHtmlTag& tag);
	297	};
	298
	299
	300	//---------------------------------------------------------------------------
	301
	302	%{
	303
	304	class wxPyHtmlTagsModule : public wxHtmlTagsModule {
	305	public:
	306	wxPyHtmlTagsModule(PyObject* thc) : wxHtmlTagsModule() {
	307	m_tagHandlerClass = thc;
	308	Py_INCREF(m_tagHandlerClass);
	309	RegisterModule(this);
	310	wxHtmlWinParser::AddModule(this);
	311	}
	312
	313	void OnExit() {
	314	wxPyBeginBlockThreads();
	315	Py_DECREF(m_tagHandlerClass);
	316	m_tagHandlerClass = NULL;
	317	for (size_t x=0; x < m_objArray.GetCount(); x++) {
	318	PyObject* obj = (PyObject*)m_objArray.Item(x);
	319	Py_DECREF(obj);
	320	}
	321	wxPyEndBlockThreads();
	322	};
	323
	324	void FillHandlersTable(wxHtmlWinParser *parser) {
	325	// Wave our magic wand... (if it works it's a miracle! ;-)
	326
	327	// First, make a new instance of the tag handler
	328	wxPyBeginBlockThreads();
	329	PyObject* arg = Py_BuildValue("()");
	330	PyObject* obj = PyInstance_New(m_tagHandlerClass, arg, NULL);
	331	Py_DECREF(arg);
	332	wxPyEndBlockThreads();
	333
	334	// now figure out where it's C++ object is...
	335	wxPyHtmlWinTagHandler* thPtr;
	336	if (SWIG_GetPtrObj(obj, (void **)&thPtr, "_wxPyHtmlWinTagHandler_p"))
	337	return;
	338
	339	// add it,
	340	parser->AddTagHandler(thPtr);
	341
	342	// and track it.
	343	m_objArray.Add(obj);
	344	}
	345
	346	private:
	347	PyObject* m_tagHandlerClass;
	348	wxArrayPtrVoid m_objArray;
	349
	350	};
	351	%}
	352
	353
	354
	355	%inline %{
	356	void wxHtmlWinParser_AddTagHandler(PyObject* tagHandlerClass) {
	357	// Dynamically create a new wxModule. Refcounts tagHandlerClass
	358	// and adds itself to the wxModules list and to the wxHtmlWinParser.
	359	new wxPyHtmlTagsModule(tagHandlerClass);
	360	}
	361	%}
	362
	363
	364	//---------------------------------------------------------------------------
	365	//---------------------------------------------------------------------------
	366
	367	class wxHtmlCell : public wxObject {
	368	public:
	369	wxHtmlCell();
	370
	371	int GetPosX();
	372	int GetPosY();
	373	int GetWidth();
	374	int GetHeight();
	375	int GetDescent();
	376	wxHtmlLinkInfo* GetLink(int x = 0, int y = 0);
	377	wxHtmlCell* GetNext();
	378	wxHtmlContainerCell* GetParent();
	379	void SetLink(const wxHtmlLinkInfo& link);
	380	void SetNext(wxHtmlCell *cell);
	381	void SetParent(wxHtmlContainerCell *p);
	382	void SetPos(int x, int y);
	383	void Layout(int w);
	384	void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2);
	385	void DrawInvisible(wxDC& dc, int x, int y);
	386	const wxHtmlCell* Find(int condition, const void* param);
	387
	388	bool AdjustPagebreak(int * pagebreak);
	389	void SetCanLiveOnPagebreak(bool can);
	390
	391	};
	392
	393
	394	class wxHtmlWordCell : public wxHtmlCell
	395	{
	396	public:
	397	wxHtmlWordCell(const wxString& word, wxDC& dc);
	398	};
	399
	400
	401	class wxHtmlContainerCell : public wxHtmlCell {
	402	public:
	403	wxHtmlContainerCell(wxHtmlContainerCell *parent);
	404
	405	void InsertCell(wxHtmlCell *cell);
	406	void SetAlignHor(int al);
	407	int GetAlignHor();
	408	void SetAlignVer(int al);
	409	int GetAlignVer();
	410	void SetIndent(int i, int what, int units = wxHTML_UNITS_PIXELS);
	411	int GetIndent(int ind);
	412	int GetIndentUnits(int ind);
	413	void SetAlign(const wxHtmlTag& tag);
	414	void SetWidthFloat(int w, int units);
	415	%name(SetWidthFloatFromTag)void SetWidthFloat(const wxHtmlTag& tag);
	416	void SetMinHeight(int h, int align = wxHTML_ALIGN_TOP);
	417	void SetBackgroundColour(const wxColour& clr);
	418	void SetBorder(const wxColour& clr1, const wxColour& clr2);
	419	wxHtmlCell* GetFirstCell();
	420	};
	421
	422
	423
	424	class wxHtmlColourCell : public wxHtmlCell {
	425	public:
	426	wxHtmlColourCell(wxColour clr, int flags = wxHTML_CLR_FOREGROUND);
	427
	428	};
	429
	430
	431	class wxHtmlFontCell : public wxHtmlCell
	432	{
	433	public:
	434	wxHtmlFontCell(wxFont *font);
	435	};
	436
	437
	438	class wxHtmlWidgetCell : public wxHtmlCell {
	439	public:
	440	wxHtmlWidgetCell(wxWindow* wnd, int w = 0);
	441
	442	};
	443
	444
	445
	446	//---------------------------------------------------------------------------
	447	//---------------------------------------------------------------------------
	448	//---------------------------------------------------------------------------
	449
	450	%{
	451	class wxPyHtmlWindow : public wxHtmlWindow {
	452	DECLARE_ABSTRACT_CLASS(wxPyHtmlWindow);
	453	public:
	454	wxPyHtmlWindow(wxWindow *parent, wxWindowID id = -1,
	455	const wxPoint& pos = wxDefaultPosition,
	456	const wxSize& size = wxDefaultSize,
	457	long style = wxHW_SCROLLBAR_AUTO,
	458	const wxString& name = "htmlWindow")
	459	: wxHtmlWindow(parent, id, pos, size, style, name) {};
	460	wxPyHtmlWindow() : wxHtmlWindow() {};
	461
	462	bool ScrollToAnchor(const wxString& anchor) {
	463	return wxHtmlWindow::ScrollToAnchor(anchor);
	464	}
	465
	466	bool HasAnchor(const wxString& anchor) {
	467	const wxHtmlCell *c = m_Cell->Find(wxHTML_COND_ISANCHOR, &anchor);
	468	return c!=NULL;
	469	}
	470
	471	void OnLinkClicked(const wxHtmlLinkInfo& link);
	472	void base_OnLinkClicked(const wxHtmlLinkInfo& link);
	473
	474	wxHtmlOpeningStatus OnOpeningURL(wxHtmlURLType type,
	475	const wxString& url,
	476	wxString *redirect) const;
	477
	478	DEC_PYCALLBACK__STRING(OnSetTitle);
	479	DEC_PYCALLBACK__CELLINTINT(OnCellMouseHover);
	480	DEC_PYCALLBACK__CELLINTINTME(OnCellClicked);
	481	// DEC_PYCALLBACK_BOOL_STRING(OnOpeningURL);
	482	PYPRIVATE;
	483	};
	484
	485	IMPLEMENT_ABSTRACT_CLASS( wxPyHtmlWindow, wxHtmlWindow );
	486	IMP_PYCALLBACK__STRING(wxPyHtmlWindow, wxHtmlWindow, OnSetTitle);
	487	IMP_PYCALLBACK__CELLINTINT(wxPyHtmlWindow, wxHtmlWindow, OnCellMouseHover);
	488	IMP_PYCALLBACK__CELLINTINTME(wxPyHtmlWindow, wxHtmlWindow, OnCellClicked);
	489	// IMP_PYCALLBACK_BOOL_STRING(wxPyHtmlWindow, wxHtmlWindow, OnOpeningURL);
	490
	491
	492	void wxPyHtmlWindow::OnLinkClicked(const wxHtmlLinkInfo& link) {
	493	bool found;
	494	wxPyBeginBlockThreads();
	495	if ((found = wxPyCBH_findCallback(m_myInst, "OnLinkClicked"))) {
	496	PyObject* obj = wxPyConstructObject((void*)&link, "wxHtmlLinkInfo", 0);
	497	wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", obj));
	498	Py_DECREF(obj);
	499	}
	500	wxPyEndBlockThreads();
	501	if (! found)
	502	wxHtmlWindow::OnLinkClicked(link);
	503	}
	504	void wxPyHtmlWindow::base_OnLinkClicked(const wxHtmlLinkInfo& link) {
	505	wxHtmlWindow::OnLinkClicked(link);
	506	}
	507
	508
	509	wxHtmlOpeningStatus wxPyHtmlWindow::OnOpeningURL(wxHtmlURLType type,
	510	const wxString& url,
	511	wxString *redirect) const {
	512	bool found;
	513	wxHtmlOpeningStatus rval;
	514	wxPyBeginBlockThreads();
	515	if ((found = wxPyCBH_findCallback(m_myInst, "OnOpeningURL"))) {
	516	PyObject* ro;
	517	ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(iO)", type, wx2PyString(url)));
	518	if (PyString_Check(ro)
	519	#if PYTHON_API_VERSION >= 1009
	520	\|\| PyUnicode_Check(ro)
	521	#endif
	522	) {
	523	*redirect = Py2wxString(ro);
	524	rval = wxHTML_REDIRECT;
	525	}
	526	else {
	527	PyObject* num = PyNumber_Int(ro);
	528	rval = (wxHtmlOpeningStatus)PyInt_AsLong(num);
	529	Py_DECREF(num);
	530	}
	531	Py_DECREF(ro);
	532	}
	533	wxPyEndBlockThreads();
	534	if (! found)
	535	rval = wxHtmlWindow::OnOpeningURL(type, url, redirect);
	536	return rval;
	537	}
	538
	539
	540	%}
	541
	542
	543
	544	%name(wxHtmlWindow) class wxPyHtmlWindow : public wxScrolledWindow {
	545	public:
	546	wxPyHtmlWindow(wxWindow *parent, int id = -1,
	547	wxPoint& pos = wxDefaultPosition,
	548	wxSize& size = wxDefaultSize,
	549	int style=wxHW_SCROLLBAR_AUTO,
	550	const wxString& name = wxPyHtmlWindowNameStr);
	551	%name(wxPreHtmlWindow)wxPyHtmlWindow();
	552
	553	bool Create(wxWindow *parent, int id = -1,
	554	wxPoint& pos = wxDefaultPosition,
	555	wxSize& size = wxDefaultSize,
	556	int style=wxHW_SCROLLBAR_AUTO,
	557	const wxString& name = wxPyHtmlWindowNameStr);
	558
	559
	560	void _setCallbackInfo(PyObject* self, PyObject* _class);
	561	%pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxHtmlWindow)"
	562	%pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
	563	%pragma(python) addtomethod = "wxPreHtmlWindow:val._setOORInfo(val)"
	564
	565	bool SetPage(const wxString& source);
	566	bool LoadPage(const wxString& location);
	567	bool AppendToPage(const wxString& source);
	568	wxString GetOpenedPage();
	569	wxString GetOpenedAnchor();
	570	wxString GetOpenedPageTitle();
	571
	572	void SetRelatedFrame(wxFrame* frame, const wxString& format);
	573	wxFrame* GetRelatedFrame();
	574	void SetRelatedStatusBar(int bar);
	575
	576	//void SetFonts(wxString normal_face, wxString fixed_face, int *LIST);
	577	%addmethods {
	578	void SetFonts(wxString normal_face, wxString fixed_face, PyObject* sizes) {
	579	int* temp = int_LIST_helper(sizes);
	580	if (temp) {
	581	self->SetFonts(normal_face, fixed_face, temp);
	582	delete [] temp;
	583	}
	584	}
	585	}
	586
	587	void SetTitle(const wxString& title);
	588	void SetBorders(int b);
	589	void ReadCustomization(wxConfigBase *cfg, wxString path = wxPyEmptyString);
	590	void WriteCustomization(wxConfigBase *cfg, wxString path = wxPyEmptyString);
	591	bool HistoryBack();
	592	bool HistoryForward();
	593	bool HistoryCanBack();
	594	bool HistoryCanForward();
	595	void HistoryClear();
	596	wxHtmlContainerCell* GetInternalRepresentation();
	597	wxHtmlWinParser* GetParser();
	598
	599	bool ScrollToAnchor(const wxString& anchor);
	600	bool HasAnchor(const wxString& anchor);
	601
	602	void base_OnLinkClicked(const wxHtmlLinkInfo& link);
	603	void base_OnSetTitle(const wxString& title);
	604	void base_OnCellMouseHover(wxHtmlCell *cell, wxCoord x, wxCoord y);
	605	void base_OnCellClicked(wxHtmlCell *cell,
	606	wxCoord x, wxCoord y,
	607	const wxMouseEvent& event);
	608	};
	609
	610	// Static methods are mapped to stand-alone functions
	611	%inline %{
	612	void wxHtmlWindow_AddFilter(wxHtmlFilter *filter) {
	613	wxHtmlWindow::AddFilter(filter);
	614	}
	615	%}
	616
	617
	618	//---------------------------------------------------------------------------
	619	//---------------------------------------------------------------------------
	620
	621
	622	class wxHtmlDCRenderer : public wxObject {
	623	public:
	624	wxHtmlDCRenderer();
	625	~wxHtmlDCRenderer();
	626
	627	void SetDC(wxDC *dc, int maxwidth);
	628	void SetSize(int width, int height);
	629	void SetHtmlText(const wxString& html,
	630	const wxString& basepath = wxPyEmptyString,
	631	bool isdir = TRUE);
	632	int Render(int x, int y, int from = 0, int dont_render = FALSE);
	633	int GetTotalHeight();
	634	// returns total height of the html document
	635	// (compare Render's return value with this)
	636	};
	637
	638	enum {
	639	wxPAGE_ODD,
	640	wxPAGE_EVEN,
	641	wxPAGE_ALL
	642	};
	643
	644
	645	class wxHtmlPrintout : public wxPyPrintout {
	646	public:
	647	wxHtmlPrintout(const wxString& title = wxPyHtmlPrintoutTitleStr);
	648	//~wxHtmlPrintout(); wxPrintPreview object takes ownership...
	649
	650	void SetHtmlText(const wxString& html,
	651	const wxString &basepath = wxPyEmptyString,
	652	bool isdir = TRUE);
	653	void SetHtmlFile(const wxString &htmlfile);
	654	void SetHeader(const wxString& header, int pg = wxPAGE_ALL);
	655	void SetFooter(const wxString& footer, int pg = wxPAGE_ALL);
	656	void SetMargins(float top = 25.2, float bottom = 25.2,
	657	float left = 25.2, float right = 25.2,
	658	float spaces = 5);
	659	};
	660
	661
	662
	663	class wxHtmlEasyPrinting : public wxObject {
	664	public:
	665	wxHtmlEasyPrinting(const wxString& name = wxPyHtmlPrintingTitleStr,
	666	wxFrame *parent_frame = NULL);
	667	~wxHtmlEasyPrinting();
	668
	669	void PreviewFile(const wxString &htmlfile);
	670	void PreviewText(const wxString &htmltext, const wxString& basepath = wxPyEmptyString);
	671	void PrintFile(const wxString &htmlfile);
	672	void PrintText(const wxString &htmltext, const wxString& basepath = wxPyEmptyString);
	673	void PrinterSetup();
	674	void PageSetup();
	675	void SetHeader(const wxString& header, int pg = wxPAGE_ALL);
	676	void SetFooter(const wxString& footer, int pg = wxPAGE_ALL);
	677
	678	wxPrintData *GetPrintData() {return m_PrintData;}
	679	wxPageSetupDialogData *GetPageSetupData() {return m_PageSetupData;}
	680
	681	};
	682
	683
	684
	685	//---------------------------------------------------------------------------
	686	//---------------------------------------------------------------------------
	687
	688	%{
	689	extern "C" SWIGEXPORT(void) inithtmlhelpc();
	690	%}
	691
	692
	693	%init %{
	694
	695	inithtmlhelpc();
	696
	697	wxClassInfo::CleanUpClasses();
	698	wxClassInfo::InitializeClasses();
	699
	700	wxPyPtrTypeMap_Add("wxHtmlTagHandler", "wxPyHtmlTagHandler");
	701	wxPyPtrTypeMap_Add("wxHtmlWinTagHandler", "wxPyHtmlWinTagHandler");
	702	wxPyPtrTypeMap_Add("wxHtmlWindow", "wxPyHtmlWindow");
	703	%}
	704
	705	//----------------------------------------------------------------------
	706	// And this gets appended to the shadow class file.
	707	//----------------------------------------------------------------------
	708
	709	%pragma(python) include="_htmlextras.py";
	710
	711	//---------------------------------------------------------------------------