This commit was manufactured by cvs2svn to create tag

'WX_HTML_BEFORE_TEXT_SELECTION'.

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/tags/WX_HTML_BEFORE_TEXT_SELECTION@20809 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

contrib/src/xrc/xh_html.cpp

@@ -0,0 +1,83 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_html.cpp
+// Purpose:     XRC resource for wxHtmlWindow
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Bob Mitchell and Verant Interactive
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+ 
+#ifdef __GNUG__
+#pragma implementation "xh_html.h"
+#endif
+
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+    #pragma hdrstop
+#endif
+
+#include "wx/xrc/xh_html.h"
+
+#if wxUSE_HTML
+
+#include "wx/html/htmlwin.h"
+#include "wx/filesys.h"
+
+
+wxHtmlWindowXmlHandler::wxHtmlWindowXmlHandler() 
+: wxXmlResourceHandler() 
+{
+    XRC_ADD_STYLE(wxHW_SCROLLBAR_NEVER);
+    XRC_ADD_STYLE(wxHW_SCROLLBAR_AUTO);
+    AddWindowStyles();
+}
+
+wxObject *wxHtmlWindowXmlHandler::DoCreateResource()
+{
+    XRC_MAKE_INSTANCE(control, wxHtmlWindow)
+
+    control->Create(m_parentAsWindow,
+                    GetID(),
+                    GetPosition(), GetSize(),
+                    GetStyle(wxT("style"), wxHW_SCROLLBAR_AUTO),
+                    GetName());
+
+    if (HasParam(wxT("borders")))
+    {
+        control->SetBorders(GetDimension(wxT("borders")));
+    }
+
+    if (HasParam(wxT("url")))
+    {
+        wxString url = GetParamValue(wxT("url"));
+        wxFileSystem& fsys = GetCurFileSystem();
+        
+        wxFSFile *f = fsys.OpenFile(url);
+        if (f)
+        {
+            control->LoadPage(f->GetLocation());
+            delete f;
+        }
+        else
+            control->LoadPage(url);
+    }
+    
+    else if (HasParam(wxT("htmlcode")))
+    {
+        control->SetPage(GetText(wxT("htmlcode")));
+    }
+
+    SetupWindow(control);
+    
+    return control;
+}
+
+bool wxHtmlWindowXmlHandler::CanHandle(wxXmlNode *node)
+{
+    return IsOfClass(node, wxT("wxHtmlWindow"));
+}
+
+#endif // wxUSE_HTML

docs/latex/wx/htcell.tex

@@ -0,0 +1,262 @@
+%
+% automatically generated by HelpGen from
+% htmlcell.tex at 21/Mar/99 22:45:23
+%
+
+\section{\class{wxHtmlCell}}\label{wxhtmlcell}
+
+Internal data structure. It represents fragments of parsed HTML
+page, the so-called {\bf cell} - a word, picture, table, horizontal line and so on.
+It is used by \helpref{wxHtmlWindow}{wxhtmlwindow} and 
+\helpref{wxHtmlWinParser}{wxhtmlwinparser} to represent HTML page in memory.
+
+You can divide cells into two groups : {\it visible} cells with non-zero width and
+height and {\it helper} cells (usually with zero width and height) that
+perform special actions such as color or font change.
+
+\wxheading{Derived from}
+
+\helpref{wxObject}{wxobject}
+
+\wxheading{Include files}
+
+<wx/html/htmlcell.h>
+
+\wxheading{See Also}
+
+\helpref{Cells Overview}{cells},
+\helpref{wxHtmlContainerCell}{wxhtmlcontainercell}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxHtmlCell::wxHtmlCell}\label{wxhtmlcellwxhtmlcell}
+
+\func{}{wxHtmlCell}{\void}
+
+Constructor.
+
+\membersection{wxHtmlCell::AdjustPagebreak}\label{wxhtmlcelladjustpagebreak}
+
+\func{virtual bool}{AdjustPagebreak}{\param{int * }{pagebreak}}
+
+This method is used to adjust pagebreak position. The parameter is
+variable that contains y-coordinate of page break (= horizontal line that
+should not be crossed by words, images etc.). If this cell cannot be divided
+into two pieces (each one on another page) then it moves the pagebreak
+few pixels up.
+
+Returns true if pagebreak was modified, false otherwise
+
+Usage: 
+\begin{verbatim}
+while (container->AdjustPagebreak(&p)) {}
+\end{verbatim}
+
+\membersection{wxHtmlCell::Draw}\label{wxhtmlcelldraw}
+
+\func{virtual void}{Draw}{\param{wxDC\& }{dc}, \param{int }{x}, \param{int }{y}, \param{int }{view\_y1}, \param{int }{view\_y2}}
+
+Renders the cell.
+
+\wxheading{Parameters}
+
+\docparam{dc}{Device context to which the cell is to be drawn}
+
+\docparam{x,y}{Coordinates of parent's upper left corner (origin). You must
+add this to m\_PosX,m\_PosY when passing coordinates to dc's methods
+Example : {\tt dc -> DrawText("hello", x + m\_PosX, y + m\_PosY)}}
+
+\docparam{view\_y1}{y-coord of the first line visible in window. This is
+used to optimize rendering speed}
+
+\docparam{view\_y2}{y-coord of the last line visible in window. This is
+used to optimize rendering speed}
+
+\membersection{wxHtmlCell::DrawInvisible}\label{wxhtmlcelldrawinvisible}
+
+\func{virtual void}{DrawInvisible}{\param{wxDC\& }{dc}, \param{int }{x}, \param{int }{y}}
+
+This method is called instead of \helpref{Draw}{wxhtmlcelldraw} when the
+cell is certainly out of the screen (and thus invisible). This is not
+nonsense - some tags (like \helpref{wxHtmlColourCell}{wxhtmlcolourcell}
+or font setter) must be drawn even if they are invisible!
+
+\wxheading{Parameters}
+
+\docparam{dc}{Device context to which the cell is to be drawn}
+
+\docparam{x,y}{Coordinates of parent's upper left corner. You must
+add this to m\_PosX,m\_PosY when passing coordinates to dc's methods
+Example : {\tt dc -> DrawText("hello", x + m\_PosX, y + m\_PosY)}}
+
+\membersection{wxHtmlCell::Find}\label{wxhtmlcellfind}
+
+\func{virtual const wxHtmlCell*}{Find}{\param{int }{condition}, \param{const void* }{param}}
+
+Returns pointer to itself if this cell matches condition (or if any of the cells
+following in the list matches), NULL otherwise.
+(In other words if you call top-level container's Find it will
+return pointer to the first cell that matches the condition)
+
+It is recommended way how to obtain pointer to particular cell or
+to cell of some type (e.g. wxHtmlAnchorCell reacts on
+wxHTML\_COND\_ISANCHOR condition)
+
+\wxheading{Parameters}
+
+\docparam{condition}{Unique integer identifier of condition}
+
+\docparam{param}{Optional parameters}
+
+\wxheading{Defined conditions}
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf wxHTML\_COND\_ISANCHOR}}{Finds particular anchor. 
+{\it param} is pointer to wxString with name of the anchor.}
+\twocolitem{{\bf wxHTML\_COND\_USER}}{User-defined conditions start
+from this number.}
+\end{twocollist}
+
+\membersection{wxHtmlCell::GetDescent}\label{wxhtmlcellgetdescent}
+
+\constfunc{int}{GetDescent}{\void}
+
+Returns descent value of the cell (m\_Descent member). 
+\helponly{See explanation:
+
+\image{}{descent.bmp}
+}
+
+\membersection{wxHtmlCell::GetHeight}\label{wxhtmlcellgetheight}
+
+\constfunc{int}{GetHeight}{\void}
+
+Returns height of the cell (m\_Height member).
+
+\membersection{wxHtmlCell::GetId}\label{wxhtmlcellgetid}
+
+\constfunc{virtual wxString}{GetId}{\void}
+
+Returns unique cell identifier if there is any, empty string otherwise.
+
+\membersection{wxHtmlCell::GetLink}\label{wxhtmlcellgetlink}
+
+\constfunc{virtual wxHtmlLinkInfo*}{GetLink}{\param{int }{x = 0}, \param{int }{y = 0}}
+
+Returns hypertext link if associated with this cell or NULL otherwise.
+See \helpref{wxHtmlLinkInfo}{wxhtmllinkinfo}.
+(Note: this makes sense only for visible tags).
+
+\wxheading{Parameters}
+
+\docparam{x,y}{Coordinates of position where the user pressed mouse button.
+These coordinates are used e.g. by COLORMAP. Values are relative to the
+upper left corner of THIS cell (i.e. from 0 to m\_Width or m\_Height)}
+
+\membersection{wxHtmlCell::GetNext}\label{wxhtmlcellgetnext}
+
+\constfunc{wxHtmlCell*}{GetNext}{\void}
+
+Returns pointer to the next cell in list (see htmlcell.h if you're
+interested in details).
+
+\membersection{wxHtmlCell::GetParent}\label{wxhtmlcellgetparent}
+
+\constfunc{wxHtmlContainerCell*}{GetParent}{\void}
+
+Returns pointer to parent container.
+
+\membersection{wxHtmlCell::GetPosX}\label{wxhtmlcellgetposx}
+
+\constfunc{int}{GetPosX}{\void}
+
+Returns X position within parent (the value is relative to parent's
+upper left corner). The returned value is meaningful only if
+parent's \helpref{Layout}{wxhtmlcelllayout} was called before!
+
+\membersection{wxHtmlCell::GetPosY}\label{wxhtmlcellgetposy}
+
+\constfunc{int}{GetPosY}{\void}
+
+Returns Y position within parent (the value is relative to parent's
+upper left corner). The returned value is meaningful only if
+parent's \helpref{Layout}{wxhtmlcelllayout} was called before!
+
+\membersection{wxHtmlCell::GetWidth}\label{wxhtmlcellgetwidth}
+
+\constfunc{int}{GetWidth}{\void}
+
+Returns width of the cell (m\_Width member).
+
+\membersection{wxHtmlCell::Layout}\label{wxhtmlcelllayout}
+
+\func{virtual void}{Layout}{\param{int }{w}}
+
+This method performs two actions:
+
+\begin{enumerate}\itemsep=0pt
+\item adjusts the cell's width according to the fact that maximal possible width is {\it w}.
+(this has sense when working with horizontal lines, tables etc.)
+\item prepares layout (=fill-in m\_PosX, m\_PosY (and sometimes m\_Height) members)
+based on actual width {\it w}
+\end{enumerate}
+
+It must be called before displaying cells structure because
+m\_PosX and m\_PosY are undefined (or invalid)
+before calling Layout.
+
+\membersection{wxHtmlCell::OnMouseClick}\label{wxhtmlcellonmouseclick}
+
+\func{virtual void}{OnMouseClick}{\param{wxWindow* }{parent}, \param{int}{x}, \param{int }{y}, \param{const wxMouseEvent\& }{event}}
+
+This function is simple event handler. Each time the user clicks mouse button over a cell
+within \helpref{wxHtmlWindow}{wxhtmlwindow} this method of that cell is called. Default behavior is
+that it calls \helpref{wxHtmlWindow::LoadPage}{wxhtmlwindowloadpage}.
+
+\wxheading{Note}
+
+If you need more "advanced" event handling
+you should use wxHtmlBinderCell instead.
+
+\wxheading{Parameters}
+
+\docparam{parent}{parent window (always wxHtmlWindow!)}
+
+\docparam{x, y}{coordinates of mouse click (this is relative to cell's origin}
+
+\docparam{left, middle, right}{boolean flags for mouse buttons. true if the left/middle/right
+button is pressed, false otherwise}
+
+\membersection{wxHtmlCell::SetId}\label{wxhtmlcellsetid}
+
+\func{void}{SetId}{\param{const wxString\& }{id}}
+
+Sets unique cell identifier. Default value is no identifier, i.e. empty string.
+
+\membersection{wxHtmlCell::SetLink}\label{wxhtmlcellsetlink}
+
+\func{void}{SetLink}{\param{const wxHtmlLinkInfo\& }{link}}
+
+Sets the hypertext link associated with this cell. (Default value
+is \helpref{wxHtmlLinkInfo}{wxhtmllinkinfo}("", "") (no link))
+
+\membersection{wxHtmlCell::SetNext}\label{wxhtmlcellsetnext}
+
+\func{void}{SetNext}{\param{wxHtmlCell }{*cell}}
+
+Sets the next cell in the list. This shouldn't be called by user - it is
+to be used only by \helpref{wxHtmlContainerCell::InsertCell}{wxhtmlcontainercellinsertcell}.
+
+\membersection{wxHtmlCell::SetParent}\label{wxhtmlcellsetparent}
+
+\func{void}{SetParent}{\param{wxHtmlContainerCell }{*p}}
+
+Sets parent container of this cell. This is called from
+\helpref{wxHtmlContainerCell::InsertCell}{wxhtmlcontainercellinsertcell}.
+
+\membersection{wxHtmlCell::SetPos}\label{wxhtmlcellsetpos}
+
+\func{void}{SetPos}{\param{int }{x}, \param{int }{y}}
+
+Sets the cell's position within parent container.
+

docs/latex/wx/htcolor.tex

@@ -0,0 +1,37 @@
+%
+% automatically generated by HelpGen from
+% htmlcolourcell.tex at 14/Mar/99 20:13:37
+%
+
+\section{\class{wxHtmlColourCell}}\label{wxhtmlcolourcell}
+
+This cell changes the colour of either the background or the foreground. 
+
+\wxheading{Derived from}
+
+\helpref{wxHtmlCell}{wxhtmlcell}
+
+\wxheading{Include files}
+
+<wx/html/htmlcell.h>
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxHtmlColourCell::wxHtmlColourCell}\label{wxhtmlcolourcellwxhtmlcolourcell}
+
+\func{}{wxHtmlColourCell}{\param{wxColour }{clr}, \param{int }{flags = wxHTML\_CLR\_FOREGROUND}}
+
+Constructor.
+
+\wxheading{Parameters}
+
+\docparam{clr}{The color}
+
+\docparam{flags}{Can be one of following:
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf wxHTML\_CLR\_FOREGROUND}}{change color of text}
+\twocolitem{{\bf wxHTML\_CLR\_BACKGROUND}}{change background color}
+\end{twocollist}
+}
+

docs/latex/wx/htcontnr.tex

@@ -0,0 +1,250 @@
+%
+% automatically generated by HelpGen from
+% htmlcontainercell.tex at 21/Mar/99 22:45:23
+%
+
+\section{\class{wxHtmlContainerCell}}\label{wxhtmlcontainercell}
+
+The wxHtmlContainerCell class is an implementation of a cell that may
+contain more cells in it. It is heavily used in the wxHTML layout algorithm.
+
+\wxheading{Derived from}
+
+\helpref{wxHtmlCell}{wxhtmlcell}
+
+\wxheading{Include files}
+
+<wx/html/htmlcell.h>
+
+\wxheading{See Also}
+
+\helpref{Cells Overview}{cells}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxHtmlContainerCell::wxHtmlContainerCell}\label{wxhtmlcontainercellwxhtmlcontainercell}
+
+\func{}{wxHtmlContainerCell}{\param{wxHtmlContainerCell }{*parent}}
+
+Constructor. {\it parent} is pointer to parent container or NULL.
+
+
+\membersection{wxHtmlContainerCell::GetAlignHor}\label{wxhtmlcontainercellgetalignhor}
+
+\constfunc{int}{GetAlignHor}{\void}
+
+Returns container's horizontal alignment.
+
+\membersection{wxHtmlContainerCell::GetAlignVer}\label{wxhtmlcontainercellgetalignver}
+
+\constfunc{int}{GetAlignVer}{\void}
+
+Returns container's vertical alignment.
+
+\membersection{wxHtmlContainerCell::GetBackgroundColour}\label{wxhtmlcontainercellgetbackgroundcolour}
+
+\func{wxColour}{GetBackgroundColour}{\void}
+
+Returns the background colour of the container or {\tt wxNullColour} if no background
+colour is set.
+
+\membersection{wxHtmlContainerCell::GetFirstCell}\label{wxhtmlcontainercellgetfirstcell}
+
+\func{wxHtmlCell*}{GetFirstCell}{\void}
+
+Returns pointer to the first cell in the list.
+You can then use wxHtmlCell's GetNext method to obtain pointer to the next
+cell in list.
+
+{\bf Note:} This shouldn't be used by the end user. If you need some way of
+finding particular cell in the list, try \helpref{Find}{wxhtmlcellfind} method
+instead.
+
+\membersection{wxHtmlContainerCell::GetIndent}\label{wxhtmlcontainercellgetindent}
+
+\constfunc{int}{GetIndent}{\param{int }{ind}}
+
+Returns the indentation. {\it ind} is one of the {\bf wxHTML\_INDENT\_*} constants.
+
+{\bf Note:} You must call \helpref{GetIndentUnits}{wxhtmlcontainercellgetindentunits} 
+with same {\it ind} parameter in order to correctly interpret the returned integer value.
+It is NOT always in pixels!
+
+\membersection{wxHtmlContainerCell::GetIndentUnits}\label{wxhtmlcontainercellgetindentunits}
+
+\constfunc{int}{GetIndentUnits}{\param{int }{ind}}
+
+Returns the units of indentation for {\it ind} where {\it ind} is one
+of the {\bf wxHTML\_INDENT\_*} constants.
+
+\membersection{wxHtmlContainerCell::InsertCell}\label{wxhtmlcontainercellinsertcell}
+
+\func{void}{InsertCell}{\param{wxHtmlCell }{*cell}}
+
+Inserts new cell into the container.
+
+\membersection{wxHtmlContainerCell::SetAlign}\label{wxhtmlcontainercellsetalign}
+
+\func{void}{SetAlign}{\param{const wxHtmlTag\& }{tag}}
+
+Sets the container's alignment (both horizontal and vertical) according to
+the values stored in {\it tag}. (Tags {\tt ALIGN} parameter is extracted.) In fact
+it is only a front-end to \helpref{SetAlignHor}{wxhtmlcontainercellsetalignhor} 
+and \helpref{SetAlignVer}{wxhtmlcontainercellsetalignver}.
+
+\membersection{wxHtmlContainerCell::SetAlignHor}\label{wxhtmlcontainercellsetalignhor}
+
+\func{void}{SetAlignHor}{\param{int }{al}}
+
+Sets the container's {\it horizontal alignment}. During \helpref{Layout}{wxhtmlcelllayout} 
+each line is aligned according to {\it al} value.
+
+\wxheading{Parameters}
+
+\docparam{al}{new horizontal alignment. May be one of these values:
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf wxHTML\_ALIGN\_LEFT}}{lines are left-aligned (default)}
+\twocolitem{{\bf wxHTML\_ALIGN\_JUSTIFY}}{lines are justified}
+\twocolitem{{\bf wxHTML\_ALIGN\_CENTER}}{lines are centered}
+\twocolitem{{\bf wxHTML\_ALIGN\_RIGHT}}{lines are right-aligned}
+\end{twocollist}
+}
+
+\membersection{wxHtmlContainerCell::SetAlignVer}\label{wxhtmlcontainercellsetalignver}
+
+\func{void}{SetAlignVer}{\param{int }{al}}
+
+Sets the container's {\it vertical alignment}. This is per-line alignment!
+
+\wxheading{Parameters}
+
+\docparam{al}{new vertical alignment. May be one of these values:
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf wxHTML\_ALIGN\_BOTTOM}}{cells are over the line (default)}
+\twocolitem{{\bf wxHTML\_ALIGN\_CENTER}}{cells are centered on line}
+\twocolitem{{\bf wxHTML\_ALIGN\_TOP}}{cells are under the line}
+\end{twocollist}
+
+\helponly{\image{}{alignv.bmp}}
+}
+
+\membersection{wxHtmlContainerCell::SetBackgroundColour}\label{wxhtmlcontainercellsetbackgroundcolour}
+
+\func{void}{SetBackgroundColour}{\param{const wxColour\& }{clr}}
+
+Sets the background colour for this container.
+
+\membersection{wxHtmlContainerCell::SetBorder}\label{wxhtmlcontainercellsetborder}
+
+\func{void}{SetBorder}{\param{const wxColour\& }{clr1}, \param{const wxColour\& }{clr2}}
+
+Sets the border (frame) colours. A border is a rectangle around the container.
+
+\wxheading{Parameters}
+
+\docparam{clr1}{Colour of top and left lines}
+
+\docparam{clr2}{Colour of bottom and right lines}
+
+\membersection{wxHtmlContainerCell::SetIndent}\label{wxhtmlcontainercellsetindent}
+
+\func{void}{SetIndent}{\param{int }{i}, \param{int }{what}, \param{int }{units = wxHTML\_UNITS\_PIXELS}}
+
+Sets the indentation (free space between borders of container and subcells).
+
+\wxheading{Parameters}
+
+\docparam{i}{Indentation value.}
+
+\docparam{what}{Determines which of the four borders we're setting. It is OR
+combination of following constants:
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf wxHTML\_INDENT\_TOP}}{top border}
+\twocolitem{{\bf wxHTML\_INDENT\_BOTTOM}}{bottom}
+\twocolitem{{\bf wxHTML\_INDENT\_LEFT}}{left}
+\twocolitem{{\bf wxHTML\_INDENT\_RIGHT}}{right}
+\twocolitem{{\bf wxHTML\_INDENT\_HORIZONTAL}}{left and right}
+\twocolitem{{\bf wxHTML\_INDENT\_VERTICAL}}{top and bottom}
+\twocolitem{{\bf wxHTML\_INDENT\_ALL}}{all 4 borders}
+\end{twocollist}
+
+\helponly{\image{}{indent.bmp}}
+}
+
+\docparam{units}{Units of {\it i}. This parameter affects interpretation of {\it} value.
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf wxHTML\_UNITS\_PIXELS}}{{\it i} is number of pixels}
+\twocolitem{{\bf wxHTML\_UNITS\_PERCENT}}{{\it i} is interpreted as percents of width
+of parent container}
+\end{twocollist}
+}
+
+\membersection{wxHtmlContainerCell::SetMinHeight}\label{wxhtmlcontainercellsetminheight}
+
+\func{void}{SetMinHeight}{\param{int }{h}, \param{int }{align = wxHTML\_ALIGN\_TOP}}
+
+Sets minimal height of the container.
+
+When container's \helpref{Layout}{wxhtmlcelllayout} is called, m\_Height
+is set depending on layout of subcells to the height of area covered
+by layed-out subcells. Calling this method guarantees you that the height
+of container is never smaller than {\it h} - even if the subcells cover
+much smaller area.
+
+\wxheading{Parameters}
+
+\docparam{h}{The minimal height.}
+
+\docparam{align}{If height of the container is lower than the minimum height, empty space must be inserted
+somewhere in order to ensure minimal height. This parameter is one of {\bf wxHTML\_ALIGN\_TOP,
+wxHTML\_ALIGN\_BOTTOM, wxHTML\_ALIGN\_CENTER}. It refers to the {\it contents}, not to the
+empty place.}
+
+\membersection{wxHtmlContainerCell::SetWidthFloat}\label{wxhtmlcontainercellsetwidthfloat}
+
+\func{void}{SetWidthFloat}{\param{int }{w}, \param{int }{units}}
+
+\func{void}{SetWidthFloat}{\param{const wxHtmlTag\& }{tag}, \param{double }{pixel\_scale = 1.0}}
+
+Sets floating width adjustment.
+
+The normal behaviour of container is that its width is the same as the width of
+parent container (and thus you can have only one sub-container per line).
+You can change this by setting FWA.
+
+{\it pixel\_scale} is number of real pixels that equals to 1 HTML pixel.
+
+\wxheading{Parameters}
+
+\docparam{w}{Width of the container. If the value is negative it means
+complement to full width of parent container (e.g.
+{\tt SetWidthFloat(-50, wxHTML\_UNITS\_PIXELS)} sets the width
+of container to parent's width minus 50 pixels. This is useful when
+creating tables - you can call SetWidthFloat(50) and SetWidthFloat(-50))}
+
+\docparam{units}{Units of {\it w} This parameter affects the interpretation of {\it} value.
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf wxHTML\_UNITS\_PIXELS}}{{\it w} is number of pixels}
+\twocolitem{{\bf wxHTML\_UNITS\_PERCENT}}{{\it w} is interpreted as percents of width
+of parent container}
+\end{twocollist}
+}
+
+\docparam{tag}{In the second version of method, {\it w} and {\it units}
+info is extracted from tag's {\tt WIDTH} parameter.}
+
+\pythonnote{The second form of this method is named
+SetWidthFloatFromTag in wxPython.}
+
+
+
+
+
+
+
+

docs/latex/wx/htdcrend.tex

@@ -0,0 +1,111 @@
+%
+% automatically generated by HelpGen from
+% htmprint.h at 17/Oct/99 12:48:02
+%
+
+\section{\class{wxHtmlDCRenderer}}\label{wxhtmldcrenderer}
+
+This class can render HTML document into a specified area of a DC. You can use it
+in your own printing code, although use of \helpref{wxHtmlEasyPrinting}{wxhtmleasyprinting} 
+or \helpref{wxHtmlPrintout}{wxhtmlprintout} is strongly recommended.
+
+\wxheading{Derived from}
+
+\helpref{wxObject}{wxobject}
+
+\wxheading{Include files}
+
+<wx/html/htmprint.h>
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxHtmlDCRenderer::wxHtmlDCRenderer}\label{wxhtmldcrendererwxhtmldcrenderer}
+
+\func{}{wxHtmlDCRenderer}{\void}
+
+Constructor.
+
+\membersection{wxHtmlDCRenderer::SetDC}\label{wxhtmldcrenderersetdc}
+
+\func{void}{SetDC}{\param{wxDC* }{dc}, \param{double }{pixel\_scale = 1.0}}
+
+Assign DC instance to the renderer.
+
+{\it pixel\_scale} can be used when rendering to high-resolution DCs (e.g. printer) to adjust size of pixel metrics.
+(Many dimensions in HTML are given in pixels -- e.g. image sizes. 300x300 image would be only one
+inch wide on typical printer. With pixel\_scale = 3.0 it would be 3 inches.)
+
+\membersection{wxHtmlDCRenderer::SetFonts}\label{wxhtmldcrenderersetfonts}
+
+\func{void}{SetFonts}{\param{wxString }{normal\_face}, \param{wxString }{fixed\_face}, \param{const int }{*sizes = NULL}}
+
+Sets fonts. See \helpref{wxHtmlWindow::SetFonts}{wxhtmlwindowsetfonts} for
+detailed description.
+
+See also \helpref{SetSize}{wxhtmldcrenderersetsize}.
+
+\membersection{wxHtmlDCRenderer::SetSize}\label{wxhtmldcrenderersetsize}
+
+\func{void}{SetSize}{\param{int }{width}, \param{int }{height}}
+
+Set size of output rectangle, in pixels. Note that you {\bf can't} change
+width of the rectangle between calls to \helpref{Render}{wxhtmldcrendererrender}!
+(You can freely change height.)
+
+\membersection{wxHtmlDCRenderer::SetHtmlText}\label{wxhtmldcrenderersethtmltext}
+
+\func{void}{SetHtmlText}{\param{const wxString\& }{html}, \param{const wxString\& }{basepath = wxEmptyString}, \param{bool }{isdir = true}}
+
+Assign text to the renderer. \helpref{Render}{wxhtmldcrendererrender} then draws 
+the text onto DC.
+
+\wxheading{Parameters}
+
+\docparam{html}{HTML text. This is {\it not} a filename.}
+
+\docparam{basepath}{base directory (html string would be stored there if it was in
+file). It is used to determine path for loading images, for example.}
+
+\docparam{isdir}{false if basepath is filename, true if it is directory name
+(see \helpref{wxFileSystem}{wxfilesystem} for detailed explanation)}
+
+\membersection{wxHtmlDCRenderer::Render}\label{wxhtmldcrendererrender}
+
+\func{int}{Render}{\param{int }{x}, \param{int }{y}, \param{int }{from = 0}, \param{int }{dont\_render = false}}
+
+Renders HTML text to the DC.
+
+\wxheading{Parameters}
+
+\docparam{x,y}{ position of upper-left corner of printing rectangle (see \helpref{SetSize}{wxhtmldcrenderersetsize})}
+
+\docparam{from}{y-coordinate of the very first visible cell}
+
+\docparam{dont\_render}{if true then this method only returns y coordinate of the next page
+and does not output anything}
+
+Returned value is y coordinate of first cell than didn't fit onto page.
+Use this value as {\it from} in next call to Render in order to print multipages
+document.
+
+\wxheading{Caution!}
+
+The Following three methods {\bf must} always be called before any call to Render (preferably
+in this order):
+
+\begin{itemize}\itemsep=0pt
+\item \helpref{SetDC}{wxhtmldcrenderersetdc}
+\item \helpref{SetSize}{wxhtmldcrenderersetsize}
+\item \helpref{SetHtmlText}{wxhtmldcrenderersethtmltext}
+\end{itemize}
+
+{\bf Render() changes the DC's user scale and does NOT restore it.}
+
+\membersection{wxHtmlDCRenderer::GetTotalHeight}\label{wxhtmldcrenderergettotalheight}
+
+\func{int}{GetTotalHeight}{\void}
+
+Returns the height of the HTML text. This is important if area height (see \helpref{SetSize}{wxhtmldcrenderersetsize})
+is smaller that total height and thus the page cannot fit into it. In that case you're supposed to
+call \helpref{Render}{wxhtmldcrendererrender} as long as its return value is smaller than GetTotalHeight's.
+

docs/latex/wx/hteasypr.tex

@@ -0,0 +1,164 @@
+%
+% automatically generated by HelpGen from
+% htmprint.h at 17/Oct/99 12:48:02
+%
+
+\section{\class{wxHtmlEasyPrinting}}\label{wxhtmleasyprinting}
+
+This class provides very simple interface to printing 
+architecture. It allows you to print HTML documents using
+only a few commands. 
+
+\wxheading{Note}
+
+Do not create this class on the stack only. You should create an instance on app 
+startup and use this instance for all printing operations. The reason is that
+this class stores various settings in it.
+
+\wxheading{Derived from}
+
+\helpref{wxObject}{wxobject}
+
+\wxheading{Include files}
+
+<wx/html/htmprint.h>
+
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxHtmlEasyPrinting::wxHtmlEasyPrinting}\label{wxhtmleasyprintingwxhtmleasyprinting}
+
+\func{}{wxHtmlEasyPrinting}{\param{const wxString\& }{name = "Printing"}, \param{wxWindow* }{parentWindow = NULL}}
+
+Constructor.
+
+\wxheading{Parameters}
+
+\docparam{name}{Name of the printing object. Used by preview frames and setup dialogs.}
+
+\docparam{parentWindow}{pointer to the window that will own the preview frame and setup dialogs. May be NULL.}
+
+\membersection{wxHtmlEasyPrinting::PreviewFile}\label{wxhtmleasyprintingpreviewfile}
+
+\func{bool}{PreviewFile}{\param{const wxString\& }{htmlfile}}
+
+Preview HTML file. 
+
+Returns false in case of error -- call
+\helpref{wxPrinter::GetLastError}{wxprintergetlasterror} to get detailed
+information about the kind of the error.
+
+
+\membersection{wxHtmlEasyPrinting::PreviewText}\label{wxhtmleasyprintingpreviewtext}
+
+\func{bool}{PreviewText}{\param{const wxString\& }{htmltext}, \param{const wxString\& }{basepath = wxEmptyString}}
+
+Preview HTML text (not file!). 
+
+Returns false in case of error -- call
+\helpref{wxPrinter::GetLastError}{wxprintergetlasterror} to get detailed
+information about the kind of the error.
+
+\wxheading{Parameters}
+
+\docparam{htmltext}{HTML text.}
+
+\docparam{basepath}{base directory (html string would be stored there if it was in
+file). It is used to determine path for loading images, for example.}
+
+\membersection{wxHtmlEasyPrinting::PrintFile}\label{wxhtmleasyprintingprintfile}
+
+\func{bool}{PrintFile}{\param{const wxString\& }{htmlfile}}
+
+Print HTML file.
+
+Returns false in case of error -- call
+\helpref{wxPrinter::GetLastError}{wxprintergetlasterror} to get detailed
+information about the kind of the error.
+
+\membersection{wxHtmlEasyPrinting::PrintText}\label{wxhtmleasyprintingprinttext}
+
+\func{bool}{PrintText}{\param{const wxString\& }{htmltext}, \param{const wxString\& }{basepath = wxEmptyString}}
+
+Print HTML text (not file!). 
+
+Returns false in case of error -- call
+\helpref{wxPrinter::GetLastError}{wxprintergetlasterror} to get detailed
+information about the kind of the error.
+
+\wxheading{Parameters}
+
+\docparam{htmltext}{HTML text.}
+
+\docparam{basepath}{base directory (html string would be stored there if it was in
+file). It is used to determine path for loading images, for example.}
+
+\membersection{wxHtmlEasyPrinting::PrinterSetup}\label{wxhtmleasyprintingprintersetup}
+
+\func{void}{PrinterSetup}{\void}
+
+Display printer setup dialog and allows the user to modify settings. 
+
+\membersection{wxHtmlEasyPrinting::PageSetup}\label{wxhtmleasyprintingpagesetup}
+
+\func{void}{PageSetup}{\void}
+
+Display page setup dialog and allows the user to modify settings. 
+
+\membersection{wxHtmlEasyPrinting::SetFonts}\label{wxhtmleasyprintingsetfonts}
+
+\func{void}{SetFonts}{\param{wxString }{normal\_face}, \param{wxString }{fixed\_face}, \param{const int }{*sizes = NULL}}
+
+Sets fonts. See \helpref{wxHtmlWindow::SetFonts}{wxhtmlwindowsetfonts} for
+detailed description.
+
+\membersection{wxHtmlEasyPrinting::SetHeader}\label{wxhtmleasyprintingsetheader}
+
+\func{void}{SetHeader}{\param{const wxString\& }{header}, \param{int }{pg = wxPAGE\_ALL}}
+
+Set page header.
+
+\wxheading{Parameters}
+
+\docparam{header}{HTML text to be used as header. You can use macros in it:
+
+\begin{itemize}\itemsep=0pt
+\item @PAGENUM@ is replaced by page number
+\item @PAGESCNT@ is replaced by total number of pages
+\end{itemize}
+}
+
+\docparam{pg}{one of wxPAGE\_ODD, wxPAGE\_EVEN and wxPAGE\_ALL constants.}
+
+\membersection{wxHtmlEasyPrinting::SetFooter}\label{wxhtmleasyprintingsetfooter}
+
+\func{void}{SetFooter}{\param{const wxString\& }{footer}, \param{int }{pg = wxPAGE\_ALL}}
+
+Set page footer.
+
+\wxheading{Parameters}
+
+\docparam{footer}{HTML text to be used as footer. You can use macros in it:
+
+\begin{itemize}\itemsep=0pt
+\item @PAGENUM@ is replaced by page number
+\item @PAGESCNT@ is replaced by total number of pages
+\end{itemize}
+}
+
+\docparam{pg}{one of wxPAGE\_ODD, wxPAGE\_EVEN and wxPAGE\_ALL constants.}
+
+\membersection{wxHtmlEasyPrinting::GetPrintData}\label{wxhtmleasyprintinggetprintdata}
+
+\func{wxPrintData*}{GetPrintData}{\void}
+
+Returns pointer to \helpref{wxPrintData}{wxprintdata} instance used by this class. You can
+set its parameters (via SetXXXX methods).
+
+\membersection{wxHtmlEasyPrinting::GetPageSetupData}\label{wxhtmleasyprintinggetpagesetupdata}
+
+\func{wxPageSetupDialogData*}{GetPageSetupData}{\void}
+
+Returns a pointer to \helpref{wxPageSetupDialogData}{wxpagesetupdialogdata} instance used by 
+this class. You can set its parameters (via SetXXXX methods).
+

docs/latex/wx/htfilter.tex

@@ -0,0 +1,63 @@
+%
+% automatically generated by HelpGen from
+% htmlfilter.tex at 29/Mar/99 18:35:09
+%
+
+\section{\class{wxHtmlFilter}}\label{wxhtmlfilter}
+
+This class is an input filter for \helpref{wxHtmlWindow}{wxhtmlwindow}.
+It allows you to read and display files of different file formats.
+
+\wxheading{Derived from}
+
+\helpref{wxObject}{wxobject}
+
+\wxheading{Include files}
+
+<wx/html/htmlfilt.h>
+
+
+\wxheading{See Also}
+
+\helpref{Overview}{filters}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxHtmlFilter::wxHtmlFilter}\label{wxhtmlfilterwxhtmlfilter}
+
+\func{}{wxHtmlFilter}{\void}
+
+Constructor.
+
+\membersection{wxHtmlFilter::CanRead}\label{wxhtmlfiltercanread}
+
+\func{bool}{CanRead}{\param{const wxFSFile\& }{file}}
+
+Returns true if this filter is capable of reading file {\it file}.
+
+Example:
+
+\begin{verbatim}
+bool MyFilter::CanRead(const wxFSFile& file)
+{
+    return (file.GetMimeType() == "application/x-ugh");
+}
+\end{verbatim}
+
+\membersection{wxHtmlFilter::ReadFile}\label{wxhtmlfilterreadfile}
+
+\func{wxString}{ReadFile}{\param{const wxFSFile\& }{file}}
+
+Reads the file and returns string with HTML document.
+
+Example:
+
+\begin{verbatim}
+wxString MyImgFilter::ReadFile(const wxFSFile& file)
+{
+    return "<html><body><img src=\"" +
+           file.GetLocation() +
+	   "\"></body></html>";
+}
+\end{verbatim}
+

docs/latex/wx/hthelpct.tex

@@ -0,0 +1,221 @@
+%
+% automatically generated by HelpGen from
+% htmlhelp.h at 02/May/99 19:58:53
+%
+
+\section{\class{wxHtmlHelpController}}\label{wxhtmlhelpcontroller}
+
+{\bf WARNING!} Although this class has an API compatible with other wxWindows
+help controllers as documented by \helpref{wxHelpController}{wxhelpcontroller}, it
+is recommended that you use the enhanced capabilities of wxHtmlHelpController's API.
+
+This help controller provides an easy way of displaying HTML help in your
+application (see {\it test} sample). The help system is based on {\bf books} 
+(see \helpref{AddBook}{wxhtmlhelpcontrolleraddbook}). A book is a logical
+section of documentation (for example "User's Guide" or "Programmer's Guide" or
+"C++ Reference" or "wxWindows Reference"). The help controller can handle as
+many books as you want.
+
+wxHTML uses Microsoft's HTML Help Workshop project files (.hhp, .hhk, .hhc) as its
+native format. The file format is described \helpref{here}{helpformat}.
+Have a look at docs/html/ directory where sample project files are stored.
+
+You can use Tex2RTF to produce these files when generating HTML, if you set {\bf htmlWorkshopFiles} to {\bf true} in
+your tex2rtf.ini file.
+
+\wxheading{Note}
+
+It is strongly recommended to use preprocessed {\bf .hhp.cached} version of
+projects. It can be either created on-the-fly (see 
+\helpref{SetTempDir}{wxhtmlhelpcontrollersettempdir}) or you can use 
+{\bf hhp2cached} utility from {\it utils/hhp2cached} to create it and
+distribute the cached version together with helpfiles. See {\it samples/html/help} 
+sample for demonstration of its use.
+
+\wxheading{See also}
+
+\helpref{Information about wxBestHelpController}{wxhelpcontroller}
+
+\wxheading{Derived from}
+
+wxHelpControllerBase
+
+\wxheading{Include files}
+
+<wx/html/helpctrl.h>
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxHtmlHelpController::wxHtmlHelpController}\label{wxhtmlhelpcontrollerwxhtmlhelpcontroller}
+
+\func{}{wxHtmlHelpController}{\param{int }{style = wxHF\_DEFAULT\_STYLE}}
+
+Constructor.
+
+\wxheading{Parameters}
+
+{\it style} is combination of these flags:
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{\windowstyle{wxHF\_TOOLBAR}}{Help frame has toolbar.}
+\twocolitem{\windowstyle{wxHF\_FLAT\_TOOLBAR}}{Help frame has toolbar with flat buttons (aka coolbar).}
+\twocolitem{\windowstyle{wxHF\_CONTENTS}}{Help frame has contents panel.}
+\twocolitem{\windowstyle{wxHF\_INDEX}}{Help frame has index panel.}
+\twocolitem{\windowstyle{wxHF\_SEARCH}}{Help frame has search panel.}
+\twocolitem{\windowstyle{wxHF\_BOOKMARKS}}{Help frame has bookmarks controls.}
+\twocolitem{\windowstyle{wxHF\_OPEN\_FILES}}{Allow user to open arbitrary HTML document.}
+\twocolitem{\windowstyle{wxHF\_PRINT}}{Toolbar contains "print" button.}
+\twocolitem{\windowstyle{wxHF\_MERGE\_BOOKS}}{Contents pane does not show
+book nodes. All books are merged together and appear as single book to the
+user.}
+\twocolitem{\windowstyle{wxHF\_ICONS\_BOOK}}{All nodes in contents pane
+have a book icon. This is how Microsoft's HTML help viewer behaves.}
+\twocolitem{\windowstyle{wxHF\_ICONS\_FOLDER}}{Book nodes in contents pane have
+a book icon, book's sections have a folder icon. This is the default.}
+\twocolitem{\windowstyle{wxHF\_ICONS\_BOOK\_CHAPTER}}{Both book nodes and
+nodes of top-level sections of a book (i.e. chapters) have a book icon,
+all other sections (sections, subsections, ...) have a folder icon.}
+\twocolitem{\windowstyle{wxHF\_DEFAULT\_STYLE}}{{\tt wxHF\_TOOLBAR | wxHF\_CONTENTS
+| wxHF\_INDEX | wxHF\_SEARCH | wxHF\_BOOKMARKS | wxHF\_PRINT}}
+\end{twocollist}
+
+\membersection{wxHtmlHelpController::AddBook}\label{wxhtmlhelpcontrolleraddbook}
+
+\func{bool}{AddBook}{\param{const wxFileName\& }{book\_file}, \param{bool }{show\_wait\_msg}}
+
+\func{bool}{AddBook}{\param{const wxString\& }{book\_url}, \param{bool }{show\_wait\_msg}}
+
+Adds book (\helpref{.hhp file}{helpformat} - HTML Help Workshop project file) into the list of loaded books.
+This must be called at least once before displaying  any help.
+
+{\it book\_file} or {\it book\_url}  may be either .hhp file or ZIP archive
+that contains arbitrary number of .hhp files in 
+top-level directory. This ZIP archive must have .zip or .htb extension
+(the latter stands for "HTML book"). In other words,
+{\tt AddBook(wxFileName("help.zip"))}
+is possible and, in fact, recommended way.
+
+\wxheading{Parameters}
+
+\docparam{show\_wait\_msg}{If true then a decoration-less window with progress message is displayed.}
+\docparam{book\_file}{Help book filename. It is recommended to use this prototype
+instead of the one taking URL, because it is less error-prone.}
+\docparam{book\_url}{Help book URL (note that syntax of filename and URL is 
+different on most platforms)}
+
+\wxheading{Note}
+
+Don't forget to install wxFileSystem ZIP handler with
+{\tt wxFileSystem::AddHandler(new wxZipFSHandler);} before calling this method
+on a .zip or .htb file!
+
+\membersection{wxHtmlHelpController::CreateHelpFrame}\label{wxhtmlhelpcontrollercreatehelpframe}
+
+\func{virtual wxHtmlHelpFrame*}{CreateHelpFrame}{\param{wxHtmlHelpData * }{data}}
+
+This protected virtual method may be overridden so that the controller
+uses slightly different frame. See {\it samples/html/helpview} sample for
+an example.
+\membersection{wxHtmlHelpController::Display}\label{wxhtmlhelpcontrollerdisplay}
+
+\func{void}{Display}{\param{const wxString\& }{x}}
+
+Displays page {\it x}. This is THE important function - it is used to display
+the help in application.
+
+You can specify the page in many ways:
+
+\begin{itemize}\itemsep=0pt
+\item as direct filename of HTML document
+\item as chapter name (from contents) or as a book name
+\item as some word from index
+\item even as any word (will be searched)
+\end{itemize}
+
+Looking for the page runs in these steps:
+
+\begin{enumerate}\itemsep=0pt
+\item try to locate file named x (if x is for example "doc/howto.htm")
+\item try to open starting page of book named x
+\item try to find x in contents (if x is for example "How To ...")
+\item try to find x in index (if x is for example "How To ...")
+\item switch to Search panel and start searching
+\end{enumerate}
+
+\func{void}{Display}{\param{const int }{id}}
+
+This alternative form is used to search help contents by numeric IDs.
+
+\pythonnote{The second form of this method is named DisplayId in
+wxPython.}
+
+\membersection{wxHtmlHelpController::DisplayContents}\label{wxhtmlhelpcontrollerdisplaycontents}
+
+\func{void}{DisplayContents}{\void}
+
+Displays help window and focuses contents panel.
+
+\membersection{wxHtmlHelpController::DisplayIndex}\label{wxhtmlhelpcontrollerdisplayindex}
+
+\func{void}{DisplayIndex}{\void}
+
+Displays help window and focuses index panel.
+
+\membersection{wxHtmlHelpController::KeywordSearch}\label{wxhtmlhelpcontrollerkeywordsearch}
+
+\func{bool}{KeywordSearch}{\param{const wxString\& }{keyword}}
+
+Displays help window, focuses search panel and starts searching.
+Returns true if the keyword was found.
+
+{\bf Important:} KeywordSearch searches only pages listed in .hhc file(s).
+You should list all pages in the contents file.
+
+\membersection{wxHtmlHelpController::ReadCustomization}\label{wxhtmlhelpcontrollerreadcustomization}
+
+\func{void}{ReadCustomization}{\param{wxConfigBase* }{cfg}, \param{wxString }{path = wxEmptyString}}
+
+Reads the controller's setting (position of window, etc.)
+
+\membersection{wxHtmlHelpController::SetTempDir}\label{wxhtmlhelpcontrollersettempdir}
+
+\func{void}{SetTempDir}{\param{const wxString\& }{path}}
+
+Sets the path for storing temporary files - cached binary versions of index and contents files. These binary
+forms are much faster to read. Default value is empty string (empty string means
+that no cached data are stored). Note that these files are {\it not} 
+deleted when program exits.
+
+Once created these cached files will be used in all subsequent executions 
+of your application. If cached files become older than corresponding .hhp
+file (e.g. if you regenerate documentation) it will be refreshed.
+
+\membersection{wxHtmlHelpController::SetTitleFormat}\label{wxhtmlhelpcontrollersettitleformat}
+
+\func{void}{SetTitleFormat}{\param{const wxString\& }{format}}
+
+Sets format of title of the frame. Must contain exactly one "\%s"
+(for title of displayed HTML page).
+
+\membersection{wxHtmlHelpController::UseConfig}\label{wxhtmlhelpcontrolleruseconfig}
+
+\func{void}{UseConfig}{\param{wxConfigBase* }{config}, \param{const wxString\& }{rootpath = wxEmptyString}}
+
+Associates {\it config} object with the controller.
+
+If there is associated config object, wxHtmlHelpController automatically
+reads and writes settings (including wxHtmlWindow's settings) when needed.
+
+The only thing you must do is create wxConfig object and call UseConfig.
+
+If you do not use {\it UseConfig}, wxHtmlHelpController will use 
+default wxConfig object if available (for details see 
+\helpref{wxConfigBase::Get}{wxconfigbaseget} and 
+\helpref{wxConfigBase::Set}{wxconfigbaseset}).
+
+\membersection{wxHtmlHelpController::WriteCustomization}\label{wxhtmlhelpcontrollerwritecustomization}
+
+\func{void}{WriteCustomization}{\param{wxConfigBase* }{cfg}, \param{wxString }{path = wxEmptyString}}
+
+Stores controllers setting (position of window etc.)
+

docs/latex/wx/hthlpdat.tex

@@ -0,0 +1,87 @@
+%
+% automatically generated by HelpGen from
+% helpdata.h at 24/Oct/99 18:03:10
+%
+
+\section{\class{wxHtmlHelpData}}\label{wxhtmlhelpdata}
+
+This class is used by \helpref{wxHtmlHelpController}{wxhtmlhelpcontroller} 
+and \helpref{wxHtmlHelpFrame}{wxhtmlhelpframe} to access HTML help items.
+It is internal class and should not be used directly - except for the case 
+you're writing your own HTML help controller.
+
+\wxheading{Derived from}
+
+\helpref{wxObject}{wxobject}
+
+\wxheading{Include files}
+
+<wx/html/helpdata.h>
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxHtmlHelpData::wxHtmlHelpData}\label{wxhtmlhelpdatawxhtmlhelpdata}
+
+\func{}{wxHtmlHelpData}{\void}
+
+Constructor.
+
+\membersection{wxHtmlHelpData::AddBook}\label{wxhtmlhelpdataaddbook}
+
+\func{bool}{AddBook}{\param{const wxString\& }{book\_url}}
+
+Adds new book. {\it book} is URL (not filename!) of HTML help project (hhp)
+or ZIP file that contains arbitrary number of .hhp projects (this zip
+file can have either .zip or .htb extension, htb stands for "html book").
+Returns success.
+
+\membersection{wxHtmlHelpData::FindPageById}\label{wxhtmlhelpdatafindpagebyid}
+
+\func{wxString}{FindPageById}{\param{int }{id}}
+
+Returns page's URL based on integer ID stored in project.
+
+\membersection{wxHtmlHelpData::FindPageByName}\label{wxhtmlhelpdatafindpagebyname}
+
+\func{wxString}{FindPageByName}{\param{const wxString\& }{page}}
+
+Returns page's URL based on its (file)name.
+
+\membersection{wxHtmlHelpData::GetBookRecArray}\label{wxhtmlhelpdatagetbookrecarray}
+
+\func{const wxHtmlBookRecArray\&}{GetBookRecArray}{\void}
+
+Returns array with help books info.
+
+\membersection{wxHtmlHelpData::GetContents}\label{wxhtmlhelpdatagetcontents}
+
+\func{wxHtmlContentsItem*}{GetContents}{\void}
+
+Returns contents lists pointer.
+
+\membersection{wxHtmlHelpData::GetContentsCnt}\label{wxhtmlhelpdatagetcontentscnt}
+
+\func{int}{GetContentsCnt}{\void}
+
+Returns size of contents list.
+
+\membersection{wxHtmlHelpData::GetIndex}\label{wxhtmlhelpdatagetindex}
+
+\func{wxHtmlContentsItem*}{GetIndex}{\void}
+
+Returns pointer to index items list.
+
+\membersection{wxHtmlHelpData::GetIndexCnt}\label{wxhtmlhelpdatagetindexcnt}
+
+\func{int}{GetIndexCnt}{\void}
+
+Returns size of index list.
+
+\membersection{wxHtmlHelpData::SetTempDir}\label{wxhtmlhelpdatasettempdir}
+
+\func{void}{SetTempDir}{\param{const wxString\& }{path}}
+
+Sets temporary directory where binary cached versions of MS HTML Workshop
+files will be stored. (This is turned off by default and you can enable
+this feature by setting non-empty temp dir.)
+

docs/latex/wx/hthlpfrm.tex

@@ -0,0 +1,170 @@
+%
+% automatically generated by HelpGen from
+% helpfrm.h at 24/Oct/99 18:03:10
+%
+
+\section{\class{wxHtmlHelpFrame}}\label{wxhtmlhelpframe}
+
+This class is used by \helpref{wxHtmlHelpController}{wxhtmlhelpcontroller} 
+to display help.
+It is an internal class and should not be used directly - except for the case
+when you're writing your own HTML help controller.
+
+\wxheading{Derived from}
+
+\helpref{wxFrame}{wxframe}
+
+\wxheading{Include files}
+
+<wx/html/helpfrm.h>
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxHtmlHelpFrame::wxHtmlHelpFrame}\label{wxhtmlhelpframewxhtmlhelpframe}
+
+\func{}{wxHtmlHelpFrame}{\param{wxHtmlHelpData* }{data = NULL}}
+
+\func{}{wxHtmlHelpFrame}{\param{wxWindow* }{parent}, \param{int }{wxWindowID}, \param{const wxString\& }{title = wxEmptyString}, \param{int }{style = wxHF\_DEFAULT\_STYLE}, \param{wxHtmlHelpData* }{data = NULL}}
+
+Constructor.
+
+{\it style} is combination of these flags:
+
+\begin{twocollist}\itemsep=0pt
+\twocolitem{\windowstyle{wxHF\_TOOLBAR}}{Help frame has toolbar.}
+\twocolitem{\windowstyle{wxHF\_FLAT\_TOOLBAR}}{Help frame has toolbar with flat buttons (aka coolbar).}
+\twocolitem{\windowstyle{wxHF\_CONTENTS}}{Help frame has contents panel.}
+\twocolitem{\windowstyle{wxHF\_INDEX}}{Help frame has index panel.}
+\twocolitem{\windowstyle{wxHF\_SEARCH}}{Help frame has search panel.}
+\twocolitem{\windowstyle{wxHF\_BOOKMARKS}}{Help frame has bookmarks controls.}
+\twocolitem{\windowstyle{wxHF\_OPEN\_FILES}}{Allow user to open arbitrary HTML document.}
+\twocolitem{\windowstyle{wxHF\_PRINT}}{Toolbar contains "print" button.}
+\twocolitem{\windowstyle{wxHF\_MERGE\_BOOKS}}{Contents pane does not show
+book nodes. All books are merged together and appear as single book to the
+user.}
+\twocolitem{\windowstyle{wxHF\_ICONS\_BOOK}}{All nodes in contents pane
+have a book icon. This is how Microsoft's HTML help viewer behaves.}
+\twocolitem{\windowstyle{wxHF\_ICONS\_FOLDER}}{Book nodes in contents pane have
+a book icon, book's sections have a folder icon. This is the default.}
+\twocolitem{\windowstyle{wxHF\_ICONS\_BOOK\_CHAPTER}}{Both book nodes and
+nodes of top-level sections of a book (i.e. chapters) have a book icon,
+all other sections (sections, subsections, ...) have a folder icon.}
+\twocolitem{\windowstyle{wxHF\_DEFAULT\_STYLE}}{{\tt wxHF\_TOOLBAR | wxHF\_CONTENTS
+| wxHF\_INDEX | wxHF\_SEARCH | wxHF\_BOOKMARKS | wxHF\_PRINT}}
+\end{twocollist}
+
+\membersection{wxHtmlHelpFrame::Create}\label{wxhtmlhelpframecreate}
+
+\func{bool}{Create}{\param{wxWindow* }{parent}, \param{wxWindowID }{id}, \param{const wxString\& }{title = wxEmptyString}, \param{int }{style = wxHF\_DEFAULT\_STYLE}}
+
+Creates the frame. See \helpref{the constructor}{wxhtmlhelpframewxhtmlhelpframe}
+for parameters description.
+
+\membersection{wxHtmlHelpFrame::CreateContents}\label{wxhtmlhelpframecreatecontents}
+
+\func{void}{CreateContents}{\param{bool }{show\_progress = false}}
+
+Creates contents panel. (May take some time.)
+
+\membersection{wxHtmlHelpFrame::CreateIndex}\label{wxhtmlhelpframecreateindex}
+
+\func{void}{CreateIndex}{\param{bool }{show\_progress = false}}
+
+Creates index panel. (May take some time.)
+
+\membersection{wxHtmlHelpFrame::CreateSearch}\label{wxhtmlhelpframecreatesearch}
+
+\func{void}{CreateSearch}{\void}
+
+Creates search panel.
+
+\membersection{wxHtmlHelpFrame::Display}\label{wxhtmlhelpframedisplay}
+
+\func{bool}{Display}{\param{const wxString\& }{x}}
+
+\func{bool}{Display}{\param{const int }{id}}
+
+Displays page x. If not found it will give the user the choice of
+searching books.
+Looking for the page runs in these steps:
+
+\begin{enumerate}\itemsep=0pt
+\item try to locate file named x (if x is for example "doc/howto.htm")
+\item try to open starting page of book x
+\item try to find x in contents (if x is for example "How To ...")
+\item try to find x in index (if x is for example "How To ...")
+\end{enumerate}
+
+The second form takes numeric ID as the parameter.
+(uses extension to MS format, <param name="ID" value=id>)
+
+\pythonnote{The second form of this method is named DisplayId in
+wxPython.}
+
+\membersection{wxHtmlHelpFrame::DisplayContents}\label{wxhtmlhelpframedisplaycontents}
+
+\func{bool}{DisplayContents}{\void}
+
+Displays contents panel.
+
+\membersection{wxHtmlHelpFrame::DisplayIndex}\label{wxhtmlhelpframedisplayindex}
+
+\func{bool}{DisplayIndex}{\void}
+
+Displays index panel.
+
+\membersection{wxHtmlHelpFrame::GetData}\label{wxhtmlhelpframegetdata}
+
+\func{wxHtmlHelpData*}{GetData}{\void}
+
+Return wxHtmlHelpData object.
+
+\membersection{wxHtmlHelpFrame::KeywordSearch}\label{wxhtmlhelpframekeywordsearch}
+
+\func{bool}{KeywordSearch}{\param{const wxString\& }{keyword}}
+
+Search for given keyword.
+
+\membersection{wxHtmlHelpFrame::ReadCustomization}\label{wxhtmlhelpframereadcustomization}
+
+\func{void}{ReadCustomization}{\param{wxConfigBase* }{cfg}, \param{const wxString\& }{path = wxEmptyString}}
+
+Reads user's settings for this frame (see \helpref{wxHtmlHelpController::ReadCustomization}{wxhtmlhelpcontrollerreadcustomization})
+
+\membersection{wxHtmlHelpFrame::RefreshLists}\label{wxhtmlhelpframerefreshlists}
+
+\func{void}{RefreshLists}{\param{bool }{show\_progress = false}}
+
+Refresh all panels. This is necessary if a new book was added.
+
+\membersection{wxHtmlHelpFrame::SetTitleFormat}\label{wxhtmlhelpframesettitleformat}
+
+\func{void}{SetTitleFormat}{\param{const wxString\& }{format}}
+
+Sets the frame's title format. {\it format} must contain exactly one "\%s"
+(it will be replaced by the page title).
+
+\membersection{wxHtmlHelpFrame::UseConfig}\label{wxhtmlhelpframeuseconfig}
+
+\func{void}{UseConfig}{\param{wxConfigBase* }{config}, \param{const wxString\& }{rootpath = wxEmptyString}}
+
+Add books to search choice panel.
+
+\membersection{wxHtmlHelpFrame::WriteCustomization}\label{wxhtmlhelpframewritecustomization}
+
+\func{void}{WriteCustomization}{\param{wxConfigBase* }{cfg}, \param{const wxString\& }{path = wxEmptyString}}
+
+Saves user's settings for this frame (see \helpref{wxHtmlHelpController::WriteCustomization}{wxhtmlhelpcontrollerwritecustomization}).
+
+\membersection{wxHtmlHelpFrame::AddToolbarButtons}\label{wxhtmlhelpframeaddtoolbarbuttons}
+
+\func{virtual void}{AddToolbarButtons}{\param{wxToolBar *}{toolBar}, \param{int }{style}} 
+
+You may override this virtual method to add more buttons into help frame's
+toolbar. {\it toolBar} is a pointer to the toolbar and {\it style} is the style
+flag as passed to Create method.
+
+wxToolBar::Realize is called immediately after returning from this function.
+
+See {\it samples/html/helpview} for an example.
+

docs/latex/wx/htlnkinf.tex

@@ -0,0 +1,59 @@
+\section{\class{wxHtmlLinkInfo}}\label{wxhtmllinkinfo}
+
+This class stores all necessary information about hypertext
+links (as represented by {\tt <A>} tag in HTML documents). In 
+current implementation it stores URL and target frame name. 
+{\it Note that frames are not currently supported by wxHTML!}
+
+\wxheading{Derived from}
+
+\helpref{wxObject}{wxobject}
+
+\wxheading{Include files}
+
+<wx/html/htmlcell.h>
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxHtmlLinkInfo::wxHtmlLinkInfo}\label{wxhtmllinkinfowxhtmllinkinfo}
+
+\func{}{wxHtmlLinkInfo}{\void}
+
+Default ctor.
+
+\func{}{wxHtmlLinkInfo}{\param{const wxString\& }{href}, \param{const wxString\& }{target = wxEmptyString}}
+
+Construct hypertext link from HREF (aka URL) and TARGET (name of target
+frame).
+
+\membersection{wxHtmlLinkInfo::GetEvent}\label{wxhtmllinkinfogetevent}
+
+\func{const wxMouseEvent *}{GetEvent}{\void}
+
+Return pointer to event that generated OnLinkClicked event. Valid
+only within \helpref{wxHtmlWindow::OnLinkClicked}{wxhtmlwindowonlinkclicked},
+NULL otherwise.
+
+\membersection{wxHtmlLinkInfo::GetHtmlCell}\label{wxhtmllinkinfogethtmlcell}
+
+\func{const wxHtmlCell *}{GetHtmlCell}{\void}
+
+Return pointer to the cell that was clicked. Valid
+only within \helpref{wxHtmlWindow::OnLinkClicked}{wxhtmlwindowonlinkclicked},
+NULL otherwise.
+
+
+\membersection{wxHtmlLinkInfo::GetHref}\label{wxhtmllinkinfogethref}
+
+\func{wxString}{GetHref}{\void}
+
+Return {\it HREF} value of the {\tt <A>} tag.
+
+\membersection{wxHtmlLinkInfo::GetTarget}\label{wxhtmllinkinfogettarget}
+
+\func{wxString}{GetTarget}{\void}
+
+Return {\it TARGET} value of the {\tt <A>} tag (this value
+is used to specify in which frame should be the page pointed
+by \helpref{Href}{wxhtmllinkinfogethref} opened).
+

docs/latex/wx/htmlcell.tex

@@ -0,0 +1,82 @@
+\subsection{Cells and Containers}\label{cells}
+
+This article describes mechanism used by 
+\helpref{wxHtmlWinParser}{wxhtmlwinparser} and 
+\helpref{wxHtmlWindow}{wxhtmlwindow} to parse and display HTML documents.
+
+\wxheading{Cells}
+
+You can divide any text (or HTML) into small fragments. Let's call these
+fragments {\bf cells}. Cell is for example one word, horizontal line, image
+or any other part of document. Each cell has width and height (except special
+"magic" cells with zero dimensions - e.g. colour changers or font changers).
+
+See \helpref{wxHtmlCell}{wxhtmlcell}.
+
+\wxheading{Containers}
+
+Container is kind of cell that may contain sub-cells. Its size depends
+on number and sizes of its sub-cells (and also depends on width of window). 
+
+See \helpref{wxHtmlContainerCell}{wxhtmlcontainercell}, 
+\helpref{wxHtmlCell::Layout}{wxhtmlcelllayout}.
+
+\begin{comment}
+% Bitmap is corrupt!
+This image shows you cells and containers:
+
+\helponly{\image{}{contbox.bmp}}
+\end{comment}
+\wxheading{Using Containers in Tag Handler}
+
+\helpref{wxHtmlWinParser}{wxhtmlwinparser} provides a user-friendly way
+of managing containers. It is based on the idea of opening and closing containers.
+
+Use \helpref{OpenContainer}{wxhtmlwinparseropencontainer} to open new
+a container {\it within an already opened container}. This new container is a 
+{\it sub-container} of the old one. (If you want to create a new container with
+the same depth level you can call {\tt CloseContainer(); OpenContainer();}.)
+
+Use \helpref{CloseContainer}{wxhtmlwinparserclosecontainer} to close the 
+container. This doesn't create a new container with same depth level but
+it returns "control" to the parent container.
+
+\begin{comment}
+% Bitmap corrupt!
+See explanation:
+
+\helponly{\image{}{cont.bmp}}
+\end{comment}
+It is clear there must be same number of calls to 
+OpenContainer as to CloseContainer...
+
+\wxheading{Example}
+
+This code creates a new paragraph (container at same depth level)
+with "Hello, world!":
+
+\begin{verbatim}
+m_WParser -> CloseContainer();
+c = m_WParser -> OpenContainer();
+
+m_WParser -> AddWord("Hello, ");
+m_WParser -> AddWord("world!");
+
+m_WParser -> CloseContainer();
+m_WParser -> OpenContainer();
+\end{verbatim}
+
+\begin{comment}
+% Bitmap corrupt!
+and here is image of the situation:
+
+\helponly{\image{}{hello.bmp}}
+\end{comment}
+
+You can see that there was opened container before running the code. We closed
+it, created our own container, then closed our container and opened
+new container. The result was that we had {\it same depth level} after
+executing. This is general rule that should be followed by tag handlers:
+leave depth level of containers unmodified (in other words, number of
+OpenContainer and CloseContainer calls should be same within \helpref{HandleTag}{wxhtmltaghandlerhandletag}'s body).
+

docs/latex/wx/htmlfilt.tex

@@ -0,0 +1,10 @@
+\subsection{Input Filters}\label{filters}
+
+The wxHTML library provides a mechanism for reading and displaying
+files of many different file formats. 
+
+\helpref{wxHtmlWindow::LoadPage}{wxhtmlwindowloadpage} can load not
+only HTML files but any known file. To make a file type known to wxHtmlWindow
+you must create a \helpref{wxHtmlFilter}{wxhtmlfilter} filter and
+register it using \helpref{wxHtmlWindow::AddFilter}{wxhtmlwindowaddfilter}.
+

docs/latex/wx/htmlhand.tex

@@ -0,0 +1,146 @@
+\subsection{Tag Handlers}\label{handlers}
+
+The wxHTML library provides architecture of pluggable {\it tag handlers}.
+Tag handler is class that understands particular HTML tag (or tags) and is
+able to interpret it.
+
+\helpref{wxHtmlWinParser}{wxhtmlwinparser} has static table of {\bf modules}.
+Each module contains one or more tag handlers. Each time a new wxHtmlWinParser
+object is constructed all modules are scanned and handlers are added
+to wxHtmlParser's list of available handlers (note: wxHtmlParser's list
+is non-static).
+
+\wxheading{How it works}
+
+Common tag handler's \helpref{HandleTag}{wxhtmltaghandlerhandletag} method
+works in four steps:
+
+\begin{enumerate}\itemsep=0pt
+\item Save state of parent parser into local variables
+\item Change parser state according to tag's params
+\item Parse text between the tag and paired ending tag (if present)
+\item Restore original parser state
+\end{enumerate}
+
+See \helpref{wxHtmlWinParser}{wxhtmlwinparser} for methods for modifying
+parser's state. In general you can do things like opening/closing containers,
+changing colors, fonts etc.
+
+\wxheading{Providing own tag handlers}
+
+You should create new .cpp file and place following lines into it: 
+
+\begin{verbatim}
+#include <mod_templ.h>
+#include <forcelink.h>
+FORCE_LINK_ME(yourmodulefilenamewithoutcpp)
+\end{verbatim}
+
+Then you must define handlers and one module.
+
+\wxheading{Tag handlers}
+
+The handler is derived from \helpref{wxHtmlWinTagHandler}{wxhtmlwintaghandler}
+(or directly from \helpref{wxHtmlTagHandler}{wxhtmltaghandler})
+
+You can use set of macros to define the handler (see src/html/m\_*.cpp files
+for details). Handler definition must start with {\bf TAG\_HANDLER\_BEGIN} macro
+and end with {\bf TAG\_HANDLER\_END} macro. I strongly recommend to have a look
+at {\it include/wxhtml/mod\_templ.h} file. Otherwise you won't understand
+the structure of macros. See macros reference:
+
+{\bf TAG\_HANDLER\_BEGIN}({\it name}, {\it tags})
+
+Starts handler definition. {\it name} is handler identifier (in fact
+part of class name), {\it tags} is string containing list of tags
+supported by this handler (in uppercase). This macro derives new class from
+wxHtmlWinTagHandler and implements it is 
+\helpref{GetSupportedTags}{wxhtmltaghandlergetsupportedtags} method.
+
+Example: TAG\_HANDLER\_BEGIN(FONTS, "B,I,U,T")
+
+{\bf TAG\_HANDLER\_VARS}
+
+This macro starts block of variables definitions. (Variables are identical
+to class attributes.) Example:
+
+\begin{verbatim}
+TAG_HANDLER_BEGIN(VARS_ONLY, "CRAZYTAG")
+    TAG_HANDLER_VARS
+        int my_int_var;
+	wxString something_else;
+TAG_HANDLER_END(VARS_ONLY)
+\end{verbatim}
+
+This macro is used only in rare cases.
+
+{\bf TAG\_HANDLER\_CONSTR}({\it name})
+
+This macro supplies object constructor. {\it name} is same name as the one
+from TAG\_HANDLER\_BEGIN macro. Body of constructor follow after
+this macro (you must use { and } ). Example:
+
+\begin{verbatim}
+TAG_HANDLER_BEGIN(VARS2, "CRAZYTAG")
+    TAG_HANDLER_VARS
+        int my_int_var;
+    TAG_HANDLER_CONSTR(vars2)
+        { // !!!!!!
+	    my_int_var = 666;
+	} // !!!!!!
+TAG_HANDLER_END(VARS2)
+\end{verbatim}
+
+Never used in wxHTML :-)
+
+{\bf TAG\_HANDLER\_PROC}({\it varib})
+
+This is very important macro. It defines \helpref{HandleTag}{wxhtmltaghandlerhandletag}
+method. {\it varib} is name of parameter passed to the method, usually
+{\it tag}. Body of method follows after this macro.
+Note than you must use { and } ! Example:
+
+\begin{verbatim}
+TAG_HANDLER_BEGIN(TITLE, "TITLE")
+    TAG_HANDLER_PROC(tag)
+        {
+	    printf("TITLE found...\n");
+	}
+TAG_HANDLER_END(TITLE)
+\end{verbatim}
+
+{\bf TAG\_HANDLER\_END}({\it name})
+
+Ends definition of tag handler {\it name}. 
+
+\wxheading{Tags Modules}
+
+You can use set of 3 macros TAGS\_MODULE\_BEGIN, TAGS\_MODULE\_ADD and 
+TAGS\_MODULE\_END to inherit new module from
+\helpref{wxHtmlTagsModule}{wxhtmltagsmodule} and to create instance of it.
+See macros reference:
+
+{\bf TAGS\_MODULE\_BEGIN}({\it modname})
+
+Begins module definition. {\it modname} is part of class name and must
+be unique.
+
+{\bf TAGS\_MODULE\_ADD}({\it name})
+
+Adds the handler to this module. {\it name} is the identifier from
+TAG\_HANDLER\_BEGIN.
+
+{\bf TAGS\_MODULE\_END}({\it modname})
+
+Ends the definition of module.
+
+{\bf Example:}
+
+\begin{verbatim}
+TAGS_MODULE_BEGIN(Examples)
+    TAGS_MODULE_ADD(VARS_ONLY)
+    TAGS_MODULE_ADD(VARS2)
+    TAGS_MODULE_ADD(TITLE)
+TAGS_MODULE_END(Examples)
+\end{verbatim}
+

docs/latex/wx/htmlhlpf.tex

@@ -0,0 +1,96 @@
+\subsection{Help Files Format}\label{helpformat}
+
+wxHTML library uses a reduced version of MS HTML Workshop format.
+Tex2RTF can produce these files when generating HTML, if you set {\bf htmlWorkshopFiles} to {\bf true} in
+your tex2rtf.ini file.
+
+(See \helpref{wxHtmlHelpController}{wxhtmlhelpcontroller} for help controller description.)
+
+A {\bf book} consists of three files: header file, contents file and index file.
+You can make a regular zip archive of these files, plus the HTML and any image files,
+for wxHTML (or helpview) to read; and the .zip file can optionally be renamed to .htb.
+
+\wxheading{Header file (.hhp)}
+
+Header file must contain these lines (and may contain additional lines which are ignored) :
+
+\begin{verbatim}
+Contents file=<filename.hhc>
+Index file=<filename.hhk>
+Title=<title of your book>
+Default topic=<default page to be displayed.htm>
+\end{verbatim}
+
+All filenames (including the Default topic) are relative to the 
+location of .hhp file.
+
+{\bf Localization note:} In addition, .hhp file may contain line
+
+\begin{verbatim}
+Charset=<rfc_charset>
+\end{verbatim}
+
+which specifies what charset (e.g. "iso8859\_1") was used in contents
+and index files. Please note that this line is incompatible with
+MS HTML Help Workshop and it would either silently remove it or complain
+with some error. See also 
+\helpref{Writing non-English applications}{nonenglishoverview}.
+
+\wxheading{Contents file (.hhc)}
+
+Contents file has HTML syntax and it can be parsed by regular HTML parser. It contains exactly one list
+({\tt <ul>}....{\tt </ul>} statement):
+
+\begin{verbatim}
+<ul>
+
+  <li> <object type="text/sitemap">
+           <param name="Name" value="@topic name@">
+           <param name="ID" value=@numeric_id@>
+           <param name="Local" value="@filename.htm@">
+       </object>
+  <li> <object type="text/sitemap">
+           <param name="Name" value="@topic name@">
+           <param name="ID" value=@numeric_id@>
+           <param name="Local" value="@filename.htm@">
+       </object>
+  ...    
+
+</ul>
+\end{verbatim}
+
+You can modify value attributes of param tags. {\it topic name} is name of chapter/topic as is displayed in
+contents, {\it filename.htm} is HTML page name (relative to .hhp file) and {\it numeric\_id} is optional 
+- it is used only when you use \helpref{wxHtmlHelpController::Display(int)}{wxhtmlhelpcontrollerdisplay}
+
+Items in the list may be nested - one {\tt <li>} statement may contain a {\tt <ul>} sub-statement:
+
+\begin{verbatim}
+<ul>
+
+  <li> <object type="text/sitemap">
+           <param name="Name" value="Top node">
+           <param name="Local" value="top.htm">
+       </object>
+       <ul>
+         <li> <object type="text/sitemap">
+              <param name="Name" value="subnode in topnode">
+              <param name="Local" value="subnode1.htm">
+              </object>
+      ...
+       </ul>
+       
+  <li> <object type="text/sitemap">
+           <param name="Name" value="Another Top">
+           <param name="Local" value="top2.htm">
+       </object>
+  ...    
+
+</ul>
+\end{verbatim}
+
+\wxheading{Index file (.hhk)}
+
+Index files have same format as contents file except that ID params are ignored and sublists are {\bf not} 
+allowed.
+

docs/latex/wx/htmllbox.tex

@@ -0,0 +1,82 @@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% Name:        htmllbox.tex
+%% Purpose:     wxHtmlListBox documentation
+%% Author:      Vadim Zeitlin
+%% Modified by:
+%% Created:     01.06.03
+%% RCS-ID:      $Id$
+%% Copyright:   (c) 2003 Vadim Zeitlin <vadim@wxwindows.org>
+%% License:     wxWindows license
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+\section{\class{wxHtmlListBox}}\label{wxhtmllistbox}
+
+wxHtmlListBox is an implementation of \helpref{wxVListBox}{wxvlistbox} which
+shows HTML content in the listbox rows. This is still an abstract base class
+and you will need to derive your own class from it (see htlbox sample for the
+example) but you will only need to override a single 
+\helpref{OnGetItem()}{wxhtmllistboxongetitem} function.
+
+\wxheading{Derived from}
+
+\helpref{wxVListBox}{wxvlistbox}
+
+\wxheading{Include files}
+
+<wx/htmllbox.h>
+
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+
+\membersection{wxHtmlListBox::wxHtmlListBox}\label{wxhtmllistboxwxhtmllistbox}
+
+\func{}{wxHtmlListBox}{\param{wxWindow* }{parent}, \param{wxWindowID }{id = wxID\_ANY}, \param{const wxPoint\& }{pos = wxDefaultPosition}, \param{const wxSize\& }{size = wxDefaultSize}, \param{size\_t }{countItems = 0}, \param{long }{style = 0}, \param{const wxString\& }{name = wxVListBoxNameStr}}
+
+Normal constructor which calls \helpref{Create()}{wxhtmllistboxcreate}
+internally.
+
+\func{}{wxHtmlListBox}{\void}
+
+Default constructor, you must call \helpref{Create()}{wxhtmllistboxcreate}
+later.
+
+
+\membersection{wxHtmlListBox::\destruct{wxHtmlListBox}}\label{wxhtmllistboxdtor}
+
+\func{}{\destruct{wxHtmlListBox}}{\void}
+
+Destructor cleans up whatever resources we use.
+
+
+\membersection{wxHtmlListBox::Create}\label{wxhtmllistboxcreate}
+
+\func{bool}{Create}{\param{wxWindow* }{parent}, \param{wxWindowID }{id = wxID\_ANY}, \param{const wxPoint\& }{pos = wxDefaultPosition}, \param{const wxSize\& }{size = wxDefaultSize}, \param{size\_t }{countItems = 0}, \param{long }{style = 0}, \param{const wxString\& }{name = wxVListBoxNameStr}}
+
+Creates the control and optionally sets the initial number of items in it
+(it may also be set or changed later with 
+\helpref{SetItemCount()}{wxvlistboxsetitemcount}).
+
+There are no special styles defined for wxHtmlListBox, in particular the
+wxListBox styles can not be used here.
+
+Returns {\tt true} on success or {\tt false} if the control couldn't be created
+
+
+
+\membersection{wxHtmlListBox::OnGetItem}\label{wxhtmllistboxongetitem}
+
+\constfunc{wxString}{OnGetItem}{\param{size\_t }{n}}
+
+This method must be implemented in the derived class and should return
+the body (i.e. without {\tt <html>} nor {\tt <body>} tags) of the HTML fragment
+for the given item.
+
+
+\membersection{wxHtmlListBox::OnGetItemMarkup}\label{wxhtmllistboxongetitemmarkup}
+
+\constfunc{wxString}{OnGetItemMarkup}{\param{size\_t }{n}}
+
+This function may be overridden to decorate HTML returned by
+\helpref{OnGetItem()}{wxhtmllistboxongetitem}.
+

docs/latex/wx/htmlprn.tex

@@ -0,0 +1,13 @@
+\subsection{HTML Printing}\label{printing}
+
+The wxHTML library provides printing facilities with several levels of complexity. 
+
+The easiest way to print an HTML document is to use 
+\helpref{wxHtmlEasyPrinting class}{wxhtmleasyprinting}. It lets you print HTML documents with only one
+command and you don't have to worry about deriving from the wxPrintout class at all. It is only a simple wrapper around the 
+\helpref{wxHtmlPrintout}{wxhtmlprintout}, normal wxWindows printout class.
+
+And finally there is the low level class \helpref{wxHtmlDCRenderer}{wxhtmldcrenderer} which you can use to
+render HTML into a rectangular area on any DC. It supports rendering into multiple rectangles with the same
+width. (The most common use of this is placing one rectangle on each page or printing into two columns.)
+

docs/latex/wx/htmlstrt.tex

@@ -0,0 +1,68 @@
+\subsection{wxHTML quick start}\label{wxhtmlquickstart}
+
+\wxheading{Displaying HMTL}
+
+First of all, you must include <wx/wxhtml.h>.
+
+Class \helpref{wxHtmlWindow}{wxhtmlwindow} (derived from wxScrolledWindow)
+is used to display HTML documents.
+It has two important methods: \helpref{LoadPage}{wxhtmlwindowloadpage} 
+and \helpref{SetPage}{wxhtmlwindowsetpage}.
+LoadPage loads and displays HTML file while SetPage displays directly the
+passed {\bf string}. See the example:
+
+\begin{verbatim}
+    mywin -> LoadPage("test.htm");
+    mywin -> SetPage("<html><body>"
+                     "<h1>Error</h1>"
+		     "Some error occurred :-H)"
+		     "</body></hmtl>");
+\end{verbatim}
+
+I think the difference is quite clear.
+
+\wxheading{Displaying Help}
+
+See \helpref{wxHtmlHelpController}{wxhtmlhelpcontroller}.
+
+\wxheading{Setting up wxHtmlWindow}
+
+Because wxHtmlWindow is derived from wxScrolledWindow and not from
+wxFrame, it doesn't have visible frame. But the user usually want to see
+the title of HTML page displayed somewhere and frame's titlebar is 
+ideal place for it.
+
+wxHtmlWindow provides 2 methods in order to handle this: 
+\helpref{SetRelatedFrame}{wxhtmlwindowsetrelatedframe} and 
+\helpref{SetRelatedStatusBar}{wxhtmlwindowsetrelatedstatusbar}. 
+See the example:
+
+\begin{verbatim}
+    html = new wxHtmlWindow(this);
+    html -> SetRelatedFrame(this, "HTML : %%s");
+    html -> SetRelatedStatusBar(0);
+\end{verbatim}
+
+The first command associates html object with it is parent frame
+(this points to wxFrame object there) and sets format of title.
+Page title "Hello, world!" will be displayed as "HTML : Hello, world!"
+in this example.
+
+The second command sets which frame's status bar should be used to display
+browser's messages (such as "Loading..." or "Done" or hypertext links).
+
+\wxheading{Customizing wxHtmlWindow}
+
+You can customize wxHtmlWindow by setting font size, font face and
+borders (space between border of window and displayed HTML). Related functions:
+
+\begin{itemize}\itemsep=0pt
+\item \helpref{SetFonts}{wxhtmlwindowsetfonts}
+\item \helpref{SetBorders}{wxhtmlwindowsetborders}
+\item \helpref{ReadCustomization}{wxhtmlwindowreadcustomization}
+\item \helpref{WriteCustomization}{wxhtmlwindowwritecustomization}
+\end{itemize}
+
+The last two functions are used to store user customization info wxConfig stuff
+(for example in the registry under Windows, or in a dotfile under Unix).
+

docs/latex/wx/htmltags.tex

@@ -0,0 +1,148 @@
+\subsection{Tags supported by wxHTML}\label{htmltagssupported}
+
+wxHTML is not full implementation of HTML standard. Instead, it supports most common tags so that it 
+is possible to display {\it simple} HTML documents with it. (For example it works fine with pages created
+in Netscape Composer or generated by tex2rtf).
+
+Following tables list all tags known to wxHTML, together with supported parameters.
+A tag has general form of {\tt <tagname param\_1 param\_2 ... param\_n>} where param\_i is
+either {\tt paramname="paramvalue"} or {\tt paramname=paramvalue} - these two are equivalent. Unless stated 
+otherwise, wxHTML is case-insensitive.
+
+\wxheading{Table of common parameter values}
+
+We will use these substitutions in tags descriptions:
+
+\begin{verbatim}
+[alignment]     CENTER
+                LEFT
+                RIGHT
+                JUSTIFY
+
+[v_alignment]   TOP
+                BOTTOM
+                CENTER
+                
+[color]         HTML 4.0-compliant colour specification
+
+[fontsize]      -2
+                -1
+                +0
+                +1
+                +2
+                +3
+                +4
+                 1
+                 2
+                 3
+                 4
+                 5
+                 6
+                 7
+
+[pixels]        integer value that represents dimension in pixels
+
+[percent]       i% 
+                where i is integer
+
+[url]           an URL 
+
+[string]        text string
+
+[coords]        c(1),c(2),c(3),...,c(n)
+                where c(i) is integer
+
+\end{verbatim}
+
+
+\wxheading{List of supported tags}
+
+\begin{verbatim}
+
+A               NAME=[string]
+                HREF=[url]
+                TARGET=[target window spec]
+ADDRESS
+AREA            SHAPE=POLY
+                SHAPE=CIRCLE
+                SHAPE=RECT
+                COORDS=[coords]
+                HREF=[url]
+B
+BIG
+BLOCKQUOTE
+BODY            TEXT=[color]
+                LINK=[color]
+                BGCOLOR=[color]
+BR              ALIGN=[alignment]
+CENTER
+CITE
+CODE
+DD
+DIV             ALIGN=[alignment]
+DL
+DT
+EM
+FONT            COLOR=[color]
+                SIZE=[fontsize]
+                FACE=[comma-separated list of facenames]
+HR              ALIGN=[alignment]
+                SIZE=[pixels]
+                WIDTH=[percent|pixels]
+                NOSHADE
+H1
+H2
+H3
+H4
+H5
+H6
+I
+IMG             SRC=[url]
+                WIDTH=[pixels]
+                HEIGHT=[pixels]
+                ALIGN=TEXTTOP
+                ALIGN=CENTER
+                ALIGN=ABSCENTER
+                ALIGN=BOTTOM
+                USEMAP=[url]
+KBD
+LI
+MAP             NAME=[string]
+META            HTTP-EQUIV="Content-Type"
+                CONTENT=[string]
+OL
+P               ALIGN=[alignment]
+PRE
+SAMP
+SMALL
+STRIKE
+STRONG
+TABLE           ALIGN=[alignment]
+                WIDTH=[percent|pixels]
+                BORDER=[pixels]
+                VALIGN=[v_alignment]
+                BGCOLOR=[color]
+                CELLSPACING=[pixels]
+                CELLPADDING=[pixels]
+TD              ALIGN=[alignment]
+                VALIGN=[v_alignment]
+                BGCOLOR=[color]
+                WIDTH=[percent|pixels]
+                COLSPAN=[pixels]
+                ROWSPAN=[pixels]
+TH              ALIGN=[alignment]
+                VALIGN=[v_alignment]
+                BGCOLOR=[color]
+                WIDTH=[percent|pixels]
+                COLSPAN=[pixels]
+                ROWSPAN=[pixels]
+TITLE
+TR              ALIGN=[alignment]
+                VALIGN=[v_alignment]
+                BGCOLOR=[color]
+TT
+U
+UL
+
+\end{verbatim}
+

docs/latex/wx/htparser.tex

@@ -0,0 +1,267 @@
+%
+% automatically generated by HelpGen from
+% htmlparser.tex at 14/Mar/99 20:13:37
+%
+
+\section{\class{wxHtmlParser}}\label{wxhtmlparser}
+
+This class handles the {\bf generic} parsing of HTML document: it scans
+the document and divide it into blocks of tags (where one block
+consists of beginning and ending tag and of text between these
+two tags).
+
+It is independent from wxHtmlWindow and can be used as stand-alone parser
+(Julian Smart's idea of speech-only HTML viewer or wget-like utility -
+see InetGet sample for example).
+
+It uses system of tag handlers to parse the HTML document. Tag handlers
+are not statically shared by all instances but are created for each
+wxHtmlParser instance. The reason is that the handler may contain
+document-specific temporary data used during parsing (e.g. complicated
+structures like tables).
+
+Typically the user calls only the \helpref{Parse}{wxhtmlparserparse} method.
+
+\wxheading{Derived from}
+
+wxObject
+
+\wxheading{Include files}
+
+<wx/html/htmlpars.h>
+
+\wxheading{See also}
+
+\helpref{Cells Overview}{cells},
+\helpref{Tag Handlers Overview}{handlers},
+\helpref{wxHtmlTag}{wxhtmltag}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxHtmlParser::wxHtmlParser}\label{wxhtmlparserwxhtmlparser}
+
+\func{}{wxHtmlParser}{\void}
+
+Constructor.
+
+\membersection{wxHtmlParser::AddTag}\label{wxhtmlparseraddtag}
+
+\func{void}{AddTag}{\param{const wxHtmlTag\& }{tag}}
+
+This may (and may not) be overwritten in derived class.
+
+This method is called each time new tag is about to be added. 
+{\it tag} contains information about the tag. (See \helpref{wxHtmlTag}{wxhtmltag}
+for details.)
+
+Default (wxHtmlParser) behaviour is this:
+First it finds a handler capable of handling this tag and then it calls
+handler's HandleTag method.
+
+\membersection{wxHtmlParser::AddTagHandler}\label{wxhtmlparseraddtaghandler}
+
+\func{virtual void}{AddTagHandler}{\param{wxHtmlTagHandler }{*handler}}
+
+Adds handler to the internal list (\& hash table) of handlers. This
+method should not be called directly by user but rather by derived class'
+constructor.
+
+This adds the handler to this {\bf instance} of wxHtmlParser, not to
+all objects of this class! (Static front-end to AddTagHandler is provided
+by wxHtmlWinParser).
+
+All handlers are deleted on object deletion.
+
+\membersection{wxHtmlParser::AddText}\label{wxhtmlparseraddword}
+
+\func{virtual void}{AddWord}{\param{const char* }{txt}}
+
+Must be overwritten in derived class.
+
+This method is called by \helpref{DoParsing}{wxhtmlparserdoparsing}
+each time a part of text is parsed. {\it txt} is NOT only one word, it is
+substring of input. It is not formatted or preprocessed (so white spaces are
+unmodified).
+
+\membersection{wxHtmlParser::DoParsing}\label{wxhtmlparserdoparsing}
+
+\func{void}{DoParsing}{\param{int }{begin\_pos}, \param{int }{end\_pos}}
+
+\func{void}{DoParsing}{\void}
+
+Parses the m\_Source from begin\_pos to end\_pos-1.
+(in noparams version it parses whole m\_Source)
+
+\membersection{wxHtmlParser::DoneParser}\label{wxhtmlparserdoneparser}
+
+\func{virtual void}{DoneParser}{\void}
+
+This must be called after DoParsing().
+
+\membersection{wxHtmlParser::GetFS}\label{wxhtmlparsergetfs}
+
+\constfunc{wxFileSystem*}{GetFS}{\void}
+
+Returns pointer to the file system. Because each tag handler has
+reference to it is parent parser it can easily request the file by
+calling
+
+\begin{verbatim}
+wxFSFile *f = m_Parser -> GetFS() -> OpenFile("image.jpg");
+\end{verbatim}
+
+\membersection{wxHtmlParser::GetProduct}\label{wxhtmlparsergetproduct}
+
+\func{virtual wxObject*}{GetProduct}{\void}
+
+Returns product of parsing. Returned value is result of parsing
+of the document. The type of this result depends on internal
+representation in derived parser (but it must be derived from wxObject!).
+
+See wxHtmlWinParser for details.
+
+\membersection{wxHtmlParser::GetSource}\label{wxhtmlparsergetsource}
+
+\func{wxString*}{GetSource}{\void}
+
+Returns pointer to the source being parsed.
+
+
+\membersection{wxHtmlParser::InitParser}\label{wxhtmlparserinitparser}
+
+\func{virtual void}{InitParser}{\param{const wxString\& }{source}}
+
+Setups the parser for parsing the {\it source} string. (Should be overridden
+in derived class)
+
+\membersection{wxHtmlParser::OpenURL}\label{wxhtmlparseropenurl}
+
+\func{virtual wxFSFile*}{OpenURL}{\param{wxHtmlURLType }{type}, \param{const wxString\& }{url}}
+
+Opens given URL and returns {\tt wxFSFile} object that can be used to read data
+from it. This method may return NULL in one of two cases: either the URL doesn't
+point to any valid resource or the URL is blocked by overridden implementation
+of {\it OpenURL} in derived class.
+
+\wxheading{Parameters}
+
+\docparam{type}{Indicates type of the resource. Is one of
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf wxHTML\_URL\_PAGE}}{Opening a HTML page.}
+\twocolitem{{\bf wxHTML\_URL\_IMAGE}}{Opening an image.}
+\twocolitem{{\bf wxHTML\_URL\_OTHER}}{Opening a resource that doesn't fall into
+any other category.}
+\end{twocollist}}
+
+\docparam{url}{URL being opened.}
+
+\wxheading{Notes}
+
+Always use this method in tag handlers instead of {\tt GetFS()->OpenFile()} 
+because it can block the URL and is thus more secure.
+
+Default behaviour is to call \helpref{wxHtmlWindow::OnOpeningURL}{wxhtmlwindowonopeningurl}
+of the associated wxHtmlWindow object (which may decide to block the URL or
+redirect it to another one),if there's any, and always open the URL if the 
+parser is not used with wxHtmlWindow.
+
+Returned {\tt wxFSFile} object is not guaranteed to point to {\it url}, it might
+have been redirected!
+
+\membersection{wxHtmlParser::Parse}\label{wxhtmlparserparse}
+
+\func{wxObject*}{Parse}{\param{const wxString\& }{source}}
+
+Proceeds parsing of the document. This is end-user method. You can simply
+call it when you need to obtain parsed output (which is parser-specific)
+
+The method does these things:
+
+\begin{enumerate}\itemsep=0pt
+\item calls \helpref{InitParser(source)}{wxhtmlparserinitparser}
+\item calls \helpref{DoParsing}{wxhtmlparserdoparsing}
+\item calls \helpref{GetProduct}{wxhtmlparsergetproduct}
+\item calls \helpref{DoneParser}{wxhtmlparserdoneparser}
+\item returns value returned by GetProduct
+\end{enumerate}
+
+You shouldn't use InitParser, DoParsing, GetProduct or DoneParser directly.
+
+
+
+\membersection{wxHtmlParser::PushTagHandler}\label{wxhtmlparserpushtaghandler}
+
+\func{void}{PushTagHandler}{\param{wxHtmlTagHandler* }{handler}, \param{wxString }{tags}}
+
+Forces the handler to handle additional tags 
+(not returned by \helpref{GetSupportedTags}{wxhtmltaghandlergetsupportedtags}). 
+The handler should already be added to this parser.
+
+\wxheading{Parameters}
+
+\docparam{handler}{the handler}
+\docparam{tags}{List of tags (in same format as GetSupportedTags's return value). The parser
+will redirect these tags to {\it handler} (until call to \helpref{PopTagHandler}{wxhtmlparserpoptaghandler}). }
+
+\wxheading{Example}
+
+Imagine you want to parse following pseudo-html structure:
+
+\begin{verbatim}
+<myitems>
+    <param name="one" value="1">
+    <param name="two" value="2">
+</myitems>
+
+<execute>
+    <param program="text.exe">
+</execute>
+\end{verbatim}
+
+It is obvious that you cannot use only one tag handler for <param> tag.
+Instead you must use context-sensitive handlers for <param> inside <myitems>
+and <param> inside <execute>.        
+
+This is the preferred solution:
+
+\begin{verbatim}
+TAG_HANDLER_BEGIN(MYITEM, "MYITEMS")
+    TAG_HANDLER_PROC(tag)
+    {
+        // ...something...
+
+        m_Parser -> PushTagHandler(this, "PARAM");
+        ParseInner(tag);
+        m_Parser -> PopTagHandler();
+
+        // ...something...
+     }
+TAG_HANDLER_END(MYITEM)
+\end{verbatim}
+
+
+\membersection{wxHtmlParser::PopTagHandler}\label{wxhtmlparserpoptaghandler}
+
+\func{void}{PopTagHandler}{\void}
+
+Restores parser's state before last call to 
+\helpref{PushTagHandler}{wxhtmlparserpushtaghandler}.
+
+
+\membersection{wxHtmlParser::SetFS}\label{wxhtmlparsersetfs}
+
+\func{void}{SetFS}{\param{wxFileSystem }{*fs}}
+
+Sets the virtual file system that will be used to request additional
+files. (For example {\tt <IMG>} tag handler requests wxFSFile with the
+image data.)
+
+\membersection{wxHtmlParser::StopParsing}\label{wxhtmlparserstopparsing}
+
+\func{void}{StopParsing}{\void}
+
+Call this function to interrupt parsing from a tag handler. No more tags
+will be parsed afterward. This function may only be called from
+\helpref{wxHtmlParser::Parse}{wxhtmlparserparse} or any function called
+by it (i.e. from tag handlers).
+

docs/latex/wx/htprint.tex

@@ -0,0 +1,106 @@
+%
+% automatically generated by HelpGen from
+% htmprint.h at 17/Oct/99 12:48:02
+%
+
+
+\section{\class{wxHtmlPrintout}}\label{wxhtmlprintout}
+
+This class serves as printout class for HTML documents.
+
+\wxheading{Derived from}
+
+\helpref{wxPrintout}{wxprintout}
+
+
+\wxheading{Include files}
+
+<wx/html/htmprint.h>
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+
+\membersection{wxHtmlPrintout::wxHtmlPrintout}\label{wxhtmlprintoutwxhtmlprintout}
+
+\func{}{wxHtmlPrintout}{\param{const wxString\& }{title = "Printout"}}
+
+Constructor. 
+
+
+\membersection{wxHtmlPrintout::SetFonts}\label{wxhtmlprintoutsetfonts}
+
+\func{void}{SetFonts}{\param{wxString }{normal\_face}, \param{wxString }{fixed\_face}, \param{const int }{*sizes = NULL}}
+
+Sets fonts. See \helpref{wxHtmlWindow::SetFonts}{wxhtmlwindowsetfonts} for
+detailed description.
+
+\membersection{wxHtmlPrintout::SetFooter}\label{wxhtmlprintoutsetfooter}
+
+\func{void}{SetFooter}{\param{const wxString\& }{footer}, \param{int }{pg = wxPAGE\_ALL}}
+
+Sets page footer.
+
+\wxheading{Parameters}
+
+\docparam{footer}{HTML text to be used as footer. You can use macros in it:
+\begin{itemize}
+\item @PAGENUM@ is replaced by page number
+\item @PAGESCNT@ is replaced by total number of pages
+\end{itemize}
+}
+
+\docparam{pg}{one of wxPAGE\_ODD, wxPAGE\_EVEN and wxPAGE\_ALL constants.}
+
+
+\membersection{wxHtmlPrintout::SetHeader}\label{wxhtmlprintoutsetheader}
+
+\func{void}{SetHeader}{\param{const wxString\& }{header}, \param{int }{pg = wxPAGE\_ALL}}
+
+Sets page header.
+
+\wxheading{Parameters}
+
+\docparam{header}{HTML text to be used as header. You can use macros in it:
+\begin{itemize}
+\item @PAGENUM@ is replaced by page number
+\item @PAGESCNT@ is replaced by total number of pages
+\end{itemize}
+}
+
+\docparam{pg}{one of wxPAGE\_ODD, wxPAGE\_EVEN and wxPAGE\_ALL constants.}
+
+
+\membersection{wxHtmlPrintout::SetHtmlFile}\label{wxhtmlprintoutsethtmlfile}
+
+\func{void}{SetHtmlFile}{\param{const wxString\& }{htmlfile}}
+
+Prepare the class for printing this HTML {\bf file}. The file may be located on 
+any virtual file system or it may be normal file.
+
+
+
+\membersection{wxHtmlPrintout::SetHtmlText}\label{wxhtmlprintoutsethtmltext}
+
+\func{void}{SetHtmlText}{\param{const wxString\& }{html}, \param{const wxString\& }{basepath = wxEmptyString}, \param{bool }{isdir = true}}
+
+Prepare the class for printing this HTML text.
+
+\wxheading{Parameters}
+
+\docparam{html}{HTML text. (NOT file!)}
+
+\docparam{basepath}{base directory (html string would be stored there if it was in
+file). It is used to determine path for loading images, for example.}
+
+\docparam{isdir}{false if basepath is filename, true if it is directory name
+(see \helpref{wxFileSystem}{wxfilesystem} for detailed explanation)}
+
+
+
+\membersection{wxHtmlPrintout::SetMargins}\label{wxhtmlprintoutsetmargins}
+
+\func{void}{SetMargins}{\param{float }{top = 25.2}, \param{float }{bottom = 25.2}, \param{float }{left = 25.2}, \param{float }{right = 25.2}, \param{float }{spaces = 5}}
+
+Sets margins in millimeters. Defaults to 1 inch for margins and 0.5cm for space
+between text and header and/or footer
+

docs/latex/wx/httag.tex

@@ -0,0 +1,194 @@
+%
+% automatically generated by HelpGen from
+% htmltag.tex at 14/Mar/99 20:13:37
+%
+
+\section{\class{wxHtmlTag}}\label{wxhtmltag}
+
+This class represents a single HTML tag. 
+It is used by \helpref{tag handlers}{handlers}.
+
+\wxheading{Derived from}
+
+wxObject
+
+\wxheading{Include files}
+
+<wx/html/htmltag.h>
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxHtmlTag::wxHtmlTag}\label{wxhtmltagwxhtmltag}
+
+\func{}{wxHtmlTag}{\param{const wxString\& }{source}, \param{int }{pos}, \param{int }{end\_pos}, \param{wxHtmlTagsCache* }{cache}}
+
+Constructor. You will probably never have to construct a wxHtmlTag object
+yourself. Feel free to ignore the constructor parameters.
+Have a look at src/html/htmlpars.cpp if you're interested in creating it.
+
+\membersection{wxHtmlTag::GetAllParams}\label{wxhtmltaggetallparams}
+
+\constfunc{const wxString\&}{GetAllParams}{\void}
+
+Returns a string containing all parameters.
+
+Example : tag contains {\tt <FONT SIZE=+2 COLOR="\#000000">}. Call to
+tag.GetAllParams() would return {\tt SIZE=+2 COLOR="\#000000"}.
+
+
+\membersection{wxHtmlTag::GetBeginPos}\label{wxhtmltaggetbeginpos}
+
+\constfunc{int}{GetBeginPos}{\void}
+
+Returns beginning position of the text {\it between} this tag and paired
+ending tag. 
+See explanation (returned position is marked with `|'):
+
+\begin{verbatim}
+bla bla bla <MYTAG> bla bla internal text</MYTAG> bla bla
+                   |
+\end{verbatim}
+
+
+\membersection{wxHtmlTag::GetEndPos1}\label{wxhtmltaggetendpos1}
+
+\constfunc{int}{GetEndPos1}{\void}
+
+Returns ending position of the text {\it between} this tag and paired
+ending tag.
+See explanation (returned position is marked with `|'):
+
+\begin{verbatim}
+bla bla bla <MYTAG> bla bla internal text</MYTAG> bla bla
+                                        |
+\end{verbatim}
+
+
+\membersection{wxHtmlTag::GetEndPos2}\label{wxhtmltaggetendpos2}
+
+\constfunc{int}{GetEndPos2}{\void}
+
+Returns ending position 2 of the text {\it between} this tag and paired
+ending tag.
+See explanation (returned position is marked with `|'):
+
+\begin{verbatim}
+bla bla bla <MYTAG> bla bla internal text</MYTAG> bla bla
+                                               |
+\end{verbatim}
+
+\membersection{wxHtmlTag::GetName}\label{wxhtmltaggetname}
+
+\constfunc{wxString}{GetName}{\void}
+
+Returns tag's name. The name is always in uppercase and it doesn't contain
+'<' or '/' characters. (So the name of {\tt <FONT SIZE=+2>} tag is "FONT"
+and name of {\tt </table>} is "TABLE")
+
+
+\membersection{wxHtmlTag::GetParam}\label{wxhtmltaggetparam}
+
+\constfunc{wxString}{GetParam}{\param{const wxString\& }{par}, \param{bool }{with\_commas = false}}
+
+Returns the value of the parameter. You should check whether the
+parameter exists or not (use \helpref{HasParam}{wxhtmltaghasparam}) first.
+
+\wxheading{Parameters}
+
+\docparam{par}{The parameter's name.}
+
+\docparam{with\_commas}{true if you want to get commas as well. See example.}
+
+\wxheading{Example}
+
+\begin{verbatim}
+...
+/* you have wxHtmlTag variable tag which is equal to
+   HTML tag <FONT SIZE=+2 COLOR="#0000FF"> */
+dummy = tag.GetParam("SIZE");
+   // dummy == "+2"
+dummy = tag.GetParam("COLOR");
+   // dummy == "#0000FF"
+dummy = tag.GetParam("COLOR", true);
+   // dummy == "\"#0000FF\"" -- see the difference!!
+\end{verbatim}
+
+\membersection{wxHtmlTag::GetParamAsColour}\label{wxhtmltaggetparamascolour}
+
+\constfunc{bool}{GetParamAsColour}{\param{const wxString\& }{par}, \param{wxColour *}{clr}}
+
+Interprets tag parameter {\it par} as colour specification and saves its value
+into wxColour variable pointed by {\it clr}.
+
+Returns true on success and false if {\it par} is not colour specification or
+if the tag has no such parameter.
+
+\membersection{wxHtmlTag::GetParamAsInt}\label{wxhtmltaggetparamasint}
+
+\constfunc{bool}{GetParamAsInt}{\param{const wxString\& }{par}, \param{int *}{value}}
+
+Interprets tag parameter {\it par} as an integer and saves its value
+into int variable pointed by {\it value}.
+
+Returns true on success and false if {\it par} is not an integer or
+if the tag has no such parameter.
+
+\membersection{wxHtmlTag::HasEnding}\label{wxhtmltaghasending}
+
+\constfunc{bool}{HasEnding}{\void}
+
+Returns true if this tag is paired with ending tag, false otherwise.
+
+See the example of HTML document:
+
+\begin{verbatim}
+<html><body>
+Hello<p>
+How are you?
+<p align=center>This is centered...</p>
+Oops<br>Oooops!
+</body></html>
+\end{verbatim}
+
+In this example tags HTML and BODY have ending tags, first P and BR 
+doesn't have ending tag while the second P has. The third P tag (which
+is ending itself) of course doesn't have ending tag.
+
+\membersection{wxHtmlTag::HasParam}\label{wxhtmltaghasparam}
+
+\constfunc{bool}{HasParam}{\param{const wxString\& }{par}}
+
+Returns true if the tag has a parameter of the given name. 
+Example : {\tt <FONT SIZE=+2 COLOR="\#FF00FF">} has two parameters named
+"SIZE" and "COLOR".
+
+\wxheading{Parameters}
+
+\docparam{par}{the parameter you're looking for.}
+
+\membersection{wxHtmlTag::IsEnding}\label{wxhtmltagisending}
+
+\constfunc{bool}{IsEnding}{\void}
+
+Returns true if this tag is ending one.
+({\tt </FONT>} is ending tag, {\tt <FONT>} is not)
+
+\membersection{wxHtmlTag::ScanParam}\label{wxhtmltagscanparam}
+
+\constfunc{wxString}{ScanParam}{\param{const wxString\& }{par}, \param{const wxChar *}{format}, \param{void *}{value}}
+
+This method scans the given parameter. Usage is exactly the same as sscanf's 
+usage except that you don't pass a string but a parameter name as the first
+argument
+and you can only retrieve one value (i.e. you can use only one "\%" element
+in {\it format}).
+
+
+\wxheading{Parameters}
+
+\docparam{par}{The name of the tag you want to query}
+
+\docparam{format}{scanf()-like format string.}
+
+\docparam{value}{pointer to a variable to store the value in }
+

docs/latex/wx/httaghnd.tex

@@ -0,0 +1,91 @@
+%
+% automatically generated by HelpGen from
+% htmltaghandler.tex at 18/Mar/99 19:20:29
+%
+
+\section{\class{wxHtmlTagHandler}}\label{wxhtmltaghandler}
+
+\wxheading{Derived from}
+
+\helpref{wxObject}{wxobject}
+
+\wxheading{Include files}
+
+<wx/html/htmlpars.h>
+
+\wxheading{See Also}
+
+\helpref{Overview}{handlers},
+\helpref{wxHtmlTag}{wxhtmltag}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxHtmlTagHandler::m\_Parser}\label{wxhtmltaghandlermparser}
+
+{\bf wxHtmlParser* m\_Parser}
+
+This attribute is used to access parent parser. It is protected so that
+it can't be accessed by user but can be accessed from derived classes.
+
+\membersection{wxHtmlTagHandler::wxHtmlTagHandler}\label{wxhtmltaghandlerwxhtmltaghandler}
+
+\func{}{wxHtmlTagHandler}{\void}
+
+Constructor.
+
+\membersection{wxHtmlTagHandler::GetSupportedTags}\label{wxhtmltaghandlergetsupportedtags}
+
+\func{virtual wxString}{GetSupportedTags}{\void}
+
+Returns list of supported tags. The list is in uppercase and tags
+are delimited by ','. Example : {\tt "I,B,FONT,P" }
+
+\membersection{wxHtmlTagHandler::HandleTag}\label{wxhtmltaghandlerhandletag}
+
+\func{virtual bool}{HandleTag}{\param{const wxHtmlTag\& }{tag}}
+
+This is the core method of each handler. It is called each time
+one of supported tags is detected. {\it tag} contains all necessary
+info (see \helpref{wxHtmlTag}{wxhtmltag} for details).
+
+\wxheading{Return value}
+
+true if \helpref{ParseInner}{wxhtmltaghandlerparseinner} was called,
+false otherwise.
+
+\wxheading{Example}
+
+\begin{verbatim}
+bool MyHandler::HandleTag(const wxHtmlTag& tag)
+{
+    ...
+    // change state of parser (e.g. set bold face)
+    ParseInner(tag);
+    ...
+    // restore original state of parser
+}
+\end{verbatim}
+
+You shouldn't call ParseInner if the tag is not paired with an ending one.
+
+\membersection{wxHtmlTagHandler::ParseInner}\label{wxhtmltaghandlerparseinner}
+
+\func{void}{ParseInner}{\param{const wxHtmlTag\& }{tag}}
+
+This method calls parser's \helpref{DoParsing}{wxhtmlparserdoparsing} method
+for the string between this tag and the paired ending tag:
+
+\begin{verbatim}
+...<A HREF="x.htm">Hello, world!</A>...
+\end{verbatim}
+
+In this example, a call to ParseInner (with {\it tag} pointing to A tag)
+will parse 'Hello, world!'.
+
+\membersection{wxHtmlTagHandler::SetParser}\label{wxhtmltaghandlersetparser}
+
+\func{virtual void}{SetParser}{\param{wxHtmlParser }{*parser}}
+
+Assigns {\it parser} to this handler. Each {\bf instance} of handler 
+is guaranteed to be called only from the parser.
+

docs/latex/wx/httagmod.tex

@@ -0,0 +1,43 @@
+%
+% automatically generated by HelpGen from
+% htmltagsmodule.tex at 14/Mar/99 20:13:37
+
+\section{\class{wxHtmlTagsModule}}\label{wxhtmltagsmodule}
+
+This class provides easy way of filling wxHtmlWinParser's table of
+tag handlers. It is used almost exclusively together with the set of
+\helpref{TAGS\_MODULE\_* macros}{handlers}
+
+\wxheading{Derived from}
+
+\helpref{wxModule}{wxmodule}
+
+\wxheading{Include files}
+
+<wx/html/winpars.h>
+
+\wxheading{See Also}
+
+\helpref{Tag Handlers}{handlers},
+\helpref{wxHtmlTagHandler}{wxhtmltaghandler},
+\helpref{wxHtmlWinTagHandler}{wxhtmlwintaghandler},
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxHtmlTagsModule::FillHandlersTable}\label{wxhtmltagsmodulefillhandlerstable}
+
+\func{virtual void}{FillHandlersTable}{\param{wxHtmlWinParser }{*parser}}
+
+You must override this method. In most common case its body consists
+only of lines of the following type:
+
+\begin{verbatim}
+parser -> AddTagHandler(new MyHandler);
+\end{verbatim}
+
+I recommend using the {\bf TAGS\_MODULE\_*} macros.
+
+\wxheading{Paremeters}
+
+\docparam{parser}{Pointer to the parser that requested tables filling.}
+

docs/latex/wx/http.tex

@@ -0,0 +1,70 @@
+\section{\class{wxHTTP}}\label{wxhttp}
+
+\wxheading{Derived from}
+
+\helpref{wxProtocol}{wxprotocol}
+
+\wxheading{Include files}
+
+<wx/protocol/http.h>
+
+\wxheading{See also}
+
+\helpref{wxSocketBase}{wxsocketbase}, \helpref{wxURL}{wxurl}
+
+% ----------------------------------------------------------------------------
+% Members
+% ----------------------------------------------------------------------------
+
+% ----------------------------------------------------------------------------
+\membersection{wxHTTP::GetInputStream}\label{wxhttpgetinputstream}
+
+\func{wxInputStream *}{GetInputStream}{\param{const wxString\&}{ path}}
+
+Creates a new input stream on the the specified path. You can use all except the seek
+functionality of wxStream. Seek isn't available on all streams. For example,
+http or ftp streams doesn't deal with it. Other functions like Tell and SeekI
+for this sort of stream.
+You will be notified when the EOF is reached by an error.
+
+\wxheading{Note}
+
+You can know the size of the file you are getting using \helpref{wxStreamBase::GetSize()}{wxstreambasegetsize}.
+But there is a limitation: as HTTP servers aren't obliged to pass the size of
+the file, in some case, you will be returned 0xfffffff by GetSize(). In these
+cases, you should use the value returned by \helpref{wxInputStream::LastRead()}{wxinputstreamlastread}:
+this value will be 0 when the stream is finished.
+
+\wxheading{Return value}
+
+Returns the initialized stream. You will have to delete it yourself once you
+don't use it anymore. The destructor closes the network connection.
+The next time you will try to get a file the network connection will have
+to be reestablished: but you don't have to take care of this wxHTTP reestablishes it automatically.
+
+\wxheading{See also}
+
+\helpref{wxInputStream}{wxinputstream}
+
+% ----------------------------------------------------------------------------
+
+\membersection{wxHTTP::SetHeader}
+
+\func{void}{SetHeader}{\param{const wxString\&}{ header}, \param{const wxString\&}{ h\_data}}
+
+It sets data of a field to be sent during the next request to the HTTP server. The field
+name is specified by {\it header} and the content by {\it h\_data}.
+This is a low level function and it assumes that you know what you are doing.
+
+\membersection{wxHTTP::GetHeader}
+
+\func{wxString}{GetHeader}{\param{const wxString\&}{ header}}
+
+Returns the data attached with a field whose name is specified by {\it header}.
+If the field doesn't exist, it will return an empty string and not a NULL string.
+
+\wxheading{Note}
+
+The header is not case-sensitive: I mean that "CONTENT-TYPE" and "content-type" 
+represent the same header.
+

docs/latex/wx/htwidget.tex

@@ -0,0 +1,37 @@
+%
+% automatically generated by HelpGen from
+% htmlcell.h at 14/Apr/99 20:12:40
+%
+
+\section{\class{wxHtmlWidgetCell}}\label{wxhtmlwidgetcell}
+
+wxHtmlWidgetCell is a class that provides a connection between HTML cells and widgets (an object derived
+from wxWindow). You can use it to display things like forms, input boxes etc. in an HTML window.
+
+wxHtmlWidgetCell takes care of resizing and moving window.
+
+\wxheading{Derived from}
+
+\helpref{wxHtmlCell}{wxhtmlcell}
+
+\wxheading{Include files}
+
+<wx/html/htmlcell.h>
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxHtmlWidgetCell::wxHtmlWidgetCell}\label{wxhtmlwidgetcellwxhtmlwidgetcell}
+
+\func{}{wxHtmlWidgetCell}{\param{wxWindow* }{wnd}, \param{int }{w = 0}}
+
+Constructor.
+
+\wxheading{Parameters}
+
+\docparam{wnd}{Connected window. It is parent window {\bf must} be the wxHtmlWindow object within
+which it is displayed!}
+
+\docparam{w}{Floating width. If non-zero width of {\it wnd} window is adjusted so that it is
+always {\it w} percents of parent container's width. (For example w = 100 means that the window
+will always have same width as parent container)}
+

docs/latex/wx/htwindow.tex

@@ -0,0 +1,383 @@
+%
+% automatically generated by HelpGen from
+% htmlwindow.tex at 14/Mar/99 20:13:37
+%
+
+\section{\class{wxHtmlWindow}}\label{wxhtmlwindow}
+
+wxHtmlWindow is probably the only class you will directly use
+unless you want to do something special (like adding new tag
+handlers or MIME filters).
+
+The purpose of this class is to display HTML pages (either local
+file or downloaded via HTTP protocol) in a window. The width
+of the window is constant - given in the constructor - and virtual height
+is changed dynamically depending on page size.
+Once the window is created you can set its content by calling 
+\helpref{SetPage(text)}{wxhtmlwindowsetpage},
+\helpref{LoadPage(filename)}{wxhtmlwindowloadpage} or
+\helpref{LoadFile}{wxhtmlwindowloadfile}.
+
+\wxheading{Note}
+
+wxHtmlWindow uses the \helpref{wxImage}{wximage} class for displaying images.
+Don't forget to initialize all image formats you need before loading any page!
+(See \helpref{wxInitAllImageHandlers}{wxinitallimagehandlers} and
+\helpref{wxImage::AddHandler}{wximageaddhandler}.)
+
+\wxheading{Derived from}
+
+\helpref{wxScrolledWindow}{wxscrolledwindow}
+
+\wxheading{Include files}
+
+<wx/html/htmlwin.h>
+
+\membersection{wxHtmlWindow::wxHtmlWindow}\label{wxhtmlwindowwxhtmlwindow}
+
+\func{}{wxHtmlWindow}{\void}
+
+Default constructor.
+
+\func{}{wxHtmlWindow}{\param{wxWindow }{*parent}, \param{wxWindowID }{id = -1}, \param{const wxPoint\& }{pos = wxDefaultPosition}, \param{const wxSize\& }{size = wxDefaultSize}, \param{long }{style = wxHW\_SCROLLBAR\_AUTO}, \param{const wxString\& }{name = "htmlWindow"}}
+
+Constructor. The parameters are the same as for the \helpref{wxScrolledWindow}{wxscrolledwindow} constructor.
+
+\wxheading{Parameters}
+
+\docparam{style}{wxHW\_SCROLLBAR\_NEVER,  or wxHW\_SCROLLBAR\_AUTO. 
+Affects the appearance of vertical scrollbar in the window.}
+
+\membersection{wxHtmlWindow::AddFilter}\label{wxhtmlwindowaddfilter}
+
+\func{static void}{AddFilter}{\param{wxHtmlFilter }{*filter}}
+
+Adds \helpref{input filter}{filters} to the static list of available
+filters. These filters are present by default:
+
+\begin{itemize}\itemsep=0pt
+\item {\tt text/html} MIME type
+\item {\tt image/*} MIME types
+\item Plain Text filter (this filter is used if no other filter matches)
+\end{itemize}
+
+\membersection{wxHtmlWindow::AppendToPage}\label{wxhtmlwindowappendtopage}
+
+\func{bool}{AppendToPage}{\param{const wxString\& }{source}}
+
+Appends HTML fragment to currently displayed text and refreshes the window. 
+
+\wxheading{Parameters}
+
+\docparam{source}{HTML code fragment}
+
+\wxheading{Return value}
+
+false if an error occurred, true otherwise.
+
+\membersection{wxHtmlWindow::GetInternalRepresentation}\label{wxhtmlwindowgetinternalrepresentation}
+
+\constfunc{wxHtmlContainerCell*}{GetInternalRepresentation}{\void}
+
+Returns pointer to the top-level container.
+
+See also: \helpref{Cells Overview}{cells}, 
+\helpref{Printing Overview}{printing}
+
+\membersection{wxHtmlWindow::GetOpenedAnchor}\label{wxhtmlwindowgetopenedanchor}
+
+\func{wxString}{GetOpenedAnchor}{\void}
+
+Returns anchor within currently opened page
+(see \helpref{GetOpenedPage}{wxhtmlwindowgetopenedpage}). 
+If no page is opened or if the displayed page wasn't
+produced by call to LoadPage, empty string is returned.
+
+
+\membersection{wxHtmlWindow::GetOpenedPage}\label{wxhtmlwindowgetopenedpage}
+
+\func{wxString}{GetOpenedPage}{\void}
+
+Returns full location of the opened page. If no page is opened or if the displayed page wasn't
+produced by call to LoadPage, empty string is returned.
+
+\membersection{wxHtmlWindow::GetOpenedPageTitle}\label{wxhtmlwindowgetopenedpagetitle}
+
+\func{wxString}{GetOpenedPageTitle}{\void}
+
+Returns title of the opened page or wxEmptyString if current page does not contain {\tt <TITLE>} tag.
+
+\membersection{wxHtmlWindow::GetRelatedFrame}\label{wxhtmlwindowgetrelatedframe}
+
+\constfunc{wxFrame*}{GetRelatedFrame}{\void}
+
+Returns the related frame.
+
+\membersection{wxHtmlWindow::HistoryBack}\label{wxhtmlwindowhistoryback}
+
+\func{bool}{HistoryBack}{\void}
+
+Moves back to the previous page. (each page displayed using 
+\helpref{LoadPage}{wxhtmlwindowloadpage} is stored in history list.)
+
+\membersection{wxHtmlWindow::HistoryCanBack}\label{wxhtmlwindowhistorycanback}
+
+\func{bool}{HistoryCanBack}{\void}
+
+Returns true if it is possible to go back in the history (i.e. HistoryBack()
+won't fail).
+
+\membersection{wxHtmlWindow::HistoryCanForward}\label{wxhtmlwindowhistorycanforward}
+
+\func{bool}{HistoryCanForward}{\void}
+
+Returns true if it is possible to go forward in the history (i.e. HistoryBack()
+won't fail).
+
+
+\membersection{wxHtmlWindow::HistoryClear}\label{wxhtmlwindowhistoryclear}
+
+\func{void}{HistoryClear}{\void}
+
+Clears history.
+
+\membersection{wxHtmlWindow::HistoryForward}\label{wxhtmlwindowhistoryforward}
+
+\func{bool}{HistoryForward}{\void}
+
+Moves to next page in history.
+
+\membersection{wxHtmlWindow::LoadFile}\label{wxhtmlwindowloadfile}
+
+\func{virtual bool}{LoadFile}{\param{const wxFileName\& }{filename}}
+
+Loads HTML page from file and displays it.
+
+\wxheading{Return value}
+
+false if an error occurred, true otherwise
+
+\wxheading{See also}
+
+\helpref{LoadPage}{wxhtmlwindowloadpage}
+
+\membersection{wxHtmlWindow::LoadPage}\label{wxhtmlwindowloadpage}
+
+\func{virtual bool}{LoadPage}{\param{const wxString\& }{location}}
+
+Unlike SetPage this function first loads HTML page from {\it location} 
+and then displays it. See example:
+
+\begin{verbatim}
+htmlwin->LoadPage("help/myproject/index.htm");
+\end{verbatim}
+
+\wxheading{Parameters}
+
+\docparam{location}{The address of document. See \helpref{wxFileSystem}{wxfilesystem} for details on address format and behaviour of "opener".}
+
+\wxheading{Return value}
+
+false if an error occurred, true otherwise
+
+\wxheading{See also}
+
+\helpref{LoadFile}{wxhtmlwindowloadfile}
+
+\membersection{wxHtmlWindow::OnCellClicked}\label{wxhtmlwindowoncellclicked}
+
+\func{virtual void}{OnCellClicked}{\param{wxHtmlCell }{*cell}, \param{wxCoord }{x}, \param{wxCoord }{y}, \param{const wxMouseEvent\& }{event}}
+
+This method is called when a mouse button is clicked inside wxHtmlWindow.
+The default behaviour is to call 
+\helpref{OnLinkClicked}{wxhtmlwindowonlinkclicked} if the cell contains a
+hypertext link.
+
+\wxheading{Parameters}
+
+\docparam{cell}{The cell inside which the mouse was clicked, always a simple
+(i.e. non container) cell}
+
+\docparam{x, y}{The logical coordinates of the click point}
+
+\docparam{event}{The mouse event containing other information about the click}
+
+\membersection{wxHtmlWindow::OnCellMouseHover}\label{wxhtmlwindowoncellmousehover}
+
+\func{virtual void}{OnCellMouseHover}{\param{wxHtmlCell }{*cell}, \param{wxCoord }{x}, \param{wxCoord }{y}}
+
+This method is called when a mouse moves over an HTML cell.
+
+\wxheading{Parameters}
+
+\docparam{cell}{The cell inside which the mouse is currently, always a simple
+(i.e. non container) cell}
+
+\docparam{x, y}{The logical coordinates of the click point}
+
+\membersection{wxHtmlWindow::OnLinkClicked}\label{wxhtmlwindowonlinkclicked}
+
+\func{virtual void}{OnLinkClicked}{\param{const wxHtmlLinkInfo\& }{link}}
+
+Called when user clicks on hypertext link. Default behaviour is to call 
+\helpref{LoadPage}{wxhtmlwindowloadpage} and do nothing else.
+
+Also see \helpref{wxHtmlLinkInfo}{wxhtmllinkinfo}.
+
+\membersection{wxHtmlWindow::OnOpeningURL}\label{wxhtmlwindowonopeningurl}
+
+\func{virtual wxHtmlOpeningStatus}{OnOpeningURL}{\param{wxHtmlURLType }{type},\param{const wxString\& }{url}, \param{wxString *}{redirect}}
+
+Called when an URL is being opened (either when the user clicks on a link or
+an image is loaded). The URL will be opened only if OnOpeningURL returns 
+{\tt wxHTML\_OPEN}. This method is called by
+\helpref{wxHtmlParser::OpenURL}{wxhtmlparseropenurl}.
+You can override OnOpeningURL to selectively block some
+URLs (e.g. for security reasons) or to redirect them elsewhere. Default
+behaviour is to always return {\tt wxHTML\_OPEN}.
+
+\wxheading{Parameters}
+
+\docparam{type}{Indicates type of the resource. Is one of
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf wxHTML\_URL\_PAGE}}{Opening a HTML page.}
+\twocolitem{{\bf wxHTML\_URL\_IMAGE}}{Opening an image.}
+\twocolitem{{\bf wxHTML\_URL\_OTHER}}{Opening a resource that doesn't fall into
+any other category.}
+\end{twocollist}}
+
+\docparam{url}{URL being opened.}
+
+\docparam{redirect}{Pointer to wxString variable that must be filled with an
+URL if OnOpeningURL returns {\tt wxHTML\_REDIRECT}.}
+
+\wxheading{Return value}
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf wxHTML\_OPEN}}{Open the URL.}
+\twocolitem{{\bf wxHTML\_BLOCK}}{Deny access to the URL, \helpref{wxHtmlParser::OpenURL}{wxhtmlparseropenurl} will return NULL.}
+\twocolitem{{\bf wxHTML\_REDIRECT}}{Don't open {\it url}, redirect to another
+URL. OnOpeningURL must fill {\it *redirect} with the new URL. OnOpeningURL will
+be called again on returned URL.}
+\end{twocollist}
+
+\membersection{wxHtmlWindow::OnSetTitle}\label{wxhtmlwindowonsettitle}
+
+\func{virtual void}{OnSetTitle}{\param{const wxString\& }{title}}
+
+Called on parsing {\tt <TITLE>} tag.
+
+
+\membersection{wxHtmlWindow::ReadCustomization}\label{wxhtmlwindowreadcustomization}
+
+\func{virtual void}{ReadCustomization}{\param{wxConfigBase }{*cfg}, \param{wxString }{path = wxEmptyString}}
+
+This reads custom settings from wxConfig. It uses the path 'path'
+if given, otherwise it saves info into currently selected path.
+The values are stored in sub-path {\tt wxHtmlWindow}
+
+Read values: all things set by SetFonts, SetBorders.
+
+\wxheading{Parameters}
+
+\docparam{cfg}{wxConfig from which you want to read the configuration.}
+
+\docparam{path}{Optional path in config tree. If not given current path is used.}
+
+\membersection{wxHtmlWindow::SetBorders}\label{wxhtmlwindowsetborders}
+
+\func{void}{SetBorders}{\param{int }{b}}
+
+This function sets the space between border of window and HTML contents. See image:
+
+\helponly{\image{}{border.bmp}}
+
+\wxheading{Parameters}
+
+\docparam{b}{indentation from borders in pixels}
+
+\membersection{wxHtmlWindow::SetFonts}\label{wxhtmlwindowsetfonts}
+
+\func{void}{SetFonts}{\param{wxString }{normal\_face}, \param{wxString }{fixed\_face}, \param{const int }{*sizes = NULL}}
+
+This function sets font sizes and faces.
+
+\wxheading{Parameters}
+
+\docparam{normal\_face}{This is face name for normal (i.e. non-fixed) font. 
+It can be either empty string (then the default face is chosen) or
+platform-specific face name. Examples are "helvetica" under Unix or
+"Times New Roman" under Windows.}
+
+\docparam{fixed\_face}{The same thing for fixed face ( <TT>..</TT> )}
+
+\docparam{sizes}{This is an array of 7 items of {\it int} type.
+The values represent size of font with HTML size from -2 to +4
+( <FONT SIZE=-2> to <FONT SIZE=+4> ). Default sizes are used if {\it sizes}
+is NULL.}
+
+\wxheading{Defaults}
+
+Default font sizes are defined by constants wxHTML\_FONT\_SIZE\_1,
+wxHTML\_FONT\_SIZE\_2, ..., wxHTML\_FONT\_SIZE\_7. Note that they differ among
+platforms. Default face names are empty strings.
+
+\membersection{wxHtmlWindow::SetPage}\label{wxhtmlwindowsetpage}
+
+\func{bool}{SetPage}{\param{const wxString\& }{source}}
+
+Sets HTML page and display it. This won't {\bf load} the page!!
+It will display the {\it source}. See example:
+
+\begin{verbatim}
+htmlwin -> SetPage("<html><body>Hello, world!</body></html>");
+\end{verbatim}
+
+If you want to load a document from some location use 
+\helpref{LoadPage}{wxhtmlwindowloadpage} instead.
+
+\wxheading{Parameters}
+
+\docparam{source}{The HTML document source to be displayed.}
+
+\wxheading{Return value}
+
+false if an error occurred, true otherwise.
+
+\membersection{wxHtmlWindow::SetRelatedFrame}\label{wxhtmlwindowsetrelatedframe}
+
+\func{void}{SetRelatedFrame}{\param{wxFrame* }{frame}, \param{const wxString\& }{format}}
+
+Sets the frame in which page title will be displayed. {\it format} is format of
+frame title, e.g. "HtmlHelp : \%s". It must contain exactly one \%s. This
+\%s is substituted with HTML page title.
+
+\membersection{wxHtmlWindow::SetRelatedStatusBar}\label{wxhtmlwindowsetrelatedstatusbar}
+
+\func{void}{SetRelatedStatusBar}{\param{int }{bar}}
+
+{\bf After} calling \helpref{SetRelatedFrame}{wxhtmlwindowsetrelatedframe},
+this sets statusbar slot where messages will be displayed.
+(Default is -1 = no messages.)
+
+\wxheading{Parameters}
+
+\docparam{bar}{statusbar slot number (0..n)}
+
+
+\membersection{wxHtmlWindow::WriteCustomization}\label{wxhtmlwindowwritecustomization}
+
+\func{virtual void}{WriteCustomization}{\param{wxConfigBase }{*cfg}, \param{wxString }{path = wxEmptyString}}
+
+Saves custom settings into wxConfig. It uses the path 'path'
+if given, otherwise it saves info into currently selected path.
+Regardless of whether the path is given or not, the function creates sub-path 
+{\tt wxHtmlWindow}.
+
+Saved values: all things set by SetFonts, SetBorders.
+
+\wxheading{Parameters}
+
+\docparam{cfg}{wxConfig to which you want to save the configuration.}
+
+\docparam{path}{Optional path in config tree. If not given, the current path is used.}
+

docs/latex/wx/htwinhnd.tex

@@ -0,0 +1,31 @@
+%
+% automatically generated by HelpGen from
+% htmlwintaghandler.tex at 14/Mar/99 20:13:37
+%
+
+\section{\class{wxHtmlWinTagHandler}}\label{wxhtmlwintaghandler}
+
+This is basically wxHtmlTagHandler except that
+it is extended with protected member m\_WParser pointing to
+the wxHtmlWinParser object (value of this member is identical
+to wxHtmlParser's m\_Parser).
+
+\wxheading{Derived from}
+
+\helpref{wxHtmlTagHandler}{wxhtmltaghandler}
+
+\wxheading{Include files}
+
+<wx/html/winpars.h>
+
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxHtmlWinTagHandler::m\_WParser}\label{wxhtmlwintaghandlerwxhtmlwintaghandlermwparser}
+
+{\bf wxHtmlWinParser* m\_WParser}
+
+Value of this attribute is identical to value of m\_Parser. The only different
+is that m\_WParser points to wxHtmlWinParser object while m\_Parser
+points to wxHtmlParser object. (The same object, but overcast.)
+

docs/latex/wx/htwinprs.tex

@@ -0,0 +1,298 @@
+%
+% automatically generated by HelpGen from
+% htmlwinparser.tex at 14/Mar/99 20:13:37
+%
+
+\section{\class{wxHtmlWinParser}}\label{wxhtmlwinparser}
+
+This class is derived from \helpref{wxHtmlParser}{wxhtmlparser} and
+its main goal is to parse HTML input so that it can be displayed in
+\helpref{wxHtmlWindow}{wxhtmlwindow}. It uses a special 
+\helpref{wxHtmlWinTagHandler}{wxhtmlwintaghandler}.
+
+\wxheading{Notes}
+
+The product of parsing is a wxHtmlCell (resp. wxHtmlContainer) object.
+
+\wxheading{Derived from}
+
+\helpref{wxHtmlParser}{wxhtmlparser}
+
+\wxheading{Include files}
+
+<wx/html/winpars.h>
+
+\wxheading{See Also}
+
+\helpref{Handlers overview}{handlers}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxHtmlWinParser::wxHtmlWinParser}\label{wxhtmlwinparserwxhtmlwinparser}
+
+\func{}{wxHtmlWinParser}{\void}
+
+\func{}{wxHtmlWinParser}{\param{wxHtmlWindow }{*wnd}}
+
+Constructor. Don't use the default one, use constructor with
+{\it wnd} parameter ({\it wnd} is pointer to associated \helpref{wxHtmlWindow}{wxhtmlwindow})
+
+\membersection{wxHtmlWinParser::AddModule}\label{wxhtmlwinparseraddmodule}
+
+\func{static void}{AddModule}{\param{wxHtmlTagsModule }{*module}}
+
+Adds \helpref{module}{handlers} to the list of wxHtmlWinParser tag handler.
+
+\membersection{wxHtmlWinParser::CloseContainer}\label{wxhtmlwinparserclosecontainer}
+
+\func{wxHtmlContainerCell*}{CloseContainer}{\void}
+
+Closes the container, sets actual container to the parent one
+and returns pointer to it (see \helpref{Overview}{cells}).
+
+\membersection{wxHtmlWinParser::CreateCurrentFont}\label{wxhtmlwinparsercreatecurrentfont}
+
+\func{virtual wxFont*}{CreateCurrentFont}{\void}
+
+Creates font based on current setting (see 
+\helpref{SetFontSize}{wxhtmlwinparsersetfontsize}, 
+\helpref{SetFontBold}{wxhtmlwinparsersetfontbold}, 
+\helpref{SetFontItalic}{wxhtmlwinparsersetfontitalic}, 
+\helpref{SetFontFixed}{wxhtmlwinparsersetfontfixed}, 
+\helpref{SetFontUnderlined}{wxhtmlwinparsersetfontunderlined})
+and returns pointer to it.
+If the font was already created only a pointer is returned.
+
+
+\membersection{wxHtmlWinParser::GetActualColor}\label{wxhtmlwinparsergetactualcolor}
+
+\constfunc{const wxColour\&}{GetActualColor}{\void}
+
+Returns actual text colour.
+
+\membersection{wxHtmlWinParser::GetAlign}\label{wxhtmlwinparsergetalign}
+
+\constfunc{int}{GetAlign}{\void}
+
+Returns default horizontal alignment.
+
+\membersection{wxHtmlWinParser::GetCharHeight}\label{wxhtmlwinparsergetcharheight}
+
+\constfunc{int}{GetCharHeight}{\void}
+
+Returns (average) char height in standard font. It is used as DC-independent metrics.
+
+{\bf Note:} This function doesn't return the {\it actual} height. If you want to
+know the height of the current font, call {\tt GetDC -> GetCharHeight()}.
+
+\membersection{wxHtmlWinParser::GetCharWidth}\label{wxhtmlwinparsergetcharwidth}
+
+\constfunc{int}{GetCharWidth}{\void}
+
+Returns average char width in standard font. It is used as DC-independent metrics.
+
+{\bf Note:} This function doesn't return the {\it actual} width. If you want to
+know the height of the current font, call {\tt GetDC -> GetCharWidth()}
+
+\membersection{wxHtmlWinParser::GetContainer}\label{wxhtmlwinparsergetcontainer}
+
+\constfunc{wxHtmlContainerCell*}{GetContainer}{\void}
+
+Returns pointer to the currently opened container (see \helpref{Overview}{cells}).
+Common use:
+
+\begin{verbatim}
+m_WParser -> GetContainer() -> InsertCell(new ...);
+\end{verbatim}
+
+\membersection{wxHtmlWinParser::GetDC}\label{wxhtmlwinparsergetdc}
+
+\func{wxDC*}{GetDC}{\void}
+
+Returns pointer to the DC used during parsing.
+
+\membersection{wxHtmlWinParser::GetEncodingConverter}\label{wxhtmlwinparsergetencodingconverter}
+
+\constfunc{wxEncodingConverter *}{GetEncodingConverter}{\void}
+
+Returns \helpref{wxEncodingConverter}{wxencodingconverter} class used
+to do conversion between \helpref{input encoding}{wxhtmlwinparsergetinputencoding} 
+and \helpref{output encoding}{wxhtmlwinparsergetoutputencoding}.
+
+\membersection{wxHtmlWinParser::GetFontBold}\label{wxhtmlwinparsergetfontbold}
+
+\constfunc{int}{GetFontBold}{\void}
+
+Returns true if actual font is bold, false otherwise.
+
+\membersection{wxHtmlWinParser::GetFontFace}\label{wxhtmlwinparsergetfontface}
+
+\constfunc{wxString}{GetFontFace}{\void}
+
+Returns actual font face name.
+
+\membersection{wxHtmlWinParser::GetFontFixed}\label{wxhtmlwinparsergetfontfixed}
+
+\constfunc{int}{GetFontFixed}{\void}
+
+Returns true if actual font is fixed face, false otherwise.
+
+\membersection{wxHtmlWinParser::GetFontItalic}\label{wxhtmlwinparsergetfontitalic}
+
+\constfunc{int}{GetFontItalic}{\void}
+
+Returns true if actual font is italic, false otherwise.
+
+\membersection{wxHtmlWinParser::GetFontSize}\label{wxhtmlwinparsergetfontsize}
+
+\constfunc{int}{GetFontSize}{\void}
+
+Returns actual font size (HTML size varies from -2 to +4)
+
+\membersection{wxHtmlWinParser::GetFontUnderlined}\label{wxhtmlwinparsergetfontunderlined}
+
+\constfunc{int}{GetFontUnderlined}{\void}
+
+Returns true if actual font is underlined, false otherwise.
+
+\membersection{wxHtmlWinParser::GetInputEncoding}\label{wxhtmlwinparsergetinputencoding}
+
+\constfunc{wxFontEncoding}{GetInputEncoding}{\void}
+
+Returns input encoding.
+
+\membersection{wxHtmlWinParser::GetLink}\label{wxhtmlwinparsergetlink}
+
+\constfunc{const wxHtmlLinkInfo\&}{GetLink}{\void}
+
+Returns actual hypertext link. (This value has a non-empty 
+\helpref{Href}{wxhtmllinkinfogethref} string
+if the parser is between {\tt <A>} and {\tt </A>} tags,
+wxEmptyString otherwise.)
+
+\membersection{wxHtmlWinParser::GetLinkColor}\label{wxhtmlwinparsergetlinkcolor}
+
+\constfunc{const wxColour\&}{GetLinkColor}{\void}
+
+Returns the colour of hypertext link text.
+
+\membersection{wxHtmlWinParser::GetOutputEncoding}\label{wxhtmlwinparsergetoutputencoding}
+
+\constfunc{wxFontEncoding}{GetOutputEncoding}{\void}
+
+Returns output encoding, i.e. closest match to document's input encoding
+that is supported by operating system.
+
+\membersection{wxHtmlWinParser::GetWindow}\label{wxhtmlwinparsergetwindow}
+
+\func{wxHtmlWindow*}{GetWindow}{\void}
+
+Returns associated window (wxHtmlWindow). This may be NULL! (You should always
+test if it is non-NULL. For example {\tt TITLE} handler sets window
+title only if some window is associated, otherwise it does nothing)
+
+\membersection{wxHtmlWinParser::OpenContainer}\label{wxhtmlwinparseropencontainer}
+
+\func{wxHtmlContainerCell*}{OpenContainer}{\void}
+
+Opens new container and returns pointer to it (see \helpref{Overview}{cells}).
+
+\membersection{wxHtmlWinParser::SetActualColor}\label{wxhtmlwinparsersetactualcolor}
+
+\func{void}{SetActualColor}{\param{const wxColour\& }{clr}}
+
+Sets actual text colour. Note: this DOESN'T change the colour!
+You must create \helpref{wxHtmlColourCell}{wxhtmlcolourcell} yourself.
+
+\membersection{wxHtmlWinParser::SetAlign}\label{wxhtmlwinparsersetalign}
+
+\func{void}{SetAlign}{\param{int }{a}}
+
+Sets default horizontal alignment (see 
+\helpref{wxHtmlContainerCell::SetAlignHor}{wxhtmlcontainercellsetalignhor}.)
+Alignment of newly opened container is set to this value.
+
+\membersection{wxHtmlWinParser::SetContainer}\label{wxhtmlwinparsersetcontainer}
+
+\func{wxHtmlContainerCell*}{SetContainer}{\param{wxHtmlContainerCell *}{c}}
+
+Allows you to directly set opened container. This is not recommended - you should use OpenContainer
+wherever possible.
+
+\membersection{wxHtmlWinParser::SetDC}\label{wxhtmlwinparsersetdc}
+
+\func{virtual void}{SetDC}{\param{wxDC }{*dc}, \param{double }{pixel\_scale = 1.0}}
+
+Sets the DC. This must be called before \helpref{Parse}{wxhtmlparserparse}!
+{\it pixel\_scale}  can be used when rendering to high-resolution 
+DCs (e.g. printer) to adjust size of pixel metrics. (Many dimensions in 
+HTML are given in pixels -- e.g. image sizes. 300x300 image would be only one
+inch wide on typical printer. With pixel\_scale = 3.0 it would be 3 inches.)
+
+\membersection{wxHtmlWinParser::SetFontBold}\label{wxhtmlwinparsersetfontbold}
+
+\func{void}{SetFontBold}{\param{int }{x}}
+
+Sets bold flag of actualfont. {\it x} is either true of false.
+
+\membersection{wxHtmlWinParser::SetFontFace}\label{wxhtmlwinparsersetfontface}
+
+\func{void}{SetFontFace}{\param{const wxString\& }{face}}
+
+Sets current font face to {\it face}. This affects either fixed size
+font or proportional, depending on context (whether the parser is 
+inside {\tt <TT>} tag or not).
+
+\membersection{wxHtmlWinParser::SetFontFixed}\label{wxhtmlwinparsersetfontfixed}
+
+\func{void}{SetFontFixed}{\param{int }{x}}
+
+Sets fixed face flag of actualfont. {\it x} is either true of false.
+
+\membersection{wxHtmlWinParser::SetFontItalic}\label{wxhtmlwinparsersetfontitalic}
+
+\func{void}{SetFontItalic}{\param{int }{x}}
+
+Sets italic flag of actualfont. {\it x} is either true of false.
+
+\membersection{wxHtmlWinParser::SetFontSize}\label{wxhtmlwinparsersetfontsize}
+
+\func{void}{SetFontSize}{\param{int }{s}}
+
+Sets actual font size (HTML size varies from 1 to 7)
+
+\membersection{wxHtmlWinParser::SetFontUnderlined}\label{wxhtmlwinparsersetfontunderlined}
+
+\func{void}{SetFontUnderlined}{\param{int }{x}}
+
+Sets underlined flag of actualfont. {\it x} is either true of false.
+
+\membersection{wxHtmlWinParser::SetFonts}\label{wxhtmlwinparsersetfonts}
+
+\func{void}{SetFonts}{\param{wxString }{normal\_face}, \param{wxString }{fixed\_face}, \param{const int }{*sizes = NULL}}
+
+Sets fonts. See \helpref{wxHtmlWindow::SetFonts}{wxhtmlwindowsetfonts} for
+detailed description.
+
+\membersection{wxHtmlWinParser::SetInputEncoding}\label{wxhtmlwinparsersetinputencoding}
+
+\func{void}{SetInputEncoding}{\param{wxFontEncoding }{enc}}
+
+Sets input encoding. The parser uses this information to build conversion
+tables from document's encoding to some encoding supported by operating
+system.
+
+\membersection{wxHtmlWinParser::SetLink}\label{wxhtmlwinparsersetlink}
+
+\func{void}{SetLink}{\param{const wxHtmlLinkInfo\& }{link}}
+
+Sets actual hypertext link. Empty link is represented
+by \helpref{wxHtmlLinkInfo}{wxhtmllinkinfo} with {\it Href} equal
+to wxEmptyString.
+
+\membersection{wxHtmlWinParser::SetLinkColor}\label{wxhtmlwinparsersetlinkcolor}
+
+\func{void}{SetLinkColor}{\param{const wxColour\& }{clr}}
+
+Sets colour of hypertext link.
+

include/wx/html/forcelnk.h

@@ -0,0 +1,73 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        forcelnk.h
+// Purpose:     see bellow
+// Author:      Vaclav Slavik
+// RCS-ID:      $Id$
+// Copyright:   (c) Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+/*
+
+DESCRPITON:
+
+mod_*.cpp files contain handlers for tags. These files are modules - they contain
+one wxTagModule class and it's OnInit() method is called from wxApp's init method.
+The module is called even if you only link it into the executable, so everything
+seems wonderful.
+
+The problem is that we have these modules in LIBRARY and mod_*.cpp files contain
+no method nor class which is known out of the module. So the linker won't
+link these .o/.obj files into executable because it detected that it is not used
+by the program.
+
+To workaround this I introduced set of macros FORCE_LINK_ME and FORCE_LINK. These
+macros are generic and are not limited to mod_*.cpp files. You may find them quite
+useful somewhere else...
+
+How to use them:
+let's suppose you want to always link file foo.cpp and that you have module
+always.cpp that is certainly always linked (e.g. the one with main() function
+or htmlwin.cpp in wxHtml library).
+
+Place FORCE_LINK_ME(foo) somewhere in foo.cpp and FORCE_LINK(foo) somewhere
+in always.cpp
+See mod_*.cpp and htmlwin.cpp for example :-)
+
+*/
+
+
+#ifndef _WX_FORCELNK_H_
+#define _WX_FORCELNK_H_
+
+
+
+// This must be part of the module you want to force:
+#define FORCE_LINK_ME(module_name)                                    \
+                int _link_dummy_func_##module_name ();                \
+                int _link_dummy_func_##module_name ()                 \
+                {                                                     \
+                    return 1;                                         \
+                }
+
+
+// And this must be somewhere where it certainly will be linked:
+#define FORCE_LINK(module_name)                                       \
+                extern int _link_dummy_func_##module_name ();         \
+                static int _link_dummy_var_##module_name =            \
+                               _link_dummy_func_##module_name ();
+
+#define FORCE_WXHTML_MODULES() \
+    FORCE_LINK(m_layout) \
+    FORCE_LINK(m_fonts) \
+    FORCE_LINK(m_image) \
+    FORCE_LINK(m_list) \
+    FORCE_LINK(m_dflist) \
+    FORCE_LINK(m_pre) \
+    FORCE_LINK(m_hline) \
+    FORCE_LINK(m_links) \
+    FORCE_LINK(m_tables) \
+    FORCE_LINK(m_style)
+
+
+#endif // _WX_FORCELNK_H_

include/wx/html/helpctrl.h

@@ -0,0 +1,108 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        helpctrl.h
+// Purpose:     wxHtmlHelpController
+// Notes:       Based on htmlhelp.cpp, implementing a monolithic
+//              HTML Help controller class,  by Vaclav Slavik
+// Author:      Harm van der Heijden and Vaclav Slavik
+// RCS-ID:      $Id$
+// Copyright:   (c) Harm van der Heijden and Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_HELPCTRL_H_
+#define _WX_HELPCTRL_H_
+
+#include "wx/defs.h"
+
+#if defined(__GNUG__) && !defined(__APPLE__)
+#pragma interface "helpctrl.h"
+#endif
+
+#if wxUSE_WXHTML_HELP
+
+#include "wx/html/helpfrm.h"
+#include "wx/helpbase.h"
+
+#define wxID_HTML_HELPFRAME   (wxID_HIGHEST + 1)
+
+class WXDLLEXPORT wxHtmlHelpController : public wxHelpControllerBase // wxEvtHandler
+{
+    DECLARE_DYNAMIC_CLASS(wxHtmlHelpController)
+
+public:
+    wxHtmlHelpController(int style = wxHF_DEFAULT_STYLE);
+    virtual ~wxHtmlHelpController();
+
+    void SetTitleFormat(const wxString& format);
+    void SetTempDir(const wxString& path) { m_helpData.SetTempDir(path); }
+    bool AddBook(const wxString& book_url, bool show_wait_msg = FALSE);
+    bool AddBook(const wxFileName& book_file, bool show_wait_msg = FALSE);
+
+    bool Display(const wxString& x);
+    bool Display(int id);
+    bool DisplayContents();
+    bool DisplayIndex();
+    bool KeywordSearch(const wxString& keyword);
+
+    wxHtmlHelpFrame* GetFrame() { return m_helpFrame; }
+    void UseConfig(wxConfigBase *config, const wxString& rootpath = wxEmptyString);
+
+    // Assigns config object to the Ctrl. This config is then
+    // used in subsequent calls to Read/WriteCustomization of both help
+    // Ctrl and it's wxHtmlWindow
+    virtual void ReadCustomization(wxConfigBase *cfg, const wxString& path = wxEmptyString);
+    virtual void WriteCustomization(wxConfigBase *cfg, const wxString& path = wxEmptyString);
+
+    //// Backward compatibility with wxHelpController API
+
+    virtual bool Initialize(const wxString& file, int WXUNUSED(server) ) { return Initialize(file); }
+    virtual bool Initialize(const wxString& file);
+    virtual void SetViewer(const wxString& WXUNUSED(viewer), long WXUNUSED(flags) = 0) {}
+    virtual bool LoadFile(const wxString& file = wxT(""));
+    virtual bool DisplaySection(int sectionNo);
+    virtual bool DisplaySection(const wxString& section) { return Display(section); }
+    virtual bool DisplayBlock(long blockNo) { return DisplaySection(blockNo); }
+    virtual bool DisplayTextPopup(const wxString& text, const wxPoint& pos);
+
+    virtual void SetFrameParameters(const wxString& title,
+                               const wxSize& size,
+                               const wxPoint& pos = wxDefaultPosition,
+                               bool newFrameEachTime = FALSE);
+    /// Obtains the latest settings used by the help frame and the help
+    /// frame.
+    virtual wxFrame *GetFrameParameters(wxSize *size = NULL,
+                               wxPoint *pos = NULL,
+                               bool *newFrameEachTime = NULL);
+
+    // Get direct access to help data:
+    wxHtmlHelpData *GetHelpData() { return &m_helpData; }
+
+    virtual bool Quit() ;
+    virtual void OnQuit() {};
+
+    void OnCloseFrame(wxCloseEvent& evt);
+
+    // Make the help controller's frame 'modal' if
+    // needed
+    void AddGrabIfNeeded();
+
+protected:
+    virtual wxHtmlHelpFrame* CreateHelpFrame(wxHtmlHelpData *data);
+
+    virtual void CreateHelpWindow();
+    virtual void DestroyHelpWindow();
+
+    wxHtmlHelpData      m_helpData;
+    wxHtmlHelpFrame*    m_helpFrame;
+    wxConfigBase *      m_Config;
+    wxString            m_ConfigRoot;
+    wxString            m_titleFormat;
+    int                 m_FrameStyle;
+    // DECLARE_EVENT_TABLE()
+
+    DECLARE_NO_COPY_CLASS(wxHtmlHelpController)
+};
+
+#endif // wxUSE_WXHTML_HELP
+
+#endif // _WX_HELPCTRL_H_

include/wx/html/helpdata.h

@@ -0,0 +1,218 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        helpdata.h
+// Purpose:     wxHtmlHelpData
+// Notes:       Based on htmlhelp.cpp, implementing a monolithic
+//              HTML Help controller class,  by Vaclav Slavik
+// Author:      Harm van der Heijden and Vaclav Slavik
+// RCS-ID:      $Id$
+// Copyright:   (c) Harm van der Heijden and Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_HELPDATA_H_
+#define _WX_HELPDATA_H_
+
+#if defined(__GNUG__) && !defined(__APPLE__)
+#pragma interface "helpdata.h"
+#endif
+
+#include "wx/defs.h"
+
+#if wxUSE_HTML
+
+#include "wx/object.h"
+#include "wx/string.h"
+#include "wx/filesys.h"
+#include "wx/dynarray.h"
+#include "wx/font.h"
+
+class WXDLLEXPORT wxHtmlHelpData;
+
+//--------------------------------------------------------------------------------
+// helper classes & structs
+//--------------------------------------------------------------------------------
+
+class WXDLLEXPORT wxHtmlBookRecord
+{
+public:
+    wxHtmlBookRecord(const wxString& bookfile, const wxString& basepath, 
+                     const wxString& title, const wxString& start)
+    {
+        m_BookFile = bookfile;
+        m_BasePath = basepath;
+        m_Title = title;
+        m_Start = start;
+        // for debugging, give the contents index obvious default values
+        m_ContentsStart = m_ContentsEnd = -1;
+    }
+    wxString GetBookFile() const { return m_BookFile; }
+    wxString GetTitle() const { return m_Title; }
+    wxString GetStart() const { return m_Start; }
+    wxString GetBasePath() const { return m_BasePath; }
+    /* SetContentsRange: store in the bookrecord where in the index/contents lists the
+     * book's records are stored. This to facilitate searching in a specific book.
+     * This code will have to be revised when loading/removing books becomes dynamic.
+     * (as opposed to appending only)
+     * Note that storing index range is pointless, because the index is alphab. sorted. */
+    void SetContentsRange(int start, int end) { m_ContentsStart = start; m_ContentsEnd = end; }
+    int GetContentsStart() const { return m_ContentsStart; }
+    int GetContentsEnd() const { return m_ContentsEnd; }
+
+    void SetTitle(const wxString& title) { m_Title = title; }
+    void SetBasePath(const wxString& path) { m_BasePath = path; }
+    void SetStart(const wxString& start) { m_Start = start; }
+
+    // returns full filename of page (which is part of the book), 
+    // i.e. with book's basePath prepended. If page is already absolute 
+    // path, basePath is _not_ prepended.
+    wxString GetFullPath(const wxString &page) const;
+
+protected:
+    wxString m_BookFile;
+    wxString m_BasePath;
+    wxString m_Title;
+    wxString m_Start;
+    int m_ContentsStart;
+    int m_ContentsEnd;
+};
+
+
+WX_DECLARE_EXPORTED_OBJARRAY(wxHtmlBookRecord, wxHtmlBookRecArray);
+
+
+struct wxHtmlContentsItem
+{
+    short int m_Level;
+    int m_ID;
+    wxChar* m_Name;
+    wxChar* m_Page;
+    wxHtmlBookRecord *m_Book;
+    
+    // returns full filename of m_Page, i.e. with book's basePath prepended
+    wxString GetFullPath() const { return m_Book->GetFullPath(m_Page); }
+};
+
+//------------------------------------------------------------------------------
+// wxHtmlSearchEngine
+//                  This class takes input streams and scans them for occurence
+//                  of keyword(s)
+//------------------------------------------------------------------------------
+
+class WXDLLEXPORT wxHtmlSearchEngine : public wxObject
+{
+public:
+    wxHtmlSearchEngine() : wxObject() {m_Keyword = NULL; }
+    ~wxHtmlSearchEngine() {if (m_Keyword) delete[] m_Keyword; }
+
+    // Sets the keyword we will be searching for
+    virtual void LookFor(const wxString& keyword, bool case_sensitive, bool whole_words_only);
+
+    // Scans the stream for the keyword.
+    // Returns TRUE if the stream contains keyword, fALSE otherwise
+    virtual bool Scan(const wxFSFile& file);
+
+private:
+    wxChar *m_Keyword;
+    bool m_CaseSensitive;
+    bool m_WholeWords;
+
+    DECLARE_NO_COPY_CLASS(wxHtmlSearchEngine)
+};
+
+
+// State information of a search action. I'd have prefered to make this a nested
+// class inside wxHtmlHelpData, but that's against coding standards :-(
+// Never construct this class yourself, obtain a copy from
+// wxHtmlHelpData::PrepareKeywordSearch(const wxString& key)
+class WXDLLEXPORT wxHtmlSearchStatus
+{
+public:
+    // constructor; supply wxHtmlHelpData ptr, the keyword and (optionally) the
+    // title of the book to search. By default, all books are searched.
+    wxHtmlSearchStatus(wxHtmlHelpData* base, const wxString& keyword,
+                       bool case_sensitive, bool whole_words_only,
+                       const wxString& book = wxEmptyString);
+    bool Search();  // do the next iteration
+    bool IsActive() { return m_Active; }
+    int GetCurIndex() { return m_CurIndex; }
+    int GetMaxIndex() { return m_MaxIndex; }
+    const wxString& GetName() { return m_Name; }
+    wxHtmlContentsItem* GetContentsItem() { return m_ContentsItem; }
+
+private:
+    wxHtmlHelpData* m_Data;
+    wxHtmlSearchEngine m_Engine;
+    wxString m_Keyword, m_Name;
+    wxChar *m_LastPage;
+    wxHtmlContentsItem* m_ContentsItem;
+    bool m_Active;   // search is not finished
+    int m_CurIndex;  // where we are now
+    int m_MaxIndex;  // number of files we search
+    // For progress bar: 100*curindex/maxindex = % complete
+
+    DECLARE_NO_COPY_CLASS(wxHtmlSearchStatus)
+};
+
+class WXDLLEXPORT wxHtmlHelpData : public wxObject
+{
+    DECLARE_DYNAMIC_CLASS(wxHtmlHelpData)
+    friend class wxHtmlSearchStatus;
+
+public:
+    wxHtmlHelpData();
+    ~wxHtmlHelpData();
+
+    // Sets directory where temporary files are stored.
+    // These temp files are index & contents file in binary (much faster to read)
+    // form. These files are NOT deleted on program's exit.
+    void SetTempDir(const wxString& path);
+
+    // Adds new book. 'book' is location of .htb file (stands for "html book").
+    // See documentation for details on its format.
+    // Returns success.
+    bool AddBook(const wxString& book);
+    bool AddBookParam(const wxFSFile& bookfile,
+                      wxFontEncoding encoding,
+                      const wxString& title, const wxString& contfile,
+                      const wxString& indexfile = wxEmptyString,
+                      const wxString& deftopic = wxEmptyString,
+                      const wxString& path = wxEmptyString);
+
+    // Some accessing stuff:
+
+    // returns URL of page on basis of (file)name
+    wxString FindPageByName(const wxString& page);
+    // returns URL of page on basis of MS id
+    wxString FindPageById(int id);
+
+    const wxHtmlBookRecArray& GetBookRecArray() { return m_BookRecords; }
+    wxHtmlContentsItem* GetContents() { return m_Contents; }
+    int GetContentsCnt() { return m_ContentsCnt; }
+    wxHtmlContentsItem* GetIndex() { return m_Index; }
+    int GetIndexCnt() { return m_IndexCnt; }
+
+protected:
+    wxString m_TempPath;
+
+    wxHtmlBookRecArray m_BookRecords;
+    // each book has one record in this array:
+    wxHtmlContentsItem* m_Contents;
+    int m_ContentsCnt;   
+    wxHtmlContentsItem* m_Index; // list of all available books and pages.
+    int m_IndexCnt;  // list of index items
+
+protected:
+    // Imports .hhp files (MS HTML Help Workshop)
+    bool LoadMSProject(wxHtmlBookRecord *book, wxFileSystem& fsys,
+                       const wxString& indexfile, const wxString& contentsfile);
+    // Reads binary book
+    bool LoadCachedBook(wxHtmlBookRecord *book, wxInputStream *f);
+    // Writes binary book
+    bool SaveCachedBook(wxHtmlBookRecord *book, wxOutputStream *f);
+
+    DECLARE_NO_COPY_CLASS(wxHtmlHelpData)
+};
+
+#endif
+
+#endif

include/wx/html/helpfrm.h

@@ -0,0 +1,239 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        helpfrm.h
+// Purpose:     wxHtmlHelpFrame
+// Notes:       Based on htmlhelp.cpp, implementing a monolithic
+//              HTML Help controller class,  by Vaclav Slavik
+// Author:      Harm van der Heijden and Vaclav Slavik
+// RCS-ID:      $Id$
+// Copyright:   (c) Harm van der Heijden and Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_HELPFRM_H_
+#define _WX_HELPFRM_H_
+
+#if defined(__GNUG__) && !defined(__APPLE__)
+#pragma interface "helpfrm.h"
+#endif
+
+#include "wx/defs.h"
+
+#if wxUSE_WXHTML_HELP
+
+#include "wx/html/helpdata.h"
+#include "wx/window.h"
+#include "wx/frame.h"
+#include "wx/config.h"
+#include "wx/splitter.h"
+#include "wx/notebook.h"
+#include "wx/listbox.h"
+#include "wx/choice.h"
+#include "wx/combobox.h"
+#include "wx/checkbox.h"
+#include "wx/stattext.h"
+#include "wx/html/htmlwin.h"
+#include "wx/html/htmprint.h"
+
+class WXDLLEXPORT wxButton;
+class WXDLLEXPORT wxTextCtrl;
+
+
+// style flags for the Help Frame
+#define wxHF_TOOLBAR                0x0001
+#define wxHF_CONTENTS               0x0002
+#define wxHF_INDEX                  0x0004
+#define wxHF_SEARCH                 0x0008
+#define wxHF_BOOKMARKS              0x0010
+#define wxHF_OPEN_FILES             0x0020
+#define wxHF_PRINT                  0x0040
+#define wxHF_FLAT_TOOLBAR           0x0080
+#define wxHF_MERGE_BOOKS            0x0100
+#define wxHF_ICONS_BOOK             0x0200
+#define wxHF_ICONS_BOOK_CHAPTER     0x0400
+#define wxHF_ICONS_FOLDER           0x0000 // this is 0 since it is default
+#define wxHF_DEFAULT_STYLE          (wxHF_TOOLBAR | wxHF_CONTENTS | \
+                                     wxHF_INDEX | wxHF_SEARCH | \
+                                     wxHF_BOOKMARKS | wxHF_PRINT)
+//compatibility:
+#define wxHF_OPENFILES               wxHF_OPEN_FILES
+#define wxHF_FLATTOOLBAR             wxHF_FLAT_TOOLBAR
+#define wxHF_DEFAULTSTYLE            wxHF_DEFAULT_STYLE
+
+
+struct wxHtmlHelpFrameCfg
+{
+    int x, y, w, h;
+    long sashpos;
+    bool navig_on;
+};
+
+
+class WXDLLEXPORT wxHelpControllerBase;
+
+class WXDLLEXPORT wxHtmlHelpFrame : public wxFrame
+{
+    DECLARE_DYNAMIC_CLASS(wxHtmlHelpFrame)
+
+public:
+    wxHtmlHelpFrame(wxHtmlHelpData* data = NULL) { Init(data); }
+    wxHtmlHelpFrame(wxWindow* parent, wxWindowID wxWindowID,
+                    const wxString& title = wxEmptyString,
+                    int style = wxHF_DEFAULT_STYLE, wxHtmlHelpData* data = NULL);
+    bool Create(wxWindow* parent, wxWindowID id, const wxString& title = wxEmptyString,
+                int style = wxHF_DEFAULT_STYLE);
+    ~wxHtmlHelpFrame();
+
+    wxHtmlHelpData* GetData() { return m_Data; }
+    wxHelpControllerBase* GetController() const { return m_helpController; }
+    void SetController(wxHelpControllerBase* controller) { m_helpController = controller; }
+
+    // Sets format of title of the frame. Must contain exactly one "%s"
+    // (for title of displayed HTML page)
+    void SetTitleFormat(const wxString& format);
+
+    // Displays page x. If not found it will offect the user a choice of
+    // searching books.
+    // Looking for the page runs in these steps:
+    // 1. try to locate file named x (if x is for example "doc/howto.htm")
+    // 2. try to open starting page of book x
+    // 3. try to find x in contents (if x is for example "How To ...")
+    // 4. try to find x in index (if x is for example "How To ...")
+    bool Display(const wxString& x);
+
+    // Alternative version that works with numeric ID.
+    // (uses extension to MS format, <param name="ID" value=id>, see docs)
+    bool Display(const int id);
+
+    // Displays help window and focuses contents.
+    bool DisplayContents();
+
+    // Displays help window and focuses index.
+    bool DisplayIndex();
+
+    // Searches for keyword. Returns TRUE and display page if found, return
+    // FALSE otherwise
+    // Syntax of keyword is Altavista-like:
+    // * words are separated by spaces
+    //   (but "\"hello world\"" is only one world "hello world")
+    // * word may be pretended by + or -
+    //   (+ : page must contain the word ; - : page can't contain the word)
+    // * if there is no + or - before the word, + is default
+    bool KeywordSearch(const wxString& keyword);
+
+    void UseConfig(wxConfigBase *config, const wxString& rootpath = wxEmptyString)
+        {
+            m_Config = config;
+            m_ConfigRoot = rootpath;
+            ReadCustomization(config, rootpath);
+        }
+
+    // Saves custom settings into cfg config. it will use the path 'path'
+    // if given, otherwise it will save info into currently selected path.
+    // saved values : things set by SetFonts, SetBorders.
+    void ReadCustomization(wxConfigBase *cfg, const wxString& path = wxEmptyString);
+    void WriteCustomization(wxConfigBase *cfg, const wxString& path = wxEmptyString);
+
+    // call this to let wxHtmlHelpFrame know page changed
+    void NotifyPageChanged();
+    
+    // Refreshes Contents and Index tabs
+    void RefreshLists();
+    
+protected:
+    void Init(wxHtmlHelpData* data = NULL);
+
+    // Adds items to m_Contents tree control
+    void CreateContents();
+
+    // Adds items to m_IndexList
+    void CreateIndex();
+
+    // Add books to search choice panel
+    void CreateSearch();
+
+    // Add custom buttons to toolbar
+    virtual void AddToolbarButtons(wxToolBar *toolBar, int style);
+
+    // Displays options dialog (fonts etc.)
+    virtual void OptionsDialog();
+
+    void OnToolbar(wxCommandEvent& event);
+    void OnContentsSel(wxTreeEvent& event);
+    void OnIndexSel(wxCommandEvent& event);
+    void OnIndexFind(wxCommandEvent& event);
+    void OnIndexAll(wxCommandEvent& event);
+    void OnSearchSel(wxCommandEvent& event);
+    void OnSearch(wxCommandEvent& event);
+    void OnBookmarksSel(wxCommandEvent& event);
+    void OnCloseWindow(wxCloseEvent& event);
+    void OnActivate(wxActivateEvent& event);
+
+#ifdef __WXMAC__
+    void OnClose(wxCommandEvent& event);
+    void OnAbout(wxCommandEvent& event);
+#endif
+
+    // Images:
+    enum {
+        IMG_Book = 0,
+        IMG_Folder,
+        IMG_Page
+    };
+
+protected:
+    wxHtmlHelpData* m_Data;
+    bool m_DataCreated;  // m_Data created by frame, or supplied?
+    wxString m_TitleFormat;  // title of the help frame
+    // below are various pointers to GUI components
+    wxHtmlWindow *m_HtmlWin;
+    wxSplitterWindow *m_Splitter;
+    wxPanel *m_NavigPan;
+    wxNotebook *m_NavigNotebook;
+    wxTreeCtrl *m_ContentsBox;
+    wxTextCtrl *m_IndexText;
+    wxButton *m_IndexButton;
+    wxButton *m_IndexButtonAll;
+    wxListBox *m_IndexList;
+    wxTextCtrl *m_SearchText;
+    wxButton *m_SearchButton;
+    wxListBox *m_SearchList;
+    wxChoice *m_SearchChoice;
+    wxStaticText *m_IndexCountInfo;
+    wxCheckBox *m_SearchCaseSensitive;
+    wxCheckBox *m_SearchWholeWords;
+
+    wxComboBox *m_Bookmarks;
+    wxArrayString m_BookmarksNames, m_BookmarksPages;
+
+    wxHtmlHelpFrameCfg m_Cfg;
+
+    wxConfigBase *m_Config;
+    wxString m_ConfigRoot;
+
+    // pagenumbers of controls in notebook (usually 0,1,2)
+    int m_ContentsPage;
+    int m_IndexPage;
+    int m_SearchPage;
+
+    // lists of available fonts (used in options dialog)
+    wxArrayString *m_NormalFonts, *m_FixedFonts;
+    int m_FontSize; // 0,1,2 = small,medium,big
+    wxString m_NormalFace, m_FixedFace;
+
+    bool m_UpdateContents;
+
+#if wxUSE_PRINTING_ARCHITECTURE
+    wxHtmlEasyPrinting *m_Printer;
+#endif
+    wxHashTable *m_PagesHash;
+    wxHelpControllerBase* m_helpController;
+
+    int m_hfStyle;
+
+    DECLARE_EVENT_TABLE()
+    DECLARE_NO_COPY_CLASS(wxHtmlHelpFrame)
+};
+
+#endif // wxUSE_WXHTML_HELP
+
+#endif

include/wx/html/htmlcell.h

@@ -0,0 +1,382 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        htmlcell.h
+// Purpose:     wxHtmlCell class is used by wxHtmlWindow/wxHtmlWinParser
+//              as a basic visual element of HTML page
+// Author:      Vaclav Slavik
+// RCS-ID:      $Id$
+// Copyright:   (c) 1999 Vaclav Slavik
+// Licence:     wxWindows Licence
+/////////////////////////////////////////////////////////////////////////////
+
+
+#ifndef _WX_HTMLCELL_H_
+#define _WX_HTMLCELL_H_
+
+#if defined(__GNUG__) && !defined(__APPLE__)
+#pragma interface "htmlcell.h"
+#endif
+
+#include "wx/defs.h"
+
+#if wxUSE_HTML
+
+#include "wx/html/htmltag.h"
+#include "wx/html/htmldefs.h"
+#include "wx/window.h"
+
+
+class WXDLLEXPORT wxHtmlLinkInfo;
+class WXDLLEXPORT wxHtmlCell;
+class WXDLLEXPORT wxHtmlContainerCell;
+
+//--------------------------------------------------------------------------------
+// wxHtmlCell
+//                  Internal data structure. It represents fragments of parsed HTML
+//                  page - a word, picture, table, horizontal line and so on.
+//                  It is used by wxHtmlWindow to represent HTML page in memory.
+//--------------------------------------------------------------------------------
+
+
+class WXDLLEXPORT wxHtmlCell : public wxObject
+{
+public:
+    wxHtmlCell();
+    virtual ~wxHtmlCell();
+
+    void SetParent(wxHtmlContainerCell *p) {m_Parent = p;}
+    wxHtmlContainerCell *GetParent() const {return m_Parent;}
+
+    int GetPosX() const {return m_PosX;}
+    int GetPosY() const {return m_PosY;}
+    int GetWidth() const {return m_Width;}
+    int GetHeight() const {return m_Height;}
+    int GetDescent() const {return m_Descent;}
+
+    const wxString& GetId() const { return m_id; }
+    void SetId(const wxString& id) { m_id = id; }
+
+    // returns the link associated with this cell. The position is position within
+    // the cell so it varies from 0 to m_Width, from 0 to m_Height
+    virtual wxHtmlLinkInfo* GetLink(int WXUNUSED(x) = 0, int WXUNUSED(y) = 0) const
+        { return m_Link; }
+
+    // members access methods
+    wxHtmlCell *GetNext() const {return m_Next;}
+
+    // members writing methods
+    virtual void SetPos(int x, int y) {m_PosX = x, m_PosY = y;}
+    void SetLink(const wxHtmlLinkInfo& link);
+    void SetNext(wxHtmlCell *cell) {m_Next = cell;}
+
+    // 1. adjust cell's width according to the fact that maximal possible width is w.
+    //    (this has sense when working with horizontal lines, tables etc.)
+    // 2. prepare layout (=fill-in m_PosX, m_PosY (and sometime m_Height) members)
+    //    = place items to fit window, according to the width w
+    virtual void Layout(int w);
+
+    // renders the cell
+    virtual void Draw(wxDC& WXUNUSED(dc), int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(view_y1), int WXUNUSED(view_y2)) {}
+
+    // proceed drawing actions in case the cell is not visible (scrolled out of screen).
+    // This is needed to change fonts, colors and so on
+    virtual void DrawInvisible(wxDC& WXUNUSED(dc), int WXUNUSED(x), int WXUNUSED(y)) {}
+
+    // This method returns pointer to the FIRST cell for that
+    // the condition
+    // is true. It first checks if the condition is true for this
+    // cell and then calls m_Next->Find(). (Note: it checks
+    // all subcells if the cell is container)
+    // Condition is unique condition identifier (see htmldefs.h)
+    // (user-defined condition IDs should start from 10000)
+    // and param is optional parameter
+    // Example : m_Cell->Find(wxHTML_COND_ISANCHOR, "news");
+    //   returns pointer to anchor news
+    virtual const wxHtmlCell* Find(int condition, const void* param) const;
+
+    // This function is called when mouse button is clicked over the cell.
+    //
+    // Parent is pointer to wxHtmlWindow that generated the event
+    // HINT: if this handling is not enough for you you should use
+    //       wxHtmlWidgetCell
+    virtual void OnMouseClick(wxWindow *parent, int x, int y, const wxMouseEvent& event);
+
+    // This method used to adjust pagebreak position. The parameter is
+    // variable that contains y-coordinate of page break (= horizontal line that
+    // should not be crossed by words, images etc.). If this cell cannot be divided
+    // into two pieces (each one on another page) then it moves the pagebreak
+    // few pixels up.
+    //
+    // Returned value : true if pagebreak was modified, false otherwise
+    // Usage : while (container->AdjustPagebreak(&p)) {}
+    virtual bool AdjustPagebreak(int *pagebreak, int *known_pagebreaks = NULL, int number_of_pages = 0) const;
+
+    // Sets cell's behaviour on pagebreaks (see AdjustPagebreak). Default
+    // is true - the cell can be split on two pages
+    void SetCanLiveOnPagebreak(bool can) { m_CanLiveOnPagebreak = can; }
+
+    // Returns y-coordinates that contraint the cell, i.e. left is highest
+    // and right lowest coordinate such that the cell lays between then.
+    // Note: this method does not return meaningful values if you haven't
+    //       called Layout() before!
+    virtual void GetHorizontalConstraints(int *left, int *right) const;
+
+    // Returns true for simple == terminal cells, i.e. not composite ones.
+    // This if for internal usage only and may disappear in future versions!
+    virtual bool IsTerminalCell() const { return TRUE; }
+
+    // Find the terminal cell inside this cell at the given position (relative
+    // to this cell)
+    //
+    // Returns NULL if not found
+    virtual wxHtmlCell *FindCellByPos(wxCoord x, wxCoord y) const;
+
+protected:
+    wxHtmlCell *m_Next;
+            // pointer to the next cell
+    wxHtmlContainerCell *m_Parent;
+            // pointer to parent cell
+    long m_Width, m_Height, m_Descent;
+            // dimensions of fragment
+            // m_Descent is used to position text&images..
+    long m_PosX, m_PosY;
+            // position where the fragment is drawn
+    wxHtmlLinkInfo *m_Link;
+            // destination address if this fragment is hypertext link, NULL otherwise
+    bool m_CanLiveOnPagebreak;
+            // true if this cell can be placed on pagebreak, false otherwise
+    wxString m_id;
+            // unique identifier of the cell, generated from "id" property of tags
+
+    DECLARE_NO_COPY_CLASS(wxHtmlCell)
+};
+
+
+
+
+//--------------------------------------------------------------------------------
+// Inherited cells:
+//--------------------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------------------
+// wxHtmlWordCell
+//                  Single word in input stream.
+//--------------------------------------------------------------------------------
+
+class WXDLLEXPORT wxHtmlWordCell : public wxHtmlCell
+{
+public:
+    wxHtmlWordCell(const wxString& word, wxDC& dc);
+    void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2);
+
+protected:
+    wxString m_Word;
+};
+
+
+
+
+
+//--------------------------------------------------------------------------------
+// wxHtmlContainerCell
+//                  Container - it contains other cells. Basic of layout algorithm.
+//--------------------------------------------------------------------------------
+
+class WXDLLEXPORT wxHtmlContainerCell : public wxHtmlCell
+{
+public:
+    wxHtmlContainerCell(wxHtmlContainerCell *parent);
+    ~wxHtmlContainerCell();
+
+    virtual void Layout(int w);
+    virtual void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2);
+    virtual void DrawInvisible(wxDC& dc, int x, int y);
+    virtual bool AdjustPagebreak(int *pagebreak, int *known_pagebreaks = NULL, int number_of_pages = 0) const;
+
+    // insert cell at the end of m_Cells list
+    void InsertCell(wxHtmlCell *cell);
+
+    // sets horizontal/vertical alignment
+    void SetAlignHor(int al) {m_AlignHor = al; m_LastLayout = -1;}
+    int GetAlignHor() const {return m_AlignHor;}
+    void SetAlignVer(int al) {m_AlignVer = al; m_LastLayout = -1;}
+    int GetAlignVer() const {return m_AlignVer;}
+
+    // sets left-border indentation. units is one of wxHTML_UNITS_* constants
+    // what is combination of wxHTML_INDENT_*
+    void SetIndent(int i, int what, int units = wxHTML_UNITS_PIXELS);
+    // returns the indentation. ind is one of wxHTML_INDENT_* constants
+    int GetIndent(int ind) const;
+    // returns type of value returned by GetIndent(ind)
+    int GetIndentUnits(int ind) const;
+
+    // sets alignment info based on given tag's params
+    void SetAlign(const wxHtmlTag& tag);
+    // sets floating width adjustment
+    // (examples : 32 percent of parent container,
+    // -15 pixels percent (this means 100 % - 15 pixels)
+    void SetWidthFloat(int w, int units) {m_WidthFloat = w; m_WidthFloatUnits = units; m_LastLayout = -1;}
+    void SetWidthFloat(const wxHtmlTag& tag, double pixel_scale = 1.0);
+    // sets minimal height of this container.
+    void SetMinHeight(int h, int align = wxHTML_ALIGN_TOP) {m_MinHeight = h; m_MinHeightAlign = align; m_LastLayout = -1;}
+
+    void SetBackgroundColour(const wxColour& clr) {m_UseBkColour = TRUE; m_BkColour = clr;}
+    // returns background colour (of wxNullColour if none set), so that widgets can
+    // adapt to it:
+    wxColour GetBackgroundColour();
+    void SetBorder(const wxColour& clr1, const wxColour& clr2) {m_UseBorder = TRUE; m_BorderColour1 = clr1, m_BorderColour2 = clr2;}
+    virtual wxHtmlLinkInfo* GetLink(int x = 0, int y = 0) const;
+    virtual const wxHtmlCell* Find(int condition, const void* param) const;
+    virtual void OnMouseClick(wxWindow *parent, int x, int y, const wxMouseEvent& event);
+    virtual void GetHorizontalConstraints(int *left, int *right) const;
+
+    // returns pointer to the first cell in container or NULL
+    wxHtmlCell* GetFirstCell() const {return m_Cells;}
+
+    // see comment in wxHtmlCell about this method
+    virtual bool IsTerminalCell() const { return FALSE; }
+
+    virtual wxHtmlCell *FindCellByPos(wxCoord x, wxCoord y) const;
+
+protected:
+    int m_IndentLeft, m_IndentRight, m_IndentTop, m_IndentBottom;
+            // indentation of subcells. There is always m_Indent pixels
+            // big space between given border of the container and the subcells
+            // it m_Indent < 0 it is in PERCENTS, otherwise it is in pixels
+    int m_MinHeight, m_MinHeightAlign;
+        // minimal height.
+    wxHtmlCell *m_Cells, *m_LastCell;
+            // internal cells, m_Cells points to the first of them, m_LastCell to the last one.
+            // (LastCell is needed only to speed-up InsertCell)
+    int m_AlignHor, m_AlignVer;
+            // alignment horizontal and vertical (left, center, right)
+    int m_WidthFloat, m_WidthFloatUnits;
+            // width float is used in adjustWidth
+    bool m_UseBkColour;
+    wxColour m_BkColour;
+            // background color of this container
+    bool m_UseBorder;
+    wxColour m_BorderColour1, m_BorderColour2;
+            // borders color of this container
+    int m_LastLayout;
+            // if != -1 then call to Layout may be no-op
+            // if previous call to Layout has same argument
+
+    DECLARE_NO_COPY_CLASS(wxHtmlContainerCell)
+};
+
+
+
+
+
+//--------------------------------------------------------------------------------
+// wxHtmlColourCell
+//                  Color changer.
+//--------------------------------------------------------------------------------
+
+class WXDLLEXPORT wxHtmlColourCell : public wxHtmlCell
+{
+public:
+    wxHtmlColourCell(const wxColour& clr, int flags = wxHTML_CLR_FOREGROUND) : wxHtmlCell() {m_Colour = clr; m_Flags = flags;}
+    virtual void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2);
+    virtual void DrawInvisible(wxDC& dc, int x, int y);
+
+protected:
+    wxColour m_Colour;
+    unsigned m_Flags;
+};
+
+
+
+
+//--------------------------------------------------------------------------------
+// wxHtmlFontCell
+//                  Sets actual font used for text rendering
+//--------------------------------------------------------------------------------
+
+class WXDLLEXPORT wxHtmlFontCell : public wxHtmlCell
+{
+public:
+    wxHtmlFontCell(wxFont *font) : wxHtmlCell() { m_Font = (*font); }
+    virtual void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2);
+    virtual void DrawInvisible(wxDC& dc, int x, int y);
+
+protected:
+    wxFont m_Font;
+};
+
+
+
+
+
+
+//--------------------------------------------------------------------------------
+// wxHtmlwidgetCell
+//                  This cell is connected with wxWindow object
+//                  You can use it to insert windows into HTML page
+//                  (buttons, input boxes etc.)
+//--------------------------------------------------------------------------------
+
+class WXDLLEXPORT wxHtmlWidgetCell : public wxHtmlCell
+{
+public:
+    // !!! wnd must have correct parent!
+    // if w != 0 then the m_Wnd has 'floating' width - it adjust
+    // it's width according to parent container's width
+    // (w is percent of parent's width)
+    wxHtmlWidgetCell(wxWindow *wnd, int w = 0);
+    ~wxHtmlWidgetCell() { m_Wnd->Destroy(); }
+    virtual void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2);
+    virtual void DrawInvisible(wxDC& dc, int x, int y);
+    virtual void Layout(int w);
+
+protected:
+    wxWindow* m_Wnd;
+    int m_WidthFloat;
+            // width float is used in adjustWidth (it is in percents)
+
+    DECLARE_NO_COPY_CLASS(wxHtmlWidgetCell)
+};
+
+
+
+//--------------------------------------------------------------------------------
+// wxHtmlLinkInfo
+//                  Internal data structure. It represents hypertext link
+//--------------------------------------------------------------------------------
+
+class WXDLLEXPORT wxHtmlLinkInfo : public wxObject
+{
+public:
+    wxHtmlLinkInfo() : wxObject()
+          { m_Href = m_Target = wxEmptyString; m_Event = NULL, m_Cell = NULL; }
+    wxHtmlLinkInfo(const wxString& href, const wxString& target = wxEmptyString) : wxObject()
+          { m_Href = href; m_Target = target; m_Event = NULL, m_Cell = NULL; }
+    wxHtmlLinkInfo(const wxHtmlLinkInfo& l) : wxObject()
+          { m_Href = l.m_Href, m_Target = l.m_Target, m_Event = l.m_Event;
+            m_Cell = l.m_Cell; }
+    wxHtmlLinkInfo& operator=(const wxHtmlLinkInfo& l)
+          { m_Href = l.m_Href, m_Target = l.m_Target, m_Event = l.m_Event;
+            m_Cell = l.m_Cell; return *this; }
+
+    void SetEvent(const wxMouseEvent *e) { m_Event = e; }
+    void SetHtmlCell(const wxHtmlCell *e) { m_Cell = e; }
+
+    wxString GetHref() const { return m_Href; }
+    wxString GetTarget() const { return m_Target; }
+    const wxMouseEvent* GetEvent() const { return m_Event; }
+    const wxHtmlCell* GetHtmlCell() const { return m_Cell; }
+
+private:
+    wxString m_Href, m_Target;
+    const wxMouseEvent *m_Event;
+    const wxHtmlCell *m_Cell;
+};
+
+
+
+
+#endif // wxUSE_HTML
+
+#endif // _WX_HTMLCELL_H_
+

include/wx/html/htmldefs.h

@@ -0,0 +1,157 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        htmldefs.h
+// Purpose:     constants for wxhtml library
+// Author:      Vaclav Slavik
+// RCS-ID:      $Id$
+// Copyright:   (c) 1999 Vaclav Slavik
+// Licence:     wxWindows Licence
+/////////////////////////////////////////////////////////////////////////////
+
+
+#ifndef _WX_HTMLDEFS_H_
+#define _WX_HTMLDEFS_H_
+
+#include "wx/defs.h"
+
+#if wxUSE_HTML
+
+//--------------------------------------------------------------------------------
+// ALIGNMENTS
+//                  Describes alignment of text etc. in containers
+//--------------------------------------------------------------------------------
+
+#define wxHTML_ALIGN_LEFT            0x0000
+#define wxHTML_ALIGN_RIGHT           0x0002
+#define wxHTML_ALIGN_JUSTIFY         0x0010
+
+#define wxHTML_ALIGN_TOP             0x0004
+#define wxHTML_ALIGN_BOTTOM          0x0008
+
+#define wxHTML_ALIGN_CENTER          0x0001
+
+
+
+//--------------------------------------------------------------------------------
+// COLOR MODES
+//                  Used by wxHtmlColourCell to determine clr of what is changing
+//--------------------------------------------------------------------------------
+
+#define wxHTML_CLR_FOREGROUND        0x0001
+#define wxHTML_CLR_BACKGROUND        0x0002
+
+
+
+//--------------------------------------------------------------------------------
+// UNITS
+//                  Used to specify units
+//--------------------------------------------------------------------------------
+
+#define wxHTML_UNITS_PIXELS          0x0001
+#define wxHTML_UNITS_PERCENT         0x0002
+
+
+
+//--------------------------------------------------------------------------------
+// INDENTS
+//                  Used to specify indetation relatives
+//--------------------------------------------------------------------------------
+
+#define wxHTML_INDENT_LEFT           0x0010
+#define wxHTML_INDENT_RIGHT          0x0020
+#define wxHTML_INDENT_TOP            0x0040
+#define wxHTML_INDENT_BOTTOM         0x0080
+
+#define wxHTML_INDENT_HORIZONTAL     wxHTML_INDENT_LEFT | wxHTML_INDENT_RIGHT
+#define wxHTML_INDENT_VERTICAL       wxHTML_INDENT_TOP | wxHTML_INDENT_BOTTOM
+#define wxHTML_INDENT_ALL            wxHTML_INDENT_VERTICAL | wxHTML_INDENT_HORIZONTAL
+
+
+
+
+//--------------------------------------------------------------------------------
+// FIND CONDITIONS
+//                  Identifiers of wxHtmlCell's Find() conditions
+//--------------------------------------------------------------------------------
+
+#define wxHTML_COND_ISANCHOR              1
+        // Finds the anchor of 'param' name (pointer to wxString).
+    
+#define wxHTML_COND_ISIMAGEMAP            2
+        // Finds imagemap of 'param' name (pointer to wxString).
+    // (used exclusively by m_image.cpp)
+    
+#define wxHTML_COND_USER              10000
+        // User-defined conditions should start from this number
+
+
+//--------------------------------------------------------------------------------
+// INTERNALS
+//                  wxHTML internal constants
+//--------------------------------------------------------------------------------
+
+#define wxHTML_SCROLL_STEP               16
+    /* size of one scroll step of wxHtmlWindow in pixels */
+#define wxHTML_BUFLEN                  1024
+    /* size of temporary buffer used during parsing */
+#define wxHTML_REALLOC_STEP              32
+    /* steps of array reallocation */
+#define wxHTML_PRINT_MAX_PAGES          999
+    /* maximum number of pages printable via html printing */
+
+
+    /* default font sizes */
+#ifdef __WXMSW__
+   #define wxHTML_FONT_SIZE_1              7
+   #define wxHTML_FONT_SIZE_2              8
+   #define wxHTML_FONT_SIZE_3             10
+   #define wxHTML_FONT_SIZE_4             12
+   #define wxHTML_FONT_SIZE_5             16
+   #define wxHTML_FONT_SIZE_6             22
+   #define wxHTML_FONT_SIZE_7             30
+#elif defined(__WXMAC__)
+   #define wxHTML_FONT_SIZE_1              9
+   #define wxHTML_FONT_SIZE_2             12
+   #define wxHTML_FONT_SIZE_3             14
+   #define wxHTML_FONT_SIZE_4             18
+   #define wxHTML_FONT_SIZE_5             24
+   #define wxHTML_FONT_SIZE_6             30
+   #define wxHTML_FONT_SIZE_7             36
+#else
+   #define wxHTML_FONT_SIZE_1             10
+   #define wxHTML_FONT_SIZE_2             12
+   #define wxHTML_FONT_SIZE_3             14
+   #define wxHTML_FONT_SIZE_4             16
+   #define wxHTML_FONT_SIZE_5             19
+   #define wxHTML_FONT_SIZE_6             24
+   #define wxHTML_FONT_SIZE_7             32
+#endif
+
+
+#if WXWIN_COMPATIBILITY_2
+
+#define HTML_ALIGN_LEFT            wxHTML_ALIGN_LEFT
+#define HTML_ALIGN_RIGHT           wxHTML_ALIGN_RIGHT
+#define HTML_ALIGN_TOP             wxHTML_ALIGN_TOP
+#define HTML_ALIGN_BOTTOM          wxHTML_ALIGN_BOTTOM
+#define HTML_ALIGN_CENTER          wxHTML_ALIGN_CENTER
+#define HTML_CLR_FOREGROUND        wxHTML_CLR_FOREGROUND
+#define HTML_CLR_BACKGROUND        wxHTML_CLR_BACKGROUND
+#define HTML_UNITS_PIXELS          wxHTML_UNITS_PIXELS
+#define HTML_UNITS_PERCENT         wxHTML_UNITS_PERCENT
+#define HTML_INDENT_LEFT           wxHTML_INDENT_LEFT
+#define HTML_INDENT_RIGHT          wxHTML_INDENT_RIGHT
+#define HTML_INDENT_TOP            wxHTML_INDENT_TOP
+#define HTML_INDENT_BOTTOM         wxHTML_INDENT_BOTTOM
+#define HTML_INDENT_HORIZONTAL     wxHTML_INDENT_HORIZONTAL
+#define HTML_INDENT_VERTICAL       wxHTML_INDENT_VERTICAL
+#define HTML_INDENT_ALL            wxHTML_INDENT_ALL
+#define HTML_COND_ISANCHOR         wxHTML_COND_ISANCHOR
+#define HTML_COND_ISIMAGEMAP       wxHTML_COND_ISIMAGEMAP
+#define HTML_COND_USER             wxHTML_COND_USER
+
+#endif
+
+
+
+#endif
+#endif

include/wx/html/htmlfilt.h

@@ -0,0 +1,87 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        htmlfilt.h
+// Purpose:     filters
+// Author:      Vaclav Slavik
+// RCS-ID:      $Id$
+// Copyright:   (c) 1999 Vaclav Slavik
+// Licence:     wxWindows Licence
+/////////////////////////////////////////////////////////////////////////////
+
+
+#ifndef _WX_HTMLFILT_H_
+#define _WX_HTMLFILT_H_
+
+#if defined(__GNUG__) && !defined(__APPLE__)
+#pragma interface "htmlfilt.h"
+#endif
+
+#include "wx/defs.h"
+
+#if wxUSE_HTML
+
+#include "wx/filesys.h"
+
+
+//--------------------------------------------------------------------------------
+// wxHtmlFilter
+//                  This class is input filter. It can "translate" files
+//                  in non-HTML format to HTML format
+//                  interface to access certain
+//                  kinds of files (HTPP, FTP, local, tar.gz etc..)
+//--------------------------------------------------------------------------------
+
+class WXDLLEXPORT wxHtmlFilter : public wxObject
+{
+    DECLARE_ABSTRACT_CLASS(wxHtmlFilter)
+
+public:
+    wxHtmlFilter() : wxObject() {}
+    virtual ~wxHtmlFilter() {}
+
+    // returns TRUE if this filter is able to open&read given file
+    virtual bool CanRead(const wxFSFile& file) const = 0;
+
+    // Reads given file and returns HTML document.
+    // Returns empty string if opening failed
+    virtual wxString ReadFile(const wxFSFile& file) const = 0;
+};
+
+
+
+//--------------------------------------------------------------------------------
+// wxHtmlFilterPlainText
+//                  This filter is used as default filter if no other can
+//                  be used (= uknown type of file). It is used by
+//                  wxHtmlWindow itself.
+//--------------------------------------------------------------------------------
+
+
+class WXDLLEXPORT wxHtmlFilterPlainText : public wxHtmlFilter
+{
+    DECLARE_DYNAMIC_CLASS(wxHtmlFilterPlainText)
+
+public:
+    virtual bool CanRead(const wxFSFile& file) const;
+    virtual wxString ReadFile(const wxFSFile& file) const;
+};
+
+//--------------------------------------------------------------------------------
+// wxHtmlFilterHTML
+//          filter for text/html
+//--------------------------------------------------------------------------------
+
+class wxHtmlFilterHTML : public wxHtmlFilter
+{
+    DECLARE_DYNAMIC_CLASS(wxHtmlFilterHTML)
+
+    public:
+        virtual bool CanRead(const wxFSFile& file) const;
+        virtual wxString ReadFile(const wxFSFile& file) const;
+};
+
+
+
+#endif // wxUSE_HTML
+
+#endif // _WX_HTMLFILT_H_
+

include/wx/html/htmlpars.h

@@ -0,0 +1,278 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        htmlpars.h
+// Purpose:     wxHtmlParser class (generic parser)
+// Author:      Vaclav Slavik
+// RCS-ID:      $Id$
+// Copyright:   (c) 1999 Vaclav Slavik
+// Licence:     wxWindows Licence
+/////////////////////////////////////////////////////////////////////////////
+
+
+#ifndef _WX_HTMLPARS_H_
+#define _WX_HTMLPARS_H_
+
+#if defined(__GNUG__) && !defined(__APPLE__)
+#pragma interface "htmlpars.h"
+#endif
+
+#include "wx/defs.h"
+#if wxUSE_HTML
+
+#include "wx/html/htmltag.h"
+#include "wx/filesys.h"
+#include "wx/hash.h"
+#include "wx/fontenc.h"
+
+class WXDLLEXPORT wxMBConv;
+class WXDLLEXPORT wxHtmlParser;
+class WXDLLEXPORT wxHtmlTagHandler;
+class WXDLLEXPORT wxHtmlEntitiesParser;
+
+class wxHtmlTextPieces;
+class wxHtmlParserState;
+
+
+enum wxHtmlURLType
+{
+    wxHTML_URL_PAGE,
+    wxHTML_URL_IMAGE,
+    wxHTML_URL_OTHER
+};
+
+// This class handles generic parsing of HTML document : it scans
+// the document and divide it into blocks of tags (where one block
+// consists of starting and ending tag and of text between these
+// 2 tags.
+class WXDLLEXPORT wxHtmlParser : public wxObject
+{
+    DECLARE_ABSTRACT_CLASS(wxHtmlParser)
+
+public:
+    wxHtmlParser();
+    virtual ~wxHtmlParser();
+
+    // Sets the class which will be used for opening files
+    void SetFS(wxFileSystem *fs) { m_FS = fs; }
+
+    wxFileSystem* GetFS() const { return m_FS; }
+
+    // Opens file if the parser is allowed to open given URL (may be forbidden
+    // for security reasons)    
+    virtual wxFSFile *OpenURL(wxHtmlURLType type, const wxString& url) const;
+
+    // You can simply call this method when you need parsed output.
+    // This method does these things:
+    // 1. call InitParser(source);
+    // 2. call DoParsing();
+    // 3. call GetProduct(); (it's return value is then returned)
+    // 4. call DoneParser();
+    wxObject* Parse(const wxString& source);
+
+    // Sets the source. This must be called before running Parse() method.
+    virtual void InitParser(const wxString& source);
+    // This must be called after Parse().
+    virtual void DoneParser();
+    
+    // May be called during parsing to immediately return from Parse().
+    virtual void StopParsing() { m_stopParsing = TRUE; }
+
+    // Parses the m_Source from begin_pos to end_pos-1.
+    // (in noparams version it parses whole m_Source)
+    void DoParsing(int begin_pos, int end_pos);
+    void DoParsing();
+
+    // Returns pointer to the tag at parser's current position
+    wxHtmlTag *GetCurrentTag() const { return m_CurTag; }
+
+    // Returns product of parsing
+    // Returned value is result of parsing of the part. The type of this result
+    // depends on internal representation in derived parser
+    // (see wxHtmlWinParser for details).
+    virtual wxObject* GetProduct() = 0;
+
+    // adds handler to the list & hash table of handlers.
+    virtual void AddTagHandler(wxHtmlTagHandler *handler);
+
+    // Forces the handler to handle additional tags (not returned by GetSupportedTags). 
+    // The handler should already be in use by this parser.
+    // Example: you want to parse following pseudo-html structure:
+    //   <myitems>
+    //     <it name="one" value="1">
+    //     <it name="two" value="2">
+    //   </myitems>
+    //   <it> This last it has different meaning, we don't want it to be parsed by myitems handler!
+    // handler can handle only 'myitems' (e.g. it's GetSupportedTags returns "MYITEMS")
+    // you can call PushTagHandler(handler, "IT") when you find <myitems>
+    // and call PopTagHandler() when you find </myitems>
+    void PushTagHandler(wxHtmlTagHandler *handler, wxString tags);
+
+    // Restores state before last call to PushTagHandler
+    void PopTagHandler();
+
+    wxString* GetSource() {return &m_Source;}
+    void SetSource(const wxString& src);
+    
+    // Sets HTML source and remebers current parser's state so that it can
+    // later be restored. This is useful for on-line modifications of 
+    // HTML source (for example, <pre> handler replaces spaces with &nbsp;
+    // and newlines with <br>)
+    virtual void SetSourceAndSaveState(const wxString& src);
+    // Restores parser's state from stack or returns FALSE if the stack is
+    // empty
+    virtual bool RestoreState();
+    
+    // Parses HTML string 'markup' and extracts charset info from <meta> tag
+    // if present. Returns empty string if the tag is missing.
+    // For wxHTML's internal use.
+    static wxString ExtractCharsetInformation(const wxString& markup);
+
+protected:
+    // DOM structure
+    void CreateDOMTree();
+    void DestroyDOMTree();
+    void CreateDOMSubTree(wxHtmlTag *cur,
+                          int begin_pos, int end_pos, 
+                          wxHtmlTagsCache *cache);
+
+    // Adds text to the output.
+    // This is called from Parse() and must be overriden in derived classes.
+    // txt is not guaranteed to be only one word. It is largest continuous part of text
+    // (= not broken by tags)
+    // NOTE : using char* because of speed improvements
+    virtual void AddText(const wxChar* txt) = 0;
+
+    // Adds tag and proceeds it. Parse() may (and usually is) called from this method.
+    // This is called from Parse() and may be overriden.
+    // Default behavior is that it looks for proper handler in m_Handlers. The tag is
+    // ignored if no hander is found.
+    // Derived class is *responsible* for filling in m_Handlers table.
+    virtual void AddTag(const wxHtmlTag& tag);
+    
+    // Returns entity parser object, used to substitute HTML &entities;
+    wxHtmlEntitiesParser *GetEntitiesParser() const { return m_entitiesParser; }
+
+protected:
+    // DOM tree:
+    wxHtmlTag *m_CurTag;
+    wxHtmlTag *m_Tags;
+    wxHtmlTextPieces *m_TextPieces;
+    size_t m_CurTextPiece;
+
+    wxString m_Source;
+    
+    wxHtmlParserState *m_SavedStates;
+    
+    // handlers that handle particular tags. The table is accessed by
+    // key = tag's name.
+    // This attribute MUST be filled by derived class otherwise it would
+    // be empty and no tags would be recognized
+    // (see wxHtmlWinParser for details about filling it)
+    // m_HandlersHash is for random access based on knowledge of tag name (BR, P, etc.)
+    //      it may (and often does) contain more references to one object
+    // m_HandlersList is list of all handlers and it is guaranteed to contain
+    //      only one reference to each handler instance.
+    wxList m_HandlersList;
+    wxHashTable m_HandlersHash;
+
+    DECLARE_NO_COPY_CLASS(wxHtmlParser)
+
+    // class for opening files (file system)
+    wxFileSystem *m_FS;
+    // handlers stack used by PushTagHandler and PopTagHandler
+    wxList *m_HandlersStack;
+    
+    // entity parse
+    wxHtmlEntitiesParser *m_entitiesParser;
+    
+    // flag indicating that the parser should stop
+    bool m_stopParsing;
+};
+
+
+
+// This class (and derived classes) cooperates with wxHtmlParser.
+// Each recognized tag is passed to handler which is capable
+// of handling it. Each tag is handled in 3 steps:
+// 1. Handler will modifies state of parser
+//    (using it's public methods)
+// 2. Parser parses source between starting and ending tag
+// 3. Handler restores original state of the parser
+class WXDLLEXPORT wxHtmlTagHandler : public wxObject
+{
+    DECLARE_ABSTRACT_CLASS(wxHtmlTagHandler)
+
+public:
+    wxHtmlTagHandler() : wxObject () { m_Parser = NULL; }
+
+    // Sets the parser.
+    // NOTE : each _instance_ of handler is guaranteed to be called
+    // only by one parser. This means you don't have to care about
+    // reentrancy.
+    virtual void SetParser(wxHtmlParser *parser) 
+        { m_Parser = parser; }
+
+    // Returns list of supported tags. The list is in uppercase and
+    // tags are delimited by ','.
+    // Example : "I,B,FONT,P"
+    //   is capable of handling italic, bold, font and paragraph tags
+    virtual wxString GetSupportedTags() = 0;
+
+    // This is hadling core method. It does all the Steps 1-3.
+    // To process step 2, you can call ParseInner()
+    // returned value : TRUE if it called ParseInner(),
+    //                  FALSE etherwise
+    virtual bool HandleTag(const wxHtmlTag& tag) = 0;
+
+protected:
+    // parses input between beginning and ending tag.
+    // m_Parser must be set.
+    void ParseInner(const wxHtmlTag& tag) 
+        { m_Parser->DoParsing(tag.GetBeginPos(), tag.GetEndPos1()); }
+
+    wxHtmlParser *m_Parser;
+
+    DECLARE_NO_COPY_CLASS(wxHtmlTagHandler)
+};
+
+
+// This class is used to parse HTML entities in strings. It can handle
+// both named entities and &#xxxx entries where xxxx is Unicode code.
+class WXDLLEXPORT wxHtmlEntitiesParser : public wxObject
+{
+    DECLARE_DYNAMIC_CLASS(wxHtmlEntitiesParser)
+
+public:
+    wxHtmlEntitiesParser();
+    virtual ~wxHtmlEntitiesParser();
+    
+    // Sets encoding of output string.
+    // Has no effect if wxUSE_WCHAR_T==0 or wxUSE_UNICODE==1
+    void SetEncoding(wxFontEncoding encoding);
+    
+    // Parses entities in input and replaces them with respective characters
+    // (with respect to output encoding)
+    wxString Parse(const wxString& input);
+
+    // Returns character for given entity or 0 if the enity is unknown
+    wxChar GetEntityChar(const wxString& entity);
+
+    // Returns character that represents given Unicode code
+#if wxUSE_UNICODE
+    wxChar GetCharForCode(unsigned code) { return (wxChar)code; }
+#else
+    wxChar GetCharForCode(unsigned code);
+#endif
+
+protected:
+#if wxUSE_WCHAR_T && !wxUSE_UNICODE
+    wxMBConv *m_conv;
+    wxFontEncoding m_encoding;
+#endif
+
+    DECLARE_NO_COPY_CLASS(wxHtmlEntitiesParser)
+};
+
+
+#endif
+
+#endif // _WX_HTMLPARS_H_

include/wx/html/htmlproc.h

@@ -0,0 +1,64 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        htmlprep.h
+// Purpose:     HTML processor
+// Author:      Vaclav Slavik
+// RCS-ID:      $Id$
+// Copyright:   (c) 2001 Vaclav Slavik
+// Licence:     wxWindows Licence
+/////////////////////////////////////////////////////////////////////////////
+
+
+#ifndef _WX_HTMLPREP_H_
+#define _WX_HTMLPREP_H_
+
+#if defined(__GNUG__) && !defined(__APPLE__)
+#pragma interface "htmlproc.h"
+// (implementation is in htmlwin.cpp, there's no htmlprep.cpp!)
+#endif
+
+#include "wx/defs.h"
+
+#if wxUSE_HTML
+
+#include "wx/string.h"
+
+// Priority of preprocessor in the chain. The higher, the earlier it is used
+enum
+{
+    wxHTML_PRIORITY_DONTCARE = 128, // if the order doesn't matter, use this
+                                    // priority
+    wxHTML_PRIORITY_SYSTEM   = 256  // >=256 is only for wxHTML's internals
+};
+
+// Classes derived from this class serve as simple text processors for 
+// wxHtmlWindow. wxHtmlWindow runs HTML markup through all registered
+// processors before displaying it, thus allowing for on-the-fly
+// modifications of the markup.
+
+class WXDLLEXPORT wxHtmlProcessor : public wxObject
+{
+    DECLARE_ABSTRACT_CLASS(wxHtmlProcessor)
+
+public:
+    wxHtmlProcessor() : wxObject(), m_enabled(TRUE) {}
+    virtual ~wxHtmlProcessor() {}
+
+    // Process input text and return processed result
+    virtual wxString Process(const wxString& text) const = 0;
+
+    // Return priority value of this processor. The higher, the sooner
+    // is the processor applied to the text.
+    virtual int GetPriority() const { return wxHTML_PRIORITY_DONTCARE; }
+    
+    // Enable/disable the processor. wxHtmlWindow won't use a disabled 
+    // processor even if it is in its processors queue.
+    virtual void Enable(bool enable = TRUE) { m_enabled = enable; }
+    bool IsEnabled() const { return m_enabled; }
+    
+protected:
+    bool m_enabled;
+};
+
+#endif // wxUSE_HTML
+
+#endif // _WX_HTMLPROC_H_

include/wx/html/htmltag.h

@@ -0,0 +1,158 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        htmltag.h
+// Purpose:     wxHtmlTag class (represents single tag)
+// Author:      Vaclav Slavik
+// RCS-ID:      $Id$
+// Copyright:   (c) 1999 Vaclav Slavik
+// Licence:     wxWindows Licence
+/////////////////////////////////////////////////////////////////////////////
+
+
+#ifndef _WX_HTMLTAG_H_
+#define _WX_HTMLTAG_H_
+
+#if defined(__GNUG__) && !defined(__APPLE__)
+#pragma interface "htmltag.h"
+#endif
+
+#include "wx/defs.h"
+
+#if wxUSE_HTML
+
+#include "wx/object.h"
+
+class WXDLLEXPORT wxColour;
+class WXDLLEXPORT wxHtmlEntitiesParser;
+
+//-----------------------------------------------------------------------------
+// wxHtmlTagsCache
+//          - internal wxHTML class, do not use!
+//-----------------------------------------------------------------------------
+
+struct wxHtmlCacheItem;
+
+class WXDLLEXPORT wxHtmlTagsCache : public wxObject
+{
+    DECLARE_DYNAMIC_CLASS(wxHtmlTagsCache)
+
+private:
+    wxHtmlCacheItem *m_Cache;
+    int m_CacheSize;
+    int m_CachePos;
+
+public:
+    wxHtmlTagsCache() : wxObject() {m_CacheSize = 0; m_Cache = NULL;}
+    wxHtmlTagsCache(const wxString& source);
+    ~wxHtmlTagsCache() {free(m_Cache);}
+
+    // Finds parameters for tag starting at at and fills the variables
+    void QueryTag(int at, int* end1, int* end2);
+
+    DECLARE_NO_COPY_CLASS(wxHtmlTagsCache)
+};
+
+
+//--------------------------------------------------------------------------------
+// wxHtmlTag
+//                  This represents single tag. It is used as internal structure
+//                  by wxHtmlParser.
+//--------------------------------------------------------------------------------
+
+class WXDLLEXPORT wxHtmlTag : public wxObject
+{
+    DECLARE_CLASS(wxHtmlTag)
+
+protected:
+    // constructs wxHtmlTag object based on HTML tag.
+    // The tag begins (with '<' character) at position pos in source
+    // end_pos is position where parsing ends (usually end of document)
+    wxHtmlTag(wxHtmlTag *parent,
+              const wxString& source, int pos, int end_pos,
+              wxHtmlTagsCache *cache,
+              wxHtmlEntitiesParser *entParser);
+    friend class wxHtmlParser;
+public:
+    ~wxHtmlTag();
+
+    wxHtmlTag *GetParent() const {return m_Parent;}
+    wxHtmlTag *GetFirstSibling() const;
+    wxHtmlTag *GetLastSibling() const;
+    wxHtmlTag *GetChildren() const { return m_FirstChild; }
+    wxHtmlTag *GetPreviousSibling() const { return m_Prev; }
+    wxHtmlTag *GetNextSibling() const {return m_Next; }
+    // Return next tag, as if tree had been flattened
+    wxHtmlTag *GetNextTag() const;
+
+    // Returns tag's name in uppercase.
+    inline wxString GetName() const {return m_Name;}
+
+    // Returns TRUE if the tag has given parameter. Parameter
+    // should always be in uppercase.
+    // Example : <IMG SRC="test.jpg"> HasParam("SRC") returns TRUE
+    bool HasParam(const wxString& par) const;
+
+    // Returns value of the param. Value is in uppercase unless it is
+    // enclosed with "
+    // Example : <P align=right> GetParam("ALIGN") returns (RIGHT)
+    //           <P IMG SRC="WhaT.jpg"> GetParam("SRC") returns (WhaT.jpg)
+    //                           (or ("WhaT.jpg") if with_commas == TRUE)
+    wxString GetParam(const wxString& par, bool with_commas = FALSE) const;
+
+    // Convenience functions:
+    bool GetParamAsColour(const wxString& par, wxColour *clr) const;
+    bool GetParamAsInt(const wxString& par, int *clr) const;
+
+    // Scans param like scanf() functions family does.
+    // Example : ScanParam("COLOR", "\"#%X\"", &clr);
+    // This is always with with_commas=FALSE
+    // Returns number of scanned values
+    // (like sscanf() does)
+    // NOTE: unlike scanf family, this function only accepts
+    //       *one* parameter !
+    int ScanParam(const wxString& par, const wxChar *format, void *param) const;
+
+    // Returns string containing all params.
+    wxString GetAllParams() const;
+
+#if WXWIN_COMPATIBILITY_2_2
+    // return TRUE if this is ending tag (</something>) or FALSE
+    // if it isn't (<something>)
+    inline bool IsEnding() const {return FALSE;}
+#endif
+
+    // return TRUE if this there is matching ending tag
+    inline bool HasEnding() const {return m_End1 >= 0;}
+
+    // returns beginning position of _internal_ block of text
+    // See explanation (returned value is marked with *):
+    // bla bla bla <MYTAG>* bla bla intenal text</MYTAG> bla bla
+    inline int GetBeginPos() const {return m_Begin;}
+    // returns ending position of _internal_ block of text.
+    // bla bla bla <MYTAG> bla bla intenal text*</MYTAG> bla bla
+    inline int GetEndPos1() const {return m_End1;}
+    // returns end position 2 :
+    // bla bla bla <MYTAG> bla bla internal text</MYTAG>* bla bla
+    inline int GetEndPos2() const {return m_End2;}
+
+private:
+    wxString m_Name;
+    int m_Begin, m_End1, m_End2;
+    wxArrayString m_ParamNames, m_ParamValues;
+
+    // DOM tree relations:
+    wxHtmlTag *m_Next;
+    wxHtmlTag *m_Prev;
+    wxHtmlTag *m_FirstChild, *m_LastChild;
+    wxHtmlTag *m_Parent;
+
+    DECLARE_NO_COPY_CLASS(wxHtmlTag)
+};
+
+
+
+
+
+#endif
+
+#endif // _WX_HTMLTAG_H_
+

include/wx/html/htmlwin.h

@@ -0,0 +1,284 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        htmlwin.h
+// Purpose:     wxHtmlWindow class for parsing & displaying HTML
+// Author:      Vaclav Slavik
+// RCS-ID:      $Id$
+// Copyright:   (c) 1999 Vaclav Slavik
+// Licence:     wxWindows Licence
+/////////////////////////////////////////////////////////////////////////////
+
+
+#ifndef _WX_HTMLWIN_H_
+#define _WX_HTMLWIN_H_
+
+#if defined(__GNUG__) && !defined(__APPLE__)
+#pragma interface "htmlwin.h"
+#endif
+
+#include "wx/defs.h"
+#if wxUSE_HTML
+
+#include "wx/window.h"
+#include "wx/scrolwin.h"
+#include "wx/config.h"
+#include "wx/treectrl.h"
+#include "wx/html/winpars.h"
+#include "wx/html/htmlcell.h"
+#include "wx/filesys.h"
+#include "wx/html/htmlfilt.h"
+#include "wx/filename.h"
+
+class wxHtmlProcessor;
+class wxHtmlWinModule;
+class wxHtmlHistoryArray;
+class wxHtmlProcessorList;
+
+
+// wxHtmlWindow flags:
+#define wxHW_SCROLLBAR_NEVER    0x0002
+#define wxHW_SCROLLBAR_AUTO     0x0004
+
+// enums for wxHtmlWindow::OnOpeningURL
+enum wxHtmlOpeningStatus
+{
+    wxHTML_OPEN,
+    wxHTML_BLOCK,
+    wxHTML_REDIRECT
+};
+
+//--------------------------------------------------------------------------------
+// wxHtmlWindow
+//                  (This is probably the only class you will directly use.)
+//                  Purpose of this class is to display HTML page (either local
+//                  file or downloaded via HTTP protocol) in a window. Width
+//                  of window is constant - given in constructor - virtual height
+//                  is changed dynamicly depending on page size.
+//                  Once the window is created you can set it's content by calling
+//                  SetPage(text) or LoadPage(filename).
+//--------------------------------------------------------------------------------
+
+class WXDLLEXPORT wxHtmlWindow : public wxScrolledWindow
+{
+    DECLARE_DYNAMIC_CLASS(wxHtmlWindow)
+    friend class wxHtmlWinModule;
+
+public:
+    wxHtmlWindow() { Init(); }
+    wxHtmlWindow(wxWindow *parent, wxWindowID id = -1,
+                 const wxPoint& pos = wxDefaultPosition,
+                 const wxSize& size = wxDefaultSize,
+                 long style = wxHW_SCROLLBAR_AUTO,
+                 const wxString& name = wxT("htmlWindow"))
+    {
+        Init();
+        Create(parent, id, pos, size, style, name);
+    }
+    ~wxHtmlWindow();
+
+    bool Create(wxWindow *parent, wxWindowID id = -1,
+                const wxPoint& pos = wxDefaultPosition,
+                const wxSize& size = wxDefaultSize,
+                long style = wxHW_SCROLLBAR_AUTO,
+                const wxString& name = wxT("htmlWindow"));
+
+    // Set HTML page and display it. !! source is HTML document itself,
+    // it is NOT address/filename of HTML document. If you want to
+    // specify document location, use LoadPage() istead
+    // Return value : FALSE if an error occured, TRUE otherwise
+    bool SetPage(const wxString& source);
+
+    // Append to current page
+    bool AppendToPage(const wxString& source);
+
+    // Load HTML page from given location. Location can be either
+    // a) /usr/wxGTK2/docs/html/wx.htm
+    // b) http://www.somewhere.uk/document.htm
+    // c) ftp://ftp.somesite.cz/pub/something.htm
+    // In case there is no prefix (http:,ftp:), the method
+    // will try to find it itself (1. local file, then http or ftp)
+    // After the page is loaded, the method calls SetPage() to display it.
+    // Note : you can also use path relative to previously loaded page
+    // Return value : same as SetPage
+    virtual bool LoadPage(const wxString& location);
+
+    // Loads HTML page from file
+    bool LoadFile(const wxFileName& filename);
+
+    // Returns full location of opened page
+    wxString GetOpenedPage() const {return m_OpenedPage;}
+    // Returns anchor within opened page
+    wxString GetOpenedAnchor() const {return m_OpenedAnchor;}
+    // Returns <TITLE> of opened page or empty string otherwise
+    wxString GetOpenedPageTitle() const {return m_OpenedPageTitle;}
+
+    // Sets frame in which page title will  be displayed. Format is format of
+    // frame title, e.g. "HtmlHelp : %s". It must contain exactly one %s
+    void SetRelatedFrame(wxFrame* frame, const wxString& format);
+    wxFrame* GetRelatedFrame() const {return m_RelatedFrame;}
+
+    // After(!) calling SetRelatedFrame, this sets statusbar slot where messages
+    // will be displayed. Default is -1 = no messages.
+    void SetRelatedStatusBar(int bar);
+
+    // Sets fonts to be used when displaying HTML page.
+    void SetFonts(wxString normal_face, wxString fixed_face,
+                  const int *sizes = NULL);
+
+    // Sets space between text and window borders.
+    void SetBorders(int b) {m_Borders = b;}
+
+    // Saves custom settings into cfg config. it will use the path 'path'
+    // if given, otherwise it will save info into currently selected path.
+    // saved values : things set by SetFonts, SetBorders.
+    virtual void ReadCustomization(wxConfigBase *cfg, wxString path = wxEmptyString);
+    // ...
+    virtual void WriteCustomization(wxConfigBase *cfg, wxString path = wxEmptyString);
+
+    // Goes to previous/next page (in browsing history)
+    // Returns TRUE if successful, FALSE otherwise
+    bool HistoryBack();
+    bool HistoryForward();
+    bool HistoryCanBack();
+    bool HistoryCanForward();
+    // Resets history
+    void HistoryClear();
+
+    // Returns pointer to conteiners/cells structure.
+    // It should be used ONLY when printing
+    wxHtmlContainerCell* GetInternalRepresentation() const {return m_Cell;}
+
+    // Adds input filter
+    static void AddFilter(wxHtmlFilter *filter);
+
+    // Returns a pointer to the parser.
+    wxHtmlWinParser *GetParser() const { return m_Parser; }
+
+    // Adds HTML processor to this instance of wxHtmlWindow:
+    void AddProcessor(wxHtmlProcessor *processor);
+    // Adds HTML processor to wxHtmlWindow class as whole:
+    static void AddGlobalProcessor(wxHtmlProcessor *processor);
+
+    // what would we do with it?
+    virtual bool AcceptsFocusFromKeyboard() const { return FALSE; }
+
+    // -- Callbacks --
+
+    // Sets the title of the window
+    // (depending on the information passed to SetRelatedFrame() method)
+    virtual void OnSetTitle(const wxString& title);
+
+    // Called when the mouse hovers over a cell: (x, y) are logical coords
+    // Default behaviour is to do nothing at all
+    virtual void OnCellMouseHover(wxHtmlCell *cell, wxCoord x, wxCoord y);
+
+    // Called when user clicks on a cell. Default behavior is to call
+    // OnLinkClicked() if this cell corresponds to a hypertext link
+    virtual void OnCellClicked(wxHtmlCell *cell,
+                               wxCoord x, wxCoord y,
+                               const wxMouseEvent& event);
+
+    // Called when user clicked on hypertext link. Default behavior is to
+    // call LoadPage(loc)
+    virtual void OnLinkClicked(const wxHtmlLinkInfo& link);
+
+    // Called when wxHtmlWindow wants to fetch data from an URL (e.g. when
+    // loading a page or loading an image). The data are downloaded if and only if
+    // OnOpeningURL returns TRUE. If OnOpeningURL returns wxHTML_REDIRECT,
+    // it must set *redirect to the new URL
+    virtual wxHtmlOpeningStatus OnOpeningURL(wxHtmlURLType WXUNUSED(type),
+                                             const wxString& WXUNUSED(url),
+                                             wxString *WXUNUSED(redirect)) const
+        { return wxHTML_OPEN; }
+
+protected:
+    void Init();
+
+    // Scrolls to anchor of this name. (Anchor is #news
+    // or #features etc. it is part of address sometimes:
+    // http://www.ms.mff.cuni.cz/~vsla8348/wxhtml/index.html#news)
+    // Return value : TRUE if anchor exists, FALSE otherwise
+    bool ScrollToAnchor(const wxString& anchor);
+
+    // Prepares layout (= fill m_PosX, m_PosY for fragments) based on
+    // actual size of window. This method also setup scrollbars
+    void CreateLayout();
+
+    void OnDraw(wxDC& dc);
+    void OnSize(wxSizeEvent& event);
+    void OnMouseEvent(wxMouseEvent& event);
+    void OnIdle(wxIdleEvent& event);
+
+    // Returns new filter (will be stored into m_DefaultFilter variable)
+    virtual wxHtmlFilter *GetDefaultFilter() {return new wxHtmlFilterPlainText;}
+
+    // cleans static variables
+    static void CleanUpStatics();
+
+protected:
+    // This is pointer to the first cell in parsed data.
+    // (Note: the first cell is usually top one = all other cells are sub-cells of this one)
+    wxHtmlContainerCell *m_Cell;
+    // parser which is used to parse HTML input.
+    // Each wxHtmlWindow has it's own parser because sharing one global
+    // parser would be problematic (because of reentrancy)
+    wxHtmlWinParser *m_Parser;
+    // contains name of actualy opened page or empty string if no page opened
+    wxString m_OpenedPage;
+    // contains name of current anchor within m_OpenedPage
+    wxString m_OpenedAnchor;
+    // contains title of actualy opened page or empty string if no <TITLE> tag
+    wxString m_OpenedPageTitle;
+    // class for opening files (file system)
+    wxFileSystem* m_FS;
+
+    wxFrame *m_RelatedFrame;
+    wxString m_TitleFormat;
+    // frame in which page title should be displayed & number of it's statusbar
+    // reserved for usage with this html window
+    int m_RelatedStatusBar;
+
+    // borders (free space between text and window borders)
+    // defaults to 10 pixels.
+    int m_Borders;
+
+    int m_Style;
+
+private:
+    // a flag indicated if mouse moved
+    // (if TRUE we will try to change cursor in last call to OnIdle)
+    bool m_tmpMouseMoved;
+    // contains last link name
+    wxHtmlLinkInfo *m_tmpLastLink;
+    // contains the last (terminal) cell which contained the mouse
+    wxHtmlCell *m_tmpLastCell;
+    // if >0 contents of the window is not redrawn
+    // (in order to avoid ugly blinking)
+    int m_tmpCanDrawLocks;
+
+    // list of HTML filters
+    static wxList m_Filters;
+    // this filter is used when no filter is able to read some file
+    static wxHtmlFilter *m_DefaultFilter;
+
+    static wxCursor *s_cur_hand;
+    static wxCursor *s_cur_arrow;
+
+    wxHtmlHistoryArray *m_History;
+    // browser history
+    int m_HistoryPos;
+    // if this FLAG is false, items are not added to history
+    bool m_HistoryOn;
+
+    // html processors array:
+    wxHtmlProcessorList *m_Processors;
+    static wxHtmlProcessorList *m_GlobalProcessors;
+
+    DECLARE_EVENT_TABLE()
+    DECLARE_NO_COPY_CLASS(wxHtmlWindow)
+};
+
+
+#endif
+
+#endif // _WX_HTMLWIN_H_
+

include/wx/html/htmprint.h

@@ -0,0 +1,258 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        htmprint.h
+// Purpose:     html printing classes
+// Author:      Vaclav Slavik
+// Created:     25/09/99
+// RCS-ID:      $Id$
+// Copyright:   (c)
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_HTMPRINT_H_
+#define _WX_HTMPRINT_H_
+
+#if defined(__GNUG__) && !defined(__APPLE__)
+#pragma interface "htmprint.h"
+#endif
+
+#include "wx/defs.h"
+
+#if wxUSE_HTML & wxUSE_PRINTING_ARCHITECTURE
+
+#include "wx/html/htmlcell.h"
+#include "wx/html/winpars.h"
+
+#include "wx/print.h"
+#include "wx/printdlg.h"
+
+#include <limits.h> // INT_MAX
+
+//--------------------------------------------------------------------------------
+// wxHtmlDCRenderer
+//                  This class is capable of rendering HTML into specified 
+//                  portion of DC
+//--------------------------------------------------------------------------------
+
+class WXDLLEXPORT wxHtmlDCRenderer : public wxObject
+{
+public:
+    wxHtmlDCRenderer();
+    ~wxHtmlDCRenderer();
+
+    // Following 3 methods *must* be called before any call to Render:
+
+    // Assign DC to this render
+    void SetDC(wxDC *dc, double pixel_scale = 1.0);
+
+    // Sets size of output rectangle, in pixels. Note that you *can't* change
+    // width of the rectangle between calls to Render! (You can freely change height.)
+    void SetSize(int width, int height);
+
+    // Sets the text to be displayed.
+    // Basepath is base directory (html string would be stored there if it was in
+    // file). It is used to determine path for loading images, for example.
+    // isdir is FALSE if basepath is filename, TRUE if it is directory name
+    // (see wxFileSystem for detailed explanation)
+    void SetHtmlText(const wxString& html, const wxString& basepath = wxEmptyString, bool isdir = TRUE);
+
+    // Sets fonts to be used when displaying HTML page. (if size null then default sizes used).
+    void SetFonts(wxString normal_face, wxString fixed_face, const int *sizes = NULL);
+
+    // [x,y] is position of upper-left corner of printing rectangle (see SetSize)
+    // from is y-coordinate of the very first visible cell
+    // to is y-coordinate of the next following page break, if any
+    // Returned value is y coordinate of first cell than didn't fit onto page.
+    // Use this value as 'from' in next call to Render in order to print multiple pages
+    // document
+    // If dont_render is TRUE then nothing is rendered into DC and it only counts
+    // pixels and return y coord of the next page
+    //
+    // known_pagebreaks and number_of_pages are used only when counting pages;
+    // otherwise, their default values should be used. Their purpose is to
+    // support pagebreaks using a subset of CSS2's <DIV>. The <DIV> handler
+    // needs to know what pagebreaks have already been set so that it doesn't
+    // set the same pagebreak twice.
+    //
+    // CAUTION! Render() changes DC's user scale and does NOT restore it!
+    int Render(int x, int y, int from = 0, int dont_render = FALSE, int to = INT_MAX,
+               int *known_pagebreaks = NULL, int number_of_pages = 0);
+
+    // returns total height of the html document
+    // (compare Render's return value with this)
+    int GetTotalHeight();
+
+private:
+    wxDC *m_DC;
+    wxHtmlWinParser *m_Parser;
+    wxFileSystem *m_FS;
+    wxHtmlContainerCell *m_Cells;
+    int m_MaxWidth, m_Width, m_Height;
+
+    DECLARE_NO_COPY_CLASS(wxHtmlDCRenderer)
+};
+
+
+
+
+
+enum {
+    wxPAGE_ODD,
+    wxPAGE_EVEN,
+    wxPAGE_ALL
+};
+
+
+
+//--------------------------------------------------------------------------------
+// wxHtmlPrintout
+//                  This class is derived from standard wxWindows printout class
+//                  and is used to print HTML documents.
+//--------------------------------------------------------------------------------
+
+
+class WXDLLEXPORT wxHtmlPrintout : public wxPrintout
+{
+public:
+    wxHtmlPrintout(const wxString& title = wxT("Printout"));
+    ~wxHtmlPrintout();
+
+    void SetHtmlText(const wxString& html, const wxString &basepath = wxEmptyString, bool isdir = TRUE); 
+            // prepares the class for printing this html document.
+            // Must be called before using the class, in fact just after constructor
+            //
+            // basepath is base directory (html string would be stored there if it was in
+            // file). It is used to determine path for loading images, for example.
+            // isdir is FALSE if basepath is filename, TRUE if it is directory name
+            // (see wxFileSystem for detailed explanation)
+
+    void SetHtmlFile(const wxString &htmlfile);
+            // same as SetHtmlText except that it takes regular file as the parameter
+
+    void SetHeader(const wxString& header, int pg = wxPAGE_ALL);
+    void SetFooter(const wxString& footer, int pg = wxPAGE_ALL);
+            // sets header/footer for the document. The argument is interpreted as HTML document.
+            // You can use macros in it:
+            //   @PAGENUM@ is replaced by page number
+            //   @PAGESCNT@ is replaced by total number of pages
+            //
+            // pg is one of wxPAGE_ODD, wxPAGE_EVEN and wx_PAGE_ALL constants.
+            // You can set different header/footer for odd and even pages
+
+    // Sets fonts to be used when displaying HTML page. (if size null then default sizes used).
+    void SetFonts(wxString normal_face, wxString fixed_face, const int *sizes = NULL);
+
+    void SetMargins(float top = 25.2, float bottom = 25.2, float left = 25.2, float right = 25.2, 
+                    float spaces = 5);
+            // sets margins in milimeters. Defaults to 1 inch for margins and 0.5cm for space
+            // between text and header and/or footer
+
+    // wxPrintout stuff:        
+    bool OnPrintPage(int page);
+    bool HasPage(int page);
+    void GetPageInfo(int *minPage, int *maxPage, int *selPageFrom, int *selPageTo);
+    bool OnBeginDocument(int startPage, int endPage);
+
+private:
+
+    void RenderPage(wxDC *dc, int page);
+            // renders one page into dc
+    wxString TranslateHeader(const wxString& instr, int page);
+            // substitute @PAGENUM@ and @PAGESCNT@ by real values
+    void CountPages();
+            // counts pages and fills m_NumPages and m_PageBreaks
+
+
+private:
+    int m_NumPages;
+    int m_PageBreaks[wxHTML_PRINT_MAX_PAGES];
+
+    wxString m_Document, m_BasePath;
+    bool m_BasePathIsDir;
+    wxString m_Headers[2], m_Footers[2];
+
+    int m_HeaderHeight, m_FooterHeight;
+    wxHtmlDCRenderer *m_Renderer, *m_RendererHdr;
+    float m_MarginTop, m_MarginBottom, m_MarginLeft, m_MarginRight, m_MarginSpace;
+
+    DECLARE_NO_COPY_CLASS(wxHtmlPrintout)
+};
+
+
+
+
+
+//--------------------------------------------------------------------------------
+// wxHtmlEasyPrinting
+//                  This class provides very simple interface to printing 
+//                  architecture. It allows you to print HTML documents only
+//                  with very few commands. 
+//
+//                  Note : do not create this class on stack only.
+//                         You should create an instance on app startup and 
+//                         use this instance for all printing. Why? The class
+//                         stores page&printer settings in it.
+//--------------------------------------------------------------------------------
+
+class WXDLLEXPORT wxHtmlEasyPrinting : public wxObject
+{
+public:
+    wxHtmlEasyPrinting(const wxString& name = wxT("Printing"), wxFrame *parent_frame = NULL);
+    ~wxHtmlEasyPrinting();
+
+    bool PreviewFile(const wxString &htmlfile);
+    bool PreviewText(const wxString &htmltext, const wxString& basepath = wxEmptyString);
+            // Preview file / html-text for printing
+            // (and offers printing)
+            // basepath is base directory for opening subsequent files (e.g. from <img> tag)
+
+    bool PrintFile(const wxString &htmlfile);
+    bool PrintText(const wxString &htmltext, const wxString& basepath = wxEmptyString);
+            // Print file / html-text w/o preview
+
+    void PrinterSetup();
+    void PageSetup();
+            // pop up printer or page setup dialog
+
+    void SetHeader(const wxString& header, int pg = wxPAGE_ALL);
+    void SetFooter(const wxString& footer, int pg = wxPAGE_ALL);
+            // sets header/footer for the document. The argument is interpreted as HTML document.
+            // You can use macros in it:
+            //   @PAGENUM@ is replaced by page number
+            //   @PAGESCNT@ is replaced by total number of pages
+            //
+            // pg is one of wxPAGE_ODD, wxPAGE_EVEN and wx_PAGE_ALL constants.
+            // You can set different header/footer for odd and even pages
+
+    void SetFonts(wxString normal_face, wxString fixed_face, const int *sizes = 0);
+    // Sets fonts to be used when displaying HTML page. (if size null then default sizes used)
+
+    wxPrintData *GetPrintData() {return m_PrintData;}
+    wxPageSetupDialogData *GetPageSetupData() {return m_PageSetupData;}
+            // return page setting data objects. 
+            // (You can set their parameters.)
+
+protected:
+    virtual wxHtmlPrintout *CreatePrintout();
+    virtual bool DoPreview(wxHtmlPrintout *printout1, wxHtmlPrintout *printout2);
+    virtual bool DoPrint(wxHtmlPrintout *printout);
+
+private:
+    wxPrintData *m_PrintData;
+    wxPageSetupDialogData *m_PageSetupData;
+    wxString m_Name;
+    int m_FontsSizesArr[7];
+    int *m_FontsSizes;
+    wxString m_FontFaceFixed, m_FontFaceNormal;
+    wxString m_Headers[2], m_Footers[2];
+    wxFrame *m_Frame;
+
+    DECLARE_NO_COPY_CLASS(wxHtmlEasyPrinting)
+};
+
+
+
+
+#endif  // wxUSE_HTML & wxUSE_PRINTING_ARCHITECTURE
+
+#endif // _WX_HTMPRINT_H_
+

include/wx/html/m_templ.h

@@ -0,0 +1,84 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        m_templ.h
+// Purpose:     Modules template file
+// Author:      Vaclav Slavik
+// RCS-ID:      $Id$
+// Copyright:   (c) Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+/*
+
+DESCRIPTION:
+This is set of macros for easier writing of tag handlers. How to use it?
+See mod_fonts.cpp for example...
+
+Attention! This is quite strange C++ bastard. Before using it,
+I STRONGLY recommend reading and understanding these macros!!
+
+*/
+
+
+#ifndef _WX_M_TEMPL_H_
+#define _WX_M_TEMPL_H_
+
+#include "wx/defs.h"
+
+#if wxUSE_HTML
+
+#include "wx/html/winpars.h"
+
+#define TAG_HANDLER_BEGIN(name,tags)                                      \
+    class HTML_Handler_##name : public wxHtmlWinTagHandler                \
+    {                                                                     \
+        public:                                                           \
+            wxString GetSupportedTags() {return wxT(tags);}
+
+
+
+#define TAG_HANDLER_VARS                                                  \
+        private:
+
+#define TAG_HANDLER_CONSTR(name)                                                \
+        public:                                                           \
+        HTML_Handler_##name () : wxHtmlWinTagHandler()
+
+
+#define TAG_HANDLER_PROC(varib)                                           \
+        public:                                                           \
+            bool HandleTag(const wxHtmlTag& varib)
+
+
+
+#define TAG_HANDLER_END(name)                                             \
+    };
+
+
+
+
+#define TAGS_MODULE_BEGIN(name)                                           \
+    class HTML_Module##name : public wxHtmlTagsModule                     \
+    {                                                                     \
+        DECLARE_DYNAMIC_CLASS(HTML_Module##name )                         \
+        public:                                                           \
+            void FillHandlersTable(wxHtmlWinParser *parser)               \
+                {
+
+
+
+
+#define TAGS_MODULE_ADD(handler)                                          \
+                    parser->AddTagHandler(new HTML_Handler_##handler);
+
+
+
+
+#define TAGS_MODULE_END(name)                                             \
+                }                                                         \
+    };                                                                    \
+    IMPLEMENT_DYNAMIC_CLASS(HTML_Module##name , wxHtmlTagsModule)
+
+
+
+#endif
+#endif

include/wx/html/winpars.h

@@ -0,0 +1,252 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        winpars.h
+// Purpose:     wxHtmlWinParser class (parser to be used with wxHtmlWindow)
+// Author:      Vaclav Slavik
+// RCS-ID:      $Id$
+// Copyright:   (c) 1999 Vaclav Slavik
+// Licence:     wxWindows Licence
+/////////////////////////////////////////////////////////////////////////////
+
+
+#ifndef _WX_WINPARS_H_
+#define _WX_WINPARS_H_
+
+#if defined(__GNUG__) && !defined(__APPLE__)
+#pragma interface "winpars.h"
+#endif
+
+#include "wx/defs.h"
+#if wxUSE_HTML
+
+#include "wx/module.h"
+#include "wx/font.h"
+#include "wx/html/htmlpars.h"
+#include "wx/html/htmlcell.h"
+#include "wx/encconv.h"
+
+class WXDLLEXPORT wxHtmlWindow;
+class WXDLLEXPORT wxHtmlWinParser;
+class WXDLLEXPORT wxHtmlWinTagHandler;
+class WXDLLEXPORT wxHtmlTagsModule;
+
+//--------------------------------------------------------------------------------
+// wxHtmlWinParser
+//                  This class is derived from wxHtmlParser and its mail goal
+//                  is to parse HTML input so that it can be displayed in
+//                  wxHtmlWindow. It uses special wxHtmlWinTagHandler.
+//--------------------------------------------------------------------------------
+
+class WXDLLEXPORT wxHtmlWinParser : public wxHtmlParser
+{
+    friend class wxHtmlWindow;
+
+public:
+    wxHtmlWinParser(wxHtmlWindow *wnd = NULL);
+    ~wxHtmlWinParser();
+
+    virtual void InitParser(const wxString& source);
+    virtual void DoneParser();
+    virtual wxObject* GetProduct();
+
+    virtual wxFSFile *OpenURL(wxHtmlURLType type, const wxString& url) const;
+
+    // Set's the DC used for parsing. If SetDC() is not called,
+    // parsing won't proceed
+    virtual void SetDC(wxDC *dc, double pixel_scale = 1.0)
+        { m_DC = dc; m_PixelScale = pixel_scale; }
+
+    wxDC *GetDC() {return m_DC;}
+    double GetPixelScale() {return m_PixelScale;}
+    int GetCharHeight() const {return m_CharHeight;}
+    int GetCharWidth() const {return m_CharWidth;}
+
+    // NOTE : these functions do _not_ return _actual_
+    // height/width. They return h/w of default font
+    // for this DC. If you want actual values, call
+    // GetDC()->GetChar...()
+
+    // returns associated wxWindow
+    wxHtmlWindow *GetWindow() {return m_Window;}
+
+    // Sets fonts to be used when displaying HTML page. (if size null then default sizes used).
+    void SetFonts(wxString normal_face, wxString fixed_face, const int *sizes = NULL);
+
+    // Adds tags module. see wxHtmlTagsModule for details.
+    static void AddModule(wxHtmlTagsModule *module);
+
+    static void RemoveModule(wxHtmlTagsModule *module);
+
+    // parsing-related methods. These methods are called by tag handlers:
+
+    // Returns pointer to actual container. Common use in tag handler is :
+    // m_WParser->GetContainer()->InsertCell(new ...);
+    wxHtmlContainerCell *GetContainer() const {return m_Container;}
+
+    // opens new container. This container is sub-container of opened
+    // container. Sets GetContainer to newly created container
+    // and returns it.
+    wxHtmlContainerCell *OpenContainer();
+
+    // works like OpenContainer except that new container is not created
+    // but c is used. You can use this to directly set actual container
+    wxHtmlContainerCell *SetContainer(wxHtmlContainerCell *c);
+
+    // closes the container and sets actual Container to upper-level
+    // container
+    wxHtmlContainerCell *CloseContainer();
+
+    int GetFontSize() const {return m_FontSize;}
+    void SetFontSize(int s);
+    int GetFontBold() const {return m_FontBold;}
+    void SetFontBold(int x) {m_FontBold = x;}
+    int GetFontItalic() const {return m_FontItalic;}
+    void SetFontItalic(int x) {m_FontItalic = x;}
+    int GetFontUnderlined() const {return m_FontUnderlined;}
+    void SetFontUnderlined(int x) {m_FontUnderlined = x;}
+    int GetFontFixed() const {return m_FontFixed;}
+    void SetFontFixed(int x) {m_FontFixed = x;}
+    wxString GetFontFace() const {return GetFontFixed() ? m_FontFaceFixed : m_FontFaceNormal;}
+    void SetFontFace(const wxString& face);
+
+    int GetAlign() const {return m_Align;}
+    void SetAlign(int a) {m_Align = a;}
+    const wxColour& GetLinkColor() const { return m_LinkColor; }
+    void SetLinkColor(const wxColour& clr) { m_LinkColor = clr; }
+    const wxColour& GetActualColor() const { return m_ActualColor; }
+    void SetActualColor(const wxColour& clr) { m_ActualColor = clr ;}
+    const wxHtmlLinkInfo& GetLink() const { return m_Link; }
+    void SetLink(const wxHtmlLinkInfo& link);
+
+#if !wxUSE_UNICODE
+    void SetInputEncoding(wxFontEncoding enc);
+    wxFontEncoding GetInputEncoding() const { return m_InputEnc; }
+    wxFontEncoding GetOutputEncoding() const { return m_OutputEnc; }
+    wxEncodingConverter *GetEncodingConverter() const { return m_EncConv; }
+#endif
+
+    // creates font depending on m_Font* members.
+    virtual wxFont* CreateCurrentFont();
+
+protected:
+    virtual void AddText(const wxChar* txt);
+
+private:
+    bool m_tmpLastWasSpace;
+    wxChar *m_tmpStrBuf;
+    size_t  m_tmpStrBufSize;
+        // temporary variables used by AddText
+    wxHtmlWindow *m_Window;
+            // window we're parsing for
+    double m_PixelScale;
+    wxDC *m_DC;
+            // Device Context we're parsing for
+    static wxList m_Modules;
+            // list of tags modules (see wxHtmlTagsModule for details)
+            // This list is used to initialize m_Handlers member.
+
+    wxHtmlContainerCell *m_Container;
+            // actual container. See Open/CloseContainer for details.
+
+    int m_FontBold, m_FontItalic, m_FontUnderlined, m_FontFixed; // this is not TRUE,FALSE but 1,0, we need it for indexing
+    int m_FontSize; /* -2 to +4,  0 is default */
+    wxColour m_LinkColor;
+    wxColour m_ActualColor;
+            // basic font parameters.
+    wxHtmlLinkInfo m_Link;
+            // actual hypertext link or empty string
+    bool m_UseLink;
+            // TRUE if m_Link is not empty
+    long m_CharHeight, m_CharWidth;
+            // average height of normal-sized text
+    int m_Align;
+            // actual alignment
+
+    wxFont* m_FontsTable[2][2][2][2][7];
+    wxString m_FontsFacesTable[2][2][2][2][7];
+#if !wxUSE_UNICODE
+    wxFontEncoding m_FontsEncTable[2][2][2][2][7];
+#endif
+            // table of loaded fonts. 1st four indexes are 0 or 1, depending on on/off
+            // state of these flags (from left to right):
+            // [bold][italic][underlined][fixed_size]
+            // last index is font size : from 0 to 6 (remapped from html sizes 1 to 7)
+            // Note : this table covers all possible combinations of fonts, but not
+            // all of them are used, so many items in table are usually NULL.
+    int m_FontsSizes[7];
+    wxString m_FontFaceFixed, m_FontFaceNormal;
+            // html font sizes and faces of fixed and proportional fonts
+
+    DECLARE_NO_COPY_CLASS(wxHtmlWinParser)
+
+#if !wxUSE_UNICODE
+    wxFontEncoding m_InputEnc, m_OutputEnc;
+            // I/O font encodings
+    wxEncodingConverter *m_EncConv;
+#endif
+};
+
+
+
+
+
+
+//--------------------------------------------------------------------------------
+// wxHtmlWinTagHandler
+//                  This is basicly wxHtmlTagHandler except
+//                  it is extended with protected member m_Parser pointing to
+//                  the wxHtmlWinParser object
+//--------------------------------------------------------------------------------
+
+class WXDLLEXPORT wxHtmlWinTagHandler : public wxHtmlTagHandler
+{
+    DECLARE_ABSTRACT_CLASS(wxHtmlWinTagHandler)
+
+public:
+    wxHtmlWinTagHandler() : wxHtmlTagHandler() {};
+
+    virtual void SetParser(wxHtmlParser *parser) {wxHtmlTagHandler::SetParser(parser); m_WParser = (wxHtmlWinParser*) parser;};
+
+protected:
+    wxHtmlWinParser *m_WParser; // same as m_Parser, but overcasted
+
+    DECLARE_NO_COPY_CLASS(wxHtmlWinTagHandler)
+};
+
+
+
+
+
+
+//--------------------------------------------------------------------------------
+// wxHtmlTagsModule
+//                  This is basic of dynamic tag handlers binding.
+//                  The class provides methods for filling parser's handlers
+//                  hash table.
+//                  (See documentation for details)
+//--------------------------------------------------------------------------------
+
+class WXDLLEXPORT wxHtmlTagsModule : public wxModule
+{
+    DECLARE_DYNAMIC_CLASS(wxHtmlTagsModule)
+
+public:
+    wxHtmlTagsModule() : wxModule() {};
+
+    virtual bool OnInit();
+    virtual void OnExit();
+
+    // This is called by wxHtmlWinParser.
+    // The method must simply call parser->AddTagHandler(new <handler_class_name>);
+    // for each handler
+    virtual void FillHandlersTable(wxHtmlWinParser * WXUNUSED(parser)) { }
+};
+
+
+#endif
+
+#endif // _WX_WINPARS_H_
+
+
+
+
+

src/html/helpctrl.cpp

@@ -0,0 +1,331 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        helpctrl.cpp
+// Purpose:     wxHtmlHelpController
+// Notes:       Based on htmlhelp.cpp, implementing a monolithic
+//              HTML Help controller class,  by Vaclav Slavik
+// Author:      Harm van der Heijden and Vaclav Slavik
+// RCS-ID:      $Id$
+// Copyright:   (c) Harm van der Heijden and Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "helpctrl.h"
+#endif
+
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#if wxUSE_WXHTML_HELP
+
+#ifndef WX_PRECOMP
+    #include "wx/app.h"
+    #include "wx/intl.h"
+#endif // WX_PRECOMP
+
+#include "wx/html/helpctrl.h"
+#include "wx/busyinfo.h"
+
+#ifdef __WXGTK__
+    // for the hack in AddGrabIfNeeded()
+    #include "wx/dialog.h"
+#endif // __WXGTK__
+
+#if wxUSE_HELP
+    #include "wx/tipwin.h"
+#endif
+
+IMPLEMENT_DYNAMIC_CLASS(wxHtmlHelpController, wxHelpControllerBase)
+
+wxHtmlHelpController::wxHtmlHelpController(int style)
+{
+    m_helpFrame = NULL;
+    m_Config = NULL;
+    m_ConfigRoot = wxEmptyString;
+    m_titleFormat = _("Help: %s");
+    m_FrameStyle = style;
+}
+
+wxHtmlHelpController::~wxHtmlHelpController()
+{
+    if (m_Config)
+        WriteCustomization(m_Config, m_ConfigRoot);
+    if (m_helpFrame)
+        DestroyHelpWindow();
+}
+
+
+void wxHtmlHelpController::DestroyHelpWindow()
+{
+    //if (m_Config) WriteCustomization(m_Config, m_ConfigRoot);
+    if (m_helpFrame)
+        m_helpFrame->Destroy();
+}
+
+void wxHtmlHelpController::OnCloseFrame(wxCloseEvent& evt)
+{
+    evt.Skip();
+
+    OnQuit();
+
+    m_helpFrame->SetController((wxHelpControllerBase*) NULL);
+    m_helpFrame = NULL;
+}
+
+void wxHtmlHelpController::SetTitleFormat(const wxString& title)
+{
+    m_titleFormat = title;
+    if (m_helpFrame)
+        m_helpFrame->SetTitleFormat(title);
+}
+
+
+bool wxHtmlHelpController::AddBook(const wxFileName& book_file, bool show_wait_msg)
+{
+    return AddBook(wxFileSystem::FileNameToURL(book_file), show_wait_msg);
+}
+
+bool wxHtmlHelpController::AddBook(const wxString& book, bool show_wait_msg)
+{
+    wxBusyCursor cur;
+#if wxUSE_BUSYINFO
+    wxBusyInfo* busy = NULL;
+    wxString info;
+    if (show_wait_msg)
+    {
+        info.Printf(_("Adding book %s"), book.c_str());
+        busy = new wxBusyInfo(info);
+    }
+#endif
+    bool retval = m_helpData.AddBook(book);
+#if wxUSE_BUSYINFO
+    if (show_wait_msg)
+        delete busy;
+#endif
+    if (m_helpFrame) 
+        m_helpFrame->RefreshLists();
+    return retval;
+}
+
+
+
+wxHtmlHelpFrame *wxHtmlHelpController::CreateHelpFrame(wxHtmlHelpData *data)
+{
+    return new wxHtmlHelpFrame(data);
+}
+
+
+void wxHtmlHelpController::CreateHelpWindow()
+{
+    if (m_helpFrame)
+    {
+        m_helpFrame->Raise();
+        return ;
+    }
+
+    if (m_Config == NULL)
+    {
+        m_Config = wxConfigBase::Get(FALSE);
+        if (m_Config != NULL)
+            m_ConfigRoot = _T("wxWindows/wxHtmlHelpController");
+    }
+
+    m_helpFrame = CreateHelpFrame(&m_helpData);
+    m_helpFrame->SetController(this);
+
+    if (m_Config)
+        m_helpFrame->UseConfig(m_Config, m_ConfigRoot);
+
+    m_helpFrame->Create(NULL, wxID_HTML_HELPFRAME, wxEmptyString, m_FrameStyle);
+    m_helpFrame->SetTitleFormat(m_titleFormat);
+    m_helpFrame->Show(TRUE);
+}
+
+void wxHtmlHelpController::ReadCustomization(wxConfigBase* cfg, const wxString& path)
+{
+    /* should not be called by the user; call UseConfig, and the controller
+     * will do the rest */
+    if (m_helpFrame && cfg)
+        m_helpFrame->ReadCustomization(cfg, path);
+}
+
+void wxHtmlHelpController::WriteCustomization(wxConfigBase* cfg, const wxString& path)
+{
+    /* typically called by the controllers OnCloseFrame handler */
+    if (m_helpFrame && cfg)
+        m_helpFrame->WriteCustomization(cfg, path);
+}
+
+void wxHtmlHelpController::UseConfig(wxConfigBase *config, const wxString& rootpath)
+{
+    m_Config = config;
+    m_ConfigRoot = rootpath;
+    if (m_helpFrame) m_helpFrame->UseConfig(config, rootpath);
+    ReadCustomization(config, rootpath);
+}
+
+//// Backward compatibility with wxHelpController API
+
+bool wxHtmlHelpController::Initialize(const wxString& file)
+{
+    wxString dir, filename, ext;
+    wxSplitPath(file, & dir, & filename, & ext);
+
+    if (!dir.IsEmpty())
+        dir = dir + wxFILE_SEP_PATH;
+
+    // Try to find a suitable file
+    wxString actualFilename = dir + filename + wxString(wxT(".zip"));
+    if (!wxFileExists(actualFilename))
+    {
+        actualFilename = dir + filename + wxString(wxT(".htb"));
+        if (!wxFileExists(actualFilename))
+        {
+            actualFilename = dir + filename + wxString(wxT(".hhp"));
+            if (!wxFileExists(actualFilename))
+                return FALSE;
+        }
+    }
+
+    return AddBook(wxFileName(actualFilename));
+}
+
+bool wxHtmlHelpController::LoadFile(const wxString& WXUNUSED(file))
+{
+    // Don't reload the file or we'll have it appear again, presumably.
+    return TRUE;
+}
+
+bool wxHtmlHelpController::DisplaySection(int sectionNo)
+{
+    return Display(sectionNo);
+}
+
+bool wxHtmlHelpController::DisplayTextPopup(const wxString& text, const wxPoint& WXUNUSED(pos))
+{
+#if wxUSE_TIPWINDOW
+    static wxTipWindow* s_tipWindow = NULL;
+
+    if (s_tipWindow)
+    {
+        // Prevent s_tipWindow being nulled in OnIdle,
+        // thereby removing the chance for the window to be closed by ShowHelp
+        s_tipWindow->SetTipWindowPtr(NULL);
+        s_tipWindow->Close();
+    }
+    s_tipWindow = NULL;
+
+    if ( !text.empty() )
+    {
+        s_tipWindow = new wxTipWindow(wxTheApp->GetTopWindow(), text, 100, & s_tipWindow);
+
+        return TRUE;
+    }
+#endif // wxUSE_TIPWINDOW
+
+    return FALSE;
+}
+
+void wxHtmlHelpController::SetFrameParameters(const wxString& title,
+                                   const wxSize& size,
+                                   const wxPoint& pos,
+                                   bool WXUNUSED(newFrameEachTime))
+{
+    SetTitleFormat(title);
+    if (m_helpFrame)
+    {
+        m_helpFrame->SetSize(pos.x, pos.y, size.x, size.y);
+    }
+}
+
+wxFrame* wxHtmlHelpController::GetFrameParameters(wxSize *size,
+                                   wxPoint *pos,
+                                   bool *newFrameEachTime)
+{
+    if (newFrameEachTime)
+        (* newFrameEachTime) = FALSE;
+    if (size && m_helpFrame)
+        (* size) = m_helpFrame->GetSize();
+    if (pos && m_helpFrame)
+        (* pos) = m_helpFrame->GetPosition();
+    return m_helpFrame;
+}
+
+bool wxHtmlHelpController::Quit()
+{
+    DestroyHelpWindow();
+    return TRUE;
+}
+
+// Make the help controller's frame 'modal' if
+// needed
+void wxHtmlHelpController::AddGrabIfNeeded()
+{
+    // So far, wxGTK only
+#ifdef __WXGTK__
+    bool needGrab = FALSE;
+    
+    // Check if there are any modal windows present,
+    // in which case we need to add a grab.
+    for ( wxWindowList::Node * node = wxTopLevelWindows.GetFirst();
+          node;
+          node = node->GetNext() )
+    {
+        wxWindow *win = node->GetData();
+        wxDialog *dialog = wxDynamicCast(win, wxDialog);
+
+        if (dialog && dialog->IsModal())
+            needGrab = TRUE;
+    }
+
+    if (needGrab && m_helpFrame)
+        m_helpFrame->AddGrab();
+#endif // __WXGTK__
+}
+
+bool wxHtmlHelpController::Display(const wxString& x)
+{
+    CreateHelpWindow();
+    bool success = m_helpFrame->Display(x);
+    AddGrabIfNeeded();
+    return success;    
+}
+
+bool wxHtmlHelpController::Display(int id)
+{
+    CreateHelpWindow();
+    bool success = m_helpFrame->Display(id);
+    AddGrabIfNeeded();
+    return success;
+}
+
+bool wxHtmlHelpController::DisplayContents()
+{
+    CreateHelpWindow();
+    bool success = m_helpFrame->DisplayContents();
+    AddGrabIfNeeded();
+    return success;
+}
+
+bool wxHtmlHelpController::DisplayIndex()
+{
+    CreateHelpWindow();
+    bool success = m_helpFrame->DisplayIndex();
+    AddGrabIfNeeded();
+    return success;
+}
+
+bool wxHtmlHelpController::KeywordSearch(const wxString& keyword)
+{
+    CreateHelpWindow();
+    bool success = m_helpFrame->KeywordSearch(keyword);
+    AddGrabIfNeeded();
+    return success;
+}
+
+#endif // wxUSE_WXHTML_HELP
+

src/html/helpdata.cpp

@@ -0,0 +1,881 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        helpdata.cpp
+// Purpose:     wxHtmlHelpData
+// Notes:       Based on htmlhelp.cpp, implementing a monolithic
+//              HTML Help controller class,  by Vaclav Slavik
+// Author:      Harm van der Heijden and Vaclav Slavik
+// RCS-ID:      $Id$
+// Copyright:   (c) Harm van der Heijden and Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "helpdata.h"
+#endif
+
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#include "wx/defs.h"
+
+#if wxUSE_HTML && wxUSE_STREAMS
+
+#ifndef WXPRECOMP
+    #include "wx/intl.h"
+    #include "wx/log.h"
+#endif
+
+#include <ctype.h>
+
+#include "wx/html/helpdata.h"
+#include "wx/tokenzr.h"
+#include "wx/wfstream.h"
+#include "wx/busyinfo.h"
+#include "wx/encconv.h"
+#include "wx/fontmap.h"
+#include "wx/log.h"
+#include "wx/html/htmlpars.h"
+#include "wx/html/htmldefs.h"
+#include "wx/html/htmlfilt.h"
+#include "wx/filename.h"
+
+#include "wx/arrimpl.cpp"
+WX_DEFINE_OBJARRAY(wxHtmlBookRecArray)
+
+//-----------------------------------------------------------------------------
+// static helper functions
+//-----------------------------------------------------------------------------
+
+// Reads one line, stores it into buf and returns pointer to new line or NULL.
+static const wxChar* ReadLine(const wxChar *line, wxChar *buf, size_t bufsize)
+{
+    wxChar *writeptr = buf;
+    wxChar *endptr = buf + bufsize - 1;
+    const wxChar *readptr = line;
+
+    while (*readptr != 0 && *readptr != _T('\r') && *readptr != _T('\n') &&
+           writeptr != endptr) 
+        *(writeptr++) = *(readptr++);
+    *writeptr = 0;
+    while (*readptr == _T('\r') || *readptr == _T('\n'))
+        readptr++;
+    if (*readptr == 0)
+        return NULL;
+    else 
+        return readptr;
+}
+
+
+
+extern "C" int LINKAGEMODE
+wxHtmlHelpIndexCompareFunc(const void *a, const void *b)
+{
+    return wxStricmp(((wxHtmlContentsItem*)a)->m_Name, ((wxHtmlContentsItem*)b)->m_Name);
+}
+
+
+//-----------------------------------------------------------------------------
+// HP_Parser
+//-----------------------------------------------------------------------------
+
+class HP_Parser : public wxHtmlParser
+{
+public:
+    wxObject* GetProduct() { return NULL; }
+protected:
+    virtual void AddText(const wxChar* WXUNUSED(txt)) {}
+};
+
+
+//-----------------------------------------------------------------------------
+// HP_TagHandler
+//-----------------------------------------------------------------------------
+
+class HP_TagHandler : public wxHtmlTagHandler
+{
+    private:
+        wxString m_Name, m_Page;
+        int m_Level;
+        int m_ID;
+        int m_Index;
+        wxHtmlContentsItem *m_Items;
+        int m_ItemsCnt;
+        wxHtmlBookRecord *m_Book;
+
+    public:
+        HP_TagHandler(wxHtmlBookRecord *b) : wxHtmlTagHandler()
+            { m_Book = b; m_Items = NULL; m_ItemsCnt = 0; m_Name = m_Page = wxEmptyString;
+              m_Level = 0; m_ID = -1; }
+        wxString GetSupportedTags() { return wxT("UL,OBJECT,PARAM"); }
+        bool HandleTag(const wxHtmlTag& tag);
+        void WriteOut(wxHtmlContentsItem*& array, int& size);
+        void ReadIn(wxHtmlContentsItem* array, int size);
+
+    DECLARE_NO_COPY_CLASS(HP_TagHandler)
+};
+
+
+bool HP_TagHandler::HandleTag(const wxHtmlTag& tag)
+{
+    if (tag.GetName() == wxT("UL"))
+    {
+        m_Level++;
+        ParseInner(tag);
+        m_Level--;
+        return TRUE;
+    }
+    else if (tag.GetName() == wxT("OBJECT"))
+    {
+        m_Name = m_Page = wxEmptyString;
+        ParseInner(tag);
+
+#if 0
+         if (!m_Page.IsEmpty())
+        /* Valid HHW's file may contain only two object tags:
+
+           <OBJECT type="text/site properties">
+               <param name="ImageType" value="Folder">
+           </OBJECT>
+
+           or
+
+           <OBJECT type="text/sitemap">
+               <param name="Name" value="main page">
+               <param name="Local" value="another.htm">
+           </OBJECT>
+
+           We're interested in the latter. !m_Page.IsEmpty() is valid
+           condition because text/site properties does not contain Local param
+        */
+#endif
+        if (tag.GetParam(wxT("TYPE")) == wxT("text/sitemap"))
+        {
+            if (m_ItemsCnt % wxHTML_REALLOC_STEP == 0)
+                m_Items = (wxHtmlContentsItem*) realloc(m_Items,
+                                       (m_ItemsCnt + wxHTML_REALLOC_STEP) *
+                                       sizeof(wxHtmlContentsItem));
+
+            m_Items[m_ItemsCnt].m_Level = m_Level;
+            m_Items[m_ItemsCnt].m_ID = m_ID;
+            m_Items[m_ItemsCnt].m_Page = new wxChar[m_Page.Length() + 1];
+            wxStrcpy(m_Items[m_ItemsCnt].m_Page, m_Page.c_str());
+            m_Items[m_ItemsCnt].m_Name = new wxChar [m_Name.Length() + 1];
+            wxStrcpy(m_Items[m_ItemsCnt].m_Name, m_Name.c_str());
+            m_Items[m_ItemsCnt].m_Book = m_Book;
+            m_ItemsCnt++;
+        }
+
+        return TRUE;
+    }
+    else
+    { // "PARAM"
+        if (m_Name == wxEmptyString && tag.GetParam(wxT("NAME")) == wxT("Name"))
+            m_Name = tag.GetParam(wxT("VALUE"));
+        if (tag.GetParam(wxT("NAME")) == wxT("Local"))
+            m_Page = tag.GetParam(wxT("VALUE"));
+        if (tag.GetParam(wxT("NAME")) == wxT("ID"))
+            tag.GetParamAsInt(wxT("VALUE"), &m_ID);
+        return FALSE;
+    }
+}
+
+
+
+void HP_TagHandler::WriteOut(wxHtmlContentsItem*& array, int& size)
+{
+    array = m_Items;
+    size = m_ItemsCnt;
+    m_Items = NULL;
+    m_ItemsCnt = 0;
+}
+
+void HP_TagHandler::ReadIn(wxHtmlContentsItem* array, int size)
+{
+    m_Items = array;
+    m_ItemsCnt = size;
+}
+
+
+
+
+//-----------------------------------------------------------------------------
+// wxHtmlHelpData
+//-----------------------------------------------------------------------------
+
+wxString wxHtmlBookRecord::GetFullPath(const wxString &page) const
+{
+    if (wxIsAbsolutePath(page))
+        return page;
+    else
+        return m_BasePath + page;
+}
+
+
+
+IMPLEMENT_DYNAMIC_CLASS(wxHtmlHelpData, wxObject)
+
+wxHtmlHelpData::wxHtmlHelpData()
+{
+    m_TempPath = wxEmptyString;
+
+    m_Contents = NULL;
+    m_ContentsCnt = 0;
+    m_Index = NULL;
+    m_IndexCnt = 0;
+}
+
+wxHtmlHelpData::~wxHtmlHelpData()
+{
+    int i;
+
+    m_BookRecords.Empty();
+    if (m_Contents)
+    {
+        for (i = 0; i < m_ContentsCnt; i++)
+        {
+            delete[] m_Contents[i].m_Page;
+            delete[] m_Contents[i].m_Name;
+        }
+        free(m_Contents);
+    }
+    if (m_Index)
+    {
+        for (i = 0; i < m_IndexCnt; i++)
+        {
+            delete[] m_Index[i].m_Page;
+            delete[] m_Index[i].m_Name;
+        }
+        free(m_Index);
+    }
+}
+
+bool wxHtmlHelpData::LoadMSProject(wxHtmlBookRecord *book, wxFileSystem& fsys, const wxString& indexfile, const wxString& contentsfile)
+{
+    wxFSFile *f;
+    wxHtmlFilterHTML filter;
+    wxString buf;
+    wxString string;
+
+    HP_Parser parser;
+    HP_TagHandler *handler = new HP_TagHandler(book);
+    parser.AddTagHandler(handler);
+
+    f = ( contentsfile.IsEmpty() ? (wxFSFile*) NULL : fsys.OpenFile(contentsfile) );
+    if (f)
+    {
+        buf.clear();
+        buf = filter.ReadFile(*f);
+        delete f;
+        handler->ReadIn(m_Contents, m_ContentsCnt);
+        parser.Parse(buf);
+        handler->WriteOut(m_Contents, m_ContentsCnt);
+    }
+    else
+    {
+        wxLogError(_("Cannot open contents file: %s"), contentsfile.c_str());
+    }
+
+    f = ( indexfile.IsEmpty() ? (wxFSFile*) NULL : fsys.OpenFile(indexfile) );
+    if (f)
+    {
+        buf.clear();
+        buf = filter.ReadFile(*f);
+        delete f;
+        handler->ReadIn(m_Index, m_IndexCnt);
+        parser.Parse(buf);
+        handler->WriteOut(m_Index, m_IndexCnt);
+    }
+    else if (!indexfile.IsEmpty())
+    {
+        wxLogError(_("Cannot open index file: %s"), indexfile.c_str());
+    }
+    return TRUE;
+}
+
+
+
+inline static void CacheWriteInt32(wxOutputStream *f, wxInt32 value)
+{
+    wxInt32 x = wxINT32_SWAP_ON_BE(value);
+    f->Write(&x, sizeof(x));
+}
+
+inline static wxInt32 CacheReadInt32(wxInputStream *f)
+{
+    wxInt32 x;
+    f->Read(&x, sizeof(x));
+    return wxINT32_SWAP_ON_BE(x);
+}
+
+inline static void CacheWriteString(wxOutputStream *f, const wxChar *str)
+{    
+#if wxUSE_UNICODE
+    wxWX2MBbuf mbstr(wxConvUTF8.cWX2MB(str));
+#else
+    const wxChar *mbstr = str;
+#endif
+    size_t len = strlen(mbstr)+1;
+    CacheWriteInt32(f, len);
+    f->Write(mbstr, len);
+}
+
+inline static wxChar* CacheReadString(wxInputStream *f)
+{
+    char *str;
+    size_t len = (size_t)CacheReadInt32(f);
+    str = new char[len];
+    f->Read(str, len);
+#if !wxUSE_UNICODE
+    return str;
+#else
+    wxMB2WXbuf wxstr(wxConvUTF8.cMB2WX(str));
+    wxChar *outstr = new wxChar[wxStrlen(wxstr)+1];
+    wxStrcpy(outstr, wxstr);
+    return outstr;
+#endif
+}
+
+#define CURRENT_CACHED_BOOK_VERSION     4
+
+// Additional flags to detect incompatibilities of the runtime environment:
+#define CACHED_BOOK_FORMAT_FLAGS \
+                     (wxUSE_UNICODE << 0)
+
+
+bool wxHtmlHelpData::LoadCachedBook(wxHtmlBookRecord *book, wxInputStream *f)
+{
+    int i, st;
+    wxInt32 version;
+
+    /* load header - version info : */
+    version = CacheReadInt32(f);
+    
+    if (version != CURRENT_CACHED_BOOK_VERSION)
+    {
+        // NB: We can just silently return FALSE here and don't worry about
+        //     it anymore, because AddBookParam will load the MS project in
+        //     absence of (properly versioned) .cached file and automatically 
+        //     create new .cached file immediately afterward.
+        return FALSE;
+    }
+
+    if (CacheReadInt32(f) != CACHED_BOOK_FORMAT_FLAGS)
+        return FALSE;
+
+    /* load contents : */
+    st = m_ContentsCnt;
+    m_ContentsCnt += CacheReadInt32(f);
+    m_Contents = (wxHtmlContentsItem*) realloc(m_Contents,
+                                               (m_ContentsCnt / wxHTML_REALLOC_STEP + 1) *
+                                               wxHTML_REALLOC_STEP * sizeof(wxHtmlContentsItem));
+    for (i = st; i < m_ContentsCnt; i++)
+    {
+        m_Contents[i].m_Level = CacheReadInt32(f);
+        m_Contents[i].m_ID = CacheReadInt32(f);
+        m_Contents[i].m_Name = CacheReadString(f);
+        m_Contents[i].m_Page = CacheReadString(f);
+        m_Contents[i].m_Book = book;
+    }
+
+    /* load index : */
+    st = m_IndexCnt;
+    m_IndexCnt += CacheReadInt32(f);
+    m_Index = (wxHtmlContentsItem*) realloc(m_Index, (m_IndexCnt / wxHTML_REALLOC_STEP + 1) *
+                                                     wxHTML_REALLOC_STEP * sizeof(wxHtmlContentsItem));
+    for (i = st; i < m_IndexCnt; i++)
+    {
+        m_Index[i].m_Name = CacheReadString(f);
+        m_Index[i].m_Page = CacheReadString(f);
+        m_Index[i].m_Book = book;
+    }
+    return TRUE;
+}
+
+
+bool wxHtmlHelpData::SaveCachedBook(wxHtmlBookRecord *book, wxOutputStream *f)
+{
+    int i;
+    wxInt32 cnt;
+
+    /* save header - version info : */
+    CacheWriteInt32(f, CURRENT_CACHED_BOOK_VERSION);
+    CacheWriteInt32(f, CACHED_BOOK_FORMAT_FLAGS);
+
+    /* save contents : */
+    for (cnt = 0, i = 0; i < m_ContentsCnt; i++) 
+        if (m_Contents[i].m_Book == book && m_Contents[i].m_Level > 0)
+            cnt++;
+    CacheWriteInt32(f, cnt);
+
+    for (i = 0; i < m_ContentsCnt; i++)
+    {
+        if (m_Contents[i].m_Book != book || m_Contents[i].m_Level == 0) 
+            continue;
+        CacheWriteInt32(f, m_Contents[i].m_Level);
+        CacheWriteInt32(f, m_Contents[i].m_ID);
+        CacheWriteString(f, m_Contents[i].m_Name);
+        CacheWriteString(f, m_Contents[i].m_Page);
+    }
+
+    /* save index : */
+    for (cnt = 0, i = 0; i < m_IndexCnt; i++) 
+        if (m_Index[i].m_Book == book && m_Index[i].m_Level > 0) 
+            cnt++;
+    CacheWriteInt32(f, cnt);
+
+    for (i = 0; i < m_IndexCnt; i++)
+    {
+        if (m_Index[i].m_Book != book || m_Index[i].m_Level == 0) 
+            continue;
+        CacheWriteString(f, m_Index[i].m_Name);
+        CacheWriteString(f, m_Index[i].m_Page);
+    }
+    return TRUE;
+}
+
+
+void wxHtmlHelpData::SetTempDir(const wxString& path)
+{
+    if (path == wxEmptyString) m_TempPath = path;
+    else
+    {
+        if (wxIsAbsolutePath(path)) m_TempPath = path;
+        else m_TempPath = wxGetCwd() + _T("/") + path;
+
+        if (m_TempPath[m_TempPath.Length() - 1] != _T('/'))
+            m_TempPath << _T('/');
+    }
+}
+
+
+
+static wxString SafeFileName(const wxString& s)
+{
+    wxString res(s);
+    res.Replace(wxT("#"), wxT("_"));
+    res.Replace(wxT(":"), wxT("_"));
+    res.Replace(wxT("\\"), wxT("_"));
+    res.Replace(wxT("/"), wxT("_"));
+    return res;
+}
+
+bool wxHtmlHelpData::AddBookParam(const wxFSFile& bookfile,
+                                  wxFontEncoding encoding,
+                                  const wxString& title, const wxString& contfile,
+                                  const wxString& indexfile, const wxString& deftopic,
+                                  const wxString& path)
+{
+    wxFileSystem fsys;
+    wxFSFile *fi;
+    wxHtmlBookRecord *bookr;
+
+    int IndexOld = m_IndexCnt,
+        ContentsOld = m_ContentsCnt;
+
+    if (!path.IsEmpty())
+        fsys.ChangePathTo(path, TRUE);
+
+    size_t booksCnt = m_BookRecords.GetCount();
+    for (size_t i = 0; i < booksCnt; i++)
+    {
+        if ( m_BookRecords[i].GetBookFile() == bookfile.GetLocation() )
+            return TRUE; // book is (was) loaded
+    }
+
+    bookr = new wxHtmlBookRecord(bookfile.GetLocation(), fsys.GetPath(), title, deftopic);
+    
+    if (m_ContentsCnt % wxHTML_REALLOC_STEP == 0)
+        m_Contents = (wxHtmlContentsItem*) realloc(m_Contents, (m_ContentsCnt + wxHTML_REALLOC_STEP) * sizeof(wxHtmlContentsItem));
+    m_Contents[m_ContentsCnt].m_Level = 0;
+    m_Contents[m_ContentsCnt].m_ID = 0;
+    m_Contents[m_ContentsCnt].m_Page = new wxChar[deftopic.Length() + 1];
+    wxStrcpy(m_Contents[m_ContentsCnt].m_Page, deftopic.c_str());
+    m_Contents[m_ContentsCnt].m_Name = new wxChar [title.Length() + 1];
+    wxStrcpy(m_Contents[m_ContentsCnt].m_Name, title.c_str());
+    m_Contents[m_ContentsCnt].m_Book = bookr;
+
+    // store the contents index for later
+    int cont_start = m_ContentsCnt++;
+
+    // Try to find cached binary versions:
+    // 1. save file as book, but with .hhp.cached extension
+    // 2. same as 1. but in temp path
+    // 3. otherwise or if cache load failed, load it from MS.
+
+    fi = fsys.OpenFile(bookfile.GetLocation() + wxT(".cached"));
+
+    if (fi == NULL ||
+#if wxUSE_DATETIME
+          fi->GetModificationTime() < bookfile.GetModificationTime() ||
+#endif // wxUSE_DATETIME
+          !LoadCachedBook(bookr, fi->GetStream()))
+    {
+        if (fi != NULL) delete fi;
+        fi = fsys.OpenFile(m_TempPath + wxFileNameFromPath(bookfile.GetLocation()) + wxT(".cached"));
+        if (m_TempPath == wxEmptyString || fi == NULL ||
+#if wxUSE_DATETIME
+            fi->GetModificationTime() < bookfile.GetModificationTime() ||
+#endif // wxUSE_DATETIME
+            !LoadCachedBook(bookr, fi->GetStream()))
+        {
+            LoadMSProject(bookr, fsys, indexfile, contfile);
+            if (m_TempPath != wxEmptyString)
+            {
+                wxFileOutputStream *outs = new wxFileOutputStream(m_TempPath +
+                                                  SafeFileName(wxFileNameFromPath(bookfile.GetLocation())) + wxT(".cached"));
+                SaveCachedBook(bookr, outs);
+                delete outs;
+            }
+        }
+    }
+
+    if (fi != NULL) delete fi;
+
+    // Now store the contents range
+    bookr->SetContentsRange(cont_start, m_ContentsCnt);
+
+    // Convert encoding, if neccessary:
+    if (encoding != wxFONTENCODING_SYSTEM)
+    {
+        wxFontEncodingArray a = wxEncodingConverter::GetPlatformEquivalents(encoding);
+        if (a.GetCount() != 0 && a[0] != encoding)
+        {
+            int i;
+            wxEncodingConverter conv;
+            conv.Init(encoding, a[0]);
+
+            for (i = IndexOld; i < m_IndexCnt; i++)
+                conv.Convert(m_Index[i].m_Name);
+            for (i = ContentsOld; i < m_ContentsCnt; i++)
+                conv.Convert(m_Contents[i].m_Name);
+        }
+    }
+
+    m_BookRecords.Add(bookr);
+    if (m_IndexCnt > 0)
+        qsort(m_Index, m_IndexCnt, sizeof(wxHtmlContentsItem), wxHtmlHelpIndexCompareFunc);
+
+    return TRUE;
+}
+
+
+bool wxHtmlHelpData::AddBook(const wxString& book)
+{
+    if (book.Right(4).Lower() == wxT(".zip") ||
+        book.Right(4).Lower() == wxT(".htb") /*html book*/)
+    {
+        wxFileSystem fsys;
+        wxString s;
+        bool rt = FALSE;
+
+        s = fsys.FindFirst(book + wxT("#zip:") + wxT("*.hhp"), wxFILE);
+        while (!s.IsEmpty())
+        {
+            if (AddBook(s)) rt = TRUE;
+            s = fsys.FindNext();
+        }
+
+        return rt;
+    }
+    else
+    {
+        wxFSFile *fi;
+        wxFileSystem fsys;
+
+        wxString title = _("noname"),
+                 safetitle,
+                 start = wxEmptyString,
+                 contents = wxEmptyString,
+                 index = wxEmptyString,
+                 charset = wxEmptyString;
+
+        fi = fsys.OpenFile(book);
+        if (fi == NULL)
+        {
+            wxLogError(_("Cannot open HTML help book: %s"), book.c_str());
+            return FALSE;
+        }
+        fsys.ChangePathTo(book);
+
+        const wxChar *lineptr;
+        wxChar linebuf[300];
+        wxString tmp;
+        wxHtmlFilterPlainText filter;
+        tmp = filter.ReadFile(*fi);
+        lineptr = tmp.c_str();
+
+        do 
+        {
+            lineptr = ReadLine(lineptr, linebuf, 300);
+            
+            for (wxChar *ch = linebuf; *ch != wxT('\0') && *ch != wxT('='); ch++)
+               *ch = tolower(*ch);
+
+            if (wxStrstr(linebuf, _T("title=")) == linebuf)
+                title = linebuf + wxStrlen(_T("title="));
+            if (wxStrstr(linebuf, _T("default topic=")) == linebuf)
+                start = linebuf + wxStrlen(_T("default topic="));
+            if (wxStrstr(linebuf, _T("index file=")) == linebuf)
+                index = linebuf + wxStrlen(_T("index file="));
+            if (wxStrstr(linebuf, _T("contents file=")) == linebuf)
+                contents = linebuf + wxStrlen(_T("contents file="));
+            if (wxStrstr(linebuf, _T("charset=")) == linebuf)
+                charset = linebuf + wxStrlen(_T("charset="));
+        } while (lineptr != NULL);
+
+        wxFontEncoding enc;
+        if (charset == wxEmptyString) enc = wxFONTENCODING_SYSTEM;
+        else enc = wxFontMapper::Get()->CharsetToEncoding(charset);
+        bool rtval = AddBookParam(*fi, enc,
+                                  title, contents, index, start, fsys.GetPath());
+        delete fi;
+        return rtval;
+    }
+}
+
+wxString wxHtmlHelpData::FindPageByName(const wxString& x)
+{
+    int cnt;
+    int i;
+    wxFileSystem fsys;
+    wxFSFile *f;
+    wxString url(wxEmptyString);
+
+    /* 1. try to open given file: */
+
+    cnt = m_BookRecords.GetCount();
+    for (i = 0; i < cnt; i++)
+    {
+        f = fsys.OpenFile(m_BookRecords[i].GetFullPath(x));
+        if (f)
+        {
+            url = m_BookRecords[i].GetFullPath(x);
+            delete f;
+            return url;
+        }
+    }
+
+
+    /* 2. try to find a book: */
+
+    for (i = 0; i < cnt; i++)
+    {
+        if (m_BookRecords[i].GetTitle() == x)
+        {
+            url = m_BookRecords[i].GetFullPath(m_BookRecords[i].GetStart());
+            return url;
+        }
+    }
+
+    /* 3. try to find in contents: */
+
+    cnt = m_ContentsCnt;
+    for (i = 0; i < cnt; i++)
+    {
+        if (wxStrcmp(m_Contents[i].m_Name, x) == 0)
+        {
+            url = m_Contents[i].GetFullPath();
+            return url;
+        }
+    }
+
+
+    /* 4. try to find in index: */
+
+    cnt = m_IndexCnt;
+    for (i = 0; i < cnt; i++)
+    {
+        if (wxStrcmp(m_Index[i].m_Name, x) == 0)
+        {
+            url = m_Index[i].GetFullPath();
+            return url;
+        }
+    }
+
+    return url;
+}
+
+wxString wxHtmlHelpData::FindPageById(int id)
+{
+    int i;
+    wxString url(wxEmptyString);
+
+    for (i = 0; i < m_ContentsCnt; i++)
+    {
+        if (m_Contents[i].m_ID == id)
+        {
+            url = m_Contents[i].GetFullPath();
+            return url;
+        }
+    }
+
+    return url;
+}
+
+//----------------------------------------------------------------------------------
+// wxHtmlSearchStatus functions
+//----------------------------------------------------------------------------------
+
+wxHtmlSearchStatus::wxHtmlSearchStatus(wxHtmlHelpData* data, const wxString& keyword,
+                                       bool case_sensitive, bool whole_words_only,
+                                       const wxString& book)
+{
+    m_Data = data;
+    m_Keyword = keyword;
+    wxHtmlBookRecord* bookr = NULL;
+    if (book != wxEmptyString)
+    {
+        // we have to search in a specific book. Find it first
+        int i, cnt = data->m_BookRecords.GetCount();
+        for (i = 0; i < cnt; i++)
+            if (data->m_BookRecords[i].GetTitle() == book)
+            {
+                bookr = &(data->m_BookRecords[i]);
+                m_CurIndex = bookr->GetContentsStart();
+                m_MaxIndex = bookr->GetContentsEnd();
+                break;
+            }
+        // check; we won't crash if the book doesn't exist, but it's Bad Anyway.
+        wxASSERT(bookr);
+    }
+    if (! bookr)
+    {
+        // no book specified; search all books
+        m_CurIndex = 0;
+        m_MaxIndex = m_Data->m_ContentsCnt;
+    }
+    m_Engine.LookFor(keyword, case_sensitive, whole_words_only);
+    m_Active = (m_CurIndex < m_MaxIndex);
+    m_LastPage = NULL;
+}
+
+bool wxHtmlSearchStatus::Search()
+{
+    wxFSFile *file;
+    int i = m_CurIndex;  // shortcut
+    bool found = FALSE;
+    wxChar *thepage;
+
+    if (!m_Active)
+    {
+        // sanity check. Illegal use, but we'll try to prevent a crash anyway
+        wxASSERT(m_Active);
+        return FALSE;
+    }
+
+    m_Name = wxEmptyString;
+    m_ContentsItem = NULL;
+    thepage = m_Data->m_Contents[i].m_Page;
+
+    m_Active = (++m_CurIndex < m_MaxIndex);
+    // check if it is same page with different anchor:
+    if (m_LastPage != NULL)
+    {
+        wxChar *p1, *p2;
+        for (p1 = thepage, p2 = m_LastPage;
+             *p1 != 0 && *p1 != _T('#') && *p1 == *p2; p1++, p2++) {}
+
+        m_LastPage = thepage;
+
+        if (*p1 == 0 || *p1 == _T('#'))
+            return FALSE;
+    }
+    else m_LastPage = thepage;
+
+    wxFileSystem fsys;
+    file = fsys.OpenFile(m_Data->m_Contents[i].m_Book->GetFullPath(thepage));
+    if (file)
+    {
+        if (m_Engine.Scan(*file))
+        {
+            m_Name = m_Data->m_Contents[i].m_Name;
+            m_ContentsItem = m_Data->m_Contents + i;
+            found = TRUE;
+        }
+        delete file;
+    }
+    return found;
+}
+
+
+
+
+
+
+
+
+//--------------------------------------------------------------------------------
+// wxHtmlSearchEngine
+//--------------------------------------------------------------------------------
+
+void wxHtmlSearchEngine::LookFor(const wxString& keyword, bool case_sensitive, bool whole_words_only)
+{
+    m_CaseSensitive = case_sensitive;
+    m_WholeWords = whole_words_only;
+    if (m_Keyword) delete[] m_Keyword;
+    m_Keyword = new wxChar[keyword.Length() + 1];
+    wxStrcpy(m_Keyword, keyword.c_str());
+
+    if (!m_CaseSensitive)
+    {
+        for (int i = wxStrlen(m_Keyword) - 1; i >= 0; i--)
+        {
+            if ((m_Keyword[i] >= wxT('A')) && (m_Keyword[i] <= wxT('Z')))
+                m_Keyword[i] += wxT('a') - wxT('A');
+        }
+    }
+}
+
+
+static inline bool WHITESPACE(wxChar c)
+{
+    return c == _T(' ') || c == _T('\n') || c == _T('\r') || c == _T('\t');
+}
+
+bool wxHtmlSearchEngine::Scan(const wxFSFile& file)
+{
+    wxASSERT_MSG(m_Keyword != NULL, wxT("wxHtmlSearchEngine::LookFor must be called before scanning!"));
+
+    int i, j;
+    int wrd = wxStrlen(m_Keyword);
+    bool found = FALSE;
+    wxHtmlFilterHTML filter;
+    wxString tmp = filter.ReadFile(file);
+    int lng = tmp.length();
+    const wxChar *buf = tmp.c_str();
+
+    if (!m_CaseSensitive)
+        for (i = 0; i < lng; i++)
+            tmp[(size_t)i] = (wxChar)wxTolower(tmp[(size_t)i]);
+
+    if (m_WholeWords)
+    {
+        for (i = 0; i < lng - wrd; i++)
+        {
+            if (WHITESPACE(buf[i])) continue;
+            j = 0;
+            while ((j < wrd) && (buf[i + j] == m_Keyword[j])) j++;
+            if (j == wrd && WHITESPACE(buf[i + j])) { found = TRUE; break; }
+        }
+    }
+
+    else
+    {
+        for (i = 0; i < lng - wrd; i++)
+        {
+            j = 0;
+            while ((j < wrd) && (buf[i + j] == m_Keyword[j])) j++;
+            if (j == wrd) { found = TRUE; break; }
+        }
+    }
+
+    return found;
+}
+
+
+
+#endif

src/html/htmlcell.cpp

@@ -0,0 +1,728 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        htmlcell.cpp
+// Purpose:     wxHtmlCell - basic element of HTML output
+// Author:      Vaclav Slavik
+// RCS-ID:      $Id$
+// Copyright:   (c) 1999 Vaclav Slavik
+// Licence:     wxWindows Licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "htmlcell.h"
+#endif
+
+#include "wx/wxprec.h"
+
+#include "wx/defs.h"
+
+#if wxUSE_HTML && wxUSE_STREAMS
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#ifndef WXPRECOMP
+    #include "wx/brush.h"
+    #include "wx/colour.h"
+    #include "wx/dc.h"
+#endif
+
+#include "wx/html/htmlcell.h"
+#include "wx/html/htmlwin.h"
+#include <stdlib.h>
+
+
+//-----------------------------------------------------------------------------
+// wxHtmlCell
+//-----------------------------------------------------------------------------
+
+wxHtmlCell::wxHtmlCell() : wxObject()
+{
+    m_Next = NULL;
+    m_Parent = NULL;
+    m_Width = m_Height = m_Descent = 0;
+    m_CanLiveOnPagebreak = TRUE;
+    m_Link = NULL;
+}
+
+wxHtmlCell::~wxHtmlCell()
+{
+    delete m_Link;
+}
+
+
+void wxHtmlCell::OnMouseClick(wxWindow *parent, int x, int y,
+                              const wxMouseEvent& event)
+{
+    wxHtmlLinkInfo *lnk = GetLink(x, y);
+    if (lnk != NULL)
+    {
+        wxHtmlLinkInfo lnk2(*lnk);
+        lnk2.SetEvent(&event);
+        lnk2.SetHtmlCell(this);
+
+        // note : this cast is legal because parent is *always* wxHtmlWindow
+        wxStaticCast(parent, wxHtmlWindow)->OnLinkClicked(lnk2);
+    }
+}
+
+
+
+bool wxHtmlCell::AdjustPagebreak(int *pagebreak, int* WXUNUSED(known_pagebreaks), int WXUNUSED(number_of_pages)) const
+{
+    if ((!m_CanLiveOnPagebreak) &&
+                m_PosY < *pagebreak && m_PosY + m_Height > *pagebreak)
+    {
+        *pagebreak = m_PosY;
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+
+
+void wxHtmlCell::SetLink(const wxHtmlLinkInfo& link)
+{
+    if (m_Link) delete m_Link;
+    m_Link = NULL;
+    if (link.GetHref() != wxEmptyString)
+        m_Link = new wxHtmlLinkInfo(link);
+}
+
+
+
+void wxHtmlCell::Layout(int WXUNUSED(w))
+{
+    SetPos(0, 0);
+}
+
+
+
+void wxHtmlCell::GetHorizontalConstraints(int *left, int *right) const
+{
+    if (left)
+        *left = m_PosX;
+    if (right)
+        *right = m_PosX + m_Width;
+}
+
+
+
+const wxHtmlCell* wxHtmlCell::Find(int WXUNUSED(condition), const void* WXUNUSED(param)) const
+{
+    return NULL;
+}
+
+
+wxHtmlCell *wxHtmlCell::FindCellByPos(wxCoord x, wxCoord y) const
+{
+    if ( x >= 0 && x < m_Width && y >= 0 && y < m_Height )
+        return wxConstCast(this, wxHtmlCell);
+
+    return NULL;
+}
+
+
+//-----------------------------------------------------------------------------
+// wxHtmlWordCell
+//-----------------------------------------------------------------------------
+
+wxHtmlWordCell::wxHtmlWordCell(const wxString& word, wxDC& dc) : wxHtmlCell()
+{
+    m_Word = word;
+    dc.GetTextExtent(m_Word, &m_Width, &m_Height, &m_Descent);
+    SetCanLiveOnPagebreak(FALSE);
+}
+
+
+
+void wxHtmlWordCell::Draw(wxDC& dc, int x, int y, int WXUNUSED(view_y1), int WXUNUSED(view_y2))
+{
+    dc.DrawText(m_Word, x + m_PosX, y + m_PosY);
+}
+
+
+
+//-----------------------------------------------------------------------------
+// wxHtmlContainerCell
+//-----------------------------------------------------------------------------
+
+
+wxHtmlContainerCell::wxHtmlContainerCell(wxHtmlContainerCell *parent) : wxHtmlCell()
+{
+    m_Cells = m_LastCell = NULL;
+    m_Parent = parent;
+    if (m_Parent) m_Parent->InsertCell(this);
+    m_AlignHor = wxHTML_ALIGN_LEFT;
+    m_AlignVer = wxHTML_ALIGN_BOTTOM;
+    m_IndentLeft = m_IndentRight = m_IndentTop = m_IndentBottom = 0;
+    m_WidthFloat = 100; m_WidthFloatUnits = wxHTML_UNITS_PERCENT;
+    m_UseBkColour = FALSE;
+    m_UseBorder = FALSE;
+    m_MinHeight = 0;
+    m_MinHeightAlign = wxHTML_ALIGN_TOP;
+    m_LastLayout = -1;
+}
+
+wxHtmlContainerCell::~wxHtmlContainerCell()
+{
+    wxHtmlCell *cell = m_Cells;
+    while ( cell )
+    {
+        wxHtmlCell *cellNext = cell->GetNext();
+        delete cell;
+        cell = cellNext;
+    }
+}
+
+
+
+void wxHtmlContainerCell::SetIndent(int i, int what, int units)
+{
+    int val = (units == wxHTML_UNITS_PIXELS) ? i : -i;
+    if (what & wxHTML_INDENT_LEFT) m_IndentLeft = val;
+    if (what & wxHTML_INDENT_RIGHT) m_IndentRight = val;
+    if (what & wxHTML_INDENT_TOP) m_IndentTop = val;
+    if (what & wxHTML_INDENT_BOTTOM) m_IndentBottom = val;
+    m_LastLayout = -1;
+}
+
+
+
+int wxHtmlContainerCell::GetIndent(int ind) const
+{
+    if (ind & wxHTML_INDENT_LEFT) return m_IndentLeft;
+    else if (ind & wxHTML_INDENT_RIGHT) return m_IndentRight;
+    else if (ind & wxHTML_INDENT_TOP) return m_IndentTop;
+    else if (ind & wxHTML_INDENT_BOTTOM) return m_IndentBottom;
+    else return -1; /* BUG! Should not be called... */
+}
+
+
+
+
+int wxHtmlContainerCell::GetIndentUnits(int ind) const
+{
+    bool p = FALSE;
+    if (ind & wxHTML_INDENT_LEFT) p = m_IndentLeft < 0;
+    else if (ind & wxHTML_INDENT_RIGHT) p = m_IndentRight < 0;
+    else if (ind & wxHTML_INDENT_TOP) p = m_IndentTop < 0;
+    else if (ind & wxHTML_INDENT_BOTTOM) p = m_IndentBottom < 0;
+    if (p) return wxHTML_UNITS_PERCENT;
+    else return wxHTML_UNITS_PIXELS;
+}
+
+
+
+bool wxHtmlContainerCell::AdjustPagebreak(int *pagebreak, int* known_pagebreaks, int number_of_pages) const
+{
+    if (!m_CanLiveOnPagebreak)
+        return wxHtmlCell::AdjustPagebreak(pagebreak, known_pagebreaks, number_of_pages);
+
+    else
+    {
+        wxHtmlCell *c = GetFirstCell();
+        bool rt = FALSE;
+        int pbrk = *pagebreak - m_PosY;
+
+        while (c)
+        {
+            if (c->AdjustPagebreak(&pbrk, known_pagebreaks, number_of_pages))
+                rt = TRUE;
+            c = c->GetNext();
+        }
+        if (rt)
+            *pagebreak = pbrk + m_PosY;
+        return rt;
+    }
+}
+
+
+
+void wxHtmlContainerCell::Layout(int w)
+{
+    wxHtmlCell::Layout(w);
+
+    if (m_LastLayout == w) return;
+
+    // VS: Any attempt to layout with negative or zero width leads to hell,
+    // but we can't ignore such attempts completely, since it sometimes
+    // happen (e.g. when trying how small a table can be). The best thing we
+    // can do is to set the width of child cells to zero
+    if (w < 1)
+    {
+       m_Width = 0;
+       for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
+            cell->Layout(0);
+            // this does two things: it recursively calls this code on all
+            // child contrainers and resets children's position to (0,0)
+       return;
+    }
+
+    wxHtmlCell *cell = m_Cells, *line = m_Cells;
+    long xpos = 0, ypos = m_IndentTop;
+    int xdelta = 0, ybasicpos = 0, ydiff;
+    int s_width, s_indent;
+    int ysizeup = 0, ysizedown = 0;
+    int MaxLineWidth = 0;
+    int xcnt = 0;
+
+
+    /*
+
+    WIDTH ADJUSTING :
+
+    */
+
+    if (m_WidthFloatUnits == wxHTML_UNITS_PERCENT)
+    {
+        if (m_WidthFloat < 0) m_Width = (100 + m_WidthFloat) * w / 100;
+        else m_Width = m_WidthFloat * w / 100;
+    }
+    else
+    {
+        if (m_WidthFloat < 0) m_Width = w + m_WidthFloat;
+        else m_Width = m_WidthFloat;
+    }
+
+    if (m_Cells)
+    {
+        int l = (m_IndentLeft < 0) ? (-m_IndentLeft * m_Width / 100) : m_IndentLeft;
+        int r = (m_IndentRight < 0) ? (-m_IndentRight * m_Width / 100) : m_IndentRight;
+        for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
+            cell->Layout(m_Width - (l + r));
+    }
+
+    /*
+
+    LAYOUTING :
+
+    */
+
+    // adjust indentation:
+    s_indent = (m_IndentLeft < 0) ? (-m_IndentLeft * m_Width / 100) : m_IndentLeft;
+    s_width = m_Width - s_indent - ((m_IndentRight < 0) ? (-m_IndentRight * m_Width / 100) : m_IndentRight);
+
+    // my own layouting:
+    while (cell != NULL)
+    {
+        switch (m_AlignVer)
+        {
+            case wxHTML_ALIGN_TOP :      ybasicpos = 0; break;
+            case wxHTML_ALIGN_BOTTOM :   ybasicpos = - cell->GetHeight(); break;
+            case wxHTML_ALIGN_CENTER :   ybasicpos = - cell->GetHeight() / 2; break;
+        }
+        ydiff = cell->GetHeight() + ybasicpos;
+
+        if (cell->GetDescent() + ydiff > ysizedown) ysizedown = cell->GetDescent() + ydiff;
+        if (ybasicpos + cell->GetDescent() < -ysizeup) ysizeup = - (ybasicpos + cell->GetDescent());
+
+        cell->SetPos(xpos, ybasicpos + cell->GetDescent());
+        xpos += cell->GetWidth();
+        cell = cell->GetNext();
+        xcnt++;
+
+        // force new line if occured:
+        if ((cell == NULL) || (xpos + cell->GetWidth() > s_width))
+        {
+            if (xpos > MaxLineWidth) MaxLineWidth = xpos;
+            if (ysizeup < 0) ysizeup = 0;
+            if (ysizedown < 0) ysizedown = 0;
+            switch (m_AlignHor) {
+                case wxHTML_ALIGN_LEFT :
+                case wxHTML_ALIGN_JUSTIFY :
+                         xdelta = 0;
+                         break;
+                case wxHTML_ALIGN_RIGHT :
+                         xdelta = 0 + (s_width - xpos);
+                         break;
+                case wxHTML_ALIGN_CENTER :
+                         xdelta = 0 + (s_width - xpos) / 2;
+                         break;
+            }
+            if (xdelta < 0) xdelta = 0;
+            xdelta += s_indent;
+
+            ypos += ysizeup;
+
+            if (m_AlignHor != wxHTML_ALIGN_JUSTIFY || cell == NULL)
+                while (line != cell)
+                {
+                    line->SetPos(line->GetPosX() + xdelta,
+                                   ypos + line->GetPosY());
+                    line = line->GetNext();
+                }
+            else
+            {
+                int counter = 0;
+                int step = (s_width - xpos);
+                if (step < 0) step = 0;
+                xcnt--;
+                if (xcnt > 0) while (line != cell)
+                {
+                    line->SetPos(line->GetPosX() + s_indent +
+                                   (counter++ * step / xcnt),
+                                   ypos + line->GetPosY());
+                    line = line->GetNext();
+                }
+                xcnt++;
+            }
+
+            ypos += ysizedown;
+            xpos = xcnt = 0;
+            ysizeup = ysizedown = 0;
+            line = cell;
+        }
+    }
+
+    // setup height & width, depending on container layout:
+    m_Height = ypos + (ysizedown + ysizeup) + m_IndentBottom;
+
+    if (m_Height < m_MinHeight)
+    {
+        if (m_MinHeightAlign != wxHTML_ALIGN_TOP)
+        {
+            int diff = m_MinHeight - m_Height;
+            if (m_MinHeightAlign == wxHTML_ALIGN_CENTER) diff /= 2;
+            cell = m_Cells;
+            while (cell)
+            {
+                cell->SetPos(cell->GetPosX(), cell->GetPosY() + diff);
+                cell = cell->GetNext();
+            }
+        }
+        m_Height = m_MinHeight;
+    }
+
+    MaxLineWidth += s_indent + ((m_IndentRight < 0) ? (-m_IndentRight * m_Width / 100) : m_IndentRight);
+    if (m_Width < MaxLineWidth) m_Width = MaxLineWidth;
+
+    m_LastLayout = w;
+}
+
+
+#define mMin(a, b) (((a) < (b)) ? (a) : (b))
+#define mMax(a, b) (((a) < (b)) ? (b) : (a))
+
+void wxHtmlContainerCell::Draw(wxDC& dc, int x, int y, int view_y1, int view_y2)
+{
+    // container visible, draw it:
+    if ((y + m_PosY <= view_y2) && (y + m_PosY + m_Height > view_y1))
+    {
+        if (m_UseBkColour)
+        {
+            wxBrush myb = wxBrush(m_BkColour, wxSOLID);
+
+            int real_y1 = mMax(y + m_PosY, view_y1);
+            int real_y2 = mMin(y + m_PosY + m_Height - 1, view_y2);
+
+            dc.SetBrush(myb);
+            dc.SetPen(*wxTRANSPARENT_PEN);
+            dc.DrawRectangle(x + m_PosX, real_y1, m_Width, real_y2 - real_y1 + 1);
+        }
+
+        if (m_UseBorder)
+        {
+            wxPen mypen1(m_BorderColour1, 1, wxSOLID);
+            wxPen mypen2(m_BorderColour2, 1, wxSOLID);
+
+            dc.SetPen(mypen1);
+            dc.DrawLine(x + m_PosX, y + m_PosY, x + m_PosX, y + m_PosY + m_Height - 1);
+            dc.DrawLine(x + m_PosX, y + m_PosY, x + m_PosX + m_Width, y + m_PosY);
+            dc.SetPen(mypen2);
+            dc.DrawLine(x + m_PosX + m_Width - 1, y + m_PosY, x + m_PosX +  m_Width - 1, y + m_PosY + m_Height - 1);
+            dc.DrawLine(x + m_PosX, y + m_PosY + m_Height - 1, x + m_PosX + m_Width, y + m_PosY + m_Height - 1);
+        }
+
+        if (m_Cells)
+        {
+            for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
+                cell->Draw(dc, x + m_PosX, y + m_PosY, view_y1, view_y2);
+        }
+    }
+    // container invisible, just proceed font+color changing:
+    else
+    {
+        if (m_Cells)
+        {
+            for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
+                cell->DrawInvisible(dc, x + m_PosX, y + m_PosY);
+        }
+    }
+}
+
+
+
+void wxHtmlContainerCell::DrawInvisible(wxDC& dc, int x, int y)
+{
+    if (m_Cells)
+    {
+        for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
+            cell->DrawInvisible(dc, x + m_PosX, y + m_PosY);
+    }
+}
+
+
+wxColour wxHtmlContainerCell::GetBackgroundColour()
+{
+    if (m_UseBkColour)
+        return m_BkColour;
+    else
+        return wxNullColour;
+}
+
+
+
+wxHtmlLinkInfo *wxHtmlContainerCell::GetLink(int x, int y) const
+{
+    wxHtmlCell *cell = FindCellByPos(x, y);
+
+    // VZ: I don't know if we should pass absolute or relative coords to
+    //     wxHtmlCell::GetLink()? As the base class version just ignores them
+    //     anyhow, it hardly matters right now but should still be clarified
+    return cell ? cell->GetLink(x, y) : NULL;
+}
+
+
+
+void wxHtmlContainerCell::InsertCell(wxHtmlCell *f)
+{
+    if (!m_Cells) m_Cells = m_LastCell = f;
+    else
+    {
+        m_LastCell->SetNext(f);
+        m_LastCell = f;
+        if (m_LastCell) while (m_LastCell->GetNext()) m_LastCell = m_LastCell->GetNext();
+    }
+    f->SetParent(this);
+    m_LastLayout = -1;
+}
+
+
+
+void wxHtmlContainerCell::SetAlign(const wxHtmlTag& tag)
+{
+    if (tag.HasParam(wxT("ALIGN")))
+    {
+        wxString alg = tag.GetParam(wxT("ALIGN"));
+        alg.MakeUpper();
+        if (alg == wxT("CENTER"))
+            SetAlignHor(wxHTML_ALIGN_CENTER);
+        else if (alg == wxT("LEFT"))
+            SetAlignHor(wxHTML_ALIGN_LEFT);
+        else if (alg == wxT("JUSTIFY"))
+            SetAlignHor(wxHTML_ALIGN_JUSTIFY);
+        else if (alg == wxT("RIGHT"))
+            SetAlignHor(wxHTML_ALIGN_RIGHT);
+        m_LastLayout = -1;
+    }
+}
+
+
+
+void wxHtmlContainerCell::SetWidthFloat(const wxHtmlTag& tag, double pixel_scale)
+{
+    if (tag.HasParam(wxT("WIDTH")))
+    {
+        int wdi;
+        wxString wd = tag.GetParam(wxT("WIDTH"));
+
+        if (wd[wd.Length()-1] == wxT('%'))
+        {
+            wxSscanf(wd.c_str(), wxT("%i%%"), &wdi);
+            SetWidthFloat(wdi, wxHTML_UNITS_PERCENT);
+        }
+        else
+        {
+            wxSscanf(wd.c_str(), wxT("%i"), &wdi);
+            SetWidthFloat((int)(pixel_scale * (double)wdi), wxHTML_UNITS_PIXELS);
+        }
+        m_LastLayout = -1;
+    }
+}
+
+
+
+const wxHtmlCell* wxHtmlContainerCell::Find(int condition, const void* param) const
+{
+    if (m_Cells)
+    {
+        const wxHtmlCell *r = NULL;
+
+        for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
+        {
+            r = cell->Find(condition, param);
+            if (r) return r;
+        }
+    }
+    return NULL;
+}
+
+
+wxHtmlCell *wxHtmlContainerCell::FindCellByPos(wxCoord x, wxCoord y) const
+{
+    for ( const wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext() )
+    {
+        int cx = cell->GetPosX(),
+            cy = cell->GetPosY();
+
+        if ( (cx <= x) && (cx + cell->GetWidth() > x) &&
+             (cy <= y) && (cy + cell->GetHeight() > y) )
+        {
+            return cell->FindCellByPos(x - cx, y - cy);
+        }
+    }
+
+    return NULL;
+}
+
+
+void wxHtmlContainerCell::OnMouseClick(wxWindow *parent, int x, int y, const wxMouseEvent& event)
+{
+    wxHtmlCell *cell = FindCellByPos(x, y);
+    if ( cell )
+        cell->OnMouseClick(parent, x, y, event);
+}
+
+
+
+void wxHtmlContainerCell::GetHorizontalConstraints(int *left, int *right) const
+{
+    int cleft = m_PosX + m_Width, cright = m_PosX; // worst case
+    int l, r;
+
+    for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
+    {
+        cell->GetHorizontalConstraints(&l, &r);
+        if (l < cleft)
+            cleft = l;
+        if (r > cright)
+            cright = r;
+    }
+
+    cleft -= (m_IndentLeft < 0) ? (-m_IndentLeft * m_Width / 100) : m_IndentLeft;
+    cright += (m_IndentRight < 0) ? (-m_IndentRight * m_Width / 100) : m_IndentRight;
+
+    if (left)
+        *left = cleft;
+    if (right)
+        *right = cright;
+}
+
+
+
+
+
+//--------------------------------------------------------------------------------
+// wxHtmlColourCell
+//--------------------------------------------------------------------------------
+
+void wxHtmlColourCell::Draw(wxDC& dc, int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(view_y1), int WXUNUSED(view_y2))
+{
+    if (m_Flags & wxHTML_CLR_FOREGROUND)
+        dc.SetTextForeground(m_Colour);
+    if (m_Flags & wxHTML_CLR_BACKGROUND)
+    {
+        dc.SetBackground(wxBrush(m_Colour, wxSOLID));
+        dc.SetTextBackground(m_Colour);
+    }
+}
+
+void wxHtmlColourCell::DrawInvisible(wxDC& dc, int WXUNUSED(x), int WXUNUSED(y))
+{
+    if (m_Flags & wxHTML_CLR_FOREGROUND)
+        dc.SetTextForeground(m_Colour);
+    if (m_Flags & wxHTML_CLR_BACKGROUND)
+    {
+        dc.SetBackground(wxBrush(m_Colour, wxSOLID));
+        dc.SetTextBackground(m_Colour);
+    }
+}
+
+
+
+
+//--------------------------------------------------------------------------------
+// wxHtmlFontCell
+//--------------------------------------------------------------------------------
+
+void wxHtmlFontCell::Draw(wxDC& dc, int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(view_y1), int WXUNUSED(view_y2))
+{
+    dc.SetFont(m_Font);
+}
+
+void wxHtmlFontCell::DrawInvisible(wxDC& dc, int WXUNUSED(x), int WXUNUSED(y))
+{
+    dc.SetFont(m_Font);
+}
+
+
+
+
+
+
+
+
+//--------------------------------------------------------------------------------
+// wxHtmlWidgetCell
+//--------------------------------------------------------------------------------
+
+wxHtmlWidgetCell::wxHtmlWidgetCell(wxWindow *wnd, int w)
+{
+    int sx, sy;
+    m_Wnd = wnd;
+    m_Wnd->GetSize(&sx, &sy);
+    m_Width = sx, m_Height = sy;
+    m_WidthFloat = w;
+}
+
+
+void wxHtmlWidgetCell::Draw(wxDC& WXUNUSED(dc), int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(view_y1), int WXUNUSED(view_y2))
+{
+    int absx = 0, absy = 0, stx, sty;
+    wxHtmlCell *c = this;
+
+    while (c)
+    {
+        absx += c->GetPosX();
+        absy += c->GetPosY();
+        c = c->GetParent();
+    }
+
+    ((wxScrolledWindow*)(m_Wnd->GetParent()))->GetViewStart(&stx, &sty);
+    m_Wnd->SetSize(absx - wxHTML_SCROLL_STEP * stx, absy  - wxHTML_SCROLL_STEP * sty, m_Width, m_Height);
+}
+
+
+
+void wxHtmlWidgetCell::DrawInvisible(wxDC& WXUNUSED(dc), int WXUNUSED(x), int WXUNUSED(y))
+{
+    int absx = 0, absy = 0, stx, sty;
+    wxHtmlCell *c = this;
+
+    while (c)
+    {
+        absx += c->GetPosX();
+        absy += c->GetPosY();
+        c = c->GetParent();
+    }
+
+    ((wxScrolledWindow*)(m_Wnd->GetParent()))->GetViewStart(&stx, &sty);
+    m_Wnd->SetSize(absx - wxHTML_SCROLL_STEP * stx, absy  - wxHTML_SCROLL_STEP * sty, m_Width, m_Height);
+}
+
+
+
+void wxHtmlWidgetCell::Layout(int w)
+{
+    if (m_WidthFloat != 0)
+    {
+        m_Width = (w * m_WidthFloat) / 100;
+        m_Wnd->SetSize(m_Width, m_Height);
+    }
+
+    wxHtmlCell::Layout(w);
+}
+
+#endif

src/html/htmlfilt.cpp

@@ -0,0 +1,229 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        htmlfilt.cpp
+// Purpose:     wxHtmlFilter - input filter for translating into HTML format
+// Author:      Vaclav Slavik
+// RCS-ID:      $Id$
+// Copyright:   (c) 1999 Vaclav Slavik
+// Licence:     wxWindows Licence
+/////////////////////////////////////////////////////////////////////////////
+
+
+#ifdef __GNUG__
+#pragma implementation "htmlfilt.h"
+#endif
+
+#include "wx/wxprec.h"
+
+#include "wx/defs.h"
+#if wxUSE_HTML && wxUSE_STREAMS
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#ifndef WXPRECOMP
+    #include "wx/log.h"
+    #include "wx/intl.h"
+#endif
+
+#include "wx/strconv.h"
+#include "wx/html/htmlfilt.h"
+#include "wx/html/htmlwin.h"
+
+// utility function: read a wxString from a wxInputStream
+static void ReadString(wxString& str, wxInputStream* s, wxMBConv& conv)
+{
+    size_t streamSize = s->GetSize();
+
+    if (streamSize == ~(size_t)0)
+    {
+        const size_t bufSize = 4095;
+        char buffer[bufSize+1];
+        size_t lastRead;
+
+        do
+        {
+            s->Read(buffer, bufSize);
+            lastRead = s->LastRead();
+            buffer[lastRead] = 0;
+            str.Append(wxString(buffer, conv));
+        }
+        while (lastRead == bufSize);
+    }
+    else
+    {
+        char* src = new char[streamSize+1];
+        s->Read(src, streamSize);
+        src[streamSize] = 0;
+        str = wxString(src, conv);
+        delete[] src;
+    }
+}
+
+/*
+
+There is code for several default filters:
+
+*/
+
+IMPLEMENT_ABSTRACT_CLASS(wxHtmlFilter, wxObject)
+
+//--------------------------------------------------------------------------------
+// wxHtmlFilterPlainText
+//          filter for text/plain or uknown
+//--------------------------------------------------------------------------------
+
+IMPLEMENT_DYNAMIC_CLASS(wxHtmlFilterPlainText, wxHtmlFilter)
+
+bool wxHtmlFilterPlainText::CanRead(const wxFSFile& WXUNUSED(file)) const
+{
+    return TRUE;
+}
+
+
+
+wxString wxHtmlFilterPlainText::ReadFile(const wxFSFile& file) const
+{
+    wxInputStream *s = file.GetStream();
+    wxString doc, doc2;
+
+    if (s == NULL) return wxEmptyString;
+    ReadString(doc, s, wxConvISO8859_1);
+
+    doc.Replace(wxT("&"), wxT("&"), TRUE);
+    doc.Replace(wxT("<"), wxT("&lt;"), TRUE);
+    doc.Replace(wxT(">"), wxT("&gt;"), TRUE);
+    doc2 = wxT("<HTML><BODY><PRE>\n") + doc + wxT("\n</PRE></BODY></HTML>");
+    return doc2;
+}
+
+
+
+
+
+//--------------------------------------------------------------------------------
+// wxHtmlFilterImage
+//          filter for image/*
+//--------------------------------------------------------------------------------
+
+class wxHtmlFilterImage : public wxHtmlFilter
+{
+    DECLARE_DYNAMIC_CLASS(wxHtmlFilterImage)
+
+    public:
+        virtual bool CanRead(const wxFSFile& file) const;
+        virtual wxString ReadFile(const wxFSFile& file) const;
+};
+
+IMPLEMENT_DYNAMIC_CLASS(wxHtmlFilterImage, wxHtmlFilter)
+
+
+
+bool wxHtmlFilterImage::CanRead(const wxFSFile& file) const
+{
+    return (file.GetMimeType().Left(6) == wxT("image/"));
+}
+
+
+
+wxString wxHtmlFilterImage::ReadFile(const wxFSFile& file) const
+{
+    wxString res = wxT("<HTML><BODY><IMG SRC=\"") + file.GetLocation() + wxT("\"></BODY></HTML>");
+    return res;
+}
+
+
+
+
+//--------------------------------------------------------------------------------
+// wxHtmlFilterHTML
+//          filter for text/html
+//--------------------------------------------------------------------------------
+
+
+IMPLEMENT_DYNAMIC_CLASS(wxHtmlFilterHTML, wxHtmlFilter)
+
+bool wxHtmlFilterHTML::CanRead(const wxFSFile& file) const
+{
+//    return (file.GetMimeType() == "text/html");
+// This is true in most case but some page can return:
+// "text/html; char-encoding=...."
+// So we use Find instead
+  return (file.GetMimeType().Find(wxT("text/html")) == 0);
+}
+
+
+
+wxString wxHtmlFilterHTML::ReadFile(const wxFSFile& file) const
+{
+    wxInputStream *s = file.GetStream();
+    wxString doc;
+
+    if (s == NULL)
+    {
+        wxLogError(_("Cannot open HTML document: %s"), file.GetLocation().c_str());
+        return wxEmptyString;
+    }
+
+    // NB: We convert input file to wchar_t here in Unicode mode, based on 
+    //     either Content-Type header or <meta> tags. In ANSI mode, we don't
+    //     do it as it is done by wxHtmlParser (for this reason, we add <meta>
+    //     tag if we used Content-Type header).
+#if wxUSE_UNICODE
+    int charsetPos;    
+    if ((charsetPos = file.GetMimeType().Find(_T("; charset="))) != wxNOT_FOUND)
+    {
+        wxString charset = file.GetMimeType().Mid(charsetPos + 10);
+        wxCSConv conv(charset);
+        ReadString(doc, s, conv);
+    }
+    else
+    {
+        wxString tmpdoc;
+        ReadString(tmpdoc, s, wxConvISO8859_1);
+        wxString charset = wxHtmlParser::ExtractCharsetInformation(tmpdoc);
+        if (charset.empty())
+            doc = tmpdoc;
+        else
+        {
+            wxCSConv conv(charset);
+            doc = wxString(tmpdoc.mb_str(wxConvISO8859_1), conv);
+        }
+    }
+#else // !wxUSE_UNICODE
+    ReadString(doc, s, wxConvLibc);
+    // add meta tag if we obtained this through http:
+    if (!file.GetMimeType().empty())
+    {
+        wxString hdr;
+        wxString mime = file.GetMimeType();
+        hdr.Printf(_T("<meta http-equiv=\"Content-Type\" content=\"%s\">"), mime.c_str());
+        return hdr+doc;
+    }
+#endif
+
+    return doc;
+}
+
+
+
+
+///// Module:
+
+class wxHtmlFilterModule : public wxModule
+{
+    DECLARE_DYNAMIC_CLASS(wxHtmlFilterModule)
+
+    public:
+        virtual bool OnInit()
+        {
+            wxHtmlWindow::AddFilter(new wxHtmlFilterHTML);
+            wxHtmlWindow::AddFilter(new wxHtmlFilterImage);
+            return TRUE;
+        }
+        virtual void OnExit() {}
+};
+
+IMPLEMENT_DYNAMIC_CLASS(wxHtmlFilterModule, wxModule)
+
+#endif

src/html/htmlpars.cpp

@@ -0,0 +1,900 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        htmlpars.cpp
+// Purpose:     wxHtmlParser class (generic parser)
+// Author:      Vaclav Slavik
+// RCS-ID:      $Id$
+// Copyright:   (c) 1999 Vaclav Slavik
+// Licence:     wxWindows Licence
+/////////////////////////////////////////////////////////////////////////////
+
+
+#ifdef __GNUG__
+#pragma implementation "htmlpars.h"
+#endif
+
+#include "wx/wxprec.h"
+
+#include "wx/defs.h"
+#if wxUSE_HTML && wxUSE_STREAMS
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#ifndef WXPRECOMP
+    #include "wx/log.h"
+    #include "wx/intl.h"
+#endif
+
+#include "wx/tokenzr.h"
+#include "wx/wfstream.h"
+#include "wx/url.h"
+#include "wx/fontmap.h"
+#include "wx/html/htmldefs.h"
+#include "wx/html/htmlpars.h"
+#include "wx/dynarray.h"
+#include "wx/arrimpl.cpp"
+
+//-----------------------------------------------------------------------------
+// wxHtmlParser helpers
+//-----------------------------------------------------------------------------
+
+class wxHtmlTextPiece
+{
+public:
+    wxHtmlTextPiece(int pos, int lng) : m_pos(pos), m_lng(lng) {}
+    int m_pos, m_lng;
+};
+
+WX_DECLARE_OBJARRAY(wxHtmlTextPiece, wxHtmlTextPieces);
+WX_DEFINE_OBJARRAY(wxHtmlTextPieces);
+
+class wxHtmlParserState
+{
+public:
+    wxHtmlTag         *m_curTag;
+    wxHtmlTag         *m_tags;
+    wxHtmlTextPieces  *m_textPieces;
+    int                m_curTextPiece;
+    wxString           m_source;
+    wxHtmlParserState *m_nextState;
+};
+
+//-----------------------------------------------------------------------------
+// wxHtmlParser
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_ABSTRACT_CLASS(wxHtmlParser,wxObject)
+
+wxHtmlParser::wxHtmlParser()
+    : wxObject(), m_HandlersHash(wxKEY_STRING),
+      m_FS(NULL), m_HandlersStack(NULL)
+{
+    m_entitiesParser = new wxHtmlEntitiesParser;
+    m_Tags = NULL;
+    m_CurTag = NULL;
+    m_TextPieces = NULL;
+    m_CurTextPiece = 0;
+    m_SavedStates = NULL;
+}
+
+wxHtmlParser::~wxHtmlParser()
+{
+    while (RestoreState()) {}
+    DestroyDOMTree();
+    
+    delete m_HandlersStack;
+    m_HandlersHash.Clear();
+    m_HandlersList.DeleteContents(TRUE);
+    m_HandlersList.Clear();
+    delete m_entitiesParser;
+}
+
+wxObject* wxHtmlParser::Parse(const wxString& source)
+{
+    InitParser(source);
+    DoParsing();
+    wxObject *result = GetProduct();
+    DoneParser();
+    return result;
+}
+
+void wxHtmlParser::InitParser(const wxString& source)
+{
+    SetSource(source);
+    m_stopParsing = FALSE;
+}
+
+void wxHtmlParser::DoneParser()
+{
+    DestroyDOMTree();
+}
+
+void wxHtmlParser::SetSource(const wxString& src)
+{
+    DestroyDOMTree();
+    m_Source = src;
+    CreateDOMTree();
+    m_CurTag = NULL;
+    m_CurTextPiece = 0;
+}
+
+void wxHtmlParser::CreateDOMTree()
+{
+    wxHtmlTagsCache cache(m_Source);
+    m_TextPieces = new wxHtmlTextPieces;
+    CreateDOMSubTree(NULL, 0, m_Source.Length(), &cache);
+    m_CurTextPiece = 0;
+}
+
+extern bool wxIsCDATAElement(const wxChar *tag);
+
+void wxHtmlParser::CreateDOMSubTree(wxHtmlTag *cur,
+                                    int begin_pos, int end_pos,
+                                    wxHtmlTagsCache *cache)
+{
+    if (end_pos <= begin_pos) return;
+
+    wxChar c;
+    int i = begin_pos;
+    int textBeginning = begin_pos;
+
+    // If the tag contains CDATA text, we include the text between beginning
+    // and ending tag verbosely. Setting i=end_pos will skip to the very
+    // end of this function where text piece is added, bypassing any child
+    // tags parsing (CDATA element can't have child elements by definition):
+    if (cur != NULL && wxIsCDATAElement(cur->GetName().c_str()))
+    {
+        i = end_pos;
+    }
+
+    while (i < end_pos)
+    {
+        c = m_Source.GetChar(i);
+
+        if (c == wxT('<'))
+        {
+            // add text to m_TextPieces:
+            if (i - textBeginning > 0)
+                m_TextPieces->Add(
+                    wxHtmlTextPiece(textBeginning, i - textBeginning));
+
+            // if it is a comment, skip it:
+            if (i < end_pos-6 && m_Source.GetChar(i+1) == wxT('!') &&
+                                 m_Source.GetChar(i+2) == wxT('-') &&
+                                 m_Source.GetChar(i+3) == wxT('-'))
+            {
+                // Comments begin with "<!--" and end with "--[ \t\r\n]*>"
+                // according to HTML 4.0
+                int dashes = 0;
+                i += 4;
+                while (i < end_pos)
+                {
+                    c = m_Source.GetChar(i++);
+                    if ((c == wxT(' ') || c == wxT('\n') ||
+                        c == wxT('\r') || c == wxT('\t')) && dashes >= 2) {}
+                    else if (c == wxT('>') && dashes >= 2)
+                    {
+                        textBeginning = i;
+                        break;
+                    }
+                    else if (c == wxT('-'))
+                        dashes++;
+                    else
+                        dashes = 0;
+                }
+            }
+
+            // add another tag to the tree:
+            else if (i < end_pos-1 && m_Source.GetChar(i+1) != wxT('/'))
+	        {
+                wxHtmlTag *chd;
+                if (cur)
+                    chd = new wxHtmlTag(cur, m_Source,
+                                        i, end_pos, cache, m_entitiesParser);
+                else
+                {
+                    chd = new wxHtmlTag(NULL, m_Source,
+                                        i, end_pos, cache, m_entitiesParser);
+                    if (!m_Tags)
+                    {
+                        // if this is the first tag to be created make the root
+                        // m_Tags point to it:
+                        m_Tags = chd;
+                    }
+                    else
+                    {
+                        // if there is already a root tag add this tag as
+                        // the last sibling:
+                        chd->m_Prev = m_Tags->GetLastSibling();
+                        chd->m_Prev->m_Next = chd;
+                    }
+                }
+
+                if (chd->HasEnding())
+                {
+                    CreateDOMSubTree(chd,
+                                     chd->GetBeginPos(), chd->GetEndPos1(),
+                                     cache);
+                    i = chd->GetEndPos2();
+                }
+                else
+                    i = chd->GetBeginPos();
+                
+                textBeginning = i;
+            }
+
+            // ... or skip ending tag:
+            else
+            {
+                while (i < end_pos && m_Source.GetChar(i) != wxT('>')) i++;
+                textBeginning = i+1;
+            }
+        }
+        else i++;
+    }
+
+    // add remaining text to m_TextPieces:
+    if (end_pos - textBeginning > 0)
+        m_TextPieces->Add(
+            wxHtmlTextPiece(textBeginning, end_pos - textBeginning));
+}
+
+void wxHtmlParser::DestroyDOMTree()
+{
+    wxHtmlTag *t1, *t2;
+    t1 = m_Tags;
+    while (t1)
+    {
+        t2 = t1->GetNextSibling();
+        delete t1;
+        t1 = t2;
+    }
+    m_Tags = m_CurTag = NULL;
+
+    delete m_TextPieces;
+    m_TextPieces = NULL;
+}
+
+void wxHtmlParser::DoParsing()
+{
+    m_CurTag = m_Tags;
+    m_CurTextPiece = 0;
+    DoParsing(0, m_Source.Length());
+}
+
+void wxHtmlParser::DoParsing(int begin_pos, int end_pos)
+{
+    if (end_pos <= begin_pos) return;
+
+    wxHtmlTextPieces& pieces = *m_TextPieces;
+    size_t piecesCnt = pieces.GetCount();
+
+    while (begin_pos < end_pos)
+    {
+        while (m_CurTag && m_CurTag->GetBeginPos() < begin_pos)
+            m_CurTag = m_CurTag->GetNextTag();
+        while (m_CurTextPiece < piecesCnt &&
+               pieces[m_CurTextPiece].m_pos < begin_pos)
+            m_CurTextPiece++;
+
+        if (m_CurTextPiece < piecesCnt &&
+            (!m_CurTag ||
+             pieces[m_CurTextPiece].m_pos < m_CurTag->GetBeginPos()))
+        {
+            // Add text:
+            AddText(GetEntitiesParser()->Parse(
+                       m_Source.Mid(pieces[m_CurTextPiece].m_pos,
+                                    pieces[m_CurTextPiece].m_lng)));
+            begin_pos = pieces[m_CurTextPiece].m_pos +
+                        pieces[m_CurTextPiece].m_lng;
+            m_CurTextPiece++;
+        }
+        else if (m_CurTag)
+        {
+            // Add tag:
+            if (m_CurTag)
+            {
+                if (m_CurTag->HasEnding())
+                    begin_pos = m_CurTag->GetEndPos2();
+                else
+                    begin_pos = m_CurTag->GetBeginPos();
+            }
+            wxHtmlTag *t = m_CurTag;
+            m_CurTag = m_CurTag->GetNextTag();
+            AddTag(*t);
+            if (m_stopParsing)
+                return;
+        }
+        else break;
+    }
+}
+
+void wxHtmlParser::AddTag(const wxHtmlTag& tag)
+{
+    wxHtmlTagHandler *h;
+    bool inner = FALSE;
+
+    h = (wxHtmlTagHandler*) m_HandlersHash.Get(tag.GetName());
+    if (h)
+    {
+        inner = h->HandleTag(tag);
+        if (m_stopParsing)
+            return;
+    }
+    if (!inner)
+    {
+        if (tag.HasEnding())
+            DoParsing(tag.GetBeginPos(), tag.GetEndPos1());
+    }
+}
+
+void wxHtmlParser::AddTagHandler(wxHtmlTagHandler *handler)
+{
+    wxString s(handler->GetSupportedTags());
+    wxStringTokenizer tokenizer(s, wxT(", "));
+
+    while (tokenizer.HasMoreTokens())
+        m_HandlersHash.Put(tokenizer.GetNextToken(), handler);
+
+    if (m_HandlersList.IndexOf(handler) == wxNOT_FOUND)
+        m_HandlersList.Append(handler);
+
+    handler->SetParser(this);
+}
+
+void wxHtmlParser::PushTagHandler(wxHtmlTagHandler *handler, wxString tags)
+{
+    wxStringTokenizer tokenizer(tags, wxT(", "));
+    wxString key;
+
+    if (m_HandlersStack == NULL)
+    {
+        m_HandlersStack = new wxList;
+        m_HandlersStack->DeleteContents(TRUE);
+    }
+
+    m_HandlersStack->Insert(new wxHashTable(m_HandlersHash));
+
+    while (tokenizer.HasMoreTokens())
+    {
+        key = tokenizer.GetNextToken();
+        m_HandlersHash.Delete(key);
+        m_HandlersHash.Put(key, handler);
+    }
+}
+
+void wxHtmlParser::PopTagHandler()
+{
+    wxNode *first;
+
+    if (m_HandlersStack == NULL ||
+        (first = m_HandlersStack->GetFirst()) == NULL)
+    {
+        wxLogWarning(_("Warning: attempt to remove HTML tag handler from empty stack."));
+        return;
+    }
+    m_HandlersHash = *((wxHashTable*) first->GetData());
+    m_HandlersStack->DeleteNode(first);
+}
+
+void wxHtmlParser::SetSourceAndSaveState(const wxString& src)
+{
+    wxHtmlParserState *s = new wxHtmlParserState;
+
+    s->m_curTag = m_CurTag;
+    s->m_tags = m_Tags;
+    s->m_textPieces = m_TextPieces;
+    s->m_curTextPiece = m_CurTextPiece;
+    s->m_source = m_Source;
+
+    s->m_nextState = m_SavedStates;
+    m_SavedStates = s;
+
+    m_CurTag = NULL;
+    m_Tags = NULL;
+    m_TextPieces = NULL;
+    m_CurTextPiece = 0;
+    m_Source = wxEmptyString;
+
+    SetSource(src);
+}
+
+bool wxHtmlParser::RestoreState()
+{
+    if (!m_SavedStates) return FALSE;
+
+    DestroyDOMTree();
+
+    wxHtmlParserState *s = m_SavedStates;
+    m_SavedStates = s->m_nextState;
+
+    m_CurTag = s->m_curTag;
+    m_Tags = s->m_tags;
+    m_TextPieces = s->m_textPieces;
+    m_CurTextPiece = s->m_curTextPiece;
+    m_Source = s->m_source;
+
+    delete s;
+    return TRUE;
+}
+
+//-----------------------------------------------------------------------------
+// wxHtmlTagHandler
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_ABSTRACT_CLASS(wxHtmlTagHandler,wxObject)
+
+
+//-----------------------------------------------------------------------------
+// wxHtmlEntitiesParser
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_DYNAMIC_CLASS(wxHtmlEntitiesParser,wxObject)
+
+wxHtmlEntitiesParser::wxHtmlEntitiesParser()
+#if wxUSE_WCHAR_T && !wxUSE_UNICODE
+    : m_conv(NULL), m_encoding(wxFONTENCODING_SYSTEM)
+#endif
+{
+}
+
+wxHtmlEntitiesParser::~wxHtmlEntitiesParser()
+{
+#if wxUSE_WCHAR_T && !wxUSE_UNICODE
+    delete m_conv;
+#endif
+}
+
+void wxHtmlEntitiesParser::SetEncoding(wxFontEncoding encoding)
+{
+#if wxUSE_WCHAR_T && !wxUSE_UNICODE
+    if (encoding == m_encoding)
+        return;
+
+    delete m_conv;
+
+    m_encoding = encoding;
+    if (m_encoding == wxFONTENCODING_SYSTEM)
+        m_conv = NULL;
+    else
+        m_conv = new wxCSConv(wxFontMapper::GetEncodingName(m_encoding));
+#else
+    (void) encoding;
+#endif
+}
+
+wxString wxHtmlEntitiesParser::Parse(const wxString& input)
+{
+    const wxChar *c, *last;
+    const wxChar *in_str = input.c_str();
+    wxString output;
+    
+    output.reserve(input.length());
+
+    for (c = in_str, last = in_str; *c != wxT('\0'); c++)
+    {
+        if (*c == wxT('&'))
+        {
+            if (c - last > 0)
+                output.append(last, c - last);
+            if (++c == wxT('\0')) break;
+        
+            wxString entity;
+            const wxChar *ent_s = c;
+            wxChar entity_char;
+        
+            for (; (*c >= wxT('a') && *c <= wxT('z')) ||
+                   (*c >= wxT('A') && *c <= wxT('Z')) ||
+                   (*c >= wxT('0') && *c <= wxT('9')) ||
+                   *c == wxT('_') || *c == wxT('#'); c++) {}
+            entity.append(ent_s, c - ent_s);
+            if (*c != wxT(';')) c--;
+            last = c+1;
+            entity_char = GetEntityChar(entity);
+            if (entity_char)
+                output << entity_char;
+            else
+            {
+                output.append(ent_s-1, c-ent_s+2);
+                wxLogDebug(wxT("Unrecognized HTML entity: '%s'"), entity.c_str());
+            }
+        }
+    }
+    if (*last != wxT('\0'))
+        output.append(last);
+    return output;
+}
+
+struct wxHtmlEntityInfo
+{
+    const wxChar *name;
+    unsigned code;
+};
+
+extern "C" int LINKAGEMODE wxHtmlEntityCompare(const void *key, const void *item)
+{
+    return wxStrcmp((wxChar*)key, ((wxHtmlEntityInfo*)item)->name);
+}
+
+#if !wxUSE_UNICODE
+wxChar wxHtmlEntitiesParser::GetCharForCode(unsigned code)
+{
+#if wxUSE_WCHAR_T
+    char buf[2];
+    wchar_t wbuf[2];
+    wbuf[0] = (wchar_t)code;
+    wbuf[1] = 0;
+    wxMBConv *conv = m_conv ? m_conv : &wxConvLocal;
+    if (conv->WC2MB(buf, wbuf, 2) == (size_t)-1)
+        return '?';
+    return buf[0];
+#else
+    return (code < 256) ? (wxChar)code : '?';
+#endif
+}
+#endif
+
+wxChar wxHtmlEntitiesParser::GetEntityChar(const wxString& entity)
+{
+    unsigned code = 0;
+
+    if (entity[0] == wxT('#'))
+    {
+        const wxChar *ent_s = entity.c_str();
+        const wxChar *format;
+
+        if (ent_s[1] == wxT('x') || ent_s[1] == wxT('X'))
+        {
+            format = wxT("%x");
+            ent_s++;
+        }
+        else
+            format = wxT("%u");
+        ent_s++;
+
+        if (wxSscanf(ent_s, format, &code) != 1)
+            code = 0;
+    }
+    else
+    {
+        static wxHtmlEntityInfo substitutions[] = {
+            { wxT("AElig"),198 },
+            { wxT("Aacute"),193 },
+            { wxT("Acirc"),194 },
+            { wxT("Agrave"),192 },
+            { wxT("Alpha"),913 },
+            { wxT("Aring"),197 },
+            { wxT("Atilde"),195 },
+            { wxT("Auml"),196 },
+            { wxT("Beta"),914 },
+            { wxT("Ccedil"),199 },
+            { wxT("Chi"),935 },
+            { wxT("Dagger"),8225 },
+            { wxT("Delta"),916 },
+            { wxT("ETH"),208 },
+            { wxT("Eacute"),201 },
+            { wxT("Ecirc"),202 },
+            { wxT("Egrave"),200 },
+            { wxT("Epsilon"),917 },
+            { wxT("Eta"),919 },
+            { wxT("Euml"),203 },
+            { wxT("Gamma"),915 },
+            { wxT("Iacute"),205 },
+            { wxT("Icirc"),206 },
+            { wxT("Igrave"),204 },
+            { wxT("Iota"),921 },
+            { wxT("Iuml"),207 },
+            { wxT("Kappa"),922 },
+            { wxT("Lambda"),923 },
+            { wxT("Mu"),924 },
+            { wxT("Ntilde"),209 },
+            { wxT("Nu"),925 },
+            { wxT("OElig"),338 },
+            { wxT("Oacute"),211 },
+            { wxT("Ocirc"),212 },
+            { wxT("Ograve"),210 },
+            { wxT("Omega"),937 },
+            { wxT("Omicron"),927 },
+            { wxT("Oslash"),216 },
+            { wxT("Otilde"),213 },
+            { wxT("Ouml"),214 },
+            { wxT("Phi"),934 },
+            { wxT("Pi"),928 },
+            { wxT("Prime"),8243 },
+            { wxT("Psi"),936 },
+            { wxT("Rho"),929 },
+            { wxT("Scaron"),352 },
+            { wxT("Sigma"),931 },
+            { wxT("THORN"),222 },
+            { wxT("Tau"),932 },
+            { wxT("Theta"),920 },
+            { wxT("Uacute"),218 },
+            { wxT("Ucirc"),219 },
+            { wxT("Ugrave"),217 },
+            { wxT("Upsilon"),933 },
+            { wxT("Uuml"),220 },
+            { wxT("Xi"),926 },
+            { wxT("Yacute"),221 },
+            { wxT("Yuml"),376 },
+            { wxT("Zeta"),918 },
+            { wxT("aacute"),225 },
+            { wxT("acirc"),226 },
+            { wxT("acute"),180 },
+            { wxT("aelig"),230 },
+            { wxT("agrave"),224 },
+            { wxT("alefsym"),8501 },
+            { wxT("alpha"),945 },
+            { wxT("amp"),38 },
+            { wxT("and"),8743 },
+            { wxT("ang"),8736 },
+            { wxT("aring"),229 },
+            { wxT("asymp"),8776 },
+            { wxT("atilde"),227 },
+            { wxT("auml"),228 },
+            { wxT("bdquo"),8222 },
+            { wxT("beta"),946 },
+            { wxT("brvbar"),166 },
+            { wxT("bull"),8226 },
+            { wxT("cap"),8745 },
+            { wxT("ccedil"),231 },
+            { wxT("cedil"),184 },
+            { wxT("cent"),162 },
+            { wxT("chi"),967 },
+            { wxT("circ"),710 },
+            { wxT("clubs"),9827 },
+            { wxT("cong"),8773 },
+            { wxT("copy"),169 },
+            { wxT("crarr"),8629 },
+            { wxT("cup"),8746 },
+            { wxT("curren"),164 },
+            { wxT("dArr"),8659 },
+            { wxT("dagger"),8224 },
+            { wxT("darr"),8595 },
+            { wxT("deg"),176 },
+            { wxT("delta"),948 },
+            { wxT("diams"),9830 },
+            { wxT("divide"),247 },
+            { wxT("eacute"),233 },
+            { wxT("ecirc"),234 },
+            { wxT("egrave"),232 },
+            { wxT("empty"),8709 },
+            { wxT("emsp"),8195 },
+            { wxT("ensp"),8194 },
+            { wxT("epsilon"),949 },
+            { wxT("equiv"),8801 },
+            { wxT("eta"),951 },
+            { wxT("eth"),240 },
+            { wxT("euml"),235 },
+            { wxT("euro"),8364 },
+            { wxT("exist"),8707 },
+            { wxT("fnof"),402 },
+            { wxT("forall"),8704 },
+            { wxT("frac12"),189 },
+            { wxT("frac14"),188 },
+            { wxT("frac34"),190 },
+            { wxT("frasl"),8260 },
+            { wxT("gamma"),947 },
+            { wxT("ge"),8805 },
+            { wxT("gt"),62 },
+            { wxT("hArr"),8660 },
+            { wxT("harr"),8596 },
+            { wxT("hearts"),9829 },
+            { wxT("hellip"),8230 },
+            { wxT("iacute"),237 },
+            { wxT("icirc"),238 },
+            { wxT("iexcl"),161 },
+            { wxT("igrave"),236 },
+            { wxT("image"),8465 },
+            { wxT("infin"),8734 },
+            { wxT("int"),8747 },
+            { wxT("iota"),953 },
+            { wxT("iquest"),191 },
+            { wxT("isin"),8712 },
+            { wxT("iuml"),239 },
+            { wxT("kappa"),954 },
+            { wxT("lArr"),8656 },
+            { wxT("lambda"),955 },
+            { wxT("lang"),9001 },
+            { wxT("laquo"),171 },
+            { wxT("larr"),8592 },
+            { wxT("lceil"),8968 },
+            { wxT("ldquo"),8220 },
+            { wxT("le"),8804 },
+            { wxT("lfloor"),8970 },
+            { wxT("lowast"),8727 },
+            { wxT("loz"),9674 },
+            { wxT("lrm"),8206 },
+            { wxT("lsaquo"),8249 },
+            { wxT("lsquo"),8216 },
+            { wxT("lt"),60 },
+            { wxT("macr"),175 },
+            { wxT("mdash"),8212 },
+            { wxT("micro"),181 },
+            { wxT("middot"),183 },
+            { wxT("minus"),8722 },
+            { wxT("mu"),956 },
+            { wxT("nabla"),8711 },
+            { wxT("nbsp"),160 },
+            { wxT("ndash"),8211 },
+            { wxT("ne"),8800 },
+            { wxT("ni"),8715 },
+            { wxT("not"),172 },
+            { wxT("notin"),8713 },
+            { wxT("nsub"),8836 },
+            { wxT("ntilde"),241 },
+            { wxT("nu"),957 },
+            { wxT("oacute"),243 },
+            { wxT("ocirc"),244 },
+            { wxT("oelig"),339 },
+            { wxT("ograve"),242 },
+            { wxT("oline"),8254 },
+            { wxT("omega"),969 },
+            { wxT("omicron"),959 },
+            { wxT("oplus"),8853 },
+            { wxT("or"),8744 },
+            { wxT("ordf"),170 },
+            { wxT("ordm"),186 },
+            { wxT("oslash"),248 },
+            { wxT("otilde"),245 },
+            { wxT("otimes"),8855 },
+            { wxT("ouml"),246 },
+            { wxT("para"),182 },
+            { wxT("part"),8706 },
+            { wxT("permil"),8240 },
+            { wxT("perp"),8869 },
+            { wxT("phi"),966 },
+            { wxT("pi"),960 },
+            { wxT("piv"),982 },
+            { wxT("plusmn"),177 },
+            { wxT("pound"),163 },
+            { wxT("prime"),8242 },
+            { wxT("prod"),8719 },
+            { wxT("prop"),8733 },
+            { wxT("psi"),968 },
+            { wxT("quot"),34 },
+            { wxT("rArr"),8658 },
+            { wxT("radic"),8730 },
+            { wxT("rang"),9002 },
+            { wxT("raquo"),187 },
+            { wxT("rarr"),8594 },
+            { wxT("rceil"),8969 },
+            { wxT("rdquo"),8221 },
+            { wxT("real"),8476 },
+            { wxT("reg"),174 },
+            { wxT("rfloor"),8971 },
+            { wxT("rho"),961 },
+            { wxT("rlm"),8207 },
+            { wxT("rsaquo"),8250 },
+            { wxT("rsquo"),8217 },
+            { wxT("sbquo"),8218 },
+            { wxT("scaron"),353 },
+            { wxT("sdot"),8901 },
+            { wxT("sect"),167 },
+            { wxT("shy"),173 },
+            { wxT("sigma"),963 },
+            { wxT("sigmaf"),962 },
+            { wxT("sim"),8764 },
+            { wxT("spades"),9824 },
+            { wxT("sub"),8834 },
+            { wxT("sube"),8838 },
+            { wxT("sum"),8721 },
+            { wxT("sup"),8835 },
+            { wxT("sup1"),185 },
+            { wxT("sup2"),178 },
+            { wxT("sup3"),179 },
+            { wxT("supe"),8839 },
+            { wxT("szlig"),223 },
+            { wxT("tau"),964 },
+            { wxT("there4"),8756 },
+            { wxT("theta"),952 },
+            { wxT("thetasym"),977 },
+            { wxT("thinsp"),8201 },
+            { wxT("thorn"),254 },
+            { wxT("tilde"),732 },
+            { wxT("times"),215 },
+            { wxT("trade"),8482 },
+            { wxT("uArr"),8657 },
+            { wxT("uacute"),250 },
+            { wxT("uarr"),8593 },
+            { wxT("ucirc"),251 },
+            { wxT("ugrave"),249 },
+            { wxT("uml"),168 },
+            { wxT("upsih"),978 },
+            { wxT("upsilon"),965 },
+            { wxT("uuml"),252 },
+            { wxT("weierp"),8472 },
+            { wxT("xi"),958 },
+            { wxT("yacute"),253 },
+            { wxT("yen"),165 },
+            { wxT("yuml"),255 },
+            { wxT("zeta"),950 },
+            { wxT("zwj"),8205 },
+            { wxT("zwnj"),8204 },
+            {NULL, 0}};
+        static size_t substitutions_cnt = 0;
+
+        if (substitutions_cnt == 0)
+            while (substitutions[substitutions_cnt].code != 0)
+                substitutions_cnt++;
+
+        wxHtmlEntityInfo *info;
+        info = (wxHtmlEntityInfo*) bsearch(entity.c_str(), substitutions,
+                                           substitutions_cnt,
+                                           sizeof(wxHtmlEntityInfo),
+                                           wxHtmlEntityCompare);
+        if (info)
+            code = info->code;
+    }
+
+    if (code == 0)
+        return 0;
+    else
+        return GetCharForCode(code);
+}
+
+wxFSFile *wxHtmlParser::OpenURL(wxHtmlURLType WXUNUSED(type), 
+                                const wxString& url) const
+{
+    return GetFS()->OpenFile(url);
+}
+
+
+//-----------------------------------------------------------------------------
+// wxHtmlParser::ExtractCharsetInformation
+//-----------------------------------------------------------------------------
+
+class wxMetaTagParser : public wxHtmlParser
+{
+public:
+    wxObject* GetProduct() { return NULL; }
+protected:
+    virtual void AddText(const wxChar* WXUNUSED(txt)) {}
+};
+
+class wxMetaTagHandler : public wxHtmlTagHandler
+{
+public:
+    wxMetaTagHandler(wxString *retval) : wxHtmlTagHandler(), m_retval(retval) {}
+    wxString GetSupportedTags() { return wxT("META,BODY"); }
+    bool HandleTag(const wxHtmlTag& tag);
+
+private:
+    wxString *m_retval;
+};
+
+bool wxMetaTagHandler::HandleTag(const wxHtmlTag& tag)
+{
+    if (tag.GetName() == _T("BODY"))
+    {
+        m_Parser->StopParsing();
+        return FALSE;
+    }
+
+    if (tag.HasParam(_T("HTTP-EQUIV")) &&
+        tag.GetParam(_T("HTTP-EQUIV")) == _T("Content-Type") &&
+        tag.HasParam(_T("CONTENT")))
+    {
+        wxString content = tag.GetParam(_T("CONTENT"));
+        if (content.Left(19) == _T("text/html; charset="))
+        {
+            *m_retval = content.Mid(19);
+            m_Parser->StopParsing();
+        }
+    }
+    return FALSE;
+}
+
+
+/*static*/
+wxString wxHtmlParser::ExtractCharsetInformation(const wxString& markup)
+{
+    wxString charset;
+    wxMetaTagParser parser;
+    parser.AddTagHandler(new wxMetaTagHandler(&charset));
+    parser.Parse(markup);
+    return charset;
+}
+
+
+#endif

src/html/htmltag.cpp

@@ -0,0 +1,497 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        htmltag.cpp
+// Purpose:     wxHtmlTag class (represents single tag)
+// Author:      Vaclav Slavik
+// RCS-ID:      $Id$
+// Copyright:   (c) 1999 Vaclav Slavik
+// Licence:     wxWindows Licence
+/////////////////////////////////////////////////////////////////////////////
+
+
+#ifdef __GNUG__
+#pragma implementation "htmltag.h"
+#endif
+
+#include "wx/wxprec.h"
+
+#include "wx/defs.h"
+#if wxUSE_HTML
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#ifndef WXPRECOMP
+#endif
+
+#include "wx/html/htmltag.h"
+#include "wx/html/htmlpars.h"
+#include "wx/colour.h"
+#include <stdio.h> // for vsscanf
+#include <stdarg.h>
+
+
+//-----------------------------------------------------------------------------
+// wxHtmlTagsCache
+//-----------------------------------------------------------------------------
+
+struct wxHtmlCacheItem
+{
+    // this is "pos" value passed to wxHtmlTag's constructor.
+    // it is position of '<' character of the tag
+    int Key;
+
+    // end positions for the tag:
+    // end1 is '<' of ending tag,
+    // end2 is '>' or both are
+    // -1 if there is no ending tag for this one...
+    // or -2 if this is ending tag  </...>
+    int End1, End2;
+
+    // name of this tag
+    wxChar *Name;
+};
+
+
+IMPLEMENT_CLASS(wxHtmlTagsCache,wxObject)
+
+#define CACHE_INCREMENT  64
+
+bool wxIsCDATAElement(const wxChar *tag)
+{
+    return (wxStrcmp(tag, _T("SCRIPT")) == 0) ||
+           (wxStrcmp(tag, _T("STYLE")) == 0);
+}
+
+wxHtmlTagsCache::wxHtmlTagsCache(const wxString& source)
+{
+    const wxChar *src = source.c_str();
+    int tg, stpos;
+    int lng = source.Length();
+    wxChar tagBuffer[256];
+
+    m_Cache = NULL;
+    m_CacheSize = 0;
+    m_CachePos = 0;
+
+    int pos = 0;
+    while (pos < lng)
+    {
+        if (src[pos] == wxT('<'))   // tag found:
+        {
+            if (m_CacheSize % CACHE_INCREMENT == 0)
+                m_Cache = (wxHtmlCacheItem*) realloc(m_Cache, (m_CacheSize + CACHE_INCREMENT) * sizeof(wxHtmlCacheItem));
+            tg = m_CacheSize++;
+            m_Cache[tg].Key = stpos = pos++;
+
+            int i;
+            for ( i = 0;
+                  pos < lng && i < (int)WXSIZEOF(tagBuffer) - 1 &&
+                  src[pos] != wxT('>') && !wxIsspace(src[pos]);
+                  i++, pos++ )
+            {
+                tagBuffer[i] = wxToupper(src[pos]);
+            }
+            tagBuffer[i] = _T('\0');
+
+            m_Cache[tg].Name = new wxChar[i+1];
+            memcpy(m_Cache[tg].Name, tagBuffer, (i+1)*sizeof(wxChar));
+
+            while (pos < lng && src[pos] != wxT('>')) pos++;
+
+            if (src[stpos+1] == wxT('/')) // ending tag:
+            {
+                m_Cache[tg].End1 = m_Cache[tg].End2 = -2;
+                // find matching begin tag:
+                for (i = tg; i >= 0; i--)
+                    if ((m_Cache[i].End1 == -1) && (wxStrcmp(m_Cache[i].Name, tagBuffer+1) == 0))
+                    {
+                        m_Cache[i].End1 = stpos;
+                        m_Cache[i].End2 = pos + 1;
+                        break;
+                    }
+            }
+            else
+            {
+                m_Cache[tg].End1 = m_Cache[tg].End2 = -1;
+
+                if (wxIsCDATAElement(tagBuffer))
+                {
+                    // find next matching tag
+                    int tag_len = wxStrlen(tagBuffer);
+                    while (pos < lng)
+                    {
+                        // find the ending tag
+                        while (pos + 1 < lng &&
+                               (src[pos] != '<' || src[pos+1] != '/'))
+                            ++pos;
+                        if (src[pos] == '<')
+                            ++pos;
+                        
+                        // see if it matches
+                        int match_pos = 0;
+                        while (pos < lng && match_pos < tag_len && src[pos] != '>' && src[pos] != '<') {
+                            if (wxToupper(src[pos]) == tagBuffer[match_pos]) {
+                                ++match_pos;
+                            }  
+                            else if (src[pos] == wxT(' ') || src[pos] == wxT('\n') ||
+                                src[pos] == wxT('\r') || src[pos] == wxT('\t')) {
+                                // need to skip over these
+                            }
+                            else {
+                                match_pos = 0;
+                            }
+                            ++pos;
+                        }
+
+                        // found a match
+                        if (match_pos == tag_len) {
+                            pos = pos - tag_len - 3;
+                            stpos = pos;
+                            break;
+                        }
+                        else {
+                            ++pos;
+                        }
+                    }
+                }
+            }
+        }
+
+        pos++;
+    }
+
+    // ok, we're done, now we'll free .Name members of cache - we don't need it anymore:
+    for (int i = 0; i < m_CacheSize; i++)
+    {
+        delete[] m_Cache[i].Name;
+        m_Cache[i].Name = NULL;
+    }
+}
+
+void wxHtmlTagsCache::QueryTag(int at, int* end1, int* end2)
+{
+    if (m_Cache == NULL) return;
+    if (m_Cache[m_CachePos].Key != at)
+    {
+        int delta = (at < m_Cache[m_CachePos].Key) ? -1 : 1;
+        do
+        {
+            m_CachePos += delta;
+        }
+        while (m_Cache[m_CachePos].Key != at);
+    }
+    *end1 = m_Cache[m_CachePos].End1;
+    *end2 = m_Cache[m_CachePos].End2;
+}
+
+
+
+
+//-----------------------------------------------------------------------------
+// wxHtmlTag
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_CLASS(wxHtmlTag,wxObject)
+
+wxHtmlTag::wxHtmlTag(wxHtmlTag *parent,
+                     const wxString& source, int pos, int end_pos,
+                     wxHtmlTagsCache *cache,
+                     wxHtmlEntitiesParser *entParser) : wxObject()
+{
+    /* Setup DOM relations */
+
+    m_Next = NULL;
+    m_FirstChild = m_LastChild = NULL;
+    m_Parent = parent;
+    if (parent)
+    {
+        m_Prev = m_Parent->m_LastChild;
+        if (m_Prev == NULL)
+            m_Parent->m_FirstChild = this;
+        else
+            m_Prev->m_Next = this;
+        m_Parent->m_LastChild = this;
+    }
+    else
+        m_Prev = NULL;
+
+    /* Find parameters and their values: */
+
+    int i;
+    wxChar c;
+
+    // fill-in name, params and begin pos:
+    i = pos+1;
+
+    // find tag's name and convert it to uppercase:
+    while ((i < end_pos) &&
+           ((c = source[i++]) != wxT(' ') && c != wxT('\r') &&
+             c != wxT('\n') && c != wxT('\t') &&
+             c != wxT('>')))
+    {
+        if ((c >= wxT('a')) && (c <= wxT('z')))
+            c -= (wxT('a') - wxT('A'));
+        m_Name << c;
+    }
+
+    // if the tag has parameters, read them and "normalize" them,
+    // i.e. convert to uppercase, replace whitespaces by spaces and
+    // remove whitespaces around '=':
+    if (source[i-1] != wxT('>'))
+    {
+        #define IS_WHITE(c) (c == wxT(' ') || c == wxT('\r') || \
+                             c == wxT('\n') || c == wxT('\t'))
+        wxString pname, pvalue;
+        wxChar quote;
+        enum
+        {
+            ST_BEFORE_NAME = 1,
+            ST_NAME,
+            ST_BEFORE_EQ,
+            ST_BEFORE_VALUE,
+            ST_VALUE
+        } state;
+
+        quote = 0;
+        state = ST_BEFORE_NAME;
+        while (i < end_pos)
+        {
+            c = source[i++];
+
+            if (c == wxT('>') && !(state == ST_VALUE && quote != 0))
+            {
+                if (state == ST_BEFORE_EQ || state == ST_NAME)
+                {
+                    m_ParamNames.Add(pname);
+                    m_ParamValues.Add(wxEmptyString);
+                }
+                else if (state == ST_VALUE && quote == 0)
+                {
+                    m_ParamNames.Add(pname);
+                    if (entParser)
+                        m_ParamValues.Add(entParser->Parse(pvalue));
+                    else
+                        m_ParamValues.Add(pvalue);
+                }
+                break;
+            }
+            switch (state)
+            {
+                case ST_BEFORE_NAME:
+                    if (!IS_WHITE(c))
+                    {
+                        pname = c;
+                        state = ST_NAME;
+                    }
+                    break;
+                case ST_NAME:
+                    if (IS_WHITE(c))
+                        state = ST_BEFORE_EQ;
+                    else if (c == wxT('='))
+                        state = ST_BEFORE_VALUE;
+                    else
+                        pname << c;
+                    break;
+                case ST_BEFORE_EQ:
+                    if (c == wxT('='))
+                        state = ST_BEFORE_VALUE;
+                    else if (!IS_WHITE(c))
+                    {
+                        m_ParamNames.Add(pname);
+                        m_ParamValues.Add(wxEmptyString);
+                        pname = c;
+                        state = ST_NAME;
+                    }
+                    break;
+                case ST_BEFORE_VALUE:
+                    if (!IS_WHITE(c))
+                    {
+                        if (c == wxT('"') || c == wxT('\''))
+                            quote = c, pvalue = wxEmptyString;
+                        else
+                            quote = 0, pvalue = c;
+                        state = ST_VALUE;
+                    }
+                    break;
+                case ST_VALUE:
+                    if ((quote != 0 && c == quote) ||
+                        (quote == 0 && IS_WHITE(c)))
+                    {
+                        m_ParamNames.Add(pname);
+                        if (quote == 0)
+                        {
+                            // VS: backward compatibility, no real reason,
+                            //     but wxHTML code relies on this... :(
+                            pvalue.MakeUpper();
+                        }
+                        if (entParser)
+                            m_ParamValues.Add(entParser->Parse(pvalue));
+                        else
+                            m_ParamValues.Add(pvalue);
+                        state = ST_BEFORE_NAME;
+                    }
+                    else
+                        pvalue << c;
+                    break;
+            }
+        }
+
+        #undef IS_WHITE
+   }
+   m_Begin = i;
+
+   cache->QueryTag(pos, &m_End1, &m_End2);
+   if (m_End1 > end_pos) m_End1 = end_pos;
+   if (m_End2 > end_pos) m_End2 = end_pos;
+}
+
+wxHtmlTag::~wxHtmlTag()
+{
+    wxHtmlTag *t1, *t2;
+    t1 = m_FirstChild;
+    while (t1)
+    {
+        t2 = t1->GetNextSibling();
+        delete t1;
+        t1 = t2;
+    }
+}
+
+bool wxHtmlTag::HasParam(const wxString& par) const
+{
+    return (m_ParamNames.Index(par, FALSE) != wxNOT_FOUND);
+}
+
+wxString wxHtmlTag::GetParam(const wxString& par, bool with_commas) const
+{
+    int index = m_ParamNames.Index(par, FALSE);
+    if (index == wxNOT_FOUND)
+        return wxEmptyString;
+    if (with_commas)
+    {
+        // VS: backward compatibility, seems to be never used by wxHTML...
+        wxString s;
+        s << wxT('"') << m_ParamValues[index] << wxT('"');
+        return s;
+    }
+    else
+        return m_ParamValues[index];
+}
+
+int wxHtmlTag::ScanParam(const wxString& par,
+                         const wxChar *format,
+                         void *param) const
+{
+    wxString parval = GetParam(par);
+    return wxSscanf(parval, format, param);
+}
+
+bool wxHtmlTag::GetParamAsColour(const wxString& par, wxColour *clr) const
+{
+    wxString str = GetParam(par);
+
+    if (str.IsEmpty()) return FALSE;
+    if (str.GetChar(0) == wxT('#'))
+    {
+        unsigned long tmp;
+        if (ScanParam(par, wxT("#%lX"), &tmp) != 1)
+            return FALSE;
+        *clr = wxColour((unsigned char)((tmp & 0xFF0000) >> 16),
+					    (unsigned char)((tmp & 0x00FF00) >> 8),
+					    (unsigned char)(tmp & 0x0000FF));
+        return TRUE;
+    }
+    else
+    {
+        // Handle colours defined in HTML 4.0:
+        #define HTML_COLOUR(name,r,g,b)                 \
+            if (str.IsSameAs(wxT(name), FALSE))         \
+                { *clr = wxColour(r,g,b); return TRUE; }
+        HTML_COLOUR("black",   0x00,0x00,0x00)
+        HTML_COLOUR("silver",  0xC0,0xC0,0xC0)
+        HTML_COLOUR("gray",    0x80,0x80,0x80)
+        HTML_COLOUR("white",   0xFF,0xFF,0xFF)
+        HTML_COLOUR("maroon",  0x80,0x00,0x00)
+        HTML_COLOUR("red",     0xFF,0x00,0x00)
+        HTML_COLOUR("purple",  0x80,0x00,0x80)
+        HTML_COLOUR("fuchsia", 0xFF,0x00,0xFF)
+        HTML_COLOUR("green",   0x00,0x80,0x00)
+        HTML_COLOUR("lime",    0x00,0xFF,0x00)
+        HTML_COLOUR("olive",   0x80,0x80,0x00)
+        HTML_COLOUR("yellow",  0xFF,0xFF,0x00)
+        HTML_COLOUR("navy",    0x00,0x00,0x80)
+        HTML_COLOUR("blue",    0x00,0x00,0xFF)
+        HTML_COLOUR("teal",    0x00,0x80,0x80)
+        HTML_COLOUR("aqua",    0x00,0xFF,0xFF)
+        #undef HTML_COLOUR
+    }
+
+    return FALSE;
+}
+
+bool wxHtmlTag::GetParamAsInt(const wxString& par, int *clr) const
+{
+    if (!HasParam(par)) return FALSE;
+    long i;
+    bool succ = GetParam(par).ToLong(&i);
+    *clr = (int)i;
+    return succ;
+}
+
+wxString wxHtmlTag::GetAllParams() const
+{
+    // VS: this function is for backward compatiblity only,
+    //     never used by wxHTML
+    wxString s;
+    size_t cnt = m_ParamNames.GetCount();
+    for (size_t i = 0; i < cnt; i++)
+    {
+        s << m_ParamNames[i];
+        s << wxT('=');
+        if (m_ParamValues[i].Find(wxT('"')) != wxNOT_FOUND)
+            s << wxT('\'') << m_ParamValues[i] << wxT('\'');
+        else
+            s << wxT('"') << m_ParamValues[i] << wxT('"');
+    }
+    return s;
+}
+
+wxHtmlTag *wxHtmlTag::GetFirstSibling() const
+{
+    if (m_Parent)
+        return m_Parent->m_FirstChild;
+    else
+    {
+        wxHtmlTag *cur = (wxHtmlTag*)this;
+        while (cur->m_Prev)
+            cur = cur->m_Prev;
+        return cur;
+    }
+}
+
+wxHtmlTag *wxHtmlTag::GetLastSibling() const
+{
+    if (m_Parent)
+        return m_Parent->m_LastChild;
+    else
+    {
+        wxHtmlTag *cur = (wxHtmlTag*)this;
+        while (cur->m_Next)
+            cur = cur->m_Next;
+        return cur;
+    }
+}
+
+wxHtmlTag *wxHtmlTag::GetNextTag() const
+{
+    if (m_FirstChild) return m_FirstChild;
+    if (m_Next) return m_Next;
+    wxHtmlTag *cur = m_Parent;
+    if (!cur) return NULL;
+    while (cur->m_Parent && !cur->m_Next)
+        cur = cur->m_Parent;
+    return cur->m_Next;
+}
+
+#endif

src/html/htmlwin.cpp

@@ -0,0 +1,798 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        htmlwin.cpp
+// Purpose:     wxHtmlWindow class for parsing & displaying HTML (implementation)
+// Author:      Vaclav Slavik
+// RCS-ID:      $Id$
+// Copyright:   (c) 1999 Vaclav Slavik
+// Licence:     wxWindows Licence
+/////////////////////////////////////////////////////////////////////////////
+
+
+#ifdef __GNUG__
+#pragma implementation "htmlwin.h"
+#pragma implementation "htmlproc.h"
+#endif
+
+#include "wx/wxprec.h"
+
+#include "wx/defs.h"
+#if wxUSE_HTML && wxUSE_STREAMS
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#ifndef WXPRECOMP
+    #include "wx/log.h"
+    #include "wx/intl.h"
+    #include "wx/dcclient.h"
+    #include "wx/frame.h"
+#endif
+
+#include "wx/html/htmlwin.h"
+#include "wx/html/htmlproc.h"
+#include "wx/list.h"
+
+#include "wx/arrimpl.cpp"
+#include "wx/listimpl.cpp"
+
+//-----------------------------------------------------------------------------
+// wxHtmlHistoryItem
+//-----------------------------------------------------------------------------
+
+// item of history list
+class WXDLLEXPORT wxHtmlHistoryItem
+{
+public:
+    wxHtmlHistoryItem(const wxString& p, const wxString& a) {m_Page = p, m_Anchor = a, m_Pos = 0;}
+    int GetPos() const {return m_Pos;}
+    void SetPos(int p) {m_Pos = p;}
+    const wxString& GetPage() const {return m_Page;}
+    const wxString& GetAnchor() const {return m_Anchor;}
+
+private:
+    wxString m_Page;
+    wxString m_Anchor;
+    int m_Pos;
+};
+
+
+//-----------------------------------------------------------------------------
+// our private arrays:
+//-----------------------------------------------------------------------------
+
+WX_DECLARE_OBJARRAY(wxHtmlHistoryItem, wxHtmlHistoryArray);
+WX_DEFINE_OBJARRAY(wxHtmlHistoryArray);
+
+WX_DECLARE_LIST(wxHtmlProcessor, wxHtmlProcessorList);
+WX_DEFINE_LIST(wxHtmlProcessorList);
+
+//-----------------------------------------------------------------------------
+// wxHtmlWindow
+//-----------------------------------------------------------------------------
+
+
+void wxHtmlWindow::Init()
+{
+    m_tmpMouseMoved = FALSE;
+    m_tmpLastLink = NULL;
+    m_tmpLastCell = NULL;
+    m_tmpCanDrawLocks = 0;
+    m_FS = new wxFileSystem();
+    m_RelatedStatusBar = -1;
+    m_RelatedFrame = NULL;
+    m_TitleFormat = wxT("%s");
+    m_OpenedPage = m_OpenedAnchor = m_OpenedPageTitle = wxEmptyString;
+    m_Cell = NULL;
+    m_Parser = new wxHtmlWinParser(this);
+    m_Parser->SetFS(m_FS);
+    m_HistoryPos = -1;
+    m_HistoryOn = TRUE;
+    m_History = new wxHtmlHistoryArray;
+    m_Processors = NULL;
+    m_Style = 0;
+    SetBorders(10);
+}
+
+bool wxHtmlWindow::Create(wxWindow *parent, wxWindowID id,
+                          const wxPoint& pos, const wxSize& size,
+                          long style, const wxString& name)
+{
+    if (!wxScrolledWindow::Create(parent, id, pos, size,
+                                  style | wxVSCROLL | wxHSCROLL, name))
+        return FALSE;
+
+    m_Style = style;
+    SetPage(wxT("<html><body></body></html>"));
+    return TRUE;
+}
+
+
+wxHtmlWindow::~wxHtmlWindow()
+{
+    HistoryClear();
+
+    if (m_Cell) delete m_Cell;
+
+    delete m_Parser;
+    delete m_FS;
+    delete m_History;
+    delete m_Processors;
+}
+
+
+
+void wxHtmlWindow::SetRelatedFrame(wxFrame* frame, const wxString& format)
+{
+    m_RelatedFrame = frame;
+    m_TitleFormat = format;
+}
+
+
+
+void wxHtmlWindow::SetRelatedStatusBar(int bar)
+{
+    m_RelatedStatusBar = bar;
+}
+
+
+
+void wxHtmlWindow::SetFonts(wxString normal_face, wxString fixed_face, const int *sizes)
+{
+    wxString op = m_OpenedPage;
+
+    m_Parser->SetFonts(normal_face, fixed_face, sizes);
+    // fonts changed => contents invalid, so reload the page:
+    SetPage(wxT("<html><body></body></html>"));
+    if (!op.IsEmpty()) LoadPage(op);
+}
+
+
+
+bool wxHtmlWindow::SetPage(const wxString& source)
+{
+    wxString newsrc(source);
+
+    // pass HTML through registered processors:
+    if (m_Processors || m_GlobalProcessors)
+    {
+        wxHtmlProcessorList::Node *nodeL, *nodeG;
+        int prL, prG;
+
+        nodeL = (m_Processors) ? m_Processors->GetFirst() : NULL;
+        nodeG = (m_GlobalProcessors) ? m_GlobalProcessors->GetFirst() : NULL;
+
+        // VS: there are two lists, global and local, both of them sorted by
+        //     priority. Since we have to go through _both_ lists with
+        //     decreasing priority, we "merge-sort" the lists on-line by
+        //     processing that one of the two heads that has higher priority
+        //     in every iteration
+        while (nodeL || nodeG)
+        {
+            prL = (nodeL) ? nodeL->GetData()->GetPriority() : -1;
+            prG = (nodeG) ? nodeG->GetData()->GetPriority() : -1;
+            if (prL > prG)
+            {
+                if (nodeL->GetData()->IsEnabled())
+                    newsrc = nodeL->GetData()->Process(newsrc);
+                nodeL = nodeL->GetNext();
+            }
+            else // prL <= prG
+            {
+                if (nodeG->GetData()->IsEnabled())
+                    newsrc = nodeG->GetData()->Process(newsrc);
+                nodeG = nodeG->GetNext();
+            }
+        }
+    }
+
+    // ...and run the parser on it:
+    wxClientDC *dc = new wxClientDC(this);
+    dc->SetMapMode(wxMM_TEXT);
+    SetBackgroundColour(wxColour(0xFF, 0xFF, 0xFF));
+    m_OpenedPage = m_OpenedAnchor = m_OpenedPageTitle = wxEmptyString;
+    m_Parser->SetDC(dc);
+    if (m_Cell)
+    {
+        delete m_Cell;
+        m_Cell = NULL;
+    }
+    m_Cell = (wxHtmlContainerCell*) m_Parser->Parse(newsrc);
+    delete dc;
+    m_Cell->SetIndent(m_Borders, wxHTML_INDENT_ALL, wxHTML_UNITS_PIXELS);
+    m_Cell->SetAlignHor(wxHTML_ALIGN_CENTER);
+    CreateLayout();
+    if (m_tmpCanDrawLocks == 0)
+        Refresh();
+    return TRUE;
+}
+
+bool wxHtmlWindow::AppendToPage(const wxString& source)
+{
+    return SetPage(*(GetParser()->GetSource()) + source);
+}
+
+bool wxHtmlWindow::LoadPage(const wxString& location)
+{
+    wxBusyCursor busyCursor;
+
+    wxFSFile *f;
+    bool rt_val;
+    bool needs_refresh = FALSE;
+
+    m_tmpCanDrawLocks++;
+    if (m_HistoryOn && (m_HistoryPos != -1))
+    {
+        // store scroll position into history item:
+        int x, y;
+        GetViewStart(&x, &y);
+        (*m_History)[m_HistoryPos].SetPos(y);
+    }
+
+    if (location[0] == wxT('#'))
+    {
+        // local anchor:
+        wxString anch = location.Mid(1) /*1 to end*/;
+        m_tmpCanDrawLocks--;
+        rt_val = ScrollToAnchor(anch);
+        m_tmpCanDrawLocks++;
+    }
+    else if (location.Find(wxT('#')) != wxNOT_FOUND && location.BeforeFirst(wxT('#')) == m_OpenedPage)
+    {
+        wxString anch = location.AfterFirst(wxT('#'));
+        m_tmpCanDrawLocks--;
+        rt_val = ScrollToAnchor(anch);
+        m_tmpCanDrawLocks++;
+    }
+    else if (location.Find(wxT('#')) != wxNOT_FOUND &&
+             (m_FS->GetPath() + location.BeforeFirst(wxT('#'))) == m_OpenedPage)
+    {
+        wxString anch = location.AfterFirst(wxT('#'));
+        m_tmpCanDrawLocks--;
+        rt_val = ScrollToAnchor(anch);
+        m_tmpCanDrawLocks++;
+    }
+
+    else
+    {
+        needs_refresh = TRUE;
+        // load&display it:
+        if (m_RelatedStatusBar != -1)
+        {
+            m_RelatedFrame->SetStatusText(_("Connecting..."), m_RelatedStatusBar);
+            Refresh(FALSE);
+        }
+
+        f = m_Parser->OpenURL(wxHTML_URL_PAGE, location);
+
+        // try to interpret 'location' as filename instead of URL:
+        if (f == NULL)
+        {
+            wxFileName fn(location);
+            wxString location2 = wxFileSystem::FileNameToURL(fn);
+            f = m_Parser->OpenURL(wxHTML_URL_PAGE, location2);
+        }
+
+        if (f == NULL)
+        {
+            wxLogError(_("Unable to open requested HTML document: %s"), location.c_str());
+            m_tmpCanDrawLocks--;
+            return FALSE;
+        }
+
+        else
+        {
+            wxNode *node;
+            wxString src = wxEmptyString;
+
+            if (m_RelatedStatusBar != -1)
+            {
+                wxString msg = _("Loading : ") + location;
+                m_RelatedFrame->SetStatusText(msg, m_RelatedStatusBar);
+                Refresh(FALSE);
+            }
+
+            node = m_Filters.GetFirst();
+            while (node)
+            {
+                wxHtmlFilter *h = (wxHtmlFilter*) node->GetData();
+                if (h->CanRead(*f))
+                {
+                    src = h->ReadFile(*f);
+                    break;
+                }
+                node = node->GetNext();
+            }
+            if (src == wxEmptyString)
+            {
+                if (m_DefaultFilter == NULL) m_DefaultFilter = GetDefaultFilter();
+                src = m_DefaultFilter->ReadFile(*f);
+            }
+
+            m_FS->ChangePathTo(f->GetLocation());
+            rt_val = SetPage(src);
+            m_OpenedPage = f->GetLocation();
+            if (f->GetAnchor() != wxEmptyString)
+            {
+                ScrollToAnchor(f->GetAnchor());
+            }
+
+            delete f;
+
+            if (m_RelatedStatusBar != -1) m_RelatedFrame->SetStatusText(_("Done"), m_RelatedStatusBar);
+        }
+    }
+
+    if (m_HistoryOn) // add this page to history there:
+    {
+        int c = m_History->GetCount() - (m_HistoryPos + 1);
+
+        if (m_HistoryPos < 0 ||
+            (*m_History)[m_HistoryPos].GetPage() != m_OpenedPage ||
+            (*m_History)[m_HistoryPos].GetAnchor() != m_OpenedAnchor)
+        {
+            m_HistoryPos++;
+            for (int i = 0; i < c; i++)
+                m_History->RemoveAt(m_HistoryPos);
+            m_History->Add(new wxHtmlHistoryItem(m_OpenedPage, m_OpenedAnchor));
+        }
+    }
+
+    if (m_OpenedPageTitle == wxEmptyString)
+        OnSetTitle(wxFileNameFromPath(m_OpenedPage));
+
+    if (needs_refresh)
+    {
+        m_tmpCanDrawLocks--;
+        Refresh();
+    }
+    else
+        m_tmpCanDrawLocks--;
+
+    return rt_val;
+}
+
+
+bool wxHtmlWindow::LoadFile(const wxFileName& filename)
+{
+    wxString url = wxFileSystem::FileNameToURL(filename);
+    return LoadPage(url);
+}
+
+
+bool wxHtmlWindow::ScrollToAnchor(const wxString& anchor)
+{
+    const wxHtmlCell *c = m_Cell->Find(wxHTML_COND_ISANCHOR, &anchor);
+    if (!c)
+    {
+        wxLogWarning(_("HTML anchor %s does not exist."), anchor.c_str());
+        return FALSE;
+    }
+    else
+    {
+        int y;
+
+        for (y = 0; c != NULL; c = c->GetParent()) y += c->GetPosY();
+        Scroll(-1, y / wxHTML_SCROLL_STEP);
+        m_OpenedAnchor = anchor;
+        return TRUE;
+    }
+}
+
+
+void wxHtmlWindow::OnSetTitle(const wxString& title)
+{
+    if (m_RelatedFrame)
+    {
+        wxString tit;
+        tit.Printf(m_TitleFormat, title.c_str());
+        m_RelatedFrame->SetTitle(tit);
+    }
+    m_OpenedPageTitle = title;
+}
+
+
+
+
+
+void wxHtmlWindow::CreateLayout()
+{
+    int ClientWidth, ClientHeight;
+
+    if (!m_Cell) return;
+
+    if (m_Style & wxHW_SCROLLBAR_NEVER)
+    {
+        SetScrollbars(wxHTML_SCROLL_STEP, 1, m_Cell->GetWidth() / wxHTML_SCROLL_STEP, 0); // always off
+        GetClientSize(&ClientWidth, &ClientHeight);
+        m_Cell->Layout(ClientWidth);
+    }
+
+    else {
+        GetClientSize(&ClientWidth, &ClientHeight);
+        m_Cell->Layout(ClientWidth);
+        if (ClientHeight < m_Cell->GetHeight() + GetCharHeight())
+        {
+            SetScrollbars(
+                  wxHTML_SCROLL_STEP, wxHTML_SCROLL_STEP,
+                  m_Cell->GetWidth() / wxHTML_SCROLL_STEP,
+                  (m_Cell->GetHeight() + GetCharHeight()) / wxHTML_SCROLL_STEP
+                  /*cheat: top-level frag is always container*/);
+        }
+        else /* we fit into window, no need for scrollbars */
+        {
+            SetScrollbars(wxHTML_SCROLL_STEP, 1, m_Cell->GetWidth() / wxHTML_SCROLL_STEP, 0); // disable...
+            GetClientSize(&ClientWidth, &ClientHeight);
+            m_Cell->Layout(ClientWidth); // ...and relayout
+        }
+    }
+}
+
+
+
+void wxHtmlWindow::ReadCustomization(wxConfigBase *cfg, wxString path)
+{
+    wxString oldpath;
+    wxString tmp;
+    int p_fontsizes[7];
+    wxString p_fff, p_ffn;
+
+    if (path != wxEmptyString)
+    {
+        oldpath = cfg->GetPath();
+        cfg->SetPath(path);
+    }
+
+    m_Borders = cfg->Read(wxT("wxHtmlWindow/Borders"), m_Borders);
+    p_fff = cfg->Read(wxT("wxHtmlWindow/FontFaceFixed"), m_Parser->m_FontFaceFixed);
+    p_ffn = cfg->Read(wxT("wxHtmlWindow/FontFaceNormal"), m_Parser->m_FontFaceNormal);
+    for (int i = 0; i < 7; i++)
+    {
+        tmp.Printf(wxT("wxHtmlWindow/FontsSize%i"), i);
+        p_fontsizes[i] = cfg->Read(tmp, m_Parser->m_FontsSizes[i]);
+    }
+    SetFonts(p_ffn, p_fff, p_fontsizes);
+
+    if (path != wxEmptyString)
+        cfg->SetPath(oldpath);
+}
+
+
+
+void wxHtmlWindow::WriteCustomization(wxConfigBase *cfg, wxString path)
+{
+    wxString oldpath;
+    wxString tmp;
+
+    if (path != wxEmptyString)
+    {
+        oldpath = cfg->GetPath();
+        cfg->SetPath(path);
+    }
+
+    cfg->Write(wxT("wxHtmlWindow/Borders"), (long) m_Borders);
+    cfg->Write(wxT("wxHtmlWindow/FontFaceFixed"), m_Parser->m_FontFaceFixed);
+    cfg->Write(wxT("wxHtmlWindow/FontFaceNormal"), m_Parser->m_FontFaceNormal);
+    for (int i = 0; i < 7; i++)
+    {
+        tmp.Printf(wxT("wxHtmlWindow/FontsSize%i"), i);
+        cfg->Write(tmp, (long) m_Parser->m_FontsSizes[i]);
+    }
+
+    if (path != wxEmptyString)
+        cfg->SetPath(oldpath);
+}
+
+
+
+bool wxHtmlWindow::HistoryBack()
+{
+    wxString a, l;
+
+    if (m_HistoryPos < 1) return FALSE;
+
+    // store scroll position into history item:
+    int x, y;
+    GetViewStart(&x, &y);
+    (*m_History)[m_HistoryPos].SetPos(y);
+
+    // go to previous position:
+    m_HistoryPos--;
+
+    l = (*m_History)[m_HistoryPos].GetPage();
+    a = (*m_History)[m_HistoryPos].GetAnchor();
+    m_HistoryOn = FALSE;
+    m_tmpCanDrawLocks++;
+    if (a == wxEmptyString) LoadPage(l);
+    else LoadPage(l + wxT("#") + a);
+    m_HistoryOn = TRUE;
+    m_tmpCanDrawLocks--;
+    Scroll(0, (*m_History)[m_HistoryPos].GetPos());
+    Refresh();
+    return TRUE;
+}
+
+bool wxHtmlWindow::HistoryCanBack()
+{
+    if (m_HistoryPos < 1) return FALSE;
+    return TRUE ;
+}
+
+
+bool wxHtmlWindow::HistoryForward()
+{
+    wxString a, l;
+
+    if (m_HistoryPos == -1) return FALSE;
+    if (m_HistoryPos >= (int)m_History->GetCount() - 1)return FALSE;
+
+    m_OpenedPage = wxEmptyString; // this will disable adding new entry into history in LoadPage()
+
+    m_HistoryPos++;
+    l = (*m_History)[m_HistoryPos].GetPage();
+    a = (*m_History)[m_HistoryPos].GetAnchor();
+    m_HistoryOn = FALSE;
+    m_tmpCanDrawLocks++;
+    if (a == wxEmptyString) LoadPage(l);
+    else LoadPage(l + wxT("#") + a);
+    m_HistoryOn = TRUE;
+    m_tmpCanDrawLocks--;
+    Scroll(0, (*m_History)[m_HistoryPos].GetPos());
+    Refresh();
+    return TRUE;
+}
+
+bool wxHtmlWindow::HistoryCanForward()
+{
+    if (m_HistoryPos == -1) return FALSE;
+    if (m_HistoryPos >= (int)m_History->GetCount() - 1)return FALSE;
+    return TRUE ;
+}
+
+
+void wxHtmlWindow::HistoryClear()
+{
+    m_History->Empty();
+    m_HistoryPos = -1;
+}
+
+void wxHtmlWindow::AddProcessor(wxHtmlProcessor *processor)
+{
+    if (!m_Processors)
+    {
+        m_Processors = new wxHtmlProcessorList;
+        m_Processors->DeleteContents(TRUE);
+    }
+    wxHtmlProcessorList::Node *node;
+
+    for (node = m_Processors->GetFirst(); node; node = node->GetNext())
+    {
+        if (processor->GetPriority() > node->GetData()->GetPriority())
+        {
+            m_Processors->Insert(node, processor);
+            return;
+        }
+    }
+    m_Processors->Append(processor);
+}
+
+/*static */ void wxHtmlWindow::AddGlobalProcessor(wxHtmlProcessor *processor)
+{
+    if (!m_GlobalProcessors)
+    {
+        m_GlobalProcessors = new wxHtmlProcessorList;
+        m_GlobalProcessors->DeleteContents(TRUE);
+    }
+    wxHtmlProcessorList::Node *node;
+
+    for (node = m_GlobalProcessors->GetFirst(); node; node = node->GetNext())
+    {
+        if (processor->GetPriority() > node->GetData()->GetPriority())
+        {
+            m_GlobalProcessors->Insert(node, processor);
+            return;
+        }
+    }
+    m_GlobalProcessors->Append(processor);
+}
+
+
+
+wxList wxHtmlWindow::m_Filters;
+wxHtmlFilter *wxHtmlWindow::m_DefaultFilter = NULL;
+wxCursor *wxHtmlWindow::s_cur_hand = NULL;
+wxCursor *wxHtmlWindow::s_cur_arrow = NULL;
+wxHtmlProcessorList *wxHtmlWindow::m_GlobalProcessors = NULL;
+
+void wxHtmlWindow::CleanUpStatics()
+{
+    wxDELETE(m_DefaultFilter);
+    m_Filters.DeleteContents(TRUE);
+    m_Filters.Clear();
+    wxDELETE(m_GlobalProcessors);
+    wxDELETE(s_cur_hand);
+    wxDELETE(s_cur_arrow);
+}
+
+
+
+void wxHtmlWindow::AddFilter(wxHtmlFilter *filter)
+{
+    m_Filters.Append(filter);
+}
+
+
+
+
+void wxHtmlWindow::OnLinkClicked(const wxHtmlLinkInfo& link)
+{
+    LoadPage(link.GetHref());
+}
+
+void wxHtmlWindow::OnCellClicked(wxHtmlCell *cell,
+                                 wxCoord x, wxCoord y,
+                                 const wxMouseEvent& event)
+{
+    wxCHECK_RET( cell, _T("can't be called with NULL cell") );
+
+    cell->OnMouseClick(this, x, y, event);
+}
+
+void wxHtmlWindow::OnCellMouseHover(wxHtmlCell * WXUNUSED(cell),
+                                    wxCoord WXUNUSED(x), wxCoord WXUNUSED(y))
+{
+    // do nothing here
+}
+
+void wxHtmlWindow::OnDraw(wxDC& dc)
+{
+    if (m_tmpCanDrawLocks > 0 || m_Cell == NULL) return;
+
+    int x, y;
+    wxRect rect = GetUpdateRegion().GetBox();
+
+    dc.SetMapMode(wxMM_TEXT);
+    dc.SetBackgroundMode(wxTRANSPARENT);
+    GetViewStart(&x, &y);
+
+    m_Cell->Draw(dc, 0, 0,
+                 y * wxHTML_SCROLL_STEP + rect.GetTop(),
+                 y * wxHTML_SCROLL_STEP + rect.GetBottom());
+}
+
+
+
+
+void wxHtmlWindow::OnSize(wxSizeEvent& event)
+{
+    wxScrolledWindow::OnSize(event);
+    CreateLayout();
+    Refresh();
+}
+
+
+void wxHtmlWindow::OnMouseEvent(wxMouseEvent& event)
+{
+    m_tmpMouseMoved = TRUE;
+
+    if (event.ButtonDown())
+    {
+        SetFocus();
+        if ( m_Cell )
+        {
+            int sx, sy;
+            GetViewStart(&sx, &sy);
+            sx *= wxHTML_SCROLL_STEP;
+            sy *= wxHTML_SCROLL_STEP;
+
+            wxPoint pos = event.GetPosition();
+            pos.x += sx;
+            pos.y += sy;
+
+            wxHtmlCell *cell = m_Cell->FindCellByPos(pos.x, pos.y);
+
+            // VZ: is it possible that we don't find anything at all?
+            // VS: yes. FindCellByPos returns terminal cell and
+            //     containers may have empty borders
+            if ( cell )
+                OnCellClicked(cell, pos.x, pos.y, event);
+        }
+    }
+}
+
+
+
+void wxHtmlWindow::OnIdle(wxIdleEvent& WXUNUSED(event))
+{
+    if (s_cur_hand == NULL)
+    {
+        s_cur_hand = new wxCursor(wxCURSOR_HAND);
+        s_cur_arrow = new wxCursor(wxCURSOR_ARROW);
+    }
+
+    if (m_tmpMouseMoved && (m_Cell != NULL))
+    {
+        int sx, sy;
+        GetViewStart(&sx, &sy);
+        sx *= wxHTML_SCROLL_STEP;
+        sy *= wxHTML_SCROLL_STEP;
+
+        int x, y;
+        wxGetMousePosition(&x, &y);
+        ScreenToClient(&x, &y);
+        x += sx;
+        y += sy;
+
+        wxHtmlCell *cell = m_Cell->FindCellByPos(x, y);
+        if ( cell != m_tmpLastCell )
+        {
+            wxHtmlLinkInfo *lnk = cell ? cell->GetLink(x, y) : NULL;
+
+            if (lnk != m_tmpLastLink)
+            {
+                if (lnk == NULL)
+                {
+                    SetCursor(*s_cur_arrow);
+                    if (m_RelatedStatusBar != -1)
+                        m_RelatedFrame->SetStatusText(wxEmptyString, m_RelatedStatusBar);
+                }
+                else
+                {
+                    SetCursor(*s_cur_hand);
+                    if (m_RelatedStatusBar != -1)
+                        m_RelatedFrame->SetStatusText(lnk->GetHref(), m_RelatedStatusBar);
+                }
+                m_tmpLastLink = lnk;
+            }
+
+            m_tmpLastCell = cell;
+        }
+        else // mouse moved but stayed in the same cell
+        {
+            if ( cell )
+                OnCellMouseHover(cell, x, y);
+        }
+
+        m_tmpMouseMoved = FALSE;
+    }
+}
+
+
+IMPLEMENT_ABSTRACT_CLASS(wxHtmlProcessor,wxObject)
+
+IMPLEMENT_DYNAMIC_CLASS(wxHtmlWindow,wxScrolledWindow)
+
+BEGIN_EVENT_TABLE(wxHtmlWindow, wxScrolledWindow)
+    EVT_SIZE(wxHtmlWindow::OnSize)
+    EVT_LEFT_DOWN(wxHtmlWindow::OnMouseEvent)
+    EVT_RIGHT_DOWN(wxHtmlWindow::OnMouseEvent)
+    EVT_MOTION(wxHtmlWindow::OnMouseEvent)
+    EVT_IDLE(wxHtmlWindow::OnIdle)
+END_EVENT_TABLE()
+
+
+
+
+
+// A module to allow initialization/cleanup
+// without calling these functions from app.cpp or from
+// the user's application.
+
+class wxHtmlWinModule: public wxModule
+{
+DECLARE_DYNAMIC_CLASS(wxHtmlWinModule)
+public:
+    wxHtmlWinModule() : wxModule() {}
+    bool OnInit() { return TRUE; }
+    void OnExit() { wxHtmlWindow::CleanUpStatics(); }
+};
+
+IMPLEMENT_DYNAMIC_CLASS(wxHtmlWinModule, wxModule)
+
+
+// This hack forces the linker to always link in m_* files
+// (wxHTML doesn't work without handlers from these files)
+#include "wx/html/forcelnk.h"
+FORCE_WXHTML_MODULES()
+
+#endif

src/html/htmprint.cpp

@@ -0,0 +1,633 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        htmprint.cpp
+// Purpose:     html printing classes
+// Author:      Vaclav Slavik
+// Created:     25/09/99
+// RCS-ID:      $Id$
+// Copyright:   (c) Vaclav Slavik, 1999
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+
+#ifdef __GNUG__
+#pragma implementation "htmprint.h"
+#endif
+
+// For compilers that support precompilation, includes "wx/wx.h".
+#include "wx/wxprec.h"
+
+#include "wx/defs.h"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#ifndef WX_PRECOMP
+    #include "wx/log.h"
+    #include "wx/intl.h"
+    #include "wx/dc.h"
+#endif
+
+#if wxUSE_HTML && wxUSE_PRINTING_ARCHITECTURE && wxUSE_STREAMS
+
+#include "wx/dc.h"
+#include "wx/print.h"
+#include "wx/printdlg.h"
+#include "wx/html/htmprint.h"
+#include "wx/wxhtml.h"
+#include "wx/wfstream.h"
+
+
+//--------------------------------------------------------------------------------
+// wxHtmlDCRenderer
+//--------------------------------------------------------------------------------
+
+
+wxHtmlDCRenderer::wxHtmlDCRenderer() : wxObject()
+{
+    m_DC = NULL;
+    m_Width = m_Height = 0;
+    m_Cells = NULL;
+    m_Parser = new wxHtmlWinParser(NULL);
+    m_FS = new wxFileSystem();
+    m_Parser->SetFS(m_FS);
+}
+
+
+
+wxHtmlDCRenderer::~wxHtmlDCRenderer()
+{
+    if (m_Cells) delete m_Cells;
+    if (m_Parser) delete m_Parser;
+    if (m_FS) delete m_FS;
+}
+
+
+
+void wxHtmlDCRenderer::SetDC(wxDC *dc, double pixel_scale)
+{
+    m_DC = dc;
+    m_Parser->SetDC(m_DC, pixel_scale);
+}
+
+
+
+void wxHtmlDCRenderer::SetSize(int width, int height)
+{
+    m_Width = width;
+    m_Height = height;
+}
+
+
+void wxHtmlDCRenderer::SetHtmlText(const wxString& html, const wxString& basepath, bool isdir)
+{
+    if (m_DC == NULL) return;
+
+    if (m_Cells != NULL) delete m_Cells;
+
+    m_FS->ChangePathTo(basepath, isdir);
+    m_Cells = (wxHtmlContainerCell*) m_Parser->Parse(html);
+    m_Cells->SetIndent(0, wxHTML_INDENT_ALL, wxHTML_UNITS_PIXELS);
+    m_Cells->Layout(m_Width);
+}
+
+
+void wxHtmlDCRenderer::SetFonts(wxString normal_face, wxString fixed_face,
+                                const int *sizes)
+{
+    m_Parser->SetFonts(normal_face, fixed_face, sizes);
+    if (m_DC == NULL && m_Cells != NULL) m_Cells->Layout(m_Width);
+}
+
+
+int wxHtmlDCRenderer::Render(int x, int y, int from, int dont_render, int to, int *known_pagebreaks, int number_of_pages)
+{
+    int pbreak, hght;
+
+    if (m_Cells == NULL || m_DC == NULL) return 0;
+
+    pbreak = (int)(from + m_Height);
+    while (m_Cells->AdjustPagebreak(&pbreak, known_pagebreaks, number_of_pages)) {}
+    hght = pbreak - from;
+    if(to < hght)
+        hght = to;
+
+    if (!dont_render)
+    {
+        m_DC->SetBrush(*wxWHITE_BRUSH);
+
+        m_DC->SetClippingRegion(x, y, m_Width, hght);
+        m_Cells->Draw(*m_DC,
+                        x, (y - from),
+                        y, pbreak + (y /*- from*/));
+        m_DC->DestroyClippingRegion();
+    }
+
+    if (pbreak < m_Cells->GetHeight()) return pbreak;
+    else return GetTotalHeight();
+}
+
+
+
+int wxHtmlDCRenderer::GetTotalHeight()
+{
+    if (m_Cells) return m_Cells->GetHeight();
+    else return 0;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//--------------------------------------------------------------------------------
+// wxHtmlPrintout
+//--------------------------------------------------------------------------------
+
+
+
+wxHtmlPrintout::wxHtmlPrintout(const wxString& title) : wxPrintout(title)
+{
+    m_Renderer = new wxHtmlDCRenderer;
+    m_RendererHdr = new wxHtmlDCRenderer;
+    m_NumPages = wxHTML_PRINT_MAX_PAGES;
+    m_Document = m_BasePath = wxEmptyString; m_BasePathIsDir = TRUE;
+    m_Headers[0] = m_Headers[1] = wxEmptyString;
+    m_Footers[0] = m_Footers[1] = wxEmptyString;
+    m_HeaderHeight = m_FooterHeight = 0;
+    SetMargins(); // to default values
+}
+
+
+
+wxHtmlPrintout::~wxHtmlPrintout()
+{
+    delete m_Renderer;
+    delete m_RendererHdr;
+}
+
+
+
+bool wxHtmlPrintout::OnBeginDocument(int startPage, int endPage)
+{
+    int pageWidth, pageHeight, mm_w, mm_h, scr_w, scr_h, dc_w, dc_h;
+    float ppmm_h, ppmm_v;
+
+    if (!wxPrintout::OnBeginDocument(startPage, endPage)) return FALSE;
+
+    GetPageSizePixels(&pageWidth, &pageHeight);
+    GetPageSizeMM(&mm_w, &mm_h);
+    ppmm_h = (float)pageWidth / mm_w;
+    ppmm_v = (float)pageHeight / mm_h;
+
+    int ppiPrinterX, ppiPrinterY;
+    GetPPIPrinter(&ppiPrinterX, &ppiPrinterY);
+    int ppiScreenX, ppiScreenY;
+    GetPPIScreen(&ppiScreenX, &ppiScreenY);
+
+    wxDisplaySize(&scr_w, &scr_h);
+    GetDC()->GetSize(&dc_w, &dc_h);
+
+    GetDC()->SetUserScale((double)dc_w / (double)pageWidth, (double)dc_w / (double)pageWidth);
+
+    /* prepare headers/footers renderer: */
+
+    m_RendererHdr->SetDC(GetDC(), (double)ppiPrinterY / (double)ppiScreenY);
+    m_RendererHdr->SetSize((int) (ppmm_h * (mm_w - m_MarginLeft - m_MarginRight)),
+                          (int) (ppmm_v * (mm_h - m_MarginTop - m_MarginBottom)));
+    if (m_Headers[0] != wxEmptyString)
+    {
+        m_RendererHdr->SetHtmlText(TranslateHeader(m_Headers[0], 1));
+        m_HeaderHeight = m_RendererHdr->GetTotalHeight();
+    }
+    else if (m_Headers[1] != wxEmptyString)
+    {
+        m_RendererHdr->SetHtmlText(TranslateHeader(m_Headers[1], 1));
+        m_HeaderHeight = m_RendererHdr->GetTotalHeight();
+    }
+    if (m_Footers[0] != wxEmptyString)
+    {
+        m_RendererHdr->SetHtmlText(TranslateHeader(m_Footers[0], 1));
+        m_FooterHeight = m_RendererHdr->GetTotalHeight();
+    }
+    else if (m_Footers[1] != wxEmptyString)
+    {
+        m_RendererHdr->SetHtmlText(TranslateHeader(m_Footers[1], 1));
+        m_FooterHeight = m_RendererHdr->GetTotalHeight();
+    }
+
+    /* prepare main renderer: */
+    m_Renderer->SetDC(GetDC(), (double)ppiPrinterY / (double)ppiScreenY);
+    m_Renderer->SetSize((int) (ppmm_h * (mm_w - m_MarginLeft - m_MarginRight)),
+                          (int) (ppmm_v * (mm_h - m_MarginTop - m_MarginBottom) -
+                          m_FooterHeight - m_HeaderHeight -
+                          ((m_HeaderHeight == 0) ? 0 : m_MarginSpace * ppmm_v) -
+                          ((m_FooterHeight == 0) ? 0 : m_MarginSpace * ppmm_v)
+                          ));
+    m_Renderer->SetHtmlText(m_Document, m_BasePath, m_BasePathIsDir);
+    CountPages();
+    return TRUE;
+}
+
+
+bool wxHtmlPrintout::OnPrintPage(int page)
+{
+    wxDC *dc = GetDC();
+    if (dc)
+    {
+        if (HasPage(page))
+            RenderPage(dc, page);
+        return TRUE;
+    }
+    else return FALSE;
+}
+
+
+void wxHtmlPrintout::GetPageInfo(int *minPage, int *maxPage, int *selPageFrom, int *selPageTo)
+{
+    *minPage = 1;
+    *maxPage = wxHTML_PRINT_MAX_PAGES;
+    *selPageFrom = 1;
+    *selPageTo = wxHTML_PRINT_MAX_PAGES;
+}
+
+
+
+bool wxHtmlPrintout::HasPage(int pageNum)
+{
+    return (pageNum >= 1 && pageNum <= m_NumPages);
+}
+
+
+
+void wxHtmlPrintout::SetHtmlText(const wxString& html, const wxString &basepath, bool isdir)
+{
+    m_Document = html;
+    m_BasePath = basepath;
+    m_BasePathIsDir = isdir;
+}
+
+void wxHtmlPrintout::SetHtmlFile(const wxString& htmlfile)
+{
+    wxFileSystem fs;
+    wxFSFile *ff = fs.OpenFile(htmlfile);
+
+    if (ff == NULL)
+    {
+        wxLogError(htmlfile + _(": file does not exist!"));
+        return;
+    }
+
+    wxHtmlFilterHTML filter;
+    wxString doc = filter.ReadFile(*ff);
+    
+    SetHtmlText(doc, htmlfile, FALSE);
+    delete ff;
+}
+
+
+
+void wxHtmlPrintout::SetHeader(const wxString& header, int pg)
+{
+    if (pg == wxPAGE_ALL || pg == wxPAGE_EVEN)
+        m_Headers[0] = header;
+    if (pg == wxPAGE_ALL || pg == wxPAGE_ODD)
+        m_Headers[1] = header;
+}
+
+
+
+void wxHtmlPrintout::SetFooter(const wxString& footer, int pg)
+{
+    if (pg == wxPAGE_ALL || pg == wxPAGE_EVEN)
+        m_Footers[0] = footer;
+    if (pg == wxPAGE_ALL || pg == wxPAGE_ODD)
+        m_Footers[1] = footer;
+}
+
+
+
+void wxHtmlPrintout::CountPages()
+{
+    wxBusyCursor wait;
+    int pageWidth, pageHeight, mm_w, mm_h;
+    float ppmm_h, ppmm_v;
+
+    GetPageSizePixels(&pageWidth, &pageHeight);
+    GetPageSizeMM(&mm_w, &mm_h);
+    ppmm_h = (float)pageWidth / mm_w;
+    ppmm_v = (float)pageHeight / mm_h;
+
+    int pos = 0;
+
+    m_NumPages = 0;
+
+    m_PageBreaks[0] = 0;
+    do
+    {
+        pos = m_Renderer->Render((int)( ppmm_h * m_MarginLeft),
+                                   (int) (ppmm_v * (m_MarginTop + (m_HeaderHeight == 0 ? 0 : m_MarginSpace)) + m_HeaderHeight),
+                                   pos, TRUE, INT_MAX, m_PageBreaks, m_NumPages);
+        m_PageBreaks[++m_NumPages] = pos;
+    } while (pos < m_Renderer->GetTotalHeight());
+}
+
+
+
+void wxHtmlPrintout::RenderPage(wxDC *dc, int page)
+{
+    wxBusyCursor wait;
+
+    int pageWidth, pageHeight, mm_w, mm_h, scr_w, scr_h, dc_w, dc_h;
+    float ppmm_h, ppmm_v;
+
+    GetPageSizePixels(&pageWidth, &pageHeight);
+    GetPageSizeMM(&mm_w, &mm_h);
+    ppmm_h = (float)pageWidth / mm_w;
+    ppmm_v = (float)pageHeight / mm_h;
+    wxDisplaySize(&scr_w, &scr_h);
+    dc->GetSize(&dc_w, &dc_h);
+
+    int ppiPrinterX, ppiPrinterY;
+    GetPPIPrinter(&ppiPrinterX, &ppiPrinterY);
+    int ppiScreenX, ppiScreenY;
+    GetPPIScreen(&ppiScreenX, &ppiScreenY);
+
+    dc->SetUserScale((double)dc_w / (double)pageWidth, (double)dc_w / (double)pageWidth);
+
+    m_Renderer->SetDC(dc, (double)ppiPrinterY / (double)ppiScreenY);
+
+    dc->SetBackgroundMode(wxTRANSPARENT);
+
+    m_Renderer->Render((int) (ppmm_h * m_MarginLeft),
+                         (int) (ppmm_v * (m_MarginTop + (m_HeaderHeight == 0 ? 0 : m_MarginSpace)) + m_HeaderHeight),
+                         m_PageBreaks[page-1], FALSE, m_PageBreaks[page]-m_PageBreaks[page-1]);
+
+    m_RendererHdr->SetDC(dc, (double)ppiPrinterY / (double)ppiScreenY);
+    if (m_Headers[page % 2] != wxEmptyString)
+    {
+        m_RendererHdr->SetHtmlText(TranslateHeader(m_Headers[page % 2], page));
+        m_RendererHdr->Render((int) (ppmm_h * m_MarginLeft), (int) (ppmm_v * m_MarginTop));
+    }
+    if (m_Footers[page % 2] != wxEmptyString)
+    {
+        m_RendererHdr->SetHtmlText(TranslateHeader(m_Footers[page % 2], page));
+        m_RendererHdr->Render((int) (ppmm_h * m_MarginLeft), (int) (pageHeight - ppmm_v * m_MarginBottom - m_FooterHeight));
+    }
+}
+
+
+
+wxString wxHtmlPrintout::TranslateHeader(const wxString& instr, int page)
+{
+    wxString r = instr;
+    wxString num;
+
+    num.Printf(wxT("%i"), page);
+    r.Replace(wxT("@PAGENUM@"), num);
+
+    num.Printf(wxT("%i"), m_NumPages);
+    r.Replace(wxT("@PAGESCNT@"), num);
+
+    return r;
+}
+
+
+
+void wxHtmlPrintout::SetMargins(float top, float bottom, float left, float right, float spaces)
+{
+    m_MarginTop = top;
+    m_MarginBottom = bottom;
+    m_MarginLeft = left;
+    m_MarginRight = right;
+    m_MarginSpace = spaces;
+}
+
+
+
+
+void wxHtmlPrintout::SetFonts(wxString normal_face, wxString fixed_face,
+                              const int *sizes)
+{
+    m_Renderer->SetFonts(normal_face, fixed_face, sizes);
+    m_RendererHdr->SetFonts(normal_face, fixed_face, sizes);
+}
+
+
+
+//----------------------------------------------------------------------------
+// wxHtmlEasyPrinting
+//----------------------------------------------------------------------------
+
+
+wxHtmlEasyPrinting::wxHtmlEasyPrinting(const wxString& name, wxFrame *parent_frame)
+{
+    m_Frame = parent_frame;
+    m_Name = name;
+    m_PrintData = new wxPrintData;
+    m_PageSetupData = new wxPageSetupDialogData;
+    m_Headers[0] = m_Headers[1] = m_Footers[0] = m_Footers[1] = wxEmptyString;
+
+    m_PageSetupData->EnableMargins(TRUE);
+    m_PageSetupData->SetMarginTopLeft(wxPoint(25, 25));
+    m_PageSetupData->SetMarginBottomRight(wxPoint(25, 25));
+
+    SetFonts(wxEmptyString, wxEmptyString, NULL);
+}
+
+
+
+wxHtmlEasyPrinting::~wxHtmlEasyPrinting()
+{
+    delete m_PrintData;
+    delete m_PageSetupData;
+}
+
+
+
+bool wxHtmlEasyPrinting::PreviewFile(const wxString &htmlfile)
+{
+    wxHtmlPrintout *p1 = CreatePrintout();
+    p1->SetHtmlFile(htmlfile);
+    wxHtmlPrintout *p2 = CreatePrintout();
+    p2->SetHtmlFile(htmlfile);
+    return DoPreview(p1, p2);
+}
+
+
+
+bool wxHtmlEasyPrinting::PreviewText(const wxString &htmltext, const wxString &basepath)
+{
+    wxHtmlPrintout *p1 = CreatePrintout();
+    p1->SetHtmlText(htmltext, basepath, TRUE);
+    wxHtmlPrintout *p2 = CreatePrintout();
+    p2->SetHtmlText(htmltext, basepath, TRUE);
+    return DoPreview(p1, p2);
+}
+
+
+
+bool wxHtmlEasyPrinting::PrintFile(const wxString &htmlfile)
+{
+    wxHtmlPrintout *p = CreatePrintout();
+    p->SetHtmlFile(htmlfile);
+    bool ret = DoPrint(p);
+    delete p;
+    return ret;
+}
+
+
+
+bool wxHtmlEasyPrinting::PrintText(const wxString &htmltext, const wxString &basepath)
+{
+    wxHtmlPrintout *p = CreatePrintout();
+    p->SetHtmlText(htmltext, basepath, TRUE);
+    bool ret = DoPrint(p);
+    delete p;
+    return ret;
+}
+
+
+
+bool wxHtmlEasyPrinting::DoPreview(wxHtmlPrintout *printout1, wxHtmlPrintout *printout2)
+{
+    // Pass two printout objects: for preview, and possible printing.
+    wxPrintDialogData printDialogData(*m_PrintData);
+    wxPrintPreview *preview = new wxPrintPreview(printout1, printout2, &printDialogData);
+    if (!preview->Ok())
+    {
+        delete preview;
+        return FALSE;
+    }
+
+    wxPreviewFrame *frame = new wxPreviewFrame(preview, m_Frame,
+                                               m_Name + _(" Preview"),
+                                               wxPoint(100, 100), wxSize(650, 500));
+    frame->Centre(wxBOTH);
+    frame->Initialize();
+    frame->Show(TRUE);
+    return TRUE;
+}
+
+
+
+bool wxHtmlEasyPrinting::DoPrint(wxHtmlPrintout *printout)
+{
+    wxPrintDialogData printDialogData(*m_PrintData);
+    wxPrinter printer(&printDialogData);
+
+    if (!printer.Print(m_Frame, printout, TRUE))
+    {
+        return FALSE;
+    }
+
+    (*m_PrintData) = printer.GetPrintDialogData().GetPrintData();
+    return TRUE;
+}
+
+
+
+void wxHtmlEasyPrinting::PrinterSetup()
+{
+    wxPrintDialogData printDialogData(*m_PrintData);
+    wxPrintDialog printerDialog(m_Frame, &printDialogData);
+
+    printerDialog.GetPrintDialogData().SetSetupDialog(TRUE);
+
+    if (printerDialog.ShowModal() == wxID_OK)
+        (*m_PrintData) = printerDialog.GetPrintDialogData().GetPrintData();
+}
+
+
+
+void wxHtmlEasyPrinting::PageSetup()
+{
+    if (!m_PrintData->Ok())
+    {
+        wxLogError(_("There was a problem during page setup: you may need to set a default printer."));
+        return;
+    }
+
+    m_PageSetupData->SetPrintData(*m_PrintData);
+    wxPageSetupDialog pageSetupDialog(m_Frame, m_PageSetupData);
+
+    if (pageSetupDialog.ShowModal() == wxID_OK)
+    {
+        (*m_PrintData) = pageSetupDialog.GetPageSetupData().GetPrintData();
+        (*m_PageSetupData) = pageSetupDialog.GetPageSetupData();
+    }
+}
+
+
+
+void wxHtmlEasyPrinting::SetHeader(const wxString& header, int pg)
+{
+    if (pg == wxPAGE_ALL || pg == wxPAGE_EVEN)
+        m_Headers[0] = header;
+    if (pg == wxPAGE_ALL || pg == wxPAGE_ODD)
+        m_Headers[1] = header;
+}
+
+
+
+void wxHtmlEasyPrinting::SetFooter(const wxString& footer, int pg)
+{
+    if (pg == wxPAGE_ALL || pg == wxPAGE_EVEN)
+        m_Footers[0] = footer;
+    if (pg == wxPAGE_ALL || pg == wxPAGE_ODD)
+        m_Footers[1] = footer;
+}
+
+
+void wxHtmlEasyPrinting::SetFonts(wxString normal_face, wxString fixed_face,
+                                  const int *sizes)
+{
+    m_FontFaceNormal = normal_face;
+    m_FontFaceFixed = fixed_face;
+
+    if (sizes)
+    {
+        m_FontsSizes = m_FontsSizesArr;
+        for (int i = 0; i < 7; i++) m_FontsSizes[i] = sizes[i];
+    }
+    else
+        m_FontsSizes = NULL;
+}
+
+
+wxHtmlPrintout *wxHtmlEasyPrinting::CreatePrintout()
+{
+    wxHtmlPrintout *p = new wxHtmlPrintout(m_Name);
+
+    p->SetFonts(m_FontFaceNormal, m_FontFaceFixed, m_FontsSizes);
+
+    p->SetHeader(m_Headers[0], wxPAGE_EVEN);
+    p->SetHeader(m_Headers[1], wxPAGE_ODD);
+    p->SetFooter(m_Footers[0], wxPAGE_EVEN);
+    p->SetFooter(m_Footers[1], wxPAGE_ODD);
+
+    p->SetMargins(m_PageSetupData->GetMarginTopLeft().y,
+                    m_PageSetupData->GetMarginBottomRight().y,
+                    m_PageSetupData->GetMarginTopLeft().x,
+                    m_PageSetupData->GetMarginBottomRight().x);
+
+    return p;
+}
+
+
+// This hack forces the linker to always link in m_* files
+// (wxHTML doesn't work without handlers from these files)
+#include "wx/html/forcelnk.h"
+FORCE_WXHTML_MODULES()
+
+#endif // wxUSE_HTML & wxUSE_PRINTING_ARCHITECTURE

src/html/m_dflist.cpp

@@ -0,0 +1,90 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        m_dflist.cpp
+// Purpose:     wxHtml module for definition lists (DL,DT,DD)
+// Author:      Vaclav Slavik
+// RCS-ID:      $Id$
+// Copyright:   (c) 1999 Vaclav Slavik
+// Licence:     wxWindows Licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "wx/wxprec.h"
+
+
+#include "wx/defs.h"
+#if wxUSE_HTML && wxUSE_STREAMS
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#ifndef WXPRECOMP
+#endif
+
+#include "wx/html/forcelnk.h"
+#include "wx/html/m_templ.h"
+
+#include "wx/html/htmlcell.h"
+
+FORCE_LINK_ME(m_dflist)
+
+
+
+
+TAG_HANDLER_BEGIN(DEFLIST, "DL,DT,DD" )
+
+    TAG_HANDLER_PROC(tag)
+    {
+        wxHtmlContainerCell *c;
+
+
+        if (tag.GetName() == wxT("DL"))
+        {
+            if (m_WParser->GetContainer()->GetFirstCell() != NULL)
+            {
+                m_WParser->CloseContainer();
+                m_WParser->OpenContainer();
+            }
+            m_WParser->GetContainer()->SetIndent(m_WParser->GetCharHeight(), wxHTML_INDENT_TOP);
+
+            ParseInner(tag);
+
+            if (m_WParser->GetContainer()->GetFirstCell() != NULL)
+            {
+                m_WParser->CloseContainer();
+                m_WParser->OpenContainer();
+            }
+            m_WParser->GetContainer()->SetIndent(m_WParser->GetCharHeight(), wxHTML_INDENT_TOP);
+
+            return TRUE;
+        }
+        else if (tag.GetName() == wxT("DT"))
+        {
+            m_WParser->CloseContainer();
+            c = m_WParser->OpenContainer();
+            c->SetAlignHor(wxHTML_ALIGN_LEFT);
+            c->SetMinHeight(m_WParser->GetCharHeight());
+            return FALSE;
+        }
+        else // "DD"
+        {
+            m_WParser->CloseContainer();
+            c = m_WParser->OpenContainer();
+            c->SetIndent(5 * m_WParser->GetCharWidth(), wxHTML_INDENT_LEFT);
+            return FALSE;
+        }
+    }
+
+TAG_HANDLER_END(DEFLIST)
+
+
+TAGS_MODULE_BEGIN(DefinitionList)
+
+    TAGS_MODULE_ADD(DEFLIST)
+
+TAGS_MODULE_END(DefinitionList)
+
+#endif

src/html/m_fonts.cpp

@@ -0,0 +1,321 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        m_fonts.cpp
+// Purpose:     wxHtml module for fonts & colors of fonts
+// Author:      Vaclav Slavik
+// RCS-ID:      $Id$
+// Copyright:   (c) 1999 Vaclav Slavik
+// Licence:     wxWindows Licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "wx/wxprec.h"
+
+#include "wx/defs.h"
+#if wxUSE_HTML && wxUSE_STREAMS
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#ifndef WXPRECOMP
+#endif
+
+#include "wx/html/forcelnk.h"
+#include "wx/html/m_templ.h"
+#include "wx/fontenum.h"
+#include "wx/tokenzr.h"
+
+FORCE_LINK_ME(m_fonts)
+
+
+TAG_HANDLER_BEGIN(FONT, "FONT" )
+
+    TAG_HANDLER_VARS
+        wxArrayString m_Faces;
+
+    TAG_HANDLER_PROC(tag)
+    {
+        wxColour oldclr = m_WParser->GetActualColor();
+        int oldsize = m_WParser->GetFontSize();
+        wxString oldface = m_WParser->GetFontFace();
+
+        if (tag.HasParam(wxT("COLOR")))
+        {
+            wxColour clr;
+            if (tag.GetParamAsColour(wxT("COLOR"), &clr))
+            {
+                m_WParser->SetActualColor(clr);
+                m_WParser->GetContainer()->InsertCell(new wxHtmlColourCell(clr));
+            }
+        }
+
+        if (tag.HasParam(wxT("SIZE")))
+        {
+            int tmp = 0;
+            wxChar c = tag.GetParam(wxT("SIZE")).GetChar(0);
+            if (tag.GetParamAsInt(wxT("SIZE"), &tmp))
+            {
+                if (c == wxT('+') || c == wxT('-'))
+                    m_WParser->SetFontSize(oldsize+tmp);
+                else
+                    m_WParser->SetFontSize(tmp);
+                m_WParser->GetContainer()->InsertCell(
+                    new wxHtmlFontCell(m_WParser->CreateCurrentFont()));
+            }
+        }
+
+        if (tag.HasParam(wxT("FACE")))
+        {
+            if (m_Faces.GetCount() == 0)
+            {
+                wxFontEnumerator enu;
+                enu.EnumerateFacenames();
+                m_Faces = *enu.GetFacenames();
+            }
+            wxStringTokenizer tk(tag.GetParam(wxT("FACE")), wxT(","));
+            int index;
+
+            while (tk.HasMoreTokens())
+            {
+                if ((index = m_Faces.Index(tk.GetNextToken(), FALSE)) != wxNOT_FOUND)
+                {
+                    m_WParser->SetFontFace(m_Faces[index]);
+                    m_WParser->GetContainer()->InsertCell(new wxHtmlFontCell(m_WParser->CreateCurrentFont()));
+                    break;
+                }
+            }
+        }
+
+        ParseInner(tag);
+
+        if (oldface != m_WParser->GetFontFace())
+        {
+            m_WParser->SetFontFace(oldface);
+            m_WParser->GetContainer()->InsertCell(new wxHtmlFontCell(m_WParser->CreateCurrentFont()));
+        }
+        if (oldsize != m_WParser->GetFontSize())
+        {
+            m_WParser->SetFontSize(oldsize);
+            m_WParser->GetContainer()->InsertCell(new wxHtmlFontCell(m_WParser->CreateCurrentFont()));
+        }
+        if (oldclr != m_WParser->GetActualColor())
+        {
+            m_WParser->SetActualColor(oldclr);
+            m_WParser->GetContainer()->InsertCell(new wxHtmlColourCell(oldclr));
+        }
+        return TRUE;
+    }
+
+TAG_HANDLER_END(FONT)
+
+
+TAG_HANDLER_BEGIN(FACES_U, "U,STRIKE")
+
+    TAG_HANDLER_PROC(tag)
+    {
+        int underlined = m_WParser->GetFontUnderlined();
+
+        m_WParser->SetFontUnderlined(TRUE);
+        m_WParser->GetContainer()->InsertCell(
+            new wxHtmlFontCell(m_WParser->CreateCurrentFont()));
+
+        ParseInner(tag);
+
+        m_WParser->SetFontUnderlined(underlined);
+        m_WParser->GetContainer()->InsertCell(
+            new wxHtmlFontCell(m_WParser->CreateCurrentFont()));
+        return TRUE;
+    }
+
+TAG_HANDLER_END(FACES_U)
+
+
+
+
+TAG_HANDLER_BEGIN(FACES_B, "B,STRONG")
+
+    TAG_HANDLER_PROC(tag)
+    {
+        int bold = m_WParser->GetFontBold();
+
+        m_WParser->SetFontBold(TRUE);
+        m_WParser->GetContainer()->InsertCell(
+            new wxHtmlFontCell(m_WParser->CreateCurrentFont()));
+
+        ParseInner(tag);
+
+        m_WParser->SetFontBold(bold);
+        m_WParser->GetContainer()->InsertCell(
+            new wxHtmlFontCell(m_WParser->CreateCurrentFont()));
+        return TRUE;
+    }
+
+TAG_HANDLER_END(FACES_B)
+
+
+
+
+TAG_HANDLER_BEGIN(FACES_I, "I,EM,CITE,ADDRESS")
+
+    TAG_HANDLER_PROC(tag)
+    {
+        int italic = m_WParser->GetFontItalic();
+
+        m_WParser->SetFontItalic(TRUE);
+        m_WParser->GetContainer()->InsertCell(
+            new wxHtmlFontCell(m_WParser->CreateCurrentFont()));
+
+        ParseInner(tag);
+
+        m_WParser->SetFontItalic(italic);
+        m_WParser->GetContainer()->InsertCell(
+            new wxHtmlFontCell(m_WParser->CreateCurrentFont()));
+        return TRUE;
+    }
+
+TAG_HANDLER_END(FACES_I)
+
+
+
+
+TAG_HANDLER_BEGIN(FACES_TT, "TT,CODE,KBD,SAMP")
+
+    TAG_HANDLER_PROC(tag)
+    {
+        int fixed = m_WParser->GetFontFixed();
+
+        m_WParser->SetFontFixed(TRUE);
+        m_WParser->GetContainer()->InsertCell(
+            new wxHtmlFontCell(m_WParser->CreateCurrentFont()));
+
+        ParseInner(tag);
+
+        m_WParser->SetFontFixed(fixed);
+        m_WParser->GetContainer()->InsertCell(
+            new wxHtmlFontCell(m_WParser->CreateCurrentFont()));
+        return TRUE;
+    }
+
+TAG_HANDLER_END(FACES_TT)
+
+
+
+
+
+TAG_HANDLER_BEGIN(Hx, "H1,H2,H3,H4,H5,H6")
+
+    TAG_HANDLER_PROC(tag)
+    {
+        int old_size, old_b, old_i, old_u, old_f, old_al;
+        wxHtmlContainerCell *c;
+
+        old_size = m_WParser->GetFontSize();
+        old_b = m_WParser->GetFontBold();
+        old_i = m_WParser->GetFontItalic();
+        old_u = m_WParser->GetFontUnderlined();
+        old_f = m_WParser->GetFontFixed();
+        old_al = m_WParser->GetAlign();
+
+        m_WParser->SetFontBold(TRUE);
+        m_WParser->SetFontItalic(FALSE);
+        m_WParser->SetFontUnderlined(FALSE);
+        m_WParser->SetFontFixed(FALSE);
+
+        if (tag.GetName() == wxT("H1"))
+                m_WParser->SetFontSize(7);
+        else if (tag.GetName() == wxT("H2"))
+                m_WParser->SetFontSize(6);
+        else if (tag.GetName() == wxT("H3"))
+                m_WParser->SetFontSize(5);
+        else if (tag.GetName() == wxT("H4"))
+        {
+                m_WParser->SetFontSize(5);
+                m_WParser->SetFontItalic(TRUE);
+                m_WParser->SetFontBold(FALSE);
+        }
+        else if (tag.GetName() == wxT("H5"))
+                m_WParser->SetFontSize(4);
+        else if (tag.GetName() == wxT("H6"))
+        {
+                m_WParser->SetFontSize(4);
+                m_WParser->SetFontItalic(TRUE);
+                m_WParser->SetFontBold(FALSE);
+        }
+
+        c = m_WParser->GetContainer();
+        if (c->GetFirstCell())
+        {
+            m_WParser->CloseContainer();
+            m_WParser->OpenContainer();
+            c = m_WParser->GetContainer();
+        }
+        c = m_WParser->GetContainer();
+
+        c->SetAlign(tag);
+        c->InsertCell(new wxHtmlFontCell(m_WParser->CreateCurrentFont()));
+        c->SetIndent(m_WParser->GetCharHeight(), wxHTML_INDENT_TOP);
+        m_WParser->SetAlign(c->GetAlignHor());
+
+        ParseInner(tag);
+
+        m_WParser->SetFontSize(old_size);
+        m_WParser->SetFontBold(old_b);
+        m_WParser->SetFontItalic(old_i);
+        m_WParser->SetFontUnderlined(old_u);
+        m_WParser->SetFontFixed(old_f);
+        m_WParser->SetAlign(old_al);
+
+        m_WParser->GetContainer()->InsertCell(
+            new wxHtmlFontCell(m_WParser->CreateCurrentFont()));
+        m_WParser->CloseContainer();
+        m_WParser->OpenContainer();
+        c = m_WParser->GetContainer();
+        c->SetIndent(m_WParser->GetCharHeight(), wxHTML_INDENT_TOP);
+
+        return TRUE;
+    }
+
+TAG_HANDLER_END(Hx)
+
+
+TAG_HANDLER_BEGIN(BIGSMALL, "BIG,SMALL")
+
+    TAG_HANDLER_PROC(tag)
+    {
+        int oldsize = m_WParser->GetFontSize();
+        int sz = (tag.GetName() == wxT("BIG")) ? +1 : -1;
+
+        m_WParser->SetFontSize(sz);
+        m_WParser->GetContainer()->InsertCell(
+            new wxHtmlFontCell(m_WParser->CreateCurrentFont()));
+
+        ParseInner(tag);
+
+        m_WParser->SetFontSize(oldsize);
+        m_WParser->GetContainer()->InsertCell(
+            new wxHtmlFontCell(m_WParser->CreateCurrentFont()));
+        return TRUE;
+    }
+
+TAG_HANDLER_END(BIGSMALL)
+
+
+
+
+TAGS_MODULE_BEGIN(Fonts)
+
+    TAGS_MODULE_ADD(FONT)
+    TAGS_MODULE_ADD(FACES_U)
+    TAGS_MODULE_ADD(FACES_I)
+    TAGS_MODULE_ADD(FACES_B)
+    TAGS_MODULE_ADD(FACES_TT)
+    TAGS_MODULE_ADD(Hx)
+    TAGS_MODULE_ADD(BIGSMALL)
+
+TAGS_MODULE_END(Fonts)
+
+
+#endif

src/html/m_hline.cpp

@@ -0,0 +1,110 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        m_hline.cpp
+// Purpose:     wxHtml module for horizontal line (HR tag)
+// Author:      Vaclav Slavik
+// RCS-ID:      $Id$
+// Copyright:   (c) 1999 Vaclav Slavik
+// Licence:     wxWindows Licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "wx/wxprec.h"
+
+
+#include "wx/defs.h"
+#if wxUSE_HTML && wxUSE_STREAMS
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#ifndef WXPRECOMP
+    #include "wx/brush.h"
+    #include "wx/pen.h"
+    #include "wx/dc.h"
+#endif
+
+#include "wx/html/forcelnk.h"
+#include "wx/html/m_templ.h"
+
+#include "wx/html/htmlcell.h"
+
+FORCE_LINK_ME(m_hline)
+
+
+//-----------------------------------------------------------------------------
+// wxHtmlLineCell
+//-----------------------------------------------------------------------------
+
+class wxHtmlLineCell : public wxHtmlCell
+{
+    public:
+        wxHtmlLineCell(int size, bool shading) : wxHtmlCell() {m_Height = size; m_HasShading = shading;}
+        void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2);
+        void Layout(int w)
+            { m_Width = w; wxHtmlCell::Layout(w); }
+
+    private:
+        // Should we draw 3-D shading or not
+      bool m_HasShading;
+};
+
+
+void wxHtmlLineCell::Draw(wxDC& dc, int x, int y, int WXUNUSED(view_y1), int WXUNUSED(view_y2))
+{
+    wxBrush mybrush(wxT("GREY"), (m_HasShading) ? wxTRANSPARENT : wxSOLID);
+    wxPen mypen(wxT("GREY"), 1, wxSOLID);
+    dc.SetBrush(mybrush);
+    dc.SetPen(mypen);
+    dc.DrawRectangle(x + m_PosX, y + m_PosY, m_Width, m_Height);
+}
+
+
+
+
+//-----------------------------------------------------------------------------
+// The list handler:
+//-----------------------------------------------------------------------------
+
+
+TAG_HANDLER_BEGIN(HR, "HR")
+
+    TAG_HANDLER_PROC(tag)
+    {
+        wxHtmlContainerCell *c;
+        int sz;
+        bool HasShading;
+
+        m_WParser->CloseContainer();
+        c = m_WParser->OpenContainer();
+
+        c->SetIndent(m_WParser->GetCharHeight(), wxHTML_INDENT_VERTICAL);
+        c->SetAlignHor(wxHTML_ALIGN_CENTER);
+        c->SetAlign(tag);
+        c->SetWidthFloat(tag);
+        sz = 1;
+        tag.GetParamAsInt(wxT("SIZE"), &sz);
+        HasShading = !(tag.HasParam(wxT("NOSHADE")));
+        c->InsertCell(new wxHtmlLineCell((int)((double)sz * m_WParser->GetPixelScale()), HasShading));
+
+        m_WParser->CloseContainer();
+        m_WParser->OpenContainer();
+
+        return FALSE;
+    }
+
+TAG_HANDLER_END(HR)
+
+
+
+
+
+TAGS_MODULE_BEGIN(HLine)
+
+    TAGS_MODULE_ADD(HR)
+
+TAGS_MODULE_END(HLine)
+
+#endif

src/html/m_image.cpp

@@ -0,0 +1,692 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        m_image.cpp
+// Purpose:     wxHtml module for displaying images
+// Author:      Vaclav Slavik
+// RCS-ID:      $Id$
+// Copyright:   (c) 1999 Vaclav Slavik, Joel Lucsy
+// Licence:     wxWindows Licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "wx/wxprec.h"
+
+#include "wx/defs.h"
+#if wxUSE_HTML && wxUSE_STREAMS
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#ifndef WXPRECOMP
+    #include "wx/dc.h"
+    #include "wx/scrolwin.h"
+    #include "wx/timer.h"
+    #include "wx/dcmemory.h"
+#endif
+
+#include "wx/html/forcelnk.h"
+#include "wx/html/m_templ.h"
+#include "wx/html/htmlwin.h"
+
+#include "wx/image.h"
+#include "wx/gifdecod.h"
+#include "wx/dynarray.h"
+#include "wx/log.h"
+#include "wx/artprov.h"
+
+#include <math.h>
+#include <float.h>
+
+FORCE_LINK_ME(m_image)
+
+
+
+
+WX_DECLARE_OBJARRAY(int, CoordArray);
+#include "wx/arrimpl.cpp" // this is a magic incantation which must be done!
+WX_DEFINE_OBJARRAY(CoordArray);
+
+
+//--------------------------------------------------------------------------------
+// wxHtmlImageMapAreaCell
+//                  0-width, 0-height cell that represents single area in imagemap
+//                  (it's GetLink is called from wxHtmlImageCell's)
+//--------------------------------------------------------------------------------
+
+class wxHtmlImageMapAreaCell : public wxHtmlCell
+{
+    public:
+        enum celltype { CIRCLE, RECT, POLY };
+    protected:
+        CoordArray coords;
+        celltype type;
+        int radius;
+    public:
+        wxHtmlImageMapAreaCell( celltype t, wxString &coords, double pixel_scale = 1.0);
+        virtual wxHtmlLinkInfo *GetLink( int x = 0, int y = 0 ) const;
+};
+
+
+
+
+
+wxHtmlImageMapAreaCell::wxHtmlImageMapAreaCell( wxHtmlImageMapAreaCell::celltype t, wxString &incoords, double pixel_scale )
+{
+    int i;
+    wxString x = incoords, y;
+
+    type = t;
+    while ((i = x.Find( ',' )) != -1)
+    {
+        coords.Add( (int)(pixel_scale * (double)wxAtoi( x.Left( i ).c_str())) );
+        x = x.Mid( i + 1 );
+    }
+    coords.Add( (int)(pixel_scale * (double)wxAtoi( x.c_str())) );
+}
+
+wxHtmlLinkInfo *wxHtmlImageMapAreaCell::GetLink( int x, int y ) const
+{
+    switch (type)
+    {
+        case RECT:
+            {
+                int l, t, r, b;
+
+                l = coords[ 0 ];
+                t = coords[ 1 ];
+                r = coords[ 2 ];
+                b = coords[ 3 ];
+                if (x >= l && x <= r && y >= t && y <= b)
+                {
+                    return m_Link;
+                }
+                break;
+            }
+        case CIRCLE:
+            {
+                int l, t, r;
+                double  d;
+
+                l = coords[ 0 ];
+                t = coords[ 1 ];
+                r = coords[ 2 ];
+                d = sqrt( (double) (((x - l) * (x - l)) + ((y - t) * (y - t))) );
+                if (d < (double)r)
+                {
+                    return m_Link;
+                }
+            }
+            break;
+        case POLY:
+            {
+                if (coords.GetCount() >= 6)
+                {
+                    int intersects = 0;
+                    int wherex = x;
+                    int wherey = y;
+                    int totalv = coords.GetCount() / 2;
+                    int totalc = totalv * 2;
+                    int xval = coords[totalc - 2];
+                    int yval = coords[totalc - 1];
+                    int end = totalc;
+                    int pointer = 1;
+
+                    if ((yval >= wherey) != (coords[pointer] >= wherey))
+                    {
+                        if ((xval >= wherex) == (coords[0] >= wherex))
+                        {
+                            intersects += (xval >= wherex) ? 1 : 0;
+                        }
+                        else
+                        {
+                            intersects += ((xval - (yval - wherey) *
+                                            (coords[0] - xval) /
+                                            (coords[pointer] - yval)) >= wherex) ? 1 : 0;
+                        }
+                    }
+
+                    while (pointer < end)
+                    {
+                        yval = coords[pointer];
+                        pointer += 2;
+                        if (yval >= wherey)
+                        {
+                            while ((pointer < end) && (coords[pointer] >= wherey))
+                            {
+                                pointer += 2;
+                            }
+                            if (pointer >= end)
+                            {
+                                break;
+                            }
+                            if ((coords[pointer - 3] >= wherex) ==
+                                    (coords[pointer - 1] >= wherex)) {
+                                intersects += (coords[pointer - 3] >= wherex) ? 1 : 0;
+                            }
+                            else
+                            {
+                                intersects +=
+                                    ((coords[pointer - 3] - (coords[pointer - 2] - wherey) *
+                                      (coords[pointer - 1] - coords[pointer - 3]) /
+                                      (coords[pointer] - coords[pointer - 2])) >= wherex) ? 1 : 0;
+                            }
+                        }
+                        else
+                        {
+                            while ((pointer < end) && (coords[pointer] < wherey))
+                            {
+                                pointer += 2;
+                            }
+                            if (pointer >= end)
+                            {
+                                break;
+                            }
+                            if ((coords[pointer - 3] >= wherex) ==
+                                    (coords[pointer - 1] >= wherex))
+                            {
+                                intersects += (coords[pointer - 3] >= wherex) ? 1 : 0;
+                            }
+                            else
+                            {
+                                intersects +=
+                                    ((coords[pointer - 3] - (coords[pointer - 2] - wherey) *
+                                      (coords[pointer - 1] - coords[pointer - 3]) /
+                                      (coords[pointer] - coords[pointer - 2])) >= wherex) ? 1 : 0;
+                            }
+                        }
+                    }
+                    if ((intersects & 1) != 0)
+                    {
+                        return m_Link;
+                    }
+                }
+            }
+            break;
+    }
+
+    if (m_Next)
+    {
+        wxHtmlImageMapAreaCell  *a = (wxHtmlImageMapAreaCell*)m_Next;
+        return a->GetLink( x, y );
+    }
+    return NULL;
+}
+
+
+
+
+
+
+
+
+//--------------------------------------------------------------------------------
+// wxHtmlImageMapCell
+//                  0-width, 0-height cell that represents map from imagemaps
+//                  it is always placed before wxHtmlImageMapAreaCells
+//                  It responds to Find(wxHTML_COND_ISIMAGEMAP)
+//--------------------------------------------------------------------------------
+
+
+class wxHtmlImageMapCell : public wxHtmlCell
+{
+    public:
+        wxHtmlImageMapCell( wxString &name );
+    protected:
+        wxString m_Name;
+    public:
+        virtual wxHtmlLinkInfo *GetLink( int x = 0, int y = 0 ) const;
+        virtual const wxHtmlCell *Find( int cond, const void *param ) const;
+};
+
+
+wxHtmlImageMapCell::wxHtmlImageMapCell( wxString &name )
+{
+    m_Name = name ;
+}
+
+wxHtmlLinkInfo *wxHtmlImageMapCell::GetLink( int x, int y ) const
+{
+    wxHtmlImageMapAreaCell  *a = (wxHtmlImageMapAreaCell*)m_Next;
+    if (a)
+        return a->GetLink( x, y );
+    return wxHtmlCell::GetLink( x, y );
+}
+
+const wxHtmlCell *wxHtmlImageMapCell::Find( int cond, const void *param ) const
+{
+    if (cond == wxHTML_COND_ISIMAGEMAP)
+    {
+        if (m_Name == *((wxString*)(param)))
+            return this;
+    }
+    return wxHtmlCell::Find(cond, param);
+}
+
+
+
+
+
+//--------------------------------------------------------------------------------
+// wxHtmlImageCell
+//                  Image/bitmap
+//--------------------------------------------------------------------------------
+
+class wxHtmlImageCell : public wxHtmlCell
+{
+public:
+    wxHtmlImageCell(wxWindow *window,
+                    wxFSFile *input, int w = -1, int h = -1,
+                    double scale = 1.0, int align = wxHTML_ALIGN_BOTTOM,
+                    const wxString& mapname = wxEmptyString);
+    ~wxHtmlImageCell();
+    void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2);
+    virtual wxHtmlLinkInfo *GetLink(int x = 0, int y = 0) const;
+
+    void SetImage(const wxImage& img);
+#if wxUSE_GIF && wxUSE_TIMER
+    void AdvanceAnimation(wxTimer *timer);
+    virtual void Layout(int w);
+#endif
+
+private:
+    wxBitmap           *m_bitmap;
+    int                 m_bmpW, m_bmpH;
+    bool                m_showFrame:1;
+    wxScrolledWindow   *m_window;
+#if wxUSE_GIF && wxUSE_TIMER
+    wxGIFDecoder       *m_gifDecoder;
+    wxTimer            *m_gifTimer;
+    int                 m_physX, m_physY;
+#endif
+    double              m_scale;
+    wxHtmlImageMapCell *m_imageMap;
+    wxString            m_mapName;
+
+    DECLARE_NO_COPY_CLASS(wxHtmlImageCell)
+};
+
+#if wxUSE_GIF && wxUSE_TIMER
+class wxGIFTimer : public wxTimer
+{
+    public:
+        wxGIFTimer(wxHtmlImageCell *cell) : m_cell(cell) {}
+        virtual void Notify()
+        {
+            m_cell->AdvanceAnimation(this);
+        }
+
+    private:
+        wxHtmlImageCell *m_cell;
+
+    DECLARE_NO_COPY_CLASS(wxGIFTimer)
+};
+#endif
+
+
+//----------------------------------------------------------------------------
+// wxHtmlImageCell
+//----------------------------------------------------------------------------
+
+
+wxHtmlImageCell::wxHtmlImageCell(wxWindow *window, wxFSFile *input,
+                                 int w, int h, double scale, int align,
+                                 const wxString& mapname) : wxHtmlCell()
+{
+    m_window = window ? wxStaticCast(window, wxScrolledWindow) : NULL;
+    m_scale = scale;
+    m_showFrame = FALSE;
+    m_bitmap = NULL;
+    m_bmpW = w;
+    m_bmpH = h;
+    m_imageMap = NULL;
+    m_mapName = mapname;
+    SetCanLiveOnPagebreak(FALSE);
+#if wxUSE_GIF && wxUSE_TIMER
+    m_gifDecoder = NULL;
+    m_gifTimer = NULL;
+    m_physX = m_physY = -1;
+#endif
+
+    if ( m_bmpW && m_bmpH )
+    {
+        if ( input )
+        {
+            wxInputStream *s = input->GetStream();
+
+            if ( s )
+            {
+                bool readImg = TRUE;
+
+#if wxUSE_GIF && wxUSE_TIMER
+                if ( (input->GetLocation().Matches(wxT("*.gif")) ||
+                      input->GetLocation().Matches(wxT("*.GIF"))) && m_window )
+                {
+                    m_gifDecoder = new wxGIFDecoder(s, TRUE);
+                    if ( m_gifDecoder->ReadGIF() == wxGIF_OK )
+                    {
+                        wxImage img;
+                        if ( m_gifDecoder->ConvertToImage(&img) )
+                            SetImage(img);
+
+                        readImg = FALSE;
+
+                        if ( m_gifDecoder->IsAnimation() )
+                        {
+                            m_gifTimer = new wxGIFTimer(this);
+                            m_gifTimer->Start(m_gifDecoder->GetDelay(), TRUE);
+                        }
+                        else
+                        {
+                            wxDELETE(m_gifDecoder);
+                        }
+                    }
+                    else
+                    {
+                        wxDELETE(m_gifDecoder);
+                    }
+                }
+
+                if ( readImg )
+#endif // wxUSE_GIF && wxUSE_TIMER
+                {
+                    wxImage image(*s, wxBITMAP_TYPE_ANY);
+                    if ( image.Ok() )
+                        SetImage(image);
+                }
+            }
+        }
+        else // input==NULL, use "broken image" bitmap
+        {
+            if ( m_bmpW == -1 && m_bmpH == -1 )
+            {
+                m_bmpW = 29;
+                m_bmpH = 31;
+            }
+            else
+            {
+                m_showFrame = TRUE;
+                if ( m_bmpW == -1 ) m_bmpW = 31;
+                if ( m_bmpH == -1 ) m_bmpH = 33;
+            }
+            m_bitmap = 
+                new wxBitmap(wxArtProvider::GetBitmap(wxART_MISSING_IMAGE));
+        }
+    }
+    //else: ignore the 0-sized images used sometimes on the Web pages
+
+    m_Width = (int)(scale * (double)m_bmpW);
+    m_Height = (int)(scale * (double)m_bmpH);
+
+    switch (align)
+    {
+        case wxHTML_ALIGN_TOP :
+            m_Descent = m_Height;
+            break;
+        case wxHTML_ALIGN_CENTER :
+            m_Descent = m_Height / 2;
+            break;
+        case wxHTML_ALIGN_BOTTOM :
+        default :
+            m_Descent = 0;
+            break;
+    }
+ }
+
+void wxHtmlImageCell::SetImage(const wxImage& img)
+{
+    if ( img.Ok() )
+    {
+        delete m_bitmap;
+
+        int ww, hh;
+        ww = img.GetWidth();
+        hh = img.GetHeight();
+
+        if ( m_bmpW == -1 )
+            m_bmpW = ww;
+        if ( m_bmpH == -1 )
+            m_bmpH = hh;
+
+        if ((m_bmpW != ww) || (m_bmpH != hh))
+        {
+            wxImage img2 = img.Scale(m_bmpW, m_bmpH);
+            m_bitmap = new wxBitmap(img2);
+        }
+        else
+            m_bitmap = new wxBitmap(img);
+    }
+}
+
+#if wxUSE_GIF && wxUSE_TIMER
+void wxHtmlImageCell::AdvanceAnimation(wxTimer *timer)
+{
+    wxImage img;
+
+    m_gifDecoder->GoNextFrame(TRUE);
+
+    if ( m_physX == -1 )
+    {
+        m_physX = m_physY = 0;
+        for (wxHtmlCell *cell = this; cell; cell = cell->GetParent())
+        {
+            m_physX += cell->GetPosX();
+            m_physY += cell->GetPosY();
+        }
+    }
+
+    int x, y;
+    m_window->CalcScrolledPosition(m_physX, m_physY, &x, &y);
+    wxRect rect(x, y, m_Width, m_Height);
+
+    if ( m_window->GetClientRect().Intersects(rect) &&
+         m_gifDecoder->ConvertToImage(&img) )
+    {
+        if ( (int)m_gifDecoder->GetWidth() != m_Width ||
+             (int)m_gifDecoder->GetHeight() != m_Height ||
+             m_gifDecoder->GetLeft() != 0 || m_gifDecoder->GetTop() != 0 )
+        {
+            wxBitmap bmp(img);
+            wxMemoryDC dc;
+            dc.SelectObject(*m_bitmap);
+            dc.DrawBitmap(bmp, m_gifDecoder->GetLeft(), m_gifDecoder->GetTop());
+        }
+        else
+            SetImage(img);
+        m_window->Refresh(img.HasMask(), &rect);
+    }
+
+    timer->Start(m_gifDecoder->GetDelay(), TRUE);
+}
+
+void wxHtmlImageCell::Layout(int w)
+{
+    wxHtmlCell::Layout(w);
+    m_physX = m_physY = -1;
+}
+
+#endif
+
+wxHtmlImageCell::~wxHtmlImageCell()
+{
+    delete m_bitmap;
+#if wxUSE_GIF && wxUSE_TIMER
+    delete m_gifTimer;
+    delete m_gifDecoder;
+#endif
+}
+
+
+void wxHtmlImageCell::Draw(wxDC& dc, int x, int y, int WXUNUSED(view_y1), int WXUNUSED(view_y2))
+{
+    if ( m_showFrame )
+    {
+        dc.SetBrush(*wxTRANSPARENT_BRUSH);
+        dc.SetPen(*wxBLACK_PEN);
+        dc.DrawRectangle(x + m_PosX, y + m_PosY, m_Width, m_Height);
+        x++, y++;
+    }
+    if ( m_bitmap )
+    {
+        double us_x, us_y;
+        dc.GetUserScale(&us_x, &us_y);
+        dc.SetUserScale(us_x * m_scale, us_y * m_scale);
+
+        dc.DrawBitmap(*m_bitmap, (int) ((x + m_PosX) / m_scale),
+                                 (int) ((y + m_PosY) / m_scale), TRUE);
+        dc.SetUserScale(us_x, us_y);
+    }
+}
+
+wxHtmlLinkInfo *wxHtmlImageCell::GetLink( int x, int y ) const
+{
+    if (m_mapName.IsEmpty())
+        return wxHtmlCell::GetLink( x, y );
+    if (!m_imageMap)
+    {
+        wxHtmlContainerCell *p, *op;
+        op = p = GetParent();
+        while (p)
+        {
+            op = p;
+            p = p->GetParent();
+        }
+        p = op;
+        wxHtmlCell *cell = (wxHtmlCell*)p->Find(wxHTML_COND_ISIMAGEMAP,
+                                                (const void*)(&m_mapName));
+        if (!cell)
+        {
+            ((wxString&)m_mapName).Clear();
+            return wxHtmlCell::GetLink( x, y );
+        }
+        {   // dirty hack, ask Joel why he fills m_ImageMap in this place
+            // THE problem is that we're in const method and we can't modify m_ImageMap
+            wxHtmlImageMapCell **cx = (wxHtmlImageMapCell**)(&m_imageMap);
+            *cx = (wxHtmlImageMapCell*)cell;
+        }
+    }
+    return m_imageMap->GetLink(x, y);
+}
+
+
+
+//--------------------------------------------------------------------------------
+// tag handler
+//--------------------------------------------------------------------------------
+
+TAG_HANDLER_BEGIN(IMG, "IMG,MAP,AREA")
+
+    TAG_HANDLER_PROC(tag)
+    {
+        if (tag.GetName() == wxT("IMG"))
+        {
+            if (tag.HasParam(wxT("SRC")))
+            {
+                int w = -1, h = -1;
+                int al;
+                wxFSFile *str;
+                wxString tmp = tag.GetParam(wxT("SRC"));
+                wxString mn = wxEmptyString;
+
+                str = m_WParser->OpenURL(wxHTML_URL_IMAGE, tmp);
+
+                if (tag.HasParam(wxT("WIDTH")))
+                    tag.GetParamAsInt(wxT("WIDTH"), &w);
+                if (tag.HasParam(wxT("HEIGHT")))
+                    tag.GetParamAsInt(wxT("HEIGHT"), &h);
+                al = wxHTML_ALIGN_BOTTOM;
+                if (tag.HasParam(wxT("ALIGN")))
+                {
+                    wxString alstr = tag.GetParam(wxT("ALIGN"));
+                    alstr.MakeUpper();  // for the case alignment was in ".."
+                    if (alstr == wxT("TEXTTOP"))
+                        al = wxHTML_ALIGN_TOP;
+                    else if ((alstr == wxT("CENTER")) || (alstr == wxT("ABSCENTER")))
+                        al = wxHTML_ALIGN_CENTER;
+                }
+                if (tag.HasParam(wxT("USEMAP")))
+                {
+                    mn = tag.GetParam( wxT("USEMAP") );
+                    if (mn.GetChar(0) == wxT('#'))
+                    {
+                        mn = mn.Mid( 1 );
+                    }
+                }
+                wxHtmlImageCell *cel = new wxHtmlImageCell(
+                                          m_WParser->GetWindow(),
+                                          str, w, h,
+                                          m_WParser->GetPixelScale(),
+                                          al, mn);
+                cel->SetLink(m_WParser->GetLink());
+                cel->SetId(tag.GetParam(wxT("id"))); // may be empty
+                m_WParser->GetContainer()->InsertCell(cel);
+                if (str)
+                    delete str;
+            }
+        }
+        if (tag.GetName() == wxT("MAP"))
+        {
+            m_WParser->CloseContainer();
+            m_WParser->OpenContainer();
+            if (tag.HasParam(wxT("NAME")))
+            {
+                wxString tmp = tag.GetParam(wxT("NAME"));
+                wxHtmlImageMapCell *cel = new wxHtmlImageMapCell( tmp );
+                m_WParser->GetContainer()->InsertCell( cel );
+            }
+            ParseInner( tag );
+            m_WParser->CloseContainer();
+            m_WParser->OpenContainer();
+        }
+        if (tag.GetName() == wxT("AREA"))
+        {
+            if (tag.HasParam(wxT("SHAPE")))
+            {
+                wxString tmp = tag.GetParam(wxT("SHAPE"));
+                wxString coords = wxEmptyString;
+                tmp.MakeUpper();
+                wxHtmlImageMapAreaCell *cel = NULL;
+                if (tag.HasParam(wxT("COORDS")))
+                {
+                    coords = tag.GetParam(wxT("COORDS"));
+                }
+                if (tmp == wxT("POLY"))
+                {
+                    cel = new wxHtmlImageMapAreaCell( wxHtmlImageMapAreaCell::POLY, coords, m_WParser->GetPixelScale() );
+                }
+                else if (tmp == wxT("CIRCLE"))
+                {
+                    cel = new wxHtmlImageMapAreaCell( wxHtmlImageMapAreaCell::CIRCLE, coords, m_WParser->GetPixelScale() );
+                }
+                else if (tmp == wxT("RECT"))
+                {
+                    cel = new wxHtmlImageMapAreaCell( wxHtmlImageMapAreaCell::RECT, coords, m_WParser->GetPixelScale() );
+                }
+                if (cel != NULL && tag.HasParam(wxT("HREF")))
+                {
+                    wxString tmp = tag.GetParam(wxT("HREF"));
+                    wxString target = wxEmptyString;
+                    if (tag.HasParam(wxT("TARGET"))) target = tag.GetParam(wxT("TARGET"));
+                    cel->SetLink( wxHtmlLinkInfo(tmp, target));
+                }
+                if (cel != NULL) m_WParser->GetContainer()->InsertCell( cel );
+            }
+        }
+
+        return FALSE;
+    }
+
+TAG_HANDLER_END(IMG)
+
+
+
+TAGS_MODULE_BEGIN(Image)
+
+    TAGS_MODULE_ADD(IMG)
+
+TAGS_MODULE_END(Image)
+
+
+#endif

src/html/m_layout.cpp

@@ -0,0 +1,369 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        m_layout.cpp
+// Purpose:     wxHtml module for basic paragraphs/layout handling
+// Author:      Vaclav Slavik
+// RCS-ID:      $Id$
+// Copyright:   (c) 1999 Vaclav Slavik
+// Licence:     wxWindows Licence
+/////////////////////////////////////////////////////////////////////////////
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "wx/wxprec.h"
+
+
+#include "wx/defs.h"
+#if wxUSE_HTML && wxUSE_STREAMS
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#ifndef WXPRECOMP
+#endif
+
+
+#include "wx/html/forcelnk.h"
+#include "wx/html/m_templ.h"
+
+#include "wx/html/htmlwin.h"
+
+FORCE_LINK_ME(m_layout)
+
+
+#include <stdlib.h> // bsearch()
+
+//-----------------------------------------------------------------------------
+// wxHtmlPageBreakCell
+//-----------------------------------------------------------------------------
+
+// Since html isn't a page-layout language, it doesn't support page
+// page breaks directly--that requires CSS2 support. But a page-break
+// facility is handy, and has been requested more than once on the
+// mailing lists. This wxHtml tag handler implements just enough of
+// CSS2 to support a page break by recognizing only
+//   <div style="page-break-before:always">
+//
+// wxHtml maintains page breaks in wxHtmlPrintout::m_PageBreaks. The
+// tag handler below adds appropriate offsets to that array member.
+// wxHtmlDCRenderer::Render() accesses that array and makes a new page
+// begin after each page-break tag.
+
+// The page-break handler does all its work in AdjustPagebreak(). For
+// all tag handlers, that function adjusts the page-break position.
+// For other tags, it determines whether the html element can fit on
+// the remainder of the page; if it cannot fit, but must not be split,
+// then the function moves the page break provided in the argument up,
+// and returns 'true' to inform the caller that the argument was
+// modified.
+//
+// Due to its special purpose, the page-break facility differs from
+// other tags. It takes up no space, but it behaves as though there is
+// never enough room to fit it on the remainder of the page--it always
+// forces a page break. Therefore, unlike other elements that trigger
+// a page break, it would never 'fit' on the following page either.
+// Therefore it's necessary to compare each pagebreak candidate to the
+// array wxHtmlPrintout::m_PageBreaks of pagebreaks already set, and
+// set a new one only if it's not in that array.
+
+class WXDLLEXPORT wxHtmlPageBreakCell : public wxHtmlCell
+{
+  public:
+    wxHtmlPageBreakCell() {}
+
+    bool AdjustPagebreak(int* pagebreak, int* known_pagebreaks = NULL, int number_of_pages = 0) const;
+
+  private:
+    DECLARE_NO_COPY_CLASS(wxHtmlPageBreakCell)
+};
+
+// Comparison routine for bsearch into an int* array of pagebreaks.
+static int integer_compare(void const* i0, void const* i1)
+{
+    return *(int*)i0 - *(int*)i1;
+}
+
+bool wxHtmlPageBreakCell::AdjustPagebreak(int* pagebreak, int* known_pagebreaks, int number_of_pages) const
+{
+    // When we are counting pages, 'known_pagebreaks' is non-NULL.
+    // That's the only time we change 'pagebreak'. Otherwise, pages
+    // were already counted, 'known_pagebreaks' is NULL, and we don't
+    // do anything except return FALSE.
+    //
+    // We also simply return FALSE if the 'pagebreak' argument is
+    // less than (vertically above) or the same as the current
+    // vertical position. Otherwise we'd be setting a pagebreak above
+    // the current cell, which is incorrect, or duplicating a
+    // pagebreak that has already been set.
+    if(NULL == known_pagebreaks || *pagebreak <= m_PosY)
+        {
+        return FALSE;
+        }
+
+    // m_PosY is only the vertical offset from the parent. The pagebreak
+    // required here is the total page offset, so m_PosY must be added
+    // to the parent's offset and height.
+    int total_height = m_PosY + GetParent()->GetPosY() + GetParent()->GetHeight();
+
+    // Search the array of pagebreaks to see whether we've already set
+    // a pagebreak here. The standard bsearch() function is appropriate
+    // because the array of pagebreaks through known_pagebreaks[number_of_pages]
+    // is known to be sorted in strictly increasing order. '1 + number_of_pages'
+    // is used as a bsearch() argument because the array contains a leading
+    // zero plus one element for each page.
+    int* where = (int*) bsearch(&total_height, known_pagebreaks,
+                                1 + number_of_pages, sizeof(int),
+                                integer_compare);
+    // Add a pagebreak only if there isn't one already set here.
+    if(NULL != where)
+        {
+        return FALSE;
+        }
+    else
+        {
+        *pagebreak = m_PosY;
+        return TRUE;
+        }
+}
+
+TAG_HANDLER_BEGIN(P, "P")
+
+    TAG_HANDLER_PROC(tag)
+    {
+        if (m_WParser->GetContainer()->GetFirstCell() != NULL)
+        {
+            m_WParser->CloseContainer();
+            m_WParser->OpenContainer();
+        }
+        m_WParser->GetContainer()->SetIndent(m_WParser->GetCharHeight(), wxHTML_INDENT_TOP);
+        m_WParser->GetContainer()->SetAlign(tag);
+        return FALSE;
+    }
+
+TAG_HANDLER_END(P)
+
+
+
+TAG_HANDLER_BEGIN(BR, "BR")
+
+    TAG_HANDLER_PROC(tag)
+    {
+        int al = m_WParser->GetContainer()->GetAlignHor();
+        wxHtmlContainerCell *c;
+
+        m_WParser->CloseContainer();
+        c = m_WParser->OpenContainer();
+        c->SetAlignHor(al);
+        c->SetAlign(tag);
+        c->SetMinHeight(m_WParser->GetCharHeight());
+        return FALSE;
+    }
+
+TAG_HANDLER_END(BR)
+
+
+
+TAG_HANDLER_BEGIN(CENTER, "CENTER")
+
+    TAG_HANDLER_PROC(tag)
+    {
+        int old = m_WParser->GetAlign();
+        wxHtmlContainerCell *c = m_WParser->GetContainer();
+
+        m_WParser->SetAlign(wxHTML_ALIGN_CENTER);
+        if (c->GetFirstCell() != NULL)
+        {
+            m_WParser->CloseContainer();
+            m_WParser->OpenContainer();
+        }
+        else
+            c->SetAlignHor(wxHTML_ALIGN_CENTER);
+
+        if (tag.HasEnding())
+        {
+            ParseInner(tag);
+
+            m_WParser->SetAlign(old);
+            if (c->GetFirstCell() != NULL)
+            {
+                m_WParser->CloseContainer();
+                m_WParser->OpenContainer();
+            }
+            else
+                c->SetAlignHor(old);
+
+            return TRUE;
+        }
+        else return FALSE;
+    }
+
+TAG_HANDLER_END(CENTER)
+
+
+
+TAG_HANDLER_BEGIN(DIV, "DIV")
+
+    TAG_HANDLER_PROC(tag)
+    {
+        if(tag.HasParam(wxT("STYLE")))
+        {
+            if(tag.GetParam(wxT("STYLE")).IsSameAs(wxT("PAGE-BREAK-BEFORE:ALWAYS"), FALSE))
+            {
+                m_WParser->CloseContainer();
+                m_WParser->OpenContainer()->InsertCell(new wxHtmlPageBreakCell);
+                m_WParser->CloseContainer();
+                m_WParser->OpenContainer();
+                return FALSE;
+            }
+            else
+            {
+                // Treat other STYLE parameters here when they're supported.
+                return FALSE;
+            }
+        }
+        else if(tag.HasParam(wxT("ALIGN")))
+        {
+            int old = m_WParser->GetAlign();
+            wxHtmlContainerCell *c = m_WParser->GetContainer();
+            if (c->GetFirstCell() != NULL)
+            {
+                m_WParser->CloseContainer();
+                m_WParser->OpenContainer();
+                c = m_WParser->GetContainer();
+                c->SetAlign(tag);
+                m_WParser->SetAlign(c->GetAlignHor());
+            }
+            else
+            {
+                c->SetAlign(tag);
+                m_WParser->SetAlign(c->GetAlignHor());
+            }
+
+            ParseInner(tag);
+
+            m_WParser->SetAlign(old);
+            if (c->GetFirstCell() != NULL)
+            {
+                m_WParser->CloseContainer();
+                m_WParser->OpenContainer();
+            }
+            else
+                c->SetAlignHor(old);
+
+            return TRUE;
+        }
+        else
+        {
+            return FALSE;
+        }
+    }
+
+TAG_HANDLER_END(DIV)
+
+
+
+
+TAG_HANDLER_BEGIN(TITLE, "TITLE")
+
+    TAG_HANDLER_PROC(tag)
+    {
+        if (m_WParser->GetWindow())
+        {
+            wxHtmlWindow *wfr = (wxHtmlWindow*)(m_WParser->GetWindow());
+            if (wfr)
+            {
+                const wxString& src = *m_WParser->GetSource();
+                wfr->OnSetTitle(src.Mid(tag.GetBeginPos(), 
+                                        tag.GetEndPos1()-tag.GetBeginPos()));
+            }
+        }
+        return TRUE;
+    }
+
+TAG_HANDLER_END(TITLE)
+
+
+
+
+TAG_HANDLER_BEGIN(BODY, "BODY")
+
+    TAG_HANDLER_PROC(tag)
+    {
+        wxColour clr;
+
+        if (tag.GetParamAsColour(wxT("TEXT"), &clr))
+        {
+            m_WParser->SetActualColor(clr);
+            m_WParser->GetContainer()->InsertCell(new wxHtmlColourCell(clr));
+        }
+
+        if (tag.GetParamAsColour(wxT("LINK"), &clr))
+            m_WParser->SetLinkColor(clr);
+
+        if (tag.GetParamAsColour(wxT("BGCOLOR"), &clr))
+        {
+            m_WParser->GetContainer()->InsertCell(
+                new wxHtmlColourCell(clr, wxHTML_CLR_BACKGROUND));
+            if (m_WParser->GetWindow() != NULL)
+                m_WParser->GetWindow()->SetBackgroundColour(clr);
+        }
+        return FALSE;
+    }
+
+TAG_HANDLER_END(BODY)
+
+
+
+TAG_HANDLER_BEGIN(BLOCKQUOTE, "BLOCKQUOTE")
+
+    TAG_HANDLER_PROC(tag)
+    {
+        wxHtmlContainerCell *c;
+
+        m_WParser->CloseContainer();
+        c = m_WParser->OpenContainer();
+
+        if (c->GetAlignHor() == wxHTML_ALIGN_RIGHT)
+            c->SetIndent(5 * m_WParser->GetCharWidth(), wxHTML_INDENT_RIGHT);
+        else
+            c->SetIndent(5 * m_WParser->GetCharWidth(), wxHTML_INDENT_LEFT);
+
+        c->SetIndent(m_WParser->GetCharHeight(), wxHTML_INDENT_TOP);
+        m_WParser->OpenContainer();
+        ParseInner(tag);
+        c = m_WParser->CloseContainer();
+        c->SetIndent(m_WParser->GetCharHeight(), wxHTML_INDENT_BOTTOM);
+        m_WParser->CloseContainer();
+        m_WParser->OpenContainer();
+        return TRUE;
+    }
+
+TAG_HANDLER_END(BLOCKQUOTE)
+
+
+
+// Tag handler for tags that we have to ignore, otherwise non-text data
+// would show up as text:
+TAG_HANDLER_BEGIN(DoNothing, "SCRIPT")
+    TAG_HANDLER_PROC(tag)
+    {
+        return true;
+    }
+TAG_HANDLER_END(DoNothing)
+
+
+
+TAGS_MODULE_BEGIN(Layout)
+
+    TAGS_MODULE_ADD(P)
+    TAGS_MODULE_ADD(BR)
+    TAGS_MODULE_ADD(CENTER)
+    TAGS_MODULE_ADD(DIV)
+    TAGS_MODULE_ADD(TITLE)
+    TAGS_MODULE_ADD(BODY)
+    TAGS_MODULE_ADD(BLOCKQUOTE)
+    TAGS_MODULE_ADD(DoNothing)
+
+TAGS_MODULE_END(Layout)
+
+#endif

src/html/m_links.cpp

@@ -0,0 +1,98 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        m_links.cpp
+// Purpose:     wxHtml module for links & anchors
+// Author:      Vaclav Slavik
+// RCS-ID:      $Id$
+// Copyright:   (c) 1999 Vaclav Slavik
+// Licence:     wxWindows Licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "wx/wxprec.h"
+
+#include "wx/defs.h"
+#if wxUSE_HTML && wxUSE_STREAMS
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#ifndef WXPRECOMP
+#endif
+
+#include "wx/html/forcelnk.h"
+#include "wx/html/m_templ.h"
+
+
+FORCE_LINK_ME(m_links)
+
+
+class wxHtmlAnchorCell : public wxHtmlCell
+{
+    private:
+        wxString m_AnchorName;
+
+    public:
+        wxHtmlAnchorCell(const wxString& name) : wxHtmlCell() {m_AnchorName = name;}
+        virtual const wxHtmlCell* Find(int condition, const void* param) const
+        {
+            if ((condition == wxHTML_COND_ISANCHOR) && (m_AnchorName == (*((const wxString*)param))))
+                return this;
+            else
+                return wxHtmlCell::Find(condition, param);
+        }
+};
+
+
+
+TAG_HANDLER_BEGIN(A, "A")
+
+    TAG_HANDLER_PROC(tag)
+    {
+        if (tag.HasParam( wxT("NAME") ))
+        {
+            m_WParser->GetContainer()->InsertCell(new wxHtmlAnchorCell(tag.GetParam( wxT("NAME") )));
+        }
+
+        if (tag.HasParam( wxT("HREF") ))
+        {
+            wxHtmlLinkInfo oldlnk = m_WParser->GetLink();
+            wxColour oldclr = m_WParser->GetActualColor();
+            int oldund = m_WParser->GetFontUnderlined();
+            wxString name(tag.GetParam( wxT("HREF") )), target;
+
+            if (tag.HasParam( wxT("TARGET") )) target = tag.GetParam( wxT("TARGET") );
+            m_WParser->SetActualColor(m_WParser->GetLinkColor());
+            m_WParser->GetContainer()->InsertCell(new wxHtmlColourCell(m_WParser->GetLinkColor()));
+            m_WParser->SetFontUnderlined(TRUE);
+            m_WParser->GetContainer()->InsertCell(new wxHtmlFontCell(m_WParser->CreateCurrentFont()));
+            m_WParser->SetLink(wxHtmlLinkInfo(name, target));
+
+            ParseInner(tag);
+
+            m_WParser->SetLink(oldlnk);
+            m_WParser->SetFontUnderlined(oldund);
+            m_WParser->GetContainer()->InsertCell(new wxHtmlFontCell(m_WParser->CreateCurrentFont()));
+            m_WParser->SetActualColor(oldclr);
+            m_WParser->GetContainer()->InsertCell(new wxHtmlColourCell(oldclr));
+
+            return TRUE;
+        }
+        else return FALSE;
+    }
+
+TAG_HANDLER_END(A)
+
+
+
+TAGS_MODULE_BEGIN(Links)
+
+    TAGS_MODULE_ADD(A)
+
+TAGS_MODULE_END(Links)
+
+
+#endif

src/html/m_list.cpp

@@ -0,0 +1,170 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        m_list.cpp
+// Purpose:     wxHtml module for lists
+// Author:      Vaclav Slavik
+// RCS-ID:      $Id$
+// Copyright:   (c) 1999 Vaclav Slavik
+// Licence:     wxWindows Licence
+/////////////////////////////////////////////////////////////////////////////
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "wx/wxprec.h"
+
+
+#include "wx/defs.h"
+#if wxUSE_HTML && wxUSE_STREAMS
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#ifndef WXPRECOMP
+    #include "wx/brush.h"
+    #include "wx/dc.h"
+#endif
+
+#include "wx/html/forcelnk.h"
+#include "wx/html/m_templ.h"
+
+#include "wx/html/htmlcell.h"
+
+FORCE_LINK_ME(m_list)
+
+
+//-----------------------------------------------------------------------------
+// wxHtmlListmarkCell
+//-----------------------------------------------------------------------------
+
+class wxHtmlListmarkCell : public wxHtmlCell
+{
+    private:
+        wxBrush m_Brush;
+    public:
+        wxHtmlListmarkCell(wxDC *dc, const wxColour& clr);
+        void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2);
+};
+
+wxHtmlListmarkCell::wxHtmlListmarkCell(wxDC* dc, const wxColour& clr) : wxHtmlCell(), m_Brush(clr, wxSOLID)
+{
+    m_Width =  dc->GetCharHeight();
+    m_Height = dc->GetCharHeight();
+    m_Descent = 0;
+}
+
+
+
+void wxHtmlListmarkCell::Draw(wxDC& dc, int x, int y, int WXUNUSED(view_y1), int WXUNUSED(view_y2))
+{
+    dc.SetBrush(m_Brush);
+    dc.DrawEllipse(x + m_PosX + m_Width / 3, y + m_PosY + m_Height / 3, 
+                   (m_Width / 3), (m_Width / 3));
+}
+
+
+
+
+//-----------------------------------------------------------------------------
+// The list handler:
+//-----------------------------------------------------------------------------
+
+
+TAG_HANDLER_BEGIN(OLULLI, "OL,UL,LI")
+
+    TAG_HANDLER_VARS
+        int m_Numbering;
+                // this is number of actual item of list or 0 for dots
+
+    TAG_HANDLER_CONSTR(OLULLI)
+    {
+        m_Numbering = 0;
+    }
+
+    TAG_HANDLER_PROC(tag)
+    {
+        wxHtmlContainerCell *c;
+
+        // List Item:
+        if (tag.GetName() == wxT("LI"))
+        {
+            m_WParser->GetContainer()->SetIndent(0, wxHTML_INDENT_TOP);
+                // this is to prevent indetation in <li><p> case
+            m_WParser->CloseContainer();
+            m_WParser->CloseContainer();
+
+            c = m_WParser->OpenContainer();
+            c->SetWidthFloat(2 * m_WParser->GetCharWidth(), wxHTML_UNITS_PIXELS);
+            if (m_Numbering == 0)
+            {
+                // Centering gives more space after the bullet
+                c->SetAlignHor(wxHTML_ALIGN_CENTER);
+                c->InsertCell(new wxHtmlListmarkCell(m_WParser->GetDC(), m_WParser->GetActualColor()));
+            }
+            else
+            {
+                c->SetAlignHor(wxHTML_ALIGN_RIGHT);
+                wxString mark;
+                mark.Printf(wxT("%i."), m_Numbering);
+                c->InsertCell(new wxHtmlWordCell(mark, *(m_WParser->GetDC())));
+            }
+            m_WParser->CloseContainer();
+
+            c = m_WParser->OpenContainer();
+            c->SetIndent(m_WParser->GetCharWidth() / 4, wxHTML_INDENT_LEFT);
+            c->SetWidthFloat(-2 * m_WParser->GetCharWidth(), wxHTML_UNITS_PIXELS);
+
+            m_WParser->OpenContainer();
+
+            if (m_Numbering != 0) m_Numbering++;
+
+            return FALSE;
+        }
+
+        // Begin of List (not-numbered): "UL", "OL"
+        else
+        {
+            int oldnum = m_Numbering;
+
+            if (tag.GetName() == wxT("UL")) m_Numbering = 0;
+            else m_Numbering = 1;
+
+            c = m_WParser->GetContainer();
+            if (c->GetFirstCell() != NULL)
+            {
+                m_WParser->CloseContainer();
+                m_WParser->OpenContainer();
+                c = m_WParser->GetContainer();
+            }
+            c->SetAlignHor(wxHTML_ALIGN_LEFT);
+            c->SetIndent(2 * m_WParser->GetCharWidth(), wxHTML_INDENT_LEFT);
+            m_WParser->OpenContainer()->SetAlignVer(wxHTML_ALIGN_TOP);
+
+            m_WParser->OpenContainer();
+            m_WParser->OpenContainer();
+            ParseInner(tag);
+
+            m_WParser->GetContainer()->SetIndent(0, wxHTML_INDENT_TOP);
+                // this is to prevent indetation in <li><p> case
+            m_WParser->CloseContainer();
+
+            m_WParser->CloseContainer();
+            m_WParser->CloseContainer();
+            m_WParser->CloseContainer();
+            m_WParser->OpenContainer();
+
+            m_Numbering = oldnum;
+            return TRUE;
+        }
+    }
+
+TAG_HANDLER_END(OLULLI)
+
+
+TAGS_MODULE_BEGIN(List)
+
+    TAGS_MODULE_ADD(OLULLI)
+
+TAGS_MODULE_END(List)
+
+#endif

src/html/m_pre.cpp

@@ -0,0 +1,130 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        m_pre.cpp
+// Purpose:     wxHtml module for <PRE> ... </PRE> tag (code citation)
+// Author:      Vaclav Slavik
+// RCS-ID:      $Id$
+// Copyright:   (c) 1999 Vaclav Slavik
+// Licence:     wxWindows Licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "wx/wxprec.h"
+
+#include "wx/defs.h"
+#if wxUSE_HTML && wxUSE_STREAMS
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#ifndef WXPRECOMP
+#endif
+
+#include "wx/html/forcelnk.h"
+#include "wx/html/m_templ.h"
+
+#include "wx/html/htmlcell.h"
+#include "wx/tokenzr.h"
+#include "wx/encconv.h"
+
+FORCE_LINK_ME(m_pre)
+
+// replaces '\t', ' ' and '\n' with HTML markup:
+static wxString LINKAGEMODE HtmlizeWhitespaces(const wxString& str)
+{
+    wxString out;
+    size_t i = 0, j = 0, len = str.Len();
+    for (i = 0; i < len; i++)
+    {
+        switch (str[i])
+        {
+            case wxT('<'):
+                while (i < len && str[i] != wxT('>'))
+                    out << str[i++];
+                out << wxT('>');
+                break;
+            case wxT(' '):
+                out << wxT("&nbsp;");
+                break;
+            case wxT('\n'):
+                out << wxT("<br>");
+                break;
+            case wxT('\t'):
+                for (j = 8 - i%8; j > 0; j--) out << wxT("&nbsp;");
+                break;
+            default:
+                out << str[i];
+                break;
+        }
+    }
+    return out;
+}
+
+
+//-----------------------------------------------------------------------------
+// The list handler:
+//-----------------------------------------------------------------------------
+
+
+TAG_HANDLER_BEGIN(PRE, "PRE")
+
+    TAG_HANDLER_PROC(tag)
+    {
+        wxHtmlContainerCell *c;
+
+        int fixed = m_WParser->GetFontFixed(),
+            italic = m_WParser->GetFontItalic(),
+            underlined = m_WParser->GetFontUnderlined(),
+            bold = m_WParser->GetFontBold(),
+            fsize = m_WParser->GetFontSize();
+
+        c = m_WParser->GetContainer();
+        m_WParser->SetFontUnderlined(FALSE);
+        m_WParser->SetFontBold(FALSE);
+        m_WParser->SetFontItalic(FALSE);
+        m_WParser->SetFontFixed(TRUE);
+        m_WParser->SetFontSize(3);
+        c->InsertCell(new wxHtmlFontCell(m_WParser->CreateCurrentFont()));
+
+        m_WParser->CloseContainer();
+        c = m_WParser->OpenContainer();
+        c->SetAlignHor(wxHTML_ALIGN_LEFT);
+        c->SetIndent(m_WParser->GetCharHeight(), wxHTML_INDENT_TOP);
+
+        wxString srcMid =
+            m_WParser->GetSource()->Mid(tag.GetBeginPos(),
+                                        tag.GetEndPos1() - tag.GetBeginPos());
+        // It is safe to temporarily change the source being parsed,
+        // provided we restore the state back after parsing
+        m_Parser->SetSourceAndSaveState(HtmlizeWhitespaces(srcMid));
+        m_Parser->DoParsing();
+        m_Parser->RestoreState();
+
+        m_WParser->CloseContainer();
+        c = m_WParser->OpenContainer();
+
+        m_WParser->SetFontUnderlined(underlined);
+        m_WParser->SetFontBold(bold);
+        m_WParser->SetFontItalic(italic);
+        m_WParser->SetFontFixed(fixed);
+        m_WParser->SetFontSize(fsize);
+        c->InsertCell(new wxHtmlFontCell(m_WParser->CreateCurrentFont()));
+
+        return TRUE;
+    }
+
+TAG_HANDLER_END(PRE)
+
+
+
+
+
+TAGS_MODULE_BEGIN(Pre)
+
+    TAGS_MODULE_ADD(PRE)
+
+TAGS_MODULE_END(Pre)
+
+#endif

src/html/m_style.cpp

@@ -0,0 +1,51 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        m_style.cpp
+// Purpose:     wxHtml module for parsing <style> tag
+// Author:      Vaclav Slavik
+// RCS-ID:      $Id$
+// Copyright:   (c) 2002 Vaclav Slavik
+// Licence:     wxWindows Licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "wx/wxprec.h"
+
+
+#include "wx/defs.h"
+#if wxUSE_HTML && wxUSE_STREAMS
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#ifndef WXPRECOMP
+#endif
+
+#include "wx/html/forcelnk.h"
+#include "wx/html/m_templ.h"
+
+FORCE_LINK_ME(m_style)
+
+
+TAG_HANDLER_BEGIN(STYLE, "STYLE")
+
+    TAG_HANDLER_PROC(WXUNUSED(tag))
+    {
+        // VS: Ignore styles for now. We must have this handler present,
+        //     because CSS style text would be rendered verbatim otherwise
+        return TRUE;
+    }
+
+TAG_HANDLER_END(STYLE)
+
+
+TAGS_MODULE_BEGIN(StyleTag)
+
+    TAGS_MODULE_ADD(STYLE)
+
+TAGS_MODULE_END(StyleTag)
+
+#endif

src/html/m_tables.cpp

@@ -0,0 +1,623 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        m_tables.cpp
+// Purpose:     wxHtml module for tables
+// Author:      Vaclav Slavik
+// RCS-ID:      $Id$
+// Copyright:   (c) 1999 Vaclav Slavik
+// Licence:     wxWindows Licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "wx/wxprec.h"
+
+#include "wx/defs.h"
+#if wxUSE_HTML && wxUSE_STREAMS
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#ifndef WXPRECOMP
+#endif
+
+
+/*
+REMARKS:
+    1. This version of m_tables doesn't support auto-layout algorithm.
+       This means that all columns are of same width unless explicitly specified.
+*/
+
+
+#include "wx/html/forcelnk.h"
+#include "wx/html/m_templ.h"
+
+#include "wx/html/htmlcell.h"
+
+FORCE_LINK_ME(m_tables)
+
+
+#define TABLE_BORDER_CLR_1  wxColour(0xC5, 0xC2, 0xC5)
+#define TABLE_BORDER_CLR_2  wxColour(0x62, 0x61, 0x62)
+
+
+//-----------------------------------------------------------------------------
+// wxHtmlTableCell
+//-----------------------------------------------------------------------------
+
+
+struct colStruct
+{
+    int width, units;
+            // width of the column either in pixels or percents
+            // ('width' is the number, 'units' determines its meaning)
+    int minWidth, maxWidth;
+            // minimal/maximal column width. This is needed by HTML 4.0
+            // layouting algorithm and can be determined by trying to
+            // layout table cells with width=1 and width=infinity
+    int leftpos, pixwidth, maxrealwidth;
+            // temporary (depends on actual width of table)
+};
+
+enum cellState
+{
+    cellSpan,
+    cellUsed,
+    cellFree
+};
+
+struct cellStruct
+{
+    wxHtmlContainerCell *cont;
+    int colspan, rowspan;
+    int minheight, valign;
+    cellState flag;
+};
+
+
+class wxHtmlTableCell : public wxHtmlContainerCell
+{
+protected:
+    /* These are real attributes: */
+
+    // should we draw borders or not?
+    bool m_HasBorders;
+    // number of columns; rows
+    int m_NumCols, m_NumRows;
+    // array of column information
+    colStruct *m_ColsInfo;
+    // 2D array of all cells in the table : m_CellInfo[row][column]
+    cellStruct **m_CellInfo;
+    // spaces between cells
+    int m_Spacing;
+    // cells internal indentation
+    int m_Padding;
+
+private:
+    /* ...and these are valid only when parsing the table: */
+
+    // number of actual column (ranging from 0..m_NumCols)
+    int m_ActualCol, m_ActualRow;
+
+    // default values (for table and row):
+    wxColour m_tBkg, m_rBkg;
+    wxString m_tValign, m_rValign;
+
+    double m_PixelScale;
+
+
+public:
+    wxHtmlTableCell(wxHtmlContainerCell *parent, const wxHtmlTag& tag, double pixel_scale = 1.0);
+    ~wxHtmlTableCell();
+    virtual void Layout(int w);
+
+    void AddRow(const wxHtmlTag& tag);
+    void AddCell(wxHtmlContainerCell *cell, const wxHtmlTag& tag);
+
+private:
+    // Reallocates memory to given number of cols/rows
+    // and changes m_NumCols/m_NumRows value to reflect this change
+    // NOTE! You CAN'T change m_NumCols/m_NumRows before calling this!!
+    void ReallocCols(int cols);
+    void ReallocRows(int rows);
+
+    // Computes minimal and maximal widths of columns. Needs to be called
+    // only once, before first Layout(). 
+    void ComputeMinMaxWidths();
+
+    DECLARE_NO_COPY_CLASS(wxHtmlTableCell)
+};
+
+
+
+wxHtmlTableCell::wxHtmlTableCell(wxHtmlContainerCell *parent, const wxHtmlTag& tag, double pixel_scale)
+ : wxHtmlContainerCell(parent)
+{
+    m_PixelScale = pixel_scale;
+    m_HasBorders = 
+            (tag.HasParam(wxT("BORDER")) && tag.GetParam(wxT("BORDER")) != wxT("0"));
+    m_ColsInfo = NULL;
+    m_NumCols = m_NumRows = 0;
+    m_CellInfo = NULL;
+    m_ActualCol = m_ActualRow = -1;
+
+    /* scan params: */
+    if (tag.HasParam(wxT("BGCOLOR")))
+        tag.GetParamAsColour(wxT("BGCOLOR"), &m_tBkg);
+    if (tag.HasParam(wxT("VALIGN")))
+        m_tValign = tag.GetParam(wxT("VALIGN"));
+    else
+        m_tValign = wxEmptyString;
+    if (!tag.GetParamAsInt(wxT("CELLSPACING"), &m_Spacing))
+        m_Spacing = 2;
+    if (!tag.GetParamAsInt(wxT("CELLPADDING"), &m_Padding))
+        m_Padding = 3;
+    m_Spacing = (int)(m_PixelScale * (double)m_Spacing);
+    m_Padding = (int)(m_PixelScale * (double)m_Padding);
+
+    if (m_HasBorders)
+        SetBorder(TABLE_BORDER_CLR_1, TABLE_BORDER_CLR_2);
+}
+
+
+
+wxHtmlTableCell::~wxHtmlTableCell()
+{
+    if (m_ColsInfo) free(m_ColsInfo);
+    if (m_CellInfo)
+    {
+        for (int i = 0; i < m_NumRows; i++)
+            free(m_CellInfo[i]);
+        free(m_CellInfo);
+    }
+}
+
+
+
+void wxHtmlTableCell::ReallocCols(int cols)
+{
+    int i,j;
+
+    for (i = 0; i < m_NumRows; i++)
+    {
+        m_CellInfo[i] = (cellStruct*) realloc(m_CellInfo[i], sizeof(cellStruct) * cols);
+        for (j = m_NumCols; j < cols; j++)
+            m_CellInfo[i][j].flag = cellFree;
+    }
+
+    m_ColsInfo = (colStruct*) realloc(m_ColsInfo, sizeof(colStruct) * cols);
+    for (j = m_NumCols; j < cols; j++)
+    {
+           m_ColsInfo[j].width = 0;
+           m_ColsInfo[j].units = wxHTML_UNITS_PERCENT;
+           m_ColsInfo[j].minWidth = m_ColsInfo[j].maxWidth = -1;
+    }
+
+    m_NumCols = cols;
+}
+
+
+
+void wxHtmlTableCell::ReallocRows(int rows)
+{
+    m_CellInfo = (cellStruct**) realloc(m_CellInfo, sizeof(cellStruct*) * rows);
+    for (int row = m_NumRows; row < rows ; row++)
+    {
+        if (m_NumCols == 0)
+            m_CellInfo[row] = NULL;
+        else
+        {
+            m_CellInfo[row] = (cellStruct*) malloc(sizeof(cellStruct) * m_NumCols);
+            for (int col = 0; col < m_NumCols; col++)
+                m_CellInfo[row][col].flag = cellFree;
+        }
+    }
+    m_NumRows = rows;
+}
+
+
+void wxHtmlTableCell::AddRow(const wxHtmlTag& tag)
+{
+    m_ActualCol = -1;
+    // VS: real allocation of row entry is done in AddCell in order
+    //     to correctly handle empty rows (i.e. "<tr></tr>")
+    //     m_ActualCol == -1 indicates that AddCell has to allocate new row.
+
+    // scan params:
+    m_rBkg = m_tBkg;
+    if (tag.HasParam(wxT("BGCOLOR")))
+        tag.GetParamAsColour(wxT("BGCOLOR"), &m_rBkg);
+    if (tag.HasParam(wxT("VALIGN")))
+        m_rValign = tag.GetParam(wxT("VALIGN"));
+    else
+        m_rValign = m_tValign;
+}
+
+
+
+void wxHtmlTableCell::AddCell(wxHtmlContainerCell *cell, const wxHtmlTag& tag)
+{
+    // Is this cell in new row?
+    // VS: we can't do it in AddRow, see my comment there
+    if (m_ActualCol == -1)
+    {
+        if (m_ActualRow + 1 > m_NumRows - 1)
+            ReallocRows(m_ActualRow + 2);
+        m_ActualRow++;
+    }
+
+    // cells & columns:
+    do
+    {
+        m_ActualCol++;
+    } while ((m_ActualCol < m_NumCols) &&
+             (m_CellInfo[m_ActualRow][m_ActualCol].flag != cellFree));
+
+    if (m_ActualCol > m_NumCols - 1)
+        ReallocCols(m_ActualCol + 1);
+
+    int r = m_ActualRow, c = m_ActualCol;
+
+    m_CellInfo[r][c].cont = cell;
+    m_CellInfo[r][c].colspan = 1;
+    m_CellInfo[r][c].rowspan = 1;
+    m_CellInfo[r][c].flag = cellUsed;
+    m_CellInfo[r][c].minheight = 0;
+    m_CellInfo[r][c].valign = wxHTML_ALIGN_TOP;
+
+    /* scan for parameters: */
+
+    // width:
+    {
+        if (tag.HasParam(wxT("WIDTH")))
+        {
+            wxString wd = tag.GetParam(wxT("WIDTH"));
+
+            if (wd[wd.Length()-1] == wxT('%'))
+            {
+                wxSscanf(wd.c_str(), wxT("%i%%"), &m_ColsInfo[c].width);
+                m_ColsInfo[c].units = wxHTML_UNITS_PERCENT;
+            }
+            else
+            {
+                wxSscanf(wd.c_str(), wxT("%i"), &m_ColsInfo[c].width);
+                m_ColsInfo[c].width = (int)(m_PixelScale * (double)m_ColsInfo[c].width);
+                m_ColsInfo[c].units = wxHTML_UNITS_PIXELS;
+            }
+        }
+    }
+
+
+    // spanning:
+    {
+        tag.GetParamAsInt(wxT("COLSPAN"), &m_CellInfo[r][c].colspan);
+        tag.GetParamAsInt(wxT("ROWSPAN"), &m_CellInfo[r][c].rowspan);
+
+        // VS: the standard says this about col/rowspan:
+        //     "This attribute specifies the number of rows spanned by the 
+        //     current cell. The default value of this attribute is one ("1"). 
+        //     The value zero ("0") means that the cell spans all rows from the 
+        //     current row to the last row of the table." All mainstream 
+        //     browsers act as if 0==1, though, and so does wxHTML.
+        if (m_CellInfo[r][c].colspan < 1) 
+            m_CellInfo[r][c].colspan = 1;
+        if (m_CellInfo[r][c].rowspan < 1) 
+            m_CellInfo[r][c].rowspan = 1;
+
+        if ((m_CellInfo[r][c].colspan > 1) || (m_CellInfo[r][c].rowspan > 1))
+        {
+            int i, j;
+
+            if (r + m_CellInfo[r][c].rowspan > m_NumRows)
+                ReallocRows(r + m_CellInfo[r][c].rowspan);
+            if (c + m_CellInfo[r][c].colspan > m_NumCols)
+                ReallocCols(c + m_CellInfo[r][c].colspan);
+            for (i = r; i < r + m_CellInfo[r][c].rowspan; i++)
+                for (j = c; j < c + m_CellInfo[r][c].colspan; j++)
+                    m_CellInfo[i][j].flag = cellSpan;
+            m_CellInfo[r][c].flag = cellUsed;
+        }
+    }
+
+    //background color:
+    {
+        wxColour bk = m_rBkg;
+        if (tag.HasParam(wxT("BGCOLOR")))
+            tag.GetParamAsColour(wxT("BGCOLOR"), &bk);
+        if (bk.Ok())
+            cell->SetBackgroundColour(bk);
+    }
+    if (m_HasBorders)
+        cell->SetBorder(TABLE_BORDER_CLR_2, TABLE_BORDER_CLR_1);
+
+    // vertical alignment:
+    {
+        wxString valign;
+        if (tag.HasParam(wxT("VALIGN")))
+            valign = tag.GetParam(wxT("VALIGN"));
+        else
+            valign = m_tValign;
+        valign.MakeUpper();
+        if (valign == wxT("TOP"))
+            m_CellInfo[r][c].valign = wxHTML_ALIGN_TOP;
+        else if (valign == wxT("BOTTOM"))
+            m_CellInfo[r][c].valign = wxHTML_ALIGN_BOTTOM;
+        else m_CellInfo[r][c].valign = wxHTML_ALIGN_CENTER;
+    }
+
+    cell->SetIndent(m_Padding, wxHTML_INDENT_ALL, wxHTML_UNITS_PIXELS);
+}
+
+void wxHtmlTableCell::ComputeMinMaxWidths()
+{
+    if (m_NumCols == 0 || m_ColsInfo[0].minWidth != -1) return;
+    
+    int left, right, width;
+
+    for (int c = 0; c < m_NumCols; c++)
+    {
+        for (int r = 0; r < m_NumRows; r++)
+        {
+            cellStruct& cell = m_CellInfo[r][c];
+            if (cell.flag == cellUsed)
+            {
+                cell.cont->Layout(2*m_Padding + 1);
+                cell.cont->GetHorizontalConstraints(&left, &right);
+                width = right - left;
+                width -= (cell.colspan-1) * m_Spacing;
+                // HTML 4.0 says it is acceptable to distribute min/max
+                // width of spanning cells evently
+                width /= cell.colspan;
+                for (int j = 0; j < cell.colspan; j++)
+                    if (width > m_ColsInfo[c+j].minWidth)
+                        m_ColsInfo[c+j].minWidth = width;
+            }
+        }
+    }
+    
+    // FIXME -- compute maxWidth as well. Not needed yet, so there's no
+    //          point in computing it. 
+}
+
+
+void wxHtmlTableCell::Layout(int w)
+{
+    ComputeMinMaxWidths();
+    
+    wxHtmlCell::Layout(w);
+
+    /*
+
+    WIDTH ADJUSTING :
+
+    */
+
+    if (m_WidthFloatUnits == wxHTML_UNITS_PERCENT)
+    {
+        if (m_WidthFloat < 0) m_Width = (100 + m_WidthFloat) * w / 100;
+        else m_Width = m_WidthFloat * w / 100;
+    }
+    else
+    {
+        if (m_WidthFloat < 0) m_Width = w + m_WidthFloat;
+        else m_Width = m_WidthFloat;
+    }
+
+
+    /*
+
+    LAYOUTING :
+
+    */
+
+    /* 1.  setup columns widths: */
+    {
+        int wpix = m_Width - (m_NumCols + 1) * m_Spacing;
+        int i, j;
+
+        // 1a. setup fixed-width columns:
+        for (i = 0; i < m_NumCols; i++)
+            if (m_ColsInfo[i].units == wxHTML_UNITS_PIXELS)
+            {
+                m_ColsInfo[i].pixwidth = wxMax(m_ColsInfo[i].width, 
+                                               m_ColsInfo[i].minWidth);
+                wpix -= m_ColsInfo[i].pixwidth;
+            }
+
+        // 1b. setup floating-width columns:
+        int wtemp = 0;
+        for (i = 0; i < m_NumCols; i++)
+            if ((m_ColsInfo[i].units == wxHTML_UNITS_PERCENT) && (m_ColsInfo[i].width != 0))
+            {
+                m_ColsInfo[i].pixwidth = wxMax(m_ColsInfo[i].width * wpix / 100,
+                                               m_ColsInfo[i].minWidth);
+                wtemp += m_ColsInfo[i].pixwidth;
+            }
+        wpix -= wtemp;
+
+        // 1c. setup defalut columns (no width specification supplied):
+        // NOTE! This algorithm doesn't conform to HTML standard : it assigns equal widths
+        // instead of optimal
+        for (i = j = 0; i < m_NumCols; i++)
+            if (m_ColsInfo[i].width == 0) j++;
+        for (i = 0; i < m_NumCols; i++)
+            if (m_ColsInfo[i].width == 0)
+                m_ColsInfo[i].pixwidth = wpix / j;
+    }
+
+    /* 2.  compute positions of columns: */
+    {
+        int wpos = m_Spacing;
+        for (int i = 0; i < m_NumCols; i++)
+        {
+            m_ColsInfo[i].leftpos = wpos;
+            wpos += m_ColsInfo[i].pixwidth + m_Spacing;
+        }
+    }
+
+    /* 3.  sub-layout all cells: */
+    {
+        int *ypos = new int[m_NumRows + 1];
+
+        int actcol, actrow;
+        int fullwid;
+        wxHtmlContainerCell *actcell;
+
+        ypos[0] = m_Spacing;
+        for (actrow = 1; actrow <= m_NumRows; actrow++) ypos[actrow] = -1;
+        for (actrow = 0; actrow < m_NumRows; actrow++)
+        {
+            if (ypos[actrow] == -1) ypos[actrow] = ypos[actrow-1];
+            // 3a. sub-layout and detect max height:
+
+            for (actcol = 0; actcol < m_NumCols; actcol++) {
+                if (m_CellInfo[actrow][actcol].flag != cellUsed) continue;
+                actcell = m_CellInfo[actrow][actcol].cont;
+                fullwid = 0;
+                for (int i = actcol; i < m_CellInfo[actrow][actcol].colspan + actcol; i++)
+                    fullwid += m_ColsInfo[i].pixwidth;
+                fullwid += (m_CellInfo[actrow][actcol].colspan - 1) * m_Spacing;
+                actcell->SetMinHeight(m_CellInfo[actrow][actcol].minheight, m_CellInfo[actrow][actcol].valign);
+                actcell->Layout(fullwid);
+
+                if (ypos[actrow] + actcell->GetHeight() + m_CellInfo[actrow][actcol].rowspan * m_Spacing > ypos[actrow + m_CellInfo[actrow][actcol].rowspan])
+                    ypos[actrow + m_CellInfo[actrow][actcol].rowspan] =
+                            ypos[actrow] + actcell->GetHeight() + m_CellInfo[actrow][actcol].rowspan * m_Spacing;
+            }
+        }
+
+        for (actrow = 0; actrow < m_NumRows; actrow++)
+        {
+            // 3b. place cells in row & let'em all have same height:
+
+            for (actcol = 0; actcol < m_NumCols; actcol++)
+            {
+                if (m_CellInfo[actrow][actcol].flag != cellUsed) continue;
+                actcell = m_CellInfo[actrow][actcol].cont;
+                actcell->SetMinHeight(
+                                 ypos[actrow + m_CellInfo[actrow][actcol].rowspan] - ypos[actrow] -  m_Spacing,
+                                 m_CellInfo[actrow][actcol].valign);
+                fullwid = 0;
+                for (int i = actcol; i < m_CellInfo[actrow][actcol].colspan + actcol; i++)
+                    fullwid += m_ColsInfo[i].pixwidth;
+                fullwid += (m_CellInfo[actrow][actcol].colspan - 1) * m_Spacing;
+                actcell->Layout(fullwid);
+                actcell->SetPos(m_ColsInfo[actcol].leftpos, ypos[actrow]);
+            }
+        }
+        m_Height = ypos[m_NumRows];
+        delete[] ypos;
+    }
+}
+
+
+
+
+
+
+//-----------------------------------------------------------------------------
+// The tables handler:
+//-----------------------------------------------------------------------------
+
+
+TAG_HANDLER_BEGIN(TABLE, "TABLE,TR,TD,TH")
+
+    TAG_HANDLER_VARS
+        wxHtmlTableCell* m_Table;
+        wxString m_tAlign, m_rAlign;
+
+    TAG_HANDLER_CONSTR(TABLE)
+    {
+        m_Table = NULL;
+        m_tAlign = m_rAlign = wxEmptyString;
+    }
+
+
+    TAG_HANDLER_PROC(tag)
+    {
+        wxHtmlContainerCell *c;
+
+        // new table started, backup upper-level table (if any) and create new:
+        if (tag.GetName() == wxT("TABLE"))
+        {
+            wxHtmlTableCell *oldt = m_Table;
+            wxHtmlContainerCell *oldcont;
+
+            oldcont = c = m_WParser->OpenContainer();
+
+            c->SetWidthFloat(tag, m_WParser->GetPixelScale());
+            m_Table = new wxHtmlTableCell(c, tag, m_WParser->GetPixelScale());
+            int oldAlign = m_WParser->GetAlign();
+            m_tAlign = wxEmptyString;
+            if (tag.HasParam(wxT("ALIGN")))
+                m_tAlign = tag.GetParam(wxT("ALIGN"));
+
+            ParseInner(tag);
+
+            m_WParser->SetAlign(oldAlign);
+            m_WParser->SetContainer(oldcont);
+            m_WParser->CloseContainer();
+            
+            m_Table = oldt;
+            return TRUE;
+        }
+
+
+        else if (m_Table)
+        {
+            // new row in table
+            if (tag.GetName() == wxT("TR"))
+            {
+                m_Table->AddRow(tag);
+                m_rAlign = m_tAlign;
+                if (tag.HasParam(wxT("ALIGN")))
+                    m_rAlign = tag.GetParam(wxT("ALIGN"));
+            }
+
+            // new cell
+            else
+            {
+                c = m_WParser->SetContainer(new wxHtmlContainerCell(m_Table));
+                m_Table->AddCell(c, tag);
+
+                m_WParser->OpenContainer();
+
+                if (tag.GetName() == wxT("TH")) /*header style*/
+                    m_WParser->SetAlign(wxHTML_ALIGN_CENTER);
+                else
+                    m_WParser->SetAlign(wxHTML_ALIGN_LEFT);
+
+                wxString als;
+
+                als = m_rAlign;
+                if (tag.HasParam(wxT("ALIGN")))
+                    als = tag.GetParam(wxT("ALIGN"));
+                als.MakeUpper();
+                if (als == wxT("RIGHT"))
+                    m_WParser->SetAlign(wxHTML_ALIGN_RIGHT);
+                else if (als == wxT("LEFT"))
+                    m_WParser->SetAlign(wxHTML_ALIGN_LEFT);
+                else if (als == wxT("CENTER"))
+                    m_WParser->SetAlign(wxHTML_ALIGN_CENTER);
+
+                m_WParser->OpenContainer();
+            }
+        }
+        return FALSE;
+    }
+
+TAG_HANDLER_END(TABLE)
+
+
+
+
+
+TAGS_MODULE_BEGIN(Tables)
+
+    TAGS_MODULE_ADD(TABLE)
+
+TAGS_MODULE_END(Tables)
+
+
+#endif

src/html/winpars.cpp

@@ -0,0 +1,519 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        winpars.cpp
+// Purpose:     wxHtmlParser class (generic parser)
+// Author:      Vaclav Slavik
+// RCS-ID:      $Id$
+// Copyright:   (c) 1999 Vaclav Slavik
+// Licence:     wxWindows Licence
+/////////////////////////////////////////////////////////////////////////////
+
+
+#ifdef __GNUG__
+#pragma implementation "winpars.h"
+#endif
+
+#include "wx/wxprec.h"
+
+#include "wx/defs.h"
+#if wxUSE_HTML && wxUSE_STREAMS
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#ifndef WXPRECOMP
+    #include "wx/intl.h"
+    #include "wx/dc.h"
+#endif
+
+#include "wx/html/htmldefs.h"
+#include "wx/html/winpars.h"
+#include "wx/html/htmlwin.h"
+#include "wx/fontmap.h"
+#include "wx/log.h"
+
+
+//-----------------------------------------------------------------------------
+// wxHtmlWinParser
+//-----------------------------------------------------------------------------
+
+
+wxList wxHtmlWinParser::m_Modules;
+
+wxHtmlWinParser::wxHtmlWinParser(wxHtmlWindow *wnd) : wxHtmlParser()
+{
+    m_tmpStrBuf = NULL;
+    m_tmpStrBufSize = 0;
+    m_Window = wnd;
+    m_Container = NULL;
+    m_DC = NULL;
+    m_CharHeight = m_CharWidth = 0;
+    m_UseLink = FALSE;
+#if !wxUSE_UNICODE
+    m_EncConv = NULL;
+    m_InputEnc = wxFONTENCODING_ISO8859_1;
+    m_OutputEnc = wxFONTENCODING_DEFAULT;
+#endif
+
+    {
+        int i, j, k, l, m;
+        for (i = 0; i < 2; i++)
+            for (j = 0; j < 2; j++)
+                for (k = 0; k < 2; k++)
+                    for (l = 0; l < 2; l++)
+                        for (m = 0; m < 7; m++)
+                        {
+                            m_FontsTable[i][j][k][l][m] = NULL;
+                            m_FontsFacesTable[i][j][k][l][m] = wxEmptyString;
+#if !wxUSE_UNICODE
+                            m_FontsEncTable[i][j][k][l][m] = wxFONTENCODING_DEFAULT;
+#endif
+                        }
+
+        SetFonts(wxEmptyString, wxEmptyString, NULL);
+    }
+
+    // fill in wxHtmlParser's tables:
+    wxNode *node = m_Modules.GetFirst();
+    while (node)
+    {
+        wxHtmlTagsModule *mod = (wxHtmlTagsModule*) node->GetData();
+        mod->FillHandlersTable(this);
+        node = node->GetNext();
+    }
+}
+
+wxHtmlWinParser::~wxHtmlWinParser()
+{
+    int i, j, k, l, m;
+
+    for (i = 0; i < 2; i++)
+        for (j = 0; j < 2; j++)
+            for (k = 0; k < 2; k++)
+                for (l = 0; l < 2; l++)
+                    for (m = 0; m < 7; m++)
+                    {
+                        if (m_FontsTable[i][j][k][l][m] != NULL)
+                            delete m_FontsTable[i][j][k][l][m];
+                    }
+#if !wxUSE_UNICODE
+    delete m_EncConv;
+#endif
+    delete[] m_tmpStrBuf;
+}
+
+void wxHtmlWinParser::AddModule(wxHtmlTagsModule *module)
+{
+    m_Modules.Append(module);
+}
+
+void wxHtmlWinParser::RemoveModule(wxHtmlTagsModule *module)
+{
+    m_Modules.DeleteObject(module);
+}
+
+void wxHtmlWinParser::SetFonts(wxString normal_face, wxString fixed_face,
+                               const int *sizes)
+{
+    static int default_sizes[7] =
+        {
+            wxHTML_FONT_SIZE_1,
+			wxHTML_FONT_SIZE_2,
+			wxHTML_FONT_SIZE_3,
+			wxHTML_FONT_SIZE_4,
+			wxHTML_FONT_SIZE_5,
+			wxHTML_FONT_SIZE_6,
+			wxHTML_FONT_SIZE_7
+        };
+    
+    if (sizes == NULL) sizes = default_sizes;
+
+    int i, j, k, l, m;
+
+    for (i = 0; i < 7; i++) m_FontsSizes[i] = sizes[i];
+    m_FontFaceFixed = fixed_face;
+    m_FontFaceNormal = normal_face;
+
+#if !wxUSE_UNICODE
+    SetInputEncoding(m_InputEnc);
+#endif
+
+    for (i = 0; i < 2; i++)
+        for (j = 0; j < 2; j++)
+            for (k = 0; k < 2; k++)
+                for (l = 0; l < 2; l++)
+                    for (m = 0; m < 7; m++) {
+                        if (m_FontsTable[i][j][k][l][m] != NULL)
+                        {
+                            delete m_FontsTable[i][j][k][l][m];
+                            m_FontsTable[i][j][k][l][m] = NULL;
+                        }
+                    }
+}
+
+void wxHtmlWinParser::InitParser(const wxString& source)
+{
+    wxHtmlParser::InitParser(source);
+    wxASSERT_MSG(m_DC != NULL, wxT("no DC assigned to wxHtmlWinParser!!"));
+
+    m_FontBold = m_FontItalic = m_FontUnderlined = m_FontFixed = FALSE;
+    m_FontSize = 3; //default one
+    CreateCurrentFont();           // we're selecting default font into
+    m_DC->GetTextExtent( wxT("H"), &m_CharWidth, &m_CharHeight);
+                /* NOTE : we're not using GetCharWidth/Height() because
+                   of differences under X and win
+                 */
+
+    m_UseLink = FALSE;
+    m_Link = wxHtmlLinkInfo( wxT(""), wxT("") );
+    m_LinkColor.Set(0, 0, 0xFF);
+    m_ActualColor.Set(0, 0, 0);
+    m_Align = wxHTML_ALIGN_LEFT;
+    m_tmpLastWasSpace = FALSE;
+
+    OpenContainer();
+    OpenContainer();
+
+#if !wxUSE_UNICODE
+    wxString charset = ExtractCharsetInformation(source);
+    if (!charset.empty())
+    {
+        wxFontEncoding enc = wxFontMapper::Get()->CharsetToEncoding(charset);
+        if (enc != wxFONTENCODING_SYSTEM)
+          SetInputEncoding(enc);
+    }
+#endif
+
+    m_Container->InsertCell(new wxHtmlColourCell(m_ActualColor));
+    m_Container->InsertCell(new wxHtmlFontCell(CreateCurrentFont()));
+}
+
+void wxHtmlWinParser::DoneParser()
+{
+    m_Container = NULL;
+#if !wxUSE_UNICODE
+    SetInputEncoding(wxFONTENCODING_ISO8859_1); // for next call
+#endif
+    wxHtmlParser::DoneParser();
+}
+
+wxObject* wxHtmlWinParser::GetProduct()
+{
+    wxHtmlContainerCell *top;
+
+    CloseContainer();
+    OpenContainer();
+
+    top = m_Container;
+    while (top->GetParent()) top = top->GetParent();
+    return top;
+}
+
+wxFSFile *wxHtmlWinParser::OpenURL(wxHtmlURLType type,
+                                   const wxString& url) const
+{
+    // FIXME - normalize the URL to full path before passing to
+    //         OnOpeningURL!!
+    if ( m_Window )
+    {
+        wxString myurl(url);
+        wxHtmlOpeningStatus status;
+        for (;;)
+        {
+            wxString redirect;
+            status = m_Window->OnOpeningURL(type, myurl, &redirect);
+            if ( status != wxHTML_REDIRECT )
+                break;
+
+            myurl = redirect;
+        }
+
+        if ( status == wxHTML_BLOCK )
+            return NULL;
+
+        return GetFS()->OpenFile(myurl);
+    }
+
+    return wxHtmlParser::OpenURL(type, url);
+}
+
+void wxHtmlWinParser::AddText(const wxChar* txt)
+{
+    wxHtmlCell *c;
+    size_t i = 0,
+           x,
+           lng = wxStrlen(txt);
+    register wxChar d;
+    int templen = 0;
+    wxChar nbsp = GetEntitiesParser()->GetCharForCode(160 /* nbsp */);
+
+    if (lng+1 > m_tmpStrBufSize)
+    {
+        delete[] m_tmpStrBuf;
+        m_tmpStrBuf = new wxChar[lng+1];
+        m_tmpStrBufSize = lng+1;
+    }
+    wxChar *temp = m_tmpStrBuf;
+
+    if (m_tmpLastWasSpace)
+    {
+        while ((i < lng) &&
+               ((txt[i] == wxT('\n')) || (txt[i] == wxT('\r')) || (txt[i] == wxT(' ')) ||
+                (txt[i] == wxT('\t')))) i++;
+    }
+
+    while (i < lng)
+    {
+        x = 0;
+        d = temp[templen++] = txt[i];
+        if ((d == wxT('\n')) || (d == wxT('\r')) || (d == wxT(' ')) || (d == wxT('\t')))
+        {
+            i++, x++;
+            while ((i < lng) && ((txt[i] == wxT('\n')) || (txt[i] == wxT('\r')) ||
+                                 (txt[i] == wxT(' ')) || (txt[i] == wxT('\t')))) i++, x++;
+        }
+        else i++;
+
+        if (x)
+        {
+            temp[templen-1] = wxT(' ');
+            temp[templen] = 0;
+#if 0 // VS - WHY was this here?!
+            if (templen == 1) continue;
+#endif
+            templen = 0;
+#if !wxUSE_UNICODE
+            if (m_EncConv)
+                m_EncConv->Convert(temp);
+#endif
+            size_t len = wxStrlen(temp);
+            for (size_t j = 0; j < len; j++)
+                if (temp[j] == nbsp)
+                    temp[j] = wxT(' ');
+            c = new wxHtmlWordCell(temp, *(GetDC()));
+            if (m_UseLink)
+                c->SetLink(m_Link);
+            m_Container->InsertCell(c);
+            m_tmpLastWasSpace = TRUE;
+        }
+    }
+
+    if (templen && (templen > 1 || temp[0] != wxT(' ')))
+    {
+        temp[templen] = 0;
+#if !wxUSE_UNICODE
+        if (m_EncConv)
+            m_EncConv->Convert(temp);
+#endif
+        size_t len = wxStrlen(temp);
+        for (size_t j = 0; j < len; j++)
+            if (temp[j] == nbsp)
+                temp[j] = wxT(' ');
+        c = new wxHtmlWordCell(temp, *(GetDC()));
+        if (m_UseLink)
+            c->SetLink(m_Link);
+        m_Container->InsertCell(c);
+        m_tmpLastWasSpace = FALSE;
+    }
+}
+
+
+
+wxHtmlContainerCell* wxHtmlWinParser::OpenContainer()
+{
+    m_Container = new wxHtmlContainerCell(m_Container);
+    m_Container->SetAlignHor(m_Align);
+    m_tmpLastWasSpace = TRUE;
+        /* to avoid space being first character in paragraph */
+    return m_Container;
+}
+
+
+
+wxHtmlContainerCell* wxHtmlWinParser::SetContainer(wxHtmlContainerCell *c)
+{
+    m_tmpLastWasSpace = TRUE;
+        /* to avoid space being first character in paragraph */
+    return m_Container = c;
+}
+
+
+
+wxHtmlContainerCell* wxHtmlWinParser::CloseContainer()
+{
+    m_Container = m_Container->GetParent();
+    return m_Container;
+}
+
+
+void wxHtmlWinParser::SetFontSize(int s)
+{
+    if (s < 1) s = 1;
+    else if (s > 7) s = 7;
+    m_FontSize = s;
+}
+
+
+
+wxFont* wxHtmlWinParser::CreateCurrentFont()
+{
+    int fb = GetFontBold(),
+        fi = GetFontItalic(),
+        fu = GetFontUnderlined(),
+        ff = GetFontFixed(),
+        fs = GetFontSize() - 1 /*remap from <1;7> to <0;6>*/ ;
+
+    wxString face = ff ? m_FontFaceFixed : m_FontFaceNormal;
+    wxString *faceptr = &(m_FontsFacesTable[fb][fi][fu][ff][fs]);
+    wxFont **fontptr = &(m_FontsTable[fb][fi][fu][ff][fs]);
+#if !wxUSE_UNICODE
+    wxFontEncoding *encptr = &(m_FontsEncTable[fb][fi][fu][ff][fs]);
+#endif
+
+    if (*fontptr != NULL && (*faceptr != face
+#if !wxUSE_UNICODE
+                             || *encptr != m_OutputEnc
+#endif
+                            ))
+    {
+        delete *fontptr;
+        *fontptr = NULL;
+    }
+
+    if (*fontptr == NULL)
+    {
+        *faceptr = face;
+        *fontptr = new wxFont(
+                       (int) (m_FontsSizes[fs] * m_PixelScale),
+                       ff ? wxMODERN : wxSWISS,
+                       fi ? wxITALIC : wxNORMAL,
+                       fb ? wxBOLD : wxNORMAL,
+                       fu ? TRUE : FALSE, face
+#if wxUSE_UNICODE
+                       );
+#else
+                       , m_OutputEnc);
+        *encptr = m_OutputEnc;
+#endif
+    }
+    m_DC->SetFont(**fontptr);
+    return (*fontptr);
+}
+
+
+
+void wxHtmlWinParser::SetLink(const wxHtmlLinkInfo& link)
+{
+    m_Link = link;
+    m_UseLink = (link.GetHref() != wxEmptyString);
+}
+
+
+void wxHtmlWinParser::SetFontFace(const wxString& face)
+{
+    if (GetFontFixed()) m_FontFaceFixed = face;
+    else m_FontFaceNormal = face;
+
+#if !wxUSE_UNICODE
+    if (m_InputEnc != wxFONTENCODING_DEFAULT)
+        SetInputEncoding(m_InputEnc);
+#endif
+}
+
+
+
+#if !wxUSE_UNICODE
+void wxHtmlWinParser::SetInputEncoding(wxFontEncoding enc)
+{
+    m_InputEnc = m_OutputEnc = wxFONTENCODING_DEFAULT;
+    if (m_EncConv)
+    {
+        delete m_EncConv;
+        m_EncConv = NULL;
+    }
+
+    if (enc == wxFONTENCODING_DEFAULT) return;
+
+    wxFontEncoding altfix, altnorm;
+    bool availfix, availnorm;
+
+    // exact match?
+    availnorm = wxFontMapper::Get()->IsEncodingAvailable(enc, m_FontFaceNormal);
+    availfix = wxFontMapper::Get()->IsEncodingAvailable(enc, m_FontFaceFixed);
+    if (availnorm && availfix)
+        m_OutputEnc = enc;
+
+    // alternatives?
+    else if (wxFontMapper::Get()->GetAltForEncoding(enc, &altnorm, m_FontFaceNormal, FALSE) &&
+             wxFontMapper::Get()->GetAltForEncoding(enc, &altfix, m_FontFaceFixed, FALSE) &&
+             altnorm == altfix)
+        m_OutputEnc = altnorm;
+
+    // at least normal face?
+    else if (availnorm)
+        m_OutputEnc = enc;
+    else if (wxFontMapper::Get()->GetAltForEncoding(enc, &altnorm, m_FontFaceNormal, FALSE))
+        m_OutputEnc = altnorm;
+
+    // okay, let convert to ISO_8859-1, available always
+    else
+        m_OutputEnc = wxFONTENCODING_DEFAULT;
+
+    m_InputEnc = enc;
+    if (m_OutputEnc == wxFONTENCODING_DEFAULT)
+        GetEntitiesParser()->SetEncoding(wxFONTENCODING_SYSTEM);
+    else
+        GetEntitiesParser()->SetEncoding(m_OutputEnc);
+
+    if (m_InputEnc == m_OutputEnc) return;
+
+    m_EncConv = new wxEncodingConverter();
+    if (!m_EncConv->Init(m_InputEnc,
+                           (m_OutputEnc == wxFONTENCODING_DEFAULT) ?
+                                      wxFONTENCODING_ISO8859_1 : m_OutputEnc,
+                           wxCONVERT_SUBSTITUTE))
+    { // total failture :-(
+        wxLogError(_("Failed to display HTML document in %s encoding"),
+                   wxFontMapper::GetEncodingName(enc).c_str());
+        m_InputEnc = m_OutputEnc = wxFONTENCODING_DEFAULT;
+        delete m_EncConv;
+        m_EncConv = NULL;
+    }
+}
+#endif
+
+
+
+
+//-----------------------------------------------------------------------------
+// wxHtmlWinTagHandler
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_ABSTRACT_CLASS(wxHtmlWinTagHandler, wxHtmlTagHandler)
+
+//-----------------------------------------------------------------------------
+// wxHtmlTagsModule
+//-----------------------------------------------------------------------------
+
+// NB: This is *NOT* winpars.cpp's initialization and shutdown code!!
+//     This module is an ancestor for tag handlers modules defined
+//     in m_*.cpp files with TAGS_MODULE_BEGIN...TAGS_MODULE_END construct.
+//
+//     Do not add any winpars.cpp shutdown or initialization code to it,
+//     create a new module instead!
+
+IMPLEMENT_DYNAMIC_CLASS(wxHtmlTagsModule, wxModule)
+
+bool wxHtmlTagsModule::OnInit()
+{
+    wxHtmlWinParser::AddModule(this);
+    return TRUE;
+}
+
+void wxHtmlTagsModule::OnExit()
+{
+    wxHtmlWinParser::RemoveModule(this);
+}
+
+#endif
+

src/xrc/xh_html.cpp

@@ -0,0 +1,83 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_html.cpp
+// Purpose:     XRC resource for wxHtmlWindow
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Bob Mitchell and Verant Interactive
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+ 
+#ifdef __GNUG__
+#pragma implementation "xh_html.h"
+#endif
+
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+    #pragma hdrstop
+#endif
+
+#include "wx/xrc/xh_html.h"
+
+#if wxUSE_HTML
+
+#include "wx/html/htmlwin.h"
+#include "wx/filesys.h"
+
+
+wxHtmlWindowXmlHandler::wxHtmlWindowXmlHandler() 
+: wxXmlResourceHandler() 
+{
+    XRC_ADD_STYLE(wxHW_SCROLLBAR_NEVER);
+    XRC_ADD_STYLE(wxHW_SCROLLBAR_AUTO);
+    AddWindowStyles();
+}
+
+wxObject *wxHtmlWindowXmlHandler::DoCreateResource()
+{
+    XRC_MAKE_INSTANCE(control, wxHtmlWindow)
+
+    control->Create(m_parentAsWindow,
+                    GetID(),
+                    GetPosition(), GetSize(),
+                    GetStyle(wxT("style"), wxHW_SCROLLBAR_AUTO),
+                    GetName());
+
+    if (HasParam(wxT("borders")))
+    {
+        control->SetBorders(GetDimension(wxT("borders")));
+    }
+
+    if (HasParam(wxT("url")))
+    {
+        wxString url = GetParamValue(wxT("url"));
+        wxFileSystem& fsys = GetCurFileSystem();
+        
+        wxFSFile *f = fsys.OpenFile(url);
+        if (f)
+        {
+            control->LoadPage(f->GetLocation());
+            delete f;
+        }
+        else
+            control->LoadPage(url);
+    }
+    
+    else if (HasParam(wxT("htmlcode")))
+    {
+        control->SetPage(GetText(wxT("htmlcode")));
+    }
+
+    SetupWindow(control);
+    
+    return control;
+}
+
+bool wxHtmlWindowXmlHandler::CanHandle(wxXmlNode *node)
+{
+    return IsOfClass(node, wxT("wxHtmlWindow"));
+}
+
+#endif // wxUSE_HTML

wxPython/.cvsignore

@@ -1,24 +0,0 @@
-.DS_Store
-.emacs.desktop
-.gdb_history
-BUILD
-MANIFEST
-_build_dmg
-_build_rpm
-build
-build-dbg
-build-gtk
-build-gtk2
-build-gtk2-dbg.unicode
-build-gtk2.unicode
-build-pkg
-build-pkg-debug
-build-x11
-build.local
-build.unicode
-build_options.py
-dist
-licence
-s.bat
-temp
-update.log

wxPython/SWIG/README.txt

@@ -1,138 +0,0 @@
-SWIG 1.3.x Patches
-==================
-
-This directory holds a set of patches for the CVS version of SWIG that
-are required if you wish to use SWIG for wxPython development, or for
-building your own extension modules that need to interface with
-wxPython.  These have been submitted to SWIG's SourceForge patch
-tracker, so hopefully they will get incorporated into the main SWIG
-source tree soon.
-
-wxPython currently uses the 1.3.27 version of SWIG, which you can get
-from https://sourceforge.net/projects/swig/, plus the patch(es) in
-this directory.  Download the SWIG sources, apply the patch(es) here
-and then build as normal.  I have also have made available a tarball
-containing the patched SWIG sources, plus a win32 binary, located
-here:
-
-	http://starship.python.net/crew/robind/wxPython/tools/
-
-If you want to use the patched version of SWIG and still have the
-stock version available for other projects, then you can configure the
-patched version to use a different --prefix and then specify that
-executable when running setup.py, like this:
-
-	python setup.py SWIG=/path/to/my/swig [other params]
-
-
-
-------------------------------------------------------------------------
-
-swig-1.3.27.patch
-
-    SWIG changed slightly how the runtime type_info data is structured
-    in order to optimize load time and runtime access.  wxPython
-    uncovered a bug in the implementation, so this patch includes the
-    fix that was checked in to CVS for 1.3.28.
-
-    SWIG changed how the import statments are output to the proxy
-    file, but this also caused the order to change (they all moved to
-    the very top of the file) so this broke the module docstring, as
-    well as some behavior that Chandler development is depending upon,
-    so this patch changes back to how it was done in prior releases.
-
-    Bug fix for SWIG's definition of the %makedefault macro.
-
-    Add a SWIG_VERSION macro to the wrapper file so C/C++ code can
-    integrate with different versions of the generated runtime code.
-
-    
-
-------------------------------------------------------------------------
-
-swig-1.3.24.patch (now obsolete)
-
-    A bug was introduced in SWIG 1.3.23 and remains in 1.3.24 that
-    causes compilation problems with wxPython (copies are being made
-    of objects that don't have a copy constructor.)  This patch fixes
-    the code generator to use a reference to the object instead of
-    making a copy.
-
-    Part of my autodoc patch was disabled becuase a unit-test failed.
-    It turns out that the failure was due to a name clash in the unit
-    test itself, so I re-enabled that section of code in this patch.
-
-    Don't generate the autodocs string for a class if it has a
-    docstring attribute.
-
-    Some typos fixed, etc.
-
-
-
-
-------------------------------------------------------------------------
-This patch was added to SWIG's CVS on 10/2/2004 and a modified version
-of it is in 1.3.23 and 1.3.24.
-------------------------------------------------------------------------
-
-
-swig.python-2.patch  
-
-    Adds the following features to the Python Module in SWIG.  See the
-    updated docs in the patch for more details.
-
-            %feature("autodoc")
-            %feature("docstring")
-            %feature("pythonprepend")
-            %feature("pythonappend")
-
-            %module(docstring="string")
-            %module(package="string")
-
-    https://sourceforge.net/tracker/index.php?func=detail&aid=1023309&group_id=1645&atid=301645
-
-
-------------------------------------------------------------------------
-This patch was applied to SWIG's CVS on 07/12/2004 and is in the
-1.3.22 relese.
-------------------------------------------------------------------------
-
-swig.xmlout.patch            Fixes a couple problems in the XML output
-                             of SWIG: an extra "/>" was removed and
-                             newlines in attribute values were changed
-                             to the #10; entity reference so they will
-                             be preserved by parsers.
-
-                             Also, added options for dumping or
-                             writing to a file the XML of the parse
-                             tree *after* other language modules have
-                             been run (previously you could only do
-                             the XML output *instead of* a regular
-                             language module.)
-                             See SF Patch #864689
-
-
-
-------------------------------------------------------------------------
-These patches have already been checked in to SWIG's CVS and are in
-the 1.3.20 release.
-------------------------------------------------------------------------
-
-swig.SplitLines.patch       Adds a new SplitLines function to the DOH
-                            library.  See SF Patch #829317.
-                            *Checked in 10/31/2003*
-
-swig.xml.patch              Adds an option that drastically reduces
-                            the size of the XML output of SWIG, which
-                            increases the performance of the
-                            build_renamers script used in the wxPython
-                            build.  See SF Patch #829319.
-                            *Checked in 10/31/2003*
-
-swig.python.patch           Lots of changes for SWIG's Python module,
-                            especially in how the proxy code is
-                            generated.  See swig.python.patch.txt for
-                            more details, also SF Patch #829325.
-                            *Checked in 10/31/2003*
-
-------------------------------------------------------------------------

wxPython/SWIG/swig-1.3.24.patch

@@ -1,201 +0,0 @@
-? .configure
-? .emacs.desktop
-? .test
-? mytests
-? switch_cvs.py
-? Source/Modules/mystuff
-Index: Doc/Manual/Python.html
-===================================================================
-RCS file: /cvsroot/swig/SWIG/Doc/Manual/Python.html,v
-retrieving revision 1.20
-diff -u -4 -r1.20 Python.html
---- Doc/Manual/Python.html	25 Oct 2004 20:42:08 -0000	1.20
-+++ Doc/Manual/Python.html	15 Apr 2005 23:11:25 -0000
-@@ -3869,10 +3869,10 @@
- 
- <H2><a name="Python_nn65"></a>26.10 Docstring Features</H2>
- 
- 
--Usign docstrings in Python code is becoming more and more important
--ans more tools are coming on the scene that take advantage of them,
-+Using docstrings in Python code is becoming more and more important
-+and more tools are coming on the scene that take advantage of them,
- everything from full-blown documentaiton generators to class browsers
- and popup call-tips in Python-aware IDEs.  Given the way that SWIG
- generates the proxy code by default, your users will normally get
- something like <tt>"function_name(*args)"</tt> in the popup calltip of
-Index: Lib/python/pyrun.swg
-===================================================================
-RCS file: /cvsroot/swig/SWIG/Lib/python/pyrun.swg,v
-retrieving revision 1.53
-diff -u -4 -r1.53 pyrun.swg
---- Lib/python/pyrun.swg	11 Dec 2004 23:38:44 -0000	1.53
-+++ Lib/python/pyrun.swg	15 Apr 2005 23:11:25 -0000
-@@ -455,9 +455,10 @@
- 	} else {
- 	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
- 		       type, otype);
- 	}
--	Py_DECREF(str);
-+	if (str)
-+          Py_DECREF(str);
- 	return;
-       }
-     }   
-     PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
-Index: Source/Modules/python.cxx
-===================================================================
-RCS file: /cvsroot/swig/SWIG/Source/Modules/python.cxx,v
-retrieving revision 1.81
-diff -u -4 -r1.81 python.cxx
---- Source/Modules/python.cxx	13 Dec 2004 22:12:47 -0000	1.81
-+++ Source/Modules/python.cxx	15 Apr 2005 23:11:26 -0000
-@@ -74,9 +74,9 @@
-      -modern         - Use modern python features only, without compatibility code\n\
-      -apply          - Use apply() in proxy classes\n\
-      -new_vwm        - New value wrapper mode, use only when everything else fails \n\
-      -new_repr       - Use more informative version of __repr__ in proxy classes\n\
--     -old_repr       - Use shorter ald old version of __repr__ in proxy classes\n\
-+     -old_repr       - Use shorter and old version of __repr__ in proxy classes\n\
-      -noexcept       - No automatic exception handling\n\
-      -noh            - Don't generate the output header file\n\
-      -noproxy        - Don't generate proxy classes \n\n";
- 
-@@ -749,10 +749,15 @@
-         
-       // Do the param type too?
-       if (showTypes) {
-         type =  SwigType_base(type);
--	lookup = Swig_symbol_clookup(type, 0);
--	if (lookup) type = Getattr(lookup, "sym:name");
-+        SwigType* qt = SwigType_typedef_resolve_all(type);
-+        if (SwigType_isenum(qt))
-+          type = NewString("int");
-+        else {
-+          lookup = Swig_symbol_clookup(type, 0);
-+          if (lookup) type = Getattr(lookup, "sym:name");
-+        }
-         Printf(doc, "%s ", type);
-       }
- 
-       if (name) {
-@@ -853,13 +858,19 @@
-         }
-         
-         switch ( ad_type ) {
-         case AUTODOC_CLASS:
--	  if (CPlusPlus) {
--	    Printf(doc, "Proxy of C++ %s class", class_name);
--	  } else {
--	    Printf(doc, "Proxy of C %s struct", class_name);
--	  }
-+          {
-+            // Only do the autodoc if there isn't a docstring for the class
-+            String* str = Getattr(n, "feature:docstring");
-+            if  (str == NULL || Len(str) == 0) {
-+              if (CPlusPlus) {
-+                Printf(doc, "Proxy of C++ %s class", class_name);
-+              } else {
-+                Printf(doc, "Proxy of C %s struct", class_name);
-+              }
-+            }
-+          }
- 	  break;
-         case AUTODOC_CTOR:
-           if ( Strcmp(class_name, symname) == 0) {
-             String* paramList = make_autodocParmList(n, showTypes);
-@@ -1027,10 +1038,12 @@
-       Printf(methods,"\t { (char *)\"%s\", (PyCFunction) %s, METH_VARARGS | METH_KEYWORDS, ", name, function);
-     
-     if (n && Getattr(n,"feature:callback")) {
-       if (have_docstring(n)) {
-+        String* ds = docstring(n, AUTODOC_FUNC, "", false);
-+        Replaceall(ds, "\n", "\\n");
- 	Printf(methods,"(char *)\"%s\\nswig_ptr: %s\"",
--	       docstring(n, AUTODOC_FUNC, "", false),
-+	       ds,
- 	       Getattr(n,"feature:callback:name"));
-       } else {
- 	Printf(methods,"(char *)\"swig_ptr: %s\"",Getattr(n,"feature:callback:name"));
-       }
-@@ -1950,11 +1963,13 @@
- 	  Printf(f_shadow, modern ? "(object)" : "(_object)");
- 	}
-       }
-       Printf(f_shadow,":\n");
--      if ( have_docstring(n) ) 
--          Printv(f_shadow, tab4, docstring(n, AUTODOC_CLASS, tab4), "\n", NIL);
--      
-+      if ( have_docstring(n) ) {
-+        String* str = docstring(n, AUTODOC_CLASS, tab4);
-+        if (str != NULL && Len(str)) 
-+          Printv(f_shadow, tab4, str, "\n", NIL);
-+      }
-       if (!modern) {
-         Printv(f_shadow,tab4,"__swig_setmethods__ = {}\n",NIL);
-         if (Len(base_class)) {
-           Printf(f_shadow,"%sfor _s in [%s]: __swig_setmethods__.update(_s.__swig_setmethods__)\n",tab4,base_class);
-@@ -2139,11 +2154,11 @@
- 	  Replaceall(pycode,"$action", pyaction);
- 	  Delete(pyaction);
- 	  Printv(f_shadow,pycode,"\n",NIL);
- 	} else {
--	  Printv(f_shadow, tab4, "def ", symname, "(*args", (allow_kwargs ? ", **kwargs" : ""), "): ", NIL);
-+	  Printv(f_shadow, tab4, "def ", symname, "(*args", (allow_kwargs ? ", **kwargs" : ""), "):", NIL);
- 	  if (!have_addtofunc(n)) {
--	    Printv(f_shadow, "return ", funcCallHelper(Swig_name_member(class_name,symname), allow_kwargs), "\n", NIL);
-+	    Printv(f_shadow, " return ", funcCallHelper(Swig_name_member(class_name,symname), allow_kwargs), "\n", NIL);
- 	  } else {
-             Printv(f_shadow, "\n", NIL);
-             if ( have_docstring(n) )
-               Printv(f_shadow, tab8, docstring(n, AUTODOC_METHOD, tab8), "\n", NIL);
-@@ -2175,12 +2190,9 @@
-       return SWIG_OK;
-     }
-     
-     if (shadow) {
--      //
--      // static + autodoc/prepend/append + def args not working!!!, disable by now
--      //
--      if (0 && !classic && !Getattr(n,"feature:python:callback") && have_addtofunc(n)) {
-+      if ( !classic && !Getattr(n,"feature:python:callback") && have_addtofunc(n)) {
-         int kw = (check_kwargs(n) && !Getattr(n,"sym:overloaded")) ? 1 : 0;
-         Printv(f_shadow, tab4, "def ", symname, "(*args", (kw ? ", **kwargs" : ""), "):\n", NIL);
-         if ( have_docstring(n) )
-           Printv(f_shadow, tab8, docstring(n, AUTODOC_STATICFUNC, tab8), "\n", NIL);
-Index: Source/Swig/cwrap.c
-===================================================================
-RCS file: /cvsroot/swig/SWIG/Source/Swig/cwrap.c,v
-retrieving revision 1.51
-diff -u -4 -r1.51 cwrap.c
---- Source/Swig/cwrap.c	4 Dec 2004 08:33:02 -0000	1.51
-+++ Source/Swig/cwrap.c	15 Apr 2005 23:11:26 -0000
-@@ -172,17 +172,26 @@
-       tycode = SwigType_type(type);
-       if (tycode == T_REFERENCE) {
- 	if (pvalue) {
- 	  SwigType *tvalue;
--	  String *defname, *defvalue, *rvalue;
-+	  String *defname, *defvalue, *rvalue, *qvalue;
- 	  rvalue = SwigType_typedef_resolve_all(pvalue);
-+	  qvalue = SwigType_typedef_qualified(rvalue);
- 	  defname = NewStringf("%s_defvalue", lname);
- 	  tvalue = Copy(type);
- 	  SwigType_del_reference(tvalue);
--	  defvalue = NewStringf("%s = %s", SwigType_lstr(tvalue,defname), rvalue);
-+	  tycode = SwigType_type(tvalue);
-+	  if (tycode != T_USER) {
-+	    /* plain primitive type, we copy the the def value */
-+	    defvalue = NewStringf("%s = %s", SwigType_lstr(tvalue,defname),qvalue);
-+	  } else {
-+	    /* user type, we copy the reference value */
-+	    defvalue = NewStringf("%s = %s",SwigType_str(type,defname),qvalue);
-+	  }
- 	  Wrapper_add_localv(w,defname, defvalue, NIL);
- 	  Delete(tvalue);
- 	  Delete(rvalue);
-+	  Delete(qvalue);
- 	  Delete(defname);
- 	  Delete(defvalue);
- 	}
-       }  else if (!pvalue && ((tycode == T_POINTER) || (tycode == T_STRING))) {

wxPython/SWIG/swig-1.3.27.patch

@@ -1,290 +0,0 @@
-Index: Doc/Manual/Python.html
-===================================================================
-RCS file: /cvsroot/swig/SWIG/Doc/Manual/Python.html,v
-retrieving revision 1.31
-diff -u -4 -r1.31 Python.html
---- Doc/Manual/Python.html	6 Oct 2005 21:49:58 -0000	1.31
-+++ Doc/Manual/Python.html	29 Jan 2006 02:05:55 -0000
-@@ -4461,10 +4461,10 @@
- <H2><a name="Python_nn65"></a>26.10 Docstring Features</H2>
- 
- 
- <p>
--Usign docstrings in Python code is becoming more and more important
--ans more tools are coming on the scene that take advantage of them,
-+Using docstrings in Python code is becoming more and more important
-+and more tools are coming on the scene that take advantage of them,
- everything from full-blown documentaiton generators to class browsers
- and popup call-tips in Python-aware IDEs.  Given the way that SWIG
- generates the proxy code by default, your users will normally get
- something like <tt>"function_name(*args)"</tt> in the popup calltip of
-Index: Lib/swig.swg
-===================================================================
-RCS file: /cvsroot/swig/SWIG/Lib/swig.swg,v
-retrieving revision 1.49
-diff -u -4 -r1.49 swig.swg
---- Lib/swig.swg	15 Oct 2005 00:15:30 -0000	1.49
-+++ Lib/swig.swg	29 Jan 2006 02:05:55 -0000
-@@ -51,9 +51,9 @@
- 
- #define %nodefault       %feature("nodefault","1")
- #define %default         %feature("nodefault","0")
- #define %clearnodefault  %feature("nodefault","")
--#define %makedefault     %cleardefault
-+#define %makedefault     %clearnodefault
- 
- /* the %exception directive */
- 
- #ifdef SWIGCSHARP
-Index: Lib/swiginit.swg
-===================================================================
-RCS file: /cvsroot/swig/SWIG/Lib/swiginit.swg,v
-retrieving revision 1.5
-diff -u -4 -r1.5 swiginit.swg
---- Lib/swiginit.swg	12 Sep 2005 23:25:03 -0000	1.5
-+++ Lib/swiginit.swg	29 Jan 2006 02:05:55 -0000
-@@ -40,14 +40,19 @@
- **/
- 
- #ifdef __cplusplus
- extern "C" {
-+#if 0
-+} /* c-mode */
-+#endif
-+#endif
-+
-+#if 0
-+#define SWIGRUNTIME_DEBUG
- #endif
- 
- SWIGRUNTIME void
- SWIG_InitializeModule(void *clientdata) {
--  swig_type_info *type, *ret;
--  swig_cast_info *cast;
-   size_t i;
-   swig_module_info *module_head;
-   static int init_run = 0;
- 
-@@ -71,18 +76,35 @@
-     SWIG_SetModule(clientdata, &swig_module);
-   }
- 		 
-   /* Now work on filling in swig_module.types */
-+#ifdef SWIGRUNTIME_DEBUG
-+  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
-+#endif
-   for (i = 0; i < swig_module.size; ++i) {
--    type = 0;
-+    swig_type_info *type = 0;
-+    swig_type_info *ret;
-+    swig_cast_info *cast;
-+  
-+#ifdef SWIGRUNTIME_DEBUG
-+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
-+#endif
- 
-     /* if there is another module already loaded */
-     if (swig_module.next != &swig_module) {
-       type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
-     }
-     if (type) {
-       /* Overwrite clientdata field */
--      if (swig_module.type_initial[i]->clientdata) type->clientdata = swig_module.type_initial[i]->clientdata;
-+#ifdef SWIGRUNTIME_DEBUG
-+      printf("SWIG_InitializeModule: found type %s\n", type->name);
-+#endif
-+      if (swig_module.type_initial[i]->clientdata) {
-+	type->clientdata = swig_module.type_initial[i]->clientdata;
-+#ifdef SWIGRUNTIME_DEBUG
-+      printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
-+#endif
-+      }
-     } else {
-       type = swig_module.type_initial[i];
-     }
- 
-@@ -91,31 +113,66 @@
-     while (cast->type) {
-     
-       /* Don't need to add information already in the list */
-       ret = 0;
-+#ifdef SWIGRUNTIME_DEBUG
-+      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
-+#endif
-       if (swig_module.next != &swig_module) {
-         ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
-+#ifdef SWIGRUNTIME_DEBUG
-+	if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
-+#endif
-       }
--      if (ret && type == swig_module.type_initial[i]) {
--        cast->type = ret;
--        ret = 0;
-+      if (ret) {
-+	if (type == swig_module.type_initial[i]) {
-+#ifdef SWIGRUNTIME_DEBUG
-+	  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
-+#endif
-+	  cast->type = ret;
-+	  ret = 0;
-+	} else {
-+	  /* Check for casting already in the list */
-+	  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
-+#ifdef SWIGRUNTIME_DEBUG
-+	  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
-+#endif
-+	  if (!ocast) ret = 0;
-+	}
-       }
--      
-+
-       if (!ret) {
-+#ifdef SWIGRUNTIME_DEBUG
-+	printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
-+#endif
-         if (type->cast) {
-           type->cast->prev = cast;
-           cast->next = type->cast;
-         }
-         type->cast = cast;
-       }
--
-       cast++;
-     }
--
-     /* Set entry in modules->types array equal to the type */
-     swig_module.types[i] = type;
-   }
-   swig_module.types[i] = 0;
-+
-+#ifdef SWIGRUNTIME_DEBUG
-+  printf("**** SWIG_InitializeModule: Cast List ******\n");
-+  for (i = 0; i < swig_module.size; ++i) {
-+    int j = 0;
-+    swig_cast_info *cast = swig_module.cast_initial[i];
-+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
-+    while (cast->type) {
-+      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
-+      cast++;
-+      ++j;
-+    }
-+  printf("---- Total casts: %d\n",j);
-+  }
-+  printf("**** SWIG_InitializeModule: Cast List ******\n");
-+#endif
- }
- 
- /* This function will propagate the clientdata field of type to
- * any new swig_type_info structures that have been added into the list
-@@ -145,6 +202,9 @@
-   }
- }
- 
- #ifdef __cplusplus
-+#if 0
-+{ /* c-mode */
-+#endif
- }
- #endif
-Index: Source/Modules/python.cxx
-===================================================================
-RCS file: /cvsroot/swig/SWIG/Source/Modules/python.cxx,v
-retrieving revision 1.107
-diff -u -4 -r1.107 python.cxx
---- Source/Modules/python.cxx	7 Oct 2005 13:17:41 -0000	1.107
-+++ Source/Modules/python.cxx	29 Jan 2006 02:05:56 -0000
-@@ -36,9 +36,8 @@
- static  File         *f_directors_h = 0;
- static  File         *f_init = 0;
- static  File         *f_shadow_py = 0;
- static  String       *f_shadow = 0;
--static  String       *f_shadow_imports = 0;
- static  String       *f_shadow_stubs = 0;
- 
- static  String       *methods;
- static  String       *class_name;
-@@ -281,8 +280,20 @@
-     Swig_banner(f_runtime);
- 
-     Printf(f_runtime,"#define SWIGPYTHON\n");
- 
-+    String *package_version = NewString(PACKAGE_VERSION);
-+    char *token = strtok(Char(package_version), ".");
-+    String *vers = NewString("#define SWIG_VERSION 0x");
-+    while (token) {
-+      int len = strlen(token);
-+      Printf(vers, "%s%s", (len == 1) ? "0" : "", token);
-+      token = strtok(NULL, ".");
-+    }
-+    Printf(f_runtime, "%s\n", vers);
-+    Delete(package_version);
-+    Delete(vers);
-+
-     if (directorsEnabled()) {
-       Printf(f_runtime,"#define SWIG_DIRECTORS\n");
-     }
- 
-@@ -322,9 +333,8 @@
-       }
-       Delete(filen); filen = NULL;
- 
-       f_shadow = NewString("");
--      f_shadow_imports = NewString("");
-       f_shadow_stubs = NewString("");
- 
-       Swig_register_filebyname("shadow",f_shadow);
-       Swig_register_filebyname("python",f_shadow);
-@@ -343,8 +353,10 @@
-       if (mod_docstring && Len(mod_docstring)) {
-         Printv(f_shadow, "\n\"\"\"\n", mod_docstring, "\n\"\"\"\n", NIL);
-         Delete(mod_docstring); mod_docstring = NULL;
-       }
-+
-+      Printf(f_shadow,"\nimport %s\n\n", module);
-       
-       /* if (!modern) */
-       /* always needed, a class can be forced to be no-modern, such as an exception */
-       { 
-@@ -445,10 +457,8 @@
-     Printf(f_wrappers,"}\n");
-     Printf(f_wrappers,"#endif\n");
- 
-     if (shadow) {
--      Printf(f_shadow_imports,"\nimport %s\n", module);
--      Printv(f_shadow_py, f_shadow_imports, "\n",NIL);
-       Printv(f_shadow_py, f_shadow, "\n",NIL);
-       Printv(f_shadow_py, f_shadow_stubs, "\n",NIL);
- 
-       Close(f_shadow_py);
-@@ -507,12 +517,9 @@
-         }
- 
-         // finally, output the name of the imported module
- 	Printf(import, "%s\n", modname);
--
--	if (!Strstr(f_shadow_imports, import)) {
--	  Printf(f_shadow_imports, "%s", import);
--	}
-+	Printf(f_shadow, "%s", import);
- 	Delete(import);
-       }
-     }
-     return Language::importDirective(n);
-@@ -774,10 +781,15 @@
-         
-       // Do the param type too?
-       if (showTypes) {
-         type =  SwigType_base(type);
--	lookup = Swig_symbol_clookup(type, 0);
--	if (lookup) type = Getattr(lookup, "sym:name");
-+        SwigType* qt = SwigType_typedef_resolve_all(type);
-+        if (SwigType_isenum(qt))
-+          type = NewString("int");
-+        else {
-+          lookup = Swig_symbol_clookup(type, 0);
-+          if (lookup) type = Getattr(lookup, "sym:name");
-+        }
-         Printf(doc, "%s ", type);
-       }
- 
-       if (name) {

wxPython/b

@@ -1,157 +0,0 @@
-#!/bin/bash
-
-# Are we using bash on win32?  If so source that file and then exit.
-if [ "$OSTYPE" = "cygwin" ]; then
-    source b.win32
-    exit
-fi
-
-
-function getpyver {
-    if [ "$1" = "15" ]; then
-	PYVER=1.5
-    elif [ "$1" = "20" ]; then
-	PYVER=2.0
-    elif [ "$1" = "21" ]; then
-	PYVER=2.1
-    elif [ "$1" = "22" ]; then
-	PYVER=2.2
-    elif [ "$1" = "23" ]; then
-	PYVER=2.3
-    elif [ "$1" = "24" ]; then
-	PYVER=2.4
-    else
-	echo You must specify Python version as first parameter.
-        exit
-    fi
-}
-
-getpyver $1
-shift
-
-python$PYVER -c "import sys;print '\n', sys.version, '\n'"
-
-
-SETUP="python$PYVER -u setup.py"
-FLAGS="USE_SWIG=1 SWIG=/opt/swig/bin/swig" 
-OTHERFLAGS=""
-PORTFLAGS=""
-UNIFLAG="UNICODE=1"
-
-
-
-if [ "$1" = "gtk1" -o "$1" = "gtk" ]; then 
-    PORTFLAGS="WXPORT=gtk"
-    UNIFLAG="UNICODE=0"
-    shift
-elif [ "$1" = "gtk2" ]; then 
-    PORTFLAGS="WXPORT=gtk2"
-    UNIFLAG="UNICODE=1"
-    shift
-fi
-
-for p in $*; do
-    if [ "$p" = "UNICODE=0" -o "$p" = "UNICODE=1" ]; then
-	UNIFLAG=""
-	break
-    fi
-done
-
-FLAGS="$FLAGS $PORTFLAGS $UNIFLAG"
-
-
-
-
-# "c" --> clean
-if [ "$1" =  "c" ]; then
-    shift
-    CMD="$SETUP $FLAGS $OTHERFLAGS clean $*"
-    OTHERCMD="rm -f wx/*.so"
-
-# "d" --> clean extension modules only
-elif [ "$1" = "d" ]; then
-    shift
-    CMD="rm -f wx/*.so"
-
-# "t" --> touch *.i files
-elif [ "$1" = "t" ]; then
-    shift
-    CMD='find . -name "*.i" | xargs touch'
-
-# "i" --> install
-elif [ "$1" = "i" ]; then
-    shift
-    CMD="$SETUP $FLAGS $OTHERFLAGS build_ext install $*"
-
-# "s" --> source dist
-elif [ "$1" = "s" ]; then
-    shift
-    CMD="$SETUP $OTHERFLAGS sdist $*"
-
-# "r" --> rpm dist
-elif [ "$1" = "r" ]; then
-    WXPYVER=`python$PYVER -c "import setup;print setup.VERSION"`
-    for VER in 21 22; do
-	getpyver $VER
-
-	echo "*****************************************************************"
-	echo "*******      Building wxPython for Python $PYVER"
-	echo "*****************************************************************"
-
-	SETUP="python$PYVER -u setup.py"
-
-	# save the original
-	cp setup.py setup.py.save
-
-	# fix up setup.py the way we want...
-	sed "s/BUILD_GLCANVAS = /BUILD_GLCANVAS = 0 #/" < setup.py.save > setup.py.temp
-	sed "s/GL_ONLY = /GL_ONLY = 1 #/" < setup.py.temp > setup.py
-
-	# build wxPython-gl RPM
-	$SETUP $OTHERFLAGS bdist_rpm --binary-only --doc-files README.txt --python=python$PYVER
-			### --requires=python$PYVER
-	rm dist/wxPython-gl*.tar.gz
-
-	# Build wxPython RPM
-	cp setup.py setup.py.temp
-	sed "s/GL_ONLY = /GL_ONLY = 0 #/" < setup.py.temp > setup.py
-	$SETUP $OTHERFLAGS bdist_rpm --binary-only --python=python$PYVER
-			### --requires=python$PYVER
-
-	# put the oringal setup.py back
-	cp setup.py.save setup.py
-	rm setup.py.*
-
-	# rename the binary RPM's
-	mv dist/wxPython-$WXPYVER-1.i386.rpm dist/wxPython-$WXPYVER-1-Py$VER.i386.rpm
-	mv dist/wxPython-gl-$WXPYVER-1.i386.rpm dist/wxPython-gl-$WXPYVER-1-Py$VER.i386.rpm
-
-    done
-
-    # rebuild the source dists without the munched up setup.py
-    $SETUP $OTHERFLAGS bdist_rpm --source-only
-    exit 0
-
-
-# "f" --> FINAL (no debug)
-elif [ "$1" = "f" ]; then
-    shift
-    CMD="$SETUP $FLAGS $OTHERFLAGS build_ext --inplace $*"
-
-# (no command arg) --> normal build for development
-else
-    CMD="$SETUP $FLAGS $OTHERFLAGS build_ext --inplace --debug $*"
-fi
-
-
-echo $CMD
-eval $CMD
-RC=$?
-
-if [ "$RC" = "0" -a  "$OTHERCMD" != "" ]; then
-    echo $OTHERCMD
-    $OTHERCMD
-    RC=$?
-fi
-
-exit $RC

wxPython/b.bat

@@ -1,3 +0,0 @@
-@echo off
-
-call bash.bat -c "b.win32 %*"

wxPython/b.win32

@@ -1,131 +0,0 @@
-#!/bin/bash
-# ----------------------------------------------------------------------
-
-# To Robin: I tried to avoid making any changes to the existing
-# build scripts, but my env requires me to specify Windows paths...
-# if this breaks something at your end, let me know and we can
-# figure out some solution for both of us.
-if [ "$SWIGDIR" = "" ]; then
-  SWIGDIR=$PROJECTS\\SWIG-1.3.27
-fi
-
-
-#  Use non-default python?
-case $1 in
-    21 | 2.1) VER=21; shift ;;
-    22 | 2.2) VER=22; shift ;;
-    23 | 2.3) VER=23; shift ;;
-    24 | 2.4) VER=24; shift ;;
-
-    *) 	VER=24
-esac
-
-PYTHON=$TOOLS/python$VER/python.exe
-
-SETUP="$PYTHON -u setup.py"
-$PYTHON -c "import sys;print '\n', sys.version, '\n'"
-
-
-FLAGS="USE_SWIG=1 SWIG=$SWIGDIR\\swig.exe"
-UNIFLAG="UNICODE=1"
-
-for p in $*; do
-    if [ "$p" = "UNICODE=0" -o "$p" = "UNICODE=1" ]; then
-	UNIFLAG=""
-	break
-    fi
-done
-
-FLAGS="$FLAGS $UNIFLAG"
-
-
-
-
-
-
-# "c" --> clean
-if [ "$1" = "c" ]; then
-    shift
-    CMD="$SETUP $FLAGS clean $@"
-    OTHERCMD="rm wx/*.pyd"
-
-# just remove the *.pyd's
-elif [ "$1" = "d" ]; then
-    shift
-    CMD="rm wx/*.pyd"
-
-# touch all the *.i files so swig will regenerate
-elif [ "$1" = "t" ]; then
-    shift
-    CMD=
-    find . -name "*.i" | xargs -l touch
-
-# "i" --> install
-elif [ "$1" = "i" ]; then
-    shift
-    CMD="$SETUP build install"
-
-# "r" --> make installer
-elif [ "$1" = "r" ]; then
-    shift
-    CMD="$PYTHON -u distrib\make_installer.py $@"
-
-# "s" --> source dist
-elif [ "$1" = "s" ]; then
-    shift
-    CMD="$SETUP sdist"
-
-# "f" --> FINAL
-elif [ "$1" == "f" ]; then
-    shift
-    CMD="$SETUP $FLAGS FINAL=1 build_ext --inplace $@"
-
-# "h" --> HYBRID
-elif [ "$1" = "h" ]; then
-    shift
-    CMD="$SETUP $FLAGS HYBRID=1 build_ext --inplace $@"
-
-# "a" --> make all installers
-elif [ "$1" = "a" ]; then
-    shift
-    CMD=
-
-#     $0 22 d
-#     $0 22 h
-#     $0 22 r
-#     $0 22 d UNICODE=1
-#     $0 22 h UNICODE=1
-#     $0 22 r UNICODE=1
-    
-    $0 23 d
-    $0 23 h
-    $0 23 r
-    $0 23 d UNICODE=1
-    $0 23 h UNICODE=1
-    $0 23 r UNICODE=1
-
-
-# "b" --> both debug and hybrid builds
-elif [ "$1" = "b" ]; then
-    shift
-    CMD="echo Finished!"
-    $0 $VER   $@
-    $0 $VER h $@
-
-# (no command arg) --> normal debug build for development
-else
-    CMD="$SETUP $FLAGS HYBRID=0 build_ext --inplace --debug $@"
-fi
-
-
-
-if [ "$CMD" != "" ]; then
-    echo $CMD
-    $CMD
-fi
-
-if [ "$OTHERCMD" != "" ]; then
-    echo $OTHERCMD
-    $OTHERCMD
-fi
-

wxPython/contrib/.cvsignore

@@ -1 +0,0 @@
-update.log

wxPython/contrib/README

@@ -1,3 +0,0 @@
-These sub directories contain add-on modules that are not part of the
-core wxPython, either because of licensing issues, optional code in
-wxWindows, contrib code in wxWindows, or whatever.

wxPython/contrib/activex/_activex_ex.py

@@ -1,211 +0,0 @@
-
-
-#---------------------------------------------------------------------------
-# Some helper and utility functions for ActiveX
-
-
-t4 = " " * 4
-t8 = " " * 8
-
-def GetAXInfo(ax):
-    """
-    Returns a printable summary of the TypeInfo from the ActiveX instance
-    passed in.
-    """
-
-    def ProcessFuncX(f, out, name):
-        out.append(name)
-        out.append(t4 + "retType:  %s" % f.retType.vt_type)
-        if f.params:
-            out.append(t4 + "params:")
-            for p in f.params:
-                out.append(t8 + p.name)
-                out.append(t8+t4+ "in:%s  out:%s  optional:%s  type:%s" % (p.isIn, p.isOut, p.isOptional, p.vt_type))
-        out.append('')
-
-    def ProcessPropX(p, out):
-        out.append(GernerateAXModule.trimPropName(p.name))
-        out.append(t4+ "type:%s  arg:%s  canGet:%s  canSet:%s" % (p.type.vt_type, p.arg.vt_type, p.canGet, p.canSet))
-        out.append('')
-
-    out = []
-
-    out.append("PROPERTIES")
-    out.append("-"*20)
-    for p in ax.GetAXProperties():
-        ProcessPropX(p, out)
-    out.append('\n\n')
-
-    out.append("METHODS")
-    out.append("-"*20)
-    for m in ax.GetAXMethods():
-        ProcessFuncX(m, out, GernerateAXModule.trimMethodName(m.name))
-    out.append('\n\n')
-
-    out.append("EVENTS")
-    out.append("-"*20)
-    for e in ax.GetAXEvents():
-        ProcessFuncX(e, out, GernerateAXModule.trimEventName(e.name))
-    out.append('\n\n')
-
-    return "\n".join(out)
-
-
-
-class GernerateAXModule:
-    def __init__(self, ax, className, modulePath, moduleName=None, verbose=False):
-        """
-        Make a Python module file with a class that has been specialized
-        for the AcitveX object.
-
-            ax           An instance of the ActiveXWindow class
-            className    The name to use for the new class
-            modulePath   The path where the new module should be written to
-            moduleName   The name of the .py file to create.  If not given
-                         then the className will be used.
-        """
-        import os
-        if moduleName is None:
-            moduleName = className + '.py'
-        filename = os.path.join(modulePath, moduleName)
-        if verbose:
-            print "Creating module in:", filename
-            print "  ProgID:  ", ax.GetCLSID().GetProgIDString()
-            print "  CLSID:   ", ax.GetCLSID().GetCLSIDString()
-            print
-        self.mf = file(filename, "w")
-        self.WriteFileHeader(ax)
-        self.WriteEvents(ax)
-        self.WriteClassHeader(ax, className)
-        self.WriteMethods(ax)
-        self.WriteProperties(ax)
-        self.WriteDocs(ax)
-        self.mf.close()
-        del self.mf
-
-
-    def WriteFileHeader(self, ax):
-        self.write("# This module was generated by the wx.activex.GernerateAXModule class\n"
-                   "# (See also the genaxmodule script.)\n")
-        self.write("import wx")
-        self.write("import wx.activex\n")
-        self.write("clsID = '%s'\nprogID = '%s'\n"
-                   % (ax.GetCLSID().GetCLSIDString(), ax.GetCLSID().GetProgIDString()))
-        self.write("\n")
-
-
-    def WriteEvents(self, ax):
-        events = ax.GetAXEvents()
-        if events:
-            self.write("# Create eventTypes and event binders")
-            for e in events:
-                self.write("wxEVT_%s = wx.activex.RegisterActiveXEvent('%s')"
-                           % (self.trimEventName(e.name), e.name))
-            self.write()
-            for e in events:
-                n = self.trimEventName(e.name)
-                self.write("EVT_%s = wx.PyEventBinder(wxEVT_%s, 1)" % (n,n))
-            self.write("\n")
-
-
-    def WriteClassHeader(self, ax, className):
-        self.write("# Derive a new class from ActiveXWindow")
-        self.write("""\
-class %s(wx.activex.ActiveXWindow):
-    def __init__(self, parent, ID=-1, pos=wx.DefaultPosition,
-                 size=wx.DefaultSize, style=0, name='%s'):
-        wx.activex.ActiveXWindow.__init__(self, parent,
-            wx.activex.CLSID('%s'),
-            ID, pos, size, style, name)
-        """ % (className, className, ax.GetCLSID().GetCLSIDString()) )
-
-
-    def WriteMethods(self, ax):
-        methods = ax.GetAXMethods()
-        if methods:
-            self.write(t4, "# Methods exported by the ActiveX object")
-            for m in methods:
-                name = self.trimMethodName(m.name)
-                self.write(t4, "def %s(self%s):" % (name, self.getParameters(m, True)))
-                self.write(t8, "return self.CallAXMethod('%s'%s)" % (m.name, self.getParameters(m, False)))
-                self.write()
-            
-
-    def WriteProperties(self, ax):
-        props = ax.GetAXProperties()
-        if props:
-            self.write(t4, "# Getters, Setters and properties")
-            for p in props:
-                getterName = setterName = "None"
-                if p.canGet:
-                    getterName = "_get_" + p.name
-                    self.write(t4, "def %s(self):" % getterName)
-                    self.write(t8, "return self.GetAXProp('%s')" % p.name)
-                if p.canSet:
-                    setterName = "_set_" + p.name
-                    self.write(t4, "def %s(self, %s):" % (setterName, p.arg.name))
-                    self.write(t8, "self.SetAXProp('%s', %s)" % (p.name, p.arg.name))
-
-                self.write(t4, "%s = property(%s, %s)" %
-                           (self.trimPropName(p.name), getterName, setterName))
-                self.write()
-                
-
-    def WriteDocs(self, ax):
-        self.write()
-        doc = GetAXInfo(ax)
-        for line in doc.split('\n'):
-            self.write("#  ", line)
-            
-
-
-    def write(self, *args):
-        for a in args:
-            self.mf.write(a)
-        self.mf.write("\n")
-
-
-    def trimEventName(name):
-        if name.startswith("On"):
-            name = name[2:]
-        return name
-    trimEventName = staticmethod(trimEventName)
-
-
-    def trimPropName(name):
-        #name = name[0].lower() + name[1:]
-        name = name.lower()
-        import keyword
-        if name in keyword.kwlist: name += '_'
-        return name
-    trimPropName = staticmethod(trimPropName)
-
-
-    def trimMethodName(name):
-        import keyword
-        if name in keyword.kwlist: name += '_'
-        return name
-    trimMethodName = staticmethod(trimMethodName)
-    
-
-    def getParameters(self, m, withDefaults):
-        import keyword
-        st = ""
-        # collect the input parameters, if both isIn and isOut are
-        # False then assume it is an input paramater
-        params = []
-        for p in m.params:
-            if p.isIn or (not p.isIn and not p.isOut):
-                params.append(p)
-        # did we get any?
-        for p in params:
-            name = p.name
-            if name in keyword.kwlist: name += '_'
-            st += ", "
-            st += name
-            if withDefaults and p.isOptional:
-                st += '=None'
-        return st
-
-
-#---------------------------------------------------------------------------

wxPython/contrib/activex/_activex_rename.i

@@ -1,16 +0,0 @@
-// A bunch of %rename directives generated by BuildRenamers in config.py
-// in order to remove the wx prefix from all global scope names.
-
-#ifndef BUILDING_RENAMERS
-
-%rename(ParamX)                             wxParamX;
-%rename(FuncX)                              wxFuncX;
-%rename(PropX)                              wxPropX;
-%rename(ParamXArray)                        wxParamXArray;
-%rename(FuncXArray)                         wxFuncXArray;
-%rename(PropXArray)                         wxPropXArray;
-%rename(ActiveXWindow)                      wxActiveXWindow;
-%rename(ActiveXEvent)                       wxActiveXEvent;
-%rename(IEHtmlWindowBase)                   wxIEHtmlWindowBase;
-
-#endif

wxPython/contrib/activex/_activex_reverse.txt

@@ -1,2 +0,0 @@
-
-EVT*

wxPython/contrib/activex/activex.py

@@ -1,670 +0,0 @@
-# This file was created automatically by SWIG 1.3.27.
-# Don't modify this file, modify the SWIG interface instead.
-
-import _activex
-
-def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
-    if (name == "this"):
-        if isinstance(value, class_type):
-            self.__dict__[name] = value.this
-            if hasattr(value,"thisown"): self.__dict__["thisown"] = value.thisown
-            del value.thisown
-            return
-    method = class_type.__swig_setmethods__.get(name,None)
-    if method: return method(self,value)
-    if (not static) or hasattr(self,name) or (name == "thisown"):
-        self.__dict__[name] = value
-    else:
-        raise AttributeError("You cannot add attributes to %s" % self)
-
-def _swig_setattr(self,class_type,name,value):
-    return _swig_setattr_nondynamic(self,class_type,name,value,0)
-
-def _swig_getattr(self,class_type,name):
-    method = class_type.__swig_getmethods__.get(name,None)
-    if method: return method(self)
-    raise AttributeError,name
-
-import types
-try:
-    _object = types.ObjectType
-    _newclass = 1
-except AttributeError:
-    class _object : pass
-    _newclass = 0
-del types
-
-
-def _swig_setattr_nondynamic_method(set):
-    def set_attr(self,name,value):
-        if hasattr(self,name) or (name in ("this", "thisown")):
-            set(self,name,value)
-        else:
-            raise AttributeError("You cannot add attributes to %s" % self)
-    return set_attr
-
-
-import _core
-wx = _core 
-__docfilter__ = wx.__DocFilter(globals()) 
-#---------------------------------------------------------------------------
-
-class CLSID(object):
-    """
-    This class wraps the Windows CLSID structure and is used to
-    specify the class of the ActiveX object that is to be created.  A
-    CLSID can be constructed from either a ProgID string, (such as
-    'WordPad.Document.1') or a classID string, (such as
-    '{CA8A9783-280D-11CF-A24D-444553540000}').
-    """
-    def __repr__(self):
-        return "<%s.%s; proxy of C++ CLSID instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __init__(self, *args, **kwargs):
-        """
-        __init__(self, String id) -> CLSID
-
-        This class wraps the Windows CLSID structure and is used to
-        specify the class of the ActiveX object that is to be created.  A
-        CLSID can be constructed from either a ProgID string, (such as
-        'WordPad.Document.1') or a classID string, (such as
-        '{CA8A9783-280D-11CF-A24D-444553540000}').
-        """
-        newobj = _activex.new_CLSID(*args, **kwargs)
-        self.this = newobj.this
-        self.thisown = 1
-        del newobj.thisown
-    def __del__(self, destroy=_activex.delete_CLSID):
-        """__del__(self)"""
-        try:
-            if self.thisown: destroy(self)
-        except: pass
-
-    def GetCLSIDString(*args, **kwargs):
-        """GetCLSIDString(self) -> String"""
-        return _activex.CLSID_GetCLSIDString(*args, **kwargs)
-
-    def GetProgIDString(*args, **kwargs):
-        """GetProgIDString(self) -> String"""
-        return _activex.CLSID_GetProgIDString(*args, **kwargs)
-
-    def __str__(self):   return self.GetCLSIDString() 
-
-class CLSIDPtr(CLSID):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = CLSID
-_activex.CLSID_swigregister(CLSIDPtr)
-
-#---------------------------------------------------------------------------
-
-class ParamX(object):
-    """Proxy of C++ ParamX class"""
-    def __init__(self): raise RuntimeError, "No constructor defined"
-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxParamX instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    flags = property(_activex.ParamX_flags_get)
-    isPtr = property(_activex.ParamX_isPtr_get)
-    isSafeArray = property(_activex.ParamX_isSafeArray_get)
-    isOptional = property(_activex.ParamX_isOptional_get)
-    vt = property(_activex.ParamX_vt_get)
-    name = property(_activex.ParamX_name_get)
-    vt_type = property(_activex.ParamX_vt_type_get)
-
-    isIn = property(_activex.ParamX_IsIn)
-
-    isOut = property(_activex.ParamX_IsOut)
-
-    isRetVal = property(_activex.ParamX_IsRetVal)
-
-
-class ParamXPtr(ParamX):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = ParamX
-_activex.ParamX_swigregister(ParamXPtr)
-
-class FuncX(object):
-    """Proxy of C++ FuncX class"""
-    def __init__(self): raise RuntimeError, "No constructor defined"
-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxFuncX instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    name = property(_activex.FuncX_name_get)
-    memid = property(_activex.FuncX_memid_get)
-    hasOut = property(_activex.FuncX_hasOut_get)
-    retType = property(_activex.FuncX_retType_get)
-    params = property(_activex.FuncX_params_get)
-
-class FuncXPtr(FuncX):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = FuncX
-_activex.FuncX_swigregister(FuncXPtr)
-
-class PropX(object):
-    """Proxy of C++ PropX class"""
-    def __init__(self): raise RuntimeError, "No constructor defined"
-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxPropX instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    name = property(_activex.PropX_name_get)
-    memid = property(_activex.PropX_memid_get)
-    type = property(_activex.PropX_type_get)
-    arg = property(_activex.PropX_arg_get)
-    putByRef = property(_activex.PropX_putByRef_get)
-    canGet = property(_activex.PropX_CanGet)
-
-    canSet = property(_activex.PropX_CanSet)
-
-
-class PropXPtr(PropX):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = PropX
-_activex.PropX_swigregister(PropXPtr)
-
-class ParamXArray(object):
-    """Proxy of C++ ParamXArray class"""
-    def __init__(self): raise RuntimeError, "No constructor defined"
-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxParamXArray instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __nonzero__(*args, **kwargs):
-        """__nonzero__(self) -> bool"""
-        return _activex.ParamXArray___nonzero__(*args, **kwargs)
-
-    def __len__(*args, **kwargs):
-        """__len__(self) -> int"""
-        return _activex.ParamXArray___len__(*args, **kwargs)
-
-    def __getitem__(*args, **kwargs):
-        """__getitem__(self, int idx) -> ParamX"""
-        return _activex.ParamXArray___getitem__(*args, **kwargs)
-
-
-class ParamXArrayPtr(ParamXArray):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = ParamXArray
-_activex.ParamXArray_swigregister(ParamXArrayPtr)
-
-class FuncXArray(object):
-    """Proxy of C++ FuncXArray class"""
-    def __init__(self): raise RuntimeError, "No constructor defined"
-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxFuncXArray instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __nonzero__(*args, **kwargs):
-        """__nonzero__(self) -> bool"""
-        return _activex.FuncXArray___nonzero__(*args, **kwargs)
-
-    def __len__(*args, **kwargs):
-        """__len__(self) -> int"""
-        return _activex.FuncXArray___len__(*args, **kwargs)
-
-    def __getitem__(*args, **kwargs):
-        """__getitem__(self, int idx) -> FuncX"""
-        return _activex.FuncXArray___getitem__(*args, **kwargs)
-
-
-class FuncXArrayPtr(FuncXArray):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = FuncXArray
-_activex.FuncXArray_swigregister(FuncXArrayPtr)
-
-class PropXArray(object):
-    """Proxy of C++ PropXArray class"""
-    def __init__(self): raise RuntimeError, "No constructor defined"
-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxPropXArray instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __nonzero__(*args, **kwargs):
-        """__nonzero__(self) -> bool"""
-        return _activex.PropXArray___nonzero__(*args, **kwargs)
-
-    def __len__(*args, **kwargs):
-        """__len__(self) -> int"""
-        return _activex.PropXArray___len__(*args, **kwargs)
-
-    def __getitem__(*args, **kwargs):
-        """__getitem__(self, int idx) -> PropX"""
-        return _activex.PropXArray___getitem__(*args, **kwargs)
-
-
-class PropXArrayPtr(PropXArray):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = PropXArray
-_activex.PropXArray_swigregister(PropXArrayPtr)
-
-#---------------------------------------------------------------------------
-
-class ActiveXWindow(_core.Window):
-    """
-    ActiveXWindow derives from wxWindow and the constructor accepts a
-    CLSID for the ActiveX Control that should be created.  The
-    ActiveXWindow class simply adds methods that allow you to query
-    some of the TypeInfo exposed by the ActiveX object, and also to
-    get/set properties or call methods by name.  The Python
-    implementation automatically handles converting parameters and
-    return values to/from the types expected by the ActiveX code as
-    specified by the TypeInfo.
-
-    """
-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxActiveXWindow instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __init__(self, *args, **kwargs):
-        """
-        __init__(self, Window parent, CLSID clsId, int id=-1, Point pos=DefaultPosition, 
-            Size size=DefaultSize, long style=0, 
-            String name=PanelNameStr) -> ActiveXWindow
-
-        Creates an ActiveX control from the clsID given and makes it act
-        as much like a regular wx.Window as possible.
-        """
-        newobj = _activex.new_ActiveXWindow(*args, **kwargs)
-        self.this = newobj.this
-        self.thisown = 1
-        del newobj.thisown
-        self._setOORInfo(self)
-
-    def GetCLSID(*args, **kwargs):
-        """
-        GetCLSID(self) -> CLSID
-
-        Return the CLSID used to construct this ActiveX window
-        """
-        return _activex.ActiveXWindow_GetCLSID(*args, **kwargs)
-
-    def GetAXEventCount(*args, **kwargs):
-        """
-        GetAXEventCount(self) -> int
-
-        Number of events defined for this control
-        """
-        return _activex.ActiveXWindow_GetAXEventCount(*args, **kwargs)
-
-    def GetAXEventDesc(*args, **kwargs):
-        """
-        GetAXEventDesc(self, int idx) -> FuncX
-
-        Returns event description by index
-        """
-        return _activex.ActiveXWindow_GetAXEventDesc(*args, **kwargs)
-
-    def GetAXPropCount(*args, **kwargs):
-        """
-        GetAXPropCount(self) -> int
-
-        Number of properties defined for this control
-        """
-        return _activex.ActiveXWindow_GetAXPropCount(*args, **kwargs)
-
-    def GetAXPropDesc(*args):
-        """
-        GetAXPropDesc(self, int idx) -> PropX
-        GetAXPropDesc(self, String name) -> PropX
-        """
-        return _activex.ActiveXWindow_GetAXPropDesc(*args)
-
-    def GetAXMethodCount(*args, **kwargs):
-        """
-        GetAXMethodCount(self) -> int
-
-        Number of methods defined for this control
-        """
-        return _activex.ActiveXWindow_GetAXMethodCount(*args, **kwargs)
-
-    def GetAXMethodDesc(*args):
-        """
-        GetAXMethodDesc(self, int idx) -> FuncX
-        GetAXMethodDesc(self, String name) -> FuncX
-        """
-        return _activex.ActiveXWindow_GetAXMethodDesc(*args)
-
-    def GetAXEvents(*args, **kwargs):
-        """
-        GetAXEvents(self) -> FuncXArray
-
-        Returns a sequence of FuncX objects describing the events
-        available for this ActiveX object.
-        """
-        return _activex.ActiveXWindow_GetAXEvents(*args, **kwargs)
-
-    def GetAXMethods(*args, **kwargs):
-        """
-        GetAXMethods(self) -> FuncXArray
-
-        Returns a sequence of FuncX objects describing the methods
-        available for this ActiveX object.
-        """
-        return _activex.ActiveXWindow_GetAXMethods(*args, **kwargs)
-
-    def GetAXProperties(*args, **kwargs):
-        """
-        GetAXProperties(self) -> PropXArray
-
-        Returns a sequence of PropX objects describing the properties
-        available for this ActiveX object.
-        """
-        return _activex.ActiveXWindow_GetAXProperties(*args, **kwargs)
-
-    def SetAXProp(*args, **kwargs):
-        """
-        SetAXProp(self, String name, PyObject value)
-
-        Set a property of the ActiveX object by name.
-        """
-        return _activex.ActiveXWindow_SetAXProp(*args, **kwargs)
-
-    def GetAXProp(*args, **kwargs):
-        """
-        GetAXProp(self, String name) -> PyObject
-
-        Get the value of an ActiveX property by name.
-        """
-        return _activex.ActiveXWindow_GetAXProp(*args, **kwargs)
-
-    def _CallAXMethod(*args):
-        """
-        _CallAXMethod(self, String name, PyObject args) -> PyObject
-
-        The implementation for CallMethod.  Calls an ActiveX method, by
-        name passing the parameters given in args.
-        """
-        return _activex.ActiveXWindow__CallAXMethod(*args)
-
-    def CallAXMethod(self, name, *args):
-        """
-        Front-end for _CallMethod.  Simply passes all positional args
-        after the name as a single tuple to _CallMethod.
-        """
-        return self._CallAXMethod(name, args)
-
-
-class ActiveXWindowPtr(ActiveXWindow):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = ActiveXWindow
-_activex.ActiveXWindow_swigregister(ActiveXWindowPtr)
-
-#---------------------------------------------------------------------------
-
-
-def RegisterActiveXEvent(*args, **kwargs):
-    """
-    RegisterActiveXEvent(String eventName) -> wxEventType
-
-    Creates a standard wx event ID for the given eventName.
-    """
-    return _activex.RegisterActiveXEvent(*args, **kwargs)
-class ActiveXEvent(_core.CommandEvent):
-    """
-    An instance of ActiveXEvent is sent to the handler for all bound
-    ActiveX events.  Any event parameters from the ActiveX cntrol are
-    turned into attributes of the Python proxy for this event object.
-    Additionally, there is a property called eventName that will
-    return (surprisingly <wink>) the name of the ActiveX event.
-    """
-    def __init__(self): raise RuntimeError, "No constructor defined"
-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxActiveXEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    eventName = property(_activex.ActiveXEvent_EventName)
-
-    def _preCallInit(*args, **kwargs):
-        """_preCallInit(self, PyObject pyself)"""
-        return _activex.ActiveXEvent__preCallInit(*args, **kwargs)
-
-    def _postCallCleanup(*args, **kwargs):
-        """_postCallCleanup(self, PyObject pyself)"""
-        return _activex.ActiveXEvent__postCallCleanup(*args, **kwargs)
-
-
-class ActiveXEventPtr(ActiveXEvent):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = ActiveXEvent
-_activex.ActiveXEvent_swigregister(ActiveXEventPtr)
-
-#---------------------------------------------------------------------------
-
-class IEHtmlWindowBase(ActiveXWindow):
-    def __repr__(self):
-        return "<%s.%s; proxy of C++ wxIEHtmlWindowBase instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-    def __init__(self, *args, **kwargs):
-        newobj = _activex.new_IEHtmlWindowBase(*args, **kwargs)
-        self.this = newobj.this
-        self.thisown = 1
-        del newobj.thisown
-        self._setOORInfo(self)
-
-    def SetCharset(*args, **kwargs): return _activex.IEHtmlWindowBase_SetCharset(*args, **kwargs)
-    def LoadString(*args, **kwargs): return _activex.IEHtmlWindowBase_LoadString(*args, **kwargs)
-    def LoadStream(*args, **kwargs): return _activex.IEHtmlWindowBase_LoadStream(*args, **kwargs)
-    def GetStringSelection(*args, **kwargs): return _activex.IEHtmlWindowBase_GetStringSelection(*args, **kwargs)
-    def GetText(*args, **kwargs): return _activex.IEHtmlWindowBase_GetText(*args, **kwargs)
-
-class IEHtmlWindowBasePtr(IEHtmlWindowBase):
-    def __init__(self, this):
-        self.this = this
-        if not hasattr(self,"thisown"): self.thisown = 0
-        self.__class__ = IEHtmlWindowBase
-_activex.IEHtmlWindowBase_swigregister(IEHtmlWindowBasePtr)
-
-#---------------------------------------------------------------------------
-# Some helper and utility functions for ActiveX
-
-
-t4 = " " * 4
-t8 = " " * 8
-
-def GetAXInfo(ax):
-    """
-    Returns a printable summary of the TypeInfo from the ActiveX instance
-    passed in.
-    """
-
-    def ProcessFuncX(f, out, name):
-        out.append(name)
-        out.append(t4 + "retType:  %s" % f.retType.vt_type)
-        if f.params:
-            out.append(t4 + "params:")
-            for p in f.params:
-                out.append(t8 + p.name)
-                out.append(t8+t4+ "in:%s  out:%s  optional:%s  type:%s" % (p.isIn, p.isOut, p.isOptional, p.vt_type))
-        out.append('')
-
-    def ProcessPropX(p, out):
-        out.append(GernerateAXModule.trimPropName(p.name))
-        out.append(t4+ "type:%s  arg:%s  canGet:%s  canSet:%s" % (p.type.vt_type, p.arg.vt_type, p.canGet, p.canSet))
-        out.append('')
-
-    out = []
-
-    out.append("PROPERTIES")
-    out.append("-"*20)
-    for p in ax.GetAXProperties():
-        ProcessPropX(p, out)
-    out.append('\n\n')
-
-    out.append("METHODS")
-    out.append("-"*20)
-    for m in ax.GetAXMethods():
-        ProcessFuncX(m, out, GernerateAXModule.trimMethodName(m.name))
-    out.append('\n\n')
-
-    out.append("EVENTS")
-    out.append("-"*20)
-    for e in ax.GetAXEvents():
-        ProcessFuncX(e, out, GernerateAXModule.trimEventName(e.name))
-    out.append('\n\n')
-
-    return "\n".join(out)
-
-
-
-class GernerateAXModule:
-    def __init__(self, ax, className, modulePath, moduleName=None, verbose=False):
-        """
-        Make a Python module file with a class that has been specialized
-        for the AcitveX object.
-
-            ax           An instance of the ActiveXWindow class
-            className    The name to use for the new class
-            modulePath   The path where the new module should be written to
-            moduleName   The name of the .py file to create.  If not given
-                         then the className will be used.
-        """
-        import os
-        if moduleName is None:
-            moduleName = className + '.py'
-        filename = os.path.join(modulePath, moduleName)
-        if verbose:
-            print "Creating module in:", filename
-            print "  ProgID:  ", ax.GetCLSID().GetProgIDString()
-            print "  CLSID:   ", ax.GetCLSID().GetCLSIDString()
-            print
-        self.mf = file(filename, "w")
-        self.WriteFileHeader(ax)
-        self.WriteEvents(ax)
-        self.WriteClassHeader(ax, className)
-        self.WriteMethods(ax)
-        self.WriteProperties(ax)
-        self.WriteDocs(ax)
-        self.mf.close()
-        del self.mf
-
-
-    def WriteFileHeader(self, ax):
-        self.write("# This module was generated by the wx.activex.GernerateAXModule class\n"
-                   "# (See also the genaxmodule script.)\n")
-        self.write("import wx")
-        self.write("import wx.activex\n")
-        self.write("clsID = '%s'\nprogID = '%s'\n"
-                   % (ax.GetCLSID().GetCLSIDString(), ax.GetCLSID().GetProgIDString()))
-        self.write("\n")
-
-
-    def WriteEvents(self, ax):
-        events = ax.GetAXEvents()
-        if events:
-            self.write("# Create eventTypes and event binders")
-            for e in events:
-                self.write("wxEVT_%s = wx.activex.RegisterActiveXEvent('%s')"
-                           % (self.trimEventName(e.name), e.name))
-            self.write()
-            for e in events:
-                n = self.trimEventName(e.name)
-                self.write("EVT_%s = wx.PyEventBinder(wxEVT_%s, 1)" % (n,n))
-            self.write("\n")
-
-
-    def WriteClassHeader(self, ax, className):
-        self.write("# Derive a new class from ActiveXWindow")
-        self.write("""\
-class %s(wx.activex.ActiveXWindow):
-    def __init__(self, parent, ID=-1, pos=wx.DefaultPosition,
-                 size=wx.DefaultSize, style=0, name='%s'):
-        wx.activex.ActiveXWindow.__init__(self, parent,
-            wx.activex.CLSID('%s'),
-            ID, pos, size, style, name)
-        """ % (className, className, ax.GetCLSID().GetCLSIDString()) )
-
-
-    def WriteMethods(self, ax):
-        methods = ax.GetAXMethods()
-        if methods:
-            self.write(t4, "# Methods exported by the ActiveX object")
-            for m in methods:
-                name = self.trimMethodName(m.name)
-                self.write(t4, "def %s(self%s):" % (name, self.getParameters(m, True)))
-                self.write(t8, "return self.CallAXMethod('%s'%s)" % (m.name, self.getParameters(m, False)))
-                self.write()
-            
-
-    def WriteProperties(self, ax):
-        props = ax.GetAXProperties()
-        if props:
-            self.write(t4, "# Getters, Setters and properties")
-            for p in props:
-                getterName = setterName = "None"
-                if p.canGet:
-                    getterName = "_get_" + p.name
-                    self.write(t4, "def %s(self):" % getterName)
-                    self.write(t8, "return self.GetAXProp('%s')" % p.name)
-                if p.canSet:
-                    setterName = "_set_" + p.name
-                    self.write(t4, "def %s(self, %s):" % (setterName, p.arg.name))
-                    self.write(t8, "self.SetAXProp('%s', %s)" % (p.name, p.arg.name))
-
-                self.write(t4, "%s = property(%s, %s)" %
-                           (self.trimPropName(p.name), getterName, setterName))
-                self.write()
-                
-
-    def WriteDocs(self, ax):
-        self.write()
-        doc = GetAXInfo(ax)
-        for line in doc.split('\n'):
-            self.write("#  ", line)
-            
-
-
-    def write(self, *args):
-        for a in args:
-            self.mf.write(a)
-        self.mf.write("\n")
-
-
-    def trimEventName(name):
-        if name.startswith("On"):
-            name = name[2:]
-        return name
-    trimEventName = staticmethod(trimEventName)
-
-
-    def trimPropName(name):
-        #name = name[0].lower() + name[1:]
-        name = name.lower()
-        import keyword
-        if name in keyword.kwlist: name += '_'
-        return name
-    trimPropName = staticmethod(trimPropName)
-
-
-    def trimMethodName(name):
-        import keyword
-        if name in keyword.kwlist: name += '_'
-        return name
-    trimMethodName = staticmethod(trimMethodName)
-    
-
-    def getParameters(self, m, withDefaults):
-        import keyword
-        st = ""
-        # collect the input parameters, if both isIn and isOut are
-        # False then assume it is an input paramater
-        params = []
-        for p in m.params:
-            if p.isIn or (not p.isIn and not p.isOut):
-                params.append(p)
-        # did we get any?
-        for p in params:
-            name = p.name
-            if name in keyword.kwlist: name += '_'
-            st += ", "
-            st += name
-            if withDefaults and p.isOptional:
-                st += '=None'
-        return st
-
-
-#---------------------------------------------------------------------------
-
-
-

wxPython/contrib/activex/wxie/IEHtmlStream.h

@@ -1,133 +0,0 @@
-/*
-                wxActiveX Library Licence, Version 3
-                ====================================
-
-  Copyright (C) 2003 Lindsay Mathieson [, ...]
-
-  Everyone is permitted to copy and distribute verbatim copies
-  of this licence document, but changing it is not allowed.
-
-                       wxActiveX LIBRARY LICENCE
-     TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-  
-  This library is free software; you can redistribute it and/or modify it
-  under the terms of the GNU Library General Public Licence as published by
-  the Free Software Foundation; either version 2 of the Licence, or (at
-  your option) any later version.
-  
-  This library is distributed in the hope that it will be useful, but
-  WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library
-  General Public Licence for more details.
-
-  You should have received a copy of the GNU Library General Public Licence
-  along with this software, usually in a file named COPYING.LIB.  If not,
-  write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
-  Boston, MA 02111-1307 USA.
-
-  EXCEPTION NOTICE
-
-  1. As a special exception, the copyright holders of this library give
-  permission for additional uses of the text contained in this release of
-  the library as licenced under the wxActiveX Library Licence, applying
-  either version 3 of the Licence, or (at your option) any later version of
-  the Licence as published by the copyright holders of version 3 of the
-  Licence document.
-
-  2. The exception is that you may use, copy, link, modify and distribute
-  under the user's own terms, binary object code versions of works based
-  on the Library.
-
-  3. If you copy code from files distributed under the terms of the GNU
-  General Public Licence or the GNU Library General Public Licence into a
-  copy of this library, as this licence permits, the exception does not
-  apply to the code that you add in this way.  To avoid misleading anyone as
-  to the status of such modified files, you must delete this exception
-  notice from such code and/or adjust the licensing conditions notice
-  accordingly.
-
-  4. If you write modifications of your own for this library, it is your
-  choice whether to permit this exception to apply to your modifications. 
-  If you do not wish that, you must delete the exception notice from such
-  code and/or adjust the licensing conditions notice accordingly.
-*/
-
-// This module contains the declarations of the stream adapters and such that
-// used to be in IEHtmlWin.cpp, so that they can be used independently in the
-// wxPython wrappers...
-
-
-#ifndef _IEHTMLSTREAM_H_
-#define _IEHTMLSTREAM_H_
-
-
-class IStreamAdaptorBase : public IStream
-{
-private:
-    DECLARE_OLE_UNKNOWN(IStreamAdaptorBase);
-
-public:
-    string prepend;
-
-    IStreamAdaptorBase() {}
-    virtual ~IStreamAdaptorBase() {}
-
-    virtual int Read(char *buf, int cb) = 0;
-
-    // ISequentialStream
-    HRESULT STDMETHODCALLTYPE Read(void __RPC_FAR *pv, ULONG cb, ULONG __RPC_FAR *pcbRead);
-
-    HRESULT STDMETHODCALLTYPE Write(const void __RPC_FAR *pv, ULONG cb, ULONG __RPC_FAR *pcbWritten) {return E_NOTIMPL;}
-
-    // IStream
-    HRESULT STDMETHODCALLTYPE Seek(LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER __RPC_FAR *plibNewPosition) {return E_NOTIMPL;}
-    HRESULT STDMETHODCALLTYPE SetSize(ULARGE_INTEGER libNewSize) {return E_NOTIMPL;}
-    HRESULT STDMETHODCALLTYPE CopyTo(IStream __RPC_FAR *pstm, ULARGE_INTEGER cb, ULARGE_INTEGER __RPC_FAR *pcbRead, ULARGE_INTEGER __RPC_FAR *pcbWritten) {return E_NOTIMPL;}
-    HRESULT STDMETHODCALLTYPE Commit(DWORD grfCommitFlags) {return E_NOTIMPL;}
-    HRESULT STDMETHODCALLTYPE Revert(void) {return E_NOTIMPL;}
-    HRESULT STDMETHODCALLTYPE LockRegion(ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType) {return E_NOTIMPL;}
-    HRESULT STDMETHODCALLTYPE UnlockRegion(ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType) {return E_NOTIMPL;}
-    HRESULT STDMETHODCALLTYPE Stat(STATSTG __RPC_FAR *pstatstg, DWORD grfStatFlag) {return E_NOTIMPL;}
-    HRESULT STDMETHODCALLTYPE Clone(IStream __RPC_FAR *__RPC_FAR *ppstm) {return E_NOTIMPL;}
-};    
-    
-
-
-class IStreamAdaptor : public IStreamAdaptorBase
-{
-private:
-    istream *m_is;
-
-public:
-    IStreamAdaptor(istream *is);
-    ~IStreamAdaptor();
-    int Read(char *buf, int cb);
-};
-
-
-
-class IwxStreamAdaptor : public IStreamAdaptorBase
-{
-private:
-    wxInputStream *m_is;
-
-public:
-    IwxStreamAdaptor(wxInputStream *is);
-    ~IwxStreamAdaptor();
-    int Read(char *buf, int cb);
-};
-
-
-class wxOwnedMemInputStream : public wxMemoryInputStream
-{
-public:
-    char *m_data;
-
-    wxOwnedMemInputStream(char *data, size_t len);
-    ~wxOwnedMemInputStream();
-};
-
-
-wxAutoOleInterface<IHTMLTxtRange> wxieGetSelRange(IOleObject *oleObject);
-
-#endif

wxPython/contrib/activex/wxie/IEHtmlWin.cpp

@@ -1,478 +0,0 @@
-/*
-                wxActiveX Library Licence, Version 3
-                ====================================
-
-  Copyright (C) 2003 Lindsay Mathieson [, ...]
-
-  Everyone is permitted to copy and distribute verbatim copies
-  of this licence document, but changing it is not allowed.
-
-                       wxActiveX LIBRARY LICENCE
-     TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-  
-  This library is free software; you can redistribute it and/or modify it
-  under the terms of the GNU Library General Public Licence as published by
-  the Free Software Foundation; either version 2 of the Licence, or (at
-  your option) any later version.
-  
-  This library is distributed in the hope that it will be useful, but
-  WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library
-  General Public Licence for more details.
-
-  You should have received a copy of the GNU Library General Public Licence
-  along with this software, usually in a file named COPYING.LIB.  If not,
-  write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
-  Boston, MA 02111-1307 USA.
-
-  EXCEPTION NOTICE
-
-  1. As a special exception, the copyright holders of this library give
-  permission for additional uses of the text contained in this release of
-  the library as licenced under the wxActiveX Library Licence, applying
-  either version 3 of the Licence, or (at your option) any later version of
-  the Licence as published by the copyright holders of version 3 of the
-  Licence document.
-
-  2. The exception is that you may use, copy, link, modify and distribute
-  under the user's own terms, binary object code versions of works based
-  on the Library.
-
-  3. If you copy code from files distributed under the terms of the GNU
-  General Public Licence or the GNU Library General Public Licence into a
-  copy of this library, as this licence permits, the exception does not
-  apply to the code that you add in this way.  To avoid misleading anyone as
-  to the status of such modified files, you must delete this exception
-  notice from such code and/or adjust the licensing conditions notice
-  accordingly.
-
-  4. If you write modifications of your own for this library, it is your
-  choice whether to permit this exception to apply to your modifications. 
-  If you do not wish that, you must delete the exception notice from such
-  code and/or adjust the licensing conditions notice accordingly.
-*/
-
-#include "IEHtmlWin.h"
-#include <wx/strconv.h>
-#include <wx/string.h>
-#include <wx/event.h>
-#include <wx/listctrl.h>
-#include <wx/mstream.h>
-#include <oleidl.h>
-#include <winerror.h>
-#include <exdispid.h>
-#include <exdisp.h>
-#include <olectl.h>
-#include <Mshtml.h>
-#include <sstream>
-#include <IEHtmlStream.h>
-using namespace std;
-
-
-
-//////////////////////////////////////////////////////////////////////
-// Stream adapters and such
-
-HRESULT STDMETHODCALLTYPE IStreamAdaptorBase::Read(void __RPC_FAR *pv, ULONG cb, ULONG __RPC_FAR *pcbRead)
-{
-    if (prepend.size() > 0)
-    {
-        int n = wxMin(prepend.size(), cb);
-        prepend.copy((char *) pv, n);
-        prepend = prepend.substr(n);
-        if (pcbRead)
-            *pcbRead = n;
-
-        return S_OK;
-    };
-
-    int rc = Read((char *) pv, cb);
-    if (pcbRead)
-        *pcbRead = rc;
-
-    return S_OK;
-};
-
-DEFINE_OLE_TABLE(IStreamAdaptorBase)
-    OLE_IINTERFACE(IUnknown)
-    OLE_IINTERFACE(ISequentialStream)
-    OLE_IINTERFACE(IStream)
-END_OLE_TABLE;
-
-
-IStreamAdaptor::IStreamAdaptor(istream *is)
-    : IStreamAdaptorBase(), m_is(is)
-{
-    wxASSERT(m_is != NULL);
-}
-
-IStreamAdaptor::~IStreamAdaptor()   
-{
-    delete m_is;
-}
-
-int IStreamAdaptor::Read(char *buf, int cb)
-{
-    m_is->read(buf, cb);
-    return m_is->gcount();
-}
-
-
-IwxStreamAdaptor::IwxStreamAdaptor(wxInputStream *is)
-    : IStreamAdaptorBase(), m_is(is) 
-{
-    wxASSERT(m_is != NULL);
-}
-IwxStreamAdaptor::~IwxStreamAdaptor() 
-{
-    delete m_is;
-}
-
-// ISequentialStream
-int IwxStreamAdaptor::Read(char *buf, int cb)
-{
-    m_is->Read(buf, cb);
-    return m_is->LastRead();
-};
-
-wxOwnedMemInputStream::wxOwnedMemInputStream(char *data, size_t len)
-    :  wxMemoryInputStream(data, len), m_data(data)
-{}
-
-wxOwnedMemInputStream::~wxOwnedMemInputStream() 
-{
-    free(m_data);
-}
-
-
-//////////////////////////////////////////////////////////////////////
-BEGIN_EVENT_TABLE(wxIEHtmlWin, wxActiveX)
-END_EVENT_TABLE()
-
-
-static const CLSID CLSID_MozillaBrowser =
-{ 0x1339B54C, 0x3453, 0x11D2,
-  { 0x93, 0xB9, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00 } };
-
-
-//#define PROGID "Shell.Explorer"
-#define PROGID CLSID_WebBrowser
-//#define PROGID CLSID_MozillaBrowser
-//#define PROGID CLSID_HTMLDocument
-//#define PROGID "MSCAL.Calendar"
-//#define PROGID ""
-//#define PROGID "SoftwareFX.ChartFX.20"
-
-wxIEHtmlWin::wxIEHtmlWin(wxWindow * parent, wxWindowID id,
-        const wxPoint& pos,
-        const wxSize& size,
-        long style,
-        const wxString& name) : 
-    wxActiveX(parent, PROGID, id, pos, size, style, name)
-{
-    SetupBrowser();
-}
-
-
-wxIEHtmlWin::~wxIEHtmlWin()
-{
-}
-
-void wxIEHtmlWin::SetupBrowser()
-{
-    HRESULT hret;
-
-    // Get IWebBrowser2 Interface
-    hret = m_webBrowser.QueryInterface(IID_IWebBrowser2, m_ActiveX);
-    assert(SUCCEEDED(hret));
-
-    // web browser setup
-    m_webBrowser->put_MenuBar(VARIANT_FALSE);
-    m_webBrowser->put_AddressBar(VARIANT_FALSE);
-    m_webBrowser->put_StatusBar(VARIANT_FALSE);
-    m_webBrowser->put_ToolBar(VARIANT_FALSE);
-
-    m_webBrowser->put_RegisterAsBrowser(VARIANT_TRUE);
-    m_webBrowser->put_RegisterAsDropTarget(VARIANT_TRUE);
-
-    m_webBrowser->Navigate( L"about:blank", NULL, NULL, NULL, NULL );
-}
-
-
-void wxIEHtmlWin::SetEditMode(bool seton)
-{
-    m_bAmbientUserMode = ! seton;
-    AmbientPropertyChanged(DISPID_AMBIENT_USERMODE);
-};
-
-bool wxIEHtmlWin::GetEditMode()
-{
-    return ! m_bAmbientUserMode;
-};
-
-
-void wxIEHtmlWin::SetCharset(const wxString& charset)
-{
-    // HTML Document ?
-    IDispatch *pDisp = NULL;
-    HRESULT hret = m_webBrowser->get_Document(&pDisp);
-    wxAutoOleInterface<IDispatch> disp(pDisp);
-
-    if (disp.Ok())
-    {
-        wxAutoOleInterface<IHTMLDocument2> doc(IID_IHTMLDocument2, disp);
-        if (doc.Ok())
-            doc->put_charset((BSTR) (const wchar_t *) charset.wc_str(wxConvUTF8));
-            //doc->put_charset((BSTR) wxConvUTF8.cMB2WC(charset).data());
-    };
-};
-
-
-void wxIEHtmlWin::LoadUrl(const wxString& url)
-{
-    VARIANTARG navFlag, targetFrame, postData, headers;
-    navFlag.vt = VT_EMPTY; 
-    navFlag.vt = VT_I2;
-    navFlag.iVal = navNoReadFromCache;
-    targetFrame.vt = VT_EMPTY;
-    postData.vt = VT_EMPTY;
-    headers.vt = VT_EMPTY;
-
-    HRESULT hret = 0;
-    hret = m_webBrowser->Navigate((BSTR) (const wchar_t *) url.wc_str(wxConvUTF8), 
-        &navFlag, &targetFrame, &postData, &headers);   
-};
-
-
-bool  wxIEHtmlWin::LoadString(const wxString& html)
-{
-    char *data = NULL;
-    size_t len = html.length();
-#ifdef UNICODE
-    len *= 2;
-#endif
-    data = (char *) malloc(len);
-    memcpy(data, html.c_str(), len);
-    return LoadStream(new wxOwnedMemInputStream(data, len));
-};
-
-bool wxIEHtmlWin::LoadStream(IStreamAdaptorBase *pstrm)
-{
-    // need to prepend this as poxy MSHTML will not recognise a HTML comment
-    // as starting a html document and treats it as plain text
-    // Does nayone know how to force it to html mode ?
-    pstrm->prepend = "<html>";
-
-    // strip leading whitespace as it can confuse MSHTML
-    wxAutoOleInterface<IStream> strm(pstrm);
-
-    // Document Interface
-    IDispatch *pDisp = NULL;
-    HRESULT hret = m_webBrowser->get_Document(&pDisp);
-    if (! pDisp)
-        return false;
-    wxAutoOleInterface<IDispatch> disp(pDisp);
-
-
-    // get IPersistStreamInit
-    wxAutoOleInterface<IPersistStreamInit>
-        pPersistStreamInit(IID_IPersistStreamInit, disp);
-
-    if (pPersistStreamInit.Ok())
-    {
-        HRESULT hr = pPersistStreamInit->InitNew();
-        if (SUCCEEDED(hr))
-            hr = pPersistStreamInit->Load(strm);
-
-        return SUCCEEDED(hr);
-    }
-    else
-        return false;
-};
-
-bool  wxIEHtmlWin::LoadStream(istream *is)
-{
-    // wrap reference around stream
-    IStreamAdaptor *pstrm = new IStreamAdaptor(is);
-    pstrm->AddRef();
-
-    return LoadStream(pstrm);
-};
-
-bool wxIEHtmlWin::LoadStream(wxInputStream *is)
-{
-    // wrap reference around stream
-    IwxStreamAdaptor *pstrm = new IwxStreamAdaptor(is);
-    pstrm->AddRef();
-
-    return LoadStream(pstrm);
-};
-
-
-bool wxIEHtmlWin::GoBack()
-{
-    HRESULT hret = 0;
-    hret = m_webBrowser->GoBack();
-    return hret == S_OK;
-}
-
-bool wxIEHtmlWin::GoForward()
-{
-    HRESULT hret = 0;
-    hret = m_webBrowser->GoForward();
-    return hret == S_OK;
-}
-
-bool wxIEHtmlWin::GoHome()
-{
-    try
-    {
-        CallMethod(_T("GoHome"));
-        return true;
-    }
-    catch(exception&)
-    {
-        return false;
-    };
-}
-
-bool wxIEHtmlWin::GoSearch()
-{
-    HRESULT hret = 0;
-    hret = m_webBrowser->GoSearch();
-    return hret == S_OK;
-}
-
-bool wxIEHtmlWin::Refresh(wxIEHtmlRefreshLevel level)
-{
-    VARIANTARG levelArg;
-    HRESULT hret = 0;
-
-    levelArg.vt = VT_I2;
-    levelArg.iVal = level;
-    hret = m_webBrowser->Refresh2(&levelArg);
-    return hret == S_OK;
-}
-
-bool wxIEHtmlWin::Stop()
-{
-    HRESULT hret = 0;
-    hret = m_webBrowser->Stop();
-    return hret == S_OK;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-
-static wxAutoOleInterface<IHTMLSelectionObject> GetSelObject(IOleObject *oleObject)
-{
-    // Query for IWebBrowser interface
-    wxAutoOleInterface<IWebBrowser2> wb(IID_IWebBrowser2, oleObject);
-    if (! wb.Ok())
-        return wxAutoOleInterface<IHTMLSelectionObject>();
-
-    IDispatch *iDisp = NULL;
-    HRESULT hr = wb->get_Document(&iDisp);
-    if (hr != S_OK)
-        return wxAutoOleInterface<IHTMLSelectionObject>();
-
-    // Query for Document Interface
-    wxAutoOleInterface<IHTMLDocument2> hd(IID_IHTMLDocument2, iDisp);
-    iDisp->Release();
-
-    if (! hd.Ok())
-        return wxAutoOleInterface<IHTMLSelectionObject>();
-
-    IHTMLSelectionObject *_so = NULL;
-    hr = hd->get_selection(&_so);
-
-    // take ownership of selection object
-    wxAutoOleInterface<IHTMLSelectionObject> so(_so);
-
-    return so;
-};
-
-wxAutoOleInterface<IHTMLTxtRange> wxieGetSelRange(IOleObject *oleObject)
-{
-    wxAutoOleInterface<IHTMLTxtRange> tr;
-
-    wxAutoOleInterface<IHTMLSelectionObject> so(GetSelObject(oleObject));
-    if (! so)
-        return tr;
-
-    IDispatch *iDisp = NULL;
-    HRESULT hr = so->createRange(&iDisp);
-    if (hr != S_OK)
-        return tr;
-
-    // Query for IHTMLTxtRange interface
-    tr.QueryInterface(IID_IHTMLTxtRange, iDisp);
-    iDisp->Release();
-    return tr;
-};
-
-
-wxString wxIEHtmlWin::GetStringSelection(bool asHTML)
-{
-    wxAutoOleInterface<IHTMLTxtRange> tr(wxieGetSelRange(m_oleObject));
-    if (! tr)
-        return wxEmptyString;
-
-    BSTR text = NULL;
-    HRESULT hr = E_FAIL;
-    
-    if (asHTML)
-        hr = tr->get_htmlText(&text);
-    else
-        hr = tr->get_text(&text);
-    if (hr != S_OK)
-        return wxEmptyString;
-
-    wxString s = text;
-    SysFreeString(text);
-
-    return s;
-};
-
-wxString wxIEHtmlWin::GetText(bool asHTML)
-{
-    if (! m_webBrowser.Ok())
-        return wxEmptyString;
-
-    // get document dispatch interface
-    IDispatch *iDisp = NULL;
-    HRESULT hr = m_webBrowser->get_Document(&iDisp);
-    if (hr != S_OK)
-        return wxEmptyString;
-
-    // Query for Document Interface
-    wxAutoOleInterface<IHTMLDocument2> hd(IID_IHTMLDocument2, iDisp);
-    iDisp->Release();
-
-    if (! hd.Ok())
-        return wxEmptyString;
-
-    // get body element
-    IHTMLElement *_body = NULL;
-    hd->get_body(&_body);
-    if (! _body)
-        return wxEmptyString;
-    wxAutoOleInterface<IHTMLElement> body(_body);
-
-    // get inner text
-    BSTR text = NULL;
-    hr = E_FAIL;
-    
-    if (asHTML)
-        hr = body->get_innerHTML(&text);
-    else
-        hr = body->get_innerText(&text);
-    if (hr != S_OK)
-        return wxEmptyString;
-
-    wxString s = text;
-    SysFreeString(text);
-
-    return s;   
-};

wxPython/contrib/activex/wxie/IEHtmlWin.h

@@ -1,120 +0,0 @@
-/*
-                wxActiveX Library Licence, Version 3
-                ====================================
-
-  Copyright (C) 2003 Lindsay Mathieson [, ...]
-
-  Everyone is permitted to copy and distribute verbatim copies
-  of this licence document, but changing it is not allowed.
-
-                       wxActiveX LIBRARY LICENCE
-     TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-  
-  This library is free software; you can redistribute it and/or modify it
-  under the terms of the GNU Library General Public Licence as published by
-  the Free Software Foundation; either version 2 of the Licence, or (at
-  your option) any later version.
-  
-  This library is distributed in the hope that it will be useful, but
-  WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library
-  General Public Licence for more details.
-
-  You should have received a copy of the GNU Library General Public Licence
-  along with this software, usually in a file named COPYING.LIB.  If not,
-  write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
-  Boston, MA 02111-1307 USA.
-
-  EXCEPTION NOTICE
-
-  1. As a special exception, the copyright holders of this library give
-  permission for additional uses of the text contained in this release of
-  the library as licenced under the wxActiveX Library Licence, applying
-  either version 3 of the Licence, or (at your option) any later version of
-  the Licence as published by the copyright holders of version 3 of the
-  Licence document.
-
-  2. The exception is that you may use, copy, link, modify and distribute
-  under the user's own terms, binary object code versions of works based
-  on the Library.
-
-  3. If you copy code from files distributed under the terms of the GNU
-  General Public Licence or the GNU Library General Public Licence into a
-  copy of this library, as this licence permits, the exception does not
-  apply to the code that you add in this way.  To avoid misleading anyone as
-  to the status of such modified files, you must delete this exception
-  notice from such code and/or adjust the licensing conditions notice
-  accordingly.
-
-  4. If you write modifications of your own for this library, it is your
-  choice whether to permit this exception to apply to your modifications. 
-  If you do not wish that, you must delete the exception notice from such
-  code and/or adjust the licensing conditions notice accordingly.
-*/
-
-/*! \file iehtmlwin.h 
-    \brief implements wxIEHtmlWin window class
-*/ 
-#ifndef _IEHTMLWIN_H_
-#define _IEHTMLWIN_H_
-#pragma warning( disable : 4101 4786)
-#pragma warning( disable : 4786)
-
-
-#include <wx/setup.h>
-#include <wx/wx.h>
-#include <exdisp.h>
-#include <iostream>
-using namespace std;
-
-#include "wxactivex.h"
-
-
-enum wxIEHtmlRefreshLevel 
-{
-    wxIEHTML_REFRESH_NORMAL = 0,
-    wxIEHTML_REFRESH_IFEXPIRED = 1,
-    wxIEHTML_REFRESH_CONTINUE = 2,
-    wxIEHTML_REFRESH_COMPLETELY = 3
-};
-
-class IStreamAdaptorBase;
-
-class wxIEHtmlWin : public wxActiveX
-{
-public:
-    wxIEHtmlWin(wxWindow * parent, wxWindowID id = -1,
-        const wxPoint& pos = wxDefaultPosition,
-        const wxSize& size = wxDefaultSize,
-        long style = 0,
-        const wxString& name = wxPanelNameStr);
-    virtual ~wxIEHtmlWin();
-
-    void LoadUrl(const wxString& url);
-    bool LoadString(const wxString& html);
-    bool LoadStream(istream *strm);
-    bool LoadStream(wxInputStream *is);
-
-    void SetCharset(const wxString& charset);
-    void SetEditMode(bool seton);
-    bool GetEditMode();
-    wxString GetStringSelection(bool asHTML = false);
-    wxString GetText(bool asHTML = false);
-
-    bool GoBack();
-    bool GoForward();
-    bool GoHome();
-    bool GoSearch();
-    bool Refresh(wxIEHtmlRefreshLevel level);
-    bool Stop();
-
-    DECLARE_EVENT_TABLE();
-
-protected:
-    void SetupBrowser();
-    bool LoadStream(IStreamAdaptorBase *pstrm);
-
-    wxAutoOleInterface<IWebBrowser2>        m_webBrowser;
-};
-
-#endif /* _IEHTMLWIN_H_ */

wxPython/contrib/activex/wxie/README.1st.txt

@@ -1,6 +0,0 @@
-The contents of this dir are from the 9-Jan-2004 version of wxie.zip
-downloaded from:
- 
-    http://members.optusnet.com.au/~blackpaw1/wxactivex.html
-
-

wxPython/contrib/activex/wxie/default.doxygen

@@ -1,205 +0,0 @@
-# Doxyfile 1.3-rc2
-
-#---------------------------------------------------------------------------
-# General configuration options
-#---------------------------------------------------------------------------
-PROJECT_NAME           = wxActiveX
-PROJECT_NUMBER         = 
-OUTPUT_DIRECTORY       = 
-OUTPUT_LANGUAGE        = English
-EXTRACT_ALL            = NO
-EXTRACT_PRIVATE        = NO
-EXTRACT_STATIC         = YES
-EXTRACT_LOCAL_CLASSES  = YES
-HIDE_UNDOC_MEMBERS     = YES
-HIDE_UNDOC_CLASSES     = YES
-HIDE_FRIEND_COMPOUNDS  = NO
-HIDE_IN_BODY_DOCS      = NO
-BRIEF_MEMBER_DESC      = YES
-REPEAT_BRIEF           = YES
-ALWAYS_DETAILED_SEC    = NO
-INLINE_INHERITED_MEMB  = NO
-FULL_PATH_NAMES        = NO
-STRIP_FROM_PATH        = 
-INTERNAL_DOCS          = NO
-CASE_SENSE_NAMES       = YES
-SHORT_NAMES            = NO
-HIDE_SCOPE_NAMES       = NO
-VERBATIM_HEADERS       = YES
-SHOW_INCLUDE_FILES     = YES
-JAVADOC_AUTOBRIEF      = YES
-MULTILINE_CPP_IS_BRIEF = NO
-DETAILS_AT_TOP         = YES
-INHERIT_DOCS           = NO
-INLINE_INFO            = YES
-SORT_MEMBER_DOCS       = NO
-DISTRIBUTE_GROUP_DOC   = YES
-TAB_SIZE               = 8
-GENERATE_TODOLIST      = YES
-GENERATE_TESTLIST      = YES
-GENERATE_BUGLIST       = YES
-GENERATE_DEPRECATEDLIST= YES
-ALIASES                = 
-ENABLED_SECTIONS       = 
-MAX_INITIALIZER_LINES  = 30
-OPTIMIZE_OUTPUT_FOR_C  = YES
-OPTIMIZE_OUTPUT_JAVA   = NO
-SHOW_USED_FILES        = YES
-#---------------------------------------------------------------------------
-# configuration options related to warning and progress messages
-#---------------------------------------------------------------------------
-QUIET                  = NO
-WARNINGS               = YES
-WARN_IF_UNDOCUMENTED   = YES
-WARN_IF_DOC_ERROR      = YES
-WARN_FORMAT            = "$file($line): $text"
-WARN_LOGFILE           = 
-#---------------------------------------------------------------------------
-# configuration options related to the input files
-#---------------------------------------------------------------------------
-INPUT                  = .\wxactivex.h .\iehtmlwin.h
-FILE_PATTERNS          = *.cpp \
-                         *.c \
-                         *.h \
-                         *.cxx \
-                         *.idl
-RECURSIVE              = NO
-EXCLUDE                = 
-EXCLUDE_SYMLINKS       = NO
-EXCLUDE_PATTERNS       = 
-EXAMPLE_PATH           = 
-EXAMPLE_PATTERNS       = 
-EXAMPLE_RECURSIVE      = NO
-IMAGE_PATH             = 
-INPUT_FILTER           = 
-FILTER_SOURCE_FILES    = NO
-#---------------------------------------------------------------------------
-# configuration options related to source browsing
-#---------------------------------------------------------------------------
-SOURCE_BROWSER         = YES
-INLINE_SOURCES         = NO
-STRIP_CODE_COMMENTS    = YES
-REFERENCED_BY_RELATION = NO
-REFERENCES_RELATION    = NO
-#---------------------------------------------------------------------------
-# configuration options related to the alphabetical class index
-#---------------------------------------------------------------------------
-ALPHABETICAL_INDEX     = YES
-COLS_IN_ALPHA_INDEX    = 4
-IGNORE_PREFIX          = 
-#---------------------------------------------------------------------------
-# configuration options related to the HTML output
-#---------------------------------------------------------------------------
-GENERATE_HTML          = YES
-HTML_OUTPUT            = doxydoc
-HTML_FILE_EXTENSION    = .html
-HTML_HEADER            = 
-HTML_FOOTER            = 
-HTML_STYLESHEET        = 
-HTML_ALIGN_MEMBERS     = YES
-GENERATE_HTMLHELP      = no
-CHM_FILE               = wxactivex.chm
-HHC_LOCATION           = hhc.exe
-GENERATE_CHI           = NO
-BINARY_TOC             = NO
-TOC_EXPAND             = NO
-DISABLE_INDEX          = NO
-ENUM_VALUES_PER_LINE   = 4
-GENERATE_TREEVIEW      = NO
-TREEVIEW_WIDTH         = 250
-#---------------------------------------------------------------------------
-# configuration options related to the LaTeX output
-#---------------------------------------------------------------------------
-GENERATE_LATEX         = YES
-LATEX_OUTPUT           = latex
-LATEX_CMD_NAME         = latex
-MAKEINDEX_CMD_NAME     = makeindex
-COMPACT_LATEX          = NO
-PAPER_TYPE             = a4wide
-EXTRA_PACKAGES         = 
-LATEX_HEADER           = 
-PDF_HYPERLINKS         = NO
-USE_PDFLATEX           = NO
-LATEX_BATCHMODE        = NO
-#---------------------------------------------------------------------------
-# configuration options related to the RTF output
-#---------------------------------------------------------------------------
-GENERATE_RTF           = NO
-RTF_OUTPUT             = rtf
-COMPACT_RTF            = NO
-RTF_HYPERLINKS         = NO
-RTF_STYLESHEET_FILE    = 
-RTF_EXTENSIONS_FILE    = 
-#---------------------------------------------------------------------------
-# configuration options related to the man page output
-#---------------------------------------------------------------------------
-GENERATE_MAN           = NO
-MAN_OUTPUT             = man
-MAN_EXTENSION          = .3
-MAN_LINKS              = NO
-#---------------------------------------------------------------------------
-# configuration options related to the XML output
-#---------------------------------------------------------------------------
-GENERATE_XML           = NO
-XML_SCHEMA             = 
-XML_DTD                = 
-#---------------------------------------------------------------------------
-# configuration options for the AutoGen Definitions output
-#---------------------------------------------------------------------------
-GENERATE_AUTOGEN_DEF   = NO
-#---------------------------------------------------------------------------
-# configuration options related to the Perl module output
-#---------------------------------------------------------------------------
-GENERATE_PERLMOD       = NO
-PERLMOD_LATEX          = NO
-PERLMOD_PRETTY         = YES
-PERLMOD_MAKEVAR_PREFIX = 
-#---------------------------------------------------------------------------
-# Configuration options related to the preprocessor   
-#---------------------------------------------------------------------------
-ENABLE_PREPROCESSING   = YES
-MACRO_EXPANSION        = NO
-EXPAND_ONLY_PREDEF     = NO
-SEARCH_INCLUDES        = YES
-INCLUDE_PATH           = 
-INCLUDE_FILE_PATTERNS  = 
-PREDEFINED             = 
-EXPAND_AS_DEFINED      = 
-SKIP_FUNCTION_MACROS   = YES
-#---------------------------------------------------------------------------
-# Configuration::addtions related to external references   
-#---------------------------------------------------------------------------
-TAGFILES               = 
-GENERATE_TAGFILE       = 
-ALLEXTERNALS           = NO
-EXTERNAL_GROUPS        = YES
-PERL_PATH              = /usr/bin/perl
-#---------------------------------------------------------------------------
-# Configuration options related to the dot tool   
-#---------------------------------------------------------------------------
-CLASS_DIAGRAMS         = YES
-HIDE_UNDOC_RELATIONS   = YES
-HAVE_DOT               = NO
-CLASS_GRAPH            = YES
-COLLABORATION_GRAPH    = YES
-TEMPLATE_RELATIONS     = YES
-INCLUDE_GRAPH          = YES
-INCLUDED_BY_GRAPH      = YES
-GRAPHICAL_HIERARCHY    = YES
-DOT_IMAGE_FORMAT       = png
-DOT_PATH               = 
-DOTFILE_DIRS           = 
-MAX_DOT_GRAPH_WIDTH    = 1024
-MAX_DOT_GRAPH_HEIGHT   = 1024
-GENERATE_LEGEND        = YES
-DOT_CLEANUP            = YES
-#---------------------------------------------------------------------------
-# Configuration::addtions related to the search engine   
-#---------------------------------------------------------------------------
-SEARCHENGINE           = NO
-CGI_NAME               = search.cgi
-CGI_URL                = 
-DOC_URL                = 
-DOC_ABSPATH            = 
-BIN_ABSPATH            = /usr/local/bin/
-EXT_DOC_PATHS          = 

wxPython/contrib/activex/wxie/license.txt

@@ -1,53 +0,0 @@
-                wxActiveX Library Licence, Version 3
-                ====================================
-
-  Copyright (C) 2003 Lindsay Mathieson [, ...]
-
-  Everyone is permitted to copy and distribute verbatim copies
-  of this licence document, but changing it is not allowed.
-
-                       wxActiveX LIBRARY LICENCE
-     TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-  
-  This library is free software; you can redistribute it and/or modify it
-  under the terms of the GNU Library General Public Licence as published by
-  the Free Software Foundation; either version 2 of the Licence, or (at
-  your option) any later version.
-  
-  This library is distributed in the hope that it will be useful, but
-  WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library
-  General Public Licence for more details.
-
-  You should have received a copy of the GNU Library General Public Licence
-  along with this software, usually in a file named COPYING.LIB.  If not,
-  write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
-  Boston, MA 02111-1307 USA.
-
-  EXCEPTION NOTICE
-
-  1. As a special exception, the copyright holders of this library give
-  permission for additional uses of the text contained in this release of
-  the library as licenced under the wxActiveX Library Licence, applying
-  either version 3 of the Licence, or (at your option) any later version of
-  the Licence as published by the copyright holders of version 3 of the
-  Licence document.
-
-  2. The exception is that you may use, copy, link, modify and distribute
-  under the user's own terms, binary object code versions of works based
-  on the Library.
-
-  3. If you copy code from files distributed under the terms of the GNU
-  General Public Licence or the GNU Library General Public Licence into a
-  copy of this library, as this licence permits, the exception does not
-  apply to the code that you add in this way.  To avoid misleading anyone as
-  to the status of such modified files, you must delete this exception
-  notice from such code and/or adjust the licensing conditions notice
-  accordingly.
-
-  4. If you write modifications of your own for this library, it is your
-  choice whether to permit this exception to apply to your modifications. 
-  If you do not wish that, you must delete the exception notice from such
-  code and/or adjust the licensing conditions notice accordingly.
-
-

wxPython/contrib/activex/wxie/makefile

@@ -1,24 +0,0 @@
-CC = gcc
-
-PROGRAM = wxIE
-
-CFLAGS = -I/m/snowball/icicle/gswd/devenv/include -D__WXMOTIF__
-LFLAGS = -L/m/snowball/icicle/devenv/lib
-
-# implementation
-
-.SUFFIXES:      .o .cpp
-
-SOURCES:sh= /bin/ls *.cpp
-
-OBJECTS = $(SOURCES:.cpp=.o)
-
-.cpp.o :
-	$(CC) -c $(CFLAGS) `wx-config --cflags` -o $@ $<
-
-$(PROGRAM): $(OBJECTS)
-	$(CC) -o $(PROGRAM) $(OBJECTS) $(LFLAGS) `wx-config --libs`
-
-clean:
-	rm -f *.o $(PROGRAM)
-

wxPython/contrib/activex/wxie/makefile.gtk

@@ -1,24 +0,0 @@
-CC = gcc
-
-PROGRAM = wxIE
-
-CFLAGS = -I/m/snowball/icicle/gswd/devenv/include -D__WXGTK__
-LFLAGS = -L/m/snowball/icicle/devenv/lib
-
-# implementation
-
-.SUFFIXES:      .o .cpp
-
-SOURCES:sh= /bin/ls *.cpp
-
-OBJECTS = $(SOURCES:.cpp=.o)
-
-.cpp.o :
-	$(CC) -c $(CFLAGS) `wx-config --cflags` -o $@ $<
-
-$(PROGRAM): $(OBJECTS)
-	$(CC) -o $(PROGRAM) $(OBJECTS) $(LFLAGS) `wx-config --libs`
-
-clean:
-	rm -f *.o $(PROGRAM)
-

wxPython/contrib/activex/wxie/makefile.mtf

@@ -1,24 +0,0 @@
-CC = gcc
-
-PROGRAM = wxIE
-
-CFLAGS = -I/m/snowball/icicle/gswd/devenv/include -D__WXMOTIF__
-LFLAGS = -L/m/snowball/icicle/devenv/lib
-
-# implementation
-
-.SUFFIXES:      .o .cpp
-
-SOURCES:sh= /bin/ls *.cpp
-
-OBJECTS = $(SOURCES:.cpp=.o)
-
-.cpp.o :
-	$(CC) -c $(CFLAGS) `wx-config --cflags` -o $@ $<
-
-$(PROGRAM): $(OBJECTS)
-	$(CC) -o $(PROGRAM) $(OBJECTS) $(LFLAGS) `wx-config --libs`
-
-clean:
-	rm -f *.o $(PROGRAM)
-

wxPython/contrib/activex/wxie/notes.txt

@@ -1,2 +0,0 @@
-Flash needs the following GUID for its event interface
-{D27CDB6D-AE6D-11CF-96B8-444553540000}

wxPython/contrib/activex/wxie/readme.txt

@@ -1,149 +0,0 @@
-Lindsay Mathieson
-Email : <lmathieson@optusnet.com.au>
-
-This is prelimanary stuff - the controls need extra methods and events etc,
-feel free to email with suggestions &/or patches.
-
-Tested with wxWindows 2.3.2.
-Built with MS Visual C++ 6.0 & DevStudio
-Minor use of templates and STL
-
------------------------------------------------------------
-This sample illustrates using wxActiveX and wxIEHtmlWin too:
-1. Host an arbitrary ActiveX control
-1.1 - Capture and logging of all events from control
-2. Specifically host the MSHTML Control
-
-
-wxActiveX:
-==========
-wxActiveX is used to host and siplay any activeX control, all the wxWindows developer
-needs to know is either the ProgID or CLSID of the control in question.
-
-Derived From:
-- wxWindow
-
-Include Files:
-- wxactivex.h
-
-Source Files:
-- wxactivex.cpp
-
-Event Handling:
----------------
-- EVT_ACTIVEX(id, eventName, handler) (handler = void OnActiveX(wxActiveXEvent& event))
-- EVT_ACTIVEX_DISPID(id, eventDispId, handler) (handler = void OnActiveX(wxActiveXEvent& event))
-class wxActiveXEvent : public wxNotifyEvent
-    wxString EventName();
-    int ParamCount() const;
-    wxString ParamType(int idx);
-    wxString ParamName(int idx);
-    wxVariant  operator[] (int idx) const;	// parameter by index
-    wxVariant& operator[] (int idx);
-    wxVariant  operator[] (wxString name) const; // named parameters
-    wxVariant& operator[] (wxString name);
-
-
-Members:
---------
-wxActiveX::wxActiveX(wxWindow * parent, REFCLSID clsid, wxWindowID id = -1);
-- Creates a activeX control identified by clsid
-e.g
-  wxFrame *frame = new wxFrame(this, -1, "test");
-  wxActiveX *X = new wxActiveX(frame, CLSID_WebBrowser);
-
-wxActiveX::wxActiveX(wxWindow * parent, wxString progId, wxWindowID id = -1);
-- Creates a activeX control identified by progId
-e.g.
-  wxFrame *frame = new wxFrame(this, -1, "test");
-  wxActiveX *X = new wxActiveX(frame, "MSCAL.Calendar");
-
-
-wxActiveX::~wxActiveX();
-- Destroys the control
-- disconnects all connection points
-
-- int GetEventCount() const;
-  Number of events generated by control
-
-- const FuncX& GetEvent(int idx) const;
-  Names, Params and Typeinfo for events
-
-HRESULT wxActiveX::ConnectAdvise(REFIID riid, IUnknown *eventSink);
-- Connects a event sink. Connections are automaticlly diconnected in the destructor
-e.g.
-  FS_DWebBrowserEvents2 *events = new FS_DWebBrowserEvents2(iecontrol);
-  hret = iecontrol->ConnectAdvise(DIID_DWebBrowserEvents2, events);
-  if (! SUCCEEDED(hret))
-    delete events;
-
-
-Sample Events:
---------------
-EVT_ACTIVEX(ID_MSHTML, "BeforeNavigate2",   OnMSHTMLBeforeNavigate2X)
-
-void wxIEFrame::OnMSHTMLBeforeNavigate2X(wxActiveXEvent& event)
-{
-  wxString url = event["Url"];
-
-  int rc = wxMessageBox(url, "Allow open url ?", wxYES_NO);
-
-  if (rc != wxYES)
-    event["Cancel"] = true;
-};
-
-
-wxIEHtmlWin:
-============
-wxIEHtmlWin is a specialisation of the wxActiveX control for hosting the MSHTML control.
-
-Derived From:
-- wxActiveX
-- wxWindow
-
-Event Handling:
----------------
-- see wxActiveX
-Members:
---------
-wxIEHtmlWin::wxIEHtmlWin(wxWindow * parent, wxWindowID id = -1);
-- Constructs and initialises the MSHTML control
-- LoadUrl("about:blank") is called
-
-wxIEHtmlWin::~wxIEHtmlWin();
-- destroys the control
-
-void wxIEHtmlWin::LoadUrl(const wxString&);
-- Attempts to browse to the url, the control uses its internal (MS)
-  network streams
-
-bool wxIEHtmlWin::LoadString(wxString html);
-- Load the passed HTML string
-
-bool wxIEHtmlWin::LoadStream(istream *strm);
-- load the passed HTML stream. The control takes ownership of
-  the pointer, deleting when finished.
-
-bool wxIEHtmlWin::LoadStream(wxInputStream *is);
-- load the passed HTML stream. The control takes ownership of
-  the pointer, deleting when finished.
-
-void wxIEHtmlWin::SetCharset(wxString charset);
-- Sets the charset of the loaded document
-
-void wxIEHtmlWin::SetEditMode(bool seton);
-- Sets edit mode. 
-  NOTE: This does work, but is bare bones - we need more events exposed before
-        this is usable as an HTML editor.
-
-bool wxIEHtmlWin::GetEditMode();
-- Returns the edit mode setting
-
-wxString wxIEHtmlWin::GetStringSelection(bool asHTML = false);
-- Returns the currently selected text (plain or HTML text)
-
-wxString GetText(bool asHTML = false);
-- Returns the body text (plain or HTML text)
-
-Lindsay Mathieson
-Email : <lmathieson@optusnet.com.au>

wxPython/contrib/activex/wxie/resource.h

@@ -1,70 +0,0 @@
-/*
-                wxActiveX Library Licence, Version 3
-                ====================================
-
-  Copyright (C) 2003 Lindsay Mathieson [, ...]
-
-  Everyone is permitted to copy and distribute verbatim copies
-  of this licence document, but changing it is not allowed.
-
-                       wxActiveX LIBRARY LICENCE
-     TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-  
-  This library is free software; you can redistribute it and/or modify it
-  under the terms of the GNU Library General Public Licence as published by
-  the Free Software Foundation; either version 2 of the Licence, or (at
-  your option) any later version.
-  
-  This library is distributed in the hope that it will be useful, but
-  WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library
-  General Public Licence for more details.
-
-  You should have received a copy of the GNU Library General Public Licence
-  along with this software, usually in a file named COPYING.LIB.  If not,
-  write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
-  Boston, MA 02111-1307 USA.
-
-  EXCEPTION NOTICE
-
-  1. As a special exception, the copyright holders of this library give
-  permission for additional uses of the text contained in this release of
-  the library as licenced under the wxActiveX Library Licence, applying
-  either version 3 of the Licence, or (at your option) any later version of
-  the Licence as published by the copyright holders of version 3 of the
-  Licence document.
-
-  2. The exception is that you may use, copy, link, modify and distribute
-  under the user's own terms, binary object code versions of works based
-  on the Library.
-
-  3. If you copy code from files distributed under the terms of the GNU
-  General Public Licence or the GNU Library General Public Licence into a
-  copy of this library, as this licence permits, the exception does not
-  apply to the code that you add in this way.  To avoid misleading anyone as
-  to the status of such modified files, you must delete this exception
-  notice from such code and/or adjust the licensing conditions notice
-  accordingly.
-
-  4. If you write modifications of your own for this library, it is your
-  choice whether to permit this exception to apply to your modifications. 
-  If you do not wish that, you must delete the exception notice from such
-  code and/or adjust the licensing conditions notice accordingly.
-*/
-
-//{{NO_DEPENDENCIES}}
-// Microsoft Developer Studio generated include file.
-// Used by wxIE.rc
-//
-#define DUMMY                           4
-
-// Next default values for new objects
-// 
-#ifdef APSTUDIO_INVOKED
-#ifndef APSTUDIO_READONLY_SYMBOLS
-#define _APS_NEXT_RESOURCE_VALUE        102
-#define _APS_NEXT_COMMAND_VALUE         40001
-#define _APS_NEXT_CONTROL_VALUE         1000
-#define _APS_NEXT_SYMED_VALUE           101
-#endif
-#endif

wxPython/contrib/activex/wxie/wxActiveXFrame.cpp

@@ -1,284 +0,0 @@
-/*
-                wxActiveX Library Licence, Version 3
-                ====================================
-
-  Copyright (C) 2003 Lindsay Mathieson [, ...]
-
-  Everyone is permitted to copy and distribute verbatim copies
-  of this licence document, but changing it is not allowed.
-
-                       wxActiveX LIBRARY LICENCE
-     TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-  
-  This library is free software; you can redistribute it and/or modify it
-  under the terms of the GNU Library General Public Licence as published by
-  the Free Software Foundation; either version 2 of the Licence, or (at
-  your option) any later version.
-  
-  This library is distributed in the hope that it will be useful, but
-  WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library
-  General Public Licence for more details.
-
-  You should have received a copy of the GNU Library General Public Licence
-  along with this software, usually in a file named COPYING.LIB.  If not,
-  write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
-  Boston, MA 02111-1307 USA.
-
-  EXCEPTION NOTICE
-
-  1. As a special exception, the copyright holders of this library give
-  permission for additional uses of the text contained in this release of
-  the library as licenced under the wxActiveX Library Licence, applying
-  either version 3 of the Licence, or (at your option) any later version of
-  the Licence as published by the copyright holders of version 3 of the
-  Licence document.
-
-  2. The exception is that you may use, copy, link, modify and distribute
-  under the user's own terms, binary object code versions of works based
-  on the Library.
-
-  3. If you copy code from files distributed under the terms of the GNU
-  General Public Licence or the GNU Library General Public Licence into a
-  copy of this library, as this licence permits, the exception does not
-  apply to the code that you add in this way.  To avoid misleading anyone as
-  to the status of such modified files, you must delete this exception
-  notice from such code and/or adjust the licensing conditions notice
-  accordingly.
-
-  4. If you write modifications of your own for this library, it is your
-  choice whether to permit this exception to apply to your modifications. 
-  If you do not wish that, you must delete the exception notice from such
-  code and/or adjust the licensing conditions notice accordingly.
-*/
-
-// ----------------------------------------------------------------------------
-// headers
-// ----------------------------------------------------------------------------
-// For compilers that support precompilation, includes "wx/wx.h".
-#if defined(__WXGTK__) || defined(__WXMOTIF__)
-        #include "wx/wx.h"
-#endif
-#include "wx/wxprec.h"
-#include "wx/filedlg.h"
-#include "wx/textdlg.h"
-#include "wxActiveXFrame.h"
-#include <sstream>
-using namespace std;
-#include "wx/splitter.h"
-#include "wx/textctrl.h"
-#include "wx/clipbrd.h"
-#include <wx/msgdlg.h>
-
-enum
-{
-    // menu items
-    MENU_GETTYPEINFO = 700,
-	MENU_INVOKEMETHOD,
-	MENU_TEST
-};
-
-BEGIN_EVENT_TABLE(wxActiveXFrame, wxFrame)
-    EVT_MENU(MENU_GETTYPEINFO, wxActiveXFrame::OnGetTypeInfo)
-	EVT_MENU(MENU_INVOKEMETHOD, wxActiveXFrame::OnInvokeMethod)
-	EVT_MENU(MENU_TEST, wxActiveXFrame::OnTest)
-END_EVENT_TABLE()
-
-
-wxActiveXFrame::wxActiveXFrame(wxWindow *parent, wxString title) :
-    wxFrame(parent, -1, title) 
-{
-    // create a menu bar
-    wxMenu *xMenu = new wxMenu("", wxMENU_TEAROFF);
-
-	xMenu->Append(MENU_GETTYPEINFO, "Get Type Info", "");
-	xMenu->Append(MENU_INVOKEMETHOD, "Invoke Method (no params)", "");
-	xMenu->Append(MENU_TEST, "Test", "For debugging purposes");
-
-    // now append the freshly created menu to the menu bar...
-    wxMenuBar *menuBar = new wxMenuBar();
-    menuBar->Append(xMenu, "&ActiveX");
-
-    // ... and attach this menu bar to the frame
-    SetMenuBar(menuBar);
-
-    wxSplitterWindow *sp = new wxSplitterWindow(this);
-    X = new wxActiveX(sp, title, 101);
-
-    textLog = new wxTextCtrl(sp, -1, "", wxPoint(0,0),  wxDefaultSize, wxTE_MULTILINE | wxTE_READONLY);
-
-    sp->SplitHorizontally(X, textLog, 0);
-
-    // conenct all events
-    for (int i = 0; i < X->GetEventCount(); i++)
-    {
-        const wxActiveX::FuncX& func = X->GetEventDesc(i);
-        const wxEventType& ev = RegisterActiveXEvent((DISPID) func.memid);
-        Connect(101, ev, (wxObjectEventFunction) OnActiveXEvent);
-    };
-}
-
-wxString VarTypeAsString(VARTYPE vt)
-{
-#define VT(vtype, desc) case vtype : return desc
-
-    if (vt & VT_BYREF)
-        vt -= VT_BYREF;
-
-    if (vt & VT_ARRAY)
-        vt -= VT_ARRAY;
-
-    switch (vt)
-    {
-    VT(VT_SAFEARRAY, "SafeArray");
-    VT(VT_EMPTY, "empty");
-    VT(VT_NULL, "null");
-    VT(VT_UI1, "byte");
-    VT(VT_I1, "char");
-    VT(VT_I2, "short");
-    VT(VT_I4, "long");
-    VT(VT_UI2, "unsigned short");
-    VT(VT_UI4, "unsigned long");
-    VT(VT_INT, "int");
-    VT(VT_UINT, "unsigned int");
-    VT(VT_R4, "real(4)");
-    VT(VT_R8, "real(8)");
-    VT(VT_CY, "Currency");
-    VT(VT_DATE, "wxDate");
-    VT(VT_BSTR, "wxString");
-    VT(VT_DISPATCH, "IDispatch");
-    VT(VT_ERROR, "SCode Error");
-    VT(VT_BOOL, "bool");
-    VT(VT_VARIANT, "wxVariant");
-    VT(VT_UNKNOWN, "IUknown");
-    VT(VT_VOID, "void");
-    VT(VT_PTR, "void *");
-    VT(VT_USERDEFINED, "*user defined*");
-
-    default:
-        {
-            wxString s;
-            s << "Unknown(" << vt << ")";
-            return s;
-        };
-    };
-
-#undef VT
-};
-
-#define ENDL "\r\n"
-
-
-void OutFunc(wxString& os, const wxActiveX::FuncX& func)
-{
-    os << VarTypeAsString(func.retType.vt) << " " << func.name << "(";
-    for (unsigned int p = 0; p < func.params.size(); p++)
-    {
-        const wxActiveX::ParamX& param = func.params[p];
-        if (param.IsIn() && param.IsOut())
-            os << "[IN OUT] ";
-        else if (param.IsIn())
-            os << "[IN] ";
-        else if (param.IsIn())
-            os << "[OUT] ";
-        os << VarTypeAsString(param.vt) << " " << (param.isPtr ? "*" : "") << param.name;
-        if (p < func.params.size() - 1)
-            os << ", ";
-    };
-    os << ")" << ENDL;
-};
-
-void wxActiveXFrame::OnGetTypeInfo(wxCommandEvent& event)
-{
-    wxString os;
-
-	int i =0;
-    os << 
-        "Props" << ENDL <<
-        "=====" << ENDL;
-    for (i = 0; i < X->GetPropCount(); i++)
-    {
-        wxActiveX::PropX prop = X->GetPropDesc(i);
-        os << VarTypeAsString(prop.type.vt) << " " << prop.name << "(";
-        if (prop.CanSet())
-        {
-            os << VarTypeAsString(prop.arg.vt);
-        };
-        os << ")" << ENDL;
-
-    };
-	os << ENDL;
-
-    os << 
-        "Events" << ENDL <<
-        "======" << ENDL;
-    for (i = 0; i < X->GetEventCount(); i++)
-		OutFunc(os, X->GetEventDesc(i));
-	os << ENDL;
-
-    os << 
-        "Methods" << ENDL <<
-        "=======" << ENDL;
-    for (i = 0; i < X->GetMethodCount(); i++)
-		OutFunc(os, X->GetMethodDesc(i));
-	os << ENDL;
-
-
-	if (wxTheClipboard->Open())
-	{
-		wxDataObjectSimple *wo = new wxTextDataObject(os);
-		wxTheClipboard->SetData(wo);
-        wxTheClipboard->Flush();
-		wxTheClipboard->Close();
-	};
-
-    wxMessageBox(os, "Type Info", wxOK, this);
-};
-
-void wxActiveXFrame::OnInvokeMethod(wxCommandEvent& event)
-{
-	//wxTextEntryDialog dlg(this, "Method");
-	//if (dlg.ShowModal() == wxID_OK)
-	//	X->CallMethod(dlg.GetValue());
-};
-
-void wxActiveXFrame::OnTest(wxCommandEvent& event)
-{
-	// flash testing
-    wxVariant args[] = {0L, "http://www.macromedia.com/support/flash/ts/documents/java_script_comm/flash_to_javascript.swf"};
-    X->CallMethod("LoadMovie", args);   
-	//X->Prop("Movie") = "http://www.macromedia.com/support/flash/ts/documents/java_script_comm/flash_to_javascript.swf";
-
-	// mc cal testing
-    //X->Prop("year") = 1964L;
-    //X->Prop("Value") = wxDateTime::Now();
-
-	// pdf testing
-	//wxVariant file = "C:\\WINNT\\wx2\\docs\\pdf\\dialoged.pdf";
-	//X->CallMethod("LoadFile", &file);
-};
-
-void wxActiveXFrame::OnActiveXEvent(wxActiveXEvent& event)
-{
-#ifdef UNICODE
-    wostringstream os;
-#else
-    ostringstream os;
-#endif
-
-    os << (const wxChar *) event.EventName() << wxT("(");
-
-    for (int p = 0; p < event.ParamCount(); p++)
-    {
-        os << 
-            (const wxChar *) event.ParamType(p) << wxT(" ") << 
-            (const wxChar *) event.ParamName(p) << wxT(" = ") <<
-            (const wxChar *) (wxString) event[p];
-        if (p < event.ParamCount() - 1)
-            os << wxT(", ");
-    };
-    os << wxT(")") << endl;
-    wxString data = os.str().c_str();
-    textLog->AppendText(data);
-};
-

wxPython/contrib/activex/wxie/wxActiveXFrame.h

@@ -1,77 +0,0 @@
-/*
-                wxActiveX Library Licence, Version 3
-                ====================================
-
-  Copyright (C) 2003 Lindsay Mathieson [, ...]
-
-  Everyone is permitted to copy and distribute verbatim copies
-  of this licence document, but changing it is not allowed.
-
-                       wxActiveX LIBRARY LICENCE
-     TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-  
-  This library is free software; you can redistribute it and/or modify it
-  under the terms of the GNU Library General Public Licence as published by
-  the Free Software Foundation; either version 2 of the Licence, or (at
-  your option) any later version.
-  
-  This library is distributed in the hope that it will be useful, but
-  WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library
-  General Public Licence for more details.
-
-  You should have received a copy of the GNU Library General Public Licence
-  along with this software, usually in a file named COPYING.LIB.  If not,
-  write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
-  Boston, MA 02111-1307 USA.
-
-  EXCEPTION NOTICE
-
-  1. As a special exception, the copyright holders of this library give
-  permission for additional uses of the text contained in this release of
-  the library as licenced under the wxActiveX Library Licence, applying
-  either version 3 of the Licence, or (at your option) any later version of
-  the Licence as published by the copyright holders of version 3 of the
-  Licence document.
-
-  2. The exception is that you may use, copy, link, modify and distribute
-  under the user's own terms, binary object code versions of works based
-  on the Library.
-
-  3. If you copy code from files distributed under the terms of the GNU
-  General Public Licence or the GNU Library General Public Licence into a
-  copy of this library, as this licence permits, the exception does not
-  apply to the code that you add in this way.  To avoid misleading anyone as
-  to the status of such modified files, you must delete this exception
-  notice from such code and/or adjust the licensing conditions notice
-  accordingly.
-
-  4. If you write modifications of your own for this library, it is your
-  choice whether to permit this exception to apply to your modifications. 
-  If you do not wish that, you must delete the exception notice from such
-  code and/or adjust the licensing conditions notice accordingly.
-*/
-
-#ifndef wxActiveXFrame_h
-#define wxActiveXFrame_h
-
-#include "wxactivex.h"
-
-class wxActiveXFrame : public wxFrame
-{
-public:
-    wxActiveX *X;
-    wxTextCtrl *textLog;
-
-    wxActiveXFrame(wxWindow *parent, wxString title);
-
-    DECLARE_EVENT_TABLE()
-
-    void OnGetTypeInfo(wxCommandEvent& event);
-    void OnInvokeMethod(wxCommandEvent& event);
-	void OnTest(wxCommandEvent& event);
-    void OnActiveXEvent(wxActiveXEvent& event);
-};
-
-
-#endif

wxPython/contrib/activex/wxie/wxIE.dsp

@@ -1,404 +0,0 @@
-# Microsoft Developer Studio Project File - Name="wxIE" - Package Owner=<4>
-# Microsoft Developer Studio Generated Build File, Format Version 6.00
-# ** DO NOT EDIT **
-
-# TARGTYPE "Win32 (x86) Console Application" 0x0103
-
-CFG=wxIE - Win32 Unicode Debug
-!MESSAGE This is not a valid makefile. To build this project using NMAKE,
-!MESSAGE use the Export Makefile command and run
-!MESSAGE 
-!MESSAGE NMAKE /f "wxIE.mak".
-!MESSAGE 
-!MESSAGE You can specify a configuration when running NMAKE
-!MESSAGE by defining the macro CFG on the command line. For example:
-!MESSAGE 
-!MESSAGE NMAKE /f "wxIE.mak" CFG="wxIE - Win32 Unicode Debug"
-!MESSAGE 
-!MESSAGE Possible choices for configuration are:
-!MESSAGE 
-!MESSAGE "wxIE - Win32 Release" (based on "Win32 (x86) Console Application")
-!MESSAGE "wxIE - Win32 Debug" (based on "Win32 (x86) Console Application")
-!MESSAGE "wxIE - Win32 Unicode Debug" (based on "Win32 (x86) Console Application")
-!MESSAGE "wxIE - Win32 Unicode Release" (based on "Win32 (x86) Console Application")
-!MESSAGE 
-
-# Begin Project
-# PROP AllowPerConfigDependencies 0
-# PROP Scc_ProjName ""
-# PROP Scc_LocalPath ""
-CPP=cl.exe
-RSC=rc.exe
-
-!IF  "$(CFG)" == "wxIE - Win32 Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release"
-# PROP BASE Intermediate_Dir "Release"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release"
-# PROP Intermediate_Dir "Release"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
-# ADD CPP /nologo /MD /W3 /GX /O1 /Ob2 /I "$(WXWIN)\include" /I "$(WXWIN)\contrib\include" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /D "_WINDOWS" /D "__WINDOWS__" /D "__WXMSW__" /D "__WIN95__" /D "__WIN32__" /D WINVER=0x0400 /D "STRICT" /YX /FD /c
-# ADD BASE RSC /l 0xc09 /d "NDEBUG"
-# ADD RSC /l 0xc09 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib rpcrt4.lib wsock32.lib winmm.lib wxmsw.lib /nologo /subsystem:windows /machine:I386 /nodefaultlib:"libc.lib" /nodefaultlib:"libci.lib" /nodefaultlib:"msvcrtd.lib" /libpath:"$(WXWIN)\Lib" /libpath:"$(WXWIN)\contrib\Lib"
-# SUBTRACT LINK32 /pdb:none
-
-!ELSEIF  "$(CFG)" == "wxIE - Win32 Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug"
-# PROP BASE Intermediate_Dir "Debug"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug"
-# PROP Intermediate_Dir "Debug"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
-# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "$(WXWIN)\lib\vc_dll\mswd" /I "$(WXWIN)\include" /I "$(WXWIN)\contrib\include" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /D "_WINDOWS" /D "__WINDOWS__" /D "__WXMSW__" /D DEBUG=1 /D "__WXDEBUG__" /D "__WIN95__" /D "__WIN32__" /D WINVER=0x0400 /D "STRICT" /Yu"wx/wxprec.h" /FD /GZ /c
-# ADD BASE RSC /l 0xc09 /d "_DEBUG"
-# ADD RSC /l 0xc09 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib rpcrt4.lib wsock32.lib winmm.lib    wxbase25d.lib             wxbase25d_net.lib         wxbase25d_xml.lib /nologo /subsystem:windows /debug /machine:I386 /nodefaultlib:"libcd.lib" /nodefaultlib:"libcid.lib" /nodefaultlib:"msvcrt.lib" /pdbtype:sept /libpath:"$(WXWIN)\Lib" /libpath:"$(WXWIN)\lib\vc_dll" /libpath:"$(WXWIN)\contrib\Lib"
-# SUBTRACT LINK32 /pdb:none
-
-!ELSEIF  "$(CFG)" == "wxIE - Win32 Unicode Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "wxIE___Win32_Unicode_Debug"
-# PROP BASE Intermediate_Dir "wxIE___Win32_Unicode_Debug"
-# PROP BASE Ignore_Export_Lib 0
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "wxIE___Win32_Unicode_Debug"
-# PROP Intermediate_Dir "wxIE___Win32_Unicode_Debug"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "$(WXWIN)\include" /I "$(WXWIN)\contrib\include" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /D "_WINDOWS" /D "__WINDOWS__" /D "__WXMSW__" /D DEBUG=1 /D "__WXDEBUG__" /D "__WIN95__" /D "__WIN32__" /D WINVER=0x0400 /D "STRICT" /Yu"wx/wxprec.h" /FD /GZ /c
-# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "$(WXWIN)\include" /I "$(WXWIN)\contrib\include" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_WINDOWS" /D "__WINDOWS__" /D "__WXMSW__" /D DEBUG=1 /D "__WXDEBUG__" /D "__WIN95__" /D "__WIN32__" /D WINVER=0x0400 /D "STRICT" /D UNICODE=1 /Yu"wx/wxprec.h" /FD /GZ /c
-# ADD BASE RSC /l 0xc09 /d "_DEBUG"
-# ADD RSC /l 0xc09 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib rpcrt4.lib wsock32.lib winmm.lib wxmswd.lib pngd.lib zlibd.lib jpegd.lib tiffd.lib /nologo /subsystem:windows /debug /machine:I386 /nodefaultlib:"libcd.lib" /nodefaultlib:"libcid.lib" /nodefaultlib:"msvcrt.lib" /out:"wxIE.exe" /pdbtype:sept /libpath:"$(WXWIN)\Lib" /libpath:"$(WXWIN)\contrib\Lib"
-# SUBTRACT BASE LINK32 /pdb:none
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib rpcrt4.lib wsock32.lib winmm.lib wxmswud.lib /nologo /subsystem:windows /debug /machine:I386 /nodefaultlib:"libcd.lib" /nodefaultlib:"libcid.lib" /nodefaultlib:"msvcrt.lib" /out:"wxIE.exe" /pdbtype:sept /libpath:"$(WXWIN)\Lib" /libpath:"$(WXWIN)\contrib\Lib"
-# SUBTRACT LINK32 /pdb:none
-
-!ELSEIF  "$(CFG)" == "wxIE - Win32 Unicode Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "wxIE___Win32_Unicode_Release"
-# PROP BASE Intermediate_Dir "wxIE___Win32_Unicode_Release"
-# PROP BASE Ignore_Export_Lib 0
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "wxIE___Win32_Unicode_Release"
-# PROP Intermediate_Dir "wxIE___Win32_Unicode_Release"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /MD /W3 /GX /O1 /Ob2 /I "$(WXWIN)\include" /I "$(WXWIN)\contrib\include" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /D "_WINDOWS" /D "__WINDOWS__" /D "__WXMSW__" /D "__WIN95__" /D "__WIN32__" /D WINVER=0x0400 /D "STRICT" /YX /FD /c
-# ADD CPP /nologo /MD /W3 /GX /O1 /Ob2 /I "$(WXWIN)\include" /I "$(WXWIN)\contrib\include" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /D "_WINDOWS" /D "__WINDOWS__" /D "__WXMSW__" /D "__WIN95__" /D "__WIN32__" /D WINVER=0x0400 /D "STRICT" /YX /FD /c
-# ADD BASE RSC /l 0xc09 /d "NDEBUG"
-# ADD RSC /l 0xc09 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib rpcrt4.lib wsock32.lib winmm.lib wx.lib xpm.lib png.lib zlib.lib jpeg.lib tiff.lib /nologo /subsystem:windows /machine:I386 /nodefaultlib:"libc.lib" /nodefaultlib:"libci.lib" /nodefaultlib:"msvcrtd.lib" /out:"wxIE.exe"
-# SUBTRACT BASE LINK32 /pdb:none
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib rpcrt4.lib wsock32.lib winmm.lib wxmswu.lib /nologo /subsystem:windows /machine:I386 /nodefaultlib:"libc.lib" /nodefaultlib:"libci.lib" /nodefaultlib:"msvcrtd.lib" /out:"wxIE.exe" /libpath:"$(WXWIN)\Lib" /libpath:"$(WXWIN)\contrib\Lib"
-# SUBTRACT LINK32 /pdb:none
-
-!ENDIF 
-
-# Begin Target
-
-# Name "wxIE - Win32 Release"
-# Name "wxIE - Win32 Debug"
-# Name "wxIE - Win32 Unicode Debug"
-# Name "wxIE - Win32 Unicode Release"
-# Begin Group "Source Files"
-
-# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
-# Begin Source File
-
-SOURCE=.\IEHtmlWin.cpp
-
-!IF  "$(CFG)" == "wxIE - Win32 Release"
-
-# SUBTRACT CPP /YX
-
-!ELSEIF  "$(CFG)" == "wxIE - Win32 Debug"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF  "$(CFG)" == "wxIE - Win32 Unicode Debug"
-
-# SUBTRACT BASE CPP /YX /Yc /Yu
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF  "$(CFG)" == "wxIE - Win32 Unicode Release"
-
-# SUBTRACT BASE CPP /YX
-# SUBTRACT CPP /YX
-
-!ENDIF 
-
-# End Source File
-# Begin Source File
-
-SOURCE=.\wxactivex.cpp
-
-!IF  "$(CFG)" == "wxIE - Win32 Release"
-
-!ELSEIF  "$(CFG)" == "wxIE - Win32 Debug"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF  "$(CFG)" == "wxIE - Win32 Unicode Debug"
-
-# SUBTRACT BASE CPP /YX /Yc /Yu
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF  "$(CFG)" == "wxIE - Win32 Unicode Release"
-
-!ENDIF 
-
-# End Source File
-# Begin Source File
-
-SOURCE=.\wxActiveXFrame.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=.\wxIE.rc
-# End Source File
-# Begin Source File
-
-SOURCE=.\wxIEApp.cpp
-# ADD CPP /Yc"wx/wxprec.h"
-# End Source File
-# Begin Source File
-
-SOURCE=.\wxIEFrm.cpp
-# End Source File
-# End Group
-# Begin Group "Header Files"
-
-# PROP Default_Filter "h;hpp;hxx;hm;inl"
-# Begin Source File
-
-SOURCE=.\IEHtmlWin.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\resource.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\wxactivex.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\wxActiveXFrame.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\wxIEApp.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\wxIEFrm.h
-# End Source File
-# End Group
-# Begin Group "Resource Files"
-
-# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
-# Begin Source File
-
-SOURCE=.\wx\msw\blank.cur
-# End Source File
-# Begin Source File
-
-SOURCE=.\wx\msw\bullseye.cur
-# End Source File
-# Begin Source File
-
-SOURCE=.\wx\msw\colours.bmp
-# End Source File
-# Begin Source File
-
-SOURCE=.\wx\msw\cross.bmp
-# End Source File
-# Begin Source File
-
-SOURCE=.\wx\msw\disable.bmp
-# End Source File
-# Begin Source File
-
-SOURCE=.\wx\msw\error.ico
-# End Source File
-# Begin Source File
-
-SOURCE=.\wx\msw\hand.cur
-# End Source File
-# Begin Source File
-
-SOURCE=.\wx\msw\info.ico
-# End Source File
-# Begin Source File
-
-SOURCE=.\wx\msw\magnif1.cur
-# End Source File
-# Begin Source File
-
-SOURCE=.\wx\msw\noentry.cur
-# End Source File
-# Begin Source File
-
-SOURCE=.\wx\msw\pbrush.cur
-# End Source File
-# Begin Source File
-
-SOURCE=.\wx\msw\pencil.cur
-# End Source File
-# Begin Source File
-
-SOURCE=.\wx\msw\plot_dwn.bmp
-# End Source File
-# Begin Source File
-
-SOURCE=.\wx\msw\plot_enl.bmp
-# End Source File
-# Begin Source File
-
-SOURCE=.\wx\msw\plot_shr.bmp
-# End Source File
-# Begin Source File
-
-SOURCE=.\wx\msw\plot_up.bmp
-# End Source File
-# Begin Source File
-
-SOURCE=.\wx\msw\plot_zin.bmp
-# End Source File
-# Begin Source File
-
-SOURCE=.\wx\msw\plot_zot.bmp
-# End Source File
-# Begin Source File
-
-SOURCE=.\wx\msw\pntleft.cur
-# End Source File
-# Begin Source File
-
-SOURCE=.\wx\msw\pntright.cur
-# End Source File
-# Begin Source File
-
-SOURCE=.\wx\msw\query.cur
-# End Source File
-# Begin Source File
-
-SOURCE=.\wx\msw\question.ico
-# End Source File
-# Begin Source File
-
-SOURCE=.\wx\msw\roller.cur
-# End Source File
-# Begin Source File
-
-SOURCE=.\wx\msw\size.cur
-# End Source File
-# Begin Source File
-
-SOURCE=.\wx\msw\tick.bmp
-# End Source File
-# Begin Source File
-
-SOURCE=.\wx\msw\tip.ico
-# End Source File
-# Begin Source File
-
-SOURCE=.\wx\msw\warning.ico
-# End Source File
-# Begin Source File
-
-SOURCE=.\wx\msw\watch1.cur
-# End Source File
-# Begin Source File
-
-SOURCE=.\wxIE.ico
-# End Source File
-# End Group
-# Begin Source File
-
-SOURCE=.\default.doxygen
-# End Source File
-# Begin Source File
-
-SOURCE=.\license.txt
-# End Source File
-# Begin Source File
-
-SOURCE=.\makefile
-# PROP Exclude_From_Scan -1
-# PROP BASE Exclude_From_Build 1
-# PROP Exclude_From_Build 1
-# End Source File
-# Begin Source File
-
-SOURCE=.\makefile.gtk
-# PROP Exclude_From_Scan -1
-# PROP BASE Exclude_From_Build 1
-# PROP Exclude_From_Build 1
-# End Source File
-# Begin Source File
-
-SOURCE=.\makefile.mtf
-# PROP Exclude_From_Scan -1
-# PROP BASE Exclude_From_Build 1
-# PROP Exclude_From_Build 1
-# End Source File
-# Begin Source File
-
-SOURCE=.\notes.txt
-# End Source File
-# Begin Source File
-
-SOURCE=.\readme.txt
-# End Source File
-# Begin Source File
-
-SOURCE=.\wxIE.xpm
-# PROP Exclude_From_Scan -1
-# PROP BASE Exclude_From_Build 1
-# PROP Exclude_From_Build 1
-# End Source File
-# End Target
-# End Project

wxPython/contrib/activex/wxie/wxIE.rc

@@ -1,169 +0,0 @@
-//Microsoft Developer Studio generated resource script.
-//
-#include "resource.h"
-
-#define APSTUDIO_READONLY_SYMBOLS
-/////////////////////////////////////////////////////////////////////////////
-//
-// Generated from the TEXTINCLUDE 2 resource.
-//
-//#include "afxres.h"
-/////////////////////////////////////////////////////////////////////////////
-#undef APSTUDIO_READONLY_SYMBOLS
-
-#include <winuser.rh>
-#include <commctrl.rh>
-#include <dde.rh>
-#include <winnt.rh>
-#include <dlgs.h>
-#include <winver.h>
-
-
-
-/////////////////////////////////////////////////////////////////////////////
-// English (U.S.) resources
-
-#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
-#ifdef _WIN32
-LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
-#pragma code_page(1252)
-#endif //_WIN32
-
-
-
-#ifdef APSTUDIO_INVOKED
-/////////////////////////////////////////////////////////////////////////////
-//
-// TEXTINCLUDE
-//
-
-1 TEXTINCLUDE DISCARDABLE 
-BEGIN
-    "resource.h\0"
-END
-
-2 TEXTINCLUDE DISCARDABLE 
-BEGIN
-    "#include ""afxres.h""\r\n"
-    "\0"
-END
-
-3 TEXTINCLUDE DISCARDABLE 
-BEGIN
-    "\r\n"
-    "\0"
-END
-
-#endif    // APSTUDIO_INVOKED
-
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// Bitmap
-//
-
-/*
-WXDISABLE_BUTTON_BITMAP BITMAP  MOVEABLE PURE   "wx/msw/disable.bmp"
-WXBITMAP_STD_COLOURS    BITMAP  MOVEABLE PURE   "wx/msw/colours.bmp"
-TICK_BMP                BITMAP  MOVEABLE PURE   "wx/msw/tick.bmp"
-PLOT_ZOT_BMP            BITMAP  MOVEABLE PURE   "wx/msw/plot_zot.bmp"
-PLOT_ZIN_BMP            BITMAP  MOVEABLE PURE   "wx/msw/plot_zin.bmp"
-PLOT_UP_BMP             BITMAP  MOVEABLE PURE   "wx/msw/plot_up.bmp"
-PLOT_SHR_BMP            BITMAP  MOVEABLE PURE   "wx/msw/plot_shr.bmp"
-PLOT_ENL_BMP            BITMAP  MOVEABLE PURE   "wx/msw/plot_enl.bmp"
-PLOT_DWN_BMP            BITMAP  MOVEABLE PURE   "wx/msw/plot_dwn.bmp"
-CROSS_BMP               BITMAP  MOVEABLE PURE   "wx/msw/cross.bmp"
-*/
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// Cursor
-//
-
-/*
-WXCURSOR_WATCH          CURSOR  DISCARDABLE     "wx\\msw\\watch1.cur"
-WXCURSOR_SIZING         CURSOR  DISCARDABLE     "wx/msw/size.cur"
-WXCURSOR_ROLLER         CURSOR  DISCARDABLE     "wx/msw/roller.cur"
-WXCURSOR_QARROW         CURSOR  DISCARDABLE     "wx/msw/query.cur"
-WXCURSOR_PRIGHT         CURSOR  DISCARDABLE     "wx/msw/pntright.cur"
-WXCURSOR_PLEFT          CURSOR  DISCARDABLE     "wx/msw/pntleft.cur"
-WXCURSOR_PENCIL         CURSOR  DISCARDABLE     "wx/msw/pencil.cur"
-WXCURSOR_PBRUSH         CURSOR  DISCARDABLE     "wx/msw/pbrush.cur"
-WXCURSOR_NO_ENTRY       CURSOR  DISCARDABLE     "wx/msw/noentry.cur"
-WXCURSOR_MAGNIFIER      CURSOR  DISCARDABLE     "wx/msw/magnif1.cur"
-WXCURSOR_HAND           CURSOR  DISCARDABLE     "wx/msw/hand.cur"
-WXCURSOR_BULLSEYE       CURSOR  DISCARDABLE     "wx/msw/bullseye.cur"
-WXCURSOR_BLANK          CURSOR  DISCARDABLE     "wx/msw/blank.cur"
-*/
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// Dialog
-//
-
-WXRESIZEABLEDIALOG DIALOG DISCARDABLE  34, 22, 144, 75
-STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME
-BEGIN
-END
-
-WXNOCAPTIONDIALOG DIALOG DISCARDABLE  34, 22, 144, 75
-STYLE WS_POPUP
-BEGIN
-END
-
-WXCAPTIONDIALOG DIALOG DISCARDABLE  34, 22, 144, 75
-STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
-CAPTION "Dummy dialog"
-BEGIN
-END
-
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// Icon
-//
-
-// Icon with lowest ID value placed first to ensure application icon
-// remains consistent on all systems.
-WXIE                    ICON    DISCARDABLE     "wxIE.ico"
-/*
-WXICON_WARNING          ICON    DISCARDABLE     "wx\\msw\\warning.ico"
-WXICON_TIP              ICON    DISCARDABLE     "wx/msw/tip.ico"
-WXICON_QUESTION         ICON    DISCARDABLE     "wx/msw/question.ico"
-WXICON_INFO             ICON    DISCARDABLE     "wx/msw/info.ico"
-WXICON_ERROR            ICON    DISCARDABLE     "wx/msw/error.ico"
-*/
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// Menu
-//
-
-WXWINDOWMENU MENU DISCARDABLE 
-BEGIN
-    POPUP "&Window"
-    BEGIN
-        MENUITEM "&Cascade",                    4002
-        MENUITEM "Tile &Horizontally",          4001
-        MENUITEM "Tile &Vertically",            4005
-        MENUITEM "",                            65535
-        MENUITEM "&Arrange Icons",              4003
-        MENUITEM "&Next",                       4004
-    END
-END
-
-#endif    // English (U.S.) resources
-/////////////////////////////////////////////////////////////////////////////
-
-
-
-#ifndef APSTUDIO_INVOKED
-/////////////////////////////////////////////////////////////////////////////
-//
-// Generated from the TEXTINCLUDE 3 resource.
-//
-
-
-/////////////////////////////////////////////////////////////////////////////
-#endif    // not APSTUDIO_INVOKED
-

wxPython/contrib/activex/wxie/wxIE.xpm

@@ -1,44 +0,0 @@
-/* XPM */
-static char *wxIE_xpm[] = {
-/* columns rows colors chars-per-pixel */
-"32 32 6 1",
-"  c Black",
-". c Blue",
-"X c #00bf00",
-"o c Red",
-"O c Yellow",
-"+ c Gray100",
-/* pixels */
-"                                ",
-" oooooo +++++++++++++++++++++++ ",
-" oooooo +++++++++++++++++++++++ ",
-" oooooo +++++++++++++++++++++++ ",
-" oooooo +++++++++++++++++++++++ ",
-" oooooo +++++++++++++++++++++++ ",
-" oooooo +++++++++++++++++++++++ ",
-" oooooo +++++++++++++++++++++++ ",
-"                                ",
-" ++++++ ++++++++++++++++++ .... ",
-" ++++++ ++++++++++++++++++ .... ",
-" ++++++ ++++++++++++++++++ .... ",
-" ++++++ ++++++++++++++++++ .... ",
-" ++++++ ++++++++++++++++++ .... ",
-" ++++++ ++++++++++++++++++      ",
-" ++++++ ++++++++++++++++++ ++++ ",
-" ++++++ ++++++++++++++++++ ++++ ",
-" ++++++ ++++++++++++++++++ ++++ ",
-" ++++++ ++++++++++++++++++ ++++ ",
-" ++++++ ++++++++++++++++++ ++++ ",
-" ++++++ ++++++++++++++++++ ++++ ",
-" ++++++ ++++++++++++++++++ ++++ ",
-" ++++++ ++++++++++++++++++ ++++ ",
-" ++++++ ++++++++++++++++++ ++++ ",
-" ++++++                    ++++ ",
-" ++++++ OOOOOOOOOOOO XXXXX ++++ ",
-" ++++++ OOOOOOOOOOOO XXXXX ++++ ",
-" ++++++ OOOOOOOOOOOO XXXXX ++++ ",
-" ++++++ OOOOOOOOOOOO XXXXX ++++ ",
-" ++++++ OOOOOOOOOOOO XXXXX ++++ ",
-" ++++++ OOOOOOOOOOOO XXXXX ++++ ",
-"                                "
-};

wxPython/contrib/activex/wxie/wxIEApp.cpp

@@ -1,99 +0,0 @@
-/*
-                wxActiveX Library Licence, Version 3
-                ====================================
-
-  Copyright (C) 2003 Lindsay Mathieson [, ...]
-
-  Everyone is permitted to copy and distribute verbatim copies
-  of this licence document, but changing it is not allowed.
-
-                       wxActiveX LIBRARY LICENCE
-     TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-  
-  This library is free software; you can redistribute it and/or modify it
-  under the terms of the GNU Library General Public Licence as published by
-  the Free Software Foundation; either version 2 of the Licence, or (at
-  your option) any later version.
-  
-  This library is distributed in the hope that it will be useful, but
-  WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library
-  General Public Licence for more details.
-
-  You should have received a copy of the GNU Library General Public Licence
-  along with this software, usually in a file named COPYING.LIB.  If not,
-  write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
-  Boston, MA 02111-1307 USA.
-
-  EXCEPTION NOTICE
-
-  1. As a special exception, the copyright holders of this library give
-  permission for additional uses of the text contained in this release of
-  the library as licenced under the wxActiveX Library Licence, applying
-  either version 3 of the Licence, or (at your option) any later version of
-  the Licence as published by the copyright holders of version 3 of the
-  Licence document.
-
-  2. The exception is that you may use, copy, link, modify and distribute
-  under the user's own terms, binary object code versions of works based
-  on the Library.
-
-  3. If you copy code from files distributed under the terms of the GNU
-  General Public Licence or the GNU Library General Public Licence into a
-  copy of this library, as this licence permits, the exception does not
-  apply to the code that you add in this way.  To avoid misleading anyone as
-  to the status of such modified files, you must delete this exception
-  notice from such code and/or adjust the licensing conditions notice
-  accordingly.
-
-  4. If you write modifications of your own for this library, it is your
-  choice whether to permit this exception to apply to your modifications. 
-  If you do not wish that, you must delete the exception notice from such
-  code and/or adjust the licensing conditions notice accordingly.
-*/
-
-// ----------------------------------------------------------------------------
-// headers
-// ----------------------------------------------------------------------------
-// For compilers that support precompilation, includes "wx/wx.h".
-#if defined(__WXGTK__) || defined(__WXMOTIF__)
-        #include "wx/wx.h"
-#endif
-#include "wx/wxprec.h"
-#include "wxIEApp.h"
-#include "wxIEFrm.h"
-#include "resource.h"
-
-
-
-// Create a new application object: this macro will allow wxWindows to create
-// the application object during program execution (it's better than using a
-// static object for many reasons) and also declares the accessor function
-// wxGetApp() which will return the reference of the right type (i.e. wxIEApp and
-// not wxApp)
-IMPLEMENT_APP(wxIEApp)
-
-// ============================================================================
-// implementation
-// ============================================================================
-
-// ----------------------------------------------------------------------------
-// the application class
-// ----------------------------------------------------------------------------
-
-// 'Main program' equivalent: the program execution "starts" here
-bool wxIEApp::OnInit()
-{
-    // create the main application window
-    wxIEFrame *frame = new wxIEFrame(wxT("IE Test"));
-
-    // and show it (the frames, unlike simple controls, are not shown when
-    // created initially)
-    frame->Show(TRUE);
-
-    // success: wxApp::OnRun() will be called which will enter the main message
-    // loop and the application will run. If we returned FALSE here, the
-    // application would exit immediately.
-    return TRUE;
-}
-

wxPython/contrib/activex/wxie/wxIEApp.h

@@ -1,66 +0,0 @@
-/*
-                wxActiveX Library Licence, Version 3
-                ====================================
-
-  Copyright (C) 2003 Lindsay Mathieson [, ...]
-
-  Everyone is permitted to copy and distribute verbatim copies
-  of this licence document, but changing it is not allowed.
-
-                       wxActiveX LIBRARY LICENCE
-     TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-  
-  This library is free software; you can redistribute it and/or modify it
-  under the terms of the GNU Library General Public Licence as published by
-  the Free Software Foundation; either version 2 of the Licence, or (at
-  your option) any later version.
-  
-  This library is distributed in the hope that it will be useful, but
-  WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library
-  General Public Licence for more details.
-
-  You should have received a copy of the GNU Library General Public Licence
-  along with this software, usually in a file named COPYING.LIB.  If not,
-  write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
-  Boston, MA 02111-1307 USA.
-
-  EXCEPTION NOTICE
-
-  1. As a special exception, the copyright holders of this library give
-  permission for additional uses of the text contained in this release of
-  the library as licenced under the wxActiveX Library Licence, applying
-  either version 3 of the Licence, or (at your option) any later version of
-  the Licence as published by the copyright holders of version 3 of the
-  Licence document.
-
-  2. The exception is that you may use, copy, link, modify and distribute
-  under the user's own terms, binary object code versions of works based
-  on the Library.
-
-  3. If you copy code from files distributed under the terms of the GNU
-  General Public Licence or the GNU Library General Public Licence into a
-  copy of this library, as this licence permits, the exception does not
-  apply to the code that you add in this way.  To avoid misleading anyone as
-  to the status of such modified files, you must delete this exception
-  notice from such code and/or adjust the licensing conditions notice
-  accordingly.
-
-  4. If you write modifications of your own for this library, it is your
-  choice whether to permit this exception to apply to your modifications. 
-  If you do not wish that, you must delete the exception notice from such
-  code and/or adjust the licensing conditions notice accordingly.
-*/
-
-// Define a new application type, each program should derive a class from wxApp
-class wxIEApp : public wxApp
-{
-public:
-    // override base class virtuals
-    // ----------------------------
-
-    // this one is called on application startup and is a good place for the app
-    // initialization (doing it here and not in the ctor allows to have an error
-    // return: if OnInit() returns false, the application terminates)
-    virtual bool OnInit();
-};