This commit was manufactured by cvs2svn to create tag 'ALPHA_3_8'.

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/tags/ALPHA_3_8@10995 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/regex/COPYRIGHT

@@ -0,0 +1,20 @@
+Copyright 1992, 1993, 1994, 1997 Henry Spencer.  All rights reserved.
+This software is not subject to any license of the American Telephone
+and Telegraph Company or of the Regents of the University of California.
+
+Permission is granted to anyone to use this software for any purpose on
+any computer system, and to alter it and redistribute it, subject
+to the following restrictions:
+
+1. The author is not responsible for the consequences of use of this
+   software, no matter how awful, even if they arise from flaws in it.
+
+2. The origin of this software must not be misrepresented, either by
+   explicit claim or by omission.  Since few users ever read sources,
+   credits must appear in the documentation.
+
+3. Altered versions must be plainly marked as such, and must not be
+   misrepresented as being the original software.  Since few users
+   ever read sources, credits must appear in the documentation.
+
+4. This notice may not be removed or altered.

src/regex/Makefile

@@ -0,0 +1,130 @@
+# You probably want to take -DREDEBUG out of CFLAGS, and put something like
+# -O in, *after* testing (-DREDEBUG strengthens testing by enabling a lot of
+# internal assertion checking and some debugging facilities).
+# Put -Dconst= in for a pre-ANSI compiler.
+# Do not take -DPOSIX_MISTAKE out.
+# REGCFLAGS isn't important to you (it's for my use in some special contexts).
+CFLAGS=-I. -DPOSIX_MISTAKE -DREDEBUG $(REGCFLAGS)
+
+# If you have a pre-ANSI compiler, put -o into MKHFLAGS.  If you want
+# the Berkeley __P macro, put -b in.
+MKHFLAGS=
+
+# Flags for linking but not compiling, if any.
+LDFLAGS=
+
+# Extra libraries for linking, if any.
+LIBS=
+
+# Internal stuff, should not need changing.
+OBJPRODN=regcomp.o regexec.o regerror.o regfree.o
+OBJS=$(OBJPRODN) split.o debug.o main.o
+H=cclass.h cname.h regex2.h utils.h
+REGSRC=regcomp.c regerror.c regexec.c regfree.c
+ALLSRC=$(REGSRC) engine.c debug.c main.c split.c
+
+# Stuff that matters only if you're trying to lint the package.
+LINTFLAGS=-I. -Dstatic= -Dconst= -DREDEBUG
+LINTC=regcomp.c regexec.c regerror.c regfree.c debug.c main.c
+JUNKLINT=possible pointer alignment|null effect
+
+# arrangements to build forward-reference header files
+.SUFFIXES:	.ih .h
+.c.ih:
+	sh ./mkh $(MKHFLAGS) -p $< >$@
+
+default:	r
+
+lib:	purge $(OBJPRODN)
+	rm -f libregex.a
+	ar crv libregex.a $(OBJPRODN)
+
+purge:
+	rm -f *.o
+
+# stuff to build regex.h
+REGEXH=regex.h
+REGEXHSRC=regex2.h $(REGSRC)
+$(REGEXH):	$(REGEXHSRC) mkh
+	sh ./mkh $(MKHFLAGS) -i _REGEX_H_ $(REGEXHSRC) >regex.tmp
+	cmp -s regex.tmp regex.h 2>/dev/null || cp regex.tmp regex.h
+	rm -f regex.tmp
+
+# dependencies
+$(OBJPRODN) debug.o:	utils.h regex.h regex2.h
+regcomp.o:	cclass.h cname.h regcomp.ih
+regexec.o:	engine.c engine.ih
+regerror.o:	regerror.ih
+debug.o:	debug.ih
+main.o:	main.ih
+
+# tester
+re:	$(OBJS)
+	$(CC) $(CFLAGS) $(LDFLAGS) $(OBJS) $(LIBS) -o $@
+
+# regression test
+r:	re tests
+	./re <tests
+	./re -el <tests
+	./re -er <tests
+
+# 57 variants, and other stuff, for development use -- not useful to you
+ra:	./re tests
+	-./re <tests
+	-./re -el <tests
+	-./re -er <tests
+
+rx:	./re tests
+	./re -x <tests
+	./re -x -el <tests
+	./re -x -er <tests
+
+t:	./re tests
+	-time ./re <tests
+	-time ./re -cs <tests
+	-time ./re -el <tests
+	-time ./re -cs -el <tests
+
+l:	$(LINTC)
+	lint $(LINTFLAGS) -h $(LINTC) 2>&1 | egrep -v '$(JUNKLINT)' | tee lint
+
+fullprint:
+	ti README WHATSNEW notes todo | list
+	ti *.h | list
+	list *.c
+	list regex.3 regex.7
+
+print:
+	ti README WHATSNEW notes todo | list
+	ti *.h | list
+	list reg*.c engine.c
+
+
+mf.tmp:	Makefile
+	sed '/^REGEXH=/s/=.*/=regex.h/' Makefile | sed '/#DEL$$/d' >$@
+
+DTRH=cclass.h cname.h regex2.h utils.h
+PRE=COPYRIGHT README WHATSNEW
+POST=mkh regex.3 regex.7 tests $(DTRH) $(ALLSRC) fake/*.[ch]
+FILES=$(PRE) Makefile $(POST)
+DTR=$(PRE) Makefile=mf.tmp $(POST)
+dtr:	$(FILES) mf.tmp
+	makedtr $(DTR) >$@
+	rm mf.tmp
+
+cio:	$(FILES)
+	cio $(FILES)
+
+rdf:	$(FILES)
+	rcsdiff -c $(FILES) 2>&1 | p
+
+# various forms of cleanup
+tidy:
+	rm -f junk* core core.* *.core dtr *.tmp lint
+
+clean:	tidy
+	rm -f *.o *.s *.ih re libregex.a
+
+# don't do this one unless you know what you're doing
+spotless:	clean
+	rm -f mkh regex.h

src/regex/README

@@ -0,0 +1,32 @@
+alpha3.8 release.
+Tue Aug 10 15:51:48 EDT 1999
+henry@spsystems.net  (formerly henry@zoo.toronto.edu)
+
+See WHATSNEW for change listing.
+
+installation notes:
+--------
+Read the comments at the beginning of Makefile before running.
+
+Utils.h contains some things that just might have to be modified on
+some systems, as well as a nested include (ugh) of <assert.h>.
+
+The "fake" directory contains quick-and-dirty fakes for some header
+files and routines that old systems may not have.  Note also that
+-DUSEBCOPY will make utils.h substitute bcopy() for memmove().
+
+After that, "make r" will build regcomp.o, regexec.o, regfree.o,
+and regerror.o (the actual routines), bundle them together into a test
+program, and run regression tests on them.  No output is good output.
+
+"make lib" builds just the .o files for the actual routines (when
+you're happy with testing and have adjusted CFLAGS for production),
+and puts them together into libregex.a.  You can pick up either the
+library or *.o ("make lib" makes sure there are no other .o files left
+around to confuse things).
+
+Main.c, debug.c, split.c are used for regression testing but are not part
+of the RE routines themselves.
+
+Regex.h goes in /usr/include.  All other .h files are internal only.
+--------

src/regex/WHATSNEW

@@ -0,0 +1,108 @@
+New in alpha3.8:  Bug fix for signed/unsigned mixup, found and fixed
+by the FreeBSD folks.
+
+New in alpha3.7:  A bit of cleanup aimed at maximizing portability,
+possibly at slight cost in efficiency.  "ul" suffixes and "unsigned long"
+no longer appear, in particular.
+
+New in alpha3.6:  A couple more portability glitches fixed.
+
+New in alpha3.5:  Active development of this code has been stopped --
+I'm working on a complete reimplementation -- but folks have found some
+minor portability glitches and the like, hence this release to fix them.
+One penalty:  slightly reduced compatibility with old compilers, because
+the ANSI C `unsigned long' type and `ul' constant suffix are used in a
+few places (I could avoid this but it would be considerably more work).
+
+New in alpha3.4:  The complex bug alluded to below has been fixed (in a
+slightly kludgey temporary way that may hurt efficiency a bit; this is
+another "get it out the door for 4.4" release).  The tests at the end of
+the tests file have accordingly been uncommented.  The primary sign of
+the bug was that something like a?b matching ab matched b rather than ab.
+(The bug was essentially specific to this exact situation, else it would
+have shown up earlier.)
+
+New in alpha3.3:  The definition of word boundaries has been altered
+slightly, to more closely match the usual programming notion that "_"
+is an alphabetic.  Stuff used for pre-ANSI systems is now in a subdir,
+and the makefile no longer alludes to it in mysterious ways.  The
+makefile has generally been cleaned up some.  Fixes have been made
+(again!) so that the regression test will run without -DREDEBUG, at
+the cost of weaker checking.  A workaround for a bug in some folks'
+<assert.h> has been added.  And some more things have been added to
+tests, including a couple right at the end which are commented out
+because the code currently flunks them (complex bug; fix coming).
+Plus the usual minor cleanup.
+
+New in alpha3.2:  Assorted bits of cleanup and portability improvement
+(the development base is now a BSDI system using GCC instead of an ancient
+Sun system, and the newer compiler exposed some glitches).  Fix for a
+serious bug that affected REs using many [] (including REG_ICASE REs
+because of the way they are implemented), *sometimes*, depending on
+memory-allocation patterns.  The header-file prototypes no longer name
+the parameters, avoiding possible name conflicts.  The possibility that
+some clot has defined CHAR_MIN as (say) `-128' instead of `(-128)' is
+now handled gracefully.  "uchar" is no longer used as an internal type
+name (too many people have the same idea).  Still the same old lousy
+performance, alas.
+
+New in alpha3.1:  Basically nothing, this release is just a bookkeeping
+convenience.  Stay tuned.
+
+New in alpha3.0:  Performance is no better, alas, but some fixes have been
+made and some functionality has been added.  (This is basically the "get
+it out the door in time for 4.4" release.)  One bug fix:  regfree() didn't
+free the main internal structure (how embarrassing).  It is now possible
+to put NULs in either the RE or the target string, using (resp.) a new
+REG_PEND flag and the old REG_STARTEND flag.  The REG_NOSPEC flag to
+regcomp() makes all characters ordinary, so you can match a literal
+string easily (this will become more useful when performance improves!).
+There are now primitives to match beginnings and ends of words, although
+the syntax is disgusting and so is the implementation.  The REG_ATOI
+debugging interface has changed a bit.  And there has been considerable
+internal cleanup of various kinds.
+
+New in alpha2.3:  Split change list out of README, and moved flags notes
+into Makefile.  Macro-ized the name of regex(7) in regex(3), since it has
+to change for 4.4BSD.  Cleanup work in engine.c, and some new regression
+tests to catch tricky cases thereof.
+
+New in alpha2.2:  Out-of-date manpages updated.  Regerror() acquires two
+small extensions -- REG_ITOA and REG_ATOI -- which avoid debugging kludges
+in my own test program and might be useful to others for similar purposes.
+The regression test will now compile (and run) without REDEBUG.  The
+BRE \$ bug is fixed.  Most uses of "uchar" are gone; it's all chars now.
+Char/uchar parameters are now written int/unsigned, to avoid possible
+portability problems with unpromoted parameters.  Some unsigned casts have
+been introduced to minimize portability problems with shifting into sign
+bits.
+
+New in alpha2.1:  Lots of little stuff, cleanup and fixes.  The one big
+thing is that regex.h is now generated, using mkh, rather than being
+supplied in the distribution; due to circularities in dependencies,
+you have to build regex.h explicitly by "make h".  The two known bugs
+have been fixed (and the regression test now checks for them), as has a
+problem with assertions not being suppressed in the absence of REDEBUG.
+No performance work yet.
+
+New in alpha2:  Backslash-anything is an ordinary character, not an
+error (except, of course, for the handful of backslashed metacharacters
+in BREs), which should reduce script breakage.  The regression test
+checks *where* null strings are supposed to match, and has generally
+been tightened up somewhat.  Small bug fixes in parameter passing (not
+harmful, but technically errors) and some other areas.  Debugging
+invoked by defining REDEBUG rather than not defining NDEBUG.
+
+New in alpha+3:  full prototyping for internal routines, using a little
+helper program, mkh, which extracts prototypes given in stylized comments.
+More minor cleanup.  Buglet fix:  it's CHAR_BIT, not CHAR_BITS.  Simple
+pre-screening of input when a literal string is known to be part of the
+RE; this does wonders for performance.
+
+New in alpha+2:  minor bits of cleanup.  Notably, the number "32" for the
+word width isn't hardwired into regexec.c any more, the public header
+file prototypes the functions if __STDC__ is defined, and some small typos
+in the manpages have been fixed.
+
+New in alpha+1:  improvements to the manual pages, and an important
+extension, the REG_STARTEND option to regexec().

src/regex/cclass.h

@@ -0,0 +1,31 @@
+/* character-class table */
+static struct cclass {
+	char *name;
+	char *chars;
+	char *multis;
+} cclasses[] = {
+	"alnum",	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\
+0123456789",				"",
+	"alpha",	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+					"",
+	"blank",	" \t",		"",
+	"cntrl",	"\007\b\t\n\v\f\r\1\2\3\4\5\6\16\17\20\21\22\23\24\
+\25\26\27\30\31\32\33\34\35\36\37\177",	"",
+	"digit",	"0123456789",	"",
+	"graph",	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\
+0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
+					"",
+	"lower",	"abcdefghijklmnopqrstuvwxyz",
+					"",
+	"print",	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\
+0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ ",
+					"",
+	"punct",	"!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
+					"",
+	"space",	"\t\n\v\f\r ",	"",
+	"upper",	"ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+					"",
+	"xdigit",	"0123456789ABCDEFabcdef",
+					"",
+	NULL,		0,		""
+};

src/regex/cname.h

