This commit was manufactured by cvs2svn to create tag

'wxPython-2_1b3'.

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/tags/wxPython-2_1b3@3555 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

contrib/src/xrc/xh_html.cpp

@@ -1,83 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,262 +0,0 @@
-%
-% 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

@@ -1,37 +0,0 @@
-%
-% 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

@@ -1,250 +0,0 @@
-%
-% 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

@@ -1,111 +0,0 @@
-%
-% 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

@@ -1,164 +0,0 @@
-%
-% 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

@@ -1,63 +0,0 @@
-%
-% 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

@@ -1,221 +0,0 @@
-%
-% 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

@@ -1,87 +0,0 @@
-%
-% 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

@@ -1,170 +0,0 @@
-%
-% 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

@@ -1,59 +0,0 @@
-\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

@@ -1,82 +0,0 @@
-\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

@@ -1,10 +0,0 @@
-\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

@@ -1,146 +0,0 @@
-\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

@@ -1,96 +0,0 @@
-\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

@@ -1,82 +0,0 @@
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% 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

@@ -1,13 +0,0 @@
-\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

@@ -1,68 +0,0 @@
-\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

@@ -1,148 +0,0 @@
-\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

@@ -1,267 +0,0 @@
-%
-% 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

@@ -1,106 +0,0 @@
-%
-% 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

@@ -1,194 +0,0 @@
-%
-% 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

@@ -1,91 +0,0 @@
-%
-% 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

@@ -1,43 +0,0 @@
-%
-% 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

@@ -1,70 +0,0 @@
-\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

@@ -1,37 +0,0 @@
-%
-% 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

@@ -1,383 +0,0 @@
-%
-% 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

@@ -1,31 +0,0 @@
-%
-% 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

@@ -1,298 +0,0 @@
-%
-% 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

@@ -1,73 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,108 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,218 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,239 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,382 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,157 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,87 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,278 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,64 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,158 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,284 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,258 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,84 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,252 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,331 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,881 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,728 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,229 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,900 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,497 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,798 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,633 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,90 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,321 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,110 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,692 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,369 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,98 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,170 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,130 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,51 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,623 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,519 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

@@ -1,83 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// 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

utils/wxPython/.cvsignore

@@ -0,0 +1,117 @@
+*.py
+*.pyc
+*.pyc
+*.pyd
+*.pyd
+*.pyo
+*.pyo
+*.zip
+.cvsignore
+.emacs.desktop
+__init__.py
+__init__.py
+__init__.pyc
+__init__.pyc
+__init__.pyo
+__init__.pyo
+build.local
+cmndlgs.py
+cmndlgs.py
+cmndlgs.pyc
+cmndlgs.pyc
+cmndlgs.pyo
+cmndlgs.pyo
+controls.py
+controls.py
+controls.pyc
+controls.pyc
+controls.pyo
+controls.pyo
+controls2.py
+controls2.py
+controls2.pyc
+controls2.pyc
+controls2.pyo
+controls2.pyo
+docs
+events.py
+events.py
+events.pyc
+events.pyc
+events.pyo
+events.pyo
+filelist
+frames.py
+frames.py
+frames.pyc
+frames.pyc
+frames.pyo
+frames.pyo
+gdi.py
+gdi.py
+gdi.pyc
+gdi.pyc
+gdi.pyo
+gdi.pyo
+glcanvas.py
+glcanvas.pyc
+glcanvasc.ilk
+glcanvasc.pyd
+image.py
+image.pyc
+mdi.py
+mdi.py
+mdi.pyc
+mdi.pyc
+mdi.pyo
+mdi.pyo
+misc.py
+misc.py
+misc.pyc
+misc.pyc
+misc.pyo
+misc.pyo
+printfw.py
+stattool.py
+stattool.py
+stattool.pyc
+stattool.pyc
+stattool.pyo
+stattool.pyo
+utils.py
+utils.py
+utils.pyc
+utils.pyc
+utils.pyo
+utilsc.ilk
+utilsc.pyd
+windows.py
+windows.py
+windows.pyc
+windows.pyc
+windows.pyo
+windows.pyo
+windows2.py
+windows2.py
+windows2.pyc
+windows2.pyc
+windows2.pyo
+windows2.pyo
+windows3.py
+windows3.pyc
+windows3.pyo
+wx.py
+wx.py
+wx.pyc
+wx.pyc
+wx.pyo
+wxPython.doc
+wxc.ilk
+wxc.pdb
+wxc.pyd
+wxp.py
+wxp.pyc
+wxp.pyo
+wxpc.ilk
+wxpc.pdb
+wxpc.pyd

utils/wxPython/README.txt

