This commit was manufactured by cvs2svn to create tag

'INT32_TO_JPEG_INT32'.

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/tags/INT32_TO_JPEG_INT32@15558 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/jpeg/.cvsignore

@@ -0,0 +1,2 @@
+jpegM*Data
+jpegM5.mcp

src/jpeg/MAKEFILE.VA

@@ -0,0 +1,335 @@
+#
+# File:      makefile.vc
+# Author:    David Webster
+# Created:   1999
+# Updated:
+# Copyright: c) 1993, AIAI, University of Edinburgh
+#
+# "%W% %G%"
+#
+# Makefile : Builds os2jpeg.lib library for OS/2 3.0/4.0
+
+# Suffixes
+OBJSUFF=obj
+SRCSUFF=cpp
+
+OS2FLAGS=/c /W2 /DOS232 /D__VISAGECPP__ /D__WXPM__ /DJPEGLOCAL /Ss /Q /N100 /Tdc
+OS2LINKFLAGS=/BASE:0x00010000 /PMTYPE:PM /NOE /NOD /ALIGN:16
+OS2LIBFLAGS=/NOL /NOE
+OS2LIBS=CPPOM30.lib CPPOOC3.LIB OS2386.LIB
+
+!if "$(WXMAKINGDLL)" != "0"
+EXTRADLLFLAGS=/DWXMAKINGDLL=1 /Ge- /D__OS2DLL__
+EXTRALNKFLAGS=/DLL
+!endif
+
+# Change WXDIR or WXWIN to wherever wxWindows is found
+WXDIR = $(WXWIN)
+
+OS2JPEGDIR=$(WXDIR)\src\jpeg
+OS2JPEGINC=$(WINJPEGDIR)
+!if "$(WXMAKINGDLL)" != "1"
+OS2JPEGLIB=$(WXDIR)\lib\os2jpeg.lib
+!else
+OS2JPEGLIB=$(WXDIR)\lib\os2jpeg.dll
+!endif
+
+TEMP1TGT=$(WXDIR)\lib\os2jpeg1.lib
+TEMP2TGT=$(WXDIR)\lib\os2jpeg2.lib
+
+INC=-I$(WXDIR)\src\jpeg -I$(WXDIR)\Include
+!ifndef FINAL
+FINAL=0
+!endif
+
+!if "$(NOPCH)" == "1"
+PCH=
+PRECOMP=
+MAKEPRECOMP=
+!else
+PCH=$(WXLIBNAME).pch
+PRECOMP=/Si$(PCH)
+MAKEPRECOMP=/Fi$(PCH)
+!endif
+
+!if "$(FINAL)" == "0"
+!if "$(WXMAKINGDLL)" == "1"
+D=DebugOS2DLL
+!else
+D=DebugOS2
+!endif
+
+OPT =
+DEBUG_FLAGS= /Ti /D__WXDEBUG__ #/Fb
+LINK_DEBUG_FLAGS=/DEBUG
+CRTFLAG=/Gm /Gd
+!else
+# /O1 - smallest code
+# /O2 - fastest code
+!if "$(WXMAKINGDLL)" == "1"
+D=RelseOS2DLL
+!else
+D=RelseOS2
+!endif
+OPT = /O+ /Oc /G5
+DEBUG_FLAGS=
+LINK_DEBUG_FLAGS=/RELEASE
+CRTFLAG=/Gm /Gd
+!endif
+
+!if [md $(OS2JPEGDIR)\$D]
+!endif
+
+CPPFLAGS=$(OS2FLAGS) $(EXTRADLLFLAGS) $(DEBUG_FLAGS) $(PRECOMP) $(INC) $(OPT) $(CRTFLAG)
+LINKFKAGS=$(OS2LINKFLAGS) $(EXTRALNKFLAGS)
+
+{..\jpeg}.c{..\jpeg\$D}.obj:
+    @echo $<
+    icc @<<
+$(CPPFLAGS) /Fo$@ /Tp $<
+<<
+
+SYSDEPMEM= ..\jpeg\$D\jmemnobs.obj
+
+# library object files common to compression and decompression
+COMOBJECTS= \
+  ..\jpeg\$D\jcomapi.obj \
+  ..\jpeg\$D\jutils.obj \
+  ..\jpeg\$D\jerror.obj \
+  ..\jpeg\$D\jmemmgr.obj \
+  $(SYSDEPMEM)
+
+COMLIBOBJS= \
+  jcomapi.obj \
+  jutils.obj \
+  jerror.obj \
+  jmemmgr.obj \
+  jmemnobs
+
+# compression library object files
+CLIBOBJECTS= \
+  ..\jpeg\$D\jcapimin.obj \
+  ..\jpeg\$D\jcapistd.obj \
+  ..\jpeg\$D\jctrans.obj \
+  ..\jpeg\$D\jcparam.obj \
+  ..\jpeg\$D\jdatadst.obj \
+  ..\jpeg\$D\jcinit.obj \
+  ..\jpeg\$D\jcmaster.obj \
+  ..\jpeg\$D\jcmarker.obj \
+  ..\jpeg\$D\jcmainct.obj \
+  ..\jpeg\$D\jcprepct.obj \
+  ..\jpeg\$D\jccoefct.obj \
+  ..\jpeg\$D\jccolor.obj \
+  ..\jpeg\$D\jcsample.obj \
+  ..\jpeg\$D\jchuff.obj \
+  ..\jpeg\$D\jcphuff.obj \
+  ..\jpeg\$D\jcdctmgr.obj \
+  ..\jpeg\$D\jfdctfst.obj \
+  ..\jpeg\$D\jfdctflt.obj \
+  ..\jpeg\$D\jfdctint.obj
+
+CLIBLIBOBJS= \
+  jcapimin.obj \
+  jcapistd.obj \
+  jctrans.obj \
+  jcparam.obj \
+  jdatadst.obj \
+  jcinit.obj \
+  jcmaster.obj \
+  jcmarker.obj \
+  jcmainct.obj \
+  jcprepct.obj \
+  jccoefct.obj \
+  jccolor.obj \
+  jcsample.obj \
+  jchuff.obj \
+  jcphuff.obj \
+  jcdctmgr.obj \
+  jfdctfst.obj \
+  jfdctflt.obj \
+  jfdctint.obj
+
+# decompression library object files
+DLIBOBJECTS= \
+  ..\jpeg\$D\jdapimin.obj \
+  ..\jpeg\$D\jdapistd.obj \
+  ..\jpeg\$D\jdtrans.obj \
+  ..\jpeg\$D\jdatasrc.obj \
+  ..\jpeg\$D\jdmaster.obj \
+  ..\jpeg\$D\jdinput.obj \
+  ..\jpeg\$D\jdmarker.obj \
+  ..\jpeg\$D\jdhuff.obj \
+  ..\jpeg\$D\jdphuff.obj \
+  ..\jpeg\$D\jdmainct.obj \
+  ..\jpeg\$D\jdcoefct.obj \
+  ..\jpeg\$D\jdpostct.obj \
+  ..\jpeg\$D\jddctmgr.obj \
+  ..\jpeg\$D\jidctfst.obj \
+  ..\jpeg\$D\jidctflt.obj \
+  ..\jpeg\$D\jidctint.obj \
+  ..\jpeg\$D\jidctred.obj \
+  ..\jpeg\$D\jdsample.obj \
+  ..\jpeg\$D\jdcolor.obj \
+  ..\jpeg\$D\jquant1.obj \
+  ..\jpeg\$D\jquant2.obj \
+  ..\jpeg\$D\jdmerge.obj
+
+DLIBLIBOBJS= \
+  jdapimin.obj \
+  jdapistd.obj \
+  jdtrans.obj \
+  jdatasrc.obj \
+  jdmaster.obj \
+  jdinput.obj \
+  jdmarker.obj \
+  jdhuff.obj \
+  jdphuff.obj \
+  jdmainct.obj \
+  jdcoefct.obj \
+  jdpostct.obj \
+  jddctmgr.obj \
+  jidctfst.obj \
+  jidctflt.obj \
+  jidctint.obj \
+  jidctred.obj \
+  jdsample.obj \
+  jdcolor.obj \
+  jquant1.obj \
+  jquant2.obj \
+  jdmerge.obj
+
+# These objectfiles are included in libjpeg.lib
+OBJECTS=  $(COMOBJECTS) $(CLIBOBJECTS) $(DLIBOBJECTS)
+
+# object files for sample applications (excluding library files)
+COBJECTS= \
+  ..\jpeg\$D\cjpeg.obj \
+  ..\jpeg\$D\rdppm.obj \
+  ..\jpeg\$D\rdgif.obj \
+  ..\jpeg\$D\rdtarga.obj \
+  ..\jpeg\$D\rdrle.obj \
+  ..\jpeg\$D\rdbmp.obj \
+  ..\jpeg\$D\rdswitch.obj \
+  ..\jpeg\$D\cdjpeg.obj
+
+DOBJECTS= \
+  ..\jpeg\$D\djpeg.obj \
+  ..\jpeg\$D\wrppm.obj \
+  ..\jpeg\$D\wrgif.obj \
+  ..\jpeg\$D\wrtarga.obj \
+  ..\jpeg\$D\wrrle.obj \
+  ..\jpeg\$D\wrbmp.obj \
+  ..\jpeg\$D\rdcolmap.obj \
+  ..\jpeg\$D\cdjpeg.obj
+
+TROBJECTS= \
+  ..\jpeg\$D\jpegtran.obj \
+  ..\jpeg\$D\rdswitch.obj \
+  ..\jpeg\$D\cdjpeg.obj \
+  ..\jpeg\$D\transupp.obj
+
+all:  $(OBJECTS) $(OS2JPEGLIB)
+
+$(COMLIBOBJS):
+  copy ..\jpeg\$D\jcomapi.obj
+  copy ..\jpeg\$D\jutils.obj
+  copy ..\jpeg\$D\jerror.obj
+  copy ..\jpeg\$D\jmemmgr.obj
+  copy ..\jpeg\$D\jmemnobs.obj
+
+$(CLIBLIBOBJS):
+  copy ..\jpeg\$D\jcapimin.obj
+  copy ..\jpeg\$D\jcapistd.obj
+  copy ..\jpeg\$D\jctrans.obj
+  copy ..\jpeg\$D\jcparam.obj
+  copy ..\jpeg\$D\jdatadst.obj
+  copy ..\jpeg\$D\jcinit.obj
+  copy ..\jpeg\$D\jcmaster.obj
+  copy ..\jpeg\$D\jcmarker.obj
+  copy ..\jpeg\$D\jcmainct.obj
+  copy ..\jpeg\$D\jcprepct.obj
+  copy ..\jpeg\$D\jccoefct.obj
+  copy ..\jpeg\$D\jccolor.obj
+  copy ..\jpeg\$D\jcsample.obj
+  copy ..\jpeg\$D\jchuff.obj
+  copy ..\jpeg\$D\jcphuff.obj
+  copy ..\jpeg\$D\jcdctmgr.obj
+  copy ..\jpeg\$D\jfdctfst.obj
+  copy ..\jpeg\$D\jfdctflt.obj
+  copy ..\jpeg\$D\jfdctint.obj
+
+$(DLIBLIBOBJS):
+  copy ..\jpeg\$D\jdapimin.obj
+  copy ..\jpeg\$D\jdapistd.obj
+  copy ..\jpeg\$D\jdtrans.obj
+  copy ..\jpeg\$D\jdatasrc.obj
+  copy ..\jpeg\$D\jdmaster.obj
+  copy ..\jpeg\$D\jdinput.obj
+  copy ..\jpeg\$D\jdmarker.obj
+  copy ..\jpeg\$D\jdhuff.obj
+  copy ..\jpeg\$D\jdphuff.obj
+  copy ..\jpeg\$D\jdmainct.obj
+  copy ..\jpeg\$D\jdcoefct.obj
+  copy ..\jpeg\$D\jdpostct.obj
+  copy ..\jpeg\$D\jddctmgr.obj
+  copy ..\jpeg\$D\jidctfst.obj
+  copy ..\jpeg\$D\jidctflt.obj
+  copy ..\jpeg\$D\jidctint.obj
+  copy ..\jpeg\$D\jidctred.obj
+  copy ..\jpeg\$D\jdsample.obj
+  copy ..\jpeg\$D\jdcolor.obj
+  copy ..\jpeg\$D\jquant1.obj
+  copy ..\jpeg\$D\jquant2.obj
+  copy ..\jpeg\$D\jdmerge.obj
+
+!if "$(WXMAKINGDLL)" != "1"
+
+$(WXDIR)\lib\os2jpeg1.lib: \
+    $(COMLIBOBJS) \
+    $(CLIBLIBOBJS)
+ -touch $(WXDIR)\lib\os2jpeg1.lib
+ -del $(WXDIR)\lib\os2jpeg1.lib
+ ilib $(OS2LIBFLAGS) $@ @<<
+    $**;
+<<
+
+$(WXDIR)\lib\os2jpeg2.lib: $(DLIBLIBOBJS)
+ -touch $(WXDIR)\lib\os2jpeg2.lib
+ -del $(WXDIR)\lib\os2jpeg2.lib
+ ilib $(OS2LIBFLAGS) $@ @<<
+    $**;
+<<
+
+$(WXDIR)\lib\os2jpeg.lib: \
+    $(TEMP1TGT) \
+    $(TEMP2TGT)
+ -touch $(WXDIR)\lib\os2jpeg.lib
+ -del $(WXDIR)\lib\os2jpeg.lib
+ ilib $(OS2LIBFLAGS) $@ @<<
+    $**;
+<<
+  del *.obj
+  del $(TEMP1TGT)
+  del $(TEMP2TGT)
+
+!else
+
+# Update the dynamic link library
+$(WXDIR)\lib\os2jpeg.dll: $(OBJECTS)
+    icc @<<
+    /B" $(LINKFLAGS)" /Fe$@
+    $(LIBS)
+    $(OBJECTS)
+    $(WXDIR)\src\os2\os2jpeg.def
+<<
+    implib $(WXDIR)\lib\os2jpegd.lib $(WXDIR)\src\os2\os2jpeg.def
+
+!endif
+
+clean:
+        del      $(OS2JPEGLIB)
+        erase /N $(OS2JPEGDIR)\$D
+        rd       $(OS2JPEGDIR)\$D
+
+cleanall:     clean
+

src/jpeg/README

@@ -0,0 +1,385 @@
+The Independent JPEG Group's JPEG software
+==========================================
+
+README for release 6b of 27-Mar-1998
+====================================
+
+This distribution contains the sixth public release of the Independent JPEG
+Group's free JPEG software.  You are welcome to redistribute this software and
+to use it for any purpose, subject to the conditions under LEGAL ISSUES, below.
+
+Serious users of this software (particularly those incorporating it into
+larger programs) should contact IJG at jpeg-info@uunet.uu.net to be added to
+our electronic mailing list.  Mailing list members are notified of updates
+and have a chance to participate in technical discussions, etc.
+
+This software is the work of Tom Lane, Philip Gladstone, Jim Boucher,
+Lee Crocker, Julian Minguillon, Luis Ortiz, George Phillips, Davide Rossi,
+Guido Vollbeding, Ge' Weijers, and other members of the Independent JPEG
+Group.
+
+IJG is not affiliated with the official ISO JPEG standards committee.
+
+
+DOCUMENTATION ROADMAP
+=====================
+
+This file contains the following sections:
+
+OVERVIEW            General description of JPEG and the IJG software.
+LEGAL ISSUES        Copyright, lack of warranty, terms of distribution.
+REFERENCES          Where to learn more about JPEG.
+ARCHIVE LOCATIONS   Where to find newer versions of this software.
+RELATED SOFTWARE    Other stuff you should get.
+FILE FORMAT WARS    Software *not* to get.
+TO DO               Plans for future IJG releases.
+
+Other documentation files in the distribution are:
+
+User documentation:
+  install.doc       How to configure and install the IJG software.
+  usage.doc         Usage instructions for cjpeg, djpeg, jpegtran,
+                    rdjpgcom, and wrjpgcom.
+  *.1               Unix-style man pages for programs (same info as usage.doc).
+  wizard.doc        Advanced usage instructions for JPEG wizards only.
+  change.log        Version-to-version change highlights.
+Programmer and internal documentation:
+  libjpeg.doc       How to use the JPEG library in your own programs.
+  example.c         Sample code for calling the JPEG library.
+  structure.doc     Overview of the JPEG library's internal structure.
+  filelist.doc      Road map of IJG files.
+  coderules.doc     Coding style rules --- please read if you contribute code.
+
+Please read at least the files install.doc and usage.doc.  Useful information
+can also be found in the JPEG FAQ (Frequently Asked Questions) article.  See
+ARCHIVE LOCATIONS below to find out where to obtain the FAQ article.
+
+If you want to understand how the JPEG code works, we suggest reading one or
+more of the REFERENCES, then looking at the documentation files (in roughly
+the order listed) before diving into the code.
+
+
+OVERVIEW
+========
+
+This package contains C software to implement JPEG image compression and
+decompression.  JPEG (pronounced "jay-peg") is a standardized compression
+method for full-color and gray-scale images.  JPEG is intended for compressing
+"real-world" scenes; line drawings, cartoons and other non-realistic images
+are not its strong suit.  JPEG is lossy, meaning that the output image is not
+exactly identical to the input image.  Hence you must not use JPEG if you
+have to have identical output bits.  However, on typical photographic images,
+very good compression levels can be obtained with no visible change, and
+remarkably high compression levels are possible if you can tolerate a
+low-quality image.  For more details, see the references, or just experiment
+with various compression settings.
+
+This software implements JPEG baseline, extended-sequential, and progressive
+compression processes.  Provision is made for supporting all variants of these
+processes, although some uncommon parameter settings aren't implemented yet.
+For legal reasons, we are not distributing code for the arithmetic-coding
+variants of JPEG; see LEGAL ISSUES.  We have made no provision for supporting
+the hierarchical or lossless processes defined in the standard.
+
+We provide a set of library routines for reading and writing JPEG image files,
+plus two sample applications "cjpeg" and "djpeg", which use the library to
+perform conversion between JPEG and some other popular image file formats.
+The library is intended to be reused in other applications.
+
+In order to support file conversion and viewing software, we have included
+considerable functionality beyond the bare JPEG coding/decoding capability;
+for example, the color quantization modules are not strictly part of JPEG
+decoding, but they are essential for output to colormapped file formats or
+colormapped displays.  These extra functions can be compiled out of the
+library if not required for a particular application.  We have also included
+"jpegtran", a utility for lossless transcoding between different JPEG
+processes, and "rdjpgcom" and "wrjpgcom", two simple applications for
+inserting and extracting textual comments in JFIF files.
+
+The emphasis in designing this software has been on achieving portability and
+flexibility, while also making it fast enough to be useful.  In particular,
+the software is not intended to be read as a tutorial on JPEG.  (See the
+REFERENCES section for introductory material.)  Rather, it is intended to
+be reliable, portable, industrial-strength code.  We do not claim to have
+achieved that goal in every aspect of the software, but we strive for it.
+
+We welcome the use of this software as a component of commercial products.
+No royalty is required, but we do ask for an acknowledgement in product
+documentation, as described under LEGAL ISSUES.
+
+
+LEGAL ISSUES
+============
+
+In plain English:
+
+1. We don't promise that this software works.  (But if you find any bugs,
+   please let us know!)
+2. You can use this software for whatever you want.  You don't have to pay us.
+3. You may not pretend that you wrote this software.  If you use it in a
+   program, you must acknowledge somewhere in your documentation that
+   you've used the IJG code.
+
+In legalese:
+
+The authors make NO WARRANTY or representation, either express or implied,
+with respect to this software, its quality, accuracy, merchantability, or
+fitness for a particular purpose.  This software is provided "AS IS", and you,
+its user, assume the entire risk as to its quality and accuracy.
+
+This software is copyright (C) 1991-1998, Thomas G. Lane.
+All Rights Reserved except as specified below.
+
+Permission is hereby granted to use, copy, modify, and distribute this
+software (or portions thereof) for any purpose, without fee, subject to these
+conditions:
+(1) If any part of the source code for this software is distributed, then this
+README file must be included, with this copyright and no-warranty notice
+unaltered; and any additions, deletions, or changes to the original files
+must be clearly indicated in accompanying documentation.
+(2) If only executable code is distributed, then the accompanying
+documentation must state that "this software is based in part on the work of
+the Independent JPEG Group".
+(3) Permission for use of this software is granted only if the user accepts
+full responsibility for any undesirable consequences; the authors accept
+NO LIABILITY for damages of any kind.
+
+These conditions apply to any software derived from or based on the IJG code,
+not just to the unmodified library.  If you use our work, you ought to
+acknowledge us.
+
+Permission is NOT granted for the use of any IJG author's name or company name
+in advertising or publicity relating to this software or products derived from
+it.  This software may be referred to only as "the Independent JPEG Group's
+software".
+
+We specifically permit and encourage the use of this software as the basis of
+commercial products, provided that all warranty or liability claims are
+assumed by the product vendor.
+
+
+ansi2knr.c is included in this distribution by permission of L. Peter Deutsch,
+sole proprietor of its copyright holder, Aladdin Enterprises of Menlo Park, CA.
+ansi2knr.c is NOT covered by the above copyright and conditions, but instead
+by the usual distribution terms of the Free Software Foundation; principally,
+that you must include source code if you redistribute it.  (See the file
+ansi2knr.c for full details.)  However, since ansi2knr.c is not needed as part
+of any program generated from the IJG code, this does not limit you more than
+the foregoing paragraphs do.
+
+The Unix configuration script "configure" was produced with GNU Autoconf.
+It is copyright by the Free Software Foundation but is freely distributable.
+The same holds for its supporting scripts (config.guess, config.sub,
+ltconfig, ltmain.sh).  Another support script, install-sh, is copyright
+by M.I.T. but is also freely distributable.
+
+It appears that the arithmetic coding option of the JPEG spec is covered by
+patents owned by IBM, AT&T, and Mitsubishi.  Hence arithmetic coding cannot
+legally be used without obtaining one or more licenses.  For this reason,
+support for arithmetic coding has been removed from the free JPEG software.
+(Since arithmetic coding provides only a marginal gain over the unpatented
+Huffman mode, it is unlikely that very many implementations will support it.)
+So far as we are aware, there are no patent restrictions on the remaining
+code.
+
+The IJG distribution formerly included code to read and write GIF files.
+To avoid entanglement with the Unisys LZW patent, GIF reading support has
+been removed altogether, and the GIF writer has been simplified to produce
+"uncompressed GIFs".  This technique does not use the LZW algorithm; the
+resulting GIF files are larger than usual, but are readable by all standard
+GIF decoders.
+
+We are required to state that
+    "The Graphics Interchange Format(c) is the Copyright property of
+    CompuServe Incorporated.  GIF(sm) is a Service Mark property of
+    CompuServe Incorporated."
+
+
+REFERENCES
+==========
+
+We highly recommend reading one or more of these references before trying to
+understand the innards of the JPEG software.
+
+The best short technical introduction to the JPEG compression algorithm is
+	Wallace, Gregory K.  "The JPEG Still Picture Compression Standard",
+	Communications of the ACM, April 1991 (vol. 34 no. 4), pp. 30-44.
+(Adjacent articles in that issue discuss MPEG motion picture compression,
+applications of JPEG, and related topics.)  If you don't have the CACM issue
+handy, a PostScript file containing a revised version of Wallace's article is
+available at ftp://ftp.uu.net/graphics/jpeg/wallace.ps.gz.  The file (actually
+a preprint for an article that appeared in IEEE Trans. Consumer Electronics)
+omits the sample images that appeared in CACM, but it includes corrections
+and some added material.  Note: the Wallace article is copyright ACM and IEEE,
+and it may not be used for commercial purposes.
+
+A somewhat less technical, more leisurely introduction to JPEG can be found in
+"The Data Compression Book" by Mark Nelson and Jean-loup Gailly, published by
+M&T Books (New York), 2nd ed. 1996, ISBN 1-55851-434-1.  This book provides
+good explanations and example C code for a multitude of compression methods
+including JPEG.  It is an excellent source if you are comfortable reading C
+code but don't know much about data compression in general.  The book's JPEG
+sample code is far from industrial-strength, but when you are ready to look
+at a full implementation, you've got one here...
+
+The best full description of JPEG is the textbook "JPEG Still Image Data
+Compression Standard" by William B. Pennebaker and Joan L. Mitchell, published
+by Van Nostrand Reinhold, 1993, ISBN 0-442-01272-1.  Price US$59.95, 638 pp.
+The book includes the complete text of the ISO JPEG standards (DIS 10918-1
+and draft DIS 10918-2).  This is by far the most complete exposition of JPEG
+in existence, and we highly recommend it.
+
+The JPEG standard itself is not available electronically; you must order a
+paper copy through ISO or ITU.  (Unless you feel a need to own a certified
+official copy, we recommend buying the Pennebaker and Mitchell book instead;
+it's much cheaper and includes a great deal of useful explanatory material.)
+In the USA, copies of the standard may be ordered from ANSI Sales at (212)
+642-4900, or from Global Engineering Documents at (800) 854-7179.  (ANSI
+doesn't take credit card orders, but Global does.)  It's not cheap: as of
+1992, ANSI was charging $95 for Part 1 and $47 for Part 2, plus 7%
+shipping/handling.  The standard is divided into two parts, Part 1 being the
+actual specification, while Part 2 covers compliance testing methods.  Part 1
+is titled "Digital Compression and Coding of Continuous-tone Still Images,
+Part 1: Requirements and guidelines" and has document numbers ISO/IEC IS
+10918-1, ITU-T T.81.  Part 2 is titled "Digital Compression and Coding of
+Continuous-tone Still Images, Part 2: Compliance testing" and has document
+numbers ISO/IEC IS 10918-2, ITU-T T.83.
+
+Some extensions to the original JPEG standard are defined in JPEG Part 3,
+a newer ISO standard numbered ISO/IEC IS 10918-3 and ITU-T T.84.  IJG
+currently does not support any Part 3 extensions.
+
+The JPEG standard does not specify all details of an interchangeable file
+format.  For the omitted details we follow the "JFIF" conventions, revision
+1.02.  A copy of the JFIF spec is available from:
+	Literature Department
+	C-Cube Microsystems, Inc.
+	1778 McCarthy Blvd.
+	Milpitas, CA 95035
+	phone (408) 944-6300,  fax (408) 944-6314
+A PostScript version of this document is available by FTP at
+ftp://ftp.uu.net/graphics/jpeg/jfif.ps.gz.  There is also a plain text
+version at ftp://ftp.uu.net/graphics/jpeg/jfif.txt.gz, but it is missing
+the figures.
+
+The TIFF 6.0 file format specification can be obtained by FTP from
+ftp://ftp.sgi.com/graphics/tiff/TIFF6.ps.gz.  The JPEG incorporation scheme
+found in the TIFF 6.0 spec of 3-June-92 has a number of serious problems.
+IJG does not recommend use of the TIFF 6.0 design (TIFF Compression tag 6).
+Instead, we recommend the JPEG design proposed by TIFF Technical Note #2
+(Compression tag 7).  Copies of this Note can be obtained from ftp.sgi.com or
+from ftp://ftp.uu.net/graphics/jpeg/.  It is expected that the next revision
+of the TIFF spec will replace the 6.0 JPEG design with the Note's design.
+Although IJG's own code does not support TIFF/JPEG, the free libtiff library
+uses our library to implement TIFF/JPEG per the Note.  libtiff is available
+from ftp://ftp.sgi.com/graphics/tiff/.
+
+
+ARCHIVE LOCATIONS
+=================
+
+The "official" archive site for this software is ftp.uu.net (Internet
+address 192.48.96.9).  The most recent released version can always be found
+there in directory graphics/jpeg.  This particular version will be archived
+as ftp://ftp.uu.net/graphics/jpeg/jpegsrc.v6b.tar.gz.  If you don't have
+direct Internet access, UUNET's archives are also available via UUCP; contact
+help@uunet.uu.net for information on retrieving files that way.
+
+Numerous Internet sites maintain copies of the UUNET files.  However, only
+ftp.uu.net is guaranteed to have the latest official version.
+
+You can also obtain this software in DOS-compatible "zip" archive format from
+the SimTel archives (ftp://ftp.simtel.net/pub/simtelnet/msdos/graphics/), or
+on CompuServe in the Graphics Support forum (GO CIS:GRAPHSUP), library 12
+"JPEG Tools".  Again, these versions may sometimes lag behind the ftp.uu.net
+release.
+
+The JPEG FAQ (Frequently Asked Questions) article is a useful source of
+general information about JPEG.  It is updated constantly and therefore is
+not included in this distribution.  The FAQ is posted every two weeks to
+Usenet newsgroups comp.graphics.misc, news.answers, and other groups.
+It is available on the World Wide Web at http://www.faqs.org/faqs/jpeg-faq/
+and other news.answers archive sites, including the official news.answers
+archive at rtfm.mit.edu: ftp://rtfm.mit.edu/pub/usenet/news.answers/jpeg-faq/.
+If you don't have Web or FTP access, send e-mail to mail-server@rtfm.mit.edu
+with body
+	send usenet/news.answers/jpeg-faq/part1
+	send usenet/news.answers/jpeg-faq/part2
+
+
+RELATED SOFTWARE
+================
+
+Numerous viewing and image manipulation programs now support JPEG.  (Quite a
+few of them use this library to do so.)  The JPEG FAQ described above lists
+some of the more popular free and shareware viewers, and tells where to
+obtain them on Internet.
+
+If you are on a Unix machine, we highly recommend Jef Poskanzer's free
+PBMPLUS software, which provides many useful operations on PPM-format image
+files.  In particular, it can convert PPM images to and from a wide range of
+other formats, thus making cjpeg/djpeg considerably more useful.  The latest
+version is distributed by the NetPBM group, and is available from numerous
+sites, notably ftp://wuarchive.wustl.edu/graphics/graphics/packages/NetPBM/.
+Unfortunately PBMPLUS/NETPBM is not nearly as portable as the IJG software is;
+you are likely to have difficulty making it work on any non-Unix machine.
+
+A different free JPEG implementation, written by the PVRG group at Stanford,
+is available from ftp://havefun.stanford.edu/pub/jpeg/.  This program
+is designed for research and experimentation rather than production use;
+it is slower, harder to use, and less portable than the IJG code, but it
+is easier to read and modify.  Also, the PVRG code supports lossless JPEG,
+which we do not.  (On the other hand, it doesn't do progressive JPEG.)
+
+
+FILE FORMAT WARS
+================
+
+Some JPEG programs produce files that are not compatible with our library.
+The root of the problem is that the ISO JPEG committee failed to specify a
+concrete file format.  Some vendors "filled in the blanks" on their own,
+creating proprietary formats that no one else could read.  (For example, none
+of the early commercial JPEG implementations for the Macintosh were able to
+exchange compressed files.)
+
+The file format we have adopted is called JFIF (see REFERENCES).  This format
+has been agreed to by a number of major commercial JPEG vendors, and it has
+become the de facto standard.  JFIF is a minimal or "low end" representation.
+We recommend the use of TIFF/JPEG (TIFF revision 6.0 as modified by TIFF
+Technical Note #2) for "high end" applications that need to record a lot of
+additional data about an image.  TIFF/JPEG is fairly new and not yet widely
+supported, unfortunately.
+
+The upcoming JPEG Part 3 standard defines a file format called SPIFF.
+SPIFF is interoperable with JFIF, in the sense that most JFIF decoders should
+be able to read the most common variant of SPIFF.  SPIFF has some technical
+advantages over JFIF, but its major claim to fame is simply that it is an
+official standard rather than an informal one.  At this point it is unclear
+whether SPIFF will supersede JFIF or whether JFIF will remain the de-facto
+standard.  IJG intends to support SPIFF once the standard is frozen, but we
+have not decided whether it should become our default output format or not.
+(In any case, our decoder will remain capable of reading JFIF indefinitely.)
+
+Various proprietary file formats incorporating JPEG compression also exist.
+We have little or no sympathy for the existence of these formats.  Indeed,
+one of the original reasons for developing this free software was to help
+force convergence on common, open format standards for JPEG files.  Don't
+use a proprietary file format!
+
+
+TO DO
+=====
+
+The major thrust for v7 will probably be improvement of visual quality.
+The current method for scaling the quantization tables is known not to be
+very good at low Q values.  We also intend to investigate block boundary
+smoothing, "poor man's variable quantization", and other means of improving
+quality-vs-file-size performance without sacrificing compatibility.
+
+In future versions, we are considering supporting some of the upcoming JPEG
+Part 3 extensions --- principally, variable quantization and the SPIFF file
+format.
+
+As always, speeding things up is of great interest.
+
+Please send bug reports, offers of help, etc. to jpeg-info@uunet.uu.net.

src/jpeg/ansi2knr.1

@@ -0,0 +1,36 @@
+.TH ANSI2KNR 1 "19 Jan 1996"
+.SH NAME
+ansi2knr \- convert ANSI C to Kernighan & Ritchie C
+.SH SYNOPSIS
+.I ansi2knr
+[--varargs] input_file [output_file]
+.SH DESCRIPTION
+If no output_file is supplied, output goes to stdout.
+.br
+There are no error messages.
+.sp
+.I ansi2knr
+recognizes function definitions by seeing a non-keyword identifier at the left
+margin, followed by a left parenthesis, with a right parenthesis as the last
+character on the line, and with a left brace as the first token on the
+following line (ignoring possible intervening comments).  It will recognize a
+multi-line header provided that no intervening line ends with a left or right
+brace or a semicolon.  These algorithms ignore whitespace and comments, except
+that the function name must be the first thing on the line.
+.sp
+The following constructs will confuse it:
+.br
+     - Any other construct that starts at the left margin and follows the
+above syntax (such as a macro or function call).
+.br
+     - Some macros that tinker with the syntax of the function header.
+.sp
+The --varargs switch is obsolete, and is recognized only for
+backwards compatibility.  The present version of
+.I ansi2knr
+will always attempt to convert a ... argument to va_alist and va_dcl.
+.SH AUTHOR
+L. Peter Deutsch <ghost@aladdin.com> wrote the original ansi2knr and
+continues to maintain the current version; most of the code in the current
+version is his work.  ansi2knr also includes contributions by Francois
+Pinard <pinard@iro.umontreal.ca> and Jim Avera <jima@netcom.com>.

src/jpeg/ansi2knr.c

@@ -0,0 +1,693 @@
+/* ansi2knr.c */
+/* Convert ANSI C function definitions to K&R ("traditional C") syntax */
+
+/*
+ansi2knr is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone for the
+consequences of using it or for whether it serves any particular purpose or
+works at all, unless he says so in writing.  Refer to the GNU General Public
+License (the "GPL") for full details.
+
+Everyone is granted permission to copy, modify and redistribute ansi2knr,
+but only under the conditions described in the GPL.  A copy of this license
+is supposed to have been given to you along with ansi2knr so you can know
+your rights and responsibilities.  It should be in a file named COPYLEFT.
+[In the IJG distribution, the GPL appears below, not in a separate file.]
+Among other things, the copyright notice and this notice must be preserved
+on all copies.
+
+We explicitly state here what we believe is already implied by the GPL: if
+the ansi2knr program is distributed as a separate set of sources and a
+separate executable file which are aggregated on a storage medium together
+with another program, this in itself does not bring the other program under
+the GPL, nor does the mere fact that such a program or the procedures for
+constructing it invoke the ansi2knr executable bring any other part of the
+program under the GPL.
+*/
+
+/*
+---------- Here is the GNU GPL file COPYLEFT, referred to above ----------
+----- These terms do NOT apply to the JPEG software itself; see README ------
+
+		    GHOSTSCRIPT GENERAL PUBLIC LICENSE
+		    (Clarified 11 Feb 1988)
+
+ Copyright (C) 1988 Richard M. Stallman
+ Everyone is permitted to copy and distribute verbatim copies of this
+ license, but changing it is not allowed.  You can also use this wording
+ to make the terms for other programs.
+
+  The license agreements of most software companies keep you at the
+mercy of those companies.  By contrast, our general public license is
+intended to give everyone the right to share Ghostscript.  To make sure
+that you get the rights we want you to have, we need to make
+restrictions that forbid anyone to deny you these rights or to ask you
+to surrender the rights.  Hence this license agreement.
+
+  Specifically, we want to make sure that you have the right to give
+away copies of Ghostscript, that you receive source code or else can get
+it if you want it, that you can change Ghostscript or use pieces of it
+in new free programs, and that you know you can do these things.
+
+  To make sure that everyone has such rights, we have to forbid you to
+deprive anyone else of these rights.  For example, if you distribute
+copies of Ghostscript, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must tell them their rights.
+
+  Also, for our own protection, we must make certain that everyone finds
+out that there is no warranty for Ghostscript.  If Ghostscript is
+modified by someone else and passed on, we want its recipients to know
+that what they have is not what we distributed, so that any problems
+introduced by others will not reflect on our reputation.
+
+  Therefore we (Richard M. Stallman and the Free Software Foundation,
+Inc.) make the following terms which say what you must do to be allowed
+to distribute or change Ghostscript.
+
+
+			COPYING POLICIES
+
+  1. You may copy and distribute verbatim copies of Ghostscript source
+code as you receive it, in any medium, provided that you conspicuously
+and appropriately publish on each copy a valid copyright and license
+notice "Copyright (C) 1989 Aladdin Enterprises.  All rights reserved.
+Distributed by Free Software Foundation, Inc." (or with whatever year is
+appropriate); keep intact the notices on all files that refer to this
+License Agreement and to the absence of any warranty; and give any other
+recipients of the Ghostscript program a copy of this License Agreement
+along with the program.  You may charge a distribution fee for the
+physical act of transferring a copy.
+
+  2. You may modify your copy or copies of Ghostscript or any portion of
+it, and copy and distribute such modifications under the terms of
+Paragraph 1 above, provided that you also do the following:
+
+    a) cause the modified files to carry prominent notices stating
+    that you changed the files and the date of any change; and
+
+    b) cause the whole of any work that you distribute or publish,
+    that in whole or in part contains or is a derivative of Ghostscript
+    or any part thereof, to be licensed at no charge to all third
+    parties on terms identical to those contained in this License
+    Agreement (except that you may choose to grant more extensive
+    warranty protection to some or all third parties, at your option).
+
+    c) You may charge a distribution fee for the physical act of
+    transferring a copy, and you may at your option offer warranty
+    protection in exchange for a fee.
+
+Mere aggregation of another unrelated program with this program (or its
+derivative) on a volume of a storage or distribution medium does not bring
+the other program under the scope of these terms.
+
+  3. You may copy and distribute Ghostscript (or a portion or derivative
+of it, under Paragraph 2) in object code or executable form under the
+terms of Paragraphs 1 and 2 above provided that you also do one of the
+following:
+
+    a) accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of
+    Paragraphs 1 and 2 above; or,
+
+    b) accompany it with a written offer, valid for at least three
+    years, to give any third party free (except for a nominal
+    shipping charge) a complete machine-readable copy of the
+    corresponding source code, to be distributed under the terms of
+    Paragraphs 1 and 2 above; or,
+
+    c) accompany it with the information you received as to where the
+    corresponding source code may be obtained.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form alone.)
+
+For an executable file, complete source code means all the source code for
+all modules it contains; but, as a special exception, it need not include
+source code for modules which are standard libraries that accompany the
+operating system on which the executable file runs.
+
+  4. You may not copy, sublicense, distribute or transfer Ghostscript
+except as expressly provided under this License Agreement.  Any attempt
+otherwise to copy, sublicense, distribute or transfer Ghostscript is
+void and your rights to use the program under this License agreement
+shall be automatically terminated.  However, parties who have received
+computer software programs from you with this License Agreement will not
+have their licenses terminated so long as such parties remain in full
+compliance.
+
+  5. If you wish to incorporate parts of Ghostscript into other free
+programs whose distribution conditions are different, write to the Free
+Software Foundation at 675 Mass Ave, Cambridge, MA 02139.  We have not
+yet worked out a simple rule that can be stated here, but we will often
+permit this.  We will be guided by the two goals of preserving the free
+status of all derivatives of our free software and of promoting the
+sharing and reuse of software.
+
+Your comments and suggestions about our licensing policies and our
+software are welcome!  Please contact the Free Software Foundation,
+Inc., 675 Mass Ave, Cambridge, MA 02139, or call (617) 876-3296.
+
+		       NO WARRANTY
+
+  BECAUSE GHOSTSCRIPT IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY
+NO WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW.  EXCEPT
+WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC, RICHARD
+M. STALLMAN, ALADDIN ENTERPRISES, L. PETER DEUTSCH, AND/OR OTHER PARTIES
+PROVIDE GHOSTSCRIPT "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER
+EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE
+ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF GHOSTSCRIPT IS WITH
+YOU.  SHOULD GHOSTSCRIPT PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL
+NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M.
+STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., L. PETER DEUTSCH, ALADDIN
+ENTERPRISES, AND/OR ANY OTHER PARTY WHO MAY MODIFY AND REDISTRIBUTE
+GHOSTSCRIPT AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING
+ANY LOST PROFITS, LOST MONIES, OR OTHER SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE
+(INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED
+INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR A FAILURE OF THE
+PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) GHOSTSCRIPT, EVEN IF YOU
+HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES, OR FOR ANY CLAIM
+BY ANY OTHER PARTY.
+
+-------------------- End of file COPYLEFT ------------------------------
+*/
+
+/*
+ * Usage:
+	ansi2knr input_file [output_file]
+ * If no output_file is supplied, output goes to stdout.
+ * There are no error messages.
+ *
+ * ansi2knr recognizes function definitions by seeing a non-keyword
+ * identifier at the left margin, followed by a left parenthesis,
+ * with a right parenthesis as the last character on the line,
+ * and with a left brace as the first token on the following line
+ * (ignoring possible intervening comments).
+ * It will recognize a multi-line header provided that no intervening
+ * line ends with a left or right brace or a semicolon.
+ * These algorithms ignore whitespace and comments, except that
+ * the function name must be the first thing on the line.
+ * The following constructs will confuse it:
+ *	- Any other construct that starts at the left margin and
+ *	    follows the above syntax (such as a macro or function call).
+ *	- Some macros that tinker with the syntax of the function header.
+ */
+
+/*
+ * The original and principal author of ansi2knr is L. Peter Deutsch
+ * <ghost@aladdin.com>.  Other authors are noted in the change history
+ * that follows (in reverse chronological order):
+	lpd 96-01-21 added code to cope with not HAVE_CONFIG_H and with
+		compilers that don't understand void, as suggested by
+		Tom Lane
+	lpd 96-01-15 changed to require that the first non-comment token
+		on the line following a function header be a left brace,
+		to reduce sensitivity to macros, as suggested by Tom Lane
+		<tgl@sss.pgh.pa.us>
+	lpd 95-06-22 removed #ifndefs whose sole purpose was to define
+		undefined preprocessor symbols as 0; changed all #ifdefs
+		for configuration symbols to #ifs
+	lpd 95-04-05 changed copyright notice to make it clear that
+		including ansi2knr in a program does not bring the entire
+		program under the GPL
+	lpd 94-12-18 added conditionals for systems where ctype macros
+		don't handle 8-bit characters properly, suggested by
+		Francois Pinard <pinard@iro.umontreal.ca>;
+		removed --varargs switch (this is now the default)
+	lpd 94-10-10 removed CONFIG_BROKETS conditional
+	lpd 94-07-16 added some conditionals to help GNU `configure',
+		suggested by Francois Pinard <pinard@iro.umontreal.ca>;
+		properly erase prototype args in function parameters,
+		contributed by Jim Avera <jima@netcom.com>;
+		correct error in writeblanks (it shouldn't erase EOLs)
+	lpd 89-xx-xx original version
+ */
+
+/* Most of the conditionals here are to make ansi2knr work with */
+/* or without the GNU configure machinery. */
+
+#if HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <stdio.h>
+#include <ctype.h>
+
+#if HAVE_CONFIG_H
+
+/*
+   For properly autoconfiguring ansi2knr, use AC_CONFIG_HEADER(config.h).
+   This will define HAVE_CONFIG_H and so, activate the following lines.
+ */
+
+# if STDC_HEADERS || HAVE_STRING_H
+#  include <string.h>
+# else
+#  include <strings.h>
+# endif
+
+#else /* not HAVE_CONFIG_H */
+
+/* Otherwise do it the hard way */
+
+# ifdef BSD
+#  include <strings.h>
+# else
+#  ifdef VMS
+    extern int strlen(), strncmp();
+#  else
+#   include <string.h>
+#  endif
+# endif
+
+#endif /* not HAVE_CONFIG_H */
+
+#if STDC_HEADERS
+# include <stdlib.h>
+#else
+/*
+   malloc and free should be declared in stdlib.h,
+   but if you've got a K&R compiler, they probably aren't.
+ */
+# ifdef MSDOS
+#  include <malloc.h>
+# else
+#  ifdef VMS
+     extern char *malloc();
+     extern void free();
+#  else
+     extern char *malloc();
+     extern int free();
+#  endif
+# endif
+
+#endif
+
+/*
+ * The ctype macros don't always handle 8-bit characters correctly.
+ * Compensate for this here.
+ */
+#ifdef isascii
+#  undef HAVE_ISASCII		/* just in case */
+#  define HAVE_ISASCII 1
+#else
+#endif
+#if STDC_HEADERS || !HAVE_ISASCII
+#  define is_ascii(c) 1
+#else
+#  define is_ascii(c) isascii(c)
+#endif
+
+#define is_space(c) (is_ascii(c) && isspace(c))
+#define is_alpha(c) (is_ascii(c) && isalpha(c))
+#define is_alnum(c) (is_ascii(c) && isalnum(c))
+
+/* Scanning macros */
+#define isidchar(ch) (is_alnum(ch) || (ch) == '_')
+#define isidfirstchar(ch) (is_alpha(ch) || (ch) == '_')
+
+/* Forward references */
+char *skipspace();
+int writeblanks();
+int test1();
+int convert1();
+
+/* The main program */
+int
+main(argc, argv)
+    int argc;
+    char *argv[];
+{	FILE *in, *out;
+#define bufsize 5000			/* arbitrary size */
+	char *buf;
+	char *line;
+	char *more;
+	/*
+	 * In previous versions, ansi2knr recognized a --varargs switch.
+	 * If this switch was supplied, ansi2knr would attempt to convert
+	 * a ... argument to va_alist and va_dcl; if this switch was not
+	 * supplied, ansi2knr would simply drop any such arguments.
+	 * Now, ansi2knr always does this conversion, and we only
+	 * check for this switch for backward compatibility.
+	 */
+	int convert_varargs = 1;
+
+	if ( argc > 1 && argv[1][0] == '-' )
+	  {	if ( !strcmp(argv[1], "--varargs") )
+		  {	convert_varargs = 1;
+			argc--;
+			argv++;
+		  }
+		else
+		  {	fprintf(stderr, "Unrecognized switch: %s\n", argv[1]);
+			exit(1);
+		  }
+	  }
+	switch ( argc )
+	   {
+	default:
+		printf("Usage: ansi2knr input_file [output_file]\n");
+		exit(0);
+	case 2:
+		out = stdout;
+		break;
+	case 3:
+		out = fopen(argv[2], "w");
+		if ( out == NULL )
+		   {	fprintf(stderr, "Cannot open output file %s\n", argv[2]);
+			exit(1);
+		   }
+	   }
+	in = fopen(argv[1], "r");
+	if ( in == NULL )
+	   {	fprintf(stderr, "Cannot open input file %s\n", argv[1]);
+		exit(1);
+	   }
+	fprintf(out, "#line 1 \"%s\"\n", argv[1]);
+	buf = malloc(bufsize);
+	line = buf;
+	while ( fgets(line, (unsigned)(buf + bufsize - line), in) != NULL )
+	   {
+test:		line += strlen(line);
+		switch ( test1(buf) )
+		   {
+		case 2:			/* a function header */
+			convert1(buf, out, 1, convert_varargs);
+			break;
+		case 1:			/* a function */
+			/* Check for a { at the start of the next line. */
+			more = ++line;
+f:			if ( line >= buf + (bufsize - 1) ) /* overflow check */
+			  goto wl;
+			if ( fgets(line, (unsigned)(buf + bufsize - line), in) == NULL )
+			  goto wl;
+			switch ( *skipspace(more, 1) )
+			  {
+			  case '{':
+			    /* Definitely a function header. */
+			    convert1(buf, out, 0, convert_varargs);
+			    fputs(more, out);
+			    break;
+			  case 0:
+			    /* The next line was blank or a comment: */
+			    /* keep scanning for a non-comment. */
+			    line += strlen(line);
+			    goto f;
+			  default:
+			    /* buf isn't a function header, but */
+			    /* more might be. */
+			    fputs(buf, out);
+			    strcpy(buf, more);
+			    line = buf;
+			    goto test;
+			  }
+			break;
+		case -1:		/* maybe the start of a function */
+			if ( line != buf + (bufsize - 1) ) /* overflow check */
+			  continue;
+			/* falls through */
+		default:		/* not a function */
+wl:			fputs(buf, out);
+			break;
+		   }
+		line = buf;
+	   }
+	if ( line != buf )
+	  fputs(buf, out);
+	free(buf);
+	fclose(out);
+	fclose(in);
+	return 0;
+}
+
+/* Skip over space and comments, in either direction. */
+char *
+skipspace(p, dir)
+    register char *p;
+    register int dir;			/* 1 for forward, -1 for backward */
+{	for ( ; ; )
+	   {	while ( is_space(*p) )
+		  p += dir;
+		if ( !(*p == '/' && p[dir] == '*') )
+		  break;
+		p += dir;  p += dir;
+		while ( !(*p == '*' && p[dir] == '/') )
+		   {	if ( *p == 0 )
+			  return p;	/* multi-line comment?? */
+			p += dir;
+		   }
+		p += dir;  p += dir;
+	   }
+	return p;
+}
+
+/*
+ * Write blanks over part of a string.
+ * Don't overwrite end-of-line characters.
+ */
+int
+writeblanks(start, end)
+    char *start;
+    char *end;
+{	char *p;
+	for ( p = start; p < end; p++ )
+	  if ( *p != '\r' && *p != '\n' )
+	    *p = ' ';
+	return 0;
+}
+
+/*
+ * Test whether the string in buf is a function definition.
+ * The string may contain and/or end with a newline.
+ * Return as follows:
+ *	0 - definitely not a function definition;
+ *	1 - definitely a function definition;
+ *	2 - definitely a function prototype (NOT USED);
+ *	-1 - may be the beginning of a function definition,
+ *		append another line and look again.
+ * The reason we don't attempt to convert function prototypes is that
+ * Ghostscript's declaration-generating macros look too much like
+ * prototypes, and confuse the algorithms.
+ */
+int
+test1(buf)
+    char *buf;
+{	register char *p = buf;
+	char *bend;
+	char *endfn;
+	int contin;
+
+	if ( !isidfirstchar(*p) )
+	  return 0;		/* no name at left margin */
+	bend = skipspace(buf + strlen(buf) - 1, -1);
+	switch ( *bend )
+	   {
+	   case ';': contin = 0 /*2*/; break;
+	   case ')': contin = 1; break;
+	   case '{': return 0;		/* not a function */
+	   case '}': return 0;		/* not a function */
+	   default: contin = -1;
+	   }
+	while ( isidchar(*p) )
+	  p++;
+	endfn = p;
+	p = skipspace(p, 1);
+	if ( *p++ != '(' )
+	  return 0;		/* not a function */
+	p = skipspace(p, 1);
+	if ( *p == ')' )
+	  return 0;		/* no parameters */
+	/* Check that the apparent function name isn't a keyword. */
+	/* We only need to check for keywords that could be followed */
+	/* by a left parenthesis (which, unfortunately, is most of them). */
+	   {	static char *words[] =
+		   {	"asm", "auto", "case", "char", "const", "double",
+			"extern", "float", "for", "if", "int", "long",
+			"register", "return", "short", "signed", "sizeof",
+			"static", "switch", "typedef", "unsigned",
+			"void", "volatile", "while", 0
+		   };
+		char **key = words;
+		char *kp;
+		int len = endfn - buf;
+
+		while ( (kp = *key) != 0 )
+		   {	if ( strlen(kp) == len && !strncmp(kp, buf, len) )
+			  return 0;	/* name is a keyword */
+			key++;
+		   }
+	   }
+	return contin;
+}
+
+/* Convert a recognized function definition or header to K&R syntax. */
+int
+convert1(buf, out, header, convert_varargs)
+    char *buf;
+    FILE *out;
+    int header;			/* Boolean */
+    int convert_varargs;	/* Boolean */
+{	char *endfn;
+	register char *p;
+	char **breaks;
+	unsigned num_breaks = 2;	/* for testing */
+	char **btop;
+	char **bp;
+	char **ap;
+	char *vararg = 0;
+
+	/* Pre-ANSI implementations don't agree on whether strchr */
+	/* is called strchr or index, so we open-code it here. */
+	for ( endfn = buf; *(endfn++) != '('; )
+	  ;
+top:	p = endfn;
+	breaks = (char **)malloc(sizeof(char *) * num_breaks * 2);
+	if ( breaks == 0 )
+	   {	/* Couldn't allocate break table, give up */
+		fprintf(stderr, "Unable to allocate break table!\n");
+		fputs(buf, out);
+		return -1;
+	   }
+	btop = breaks + num_breaks * 2 - 2;
+	bp = breaks;
+	/* Parse the argument list */
+	do
+	   {	int level = 0;
+		char *lp = NULL;
+		char *rp;
+		char *end = NULL;
+
+		if ( bp >= btop )
+		   {	/* Filled up break table. */
+			/* Allocate a bigger one and start over. */
+			free((char *)breaks);
+			num_breaks <<= 1;
+			goto top;
+		   }
+		*bp++ = p;
+		/* Find the end of the argument */
+		for ( ; end == NULL; p++ )
+		   {	switch(*p)
+			   {
+			   case ',':
+				if ( !level ) end = p;
+				break;
+			   case '(':
+				if ( !level ) lp = p;
+				level++;
+				break;
+			   case ')':
+				if ( --level < 0 ) end = p;
+				else rp = p;
+				break;
+			   case '/':
+				p = skipspace(p, 1) - 1;
+				break;
+			   default:
+				;
+			   }
+		   }
+		/* Erase any embedded prototype parameters. */
+		if ( lp )
+		  writeblanks(lp + 1, rp);
+		p--;			/* back up over terminator */
+		/* Find the name being declared. */
+		/* This is complicated because of procedure and */
+		/* array modifiers. */
+		for ( ; ; )
+		   {	p = skipspace(p - 1, -1);
+			switch ( *p )
+			   {
+			   case ']':	/* skip array dimension(s) */
+			   case ')':	/* skip procedure args OR name */
+			   {	int level = 1;
+				while ( level )
+				 switch ( *--p )
+				   {
+				   case ']': case ')': level++; break;
+				   case '[': case '(': level--; break;
+				   case '/': p = skipspace(p, -1) + 1; break;
+				   default: ;
+				   }
+			   }
+				if ( *p == '(' && *skipspace(p + 1, 1) == '*' )
+				   {	/* We found the name being declared */
+					while ( !isidfirstchar(*p) )
+					  p = skipspace(p, 1) + 1;
+					goto found;
+				   }
+				break;
+			   default:
+				goto found;
+			   }
+		   }
+found:		if ( *p == '.' && p[-1] == '.' && p[-2] == '.' )
+		  {	if ( convert_varargs )
+			  {	*bp++ = "va_alist";
+				vararg = p-2;
+			  }
+			else
+			  {	p++;
+				if ( bp == breaks + 1 )	/* sole argument */
+				  writeblanks(breaks[0], p);
+				else
+				  writeblanks(bp[-1] - 1, p);
+				bp--;
+			  }
+		   }
+		else
+		   {	while ( isidchar(*p) ) p--;
+			*bp++ = p+1;
+		   }
+		p = end;
+	   }
+	while ( *p++ == ',' );
+	*bp = p;
+	/* Make a special check for 'void' arglist */
+	if ( bp == breaks+2 )
+	   {	p = skipspace(breaks[0], 1);
+		if ( !strncmp(p, "void", 4) )
+		   {	p = skipspace(p+4, 1);
+			if ( p == breaks[2] - 1 )
+			   {	bp = breaks;	/* yup, pretend arglist is empty */
+				writeblanks(breaks[0], p + 1);
+			   }
+		   }
+	   }
+	/* Put out the function name and left parenthesis. */
+	p = buf;
+	while ( p != endfn ) putc(*p, out), p++;
+	/* Put out the declaration. */
+	if ( header )
+	  {	fputs(");", out);
+		for ( p = breaks[0]; *p; p++ )
+		  if ( *p == '\r' || *p == '\n' )
+		    putc(*p, out);
+	  }
+	else
+	  {	for ( ap = breaks+1; ap < bp; ap += 2 )
+		  {	p = *ap;
+			while ( isidchar(*p) )
+			  putc(*p, out), p++;
+			if ( ap < bp - 1 )
+			  fputs(", ", out);
+		  }
+		fputs(")  ", out);
+		/* Put out the argument declarations */
+		for ( ap = breaks+2; ap <= bp; ap += 2 )
+		  (*ap)[-1] = ';';
+		if ( vararg != 0 )
+		  {	*vararg = 0;
+			fputs(breaks[0], out);		/* any prior args */
+			fputs("va_dcl", out);		/* the final arg */
+			fputs(bp[0], out);
+		  }
+		else
+		  fputs(breaks[0], out);
+	  }
+	free((char *)breaks);
+	return 0;
+}

src/jpeg/change.log

@@ -0,0 +1,217 @@
+CHANGE LOG for Independent JPEG Group's JPEG software
+
+
+Version 6b  27-Mar-1998
+-----------------------
+
+jpegtran has new features for lossless image transformations (rotation
+and flipping) as well as "lossless" reduction to grayscale.
+
+jpegtran now copies comments by default; it has a -copy switch to enable
+copying all APPn blocks as well, or to suppress comments.  (Formerly it
+always suppressed comments and APPn blocks.)  jpegtran now also preserves
+JFIF version and resolution information.
+
+New decompressor library feature: COM and APPn markers found in the input
+file can be saved in memory for later use by the application.  (Before,
+you had to code this up yourself with a custom marker processor.)
+
+There is an unused field "void * client_data" now in compress and decompress
+parameter structs; this may be useful in some applications.
+
+JFIF version number information is now saved by the decoder and accepted by
+the encoder.  jpegtran uses this to copy the source file's version number,
+to ensure "jpegtran -copy all" won't create bogus files that contain JFXX
+extensions but claim to be version 1.01.  Applications that generate their
+own JFXX extension markers also (finally) have a supported way to cause the
+encoder to emit JFIF version number 1.02.
+
+djpeg's trace mode reports JFIF 1.02 thumbnail images as such, rather
+than as unknown APP0 markers.
+
+In -verbose mode, djpeg and rdjpgcom will try to print the contents of
+APP12 markers as text.  Some digital cameras store useful text information
+in APP12 markers.
+
+Handling of truncated data streams is more robust: blocks beyond the one in
+which the error occurs will be output as uniform gray, or left unchanged
+if decoding a progressive JPEG.  The appearance no longer depends on the
+Huffman tables being used.
+
+Huffman tables are checked for validity much more carefully than before.
+
+To avoid the Unisys LZW patent, djpeg's GIF output capability has been
+changed to produce "uncompressed GIFs", and cjpeg's GIF input capability
+has been removed altogether.  We're not happy about it either, but there
+seems to be no good alternative.
+
+The configure script now supports building libjpeg as a shared library
+on many flavors of Unix (all the ones that GNU libtool knows how to
+build shared libraries for).  Use "./configure --enable-shared" to
+try this out.
+
+New jconfig file and makefiles for Microsoft Visual C++ and Developer Studio.
+Also, a jconfig file and a build script for Metrowerks CodeWarrior
+on Apple Macintosh.  makefile.dj has been updated for DJGPP v2, and there
+are miscellaneous other minor improvements in the makefiles.
+
+jmemmac.c now knows how to create temporary files following Mac System 7
+conventions.
+
+djpeg's -map switch is now able to read raw-format PPM files reliably.
+
+cjpeg -progressive -restart no longer generates any unnecessary DRI markers.
+
+Multiple calls to jpeg_simple_progression for a single JPEG object
+no longer leak memory.
+
+
+Version 6a  7-Feb-96
+--------------------
+
+Library initialization sequence modified to detect version mismatches
+and struct field packing mismatches between library and calling application.
+This change requires applications to be recompiled, but does not require
+any application source code change.
+
+All routine declarations changed to the style "GLOBAL(type) name ...",
+that is, GLOBAL, LOCAL, METHODDEF, EXTERN are now macros taking the
+routine's return type as an argument.  This makes it possible to add
+Microsoft-style linkage keywords to all the routines by changing just
+these macros.  Note that any application code that was using these macros
+will have to be changed.
+
+DCT coefficient quantization tables are now stored in normal array order
+rather than zigzag order.  Application code that calls jpeg_add_quant_table,
+or otherwise manipulates quantization tables directly, will need to be
+changed.  If you need to make such code work with either older or newer
+versions of the library, a test like "#if JPEG_LIB_VERSION >= 61" is
+recommended.
+
+djpeg's trace capability now dumps DQT tables in natural order, not zigzag
+order.  This allows the trace output to be made into a "-qtables" file
+more easily.
+
+New system-dependent memory manager module for use on Apple Macintosh.
+
+Fix bug in cjpeg's -smooth option: last one or two scanlines would be
+duplicates of the prior line unless the image height mod 16 was 1 or 2.
+
+Repair minor problems in VMS, BCC, MC6 makefiles.
+
+New configure script based on latest GNU Autoconf.
+
+Correct the list of include files needed by MetroWerks C for ccommand().
+
+Numerous small documentation updates.
+
+
+Version 6  2-Aug-95
+-------------------
+
+Progressive JPEG support: library can read and write full progressive JPEG
+files.  A "buffered image" mode supports incremental decoding for on-the-fly
+display of progressive images.  Simply recompiling an existing IJG-v5-based
+decoder with v6 should allow it to read progressive files, though of course
+without any special progressive display.
+
+New "jpegtran" application performs lossless transcoding between different
+JPEG formats; primarily, it can be used to convert baseline to progressive
+JPEG and vice versa.  In support of jpegtran, the library now allows lossless
+reading and writing of JPEG files as DCT coefficient arrays.  This ability
+may be of use in other applications.
+
+Notes for programmers:
+* We changed jpeg_start_decompress() to be able to suspend; this makes all
+decoding modes available to suspending-input applications.  However,
+existing applications that use suspending input will need to be changed
+to check the return value from jpeg_start_decompress().  You don't need to
+do anything if you don't use a suspending data source.
+* We changed the interface to the virtual array routines: access_virt_array
+routines now take a count of the number of rows to access this time.  The
+last parameter to request_virt_array routines is now interpreted as the
+maximum number of rows that may be accessed at once, but not necessarily
+the height of every access.
+
+
+Version 5b  15-Mar-95
+---------------------
+
+Correct bugs with grayscale images having v_samp_factor > 1.
+
+jpeg_write_raw_data() now supports output suspension.
+
+Correct bugs in "configure" script for case of compiling in
+a directory other than the one containing the source files.
+
+Repair bug in jquant1.c: sometimes didn't use as many colors as it could.
+
+Borland C makefile and jconfig file work under either MS-DOS or OS/2.
+
+Miscellaneous improvements to documentation.
+
+
+Version 5a  7-Dec-94
+--------------------
+
+Changed color conversion roundoff behavior so that grayscale values are
+represented exactly.  (This causes test image files to change.)
+
+Make ordered dither use 16x16 instead of 4x4 pattern for a small quality
+improvement.
+
+New configure script based on latest GNU Autoconf.
+Fix configure script to handle CFLAGS correctly.
+Rename *.auto files to *.cfg, so that configure script still works if
+file names have been truncated for DOS.
+
+Fix bug in rdbmp.c: didn't allow for extra data between header and image.
+
+Modify rdppm.c/wrppm.c to handle 2-byte raw PPM/PGM formats for 12-bit data.
+
+Fix several bugs in rdrle.c.
+
+NEED_SHORT_EXTERNAL_NAMES option was broken.
+
+Revise jerror.h/jerror.c for more flexibility in message table.
+
+Repair oversight in jmemname.c NO_MKTEMP case: file could be there
+but unreadable.
+
+
+Version 5  24-Sep-94
+--------------------
+
+Version 5 represents a nearly complete redesign and rewrite of the IJG
+software.  Major user-visible changes include:
+  * Automatic configuration simplifies installation for most Unix systems.
+  * A range of speed vs. image quality tradeoffs are supported.
+    This includes resizing of an image during decompression: scaling down
+    by a factor of 1/2, 1/4, or 1/8 is handled very efficiently.
+  * New programs rdjpgcom and wrjpgcom allow insertion and extraction
+    of text comments in a JPEG file.
+
+The application programmer's interface to the library has changed completely.
+Notable improvements include:
+  * We have eliminated the use of callback routines for handling the
+    uncompressed image data.  The application now sees the library as a
+    set of routines that it calls to read or write image data on a
+    scanline-by-scanline basis.
+  * The application image data is represented in a conventional interleaved-
+    pixel format, rather than as a separate array for each color channel.
+    This can save a copying step in many programs.
+  * The handling of compressed data has been cleaned up: the application can
+    supply routines to source or sink the compressed data.  It is possible to
+    suspend processing on source/sink buffer overrun, although this is not
+    supported in all operating modes.
+  * All static state has been eliminated from the library, so that multiple
+    instances of compression or decompression can be active concurrently.
+  * JPEG abbreviated datastream formats are supported, ie, quantization and
+    Huffman tables can be stored separately from the image data.
+  * And not only that, but the documentation of the library has improved
+    considerably!
+
+
+The last widely used release before the version 5 rewrite was version 4A of
+18-Feb-93.  Change logs before that point have been discarded, since they
+are not of much interest after the rewrite.

src/jpeg/jcapimin.c

@@ -0,0 +1,280 @@
+/*
+ * jcapimin.c
+ *
+ * Copyright (C) 1994-1998, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains application interface code for the compression half
+ * of the JPEG library.  These are the "minimum" API routines that may be
+ * needed in either the normal full-compression case or the transcoding-only
+ * case.
+ *
+ * Most of the routines intended to be called directly by an application
+ * are in this file or in jcapistd.c.  But also see jcparam.c for
+ * parameter-setup helper routines, jcomapi.c for routines shared by
+ * compression and decompression, and jctrans.c for the transcoding case.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * Initialization of a JPEG compression object.
+ * The error manager must already be set up (in case memory manager fails).
+ */
+
+GLOBAL(void)
+jpeg_CreateCompress (j_compress_ptr cinfo, int version, size_t structsize)
+{
+  int i;
+
+  /* Guard against version mismatches between library and caller. */
+  cinfo->mem = NULL;		/* so jpeg_destroy knows mem mgr not called */
+  if (version != JPEG_LIB_VERSION)
+    ERREXIT2(cinfo, JERR_BAD_LIB_VERSION, JPEG_LIB_VERSION, version);
+  if (structsize != SIZEOF(struct jpeg_compress_struct))
+    ERREXIT2(cinfo, JERR_BAD_STRUCT_SIZE, 
+	     (int) SIZEOF(struct jpeg_compress_struct), (int) structsize);
+
+  /* For debugging purposes, we zero the whole master structure.
+   * But the application has already set the err pointer, and may have set
+   * client_data, so we have to save and restore those fields.
+   * Note: if application hasn't set client_data, tools like Purify may
+   * complain here.
+   */
+  {
+    struct jpeg_error_mgr * err = cinfo->err;
+    void * client_data = cinfo->client_data; /* ignore Purify complaint here */
+    MEMZERO(cinfo, SIZEOF(struct jpeg_compress_struct));
+    cinfo->err = err;
+    cinfo->client_data = client_data;
+  }
+  cinfo->is_decompressor = FALSE;
+
+  /* Initialize a memory manager instance for this object */
+  jinit_memory_mgr((j_common_ptr) cinfo);
+
+  /* Zero out pointers to permanent structures. */
+  cinfo->progress = NULL;
+  cinfo->dest = NULL;
+
+  cinfo->comp_info = NULL;
+
+  for (i = 0; i < NUM_QUANT_TBLS; i++)
+    cinfo->quant_tbl_ptrs[i] = NULL;
+
+  for (i = 0; i < NUM_HUFF_TBLS; i++) {
+    cinfo->dc_huff_tbl_ptrs[i] = NULL;
+    cinfo->ac_huff_tbl_ptrs[i] = NULL;
+  }
+
+  cinfo->script_space = NULL;
+
+  cinfo->input_gamma = 1.0;	/* in case application forgets */
+
+  /* OK, I'm ready */
+  cinfo->global_state = CSTATE_START;
+}
+
+
+/*
+ * Destruction of a JPEG compression object
+ */
+
+GLOBAL(void)
+jpeg_destroy_compress (j_compress_ptr cinfo)
+{
+  jpeg_destroy((j_common_ptr) cinfo); /* use common routine */
+}
+
+
+/*
+ * Abort processing of a JPEG compression operation,
+ * but don't destroy the object itself.
+ */
+
+GLOBAL(void)
+jpeg_abort_compress (j_compress_ptr cinfo)
+{
+  jpeg_abort((j_common_ptr) cinfo); /* use common routine */
+}
+
+
+/*
+ * Forcibly suppress or un-suppress all quantization and Huffman tables.
+ * Marks all currently defined tables as already written (if suppress)
+ * or not written (if !suppress).  This will control whether they get emitted
+ * by a subsequent jpeg_start_compress call.
+ *
+ * This routine is exported for use by applications that want to produce
+ * abbreviated JPEG datastreams.  It logically belongs in jcparam.c, but
+ * since it is called by jpeg_start_compress, we put it here --- otherwise
+ * jcparam.o would be linked whether the application used it or not.
+ */
+
+GLOBAL(void)
+jpeg_suppress_tables (j_compress_ptr cinfo, boolean suppress)
+{
+  int i;
+  JQUANT_TBL * qtbl;
+  JHUFF_TBL * htbl;
+
+  for (i = 0; i < NUM_QUANT_TBLS; i++) {
+    if ((qtbl = cinfo->quant_tbl_ptrs[i]) != NULL)
+      qtbl->sent_table = suppress;
+  }
+
+  for (i = 0; i < NUM_HUFF_TBLS; i++) {
+    if ((htbl = cinfo->dc_huff_tbl_ptrs[i]) != NULL)
+      htbl->sent_table = suppress;
+    if ((htbl = cinfo->ac_huff_tbl_ptrs[i]) != NULL)
+      htbl->sent_table = suppress;
+  }
+}
+
+
+/*
+ * Finish JPEG compression.
+ *
+ * If a multipass operating mode was selected, this may do a great deal of
+ * work including most of the actual output.
+ */
+
+GLOBAL(void)
+jpeg_finish_compress (j_compress_ptr cinfo)
+{
+  JDIMENSION iMCU_row;
+
+  if (cinfo->global_state == CSTATE_SCANNING ||
+      cinfo->global_state == CSTATE_RAW_OK) {
+    /* Terminate first pass */
+    if (cinfo->next_scanline < cinfo->image_height)
+      ERREXIT(cinfo, JERR_TOO_LITTLE_DATA);
+    (*cinfo->master->finish_pass) (cinfo);
+  } else if (cinfo->global_state != CSTATE_WRCOEFS)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  /* Perform any remaining passes */
+  while (! cinfo->master->is_last_pass) {
+    (*cinfo->master->prepare_for_pass) (cinfo);
+    for (iMCU_row = 0; iMCU_row < cinfo->total_iMCU_rows; iMCU_row++) {
+      if (cinfo->progress != NULL) {
+	cinfo->progress->pass_counter = (long) iMCU_row;
+	cinfo->progress->pass_limit = (long) cinfo->total_iMCU_rows;
+	(*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+      }
+      /* We bypass the main controller and invoke coef controller directly;
+       * all work is being done from the coefficient buffer.
+       */
+      if (! (*cinfo->coef->compress_data) (cinfo, (JSAMPIMAGE) NULL))
+	ERREXIT(cinfo, JERR_CANT_SUSPEND);
+    }
+    (*cinfo->master->finish_pass) (cinfo);
+  }
+  /* Write EOI, do final cleanup */
+  (*cinfo->marker->write_file_trailer) (cinfo);
+  (*cinfo->dest->term_destination) (cinfo);
+  /* We can use jpeg_abort to release memory and reset global_state */
+  jpeg_abort((j_common_ptr) cinfo);
+}
+
+
+/*
+ * Write a special marker.
+ * This is only recommended for writing COM or APPn markers.
+ * Must be called after jpeg_start_compress() and before
+ * first call to jpeg_write_scanlines() or jpeg_write_raw_data().
+ */
+
+GLOBAL(void)
+jpeg_write_marker (j_compress_ptr cinfo, int marker,
+		   const JOCTET *dataptr, unsigned int datalen)
+{
+  JMETHOD(void, write_marker_byte, (j_compress_ptr info, int val));
+
+  if (cinfo->next_scanline != 0 ||
+      (cinfo->global_state != CSTATE_SCANNING &&
+       cinfo->global_state != CSTATE_RAW_OK &&
+       cinfo->global_state != CSTATE_WRCOEFS))
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  (*cinfo->marker->write_marker_header) (cinfo, marker, datalen);
+  write_marker_byte = cinfo->marker->write_marker_byte;	/* copy for speed */
+  while (datalen--) {
+    (*write_marker_byte) (cinfo, *dataptr);
+    dataptr++;
+  }
+}
+
+/* Same, but piecemeal. */
+
+GLOBAL(void)
+jpeg_write_m_header (j_compress_ptr cinfo, int marker, unsigned int datalen)
+{
+  if (cinfo->next_scanline != 0 ||
+      (cinfo->global_state != CSTATE_SCANNING &&
+       cinfo->global_state != CSTATE_RAW_OK &&
+       cinfo->global_state != CSTATE_WRCOEFS))
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  (*cinfo->marker->write_marker_header) (cinfo, marker, datalen);
+}
+
+GLOBAL(void)
+jpeg_write_m_byte (j_compress_ptr cinfo, int val)
+{
+  (*cinfo->marker->write_marker_byte) (cinfo, val);
+}
+
+
+/*
+ * Alternate compression function: just write an abbreviated table file.
+ * Before calling this, all parameters and a data destination must be set up.
+ *
+ * To produce a pair of files containing abbreviated tables and abbreviated
+ * image data, one would proceed as follows:
+ *
+ *		initialize JPEG object
+ *		set JPEG parameters
+ *		set destination to table file
+ *		jpeg_write_tables(cinfo);
+ *		set destination to image file
+ *		jpeg_start_compress(cinfo, FALSE);
+ *		write data...
+ *		jpeg_finish_compress(cinfo);
+ *
+ * jpeg_write_tables has the side effect of marking all tables written
+ * (same as jpeg_suppress_tables(..., TRUE)).  Thus a subsequent start_compress
+ * will not re-emit the tables unless it is passed write_all_tables=TRUE.
+ */
+
+GLOBAL(void)
+jpeg_write_tables (j_compress_ptr cinfo)
+{
+  if (cinfo->global_state != CSTATE_START)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  /* (Re)initialize error mgr and destination modules */
+  (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo);
+  (*cinfo->dest->init_destination) (cinfo);
+  /* Initialize the marker writer ... bit of a crock to do it here. */
+  jinit_marker_writer(cinfo);
+  /* Write them tables! */
+  (*cinfo->marker->write_tables_only) (cinfo);
+  /* And clean up. */
+  (*cinfo->dest->term_destination) (cinfo);
+  /*
+   * In library releases up through v6a, we called jpeg_abort() here to free
+   * any working memory allocated by the destination manager and marker
+   * writer.  Some applications had a problem with that: they allocated space
+   * of their own from the library memory manager, and didn't want it to go
+   * away during write_tables.  So now we do nothing.  This will cause a
+   * memory leak if an app calls write_tables repeatedly without doing a full
+   * compression cycle or otherwise resetting the JPEG object.  However, that
+   * seems less bad than unexpectedly freeing memory in the normal case.
+   * An app that prefers the old behavior can call jpeg_abort for itself after
+   * each call to jpeg_write_tables().
+   */
+}

src/jpeg/jcapistd.c

@@ -0,0 +1,161 @@
+/*
+ * jcapistd.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains application interface code for the compression half
+ * of the JPEG library.  These are the "standard" API routines that are
+ * used in the normal full-compression case.  They are not used by a
+ * transcoding-only application.  Note that if an application links in
+ * jpeg_start_compress, it will end up linking in the entire compressor.
+ * We thus must separate this file from jcapimin.c to avoid linking the
+ * whole compression library into a transcoder.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * Compression initialization.
+ * Before calling this, all parameters and a data destination must be set up.
+ *
+ * We require a write_all_tables parameter as a failsafe check when writing
+ * multiple datastreams from the same compression object.  Since prior runs
+ * will have left all the tables marked sent_table=TRUE, a subsequent run
+ * would emit an abbreviated stream (no tables) by default.  This may be what
+ * is wanted, but for safety's sake it should not be the default behavior:
+ * programmers should have to make a deliberate choice to emit abbreviated
+ * images.  Therefore the documentation and examples should encourage people
+ * to pass write_all_tables=TRUE; then it will take active thought to do the
+ * wrong thing.
+ */
+
+GLOBAL(void)
+jpeg_start_compress (j_compress_ptr cinfo, boolean write_all_tables)
+{
+  if (cinfo->global_state != CSTATE_START)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  if (write_all_tables)
+    jpeg_suppress_tables(cinfo, FALSE);	/* mark all tables to be written */
+
+  /* (Re)initialize error mgr and destination modules */
+  (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo);
+  (*cinfo->dest->init_destination) (cinfo);
+  /* Perform master selection of active modules */
+  jinit_compress_master(cinfo);
+  /* Set up for the first pass */
+  (*cinfo->master->prepare_for_pass) (cinfo);
+  /* Ready for application to drive first pass through jpeg_write_scanlines
+   * or jpeg_write_raw_data.
+   */
+  cinfo->next_scanline = 0;
+  cinfo->global_state = (cinfo->raw_data_in ? CSTATE_RAW_OK : CSTATE_SCANNING);
+}
+
+
+/*
+ * Write some scanlines of data to the JPEG compressor.
+ *
+ * The return value will be the number of lines actually written.
+ * This should be less than the supplied num_lines only in case that
+ * the data destination module has requested suspension of the compressor,
+ * or if more than image_height scanlines are passed in.
+ *
+ * Note: we warn about excess calls to jpeg_write_scanlines() since
+ * this likely signals an application programmer error.  However,
+ * excess scanlines passed in the last valid call are *silently* ignored,
+ * so that the application need not adjust num_lines for end-of-image
+ * when using a multiple-scanline buffer.
+ */
+
+GLOBAL(JDIMENSION)
+jpeg_write_scanlines (j_compress_ptr cinfo, JSAMPARRAY scanlines,
+		      JDIMENSION num_lines)
+{
+  JDIMENSION row_ctr, rows_left;
+
+  if (cinfo->global_state != CSTATE_SCANNING)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  if (cinfo->next_scanline >= cinfo->image_height)
+    WARNMS(cinfo, JWRN_TOO_MUCH_DATA);
+
+  /* Call progress monitor hook if present */
+  if (cinfo->progress != NULL) {
+    cinfo->progress->pass_counter = (long) cinfo->next_scanline;
+    cinfo->progress->pass_limit = (long) cinfo->image_height;
+    (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+  }
+
+  /* Give master control module another chance if this is first call to
+   * jpeg_write_scanlines.  This lets output of the frame/scan headers be
+   * delayed so that application can write COM, etc, markers between
+   * jpeg_start_compress and jpeg_write_scanlines.
+   */
+  if (cinfo->master->call_pass_startup)
+    (*cinfo->master->pass_startup) (cinfo);
+
+  /* Ignore any extra scanlines at bottom of image. */
+  rows_left = cinfo->image_height - cinfo->next_scanline;
+  if (num_lines > rows_left)
+    num_lines = rows_left;
+
+  row_ctr = 0;
+  (*cinfo->main->process_data) (cinfo, scanlines, &row_ctr, num_lines);
+  cinfo->next_scanline += row_ctr;
+  return row_ctr;
+}
+
+
+/*
+ * Alternate entry point to write raw data.
+ * Processes exactly one iMCU row per call, unless suspended.
+ */
+
+GLOBAL(JDIMENSION)
+jpeg_write_raw_data (j_compress_ptr cinfo, JSAMPIMAGE data,
+		     JDIMENSION num_lines)
+{
+  JDIMENSION lines_per_iMCU_row;
+
+  if (cinfo->global_state != CSTATE_RAW_OK)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  if (cinfo->next_scanline >= cinfo->image_height) {
+    WARNMS(cinfo, JWRN_TOO_MUCH_DATA);
+    return 0;
+  }
+
+  /* Call progress monitor hook if present */
+  if (cinfo->progress != NULL) {
+    cinfo->progress->pass_counter = (long) cinfo->next_scanline;
+    cinfo->progress->pass_limit = (long) cinfo->image_height;
+    (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+  }
+
+  /* Give master control module another chance if this is first call to
+   * jpeg_write_raw_data.  This lets output of the frame/scan headers be
+   * delayed so that application can write COM, etc, markers between
+   * jpeg_start_compress and jpeg_write_raw_data.
+   */
+  if (cinfo->master->call_pass_startup)
+    (*cinfo->master->pass_startup) (cinfo);
+
+  /* Verify that at least one iMCU row has been passed. */
+  lines_per_iMCU_row = cinfo->max_v_samp_factor * DCTSIZE;
+  if (num_lines < lines_per_iMCU_row)
+    ERREXIT(cinfo, JERR_BUFFER_SIZE);
+
+  /* Directly compress the row. */
+  if (! (*cinfo->coef->compress_data) (cinfo, data)) {
+    /* If compressor did not consume the whole row, suspend processing. */
+    return 0;
+  }
+
+  /* OK, we processed one iMCU row. */
+  cinfo->next_scanline += lines_per_iMCU_row;
+  return lines_per_iMCU_row;
+}

src/jpeg/jccoefct.c

@@ -0,0 +1,449 @@
+/*
+ * jccoefct.c
+ *
+ * Copyright (C) 1994-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the coefficient buffer controller for compression.
+ * This controller is the top level of the JPEG compressor proper.
+ * The coefficient buffer lies between forward-DCT and entropy encoding steps.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* We use a full-image coefficient buffer when doing Huffman optimization,
+ * and also for writing multiple-scan JPEG files.  In all cases, the DCT
+ * step is run during the first pass, and subsequent passes need only read
+ * the buffered coefficients.
+ */
+#ifdef ENTROPY_OPT_SUPPORTED
+#define FULL_COEF_BUFFER_SUPPORTED
+#else
+#ifdef C_MULTISCAN_FILES_SUPPORTED
+#define FULL_COEF_BUFFER_SUPPORTED
+#endif
+#endif
+
+
+/* Private buffer controller object */
+
+typedef struct {
+  struct jpeg_c_coef_controller pub; /* public fields */
+
+  JDIMENSION iMCU_row_num;	/* iMCU row # within image */
+  JDIMENSION mcu_ctr;		/* counts MCUs processed in current row */
+  int MCU_vert_offset;		/* counts MCU rows within iMCU row */
+  int MCU_rows_per_iMCU_row;	/* number of such rows needed */
+
+  /* For single-pass compression, it's sufficient to buffer just one MCU
+   * (although this may prove a bit slow in practice).  We allocate a
+   * workspace of C_MAX_BLOCKS_IN_MCU coefficient blocks, and reuse it for each
+   * MCU constructed and sent.  (On 80x86, the workspace is FAR even though
+   * it's not really very big; this is to keep the module interfaces unchanged
+   * when a large coefficient buffer is necessary.)
+   * In multi-pass modes, this array points to the current MCU's blocks
+   * within the virtual arrays.
+   */
+  JBLOCKROW MCU_buffer[C_MAX_BLOCKS_IN_MCU];
+
+  /* In multi-pass modes, we need a virtual block array for each component. */
+  jvirt_barray_ptr whole_image[MAX_COMPONENTS];
+} my_coef_controller;
+
+typedef my_coef_controller * my_coef_ptr;
+
+
+/* Forward declarations */
+METHODDEF(boolean) compress_data
+    JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
+#ifdef FULL_COEF_BUFFER_SUPPORTED
+METHODDEF(boolean) compress_first_pass
+    JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
+METHODDEF(boolean) compress_output
+    JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
+#endif
+
+
+LOCAL(void)
+start_iMCU_row (j_compress_ptr cinfo)
+/* Reset within-iMCU-row counters for a new row */
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+
+  /* In an interleaved scan, an MCU row is the same as an iMCU row.
+   * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
+   * But at the bottom of the image, process only what's left.
+   */
+  if (cinfo->comps_in_scan > 1) {
+    coef->MCU_rows_per_iMCU_row = 1;
+  } else {
+    if (coef->iMCU_row_num < (cinfo->total_iMCU_rows-1))
+      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
+    else
+      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
+  }
+
+  coef->mcu_ctr = 0;
+  coef->MCU_vert_offset = 0;
+}
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF(void)
+start_pass_coef (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+
+  coef->iMCU_row_num = 0;
+  start_iMCU_row(cinfo);
+
+  switch (pass_mode) {
+  case JBUF_PASS_THRU:
+    if (coef->whole_image[0] != NULL)
+      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    coef->pub.compress_data = compress_data;
+    break;
+#ifdef FULL_COEF_BUFFER_SUPPORTED
+  case JBUF_SAVE_AND_PASS:
+    if (coef->whole_image[0] == NULL)
+      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    coef->pub.compress_data = compress_first_pass;
+    break;
+  case JBUF_CRANK_DEST:
+    if (coef->whole_image[0] == NULL)
+      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    coef->pub.compress_data = compress_output;
+    break;
+#endif
+  default:
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    break;
+  }
+}
+
+
+/*
+ * Process some data in the single-pass case.
+ * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
+ * per call, ie, v_samp_factor block rows for each component in the image.
+ * Returns TRUE if the iMCU row is completed, FALSE if suspended.
+ *
+ * NB: input_buf contains a plane for each component in image,
+ * which we index according to the component's SOF position.
+ */
+
+METHODDEF(boolean)
+compress_data (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+  JDIMENSION MCU_col_num;	/* index of current MCU within row */
+  JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
+  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+  int blkn, bi, ci, yindex, yoffset, blockcnt;
+  JDIMENSION ypos, xpos;
+  jpeg_component_info *compptr;
+
+  /* Loop to write as much as one whole iMCU row */
+  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
+       yoffset++) {
+    for (MCU_col_num = coef->mcu_ctr; MCU_col_num <= last_MCU_col;
+	 MCU_col_num++) {
+      /* Determine where data comes from in input_buf and do the DCT thing.
+       * Each call on forward_DCT processes a horizontal row of DCT blocks
+       * as wide as an MCU; we rely on having allocated the MCU_buffer[] blocks
+       * sequentially.  Dummy blocks at the right or bottom edge are filled in
+       * specially.  The data in them does not matter for image reconstruction,
+       * so we fill them with values that will encode to the smallest amount of
+       * data, viz: all zeroes in the AC entries, DC entries equal to previous
+       * block's DC value.  (Thanks to Thomas Kinsman for this idea.)
+       */
+      blkn = 0;
+      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+	compptr = cinfo->cur_comp_info[ci];
+	blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
+						: compptr->last_col_width;
+	xpos = MCU_col_num * compptr->MCU_sample_width;
+	ypos = yoffset * DCTSIZE; /* ypos == (yoffset+yindex) * DCTSIZE */
+	for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+	  if (coef->iMCU_row_num < last_iMCU_row ||
+	      yoffset+yindex < compptr->last_row_height) {
+	    (*cinfo->fdct->forward_DCT) (cinfo, compptr,
+					 input_buf[compptr->component_index],
+					 coef->MCU_buffer[blkn],
+					 ypos, xpos, (JDIMENSION) blockcnt);
+	    if (blockcnt < compptr->MCU_width) {
+	      /* Create some dummy blocks at the right edge of the image. */
+	      jzero_far((void FAR *) coef->MCU_buffer[blkn + blockcnt],
+			(compptr->MCU_width - blockcnt) * SIZEOF(JBLOCK));
+	      for (bi = blockcnt; bi < compptr->MCU_width; bi++) {
+		coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn+bi-1][0][0];
+	      }
+	    }
+	  } else {
+	    /* Create a row of dummy blocks at the bottom of the image. */
+	    jzero_far((void FAR *) coef->MCU_buffer[blkn],
+		      compptr->MCU_width * SIZEOF(JBLOCK));
+	    for (bi = 0; bi < compptr->MCU_width; bi++) {
+	      coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn-1][0][0];
+	    }
+	  }
+	  blkn += compptr->MCU_width;
+	  ypos += DCTSIZE;
+	}
+      }
+      /* Try to write the MCU.  In event of a suspension failure, we will
+       * re-DCT the MCU on restart (a bit inefficient, could be fixed...)
+       */
+      if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
+	/* Suspension forced; update state counters and exit */
+	coef->MCU_vert_offset = yoffset;
+	coef->mcu_ctr = MCU_col_num;
+	return FALSE;
+      }
+    }
+    /* Completed an MCU row, but perhaps not an iMCU row */
+    coef->mcu_ctr = 0;
+  }
+  /* Completed the iMCU row, advance counters for next one */
+  coef->iMCU_row_num++;
+  start_iMCU_row(cinfo);
+  return TRUE;
+}
+
+
+#ifdef FULL_COEF_BUFFER_SUPPORTED
+
+/*
+ * Process some data in the first pass of a multi-pass case.
+ * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
+ * per call, ie, v_samp_factor block rows for each component in the image.
+ * This amount of data is read from the source buffer, DCT'd and quantized,
+ * and saved into the virtual arrays.  We also generate suitable dummy blocks
+ * as needed at the right and lower edges.  (The dummy blocks are constructed
+ * in the virtual arrays, which have been padded appropriately.)  This makes
+ * it possible for subsequent passes not to worry about real vs. dummy blocks.
+ *
+ * We must also emit the data to the entropy encoder.  This is conveniently
+ * done by calling compress_output() after we've loaded the current strip
+ * of the virtual arrays.
+ *
+ * NB: input_buf contains a plane for each component in image.  All
+ * components are DCT'd and loaded into the virtual arrays in this pass.
+ * However, it may be that only a subset of the components are emitted to
+ * the entropy encoder during this first pass; be careful about looking
+ * at the scan-dependent variables (MCU dimensions, etc).
+ */
+
+METHODDEF(boolean)
+compress_first_pass (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+  JDIMENSION blocks_across, MCUs_across, MCUindex;
+  int bi, ci, h_samp_factor, block_row, block_rows, ndummy;
+  JCOEF lastDC;
+  jpeg_component_info *compptr;
+  JBLOCKARRAY buffer;
+  JBLOCKROW thisblockrow, lastblockrow;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Align the virtual buffer for this component. */
+    buffer = (*cinfo->mem->access_virt_barray)
+      ((j_common_ptr) cinfo, coef->whole_image[ci],
+       coef->iMCU_row_num * compptr->v_samp_factor,
+       (JDIMENSION) compptr->v_samp_factor, TRUE);
+    /* Count non-dummy DCT block rows in this iMCU row. */
+    if (coef->iMCU_row_num < last_iMCU_row)
+      block_rows = compptr->v_samp_factor;
+    else {
+      /* NB: can't use last_row_height here, since may not be set! */
+      block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
+      if (block_rows == 0) block_rows = compptr->v_samp_factor;
+    }
+    blocks_across = compptr->width_in_blocks;
+    h_samp_factor = compptr->h_samp_factor;
+    /* Count number of dummy blocks to be added at the right margin. */
+    ndummy = (int) (blocks_across % h_samp_factor);
+    if (ndummy > 0)
+      ndummy = h_samp_factor - ndummy;
+    /* Perform DCT for all non-dummy blocks in this iMCU row.  Each call
+     * on forward_DCT processes a complete horizontal row of DCT blocks.
+     */
+    for (block_row = 0; block_row < block_rows; block_row++) {
+      thisblockrow = buffer[block_row];
+      (*cinfo->fdct->forward_DCT) (cinfo, compptr,
+				   input_buf[ci], thisblockrow,
+				   (JDIMENSION) (block_row * DCTSIZE),
+				   (JDIMENSION) 0, blocks_across);
+      if (ndummy > 0) {
+	/* Create dummy blocks at the right edge of the image. */
+	thisblockrow += blocks_across; /* => first dummy block */
+	jzero_far((void FAR *) thisblockrow, ndummy * SIZEOF(JBLOCK));
+	lastDC = thisblockrow[-1][0];
+	for (bi = 0; bi < ndummy; bi++) {
+	  thisblockrow[bi][0] = lastDC;
+	}
+      }
+    }
+    /* If at end of image, create dummy block rows as needed.
+     * The tricky part here is that within each MCU, we want the DC values
+     * of the dummy blocks to match the last real block's DC value.
+     * This squeezes a few more bytes out of the resulting file...
+     */
+    if (coef->iMCU_row_num == last_iMCU_row) {
+      blocks_across += ndummy;	/* include lower right corner */
+      MCUs_across = blocks_across / h_samp_factor;
+      for (block_row = block_rows; block_row < compptr->v_samp_factor;
+	   block_row++) {
+	thisblockrow = buffer[block_row];
+	lastblockrow = buffer[block_row-1];
+	jzero_far((void FAR *) thisblockrow,
+		  (size_t) (blocks_across * SIZEOF(JBLOCK)));
+	for (MCUindex = 0; MCUindex < MCUs_across; MCUindex++) {
+	  lastDC = lastblockrow[h_samp_factor-1][0];
+	  for (bi = 0; bi < h_samp_factor; bi++) {
+	    thisblockrow[bi][0] = lastDC;
+	  }
+	  thisblockrow += h_samp_factor; /* advance to next MCU in row */
+	  lastblockrow += h_samp_factor;
+	}
+      }
+    }
+  }
+  /* NB: compress_output will increment iMCU_row_num if successful.
+   * A suspension return will result in redoing all the work above next time.
+   */
+
+  /* Emit data to the entropy encoder, sharing code with subsequent passes */
+  return compress_output(cinfo, input_buf);
+}
+
+
+/*
+ * Process some data in subsequent passes of a multi-pass case.
+ * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
+ * per call, ie, v_samp_factor block rows for each component in the scan.
+ * The data is obtained from the virtual arrays and fed to the entropy coder.
+ * Returns TRUE if the iMCU row is completed, FALSE if suspended.
+ *
+ * NB: input_buf is ignored; it is likely to be a NULL pointer.
+ */
+
+METHODDEF(boolean)
+compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+  JDIMENSION MCU_col_num;	/* index of current MCU within row */
+  int blkn, ci, xindex, yindex, yoffset;
+  JDIMENSION start_col;
+  JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
+  JBLOCKROW buffer_ptr;
+  jpeg_component_info *compptr;
+
+  /* Align the virtual buffers for the components used in this scan.
+   * NB: during first pass, this is safe only because the buffers will
+   * already be aligned properly, so jmemmgr.c won't need to do any I/O.
+   */
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    buffer[ci] = (*cinfo->mem->access_virt_barray)
+      ((j_common_ptr) cinfo, coef->whole_image[compptr->component_index],
+       coef->iMCU_row_num * compptr->v_samp_factor,
+       (JDIMENSION) compptr->v_samp_factor, FALSE);
+  }
+
+  /* Loop to process one whole iMCU row */
+  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
+       yoffset++) {
+    for (MCU_col_num = coef->mcu_ctr; MCU_col_num < cinfo->MCUs_per_row;
+	 MCU_col_num++) {
+      /* Construct list of pointers to DCT blocks belonging to this MCU */
+      blkn = 0;			/* index of current DCT block within MCU */
+      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+	compptr = cinfo->cur_comp_info[ci];
+	start_col = MCU_col_num * compptr->MCU_width;
+	for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+	  buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
+	  for (xindex = 0; xindex < compptr->MCU_width; xindex++) {
+	    coef->MCU_buffer[blkn++] = buffer_ptr++;
+	  }
+	}
+      }
+      /* Try to write the MCU. */
+      if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
+	/* Suspension forced; update state counters and exit */
+	coef->MCU_vert_offset = yoffset;
+	coef->mcu_ctr = MCU_col_num;
+	return FALSE;
+      }
+    }
+    /* Completed an MCU row, but perhaps not an iMCU row */
+    coef->mcu_ctr = 0;
+  }
+  /* Completed the iMCU row, advance counters for next one */
+  coef->iMCU_row_num++;
+  start_iMCU_row(cinfo);
+  return TRUE;
+}
+
+#endif /* FULL_COEF_BUFFER_SUPPORTED */
+
+
+/*
+ * Initialize coefficient buffer controller.
+ */
+
+GLOBAL(void)
+jinit_c_coef_controller (j_compress_ptr cinfo, boolean need_full_buffer)
+{
+  my_coef_ptr coef;
+
+  coef = (my_coef_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_coef_controller));
+  cinfo->coef = (struct jpeg_c_coef_controller *) coef;
+  coef->pub.start_pass = start_pass_coef;
+
+  /* Create the coefficient buffer. */
+  if (need_full_buffer) {
+#ifdef FULL_COEF_BUFFER_SUPPORTED
+    /* Allocate a full-image virtual array for each component, */
+    /* padded to a multiple of samp_factor DCT blocks in each direction. */
+    int ci;
+    jpeg_component_info *compptr;
+
+    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+	 ci++, compptr++) {
+      coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
+	((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
+	 (JDIMENSION) jround_up((long) compptr->width_in_blocks,
+				(long) compptr->h_samp_factor),
+	 (JDIMENSION) jround_up((long) compptr->height_in_blocks,
+				(long) compptr->v_samp_factor),
+	 (JDIMENSION) compptr->v_samp_factor);
+    }
+#else
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+#endif
+  } else {
+    /* We only need a single-MCU buffer. */
+    JBLOCKROW buffer;
+    int i;
+
+    buffer = (JBLOCKROW)
+      (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
+    for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
+      coef->MCU_buffer[i] = buffer + i;
+    }
+    coef->whole_image[0] = NULL; /* flag for no virtual arrays */
+  }
+}

src/jpeg/jccolor.c

@@ -0,0 +1,459 @@
+/*
+ * jccolor.c
+ *
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains input colorspace conversion routines.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Private subobject */
+
+typedef struct {
+  struct jpeg_color_converter pub; /* public fields */
+
+  /* Private state for RGB->YCC conversion */
+  INT32 * rgb_ycc_tab;		/* => table for RGB to YCbCr conversion */
+} my_color_converter;
+
+typedef my_color_converter * my_cconvert_ptr;
+
+
+/**************** RGB -> YCbCr conversion: most common case **************/
+
+/*
+ * YCbCr is defined per CCIR 601-1, except that Cb and Cr are
+ * normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5.
+ * The conversion equations to be implemented are therefore
+ *	Y  =  0.29900 * R + 0.58700 * G + 0.11400 * B
+ *	Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B  + CENTERJSAMPLE
+ *	Cr =  0.50000 * R - 0.41869 * G - 0.08131 * B  + CENTERJSAMPLE
+ * (These numbers are derived from TIFF 6.0 section 21, dated 3-June-92.)
+ * Note: older versions of the IJG code used a zero offset of MAXJSAMPLE/2,
+ * rather than CENTERJSAMPLE, for Cb and Cr.  This gave equal positive and
+ * negative swings for Cb/Cr, but meant that grayscale values (Cb=Cr=0)
+ * were not represented exactly.  Now we sacrifice exact representation of
+ * maximum red and maximum blue in order to get exact grayscales.
+ *
+ * To avoid floating-point arithmetic, we represent the fractional constants
+ * as integers scaled up by 2^16 (about 4 digits precision); we have to divide
+ * the products by 2^16, with appropriate rounding, to get the correct answer.
+ *
+ * For even more speed, we avoid doing any multiplications in the inner loop
+ * by precalculating the constants times R,G,B for all possible values.
+ * For 8-bit JSAMPLEs this is very reasonable (only 256 entries per table);
+ * for 12-bit samples it is still acceptable.  It's not very reasonable for
+ * 16-bit samples, but if you want lossless storage you shouldn't be changing
+ * colorspace anyway.
+ * The CENTERJSAMPLE offsets and the rounding fudge-factor of 0.5 are included
+ * in the tables to save adding them separately in the inner loop.
+ */
+
+#define SCALEBITS	16	/* speediest right-shift on some machines */
+#define CBCR_OFFSET	((INT32) CENTERJSAMPLE << SCALEBITS)
+#define ONE_HALF	((INT32) 1 << (SCALEBITS-1))
+#define FIX(x)		((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
+
+/* We allocate one big table and divide it up into eight parts, instead of
+ * doing eight alloc_small requests.  This lets us use a single table base
+ * address, which can be held in a register in the inner loops on many
+ * machines (more than can hold all eight addresses, anyway).
+ */
+
+#define R_Y_OFF		0			/* offset to R => Y section */
+#define G_Y_OFF		(1*(MAXJSAMPLE+1))	/* offset to G => Y section */
+#define B_Y_OFF		(2*(MAXJSAMPLE+1))	/* etc. */
+#define R_CB_OFF	(3*(MAXJSAMPLE+1))
+#define G_CB_OFF	(4*(MAXJSAMPLE+1))
+#define B_CB_OFF	(5*(MAXJSAMPLE+1))
+#define R_CR_OFF	B_CB_OFF		/* B=>Cb, R=>Cr are the same */
+#define G_CR_OFF	(6*(MAXJSAMPLE+1))
+#define B_CR_OFF	(7*(MAXJSAMPLE+1))
+#define TABLE_SIZE	(8*(MAXJSAMPLE+1))
+
+
+/*
+ * Initialize for RGB->YCC colorspace conversion.
+ */
+
+METHODDEF(void)
+rgb_ycc_start (j_compress_ptr cinfo)
+{
+  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+  INT32 * rgb_ycc_tab;
+  INT32 i;
+
+  /* Allocate and fill in the conversion tables. */
+  cconvert->rgb_ycc_tab = rgb_ycc_tab = (INT32 *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(TABLE_SIZE * SIZEOF(INT32)));
+
+  for (i = 0; i <= MAXJSAMPLE; i++) {
+    rgb_ycc_tab[i+R_Y_OFF] = FIX(0.29900) * i;
+    rgb_ycc_tab[i+G_Y_OFF] = FIX(0.58700) * i;
+    rgb_ycc_tab[i+B_Y_OFF] = FIX(0.11400) * i     + ONE_HALF;
+    rgb_ycc_tab[i+R_CB_OFF] = (-FIX(0.16874)) * i;
+    rgb_ycc_tab[i+G_CB_OFF] = (-FIX(0.33126)) * i;
+    /* We use a rounding fudge-factor of 0.5-epsilon for Cb and Cr.
+     * This ensures that the maximum output will round to MAXJSAMPLE
+     * not MAXJSAMPLE+1, and thus that we don't have to range-limit.
+     */
+    rgb_ycc_tab[i+B_CB_OFF] = FIX(0.50000) * i    + CBCR_OFFSET + ONE_HALF-1;
+/*  B=>Cb and R=>Cr tables are the same
+    rgb_ycc_tab[i+R_CR_OFF] = FIX(0.50000) * i    + CBCR_OFFSET + ONE_HALF-1;
+*/
+    rgb_ycc_tab[i+G_CR_OFF] = (-FIX(0.41869)) * i;
+    rgb_ycc_tab[i+B_CR_OFF] = (-FIX(0.08131)) * i;
+  }
+}
+
+
+/*
+ * Convert some rows of samples to the JPEG colorspace.
+ *
+ * Note that we change from the application's interleaved-pixel format
+ * to our internal noninterleaved, one-plane-per-component format.
+ * The input buffer is therefore three times as wide as the output buffer.
+ *
+ * A starting row offset is provided only for the output buffer.  The caller
+ * can easily adjust the passed input_buf value to accommodate any row
+ * offset required on that side.
+ */
+
+METHODDEF(void)
+rgb_ycc_convert (j_compress_ptr cinfo,
+		 JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+		 JDIMENSION output_row, int num_rows)
+{
+  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+  register int r, g, b;
+  register INT32 * ctab = cconvert->rgb_ycc_tab;
+  register JSAMPROW inptr;
+  register JSAMPROW outptr0, outptr1, outptr2;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->image_width;
+
+  while (--num_rows >= 0) {
+    inptr = *input_buf++;
+    outptr0 = output_buf[0][output_row];
+    outptr1 = output_buf[1][output_row];
+    outptr2 = output_buf[2][output_row];
+    output_row++;
+    for (col = 0; col < num_cols; col++) {
+      r = GETJSAMPLE(inptr[RGB_RED]);
+      g = GETJSAMPLE(inptr[RGB_GREEN]);
+      b = GETJSAMPLE(inptr[RGB_BLUE]);
+      inptr += RGB_PIXELSIZE;
+      /* If the inputs are 0..MAXJSAMPLE, the outputs of these equations
+       * must be too; we do not need an explicit range-limiting operation.
+       * Hence the value being shifted is never negative, and we don't
+       * need the general RIGHT_SHIFT macro.
+       */
+      /* Y */
+      outptr0[col] = (JSAMPLE)
+		((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
+		 >> SCALEBITS);
+      /* Cb */
+      outptr1[col] = (JSAMPLE)
+		((ctab[r+R_CB_OFF] + ctab[g+G_CB_OFF] + ctab[b+B_CB_OFF])
+		 >> SCALEBITS);
+      /* Cr */
+      outptr2[col] = (JSAMPLE)
+		((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF])
+		 >> SCALEBITS);
+    }
+  }
+}
+
+
+/**************** Cases other than RGB -> YCbCr **************/
+
+
+/*
+ * Convert some rows of samples to the JPEG colorspace.
+ * This version handles RGB->grayscale conversion, which is the same
+ * as the RGB->Y portion of RGB->YCbCr.
+ * We assume rgb_ycc_start has been called (we only use the Y tables).
+ */
+
+METHODDEF(void)
+rgb_gray_convert (j_compress_ptr cinfo,
+		  JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+		  JDIMENSION output_row, int num_rows)
+{
+  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+  register int r, g, b;
+  register INT32 * ctab = cconvert->rgb_ycc_tab;
+  register JSAMPROW inptr;
+  register JSAMPROW outptr;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->image_width;
+
+  while (--num_rows >= 0) {
+    inptr = *input_buf++;
+    outptr = output_buf[0][output_row];
+    output_row++;
+    for (col = 0; col < num_cols; col++) {
+      r = GETJSAMPLE(inptr[RGB_RED]);
+      g = GETJSAMPLE(inptr[RGB_GREEN]);
+      b = GETJSAMPLE(inptr[RGB_BLUE]);
+      inptr += RGB_PIXELSIZE;
+      /* Y */
+      outptr[col] = (JSAMPLE)
+		((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
+		 >> SCALEBITS);
+    }
+  }
+}
+
+
+/*
+ * Convert some rows of samples to the JPEG colorspace.
+ * This version handles Adobe-style CMYK->YCCK conversion,
+ * where we convert R=1-C, G=1-M, and B=1-Y to YCbCr using the same
+ * conversion as above, while passing K (black) unchanged.
+ * We assume rgb_ycc_start has been called.
+ */
+
+METHODDEF(void)
+cmyk_ycck_convert (j_compress_ptr cinfo,
+		   JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+		   JDIMENSION output_row, int num_rows)
+{
+  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+  register int r, g, b;
+  register INT32 * ctab = cconvert->rgb_ycc_tab;
+  register JSAMPROW inptr;
+  register JSAMPROW outptr0, outptr1, outptr2, outptr3;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->image_width;
+
+  while (--num_rows >= 0) {
+    inptr = *input_buf++;
+    outptr0 = output_buf[0][output_row];
+    outptr1 = output_buf[1][output_row];
+    outptr2 = output_buf[2][output_row];
+    outptr3 = output_buf[3][output_row];
+    output_row++;
+    for (col = 0; col < num_cols; col++) {
+      r = MAXJSAMPLE - GETJSAMPLE(inptr[0]);
+      g = MAXJSAMPLE - GETJSAMPLE(inptr[1]);
+      b = MAXJSAMPLE - GETJSAMPLE(inptr[2]);
+      /* K passes through as-is */
+      outptr3[col] = inptr[3];	/* don't need GETJSAMPLE here */
+      inptr += 4;
+      /* If the inputs are 0..MAXJSAMPLE, the outputs of these equations
+       * must be too; we do not need an explicit range-limiting operation.
+       * Hence the value being shifted is never negative, and we don't
+       * need the general RIGHT_SHIFT macro.
+       */
+      /* Y */
+      outptr0[col] = (JSAMPLE)
+		((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
+		 >> SCALEBITS);
+      /* Cb */
+      outptr1[col] = (JSAMPLE)
+		((ctab[r+R_CB_OFF] + ctab[g+G_CB_OFF] + ctab[b+B_CB_OFF])
+		 >> SCALEBITS);
+      /* Cr */
+      outptr2[col] = (JSAMPLE)
+		((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF])
+		 >> SCALEBITS);
+    }
+  }
+}
+
+
+/*
+ * Convert some rows of samples to the JPEG colorspace.
+ * This version handles grayscale output with no conversion.
+ * The source can be either plain grayscale or YCbCr (since Y == gray).
+ */
+
+METHODDEF(void)
+grayscale_convert (j_compress_ptr cinfo,
+		   JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+		   JDIMENSION output_row, int num_rows)
+{
+  register JSAMPROW inptr;
+  register JSAMPROW outptr;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->image_width;
+  int instride = cinfo->input_components;
+
+  while (--num_rows >= 0) {
+    inptr = *input_buf++;
+    outptr = output_buf[0][output_row];
+    output_row++;
+    for (col = 0; col < num_cols; col++) {
+      outptr[col] = inptr[0];	/* don't need GETJSAMPLE() here */
+      inptr += instride;
+    }
+  }
+}
+
+
+/*
+ * Convert some rows of samples to the JPEG colorspace.
+ * This version handles multi-component colorspaces without conversion.
+ * We assume input_components == num_components.
+ */
+
+METHODDEF(void)
+null_convert (j_compress_ptr cinfo,
+	      JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+	      JDIMENSION output_row, int num_rows)
+{
+  register JSAMPROW inptr;
+  register JSAMPROW outptr;
+  register JDIMENSION col;
+  register int ci;
+  int nc = cinfo->num_components;
+  JDIMENSION num_cols = cinfo->image_width;
+
+  while (--num_rows >= 0) {
+    /* It seems fastest to make a separate pass for each component. */
+    for (ci = 0; ci < nc; ci++) {
+      inptr = *input_buf;
+      outptr = output_buf[ci][output_row];
+      for (col = 0; col < num_cols; col++) {
+	outptr[col] = inptr[ci]; /* don't need GETJSAMPLE() here */
+	inptr += nc;
+      }
+    }
+    input_buf++;
+    output_row++;
+  }
+}
+
+
+/*
+ * Empty method for start_pass.
+ */
+
+METHODDEF(void)
+null_method (j_compress_ptr cinfo)
+{
+  /* no work needed */
+}
+
+
+/*
+ * Module initialization routine for input colorspace conversion.
+ */
+
+GLOBAL(void)
+jinit_color_converter (j_compress_ptr cinfo)
+{
+  my_cconvert_ptr cconvert;
+
+  cconvert = (my_cconvert_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_color_converter));
+  cinfo->cconvert = (struct jpeg_color_converter *) cconvert;
+  /* set start_pass to null method until we find out differently */
+  cconvert->pub.start_pass = null_method;
+
+  /* Make sure input_components agrees with in_color_space */
+  switch (cinfo->in_color_space) {
+  case JCS_GRAYSCALE:
+    if (cinfo->input_components != 1)
+      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+    break;
+
+  case JCS_RGB:
+#if RGB_PIXELSIZE != 3
+    if (cinfo->input_components != RGB_PIXELSIZE)
+      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+    break;
+#endif /* else share code with YCbCr */
+
+  case JCS_YCbCr:
+    if (cinfo->input_components != 3)
+      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+    break;
+
+  case JCS_CMYK:
+  case JCS_YCCK:
+    if (cinfo->input_components != 4)
+      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+    break;
+
+  default:			/* JCS_UNKNOWN can be anything */
+    if (cinfo->input_components < 1)
+      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+    break;
+  }
+
+  /* Check num_components, set conversion method based on requested space */
+  switch (cinfo->jpeg_color_space) {
+  case JCS_GRAYSCALE:
+    if (cinfo->num_components != 1)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    if (cinfo->in_color_space == JCS_GRAYSCALE)
+      cconvert->pub.color_convert = grayscale_convert;
+    else if (cinfo->in_color_space == JCS_RGB) {
+      cconvert->pub.start_pass = rgb_ycc_start;
+      cconvert->pub.color_convert = rgb_gray_convert;
+    } else if (cinfo->in_color_space == JCS_YCbCr)
+      cconvert->pub.color_convert = grayscale_convert;
+    else
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+
+  case JCS_RGB:
+    if (cinfo->num_components != 3)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    if (cinfo->in_color_space == JCS_RGB && RGB_PIXELSIZE == 3)
+      cconvert->pub.color_convert = null_convert;
+    else
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+
+  case JCS_YCbCr:
+    if (cinfo->num_components != 3)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    if (cinfo->in_color_space == JCS_RGB) {
+      cconvert->pub.start_pass = rgb_ycc_start;
+      cconvert->pub.color_convert = rgb_ycc_convert;
+    } else if (cinfo->in_color_space == JCS_YCbCr)
+      cconvert->pub.color_convert = null_convert;
+    else
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+
+  case JCS_CMYK:
+    if (cinfo->num_components != 4)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    if (cinfo->in_color_space == JCS_CMYK)
+      cconvert->pub.color_convert = null_convert;
+    else
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+
+  case JCS_YCCK:
+    if (cinfo->num_components != 4)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    if (cinfo->in_color_space == JCS_CMYK) {
+      cconvert->pub.start_pass = rgb_ycc_start;
+      cconvert->pub.color_convert = cmyk_ycck_convert;
+    } else if (cinfo->in_color_space == JCS_YCCK)
+      cconvert->pub.color_convert = null_convert;
+    else
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+
+  default:			/* allow null conversion of JCS_UNKNOWN */
+    if (cinfo->jpeg_color_space != cinfo->in_color_space ||
+	cinfo->num_components != cinfo->input_components)
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    cconvert->pub.color_convert = null_convert;
+    break;
+  }
+}

src/jpeg/jcdctmgr.c

@@ -0,0 +1,387 @@
+/*
+ * jcdctmgr.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the forward-DCT management logic.
+ * This code selects a particular DCT implementation to be used,
+ * and it performs related housekeeping chores including coefficient
+ * quantization.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h"		/* Private declarations for DCT subsystem */
+
+
+/* Private subobject for this module */
+
+typedef struct {
+  struct jpeg_forward_dct pub;	/* public fields */
+
+  /* Pointer to the DCT routine actually in use */
+  forward_DCT_method_ptr do_dct;
+
+  /* The actual post-DCT divisors --- not identical to the quant table
+   * entries, because of scaling (especially for an unnormalized DCT).
+   * Each table is given in normal array order.
+   */
+  DCTELEM * divisors[NUM_QUANT_TBLS];
+
+#ifdef DCT_FLOAT_SUPPORTED
+  /* Same as above for the floating-point case. */
+  float_DCT_method_ptr do_float_dct;
+  FAST_FLOAT * float_divisors[NUM_QUANT_TBLS];
+#endif
+} my_fdct_controller;
+
+typedef my_fdct_controller * my_fdct_ptr;
+
+
+/*
+ * Initialize for a processing pass.
+ * Verify that all referenced Q-tables are present, and set up
+ * the divisor table for each one.
+ * In the current implementation, DCT of all components is done during
+ * the first pass, even if only some components will be output in the
+ * first scan.  Hence all components should be examined here.
+ */
+
+METHODDEF(void)
+start_pass_fdctmgr (j_compress_ptr cinfo)
+{
+  my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct;
+  int ci, qtblno, i;
+  jpeg_component_info *compptr;
+  JQUANT_TBL * qtbl;
+  DCTELEM * dtbl;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    qtblno = compptr->quant_tbl_no;
+    /* Make sure specified quantization table is present */
+    if (qtblno < 0 || qtblno >= NUM_QUANT_TBLS ||
+	cinfo->quant_tbl_ptrs[qtblno] == NULL)
+      ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, qtblno);
+    qtbl = cinfo->quant_tbl_ptrs[qtblno];
+    /* Compute divisors for this quant table */
+    /* We may do this more than once for same table, but it's not a big deal */
+    switch (cinfo->dct_method) {
+#ifdef DCT_ISLOW_SUPPORTED
+    case JDCT_ISLOW:
+      /* For LL&M IDCT method, divisors are equal to raw quantization
+       * coefficients multiplied by 8 (to counteract scaling).
+       */
+      if (fdct->divisors[qtblno] == NULL) {
+	fdct->divisors[qtblno] = (DCTELEM *)
+	  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				      DCTSIZE2 * SIZEOF(DCTELEM));
+      }
+      dtbl = fdct->divisors[qtblno];
+      for (i = 0; i < DCTSIZE2; i++) {
+	dtbl[i] = ((DCTELEM) qtbl->quantval[i]) << 3;
+      }
+      break;
+#endif
+#ifdef DCT_IFAST_SUPPORTED
+    case JDCT_IFAST:
+      {
+	/* For AA&N IDCT method, divisors are equal to quantization
+	 * coefficients scaled by scalefactor[row]*scalefactor[col], where
+	 *   scalefactor[0] = 1
+	 *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
+	 * We apply a further scale factor of 8.
+	 */
+#define CONST_BITS 14
+	static const INT16 aanscales[DCTSIZE2] = {
+	  /* precomputed values scaled up by 14 bits */
+	  16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
+	  22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
+	  21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
+	  19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
+	  16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
+	  12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
+	   8867, 12299, 11585, 10426,  8867,  6967,  4799,  2446,
+	   4520,  6270,  5906,  5315,  4520,  3552,  2446,  1247
+	};
+	SHIFT_TEMPS
+
+	if (fdct->divisors[qtblno] == NULL) {
+	  fdct->divisors[qtblno] = (DCTELEM *)
+	    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+					DCTSIZE2 * SIZEOF(DCTELEM));
+	}
+	dtbl = fdct->divisors[qtblno];
+	for (i = 0; i < DCTSIZE2; i++) {
+	  dtbl[i] = (DCTELEM)
+	    DESCALE(MULTIPLY16V16((INT32) qtbl->quantval[i],
+				  (INT32) aanscales[i]),
+		    CONST_BITS-3);
+	}
+      }
+      break;
+#endif
+#ifdef DCT_FLOAT_SUPPORTED
+    case JDCT_FLOAT:
+      {
+	/* For float AA&N IDCT method, divisors are equal to quantization
+	 * coefficients scaled by scalefactor[row]*scalefactor[col], where
+	 *   scalefactor[0] = 1
+	 *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
+	 * We apply a further scale factor of 8.
+	 * What's actually stored is 1/divisor so that the inner loop can
+	 * use a multiplication rather than a division.
+	 */
+	FAST_FLOAT * fdtbl;
+	int row, col;
+	static const double aanscalefactor[DCTSIZE] = {
+	  1.0, 1.387039845, 1.306562965, 1.175875602,
+	  1.0, 0.785694958, 0.541196100, 0.275899379
+	};
+
+	if (fdct->float_divisors[qtblno] == NULL) {
+	  fdct->float_divisors[qtblno] = (FAST_FLOAT *)
+	    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+					DCTSIZE2 * SIZEOF(FAST_FLOAT));
+	}
+	fdtbl = fdct->float_divisors[qtblno];
+	i = 0;
+	for (row = 0; row < DCTSIZE; row++) {
+	  for (col = 0; col < DCTSIZE; col++) {
+	    fdtbl[i] = (FAST_FLOAT)
+	      (1.0 / (((double) qtbl->quantval[i] *
+		       aanscalefactor[row] * aanscalefactor[col] * 8.0)));
+	    i++;
+	  }
+	}
+      }
+      break;
+#endif
+    default:
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+      break;
+    }
+  }
+}
+
+
+/*
+ * Perform forward DCT on one or more blocks of a component.
+ *
+ * The input samples are taken from the sample_data[] array starting at
+ * position start_row/start_col, and moving to the right for any additional
+ * blocks. The quantized coefficients are returned in coef_blocks[].
+ */
+
+METHODDEF(void)
+forward_DCT (j_compress_ptr cinfo, jpeg_component_info * compptr,
+	     JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
+	     JDIMENSION start_row, JDIMENSION start_col,
+	     JDIMENSION num_blocks)
+/* This version is used for integer DCT implementations. */
+{
+  /* This routine is heavily used, so it's worth coding it tightly. */
+  my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct;
+  forward_DCT_method_ptr do_dct = fdct->do_dct;
+  DCTELEM * divisors = fdct->divisors[compptr->quant_tbl_no];
+  DCTELEM workspace[DCTSIZE2];	/* work area for FDCT subroutine */
+  JDIMENSION bi;
+
+  sample_data += start_row;	/* fold in the vertical offset once */
+
+  for (bi = 0; bi < num_blocks; bi++, start_col += DCTSIZE) {
+    /* Load data into workspace, applying unsigned->signed conversion */
+    { register DCTELEM *workspaceptr;
+      register JSAMPROW elemptr;
+      register int elemr;
+
+      workspaceptr = workspace;
+      for (elemr = 0; elemr < DCTSIZE; elemr++) {
+	elemptr = sample_data[elemr] + start_col;
+#if DCTSIZE == 8		/* unroll the inner loop */
+	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+#else
+	{ register int elemc;
+	  for (elemc = DCTSIZE; elemc > 0; elemc--) {
+	    *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+	  }
+	}
+#endif
+      }
+    }
+
+    /* Perform the DCT */
+    (*do_dct) (workspace);
+
+    /* Quantize/descale the coefficients, and store into coef_blocks[] */
+    { register DCTELEM temp, qval;
+      register int i;
+      register JCOEFPTR output_ptr = coef_blocks[bi];
+
+      for (i = 0; i < DCTSIZE2; i++) {
+	qval = divisors[i];
+	temp = workspace[i];
+	/* Divide the coefficient value by qval, ensuring proper rounding.
+	 * Since C does not specify the direction of rounding for negative
+	 * quotients, we have to force the dividend positive for portability.
+	 *
+	 * In most files, at least half of the output values will be zero
+	 * (at default quantization settings, more like three-quarters...)
+	 * so we should ensure that this case is fast.  On many machines,
+	 * a comparison is enough cheaper than a divide to make a special test
+	 * a win.  Since both inputs will be nonnegative, we need only test
+	 * for a < b to discover whether a/b is 0.
+	 * If your machine's division is fast enough, define FAST_DIVIDE.
+	 */
+#ifdef FAST_DIVIDE
+#define DIVIDE_BY(a,b)	a /= b
+#else
+#define DIVIDE_BY(a,b)	if (a >= b) a /= b; else a = 0
+#endif
+	if (temp < 0) {
+	  temp = -temp;
+	  temp += qval>>1;	/* for rounding */
+	  DIVIDE_BY(temp, qval);
+	  temp = -temp;
+	} else {
+	  temp += qval>>1;	/* for rounding */
+	  DIVIDE_BY(temp, qval);
+	}
+	output_ptr[i] = (JCOEF) temp;
+      }
+    }
+  }
+}
+
+
+#ifdef DCT_FLOAT_SUPPORTED
+
+METHODDEF(void)
+forward_DCT_float (j_compress_ptr cinfo, jpeg_component_info * compptr,
+		   JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
+		   JDIMENSION start_row, JDIMENSION start_col,
+		   JDIMENSION num_blocks)
+/* This version is used for floating-point DCT implementations. */
+{
+  /* This routine is heavily used, so it's worth coding it tightly. */
+  my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct;
+  float_DCT_method_ptr do_dct = fdct->do_float_dct;
+  FAST_FLOAT * divisors = fdct->float_divisors[compptr->quant_tbl_no];
+  FAST_FLOAT workspace[DCTSIZE2]; /* work area for FDCT subroutine */
+  JDIMENSION bi;
+
+  sample_data += start_row;	/* fold in the vertical offset once */
+
+  for (bi = 0; bi < num_blocks; bi++, start_col += DCTSIZE) {
+    /* Load data into workspace, applying unsigned->signed conversion */
+    { register FAST_FLOAT *workspaceptr;
+      register JSAMPROW elemptr;
+      register int elemr;
+
+      workspaceptr = workspace;
+      for (elemr = 0; elemr < DCTSIZE; elemr++) {
+	elemptr = sample_data[elemr] + start_col;
+#if DCTSIZE == 8		/* unroll the inner loop */
+	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+#else
+	{ register int elemc;
+	  for (elemc = DCTSIZE; elemc > 0; elemc--) {
+	    *workspaceptr++ = (FAST_FLOAT)
+	      (GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+	  }
+	}
+#endif
+      }
+    }
+
+    /* Perform the DCT */
+    (*do_dct) (workspace);
+
+    /* Quantize/descale the coefficients, and store into coef_blocks[] */
+    { register FAST_FLOAT temp;
+      register int i;
+      register JCOEFPTR output_ptr = coef_blocks[bi];
+
+      for (i = 0; i < DCTSIZE2; i++) {
+	/* Apply the quantization and scaling factor */
+	temp = workspace[i] * divisors[i];
+	/* Round to nearest integer.
+	 * Since C does not specify the direction of rounding for negative
+	 * quotients, we have to force the dividend positive for portability.
+	 * The maximum coefficient size is +-16K (for 12-bit data), so this
+	 * code should work for either 16-bit or 32-bit ints.
+	 */
+	output_ptr[i] = (JCOEF) ((int) (temp + (FAST_FLOAT) 16384.5) - 16384);
+      }
+    }
+  }
+}
+
+#endif /* DCT_FLOAT_SUPPORTED */
+
+
+/*
+ * Initialize FDCT manager.
+ */
+
+GLOBAL(void)
+jinit_forward_dct (j_compress_ptr cinfo)
+{
+  my_fdct_ptr fdct;
+  int i;
+
+  fdct = (my_fdct_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_fdct_controller));
+  cinfo->fdct = (struct jpeg_forward_dct *) fdct;
+  fdct->pub.start_pass = start_pass_fdctmgr;
+
+  switch (cinfo->dct_method) {
+#ifdef DCT_ISLOW_SUPPORTED
+  case JDCT_ISLOW:
+    fdct->pub.forward_DCT = forward_DCT;
+    fdct->do_dct = jpeg_fdct_islow;
+    break;
+#endif
+#ifdef DCT_IFAST_SUPPORTED
+  case JDCT_IFAST:
+    fdct->pub.forward_DCT = forward_DCT;
+    fdct->do_dct = jpeg_fdct_ifast;
+    break;
+#endif
+#ifdef DCT_FLOAT_SUPPORTED
+  case JDCT_FLOAT:
+    fdct->pub.forward_DCT = forward_DCT_float;
+    fdct->do_float_dct = jpeg_fdct_float;
+    break;
+#endif
+  default:
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+    break;
+  }
+
+  /* Mark divisor tables unallocated */
+  for (i = 0; i < NUM_QUANT_TBLS; i++) {
+    fdct->divisors[i] = NULL;
+#ifdef DCT_FLOAT_SUPPORTED
+    fdct->float_divisors[i] = NULL;
+#endif
+  }
+}

src/jpeg/jchuff.c

@@ -0,0 +1,909 @@
+/*
+ * jchuff.c
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains Huffman entropy encoding routines.
+ *
+ * Much of the complexity here has to do with supporting output suspension.
+ * If the data destination module demands suspension, we want to be able to
+ * back up to the start of the current MCU.  To do this, we copy state
+ * variables into local working storage, and update them back to the
+ * permanent JPEG objects only upon successful completion of an MCU.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jchuff.h"		/* Declarations shared with jcphuff.c */
+
+
+/* Expanded entropy encoder object for Huffman encoding.
+ *
+ * The savable_state subrecord contains fields that change within an MCU,
+ * but must not be updated permanently until we complete the MCU.
+ */
+
+typedef struct {
+  INT32 put_buffer;		/* current bit-accumulation buffer */
+  int put_bits;			/* # of bits now in it */
+  int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
+} savable_state;
+
+/* This macro is to work around compilers with missing or broken
+ * structure assignment.  You'll need to fix this code if you have
+ * such a compiler and you change MAX_COMPS_IN_SCAN.
+ */
+
+#ifndef NO_STRUCT_ASSIGN
+#define ASSIGN_STATE(dest,src)  ((dest) = (src))
+#else
+#if MAX_COMPS_IN_SCAN == 4
+#define ASSIGN_STATE(dest,src)  \
+	((dest).put_buffer = (src).put_buffer, \
+	 (dest).put_bits = (src).put_bits, \
+	 (dest).last_dc_val[0] = (src).last_dc_val[0], \
+	 (dest).last_dc_val[1] = (src).last_dc_val[1], \
+	 (dest).last_dc_val[2] = (src).last_dc_val[2], \
+	 (dest).last_dc_val[3] = (src).last_dc_val[3])
+#endif
+#endif
+
+
+typedef struct {
+  struct jpeg_entropy_encoder pub; /* public fields */
+
+  savable_state saved;		/* Bit buffer & DC state at start of MCU */
+
+  /* These fields are NOT loaded into local working state. */
+  unsigned int restarts_to_go;	/* MCUs left in this restart interval */
+  int next_restart_num;		/* next restart number to write (0-7) */
+
+  /* Pointers to derived tables (these workspaces have image lifespan) */
+  c_derived_tbl * dc_derived_tbls[NUM_HUFF_TBLS];
+  c_derived_tbl * ac_derived_tbls[NUM_HUFF_TBLS];
+
+#ifdef ENTROPY_OPT_SUPPORTED	/* Statistics tables for optimization */
+  long * dc_count_ptrs[NUM_HUFF_TBLS];
+  long * ac_count_ptrs[NUM_HUFF_TBLS];
+#endif
+} huff_entropy_encoder;
+
+typedef huff_entropy_encoder * huff_entropy_ptr;
+
+/* Working state while writing an MCU.
+ * This struct contains all the fields that are needed by subroutines.
+ */
+
+typedef struct {
+  JOCTET * next_output_byte;	/* => next byte to write in buffer */
+  size_t free_in_buffer;	/* # of byte spaces remaining in buffer */
+  savable_state cur;		/* Current bit buffer & DC state */
+  j_compress_ptr cinfo;		/* dump_buffer needs access to this */
+} working_state;
+
+
+/* Forward declarations */
+METHODDEF(boolean) encode_mcu_huff JPP((j_compress_ptr cinfo,
+					JBLOCKROW *MCU_data));
+METHODDEF(void) finish_pass_huff JPP((j_compress_ptr cinfo));
+#ifdef ENTROPY_OPT_SUPPORTED
+METHODDEF(boolean) encode_mcu_gather JPP((j_compress_ptr cinfo,
+					  JBLOCKROW *MCU_data));
+METHODDEF(void) finish_pass_gather JPP((j_compress_ptr cinfo));
+#endif
+
+
+/*
+ * Initialize for a Huffman-compressed scan.
+ * If gather_statistics is TRUE, we do not output anything during the scan,
+ * just count the Huffman symbols used and generate Huffman code tables.
+ */
+
+METHODDEF(void)
+start_pass_huff (j_compress_ptr cinfo, boolean gather_statistics)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+  int ci, dctbl, actbl;
+  jpeg_component_info * compptr;
+
+  if (gather_statistics) {
+#ifdef ENTROPY_OPT_SUPPORTED
+    entropy->pub.encode_mcu = encode_mcu_gather;
+    entropy->pub.finish_pass = finish_pass_gather;
+#else
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+  } else {
+    entropy->pub.encode_mcu = encode_mcu_huff;
+    entropy->pub.finish_pass = finish_pass_huff;
+  }
+
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    dctbl = compptr->dc_tbl_no;
+    actbl = compptr->ac_tbl_no;
+    if (gather_statistics) {
+#ifdef ENTROPY_OPT_SUPPORTED
+      /* Check for invalid table indexes */
+      /* (make_c_derived_tbl does this in the other path) */
+      if (dctbl < 0 || dctbl >= NUM_HUFF_TBLS)
+	ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, dctbl);
+      if (actbl < 0 || actbl >= NUM_HUFF_TBLS)
+	ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, actbl);
+      /* Allocate and zero the statistics tables */
+      /* Note that jpeg_gen_optimal_table expects 257 entries in each table! */
+      if (entropy->dc_count_ptrs[dctbl] == NULL)
+	entropy->dc_count_ptrs[dctbl] = (long *)
+	  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				      257 * SIZEOF(long));
+      MEMZERO(entropy->dc_count_ptrs[dctbl], 257 * SIZEOF(long));
+      if (entropy->ac_count_ptrs[actbl] == NULL)
+	entropy->ac_count_ptrs[actbl] = (long *)
+	  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				      257 * SIZEOF(long));
+      MEMZERO(entropy->ac_count_ptrs[actbl], 257 * SIZEOF(long));
+#endif
+    } else {
+      /* Compute derived values for Huffman tables */
+      /* We may do this more than once for a table, but it's not expensive */
+      jpeg_make_c_derived_tbl(cinfo, TRUE, dctbl,
+			      & entropy->dc_derived_tbls[dctbl]);
+      jpeg_make_c_derived_tbl(cinfo, FALSE, actbl,
+			      & entropy->ac_derived_tbls[actbl]);
+    }
+    /* Initialize DC predictions to 0 */
+    entropy->saved.last_dc_val[ci] = 0;
+  }
+
+  /* Initialize bit buffer to empty */
+  entropy->saved.put_buffer = 0;
+  entropy->saved.put_bits = 0;
+
+  /* Initialize restart stuff */
+  entropy->restarts_to_go = cinfo->restart_interval;
+  entropy->next_restart_num = 0;
+}
+
+
+/*
+ * Compute the derived values for a Huffman table.
+ * This routine also performs some validation checks on the table.
+ *
+ * Note this is also used by jcphuff.c.
+ */
+
+GLOBAL(void)
+jpeg_make_c_derived_tbl (j_compress_ptr cinfo, boolean isDC, int tblno,
+			 c_derived_tbl ** pdtbl)
+{
+  JHUFF_TBL *htbl;
+  c_derived_tbl *dtbl;
+  int p, i, l, lastp, si, maxsymbol;
+  char huffsize[257];
+  unsigned int huffcode[257];
+  unsigned int code;
+
+  /* Note that huffsize[] and huffcode[] are filled in code-length order,
+   * paralleling the order of the symbols themselves in htbl->huffval[].
+   */
+
+  /* Find the input Huffman table */
+  if (tblno < 0 || tblno >= NUM_HUFF_TBLS)
+    ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
+  htbl =
+    isDC ? cinfo->dc_huff_tbl_ptrs[tblno] : cinfo->ac_huff_tbl_ptrs[tblno];
+  if (htbl == NULL)
+    ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
+
+  /* Allocate a workspace if we haven't already done so. */
+  if (*pdtbl == NULL)
+    *pdtbl = (c_derived_tbl *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  SIZEOF(c_derived_tbl));
+  dtbl = *pdtbl;
+  
+  /* Figure C.1: make table of Huffman code length for each symbol */
+
+  p = 0;
+  for (l = 1; l <= 16; l++) {
+    i = (int) htbl->bits[l];
+    if (i < 0 || p + i > 256)	/* protect against table overrun */
+      ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
+    while (i--)
+      huffsize[p++] = (char) l;
+  }
+  huffsize[p] = 0;
+  lastp = p;
+  
+  /* Figure C.2: generate the codes themselves */
+  /* We also validate that the counts represent a legal Huffman code tree. */
+
+  code = 0;
+  si = huffsize[0];
+  p = 0;
+  while (huffsize[p]) {
+    while (((int) huffsize[p]) == si) {
+      huffcode[p++] = code;
+      code++;
+    }
+    /* code is now 1 more than the last code used for codelength si; but
+     * it must still fit in si bits, since no code is allowed to be all ones.
+     */
+    if (((INT32) code) >= (((INT32) 1) << si))
+      ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
+    code <<= 1;
+    si++;
+  }
+  
+  /* Figure C.3: generate encoding tables */
+  /* These are code and size indexed by symbol value */
+
+  /* Set all codeless symbols to have code length 0;
+   * this lets us detect duplicate VAL entries here, and later
+   * allows emit_bits to detect any attempt to emit such symbols.
+   */
+  MEMZERO(dtbl->ehufsi, SIZEOF(dtbl->ehufsi));
+
+  /* This is also a convenient place to check for out-of-range
+   * and duplicated VAL entries.  We allow 0..255 for AC symbols
+   * but only 0..15 for DC.  (We could constrain them further
+   * based on data depth and mode, but this seems enough.)
+   */
+  maxsymbol = isDC ? 15 : 255;
+
+  for (p = 0; p < lastp; p++) {
+    i = htbl->huffval[p];
+    if (i < 0 || i > maxsymbol || dtbl->ehufsi[i])
+      ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
+    dtbl->ehufco[i] = huffcode[p];
+    dtbl->ehufsi[i] = huffsize[p];
+  }
+}
+
+
+/* Outputting bytes to the file */
+
+/* Emit a byte, taking 'action' if must suspend. */
+#define emit_byte(state,val,action)  \
+	{ *(state)->next_output_byte++ = (JOCTET) (val);  \
+	  if (--(state)->free_in_buffer == 0)  \
+	    if (! dump_buffer(state))  \
+	      { action; } }
+
+
+LOCAL(boolean)
+dump_buffer (working_state * state)
+/* Empty the output buffer; return TRUE if successful, FALSE if must suspend */
+{
+  struct jpeg_destination_mgr * dest = state->cinfo->dest;
+
+  if (! (*dest->empty_output_buffer) (state->cinfo))
+    return FALSE;
+  /* After a successful buffer dump, must reset buffer pointers */
+  state->next_output_byte = dest->next_output_byte;
+  state->free_in_buffer = dest->free_in_buffer;
+  return TRUE;
+}
+
+
+/* Outputting bits to the file */
+
+/* Only the right 24 bits of put_buffer are used; the valid bits are
+ * left-justified in this part.  At most 16 bits can be passed to emit_bits
+ * in one call, and we never retain more than 7 bits in put_buffer
+ * between calls, so 24 bits are sufficient.
+ */
+
+INLINE
+LOCAL(boolean)
+emit_bits (working_state * state, unsigned int code, int size)
+/* Emit some bits; return TRUE if successful, FALSE if must suspend */
+{
+  /* This routine is heavily used, so it's worth coding tightly. */
+  register INT32 put_buffer = (INT32) code;
+  register int put_bits = state->cur.put_bits;
+
+  /* if size is 0, caller used an invalid Huffman table entry */
+  if (size == 0)
+    ERREXIT(state->cinfo, JERR_HUFF_MISSING_CODE);
+
+  put_buffer &= (((INT32) 1)<<size) - 1; /* mask off any extra bits in code */
+  
+  put_bits += size;		/* new number of bits in buffer */
+  
+  put_buffer <<= 24 - put_bits; /* align incoming bits */
+
+  put_buffer |= state->cur.put_buffer; /* and merge with old buffer contents */
+  
+  while (put_bits >= 8) {
+    int c = (int) ((put_buffer >> 16) & 0xFF);
+    
+    emit_byte(state, c, return FALSE);
+    if (c == 0xFF) {		/* need to stuff a zero byte? */
+      emit_byte(state, 0, return FALSE);
+    }
+    put_buffer <<= 8;
+    put_bits -= 8;
+  }
+
+  state->cur.put_buffer = put_buffer; /* update state variables */
+  state->cur.put_bits = put_bits;
+
+  return TRUE;
+}
+
+
+LOCAL(boolean)
+flush_bits (working_state * state)
+{
+  if (! emit_bits(state, 0x7F, 7)) /* fill any partial byte with ones */
+    return FALSE;
+  state->cur.put_buffer = 0;	/* and reset bit-buffer to empty */
+  state->cur.put_bits = 0;
+  return TRUE;
+}
+
+
+/* Encode a single block's worth of coefficients */
+
+LOCAL(boolean)
+encode_one_block (working_state * state, JCOEFPTR block, int last_dc_val,
+		  c_derived_tbl *dctbl, c_derived_tbl *actbl)
+{
+  register int temp, temp2;
+  register int nbits;
+  register int k, r, i;
+  
+  /* Encode the DC coefficient difference per section F.1.2.1 */
+  
+  temp = temp2 = block[0] - last_dc_val;
+
+  if (temp < 0) {
+    temp = -temp;		/* temp is abs value of input */
+    /* For a negative input, want temp2 = bitwise complement of abs(input) */
+    /* This code assumes we are on a two's complement machine */
+    temp2--;
+  }
+  
+  /* Find the number of bits needed for the magnitude of the coefficient */
+  nbits = 0;
+  while (temp) {
+    nbits++;
+    temp >>= 1;
+  }
+  /* Check for out-of-range coefficient values.
+   * Since we're encoding a difference, the range limit is twice as much.
+   */
+  if (nbits > MAX_COEF_BITS+1)
+    ERREXIT(state->cinfo, JERR_BAD_DCT_COEF);
+  
+  /* Emit the Huffman-coded symbol for the number of bits */
+  if (! emit_bits(state, dctbl->ehufco[nbits], dctbl->ehufsi[nbits]))
+    return FALSE;
+
+  /* Emit that number of bits of the value, if positive, */
+  /* or the complement of its magnitude, if negative. */
+  if (nbits)			/* emit_bits rejects calls with size 0 */
+    if (! emit_bits(state, (unsigned int) temp2, nbits))
+      return FALSE;
+
+  /* Encode the AC coefficients per section F.1.2.2 */
+  
+  r = 0;			/* r = run length of zeros */
+  
+  for (k = 1; k < DCTSIZE2; k++) {
+    if ((temp = block[jpeg_natural_order[k]]) == 0) {
+      r++;
+    } else {
+      /* if run length > 15, must emit special run-length-16 codes (0xF0) */
+      while (r > 15) {
+	if (! emit_bits(state, actbl->ehufco[0xF0], actbl->ehufsi[0xF0]))
+	  return FALSE;
+	r -= 16;
+      }
+
+      temp2 = temp;
+      if (temp < 0) {
+	temp = -temp;		/* temp is abs value of input */
+	/* This code assumes we are on a two's complement machine */
+	temp2--;
+      }
+      
+      /* Find the number of bits needed for the magnitude of the coefficient */
+      nbits = 1;		/* there must be at least one 1 bit */
+      while ((temp >>= 1))
+	nbits++;
+      /* Check for out-of-range coefficient values */
+      if (nbits > MAX_COEF_BITS)
+	ERREXIT(state->cinfo, JERR_BAD_DCT_COEF);
+      
+      /* Emit Huffman symbol for run length / number of bits */
+      i = (r << 4) + nbits;
+      if (! emit_bits(state, actbl->ehufco[i], actbl->ehufsi[i]))
+	return FALSE;
+
+      /* Emit that number of bits of the value, if positive, */
+      /* or the complement of its magnitude, if negative. */
+      if (! emit_bits(state, (unsigned int) temp2, nbits))
+	return FALSE;
+      
+      r = 0;
+    }
+  }
+
+  /* If the last coef(s) were zero, emit an end-of-block code */
+  if (r > 0)
+    if (! emit_bits(state, actbl->ehufco[0], actbl->ehufsi[0]))
+      return FALSE;
+
+  return TRUE;
+}
+
+
+/*
+ * Emit a restart marker & resynchronize predictions.
+ */
+
+LOCAL(boolean)
+emit_restart (working_state * state, int restart_num)
+{
+  int ci;
+
+  if (! flush_bits(state))
+    return FALSE;
+
+  emit_byte(state, 0xFF, return FALSE);
+  emit_byte(state, JPEG_RST0 + restart_num, return FALSE);
+
+  /* Re-initialize DC predictions to 0 */
+  for (ci = 0; ci < state->cinfo->comps_in_scan; ci++)
+    state->cur.last_dc_val[ci] = 0;
+
+  /* The restart counter is not updated until we successfully write the MCU. */
+
+  return TRUE;
+}
+
+
+/*
+ * Encode and output one MCU's worth of Huffman-compressed coefficients.
+ */
+
+METHODDEF(boolean)
+encode_mcu_huff (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+  working_state state;
+  int blkn, ci;
+  jpeg_component_info * compptr;
+
+  /* Load up working state */
+  state.next_output_byte = cinfo->dest->next_output_byte;
+  state.free_in_buffer = cinfo->dest->free_in_buffer;
+  ASSIGN_STATE(state.cur, entropy->saved);
+  state.cinfo = cinfo;
+
+  /* Emit restart marker if needed */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0)
+      if (! emit_restart(&state, entropy->next_restart_num))
+	return FALSE;
+  }
+
+  /* Encode the MCU data blocks */
+  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+    ci = cinfo->MCU_membership[blkn];
+    compptr = cinfo->cur_comp_info[ci];
+    if (! encode_one_block(&state,
+			   MCU_data[blkn][0], state.cur.last_dc_val[ci],
+			   entropy->dc_derived_tbls[compptr->dc_tbl_no],
+			   entropy->ac_derived_tbls[compptr->ac_tbl_no]))
+      return FALSE;
+    /* Update last_dc_val */
+    state.cur.last_dc_val[ci] = MCU_data[blkn][0][0];
+  }
+
+  /* Completed MCU, so update state */
+  cinfo->dest->next_output_byte = state.next_output_byte;
+  cinfo->dest->free_in_buffer = state.free_in_buffer;
+  ASSIGN_STATE(entropy->saved, state.cur);
+
+  /* Update restart-interval state too */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0) {
+      entropy->restarts_to_go = cinfo->restart_interval;
+      entropy->next_restart_num++;
+      entropy->next_restart_num &= 7;
+    }
+    entropy->restarts_to_go--;
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * Finish up at the end of a Huffman-compressed scan.
+ */
+
+METHODDEF(void)
+finish_pass_huff (j_compress_ptr cinfo)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+  working_state state;
+
+  /* Load up working state ... flush_bits needs it */
+  state.next_output_byte = cinfo->dest->next_output_byte;
+  state.free_in_buffer = cinfo->dest->free_in_buffer;
+  ASSIGN_STATE(state.cur, entropy->saved);
+  state.cinfo = cinfo;
+
+  /* Flush out the last data */
+  if (! flush_bits(&state))
+    ERREXIT(cinfo, JERR_CANT_SUSPEND);
+
+  /* Update state */
+  cinfo->dest->next_output_byte = state.next_output_byte;
+  cinfo->dest->free_in_buffer = state.free_in_buffer;
+  ASSIGN_STATE(entropy->saved, state.cur);
+}
+
+
+/*
+ * Huffman coding optimization.
+ *
+ * We first scan the supplied data and count the number of uses of each symbol
+ * that is to be Huffman-coded. (This process MUST agree with the code above.)
+ * Then we build a Huffman coding tree for the observed counts.
+ * Symbols which are not needed at all for the particular image are not
+ * assigned any code, which saves space in the DHT marker as well as in
+ * the compressed data.
+ */
+
+#ifdef ENTROPY_OPT_SUPPORTED
+
+
+/* Process a single block's worth of coefficients */
+
+LOCAL(void)
+htest_one_block (j_compress_ptr cinfo, JCOEFPTR block, int last_dc_val,
+		 long dc_counts[], long ac_counts[])
+{
+  register int temp;
+  register int nbits;
+  register int k, r;
+  
+  /* Encode the DC coefficient difference per section F.1.2.1 */
+  
+  temp = block[0] - last_dc_val;
+  if (temp < 0)
+    temp = -temp;
+  
+  /* Find the number of bits needed for the magnitude of the coefficient */
+  nbits = 0;
+  while (temp) {
+    nbits++;
+    temp >>= 1;
+  }
+  /* Check for out-of-range coefficient values.
+   * Since we're encoding a difference, the range limit is twice as much.
+   */
+  if (nbits > MAX_COEF_BITS+1)
+    ERREXIT(cinfo, JERR_BAD_DCT_COEF);
+
+  /* Count the Huffman symbol for the number of bits */
+  dc_counts[nbits]++;
+  
+  /* Encode the AC coefficients per section F.1.2.2 */
+  
+  r = 0;			/* r = run length of zeros */
+  
+  for (k = 1; k < DCTSIZE2; k++) {
+    if ((temp = block[jpeg_natural_order[k]]) == 0) {
+      r++;
+    } else {
+      /* if run length > 15, must emit special run-length-16 codes (0xF0) */
+      while (r > 15) {
+	ac_counts[0xF0]++;
+	r -= 16;
+      }
+      
+      /* Find the number of bits needed for the magnitude of the coefficient */
+      if (temp < 0)
+	temp = -temp;
+      
+      /* Find the number of bits needed for the magnitude of the coefficient */
+      nbits = 1;		/* there must be at least one 1 bit */
+      while ((temp >>= 1))
+	nbits++;
+      /* Check for out-of-range coefficient values */
+      if (nbits > MAX_COEF_BITS)
+	ERREXIT(cinfo, JERR_BAD_DCT_COEF);
+      
+      /* Count Huffman symbol for run length / number of bits */
+      ac_counts[(r << 4) + nbits]++;
+      
+      r = 0;
+    }
+  }
+
+  /* If the last coef(s) were zero, emit an end-of-block code */
+  if (r > 0)
+    ac_counts[0]++;
+}
+
+
+/*
+ * Trial-encode one MCU's worth of Huffman-compressed coefficients.
+ * No data is actually output, so no suspension return is possible.
+ */
+
+METHODDEF(boolean)
+encode_mcu_gather (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+  int blkn, ci;
+  jpeg_component_info * compptr;
+
+  /* Take care of restart intervals if needed */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0) {
+      /* Re-initialize DC predictions to 0 */
+      for (ci = 0; ci < cinfo->comps_in_scan; ci++)
+	entropy->saved.last_dc_val[ci] = 0;
+      /* Update restart state */
+      entropy->restarts_to_go = cinfo->restart_interval;
+    }
+    entropy->restarts_to_go--;
+  }
+
+  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+    ci = cinfo->MCU_membership[blkn];
+    compptr = cinfo->cur_comp_info[ci];
+    htest_one_block(cinfo, MCU_data[blkn][0], entropy->saved.last_dc_val[ci],
+		    entropy->dc_count_ptrs[compptr->dc_tbl_no],
+		    entropy->ac_count_ptrs[compptr->ac_tbl_no]);
+    entropy->saved.last_dc_val[ci] = MCU_data[blkn][0][0];
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * Generate the best Huffman code table for the given counts, fill htbl.
+ * Note this is also used by jcphuff.c.
+ *
+ * The JPEG standard requires that no symbol be assigned a codeword of all
+ * one bits (so that padding bits added at the end of a compressed segment
+ * can't look like a valid code).  Because of the canonical ordering of
+ * codewords, this just means that there must be an unused slot in the
+ * longest codeword length category.  Section K.2 of the JPEG spec suggests
+ * reserving such a slot by pretending that symbol 256 is a valid symbol
+ * with count 1.  In theory that's not optimal; giving it count zero but
+ * including it in the symbol set anyway should give a better Huffman code.
+ * But the theoretically better code actually seems to come out worse in
+ * practice, because it produces more all-ones bytes (which incur stuffed
+ * zero bytes in the final file).  In any case the difference is tiny.
+ *
+ * The JPEG standard requires Huffman codes to be no more than 16 bits long.
+ * If some symbols have a very small but nonzero probability, the Huffman tree
+ * must be adjusted to meet the code length restriction.  We currently use
+ * the adjustment method suggested in JPEG section K.2.  This method is *not*
+ * optimal; it may not choose the best possible limited-length code.  But
+ * typically only very-low-frequency symbols will be given less-than-optimal
+ * lengths, so the code is almost optimal.  Experimental comparisons against
+ * an optimal limited-length-code algorithm indicate that the difference is
+ * microscopic --- usually less than a hundredth of a percent of total size.
+ * So the extra complexity of an optimal algorithm doesn't seem worthwhile.
+ */
+
+GLOBAL(void)
+jpeg_gen_optimal_table (j_compress_ptr cinfo, JHUFF_TBL * htbl, long freq[])
+{
+#define MAX_CLEN 32		/* assumed maximum initial code length */
+  UINT8 bits[MAX_CLEN+1];	/* bits[k] = # of symbols with code length k */
+  int codesize[257];		/* codesize[k] = code length of symbol k */
+  int others[257];		/* next symbol in current branch of tree */
+  int c1, c2;
+  int p, i, j;
+  long v;
+
+  /* This algorithm is explained in section K.2 of the JPEG standard */
+
+  MEMZERO(bits, SIZEOF(bits));
+  MEMZERO(codesize, SIZEOF(codesize));
+  for (i = 0; i < 257; i++)
+    others[i] = -1;		/* init links to empty */
+  
+  freq[256] = 1;		/* make sure 256 has a nonzero count */
+  /* Including the pseudo-symbol 256 in the Huffman procedure guarantees
+   * that no real symbol is given code-value of all ones, because 256
+   * will be placed last in the largest codeword category.
+   */
+
+  /* Huffman's basic algorithm to assign optimal code lengths to symbols */
+
+  for (;;) {
+    /* Find the smallest nonzero frequency, set c1 = its symbol */
+    /* In case of ties, take the larger symbol number */
+    c1 = -1;
+    v = 1000000000L;
+    for (i = 0; i <= 256; i++) {
+      if (freq[i] && freq[i] <= v) {
+	v = freq[i];
+	c1 = i;
+      }
+    }
+
+    /* Find the next smallest nonzero frequency, set c2 = its symbol */
+    /* In case of ties, take the larger symbol number */
+    c2 = -1;
+    v = 1000000000L;
+    for (i = 0; i <= 256; i++) {
+      if (freq[i] && freq[i] <= v && i != c1) {
+	v = freq[i];
+	c2 = i;
+      }
+    }
+
+    /* Done if we've merged everything into one frequency */
+    if (c2 < 0)
+      break;
+    
+    /* Else merge the two counts/trees */
+    freq[c1] += freq[c2];
+    freq[c2] = 0;
+
+    /* Increment the codesize of everything in c1's tree branch */
+    codesize[c1]++;
+    while (others[c1] >= 0) {
+      c1 = others[c1];
+      codesize[c1]++;
+    }
+    
+    others[c1] = c2;		/* chain c2 onto c1's tree branch */
+    
+    /* Increment the codesize of everything in c2's tree branch */
+    codesize[c2]++;
+    while (others[c2] >= 0) {
+      c2 = others[c2];
+      codesize[c2]++;
+    }
+  }
+
+  /* Now count the number of symbols of each code length */
+  for (i = 0; i <= 256; i++) {
+    if (codesize[i]) {
+      /* The JPEG standard seems to think that this can't happen, */
+      /* but I'm paranoid... */
+      if (codesize[i] > MAX_CLEN)
+	ERREXIT(cinfo, JERR_HUFF_CLEN_OVERFLOW);
+
+      bits[codesize[i]]++;
+    }
+  }
+
+  /* JPEG doesn't allow symbols with code lengths over 16 bits, so if the pure
+   * Huffman procedure assigned any such lengths, we must adjust the coding.
+   * Here is what the JPEG spec says about how this next bit works:
+   * Since symbols are paired for the longest Huffman code, the symbols are
+   * removed from this length category two at a time.  The prefix for the pair
+   * (which is one bit shorter) is allocated to one of the pair; then,
+   * skipping the BITS entry for that prefix length, a code word from the next
+   * shortest nonzero BITS entry is converted into a prefix for two code words
+   * one bit longer.
+   */
+  
+  for (i = MAX_CLEN; i > 16; i--) {
+    while (bits[i] > 0) {
+      j = i - 2;		/* find length of new prefix to be used */
+      while (bits[j] == 0)
+	j--;
+      
+      bits[i] -= 2;		/* remove two symbols */
+      bits[i-1]++;		/* one goes in this length */
+      bits[j+1] += 2;		/* two new symbols in this length */
+      bits[j]--;		/* symbol of this length is now a prefix */
+    }
+  }
+
+  /* Remove the count for the pseudo-symbol 256 from the largest codelength */
+  while (bits[i] == 0)		/* find largest codelength still in use */
+    i--;
+  bits[i]--;
+  
+  /* Return final symbol counts (only for lengths 0..16) */
+  MEMCOPY(htbl->bits, bits, SIZEOF(htbl->bits));
+  
+  /* Return a list of the symbols sorted by code length */
+  /* It's not real clear to me why we don't need to consider the codelength
+   * changes made above, but the JPEG spec seems to think this works.
+   */
+  p = 0;
+  for (i = 1; i <= MAX_CLEN; i++) {
+    for (j = 0; j <= 255; j++) {
+      if (codesize[j] == i) {
+	htbl->huffval[p] = (UINT8) j;
+	p++;
+      }
+    }
+  }
+
+  /* Set sent_table FALSE so updated table will be written to JPEG file. */
+  htbl->sent_table = FALSE;
+}
+
+
+/*
+ * Finish up a statistics-gathering pass and create the new Huffman tables.
+ */
+
+METHODDEF(void)
+finish_pass_gather (j_compress_ptr cinfo)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+  int ci, dctbl, actbl;
+  jpeg_component_info * compptr;
+  JHUFF_TBL **htblptr;
+  boolean did_dc[NUM_HUFF_TBLS];
+  boolean did_ac[NUM_HUFF_TBLS];
+
+  /* It's important not to apply jpeg_gen_optimal_table more than once
+   * per table, because it clobbers the input frequency counts!
+   */
+  MEMZERO(did_dc, SIZEOF(did_dc));
+  MEMZERO(did_ac, SIZEOF(did_ac));
+
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    dctbl = compptr->dc_tbl_no;
+    actbl = compptr->ac_tbl_no;
+    if (! did_dc[dctbl]) {
+      htblptr = & cinfo->dc_huff_tbl_ptrs[dctbl];
+      if (*htblptr == NULL)
+	*htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
+      jpeg_gen_optimal_table(cinfo, *htblptr, entropy->dc_count_ptrs[dctbl]);
+      did_dc[dctbl] = TRUE;
+    }
+    if (! did_ac[actbl]) {
+      htblptr = & cinfo->ac_huff_tbl_ptrs[actbl];
+      if (*htblptr == NULL)
+	*htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
+      jpeg_gen_optimal_table(cinfo, *htblptr, entropy->ac_count_ptrs[actbl]);
+      did_ac[actbl] = TRUE;
+    }
+  }
+}
+
+
+#endif /* ENTROPY_OPT_SUPPORTED */
+
+
+/*
+ * Module initialization routine for Huffman entropy encoding.
+ */
+
+GLOBAL(void)
+jinit_huff_encoder (j_compress_ptr cinfo)
+{
+  huff_entropy_ptr entropy;
+  int i;
+
+  entropy = (huff_entropy_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(huff_entropy_encoder));
+  cinfo->entropy = (struct jpeg_entropy_encoder *) entropy;
+  entropy->pub.start_pass = start_pass_huff;
+
+  /* Mark tables unallocated */
+  for (i = 0; i < NUM_HUFF_TBLS; i++) {
+    entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL;
+#ifdef ENTROPY_OPT_SUPPORTED
+    entropy->dc_count_ptrs[i] = entropy->ac_count_ptrs[i] = NULL;
+#endif
+  }
+}

src/jpeg/jchuff.h

@@ -0,0 +1,47 @@
+/*
+ * jchuff.h
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains declarations for Huffman entropy encoding routines
+ * that are shared between the sequential encoder (jchuff.c) and the
+ * progressive encoder (jcphuff.c).  No other modules need to see these.
+ */
+
+/* The legal range of a DCT coefficient is
+ *  -1024 .. +1023  for 8-bit data;
+ * -16384 .. +16383 for 12-bit data.
+ * Hence the magnitude should always fit in 10 or 14 bits respectively.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+#define MAX_COEF_BITS 10
+#else
+#define MAX_COEF_BITS 14
+#endif
+
+/* Derived data constructed for each Huffman table */
+
+typedef struct {
+  unsigned int ehufco[256];	/* code for each symbol */
+  char ehufsi[256];		/* length of code for each symbol */
+  /* If no code has been allocated for a symbol S, ehufsi[S] contains 0 */
+} c_derived_tbl;
+
+/* Short forms of external names for systems with brain-damaged linkers. */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jpeg_make_c_derived_tbl	jMkCDerived
+#define jpeg_gen_optimal_table	jGenOptTbl
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+/* Expand a Huffman table definition into the derived format */
+EXTERN(void) jpeg_make_c_derived_tbl
+	JPP((j_compress_ptr cinfo, boolean isDC, int tblno,
+	     c_derived_tbl ** pdtbl));
+
+/* Generate an optimal table definition given the specified counts */
+EXTERN(void) jpeg_gen_optimal_table
+	JPP((j_compress_ptr cinfo, JHUFF_TBL * htbl, long freq[]));

src/jpeg/jcinit.c

@@ -0,0 +1,72 @@
+/*
+ * jcinit.c
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains initialization logic for the JPEG compressor.
+ * This routine is in charge of selecting the modules to be executed and
+ * making an initialization call to each one.
+ *
+ * Logically, this code belongs in jcmaster.c.  It's split out because
+ * linking this routine implies linking the entire compression library.
+ * For a transcoding-only application, we want to be able to use jcmaster.c
+ * without linking in the whole library.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * Master selection of compression modules.
+ * This is done once at the start of processing an image.  We determine
+ * which modules will be used and give them appropriate initialization calls.
+ */
+
+GLOBAL(void)
+jinit_compress_master (j_compress_ptr cinfo)
+{
+  /* Initialize master control (includes parameter checking/processing) */
+  jinit_c_master_control(cinfo, FALSE /* full compression */);
+
+  /* Preprocessing */
+  if (! cinfo->raw_data_in) {
+    jinit_color_converter(cinfo);
+    jinit_downsampler(cinfo);
+    jinit_c_prep_controller(cinfo, FALSE /* never need full buffer here */);
+  }
+  /* Forward DCT */
+  jinit_forward_dct(cinfo);
+  /* Entropy encoding: either Huffman or arithmetic coding. */
+  if (cinfo->arith_code) {
+    ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
+  } else {
+    if (cinfo->progressive_mode) {
+#ifdef C_PROGRESSIVE_SUPPORTED
+      jinit_phuff_encoder(cinfo);
+#else
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+    } else
+      jinit_huff_encoder(cinfo);
+  }
+
+  /* Need a full-image coefficient buffer in any multi-pass mode. */
+  jinit_c_coef_controller(cinfo,
+		(boolean) (cinfo->num_scans > 1 || cinfo->optimize_coding));
+  jinit_c_main_controller(cinfo, FALSE /* never need full buffer here */);
+
+  jinit_marker_writer(cinfo);
+
+  /* We can now tell the memory manager to allocate virtual arrays. */
+  (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo);
+
+  /* Write the datastream header (SOI) immediately.
+   * Frame and scan headers are postponed till later.
+   * This lets application insert special markers after the SOI.
+   */
+  (*cinfo->marker->write_file_header) (cinfo);
+}

src/jpeg/jcmainct.c

@@ -0,0 +1,293 @@
+/*
+ * jcmainct.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the main buffer controller for compression.
+ * The main buffer lies between the pre-processor and the JPEG
+ * compressor proper; it holds downsampled data in the JPEG colorspace.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Note: currently, there is no operating mode in which a full-image buffer
+ * is needed at this step.  If there were, that mode could not be used with
+ * "raw data" input, since this module is bypassed in that case.  However,
+ * we've left the code here for possible use in special applications.
+ */
+#undef FULL_MAIN_BUFFER_SUPPORTED
+
+
+/* Private buffer controller object */
+
+typedef struct {
+  struct jpeg_c_main_controller pub; /* public fields */
+
+  JDIMENSION cur_iMCU_row;	/* number of current iMCU row */
+  JDIMENSION rowgroup_ctr;	/* counts row groups received in iMCU row */
+  boolean suspended;		/* remember if we suspended output */
+  J_BUF_MODE pass_mode;		/* current operating mode */
+
+  /* If using just a strip buffer, this points to the entire set of buffers
+   * (we allocate one for each component).  In the full-image case, this
+   * points to the currently accessible strips of the virtual arrays.
+   */
+  JSAMPARRAY buffer[MAX_COMPONENTS];
+
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+  /* If using full-image storage, this array holds pointers to virtual-array
+   * control blocks for each component.  Unused if not full-image storage.
+   */
+  jvirt_sarray_ptr whole_image[MAX_COMPONENTS];
+#endif
+} my_main_controller;
+
+typedef my_main_controller * my_main_ptr;
+
+
+/* Forward declarations */
+METHODDEF(void) process_data_simple_main
+	JPP((j_compress_ptr cinfo, JSAMPARRAY input_buf,
+	     JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail));
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+METHODDEF(void) process_data_buffer_main
+	JPP((j_compress_ptr cinfo, JSAMPARRAY input_buf,
+	     JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail));
+#endif
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF(void)
+start_pass_main (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+  my_main_ptr mymain = (my_main_ptr) cinfo->main;
+
+  /* Do nothing in raw-data mode. */
+  if (cinfo->raw_data_in)
+    return;
+
+  mymain->cur_iMCU_row = 0;	/* initialize counters */
+  mymain->rowgroup_ctr = 0;
+  mymain->suspended = FALSE;
+  mymain->pass_mode = pass_mode;	/* save mode for use by process_data */
+
+  switch (pass_mode) {
+  case JBUF_PASS_THRU:
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+    if (mymain->whole_image[0] != NULL)
+      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+#endif
+    mymain->pub.process_data = process_data_simple_main;
+    break;
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+  case JBUF_SAVE_SOURCE:
+  case JBUF_CRANK_DEST:
+  case JBUF_SAVE_AND_PASS:
+    if (mymain->whole_image[0] == NULL)
+      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    mymain->pub.process_data = process_data_buffer_main;
+    break;
+#endif
+  default:
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    break;
+  }
+}
+
+
+/*
+ * Process some data.
+ * This routine handles the simple pass-through mode,
+ * where we have only a strip buffer.
+ */
+
+METHODDEF(void)
+process_data_simple_main (j_compress_ptr cinfo,
+			  JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
+			  JDIMENSION in_rows_avail)
+{
+  my_main_ptr mymain = (my_main_ptr) cinfo->main;
+
+  while (mymain->cur_iMCU_row < cinfo->total_iMCU_rows) {
+    /* Read input data if we haven't filled the main buffer yet */
+    if (mymain->rowgroup_ctr < DCTSIZE)
+      (*cinfo->prep->pre_process_data) (cinfo,
+					input_buf, in_row_ctr, in_rows_avail,
+					mymain->buffer, &mymain->rowgroup_ctr,
+					(JDIMENSION) DCTSIZE);
+
+    /* If we don't have a full iMCU row buffered, return to application for
+     * more data.  Note that preprocessor will always pad to fill the iMCU row
+     * at the bottom of the image.
+     */
+    if (mymain->rowgroup_ctr != DCTSIZE)
+      return;
+
+    /* Send the completed row to the compressor */
+    if (! (*cinfo->coef->compress_data) (cinfo, mymain->buffer)) {
+      /* If compressor did not consume the whole row, then we must need to
+       * suspend processing and return to the application.  In this situation
+       * we pretend we didn't yet consume the last input row; otherwise, if
+       * it happened to be the last row of the image, the application would
+       * think we were done.
+       */
+      if (! mymain->suspended) {
+	(*in_row_ctr)--;
+	mymain->suspended = TRUE;
+      }
+      return;
+    }
+    /* We did finish the row.  Undo our little suspension hack if a previous
+     * call suspended; then mark the main buffer empty.
+     */
+    if (mymain->suspended) {
+      (*in_row_ctr)++;
+      mymain->suspended = FALSE;
+    }
+    mymain->rowgroup_ctr = 0;
+    mymain->cur_iMCU_row++;
+  }
+}
+
+
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+
+/*
+ * Process some data.
+ * This routine handles all of the modes that use a full-size buffer.
+ */
+
+METHODDEF(void)
+process_data_buffer_main (j_compress_ptr cinfo,
+			  JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
+			  JDIMENSION in_rows_avail)
+{
+  my_main_ptr mymain = (my_main_ptr) cinfo->main;
+  int ci;
+  jpeg_component_info *compptr;
+  boolean writing = (mymain->pass_mode != JBUF_CRANK_DEST);
+
+  while (mymain->cur_iMCU_row < cinfo->total_iMCU_rows) {
+    /* Realign the virtual buffers if at the start of an iMCU row. */
+    if (mymain->rowgroup_ctr == 0) {
+      for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+	   ci++, compptr++) {
+	mymain->buffer[ci] = (*cinfo->mem->access_virt_sarray)
+	  ((j_common_ptr) cinfo, mymain->whole_image[ci],
+	   mymain->cur_iMCU_row * (compptr->v_samp_factor * DCTSIZE),
+	   (JDIMENSION) (compptr->v_samp_factor * DCTSIZE), writing);
+      }
+      /* In a read pass, pretend we just read some source data. */
+      if (! writing) {
+	*in_row_ctr += cinfo->max_v_samp_factor * DCTSIZE;
+	mymain->rowgroup_ctr = DCTSIZE;
+      }
+    }
+
+    /* If a write pass, read input data until the current iMCU row is full. */
+    /* Note: preprocessor will pad if necessary to fill the last iMCU row. */
+    if (writing) {
+      (*cinfo->prep->pre_process_data) (cinfo,
+					input_buf, in_row_ctr, in_rows_avail,
+					mymain->buffer, &mymain->rowgroup_ctr,
+					(JDIMENSION) DCTSIZE);
+      /* Return to application if we need more data to fill the iMCU row. */
+      if (mymain->rowgroup_ctr < DCTSIZE)
+	return;
+    }
+
+    /* Emit data, unless this is a sink-only pass. */
+    if (mymain->pass_mode != JBUF_SAVE_SOURCE) {
+      if (! (*cinfo->coef->compress_data) (cinfo, mymain->buffer)) {
+	/* If compressor did not consume the whole row, then we must need to
+	 * suspend processing and return to the application.  In this situation
+	 * we pretend we didn't yet consume the last input row; otherwise, if
+	 * it happened to be the last row of the image, the application would
+	 * think we were done.
+	 */
+	if (! mymain->suspended) {
+	  (*in_row_ctr)--;
+	  mymain->suspended = TRUE;
+	}
+	return;
+      }
+      /* We did finish the row.  Undo our little suspension hack if a previous
+       * call suspended; then mark the main buffer empty.
+       */
+      if (mymain->suspended) {
+	(*in_row_ctr)++;
+	mymain->suspended = FALSE;
+      }
+    }
+
+    /* If get here, we are done with this iMCU row.  Mark buffer empty. */
+    mymain->rowgroup_ctr = 0;
+    mymain->cur_iMCU_row++;
+  }
+}
+
+#endif /* FULL_MAIN_BUFFER_SUPPORTED */
+
+
+/*
+ * Initialize main buffer controller.
+ */
+
+GLOBAL(void)
+jinit_c_main_controller (j_compress_ptr cinfo, boolean need_full_buffer)
+{
+  my_main_ptr mymain;
+  int ci;
+  jpeg_component_info *compptr;
+
+  mymain = (my_main_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_main_controller));
+  cinfo->main = (struct jpeg_c_main_controller *) mymain;
+  mymain->pub.start_pass = start_pass_main;
+
+  /* We don't need to create a buffer in raw-data mode. */
+  if (cinfo->raw_data_in)
+    return;
+
+  /* Create the buffer.  It holds downsampled data, so each component
+   * may be of a different size.
+   */
+  if (need_full_buffer) {
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+    /* Allocate a full-image virtual array for each component */
+    /* Note we pad the bottom to a multiple of the iMCU height */
+    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+	 ci++, compptr++) {
+      mymain->whole_image[ci] = (*cinfo->mem->request_virt_sarray)
+	((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
+	 compptr->width_in_blocks * DCTSIZE,
+	 (JDIMENSION) jround_up((long) compptr->height_in_blocks,
+				(long) compptr->v_samp_factor) * DCTSIZE,
+	 (JDIMENSION) (compptr->v_samp_factor * DCTSIZE));
+    }
+#else
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+#endif
+  } else {
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+    mymain->whole_image[0] = NULL; /* flag for no virtual arrays */
+#endif
+    /* Allocate a strip buffer for each component */
+    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+	 ci++, compptr++) {
+      mymain->buffer[ci] = (*cinfo->mem->alloc_sarray)
+	((j_common_ptr) cinfo, JPOOL_IMAGE,
+	 compptr->width_in_blocks * DCTSIZE,
+	 (JDIMENSION) (compptr->v_samp_factor * DCTSIZE));
+    }
+  }
+}

src/jpeg/jcmarker.c

@@ -0,0 +1,664 @@
+/*
+ * jcmarker.c
+ *
+ * Copyright (C) 1991-1998, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains routines to write JPEG datastream markers.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+typedef enum {			/* JPEG marker codes */
+  M_SOF0  = 0xc0,
+  M_SOF1  = 0xc1,
+  M_SOF2  = 0xc2,
+  M_SOF3  = 0xc3,
+  
+  M_SOF5  = 0xc5,
+  M_SOF6  = 0xc6,
+  M_SOF7  = 0xc7,
+  
+  M_JPG   = 0xc8,
+  M_SOF9  = 0xc9,
+  M_SOF10 = 0xca,
+  M_SOF11 = 0xcb,
+  
+  M_SOF13 = 0xcd,
+  M_SOF14 = 0xce,
+  M_SOF15 = 0xcf,
+  
+  M_DHT   = 0xc4,
+  
+  M_DAC   = 0xcc,
+  
+  M_RST0  = 0xd0,
+  M_RST1  = 0xd1,
+  M_RST2  = 0xd2,
+  M_RST3  = 0xd3,
+  M_RST4  = 0xd4,
+  M_RST5  = 0xd5,
+  M_RST6  = 0xd6,
+  M_RST7  = 0xd7,
+  
+  M_SOI   = 0xd8,
+  M_EOI   = 0xd9,
+  M_SOS   = 0xda,
+  M_DQT   = 0xdb,
+  M_DNL   = 0xdc,
+  M_DRI   = 0xdd,
+  M_DHP   = 0xde,
+  M_EXP   = 0xdf,
+  
+  M_APP0  = 0xe0,
+  M_APP1  = 0xe1,
+  M_APP2  = 0xe2,
+  M_APP3  = 0xe3,
+  M_APP4  = 0xe4,
+  M_APP5  = 0xe5,
+  M_APP6  = 0xe6,
+  M_APP7  = 0xe7,
+  M_APP8  = 0xe8,
+  M_APP9  = 0xe9,
+  M_APP10 = 0xea,
+  M_APP11 = 0xeb,
+  M_APP12 = 0xec,
+  M_APP13 = 0xed,
+  M_APP14 = 0xee,
+  M_APP15 = 0xef,
+  
+  M_JPG0  = 0xf0,
+  M_JPG13 = 0xfd,
+  M_COM   = 0xfe,
+  
+  M_TEM   = 0x01,
+  
+  M_ERROR = 0x100
+} JPEG_MARKER;
+
+
+/* Private state */
+
+typedef struct {
+  struct jpeg_marker_writer pub; /* public fields */
+
+  unsigned int last_restart_interval; /* last DRI value emitted; 0 after SOI */
+} my_marker_writer;
+
+typedef my_marker_writer * my_marker_ptr;
+
+
+/*
+ * Basic output routines.
+ *
+ * Note that we do not support suspension while writing a marker.
+ * Therefore, an application using suspension must ensure that there is
+ * enough buffer space for the initial markers (typ. 600-700 bytes) before
+ * calling jpeg_start_compress, and enough space to write the trailing EOI
+ * (a few bytes) before calling jpeg_finish_compress.  Multipass compression
+ * modes are not supported at all with suspension, so those two are the only
+ * points where markers will be written.
+ */
+
+LOCAL(void)
+emit_byte (j_compress_ptr cinfo, int val)
+/* Emit a byte */
+{
+  struct jpeg_destination_mgr * dest = cinfo->dest;
+
+  *(dest->next_output_byte)++ = (JOCTET) val;
+  if (--dest->free_in_buffer == 0) {
+    if (! (*dest->empty_output_buffer) (cinfo))
+      ERREXIT(cinfo, JERR_CANT_SUSPEND);
+  }
+}
+
+
+LOCAL(void)
+emit_marker (j_compress_ptr cinfo, JPEG_MARKER mark)
+/* Emit a marker code */
+{
+  emit_byte(cinfo, 0xFF);
+  emit_byte(cinfo, (int) mark);
+}
+
+
+LOCAL(void)
+emit_2bytes (j_compress_ptr cinfo, int value)
+/* Emit a 2-byte integer; these are always MSB first in JPEG files */
+{
+  emit_byte(cinfo, (value >> 8) & 0xFF);
+  emit_byte(cinfo, value & 0xFF);
+}
+
+
+/*
+ * Routines to write specific marker types.
+ */
+
+LOCAL(int)
+emit_dqt (j_compress_ptr cinfo, int index)
+/* Emit a DQT marker */
+/* Returns the precision used (0 = 8bits, 1 = 16bits) for baseline checking */
+{
+  JQUANT_TBL * qtbl = cinfo->quant_tbl_ptrs[index];
+  int prec;
+  int i;
+
+  if (qtbl == NULL)
+    ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, index);
+
+  prec = 0;
+  for (i = 0; i < DCTSIZE2; i++) {
+    if (qtbl->quantval[i] > 255)
+      prec = 1;
+  }
+
+  if (! qtbl->sent_table) {
+    emit_marker(cinfo, M_DQT);
+
+    emit_2bytes(cinfo, prec ? DCTSIZE2*2 + 1 + 2 : DCTSIZE2 + 1 + 2);
+
+    emit_byte(cinfo, index + (prec<<4));
+
+    for (i = 0; i < DCTSIZE2; i++) {
+      /* The table entries must be emitted in zigzag order. */
+      unsigned int qval = qtbl->quantval[jpeg_natural_order[i]];
+      if (prec)
+	emit_byte(cinfo, (int) (qval >> 8));
+      emit_byte(cinfo, (int) (qval & 0xFF));
+    }
+
+    qtbl->sent_table = TRUE;
+  }
+
+  return prec;
+}
+
+
+LOCAL(void)
+emit_dht (j_compress_ptr cinfo, int index, boolean is_ac)
+/* Emit a DHT marker */
+{
+  JHUFF_TBL * htbl;
+  int length, i;
+  
+  if (is_ac) {
+    htbl = cinfo->ac_huff_tbl_ptrs[index];
+    index += 0x10;		/* output index has AC bit set */
+  } else {
+    htbl = cinfo->dc_huff_tbl_ptrs[index];
+  }
+
+  if (htbl == NULL)
+    ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, index);
+  
+  if (! htbl->sent_table) {
+    emit_marker(cinfo, M_DHT);
+    
+    length = 0;
+    for (i = 1; i <= 16; i++)
+      length += htbl->bits[i];
+    
+    emit_2bytes(cinfo, length + 2 + 1 + 16);
+    emit_byte(cinfo, index);
+    
+    for (i = 1; i <= 16; i++)
+      emit_byte(cinfo, htbl->bits[i]);
+    
+    for (i = 0; i < length; i++)
+      emit_byte(cinfo, htbl->huffval[i]);
+    
+    htbl->sent_table = TRUE;
+  }
+}
+
+
+LOCAL(void)
+emit_dac (j_compress_ptr cinfo)
+/* Emit a DAC marker */
+/* Since the useful info is so small, we want to emit all the tables in */
+/* one DAC marker.  Therefore this routine does its own scan of the table. */
+{
+#ifdef C_ARITH_CODING_SUPPORTED
+  char dc_in_use[NUM_ARITH_TBLS];
+  char ac_in_use[NUM_ARITH_TBLS];
+  int length, i;
+  jpeg_component_info *compptr;
+  
+  for (i = 0; i < NUM_ARITH_TBLS; i++)
+    dc_in_use[i] = ac_in_use[i] = 0;
+  
+  for (i = 0; i < cinfo->comps_in_scan; i++) {
+    compptr = cinfo->cur_comp_info[i];
+    dc_in_use[compptr->dc_tbl_no] = 1;
+    ac_in_use[compptr->ac_tbl_no] = 1;
+  }
+  
+  length = 0;
+  for (i = 0; i < NUM_ARITH_TBLS; i++)
+    length += dc_in_use[i] + ac_in_use[i];
+  
+  emit_marker(cinfo, M_DAC);
+  
+  emit_2bytes(cinfo, length*2 + 2);
+  
+  for (i = 0; i < NUM_ARITH_TBLS; i++) {
+    if (dc_in_use[i]) {
+      emit_byte(cinfo, i);
+      emit_byte(cinfo, cinfo->arith_dc_L[i] + (cinfo->arith_dc_U[i]<<4));
+    }
+    if (ac_in_use[i]) {
+      emit_byte(cinfo, i + 0x10);
+      emit_byte(cinfo, cinfo->arith_ac_K[i]);
+    }
+  }
+#endif /* C_ARITH_CODING_SUPPORTED */
+}
+
+
+LOCAL(void)
+emit_dri (j_compress_ptr cinfo)
+/* Emit a DRI marker */
+{
+  emit_marker(cinfo, M_DRI);
+  
+  emit_2bytes(cinfo, 4);	/* fixed length */
+
+  emit_2bytes(cinfo, (int) cinfo->restart_interval);
+}
+
+
+LOCAL(void)
+emit_sof (j_compress_ptr cinfo, JPEG_MARKER code)
+/* Emit a SOF marker */
+{
+  int ci;
+  jpeg_component_info *compptr;
+  
+  emit_marker(cinfo, code);
+  
+  emit_2bytes(cinfo, 3 * cinfo->num_components + 2 + 5 + 1); /* length */
+
+  /* Make sure image isn't bigger than SOF field can handle */
+  if ((long) cinfo->image_height > 65535L ||
+      (long) cinfo->image_width > 65535L)
+    ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int) 65535);
+
+  emit_byte(cinfo, cinfo->data_precision);
+  emit_2bytes(cinfo, (int) cinfo->image_height);
+  emit_2bytes(cinfo, (int) cinfo->image_width);
+
+  emit_byte(cinfo, cinfo->num_components);
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    emit_byte(cinfo, compptr->component_id);
+    emit_byte(cinfo, (compptr->h_samp_factor << 4) + compptr->v_samp_factor);
+    emit_byte(cinfo, compptr->quant_tbl_no);
+  }
+}
+
+
+LOCAL(void)
+emit_sos (j_compress_ptr cinfo)
+/* Emit a SOS marker */
+{
+  int i, td, ta;
+  jpeg_component_info *compptr;
+  
+  emit_marker(cinfo, M_SOS);
+  
+  emit_2bytes(cinfo, 2 * cinfo->comps_in_scan + 2 + 1 + 3); /* length */
+  
+  emit_byte(cinfo, cinfo->comps_in_scan);
+  
+  for (i = 0; i < cinfo->comps_in_scan; i++) {
+    compptr = cinfo->cur_comp_info[i];
+    emit_byte(cinfo, compptr->component_id);
+    td = compptr->dc_tbl_no;
+    ta = compptr->ac_tbl_no;
+    if (cinfo->progressive_mode) {
+      /* Progressive mode: only DC or only AC tables are used in one scan;
+       * furthermore, Huffman coding of DC refinement uses no table at all.
+       * We emit 0 for unused field(s); this is recommended by the P&M text
+       * but does not seem to be specified in the standard.
+       */
+      if (cinfo->Ss == 0) {
+	ta = 0;			/* DC scan */
+	if (cinfo->Ah != 0 && !cinfo->arith_code)
+	  td = 0;		/* no DC table either */
+      } else {
+	td = 0;			/* AC scan */
+      }
+    }
+    emit_byte(cinfo, (td << 4) + ta);
+  }
+
+  emit_byte(cinfo, cinfo->Ss);
+  emit_byte(cinfo, cinfo->Se);
+  emit_byte(cinfo, (cinfo->Ah << 4) + cinfo->Al);
+}
+
+
+LOCAL(void)
+emit_jfif_app0 (j_compress_ptr cinfo)
+/* Emit a JFIF-compliant APP0 marker */
+{
+  /*
+   * Length of APP0 block	(2 bytes)
+   * Block ID			(4 bytes - ASCII "JFIF")
+   * Zero byte			(1 byte to terminate the ID string)
+   * Version Major, Minor	(2 bytes - major first)
+   * Units			(1 byte - 0x00 = none, 0x01 = inch, 0x02 = cm)
+   * Xdpu			(2 bytes - dots per unit horizontal)
+   * Ydpu			(2 bytes - dots per unit vertical)
+   * Thumbnail X size		(1 byte)
+   * Thumbnail Y size		(1 byte)
+   */
+  
+  emit_marker(cinfo, M_APP0);
+  
+  emit_2bytes(cinfo, 2 + 4 + 1 + 2 + 1 + 2 + 2 + 1 + 1); /* length */
+
+  emit_byte(cinfo, 0x4A);	/* Identifier: ASCII "JFIF" */
+  emit_byte(cinfo, 0x46);
+  emit_byte(cinfo, 0x49);
+  emit_byte(cinfo, 0x46);
+  emit_byte(cinfo, 0);
+  emit_byte(cinfo, cinfo->JFIF_major_version); /* Version fields */
+  emit_byte(cinfo, cinfo->JFIF_minor_version);
+  emit_byte(cinfo, cinfo->density_unit); /* Pixel size information */
+  emit_2bytes(cinfo, (int) cinfo->X_density);
+  emit_2bytes(cinfo, (int) cinfo->Y_density);
+  emit_byte(cinfo, 0);		/* No thumbnail image */
+  emit_byte(cinfo, 0);
+}
+
+
+LOCAL(void)
+emit_adobe_app14 (j_compress_ptr cinfo)
+/* Emit an Adobe APP14 marker */
+{
+  /*
+   * Length of APP14 block	(2 bytes)
+   * Block ID			(5 bytes - ASCII "Adobe")
+   * Version Number		(2 bytes - currently 100)
+   * Flags0			(2 bytes - currently 0)
+   * Flags1			(2 bytes - currently 0)
+   * Color transform		(1 byte)
+   *
+   * Although Adobe TN 5116 mentions Version = 101, all the Adobe files
+   * now in circulation seem to use Version = 100, so that's what we write.
+   *
+   * We write the color transform byte as 1 if the JPEG color space is
+   * YCbCr, 2 if it's YCCK, 0 otherwise.  Adobe's definition has to do with
+   * whether the encoder performed a transformation, which is pretty useless.
+   */
+  
+  emit_marker(cinfo, M_APP14);
+  
+  emit_2bytes(cinfo, 2 + 5 + 2 + 2 + 2 + 1); /* length */
+
+  emit_byte(cinfo, 0x41);	/* Identifier: ASCII "Adobe" */
+  emit_byte(cinfo, 0x64);
+  emit_byte(cinfo, 0x6F);
+  emit_byte(cinfo, 0x62);
+  emit_byte(cinfo, 0x65);
+  emit_2bytes(cinfo, 100);	/* Version */
+  emit_2bytes(cinfo, 0);	/* Flags0 */
+  emit_2bytes(cinfo, 0);	/* Flags1 */
+  switch (cinfo->jpeg_color_space) {
+  case JCS_YCbCr:
+    emit_byte(cinfo, 1);	/* Color transform = 1 */
+    break;
+  case JCS_YCCK:
+    emit_byte(cinfo, 2);	/* Color transform = 2 */
+    break;
+  default:
+    emit_byte(cinfo, 0);	/* Color transform = 0 */
+    break;
+  }
+}
+
+
+/*
+ * These routines allow writing an arbitrary marker with parameters.
+ * The only intended use is to emit COM or APPn markers after calling
+ * write_file_header and before calling write_frame_header.
+ * Other uses are not guaranteed to produce desirable results.
+ * Counting the parameter bytes properly is the caller's responsibility.
+ */
+
+METHODDEF(void)
+write_marker_header (j_compress_ptr cinfo, int marker, unsigned int datalen)
+/* Emit an arbitrary marker header */
+{
+  if (datalen > (unsigned int) 65533)		/* safety check */
+    ERREXIT(cinfo, JERR_BAD_LENGTH);
+
+  emit_marker(cinfo, (JPEG_MARKER) marker);
+
+  emit_2bytes(cinfo, (int) (datalen + 2));	/* total length */
+}
+
+METHODDEF(void)
+write_marker_byte (j_compress_ptr cinfo, int val)
+/* Emit one byte of marker parameters following write_marker_header */
+{
+  emit_byte(cinfo, val);
+}
+
+
+/*
+ * Write datastream header.
+ * This consists of an SOI and optional APPn markers.
+ * We recommend use of the JFIF marker, but not the Adobe marker,
+ * when using YCbCr or grayscale data.  The JFIF marker should NOT
+ * be used for any other JPEG colorspace.  The Adobe marker is helpful
+ * to distinguish RGB, CMYK, and YCCK colorspaces.
+ * Note that an application can write additional header markers after
+ * jpeg_start_compress returns.
+ */
+
+METHODDEF(void)
+write_file_header (j_compress_ptr cinfo)
+{
+  my_marker_ptr marker = (my_marker_ptr) cinfo->marker;
+
+  emit_marker(cinfo, M_SOI);	/* first the SOI */
+
+  /* SOI is defined to reset restart interval to 0 */
+  marker->last_restart_interval = 0;
+
+  if (cinfo->write_JFIF_header)	/* next an optional JFIF APP0 */
+    emit_jfif_app0(cinfo);
+  if (cinfo->write_Adobe_marker) /* next an optional Adobe APP14 */
+    emit_adobe_app14(cinfo);
+}
+
+
+/*
+ * Write frame header.
+ * This consists of DQT and SOFn markers.
+ * Note that we do not emit the SOF until we have emitted the DQT(s).
+ * This avoids compatibility problems with incorrect implementations that
+ * try to error-check the quant table numbers as soon as they see the SOF.
+ */
+
+METHODDEF(void)
+write_frame_header (j_compress_ptr cinfo)
+{
+  int ci, prec;
+  boolean is_baseline;
+  jpeg_component_info *compptr;
+  
+  /* Emit DQT for each quantization table.
+   * Note that emit_dqt() suppresses any duplicate tables.
+   */
+  prec = 0;
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    prec += emit_dqt(cinfo, compptr->quant_tbl_no);
+  }
+  /* now prec is nonzero iff there are any 16-bit quant tables. */
+
+  /* Check for a non-baseline specification.
+   * Note we assume that Huffman table numbers won't be changed later.
+   */
+  if (cinfo->arith_code || cinfo->progressive_mode ||
+      cinfo->data_precision != 8) {
+    is_baseline = FALSE;
+  } else {
+    is_baseline = TRUE;
+    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+	 ci++, compptr++) {
+      if (compptr->dc_tbl_no > 1 || compptr->ac_tbl_no > 1)
+	is_baseline = FALSE;
+    }
+    if (prec && is_baseline) {
+      is_baseline = FALSE;
+      /* If it's baseline except for quantizer size, warn the user */
+      TRACEMS(cinfo, 0, JTRC_16BIT_TABLES);
+    }
+  }
+
+  /* Emit the proper SOF marker */
+  if (cinfo->arith_code) {
+    emit_sof(cinfo, M_SOF9);	/* SOF code for arithmetic coding */
+  } else {
+    if (cinfo->progressive_mode)
+      emit_sof(cinfo, M_SOF2);	/* SOF code for progressive Huffman */
+    else if (is_baseline)
+      emit_sof(cinfo, M_SOF0);	/* SOF code for baseline implementation */
+    else
+      emit_sof(cinfo, M_SOF1);	/* SOF code for non-baseline Huffman file */
+  }
+}
+
+
+/*
+ * Write scan header.
+ * This consists of DHT or DAC markers, optional DRI, and SOS.
+ * Compressed data will be written following the SOS.
+ */
+
+METHODDEF(void)
+write_scan_header (j_compress_ptr cinfo)
+{
+  my_marker_ptr marker = (my_marker_ptr) cinfo->marker;
+  int i;
+  jpeg_component_info *compptr;
+
+  if (cinfo->arith_code) {
+    /* Emit arith conditioning info.  We may have some duplication
+     * if the file has multiple scans, but it's so small it's hardly
+     * worth worrying about.
+     */
+    emit_dac(cinfo);
+  } else {
+    /* Emit Huffman tables.
+     * Note that emit_dht() suppresses any duplicate tables.
+     */
+    for (i = 0; i < cinfo->comps_in_scan; i++) {
+      compptr = cinfo->cur_comp_info[i];
+      if (cinfo->progressive_mode) {
+	/* Progressive mode: only DC or only AC tables are used in one scan */
+	if (cinfo->Ss == 0) {
+	  if (cinfo->Ah == 0)	/* DC needs no table for refinement scan */
+	    emit_dht(cinfo, compptr->dc_tbl_no, FALSE);
+	} else {
+	  emit_dht(cinfo, compptr->ac_tbl_no, TRUE);
+	}
+      } else {
+	/* Sequential mode: need both DC and AC tables */
+	emit_dht(cinfo, compptr->dc_tbl_no, FALSE);
+	emit_dht(cinfo, compptr->ac_tbl_no, TRUE);
+      }
+    }
+  }
+
+  /* Emit DRI if required --- note that DRI value could change for each scan.
+   * We avoid wasting space with unnecessary DRIs, however.
+   */
+  if (cinfo->restart_interval != marker->last_restart_interval) {
+    emit_dri(cinfo);
+    marker->last_restart_interval = cinfo->restart_interval;
+  }
+
+  emit_sos(cinfo);
+}
+
+
+/*
+ * Write datastream trailer.
+ */
+
+METHODDEF(void)
+write_file_trailer (j_compress_ptr cinfo)
+{
+  emit_marker(cinfo, M_EOI);
+}
+
+
+/*
+ * Write an abbreviated table-specification datastream.
+ * This consists of SOI, DQT and DHT tables, and EOI.
+ * Any table that is defined and not marked sent_table = TRUE will be
+ * emitted.  Note that all tables will be marked sent_table = TRUE at exit.
+ */
+
+METHODDEF(void)
+write_tables_only (j_compress_ptr cinfo)
+{
+  int i;
+
+  emit_marker(cinfo, M_SOI);
+
+  for (i = 0; i < NUM_QUANT_TBLS; i++) {
+    if (cinfo->quant_tbl_ptrs[i] != NULL)
+      (void) emit_dqt(cinfo, i);
+  }
+
+  if (! cinfo->arith_code) {
+    for (i = 0; i < NUM_HUFF_TBLS; i++) {
+      if (cinfo->dc_huff_tbl_ptrs[i] != NULL)
+	emit_dht(cinfo, i, FALSE);
+      if (cinfo->ac_huff_tbl_ptrs[i] != NULL)
+	emit_dht(cinfo, i, TRUE);
+    }
+  }
+
+  emit_marker(cinfo, M_EOI);
+}
+
+
+/*
+ * Initialize the marker writer module.
+ */
+
+GLOBAL(void)
+jinit_marker_writer (j_compress_ptr cinfo)
+{
+  my_marker_ptr marker;
+
+  /* Create the subobject */
+  marker = (my_marker_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_marker_writer));
+  cinfo->marker = (struct jpeg_marker_writer *) marker;
+  /* Initialize method pointers */
+  marker->pub.write_file_header = write_file_header;
+  marker->pub.write_frame_header = write_frame_header;
+  marker->pub.write_scan_header = write_scan_header;
+  marker->pub.write_file_trailer = write_file_trailer;
+  marker->pub.write_tables_only = write_tables_only;
+  marker->pub.write_marker_header = write_marker_header;
+  marker->pub.write_marker_byte = write_marker_byte;
+  /* Initialize private state */
+  marker->last_restart_interval = 0;
+}

src/jpeg/jcmaster.c

@@ -0,0 +1,590 @@
+/*
+ * jcmaster.c
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains master control logic for the JPEG compressor.
+ * These routines are concerned with parameter validation, initial setup,
+ * and inter-pass control (determining the number of passes and the work 
+ * to be done in each pass).
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Private state */
+
+typedef enum {
+	main_pass,		/* input data, also do first output step */
+	huff_opt_pass,		/* Huffman code optimization pass */
+	output_pass		/* data output pass */
+} c_pass_type;
+
+typedef struct {
+  struct jpeg_comp_master pub;	/* public fields */
+
+  c_pass_type pass_type;	/* the type of the current pass */
+
+  int pass_number;		/* # of passes completed */
+  int total_passes;		/* total # of passes needed */
+
+  int scan_number;		/* current index in scan_info[] */
+} my_comp_master;
+
+typedef my_comp_master * my_master_ptr;
+
+
+/*
+ * Support routines that do various essential calculations.
+ */
+
+LOCAL(void)
+initial_setup (j_compress_ptr cinfo)
+/* Do computations that are needed before master selection phase */
+{
+  int ci;
+  jpeg_component_info *compptr;
+  long samplesperrow;
+  JDIMENSION jd_samplesperrow;
+
+  /* Sanity check on image dimensions */
+  if (cinfo->image_height <= 0 || cinfo->image_width <= 0
+      || cinfo->num_components <= 0 || cinfo->input_components <= 0)
+    ERREXIT(cinfo, JERR_EMPTY_IMAGE);
+
+  /* Make sure image isn't bigger than I can handle */
+  if ((long) cinfo->image_height > (long) JPEG_MAX_DIMENSION ||
+      (long) cinfo->image_width > (long) JPEG_MAX_DIMENSION)
+    ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int) JPEG_MAX_DIMENSION);
+
+  /* Width of an input scanline must be representable as JDIMENSION. */
+  samplesperrow = (long) cinfo->image_width * (long) cinfo->input_components;
+  jd_samplesperrow = (JDIMENSION) samplesperrow;
+  if ((long) jd_samplesperrow != samplesperrow)
+    ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
+
+  /* For now, precision must match compiled-in value... */
+  if (cinfo->data_precision != BITS_IN_JSAMPLE)
+    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
+
+  /* Check that number of components won't exceed internal array sizes */
+  if (cinfo->num_components > MAX_COMPONENTS)
+    ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
+	     MAX_COMPONENTS);
+
+  /* Compute maximum sampling factors; check factor validity */
+  cinfo->max_h_samp_factor = 1;
+  cinfo->max_v_samp_factor = 1;
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    if (compptr->h_samp_factor<=0 || compptr->h_samp_factor>MAX_SAMP_FACTOR ||
+	compptr->v_samp_factor<=0 || compptr->v_samp_factor>MAX_SAMP_FACTOR)
+      ERREXIT(cinfo, JERR_BAD_SAMPLING);
+    cinfo->max_h_samp_factor = MAX(cinfo->max_h_samp_factor,
+				   compptr->h_samp_factor);
+    cinfo->max_v_samp_factor = MAX(cinfo->max_v_samp_factor,
+				   compptr->v_samp_factor);
+  }
+
+  /* Compute dimensions of components */
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Fill in the correct component_index value; don't rely on application */
+    compptr->component_index = ci;
+    /* For compression, we never do DCT scaling. */
+    compptr->DCT_scaled_size = DCTSIZE;
+    /* Size in DCT blocks */
+    compptr->width_in_blocks = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor,
+		    (long) (cinfo->max_h_samp_factor * DCTSIZE));
+    compptr->height_in_blocks = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor,
+		    (long) (cinfo->max_v_samp_factor * DCTSIZE));
+    /* Size in samples */
+    compptr->downsampled_width = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor,
+		    (long) cinfo->max_h_samp_factor);
+    compptr->downsampled_height = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor,
+		    (long) cinfo->max_v_samp_factor);
+    /* Mark component needed (this flag isn't actually used for compression) */
+    compptr->component_needed = TRUE;
+  }
+
+  /* Compute number of fully interleaved MCU rows (number of times that
+   * main controller will call coefficient controller).
+   */
+  cinfo->total_iMCU_rows = (JDIMENSION)
+    jdiv_round_up((long) cinfo->image_height,
+		  (long) (cinfo->max_v_samp_factor*DCTSIZE));
+}
+
+
+#ifdef C_MULTISCAN_FILES_SUPPORTED
+
+LOCAL(void)
+validate_script (j_compress_ptr cinfo)
+/* Verify that the scan script in cinfo->scan_info[] is valid; also
+ * determine whether it uses progressive JPEG, and set cinfo->progressive_mode.
+ */
+{
+  const jpeg_scan_info * scanptr;
+  int scanno, ncomps, ci, coefi, thisi;
+  int Ss, Se, Ah, Al;
+  boolean component_sent[MAX_COMPONENTS];
+#ifdef C_PROGRESSIVE_SUPPORTED
+  int * last_bitpos_ptr;
+  int last_bitpos[MAX_COMPONENTS][DCTSIZE2];
+  /* -1 until that coefficient has been seen; then last Al for it */
+#endif
+
+  if (cinfo->num_scans <= 0)
+    ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, 0);
+
+  /* For sequential JPEG, all scans must have Ss=0, Se=DCTSIZE2-1;
+   * for progressive JPEG, no scan can have this.
+   */
+  scanptr = cinfo->scan_info;
+  if (scanptr->Ss != 0 || scanptr->Se != DCTSIZE2-1) {
+#ifdef C_PROGRESSIVE_SUPPORTED
+    cinfo->progressive_mode = TRUE;
+    last_bitpos_ptr = & last_bitpos[0][0];
+    for (ci = 0; ci < cinfo->num_components; ci++) 
+      for (coefi = 0; coefi < DCTSIZE2; coefi++)
+	*last_bitpos_ptr++ = -1;
+#else
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+  } else {
+    cinfo->progressive_mode = FALSE;
+    for (ci = 0; ci < cinfo->num_components; ci++) 
+      component_sent[ci] = FALSE;
+  }
+
+  for (scanno = 1; scanno <= cinfo->num_scans; scanptr++, scanno++) {
+    /* Validate component indexes */
+    ncomps = scanptr->comps_in_scan;
+    if (ncomps <= 0 || ncomps > MAX_COMPS_IN_SCAN)
+      ERREXIT2(cinfo, JERR_COMPONENT_COUNT, ncomps, MAX_COMPS_IN_SCAN);
+    for (ci = 0; ci < ncomps; ci++) {
+      thisi = scanptr->component_index[ci];
+      if (thisi < 0 || thisi >= cinfo->num_components)
+	ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, scanno);
+      /* Components must appear in SOF order within each scan */
+      if (ci > 0 && thisi <= scanptr->component_index[ci-1])
+	ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, scanno);
+    }
+    /* Validate progression parameters */
+    Ss = scanptr->Ss;
+    Se = scanptr->Se;
+    Ah = scanptr->Ah;
+    Al = scanptr->Al;
+    if (cinfo->progressive_mode) {
+#ifdef C_PROGRESSIVE_SUPPORTED
+      /* The JPEG spec simply gives the ranges 0..13 for Ah and Al, but that
+       * seems wrong: the upper bound ought to depend on data precision.
+       * Perhaps they really meant 0..N+1 for N-bit precision.
+       * Here we allow 0..10 for 8-bit data; Al larger than 10 results in
+       * out-of-range reconstructed DC values during the first DC scan,
+       * which might cause problems for some decoders.
+       */
+#if BITS_IN_JSAMPLE == 8
+#define MAX_AH_AL 10
+#else
+#define MAX_AH_AL 13
+#endif
+      if (Ss < 0 || Ss >= DCTSIZE2 || Se < Ss || Se >= DCTSIZE2 ||
+	  Ah < 0 || Ah > MAX_AH_AL || Al < 0 || Al > MAX_AH_AL)
+	ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+      if (Ss == 0) {
+	if (Se != 0)		/* DC and AC together not OK */
+	  ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+      } else {
+	if (ncomps != 1)	/* AC scans must be for only one component */
+	  ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+      }
+      for (ci = 0; ci < ncomps; ci++) {
+	last_bitpos_ptr = & last_bitpos[scanptr->component_index[ci]][0];
+	if (Ss != 0 && last_bitpos_ptr[0] < 0) /* AC without prior DC scan */
+	  ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+	for (coefi = Ss; coefi <= Se; coefi++) {
+	  if (last_bitpos_ptr[coefi] < 0) {
+	    /* first scan of this coefficient */
+	    if (Ah != 0)
+	      ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+	  } else {
+	    /* not first scan */
+	    if (Ah != last_bitpos_ptr[coefi] || Al != Ah-1)
+	      ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+	  }
+	  last_bitpos_ptr[coefi] = Al;
+	}
+      }
+#endif
+    } else {
+      /* For sequential JPEG, all progression parameters must be these: */
+      if (Ss != 0 || Se != DCTSIZE2-1 || Ah != 0 || Al != 0)
+	ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+      /* Make sure components are not sent twice */
+      for (ci = 0; ci < ncomps; ci++) {
+	thisi = scanptr->component_index[ci];
+	if (component_sent[thisi])
+	  ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, scanno);
+	component_sent[thisi] = TRUE;
+      }
+    }
+  }
+
+  /* Now verify that everything got sent. */
+  if (cinfo->progressive_mode) {
+#ifdef C_PROGRESSIVE_SUPPORTED
+    /* For progressive mode, we only check that at least some DC data
+     * got sent for each component; the spec does not require that all bits
+     * of all coefficients be transmitted.  Would it be wiser to enforce
+     * transmission of all coefficient bits??
+     */
+    for (ci = 0; ci < cinfo->num_components; ci++) {
+      if (last_bitpos[ci][0] < 0)
+	ERREXIT(cinfo, JERR_MISSING_DATA);
+    }
+#endif
+  } else {
+    for (ci = 0; ci < cinfo->num_components; ci++) {
+      if (! component_sent[ci])
+	ERREXIT(cinfo, JERR_MISSING_DATA);
+    }
+  }
+}
+
+#endif /* C_MULTISCAN_FILES_SUPPORTED */
+
+
+LOCAL(void)
+select_scan_parameters (j_compress_ptr cinfo)
+/* Set up the scan parameters for the current scan */
+{
+  int ci;
+
+#ifdef C_MULTISCAN_FILES_SUPPORTED
+  if (cinfo->scan_info != NULL) {
+    /* Prepare for current scan --- the script is already validated */
+    my_master_ptr master = (my_master_ptr) cinfo->master;
+    const jpeg_scan_info * scanptr = cinfo->scan_info + master->scan_number;
+
+    cinfo->comps_in_scan = scanptr->comps_in_scan;
+    for (ci = 0; ci < scanptr->comps_in_scan; ci++) {
+      cinfo->cur_comp_info[ci] =
+	&cinfo->comp_info[scanptr->component_index[ci]];
+    }
+    cinfo->Ss = scanptr->Ss;
+    cinfo->Se = scanptr->Se;
+    cinfo->Ah = scanptr->Ah;
+    cinfo->Al = scanptr->Al;
+  }
+  else
+#endif
+  {
+    /* Prepare for single sequential-JPEG scan containing all components */
+    if (cinfo->num_components > MAX_COMPS_IN_SCAN)
+      ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
+	       MAX_COMPS_IN_SCAN);
+    cinfo->comps_in_scan = cinfo->num_components;
+    for (ci = 0; ci < cinfo->num_components; ci++) {
+      cinfo->cur_comp_info[ci] = &cinfo->comp_info[ci];
+    }
+    cinfo->Ss = 0;
+    cinfo->Se = DCTSIZE2-1;
+    cinfo->Ah = 0;
+    cinfo->Al = 0;
+  }
+}
+
+
+LOCAL(void)
+per_scan_setup (j_compress_ptr cinfo)
+/* Do computations that are needed before processing a JPEG scan */
+/* cinfo->comps_in_scan and cinfo->cur_comp_info[] are already set */
+{
+  int ci, mcublks, tmp;
+  jpeg_component_info *compptr;
+  
+  if (cinfo->comps_in_scan == 1) {
+    
+    /* Noninterleaved (single-component) scan */
+    compptr = cinfo->cur_comp_info[0];
+    
+    /* Overall image size in MCUs */
+    cinfo->MCUs_per_row = compptr->width_in_blocks;
+    cinfo->MCU_rows_in_scan = compptr->height_in_blocks;
+    
+    /* For noninterleaved scan, always one block per MCU */
+    compptr->MCU_width = 1;
+    compptr->MCU_height = 1;
+    compptr->MCU_blocks = 1;
+    compptr->MCU_sample_width = DCTSIZE;
+    compptr->last_col_width = 1;
+    /* For noninterleaved scans, it is convenient to define last_row_height
+     * as the number of block rows present in the last iMCU row.
+     */
+    tmp = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
+    if (tmp == 0) tmp = compptr->v_samp_factor;
+    compptr->last_row_height = tmp;
+    
+    /* Prepare array describing MCU composition */
+    cinfo->blocks_in_MCU = 1;
+    cinfo->MCU_membership[0] = 0;
+    
+  } else {
+    
+    /* Interleaved (multi-component) scan */
+    if (cinfo->comps_in_scan <= 0 || cinfo->comps_in_scan > MAX_COMPS_IN_SCAN)
+      ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->comps_in_scan,
+	       MAX_COMPS_IN_SCAN);
+    
+    /* Overall image size in MCUs */
+    cinfo->MCUs_per_row = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_width,
+		    (long) (cinfo->max_h_samp_factor*DCTSIZE));
+    cinfo->MCU_rows_in_scan = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_height,
+		    (long) (cinfo->max_v_samp_factor*DCTSIZE));
+    
+    cinfo->blocks_in_MCU = 0;
+    
+    for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+      compptr = cinfo->cur_comp_info[ci];
+      /* Sampling factors give # of blocks of component in each MCU */
+      compptr->MCU_width = compptr->h_samp_factor;
+      compptr->MCU_height = compptr->v_samp_factor;
+      compptr->MCU_blocks = compptr->MCU_width * compptr->MCU_height;
+      compptr->MCU_sample_width = compptr->MCU_width * DCTSIZE;
+      /* Figure number of non-dummy blocks in last MCU column & row */
+      tmp = (int) (compptr->width_in_blocks % compptr->MCU_width);
+      if (tmp == 0) tmp = compptr->MCU_width;
+      compptr->last_col_width = tmp;
+      tmp = (int) (compptr->height_in_blocks % compptr->MCU_height);
+      if (tmp == 0) tmp = compptr->MCU_height;
+      compptr->last_row_height = tmp;
+      /* Prepare array describing MCU composition */
+      mcublks = compptr->MCU_blocks;
+      if (cinfo->blocks_in_MCU + mcublks > C_MAX_BLOCKS_IN_MCU)
+	ERREXIT(cinfo, JERR_BAD_MCU_SIZE);
+      while (mcublks-- > 0) {
+	cinfo->MCU_membership[cinfo->blocks_in_MCU++] = ci;
+      }
+    }
+    
+  }
+
+  /* Convert restart specified in rows to actual MCU count. */
+  /* Note that count must fit in 16 bits, so we provide limiting. */
+  if (cinfo->restart_in_rows > 0) {
+    long nominal = (long) cinfo->restart_in_rows * (long) cinfo->MCUs_per_row;
+    cinfo->restart_interval = (unsigned int) MIN(nominal, 65535L);
+  }
+}
+
+
+/*
+ * Per-pass setup.
+ * This is called at the beginning of each pass.  We determine which modules
+ * will be active during this pass and give them appropriate start_pass calls.
+ * We also set is_last_pass to indicate whether any more passes will be
+ * required.
+ */
+
+METHODDEF(void)
+prepare_for_pass (j_compress_ptr cinfo)
+{
+  my_master_ptr master = (my_master_ptr) cinfo->master;
+
+  switch (master->pass_type) {
+  case main_pass:
+    /* Initial pass: will collect input data, and do either Huffman
+     * optimization or data output for the first scan.
+     */
+    select_scan_parameters(cinfo);
+    per_scan_setup(cinfo);
+    if (! cinfo->raw_data_in) {
+      (*cinfo->cconvert->start_pass) (cinfo);
+      (*cinfo->downsample->start_pass) (cinfo);
+      (*cinfo->prep->start_pass) (cinfo, JBUF_PASS_THRU);
+    }
+    (*cinfo->fdct->start_pass) (cinfo);
+    (*cinfo->entropy->start_pass) (cinfo, cinfo->optimize_coding);
+    (*cinfo->coef->start_pass) (cinfo,
+				(master->total_passes > 1 ?
+				 JBUF_SAVE_AND_PASS : JBUF_PASS_THRU));
+    (*cinfo->main->start_pass) (cinfo, JBUF_PASS_THRU);
+    if (cinfo->optimize_coding) {
+      /* No immediate data output; postpone writing frame/scan headers */
+      master->pub.call_pass_startup = FALSE;
+    } else {
+      /* Will write frame/scan headers at first jpeg_write_scanlines call */
+      master->pub.call_pass_startup = TRUE;
+    }
+    break;
+#ifdef ENTROPY_OPT_SUPPORTED
+  case huff_opt_pass:
+    /* Do Huffman optimization for a scan after the first one. */
+    select_scan_parameters(cinfo);
+    per_scan_setup(cinfo);
+    if (cinfo->Ss != 0 || cinfo->Ah == 0 || cinfo->arith_code) {
+      (*cinfo->entropy->start_pass) (cinfo, TRUE);
+      (*cinfo->coef->start_pass) (cinfo, JBUF_CRANK_DEST);
+      master->pub.call_pass_startup = FALSE;
+      break;
+    }
+    /* Special case: Huffman DC refinement scans need no Huffman table
+     * and therefore we can skip the optimization pass for them.
+     */
+    master->pass_type = output_pass;
+    master->pass_number++;
+    /*FALLTHROUGH*/
+#endif
+  case output_pass:
+    /* Do a data-output pass. */
+    /* We need not repeat per-scan setup if prior optimization pass did it. */
+    if (! cinfo->optimize_coding) {
+      select_scan_parameters(cinfo);
+      per_scan_setup(cinfo);
+    }
+    (*cinfo->entropy->start_pass) (cinfo, FALSE);
+    (*cinfo->coef->start_pass) (cinfo, JBUF_CRANK_DEST);
+    /* We emit frame/scan headers now */
+    if (master->scan_number == 0)
+      (*cinfo->marker->write_frame_header) (cinfo);
+    (*cinfo->marker->write_scan_header) (cinfo);
+    master->pub.call_pass_startup = FALSE;
+    break;
+  default:
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+  }
+
+  master->pub.is_last_pass = (master->pass_number == master->total_passes-1);
+
+  /* Set up progress monitor's pass info if present */
+  if (cinfo->progress != NULL) {
+    cinfo->progress->completed_passes = master->pass_number;
+    cinfo->progress->total_passes = master->total_passes;
+  }
+}
+
+
+/*
+ * Special start-of-pass hook.
+ * This is called by jpeg_write_scanlines if call_pass_startup is TRUE.
+ * In single-pass processing, we need this hook because we don't want to
+ * write frame/scan headers during jpeg_start_compress; we want to let the
+ * application write COM markers etc. between jpeg_start_compress and the
+ * jpeg_write_scanlines loop.
+ * In multi-pass processing, this routine is not used.
+ */
+
+METHODDEF(void)
+pass_startup (j_compress_ptr cinfo)
+{
+  cinfo->master->call_pass_startup = FALSE; /* reset flag so call only once */
+
+  (*cinfo->marker->write_frame_header) (cinfo);
+  (*cinfo->marker->write_scan_header) (cinfo);
+}
+
+
+/*
+ * Finish up at end of pass.
+ */
+
+METHODDEF(void)
+finish_pass_master (j_compress_ptr cinfo)
+{
+  my_master_ptr master = (my_master_ptr) cinfo->master;
+
+  /* The entropy coder always needs an end-of-pass call,
+   * either to analyze statistics or to flush its output buffer.
+   */
+  (*cinfo->entropy->finish_pass) (cinfo);
+
+  /* Update state for next pass */
+  switch (master->pass_type) {
+  case main_pass:
+    /* next pass is either output of scan 0 (after optimization)
+     * or output of scan 1 (if no optimization).
+     */
+    master->pass_type = output_pass;
+    if (! cinfo->optimize_coding)
+      master->scan_number++;
+    break;
+  case huff_opt_pass:
+    /* next pass is always output of current scan */
+    master->pass_type = output_pass;
+    break;
+  case output_pass:
+    /* next pass is either optimization or output of next scan */
+    if (cinfo->optimize_coding)
+      master->pass_type = huff_opt_pass;
+    master->scan_number++;
+    break;
+  }
+
+  master->pass_number++;
+}
+
+
+/*
+ * Initialize master compression control.
+ */
+
+GLOBAL(void)
+jinit_c_master_control (j_compress_ptr cinfo, boolean transcode_only)
+{
+  my_master_ptr master;
+
+  master = (my_master_ptr)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  SIZEOF(my_comp_master));
+  cinfo->master = (struct jpeg_comp_master *) master;
+  master->pub.prepare_for_pass = prepare_for_pass;
+  master->pub.pass_startup = pass_startup;
+  master->pub.finish_pass = finish_pass_master;
+  master->pub.is_last_pass = FALSE;
+
+  /* Validate parameters, determine derived values */
+  initial_setup(cinfo);
+
+  if (cinfo->scan_info != NULL) {
+#ifdef C_MULTISCAN_FILES_SUPPORTED
+    validate_script(cinfo);
+#else
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+  } else {
+    cinfo->progressive_mode = FALSE;
+    cinfo->num_scans = 1;
+  }
+
+  if (cinfo->progressive_mode)	/*  TEMPORARY HACK ??? */
+    cinfo->optimize_coding = TRUE; /* assume default tables no good for progressive mode */
+
+  /* Initialize my private state */
+  if (transcode_only) {
+    /* no main pass in transcoding */
+    if (cinfo->optimize_coding)
+      master->pass_type = huff_opt_pass;
+    else
+      master->pass_type = output_pass;
+  } else {
+    /* for normal compression, first pass is always this type: */
+    master->pass_type = main_pass;
+  }
+  master->scan_number = 0;
+  master->pass_number = 0;
+  if (cinfo->optimize_coding)
+    master->total_passes = cinfo->num_scans * 2;
+  else
+    master->total_passes = cinfo->num_scans;
+}

src/jpeg/jcomapi.c

@@ -0,0 +1,106 @@
+/*
+ * jcomapi.c
+ *
+ * Copyright (C) 1994-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains application interface routines that are used for both
+ * compression and decompression.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * Abort processing of a JPEG compression or decompression operation,
+ * but don't destroy the object itself.
+ *
+ * For this, we merely clean up all the nonpermanent memory pools.
+ * Note that temp files (virtual arrays) are not allowed to belong to
+ * the permanent pool, so we will be able to close all temp files here.
+ * Closing a data source or destination, if necessary, is the application's
+ * responsibility.
+ */
+
+GLOBAL(void)
+jpeg_abort (j_common_ptr cinfo)
+{
+  int pool;
+
+  /* Do nothing if called on a not-initialized or destroyed JPEG object. */
+  if (cinfo->mem == NULL)
+    return;
+
+  /* Releasing pools in reverse order might help avoid fragmentation
+   * with some (brain-damaged) malloc libraries.
+   */
+  for (pool = JPOOL_NUMPOOLS-1; pool > JPOOL_PERMANENT; pool--) {
+    (*cinfo->mem->free_pool) (cinfo, pool);
+  }
+
+  /* Reset overall state for possible reuse of object */
+  if (cinfo->is_decompressor) {
+    cinfo->global_state = DSTATE_START;
+    /* Try to keep application from accessing now-deleted marker list.
+     * A bit kludgy to do it here, but this is the most central place.
+     */
+    ((j_decompress_ptr) cinfo)->marker_list = NULL;
+  } else {
+    cinfo->global_state = CSTATE_START;
+  }
+}
+
+
+/*
+ * Destruction of a JPEG object.
+ *
+ * Everything gets deallocated except the master jpeg_compress_struct itself
+ * and the error manager struct.  Both of these are supplied by the application
+ * and must be freed, if necessary, by the application.  (Often they are on
+ * the stack and so don't need to be freed anyway.)
+ * Closing a data source or destination, if necessary, is the application's
+ * responsibility.
+ */
+
+GLOBAL(void)
+jpeg_destroy (j_common_ptr cinfo)
+{
+  /* We need only tell the memory manager to release everything. */
+  /* NB: mem pointer is NULL if memory mgr failed to initialize. */
+  if (cinfo->mem != NULL)
+    (*cinfo->mem->self_destruct) (cinfo);
+  cinfo->mem = NULL;		/* be safe if jpeg_destroy is called twice */
+  cinfo->global_state = 0;	/* mark it destroyed */
+}
+
+
+/*
+ * Convenience routines for allocating quantization and Huffman tables.
+ * (Would jutils.c be a more reasonable place to put these?)
+ */
+
+GLOBAL(JQUANT_TBL *)
+jpeg_alloc_quant_table (j_common_ptr cinfo)
+{
+  JQUANT_TBL *tbl;
+
+  tbl = (JQUANT_TBL *)
+    (*cinfo->mem->alloc_small) (cinfo, JPOOL_PERMANENT, SIZEOF(JQUANT_TBL));
+  tbl->sent_table = FALSE;	/* make sure this is false in any new table */
+  return tbl;
+}
+
+
+GLOBAL(JHUFF_TBL *)
+jpeg_alloc_huff_table (j_common_ptr cinfo)
+{
+  JHUFF_TBL *tbl;
+
+  tbl = (JHUFF_TBL *)
+    (*cinfo->mem->alloc_small) (cinfo, JPOOL_PERMANENT, SIZEOF(JHUFF_TBL));
+  tbl->sent_table = FALSE;	/* make sure this is false in any new table */
+  return tbl;
+}

src/jpeg/jconfig.h

@@ -0,0 +1,89 @@
+/* This test added by JACS as a quick fix. What should we do
+ * to make it work with configure?
+ */
+
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+#include "jconfig.vc"
+#else
+
+/* jconfig.h.  Generated automatically by configure.  */
+/* jconfig.cfg --- source file edited by configure script */
+/* see jconfig.doc for explanations */
+
+/* use wxWindows' configure */
+#ifdef __MWERKS__
+#if (__MWERKS__ < 0x0900) || macintosh
+    #define __WXMAC__
+		#define USE_MAC_MEMMGR
+// automatically includes MacHeaders
+#elif (__MWERKS__ >= 0x0900) && __INTEL__
+    #define __WXMSW__
+#endif
+#endif
+
+#include "wx/setup.h"
+
+#define HAVE_PROTOTYPES
+#define HAVE_UNSIGNED_CHAR
+#define HAVE_UNSIGNED_SHORT
+#undef void
+#undef const
+
+/* use wxWindows' configure */
+/* #undef CHAR_IS_UNSIGNED */
+#ifdef __CHAR_UNSIGNED__
+  #ifndef CHAR_IS_UNSIGNED
+    #define CHAR_IS_UNSIGNED
+  #endif
+#else
+  #undef CHAR_IS_UNSIGNED
+#endif
+
+#define HAVE_STDDEF_H
+#define HAVE_STDLIB_H
+#undef NEED_BSD_STRINGS
+#undef NEED_SYS_TYPES_H
+#undef NEED_FAR_POINTERS
+#undef NEED_SHORT_EXTERNAL_NAMES
+/* Define this if you get warnings about undefined structures. */
+#undef INCOMPLETE_TYPES_BROKEN
+
+#ifdef JPEG_INTERNALS
+
+#undef RIGHT_SHIFT_IS_UNSIGNED
+
+/* use wxWindows' configure */
+/* #define INLINE __inline__ */
+#if defined(__VISAGECPP__) && (__IBMCPP__ >= 400 || __IBMC__ >= 400)
+#define INLINE
+#elif defined(__WATCOMC__)
+#define INLINE
+#else
+#define INLINE inline
+#endif
+
+/* These are for configuring the JPEG memory manager. */
+#undef DEFAULT_MAX_MEM
+#undef NO_MKTEMP
+
+#endif /* JPEG_INTERNALS */
+
+#ifdef JPEG_CJPEG_DJPEG
+
+#define BMP_SUPPORTED		/* BMP image file format */
+#define GIF_SUPPORTED		/* GIF image file format */
+#define PPM_SUPPORTED		/* PBMPLUS PPM/PGM image file format */
+#undef RLE_SUPPORTED		/* Utah RLE image file format */
+#define TARGA_SUPPORTED		/* Targa image file format */
+
+#undef TWO_FILE_COMMANDLINE
+#undef NEED_SIGNAL_CATCHER
+#undef DONT_USE_B_MODE
+
+/* Define this if you want percent-done progress reports from cjpeg/djpeg. */
+#undef PROGRESS_REPORT
+
+#endif /* JPEG_CJPEG_DJPEG */
+#endif
+    /* _MSC_VER */
+

src/jpeg/jconfig.vc

@@ -0,0 +1,45 @@
+/* jconfig.vc --- jconfig.h for Microsoft Visual C++ on Windows 95 or NT. */
+/* see jconfig.doc for explanations */
+
+#define HAVE_PROTOTYPES
+#define HAVE_UNSIGNED_CHAR
+#define HAVE_UNSIGNED_SHORT
+/* #define void char */
+/* #define const */
+#undef CHAR_IS_UNSIGNED
+#define HAVE_STDDEF_H
+#define HAVE_STDLIB_H
+#undef NEED_BSD_STRINGS
+#undef NEED_SYS_TYPES_H
+#undef NEED_FAR_POINTERS	/* we presume a 32-bit flat memory model */
+#undef NEED_SHORT_EXTERNAL_NAMES
+#undef INCOMPLETE_TYPES_BROKEN
+
+/* Define "boolean" as unsigned char, not int, per Windows custom */
+#ifndef __RPCNDR_H__		/* don't conflict if rpcndr.h already read */
+typedef unsigned char boolean;
+#endif
+#define HAVE_BOOLEAN		/* prevent jmorecfg.h from redefining it */
+
+
+#ifdef JPEG_INTERNALS
+
+#undef RIGHT_SHIFT_IS_UNSIGNED
+
+#endif /* JPEG_INTERNALS */
+
+#ifdef JPEG_CJPEG_DJPEG
+
+#define BMP_SUPPORTED		/* BMP image file format */
+#define GIF_SUPPORTED		/* GIF image file format */
+#define PPM_SUPPORTED		/* PBMPLUS PPM/PGM image file format */
+#undef RLE_SUPPORTED		/* Utah RLE image file format */
+#define TARGA_SUPPORTED		/* Targa image file format */
+
+#define TWO_FILE_COMMANDLINE	/* optional */
+#define USE_SETMODE		/* Microsoft has setmode() */
+#undef NEED_SIGNAL_CATCHER
+#undef DONT_USE_B_MODE
+#undef PROGRESS_REPORT		/* optional */
+
+#endif /* JPEG_CJPEG_DJPEG */

src/jpeg/jcparam.c

@@ -0,0 +1,610 @@
+/*
+ * jcparam.c
+ *
+ * Copyright (C) 1991-1998, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains optional default-setting code for the JPEG compressor.
+ * Applications do not have to use this file, but those that don't use it
+ * must know a lot more about the innards of the JPEG code.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * Quantization table setup routines
+ */
+
+GLOBAL(void)
+jpeg_add_quant_table (j_compress_ptr cinfo, int which_tbl,
+		      const unsigned int *basic_table,
+		      int scale_factor, boolean force_baseline)
+/* Define a quantization table equal to the basic_table times
+ * a scale factor (given as a percentage).
+ * If force_baseline is TRUE, the computed quantization table entries
+ * are limited to 1..255 for JPEG baseline compatibility.
+ */
+{
+  JQUANT_TBL ** qtblptr;
+  int i;
+  long temp;
+
+  /* Safety check to ensure start_compress not called yet. */
+  if (cinfo->global_state != CSTATE_START)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  if (which_tbl < 0 || which_tbl >= NUM_QUANT_TBLS)
+    ERREXIT1(cinfo, JERR_DQT_INDEX, which_tbl);
+
+  qtblptr = & cinfo->quant_tbl_ptrs[which_tbl];
+
+  if (*qtblptr == NULL)
+    *qtblptr = jpeg_alloc_quant_table((j_common_ptr) cinfo);
+
+  for (i = 0; i < DCTSIZE2; i++) {
+    temp = ((long) basic_table[i] * scale_factor + 50L) / 100L;
+    /* limit the values to the valid range */
+    if (temp <= 0L) temp = 1L;
+    if (temp > 32767L) temp = 32767L; /* max quantizer needed for 12 bits */
+    if (force_baseline && temp > 255L)
+      temp = 255L;		/* limit to baseline range if requested */
+    (*qtblptr)->quantval[i] = (UINT16) temp;
+  }
+
+  /* Initialize sent_table FALSE so table will be written to JPEG file. */
+  (*qtblptr)->sent_table = FALSE;
+}
+
+
+GLOBAL(void)
+jpeg_set_linear_quality (j_compress_ptr cinfo, int scale_factor,
+			 boolean force_baseline)
+/* Set or change the 'quality' (quantization) setting, using default tables
+ * and a straight percentage-scaling quality scale.  In most cases it's better
+ * to use jpeg_set_quality (below); this entry point is provided for
+ * applications that insist on a linear percentage scaling.
+ */
+{
+  /* These are the sample quantization tables given in JPEG spec section K.1.
+   * The spec says that the values given produce "good" quality, and
+   * when divided by 2, "very good" quality.
+   */
+  static const unsigned int std_luminance_quant_tbl[DCTSIZE2] = {
+    16,  11,  10,  16,  24,  40,  51,  61,
+    12,  12,  14,  19,  26,  58,  60,  55,
+    14,  13,  16,  24,  40,  57,  69,  56,
+    14,  17,  22,  29,  51,  87,  80,  62,
+    18,  22,  37,  56,  68, 109, 103,  77,
+    24,  35,  55,  64,  81, 104, 113,  92,
+    49,  64,  78,  87, 103, 121, 120, 101,
+    72,  92,  95,  98, 112, 100, 103,  99
+  };
+  static const unsigned int std_chrominance_quant_tbl[DCTSIZE2] = {
+    17,  18,  24,  47,  99,  99,  99,  99,
+    18,  21,  26,  66,  99,  99,  99,  99,
+    24,  26,  56,  99,  99,  99,  99,  99,
+    47,  66,  99,  99,  99,  99,  99,  99,
+    99,  99,  99,  99,  99,  99,  99,  99,
+    99,  99,  99,  99,  99,  99,  99,  99,
+    99,  99,  99,  99,  99,  99,  99,  99,
+    99,  99,  99,  99,  99,  99,  99,  99
+  };
+
+  /* Set up two quantization tables using the specified scaling */
+  jpeg_add_quant_table(cinfo, 0, std_luminance_quant_tbl,
+		       scale_factor, force_baseline);
+  jpeg_add_quant_table(cinfo, 1, std_chrominance_quant_tbl,
+		       scale_factor, force_baseline);
+}
+
+
+GLOBAL(int)
+jpeg_quality_scaling (int quality)
+/* Convert a user-specified quality rating to a percentage scaling factor
+ * for an underlying quantization table, using our recommended scaling curve.
+ * The input 'quality' factor should be 0 (terrible) to 100 (very good).
+ */
+{
+  /* Safety limit on quality factor.  Convert 0 to 1 to avoid zero divide. */
+  if (quality <= 0) quality = 1;
+  if (quality > 100) quality = 100;
+
+  /* The basic table is used as-is (scaling 100) for a quality of 50.
+   * Qualities 50..100 are converted to scaling percentage 200 - 2*Q;
+   * note that at Q=100 the scaling is 0, which will cause jpeg_add_quant_table
+   * to make all the table entries 1 (hence, minimum quantization loss).
+   * Qualities 1..50 are converted to scaling percentage 5000/Q.
+   */
+  if (quality < 50)
+    quality = 5000 / quality;
+  else
+    quality = 200 - quality*2;
+
+  return quality;
+}
+
+
+GLOBAL(void)
+jpeg_set_quality (j_compress_ptr cinfo, int quality, boolean force_baseline)
+/* Set or change the 'quality' (quantization) setting, using default tables.
+ * This is the standard quality-adjusting entry point for typical user
+ * interfaces; only those who want detailed control over quantization tables
+ * would use the preceding three routines directly.
+ */
+{
+  /* Convert user 0-100 rating to percentage scaling */
+  quality = jpeg_quality_scaling(quality);
+
+  /* Set up standard quality tables */
+  jpeg_set_linear_quality(cinfo, quality, force_baseline);
+}
+
+
+/*
+ * Huffman table setup routines
+ */
+
+LOCAL(void)
+add_huff_table (j_compress_ptr cinfo,
+		JHUFF_TBL **htblptr, const UINT8 *bits, const UINT8 *val)
+/* Define a Huffman table */
+{
+  int nsymbols, len;
+
+  if (*htblptr == NULL)
+    *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
+
+  /* Copy the number-of-symbols-of-each-code-length counts */
+  MEMCOPY((*htblptr)->bits, bits, SIZEOF((*htblptr)->bits));
+
+  /* Validate the counts.  We do this here mainly so we can copy the right
+   * number of symbols from the val[] array, without risking marching off
+   * the end of memory.  jchuff.c will do a more thorough test later.
+   */
+  nsymbols = 0;
+  for (len = 1; len <= 16; len++)
+    nsymbols += bits[len];
+  if (nsymbols < 1 || nsymbols > 256)
+    ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
+
+  MEMCOPY((*htblptr)->huffval, val, nsymbols * SIZEOF(UINT8));
+
+  /* Initialize sent_table FALSE so table will be written to JPEG file. */
+  (*htblptr)->sent_table = FALSE;
+}
+
+
+LOCAL(void)
+std_huff_tables (j_compress_ptr cinfo)
+/* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
+/* IMPORTANT: these are only valid for 8-bit data precision! */
+{
+  static const UINT8 bits_dc_luminance[17] =
+    { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
+  static const UINT8 val_dc_luminance[] =
+    { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
+  
+  static const UINT8 bits_dc_chrominance[17] =
+    { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
+  static const UINT8 val_dc_chrominance[] =
+    { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
+  
+  static const UINT8 bits_ac_luminance[17] =
+    { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
+  static const UINT8 val_ac_luminance[] =
+    { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
+      0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
+      0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
+      0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
+      0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
+      0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
+      0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
+      0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
+      0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
+      0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+      0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
+      0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
+      0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
+      0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
+      0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
+      0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
+      0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
+      0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
+      0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
+      0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
+      0xf9, 0xfa };
+  
+  static const UINT8 bits_ac_chrominance[17] =
+    { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
+  static const UINT8 val_ac_chrominance[] =
+    { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
+      0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
+      0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
+      0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
+      0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
+      0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
+      0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
+      0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
+      0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
+      0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
+      0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
+      0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+      0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
+      0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
+      0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
+      0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
+      0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
+      0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
+      0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
+      0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
+      0xf9, 0xfa };
+  
+  add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[0],
+		 bits_dc_luminance, val_dc_luminance);
+  add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[0],
+		 bits_ac_luminance, val_ac_luminance);
+  add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[1],
+		 bits_dc_chrominance, val_dc_chrominance);
+  add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[1],
+		 bits_ac_chrominance, val_ac_chrominance);
+}
+
+
+/*
+ * Default parameter setup for compression.
+ *
+ * Applications that don't choose to use this routine must do their
+ * own setup of all these parameters.  Alternately, you can call this
+ * to establish defaults and then alter parameters selectively.  This
+ * is the recommended approach since, if we add any new parameters,
+ * your code will still work (they'll be set to reasonable defaults).
+ */
+
+GLOBAL(void)
+jpeg_set_defaults (j_compress_ptr cinfo)
+{
+  int i;
+
+  /* Safety check to ensure start_compress not called yet. */
+  if (cinfo->global_state != CSTATE_START)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  /* Allocate comp_info array large enough for maximum component count.
+   * Array is made permanent in case application wants to compress
+   * multiple images at same param settings.
+   */
+  if (cinfo->comp_info == NULL)
+    cinfo->comp_info = (jpeg_component_info *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+				  MAX_COMPONENTS * SIZEOF(jpeg_component_info));
+
+  /* Initialize everything not dependent on the color space */
+
+  cinfo->data_precision = BITS_IN_JSAMPLE;
+  /* Set up two quantization tables using default quality of 75 */
+  jpeg_set_quality(cinfo, 75, TRUE);
+  /* Set up two Huffman tables */
+  std_huff_tables(cinfo);
+
+  /* Initialize default arithmetic coding conditioning */
+  for (i = 0; i < NUM_ARITH_TBLS; i++) {
+    cinfo->arith_dc_L[i] = 0;
+    cinfo->arith_dc_U[i] = 1;
+    cinfo->arith_ac_K[i] = 5;
+  }
+
+  /* Default is no multiple-scan output */
+  cinfo->scan_info = NULL;
+  cinfo->num_scans = 0;
+
+  /* Expect normal source image, not raw downsampled data */
+  cinfo->raw_data_in = FALSE;
+
+  /* Use Huffman coding, not arithmetic coding, by default */
+  cinfo->arith_code = FALSE;
+
+  /* By default, don't do extra passes to optimize entropy coding */
+  cinfo->optimize_coding = FALSE;
+  /* The standard Huffman tables are only valid for 8-bit data precision.
+   * If the precision is higher, force optimization on so that usable
+   * tables will be computed.  This test can be removed if default tables
+   * are supplied that are valid for the desired precision.
+   */
+  if (cinfo->data_precision > 8)
+    cinfo->optimize_coding = TRUE;
+
+  /* By default, use the simpler non-cosited sampling alignment */
+  cinfo->CCIR601_sampling = FALSE;
+
+  /* No input smoothing */
+  cinfo->smoothing_factor = 0;
+
+  /* DCT algorithm preference */
+  cinfo->dct_method = JDCT_DEFAULT;
+
+  /* No restart markers */
+  cinfo->restart_interval = 0;
+  cinfo->restart_in_rows = 0;
+
+  /* Fill in default JFIF marker parameters.  Note that whether the marker
+   * will actually be written is determined by jpeg_set_colorspace.
+   *
+   * By default, the library emits JFIF version code 1.01.
+   * An application that wants to emit JFIF 1.02 extension markers should set
+   * JFIF_minor_version to 2.  We could probably get away with just defaulting
+   * to 1.02, but there may still be some decoders in use that will complain
+   * about that; saying 1.01 should minimize compatibility problems.
+   */
+  cinfo->JFIF_major_version = 1; /* Default JFIF version = 1.01 */
+  cinfo->JFIF_minor_version = 1;
+  cinfo->density_unit = 0;	/* Pixel size is unknown by default */
+  cinfo->X_density = 1;		/* Pixel aspect ratio is square by default */
+  cinfo->Y_density = 1;
+
+  /* Choose JPEG colorspace based on input space, set defaults accordingly */
+
+  jpeg_default_colorspace(cinfo);
+}
+
+
+/*
+ * Select an appropriate JPEG colorspace for in_color_space.
+ */
+
+GLOBAL(void)
+jpeg_default_colorspace (j_compress_ptr cinfo)
+{
+  switch (cinfo->in_color_space) {
+  case JCS_GRAYSCALE:
+    jpeg_set_colorspace(cinfo, JCS_GRAYSCALE);
+    break;
+  case JCS_RGB:
+    jpeg_set_colorspace(cinfo, JCS_YCbCr);
+    break;
+  case JCS_YCbCr:
+    jpeg_set_colorspace(cinfo, JCS_YCbCr);
+    break;
+  case JCS_CMYK:
+    jpeg_set_colorspace(cinfo, JCS_CMYK); /* By default, no translation */
+    break;
+  case JCS_YCCK:
+    jpeg_set_colorspace(cinfo, JCS_YCCK);
+    break;
+  case JCS_UNKNOWN:
+    jpeg_set_colorspace(cinfo, JCS_UNKNOWN);
+    break;
+  default:
+    ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+  }
+}
+
+
+/*
+ * Set the JPEG colorspace, and choose colorspace-dependent default values.
+ */
+
+GLOBAL(void)
+jpeg_set_colorspace (j_compress_ptr cinfo, J_COLOR_SPACE colorspace)
+{
+  jpeg_component_info * compptr;
+  int ci;
+
+#define SET_COMP(index,id,hsamp,vsamp,quant,dctbl,actbl)  \
+  (compptr = &cinfo->comp_info[index], \
+   compptr->component_id = (id), \
+   compptr->h_samp_factor = (hsamp), \
+   compptr->v_samp_factor = (vsamp), \
+   compptr->quant_tbl_no = (quant), \
+   compptr->dc_tbl_no = (dctbl), \
+   compptr->ac_tbl_no = (actbl) )
+
+  /* Safety check to ensure start_compress not called yet. */
+  if (cinfo->global_state != CSTATE_START)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  /* For all colorspaces, we use Q and Huff tables 0 for luminance components,
+   * tables 1 for chrominance components.
+   */
+
+  cinfo->jpeg_color_space = colorspace;
+
+  cinfo->write_JFIF_header = FALSE; /* No marker for non-JFIF colorspaces */
+  cinfo->write_Adobe_marker = FALSE; /* write no Adobe marker by default */
+
+  switch (colorspace) {
+  case JCS_GRAYSCALE:
+    cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
+    cinfo->num_components = 1;
+    /* JFIF specifies component ID 1 */
+    SET_COMP(0, 1, 1,1, 0, 0,0);
+    break;
+  case JCS_RGB:
+    cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag RGB */
+    cinfo->num_components = 3;
+    SET_COMP(0, 0x52 /* 'R' */, 1,1, 0, 0,0);
+    SET_COMP(1, 0x47 /* 'G' */, 1,1, 0, 0,0);
+    SET_COMP(2, 0x42 /* 'B' */, 1,1, 0, 0,0);
+    break;
+  case JCS_YCbCr:
+    cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
+    cinfo->num_components = 3;
+    /* JFIF specifies component IDs 1,2,3 */
+    /* We default to 2x2 subsamples of chrominance */
+    SET_COMP(0, 1, 2,2, 0, 0,0);
+    SET_COMP(1, 2, 1,1, 1, 1,1);
+    SET_COMP(2, 3, 1,1, 1, 1,1);
+    break;
+  case JCS_CMYK:
+    cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag CMYK */
+    cinfo->num_components = 4;
+    SET_COMP(0, 0x43 /* 'C' */, 1,1, 0, 0,0);
+    SET_COMP(1, 0x4D /* 'M' */, 1,1, 0, 0,0);
+    SET_COMP(2, 0x59 /* 'Y' */, 1,1, 0, 0,0);
+    SET_COMP(3, 0x4B /* 'K' */, 1,1, 0, 0,0);
+    break;
+  case JCS_YCCK:
+    cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag YCCK */
+    cinfo->num_components = 4;
+    SET_COMP(0, 1, 2,2, 0, 0,0);
+    SET_COMP(1, 2, 1,1, 1, 1,1);
+    SET_COMP(2, 3, 1,1, 1, 1,1);
+    SET_COMP(3, 4, 2,2, 0, 0,0);
+    break;
+  case JCS_UNKNOWN:
+    cinfo->num_components = cinfo->input_components;
+    if (cinfo->num_components < 1 || cinfo->num_components > MAX_COMPONENTS)
+      ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
+	       MAX_COMPONENTS);
+    for (ci = 0; ci < cinfo->num_components; ci++) {
+      SET_COMP(ci, ci, 1,1, 0, 0,0);
+    }
+    break;
+  default:
+    ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+  }
+}
+
+
+#ifdef C_PROGRESSIVE_SUPPORTED
+
+LOCAL(jpeg_scan_info *)
+fill_a_scan (jpeg_scan_info * scanptr, int ci,
+	     int Ss, int Se, int Ah, int Al)
+/* Support routine: generate one scan for specified component */
+{
+  scanptr->comps_in_scan = 1;
+  scanptr->component_index[0] = ci;
+  scanptr->Ss = Ss;
+  scanptr->Se = Se;
+  scanptr->Ah = Ah;
+  scanptr->Al = Al;
+  scanptr++;
+  return scanptr;
+}
+
+LOCAL(jpeg_scan_info *)
+fill_scans (jpeg_scan_info * scanptr, int ncomps,
+	    int Ss, int Se, int Ah, int Al)
+/* Support routine: generate one scan for each component */
+{
+  int ci;
+
+  for (ci = 0; ci < ncomps; ci++) {
+    scanptr->comps_in_scan = 1;
+    scanptr->component_index[0] = ci;
+    scanptr->Ss = Ss;
+    scanptr->Se = Se;
+    scanptr->Ah = Ah;
+    scanptr->Al = Al;
+    scanptr++;
+  }
+  return scanptr;
+}
+
+LOCAL(jpeg_scan_info *)
+fill_dc_scans (jpeg_scan_info * scanptr, int ncomps, int Ah, int Al)
+/* Support routine: generate interleaved DC scan if possible, else N scans */
+{
+  int ci;
+
+  if (ncomps <= MAX_COMPS_IN_SCAN) {
+    /* Single interleaved DC scan */
+    scanptr->comps_in_scan = ncomps;
+    for (ci = 0; ci < ncomps; ci++)
+      scanptr->component_index[ci] = ci;
+    scanptr->Ss = scanptr->Se = 0;
+    scanptr->Ah = Ah;
+    scanptr->Al = Al;
+    scanptr++;
+  } else {
+    /* Noninterleaved DC scan for each component */
+    scanptr = fill_scans(scanptr, ncomps, 0, 0, Ah, Al);
+  }
+  return scanptr;
+}
+
+
+/*
+ * Create a recommended progressive-JPEG script.
+ * cinfo->num_components and cinfo->jpeg_color_space must be correct.
+ */
+
+GLOBAL(void)
+jpeg_simple_progression (j_compress_ptr cinfo)
+{
+  int ncomps = cinfo->num_components;
+  int nscans;
+  jpeg_scan_info * scanptr;
+
+  /* Safety check to ensure start_compress not called yet. */
+  if (cinfo->global_state != CSTATE_START)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  /* Figure space needed for script.  Calculation must match code below! */
+  if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
+    /* Custom script for YCbCr color images. */
+    nscans = 10;
+  } else {
+    /* All-purpose script for other color spaces. */
+    if (ncomps > MAX_COMPS_IN_SCAN)
+      nscans = 6 * ncomps;	/* 2 DC + 4 AC scans per component */
+    else
+      nscans = 2 + 4 * ncomps;	/* 2 DC scans; 4 AC scans per component */
+  }
+
+  /* Allocate space for script.
+   * We need to put it in the permanent pool in case the application performs
+   * multiple compressions without changing the settings.  To avoid a memory
+   * leak if jpeg_simple_progression is called repeatedly for the same JPEG
+   * object, we try to re-use previously allocated space, and we allocate
+   * enough space to handle YCbCr even if initially asked for grayscale.
+   */
+  if (cinfo->script_space == NULL || cinfo->script_space_size < nscans) {
+    cinfo->script_space_size = MAX(nscans, 10);
+    cinfo->script_space = (jpeg_scan_info *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+			cinfo->script_space_size * SIZEOF(jpeg_scan_info));
+  }
+  scanptr = cinfo->script_space;
+  cinfo->scan_info = scanptr;
+  cinfo->num_scans = nscans;
+
+  if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
+    /* Custom script for YCbCr color images. */
+    /* Initial DC scan */
+    scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
+    /* Initial AC scan: get some luma data out in a hurry */
+    scanptr = fill_a_scan(scanptr, 0, 1, 5, 0, 2);
+    /* Chroma data is too small to be worth expending many scans on */
+    scanptr = fill_a_scan(scanptr, 2, 1, 63, 0, 1);
+    scanptr = fill_a_scan(scanptr, 1, 1, 63, 0, 1);
+    /* Complete spectral selection for luma AC */
+    scanptr = fill_a_scan(scanptr, 0, 6, 63, 0, 2);
+    /* Refine next bit of luma AC */
+    scanptr = fill_a_scan(scanptr, 0, 1, 63, 2, 1);
+    /* Finish DC successive approximation */
+    scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
+    /* Finish AC successive approximation */
+    scanptr = fill_a_scan(scanptr, 2, 1, 63, 1, 0);
+    scanptr = fill_a_scan(scanptr, 1, 1, 63, 1, 0);
+    /* Luma bottom bit comes last since it's usually largest scan */
+    scanptr = fill_a_scan(scanptr, 0, 1, 63, 1, 0);
+  } else {
+    /* All-purpose script for other color spaces. */
+    /* Successive approximation first pass */
+    scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
+    scanptr = fill_scans(scanptr, ncomps, 1, 5, 0, 2);
+    scanptr = fill_scans(scanptr, ncomps, 6, 63, 0, 2);
+    /* Successive approximation second pass */
+    scanptr = fill_scans(scanptr, ncomps, 1, 63, 2, 1);
+    /* Successive approximation final pass */
+    scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
+    scanptr = fill_scans(scanptr, ncomps, 1, 63, 1, 0);
+  }
+}
+
+#endif /* C_PROGRESSIVE_SUPPORTED */

src/jpeg/jcphuff.c

@@ -0,0 +1,833 @@
+/*
+ * jcphuff.c
+ *
+ * Copyright (C) 1995-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains Huffman entropy encoding routines for progressive JPEG.
+ *
+ * We do not support output suspension in this module, since the library
+ * currently does not allow multiple-scan files to be written with output
+ * suspension.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jchuff.h"		/* Declarations shared with jchuff.c */
+
+#ifdef C_PROGRESSIVE_SUPPORTED
+
+/* Expanded entropy encoder object for progressive Huffman encoding. */
+
+typedef struct {
+  struct jpeg_entropy_encoder pub; /* public fields */
+
+  /* Mode flag: TRUE for optimization, FALSE for actual data output */
+  boolean gather_statistics;
+
+  /* Bit-level coding status.
+   * next_output_byte/free_in_buffer are local copies of cinfo->dest fields.
+   */
+  JOCTET * next_output_byte;	/* => next byte to write in buffer */
+  size_t free_in_buffer;	/* # of byte spaces remaining in buffer */
+  INT32 put_buffer;		/* current bit-accumulation buffer */
+  int put_bits;			/* # of bits now in it */
+  j_compress_ptr cinfo;		/* link to cinfo (needed for dump_buffer) */
+
+  /* Coding status for DC components */
+  int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
+
+  /* Coding status for AC components */
+  int ac_tbl_no;		/* the table number of the single component */
+  unsigned int EOBRUN;		/* run length of EOBs */
+  unsigned int BE;		/* # of buffered correction bits before MCU */
+  char * bit_buffer;		/* buffer for correction bits (1 per char) */
+  /* packing correction bits tightly would save some space but cost time... */
+
+  unsigned int restarts_to_go;	/* MCUs left in this restart interval */
+  int next_restart_num;		/* next restart number to write (0-7) */
+
+  /* Pointers to derived tables (these workspaces have image lifespan).
+   * Since any one scan codes only DC or only AC, we only need one set
+   * of tables, not one for DC and one for AC.
+   */
+  c_derived_tbl * derived_tbls[NUM_HUFF_TBLS];
+
+  /* Statistics tables for optimization; again, one set is enough */
+  long * count_ptrs[NUM_HUFF_TBLS];
+} phuff_entropy_encoder;
+
+typedef phuff_entropy_encoder * phuff_entropy_ptr;
+
+/* MAX_CORR_BITS is the number of bits the AC refinement correction-bit
+ * buffer can hold.  Larger sizes may slightly improve compression, but
+ * 1000 is already well into the realm of overkill.
+ * The minimum safe size is 64 bits.
+ */
+
+#define MAX_CORR_BITS  1000	/* Max # of correction bits I can buffer */
+
+/* IRIGHT_SHIFT is like RIGHT_SHIFT, but works on int rather than INT32.
+ * We assume that int right shift is unsigned if INT32 right shift is,
+ * which should be safe.
+ */
+
+#ifdef RIGHT_SHIFT_IS_UNSIGNED
+#define ISHIFT_TEMPS	int ishift_temp;
+#define IRIGHT_SHIFT(x,shft)  \
+	((ishift_temp = (x)) < 0 ? \
+	 (ishift_temp >> (shft)) | ((~0) << (16-(shft))) : \
+	 (ishift_temp >> (shft)))
+#else
+#define ISHIFT_TEMPS
+#define IRIGHT_SHIFT(x,shft)	((x) >> (shft))
+#endif
+
+/* Forward declarations */
+METHODDEF(boolean) encode_mcu_DC_first JPP((j_compress_ptr cinfo,
+					    JBLOCKROW *MCU_data));
+METHODDEF(boolean) encode_mcu_AC_first JPP((j_compress_ptr cinfo,
+					    JBLOCKROW *MCU_data));
+METHODDEF(boolean) encode_mcu_DC_refine JPP((j_compress_ptr cinfo,
+					     JBLOCKROW *MCU_data));
+METHODDEF(boolean) encode_mcu_AC_refine JPP((j_compress_ptr cinfo,
+					     JBLOCKROW *MCU_data));
+METHODDEF(void) finish_pass_phuff JPP((j_compress_ptr cinfo));
+METHODDEF(void) finish_pass_gather_phuff JPP((j_compress_ptr cinfo));
+
+
+/*
+ * Initialize for a Huffman-compressed scan using progressive JPEG.
+ */
+
+METHODDEF(void)
+start_pass_phuff (j_compress_ptr cinfo, boolean gather_statistics)
+{  
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+  boolean is_DC_band;
+  int ci, tbl;
+  jpeg_component_info * compptr;
+
+  entropy->cinfo = cinfo;
+  entropy->gather_statistics = gather_statistics;
+
+  is_DC_band = (cinfo->Ss == 0);
+
+  /* We assume jcmaster.c already validated the scan parameters. */
+
+  /* Select execution routines */
+  if (cinfo->Ah == 0) {
+    if (is_DC_band)
+      entropy->pub.encode_mcu = encode_mcu_DC_first;
+    else
+      entropy->pub.encode_mcu = encode_mcu_AC_first;
+  } else {
+    if (is_DC_band)
+      entropy->pub.encode_mcu = encode_mcu_DC_refine;
+    else {
+      entropy->pub.encode_mcu = encode_mcu_AC_refine;
+      /* AC refinement needs a correction bit buffer */
+      if (entropy->bit_buffer == NULL)
+	entropy->bit_buffer = (char *)
+	  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				      MAX_CORR_BITS * SIZEOF(char));
+    }
+  }
+  if (gather_statistics)
+    entropy->pub.finish_pass = finish_pass_gather_phuff;
+  else
+    entropy->pub.finish_pass = finish_pass_phuff;
+
+  /* Only DC coefficients may be interleaved, so cinfo->comps_in_scan = 1
+   * for AC coefficients.
+   */
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    /* Initialize DC predictions to 0 */
+    entropy->last_dc_val[ci] = 0;
+    /* Get table index */
+    if (is_DC_band) {
+      if (cinfo->Ah != 0)	/* DC refinement needs no table */
+	continue;
+      tbl = compptr->dc_tbl_no;
+    } else {
+      entropy->ac_tbl_no = tbl = compptr->ac_tbl_no;
+    }
+    if (gather_statistics) {
+      /* Check for invalid table index */
+      /* (make_c_derived_tbl does this in the other path) */
+      if (tbl < 0 || tbl >= NUM_HUFF_TBLS)
+        ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tbl);
+      /* Allocate and zero the statistics tables */
+      /* Note that jpeg_gen_optimal_table expects 257 entries in each table! */
+      if (entropy->count_ptrs[tbl] == NULL)
+	entropy->count_ptrs[tbl] = (long *)
+	  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				      257 * SIZEOF(long));
+      MEMZERO(entropy->count_ptrs[tbl], 257 * SIZEOF(long));
+    } else {
+      /* Compute derived values for Huffman table */
+      /* We may do this more than once for a table, but it's not expensive */
+      jpeg_make_c_derived_tbl(cinfo, is_DC_band, tbl,
+			      & entropy->derived_tbls[tbl]);
+    }
+  }
+
+  /* Initialize AC stuff */
+  entropy->EOBRUN = 0;
+  entropy->BE = 0;
+
+  /* Initialize bit buffer to empty */
+  entropy->put_buffer = 0;
+  entropy->put_bits = 0;
+
+  /* Initialize restart stuff */
+  entropy->restarts_to_go = cinfo->restart_interval;
+  entropy->next_restart_num = 0;
+}
+
+
+/* Outputting bytes to the file.
+ * NB: these must be called only when actually outputting,
+ * that is, entropy->gather_statistics == FALSE.
+ */
+
+/* Emit a byte */
+#define emit_byte(entropy,val)  \
+	{ *(entropy)->next_output_byte++ = (JOCTET) (val);  \
+	  if (--(entropy)->free_in_buffer == 0)  \
+	    dump_buffer(entropy); }
+
+
+LOCAL(void)
+dump_buffer (phuff_entropy_ptr entropy)
+/* Empty the output buffer; we do not support suspension in this module. */
+{
+  struct jpeg_destination_mgr * dest = entropy->cinfo->dest;
+
+  if (! (*dest->empty_output_buffer) (entropy->cinfo))
+    ERREXIT(entropy->cinfo, JERR_CANT_SUSPEND);
+  /* After a successful buffer dump, must reset buffer pointers */
+  entropy->next_output_byte = dest->next_output_byte;
+  entropy->free_in_buffer = dest->free_in_buffer;
+}
+
+
+/* Outputting bits to the file */
+
+/* Only the right 24 bits of put_buffer are used; the valid bits are
+ * left-justified in this part.  At most 16 bits can be passed to emit_bits
+ * in one call, and we never retain more than 7 bits in put_buffer
+ * between calls, so 24 bits are sufficient.
+ */
+
+INLINE
+LOCAL(void)
+emit_bits (phuff_entropy_ptr entropy, unsigned int code, int size)
+/* Emit some bits, unless we are in gather mode */
+{
+  /* This routine is heavily used, so it's worth coding tightly. */
+  register INT32 put_buffer = (INT32) code;
+  register int put_bits = entropy->put_bits;
+
+  /* if size is 0, caller used an invalid Huffman table entry */
+  if (size == 0)
+    ERREXIT(entropy->cinfo, JERR_HUFF_MISSING_CODE);
+
+  if (entropy->gather_statistics)
+    return;			/* do nothing if we're only getting stats */
+
+  put_buffer &= (((INT32) 1)<<size) - 1; /* mask off any extra bits in code */
+  
+  put_bits += size;		/* new number of bits in buffer */
+  
+  put_buffer <<= 24 - put_bits; /* align incoming bits */
+
+  put_buffer |= entropy->put_buffer; /* and merge with old buffer contents */
+
+  while (put_bits >= 8) {
+    int c = (int) ((put_buffer >> 16) & 0xFF);
+    
+    emit_byte(entropy, c);
+    if (c == 0xFF) {		/* need to stuff a zero byte? */
+      emit_byte(entropy, 0);
+    }
+    put_buffer <<= 8;
+    put_bits -= 8;
+  }
+
+  entropy->put_buffer = put_buffer; /* update variables */
+  entropy->put_bits = put_bits;
+}
+
+
+LOCAL(void)
+flush_bits (phuff_entropy_ptr entropy)
+{
+  emit_bits(entropy, 0x7F, 7); /* fill any partial byte with ones */
+  entropy->put_buffer = 0;     /* and reset bit-buffer to empty */
+  entropy->put_bits = 0;
+}
+
+
+/*
+ * Emit (or just count) a Huffman symbol.
+ */
+
+INLINE
+LOCAL(void)
+emit_symbol (phuff_entropy_ptr entropy, int tbl_no, int symbol)
+{
+  if (entropy->gather_statistics)
+    entropy->count_ptrs[tbl_no][symbol]++;
+  else {
+    c_derived_tbl * tbl = entropy->derived_tbls[tbl_no];
+    emit_bits(entropy, tbl->ehufco[symbol], tbl->ehufsi[symbol]);
+  }
+}
+
+
+/*
+ * Emit bits from a correction bit buffer.
+ */
+
+LOCAL(void)
+emit_buffered_bits (phuff_entropy_ptr entropy, char * bufstart,
+		    unsigned int nbits)
+{
+  if (entropy->gather_statistics)
+    return;			/* no real work */
+
+  while (nbits > 0) {
+    emit_bits(entropy, (unsigned int) (*bufstart), 1);
+    bufstart++;
+    nbits--;
+  }
+}
+
+
+/*
+ * Emit any pending EOBRUN symbol.
+ */
+
+LOCAL(void)
+emit_eobrun (phuff_entropy_ptr entropy)
+{
+  register int temp, nbits;
+
+  if (entropy->EOBRUN > 0) {	/* if there is any pending EOBRUN */
+    temp = entropy->EOBRUN;
+    nbits = 0;
+    while ((temp >>= 1))
+      nbits++;
+    /* safety check: shouldn't happen given limited correction-bit buffer */
+    if (nbits > 14)
+      ERREXIT(entropy->cinfo, JERR_HUFF_MISSING_CODE);
+
+    emit_symbol(entropy, entropy->ac_tbl_no, nbits << 4);
+    if (nbits)
+      emit_bits(entropy, entropy->EOBRUN, nbits);
+
+    entropy->EOBRUN = 0;
+
+    /* Emit any buffered correction bits */
+    emit_buffered_bits(entropy, entropy->bit_buffer, entropy->BE);
+    entropy->BE = 0;
+  }
+}
+
+
+/*
+ * Emit a restart marker & resynchronize predictions.
+ */
+
+LOCAL(void)
+emit_restart (phuff_entropy_ptr entropy, int restart_num)
+{
+  int ci;
+
+  emit_eobrun(entropy);
+
+  if (! entropy->gather_statistics) {
+    flush_bits(entropy);
+    emit_byte(entropy, 0xFF);
+    emit_byte(entropy, JPEG_RST0 + restart_num);
+  }
+
+  if (entropy->cinfo->Ss == 0) {
+    /* Re-initialize DC predictions to 0 */
+    for (ci = 0; ci < entropy->cinfo->comps_in_scan; ci++)
+      entropy->last_dc_val[ci] = 0;
+  } else {
+    /* Re-initialize all AC-related fields to 0 */
+    entropy->EOBRUN = 0;
+    entropy->BE = 0;
+  }
+}
+
+
+/*
+ * MCU encoding for DC initial scan (either spectral selection,
+ * or first pass of successive approximation).
+ */
+
+METHODDEF(boolean)
+encode_mcu_DC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+  register int temp, temp2;
+  register int nbits;
+  int blkn, ci;
+  int Al = cinfo->Al;
+  JBLOCKROW block;
+  jpeg_component_info * compptr;
+  ISHIFT_TEMPS
+
+  entropy->next_output_byte = cinfo->dest->next_output_byte;
+  entropy->free_in_buffer = cinfo->dest->free_in_buffer;
+
+  /* Emit restart marker if needed */
+  if (cinfo->restart_interval)
+    if (entropy->restarts_to_go == 0)
+      emit_restart(entropy, entropy->next_restart_num);
+
+  /* Encode the MCU data blocks */
+  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+    block = MCU_data[blkn];
+    ci = cinfo->MCU_membership[blkn];
+    compptr = cinfo->cur_comp_info[ci];
+
+    /* Compute the DC value after the required point transform by Al.
+     * This is simply an arithmetic right shift.
+     */
+    temp2 = IRIGHT_SHIFT((int) ((*block)[0]), Al);
+
+    /* DC differences are figured on the point-transformed values. */
+    temp = temp2 - entropy->last_dc_val[ci];
+    entropy->last_dc_val[ci] = temp2;
+
+    /* Encode the DC coefficient difference per section G.1.2.1 */
+    temp2 = temp;
+    if (temp < 0) {
+      temp = -temp;		/* temp is abs value of input */
+      /* For a negative input, want temp2 = bitwise complement of abs(input) */
+      /* This code assumes we are on a two's complement machine */
+      temp2--;
+    }
+    
+    /* Find the number of bits needed for the magnitude of the coefficient */
+    nbits = 0;
+    while (temp) {
+      nbits++;
+      temp >>= 1;
+    }
+    /* Check for out-of-range coefficient values.
+     * Since we're encoding a difference, the range limit is twice as much.
+     */
+    if (nbits > MAX_COEF_BITS+1)
+      ERREXIT(cinfo, JERR_BAD_DCT_COEF);
+    
+    /* Count/emit the Huffman-coded symbol for the number of bits */
+    emit_symbol(entropy, compptr->dc_tbl_no, nbits);
+    
+    /* Emit that number of bits of the value, if positive, */
+    /* or the complement of its magnitude, if negative. */
+    if (nbits)			/* emit_bits rejects calls with size 0 */
+      emit_bits(entropy, (unsigned int) temp2, nbits);
+  }
+
+  cinfo->dest->next_output_byte = entropy->next_output_byte;
+  cinfo->dest->free_in_buffer = entropy->free_in_buffer;
+
+  /* Update restart-interval state too */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0) {
+      entropy->restarts_to_go = cinfo->restart_interval;
+      entropy->next_restart_num++;
+      entropy->next_restart_num &= 7;
+    }
+    entropy->restarts_to_go--;
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * MCU encoding for AC initial scan (either spectral selection,
+ * or first pass of successive approximation).
+ */
+
+METHODDEF(boolean)
+encode_mcu_AC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+  register int temp, temp2;
+  register int nbits;
+  register int r, k;
+  int Se = cinfo->Se;
+  int Al = cinfo->Al;
+  JBLOCKROW block;
+
+  entropy->next_output_byte = cinfo->dest->next_output_byte;
+  entropy->free_in_buffer = cinfo->dest->free_in_buffer;
+
+  /* Emit restart marker if needed */
+  if (cinfo->restart_interval)
+    if (entropy->restarts_to_go == 0)
+      emit_restart(entropy, entropy->next_restart_num);
+
+  /* Encode the MCU data block */
+  block = MCU_data[0];
+
+  /* Encode the AC coefficients per section G.1.2.2, fig. G.3 */
+  
+  r = 0;			/* r = run length of zeros */
+   
+  for (k = cinfo->Ss; k <= Se; k++) {
+    if ((temp = (*block)[jpeg_natural_order[k]]) == 0) {
+      r++;
+      continue;
+    }
+    /* We must apply the point transform by Al.  For AC coefficients this
+     * is an integer division with rounding towards 0.  To do this portably
+     * in C, we shift after obtaining the absolute value; so the code is
+     * interwoven with finding the abs value (temp) and output bits (temp2).
+     */
+    if (temp < 0) {
+      temp = -temp;		/* temp is abs value of input */
+      temp >>= Al;		/* apply the point transform */
+      /* For a negative coef, want temp2 = bitwise complement of abs(coef) */
+      temp2 = ~temp;
+    } else {
+      temp >>= Al;		/* apply the point transform */
+      temp2 = temp;
+    }
+    /* Watch out for case that nonzero coef is zero after point transform */
+    if (temp == 0) {
+      r++;
+      continue;
+    }
+
+    /* Emit any pending EOBRUN */
+    if (entropy->EOBRUN > 0)
+      emit_eobrun(entropy);
+    /* if run length > 15, must emit special run-length-16 codes (0xF0) */
+    while (r > 15) {
+      emit_symbol(entropy, entropy->ac_tbl_no, 0xF0);
+      r -= 16;
+    }
+
+    /* Find the number of bits needed for the magnitude of the coefficient */
+    nbits = 1;			/* there must be at least one 1 bit */
+    while ((temp >>= 1))
+      nbits++;
+    /* Check for out-of-range coefficient values */
+    if (nbits > MAX_COEF_BITS)
+      ERREXIT(cinfo, JERR_BAD_DCT_COEF);
+
+    /* Count/emit Huffman symbol for run length / number of bits */
+    emit_symbol(entropy, entropy->ac_tbl_no, (r << 4) + nbits);
+
+    /* Emit that number of bits of the value, if positive, */
+    /* or the complement of its magnitude, if negative. */
+    emit_bits(entropy, (unsigned int) temp2, nbits);
+
+    r = 0;			/* reset zero run length */
+  }
+
+  if (r > 0) {			/* If there are trailing zeroes, */
+    entropy->EOBRUN++;		/* count an EOB */
+    if (entropy->EOBRUN == 0x7FFF)
+      emit_eobrun(entropy);	/* force it out to avoid overflow */
+  }
+
+  cinfo->dest->next_output_byte = entropy->next_output_byte;
+  cinfo->dest->free_in_buffer = entropy->free_in_buffer;
+
+  /* Update restart-interval state too */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0) {
+      entropy->restarts_to_go = cinfo->restart_interval;
+      entropy->next_restart_num++;
+      entropy->next_restart_num &= 7;
+    }
+    entropy->restarts_to_go--;
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * MCU encoding for DC successive approximation refinement scan.
+ * Note: we assume such scans can be multi-component, although the spec
+ * is not very clear on the point.
+ */
+
+METHODDEF(boolean)
+encode_mcu_DC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+  register int temp;
+  int blkn;
+  int Al = cinfo->Al;
+  JBLOCKROW block;
+
+  entropy->next_output_byte = cinfo->dest->next_output_byte;
+  entropy->free_in_buffer = cinfo->dest->free_in_buffer;
+
+  /* Emit restart marker if needed */
+  if (cinfo->restart_interval)
+    if (entropy->restarts_to_go == 0)
+      emit_restart(entropy, entropy->next_restart_num);
+
+  /* Encode the MCU data blocks */
+  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+    block = MCU_data[blkn];
+
+    /* We simply emit the Al'th bit of the DC coefficient value. */
+    temp = (*block)[0];
+    emit_bits(entropy, (unsigned int) (temp >> Al), 1);
+  }
+
+  cinfo->dest->next_output_byte = entropy->next_output_byte;
+  cinfo->dest->free_in_buffer = entropy->free_in_buffer;
+
+  /* Update restart-interval state too */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0) {
+      entropy->restarts_to_go = cinfo->restart_interval;
+      entropy->next_restart_num++;
+      entropy->next_restart_num &= 7;
+    }
+    entropy->restarts_to_go--;
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * MCU encoding for AC successive approximation refinement scan.
+ */
+
+METHODDEF(boolean)
+encode_mcu_AC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+  register int temp;
+  register int r, k;
+  int EOB;
+  char *BR_buffer;
+  unsigned int BR;
+  int Se = cinfo->Se;
+  int Al = cinfo->Al;
+  JBLOCKROW block;
+  int absvalues[DCTSIZE2];
+
+  entropy->next_output_byte = cinfo->dest->next_output_byte;
+  entropy->free_in_buffer = cinfo->dest->free_in_buffer;
+
+  /* Emit restart marker if needed */
+  if (cinfo->restart_interval)
+    if (entropy->restarts_to_go == 0)
+      emit_restart(entropy, entropy->next_restart_num);
+
+  /* Encode the MCU data block */
+  block = MCU_data[0];
+
+  /* It is convenient to make a pre-pass to determine the transformed
+   * coefficients' absolute values and the EOB position.
+   */
+  EOB = 0;
+  for (k = cinfo->Ss; k <= Se; k++) {
+    temp = (*block)[jpeg_natural_order[k]];
+    /* We must apply the point transform by Al.  For AC coefficients this
+     * is an integer division with rounding towards 0.  To do this portably
+     * in C, we shift after obtaining the absolute value.
+     */
+    if (temp < 0)
+      temp = -temp;		/* temp is abs value of input */
+    temp >>= Al;		/* apply the point transform */
+    absvalues[k] = temp;	/* save abs value for main pass */
+    if (temp == 1)
+      EOB = k;			/* EOB = index of last newly-nonzero coef */
+  }
+
+  /* Encode the AC coefficients per section G.1.2.3, fig. G.7 */
+  
+  r = 0;			/* r = run length of zeros */
+  BR = 0;			/* BR = count of buffered bits added now */
+  BR_buffer = entropy->bit_buffer + entropy->BE; /* Append bits to buffer */
+
+  for (k = cinfo->Ss; k <= Se; k++) {
+    if ((temp = absvalues[k]) == 0) {
+      r++;
+      continue;
+    }
+
+    /* Emit any required ZRLs, but not if they can be folded into EOB */
+    while (r > 15 && k <= EOB) {
+      /* emit any pending EOBRUN and the BE correction bits */
+      emit_eobrun(entropy);
+      /* Emit ZRL */
+      emit_symbol(entropy, entropy->ac_tbl_no, 0xF0);
+      r -= 16;
+      /* Emit buffered correction bits that must be associated with ZRL */
+      emit_buffered_bits(entropy, BR_buffer, BR);
+      BR_buffer = entropy->bit_buffer; /* BE bits are gone now */
+      BR = 0;
+    }
+
+    /* If the coef was previously nonzero, it only needs a correction bit.
+     * NOTE: a straight translation of the spec's figure G.7 would suggest
+     * that we also need to test r > 15.  But if r > 15, we can only get here
+     * if k > EOB, which implies that this coefficient is not 1.
+     */
+    if (temp > 1) {
+      /* The correction bit is the next bit of the absolute value. */
+      BR_buffer[BR++] = (char) (temp & 1);
+      continue;
+    }
+
+    /* Emit any pending EOBRUN and the BE correction bits */
+    emit_eobrun(entropy);
+
+    /* Count/emit Huffman symbol for run length / number of bits */
+    emit_symbol(entropy, entropy->ac_tbl_no, (r << 4) + 1);
+
+    /* Emit output bit for newly-nonzero coef */
+    temp = ((*block)[jpeg_natural_order[k]] < 0) ? 0 : 1;
+    emit_bits(entropy, (unsigned int) temp, 1);
+
+    /* Emit buffered correction bits that must be associated with this code */
+    emit_buffered_bits(entropy, BR_buffer, BR);
+    BR_buffer = entropy->bit_buffer; /* BE bits are gone now */
+    BR = 0;
+    r = 0;			/* reset zero run length */
+  }
+
+  if (r > 0 || BR > 0) {	/* If there are trailing zeroes, */
+    entropy->EOBRUN++;		/* count an EOB */
+    entropy->BE += BR;		/* concat my correction bits to older ones */
+    /* We force out the EOB if we risk either:
+     * 1. overflow of the EOB counter;
+     * 2. overflow of the correction bit buffer during the next MCU.
+     */
+    if (entropy->EOBRUN == 0x7FFF || entropy->BE > (MAX_CORR_BITS-DCTSIZE2+1))
+      emit_eobrun(entropy);
+  }
+
+  cinfo->dest->next_output_byte = entropy->next_output_byte;
+  cinfo->dest->free_in_buffer = entropy->free_in_buffer;
+
+  /* Update restart-interval state too */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0) {
+      entropy->restarts_to_go = cinfo->restart_interval;
+      entropy->next_restart_num++;
+      entropy->next_restart_num &= 7;
+    }
+    entropy->restarts_to_go--;
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * Finish up at the end of a Huffman-compressed progressive scan.
+ */
+
+METHODDEF(void)
+finish_pass_phuff (j_compress_ptr cinfo)
+{   
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+
+  entropy->next_output_byte = cinfo->dest->next_output_byte;
+  entropy->free_in_buffer = cinfo->dest->free_in_buffer;
+
+  /* Flush out any buffered data */
+  emit_eobrun(entropy);
+  flush_bits(entropy);
+
+  cinfo->dest->next_output_byte = entropy->next_output_byte;
+  cinfo->dest->free_in_buffer = entropy->free_in_buffer;
+}
+
+
+/*
+ * Finish up a statistics-gathering pass and create the new Huffman tables.
+ */
+
+METHODDEF(void)
+finish_pass_gather_phuff (j_compress_ptr cinfo)
+{
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+  boolean is_DC_band;
+  int ci, tbl;
+  jpeg_component_info * compptr;
+  JHUFF_TBL **htblptr;
+  boolean did[NUM_HUFF_TBLS];
+
+  /* Flush out buffered data (all we care about is counting the EOB symbol) */
+  emit_eobrun(entropy);
+
+  is_DC_band = (cinfo->Ss == 0);
+
+  /* It's important not to apply jpeg_gen_optimal_table more than once
+   * per table, because it clobbers the input frequency counts!
+   */
+  MEMZERO(did, SIZEOF(did));
+
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    if (is_DC_band) {
+      if (cinfo->Ah != 0)	/* DC refinement needs no table */
+	continue;
+      tbl = compptr->dc_tbl_no;
+    } else {
+      tbl = compptr->ac_tbl_no;
+    }
+    if (! did[tbl]) {
+      if (is_DC_band)
+        htblptr = & cinfo->dc_huff_tbl_ptrs[tbl];
+      else
+        htblptr = & cinfo->ac_huff_tbl_ptrs[tbl];
+      if (*htblptr == NULL)
+        *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
+      jpeg_gen_optimal_table(cinfo, *htblptr, entropy->count_ptrs[tbl]);
+      did[tbl] = TRUE;
+    }
+  }
+}
+
+
+/*
+ * Module initialization routine for progressive Huffman entropy encoding.
+ */
+
+GLOBAL(void)
+jinit_phuff_encoder (j_compress_ptr cinfo)
+{
+  phuff_entropy_ptr entropy;
+  int i;
+
+  entropy = (phuff_entropy_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(phuff_entropy_encoder));
+  cinfo->entropy = (struct jpeg_entropy_encoder *) entropy;
+  entropy->pub.start_pass = start_pass_phuff;
+
+  /* Mark tables unallocated */
+  for (i = 0; i < NUM_HUFF_TBLS; i++) {
+    entropy->derived_tbls[i] = NULL;
+    entropy->count_ptrs[i] = NULL;
+  }
+  entropy->bit_buffer = NULL;	/* needed only in AC refinement scan */
+}
+
+#endif /* C_PROGRESSIVE_SUPPORTED */

src/jpeg/jcprepct.c

@@ -0,0 +1,354 @@
+/*
+ * jcprepct.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the compression preprocessing controller.
+ * This controller manages the color conversion, downsampling,
+ * and edge expansion steps.
+ *
+ * Most of the complexity here is associated with buffering input rows
+ * as required by the downsampler.  See the comments at the head of
+ * jcsample.c for the downsampler's needs.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* At present, jcsample.c can request context rows only for smoothing.
+ * In the future, we might also need context rows for CCIR601 sampling
+ * or other more-complex downsampling procedures.  The code to support
+ * context rows should be compiled only if needed.
+ */
+#ifdef INPUT_SMOOTHING_SUPPORTED
+#define CONTEXT_ROWS_SUPPORTED
+#endif
+
+
+/*
+ * For the simple (no-context-row) case, we just need to buffer one
+ * row group's worth of pixels for the downsampling step.  At the bottom of
+ * the image, we pad to a full row group by replicating the last pixel row.
+ * The downsampler's last output row is then replicated if needed to pad
+ * out to a full iMCU row.
+ *
+ * When providing context rows, we must buffer three row groups' worth of
+ * pixels.  Three row groups are physically allocated, but the row pointer
+ * arrays are made five row groups high, with the extra pointers above and
+ * below "wrapping around" to point to the last and first real row groups.
+ * This allows the downsampler to access the proper context rows.
+ * At the top and bottom of the image, we create dummy context rows by
+ * copying the first or last real pixel row.  This copying could be avoided
+ * by pointer hacking as is done in jdmainct.c, but it doesn't seem worth the
+ * trouble on the compression side.
+ */
+
+
+/* Private buffer controller object */
+
+typedef struct {
+  struct jpeg_c_prep_controller pub; /* public fields */
+
+  /* Downsampling input buffer.  This buffer holds color-converted data
+   * until we have enough to do a downsample step.
+   */
+  JSAMPARRAY color_buf[MAX_COMPONENTS];
+
+  JDIMENSION rows_to_go;	/* counts rows remaining in source image */
+  int next_buf_row;		/* index of next row to store in color_buf */
+
+#ifdef CONTEXT_ROWS_SUPPORTED	/* only needed for context case */
+  int this_row_group;		/* starting row index of group to process */
+  int next_buf_stop;		/* downsample when we reach this index */
+#endif
+} my_prep_controller;
+
+typedef my_prep_controller * my_prep_ptr;
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF(void)
+start_pass_prep (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+  my_prep_ptr prep = (my_prep_ptr) cinfo->prep;
+
+  if (pass_mode != JBUF_PASS_THRU)
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+
+  /* Initialize total-height counter for detecting bottom of image */
+  prep->rows_to_go = cinfo->image_height;
+  /* Mark the conversion buffer empty */
+  prep->next_buf_row = 0;
+#ifdef CONTEXT_ROWS_SUPPORTED
+  /* Preset additional state variables for context mode.
+   * These aren't used in non-context mode, so we needn't test which mode.
+   */
+  prep->this_row_group = 0;
+  /* Set next_buf_stop to stop after two row groups have been read in. */
+  prep->next_buf_stop = 2 * cinfo->max_v_samp_factor;
+#endif
+}
+
+
+/*
+ * Expand an image vertically from height input_rows to height output_rows,
+ * by duplicating the bottom row.
+ */
+
+LOCAL(void)
+expand_bottom_edge (JSAMPARRAY image_data, JDIMENSION num_cols,
+		    int input_rows, int output_rows)
+{
+  register int row;
+
+  for (row = input_rows; row < output_rows; row++) {
+    jcopy_sample_rows(image_data, input_rows-1, image_data, row,
+		      1, num_cols);
+  }
+}
+
+
+/*
+ * Process some data in the simple no-context case.
+ *
+ * Preprocessor output data is counted in "row groups".  A row group
+ * is defined to be v_samp_factor sample rows of each component.
+ * Downsampling will produce this much data from each max_v_samp_factor
+ * input rows.
+ */
+
+METHODDEF(void)
+pre_process_data (j_compress_ptr cinfo,
+		  JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
+		  JDIMENSION in_rows_avail,
+		  JSAMPIMAGE output_buf, JDIMENSION *out_row_group_ctr,
+		  JDIMENSION out_row_groups_avail)
+{
+  my_prep_ptr prep = (my_prep_ptr) cinfo->prep;
+  int numrows, ci;
+  JDIMENSION inrows;
+  jpeg_component_info * compptr;
+
+  while (*in_row_ctr < in_rows_avail &&
+	 *out_row_group_ctr < out_row_groups_avail) {
+    /* Do color conversion to fill the conversion buffer. */
+    inrows = in_rows_avail - *in_row_ctr;
+    numrows = cinfo->max_v_samp_factor - prep->next_buf_row;
+    numrows = (int) MIN((JDIMENSION) numrows, inrows);
+    (*cinfo->cconvert->color_convert) (cinfo, input_buf + *in_row_ctr,
+				       prep->color_buf,
+				       (JDIMENSION) prep->next_buf_row,
+				       numrows);
+    *in_row_ctr += numrows;
+    prep->next_buf_row += numrows;
+    prep->rows_to_go -= numrows;
+    /* If at bottom of image, pad to fill the conversion buffer. */
+    if (prep->rows_to_go == 0 &&
+	prep->next_buf_row < cinfo->max_v_samp_factor) {
+      for (ci = 0; ci < cinfo->num_components; ci++) {
+	expand_bottom_edge(prep->color_buf[ci], cinfo->image_width,
+			   prep->next_buf_row, cinfo->max_v_samp_factor);
+      }
+      prep->next_buf_row = cinfo->max_v_samp_factor;
+    }
+    /* If we've filled the conversion buffer, empty it. */
+    if (prep->next_buf_row == cinfo->max_v_samp_factor) {
+      (*cinfo->downsample->downsample) (cinfo,
+					prep->color_buf, (JDIMENSION) 0,
+					output_buf, *out_row_group_ctr);
+      prep->next_buf_row = 0;
+      (*out_row_group_ctr)++;
+    }
+    /* If at bottom of image, pad the output to a full iMCU height.
+     * Note we assume the caller is providing a one-iMCU-height output buffer!
+     */
+    if (prep->rows_to_go == 0 &&
+	*out_row_group_ctr < out_row_groups_avail) {
+      for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+	   ci++, compptr++) {
+	expand_bottom_edge(output_buf[ci],
+			   compptr->width_in_blocks * DCTSIZE,
+			   (int) (*out_row_group_ctr * compptr->v_samp_factor),
+			   (int) (out_row_groups_avail * compptr->v_samp_factor));
+      }
+      *out_row_group_ctr = out_row_groups_avail;
+      break;			/* can exit outer loop without test */
+    }
+  }
+}
+
+
+#ifdef CONTEXT_ROWS_SUPPORTED
+
+/*
+ * Process some data in the context case.
+ */
+
+METHODDEF(void)
+pre_process_context (j_compress_ptr cinfo,
+		     JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
+		     JDIMENSION in_rows_avail,
+		     JSAMPIMAGE output_buf, JDIMENSION *out_row_group_ctr,
+		     JDIMENSION out_row_groups_avail)
+{
+  my_prep_ptr prep = (my_prep_ptr) cinfo->prep;
+  int numrows, ci;
+  int buf_height = cinfo->max_v_samp_factor * 3;
+  JDIMENSION inrows;
+
+  while (*out_row_group_ctr < out_row_groups_avail) {
+    if (*in_row_ctr < in_rows_avail) {
+      /* Do color conversion to fill the conversion buffer. */
+      inrows = in_rows_avail - *in_row_ctr;
+      numrows = prep->next_buf_stop - prep->next_buf_row;
+      numrows = (int) MIN((JDIMENSION) numrows, inrows);
+      (*cinfo->cconvert->color_convert) (cinfo, input_buf + *in_row_ctr,
+					 prep->color_buf,
+					 (JDIMENSION) prep->next_buf_row,
+					 numrows);
+      /* Pad at top of image, if first time through */
+      if (prep->rows_to_go == cinfo->image_height) {
+	for (ci = 0; ci < cinfo->num_components; ci++) {
+	  int row;
+	  for (row = 1; row <= cinfo->max_v_samp_factor; row++) {
+	    jcopy_sample_rows(prep->color_buf[ci], 0,
+			      prep->color_buf[ci], -row,
+			      1, cinfo->image_width);
+	  }
+	}
+      }
+      *in_row_ctr += numrows;
+      prep->next_buf_row += numrows;
+      prep->rows_to_go -= numrows;
+    } else {
+      /* Return for more data, unless we are at the bottom of the image. */
+      if (prep->rows_to_go != 0)
+	break;
+      /* When at bottom of image, pad to fill the conversion buffer. */
+      if (prep->next_buf_row < prep->next_buf_stop) {
+	for (ci = 0; ci < cinfo->num_components; ci++) {
+	  expand_bottom_edge(prep->color_buf[ci], cinfo->image_width,
+			     prep->next_buf_row, prep->next_buf_stop);
+	}
+	prep->next_buf_row = prep->next_buf_stop;
+      }
+    }
+    /* If we've gotten enough data, downsample a row group. */
+    if (prep->next_buf_row == prep->next_buf_stop) {
+      (*cinfo->downsample->downsample) (cinfo,
+					prep->color_buf,
+					(JDIMENSION) prep->this_row_group,
+					output_buf, *out_row_group_ctr);
+      (*out_row_group_ctr)++;
+      /* Advance pointers with wraparound as necessary. */
+      prep->this_row_group += cinfo->max_v_samp_factor;
+      if (prep->this_row_group >= buf_height)
+	prep->this_row_group = 0;
+      if (prep->next_buf_row >= buf_height)
+	prep->next_buf_row = 0;
+      prep->next_buf_stop = prep->next_buf_row + cinfo->max_v_samp_factor;
+    }
+  }
+}
+
+
+/*
+ * Create the wrapped-around downsampling input buffer needed for context mode.
+ */
+
+LOCAL(void)
+create_context_buffer (j_compress_ptr cinfo)
+{
+  my_prep_ptr prep = (my_prep_ptr) cinfo->prep;
+  int rgroup_height = cinfo->max_v_samp_factor;
+  int ci, i;
+  jpeg_component_info * compptr;
+  JSAMPARRAY true_buffer, fake_buffer;
+
+  /* Grab enough space for fake row pointers for all the components;
+   * we need five row groups' worth of pointers for each component.
+   */
+  fake_buffer = (JSAMPARRAY)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(cinfo->num_components * 5 * rgroup_height) *
+				SIZEOF(JSAMPROW));
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Allocate the actual buffer space (3 row groups) for this component.
+     * We make the buffer wide enough to allow the downsampler to edge-expand
+     * horizontally within the buffer, if it so chooses.
+     */
+    true_buffer = (*cinfo->mem->alloc_sarray)
+      ((j_common_ptr) cinfo, JPOOL_IMAGE,
+       (JDIMENSION) (((long) compptr->width_in_blocks * DCTSIZE *
+		      cinfo->max_h_samp_factor) / compptr->h_samp_factor),
+       (JDIMENSION) (3 * rgroup_height));
+    /* Copy true buffer row pointers into the middle of the fake row array */
+    MEMCOPY(fake_buffer + rgroup_height, true_buffer,
+	    3 * rgroup_height * SIZEOF(JSAMPROW));
+    /* Fill in the above and below wraparound pointers */
+    for (i = 0; i < rgroup_height; i++) {
+      fake_buffer[i] = true_buffer[2 * rgroup_height + i];
+      fake_buffer[4 * rgroup_height + i] = true_buffer[i];
+    }
+    prep->color_buf[ci] = fake_buffer + rgroup_height;
+    fake_buffer += 5 * rgroup_height; /* point to space for next component */
+  }
+}
+
+#endif /* CONTEXT_ROWS_SUPPORTED */
+
+
+/*
+ * Initialize preprocessing controller.
+ */
+
+GLOBAL(void)
+jinit_c_prep_controller (j_compress_ptr cinfo, boolean need_full_buffer)
+{
+  my_prep_ptr prep;
+  int ci;
+  jpeg_component_info * compptr;
+
+  if (need_full_buffer)		/* safety check */
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+
+  prep = (my_prep_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_prep_controller));
+  cinfo->prep = (struct jpeg_c_prep_controller *) prep;
+  prep->pub.start_pass = start_pass_prep;
+
+  /* Allocate the color conversion buffer.
+   * We make the buffer wide enough to allow the downsampler to edge-expand
+   * horizontally within the buffer, if it so chooses.
+   */
+  if (cinfo->downsample->need_context_rows) {
+    /* Set up to provide context rows */
+#ifdef CONTEXT_ROWS_SUPPORTED
+    prep->pub.pre_process_data = pre_process_context;
+    create_context_buffer(cinfo);
+#else
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+  } else {
+    /* No context, just make it tall enough for one row group */
+    prep->pub.pre_process_data = pre_process_data;
+    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+	 ci++, compptr++) {
+      prep->color_buf[ci] = (*cinfo->mem->alloc_sarray)
+	((j_common_ptr) cinfo, JPOOL_IMAGE,
+	 (JDIMENSION) (((long) compptr->width_in_blocks * DCTSIZE *
+			cinfo->max_h_samp_factor) / compptr->h_samp_factor),
+	 (JDIMENSION) cinfo->max_v_samp_factor);
+    }
+  }
+}

src/jpeg/jcsample.c

@@ -0,0 +1,519 @@
+/*
+ * jcsample.c
+ *
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains downsampling routines.
+ *
+ * Downsampling input data is counted in "row groups".  A row group
+ * is defined to be max_v_samp_factor pixel rows of each component,
+ * from which the downsampler produces v_samp_factor sample rows.
+ * A single row group is processed in each call to the downsampler module.
+ *
+ * The downsampler is responsible for edge-expansion of its output data
+ * to fill an integral number of DCT blocks horizontally.  The source buffer
+ * may be modified if it is helpful for this purpose (the source buffer is
+ * allocated wide enough to correspond to the desired output width).
+ * The caller (the prep controller) is responsible for vertical padding.
+ *
+ * The downsampler may request "context rows" by setting need_context_rows
+ * during startup.  In this case, the input arrays will contain at least
+ * one row group's worth of pixels above and below the passed-in data;
+ * the caller will create dummy rows at image top and bottom by replicating
+ * the first or last real pixel row.
+ *
+ * An excellent reference for image resampling is
+ *   Digital Image Warping, George Wolberg, 1990.
+ *   Pub. by IEEE Computer Society Press, Los Alamitos, CA. ISBN 0-8186-8944-7.
+ *
+ * The downsampling algorithm used here is a simple average of the source
+ * pixels covered by the output pixel.  The hi-falutin sampling literature
+ * refers to this as a "box filter".  In general the characteristics of a box
+ * filter are not very good, but for the specific cases we normally use (1:1
+ * and 2:1 ratios) the box is equivalent to a "triangle filter" which is not
+ * nearly so bad.  If you intend to use other sampling ratios, you'd be well
+ * advised to improve this code.
+ *
+ * A simple input-smoothing capability is provided.  This is mainly intended
+ * for cleaning up color-dithered GIF input files (if you find it inadequate,
+ * we suggest using an external filtering program such as pnmconvol).  When
+ * enabled, each input pixel P is replaced by a weighted sum of itself and its
+ * eight neighbors.  P's weight is 1-8*SF and each neighbor's weight is SF,
+ * where SF = (smoothing_factor / 1024).
+ * Currently, smoothing is only supported for 2h2v sampling factors.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Pointer to routine to downsample a single component */
+typedef JMETHOD(void, downsample1_ptr,
+		(j_compress_ptr cinfo, jpeg_component_info * compptr,
+		 JSAMPARRAY input_data, JSAMPARRAY output_data));
+
+/* Private subobject */
+
+typedef struct {
+  struct jpeg_downsampler pub;	/* public fields */
+
+  /* Downsampling method pointers, one per component */
+  downsample1_ptr methods[MAX_COMPONENTS];
+} my_downsampler;
+
+typedef my_downsampler * my_downsample_ptr;
+
+
+/*
+ * Initialize for a downsampling pass.
+ */
+
+METHODDEF(void)
+start_pass_downsample (j_compress_ptr cinfo)
+{
+  /* no work for now */
+}
+
+
+/*
+ * Expand a component horizontally from width input_cols to width output_cols,
+ * by duplicating the rightmost samples.
+ */
+
+LOCAL(void)
+expand_right_edge (JSAMPARRAY image_data, int num_rows,
+		   JDIMENSION input_cols, JDIMENSION output_cols)
+{
+  register JSAMPROW ptr;
+  register JSAMPLE pixval;
+  register int count;
+  int row;
+  int numcols = (int) (output_cols - input_cols);
+
+  if (numcols > 0) {
+    for (row = 0; row < num_rows; row++) {
+      ptr = image_data[row] + input_cols;
+      pixval = ptr[-1];		/* don't need GETJSAMPLE() here */
+      for (count = numcols; count > 0; count--)
+	*ptr++ = pixval;
+    }
+  }
+}
+
+
+/*
+ * Do downsampling for a whole row group (all components).
+ *
+ * In this version we simply downsample each component independently.
+ */
+
+METHODDEF(void)
+sep_downsample (j_compress_ptr cinfo,
+		JSAMPIMAGE input_buf, JDIMENSION in_row_index,
+		JSAMPIMAGE output_buf, JDIMENSION out_row_group_index)
+{
+  my_downsample_ptr downsample = (my_downsample_ptr) cinfo->downsample;
+  int ci;
+  jpeg_component_info * compptr;
+  JSAMPARRAY in_ptr, out_ptr;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    in_ptr = input_buf[ci] + in_row_index;
+    out_ptr = output_buf[ci] + (out_row_group_index * compptr->v_samp_factor);
+    (*downsample->methods[ci]) (cinfo, compptr, in_ptr, out_ptr);
+  }
+}
+
+
+/*
+ * Downsample pixel values of a single component.
+ * One row group is processed per call.
+ * This version handles arbitrary integral sampling ratios, without smoothing.
+ * Note that this version is not actually used for customary sampling ratios.
+ */
+
+METHODDEF(void)
+int_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
+		JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  int inrow, outrow, h_expand, v_expand, numpix, numpix2, h, v;
+  JDIMENSION outcol, outcol_h;	/* outcol_h == outcol*h_expand */
+  JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
+  JSAMPROW inptr, outptr;
+  INT32 outvalue;
+
+  h_expand = cinfo->max_h_samp_factor / compptr->h_samp_factor;
+  v_expand = cinfo->max_v_samp_factor / compptr->v_samp_factor;
+  numpix = h_expand * v_expand;
+  numpix2 = numpix/2;
+
+  /* Expand input data enough to let all the output samples be generated
+   * by the standard loop.  Special-casing padded output would be more
+   * efficient.
+   */
+  expand_right_edge(input_data, cinfo->max_v_samp_factor,
+		    cinfo->image_width, output_cols * h_expand);
+
+  inrow = 0;
+  for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
+    outptr = output_data[outrow];
+    for (outcol = 0, outcol_h = 0; outcol < output_cols;
+	 outcol++, outcol_h += h_expand) {
+      outvalue = 0;
+      for (v = 0; v < v_expand; v++) {
+	inptr = input_data[inrow+v] + outcol_h;
+	for (h = 0; h < h_expand; h++) {
+	  outvalue += (INT32) GETJSAMPLE(*inptr++);
+	}
+      }
+      *outptr++ = (JSAMPLE) ((outvalue + numpix2) / numpix);
+    }
+    inrow += v_expand;
+  }
+}
+
+
+/*
+ * Downsample pixel values of a single component.
+ * This version handles the special case of a full-size component,
+ * without smoothing.
+ */
+
+METHODDEF(void)
+fullsize_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
+		     JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  /* Copy the data */
+  jcopy_sample_rows(input_data, 0, output_data, 0,
+		    cinfo->max_v_samp_factor, cinfo->image_width);
+  /* Edge-expand */
+  expand_right_edge(output_data, cinfo->max_v_samp_factor,
+		    cinfo->image_width, compptr->width_in_blocks * DCTSIZE);
+}
+
+
+/*
+ * Downsample pixel values of a single component.
+ * This version handles the common case of 2:1 horizontal and 1:1 vertical,
+ * without smoothing.
+ *
+ * A note about the "bias" calculations: when rounding fractional values to
+ * integer, we do not want to always round 0.5 up to the next integer.
+ * If we did that, we'd introduce a noticeable bias towards larger values.
+ * Instead, this code is arranged so that 0.5 will be rounded up or down at
+ * alternate pixel locations (a simple ordered dither pattern).
+ */
+
+METHODDEF(void)
+h2v1_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
+		 JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  int outrow;
+  JDIMENSION outcol;
+  JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
+  register JSAMPROW inptr, outptr;
+  register int bias;
+
+  /* Expand input data enough to let all the output samples be generated
+   * by the standard loop.  Special-casing padded output would be more
+   * efficient.
+   */
+  expand_right_edge(input_data, cinfo->max_v_samp_factor,
+		    cinfo->image_width, output_cols * 2);
+
+  for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
+    outptr = output_data[outrow];
+    inptr = input_data[outrow];
+    bias = 0;			/* bias = 0,1,0,1,... for successive samples */
+    for (outcol = 0; outcol < output_cols; outcol++) {
+      *outptr++ = (JSAMPLE) ((GETJSAMPLE(*inptr) + GETJSAMPLE(inptr[1])
+			      + bias) >> 1);
+      bias ^= 1;		/* 0=>1, 1=>0 */
+      inptr += 2;
+    }
+  }
+}
+
+
+/*
+ * Downsample pixel values of a single component.
+ * This version handles the standard case of 2:1 horizontal and 2:1 vertical,
+ * without smoothing.
+ */
+
+METHODDEF(void)
+h2v2_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
+		 JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  int inrow, outrow;
+  JDIMENSION outcol;
+  JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
+  register JSAMPROW inptr0, inptr1, outptr;
+  register int bias;
+
+  /* Expand input data enough to let all the output samples be generated
+   * by the standard loop.  Special-casing padded output would be more
+   * efficient.
+   */
+  expand_right_edge(input_data, cinfo->max_v_samp_factor,
+		    cinfo->image_width, output_cols * 2);
+
+  inrow = 0;
+  for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
+    outptr = output_data[outrow];
+    inptr0 = input_data[inrow];
+    inptr1 = input_data[inrow+1];
+    bias = 1;			/* bias = 1,2,1,2,... for successive samples */
+    for (outcol = 0; outcol < output_cols; outcol++) {
+      *outptr++ = (JSAMPLE) ((GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
+			      GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1])
+			      + bias) >> 2);
+      bias ^= 3;		/* 1=>2, 2=>1 */
+      inptr0 += 2; inptr1 += 2;
+    }
+    inrow += 2;
+  }
+}
+
+
+#ifdef INPUT_SMOOTHING_SUPPORTED
+
+/*
+ * Downsample pixel values of a single component.
+ * This version handles the standard case of 2:1 horizontal and 2:1 vertical,
+ * with smoothing.  One row of context is required.
+ */
+
+METHODDEF(void)
+h2v2_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
+			JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  int inrow, outrow;
+  JDIMENSION colctr;
+  JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
+  register JSAMPROW inptr0, inptr1, above_ptr, below_ptr, outptr;
+  INT32 membersum, neighsum, memberscale, neighscale;
+
+  /* Expand input data enough to let all the output samples be generated
+   * by the standard loop.  Special-casing padded output would be more
+   * efficient.
+   */
+  expand_right_edge(input_data - 1, cinfo->max_v_samp_factor + 2,
+		    cinfo->image_width, output_cols * 2);
+
+  /* We don't bother to form the individual "smoothed" input pixel values;
+   * we can directly compute the output which is the average of the four
+   * smoothed values.  Each of the four member pixels contributes a fraction
+   * (1-8*SF) to its own smoothed image and a fraction SF to each of the three
+   * other smoothed pixels, therefore a total fraction (1-5*SF)/4 to the final
+   * output.  The four corner-adjacent neighbor pixels contribute a fraction
+   * SF to just one smoothed pixel, or SF/4 to the final output; while the
+   * eight edge-adjacent neighbors contribute SF to each of two smoothed
+   * pixels, or SF/2 overall.  In order to use integer arithmetic, these
+   * factors are scaled by 2^16 = 65536.
+   * Also recall that SF = smoothing_factor / 1024.
+   */
+
+  memberscale = 16384 - cinfo->smoothing_factor * 80; /* scaled (1-5*SF)/4 */
+  neighscale = cinfo->smoothing_factor * 16; /* scaled SF/4 */
+
+  inrow = 0;
+  for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
+    outptr = output_data[outrow];
+    inptr0 = input_data[inrow];
+    inptr1 = input_data[inrow+1];
+    above_ptr = input_data[inrow-1];
+    below_ptr = input_data[inrow+2];
+
+    /* Special case for first column: pretend column -1 is same as column 0 */
+    membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
+		GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
+    neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
+	       GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
+	       GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[2]) +
+	       GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[2]);
+    neighsum += neighsum;
+    neighsum += GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[2]) +
+		GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[2]);
+    membersum = membersum * memberscale + neighsum * neighscale;
+    *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
+    inptr0 += 2; inptr1 += 2; above_ptr += 2; below_ptr += 2;
+
+    for (colctr = output_cols - 2; colctr > 0; colctr--) {
+      /* sum of pixels directly mapped to this output element */
+      membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
+		  GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
+      /* sum of edge-neighbor pixels */
+      neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
+		 GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
+		 GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[2]) +
+		 GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[2]);
+      /* The edge-neighbors count twice as much as corner-neighbors */
+      neighsum += neighsum;
+      /* Add in the corner-neighbors */
+      neighsum += GETJSAMPLE(above_ptr[-1]) + GETJSAMPLE(above_ptr[2]) +
+		  GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[2]);
+      /* form final output scaled up by 2^16 */
+      membersum = membersum * memberscale + neighsum * neighscale;
+      /* round, descale and output it */
+      *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
+      inptr0 += 2; inptr1 += 2; above_ptr += 2; below_ptr += 2;
+    }
+
+    /* Special case for last column */
+    membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
+		GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
+    neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
+	       GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
+	       GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[1]) +
+	       GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[1]);
+    neighsum += neighsum;
+    neighsum += GETJSAMPLE(above_ptr[-1]) + GETJSAMPLE(above_ptr[1]) +
+		GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[1]);
+    membersum = membersum * memberscale + neighsum * neighscale;
+    *outptr = (JSAMPLE) ((membersum + 32768) >> 16);
+
+    inrow += 2;
+  }
+}
+
+
+/*
+ * Downsample pixel values of a single component.
+ * This version handles the special case of a full-size component,
+ * with smoothing.  One row of context is required.
+ */
+
+METHODDEF(void)
+fullsize_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info *compptr,
+			    JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  int outrow;
+  JDIMENSION colctr;
+  JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
+  register JSAMPROW inptr, above_ptr, below_ptr, outptr;
+  INT32 membersum, neighsum, memberscale, neighscale;
+  int colsum, lastcolsum, nextcolsum;
+
+  /* Expand input data enough to let all the output samples be generated
+   * by the standard loop.  Special-casing padded output would be more
+   * efficient.
+   */
+  expand_right_edge(input_data - 1, cinfo->max_v_samp_factor + 2,
+		    cinfo->image_width, output_cols);
+
+  /* Each of the eight neighbor pixels contributes a fraction SF to the
+   * smoothed pixel, while the main pixel contributes (1-8*SF).  In order
+   * to use integer arithmetic, these factors are multiplied by 2^16 = 65536.
+   * Also recall that SF = smoothing_factor / 1024.
+   */
+
+  memberscale = 65536L - cinfo->smoothing_factor * 512L; /* scaled 1-8*SF */
+  neighscale = cinfo->smoothing_factor * 64; /* scaled SF */
+
+  for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
+    outptr = output_data[outrow];
+    inptr = input_data[outrow];
+    above_ptr = input_data[outrow-1];
+    below_ptr = input_data[outrow+1];
+
+    /* Special case for first column */
+    colsum = GETJSAMPLE(*above_ptr++) + GETJSAMPLE(*below_ptr++) +
+	     GETJSAMPLE(*inptr);
+    membersum = GETJSAMPLE(*inptr++);
+    nextcolsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(*below_ptr) +
+		 GETJSAMPLE(*inptr);
+    neighsum = colsum + (colsum - membersum) + nextcolsum;
+    membersum = membersum * memberscale + neighsum * neighscale;
+    *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
+    lastcolsum = colsum; colsum = nextcolsum;
+
+    for (colctr = output_cols - 2; colctr > 0; colctr--) {
+      membersum = GETJSAMPLE(*inptr++);
+      above_ptr++; below_ptr++;
+      nextcolsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(*below_ptr) +
+		   GETJSAMPLE(*inptr);
+      neighsum = lastcolsum + (colsum - membersum) + nextcolsum;
+      membersum = membersum * memberscale + neighsum * neighscale;
+      *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
+      lastcolsum = colsum; colsum = nextcolsum;
+    }
+
+    /* Special case for last column */
+    membersum = GETJSAMPLE(*inptr);
+    neighsum = lastcolsum + (colsum - membersum) + colsum;
+    membersum = membersum * memberscale + neighsum * neighscale;
+    *outptr = (JSAMPLE) ((membersum + 32768) >> 16);
+
+  }
+}
+
+#endif /* INPUT_SMOOTHING_SUPPORTED */
+
+
+/*
+ * Module initialization routine for downsampling.
+ * Note that we must select a routine for each component.
+ */
+
+GLOBAL(void)
+jinit_downsampler (j_compress_ptr cinfo)
+{
+  my_downsample_ptr downsample;
+  int ci;
+  jpeg_component_info * compptr;
+  boolean smoothok = TRUE;
+
+  downsample = (my_downsample_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_downsampler));
+  cinfo->downsample = (struct jpeg_downsampler *) downsample;
+  downsample->pub.start_pass = start_pass_downsample;
+  downsample->pub.downsample = sep_downsample;
+  downsample->pub.need_context_rows = FALSE;
+
+  if (cinfo->CCIR601_sampling)
+    ERREXIT(cinfo, JERR_CCIR601_NOTIMPL);
+
+  /* Verify we can handle the sampling factors, and set up method pointers */
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    if (compptr->h_samp_factor == cinfo->max_h_samp_factor &&
+	compptr->v_samp_factor == cinfo->max_v_samp_factor) {
+#ifdef INPUT_SMOOTHING_SUPPORTED
+      if (cinfo->smoothing_factor) {
+	downsample->methods[ci] = fullsize_smooth_downsample;
+	downsample->pub.need_context_rows = TRUE;
+      } else
+#endif
+	downsample->methods[ci] = fullsize_downsample;
+    } else if (compptr->h_samp_factor * 2 == cinfo->max_h_samp_factor &&
+	       compptr->v_samp_factor == cinfo->max_v_samp_factor) {
+      smoothok = FALSE;
+      downsample->methods[ci] = h2v1_downsample;
+    } else if (compptr->h_samp_factor * 2 == cinfo->max_h_samp_factor &&
+	       compptr->v_samp_factor * 2 == cinfo->max_v_samp_factor) {
+#ifdef INPUT_SMOOTHING_SUPPORTED
+      if (cinfo->smoothing_factor) {
+	downsample->methods[ci] = h2v2_smooth_downsample;
+	downsample->pub.need_context_rows = TRUE;
+      } else
+#endif
+	downsample->methods[ci] = h2v2_downsample;
+    } else if ((cinfo->max_h_samp_factor % compptr->h_samp_factor) == 0 &&
+	       (cinfo->max_v_samp_factor % compptr->v_samp_factor) == 0) {
+      smoothok = FALSE;
+      downsample->methods[ci] = int_downsample;
+    } else
+      ERREXIT(cinfo, JERR_FRACT_SAMPLE_NOTIMPL);
+  }
+
+#ifdef INPUT_SMOOTHING_SUPPORTED
+  if (cinfo->smoothing_factor && !smoothok)
+    TRACEMS(cinfo, 0, JTRC_SMOOTH_NOTIMPL);
+#endif
+}

src/jpeg/jctrans.c

@@ -0,0 +1,388 @@
+/*
+ * jctrans.c
+ *
+ * Copyright (C) 1995-1998, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains library routines for transcoding compression,
+ * that is, writing raw DCT coefficient arrays to an output JPEG file.
+ * The routines in jcapimin.c will also be needed by a transcoder.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Forward declarations */
+LOCAL(void) transencode_master_selection
+	JPP((j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays));
+LOCAL(void) transencode_coef_controller
+	JPP((j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays));
+
+
+/*
+ * Compression initialization for writing raw-coefficient data.
+ * Before calling this, all parameters and a data destination must be set up.
+ * Call jpeg_finish_compress() to actually write the data.
+ *
+ * The number of passed virtual arrays must match cinfo->num_components.
+ * Note that the virtual arrays need not be filled or even realized at
+ * the time write_coefficients is called; indeed, if the virtual arrays
+ * were requested from this compression object's memory manager, they
+ * typically will be realized during this routine and filled afterwards.
+ */
+
+GLOBAL(void)
+jpeg_write_coefficients (j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays)
+{
+  if (cinfo->global_state != CSTATE_START)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  /* Mark all tables to be written */
+  jpeg_suppress_tables(cinfo, FALSE);
+  /* (Re)initialize error mgr and destination modules */
+  (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo);
+  (*cinfo->dest->init_destination) (cinfo);
+  /* Perform master selection of active modules */
+  transencode_master_selection(cinfo, coef_arrays);
+  /* Wait for jpeg_finish_compress() call */
+  cinfo->next_scanline = 0;	/* so jpeg_write_marker works */
+  cinfo->global_state = CSTATE_WRCOEFS;
+}
+
+
+/*
+ * Initialize the compression object with default parameters,
+ * then copy from the source object all parameters needed for lossless
+ * transcoding.  Parameters that can be varied without loss (such as
+ * scan script and Huffman optimization) are left in their default states.
+ */
+
+GLOBAL(void)
+jpeg_copy_critical_parameters (j_decompress_ptr srcinfo,
+			       j_compress_ptr dstinfo)
+{
+  JQUANT_TBL ** qtblptr;
+  jpeg_component_info *incomp, *outcomp;
+  JQUANT_TBL *c_quant, *slot_quant;
+  int tblno, ci, coefi;
+
+  /* Safety check to ensure start_compress not called yet. */
+  if (dstinfo->global_state != CSTATE_START)
+    ERREXIT1(dstinfo, JERR_BAD_STATE, dstinfo->global_state);
+  /* Copy fundamental image dimensions */
+  dstinfo->image_width = srcinfo->image_width;
+  dstinfo->image_height = srcinfo->image_height;
+  dstinfo->input_components = srcinfo->num_components;
+  dstinfo->in_color_space = srcinfo->jpeg_color_space;
+  /* Initialize all parameters to default values */
+  jpeg_set_defaults(dstinfo);
+  /* jpeg_set_defaults may choose wrong colorspace, eg YCbCr if input is RGB.
+   * Fix it to get the right header markers for the image colorspace.
+   */
+  jpeg_set_colorspace(dstinfo, srcinfo->jpeg_color_space);
+  dstinfo->data_precision = srcinfo->data_precision;
+  dstinfo->CCIR601_sampling = srcinfo->CCIR601_sampling;
+  /* Copy the source's quantization tables. */
+  for (tblno = 0; tblno < NUM_QUANT_TBLS; tblno++) {
+    if (srcinfo->quant_tbl_ptrs[tblno] != NULL) {
+      qtblptr = & dstinfo->quant_tbl_ptrs[tblno];
+      if (*qtblptr == NULL)
+	*qtblptr = jpeg_alloc_quant_table((j_common_ptr) dstinfo);
+      MEMCOPY((*qtblptr)->quantval,
+	      srcinfo->quant_tbl_ptrs[tblno]->quantval,
+	      SIZEOF((*qtblptr)->quantval));
+      (*qtblptr)->sent_table = FALSE;
+    }
+  }
+  /* Copy the source's per-component info.
+   * Note we assume jpeg_set_defaults has allocated the dest comp_info array.
+   */
+  dstinfo->num_components = srcinfo->num_components;
+  if (dstinfo->num_components < 1 || dstinfo->num_components > MAX_COMPONENTS)
+    ERREXIT2(dstinfo, JERR_COMPONENT_COUNT, dstinfo->num_components,
+	     MAX_COMPONENTS);
+  for (ci = 0, incomp = srcinfo->comp_info, outcomp = dstinfo->comp_info;
+       ci < dstinfo->num_components; ci++, incomp++, outcomp++) {
+    outcomp->component_id = incomp->component_id;
+    outcomp->h_samp_factor = incomp->h_samp_factor;
+    outcomp->v_samp_factor = incomp->v_samp_factor;
+    outcomp->quant_tbl_no = incomp->quant_tbl_no;
+    /* Make sure saved quantization table for component matches the qtable
+     * slot.  If not, the input file re-used this qtable slot.
+     * IJG encoder currently cannot duplicate this.
+     */
+    tblno = outcomp->quant_tbl_no;
+    if (tblno < 0 || tblno >= NUM_QUANT_TBLS ||
+	srcinfo->quant_tbl_ptrs[tblno] == NULL)
+      ERREXIT1(dstinfo, JERR_NO_QUANT_TABLE, tblno);
+    slot_quant = srcinfo->quant_tbl_ptrs[tblno];
+    c_quant = incomp->quant_table;
+    if (c_quant != NULL) {
+      for (coefi = 0; coefi < DCTSIZE2; coefi++) {
+	if (c_quant->quantval[coefi] != slot_quant->quantval[coefi])
+	  ERREXIT1(dstinfo, JERR_MISMATCHED_QUANT_TABLE, tblno);
+      }
+    }
+    /* Note: we do not copy the source's Huffman table assignments;
+     * instead we rely on jpeg_set_colorspace to have made a suitable choice.
+     */
+  }
+  /* Also copy JFIF version and resolution information, if available.
+   * Strictly speaking this isn't "critical" info, but it's nearly
+   * always appropriate to copy it if available.  In particular,
+   * if the application chooses to copy JFIF 1.02 extension markers from
+   * the source file, we need to copy the version to make sure we don't
+   * emit a file that has 1.02 extensions but a claimed version of 1.01.
+   * We will *not*, however, copy version info from mislabeled "2.01" files.
+   */
+  if (srcinfo->saw_JFIF_marker) {
+    if (srcinfo->JFIF_major_version == 1) {
+      dstinfo->JFIF_major_version = srcinfo->JFIF_major_version;
+      dstinfo->JFIF_minor_version = srcinfo->JFIF_minor_version;
+    }
+    dstinfo->density_unit = srcinfo->density_unit;
+    dstinfo->X_density = srcinfo->X_density;
+    dstinfo->Y_density = srcinfo->Y_density;
+  }
+}
+
+
+/*
+ * Master selection of compression modules for transcoding.
+ * This substitutes for jcinit.c's initialization of the full compressor.
+ */
+
+LOCAL(void)
+transencode_master_selection (j_compress_ptr cinfo,
+			      jvirt_barray_ptr * coef_arrays)
+{
+  /* Although we don't actually use input_components for transcoding,
+   * jcmaster.c's initial_setup will complain if input_components is 0.
+   */
+  cinfo->input_components = 1;
+  /* Initialize master control (includes parameter checking/processing) */
+  jinit_c_master_control(cinfo, TRUE /* transcode only */);
+
+  /* Entropy encoding: either Huffman or arithmetic coding. */
+  if (cinfo->arith_code) {
+    ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
+  } else {
+    if (cinfo->progressive_mode) {
+#ifdef C_PROGRESSIVE_SUPPORTED
+      jinit_phuff_encoder(cinfo);
+#else
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+    } else
+      jinit_huff_encoder(cinfo);
+  }
+
+  /* We need a special coefficient buffer controller. */
+  transencode_coef_controller(cinfo, coef_arrays);
+
+  jinit_marker_writer(cinfo);
+
+  /* We can now tell the memory manager to allocate virtual arrays. */
+  (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo);
+
+  /* Write the datastream header (SOI, JFIF) immediately.
+   * Frame and scan headers are postponed till later.
+   * This lets application insert special markers after the SOI.
+   */
+  (*cinfo->marker->write_file_header) (cinfo);
+}
+
+
+/*
+ * The rest of this file is a special implementation of the coefficient
+ * buffer controller.  This is similar to jccoefct.c, but it handles only
+ * output from presupplied virtual arrays.  Furthermore, we generate any
+ * dummy padding blocks on-the-fly rather than expecting them to be present
+ * in the arrays.
+ */
+
+/* Private buffer controller object */
+
+typedef struct {
+  struct jpeg_c_coef_controller pub; /* public fields */
+
+  JDIMENSION iMCU_row_num;	/* iMCU row # within image */
+  JDIMENSION mcu_ctr;		/* counts MCUs processed in current row */
+  int MCU_vert_offset;		/* counts MCU rows within iMCU row */
+  int MCU_rows_per_iMCU_row;	/* number of such rows needed */
+
+  /* Virtual block array for each component. */
+  jvirt_barray_ptr * whole_image;
+
+  /* Workspace for constructing dummy blocks at right/bottom edges. */
+  JBLOCKROW dummy_buffer[C_MAX_BLOCKS_IN_MCU];
+} my_coef_controller;
+
+typedef my_coef_controller * my_coef_ptr;
+
+
+LOCAL(void)
+start_iMCU_row (j_compress_ptr cinfo)
+/* Reset within-iMCU-row counters for a new row */
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+
+  /* In an interleaved scan, an MCU row is the same as an iMCU row.
+   * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
+   * But at the bottom of the image, process only what's left.
+   */
+  if (cinfo->comps_in_scan > 1) {
+    coef->MCU_rows_per_iMCU_row = 1;
+  } else {
+    if (coef->iMCU_row_num < (cinfo->total_iMCU_rows-1))
+      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
+    else
+      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
+  }
+
+  coef->mcu_ctr = 0;
+  coef->MCU_vert_offset = 0;
+}
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF(void)
+start_pass_coef (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+
+  if (pass_mode != JBUF_CRANK_DEST)
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+
+  coef->iMCU_row_num = 0;
+  start_iMCU_row(cinfo);
+}
+
+
+/*
+ * Process some data.
+ * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
+ * per call, ie, v_samp_factor block rows for each component in the scan.
+ * The data is obtained from the virtual arrays and fed to the entropy coder.
+ * Returns TRUE if the iMCU row is completed, FALSE if suspended.
+ *
+ * NB: input_buf is ignored; it is likely to be a NULL pointer.
+ */
+
+METHODDEF(boolean)
+compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+  JDIMENSION MCU_col_num;	/* index of current MCU within row */
+  JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
+  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+  int blkn, ci, xindex, yindex, yoffset, blockcnt;
+  JDIMENSION start_col;
+  JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
+  JBLOCKROW MCU_buffer[C_MAX_BLOCKS_IN_MCU];
+  JBLOCKROW buffer_ptr;
+  jpeg_component_info *compptr;
+
+  /* Align the virtual buffers for the components used in this scan. */
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    buffer[ci] = (*cinfo->mem->access_virt_barray)
+      ((j_common_ptr) cinfo, coef->whole_image[compptr->component_index],
+       coef->iMCU_row_num * compptr->v_samp_factor,
+       (JDIMENSION) compptr->v_samp_factor, FALSE);
+  }
+
+  /* Loop to process one whole iMCU row */
+  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
+       yoffset++) {
+    for (MCU_col_num = coef->mcu_ctr; MCU_col_num < cinfo->MCUs_per_row;
+	 MCU_col_num++) {
+      /* Construct list of pointers to DCT blocks belonging to this MCU */
+      blkn = 0;			/* index of current DCT block within MCU */
+      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+	compptr = cinfo->cur_comp_info[ci];
+	start_col = MCU_col_num * compptr->MCU_width;
+	blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
+						: compptr->last_col_width;
+	for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+	  if (coef->iMCU_row_num < last_iMCU_row ||
+	      yindex+yoffset < compptr->last_row_height) {
+	    /* Fill in pointers to real blocks in this row */
+	    buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
+	    for (xindex = 0; xindex < blockcnt; xindex++)
+	      MCU_buffer[blkn++] = buffer_ptr++;
+	  } else {
+	    /* At bottom of image, need a whole row of dummy blocks */
+	    xindex = 0;
+	  }
+	  /* Fill in any dummy blocks needed in this row.
+	   * Dummy blocks are filled in the same way as in jccoefct.c:
+	   * all zeroes in the AC entries, DC entries equal to previous
+	   * block's DC value.  The init routine has already zeroed the
+	   * AC entries, so we need only set the DC entries correctly.
+	   */
+	  for (; xindex < compptr->MCU_width; xindex++) {
+	    MCU_buffer[blkn] = coef->dummy_buffer[blkn];
+	    MCU_buffer[blkn][0][0] = MCU_buffer[blkn-1][0][0];
+	    blkn++;
+	  }
+	}
+      }
+      /* Try to write the MCU. */
+      if (! (*cinfo->entropy->encode_mcu) (cinfo, MCU_buffer)) {
+	/* Suspension forced; update state counters and exit */
+	coef->MCU_vert_offset = yoffset;
+	coef->mcu_ctr = MCU_col_num;
+	return FALSE;
+      }
+    }
+    /* Completed an MCU row, but perhaps not an iMCU row */
+    coef->mcu_ctr = 0;
+  }
+  /* Completed the iMCU row, advance counters for next one */
+  coef->iMCU_row_num++;
+  start_iMCU_row(cinfo);
+  return TRUE;
+}
+
+
+/*
+ * Initialize coefficient buffer controller.
+ *
+ * Each passed coefficient array must be the right size for that
+ * coefficient: width_in_blocks wide and height_in_blocks high,
+ * with unitheight at least v_samp_factor.
+ */
+
+LOCAL(void)
+transencode_coef_controller (j_compress_ptr cinfo,
+			     jvirt_barray_ptr * coef_arrays)
+{
+  my_coef_ptr coef;
+  JBLOCKROW buffer;
+  int i;
+
+  coef = (my_coef_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_coef_controller));
+  cinfo->coef = (struct jpeg_c_coef_controller *) coef;
+  coef->pub.start_pass = start_pass_coef;
+  coef->pub.compress_data = compress_output;
+
+  /* Save pointer to virtual arrays */
+  coef->whole_image = coef_arrays;
+
+  /* Allocate and pre-zero space for dummy DCT blocks. */
+  buffer = (JBLOCKROW)
+    (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
+  jzero_far((void FAR *) buffer, C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
+  for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
+    coef->dummy_buffer[i] = buffer + i;
+  }
+}

src/jpeg/jdapimin.c

@@ -0,0 +1,395 @@
+/*
+ * jdapimin.c
+ *
+ * Copyright (C) 1994-1998, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains application interface code for the decompression half
+ * of the JPEG library.  These are the "minimum" API routines that may be
+ * needed in either the normal full-decompression case or the
+ * transcoding-only case.
+ *
+ * Most of the routines intended to be called directly by an application
+ * are in this file or in jdapistd.c.  But also see jcomapi.c for routines
+ * shared by compression and decompression, and jdtrans.c for the transcoding
+ * case.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * Initialization of a JPEG decompression object.
+ * The error manager must already be set up (in case memory manager fails).
+ */
+
+GLOBAL(void)
+jpeg_CreateDecompress (j_decompress_ptr cinfo, int version, size_t structsize)
+{
+  int i;
+
+  /* Guard against version mismatches between library and caller. */
+  cinfo->mem = NULL;		/* so jpeg_destroy knows mem mgr not called */
+  if (version != JPEG_LIB_VERSION)
+    ERREXIT2(cinfo, JERR_BAD_LIB_VERSION, JPEG_LIB_VERSION, version);
+  if (structsize != SIZEOF(struct jpeg_decompress_struct))
+    ERREXIT2(cinfo, JERR_BAD_STRUCT_SIZE, 
+	     (int) SIZEOF(struct jpeg_decompress_struct), (int) structsize);
+
+  /* For debugging purposes, we zero the whole master structure.
+   * But the application has already set the err pointer, and may have set
+   * client_data, so we have to save and restore those fields.
+   * Note: if application hasn't set client_data, tools like Purify may
+   * complain here.
+   */
+  {
+    struct jpeg_error_mgr * err = cinfo->err;
+    void * client_data = cinfo->client_data; /* ignore Purify complaint here */
+    MEMZERO(cinfo, SIZEOF(struct jpeg_decompress_struct));
+    cinfo->err = err;
+    cinfo->client_data = client_data;
+  }
+  cinfo->is_decompressor = TRUE;
+
+  /* Initialize a memory manager instance for this object */
+  jinit_memory_mgr((j_common_ptr) cinfo);
+
+  /* Zero out pointers to permanent structures. */
+  cinfo->progress = NULL;
+  cinfo->src = NULL;
+
+  for (i = 0; i < NUM_QUANT_TBLS; i++)
+    cinfo->quant_tbl_ptrs[i] = NULL;
+
+  for (i = 0; i < NUM_HUFF_TBLS; i++) {
+    cinfo->dc_huff_tbl_ptrs[i] = NULL;
+    cinfo->ac_huff_tbl_ptrs[i] = NULL;
+  }
+
+  /* Initialize marker processor so application can override methods
+   * for COM, APPn markers before calling jpeg_read_header.
+   */
+  cinfo->marker_list = NULL;
+  jinit_marker_reader(cinfo);
+
+  /* And initialize the overall input controller. */
+  jinit_input_controller(cinfo);
+
+  /* OK, I'm ready */
+  cinfo->global_state = DSTATE_START;
+}
+
+
+/*
+ * Destruction of a JPEG decompression object
+ */
+
+GLOBAL(void)
+jpeg_destroy_decompress (j_decompress_ptr cinfo)
+{
+  jpeg_destroy((j_common_ptr) cinfo); /* use common routine */
+}
+
+
+/*
+ * Abort processing of a JPEG decompression operation,
+ * but don't destroy the object itself.
+ */
+
+GLOBAL(void)
+jpeg_abort_decompress (j_decompress_ptr cinfo)
+{
+  jpeg_abort((j_common_ptr) cinfo); /* use common routine */
+}
+
+
+/*
+ * Set default decompression parameters.
+ */
+
+LOCAL(void)
+default_decompress_parms (j_decompress_ptr cinfo)
+{
+  /* Guess the input colorspace, and set output colorspace accordingly. */
+  /* (Wish JPEG committee had provided a real way to specify this...) */
+  /* Note application may override our guesses. */
+  switch (cinfo->num_components) {
+  case 1:
+    cinfo->jpeg_color_space = JCS_GRAYSCALE;
+    cinfo->out_color_space = JCS_GRAYSCALE;
+    break;
+    
+  case 3:
+    if (cinfo->saw_JFIF_marker) {
+      cinfo->jpeg_color_space = JCS_YCbCr; /* JFIF implies YCbCr */
+    } else if (cinfo->saw_Adobe_marker) {
+      switch (cinfo->Adobe_transform) {
+      case 0:
+	cinfo->jpeg_color_space = JCS_RGB;
+	break;
+      case 1:
+	cinfo->jpeg_color_space = JCS_YCbCr;
+	break;
+      default:
+	WARNMS1(cinfo, JWRN_ADOBE_XFORM, cinfo->Adobe_transform);
+	cinfo->jpeg_color_space = JCS_YCbCr; /* assume it's YCbCr */
+	break;
+      }
+    } else {
+      /* Saw no special markers, try to guess from the component IDs */
+      int cid0 = cinfo->comp_info[0].component_id;
+      int cid1 = cinfo->comp_info[1].component_id;
+      int cid2 = cinfo->comp_info[2].component_id;
+
+      if (cid0 == 1 && cid1 == 2 && cid2 == 3)
+	cinfo->jpeg_color_space = JCS_YCbCr; /* assume JFIF w/out marker */
+      else if (cid0 == 82 && cid1 == 71 && cid2 == 66)
+	cinfo->jpeg_color_space = JCS_RGB; /* ASCII 'R', 'G', 'B' */
+      else {
+	TRACEMS3(cinfo, 1, JTRC_UNKNOWN_IDS, cid0, cid1, cid2);
+	cinfo->jpeg_color_space = JCS_YCbCr; /* assume it's YCbCr */
+      }
+    }
+    /* Always guess RGB is proper output colorspace. */
+    cinfo->out_color_space = JCS_RGB;
+    break;
+    
+  case 4:
+    if (cinfo->saw_Adobe_marker) {
+      switch (cinfo->Adobe_transform) {
+      case 0:
+	cinfo->jpeg_color_space = JCS_CMYK;
+	break;
+      case 2:
+	cinfo->jpeg_color_space = JCS_YCCK;
+	break;
+      default:
+	WARNMS1(cinfo, JWRN_ADOBE_XFORM, cinfo->Adobe_transform);
+	cinfo->jpeg_color_space = JCS_YCCK; /* assume it's YCCK */
+	break;
+      }
+    } else {
+      /* No special markers, assume straight CMYK. */
+      cinfo->jpeg_color_space = JCS_CMYK;
+    }
+    cinfo->out_color_space = JCS_CMYK;
+    break;
+    
+  default:
+    cinfo->jpeg_color_space = JCS_UNKNOWN;
+    cinfo->out_color_space = JCS_UNKNOWN;
+    break;
+  }
+
+  /* Set defaults for other decompression parameters. */
+  cinfo->scale_num = 1;		/* 1:1 scaling */
+  cinfo->scale_denom = 1;
+  cinfo->output_gamma = 1.0;
+  cinfo->buffered_image = FALSE;
+  cinfo->raw_data_out = FALSE;
+  cinfo->dct_method = JDCT_DEFAULT;
+  cinfo->do_fancy_upsampling = TRUE;
+  cinfo->do_block_smoothing = TRUE;
+  cinfo->quantize_colors = FALSE;
+  /* We set these in case application only sets quantize_colors. */
+  cinfo->dither_mode = JDITHER_FS;
+#ifdef QUANT_2PASS_SUPPORTED
+  cinfo->two_pass_quantize = TRUE;
+#else
+  cinfo->two_pass_quantize = FALSE;
+#endif
+  cinfo->desired_number_of_colors = 256;
+  cinfo->colormap = NULL;
+  /* Initialize for no mode change in buffered-image mode. */
+  cinfo->enable_1pass_quant = FALSE;
+  cinfo->enable_external_quant = FALSE;
+  cinfo->enable_2pass_quant = FALSE;
+}
+
+
+/*
+ * Decompression startup: read start of JPEG datastream to see what's there.
+ * Need only initialize JPEG object and supply a data source before calling.
+ *
+ * This routine will read as far as the first SOS marker (ie, actual start of
+ * compressed data), and will save all tables and parameters in the JPEG
+ * object.  It will also initialize the decompression parameters to default
+ * values, and finally return JPEG_HEADER_OK.  On return, the application may
+ * adjust the decompression parameters and then call jpeg_start_decompress.
+ * (Or, if the application only wanted to determine the image parameters,
+ * the data need not be decompressed.  In that case, call jpeg_abort or
+ * jpeg_destroy to release any temporary space.)
+ * If an abbreviated (tables only) datastream is presented, the routine will
+ * return JPEG_HEADER_TABLES_ONLY upon reaching EOI.  The application may then
+ * re-use the JPEG object to read the abbreviated image datastream(s).
+ * It is unnecessary (but OK) to call jpeg_abort in this case.
+ * The JPEG_SUSPENDED return code only occurs if the data source module
+ * requests suspension of the decompressor.  In this case the application
+ * should load more source data and then re-call jpeg_read_header to resume
+ * processing.
+ * If a non-suspending data source is used and require_image is TRUE, then the
+ * return code need not be inspected since only JPEG_HEADER_OK is possible.
+ *
+ * This routine is now just a front end to jpeg_consume_input, with some
+ * extra error checking.
+ */
+
+GLOBAL(int)
+jpeg_read_header (j_decompress_ptr cinfo, boolean require_image)
+{
+  int retcode;
+
+  if (cinfo->global_state != DSTATE_START &&
+      cinfo->global_state != DSTATE_INHEADER)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  retcode = jpeg_consume_input(cinfo);
+
+  switch (retcode) {
+  case JPEG_REACHED_SOS:
+    retcode = JPEG_HEADER_OK;
+    break;
+  case JPEG_REACHED_EOI:
+    if (require_image)		/* Complain if application wanted an image */
+      ERREXIT(cinfo, JERR_NO_IMAGE);
+    /* Reset to start state; it would be safer to require the application to
+     * call jpeg_abort, but we can't change it now for compatibility reasons.
+     * A side effect is to free any temporary memory (there shouldn't be any).
+     */
+    jpeg_abort((j_common_ptr) cinfo); /* sets state = DSTATE_START */
+    retcode = JPEG_HEADER_TABLES_ONLY;
+    break;
+  case JPEG_SUSPENDED:
+    /* no work */
+    break;
+  }
+
+  return retcode;
+}
+
+
+/*
+ * Consume data in advance of what the decompressor requires.
+ * This can be called at any time once the decompressor object has
+ * been created and a data source has been set up.
+ *
+ * This routine is essentially a state machine that handles a couple
+ * of critical state-transition actions, namely initial setup and
+ * transition from header scanning to ready-for-start_decompress.
+ * All the actual input is done via the input controller's consume_input
+ * method.
+ */
+
+GLOBAL(int)
+jpeg_consume_input (j_decompress_ptr cinfo)
+{
+  int retcode = JPEG_SUSPENDED;
+
+  /* NB: every possible DSTATE value should be listed in this switch */
+  switch (cinfo->global_state) {
+  case DSTATE_START:
+    /* Start-of-datastream actions: reset appropriate modules */
+    (*cinfo->inputctl->reset_input_controller) (cinfo);
+    /* Initialize application's data source module */
+    (*cinfo->src->init_source) (cinfo);
+    cinfo->global_state = DSTATE_INHEADER;
+    /*FALLTHROUGH*/
+  case DSTATE_INHEADER:
+    retcode = (*cinfo->inputctl->consume_input) (cinfo);
+    if (retcode == JPEG_REACHED_SOS) { /* Found SOS, prepare to decompress */
+      /* Set up default parameters based on header data */
+      default_decompress_parms(cinfo);
+      /* Set global state: ready for start_decompress */
+      cinfo->global_state = DSTATE_READY;
+    }
+    break;
+  case DSTATE_READY:
+    /* Can't advance past first SOS until start_decompress is called */
+    retcode = JPEG_REACHED_SOS;
+    break;
+  case DSTATE_PRELOAD:
+  case DSTATE_PRESCAN:
+  case DSTATE_SCANNING:
+  case DSTATE_RAW_OK:
+  case DSTATE_BUFIMAGE:
+  case DSTATE_BUFPOST:
+  case DSTATE_STOPPING:
+    retcode = (*cinfo->inputctl->consume_input) (cinfo);
+    break;
+  default:
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  }
+  return retcode;
+}
+
+
+/*
+ * Have we finished reading the input file?
+ */
+
+GLOBAL(boolean)
+jpeg_input_complete (j_decompress_ptr cinfo)
+{
+  /* Check for valid jpeg object */
+  if (cinfo->global_state < DSTATE_START ||
+      cinfo->global_state > DSTATE_STOPPING)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  return cinfo->inputctl->eoi_reached;
+}
+
+
+/*
+ * Is there more than one scan?
+ */
+
+GLOBAL(boolean)
+jpeg_has_multiple_scans (j_decompress_ptr cinfo)
+{
+  /* Only valid after jpeg_read_header completes */
+  if (cinfo->global_state < DSTATE_READY ||
+      cinfo->global_state > DSTATE_STOPPING)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  return cinfo->inputctl->has_multiple_scans;
+}
+
+
+/*
+ * Finish JPEG decompression.
+ *
+ * This will normally just verify the file trailer and release temp storage.
+ *
+ * Returns FALSE if suspended.  The return value need be inspected only if
+ * a suspending data source is used.
+ */
+
+GLOBAL(boolean)
+jpeg_finish_decompress (j_decompress_ptr cinfo)
+{
+  if ((cinfo->global_state == DSTATE_SCANNING ||
+       cinfo->global_state == DSTATE_RAW_OK) && ! cinfo->buffered_image) {
+    /* Terminate final pass of non-buffered mode */
+    if (cinfo->output_scanline < cinfo->output_height)
+      ERREXIT(cinfo, JERR_TOO_LITTLE_DATA);
+    (*cinfo->master->finish_output_pass) (cinfo);
+    cinfo->global_state = DSTATE_STOPPING;
+  } else if (cinfo->global_state == DSTATE_BUFIMAGE) {
+    /* Finishing after a buffered-image operation */
+    cinfo->global_state = DSTATE_STOPPING;
+  } else if (cinfo->global_state != DSTATE_STOPPING) {
+    /* STOPPING = repeat call after a suspension, anything else is error */
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  }
+  /* Read until EOI */
+  while (! cinfo->inputctl->eoi_reached) {
+    if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED)
+      return FALSE;		/* Suspend, come back later */
+  }
+  /* Do final cleanup */
+  (*cinfo->src->term_source) (cinfo);
+  /* We can use jpeg_abort to release memory and reset global_state */
+  jpeg_abort((j_common_ptr) cinfo);
+  return TRUE;
+}

src/jpeg/jdapistd.c

@@ -0,0 +1,275 @@
+/*
+ * jdapistd.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains application interface code for the decompression half
+ * of the JPEG library.  These are the "standard" API routines that are
+ * used in the normal full-decompression case.  They are not used by a
+ * transcoding-only application.  Note that if an application links in
+ * jpeg_start_decompress, it will end up linking in the entire decompressor.
+ * We thus must separate this file from jdapimin.c to avoid linking the
+ * whole decompression library into a transcoder.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Forward declarations */
+LOCAL(boolean) output_pass_setup JPP((j_decompress_ptr cinfo));
+
+
+/*
+ * Decompression initialization.
+ * jpeg_read_header must be completed before calling this.
+ *
+ * If a multipass operating mode was selected, this will do all but the
+ * last pass, and thus may take a great deal of time.
+ *
+ * Returns FALSE if suspended.  The return value need be inspected only if
+ * a suspending data source is used.
+ */
+
+GLOBAL(boolean)
+jpeg_start_decompress (j_decompress_ptr cinfo)
+{
+  if (cinfo->global_state == DSTATE_READY) {
+    /* First call: initialize master control, select active modules */
+    jinit_master_decompress(cinfo);
+    if (cinfo->buffered_image) {
+      /* No more work here; expecting jpeg_start_output next */
+      cinfo->global_state = DSTATE_BUFIMAGE;
+      return TRUE;
+    }
+    cinfo->global_state = DSTATE_PRELOAD;
+  }
+  if (cinfo->global_state == DSTATE_PRELOAD) {
+    /* If file has multiple scans, absorb them all into the coef buffer */
+    if (cinfo->inputctl->has_multiple_scans) {
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+      for (;;) {
+	int retcode;
+	/* Call progress monitor hook if present */
+	if (cinfo->progress != NULL)
+	  (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+	/* Absorb some more input */
+	retcode = (*cinfo->inputctl->consume_input) (cinfo);
+	if (retcode == JPEG_SUSPENDED)
+	  return FALSE;
+	if (retcode == JPEG_REACHED_EOI)
+	  break;
+	/* Advance progress counter if appropriate */
+	if (cinfo->progress != NULL &&
+	    (retcode == JPEG_ROW_COMPLETED || retcode == JPEG_REACHED_SOS)) {
+	  if (++cinfo->progress->pass_counter >= cinfo->progress->pass_limit) {
+	    /* jdmaster underestimated number of scans; ratchet up one scan */
+	    cinfo->progress->pass_limit += (long) cinfo->total_iMCU_rows;
+	  }
+	}
+      }
+#else
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif /* D_MULTISCAN_FILES_SUPPORTED */
+    }
+    cinfo->output_scan_number = cinfo->input_scan_number;
+  } else if (cinfo->global_state != DSTATE_PRESCAN)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  /* Perform any dummy output passes, and set up for the final pass */
+  return output_pass_setup(cinfo);
+}
+
+
+/*
+ * Set up for an output pass, and perform any dummy pass(es) needed.
+ * Common subroutine for jpeg_start_decompress and jpeg_start_output.
+ * Entry: global_state = DSTATE_PRESCAN only if previously suspended.
+ * Exit: If done, returns TRUE and sets global_state for proper output mode.
+ *       If suspended, returns FALSE and sets global_state = DSTATE_PRESCAN.
+ */
+
+LOCAL(boolean)
+output_pass_setup (j_decompress_ptr cinfo)
+{
+  if (cinfo->global_state != DSTATE_PRESCAN) {
+    /* First call: do pass setup */
+    (*cinfo->master->prepare_for_output_pass) (cinfo);
+    cinfo->output_scanline = 0;
+    cinfo->global_state = DSTATE_PRESCAN;
+  }
+  /* Loop over any required dummy passes */
+  while (cinfo->master->is_dummy_pass) {
+#ifdef QUANT_2PASS_SUPPORTED
+    /* Crank through the dummy pass */
+    while (cinfo->output_scanline < cinfo->output_height) {
+      JDIMENSION last_scanline;
+      /* Call progress monitor hook if present */
+      if (cinfo->progress != NULL) {
+	cinfo->progress->pass_counter = (long) cinfo->output_scanline;
+	cinfo->progress->pass_limit = (long) cinfo->output_height;
+	(*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+      }
+      /* Process some data */
+      last_scanline = cinfo->output_scanline;
+      (*cinfo->main->process_data) (cinfo, (JSAMPARRAY) NULL,
+				    &cinfo->output_scanline, (JDIMENSION) 0);
+      if (cinfo->output_scanline == last_scanline)
+	return FALSE;		/* No progress made, must suspend */
+    }
+    /* Finish up dummy pass, and set up for another one */
+    (*cinfo->master->finish_output_pass) (cinfo);
+    (*cinfo->master->prepare_for_output_pass) (cinfo);
+    cinfo->output_scanline = 0;
+#else
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif /* QUANT_2PASS_SUPPORTED */
+  }
+  /* Ready for application to drive output pass through
+   * jpeg_read_scanlines or jpeg_read_raw_data.
+   */
+  cinfo->global_state = cinfo->raw_data_out ? DSTATE_RAW_OK : DSTATE_SCANNING;
+  return TRUE;
+}
+
+
+/*
+ * Read some scanlines of data from the JPEG decompressor.
+ *
+ * The return value will be the number of lines actually read.
+ * This may be less than the number requested in several cases,
+ * including bottom of image, data source suspension, and operating
+ * modes that emit multiple scanlines at a time.
+ *
+ * Note: we warn about excess calls to jpeg_read_scanlines() since
+ * this likely signals an application programmer error.  However,
+ * an oversize buffer (max_lines > scanlines remaining) is not an error.
+ */
+
+GLOBAL(JDIMENSION)
+jpeg_read_scanlines (j_decompress_ptr cinfo, JSAMPARRAY scanlines,
+		     JDIMENSION max_lines)
+{
+  JDIMENSION row_ctr;
+
+  if (cinfo->global_state != DSTATE_SCANNING)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  if (cinfo->output_scanline >= cinfo->output_height) {
+    WARNMS(cinfo, JWRN_TOO_MUCH_DATA);
+    return 0;
+  }
+
+  /* Call progress monitor hook if present */
+  if (cinfo->progress != NULL) {
+    cinfo->progress->pass_counter = (long) cinfo->output_scanline;
+    cinfo->progress->pass_limit = (long) cinfo->output_height;
+    (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+  }
+
+  /* Process some data */
+  row_ctr = 0;
+  (*cinfo->main->process_data) (cinfo, scanlines, &row_ctr, max_lines);
+  cinfo->output_scanline += row_ctr;
+  return row_ctr;
+}
+
+
+/*
+ * Alternate entry point to read raw data.
+ * Processes exactly one iMCU row per call, unless suspended.
+ */
+
+GLOBAL(JDIMENSION)
+jpeg_read_raw_data (j_decompress_ptr cinfo, JSAMPIMAGE data,
+		    JDIMENSION max_lines)
+{
+  JDIMENSION lines_per_iMCU_row;
+
+  if (cinfo->global_state != DSTATE_RAW_OK)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  if (cinfo->output_scanline >= cinfo->output_height) {
+    WARNMS(cinfo, JWRN_TOO_MUCH_DATA);
+    return 0;
+  }
+
+  /* Call progress monitor hook if present */
+  if (cinfo->progress != NULL) {
+    cinfo->progress->pass_counter = (long) cinfo->output_scanline;
+    cinfo->progress->pass_limit = (long) cinfo->output_height;
+    (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+  }
+
+  /* Verify that at least one iMCU row can be returned. */
+  lines_per_iMCU_row = cinfo->max_v_samp_factor * cinfo->min_DCT_scaled_size;
+  if (max_lines < lines_per_iMCU_row)
+    ERREXIT(cinfo, JERR_BUFFER_SIZE);
+
+  /* Decompress directly into user's buffer. */
+  if (! (*cinfo->coef->decompress_data) (cinfo, data))
+    return 0;			/* suspension forced, can do nothing more */
+
+  /* OK, we processed one iMCU row. */
+  cinfo->output_scanline += lines_per_iMCU_row;
+  return lines_per_iMCU_row;
+}
+
+
+/* Additional entry points for buffered-image mode. */
+
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+
+/*
+ * Initialize for an output pass in buffered-image mode.
+ */
+
+GLOBAL(boolean)
+jpeg_start_output (j_decompress_ptr cinfo, int scan_number)
+{
+  if (cinfo->global_state != DSTATE_BUFIMAGE &&
+      cinfo->global_state != DSTATE_PRESCAN)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  /* Limit scan number to valid range */
+  if (scan_number <= 0)
+    scan_number = 1;
+  if (cinfo->inputctl->eoi_reached &&
+      scan_number > cinfo->input_scan_number)
+    scan_number = cinfo->input_scan_number;
+  cinfo->output_scan_number = scan_number;
+  /* Perform any dummy output passes, and set up for the real pass */
+  return output_pass_setup(cinfo);
+}
+
+
+/*
+ * Finish up after an output pass in buffered-image mode.
+ *
+ * Returns FALSE if suspended.  The return value need be inspected only if
+ * a suspending data source is used.
+ */
+
+GLOBAL(boolean)
+jpeg_finish_output (j_decompress_ptr cinfo)
+{
+  if ((cinfo->global_state == DSTATE_SCANNING ||
+       cinfo->global_state == DSTATE_RAW_OK) && cinfo->buffered_image) {
+    /* Terminate this pass. */
+    /* We do not require the whole pass to have been completed. */
+    (*cinfo->master->finish_output_pass) (cinfo);
+    cinfo->global_state = DSTATE_BUFPOST;
+  } else if (cinfo->global_state != DSTATE_BUFPOST) {
+    /* BUFPOST = repeat call after a suspension, anything else is error */
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  }
+  /* Read markers looking for SOS or EOI */
+  while (cinfo->input_scan_number <= cinfo->output_scan_number &&
+	 ! cinfo->inputctl->eoi_reached) {
+    if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED)
+      return FALSE;		/* Suspend, come back later */
+  }
+  cinfo->global_state = DSTATE_BUFIMAGE;
+  return TRUE;
+}
+
+#endif /* D_MULTISCAN_FILES_SUPPORTED */

src/jpeg/jdatadst.c

@@ -0,0 +1,151 @@
+/*
+ * jdatadst.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains compression data destination routines for the case of
+ * emitting JPEG data to a file (or any stdio stream).  While these routines
+ * are sufficient for most applications, some will want to use a different
+ * destination manager.
+ * IMPORTANT: we assume that fwrite() will correctly transcribe an array of
+ * JOCTETs into 8-bit-wide elements on external storage.  If char is wider
+ * than 8 bits on your machine, you may need to do some tweaking.
+ */
+
+/* this is not a core library module, so it doesn't define JPEG_INTERNALS */
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jerror.h"
+
+
+/* Expanded data destination object for stdio output */
+
+typedef struct {
+  struct jpeg_destination_mgr pub; /* public fields */
+
+  FILE * outfile;		/* target stream */
+  JOCTET * buffer;		/* start of buffer */
+} my_destination_mgr;
+
+typedef my_destination_mgr * my_dest_ptr;
+
+#define OUTPUT_BUF_SIZE  4096	/* choose an efficiently fwrite'able size */
+
+
+/*
+ * Initialize destination --- called by jpeg_start_compress
+ * before any data is actually written.
+ */
+
+METHODDEF(void)
+init_destination (j_compress_ptr cinfo)
+{
+  my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
+
+  /* Allocate the output buffer --- it will be released when done with image */
+  dest->buffer = (JOCTET *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  OUTPUT_BUF_SIZE * SIZEOF(JOCTET));
+
+  dest->pub.next_output_byte = dest->buffer;
+  dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
+}
+
+
+/*
+ * Empty the output buffer --- called whenever buffer fills up.
+ *
+ * In typical applications, this should write the entire output buffer
+ * (ignoring the current state of next_output_byte & free_in_buffer),
+ * reset the pointer & count to the start of the buffer, and return TRUE
+ * indicating that the buffer has been dumped.
+ *
+ * In applications that need to be able to suspend compression due to output
+ * overrun, a FALSE return indicates that the buffer cannot be emptied now.
+ * In this situation, the compressor will return to its caller (possibly with
+ * an indication that it has not accepted all the supplied scanlines).  The
+ * application should resume compression after it has made more room in the
+ * output buffer.  Note that there are substantial restrictions on the use of
+ * suspension --- see the documentation.
+ *
+ * When suspending, the compressor will back up to a convenient restart point
+ * (typically the start of the current MCU). next_output_byte & free_in_buffer
+ * indicate where the restart point will be if the current call returns FALSE.
+ * Data beyond this point will be regenerated after resumption, so do not
+ * write it out when emptying the buffer externally.
+ */
+
+METHODDEF(boolean)
+empty_output_buffer (j_compress_ptr cinfo)
+{
+  my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
+
+  if (JFWRITE(dest->outfile, dest->buffer, OUTPUT_BUF_SIZE) !=
+      (size_t) OUTPUT_BUF_SIZE)
+    ERREXIT(cinfo, JERR_FILE_WRITE);
+
+  dest->pub.next_output_byte = dest->buffer;
+  dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
+
+  return TRUE;
+}
+
+
+/*
+ * Terminate destination --- called by jpeg_finish_compress
+ * after all data has been written.  Usually needs to flush buffer.
+ *
+ * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding
+ * application must deal with any cleanup that should happen even
+ * for error exit.
+ */
+
+METHODDEF(void)
+term_destination (j_compress_ptr cinfo)
+{
+  my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
+  size_t datacount = OUTPUT_BUF_SIZE - dest->pub.free_in_buffer;
+
+  /* Write any data remaining in the buffer */
+  if (datacount > 0) {
+    if (JFWRITE(dest->outfile, dest->buffer, datacount) != datacount)
+      ERREXIT(cinfo, JERR_FILE_WRITE);
+  }
+  fflush(dest->outfile);
+  /* Make sure we wrote the output file OK */
+  if (ferror(dest->outfile))
+    ERREXIT(cinfo, JERR_FILE_WRITE);
+}
+
+
+/*
+ * Prepare for output to a stdio stream.
+ * The caller must have already opened the stream, and is responsible
+ * for closing it after finishing compression.
+ */
+
+GLOBAL(void)
+jpeg_stdio_dest (j_compress_ptr cinfo, FILE * outfile)
+{
+  my_dest_ptr dest;
+
+  /* The destination object is made permanent so that multiple JPEG images
+   * can be written to the same file without re-executing jpeg_stdio_dest.
+   * This makes it dangerous to use this manager and a different destination
+   * manager serially with the same JPEG object, because their private object
+   * sizes may be different.  Caveat programmer.
+   */
+  if (cinfo->dest == NULL) {	/* first time for this JPEG object? */
+    cinfo->dest = (struct jpeg_destination_mgr *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+				  SIZEOF(my_destination_mgr));
+  }
+
+  dest = (my_dest_ptr) cinfo->dest;
+  dest->pub.init_destination = init_destination;
+  dest->pub.empty_output_buffer = empty_output_buffer;
+  dest->pub.term_destination = term_destination;
+  dest->outfile = outfile;
+}

src/jpeg/jdatasrc.c

@@ -0,0 +1,212 @@
+/*
+ * jdatasrc.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains decompression data source routines for the case of
+ * reading JPEG data from a file (or any stdio stream).  While these routines
+ * are sufficient for most applications, some will want to use a different
+ * source manager.
+ * IMPORTANT: we assume that fread() will correctly transcribe an array of
+ * JOCTETs from 8-bit-wide elements on external storage.  If char is wider
+ * than 8 bits on your machine, you may need to do some tweaking.
+ */
+
+/* this is not a core library module, so it doesn't define JPEG_INTERNALS */
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jerror.h"
+
+
+/* Expanded data source object for stdio input */
+
+typedef struct {
+  struct jpeg_source_mgr pub;	/* public fields */
+
+  FILE * infile;		/* source stream */
+  JOCTET * buffer;		/* start of buffer */
+  boolean start_of_file;	/* have we gotten any data yet? */
+} my_source_mgr;
+
+typedef my_source_mgr * my_src_ptr;
+
+#define INPUT_BUF_SIZE  4096	/* choose an efficiently fread'able size */
+
+
+/*
+ * Initialize source --- called by jpeg_read_header
+ * before any data is actually read.
+ */
+
+METHODDEF(void)
+init_source (j_decompress_ptr cinfo)
+{
+  my_src_ptr src = (my_src_ptr) cinfo->src;
+
+  /* We reset the empty-input-file flag for each image,
+   * but we don't clear the input buffer.
+   * This is correct behavior for reading a series of images from one source.
+   */
+  src->start_of_file = TRUE;
+}
+
+
+/*
+ * Fill the input buffer --- called whenever buffer is emptied.
+ *
+ * In typical applications, this should read fresh data into the buffer
+ * (ignoring the current state of next_input_byte & bytes_in_buffer),
+ * reset the pointer & count to the start of the buffer, and return TRUE
+ * indicating that the buffer has been reloaded.  It is not necessary to
+ * fill the buffer entirely, only to obtain at least one more byte.
+ *
+ * There is no such thing as an EOF return.  If the end of the file has been
+ * reached, the routine has a choice of ERREXIT() or inserting fake data into
+ * the buffer.  In most cases, generating a warning message and inserting a
+ * fake EOI marker is the best course of action --- this will allow the
+ * decompressor to output however much of the image is there.  However,
+ * the resulting error message is misleading if the real problem is an empty
+ * input file, so we handle that case specially.
+ *
+ * In applications that need to be able to suspend compression due to input
+ * not being available yet, a FALSE return indicates that no more data can be
+ * obtained right now, but more may be forthcoming later.  In this situation,
+ * the decompressor will return to its caller (with an indication of the
+ * number of scanlines it has read, if any).  The application should resume
+ * decompression after it has loaded more data into the input buffer.  Note
+ * that there are substantial restrictions on the use of suspension --- see
+ * the documentation.
+ *
+ * When suspending, the decompressor will back up to a convenient restart point
+ * (typically the start of the current MCU). next_input_byte & bytes_in_buffer
+ * indicate where the restart point will be if the current call returns FALSE.
+ * Data beyond this point must be rescanned after resumption, so move it to
+ * the front of the buffer rather than discarding it.
+ */
+
+METHODDEF(boolean)
+fill_input_buffer (j_decompress_ptr cinfo)
+{
+  my_src_ptr src = (my_src_ptr) cinfo->src;
+  size_t nbytes;
+
+  nbytes = JFREAD(src->infile, src->buffer, INPUT_BUF_SIZE);
+
+  if (nbytes <= 0) {
+    if (src->start_of_file)	/* Treat empty input file as fatal error */
+      ERREXIT(cinfo, JERR_INPUT_EMPTY);
+    WARNMS(cinfo, JWRN_JPEG_EOF);
+    /* Insert a fake EOI marker */
+    src->buffer[0] = (JOCTET) 0xFF;
+    src->buffer[1] = (JOCTET) JPEG_EOI;
+    nbytes = 2;
+  }
+
+  src->pub.next_input_byte = src->buffer;
+  src->pub.bytes_in_buffer = nbytes;
+  src->start_of_file = FALSE;
+
+  return TRUE;
+}
+
+
+/*
+ * Skip data --- used to skip over a potentially large amount of
+ * uninteresting data (such as an APPn marker).
+ *
+ * Writers of suspendable-input applications must note that skip_input_data
+ * is not granted the right to give a suspension return.  If the skip extends
+ * beyond the data currently in the buffer, the buffer can be marked empty so
+ * that the next read will cause a fill_input_buffer call that can suspend.
+ * Arranging for additional bytes to be discarded before reloading the input
+ * buffer is the application writer's problem.
+ */
+
+METHODDEF(void)
+skip_input_data (j_decompress_ptr cinfo, long num_bytes)
+{
+  my_src_ptr src = (my_src_ptr) cinfo->src;
+
+  /* Just a dumb implementation for now.  Could use fseek() except
+   * it doesn't work on pipes.  Not clear that being smart is worth
+   * any trouble anyway --- large skips are infrequent.
+   */
+  if (num_bytes > 0) {
+    while (num_bytes > (long) src->pub.bytes_in_buffer) {
+      num_bytes -= (long) src->pub.bytes_in_buffer;
+      (void) fill_input_buffer(cinfo);
+      /* note we assume that fill_input_buffer will never return FALSE,
+       * so suspension need not be handled.
+       */
+    }
+    src->pub.next_input_byte += (size_t) num_bytes;
+    src->pub.bytes_in_buffer -= (size_t) num_bytes;
+  }
+}
+
+
+/*
+ * An additional method that can be provided by data source modules is the
+ * resync_to_restart method for error recovery in the presence of RST markers.
+ * For the moment, this source module just uses the default resync method
+ * provided by the JPEG library.  That method assumes that no backtracking
+ * is possible.
+ */
+
+
+/*
+ * Terminate source --- called by jpeg_finish_decompress
+ * after all data has been read.  Often a no-op.
+ *
+ * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding
+ * application must deal with any cleanup that should happen even
+ * for error exit.
+ */
+
+METHODDEF(void)
+term_source (j_decompress_ptr cinfo)
+{
+  /* no work necessary here */
+}
+
+
+/*
+ * Prepare for input from a stdio stream.
+ * The caller must have already opened the stream, and is responsible
+ * for closing it after finishing decompression.
+ */
+
+GLOBAL(void)
+jpeg_stdio_src (j_decompress_ptr cinfo, FILE * infile)
+{
+  my_src_ptr src;
+
+  /* The source object and input buffer are made permanent so that a series
+   * of JPEG images can be read from the same file by calling jpeg_stdio_src
+   * only before the first one.  (If we discarded the buffer at the end of
+   * one image, we'd likely lose the start of the next one.)
+   * This makes it unsafe to use this manager and a different source
+   * manager serially with the same JPEG object.  Caveat programmer.
+   */
+  if (cinfo->src == NULL) {	/* first time for this JPEG object? */
+    cinfo->src = (struct jpeg_source_mgr *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+				  SIZEOF(my_source_mgr));
+    src = (my_src_ptr) cinfo->src;
+    src->buffer = (JOCTET *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+				  INPUT_BUF_SIZE * SIZEOF(JOCTET));
+  }
+
+  src = (my_src_ptr) cinfo->src;
+  src->pub.init_source = init_source;
+  src->pub.fill_input_buffer = fill_input_buffer;
+  src->pub.skip_input_data = skip_input_data;
+  src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */
+  src->pub.term_source = term_source;
+  src->infile = infile;
+  src->pub.bytes_in_buffer = 0; /* forces fill_input_buffer on first read */
+  src->pub.next_input_byte = NULL; /* until buffer loaded */
+}

src/jpeg/jdcoefct.c

@@ -0,0 +1,736 @@
+/*
+ * jdcoefct.c
+ *
+ * Copyright (C) 1994-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the coefficient buffer controller for decompression.
+ * This controller is the top level of the JPEG decompressor proper.
+ * The coefficient buffer lies between entropy decoding and inverse-DCT steps.
+ *
+ * In buffered-image mode, this controller is the interface between
+ * input-oriented processing and output-oriented processing.
+ * Also, the input side (only) is used when reading a file for transcoding.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+/* Block smoothing is only applicable for progressive JPEG, so: */
+#ifndef D_PROGRESSIVE_SUPPORTED
+#undef BLOCK_SMOOTHING_SUPPORTED
+#endif
+
+/* Private buffer controller object */
+
+typedef struct {
+  struct jpeg_d_coef_controller pub; /* public fields */
+
+  /* These variables keep track of the current location of the input side. */
+  /* cinfo->input_iMCU_row is also used for this. */
+  JDIMENSION MCU_ctr;		/* counts MCUs processed in current row */
+  int MCU_vert_offset;		/* counts MCU rows within iMCU row */
+  int MCU_rows_per_iMCU_row;	/* number of such rows needed */
+
+  /* The output side's location is represented by cinfo->output_iMCU_row. */
+
+  /* In single-pass modes, it's sufficient to buffer just one MCU.
+   * We allocate a workspace of D_MAX_BLOCKS_IN_MCU coefficient blocks,
+   * and let the entropy decoder write into that workspace each time.
+   * (On 80x86, the workspace is FAR even though it's not really very big;
+   * this is to keep the module interfaces unchanged when a large coefficient
+   * buffer is necessary.)
+   * In multi-pass modes, this array points to the current MCU's blocks
+   * within the virtual arrays; it is used only by the input side.
+   */
+  JBLOCKROW MCU_buffer[D_MAX_BLOCKS_IN_MCU];
+
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+  /* In multi-pass modes, we need a virtual block array for each component. */
+  jvirt_barray_ptr whole_image[MAX_COMPONENTS];
+#endif
+
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+  /* When doing block smoothing, we latch coefficient Al values here */
+  int * coef_bits_latch;
+#define SAVED_COEFS  6		/* we save coef_bits[0..5] */
+#endif
+} my_coef_controller;
+
+typedef my_coef_controller * my_coef_ptr;
+
+/* Forward declarations */
+METHODDEF(int) decompress_onepass
+	JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf));
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+METHODDEF(int) decompress_data
+	JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf));
+#endif
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+LOCAL(boolean) smoothing_ok JPP((j_decompress_ptr cinfo));
+METHODDEF(int) decompress_smooth_data
+	JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf));
+#endif
+
+
+LOCAL(void)
+start_iMCU_row (j_decompress_ptr cinfo)
+/* Reset within-iMCU-row counters for a new row (input side) */
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+
+  /* In an interleaved scan, an MCU row is the same as an iMCU row.
+   * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
+   * But at the bottom of the image, process only what's left.
+   */
+  if (cinfo->comps_in_scan > 1) {
+    coef->MCU_rows_per_iMCU_row = 1;
+  } else {
+    if (cinfo->input_iMCU_row < (cinfo->total_iMCU_rows-1))
+      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
+    else
+      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
+  }
+
+  coef->MCU_ctr = 0;
+  coef->MCU_vert_offset = 0;
+}
+
+
+/*
+ * Initialize for an input processing pass.
+ */
+
+METHODDEF(void)
+start_input_pass (j_decompress_ptr cinfo)
+{
+  cinfo->input_iMCU_row = 0;
+  start_iMCU_row(cinfo);
+}
+
+
+/*
+ * Initialize for an output processing pass.
+ */
+
+METHODDEF(void)
+start_output_pass (j_decompress_ptr cinfo)
+{
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+
+  /* If multipass, check to see whether to use block smoothing on this pass */
+  if (coef->pub.coef_arrays != NULL) {
+    if (cinfo->do_block_smoothing && smoothing_ok(cinfo))
+      coef->pub.decompress_data = decompress_smooth_data;
+    else
+      coef->pub.decompress_data = decompress_data;
+  }
+#endif
+  cinfo->output_iMCU_row = 0;
+}
+
+
+/*
+ * Decompress and return some data in the single-pass case.
+ * Always attempts to emit one fully interleaved MCU row ("iMCU" row).
+ * Input and output must run in lockstep since we have only a one-MCU buffer.
+ * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
+ *
+ * NB: output_buf contains a plane for each component in image,
+ * which we index according to the component's SOF position.
+ */
+
+METHODDEF(int)
+decompress_onepass (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+  JDIMENSION MCU_col_num;	/* index of current MCU within row */
+  JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
+  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+  int blkn, ci, xindex, yindex, yoffset, useful_width;
+  JSAMPARRAY output_ptr;
+  JDIMENSION start_col, output_col;
+  jpeg_component_info *compptr;
+  inverse_DCT_method_ptr inverse_DCT;
+
+  /* Loop to process as much as one whole iMCU row */
+  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
+       yoffset++) {
+    for (MCU_col_num = coef->MCU_ctr; MCU_col_num <= last_MCU_col;
+	 MCU_col_num++) {
+      /* Try to fetch an MCU.  Entropy decoder expects buffer to be zeroed. */
+      jzero_far((void FAR *) coef->MCU_buffer[0],
+		(size_t) (cinfo->blocks_in_MCU * SIZEOF(JBLOCK)));
+      if (! (*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) {
+	/* Suspension forced; update state counters and exit */
+	coef->MCU_vert_offset = yoffset;
+	coef->MCU_ctr = MCU_col_num;
+	return JPEG_SUSPENDED;
+      }
+      /* Determine where data should go in output_buf and do the IDCT thing.
+       * We skip dummy blocks at the right and bottom edges (but blkn gets
+       * incremented past them!).  Note the inner loop relies on having
+       * allocated the MCU_buffer[] blocks sequentially.
+       */
+      blkn = 0;			/* index of current DCT block within MCU */
+      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+	compptr = cinfo->cur_comp_info[ci];
+	/* Don't bother to IDCT an uninteresting component. */
+	if (! compptr->component_needed) {
+	  blkn += compptr->MCU_blocks;
+	  continue;
+	}
+	inverse_DCT = cinfo->idct->inverse_DCT[compptr->component_index];
+	useful_width = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
+						    : compptr->last_col_width;
+	output_ptr = output_buf[compptr->component_index] +
+	  yoffset * compptr->DCT_scaled_size;
+	start_col = MCU_col_num * compptr->MCU_sample_width;
+	for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+	  if (cinfo->input_iMCU_row < last_iMCU_row ||
+	      yoffset+yindex < compptr->last_row_height) {
+	    output_col = start_col;
+	    for (xindex = 0; xindex < useful_width; xindex++) {
+	      (*inverse_DCT) (cinfo, compptr,
+			      (JCOEFPTR) coef->MCU_buffer[blkn+xindex],
+			      output_ptr, output_col);
+	      output_col += compptr->DCT_scaled_size;
+	    }
+	  }
+	  blkn += compptr->MCU_width;
+	  output_ptr += compptr->DCT_scaled_size;
+	}
+      }
+    }
+    /* Completed an MCU row, but perhaps not an iMCU row */
+    coef->MCU_ctr = 0;
+  }
+  /* Completed the iMCU row, advance counters for next one */
+  cinfo->output_iMCU_row++;
+  if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) {
+    start_iMCU_row(cinfo);
+    return JPEG_ROW_COMPLETED;
+  }
+  /* Completed the scan */
+  (*cinfo->inputctl->finish_input_pass) (cinfo);
+  return JPEG_SCAN_COMPLETED;
+}
+
+
+/*
+ * Dummy consume-input routine for single-pass operation.
+ */
+
+METHODDEF(int)
+dummy_consume_data (j_decompress_ptr cinfo)
+{
+  return JPEG_SUSPENDED;	/* Always indicate nothing was done */
+}
+
+
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+
+/*
+ * Consume input data and store it in the full-image coefficient buffer.
+ * We read as much as one fully interleaved MCU row ("iMCU" row) per call,
+ * ie, v_samp_factor block rows for each component in the scan.
+ * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
+ */
+
+METHODDEF(int)
+consume_data (j_decompress_ptr cinfo)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+  JDIMENSION MCU_col_num;	/* index of current MCU within row */
+  int blkn, ci, xindex, yindex, yoffset;
+  JDIMENSION start_col;
+  JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
+  JBLOCKROW buffer_ptr;
+  jpeg_component_info *compptr;
+
+  /* Align the virtual buffers for the components used in this scan. */
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    buffer[ci] = (*cinfo->mem->access_virt_barray)
+      ((j_common_ptr) cinfo, coef->whole_image[compptr->component_index],
+       cinfo->input_iMCU_row * compptr->v_samp_factor,
+       (JDIMENSION) compptr->v_samp_factor, TRUE);
+    /* Note: entropy decoder expects buffer to be zeroed,
+     * but this is handled automatically by the memory manager
+     * because we requested a pre-zeroed array.
+     */
+  }
+
+  /* Loop to process one whole iMCU row */
+  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
+       yoffset++) {
+    for (MCU_col_num = coef->MCU_ctr; MCU_col_num < cinfo->MCUs_per_row;
+	 MCU_col_num++) {
+      /* Construct list of pointers to DCT blocks belonging to this MCU */
+      blkn = 0;			/* index of current DCT block within MCU */
+      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+	compptr = cinfo->cur_comp_info[ci];
+	start_col = MCU_col_num * compptr->MCU_width;
+	for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+	  buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
+	  for (xindex = 0; xindex < compptr->MCU_width; xindex++) {
+	    coef->MCU_buffer[blkn++] = buffer_ptr++;
+	  }
+	}
+      }
+      /* Try to fetch the MCU. */
+      if (! (*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) {
+	/* Suspension forced; update state counters and exit */
+	coef->MCU_vert_offset = yoffset;
+	coef->MCU_ctr = MCU_col_num;
+	return JPEG_SUSPENDED;
+      }
+    }
+    /* Completed an MCU row, but perhaps not an iMCU row */
+    coef->MCU_ctr = 0;
+  }
+  /* Completed the iMCU row, advance counters for next one */
+  if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) {
+    start_iMCU_row(cinfo);
+    return JPEG_ROW_COMPLETED;
+  }
+  /* Completed the scan */
+  (*cinfo->inputctl->finish_input_pass) (cinfo);
+  return JPEG_SCAN_COMPLETED;
+}
+
+
+/*
+ * Decompress and return some data in the multi-pass case.
+ * Always attempts to emit one fully interleaved MCU row ("iMCU" row).
+ * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
+ *
+ * NB: output_buf contains a plane for each component in image.
+ */
+
+METHODDEF(int)
+decompress_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+  JDIMENSION block_num;
+  int ci, block_row, block_rows;
+  JBLOCKARRAY buffer;
+  JBLOCKROW buffer_ptr;
+  JSAMPARRAY output_ptr;
+  JDIMENSION output_col;
+  jpeg_component_info *compptr;
+  inverse_DCT_method_ptr inverse_DCT;
+
+  /* Force some input to be done if we are getting ahead of the input. */
+  while (cinfo->input_scan_number < cinfo->output_scan_number ||
+	 (cinfo->input_scan_number == cinfo->output_scan_number &&
+	  cinfo->input_iMCU_row <= cinfo->output_iMCU_row)) {
+    if ((*cinfo->inputctl->consume_input)(cinfo) == JPEG_SUSPENDED)
+      return JPEG_SUSPENDED;
+  }
+
+  /* OK, output from the virtual arrays. */
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Don't bother to IDCT an uninteresting component. */
+    if (! compptr->component_needed)
+      continue;
+    /* Align the virtual buffer for this component. */
+    buffer = (*cinfo->mem->access_virt_barray)
+      ((j_common_ptr) cinfo, coef->whole_image[ci],
+       cinfo->output_iMCU_row * compptr->v_samp_factor,
+       (JDIMENSION) compptr->v_samp_factor, FALSE);
+    /* Count non-dummy DCT block rows in this iMCU row. */
+    if (cinfo->output_iMCU_row < last_iMCU_row)
+      block_rows = compptr->v_samp_factor;
+    else {
+      /* NB: can't use last_row_height here; it is input-side-dependent! */
+      block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
+      if (block_rows == 0) block_rows = compptr->v_samp_factor;
+    }
+    inverse_DCT = cinfo->idct->inverse_DCT[ci];
+    output_ptr = output_buf[ci];
+    /* Loop over all DCT blocks to be processed. */
+    for (block_row = 0; block_row < block_rows; block_row++) {
+      buffer_ptr = buffer[block_row];
+      output_col = 0;
+      for (block_num = 0; block_num < compptr->width_in_blocks; block_num++) {
+	(*inverse_DCT) (cinfo, compptr, (JCOEFPTR) buffer_ptr,
+			output_ptr, output_col);
+	buffer_ptr++;
+	output_col += compptr->DCT_scaled_size;
+      }
+      output_ptr += compptr->DCT_scaled_size;
+    }
+  }
+
+  if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows)
+    return JPEG_ROW_COMPLETED;
+  return JPEG_SCAN_COMPLETED;
+}
+
+#endif /* D_MULTISCAN_FILES_SUPPORTED */
+
+
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+
+/*
+ * This code applies interblock smoothing as described by section K.8
+ * of the JPEG standard: the first 5 AC coefficients are estimated from
+ * the DC values of a DCT block and its 8 neighboring blocks.
+ * We apply smoothing only for progressive JPEG decoding, and only if
+ * the coefficients it can estimate are not yet known to full precision.
+ */
+
+/* Natural-order array positions of the first 5 zigzag-order coefficients */
+#define Q01_POS  1
+#define Q10_POS  8
+#define Q20_POS  16
+#define Q11_POS  9
+#define Q02_POS  2
+
+/*
+ * Determine whether block smoothing is applicable and safe.
+ * We also latch the current states of the coef_bits[] entries for the
+ * AC coefficients; otherwise, if the input side of the decompressor
+ * advances into a new scan, we might think the coefficients are known
+ * more accurately than they really are.
+ */
+
+LOCAL(boolean)
+smoothing_ok (j_decompress_ptr cinfo)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+  boolean smoothing_useful = FALSE;
+  int ci, coefi;
+  jpeg_component_info *compptr;
+  JQUANT_TBL * qtable;
+  int * coef_bits;
+  int * coef_bits_latch;
+
+  if (! cinfo->progressive_mode || cinfo->coef_bits == NULL)
+    return FALSE;
+
+  /* Allocate latch area if not already done */
+  if (coef->coef_bits_latch == NULL)
+    coef->coef_bits_latch = (int *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  cinfo->num_components *
+				  (SAVED_COEFS * SIZEOF(int)));
+  coef_bits_latch = coef->coef_bits_latch;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* All components' quantization values must already be latched. */
+    if ((qtable = compptr->quant_table) == NULL)
+      return FALSE;
+    /* Verify DC & first 5 AC quantizers are nonzero to avoid zero-divide. */
+    if (qtable->quantval[0] == 0 ||
+	qtable->quantval[Q01_POS] == 0 ||
+	qtable->quantval[Q10_POS] == 0 ||
+	qtable->quantval[Q20_POS] == 0 ||
+	qtable->quantval[Q11_POS] == 0 ||
+	qtable->quantval[Q02_POS] == 0)
+      return FALSE;
+    /* DC values must be at least partly known for all components. */
+    coef_bits = cinfo->coef_bits[ci];
+    if (coef_bits[0] < 0)
+      return FALSE;
+    /* Block smoothing is helpful if some AC coefficients remain inaccurate. */
+    for (coefi = 1; coefi <= 5; coefi++) {
+      coef_bits_latch[coefi] = coef_bits[coefi];
+      if (coef_bits[coefi] != 0)
+	smoothing_useful = TRUE;
+    }
+    coef_bits_latch += SAVED_COEFS;
+  }
+
+  return smoothing_useful;
+}
+
+
+/*
+ * Variant of decompress_data for use when doing block smoothing.
+ */
+
+METHODDEF(int)
+decompress_smooth_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+  JDIMENSION block_num, last_block_column;
+  int ci, block_row, block_rows, access_rows;
+  JBLOCKARRAY buffer;
+  JBLOCKROW buffer_ptr, prev_block_row, next_block_row;
+  JSAMPARRAY output_ptr;
+  JDIMENSION output_col;
+  jpeg_component_info *compptr;
+  inverse_DCT_method_ptr inverse_DCT;
+  boolean first_row, last_row;
+  JBLOCK workspace;
+  int *coef_bits;
+  JQUANT_TBL *quanttbl;
+  INT32 Q00,Q01,Q02,Q10,Q11,Q20, num;
+  int DC1,DC2,DC3,DC4,DC5,DC6,DC7,DC8,DC9;
+  int Al, pred;
+
+  /* Force some input to be done if we are getting ahead of the input. */
+  while (cinfo->input_scan_number <= cinfo->output_scan_number &&
+	 ! cinfo->inputctl->eoi_reached) {
+    if (cinfo->input_scan_number == cinfo->output_scan_number) {
+      /* If input is working on current scan, we ordinarily want it to
+       * have completed the current row.  But if input scan is DC,
+       * we want it to keep one row ahead so that next block row's DC
+       * values are up to date.
+       */
+      JDIMENSION delta = (cinfo->Ss == 0) ? 1 : 0;
+      if (cinfo->input_iMCU_row > cinfo->output_iMCU_row+delta)
+	break;
+    }
+    if ((*cinfo->inputctl->consume_input)(cinfo) == JPEG_SUSPENDED)
+      return JPEG_SUSPENDED;
+  }
+
+  /* OK, output from the virtual arrays. */
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Don't bother to IDCT an uninteresting component. */
+    if (! compptr->component_needed)
+      continue;
+    /* Count non-dummy DCT block rows in this iMCU row. */
+    if (cinfo->output_iMCU_row < last_iMCU_row) {
+      block_rows = compptr->v_samp_factor;
+      access_rows = block_rows * 2; /* this and next iMCU row */
+      last_row = FALSE;
+    } else {
+      /* NB: can't use last_row_height here; it is input-side-dependent! */
+      block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
+      if (block_rows == 0) block_rows = compptr->v_samp_factor;
+      access_rows = block_rows; /* this iMCU row only */
+      last_row = TRUE;
+    }
+    /* Align the virtual buffer for this component. */
+    if (cinfo->output_iMCU_row > 0) {
+      access_rows += compptr->v_samp_factor; /* prior iMCU row too */
+      buffer = (*cinfo->mem->access_virt_barray)
+	((j_common_ptr) cinfo, coef->whole_image[ci],
+	 (cinfo->output_iMCU_row - 1) * compptr->v_samp_factor,
+	 (JDIMENSION) access_rows, FALSE);
+      buffer += compptr->v_samp_factor;	/* point to current iMCU row */
+      first_row = FALSE;
+    } else {
+      buffer = (*cinfo->mem->access_virt_barray)
+	((j_common_ptr) cinfo, coef->whole_image[ci],
+	 (JDIMENSION) 0, (JDIMENSION) access_rows, FALSE);
+      first_row = TRUE;
+    }
+    /* Fetch component-dependent info */
+    coef_bits = coef->coef_bits_latch + (ci * SAVED_COEFS);
+    quanttbl = compptr->quant_table;
+    Q00 = quanttbl->quantval[0];
+    Q01 = quanttbl->quantval[Q01_POS];
+    Q10 = quanttbl->quantval[Q10_POS];
+    Q20 = quanttbl->quantval[Q20_POS];
+    Q11 = quanttbl->quantval[Q11_POS];
+    Q02 = quanttbl->quantval[Q02_POS];
+    inverse_DCT = cinfo->idct->inverse_DCT[ci];
+    output_ptr = output_buf[ci];
+    /* Loop over all DCT blocks to be processed. */
+    for (block_row = 0; block_row < block_rows; block_row++) {
+      buffer_ptr = buffer[block_row];
+      if (first_row && block_row == 0)
+	prev_block_row = buffer_ptr;
+      else
+	prev_block_row = buffer[block_row-1];
+      if (last_row && block_row == block_rows-1)
+	next_block_row = buffer_ptr;
+      else
+	next_block_row = buffer[block_row+1];
+      /* We fetch the surrounding DC values using a sliding-register approach.
+       * Initialize all nine here so as to do the right thing on narrow pics.
+       */
+      DC1 = DC2 = DC3 = (int) prev_block_row[0][0];
+      DC4 = DC5 = DC6 = (int) buffer_ptr[0][0];
+      DC7 = DC8 = DC9 = (int) next_block_row[0][0];
+      output_col = 0;
+      last_block_column = compptr->width_in_blocks - 1;
+      for (block_num = 0; block_num <= last_block_column; block_num++) {
+	/* Fetch current DCT block into workspace so we can modify it. */
+	jcopy_block_row(buffer_ptr, (JBLOCKROW) workspace, (JDIMENSION) 1);
+	/* Update DC values */
+	if (block_num < last_block_column) {
+	  DC3 = (int) prev_block_row[1][0];
+	  DC6 = (int) buffer_ptr[1][0];
+	  DC9 = (int) next_block_row[1][0];
+	}
+	/* Compute coefficient estimates per K.8.
+	 * An estimate is applied only if coefficient is still zero,
+	 * and is not known to be fully accurate.
+	 */
+	/* AC01 */
+	if ((Al=coef_bits[1]) != 0 && workspace[1] == 0) {
+	  num = 36 * Q00 * (DC4 - DC6);
+	  if (num >= 0) {
+	    pred = (int) (((Q01<<7) + num) / (Q01<<8));
+	    if (Al > 0 && pred >= (1<<Al))
+	      pred = (1<<Al)-1;
+	  } else {
+	    pred = (int) (((Q01<<7) - num) / (Q01<<8));
+	    if (Al > 0 && pred >= (1<<Al))
+	      pred = (1<<Al)-1;
+	    pred = -pred;
+	  }
+	  workspace[1] = (JCOEF) pred;
+	}
+	/* AC10 */
+	if ((Al=coef_bits[2]) != 0 && workspace[8] == 0) {
+	  num = 36 * Q00 * (DC2 - DC8);
+	  if (num >= 0) {
+	    pred = (int) (((Q10<<7) + num) / (Q10<<8));
+	    if (Al > 0 && pred >= (1<<Al))
+	      pred = (1<<Al)-1;
+	  } else {
+	    pred = (int) (((Q10<<7) - num) / (Q10<<8));
+	    if (Al > 0 && pred >= (1<<Al))
+	      pred = (1<<Al)-1;
+	    pred = -pred;
+	  }
+	  workspace[8] = (JCOEF) pred;
+	}
+	/* AC20 */
+	if ((Al=coef_bits[3]) != 0 && workspace[16] == 0) {
+	  num = 9 * Q00 * (DC2 + DC8 - 2*DC5);
+	  if (num >= 0) {
+	    pred = (int) (((Q20<<7) + num) / (Q20<<8));
+	    if (Al > 0 && pred >= (1<<Al))
+	      pred = (1<<Al)-1;
+	  } else {
+	    pred = (int) (((Q20<<7) - num) / (Q20<<8));
+	    if (Al > 0 && pred >= (1<<Al))
+	      pred = (1<<Al)-1;
+	    pred = -pred;
+	  }
+	  workspace[16] = (JCOEF) pred;
+	}
+	/* AC11 */
+	if ((Al=coef_bits[4]) != 0 && workspace[9] == 0) {
+	  num = 5 * Q00 * (DC1 - DC3 - DC7 + DC9);
+	  if (num >= 0) {
+	    pred = (int) (((Q11<<7) + num) / (Q11<<8));
+	    if (Al > 0 && pred >= (1<<Al))
+	      pred = (1<<Al)-1;
+	  } else {
+	    pred = (int) (((Q11<<7) - num) / (Q11<<8));
+	    if (Al > 0 && pred >= (1<<Al))
+	      pred = (1<<Al)-1;
+	    pred = -pred;
+	  }
+	  workspace[9] = (JCOEF) pred;
+	}
+	/* AC02 */
+	if ((Al=coef_bits[5]) != 0 && workspace[2] == 0) {
+	  num = 9 * Q00 * (DC4 + DC6 - 2*DC5);
+	  if (num >= 0) {
+	    pred = (int) (((Q02<<7) + num) / (Q02<<8));
+	    if (Al > 0 && pred >= (1<<Al))
+	      pred = (1<<Al)-1;
+	  } else {
+	    pred = (int) (((Q02<<7) - num) / (Q02<<8));
+	    if (Al > 0 && pred >= (1<<Al))
+	      pred = (1<<Al)-1;
+	    pred = -pred;
+	  }
+	  workspace[2] = (JCOEF) pred;
+	}
+	/* OK, do the IDCT */
+	(*inverse_DCT) (cinfo, compptr, (JCOEFPTR) workspace,
+			output_ptr, output_col);
+	/* Advance for next column */
+	DC1 = DC2; DC2 = DC3;
+	DC4 = DC5; DC5 = DC6;
+	DC7 = DC8; DC8 = DC9;
+	buffer_ptr++, prev_block_row++, next_block_row++;
+	output_col += compptr->DCT_scaled_size;
+      }
+      output_ptr += compptr->DCT_scaled_size;
+    }
+  }
+
+  if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows)
+    return JPEG_ROW_COMPLETED;
+  return JPEG_SCAN_COMPLETED;
+}
+
+#endif /* BLOCK_SMOOTHING_SUPPORTED */
+
+
+/*
+ * Initialize coefficient buffer controller.
+ */
+
+GLOBAL(void)
+jinit_d_coef_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
+{
+  my_coef_ptr coef;
+
+  coef = (my_coef_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_coef_controller));
+  cinfo->coef = (struct jpeg_d_coef_controller *) coef;
+  coef->pub.start_input_pass = start_input_pass;
+  coef->pub.start_output_pass = start_output_pass;
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+  coef->coef_bits_latch = NULL;
+#endif
+
+  /* Create the coefficient buffer. */
+  if (need_full_buffer) {
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+    /* Allocate a full-image virtual array for each component, */
+    /* padded to a multiple of samp_factor DCT blocks in each direction. */
+    /* Note we ask for a pre-zeroed array. */
+    int ci, access_rows;
+    jpeg_component_info *compptr;
+
+    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+	 ci++, compptr++) {
+      access_rows = compptr->v_samp_factor;
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+      /* If block smoothing could be used, need a bigger window */
+      if (cinfo->progressive_mode)
+	access_rows *= 3;
+#endif
+      coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
+	((j_common_ptr) cinfo, JPOOL_IMAGE, TRUE,
+	 (JDIMENSION) jround_up((long) compptr->width_in_blocks,
+				(long) compptr->h_samp_factor),
+	 (JDIMENSION) jround_up((long) compptr->height_in_blocks,
+				(long) compptr->v_samp_factor),
+	 (JDIMENSION) access_rows);
+    }
+    coef->pub.consume_data = consume_data;
+    coef->pub.decompress_data = decompress_data;
+    coef->pub.coef_arrays = coef->whole_image; /* link to virtual arrays */
+#else
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+  } else {
+    /* We only need a single-MCU buffer. */
+    JBLOCKROW buffer;
+    int i;
+
+    buffer = (JBLOCKROW)
+      (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  D_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
+    for (i = 0; i < D_MAX_BLOCKS_IN_MCU; i++) {
+      coef->MCU_buffer[i] = buffer + i;
+    }
+    coef->pub.consume_data = dummy_consume_data;
+    coef->pub.decompress_data = decompress_onepass;
+    coef->pub.coef_arrays = NULL; /* flag for no virtual arrays */
+  }
+}

src/jpeg/jdcolor.c

@@ -0,0 +1,396 @@
+/*
+ * jdcolor.c
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains output colorspace conversion routines.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Private subobject */
+
+typedef struct {
+  struct jpeg_color_deconverter pub; /* public fields */
+
+  /* Private state for YCC->RGB conversion */
+  int * Cr_r_tab;		/* => table for Cr to R conversion */
+  int * Cb_b_tab;		/* => table for Cb to B conversion */
+  INT32 * Cr_g_tab;		/* => table for Cr to G conversion */
+  INT32 * Cb_g_tab;		/* => table for Cb to G conversion */
+} my_color_deconverter;
+
+typedef my_color_deconverter * my_cconvert_ptr;
+
+
+/**************** YCbCr -> RGB conversion: most common case **************/
+
+/*
+ * YCbCr is defined per CCIR 601-1, except that Cb and Cr are
+ * normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5.
+ * The conversion equations to be implemented are therefore
+ *	R = Y                + 1.40200 * Cr
+ *	G = Y - 0.34414 * Cb - 0.71414 * Cr
+ *	B = Y + 1.77200 * Cb
+ * where Cb and Cr represent the incoming values less CENTERJSAMPLE.
+ * (These numbers are derived from TIFF 6.0 section 21, dated 3-June-92.)
+ *
+ * To avoid floating-point arithmetic, we represent the fractional constants
+ * as integers scaled up by 2^16 (about 4 digits precision); we have to divide
+ * the products by 2^16, with appropriate rounding, to get the correct answer.
+ * Notice that Y, being an integral input, does not contribute any fraction
+ * so it need not participate in the rounding.
+ *
+ * For even more speed, we avoid doing any multiplications in the inner loop
+ * by precalculating the constants times Cb and Cr for all possible values.
+ * For 8-bit JSAMPLEs this is very reasonable (only 256 entries per table);
+ * for 12-bit samples it is still acceptable.  It's not very reasonable for
+ * 16-bit samples, but if you want lossless storage you shouldn't be changing
+ * colorspace anyway.
+ * The Cr=>R and Cb=>B values can be rounded to integers in advance; the
+ * values for the G calculation are left scaled up, since we must add them
+ * together before rounding.
+ */
+
+#define SCALEBITS	16	/* speediest right-shift on some machines */
+#define ONE_HALF	((INT32) 1 << (SCALEBITS-1))
+#define FIX(x)		((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
+
+
+/*
+ * Initialize tables for YCC->RGB colorspace conversion.
+ */
+
+LOCAL(void)
+build_ycc_rgb_table (j_decompress_ptr cinfo)
+{
+  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+  int i;
+  INT32 x;
+  SHIFT_TEMPS
+
+  cconvert->Cr_r_tab = (int *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(MAXJSAMPLE+1) * SIZEOF(int));
+  cconvert->Cb_b_tab = (int *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(MAXJSAMPLE+1) * SIZEOF(int));
+  cconvert->Cr_g_tab = (INT32 *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(MAXJSAMPLE+1) * SIZEOF(INT32));
+  cconvert->Cb_g_tab = (INT32 *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(MAXJSAMPLE+1) * SIZEOF(INT32));
+
+  for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
+    /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
+    /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */
+    /* Cr=>R value is nearest int to 1.40200 * x */
+    cconvert->Cr_r_tab[i] = (int)
+		    RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS);
+    /* Cb=>B value is nearest int to 1.77200 * x */
+    cconvert->Cb_b_tab[i] = (int)
+		    RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS);
+    /* Cr=>G value is scaled-up -0.71414 * x */
+    cconvert->Cr_g_tab[i] = (- FIX(0.71414)) * x;
+    /* Cb=>G value is scaled-up -0.34414 * x */
+    /* We also add in ONE_HALF so that need not do it in inner loop */
+    cconvert->Cb_g_tab[i] = (- FIX(0.34414)) * x + ONE_HALF;
+  }
+}
+
+
+/*
+ * Convert some rows of samples to the output colorspace.
+ *
+ * Note that we change from noninterleaved, one-plane-per-component format
+ * to interleaved-pixel format.  The output buffer is therefore three times
+ * as wide as the input buffer.
+ * A starting row offset is provided only for the input buffer.  The caller
+ * can easily adjust the passed output_buf value to accommodate any row
+ * offset required on that side.
+ */
+
+METHODDEF(void)
+ycc_rgb_convert (j_decompress_ptr cinfo,
+		 JSAMPIMAGE input_buf, JDIMENSION input_row,
+		 JSAMPARRAY output_buf, int num_rows)
+{
+  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+  register int y, cb, cr;
+  register JSAMPROW outptr;
+  register JSAMPROW inptr0, inptr1, inptr2;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->output_width;
+  /* copy these pointers into registers if possible */
+  register JSAMPLE * range_limit = cinfo->sample_range_limit;
+  register int * Crrtab = cconvert->Cr_r_tab;
+  register int * Cbbtab = cconvert->Cb_b_tab;
+  register INT32 * Crgtab = cconvert->Cr_g_tab;
+  register INT32 * Cbgtab = cconvert->Cb_g_tab;
+  SHIFT_TEMPS
+
+  while (--num_rows >= 0) {
+    inptr0 = input_buf[0][input_row];
+    inptr1 = input_buf[1][input_row];
+    inptr2 = input_buf[2][input_row];
+    input_row++;
+    outptr = *output_buf++;
+    for (col = 0; col < num_cols; col++) {
+      y  = GETJSAMPLE(inptr0[col]);
+      cb = GETJSAMPLE(inptr1[col]);
+      cr = GETJSAMPLE(inptr2[col]);
+      /* Range-limiting is essential due to noise introduced by DCT losses. */
+      outptr[RGB_RED] =   range_limit[y + Crrtab[cr]];
+      outptr[RGB_GREEN] = range_limit[y +
+			      ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
+						 SCALEBITS))];
+      outptr[RGB_BLUE] =  range_limit[y + Cbbtab[cb]];
+      outptr += RGB_PIXELSIZE;
+    }
+  }
+}
+
+
+/**************** Cases other than YCbCr -> RGB **************/
+
+
+/*
+ * Color conversion for no colorspace change: just copy the data,
+ * converting from separate-planes to interleaved representation.
+ */
+
+METHODDEF(void)
+null_convert (j_decompress_ptr cinfo,
+	      JSAMPIMAGE input_buf, JDIMENSION input_row,
+	      JSAMPARRAY output_buf, int num_rows)
+{
+  register JSAMPROW inptr, outptr;
+  register JDIMENSION count;
+  register int num_components = cinfo->num_components;
+  JDIMENSION num_cols = cinfo->output_width;
+  int ci;
+
+  while (--num_rows >= 0) {
+    for (ci = 0; ci < num_components; ci++) {
+      inptr = input_buf[ci][input_row];
+      outptr = output_buf[0] + ci;
+      for (count = num_cols; count > 0; count--) {
+	*outptr = *inptr++;	/* needn't bother with GETJSAMPLE() here */
+	outptr += num_components;
+      }
+    }
+    input_row++;
+    output_buf++;
+  }
+}
+
+
+/*
+ * Color conversion for grayscale: just copy the data.
+ * This also works for YCbCr -> grayscale conversion, in which
+ * we just copy the Y (luminance) component and ignore chrominance.
+ */
+
+METHODDEF(void)
+grayscale_convert (j_decompress_ptr cinfo,
+		   JSAMPIMAGE input_buf, JDIMENSION input_row,
+		   JSAMPARRAY output_buf, int num_rows)
+{
+  jcopy_sample_rows(input_buf[0], (int) input_row, output_buf, 0,
+		    num_rows, cinfo->output_width);
+}
+
+
+/*
+ * Convert grayscale to RGB: just duplicate the graylevel three times.
+ * This is provided to support applications that don't want to cope
+ * with grayscale as a separate case.
+ */
+
+METHODDEF(void)
+gray_rgb_convert (j_decompress_ptr cinfo,
+		  JSAMPIMAGE input_buf, JDIMENSION input_row,
+		  JSAMPARRAY output_buf, int num_rows)
+{
+  register JSAMPROW inptr, outptr;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->output_width;
+
+  while (--num_rows >= 0) {
+    inptr = input_buf[0][input_row++];
+    outptr = *output_buf++;
+    for (col = 0; col < num_cols; col++) {
+      /* We can dispense with GETJSAMPLE() here */
+      outptr[RGB_RED] = outptr[RGB_GREEN] = outptr[RGB_BLUE] = inptr[col];
+      outptr += RGB_PIXELSIZE;
+    }
+  }
+}
+
+
+/*
+ * Adobe-style YCCK->CMYK conversion.
+ * We convert YCbCr to R=1-C, G=1-M, and B=1-Y using the same
+ * conversion as above, while passing K (black) unchanged.
+ * We assume build_ycc_rgb_table has been called.
+ */
+
+METHODDEF(void)
+ycck_cmyk_convert (j_decompress_ptr cinfo,
+		   JSAMPIMAGE input_buf, JDIMENSION input_row,
+		   JSAMPARRAY output_buf, int num_rows)
+{
+  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+  register int y, cb, cr;
+  register JSAMPROW outptr;
+  register JSAMPROW inptr0, inptr1, inptr2, inptr3;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->output_width;
+  /* copy these pointers into registers if possible */
+  register JSAMPLE * range_limit = cinfo->sample_range_limit;
+  register int * Crrtab = cconvert->Cr_r_tab;
+  register int * Cbbtab = cconvert->Cb_b_tab;
+  register INT32 * Crgtab = cconvert->Cr_g_tab;
+  register INT32 * Cbgtab = cconvert->Cb_g_tab;
+  SHIFT_TEMPS
+
+  while (--num_rows >= 0) {
+    inptr0 = input_buf[0][input_row];
+    inptr1 = input_buf[1][input_row];
+    inptr2 = input_buf[2][input_row];
+    inptr3 = input_buf[3][input_row];
+    input_row++;
+    outptr = *output_buf++;
+    for (col = 0; col < num_cols; col++) {
+      y  = GETJSAMPLE(inptr0[col]);
+      cb = GETJSAMPLE(inptr1[col]);
+      cr = GETJSAMPLE(inptr2[col]);
+      /* Range-limiting is essential due to noise introduced by DCT losses. */
+      outptr[0] = range_limit[MAXJSAMPLE - (y + Crrtab[cr])];	/* red */
+      outptr[1] = range_limit[MAXJSAMPLE - (y +			/* green */
+			      ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
+						 SCALEBITS)))];
+      outptr[2] = range_limit[MAXJSAMPLE - (y + Cbbtab[cb])];	/* blue */
+      /* K passes through unchanged */
+      outptr[3] = inptr3[col];	/* don't need GETJSAMPLE here */
+      outptr += 4;
+    }
+  }
+}
+
+
+/*
+ * Empty method for start_pass.
+ */
+
+METHODDEF(void)
+start_pass_dcolor (j_decompress_ptr cinfo)
+{
+  /* no work needed */
+}
+
+
+/*
+ * Module initialization routine for output colorspace conversion.
+ */
+
+GLOBAL(void)
+jinit_color_deconverter (j_decompress_ptr cinfo)
+{
+  my_cconvert_ptr cconvert;
+  int ci;
+
+  cconvert = (my_cconvert_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_color_deconverter));
+  cinfo->cconvert = (struct jpeg_color_deconverter *) cconvert;
+  cconvert->pub.start_pass = start_pass_dcolor;
+
+  /* Make sure num_components agrees with jpeg_color_space */
+  switch (cinfo->jpeg_color_space) {
+  case JCS_GRAYSCALE:
+    if (cinfo->num_components != 1)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    break;
+
+  case JCS_RGB:
+  case JCS_YCbCr:
+    if (cinfo->num_components != 3)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    break;
+
+  case JCS_CMYK:
+  case JCS_YCCK:
+    if (cinfo->num_components != 4)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    break;
+
+  default:			/* JCS_UNKNOWN can be anything */
+    if (cinfo->num_components < 1)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    break;
+  }
+
+  /* Set out_color_components and conversion method based on requested space.
+   * Also clear the component_needed flags for any unused components,
+   * so that earlier pipeline stages can avoid useless computation.
+   */
+
+  switch (cinfo->out_color_space) {
+  case JCS_GRAYSCALE:
+    cinfo->out_color_components = 1;
+    if (cinfo->jpeg_color_space == JCS_GRAYSCALE ||
+	cinfo->jpeg_color_space == JCS_YCbCr) {
+      cconvert->pub.color_convert = grayscale_convert;
+      /* For color->grayscale conversion, only the Y (0) component is needed */
+      for (ci = 1; ci < cinfo->num_components; ci++)
+	cinfo->comp_info[ci].component_needed = FALSE;
+    } else
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+
+  case JCS_RGB:
+    cinfo->out_color_components = RGB_PIXELSIZE;
+    if (cinfo->jpeg_color_space == JCS_YCbCr) {
+      cconvert->pub.color_convert = ycc_rgb_convert;
+      build_ycc_rgb_table(cinfo);
+    } else if (cinfo->jpeg_color_space == JCS_GRAYSCALE) {
+      cconvert->pub.color_convert = gray_rgb_convert;
+    } else if (cinfo->jpeg_color_space == JCS_RGB && RGB_PIXELSIZE == 3) {
+      cconvert->pub.color_convert = null_convert;
+    } else
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+
+  case JCS_CMYK:
+    cinfo->out_color_components = 4;
+    if (cinfo->jpeg_color_space == JCS_YCCK) {
+      cconvert->pub.color_convert = ycck_cmyk_convert;
+      build_ycc_rgb_table(cinfo);
+    } else if (cinfo->jpeg_color_space == JCS_CMYK) {
+      cconvert->pub.color_convert = null_convert;
+    } else
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+
+  default:
+    /* Permit null conversion to same output space */
+    if (cinfo->out_color_space == cinfo->jpeg_color_space) {
+      cinfo->out_color_components = cinfo->num_components;
+      cconvert->pub.color_convert = null_convert;
+    } else			/* unsupported non-null conversion */
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+  }
+
+  if (cinfo->quantize_colors)
+    cinfo->output_components = 1; /* single colormapped output component */
+  else
+    cinfo->output_components = cinfo->out_color_components;
+}

src/jpeg/jdct.h

@@ -0,0 +1,176 @@
+/*
+ * jdct.h
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This include file contains common declarations for the forward and
+ * inverse DCT modules.  These declarations are private to the DCT managers
+ * (jcdctmgr.c, jddctmgr.c) and the individual DCT algorithms.
+ * The individual DCT algorithms are kept in separate files to ease 
+ * machine-dependent tuning (e.g., assembly coding).
+ */
+
+
+/*
+ * A forward DCT routine is given a pointer to a work area of type DCTELEM[];
+ * the DCT is to be performed in-place in that buffer.  Type DCTELEM is int
+ * for 8-bit samples, INT32 for 12-bit samples.  (NOTE: Floating-point DCT
+ * implementations use an array of type FAST_FLOAT, instead.)
+ * The DCT inputs are expected to be signed (range +-CENTERJSAMPLE).
+ * The DCT outputs are returned scaled up by a factor of 8; they therefore
+ * have a range of +-8K for 8-bit data, +-128K for 12-bit data.  This
+ * convention improves accuracy in integer implementations and saves some
+ * work in floating-point ones.
+ * Quantization of the output coefficients is done by jcdctmgr.c.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+typedef int DCTELEM;		/* 16 or 32 bits is fine */
+#else
+typedef INT32 DCTELEM;		/* must have 32 bits */
+#endif
+
+typedef JMETHOD(void, forward_DCT_method_ptr, (DCTELEM * data));
+typedef JMETHOD(void, float_DCT_method_ptr, (FAST_FLOAT * data));
+
+
+/*
+ * An inverse DCT routine is given a pointer to the input JBLOCK and a pointer
+ * to an output sample array.  The routine must dequantize the input data as
+ * well as perform the IDCT; for dequantization, it uses the multiplier table
+ * pointed to by compptr->dct_table.  The output data is to be placed into the
+ * sample array starting at a specified column.  (Any row offset needed will
+ * be applied to the array pointer before it is passed to the IDCT code.)
+ * Note that the number of samples emitted by the IDCT routine is
+ * DCT_scaled_size * DCT_scaled_size.
+ */
+
+/* typedef inverse_DCT_method_ptr is declared in jpegint.h */
+
+/*
+ * Each IDCT routine has its own ideas about the best dct_table element type.
+ */
+
+typedef MULTIPLIER ISLOW_MULT_TYPE; /* short or int, whichever is faster */
+#if BITS_IN_JSAMPLE == 8
+typedef MULTIPLIER IFAST_MULT_TYPE; /* 16 bits is OK, use short if faster */
+#define IFAST_SCALE_BITS  2	/* fractional bits in scale factors */
+#else
+typedef INT32 IFAST_MULT_TYPE;	/* need 32 bits for scaled quantizers */
+#define IFAST_SCALE_BITS  13	/* fractional bits in scale factors */
+#endif
+typedef FAST_FLOAT FLOAT_MULT_TYPE; /* preferred floating type */
+
+
+/*
+ * Each IDCT routine is responsible for range-limiting its results and
+ * converting them to unsigned form (0..MAXJSAMPLE).  The raw outputs could
+ * be quite far out of range if the input data is corrupt, so a bulletproof
+ * range-limiting step is required.  We use a mask-and-table-lookup method
+ * to do the combined operations quickly.  See the comments with
+ * prepare_range_limit_table (in jdmaster.c) for more info.
+ */
+
+#define IDCT_range_limit(cinfo)  ((cinfo)->sample_range_limit + CENTERJSAMPLE)
+
+#define RANGE_MASK  (MAXJSAMPLE * 4 + 3) /* 2 bits wider than legal samples */
+
+
+/* Short forms of external names for systems with brain-damaged linkers. */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jpeg_fdct_islow		jFDislow
+#define jpeg_fdct_ifast		jFDifast
+#define jpeg_fdct_float		jFDfloat
+#define jpeg_idct_islow		jRDislow
+#define jpeg_idct_ifast		jRDifast
+#define jpeg_idct_float		jRDfloat
+#define jpeg_idct_4x4		jRD4x4
+#define jpeg_idct_2x2		jRD2x2
+#define jpeg_idct_1x1		jRD1x1
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+/* Extern declarations for the forward and inverse DCT routines. */
+
+EXTERN(void) jpeg_fdct_islow JPP((DCTELEM * data));
+EXTERN(void) jpeg_fdct_ifast JPP((DCTELEM * data));
+EXTERN(void) jpeg_fdct_float JPP((FAST_FLOAT * data));
+
+EXTERN(void) jpeg_idct_islow
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+	 JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_ifast
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+	 JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_float
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+	 JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_4x4
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+	 JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_2x2
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+	 JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_1x1
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+	 JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+
+
+/*
+ * Macros for handling fixed-point arithmetic; these are used by many
+ * but not all of the DCT/IDCT modules.
+ *
+ * All values are expected to be of type INT32.
+ * Fractional constants are scaled left by CONST_BITS bits.
+ * CONST_BITS is defined within each module using these macros,
+ * and may differ from one module to the next.
+ */
+
+#define ONE	((INT32) 1)
+#define CONST_SCALE (ONE << CONST_BITS)
+
+/* Convert a positive real constant to an integer scaled by CONST_SCALE.
+ * Caution: some C compilers fail to reduce "FIX(constant)" at compile time,
+ * thus causing a lot of useless floating-point operations at run time.
+ */
+
+#define FIX(x)	((INT32) ((x) * CONST_SCALE + 0.5))
+
+/* Descale and correctly round an INT32 value that's scaled by N bits.
+ * We assume RIGHT_SHIFT rounds towards minus infinity, so adding
+ * the fudge factor is correct for either sign of X.
+ */
+
+#define DESCALE(x,n)  RIGHT_SHIFT((x) + (ONE << ((n)-1)), n)
+
+/* Multiply an INT32 variable by an INT32 constant to yield an INT32 result.
+ * This macro is used only when the two inputs will actually be no more than
+ * 16 bits wide, so that a 16x16->32 bit multiply can be used instead of a
+ * full 32x32 multiply.  This provides a useful speedup on many machines.
+ * Unfortunately there is no way to specify a 16x16->32 multiply portably
+ * in C, but some C compilers will do the right thing if you provide the
+ * correct combination of casts.
+ */
+
+#ifdef SHORTxSHORT_32		/* may work if 'int' is 32 bits */
+#define MULTIPLY16C16(var,const)  (((INT16) (var)) * ((INT16) (const)))
+#endif
+#ifdef SHORTxLCONST_32		/* known to work with Microsoft C 6.0 */
+#define MULTIPLY16C16(var,const)  (((INT16) (var)) * ((INT32) (const)))
+#endif
+
+#ifndef MULTIPLY16C16		/* default definition */
+#define MULTIPLY16C16(var,const)  ((var) * (const))
+#endif
+
+/* Same except both inputs are variables. */
+
+#ifdef SHORTxSHORT_32		/* may work if 'int' is 32 bits */
+#define MULTIPLY16V16(var1,var2)  (((INT16) (var1)) * ((INT16) (var2)))
+#endif
+
+#ifndef MULTIPLY16V16		/* default definition */
+#define MULTIPLY16V16(var1,var2)  ((var1) * (var2))
+#endif

src/jpeg/jddctmgr.c

@@ -0,0 +1,269 @@
+/*
+ * jddctmgr.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the inverse-DCT management logic.
+ * This code selects a particular IDCT implementation to be used,
+ * and it performs related housekeeping chores.  No code in this file
+ * is executed per IDCT step, only during output pass setup.
+ *
+ * Note that the IDCT routines are responsible for performing coefficient
+ * dequantization as well as the IDCT proper.  This module sets up the
+ * dequantization multiplier table needed by the IDCT routine.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h"		/* Private declarations for DCT subsystem */
+
+
+/*
+ * The decompressor input side (jdinput.c) saves away the appropriate
+ * quantization table for each component at the start of the first scan
+ * involving that component.  (This is necessary in order to correctly
+ * decode files that reuse Q-table slots.)
+ * When we are ready to make an output pass, the saved Q-table is converted
+ * to a multiplier table that will actually be used by the IDCT routine.
+ * The multiplier table contents are IDCT-method-dependent.  To support
+ * application changes in IDCT method between scans, we can remake the
+ * multiplier tables if necessary.
+ * In buffered-image mode, the first output pass may occur before any data
+ * has been seen for some components, and thus before their Q-tables have
+ * been saved away.  To handle this case, multiplier tables are preset
+ * to zeroes; the result of the IDCT will be a neutral gray level.
+ */
+
+
+/* Private subobject for this module */
+
+typedef struct {
+  struct jpeg_inverse_dct pub;	/* public fields */
+
+  /* This array contains the IDCT method code that each multiplier table
+   * is currently set up for, or -1 if it's not yet set up.
+   * The actual multiplier tables are pointed to by dct_table in the
+   * per-component comp_info structures.
+   */
+  int cur_method[MAX_COMPONENTS];
+} my_idct_controller;
+
+typedef my_idct_controller * my_idct_ptr;
+
+
+/* Allocated multiplier tables: big enough for any supported variant */
+
+typedef union {
+  ISLOW_MULT_TYPE islow_array[DCTSIZE2];
+#ifdef DCT_IFAST_SUPPORTED
+  IFAST_MULT_TYPE ifast_array[DCTSIZE2];
+#endif
+#ifdef DCT_FLOAT_SUPPORTED
+  FLOAT_MULT_TYPE float_array[DCTSIZE2];
+#endif
+} multiplier_table;
+
+
+/* The current scaled-IDCT routines require ISLOW-style multiplier tables,
+ * so be sure to compile that code if either ISLOW or SCALING is requested.
+ */
+#ifdef DCT_ISLOW_SUPPORTED
+#define PROVIDE_ISLOW_TABLES
+#else
+#ifdef IDCT_SCALING_SUPPORTED
+#define PROVIDE_ISLOW_TABLES
+#endif
+#endif
+
+
+/*
+ * Prepare for an output pass.
+ * Here we select the proper IDCT routine for each component and build
+ * a matching multiplier table.
+ */
+
+METHODDEF(void)
+start_pass (j_decompress_ptr cinfo)
+{
+  my_idct_ptr idct = (my_idct_ptr) cinfo->idct;
+  int ci, i;
+  jpeg_component_info *compptr;
+  int method = 0;
+  inverse_DCT_method_ptr method_ptr = NULL;
+  JQUANT_TBL * qtbl;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Select the proper IDCT routine for this component's scaling */
+    switch (compptr->DCT_scaled_size) {
+#ifdef IDCT_SCALING_SUPPORTED
+    case 1:
+      method_ptr = jpeg_idct_1x1;
+      method = JDCT_ISLOW;	/* jidctred uses islow-style table */
+      break;
+    case 2:
+      method_ptr = jpeg_idct_2x2;
+      method = JDCT_ISLOW;	/* jidctred uses islow-style table */
+      break;
+    case 4:
+      method_ptr = jpeg_idct_4x4;
+      method = JDCT_ISLOW;	/* jidctred uses islow-style table */
+      break;
+#endif
+    case DCTSIZE:
+      switch (cinfo->dct_method) {
+#ifdef DCT_ISLOW_SUPPORTED
+      case JDCT_ISLOW:
+	method_ptr = jpeg_idct_islow;
+	method = JDCT_ISLOW;
+	break;
+#endif
+#ifdef DCT_IFAST_SUPPORTED
+      case JDCT_IFAST:
+	method_ptr = jpeg_idct_ifast;
+	method = JDCT_IFAST;
+	break;
+#endif
+#ifdef DCT_FLOAT_SUPPORTED
+      case JDCT_FLOAT:
+	method_ptr = jpeg_idct_float;
+	method = JDCT_FLOAT;
+	break;
+#endif
+      default:
+	ERREXIT(cinfo, JERR_NOT_COMPILED);
+	break;
+      }
+      break;
+    default:
+      ERREXIT1(cinfo, JERR_BAD_DCTSIZE, compptr->DCT_scaled_size);
+      break;
+    }
+    idct->pub.inverse_DCT[ci] = method_ptr;
+    /* Create multiplier table from quant table.
+     * However, we can skip this if the component is uninteresting
+     * or if we already built the table.  Also, if no quant table
+     * has yet been saved for the component, we leave the
+     * multiplier table all-zero; we'll be reading zeroes from the
+     * coefficient controller's buffer anyway.
+     */
+    if (! compptr->component_needed || idct->cur_method[ci] == method)
+      continue;
+    qtbl = compptr->quant_table;
+    if (qtbl == NULL)		/* happens if no data yet for component */
+      continue;
+    idct->cur_method[ci] = method;
+    switch (method) {
+#ifdef PROVIDE_ISLOW_TABLES
+    case JDCT_ISLOW:
+      {
+	/* For LL&M IDCT method, multipliers are equal to raw quantization
+	 * coefficients, but are stored as ints to ensure access efficiency.
+	 */
+	ISLOW_MULT_TYPE * ismtbl = (ISLOW_MULT_TYPE *) compptr->dct_table;
+	for (i = 0; i < DCTSIZE2; i++) {
+	  ismtbl[i] = (ISLOW_MULT_TYPE) qtbl->quantval[i];
+	}
+      }
+      break;
+#endif
+#ifdef DCT_IFAST_SUPPORTED
+    case JDCT_IFAST:
+      {
+	/* For AA&N IDCT method, multipliers are equal to quantization
+	 * coefficients scaled by scalefactor[row]*scalefactor[col], where
+	 *   scalefactor[0] = 1
+	 *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
+	 * For integer operation, the multiplier table is to be scaled by
+	 * IFAST_SCALE_BITS.
+	 */
+	IFAST_MULT_TYPE * ifmtbl = (IFAST_MULT_TYPE *) compptr->dct_table;
+#define CONST_BITS 14
+	static const INT16 aanscales[DCTSIZE2] = {
+	  /* precomputed values scaled up by 14 bits */
+	  16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
+	  22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
+	  21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
+	  19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
+	  16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
+	  12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
+	   8867, 12299, 11585, 10426,  8867,  6967,  4799,  2446,
+	   4520,  6270,  5906,  5315,  4520,  3552,  2446,  1247
+	};
+	SHIFT_TEMPS
+
+	for (i = 0; i < DCTSIZE2; i++) {
+	  ifmtbl[i] = (IFAST_MULT_TYPE)
+	    DESCALE(MULTIPLY16V16((INT32) qtbl->quantval[i],
+				  (INT32) aanscales[i]),
+		    CONST_BITS-IFAST_SCALE_BITS);
+	}
+      }
+      break;
+#endif
+#ifdef DCT_FLOAT_SUPPORTED
+    case JDCT_FLOAT:
+      {
+	/* For float AA&N IDCT method, multipliers are equal to quantization
+	 * coefficients scaled by scalefactor[row]*scalefactor[col], where
+	 *   scalefactor[0] = 1
+	 *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
+	 */
+	FLOAT_MULT_TYPE * fmtbl = (FLOAT_MULT_TYPE *) compptr->dct_table;
+	int row, col;
+	static const double aanscalefactor[DCTSIZE] = {
+	  1.0, 1.387039845, 1.306562965, 1.175875602,
+	  1.0, 0.785694958, 0.541196100, 0.275899379
+	};
+
+	i = 0;
+	for (row = 0; row < DCTSIZE; row++) {
+	  for (col = 0; col < DCTSIZE; col++) {
+	    fmtbl[i] = (FLOAT_MULT_TYPE)
+	      ((double) qtbl->quantval[i] *
+	       aanscalefactor[row] * aanscalefactor[col]);
+	    i++;
+	  }
+	}
+      }
+      break;
+#endif
+    default:
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+      break;
+    }
+  }
+}
+
+
+/*
+ * Initialize IDCT manager.
+ */
+
+GLOBAL(void)
+jinit_inverse_dct (j_decompress_ptr cinfo)
+{
+  my_idct_ptr idct;
+  int ci;
+  jpeg_component_info *compptr;
+
+  idct = (my_idct_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_idct_controller));
+  cinfo->idct = (struct jpeg_inverse_dct *) idct;
+  idct->pub.start_pass = start_pass;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Allocate and pre-zero a multiplier table for each component */
+    compptr->dct_table =
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  SIZEOF(multiplier_table));
+    MEMZERO(compptr->dct_table, SIZEOF(multiplier_table));
+    /* Mark multiplier table not yet set up for any method */
+    idct->cur_method[ci] = -1;
+  }
+}

src/jpeg/jdhuff.c

@@ -0,0 +1,651 @@
+/*
+ * jdhuff.c
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains Huffman entropy decoding routines.
+ *
+ * Much of the complexity here has to do with supporting input suspension.
+ * If the data source module demands suspension, we want to be able to back
+ * up to the start of the current MCU.  To do this, we copy state variables
+ * into local working storage, and update them back to the permanent
+ * storage only upon successful completion of an MCU.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdhuff.h"		/* Declarations shared with jdphuff.c */
+
+
+/*
+ * Expanded entropy decoder object for Huffman decoding.
+ *
+ * The savable_state subrecord contains fields that change within an MCU,
+ * but must not be updated permanently until we complete the MCU.
+ */
+
+typedef struct {
+  int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
+} savable_state;
+
+/* This macro is to work around compilers with missing or broken
+ * structure assignment.  You'll need to fix this code if you have
+ * such a compiler and you change MAX_COMPS_IN_SCAN.
+ */
+
+#ifndef NO_STRUCT_ASSIGN
+#define ASSIGN_STATE(dest,src)  ((dest) = (src))
+#else
+#if MAX_COMPS_IN_SCAN == 4
+#define ASSIGN_STATE(dest,src)  \
+	((dest).last_dc_val[0] = (src).last_dc_val[0], \
+	 (dest).last_dc_val[1] = (src).last_dc_val[1], \
+	 (dest).last_dc_val[2] = (src).last_dc_val[2], \
+	 (dest).last_dc_val[3] = (src).last_dc_val[3])
+#endif
+#endif
+
+
+typedef struct {
+  struct jpeg_entropy_decoder pub; /* public fields */
+
+  /* These fields are loaded into local variables at start of each MCU.
+   * In case of suspension, we exit WITHOUT updating them.
+   */
+  bitread_perm_state bitstate;	/* Bit buffer at start of MCU */
+  savable_state saved;		/* Other state at start of MCU */
+
+  /* These fields are NOT loaded into local working state. */
+  unsigned int restarts_to_go;	/* MCUs left in this restart interval */
+
+  /* Pointers to derived tables (these workspaces have image lifespan) */
+  d_derived_tbl * dc_derived_tbls[NUM_HUFF_TBLS];
+  d_derived_tbl * ac_derived_tbls[NUM_HUFF_TBLS];
+
+  /* Precalculated info set up by start_pass for use in decode_mcu: */
+
+  /* Pointers to derived tables to be used for each block within an MCU */
+  d_derived_tbl * dc_cur_tbls[D_MAX_BLOCKS_IN_MCU];
+  d_derived_tbl * ac_cur_tbls[D_MAX_BLOCKS_IN_MCU];
+  /* Whether we care about the DC and AC coefficient values for each block */
+  boolean dc_needed[D_MAX_BLOCKS_IN_MCU];
+  boolean ac_needed[D_MAX_BLOCKS_IN_MCU];
+} huff_entropy_decoder;
+
+typedef huff_entropy_decoder * huff_entropy_ptr;
+
+
+/*
+ * Initialize for a Huffman-compressed scan.
+ */
+
+METHODDEF(void)
+start_pass_huff_decoder (j_decompress_ptr cinfo)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+  int ci, blkn, dctbl, actbl;
+  jpeg_component_info * compptr;
+
+  /* Check that the scan parameters Ss, Se, Ah/Al are OK for sequential JPEG.
+   * This ought to be an error condition, but we make it a warning because
+   * there are some baseline files out there with all zeroes in these bytes.
+   */
+  if (cinfo->Ss != 0 || cinfo->Se != DCTSIZE2-1 ||
+      cinfo->Ah != 0 || cinfo->Al != 0)
+    WARNMS(cinfo, JWRN_NOT_SEQUENTIAL);
+
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    dctbl = compptr->dc_tbl_no;
+    actbl = compptr->ac_tbl_no;
+    /* Compute derived values for Huffman tables */
+    /* We may do this more than once for a table, but it's not expensive */
+    jpeg_make_d_derived_tbl(cinfo, TRUE, dctbl,
+			    & entropy->dc_derived_tbls[dctbl]);
+    jpeg_make_d_derived_tbl(cinfo, FALSE, actbl,
+			    & entropy->ac_derived_tbls[actbl]);
+    /* Initialize DC predictions to 0 */
+    entropy->saved.last_dc_val[ci] = 0;
+  }
+
+  /* Precalculate decoding info for each block in an MCU of this scan */
+  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+    ci = cinfo->MCU_membership[blkn];
+    compptr = cinfo->cur_comp_info[ci];
+    /* Precalculate which table to use for each block */
+    entropy->dc_cur_tbls[blkn] = entropy->dc_derived_tbls[compptr->dc_tbl_no];
+    entropy->ac_cur_tbls[blkn] = entropy->ac_derived_tbls[compptr->ac_tbl_no];
+    /* Decide whether we really care about the coefficient values */
+    if (compptr->component_needed) {
+      entropy->dc_needed[blkn] = TRUE;
+      /* we don't need the ACs if producing a 1/8th-size image */
+      entropy->ac_needed[blkn] = (compptr->DCT_scaled_size > 1);
+    } else {
+      entropy->dc_needed[blkn] = entropy->ac_needed[blkn] = FALSE;
+    }
+  }
+
+  /* Initialize bitread state variables */
+  entropy->bitstate.bits_left = 0;
+  entropy->bitstate.get_buffer = 0; /* unnecessary, but keeps Purify quiet */
+  entropy->pub.insufficient_data = FALSE;
+
+  /* Initialize restart counter */
+  entropy->restarts_to_go = cinfo->restart_interval;
+}
+
+
+/*
+ * Compute the derived values for a Huffman table.
+ * This routine also performs some validation checks on the table.
+ *
+ * Note this is also used by jdphuff.c.
+ */
+
+GLOBAL(void)
+jpeg_make_d_derived_tbl (j_decompress_ptr cinfo, boolean isDC, int tblno,
+			 d_derived_tbl ** pdtbl)
+{
+  JHUFF_TBL *htbl;
+  d_derived_tbl *dtbl;
+  int p, i, l, si, numsymbols;
+  int lookbits, ctr;
+  char huffsize[257];
+  unsigned int huffcode[257];
+  unsigned int code;
+
+  /* Note that huffsize[] and huffcode[] are filled in code-length order,
+   * paralleling the order of the symbols themselves in htbl->huffval[].
+   */
+
+  /* Find the input Huffman table */
+  if (tblno < 0 || tblno >= NUM_HUFF_TBLS)
+    ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
+  htbl =
+    isDC ? cinfo->dc_huff_tbl_ptrs[tblno] : cinfo->ac_huff_tbl_ptrs[tblno];
+  if (htbl == NULL)
+    ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
+
+  /* Allocate a workspace if we haven't already done so. */
+  if (*pdtbl == NULL)
+    *pdtbl = (d_derived_tbl *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  SIZEOF(d_derived_tbl));
+  dtbl = *pdtbl;
+  dtbl->pub = htbl;		/* fill in back link */
+  
+  /* Figure C.1: make table of Huffman code length for each symbol */
+
+  p = 0;
+  for (l = 1; l <= 16; l++) {
+    i = (int) htbl->bits[l];
+    if (i < 0 || p + i > 256)	/* protect against table overrun */
+      ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
+    while (i--)
+      huffsize[p++] = (char) l;
+  }
+  huffsize[p] = 0;
+  numsymbols = p;
+  
+  /* Figure C.2: generate the codes themselves */
+  /* We also validate that the counts represent a legal Huffman code tree. */
+  
+  code = 0;
+  si = huffsize[0];
+  p = 0;
+  while (huffsize[p]) {
+    while (((int) huffsize[p]) == si) {
+      huffcode[p++] = code;
+      code++;
+    }
+    /* code is now 1 more than the last code used for codelength si; but
+     * it must still fit in si bits, since no code is allowed to be all ones.
+     */
+    if (((INT32) code) >= (((INT32) 1) << si))
+      ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
+    code <<= 1;
+    si++;
+  }
+
+  /* Figure F.15: generate decoding tables for bit-sequential decoding */
+
+  p = 0;
+  for (l = 1; l <= 16; l++) {
+    if (htbl->bits[l]) {
+      /* valoffset[l] = huffval[] index of 1st symbol of code length l,
+       * minus the minimum code of length l
+       */
+      dtbl->valoffset[l] = (INT32) p - (INT32) huffcode[p];
+      p += htbl->bits[l];
+      dtbl->maxcode[l] = huffcode[p-1]; /* maximum code of length l */
+    } else {
+      dtbl->maxcode[l] = -1;	/* -1 if no codes of this length */
+    }
+  }
+  dtbl->maxcode[17] = 0xFFFFFL; /* ensures jpeg_huff_decode terminates */
+
+  /* Compute lookahead tables to speed up decoding.
+   * First we set all the table entries to 0, indicating "too long";
+   * then we iterate through the Huffman codes that are short enough and
+   * fill in all the entries that correspond to bit sequences starting
+   * with that code.
+   */
+
+  MEMZERO(dtbl->look_nbits, SIZEOF(dtbl->look_nbits));
+
+  p = 0;
+  for (l = 1; l <= HUFF_LOOKAHEAD; l++) {
+    for (i = 1; i <= (int) htbl->bits[l]; i++, p++) {
+      /* l = current code's length, p = its index in huffcode[] & huffval[]. */
+      /* Generate left-justified code followed by all possible bit sequences */
+      lookbits = huffcode[p] << (HUFF_LOOKAHEAD-l);
+      for (ctr = 1 << (HUFF_LOOKAHEAD-l); ctr > 0; ctr--) {
+	dtbl->look_nbits[lookbits] = l;
+	dtbl->look_sym[lookbits] = htbl->huffval[p];
+	lookbits++;
+      }
+    }
+  }
+
+  /* Validate symbols as being reasonable.
+   * For AC tables, we make no check, but accept all byte values 0..255.
+   * For DC tables, we require the symbols to be in range 0..15.
+   * (Tighter bounds could be applied depending on the data depth and mode,
+   * but this is sufficient to ensure safe decoding.)
+   */
+  if (isDC) {
+    for (i = 0; i < numsymbols; i++) {
+      int sym = htbl->huffval[i];
+      if (sym < 0 || sym > 15)
+	ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
+    }
+  }
+}
+
+
+/*
+ * Out-of-line code for bit fetching (shared with jdphuff.c).
+ * See jdhuff.h for info about usage.
+ * Note: current values of get_buffer and bits_left are passed as parameters,
+ * but are returned in the corresponding fields of the state struct.
+ *
+ * On most machines MIN_GET_BITS should be 25 to allow the full 32-bit width
+ * of get_buffer to be used.  (On machines with wider words, an even larger
+ * buffer could be used.)  However, on some machines 32-bit shifts are
+ * quite slow and take time proportional to the number of places shifted.
+ * (This is true with most PC compilers, for instance.)  In this case it may
+ * be a win to set MIN_GET_BITS to the minimum value of 15.  This reduces the
+ * average shift distance at the cost of more calls to jpeg_fill_bit_buffer.
+ */
+
+#ifdef SLOW_SHIFT_32
+#define MIN_GET_BITS  15	/* minimum allowable value */
+#else
+#define MIN_GET_BITS  (BIT_BUF_SIZE-7)
+#endif
+
+
+GLOBAL(boolean)
+jpeg_fill_bit_buffer (bitread_working_state * state,
+		      register bit_buf_type get_buffer, register int bits_left,
+		      int nbits)
+/* Load up the bit buffer to a depth of at least nbits */
+{
+  /* Copy heavily used state fields into locals (hopefully registers) */
+  register const JOCTET * next_input_byte = state->next_input_byte;
+  register size_t bytes_in_buffer = state->bytes_in_buffer;
+  j_decompress_ptr cinfo = state->cinfo;
+
+  /* Attempt to load at least MIN_GET_BITS bits into get_buffer. */
+  /* (It is assumed that no request will be for more than that many bits.) */
+  /* We fail to do so only if we hit a marker or are forced to suspend. */
+
+  if (cinfo->unread_marker == 0) {	/* cannot advance past a marker */
+    while (bits_left < MIN_GET_BITS) {
+      register int c;
+
+      /* Attempt to read a byte */
+      if (bytes_in_buffer == 0) {
+	if (! (*cinfo->src->fill_input_buffer) (cinfo))
+	  return FALSE;
+	next_input_byte = cinfo->src->next_input_byte;
+	bytes_in_buffer = cinfo->src->bytes_in_buffer;
+      }
+      bytes_in_buffer--;
+      c = GETJOCTET(*next_input_byte++);
+
+      /* If it's 0xFF, check and discard stuffed zero byte */
+      if (c == 0xFF) {
+	/* Loop here to discard any padding FF's on terminating marker,
+	 * so that we can save a valid unread_marker value.  NOTE: we will
+	 * accept multiple FF's followed by a 0 as meaning a single FF data
+	 * byte.  This data pattern is not valid according to the standard.
+	 */
+	do {
+	  if (bytes_in_buffer == 0) {
+	    if (! (*cinfo->src->fill_input_buffer) (cinfo))
+	      return FALSE;
+	    next_input_byte = cinfo->src->next_input_byte;
+	    bytes_in_buffer = cinfo->src->bytes_in_buffer;
+	  }
+	  bytes_in_buffer--;
+	  c = GETJOCTET(*next_input_byte++);
+	} while (c == 0xFF);
+
+	if (c == 0) {
+	  /* Found FF/00, which represents an FF data byte */
+	  c = 0xFF;
+	} else {
+	  /* Oops, it's actually a marker indicating end of compressed data.
+	   * Save the marker code for later use.
+	   * Fine point: it might appear that we should save the marker into
+	   * bitread working state, not straight into permanent state.  But
+	   * once we have hit a marker, we cannot need to suspend within the
+	   * current MCU, because we will read no more bytes from the data
+	   * source.  So it is OK to update permanent state right away.
+	   */
+	  cinfo->unread_marker = c;
+	  /* See if we need to insert some fake zero bits. */
+	  goto no_more_bytes;
+	}
+      }
+
+      /* OK, load c into get_buffer */
+      get_buffer = (get_buffer << 8) | c;
+      bits_left += 8;
+    } /* end while */
+  } else {
+  no_more_bytes:
+    /* We get here if we've read the marker that terminates the compressed
+     * data segment.  There should be enough bits in the buffer register
+     * to satisfy the request; if so, no problem.
+     */
+    if (nbits > bits_left) {
+      /* Uh-oh.  Report corrupted data to user and stuff zeroes into
+       * the data stream, so that we can produce some kind of image.
+       * We use a nonvolatile flag to ensure that only one warning message
+       * appears per data segment.
+       */
+      if (! cinfo->entropy->insufficient_data) {
+	WARNMS(cinfo, JWRN_HIT_MARKER);
+	cinfo->entropy->insufficient_data = TRUE;
+      }
+      /* Fill the buffer with zero bits */
+      get_buffer <<= MIN_GET_BITS - bits_left;
+      bits_left = MIN_GET_BITS;
+    }
+  }
+
+  /* Unload the local registers */
+  state->next_input_byte = next_input_byte;
+  state->bytes_in_buffer = bytes_in_buffer;
+  state->get_buffer = get_buffer;
+  state->bits_left = bits_left;
+
+  return TRUE;
+}
+
+
+/*
+ * Out-of-line code for Huffman code decoding.
+ * See jdhuff.h for info about usage.
+ */
+
+GLOBAL(int)
+jpeg_huff_decode (bitread_working_state * state,
+		  register bit_buf_type get_buffer, register int bits_left,
+		  d_derived_tbl * htbl, int min_bits)
+{
+  register int l = min_bits;
+  register INT32 code;
+
+  /* HUFF_DECODE has determined that the code is at least min_bits */
+  /* bits long, so fetch that many bits in one swoop. */
+
+  CHECK_BIT_BUFFER(*state, l, return -1);
+  code = GET_BITS(l);
+
+  /* Collect the rest of the Huffman code one bit at a time. */
+  /* This is per Figure F.16 in the JPEG spec. */
+
+  while (code > htbl->maxcode[l]) {
+    code <<= 1;
+    CHECK_BIT_BUFFER(*state, 1, return -1);
+    code |= GET_BITS(1);
+    l++;
+  }
+
+  /* Unload the local registers */
+  state->get_buffer = get_buffer;
+  state->bits_left = bits_left;
+
+  /* With garbage input we may reach the sentinel value l = 17. */
+
+  if (l > 16) {
+    WARNMS(state->cinfo, JWRN_HUFF_BAD_CODE);
+    return 0;			/* fake a zero as the safest result */
+  }
+
+  return htbl->pub->huffval[ (int) (code + htbl->valoffset[l]) ];
+}
+
+
+/*
+ * Figure F.12: extend sign bit.
+ * On some machines, a shift and add will be faster than a table lookup.
+ */
+
+#ifdef AVOID_TABLES
+
+#define HUFF_EXTEND(x,s)  ((x) < (1<<((s)-1)) ? (x) + (((-1)<<(s)) + 1) : (x))
+
+#else
+
+#define HUFF_EXTEND(x,s)  ((x) < extend_test[s] ? (x) + extend_offset[s] : (x))
+
+static const int extend_test[16] =   /* entry n is 2**(n-1) */
+  { 0, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
+    0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000 };
+
+static const int extend_offset[16] = /* entry n is (-1 << n) + 1 */
+  { 0, ((-1)<<1) + 1, ((-1)<<2) + 1, ((-1)<<3) + 1, ((-1)<<4) + 1,
+    ((-1)<<5) + 1, ((-1)<<6) + 1, ((-1)<<7) + 1, ((-1)<<8) + 1,
+    ((-1)<<9) + 1, ((-1)<<10) + 1, ((-1)<<11) + 1, ((-1)<<12) + 1,
+    ((-1)<<13) + 1, ((-1)<<14) + 1, ((-1)<<15) + 1 };
+
+#endif /* AVOID_TABLES */
+
+
+/*
+ * Check for a restart marker & resynchronize decoder.
+ * Returns FALSE if must suspend.
+ */
+
+LOCAL(boolean)
+process_restart (j_decompress_ptr cinfo)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+  int ci;
+
+  /* Throw away any unused bits remaining in bit buffer; */
+  /* include any full bytes in next_marker's count of discarded bytes */
+  cinfo->marker->discarded_bytes += entropy->bitstate.bits_left / 8;
+  entropy->bitstate.bits_left = 0;
+
+  /* Advance past the RSTn marker */
+  if (! (*cinfo->marker->read_restart_marker) (cinfo))
+    return FALSE;
+
+  /* Re-initialize DC predictions to 0 */
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++)
+    entropy->saved.last_dc_val[ci] = 0;
+
+  /* Reset restart counter */
+  entropy->restarts_to_go = cinfo->restart_interval;
+
+  /* Reset out-of-data flag, unless read_restart_marker left us smack up
+   * against a marker.  In that case we will end up treating the next data
+   * segment as empty, and we can avoid producing bogus output pixels by
+   * leaving the flag set.
+   */
+  if (cinfo->unread_marker == 0)
+    entropy->pub.insufficient_data = FALSE;
+
+  return TRUE;
+}
+
+
+/*
+ * Decode and return one MCU's worth of Huffman-compressed coefficients.
+ * The coefficients are reordered from zigzag order into natural array order,
+ * but are not dequantized.
+ *
+ * The i'th block of the MCU is stored into the block pointed to by
+ * MCU_data[i].  WE ASSUME THIS AREA HAS BEEN ZEROED BY THE CALLER.
+ * (Wholesale zeroing is usually a little faster than retail...)
+ *
+ * Returns FALSE if data source requested suspension.  In that case no
+ * changes have been made to permanent state.  (Exception: some output
+ * coefficients may already have been assigned.  This is harmless for
+ * this module, since we'll just re-assign them on the next call.)
+ */
+
+METHODDEF(boolean)
+decode_mcu (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+  int blkn;
+  BITREAD_STATE_VARS;
+  savable_state state;
+
+  /* Process restart marker if needed; may have to suspend */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0)
+      if (! process_restart(cinfo))
+	return FALSE;
+  }
+
+  /* If we've run out of data, just leave the MCU set to zeroes.
+   * This way, we return uniform gray for the remainder of the segment.
+   */
+  if (! entropy->pub.insufficient_data) {
+
+    /* Load up working state */
+    BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
+    ASSIGN_STATE(state, entropy->saved);
+
+    /* Outer loop handles each block in the MCU */
+
+    for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+      JBLOCKROW block = MCU_data[blkn];
+      d_derived_tbl * dctbl = entropy->dc_cur_tbls[blkn];
+      d_derived_tbl * actbl = entropy->ac_cur_tbls[blkn];
+      register int s, k, r;
+
+      /* Decode a single block's worth of coefficients */
+
+      /* Section F.2.2.1: decode the DC coefficient difference */
+      HUFF_DECODE(s, br_state, dctbl, return FALSE, label1);
+      if (s) {
+	CHECK_BIT_BUFFER(br_state, s, return FALSE);
+	r = GET_BITS(s);
+	s = HUFF_EXTEND(r, s);
+      }
+
+      if (entropy->dc_needed[blkn]) {
+	/* Convert DC difference to actual value, update last_dc_val */
+	int ci = cinfo->MCU_membership[blkn];
+	s += state.last_dc_val[ci];
+	state.last_dc_val[ci] = s;
+	/* Output the DC coefficient (assumes jpeg_natural_order[0] = 0) */
+	(*block)[0] = (JCOEF) s;
+      }
+
+      if (entropy->ac_needed[blkn]) {
+
+	/* Section F.2.2.2: decode the AC coefficients */
+	/* Since zeroes are skipped, output area must be cleared beforehand */
+	for (k = 1; k < DCTSIZE2; k++) {
+	  HUFF_DECODE(s, br_state, actbl, return FALSE, label2);
+      
+	  r = s >> 4;
+	  s &= 15;
+      
+	  if (s) {
+	    k += r;
+	    CHECK_BIT_BUFFER(br_state, s, return FALSE);
+	    r = GET_BITS(s);
+	    s = HUFF_EXTEND(r, s);
+	    /* Output coefficient in natural (dezigzagged) order.
+	     * Note: the extra entries in jpeg_natural_order[] will save us
+	     * if k >= DCTSIZE2, which could happen if the data is corrupted.
+	     */
+	    (*block)[jpeg_natural_order[k]] = (JCOEF) s;
+	  } else {
+	    if (r != 15)
+	      break;
+	    k += 15;
+	  }
+	}
+
+      } else {
+
+	/* Section F.2.2.2: decode the AC coefficients */
+	/* In this path we just discard the values */
+	for (k = 1; k < DCTSIZE2; k++) {
+	  HUFF_DECODE(s, br_state, actbl, return FALSE, label3);
+      
+	  r = s >> 4;
+	  s &= 15;
+      
+	  if (s) {
+	    k += r;
+	    CHECK_BIT_BUFFER(br_state, s, return FALSE);
+	    DROP_BITS(s);
+	  } else {
+	    if (r != 15)
+	      break;
+	    k += 15;
+	  }
+	}
+
+      }
+    }
+
+    /* Completed MCU, so update state */
+    BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
+    ASSIGN_STATE(entropy->saved, state);
+  }
+
+  /* Account for restart interval (no-op if not using restarts) */
+  entropy->restarts_to_go--;
+
+  return TRUE;
+}
+
+
+/*
+ * Module initialization routine for Huffman entropy decoding.
+ */
+
+GLOBAL(void)
+jinit_huff_decoder (j_decompress_ptr cinfo)
+{
+  huff_entropy_ptr entropy;
+  int i;
+
+  entropy = (huff_entropy_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(huff_entropy_decoder));
+  cinfo->entropy = (struct jpeg_entropy_decoder *) entropy;
+  entropy->pub.start_pass = start_pass_huff_decoder;
+  entropy->pub.decode_mcu = decode_mcu;
+
+  /* Mark tables unallocated */
+  for (i = 0; i < NUM_HUFF_TBLS; i++) {
+    entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL;
+  }
+}

src/jpeg/jdhuff.h

@@ -0,0 +1,201 @@
+/*
+ * jdhuff.h
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains declarations for Huffman entropy decoding routines
+ * that are shared between the sequential decoder (jdhuff.c) and the
+ * progressive decoder (jdphuff.c).  No other modules need to see these.
+ */
+
+/* Short forms of external names for systems with brain-damaged linkers. */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jpeg_make_d_derived_tbl	jMkDDerived
+#define jpeg_fill_bit_buffer	jFilBitBuf
+#define jpeg_huff_decode	jHufDecode
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+
+/* Derived data constructed for each Huffman table */
+
+#define HUFF_LOOKAHEAD	8	/* # of bits of lookahead */
+
+typedef struct {
+  /* Basic tables: (element [0] of each array is unused) */
+  INT32 maxcode[18];		/* largest code of length k (-1 if none) */
+  /* (maxcode[17] is a sentinel to ensure jpeg_huff_decode terminates) */
+  INT32 valoffset[17];		/* huffval[] offset for codes of length k */
+  /* valoffset[k] = huffval[] index of 1st symbol of code length k, less
+   * the smallest code of length k; so given a code of length k, the
+   * corresponding symbol is huffval[code + valoffset[k]]
+   */
+
+  /* Link to public Huffman table (needed only in jpeg_huff_decode) */
+  JHUFF_TBL *pub;
+
+  /* Lookahead tables: indexed by the next HUFF_LOOKAHEAD bits of
+   * the input data stream.  If the next Huffman code is no more
+   * than HUFF_LOOKAHEAD bits long, we can obtain its length and
+   * the corresponding symbol directly from these tables.
+   */
+  int look_nbits[1<<HUFF_LOOKAHEAD]; /* # bits, or 0 if too long */
+  UINT8 look_sym[1<<HUFF_LOOKAHEAD]; /* symbol, or unused */
+} d_derived_tbl;
+
+/* Expand a Huffman table definition into the derived format */
+EXTERN(void) jpeg_make_d_derived_tbl
+	JPP((j_decompress_ptr cinfo, boolean isDC, int tblno,
+	     d_derived_tbl ** pdtbl));
+
+
+/*
+ * Fetching the next N bits from the input stream is a time-critical operation
+ * for the Huffman decoders.  We implement it with a combination of inline
+ * macros and out-of-line subroutines.  Note that N (the number of bits
+ * demanded at one time) never exceeds 15 for JPEG use.
+ *
+ * We read source bytes into get_buffer and dole out bits as needed.
+ * If get_buffer already contains enough bits, they are fetched in-line
+ * by the macros CHECK_BIT_BUFFER and GET_BITS.  When there aren't enough
+ * bits, jpeg_fill_bit_buffer is called; it will attempt to fill get_buffer
+ * as full as possible (not just to the number of bits needed; this
+ * prefetching reduces the overhead cost of calling jpeg_fill_bit_buffer).
+ * Note that jpeg_fill_bit_buffer may return FALSE to indicate suspension.
+ * On TRUE return, jpeg_fill_bit_buffer guarantees that get_buffer contains
+ * at least the requested number of bits --- dummy zeroes are inserted if
+ * necessary.
+ */
+
+typedef INT32 bit_buf_type;	/* type of bit-extraction buffer */
+#define BIT_BUF_SIZE  32	/* size of buffer in bits */
+
+/* If long is > 32 bits on your machine, and shifting/masking longs is
+ * reasonably fast, making bit_buf_type be long and setting BIT_BUF_SIZE
+ * appropriately should be a win.  Unfortunately we can't define the size
+ * with something like  #define BIT_BUF_SIZE (sizeof(bit_buf_type)*8)
+ * because not all machines measure sizeof in 8-bit bytes.
+ */
+
+typedef struct {		/* Bitreading state saved across MCUs */
+  bit_buf_type get_buffer;	/* current bit-extraction buffer */
+  int bits_left;		/* # of unused bits in it */
+} bitread_perm_state;
+
+typedef struct {		/* Bitreading working state within an MCU */
+  /* Current data source location */
+  /* We need a copy, rather than munging the original, in case of suspension */
+  const JOCTET * next_input_byte; /* => next byte to read from source */
+  size_t bytes_in_buffer;	/* # of bytes remaining in source buffer */
+  /* Bit input buffer --- note these values are kept in register variables,
+   * not in this struct, inside the inner loops.
+   */
+  bit_buf_type get_buffer;	/* current bit-extraction buffer */
+  int bits_left;		/* # of unused bits in it */
+  /* Pointer needed by jpeg_fill_bit_buffer. */
+  j_decompress_ptr cinfo;	/* back link to decompress master record */
+} bitread_working_state;
+
+/* Macros to declare and load/save bitread local variables. */
+#define BITREAD_STATE_VARS  \
+	register bit_buf_type get_buffer;  \
+	register int bits_left;  \
+	bitread_working_state br_state
+
+#define BITREAD_LOAD_STATE(cinfop,permstate)  \
+	br_state.cinfo = cinfop; \
+	br_state.next_input_byte = cinfop->src->next_input_byte; \
+	br_state.bytes_in_buffer = cinfop->src->bytes_in_buffer; \
+	get_buffer = permstate.get_buffer; \
+	bits_left = permstate.bits_left;
+
+#define BITREAD_SAVE_STATE(cinfop,permstate)  \
+	cinfop->src->next_input_byte = br_state.next_input_byte; \
+	cinfop->src->bytes_in_buffer = br_state.bytes_in_buffer; \
+	permstate.get_buffer = get_buffer; \
+	permstate.bits_left = bits_left
+
+/*
+ * These macros provide the in-line portion of bit fetching.
+ * Use CHECK_BIT_BUFFER to ensure there are N bits in get_buffer
+ * before using GET_BITS, PEEK_BITS, or DROP_BITS.
+ * The variables get_buffer and bits_left are assumed to be locals,
+ * but the state struct might not be (jpeg_huff_decode needs this).
+ *	CHECK_BIT_BUFFER(state,n,action);
+ *		Ensure there are N bits in get_buffer; if suspend, take action.
+ *      val = GET_BITS(n);
+ *		Fetch next N bits.
+ *      val = PEEK_BITS(n);
+ *		Fetch next N bits without removing them from the buffer.
+ *	DROP_BITS(n);
+ *		Discard next N bits.
+ * The value N should be a simple variable, not an expression, because it
+ * is evaluated multiple times.
+ */
+
+#define CHECK_BIT_BUFFER(state,nbits,action) \
+	{ if (bits_left < (nbits)) {  \
+	    if (! jpeg_fill_bit_buffer(&(state),get_buffer,bits_left,nbits))  \
+	      { action; }  \
+	    get_buffer = (state).get_buffer; bits_left = (state).bits_left; } }
+
+#define GET_BITS(nbits) \
+	(((int) (get_buffer >> (bits_left -= (nbits)))) & ((1<<(nbits))-1))
+
+#define PEEK_BITS(nbits) \
+	(((int) (get_buffer >> (bits_left -  (nbits)))) & ((1<<(nbits))-1))
+
+#define DROP_BITS(nbits) \
+	(bits_left -= (nbits))
+
+/* Load up the bit buffer to a depth of at least nbits */
+EXTERN(boolean) jpeg_fill_bit_buffer
+	JPP((bitread_working_state * state, register bit_buf_type get_buffer,
+	     register int bits_left, int nbits));
+
+
+/*
+ * Code for extracting next Huffman-coded symbol from input bit stream.
+ * Again, this is time-critical and we make the main paths be macros.
+ *
+ * We use a lookahead table to process codes of up to HUFF_LOOKAHEAD bits
+ * without looping.  Usually, more than 95% of the Huffman codes will be 8
+ * or fewer bits long.  The few overlength codes are handled with a loop,
+ * which need not be inline code.
+ *
+ * Notes about the HUFF_DECODE macro:
+ * 1. Near the end of the data segment, we may fail to get enough bits
+ *    for a lookahead.  In that case, we do it the hard way.
+ * 2. If the lookahead table contains no entry, the next code must be
+ *    more than HUFF_LOOKAHEAD bits long.
+ * 3. jpeg_huff_decode returns -1 if forced to suspend.
+ */
+
+#define HUFF_DECODE(result,state,htbl,failaction,slowlabel) \
+{ register int nb, look; \
+  if (bits_left < HUFF_LOOKAHEAD) { \
+    if (! jpeg_fill_bit_buffer(&state,get_buffer,bits_left, 0)) {failaction;} \
+    get_buffer = state.get_buffer; bits_left = state.bits_left; \
+    if (bits_left < HUFF_LOOKAHEAD) { \
+      nb = 1; goto slowlabel; \
+    } \
+  } \
+  look = PEEK_BITS(HUFF_LOOKAHEAD); \
+  if ((nb = htbl->look_nbits[look]) != 0) { \
+    DROP_BITS(nb); \
+    result = htbl->look_sym[look]; \
+  } else { \
+    nb = HUFF_LOOKAHEAD+1; \
+slowlabel: \
+    if ((result=jpeg_huff_decode(&state,get_buffer,bits_left,htbl,nb)) < 0) \
+	{ failaction; } \
+    get_buffer = state.get_buffer; bits_left = state.bits_left; \
+  } \
+}
+
+/* Out-of-line case for Huffman code fetching */
+EXTERN(int) jpeg_huff_decode
+	JPP((bitread_working_state * state, register bit_buf_type get_buffer,
+	     register int bits_left, d_derived_tbl * htbl, int min_bits));

src/jpeg/jdinput.c

@@ -0,0 +1,381 @@
+/*
+ * jdinput.c
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains input control logic for the JPEG decompressor.
+ * These routines are concerned with controlling the decompressor's input
+ * processing (marker reading and coefficient decoding).  The actual input
+ * reading is done in jdmarker.c, jdhuff.c, and jdphuff.c.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Private state */
+
+typedef struct {
+  struct jpeg_input_controller pub; /* public fields */
+
+  boolean inheaders;		/* TRUE until first SOS is reached */
+} my_input_controller;
+
+typedef my_input_controller * my_inputctl_ptr;
+
+
+/* Forward declarations */
+METHODDEF(int) consume_markers JPP((j_decompress_ptr cinfo));
+
+
+/*
+ * Routines to calculate various quantities related to the size of the image.
+ */
+
+LOCAL(void)
+initial_setup (j_decompress_ptr cinfo)
+/* Called once, when first SOS marker is reached */
+{
+  int ci;
+  jpeg_component_info *compptr;
+
+  /* Make sure image isn't bigger than I can handle */
+  if ((long) cinfo->image_height > (long) JPEG_MAX_DIMENSION ||
+      (long) cinfo->image_width > (long) JPEG_MAX_DIMENSION)
+    ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int) JPEG_MAX_DIMENSION);
+
+  /* For now, precision must match compiled-in value... */
+  if (cinfo->data_precision != BITS_IN_JSAMPLE)
+    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
+
+  /* Check that number of components won't exceed internal array sizes */
+  if (cinfo->num_components > MAX_COMPONENTS)
+    ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
+	     MAX_COMPONENTS);
+
+  /* Compute maximum sampling factors; check factor validity */
+  cinfo->max_h_samp_factor = 1;
+  cinfo->max_v_samp_factor = 1;
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    if (compptr->h_samp_factor<=0 || compptr->h_samp_factor>MAX_SAMP_FACTOR ||
+	compptr->v_samp_factor<=0 || compptr->v_samp_factor>MAX_SAMP_FACTOR)
+      ERREXIT(cinfo, JERR_BAD_SAMPLING);
+    cinfo->max_h_samp_factor = MAX(cinfo->max_h_samp_factor,
+				   compptr->h_samp_factor);
+    cinfo->max_v_samp_factor = MAX(cinfo->max_v_samp_factor,
+				   compptr->v_samp_factor);
+  }
+
+  /* We initialize DCT_scaled_size and min_DCT_scaled_size to DCTSIZE.
+   * In the full decompressor, this will be overridden by jdmaster.c;
+   * but in the transcoder, jdmaster.c is not used, so we must do it here.
+   */
+  cinfo->min_DCT_scaled_size = DCTSIZE;
+
+  /* Compute dimensions of components */
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    compptr->DCT_scaled_size = DCTSIZE;
+    /* Size in DCT blocks */
+    compptr->width_in_blocks = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor,
+		    (long) (cinfo->max_h_samp_factor * DCTSIZE));
+    compptr->height_in_blocks = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor,
+		    (long) (cinfo->max_v_samp_factor * DCTSIZE));
+    /* downsampled_width and downsampled_height will also be overridden by
+     * jdmaster.c if we are doing full decompression.  The transcoder library
+     * doesn't use these values, but the calling application might.
+     */
+    /* Size in samples */
+    compptr->downsampled_width = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor,
+		    (long) cinfo->max_h_samp_factor);
+    compptr->downsampled_height = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor,
+		    (long) cinfo->max_v_samp_factor);
+    /* Mark component needed, until color conversion says otherwise */
+    compptr->component_needed = TRUE;
+    /* Mark no quantization table yet saved for component */
+    compptr->quant_table = NULL;
+  }
+
+  /* Compute number of fully interleaved MCU rows. */
+  cinfo->total_iMCU_rows = (JDIMENSION)
+    jdiv_round_up((long) cinfo->image_height,
+		  (long) (cinfo->max_v_samp_factor*DCTSIZE));
+
+  /* Decide whether file contains multiple scans */
+  if (cinfo->comps_in_scan < cinfo->num_components || cinfo->progressive_mode)
+    cinfo->inputctl->has_multiple_scans = TRUE;
+  else
+    cinfo->inputctl->has_multiple_scans = FALSE;
+}
+
+
+LOCAL(void)
+per_scan_setup (j_decompress_ptr cinfo)
+/* Do computations that are needed before processing a JPEG scan */
+/* cinfo->comps_in_scan and cinfo->cur_comp_info[] were set from SOS marker */
+{
+  int ci, mcublks, tmp;
+  jpeg_component_info *compptr;
+  
+  if (cinfo->comps_in_scan == 1) {
+    
+    /* Noninterleaved (single-component) scan */
+    compptr = cinfo->cur_comp_info[0];
+    
+    /* Overall image size in MCUs */
+    cinfo->MCUs_per_row = compptr->width_in_blocks;
+    cinfo->MCU_rows_in_scan = compptr->height_in_blocks;
+    
+    /* For noninterleaved scan, always one block per MCU */
+    compptr->MCU_width = 1;
+    compptr->MCU_height = 1;
+    compptr->MCU_blocks = 1;
+    compptr->MCU_sample_width = compptr->DCT_scaled_size;
+    compptr->last_col_width = 1;
+    /* For noninterleaved scans, it is convenient to define last_row_height
+     * as the number of block rows present in the last iMCU row.
+     */
+    tmp = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
+    if (tmp == 0) tmp = compptr->v_samp_factor;
+    compptr->last_row_height = tmp;
+    
+    /* Prepare array describing MCU composition */
+    cinfo->blocks_in_MCU = 1;
+    cinfo->MCU_membership[0] = 0;
+    
+  } else {
+    
+    /* Interleaved (multi-component) scan */
+    if (cinfo->comps_in_scan <= 0 || cinfo->comps_in_scan > MAX_COMPS_IN_SCAN)
+      ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->comps_in_scan,
+	       MAX_COMPS_IN_SCAN);
+    
+    /* Overall image size in MCUs */
+    cinfo->MCUs_per_row = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_width,
+		    (long) (cinfo->max_h_samp_factor*DCTSIZE));
+    cinfo->MCU_rows_in_scan = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_height,
+		    (long) (cinfo->max_v_samp_factor*DCTSIZE));
+    
+    cinfo->blocks_in_MCU = 0;
+    
+    for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+      compptr = cinfo->cur_comp_info[ci];
+      /* Sampling factors give # of blocks of component in each MCU */
+      compptr->MCU_width = compptr->h_samp_factor;
+      compptr->MCU_height = compptr->v_samp_factor;
+      compptr->MCU_blocks = compptr->MCU_width * compptr->MCU_height;
+      compptr->MCU_sample_width = compptr->MCU_width * compptr->DCT_scaled_size;
+      /* Figure number of non-dummy blocks in last MCU column & row */
+      tmp = (int) (compptr->width_in_blocks % compptr->MCU_width);
+      if (tmp == 0) tmp = compptr->MCU_width;
+      compptr->last_col_width = tmp;
+      tmp = (int) (compptr->height_in_blocks % compptr->MCU_height);
+      if (tmp == 0) tmp = compptr->MCU_height;
+      compptr->last_row_height = tmp;
+      /* Prepare array describing MCU composition */
+      mcublks = compptr->MCU_blocks;
+      if (cinfo->blocks_in_MCU + mcublks > D_MAX_BLOCKS_IN_MCU)
+	ERREXIT(cinfo, JERR_BAD_MCU_SIZE);
+      while (mcublks-- > 0) {
+	cinfo->MCU_membership[cinfo->blocks_in_MCU++] = ci;
+      }
+    }
+    
+  }
+}
+
+
+/*
+ * Save away a copy of the Q-table referenced by each component present
+ * in the current scan, unless already saved during a prior scan.
+ *
+ * In a multiple-scan JPEG file, the encoder could assign different components
+ * the same Q-table slot number, but change table definitions between scans
+ * so that each component uses a different Q-table.  (The IJG encoder is not
+ * currently capable of doing this, but other encoders might.)  Since we want
+ * to be able to dequantize all the components at the end of the file, this
+ * means that we have to save away the table actually used for each component.
+ * We do this by copying the table at the start of the first scan containing
+ * the component.
+ * The JPEG spec prohibits the encoder from changing the contents of a Q-table
+ * slot between scans of a component using that slot.  If the encoder does so
+ * anyway, this decoder will simply use the Q-table values that were current
+ * at the start of the first scan for the component.
+ *
+ * The decompressor output side looks only at the saved quant tables,
+ * not at the current Q-table slots.
+ */
+
+LOCAL(void)
+latch_quant_tables (j_decompress_ptr cinfo)
+{
+  int ci, qtblno;
+  jpeg_component_info *compptr;
+  JQUANT_TBL * qtbl;
+
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    /* No work if we already saved Q-table for this component */
+    if (compptr->quant_table != NULL)
+      continue;
+    /* Make sure specified quantization table is present */
+    qtblno = compptr->quant_tbl_no;
+    if (qtblno < 0 || qtblno >= NUM_QUANT_TBLS ||
+	cinfo->quant_tbl_ptrs[qtblno] == NULL)
+      ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, qtblno);
+    /* OK, save away the quantization table */
+    qtbl = (JQUANT_TBL *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  SIZEOF(JQUANT_TBL));
+    MEMCOPY(qtbl, cinfo->quant_tbl_ptrs[qtblno], SIZEOF(JQUANT_TBL));
+    compptr->quant_table = qtbl;
+  }
+}
+
+
+/*
+ * Initialize the input modules to read a scan of compressed data.
+ * The first call to this is done by jdmaster.c after initializing
+ * the entire decompressor (during jpeg_start_decompress).
+ * Subsequent calls come from consume_markers, below.
+ */
+
+METHODDEF(void)
+start_input_pass (j_decompress_ptr cinfo)
+{
+  per_scan_setup(cinfo);
+  latch_quant_tables(cinfo);
+  (*cinfo->entropy->start_pass) (cinfo);
+  (*cinfo->coef->start_input_pass) (cinfo);
+  cinfo->inputctl->consume_input = cinfo->coef->consume_data;
+}
+
+
+/*
+ * Finish up after inputting a compressed-data scan.
+ * This is called by the coefficient controller after it's read all
+ * the expected data of the scan.
+ */
+
+METHODDEF(void)
+finish_input_pass (j_decompress_ptr cinfo)
+{
+  cinfo->inputctl->consume_input = consume_markers;
+}
+
+
+/*
+ * Read JPEG markers before, between, or after compressed-data scans.
+ * Change state as necessary when a new scan is reached.
+ * Return value is JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.
+ *
+ * The consume_input method pointer points either here or to the
+ * coefficient controller's consume_data routine, depending on whether
+ * we are reading a compressed data segment or inter-segment markers.
+ */
+
+METHODDEF(int)
+consume_markers (j_decompress_ptr cinfo)
+{
+  my_inputctl_ptr inputctl = (my_inputctl_ptr) cinfo->inputctl;
+  int val;
+
+  if (inputctl->pub.eoi_reached) /* After hitting EOI, read no further */
+    return JPEG_REACHED_EOI;
+
+  val = (*cinfo->marker->read_markers) (cinfo);
+
+  switch (val) {
+  case JPEG_REACHED_SOS:	/* Found SOS */
+    if (inputctl->inheaders) {	/* 1st SOS */
+      initial_setup(cinfo);
+      inputctl->inheaders = FALSE;
+      /* Note: start_input_pass must be called by jdmaster.c
+       * before any more input can be consumed.  jdapimin.c is
+       * responsible for enforcing this sequencing.
+       */
+    } else {			/* 2nd or later SOS marker */
+      if (! inputctl->pub.has_multiple_scans)
+	ERREXIT(cinfo, JERR_EOI_EXPECTED); /* Oops, I wasn't expecting this! */
+      start_input_pass(cinfo);
+    }
+    break;
+  case JPEG_REACHED_EOI:	/* Found EOI */
+    inputctl->pub.eoi_reached = TRUE;
+    if (inputctl->inheaders) {	/* Tables-only datastream, apparently */
+      if (cinfo->marker->saw_SOF)
+	ERREXIT(cinfo, JERR_SOF_NO_SOS);
+    } else {
+      /* Prevent infinite loop in coef ctlr's decompress_data routine
+       * if user set output_scan_number larger than number of scans.
+       */
+      if (cinfo->output_scan_number > cinfo->input_scan_number)
+	cinfo->output_scan_number = cinfo->input_scan_number;
+    }
+    break;
+  case JPEG_SUSPENDED:
+    break;
+  }
+
+  return val;
+}
+
+
+/*
+ * Reset state to begin a fresh datastream.
+ */
+
+METHODDEF(void)
+reset_input_controller (j_decompress_ptr cinfo)
+{
+  my_inputctl_ptr inputctl = (my_inputctl_ptr) cinfo->inputctl;
+
+  inputctl->pub.consume_input = consume_markers;
+  inputctl->pub.has_multiple_scans = FALSE; /* "unknown" would be better */
+  inputctl->pub.eoi_reached = FALSE;
+  inputctl->inheaders = TRUE;
+  /* Reset other modules */
+  (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo);
+  (*cinfo->marker->reset_marker_reader) (cinfo);
+  /* Reset progression state -- would be cleaner if entropy decoder did this */
+  cinfo->coef_bits = NULL;
+}
+
+
+/*
+ * Initialize the input controller module.
+ * This is called only once, when the decompression object is created.
+ */
+
+GLOBAL(void)
+jinit_input_controller (j_decompress_ptr cinfo)
+{
+  my_inputctl_ptr inputctl;
+
+  /* Create subobject in permanent pool */
+  inputctl = (my_inputctl_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+				SIZEOF(my_input_controller));
+  cinfo->inputctl = (struct jpeg_input_controller *) inputctl;
+  /* Initialize method pointers */
+  inputctl->pub.consume_input = consume_markers;
+  inputctl->pub.reset_input_controller = reset_input_controller;
+  inputctl->pub.start_input_pass = start_input_pass;
+  inputctl->pub.finish_input_pass = finish_input_pass;
+  /* Initialize state: can't use reset_input_controller since we don't
+   * want to try to reset other modules yet.
+   */
+  inputctl->pub.has_multiple_scans = FALSE; /* "unknown" would be better */
+  inputctl->pub.eoi_reached = FALSE;
+  inputctl->inheaders = TRUE;
+}

src/jpeg/jdmainct.c

@@ -0,0 +1,514 @@
+/*
+ * jdmainct.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the main buffer controller for decompression.
+ * The main buffer lies between the JPEG decompressor proper and the
+ * post-processor; it holds downsampled data in the JPEG colorspace.
+ *
+ * Note that this code is bypassed in raw-data mode, since the application
+ * supplies the equivalent of the main buffer in that case.
+ */
+
+/* suppress the warnings about using main for the variable names */
+#define main jpegMain
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+/*
+ * In the current system design, the main buffer need never be a full-image
+ * buffer; any full-height buffers will be found inside the coefficient or
+ * postprocessing controllers.  Nonetheless, the main controller is not
+ * trivial.  Its responsibility is to provide context rows for upsampling/
+ * rescaling, and doing this in an efficient fashion is a bit tricky.
+ *
+ * Postprocessor input data is counted in "row groups".  A row group
+ * is defined to be (v_samp_factor * DCT_scaled_size / min_DCT_scaled_size)
+ * sample rows of each component.  (We require DCT_scaled_size values to be
+ * chosen such that these numbers are integers.  In practice DCT_scaled_size
+ * values will likely be powers of two, so we actually have the stronger
+ * condition that DCT_scaled_size / min_DCT_scaled_size is an integer.)
+ * Upsampling will typically produce max_v_samp_factor pixel rows from each
+ * row group (times any additional scale factor that the upsampler is
+ * applying).
+ *
+ * The coefficient controller will deliver data to us one iMCU row at a time;
+ * each iMCU row contains v_samp_factor * DCT_scaled_size sample rows, or
+ * exactly min_DCT_scaled_size row groups.  (This amount of data corresponds
+ * to one row of MCUs when the image is fully interleaved.)  Note that the
+ * number of sample rows varies across components, but the number of row
+ * groups does not.  Some garbage sample rows may be included in the last iMCU
+ * row at the bottom of the image.
+ *
+ * Depending on the vertical scaling algorithm used, the upsampler may need
+ * access to the sample row(s) above and below its current input row group.
+ * The upsampler is required to set need_context_rows TRUE at global selection
+ * time if so.  When need_context_rows is FALSE, this controller can simply
+ * obtain one iMCU row at a time from the coefficient controller and dole it
+ * out as row groups to the postprocessor.
+ *
+ * When need_context_rows is TRUE, this controller guarantees that the buffer
+ * passed to postprocessing contains at least one row group's worth of samples
+ * above and below the row group(s) being processed.  Note that the context
+ * rows "above" the first passed row group appear at negative row offsets in
+ * the passed buffer.  At the top and bottom of the image, the required
+ * context rows are manufactured by duplicating the first or last real sample
+ * row; this avoids having special cases in the upsampling inner loops.
+ *
+ * The amount of context is fixed at one row group just because that's a
+ * convenient number for this controller to work with.  The existing
+ * upsamplers really only need one sample row of context.  An upsampler
+ * supporting arbitrary output rescaling might wish for more than one row
+ * group of context when shrinking the image; tough, we don't handle that.
+ * (This is justified by the assumption that downsizing will be handled mostly
+ * by adjusting the DCT_scaled_size values, so that the actual scale factor at
+ * the upsample step needn't be much less than one.)
+ *
+ * To provide the desired context, we have to retain the last two row groups
+ * of one iMCU row while reading in the next iMCU row.  (The last row group
+ * can't be processed until we have another row group for its below-context,
+ * and so we have to save the next-to-last group too for its above-context.)
+ * We could do this most simply by copying data around in our buffer, but
+ * that'd be very slow.  We can avoid copying any data by creating a rather
+ * strange pointer structure.  Here's how it works.  We allocate a workspace
+ * consisting of M+2 row groups (where M = min_DCT_scaled_size is the number
+ * of row groups per iMCU row).  We create two sets of redundant pointers to
+ * the workspace.  Labeling the physical row groups 0 to M+1, the synthesized
+ * pointer lists look like this:
+ *                   M+1                          M-1
+ * master pointer --> 0         master pointer --> 0
+ *                    1                            1
+ *                   ...                          ...
+ *                   M-3                          M-3
+ *                   M-2                           M
+ *                   M-1                          M+1
+ *                    M                           M-2
+ *                   M+1                          M-1
+ *                    0                            0
+ * We read alternate iMCU rows using each master pointer; thus the last two
+ * row groups of the previous iMCU row remain un-overwritten in the workspace.
+ * The pointer lists are set up so that the required context rows appear to
+ * be adjacent to the proper places when we pass the pointer lists to the
+ * upsampler.
+ *
+ * The above pictures describe the normal state of the pointer lists.
+ * At top and bottom of the image, we diddle the pointer lists to duplicate
+ * the first or last sample row as necessary (this is cheaper than copying
+ * sample rows around).
+ *
+ * This scheme breaks down if M < 2, ie, min_DCT_scaled_size is 1.  In that
+ * situation each iMCU row provides only one row group so the buffering logic
+ * must be different (eg, we must read two iMCU rows before we can emit the
+ * first row group).  For now, we simply do not support providing context
+ * rows when min_DCT_scaled_size is 1.  That combination seems unlikely to
+ * be worth providing --- if someone wants a 1/8th-size preview, they probably
+ * want it quick and dirty, so a context-free upsampler is sufficient.
+ */
+
+
+/* Private buffer controller object */
+
+typedef struct {
+  struct jpeg_d_main_controller pub; /* public fields */
+
+  /* Pointer to allocated workspace (M or M+2 row groups). */
+  JSAMPARRAY buffer[MAX_COMPONENTS];
+
+  boolean buffer_full;		/* Have we gotten an iMCU row from decoder? */
+  JDIMENSION rowgroup_ctr;	/* counts row groups output to postprocessor */
+
+  /* Remaining fields are only used in the context case. */
+
+  /* These are the master pointers to the funny-order pointer lists. */
+  JSAMPIMAGE xbuffer[2];	/* pointers to weird pointer lists */
+
+  int whichptr;			/* indicates which pointer set is now in use */
+  int context_state;		/* process_data state machine status */
+  JDIMENSION rowgroups_avail;	/* row groups available to postprocessor */
+  JDIMENSION iMCU_row_ctr;	/* counts iMCU rows to detect image top/bot */
+} my_main_controller;
+
+typedef my_main_controller * my_main_ptr;
+
+/* context_state values: */
+#define CTX_PREPARE_FOR_IMCU	0	/* need to prepare for MCU row */
+#define CTX_PROCESS_IMCU	1	/* feeding iMCU to postprocessor */
+#define CTX_POSTPONED_ROW	2	/* feeding postponed row group */
+
+
+/* Forward declarations */
+METHODDEF(void) process_data_simple_main
+	JPP((j_decompress_ptr cinfo, JSAMPARRAY output_buf,
+	     JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail));
+METHODDEF(void) process_data_context_main
+	JPP((j_decompress_ptr cinfo, JSAMPARRAY output_buf,
+	     JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail));
+#ifdef QUANT_2PASS_SUPPORTED
+METHODDEF(void) process_data_crank_post
+	JPP((j_decompress_ptr cinfo, JSAMPARRAY output_buf,
+	     JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail));
+#endif
+
+
+LOCAL(void)
+alloc_funny_pointers (j_decompress_ptr cinfo)
+/* Allocate space for the funny pointer lists.
+ * This is done only once, not once per pass.
+ */
+{
+  my_main_ptr main = (my_main_ptr) cinfo->main;
+  int ci, rgroup;
+  int M = cinfo->min_DCT_scaled_size;
+  jpeg_component_info *compptr;
+  JSAMPARRAY xbuf;
+
+  /* Get top-level space for component array pointers.
+   * We alloc both arrays with one call to save a few cycles.
+   */
+  main->xbuffer[0] = (JSAMPIMAGE)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				cinfo->num_components * 2 * SIZEOF(JSAMPARRAY));
+  main->xbuffer[1] = main->xbuffer[0] + cinfo->num_components;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
+      cinfo->min_DCT_scaled_size; /* height of a row group of component */
+    /* Get space for pointer lists --- M+4 row groups in each list.
+     * We alloc both pointer lists with one call to save a few cycles.
+     */
+    xbuf = (JSAMPARRAY)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  2 * (rgroup * (M + 4)) * SIZEOF(JSAMPROW));
+    xbuf += rgroup;		/* want one row group at negative offsets */
+    main->xbuffer[0][ci] = xbuf;
+    xbuf += rgroup * (M + 4);
+    main->xbuffer[1][ci] = xbuf;
+  }
+}
+
+
+LOCAL(void)
+make_funny_pointers (j_decompress_ptr cinfo)
+/* Create the funny pointer lists discussed in the comments above.
+ * The actual workspace is already allocated (in main->buffer),
+ * and the space for the pointer lists is allocated too.
+ * This routine just fills in the curiously ordered lists.
+ * This will be repeated at the beginning of each pass.
+ */
+{
+  my_main_ptr main = (my_main_ptr) cinfo->main;
+  int ci, i, rgroup;
+  int M = cinfo->min_DCT_scaled_size;
+  jpeg_component_info *compptr;
+  JSAMPARRAY buf, xbuf0, xbuf1;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
+      cinfo->min_DCT_scaled_size; /* height of a row group of component */
+    xbuf0 = main->xbuffer[0][ci];
+    xbuf1 = main->xbuffer[1][ci];
+    /* First copy the workspace pointers as-is */
+    buf = main->buffer[ci];
+    for (i = 0; i < rgroup * (M + 2); i++) {
+      xbuf0[i] = xbuf1[i] = buf[i];
+    }
+    /* In the second list, put the last four row groups in swapped order */
+    for (i = 0; i < rgroup * 2; i++) {
+      xbuf1[rgroup*(M-2) + i] = buf[rgroup*M + i];
+      xbuf1[rgroup*M + i] = buf[rgroup*(M-2) + i];
+    }
+    /* The wraparound pointers at top and bottom will be filled later
+     * (see set_wraparound_pointers, below).  Initially we want the "above"
+     * pointers to duplicate the first actual data line.  This only needs
+     * to happen in xbuffer[0].
+     */
+    for (i = 0; i < rgroup; i++) {
+      xbuf0[i - rgroup] = xbuf0[0];
+    }
+  }
+}
+
+
+LOCAL(void)
+set_wraparound_pointers (j_decompress_ptr cinfo)
+/* Set up the "wraparound" pointers at top and bottom of the pointer lists.
+ * This changes the pointer list state from top-of-image to the normal state.
+ */
+{
+  my_main_ptr main = (my_main_ptr) cinfo->main;
+  int ci, i, rgroup;
+  int M = cinfo->min_DCT_scaled_size;
+  jpeg_component_info *compptr;
+  JSAMPARRAY xbuf0, xbuf1;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
+      cinfo->min_DCT_scaled_size; /* height of a row group of component */
+    xbuf0 = main->xbuffer[0][ci];
+    xbuf1 = main->xbuffer[1][ci];
+    for (i = 0; i < rgroup; i++) {
+      xbuf0[i - rgroup] = xbuf0[rgroup*(M+1) + i];
+      xbuf1[i - rgroup] = xbuf1[rgroup*(M+1) + i];
+      xbuf0[rgroup*(M+2) + i] = xbuf0[i];
+      xbuf1[rgroup*(M+2) + i] = xbuf1[i];
+    }
+  }
+}
+
+
+LOCAL(void)
+set_bottom_pointers (j_decompress_ptr cinfo)
+/* Change the pointer lists to duplicate the last sample row at the bottom
+ * of the image.  whichptr indicates which xbuffer holds the final iMCU row.
+ * Also sets rowgroups_avail to indicate number of nondummy row groups in row.
+ */
+{
+  my_main_ptr main = (my_main_ptr) cinfo->main;
+  int ci, i, rgroup, iMCUheight, rows_left;
+  jpeg_component_info *compptr;
+  JSAMPARRAY xbuf;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Count sample rows in one iMCU row and in one row group */
+    iMCUheight = compptr->v_samp_factor * compptr->DCT_scaled_size;
+    rgroup = iMCUheight / cinfo->min_DCT_scaled_size;
+    /* Count nondummy sample rows remaining for this component */
+    rows_left = (int) (compptr->downsampled_height % (JDIMENSION) iMCUheight);
+    if (rows_left == 0) rows_left = iMCUheight;
+    /* Count nondummy row groups.  Should get same answer for each component,
+     * so we need only do it once.
+     */
+    if (ci == 0) {
+      main->rowgroups_avail = (JDIMENSION) ((rows_left-1) / rgroup + 1);
+    }
+    /* Duplicate the last real sample row rgroup*2 times; this pads out the
+     * last partial rowgroup and ensures at least one full rowgroup of context.
+     */
+    xbuf = main->xbuffer[main->whichptr][ci];
+    for (i = 0; i < rgroup * 2; i++) {
+      xbuf[rows_left + i] = xbuf[rows_left-1];
+    }
+  }
+}
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF(void)
+start_pass_main (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+  my_main_ptr main = (my_main_ptr) cinfo->main;
+
+  switch (pass_mode) {
+  case JBUF_PASS_THRU:
+    if (cinfo->upsample->need_context_rows) {
+      main->pub.process_data = process_data_context_main;
+      make_funny_pointers(cinfo); /* Create the xbuffer[] lists */
+      main->whichptr = 0;	/* Read first iMCU row into xbuffer[0] */
+      main->context_state = CTX_PREPARE_FOR_IMCU;
+      main->iMCU_row_ctr = 0;
+    } else {
+      /* Simple case with no context needed */
+      main->pub.process_data = process_data_simple_main;
+    }
+    main->buffer_full = FALSE;	/* Mark buffer empty */
+    main->rowgroup_ctr = 0;
+    break;
+#ifdef QUANT_2PASS_SUPPORTED
+  case JBUF_CRANK_DEST:
+    /* For last pass of 2-pass quantization, just crank the postprocessor */
+    main->pub.process_data = process_data_crank_post;
+    break;
+#endif
+  default:
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    break;
+  }
+}
+
+
+/*
+ * Process some data.
+ * This handles the simple case where no context is required.
+ */
+
+METHODDEF(void)
+process_data_simple_main (j_decompress_ptr cinfo,
+			  JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+			  JDIMENSION out_rows_avail)
+{
+  my_main_ptr main = (my_main_ptr) cinfo->main;
+  JDIMENSION rowgroups_avail;
+
+  /* Read input data if we haven't filled the main buffer yet */
+  if (! main->buffer_full) {
+    if (! (*cinfo->coef->decompress_data) (cinfo, main->buffer))
+      return;			/* suspension forced, can do nothing more */
+    main->buffer_full = TRUE;	/* OK, we have an iMCU row to work with */
+  }
+
+  /* There are always min_DCT_scaled_size row groups in an iMCU row. */
+  rowgroups_avail = (JDIMENSION) cinfo->min_DCT_scaled_size;
+  /* Note: at the bottom of the image, we may pass extra garbage row groups
+   * to the postprocessor.  The postprocessor has to check for bottom
+   * of image anyway (at row resolution), so no point in us doing it too.
+   */
+
+  /* Feed the postprocessor */
+  (*cinfo->post->post_process_data) (cinfo, main->buffer,
+				     &main->rowgroup_ctr, rowgroups_avail,
+				     output_buf, out_row_ctr, out_rows_avail);
+
+  /* Has postprocessor consumed all the data yet? If so, mark buffer empty */
+  if (main->rowgroup_ctr >= rowgroups_avail) {
+    main->buffer_full = FALSE;
+    main->rowgroup_ctr = 0;
+  }
+}
+
+
+/*
+ * Process some data.
+ * This handles the case where context rows must be provided.
+ */
+
+METHODDEF(void)
+process_data_context_main (j_decompress_ptr cinfo,
+			   JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+			   JDIMENSION out_rows_avail)
+{
+  my_main_ptr main = (my_main_ptr) cinfo->main;
+
+  /* Read input data if we haven't filled the main buffer yet */
+  if (! main->buffer_full) {
+    if (! (*cinfo->coef->decompress_data) (cinfo,
+					   main->xbuffer[main->whichptr]))
+      return;			/* suspension forced, can do nothing more */
+    main->buffer_full = TRUE;	/* OK, we have an iMCU row to work with */
+    main->iMCU_row_ctr++;	/* count rows received */
+  }
+
+  /* Postprocessor typically will not swallow all the input data it is handed
+   * in one call (due to filling the output buffer first).  Must be prepared
+   * to exit and restart.  This switch lets us keep track of how far we got.
+   * Note that each case falls through to the next on successful completion.
+   */
+  switch (main->context_state) {
+  case CTX_POSTPONED_ROW:
+    /* Call postprocessor using previously set pointers for postponed row */
+    (*cinfo->post->post_process_data) (cinfo, main->xbuffer[main->whichptr],
+			&main->rowgroup_ctr, main->rowgroups_avail,
+			output_buf, out_row_ctr, out_rows_avail);
+    if (main->rowgroup_ctr < main->rowgroups_avail)
+      return;			/* Need to suspend */
+    main->context_state = CTX_PREPARE_FOR_IMCU;
+    if (*out_row_ctr >= out_rows_avail)
+      return;			/* Postprocessor exactly filled output buf */
+    /*FALLTHROUGH*/
+  case CTX_PREPARE_FOR_IMCU:
+    /* Prepare to process first M-1 row groups of this iMCU row */
+    main->rowgroup_ctr = 0;
+    main->rowgroups_avail = (JDIMENSION) (cinfo->min_DCT_scaled_size - 1);
+    /* Check for bottom of image: if so, tweak pointers to "duplicate"
+     * the last sample row, and adjust rowgroups_avail to ignore padding rows.
+     */
+    if (main->iMCU_row_ctr == cinfo->total_iMCU_rows)
+      set_bottom_pointers(cinfo);
+    main->context_state = CTX_PROCESS_IMCU;
+    /*FALLTHROUGH*/
+  case CTX_PROCESS_IMCU:
+    /* Call postprocessor using previously set pointers */
+    (*cinfo->post->post_process_data) (cinfo, main->xbuffer[main->whichptr],
+			&main->rowgroup_ctr, main->rowgroups_avail,
+			output_buf, out_row_ctr, out_rows_avail);
+    if (main->rowgroup_ctr < main->rowgroups_avail)
+      return;			/* Need to suspend */
+    /* After the first iMCU, change wraparound pointers to normal state */
+    if (main->iMCU_row_ctr == 1)
+      set_wraparound_pointers(cinfo);
+    /* Prepare to load new iMCU row using other xbuffer list */
+    main->whichptr ^= 1;	/* 0=>1 or 1=>0 */
+    main->buffer_full = FALSE;
+    /* Still need to process last row group of this iMCU row, */
+    /* which is saved at index M+1 of the other xbuffer */
+    main->rowgroup_ctr = (JDIMENSION) (cinfo->min_DCT_scaled_size + 1);
+    main->rowgroups_avail = (JDIMENSION) (cinfo->min_DCT_scaled_size + 2);
+    main->context_state = CTX_POSTPONED_ROW;
+  }
+}
+
+
+/*
+ * Process some data.
+ * Final pass of two-pass quantization: just call the postprocessor.
+ * Source data will be the postprocessor controller's internal buffer.
+ */
+
+#ifdef QUANT_2PASS_SUPPORTED
+
+METHODDEF(void)
+process_data_crank_post (j_decompress_ptr cinfo,
+			 JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+			 JDIMENSION out_rows_avail)
+{
+  (*cinfo->post->post_process_data) (cinfo, (JSAMPIMAGE) NULL,
+				     (JDIMENSION *) NULL, (JDIMENSION) 0,
+				     output_buf, out_row_ctr, out_rows_avail);
+}
+
+#endif /* QUANT_2PASS_SUPPORTED */
+
+
+/*
+ * Initialize main buffer controller.
+ */
+
+GLOBAL(void)
+jinit_d_main_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
+{
+  my_main_ptr main;
+  int ci, rgroup, ngroups;
+  jpeg_component_info *compptr;
+
+  main = (my_main_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_main_controller));
+  cinfo->main = (struct jpeg_d_main_controller *) main;
+  main->pub.start_pass = start_pass_main;
+
+  if (need_full_buffer)		/* shouldn't happen */
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+
+  /* Allocate the workspace.
+   * ngroups is the number of row groups we need.
+   */
+  if (cinfo->upsample->need_context_rows) {
+    if (cinfo->min_DCT_scaled_size < 2) /* unsupported, see comments above */
+      ERREXIT(cinfo, JERR_NOTIMPL);
+    alloc_funny_pointers(cinfo); /* Alloc space for xbuffer[] lists */
+    ngroups = cinfo->min_DCT_scaled_size + 2;
+  } else {
+    ngroups = cinfo->min_DCT_scaled_size;
+  }
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
+      cinfo->min_DCT_scaled_size; /* height of a row group of component */
+    main->buffer[ci] = (*cinfo->mem->alloc_sarray)
+			((j_common_ptr) cinfo, JPOOL_IMAGE,
+			 compptr->width_in_blocks * compptr->DCT_scaled_size,
+			 (JDIMENSION) (rgroup * ngroups));
+  }
+}