@@ -0,0 +1,102 @@
+/* character-name table */
+static struct cname {
+	char *name;
+	char code;
+} cnames[] = {
+	"NUL",	'\0',
+	"SOH",	'\001',
+	"STX",	'\002',
+	"ETX",	'\003',
+	"EOT",	'\004',
+	"ENQ",	'\005',
+	"ACK",	'\006',
+	"BEL",	'\007',
+	"alert",	'\007',
+	"BS",		'\010',
+	"backspace",	'\b',
+	"HT",		'\011',
+	"tab",		'\t',
+	"LF",		'\012',
+	"newline",	'\n',
+	"VT",		'\013',
+	"vertical-tab",	'\v',
+	"FF",		'\014',
+	"form-feed",	'\f',
+	"CR",		'\015',
+	"carriage-return",	'\r',
+	"SO",	'\016',
+	"SI",	'\017',
+	"DLE",	'\020',
+	"DC1",	'\021',
+	"DC2",	'\022',
+	"DC3",	'\023',
+	"DC4",	'\024',
+	"NAK",	'\025',
+	"SYN",	'\026',
+	"ETB",	'\027',
+	"CAN",	'\030',
+	"EM",	'\031',
+	"SUB",	'\032',
+	"ESC",	'\033',
+	"IS4",	'\034',
+	"FS",	'\034',
+	"IS3",	'\035',
+	"GS",	'\035',
+	"IS2",	'\036',
+	"RS",	'\036',
+	"IS1",	'\037',
+	"US",	'\037',
+	"space",		' ',
+	"exclamation-mark",	'!',
+	"quotation-mark",	'"',
+	"number-sign",		'#',
+	"dollar-sign",		'$',
+	"percent-sign",		'%',
+	"ampersand",		'&',
+	"apostrophe",		'\'',
+	"left-parenthesis",	'(',
+	"right-parenthesis",	')',
+	"asterisk",	'*',
+	"plus-sign",	'+',
+	"comma",	',',
+	"hyphen",	'-',
+	"hyphen-minus",	'-',
+	"period",	'.',
+	"full-stop",	'.',
+	"slash",	'/',
+	"solidus",	'/',
+	"zero",		'0',
+	"one",		'1',
+	"two",		'2',
+	"three",	'3',
+	"four",		'4',
+	"five",		'5',
+	"six",		'6',
+	"seven",	'7',
+	"eight",	'8',
+	"nine",		'9',
+	"colon",	':',
+	"semicolon",	';',
+	"less-than-sign",	'<',
+	"equals-sign",		'=',
+	"greater-than-sign",	'>',
+	"question-mark",	'?',
+	"commercial-at",	'@',
+	"left-square-bracket",	'[',
+	"backslash",		'\\',
+	"reverse-solidus",	'\\',
+	"right-square-bracket",	']',
+	"circumflex",		'^',
+	"circumflex-accent",	'^',
+	"underscore",		'_',
+	"low-line",		'_',
+	"grave-accent",		'`',
+	"left-brace",		'{',
+	"left-curly-bracket",	'{',
+	"vertical-line",	'|',
+	"right-brace",		'}',
+	"right-curly-bracket",	'}',
+	"tilde",		'~',
+	"DEL",	'\177',
+	NULL,	0,
+};

src/regex/debug.c

@@ -0,0 +1,242 @@
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <regex.h>
+
+#include "utils.h"
+#include "regex2.h"
+#include "debug.ih"
+
+/*
+ - regprint - print a regexp for debugging
+ == void regprint(regex_t *r, FILE *d);
+ */
+void
+regprint(r, d)
+regex_t *r;
+FILE *d;
+{
+	register struct re_guts *g = r->re_g;
+	register int i;
+	register int c;
+	register int last;
+	int nincat[NC];
+
+	fprintf(d, "%ld states, %d categories", (long)g->nstates,
+							g->ncategories);
+	fprintf(d, ", first %ld last %ld", (long)g->firststate,
+						(long)g->laststate);
+	if (g->iflags&USEBOL)
+		fprintf(d, ", USEBOL");
+	if (g->iflags&USEEOL)
+		fprintf(d, ", USEEOL");
+	if (g->iflags&BAD)
+		fprintf(d, ", BAD");
+	if (g->nsub > 0)
+		fprintf(d, ", nsub=%ld", (long)g->nsub);
+	if (g->must != NULL)
+		fprintf(d, ", must(%ld) `%*s'", (long)g->mlen, (int)g->mlen,
+								g->must);
+	if (g->backrefs)
+		fprintf(d, ", backrefs");
+	if (g->nplus > 0)
+		fprintf(d, ", nplus %ld", (long)g->nplus);
+	fprintf(d, "\n");
+	s_print(g, d);
+	for (i = 0; i < g->ncategories; i++) {
+		nincat[i] = 0;
+		for (c = CHAR_MIN; c <= CHAR_MAX; c++)
+			if (g->categories[c] == i)
+				nincat[i]++;
+	}
+	fprintf(d, "cc0#%d", nincat[0]);
+	for (i = 1; i < g->ncategories; i++)
+		if (nincat[i] == 1) {
+			for (c = CHAR_MIN; c <= CHAR_MAX; c++)
+				if (g->categories[c] == i)
+					break;
+			fprintf(d, ", %d=%s", i, regchar(c));
+		}
+	fprintf(d, "\n");
+	for (i = 1; i < g->ncategories; i++)
+		if (nincat[i] != 1) {
+			fprintf(d, "cc%d\t", i);
+			last = -1;
+			for (c = CHAR_MIN; c <= CHAR_MAX+1; c++)	/* +1 does flush */
+				if (c <= CHAR_MAX && g->categories[c] == i) {
+					if (last < 0) {
+						fprintf(d, "%s", regchar(c));
+						last = c;
+					}
+				} else {
+					if (last >= 0) {
+						if (last != c-1)
+							fprintf(d, "-%s",
+								regchar(c-1));
+						last = -1;
+					}
+				}
+			fprintf(d, "\n");
+		}
+}
+
+/*
+ - s_print - print the strip for debugging
+ == static void s_print(register struct re_guts *g, FILE *d);
+ */
+static void
+s_print(g, d)
+register struct re_guts *g;
+FILE *d;
+{
+	register sop *s;
+	register cset *cs;
+	register int i;
+	register int done = 0;
+	register sop opnd;
+	register int col = 0;
+	register int last;
+	register sopno offset = 2;
+#	define	GAP()	{	if (offset % 5 == 0) { \
+					if (col > 40) { \
+						fprintf(d, "\n\t"); \
+						col = 0; \
+					} else { \
+						fprintf(d, " "); \
+						col++; \
+					} \
+				} else \
+					col++; \
+				offset++; \
+			}
+
+	if (OP(g->strip[0]) != OEND)
+		fprintf(d, "missing initial OEND!\n");
+	for (s = &g->strip[1]; !done; s++) {
+		opnd = OPND(*s);
+		switch (OP(*s)) {
+		case OEND:
+			fprintf(d, "\n");
+			done = 1;
+			break;
+		case OCHAR:
+			if (strchr("\\|()^$.[+*?{}!<> ", (char)opnd) != NULL)
+				fprintf(d, "\\%c", (char)opnd);
+			else
+				fprintf(d, "%s", regchar((char)opnd));
+			break;
+		case OBOL:
+			fprintf(d, "^");
+			break;
+		case OEOL:
+			fprintf(d, "$");
+			break;
+		case OBOW:
+			fprintf(d, "\\{");
+			break;
+		case OEOW:
+			fprintf(d, "\\}");
+			break;
+		case OANY:
+			fprintf(d, ".");
+			break;
+		case OANYOF:
+			fprintf(d, "[(%ld)", (long)opnd);
+			cs = &g->sets[opnd];
+			last = -1;
+			for (i = 0; i < g->csetsize+1; i++)	/* +1 flushes */
+				if (CHIN(cs, i) && i < g->csetsize) {
+					if (last < 0) {
+						fprintf(d, "%s", regchar(i));
+						last = i;
+					}
+				} else {
+					if (last >= 0) {
+						if (last != i-1)
+							fprintf(d, "-%s",
+								regchar(i-1));
+						last = -1;
+					}
+				}
+			fprintf(d, "]");
+			break;
+		case OBACK_:
+			fprintf(d, "(\\<%ld>", (long)opnd);
+			break;
+		case O_BACK:
+			fprintf(d, "<%ld>\\)", (long)opnd);
+			break;
+		case OPLUS_:
+			fprintf(d, "(+");
+			if (OP(*(s+opnd)) != O_PLUS)
+				fprintf(d, "<%ld>", (long)opnd);
+			break;
+		case O_PLUS:
+			if (OP(*(s-opnd)) != OPLUS_)
+				fprintf(d, "<%ld>", (long)opnd);
+			fprintf(d, "+)");
+			break;
+		case OQUEST_:
+			fprintf(d, "(?");
+			if (OP(*(s+opnd)) != O_QUEST)
+				fprintf(d, "<%ld>", (long)opnd);
+			break;
+		case O_QUEST:
+			if (OP(*(s-opnd)) != OQUEST_)
+				fprintf(d, "<%ld>", (long)opnd);
+			fprintf(d, "?)");
+			break;
+		case OLPAREN:
+			fprintf(d, "((<%ld>", (long)opnd);
+			break;
+		case ORPAREN:
+			fprintf(d, "<%ld>))", (long)opnd);
+			break;
+		case OCH_:
+			fprintf(d, "<");
+			if (OP(*(s+opnd)) != OOR2)
+				fprintf(d, "<%ld>", (long)opnd);
+			break;
+		case OOR1:
+			if (OP(*(s-opnd)) != OOR1 && OP(*(s-opnd)) != OCH_)
+				fprintf(d, "<%ld>", (long)opnd);
+			fprintf(d, "|");
+			break;
+		case OOR2:
+			fprintf(d, "|");
+			if (OP(*(s+opnd)) != OOR2 && OP(*(s+opnd)) != O_CH)
+				fprintf(d, "<%ld>", (long)opnd);
+			break;
+		case O_CH:
+			if (OP(*(s-opnd)) != OOR1)
+				fprintf(d, "<%ld>", (long)opnd);
+			fprintf(d, ">");
+			break;
+		default:
+			fprintf(d, "!%d(%d)!", OP(*s), opnd);
+			break;
+		}
+		if (!done)
+			GAP();
+	}
+}
+
+/*
+ - regchar - make a character printable
+ == static char *regchar(int ch);
+ */
+static char *			/* -> representation */
+regchar(ch)
+int ch;
+{
+	static char buf[10];
+
+	if (isprint(ch) || ch == ' ')
+		sprintf(buf, "%c", ch);
+	else
+		sprintf(buf, "\\%o", ch);
+	return(buf);
+}

src/regex/main.c

