This commit was manufactured by cvs2svn to create tag

'wxPython-0_5_3'.

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/tags/wxPython-0_5_3@1524 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

contrib/src/xrc/xh_html.cpp

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

docs/latex/wx/htcell.tex

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

docs/latex/wx/htcolor.tex

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

docs/latex/wx/htcontnr.tex

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

docs/latex/wx/htdcrend.tex

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

docs/latex/wx/hteasypr.tex

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

docs/latex/wx/htfilter.tex

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

docs/latex/wx/hthelpct.tex

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

docs/latex/wx/hthlpdat.tex

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

docs/latex/wx/hthlpfrm.tex

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

docs/latex/wx/htlnkinf.tex

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

docs/latex/wx/htmlcell.tex

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

docs/latex/wx/htmlfilt.tex

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

docs/latex/wx/htmlhand.tex

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

docs/latex/wx/htmlhlpf.tex

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

docs/latex/wx/htmllbox.tex

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

docs/latex/wx/htmlprn.tex

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

docs/latex/wx/htmlstrt.tex

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

docs/latex/wx/htmltags.tex

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

docs/latex/wx/htparser.tex

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

docs/latex/wx/htprint.tex

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

docs/latex/wx/httag.tex

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

docs/latex/wx/httaghnd.tex

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

docs/latex/wx/httagmod.tex

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

docs/latex/wx/http.tex

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

docs/latex/wx/htwidget.tex

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

docs/latex/wx/htwindow.tex

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

docs/latex/wx/htwinhnd.tex

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

docs/latex/wx/htwinprs.tex

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

include/wx/html/forcelnk.h

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

include/wx/html/helpctrl.h

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

include/wx/html/helpdata.h

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

include/wx/html/helpfrm.h

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

include/wx/html/htmlcell.h

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

include/wx/html/htmldefs.h

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

include/wx/html/htmlfilt.h

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

include/wx/html/htmlpars.h

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

include/wx/html/htmlproc.h

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

include/wx/html/htmltag.h

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

include/wx/html/htmlwin.h

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

include/wx/html/htmprint.h

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

include/wx/html/m_templ.h

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

include/wx/html/winpars.h

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

src/html/helpctrl.cpp

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

src/html/helpdata.cpp

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

src/html/htmlcell.cpp

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

src/html/htmlfilt.cpp

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

src/html/htmlpars.cpp

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

src/html/htmltag.cpp

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

src/html/htmlwin.cpp

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

src/html/htmprint.cpp

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

src/html/m_dflist.cpp

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

src/html/m_fonts.cpp

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

src/html/m_hline.cpp

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

src/html/m_image.cpp

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

src/html/m_layout.cpp

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

src/html/m_links.cpp

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

src/html/m_list.cpp

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

src/html/m_pre.cpp

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

src/html/m_style.cpp

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

src/html/m_tables.cpp

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

src/html/winpars.cpp

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

src/xrc/xh_html.cpp

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

utils/wxPython/.cvsignore

@@ -0,0 +1,97 @@
+*.zip
+.cvsignore
+.emacs.desktop
+__init__.py
+__init__.py
+__init__.pyc
+__init__.pyc
+__init__.pyo
+__init__.pyo
+cmndlgs.py
+cmndlgs.py
+cmndlgs.pyc
+cmndlgs.pyc
+cmndlgs.pyo
+cmndlgs.pyo
+controls.py
+controls.py
+controls.pyc
+controls.pyc
+controls.pyo
+controls.pyo
+controls2.py
+controls2.py
+controls2.pyc
+controls2.pyc
+controls2.pyo
+controls2.pyo
+events.py
+events.py
+events.pyc
+events.pyc
+events.pyo
+events.pyo
+frames.py
+frames.py
+frames.pyc
+frames.pyc
+frames.pyo
+frames.pyo
+gdi.py
+gdi.py
+gdi.pyc
+gdi.pyc
+gdi.pyo
+gdi.pyo
+mdi.py
+mdi.py
+mdi.pyc
+mdi.pyc
+mdi.pyo
+mdi.pyo
+misc.py
+misc.py
+misc.pyc
+misc.pyc
+misc.pyo
+misc.pyo
+stattool.py
+stattool.py
+stattool.pyc
+stattool.pyc
+stattool.pyo
+stattool.pyo
+utils.py
+utils.py
+utils.pyc
+utils.pyc
+utils.pyo
+windows.py
+windows.py
+windows.pyc
+windows.pyc
+windows.pyo
+windows.pyo
+windows2.py
+windows2.py
+windows2.pyc
+windows2.pyc
+windows2.pyo
+windows2.pyo
+windows3.py
+windows3.pyc
+windows3.pyo
+wx.py
+wx.py
+wx.pyc
+wx.pyc
+wx.pyo
+wxc.ilk
+wxc.pdb
+wxc.pyd
+wxp.py
+wxp.pyc
+wxp.pyo
+wxpc.ilk
+wxpc.pdb
+wxpc.pyd

utils/wxPython/README.txt

@@ -0,0 +1,204 @@
+wxPython README
+---------------
+
+Introduction
+------------
+The code in this subtree is a Python Extension Module that enables the
+use of wxWindows from the Python language.  So what is Python?  Go to
+http://www.python.org to learn more but in a nutshell, it's an
+extremly cool object oriented language.  It's easier than Perl and
+nearly as powerful.  It runs on more platforms than Java, and by some
+reports, is even faster than Java with a JIT compiler!
+
+So why would you want to use wxPython over just C++ and wxWindows?
+Personally I prefer using Python for everything.  I only use C++ when
+I absolutly have to eek more performance out of an algorithm, and even
+then I ususally code it as an extension module and leave the majority
+of the program in Python.  Another good thing to use wxPython for is
+quick prototyping of your wxWindows apps.  With C++ you have to
+continuously go though the edit-compile-link-run cycle, which can be
+quite time comsuming.  With Python it is only an edit-run cycle.  You
+can easily build an application in a few hours with Python that would
+normally take a few days with C++.  Converting a wxPython app to a
+C++/wxWindows app should be a straight forward task.
+
+This extension module attempts to mirror the class heiarchy of
+wxWindows as closely as possble.  This means that there is a wxFrame
+class in wxPython that looks, smells, tastes and acts almost the same
+as the wxFrame class in the C++ version.  Unfortunatly, I wasn't able
+to match things exactly because of differences in the languages, but
+the differences should be easy to absorb because they are natural to
+Python.  For example, some methods that return mutliple values via
+argument pointers in C++ will return a tuple of values in Python.
+These differences have not been documented yet so if something isn't
+working the same as described in the wxWindows documents the best
+thing to do is to scan through the wxPython sources, especially the .i
+files, as that is where the interfaces for wxPython are defined.
+
+Currently this extension module is designed such that the entire
+application will be written in Python.  I havn't tried it yet, but I
+am sure that attempting to embed wxPython in a C++ wxWindows
+application will cause problems.  However there is a plan to support
+this in the future.
+
+
+What's new in 0.5.3
+-------------------
+Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
+
+Various cleanup, tweaks, minor additions, etc. to maintain
+compatibility with the current wxWindows.
+
+
+
+What's new in 0.5.0
+-------------------
+Changed the import semantics from "from wxPython import *" to "from
+wxPython.wx import *"  This is for people who are worried about
+namespace pollution, they can use "from wxPython import wx" and then
+prefix all the wxPython identifiers with "wx."
+
+Added wxTaskbarIcon for wxMSW.
+
+Made the events work for wxGrid.
+
+Added wxConfig.
+
+Added wxMiniFrame for wxGTK.
+
+Changed many of the args and return values that were pointers to gdi
+objects to references to reflect changes in the wxWindows API.
+
+Other assorted fixes and additions.
+
+
+
+
+What's new in 0.4.2
+-------------------
+
+wxPython on wxGTK works!!!  Both dynamic and static on Linux and
+static on Solaris have been tested.  Many thanks go to Harm
+<H.v.d.Heijden@phys.tue.nl> for his astute detective work on tracking
+down a nasty DECREF bug.  Okay so I have to confess that it was just a
+DSM (Dumb Stupid Mistake) on my part but it was nasty none the less
+because the behavior was so different on different platforms.
+
+
+The dynamicly loaded module on Solaris is still segfaulting, so it
+must have been a different issue all along...
+
+
+
+What's New in 0.4
+-----------------
+
+1. Worked on wxGTK compatibility.  It is partially working.  On a
+Solaris/Sparc box wxPython is working but only when it is statically
+linked with the Python interpreter.  When built as a dyamically loaded
+extension module, things start acting weirdly and it soon seg-faults.
+And on Linux both the statically linked and the dynamically linked
+version segfault shortly after starting up.
+
+2. Added Toolbar, StatusBar and SplitterWindow classes.
+
+3. Varioius bug fixes, enhancements, etc.
+
+
+
+Build Instructions
+------------------
+I used SWIG (http://www.swig.org) to create the source code for the
+extension module.  This enabled me to only have to deal with a small
+amount of code and only have to bother with the exceptional issues.
+SWIG takes care of the rest and generates all the repetative code for
+me.  You don't need SWIG to build the extension module as all the
+generated C++ code is included under the src directory.
+
+I added a few minor features to SWIG to control some of the code
+generation.  If you want to playaround with this the patches are in
+wxPython/SWIG.patches and they should be applied to the 1.1p5 version
+of SWIG.  These new patches are documented at
+http://starship.skyport.net/crew/robind/python/#swig, and they should
+also end up in the 1.2 version of SWIG.
+
+wxPython is organized as a Python package.  This means that the
+directory containing the results of the build process should be a
+subdirectory of a directory on the PYTHONPATH.  (And preferably should
+be named wxPython.)  You can control where the build process will dump
+wxPython by setting the TARGETDIR makefile variable.  The default is
+$(WXWIN)/utils/wxPython, where this README.txt is located.  If you
+leave it here then you should add $(WXWIN)/utils to your PYTHONPATH.
+However, you may prefer to use something that is already on your
+PYTHONPATH, such as the site-packages directory on Unix systems.
+
+
+Win32
+-----
+
+1. Build wxWindows with wxUSE_RESOURCE_LOADING_IN_MSW set to 1 in
+include/wx/msw/setup.h so icons can be loaded dynamically.  While
+there, make sure wxUSE_OWNER_DRAWN is also set to 1.
+
+2. Change into the $(WXWIN)/utils/wxPython/src directory.
+
+3. Edit makefile.nt and specify where your python installation is at.
+You may also want to fiddle with the TARGETDIR variable as described
+above.
+
+4. Run nmake -f makefile.nt
+
+5. If it builds successfully, congratulations!  Move on to the next
+step.  If not then you can try mailing me for help.  Also, I will
+always have a pre-built win32 version of this extension module at
+http://starship.skyport.net/crew/robind/python.
+
+6. Change to the $(WXWIN)/utils/wxPython/tests directory.
+
+7. Try executing the test programs.  Note that some of these print
+diagnositc or test info to standard output, so they will require the
+console version of python.  For example:
+
+    python test1.py
+
+To run them without requiring a console, you can use the pythonw.exe
+version of Python either from the command line or from a shortcut.
+
+
+
+Unix
+----
+
+1. Change into the $(WXWIN)/utils/wxPython/src directory.
+
+2. Edit Setup.in and ensure that the flags, directories, and toolkit
+options are correct.  See the above commentary about TARGETDIR.  There
+are a few sample Setup.in.[platform] files provided.
+
+3. Run this command to generate a makefile:
+
+    make -f Makefile.pre.in boot
+
+4. Run these commands to build and then install the wxPython extension
+module:
+
+    make
+    make install
+
+
+5. Change to the $(WXWIN)/utils/wxPython/tests directory.
+
+6. Try executing the test programs.  For example:
+
+    python test1.py
+
+
+
+------------------------
+10/20/1998
+
+Robin Dunn
+robin@alldunn.com
+
+
+

utils/wxPython/SWIG.patches/Include.patch

@@ -0,0 +1,97 @@
+*** swig.h.old	Wed Feb 04 14:59:40 1998
+--- swig.h	Fri Aug 28 14:46:32 1998
+***************
+*** 178,185 ****
+--- 178,211 ----
+    char  *firstkey();
+    char  *nextkey();
+  };
+  
++ // -------------------------------------------------------------------
++ // Simple Vector class
++ // User is responsible for deleting contents before deleteing Vector
++ // -------------------------------------------------------------------
++ 
++ class Vector {
++ public:
++     Vector(size_t allocSize=8);
++     ~Vector();
++ 
++     size_t size()                      { return m_size;  }
++     size_t count()                     { return m_count; }
++     size_t append(void* object);
++     size_t extend(size_t newSize);
++ 
++     void*& operator[] (size_t idx);
++ 
++     static void*    s_nullPtr;
++ 
++ private:
++     size_t          m_size;
++     size_t          m_count;
++     void**          m_data;
++ };
++ 
++ 
+  /************************************************************************
+   * class DataType
+   *
+   * Defines the basic datatypes supported by the translator.
+***************
+*** 684,691 ****
+--- 710,761 ----
+  extern char  *name_get(char *vname, int suppress=0);
+  extern char  *name_set(char *vname, int suppress=0);
+  extern char  *name_construct(char *classname, int suppress=0);
+  extern char  *name_destroy(char *classname, int suppress=0);
++ 
++ // ----------------------------------------------------------------------
++ // class CPP_class
++ //
++ // Class for managing class members (internally)
++ // ----------------------------------------------------------------------
++ 
++ class CPP_member;
++ 
++ class CPP_class {
++ public:
++   char        *classname;             // Real class name
++   char        *classrename;           // New name of class (if applicable)
++   char        *classtype;             // class type (struct, union, class)
++   int          strip;                 // Strip off class declarator
++   int          wextern;               // Value of extern wrapper variable for this class
++   int          have_constructor;      // Status bit indicating if we've seen a constructor
++   int          have_destructor;       // Status bit indicating if a destructor has been seen
++   int          is_abstract;           // Status bit indicating if this is an abstract class
++   int          generate_default;      // Generate default constructors
++   int          objective_c;           // Set if this is an objective C class
++   int          error;                 // Set if this class can't be generated
++   int          line;                  // Line number
++   char        **baseclass;            // Base classes (if any)
++   Hash        *local;                 // Hash table for local types
++   Hash        *scope;                 // Local scope hash table
++   DocEntry    *de;                    // Documentation entry of class
++   CPP_member  *members;               // Linked list of members
++   CPP_class   *next;                  // Next class
++   static CPP_class *classlist;        // List of all classes stored
++ 
++   Vector      addPragmas;
++ 
++   CPP_class(char *name, char *ctype);
++   void add_member(CPP_member *m);
++   CPP_member *search_member(char *name);
++   void inherit_decls(int mode);
++   void emit_decls();
++   static CPP_class *search(char *name);
++   void create_default();
++   static void create_all();
++ };
++ 
++ extern CPP_class     *current_class;
+  
+  /***********************************************************************
+   * -- Revision History
+   * $Log$
+   * Revision 1.1  1998/10/03 05:56:02  RD
+   * *** empty log message ***
+   *

utils/wxPython/SWIG.patches/Modules.patch

@@ -0,0 +1,136 @@
+*** python.cxx.old	Fri Jan 02 22:17:40 1998
+--- python.cxx	Fri Aug 28 14:49:18 1998
+***************
+*** 1679,1684 ****
+--- 1679,1701 ----
+  	      }
+  	    }
+  	  }
++         } else if (strcmp(cmd, "addtomethod") == 0) {
++             // parse value, expected to be in the form "methodName:line"
++             char* txtptr = strchr(value, ':');
++             if (txtptr) {
++                 // add name and line to a list in current_class
++                 *txtptr = 0;
++                 txtptr++;
++                 AddPragmaData* apData = new AddPragmaData(value, txtptr);
++                 current_class->addPragmas.append(apData);
++ 
++             } else {
++                 fprintf(stderr,"%s : Line %d. Malformed addtomethod pragma.  Should be \"methodName:text\"\n",
++                         input_file, line_number);
++             }
++         } else if (strcmp(cmd, "addtoclass") == 0) {
++                 AddPragmaData* apData = new AddPragmaData("__class__", value);
++                 current_class->addPragmas.append(apData);
+  	} else {
+  	  fprintf(stderr,"%s : Line %d. Unrecognized pragma.\n", input_file, line_number);
+  	}
+*** python.h.old	Thu Jul 24 22:18:50 1997
+--- python.h	Fri Aug 28 14:46:08 1998
+***************
+*** 185,191 ****
+--- 185,203 ----
+    void cpp_class_decl(char *, char *,char *);
+    void pragma(char *, char *, char *);
+    void add_typedef(DataType *t, char *name);
++ 
++   void emitAddPragmas(String& output, char* name, char* spacing);
+  };
+  
+  #define PYSHADOW_MEMBER  0x2
++ 
++ struct AddPragmaData {
++     String      m_method;
++     String      m_text;
++ 
++     AddPragmaData(char* method, char* text)
++         : m_method(method),
++           m_text(text)
++         {}
++ };
+  
+*** pycpp.cxx.old	Fri Jan 02 20:23:22 1998
+--- pycpp.cxx	Fri Aug 28 16:01:46 1998
+***************
+*** 276,281 ****
+--- 276,282 ----
+        }
+      }
+      //    if ((t->type != T_VOID) || (t->is_pointer))
++     emitAddPragmas(*pyclass, realname, tab8);
+      *pyclass << tab8 << "return val\n";
+  
+      // Change the usage string to reflect our shadow class
+***************
+*** 394,399 ****
+--- 395,401 ----
+        }
+        *construct << ")\n";
+        *construct << tab8 << "self.thisown = 1\n";
++       emitAddPragmas(*construct, "__init__", tab8);
+        have_constructor = 1;
+      } else {
+  
+***************
+*** 494,502 ****
+      *pyclass << tab4 << "def __del__(self):\n"
+  	     << tab8 << "if self.thisown == 1 :\n"
+  	     << tab8 << tab4 << module << "." << name_destroy(realname) << "(self.this)\n";
+!     
+      have_destructor = 1;
+- 
+      if (doc_entry) {
+        doc_entry->usage = "";
+        doc_entry->usage << "del this";
+--- 496,503 ----
+      *pyclass << tab4 << "def __del__(self):\n"
+  	     << tab8 << "if self.thisown == 1 :\n"
+  	     << tab8 << tab4 << module << "." << name_destroy(realname) << "(self.this)\n";
+!     emitAddPragmas(*pyclass, "__del__", tab8);
+      have_destructor = 1;
+      if (doc_entry) {
+        doc_entry->usage = "";
+        doc_entry->usage << "del this";
+***************
+*** 552,557 ****
+--- 553,560 ----
+  	   << tab8 << "return \"<C " << class_name <<" instance>\"\n";
+  
+        classes << repr;
++       emitAddPragmas(classes, "__class__", tab4);
++ 
+      }
+  
+      // Now build the real class with a normal constructor
+***************
+*** 747,752 ****
+--- 750,777 ----
+    }
+  }
+  
++ // --------------------------------------------------------------------------------
++ // PYTHON::emitAddPragmas(String& output, char* name, char* spacing);
++ //
++ // Search the current_class->addPragmas vector for any text belonging to name.
++ // Append the text properly spcaed to the output string.
++ //
++ // --------------------------------------------------------------------------------
++ 
++ void PYTHON::emitAddPragmas(String& output, char* name, char* spacing)
++ {
++     AddPragmaData*      apData;
++     size_t              count;
++     int                 i;
++ 
++     count = current_class->addPragmas.count();
++     for (i=0; i<count; i++) {
++         apData = (AddPragmaData*)current_class->addPragmas[i];
++         if (strcmp(apData->m_method, name) == 0) {
++             output << spacing << apData->m_text << "\n";
++         }
++     }
++ }
+  
+  /*********************************************************************************
+   *

utils/wxPython/SWIG.patches/SWIG.patch

@@ -0,0 +1,488 @@
+*** cplus.cxx.old	Mon Feb 02 14:55:42 1998
+--- cplus.cxx	Fri Aug 28 12:02:50 1998
+***************
+*** 581,612 ****
+  // Class for managing class members (internally)
+  // ----------------------------------------------------------------------
+  
+  static char   *inherit_base_class = 0;
+  
+- class CPP_class {
+- public:
+-   char        *classname;             // Real class name
+-   char        *classrename;           // New name of class (if applicable)
+-   char        *classtype;             // class type (struct, union, class)
+-   int          strip;                 // Strip off class declarator
+-   int          wextern;               // Value of extern wrapper variable for this class
+-   int          have_constructor;      // Status bit indicating if we've seen a constructor
+-   int          have_destructor;       // Status bit indicating if a destructor has been seen
+-   int          is_abstract;           // Status bit indicating if this is an abstract class
+-   int          generate_default;      // Generate default constructors
+-   int          objective_c;           // Set if this is an objective C class
+-   int          error;                 // Set if this class can't be generated
+-   int          line;                  // Line number
+-   char        **baseclass;            // Base classes (if any)
+-   Hash        *local;                 // Hash table for local types
+-   Hash        *scope;                 // Local scope hash table
+-   DocEntry    *de;                    // Documentation entry of class
+-   CPP_member  *members;               // Linked list of members
+-   CPP_class   *next;                  // Next class
+-   static CPP_class *classlist;        // List of all classes stored
+  
+!   CPP_class(char *name, char *ctype) {
+      CPP_class *c;
+      classname = copy_string(name);
+      classtype = copy_string(ctype);
+      classrename = 0;
+--- 581,593 ----
+  // Class for managing class members (internally)
+  // ----------------------------------------------------------------------
+  
+  static char   *inherit_base_class = 0;
++ CPP_class *CPP_class::classlist = 0;
++ CPP_class     *current_class;
+  
+  
+! CPP_class::CPP_class(char *name, char *ctype) {
+    CPP_class *c;
+    classname = copy_string(name);
+    classtype = copy_string(ctype);
+    classrename = 0;
+***************
+*** 642,650 ****
+    // ------------------------------------------------------------------------------
+    // Add a new C++ member to this class
+    // ------------------------------------------------------------------------------
+  
+!   void add_member(CPP_member *m) {
+      CPP_member *cm;
+      
+      // Set base class where this was defined
+      if (inherit_base_class)          
+--- 623,631 ----
+  // ------------------------------------------------------------------------------
+  // Add a new C++ member to this class
+  // ------------------------------------------------------------------------------
+  
+! void CPP_class::add_member(CPP_member *m) {
+    CPP_member *cm;
+  
+    // Set base class where this was defined
+    if (inherit_base_class)
+***************
+*** 664,672 ****
+    // ------------------------------------------------------------------------------
+    // Search for a member with the given name. Returns the member on success, 0 on failure
+    // ------------------------------------------------------------------------------
+  
+!   CPP_member *search_member(char *name) {
+      CPP_member *m;
+      char *c;
+      m = members;
+      while (m) {
+--- 645,653 ----
+  // ------------------------------------------------------------------------------
+  // Search for a member with the given name. Returns the member on success, 0 on failure
+  // ------------------------------------------------------------------------------
+  
+! CPP_member *CPP_class::search_member(char *name) {
+    CPP_member *m;
+    char *c;
+    m = members;
+    while (m) {
+***************
+*** 680,688 ****
+    // ------------------------------------------------------------------------------
+    // Inherit.  Put all the declarations associated with this class into the current
+    // ------------------------------------------------------------------------------
+  
+!   void inherit_decls(int mode) {
+      CPP_member *m;
+      m = members;
+      while (m) {
+        inherit_base_class = m->base;
+--- 661,669 ----
+  // ------------------------------------------------------------------------------
+  // Inherit.  Put all the declarations associated with this class into the current
+  // ------------------------------------------------------------------------------
+  
+! void CPP_class::inherit_decls(int mode) {
+    CPP_member *m;
+    m = members;
+    while (m) {
+      inherit_base_class = m->base;
+***************
+*** 696,704 ****
+    // ------------------------------------------------------------------------------
+    // Emit all of the declarations associated with this class 
+    // ------------------------------------------------------------------------------
+  
+!   void emit_decls() {
+      CPP_member    *m = members;
+      int  last_scope = name_scope(0);
+      abstract = is_abstract;
+      while (m) {
+--- 677,685 ----
+  // ------------------------------------------------------------------------------
+  // Emit all of the declarations associated with this class
+  // ------------------------------------------------------------------------------
+  
+! void CPP_class::emit_decls() {
+    CPP_member    *m = members;
+    int  last_scope = name_scope(0);
+    abstract = is_abstract;
+    while (m) {
+***************
+*** 713,721 ****
+    // ------------------------------------------------------------------------------  
+    // Search for a given class in the list
+    // ------------------------------------------------------------------------------
+  
+!   static CPP_class *search(char *name) {
+      CPP_class *c;
+      c = classlist;
+      if (!name) return 0;
+      while (c) {
+--- 694,702 ----
+  // ------------------------------------------------------------------------------
+  // Search for a given class in the list
+  // ------------------------------------------------------------------------------
+  
+! CPP_class *CPP_class::search(char *name) {
+    CPP_class *c;
+    c = classlist;
+    if (!name) return 0;
+    while (c) {
+***************
+*** 729,737 ****
+    // Add default constructors and destructors
+    //
+    // ------------------------------------------------------------------------------
+  
+!   void create_default() {
+      if (!generate_default) return;
+      
+      // Try to generate a constructor if not available.
+  
+--- 710,718 ----
+  // Add default constructors and destructors
+  //
+  // ------------------------------------------------------------------------------
+  
+! void CPP_class::create_default() {
+    if (!generate_default) return;
+  
+    // Try to generate a constructor if not available.
+  
+***************
+*** 751,764 ****
+    // ------------------------------------------------------------------------------
+    // Dump *all* of the classes saved out to the various
+    // language modules (this does what cplus_close_class used to do)
+    // ------------------------------------------------------------------------------
+-   static void create_all();
+- };
+- 
+- CPP_class *CPP_class::classlist = 0;
+- static CPP_class     *current_class;
+- 
+  void CPP_class::create_all() {
+    CPP_class *c;
+    c = classlist;
+    while (c) {
+--- 732,739 ----
+*** vector.cxx.old	Fri Aug 28 14:23:16 1998
+--- vector.cxx	Fri Aug 28 14:46:52 1998
+***************
+*** 0 ****
+--- 1,182 ----
++ 
++ /*******************************************************************************
++  * Simplified Wrapper and Interface Generator  (SWIG)
++  *
++  * Dave Beazley
++  *
++  * Department of Computer Science        Theoretical Division (T-11)
++  * University of Utah                    Los Alamos National Laboratory
++  * Salt Lake City, Utah  84112           Los Alamos, New Mexico  87545
++  * beazley@cs.utah.edu                   beazley@lanl.gov
++  *
++  * Copyright (c) 1995-1997
++  * The University of Utah and the Regents of the University of California
++  * All Rights Reserved
++  *
++  * Permission is hereby granted, without written agreement and without
++  * license or royalty fees, to use, copy, modify, and distribute this
++  * software and its documentation for any purpose, provided that
++  * (1) The above copyright notice and the following two paragraphs
++  * appear in all copies of the source code and (2) redistributions
++  * including binaries reproduces these notices in the supporting
++  * documentation.   Substantial modifications to this software may be
++  * copyrighted by their authors and need not follow the licensing terms
++  * described here, provided that the new terms are clearly indicated in
++  * all files where they apply.
++  *
++  * IN NO EVENT SHALL THE AUTHOR, THE UNIVERSITY OF CALIFORNIA, THE
++  * UNIVERSITY OF UTAH OR DISTRIBUTORS OF THIS SOFTWARE BE LIABLE TO ANY
++  * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL
++  * DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION,
++  * EVEN IF THE AUTHORS OR ANY OF THE ABOVE PARTIES HAVE BEEN ADVISED OF
++  * THE POSSIBILITY OF SUCH DAMAGE.
++  *
++  * THE AUTHOR, THE UNIVERSITY OF CALIFORNIA, AND THE UNIVERSITY OF UTAH
++  * SPECIFICALLY DISCLAIM ANY WARRANTIES,INCLUDING, BUT NOT LIMITED TO,
++  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
++  * PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND
++  * THE AUTHORS AND DISTRIBUTORS HAVE NO OBLIGATION TO PROVIDE MAINTENANCE,
++  * SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
++  *
++  *******************************************************************************/
++ 
++ #include "internal.h"
++ 
++ /*******************************************************************************
++  * $Header$
++  *
++  * File : vector.cxx
++  *
++  * A very simple Vector class.  Allways assumes that memory allocations are
++  * successful.  Should be made more robust...
++  *
++  *******************************************************************************/
++ 
++ void* Vector::s_nullPtr = NULL;
++ 
++ // -----------------------------------------------------------------------------
++ // Vector::Vector(size_t allocSize = 8)
++ //
++ // Constructor.  Creates a new Vector.
++ //
++ // Inputs : initial allocation size (optional)
++ //
++ // Output : New Vector object.
++ //
++ // Side Effects : None
++ // -----------------------------------------------------------------------------
++ 
++ Vector::Vector(size_t allocSize)
++     : m_size(allocSize),
++       m_count(0),
++       m_data(0)
++ {
++     if (m_size) {
++         m_data = new void*[m_size];
++         int i;
++         for (i=0; i<m_size;i++)
++             m_data[i] = 0;
++     }
++ }
++ 
++ 
++ // -----------------------------------------------------------------------------
++ // Vector::~Vector
++ //
++ // Destructor.  Only cleans up the vector, not its contents!
++ //
++ // -----------------------------------------------------------------------------
++ 
++ 
++ Vector::~Vector() {
++     if (m_data) {
++         delete [] m_data;
++     }
++ 
++     m_data = 0;
++     m_size = m_count = 0;
++ }
++ 
++ 
++ 
++ // -----------------------------------------------------------------------------
++ // size_t Vector::extend(size_t newSize)
++ //
++ // Extends the vector to at least newSize length.  Won't do anything if newSize
++ // is smaller than the current size of the vector.
++ //
++ // Returns the new allocated size.
++ //
++ // -----------------------------------------------------------------------------
++ 
++ #define GRANULARITY     16
++ 
++ size_t Vector::extend(size_t newSize) {
++ 
++     if (newSize > m_size) {
++         newSize = newSize + (GRANULARITY - (newSize % GRANULARITY));
++ 
++         void** temp = new void*[newSize];
++         memcpy(temp, m_data, m_size*sizeof(void*));
++ 
++         int i;
++         for (i=m_size; i<newSize; i++)
++             temp[i] = 0;
++ 
++         delete [] m_data;
++         m_data = temp;
++         m_size = newSize;
++     }
++     return m_size;
++ }
++ 
++ 
++ // -----------------------------------------------------------------------------
++ // Vector::append(void* object)
++ //
++ // Appends the object pointer to vector at index m_count.  Increments m_count.
++ // Returns the new count.
++ // -----------------------------------------------------------------------------
++ 
++ size_t Vector::append(void* object) {
++     if (m_count >= m_size) {
++         extend(m_count + 1);
++     }
++ 
++     m_data[m_count] = object;
++     m_count += 1;
++ 
++     return m_count;
++ }
++ 
++ 
++ // -----------------------------------------------------------------------------
++ // Vector::operator[] (size_t idx)
++ //
++ // Returns a reference to the void pointer at idx.  If idx is beyond the range
++ // of the vector, returns a reference to s_nullPtr.
++ //
++ // -----------------------------------------------------------------------------
++ 
++ void*& Vector::operator[] (size_t idx) {
++     if (idx >= m_size) {
++         s_nullPtr = 0;
++         return s_nullPtr;
++     }
++ 
++     return m_data[idx];
++ }
++ 
++ 
++ /***********************************************************************
++  *
++  * -- Revision History
++  * $Log$
++  * Revision 1.1  1998/10/03 05:56:03  RD
++  * *** empty log message ***
++  *
++  *
++  ***********************************************************************/
++ 
++ 
++ 
++ 
++ 
++ 
+*** makefile.msc.old	Mon Jun 23 15:15:32 1997
+--- makefile.msc	Fri Aug 28 10:21:58 1998
+***************
+*** 33,50 ****
+  # Normally, you shouldn't have to change anything below this point     #
+  ########################################################################
+  
+  LIBOBJS = main.obj scanner.obj symbol.obj include.obj types.obj parms.obj emit.obj newdoc.obj ascii.obj \
+!           html.obj latex.obj cplus.obj lang.obj hash.obj sstring.obj wrapfunc.obj getopt.obj comment.obj typemap.obj naming.obj
+  
+  LIBSRCS = main.cxx scanner.cxx symbol.cxx include.cxx types.cxx parms.cxx emit.cxx \
+! 	  newdoc.cxx ascii.cxx html.cxx latex.cxx cplus.cxx lang.cxx hash.cxx \
+            sstring.cxx wrapfunc.cxx getopt.cxx comment.cxx typemap.cxx naming.cxx
+  
+  LIBHEADERS = internal.h ../Include/swig.h latex.h ascii.h html.h nodoc.h
+  LIBNAME      = ..\libswig.lib
+  INCLUDE  = -I../Include -I$(STD_INC)
+! CFLAGS   = -Zi -nologo -DSWIG_LIB="\"$(SWIG_LIB)\"" -DSWIG_CC="\"$(CC)\""  -DMSDOS -DSTDC_HEADERS=1 -DHAVE_LIBDL=1 $(SWIG_OPTS)
+  LD_FLAGS    =  -VERBOSE
+  
+  
+  #
+--- 33,50 ----
+  # Normally, you shouldn't have to change anything below this point     #
+  ########################################################################
+  
+  LIBOBJS = main.obj scanner.obj symbol.obj include.obj types.obj parms.obj emit.obj newdoc.obj ascii.obj \
+!           html.obj latex.obj cplus.obj lang.obj hash.obj vector.obj sstring.obj wrapfunc.obj getopt.obj comment.obj typemap.obj naming.obj
+  
+  LIBSRCS = main.cxx scanner.cxx symbol.cxx include.cxx types.cxx parms.cxx emit.cxx \
+! 	  newdoc.cxx ascii.cxx html.cxx latex.cxx cplus.cxx lang.cxx hash.cxx vector.cxx \
+            sstring.cxx wrapfunc.cxx getopt.cxx comment.cxx typemap.cxx naming.cxx
+  
+  LIBHEADERS = internal.h ../Include/swig.h latex.h ascii.h html.h nodoc.h
+  LIBNAME      = ..\libswig.lib
+  INCLUDE  = -I../Include -I$(STD_INC)
+! CFLAGS   = -Zi -nologo -DSWIG_LIB="\"$(SWIG_LIB)\"" -DSWIG_CC="\"$(CC)\""  -DMSDOS -DSTDC_HEADERS=1 -DHAVE_LIBDL=1 $(SWIG_OPTS) $(OTHERFLAGS)
+  LD_FLAGS    =  -VERBOSE
+  
+  
+  #
+*** makefile.bc.old	Sun Jan 04 12:49:24 1998
+--- makefile.bc	Fri Aug 28 14:42:58 1998
+***************
+*** 34,47 ****
+  ########################################################################
+  
+  LIBOBJS = main.obj scanner.obj symbol.obj include.obj types.obj parms.obj \
+            emit.obj newdoc.obj ascii.obj \
+!           html.obj latex.obj cplus.obj lang.obj hash.obj sstring.obj \
+            wrapfunc.obj getopt.obj comment.obj typemap.obj naming.obj
+  
+  LIBSRCS = main.cxx scanner.cxx symbol.cxx include.cxx types.cxx parms.cxx \
+            emit.cxx newdoc.cxx ascii.cxx html.cxx latex.cxx cplus.cxx lang.cxx hash.cxx \
+!           sstring.cxx wrapfunc.cxx getopt.cxx comment.cxx typemap.cxx naming.cxx
+  
+  LIBHEADERS = internal.h ../Include/swig.h latex.h ascii.h html.h nodoc.h
+  LIBNAME      = ..\libswig.lib
+  INCLUDE  = -I../Include -I$(STD_INC)
+--- 34,47 ----
+  ########################################################################
+  
+  LIBOBJS = main.obj scanner.obj symbol.obj include.obj types.obj parms.obj \
+            emit.obj newdoc.obj ascii.obj \
+!           html.obj latex.obj cplus.obj lang.obj hash.obj vector.obj sstring.obj \
+            wrapfunc.obj getopt.obj comment.obj typemap.obj naming.obj
+  
+  LIBSRCS = main.cxx scanner.cxx symbol.cxx include.cxx types.cxx parms.cxx \
+            emit.cxx newdoc.cxx ascii.cxx html.cxx latex.cxx cplus.cxx lang.cxx hash.cxx \
+!           vector.cxx sstring.cxx wrapfunc.cxx getopt.cxx comment.cxx typemap.cxx naming.cxx
+  
+  LIBHEADERS = internal.h ../Include/swig.h latex.h ascii.h html.h nodoc.h
+  LIBNAME      = ..\libswig.lib
+  INCLUDE  = -I../Include -I$(STD_INC)
+*** Makefile.in.old	Wed May 28 22:56:56 1997
+--- Makefile.in	Fri Aug 28 14:43:36 1998
+***************
+*** 51,63 ****
+  # Normally, you shouldn't have to change anything below this point     #
+  ########################################################################
+  
+  LIBOBJS = main.o scanner.o symbol.o include.o types.o parms.o emit.o newdoc.o ascii.o \
+!           html.o latex.o cplus.o lang.o hash.o sstring.o wrapfunc.o getopt.o comment.o \
+            typemap.o naming.o
+  
+  LIBSRCS = main.cxx scanner.cxx symbol.cxx include.cxx types.cxx parms.cxx emit.cxx \
+! 	  newdoc.cxx ascii.cxx html.cxx latex.cxx cplus.cxx lang.cxx hash.cxx \
+            sstring.cxx wrapfunc.cxx getopt.cxx comment.cxx typemap.cxx naming.cxx
+  
+  LIBHEADERS = internal.h ../Include/swig.h latex.h ascii.h html.h nodoc.h
+  LIB      = ../libswig.a
+--- 51,63 ----
+  # Normally, you shouldn't have to change anything below this point     #
+  ########################################################################
+  
+  LIBOBJS = main.o scanner.o symbol.o include.o types.o parms.o emit.o newdoc.o ascii.o \
+!           html.o latex.o cplus.o lang.o hash.o vector.o sstring.o wrapfunc.o getopt.o comment.o \
+            typemap.o naming.o
+  
+  LIBSRCS = main.cxx scanner.cxx symbol.cxx include.cxx types.cxx parms.cxx emit.cxx \
+! 	  newdoc.cxx ascii.cxx html.cxx latex.cxx cplus.cxx lang.cxx hash.cxx vector.cxx \
+            sstring.cxx wrapfunc.cxx getopt.cxx comment.cxx typemap.cxx naming.cxx
+  
+  LIBHEADERS = internal.h ../Include/swig.h latex.h ascii.h html.h nodoc.h
+  LIB      = ../libswig.a

utils/wxPython/TODO.txt

@@ -0,0 +1,43 @@
+wxPython TODO List
+------------------
+
+These are the major tasks to be done on wxPython:
+
+1. Get it working for wxGTK.
+
+2. Figure out how to do embedding of wxPython in a wxWindows C++
+   application.
+
+    Actually, now that I think about it it might actually work.  We
+    just need to move some of the wxWindows initialization stuff out
+    of wxpcinit, ensure that __wxStart is not called and that a wxApp
+    is not created.  So this task becomes: Create a test case for
+    embedding wxPython in a C++ app.  Should also create some helper
+    functions for passing window objects into the Python code, etc.
+
+    Test this with M.
+
+
+3. Add significantly to the tests.
+
+4. Derived Python classes should have the ability to call the standard
+   On** methods in the base class.
+
+5. There are some virtual On** and other methods in wxWindows that
+   should end up being callbacks in derived python classes, but they
+   are not called via the standard event system.  Is there any way to
+   hook into these and call Python methods (if they exist in the
+   derived class) without having to derive a specialized C++ class?
+
+6. Add the Doc/View related classes
+
+7. Add the Printing related classes
+
+8. Document the differences (method signatures, new methods to
+   compensate for no overloading, etc.) between wxPython and wxWindows.
+
+9. Create some larger-scale sample application with wxPython to show
+   it can be done and the simplicity that it will provide...  Test
+   distribution with Freeze.
+
+

utils/wxPython/distrib/wxPython.rsp

@@ -0,0 +1,38 @@
+wxPython\*.pyd
+wxPython\*.pyc
+wxPython\*.pyo
+wxPython\*.py
+wxPython\*.txt
+
+wxPython\tests\*.py
+wxPython\tests\bitmaps
+
+
+wxPython\src\*.i
+wxPython\src\*.py
+wxPython\src\*.cpp
+wxPython\src\*.h
+wxPython\src\*.ico
+wxPython\src\*.def
+wxPython\src\*.rc
+wxPython\src\makefile.*
+wxPython\src\Makefile.pre.in
+wxPython\src\Setup.in
+
+wxPython\src\msw\*.cpp
+wxPython\src\msw\*.h
+wxPython\src\msw\*.py
+
+wxPython\src\gtk\*.cpp
+wxPython\src\gtk\*.h
+wxPython\src\gtk\*.py
+
+wxPython\src\motif\*.cpp
+wxPython\src\motif\*.h
+wxPython\src\motif\*.py
+
+wxPython\src\qt\*.cpp
+wxPython\src\qt\*.h
+wxPython\src\qt\*.py
+
+

utils/wxPython/distrib/zipit.bat

@@ -0,0 +1,8 @@
+
+@echo off
+
+cd %WXWIN%\utils
+
+zip -@ -r wxPython\wxPython-%1.zip < wxPython\distrib\wxPython.rsp
+
+cd -

utils/wxPython/src/.cvsignore

@@ -0,0 +1,26 @@
+.emacs.desktop
+Makefile
+Makefile.pre
+Setup
+Setup.save
+Setup.save
+config.c
+make.bat
+sedscript
+templates
+transfer.zip
+vc50.pdb
+vc60.pdb
+wxPython.001
+wxPython.dsp
+wxPython.dsw
+wxPython.ncb
+wxPython.opt
+wxc.exp
+wxc.lib
+wxc.res
+wxp.pch
+wxpc.exp
+wxpc.lib
+wxpc.res
+wxpc.res.save

utils/wxPython/src/Makefile.pre.in

@@ -0,0 +1,389 @@
+# Universal Unix Makefile for Python extensions
+# =============================================
+
+# Short Instructions
+# ------------------
+
+# 1. Build and install Python (1.5 or newer).
+# 2. "make -f Makefile.pre.in boot"
+# 3. "make"
+# You should now have a shared library.
+
+# Long Instructions
+# -----------------
+
+# Build *and install* the basic Python 1.5 distribution.  See the
+# Python README for instructions.  (This version of Makefile.pre.in
+# only withs with Python 1.5, alpha 3 or newer.)
+
+# Create a file Setup.in for your extension.  This file follows the
+# format of the Modules/Setup.in file; see the instructions there.
+# For a simple module called "spam" on file "spammodule.c", it can
+# contain a single line:
+#   spam spammodule.c
+# You can build as many modules as you want in the same directory --
+# just have a separate line for each of them in the Setup.in file.
+
+# If you want to build your extension as a shared library, insert a
+# line containing just the string
+#   *shared*
+# at the top of your Setup.in file.
+
+# Note that the build process copies Setup.in to Setup, and then works
+# with Setup.  It doesn't overwrite Setup when Setup.in is changed, so
+# while you're in the process of debugging your Setup.in file, you may
+# want to edit Setup instead, and copy it back to Setup.in later.
+# (All this is done so you can distribute your extension easily and
+# someone else can select the modules they actually want to build by
+# commenting out lines in the Setup file, without editing the
+# original.  Editing Setup is also used to specify nonstandard
+# locations for include or library files.)
+
+# Copy this file (Misc/Makefile.pre.in) to the directory containing
+# your extension.
+
+# Run "make -f Makefile.pre.in boot".  This creates Makefile
+# (producing Makefile.pre and sedscript as intermediate files) and
+# config.c, incorporating the values for sys.prefix, sys.exec_prefix
+# and sys.version from the installed Python binary.  For this to work,
+# the python binary must be on your path.  If this fails, try
+#   make -f Makefile.pre.in Makefile VERSION=1.5 installdir=<prefix>
+# where <prefix> is the prefix used to install Python for installdir
+# (and possibly similar for exec_installdir=<exec_prefix>).
+
+# Note: "make boot" implies "make clobber" -- it assumes that when you
+# bootstrap you may have changed platforms so it removes all previous
+# output files.
+
+# If you are building your extension as a shared library (your
+# Setup.in file starts with *shared*), run "make" or "make sharedmods"
+# to build the shared library files.  If you are building a statically
+# linked Python binary (the only solution of your platform doesn't
+# support shared libraries, and sometimes handy if you want to
+# distribute or install the resulting Python binary), run "make
+# python".
+
+# Note: Each time you edit Makefile.pre.in or Setup, you must run
+# "make Makefile" before running "make".
+
+# Hint: if you want to use VPATH, you can start in an empty
+# subdirectory and say (e.g.):
+#   make -f ../Makefile.pre.in boot srcdir=.. VPATH=..
+
+
+# === Bootstrap variables (edited through "make boot") ===
+
+# The prefix used by "make inclinstall libainstall" of core python
+installdir=	/usr/local
+
+# The exec_prefix used by the same
+exec_installdir=$(installdir)
+
+# Source directory and VPATH in case you want to use VPATH.
+# (You will have to edit these two lines yourself -- there is no
+# automatic support as the Makefile is not generated by
+# config.status.)
+srcdir=		.
+VPATH=		.
+
+# === Variables that you may want to customize (rarely) ===
+
+# (Static) build target
+TARGET=		python
+
+# Installed python binary (used only by boot target)
+PYTHON=		python
+
+# Add more -I and -D options here
+CFLAGS=		$(OPT) -I$(INCLUDEPY) -I$(EXECINCLUDEPY) $(DEFS)
+
+# These two variables can be set in Setup to merge extensions.
+# See example[23].
+BASELIB=
+BASESETUP=
+
+# === Variables set by makesetup ===
+
+MODOBJS=	_MODOBJS_
+MODLIBS=	_MODLIBS_
+
+# === Definitions added by makesetup ===
+
+# === Variables from configure (through sedscript) ===
+
+VERSION=	@VERSION@
+CC=		@CC@
+LINKCC=		@LINKCC@
+SGI_ABI=	@SGI_ABI@
+OPT=		@OPT@
+LDFLAGS=	@LDFLAGS@
+LDLAST=		@LDLAST@
+DEFS=		@DEFS@
+LIBS=		@LIBS@
+LIBM=		@LIBM@
+LIBC=		@LIBC@
+RANLIB=		@RANLIB@
+MACHDEP=	@MACHDEP@
+SO=		@SO@
+LDSHARED=	@LDSHARED@
+CCSHARED=	@CCSHARED@
+LINKFORSHARED=	@LINKFORSHARED@
+#@SET_CCC@
+
+# Install prefix for architecture-independent files
+prefix=		/usr/local
+
+# Install prefix for architecture-dependent files
+exec_prefix=	$(prefix)
+
+# === Fixed definitions ===
+
+# Shell used by make (some versions default to the login shell, which is bad)
+SHELL=		/bin/sh
+
+# Expanded directories
+BINDIR=		$(exec_installdir)/bin
+LIBDIR=		$(exec_prefix)/lib
+MANDIR=		$(installdir)/man
+INCLUDEDIR=	$(installdir)/include
+SCRIPTDIR=	$(prefix)/lib
+
+# Detailed destination directories
+BINLIBDEST=	$(LIBDIR)/python$(VERSION)
+LIBDEST=	$(SCRIPTDIR)/python$(VERSION)
+INCLUDEPY=	$(INCLUDEDIR)/python$(VERSION)
+EXECINCLUDEPY=	$(exec_installdir)/include/python$(VERSION)
+LIBP=		$(exec_installdir)/lib/python$(VERSION)
+DESTSHARED=	$(BINLIBDEST)/site-packages
+
+LIBPL=		$(LIBP)/config
+
+PYTHONLIBS=	$(LIBPL)/libpython$(VERSION).a
+
+MAKESETUP=	$(LIBPL)/makesetup
+MAKEFILE=	$(LIBPL)/Makefile
+CONFIGC=	$(LIBPL)/config.c
+CONFIGCIN=	$(LIBPL)/config.c.in
+SETUP=		$(LIBPL)/Setup
+
+SYSLIBS=	$(LIBM) $(LIBC)
+
+ADDOBJS=	$(LIBPL)/python.o config.o
+
+# Portable install script (configure doesn't always guess right)
+INSTALL=	$(LIBPL)/install-sh -c
+# Shared libraries must be installed with executable mode on some systems;
+# rather than figuring out exactly which, we always give them executable mode.
+# Also, making them read-only seems to be a good idea...
+INSTALL_SHARED=	${INSTALL} -m 555
+
+#---------------------------------------------------
+# Possibly change some definintions for C++
+ifdef MY_LDSHARED
+LDSHARED=$(MY_LDSHARED)
+endif
+ifdef MY_LINKCC
+LINKCC=$(MY_LINKCC)
+endif
+
+
+# === Fixed rules ===
+
+# Default target.  This builds shared libraries only
+default:	sharedmods
+
+# Build everything
+all:		static sharedmods
+
+# Build shared libraries from our extension modules
+sharedmods:	$(SHAREDMODS)
+
+# Build a static Python binary containing our extension modules
+static:		$(TARGET)
+$(TARGET):	$(ADDOBJS) lib.a $(PYTHONLIBS) Makefile $(BASELIB)
+		$(LINKCC) $(LDFLAGS) $(LINKFORSHARED) \
+		 $(ADDOBJS) lib.a $(PYTHONLIBS) \
+		 $(LINKPATH) $(BASELIB) $(MODLIBS) $(LIBS) $(SYSLIBS) \
+		 -o $(TARGET) $(LDLAST)
+
+#------------------------------------------------------------------------
+#------------------------------------------------------------------------
+# This is a default version of the install target for wxPython.  It just
+# redirects to wxInstall below...
+
+install:	wxInstall
+
+#install:	sharedmods
+#		if test ! -d $(DESTSHARED) ; then \
+#			mkdir $(DESTSHARED) ; else true ; fi
+#		-for i in X $(SHAREDMODS); do \
+#			if test $$i != X; \
+#			then $(INSTALL_SHARED) $$i $(DESTSHARED)/$$i; \
+#			fi; \
+#		done
+
+
+# Build the library containing our extension modules
+lib.a:		$(MODOBJS)
+		-rm -f lib.a
+		ar cr lib.a $(MODOBJS)
+		-$(RANLIB) lib.a
+
+# This runs makesetup *twice* to use the BASESETUP definition from Setup
+config.c Makefile:	Makefile.pre Setup $(BASESETUP) $(MAKESETUP)
+		$(MAKESETUP) \
+		 -m Makefile.pre -c $(CONFIGCIN) Setup -n $(BASESETUP) $(SETUP)
+		$(MAKE) -f Makefile do-it-again
+
+# Internal target to run makesetup for the second time
+do-it-again:
+		$(MAKESETUP) \
+		 -m Makefile.pre -c $(CONFIGCIN) Setup -n $(BASESETUP) $(SETUP)
+
+# Make config.o from the config.c created by makesetup
+config.o:	config.c
+		$(CC) $(CFLAGS) -c config.c
+
+# Setup is copied from Setup.in *only* if it doesn't yet exist
+Setup:
+		cp Setup.in Setup
+
+# Make the intermediate Makefile.pre from Makefile.pre.in
+Makefile.pre: Makefile.pre.in sedscript
+		sed -f sedscript Makefile.pre.in >Makefile.pre
+
+# Shortcuts to make the sed arguments on one line
+P=prefix
+E=exec_prefix
+H=Generated automatically from Makefile.pre.in by sedscript.
+L=LINKFORSHARED
+
+# Make the sed script used to create Makefile.pre from Makefile.pre.in
+sedscript:	$(MAKEFILE)
+	sed -n \
+	 -e '1s/.*/1i\\/p' \
+	 -e '2s%.*%# $H%p' \
+	 -e '/^VERSION=/s/^VERSION=[ 	]*\(.*\)/s%@VERSION[@]%\1%/p' \
+	 -e '/^CC=/s/^CC=[ 	]*\(.*\)/s%@CC[@]%\1%/p' \
+	 -e '/^CCC=/s/^CCC=[ 	]*\(.*\)/s%#@SET_CCC[@]%CCC=\1%/p' \
+	 -e '/^LINKCC=/s/^LINKCC=[ 	]*\(.*\)/s%@LINKCC[@]%\1%/p' \
+	 -e '/^OPT=/s/^OPT=[ 	]*\(.*\)/s%@OPT[@]%\1%/p' \
+	 -e '/^LDFLAGS=/s/^LDFLAGS=[ 	]*\(.*\)/s%@LDFLAGS[@]%\1%/p' \
+	 -e '/^DEFS=/s/^DEFS=[ 	]*\(.*\)/s%@DEFS[@]%\1%/p' \
+	 -e '/^LIBS=/s/^LIBS=[ 	]*\(.*\)/s%@LIBS[@]%\1%/p' \
+	 -e '/^LIBM=/s/^LIBM=[ 	]*\(.*\)/s%@LIBM[@]%\1%/p' \
+	 -e '/^LIBC=/s/^LIBC=[ 	]*\(.*\)/s%@LIBC[@]%\1%/p' \
+	 -e '/^RANLIB=/s/^RANLIB=[ 	]*\(.*\)/s%@RANLIB[@]%\1%/p' \
+	 -e '/^MACHDEP=/s/^MACHDEP=[ 	]*\(.*\)/s%@MACHDEP[@]%\1%/p' \
+	 -e '/^SO=/s/^SO=[ 	]*\(.*\)/s%@SO[@]%\1%/p' \
+	 -e '/^LDSHARED=/s/^LDSHARED=[ 	]*\(.*\)/s%@LDSHARED[@]%\1%/p' \
+	 -e '/^CCSHARED=/s/^CCSHARED=[ 	]*\(.*\)/s%@CCSHARED[@]%\1%/p' \
+	 -e '/^$L=/s/^$L=[ 	]*\(.*\)/s%@$L[@]%\1%/p' \
+	 -e '/^$P=/s/^$P=\(.*\)/s%^$P=.*%$P=\1%/p' \
+	 -e '/^$E=/s/^$E=\(.*\)/s%^$E=.*%$E=\1%/p' \
+	 $(MAKEFILE) >sedscript
+	echo "/^#@SET_CCC@/d" >>sedscript
+	echo "/^installdir=/s%=.*%=	$(installdir)%" >>sedscript
+	echo "/^exec_installdir=/s%=.*%=$(exec_installdir)%" >>sedscript
+	echo "/^srcdir=/s%=.*%=		$(srcdir)%" >>sedscript
+	echo "/^VPATH=/s%=.*%=		$(VPATH)%" >>sedscript
+	echo "/^LINKPATH=/s%=.*%=	$(LINKPATH)%" >>sedscript
+	echo "/^BASELIB=/s%=.*%=	$(BASELIB)%" >>sedscript
+	echo "/^BASESETUP=/s%=.*%=	$(BASESETUP)%" >>sedscript
+
+# Bootstrap target
+boot:	clobber
+	VERSION=`$(PYTHON) -c "import sys; print sys.version[:3]"`; \
+	installdir=`$(PYTHON) -c "import sys; print sys.prefix"`; \
+	exec_installdir=`$(PYTHON) -c "import sys; print sys.exec_prefix"`; \
+	$(MAKE) -f Makefile.pre.in VPATH=$(VPATH) srcdir=$(srcdir) \
+		VERSION=$$VERSION \
+		installdir=$$installdir \
+		exec_installdir=$$exec_installdir \
+		Makefile
+
+# Handy target to remove intermediate files and backups
+clean:
+		-rm -f *.o *~
+
+# Handy target to remove everything that is easily regenerated
+clobber:	clean
+		-rm -f *.a tags TAGS config.c Makefile.pre $(TARGET) sedscript
+		-rm -f *.so *.sl so_locations
+
+
+# Handy target to remove everything you don't want to distribute
+distclean:	clobber
+		-rm -f Makefile Setup
+
+
+
+
+#------------------------------------------------------------------------
+#------------------------------------------------------------------------
+# Custom rules and dependencies added for wxPython
+#
+
+
+SWIGFLAGS=-c++ -shadow -python -dnone -D__WXGTK__
+
+
+PYMODULES = $(GENCODEDIR)/wx.py        $(GENCODEDIR)/events.py    \
+	    $(GENCODEDIR)/windows.py   $(GENCODEDIR)/misc.py      \
+	    $(GENCODEDIR)/gdi.py       $(GENCODEDIR)/mdi.py       \
+	    $(GENCODEDIR)/controls.py  $(GENCODEDIR)/controls2.py \
+            $(GENCODEDIR)/windows2.py  $(GENCODEDIR)/cmndlgs.py   \
+            $(GENCODEDIR)/frames.py    $(GENCODEDIR)/stattool.py   \
+	    $(GENCODEDIR)/utils.py     $(GENCODEDIR)/windows3.py  \
+	    __init__.py
+
+
+# Implicit rules to run SWIG
+$(GENCODEDIR)/%.cpp : %.i
+	swig $(SWIGFLAGS) -c -o $@ $<
+
+$(GENCODEDIR)/%.py : %.i
+	swig $(SWIGFLAGS) -c -o $@ $<
+
+
+# This one must leave out the -c flag so we define the whole rule
+$(GENCODEDIR)/wx.cpp $(GENCODEDIR)/wx.py : wx.i my_typemaps.i _defs.i _extras.py
+	swig $(SWIGFLAGS) -o $(GENCODEDIR)/wx.cpp wx.i
+
+
+# define some dependencies
+$(GENCODEDIR)/windows.cpp   $(GENCODEDIR)/windows.py   : windows.i    my_typemaps.i _defs.i
+$(GENCODEDIR)/windows2.cpp  $(GENCODEDIR)/windows2.py  : windows2.i   my_typemaps.i _defs.i
+$(GENCODEDIR)/windows3.cpp  $(GENCODEDIR)/windows3.py  : windows3.i   my_typemaps.i _defs.i
+$(GENCODEDIR)/events.cpp    $(GENCODEDIR)/events.py    : events.i     my_typemaps.i _defs.i
+$(GENCODEDIR)/misc.cpp      $(GENCODEDIR)/misc.py      : misc.i       my_typemaps.i _defs.i
+$(GENCODEDIR)/gdi.cpp       $(GENCODEDIR)/gdi.py       : gdi.i        my_typemaps.i _defs.i
+$(GENCODEDIR)/mdi.cpp       $(GENCODEDIR)/mdi.py       : mdi.i        my_typemaps.i _defs.i
+$(GENCODEDIR)/controls.cpp  $(GENCODEDIR)/controls.py  : controls.i   my_typemaps.i _defs.i
+$(GENCODEDIR)/controls2.cpp $(GENCODEDIR)/controls2.py : controls2.i  my_typemaps.i _defs.i
+$(GENCODEDIR)/cmndlgs.cpp   $(GENCODEDIR)/cmndlgs.py   : cmndlgs.i    my_typemaps.i _defs.i
+$(GENCODEDIR)/frames.cpp    $(GENCODEDIR)/frames.py    : frames.i     my_typemaps.i _defs.i
+$(GENCODEDIR)/stattool.cpp  $(GENCODEDIR)/stattool.py  : stattool.i   my_typemaps.i _defs.i
+$(GENCODEDIR)/utils.cpp     $(GENCODEDIR)/utils.py     : utils.i      my_typemaps.i _defs.i
+
+$(GENCODEDIR)/helpers.cpp:
+	ln -s `pwd`/helpers.cpp $@
+
+
+wxInstall :	sharedmods $(PYMODULES)
+	if test ! -d $(TARGETDIR) ; then \
+		mkdir $(TARGETDIR) ; else true ; fi
+	if [ "$(SHAREDMODS)" != "" ]; then \
+		 chmod 755 $(SHAREDMODS); \
+		 cp $(SHAREDMODS) $(TARGETDIR); fi
+	-for i in $(PYMODULES); do \
+		cp $$i $(TARGETDIR); \
+	done
+	python $(LIBDEST)/compileall.py -l $(TARGETDIR)
+	python -O $(LIBDEST)/compileall.py -l $(TARGETDIR)
+
+
+lib : libwxPython.a
+
+libwxPython.a : lib.a
+	cp $< $@

utils/wxPython/src/Setup.in

@@ -0,0 +1,44 @@
+# This file gives the details of what is needed to build this extension
+# module so the Makefile can be created.
+
+###
+### This file should be created by configure.  Currently it is tweaked by hand.
+###
+
+*shared*
+
+CCC=c++
+WXWIN=../../..
+GENCODEDIR=gtk
+srcdir=$(GENCODEDIR)
+
+# Depending on how your Python was built, you may have to set this
+# value to use the C++ driver to link with instead of the default
+# C driver.  For example:
+MY_LDSHARED=$(CCC) -shared
+
+# Same as above, but for statically linking Python and wxPython together,
+# in other words, if you comment out the *shared* above.  If this is the
+# case then you should ensure that the main() function is Python's, not
+# wxWindows'.  You can rebuild $(WXWIN)/src/gtk/app.cpp with NOMAIN defined
+# to force this...
+MY_LINKCC=$(CCC)
+
+
+## Pick one of these, or set your own.  This is where the
+## wxPython module should be installed.  It should be a
+## subdirectory named wxPython.
+TARGETDIR=..
+#TARGETDIR=$(BINLIBDEST)/site-packages/wxPython
+
+
+wxc	wx.cpp helpers.cpp windows.cpp events.cpp misc.cpp gdi.cpp \
+	mdi.cpp controls.cpp controls2.cpp windows2.cpp cmndlgs.cpp \
+	frames.cpp stattool.cpp utils.cpp windows3.cpp \
+	# CFLAGS
+	-I. -I$(WXWIN)/include -I/usr/lib/glib/include -I$(WXWIN)/src \
+	-I/usr/X11R6/include -DSWIG_GLOBAL -D__WXGTK__ \
+	#-D__WXDEBUG__ \
+	# LFLAGS
+	-L$(WXWIN)/lib/Linux -L/usr/X11R6/lib \
+	-lwx_gtk2 -lgtk -lgdk -lglib -lXext -lX11

utils/wxPython/src/Setup.in.linux

@@ -0,0 +1,44 @@
+# This file gives the details of what is needed to build this extension
+# module so the Makefile can be created.
+
+###
+### This file should be created by configure.  Currently it is tweaked by hand.
+###
+
+*shared*
+
+CCC=c++
+WXWIN=../../..
+GENCODEDIR=gtk
+srcdir=$(GENCODEDIR)
+
+# Depending on how your Python was built, you may have to set this
+# value to use the C++ driver to link with instead of the default
+# C driver.  For example:
+MY_LDSHARED=$(CCC) -shared
+
+# Same as above, but for statically linking Python and wxPython together,
+# in other words, if you comment out the *shared* above.  If this is the
+# case then you should ensure that the main() function is Python's, not
+# wxWindows'.  You can rebuild $(WXWIN)/src/gtk/app.cpp with NOMAIN defined
+# to force this...
+MY_LINKCC=$(CCC)
+
+
+## Pick one of these, or set your own.  This is where the
+## wxPython module should be installed.  It should be a
+## subdirectory named wxPython.
+TARGETDIR=..
+#TARGETDIR=$(BINLIBDEST)/site-packages/wxPython
+
+
+wxc	wx.cpp helpers.cpp windows.cpp events.cpp misc.cpp gdi.cpp \
+	mdi.cpp controls.cpp controls2.cpp windows2.cpp cmndlgs.cpp \
+	frames.cpp stattool.cpp utils.cpp windows3.cpp \
+	# CFLAGS
+	-I. -I$(WXWIN)/include -I/usr/lib/glib/include -I$(WXWIN)/src \
+	-I/usr/X11R6/include -DSWIG_GLOBAL -D__WXGTK__ \
+	#-D__WXDEBUG__ \
+	# LFLAGS
+	-L$(WXWIN)/lib/Linux -L/usr/X11R6/lib \
+	-lwx_gtk2 -lgtk -lgdk -lglib -lXext -lX11

utils/wxPython/src/Setup.in.solaris

@@ -0,0 +1,45 @@
+# This file gives the details of what is needed to build this extension
+# module so the Makefile can be created.
+
+###
+### This file should be created by configure.  Currently it is tweaked by hand.
+###
+
+#*shared*
+
+CCC=c++
+WXWIN=../../..
+GENCODEDIR=gtk
+srcdir=$(GENCODEDIR)
+
+# Depending on how your Python was built, you may have to set this
+# value to use the C++ driver to link with instead of the default
+# C driver.  For example:
+#MY_LDSHARED=$(CCC) -shared
+
+# Same as above, but for statically linking Python and wxPython together,
+# in other words, if you comment out the *shared* above.  If this is the
+# case then you should ensure that the main() function is Python's, not
+# wxWindows'.  You can rebuild $(WXWIN)/src/gtk/app.cpp with NOMAIN defined
+# to force this...
+MY_LINKCC=$(CCC)
+
+
+## Pick one of these, or set your own.  This is where the
+## wxPython module should be installed.  It should be a
+## subdirectory named wxPython.
+TARGETDIR=..
+#TARGETDIR=$(BINLIBDEST)/site-packages/wxPython
+
+
+wxc 	wx.cpp helpers.cpp windows.cpp events.cpp misc.cpp gdi.cpp \
+	mdi.cpp controls.cpp controls2.cpp windows2.cpp cmndlgs.cpp \
+	frames.cpp stattool.cpp utils.cpp windows3.cpp \
+	# CFLAGS
+	-I. -I$(WXWIN)/include -I/usr/local/lib/glib/include -I$(WXWIN)/src \
+	-I/usr/X/include -DSWIG_GLOBAL -D__WXGTK__ \
+	#-D__WXDEBUG__ \
+	# LFLAGS
+	-L$(WXWIN)/lib/solaris2.6 -L/usr/X/lib \
+	-L/usr/local/lib/gcc-lib/sparc-sun-solaris2.6/2.8.1 \
+	-lwx_gtk2 -lgtk -lgdk -lglib -lXext -lX11 -lstdc++ -lgcc

utils/wxPython/src/__init__.py

@@ -0,0 +1,43 @@
+#----------------------------------------------------------------------------
+# Name:         __init__.py
+# Purpose:      The presence of this file turns this directory into a
+#               Python package.
+#
+# Author:       Robin Dunn
+#
+# Created:      8/8/98
+# RCS-ID:       $Id$
+# Copyright:    (c) 1998 by Total Control Software
+# Licence:      wxWindows license
+#----------------------------------------------------------------------------
+
+
+#----------------------------------------------------------------------------
+#
+# $Log$
+# Revision 1.3  1998/12/15 20:41:12  RD
+# Changed the import semantics from "from wxPython import *" to "from
+# wxPython.wx import *"  This is for people who are worried about
+# namespace pollution, they can use "from wxPython import wx" and then
+# prefix all the wxPython identifiers with "wx."
+#
+# Added wxTaskbarIcon for wxMSW.
+#
+# Made the events work for wxGrid.
+#
+# Added wxConfig.
+#
+# Added wxMiniFrame for wxGTK, (untested.)
+#
+# Changed many of the args and return values that were pointers to gdi
+# objects to references to reflect changes in the wxWindows API.
+#
+# Other assorted fixes and additions.
+#
+# Revision 1.2  1998/10/07 07:34:32  RD
+# Version 0.4.1 for wxGTK
+#
+# Revision 1.1  1998/08/09 08:25:49  RD
+# Initial version
+#
+#

utils/wxPython/src/_defs.i

@@ -0,0 +1,763 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        _defs.i
+// Purpose:     Definitions and stuff
+//
+// Author:      Robin Dunn
+//
+// Created:     6/24/97
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998 by Total Control Software
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+//---------------------------------------------------------------------------
+// Forward declares...
+
+class wxPyApp;
+class wxEvtHandler;
+class wxWindow;
+class wxFrame;
+class wxMiniFrame;
+class wxPanel;
+class wxDialog;
+class wxMenu;
+class wxPyMenu;
+class wxMenuBar;
+class wxMenuItem;
+class wxEvent;
+class wxSizeEvent;
+class wxCloseEvent;
+class wxCommandEvent;
+class wxScrollEvent;
+class wxMouseEvent;
+class wxKeyEvent;
+class wxMoveEvent;
+class wxPaintEvent;
+class wxEraseEvent;
+class wxFocusEvent;
+class wxActivateEvent;
+class wxInitDialogEvent;
+class wxMenuEvent;
+class wxShowEvent;
+class wxIconizeEvent;
+class wxMaximizeEvent;
+class wxJoystickEvent;
+class wxDropFilesEvent;
+class wxIdleEvent;
+class wxUpdateUIEvent;
+class wxSysColourChangedEvent;
+class wxSize;
+class wxRealPoint;
+class wxPoint;
+class wxRect;
+class wxBitmap;
+class wxMask;
+class wxIcon;
+class wxCursor;
+class wxFont;
+class wxColour;
+class wxPen;
+class wxBrush;
+class wxDC;
+class wxMemoryDC;
+class wxScreenDC;
+class wxClientDC;
+class wxPaintDC;
+class wxPostScriptDC;
+class wxPrinterDC;
+class wxMetaFileDC;
+class wxMDIParentFrame;
+class wxMDIChildFrame;
+class wxMDIClientWindow;
+class wxControl;
+class wxButton;
+class wxBitmapButton;
+class wxCheckBox;
+class wxChoice;
+class wxComboBox;
+class wxGauge;
+class wxStaticBox;
+class wxStaticText;
+class wxListBox;
+class wxTextCtrl;
+class wxScrollBar;
+class wxSpinButton;
+class wxStaticBitmap;
+class wxRadioBox;
+class wxRadioButton;
+class wxSlider;
+
+class wxPyTimer;
+class wxIndividualLayoutConstraint;
+class wxLayoutConstraints;
+class wxToolBar;
+class wxStatusBar;
+
+//---------------------------------------------------------------------------
+
+// some definitions for SWIG only
+typedef unsigned char   byte;
+typedef short int       WXTYPE;
+typedef int             wxWindowID;
+typedef unsigned int    uint;
+typedef signed   int    EBool;
+
+
+//---------------------------------------------------------------------------
+
+// General numeric #define's and etc.  Making them all enums makes SWIG use the
+// real macro when making the Python Int
+
+enum {
+    wxMAJOR_VERSION,
+    wxMINOR_VERSION,
+    wxRELEASE_NUMBER,
+
+    wxNOT_FOUND,
+
+    wxVSCROLL,
+    wxHSCROLL,
+    wxCAPTION,
+    wxDOUBLE_BORDER,
+    wxSUNKEN_BORDER,
+    wxRAISED_BORDER,
+    wxBORDER,
+    wxSIMPLE_BORDER,
+    wxSTATIC_BORDER,
+    wxTRANSPARENT_WINDOW,
+    wxNO_BORDER,
+    wxUSER_COLOURS,
+    wxNO_3D,
+//wxOVERRIDE_KEY_TRANSLATIONS,
+    wxTAB_TRAVERSAL,
+    wxHORIZONTAL,
+    wxVERTICAL,
+    wxBOTH,
+    wxCENTER_FRAME,
+    wxSTAY_ON_TOP,
+    wxICONIZE,
+    wxMINIMIZE,
+    wxMAXIMIZE,
+    wxTHICK_FRAME,
+    wxSYSTEM_MENU,
+    wxMINIMIZE_BOX,
+    wxMAXIMIZE_BOX,
+    wxTINY_CAPTION_HORIZ,
+    wxTINY_CAPTION_VERT,
+    wxRESIZE_BOX,
+    wxRESIZE_BORDER,
+    wxDIALOG_MODAL,
+    wxDIALOG_MODELESS,
+    wxDEFAULT_FRAME_STYLE,
+    wxDEFAULT_DIALOG_STYLE,
+
+    wxFRAME_TOOL_WINDOW,
+    wxCLIP_CHILDREN,
+
+    wxRETAINED,
+    wxBACKINGSTORE,
+    wxTB_3DBUTTONS,
+    wxTB_HORIZONTAL,
+    wxTB_VERTICAL,
+    wxTB_FLAT,
+    wxCOLOURED,
+    wxFIXED_LENGTH,
+    wxALIGN_LEFT,
+    wxALIGN_CENTER,
+    wxALIGN_CENTRE,
+    wxALIGN_RIGHT,
+    wxLB_NEEDED_SB,
+    wxLB_ALWAYS_SB,
+    wxLB_SORT,
+    wxLB_SINGLE,
+    wxLB_MULTIPLE,
+    wxLB_EXTENDED,
+    wxLB_OWNERDRAW,
+    wxLB_HSCROLL,
+    wxPROCESS_ENTER,
+    wxPASSWORD,
+    wxTE_PROCESS_ENTER,
+    wxTE_PASSWORD,
+    wxTE_READONLY,
+    wxTE_MULTILINE,
+    wxCB_SIMPLE,
+    wxCB_DROPDOWN,
+    wxCB_SORT,
+    wxCB_READONLY,
+    wxRA_HORIZONTAL,
+    wxRA_VERTICAL,
+    wxRB_GROUP,
+    wxGA_PROGRESSBAR,
+    wxGA_HORIZONTAL,
+    wxGA_VERTICAL,
+    wxSL_HORIZONTAL,
+    wxSL_VERTICAL,
+    wxSL_AUTOTICKS,
+    wxSL_LABELS,
+    wxSL_LEFT,
+    wxSL_TOP,
+    wxSL_RIGHT,
+    wxSL_BOTTOM,
+    wxSL_BOTH,
+    wxSL_SELRANGE,
+    wxSB_HORIZONTAL,
+    wxSB_VERTICAL,
+    wxBU_AUTODRAW,
+    wxBU_NOAUTODRAW,
+    wxTR_HAS_BUTTONS,
+    wxTR_EDIT_LABELS,
+    wxTR_LINES_AT_ROOT,
+    wxLC_ICON,
+    wxLC_SMALL_ICON,
+    wxLC_LIST,
+    wxLC_REPORT,
+    wxLC_ALIGN_TOP,
+    wxLC_ALIGN_LEFT,
+    wxLC_AUTOARRANGE,
+    wxLC_USER_TEXT,
+    wxLC_EDIT_LABELS,
+    wxLC_NO_HEADER,
+    wxLC_NO_SORT_HEADER,
+    wxLC_SINGLE_SEL,
+    wxLC_SORT_ASCENDING,
+    wxLC_SORT_DESCENDING,
+    wxLC_MASK_TYPE,
+    wxLC_MASK_ALIGN,
+    wxLC_MASK_SORT,
+    wxSP_VERTICAL,
+    wxSP_HORIZONTAL,
+    wxSP_ARROW_KEYS,
+    wxSP_WRAP,
+    wxSP_NOBORDER,
+    wxSP_3D,
+    wxSP_BORDER,
+    wxTAB_MULTILINE,
+    wxTAB_RIGHTJUSTIFY,
+    wxTAB_FIXEDWIDTH,
+    wxTAB_OWNERDRAW,
+//    wxSB_SIZEGRIP,
+    wxFLOOD_SURFACE,
+    wxFLOOD_BORDER,
+    wxODDEVEN_RULE,
+    wxWINDING_RULE,
+    wxTOOL_TOP,
+    wxTOOL_BOTTOM,
+    wxTOOL_LEFT,
+    wxTOOL_RIGHT,
+    wxOK,
+    wxYES_NO,
+    wxCANCEL,
+    wxYES,
+    wxNO,
+    wxICON_EXCLAMATION,
+    wxICON_HAND,
+    wxICON_QUESTION,
+    wxICON_INFORMATION,
+    wxICON_STOP,
+    wxICON_ASTERISK,
+    wxICON_MASK,
+    wxCENTRE,
+    wxCENTER,
+    wxSIZE_AUTO_WIDTH,
+    wxSIZE_AUTO_HEIGHT,
+    wxSIZE_AUTO,
+    wxSIZE_USE_EXISTING,
+    wxSIZE_ALLOW_MINUS_ONE,
+#ifndef __WXGTK__
+    wxDF_TEXT,
+    wxDF_BITMAP,
+    wxDF_METAFILE,
+    wxDF_DIB,
+    wxDF_OEMTEXT,
+    wxDF_FILENAME,
+#endif
+    wxPORTRAIT,
+    wxLANDSCAPE,
+    wxID_OPEN,
+    wxID_CLOSE,
+    wxID_NEW,
+    wxID_SAVE,
+    wxID_SAVEAS,
+    wxID_REVERT,
+    wxID_EXIT,
+    wxID_UNDO,
+    wxID_REDO,
+    wxID_HELP,
+    wxID_PRINT,
+    wxID_PRINT_SETUP,
+    wxID_PREVIEW,
+    wxID_ABOUT,
+    wxID_HELP_CONTENTS,
+    wxID_HELP_COMMANDS,
+    wxID_HELP_PROCEDURES,
+    wxID_HELP_CONTEXT,
+    wxID_CUT,
+    wxID_COPY,
+    wxID_PASTE,
+    wxID_CLEAR,
+    wxID_FIND,
+    wxID_FILE1,
+    wxID_FILE2,
+    wxID_FILE3,
+    wxID_FILE4,
+    wxID_FILE5,
+    wxID_FILE6,
+    wxID_FILE7,
+    wxID_FILE8,
+    wxID_FILE9,
+    wxID_OK,
+    wxID_CANCEL,
+    wxID_APPLY,
+    wxID_YES,
+    wxID_NO,
+    wxBITMAP_TYPE_BMP,
+    wxBITMAP_TYPE_BMP_RESOURCE,
+    wxBITMAP_TYPE_ICO,
+    wxBITMAP_TYPE_ICO_RESOURCE,
+    wxBITMAP_TYPE_CUR,
+    wxBITMAP_TYPE_CUR_RESOURCE,
+    wxBITMAP_TYPE_XBM,
+    wxBITMAP_TYPE_XBM_DATA,
+    wxBITMAP_TYPE_XPM,
+    wxBITMAP_TYPE_XPM_DATA,
+    wxBITMAP_TYPE_TIF,
+    wxBITMAP_TYPE_TIF_RESOURCE,
+    wxBITMAP_TYPE_GIF,
+    wxBITMAP_TYPE_GIF_RESOURCE,
+    wxBITMAP_TYPE_PNG,
+    wxBITMAP_TYPE_PNG_RESOURCE,
+    wxBITMAP_TYPE_ANY,
+    wxBITMAP_TYPE_RESOURCE,
+
+    wxOPEN,
+    wxSAVE,
+    wxHIDE_READONLY,
+    wxOVERWRITE_PROMPT,
+
+    wxACCEL_ALT,
+    wxACCEL_CTRL,
+    wxACCEL_SHIFT,
+};
+
+
+/// Standard error codes
+enum  ErrCode
+{
+  ERR_PARAM = (-4000),
+  ERR_NODATA,
+  ERR_CANCEL,
+  ERR_SUCCESS = 0
+};
+
+
+enum {
+  wxDEFAULT ,
+  wxDECORATIVE,
+  wxROMAN,
+  wxSCRIPT,
+  wxSWISS,
+  wxMODERN,
+  wxTELETYPE,
+  wxVARIABLE,
+  wxFIXED,
+  wxNORMAL,
+  wxLIGHT,
+  wxBOLD,
+  wxITALIC,
+  wxSLANT,
+  wxSOLID,
+  wxDOT,
+  wxLONG_DASH,
+  wxSHORT_DASH,
+  wxDOT_DASH,
+  wxUSER_DASH,
+  wxTRANSPARENT,
+  wxSTIPPLE,
+  wxBDIAGONAL_HATCH,
+  wxCROSSDIAG_HATCH,
+  wxFDIAGONAL_HATCH,
+  wxCROSS_HATCH,
+  wxHORIZONTAL_HATCH,
+  wxVERTICAL_HATCH,
+  wxJOIN_BEVEL,
+  wxJOIN_MITER,
+  wxJOIN_ROUND,
+  wxCAP_ROUND,
+  wxCAP_PROJECTING,
+  wxCAP_BUTT
+};
+
+typedef enum {
+  wxCLEAR,      // 0
+  wxXOR,        // src XOR dst
+  wxINVERT,     // NOT dst
+  wxOR_REVERSE, // src OR (NOT dst)
+  wxAND_REVERSE,// src AND (NOT dst)
+  wxCOPY,       // src
+  wxAND,        // src AND dst
+  wxAND_INVERT, // (NOT src) AND dst
+  wxNO_OP,      // dst
+  wxNOR,        // (NOT src) AND (NOT dst)
+  wxEQUIV,      // (NOT src) XOR dst
+  wxSRC_INVERT, // (NOT src)
+  wxOR_INVERT,  // (NOT src) OR dst
+  wxNAND,       // (NOT src) OR (NOT dst)
+  wxOR,         // src OR dst
+  wxSET,        // 1
+  wxSRC_OR,     // source _bitmap_ OR destination
+  wxSRC_AND     // source _bitmap_ AND destination
+} form_ops_t;
+
+enum _Virtual_keycodes {
+ WXK_BACK    =   8,
+ WXK_TAB     =   9,
+ WXK_RETURN  =	13,
+ WXK_ESCAPE  =	27,
+ WXK_SPACE   =	32,
+ WXK_DELETE  = 127,
+
+ WXK_START   = 300,
+ WXK_LBUTTON,
+ WXK_RBUTTON,
+ WXK_CANCEL,
+ WXK_MBUTTON,
+ WXK_CLEAR,
+ WXK_SHIFT,
+ WXK_CONTROL,
+ WXK_MENU,
+ WXK_PAUSE,
+ WXK_CAPITAL,
+ WXK_PRIOR,  // Page up
+ WXK_NEXT,   // Page down
+ WXK_END,
+ WXK_HOME,
+ WXK_LEFT,
+ WXK_UP,
+ WXK_RIGHT,
+ WXK_DOWN,
+ WXK_SELECT,
+ WXK_PRINT,
+ WXK_EXECUTE,
+ WXK_SNAPSHOT,
+ WXK_INSERT,
+ WXK_HELP,
+ WXK_NUMPAD0,
+ WXK_NUMPAD1,
+ WXK_NUMPAD2,
+ WXK_NUMPAD3,
+ WXK_NUMPAD4,
+ WXK_NUMPAD5,
+ WXK_NUMPAD6,
+ WXK_NUMPAD7,
+ WXK_NUMPAD8,
+ WXK_NUMPAD9,
+ WXK_MULTIPLY,
+ WXK_ADD,
+ WXK_SEPARATOR,
+ WXK_SUBTRACT,
+ WXK_DECIMAL,
+ WXK_DIVIDE,
+ WXK_F1,
+ WXK_F2,
+ WXK_F3,
+ WXK_F4,
+ WXK_F5,
+ WXK_F6,
+ WXK_F7,
+ WXK_F8,
+ WXK_F9,
+ WXK_F10,
+ WXK_F11,
+ WXK_F12,
+ WXK_F13,
+ WXK_F14,
+ WXK_F15,
+ WXK_F16,
+ WXK_F17,
+ WXK_F18,
+ WXK_F19,
+ WXK_F20,
+ WXK_F21,
+ WXK_F22,
+ WXK_F23,
+ WXK_F24,
+ WXK_NUMLOCK,
+ WXK_SCROLL,
+ WXK_PAGEUP,
+ WXK_PAGEDOWN
+};
+
+typedef enum {
+ wxCURSOR_NONE = 0,
+ wxCURSOR_ARROW =  1,
+ wxCURSOR_BULLSEYE,
+ wxCURSOR_CHAR,
+ wxCURSOR_CROSS,
+ wxCURSOR_HAND,
+ wxCURSOR_IBEAM,
+ wxCURSOR_LEFT_BUTTON,
+ wxCURSOR_MAGNIFIER,
+ wxCURSOR_MIDDLE_BUTTON,
+ wxCURSOR_NO_ENTRY,
+ wxCURSOR_PAINT_BRUSH,
+ wxCURSOR_PENCIL,
+ wxCURSOR_POINT_LEFT,
+ wxCURSOR_POINT_RIGHT,
+ wxCURSOR_QUESTION_ARROW,
+ wxCURSOR_RIGHT_BUTTON,
+ wxCURSOR_SIZENESW,
+ wxCURSOR_SIZENS,
+ wxCURSOR_SIZENWSE,
+ wxCURSOR_SIZEWE,
+ wxCURSOR_SIZING,
+ wxCURSOR_SPRAYCAN,
+ wxCURSOR_WAIT,
+ wxCURSOR_WATCH,
+ wxCURSOR_BLANK
+//  #ifndef __WXMSW__
+//    /* Not yet implemented for Windows */
+//    , wxCURSOR_CROSS_REVERSE,
+//    wxCURSOR_DOUBLE_ARROW,
+//    wxCURSOR_BASED_ARROW_UP,
+//    wxCURSOR_BASED_ARROW_DOWN
+//  #endif
+} _standard_cursors_t;
+
+
+#define FALSE 0
+#define false 0
+#define TRUE 1
+#define true 1
+
+
+//---------------------------------------------------------------------------
+//---------------------------------------------------------------------------
+
+/*
+ * Event types
+ *
+ */
+enum wxEventType {
+ wxEVT_NULL = 0,
+ wxEVT_FIRST = 10000,
+
+ // New names
+ wxEVT_COMMAND_BUTTON_CLICKED,
+ wxEVT_COMMAND_CHECKBOX_CLICKED,
+ wxEVT_COMMAND_CHOICE_SELECTED,
+ wxEVT_COMMAND_LISTBOX_SELECTED,
+ wxEVT_COMMAND_LISTBOX_DOUBLECLICKED,
+ wxEVT_COMMAND_CHECKLISTBOX_TOGGLED,
+ wxEVT_COMMAND_TEXT_UPDATED,
+ wxEVT_COMMAND_TEXT_ENTER,
+ wxEVT_COMMAND_MENU_SELECTED,
+ wxEVT_COMMAND_SLIDER_UPDATED,
+ wxEVT_COMMAND_RADIOBOX_SELECTED,
+ wxEVT_COMMAND_RADIOBUTTON_SELECTED,
+// wxEVT_COMMAND_SCROLLBAR_UPDATED is now obsolete since we use wxEVT_SCROLL... events
+ wxEVT_COMMAND_SCROLLBAR_UPDATED,
+ wxEVT_COMMAND_VLBOX_SELECTED,
+ wxEVT_COMMAND_COMBOBOX_SELECTED,
+ wxEVT_COMMAND_TOOL_CLICKED,
+ wxEVT_COMMAND_TOOL_RCLICKED,
+ wxEVT_COMMAND_TOOL_ENTER,
+ wxEVT_SET_FOCUS,
+ wxEVT_KILL_FOCUS,
+
+/* Mouse event types */
+ wxEVT_LEFT_DOWN,
+ wxEVT_LEFT_UP,
+ wxEVT_MIDDLE_DOWN,
+ wxEVT_MIDDLE_UP,
+ wxEVT_RIGHT_DOWN,
+ wxEVT_RIGHT_UP,
+ wxEVT_MOTION,
+ wxEVT_ENTER_WINDOW,
+ wxEVT_LEAVE_WINDOW,
+ wxEVT_LEFT_DCLICK,
+ wxEVT_MIDDLE_DCLICK,
+ wxEVT_RIGHT_DCLICK,
+
+ // Non-client mouse events
+ wxEVT_NC_LEFT_DOWN = wxEVT_FIRST + 100,
+ wxEVT_NC_LEFT_UP,
+ wxEVT_NC_MIDDLE_DOWN,
+ wxEVT_NC_MIDDLE_UP,
+ wxEVT_NC_RIGHT_DOWN,
+ wxEVT_NC_RIGHT_UP,
+ wxEVT_NC_MOTION,
+ wxEVT_NC_ENTER_WINDOW,
+ wxEVT_NC_LEAVE_WINDOW,
+ wxEVT_NC_LEFT_DCLICK,
+ wxEVT_NC_MIDDLE_DCLICK,
+ wxEVT_NC_RIGHT_DCLICK,
+
+/* Character input event type  */
+ wxEVT_CHAR,
+
+ /*
+  * Scrollbar event identifiers
+  */
+ wxEVT_SCROLL_TOP,
+ wxEVT_SCROLL_BOTTOM,
+ wxEVT_SCROLL_LINEUP,
+ wxEVT_SCROLL_LINEDOWN,
+ wxEVT_SCROLL_PAGEUP,
+ wxEVT_SCROLL_PAGEDOWN,
+ wxEVT_SCROLL_THUMBTRACK,
+
+ wxEVT_SIZE = wxEVT_FIRST + 200,
+ wxEVT_MOVE,
+ wxEVT_CLOSE_WINDOW,
+ wxEVT_END_SESSION,
+ wxEVT_QUERY_END_SESSION,
+ wxEVT_ACTIVATE_APP,
+ wxEVT_POWER,
+ wxEVT_CHAR_HOOK,
+ wxEVT_KEY_UP,
+ wxEVT_ACTIVATE,
+ wxEVT_CREATE,
+ wxEVT_DESTROY,
+ wxEVT_SHOW,
+ wxEVT_ICONIZE,
+ wxEVT_MAXIMIZE,
+ wxEVT_MOUSE_CAPTURE_CHANGED,
+ wxEVT_PAINT,
+ wxEVT_ERASE_BACKGROUND,
+ wxEVT_NC_PAINT,
+ wxEVT_PAINT_ICON,
+ wxEVT_MENU_CHAR,
+ wxEVT_MENU_INIT,
+ wxEVT_MENU_HIGHLIGHT,
+ wxEVT_POPUP_MENU_INIT,
+ wxEVT_CONTEXT_MENU,
+ wxEVT_SYS_COLOUR_CHANGED,
+ wxEVT_SETTING_CHANGED,
+ wxEVT_QUERY_NEW_PALETTE,
+ wxEVT_PALETTE_CHANGED,
+ wxEVT_JOY_BUTTON_DOWN,
+ wxEVT_JOY_BUTTON_UP,
+ wxEVT_JOY_MOVE,
+ wxEVT_JOY_ZMOVE,
+ wxEVT_DROP_FILES,
+ wxEVT_DRAW_ITEM,
+ wxEVT_MEASURE_ITEM,
+ wxEVT_COMPARE_ITEM,
+ wxEVT_INIT_DIALOG,
+ wxEVT_IDLE,
+ wxEVT_UPDATE_UI,
+
+ /* Generic command events */
+ // Note: a click is a higher-level event
+ // than button down/up
+ wxEVT_COMMAND_LEFT_CLICK,
+ wxEVT_COMMAND_LEFT_DCLICK,
+ wxEVT_COMMAND_RIGHT_CLICK,
+ wxEVT_COMMAND_RIGHT_DCLICK,
+ wxEVT_COMMAND_SET_FOCUS,
+ wxEVT_COMMAND_KILL_FOCUS,
+ wxEVT_COMMAND_ENTER,
+
+ /* Tree control event types */
+ wxEVT_COMMAND_TREE_BEGIN_DRAG,
+ wxEVT_COMMAND_TREE_BEGIN_RDRAG,
+ wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT,
+ wxEVT_COMMAND_TREE_END_LABEL_EDIT,
+ wxEVT_COMMAND_TREE_DELETE_ITEM,
+ wxEVT_COMMAND_TREE_GET_INFO,
+ wxEVT_COMMAND_TREE_SET_INFO,
+ wxEVT_COMMAND_TREE_ITEM_EXPANDED,
+ wxEVT_COMMAND_TREE_ITEM_EXPANDING,
+ wxEVT_COMMAND_TREE_ITEM_COLLAPSED,
+ wxEVT_COMMAND_TREE_ITEM_COLLAPSING,
+ wxEVT_COMMAND_TREE_SEL_CHANGED,
+ wxEVT_COMMAND_TREE_SEL_CHANGING,
+ wxEVT_COMMAND_TREE_KEY_DOWN,
+
+ /* List control event types */
+ wxEVT_COMMAND_LIST_BEGIN_DRAG,
+ wxEVT_COMMAND_LIST_BEGIN_RDRAG,
+ wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT,
+ wxEVT_COMMAND_LIST_END_LABEL_EDIT,
+ wxEVT_COMMAND_LIST_DELETE_ITEM,
+ wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS,
+ wxEVT_COMMAND_LIST_GET_INFO,
+ wxEVT_COMMAND_LIST_SET_INFO,
+ wxEVT_COMMAND_LIST_ITEM_SELECTED,
+ wxEVT_COMMAND_LIST_ITEM_DESELECTED,
+ wxEVT_COMMAND_LIST_KEY_DOWN,
+ wxEVT_COMMAND_LIST_INSERT_ITEM,
+ wxEVT_COMMAND_LIST_COL_CLICK,
+
+ /* Tab and notebook control event types */
+ wxEVT_COMMAND_TAB_SEL_CHANGED,
+ wxEVT_COMMAND_TAB_SEL_CHANGING,
+ wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED,
+ wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING
+
+};
+
+
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// $Log$
+// Revision 1.10  1999/01/30 07:30:08  RD
+// Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
+//
+// Various cleanup, tweaks, minor additions, etc. to maintain
+// compatibility with the current wxWindows.
+//
+// Revision 1.9  1998/12/15 20:41:13  RD
+// Changed the import semantics from "from wxPython import *" to "from
+// wxPython.wx import *"  This is for people who are worried about
+// namespace pollution, they can use "from wxPython import wx" and then
+// prefix all the wxPython identifiers with "wx."
+//
+// Added wxTaskbarIcon for wxMSW.
+//
+// Made the events work for wxGrid.
+//
+// Added wxConfig.
+//
+// Added wxMiniFrame for wxGTK, (untested.)
+//
+// Changed many of the args and return values that were pointers to gdi
+// objects to references to reflect changes in the wxWindows API.
+//
+// Other assorted fixes and additions.
+//
+// Revision 1.8  1998/11/15 23:03:42  RD
+// Removing some ifdef's for wxGTK
+//
+// Revision 1.7  1998/11/11 03:12:24  RD
+//
+// Additions for wxTreeCtrl
+//
+// Revision 1.6  1998/10/20 06:43:53  RD
+// New wxTreeCtrl wrappers (untested)
+// some changes in helpers
+// etc.
+//
+// Revision 1.5  1998/10/02 06:40:32  RD
+//
+// Version 0.4 of wxPython for MSW.
+//
+// Revision 1.4  1998/08/18 19:48:11  RD
+// more wxGTK compatibility things.
+//
+// It builds now but there are serious runtime problems...
+//
+// Revision 1.3  1998/08/14 23:36:33  RD
+// Beginings of wxGTK compatibility
+//
+// Revision 1.2  1998/08/14 03:16:35  RD
+// removed some definitions that got removed from defs.h
+//
+// Revision 1.1  1998/08/09 08:25:49  RD
+// Initial version
+//
+//

utils/wxPython/src/_extras.py

@@ -0,0 +1,619 @@
+#----------------------------------------------------------------------------
+# Name:         _extra.py
+# Purpose:	This file is appended to the shadow class file generated
+#               by SWIG.  We add some unSWIGable things here.
+#
+# Author:       Robin Dunn
+#
+# Created:      6/30/97
+# RCS-ID:       $Id$
+# Copyright:    (c) 1998 by Total Control Software
+# Licence:      wxWindows license
+#----------------------------------------------------------------------------
+
+import sys
+
+#----------------------------------------------------------------------
+# This gives this module's dictionary to the C++ extension code...
+
+_wxSetDictionary(vars())
+
+
+#----------------------------------------------------------------------
+#----------------------------------------------------------------------
+# Helper function to link python methods to wxWindows virtual
+# functions by name.
+
+def _checkForCallback(obj, name, event, theID=-1):
+    try:    cb = getattr(obj, name)
+    except: pass
+    else:   obj.Connect(theID, -1, event, cb)
+
+def _StdWindowCallbacks(win):
+    _checkForCallback(win, "OnChar",               wxEVT_CHAR)
+    _checkForCallback(win, "OnSize",               wxEVT_SIZE)
+    _checkForCallback(win, "OnEraseBackground",    wxEVT_ERASE_BACKGROUND)
+    _checkForCallback(win, "OnSysColourChanged",   wxEVT_SYS_COLOUR_CHANGED)
+    _checkForCallback(win, "OnInitDialog",         wxEVT_INIT_DIALOG)
+    _checkForCallback(win, "OnIdle",               wxEVT_IDLE)
+    _checkForCallback(win, "OnPaint",              wxEVT_PAINT)
+
+def _StdFrameCallbacks(win):
+    _StdWindowCallbacks(win)
+    _checkForCallback(win, "OnActivate",           wxEVT_ACTIVATE)
+    _checkForCallback(win, "OnMenuHighlight",      wxEVT_MENU_HIGHLIGHT)
+    _checkForCallback(win, "OnCloseWindow",        wxEVT_CLOSE_WINDOW)
+
+
+def _StdDialogCallbacks(win):
+    _StdWindowCallbacks(win)
+    _checkForCallback(win, "OnOk",     wxEVT_COMMAND_BUTTON_CLICKED,   wxID_OK)
+    _checkForCallback(win, "OnApply",  wxEVT_COMMAND_BUTTON_CLICKED,   wxID_APPLY)
+    _checkForCallback(win, "OnCancel", wxEVT_COMMAND_BUTTON_CLICKED,   wxID_CANCEL)
+    _checkForCallback(win, "OnCloseWindow", wxEVT_CLOSE_WINDOW)
+    _checkForCallback(win, "OnCharHook",    wxEVT_CHAR_HOOK)
+
+
+def _StdOnScrollCallback(win):
+    try:    cb = getattr(win, "OnScroll")
+    except: pass
+    else:   EVT_SCROLL(win, cb)
+
+
+
+#----------------------------------------------------------------------
+#----------------------------------------------------------------------
+# functions that look and act like the C++ Macros of the same name
+
+
+# Miscellaneous
+def EVT_SIZE(win, func):
+    win.Connect(-1, -1, wxEVT_SIZE, func)
+
+def EVT_MOVE(win, func):
+    win.Connect(-1, -1, wxEVT_MOVE, func)
+
+def EVT_CLOSE(win, func):
+    win.Connect(-1, -1, wxEVT_CLOSE_WINDOW, func)
+
+def EVT_PAINT(win, func):
+    win.Connect(-1, -1, wxEVT_PAINT, func)
+
+def EVT_ERASE_BACKGROUND(win, func):
+    win.Connect(-1, -1, wxEVT_ERASE_BACKGROUND, func)
+
+def EVT_CHAR(win, func):
+    win.Connect(-1, -1, wxEVT_CHAR, func)
+
+def EVT_CHAR_HOOK(win, func):
+    win.Connect(-1, -1, wxEVT_CHAR_HOOK, func)
+
+def EVT_MENU_HIGHLIGHT(win, id, func):
+    win.Connect(id, -1, wxEVT_MENU_HIGHLIGHT, func)
+
+def EVT_MENU_HIGHLIGHT_ALL(win, func):
+    win.Connect(-1, -1, wxEVT_MENU_HIGHLIGHT, func)
+
+def EVT_SET_FOCUS(win, func):
+    win.Connect(-1, -1, wxEVT_SET_FOCUS, func)
+
+def EVT_KILL_FOCUS(win, func):
+    win.Connect(-1, -1, wxEVT_KILL_FOCUS, func)
+
+def EVT_ACTIVATE(win, func):
+    win.Connect(-1, -1, wxEVT_ACTIVATE, func)
+
+def EVT_ACTIVATE_APP(win, func):
+    win.Connect(-1, -1, wxEVT_ACTIVATE_APP, func)
+
+def EVT_END_SESSION(win, func):
+    win.Connect(-1, -1, wxEVT_END_SESSION, func)
+
+def EVT_QUERY_END_SESSION(win, func):
+    win.Connect(-1, -1, wxEVT_QUERY_END_SESSION, func)
+
+def EVT_DROP_FILES(win, func):
+    win.Connect(-1, -1, wxEVT_DROP_FILES, func)
+
+def EVT_INIT_DIALOG(win, func):
+    win.Connect(-1, -1, wxEVT_INIT_DIALOG, func)
+
+def EVT_SYS_COLOUR_CHANGED(win, func):
+    win.Connect(-1, -1, wxEVT_SYS_COLOUR_CHANGED, func)
+
+def EVT_SHOW(win, func):
+    win.Connect(-1, -1, wxEVT_SHOW, func)
+
+def EVT_MAXIMIZE(win, func):
+    win.Connect(-1, -1, wxEVT_MAXIMIZE, func)
+
+def EVT_ICONIZE(win, func):
+    win.Connect(-1, -1, wxEVT_ICONIZE, func)
+
+def EVT_NAVIGATION_KEY(win, func):
+    win.Connect(-1, -1, wxEVT_NAVIGATION_KEY, func)
+
+
+# Mouse Events
+def EVT_LEFT_DOWN(win, func):
+    win.Connect(-1, -1, wxEVT_LEFT_DOWN, func)
+
+def EVT_LEFT_UP(win, func):
+    win.Connect(-1, -1, wxEVT_LEFT_UP, func)
+
+def EVT_MIDDLE_DOWN(win, func):
+    win.Connect(-1, -1, wxEVT_MIDDLE_DOWN, func)
+
+def EVT_MIDDLE_UP(win, func):
+    win.Connect(-1, -1, wxEVT_MIDDLE_UP, func)
+
+def EVT_RIGHT_DOWN(win, func):
+    win.Connect(-1, -1, wxEVT_RIGHT_DOWN, func)
+
+def EVT_RIGHT_UP(win, func):
+    win.Connect(-1, -1, wxEVT_RIGHT_UP, func)
+
+def EVT_MOTION(win, func):
+    win.Connect(-1, -1, wxEVT_MOTION, func)
+
+def EVT_LEFT_DCLICK(win, func):
+    win.Connect(-1, -1, wxEVT_LEFT_DCLICK, func)
+
+def EVT_MIDDLE_DCLICK(win, func):
+    win.Connect(-1, -1, wxEVT_MIDDLE_DCLICK, func)
+
+def EVT_RIGHT_DCLICK(win, func):
+    win.Connect(-1, -1, wxEVT_RIGHT_DCLICK, func)
+
+def EVT_LEAVE_WINDOW(win, func):
+    win.Connect(-1, -1, wxEVT_LEAVE_WINDOW, func)
+
+def EVT_ENTER_WINDOW(win, func):
+    win.Connect(-1, -1, wxEVT_ENTER_WINDOW, func)
+
+
+# all mouse events
+def EVT_MOUSE_EVENTS(win, func):
+    win.Connect(-1, -1, wxEVT_LEFT_DOWN,     func)
+    win.Connect(-1, -1, wxEVT_LEFT_UP,       func)
+    win.Connect(-1, -1, wxEVT_MIDDLE_DOWN,   func)
+    win.Connect(-1, -1, wxEVT_MIDDLE_UP,     func)
+    win.Connect(-1, -1, wxEVT_RIGHT_DOWN,    func)
+    win.Connect(-1, -1, wxEVT_RIGHT_UP,      func)
+    win.Connect(-1, -1, wxEVT_MOTION,        func)
+    win.Connect(-1, -1, wxEVT_LEFT_DCLICK,   func)
+    win.Connect(-1, -1, wxEVT_MIDDLE_DCLICK, func)
+    win.Connect(-1, -1, wxEVT_RIGHT_DCLICK,  func)
+    win.Connect(-1, -1, wxEVT_LEAVE_WINDOW,  func)
+    win.Connect(-1, -1, wxEVT_ENTER_WINDOW,  func)
+
+# EVT_COMMAND
+def EVT_COMMAND(win, id, cmd, func):
+    win.Connect(id, -1, cmd, func)
+
+def EVT_COMMAND_RANGE(win, id1, id2, cmd, func):
+    win.Connect(id1, id2, cmd, func)
+
+# Scrolling
+def EVT_SCROLL(win, func):
+    win.Connect(-1, -1, wxEVT_SCROLL_TOP,       func)
+    win.Connect(-1, -1, wxEVT_SCROLL_BOTTOM,    func)
+    win.Connect(-1, -1, wxEVT_SCROLL_LINEUP,    func)
+    win.Connect(-1, -1, wxEVT_SCROLL_LINEDOWN,  func)
+    win.Connect(-1, -1, wxEVT_SCROLL_PAGEUP,    func)
+    win.Connect(-1, -1, wxEVT_SCROLL_PAGEDOWN,  func)
+    win.Connect(-1, -1, wxEVT_SCROLL_THUMBTRACK,func)
+
+def EVT_SCROLL_TOP(win, func):
+    win.Connect(-1, -1, wxEVT_SCROLL_TOP, func)
+
+def EVT_SCROLL_BOTTOM(win, func):
+    win.Connect(-1, -1, wxEVT_SCROLL_BOTTOM, func)
+
+def EVT_SCROLL_LINEUP(win, func):
+    win.Connect(-1, -1, wxEVT_SCROLL_LINEUP, func)
+
+def EVT_SCROLL_LINEDOWN(win, func):
+    win.Connect(-1, -1, wxEVT_SCROLL_LINEDOWN, func)
+
+def EVT_SCROLL_PAGEUP(win, func):
+    win.Connect(-1, -1, wxEVT_SCROLL_PAGEUP, func)
+
+def EVT_SCROLL_PAGEDOWN(win, func):
+    win.Connect(-1, -1, wxEVT_SCROLL_PAGEDOWN, func)
+
+def EVT_SCROLL_THUMBTRACK(win, func):
+    win.Connect(-1, -1, wxEVT_SCROLL_THUMBTRACK, func)
+
+
+
+# Scrolling, with an id
+def EVT_COMMAND_SCROLL(win, id, func):
+    win.Connect(id, -1, wxEVT_SCROLL_TOP,       func)
+    win.Connect(id, -1, wxEVT_SCROLL_BOTTOM,    func)
+    win.Connect(id, -1, wxEVT_SCROLL_LINEUP,    func)
+    win.Connect(id, -1, wxEVT_SCROLL_LINEDOWN,  func)
+    win.Connect(id, -1, wxEVT_SCROLL_PAGEUP,    func)
+    win.Connect(id, -1, wxEVT_SCROLL_PAGEDOWN,  func)
+    win.Connect(id, -1, wxEVT_SCROLL_THUMBTRACK,func)
+
+def EVT_COMMAND_SCROLL_TOP(win, id, func):
+    win.Connect(id, -1, wxEVT_SCROLL_TOP, func)
+
+def EVT_COMMAND_SCROLL_BOTTOM(win, id, func):
+    win.Connect(id, -1, wxEVT_SCROLL_BOTTOM, func)
+
+def EVT_COMMAND_SCROLL_LINEUP(win, id, func):
+    win.Connect(id, -1, wxEVT_SCROLL_LINEUP, func)
+
+def EVT_COMMAND_SCROLL_LINEDOWN(win, id, func):
+    win.Connect(id, -1, wxEVT_SCROLL_LINEDOWN, func)
+
+def EVT_COMMAND_SCROLL_PAGEUP(win, id, func):
+    win.Connect(id, -1, wxEVT_SCROLL_PAGEUP, func)
+
+def EVT_COMMAND_SCROLL_PAGEDOWN(win, id, func):
+    win.Connect(id, -1, wxEVT_SCROLL_PAGEDOWN, func)
+
+def EVT_COMMAND_SCROLL_THUMBTRACK(win, id, func):
+    win.Connect(id, -1, wxEVT_SCROLL_THUMBTRACK, func)
+
+
+# Convenience commands
+def EVT_BUTTON(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_BUTTON_CLICKED, func)
+
+def EVT_CHECKBOX(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_CHECKBOX_CLICKED, func)
+
+def EVT_CHOICE(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_CHOICE_SELECTED, func)
+
+def EVT_LISTBOX(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_LISTBOX_SELECTED, func)
+
+def EVT_LISTBOX_DCLICK(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, func)
+
+def EVT_TEXT(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TEXT_UPDATED, func)
+
+def EVT_TEXT_ENTER(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TEXT_ENTER, func)
+
+def EVT_MENU(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_MENU_SELECTED, func)
+
+def EVT_MENU_RANGE(win, id1, id2, func):
+    win.Connect(id1, id2, wxEVT_COMMAND_MENU_SELECTED, func)
+
+def EVT_SLIDER(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_SLIDER_UPDATED, func)
+
+def EVT_RADIOBOX(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_RADIOBOX_SELECTED, func)
+
+def EVT_RADIOBUTTON(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_RADIOBUTTON_SELECTED, func)
+
+def EVT_VLBOX(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_VLBOX_SELECTED, func)
+
+def EVT_COMBOBOX(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_COMBOBOX_SELECTED, func)
+
+def EVT_TOOL(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TOOL_CLICKED, func)
+
+def EVT_TOOL_RCLICKED(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TOOL_RCLICKED, func)
+
+def EVT_TOOL_ENTER(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TOOL_ENTER, func)
+
+def EVT_CHECKLISTBOX(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_CHECKLISTBOX_TOGGLED, func)
+
+
+# Generic command events
+
+def EVT_COMMAND_LEFT_CLICK(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_LEFT_CLICK, func)
+
+def EVT_COMMAND_LEFT_DCLICK(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_LEFT_DCLICK, func)
+
+def EVT_COMMAND_RIGHT_CLICK(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_RIGHT_CLICK, func)
+
+def EVT_COMMAND_RIGHT_DCLICK(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_RIGHT_DCLICK, func)
+
+def EVT_COMMAND_SET_FOCUS(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_SET_FOCUS, func)
+
+def EVT_COMMAND_KILL_FOCUS(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_KILL_FOCUS, func)
+
+def EVT_COMMAND_ENTER(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_ENTER, func)
+
+
+# wxNotebook events
+def EVT_NOTEBOOK_PAGE_CHANGED(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED, func)
+
+def EVT_NOTEBOOK_PAGE_CHANGING(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING, func)
+
+
+# wxTreeCtrl events
+def EVT_TREE_BEGIN_DRAG(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TREE_BEGIN_DRAG, func)
+
+def EVT_TREE_BEGIN_RDRAG(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TREE_BEGIN_RDRAG, func)
+
+def EVT_TREE_BEGIN_LABEL_EDIT(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT, func)
+
+def EVT_TREE_END_LABEL_EDIT(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TREE_END_LABEL_EDIT, func)
+
+def EVT_TREE_GET_INFO(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TREE_GET_INFO, func)
+
+def EVT_TREE_SET_INFO(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TREE_SET_INFO, func)
+
+def EVT_TREE_ITEM_EXPANDED(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TREE_ITEM_EXPANDED, func)
+
+def EVT_TREE_ITEM_EXPANDING(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TREE_ITEM_EXPANDING, func)
+
+def EVT_TREE_ITEM_COLLAPSED(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TREE_ITEM_COLLAPSED, func)
+
+def EVT_TREE_ITEM_COLLAPSING(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TREE_ITEM_COLLAPSING, func)
+
+def EVT_TREE_SEL_CHANGED(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TREE_SEL_CHANGED, func)
+
+def EVT_TREE_SEL_CHANGING(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TREE_SEL_CHANGING, func)
+
+def EVT_TREE_KEY_DOWN(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TREE_KEY_DOWN, func)
+
+def EVT_TREE_DELETE_ITEM(win, id, func):
+    win.Connect(id, -1, wxEVT_COMMAND_TREE_DELETE_ITEM, func)
+
+
+# wxSpinButton
+def EVT_SPIN_UP(win, id, func):
+    win.Connect(id, -1, wxEVT_SCROLL_LINEUP, func)
+
+def EVT_SPIN_DOWN(win, id, func):
+    win.Connect(id, -1,wxEVT_SCROLL_LINEDOWN, func)
+
+def EVT_SPIN(win, id, func):
+    win.Connect(id, -1, wxEVT_SCROLL_TOP,       func)
+    win.Connect(id, -1, wxEVT_SCROLL_BOTTOM,    func)
+    win.Connect(id, -1, wxEVT_SCROLL_LINEUP,    func)
+    win.Connect(id, -1, wxEVT_SCROLL_LINEDOWN,  func)
+    win.Connect(id, -1, wxEVT_SCROLL_PAGEUP,    func)
+    win.Connect(id, -1, wxEVT_SCROLL_PAGEDOWN,  func)
+    win.Connect(id, -1, wxEVT_SCROLL_THUMBTRACK,func)
+
+
+
+
+# wxTaskBarIcon
+def EVT_TASKBAR_MOVE(win, func):
+    win.Connect(-1, -1, wxEVT_TASKBAR_MOVE, func)
+
+def EVT_TASKBAR_LEFT_DOWN(win, func):
+    win.Connect(-1, -1, wxEVT_TASKBAR_LEFT_DOWN, func)
+
+def EVT_TASKBAR_LEFT_UP(win, func):
+    win.Connect(-1, -1, wxEVT_TASKBAR_LEFT_UP, func)
+
+def EVT_TASKBAR_RIGHT_DOWN(win, func):
+    win.Connect(-1, -1, wxEVT_TASKBAR_RIGHT_DOWN, func)
+
+def EVT_TASKBAR_RIGHT_UP(win, func):
+    win.Connect(-1, -1, wxEVT_TASKBAR_RIGHT_UP, func)
+
+def EVT_TASKBAR_LEFT_DCLICK(win, func):
+    win.Connect(-1, -1, wxEVT_TASKBAR_LEFT_DCLICK, func)
+
+def EVT_TASKBAR_RIGHT_DCLICK(win, func):
+    win.Connect(-1, -1, wxEVT_TASKBAR_RIGHT_DCLICK, func)
+
+
+# wxGrid
+def EVT_GRID_SELECT_CELL(win, fn):
+    win.Connect(-1, -1, wxEVT_GRID_SELECT_CELL, fn)
+
+def EVT_GRID_CREATE_CELL(win, fn):
+    win.Connect(-1, -1, wxEVT_GRID_CREATE_CELL, fn)
+
+def EVT_GRID_CHANGE_LABELS(win, fn):
+    win.Connect(-1, -1, wxEVT_GRID_CHANGE_LABELS, fn)
+
+def EVT_GRID_CHANGE_SEL_LABEL(win, fn):
+    win.Connect(-1, -1, wxEVT_GRID_CHANGE_SEL_LABEL, fn)
+
+def EVT_GRID_CELL_CHANGE(win, fn):
+    win.Connect(-1, -1, wxEVT_GRID_CELL_CHANGE, fn)
+
+def EVT_GRID_CELL_LCLICK(win, fn):
+    win.Connect(-1, -1, wxEVT_GRID_CELL_LCLICK, fn)
+
+def EVT_GRID_CELL_RCLICK(win, fn):
+    win.Connect(-1, -1, wxEVT_GRID_CELL_RCLICK, fn)
+
+def EVT_GRID_LABEL_LCLICK(win, fn):
+    win.Connect(-1, -1, wxEVT_GRID_LABEL_LCLICK, fn)
+
+def EVT_GRID_LABEL_RCLICK(win, fn):
+    win.Connect(-1, -1, wxEVT_GRID_LABEL_RCLICK, fn)
+
+
+# wxSashWindow
+def EVT_SASH_DRAGGED(win, id, func):
+    win.Connect(id, -1, wxEVT_SASH_DRAGGED, func)
+
+def EVT_SASH_DRAGGED_RANGE(win, id1, id2, func):
+    win.Connect(id1, id2, wxEVT_SASH_DRAGGED, func)
+
+def EVT_QUERY_LAYOUT_INFO(win, func):
+    win.Connect(-1, -1, wxEVT_EVT_QUERY_LAYOUT_INFO, func)
+
+def EVT_CALCULATE_LAYOUT(win, func):
+    win.Connect(-1, -1, wxEVT_EVT_CALCULATE_LAYOUT, func)
+
+
+
+
+#----------------------------------------------------------------------
+
+class wxTimer(wxPyTimer):
+    def __init__(self):
+        wxPyTimer.__init__(self, self.Notify)   # derived class must provide
+                                                # Notify(self) method.
+
+#----------------------------------------------------------------------
+# Some wxWin methods can take "NULL" as parameters, but the shadow classes
+# expect an object with the SWIG pointer as a 'this' member.  This class
+# and instance fools the shadow into passing the NULL pointer.
+
+class NullObj:
+    this = 'NULL'       # SWIG converts this to (void*)0
+
+NULL = NullObj()
+
+
+#----------------------------------------------------------------------
+# aliases
+
+wxColor      = wxColour
+wxNamedColor = wxNamedColour
+
+wxPyDefaultPosition.Set(-1,-1)
+wxPyDefaultSize.Set(-1,-1)
+
+# aliases so that C++ documentation applies:
+wxDefaultPosition = wxPyDefaultPosition
+wxDefaultSize     = wxPyDefaultSize
+
+#----------------------------------------------------------------------
+
+## class wxPyStdOutWindow(wxFrame):
+##     def __init__(self, title = "wxPython: stdout/stderr"):
+##         wxFrame.__init__(self, NULL, title)
+##         self.title = title
+##         self.text = wxTextWindow(self)
+##         self.text.SetFont(wxFont(10, wxMODERN, wxNORMAL, wxBOLD))
+##         self.SetSize(-1,-1,400,200)
+##         self.Show(false)
+##         self.isShown = false
+
+##     def write(self, str):  # with this method,
+##         if not self.isShown:
+##             self.Show(true)
+##             self.isShown = true
+##         self.text.WriteText(str)
+
+##     def OnCloseWindow(self, event): # doesn't allow the window to close, just hides it
+##         self.Show(false)
+##         self.isShown = false
+
+
+_defRedirect = (wxPlatform == '__WXMSW__')
+
+#----------------------------------------------------------------------
+# The main application class.  Derive from this and implement an OnInit
+# method that creates a frame and then calls self.SetTopWindow(frame)
+
+class wxApp(wxPyApp):
+    error = 'wxApp.error'
+
+    def __init__(self, redirect=_defRedirect, filename=None):
+        wxPyApp.__init__(self)
+        self.stdioWin = None
+        self.saveStdio = (sys.stdout, sys.stderr)
+        if redirect:
+            self.RedirectStdio(filename)
+
+        # this initializes wxWindows and then calls our OnInit
+        _wxStart(self.OnInit)
+
+
+    def __del__(self):
+        try:
+            self.RestoreStdio()
+        except:
+            pass
+
+    def RedirectStdio(self, filename):
+        if filename:
+            sys.stdout = sys.stderr = open(filename, 'a')
+        else:
+            raise self.error, 'wxPyStdOutWindow not yet implemented.'
+            #self.stdioWin = sys.stdout = sys.stderr = wxPyStdOutWindow()
+
+    def RestoreStdio(self):
+        sys.stdout, sys.stderr = self.saveStdio
+        if self.stdioWin != None:
+            self.stdioWin.Show(false)
+            self.stdioWin.Destroy()
+            self.stdioWin = None
+
+
+#----------------------------------------------------------------------------
+#
+# $Log$
+# Revision 1.9  1999/01/30 07:30:09  RD
+# Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
+#
+# Various cleanup, tweaks, minor additions, etc. to maintain
+# compatibility with the current wxWindows.
+#
+# Revision 1.8  1999/01/29 21:13:42  HH
+# Added aliases for wxDefaultPosition and wxDefaultSize (from wxPy..) in _extras,
+# so that C++ documentation applies.
+#
+# Revision 1.7  1998/11/25 08:45:21  RD
+#
+# Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon
+# Added events for wxGrid
+# Other various fixes and additions
+#
+# Revision 1.6  1998/11/16 00:00:52  RD
+# Generic treectrl for wxPython/GTK compiles...
+#
+# Revision 1.5  1998/10/20 07:38:02  RD
+# bug fix
+#
+# Revision 1.4  1998/10/20 06:43:54  RD
+# New wxTreeCtrl wrappers (untested)
+# some changes in helpers
+# etc.
+#
+# Revision 1.3  1998/10/02 06:40:33  RD
+#
+# Version 0.4 of wxPython for MSW.
+#
+# Revision 1.2  1998/08/18 19:48:12  RD
+# more wxGTK compatibility things.
+#
+# It builds now but there are serious runtime problems...
+#
+# Revision 1.1  1998/08/09 08:25:49  RD
+# Initial version
+#
+#
+

utils/wxPython/src/cmndlgs.i

@@ -0,0 +1,359 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        cmndlgs.i
+// Purpose:     SWIG definitions for the Common Dialog Classes
+//
+// Author:      Robin Dunn
+//
+// Created:     7/25/98
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998 by Total Control Software
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+%module cmndlgs
+
+%{
+#include "helpers.h"
+#include <wx/colordlg.h>
+#include <wx/dirdlg.h>
+#include <wx/fontdlg.h>
+#include <wx/printdlg.h>
+%}
+
+//----------------------------------------------------------------------
+
+%include typemaps.i
+%include my_typemaps.i
+
+// Import some definitions of other classes, etc.
+%import _defs.i
+%import misc.i
+%import gdi.i
+%import windows.i
+
+%pragma(python) code = "import wx"
+
+//----------------------------------------------------------------------
+
+class wxColourData {
+public:
+    wxColourData();
+    ~wxColourData();
+
+    bool GetChooseFull();
+    wxColour& GetColour();
+    wxColour GetCustomColour(int i);
+    void SetChooseFull(int flag);
+    void SetColour(const wxColour& colour);
+    void SetCustomColour(int i, const wxColour& colour);
+};
+
+
+class wxColourDialog : public wxDialog {
+public:
+    wxColourDialog(wxWindow* parent, wxColourData* data = NULL);
+
+    %pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
+
+    wxColourData& GetColourData();
+    int ShowModal();
+};
+
+
+//----------------------------------------------------------------------
+
+class wxDirDialog : public wxDialog {
+public:
+    wxDirDialog(wxWindow* parent,
+                char* message = "Choose a directory",
+                char* defaultPath = "",
+                long style = 0,
+                const wxPoint& pos = wxPyDefaultPosition);
+
+    %pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
+
+    wxString GetPath();
+    wxString GetMessage();
+    long GetStyle();
+    void SetMessage(const wxString& message);
+    void SetPath(const wxString& path);
+    int ShowModal();
+};
+
+//----------------------------------------------------------------------
+
+class wxFileDialog : public wxDialog {
+public:
+    wxFileDialog(wxWindow* parent,
+                 char* message = "Choose a file",
+                 char* defaultDir = "",
+                 char* defaultFile = "",
+                 char* wildcard = "*.*",
+                 long style = 0,
+                 const wxPoint& pos = wxPyDefaultPosition);
+
+    %pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
+
+    wxString GetDirectory();
+    wxString GetFilename();
+    int GetFilterIndex();
+    wxString GetMessage();
+    wxString GetPath();
+    long GetStyle();
+    wxString GetWildcard();
+    void SetDirectory(const wxString& directory);
+    void SetFilename(const wxString& setfilename);
+    void SetFilterIndex(int filterIndex);
+    void SetMessage(const wxString& message);
+    void SetPath(const wxString& path);
+    void SetStyle(long style);
+    void SetWildcard(const wxString& wildCard);
+    int ShowModal();
+};
+
+
+//----------------------------------------------------------------------
+
+//TODO: wxMultipleChoiceDialog
+
+//----------------------------------------------------------------------
+
+class wxSingleChoiceDialog : public wxDialog {
+public:
+    %addmethods {
+        // TODO: ignoring clientData for now...
+        //       SWIG is messing up the &/*'s for some reason.
+        wxSingleChoiceDialog(wxWindow* parent,
+                             wxString* message,
+                             wxString* caption,
+                             int LCOUNT, wxString* LIST,
+                             //char** clientData = NULL,
+                             long style = wxOK | wxCANCEL | wxCENTRE,
+                             wxPoint* pos = &wxPyDefaultPosition) {
+            return new wxSingleChoiceDialog(parent, *message, *caption,
+                                            LCOUNT, LIST, NULL, style, *pos);
+        }
+    }
+
+    %pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
+
+    int GetSelection();
+    wxString GetStringSelection();
+    void SetSelection(int sel);
+    int ShowModal();
+};
+
+
+//----------------------------------------------------------------------
+
+class wxTextEntryDialog : public wxDialog {
+public:
+    wxTextEntryDialog(wxWindow* parent,
+                      char* message,
+                      char* caption = "Input Text",
+                      char* defaultValue = "",
+                      long style = wxOK | wxCANCEL | wxCENTRE,
+                      const wxPoint& pos = wxPyDefaultPosition);
+
+    %pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
+
+    wxString GetValue();
+    void SetValue(const wxString& value);
+    int ShowModal();
+};
+
+//----------------------------------------------------------------------
+
+class wxFontData {
+public:
+    wxFontData();
+    ~wxFontData();
+
+    void EnableEffects(bool enable);
+    bool GetAllowSymbols();
+    wxColour& GetColour();
+    wxFont GetChosenFont();
+    bool GetEnableEffects();
+    wxFont GetInitialFont();
+    bool GetShowHelp();
+    void SetAllowSymbols(bool allowSymbols);
+    void SetChosenFont(const wxFont& font);
+    void SetColour(const wxColour& colour);
+    void SetInitialFont(const wxFont& font);
+    void SetRange(int min, int max);
+    void SetShowHelp(bool showHelp);
+};
+
+
+class wxFontDialog : public wxDialog {
+public:
+    wxFontDialog(wxWindow* parent, wxFontData* data = NULL);
+
+    %pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
+
+    wxFontData& GetFontData();
+    int ShowModal();
+};
+
+
+//----------------------------------------------------------------------
+
+class wxPageSetupData {
+public:
+    wxPageSetupData();
+    ~wxPageSetupData();
+
+    void EnableHelp(bool flag);
+    void EnableMargins(bool flag);
+    void EnableOrientation(bool flag);
+    void EnablePaper(bool flag);
+    void EnablePrinter(bool flag);
+    wxPoint GetPaperSize();
+    wxPoint GetMarginTopLeft();
+    wxPoint GetMarginBottomRight();
+    wxPoint GetMinMarginTopLeft();
+    wxPoint GetMinMarginBottomRight();
+    int GetOrientation();
+    bool GetDefaultMinMargins();
+    bool GetEnableMargins();
+    bool GetEnableOrientation();
+    bool GetEnablePaper();
+    bool GetEnablePrinter();
+    bool GetEnableHelp();
+    bool GetDefaultInfo();
+    void SetPaperSize(const wxPoint& size);
+    void SetMarginTopLeft(const wxPoint& pt);
+    void SetMarginBottomRight(const wxPoint& pt);
+    void SetMinMarginTopLeft(const wxPoint& pt);
+    void SetMinMarginBottomRight(const wxPoint& pt);
+    void SetOrientation(int orientation);
+    void SetDefaultMinMargins(bool flag);
+    void SetDefaultInfo(bool flag);
+};
+
+
+class wxPageSetupDialog : public wxDialog {
+public:
+    wxPageSetupDialog(wxWindow* parent, wxPageSetupData* data = NULL);
+
+    %pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
+
+    wxPageSetupData& GetPageSetupData();
+    int ShowModal();
+};
+
+//----------------------------------------------------------------------
+
+class wxPrintData {
+public:
+    wxPrintData();
+    ~wxPrintData();
+
+    void EnableHelp(bool flag);
+    void EnablePageNumbers(bool flag);
+    void EnablePrintToFile(bool flag);
+    void EnableSelection(bool flag);
+    bool GetAllPages();
+    bool GetCollate();
+    int GetFromPage();
+    int GetMaxPage();
+    int GetMinPage();
+    int GetNoCopies();
+    int GetOrientation();
+    int GetToPage();
+    void SetCollate(bool flag);
+    void SetFromPage(int page);
+    void SetMaxPage(int page);
+    void SetMinPage(int page);
+    void SetOrientation(int orientation);
+    void SetNoCopies(int n);
+    void SetPrintToFile(bool flag);
+    void SetSetupDialog(bool flag);
+    void SetToPage(int page);
+};
+
+
+class wxPrintDialog : public wxDialog {
+public:
+    wxPrintDialog(wxWindow* parent, wxPrintData* data = NULL);
+
+    %pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
+
+    wxPrintData& GetPrintData();
+    %new wxDC* GetPrintDC();
+    int ShowModal();
+};
+
+//----------------------------------------------------------------------
+
+class wxMessageDialog : public wxDialog {
+public:
+    wxMessageDialog(wxWindow* parent,
+                    char* message,
+                    char* caption = "Message box",
+                    long style = wxOK | wxCANCEL | wxCENTRE,
+                    const wxPoint& pos = wxPyDefaultPosition);
+
+    %pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
+
+    int ShowModal();
+};
+
+//----------------------------------------------------------------------
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// $Log$
+// Revision 1.8  1998/12/17 14:07:25  RR
+//   Removed minor differences between wxMSW and wxGTK
+//
+// Revision 1.7  1998/12/15 20:41:14  RD
+// Changed the import semantics from "from wxPython import *" to "from
+// wxPython.wx import *"  This is for people who are worried about
+// namespace pollution, they can use "from wxPython import wx" and then
+// prefix all the wxPython identifiers with "wx."
+//
+// Added wxTaskbarIcon for wxMSW.
+//
+// Made the events work for wxGrid.
+//
+// Added wxConfig.
+//
+// Added wxMiniFrame for wxGTK, (untested.)
+//
+// Changed many of the args and return values that were pointers to gdi
+// objects to references to reflect changes in the wxWindows API.
+//
+// Other assorted fixes and additions.
+//
+// Revision 1.6  1998/11/25 08:45:22  RD
+//
+// Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon
+// Added events for wxGrid
+// Other various fixes and additions
+//
+// Revision 1.5  1998/11/15 23:03:43  RD
+// Removing some ifdef's for wxGTK
+//
+// Revision 1.4  1998/10/02 06:40:34  RD
+//
+// Version 0.4 of wxPython for MSW.
+//
+// Revision 1.3  1998/08/18 19:48:13  RD
+// more wxGTK compatibility things.
+//
+// It builds now but there are serious runtime problems...
+//
+// Revision 1.2  1998/08/15 07:36:25  RD
+// - Moved the header in the .i files out of the code that gets put into
+// the .cpp files.  It caused CVS conflicts because of the RCS ID being
+// different each time.
+//
+// - A few minor fixes.
+//
+// Revision 1.1  1998/08/09 08:25:49  RD
+// Initial version
+//
+//
+

utils/wxPython/src/controls.i

@@ -0,0 +1,543 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        controls.i
+// Purpose:     Control (widget) classes for wxPython
+//
+// Author:      Robin Dunn
+//
+// Created:     6/10/98
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998 by Total Control Software
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+%module controls
+
+%{
+#include "helpers.h"
+#include <wx/slider.h>
+#include <wx/spinbutt.h>
+
+#ifdef __WXMSW__
+#if wxUSE_OWNER_DRAWN
+#include <wx/checklst.h>
+#endif
+#endif
+
+#ifdef __WXGTK__
+#include <wx/checklst.h>
+#endif
+%}
+
+//----------------------------------------------------------------------
+
+%include typemaps.i
+%include my_typemaps.i
+
+// Import some definitions of other classes, etc.
+%import _defs.i
+%import misc.i
+%import windows.i
+%import gdi.i
+%import events.i
+
+%pragma(python) code = "import wx"
+
+//----------------------------------------------------------------------
+
+%{
+wxValidator wxPyDefaultValidator;       // Non-const default because of SWIG
+%}
+
+//----------------------------------------------------------------------
+
+class wxControl : public wxWindow {
+public:
+    void Command(wxCommandEvent& event);
+    wxString GetLabel();
+    void SetLabel(const wxString& label);
+};
+
+//----------------------------------------------------------------------
+
+class wxButton : public wxControl {
+public:
+    wxButton(wxWindow* parent, wxWindowID id, const wxString& label,
+             const wxPoint& pos = wxPyDefaultPosition,
+             const wxSize& size = wxPyDefaultSize,
+             long style = 0,
+             const wxValidator& validator = wxPyDefaultValidator,
+             char* name = "button");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    void SetDefault();
+};
+
+//----------------------------------------------------------------------
+
+class wxBitmapButton : public wxButton {
+public:
+    wxBitmapButton(wxWindow* parent, wxWindowID id, const wxBitmap& bitmap,
+                   const wxPoint& pos = wxPyDefaultPosition,
+                   const wxSize& size = wxPyDefaultSize,
+                   long style = wxBU_AUTODRAW,
+                   const wxValidator& validator = wxPyDefaultValidator,
+                   char* name = "button");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    wxBitmap& GetBitmapLabel();
+    wxBitmap& GetBitmapDisabled();
+    wxBitmap& GetBitmapFocus();
+    wxBitmap& GetBitmapSelected();
+    void SetBitmapDisabled(const wxBitmap& bitmap);
+    void SetBitmapFocus(const wxBitmap& bitmap);
+    void SetBitmapSelected(const wxBitmap& bitmap);
+    void SetBitmapLabel(const wxBitmap& bitmap);
+
+};
+
+//----------------------------------------------------------------------
+
+class wxCheckBox : public wxControl {
+public:
+    wxCheckBox(wxWindow* parent, wxWindowID id, const wxString& label,
+               const wxPoint& pos = wxPyDefaultPosition,
+               const wxSize& size = wxPyDefaultSize,
+               long style = 0,
+               const wxValidator& val = wxPyDefaultValidator,
+               char* name = "checkBox");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    bool GetValue();
+    void SetValue(const bool state);
+};
+
+//----------------------------------------------------------------------
+
+class wxChoice : public wxControl {
+public:
+    wxChoice(wxWindow *parent, wxWindowID id,
+             const wxPoint& pos = wxPyDefaultPosition,
+             const wxSize& size = wxPyDefaultSize,
+             int LCOUNT=0, wxString* LIST=NULL,
+             long style = 0,
+             const wxValidator& validator = wxPyDefaultValidator,
+             char* name = "choice");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    void Append(const wxString& item);
+    void Clear();
+    int FindString(const wxString& string);
+    int GetColumns();
+    int GetSelection();
+    wxString GetString(const int n);
+    wxString GetStringSelection();
+    int Number();
+    void SetColumns(const int n = 1);
+    void SetSelection(const int n);
+    void SetStringSelection(const wxString& string);
+};
+
+//----------------------------------------------------------------------
+
+class wxComboBox : public wxControl {
+public:
+    wxComboBox(wxWindow* parent, wxWindowID id, char* value = "",
+               const wxPoint& pos = wxPyDefaultPosition,
+               const wxSize& size = wxPyDefaultSize,
+               int LCOUNT=0, wxString* LIST=NULL,
+               long style = 0,
+               const wxValidator& validator = wxPyDefaultValidator,
+               char* name = "comboBox");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    void Append(const wxString& item);
+    // TODO: void Append(const wxString& item, char* clientData);
+    void Clear();
+    void Copy();
+    void Cut();
+    void Delete(int n);
+    // NotMember??:    void Deselect(int n);
+    int FindString(const wxString& string);
+    // TODO: char* GetClientData(const int n);
+    long GetInsertionPoint();
+    long GetLastPosition();
+    int GetSelection();
+    wxString GetString(int n);
+    wxString GetStringSelection();
+    wxString GetValue();
+    int Number();
+    void Paste();
+    void Replace(long from, long to, const wxString& text);
+    void Remove(long from, long to);
+    // TODO:    void SetClientData(const int n, char* data);
+    void SetInsertionPoint(long pos);
+    void SetInsertionPointEnd();
+    void SetSelection(int n, bool select = TRUE);
+    %name(SetMark)void SetSelection(long from, long to);
+    void SetValue(const wxString& text);
+};
+
+//----------------------------------------------------------------------
+
+class wxGauge : public wxControl {
+public:
+    wxGauge(wxWindow* parent, wxWindowID id, int range,
+            const wxPoint& pos = wxPyDefaultPosition,
+            const wxSize& size = wxPyDefaultSize,
+            long style = wxGA_HORIZONTAL,
+            const wxValidator& validator = wxPyDefaultValidator,
+            char* name = "gauge");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    int GetBezelFace();
+    int GetRange();
+    int GetShadowWidth();
+    int GetValue();
+    void SetBezelFace(int width);
+    void SetRange(int range);
+    void SetShadowWidth(int width);
+    void SetValue(int pos);
+};
+
+//----------------------------------------------------------------------
+
+class wxStaticBox : public wxControl {
+public:
+    wxStaticBox(wxWindow* parent, wxWindowID id, const wxString& label,
+                const wxPoint& pos = wxPyDefaultPosition,
+                const wxSize& size = wxPyDefaultSize,
+                long style = 0,
+                char* name = "staticBox");
+};
+
+
+//----------------------------------------------------------------------
+
+class wxStaticText : public wxControl {
+public:
+    wxStaticText(wxWindow* parent, wxWindowID id, const wxString& label,
+                 const wxPoint& pos = wxPyDefaultPosition,
+                 const wxSize& size = wxPyDefaultSize,
+                 long style = 0,
+                 char* name = "staticText");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    wxString GetLabel();
+    void SetLabel(const wxString& label);
+};
+
+//----------------------------------------------------------------------
+
+class wxListBox : public wxControl {
+public:
+    wxListBox(wxWindow* parent, wxWindowID id,
+              const wxPoint& pos = wxPyDefaultPosition,
+              const wxSize& size = wxPyDefaultSize,
+              int LCOUNT, wxString* LIST = NULL,
+              long style = 0,
+              const wxValidator& validator = wxPyDefaultValidator,
+              char* name = "listBox");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    void Append(const wxString& item);
+    // TODO:    void Append(const wxString& item, char* clientData);
+    void Clear();
+    void Delete(int n);
+    void Deselect(int n);
+    int FindString(const wxString& string);
+    // TODO:    char* GetClientData(const int n);
+    int GetSelection();
+    // TODO: int GetSelections(int **selections);
+    wxString GetString(int n);
+    wxString GetStringSelection();
+    int Number();
+    bool Selected(const int n);
+    void Set(int LCOUNT, wxString* LIST);
+    // TODO:    void SetClientData(const int n, char* data);
+    void SetFirstItem(int n);
+    %name(SetFirstItemStr)void SetFirstItem(const wxString& string);
+    void SetSelection(int n, bool select = TRUE);
+    void SetString(int n, const wxString& string);
+    void SetStringSelection(const wxString& string, bool select = TRUE);
+};
+
+
+//----------------------------------------------------------------------
+
+class wxCheckListBox : public wxListBox {
+public:
+    wxCheckListBox(wxWindow *parent, wxWindowID id,
+                   const wxPoint& pos = wxPyDefaultPosition,
+                   const wxSize& size = wxPyDefaultSize,
+                   int LCOUNT = 0,
+                   wxString* LIST = NULL,
+                   long style = 0,
+                   const wxValidator& validator = wxPyDefaultValidator,
+                   char* name = "listBox");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    bool  IsChecked(int uiIndex);
+    void  Check(int uiIndex, bool bCheck = TRUE);
+
+    int GetItemHeight();
+};
+
+//----------------------------------------------------------------------
+
+class wxTextCtrl : public wxControl {
+public:
+    wxTextCtrl(wxWindow* parent, wxWindowID id, char* value = "",
+               const wxPoint& pos = wxPyDefaultPosition,
+               const wxSize& size = wxPyDefaultSize,
+               long style = 0,
+               const wxValidator& validator = wxPyDefaultValidator,
+               char* name = "text");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    void Clear();
+    void Copy();
+    void Cut();
+    void DiscardEdits();
+    long GetInsertionPoint();
+    long GetLastPosition();
+    int GetLineLength(long lineNo);
+    wxString GetLineText(long lineNo);
+    int GetNumberOfLines();
+    wxString GetValue();
+    bool IsModified();
+    bool LoadFile(const wxString& filename);
+    void Paste();
+    void PositionToXY(long pos, long *OUTPUT, long *OUTPUT);
+    void Remove(long from, long to);
+    void Replace(long from, long to, const wxString& value);
+    bool SaveFile(const wxString& filename);
+    void SetEditable(bool editable);
+    void SetInsertionPoint(long pos);
+    void SetInsertionPointEnd();
+    void SetSelection(long from, long to);
+    void SetValue(const wxString& value);
+    void ShowPosition(long pos);
+    void WriteText(const wxString& text);
+    long XYToPosition(long x, long y);
+};
+
+//----------------------------------------------------------------------
+
+class wxScrollBar : public wxControl {
+public:
+    wxScrollBar(wxWindow* parent, wxWindowID id = -1,
+                const wxPoint& pos = wxPyDefaultPosition,
+                const wxSize& size = wxPyDefaultSize,
+                long style = wxSB_HORIZONTAL,
+                const wxValidator& validator = wxPyDefaultValidator,
+                char* name = "scrollBar");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    int GetRange();
+    int GetPageSize();
+    int GetThumbPosition();
+    int GetThumbSize();
+    void SetThumbPosition(int viewStart);
+    void SetScrollbar(int position, int thumbSize,
+                      int range,    int pageSize,
+                      bool refresh = TRUE);
+};
+
+//----------------------------------------------------------------------
+
+class wxSpinButton : public wxControl {
+public:
+    wxSpinButton(wxWindow* parent, wxWindowID id = -1,
+                 const wxPoint& pos = wxPyDefaultPosition,
+                 const wxSize& size = wxPyDefaultSize,
+                 long style = wxSP_HORIZONTAL,
+                 char* name = "spinButton");
+
+    int GetMax();
+    int GetMin();
+    int GetValue();
+    void SetRange(int min, int max);
+    void SetValue(int value);
+};
+
+//----------------------------------------------------------------------
+
+class wxStaticBitmap : public wxControl {
+public:
+    wxStaticBitmap(wxWindow* parent, wxWindowID id,
+                   const wxBitmap& bitmap,
+                   const wxPoint& pos = wxPyDefaultPosition,
+                   const wxSize& size = wxPyDefaultSize,
+                   long style = 0,
+                   char* name = "staticBitmap");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    wxBitmap& GetBitmap();
+    void SetBitmap(const wxBitmap& bitmap);
+};
+
+//----------------------------------------------------------------------
+
+class wxRadioBox : public wxControl {
+public:
+    wxRadioBox(wxWindow* parent, wxWindowID id,
+               const wxString& label,
+               const wxPoint& point = wxPyDefaultPosition,
+               const wxSize& size = wxPyDefaultSize,
+               int LCOUNT = 0, wxString* LIST = NULL,
+               int majorDimension = 0,
+               long style = wxRA_HORIZONTAL,
+               const wxValidator& validator = wxPyDefaultValidator,
+               char* name = "radioBox");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    %name(EnableBox)void Enable(bool enable);
+    void Enable(int n, bool enable);
+    int FindString(const wxString& string);
+#ifdef __WXMSW__
+    %name(GetBoxLabel)wxString GetLabel();
+#endif
+    wxString GetLabel(int n);
+    int GetSelection();
+    wxString GetString(int n);
+    wxString GetStringSelection();
+    int Number();
+    %name(SetBoxLabel)void SetLabel(const wxString& label);
+    void SetLabel(int n, const wxString& label);
+    void SetSelection(int n);
+    void SetStringSelection(const wxString& string);
+    void Show(bool show);
+    %name(ShowItem)void Show(int item, bool show);
+};
+
+//----------------------------------------------------------------------
+
+class wxRadioButton : public wxControl {
+public:
+    wxRadioButton(wxWindow* parent, wxWindowID id,
+                  const wxString& label,
+                  const wxPoint& pos = wxPyDefaultPosition,
+                  const wxSize& size = wxPyDefaultSize,
+                  long style = 0,
+                  const wxValidator& validator = wxPyDefaultValidator,
+                  char* name = "radioButton");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    bool GetValue();
+    void SetValue(bool value);
+};
+
+//----------------------------------------------------------------------
+
+class wxSlider : public wxControl {
+public:
+    wxSlider(wxWindow* parent, wxWindowID id,
+             int value, int minValue, int maxValue,
+             const wxPoint& point = wxPyDefaultPosition,
+             const wxSize& size = wxPyDefaultSize,
+             long style = wxSL_HORIZONTAL,
+             const wxValidator& validator = wxPyDefaultValidator,
+             char* name = "slider");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    void ClearSel();
+    void ClearTicks();
+    int GetLineSize();
+    int GetMax();
+    int GetMin();
+    int GetPageSize();
+    int GetSelEnd();
+    int GetSelStart();
+    int GetThumbLength();
+    int GetTickFreq();
+    int GetValue();
+    void SetRange(int minValue, int maxValue);
+    void SetTickFreq(int n, int pos);
+    void SetLineSize(int lineSize);
+    void SetPageSize(int pageSize);
+    void SetSelection(int startPos, int endPos);
+    void SetThumbLength(int len);
+    void SetTick(int tickPos);
+    void SetValue(int value);
+};
+
+
+//----------------------------------------------------------------------
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// $Log$
+// Revision 1.10  1998/12/17 17:52:19  RD
+// wxPython 0.5.2
+// Minor fixes and SWIG code generation for RR's changes.  MSW and GTK
+// versions are much closer now!
+//
+// Revision 1.9  1998/12/17 14:07:29  RR
+//
+//   Removed minor differences between wxMSW and wxGTK
+//
+// Revision 1.8  1998/12/15 20:41:15  RD
+// Changed the import semantics from "from wxPython import *" to "from
+// wxPython.wx import *"  This is for people who are worried about
+// namespace pollution, they can use "from wxPython import wx" and then
+// prefix all the wxPython identifiers with "wx."
+//
+// Added wxTaskbarIcon for wxMSW.
+//
+// Made the events work for wxGrid.
+//
+// Added wxConfig.
+//
+// Added wxMiniFrame for wxGTK, (untested.)
+//
+// Changed many of the args and return values that were pointers to gdi
+// objects to references to reflect changes in the wxWindows API.
+//
+// Other assorted fixes and additions.
+//
+// Revision 1.7  1998/11/16 00:00:53  RD
+// Generic treectrl for wxPython/GTK compiles...
+//
+// Revision 1.6  1998/11/15 23:03:43  RD
+// Removing some ifdef's for wxGTK
+//
+// Revision 1.5  1998/10/07 07:34:32  RD
+// Version 0.4.1 for wxGTK
+//
+// Revision 1.4  1998/10/02 06:40:35  RD
+//
+// Version 0.4 of wxPython for MSW.
+//
+// Revision 1.3  1998/08/18 19:48:14  RD
+// more wxGTK compatibility things.
+//
+// It builds now but there are serious runtime problems...
+//
+// Revision 1.2  1998/08/15 07:36:28  RD
+// - Moved the header in the .i files out of the code that gets put into
+// the .cpp files.  It caused CVS conflicts because of the RCS ID being
+// different each time.
+//
+// - A few minor fixes.
+//
+// Revision 1.1  1998/08/09 08:25:49  RD
+// Initial version
+//
+//
+

utils/wxPython/src/controls2.i

@@ -0,0 +1,451 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        controls2.i
+// Purpose:     More control (widget) classes for wxPython
+//
+// Author:      Robin Dunn
+//
+// Created:     6/10/98
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998 by Total Control Software
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+%module controls2
+
+%{
+#include "helpers.h"
+#include <wx/listctrl.h>
+#include <wx/treectrl.h>
+%}
+
+//----------------------------------------------------------------------
+
+%include typemaps.i
+%include my_typemaps.i
+
+// Import some definitions of other classes, etc.
+%import _defs.i
+%import misc.i
+%import windows.i
+%import gdi.i
+%import events.i
+%import controls.i
+
+%pragma(python) code = "import wx"
+
+//----------------------------------------------------------------------
+
+%{
+extern wxValidator wxPyDefaultValidator;
+%}
+
+//----------------------------------------------------------------------
+
+class wxListItem {
+public:
+    long            m_mask;     // Indicates what fields are valid
+    long            m_itemId;   // The zero-based item position
+    int             m_col;      // Zero-based column, if in report mode
+    long            m_state;    // The state of the item
+    long            m_stateMask; // Which flags of m_state are valid (uses same flags)
+    wxString        m_text;     // The label/header text
+    int             m_image;    // The zero-based index into an image list
+    long            m_data;     // App-defined data
+//    wxColour       *m_colour;   // only wxGLC, not supported by Windows ;->
+
+    // For columns only
+    int             m_format;   // left, right, centre
+    int             m_width;    // width of column
+
+    wxListItem();
+    ~wxListItem();
+};
+
+class wxListEvent: public wxCommandEvent {
+public:
+    int           m_code;
+    long          m_itemIndex;
+    long          m_oldItemIndex;
+    int           m_col;
+    bool          m_cancelled;
+    wxPoint       m_pointDrag;
+    wxListItem    m_item;
+};
+
+
+
+
+class wxListCtrl : public wxControl {
+public:
+    wxListCtrl(wxWindow* parent, wxWindowID id,
+               const wxPoint& pos = wxPyDefaultPosition,
+               const wxSize& size = wxPyDefaultSize,
+               long style = wxLC_ICON,
+               const wxValidator& validator = wxPyDefaultValidator,
+               char* name = "listCtrl");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    bool Arrange(int flag = wxLIST_ALIGN_DEFAULT);
+    bool DeleteItem(long item);
+    bool DeleteAllItems();
+    bool DeleteColumn(int col);
+    bool DeleteAllColumns(void);
+    void ClearAll(void);
+#ifdef __WXMSW__
+    wxTextCtrl* EditLabel(long item);
+    bool EndEditLabel(bool cancel);
+    wxTextCtrl* GetEditControl();
+#endif
+    bool EnsureVisible(long item);
+    long FindItem(long start, const wxString& str, bool partial = FALSE);
+    %name(FindItemData)long FindItem(long start, long data);
+    %name(FindItemAtPos)long FindItem(long start, const wxPoint& pt,
+                                      int direction);
+    bool GetColumn(int col, wxListItem& item);
+    int GetColumnWidth(int col);
+    int GetCountPerPage();
+    wxImageList* GetImageList(int which);
+    long GetItemData(long item);
+
+    %addmethods {
+        %new wxListItem* GetItem() {
+            wxListItem* info = new wxListItem;
+            self->GetItem(*info);
+            return info;
+        }
+        %new wxPoint* GetItemPosition(long item) {
+            wxPoint* pos = new wxPoint;
+            self->GetItemPosition(item, *pos);
+            return pos;
+        }
+        %new wxRect* GetItemRect(long item, int code = wxLIST_RECT_BOUNDS) {
+            wxRect* rect= new wxRect;
+            self->GetItemRect(item, *rect, code);
+            return rect;
+        }
+    }
+
+    int GetItemState(long item, long stateMask);
+    int GetItemCount();
+    int GetItemSpacing(bool isSmall);
+    wxString GetItemText(long item);
+    long GetNextItem(long item,
+                     int geometry = wxLIST_NEXT_ALL,
+                     int state = wxLIST_STATE_DONTCARE);
+    int GetSelectedItemCount();
+#ifdef __WXMSW__
+    wxColour GetTextColour();
+    void SetTextColour(const wxColour& col);
+#endif
+    long GetTopItem();
+    long HitTest(const wxPoint& point, int& OUTPUT);
+    %name(InsertColumnWithInfo)long InsertColumn(long col, wxListItem& info);
+    long InsertColumn(long col, const wxString& heading,
+                      int format = wxLIST_FORMAT_LEFT,
+                      int width = -1);
+
+    long InsertItem(wxListItem& info);
+    %name(InsertStringItem)     long InsertItem(long index, const wxString& label);
+    %name(InsertImageItem)      long InsertItem(long index, int imageIndex);
+    %name(InsertImageStringItem)long InsertItem(long index, const wxString& label,
+                                                int imageIndex);
+
+    bool ScrollList(int dx, int dy);
+    void SetBackgroundColour(const wxColour& col);
+    bool SetColumn(int col, wxListItem& item);
+    bool SetColumnWidth(int col, int width);
+    void SetImageList(wxImageList* imageList, int which);
+    bool SetItem(wxListItem& info);
+    %name(SetItemString)long SetItem(long index, int col, const wxString& label,
+                                     int imageId = -1);
+    bool SetItemData(long item, long data);
+    bool SetItemImage(long item, int image, int selImage);
+    bool SetItemPosition(long item, const wxPoint& pos);
+    bool SetItemState(long item, long state, long stateMask);
+    void SetItemText(long item, const wxString& text);
+    void SetSingleStyle(long style, bool add = TRUE);
+    void SetWindowStyleFlag(long style);
+    // TODO:  bool SortItems(wxListCtrlCompare fn, long data);
+};
+
+
+
+//----------------------------------------------------------------------
+
+
+class wxTreeItemId {
+public:
+    wxTreeItemId();
+    ~wxTreeItemId();
+    bool IsOk() const { return m_itemId != 0; }
+
+//    %addmethods {
+//        long GetId() { return (long)(*self); }
+//    }
+};
+
+
+
+// ****  This isn't very useful yet.  This needs to be specialized to enable
+// derived Python classes...
+class wxTreeItemData {
+public:
+    wxTreeItemData();
+    ~wxTreeItemData();
+
+    const wxTreeItemId& GetId();
+    void SetId(const wxTreeItemId& id);
+};
+
+
+
+
+class wxTreeEvent : public wxCommandEvent {
+public:
+    wxTreeItemId GetItem();
+    wxTreeItemId GetOldItem();
+    wxPoint GetPoint();
+    int GetCode();
+    void Veto();
+};
+
+
+// These are for the GetFirstChild/GetNextChild methods below
+%typemap(python, in)     long& INOUT = long* INOUT;
+%typemap(python, argout) long& INOUT = long* INOUT;
+
+
+class wxTreeCtrl : public wxControl {
+public:
+    wxTreeCtrl(wxWindow *parent, wxWindowID id = -1,
+               const wxPoint& pos = wxPyDefaultPosition,
+               const wxSize& size = wxPyDefaultSize,
+               long style = wxTR_HAS_BUTTONS | wxTR_LINES_AT_ROOT,
+               const wxValidator& validator = wxPyDefaultValidator,
+               char* name = "wxTreeCtrl");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    size_t GetCount();
+    unsigned int GetIndent();
+    void SetIndent(unsigned int indent);
+    wxImageList *GetImageList();
+    wxImageList *GetStateImageList();
+    void SetImageList(wxImageList *imageList);
+    void SetStateImageList(wxImageList *imageList);
+
+    wxString GetItemText(const wxTreeItemId& item);
+    int GetItemImage(const wxTreeItemId& item);
+    int GetItemSelectedImage(const wxTreeItemId& item);
+    wxTreeItemData *GetItemData(const wxTreeItemId& item);
+
+    void SetItemText(const wxTreeItemId& item, const wxString& text);
+    void SetItemImage(const wxTreeItemId& item, int image);
+    void SetItemSelectedImage(const wxTreeItemId& item, int image);
+    void SetItemData(const wxTreeItemId& item, wxTreeItemData *data);
+    void SetItemHasChildren(const wxTreeItemId& item, bool hasChildren = TRUE);
+
+    bool IsVisible(const wxTreeItemId& item);
+    bool ItemHasChildren(const wxTreeItemId& item);
+    bool IsExpanded(const wxTreeItemId& item);
+    bool IsSelected(const wxTreeItemId& item);
+
+    wxTreeItemId GetRootItem();
+    wxTreeItemId GetSelection();
+    wxTreeItemId GetParent(const wxTreeItemId& item);
+
+    wxTreeItemId GetFirstChild(const wxTreeItemId& item, long& INOUT);
+    wxTreeItemId GetNextChild(const wxTreeItemId& item, long& INOUT);
+    wxTreeItemId GetNextSibling(const wxTreeItemId& item);
+    wxTreeItemId GetPrevSibling(const wxTreeItemId& item);
+    wxTreeItemId GetFirstVisibleItem();
+    wxTreeItemId GetNextVisible(const wxTreeItemId& item);
+    wxTreeItemId GetPrevVisible(const wxTreeItemId& item);
+
+
+    wxTreeItemId AddRoot(const wxString& text,
+                         int image = -1, int selectedImage = -1,
+                         wxTreeItemData *data = NULL);
+    wxTreeItemId PrependItem(const wxTreeItemId& parent,
+                             const wxString& text,
+                             int image = -1, int selectedImage = -1,
+                             wxTreeItemData *data = NULL);
+    wxTreeItemId InsertItem(const wxTreeItemId& parent,
+                            const wxTreeItemId& idPrevious,
+                            const wxString& text,
+                            int image = -1, int selectedImage = -1,
+                            wxTreeItemData *data = NULL);
+    wxTreeItemId AppendItem(const wxTreeItemId& parent,
+                            const wxString& text,
+                            int image = -1, int selectedImage = -1,
+                            wxTreeItemData *data = NULL);
+
+    void Delete(const wxTreeItemId& item);
+    void DeleteChildren(const wxTreeItemId& item);
+    void DeleteAllItems();
+
+    void Expand(const wxTreeItemId& item);
+    void Collapse(const wxTreeItemId& item);
+    void CollapseAndReset(const wxTreeItemId& item);
+    void Toggle(const wxTreeItemId& item);
+
+    void Unselect();
+    void SelectItem(const wxTreeItemId& item);
+    void EnsureVisible(const wxTreeItemId& item);
+    void ScrollTo(const wxTreeItemId& item);
+
+    wxTextCtrl* EditLabel(const wxTreeItemId& item);
+                          // **** figure out how to do this
+                          // wxClassInfo* textCtrlClass = CLASSINFO(wxTextCtrl));
+    wxTextCtrl* GetEditControl();
+    void EndEditLabel(const wxTreeItemId& item, bool discardChanges = FALSE);
+
+//    void SortChildren(const wxTreeItemId& item);
+                      // **** And this too
+                      // wxTreeItemCmpFunc *cmpFunction = NULL);
+
+    void SetItemBold(const wxTreeItemId& item, bool bold = TRUE);
+    bool IsBold(const wxTreeItemId& item) const;
+    wxTreeItemId HitTest(const wxPoint& point);
+};
+
+
+//----------------------------------------------------------------------
+
+#ifdef SKIPTHIS
+#ifdef __WXMSW__
+class wxTabEvent : public wxCommandEvent {
+public:
+};
+
+
+
+class wxTabCtrl : public wxControl {
+public:
+    wxTabCtrl(wxWindow* parent, wxWindowID id,
+              const wxPoint& pos = wxPyDefaultPosition,
+              const wxSize& size = wxPyDefaultSize,
+              long style = 0,
+              char* name = "tabCtrl");
+
+    %pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
+
+    bool DeleteAllItems();
+    bool DeleteItem(int item);
+    wxImageList* GetImageList();
+    int GetItemCount();
+    // TODO: void* GetItemData();
+    int GetItemImage(int item);
+
+    %addmethods {
+        %new wxRect* GetItemRect(int item) {
+            wxRect* rect = new wxRect;
+            self->GetItemRect(item, *rect);
+            return rect;
+        }
+    }
+
+    wxString GetItemText(int item);
+    bool GetRowCount();
+    int GetSelection();
+    int HitTest(const wxPoint& pt, long& OUTPUT);
+    void InsertItem(int item, const wxString& text,
+                    int imageId = -1, void* clientData = NULL);
+    // TODO: bool SetItemData(int item, void* data);
+    bool SetItemImage(int item, int image);
+    void SetImageList(wxImageList* imageList);
+    void SetItemSize(const wxSize& size);
+    bool SetItemText(int item, const wxString& text);
+    void SetPadding(const wxSize& padding);
+    int SetSelection(int item);
+
+};
+
+#endif
+#endif
+
+//----------------------------------------------------------------------
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// $Log$
+// Revision 1.14  1999/01/30 07:30:10  RD
+// Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
+//
+// Various cleanup, tweaks, minor additions, etc. to maintain
+// compatibility with the current wxWindows.
+//
+// Revision 1.13  1998/12/17 14:07:34  RR
+//
+//   Removed minor differences between wxMSW and wxGTK
+//
+// Revision 1.12  1998/12/16 22:10:52  RD
+//
+// Tweaks needed to be able to build wxPython with wxGTK.
+//
+// Revision 1.11  1998/12/15 20:41:16  RD
+// Changed the import semantics from "from wxPython import *" to "from
+// wxPython.wx import *"  This is for people who are worried about
+// namespace pollution, they can use "from wxPython import wx" and then
+// prefix all the wxPython identifiers with "wx."
+//
+// Added wxTaskbarIcon for wxMSW.
+//
+// Made the events work for wxGrid.
+//
+// Added wxConfig.
+//
+// Added wxMiniFrame for wxGTK, (untested.)
+//
+// Changed many of the args and return values that were pointers to gdi
+// objects to references to reflect changes in the wxWindows API.
+//
+// Other assorted fixes and additions.
+//
+// Revision 1.10  1998/11/25 08:45:23  RD
+//
+// Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon
+// Added events for wxGrid
+// Other various fixes and additions
+//
+// Revision 1.9  1998/11/16 00:00:54  RD
+// Generic treectrl for wxPython/GTK compiles...
+//
+// Revision 1.8  1998/11/11 04:40:20  RD
+// wxTreeCtrl now works (sort of) for wxPython-GTK.  This is the new
+// TreeCtrl in src/gtk/treectrl.cpp not the old generic one.
+//
+// Revision 1.7  1998/11/11 03:12:25  RD
+//
+// Additions for wxTreeCtrl
+//
+// Revision 1.6  1998/10/20 06:43:55  RD
+// New wxTreeCtrl wrappers (untested)
+// some changes in helpers
+// etc.
+//
+// Revision 1.5  1998/10/07 07:34:33  RD
+// Version 0.4.1 for wxGTK
+//
+// Revision 1.4  1998/10/02 06:40:36  RD
+//
+// Version 0.4 of wxPython for MSW.
+//
+// Revision 1.3  1998/08/18 19:48:15  RD
+// more wxGTK compatibility things.
+//
+// It builds now but there are serious runtime problems...
+//
+// Revision 1.2  1998/08/15 07:36:30  RD
+// - Moved the header in the .i files out of the code that gets put into
+// the .cpp files.  It caused CVS conflicts because of the RCS ID being
+// different each time.
+//
+// - A few minor fixes.
+//
+// Revision 1.1  1998/08/09 08:25:49  RD
+// Initial version
+//
+//

utils/wxPython/src/events.i

@@ -0,0 +1,341 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        events.i
+// Purpose:     SWIGgable Event classes for wxPython
+//
+// Author:      Robin Dunn
+//
+// Created:     5/24/98
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998 by Total Control Software
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+
+%module events
+
+%{
+#include "helpers.h"
+#include <wx/spinbutt.h>
+%}
+
+//----------------------------------------------------------------------
+
+%include typemaps.i
+%include my_typemaps.i
+
+// Import some definitions of other classes, etc.
+%import _defs.i
+%import misc.i
+
+//---------------------------------------------------------------------------
+
+class wxEvent {
+public:
+    wxObject* GetEventObject();
+    wxEventType GetEventType();
+    int GetId();
+    bool GetSkipped();
+    long GetTimestamp();
+    void SetEventObject(wxObject* object);
+    void SetEventType(wxEventType typ);
+    void SetId(int id);
+    void SetTimestamp(long timeStamp);
+    void Skip(bool skip = TRUE);
+};
+
+//---------------------------------------------------------------------------
+
+class wxSizeEvent : public wxEvent {
+public:
+    wxSize GetSize();
+};
+
+//---------------------------------------------------------------------------
+
+class wxCloseEvent : public wxEvent {
+public:
+    bool CanVeto();
+// ****    bool GetSessionEnding();
+    bool GetLoggingOff();
+    void Veto(bool veto = TRUE);
+    bool GetVeto();
+    void SetForce(bool force);
+    void SetCanVeto(bool canVeto);
+    void SetLoggingOff(bool loggingOff);
+    bool GetForce();
+};
+
+//---------------------------------------------------------------------------
+
+class wxCommandEvent : public wxEvent {
+public:
+    bool Checked();
+    long GetExtraLong();
+    int GetInt();
+    int GetSelection();
+    char* GetString();
+    bool IsSelection();
+
+};
+
+
+//---------------------------------------------------------------------------
+
+class wxScrollEvent: public wxCommandEvent {
+public:
+    int GetOrientation();
+    int GetPosition();
+};
+
+//---------------------------------------------------------------------------
+
+class wxSpinEvent : public wxScrollEvent {
+public:
+
+};
+
+//---------------------------------------------------------------------------
+
+class wxMouseEvent: public wxEvent {
+public:
+    bool IsButton();
+    bool ButtonDown(int but = -1);
+    bool ButtonDClick(int but = -1);
+    bool ButtonUp(int but = -1);
+    bool Button(int but);
+    bool ButtonIsDown(int but);
+    bool ControlDown();
+    bool MetaDown();
+    bool AltDown();
+    bool ShiftDown();
+    bool LeftDown();
+    bool MiddleDown();
+    bool RightDown();
+    bool LeftUp();
+    bool MiddleUp();
+    bool RightUp();
+    bool LeftDClick();
+    bool MiddleDClick();
+    bool RightDClick();
+    bool LeftIsDown();
+    bool MiddleIsDown();
+    bool RightIsDown();
+    bool Dragging();
+    bool Moving();
+    bool Entering();
+    bool Leaving();
+    void Position(long *OUTPUT, long *OUTPUT);
+    wxPoint GetPosition();
+    wxPoint GetLogicalPosition(const wxDC& dc);
+    long GetX();
+    long GetY();
+};
+
+//---------------------------------------------------------------------------
+
+class wxKeyEvent: public wxEvent {
+public:
+    bool ControlDown();
+    bool MetaDown();
+    bool AltDown();
+    bool ShiftDown();
+    long KeyCode();
+    void Position(float *OUTPUT, float *OUTPUT);
+    float GetX();
+    float GetY();
+};
+
+//---------------------------------------------------------------------------
+
+class wxMoveEvent: public wxEvent {
+public:
+    wxPoint GetPosition();
+};
+
+//---------------------------------------------------------------------------
+
+class wxPaintEvent: public wxEvent {
+public:
+
+};
+
+//---------------------------------------------------------------------------
+
+class wxEraseEvent: public wxEvent {
+public:
+    wxDC *GetDC();
+};
+
+//---------------------------------------------------------------------------
+
+class wxFocusEvent: public wxEvent {
+public:
+
+};
+
+//---------------------------------------------------------------------------
+
+class wxActivateEvent: public wxEvent{
+public:
+    bool GetActive();
+};
+
+//---------------------------------------------------------------------------
+
+class wxInitDialogEvent: public wxEvent {
+public:
+
+};
+
+//---------------------------------------------------------------------------
+
+class wxMenuEvent: public wxEvent {
+public:
+    int GetMenuId();
+};
+
+//---------------------------------------------------------------------------
+
+class wxShowEvent: public wxEvent {
+public:
+    void SetShow(bool show);
+    bool GetShow();
+};
+
+//---------------------------------------------------------------------------
+
+class wxIconizeEvent: public wxEvent {
+public:
+};
+
+//---------------------------------------------------------------------------
+
+class wxMaximizeEvent: public wxEvent {
+public:
+
+};
+
+//---------------------------------------------------------------------------
+
+class wxJoystickEvent: public wxEvent {
+public:
+    wxPoint GetPosition();
+    int GetZPosition();
+    int GetButtonState();
+    int GetButtonChange();
+    int GetJoystick();
+    void SetJoystick(int stick);
+    void SetButtonState(int state);
+    void SetButtonChange(int change);
+    void SetPosition(const wxPoint& pos);
+    void SetZPosition(int zPos);
+    bool IsButton();
+    bool IsMove();
+    bool IsZMove();
+    bool ButtonDown(int but = wxJOY_BUTTON_ANY);
+    bool ButtonUp(int but = wxJOY_BUTTON_ANY);
+    bool ButtonIsDown(int but =  wxJOY_BUTTON_ANY);
+};
+
+//---------------------------------------------------------------------------
+
+class wxDropFilesEvent: public wxEvent {
+public:
+    wxPoint GetPosition();
+    int GetNumberOfFiles();
+
+    %addmethods {
+        PyObject* GetFiles() {
+            int         count = self->GetNumberOfFiles();
+            wxString*   files = self->GetFiles();
+            PyObject*   list  = PyList_New(count);
+
+            if (!list) {
+                PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
+                return NULL;
+            }
+
+            for (int i=0; i<count; i++) {
+                PyList_SetItem(list, i, PyString_FromString((const char*)files[i]));
+            }
+            return list;
+        }
+    }
+};
+
+//---------------------------------------------------------------------------
+
+class wxIdleEvent: public wxEvent {
+public:
+    void RequestMore(bool needMore = TRUE);
+    bool MoreRequested();
+};
+
+//---------------------------------------------------------------------------
+
+class wxUpdateUIEvent: public wxEvent {
+public:
+    bool GetChecked();
+    bool GetEnabled();
+    wxString GetText();
+    bool GetSetText();
+    bool GetSetChecked();
+    bool GetSetEnabled();
+
+    void Check(bool check);
+    void Enable(bool enable);
+    void SetText(const wxString& text);
+};
+
+//---------------------------------------------------------------------------
+
+class wxSysColourChangedEvent: public wxEvent {
+public:
+
+};
+
+//---------------------------------------------------------------------------
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// $Log$
+// Revision 1.5  1998/12/15 20:41:17  RD
+// Changed the import semantics from "from wxPython import *" to "from
+// wxPython.wx import *"  This is for people who are worried about
+// namespace pollution, they can use "from wxPython import wx" and then
+// prefix all the wxPython identifiers with "wx."
+//
+// Added wxTaskbarIcon for wxMSW.
+//
+// Made the events work for wxGrid.
+//
+// Added wxConfig.
+//
+// Added wxMiniFrame for wxGTK, (untested.)
+//
+// Changed many of the args and return values that were pointers to gdi
+// objects to references to reflect changes in the wxWindows API.
+//
+// Other assorted fixes and additions.
+//
+// Revision 1.4  1998/11/16 00:00:55  RD
+// Generic treectrl for wxPython/GTK compiles...
+//
+// Revision 1.3  1998/10/20 06:43:56  RD
+// New wxTreeCtrl wrappers (untested)
+// some changes in helpers
+// etc.
+//
+// Revision 1.2  1998/08/15 07:36:33  RD
+// - Moved the header in the .i files out of the code that gets put into
+// the .cpp files.  It caused CVS conflicts because of the RCS ID being
+// different each time.
+//
+// - A few minor fixes.
+//
+// Revision 1.1  1998/08/09 08:25:50  RD
+// Initial version
+//
+//
+

utils/wxPython/src/frames.i

@@ -0,0 +1,122 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        frames.i
+// Purpose:     SWIG definitions of various window classes
+//
+// Author:      Robin Dunn
+//
+// Created:     8/27/98
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998 by Total Control Software
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+
+%module frames
+
+%{
+#include "helpers.h"
+#include <wx/minifram.h>
+%}
+
+//----------------------------------------------------------------------
+
+%include typemaps.i
+%include my_typemaps.i
+
+// Import some definitions of other classes, etc.
+%import _defs.i
+%import misc.i
+%import gdi.i
+%import windows.i
+%import stattool.i
+
+%pragma(python) code = "import wx"
+
+//----------------------------------------------------------------------
+
+class wxFrame : public wxWindow {
+public:
+    wxFrame(wxWindow* parent, const wxWindowID id, const wxString& title,
+            const wxPoint& pos = wxPyDefaultPosition,
+            const wxSize& size = wxPyDefaultSize,
+            long style = wxDEFAULT_FRAME_STYLE,
+            char* name = "frame");
+
+    %pragma(python) addtomethod = "__init__:wx._StdFrameCallbacks(self)"
+
+    void Centre(int direction = wxBOTH);
+#ifdef __WXMSW__
+    void Command(int id);
+#endif
+    wxStatusBar* CreateStatusBar(int number = 1,
+                                 long style = wxST_SIZEGRIP,
+                                 wxWindowID id = -1,
+                                 char* name = "statusBar");
+    wxToolBar* CreateToolBar(long style = wxNO_BORDER|wxTB_HORIZONTAL|wxTB_FLAT,
+                             wxWindowID id = -1,
+                             char* name = "toolBar");
+
+    wxMenuBar* GetMenuBar();
+    wxStatusBar* GetStatusBar();
+    wxString GetTitle();
+    wxToolBar* GetToolBar();
+    void Iconize(bool iconize);
+    bool IsIconized();
+    void Maximize(bool maximize);
+    void SetAcceleratorTable(const wxAcceleratorTable& accel);
+    void SetIcon(const wxIcon& icon);
+    void SetMenuBar(wxMenuBar* menuBar);
+    void SetStatusBar(wxStatusBar *statusBar);
+    void SetStatusText(const wxString& text, int number = 0);
+    void SetStatusWidths(int LCOUNT, int* LIST); // uses typemap
+    void SetTitle(const wxString& title);
+    void SetToolBar(wxToolBar* toolbar);
+
+};
+
+//---------------------------------------------------------------------------
+
+class wxMiniFrame : public wxFrame {
+public:
+    wxMiniFrame(wxWindow* parent, const wxWindowID id, const wxString& title,
+                const wxPoint& pos = wxPyDefaultPosition,
+                const wxSize& size = wxPyDefaultSize,
+                long style = wxDEFAULT_FRAME_STYLE,
+                char* name = "frame");
+
+    %pragma(python) addtomethod = "__init__:wx._StdFrameCallbacks(self)"
+};
+
+
+//---------------------------------------------------------------------------
+/////////////////////////////////////////////////////////////////////////////
+//
+// $Log$
+// Revision 1.4  1998/12/16 22:10:53  RD
+// Tweaks needed to be able to build wxPython with wxGTK.
+//
+// Revision 1.3  1998/12/15 20:41:18  RD
+// Changed the import semantics from "from wxPython import *" to "from
+// wxPython.wx import *"  This is for people who are worried about
+// namespace pollution, they can use "from wxPython import wx" and then
+// prefix all the wxPython identifiers with "wx."
+//
+// Added wxTaskbarIcon for wxMSW.
+//
+// Made the events work for wxGrid.
+//
+// Added wxConfig.
+//
+// Added wxMiniFrame for wxGTK, (untested.)
+//
+// Changed many of the args and return values that were pointers to gdi
+// objects to references to reflect changes in the wxWindows API.
+//
+// Other assorted fixes and additions.
+//
+
+
+
+
+
+

utils/wxPython/src/gdi.i

@@ -0,0 +1,582 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        gdi.i
+// Purpose:     SWIG interface file for wxDC, wxBrush, wxPen, wxFont, etc.
+//
+// Author:      Robin Dunn
+//
+// Created:     7/7/97
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998 by Total Control Software
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+
+%module gdi
+
+%{
+#include "helpers.h"
+#include <wx/metafile.h>
+#ifndef __WXMSW__
+#include <wx/dcps.h>
+#endif
+%}
+
+//----------------------------------------------------------------------
+
+%include typemaps.i
+%include my_typemaps.i
+
+// Import some definitions of other classes, etc.
+%import _defs.i
+%import misc.i
+
+//---------------------------------------------------------------------------
+
+class wxBitmap {
+public:
+    wxBitmap(const wxString& name, long type);
+    ~wxBitmap();
+
+#ifdef __WXMSW__
+    void Create(int width, int height, int depth = -1);
+#endif
+    int GetDepth();
+    int GetHeight();
+    wxPalette* GetPalette();
+    wxMask* GetMask();
+    int GetWidth();
+    bool LoadFile(const wxString& name, long flags);
+    bool Ok();
+    bool SaveFile(const wxString& name, int type, wxPalette* palette = NULL);
+    void SetDepth(int depth);
+    void SetHeight(int height);
+    void SetMask(wxMask* mask);
+#ifdef __WXMSW__
+    void SetPalette(wxPalette& palette);
+#endif
+    void SetWidth(int width);
+};
+
+%new wxBitmap* wxEmptyBitmap(int width, int height, int depth=-1);
+wxBitmap* wxNoRefBitmap(char* name, long flags);
+
+%{                              // Alternate 'constructor'
+    wxBitmap* wxEmptyBitmap(int width, int height, int depth=-1) {
+        return new wxBitmap(width, height, depth);
+    }
+
+                                // This one won't own the reference, so Python won't call
+                                // the dtor, this is good for toolbars and such where
+                                // the parent will manage the bitmap.
+    wxBitmap* wxNoRefBitmap(char* name, long flags) {
+        return new wxBitmap(name, flags);
+    }
+%}
+
+//---------------------------------------------------------------------------
+
+class wxMask {
+public:
+    wxMask(const wxBitmap& bitmap);
+    ~wxMask();
+};
+
+%new wxMask* wxMaskColour(const wxBitmap& bitmap, const wxColour& colour);
+%{
+    wxMask* wxMaskColour(const wxBitmap& bitmap, const wxColour& colour) {
+        return new wxMask(bitmap, colour);
+    }
+%}
+
+
+//---------------------------------------------------------------------------
+
+
+class wxIcon : public wxBitmap {
+public:
+#ifdef __WXMSW__
+    wxIcon(const wxString& name, long flags,
+           int desiredWidth = -1, int desiredHeight = -1);
+#endif
+    ~wxIcon();
+
+    int GetDepth();
+    int GetHeight();
+    int GetWidth();
+    bool LoadFile(const wxString& name, long flags);
+    bool Ok();
+    void SetDepth(int depth);
+    void SetHeight(int height);
+    void SetWidth(int width);
+};
+
+//---------------------------------------------------------------------------
+
+class wxCursor : public wxBitmap {
+public:
+#ifdef __WXMSW__
+    wxCursor(const wxString& cursorName, long flags, int hotSpotX=0, int hotSpotY=0);
+#endif
+    ~wxCursor();
+    bool Ok();
+};
+
+%name(wxStockCursor) %new wxCursor* wxPyStockCursor(int id);
+%{                              // Alternate 'constructor'
+    wxCursor* wxPyStockCursor(int id) {
+        return new wxCursor(id);
+    }
+%}
+
+//----------------------------------------------------------------------
+
+class wxFont {
+public:
+    // I'll do it this way to use long-lived objects and not have to
+    // worry about when python may delete the object.
+    %addmethods {
+        wxFont( int pointSize, int family, int style, int weight,
+                int underline=FALSE, char* faceName = "") {
+
+            return wxTheFontList->FindOrCreateFont(pointSize, family, style, weight,
+                                                   underline, faceName);
+        }
+        // NO Destructor.
+    }
+
+
+    wxString GetFaceName();
+    int GetFamily();
+#ifdef __WXMSW__
+    int GetFontId();
+#endif
+    int GetPointSize();
+    int GetStyle();
+    bool GetUnderlined();
+    int GetWeight();
+    void SetFaceName(const wxString& faceName);
+    void SetFamily(int family);
+    void SetPointSize(int pointSize);
+    void SetStyle(int style);
+    void SetUnderlined(bool underlined);
+    void SetWeight(int weight);
+};
+
+//----------------------------------------------------------------------
+
+class wxColour {
+public:
+    wxColour(unsigned char red=0, unsigned char green=0, unsigned char blue=0);
+    ~wxColour();
+    unsigned char Red();
+    unsigned char Green();
+    unsigned char Blue();
+    bool Ok();
+    void Set(unsigned char red, unsigned char green, unsigned char blue);
+    %addmethods {
+        PyObject* Get() {
+            PyObject* rv = PyTuple_New(3);
+            PyTuple_SetItem(rv, 0, PyInt_FromLong(self->Red()));
+            PyTuple_SetItem(rv, 1, PyInt_FromLong(self->Green()));
+            PyTuple_SetItem(rv, 2, PyInt_FromLong(self->Blue()));
+            return rv;
+        }
+    }
+};
+
+%new wxColour* wxNamedColour(const wxString& colorName);
+%{                                      // Alternate 'constructor'
+    wxColour* wxNamedColour(const wxString& colorName) {
+        return new wxColour(colorName);
+    }
+%}
+
+
+//----------------------------------------------------------------------
+
+typedef unsigned long wxDash;
+
+class wxPen {
+public:
+    // I'll do it this way to use long-lived objects and not have to
+    // worry about when python may delete the object.
+    %addmethods {
+        wxPen(wxColour* colour, int width=1, int style=wxSOLID) {
+            return wxThePenList->FindOrCreatePen(*colour, width, style);
+        }
+        // NO Destructor.
+    }
+
+    int GetCap();
+    wxColour& GetColour();
+
+    int GetJoin();
+    int GetStyle();
+    int GetWidth();
+    bool Ok();
+    void SetCap(int cap_style);
+    void SetColour(wxColour& colour);
+    void SetJoin(int join_style);
+    void SetStyle(int style);
+    void SetWidth(int width);
+
+#ifdef __WXMSW__
+            // **** This one needs to return a list of ints (wxDash)
+    int GetDashes(wxDash **dashes);
+    wxBitmap* GetStipple();
+    void SetDashes(int LCOUNT, wxDash* LIST);
+    void SetStipple(wxBitmap& stipple);
+#endif
+};
+
+//----------------------------------------------------------------------
+
+class wxBrush {
+public:
+    // I'll do it this way to use long-lived objects and not have to
+    // worry about when python may delete the object.
+    %addmethods {
+        wxBrush(wxColour* colour, int style=wxSOLID) {
+            return wxTheBrushList->FindOrCreateBrush(*colour, style);
+        }
+        // NO Destructor.
+    }
+
+    wxColour& GetColour();
+    wxBitmap * GetStipple();
+    int GetStyle();
+    bool Ok();
+    void SetColour(wxColour &colour);
+    void SetStipple(wxBitmap& bitmap);
+    void SetStyle(int style);
+};
+
+//----------------------------------------------------------------------
+
+
+
+class wxDC {
+public:
+//    wxDC(); **** abstract base class, can't instantiate.
+    ~wxDC();
+
+    void BeginDrawing();
+    bool Blit(long xdest, long ydest, long width, long height,
+                wxDC *source, long xsrc, long ysrc, long logical_func);
+    void Clear();
+    void CrossHair(long x, long y);
+    void DestroyClippingRegion();
+    long DeviceToLogicalX(long x);
+    long DeviceToLogicalXRel(long x);
+    long DeviceToLogicalY(long y);
+    long DeviceToLogicalYRel(long y);
+    void DrawArc(long x1, long y1, long x2, long y2, long xc, long yc);
+    void DrawEllipse(long x, long y, long width, long height);
+    void DrawEllipticArc(long x, long y, long width, long height, long start, long end);
+    void DrawIcon(const wxIcon& icon, long x, long y);
+    void DrawLine(long x1, long y1, long x2, long y2);
+    void DrawLines(int LCOUNT, wxPoint* LIST, long xoffset=0, long yoffset=0);
+    void DrawPolygon(int LCOUNT, wxPoint* LIST, long xoffset=0, long yoffset=0,
+                     int fill_style=wxODDEVEN_RULE);
+    void DrawPoint(long x, long y);
+    void DrawRectangle(long x, long y, long width, long height);
+    void DrawRoundedRectangle(long x, long y, long width, long height, long radius=20);
+    void DrawSpline(int LCOUNT, wxPoint* LIST);
+    void DrawText(const wxString& text, long x, long y);
+    void EndDoc();
+    void EndDrawing();
+    void EndPage();
+    void FloodFill(long x, long y, const wxColour& colour, int style=wxFLOOD_SURFACE);
+    wxBrush&  GetBackground();
+    wxBrush&  GetBrush();
+    long GetCharHeight();
+    long GetCharWidth();
+    void GetClippingBox(long *OUTPUT, long *OUTPUT,
+                        long *OUTPUT, long *OUTPUT);
+    wxFont& GetFont();
+    int GetLogicalFunction();
+    int GetMapMode();
+    bool GetOptimization();
+    wxPen& GetPen();
+    %addmethods {
+        %new wxColour* GetPixel(long x, long y) {
+            wxColour* wc = new wxColour();
+            self->GetPixel(x, y, wc);
+            return wc;
+        }
+    }
+    void GetSize(int* OUTPUT, int* OUTPUT); //void GetSize(long* OUTPUT, long* OUTPUT);
+    wxColour& GetTextBackground();
+    void GetTextExtent(const wxString& string, long *OUTPUT, long *OUTPUT,
+                       long *OUTPUT, long *OUTPUT);
+    wxColour& GetTextForeground();
+    long LogicalToDeviceX(long x);
+    long LogicalToDeviceXRel(long x);
+    long LogicalToDeviceY(long y);
+    long LogicalToDeviceYRel(long y);
+    long MaxX();
+    long MaxY();
+    long MinX();
+    long MinY();
+    bool Ok();
+    void SetDeviceOrigin(long x, long y);
+    void SetBackground(const wxBrush& brush);
+    void SetBackgroundMode(int mode);
+    void SetClippingRegion(long x, long y, long width, long height);
+    void SetPalette(const wxPalette& colourMap);
+    void SetBrush(const wxBrush& brush);
+    void SetFont(const wxFont& font);
+    void SetLogicalFunction(int function);
+    void SetMapMode(int mode);
+    void SetOptimization(bool optimize);
+    void SetPen(const wxPen& pen);
+    void SetTextBackground(const wxColour& colour);
+    void SetTextForeground(const wxColour& colour);
+    void SetUserScale(double x_scale, double y_scale);
+    bool StartDoc(const wxString& message);
+    void StartPage();
+
+
+    %addmethods {
+            // This one is my own creation...
+        void DrawBitmap(wxBitmap& bitmap, long x, long y, bool swapPalette=TRUE) {
+            wxMemoryDC* memDC = new wxMemoryDC;
+            memDC->SelectObject(bitmap);
+            if (swapPalette)
+                self->SetPalette(*bitmap.GetPalette());
+            self->Blit(x, y, bitmap.GetWidth(), bitmap.GetHeight(), memDC,
+                    0, 0, self->GetLogicalFunction());
+            memDC->SelectObject(wxNullBitmap);
+            delete memDC;
+        }
+    }
+};
+
+
+//----------------------------------------------------------------------
+
+class wxMemoryDC : public wxDC {
+public:
+    wxMemoryDC();
+
+    void SelectObject(const wxBitmap& bitmap);
+}
+
+%new wxMemoryDC* wxMemoryDCFromDC(wxDC* oldDC);
+%{                                      // Alternate 'constructor'
+    wxMemoryDC* wxMemoryDCFromDC(wxDC* oldDC) {
+        return new wxMemoryDC(oldDC);
+    }
+%}
+
+
+//---------------------------------------------------------------------------
+
+class wxScreenDC : public wxDC {
+public:
+    wxScreenDC();
+
+    bool StartDrawingOnTop(wxWindow* window);
+    %name(StartDrawingOnTopRect) bool StartDrawingOnTop(wxRect* rect = NULL);
+    bool EndDrawingOnTop();
+};
+
+//---------------------------------------------------------------------------
+
+class wxClientDC : public wxDC {
+public:
+      wxClientDC(wxWindow* win);
+};
+
+//---------------------------------------------------------------------------
+
+class wxPaintDC : public wxDC {
+public:
+      wxPaintDC(wxWindow* win);
+};
+
+//---------------------------------------------------------------------------
+
+class wxWindowDC : public wxDC {
+public:
+      wxWindowDC(wxWindow* win);
+};
+
+//---------------------------------------------------------------------------
+
+#ifndef __WXMSW__
+class wxPostScriptDC : public wxDC {
+public:
+      wxPostScriptDC(const wxString& output, bool interactive = TRUE, wxWindow* win = NULL);
+};
+#endif
+
+//---------------------------------------------------------------------------
+
+#ifdef __WXMSW__
+class  wxPrinterDC : public wxDC {
+public:
+    wxPrinterDC(const wxString& driver, const wxString& device, const wxString& output,
+                bool interactive = TRUE, int orientation = wxPORTRAIT);
+};
+#endif
+
+//---------------------------------------------------------------------------
+
+#ifdef __WXMSW__
+class wxMetaFileDC : public wxDC {
+public:
+    wxMetaFileDC(const wxString& filename = wxPyEmptyStr);
+    wxMetaFile* Close();
+};
+#endif
+
+//---------------------------------------------------------------------------
+//---------------------------------------------------------------------------
+
+
+%readonly
+extern wxFont *wxNORMAL_FONT;
+extern wxFont *wxSMALL_FONT;
+extern wxFont *wxITALIC_FONT;
+extern wxFont *wxSWISS_FONT;
+extern wxPen *wxRED_PEN;
+
+extern wxPen *wxCYAN_PEN;
+extern wxPen *wxGREEN_PEN;
+extern wxPen *wxBLACK_PEN;
+extern wxPen *wxWHITE_PEN;
+extern wxPen *wxTRANSPARENT_PEN;
+extern wxPen *wxBLACK_DASHED_PEN;
+extern wxPen *wxGREY_PEN;
+extern wxPen *wxMEDIUM_GREY_PEN;
+extern wxPen *wxLIGHT_GREY_PEN;
+
+extern wxBrush *wxBLUE_BRUSH;
+extern wxBrush *wxGREEN_BRUSH;
+extern wxBrush *wxWHITE_BRUSH;
+extern wxBrush *wxBLACK_BRUSH;
+extern wxBrush *wxTRANSPARENT_BRUSH;
+extern wxBrush *wxCYAN_BRUSH;
+extern wxBrush *wxRED_BRUSH;
+extern wxBrush *wxGREY_BRUSH;
+extern wxBrush *wxMEDIUM_GREY_BRUSH;
+extern wxBrush *wxLIGHT_GREY_BRUSH;
+
+extern wxColour *wxBLACK;
+extern wxColour *wxWHITE;
+extern wxColour *wxRED;
+extern wxColour *wxBLUE;
+extern wxColour *wxGREEN;
+extern wxColour *wxCYAN;
+extern wxColour *wxLIGHT_GREY;
+
+extern wxCursor *wxSTANDARD_CURSOR;
+extern wxCursor *wxHOURGLASS_CURSOR;
+extern wxCursor *wxCROSS_CURSOR;
+
+extern wxBitmap wxNullBitmap;
+extern wxIcon   wxNullIcon;
+extern wxCursor wxNullCursor;
+extern wxPen    wxNullPen;
+extern wxBrush  wxNullBrush;
+extern wxPalette wxNullPalette;
+extern wxFont   wxNullFont;
+extern wxColour wxNullColour;
+
+//---------------------------------------------------------------------------
+
+class wxPalette {
+public:
+    wxPalette(int LCOUNT, byte* LIST, byte* LIST, byte* LIST);
+    ~wxPalette();
+
+    int GetPixel(byte red, byte green, byte blue);
+    bool GetRGB(int pixel, byte* OUTPUT, byte* OUTPUT, byte* OUTPUT);
+    bool Ok();
+};
+
+//---------------------------------------------------------------------------
+
+
+//---------------------------------------------------------------------------
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// $Log$
+// Revision 1.12  1999/01/30 07:30:11  RD
+// Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
+//
+// Various cleanup, tweaks, minor additions, etc. to maintain
+// compatibility with the current wxWindows.
+//
+// Revision 1.11  1998/12/18 15:49:05  RR
+//
+//   wxClipboard now serves the primary selection as well
+//   wxPython fixes
+//   warning mesages
+//
+// Revision 1.10  1998/12/17 18:05:50  RD
+//
+// wxPython 0.5.2
+// Minor fixes and SWIG code generation for RR's changes.  MSW and GTK
+// versions are much closer now!
+//
+// Revision 1.9  1998/12/17 14:07:37  RR
+//
+//   Removed minor differences between wxMSW and wxGTK
+//
+// Revision 1.8  1998/12/16 22:10:54  RD
+//
+// Tweaks needed to be able to build wxPython with wxGTK.
+//
+// Revision 1.7  1998/12/15 20:41:18  RD
+// Changed the import semantics from "from wxPython import *" to "from
+// wxPython.wx import *"  This is for people who are worried about
+// namespace pollution, they can use "from wxPython import wx" and then
+// prefix all the wxPython identifiers with "wx."
+//
+// Added wxTaskbarIcon for wxMSW.
+//
+// Made the events work for wxGrid.
+//
+// Added wxConfig.
+//
+// Added wxMiniFrame for wxGTK, (untested.)
+//
+// Changed many of the args and return values that were pointers to gdi
+// objects to references to reflect changes in the wxWindows API.
+//
+// Other assorted fixes and additions.
+//
+// Revision 1.6  1998/11/25 08:45:24  RD
+//
+// Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon
+// Added events for wxGrid
+// Other various fixes and additions
+//
+// Revision 1.5  1998/10/20 06:43:57  RD
+// New wxTreeCtrl wrappers (untested)
+// some changes in helpers
+// etc.
+//
+// Revision 1.4  1998/10/02 06:40:38  RD
+//
+// Version 0.4 of wxPython for MSW.
+//
+// Revision 1.3  1998/08/18 19:48:16  RD
+// more wxGTK compatibility things.
+//
+// It builds now but there are serious runtime problems...
+//
+// Revision 1.2  1998/08/15 07:36:35  RD
+// - Moved the header in the .i files out of the code that gets put into
+// the .cpp files.  It caused CVS conflicts because of the RCS ID being
+// different each time.
+//
+// - A few minor fixes.
+//
+// Revision 1.1  1998/08/09 08:25:50  RD
+// Initial version
+//
+//

utils/wxPython/src/gtk/cmndlgs.py

@@ -0,0 +1,592 @@
+# This file was created automatically by SWIG.
+import cmndlgsc
+
+from misc import *
+
+from gdi import *
+
+from windows import *
+import wx
+class wxColourDataPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            cmndlgsc.delete_wxColourData(self.this)
+    def GetChooseFull(self):
+        val = cmndlgsc.wxColourData_GetChooseFull(self.this)
+        return val
+    def GetColour(self):
+        val = cmndlgsc.wxColourData_GetColour(self.this)
+        val = wxColourPtr(val)
+        return val
+    def GetCustomColour(self,arg0):
+        val = cmndlgsc.wxColourData_GetCustomColour(self.this,arg0)
+        val = wxColourPtr(val)
+        val.thisown = 1
+        return val
+    def SetChooseFull(self,arg0):
+        val = cmndlgsc.wxColourData_SetChooseFull(self.this,arg0)
+        return val
+    def SetColour(self,arg0):
+        val = cmndlgsc.wxColourData_SetColour(self.this,arg0.this)
+        return val
+    def SetCustomColour(self,arg0,arg1):
+        val = cmndlgsc.wxColourData_SetCustomColour(self.this,arg0,arg1.this)
+        return val
+    def __repr__(self):
+        return "<C wxColourData instance>"
+class wxColourData(wxColourDataPtr):
+    def __init__(self) :
+        self.this = cmndlgsc.new_wxColourData()
+        self.thisown = 1
+
+
+
+
+class wxColourDialogPtr(wxDialogPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetColourData(self):
+        val = cmndlgsc.wxColourDialog_GetColourData(self.this)
+        val = wxColourDataPtr(val)
+        return val
+    def ShowModal(self):
+        val = cmndlgsc.wxColourDialog_ShowModal(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxColourDialog instance>"
+class wxColourDialog(wxColourDialogPtr):
+    def __init__(self,arg0,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(cmndlgsc.new_wxColourDialog,(arg0.this,)+args)
+        self.thisown = 1
+        wx._StdDialogCallbacks(self)
+
+
+
+
+class wxDirDialogPtr(wxDialogPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetPath(self):
+        val = cmndlgsc.wxDirDialog_GetPath(self.this)
+        return val
+    def GetMessage(self):
+        val = cmndlgsc.wxDirDialog_GetMessage(self.this)
+        return val
+    def GetStyle(self):
+        val = cmndlgsc.wxDirDialog_GetStyle(self.this)
+        return val
+    def SetMessage(self,arg0):
+        val = cmndlgsc.wxDirDialog_SetMessage(self.this,arg0)
+        return val
+    def SetPath(self,arg0):
+        val = cmndlgsc.wxDirDialog_SetPath(self.this,arg0)
+        return val
+    def ShowModal(self):
+        val = cmndlgsc.wxDirDialog_ShowModal(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxDirDialog instance>"
+class wxDirDialog(wxDirDialogPtr):
+    def __init__(self,arg0,*args) :
+        argl = map(None,args)
+        try: argl[3] = argl[3].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(cmndlgsc.new_wxDirDialog,(arg0.this,)+args)
+        self.thisown = 1
+        wx._StdDialogCallbacks(self)
+
+
+
+
+class wxFileDialogPtr(wxDialogPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetDirectory(self):
+        val = cmndlgsc.wxFileDialog_GetDirectory(self.this)
+        return val
+    def GetFilename(self):
+        val = cmndlgsc.wxFileDialog_GetFilename(self.this)
+        return val
+    def GetFilterIndex(self):
+        val = cmndlgsc.wxFileDialog_GetFilterIndex(self.this)
+        return val
+    def GetMessage(self):
+        val = cmndlgsc.wxFileDialog_GetMessage(self.this)
+        return val
+    def GetPath(self):
+        val = cmndlgsc.wxFileDialog_GetPath(self.this)
+        return val
+    def GetStyle(self):
+        val = cmndlgsc.wxFileDialog_GetStyle(self.this)
+        return val
+    def GetWildcard(self):
+        val = cmndlgsc.wxFileDialog_GetWildcard(self.this)
+        return val
+    def SetDirectory(self,arg0):
+        val = cmndlgsc.wxFileDialog_SetDirectory(self.this,arg0)
+        return val
+    def SetFilename(self,arg0):
+        val = cmndlgsc.wxFileDialog_SetFilename(self.this,arg0)
+        return val
+    def SetFilterIndex(self,arg0):
+        val = cmndlgsc.wxFileDialog_SetFilterIndex(self.this,arg0)
+        return val
+    def SetMessage(self,arg0):
+        val = cmndlgsc.wxFileDialog_SetMessage(self.this,arg0)
+        return val
+    def SetPath(self,arg0):
+        val = cmndlgsc.wxFileDialog_SetPath(self.this,arg0)
+        return val
+    def SetStyle(self,arg0):
+        val = cmndlgsc.wxFileDialog_SetStyle(self.this,arg0)
+        return val
+    def SetWildcard(self,arg0):
+        val = cmndlgsc.wxFileDialog_SetWildcard(self.this,arg0)
+        return val
+    def ShowModal(self):
+        val = cmndlgsc.wxFileDialog_ShowModal(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxFileDialog instance>"
+class wxFileDialog(wxFileDialogPtr):
+    def __init__(self,arg0,*args) :
+        argl = map(None,args)
+        try: argl[5] = argl[5].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(cmndlgsc.new_wxFileDialog,(arg0.this,)+args)
+        self.thisown = 1
+        wx._StdDialogCallbacks(self)
+
+
+
+
+class wxSingleChoiceDialogPtr(wxDialogPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetSelection(self):
+        val = cmndlgsc.wxSingleChoiceDialog_GetSelection(self.this)
+        return val
+    def GetStringSelection(self):
+        val = cmndlgsc.wxSingleChoiceDialog_GetStringSelection(self.this)
+        return val
+    def SetSelection(self,arg0):
+        val = cmndlgsc.wxSingleChoiceDialog_SetSelection(self.this,arg0)
+        return val
+    def ShowModal(self):
+        val = cmndlgsc.wxSingleChoiceDialog_ShowModal(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxSingleChoiceDialog instance>"
+class wxSingleChoiceDialog(wxSingleChoiceDialogPtr):
+    def __init__(self,arg0,arg1,arg2,arg3,*args) :
+        argl = map(None,args)
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(cmndlgsc.new_wxSingleChoiceDialog,(arg0.this,arg1,arg2,arg3,)+args)
+        self.thisown = 1
+        wx._StdDialogCallbacks(self)
+
+
+
+
+class wxTextEntryDialogPtr(wxDialogPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetValue(self):
+        val = cmndlgsc.wxTextEntryDialog_GetValue(self.this)
+        return val
+    def SetValue(self,arg0):
+        val = cmndlgsc.wxTextEntryDialog_SetValue(self.this,arg0)
+        return val
+    def ShowModal(self):
+        val = cmndlgsc.wxTextEntryDialog_ShowModal(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxTextEntryDialog instance>"
+class wxTextEntryDialog(wxTextEntryDialogPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[3] = argl[3].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(cmndlgsc.new_wxTextEntryDialog,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdDialogCallbacks(self)
+
+
+
+
+class wxFontDataPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            cmndlgsc.delete_wxFontData(self.this)
+    def EnableEffects(self,arg0):
+        val = cmndlgsc.wxFontData_EnableEffects(self.this,arg0)
+        return val
+    def GetAllowSymbols(self):
+        val = cmndlgsc.wxFontData_GetAllowSymbols(self.this)
+        return val
+    def GetColour(self):
+        val = cmndlgsc.wxFontData_GetColour(self.this)
+        val = wxColourPtr(val)
+        return val
+    def GetChosenFont(self):
+        val = cmndlgsc.wxFontData_GetChosenFont(self.this)
+        val = wxFontPtr(val)
+        val.thisown = 1
+        return val
+    def GetEnableEffects(self):
+        val = cmndlgsc.wxFontData_GetEnableEffects(self.this)
+        return val
+    def GetInitialFont(self):
+        val = cmndlgsc.wxFontData_GetInitialFont(self.this)
+        val = wxFontPtr(val)
+        val.thisown = 1
+        return val
+    def GetShowHelp(self):
+        val = cmndlgsc.wxFontData_GetShowHelp(self.this)
+        return val
+    def SetAllowSymbols(self,arg0):
+        val = cmndlgsc.wxFontData_SetAllowSymbols(self.this,arg0)
+        return val
+    def SetChosenFont(self,arg0):
+        val = cmndlgsc.wxFontData_SetChosenFont(self.this,arg0.this)
+        return val
+    def SetColour(self,arg0):
+        val = cmndlgsc.wxFontData_SetColour(self.this,arg0.this)
+        return val
+    def SetInitialFont(self,arg0):
+        val = cmndlgsc.wxFontData_SetInitialFont(self.this,arg0.this)
+        return val
+    def SetRange(self,arg0,arg1):
+        val = cmndlgsc.wxFontData_SetRange(self.this,arg0,arg1)
+        return val
+    def SetShowHelp(self,arg0):
+        val = cmndlgsc.wxFontData_SetShowHelp(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxFontData instance>"
+class wxFontData(wxFontDataPtr):
+    def __init__(self) :
+        self.this = cmndlgsc.new_wxFontData()
+        self.thisown = 1
+
+
+
+
+class wxFontDialogPtr(wxDialogPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetFontData(self):
+        val = cmndlgsc.wxFontDialog_GetFontData(self.this)
+        val = wxFontDataPtr(val)
+        return val
+    def ShowModal(self):
+        val = cmndlgsc.wxFontDialog_ShowModal(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxFontDialog instance>"
+class wxFontDialog(wxFontDialogPtr):
+    def __init__(self,arg0,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(cmndlgsc.new_wxFontDialog,(arg0.this,)+args)
+        self.thisown = 1
+        wx._StdDialogCallbacks(self)
+
+
+
+
+class wxPageSetupDataPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            cmndlgsc.delete_wxPageSetupData(self.this)
+    def EnableHelp(self,arg0):
+        val = cmndlgsc.wxPageSetupData_EnableHelp(self.this,arg0)
+        return val
+    def EnableMargins(self,arg0):
+        val = cmndlgsc.wxPageSetupData_EnableMargins(self.this,arg0)
+        return val
+    def EnableOrientation(self,arg0):
+        val = cmndlgsc.wxPageSetupData_EnableOrientation(self.this,arg0)
+        return val
+    def EnablePaper(self,arg0):
+        val = cmndlgsc.wxPageSetupData_EnablePaper(self.this,arg0)
+        return val
+    def EnablePrinter(self,arg0):
+        val = cmndlgsc.wxPageSetupData_EnablePrinter(self.this,arg0)
+        return val
+    def GetPaperSize(self):
+        val = cmndlgsc.wxPageSetupData_GetPaperSize(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetMarginTopLeft(self):
+        val = cmndlgsc.wxPageSetupData_GetMarginTopLeft(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetMarginBottomRight(self):
+        val = cmndlgsc.wxPageSetupData_GetMarginBottomRight(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetMinMarginTopLeft(self):
+        val = cmndlgsc.wxPageSetupData_GetMinMarginTopLeft(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetMinMarginBottomRight(self):
+        val = cmndlgsc.wxPageSetupData_GetMinMarginBottomRight(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetOrientation(self):
+        val = cmndlgsc.wxPageSetupData_GetOrientation(self.this)
+        return val
+    def GetDefaultMinMargins(self):
+        val = cmndlgsc.wxPageSetupData_GetDefaultMinMargins(self.this)
+        return val
+    def GetEnableMargins(self):
+        val = cmndlgsc.wxPageSetupData_GetEnableMargins(self.this)
+        return val
+    def GetEnableOrientation(self):
+        val = cmndlgsc.wxPageSetupData_GetEnableOrientation(self.this)
+        return val
+    def GetEnablePaper(self):
+        val = cmndlgsc.wxPageSetupData_GetEnablePaper(self.this)
+        return val
+    def GetEnablePrinter(self):
+        val = cmndlgsc.wxPageSetupData_GetEnablePrinter(self.this)
+        return val
+    def GetEnableHelp(self):
+        val = cmndlgsc.wxPageSetupData_GetEnableHelp(self.this)
+        return val
+    def GetDefaultInfo(self):
+        val = cmndlgsc.wxPageSetupData_GetDefaultInfo(self.this)
+        return val
+    def SetPaperSize(self,arg0):
+        val = cmndlgsc.wxPageSetupData_SetPaperSize(self.this,arg0.this)
+        return val
+    def SetMarginTopLeft(self,arg0):
+        val = cmndlgsc.wxPageSetupData_SetMarginTopLeft(self.this,arg0.this)
+        return val
+    def SetMarginBottomRight(self,arg0):
+        val = cmndlgsc.wxPageSetupData_SetMarginBottomRight(self.this,arg0.this)
+        return val
+    def SetMinMarginTopLeft(self,arg0):
+        val = cmndlgsc.wxPageSetupData_SetMinMarginTopLeft(self.this,arg0.this)
+        return val
+    def SetMinMarginBottomRight(self,arg0):
+        val = cmndlgsc.wxPageSetupData_SetMinMarginBottomRight(self.this,arg0.this)
+        return val
+    def SetOrientation(self,arg0):
+        val = cmndlgsc.wxPageSetupData_SetOrientation(self.this,arg0)
+        return val
+    def SetDefaultMinMargins(self,arg0):
+        val = cmndlgsc.wxPageSetupData_SetDefaultMinMargins(self.this,arg0)
+        return val
+    def SetDefaultInfo(self,arg0):
+        val = cmndlgsc.wxPageSetupData_SetDefaultInfo(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxPageSetupData instance>"
+class wxPageSetupData(wxPageSetupDataPtr):
+    def __init__(self) :
+        self.this = cmndlgsc.new_wxPageSetupData()
+        self.thisown = 1
+
+
+
+
+class wxPageSetupDialogPtr(wxDialogPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetPageSetupData(self):
+        val = cmndlgsc.wxPageSetupDialog_GetPageSetupData(self.this)
+        val = wxPageSetupDataPtr(val)
+        return val
+    def ShowModal(self):
+        val = cmndlgsc.wxPageSetupDialog_ShowModal(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxPageSetupDialog instance>"
+class wxPageSetupDialog(wxPageSetupDialogPtr):
+    def __init__(self,arg0,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(cmndlgsc.new_wxPageSetupDialog,(arg0.this,)+args)
+        self.thisown = 1
+        wx._StdDialogCallbacks(self)
+
+
+
+
+class wxPrintDataPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            cmndlgsc.delete_wxPrintData(self.this)
+    def EnableHelp(self,arg0):
+        val = cmndlgsc.wxPrintData_EnableHelp(self.this,arg0)
+        return val
+    def EnablePageNumbers(self,arg0):
+        val = cmndlgsc.wxPrintData_EnablePageNumbers(self.this,arg0)
+        return val
+    def EnablePrintToFile(self,arg0):
+        val = cmndlgsc.wxPrintData_EnablePrintToFile(self.this,arg0)
+        return val
+    def EnableSelection(self,arg0):
+        val = cmndlgsc.wxPrintData_EnableSelection(self.this,arg0)
+        return val
+    def GetAllPages(self):
+        val = cmndlgsc.wxPrintData_GetAllPages(self.this)
+        return val
+    def GetCollate(self):
+        val = cmndlgsc.wxPrintData_GetCollate(self.this)
+        return val
+    def GetFromPage(self):
+        val = cmndlgsc.wxPrintData_GetFromPage(self.this)
+        return val
+    def GetMaxPage(self):
+        val = cmndlgsc.wxPrintData_GetMaxPage(self.this)
+        return val
+    def GetMinPage(self):
+        val = cmndlgsc.wxPrintData_GetMinPage(self.this)
+        return val
+    def GetNoCopies(self):
+        val = cmndlgsc.wxPrintData_GetNoCopies(self.this)
+        return val
+    def GetOrientation(self):
+        val = cmndlgsc.wxPrintData_GetOrientation(self.this)
+        return val
+    def GetToPage(self):
+        val = cmndlgsc.wxPrintData_GetToPage(self.this)
+        return val
+    def SetCollate(self,arg0):
+        val = cmndlgsc.wxPrintData_SetCollate(self.this,arg0)
+        return val
+    def SetFromPage(self,arg0):
+        val = cmndlgsc.wxPrintData_SetFromPage(self.this,arg0)
+        return val
+    def SetMaxPage(self,arg0):
+        val = cmndlgsc.wxPrintData_SetMaxPage(self.this,arg0)
+        return val
+    def SetMinPage(self,arg0):
+        val = cmndlgsc.wxPrintData_SetMinPage(self.this,arg0)
+        return val
+    def SetOrientation(self,arg0):
+        val = cmndlgsc.wxPrintData_SetOrientation(self.this,arg0)
+        return val
+    def SetNoCopies(self,arg0):
+        val = cmndlgsc.wxPrintData_SetNoCopies(self.this,arg0)
+        return val
+    def SetPrintToFile(self,arg0):
+        val = cmndlgsc.wxPrintData_SetPrintToFile(self.this,arg0)
+        return val
+    def SetSetupDialog(self,arg0):
+        val = cmndlgsc.wxPrintData_SetSetupDialog(self.this,arg0)
+        return val
+    def SetToPage(self,arg0):
+        val = cmndlgsc.wxPrintData_SetToPage(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxPrintData instance>"
+class wxPrintData(wxPrintDataPtr):
+    def __init__(self) :
+        self.this = cmndlgsc.new_wxPrintData()
+        self.thisown = 1
+
+
+
+
+class wxPrintDialogPtr(wxDialogPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetPrintData(self):
+        val = cmndlgsc.wxPrintDialog_GetPrintData(self.this)
+        val = wxPrintDataPtr(val)
+        return val
+    def GetPrintDC(self):
+        val = cmndlgsc.wxPrintDialog_GetPrintDC(self.this)
+        val = wxDCPtr(val)
+        val.thisown = 1
+        return val
+    def ShowModal(self):
+        val = cmndlgsc.wxPrintDialog_ShowModal(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxPrintDialog instance>"
+class wxPrintDialog(wxPrintDialogPtr):
+    def __init__(self,arg0,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(cmndlgsc.new_wxPrintDialog,(arg0.this,)+args)
+        self.thisown = 1
+        wx._StdDialogCallbacks(self)
+
+
+
+
+class wxMessageDialogPtr(wxDialogPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def ShowModal(self):
+        val = cmndlgsc.wxMessageDialog_ShowModal(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxMessageDialog instance>"
+class wxMessageDialog(wxMessageDialogPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[2] = argl[2].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(cmndlgsc.new_wxMessageDialog,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdDialogCallbacks(self)
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+

utils/wxPython/src/gtk/controls.py

@@ -0,0 +1,836 @@
+# This file was created automatically by SWIG.
+import controlsc
+
+from misc import *
+
+from windows import *
+
+from gdi import *
+
+from events import *
+import wx
+class wxControlPtr(wxWindowPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Command(self,arg0):
+        val = controlsc.wxControl_Command(self.this,arg0.this)
+        return val
+    def GetLabel(self):
+        val = controlsc.wxControl_GetLabel(self.this)
+        return val
+    def SetLabel(self,arg0):
+        val = controlsc.wxControl_SetLabel(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxControl instance>"
+class wxControl(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxButtonPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def SetDefault(self):
+        val = controlsc.wxButton_SetDefault(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxButton instance>"
+class wxButton(wxButtonPtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxButton,(arg0.this,arg1,arg2,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxBitmapButtonPtr(wxButtonPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetBitmapLabel(self):
+        val = controlsc.wxBitmapButton_GetBitmapLabel(self.this)
+        val = wxBitmapPtr(val)
+        return val
+    def GetBitmapDisabled(self):
+        val = controlsc.wxBitmapButton_GetBitmapDisabled(self.this)
+        val = wxBitmapPtr(val)
+        return val
+    def GetBitmapFocus(self):
+        val = controlsc.wxBitmapButton_GetBitmapFocus(self.this)
+        val = wxBitmapPtr(val)
+        return val
+    def GetBitmapSelected(self):
+        val = controlsc.wxBitmapButton_GetBitmapSelected(self.this)
+        val = wxBitmapPtr(val)
+        return val
+    def SetBitmapDisabled(self,arg0):
+        val = controlsc.wxBitmapButton_SetBitmapDisabled(self.this,arg0.this)
+        return val
+    def SetBitmapFocus(self,arg0):
+        val = controlsc.wxBitmapButton_SetBitmapFocus(self.this,arg0.this)
+        return val
+    def SetBitmapSelected(self,arg0):
+        val = controlsc.wxBitmapButton_SetBitmapSelected(self.this,arg0.this)
+        return val
+    def SetBitmapLabel(self,arg0):
+        val = controlsc.wxBitmapButton_SetBitmapLabel(self.this,arg0.this)
+        return val
+    def __repr__(self):
+        return "<C wxBitmapButton instance>"
+class wxBitmapButton(wxBitmapButtonPtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxBitmapButton,(arg0.this,arg1,arg2.this,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxCheckBoxPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetValue(self):
+        val = controlsc.wxCheckBox_GetValue(self.this)
+        return val
+    def SetValue(self,arg0):
+        val = controlsc.wxCheckBox_SetValue(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxCheckBox instance>"
+class wxCheckBox(wxCheckBoxPtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxCheckBox,(arg0.this,arg1,arg2,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxChoicePtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Append(self,arg0):
+        val = controlsc.wxChoice_Append(self.this,arg0)
+        return val
+    def Clear(self):
+        val = controlsc.wxChoice_Clear(self.this)
+        return val
+    def FindString(self,arg0):
+        val = controlsc.wxChoice_FindString(self.this,arg0)
+        return val
+    def GetColumns(self):
+        val = controlsc.wxChoice_GetColumns(self.this)
+        return val
+    def GetSelection(self):
+        val = controlsc.wxChoice_GetSelection(self.this)
+        return val
+    def GetString(self,arg0):
+        val = controlsc.wxChoice_GetString(self.this,arg0)
+        return val
+    def GetStringSelection(self):
+        val = controlsc.wxChoice_GetStringSelection(self.this)
+        return val
+    def Number(self):
+        val = controlsc.wxChoice_Number(self.this)
+        return val
+    def SetColumns(self,*args):
+        val = apply(controlsc.wxChoice_SetColumns,(self.this,)+args)
+        return val
+    def SetSelection(self,arg0):
+        val = controlsc.wxChoice_SetSelection(self.this,arg0)
+        return val
+    def SetStringSelection(self,arg0):
+        val = controlsc.wxChoice_SetStringSelection(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxChoice instance>"
+class wxChoice(wxChoicePtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxChoice,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxComboBoxPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Append(self,arg0):
+        val = controlsc.wxComboBox_Append(self.this,arg0)
+        return val
+    def Clear(self):
+        val = controlsc.wxComboBox_Clear(self.this)
+        return val
+    def Copy(self):
+        val = controlsc.wxComboBox_Copy(self.this)
+        return val
+    def Cut(self):
+        val = controlsc.wxComboBox_Cut(self.this)
+        return val
+    def Delete(self,arg0):
+        val = controlsc.wxComboBox_Delete(self.this,arg0)
+        return val
+    def FindString(self,arg0):
+        val = controlsc.wxComboBox_FindString(self.this,arg0)
+        return val
+    def GetInsertionPoint(self):
+        val = controlsc.wxComboBox_GetInsertionPoint(self.this)
+        return val
+    def GetLastPosition(self):
+        val = controlsc.wxComboBox_GetLastPosition(self.this)
+        return val
+    def GetSelection(self):
+        val = controlsc.wxComboBox_GetSelection(self.this)
+        return val
+    def GetString(self,arg0):
+        val = controlsc.wxComboBox_GetString(self.this,arg0)
+        return val
+    def GetStringSelection(self):
+        val = controlsc.wxComboBox_GetStringSelection(self.this)
+        return val
+    def GetValue(self):
+        val = controlsc.wxComboBox_GetValue(self.this)
+        return val
+    def Number(self):
+        val = controlsc.wxComboBox_Number(self.this)
+        return val
+    def Paste(self):
+        val = controlsc.wxComboBox_Paste(self.this)
+        return val
+    def Replace(self,arg0,arg1,arg2):
+        val = controlsc.wxComboBox_Replace(self.this,arg0,arg1,arg2)
+        return val
+    def Remove(self,arg0,arg1):
+        val = controlsc.wxComboBox_Remove(self.this,arg0,arg1)
+        return val
+    def SetInsertionPoint(self,arg0):
+        val = controlsc.wxComboBox_SetInsertionPoint(self.this,arg0)
+        return val
+    def SetInsertionPointEnd(self):
+        val = controlsc.wxComboBox_SetInsertionPointEnd(self.this)
+        return val
+    def SetSelection(self,arg0,*args):
+        val = apply(controlsc.wxComboBox_SetSelection,(self.this,arg0,)+args)
+        return val
+    def SetMark(self,arg0,arg1):
+        val = controlsc.wxComboBox_SetMark(self.this,arg0,arg1)
+        return val
+    def SetValue(self,arg0):
+        val = controlsc.wxComboBox_SetValue(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxComboBox instance>"
+class wxComboBox(wxComboBoxPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[1] = argl[1].this
+        except: pass
+        try: argl[2] = argl[2].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxComboBox,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxGaugePtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetBezelFace(self):
+        val = controlsc.wxGauge_GetBezelFace(self.this)
+        return val
+    def GetRange(self):
+        val = controlsc.wxGauge_GetRange(self.this)
+        return val
+    def GetShadowWidth(self):
+        val = controlsc.wxGauge_GetShadowWidth(self.this)
+        return val
+    def GetValue(self):
+        val = controlsc.wxGauge_GetValue(self.this)
+        return val
+    def SetBezelFace(self,arg0):
+        val = controlsc.wxGauge_SetBezelFace(self.this,arg0)
+        return val
+    def SetRange(self,arg0):
+        val = controlsc.wxGauge_SetRange(self.this,arg0)
+        return val
+    def SetShadowWidth(self,arg0):
+        val = controlsc.wxGauge_SetShadowWidth(self.this,arg0)
+        return val
+    def SetValue(self,arg0):
+        val = controlsc.wxGauge_SetValue(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxGauge instance>"
+class wxGauge(wxGaugePtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxGauge,(arg0.this,arg1,arg2,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxStaticBoxPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxStaticBox instance>"
+class wxStaticBox(wxStaticBoxPtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxStaticBox,(arg0.this,arg1,arg2,)+args)
+        self.thisown = 1
+
+
+
+
+class wxStaticTextPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetLabel(self):
+        val = controlsc.wxStaticText_GetLabel(self.this)
+        return val
+    def SetLabel(self,arg0):
+        val = controlsc.wxStaticText_SetLabel(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxStaticText instance>"
+class wxStaticText(wxStaticTextPtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxStaticText,(arg0.this,arg1,arg2,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxListBoxPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Append(self,arg0):
+        val = controlsc.wxListBox_Append(self.this,arg0)
+        return val
+    def Clear(self):
+        val = controlsc.wxListBox_Clear(self.this)
+        return val
+    def Delete(self,arg0):
+        val = controlsc.wxListBox_Delete(self.this,arg0)
+        return val
+    def Deselect(self,arg0):
+        val = controlsc.wxListBox_Deselect(self.this,arg0)
+        return val
+    def FindString(self,arg0):
+        val = controlsc.wxListBox_FindString(self.this,arg0)
+        return val
+    def GetSelection(self):
+        val = controlsc.wxListBox_GetSelection(self.this)
+        return val
+    def GetString(self,arg0):
+        val = controlsc.wxListBox_GetString(self.this,arg0)
+        return val
+    def GetStringSelection(self):
+        val = controlsc.wxListBox_GetStringSelection(self.this)
+        return val
+    def Number(self):
+        val = controlsc.wxListBox_Number(self.this)
+        return val
+    def Selected(self,arg0):
+        val = controlsc.wxListBox_Selected(self.this,arg0)
+        return val
+    def Set(self,arg0,*args):
+        val = apply(controlsc.wxListBox_Set,(self.this,arg0,)+args)
+        return val
+    def SetFirstItem(self,arg0):
+        val = controlsc.wxListBox_SetFirstItem(self.this,arg0)
+        return val
+    def SetFirstItemStr(self,arg0):
+        val = controlsc.wxListBox_SetFirstItemStr(self.this,arg0)
+        return val
+    def SetSelection(self,arg0,*args):
+        val = apply(controlsc.wxListBox_SetSelection,(self.this,arg0,)+args)
+        return val
+    def SetString(self,arg0,arg1):
+        val = controlsc.wxListBox_SetString(self.this,arg0,arg1)
+        return val
+    def SetStringSelection(self,arg0,*args):
+        val = apply(controlsc.wxListBox_SetStringSelection,(self.this,arg0,)+args)
+        return val
+    def __repr__(self):
+        return "<C wxListBox instance>"
+class wxListBox(wxListBoxPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxListBox,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxCheckListBoxPtr(wxListBoxPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def IsChecked(self,arg0):
+        val = controlsc.wxCheckListBox_IsChecked(self.this,arg0)
+        return val
+    def Check(self,arg0,*args):
+        val = apply(controlsc.wxCheckListBox_Check,(self.this,arg0,)+args)
+        return val
+    def GetItemHeight(self):
+        val = controlsc.wxCheckListBox_GetItemHeight(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxCheckListBox instance>"
+class wxCheckListBox(wxCheckListBoxPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxCheckListBox,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxTextCtrlPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Clear(self):
+        val = controlsc.wxTextCtrl_Clear(self.this)
+        return val
+    def Copy(self):
+        val = controlsc.wxTextCtrl_Copy(self.this)
+        return val
+    def Cut(self):
+        val = controlsc.wxTextCtrl_Cut(self.this)
+        return val
+    def DiscardEdits(self):
+        val = controlsc.wxTextCtrl_DiscardEdits(self.this)
+        return val
+    def GetInsertionPoint(self):
+        val = controlsc.wxTextCtrl_GetInsertionPoint(self.this)
+        return val
+    def GetLastPosition(self):
+        val = controlsc.wxTextCtrl_GetLastPosition(self.this)
+        return val
+    def GetLineLength(self,arg0):
+        val = controlsc.wxTextCtrl_GetLineLength(self.this,arg0)
+        return val
+    def GetLineText(self,arg0):
+        val = controlsc.wxTextCtrl_GetLineText(self.this,arg0)
+        return val
+    def GetNumberOfLines(self):
+        val = controlsc.wxTextCtrl_GetNumberOfLines(self.this)
+        return val
+    def GetValue(self):
+        val = controlsc.wxTextCtrl_GetValue(self.this)
+        return val
+    def IsModified(self):
+        val = controlsc.wxTextCtrl_IsModified(self.this)
+        return val
+    def LoadFile(self,arg0):
+        val = controlsc.wxTextCtrl_LoadFile(self.this,arg0)
+        return val
+    def Paste(self):
+        val = controlsc.wxTextCtrl_Paste(self.this)
+        return val
+    def PositionToXY(self,arg0):
+        val = controlsc.wxTextCtrl_PositionToXY(self.this,arg0)
+        return val
+    def Remove(self,arg0,arg1):
+        val = controlsc.wxTextCtrl_Remove(self.this,arg0,arg1)
+        return val
+    def Replace(self,arg0,arg1,arg2):
+        val = controlsc.wxTextCtrl_Replace(self.this,arg0,arg1,arg2)
+        return val
+    def SaveFile(self,arg0):
+        val = controlsc.wxTextCtrl_SaveFile(self.this,arg0)
+        return val
+    def SetEditable(self,arg0):
+        val = controlsc.wxTextCtrl_SetEditable(self.this,arg0)
+        return val
+    def SetInsertionPoint(self,arg0):
+        val = controlsc.wxTextCtrl_SetInsertionPoint(self.this,arg0)
+        return val
+    def SetInsertionPointEnd(self):
+        val = controlsc.wxTextCtrl_SetInsertionPointEnd(self.this)
+        return val
+    def SetSelection(self,arg0,arg1):
+        val = controlsc.wxTextCtrl_SetSelection(self.this,arg0,arg1)
+        return val
+    def SetValue(self,arg0):
+        val = controlsc.wxTextCtrl_SetValue(self.this,arg0)
+        return val
+    def ShowPosition(self,arg0):
+        val = controlsc.wxTextCtrl_ShowPosition(self.this,arg0)
+        return val
+    def WriteText(self,arg0):
+        val = controlsc.wxTextCtrl_WriteText(self.this,arg0)
+        return val
+    def XYToPosition(self,arg0,arg1):
+        val = controlsc.wxTextCtrl_XYToPosition(self.this,arg0,arg1)
+        return val
+    def __repr__(self):
+        return "<C wxTextCtrl instance>"
+class wxTextCtrl(wxTextCtrlPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[1] = argl[1].this
+        except: pass
+        try: argl[2] = argl[2].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxTextCtrl,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxScrollBarPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetRange(self):
+        val = controlsc.wxScrollBar_GetRange(self.this)
+        return val
+    def GetPageSize(self):
+        val = controlsc.wxScrollBar_GetPageSize(self.this)
+        return val
+    def GetThumbPosition(self):
+        val = controlsc.wxScrollBar_GetThumbPosition(self.this)
+        return val
+    def GetThumbSize(self):
+        val = controlsc.wxScrollBar_GetThumbSize(self.this)
+        return val
+    def SetThumbPosition(self,arg0):
+        val = controlsc.wxScrollBar_SetThumbPosition(self.this,arg0)
+        return val
+    def SetScrollbar(self,arg0,arg1,arg2,arg3,*args):
+        val = apply(controlsc.wxScrollBar_SetScrollbar,(self.this,arg0,arg1,arg2,arg3,)+args)
+        return val
+    def __repr__(self):
+        return "<C wxScrollBar instance>"
+class wxScrollBar(wxScrollBarPtr):
+    def __init__(self,arg0,*args) :
+        argl = map(None,args)
+        try: argl[1] = argl[1].this
+        except: pass
+        try: argl[2] = argl[2].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxScrollBar,(arg0.this,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxSpinButtonPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetMax(self):
+        val = controlsc.wxSpinButton_GetMax(self.this)
+        return val
+    def GetMin(self):
+        val = controlsc.wxSpinButton_GetMin(self.this)
+        return val
+    def GetValue(self):
+        val = controlsc.wxSpinButton_GetValue(self.this)
+        return val
+    def SetRange(self,arg0,arg1):
+        val = controlsc.wxSpinButton_SetRange(self.this,arg0,arg1)
+        return val
+    def SetValue(self,arg0):
+        val = controlsc.wxSpinButton_SetValue(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxSpinButton instance>"
+class wxSpinButton(wxSpinButtonPtr):
+    def __init__(self,arg0,*args) :
+        argl = map(None,args)
+        try: argl[1] = argl[1].this
+        except: pass
+        try: argl[2] = argl[2].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxSpinButton,(arg0.this,)+args)
+        self.thisown = 1
+
+
+
+
+class wxStaticBitmapPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetBitmap(self):
+        val = controlsc.wxStaticBitmap_GetBitmap(self.this)
+        val = wxBitmapPtr(val)
+        return val
+    def SetBitmap(self,arg0):
+        val = controlsc.wxStaticBitmap_SetBitmap(self.this,arg0.this)
+        return val
+    def __repr__(self):
+        return "<C wxStaticBitmap instance>"
+class wxStaticBitmap(wxStaticBitmapPtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxStaticBitmap,(arg0.this,arg1,arg2.this,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxRadioBoxPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def EnableBox(self,arg0):
+        val = controlsc.wxRadioBox_EnableBox(self.this,arg0)
+        return val
+    def Enable(self,arg0,arg1):
+        val = controlsc.wxRadioBox_Enable(self.this,arg0,arg1)
+        return val
+    def FindString(self,arg0):
+        val = controlsc.wxRadioBox_FindString(self.this,arg0)
+        return val
+    def GetLabel(self,arg0):
+        val = controlsc.wxRadioBox_GetLabel(self.this,arg0)
+        return val
+    def GetSelection(self):
+        val = controlsc.wxRadioBox_GetSelection(self.this)
+        return val
+    def GetString(self,arg0):
+        val = controlsc.wxRadioBox_GetString(self.this,arg0)
+        return val
+    def GetStringSelection(self):
+        val = controlsc.wxRadioBox_GetStringSelection(self.this)
+        return val
+    def Number(self):
+        val = controlsc.wxRadioBox_Number(self.this)
+        return val
+    def SetBoxLabel(self,arg0):
+        val = controlsc.wxRadioBox_SetBoxLabel(self.this,arg0)
+        return val
+    def SetLabel(self,arg0,arg1):
+        val = controlsc.wxRadioBox_SetLabel(self.this,arg0,arg1)
+        return val
+    def SetSelection(self,arg0):
+        val = controlsc.wxRadioBox_SetSelection(self.this,arg0)
+        return val
+    def SetStringSelection(self,arg0):
+        val = controlsc.wxRadioBox_SetStringSelection(self.this,arg0)
+        return val
+    def Show(self,arg0):
+        val = controlsc.wxRadioBox_Show(self.this,arg0)
+        return val
+    def ShowItem(self,arg0,arg1):
+        val = controlsc.wxRadioBox_ShowItem(self.this,arg0,arg1)
+        return val
+    def __repr__(self):
+        return "<C wxRadioBox instance>"
+class wxRadioBox(wxRadioBoxPtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxRadioBox,(arg0.this,arg1,arg2,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxRadioButtonPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetValue(self):
+        val = controlsc.wxRadioButton_GetValue(self.this)
+        return val
+    def SetValue(self,arg0):
+        val = controlsc.wxRadioButton_SetValue(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxRadioButton instance>"
+class wxRadioButton(wxRadioButtonPtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxRadioButton,(arg0.this,arg1,arg2,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxSliderPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def ClearSel(self):
+        val = controlsc.wxSlider_ClearSel(self.this)
+        return val
+    def ClearTicks(self):
+        val = controlsc.wxSlider_ClearTicks(self.this)
+        return val
+    def GetLineSize(self):
+        val = controlsc.wxSlider_GetLineSize(self.this)
+        return val
+    def GetMax(self):
+        val = controlsc.wxSlider_GetMax(self.this)
+        return val
+    def GetMin(self):
+        val = controlsc.wxSlider_GetMin(self.this)
+        return val
+    def GetPageSize(self):
+        val = controlsc.wxSlider_GetPageSize(self.this)
+        return val
+    def GetSelEnd(self):
+        val = controlsc.wxSlider_GetSelEnd(self.this)
+        return val
+    def GetSelStart(self):
+        val = controlsc.wxSlider_GetSelStart(self.this)
+        return val
+    def GetThumbLength(self):
+        val = controlsc.wxSlider_GetThumbLength(self.this)
+        return val
+    def GetTickFreq(self):
+        val = controlsc.wxSlider_GetTickFreq(self.this)
+        return val
+    def GetValue(self):
+        val = controlsc.wxSlider_GetValue(self.this)
+        return val
+    def SetRange(self,arg0,arg1):
+        val = controlsc.wxSlider_SetRange(self.this,arg0,arg1)
+        return val
+    def SetTickFreq(self,arg0,arg1):
+        val = controlsc.wxSlider_SetTickFreq(self.this,arg0,arg1)
+        return val
+    def SetLineSize(self,arg0):
+        val = controlsc.wxSlider_SetLineSize(self.this,arg0)
+        return val
+    def SetPageSize(self,arg0):
+        val = controlsc.wxSlider_SetPageSize(self.this,arg0)
+        return val
+    def SetSelection(self,arg0,arg1):
+        val = controlsc.wxSlider_SetSelection(self.this,arg0,arg1)
+        return val
+    def SetThumbLength(self,arg0):
+        val = controlsc.wxSlider_SetThumbLength(self.this,arg0)
+        return val
+    def SetTick(self,arg0):
+        val = controlsc.wxSlider_SetTick(self.this,arg0)
+        return val
+    def SetValue(self,arg0):
+        val = controlsc.wxSlider_SetValue(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxSlider instance>"
+class wxSlider(wxSliderPtr):
+    def __init__(self,arg0,arg1,arg2,arg3,arg4,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controlsc.new_wxSlider,(arg0.this,arg1,arg2,arg3,arg4,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+

utils/wxPython/src/gtk/controls2.py

@@ -0,0 +1,606 @@
+# This file was created automatically by SWIG.
+import controls2c
+
+from misc import *
+
+from windows import *
+
+from gdi import *
+
+from events import *
+
+from controls import *
+import wx
+class wxListItemPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            controls2c.delete_wxListItem(self.this)
+    def __setattr__(self,name,value):
+        if name == "m_mask" :
+            controls2c.wxListItem_m_mask_set(self.this,value)
+            return
+        if name == "m_itemId" :
+            controls2c.wxListItem_m_itemId_set(self.this,value)
+            return
+        if name == "m_col" :
+            controls2c.wxListItem_m_col_set(self.this,value)
+            return
+        if name == "m_state" :
+            controls2c.wxListItem_m_state_set(self.this,value)
+            return
+        if name == "m_stateMask" :
+            controls2c.wxListItem_m_stateMask_set(self.this,value)
+            return
+        if name == "m_text" :
+            controls2c.wxListItem_m_text_set(self.this,value)
+            return
+        if name == "m_image" :
+            controls2c.wxListItem_m_image_set(self.this,value)
+            return
+        if name == "m_data" :
+            controls2c.wxListItem_m_data_set(self.this,value)
+            return
+        if name == "m_format" :
+            controls2c.wxListItem_m_format_set(self.this,value)
+            return
+        if name == "m_width" :
+            controls2c.wxListItem_m_width_set(self.this,value)
+            return
+        self.__dict__[name] = value
+    def __getattr__(self,name):
+        if name == "m_mask" : 
+            return controls2c.wxListItem_m_mask_get(self.this)
+        if name == "m_itemId" : 
+            return controls2c.wxListItem_m_itemId_get(self.this)
+        if name == "m_col" : 
+            return controls2c.wxListItem_m_col_get(self.this)
+        if name == "m_state" : 
+            return controls2c.wxListItem_m_state_get(self.this)
+        if name == "m_stateMask" : 
+            return controls2c.wxListItem_m_stateMask_get(self.this)
+        if name == "m_text" : 
+            return controls2c.wxListItem_m_text_get(self.this)
+        if name == "m_image" : 
+            return controls2c.wxListItem_m_image_get(self.this)
+        if name == "m_data" : 
+            return controls2c.wxListItem_m_data_get(self.this)
+        if name == "m_format" : 
+            return controls2c.wxListItem_m_format_get(self.this)
+        if name == "m_width" : 
+            return controls2c.wxListItem_m_width_get(self.this)
+        raise AttributeError,name
+    def __repr__(self):
+        return "<C wxListItem instance>"
+class wxListItem(wxListItemPtr):
+    def __init__(self) :
+        self.this = controls2c.new_wxListItem()
+        self.thisown = 1
+
+
+
+
+class wxListEventPtr(wxCommandEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __setattr__(self,name,value):
+        if name == "m_code" :
+            controls2c.wxListEvent_m_code_set(self.this,value)
+            return
+        if name == "m_itemIndex" :
+            controls2c.wxListEvent_m_itemIndex_set(self.this,value)
+            return
+        if name == "m_oldItemIndex" :
+            controls2c.wxListEvent_m_oldItemIndex_set(self.this,value)
+            return
+        if name == "m_col" :
+            controls2c.wxListEvent_m_col_set(self.this,value)
+            return
+        if name == "m_cancelled" :
+            controls2c.wxListEvent_m_cancelled_set(self.this,value)
+            return
+        if name == "m_pointDrag" :
+            controls2c.wxListEvent_m_pointDrag_set(self.this,value.this)
+            return
+        if name == "m_item" :
+            controls2c.wxListEvent_m_item_set(self.this,value.this)
+            return
+        self.__dict__[name] = value
+    def __getattr__(self,name):
+        if name == "m_code" : 
+            return controls2c.wxListEvent_m_code_get(self.this)
+        if name == "m_itemIndex" : 
+            return controls2c.wxListEvent_m_itemIndex_get(self.this)
+        if name == "m_oldItemIndex" : 
+            return controls2c.wxListEvent_m_oldItemIndex_get(self.this)
+        if name == "m_col" : 
+            return controls2c.wxListEvent_m_col_get(self.this)
+        if name == "m_cancelled" : 
+            return controls2c.wxListEvent_m_cancelled_get(self.this)
+        if name == "m_pointDrag" : 
+            return wxPointPtr(controls2c.wxListEvent_m_pointDrag_get(self.this))
+        if name == "m_item" : 
+            return wxListItemPtr(controls2c.wxListEvent_m_item_get(self.this))
+        raise AttributeError,name
+    def __repr__(self):
+        return "<C wxListEvent instance>"
+class wxListEvent(wxListEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxListCtrlPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Arrange(self,*args):
+        val = apply(controls2c.wxListCtrl_Arrange,(self.this,)+args)
+        return val
+    def DeleteItem(self,arg0):
+        val = controls2c.wxListCtrl_DeleteItem(self.this,arg0)
+        return val
+    def DeleteAllItems(self):
+        val = controls2c.wxListCtrl_DeleteAllItems(self.this)
+        return val
+    def DeleteColumn(self,arg0):
+        val = controls2c.wxListCtrl_DeleteColumn(self.this,arg0)
+        return val
+    def DeleteAllColumns(self):
+        val = controls2c.wxListCtrl_DeleteAllColumns(self.this)
+        return val
+    def ClearAll(self):
+        val = controls2c.wxListCtrl_ClearAll(self.this)
+        return val
+    def EnsureVisible(self,arg0):
+        val = controls2c.wxListCtrl_EnsureVisible(self.this,arg0)
+        return val
+    def FindItem(self,arg0,arg1,*args):
+        val = apply(controls2c.wxListCtrl_FindItem,(self.this,arg0,arg1,)+args)
+        return val
+    def FindItemData(self,arg0,arg1):
+        val = controls2c.wxListCtrl_FindItemData(self.this,arg0,arg1)
+        return val
+    def FindItemAtPos(self,arg0,arg1,arg2):
+        val = controls2c.wxListCtrl_FindItemAtPos(self.this,arg0,arg1.this,arg2)
+        return val
+    def GetColumn(self,arg0,arg1):
+        val = controls2c.wxListCtrl_GetColumn(self.this,arg0,arg1.this)
+        return val
+    def GetColumnWidth(self,arg0):
+        val = controls2c.wxListCtrl_GetColumnWidth(self.this,arg0)
+        return val
+    def GetCountPerPage(self):
+        val = controls2c.wxListCtrl_GetCountPerPage(self.this)
+        return val
+    def GetImageList(self,arg0):
+        val = controls2c.wxListCtrl_GetImageList(self.this,arg0)
+        return val
+    def GetItemData(self,arg0):
+        val = controls2c.wxListCtrl_GetItemData(self.this,arg0)
+        return val
+    def GetItem(self):
+        val = controls2c.wxListCtrl_GetItem(self.this)
+        val = wxListItemPtr(val)
+        val.thisown = 1
+        return val
+    def GetItemPosition(self,arg0):
+        val = controls2c.wxListCtrl_GetItemPosition(self.this,arg0)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetItemRect(self,arg0,*args):
+        val = apply(controls2c.wxListCtrl_GetItemRect,(self.this,arg0,)+args)
+        val = wxRectPtr(val)
+        val.thisown = 1
+        return val
+    def GetItemState(self,arg0,arg1):
+        val = controls2c.wxListCtrl_GetItemState(self.this,arg0,arg1)
+        return val
+    def GetItemCount(self):
+        val = controls2c.wxListCtrl_GetItemCount(self.this)
+        return val
+    def GetItemSpacing(self,arg0):
+        val = controls2c.wxListCtrl_GetItemSpacing(self.this,arg0)
+        return val
+    def GetItemText(self,arg0):
+        val = controls2c.wxListCtrl_GetItemText(self.this,arg0)
+        return val
+    def GetNextItem(self,arg0,*args):
+        val = apply(controls2c.wxListCtrl_GetNextItem,(self.this,arg0,)+args)
+        return val
+    def GetSelectedItemCount(self):
+        val = controls2c.wxListCtrl_GetSelectedItemCount(self.this)
+        return val
+    def GetTopItem(self):
+        val = controls2c.wxListCtrl_GetTopItem(self.this)
+        return val
+    def HitTest(self,arg0):
+        val = controls2c.wxListCtrl_HitTest(self.this,arg0.this)
+        return val
+    def InsertColumnWithInfo(self,arg0,arg1):
+        val = controls2c.wxListCtrl_InsertColumnWithInfo(self.this,arg0,arg1.this)
+        return val
+    def InsertColumn(self,arg0,arg1,*args):
+        val = apply(controls2c.wxListCtrl_InsertColumn,(self.this,arg0,arg1,)+args)
+        return val
+    def InsertItem(self,arg0):
+        val = controls2c.wxListCtrl_InsertItem(self.this,arg0.this)
+        return val
+    def InsertStringItem(self,arg0,arg1):
+        val = controls2c.wxListCtrl_InsertStringItem(self.this,arg0,arg1)
+        return val
+    def InsertImageItem(self,arg0,arg1):
+        val = controls2c.wxListCtrl_InsertImageItem(self.this,arg0,arg1)
+        return val
+    def InsertImageStringItem(self,arg0,arg1,arg2):
+        val = controls2c.wxListCtrl_InsertImageStringItem(self.this,arg0,arg1,arg2)
+        return val
+    def ScrollList(self,arg0,arg1):
+        val = controls2c.wxListCtrl_ScrollList(self.this,arg0,arg1)
+        return val
+    def SetBackgroundColour(self,arg0):
+        val = controls2c.wxListCtrl_SetBackgroundColour(self.this,arg0.this)
+        return val
+    def SetColumn(self,arg0,arg1):
+        val = controls2c.wxListCtrl_SetColumn(self.this,arg0,arg1.this)
+        return val
+    def SetColumnWidth(self,arg0,arg1):
+        val = controls2c.wxListCtrl_SetColumnWidth(self.this,arg0,arg1)
+        return val
+    def SetImageList(self,arg0,arg1):
+        val = controls2c.wxListCtrl_SetImageList(self.this,arg0,arg1)
+        return val
+    def SetItem(self,arg0):
+        val = controls2c.wxListCtrl_SetItem(self.this,arg0.this)
+        return val
+    def SetItemString(self,arg0,arg1,arg2,*args):
+        val = apply(controls2c.wxListCtrl_SetItemString,(self.this,arg0,arg1,arg2,)+args)
+        return val
+    def SetItemData(self,arg0,arg1):
+        val = controls2c.wxListCtrl_SetItemData(self.this,arg0,arg1)
+        return val
+    def SetItemImage(self,arg0,arg1,arg2):
+        val = controls2c.wxListCtrl_SetItemImage(self.this,arg0,arg1,arg2)
+        return val
+    def SetItemPosition(self,arg0,arg1):
+        val = controls2c.wxListCtrl_SetItemPosition(self.this,arg0,arg1.this)
+        return val
+    def SetItemState(self,arg0,arg1,arg2):
+        val = controls2c.wxListCtrl_SetItemState(self.this,arg0,arg1,arg2)
+        return val
+    def SetItemText(self,arg0,arg1):
+        val = controls2c.wxListCtrl_SetItemText(self.this,arg0,arg1)
+        return val
+    def SetSingleStyle(self,arg0,*args):
+        val = apply(controls2c.wxListCtrl_SetSingleStyle,(self.this,arg0,)+args)
+        return val
+    def SetWindowStyleFlag(self,arg0):
+        val = controls2c.wxListCtrl_SetWindowStyleFlag(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxListCtrl instance>"
+class wxListCtrl(wxListCtrlPtr):
+    def __init__(self,arg0,arg1,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controls2c.new_wxListCtrl,(arg0.this,arg1,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+class wxTreeItemIdPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            controls2c.delete_wxTreeItemId(self.this)
+    def IsOk(self):
+        val = controls2c.wxTreeItemId_IsOk(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxTreeItemId instance>"
+class wxTreeItemId(wxTreeItemIdPtr):
+    def __init__(self) :
+        self.this = controls2c.new_wxTreeItemId()
+        self.thisown = 1
+
+
+
+
+class wxTreeItemDataPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            controls2c.delete_wxTreeItemData(self.this)
+    def GetId(self):
+        val = controls2c.wxTreeItemData_GetId(self.this)
+        val = wxTreeItemIdPtr(val)
+        return val
+    def SetId(self,arg0):
+        val = controls2c.wxTreeItemData_SetId(self.this,arg0.this)
+        return val
+    def __repr__(self):
+        return "<C wxTreeItemData instance>"
+class wxTreeItemData(wxTreeItemDataPtr):
+    def __init__(self) :
+        self.this = controls2c.new_wxTreeItemData()
+        self.thisown = 1
+
+
+
+
+class wxTreeEventPtr(wxCommandEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetItem(self):
+        val = controls2c.wxTreeEvent_GetItem(self.this)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def GetOldItem(self):
+        val = controls2c.wxTreeEvent_GetOldItem(self.this)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def GetPoint(self):
+        val = controls2c.wxTreeEvent_GetPoint(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetCode(self):
+        val = controls2c.wxTreeEvent_GetCode(self.this)
+        return val
+    def Veto(self):
+        val = controls2c.wxTreeEvent_Veto(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxTreeEvent instance>"
+class wxTreeEvent(wxTreeEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxTreeCtrlPtr(wxControlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetCount(self):
+        val = controls2c.wxTreeCtrl_GetCount(self.this)
+        return val
+    def GetIndent(self):
+        val = controls2c.wxTreeCtrl_GetIndent(self.this)
+        return val
+    def SetIndent(self,arg0):
+        val = controls2c.wxTreeCtrl_SetIndent(self.this,arg0)
+        return val
+    def GetImageList(self):
+        val = controls2c.wxTreeCtrl_GetImageList(self.this)
+        return val
+    def GetStateImageList(self):
+        val = controls2c.wxTreeCtrl_GetStateImageList(self.this)
+        return val
+    def SetImageList(self,arg0):
+        val = controls2c.wxTreeCtrl_SetImageList(self.this,arg0)
+        return val
+    def SetStateImageList(self,arg0):
+        val = controls2c.wxTreeCtrl_SetStateImageList(self.this,arg0)
+        return val
+    def GetItemText(self,arg0):
+        val = controls2c.wxTreeCtrl_GetItemText(self.this,arg0.this)
+        return val
+    def GetItemImage(self,arg0):
+        val = controls2c.wxTreeCtrl_GetItemImage(self.this,arg0.this)
+        return val
+    def GetItemSelectedImage(self,arg0):
+        val = controls2c.wxTreeCtrl_GetItemSelectedImage(self.this,arg0.this)
+        return val
+    def GetItemData(self,arg0):
+        val = controls2c.wxTreeCtrl_GetItemData(self.this,arg0.this)
+        val = wxTreeItemDataPtr(val)
+        return val
+    def SetItemText(self,arg0,arg1):
+        val = controls2c.wxTreeCtrl_SetItemText(self.this,arg0.this,arg1)
+        return val
+    def SetItemImage(self,arg0,arg1):
+        val = controls2c.wxTreeCtrl_SetItemImage(self.this,arg0.this,arg1)
+        return val
+    def SetItemSelectedImage(self,arg0,arg1):
+        val = controls2c.wxTreeCtrl_SetItemSelectedImage(self.this,arg0.this,arg1)
+        return val
+    def SetItemData(self,arg0,arg1):
+        val = controls2c.wxTreeCtrl_SetItemData(self.this,arg0.this,arg1.this)
+        return val
+    def SetItemHasChildren(self,arg0,*args):
+        val = apply(controls2c.wxTreeCtrl_SetItemHasChildren,(self.this,arg0.this,)+args)
+        return val
+    def IsVisible(self,arg0):
+        val = controls2c.wxTreeCtrl_IsVisible(self.this,arg0.this)
+        return val
+    def ItemHasChildren(self,arg0):
+        val = controls2c.wxTreeCtrl_ItemHasChildren(self.this,arg0.this)
+        return val
+    def IsExpanded(self,arg0):
+        val = controls2c.wxTreeCtrl_IsExpanded(self.this,arg0.this)
+        return val
+    def IsSelected(self,arg0):
+        val = controls2c.wxTreeCtrl_IsSelected(self.this,arg0.this)
+        return val
+    def GetRootItem(self):
+        val = controls2c.wxTreeCtrl_GetRootItem(self.this)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def GetSelection(self):
+        val = controls2c.wxTreeCtrl_GetSelection(self.this)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def GetParent(self,arg0):
+        val = controls2c.wxTreeCtrl_GetParent(self.this,arg0.this)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def GetFirstChild(self,arg0,arg1):
+        val = controls2c.wxTreeCtrl_GetFirstChild(self.this,arg0.this,arg1)
+        return val
+    def GetNextChild(self,arg0,arg1):
+        val = controls2c.wxTreeCtrl_GetNextChild(self.this,arg0.this,arg1)
+        return val
+    def GetNextSibling(self,arg0):
+        val = controls2c.wxTreeCtrl_GetNextSibling(self.this,arg0.this)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def GetPrevSibling(self,arg0):
+        val = controls2c.wxTreeCtrl_GetPrevSibling(self.this,arg0.this)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def GetFirstVisibleItem(self):
+        val = controls2c.wxTreeCtrl_GetFirstVisibleItem(self.this)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def GetNextVisible(self,arg0):
+        val = controls2c.wxTreeCtrl_GetNextVisible(self.this,arg0.this)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def GetPrevVisible(self,arg0):
+        val = controls2c.wxTreeCtrl_GetPrevVisible(self.this,arg0.this)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def AddRoot(self,arg0,*args):
+        argl = map(None,args)
+        try: argl[2] = argl[2].this
+        except: pass
+        args = tuple(argl)
+        val = apply(controls2c.wxTreeCtrl_AddRoot,(self.this,arg0,)+args)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def PrependItem(self,arg0,arg1,*args):
+        argl = map(None,args)
+        try: argl[2] = argl[2].this
+        except: pass
+        args = tuple(argl)
+        val = apply(controls2c.wxTreeCtrl_PrependItem,(self.this,arg0.this,arg1,)+args)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def InsertItem(self,arg0,arg1,arg2,*args):
+        argl = map(None,args)
+        try: argl[2] = argl[2].this
+        except: pass
+        args = tuple(argl)
+        val = apply(controls2c.wxTreeCtrl_InsertItem,(self.this,arg0.this,arg1.this,arg2,)+args)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def AppendItem(self,arg0,arg1,*args):
+        argl = map(None,args)
+        try: argl[2] = argl[2].this
+        except: pass
+        args = tuple(argl)
+        val = apply(controls2c.wxTreeCtrl_AppendItem,(self.this,arg0.this,arg1,)+args)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def Delete(self,arg0):
+        val = controls2c.wxTreeCtrl_Delete(self.this,arg0.this)
+        return val
+    def DeleteChildren(self,arg0):
+        val = controls2c.wxTreeCtrl_DeleteChildren(self.this,arg0.this)
+        return val
+    def DeleteAllItems(self):
+        val = controls2c.wxTreeCtrl_DeleteAllItems(self.this)
+        return val
+    def Expand(self,arg0):
+        val = controls2c.wxTreeCtrl_Expand(self.this,arg0.this)
+        return val
+    def Collapse(self,arg0):
+        val = controls2c.wxTreeCtrl_Collapse(self.this,arg0.this)
+        return val
+    def CollapseAndReset(self,arg0):
+        val = controls2c.wxTreeCtrl_CollapseAndReset(self.this,arg0.this)
+        return val
+    def Toggle(self,arg0):
+        val = controls2c.wxTreeCtrl_Toggle(self.this,arg0.this)
+        return val
+    def Unselect(self):
+        val = controls2c.wxTreeCtrl_Unselect(self.this)
+        return val
+    def SelectItem(self,arg0):
+        val = controls2c.wxTreeCtrl_SelectItem(self.this,arg0.this)
+        return val
+    def EnsureVisible(self,arg0):
+        val = controls2c.wxTreeCtrl_EnsureVisible(self.this,arg0.this)
+        return val
+    def ScrollTo(self,arg0):
+        val = controls2c.wxTreeCtrl_ScrollTo(self.this,arg0.this)
+        return val
+    def EditLabel(self,arg0):
+        val = controls2c.wxTreeCtrl_EditLabel(self.this,arg0.this)
+        val = wxTextCtrlPtr(val)
+        return val
+    def GetEditControl(self):
+        val = controls2c.wxTreeCtrl_GetEditControl(self.this)
+        val = wxTextCtrlPtr(val)
+        return val
+    def EndEditLabel(self,arg0,*args):
+        val = apply(controls2c.wxTreeCtrl_EndEditLabel,(self.this,arg0.this,)+args)
+        return val
+    def SetItemBold(self,arg0,*args):
+        val = apply(controls2c.wxTreeCtrl_SetItemBold,(self.this,arg0.this,)+args)
+        return val
+    def IsBold(self,arg0):
+        val = controls2c.wxTreeCtrl_IsBold(self.this,arg0.this)
+        return val
+    def HitTest(self,arg0):
+        val = controls2c.wxTreeCtrl_HitTest(self.this,arg0.this)
+        val = wxTreeItemIdPtr(val)
+        val.thisown = 1
+        return val
+    def __repr__(self):
+        return "<C wxTreeCtrl instance>"
+class wxTreeCtrl(wxTreeCtrlPtr):
+    def __init__(self,arg0,*args) :
+        argl = map(None,args)
+        try: argl[1] = argl[1].this
+        except: pass
+        try: argl[2] = argl[2].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(controls2c.new_wxTreeCtrl,(arg0.this,)+args)
+        self.thisown = 1
+        wx._StdWindowCallbacks(self)
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+

utils/wxPython/src/gtk/events.py

@@ -0,0 +1,630 @@
+# This file was created automatically by SWIG.
+import eventsc
+
+from misc import *
+class wxEventPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetEventObject(self):
+        val = eventsc.wxEvent_GetEventObject(self.this)
+        return val
+    def GetEventType(self):
+        val = eventsc.wxEvent_GetEventType(self.this)
+        return val
+    def GetId(self):
+        val = eventsc.wxEvent_GetId(self.this)
+        return val
+    def GetSkipped(self):
+        val = eventsc.wxEvent_GetSkipped(self.this)
+        return val
+    def GetTimestamp(self):
+        val = eventsc.wxEvent_GetTimestamp(self.this)
+        return val
+    def SetEventObject(self,arg0):
+        val = eventsc.wxEvent_SetEventObject(self.this,arg0)
+        return val
+    def SetEventType(self,arg0):
+        val = eventsc.wxEvent_SetEventType(self.this,arg0)
+        return val
+    def SetId(self,arg0):
+        val = eventsc.wxEvent_SetId(self.this,arg0)
+        return val
+    def SetTimestamp(self,arg0):
+        val = eventsc.wxEvent_SetTimestamp(self.this,arg0)
+        return val
+    def Skip(self,*args):
+        val = apply(eventsc.wxEvent_Skip,(self.this,)+args)
+        return val
+    def __repr__(self):
+        return "<C wxEvent instance>"
+class wxEvent(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxSizeEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetSize(self):
+        val = eventsc.wxSizeEvent_GetSize(self.this)
+        val = wxSizePtr(val)
+        val.thisown = 1
+        return val
+    def __repr__(self):
+        return "<C wxSizeEvent instance>"
+class wxSizeEvent(wxSizeEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxCloseEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def CanVeto(self):
+        val = eventsc.wxCloseEvent_CanVeto(self.this)
+        return val
+    def GetLoggingOff(self):
+        val = eventsc.wxCloseEvent_GetLoggingOff(self.this)
+        return val
+    def Veto(self,*args):
+        val = apply(eventsc.wxCloseEvent_Veto,(self.this,)+args)
+        return val
+    def GetVeto(self):
+        val = eventsc.wxCloseEvent_GetVeto(self.this)
+        return val
+    def SetForce(self,arg0):
+        val = eventsc.wxCloseEvent_SetForce(self.this,arg0)
+        return val
+    def SetCanVeto(self,arg0):
+        val = eventsc.wxCloseEvent_SetCanVeto(self.this,arg0)
+        return val
+    def SetLoggingOff(self,arg0):
+        val = eventsc.wxCloseEvent_SetLoggingOff(self.this,arg0)
+        return val
+    def GetForce(self):
+        val = eventsc.wxCloseEvent_GetForce(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxCloseEvent instance>"
+class wxCloseEvent(wxCloseEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxCommandEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Checked(self):
+        val = eventsc.wxCommandEvent_Checked(self.this)
+        return val
+    def GetExtraLong(self):
+        val = eventsc.wxCommandEvent_GetExtraLong(self.this)
+        return val
+    def GetInt(self):
+        val = eventsc.wxCommandEvent_GetInt(self.this)
+        return val
+    def GetSelection(self):
+        val = eventsc.wxCommandEvent_GetSelection(self.this)
+        return val
+    def GetString(self):
+        val = eventsc.wxCommandEvent_GetString(self.this)
+        return val
+    def IsSelection(self):
+        val = eventsc.wxCommandEvent_IsSelection(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxCommandEvent instance>"
+class wxCommandEvent(wxCommandEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxScrollEventPtr(wxCommandEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetOrientation(self):
+        val = eventsc.wxScrollEvent_GetOrientation(self.this)
+        return val
+    def GetPosition(self):
+        val = eventsc.wxScrollEvent_GetPosition(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxScrollEvent instance>"
+class wxScrollEvent(wxScrollEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxSpinEventPtr(wxScrollEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxSpinEvent instance>"
+class wxSpinEvent(wxSpinEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxMouseEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def IsButton(self):
+        val = eventsc.wxMouseEvent_IsButton(self.this)
+        return val
+    def ButtonDown(self,*args):
+        val = apply(eventsc.wxMouseEvent_ButtonDown,(self.this,)+args)
+        return val
+    def ButtonDClick(self,*args):
+        val = apply(eventsc.wxMouseEvent_ButtonDClick,(self.this,)+args)
+        return val
+    def ButtonUp(self,*args):
+        val = apply(eventsc.wxMouseEvent_ButtonUp,(self.this,)+args)
+        return val
+    def Button(self,arg0):
+        val = eventsc.wxMouseEvent_Button(self.this,arg0)
+        return val
+    def ButtonIsDown(self,arg0):
+        val = eventsc.wxMouseEvent_ButtonIsDown(self.this,arg0)
+        return val
+    def ControlDown(self):
+        val = eventsc.wxMouseEvent_ControlDown(self.this)
+        return val
+    def MetaDown(self):
+        val = eventsc.wxMouseEvent_MetaDown(self.this)
+        return val
+    def AltDown(self):
+        val = eventsc.wxMouseEvent_AltDown(self.this)
+        return val
+    def ShiftDown(self):
+        val = eventsc.wxMouseEvent_ShiftDown(self.this)
+        return val
+    def LeftDown(self):
+        val = eventsc.wxMouseEvent_LeftDown(self.this)
+        return val
+    def MiddleDown(self):
+        val = eventsc.wxMouseEvent_MiddleDown(self.this)
+        return val
+    def RightDown(self):
+        val = eventsc.wxMouseEvent_RightDown(self.this)
+        return val
+    def LeftUp(self):
+        val = eventsc.wxMouseEvent_LeftUp(self.this)
+        return val
+    def MiddleUp(self):
+        val = eventsc.wxMouseEvent_MiddleUp(self.this)
+        return val
+    def RightUp(self):
+        val = eventsc.wxMouseEvent_RightUp(self.this)
+        return val
+    def LeftDClick(self):
+        val = eventsc.wxMouseEvent_LeftDClick(self.this)
+        return val
+    def MiddleDClick(self):
+        val = eventsc.wxMouseEvent_MiddleDClick(self.this)
+        return val
+    def RightDClick(self):
+        val = eventsc.wxMouseEvent_RightDClick(self.this)
+        return val
+    def LeftIsDown(self):
+        val = eventsc.wxMouseEvent_LeftIsDown(self.this)
+        return val
+    def MiddleIsDown(self):
+        val = eventsc.wxMouseEvent_MiddleIsDown(self.this)
+        return val
+    def RightIsDown(self):
+        val = eventsc.wxMouseEvent_RightIsDown(self.this)
+        return val
+    def Dragging(self):
+        val = eventsc.wxMouseEvent_Dragging(self.this)
+        return val
+    def Moving(self):
+        val = eventsc.wxMouseEvent_Moving(self.this)
+        return val
+    def Entering(self):
+        val = eventsc.wxMouseEvent_Entering(self.this)
+        return val
+    def Leaving(self):
+        val = eventsc.wxMouseEvent_Leaving(self.this)
+        return val
+    def Position(self):
+        val = eventsc.wxMouseEvent_Position(self.this)
+        return val
+    def GetPosition(self):
+        val = eventsc.wxMouseEvent_GetPosition(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetLogicalPosition(self,arg0):
+        val = eventsc.wxMouseEvent_GetLogicalPosition(self.this,arg0.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetX(self):
+        val = eventsc.wxMouseEvent_GetX(self.this)
+        return val
+    def GetY(self):
+        val = eventsc.wxMouseEvent_GetY(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxMouseEvent instance>"
+class wxMouseEvent(wxMouseEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxKeyEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def ControlDown(self):
+        val = eventsc.wxKeyEvent_ControlDown(self.this)
+        return val
+    def MetaDown(self):
+        val = eventsc.wxKeyEvent_MetaDown(self.this)
+        return val
+    def AltDown(self):
+        val = eventsc.wxKeyEvent_AltDown(self.this)
+        return val
+    def ShiftDown(self):
+        val = eventsc.wxKeyEvent_ShiftDown(self.this)
+        return val
+    def KeyCode(self):
+        val = eventsc.wxKeyEvent_KeyCode(self.this)
+        return val
+    def Position(self):
+        val = eventsc.wxKeyEvent_Position(self.this)
+        return val
+    def GetX(self):
+        val = eventsc.wxKeyEvent_GetX(self.this)
+        return val
+    def GetY(self):
+        val = eventsc.wxKeyEvent_GetY(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxKeyEvent instance>"
+class wxKeyEvent(wxKeyEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxMoveEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetPosition(self):
+        val = eventsc.wxMoveEvent_GetPosition(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def __repr__(self):
+        return "<C wxMoveEvent instance>"
+class wxMoveEvent(wxMoveEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxPaintEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxPaintEvent instance>"
+class wxPaintEvent(wxPaintEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxEraseEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetDC(self):
+        val = eventsc.wxEraseEvent_GetDC(self.this)
+        val = wxDCPtr(val)
+        return val
+    def __repr__(self):
+        return "<C wxEraseEvent instance>"
+class wxEraseEvent(wxEraseEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxFocusEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxFocusEvent instance>"
+class wxFocusEvent(wxFocusEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxActivateEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetActive(self):
+        val = eventsc.wxActivateEvent_GetActive(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxActivateEvent instance>"
+class wxActivateEvent(wxActivateEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxInitDialogEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxInitDialogEvent instance>"
+class wxInitDialogEvent(wxInitDialogEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxMenuEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetMenuId(self):
+        val = eventsc.wxMenuEvent_GetMenuId(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxMenuEvent instance>"
+class wxMenuEvent(wxMenuEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxShowEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def SetShow(self,arg0):
+        val = eventsc.wxShowEvent_SetShow(self.this,arg0)
+        return val
+    def GetShow(self):
+        val = eventsc.wxShowEvent_GetShow(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxShowEvent instance>"
+class wxShowEvent(wxShowEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxIconizeEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxIconizeEvent instance>"
+class wxIconizeEvent(wxIconizeEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxMaximizeEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxMaximizeEvent instance>"
+class wxMaximizeEvent(wxMaximizeEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxJoystickEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetPosition(self):
+        val = eventsc.wxJoystickEvent_GetPosition(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetZPosition(self):
+        val = eventsc.wxJoystickEvent_GetZPosition(self.this)
+        return val
+    def GetButtonState(self):
+        val = eventsc.wxJoystickEvent_GetButtonState(self.this)
+        return val
+    def GetButtonChange(self):
+        val = eventsc.wxJoystickEvent_GetButtonChange(self.this)
+        return val
+    def GetJoystick(self):
+        val = eventsc.wxJoystickEvent_GetJoystick(self.this)
+        return val
+    def SetJoystick(self,arg0):
+        val = eventsc.wxJoystickEvent_SetJoystick(self.this,arg0)
+        return val
+    def SetButtonState(self,arg0):
+        val = eventsc.wxJoystickEvent_SetButtonState(self.this,arg0)
+        return val
+    def SetButtonChange(self,arg0):
+        val = eventsc.wxJoystickEvent_SetButtonChange(self.this,arg0)
+        return val
+    def SetPosition(self,arg0):
+        val = eventsc.wxJoystickEvent_SetPosition(self.this,arg0.this)
+        return val
+    def SetZPosition(self,arg0):
+        val = eventsc.wxJoystickEvent_SetZPosition(self.this,arg0)
+        return val
+    def IsButton(self):
+        val = eventsc.wxJoystickEvent_IsButton(self.this)
+        return val
+    def IsMove(self):
+        val = eventsc.wxJoystickEvent_IsMove(self.this)
+        return val
+    def IsZMove(self):
+        val = eventsc.wxJoystickEvent_IsZMove(self.this)
+        return val
+    def ButtonDown(self,*args):
+        val = apply(eventsc.wxJoystickEvent_ButtonDown,(self.this,)+args)
+        return val
+    def ButtonUp(self,*args):
+        val = apply(eventsc.wxJoystickEvent_ButtonUp,(self.this,)+args)
+        return val
+    def ButtonIsDown(self,*args):
+        val = apply(eventsc.wxJoystickEvent_ButtonIsDown,(self.this,)+args)
+        return val
+    def __repr__(self):
+        return "<C wxJoystickEvent instance>"
+class wxJoystickEvent(wxJoystickEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxDropFilesEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetPosition(self):
+        val = eventsc.wxDropFilesEvent_GetPosition(self.this)
+        val = wxPointPtr(val)
+        val.thisown = 1
+        return val
+    def GetNumberOfFiles(self):
+        val = eventsc.wxDropFilesEvent_GetNumberOfFiles(self.this)
+        return val
+    def GetFiles(self):
+        val = eventsc.wxDropFilesEvent_GetFiles(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxDropFilesEvent instance>"
+class wxDropFilesEvent(wxDropFilesEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxIdleEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def RequestMore(self,*args):
+        val = apply(eventsc.wxIdleEvent_RequestMore,(self.this,)+args)
+        return val
+    def MoreRequested(self):
+        val = eventsc.wxIdleEvent_MoreRequested(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxIdleEvent instance>"
+class wxIdleEvent(wxIdleEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxUpdateUIEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetChecked(self):
+        val = eventsc.wxUpdateUIEvent_GetChecked(self.this)
+        return val
+    def GetEnabled(self):
+        val = eventsc.wxUpdateUIEvent_GetEnabled(self.this)
+        return val
+    def GetText(self):
+        val = eventsc.wxUpdateUIEvent_GetText(self.this)
+        return val
+    def GetSetText(self):
+        val = eventsc.wxUpdateUIEvent_GetSetText(self.this)
+        return val
+    def GetSetChecked(self):
+        val = eventsc.wxUpdateUIEvent_GetSetChecked(self.this)
+        return val
+    def GetSetEnabled(self):
+        val = eventsc.wxUpdateUIEvent_GetSetEnabled(self.this)
+        return val
+    def Check(self,arg0):
+        val = eventsc.wxUpdateUIEvent_Check(self.this,arg0)
+        return val
+    def Enable(self,arg0):
+        val = eventsc.wxUpdateUIEvent_Enable(self.this,arg0)
+        return val
+    def SetText(self,arg0):
+        val = eventsc.wxUpdateUIEvent_SetText(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxUpdateUIEvent instance>"
+class wxUpdateUIEvent(wxUpdateUIEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxSysColourChangedEventPtr(wxEventPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxSysColourChangedEvent instance>"
+class wxSysColourChangedEvent(wxSysColourChangedEventPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+

utils/wxPython/src/gtk/frames.py

@@ -0,0 +1,124 @@
+# This file was created automatically by SWIG.
+import framesc
+
+from misc import *
+
+from gdi import *
+
+from windows import *
+
+from stattool import *
+
+from controls import *
+
+from events import *
+import wx
+class wxFramePtr(wxWindowPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def Centre(self,*args):
+        val = apply(framesc.wxFrame_Centre,(self.this,)+args)
+        return val
+    def CreateStatusBar(self,*args):
+        val = apply(framesc.wxFrame_CreateStatusBar,(self.this,)+args)
+        val = wxStatusBarPtr(val)
+        return val
+    def CreateToolBar(self,*args):
+        val = apply(framesc.wxFrame_CreateToolBar,(self.this,)+args)
+        val = wxToolBarPtr(val)
+        return val
+    def GetMenuBar(self):
+        val = framesc.wxFrame_GetMenuBar(self.this)
+        val = wxMenuBarPtr(val)
+        return val
+    def GetStatusBar(self):
+        val = framesc.wxFrame_GetStatusBar(self.this)
+        val = wxStatusBarPtr(val)
+        return val
+    def GetTitle(self):
+        val = framesc.wxFrame_GetTitle(self.this)
+        return val
+    def GetToolBar(self):
+        val = framesc.wxFrame_GetToolBar(self.this)
+        val = wxToolBarPtr(val)
+        return val
+    def Iconize(self,arg0):
+        val = framesc.wxFrame_Iconize(self.this,arg0)
+        return val
+    def IsIconized(self):
+        val = framesc.wxFrame_IsIconized(self.this)
+        return val
+    def Maximize(self,arg0):
+        val = framesc.wxFrame_Maximize(self.this,arg0)
+        return val
+    def SetAcceleratorTable(self,arg0):
+        val = framesc.wxFrame_SetAcceleratorTable(self.this,arg0.this)
+        return val
+    def SetIcon(self,arg0):
+        val = framesc.wxFrame_SetIcon(self.this,arg0.this)
+        return val
+    def SetMenuBar(self,arg0):
+        val = framesc.wxFrame_SetMenuBar(self.this,arg0.this)
+        return val
+    def SetStatusBar(self,arg0):
+        val = framesc.wxFrame_SetStatusBar(self.this,arg0.this)
+        return val
+    def SetStatusText(self,arg0,*args):
+        val = apply(framesc.wxFrame_SetStatusText,(self.this,arg0,)+args)
+        return val
+    def SetStatusWidths(self,arg0,*args):
+        val = apply(framesc.wxFrame_SetStatusWidths,(self.this,arg0,)+args)
+        return val
+    def SetTitle(self,arg0):
+        val = framesc.wxFrame_SetTitle(self.this,arg0)
+        return val
+    def SetToolBar(self,arg0):
+        val = framesc.wxFrame_SetToolBar(self.this,arg0.this)
+        return val
+    def __repr__(self):
+        return "<C wxFrame instance>"
+class wxFrame(wxFramePtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(framesc.new_wxFrame,(arg0.this,arg1,arg2,)+args)
+        self.thisown = 1
+        wx._StdFrameCallbacks(self)
+
+
+
+
+class wxMiniFramePtr(wxFramePtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxMiniFrame instance>"
+class wxMiniFrame(wxMiniFramePtr):
+    def __init__(self,arg0,arg1,arg2,*args) :
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(framesc.new_wxMiniFrame,(arg0.this,arg1,arg2,)+args)
+        self.thisown = 1
+        wx._StdFrameCallbacks(self)
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+

utils/wxPython/src/gtk/gdi.py

@@ -0,0 +1,758 @@
+# This file was created automatically by SWIG.
+import gdic
+
+from misc import *
+class wxBitmapPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            gdic.delete_wxBitmap(self.this)
+    def GetDepth(self):
+        val = gdic.wxBitmap_GetDepth(self.this)
+        return val
+    def GetHeight(self):
+        val = gdic.wxBitmap_GetHeight(self.this)
+        return val
+    def GetPalette(self):
+        val = gdic.wxBitmap_GetPalette(self.this)
+        val = wxPalettePtr(val)
+        return val
+    def GetMask(self):
+        val = gdic.wxBitmap_GetMask(self.this)
+        val = wxMaskPtr(val)
+        return val
+    def GetWidth(self):
+        val = gdic.wxBitmap_GetWidth(self.this)
+        return val
+    def LoadFile(self,arg0,arg1):
+        val = gdic.wxBitmap_LoadFile(self.this,arg0,arg1)
+        return val
+    def Ok(self):
+        val = gdic.wxBitmap_Ok(self.this)
+        return val
+    def SaveFile(self,arg0,arg1,*args):
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        val = apply(gdic.wxBitmap_SaveFile,(self.this,arg0,arg1,)+args)
+        return val
+    def SetDepth(self,arg0):
+        val = gdic.wxBitmap_SetDepth(self.this,arg0)
+        return val
+    def SetHeight(self,arg0):
+        val = gdic.wxBitmap_SetHeight(self.this,arg0)
+        return val
+    def SetMask(self,arg0):
+        val = gdic.wxBitmap_SetMask(self.this,arg0.this)
+        return val
+    def SetWidth(self,arg0):
+        val = gdic.wxBitmap_SetWidth(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxBitmap instance>"
+class wxBitmap(wxBitmapPtr):
+    def __init__(self,arg0,arg1) :
+        self.this = gdic.new_wxBitmap(arg0,arg1)
+        self.thisown = 1
+
+
+
+
+class wxMaskPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            gdic.delete_wxMask(self.this)
+    def __repr__(self):
+        return "<C wxMask instance>"
+class wxMask(wxMaskPtr):
+    def __init__(self,arg0) :
+        self.this = gdic.new_wxMask(arg0.this)
+        self.thisown = 1
+
+
+
+
+class wxIconPtr(wxBitmapPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            gdic.delete_wxIcon(self.this)
+    def GetDepth(self):
+        val = gdic.wxIcon_GetDepth(self.this)
+        return val
+    def GetHeight(self):
+        val = gdic.wxIcon_GetHeight(self.this)
+        return val
+    def GetWidth(self):
+        val = gdic.wxIcon_GetWidth(self.this)
+        return val
+    def LoadFile(self,arg0,arg1):
+        val = gdic.wxIcon_LoadFile(self.this,arg0,arg1)
+        return val
+    def Ok(self):
+        val = gdic.wxIcon_Ok(self.this)
+        return val
+    def SetDepth(self,arg0):
+        val = gdic.wxIcon_SetDepth(self.this,arg0)
+        return val
+    def SetHeight(self,arg0):
+        val = gdic.wxIcon_SetHeight(self.this,arg0)
+        return val
+    def SetWidth(self,arg0):
+        val = gdic.wxIcon_SetWidth(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxIcon instance>"
+class wxIcon(wxIconPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxCursorPtr(wxBitmapPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            gdic.delete_wxCursor(self.this)
+    def Ok(self):
+        val = gdic.wxCursor_Ok(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxCursor instance>"
+class wxCursor(wxCursorPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxFontPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetFaceName(self):
+        val = gdic.wxFont_GetFaceName(self.this)
+        return val
+    def GetFamily(self):
+        val = gdic.wxFont_GetFamily(self.this)
+        return val
+    def GetPointSize(self):
+        val = gdic.wxFont_GetPointSize(self.this)
+        return val
+    def GetStyle(self):
+        val = gdic.wxFont_GetStyle(self.this)
+        return val
+    def GetUnderlined(self):
+        val = gdic.wxFont_GetUnderlined(self.this)
+        return val
+    def GetWeight(self):
+        val = gdic.wxFont_GetWeight(self.this)
+        return val
+    def SetFaceName(self,arg0):
+        val = gdic.wxFont_SetFaceName(self.this,arg0)
+        return val
+    def SetFamily(self,arg0):
+        val = gdic.wxFont_SetFamily(self.this,arg0)
+        return val
+    def SetPointSize(self,arg0):
+        val = gdic.wxFont_SetPointSize(self.this,arg0)
+        return val
+    def SetStyle(self,arg0):
+        val = gdic.wxFont_SetStyle(self.this,arg0)
+        return val
+    def SetUnderlined(self,arg0):
+        val = gdic.wxFont_SetUnderlined(self.this,arg0)
+        return val
+    def SetWeight(self,arg0):
+        val = gdic.wxFont_SetWeight(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxFont instance>"
+class wxFont(wxFontPtr):
+    def __init__(self,arg0,arg1,arg2,arg3,*args) :
+        self.this = apply(gdic.new_wxFont,(arg0,arg1,arg2,arg3,)+args)
+        self.thisown = 1
+
+
+
+
+class wxColourPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            gdic.delete_wxColour(self.this)
+    def Red(self):
+        val = gdic.wxColour_Red(self.this)
+        return val
+    def Green(self):
+        val = gdic.wxColour_Green(self.this)
+        return val
+    def Blue(self):
+        val = gdic.wxColour_Blue(self.this)
+        return val
+    def Ok(self):
+        val = gdic.wxColour_Ok(self.this)
+        return val
+    def Set(self,arg0,arg1,arg2):
+        val = gdic.wxColour_Set(self.this,arg0,arg1,arg2)
+        return val
+    def Get(self):
+        val = gdic.wxColour_Get(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxColour instance>"
+class wxColour(wxColourPtr):
+    def __init__(self,*args) :
+        self.this = apply(gdic.new_wxColour,()+args)
+        self.thisown = 1
+
+
+
+
+class wxPenPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetCap(self):
+        val = gdic.wxPen_GetCap(self.this)
+        return val
+    def GetColour(self):
+        val = gdic.wxPen_GetColour(self.this)
+        val = wxColourPtr(val)
+        return val
+    def GetJoin(self):
+        val = gdic.wxPen_GetJoin(self.this)
+        return val
+    def GetStyle(self):
+        val = gdic.wxPen_GetStyle(self.this)
+        return val
+    def GetWidth(self):
+        val = gdic.wxPen_GetWidth(self.this)
+        return val
+    def Ok(self):
+        val = gdic.wxPen_Ok(self.this)
+        return val
+    def SetCap(self,arg0):
+        val = gdic.wxPen_SetCap(self.this,arg0)
+        return val
+    def SetColour(self,arg0):
+        val = gdic.wxPen_SetColour(self.this,arg0.this)
+        return val
+    def SetJoin(self,arg0):
+        val = gdic.wxPen_SetJoin(self.this,arg0)
+        return val
+    def SetStyle(self,arg0):
+        val = gdic.wxPen_SetStyle(self.this,arg0)
+        return val
+    def SetWidth(self,arg0):
+        val = gdic.wxPen_SetWidth(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxPen instance>"
+class wxPen(wxPenPtr):
+    def __init__(self,arg0,*args) :
+        self.this = apply(gdic.new_wxPen,(arg0.this,)+args)
+        self.thisown = 1
+
+
+
+
+class wxBrushPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def GetColour(self):
+        val = gdic.wxBrush_GetColour(self.this)
+        val = wxColourPtr(val)
+        return val
+    def GetStipple(self):
+        val = gdic.wxBrush_GetStipple(self.this)
+        val = wxBitmapPtr(val)
+        return val
+    def GetStyle(self):
+        val = gdic.wxBrush_GetStyle(self.this)
+        return val
+    def Ok(self):
+        val = gdic.wxBrush_Ok(self.this)
+        return val
+    def SetColour(self,arg0):
+        val = gdic.wxBrush_SetColour(self.this,arg0.this)
+        return val
+    def SetStipple(self,arg0):
+        val = gdic.wxBrush_SetStipple(self.this,arg0.this)
+        return val
+    def SetStyle(self,arg0):
+        val = gdic.wxBrush_SetStyle(self.this,arg0)
+        return val
+    def __repr__(self):
+        return "<C wxBrush instance>"
+class wxBrush(wxBrushPtr):
+    def __init__(self,arg0,*args) :
+        self.this = apply(gdic.new_wxBrush,(arg0.this,)+args)
+        self.thisown = 1
+
+
+
+
+class wxDCPtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            gdic.delete_wxDC(self.this)
+    def BeginDrawing(self):
+        val = gdic.wxDC_BeginDrawing(self.this)
+        return val
+    def Blit(self,arg0,arg1,arg2,arg3,arg4,arg5,arg6,arg7):
+        val = gdic.wxDC_Blit(self.this,arg0,arg1,arg2,arg3,arg4.this,arg5,arg6,arg7)
+        return val
+    def Clear(self):
+        val = gdic.wxDC_Clear(self.this)
+        return val
+    def CrossHair(self,arg0,arg1):
+        val = gdic.wxDC_CrossHair(self.this,arg0,arg1)
+        return val
+    def DestroyClippingRegion(self):
+        val = gdic.wxDC_DestroyClippingRegion(self.this)
+        return val
+    def DeviceToLogicalX(self,arg0):
+        val = gdic.wxDC_DeviceToLogicalX(self.this,arg0)
+        return val
+    def DeviceToLogicalXRel(self,arg0):
+        val = gdic.wxDC_DeviceToLogicalXRel(self.this,arg0)
+        return val
+    def DeviceToLogicalY(self,arg0):
+        val = gdic.wxDC_DeviceToLogicalY(self.this,arg0)
+        return val
+    def DeviceToLogicalYRel(self,arg0):
+        val = gdic.wxDC_DeviceToLogicalYRel(self.this,arg0)
+        return val
+    def DrawArc(self,arg0,arg1,arg2,arg3,arg4,arg5):
+        val = gdic.wxDC_DrawArc(self.this,arg0,arg1,arg2,arg3,arg4,arg5)
+        return val
+    def DrawEllipse(self,arg0,arg1,arg2,arg3):
+        val = gdic.wxDC_DrawEllipse(self.this,arg0,arg1,arg2,arg3)
+        return val
+    def DrawEllipticArc(self,arg0,arg1,arg2,arg3,arg4,arg5):
+        val = gdic.wxDC_DrawEllipticArc(self.this,arg0,arg1,arg2,arg3,arg4,arg5)
+        return val
+    def DrawIcon(self,arg0,arg1,arg2):
+        val = gdic.wxDC_DrawIcon(self.this,arg0.this,arg1,arg2)
+        return val
+    def DrawLine(self,arg0,arg1,arg2,arg3):
+        val = gdic.wxDC_DrawLine(self.this,arg0,arg1,arg2,arg3)
+        return val
+    def DrawLines(self,arg0,*args):
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        val = apply(gdic.wxDC_DrawLines,(self.this,arg0,)+args)
+        return val
+    def DrawPolygon(self,arg0,*args):
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        val = apply(gdic.wxDC_DrawPolygon,(self.this,arg0,)+args)
+        return val
+    def DrawPoint(self,arg0,arg1):
+        val = gdic.wxDC_DrawPoint(self.this,arg0,arg1)
+        return val
+    def DrawRectangle(self,arg0,arg1,arg2,arg3):
+        val = gdic.wxDC_DrawRectangle(self.this,arg0,arg1,arg2,arg3)
+        return val
+    def DrawRoundedRectangle(self,arg0,arg1,arg2,arg3,*args):
+        val = apply(gdic.wxDC_DrawRoundedRectangle,(self.this,arg0,arg1,arg2,arg3,)+args)
+        return val
+    def DrawSpline(self,arg0,*args):
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        val = apply(gdic.wxDC_DrawSpline,(self.this,arg0,)+args)
+        return val
+    def DrawText(self,arg0,arg1,arg2):
+        val = gdic.wxDC_DrawText(self.this,arg0,arg1,arg2)
+        return val
+    def EndDoc(self):
+        val = gdic.wxDC_EndDoc(self.this)
+        return val
+    def EndDrawing(self):
+        val = gdic.wxDC_EndDrawing(self.this)
+        return val
+    def EndPage(self):
+        val = gdic.wxDC_EndPage(self.this)
+        return val
+    def FloodFill(self,arg0,arg1,arg2,*args):
+        val = apply(gdic.wxDC_FloodFill,(self.this,arg0,arg1,arg2.this,)+args)
+        return val
+    def GetBackground(self):
+        val = gdic.wxDC_GetBackground(self.this)
+        val = wxBrushPtr(val)
+        return val
+    def GetBrush(self):
+        val = gdic.wxDC_GetBrush(self.this)
+        val = wxBrushPtr(val)
+        return val
+    def GetCharHeight(self):
+        val = gdic.wxDC_GetCharHeight(self.this)
+        return val
+    def GetCharWidth(self):
+        val = gdic.wxDC_GetCharWidth(self.this)
+        return val
+    def GetClippingBox(self):
+        val = gdic.wxDC_GetClippingBox(self.this)
+        return val
+    def GetFont(self):
+        val = gdic.wxDC_GetFont(self.this)
+        val = wxFontPtr(val)
+        return val
+    def GetLogicalFunction(self):
+        val = gdic.wxDC_GetLogicalFunction(self.this)
+        return val
+    def GetMapMode(self):
+        val = gdic.wxDC_GetMapMode(self.this)
+        return val
+    def GetOptimization(self):
+        val = gdic.wxDC_GetOptimization(self.this)
+        return val
+    def GetPen(self):
+        val = gdic.wxDC_GetPen(self.this)
+        val = wxPenPtr(val)
+        return val
+    def GetPixel(self,arg0,arg1):
+        val = gdic.wxDC_GetPixel(self.this,arg0,arg1)
+        val = wxColourPtr(val)
+        val.thisown = 1
+        return val
+    def GetSize(self):
+        val = gdic.wxDC_GetSize(self.this)
+        return val
+    def GetTextBackground(self):
+        val = gdic.wxDC_GetTextBackground(self.this)
+        val = wxColourPtr(val)
+        return val
+    def GetTextExtent(self,arg0):
+        val = gdic.wxDC_GetTextExtent(self.this,arg0)
+        return val
+    def GetTextForeground(self):
+        val = gdic.wxDC_GetTextForeground(self.this)
+        val = wxColourPtr(val)
+        return val
+    def LogicalToDeviceX(self,arg0):
+        val = gdic.wxDC_LogicalToDeviceX(self.this,arg0)
+        return val
+    def LogicalToDeviceXRel(self,arg0):
+        val = gdic.wxDC_LogicalToDeviceXRel(self.this,arg0)
+        return val
+    def LogicalToDeviceY(self,arg0):
+        val = gdic.wxDC_LogicalToDeviceY(self.this,arg0)
+        return val
+    def LogicalToDeviceYRel(self,arg0):
+        val = gdic.wxDC_LogicalToDeviceYRel(self.this,arg0)
+        return val
+    def MaxX(self):
+        val = gdic.wxDC_MaxX(self.this)
+        return val
+    def MaxY(self):
+        val = gdic.wxDC_MaxY(self.this)
+        return val
+    def MinX(self):
+        val = gdic.wxDC_MinX(self.this)
+        return val
+    def MinY(self):
+        val = gdic.wxDC_MinY(self.this)
+        return val
+    def Ok(self):
+        val = gdic.wxDC_Ok(self.this)
+        return val
+    def SetDeviceOrigin(self,arg0,arg1):
+        val = gdic.wxDC_SetDeviceOrigin(self.this,arg0,arg1)
+        return val
+    def SetBackground(self,arg0):
+        val = gdic.wxDC_SetBackground(self.this,arg0.this)
+        return val
+    def SetBackgroundMode(self,arg0):
+        val = gdic.wxDC_SetBackgroundMode(self.this,arg0)
+        return val
+    def SetClippingRegion(self,arg0,arg1,arg2,arg3):
+        val = gdic.wxDC_SetClippingRegion(self.this,arg0,arg1,arg2,arg3)
+        return val
+    def SetPalette(self,arg0):
+        val = gdic.wxDC_SetPalette(self.this,arg0.this)
+        return val
+    def SetBrush(self,arg0):
+        val = gdic.wxDC_SetBrush(self.this,arg0.this)
+        return val
+    def SetFont(self,arg0):
+        val = gdic.wxDC_SetFont(self.this,arg0.this)
+        return val
+    def SetLogicalFunction(self,arg0):
+        val = gdic.wxDC_SetLogicalFunction(self.this,arg0)
+        return val
+    def SetMapMode(self,arg0):
+        val = gdic.wxDC_SetMapMode(self.this,arg0)
+        return val
+    def SetOptimization(self,arg0):
+        val = gdic.wxDC_SetOptimization(self.this,arg0)
+        return val
+    def SetPen(self,arg0):
+        val = gdic.wxDC_SetPen(self.this,arg0.this)
+        return val
+    def SetTextBackground(self,arg0):
+        val = gdic.wxDC_SetTextBackground(self.this,arg0.this)
+        return val
+    def SetTextForeground(self,arg0):
+        val = gdic.wxDC_SetTextForeground(self.this,arg0.this)
+        return val
+    def SetUserScale(self,arg0,arg1):
+        val = gdic.wxDC_SetUserScale(self.this,arg0,arg1)
+        return val
+    def StartDoc(self,arg0):
+        val = gdic.wxDC_StartDoc(self.this,arg0)
+        return val
+    def StartPage(self):
+        val = gdic.wxDC_StartPage(self.this)
+        return val
+    def DrawBitmap(self,arg0,arg1,arg2,*args):
+        val = apply(gdic.wxDC_DrawBitmap,(self.this,arg0.this,arg1,arg2,)+args)
+        return val
+    def __repr__(self):
+        return "<C wxDC instance>"
+class wxDC(wxDCPtr):
+    def __init__(self,this):
+        self.this = this
+
+
+
+
+class wxMemoryDCPtr(wxDCPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def SelectObject(self,arg0):
+        val = gdic.wxMemoryDC_SelectObject(self.this,arg0.this)
+        return val
+    def __repr__(self):
+        return "<C wxMemoryDC instance>"
+class wxMemoryDC(wxMemoryDCPtr):
+    def __init__(self) :
+        self.this = gdic.new_wxMemoryDC()
+        self.thisown = 1
+
+
+
+
+class wxScreenDCPtr(wxDCPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def StartDrawingOnTop(self,arg0):
+        val = gdic.wxScreenDC_StartDrawingOnTop(self.this,arg0.this)
+        return val
+    def StartDrawingOnTopRect(self,*args):
+        argl = map(None,args)
+        try: argl[0] = argl[0].this
+        except: pass
+        args = tuple(argl)
+        val = apply(gdic.wxScreenDC_StartDrawingOnTopRect,(self.this,)+args)
+        return val
+    def EndDrawingOnTop(self):
+        val = gdic.wxScreenDC_EndDrawingOnTop(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxScreenDC instance>"
+class wxScreenDC(wxScreenDCPtr):
+    def __init__(self) :
+        self.this = gdic.new_wxScreenDC()
+        self.thisown = 1
+
+
+
+
+class wxClientDCPtr(wxDCPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxClientDC instance>"
+class wxClientDC(wxClientDCPtr):
+    def __init__(self,arg0) :
+        self.this = gdic.new_wxClientDC(arg0.this)
+        self.thisown = 1
+
+
+
+
+class wxPaintDCPtr(wxDCPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxPaintDC instance>"
+class wxPaintDC(wxPaintDCPtr):
+    def __init__(self,arg0) :
+        self.this = gdic.new_wxPaintDC(arg0.this)
+        self.thisown = 1
+
+
+
+
+class wxWindowDCPtr(wxDCPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxWindowDC instance>"
+class wxWindowDC(wxWindowDCPtr):
+    def __init__(self,arg0) :
+        self.this = gdic.new_wxWindowDC(arg0.this)
+        self.thisown = 1
+
+
+
+
+class wxPostScriptDCPtr(wxDCPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxPostScriptDC instance>"
+class wxPostScriptDC(wxPostScriptDCPtr):
+    def __init__(self,arg0,*args) :
+        argl = map(None,args)
+        try: argl[1] = argl[1].this
+        except: pass
+        args = tuple(argl)
+        self.this = apply(gdic.new_wxPostScriptDC,(arg0,)+args)
+        self.thisown = 1
+
+
+
+
+class wxPalettePtr :
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __del__(self):
+        if self.thisown == 1 :
+            gdic.delete_wxPalette(self.this)
+    def GetPixel(self,arg0,arg1,arg2):
+        val = gdic.wxPalette_GetPixel(self.this,arg0,arg1,arg2)
+        return val
+    def GetRGB(self,arg0,arg1,arg2,arg3):
+        val = gdic.wxPalette_GetRGB(self.this,arg0,arg1,arg2,arg3)
+        return val
+    def Ok(self):
+        val = gdic.wxPalette_Ok(self.this)
+        return val
+    def __repr__(self):
+        return "<C wxPalette instance>"
+class wxPalette(wxPalettePtr):
+    def __init__(self,arg0,arg1,arg2) :
+        self.this = gdic.new_wxPalette(arg0,arg1,arg2)
+        self.thisown = 1
+
+
+
+
+
+
+#-------------- FUNCTION WRAPPERS ------------------
+
+def wxEmptyBitmap(arg0,arg1,*args):
+    val = apply(gdic.wxEmptyBitmap,(arg0,arg1,)+args)
+    val = wxBitmapPtr(val)
+    val.thisown = 1
+    return val
+
+def wxNoRefBitmap(arg0,arg1):
+    val = gdic.wxNoRefBitmap(arg0,arg1)
+    val = wxBitmapPtr(val)
+    return val
+
+def wxMaskColour(arg0,arg1):
+    val = gdic.wxMaskColour(arg0.this,arg1.this)
+    val = wxMaskPtr(val)
+    val.thisown = 1
+    return val
+
+def wxStockCursor(arg0):
+    val = gdic.wxStockCursor(arg0)
+    val = wxCursorPtr(val)
+    val.thisown = 1
+    return val
+
+def wxNamedColour(arg0):
+    val = gdic.wxNamedColour(arg0)
+    val = wxColourPtr(val)
+    val.thisown = 1
+    return val
+
+def wxMemoryDCFromDC(arg0):
+    val = gdic.wxMemoryDCFromDC(arg0.this)
+    val = wxMemoryDCPtr(val)
+    val.thisown = 1
+    return val
+
+
+
+#-------------- VARIABLE WRAPPERS ------------------
+
+cvar = gdic.cvar
+wxNORMAL_FONT = wxFontPtr(gdic.cvar.wxNORMAL_FONT)
+wxSMALL_FONT = wxFontPtr(gdic.cvar.wxSMALL_FONT)
+wxITALIC_FONT = wxFontPtr(gdic.cvar.wxITALIC_FONT)
+wxSWISS_FONT = wxFontPtr(gdic.cvar.wxSWISS_FONT)
+wxRED_PEN = wxPenPtr(gdic.cvar.wxRED_PEN)
+wxCYAN_PEN = wxPenPtr(gdic.cvar.wxCYAN_PEN)
+wxGREEN_PEN = wxPenPtr(gdic.cvar.wxGREEN_PEN)
+wxBLACK_PEN = wxPenPtr(gdic.cvar.wxBLACK_PEN)
+wxWHITE_PEN = wxPenPtr(gdic.cvar.wxWHITE_PEN)
+wxTRANSPARENT_PEN = wxPenPtr(gdic.cvar.wxTRANSPARENT_PEN)
+wxBLACK_DASHED_PEN = wxPenPtr(gdic.cvar.wxBLACK_DASHED_PEN)
+wxGREY_PEN = wxPenPtr(gdic.cvar.wxGREY_PEN)
+wxMEDIUM_GREY_PEN = wxPenPtr(gdic.cvar.wxMEDIUM_GREY_PEN)
+wxLIGHT_GREY_PEN = wxPenPtr(gdic.cvar.wxLIGHT_GREY_PEN)
+wxBLUE_BRUSH = wxBrushPtr(gdic.cvar.wxBLUE_BRUSH)
+wxGREEN_BRUSH = wxBrushPtr(gdic.cvar.wxGREEN_BRUSH)
+wxWHITE_BRUSH = wxBrushPtr(gdic.cvar.wxWHITE_BRUSH)
+wxBLACK_BRUSH = wxBrushPtr(gdic.cvar.wxBLACK_BRUSH)
+wxTRANSPARENT_BRUSH = wxBrushPtr(gdic.cvar.wxTRANSPARENT_BRUSH)
+wxCYAN_BRUSH = wxBrushPtr(gdic.cvar.wxCYAN_BRUSH)
+wxRED_BRUSH = wxBrushPtr(gdic.cvar.wxRED_BRUSH)
+wxGREY_BRUSH = wxBrushPtr(gdic.cvar.wxGREY_BRUSH)
+wxMEDIUM_GREY_BRUSH = wxBrushPtr(gdic.cvar.wxMEDIUM_GREY_BRUSH)
+wxLIGHT_GREY_BRUSH = wxBrushPtr(gdic.cvar.wxLIGHT_GREY_BRUSH)
+wxBLACK = wxColourPtr(gdic.cvar.wxBLACK)
+wxWHITE = wxColourPtr(gdic.cvar.wxWHITE)
+wxRED = wxColourPtr(gdic.cvar.wxRED)
+wxBLUE = wxColourPtr(gdic.cvar.wxBLUE)
+wxGREEN = wxColourPtr(gdic.cvar.wxGREEN)
+wxCYAN = wxColourPtr(gdic.cvar.wxCYAN)
+wxLIGHT_GREY = wxColourPtr(gdic.cvar.wxLIGHT_GREY)
+wxSTANDARD_CURSOR = wxCursorPtr(gdic.cvar.wxSTANDARD_CURSOR)
+wxHOURGLASS_CURSOR = wxCursorPtr(gdic.cvar.wxHOURGLASS_CURSOR)
+wxCROSS_CURSOR = wxCursorPtr(gdic.cvar.wxCROSS_CURSOR)
+wxNullBitmap = wxBitmapPtr(gdic.cvar.wxNullBitmap)
+wxNullIcon = wxIconPtr(gdic.cvar.wxNullIcon)
+wxNullCursor = wxCursorPtr(gdic.cvar.wxNullCursor)
+wxNullPen = wxPenPtr(gdic.cvar.wxNullPen)
+wxNullBrush = wxBrushPtr(gdic.cvar.wxNullBrush)
+wxNullFont = wxFontPtr(gdic.cvar.wxNullFont)
+wxNullColour = wxColourPtr(gdic.cvar.wxNullColour)

utils/wxPython/src/gtk/mdi.cpp

@@ -0,0 +1,964 @@
+/*
+ * FILE : gtk/mdi.cpp
+ * 
+ * This file was automatically generated by :
+ * Simplified Wrapper and Interface Generator (SWIG)
+ * Version 1.1 (Patch 5)
+ * 
+ * Portions Copyright (c) 1995-1998
+ * The University of Utah and The Regents of the University of California.
+ * Permission is granted to distribute this file in any manner provided
+ * this notice remains intact.
+ * 
+ * Do not make changes to this file--changes will be lost!
+ *
+ */
+
+
+#define SWIGCODE
+/* Implementation : PYTHON */
+
+#define SWIGPYTHON
+#include <string.h>
+#include <stdlib.h>
+/* Definitions for Windows/Unix exporting */
+#if defined(__WIN32__)
+#   if defined(_MSC_VER)
+#	define SWIGEXPORT(a,b) __declspec(dllexport) a b
+#   else
+#	if defined(__BORLANDC__)
+#	    define SWIGEXPORT(a,b) a _export b
+#	else
+#	    define SWIGEXPORT(a,b) a b
+#	endif
+#   endif
+#else
+#   define SWIGEXPORT(a,b) a b
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "Python.h"
+extern void SWIG_MakePtr(char *, void *, char *);
+extern void SWIG_RegisterMapping(char *, char *, void *(*)(void *));
+extern char *SWIG_GetPtr(char *, void **, char *);
+extern void SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
+extern PyObject *SWIG_newvarlink(void);
+#ifdef __cplusplus
+}
+#endif
+
+#define SWIG_init    initmdic
+
+#define SWIG_name    "mdic"
+
+#include "helpers.h"
+
+static PyObject* l_output_helper(PyObject* target, PyObject* o) {
+    PyObject*   o2;
+    PyObject*   o3;
+    if (!target) {                   
+        target = o;
+    } else if (target == Py_None) {  
+        Py_DECREF(Py_None);
+        target = o;
+    } else {                         
+        if (!PyList_Check(target)) {
+            o2 = target;
+            target = PyList_New(0);
+            PyList_Append(target, o2);
+	    Py_XDECREF(o2);
+        }
+        PyList_Append(target,o);
+	Py_XDECREF(o);
+    }
+    return target;
+}
+
+static PyObject* t_output_helper(PyObject* target, PyObject* o) {
+    PyObject*   o2;
+    PyObject*   o3;
+
+    if (!target) {                   
+        target = o;
+    } else if (target == Py_None) {  
+        Py_DECREF(Py_None);
+        target = o;
+    } else {                         
+        if (!PyTuple_Check(target)) {
+            o2 = target;
+            target = PyTuple_New(1);
+            PyTuple_SetItem(target, 0, o2);
+        }
+        o3 = PyTuple_New(1);            
+        PyTuple_SetItem(o3, 0, o);      
+
+        o2 = target;
+        target = PySequence_Concat(o2, o3); 
+        Py_DECREF(o2);                      
+        Py_DECREF(o3);
+    }
+    return target;
+}
+
+
+extern byte* byte_LIST_helper(PyObject* source);
+extern int* int_LIST_helper(PyObject* source);
+extern long* long_LIST_helper(PyObject* source);
+extern char** string_LIST_helper(PyObject* source);
+extern wxPoint* wxPoint_LIST_helper(PyObject* source);
+extern wxBitmap** wxBitmap_LIST_helper(PyObject* source);
+extern wxString* wxString_LIST_helper(PyObject* source);
+extern wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
+
+
+static char* wxStringErrorMsg = "string type is required for parameter";
+static void *SwigwxMDIParentFrameTowxFrame(void *ptr) {
+    wxMDIParentFrame *src;
+    wxFrame *dest;
+    src = (wxMDIParentFrame *) ptr;
+    dest = (wxFrame *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxMDIParentFrameTowxWindow(void *ptr) {
+    wxMDIParentFrame *src;
+    wxWindow *dest;
+    src = (wxMDIParentFrame *) ptr;
+    dest = (wxWindow *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxMDIParentFrameTowxEvtHandler(void *ptr) {
+    wxMDIParentFrame *src;
+    wxEvtHandler *dest;
+    src = (wxMDIParentFrame *) ptr;
+    dest = (wxEvtHandler *) src;
+    return (void *) dest;
+}
+
+#define new_wxMDIParentFrame(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6) (new wxMDIParentFrame(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6))
+static PyObject *_wrap_new_wxMDIParentFrame(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIParentFrame * _result;
+    wxWindow * _arg0;
+    wxWindowID  _arg1;
+    wxString * _arg2;
+    wxPoint * _arg3 = &wxPyDefaultPosition;
+    wxSize * _arg4 = &wxPyDefaultSize;
+    long  _arg5 = (wxDEFAULT_FRAME_STYLE)|(wxVSCROLL)|(wxHSCROLL);
+    char * _arg6 = "frame";
+    char * _argc0 = 0;
+    PyObject * _obj2 = 0;
+    char * _argc3 = 0;
+    char * _argc4 = 0;
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"siO|ssls:new_wxMDIParentFrame",&_argc0,&_arg1,&_obj2,&_argc3,&_argc4,&_arg5,&_arg6)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxWindow_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxMDIParentFrame. Expected _wxWindow_p.");
+        return NULL;
+        }
+    }
+{
+    if (!PyString_Check(_obj2)) {
+        PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
+        return NULL;
+    }
+    _arg2 = new wxString(PyString_AsString(_obj2));
+}
+    if (_argc3) {
+        if (SWIG_GetPtr(_argc3,(void **) &_arg3,"_wxPoint_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxMDIParentFrame. Expected _wxPoint_p.");
+        return NULL;
+        }
+    }
+    if (_argc4) {
+        if (SWIG_GetPtr(_argc4,(void **) &_arg4,"_wxSize_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of new_wxMDIParentFrame. Expected _wxSize_p.");
+        return NULL;
+        }
+    }
+    _result = (wxMDIParentFrame *)new_wxMDIParentFrame(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6);
+    SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIParentFrame_p");
+    _resultobj = Py_BuildValue("s",_ptemp);
+{
+    if (_obj2)
+        delete _arg2;
+}
+    return _resultobj;
+}
+
+#define wxMDIParentFrame_ActivateNext(_swigobj)  (_swigobj->ActivateNext())
+static PyObject *_wrap_wxMDIParentFrame_ActivateNext(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIParentFrame * _arg0;
+    char * _argc0 = 0;
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_ActivateNext",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_ActivateNext. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+    wxMDIParentFrame_ActivateNext(_arg0);
+    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxMDIParentFrame_ActivatePrevious(_swigobj)  (_swigobj->ActivatePrevious())
+static PyObject *_wrap_wxMDIParentFrame_ActivatePrevious(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIParentFrame * _arg0;
+    char * _argc0 = 0;
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_ActivatePrevious",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_ActivatePrevious. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+    wxMDIParentFrame_ActivatePrevious(_arg0);
+    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxMDIParentFrame_ArrangeIcons(_swigobj)  (_swigobj->ArrangeIcons())
+static PyObject *_wrap_wxMDIParentFrame_ArrangeIcons(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIParentFrame * _arg0;
+    char * _argc0 = 0;
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_ArrangeIcons",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_ArrangeIcons. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+    wxMDIParentFrame_ArrangeIcons(_arg0);
+    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxMDIParentFrame_Cascade(_swigobj)  (_swigobj->Cascade())
+static PyObject *_wrap_wxMDIParentFrame_Cascade(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIParentFrame * _arg0;
+    char * _argc0 = 0;
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_Cascade",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_Cascade. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+    wxMDIParentFrame_Cascade(_arg0);
+    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxMDIParentFrame_GetClientSize(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetClientSize(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxMDIParentFrame_GetClientSize(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIParentFrame * _arg0;
+    int * _arg1;
+    int  temp;
+    int * _arg2;
+    int  temp0;
+    char * _argc0 = 0;
+
+    self = self;
+{
+  _arg1 = &temp;
+}
+{
+  _arg2 = &temp0;
+}
+    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_GetClientSize",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_GetClientSize. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+    wxMDIParentFrame_GetClientSize(_arg0,_arg1,_arg2);
+    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+{
+    PyObject *o;
+    o = PyInt_FromLong((long) (*_arg1));
+    _resultobj = t_output_helper(_resultobj, o);
+}
+{
+    PyObject *o;
+    o = PyInt_FromLong((long) (*_arg2));
+    _resultobj = t_output_helper(_resultobj, o);
+}
+    return _resultobj;
+}
+
+#define wxMDIParentFrame_GetActiveChild(_swigobj)  (_swigobj->GetActiveChild())
+static PyObject *_wrap_wxMDIParentFrame_GetActiveChild(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIChildFrame * _result;
+    wxMDIParentFrame * _arg0;
+    char * _argc0 = 0;
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_GetActiveChild",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_GetActiveChild. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+    _result = (wxMDIChildFrame *)wxMDIParentFrame_GetActiveChild(_arg0);
+    SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIChildFrame_p");
+    _resultobj = Py_BuildValue("s",_ptemp);
+    return _resultobj;
+}
+
+#define wxMDIParentFrame_GetClientWindow(_swigobj)  (_swigobj->GetClientWindow())
+static PyObject *_wrap_wxMDIParentFrame_GetClientWindow(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIClientWindow * _result;
+    wxMDIParentFrame * _arg0;
+    char * _argc0 = 0;
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_GetClientWindow",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_GetClientWindow. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+    _result = (wxMDIClientWindow *)wxMDIParentFrame_GetClientWindow(_arg0);
+    SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIClientWindow_p");
+    _resultobj = Py_BuildValue("s",_ptemp);
+    return _resultobj;
+}
+
+#define wxMDIParentFrame_GetToolBar(_swigobj)  (_swigobj->GetToolBar())
+static PyObject *_wrap_wxMDIParentFrame_GetToolBar(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxWindow * _result;
+    wxMDIParentFrame * _arg0;
+    char * _argc0 = 0;
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_GetToolBar",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_GetToolBar. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+    _result = (wxWindow *)wxMDIParentFrame_GetToolBar(_arg0);
+    SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p");
+    _resultobj = Py_BuildValue("s",_ptemp);
+    return _resultobj;
+}
+
+#define wxMDIParentFrame_Tile(_swigobj)  (_swigobj->Tile())
+static PyObject *_wrap_wxMDIParentFrame_Tile(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIParentFrame * _arg0;
+    char * _argc0 = 0;
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_Tile",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_Tile. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+    wxMDIParentFrame_Tile(_arg0);
+    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+static void *SwigwxMDIChildFrameTowxFrame(void *ptr) {
+    wxMDIChildFrame *src;
+    wxFrame *dest;
+    src = (wxMDIChildFrame *) ptr;
+    dest = (wxFrame *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxMDIChildFrameTowxWindow(void *ptr) {
+    wxMDIChildFrame *src;
+    wxWindow *dest;
+    src = (wxMDIChildFrame *) ptr;
+    dest = (wxWindow *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxMDIChildFrameTowxEvtHandler(void *ptr) {
+    wxMDIChildFrame *src;
+    wxEvtHandler *dest;
+    src = (wxMDIChildFrame *) ptr;
+    dest = (wxEvtHandler *) src;
+    return (void *) dest;
+}
+
+#define new_wxMDIChildFrame(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6) (new wxMDIChildFrame(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6))
+static PyObject *_wrap_new_wxMDIChildFrame(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIChildFrame * _result;
+    wxMDIParentFrame * _arg0;
+    wxWindowID  _arg1;
+    wxString * _arg2;
+    wxPoint * _arg3 = &wxPyDefaultPosition;
+    wxSize * _arg4 = &wxPyDefaultSize;
+    long  _arg5 = (wxDEFAULT_FRAME_STYLE);
+    char * _arg6 = "frame";
+    char * _argc0 = 0;
+    PyObject * _obj2 = 0;
+    char * _argc3 = 0;
+    char * _argc4 = 0;
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"siO|ssls:new_wxMDIChildFrame",&_argc0,&_arg1,&_obj2,&_argc3,&_argc4,&_arg5,&_arg6)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxMDIChildFrame. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+{
+    if (!PyString_Check(_obj2)) {
+        PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
+        return NULL;
+    }
+    _arg2 = new wxString(PyString_AsString(_obj2));
+}
+    if (_argc3) {
+        if (SWIG_GetPtr(_argc3,(void **) &_arg3,"_wxPoint_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxMDIChildFrame. Expected _wxPoint_p.");
+        return NULL;
+        }
+    }
+    if (_argc4) {
+        if (SWIG_GetPtr(_argc4,(void **) &_arg4,"_wxSize_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of new_wxMDIChildFrame. Expected _wxSize_p.");
+        return NULL;
+        }
+    }
+    _result = (wxMDIChildFrame *)new_wxMDIChildFrame(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6);
+    SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIChildFrame_p");
+    _resultobj = Py_BuildValue("s",_ptemp);
+{
+    if (_obj2)
+        delete _arg2;
+}
+    return _resultobj;
+}
+
+#define wxMDIChildFrame_Activate(_swigobj)  (_swigobj->Activate())
+static PyObject *_wrap_wxMDIChildFrame_Activate(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIChildFrame * _arg0;
+    char * _argc0 = 0;
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s:wxMDIChildFrame_Activate",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_Activate. Expected _wxMDIChildFrame_p.");
+        return NULL;
+        }
+    }
+    wxMDIChildFrame_Activate(_arg0);
+    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxMDIChildFrame_Maximize(_swigobj)  (_swigobj->Maximize())
+static PyObject *_wrap_wxMDIChildFrame_Maximize(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIChildFrame * _arg0;
+    char * _argc0 = 0;
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s:wxMDIChildFrame_Maximize",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_Maximize. Expected _wxMDIChildFrame_p.");
+        return NULL;
+        }
+    }
+    wxMDIChildFrame_Maximize(_arg0);
+    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxMDIChildFrame_Restore(_swigobj)  (_swigobj->Restore())
+static PyObject *_wrap_wxMDIChildFrame_Restore(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIChildFrame * _arg0;
+    char * _argc0 = 0;
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s:wxMDIChildFrame_Restore",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_Restore. Expected _wxMDIChildFrame_p.");
+        return NULL;
+        }
+    }
+    wxMDIChildFrame_Restore(_arg0);
+    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxMDIChildFrame_SetMenuBar(_swigobj,_swigarg0)  (_swigobj->SetMenuBar(_swigarg0))
+static PyObject *_wrap_wxMDIChildFrame_SetMenuBar(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIChildFrame * _arg0;
+    wxMenuBar * _arg1;
+    char * _argc0 = 0;
+    char * _argc1 = 0;
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"ss:wxMDIChildFrame_SetMenuBar",&_argc0,&_argc1)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_SetMenuBar. Expected _wxMDIChildFrame_p.");
+        return NULL;
+        }
+    }
+    if (_argc1) {
+        if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxMenuBar_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxMDIChildFrame_SetMenuBar. Expected _wxMenuBar_p.");
+        return NULL;
+        }
+    }
+    wxMDIChildFrame_SetMenuBar(_arg0,_arg1);
+    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxMDIChildFrame_SetClientSize(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetClientSize(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxMDIChildFrame_SetClientSize(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIChildFrame * _arg0;
+    int  _arg1;
+    int  _arg2;
+    char * _argc0 = 0;
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"sii:wxMDIChildFrame_SetClientSize",&_argc0,&_arg1,&_arg2)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_SetClientSize. Expected _wxMDIChildFrame_p.");
+        return NULL;
+        }
+    }
+    wxMDIChildFrame_SetClientSize(_arg0,_arg1,_arg2);
+    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxMDIChildFrame_GetPosition(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetPosition(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxMDIChildFrame_GetPosition(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIChildFrame * _arg0;
+    int * _arg1;
+    int  temp;
+    int * _arg2;
+    int  temp0;
+    char * _argc0 = 0;
+
+    self = self;
+{
+  _arg1 = &temp;
+}
+{
+  _arg2 = &temp0;
+}
+    if(!PyArg_ParseTuple(args,"s:wxMDIChildFrame_GetPosition",&_argc0)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_GetPosition. Expected _wxMDIChildFrame_p.");
+        return NULL;
+        }
+    }
+    wxMDIChildFrame_GetPosition(_arg0,_arg1,_arg2);
+    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+{
+    PyObject *o;
+    o = PyInt_FromLong((long) (*_arg1));
+    _resultobj = t_output_helper(_resultobj, o);
+}
+{
+    PyObject *o;
+    o = PyInt_FromLong((long) (*_arg2));
+    _resultobj = t_output_helper(_resultobj, o);
+}
+    return _resultobj;
+}
+
+static void *SwigwxMDIClientWindowTowxWindow(void *ptr) {
+    wxMDIClientWindow *src;
+    wxWindow *dest;
+    src = (wxMDIClientWindow *) ptr;
+    dest = (wxWindow *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxMDIClientWindowTowxEvtHandler(void *ptr) {
+    wxMDIClientWindow *src;
+    wxEvtHandler *dest;
+    src = (wxMDIClientWindow *) ptr;
+    dest = (wxEvtHandler *) src;
+    return (void *) dest;
+}
+
+#define new_wxMDIClientWindow(_swigarg0,_swigarg1) (new wxMDIClientWindow(_swigarg0,_swigarg1))
+static PyObject *_wrap_new_wxMDIClientWindow(PyObject *self, PyObject *args) {
+    PyObject * _resultobj;
+    wxMDIClientWindow * _result;
+    wxMDIParentFrame * _arg0;
+    long  _arg1 = 0;
+    char * _argc0 = 0;
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTuple(args,"s|l:new_wxMDIClientWindow",&_argc0,&_arg1)) 
+        return NULL;
+    if (_argc0) {
+        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxMDIClientWindow. Expected _wxMDIParentFrame_p.");
+        return NULL;
+        }
+    }
+    _result = (wxMDIClientWindow *)new_wxMDIClientWindow(_arg0,_arg1);
+    SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIClientWindow_p");
+    _resultobj = Py_BuildValue("s",_ptemp);
+    return _resultobj;
+}
+
+static PyMethodDef mdicMethods[] = {
+	 { "new_wxMDIClientWindow", _wrap_new_wxMDIClientWindow, 1 },
+	 { "wxMDIChildFrame_GetPosition", _wrap_wxMDIChildFrame_GetPosition, 1 },
+	 { "wxMDIChildFrame_SetClientSize", _wrap_wxMDIChildFrame_SetClientSize, 1 },
+	 { "wxMDIChildFrame_SetMenuBar", _wrap_wxMDIChildFrame_SetMenuBar, 1 },
+	 { "wxMDIChildFrame_Restore", _wrap_wxMDIChildFrame_Restore, 1 },
+	 { "wxMDIChildFrame_Maximize", _wrap_wxMDIChildFrame_Maximize, 1 },
+	 { "wxMDIChildFrame_Activate", _wrap_wxMDIChildFrame_Activate, 1 },
+	 { "new_wxMDIChildFrame", _wrap_new_wxMDIChildFrame, 1 },
+	 { "wxMDIParentFrame_Tile", _wrap_wxMDIParentFrame_Tile, 1 },
+	 { "wxMDIParentFrame_GetToolBar", _wrap_wxMDIParentFrame_GetToolBar, 1 },
+	 { "wxMDIParentFrame_GetClientWindow", _wrap_wxMDIParentFrame_GetClientWindow, 1 },
+	 { "wxMDIParentFrame_GetActiveChild", _wrap_wxMDIParentFrame_GetActiveChild, 1 },
+	 { "wxMDIParentFrame_GetClientSize", _wrap_wxMDIParentFrame_GetClientSize, 1 },
+	 { "wxMDIParentFrame_Cascade", _wrap_wxMDIParentFrame_Cascade, 1 },
+	 { "wxMDIParentFrame_ArrangeIcons", _wrap_wxMDIParentFrame_ArrangeIcons, 1 },
+	 { "wxMDIParentFrame_ActivatePrevious", _wrap_wxMDIParentFrame_ActivatePrevious, 1 },
+	 { "wxMDIParentFrame_ActivateNext", _wrap_wxMDIParentFrame_ActivateNext, 1 },
+	 { "new_wxMDIParentFrame", _wrap_new_wxMDIParentFrame, 1 },
+	 { NULL, NULL }
+};
+static PyObject *SWIG_globals;
+#ifdef __cplusplus
+extern "C" 
+#endif
+SWIGEXPORT(void,initmdic)() {
+	 PyObject *m, *d;
+	 SWIG_globals = SWIG_newvarlink();
+	 m = Py_InitModule("mdic", mdicMethods);
+	 d = PyModule_GetDict(m);
+/*
+ * These are the pointer type-equivalency mappings. 
+ * (Used by the SWIG pointer type-checker).
+ */
+	 SWIG_RegisterMapping("_wxAcceleratorTable","_class_wxAcceleratorTable",0);
+	 SWIG_RegisterMapping("_wxEvent","_class_wxEvent",0);
+	 SWIG_RegisterMapping("_class_wxActivateEvent","_wxActivateEvent",0);
+	 SWIG_RegisterMapping("_signed_long","_long",0);
+	 SWIG_RegisterMapping("_wxMenuEvent","_class_wxMenuEvent",0);
+	 SWIG_RegisterMapping("_class_wxRegionIterator","_wxRegionIterator",0);
+	 SWIG_RegisterMapping("_class_wxMenuBar","_wxMenuBar",0);
+	 SWIG_RegisterMapping("_class_wxEvtHandler","_class_wxMDIClientWindow",SwigwxMDIClientWindowTowxEvtHandler);
+	 SWIG_RegisterMapping("_class_wxEvtHandler","_wxMDIClientWindow",SwigwxMDIClientWindowTowxEvtHandler);
+	 SWIG_RegisterMapping("_class_wxEvtHandler","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxEvtHandler);
+	 SWIG_RegisterMapping("_class_wxEvtHandler","_wxMDIChildFrame",SwigwxMDIChildFrameTowxEvtHandler);
+	 SWIG_RegisterMapping("_class_wxEvtHandler","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxEvtHandler);
+	 SWIG_RegisterMapping("_class_wxEvtHandler","_wxMDIParentFrame",SwigwxMDIParentFrameTowxEvtHandler);
+	 SWIG_RegisterMapping("_class_wxEvtHandler","_wxEvtHandler",0);
+	 SWIG_RegisterMapping("_wxPaintEvent","_class_wxPaintEvent",0);
+	 SWIG_RegisterMapping("_wxIndividualLayoutConstraint","_class_wxIndividualLayoutConstraint",0);
+	 SWIG_RegisterMapping("_wxCursor","_class_wxCursor",0);
+	 SWIG_RegisterMapping("_wxMask","_class_wxMask",0);
+	 SWIG_RegisterMapping("_wxPyMenu","_class_wxPyMenu",0);
+	 SWIG_RegisterMapping("_wxPen","_class_wxPen",0);
+	 SWIG_RegisterMapping("_wxUpdateUIEvent","_class_wxUpdateUIEvent",0);
+	 SWIG_RegisterMapping("_byte","_unsigned_char",0);
+	 SWIG_RegisterMapping("_wxStaticBox","_class_wxStaticBox",0);
+	 SWIG_RegisterMapping("_wxChoice","_class_wxChoice",0);
+	 SWIG_RegisterMapping("_wxSlider","_class_wxSlider",0);
+	 SWIG_RegisterMapping("_long","_wxDash",0);
+	 SWIG_RegisterMapping("_long","_unsigned_long",0);
+	 SWIG_RegisterMapping("_long","_signed_long",0);
+	 SWIG_RegisterMapping("_wxDropFilesEvent","_class_wxDropFilesEvent",0);
+	 SWIG_RegisterMapping("_wxBitmapButton","_class_wxBitmapButton",0);
+	 SWIG_RegisterMapping("_class_wxAcceleratorTable","_wxAcceleratorTable",0);
+	 SWIG_RegisterMapping("_class_wxGauge","_wxGauge",0);
+	 SWIG_RegisterMapping("_wxDC","_class_wxDC",0);
+	 SWIG_RegisterMapping("_wxSpinEvent","_class_wxSpinEvent",0);
+	 SWIG_RegisterMapping("_class_wxRealPoint","_wxRealPoint",0);
+	 SWIG_RegisterMapping("_class_wxMenuItem","_wxMenuItem",0);
+	 SWIG_RegisterMapping("_class_wxPaintEvent","_wxPaintEvent",0);
+	 SWIG_RegisterMapping("_wxSysColourChangedEvent","_class_wxSysColourChangedEvent",0);
+	 SWIG_RegisterMapping("_class_wxStatusBar","_wxStatusBar",0);
+	 SWIG_RegisterMapping("_class_wxPostScriptDC","_wxPostScriptDC",0);
+	 SWIG_RegisterMapping("_wxPanel","_class_wxPanel",0);
+	 SWIG_RegisterMapping("_wxInitDialogEvent","_class_wxInitDialogEvent",0);
+	 SWIG_RegisterMapping("_wxCheckBox","_class_wxCheckBox",0);
+	 SWIG_RegisterMapping("_wxTextCtrl","_class_wxTextCtrl",0);
+	 SWIG_RegisterMapping("_class_wxMask","_wxMask",0);
+	 SWIG_RegisterMapping("_class_wxKeyEvent","_wxKeyEvent",0);
+	 SWIG_RegisterMapping("_wxColour","_class_wxColour",0);
+	 SWIG_RegisterMapping("_class_wxDialog","_wxDialog",0);
+	 SWIG_RegisterMapping("_wxIdleEvent","_class_wxIdleEvent",0);
+	 SWIG_RegisterMapping("_class_wxUpdateUIEvent","_wxUpdateUIEvent",0);
+	 SWIG_RegisterMapping("_wxToolBar","_class_wxToolBar",0);
+	 SWIG_RegisterMapping("_wxBrush","_class_wxBrush",0);
+	 SWIG_RegisterMapping("_wxMiniFrame","_class_wxMiniFrame",0);
+	 SWIG_RegisterMapping("_wxShowEvent","_class_wxShowEvent",0);
+	 SWIG_RegisterMapping("_uint","_unsigned_int",0);
+	 SWIG_RegisterMapping("_uint","_int",0);
+	 SWIG_RegisterMapping("_uint","_wxWindowID",0);
+	 SWIG_RegisterMapping("_class_wxEvent","_wxEvent",0);
+	 SWIG_RegisterMapping("_wxCheckListBox","_class_wxCheckListBox",0);
+	 SWIG_RegisterMapping("_wxRect","_class_wxRect",0);
+	 SWIG_RegisterMapping("_wxCommandEvent","_class_wxCommandEvent",0);
+	 SWIG_RegisterMapping("_wxSizeEvent","_class_wxSizeEvent",0);
+	 SWIG_RegisterMapping("_wxPoint","_class_wxPoint",0);
+	 SWIG_RegisterMapping("_class_wxButton","_wxButton",0);
+	 SWIG_RegisterMapping("_wxRadioBox","_class_wxRadioBox",0);
+	 SWIG_RegisterMapping("_wxBitmap","_class_wxBitmap",0);
+	 SWIG_RegisterMapping("_wxPyTimer","_class_wxPyTimer",0);
+	 SWIG_RegisterMapping("_wxWindowDC","_class_wxWindowDC",0);
+	 SWIG_RegisterMapping("_wxScrollBar","_class_wxScrollBar",0);
+	 SWIG_RegisterMapping("_wxSpinButton","_class_wxSpinButton",0);
+	 SWIG_RegisterMapping("_wxToolBarTool","_class_wxToolBarTool",0);
+	 SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0);
+	 SWIG_RegisterMapping("_class_wxIconizeEvent","_wxIconizeEvent",0);
+	 SWIG_RegisterMapping("_class_wxStaticBitmap","_wxStaticBitmap",0);
+	 SWIG_RegisterMapping("_wxMDIChildFrame","_class_wxMDIChildFrame",0);
+	 SWIG_RegisterMapping("_class_wxToolBar","_wxToolBar",0);
+	 SWIG_RegisterMapping("_wxScrollEvent","_class_wxScrollEvent",0);
+	 SWIG_RegisterMapping("_EBool","_signed_int",0);
+	 SWIG_RegisterMapping("_EBool","_int",0);
+	 SWIG_RegisterMapping("_EBool","_wxWindowID",0);
+	 SWIG_RegisterMapping("_class_wxRegion","_wxRegion",0);
+	 SWIG_RegisterMapping("_class_wxDropFilesEvent","_wxDropFilesEvent",0);
+	 SWIG_RegisterMapping("_wxStaticText","_class_wxStaticText",0);
+	 SWIG_RegisterMapping("_wxFont","_class_wxFont",0);
+	 SWIG_RegisterMapping("_wxCloseEvent","_class_wxCloseEvent",0);
+	 SWIG_RegisterMapping("_unsigned_long","_wxDash",0);
+	 SWIG_RegisterMapping("_unsigned_long","_long",0);
+	 SWIG_RegisterMapping("_class_wxRect","_wxRect",0);
+	 SWIG_RegisterMapping("_class_wxDC","_wxDC",0);
+	 SWIG_RegisterMapping("_wxMDIParentFrame","_class_wxMDIParentFrame",0);
+	 SWIG_RegisterMapping("_class_wxPyTimer","_wxPyTimer",0);
+	 SWIG_RegisterMapping("_wxFocusEvent","_class_wxFocusEvent",0);
+	 SWIG_RegisterMapping("_wxMaximizeEvent","_class_wxMaximizeEvent",0);
+	 SWIG_RegisterMapping("_class_wxSpinButton","_wxSpinButton",0);
+	 SWIG_RegisterMapping("_wxAcceleratorEntry","_class_wxAcceleratorEntry",0);
+	 SWIG_RegisterMapping("_class_wxPanel","_wxPanel",0);
+	 SWIG_RegisterMapping("_class_wxCheckBox","_wxCheckBox",0);
+	 SWIG_RegisterMapping("_wxComboBox","_class_wxComboBox",0);
+	 SWIG_RegisterMapping("_wxRadioButton","_class_wxRadioButton",0);
+	 SWIG_RegisterMapping("_signed_int","_EBool",0);
+	 SWIG_RegisterMapping("_signed_int","_wxWindowID",0);
+	 SWIG_RegisterMapping("_signed_int","_int",0);
+	 SWIG_RegisterMapping("_class_wxTextCtrl","_wxTextCtrl",0);
+	 SWIG_RegisterMapping("_wxLayoutConstraints","_class_wxLayoutConstraints",0);
+	 SWIG_RegisterMapping("_wxMenu","_class_wxMenu",0);
+	 SWIG_RegisterMapping("_class_wxMoveEvent","_wxMoveEvent",0);
+	 SWIG_RegisterMapping("_wxListBox","_class_wxListBox",0);
+	 SWIG_RegisterMapping("_wxScreenDC","_class_wxScreenDC",0);
+	 SWIG_RegisterMapping("_class_wxMDIChildFrame","_wxMDIChildFrame",0);
+	 SWIG_RegisterMapping("_WXTYPE","_short",0);
+	 SWIG_RegisterMapping("_WXTYPE","_signed_short",0);
+	 SWIG_RegisterMapping("_WXTYPE","_unsigned_short",0);
+	 SWIG_RegisterMapping("_class_wxMDIClientWindow","_wxMDIClientWindow",0);
+	 SWIG_RegisterMapping("_class_wxBrush","_wxBrush",0);
+	 SWIG_RegisterMapping("_unsigned_short","_WXTYPE",0);
+	 SWIG_RegisterMapping("_unsigned_short","_short",0);
+	 SWIG_RegisterMapping("_class_wxWindow","_class_wxMDIClientWindow",SwigwxMDIClientWindowTowxWindow);
+	 SWIG_RegisterMapping("_class_wxWindow","_wxMDIClientWindow",SwigwxMDIClientWindowTowxWindow);
+	 SWIG_RegisterMapping("_class_wxWindow","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxWindow);
+	 SWIG_RegisterMapping("_class_wxWindow","_wxMDIChildFrame",SwigwxMDIChildFrameTowxWindow);
+	 SWIG_RegisterMapping("_class_wxWindow","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxWindow);
+	 SWIG_RegisterMapping("_class_wxWindow","_wxMDIParentFrame",SwigwxMDIParentFrameTowxWindow);
+	 SWIG_RegisterMapping("_class_wxWindow","_wxWindow",0);
+	 SWIG_RegisterMapping("_class_wxStaticText","_wxStaticText",0);
+	 SWIG_RegisterMapping("_class_wxFont","_wxFont",0);
+	 SWIG_RegisterMapping("_class_wxCloseEvent","_wxCloseEvent",0);
+	 SWIG_RegisterMapping("_class_wxMenuEvent","_wxMenuEvent",0);
+	 SWIG_RegisterMapping("_wxClientDC","_class_wxClientDC",0);
+	 SWIG_RegisterMapping("_wxMouseEvent","_class_wxMouseEvent",0);
+	 SWIG_RegisterMapping("_class_wxPoint","_wxPoint",0);
+	 SWIG_RegisterMapping("_wxRealPoint","_class_wxRealPoint",0);
+	 SWIG_RegisterMapping("_class_wxRadioBox","_wxRadioBox",0);
+	 SWIG_RegisterMapping("_signed_short","_WXTYPE",0);
+	 SWIG_RegisterMapping("_signed_short","_short",0);
+	 SWIG_RegisterMapping("_wxMemoryDC","_class_wxMemoryDC",0);
+	 SWIG_RegisterMapping("_wxPaintDC","_class_wxPaintDC",0);
+	 SWIG_RegisterMapping("_class_wxWindowDC","_wxWindowDC",0);
+	 SWIG_RegisterMapping("_class_wxFocusEvent","_wxFocusEvent",0);
+	 SWIG_RegisterMapping("_class_wxMaximizeEvent","_wxMaximizeEvent",0);
+	 SWIG_RegisterMapping("_wxStatusBar","_class_wxStatusBar",0);
+	 SWIG_RegisterMapping("_class_wxToolBarTool","_wxToolBarTool",0);
+	 SWIG_RegisterMapping("_class_wxAcceleratorEntry","_wxAcceleratorEntry",0);
+	 SWIG_RegisterMapping("_class_wxCursor","_wxCursor",0);
+	 SWIG_RegisterMapping("_wxPostScriptDC","_class_wxPostScriptDC",0);
+	 SWIG_RegisterMapping("_wxScrolledWindow","_class_wxScrolledWindow",0);
+	 SWIG_RegisterMapping("_unsigned_char","_byte",0);
+	 SWIG_RegisterMapping("_class_wxMenu","_wxMenu",0);
+	 SWIG_RegisterMapping("_wxControl","_class_wxControl",0);
+	 SWIG_RegisterMapping("_class_wxListBox","_wxListBox",0);
+	 SWIG_RegisterMapping("_unsigned_int","_uint",0);
+	 SWIG_RegisterMapping("_unsigned_int","_wxWindowID",0);
+	 SWIG_RegisterMapping("_unsigned_int","_int",0);
+	 SWIG_RegisterMapping("_wxIcon","_class_wxIcon",0);
+	 SWIG_RegisterMapping("_wxDialog","_class_wxDialog",0);
+	 SWIG_RegisterMapping("_class_wxPyMenu","_wxPyMenu",0);
+	 SWIG_RegisterMapping("_class_wxPen","_wxPen",0);
+	 SWIG_RegisterMapping("_short","_WXTYPE",0);
+	 SWIG_RegisterMapping("_short","_unsigned_short",0);
+	 SWIG_RegisterMapping("_short","_signed_short",0);
+	 SWIG_RegisterMapping("_class_wxStaticBox","_wxStaticBox",0);
+	 SWIG_RegisterMapping("_class_wxScrollEvent","_wxScrollEvent",0);
+	 SWIG_RegisterMapping("_wxJoystickEvent","_class_wxJoystickEvent",0);
+	 SWIG_RegisterMapping("_class_wxChoice","_wxChoice",0);
+	 SWIG_RegisterMapping("_class_wxSlider","_wxSlider",0);
+	 SWIG_RegisterMapping("_class_wxBitmapButton","_wxBitmapButton",0);
+	 SWIG_RegisterMapping("_wxFrame","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxFrame);
+	 SWIG_RegisterMapping("_wxFrame","_wxMDIChildFrame",SwigwxMDIChildFrameTowxFrame);
+	 SWIG_RegisterMapping("_wxFrame","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxFrame);
+	 SWIG_RegisterMapping("_wxFrame","_wxMDIParentFrame",SwigwxMDIParentFrameTowxFrame);
+	 SWIG_RegisterMapping("_wxFrame","_class_wxFrame",0);
+	 SWIG_RegisterMapping("_wxWindowID","_EBool",0);
+	 SWIG_RegisterMapping("_wxWindowID","_uint",0);
+	 SWIG_RegisterMapping("_wxWindowID","_int",0);
+	 SWIG_RegisterMapping("_wxWindowID","_signed_int",0);
+	 SWIG_RegisterMapping("_wxWindowID","_unsigned_int",0);
+	 SWIG_RegisterMapping("_int","_EBool",0);
+	 SWIG_RegisterMapping("_int","_uint",0);
+	 SWIG_RegisterMapping("_int","_wxWindowID",0);
+	 SWIG_RegisterMapping("_int","_unsigned_int",0);
+	 SWIG_RegisterMapping("_int","_signed_int",0);
+	 SWIG_RegisterMapping("_class_wxMouseEvent","_wxMouseEvent",0);
+	 SWIG_RegisterMapping("_class_wxSpinEvent","_wxSpinEvent",0);
+	 SWIG_RegisterMapping("_wxButton","_class_wxButton",0);
+	 SWIG_RegisterMapping("_wxSize","_class_wxSize",0);
+	 SWIG_RegisterMapping("_wxRegionIterator","_class_wxRegionIterator",0);
+	 SWIG_RegisterMapping("_class_wxMDIParentFrame","_wxMDIParentFrame",0);
+	 SWIG_RegisterMapping("_class_wxPaintDC","_wxPaintDC",0);
+	 SWIG_RegisterMapping("_class_wxSysColourChangedEvent","_wxSysColourChangedEvent",0);
+	 SWIG_RegisterMapping("_class_wxInitDialogEvent","_wxInitDialogEvent",0);
+	 SWIG_RegisterMapping("_class_wxComboBox","_wxComboBox",0);
+	 SWIG_RegisterMapping("_class_wxRadioButton","_wxRadioButton",0);
+	 SWIG_RegisterMapping("_class_wxLayoutConstraints","_wxLayoutConstraints",0);
+	 SWIG_RegisterMapping("_wxIconizeEvent","_class_wxIconizeEvent",0);
+	 SWIG_RegisterMapping("_class_wxControl","_wxControl",0);
+	 SWIG_RegisterMapping("_wxStaticBitmap","_class_wxStaticBitmap",0);
+	 SWIG_RegisterMapping("_class_wxIcon","_wxIcon",0);
+	 SWIG_RegisterMapping("_class_wxColour","_wxColour",0);
+	 SWIG_RegisterMapping("_class_wxScreenDC","_wxScreenDC",0);
+	 SWIG_RegisterMapping("_wxPalette","_class_wxPalette",0);
+	 SWIG_RegisterMapping("_class_wxIdleEvent","_wxIdleEvent",0);
+	 SWIG_RegisterMapping("_wxEraseEvent","_class_wxEraseEvent",0);
+	 SWIG_RegisterMapping("_class_wxJoystickEvent","_wxJoystickEvent",0);
+	 SWIG_RegisterMapping("_class_wxMiniFrame","_wxMiniFrame",0);
+	 SWIG_RegisterMapping("_wxRegion","_class_wxRegion",0);
+	 SWIG_RegisterMapping("_class_wxShowEvent","_wxShowEvent",0);
+	 SWIG_RegisterMapping("_wxActivateEvent","_class_wxActivateEvent",0);
+	 SWIG_RegisterMapping("_wxGauge","_class_wxGauge",0);
+	 SWIG_RegisterMapping("_class_wxCheckListBox","_wxCheckListBox",0);
+	 SWIG_RegisterMapping("_class_wxCommandEvent","_wxCommandEvent",0);
+	 SWIG_RegisterMapping("_class_wxClientDC","_wxClientDC",0);
+	 SWIG_RegisterMapping("_class_wxSizeEvent","_wxSizeEvent",0);
+	 SWIG_RegisterMapping("_class_wxSize","_wxSize",0);
+	 SWIG_RegisterMapping("_class_wxBitmap","_wxBitmap",0);
+	 SWIG_RegisterMapping("_class_wxMemoryDC","_wxMemoryDC",0);
+	 SWIG_RegisterMapping("_wxMenuBar","_class_wxMenuBar",0);
+	 SWIG_RegisterMapping("_wxEvtHandler","_class_wxMDIClientWindow",SwigwxMDIClientWindowTowxEvtHandler);
+	 SWIG_RegisterMapping("_wxEvtHandler","_wxMDIClientWindow",SwigwxMDIClientWindowTowxEvtHandler);
+	 SWIG_RegisterMapping("_wxEvtHandler","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxEvtHandler);
+	 SWIG_RegisterMapping("_wxEvtHandler","_wxMDIChildFrame",SwigwxMDIChildFrameTowxEvtHandler);
+	 SWIG_RegisterMapping("_wxEvtHandler","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxEvtHandler);
+	 SWIG_RegisterMapping("_wxEvtHandler","_wxMDIParentFrame",SwigwxMDIParentFrameTowxEvtHandler);
+	 SWIG_RegisterMapping("_wxEvtHandler","_class_wxEvtHandler",0);
+	 SWIG_RegisterMapping("_wxMenuItem","_class_wxMenuItem",0);
+	 SWIG_RegisterMapping("_class_wxScrollBar","_wxScrollBar",0);
+	 SWIG_RegisterMapping("_wxDash","_unsigned_long",0);
+	 SWIG_RegisterMapping("_wxDash","_long",0);
+	 SWIG_RegisterMapping("_class_wxScrolledWindow","_wxScrolledWindow",0);
+	 SWIG_RegisterMapping("_wxKeyEvent","_class_wxKeyEvent",0);
+	 SWIG_RegisterMapping("_wxMoveEvent","_class_wxMoveEvent",0);
+	 SWIG_RegisterMapping("_class_wxPalette","_wxPalette",0);
+	 SWIG_RegisterMapping("_class_wxEraseEvent","_wxEraseEvent",0);
+	 SWIG_RegisterMapping("_wxMDIClientWindow","_class_wxMDIClientWindow",0);
+	 SWIG_RegisterMapping("_wxWindow","_class_wxMDIClientWindow",SwigwxMDIClientWindowTowxWindow);
+	 SWIG_RegisterMapping("_wxWindow","_wxMDIClientWindow",SwigwxMDIClientWindowTowxWindow);
+	 SWIG_RegisterMapping("_wxWindow","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxWindow);
+	 SWIG_RegisterMapping("_wxWindow","_wxMDIChildFrame",SwigwxMDIChildFrameTowxWindow);
+	 SWIG_RegisterMapping("_wxWindow","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxWindow);
+	 SWIG_RegisterMapping("_wxWindow","_wxMDIParentFrame",SwigwxMDIParentFrameTowxWindow);
+	 SWIG_RegisterMapping("_wxWindow","_class_wxWindow",0);
+	 SWIG_RegisterMapping("_class_wxFrame","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxFrame);
+	 SWIG_RegisterMapping("_class_wxFrame","_wxMDIChildFrame",SwigwxMDIChildFrameTowxFrame);
+	 SWIG_RegisterMapping("_class_wxFrame","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxFrame);
+	 SWIG_RegisterMapping("_class_wxFrame","_wxMDIParentFrame",SwigwxMDIParentFrameTowxFrame);
+	 SWIG_RegisterMapping("_class_wxFrame","_wxFrame",0);
+}