@@ -0,0 +1,411 @@
+wxPython README
+---------------
+
+Welcome to the wonderful world of wxPython!
+
+Once you have installed the wxPython extension module, you can try it
+out by going to the [install dir]\wxPython\demo directory and typing:
+
+    python demo.py
+
+There are also some other sample files there for you to play with and
+learn from.
+
+If you selected to install the documentation then point your browser
+to [install dir]\wxPython\docs\index.htm and you will then be looking
+at the docs for wxWindows.  For the most part you can use the C++ docs
+as most classes and methods are used identically.  Where there are
+differences they are documented with a "wxPython Note."
+
+On Win32 systems the binary self-installer creates a program group on
+the Start Menu that contains a link to running the demo and a link to
+the help file.  To help you save disk space I'm now using Microsoft's
+HTML Help format.  If your system doesn't know what to do with the help
+file, you can install the HTML Help Viewer as part of IE 4+, NT
+Service Pack 4+, or the HTML Workshop at
+
+http://msdn.microsoft.com/workshop/author/htmlhelp/download.asp.
+
+
+
+Getting Help
+------------
+
+Since wxPython is a blending of multiple technologies, help comes from
+multiple sources.  See the http://alldunn.com/wxPython for details on
+various sources of help, but probably the best source is the
+wxPython-users mail list.  You can view the archive or subscribe by
+going to
+
+       http://starship.python.net/mailman/listinfo/wxpython-users
+
+Or you can send mail directly to the list using this address:
+
+       wxpython-users@starship.python.net
+
+----------------------------------------------------------------------
+
+What's new in 2.1b3
+--------------------
+
+This release is syncronized with release 2.1 snapshot 9 of wxWindows.
+
+Switched to using SWIG from CVS (see http://swig.cs.uchicago.edu/cvs.html)
+for some of the new features and such.  Also they have encorporated my
+patches so there is really no reason to stick with the current (very
+old) release...  This version of SWIG gives the following new
+features:
+
+    1. Keyword arguments.  You no longer have to specify all the
+       parameters with defaults to a method just to specify a
+       non-default value on the end.  You can now do this instead:
+
+	  win = wxWindow(parent, -1, style = mystyle)
+
+    2. There is now an an equivalence between Python's None and C++'s
+       NULL.  This means that any methods that might return NULL will
+       now return None and you can use none where wxWindows might be
+       expecting NULL.  This makes things much more snake-ish.
+
+
+There is a new build system based on a new Python program instead of
+raw makefiles.  Now wxPython builds are virtually the same on MSW or
+Unix systems.  See the end of this file for new build instructions and
+see distrib/build.py for more details.
+
+wxDC.Bilt now includes the useMask parameter, and has been split into
+two different versions.  wxDC.BlitXY is like what was there before and
+takes raw coordinants and sizes, and the new wxDC.Blit is for the new
+interface using wxPoints and a wxSize.
+
+
+
+
+
+What's new in 2.1b2
+--------------------
+
+Added the missing wxWindow.GetUpdateRegion() method.
+
+Made a new change in SWIG (update your patches everybody) that
+provides a fix for global shadow objects that get an exception in
+their __del__ when their extension module has already been deleted.
+It was only a 1 line change in .../SWIG/Modules/pycpp.cxx at about
+line 496 if you want to do it by hand.
+
+It is now possible to run through MainLoop more than once in any one
+process.  The cleanup that used to happen as MainLoop completed (and
+prevented it from running again) has been delayed until the wxc module
+is being unloaded by Python.
+
+I fixed a bunch of stuff in the C++ version of wxGrid so it wouldn't
+make wxPython look bad.
+
+wxWindow.PopupMenu() now takes a wxPoint instead of  x,y.  Added
+wxWindow.PopupMenuXY to be consistent with some other methods.
+
+Added wxGrid.SetEditInPlace and wxGrid.GetEditInPlace.
+
+You can now provide your own app.MainLoop method.  See
+wxPython/demo/demoMainLoop.py for an example and some explaination.
+
+Got the in-place-edit for the wxTreeCtrl fixed and added some demo
+code to show how to use it.
+
+Put the wxIcon constructor back in for GTK as it now has one that
+matches MSW's.
+
+Added wxGrid.GetCells
+
+Added wxSystemSettings static methods as functions with names like
+wxSystemSettings_GetSystemColour.
+
+Removed wxPyMenu since using menu callbacks have been depreciated in
+wxWindows.  Use wxMenu and events instead.
+
+Added alternate wxBitmap constructor (for MSW only) as
+      wxBitmapFromData(data, type, width, height, depth = 1)
+
+Added a helper function named wxPyTypeCast that can convert shadow
+objects of one type into shadow objects of another type.  (Like doing
+a down-cast.)  See the implementation in wx.py for some docs.
+
+Fixed wxImage GetData and SetData to properly use String objects for
+data transfer.
+
+Added access methods to wxGridEvent.
+
+New Makefile/Setup files supporting multiple dynamic extension modules
+for unix systems.
+
+Fixes for the wxGLCanvas demo to work around a strange bug in gtk.
+
+SWIG support routines now compiled separately instead of being bundled
+in wx.cpp.
+
+
+
+
+
+What's new in 2.1b1
+--------------------
+Fixed wxComboBox.SetSelection so that it actually sets the selected
+item.  (Actually just removed it from wxPython and let it default to
+wxChoice.SetSelection which was already doing the right thing.)
+
+Added the Printing Framework.
+
+Switched back to using the wxWindows DLL for the pre-built Win32
+version.  The problem was needing to reinitialize static class info
+data after loading each extension module.
+
+Lots of little tweaks and additions to reflect changes to various
+wxWindows classes.
+
+Fixed a bug with attaching objects to tree items.  Actually was a
+symptom of a larger problem with not obtaining the interpreter lock
+when doing any Py_DECREFs.
+
+wxSizer and friends.  Sizers are layout tools that manage a colection
+of windows and sizers.  Different types of sizers apply different
+types of layout algorithms.  You saw it here first!  These classes are
+not even in the wxWindows C++ library yet!
+
+
+
+What's new in 2.0b9
+-------------------
+Bug fix for ListCtrl in test4.py (Was a missing file...  DSM!)
+
+Bug fix for occassional GPF on Win32 systems upon termination of a
+wxPython application.
+
+Added wxListBox.GetSelections returning selections as a Tuple.
+
+Added a wxTreeItemData that is able to hold any Python object and be
+associated with items in a wxTreeCtrl.  Added test pytree.py to show
+this feature off.
+
+Added wxSafeYield function.
+
+OpenGL Canvas can be optionally compiled in to wxPython.
+
+Awesome new Demo Framework for showing off wxPython and for learning
+how it all works.
+
+The pre-built Win32 version is no longer distributing the wxWindows
+DLL.  It is statically linked with the wxWindows library instead.
+
+Added a couple missing items from the docs.
+
+Added wxImage, wxImageHandler, wxPNGHandler, wxJPEGHandler,
+wxGIFHandler and wxBMPHandler.
+
+Added new methods to wxTextCtrl.
+
+Fixed some problems with how SWIG was wrapping some wxTreeCtrl
+methods.
+
+
+
+What's new in 2.0b8
+-------------------
+Support for using Python threads in wxPython apps.
+
+Several missing methods from various classes.
+
+Various bug fixes.
+
+
+
+What's new in 2.0b7
+-------------------
+Added DLG_PNT and DLG_SZE convienience methods to wxWindow class.
+
+Added missing constructor and other methods for wxMenuItem.
+
+
+
+What's new in 2.0b6
+-------------------
+Just a quickie update to fix the self-installer to be compatible with
+Python 1.5.2b2's Registry settings.
+
+
+What's new in 2.0b5
+-------------------
+Well obviously the numbering scheme has changed.  I did this to
+reflect the fact that this truly is the second major revision of
+wxPython, (well the third actually if you count the one I did for
+wxWindows 1.68 and then threw away...) and also that it is associated
+with the 2.0 version of wxWindows.
+
+I have finally started documenting wxPython.  There are several pages
+in the wxWindows documentation tree specifically about wxPython, and I
+have added notes within the class references about where and how wxPython
+diverges from wxWindows.
+
+Added wxWindow_FromHWND(hWnd) for wxMSW to construct a wxWindow from a
+window handle.  If you can get the window handle into the python code,
+it should just work...  More news on this later.
+
+Added wxImageList, wxToolTip.
+
+Re-enabled wxConfig.DeleteAll() since it is reportedly fixed for the
+wxRegConfig class.
+
+As usual, some bug fixes, tweaks, etc.
+
+
+
+What's new in 0.5.3
+-------------------
+Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
+
+Various cleanup, tweaks, minor additions, etc. to maintain
+compatibility with the current wxWindows.
+
+
+
+What's new in 0.5.0
+-------------------
+Changed the import semantics from "from wxPython import *" to "from
+wxPython.wx import *"  This is for people who are worried about
+namespace pollution, they can use "from wxPython import wx" and then
+prefix all the wxPython identifiers with "wx."
+
+Added wxTaskbarIcon for wxMSW.
+
+Made the events work for wxGrid.
+
+Added wxConfig.
+
+Added wxMiniFrame for wxGTK.
+
+Changed many of the args and return values that were pointers to gdi
+objects to references to reflect changes in the wxWindows API.
+
+Other assorted fixes and additions.
+
+
+
+
+What's new in 0.4.2
+-------------------
+
+wxPython on wxGTK works!!!  Both dynamic and static on Linux and
+static on Solaris have been tested.  Many thanks go to Harm
+<H.v.d.Heijden@phys.tue.nl> for his astute detective work on tracking
+down a nasty DECREF bug.  Okay so I have to confess that it was just a
+DSM (Dumb Stupid Mistake) on my part but it was nasty none the less
+because the behavior was so different on different platforms.
+
+The dynamicly loaded module on Solaris is still segfaulting, so it
+must have been a different issue all along...
+
+
+
+What's New in 0.4
+-----------------
+
+1. Worked on wxGTK compatibility.  It is partially working.  On a
+Solaris/Sparc box wxPython is working but only when it is statically
+linked with the Python interpreter.  When built as a dyamically loaded
+extension module, things start acting weirdly and it soon seg-faults.
+And on Linux both the statically linked and the dynamically linked
+version segfault shortly after starting up.
+
+2. Added Toolbar, StatusBar and SplitterWindow classes.
+
+3. Varioius bug fixes, enhancements, etc.
+
+----------------------------------------------------------------------
+
+
+
+Build Instructions
+------------------
+I used SWIG (http://www.swig.org) to create the source code for the
+extension module.  This enabled me to only have to deal with a small
+amount of code and only have to bother with the exceptional issues.
+SWIG takes care of the rest and generates all the repetative code for
+me.  You don't need SWIG to build the extension module as all the
+generated C++ code is included under the src directory.
+
+I added a few minor features to SWIG to control some of the code
+generation.  If you want to play around with this you will need to get
+a recent version of SWIG from their CVS or from a daily build.  See
+http://www.swig.org/ for details.
+
+wxPython is organized as a Python package.  This means that the
+directory containing the results of the build process should be a
+subdirectory of a directory on the PYTHONPATH.  (And preferably should
+be named wxPython.)  You can control where the build process will dump
+wxPython by setting the TARGETDIR variable for the build utility, (see
+below.)
+
+
+1. Build wxWindows as described in its BuildCVS.txt file.  For *nix
+   systems I run configure with these flags:
+
+                --with-gtk
+                --with-libjpeg
+                --without-odbc
+                --enable-unicode=no
+                --enable-threads=yes
+                --enable-socket=yes
+                --enable-static=no
+                --enable-shared=yes
+                --disable-std_iostreams
+
+   You can use whatever flags you want, but I know these work.
+
+   For Win32 systems I use Visual C++ 6.0, but 5.0 should work.  The
+   build utility currently does not support any other win32 compilers.
+
+2. At this point you may want to make an alias or symlink, script,
+   batch file, whatever on the PATH that invokes
+   $(WXWIN)/utils/wxPython/distrib/build.py to help simplify matters
+   somewhat.  For example, on my win32 system I have a file named
+   build.bat in a directory on the PATH that contains:
+
+   python $(WXWIN)/utils/wxPython/distrib/build.py %1 %2 %3 %4 %5 %6
+
+
+3. Change into the $(WXWIN)/utils/wxPython/src directory.
+
+4. Type "build -b" to build wxPython and "build -i" to install it.
+
+   The build.py script actually generates a Makefile based on what it
+   finds on your system and information found in the build.cfg file.
+   If you have troubles building or you want it built or installed in
+   a different way, take a look at the docstring in build.py.  You may
+   be able to override configuration options in a file named
+   build.local.
+
+5. To build and install the add-on modules, change to the appropriate
+   directory under $(WXWIN)/utils/wxPython/modules and run the build
+   utility again.
+
+6. Change to the $(WXWIN)/utils/wxPython/demo directory.
+
+7. Try executing the demo program.  For example:
+
+    python demo.py
+
+To run it without requiring a console on win32, you can use the
+pythonw.exe version of Python either from the command line or from a
+shortcut.
+
+
+
+----------------
+Robin Dunn
+robin@alldunn.com
+
+
+
+
+
+
+

utils/wxPython/SWIG.patches/Include.patch

@@ -0,0 +1,139 @@
+*** swig.h.old	Wed Feb 04 15:59:40 1998
+--- swig.h	Fri Aug 28 15:46:32 1998
+***************
+*** 178,185 ****
+--- 178,211 ----
+    char  *firstkey();
+    char  *nextkey();
+  };
+
++ // -------------------------------------------------------------------
++ // Simple Vector class
++ // User is responsible for deleting contents before deleteing Vector
++ // -------------------------------------------------------------------
++
++ class Vector {
++ public:
++     Vector(size_t allocSize=8);
++     ~Vector();
++
++     size_t size()                      { return m_size;  }
++     size_t count()                     { return m_count; }
++     size_t append(void* object);
++     size_t extend(size_t newSize);
++
++     void*& operator[] (size_t idx);
++
++     static void*    s_nullPtr;
++
++ private:
++     size_t          m_size;
++     size_t          m_count;
++     void**          m_data;
++ };
++
++
+  /************************************************************************
+   * class DataType
+   *
+   * Defines the basic datatypes supported by the translator.
+***************
+*** 684,691 ****
+--- 710,761 ----
+  extern char  *name_get(char *vname, int suppress=0);
+  extern char  *name_set(char *vname, int suppress=0);
+  extern char  *name_construct(char *classname, int suppress=0);
+  extern char  *name_destroy(char *classname, int suppress=0);
++
++ // ----------------------------------------------------------------------
++ // class CPP_class
++ //
++ // Class for managing class members (internally)
++ // ----------------------------------------------------------------------
++
++ class CPP_member;
++
++ class CPP_class {
++ public:
++   char        *classname;             // Real class name
++   char        *classrename;           // New name of class (if applicable)
++   char        *classtype;             // class type (struct, union, class)
++   int          strip;                 // Strip off class declarator
++   int          wextern;               // Value of extern wrapper variable for this class
++   int          have_constructor;      // Status bit indicating if we've seen a constructor
++   int          have_destructor;       // Status bit indicating if a destructor has been seen
++   int          is_abstract;           // Status bit indicating if this is an abstract class
++   int          generate_default;      // Generate default constructors
++   int          objective_c;           // Set if this is an objective C class
++   int          error;                 // Set if this class can't be generated
++   int          line;                  // Line number
++   char        **baseclass;            // Base classes (if any)
++   Hash        *local;                 // Hash table for local types
++   Hash        *scope;                 // Local scope hash table
++   DocEntry    *de;                    // Documentation entry of class
++   CPP_member  *members;               // Linked list of members
++   CPP_class   *next;                  // Next class
++   static CPP_class *classlist;        // List of all classes stored
++
++   Vector      addPragmas;
++
++   CPP_class(char *name, char *ctype);
++   void add_member(CPP_member *m);
++   CPP_member *search_member(char *name);
++   void inherit_decls(int mode);
++   void emit_decls();
++   static CPP_class *search(char *name);
++   void create_default();
++   static void create_all();
++ };
++
++ extern CPP_class     *current_class;
+
+  /***********************************************************************
+   * -- Revision History
+   * $Log$
+   * Revision 1.2  1999/07/31 07:54:05  RD
+   * wxPython 2.1b1:
+   *
+   * 	Added the missing wxWindow.GetUpdateRegion() method.
+   *
+   * 	Made a new change in SWIG (update your patches everybody) that
+   * 	provides a fix for global shadow objects that get an exception in
+   * 	their __del__ when their extension module has already been deleted.
+   * 	It was only a 1 line change in .../SWIG/Modules/pycpp.cxx at about
+   * 	line 496 if you want to do it by hand.
+   *
+   * 	It is now possible to run through MainLoop more than once in any one
+   * 	process.  The cleanup that used to happen as MainLoop completed (and
+   * 	prevented it from running again) has been delayed until the wxc module
+   * 	is being unloaded by Python.
+   *
+   * 	wxWindow.PopupMenu() now takes a wxPoint instead of  x,y.  Added
+   * 	wxWindow.PopupMenuXY to be consistent with some other methods.
+   *
+   * 	Added wxGrid.SetEditInPlace and wxGrid.GetEditInPlace.
+   *
+   * 	You can now provide your own app.MainLoop method.  See
+   * 	wxPython/demo/demoMainLoop.py for an example and some explaination.
+   *
+   * 	Got the in-place-edit for the wxTreeCtrl fixed and added some demo
+   * 	code to show how to use it.
+   *
+   * 	Put the wxIcon constructor back in for GTK as it now has one that
+   * 	matches MSW's.
+   *
+   * 	Added wxGrid.GetCells
+   *
+   * 	Added wxSystemSettings static methods as functions with names like
+   * 	wxSystemSettings_GetSystemColour.
+   *
+   * 	Removed wxPyMenu since using menu callbacks have been depreciated in
+   * 	wxWindows.  Use wxMenu and events instead.
+   *
+   * 	Added alternate wxBitmap constructor (for MSW only) as
+   * 	      wxBitmapFromData(data, type, width, height, depth = 1)
+   *
+   * 	Added a helper function named wxPyTypeCast that can convert shadow
+   * 	objects of one type into shadow objects of another type.  (Like doing
+   * 	a down-cast.)  See the implementation in wx.py for some docs.
+   *

utils/wxPython/SWIG.patches/Modules.patch

@@ -0,0 +1,202 @@
+*** python.cxx.old	Fri Jan 02 23:17:40 1998
+--- python.cxx	Fri Aug 28 15:49:18 1998
+***************
+*** 1678,1685 ****
+--- 1678,1702 ----
+  		fprintf(stderr,"%s : Line %d. Unable to locate file %s\n", input_file, line_number, value);
+  	      }
+  	    }
+  	  }
++         } else if (strcmp(cmd, "addtomethod") == 0) {
++             // parse value, expected to be in the form "methodName:line"
++             char* txtptr = strchr(value, ':');
++             if (txtptr) {
++                 // add name and line to a list in current_class
++                 *txtptr = 0;
++                 txtptr++;
++                 AddPragmaData* apData = new AddPragmaData(value, txtptr);
++                 current_class->addPragmas.append(apData);
++
++             } else {
++                 fprintf(stderr,"%s : Line %d. Malformed addtomethod pragma.  Should be \"methodName:text\"\n",
++                         input_file, line_number);
++             }
++         } else if (strcmp(cmd, "addtoclass") == 0) {
++                 AddPragmaData* apData = new AddPragmaData("__class__", value);
++                 current_class->addPragmas.append(apData);
+  	} else {
+  	  fprintf(stderr,"%s : Line %d. Unrecognized pragma.\n", input_file, line_number);
+  	}
+      }
+*** python.h.old	Thu Jul 24 23:18:50 1997
+--- python.h	Fri Aug 28 15:46:08 1998
+***************
+*** 184,191 ****
+--- 184,203 ----
+    void cpp_declare_const(char *name, char *iname, DataType *type, char *value);
+    void cpp_class_decl(char *, char *,char *);
+    void pragma(char *, char *, char *);
+    void add_typedef(DataType *t, char *name);
++
++   void emitAddPragmas(String& output, char* name, char* spacing);
+  };
+
+  #define PYSHADOW_MEMBER  0x2
++
++ struct AddPragmaData {
++     String      m_method;
++     String      m_text;
++
++     AddPragmaData(char* method, char* text)
++         : m_method(method),
++           m_text(text)
++         {}
++ };
+
+*** pycpp.cxx.old	Fri Jan 02 21:23:22 1998
+--- pycpp.cxx	Tue Jul 20 14:34:36 1999
+***************
+*** 275,282 ****
+--- 275,283 ----
+  #endif
+        }
+      }
+      //    if ((t->type != T_VOID) || (t->is_pointer))
++     emitAddPragmas(*pyclass, realname, tab8);
+      *pyclass << tab8 << "return val\n";
+
+      // Change the usage string to reflect our shadow class
+
+***************
+*** 393,400 ****
+--- 394,402 ----
+  	}
+        }
+        *construct << ")\n";
+        *construct << tab8 << "self.thisown = 1\n";
++       emitAddPragmas(*construct, "__init__", tab8);
+        have_constructor = 1;
+      } else {
+
+        // Hmmm. We seem to be creating a different constructor.  We're just going to create a
+***************
+*** 490,503 ****
+        if (class_renamed) realname = class_name;
+        else realname = name;
+      }
+
+!     *pyclass << tab4 << "def __del__(self):\n"
+  	     << tab8 << "if self.thisown == 1 :\n"
+  	     << tab8 << tab4 << module << "." << name_destroy(realname) << "(self.this)\n";
+!
+      have_destructor = 1;
+-
+      if (doc_entry) {
+        doc_entry->usage = "";
+        doc_entry->usage << "del this";
+      }
+--- 492,504 ----
+        if (class_renamed) realname = class_name;
+        else realname = name;
+      }
+
+!     *pyclass << tab4 << "def __del__(self, " << module << "=" << module << "):\n"
+  	     << tab8 << "if self.thisown == 1 :\n"
+  	     << tab8 << tab4 << module << "." << name_destroy(realname) << "(self.this)\n";
+!     emitAddPragmas(*pyclass, "__del__", tab8);
+      have_destructor = 1;
+      if (doc_entry) {
+        doc_entry->usage = "";
+        doc_entry->usage << "del this";
+      }
+***************
+*** 551,558 ****
+--- 552,561 ----
+        repr << tab4 << "def __repr__(self):\n"
+  	   << tab8 << "return \"<C " << class_name <<" instance>\"\n";
+
+        classes << repr;
++       emitAddPragmas(classes, "__class__", tab4);
++
+      }
+
+      // Now build the real class with a normal constructor
+
+***************
+*** 746,753 ****
+--- 749,778 ----
+      hash.add(name,copy_string((char *) hash.lookup(t->name)));
+    }
+  }
+
++ // --------------------------------------------------------------------------------
++ // PYTHON::emitAddPragmas(String& output, char* name, char* spacing);
++ //
++ // Search the current_class->addPragmas vector for any text belonging to name.
++ // Append the text properly spcaed to the output string.
++ //
++ // --------------------------------------------------------------------------------
++
++ void PYTHON::emitAddPragmas(String& output, char* name, char* spacing)
++ {
++     AddPragmaData*      apData;
++     size_t              count;
++     int                 i;
++
++     count = current_class->addPragmas.count();
++     for (i=0; i<count; i++) {
++         apData = (AddPragmaData*)current_class->addPragmas[i];
++         if (strcmp(apData->m_method, name) == 0) {
++             output << spacing << apData->m_text << "\n";
++         }
++     }
++ }
+
+  /*********************************************************************************
+   *
+   * $Log$
+   * Revision 1.2  1999/07/31 07:54:05  RD
+   * wxPython 2.1b1:
+   *
+   * 	Added the missing wxWindow.GetUpdateRegion() method.
+   *
+   * 	Made a new change in SWIG (update your patches everybody) that
+   * 	provides a fix for global shadow objects that get an exception in
+   * 	their __del__ when their extension module has already been deleted.
+   * 	It was only a 1 line change in .../SWIG/Modules/pycpp.cxx at about
+   * 	line 496 if you want to do it by hand.
+   *
+   * 	It is now possible to run through MainLoop more than once in any one
+   * 	process.  The cleanup that used to happen as MainLoop completed (and
+   * 	prevented it from running again) has been delayed until the wxc module
+   * 	is being unloaded by Python.
+   *
+   * 	wxWindow.PopupMenu() now takes a wxPoint instead of  x,y.  Added
+   * 	wxWindow.PopupMenuXY to be consistent with some other methods.
+   *
+   * 	Added wxGrid.SetEditInPlace and wxGrid.GetEditInPlace.
+   *
+   * 	You can now provide your own app.MainLoop method.  See
+   * 	wxPython/demo/demoMainLoop.py for an example and some explaination.
+   *
+   * 	Got the in-place-edit for the wxTreeCtrl fixed and added some demo
+   * 	code to show how to use it.
+   *
+   * 	Put the wxIcon constructor back in for GTK as it now has one that
+   * 	matches MSW's.
+   *
+   * 	Added wxGrid.GetCells
+   *
+   * 	Added wxSystemSettings static methods as functions with names like
+   * 	wxSystemSettings_GetSystemColour.
+   *
+   * 	Removed wxPyMenu since using menu callbacks have been depreciated in
+   * 	wxWindows.  Use wxMenu and events instead.
+   *
+   * 	Added alternate wxBitmap constructor (for MSW only) as
+   * 	      wxBitmapFromData(data, type, width, height, depth = 1)
+   *
+   * 	Added a helper function named wxPyTypeCast that can convert shadow
+   * 	objects of one type into shadow objects of another type.  (Like doing
+   * 	a down-cast.)  See the implementation in wx.py for some docs.
+   *

utils/wxPython/SWIG.patches/SWIG.patch

@@ -0,0 +1,530 @@
+*** cplus.cxx.old	Mon Feb 02 15:55:42 1998
+--- cplus.cxx	Fri Aug 28 13:02:50 1998
+***************
+*** 581,612 ****
+  // Class for managing class members (internally)
+  // ----------------------------------------------------------------------
+
+  static char   *inherit_base_class = 0;
+
+- class CPP_class {
+- public:
+-   char        *classname;             // Real class name
+-   char        *classrename;           // New name of class (if applicable)
+-   char        *classtype;             // class type (struct, union, class)
+-   int          strip;                 // Strip off class declarator
+-   int          wextern;               // Value of extern wrapper variable for this class
+-   int          have_constructor;      // Status bit indicating if we've seen a constructor
+-   int          have_destructor;       // Status bit indicating if a destructor has been seen
+-   int          is_abstract;           // Status bit indicating if this is an abstract class
+-   int          generate_default;      // Generate default constructors
+-   int          objective_c;           // Set if this is an objective C class
+-   int          error;                 // Set if this class can't be generated
+-   int          line;                  // Line number
+-   char        **baseclass;            // Base classes (if any)
+-   Hash        *local;                 // Hash table for local types
+-   Hash        *scope;                 // Local scope hash table
+-   DocEntry    *de;                    // Documentation entry of class
+-   CPP_member  *members;               // Linked list of members
+-   CPP_class   *next;                  // Next class
+-   static CPP_class *classlist;        // List of all classes stored
+
+!   CPP_class(char *name, char *ctype) {
+      CPP_class *c;
+      classname = copy_string(name);
+      classtype = copy_string(ctype);
+      classrename = 0;
+--- 581,593 ----
+  // Class for managing class members (internally)
+  // ----------------------------------------------------------------------
+
+  static char   *inherit_base_class = 0;
++ CPP_class *CPP_class::classlist = 0;
++ CPP_class     *current_class;
+
+
+! CPP_class::CPP_class(char *name, char *ctype) {
+    CPP_class *c;
+    classname = copy_string(name);
+    classtype = copy_string(ctype);
+    classrename = 0;
+***************
+*** 642,650 ****
+    // ------------------------------------------------------------------------------
+    // Add a new C++ member to this class
+    // ------------------------------------------------------------------------------
+
+!   void add_member(CPP_member *m) {
+      CPP_member *cm;
+
+      // Set base class where this was defined
+      if (inherit_base_class)
+--- 623,631 ----
+  // ------------------------------------------------------------------------------
+  // Add a new C++ member to this class
+  // ------------------------------------------------------------------------------
+
+! void CPP_class::add_member(CPP_member *m) {
+    CPP_member *cm;
+
+    // Set base class where this was defined
+    if (inherit_base_class)
+***************
+*** 664,672 ****
+    // ------------------------------------------------------------------------------
+    // Search for a member with the given name. Returns the member on success, 0 on failure
+    // ------------------------------------------------------------------------------
+
+!   CPP_member *search_member(char *name) {
+      CPP_member *m;
+      char *c;
+      m = members;
+      while (m) {
+--- 645,653 ----
+  // ------------------------------------------------------------------------------
+  // Search for a member with the given name. Returns the member on success, 0 on failure
+  // ------------------------------------------------------------------------------
+
+! CPP_member *CPP_class::search_member(char *name) {
+    CPP_member *m;
+    char *c;
+    m = members;
+    while (m) {
+***************
+*** 680,688 ****
+    // ------------------------------------------------------------------------------
+    // Inherit.  Put all the declarations associated with this class into the current
+    // ------------------------------------------------------------------------------
+
+!   void inherit_decls(int mode) {
+      CPP_member *m;
+      m = members;
+      while (m) {
+        inherit_base_class = m->base;
+--- 661,669 ----
+  // ------------------------------------------------------------------------------
+  // Inherit.  Put all the declarations associated with this class into the current
+  // ------------------------------------------------------------------------------
+
+! void CPP_class::inherit_decls(int mode) {
+    CPP_member *m;
+    m = members;
+    while (m) {
+      inherit_base_class = m->base;
+***************
+*** 696,704 ****
+    // ------------------------------------------------------------------------------
+    // Emit all of the declarations associated with this class
+    // ------------------------------------------------------------------------------
+
+!   void emit_decls() {
+      CPP_member    *m = members;
+      int  last_scope = name_scope(0);
+      abstract = is_abstract;
+      while (m) {
+--- 677,685 ----
+  // ------------------------------------------------------------------------------
+  // Emit all of the declarations associated with this class
+  // ------------------------------------------------------------------------------
+
+! void CPP_class::emit_decls() {
+    CPP_member    *m = members;
+    int  last_scope = name_scope(0);
+    abstract = is_abstract;
+    while (m) {
+***************
+*** 713,721 ****
+    // ------------------------------------------------------------------------------
+    // Search for a given class in the list
+    // ------------------------------------------------------------------------------
+
+!   static CPP_class *search(char *name) {
+      CPP_class *c;
+      c = classlist;
+      if (!name) return 0;
+      while (c) {
+--- 694,702 ----
+  // ------------------------------------------------------------------------------
+  // Search for a given class in the list
+  // ------------------------------------------------------------------------------
+
+! CPP_class *CPP_class::search(char *name) {
+    CPP_class *c;
+    c = classlist;
+    if (!name) return 0;
+    while (c) {
+***************
+*** 729,737 ****
+    // Add default constructors and destructors
+    //
+    // ------------------------------------------------------------------------------
+
+!   void create_default() {
+      if (!generate_default) return;
+
+      // Try to generate a constructor if not available.
+
+--- 710,718 ----
+  // Add default constructors and destructors
+  //
+  // ------------------------------------------------------------------------------
+
+! void CPP_class::create_default() {
+    if (!generate_default) return;
+
+    // Try to generate a constructor if not available.
+
+***************
+*** 751,764 ****
+    // ------------------------------------------------------------------------------
+    // Dump *all* of the classes saved out to the various
+    // language modules (this does what cplus_close_class used to do)
+    // ------------------------------------------------------------------------------
+-   static void create_all();
+- };
+-
+- CPP_class *CPP_class::classlist = 0;
+- static CPP_class     *current_class;
+-
+  void CPP_class::create_all() {
+    CPP_class *c;
+    c = classlist;
+    while (c) {
+--- 732,739 ----
+*** vector.cxx.old	Fri Aug 28 15:23:16 1998
+--- vector.cxx	Fri Aug 28 15:46:52 1998
+***************
+*** 0 ****
+--- 1,182 ----
++
++ /*******************************************************************************
++  * Simplified Wrapper and Interface Generator  (SWIG)
++  *
++  * Dave Beazley
++  *
++  * Department of Computer Science        Theoretical Division (T-11)
++  * University of Utah                    Los Alamos National Laboratory
++  * Salt Lake City, Utah  84112           Los Alamos, New Mexico  87545
++  * beazley@cs.utah.edu                   beazley@lanl.gov
++  *
++  * Copyright (c) 1995-1997
++  * The University of Utah and the Regents of the University of California
++  * All Rights Reserved
++  *
++  * Permission is hereby granted, without written agreement and without
++  * license or royalty fees, to use, copy, modify, and distribute this
++  * software and its documentation for any purpose, provided that
++  * (1) The above copyright notice and the following two paragraphs
++  * appear in all copies of the source code and (2) redistributions
++  * including binaries reproduces these notices in the supporting
++  * documentation.   Substantial modifications to this software may be
++  * copyrighted by their authors and need not follow the licensing terms
++  * described here, provided that the new terms are clearly indicated in
++  * all files where they apply.
++  *
++  * IN NO EVENT SHALL THE AUTHOR, THE UNIVERSITY OF CALIFORNIA, THE
++  * UNIVERSITY OF UTAH OR DISTRIBUTORS OF THIS SOFTWARE BE LIABLE TO ANY
++  * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL
++  * DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION,
++  * EVEN IF THE AUTHORS OR ANY OF THE ABOVE PARTIES HAVE BEEN ADVISED OF
++  * THE POSSIBILITY OF SUCH DAMAGE.
++  *
++  * THE AUTHOR, THE UNIVERSITY OF CALIFORNIA, AND THE UNIVERSITY OF UTAH
++  * SPECIFICALLY DISCLAIM ANY WARRANTIES,INCLUDING, BUT NOT LIMITED TO,
++  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
++  * PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND
++  * THE AUTHORS AND DISTRIBUTORS HAVE NO OBLIGATION TO PROVIDE MAINTENANCE,
++  * SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
++  *
++  *******************************************************************************/
++
++ #include "internal.h"
++
++ /*******************************************************************************
++  * $Header$
++  *
++  * File : vector.cxx
++  *
++  * A very simple Vector class.  Allways assumes that memory allocations are
++  * successful.  Should be made more robust...
++  *
++  *******************************************************************************/
++
++ void* Vector::s_nullPtr = NULL;
++
++ // -----------------------------------------------------------------------------
++ // Vector::Vector(size_t allocSize = 8)
++ //
++ // Constructor.  Creates a new Vector.
++ //
++ // Inputs : initial allocation size (optional)
++ //
++ // Output : New Vector object.
++ //
++ // Side Effects : None
++ // -----------------------------------------------------------------------------
++
++ Vector::Vector(size_t allocSize)
++     : m_size(allocSize),
++       m_count(0),
++       m_data(0)
++ {
++     if (m_size) {
++         m_data = new void*[m_size];
++         int i;
++         for (i=0; i<m_size;i++)
++             m_data[i] = 0;
++     }
++ }
++
++
++ // -----------------------------------------------------------------------------
++ // Vector::~Vector
++ //
++ // Destructor.  Only cleans up the vector, not its contents!
++ //
++ // -----------------------------------------------------------------------------
++
++
++ Vector::~Vector() {
++     if (m_data) {
++         delete [] m_data;
++     }
++
++     m_data = 0;
++     m_size = m_count = 0;
++ }
++
++
++
++ // -----------------------------------------------------------------------------
++ // size_t Vector::extend(size_t newSize)
++ //
++ // Extends the vector to at least newSize length.  Won't do anything if newSize
++ // is smaller than the current size of the vector.
++ //
++ // Returns the new allocated size.
++ //
++ // -----------------------------------------------------------------------------
++
++ #define GRANULARITY     16
++
++ size_t Vector::extend(size_t newSize) {
++
++     if (newSize > m_size) {
++         newSize = newSize + (GRANULARITY - (newSize % GRANULARITY));
++
++         void** temp = new void*[newSize];
++         memcpy(temp, m_data, m_size*sizeof(void*));
++
++         int i;
++         for (i=m_size; i<newSize; i++)
++             temp[i] = 0;
++
++         delete [] m_data;
++         m_data = temp;
++         m_size = newSize;
++     }
++     return m_size;
++ }
++
++
++ // -----------------------------------------------------------------------------
++ // Vector::append(void* object)
++ //
++ // Appends the object pointer to vector at index m_count.  Increments m_count.
++ // Returns the new count.
++ // -----------------------------------------------------------------------------
++
++ size_t Vector::append(void* object) {
++     if (m_count >= m_size) {
++         extend(m_count + 1);
++     }
++
++     m_data[m_count] = object;
++     m_count += 1;
++
++     return m_count;
++ }
++
++
++ // -----------------------------------------------------------------------------
++ // Vector::operator[] (size_t idx)
++ //
++ // Returns a reference to the void pointer at idx.  If idx is beyond the range
++ // of the vector, returns a reference to s_nullPtr.
++ //
++ // -----------------------------------------------------------------------------
++
++ void*& Vector::operator[] (size_t idx) {
++     if (idx >= m_size) {
++         s_nullPtr = 0;
++         return s_nullPtr;
++     }
++
++     return m_data[idx];
++ }
++
++
++ /***********************************************************************
++  *
++  * -- Revision History
++  * $Log$
++  * Revision 1.3  1999/07/31 07:54:05  RD
++  * wxPython 2.1b1:
++  *
++  * 	Added the missing wxWindow.GetUpdateRegion() method.
++  *
++  * 	Made a new change in SWIG (update your patches everybody) that
++  * 	provides a fix for global shadow objects that get an exception in
++  * 	their __del__ when their extension module has already been deleted.
++  * 	It was only a 1 line change in .../SWIG/Modules/pycpp.cxx at about
++  * 	line 496 if you want to do it by hand.
++  *
++  * 	It is now possible to run through MainLoop more than once in any one
++  * 	process.  The cleanup that used to happen as MainLoop completed (and
++  * 	prevented it from running again) has been delayed until the wxc module
++  * 	is being unloaded by Python.
++  *
++  * 	wxWindow.PopupMenu() now takes a wxPoint instead of  x,y.  Added
++  * 	wxWindow.PopupMenuXY to be consistent with some other methods.
++  *
++  * 	Added wxGrid.SetEditInPlace and wxGrid.GetEditInPlace.
++  *
++  * 	You can now provide your own app.MainLoop method.  See
++  * 	wxPython/demo/demoMainLoop.py for an example and some explaination.
++  *
++  * 	Got the in-place-edit for the wxTreeCtrl fixed and added some demo
++  * 	code to show how to use it.
++  *
++  * 	Put the wxIcon constructor back in for GTK as it now has one that
++  * 	matches MSW's.
++  *
++  * 	Added wxGrid.GetCells
++  *
++  * 	Added wxSystemSettings static methods as functions with names like
++  * 	wxSystemSettings_GetSystemColour.
++  *
++  * 	Removed wxPyMenu since using menu callbacks have been depreciated in
++  * 	wxWindows.  Use wxMenu and events instead.
++  *
++  * 	Added alternate wxBitmap constructor (for MSW only) as
++  * 	      wxBitmapFromData(data, type, width, height, depth = 1)
++  *
++  * 	Added a helper function named wxPyTypeCast that can convert shadow
++  * 	objects of one type into shadow objects of another type.  (Like doing
++  * 	a down-cast.)  See the implementation in wx.py for some docs.
++  *
++  *
++  ***********************************************************************/
++
++
++
++
++
++
+*** makefile.msc.old	Mon Jun 23 16:15:32 1997
+--- makefile.msc	Fri Aug 28 11:21:58 1998
+***************
+*** 33,50 ****
+  # Normally, you shouldn't have to change anything below this point     #
+  ########################################################################
+
+  LIBOBJS = main.obj scanner.obj symbol.obj include.obj types.obj parms.obj emit.obj newdoc.obj ascii.obj \
+!           html.obj latex.obj cplus.obj lang.obj hash.obj sstring.obj wrapfunc.obj getopt.obj comment.obj typemap.obj naming.obj
+
+  LIBSRCS = main.cxx scanner.cxx symbol.cxx include.cxx types.cxx parms.cxx emit.cxx \
+! 	  newdoc.cxx ascii.cxx html.cxx latex.cxx cplus.cxx lang.cxx hash.cxx \
+            sstring.cxx wrapfunc.cxx getopt.cxx comment.cxx typemap.cxx naming.cxx
+
+  LIBHEADERS = internal.h ../Include/swig.h latex.h ascii.h html.h nodoc.h
+  LIBNAME      = ..\libswig.lib
+  INCLUDE  = -I../Include -I$(STD_INC)
+! CFLAGS   = -Zi -nologo -DSWIG_LIB="\"$(SWIG_LIB)\"" -DSWIG_CC="\"$(CC)\""  -DMSDOS -DSTDC_HEADERS=1 -DHAVE_LIBDL=1 $(SWIG_OPTS)
+  LD_FLAGS    =  -VERBOSE
+
+
+  #
+--- 33,50 ----
+  # Normally, you shouldn't have to change anything below this point     #
+  ########################################################################
+
+  LIBOBJS = main.obj scanner.obj symbol.obj include.obj types.obj parms.obj emit.obj newdoc.obj ascii.obj \
+!           html.obj latex.obj cplus.obj lang.obj hash.obj vector.obj sstring.obj wrapfunc.obj getopt.obj comment.obj typemap.obj naming.obj
+
+  LIBSRCS = main.cxx scanner.cxx symbol.cxx include.cxx types.cxx parms.cxx emit.cxx \
+! 	  newdoc.cxx ascii.cxx html.cxx latex.cxx cplus.cxx lang.cxx hash.cxx vector.cxx \
+            sstring.cxx wrapfunc.cxx getopt.cxx comment.cxx typemap.cxx naming.cxx
+
+  LIBHEADERS = internal.h ../Include/swig.h latex.h ascii.h html.h nodoc.h
+  LIBNAME      = ..\libswig.lib
+  INCLUDE  = -I../Include -I$(STD_INC)
+! CFLAGS   = -Zi -nologo -DSWIG_LIB="\"$(SWIG_LIB)\"" -DSWIG_CC="\"$(CC)\""  -DMSDOS -DSTDC_HEADERS=1 -DHAVE_LIBDL=1 $(SWIG_OPTS) $(OTHERFLAGS)
+  LD_FLAGS    =  -VERBOSE
+
+
+  #
+*** makefile.bc.old	Sun Jan 04 13:49:24 1998
+--- makefile.bc	Fri Aug 28 15:42:58 1998
+***************
+*** 34,47 ****
+  ########################################################################
+
+  LIBOBJS = main.obj scanner.obj symbol.obj include.obj types.obj parms.obj \
+            emit.obj newdoc.obj ascii.obj \
+!           html.obj latex.obj cplus.obj lang.obj hash.obj sstring.obj \
+            wrapfunc.obj getopt.obj comment.obj typemap.obj naming.obj
+
+  LIBSRCS = main.cxx scanner.cxx symbol.cxx include.cxx types.cxx parms.cxx \
+            emit.cxx newdoc.cxx ascii.cxx html.cxx latex.cxx cplus.cxx lang.cxx hash.cxx \
+!           sstring.cxx wrapfunc.cxx getopt.cxx comment.cxx typemap.cxx naming.cxx
+
+  LIBHEADERS = internal.h ../Include/swig.h latex.h ascii.h html.h nodoc.h
+  LIBNAME      = ..\libswig.lib
+  INCLUDE  = -I../Include -I$(STD_INC)
+--- 34,47 ----
+  ########################################################################
+
+  LIBOBJS = main.obj scanner.obj symbol.obj include.obj types.obj parms.obj \
+            emit.obj newdoc.obj ascii.obj \
+!           html.obj latex.obj cplus.obj lang.obj hash.obj vector.obj sstring.obj \
+            wrapfunc.obj getopt.obj comment.obj typemap.obj naming.obj
+
+  LIBSRCS = main.cxx scanner.cxx symbol.cxx include.cxx types.cxx parms.cxx \
+            emit.cxx newdoc.cxx ascii.cxx html.cxx latex.cxx cplus.cxx lang.cxx hash.cxx \
+!           vector.cxx sstring.cxx wrapfunc.cxx getopt.cxx comment.cxx typemap.cxx naming.cxx
+
+  LIBHEADERS = internal.h ../Include/swig.h latex.h ascii.h html.h nodoc.h
+  LIBNAME      = ..\libswig.lib
+  INCLUDE  = -I../Include -I$(STD_INC)
+*** Makefile.in.old	Wed May 28 23:56:56 1997
+--- Makefile.in	Fri Aug 28 15:43:36 1998
+***************
+*** 51,63 ****
+  # Normally, you shouldn't have to change anything below this point     #
+  ########################################################################
+
+  LIBOBJS = main.o scanner.o symbol.o include.o types.o parms.o emit.o newdoc.o ascii.o \
+!           html.o latex.o cplus.o lang.o hash.o sstring.o wrapfunc.o getopt.o comment.o \
+            typemap.o naming.o
+
+  LIBSRCS = main.cxx scanner.cxx symbol.cxx include.cxx types.cxx parms.cxx emit.cxx \
+! 	  newdoc.cxx ascii.cxx html.cxx latex.cxx cplus.cxx lang.cxx hash.cxx \
+            sstring.cxx wrapfunc.cxx getopt.cxx comment.cxx typemap.cxx naming.cxx
+
+  LIBHEADERS = internal.h ../Include/swig.h latex.h ascii.h html.h nodoc.h
+  LIB      = ../libswig.a
+--- 51,63 ----
+  # Normally, you shouldn't have to change anything below this point     #
+  ########################################################################
+
+  LIBOBJS = main.o scanner.o symbol.o include.o types.o parms.o emit.o newdoc.o ascii.o \
+!           html.o latex.o cplus.o lang.o hash.o vector.o sstring.o wrapfunc.o getopt.o comment.o \
+            typemap.o naming.o
+
+  LIBSRCS = main.cxx scanner.cxx symbol.cxx include.cxx types.cxx parms.cxx emit.cxx \
+! 	  newdoc.cxx ascii.cxx html.cxx latex.cxx cplus.cxx lang.cxx hash.cxx vector.cxx \
+            sstring.cxx wrapfunc.cxx getopt.cxx comment.cxx typemap.cxx naming.cxx
+
+  LIBHEADERS = internal.h ../Include/swig.h latex.h ascii.h html.h nodoc.h
+  LIB      = ../libswig.a

utils/wxPython/demo/.cvsignore

@@ -0,0 +1,5 @@
+*.pyc
+.emacs.desktop
+hangman_dict.txt
+setup.bat
+tmphtml.txt

utils/wxPython/demo/ColorPanel.py

@@ -0,0 +1,13 @@
+
+from wxPython.wx import *
+
+#---------------------------------------------------------------------------
+
+
+class ColoredPanel(wxWindow):
+    def __init__(self, parent, color):
+        wxWindow.__init__(self, parent, -1,
+                          wxDefaultPosition, wxDefaultSize, wxRAISED_BORDER)
+        self.SetBackgroundColour(color)
+
+#---------------------------------------------------------------------------

utils/wxPython/demo/DialogUnits.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python
+#----------------------------------------------------------------------------
+# Name:         DialogUnits.py
+# Purpose:      A minimal wxPython program that is a bit smarter than test1.
+#
+# Author:       Robin Dunn
+#
+# Created:      A long time ago, in a galaxy far, far away...
+# RCS-ID:       $Id$
+# Copyright:    (c) 1998 by Total Control Software
+# Licence:      wxWindows license
+#----------------------------------------------------------------------------
+
+
+## import all of the wxPython GUI package
+from wxPython.wx import *
+
+
+#---------------------------------------------------------------------------
+
+## Create a new frame class, derived from the wxPython Frame.
+class MyFrame(wxFrame):
+
+    def __init__(self, parent, id, title):
+        # First, call the base class' __init__ method to create the frame
+        wxFrame.__init__(self, parent, id, title,
+                         wxPoint(100, 100), wxSize(160, 100))
+
+        # Associate some events with methods of this class
+        EVT_SIZE(self, self.OnSize)
+        EVT_MOVE(self, self.OnMove)
+
+        # Add a panel and some controls to display the size and position
+        panel = wxPanel(self, -1)
+        wxStaticText(panel, -1, "Size:",
+                     wxDLG_PNT(panel, wxPoint(4, 4)),  wxDefaultSize)
+        wxStaticText(panel, -1, "Pos:",
+                     wxDLG_PNT(panel, wxPoint(4, 16)), wxDefaultSize)
+        self.sizeCtrl = wxTextCtrl(panel, -1, "",
+                                   wxDLG_PNT(panel, wxPoint(24, 4)),
+                                   wxDLG_SZE(panel, wxSize(36, -1)),
+                                   wxTE_READONLY)
+
+        self.posCtrl = wxTextCtrl(panel, -1, "",
+                                  wxDLG_PNT(panel, wxPoint(24, 16)),
+                                  wxDLG_SZE(panel, wxSize(36, -1)),
+                                  wxTE_READONLY)
+
+        print wxDLG_PNT(panel, wxPoint(24, 4)), wxDLG_SZE(panel, wxSize(36, -1))
+        print wxDLG_PNT(panel, wxPoint(24, 16)),wxDLG_SZE(panel, wxSize(36, -1))
+
+
+    # This method is called automatically when the CLOSE event is
+    # sent to this window
+    def OnCloseWindow(self, event):
+        # tell the window to kill itself
+        self.Destroy()
+
+
+    # This method is called by the System when the window is resized,
+    # because of the association above.
+    def OnSize(self, event):
+        size = event.GetSize()
+        self.sizeCtrl.SetValue("%s, %s" % (size.width, size.height))
+
+        # tell the event system to continue looking for an event handler,
+        # so the default handler will get called.
+        event.Skip()
+
+    # This method is called by the System when the window is moved,
+    # because of the association above.
+    def OnMove(self, event):
+        pos = event.GetPosition()
+        self.posCtrl.SetValue("%s, %s" % (pos.x, pos.y))
+
+
+
+#---------------------------------------------------------------------------
+# if running standalone
+
+if __name__ == "__main__":
+    # Every wxWindows application must have a class derived from wxApp
+    class MyApp(wxApp):
+
+        # wxWindows calls this method to initialize the application
+        def OnInit(self):
+
+            # Create an instance of our customized Frame class
+            frame = MyFrame(NULL, -1, "This is a test")
+            frame.Show(true)
+
+            # Tell wxWindows that this is our main window
+            self.SetTopWindow(frame)
+
+            # Return a success flag
+            return true
+
+
+    app = MyApp(0)     # Create an instance of the application class
+    app.MainLoop()     # Tell it to start processing events
+
+
+#---------------------------------------------------------------------------
+# if running as part of the Demo Framework...
+
+def runTest(frame, nb, log):
+    win = MyFrame(frame, -1, "This is a test")
+    frame.otherWin = win
+    win.Show(true)
+
+
+overview = """\
+A simple example that shows how to use Dialog Units.
+"""
+
+#----------------------------------------------------------------------------
+#
+
+
+
+
+
+
+
+
+

utils/wxPython/demo/Layoutf.py

@@ -0,0 +1,62 @@
+
+from wxPython.wx          import *
+from wxPython.lib.layoutf import Layoutf
+
+#---------------------------------------------------------------------------
+
+class TestLayoutf(wxPanel):
+    def __init__(self, parent):
+        wxPanel.__init__(self, parent, -1)
+
+        self.SetAutoLayout(true)
+        EVT_BUTTON(self, 100, self.OnButton)
+
+        self.panelA = wxWindow(self, -1, wxPyDefaultPosition, wxPyDefaultSize, wxSIMPLE_BORDER)
+        self.panelA.SetBackgroundColour(wxBLUE)
+        self.panelA.SetConstraints(Layoutf('t=t10#1;l=l10#1;b=b10#1;r%r50#1',(self,)))
+
+        self.panelB = wxWindow(self, -1, wxPyDefaultPosition, wxPyDefaultSize, wxSIMPLE_BORDER)
+        self.panelB.SetBackgroundColour(wxRED)
+        self.panelB.SetConstraints(Layoutf('t=t10#1;r=r10#1;b%b30#1;l>10#2', (self,self.panelA)))
+
+        self.panelC = wxWindow(self, -1, wxPyDefaultPosition, wxPyDefaultSize, wxSIMPLE_BORDER)
+        self.panelC.SetBackgroundColour(wxWHITE)
+        self.panelC.SetConstraints(Layoutf('t_10#3;r=r10#1;b=b10#1;l>10#2', (self,self.panelA,self.panelB)))
+
+        b = wxButton(self.panelA, 100, ' Panel A ')
+        b.SetConstraints(Layoutf('X=X#1;Y=Y#1;h*;w%w50#1', (self.panelA,)))
+
+        b = wxButton(self.panelB, 100, ' Panel B ')
+        b.SetConstraints(Layoutf('t=t2#1;r=r4#1;h*;w*', (self.panelB,)))
+
+        self.panelD = wxWindow(self.panelC, -1, wxPyDefaultPosition, wxPyDefaultSize, wxSIMPLE_BORDER)
+        self.panelD.SetBackgroundColour(wxGREEN)
+        self.panelD.SetConstraints(Layoutf('b%h50#1;r%w50#1;h=h#2;w=w#2', (self.panelC, b)))
+
+        b = wxButton(self.panelC, 100, ' Panel C ')
+        b.SetConstraints(Layoutf('t_#1;l>#1;h*;w*', (self.panelD,)))
+
+        wxStaticText(self.panelD, -1, "Panel D", wxPoint(4, 4)).SetBackgroundColour(wxGREEN)
+
+    def OnButton(self, event):
+        wxBell()
+
+
+
+#---------------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+    win = TestLayoutf(nb)
+    return win
+
+#---------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+overview = Layoutf.__doc__

utils/wxPython/demo/Main.py

@@ -0,0 +1,336 @@
+#!/bin/env python
+#----------------------------------------------------------------------------
+# Name:         Main.py
+# Purpose:      Testing lots of stuff, controls, window types, etc.
+#
+# Author:       Robin Dunn & Gary Dumer
+#
+# Created:
+# RCS-ID:       $Id$
+# Copyright:    (c) 1999 by Total Control Software
+# Licence:      wxWindows license
+#----------------------------------------------------------------------------
+
+import sys, os
+from   wxPython.wx import *
+
+
+#---------------------------------------------------------------------------
+
+
+_treeList = [
+    ('Managed Windows', ['wxFrame', 'wxDialog', 'wxMiniFrame']),
+
+    ('Miscellaneous Windows', ['wxGrid', 'wxSashWindow',
+                               'wxScrolledWindow', 'wxSplitterWindow',
+                               'wxStatusBar', 'wxToolBar', 'wxNotebook']),
+
+    ('Common Dialogs', ['wxColourDialog', 'wxDirDialog', 'wxFileDialog',
+                        'wxSingleChoiceDialog', 'wxTextEntryDialog',
+                        'wxFontDialog', 'wxPageSetupDialog', 'wxPrintDialog',
+                        'wxMessageDialog', 'wxProgressDialog']),
+
+    ('Controls', ['wxButton', 'wxCheckBox', 'wxCheckListBox', 'wxChoice',
+                  'wxComboBox', 'wxGauge', 'wxListBox', 'wxListCtrl', 'wxTextCtrl',
+                  'wxTreeCtrl', 'wxSpinButton', 'wxStaticText', 'wxStaticBitmap',
+                  'wxRadioBox', 'wxSlider']),
+
+    ('Window Layout', ['wxLayoutConstraints', 'Sizers']),
+
+    ('Miscellaneous', ['wxTimer', 'wxGLCanvas', 'DialogUnits', 'wxImage',
+                      'PrintFramework']),
+
+    ('wxPython Library', ['Sizers', 'Layoutf', 'wxScrolledMessageDialog',
+                          'wxMultipleChoiceDialog', 'wxPlotCanvas']),
+
+    ('Cool Contribs', ['pyTree', 'hangman', 'SlashDot', 'XMLtreeview']),
+
+    ]
+
+#---------------------------------------------------------------------------
+
+class wxPythonDemo(wxFrame):
+    def __init__(self, parent, id, title):
+        wxFrame.__init__(self, parent, -1, title,
+                         wxDefaultPosition, wxSize(700, 550))
+        if wxPlatform == '__WXMSW__':
+            self.icon = wxIcon('bitmaps/mondrian.ico', wxBITMAP_TYPE_ICO)
+            self.SetIcon(self.icon)
+
+        self.otherWin = None
+        EVT_IDLE(self, self.OnIdle)
+
+        self.Centre(wxBOTH)
+        self.CreateStatusBar(1, wxST_SIZEGRIP)
+        splitter = wxSplitterWindow(self, -1)
+        splitter2 = wxSplitterWindow(splitter, -1)
+
+        # Prevent TreeCtrl from displaying all items after destruction
+        self.dying = false
+
+        # Make a File menu
+        self.mainmenu = wxMenuBar()
+        menu = wxMenu()
+        mID = NewId()
+        menu.Append(mID, 'E&xit', 'Get the heck outta here!')
+        EVT_MENU(self, mID, self.OnFileExit)
+        self.mainmenu.Append(menu, '&File')
+
+        # Make a Help menu
+        mID = NewId()
+        menu = wxMenu()
+        menu.Append(mID, '&About', 'wxPython RULES!!!')
+        EVT_MENU(self, mID, self.OnHelpAbout)
+        self.mainmenu.Append(menu, '&Help')
+        self.SetMenuBar(self.mainmenu)
+
+        selectedDemo = None
+        selectedDemoName = "Nada"
+        if len(sys.argv) == 2:
+            selectedDemoName = sys.argv[1]
+
+        # Create a TreeCtrl
+        tID = NewId()
+        self.tree = wxTreeCtrl(splitter, tID)
+        root = self.tree.AddRoot("Overview")
+        for item in _treeList:
+            child = self.tree.AppendItem(root, item[0])
+            for childItem in item[1]:
+                theDemo = self.tree.AppendItem(child, childItem)
+                if childItem == selectedDemoName:
+                    selectedDemo = theDemo
+
+        self.tree.Expand(root)
+        EVT_TREE_ITEM_EXPANDED   (self.tree, tID, self.OnItemExpanded)
+        EVT_TREE_ITEM_COLLAPSED  (self.tree, tID, self.OnItemCollapsed)
+        EVT_TREE_SEL_CHANGED     (self.tree, tID, self.OnSelChanged)
+
+        # Create a Notebook
+        self.nb = wxNotebook(splitter2, -1)
+
+        # Set up a TextCtrl on the Overview Notebook page
+        self.ovr = wxTextCtrl(self.nb, -1, style = wxTE_MULTILINE|wxTE_READONLY)
+        self.nb.AddPage(self.ovr, "Overview")
+
+
+        # Set up a TextCtrl on the Demo Code Notebook page
+        self.txt = wxTextCtrl(self.nb, -1,
+                              style = wxTE_MULTILINE|wxTE_READONLY|wxHSCROLL)
+        self.txt.SetFont(wxFont(9, wxMODERN, wxNORMAL, wxNORMAL, false))
+        self.nb.AddPage(self.txt, "Demo Code")
+
+
+        # Set up a log on the View Log Notebook page
+        self.log = wxTextCtrl(splitter2, -1,
+                              style = wxTE_MULTILINE|wxTE_READONLY|wxHSCROLL)
+        (w, self.charHeight) = self.log.GetTextExtent('X')
+        #self.WriteText('wxPython Demo Log:\n')
+
+
+        # add the windows to the splitter and split it.
+        splitter.SplitVertically(self.tree, splitter2)
+        splitter.SetSashPosition(180, true)
+        splitter.SetMinimumPaneSize(20)
+
+        splitter2.SplitHorizontally(self.nb, self.log)
+        splitter2.SetSashPosition(360, true)
+        splitter2.SetMinimumPaneSize(20)
+
+        # make our log window be stdout
+        #sys.stdout = self
+
+        # select initial items
+        self.nb.SetSelection(0)
+        self.tree.SelectItem(root)
+        if selectedDemo:
+            self.tree.SelectItem(selectedDemo)
+            self.tree.EnsureVisible(selectedDemo)
+
+    #---------------------------------------------
+    def WriteText(self, text):
+        self.log.WriteText(text)
+        w, h = self.log.GetClientSizeTuple()
+        numLines = h/self.charHeight
+        x, y = self.log.PositionToXY(self.log.GetLastPosition())
+        self.log.ShowPosition(self.log.XYToPosition(x, y-numLines))
+        ##self.log.ShowPosition(self.log.GetLastPosition())
+        self.log.SetInsertionPointEnd()
+
+    def write(self, txt):
+        self.WriteText(txt)
+
+    #---------------------------------------------
+    def OnItemExpanded(self, event):
+        item = event.GetItem()
+        self.log.WriteText("OnItemExpanded: %s\n" % self.tree.GetItemText(item))
+
+    #---------------------------------------------
+    def OnItemCollapsed(self, event):
+        item = event.GetItem()
+        self.log.WriteText("OnItemCollapsed: %s\n" % self.tree.GetItemText(item))
+
+    #---------------------------------------------
+    def OnSelChanged(self, event):
+        if self.dying:
+            return
+
+        if self.nb.GetPageCount() == 3:
+            if self.nb.GetSelection() == 2:
+                self.nb.SetSelection(0)
+            self.nb.DeletePage(2)
+
+        item = event.GetItem()
+        itemText = self.tree.GetItemText(item)
+
+        if itemText == 'Overview':
+            self.GetDemoFile('Main.py')
+            self.SetOverview('Overview', overview)
+            #self.nb.ResizeChildren();
+            self.nb.Refresh();
+            #wxYield()
+
+        else:
+            if os.path.exists(itemText + '.py'):
+                self.GetDemoFile(itemText + '.py')
+                module = __import__(itemText, globals())
+                self.SetOverview(itemText, module.overview)
+
+                # in case runTest is modal, make sure things look right...
+                self.nb.Refresh();
+                wxYield()
+
+                window = module.runTest(self, self.nb, self)
+                if window:
+                    self.nb.AddPage(window, 'Demo')
+                    self.nb.SetSelection(2)
+                    self.nb.ResizeChildren();
+
+            else:
+                self.ovr.Clear()
+                self.txt.Clear()
+
+
+    #---------------------------------------------
+    # Get the Demo files
+    def GetDemoFile(self, filename):
+        self.txt.Clear()
+        #if not self.txt.LoadFile(filename):
+        #    self.txt.WriteText("Cannot open %s file." % filename)
+        try:
+            self.txt.SetValue(open(filename).read())
+        except IOError:
+            self.txt.WriteText("Cannot open %s file." % filename)
+
+
+        self.txt.SetInsertionPoint(0)
+        self.txt.ShowPosition(0)
+
+    #---------------------------------------------
+    def SetOverview(self, name, text):
+        self.ovr.Clear()
+        self.ovr.WriteText(text)
+        self.nb.SetPageText(0, name)
+        self.ovr.SetInsertionPoint(0)
+        self.ovr.ShowPosition(0)
+
+    #---------------------------------------------
+    # Menu methods
+    def OnFileExit(self, event):
+        self.Close()
+
+
+    def OnHelpAbout(self, event):
+        about = wxMessageDialog(self,
+                                "wxPython is a Python extension module that\n"
+                                "encapsulates the wxWindows GUI classes.\n\n"
+                                "This demo shows off some of the capabilities\n"
+                                "of wxPython.\n\n"
+                                "          Developed by Robin Dunn",
+                               "About wxPython", wxOK)
+        about.ShowModal()
+        about.Destroy()
+
+
+    #---------------------------------------------
+    def OnCloseWindow(self, event):
+        self.dying = true
+        self.Destroy()
+
+    #---------------------------------------------
+    def OnIdle(self, event):
+        if self.otherWin:
+            self.otherWin.Raise()
+            self.otherWin = None
+
+
+#---------------------------------------------------------------------------
+#---------------------------------------------------------------------------
+
+class MyApp(wxApp):
+    def OnInit(self):
+        wxImage_AddHandler(wxJPEGHandler())
+        wxImage_AddHandler(wxPNGHandler())
+        wxImage_AddHandler(wxGIFHandler())
+        frame = wxPythonDemo(NULL, -1, "wxPython: (A Demonstration)")
+        frame.Show(true)
+        self.SetTopWindow(frame)
+        return true
+
+#---------------------------------------------------------------------------
+
+def main():
+    app = MyApp(0)
+    app.MainLoop()
+
+
+#---------------------------------------------------------------------------
+
+
+
+overview = """\
+Python
+------------
+
+Python is an interpreted, interactive, object-oriented programming language often compared to Tcl, Perl, Scheme, or Java.
+
+Python combines remarkable power with very clear syntax. It has modules, classes, exceptions, very high level dynamic data types, and dynamic typing. There are interfaces to many system calls and libraries, and new built-in modules are easily written in C or C++. Python is also usable as an extension language for applications that need a programmable interface.
+
+wxWindows
+--------------------
+
+wxWindows is a free C++ framework designed to make cross-platform programming child's play. Well, almost. wxWindows 2 supports Windows 3.1/95/98/NT, Unix with GTK/Motif/Lesstif, with a Mac version underway. Other ports are under consideration.
+
+wxWindows is a set of libraries that allows C++ applications to compile and run on several different types of computers, with minimal source code changes. There is one library per supported GUI (such as Motif, or Windows). As well as providing a common API (Application Programming Interface) for GUI functionality, it provides functionality for accessing some commonly-used operating system facilities, such as copying or deleting files. wxWindows is a 'framework' in the sense that it provides a lot of built-in functionality, which the application can use or replace as required, thus saving a great deal of coding effort. Basic data structures such as strings, linked lists and hash tables are also supported.
+
+wxPython
+----------------
+
+wxPython is a Python extension module that encapsulates the wxWindows GUI classes. Currently it is only available for the Win32 and GTK ports of wxWindows, but as soon as the other ports are brought up to the same level as Win32 and GTK, it should be fairly trivial to enable wxPython to be used with the new GUI.
+
+The wxPython extension module attempts to mirror the class heiarchy of wxWindows as closely as possible. This means that there is a wxFrame class in wxPython that looks, smells, tastes and acts almost the same as the wxFrame class in the C++ version. Unfortunately, because of differences in the languages, wxPython doesn't match wxWindows exactly, but the differences should be easy to absorb because they are natural to Python. For example, some methods that return multiple values via argument pointers in C++ will return a tuple of values in Python.
+
+There is still much to be done for wxPython, many classes still need to be mirrored. Also, wxWindows is still somewhat of a moving target so it is a bit of an effort just keeping wxPython up to date. On the other hand, there are enough of the core classes completed that useful applications can be written.
+
+wxPython is close enough to the C++ version that the majority of the wxPython documentation is actually just notes attached to the C++ documents that describe the places where wxPython is different. There is also a series of sample programs included, and a series of documentation pages that assist the programmer in getting started with wxPython.
+"""
+
+
+
+
+
+
+
+#----------------------------------------------------------------------------
+#----------------------------------------------------------------------------
+
+if __name__ == '__main__':
+    main()
+
+#----------------------------------------------------------------------------
+
+
+
+
+
+
+

utils/wxPython/demo/PrintFramework.py

@@ -0,0 +1,179 @@
+
+from wxPython.wx         import *
+from wxPython.lib.sizers import *
+from wxScrolledWindow    import MyCanvas
+
+#----------------------------------------------------------------------
+
+class MyPrintout(wxPrintout):
+    def __init__(self, canvas, log):
+        wxPrintout.__init__(self)
+        self.canvas = canvas
+        self.log = log
+
+    def OnBeginDocument(self, start, end):
+        self.log.WriteText("wxPrintout.OnBeginDocument\n")
+        return self.base_OnBeginDocument(start, end)
+
+    def OnEndDocument(self):
+        self.log.WriteText("wxPrintout.OnEndDocument\n")
+        self.base_OnEndDocument()
+
+    def OnBeginPrinting(self):
+        self.log.WriteText("wxPrintout.OnBeginPrinting\n")
+        self.base_OnBeginPrinting()
+
+    def OnEndPrinting(self):
+        self.log.WriteText("wxPrintout.OnEndPrinting\n")
+        self.base_OnEndPrinting()
+
+    def OnPreparePrinting(self):
+        self.log.WriteText("wxPrintout.OnPreparePrinting\n")
+        self.base_OnPreparePrinting()
+
+    def HasPage(self, page):
+        self.log.WriteText("wxPrintout.HasPage\n")
+        if page == 1:
+            return true
+        else:
+            return false
+
+    def GetPageInfo(self):
+        self.log.WriteText("wxPrintout.GetPageInfo\n")
+        return (1, 1, 1, 1)
+
+    def OnPrintPage(self, page):
+        self.log.WriteText("wxPrintout.OnPrintPage\n")
+        dc = self.GetDC()
+
+        #-------------------------------------------
+        # One possible method of setting scaling factors...
+
+        maxX = self.canvas.getWidth()
+        maxY = self.canvas.getHeight()
+
+        # Let's have at least 50 device units margin
+        marginX = 50
+        marginY = 50
+
+        # Add the margin to the graphic size
+        maxX = maxX + (2 * marginX)
+        maxY = maxY + (2 * marginY)
+
+        # Get the size of the DC in pixels
+        (w, h) = dc.GetSizeTuple()
+
+        # Calculate a suitable scaling factor
+        scaleX = float(w) / maxX
+        scaleY = float(h) / maxY
+
+        # Use x or y scaling factor, whichever fits on the DC
+        actualScale = min(scaleX, scaleY)
+
+        # Calculate the position on the DC for centring the graphic
+        posX = (w - (self.canvas.getWidth() * actualScale)) / 2.0
+        posY = (h - (self.canvas.getHeight() * actualScale)) / 2.0
+
+        # Set the scale and origin
+        dc.SetUserScale(actualScale, actualScale)
+        dc.SetDeviceOrigin(int(posX), int(posY))
+
+        #-------------------------------------------
+
+        self.canvas.DoDrawing(dc)
+        return true
+
+
+#----------------------------------------------------------------------
+
+
+class TestPrintPanel(wxPanel):
+    def __init__(self, parent, frame, log):
+        wxPanel.__init__(self, parent, -1)
+        self.log = log
+        self.frame = frame
+
+
+        self.printData = wxPrintData()
+        self.printData.SetPaperId(wxPAPER_LETTER)
+
+        self.box = box.wxBoxSizer(wxVERTICAL)
+        self.canvas = MyCanvas(self)
+        self.box.Add(self.canvas, 1)
+
+        subbox = wxBoxSizer(wxHORIZONTAL)
+        btn = wxButton(self, 1201, "Print Setup")
+        EVT_BUTTON(self, 1201, self.OnPrintSetup)
+        subbox.Add(btn, 1)
+
+        btn = wxButton(self, 1202, "Print Preview")
+        EVT_BUTTON(self, 1202, self.OnPrintPreview)
+        subbox.Add(btn, 1)
+
+        btn = wxButton(self, 1203, "Print")
+        EVT_BUTTON(self, 1203, self.OnDoPrint)
+        subbox.Add(btn, 1)
+
+        self.box.Add(subbox)
+
+
+
+    def OnSize(self, event):
+        size = self.GetClientSize()
+        self.box.Layout(size)
+
+    def OnPrintSetup(self, event):
+        printerDialog = wxPrintDialog(self)
+        printerDialog.GetPrintDialogData().SetPrintData(self.printData)
+        printerDialog.GetPrintDialogData().SetSetupDialog(true)
+        printerDialog.ShowModal();
+        self.printData = printerDialog.GetPrintDialogData().GetPrintData()
+        printerDialog.Destroy()
+
+
+    def OnPrintPreview(self, event):
+        self.log.WriteText("OnPrintPreview\n")
+        printout = MyPrintout(self.canvas, self.log)
+        printout2 = MyPrintout(self.canvas, self.log)
+        self.preview = wxPrintPreview(printout, printout2, self.printData)
+        if not self.preview.Ok():
+            self.log.WriteText("Houston, we have a problem...\n")
+            return
+
+        frame = wxPreviewFrame(self.preview, self.frame, "This is a print preview")
+
+        frame.Initialize()
+        frame.SetPosition(self.frame.GetPosition())
+        frame.SetSize(self.frame.GetSize())
+        frame.Show(true)
+
+
+
+    def OnDoPrint(self, event):
+        pdd = wxPrintDialogData()
+        pdd.SetPrintData(self.printData)
+        printer = wxPrinter(pdd)
+        printout = MyPrintout(self.canvas, self.log)
+        if not printer.Print(self.frame, printout):
+            wxMessageBox("There was a problem printing.\nPerhaps your current printer is not set correctly?", "Printing", wxOK)
+        else:
+            self.printData = printer.GetPrintDialogData().GetPrintData()
+        printout.Destroy()
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+    win = TestPrintPanel(nb, frame, log)
+    return win
+
+
+#----------------------------------------------------------------------
+
+
+
+
+
+overview = """\
+"""
+

utils/wxPython/demo/README.txt

@@ -0,0 +1,7 @@
+To run the main demo in this directory, execute demo.py.  In other
+words, one of the following commands should do it:
+
+       demo.py
+       python demo.py
+       pythonw demo.py
+

utils/wxPython/demo/Sizers.py

@@ -0,0 +1,365 @@
+#----------------------------------------------------------------------
+# sizer test code
+#----------------------------------------------------------------------
+
+from wxPython.wx         import *
+from wxPython.lib.sizers import *
+
+#----------------------------------------------------------------------
+
+def makeSimpleBox1(win):
+    box = wxBoxSizer(wxHORIZONTAL)
+    box.Add(wxButton(win, 1010, "one"), 0)
+    box.Add(wxButton(win, 1010, "two"), 0)
+    box.Add(wxButton(win, 1010, "three"), 0)
+    box.Add(wxButton(win, 1010, "four"), 0)
+
+    return box
+
+#----------------------------------------------------------------------
+
+def makeSimpleBox2(win):
+    box = wxBoxSizer(wxVERTICAL)
+    box.Add(wxButton(win, 1010, "one"), 0)
+    box.Add(wxButton(win, 1010, "two"), 0)
+    box.Add(wxButton(win, 1010, "three"), 0)
+    box.Add(wxButton(win, 1010, "four"), 0)
+
+    return box
+
+#----------------------------------------------------------------------
+
+def makeSimpleBox3(win):
+    box = wxBoxSizer(wxHORIZONTAL)
+    box.Add(wxButton(win, 1010, "one"), 0)
+    box.Add(wxButton(win, 1010, "two"), 0)
+    box.Add(wxButton(win, 1010, "three"), 0)
+    box.Add(wxButton(win, 1010, "four"), 0)
+    box.Add(wxButton(win, 1010, "five"), 1)
+
+    return box
+
+#----------------------------------------------------------------------
+
+def makeSimpleBox4(win):
+    box = wxBoxSizer(wxHORIZONTAL)
+    box.Add(wxButton(win, 1010, "one"), 0)
+    box.Add(wxButton(win, 1010, "two"), 0)
+    box.Add(wxButton(win, 1010, "three"), 1)
+    box.Add(wxButton(win, 1010, "four"), 1)
+    box.Add(wxButton(win, 1010, "five"), 1)
+
+    return box
+
+#----------------------------------------------------------------------
+
+def makeSimpleBox5(win):
+    box = wxBoxSizer(wxHORIZONTAL)
+    box.Add(wxButton(win, 1010, "one"), 0)
+    box.Add(wxButton(win, 1010, "two"), 0)
+    box.Add(wxButton(win, 1010, "three"), 3)
+    box.Add(wxButton(win, 1010, "four"), 1)
+    box.Add(wxButton(win, 1010, "five"), 1)
+
+    return box
+
+#----------------------------------------------------------------------
+
+def makeSimpleBox6(win):
+    box = wxBoxSizer(wxHORIZONTAL, wxSize(250, 50))
+    box.Add(wxButton(win, 1010, "10"), 10)
+    box.Add(wxButton(win, 1010, "20"), 20)
+    box.Add(wxButton(win, 1010, "30"), 30)
+    box.Add(wxButton(win, 1010, "15"), 15)
+    box.Add(wxButton(win, 1010, "5"), 5)
+
+    return box
+
+#----------------------------------------------------------------------
+
+def makeSimpleBorder1(win):
+    bdr = wxBorderSizer(wxALL)
+    btn = wxButton(win, 1010, "border")
+    btn.SetSize(wxSize(80, 80))
+    bdr.Add(btn, 15)
+
+    return bdr
+
+#----------------------------------------------------------------------
+
+def makeSimpleBorder2(win):
+    bdr = wxBorderSizer(wxEAST | wxWEST)
+    btn = wxButton(win, 1010, "border")
+    btn.SetSize(wxSize(80, 80))
+    bdr.Add(btn, 15)
+
+    return bdr
+
+#----------------------------------------------------------------------
+
+def makeSimpleBorder3(win):
+    bdr = wxBorderSizer(wxNORTH | wxWEST)
+    btn = wxButton(win, 1010, "border")
+    btn.SetSize(wxSize(80, 80))
+    bdr.Add(btn, 15)
+
+    return bdr
+
+#----------------------------------------------------------------------
+#----------------------------------------------------------------------
+
+def makeBoxInBox(win):
+    box = wxBoxSizer(wxVERTICAL)
+
+    box.Add(wxButton(win, 1010, "one"))
+
+    box2 = wxBoxSizer(wxHORIZONTAL)
+    box2.AddMany([ wxButton(win, 1010, "two"),
+                   wxButton(win, 1010, "three"),
+                   wxButton(win, 1010, "four"),
+                   wxButton(win, 1010, "five"),
+                   ])
+
+    box3 = wxBoxSizer(wxVERTICAL)
+    box3.AddMany([ (wxButton(win, 1010, "six"),   0),
+                   (wxButton(win, 1010, "seven"), 2),
+                   (wxButton(win, 1010, "eight"), 1),
+                   (wxButton(win, 1010, "nine"),  1),
+                   ])
+
+    box2.Add(box3, 1)
+    box.Add(box2, 1)
+
+    box.Add(wxButton(win, 1010, "ten"))
+
+    return box
+
+#----------------------------------------------------------------------
+
+def makeBoxInBorder(win):
+    bdr = wxBorderSizer(wxALL)
+    box = makeSimpleBox3(win)
+    bdr.Add(box, 15)
+
+    return bdr
+
+#----------------------------------------------------------------------
+
+def makeBorderInBox(win):
+    insideBox = wxBoxSizer(wxHORIZONTAL)
+
+    box2 = wxBoxSizer(wxHORIZONTAL)
+    box2.AddMany([ wxButton(win, 1010, "one"),
+                   wxButton(win, 1010, "two"),
+                   wxButton(win, 1010, "three"),
+                   wxButton(win, 1010, "four"),
+                   wxButton(win, 1010, "five"),
+                 ])
+
+    insideBox.Add(box2, 0)
+
+    bdr = wxBorderSizer(wxALL)
+    bdr.Add(wxButton(win, 1010, "border"), 20)
+    insideBox.Add(bdr, 1)
+
+    box3 = wxBoxSizer(wxVERTICAL)
+    box3.AddMany([ (wxButton(win, 1010, "six"),   0),
+                   (wxButton(win, 1010, "seven"), 2),
+                   (wxButton(win, 1010, "eight"), 1),
+                   (wxButton(win, 1010, "nine"),  1),
+                 ])
+    insideBox.Add(box3, 1)
+
+    outsideBox = wxBoxSizer(wxVERTICAL)
+    outsideBox.Add(wxButton(win, 1010, "top"))
+    outsideBox.Add(insideBox, 1)
+    outsideBox.Add(wxButton(win, 1010, "bottom"))
+
+    return outsideBox
+
+
+#----------------------------------------------------------------------
+
+theTests = [
+    ("Simple horizontal boxes", makeSimpleBox1,
+     "This is a HORIZONTAL box sizer with four non-stretchable buttons held "
+     "within it.  Notice that the buttons are added and aligned in the horizontal "
+     "dimension.  Also notice that they are fixed size in the horizontal dimension, "
+     "but will stretch vertically."
+     ),
+
+    ("Simple vertical boxes", makeSimpleBox2,
+     "Exactly the same as the previous sample but using a VERTICAL box sizer "
+     "instead of a HORIZONTAL one."
+     ),
+
+    ("Add a stretchable", makeSimpleBox3,
+     "We've added one more button with the strechable flag turned on.  Notice "
+     "how it grows to fill the extra space in the otherwise fixed dimension."
+     ),
+
+    ("More than one stretchable", makeSimpleBox4,
+     "Here there are several items that are stretchable, they all divide up the "
+     "extra space evenly."
+     ),
+
+    ("Weighting factor", makeSimpleBox5,
+     "This one shows more than one strechable, but one of them has a weighting "
+     "factor so it gets more of the free space."
+     ),
+
+#    ("Percent Sizer", makeSimpleBox6,
+#     "You can use the wxBoxSizer like a Percent Sizer.  Just make sure that all "
+#     "the weighting factors add up to 100!"
+#     ),
+
+    ("", None, ""),
+
+    ("Simple border sizer", makeSimpleBorder1,
+     "The wxBorderSizer leaves empty space around its contents.  This one "
+     "gives a border all the way around."
+     ),
+
+    ("East and West border", makeSimpleBorder2,
+     "You can pick and choose which sides have borders."
+     ),
+
+    ("North and West border", makeSimpleBorder3,
+     "You can pick and choose which sides have borders."
+     ),
+
+    ("", None, ""),
+
+    ("Boxes inside of boxes", makeBoxInBox,
+     "This one shows nesting of boxes within boxes within boxes, using both "
+     "orientations.  Notice also that button seven has a greater weighting "
+     "factor than its siblings."
+     ),
+
+    ("Boxes inside a Border", makeBoxInBorder,
+     "Sizers of different types can be nested withing each other as well. "
+     "Here is a box sizer with several buttons embedded within a border sizer."
+     ),
+
+    ("Border in a Box", makeBorderInBox,
+     "Another nesting example.  This one has Boxes and a Border inside another Box."
+     ),
+
+    ]
+#----------------------------------------------------------------------
+
+class TestFrame(wxFrame):
+    def __init__(self, parent, title, sizerFunc):
+        wxFrame.__init__(self, parent, -1, title)
+        EVT_BUTTON(self, 1010, self.OnButton)
+
+        self.sizer = sizerFunc(self)
+        self.CreateStatusBar()
+        self.SetStatusText("Resize this frame to see how the sizers respond...")
+        self.sizer.FitWindow(self)
+
+
+    def OnSize(self, event):
+        size = self.GetClientSize()
+        self.sizer.Layout(size)
+
+    def OnCloseWindow(self, event):
+        self.MakeModal(false)
+        self.Destroy()
+
+    def OnButton(self, event):
+        self.Close(true)
+
+#----------------------------------------------------------------------
+
+
+
+class TestSelectionPanel(wxPanel):
+    def __init__(self, parent, frame):
+        wxPanel.__init__(self, parent, -1)
+        self.frame = frame
+
+        self.list = wxListBox(self, 401,
+                              wxDLG_PNT(self, 10, 10), wxDLG_SZE(self, 100, 60),
+                              [])
+        EVT_LISTBOX(self, 401, self.OnSelect)
+        EVT_LISTBOX_DCLICK(self, 401, self.OnDClick)
+
+        wxButton(self, 402, "Try it!", wxDLG_PNT(self, 120, 10)).SetDefault()
+        EVT_BUTTON(self, 402, self.OnDClick)
+
+        self.text = wxTextCtrl(self, -1, "",
+                               wxDLG_PNT(self, 10, 80),
+                               wxDLG_SZE(self, 200, 60),
+                               wxTE_MULTILINE | wxTE_READONLY)
+
+        for item in theTests:
+            self.list.Append(item[0])
+
+
+
+    def OnSelect(self, event):
+        pos = self.list.GetSelection()
+        self.text.SetValue(theTests[pos][2])
+
+
+    def OnDClick(self, event):
+        pos = self.list.GetSelection()
+        title = theTests[pos][0]
+        func = theTests[pos][1]
+
+        if func:
+            win = TestFrame(self, title, func)
+            win.CentreOnParent(wxBOTH)
+            win.Show(true)
+            win.MakeModal(true)
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+    win = TestSelectionPanel(nb, frame)
+    return win
+
+overview = wxSizer.__doc__        + '\n' + '-' * 80 + '\n' + \
+           wxBoxSizer.__doc__     + '\n' + '-' * 80 + '\n' + \
+           wxBorderSizer.__doc__
+
+#----------------------------------------------------------------------
+
+
+
+if __name__ == '__main__':
+
+    class MainFrame(wxFrame):
+        def __init__(self):
+            wxFrame.__init__(self, NULL, -1, "Testing...")
+
+	    self.CreateStatusBar()
+	    mainmenu = wxMenuBar()
+	    menu = wxMenu()
+	    menu.Append(200, 'E&xit', 'Get the heck outta here!')
+	    mainmenu.Append(menu, "&File")
+	    self.SetMenuBar(mainmenu)
+            EVT_MENU(self, 200, self.OnExit)
+            self.panel = TestSelectionPanel(self)
+            self.SetSize(wxSize(400, 380))
+
+        def OnCloseWindow(self, event):
+            self.Destroy()
+
+        def OnExit(self, event):
+            self.Close(true)
+
+
+    class TestApp(wxApp):
+        def OnInit(self):
+            frame = MainFrame()
+            frame.Show(true)
+            self.SetTopWindow(frame)
+            return true
+
+    app = TestApp(0)
+    app.MainLoop()
+
+
+#----------------------------------------------------------------------

utils/wxPython/demo/SlashDot.py

@@ -0,0 +1,378 @@
+#!/usr/bin/python
+"""This is SlashDot 1.2
+
+    It's the obligatory Slashdot.org headlines reader that
+any modern widget set/library must have in order to be taken
+seriously :-)
+
+    Usage is quite simple; wxSlash attempts to download the
+'ultramode.txt' file from http://slashdot.org, which
+contains the headlines in a computer friendly format. It
+then displays said headlines in a wxWindows list control.
+
+    You can read articles using either Python's html library
+or an external browser. Uncheck the 'browser->internal' menu
+item to use the latter option.  Use the settings dialog box
+to set which external browser is started.
+
+    This code is available under the wxWindows license, see
+elsewhere. If you modify this code, be aware of the fact
+that slashdot.org's maintainer, CmdrTaco, explicitly asks
+'ultramode.txt' downloaders not to do this automatically
+more than twice per hour. If this feature is abused,
+CmdrTaco may remove the ultramode file completely and that
+will make a *lot* of people unhappy.
+
+    I want to thank Alex Shnitman whose slashes.pl
+(Perl/GTK) script gave me the idea for this applet.
+
+    Have fun with it,
+
+    Harm van der Heijden (H.v.d.Heijden@phys.tue.nl)
+"""
+
+from wxPython.wx import *
+from httplib import HTTP
+from htmllib import HTMLParser
+import os
+import re
+import formatter
+
+class HTMLTextView(wxFrame):
+    def __init__(self, parent, id, title='HTMLTextView', url=None):
+        wxFrame.__init__(self, parent, id, title, wxPyDefaultPosition,
+                         wxSize(600,400))
+
+        self.mainmenu = wxMenuBar()
+
+        menu = wxMenu()
+        menu.Append(201, '&Open URL...', 'Open URL')
+        EVT_MENU(self, 201, self.OnFileOpen)
+        menu.Append(209, 'E&xit', 'Exit viewer')
+        EVT_MENU(self, 209, self.OnFileExit)
+
+        self.mainmenu.Append(menu, '&File')
+        self.SetMenuBar(self.mainmenu)
+        self.CreateStatusBar(1)
+
+        self.text = wxTextCtrl(self, -1, "", wxPyDefaultPosition,
+                               wxPyDefaultSize, wxTE_MULTILINE | wxTE_READONLY)
+
+        if (url):
+            self.OpenURL(url)
+
+    def logprint(self, x):
+        self.SetStatusText(x)
+
+    def OpenURL(self, url):
+        self.url = url
+        m = re.match('file:(\S+)\s*', url)
+        if m:
+            f = open(m.groups()[0],'r')
+        else:
+            m = re.match('http://([^/]+)(/\S*)\s*', url)
+            if m:
+                host = m.groups()[0]
+                path = m.groups()[1]
+            else:
+                m = re.match('http://(\S+)\s*', url)
+                if not m:
+                    # Invalid URL
+                    self.logprint("Invalid or unsupported URL: %s" % (url))
+                    return
+                host = m.groups()[0]
+                path = ''
+            f = RetrieveAsFile(host,path,self.logprint)
+        if not f:
+            self.logprint("Could not open %s" % (url))
+            return
+        self.logprint("Receiving data...")
+        data = f.read()
+        tmp = open('tmphtml.txt','w')
+        fmt = formatter.AbstractFormatter(formatter.DumbWriter(tmp))
+        p = HTMLParser(fmt)
+        self.logprint("Parsing data...")
+        p.feed(data)
+        p.close()
+        tmp.close()
+        tmp = open('tmphtml.txt', 'r')
+        self.text.SetValue(tmp.read())
+        self.SetTitle(url)
+        self.logprint(url)
+
+    def OnFileOpen(self, event):
+        dlg = wxTextEntryDialog(self, "Enter URL to open:", "")
+        if dlg.ShowModal() == wxID_OK:
+            url = dlg.GetValue()
+        else:
+            url = None
+        if url:
+            self.OpenURL(url)
+
+    def OnFileExit(self, event):
+        self.Close()
+
+    def OnCloseWindow(self, event):
+        self.Destroy()
+
+
+def ParseSlashdot(f):
+    art_sep = re.compile('%%\r?\n')
+    line_sep = re.compile('\r?\n')
+    data = f.read()
+    list = art_sep.split(data)
+    art_list = []
+    for i in range(1,len(list)-1):
+        art_list.append(line_sep.split(list[i]))
+    return art_list
+
+def myprint(x):
+    print x
+
+def RetrieveAsFile(host, path='', logprint = myprint):
+    try:
+        h = HTTP(host)
+    except:
+        logprint("Failed to create HTTP connection to %s... is the network available?" % (host))
+        return None
+    h.putrequest('GET',path)
+    h.putheader('Accept','text/html')
+    h.putheader('Accept','text/plain')
+    h.endheaders()
+    errcode, errmsg, headers = h.getreply()
+    if errcode != 200:
+        logprint("HTTP error code %d: %s" % (errcode, errmsg))
+        return None
+    f = h.getfile()
+#    f = open('/home/harm/ultramode.txt','r')
+    return f
+
+
+class AppStatusBar(wxStatusBar):
+    def __init__(self, parent):
+        wxStatusBar.__init__(self,parent, -1)
+        self.SetFieldsCount(2)
+        self.SetStatusWidths([-1, 100])
+        self.but = wxButton(self, 1001, "Refresh")
+        EVT_BUTTON(self, 1001, parent.OnViewRefresh)
+        self.OnSize(None)
+
+    def logprint(self,x):
+        self.SetStatusText(x,0)
+
+    def OnSize(self, event):
+        rect = self.GetFieldRect(1)
+        self.but.SetPosition(wxPoint(rect.x+2, rect.y+2))
+        self.but.SetSize(wxSize(rect.width-4, rect.height-4))
+
+# This is a simple timer class to start a function after a short delay;
+class QuickTimer(wxTimer):
+    def __init__(self, func, wait=100):
+	wxTimer.__init__(self)
+	self.callback = func
+	self.Start(wait); # wait .1 second (.001 second doesn't work. why?)
+    def Notify(self):
+	self.Stop();
+	apply(self.callback, ());
+
+class AppFrame(wxFrame):
+    def __init__(self, parent, id, title):
+        wxFrame.__init__(self, parent, id, title, wxPyDefaultPosition,
+                         wxSize(650, 250))
+
+	# if the window manager closes the window:
+	EVT_CLOSE(self, self.OnCloseWindow);
+
+	# Now Create the menu bar and items
+        self.mainmenu = wxMenuBar()
+
+        menu = wxMenu()
+        menu.Append(209, 'E&xit', 'Enough of this already!')
+        EVT_MENU(self, 209, self.OnFileExit)
+        self.mainmenu.Append(menu, '&File')
+        menu = wxMenu()
+        menu.Append(210, '&Refresh', 'Refresh headlines')
+        EVT_MENU(self, 210, self.OnViewRefresh)
+        menu.Append(211, '&Slashdot Index', 'View Slashdot index')
+        EVT_MENU(self, 211, self.OnViewIndex)
+        menu.Append(212, 'Selected &Article', 'View selected article')
+        EVT_MENU(self, 212, self.OnViewArticle)
+        self.mainmenu.Append(menu, '&View')
+        menu = wxMenu()
+        menu.Append(220, '&Internal', 'Use internal text browser',TRUE)
+        menu.Check(220, true)
+        self.UseInternal = 1;
+        EVT_MENU(self, 220, self.OnBrowserInternal)
+        menu.Append(222, '&Settings...', 'External browser Settings')
+        EVT_MENU(self, 222, self.OnBrowserSettings)
+        self.mainmenu.Append(menu, '&Browser')
+	menu = wxMenu()
+	menu.Append(230, '&About', 'Some documentation');
+	EVT_MENU(self, 230, self.OnAbout)
+	self.mainmenu.Append(menu, '&Help')
+
+        self.SetMenuBar(self.mainmenu)
+
+	if wxPlatform == '__WXGTK__':
+	    # I like lynx. Also Netscape 4.5 doesn't react to my cmdline opts
+	    self.BrowserSettings = "xterm -e lynx %s &"
+	elif wxPlatform == '__WXMSW__':
+	    # netscape 4.x likes to hang out here...
+	    self.BrowserSettings = '\\progra~1\\Netscape\\Communicator\\Program\\netscape.exe %s'
+	else:
+	    # a wild guess...
+	    self.BrowserSettings = 'netscape %s'
+
+	# A status bar to tell people what's happening
+	self.sb = AppStatusBar(self)
+        self.SetStatusBar(self.sb)
+
+        self.list = wxListCtrl(self, 1100)
+	self.list.SetSingleStyle(wxLC_REPORT)
+	self.list.InsertColumn(0, 'Subject')
+	self.list.InsertColumn(1, 'Date')
+	self.list.InsertColumn(2, 'Posted by')
+	self.list.InsertColumn(3, 'Comments')
+        self.list.SetColumnWidth(0, 300)
+        self.list.SetColumnWidth(1, 150)
+        self.list.SetColumnWidth(2, 100)
+        self.list.SetColumnWidth(3, 100)
+
+        EVT_LIST_ITEM_SELECTED(self, 1100, self.OnItemSelected)
+	EVT_LEFT_DCLICK(self.list, self.OnLeftDClick)
+
+	self.logprint("Connecting to slashdot... Please wait.")
+	# wxYield doesn't yet work here. That's why we use a timer
+	# to make sure that we see some GUI stuff before the slashdot
+	# file is transfered.
+	self.timer = QuickTimer(self.DoRefresh, 1000)
+
+    def logprint(self, x):
+        self.sb.logprint(x)
+
+    def OnFileExit(self, event):
+        self.Destroy()
+
+    def DoRefresh(self):
+        f = RetrieveAsFile('slashdot.org','/ultramode.txt',self.sb.logprint)
+        art_list = ParseSlashdot(f)
+        self.list.DeleteAllItems()
+        self.url = []
+        self.current = -1
+        i = 0;
+        for article in art_list:
+            self.list.InsertStringItem(i, article[0])
+            self.list.SetStringItem(i, 1, article[2])
+            self.list.SetStringItem(i, 2, article[3])
+            self.list.SetStringItem(i, 3, article[6])
+            self.url.append(article[1])
+            i = i + 1
+	self.logprint("File retrieved OK.")
+
+    def OnViewRefresh(self, event):
+	self.logprint("Connecting to slashdot... Please wait.");
+	wxYield()
+	self.DoRefresh()
+
+    def DoViewIndex(self):
+        if self.UseInternal:
+            self.view = HTMLTextView(self, -1, 'slashdot.org',
+                                     'http://slashdot.org')
+            self.view.Show(true)
+        else:
+            self.logprint(self.BrowserSettings % ('http://slashdot.org'))
+            #os.system(self.BrowserSettings % ('http://slashdot.org'))
+            wxExecute(self.BrowserSettings % ('http://slashdot.org'))
+	self.logprint("OK")
+
+    def OnViewIndex(self, event):
+	self.logprint("Starting browser... Please wait.")
+	wxYield()
+	self.DoViewIndex()
+
+    def DoViewArticle(self):
+        if self.current<0: return
+        url = self.url[self.current]
+        if self.UseInternal:
+            self.view = HTMLTextView(self, -1, url, url)
+            self.view.Show(true)
+        else:
+            self.logprint(self.BrowserSettings % (url))
+            os.system(self.BrowserSettings % (url))
+	self.logprint("OK")
+
+    def OnViewArticle(self, event):
+	self.logprint("Starting browser... Please wait.")
+	wxYield()
+	self.DoViewArticle()
+
+    def OnBrowserInternal(self, event):
+        if self.mainmenu.Checked(220):
+            self.UseInternal = 1
+        else:
+            self.UseInternal = 0
+
+    def OnBrowserSettings(self, event):
+        dlg = wxTextEntryDialog(self, "Enter command to view URL.\nUse %s as a placeholder for the URL.", "", self.BrowserSettings);
+        if dlg.ShowModal() == wxID_OK:
+            self.BrowserSettings = dlg.GetValue()
+
+    def OnAbout(self, event):
+	dlg = wxMessageDialog(self, __doc__, "wxSlash", wxOK | wxICON_INFORMATION)
+	dlg.ShowModal()
+
+    def OnItemSelected(self, event):
+        self.current = event.m_itemIndex
+        self.logprint("URL: %s" % (self.url[self.current]))
+
+    def OnLeftDClick(self, event):
+	(x,y) = event.Position();
+	# Actually, we should convert x,y to logical coords using
+	# a dc, but only for a wxScrolledWindow widget.
+	# Now wxGTK derives wxListCtrl from wxScrolledWindow,
+	# and wxMSW from wxControl... So that doesn't work.
+	#dc = wxClientDC(self.list)
+	##self.list.PrepareDC(dc)
+	#x = dc.DeviceToLogicalX( event.GetX() )
+	#y = dc.DeviceToLogicalY( event.GetY() )
+	id = self.list.HitTest(wxPoint(x,y))
+	#print "Double click at %d %d" % (x,y), id
+	# Okay, we got a double click. Let's assume it's the current selection
+	wxYield()
+	self.OnViewArticle(event)
+
+    def OnCloseWindow(self, event):
+        self.Destroy()
+
+
+#---------------------------------------------------------------------------
+# if running standalone
+
+if __name__ == '__main__':
+    class MyApp(wxApp):
+        def OnInit(self):
+            frame = AppFrame(NULL, -1, "Slashdot Breaking News")
+            frame.Show(true)
+            self.SetTopWindow(frame)
+            return true
+
+    app = MyApp(0)
+    app.MainLoop()
+
+
+
+#---------------------------------------------------------------------------
+# if running as part of the Demo Framework...
+
+def runTest(frame, nb, log):
+    win = AppFrame(NULL, -1, "Slashdot Breaking News")
+    frame.otherWin = win
+    win.Show(true)
+
+
+overview = __doc__
+
+
+#----------------------------------------------------------------------------
+
+

utils/wxPython/demo/XMLtreeview.py

@@ -0,0 +1,66 @@
+
+import string
+
+from wxPython.wx import *
+try:
+    from xml.parsers import pyexpat
+    haveXML = true
+except ImportError:
+    haveXML = false
+
+#----------------------------------------------------------------------
+
+if not haveXML:
+    def runTest(frame, nb, log):
+        dlg = wxMessageDialog(frame, 'This demo requires the XML package.  See http://www.python.org/sigs/xml-sig/',
+                          'Sorry', wxOK | wxICON_INFORMATION)
+        dlg.ShowModal()
+        dlg.Destroy()
+
+else:
+
+    class XMLTree(wxTreeCtrl):
+        def __init__(self, parent, ID):
+            wxTreeCtrl.__init__(self, parent, ID)
+            self.nodeStack = [self.AddRoot("Root")]
+
+        # Define a handler for start element events
+        def StartElement(self, name, attrs ):
+            self.nodeStack.append(self.AppendItem(self.nodeStack[-1], name))
+
+        def EndElement(self,  name ):
+            self.nodeStack = self.nodeStack[:-1]
+
+        def CharacterData(self, data ):
+            if string.strip(data):
+                self.AppendItem(self.nodeStack[-1], data)
+
+
+        def LoadTree(self, filename):
+            # Create a parser
+            Parser = pyexpat.ParserCreate()
+
+            # Tell the parser what the start element handler is
+            Parser.StartElementHandler = self.StartElement
+            Parser.EndElementHandler = self.EndElement
+            Parser.CharacterDataHandler = self.CharacterData
+
+            # Parse the XML File
+            ParserStatus = Parser.Parse(open(filename,'r').read(), 1)
+
+
+    def runTest(frame, nb, log):
+        win = XMLTree(nb, -1)
+        win.LoadTree("paper.xml")
+        return win
+
+#----------------------------------------------------------------------
+
+
+
+
+
+
+overview = """\
+"""
+

utils/wxPython/demo/demo.py

@@ -0,0 +1,4 @@
+#!/usr/bin/env python
+
+import Main
+Main.main()

utils/wxPython/demo/demoMainLoop.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python
+#---------------------------------------------------------------------------
+"""
+This demo attempts to override the C++ MainLoop and implement it
+in Python.  This is not part of the demo framework.
+
+
+                THIS FEATURE IS STILL EXPERIMENTAL...
+"""
+
+
+from wxPython.wx import *
+import time
+
+
+#---------------------------------------------------------------------------
+
+class MyFrame(wxFrame):
+
+    def __init__(self, parent, id, title):
+        wxFrame.__init__(self, parent, id, title,
+                         wxPoint(100, 100), wxSize(160, 150))
+
+        EVT_SIZE(self, self.OnSize)
+        EVT_MOVE(self, self.OnMove)
+        EVT_CLOSE(self, self.OnCloseWindow)
+        EVT_IDLE(self, self.OnIdle)
+
+        self.count = 0
+
+        panel = wxPanel(self, -1)
+        wxStaticText(panel, -1, "Size:",
+                     wxDLG_PNT(panel, wxPoint(4, 4)),  wxDefaultSize)
+        wxStaticText(panel, -1, "Pos:",
+                     wxDLG_PNT(panel, wxPoint(4, 16)), wxDefaultSize)
+
+        wxStaticText(panel, -1, "Idle:",
+                     wxDLG_PNT(panel, wxPoint(4, 28)), wxDefaultSize)
+
+        self.sizeCtrl = wxTextCtrl(panel, -1, "",
+                                   wxDLG_PNT(panel, wxPoint(24, 4)),
+                                   wxDLG_SZE(panel, wxSize(36, -1)),
+                                   wxTE_READONLY)
+
+        self.posCtrl = wxTextCtrl(panel, -1, "",
+                                  wxDLG_PNT(panel, wxPoint(24, 16)),
+                                  wxDLG_SZE(panel, wxSize(36, -1)),
+                                  wxTE_READONLY)
+
+        self.idleCtrl = wxTextCtrl(panel, -1, "",
+                                   wxDLG_PNT(panel, wxPoint(24, 28)),
+                                   wxDLG_SZE(panel, wxSize(36, -1)),
+                                   wxTE_READONLY)
+
+
+    def OnCloseWindow(self, event):
+        app.keepGoing = false
+        self.Destroy()
+
+    def OnIdle(self, event):
+        self.idleCtrl.SetValue(str(self.count))
+        self.count = self.count + 1
+
+    def OnSize(self, event):
+        size = event.GetSize()
+        self.sizeCtrl.SetValue("%s, %s" % (size.width, size.height))
+        event.Skip()
+
+    def OnMove(self, event):
+        pos = event.GetPosition()
+        self.posCtrl.SetValue("%s, %s" % (pos.x, pos.y))
+
+
+
+#---------------------------------------------------------------------------
+
+class MyApp(wxApp):
+    def MainLoop(self):
+        # This outer loop determines when to exit the application,  for
+        # this example we let the main frame reset this flag when it
+        # closes.
+        while self.keepGoing:
+            # At this point in the outer loop you could do whatever you
+            # implemented your own MainLoop for.  It should be quick and
+            # non-blocking, otherwise your GUI will freeze.  For example,
+            # call Fnorb's reactor.do_one_event(0), etc.
+
+            # call_your_code_here()
+
+
+            # This inner loop will process any GUI events until there
+            # are no more waiting.
+            while self.Pending():
+                self.Dispatch()
+
+            # Send idle events to idle handlers.  You may want to throtle
+            # this back a bit so there is not too much CPU time spent in
+            # the idle handlers.  For this example, I'll just snooze a
+            # little...
+            time.sleep(0.25)
+            self.ProcessIdle()
+
+
+
+    def OnInit(self):
+        frame = MyFrame(NULL, -1, "This is a test")
+        frame.Show(true)
+        self.SetTopWindow(frame)
+
+        self.keepGoing = true
+
+        return true
+
+
+app = MyApp(0)
+app.MainLoop()
+
+
+
+
+

utils/wxPython/demo/hangman.py

@@ -0,0 +1,465 @@
+"""Hangman.py, a simple wxPython game, inspired by the
+old bsd game by Ken Arnold.
+From the original man page:
+
+ In hangman, the computer picks a word from the on-line
+ word list and you must try to guess it.  The computer
+ keeps track of which letters have been guessed and how
+ many wrong guesses you have made on the screen in a
+ graphic fashion.
+
+That says it all, doesn't it?
+
+Have fun with it,
+
+Harm van der Heijden (H.v.d.Heijden@phys.tue.nl)"""
+
+import random,re,string
+from wxPython.wx import *
+
+
+
+class WordFetcher:
+    builtin_words = ' albatros  banana  electrometer  eggshell'
+
+    def __init__(self, filename, min_length = 5):
+        self.min_length = min_length
+        print "Trying to open file %s" % (filename,)
+        try:
+            f = open(filename, "r")
+        except:
+            print "Couldn't open dictionary file %s, using builtins" % (filename,)
+            self.words = self.builtin_words
+            self.filename = None
+            return
+        self.words = f.read()
+        self.filename = filename
+        print "Got %d bytes." % (len(self.words),)
+
+    def SetMinLength(min_length):
+        self.min_length = min_length
+
+    def Get(self):
+        reg = re.compile('\s+([a-zA-Z]+)\s+')
+        n = 50 # safety valve; maximum number of tries to find a suitable word
+        while n:
+            index = int(random.random()*len(self.words))
+            m = reg.search(self.words[index:])
+            if m and len(m.groups()[0]) >= self.min_length: break
+            n = n - 1
+        if n: return string.lower(m.groups()[0])
+        return "error"
+
+
+
+def stdprint(x):
+    print x
+
+
+
+class URLWordFetcher(WordFetcher):
+    def __init__(self, url):
+        self.OpenURL(url)
+        WordFetcher.__init__(self, "hangman_dict.txt")
+
+    def logprint(self,x):
+        print x
+
+    def RetrieveAsFile(self, host, path=''):
+        from httplib import HTTP
+        try:
+            h = HTTP(host)
+        except:
+            self.logprint("Failed to create HTTP connection to %s... is the network available?" % (host))
+            return None
+        h.putrequest('GET',path)
+        h.putheader('Accept','text/html')
+        h.putheader('Accept','text/plain')
+        h.endheaders()
+        errcode, errmsg, headers = h.getreply()
+        if errcode != 200:
+            self.logprint("HTTP error code %d: %s" % (errcode, errmsg))
+            return None
+        f = h.getfile()
+        return f
+
+    def OpenURL(self,url):
+        from htmllib import HTMLParser
+        import formatter
+        self.url = url
+        m = re.match('http://([^/]+)(/\S*)\s*', url)
+        if m:
+            host = m.groups()[0]
+            path = m.groups()[1]
+        else:
+            m = re.match('http://(\S+)\s*', url)
+            if not m:
+                # Invalid URL
+                self.logprint("Invalid or unsupported URL: %s" % (url))
+                return
+            host = m.groups()[0]
+            path = ''
+        f = self.RetrieveAsFile(host,path)
+        if not f:
+            self.logprint("Could not open %s" % (url))
+            return
+        self.logprint("Receiving data...")
+        data = f.read()
+        tmp = open('hangman_dict.txt','w')
+        fmt = formatter.AbstractFormatter(formatter.DumbWriter(tmp))
+        p = HTMLParser(fmt)
+        self.logprint("Parsing data...")
+        p.feed(data)
+        p.close()
+        tmp.close()
+
+
+
+class HangmanWnd(wxWindow):
+    def __init__(self, parent, id, pos=wxDefaultPosition, size=wxDefaultSize):
+        wxWindow.__init__(self, parent, id, pos, size)
+        self.SetBackgroundColour(wxNamedColour('white'))
+        if wxPlatform == '__WXGTK__':
+            self.font = wxFont(12, wxMODERN, wxNORMAL, wxNORMAL)
+        else:
+            self.font = wxFont(10, wxMODERN, wxNORMAL, wxNORMAL)
+        self.SetFocus()
+
+    def StartGame(self, word):
+        self.word = word
+        self.guess = []
+        self.tries = 0
+        self.misses = 0
+        self.Draw()
+
+    def EndGame(self):
+        self.misses = 7;
+        self.guess = map(chr, range(ord('a'),ord('z')+1))
+        self.Draw()
+
+    def HandleKey(self, key):
+        self.message = ""
+        if self.guess.count(key):
+            self.message = 'Already guessed %s' % (key,)
+            return 0
+        self.guess.append(key)
+        self.guess.sort()
+        self.tries = self.tries+1
+        if not key in self.word:
+            self.misses = self.misses+1
+        if self.misses == 7:
+            self.EndGame()
+            return 1
+        has_won = 1
+        for letter in self.word:
+            if not self.guess.count(letter):
+                has_won = 0
+                break
+        if has_won:
+            self.Draw()
+            return 2
+        self.Draw()
+        return 0
+
+    def Draw(self, dc = None):
+        if not dc:
+            dc = wxClientDC(self)
+        dc.SetFont(self.font)
+        dc.Clear()
+        (x,y) = self.GetSizeTuple()
+        x1 = x-200; y1 = 20
+        for letter in self.word:
+            if self.guess.count(letter):
+                dc.DrawText(letter, x1, y1)
+            else:
+                dc.DrawText('.', x1, y1)
+            x1 = x1 + 10
+        x1 = x-200
+        dc.DrawText("tries %d misses %d" % (self.tries,self.misses),x1,50)
+        guesses = ""
+        for letter in self.guess:
+            guesses = guesses + letter
+        dc.DrawText("guessed:", x1, 70)
+        dc.DrawText(guesses[:13], x1+80, 70)
+        dc.DrawText(guesses[13:], x1+80, 90)
+        dc.SetUserScale(x/1000.0, y/1000.0)
+        self.DrawVictim(dc)
+
+    def DrawVictim(self, dc):
+        dc.SetPen(wxPen(wxNamedColour('black'), 20))
+        dc.DrawLines([(10, 980), (10,900), (700,900), (700,940), (720,940),
+                      (720,980), (900,980)])
+        dc.DrawLines([(100,900), (100, 100), (300,100)])
+        dc.DrawLine(100,200,200,100)
+        if ( self.misses == 0 ): return
+        dc.SetPen(wxPen(wxNamedColour('blue'), 10))
+        dc.DrawLine(300,100,300,200)
+        if ( self.misses == 1 ): return
+        dc.DrawEllipse(250,200,100,100)
+        if ( self.misses == 2 ): return
+        dc.DrawLine(300,300,300,600)
+        if ( self.misses == 3) : return
+        dc.DrawLine(300,300,250,550)
+        if ( self.misses == 4) : return
+        dc.DrawLine(300,300,350,550)
+        if ( self.misses == 5) : return
+        dc.DrawLine(300,600,350,850)
+        if ( self.misses == 6) : return
+        dc.DrawLine(300,600,250,850)
+
+    def OnPaint(self, event):
+        dc = wxPaintDC(self)
+        self.Draw(dc)
+
+
+
+class HangmanDemo(HangmanWnd):
+    def __init__(self, wf, parent, id, pos, size):
+        HangmanWnd.__init__(self, parent, id, pos, size)
+        self.StartGame("dummy")
+        self.start_new = 1
+        self.wf = wf
+        self.delay = 500
+        self.timer = self.PlayTimer(self.MakeMove)
+
+    def MakeMove(self):
+        self.timer.Stop()
+        if self.start_new:
+            self.StartGame(self.wf.Get())
+            self.start_new = 0
+            self.left = list('aaaabcdeeeeefghiiiiijklmnnnoooopqrssssttttuuuuvwxyz')
+        else:
+            key = self.left[int(random.random()*len(self.left))]
+            while self.left.count(key): self.left.remove(key)
+            self.start_new = self.HandleKey(key)
+        self.timer.Start(self.delay)
+
+    def Stop(self):
+        self.timer.Stop()
+
+    class PlayTimer(wxTimer):
+        def __init__(self,func):
+            wxTimer.__init__(self)
+            self.func = func
+            self.Start(1000)
+
+        def Notify(self):
+            apply(self.func, ())
+
+
+
+class HangmanDemoFrame(wxFrame):
+    def __init__(self, wf, parent, id, pos, size):
+        wxFrame.__init__(self, parent, id, "Hangman demo", pos, size)
+        self.demo = HangmanDemo(wf, self, -1, wxDefaultPosition, wxDefaultSize)
+
+    def OnCloseWindow(self, event):
+        self.demo.timer.Stop()
+        self.Destroy()
+
+
+
+class AboutBox(wxDialog):
+    def __init__(self, parent,wf):
+        wxDialog.__init__(self, parent, -1, "About Hangman", wxDefaultPosition, wxSize(350,450))
+        self.wnd = HangmanDemo(wf, self, -1, wxPoint(1,1), wxSize(350,150))
+        self.static = wxStaticText(self, -1, __doc__, wxPoint(1,160), wxSize(350, 250))
+        self.button = wxButton(self, 2001, "OK", wxPoint(150,420), wxSize(50,-1))
+        EVT_BUTTON(self, 2001, self.OnOK)
+
+    def OnOK(self, event):
+        self.wnd.Stop()
+        self.EndModal(wxID_OK)
+
+
+
+class MyFrame(wxFrame):
+    def __init__(self, parent, wf):
+        self.wf = wf
+        wxFrame.__init__(self, parent, -1, "hangman", wxDefaultPosition, wxSize(400,300))
+        self.wnd = HangmanWnd(self, -1)
+        menu = wxMenu()
+        menu.Append(1001, "New")
+        menu.Append(1002, "End")
+        menu.AppendSeparator()
+        menu.Append(1003, "Reset")
+        menu.Append(1004, "Demo...")
+        menu.AppendSeparator()
+        menu.Append(1005, "Exit")
+        menubar = wxMenuBar()
+        menubar.Append(menu, "Game")
+        menu = wxMenu()
+        #menu.Append(1010, "Internal", "Use internal dictionary", TRUE)
+        menu.Append(1011, "ASCII File...")
+        urls = [ 'wxPython home', 'http://alldunn.com/wxPython/main.html',
+                 'slashdot.org', 'http://slashdot.org/',
+                 'cnn.com', 'http://cnn.com',
+                 'The New York Times', 'http://www.nytimes.com',
+                 'De Volkskrant', 'http://www.volkskrant.nl/frameless/25000006.html',
+                 'Gnu GPL', 'http://www.fsf.org/copyleft/gpl.html',
+                 'Bijbel: Genesis', 'http://www.coas.com/bijbel/gn1.htm']
+        urlmenu = wxMenu()
+        for item in range(0,len(urls),2):
+            urlmenu.Append(1020+item/2, urls[item], urls[item+1])
+        urlmenu.Append(1080, 'Other...', 'Enter an URL')
+        menu.AppendMenu(1012, 'URL', urlmenu, 'Use a webpage')
+        menu.Append(1013, 'Dump', 'Write contents to stdout')
+        menubar.Append(menu, "Dictionary")
+        self.urls = urls
+        self.urloffset = 1020
+        menu = wxMenu()
+        menu.Append(1090, "About...")
+        menubar.Append(menu, "Help")
+        self.SetMenuBar(menubar)
+        self.CreateStatusBar(2)
+        EVT_MENU(self, 1001, self.OnGameNew)
+        EVT_MENU(self, 1002, self.OnGameEnd)
+        EVT_MENU(self, 1003, self.OnGameReset)
+        EVT_MENU(self, 1004, self.OnGameDemo)
+        EVT_MENU(self, 1005, self.OnWindowClose)
+        EVT_MENU(self, 1011, self.OnDictFile)
+        EVT_MENU_RANGE(self, 1020, 1020+len(urls)/2, self.OnDictURL)
+        EVT_MENU(self, 1080, self.OnDictURLSel)
+        EVT_MENU(self, 1013, self.OnDictDump)
+        EVT_MENU(self, 1090, self.OnHelpAbout)
+        EVT_CHAR(self.wnd, self.OnChar)
+        self.OnGameReset()
+
+    def OnGameNew(self, event):
+        word = self.wf.Get()
+        self.in_progress = 1
+        self.SetStatusText("",0)
+        self.wnd.StartGame(word)
+
+    def OnGameEnd(self, event):
+        self.UpdateAverages(0)
+        self.in_progress = 0
+        self.SetStatusText("",0)
+        self.wnd.EndGame()
+
+    def OnGameReset(self, event=None):
+        self.played = 0
+        self.won = 0
+        self.history = []
+        self.average = 0.0
+        self.OnGameNew(None)
+
+    def OnGameDemo(self, event):
+        frame = HangmanDemoFrame(self.wf, self, -1, wxDefaultPosition, self.GetSize())
+        frame.Show(TRUE)
+
+    def OnDictFile(self, event):
+        fd = wxFileDialog(self)
+        if (self.wf.filename):
+            fd.SetFilename(self.wf.filename)
+        if fd.ShowModal() == wxID_OK:
+            file = fd.GetPath()
+            self.wf = WordFetcher(file)
+
+    def OnDictURL(self, event):
+        item = (event.GetId() - self.urloffset)*2
+        print "Trying to open %s at %s" % (self.urls[item], self.urls[item+1])
+        self.wf = URLWordFetcher(self.urls[item+1])
+
+    def OnDictURLSel(self, event):
+        msg = wxTextEntryDialog(self, "Enter the URL of the dictionary document", "Enter URL")
+        if msg.ShowModal() == wxID_OK:
+            url = msg.GetValue()
+            self.wf = URLWordFetcher(url)
+    def OnDictDump(self, event):
+        print self.wf.words
+
+    def OnHelpAbout(self, event):
+        about = AboutBox(self, self.wf)
+        about.ShowModal()
+        about.wnd.Stop() # that damn timer won't stop!
+
+    def UpdateAverages(self, has_won):
+        if has_won:
+            self.won = self.won + 1
+        self.played = self.played+1
+        self.history.append(self.wnd.misses) # ugly
+        total = 0.0
+        for m in self.history:
+            total = total + m
+        self.average = float(total/len(self.history))
+
+    def OnChar(self, event):
+        if not self.in_progress:
+            #print "new"
+            self.OnGameNew(None)
+            return
+        key = event.KeyCode();
+        #print key
+        if key >= ord('A') and key <= ord('Z'):
+            key = key + ord('a') - ord('A')
+        key = chr(key)
+        if key < 'a' or key > 'z':
+            event.Skip()
+            return
+        res = self.wnd.HandleKey(key)
+        if res == 0:
+            self.SetStatusText(self.wnd.message)
+        elif res == 1:
+            self.UpdateAverages(0)
+            self.SetStatusText("Too bad, you're dead!",0)
+            self.in_progress = 0
+        elif res == 2:
+            self.in_progress = 0
+            self.UpdateAverages(1)
+            self.SetStatusText("Congratulations!",0)
+        if self.played:
+            percent = (100.*self.won)/self.played
+        else:
+            percent = 0.0
+        self.SetStatusText("p %d, w %d (%g %%), av %g" % (self.played,self.won, percent, self.average),1)
+
+    def OnWindowClose(self, event):
+        self.Destroy()
+
+
+
+class MyApp(wxApp):
+    def OnInit(self):
+        if wxPlatform == '__WXGTK__':
+            defaultfile = "/usr/share/games/hangman-words"
+        elif wxPlatform == '__WXMSW__':
+            defaultfile = "c:\\windows\\hardware.txt"
+        else:
+            defaultfile = ""
+        wf = WordFetcher(defaultfile)
+        frame = MyFrame(NULL, wf)
+        self.SetTopWindow(frame)
+        frame.Show(TRUE)
+        return TRUE
+
+
+
+if __name__ == '__main__':
+    app = MyApp(0)
+    app.MainLoop()
+
+
+#----------------------------------------------------------------------
+
+overview = __doc__
+
+
+def runTest(frame, nb, log):
+    if wxPlatform == '__WXGTK__' or wxPlatform == '__WXMOTIF__':
+        defaultfile = "/usr/share/games/hangman-words"
+    elif wxPlatform == '__WXMSW__':
+        defaultfile = "c:\\windows\\hardware.txt"
+    else:
+        defaultfile = ""
+    wf = WordFetcher(defaultfile)
+    win = MyFrame(frame, wf)
+    frame.otherWin = win
+    win.Show(true)
+
+
+#----------------------------------------------------------------------
+
+
+
+

utils/wxPython/demo/htmlview.py

@@ -0,0 +1,77 @@
+from wxPython.wx import *
+from wxPython.html import *
+import sys
+
+default_page = """
+<H1>HTML Viewer</H1>Please select <I>File->Open</I>
+to open a HTML file, or edit this page in the
+text control below and select <I>File->Update</I>
+<P>
+The python source can be seen
+<a href="%s">here</a>.
+""" % (sys.argv[0], )
+
+class HtmlViewer(wxFrame):
+	def __init__(self, parent, id, title, pos = wxDefaultPosition, size = wxSize(400,400)):
+		wxFrame.__init__(self, parent, id, title, pos, size)
+                self.CreateStatusBar(1)
+                split = wxSplitterWindow(self, -1)
+                self.html = wxHtmlWindow(split)
+                self.html.SetRelatedFrame(self, "HTML Viewer:  \%s")
+                self.html.SetRelatedStatusBar(0)
+                self.txt = wxTextCtrl(split, -1, default_page,
+                                      wxDefaultPosition, wxDefaultSize,
+                                      wxTE_MULTILINE)
+                split.SplitHorizontally(self.html, self.txt, size.y/2)
+		mbar = wxMenuBar()
+		menu = wxMenu()
+		menu.Append(1500, "Open")
+                menu.Append(1501, "Reset")
+                menu.Append(1502, "Update HTML")
+		menu.AppendSeparator()
+		menu.Append(1503, "Exit")
+		mbar.Append(menu, "File")
+                menu = wxMenu()
+                menu.Append(1510, "Back")
+                menu.Append(1511, "Forward")
+                mbar.Append(menu, "Go")
+		self.SetMenuBar(mbar)
+		self.filename = ""
+                EVT_MENU(self, 1500, self.OnFileOpen)
+                EVT_MENU(self, 1501, self.OnFileReset)
+                EVT_MENU(self, 1502, self.OnFileUpdate)
+                EVT_MENU(self, 1503, self.OnClose)
+                EVT_MENU(self, 1510, self.OnGoBack)
+                EVT_MENU(self, 1511, self.OnGoForward)
+                # A default opening text
+                self.html.SetPage( default_page )
+        def OnFileOpen(self, event):
+		dlg = wxFileDialog(NULL, "Open file")
+		if dlg.ShowModal() == wxID_OK:
+			self.filename = dlg.GetPath()
+                        self.html.LoadPage(self.filename)
+        def OnFileReset(self, event):
+                self.html.SetPage( default_page )
+                self.txt.SetValue( default_page )
+        def OnFileUpdate(self, event):
+                self.html.SetPage( self.txt.GetValue() )
+        def OnGoBack(self, event):
+                self.html.HistoryBack()
+        def OnGoForward(self, event):
+                self.html.HistoryForward()
+	def OnClose(self,event):
+		self.Destroy()
+
+class MyApp(wxApp):
+	def OnInit(self):
+		frame = HtmlViewer(NULL, -1, "HTML Viewer")
+		frame.Show(TRUE)
+		self.SetTopWindow(frame)
+		return TRUE
+
+wxImage_AddHandler(wxPNGHandler())
+wxImage_AddHandler(wxGIFHandler())
+wxImage_AddHandler(wxJPEGHandler())
+
+theApp = MyApp(0)
+theApp.MainLoop()

utils/wxPython/demo/htmlwidget.py

@@ -0,0 +1,97 @@
+from wxPython.wx import *
+from wxPython.html import *
+import sys,string
+
+# A bunch of simple widgets, all somehow derived from wxWindow
+class Widget1(wxWindow):
+    def __init__(self, parent, param):
+	wxWindow.__init__(self, parent, -1)
+	self.text = wxTextCtrl(self, -1, param['param_str'], wxPoint(5,5),
+	                   wxSize(200,150), wxTE_MULTILINE)
+	but = wxButton(self, 1001, "Click me", wxPoint(50,160), wxSize(100,30))
+	EVT_BUTTON(self, 1001, self.OnButton)
+	self.SetSize(wxSize(210,200))
+    def OnButton(self, event):
+	self.text.AppendText( "Click!\n" )
+
+class Widget2(wxButton):
+    def __init__(self, parent, param):
+	wxButton.__init__(self, parent, int(param['id']), param['title'])
+
+class Widget3(wxTextCtrl):
+    def __init__(self, parent, param):
+	wxTextCtrl.__init__(self, parent, -1, "No clicks")
+	self.clicked = 0;
+	EVT_BUTTON(parent, int(param['button_id']), self.OnButton)
+    def OnButton(self, event):
+	self.clicked = self.clicked + 1
+	self.SetValue("%d clicks" % (self.clicked,))
+
+# make the widgets known in the widget module (aka htmlc)
+widget.Widget1 = Widget1
+widget.Widget2 = Widget2
+widget.Widget3 = Widget3
+
+# our default page
+default_page = """
+<H2>wxPython widgets go HTML</H2>
+A bunch of wxPython widgets are scattered on this HTML page.
+Here's one:
+<center><python class="Widget1" greeting="Hello World"></center>
+<hr>
+Here's another:
+<center><python class="Widget2" float=70 id=1002 title="Button A"></center>
+It should always take up 70% of the page width.
+<p>And then there's this, listening to button A:
+<python class="Widget3" button_id=1002></p>
+"""
+
+# our explanation
+apology = """
+For some bizarre reason, it takes forever and a day to display the
+widgets if they are constructed in the frame's constructor. This
+only happens in MSW, wxGTK works fine.
+<p>Select <I>File->Show it</I> to draw the widgets."""
+
+default_page = default_page + "The HTML code for this page is\n <pre>" + default_page + "</pre>"
+
+
+class HtmlViewer(wxFrame):
+	def __init__(self, parent, id, title, pos = wxDefaultPosition, size = wxSize(400,400)):
+		wxFrame.__init__(self, parent, id, title, pos, size)
+                self.CreateStatusBar(1)
+                self.html = wxHtmlWindow(self)
+                self.html.SetRelatedFrame(self, "HTML Viewer:  \%s")
+                self.html.SetRelatedStatusBar(0)
+		mbar = wxMenuBar()
+		menu = wxMenu()
+                menu.Append(1500, "Show it")
+		menu.Append(1503, "Exit")
+		mbar.Append(menu, "File")
+                EVT_MENU(self, 1500, self.OnShowIt)
+                EVT_MENU(self, 1503, self.OnClose)
+                self.SetMenuBar(mbar)
+                # change apology below to default_page, if you dare!
+                self.html.SetPage( default_page )
+	def OnClose(self,event):
+		self.Destroy()
+        def OnShowIt(self,event):
+                self.html.SetPage( default_page )
+                # now quickly remove the menu option, to hide that
+                # other bug; namely that widgets aren't removed when the
+                # HTML page is.
+                self.GetMenuBar().Enable(1500, FALSE)        
+
+class MyApp(wxApp):
+	def OnInit(self):
+		frame = HtmlViewer(NULL, -1, "HTML Viewer")
+		frame.Show(TRUE)
+                self.SetTopWindow(frame)
+		return TRUE
+
+wxImage_AddHandler(wxPNGHandler())
+wxImage_AddHandler(wxGIFHandler())
+wxImage_AddHandler(wxJPEGHandler())
+
+theApp = MyApp(0)
+theApp.MainLoop()

utils/wxPython/demo/paper.xml

@@ -0,0 +1,85 @@
+<?xml version="1.0"?>
+<!DOCTYPE gcapaper SYSTEM "gcapap-X.dtd" [
+<!ENTITY footprint SYSTEM "footprint.tif" NDATA tiff >
+<!ENTITY footprint SYSTEM "footprint.eps" NDATA eps >
+<!ENTITY shoes SYSTEM "shoes.tif" NDATA tiff >
+<!ENTITY super1 "&#90;"> 
+]>
+
+<gcapaper><front><title>Using SGML to make footprints in the sand
+</title><keyword>footprints</keyword><keyword>sand</keyword>
+<author><fname>Jane</fname><surname>Doe</surname>
+<jobtitle>Empress</jobtitle>
+<address><affil>Universe Corporation</affil>
+<aline>1 Main Street</aline>
+<city>Perfect City</city>
+<province>Dorado</province>
+<cntry>Neutral</cntry><postcode>999999</postcode>
+<phone>+55 555 555 5550</phone>
+<fax>+55 555 555 5555</fax>
+<email>jane@universe.com</email>
+<web>www.universe.com</web>
+</address>
+<bio><para>Jane Doe is the Empress of the Universe <bibref refloc="jd000"/>, a position to which she has always aspired.</para></bio>
+</author>
+<author><fname>Fred</fname><surname>Bloggs</surname>
+<jobtitle>Designer</jobtitle>
+<address><affil>Fred (The Shoe) Bloggs Ltd</affil>
+<aline>1 Shoe Lane</aline>
+<city>Perfect City</city>
+<province>Dorado</province>
+<cntry>Neutral</cntry><postcode>999999</postcode>
+<phone>+55 555 555 1122</phone>
+<fax>+55 555 555 1133</fax>
+<email>fred@shoebloggs.com</email>
+<web>www.shoebloggs.com</web></address>
+<bio><para>Fred has always wanted to create the perfect shoe for making footprints in the sand. Now with SGML and XML, he has been able to document his design.</para></bio>
+</author>
+<abstract>
+<para><keyword>ease</keyword><keyword>documentation</keyword>It's not easy being an Empress of the Universe (<a href="http://www.universe.com"/>), but with the right pair of shoes and the right documentation on how to make footprints in the sand of life, it's easier than it was. Since the introduction of <acronym.grp><acronym>SGML</acronym><expansion>Standard Generalized Markup Language</expansion></acronym.grp> and <acronym.grp><acronym>XML</acronym><expansion>Extensible Markup Language</expansion></acronym.grp> it is now possible to identify and manage the key bits of information on this process.</para>
+</abstract>
+</front>
+<body><section id="jd001"><title>Introduction</title>
+<para><keyword>documentation</keyword>Since its inception, the Universe has always had sand, now it has an Empress, a good shoe design, and <acronym>SGML</acronym> / <acronym>XML</acronym> documentation. The time is now ripe for making <highlight style="ital">footprints</highlight> in the sand.</para></section>
+<section id="jd002"><title>Footprints - truly a push technology</title><keyword>push</keyword>
+<para>One could safely say that making footprints is a push technology. This is even more true when the footprint maker is the Empress of the Universe. </para>
+<subsec1 id="jd003"><title>The sands of time</title><keyword>time</keyword>
+<para>The 1<super>st</super> think to remember about the Universe is the time/space continuum to which it conforms. This then confuses the sands of time to be something more like the sands of time/space continuum because if you wait on those sands long enough they may be somewhere else - not necessarily because of the time/space continuum but because the winds will <highlight style="ital">push</highlight> them down the beach.</para></subsec1>
+<subsec1 id="jd004"><title>Identifying the footprints</title>
+<para>In order to truly understand who has walked on the sands and left the footprints, it is important to identify the <keyword>characteristics</keyword>characteristics of the footprint. In the graphic <xref refloc="jd005" type="title"/>, we can see the footprints are large, well shaped, and evenly distributed from front to back and side to side.</para>
+<figure id="jd005"><title>Footprint in Sand</title><caption><para>Note the evenly distributed shape and indention</para></caption><graphic figname="footprint"/></figure>
+<para>This footprint begs the question, 'What kind of remarkable <keyword>shoe</keyword>shoe could make such a wonderful footprint?'</para>
+<table id="t1">
+<tgroup cols="2">
+<thead><row><entry>Shoe Type</entry><entry>Remarkability Rating</entry></row></thead>
+<tbody><row><entry>Acme Shoe</entry><entry>Unremarkable</entry></row>
+<row><entry>Budget Shoe</entry><entry>Not worth remarking on</entry></row>
+<row><entry>Super Duper Shoe</entry><entry>Absolutely Remarkable</entry></row></tbody>
+</tgroup></table></subsec1>
+<subsec1 id="jd006"><title>The Shoe What Made the Footprint</title>
+<para>The remarkable footprint is made by a combination of a terrific shoe worn on a fantastic foot propelled by a one-of-a-kind Empress. As can be seen in Figure <xref refloc="jd007" type="number"/>, the shoe is worthy of an Empress.</para>
+<figure id="jd007"><title>The Terrific Shoe</title><graphic figname="shoes"/></figure>
+<para>The design goals of the shoe were:
+<randlist style = "bulleted">
+<li><para>to minimize time-consuming manual tasks such as shoelace tying;</para></li>
+<li><para>to allow different decorations to be placed on the toes; and</para></li>
+<li><para>to enforce a good arch.</para></li></randlist></para></subsec1></section>
+<section id="jd008"><title>Documenting the Shoe</title>
+<para>Documenting the shoe was the best part for Fred Bloggs. His superior design could be captured for all time in a neutrally-encoded, content-specific manner. An excerpt from his DTD gives an insight into the type of information he captured in his documentation.</para>
+<code.block>&lt;!DOCTYPE shoedoc [
+&lt;!ELEMENT shoedoc - - (design, mfg, care, recycle) >
+&lt;!ATTLIST shoedoc designer CDATA #REQUIRED
+                  date     CDATA #REQUIRED>
+&lt;!ELEMENT design - - (specs, desc) >
+etc.
+</code.block>
+<para>An excerpt from the documentation also gives us insights.</para>
+<code.block><![CDATA[<design>
+<specs sizerange="4-12" widthrange="aa-d" color="navy black white red taupe">
+<para>The arch shall be high. The toe shall be narrow, but not pinch. The heel shall not come off in grates. Sand shall not get in.</para></specs>]]>
+</code.block>
+</section></body>
+<rear><acknowl>
+<para>The authors wish to express our thanks to the Universe for being there and to  gravity for holding the sand down long enough to see the footprints.</para></acknowl>
+<bibliog>
+<bibitem id="jd000"><bib>Barrett 00</bib><pub>Barrett, B., Being Empress Made Easy, Galaxy Division of Universal Publishers. 0000</pub></bibitem></bibliog></rear></gcapaper>

utils/wxPython/demo/pyTree.py

@@ -0,0 +1,211 @@
+"""
+Hello, and welcome to this test of the wxTreeItemData
+class.
+
+The wxTreeItemData class can be used to associate a python
+object with a wxTreeCtrl item. In this sample, its use is
+demonstrated via a tree control that shows the contents of a
+python namespace according to the standard dir()
+command. Every item in the tree has its label taken from the
+dir() output, and 'behind it' a reference to the python
+object is stored in a wxTreeItemData object.
+
+As you may have guessed by now, this sample automatically
+displays '__doc__' strings if the selected python object
+happens to have one. Please expand the pyTree object to
+learn more about the implementation.
+
+Version 1.0, April 4 1999.
+Harm van der Heijden (H.v.d.Heijden@phys.tue.nl)
+
+P.S. Check out the string module. It's imported in this
+sample not because it's used, but because it's so
+beautifully documented...
+"""
+
+from wxPython import wx
+import string # Don't use it, but it's fun expanding :-)
+
+#----------------------------------------------------------------------
+
+def _getindent(line):
+    """Returns the indentation level of the given line."""
+    indent = 0
+    for c in line:
+        if c == ' ': indent = indent + 1
+        elif c == '\t': indent = indent + 8
+        else: break
+    return indent
+
+def _sourcefinder(func):
+    """Given a func_code object, this function tries to find and return
+    the python source code of the function."""
+    try:
+        f = open(func.co_filename,"r")
+    except:
+        return "(could not open file %s)" % (func.co_filename,)
+
+    for i in range(func.co_firstlineno):
+        line = f.readline()
+    ind = _getindent(line)
+    msg = ""
+    while line:
+        msg = msg + line
+        line = f.readline()
+        # the following should be <= ind, but then we get
+        # confused by multiline docstrings. Using == works most of
+        # the time... but not always!
+        if _getindent(line) == ind: break
+    return msg
+
+#----------------------------------------------------------------------
+
+class pyTree(wx.wxTreeCtrl):
+    """
+    This wxTreeCtrl derivative displays a tree view of a Python namespace.
+    Anything from which the dir() command returns a non-empty list is a branch
+    in this tree.
+    """
+
+    def __init__(self, parent, id, root):
+        """
+        Initialize function; because we insert branches into the tree
+        as needed, we use the ITEM_EXPANDING event handler. The
+        ITEM_COLLAPSED handler removes the stuff afterwards. The
+        SEL_CHANGED handler attempts to display interesting
+        information about the selected object.
+        """
+        wx.wxTreeCtrl.__init__(self, parent, id)
+        self.root = self.AddRoot(str(root), -1, -1, wx.wxTreeItemData(root))
+        if dir(root):
+            self.SetItemHasChildren(self.root, wx.TRUE)
+        wx.EVT_TREE_ITEM_EXPANDING(self, self.GetId(), self.OnItemExpanding)
+        wx.EVT_TREE_ITEM_COLLAPSED(self, self.GetId(), self.OnItemCollapsed)
+        wx.EVT_TREE_SEL_CHANGED(self, self.GetId(), self.OnSelChanged)
+        self.output = None
+
+
+    def SetOutput(self, output):
+        """
+        Set output function (accepts single string). Used to display string
+        representation of the selected object by OnSelChanged.
+        """
+        self.output = output
+
+
+    def OnItemExpanding(self,event):
+        """
+        The real workhorse of this class. First we retrieve the object
+        (parent) belonging to the branch that is to be expanded. This
+        is done by calling GetPyData(parent), which is a short-cut for
+        GetPyItemData(parent).Get().
+
+        Then we get the dir() list of that object. For each item in
+        this list, a tree item is created with associated
+        wxTreeItemData referencing the child object. We get this
+        object using child = getattr(parent, item).
+
+        Finally, we check wether the child returns a non-empty dir()
+        list. If so, it is labeled as 'having children', so that it
+        may be expanded. When it actually is expanded, this function
+        will again figure out what the offspring is.
+        """
+        item = event.GetItem()
+        obj = self.GetPyData( item )
+        lst = dir(obj)
+        for key in lst:
+            new_obj = getattr(obj,key)
+            new_item = self.AppendItem( item, key, -1, -1,
+                                        wx.wxTreeItemData(new_obj) )
+            if dir(new_obj):
+                self.SetItemHasChildren(new_item, wx.TRUE)
+
+    def OnItemCollapsed(self, event):
+        """
+        We need to remove all children here, otherwise we'll see all
+        that old rubbish again after the next expansion.
+        """
+        item = event.GetItem()
+        self.DeleteChildren(item)
+
+    def OnSelChanged(self, event):
+        """
+        If an output function is defined, we try to print some
+        informative, interesting and thought-provoking stuff to it.
+        If it has a __doc__ string, we print it. If it's a function or
+        unbound class method, we attempt to find the python source.
+        """
+        if not self.output:
+            return
+        obj = self.GetPyData( event.GetItem() )
+        msg = str(obj)
+        if hasattr(obj, '__doc__'):
+            msg = msg+"\n\nDocumentation string:\n\n%s" % ( getattr(obj, '__doc__'),)
+        # Is it a function?
+        func = None
+        if hasattr(obj, "func_code"): # normal function
+            func = getattr(obj, "func_code")
+        elif hasattr(obj, "im_func"): # unbound class method
+            func = getattr(getattr(obj, "im_func"), "func_code")
+        if func: # if we found one, let's try to print the source
+            msg = msg+"\n\nFunction source:\n\n" + _sourcefinder(func)
+
+        apply(self.output, (msg,))
+
+#----------------------------------------------------------------------
+
+overview = __doc__
+
+def runTest(frame, nb, log):
+    """
+    This method is used by the wxPython Demo Framework for integrating
+    this demo with the rest.
+    """
+    thisModule = __import__(__name__, globals())
+    win = wx.wxFrame(frame, -1, "PyTreeItemData Test")
+    split = wx.wxSplitterWindow(win, -1)
+    tree = pyTree(split, -1, thisModule)
+    text = wx.wxTextCtrl(split, -1, "", wx.wxDefaultPosition,
+                         wx.wxDefaultSize, wx.wxTE_MULTILINE)
+    split.SplitVertically(tree, text, 200)
+    tree.SetOutput(text.SetValue)
+    tree.SelectItem(tree.root)
+    win.SetSize(wx.wxSize(800,500))
+    frame.otherWin = win
+    win.Show(1)
+
+
+
+#----------------------------------------------------------------------
+if __name__ == '__main__':
+
+    class MyFrame(wx.wxFrame):
+        """Very standard Frame class. Nothing special here!"""
+
+        def __init__(self):
+            """Make a splitter window; left a tree, right a textctrl. Wow."""
+            import __main__
+            wx.wxFrame.__init__(self, wx.NULL, -1, "PyTreeItemData Test",
+                                wx.wxDefaultPosition, wx.wxSize(800,500))
+            split = wx.wxSplitterWindow(self, -1)
+            tree = pyTree(split, -1, __main__)
+            text = wx.wxTextCtrl(split, -1, "", wx.wxDefaultPosition,
+                                 wx.wxDefaultSize, wx.wxTE_MULTILINE)
+            split.SplitVertically(tree, text, 200)
+            tree.SetOutput(text.SetValue)
+            tree.SelectItem(tree.root)
+
+    class MyApp(wx.wxApp):
+        """This class is even less interesting than MyFrame."""
+
+        def OnInit(self):
+            """OnInit. Boring, boring, boring!"""
+            frame = MyFrame()
+            frame.Show(wx.TRUE)
+            self.SetTopWindow(frame)
+            return wx.TRUE
+
+    app = MyApp(0)
+    app.MainLoop()
+
+