@@ -0,0 +1,510 @@
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <regex.h>
+#include <assert.h>
+
+#include "main.ih"
+
+char *progname;
+int debug = 0;
+int line = 0;
+int status = 0;
+
+int copts = REG_EXTENDED;
+int eopts = 0;
+regoff_t startoff = 0;
+regoff_t endoff = 0;
+
+
+extern int split();
+extern void regprint();
+
+/*
+ - main - do the simple case, hand off to regress() for regression
+ */
+main(argc, argv)
+int argc;
+char *argv[];
+{
+	regex_t re;
+#	define	NS	10
+	regmatch_t subs[NS];
+	char erbuf[100];
+	int err;
+	size_t len;
+	int c;
+	int errflg = 0;
+	register int i;
+	extern int optind;
+	extern char *optarg;
+
+	progname = argv[0];
+
+	while ((c = getopt(argc, argv, "c:e:S:E:x")) != EOF)
+		switch (c) {
+		case 'c':	/* compile options */
+			copts = options('c', optarg);
+			break;
+		case 'e':	/* execute options */
+			eopts = options('e', optarg);
+			break;
+		case 'S':	/* start offset */
+			startoff = (regoff_t)atoi(optarg);
+			break;
+		case 'E':	/* end offset */
+			endoff = (regoff_t)atoi(optarg);
+			break;
+		case 'x':	/* Debugging. */
+			debug++;
+			break;
+		case '?':
+		default:
+			errflg++;
+			break;
+		}
+	if (errflg) {
+		fprintf(stderr, "usage: %s ", progname);
+		fprintf(stderr, "[-c copt][-C][-d] [re]\n");
+		exit(2);
+	}
+
+	if (optind >= argc) {
+		regress(stdin);
+		exit(status);
+	}
+
+	err = regcomp(&re, argv[optind++], copts);
+	if (err) {
+		len = regerror(err, &re, erbuf, sizeof(erbuf));
+		fprintf(stderr, "error %s, %d/%d `%s'\n",
+			eprint(err), len, sizeof(erbuf), erbuf);
+		exit(status);
+	}
+	regprint(&re, stdout);	
+
+	if (optind >= argc) {
+		regfree(&re);
+		exit(status);
+	}
+
+	if (eopts&REG_STARTEND) {
+		subs[0].rm_so = startoff;
+		subs[0].rm_eo = strlen(argv[optind]) - endoff;
+	}
+	err = regexec(&re, argv[optind], (size_t)NS, subs, eopts);
+	if (err) {
+		len = regerror(err, &re, erbuf, sizeof(erbuf));
+		fprintf(stderr, "error %s, %d/%d `%s'\n",
+			eprint(err), len, sizeof(erbuf), erbuf);
+		exit(status);
+	}
+	if (!(copts&REG_NOSUB)) {
+		len = (int)(subs[0].rm_eo - subs[0].rm_so);
+		if (subs[0].rm_so != -1) {
+			if (len != 0)
+				printf("match `%.*s'\n", len,
+					argv[optind] + subs[0].rm_so);
+			else
+				printf("match `'@%.1s\n",
+					argv[optind] + subs[0].rm_so);
+		}
+		for (i = 1; i < NS; i++)
+			if (subs[i].rm_so != -1)
+				printf("(%d) `%.*s'\n", i,
+					(int)(subs[i].rm_eo - subs[i].rm_so),
+					argv[optind] + subs[i].rm_so);
+	}
+	exit(status);
+}
+
+/*
+ - regress - main loop of regression test
+ == void regress(FILE *in);
+ */
+void
+regress(in)
+FILE *in;
+{
+	char inbuf[1000];
+#	define	MAXF	10
+	char *f[MAXF];
+	int nf;
+	int i;
+	char erbuf[100];
+	size_t ne;
+	char *badpat = "invalid regular expression";
+#	define	SHORT	10
+	char *bpname = "REG_BADPAT";
+	regex_t re;
+
+	while (fgets(inbuf, sizeof(inbuf), in) != NULL) {
+		line++;
+		if (inbuf[0] == '#' || inbuf[0] == '\n')
+			continue;			/* NOTE CONTINUE */
+		inbuf[strlen(inbuf)-1] = '\0';	/* get rid of stupid \n */
+		if (debug)
+			fprintf(stdout, "%d:\n", line);
+		nf = split(inbuf, f, MAXF, "\t\t");
+		if (nf < 3) {
+			fprintf(stderr, "bad input, line %d\n", line);
+			exit(1);
+		}
+		for (i = 0; i < nf; i++)
+			if (strcmp(f[i], "\"\"") == 0)
+				f[i] = "";
+		if (nf <= 3)
+			f[3] = NULL;
+		if (nf <= 4)
+			f[4] = NULL;
+		try(f[0], f[1], f[2], f[3], f[4], options('c', f[1]));
+		if (opt('&', f[1]))	/* try with either type of RE */
+			try(f[0], f[1], f[2], f[3], f[4],
+					options('c', f[1]) &~ REG_EXTENDED);
+	}
+
+	ne = regerror(REG_BADPAT, (regex_t *)NULL, erbuf, sizeof(erbuf));
+	if (strcmp(erbuf, badpat) != 0 || ne != strlen(badpat)+1) {
+		fprintf(stderr, "end: regerror() test gave `%s' not `%s'\n",
+							erbuf, badpat);
+		status = 1;
+	}
+	ne = regerror(REG_BADPAT, (regex_t *)NULL, erbuf, (size_t)SHORT);
+	if (strncmp(erbuf, badpat, SHORT-1) != 0 || erbuf[SHORT-1] != '\0' ||
+						ne != strlen(badpat)+1) {
+		fprintf(stderr, "end: regerror() short test gave `%s' not `%.*s'\n",
+						erbuf, SHORT-1, badpat);
+		status = 1;
+	}
+	ne = regerror(REG_ITOA|REG_BADPAT, (regex_t *)NULL, erbuf, sizeof(erbuf));
+	if (strcmp(erbuf, bpname) != 0 || ne != strlen(bpname)+1) {
+		fprintf(stderr, "end: regerror() ITOA test gave `%s' not `%s'\n",
+						erbuf, bpname);
+		status = 1;
+	}
+	re.re_endp = bpname;
+	ne = regerror(REG_ATOI, &re, erbuf, sizeof(erbuf));
+	if (atoi(erbuf) != (int)REG_BADPAT) {
+		fprintf(stderr, "end: regerror() ATOI test gave `%s' not `%ld'\n",
+						erbuf, (long)REG_BADPAT);
+		status = 1;
+	} else if (ne != strlen(erbuf)+1) {
+		fprintf(stderr, "end: regerror() ATOI test len(`%s') = %ld\n",
+						erbuf, (long)REG_BADPAT);
+		status = 1;
+	}
+}
+
+/*
+ - try - try it, and report on problems
+ == void try(char *f0, char *f1, char *f2, char *f3, char *f4, int opts);
+ */
+void
+try(f0, f1, f2, f3, f4, opts)
+char *f0;
+char *f1;
+char *f2;
+char *f3;
+char *f4;
+int opts;			/* may not match f1 */
+{
+	regex_t re;
+#	define	NSUBS	10
+	regmatch_t subs[NSUBS];
+#	define	NSHOULD	15
+	char *should[NSHOULD];
+	int nshould;
+	char erbuf[100];
+	int err;
+	int len;
+	char *type = (opts & REG_EXTENDED) ? "ERE" : "BRE";
+	register int i;
+	char *grump;
+	char f0copy[1000];
+	char f2copy[1000];
+
+	strcpy(f0copy, f0);
+	re.re_endp = (opts&REG_PEND) ? f0copy + strlen(f0copy) : NULL;
+	fixstr(f0copy);
+	err = regcomp(&re, f0copy, opts);
+	if (err != 0 && (!opt('C', f1) || err != efind(f2))) {
+		/* unexpected error or wrong error */
+		len = regerror(err, &re, erbuf, sizeof(erbuf));
+		fprintf(stderr, "%d: %s error %s, %d/%d `%s'\n",
+					line, type, eprint(err), len,
+					sizeof(erbuf), erbuf);
+		status = 1;
+	} else if (err == 0 && opt('C', f1)) {
+		/* unexpected success */
+		fprintf(stderr, "%d: %s should have given REG_%s\n",
+						line, type, f2);
+		status = 1;
+		err = 1;	/* so we won't try regexec */
+	}
+
+	if (err != 0) {
+		regfree(&re);
+		return;
+	}
+
+	strcpy(f2copy, f2);
+	fixstr(f2copy);
+
+	if (options('e', f1)&REG_STARTEND) {
+		if (strchr(f2, '(') == NULL || strchr(f2, ')') == NULL)
+			fprintf(stderr, "%d: bad STARTEND syntax\n", line);
+		subs[0].rm_so = strchr(f2, '(') - f2 + 1;
+		subs[0].rm_eo = strchr(f2, ')') - f2;
+	}
+	err = regexec(&re, f2copy, NSUBS, subs, options('e', f1));
+
+	if (err != 0 && (f3 != NULL || err != REG_NOMATCH)) {
+		/* unexpected error or wrong error */
+		len = regerror(err, &re, erbuf, sizeof(erbuf));
+		fprintf(stderr, "%d: %s exec error %s, %d/%d `%s'\n",
+					line, type, eprint(err), len,
+					sizeof(erbuf), erbuf);
+		status = 1;
+	} else if (err != 0) {
+		/* nothing more to check */
+	} else if (f3 == NULL) {
+		/* unexpected success */
+		fprintf(stderr, "%d: %s exec should have failed\n",
+						line, type);
+		status = 1;
+		err = 1;		/* just on principle */
+	} else if (opts&REG_NOSUB) {
+		/* nothing more to check */
+	} else if ((grump = check(f2, subs[0], f3)) != NULL) {
+		fprintf(stderr, "%d: %s %s\n", line, type, grump);
+		status = 1;
+		err = 1;
+	}
+
+	if (err != 0 || f4 == NULL) {
+		regfree(&re);
+		return;
+	}
+
+	for (i = 1; i < NSHOULD; i++)
+		should[i] = NULL;
+	nshould = split(f4, should+1, NSHOULD-1, ",");
+	if (nshould == 0) {
+		nshould = 1;
+		should[1] = "";
+	}
+	for (i = 1; i < NSUBS; i++) {
+		grump = check(f2, subs[i], should[i]);
+		if (grump != NULL) {
+			fprintf(stderr, "%d: %s $%d %s\n", line,
+							type, i, grump);
+			status = 1;
+			err = 1;
+		}
+	}
+
+	regfree(&re);
+}
+
+/*
+ - options - pick options out of a regression-test string
+ == int options(int type, char *s);
+ */
+int
+options(type, s)
+int type;			/* 'c' compile, 'e' exec */
+char *s;
+{
+	register char *p;
+	register int o = (type == 'c') ? copts : eopts;
+	register char *legal = (type == 'c') ? "bisnmp" : "^$#tl";
+
+	for (p = s; *p != '\0'; p++)
+		if (strchr(legal, *p) != NULL)
+			switch (*p) {
+			case 'b':
+				o &= ~REG_EXTENDED;
+				break;
+			case 'i':
+				o |= REG_ICASE;
+				break;
+			case 's':
+				o |= REG_NOSUB;
+				break;
+			case 'n':
+				o |= REG_NEWLINE;
+				break;
+			case 'm':
+				o &= ~REG_EXTENDED;
+				o |= REG_NOSPEC;
+				break;
+			case 'p':
+				o |= REG_PEND;
+				break;
+			case '^':
+				o |= REG_NOTBOL;
+				break;
+			case '$':
+				o |= REG_NOTEOL;
+				break;
+			case '#':
+				o |= REG_STARTEND;
+				break;
+			case 't':	/* trace */
+				o |= REG_TRACE;
+				break;
+			case 'l':	/* force long representation */
+				o |= REG_LARGE;
+				break;
+			case 'r':	/* force backref use */
+				o |= REG_BACKR;
+				break;
+			}
+	return(o);
+}
+
+/*
+ - opt - is a particular option in a regression string?
+ == int opt(int c, char *s);
+ */
+int				/* predicate */
+opt(c, s)
+int c;
+char *s;
+{
+	return(strchr(s, c) != NULL);
+}
+
+/*
+ - fixstr - transform magic characters in strings
+ == void fixstr(register char *p);
+ */
+void
+fixstr(p)
+register char *p;
+{
+	if (p == NULL)
+		return;
+
+	for (; *p != '\0'; p++)
+		if (*p == 'N')
+			*p = '\n';
+		else if (*p == 'T')
+			*p = '\t';
+		else if (*p == 'S')
+			*p = ' ';
+		else if (*p == 'Z')
+			*p = '\0';
+}
+
+/*
+ - check - check a substring match
+ == char *check(char *str, regmatch_t sub, char *should);
+ */
+char *				/* NULL or complaint */
+check(str, sub, should)
+char *str;
+regmatch_t sub;
+char *should;
+{
+	register int len;
+	register int shlen;
+	register char *p;
+	static char grump[500];
+	register char *at = NULL;
+
+	if (should != NULL && strcmp(should, "-") == 0)
+		should = NULL;
+	if (should != NULL && should[0] == '@') {
+		at = should + 1;
+		should = "";
+	}
+
+	/* check rm_so and rm_eo for consistency */
+	if (sub.rm_so > sub.rm_eo || (sub.rm_so == -1 && sub.rm_eo != -1) ||
+				(sub.rm_so != -1 && sub.rm_eo == -1) ||
+				(sub.rm_so != -1 && sub.rm_so < 0) ||
+				(sub.rm_eo != -1 && sub.rm_eo < 0) ) {
+		sprintf(grump, "start %ld end %ld", (long)sub.rm_so,
+							(long)sub.rm_eo);
+		return(grump);
+	}
+
+	/* check for no match */
+	if (sub.rm_so == -1 && should == NULL)
+		return(NULL);
+	if (sub.rm_so == -1)
+		return("did not match");
+
+	/* check for in range */
+	if (sub.rm_eo > strlen(str)) {
+		sprintf(grump, "start %ld end %ld, past end of string",
+					(long)sub.rm_so, (long)sub.rm_eo);
+		return(grump);
+	}
+
+	len = (int)(sub.rm_eo - sub.rm_so);
+	shlen = (int)strlen(should);
+	p = str + sub.rm_so;
+
+	/* check for not supposed to match */
+	if (should == NULL) {
+		sprintf(grump, "matched `%.*s'", len, p);
+		return(grump);
+	}
+
+	/* check for wrong match */
+	if (len != shlen || strncmp(p, should, (size_t)shlen) != 0) {
+		sprintf(grump, "matched `%.*s' instead", len, p);
+		return(grump);
+	}
+	if (shlen > 0)
+		return(NULL);
+
+	/* check null match in right place */
+	if (at == NULL)
+		return(NULL);
+	shlen = strlen(at);
+	if (shlen == 0)
+		shlen = 1;	/* force check for end-of-string */
+	if (strncmp(p, at, shlen) != 0) {
+		sprintf(grump, "matched null at `%.20s'", p);
+		return(grump);
+	}
+	return(NULL);
+}
+
+/*
+ - eprint - convert error number to name
+ == static char *eprint(int err);
+ */
+static char *
+eprint(err)
+int err;
+{
+	static char epbuf[100];
+	size_t len;
+
+	len = regerror(REG_ITOA|err, (regex_t *)NULL, epbuf, sizeof(epbuf));
+	assert(len <= sizeof(epbuf));
+	return(epbuf);
+}
+
+/*
+ - efind - convert error name to number
+ == static int efind(char *name);
+ */
+static int
+efind(name)
+char *name;
+{
+	static char efbuf[100];
+	size_t n;
+	regex_t re;
+
+	sprintf(efbuf, "REG_%s", name);
+	assert(strlen(efbuf) < sizeof(efbuf));
+	re.re_endp = efbuf;
+	(void) regerror(REG_ATOI, &re, efbuf, sizeof(efbuf));
+	return(atoi(efbuf));
+}

src/regex/mkh

@@ -0,0 +1,76 @@
+#! /bin/sh
+# mkh - pull headers out of C source
+PATH=/bin:/usr/bin ; export PATH
+
+# egrep pattern to pick out marked lines
+egrep='^ =([ 	]|$)'
+
+# Sed program to process marked lines into lines for the header file.
+# The markers have already been removed.  Two things are done here:  removal
+# of backslashed newlines, and some fudging of comments.  The first is done
+# because -o needs to have prototypes on one line to strip them down.
+# Getting comments into the output is tricky; we turn C++-style // comments
+# into /* */ comments, after altering any existing */'s to avoid trouble.
+peel='	/\\$/N
+	/\\\n[ 	]*/s///g
+	/\/\//s;\*/;* /;g
+	/\/\//s;//\(.*\);/*\1 */;'
+
+for a
+do
+	case "$a" in
+	-o)	# old (pre-function-prototype) compiler
+		# add code to comment out argument lists
+		peel="$peel
+			"'/^\([^#\/][^\/]*[a-zA-Z0-9_)]\)(\(.*\))/s;;\1(/*\2*/);'
+		shift
+		;;
+	-b)	# funny Berkeley __P macro
+		peel="$peel
+			"'/^\([^#\/][^\/]*[a-zA-Z0-9_)]\)(\(.*\))/s;;\1 __P((\2));'
+		shift
+		;;
+	-s)	# compiler doesn't like `static foo();'
+		# add code to get rid of the `static'
+		peel="$peel
+			"'/^static[ 	][^\/]*[a-zA-Z0-9_)](.*)/s;static.;;'
+		shift
+		;;
+	-p)	# private declarations
+		egrep='^ ==([ 	]|$)'
+		shift
+		;;
+	-i)	# wrap in #ifndef, argument is name
+		ifndef="$2"
+		shift ; shift
+		;;
+	*)	break
+		;;
+	esac
+done
+
+if test " $ifndef" != " "
+then
+	echo "#ifndef $ifndef"
+	echo "#define	$ifndef	/* never again */"
+fi
+echo "/* ========= begin header generated by $0 ========= */"
+echo '#ifdef __cplusplus'
+echo 'extern "C" {'
+echo '#endif'
+for f
+do
+	echo
+	echo "/* === $f === */"
+	egrep "$egrep" $f | sed 's/^ ==*[ 	]//;s/^ ==*$//' | sed "$peel"
+	echo
+done
+echo '#ifdef __cplusplus'
+echo '}'
+echo '#endif'
+echo "/* ========= end header generated by $0 ========= */"
+if test " $ifndef" != " "
+then
+	echo "#endif"
+fi
+exit 0

src/regex/regerror.c

@@ -0,0 +1,126 @@
+#include <sys/types.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <regex.h>
+
+#include "utils.h"
+#include "regerror.ih"
+
+/*
+ = #define	REG_OKAY	 0
+ = #define	REG_NOMATCH	 1
+ = #define	REG_BADPAT	 2
+ = #define	REG_ECOLLATE	 3
+ = #define	REG_ECTYPE	 4
+ = #define	REG_EESCAPE	 5
+ = #define	REG_ESUBREG	 6
+ = #define	REG_EBRACK	 7
+ = #define	REG_EPAREN	 8
+ = #define	REG_EBRACE	 9
+ = #define	REG_BADBR	10
+ = #define	REG_ERANGE	11
+ = #define	REG_ESPACE	12
+ = #define	REG_BADRPT	13
+ = #define	REG_EMPTY	14
+ = #define	REG_ASSERT	15
+ = #define	REG_INVARG	16
+ = #define	REG_ATOI	255	// convert name to number (!)
+ = #define	REG_ITOA	0400	// convert number to name (!)
+ */
+static struct rerr {
+	int code;
+	char *name;
+	char *explain;
+} rerrs[] = {
+	REG_OKAY,	"REG_OKAY",	"no errors detected",
+	REG_NOMATCH,	"REG_NOMATCH",	"regexec() failed to match",
+	REG_BADPAT,	"REG_BADPAT",	"invalid regular expression",
+	REG_ECOLLATE,	"REG_ECOLLATE",	"invalid collating element",
+	REG_ECTYPE,	"REG_ECTYPE",	"invalid character class",
+	REG_EESCAPE,	"REG_EESCAPE",	"trailing backslash (\\)",
+	REG_ESUBREG,	"REG_ESUBREG",	"invalid backreference number",
+	REG_EBRACK,	"REG_EBRACK",	"brackets ([ ]) not balanced",
+	REG_EPAREN,	"REG_EPAREN",	"parentheses not balanced",
+	REG_EBRACE,	"REG_EBRACE",	"braces not balanced",
+	REG_BADBR,	"REG_BADBR",	"invalid repetition count(s)",
+	REG_ERANGE,	"REG_ERANGE",	"invalid character range",
+	REG_ESPACE,	"REG_ESPACE",	"out of memory",
+	REG_BADRPT,	"REG_BADRPT",	"repetition-operator operand invalid",
+	REG_EMPTY,	"REG_EMPTY",	"empty (sub)expression",
+	REG_ASSERT,	"REG_ASSERT",	"\"can't happen\" -- you found a bug",
+	REG_INVARG,	"REG_INVARG",	"invalid argument to regex routine",
+	-1,		"",		"*** unknown regexp error code ***",
+};
+
+/*
+ - regerror - the interface to error numbers
+ = extern size_t regerror(int, const regex_t *, char *, size_t);
+ */
+/* ARGSUSED */
+size_t
+regerror(errcode, preg, errbuf, errbuf_size)
+int errcode;
+const regex_t *preg;
+char *errbuf;
+size_t errbuf_size;
+{
+	register struct rerr *r;
+	register size_t len;
+	register int target = errcode &~ REG_ITOA;
+	register char *s;
+	char convbuf[50];
+
+	if (errcode == REG_ATOI)
+		s = regatoi(preg, convbuf);
+	else {
+		for (r = rerrs; r->code >= 0; r++)
+			if (r->code == target)
+				break;
+	
+		if (errcode&REG_ITOA) {
+			if (r->code >= 0)
+				(void) strcpy(convbuf, r->name);
+			else
+				sprintf(convbuf, "REG_0x%x", target);
+			assert(strlen(convbuf) < sizeof(convbuf));
+			s = convbuf;
+		} else
+			s = r->explain;
+	}
+
+	len = strlen(s) + 1;
+	if (errbuf_size > 0) {
+		if (errbuf_size > len)
+			(void) strcpy(errbuf, s);
+		else {
+			(void) strncpy(errbuf, s, errbuf_size-1);
+			errbuf[errbuf_size-1] = '\0';
+		}
+	}
+
+	return(len);
+}
+
+/*
+ - regatoi - internal routine to implement REG_ATOI
+ == static char *regatoi(const regex_t *preg, char *localbuf);
+ */
+static char *
+regatoi(preg, localbuf)
+const regex_t *preg;
+char *localbuf;
+{
+	register struct rerr *r;
+
+	for (r = rerrs; r->code >= 0; r++)
+		if (strcmp(r->name, preg->re_endp) == 0)
+			break;
+	if (r->code < 0)
+		return("0");
+
+	sprintf(localbuf, "%d", r->code);
+	return(localbuf);
+}

src/regex/regex.3

@@ -0,0 +1,509 @@
+.TH REGEX 3 "25 Sept 1997"
+.BY "Henry Spencer"
+.de ZR
+.\" one other place knows this name:  the SEE ALSO section
+.IR regex (7) \\$1
+..
+.SH NAME
+regcomp, regexec, regerror, regfree \- regular-expression library
+.SH SYNOPSIS
+.ft B
+.\".na
+#include <sys/types.h>
+.br
+#include <regex.h>
+.HP 10
+int regcomp(regex_t\ *preg, const\ char\ *pattern, int\ cflags);
+.HP
+int\ regexec(const\ regex_t\ *preg, const\ char\ *string,
+size_t\ nmatch, regmatch_t\ pmatch[], int\ eflags);
+.HP
+size_t\ regerror(int\ errcode, const\ regex_t\ *preg,
+char\ *errbuf, size_t\ errbuf_size);
+.HP
+void\ regfree(regex_t\ *preg);
+.\".ad
+.ft
+.SH DESCRIPTION
+These routines implement POSIX 1003.2 regular expressions (``RE''s);
+see
+.ZR .
+.I Regcomp
+compiles an RE written as a string into an internal form,
+.I regexec
+matches that internal form against a string and reports results,
+.I regerror
+transforms error codes from either into human-readable messages,
+and
+.I regfree
+frees any dynamically-allocated storage used by the internal form
+of an RE.
+.PP
+The header
+.I <regex.h>
+declares two structure types,
+.I regex_t
+and
+.IR regmatch_t ,
+the former for compiled internal forms and the latter for match reporting.
+It also declares the four functions,
+a type
+.IR regoff_t ,
+and a number of constants with names starting with ``REG_''.
+.PP
+.I Regcomp
+compiles the regular expression contained in the
+.I pattern
+string,
+subject to the flags in
+.IR cflags ,
+and places the results in the
+.I regex_t
+structure pointed to by
+.IR preg .
+.I Cflags
+is the bitwise OR of zero or more of the following flags:
+.IP REG_EXTENDED \w'REG_EXTENDED'u+2n
+Compile modern (``extended'') REs,
+rather than the obsolete (``basic'') REs that
+are the default.
+.IP REG_BASIC
+This is a synonym for 0,
+provided as a counterpart to REG_EXTENDED to improve readability.
+This is an extension,
+compatible with but not specified by POSIX 1003.2,
+and should be used with
+caution in software intended to be portable to other systems.
+.IP REG_NOSPEC
+Compile with recognition of all special characters turned off.
+All characters are thus considered ordinary,
+so the ``RE'' is a literal string.
+This is an extension,
+compatible with but not specified by POSIX 1003.2,
+and should be used with
+caution in software intended to be portable to other systems.
+REG_EXTENDED and REG_NOSPEC may not be used
+in the same call to
+.IR regcomp .
+.IP REG_ICASE
+Compile for matching that ignores upper/lower case distinctions.
+See
+.ZR .
+.IP REG_NOSUB
+Compile for matching that need only report success or failure,
+not what was matched.
+.IP REG_NEWLINE
+Compile for newline-sensitive matching.
+By default, newline is a completely ordinary character with no special
+meaning in either REs or strings.
+With this flag,
+`[^' bracket expressions and `.' never match newline,
+a `^' anchor matches the null string after any newline in the string
+in addition to its normal function,
+and the `$' anchor matches the null string before any newline in the
+string in addition to its normal function.
+.IP REG_PEND
+The regular expression ends,
+not at the first NUL,
+but just before the character pointed to by the
+.I re_endp
+member of the structure pointed to by
+.IR preg .
+The
+.I re_endp
+member is of type
+.IR const\ char\ * .
+This flag permits inclusion of NULs in the RE;
+they are considered ordinary characters.
+This is an extension,
+compatible with but not specified by POSIX 1003.2,
+and should be used with
+caution in software intended to be portable to other systems.
+.PP
+When successful,
+.I regcomp
+returns 0 and fills in the structure pointed to by
+.IR preg .
+One member of that structure
+(other than
+.IR re_endp )
+is publicized:
+.IR re_nsub ,
+of type
+.IR size_t ,
+contains the number of parenthesized subexpressions within the RE
+(except that the value of this member is undefined if the
+REG_NOSUB flag was used).
+If
+.I regcomp
+fails, it returns a non-zero error code;
+see DIAGNOSTICS.
+.PP
+.I Regexec
+matches the compiled RE pointed to by
+.I preg
+against the
+.IR string ,
+subject to the flags in
+.IR eflags ,
+and reports results using
+.IR nmatch ,
+.IR pmatch ,
+and the returned value.
+The RE must have been compiled by a previous invocation of
+.IR regcomp .
+The compiled form is not altered during execution of
+.IR regexec ,
+so a single compiled RE can be used simultaneously by multiple threads.
+.PP
+By default,
+the NUL-terminated string pointed to by
+.I string
+is considered to be the text of an entire line,
+with the NUL indicating the end of the line.
+(That is,
+any other end-of-line marker is considered to have been removed
+and replaced by the NUL.)
+The
+.I eflags
+argument is the bitwise OR of zero or more of the following flags:
+.IP REG_NOTBOL \w'REG_STARTEND'u+2n
+The first character of
+the string
+is not the beginning of a line, so the `^' anchor should not match before it.
+This does not affect the behavior of newlines under REG_NEWLINE.
+.IP REG_NOTEOL
+The NUL terminating
+the string
+does not end a line, so the `$' anchor should not match before it.
+This does not affect the behavior of newlines under REG_NEWLINE.
+.IP REG_STARTEND
+The string is considered to start at
+\fIstring\fR\ + \fIpmatch\fR[0].\fIrm_so\fR
+and to have a terminating NUL located at
+\fIstring\fR\ + \fIpmatch\fR[0].\fIrm_eo\fR
+(there need not actually be a NUL at that location),
+regardless of the value of
+.IR nmatch .
+See below for the definition of
+.IR pmatch
+and
+.IR nmatch .
+This is an extension,
+compatible with but not specified by POSIX 1003.2,
+and should be used with
+caution in software intended to be portable to other systems.
+Note that a non-zero \fIrm_so\fR does not imply REG_NOTBOL;
+REG_STARTEND affects only the location of the string,
+not how it is matched.
+.PP
+See
+.ZR
+for a discussion of what is matched in situations where an RE or a
+portion thereof could match any of several substrings of
+.IR string .
+.PP
+Normally,
+.I regexec
+returns 0 for success and the non-zero code REG_NOMATCH for failure.
+Other non-zero error codes may be returned in exceptional situations;
+see DIAGNOSTICS.
+.PP
+If REG_NOSUB was specified in the compilation of the RE,
+or if
+.I nmatch
+is 0,
+.I regexec
+ignores the
+.I pmatch
+argument (but see below for the case where REG_STARTEND is specified).
+Otherwise,
+.I pmatch
+points to an array of
+.I nmatch
+structures of type
+.IR regmatch_t .
+Such a structure has at least the members
+.I rm_so
+and
+.IR rm_eo ,
+both of type
+.I regoff_t
+(a signed arithmetic type at least as large as an
+.I off_t
+and a
+.IR ssize_t ),
+containing respectively the offset of the first character of a substring
+and the offset of the first character after the end of the substring.
+Offsets are measured from the beginning of the
+.I string
+argument given to
+.IR regexec .
+An empty substring is denoted by equal offsets,
+both indicating the character following the empty substring.
+.PP
+The 0th member of the
+.I pmatch
+array is filled in to indicate what substring of
+.I string
+was matched by the entire RE.
+Remaining members report what substring was matched by parenthesized
+subexpressions within the RE;
+member
+.I i
+reports subexpression
+.IR i ,
+with subexpressions counted (starting at 1) by the order of their opening
+parentheses in the RE, left to right.
+Unused entries in the array\(emcorresponding either to subexpressions that
+did not participate in the match at all, or to subexpressions that do not
+exist in the RE (that is, \fIi\fR\ > \fIpreg\fR\->\fIre_nsub\fR)\(emhave both
+.I rm_so
+and
+.I rm_eo
+set to \-1.
+If a subexpression participated in the match several times,
+the reported substring is the last one it matched.
+(Note, as an example in particular, that when the RE `(b*)+' matches `bbb',
+the parenthesized subexpression matches the three `b's and then
+an infinite number of empty strings following the last `b',
+so the reported substring is one of the empties.)
+.PP
+If REG_STARTEND is specified,
+.I pmatch
+must point to at least one
+.I regmatch_t
+(even if
+.I nmatch
+is 0 or REG_NOSUB was specified),
+to hold the input offsets for REG_STARTEND.
+Use for output is still entirely controlled by
+.IR nmatch ;
+if
+.I nmatch
+is 0 or REG_NOSUB was specified,
+the value of
+.IR pmatch [0]
+will not be changed by a successful
+.IR regexec .
+.PP
+.I Regerror
+maps a non-zero
+.I errcode
+from either
+.I regcomp
+or
+.I regexec
+to a human-readable, printable message.
+If
+.I preg
+is non-NULL,
+the error code should have arisen from use of
+the
+.I regex_t
+pointed to by
+.IR preg ,
+and if the error code came from
+.IR regcomp ,
+it should have been the result from the most recent
+.I regcomp
+using that
+.IR regex_t .
+.RI ( Regerror
+may be able to supply a more detailed message using information
+from the
+.IR regex_t .)
+.I Regerror
+places the NUL-terminated message into the buffer pointed to by
+.IR errbuf ,
+limiting the length (including the NUL) to at most
+.I errbuf_size
+bytes.
+If the whole message won't fit,
+as much of it as will fit before the terminating NUL is supplied.
+In any case,
+the returned value is the size of buffer needed to hold the whole
+message (including terminating NUL).
+If
+.I errbuf_size
+is 0,
+.I errbuf
+is ignored but the return value is still correct.
+.PP
+If the
+.I errcode
+given to
+.I regerror
+is first ORed with REG_ITOA,
+the ``message'' that results is the printable name of the error code,
+e.g. ``REG_NOMATCH'',
+rather than an explanation thereof.
+If
+.I errcode
+is REG_ATOI,
+then
+.I preg
+shall be non-NULL and the
+.I re_endp
+member of the structure it points to
+must point to the printable name of an error code;
+in this case, the result in
+.I errbuf
+is the decimal digits of
+the numeric value of the error code
+(0 if the name is not recognized).
+REG_ITOA and REG_ATOI are intended primarily as debugging facilities;
+they are extensions,
+compatible with but not specified by POSIX 1003.2,
+and should be used with
+caution in software intended to be portable to other systems.
+Be warned also that they are considered experimental and changes are possible.
+.PP
+.I Regfree
+frees any dynamically-allocated storage associated with the compiled RE
+pointed to by
+.IR preg .
+The remaining
+.I regex_t
+is no longer a valid compiled RE
+and the effect of supplying it to
+.I regexec
+or
+.I regerror
+is undefined.
+.PP
+None of these functions references global variables except for tables
+of constants;
+all are safe for use from multiple threads if the arguments are safe.
+.SH IMPLEMENTATION CHOICES
+There are a number of decisions that 1003.2 leaves up to the implementor,
+either by explicitly saying ``undefined'' or by virtue of them being
+forbidden by the RE grammar.
+This implementation treats them as follows.
+.PP
+See
+.ZR
+for a discussion of the definition of case-independent matching.
+.PP
+There is no particular limit on the length of REs,
+except insofar as memory is limited.
+Memory usage is approximately linear in RE size, and largely insensitive
+to RE complexity, except for bounded repetitions.
+See BUGS for one short RE using them
+that will run almost any system out of memory.
+.PP
+A backslashed character other than one specifically given a magic meaning
+by 1003.2 (such magic meanings occur only in obsolete [``basic''] REs)
+is taken as an ordinary character.
+.PP
+Any unmatched [ is a REG_EBRACK error.
+.PP
+Equivalence classes cannot begin or end bracket-expression ranges.
+The endpoint of one range cannot begin another.
+.PP
+RE_DUP_MAX, the limit on repetition counts in bounded repetitions, is 255.
+.PP
+A repetition operator (?, *, +, or bounds) cannot follow another
+repetition operator.
+A repetition operator cannot begin an expression or subexpression
+or follow `^' or `|'.
+.PP
+`|' cannot appear first or last in a (sub)expression or after another `|',
+i.e. an operand of `|' cannot be an empty subexpression.
+An empty parenthesized subexpression, `()', is legal and matches an
+empty (sub)string.
+An empty string is not a legal RE.
+.PP
+A `{' followed by a digit is considered the beginning of bounds for a
+bounded repetition, which must then follow the syntax for bounds.
+A `{' \fInot\fR followed by a digit is considered an ordinary character.
+.PP
+`^' and `$' beginning and ending subexpressions in obsolete (``basic'')
+REs are anchors, not ordinary characters.
+.SH SEE ALSO
+grep(1), regex(7)
+.PP
+POSIX 1003.2, sections 2.8 (Regular Expression Notation)
+and
+B.5 (C Binding for Regular Expression Matching).
+.SH DIAGNOSTICS
+Non-zero error codes from
+.I regcomp
+and
+.I regexec
+include the following:
+.PP
+.nf
+.ta \w'REG_ECOLLATE'u+3n
+REG_NOMATCH	regexec() failed to match
+REG_BADPAT	invalid regular expression
+REG_ECOLLATE	invalid collating element
+REG_ECTYPE	invalid character class
+REG_EESCAPE	\e applied to unescapable character
+REG_ESUBREG	invalid backreference number
+REG_EBRACK	brackets [ ] not balanced
+REG_EPAREN	parentheses ( ) not balanced
+REG_EBRACE	braces { } not balanced
+REG_BADBR	invalid repetition count(s) in { }
+REG_ERANGE	invalid character range in [ ]
+REG_ESPACE	ran out of memory
+REG_BADRPT	?, *, or + operand invalid
+REG_EMPTY	empty (sub)expression
+REG_ASSERT	``can't happen''\(emyou found a bug
+REG_INVARG	invalid argument, e.g. negative-length string
+.fi
+.SH HISTORY
+Written by Henry Spencer,
+henry@zoo.toronto.edu.
+.SH BUGS
+This is an alpha release with known defects.
+Please report problems.
+.PP
+There is one known functionality bug.
+The implementation of internationalization is incomplete:
+the locale is always assumed to be the default one of 1003.2,
+and only the collating elements etc. of that locale are available.
+.PP
+The back-reference code is subtle and doubts linger about its correctness
+in complex cases.
+.PP
+.I Regexec
+performance is poor.
+This will improve with later releases.
+.I Nmatch
+exceeding 0 is expensive;
+.I nmatch
+exceeding 1 is worse.
+.I Regexec
+is largely insensitive to RE complexity \fIexcept\fR that back
+references are massively expensive.
+RE length does matter; in particular, there is a strong speed bonus
+for keeping RE length under about 30 characters,
+with most special characters counting roughly double.
+.PP
+.I Regcomp
+implements bounded repetitions by macro expansion,
+which is costly in time and space if counts are large
+or bounded repetitions are nested.
+An RE like, say,
+`((((a{1,100}){1,100}){1,100}){1,100}){1,100}'
+will (eventually) run almost any existing machine out of swap space.
+.PP
+There are suspected problems with response to obscure error conditions.
+Notably,
+certain kinds of internal overflow,
+produced only by truly enormous REs or by multiply nested bounded repetitions,
+are probably not handled well.
+.PP
+Due to a mistake in 1003.2, things like `a)b' are legal REs because `)' is
+a special character only in the presence of a previous unmatched `('.
+This can't be fixed until the spec is fixed.
+.PP
+The standard's definition of back references is vague.
+For example, does
+`a\e(\e(b\e)*\e2\e)*d' match `abbbd'?
+Until the standard is clarified,
+behavior in such cases should not be relied on.
+.PP
+The implementation of word-boundary matching is a bit of a kludge,
+and bugs may lurk in combinations of word-boundary matching and anchoring.

src/regex/regex.7

@@ -0,0 +1,235 @@
+.TH REGEX 7 "25 Oct 1995"
+.BY "Henry Spencer"
+.SH NAME
+regex \- POSIX 1003.2 regular expressions
+.SH DESCRIPTION
+Regular expressions (``RE''s),
+as defined in POSIX 1003.2, come in two forms:
+modern REs (roughly those of
+.IR egrep ;
+1003.2 calls these ``extended'' REs)
+and obsolete REs (roughly those of
+.IR ed ;
+1003.2 ``basic'' REs).
+Obsolete REs mostly exist for backward compatibility in some old programs;
+they will be discussed at the end.
+1003.2 leaves some aspects of RE syntax and semantics open;
+`\(dg' marks decisions on these aspects that
+may not be fully portable to other 1003.2 implementations.
+.PP
+A (modern) RE is one\(dg or more non-empty\(dg \fIbranches\fR,
+separated by `|'.
+It matches anything that matches one of the branches.
+.PP
+A branch is one\(dg or more \fIpieces\fR, concatenated.
+It matches a match for the first, followed by a match for the second, etc.
+.PP
+A piece is an \fIatom\fR possibly followed
+by a single\(dg `*', `+', `?', or \fIbound\fR.
+An atom followed by `*' matches a sequence of 0 or more matches of the atom.
+An atom followed by `+' matches a sequence of 1 or more matches of the atom.
+An atom followed by `?' matches a sequence of 0 or 1 matches of the atom.
+.PP
+A \fIbound\fR is `{' followed by an unsigned decimal integer,
+possibly followed by `,'
+possibly followed by another unsigned decimal integer,
+always followed by `}'.
+The integers must lie between 0 and RE_DUP_MAX (255\(dg) inclusive,
+and if there are two of them, the first may not exceed the second.
+An atom followed by a bound containing one integer \fIi\fR
+and no comma matches
+a sequence of exactly \fIi\fR matches of the atom.
+An atom followed by a bound
+containing one integer \fIi\fR and a comma matches
+a sequence of \fIi\fR or more matches of the atom.
+An atom followed by a bound
+containing two integers \fIi\fR and \fIj\fR matches
+a sequence of \fIi\fR through \fIj\fR (inclusive) matches of the atom.
+.PP
+An atom is a regular expression enclosed in `()' (matching a match for the
+regular expression),
+an empty set of `()' (matching the null string)\(dg,
+a \fIbracket expression\fR (see below), `.'
+(matching any single character), `^' (matching the null string at the
+beginning of a line), `$' (matching the null string at the
+end of a line), a `\e' followed by one of the characters
+`^.[$()|*+?{\e'
+(matching that character taken as an ordinary character),
+a `\e' followed by any other character\(dg
+(matching that character taken as an ordinary character,
+as if the `\e' had not been present\(dg),
+or a single character with no other significance (matching that character).
+A `{' followed by a character other than a digit is an ordinary
+character, not the beginning of a bound\(dg.
+It is illegal to end an RE with `\e'.
+.PP
+A \fIbracket expression\fR is a list of characters enclosed in `[]'.
+It normally matches any single character from the list (but see below).
+If the list begins with `^',
+it matches any single character
+(but see below) \fInot\fR from the rest of the list.
+If two characters in the list are separated by `\-', this is shorthand
+for the full \fIrange\fR of characters between those two (inclusive) in the
+collating sequence,
+e.g. `[0\-9]' in ASCII matches any decimal digit.
+It is illegal\(dg for two ranges to share an
+endpoint, e.g. `a\-c\-e'.
+Ranges are very collating-sequence-dependent,
+and portable programs should avoid relying on them.
+.PP
+To include a literal `]' in the list, make it the first character
+(following a possible `^').
+To include a literal `\-', make it the first or last character,
+or the second endpoint of a range.
+To use a literal `\-' as the first endpoint of a range,
+enclose it in `[.' and `.]' to make it a collating element (see below).
+With the exception of these and some combinations using `[' (see next
+paragraphs), all other special characters, including `\e', lose their
+special significance within a bracket expression.
+.PP
+Within a bracket expression, a collating element (a character,
+a multi-character sequence that collates as if it were a single character,
+or a collating-sequence name for either)
+enclosed in `[.' and `.]' stands for the
+sequence of characters of that collating element.
+The sequence is a single element of the bracket expression's list.
+A bracket expression containing a multi-character collating element 
+can thus match more than one character,
+e.g. if the collating sequence includes a `ch' collating element,
+then the RE `[[.ch.]]*c' matches the first five characters
+of `chchcc'.
+.PP
+Within a bracket expression, a collating element enclosed in `[=' and
+`=]' is an equivalence class, standing for the sequences of characters
+of all collating elements equivalent to that one, including itself.
+(If there are no other equivalent collating elements,
+the treatment is as if the enclosing delimiters were `[.' and `.]'.)
+For example, if o and \o'o^' are the members of an equivalence class,
+then `[[=o=]]', `[[=\o'o^'=]]', and `[o\o'o^']' are all synonymous.
+An equivalence class may not\(dg be an endpoint
+of a range.
+.PP
+Within a bracket expression, the name of a \fIcharacter class\fR enclosed
+in `[:' and `:]' stands for the list of all characters belonging to that
+class.
+Standard character class names are:
+.PP
+.RS
+.nf
+.ta 3c 6c 9c
+alnum	digit	punct
+alpha	graph	space
+blank	lower	upper
+cntrl	print	xdigit
+.fi
+.RE
+.PP
+These stand for the character classes defined in
+.IR ctype (3).
+A locale may provide others.
+A character class may not be used as an endpoint of a range.
+.PP
+There are two special cases\(dg of bracket expressions:
+the bracket expressions `[[:<:]]' and `[[:>:]]' match the null string at
+the beginning and end of a word respectively.
+A word is defined as a sequence of
+word characters
+which is neither preceded nor followed by
+word characters.
+A word character is an
+.I alnum
+character (as defined by
+.IR ctype (3))
+or an underscore.
+This is an extension,
+compatible with but not specified by POSIX 1003.2,
+and should be used with
+caution in software intended to be portable to other systems.
+.PP
+In the event that an RE could match more than one substring of a given
+string,
+the RE matches the one starting earliest in the string.
+If the RE could match more than one substring starting at that point,
+it matches the longest.
+Subexpressions also match the longest possible substrings, subject to
+the constraint that the whole match be as long as possible,
+with subexpressions starting earlier in the RE taking priority over
+ones starting later.
+Note that higher-level subexpressions thus take priority over
+their lower-level component subexpressions.
+.PP
+Match lengths are measured in characters, not collating elements.
+A null string is considered longer than no match at all.
+For example,
+`bb*' matches the three middle characters of `abbbc',
+`(wee|week)(knights|nights)' matches all ten characters of `weeknights',
+when `(.*).*' is matched against `abc' the parenthesized subexpression
+matches all three characters, and
+when `(a*)*' is matched against `bc' both the whole RE and the parenthesized
+subexpression match the null string.
+.PP
+If case-independent matching is specified,
+the effect is much as if all case distinctions had vanished from the
+alphabet.
+When an alphabetic that exists in multiple cases appears as an
+ordinary character outside a bracket expression, it is effectively
+transformed into a bracket expression containing both cases,
+e.g. `x' becomes `[xX]'.
+When it appears inside a bracket expression, all case counterparts
+of it are added to the bracket expression, so that (e.g.) `[x]'
+becomes `[xX]' and `[^x]' becomes `[^xX]'.
+.PP
+No particular limit is imposed on the length of REs\(dg.
+Programs intended to be portable should not employ REs longer
+than 256 bytes,
+as an implementation can refuse to accept such REs and remain
+POSIX-compliant.
+.PP
+Obsolete (``basic'') regular expressions differ in several respects.
+`|', `+', and `?' are ordinary characters and there is no equivalent
+for their functionality.
+The delimiters for bounds are `\e{' and `\e}',
+with `{' and `}' by themselves ordinary characters.
+The parentheses for nested subexpressions are `\e(' and `\e)',
+with `(' and `)' by themselves ordinary characters.
+`^' is an ordinary character except at the beginning of the
+RE or\(dg the beginning of a parenthesized subexpression,
+`$' is an ordinary character except at the end of the
+RE or\(dg the end of a parenthesized subexpression,
+and `*' is an ordinary character if it appears at the beginning of the
+RE or the beginning of a parenthesized subexpression
+(after a possible leading `^').
+Finally, there is one new type of atom, a \fIback reference\fR:
+`\e' followed by a non-zero decimal digit \fId\fR
+matches the same sequence of characters
+matched by the \fId\fRth parenthesized subexpression
+(numbering subexpressions by the positions of their opening parentheses,
+left to right),
+so that (e.g.) `\e([bc]\e)\e1' matches `bb' or `cc' but not `bc'.
+.SH SEE ALSO
+regex(3)
+.PP
+POSIX 1003.2, section 2.8 (Regular Expression Notation).
+.SH HISTORY
+Written by Henry Spencer, based on the 1003.2 spec.
+.SH BUGS
+Having two kinds of REs is a botch.
+.PP
+The current 1003.2 spec says that `)' is an ordinary character in
+the absence of an unmatched `(';
+this was an unintentional result of a wording error,
+and change is likely.
+Avoid relying on it.
+.PP
+Back references are a dreadful botch,
+posing major problems for efficient implementations.
+They are also somewhat vaguely defined
+(does
+`a\e(\e(b\e)*\e2\e)*d' match `abbbd'?).
+Avoid using them.
+.PP
+1003.2's specification of case-independent matching is vague.
+The ``one case implies all cases'' definition given above
+is current consensus among implementors as to the right interpretation.
+.PP
+The syntax for word boundaries is incredibly ugly.

src/regex/regex2.h

@@ -0,0 +1,134 @@
+/*
+ * First, the stuff that ends up in the outside-world include file
+ = typedef off_t regoff_t;
+ = typedef struct {
+ = 	int re_magic;
+ = 	size_t re_nsub;		// number of parenthesized subexpressions
+ = 	const char *re_endp;	// end pointer for REG_PEND
+ = 	struct re_guts *re_g;	// none of your business :-)
+ = } regex_t;
+ = typedef struct {
+ = 	regoff_t rm_so;		// start of match
+ = 	regoff_t rm_eo;		// end of match
+ = } regmatch_t;
+ */
+/*
+ * internals of regex_t
+ */
+#define	MAGIC1	((('r'^0200)<<8) | 'e')
+
+/*
+ * The internal representation is a *strip*, a sequence of
+ * operators ending with an endmarker.  (Some terminology etc. is a
+ * historical relic of earlier versions which used multiple strips.)
+ * Certain oddities in the representation are there to permit running
+ * the machinery backwards; in particular, any deviation from sequential
+ * flow must be marked at both its source and its destination.  Some
+ * fine points:
+ *
+ * - OPLUS_ and O_PLUS are *inside* the loop they create.
+ * - OQUEST_ and O_QUEST are *outside* the bypass they create.
+ * - OCH_ and O_CH are *outside* the multi-way branch they create, while
+ *   OOR1 and OOR2 are respectively the end and the beginning of one of
+ *   the branches.  Note that there is an implicit OOR2 following OCH_
+ *   and an implicit OOR1 preceding O_CH.
+ *
+ * In state representations, an operator's bit is on to signify a state
+ * immediately *preceding* "execution" of that operator.
+ */
+typedef long sop;		/* strip operator */
+typedef long sopno;
+#define	OPRMASK	0x7c000000
+#define	OPDMASK	0x03ffffff
+#define	OPSHIFT	(26)
+#define	OP(n)	((n)&OPRMASK)
+#define	OPND(n)	((n)&OPDMASK)
+#define	SOP(op, opnd)	((op)|(opnd))
+/* operators			   meaning	operand			*/
+/*						(back, fwd are offsets)	*/
+#define	OEND	(1<<OPSHIFT)	/* endmarker	-			*/
+#define	OCHAR	(2<<OPSHIFT)	/* character	unsigned char		*/
+#define	OBOL	(3<<OPSHIFT)	/* left anchor	-			*/
+#define	OEOL	(4<<OPSHIFT)	/* right anchor	-			*/
+#define	OANY	(5<<OPSHIFT)	/* .		-			*/
+#define	OANYOF	(6<<OPSHIFT)	/* [...]	set number		*/
+#define	OBACK_	(7<<OPSHIFT)	/* begin \d	paren number		*/
+#define	O_BACK	(8<<OPSHIFT)	/* end \d	paren number		*/
+#define	OPLUS_	(9<<OPSHIFT)	/* + prefix	fwd to suffix		*/
+#define	O_PLUS	(10<<OPSHIFT)	/* + suffix	back to prefix		*/
+#define	OQUEST_	(11<<OPSHIFT)	/* ? prefix	fwd to suffix		*/
+#define	O_QUEST	(12<<OPSHIFT)	/* ? suffix	back to prefix		*/
+#define	OLPAREN	(13<<OPSHIFT)	/* (		fwd to )		*/
+#define	ORPAREN	(14<<OPSHIFT)	/* )		back to (		*/
+#define	OCH_	(15<<OPSHIFT)	/* begin choice	fwd to OOR2		*/
+#define	OOR1	(16<<OPSHIFT)	/* | pt. 1	back to OOR1 or OCH_	*/
+#define	OOR2	(17<<OPSHIFT)	/* | pt. 2	fwd to OOR2 or O_CH	*/
+#define	O_CH	(18<<OPSHIFT)	/* end choice	back to OOR1		*/
+#define	OBOW	(19<<OPSHIFT)	/* begin word	-			*/
+#define	OEOW	(20<<OPSHIFT)	/* end word	-			*/
+
+/*
+ * Structure for [] character-set representation.  Character sets are
+ * done as bit vectors, grouped 8 to a byte vector for compactness.
+ * The individual set therefore has both a pointer to the byte vector
+ * and a mask to pick out the relevant bit of each byte.  A hash code
+ * simplifies testing whether two sets could be identical.
+ *
+ * This will get trickier for multicharacter collating elements.  As
+ * preliminary hooks for dealing with such things, we also carry along
+ * a string of multi-character elements, and decide the size of the
+ * vectors at run time.
+ */
+typedef struct {
+	uch *ptr;		/* -> uch [csetsize] */
+	uch mask;		/* bit within array */
+	uch hash;		/* hash code */
+	size_t smultis;
+	char *multis;		/* -> char[smulti]  ab\0cd\0ef\0\0 */
+} cset;
+/* note that CHadd and CHsub are unsafe, and CHIN doesn't yield 0/1 */
+#define	CHadd(cs, c)	((cs)->ptr[(uch)(c)] |= (cs)->mask, (cs)->hash += (c))
+#define	CHsub(cs, c)	((cs)->ptr[(uch)(c)] &= ~(cs)->mask, (cs)->hash -= (c))
+#define	CHIN(cs, c)	((cs)->ptr[(uch)(c)] & (cs)->mask)
+#define	MCadd(p, cs, cp)	mcadd(p, cs, cp)	/* regcomp() internal fns */
+#define	MCsub(p, cs, cp)	mcsub(p, cs, cp)
+#define	MCin(p, cs, cp)	mcin(p, cs, cp)
+
+/* stuff for character categories */
+typedef unsigned char cat_t;
+
+/*
+ * main compiled-expression structure
+ */
+struct re_guts {
+	int magic;
+#		define	MAGIC2	((('R'^0200)<<8)|'E')
+	sop *strip;		/* malloced area for strip */
+	int csetsize;		/* number of bits in a cset vector */
+	int ncsets;		/* number of csets in use */
+	cset *sets;		/* -> cset [ncsets] */
+	uch *setbits;		/* -> uch[csetsize][ncsets/CHAR_BIT] */
+	int cflags;		/* copy of regcomp() cflags argument */
+	sopno nstates;		/* = number of sops */
+	sopno firststate;	/* the initial OEND (normally 0) */
+	sopno laststate;	/* the final OEND */
+	int iflags;		/* internal flags */
+#		define	USEBOL	01	/* used ^ */
+#		define	USEEOL	02	/* used $ */
+#		define	BAD	04	/* something wrong */
+	int nbol;		/* number of ^ used */
+	int neol;		/* number of $ used */
+	int ncategories;	/* how many character categories */
+	cat_t *categories;	/* ->catspace[-CHAR_MIN] */
+	char *must;		/* match must contain this string */
+	int mlen;		/* length of must */
+	size_t nsub;		/* copy of re_nsub */
+	int backrefs;		/* does it use back references? */
+	sopno nplus;		/* how deep does it nest +s? */
+	/* catspace must be last */
+	cat_t catspace[1];	/* actually [NC] */
+};
+
+/* misc utilities */
+#define	OUT	(CHAR_MAX+1)	/* a non-character value */
+#define	ISWORD(c)	(isalnum(c) || (c) == '_')

src/regex/regexec.c

@@ -0,0 +1,138 @@
+/*
+ * the outer shell of regexec()
+ *
+ * This file includes engine.c *twice*, after muchos fiddling with the
+ * macros that code uses.  This lets the same code operate on two different
+ * representations for state sets.
+ */
+#include <sys/types.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <ctype.h>
+#include <regex.h>
+
+#include "utils.h"
+#include "regex2.h"
+
+static int nope = 0;		/* for use in asserts; shuts lint up */
+
+/* macros for manipulating states, small version */
+#define	states	unsigned
+#define	states1	unsigned	/* for later use in regexec() decision */
+#define	CLEAR(v)	((v) = 0)
+#define	SET0(v, n)	((v) &= ~((unsigned)1 << (n)))
+#define	SET1(v, n)	((v) |= (unsigned)1 << (n))
+#define	ISSET(v, n)	((v) & ((unsigned)1 << (n)))
+#define	ASSIGN(d, s)	((d) = (s))
+#define	EQ(a, b)	((a) == (b))
+#define	STATEVARS	int dummy	/* dummy version */
+#define	STATESETUP(m, n)	/* nothing */
+#define	STATETEARDOWN(m)	/* nothing */
+#define	SETUP(v)	((v) = 0)
+#define	onestate	unsigned
+#define	INIT(o, n)	((o) = (unsigned)1 << (n))
+#define	INC(o)	((o) <<= 1)
+#define	ISSTATEIN(v, o)	((v) & (o))
+/* some abbreviations; note that some of these know variable names! */
+/* do "if I'm here, I can also be there" etc without branches */
+#define	FWD(dst, src, n)	((dst) |= ((unsigned)(src)&(here)) << (n))
+#define	BACK(dst, src, n)	((dst) |= ((unsigned)(src)&(here)) >> (n))
+#define	ISSETBACK(v, n)	((v) & ((unsigned)here >> (n)))
+/* function names */
+#define SNAMES			/* engine.c looks after details */
+
+#include "engine.c"
+
+/* now undo things */
+#undef	states
+#undef	CLEAR
+#undef	SET0
+#undef	SET1
+#undef	ISSET
+#undef	ASSIGN
+#undef	EQ
+#undef	STATEVARS
+#undef	STATESETUP
+#undef	STATETEARDOWN
+#undef	SETUP
+#undef	onestate
+#undef	INIT
+#undef	INC
+#undef	ISSTATEIN
+#undef	FWD
+#undef	BACK
+#undef	ISSETBACK
+#undef	SNAMES
+
+/* macros for manipulating states, large version */
+#define	states	char *
+#define	CLEAR(v)	memset(v, 0, m->g->nstates)
+#define	SET0(v, n)	((v)[n] = 0)
+#define	SET1(v, n)	((v)[n] = 1)
+#define	ISSET(v, n)	((v)[n])
+#define	ASSIGN(d, s)	memcpy(d, s, m->g->nstates)
+#define	EQ(a, b)	(memcmp(a, b, m->g->nstates) == 0)
+#define	STATEVARS	int vn; char *space
+#define	STATESETUP(m, nv)	{ (m)->space = malloc((nv)*(m)->g->nstates); \
+				if ((m)->space == NULL) return(REG_ESPACE); \
+				(m)->vn = 0; }
+#define	STATETEARDOWN(m)	{ free((m)->space); }
+#define	SETUP(v)	((v) = &m->space[m->vn++ * m->g->nstates])
+#define	onestate	int
+#define	INIT(o, n)	((o) = (n))
+#define	INC(o)	((o)++)
+#define	ISSTATEIN(v, o)	((v)[o])
+/* some abbreviations; note that some of these know variable names! */
+/* do "if I'm here, I can also be there" etc without branches */
+#define	FWD(dst, src, n)	((dst)[here+(n)] |= (src)[here])
+#define	BACK(dst, src, n)	((dst)[here-(n)] |= (src)[here])
+#define	ISSETBACK(v, n)	((v)[here - (n)])
+/* function names */
+#define	LNAMES			/* flag */
+
+#include "engine.c"
+
+/*
+ - regexec - interface for matching
+ = extern int regexec(const regex_t *, const char *, size_t, \
+ =					regmatch_t [], int);
+ = #define	REG_NOTBOL	00001
+ = #define	REG_NOTEOL	00002
+ = #define	REG_STARTEND	00004
+ = #define	REG_TRACE	00400	// tracing of execution
+ = #define	REG_LARGE	01000	// force large representation
+ = #define	REG_BACKR	02000	// force use of backref code
+ *
+ * We put this here so we can exploit knowledge of the state representation
+ * when choosing which matcher to call.  Also, by this point the matchers
+ * have been prototyped.
+ */
+int				/* 0 success, REG_NOMATCH failure */
+regexec(preg, string, nmatch, pmatch, eflags)
+const regex_t *preg;
+const char *string;
+size_t nmatch;
+regmatch_t pmatch[];
+int eflags;
+{
+	register struct re_guts *g = preg->re_g;
+#ifdef REDEBUG
+#	define	GOODFLAGS(f)	(f)
+#else
+#	define	GOODFLAGS(f)	((f)&(REG_NOTBOL|REG_NOTEOL|REG_STARTEND))
+#endif
+
+	if (preg->re_magic != MAGIC1 || g->magic != MAGIC2)
+		return(REG_BADPAT);
+	assert(!(g->iflags&BAD));
+	if (g->iflags&BAD)		/* backstop for no-debug case */
+		return(REG_BADPAT);
+	eflags = GOODFLAGS(eflags);
+
+	if (g->nstates <= CHAR_BIT*sizeof(states1) && !(eflags&REG_LARGE))
+		return(smatcher(g, (char *)string, nmatch, pmatch, eflags));
+	else
+		return(lmatcher(g, (char *)string, nmatch, pmatch, eflags));
+}

src/regex/regfree.c

@@ -0,0 +1,37 @@
+#include <sys/types.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <regex.h>
+
+#include "utils.h"
+#include "regex2.h"
+
+/*
+ - regfree - free everything
+ = extern void regfree(regex_t *);
+ */
+void
+regfree(preg)
+regex_t *preg;
+{
+	register struct re_guts *g;
+
+	if (preg->re_magic != MAGIC1)	/* oops */
+		return;			/* nice to complain, but hard */
+
+	g = preg->re_g;
+	if (g == NULL || g->magic != MAGIC2)	/* oops again */
+		return;
+	preg->re_magic = 0;		/* mark it invalid */
+	g->magic = 0;			/* mark it invalid */
+
+	if (g->strip != NULL)
+		free((char *)g->strip);
+	if (g->sets != NULL)
+		free((char *)g->sets);
+	if (g->setbits != NULL)
+		free((char *)g->setbits);
+	if (g->must != NULL)
+		free(g->must);
+	free((char *)g);
+}

src/regex/split.c

@@ -0,0 +1,316 @@
+#include <stdio.h>
+#include <string.h>
+
+/*
+ - split - divide a string into fields, like awk split()
+ = int split(char *string, char *fields[], int nfields, char *sep);
+ */
+int				/* number of fields, including overflow */
+split(string, fields, nfields, sep)
+char *string;
+char *fields[];			/* list is not NULL-terminated */
+int nfields;			/* number of entries available in fields[] */
+char *sep;			/* "" white, "c" single char, "ab" [ab]+ */
+{
+	register char *p = string;
+	register char c;			/* latest character */
+	register char sepc = sep[0];
+	register char sepc2;
+	register int fn;
+	register char **fp = fields;
+	register char *sepp;
+	register int trimtrail;
+
+	/* white space */
+	if (sepc == '\0') {
+		while ((c = *p++) == ' ' || c == '\t')
+			continue;
+		p--;
+		trimtrail = 1;
+		sep = " \t";	/* note, code below knows this is 2 long */
+		sepc = ' ';
+	} else
+		trimtrail = 0;
+	sepc2 = sep[1];		/* now we can safely pick this up */
+
+	/* catch empties */
+	if (*p == '\0')
+		return(0);
+
+	/* single separator */
+	if (sepc2 == '\0') {
+		fn = nfields;
+		for (;;) {
+			*fp++ = p;
+			fn--;
+			if (fn == 0)
+				break;
+			while ((c = *p++) != sepc)
+				if (c == '\0')
+					return(nfields - fn);
+			*(p-1) = '\0';
+		}
+		/* we have overflowed the fields vector -- just count them */
+		fn = nfields;
+		for (;;) {
+			while ((c = *p++) != sepc)
+				if (c == '\0')
+					return(fn);
+			fn++;
+		}
+		/* not reached */
+	}
+
+	/* two separators */
+	if (sep[2] == '\0') {
+		fn = nfields;
+		for (;;) {
+			*fp++ = p;
+			fn--;
+			while ((c = *p++) != sepc && c != sepc2)
+				if (c == '\0') {
+					if (trimtrail && **(fp-1) == '\0')
+						fn++;
+					return(nfields - fn);
+				}
+			if (fn == 0)
+				break;
+			*(p-1) = '\0';
+			while ((c = *p++) == sepc || c == sepc2)
+				continue;
+			p--;
+		}
+		/* we have overflowed the fields vector -- just count them */
+		fn = nfields;
+		while (c != '\0') {
+			while ((c = *p++) == sepc || c == sepc2)
+				continue;
+			p--;
+			fn++;
+			while ((c = *p++) != '\0' && c != sepc && c != sepc2)
+				continue;
+		}
+		/* might have to trim trailing white space */
+		if (trimtrail) {
+			p--;
+			while ((c = *--p) == sepc || c == sepc2)
+				continue;
+			p++;
+			if (*p != '\0') {
+				if (fn == nfields+1)
+					*p = '\0';
+				fn--;
+			}
+		}
+		return(fn);
+	}
+
+	/* n separators */
+	fn = 0;
+	for (;;) {
+		if (fn < nfields)
+			*fp++ = p;
+		fn++;
+		for (;;) {
+			c = *p++;
+			if (c == '\0')
+				return(fn);
+			sepp = sep;
+			while ((sepc = *sepp++) != '\0' && sepc != c)
+				continue;
+			if (sepc != '\0')	/* it was a separator */
+				break;
+		}
+		if (fn < nfields)
+			*(p-1) = '\0';
+		for (;;) {
+			c = *p++;
+			sepp = sep;
+			while ((sepc = *sepp++) != '\0' && sepc != c)
+				continue;
+			if (sepc == '\0')	/* it wasn't a separator */
+				break;
+		}
+		p--;
+	}
+
+	/* not reached */
+}
+
+#ifdef TEST_SPLIT
+
+
+/*
+ * test program
+ * pgm		runs regression
+ * pgm sep	splits stdin lines by sep
+ * pgm str sep	splits str by sep
+ * pgm str sep n	splits str by sep n times
+ */
+int
+main(argc, argv)
+int argc;
+char *argv[];
+{
+	char buf[512];
+	register int n;
+#	define	MNF	10
+	char *fields[MNF];
+
+	if (argc > 4)
+		for (n = atoi(argv[3]); n > 0; n--) {
+			(void) strcpy(buf, argv[1]);
+		}
+	else if (argc > 3)
+		for (n = atoi(argv[3]); n > 0; n--) {
+			(void) strcpy(buf, argv[1]);
+			(void) split(buf, fields, MNF, argv[2]);
+		}
+	else if (argc > 2)
+		dosplit(argv[1], argv[2]);
+	else if (argc > 1)
+		while (fgets(buf, sizeof(buf), stdin) != NULL) {
+			buf[strlen(buf)-1] = '\0';	/* stomp newline */
+			dosplit(buf, argv[1]);
+		}
+	else
+		regress();
+
+	exit(0);
+}
+
+dosplit(string, seps)
+char *string;
+char *seps;
+{
+#	define	NF	5
+	char *fields[NF];
+	register int nf;
+
+	nf = split(string, fields, NF, seps);
+	print(nf, NF, fields);
+}
+
+print(nf, nfp, fields)
+int nf;
+int nfp;
+char *fields[];
+{
+	register int fn;
+	register int bound;
+
+	bound = (nf > nfp) ? nfp : nf;
+	printf("%d:\t", nf);
+	for (fn = 0; fn < bound; fn++)
+		printf("\"%s\"%s", fields[fn], (fn+1 < nf) ? ", " : "\n");
+}
+
+#define	RNF	5		/* some table entries know this */
+struct {
+	char *str;
+	char *seps;
+	int nf;
+	char *fi[RNF];
+} tests[] = {
+	"",		" ",	0,	{ "" },
+	" ",		" ",	2,	{ "", "" },
+	"x",		" ",	1,	{ "x" },
+	"xy",		" ",	1,	{ "xy" },
+	"x y",		" ",	2,	{ "x", "y" },
+	"abc def  g ",	" ",	5,	{ "abc", "def", "", "g", "" },
+	"  a bcd",	" ",	4,	{ "", "", "a", "bcd" },
+	"a b c d e f",	" ",	6,	{ "a", "b", "c", "d", "e f" },
+	" a b c d ",	" ",	6,	{ "", "a", "b", "c", "d " },
+
+	"",		" _",	0,	{ "" },
+	" ",		" _",	2,	{ "", "" },
+	"x",		" _",	1,	{ "x" },
+	"x y",		" _",	2,	{ "x", "y" },
+	"ab _ cd",	" _",	2,	{ "ab", "cd" },
+	" a_b  c ",	" _",	5,	{ "", "a", "b", "c", "" },
+	"a b c_d e f",	" _",	6,	{ "a", "b", "c", "d", "e f" },
+	" a b c d ",	" _",	6,	{ "", "a", "b", "c", "d " },
+
+	"",		" _~",	0,	{ "" },
+	" ",		" _~",	2,	{ "", "" },
+	"x",		" _~",	1,	{ "x" },
+	"x y",		" _~",	2,	{ "x", "y" },
+	"ab _~ cd",	" _~",	2,	{ "ab", "cd" },
+	" a_b  c~",	" _~",	5,	{ "", "a", "b", "c", "" },
+	"a b_c d~e f",	" _~",	6,	{ "a", "b", "c", "d", "e f" },
+	"~a b c d ",	" _~",	6,	{ "", "a", "b", "c", "d " },
+
+	"",		" _~-",	0,	{ "" },
+	" ",		" _~-",	2,	{ "", "" },
+	"x",		" _~-",	1,	{ "x" },
+	"x y",		" _~-",	2,	{ "x", "y" },
+	"ab _~- cd",	" _~-",	2,	{ "ab", "cd" },
+	" a_b  c~",	" _~-",	5,	{ "", "a", "b", "c", "" },
+	"a b_c-d~e f",	" _~-",	6,	{ "a", "b", "c", "d", "e f" },
+	"~a-b c d ",	" _~-",	6,	{ "", "a", "b", "c", "d " },
+
+	"",		"  ",	0,	{ "" },
+	" ",		"  ",	2,	{ "", "" },
+	"x",		"  ",	1,	{ "x" },
+	"xy",		"  ",	1,	{ "xy" },
+	"x y",		"  ",	2,	{ "x", "y" },
+	"abc def  g ",	"  ",	4,	{ "abc", "def", "g", "" },
+	"  a bcd",	"  ",	3,	{ "", "a", "bcd" },
+	"a b c d e f",	"  ",	6,	{ "a", "b", "c", "d", "e f" },
+	" a b c d ",	"  ",	6,	{ "", "a", "b", "c", "d " },
+
+	"",		"",	0,	{ "" },
+	" ",		"",	0,	{ "" },
+	"x",		"",	1,	{ "x" },
+	"xy",		"",	1,	{ "xy" },
+	"x y",		"",	2,	{ "x", "y" },
+	"abc def  g ",	"",	3,	{ "abc", "def", "g" },
+	"\t a bcd",	"",	2,	{ "a", "bcd" },
+	"  a \tb\t c ",	"",	3,	{ "a", "b", "c" },
+	"a b c d e ",	"",	5,	{ "a", "b", "c", "d", "e" },
+	"a b\tc d e f",	"",	6,	{ "a", "b", "c", "d", "e f" },
+	" a b c d e f ",	"",	6,	{ "a", "b", "c", "d", "e f " },
+
+	NULL,		NULL,	0,	{ NULL },
+};
+
+regress()
+{
+	char buf[512];
+	register int n;
+	char *fields[RNF+1];
+	register int nf;
+	register int i;
+	register int printit;
+	register char *f;
+
+	for (n = 0; tests[n].str != NULL; n++) {
+		(void) strcpy(buf, tests[n].str);
+		fields[RNF] = NULL;
+		nf = split(buf, fields, RNF, tests[n].seps);
+		printit = 0;
+		if (nf != tests[n].nf) {
+			printf("split `%s' by `%s' gave %d fields, not %d\n",
+				tests[n].str, tests[n].seps, nf, tests[n].nf);
+			printit = 1;
+		} else if (fields[RNF] != NULL) {
+			printf("split() went beyond array end\n");
+			printit = 1;
+		} else {
+			for (i = 0; i < nf && i < RNF; i++) {
+				f = fields[i];
+				if (f == NULL)
+					f = "(NULL)";
+				if (strcmp(f, tests[n].fi[i]) != 0) {
+					printf("split `%s' by `%s', field %d is `%s', not `%s'\n",
+						tests[n].str, tests[n].seps,
+						i, fields[i], tests[n].fi[i]);
+					printit = 1;
+				}
+			}
+		}
+		if (printit)
+			print(nf, RNF, fields);
+	}
+}
+#endif

src/regex/tests

@@ -0,0 +1,477 @@
+# regular expression test set
+# Lines are at least three fields, separated by one or more tabs.  "" stands
+# for an empty field.  First field is an RE.  Second field is flags.  If
+# C flag given, regcomp() is expected to fail, and the third field is the
+# error name (minus the leading REG_).
+#
+# Otherwise it is expected to succeed, and the third field is the string to
+# try matching it against.  If there is no fourth field, the match is
+# expected to fail.  If there is a fourth field, it is the substring that
+# the RE is expected to match.  If there is a fifth field, it is a comma-
+# separated list of what the subexpressions should match, with - indicating
+# no match for that one.  In both the fourth and fifth fields, a (sub)field
+# starting with @ indicates that the (sub)expression is expected to match
+# a null string followed by the stuff after the @; this provides a way to
+# test where null strings match.  The character `N' in REs and strings
+# is newline, `S' is space, `T' is tab, `Z' is NUL.
+#
+# The full list of flags:
+#	-	placeholder, does nothing
+#	b	RE is a BRE, not an ERE
+#	&	try it as both an ERE and a BRE
+#	C	regcomp() error expected, third field is error name
+#	i	REG_ICASE
+#	m	("mundane") REG_NOSPEC
+#	s	REG_NOSUB (not really testable)
+#	n	REG_NEWLINE
+#	^	REG_NOTBOL
+#	$	REG_NOTEOL
+#	#	REG_STARTEND (see below)
+#	p	REG_PEND
+#
+# For REG_STARTEND, the start/end offsets are those of the substring
+# enclosed in ().
+
+# basics
+a		&	a	a
+abc		&	abc	abc
+abc|de		-	abc	abc
+a|b|c		-	abc	a
+
+# parentheses and perversions thereof
+a(b)c		-	abc	abc
+a\(b\)c		b	abc	abc
+a(		C	EPAREN
+a(		b	a(	a(
+a\(		-	a(	a(
+a\(		bC	EPAREN
+a\(b		bC	EPAREN
+a(b		C	EPAREN
+a(b		b	a(b	a(b
+# gag me with a right parenthesis -- 1003.2 goofed here (my fault, partly)
+a)		-	a)	a)
+)		-	)	)
+# end gagging (in a just world, those *should* give EPAREN)
+a)		b	a)	a)
+a\)		bC	EPAREN
+\)		bC	EPAREN
+a()b		-	ab	ab
+a\(\)b		b	ab	ab
+
+# anchoring and REG_NEWLINE
+^abc$		&	abc	abc
+a^b		-	a^b
+a^b		b	a^b	a^b
+a$b		-	a$b
+a$b		b	a$b	a$b
+^		&	abc	@abc
+$		&	abc	@
+^$		&	""	@
+$^		-	""	@
+\($\)\(^\)	b	""	@
+# stop retching, those are legitimate (although disgusting)
+^^		-	""	@
+$$		-	""	@
+b$		&	abNc
+b$		&n	abNc	b
+^b$		&	aNbNc
+^b$		&n	aNbNc	b
+^$		&n	aNNb	@Nb
+^$		n	abc
+^$		n	abcN	@
+$^		n	aNNb	@Nb
+\($\)\(^\)	bn	aNNb	@Nb
+^^		n^	aNNb	@Nb
+$$		n	aNNb	@NN
+^a		^	a
+a$		$	a
+^a		^n	aNb
+^b		^n	aNb	b
+a$		$n	bNa
+b$		$n	bNa	b
+a*(^b$)c*	-	b	b
+a*\(^b$\)c*	b	b	b
+
+# certain syntax errors and non-errors
+|		C	EMPTY
+|		b	|	|
+*		C	BADRPT
+*		b	*	*
++		C	BADRPT
+?		C	BADRPT
+""		&C	EMPTY
+()		-	abc	@abc
+\(\)		b	abc	@abc
+a||b		C	EMPTY
+|ab		C	EMPTY
+ab|		C	EMPTY
+(|a)b		C	EMPTY
+(a|)b		C	EMPTY
+(*a)		C	BADRPT
+(+a)		C	BADRPT
+(?a)		C	BADRPT
+({1}a)		C	BADRPT
+\(\{1\}a\)	bC	BADRPT
+(a|*b)		C	BADRPT
+(a|+b)		C	BADRPT
+(a|?b)		C	BADRPT
+(a|{1}b)	C	BADRPT
+^*		C	BADRPT
+^*		b	*	*
+^+		C	BADRPT
+^?		C	BADRPT
+^{1}		C	BADRPT
+^\{1\}		bC	BADRPT
+
+# metacharacters, backslashes
+a.c		&	abc	abc
+a[bc]d		&	abd	abd
+a\*c		&	a*c	a*c
+a\\b		&	a\b	a\b
+a\\\*b		&	a\*b	a\*b
+a\bc		&	abc	abc
+a\		&C	EESCAPE
+a\\bc		&	a\bc	a\bc
+\{		bC	BADRPT
+a\[b		&	a[b	a[b
+a[b		&C	EBRACK
+# trailing $ is a peculiar special case for the BRE code
+a$		&	a	a
+a$		&	a$
+a\$		&	a
+a\$		&	a$	a$
+a\\$		&	a
+a\\$		&	a$
+a\\$		&	a\$
+a\\$		&	a\	a\
+
+# back references, ugh
+a\(b\)\2c	bC	ESUBREG
+a\(b\1\)c	bC	ESUBREG
+a\(b*\)c\1d	b	abbcbbd	abbcbbd	bb
+a\(b*\)c\1d	b	abbcbd
+a\(b*\)c\1d	b	abbcbbbd
+^\(.\)\1	b	abc
+a\([bc]\)\1d	b	abcdabbd	abbd	b
+a\(\([bc]\)\2\)*d	b	abbccd	abbccd
+a\(\([bc]\)\2\)*d	b	abbcbd
+# actually, this next one probably ought to fail, but the spec is unclear
+a\(\(b\)*\2\)*d		b	abbbd	abbbd
+# here is a case that no NFA implementation does right
+\(ab*\)[ab]*\1	b	ababaaa	ababaaa	a
+# check out normal matching in the presence of back refs
+\(a\)\1bcd	b	aabcd	aabcd
+\(a\)\1bc*d	b	aabcd	aabcd
+\(a\)\1bc*d	b	aabd	aabd
+\(a\)\1bc*d	b	aabcccd	aabcccd
+\(a\)\1bc*[ce]d	b	aabcccd	aabcccd
+^\(a\)\1b\(c\)*cd$	b	aabcccd	aabcccd
+
+# ordinary repetitions
+ab*c		&	abc	abc
+ab+c		-	abc	abc
+ab?c		-	abc	abc
+a\(*\)b		b	a*b	a*b
+a\(**\)b	b	ab	ab
+a\(***\)b	bC	BADRPT
+*a		b	*a	*a
+**a		b	a	a
+***a		bC	BADRPT
+
+# the dreaded bounded repetitions
+{		&	{	{
+{abc		&	{abc	{abc
+{1		C	BADRPT
+{1}		C	BADRPT
+a{b		&	a{b	a{b
+a{1}b		-	ab	ab
+a\{1\}b		b	ab	ab
+a{1,}b		-	ab	ab
+a\{1,\}b	b	ab	ab
+a{1,2}b		-	aab	aab
+a\{1,2\}b	b	aab	aab
+a{1		C	EBRACE
+a\{1		bC	EBRACE
+a{1a		C	EBRACE
+a\{1a		bC	EBRACE
+a{1a}		C	BADBR
+a\{1a\}		bC	BADBR
+a{,2}		-	a{,2}	a{,2}
+a\{,2\}		bC	BADBR
+a{,}		-	a{,}	a{,}
+a\{,\}		bC	BADBR
+a{1,x}		C	BADBR
+a\{1,x\}	bC	BADBR
+a{1,x		C	EBRACE
+a\{1,x		bC	EBRACE
+a{300}		C	BADBR
+a\{300\}	bC	BADBR
+a{1,0}		C	BADBR
+a\{1,0\}	bC	BADBR
+ab{0,0}c	-	abcac	ac
+ab\{0,0\}c	b	abcac	ac
+ab{0,1}c	-	abcac	abc
+ab\{0,1\}c	b	abcac	abc
+ab{0,3}c	-	abbcac	abbc
+ab\{0,3\}c	b	abbcac	abbc
+ab{1,1}c	-	acabc	abc
+ab\{1,1\}c	b	acabc	abc
+ab{1,3}c	-	acabc	abc
+ab\{1,3\}c	b	acabc	abc
+ab{2,2}c	-	abcabbc	abbc
+ab\{2,2\}c	b	abcabbc	abbc
+ab{2,4}c	-	abcabbc	abbc
+ab\{2,4\}c	b	abcabbc	abbc
+((a{1,10}){1,10}){1,10}	-	a	a	a,a
+
+# multiple repetitions
+a**		&C	BADRPT
+a++		C	BADRPT
+a??		C	BADRPT
+a*+		C	BADRPT
+a*?		C	BADRPT
+a+*		C	BADRPT
+a+?		C	BADRPT
+a?*		C	BADRPT
+a?+		C	BADRPT
+a{1}{1}		C	BADRPT
+a*{1}		C	BADRPT
+a+{1}		C	BADRPT
+a?{1}		C	BADRPT
+a{1}*		C	BADRPT
+a{1}+		C	BADRPT
+a{1}?		C	BADRPT
+a*{b}		-	a{b}	a{b}
+a\{1\}\{1\}	bC	BADRPT
+a*\{1\}		bC	BADRPT
+a\{1\}*		bC	BADRPT
+
+# brackets, and numerous perversions thereof
+a[b]c		&	abc	abc
+a[ab]c		&	abc	abc
+a[^ab]c		&	adc	adc
+a[]b]c		&	a]c	a]c
+a[[b]c		&	a[c	a[c
+a[-b]c		&	a-c	a-c
+a[^]b]c		&	adc	adc
+a[^-b]c		&	adc	adc
+a[b-]c		&	a-c	a-c
+a[b		&C	EBRACK
+a[]		&C	EBRACK
+a[1-3]c		&	a2c	a2c
+a[3-1]c		&C	ERANGE
+a[1-3-5]c	&C	ERANGE
+a[[.-.]--]c	&	a-c	a-c
+a[1-		&C	ERANGE
+a[[.		&C	EBRACK
+a[[.x		&C	EBRACK
+a[[.x.		&C	EBRACK
+a[[.x.]		&C	EBRACK
+a[[.x.]]	&	ax	ax
+a[[.x,.]]	&C	ECOLLATE
+a[[.one.]]b	&	a1b	a1b
+a[[.notdef.]]b	&C	ECOLLATE
+a[[.].]]b	&	a]b	a]b
+a[[:alpha:]]c	&	abc	abc
+a[[:notdef:]]c	&C	ECTYPE
+a[[:		&C	EBRACK
+a[[:alpha	&C	EBRACK
+a[[:alpha:]	&C	EBRACK
+a[[:alpha,:]	&C	ECTYPE
+a[[:]:]]b	&C	ECTYPE
+a[[:-:]]b	&C	ECTYPE
+a[[:alph:]]	&C	ECTYPE
+a[[:alphabet:]]	&C	ECTYPE
+[[:alnum:]]+	-	-%@a0X-	a0X
+[[:alpha:]]+	-	-%@aX0-	aX
+[[:blank:]]+	-	aSSTb	SST
+[[:cntrl:]]+	-	aNTb	NT
+[[:digit:]]+	-	a019b	019
+[[:graph:]]+	-	Sa%bS	a%b
+[[:lower:]]+	-	AabC	ab
+[[:print:]]+	-	NaSbN	aSb
+[[:punct:]]+	-	S%-&T	%-&
+[[:space:]]+	-	aSNTb	SNT
+[[:upper:]]+	-	aBCd	BC
+[[:xdigit:]]+	-	p0f3Cq	0f3C
+a[[=b=]]c	&	abc	abc
+a[[=		&C	EBRACK
+a[[=b		&C	EBRACK
+a[[=b=		&C	EBRACK
+a[[=b=]		&C	EBRACK
+a[[=b,=]]	&C	ECOLLATE
+a[[=one=]]b	&	a1b	a1b
+
+# complexities
+a(((b)))c	-	abc	abc
+a(b|(c))d	-	abd	abd
+a(b*|c)d	-	abbd	abbd
+# just gotta have one DFA-buster, of course
+a[ab]{20}	-	aaaaabaaaabaaaabaaaab	aaaaabaaaabaaaabaaaab
+# and an inline expansion in case somebody gets tricky
+a[ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab]	-	aaaaabaaaabaaaabaaaab	aaaaabaaaabaaaabaaaab
+# and in case somebody just slips in an NFA...
+a[ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab](wee|week)(knights|night)	-	aaaaabaaaabaaaabaaaabweeknights	aaaaabaaaabaaaabaaaabweeknights
+# fish for anomalies as the number of states passes 32
+12345678901234567890123456789	-	a12345678901234567890123456789b	12345678901234567890123456789
+123456789012345678901234567890	-	a123456789012345678901234567890b	123456789012345678901234567890
+1234567890123456789012345678901	-	a1234567890123456789012345678901b	1234567890123456789012345678901
+12345678901234567890123456789012	-	a12345678901234567890123456789012b	12345678901234567890123456789012
+123456789012345678901234567890123	-	a123456789012345678901234567890123b	123456789012345678901234567890123
+# and one really big one, beyond any plausible word width
+1234567890123456789012345678901234567890123456789012345678901234567890	-	a1234567890123456789012345678901234567890123456789012345678901234567890b	1234567890123456789012345678901234567890123456789012345678901234567890
+# fish for problems as brackets go past 8
+[ab][cd][ef][gh][ij][kl][mn]	-	xacegikmoq	acegikm
+[ab][cd][ef][gh][ij][kl][mn][op]	-	xacegikmoq	acegikmo
+[ab][cd][ef][gh][ij][kl][mn][op][qr]	-	xacegikmoqy	acegikmoq
+[ab][cd][ef][gh][ij][kl][mn][op][q]	-	xacegikmoqy	acegikmoq
+
+# subtleties of matching
+abc		&	xabcy	abc
+a\(b\)?c\1d	b	acd
+aBc		i	Abc	Abc
+a[Bc]*d		i	abBCcd	abBCcd
+0[[:upper:]]1	&i	0a1	0a1
+0[[:lower:]]1	&i	0A1	0A1
+a[^b]c		&i	abc
+a[^b]c		&i	aBc
+a[^b]c		&i	adc	adc
+[a]b[c]		-	abc	abc
+[a]b[a]		-	aba	aba
+[abc]b[abc]	-	abc	abc
+[abc]b[abd]	-	abd	abd
+a(b?c)+d	-	accd	accd
+(wee|week)(knights|night)	-	weeknights	weeknights
+(we|wee|week|frob)(knights|night|day)	-	weeknights	weeknights
+a[bc]d		-	xyzaaabcaababdacd	abd
+a[ab]c		-	aaabc	abc
+abc		s	abc	abc
+a*		&	b	@b
+
+# Let's have some fun -- try to match a C comment.
+# first the obvious, which looks okay at first glance...
+/\*.*\*/	-	/*x*/	/*x*/
+# but...
+/\*.*\*/	-	/*x*/y/*z*/	/*x*/y/*z*/
+# okay, we must not match */ inside; try to do that...
+/\*([^*]|\*[^/])*\*/	-	/*x*/	/*x*/
+/\*([^*]|\*[^/])*\*/	-	/*x*/y/*z*/	/*x*/
+# but...
+/\*([^*]|\*[^/])*\*/	-	/*x**/y/*z*/	/*x**/y/*z*/
+# and a still fancier version, which does it right (I think)...
+/\*([^*]|\*+[^*/])*\*+/	-	/*x*/	/*x*/
+/\*([^*]|\*+[^*/])*\*+/	-	/*x*/y/*z*/	/*x*/
+/\*([^*]|\*+[^*/])*\*+/	-	/*x**/y/*z*/	/*x**/
+/\*([^*]|\*+[^*/])*\*+/	-	/*x****/y/*z*/	/*x****/
+/\*([^*]|\*+[^*/])*\*+/	-	/*x**x*/y/*z*/	/*x**x*/
+/\*([^*]|\*+[^*/])*\*+/	-	/*x***x/y/*z*/	/*x***x/y/*z*/
+
+# subexpressions
+.*		-	abc	abc	-
+a(b)(c)d	-	abcd	abcd	b,c
+a(((b)))c	-	abc	abc	b,b,b
+a(b|(c))d	-	abd	abd	b,-
+a(b*|c|e)d	-	abbd	abbd	bb
+a(b*|c|e)d	-	acd	acd	c
+a(b*|c|e)d	-	ad	ad	@d
+a(b?)c		-	abc	abc	b
+a(b?)c		-	ac	ac	@c
+a(b+)c		-	abc	abc	b
+a(b+)c		-	abbbc	abbbc	bbb
+a(b*)c		-	ac	ac	@c
+(a|ab)(bc([de]+)f|cde)	-	abcdef	abcdef	a,bcdef,de
+# the regression tester only asks for 9 subexpressions
+a(b)(c)(d)(e)(f)(g)(h)(i)(j)k	-	abcdefghijk	abcdefghijk	b,c,d,e,f,g,h,i,j
+a(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)l	-	abcdefghijkl	abcdefghijkl	b,c,d,e,f,g,h,i,j,k
+a([bc]?)c	-	abc	abc	b
+a([bc]?)c	-	ac	ac	@c
+a([bc]+)c	-	abc	abc	b
+a([bc]+)c	-	abcc	abcc	bc
+a([bc]+)bc	-	abcbc	abcbc	bc
+a(bb+|b)b	-	abb	abb	b
+a(bbb+|bb+|b)b	-	abb	abb	b
+a(bbb+|bb+|b)b	-	abbb	abbb	bb
+a(bbb+|bb+|b)bb	-	abbb	abbb	b
+(.*).*		-	abcdef	abcdef	abcdef
+(a*)*		-	bc	@b	@b
+
+# do we get the right subexpression when it is used more than once?
+a(b|c)*d	-	ad	ad	-
+a(b|c)*d	-	abcd	abcd	c
+a(b|c)+d	-	abd	abd	b
+a(b|c)+d	-	abcd	abcd	c
+a(b|c?)+d	-	ad	ad	@d
+a(b|c?)+d	-	abcd	abcd	@d
+a(b|c){0,0}d	-	ad	ad	-
+a(b|c){0,1}d	-	ad	ad	-
+a(b|c){0,1}d	-	abd	abd	b
+a(b|c){0,2}d	-	ad	ad	-
+a(b|c){0,2}d	-	abcd	abcd	c
+a(b|c){0,}d	-	ad	ad	-
+a(b|c){0,}d	-	abcd	abcd	c
+a(b|c){1,1}d	-	abd	abd	b
+a(b|c){1,1}d	-	acd	acd	c
+a(b|c){1,2}d	-	abd	abd	b
+a(b|c){1,2}d	-	abcd	abcd	c
+a(b|c){1,}d	-	abd	abd	b
+a(b|c){1,}d	-	abcd	abcd	c
+a(b|c){2,2}d	-	acbd	acbd	b
+a(b|c){2,2}d	-	abcd	abcd	c
+a(b|c){2,4}d	-	abcd	abcd	c
+a(b|c){2,4}d	-	abcbd	abcbd	b
+a(b|c){2,4}d	-	abcbcd	abcbcd	c
+a(b|c){2,}d	-	abcd	abcd	c
+a(b|c){2,}d	-	abcbd	abcbd	b
+a(b+|((c)*))+d	-	abd	abd	@d,@d,-
+a(b+|((c)*))+d	-	abcd	abcd	@d,@d,-
+
+# check out the STARTEND option
+[abc]		&#	a(b)c	b
+[abc]		&#	a(d)c
+[abc]		&#	a(bc)d	b
+[abc]		&#	a(dc)d	c
+.		&#	a()c
+b.*c		&#	b(bc)c	bc
+b.*		&#	b(bc)c	bc
+.*c		&#	b(bc)c	bc
+
+# plain strings, with the NOSPEC flag
+abc		m	abc	abc
+abc		m	xabcy	abc
+abc		m	xyz
+a*b		m	aba*b	a*b
+a*b		m	ab
+""		mC	EMPTY
+
+# cases involving NULs
+aZb		&	a	a
+aZb		&p	a
+aZb		&p#	(aZb)	aZb
+aZ*b		&p#	(ab)	ab
+a.b		&#	(aZb)	aZb
+a.*		&#	(aZb)c	aZb
+
+# word boundaries (ick)
+[[:<:]]a	&	a	a
+[[:<:]]a	&	ba
+[[:<:]]a	&	-a	a
+a[[:>:]]	&	a	a
+a[[:>:]]	&	ab
+a[[:>:]]	&	a-	a
+[[:<:]]a.c[[:>:]]	&	axcd-dayc-dazce-abc	abc
+[[:<:]]a.c[[:>:]]	&	axcd-dayc-dazce-abc-q	abc
+[[:<:]]a.c[[:>:]]	&	axc-dayc-dazce-abc	axc
+[[:<:]]b.c[[:>:]]	&	a_bxc-byc_d-bzc-q	bzc
+[[:<:]].x..[[:>:]]	&	y_xa_-_xb_y-_xc_-axdc	_xc_
+[[:<:]]a_b[[:>:]]	&	x_a_b
+
+# past problems, and suspected problems
+(A[1])|(A[2])|(A[3])|(A[4])|(A[5])|(A[6])|(A[7])|(A[8])|(A[9])|(A[A])	-	A1	A1
+abcdefghijklmnop	i	abcdefghijklmnop	abcdefghijklmnop
+abcdefghijklmnopqrstuv	i	abcdefghijklmnopqrstuv	abcdefghijklmnopqrstuv
+(ALAK)|(ALT[AB])|(CC[123]1)|(CM[123]1)|(GAMC)|(LC[23][EO ])|(SEM[1234])|(SL[ES][12])|(SLWW)|(SLF )|(SLDT)|(VWH[12])|(WH[34][EW])|(WP1[ESN])	-	CC11	CC11
+CC[13]1|a{21}[23][EO][123][Es][12]a{15}aa[34][EW]aaaaaaa[X]a	-	CC11	CC11
+Char \([a-z0-9_]*\)\[.*	b	Char xyz[k	Char xyz[k	xyz
+a?b	-	ab	ab
+-\{0,1\}[0-9]*$	b	-5	-5
+a*a*a*a*a*a*a*	&	aaaaaa	aaaaaa

src/regex/utils.h

@@ -0,0 +1,22 @@
+/* utility definitions */
+#ifdef _POSIX2_RE_DUP_MAX
+#define	DUPMAX	_POSIX2_RE_DUP_MAX
+#else
+#define	DUPMAX	255
+#endif
+#define	INFINITY	(DUPMAX + 1)
+#define	NC		(CHAR_MAX - CHAR_MIN + 1)
+typedef unsigned char uch;
+
+/* switch off assertions (if not already off) if no REDEBUG */
+#ifndef REDEBUG
+#ifndef NDEBUG
+#define	NDEBUG	/* no assertions please */
+#endif
+#endif
+#include <assert.h>
+
+/* for old systems with bcopy() but no memmove() */
+#ifdef USEBCOPY
+#define	memmove(d, s, c)	bcopy(s, d, c)
+#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