Repatch (from linux) of OSX IRAF

1 files changed, 6177 insertions, 0 deletions

diff --git a/vendor/x11iraf/obm/ObmW/HTML.c b/vendor/x11iraf/obm/ObmW/HTML.c
new file mode 100644
index 00000000..546bfbc0
--- /dev/null
+++ b/vendor/x11iraf/obm/ObmW/HTML.c
@@ -0,0 +1,6177 @@
+/****************************************************************************
+ * NCSA Mosaic for the X Window System                                      *
+ * Software Development Group                                               *
+ * National Center for Supercomputing Applications                          *
+ * University of Illinois at Urbana-Champaign                               *
+ * 605 E. Springfield, Champaign IL 61820                                   *
+ * mosaic@ncsa.uiuc.edu                                                     *
+ *                                                                          *
+ * Copyright (C) 1993, Board of Trustees of the University of Illinois      *
+ *                                                                          *
+ * NCSA Mosaic software, both binary and source (hereafter, Software) is    *
+ * copyrighted by The Board of Trustees of the University of Illinois       *
+ * (UI), and ownership remains with the UI.                                 *
+ *                                                                          *
+ * The UI grants you (hereafter, Licensee) a license to use the Software    *
+ * for academic, research and internal business purposes only, without a    *
+ * fee.  Licensee may distribute the binary and source code (if released)   *
+ * to third parties provided that the copyright notice and this statement   *
+ * appears on all copies and that no charge is associated with such         *
+ * copies.                                                                  *
+ *                                                                          *
+ * Licensee may make derivative works.  However, if Licensee distributes    *
+ * any derivative work based on or derived from the Software, then          *
+ * Licensee will (1) notify NCSA regarding its distribution of the          *
+ * derivative work, and (2) clearly notify users that such derivative       *
+ * work is a modified version and not the original NCSA Mosaic              *
+ * distributed by the UI.                                                   *
+ *                                                                          *
+ * Any Licensee wishing to make commercial use of the Software should       *
+ * contact the UI, c/o NCSA, to negotiate an appropriate license for such   *
+ * commercial use.  Commercial use includes (1) integration of all or       *
+ * part of the source code into a product for sale or license by or on      *
+ * behalf of Licensee to third parties, or (2) distribution of the binary   *
+ * code or source code to third parties that need it to utilize a           *
+ * commercial product sold or licensed by or on behalf of Licensee.         *
+ *                                                                          *
+ * UI MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THIS SOFTWARE FOR   *
+ * ANY PURPOSE.  IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED          *
+ * WARRANTY.  THE UI SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY THE    *
+ * USERS OF THIS SOFTWARE.                                                  *
+ *                                                                          *
+ * By using or copying this Software, Licensee agrees to abide by the       *
+ * copyright law and all other applicable laws of the U.S. including, but   *
+ * not limited to, export control laws, and the terms of this license.      *
+ * UI shall have the right to terminate this license immediately by         *
+ * written notice upon Licensee's breach of, or non-compliance with, any    *
+ * of its terms.  Licensee may be held legally responsible for any          *
+ * copyright infringement that is caused or encouraged by Licensee's        *
+ * failure to abide by the terms of this license.                           *
+ *                                                                          *
+ * Comments and questions are welcome and can be sent to                    *
+ * mosaic-x@ncsa.uiuc.edu.                                                  *
+ ****************************************************************************/
+
+#include <stdio.h>
+#include "HTMLP.h"
+#ifdef MOTIF
+#include <Xm/DrawingA.h>
+#include <Xm/ScrollBar.h>
+#else
+#include "DrawingArea.h"
+#include <X11/Xaw/Scrollbar.h>
+#endif
+#include <X11/cursorfont.h>
+
+
+#define	MARGIN_DEFAULT		20
+#define	CLICK_TIME		500
+#define	SELECT_THRESHOLD	3
+#define	MAX_UNDERLINES		3
+#define DEFAULT_INCREMENT       18
+
+#ifndef ABS
+#define ABS(x)  (((x) > 0) ? (x) : ((x) * -1))
+#endif
+
+#define	W_TEXTFIELD	0
+#define	W_CHECKBOX	1
+#define	W_RADIOBOX	2
+#define	W_PUSHBUTTON	3
+#define	W_PASSWORD	4
+#define	W_OPTIONMENU	5
+
+
+extern int FormatAll();
+extern int DocumentWidth();
+extern void PlaceLine();
+extern void TextRefresh();
+extern void ImageRefresh();
+extern void LinefeedRefresh();
+extern void RefreshTextRange();
+extern void FreeColors();
+extern void FreeImages();
+extern void HideWidgets();
+extern void MapWidgets();
+extern int SwapElements();
+extern int ElementLessThan();
+extern int IsDelayedHRef();
+extern int IsIsMapForm();
+extern int AnchoredHeight();
+extern char *ParseMarkTag();
+extern char *ParseTextToString();
+extern char *ParseTextToPrettyString();
+extern char *ParseTextToPSString();
+extern struct mark_up *HTMLParse();
+extern struct ele_rec *LocateElement();
+extern struct ele_rec **MakeLineList();
+extern void FreeHRefs();
+extern struct ref_rec *AddHRef();
+extern void FreeDelayedImages();
+extern struct delay_rec *AddDelayedImage();
+extern ImageInfo *NoImageData();
+extern void ImageSubmitForm();
+
+
+static void		SelectStart();
+static void		ExtendStart();
+static void		ExtendAdjust();
+static void		ExtendEnd();
+static void             TrackMotion();
+static Boolean		ConvertSelection();
+static void		LoseSelection();
+static void		SelectionDone();
+static void		Scroll();
+
+
+#ifdef _NO_PROTO
+
+static void		_HTMLInput() ;
+#ifndef MOTIF
+static void		_HTMLpwdInput() ;
+#endif
+static void             Initialize() ;
+static void             Realize() ;
+static void             Redisplay() ;
+static void             Resize() ;
+static Boolean          SetValues() ;
+static XtGeometryResult	GeometryManager() ;
+static void		RecolorInternalHRefs() ;
+static Dimension	VbarWidth();
+static Dimension	HbarHeight();
+static void		ViewRedisplay();
+static void		ViewClearAndRefresh();
+static void		CallLinkCallbacks();
+
+#else /* _NO_PROTO */
+
+static void		_HTMLInput(Widget w, XEvent *event,
+				String *params, Cardinal *num_params);
+#ifndef MOTIF
+static void		_HTMLpwdInput(Widget w, XEvent *event,
+				String *params, Cardinal *num_params);
+#endif
+static void             Initialize(HTMLWidget request, HTMLWidget new);
+static void             Realize(HTMLWidget hw, Mask *valueMask, 
+				XSetWindowAttributes *attributes);
+static void             Redisplay(HTMLWidget hw, XEvent *event, Region region);
+static void             Resize(HTMLWidget hw);
+static Boolean          SetValues(HTMLWidget current, HTMLWidget request,
+				HTMLWidget new);
+static XtGeometryResult GeometryManager(Widget w, XtWidgetGeometry *request,
+				XtWidgetGeometry *reply);
+static void		RecolorInternalHRefs(HTMLWidget hw, char *href);
+static Dimension        VbarWidth(HTMLWidget hw);
+static Dimension        HbarHeight(HTMLWidget hw);
+static void		ViewRedisplay(HTMLWidget hw, int x, int y,
+				int width, int height);
+static void             ViewClearAndRefresh(HTMLWidget hw);
+static void             CallLinkCallbacks(HTMLWidget hw);
+#endif /* _NO_PROTO */
+
+
+/*
+ * Default translations
+ * Selection of text, and activate anchors.
+ * If motif, add manager translations.
+ */
+#ifdef MOTIF
+static char defaultTranslations[] =
+" \
+<Btn1Down>:	select-start() ManagerGadgetArm()\n\
+<Btn1Motion>:	extend-adjust() ManagerGadgetButtonMotion()\n\
+<Btn1Up>:	extend-end(PRIMARY, CUT_BUFFER0) ManagerGadgetActivate()\n\
+<Btn2Down>:	select-start()\n\
+<Btn2Motion>:	extend-adjust()\n\
+<Btn2Up>:	extend-end(PRIMARY, CUT_BUFFER0)\n\
+<Btn3Down>:	extend-start()\n\
+<Btn3Motion>:	extend-adjust()\n\
+<Btn3Up>:	extend-end(PRIMARY, CUT_BUFFER0) \n\
+<Key>f:		scroll(1)\n\
+<Key>b:		scroll(-1)\n\
+<Key>Prior:     scroll(-1)\n\
+<Key>Next:      scroll(1)\n\
+<Key>u:		scroll(-0.5)\n\
+<Key>d:		scroll(0.5)\n\
+<Key>Up:        scroll(-0.5)\n\
+<Key>Down:      scroll(0.5)\n\
+<Key>j:		scroll(1ch)\n\
+<Key>k:		scroll(-1ch)\n\
+<Motion>:       track-motion()\n\
+<Leave>:        track-motion()\n\
+<FocusOut>:     track-motion()\n\
+<Expose>:       track-motion()\
+";
+#else
+static char defaultTranslations[] =
+" \
+<Btn1Down>:	select-start() \n\
+<Btn1Motion>:	extend-adjust() \n\
+<Btn1Up>:	extend-end(PRIMARY, CUT_BUFFER0) \n\
+<Btn2Down>:	select-start() \n\
+<Btn2Motion>:	extend-adjust() \n\
+<Btn2Up>:	extend-end(PRIMARY, CUT_BUFFER0) \n\
+<Btn3Down>:	extend-start()\n\
+<Btn3Motion>:	extend-adjust()\n\
+<Btn3Up>:	extend-end(PRIMARY, CUT_BUFFER0) \n\
+<Key>f:		scroll(1)\n\
+<Key>b:		scroll(-1)\n\
+<Key>Prior:     scroll(-1)\n\
+<Key>Next:      scroll(1)\n\
+<Key>u:		scroll(-0.5)\n\
+<Key>d:		scroll(0.5)\n\
+<Key>Up:        scroll(-0.5)\n\
+<Key>Down:      scroll(0.5)\n\
+<Key>j:		scroll(1ch)\n\
+<Key>k:		scroll(-1ch)\n\
+<Motion>:       track-motion()\n\
+<Leave>:        track-motion()\n\
+<FocusOut>:     track-motion()\n\
+<Expose>:       track-motion()\
+";
+#endif /* MOTIF */
+
+
+static XtActionsRec actionsList[] =
+{
+   { "select-start",    (XtActionProc) SelectStart },
+   { "extend-start",    (XtActionProc) ExtendStart },
+   { "extend-adjust",   (XtActionProc) ExtendAdjust },
+   { "extend-end",      (XtActionProc) ExtendEnd },
+   { "track-motion",    (XtActionProc) TrackMotion },
+   { "scroll",		(XtActionProc) Scroll },
+   { "HTMLInput",	(XtActionProc) _HTMLInput },
+#ifndef MOTIF
+   { "HTMLpwdInput",	(XtActionProc) _HTMLpwdInput },
+#endif
+
+#ifdef MOTIF
+#ifndef MOTIF1_2
+   { "Arm",      (XtActionProc) _XmGadgetArm },         /* Motif 1.0 */
+   { "Activate", (XtActionProc) _XmGadgetActivate },    /* Motif 1.0 */
+   { "Enter",    (XtActionProc) _XmManagerEnter },      /* Motif 1.0 */
+   { "FocusIn",  (XtActionProc) _XmManagerFocusIn },    /* Motif 1.0 */
+   { "Help",     (XtActionProc) _XmManagerHelp },       /* Motif 1.0 */
+#endif /* not MOTIF1_2 */
+#endif /* MOTIF */
+};
+
+/*
+ * For some reason, in Motif1.2/X11R5 the actionsList above gets corrupted
+ * When the parent HTML widget is created.  This means we can't use
+ * it later with XtAppAddActions to add to the viewing area.
+ * So, we make a spare copy here to use with XtAppAddActions.
+ */
+static XtActionsRec SpareActionsList[] =
+{
+   { "select-start",    (XtActionProc) SelectStart },
+   { "extend-start",    (XtActionProc) ExtendStart },
+   { "extend-adjust",   (XtActionProc) ExtendAdjust },
+   { "extend-end",      (XtActionProc) ExtendEnd },
+   { "track-motion",    (XtActionProc) TrackMotion },
+   { "scroll",		(XtActionProc) Scroll },
+   { "HTMLInput",	(XtActionProc) _HTMLInput },
+#ifndef MOTIF
+   { "HTMLpwdInput",	(XtActionProc) _HTMLpwdInput },
+#endif
+};
+
+
+
+/*
+ *  Resource definitions for HTML widget
+ */
+
+static XtResource resources[] =
+{
+  /* Without Motif we need to override the borderWidth to 0 (from 1). */
+#ifndef MOTIF
+        {       XtNborderWidth,
+                XtCBorderWidth, XtRDimension, sizeof (Dimension),
+                XtOffset (HTMLWidget, core.border_width),
+                XtRImmediate, (XtPointer) 0
+        },
+#endif
+
+	{	WbNmarginWidth,
+		WbCMarginWidth, XtRDimension, sizeof (Dimension),
+		XtOffset (HTMLWidget, html.margin_width),
+		XtRImmediate, (caddr_t) MARGIN_DEFAULT
+	},
+
+	{	WbNmarginHeight,
+		WbCMarginHeight, XtRDimension, sizeof (Dimension),
+		XtOffset (HTMLWidget, html.margin_height),
+		XtRImmediate, (caddr_t) MARGIN_DEFAULT
+	},
+
+	{	WbNanchorCallback,
+		XtCCallback, XtRCallback, sizeof (XtCallbackList),
+		XtOffset (HTMLWidget, html.anchor_callback),
+		XtRImmediate, (caddr_t) NULL
+	},
+
+	{	WbNlinkCallback,
+		XtCCallback, XtRCallback, sizeof (XtCallbackList),
+		XtOffset (HTMLWidget, html.link_callback),
+		XtRImmediate, (caddr_t) NULL
+	},
+
+	{	WbNsubmitFormCallback,
+		XtCCallback, XtRCallback, sizeof (XtCallbackList),
+		XtOffset (HTMLWidget, html.form_callback),
+		XtRImmediate, (caddr_t) NULL
+	},
+
+	{	WbNtext,
+		WbCText, XtRString, sizeof (char *),
+		XtOffset (HTMLWidget, html.raw_text),
+		XtRString, (char *) NULL
+	},
+
+	{	WbNheaderText,
+		WbCHeaderText, XtRString, sizeof (char *),
+		XtOffset (HTMLWidget, html.header_text),
+		XtRString, (char *) NULL
+	},
+
+	{	WbNfooterText,
+		WbCFooterText, XtRString, sizeof (char *),
+		XtOffset (HTMLWidget, html.footer_text),
+		XtRString, (char *) NULL
+	},
+
+	{	WbNtitleText,
+		WbCTitleText, XtRString, sizeof (char *),
+		XtOffset (HTMLWidget, html.title),
+		XtRString, (char *) NULL
+	},
+
+/*
+ * Without motif we need our own foreground resource instead of
+ * using the manager's
+ */
+#ifndef MOTIF
+	{	XtNforeground,
+		XtCForeground, XtRPixel, sizeof (Pixel),
+		XtOffset (HTMLWidget, html.foreground),
+		XtRString, "Black"
+	},
+#endif
+
+	{	WbNanchorUnderlines,
+		WbCAnchorUnderlines, XtRInt, sizeof (int),
+		XtOffset (HTMLWidget, html.num_anchor_underlines),
+		XtRString, "0"
+	},
+
+	{	WbNvisitedAnchorUnderlines,
+		WbCVisitedAnchorUnderlines, XtRInt, sizeof (int),
+		XtOffset (HTMLWidget, html.num_visitedAnchor_underlines),
+		XtRString, "0"
+	},
+
+	{	WbNdashedAnchorUnderlines,
+		WbCDashedAnchorUnderlines, XtRBoolean, sizeof (Boolean),
+		XtOffset (HTMLWidget, html.dashed_anchor_lines),
+		XtRString, "False"
+	},
+
+	{	WbNdashedVisitedAnchorUnderlines,
+		WbCDashedVisitedAnchorUnderlines, XtRBoolean, sizeof (Boolean),
+		XtOffset (HTMLWidget, html.dashed_visitedAnchor_lines),
+		XtRString, "False"
+	},
+
+	{	WbNanchorColor,
+		XtCForeground, XtRPixel, sizeof (Pixel),
+		XtOffset (HTMLWidget, html.anchor_fg),
+		XtRString, "blue2"
+	},
+
+	{	WbNvisitedAnchorColor,
+		XtCForeground, XtRPixel, sizeof (Pixel),
+		XtOffset (HTMLWidget, html.visitedAnchor_fg),
+		XtRString, "purple4"
+	},
+
+	{	WbNactiveAnchorFG,
+		XtCBackground, XtRPixel, sizeof (Pixel),
+		XtOffset (HTMLWidget, html.activeAnchor_fg),
+		XtRString, "Red"
+	},
+
+	{	WbNactiveAnchorBG,
+		XtCForeground, XtRPixel, sizeof (Pixel),
+		XtOffset (HTMLWidget, html.activeAnchor_bg),
+		XtRString, "White"
+	},
+
+	{	WbNpercentVerticalSpace,
+		WbCPercentVerticalSpace, XtRInt, sizeof (int),
+		XtOffset (HTMLWidget, html.percent_vert_space),
+		XtRString, "90"
+	},
+
+	{	WbNimageBorders,
+		WbCImageBorders, XtRBoolean, sizeof (Boolean),
+		XtOffset (HTMLWidget, html.border_images),
+		XtRString, "False"
+	},
+
+	{	WbNdelayImageLoads,
+		WbCDelayImageLoads, XtRBoolean, sizeof (Boolean),
+		XtOffset (HTMLWidget, html.delay_images),
+		XtRString, "False"
+	},
+
+	{	WbNfancySelections,
+		WbCFancySelections, XtRBoolean, sizeof (Boolean),
+		XtOffset (HTMLWidget, html.fancy_selections),
+		XtRString, "False"
+	},
+
+	{	WbNisIndex,
+		WbCIsIndex, XtRBoolean, sizeof (Boolean),
+		XtOffset (HTMLWidget, html.is_index),
+		XtRString, "False"
+	},
+
+	{	WbNview,
+		WbCView, XtRWidget, sizeof (Widget),
+		XtOffset (HTMLWidget, html.view),
+		XtRImmediate, NULL
+	},
+
+	{	WbNverticalScrollBar,
+		WbCVerticalScrollBar, XtRWidget, sizeof (Widget),
+		XtOffset (HTMLWidget, html.vbar),
+		XtRImmediate, NULL
+	},
+
+	{	WbNhorizontalScrollBar,
+		WbCHorizontalScrollBar, XtRWidget, sizeof (Widget),
+		XtOffset (HTMLWidget, html.hbar),
+		XtRImmediate, NULL
+	},
+
+	{	WbNverticalScrollOnRight,
+		WbCVerticalScrollOnRight, XtRBoolean, sizeof (Boolean),
+		XtOffset (HTMLWidget, html.vbar_right),
+		XtRString, "True"
+	},
+
+	{	WbNhorizontalScrollOnTop,
+		WbCHorizontalScrollOnTop, XtRBoolean, sizeof (Boolean),
+		XtOffset (HTMLWidget, html.hbar_top),
+		XtRString, "False"
+	},
+
+	{	XtNfont,
+		XtCFont, XtRFontStruct, sizeof (XFontStruct *),
+		XtOffset (HTMLWidget, html.font),
+		XtRString, "-adobe-times-medium-r-normal-*-14-*-*-*-*-*-*-*"
+	},
+
+	{	WbNitalicFont,
+		WbCItalicFont, XtRFontStruct, sizeof (XFontStruct *),
+		XtOffset (HTMLWidget, html.italic_font),
+		XtRString, "-adobe-times-medium-i-normal-*-14-*-*-*-*-*-*-*"
+	},
+
+	{	WbNboldFont,
+		WbCBoldFont, XtRFontStruct, sizeof (XFontStruct *),
+		XtOffset (HTMLWidget, html.bold_font),
+		XtRString, "-adobe-times-bold-r-normal-*-14-*-*-*-*-*-*-*"
+	},
+
+	{	WbNfixedFont,
+		WbCFixedFont, XtRFontStruct, sizeof (XFontStruct *),
+		XtOffset (HTMLWidget, html.fixed_font),
+		XtRString, "-adobe-courier-medium-r-normal-*-14-*-*-*-*-*-*-*"
+	},
+
+	{	WbNfixedboldFont,
+		WbCFixedboldFont, XtRFontStruct, sizeof (XFontStruct *),
+		XtOffset (HTMLWidget, html.fixedbold_font),
+		XtRString, "-adobe-courier-bold-r-normal-*-14-*-*-*-*-*-*-*"
+	},
+
+	{	WbNfixeditalicFont,
+		WbCFixeditalicFont, XtRFontStruct, sizeof (XFontStruct *),
+		XtOffset (HTMLWidget, html.fixeditalic_font),
+		XtRString, "-adobe-courier-medium-o-normal-*-14-*-*-*-*-*-*-*"
+	},
+
+	{	WbNheader1Font,
+		WbCHeader1Font, XtRFontStruct, sizeof (XFontStruct *),
+		XtOffset (HTMLWidget, html.header1_font),
+		XtRString, "-adobe-times-bold-r-normal-*-24-*-*-*-*-*-*-*"
+	},
+
+	{	WbNheader2Font,
+		WbCHeader2Font, XtRFontStruct, sizeof (XFontStruct *),
+		XtOffset (HTMLWidget, html.header2_font),
+		XtRString, "-adobe-times-bold-r-normal-*-18-*-*-*-*-*-*-*"
+	},
+
+	{	WbNheader3Font,
+		WbCHeader3Font, XtRFontStruct, sizeof (XFontStruct *),
+		XtOffset (HTMLWidget, html.header3_font),
+		XtRString, "-adobe-times-bold-r-normal-*-17-*-*-*-*-*-*-*"
+	},
+
+	{	WbNheader4Font,
+		WbCHeader4Font, XtRFontStruct, sizeof (XFontStruct *),
+		XtOffset (HTMLWidget, html.header4_font),
+		XtRString, "-adobe-times-bold-r-normal-*-14-*-*-*-*-*-*-*"
+	},
+
+	{	WbNheader5Font,
+		WbCHeader5Font, XtRFontStruct, sizeof (XFontStruct *),
+		XtOffset (HTMLWidget, html.header5_font),
+		XtRString, "-adobe-times-bold-r-normal-*-12-*-*-*-*-*-*-*"
+	},
+
+	{	WbNheader6Font,
+		WbCHeader6Font, XtRFontStruct, sizeof (XFontStruct *),
+		XtOffset (HTMLWidget, html.header6_font),
+		XtRString, "-adobe-times-bold-r-normal-*-10-*-*-*-*-*-*-*"
+	},
+
+	{	WbNaddressFont,
+		WbCAddressFont, XtRFontStruct, sizeof (XFontStruct *),
+		XtOffset (HTMLWidget, html.address_font),
+		XtRString, "-adobe-times-medium-i-normal-*-14-*-*-*-*-*-*-*"
+	},
+
+	{	WbNplainFont,
+		WbCPlainFont, XtRFontStruct, sizeof (XFontStruct *),
+		XtOffset (HTMLWidget, html.plain_font),
+		XtRString, "-adobe-courier-medium-r-normal-*-14-*-*-*-*-*-*-*"
+	},
+
+	{	WbNplainboldFont,
+		WbCPlainboldFont, XtRFontStruct, sizeof (XFontStruct *),
+		XtOffset (HTMLWidget, html.plainbold_font),
+		XtRString, "-adobe-courier-bold-r-normal-*-14-*-*-*-*-*-*-*"
+	},
+
+	{	WbNplainitalicFont,
+		WbCPlainitalicFont, XtRFontStruct, sizeof (XFontStruct *),
+		XtOffset (HTMLWidget, html.plainitalic_font),
+		XtRString, "-adobe-courier-medium-o-normal-*-14-*-*-*-*-*-*-*"
+	},
+
+	{	WbNlistingFont,
+		WbCListingFont, XtRFontStruct, sizeof (XFontStruct *),
+		XtOffset (HTMLWidget, html.listing_font),
+		XtRString, "-adobe-courier-medium-r-normal-*-12-*-*-*-*-*-*-*"
+	},
+                  
+        {       WbNpreviouslyVisitedTestFunction,
+                WbCPreviouslyVisitedTestFunction, XtRPointer, 
+                sizeof (XtPointer),
+                XtOffset (HTMLWidget, html.previously_visited_test),
+                XtRImmediate, (caddr_t) NULL
+        },
+
+        {       WbNpreviouslyVisitedTestData,
+                WbCPreviouslyVisitedTestData, XtRPointer, 
+                sizeof (XtPointer),
+                XtOffset (HTMLWidget, html.vt_client_data),
+                XtRImmediate, (caddr_t) NULL
+        },
+                  
+        {       WbNresolveImageFunction,
+                WbCResolveImageFunction, XtRPointer, 
+                sizeof (XtPointer),
+                XtOffset (HTMLWidget, html.resolveImage),
+                XtRImmediate, (caddr_t) NULL
+        },
+                  
+        {       WbNresolveDelayedImage,
+                WbCResolveDelayedImage, XtRPointer, 
+                sizeof (XtPointer),
+                XtOffset (HTMLWidget, html.resolveDelayedImage),
+                XtRImmediate, (caddr_t) NULL
+        },
+
+        {
+                WbNpointerMotionCallback,
+                WbCPointerMotionCallback, XtRPointer, 
+                sizeof (XtPointer),
+                XtOffset (HTMLWidget, html.pointer_motion_callback),
+                XtRImmediate, (caddr_t) NULL
+        },
+
+        {       WbNpointerMotionData,
+                WbCPointerMotionData, XtRPointer, 
+                sizeof (XtPointer),
+                XtOffset (HTMLWidget, html.pm_client_data),
+                XtRImmediate, (caddr_t) NULL
+        },
+
+};
+
+
+
+HTMLClassRec htmlClassRec = {
+   {						/* core class fields  */
+#ifdef MOTIF
+      (WidgetClass) &xmManagerClassRec,		/* superclass         */
+#else
+      (WidgetClass) &constraintClassRec,	/* superclass         */
+#endif /* MOTIF */
+      "HTML",					/* class_name         */
+      sizeof(HTMLRec),				/* widget_size        */
+      NULL,					/* class_initialize   */
+      NULL,					/* class_part_init    */
+      FALSE,					/* class_inited       */
+      (XtInitProc) Initialize,			/* initialize         */
+      NULL,					/* initialize_hook    */
+      (XtRealizeProc) Realize,			/* realize            */
+      actionsList,				/* actions	      */
+      XtNumber(actionsList),			/* num_actions	      */
+      resources,				/* resources          */
+      XtNumber(resources),			/* num_resources      */
+      NULLQUARK,				/* xrm_class          */
+      TRUE,					/* compress_motion    */
+      FALSE,					/* compress_exposure  */
+      TRUE,					/* compress_enterlv   */
+      FALSE,					/* visible_interest   */
+      NULL,			                /* destroy            */
+      (XtWidgetProc) Resize,			/* resize             */
+      (XtExposeProc) Redisplay,			/* expose             */
+      (XtSetValuesFunc) SetValues,		/* set_values         */
+      NULL,					/* set_values_hook    */
+      XtInheritSetValuesAlmost,			/* set_values_almost  */
+      NULL,					/* get_values_hook    */
+      NULL,					/* accept_focus       */
+      XtVersion,				/* version            */
+      NULL,					/* callback_private   */
+      defaultTranslations,			/* tm_table           */
+      XtInheritQueryGeometry,			/* query_geometry     */
+      XtInheritDisplayAccelerator,              /* display_accelerator*/
+      NULL,		                        /* extension          */
+   },
+
+   {		/* composite_class fields */
+      (XtGeometryHandler) GeometryManager,   	/* geometry_manager   */
+      NULL,					/* change_managed     */
+      XtInheritInsertChild,			/* insert_child       */
+      XtInheritDeleteChild,			/* delete_child       */
+      NULL,                                     /* extension          */
+   },
+
+   {		/* constraint_class fields */
+      NULL,					/* resource list        */   
+      0,					/* num resources        */   
+      0,					/* constraint size      */   
+      NULL,					/* init proc            */   
+      NULL,					/* destroy proc         */   
+      NULL,					/* set values proc      */   
+      NULL,                                     /* extension            */
+   },
+
+#ifdef MOTIF
+   {		/* manager_class fields */
+      XtInheritTranslations,			/* translations           */
+      NULL,					/* syn_resources      	  */
+      0,					/* num_syn_resources 	  */
+      NULL,					/* syn_cont_resources     */
+      0,					/* num_syn_cont_resources */
+      XmInheritParentProcess,                   /* parent_process         */
+      NULL,					/* extension 	          */    
+   },
+#endif /* MOTIF */
+
+   {		/* html_class fields */     
+      0						/* none			  */
+   }	
+};
+
+WidgetClass htmlWidgetClass = (WidgetClass)&htmlClassRec;
+
+/*static Cursor in_anchor_cursor = (Cursor)NULL;*/		/* MF021 */
+Cursor in_anchor_cursor = (Cursor)NULL;
+
+
+/*
+ * Process an expose event in the View (or drawing area).  This
+ * Can be a regular expose event, or perhaps a GraphicsExpose Event.
+ */
+static void
+DrawExpose(w, data, event)
+	Widget w;
+	caddr_t data;
+	XEvent *event;
+{
+	XExposeEvent *ExEvent = (XExposeEvent *)event;
+	HTMLWidget hw = (HTMLWidget)data;
+	int x, y;
+	int width, height;
+
+	if ((event->xany.type != Expose)&&(event->xany.type != GraphicsExpose))
+	{
+		return;
+	}
+
+	/*
+	 * Make sure we have a valid GC to draw with.
+	 */
+	if (hw->html.drawGC == NULL)
+	{
+		unsigned long valuemask;
+		XGCValues values;
+
+		values.function = GXcopy;
+		values.plane_mask = AllPlanes;
+/*
+ * Without motif we use our own foreground resource instead of
+ * using the manager's
+ */
+#ifdef MOTIF
+		values.foreground = hw->manager.foreground;
+#else
+		values.foreground = hw->html.foreground;
+#endif /* MOTIF */
+		values.background = hw->core.background_pixel;
+
+		valuemask = GCFunction|GCPlaneMask|GCForeground|GCBackground;
+
+		hw->html.drawGC = XCreateGC(XtDisplay(hw), XtWindow(hw),
+			valuemask, &values);
+	}
+
+	x = ExEvent->x;
+	y = ExEvent->y;
+	width = (int)ExEvent->width;
+	height = (int)ExEvent->height;
+
+#ifdef DEBUG
+DebugHook(x, y, width, height);
+#endif
+
+	ViewRedisplay(hw, x, y, width, height);
+}
+
+
+void
+ScrollWidgets(hw)
+	HTMLWidget hw;
+{
+	WidgetInfo *wptr;
+	int xval, yval;
+
+	xval = hw->html.scroll_x;
+	yval = hw->html.scroll_y;
+	wptr = hw->html.widget_list;
+	while (wptr != NULL)
+	{
+		if (wptr->w != NULL)
+		{
+			Widget w;
+			int x, y;
+
+			w = wptr->w;
+			x = wptr->x;
+			y = wptr->y;
+			XtMoveWidget(w, (x - xval), (y - yval));
+		}
+		wptr = wptr->next;
+	}
+}
+
+
+#ifndef MOTIF
+/*
+ * Set the Athena Scrollbar's thumb position properly.
+ */
+static void
+setScrollBar(sb, topPosition, totalLength, currentLength)
+	Widget sb;
+        int topPosition;                                        /* MF026 */
+	int totalLength, currentLength;				/* MF026 */
+{
+	float top   = (float)topPosition  /(float)(totalLength);
+	float shown = (float)currentLength/(float)(totalLength);
+
+	XawScrollbarSetThumb(sb, top, shown);
+}
+#endif
+
+
+/*
+ * Either the vertical or hortizontal scrollbar has been moved
+ */
+void
+ScrollToPos(w, hw, value)
+	Widget w;
+	HTMLWidget hw;
+	int value;
+{
+	/*
+	 * Special code incase the scrollbar is "moved" before we have a window
+	 * (if we have a GC we have a window)
+	 */
+	if (hw->html.drawGC == NULL)
+	{
+		if (w == hw->html.vbar)
+		{
+			hw->html.scroll_y = value;
+		}
+		else if (w == hw->html.hbar)
+		{
+			hw->html.scroll_x = value;
+		}
+		return;
+	}
+
+	/*
+	 * get our widgets out of the way (No Expose events)
+	HideWidgets(hw);
+	 */
+
+	/*
+	 * If we've moved the vertical scrollbar
+	 */
+	if (w == hw->html.vbar)
+	{
+		/*
+		 * We've scrolled down. Copy up the untouched part of the
+		 * window.  Then Clear and redraw the new area
+		 * exposed.
+		 */
+		if (value > hw->html.scroll_y)
+		{
+			int dy;
+	    
+			dy = value - hw->html.scroll_y;
+			if (dy > hw->html.view_height)
+			{
+				hw->html.scroll_y = value;
+				XClearArea(XtDisplay(hw->html.view),
+					XtWindow(hw->html.view),
+					0, 0,
+					hw->html.view_width,
+					hw->html.view_height, False);
+				ViewRedisplay(hw,
+					0, 0,
+					hw->html.view_width,
+					hw->html.view_height);
+			}
+			else
+			{
+				XCopyArea(XtDisplay(hw->html.view),
+					XtWindow(hw->html.view),
+					XtWindow(hw->html.view),
+					hw->html.drawGC, 0, dy,
+					hw->html.view_width,
+					hw->html.view_height - dy,
+					0, 0);
+				hw->html.scroll_y = value;
+				XClearArea(XtDisplay(hw->html.view),
+					XtWindow(hw->html.view),
+					0, (int)hw->html.view_height - dy,
+					hw->html.view_width, dy, False);
+				ViewRedisplay(hw,
+					0, (int)hw->html.view_height - dy,
+					hw->html.view_width, dy);
+			}
+		}
+		/*
+		 * We've scrolled up. Copy down the untouched part of the
+		 * window.  Then Clear and redraw the new area
+		 * exposed.
+		 */
+		else if (value < hw->html.scroll_y)
+		{
+			int dy;
+	    
+			dy = hw->html.scroll_y - value;
+			if (dy > hw->html.view_height)
+			{
+				hw->html.scroll_y = value;
+				XClearArea(XtDisplay(hw->html.view),
+					XtWindow(hw->html.view),
+					0, 0,
+					hw->html.view_width,
+					hw->html.view_height, False);
+				ViewRedisplay(hw,
+					0, 0,
+					hw->html.view_width,
+					hw->html.view_height);
+			}
+			else
+			{
+				XCopyArea(XtDisplay(hw->html.view),
+					XtWindow(hw->html.view),
+					XtWindow(hw->html.view),
+					hw->html.drawGC, 0, 0,
+					hw->html.view_width,
+					hw->html.view_height - dy,
+					0, dy);
+				hw->html.scroll_y = value;
+				XClearArea(XtDisplay(hw->html.view),
+					XtWindow(hw->html.view),
+					0, 0,
+					hw->html.view_width, dy, False);
+				ViewRedisplay(hw,
+					0, 0,
+					hw->html.view_width, dy);
+			}
+		}
+	}
+	/*
+	 * Else we've moved the horizontal scrollbar
+	 */
+	else if (w == hw->html.hbar)
+	{
+		/*
+		 * We've scrolled right. Copy left the untouched part of the
+		 * window.  Then Clear and redraw the new area
+		 * exposed.
+		 */
+		if (value > hw->html.scroll_x)
+		{
+			int dx;
+	    
+			dx = value - hw->html.scroll_x;
+			if (dx > hw->html.view_width)
+			{
+				hw->html.scroll_x = value;
+				XClearArea(XtDisplay(hw->html.view),
+					XtWindow(hw->html.view),
+					0, 0,
+					hw->html.view_width,
+					hw->html.view_height, False);
+				ViewRedisplay(hw,
+					0, 0,
+					hw->html.view_width,
+					hw->html.view_height);
+			}
+			else
+			{
+				XCopyArea(XtDisplay(hw->html.view),
+					XtWindow(hw->html.view),
+					XtWindow(hw->html.view),
+					hw->html.drawGC, dx, 0,
+					hw->html.view_width - dx,
+					hw->html.view_height,
+					0, 0);
+				hw->html.scroll_x = value;
+				XClearArea(XtDisplay(hw->html.view),
+					XtWindow(hw->html.view),
+					(int)hw->html.view_width - dx, 0,
+					dx, hw->html.view_height, False);
+				ViewRedisplay(hw,
+					(int)hw->html.view_width - dx, 0,
+					dx, hw->html.view_height);
+			}
+		}
+		/*
+		 * We've scrolled left. Copy right the untouched part of the
+		 * window.  Then Clear and redraw the new area
+		 * exposed.
+		 */
+		else if (value < hw->html.scroll_x)
+		{
+			int dx;
+	    
+			dx = hw->html.scroll_x - value;
+			if (dx > hw->html.view_width)
+			{
+				hw->html.scroll_x = value;
+				XClearArea(XtDisplay(hw->html.view),
+					XtWindow(hw->html.view),
+					0, 0,
+					hw->html.view_width,
+					hw->html.view_height, False);
+				ViewRedisplay(hw,
+					0, 0,
+					hw->html.view_width,
+					hw->html.view_height);
+			}
+			else
+			{
+				XCopyArea(XtDisplay(hw->html.view),
+					XtWindow(hw->html.view),
+					XtWindow(hw->html.view),
+					hw->html.drawGC, 0, 0,
+					hw->html.view_width - dx,
+					hw->html.view_height,
+					dx, 0);
+				hw->html.scroll_x = value;
+				XClearArea(XtDisplay(hw->html.view),
+					XtWindow(hw->html.view),
+					0, 0,
+					dx, hw->html.view_height, False);
+				ViewRedisplay(hw,
+					0, 0,
+					dx, hw->html.view_height);
+			}
+		}
+	}
+
+	/*
+	 * Move the now hidden widgets
+	 * Flush any Copyed or Cleared text first.
+	XFlush(XtDisplay(hw));
+	 */
+	ScrollWidgets(hw);
+
+	/*
+	 * Remap the widgets to their new location
+	MapWidgets(hw);
+	 */
+}
+
+
+/*
+ * Either the vertical or hortizontal scrollbar has been moved
+ */
+void
+ScrollMove(w, client_data, call_data)
+	Widget w;
+	caddr_t client_data;
+	caddr_t call_data;
+{
+#ifdef MOTIF
+	XmScrollBarCallbackStruct *sc = (XmScrollBarCallbackStruct *)call_data;
+
+	ScrollToPos(w, (HTMLWidget)client_data, sc->value);
+#else
+	float scrollDir = (int)call_data < 0 ? -0.3 : 0.3;
+	HTMLWidget hw = (HTMLWidget)client_data;
+	int value;
+ 	int totalLength, currentLength; 			/* MF026 */
+
+	if (w == hw->html.vbar)
+	{
+		totalLength = hw->html.doc_height;
+		currentLength = hw->html.view_height;
+		value = hw->html.scroll_y + scrollDir * currentLength;
+	}
+	else 
+	{
+		totalLength = hw->html.doc_width;
+		currentLength = hw->html.view_width;
+		value = hw->html.scroll_x + scrollDir * currentLength;
+	}
+
+	if (value > (int)totalLength) value = totalLength;
+	if (value < 0) value = 0;
+  
+	setScrollBar(w, value, totalLength, currentLength);
+	ScrollToPos(w, hw, value);
+#endif
+}
+
+
+#ifndef MOTIF
+void
+JumpMove(w, client_data, call_data)
+	Widget w;
+	caddr_t client_data;
+	caddr_t call_data;
+{
+	HTMLWidget hw = (HTMLWidget)client_data;
+	int value = (int)(*(float *)call_data * 
+			(w == hw->html.vbar ?  
+			hw->html.doc_height : 
+			hw->html.doc_width));
+	ScrollToPos(w, hw, value);
+}
+#endif
+  
+
+/*
+ * Create the horizontal and vertical scroll bars.
+ * Size them later.
+ */
+static void
+#ifdef _NO_PROTO
+CreateScrollbars (hw)
+            HTMLWidget hw ;
+#else
+CreateScrollbars(
+            HTMLWidget hw)
+#endif
+{
+	Arg arg[20];
+	Cardinal argcnt;
+	XtTranslations trans;
+
+	/*
+	 * If the user hasn't provided a viewing area Widget (which they
+	 * should not most of the time) make a drawing are to use.
+	 */
+	if (hw->html.view == NULL)
+	{
+		argcnt = 0;
+		XtSetArg(arg[argcnt], XxNwidth, 10); argcnt++;
+		XtSetArg(arg[argcnt], XxNheight, 10); argcnt++;
+		hw->html.view = XtCreateWidget("View",
+#ifdef MOTIF		
+			xmDrawingAreaWidgetClass,
+#else
+			drawingAreaWidgetClass, 
+#endif
+			(Widget)hw, arg, argcnt);
+		XtManageChild(hw->html.view);
+	}
+
+	/*
+	 * For the view widget catch all Expose and GraphicsExpose
+	 * events.  Replace its translations with ours, and make
+	 * sure all the actions are in order.
+	 */
+	XtAddEventHandler((Widget)hw->html.view, ExposureMask, True,
+		(XtEventHandler)DrawExpose, (caddr_t)hw);
+	/*
+	 * As described previoisly, for some reason with Motif1.2/X11R5
+	 * the list actionsList is corrupted when we get here,
+	 * so we have to use the special copy SpareActionsList
+	 */
+	XtAppAddActions(XtWidgetToApplicationContext(hw->html.view),
+		SpareActionsList, XtNumber(SpareActionsList));
+	trans = XtParseTranslationTable(defaultTranslations);
+	argcnt = 0;
+	XtSetArg(arg[argcnt], XtNtranslations, trans); argcnt++;
+	XtSetValues(hw->html.view, arg, argcnt);
+
+	/*
+	 * If the user hasn't provided a vertical scrollbar (which they
+	 * should not most of the time) make one.
+	 */
+	if (hw->html.vbar == NULL)
+	{
+		argcnt = 0;
+#ifdef MOTIF
+		XtSetArg(arg[argcnt], XmNorientation, XmVERTICAL); argcnt++;
+		hw->html.vbar = XtCreateWidget("Vbar", xmScrollBarWidgetClass,
+			(Widget)hw, arg, argcnt);
+#else
+		XtSetArg(arg[argcnt],XtNorientation,XtorientVertical); argcnt++;
+		hw->html.vbar = XtCreateWidget("Vbar", scrollbarWidgetClass,
+			(Widget)hw, arg, argcnt);
+#endif
+		XtManageChild(hw->html.vbar);
+	}
+
+	/*
+	 * Add callbacks to catch scrollbar changes
+	 */
+#ifdef MOTIF
+	XtAddCallback(hw->html.vbar, XmNvalueChangedCallback,
+		(XtCallbackProc)ScrollMove, (caddr_t)hw);
+	XtAddCallback(hw->html.vbar, XmNdragCallback,
+		(XtCallbackProc)ScrollMove, (caddr_t)hw);
+#else
+	XtAddCallback(hw->html.vbar, XtNjumpProc,
+		(XtCallbackProc)JumpMove, (caddr_t)hw);
+	XtAddCallback(hw->html.vbar, XtNscrollProc,
+		(XtCallbackProc)ScrollMove, (caddr_t)hw);
+#endif
+
+	/*
+	 * If the user hasn't provided a horizontal scrollbar (which they
+	 * should not most of the time) make one.
+	 */
+	if (hw->html.hbar == NULL)
+	{
+		argcnt = 0;
+#ifdef MOTIF
+		XtSetArg(arg[argcnt], XmNorientation, XmHORIZONTAL); argcnt++;
+		hw->html.hbar = XtCreateWidget("Hbar", xmScrollBarWidgetClass,
+			(Widget)hw, arg, argcnt);
+#else
+		XtSetArg(arg[argcnt], XtNorientation, XtorientHorizontal);
+		argcnt++;
+		hw->html.hbar = XtCreateWidget("Hbar", scrollbarWidgetClass,
+			(Widget)hw, arg, argcnt);
+#endif
+		XtManageChild(hw->html.hbar);
+	}
+
+	/*
+	 * Add callbacks to catch scrollbar changes
+	 */
+#ifdef MOTIF
+	XtAddCallback(hw->html.hbar, XmNvalueChangedCallback,
+		(XtCallbackProc)ScrollMove, (caddr_t)hw);
+	XtAddCallback(hw->html.hbar, XmNdragCallback,
+		(XtCallbackProc)ScrollMove, (caddr_t)hw);
+#else
+	XtAddCallback(hw->html.hbar, XtNjumpProc,
+		(XtCallbackProc)JumpMove, (caddr_t)hw);
+	XtAddCallback(hw->html.hbar, XtNscrollProc,
+		(XtCallbackProc)ScrollMove, (caddr_t)hw);
+#endif
+}
+
+
+/*
+ * Return the width of the vertical scrollbar
+ */
+static Dimension
+#ifdef _NO_PROTO
+VbarWidth (hw)
+            HTMLWidget hw ;
+#else
+VbarWidth(
+            HTMLWidget hw)
+#endif
+{
+	Arg arg[4];
+	Cardinal argcnt;
+	Dimension width;
+
+	width = 0;
+	if (hw->html.vbar != NULL)
+	{
+		argcnt = 0;
+		XtSetArg(arg[argcnt], XxNwidth, &width); argcnt++;
+		XtGetValues(hw->html.vbar, arg, argcnt);
+	}
+
+	return(width);
+}
+
+
+/*
+ * Return the height of the horizontal scrollbar
+ */
+static Dimension
+#ifdef _NO_PROTO
+HbarHeight (hw)
+            HTMLWidget hw ;
+#else
+HbarHeight(
+            HTMLWidget hw)
+#endif
+{
+	Arg arg[4];
+	Cardinal argcnt;
+	Dimension height;
+
+	height = 0;
+	if (hw->html.hbar != NULL)
+	{
+		argcnt = 0;
+		XtSetArg(arg[argcnt], XxNheight, &height); argcnt++;
+		XtGetValues(hw->html.hbar, arg, argcnt);
+	}
+
+	return(height);
+}
+
+
+/*
+ * Resize and set the min and max values of the scrollbars.  Position viewing
+ * area based on scrollbar locations.
+ */
+static void
+#ifdef _NO_PROTO
+ConfigScrollBars (hw)
+            HTMLWidget hw ;
+#else
+ConfigScrollBars(
+            HTMLWidget hw)
+#endif
+{
+#ifdef MOTIF
+	Arg arg[20];
+	Cardinal argcnt;
+#endif
+	int vx, vy;
+
+	/*
+	 * Move and size the viewing area
+	 */
+#ifdef MOTIF
+	vx = hw->manager.shadow_thickness;
+	vy = hw->manager.shadow_thickness;
+#else
+	vx = vy = 0;
+#endif
+	if ((hw->html.use_vbar == True)&&(hw->html.vbar_right == False))
+	{
+		vx += VbarWidth(hw);
+	}
+	if ((hw->html.use_hbar == True)&&(hw->html.hbar_top == True))
+	{
+		vy += HbarHeight(hw);
+	}
+	XtMoveWidget(hw->html.view, vx, vy);
+	XtResizeWidget(hw->html.view, hw->html.view_width, hw->html.view_height,
+		hw->html.view->core.border_width);
+
+	/*
+	 * Set up vertical scrollbar
+	 */
+	if (hw->html.use_vbar == True)
+	{
+		int maxv;
+		int ss;
+
+		/*
+		 * Size the vertical scrollbar to the height of
+		 * the viewing area
+		 */
+		XtResizeWidget(hw->html.vbar, hw->html.vbar->core.width,
+		    hw->html.view_height + (2 * 
+#ifdef MOTIF
+					    hw->manager.shadow_thickness
+#else
+					    0
+#endif
+					    ),
+		    hw->html.vbar->core.border_width);
+
+		/*
+		 * Set the slider size to be the percentage of the
+		 * viewing area that the viewing area is of the
+		 * document area.  Or set it to 1 if that isn't possible.
+		 */
+		if (hw->html.doc_height == 0)
+		{
+			ss = 1;
+		}
+		else
+		{
+#ifdef DEBUG
+fprintf (stderr, "view_height %d, doc_height %d\n", 
+hw->html.view_height, hw->html.doc_height);
+#endif
+#ifdef NOT_RIGHT
+                        /* Eric -- your previous equation wasn't doing it.
+                           This isn't either... */
+			ss = 
+                          (int)((float)hw->html.view_height *
+                                ((float)hw->html.view_height / 
+                                 (float)(hw->html.doc_height - (int)hw->html.view_height)));
+			if (ss > hw->html.view_height)
+			{
+				ss = hw->html.view_height;
+			}
+#endif
+                        /* Added by marca: this produces results *very* close (~1 pixel)
+                           to the original scrolled window behavior. */
+                        ss = hw->html.view_height;
+		}
+		if (ss < 1)
+		{
+			ss = 1;
+		}
+#ifdef DEBUG
+fprintf (stderr, "computed ss to be %d\n", ss);
+#endif
+
+		/*
+		 * If resizing of the document has made scroll_y
+		 * greater than the max, we want to hold it at the max.
+		 */
+		maxv = hw->html.doc_height - (int)hw->html.view_height;
+		if (maxv < 0)
+		{
+			maxv = 0;
+		}
+		if (hw->html.scroll_y > maxv)
+		{
+			hw->html.scroll_y = maxv;
+		}
+
+		/*
+		 * Prevent the Motif max value and slider size
+		 * from going to zero, which is illegal
+		 */
+		maxv = maxv + ss;
+		if (maxv < 1)
+		{
+			maxv = 1;
+		}
+
+		/*
+		 * Motif will not allow the actual value to be equal to
+		 * its max value.  Adjust accordingly.
+		 * Since we might decrease scroll_y, cap it at zero.
+		 */
+		if (hw->html.scroll_y >= maxv)
+		{
+			hw->html.scroll_y = maxv - 1;
+		}
+		if (hw->html.scroll_y < 0)
+		{
+			hw->html.scroll_y = 0;
+		}
+
+#ifdef MOTIF
+		argcnt = 0;
+		XtSetArg(arg[argcnt], XmNminimum, 0); argcnt++;
+		XtSetArg(arg[argcnt], XmNmaximum, maxv); argcnt++;
+		XtSetArg(arg[argcnt], XmNvalue, hw->html.scroll_y); argcnt++;
+		XtSetArg(arg[argcnt], XmNsliderSize, ss); argcnt++;
+                XtSetArg(arg[argcnt], XmNincrement, DEFAULT_INCREMENT); argcnt++;
+                XtSetArg(arg[argcnt], XmNpageIncrement, 
+                         hw->html.view_height > DEFAULT_INCREMENT ? 
+                           hw->html.view_height - DEFAULT_INCREMENT : 1); argcnt++;
+		XtSetValues(hw->html.vbar, arg, argcnt);
+#else
+		setScrollBar(hw->html.vbar, 
+			     hw->html.scroll_y,
+			     hw->html.doc_height, 
+			     (int)hw->html.view_height);
+#endif /* MOTIF */
+
+#ifdef DEBUG
+XtVaGetValues(hw->html.vbar, XmNsliderSize, &ss, NULL);
+fprintf (stderr, "real slider size %d\n", ss);
+#endif
+	}
+
+	/*
+	 * Set up horizontal scrollbar
+	 */
+	if (hw->html.use_hbar == True)
+	{
+		int maxv;
+		int ss;
+
+		/*
+		 * Size the horizontal scrollbar to the width of
+		 * the viewing area
+		 */
+		XtResizeWidget(hw->html.hbar,
+		    hw->html.view_width + (2 *
+#ifdef MOTIF
+					   hw->manager.shadow_thickness
+#else
+					   0
+#endif /* MOTIF */
+					   ),
+		    hw->html.hbar->core.height,
+		    hw->html.hbar->core.border_width);
+
+		/*
+		 * Set the slider size to be the percentage of the
+		 * viewing area that the viewing area is of the
+		 * document area.  Or set it to 1 if that isn't possible.
+		 */
+		if (hw->html.doc_width == 0)
+		{
+			ss = 1;
+		}
+		else
+		{
+#ifdef NOT_RIGHT
+			ss = hw->html.view_width *
+				hw->html.view_width / hw->html.doc_width;
+			if (ss > hw->html.view_width)
+			{
+				ss = hw->html.view_width;
+			}
+#endif
+                        /* Added by marca: this produces results *very* close (~1 pixel)
+                           to the original scrolled window behavior. */
+                        ss = hw->html.view_width;
+		}
+		if (ss < 1)
+		{
+			ss = 1;
+		}
+
+		/*
+		 * If resizing of the document has made scroll_x
+		 * greater than the max, we want to hold it at the max.
+		 */
+		maxv = hw->html.doc_width - (int)hw->html.view_width;
+		if (maxv < 0)
+		{
+			maxv = 0;
+		}
+		if (hw->html.scroll_x > maxv)
+		{
+			hw->html.scroll_x = maxv;
+		}
+
+		/*
+		 * Prevent the Motif max value and slider size
+		 * from going to zero, which is illegal
+		 */
+		maxv = maxv + ss;
+		if (maxv < 1)
+		{
+			maxv = 1;
+		}
+
+		/*
+		 * Motif will not allow the actual value to be equal to
+		 * its max value.  Adjust accordingly.
+		 * Since we might decrease scroll_x, cap it at zero.
+		 */
+		if (hw->html.scroll_x >= maxv)
+		{
+			hw->html.scroll_x = maxv - 1;
+		}
+		if (hw->html.scroll_x < 0)
+		{
+			hw->html.scroll_x = 0;
+		}
+
+#ifdef MOTIF
+		argcnt = 0;
+		XtSetArg(arg[argcnt], XmNminimum, 0); argcnt++;
+		XtSetArg(arg[argcnt], XmNmaximum, maxv); argcnt++;
+		XtSetArg(arg[argcnt], XmNvalue, hw->html.scroll_x); argcnt++;
+		XtSetArg(arg[argcnt], XmNsliderSize, ss); argcnt++;
+                XtSetArg(arg[argcnt], XmNincrement, DEFAULT_INCREMENT); argcnt++;
+                XtSetArg(arg[argcnt], XmNpageIncrement, 
+                         hw->html.view_width > DEFAULT_INCREMENT ? 
+                         hw->html.view_width - DEFAULT_INCREMENT : 1); argcnt++;
+		XtSetValues(hw->html.hbar, arg, argcnt);
+#else
+		setScrollBar(hw->html.hbar, 	
+			     hw->html.scroll_x,
+			     hw->html.doc_width, 
+			     (int)hw->html.view_width);
+#endif /* MOTIF */
+	}
+
+#ifdef DEBUG
+        {
+          int ss;
+XtVaGetValues(hw->html.vbar, XmNsliderSize, &ss, NULL);
+fprintf (stderr, "real slider size %d\n", ss);
+        }
+#endif
+}
+
+
+/*
+ * Reformat the window and scrollbars.
+ * May be called because of a changed document, or because of a changed
+ * window size.
+ */
+static void
+#ifdef _NO_PROTO
+ReformatWindow (hw)
+            HTMLWidget hw ;
+#else
+ReformatWindow(
+            HTMLWidget hw)
+#endif
+{
+	int temp;
+	int new_width;
+	Dimension swidth, sheight;
+	Dimension st;
+
+	/*
+	 * Find the current scrollbar sizes, and shadow thickness and format
+	 * the document to the current window width
+	 * (assume a vertical scrollbar)
+	 */
+	swidth = VbarWidth(hw);
+	sheight = HbarHeight(hw);
+#ifdef MOTIF
+	st = hw->manager.shadow_thickness;
+#else
+	st = 0;
+#endif /* MOTIF */
+	if (hw->core.width <= swidth)
+	{
+		hw->core.width = swidth + 10;
+	} 
+	new_width = hw->core.width - swidth - (2 * st);
+	temp = FormatAll(hw, &new_width);
+
+	/*
+	 * If we need the vertical scrollbar, place and manage it,
+	 * and store the current viewing area width.
+	 */
+	if (temp > hw->core.height - sheight)
+	{
+		hw->html.use_vbar = True;
+		if (hw->html.vbar_right == True)
+		{
+			XtMoveWidget(hw->html.vbar,
+				(hw->core.width - swidth), 0);
+		}
+		else
+		{
+			XtMoveWidget(hw->html.vbar, 0, 0);
+		}
+		XtManageChild(hw->html.vbar);
+		hw->html.view_width = hw->core.width - swidth - (2 * st);
+	}
+	/*
+	 * Else we were wrong to assume a vertical scrollbar.
+	 * Remove it, and reformat the document to the wider width.
+	 * Save the as the current viewing are width.
+	 */
+	else
+	{
+		hw->html.use_vbar = False;
+		XtUnmanageChild(hw->html.vbar);
+		hw->html.scroll_y = 0;
+		new_width = hw->core.width - (2 * st);
+		temp = FormatAll(hw, &new_width);
+		hw->html.view_width = hw->core.width - (2 * st);
+		/* fake out later horizontal scrollbars */
+		swidth = 0;
+	}
+
+	/*
+	 * Calculate the actual max width and height of the complete
+	 * formatted document.
+	 * The max width may exceed the preformatted width due to special
+	 * factors in the formatting of the widget.
+	 * Use the max of the 2 here, but leave max_pre_width unchanged
+	 * for future formatting calls.
+	 */
+	/*
+	 * new_width includes the margins, and hw->html.max_pre_width
+	 * does not, fix that here.
+	 */
+	new_width = new_width - (2 * hw->html.margin_width);
+	if (hw->html.max_pre_width > new_width)
+	{
+		new_width = hw->html.max_pre_width;
+	}
+	/*
+	 * If the maximum width derives from a formatted, as opposed to
+	 * unformatted piece of text, allow a 20% of margin width slop
+	 * over into the margin to cover up a minor glick with terminaing
+	 * punctuation after anchors at the end of the line.
+	 */
+	else
+	{
+		new_width = new_width - (20 * hw->html.margin_width / 100);
+	}
+
+	hw->html.doc_height = temp;
+	hw->html.doc_width = new_width + (2 * hw->html.margin_width);
+	if (hw->html.view_width > hw->html.doc_width)
+	{
+		hw->html.doc_width = hw->html.view_width;
+	}
+
+	/*
+	 * If we need a horizontal scrollbar
+	 * Place it and manage it.  Save the height of the current
+	 * viewing area.
+	 */
+	if (hw->html.doc_width > hw->html.view_width)
+	{
+		hw->html.use_hbar = True;
+		if (hw->html.hbar_top == True)
+		{
+			if (hw->html.use_vbar == True)
+			{
+				XtMoveWidget(hw->html.vbar,
+					hw->html.vbar->core.x, sheight);
+			}
+
+			if (hw->html.vbar_right == True)
+			{
+				XtMoveWidget(hw->html.hbar, 0, 0);
+			}
+			else
+			{
+				XtMoveWidget(hw->html.hbar, swidth, 0);
+			}
+		}
+		else
+		{
+			if (hw->html.vbar_right == True)
+			{
+				XtMoveWidget(hw->html.hbar, 0,
+					(hw->core.height - sheight));
+			}
+			else
+			{
+				XtMoveWidget(hw->html.hbar, swidth,
+					(hw->core.height - sheight));
+			}
+		}
+		XtManageChild(hw->html.hbar);
+		hw->html.view_height = hw->core.height - sheight - (2 * st);
+	}
+	/*
+	 * Else we don't need a horizontal scrollbar.
+	 * Remove it and save the current viewing area height.
+	 */
+	else
+	{
+		hw->html.use_hbar = False;
+		XtUnmanageChild(hw->html.hbar);
+		hw->html.scroll_x = 0;
+		hw->html.view_height = hw->core.height - (2 * st);
+	}
+
+	/*
+	 * Configure the scrollbar min, max, and slider sizes
+	 */
+#ifdef DEBUG
+fprintf (stderr, "calling in ReformatWindow\n");
+#endif
+	ConfigScrollBars(hw);
+}
+
+
+/*
+ * We're a happy widget.  We let any child move or resize themselves
+ * however they want, we don't care.
+ */
+static XtGeometryResult
+#ifdef _NO_PROTO
+GeometryManager (w, request, reply)
+	Widget w;
+	XtWidgetGeometry * request;
+	XtWidgetGeometry * reply;
+#else
+GeometryManager (
+	Widget w,
+	XtWidgetGeometry * request,
+	XtWidgetGeometry * reply)
+#endif
+{
+	reply->x = request->x;
+	reply->y = request->y;
+	reply->width = request->width;
+	reply->height = request->height;
+	reply->border_width = request->border_width;
+	reply->request_mode = request->request_mode;
+	return (XtGeometryYes);
+}
+
+
+/*
+ * Initialize is called when the widget is first initialized.
+ * Check to see that all the starting resources are valid.
+ */
+static void
+#ifdef _NO_PROTO
+Initialize (request, new)
+            HTMLWidget request ;
+            HTMLWidget new ;
+#else
+Initialize(
+            HTMLWidget request,
+            HTMLWidget new)
+#endif
+{
+	/*
+	 *	Make sure height and width are not zero.
+	 */
+	if (new->core.width == 0)
+	{
+		new->core.width = new->html.margin_width << 1 ;
+	} 
+	if (new->core.width == 0)
+	{
+		new->core.width = 10 ;
+	} 
+	if (new->core.height == 0)
+	{
+		new->core.height = new->html.margin_height << 1 ;
+	} 
+	if (new->core.height == 0)
+	{
+		new->core.height = 10 ;
+	} 
+
+	/*
+	 *	Make sure the underline numbers are within bounds.
+	 */
+	if (new->html.num_anchor_underlines < 0)
+	{
+		new->html.num_anchor_underlines = 0;
+	} 
+	if (new->html.num_anchor_underlines > MAX_UNDERLINES)
+	{
+		new->html.num_anchor_underlines = MAX_UNDERLINES;
+	} 
+	if (new->html.num_visitedAnchor_underlines < 0)
+	{
+		new->html.num_visitedAnchor_underlines = 0;
+	} 
+	if (new->html.num_visitedAnchor_underlines > MAX_UNDERLINES)
+	{
+		new->html.num_visitedAnchor_underlines = MAX_UNDERLINES;
+	} 
+
+	/*
+	 * Parse the raw text with the HTML parser.  And set the formatted 
+	 * element list to NULL.
+	 */
+	new->html.html_objects = HTMLParse(NULL, request->html.raw_text);
+	CallLinkCallbacks(new);
+	new->html.html_header_objects =
+		HTMLParse(NULL, request->html.header_text);
+	new->html.html_footer_objects =
+		HTMLParse(NULL, request->html.footer_text);
+	new->html.formatted_elements = NULL;
+	new->html.my_visited_hrefs = NULL;
+	new->html.my_delayed_images = NULL;
+	new->html.widget_list = NULL;
+	new->html.form_list = NULL;
+
+	/*
+	 * Blank document
+	 */
+	new->html.line_array = NULL;
+	new->html.line_count = 0;
+
+	/*
+	 * Find the max width of a preformatted
+	 * line in this document.
+	 */
+	new->html.max_pre_width = DocumentWidth(new, new->html.html_objects);
+
+	/*
+	 * Create the scrollbars.
+	 * Find their dimensions and then decide which scrollbars you
+	 * will need, and what the dimensions of the viewing area are.
+	 * Start assuming a vertical scrollbar and a horizontal one.
+	 * The remove vertical if short enough, and remove horizontal
+	 * if narrow enough.
+	 */
+	CreateScrollbars(new);
+	new->html.scroll_x = 0;
+	new->html.scroll_y = 0;
+	ReformatWindow(new);
+
+	/*
+	 * Initialize private widget resources
+	 */
+	new->html.drawGC = NULL;
+	new->html.select_start = NULL;
+	new->html.select_end = NULL;
+	new->html.sel_start_pos = 0;
+	new->html.sel_end_pos = 0;
+	new->html.new_start = NULL;
+	new->html.new_end = NULL;
+	new->html.new_start_pos = 0;
+	new->html.new_end_pos = 0;
+	new->html.active_anchor = NULL;
+	new->html.press_x = 0;
+	new->html.press_y = 0;
+
+        new->html.cached_tracked_ele = NULL;
+
+        /* Initialize cursor used when pointer is inside anchor.
+        if (in_anchor_cursor == (Cursor)NULL) */
+          in_anchor_cursor = XCreateFontCursor (XtDisplay (new), XC_hand2);
+
+        return;
+}
+
+/*
+ * Realize is called when the widget is realized to create its window.
+ * We call the Realize method of our superclass and then create the drawGC
+ * to be used by the HTML widget.  (This was added at NOAO, the NCSA
+ * version does not use a custom Realize method, and the drawGC is not
+ * created until the first Expose event occurs.  This causes the widget to
+ * crash if a drawing routine is called before the application becomes idle
+ * and processes the queued input from the display server.)
+ */
+static void
+#ifdef _NO_PROTO
+Realize (hw, valueMask, attributes)
+            HTMLWidget hw ;
+            Mask *valueMask ;
+	    XSetWindowAttributes *attributes ;
+#else
+Realize (
+            HTMLWidget hw ,
+            Mask *valueMask ,
+	    XSetWindowAttributes *attributes )
+#endif
+{
+	unsigned long valuemask;
+	XGCValues values;
+
+	/* Call the Realize method of the superclass to create the window. */
+	(*htmlWidgetClass->core_class.superclass->core_class.realize)
+	    ((Widget)hw, valueMask, attributes);
+
+	/* Create the drawGC for the HTML window (copied from Expose). */
+	values.function = GXcopy;
+	values.plane_mask = AllPlanes;
+/*
+ * Without motif we use our own foreground resource instead of
+ * using the manager's
+ */
+#ifdef MOTIF
+	values.foreground = hw->manager.foreground;
+#else
+	values.foreground = hw->html.foreground;
+#endif /* MOTIF */
+	values.background = hw->core.background_pixel;
+
+	valuemask = GCFunction|GCPlaneMask|GCForeground|GCBackground;
+
+	hw->html.drawGC = XCreateGC(XtDisplay(hw), XtWindow(hw),
+		valuemask, &values);
+}
+
+
+#ifdef DEBUG
+void
+DebugHook(x, y, width, height)
+	int x, y, width, height;
+{
+fprintf(stderr, "Redrawing (%d,%d) %dx%d\n", x, y, width, height);
+}
+#endif
+
+
+/*
+ * This is called by redisplay.  It is passed a rectangle
+ * in the viewing area, and it redisplays that portion of the
+ * underlying document area.
+ */
+static void
+#ifdef _NO_PROTO
+ViewRedisplay (hw, x, y, width, height)
+            HTMLWidget hw;
+	    int x, y;
+	    int width, height;
+#else
+ViewRedisplay(
+            HTMLWidget hw,
+            int x,
+            int y,
+            int width,
+            int height)
+#endif
+{
+	int sx, sy;
+	int doc_x, doc_y;
+	int i, start, end, guess;
+
+	/*
+	 * Use scrollbar values to map from view space to document space.
+	 */
+	sx = sy = 0;
+	if (hw->html.use_vbar == True)
+	{
+		sy += hw->html.scroll_y;
+	}
+	if (hw->html.use_hbar == True)
+	{
+		sx += hw->html.scroll_x;
+	}
+
+	doc_x = x + sx;
+	doc_y = y + sy;
+
+	/*
+	 * Find the lines that overlap the exposed area.
+	 */
+	start = 0;
+	end = hw->html.line_count - 1;
+
+	/*
+	 * Heuristic to speed up redraws by guessing at the starting line.
+	 */
+	guess = doc_y / (hw->html.font->max_bounds.ascent +
+		hw->html.font->max_bounds.descent);
+	if (guess > end)
+	{
+		guess = end;
+	}
+	while (guess > 0)
+	{
+		if ((hw->html.line_array[guess] != NULL)&&
+			(hw->html.line_array[guess]->y < doc_y))
+		{
+			break;
+		}
+		guess--;
+	}
+	if (guess < start)
+	{
+		guess = start;
+	}
+
+	for (i=guess; i<hw->html.line_count; i++)
+	{
+		if (hw->html.line_array[i] == NULL)
+		{
+			continue;
+		}
+
+		if (hw->html.line_array[i]->y < doc_y)
+		{
+			start = i;
+		}
+		if (hw->html.line_array[i]->y > (doc_y + height))
+		{
+			end = i;
+			break;
+		}
+	}
+
+	/*
+	 * If we have a GC draw the lines that overlap the exposed area.
+	 */
+	if (hw->html.drawGC != NULL)
+	{
+		for (i=start; i<=end; i++)
+		{
+			PlaceLine(hw, i);
+		}
+#ifdef EXTRA_FLUSH
+		XFlush(XtDisplay(hw));
+#endif
+	}
+}
+
+
+static void
+#ifdef _NO_PROTO
+ViewClearAndRefresh (hw)
+            HTMLWidget hw;
+#else
+ViewClearAndRefresh(
+            HTMLWidget hw)
+#endif
+{
+	/*
+	 * Only refresh if we have a window already.
+	 * (if we have a GC we have a window)
+	 */
+	if (hw->html.drawGC != NULL)
+	{
+		XClearArea(XtDisplay(hw->html.view), XtWindow(hw->html.view),
+			0, 0, 0, 0, False);
+		ViewRedisplay(hw, 0, 0,
+			hw->html.view_width, hw->html.view_height);
+		/*
+		 * This is a fake deal to make an Expose event tocall Redisplay
+		 * to redraw the shadow around the view area
+		 */
+		XClearArea(XtDisplay(hw), XtWindow(hw),
+			0, 0, 1, 1, True);
+	}
+}
+
+
+/*
+ * The Redisplay function is what you do with an expose event.
+ * Right now we call user callbacks, and then call the CompositeWidget's
+ * Redisplay routine.
+ */
+static void
+#ifdef _NO_PROTO
+Redisplay (hw, event, region)
+            HTMLWidget hw;
+            XEvent * event;
+            Region region;
+#else
+Redisplay(
+            HTMLWidget hw,
+            XEvent * event,
+            Region region)
+#endif
+{
+	XExposeEvent *ExEvent = (XExposeEvent *)event;
+	int dx, dy;
+
+#ifdef MOTIF
+	/*
+	 * find out where the shadow is based on scrollbars
+	 */
+
+	Dimension st = hw->manager.shadow_thickness;
+#endif /* MOTIF */
+
+	dx = dy = 0;
+	if ((hw->html.use_vbar == True)&&(hw->html.vbar_right == False))
+	{
+		dx += VbarWidth(hw);
+	}
+	if ((hw->html.use_hbar == True)&&(hw->html.hbar_top == True))
+	{
+		dy += HbarHeight(hw);
+	}
+
+#ifdef MOTIF
+	/*
+	 * Redraw the shadow around the scrolling area which may have been
+	 * messed up.
+	 */
+	_XmDrawShadow(XtDisplay(hw), XtWindow(hw),
+		hw->manager.bottom_shadow_GC, hw->manager.top_shadow_GC,
+		hw->manager.shadow_thickness, dx, dy,
+		hw->html.view_width + (2 * st),hw->html.view_height + (2 * st));
+#endif /* MOTIF */
+
+#ifdef MOTIF
+#ifdef MOTIF1_2
+	_XmRedisplayGadgets ((Widget)hw, (XEvent*)event, region);
+#else
+	_XmRedisplayGadgets ((CompositeWidget)hw, (XExposeEvent*)event, region);
+#endif /* MOTIF1_2 */
+#endif /* MOTIF */
+
+	return;
+}
+
+
+/*
+ * Resize is called when the widget changes size.
+ * Mostly any resize causes a reformat, except for the special case
+ * where the width doesn't change, and the height doesn't change
+ * enought to affect the vertical scrollbar.
+ * It is too complex to guess exactly what needs to be redrawn, so refresh the
+ * whole window on any resize.
+ */
+static void
+#ifdef _NO_PROTO
+Resize (hw)
+            HTMLWidget hw;
+#else
+Resize(
+            HTMLWidget hw)
+#endif
+{
+	int tempw;
+	Dimension swidth, sheight;
+	Dimension st;
+
+	/*
+	 * Find the new widht of the viewing area.
+	 */
+	swidth = VbarWidth(hw);
+	sheight = HbarHeight(hw);
+#ifdef MOTIF
+	st = hw->manager.shadow_thickness;
+#else
+	st = 0;
+#endif /* MOTIF */
+	if (hw->core.width <= swidth)
+	{
+		hw->core.width = swidth + 10 ;
+	} 
+
+	if (hw->html.use_vbar == True)
+	{
+		tempw = hw->core.width - swidth - (2 * st);
+	}
+	else
+	{
+		tempw = hw->core.width - (2 * st);
+		/* fool positioning of horz scrollbar later */
+		swidth = 0;
+	}
+
+	/*
+	 * Special case where we don't have to reformat to a new width.
+	 * The width has not changed, and the height has not changed
+	 * significantly to change the state of the vertical scrollbar.
+	 */
+	if ((tempw == hw->html.view_width)&&
+	    (((hw->html.use_vbar == True)&&
+	      ((hw->core.height - sheight - (2 * st)) < hw->html.doc_height))||
+	     ((hw->html.use_vbar == False)&&
+	      ((hw->core.height - sheight - (2 * st)) >= hw->html.doc_height))))
+	{
+		/*
+		 * Super special case where the size of the window hasn't
+		 * changed at ALL!
+		 */
+		if (((hw->html.use_hbar == True)&&(hw->html.view_height ==
+			(hw->core.height - sheight - (2 * st))))||
+			((hw->html.use_hbar == False)&&(hw->html.view_height ==
+			(hw->core.height - (2 * st)))))
+		{
+			return;
+		}
+
+		if (hw->html.use_hbar == True)
+		{
+			if (hw->html.hbar_top == True)
+			{
+				if (hw->html.vbar_right == True)
+				{
+					XtMoveWidget(hw->html.hbar, 0, 0);
+				}
+				else
+				{
+					XtMoveWidget(hw->html.hbar, swidth, 0);
+				}
+			}
+			else
+			{
+				if (hw->html.vbar_right == True)
+				{
+					XtMoveWidget(hw->html.hbar, 0,
+						(hw->core.height - sheight));
+				}
+				else
+				{
+					XtMoveWidget(hw->html.hbar, swidth,
+						(hw->core.height - sheight));
+				}
+			}
+			hw->html.view_height = hw->core.height - sheight -
+				(2 * st);
+		}
+		else
+		{
+			hw->html.view_height = hw->core.height - (2 * st);
+		}
+#ifdef DEBUG
+fprintf (stderr, "calling in Resize\n");
+#endif
+		ConfigScrollBars(hw);
+		ScrollWidgets(hw);
+		ViewClearAndRefresh(hw);
+	}
+	/*
+	 * Otherwise we have to do a full reformat on every resize.
+	 */
+	else
+	{
+		ReformatWindow(hw);
+		ScrollWidgets(hw);
+		ViewClearAndRefresh(hw);
+	}
+
+#ifdef DEBUG
+        {
+          int ss;
+XtVaGetValues(hw->html.vbar, XmNsliderSize, &ss, NULL);
+fprintf (stderr, "leaving; slider size %d\n", ss);
+        }
+#endif
+
+	return;
+}
+
+
+/*
+ * Find the complete text for this the anchor that aptr is a part of
+ * and set it into the selection.
+ */
+static void
+FindSelectAnchor(hw, aptr)
+	HTMLWidget hw;
+	struct ele_rec *aptr;
+{
+	struct ele_rec *eptr;
+
+	eptr = aptr;
+	while ((eptr->prev != NULL)&&
+		(eptr->prev->anchorHRef != NULL)&&
+		(strcmp(eptr->prev->anchorHRef, eptr->anchorHRef) == 0))
+	{
+		eptr = eptr->prev;
+	}
+	hw->html.select_start = eptr;
+	hw->html.sel_start_pos = 0;
+
+	eptr = aptr;
+	while ((eptr->next != NULL)&&
+		(eptr->next->anchorHRef != NULL)&&
+		(strcmp(eptr->next->anchorHRef, eptr->anchorHRef) == 0))
+	{
+		eptr = eptr->next;
+	}
+	hw->html.select_end = eptr;
+	hw->html.sel_end_pos = eptr->edata_len - 2;
+}
+
+
+/*
+ * Set as active all elements in the widget that are part of the anchor
+ * in the widget's start ptr.
+ */
+static void
+SetAnchor(hw)
+	HTMLWidget hw;
+{
+	struct ele_rec *eptr;
+	struct ele_rec *start;
+	struct ele_rec *end;
+	unsigned long fg, bg;
+	unsigned long old_fg, old_bg;
+
+	eptr = hw->html.active_anchor;
+	if ((eptr == NULL)||(eptr->anchorHRef == NULL))
+	{
+		return;
+	}
+	fg = hw->html.activeAnchor_fg;
+	bg = hw->html.activeAnchor_bg;
+
+	FindSelectAnchor(hw, eptr);
+
+	start = hw->html.select_start;
+	end = hw->html.select_end;
+
+	eptr = start;
+	while ((eptr != NULL)&&(eptr != end))
+	{
+		if (eptr->type == E_TEXT)
+		{
+			old_fg = eptr->fg;
+			old_bg = eptr->bg;
+			eptr->fg = fg;
+			eptr->bg = bg;
+			TextRefresh(hw, eptr,
+				0, (eptr->edata_len - 2));
+			eptr->fg = old_fg;
+			eptr->bg = old_bg;
+		}
+		else if (eptr->type == E_IMAGE)
+		{
+			old_fg = eptr->fg;
+			old_bg = eptr->bg;
+			eptr->fg = fg;
+			eptr->bg = bg;
+			ImageRefresh(hw, eptr);
+			eptr->fg = old_fg;
+			eptr->bg = old_bg;
+		}
+	/*
+	 * Linefeeds in anchor spanning multiple lines should NOT
+	 * be highlighted!
+		else if (eptr->type == E_LINEFEED)
+		{
+			old_fg = eptr->fg;
+			old_bg = eptr->bg;
+			eptr->fg = fg;
+			eptr->bg = bg;
+			LinefeedRefresh(hw, eptr);
+			eptr->fg = old_fg;
+			eptr->bg = old_bg;
+		}
+	*/
+		eptr = eptr->next;
+	}
+	if (eptr != NULL)
+	{
+		if (eptr->type == E_TEXT)
+		{
+			old_fg = eptr->fg;
+			old_bg = eptr->bg;
+			eptr->fg = fg;
+			eptr->bg = bg;
+			TextRefresh(hw, eptr,
+				0, (eptr->edata_len - 2));
+			eptr->fg = old_fg;
+			eptr->bg = old_bg;
+		}
+		else if (eptr->type == E_IMAGE)
+		{
+			old_fg = eptr->fg;
+			old_bg = eptr->bg;
+			eptr->fg = fg;
+			eptr->bg = bg;
+			ImageRefresh(hw, eptr);
+			eptr->fg = old_fg;
+			eptr->bg = old_bg;
+		}
+	/*
+	 * Linefeeds in anchor spanning multiple lines should NOT
+	 * be highlighted!
+		else if (eptr->type == E_LINEFEED)
+		{
+			old_fg = eptr->fg;
+			old_bg = eptr->bg;
+			eptr->fg = fg;
+			eptr->bg = bg;
+			LinefeedRefresh(hw, eptr);
+			eptr->fg = old_fg;
+			eptr->bg = old_bg;
+		}
+	*/
+	}
+}
+
+
+/*
+ * Draw selection for all elements in the widget
+ * from start to end.
+ */
+static void
+DrawSelection(hw, start, end, start_pos, end_pos)
+	HTMLWidget hw;
+	struct ele_rec *start;
+	struct ele_rec *end;
+	int start_pos, end_pos;
+{
+	struct ele_rec *eptr;
+	int epos;
+
+	if ((start == NULL)||(end == NULL))
+	{
+		return;
+	}
+
+	/*
+	 * Keep positions within bounds (allows us to be sloppy elsewhere)
+	 */
+	if (start_pos < 0)
+	{
+		start_pos = 0;
+	}
+	if (start_pos >= start->edata_len - 1)
+	{
+		start_pos = start->edata_len - 2;
+	}
+	if (end_pos < 0)
+	{
+		end_pos = 0;
+	}
+	if (end_pos >= end->edata_len - 1)
+	{
+		end_pos = end->edata_len - 2;
+	}
+
+	if (SwapElements(start, end, start_pos, end_pos))
+	{
+		eptr = start;
+		start = end;
+		end = eptr;
+		epos = start_pos;
+		start_pos = end_pos;
+		end_pos = epos;
+	}
+
+	eptr = start;
+	while ((eptr != NULL)&&(eptr != end))
+	{
+		int p1, p2;
+
+		if (eptr == start)
+		{
+			p1 = start_pos;
+		}
+		else
+		{
+			p1 = 0;
+		}
+		p2 = eptr->edata_len - 2;
+
+		if (eptr->type == E_TEXT)
+		{
+			eptr->selected = True;
+			eptr->start_pos = p1;
+			eptr->end_pos = p2;
+			TextRefresh(hw, eptr, p1, p2);
+		}
+		else if (eptr->type == E_LINEFEED)
+		{
+			eptr->selected = True;
+			LinefeedRefresh(hw, eptr);
+		}
+		eptr = eptr->next;
+	}
+	if (eptr != NULL)
+	{
+		int p1, p2;
+
+		if (eptr == start)
+		{
+			p1 = start_pos;
+		}
+		else
+		{
+			p1 = 0;
+		}
+
+		if (eptr == end)
+		{
+			p2 = end_pos;
+		}
+		else
+		{
+			p2 = eptr->edata_len - 2;
+		}
+
+		if (eptr->type == E_TEXT)
+		{
+			eptr->selected = True;
+			eptr->start_pos = p1;
+			eptr->end_pos = p2;
+			TextRefresh(hw, eptr, p1, p2);
+		}
+		else if (eptr->type == E_LINEFEED)
+		{
+			eptr->selected = True;
+			LinefeedRefresh(hw, eptr);
+		}
+	}
+}
+
+
+/*
+ * Set selection for all elements in the widget's
+ * start to end list.
+ */
+static void
+SetSelection(hw)
+	HTMLWidget hw;
+{
+	struct ele_rec *start;
+	struct ele_rec *end;
+	int start_pos, end_pos;
+
+	start = hw->html.select_start;
+	end = hw->html.select_end;
+	start_pos = hw->html.sel_start_pos;
+	end_pos = hw->html.sel_end_pos;
+	DrawSelection(hw, start, end, start_pos, end_pos);
+}
+
+
+/*
+ * Erase the selection from start to end
+ */
+static void
+EraseSelection(hw, start, end, start_pos, end_pos)
+	HTMLWidget hw;
+	struct ele_rec *start;
+	struct ele_rec *end;
+	int start_pos, end_pos;
+{
+	struct ele_rec *eptr;
+	int epos;
+
+	if ((start == NULL)||(end == NULL))
+	{
+		return;
+	}
+
+	/*
+	 * Keep positoins within bounds (allows us to be sloppy elsewhere)
+	 */
+	if (start_pos < 0)
+	{
+		start_pos = 0;
+	}
+	if (start_pos >= start->edata_len - 1)
+	{
+		start_pos = start->edata_len - 2;
+	}
+	if (end_pos < 0)
+	{
+		end_pos = 0;
+	}
+	if (end_pos >= end->edata_len - 1)
+	{
+		end_pos = end->edata_len - 2;
+	}
+
+	if (SwapElements(start, end, start_pos, end_pos))
+	{
+		eptr = start;
+		start = end;
+		end = eptr;
+		epos = start_pos;
+		start_pos = end_pos;
+		end_pos = epos;
+	}
+
+	eptr = start;
+	while ((eptr != NULL)&&(eptr != end))
+	{
+		int p1, p2;
+
+		if (eptr == start)
+		{
+			p1 = start_pos;
+		}
+		else
+		{
+			p1 = 0;
+		}
+		p2 = eptr->edata_len - 2;
+
+		if (eptr->type == E_TEXT)
+		{
+			eptr->selected = False;
+			TextRefresh(hw, eptr, p1, p2);
+		}
+		else if (eptr->type == E_LINEFEED)
+		{
+			eptr->selected = False;
+			LinefeedRefresh(hw, eptr);
+		}
+		eptr = eptr->next;
+	}
+	if (eptr != NULL)
+	{
+		int p1, p2;
+
+		if (eptr == start)
+		{
+			p1 = start_pos;
+		}
+		else
+		{
+			p1 = 0;
+		}
+
+		if (eptr == end)
+		{
+			p2 = end_pos;
+		}
+		else
+		{
+			p2 = eptr->edata_len - 2;
+		}
+
+		if (eptr->type == E_TEXT)
+		{
+			eptr->selected = False;
+			TextRefresh(hw, eptr, p1, p2);
+		}
+		else if (eptr->type == E_LINEFEED)
+		{
+			eptr->selected = False;
+			LinefeedRefresh(hw, eptr);
+		}
+	}
+}
+
+
+/*
+ * Clear the current selection (if there is one)
+ */
+static void
+ClearSelection(hw)
+	HTMLWidget hw;
+{
+	struct ele_rec *start;
+	struct ele_rec *end;
+	int start_pos, end_pos;
+
+	start = hw->html.select_start;
+	end = hw->html.select_end;
+	start_pos = hw->html.sel_start_pos;
+	end_pos = hw->html.sel_end_pos;
+	EraseSelection(hw, start, end, start_pos, end_pos);
+
+	if ((start == NULL)||(end == NULL))
+	{
+		hw->html.select_start = NULL;
+		hw->html.select_end = NULL;
+		hw->html.sel_start_pos = 0;
+		hw->html.sel_end_pos = 0;
+		hw->html.active_anchor = NULL;
+		return;
+	}
+
+	hw->html.select_start = NULL;
+	hw->html.select_end = NULL;
+	hw->html.sel_start_pos = 0;
+	hw->html.sel_end_pos = 0;
+	hw->html.active_anchor = NULL;
+}
+
+
+/*
+ * clear from active all elements in the widget that are part of the anchor.
+ * (These have already been previously set into the start and end of the
+ * selection.
+ */
+static void
+UnsetAnchor(hw)
+	HTMLWidget hw;
+{
+	struct ele_rec *eptr;
+
+	/*
+	 * Clear any activated images
+	 */
+	eptr = hw->html.select_start;
+	while ((eptr != NULL)&&(eptr != hw->html.select_end))
+	{
+		if (eptr->type == E_IMAGE)
+		{
+			ImageRefresh(hw, eptr);
+		}
+		eptr = eptr->next;
+	}
+	if ((eptr != NULL)&&(eptr->type == E_IMAGE))
+	{
+		ImageRefresh(hw, eptr);
+	}
+
+	/*
+	 * Clear the activated anchor
+	 */
+	ClearSelection(hw);
+}
+
+
+/*
+ * Erase the old selection, and draw the new one in such a way
+ * that advantage is taken of overlap, and there is no obnoxious
+ * flashing.
+ */
+static void
+ChangeSelection(hw, start, end, start_pos, end_pos)
+	HTMLWidget hw;
+	struct ele_rec *start;
+	struct ele_rec *end;
+	int start_pos, end_pos;
+{
+	struct ele_rec *old_start;
+	struct ele_rec *old_end;
+	struct ele_rec *new_start;
+	struct ele_rec *new_end;
+	struct ele_rec *eptr;
+	int epos;
+	int new_start_pos, new_end_pos;
+	int old_start_pos, old_end_pos;
+
+	old_start = hw->html.new_start;
+	old_end = hw->html.new_end;
+	old_start_pos = hw->html.new_start_pos;
+	old_end_pos = hw->html.new_end_pos;
+	new_start = start;
+	new_end = end;
+	new_start_pos = start_pos;
+	new_end_pos = end_pos;
+
+	if ((new_start == NULL)||(new_end == NULL))
+	{
+		return;
+	}
+
+	if ((old_start == NULL)||(old_end == NULL))
+	{
+		DrawSelection(hw, new_start, new_end,
+			new_start_pos, new_end_pos);
+		return;
+	}
+
+	if (SwapElements(old_start, old_end, old_start_pos, old_end_pos))
+	{
+		eptr = old_start;
+		old_start = old_end;
+		old_end = eptr;
+		epos = old_start_pos;
+		old_start_pos = old_end_pos;
+		old_end_pos = epos;
+	}
+
+	if (SwapElements(new_start, new_end, new_start_pos, new_end_pos))
+	{
+		eptr = new_start;
+		new_start = new_end;
+		new_end = eptr;
+		epos = new_start_pos;
+		new_start_pos = new_end_pos;
+		new_end_pos = epos;
+	}
+
+	/*
+	 * Deal with all possible intersections of the 2 selection sets.
+	 *
+	 ********************************************************
+	 *			*				*
+	 *      |--		*	     |--		*
+	 * old--|		*	new--|			*
+	 *      |--		*	     |--		*
+	 *			*				*
+	 *      |--		*	     |--		*
+	 * new--|		*	old--|			*
+	 *      |--		*	     |--		*
+	 *			*				*
+	 ********************************************************
+	 *			*				*
+	 *      |----		*	       |--		*
+	 * old--|		*	  new--|		*
+	 *      | |--		*	       |		*
+	 *      |-+--		*	     |-+--		*
+	 *        |		*	     | |--		*
+	 *   new--|		*	old--|			*
+	 *        |--		*	     |----		*
+	 *			*				*
+	 ********************************************************
+	 *			*				*
+	 *      |---------	*	     |---------		*
+	 *      |		*	     |			*
+	 *      |      |--	*	     |      |--		*
+	 * new--| old--|	*	old--| new--|		*
+	 *      |      |--	*	     |      |--		*
+	 *      |		*	     |			*
+	 *      |---------	*	     |---------		*
+	 *			*				*
+	 ********************************************************
+	 *
+	 */
+	if ((ElementLessThan(old_end, new_start, old_end_pos, new_start_pos))||
+	    (ElementLessThan(new_end, old_start, new_end_pos, old_start_pos)))
+	{
+		EraseSelection(hw, old_start, old_end,
+			old_start_pos, old_end_pos);
+		DrawSelection(hw, new_start, new_end,
+			new_start_pos, new_end_pos);
+	}
+	else if ((ElementLessThan(old_start, new_start,
+			old_start_pos, new_start_pos))&&
+		 (ElementLessThan(old_end, new_end, old_end_pos, new_end_pos)))
+	{
+		if (new_start_pos != 0)
+		{
+			EraseSelection(hw, old_start, new_start,
+				old_start_pos, new_start_pos - 1);
+		}
+		else
+		{
+			EraseSelection(hw, old_start, new_start->prev,
+				old_start_pos, new_start->prev->edata_len - 2);
+		}
+		if (old_end_pos < (old_end->edata_len - 2))
+		{
+			DrawSelection(hw, old_end, new_end,
+				old_end_pos + 1, new_end_pos);
+		}
+		else
+		{
+			DrawSelection(hw, old_end->next, new_end,
+				0, new_end_pos);
+		}
+	}
+	else if ((ElementLessThan(new_start, old_start,
+			new_start_pos, old_start_pos))&&
+		 (ElementLessThan(new_end, old_end, new_end_pos, old_end_pos)))
+	{
+		if (old_start_pos != 0)
+		{
+			DrawSelection(hw, new_start, old_start,
+				new_start_pos, old_start_pos - 1);
+		}
+		else
+		{
+			DrawSelection(hw, new_start, old_start->prev,
+				new_start_pos, old_start->prev->edata_len - 2);
+		}
+		if (new_end_pos < (new_end->edata_len - 2))
+		{
+			EraseSelection(hw, new_end, old_end,
+				new_end_pos + 1, old_end_pos);
+		}
+		else
+		{
+			EraseSelection(hw, new_end->next, old_end,
+				0, old_end_pos);
+		}
+	}
+	else if ((ElementLessThan(new_start, old_start,
+			new_start_pos, old_start_pos))||
+		 (ElementLessThan(old_end, new_end, old_end_pos, new_end_pos)))
+	{
+		if ((new_start != old_start)||(new_start_pos != old_start_pos))
+		{
+			if (old_start_pos != 0)
+			{
+				DrawSelection(hw, new_start, old_start,
+					new_start_pos, old_start_pos - 1);
+			}
+			else
+			{
+				DrawSelection(hw, new_start, old_start->prev,
+					new_start_pos,
+					old_start->prev->edata_len - 2);
+			}
+		}
+		if ((old_end != new_end)||(old_end_pos != new_end_pos))
+		{
+			if (old_end_pos < (old_end->edata_len - 2))
+			{
+				DrawSelection(hw, old_end, new_end,
+					old_end_pos + 1, new_end_pos);
+			}
+			else
+			{
+				DrawSelection(hw, old_end->next, new_end,
+					0, new_end_pos);
+			}
+		}
+	}
+	else
+	{
+		if ((old_start != new_start)||(old_start_pos != new_start_pos))
+		{
+			if (new_start_pos != 0)
+			{
+				EraseSelection(hw, old_start, new_start,
+					old_start_pos, new_start_pos - 1);
+			}
+			else
+			{
+				EraseSelection(hw, old_start, new_start->prev,
+					old_start_pos,
+					new_start->prev->edata_len - 2);
+			}
+		}
+		if ((new_end != old_end)||(new_end_pos != old_end_pos))
+		{
+			if (new_end_pos < (new_end->edata_len - 2))
+			{
+				EraseSelection(hw, new_end, old_end,
+					new_end_pos + 1, old_end_pos);
+			}
+			else
+			{
+				EraseSelection(hw, new_end->next, old_end,
+					0, old_end_pos);
+			}
+		}
+	}
+}
+
+
+static void
+SelectStart(w, event, params, num_params)
+	Widget w;
+	XEvent *event;
+	String *params;         /* unused */
+	Cardinal *num_params;   /* unused */
+{
+	HTMLWidget hw = (HTMLWidget)XtParent(w);
+	XButtonPressedEvent *BuEvent = (XButtonPressedEvent *)event;
+	struct ele_rec *eptr;
+	int epos;
+
+	if (XtClass(XtParent(w)) != htmlWidgetClass)
+	{
+		return;
+	}
+
+#ifdef NOT_RIGHT
+        XUndefineCursor(XtDisplay(hw->html.view), XtWindow(hw->html.view));
+#endif
+        XUndefineCursor(XtDisplay(hw), XtWindow(hw));
+
+	/*
+	 * Because X sucks, we can get the button pressed in the window, but
+	 * released out of the window.  This will highlight some text, but
+	 * never complete the selection.  Now on the next button press we
+	 * have to clean up this mess.
+	 */
+	EraseSelection(hw, hw->html.new_start, hw->html.new_end,
+		hw->html.new_start_pos, hw->html.new_end_pos);
+
+	/*
+	 * We want to erase the currently selected text, but still save the
+	 * selection internally in case we don't create a new one.
+	 */
+	EraseSelection(hw, hw->html.select_start, hw->html.select_end,
+		hw->html.sel_start_pos, hw->html.sel_end_pos);
+	hw->html.new_start = hw->html.select_start;
+	hw->html.new_end = NULL;
+	hw->html.new_start_pos = hw->html.sel_start_pos;
+	hw->html.new_end_pos = 0;
+
+	eptr = LocateElement(hw, BuEvent->x, BuEvent->y, &epos);
+	if (eptr != NULL)
+	{
+		/*
+		 * If this is an anchor assume for now we are activating it
+		 * and not selecting it.
+		 */
+		if (eptr->anchorHRef != NULL)
+		{
+			hw->html.active_anchor = eptr;
+			hw->html.press_x = BuEvent->x;
+			hw->html.press_y = BuEvent->y;
+			SetAnchor(hw);
+		}
+		/*
+		 * Else if we are on an image we can't select text so
+		 * pretend we got eptr==NULL, and exit here.
+		 */
+		else if (eptr->type == E_IMAGE)
+		{
+			hw->html.new_start = NULL;
+			hw->html.new_end = NULL;
+			hw->html.new_start_pos = 0;
+			hw->html.new_end_pos = 0;
+			hw->html.press_x = BuEvent->x;
+			hw->html.press_y = BuEvent->y;
+			hw->html.but_press_time = BuEvent->time;
+			return;
+		}
+		/*
+		 * Else if we used button2, we can't select text, so exit
+		 * here.
+		 */
+		else if (BuEvent->button == Button2)
+		{
+			hw->html.press_x = BuEvent->x;
+			hw->html.press_y = BuEvent->y;
+			hw->html.but_press_time = BuEvent->time;
+			return;
+		}
+		/*
+		 * Else a single click will not select a new object
+		 * but it will prime that selection on the next mouse
+		 * move.
+		 * Ignore special internal text
+		 */
+		else if (eptr->internal == False)
+		{
+			hw->html.new_start = eptr;
+			hw->html.new_start_pos = epos;
+			hw->html.new_end = NULL;
+			hw->html.new_end_pos = 0;
+			hw->html.press_x = BuEvent->x;
+			hw->html.press_y = BuEvent->y;
+		}
+		else
+		{
+			hw->html.new_start = NULL;
+			hw->html.new_end = NULL;
+			hw->html.new_start_pos = 0;
+			hw->html.new_end_pos = 0;
+			hw->html.press_x = BuEvent->x;
+			hw->html.press_y = BuEvent->y;
+		}
+	}
+	else
+	{
+		hw->html.new_start = NULL;
+		hw->html.new_end = NULL;
+		hw->html.new_start_pos = 0;
+		hw->html.new_end_pos = 0;
+		hw->html.press_x = BuEvent->x;
+		hw->html.press_y = BuEvent->y;
+	}
+	hw->html.but_press_time = BuEvent->time;
+}
+
+
+static void
+ExtendStart(w, event, params, num_params)
+	Widget w;
+	XEvent *event;
+	String *params;         /* unused */
+	Cardinal *num_params;   /* unused */
+{
+	HTMLWidget hw = (HTMLWidget)XtParent(w);
+	XButtonPressedEvent *BuEvent = (XButtonPressedEvent *)event;
+	struct ele_rec *eptr;
+	struct ele_rec *start, *end;
+	struct ele_rec *old_start, *old_end;
+	int old_start_pos, old_end_pos;
+	int start_pos, end_pos;
+	int epos;
+
+	if (XtClass(XtParent(w)) != htmlWidgetClass)
+	{
+		return;
+	}
+
+	eptr = LocateElement(hw, BuEvent->x, BuEvent->y, &epos);
+
+	/*
+	 * Ignore IMAGE elements.
+	 */
+	if ((eptr != NULL)&&(eptr->type == E_IMAGE))
+	{
+		eptr = NULL;
+	}
+
+	/*
+	 * Ignore NULL elements.
+	 * Ignore special internal text
+	 * documents.
+	 */
+	if ((eptr != NULL)&&(eptr->internal == False))
+	{
+		old_start = hw->html.new_start;
+		old_start_pos = hw->html.new_start_pos;
+		old_end = hw->html.new_end;
+		old_end_pos = hw->html.new_end_pos;
+		if (hw->html.new_start == NULL)
+		{
+			hw->html.new_start = hw->html.select_start;
+			hw->html.new_start_pos = hw->html.sel_start_pos;
+			hw->html.new_end = hw->html.select_end;
+			hw->html.new_end_pos = hw->html.sel_end_pos;
+		}
+		else
+		{
+			hw->html.new_end = eptr;
+			hw->html.new_end_pos = epos;
+		}
+
+		if (SwapElements(hw->html.new_start, hw->html.new_end,
+			hw->html.new_start_pos, hw->html.new_end_pos))
+		{
+			if (SwapElements(eptr, hw->html.new_end,
+				epos, hw->html.new_end_pos))
+			{
+				start = hw->html.new_end;
+				start_pos = hw->html.new_end_pos;
+				end = eptr;
+				end_pos = epos;
+			}
+			else
+			{
+				start = hw->html.new_start;
+				start_pos = hw->html.new_start_pos;
+				end = eptr;
+				end_pos = epos;
+			}
+		}
+		else
+		{
+			if (SwapElements(eptr, hw->html.new_start,
+				epos, hw->html.new_start_pos))
+			{
+				start = hw->html.new_start;
+				start_pos = hw->html.new_start_pos;
+				end = eptr;
+				end_pos = epos;
+			}
+			else
+			{
+				start = hw->html.new_end;
+				start_pos = hw->html.new_end_pos;
+				end = eptr;
+				end_pos = epos;
+			}
+		}
+
+		if (start == NULL)
+		{
+			start = eptr;
+			start_pos = epos;
+		}
+
+		if (old_start == NULL)
+		{
+			hw->html.new_start = hw->html.select_start;
+			hw->html.new_end = hw->html.select_end;
+			hw->html.new_start_pos = hw->html.sel_start_pos;
+			hw->html.new_end_pos = hw->html.sel_end_pos;
+		}
+		else
+		{
+			hw->html.new_start = old_start;
+			hw->html.new_end = old_end;
+			hw->html.new_start_pos = old_start_pos;
+			hw->html.new_end_pos = old_end_pos;
+		}
+		ChangeSelection(hw, start, end, start_pos, end_pos);
+		hw->html.new_start = start;
+		hw->html.new_end = end;
+		hw->html.new_start_pos = start_pos;
+		hw->html.new_end_pos = end_pos;
+	}
+	else
+	{
+		if (hw->html.new_start == NULL)
+		{
+			hw->html.new_start = hw->html.select_start;
+			hw->html.new_start_pos = hw->html.sel_start_pos;
+			hw->html.new_end = hw->html.select_end;
+			hw->html.new_end_pos = hw->html.sel_end_pos;
+		}
+	}
+	hw->html.press_x = BuEvent->x;
+	hw->html.press_y = BuEvent->y;
+}
+
+
+static void
+ExtendAdjust(w, event, params, num_params)
+	Widget w;
+	XEvent *event;
+	String *params;         /* unused */
+	Cardinal *num_params;   /* unused */
+{
+	HTMLWidget hw = (HTMLWidget)XtParent(w);
+	XPointerMovedEvent *MoEvent = (XPointerMovedEvent *)event;
+	struct ele_rec *eptr;
+	struct ele_rec *start, *end;
+	int start_pos, end_pos;
+	int epos;
+
+	if (XtClass(XtParent(w)) != htmlWidgetClass)
+	{
+		return;
+	}
+
+	/*
+	 * Very small mouse motion immediately after button press
+	 * is ignored.
+	 */
+	if ((ABS((hw->html.press_x - MoEvent->x)) <= SELECT_THRESHOLD)&&
+	    (ABS((hw->html.press_y - MoEvent->y)) <= SELECT_THRESHOLD))
+	{
+		return;
+	}
+
+	/*
+	 * If we have an active anchor and we got here, we have moved the
+	 * mouse too far.  Deactivate anchor, and prime a selection.
+	 * If the anchor is internal text, don't
+	 * prime a selection.
+	 */
+	if (hw->html.active_anchor != NULL)
+	{
+		eptr = hw->html.active_anchor;
+		UnsetAnchor(hw);
+		if (eptr->internal == False)
+		{
+			hw->html.new_start = NULL;
+			hw->html.new_start_pos = 0;
+			hw->html.new_end = NULL;
+			hw->html.new_end_pos = 0;
+		}
+	}
+
+	/*
+	 * If we used button2, we can't select text, so
+	 * clear selection and exit here.
+	 */
+	if ((MoEvent->state & Button2Mask) != 0)
+	{
+		hw->html.select_start = NULL;
+		hw->html.select_end = NULL;
+		hw->html.sel_start_pos = 0;
+		hw->html.sel_end_pos = 0;
+		hw->html.new_start = NULL;
+		hw->html.new_end = NULL;
+		hw->html.new_start_pos = 0;
+		hw->html.new_end_pos = 0;
+		return;
+	}
+
+	eptr = LocateElement(hw, MoEvent->x, MoEvent->y, &epos);
+
+	/*
+	 * If we are on an image pretend we are nowhere
+	 * and just return;
+	 */
+	if ((eptr != NULL)&&(eptr->type == E_IMAGE))
+	{
+		return;
+	}
+
+	/*
+	 * Ignore NULL items.
+	 * Ignore if the same as last selected item and position.
+	 * Ignore special internal text
+	 */
+	if ((eptr != NULL)&&
+	    ((eptr != hw->html.new_end)||(epos != hw->html.new_end_pos))&&
+	    (eptr->internal == False))
+	{
+		start = hw->html.new_start;
+		start_pos = hw->html.new_start_pos;
+		end = eptr;
+		end_pos = epos;
+		if (start == NULL)
+		{
+			start = eptr;
+			start_pos = epos;
+		}
+
+		ChangeSelection(hw, start, end, start_pos, end_pos);
+		hw->html.new_start = start;
+		hw->html.new_end = end;
+		hw->html.new_start_pos = start_pos;
+		hw->html.new_end_pos = end_pos;
+	}
+}
+
+
+static void
+ExtendEnd(w, event, params, num_params)
+	Widget w;
+	XEvent *event;
+	String *params;
+	Cardinal *num_params;
+{
+	HTMLWidget hw = (HTMLWidget)XtParent(w);
+	XButtonReleasedEvent *BuEvent = (XButtonReleasedEvent *)event;
+	struct ele_rec *eptr;
+	struct ele_rec *start, *end;
+	Atom *atoms;
+	int i, buffer;
+	int start_pos, end_pos;
+	int epos;
+	char *text;
+
+	if (XtClass(XtParent(w)) != htmlWidgetClass)
+	{
+		return;
+	}
+
+	eptr = LocateElement(hw, BuEvent->x, BuEvent->y, &epos);
+
+	/*
+	 * If we just released button one or two, and we are on an object,
+	 * and we have an active anchor, and we are on the active anchor,
+	 * and if we havn't waited too long.  Activate that anchor.
+	 */
+	if (((BuEvent->button == Button1)||(BuEvent->button == Button2))&&
+		(eptr != NULL)&&
+		(hw->html.active_anchor != NULL)&&
+		(eptr == hw->html.active_anchor)&&
+		((BuEvent->time - hw->html.but_press_time) < CLICK_TIME))
+	{
+		_HTMLInput(w, event, params, num_params);
+		return;
+	}
+	else if (hw->html.active_anchor != NULL)
+	{
+		start = hw->html.active_anchor;
+		UnsetAnchor(hw);
+		if (start->internal == False)
+		{
+			hw->html.new_start = eptr;
+			hw->html.new_start_pos = epos;
+			hw->html.new_end = NULL;
+			hw->html.new_end_pos = 0;
+		}
+	}
+
+	/*
+	 * If we used button2, we can't select text, so clear
+	 * selection and exit here.
+	 */
+	if (BuEvent->button == Button2)
+	{
+		hw->html.new_start = hw->html.select_start;
+		hw->html.new_end = NULL;
+		hw->html.new_start_pos = hw->html.sel_start_pos;
+		hw->html.new_end_pos = 0;
+		return;
+	}
+
+	/*
+	 * If we are on an image, pretend we are nowhere
+	 * and NULL out the eptr
+	 */
+	if ((eptr != NULL)&&(eptr->type == E_IMAGE))
+	{
+		eptr = NULL;
+	}
+
+	/*
+	 * If button released on a NULL item, take the last non-NULL
+	 * item that we highlighted.
+	 */
+	if ((eptr == NULL)&&(hw->html.new_end != NULL))
+	{
+		eptr = hw->html.new_end;
+		epos = hw->html.new_end_pos;
+	}
+
+	if ((eptr != NULL)&&(eptr->internal == False)&&
+		(hw->html.new_end != NULL))
+	{
+		start = hw->html.new_start;
+		start_pos = hw->html.new_start_pos;
+		end = eptr;
+		end_pos = epos;
+		if (start == NULL)
+		{
+			start = eptr;
+			start_pos = epos;
+		}
+		ChangeSelection(hw, start, end, start_pos, end_pos);
+		hw->html.select_start = start;
+		hw->html.sel_start_pos = start_pos;
+		hw->html.select_end = end;
+		hw->html.sel_end_pos = end_pos;
+		SetSelection(hw);
+		hw->html.new_start = NULL;
+		hw->html.new_end = NULL;
+		hw->html.new_start_pos = 0;
+		hw->html.new_end_pos = 0;
+
+		atoms = (Atom *)malloc(*num_params * sizeof(Atom));
+		if (atoms == NULL)
+		{
+			fprintf(stderr, "cannot allocate atom list\n");
+			return;
+		}
+		XmuInternStrings(XtDisplay((Widget)hw), params, *num_params, atoms);
+		hw->html.selection_time = BuEvent->time;
+		for (i=0; i< *num_params; i++)
+		{
+			switch (atoms[i])
+			{
+				case XA_CUT_BUFFER0: buffer = 0; break;
+				case XA_CUT_BUFFER1: buffer = 1; break;
+				case XA_CUT_BUFFER2: buffer = 2; break;
+				case XA_CUT_BUFFER3: buffer = 3; break;
+				case XA_CUT_BUFFER4: buffer = 4; break;
+				case XA_CUT_BUFFER5: buffer = 5; break;
+				case XA_CUT_BUFFER6: buffer = 6; break;
+				case XA_CUT_BUFFER7: buffer = 7; break;
+				default: buffer = -1; break;
+			}
+			if (buffer >= 0)
+			{
+				if (hw->html.fancy_selections == True)
+				{
+				    text = ParseTextToPrettyString(hw,
+					hw->html.formatted_elements,
+					hw->html.select_start,
+					hw->html.select_end,
+					hw->html.sel_start_pos,
+					hw->html.sel_end_pos,
+					hw->html.font->max_bounds.width,
+					hw->html.margin_width);
+				}
+				else
+				{
+				    text = ParseTextToString(
+					hw->html.formatted_elements,
+					hw->html.select_start,
+					hw->html.select_end,
+					hw->html.sel_start_pos,
+					hw->html.sel_end_pos,
+					hw->html.font->max_bounds.width,
+					hw->html.margin_width);
+				}
+				XStoreBuffer(XtDisplay((Widget)hw),
+					text, strlen(text), buffer);
+				if (text != NULL)
+				{
+					free(text);
+				}
+			}
+			else
+			{
+				XtOwnSelection((Widget)hw, atoms[i],
+					       BuEvent->time,
+					       (XtConvertSelectionProc )ConvertSelection,
+					       (XtLoseSelectionProc )LoseSelection,
+					       (XtSelectionDoneProc )SelectionDone);
+			}
+		}
+		free((char *)atoms);
+	}
+	else if (eptr == NULL)
+	{
+		hw->html.select_start = NULL;
+		hw->html.sel_start_pos = 0;
+		hw->html.select_end = NULL;
+		hw->html.sel_end_pos = 0;
+		hw->html.new_start = NULL;
+		hw->html.new_start_pos = 0;
+		hw->html.new_end = NULL;
+		hw->html.new_end_pos = 0;
+	}
+}
+
+
+#define LEAVING_ANCHOR(hw) \
+  hw->html.cached_tracked_ele = NULL; \
+  (*(pointerTrackProc) \
+    (hw->html.pointer_motion_callback))(hw, hw->html.pm_client_data, ""); \
+  XUndefineCursor (XtDisplay (hw), XtWindow (hw));
+
+/* KNOWN PROBLEM: We never get LeaveNotify or FocusOut events,
+   despite the fact we've requested them.  Bummer. */
+static void
+TrackMotion(w, event, params, num_params)
+	Widget w;
+	XEvent *event;
+	String *params;         /* unused */
+	Cardinal *num_params;   /* unused */
+{
+	HTMLWidget hw = (HTMLWidget)XtParent(w);
+	struct ele_rec *eptr;
+	int epos, x, y;
+
+	if (XtClass(XtParent(w)) != htmlWidgetClass)
+	{
+		return;
+	}
+
+        if (!hw->html.pointer_motion_callback)
+          return;
+
+        if (event->type == MotionNotify)
+          {
+            x = ((XMotionEvent *)event)->x;
+            y = ((XMotionEvent *)event)->y;
+          }
+        else if (event->type == LeaveNotify || event->type == FocusOut ||
+                 event->type == Expose)
+          {
+            /* Wipe out. */
+            if (hw->html.cached_tracked_ele)
+              {
+                LEAVING_ANCHOR (hw);
+              }
+            return;
+          }
+        else
+          {
+            return;
+          }
+
+	eptr = LocateElement(hw, x, y, &epos);
+        
+        /* We're hitting a new anchor if eptr exists and
+           eptr != cached tracked element and anchorHRef != NULL. */
+	if (eptr != NULL && eptr != hw->html.cached_tracked_ele &&
+            eptr->anchorHRef != NULL)
+          {
+            hw->html.cached_tracked_ele = eptr;
+	    (*(pointerTrackProc)
+             (hw->html.pointer_motion_callback))
+		 (hw, hw->html.pm_client_data, eptr->anchorHRef);
+            XDefineCursor (XtDisplay (hw), XtWindow (hw), in_anchor_cursor);
+          }
+        /* We're leaving an anchor if eptr exists and
+           a cached ele exists and we're not entering a new anchor. */
+        else if (eptr != NULL && hw->html.cached_tracked_ele != NULL && 
+                 eptr->anchorHRef == NULL)
+          {
+            LEAVING_ANCHOR (hw);
+          }
+
+        return;
+}
+
+
+/*
+ * Scroll display vertically.
+ */
+static void
+Scroll (w, event, params, num_params)
+	Widget w;
+	XEvent *event;
+	String *params;
+	Cardinal *num_params;
+{
+	register HTMLWidget hw = (HTMLWidget)XtParent(w);
+#ifdef MOTIF
+	int val, size, inc, pageinc;
+#endif
+	int offset, newy;
+
+	if (XtClass(XtParent(w)) != htmlWidgetClass)
+	    return;
+
+	if (*num_params > 0) {
+	    char *s = params[0];
+	    double fraction;
+	    double atof();
+	    int ch;
+
+	    if (strcmp (s + strlen(s) - 2, "ch") == 0) {
+		fraction = atof (s);
+		ch = (hw->html.font->max_bounds.ascent +
+		      hw->html.font->max_bounds.descent);
+		offset = fraction * ch;
+	    } else
+		offset = (int)hw->html.view_height * atof(s);
+
+	} else
+	    offset = (int)hw->html.view_height / 10;
+
+	newy = hw->html.scroll_y + offset;
+	if (newy < 0)
+	    newy = 0;
+	if (newy > (hw->html.doc_height - (int)hw->html.view_height))
+	    newy = hw->html.doc_height - (int)hw->html.view_height;
+	if (newy < 0)
+	    newy = 0;
+
+#ifdef MOTIF
+	XmScrollBarGetValues(hw->html.vbar, &val, &size, &inc, &pageinc);
+	XmScrollBarSetValues(hw->html.vbar, newy, size, inc, pageinc, True);
+	XmScrollBarGetValues(hw->html.hbar, &val, &size, &inc, &pageinc);
+	XmScrollBarSetValues(hw->html.hbar, 0, size, inc, pageinc, True);
+#else
+	ScrollToPos(hw->html.vbar, hw, newy);
+	ScrollToPos(hw->html.hbar, hw, 0);
+	setScrollBar(hw->html.vbar, newy, 
+		     hw->html.doc_height,
+		     (int)hw->html.view_height);
+#endif
+}
+
+
+/*
+ * Process mouse input to the HTML widget
+ * Currently only processes an anchor-activate when Button1
+ * is pressed
+ */
+static void
+#ifdef _NO_PROTO
+_HTMLInput( w, event, params, num_params)
+	Widget w ;
+	XEvent *event ;
+	String *params;		/* unused */
+	Cardinal *num_params;	/* unused */
+#else
+_HTMLInput(
+	Widget w,
+	XEvent *event,
+	String *params,		/* unused */
+	Cardinal *num_params)	/* unused */
+#endif
+{   
+	HTMLWidget hw = (HTMLWidget)XtParent(w);
+	struct ele_rec *eptr;
+	WbAnchorCallbackData cbdata;
+	int epos;
+#ifdef MOTIF
+	Boolean on_gadget;
+#endif /* MOTIF */
+
+	if (XtClass(XtParent(w)) != htmlWidgetClass)
+	{
+		return;
+	}
+
+#ifdef MOTIF
+	/*
+	 * If motif is defined, we don't want to process this button press
+	 * if it is on a gadget
+	 */
+#ifdef MOTIF1_2
+	on_gadget = (_XmInputForGadget((Widget)hw,
+#else
+	on_gadget = (_XmInputForGadget((CompositeWidget)hw,
+#endif /* MOTIF1_2 */
+				event->xbutton.x, event->xbutton.y) != NULL);
+
+	if (on_gadget)
+	{
+		return;
+	}
+#endif /* MOTIF */
+
+	if (event->type == ButtonRelease)
+	{
+		eptr = LocateElement(hw, event->xbutton.x, event->xbutton.y,
+				&epos);
+		if (eptr != NULL)
+		{
+			if (eptr->anchorHRef != NULL)
+			{
+			    char *tptr, *ptr;
+
+			   /*
+			    * Save the anchor text, replace newlines with
+			    * spaces.
+			    */
+			    tptr = ParseTextToString(hw->html.select_start,
+				hw->html.select_start, hw->html.select_end,
+				hw->html.sel_start_pos, hw->html.sel_end_pos,
+				hw->html.font->max_bounds.width,
+				hw->html.margin_width);
+			    ptr = tptr;
+			    while ((ptr != NULL)&&(*ptr != '\0'))
+			    {
+				if (*ptr == '\n')
+				{
+					*ptr = ' ';
+				}
+				ptr++;
+			    }
+
+			   /*
+			    * Clear the activated anchor
+			    */
+			    UnsetAnchor(hw);
+#ifdef EXTRA_FLUSH
+			    XFlush(XtDisplay(hw));
+#endif
+
+			    if ((IsDelayedHRef(hw, eptr->anchorHRef))&&
+				(hw->html.resolveDelayedImage != NULL))
+			    {
+				eptr->pic_data = (*(resolveImageProc)
+				    (hw->html.resolveDelayedImage))(hw, eptr->edata);
+
+				if (eptr->pic_data == NULL)
+				{
+					eptr->pic_data = NoImageData(hw);
+					eptr->pic_data->delayed = 0;
+					eptr->pic_data->internal = 0;
+				}
+				else
+				{
+					eptr->pic_data->delayed = 0;
+					/*
+					 * Mark images we have sucessfully
+					 * loaded at least once
+					 */
+					if (eptr->pic_data->image_data != NULL)
+					{
+					    eptr->pic_data->fetched = 1;
+					}
+					/*
+					 * See if this is a special
+					 * internal image
+					 */
+					if ((eptr->edata != NULL)&&
+						(strncmp(eptr->edata,
+						INTERNAL_IMAGE,
+						strlen(INTERNAL_IMAGE)) == 0))
+					{
+					    eptr->pic_data->internal = 1;
+					}
+					else
+					{
+					    eptr->pic_data->internal = 0;
+					}
+				}
+
+				ReformatWindow(hw);
+				ScrollWidgets(hw);
+				ViewClearAndRefresh(hw);
+			    }
+			    else if ((eptr->pic_data != NULL)&&
+				(eptr->pic_data->delayed)&&
+				(eptr->anchorHRef != NULL)&&
+				(IsIsMapForm(hw, eptr->anchorHRef)))
+			    {
+				eptr->pic_data = (*(resolveImageProc)
+				    (hw->html.resolveDelayedImage))(hw, eptr->edata);
+
+				if (eptr->pic_data == NULL)
+				{
+					eptr->pic_data = NoImageData(hw);
+					eptr->pic_data->delayed = 0;
+					eptr->pic_data->internal = 0;
+				}
+				else
+				{
+					eptr->pic_data->delayed = 0;
+					/*
+					 * Mark images we have sucessfully
+					 * loaded at least once
+					 */
+					if (eptr->pic_data->image_data != NULL)
+					{
+					    eptr->pic_data->fetched = 1;
+					}
+					/*
+					 * See if this is a special
+					 * internal image
+					 */
+					if ((eptr->edata != NULL)&&
+						(strncmp(eptr->edata,
+						INTERNAL_IMAGE,
+						strlen(INTERNAL_IMAGE)) == 0))
+					{
+					    eptr->pic_data->internal = 1;
+					}
+					else
+					{
+					    eptr->pic_data->internal = 0;
+					}
+				}
+
+				ReformatWindow(hw);
+				ScrollWidgets(hw);
+				ViewClearAndRefresh(hw);
+			    }
+			    else if ((eptr->pic_data != NULL)&&
+				(eptr->pic_data->delayed)&&
+				(eptr->anchorHRef != NULL)&&
+				(!IsDelayedHRef(hw, eptr->anchorHRef))&&
+				(!IsIsMapForm(hw, eptr->anchorHRef))&&
+				(((event->xbutton.y + hw->html.scroll_y) -
+				  (eptr->y + eptr->y_offset)) >
+				  AnchoredHeight(hw)))
+			    {
+				eptr->pic_data = (*(resolveImageProc)
+				    (hw->html.resolveDelayedImage))(hw, eptr->edata);
+
+				if (eptr->pic_data == NULL)
+				{
+					eptr->pic_data = NoImageData(hw);
+					eptr->pic_data->delayed = 0;
+					eptr->pic_data->internal = 0;
+				}
+				else
+				{
+					/*
+					 * Mark images we have sucessfully
+					 * loaded at least once
+					 */
+					if (eptr->pic_data->image_data != NULL)
+					{
+					    eptr->pic_data->fetched = 1;
+					}
+					/*
+					 * See if this is a special
+					 * internal image
+					 */
+					if ((eptr->edata != NULL)&&
+						(strncmp(eptr->edata,
+						INTERNAL_IMAGE,
+						strlen(INTERNAL_IMAGE)) == 0))
+					{
+					    eptr->pic_data->internal = 1;
+					}
+					else
+					{
+					    eptr->pic_data->internal = 0;
+					}
+				}
+				eptr->pic_data->delayed = 0;
+
+				ReformatWindow(hw);
+				ScrollWidgets(hw);
+				ViewClearAndRefresh(hw);
+			    }
+			    else if ((eptr->pic_data != NULL)&&
+				(eptr->pic_data->ismap)&&
+				(eptr->anchorHRef != NULL)&&
+				(IsIsMapForm(hw, eptr->anchorHRef)))
+			    {
+				int form_x, form_y;
+
+				form_x = event->xbutton.x + hw->html.scroll_x -
+					eptr->x;
+				form_y = event->xbutton.y + hw->html.scroll_y -
+					eptr->y;
+				ImageSubmitForm(eptr->pic_data->fptr, event,
+					eptr->pic_data->text, form_x, form_y);
+			    }
+			    else
+			    {
+			     	/* The following is a hack to send the
+			     	 * selection location along with the HRef
+			     	 * for images.  This allows you to
+			     	 * point at a location on a map and have
+			     	 * the server send you the related document.
+			     	 * Tony Sanders, April 1993 <sanders@bsdi.com>
+			     	 */
+			     	int alloced = 0;
+			     	char *buf = eptr->anchorHRef;
+				if (eptr->type == E_IMAGE && eptr->pic_data
+				        && eptr->pic_data->ismap) {
+				    buf = (char *)
+				        malloc(strlen(eptr->anchorHRef) + 256);
+				    alloced = 1;
+				    sprintf(buf, "%s?%d,%d",
+					eptr->anchorHRef,
+					event->xbutton.x + hw->html.scroll_x - eptr->x,
+					event->xbutton.y + hw->html.scroll_y - eptr->y);
+			        }
+				/*
+				 * XXX: should call a media dependent
+				 * function that decides how to munge the
+				 * HRef.  For example mpeg data will want
+				 * to know on what frame the event occured.
+				 *
+				 * cddata.href = *(eptr->eventf)(eptr, event);
+			         */
+				cbdata.event = event;
+				cbdata.element_id = eptr->ele_id;
+				cbdata.href = buf;
+				/* cbdata.href = eptr->anchorHRef; */
+				cbdata.text = tptr;
+				XtCallCallbackList ((Widget)hw,
+					hw->html.anchor_callback,
+					(XtPointer)&cbdata);
+			        if (alloced) free(buf);
+			        if (tptr != NULL) free(tptr);
+			    }
+			}
+		}
+	}
+
+	return;
+}
+
+
+#ifndef MOTIF
+#include <X11/Xaw/AsciiText.h>
+/*
+ * Process key input passwd widgets
+ */
+static void
+#ifdef _NO_PROTO
+_HTMLpwdInput( w, event, params, num_params)
+	Widget w ;
+	XEvent *event ;
+	String *params;		/* unused */
+	Cardinal *num_params;	/* unused */
+#else
+_HTMLpwdInput(
+	Widget w,
+	XEvent *event,
+	String *params,		/* unused */
+	Cardinal *num_params)	/* unused */
+#endif
+     {
+     char buffer[50];
+     KeySym ks;
+     char *keySymString;
+     char *star = "*";
+     int length, passwdLength, i, insertPos, maxLength;
+     Boolean stringInPlace; 
+     
+     if (event->type == KeyPress)
+	 {
+	 HTMLWidget hw = (HTMLWidget)XtParent(XtParent(w));
+	 WidgetInfo *wptr;
+
+	 if (XtClass((Widget)hw) != htmlWidgetClass) 
+	     return;   /* it was not for us */
+ 
+	/*
+	 * find the structure for this widget
+	 */
+	wptr = hw->html.widget_list;
+	while (wptr != NULL)
+	    {
+	    if (wptr->w == w)
+		break;
+	    wptr = wptr->next;
+	    }
+	 if (wptr == NULL)
+	     return;
+
+	 passwdLength = wptr->password ? strlen(wptr->password) : 0;
+
+	 length = XLookupString((XKeyEvent *)event, 
+				buffer, 50, &ks, NULL);
+	 keySymString = XKeysymToString(ks);
+	 XtVaGetValues(w,
+		       XtNinsertPosition,&insertPos,
+		       XtNuseStringInPlace, &stringInPlace,
+		       XtNlength, &maxLength,
+		       NULL);
+
+         if (maxLength<1) maxLength = 1000000;
+
+	 if (!strcmp("Left",keySymString))
+	     {
+	     if (insertPos > 0)
+		 XtVaSetValues(w,XtNinsertPosition,--insertPos,NULL);
+	     return;
+	     }
+	 else if (!strcmp("Right",keySymString))
+	     {
+	     if (insertPos < passwdLength)
+		 XtVaSetValues(w,XtNinsertPosition,++insertPos,NULL);
+	     return;
+	     }
+
+	 if ((!strcmp("BackSpace",keySymString))
+	     || (!strcmp("Backspace",keySymString))
+	     || (!strcmp("Delete",keySymString)) ) 
+	     {
+	     insertPos --;
+
+	     if (passwdLength>0)
+		 {
+		 char *pwd = &(wptr->password[insertPos]);
+
+		 for (i = passwdLength - insertPos; i>0; i--,pwd++)
+		     *pwd = *(pwd+1);
+
+/*		 fprintf(stderr,"modified passwd <%s>\n", wptr->password);*/
+		 XtCallActionProc(w, 
+				  insertPos>-1 ? "delete-previous-character" :
+				  "delete-next-character",
+				  event, NULL,0);
+		 }
+	     /* else nothing to erase */
+	     return;
+	     }
+
+	 if (length == 1)
+	     {
+	     buffer[1] = '\0';
+
+	     if (passwdLength>0)
+		 {
+
+		 if (passwdLength < maxLength)
+		     {
+		     char *pwd = wptr->password =
+			 (char *)realloc(wptr->password, 
+				 sizeof(char)*(passwdLength+2));
+		     for (i=passwdLength+1; i>insertPos; i--)
+			 pwd[i] = pwd[i-1];
+		     
+		     pwd[insertPos] = buffer[0];
+		     }
+		 }
+	     else 
+		 {
+		 if (wptr->password == NULL)
+		     wptr->password = (char *)malloc(sizeof(char)*2);
+
+		 wptr->password[0] = buffer[0];
+		 wptr->password[1] = '\0';
+		 }
+
+	     if (stringInPlace && passwdLength<maxLength)
+		 {
+		 char *txt;
+		 /* insert string dumps core when  string in place is true */
+
+		 XtVaGetValues(w,XtNstring,&txt,NULL);
+		 txt[passwdLength] = star[0];
+		 txt[passwdLength+1] = '\0';
+
+		 /* the combined set values command does not work */
+		 XtVaSetValues(w, XtNstring,txt, NULL);
+		 XtVaSetValues(w, XtNinsertPosition,insertPos+1, NULL);
+		 }
+	     else
+		 XtCallActionProc(w, "insert-string", event, &star, 1);
+/*	     fprintf(stderr,"modified passwd <%s>\n",  wptr->password); */
+	     }
+	 }
+     }
+#endif /* not MOTIF */
+
+
+/*
+ * SetValues is called when XtSetValues is used to change resources in this
+ * widget.
+ */
+static Boolean
+#ifdef _NO_PROTO
+SetValues (current, request, new)
+            HTMLWidget current ;
+            HTMLWidget request ;
+            HTMLWidget new ;
+#else
+SetValues(
+            HTMLWidget current,
+            HTMLWidget request,
+            HTMLWidget new)
+#endif
+{
+	int reformatted;
+
+	/*
+	 *	Make sure the underline numbers are within bounds.
+	 */
+	if (request->html.num_anchor_underlines < 0)
+	{
+		new->html.num_anchor_underlines = 0;
+	} 
+	if (request->html.num_anchor_underlines > MAX_UNDERLINES)
+	{
+		new->html.num_anchor_underlines = MAX_UNDERLINES;
+	} 
+	if (request->html.num_visitedAnchor_underlines < 0)
+	{
+		new->html.num_visitedAnchor_underlines = 0;
+	} 
+	if (request->html.num_visitedAnchor_underlines > MAX_UNDERLINES)
+	{
+		new->html.num_visitedAnchor_underlines = MAX_UNDERLINES;
+	} 
+
+	reformatted = 0;
+	if ((request->html.raw_text != current->html.raw_text)||
+	    (request->html.header_text != current->html.header_text)||
+	    (request->html.footer_text != current->html.footer_text))
+	{
+		/*
+		 * Free up the old visited href list.
+		 */
+		FreeHRefs(current->html.my_visited_hrefs);
+		new->html.my_visited_hrefs = NULL;
+
+		/*
+		 * Free up the old visited delayed images list.
+		 */
+		FreeDelayedImages(current->html.my_delayed_images);
+		new->html.my_delayed_images = NULL;
+
+		/*
+		 * Free any old colors and pixmaps
+		 */
+		FreeColors(XtDisplay(current), DefaultColormapOfScreen(XtScreen(current)));
+		FreeImages(current);
+
+		/*
+		 * Hide any old widgets
+		 */
+		HideWidgets(current);
+		new->html.widget_list = NULL;
+		new->html.form_list = NULL;
+
+		/*
+		 * Parse the raw text with the HTML parser
+		 */
+		new->html.html_objects = HTMLParse(current->html.html_objects,
+			request->html.raw_text);
+		CallLinkCallbacks(new);
+		new->html.html_header_objects =
+			HTMLParse(current->html.html_header_objects,
+			request->html.header_text);
+		new->html.html_footer_objects =
+			HTMLParse(current->html.html_footer_objects,
+			request->html.footer_text);
+
+		/*
+		 * Redisplay for the changed data.
+		 */
+		{
+			new->html.scroll_x = 0;
+			new->html.scroll_y = 0;
+			new->html.max_pre_width = DocumentWidth(new,
+				new->html.html_objects);
+			ReformatWindow(new);
+			ViewClearAndRefresh(new);
+			reformatted = 1;
+		}
+
+		/*
+		 * Clear any previous selection
+		 */
+		new->html.select_start = NULL;
+		new->html.select_end = NULL;
+		new->html.sel_start_pos = 0;
+		new->html.sel_end_pos = 0;
+		new->html.new_start = NULL;
+		new->html.new_end = NULL;
+		new->html.new_start_pos = 0;
+		new->html.new_end_pos = 0;
+		new->html.active_anchor = NULL;
+	}
+	else if ((request->html.font != current->html.font)||
+	         (request->html.italic_font != current->html.italic_font)||
+	         (request->html.bold_font != current->html.bold_font)||
+	         (request->html.fixed_font != current->html.fixed_font)||
+	         (request->html.fixedbold_font != current->html.fixedbold_font)||
+	         (request->html.fixeditalic_font != current->html.fixeditalic_font)||
+	         (request->html.header1_font != current->html.header1_font)||
+	         (request->html.header2_font != current->html.header2_font)||
+	         (request->html.header3_font != current->html.header3_font)||
+	         (request->html.header4_font != current->html.header4_font)||
+	         (request->html.header5_font != current->html.header5_font)||
+	         (request->html.header6_font != current->html.header6_font)||
+	         (request->html.address_font != current->html.address_font)||
+	         (request->html.plain_font != current->html.plain_font)||
+	         (request->html.plainbold_font != current->html.plainbold_font)||
+	         (request->html.plainitalic_font != current->html.plainitalic_font)||
+	         (request->html.listing_font != current->html.listing_font)||
+	         (request->html.activeAnchor_fg != current->html.activeAnchor_fg)||
+	         (request->html.activeAnchor_bg != current->html.activeAnchor_bg)||
+	         (request->html.anchor_fg != current->html.anchor_fg)||
+	         (request->html.visitedAnchor_fg != current->html.visitedAnchor_fg)||
+	         (request->html.dashed_anchor_lines != current->html.dashed_anchor_lines)||
+	         (request->html.dashed_visitedAnchor_lines != current->html.dashed_visitedAnchor_lines)||
+	         (request->html.num_anchor_underlines != current->html.num_anchor_underlines)||
+	         (request->html.num_visitedAnchor_underlines != current->html.num_visitedAnchor_underlines))
+	{
+		if ((request->html.plain_font != current->html.plain_font)||
+		    (request->html.listing_font != current->html.listing_font))
+		{
+			new->html.max_pre_width = DocumentWidth(new,
+				new->html.html_objects);
+		}
+
+		ReformatWindow(new);
+		ScrollWidgets(new);
+		ViewClearAndRefresh(new);
+		reformatted = 1;
+	}
+
+	/*
+	 * image borders have been changed
+	 */
+	if (request->html.border_images != current->html.border_images)
+	{
+		ReformatWindow(new);
+		ScrollWidgets(new);
+		ViewClearAndRefresh(new);
+		reformatted = 1;
+	}
+
+	/*
+	 * vertical space has been changed
+	 */
+	if(request->html.percent_vert_space != current->html.percent_vert_space)
+	{
+		ReformatWindow(new);
+		ScrollWidgets(new);
+		ViewClearAndRefresh(new);
+		reformatted = 1;
+	}
+
+	/*
+	 * Set client data for retest anchors callback.
+	 */
+	if(request->html.vt_client_data != current->html.vt_client_data)
+	{
+		new->html.vt_client_data = request->html.vt_client_data;
+	}
+
+	/*
+	 * Set client data for pointer motion callback.
+	 */
+	if(request->html.pm_client_data != current->html.pm_client_data)
+	{
+		new->html.pm_client_data = request->html.pm_client_data;
+	}
+
+	return(False);
+}
+
+
+/*
+ * Go through the parsed marks and for all the <LINK> tags in the document
+ * call the LinkCallback.
+ */
+static void
+#ifdef _NO_PROTO
+CallLinkCallbacks(hw)
+	HTMLWidget hw;
+#else
+CallLinkCallbacks(HTMLWidget hw)
+#endif
+{
+	struct mark_up *mptr;
+	LinkInfo l_info;
+
+	mptr = hw->html.html_objects;
+	while (mptr != NULL)
+	{
+		if (mptr->type == M_BASE)
+		{
+			l_info.href = ParseMarkTag(mptr->start, MT_BASE,
+				"HREF");
+			l_info.role = ParseMarkTag(mptr->start, MT_BASE,
+				"ROLE");
+			XtCallCallbackList ((Widget)hw, hw->html.link_callback,
+				(XtPointer)&l_info);
+			if (l_info.href != NULL)
+			{
+				free(l_info.href);
+			}
+			if (l_info.role != NULL)
+			{
+				free(l_info.role);
+			}
+		}
+		mptr = mptr->next;
+	}
+}
+
+
+/*
+ * Search through the whole document, and recolor the internal elements with
+ * the passed HREF.
+ */
+static void
+#ifdef _NO_PROTO
+RecolorInternalHRefs(hw, href)
+	HTMLWidget hw;
+	char *href;
+#else
+RecolorInternalHRefs(HTMLWidget hw, char *href)
+#endif
+{
+	struct ele_rec *start;
+	unsigned long fg;
+
+	fg = hw->html.visitedAnchor_fg;
+	start = hw->html.formatted_elements;
+	while (start != NULL)
+	{
+		/*
+		 * This one is internal
+		 * This one has an href
+		 * This is the href we want
+		 */
+		if ((start->internal == True)&&
+		    (start->anchorHRef != NULL)&&
+		    (strcmp(start->anchorHRef, href) == 0))
+		{
+			start->fg = fg;
+			start->underline_number =
+				hw->html.num_visitedAnchor_underlines;
+			start->dashed_underline =
+				hw->html.dashed_visitedAnchor_lines;
+		}
+		start = start->next;
+	}
+}
+
+
+static Boolean
+ConvertSelection(w, selection, target, type, value, length, format)
+	Widget w;
+	Atom *selection, *target, *type;
+	caddr_t *value;
+	unsigned long *length;
+	int *format;
+{
+	Display *d = XtDisplay(w);
+	HTMLWidget hw = (HTMLWidget)w;
+	char *text;
+
+	if (hw->html.select_start == NULL)
+	{
+		return False;
+	}
+
+	if (*target == XA_TARGETS(d))
+	{
+		Atom *targetP;
+		Atom *std_targets;
+		unsigned long std_length;
+		XmuConvertStandardSelection( w, hw->html.selection_time,
+			selection, target, type, (caddr_t*)&std_targets,
+			&std_length, format);
+
+		*length = std_length + 5;
+		*value = (caddr_t)XtMalloc(sizeof(Atom)*(*length));
+		targetP = *(Atom**)value;
+		*targetP++ = XA_STRING;
+		*targetP++ = XA_TEXT(d);
+		*targetP++ = XA_COMPOUND_TEXT(d);
+		*targetP++ = XA_LENGTH(d);
+		*targetP++ = XA_LIST_LENGTH(d);
+
+		bcopy((char*)std_targets, (char*)targetP,
+			sizeof(Atom)*std_length);
+		XtFree((char*)std_targets);
+		*type = XA_ATOM;
+		*format = 32;
+		return True;
+	}
+
+	if (*target == XA_STRING || *target == XA_TEXT(d) ||
+		*target == XA_COMPOUND_TEXT(d))
+	{
+		if (*target == XA_COMPOUND_TEXT(d))
+		{
+			*type = *target;
+		}
+		else
+		{
+			*type = XA_STRING;
+		}
+		if (hw->html.fancy_selections == True)
+		{
+			text = ParseTextToPrettyString(hw,
+				hw->html.formatted_elements,
+				hw->html.select_start, hw->html.select_end,
+				hw->html.sel_start_pos, hw->html.sel_end_pos,
+				hw->html.font->max_bounds.width,
+				hw->html.margin_width);
+		}
+		else
+		{
+			text = ParseTextToString(hw->html.formatted_elements,
+				hw->html.select_start, hw->html.select_end,
+				hw->html.sel_start_pos, hw->html.sel_end_pos,
+				hw->html.font->max_bounds.width,
+				hw->html.margin_width);
+		}
+		*value = text;
+		*length = strlen(*value);
+		*format = 8;
+		return True;
+	}
+
+	if (*target == XA_LIST_LENGTH(d))
+	{
+		*value = XtMalloc(4);
+		if (sizeof(long) == 4)
+		{
+			*(long*)*value = 1;
+		}
+		else
+		{
+			long temp = 1;
+			bcopy( ((char*)&temp)+sizeof(long)-4, (char*)*value, 4);
+		}
+		*type = XA_INTEGER;
+		*length = 1;
+		*format = 32;
+		return True;
+	}
+
+	if (*target == XA_LENGTH(d))
+	{
+		if (hw->html.fancy_selections == True)
+		{
+			text = ParseTextToPrettyString(hw,
+				hw->html.formatted_elements,
+				hw->html.select_start, hw->html.select_end,
+				hw->html.sel_start_pos, hw->html.sel_end_pos,
+				hw->html.font->max_bounds.width,
+				hw->html.margin_width);
+		}
+		else
+		{
+			text = ParseTextToString(hw->html.formatted_elements,
+				hw->html.select_start, hw->html.select_end,
+				hw->html.sel_start_pos, hw->html.sel_end_pos,
+				hw->html.font->max_bounds.width,
+				hw->html.margin_width);
+		}
+		*value = XtMalloc(4);
+		if (sizeof(long) == 4)
+		{
+			*(long*)*value = strlen(text);
+		}
+		else
+		{
+			long temp = strlen(text);
+			bcopy( ((char*)&temp)+sizeof(long)-4, (char*)*value, 4);
+		}
+		free(text);
+		*type = XA_INTEGER;
+		*length = 1;
+		*format = 32;
+		return True;
+	}
+
+	if (XmuConvertStandardSelection(w, hw->html.selection_time, selection,
+				    target, type, value, length, format))
+	{
+		return True;
+	}
+
+	return False;
+}
+
+
+static void
+LoseSelection(w, selection)
+	Widget w;
+	Atom *selection;
+{
+	HTMLWidget hw = (HTMLWidget)w;
+
+	ClearSelection(hw);
+}
+
+
+static void
+SelectionDone(w, selection, target)
+	Widget w;
+	Atom *selection, *target;
+{
+	/* empty proc so Intrinsics know we want to keep storage */
+}
+
+
+/*
+ *************************************************************************
+ ******************************* PUBLIC FUNCTIONS ************************
+ *************************************************************************
+ */
+
+
+/*
+ * Convenience function to return the text of the HTML document as a plain
+ * ascii text string.
+ * This function allocates memory for the returned string, that it is up
+ * to the user to free.
+ * Extra option flags "pretty" text to be returned.
+ * when pretty is two or larger, Postscript is returned. The font used is
+ * encoded in the pretty parameter:
+ * pretty = 2: Times
+ * pretty = 3: Helvetica
+ * pretty = 4: New century schoolbook
+ * pretty = 5: Lucida Bright
+ */
+char *
+#ifdef _NO_PROTO
+HTMLGetText (w, pretty)
+	Widget w;
+	int pretty;
+#else
+HTMLGetText(Widget w, int pretty)
+#endif
+{
+	HTMLWidget hw = (HTMLWidget)w;
+	char *text;
+	char *tptr, *buf;
+	struct ele_rec *start;
+	struct ele_rec *end;
+
+	text = NULL;
+	start = hw->html.formatted_elements;
+	end = start;
+	while (end != NULL)
+	{
+		end = end->next;
+	}
+
+	if (pretty >= 2)
+	{
+		tptr = ParseTextToPSString(hw, start, start, end,
+				0, 0,
+				hw->html.font->max_bounds.width,
+				hw->html.margin_width , pretty-2);
+	}
+	else if (pretty)
+	{
+		tptr = ParseTextToPrettyString(hw, start, start, end,
+				0, 0,
+				hw->html.font->max_bounds.width,
+				hw->html.margin_width);
+	}
+	else
+	{
+		tptr = ParseTextToString(start, start, end,
+				0, 0,
+				hw->html.font->max_bounds.width,
+				hw->html.margin_width);
+	}
+	if (tptr != NULL)
+	{
+		if (text == NULL)
+		{
+			text = tptr;
+		}
+		else
+		{
+			buf = (char *)malloc(strlen(text) +
+				strlen(tptr) + 1);
+			strcpy(buf, text);
+			strcat(buf, tptr);
+			free(text);
+			free(tptr);
+			text = buf;
+		}
+	}
+	return(text);
+}
+
+
+/*
+ * Convenience function to return the element id of the element
+ * nearest to the x,y coordinates passed in.
+ * If there is no element there, return the first element in the
+ * line we are on.  If there we are on no line, either return the
+ * beginning, or the end of the document.
+ */
+int
+#ifdef _NO_PROTO
+HTMLPositionToId(w, x, y)
+	Widget w;
+	int x, y;
+#else
+HTMLPositionToId(Widget w, int x, int y)
+#endif
+{
+	HTMLWidget hw = (HTMLWidget)w;
+	int i;
+	int epos;
+	struct ele_rec *eptr;
+
+	eptr = LocateElement(hw, x, y, &epos);
+	if (eptr == NULL)
+	{
+		x = x + hw->html.scroll_x;
+		y = y + hw->html.scroll_y;
+		eptr = hw->html.line_array[0];
+		for (i=0; i<hw->html.line_count; i++)
+		{
+			if (hw->html.line_array[i] == NULL)
+			{
+				continue;
+			}
+			else if (hw->html.line_array[i]->y <= y)
+			{
+				eptr = hw->html.line_array[i];
+				continue;
+			}
+			else
+			{
+				break;
+			}
+		}
+	}
+
+	/*
+	 * 0 means the very top of the document.  We put you there for
+	 * unfound elements.
+	 * We also special case for when the scrollbar is at the
+	 * absolute top.
+	 */
+	if ((eptr == NULL)||(hw->html.scroll_y == 0))
+	{
+		return(0);
+	}
+	else
+	{
+		return(eptr->ele_id);
+	}
+}
+
+
+/*
+ * Convenience function to return the position of the element
+ * based on the element id passed in.
+ * Function returns 1 on success and fills in x,y pixel values.
+ * If there is no such element, x=0, y=0 and -1 is returned.
+ */
+int
+#ifdef _NO_PROTO
+HTMLIdToPosition(w, element_id, x, y)
+	Widget w;
+	int element_id;
+	int *x, *y;
+#else
+HTMLIdToPosition(Widget w, int element_id, int *x, int *y)
+#endif
+{
+	HTMLWidget hw = (HTMLWidget)w;
+	struct ele_rec *start;
+	struct ele_rec *eptr;
+
+	eptr = NULL;
+	start = hw->html.formatted_elements;
+	while (start != NULL)
+	{
+		if (start->ele_id == element_id)
+		{
+			eptr = start;
+			break;
+		}
+		start = start->next;
+	}
+
+	if (eptr == NULL)
+	{
+		*x = 0;
+		*y = 0;
+		return(-1);
+	}
+	else
+	{
+		*x = eptr->x;
+		*y = eptr->y;
+		return(1);
+	}
+}
+
+
+/*
+ * Convenience function to position the element
+ * based on the element id passed at the top of the viewing area.
+ * A passed in id of 0 means goto the top.
+ */
+void
+#ifdef _NO_PROTO
+HTMLGotoId(w, element_id)
+	Widget w;
+	int element_id;
+#else
+HTMLGotoId(Widget w, int element_id)
+#endif
+{
+	HTMLWidget hw = (HTMLWidget)w;
+	struct ele_rec *start;
+	struct ele_rec *eptr;
+	int newy;
+#ifdef MOTIF
+	int val, size, inc, pageinc;
+#endif
+
+	/*
+	 * If we have no scrollbar, just return.
+	 */
+	if (hw->html.use_vbar == False)
+	{
+		return;
+	}
+
+	/*
+	 * Find the element corrsponding to the id passed in.
+	 */
+	eptr = NULL;
+	start = hw->html.formatted_elements;
+	while (start != NULL)
+	{
+		if (start->ele_id == element_id)
+		{
+			eptr = start;
+			break;
+		}
+		start = start->next;
+	}
+
+	/*
+	 * No such element, do nothing.
+	 */
+	if ((element_id != 0)&&(eptr == NULL))
+	{
+		return;
+	}
+
+	if (element_id == 0)
+	{
+		newy = 0;
+	}
+	else
+	{
+		newy = eptr->y - 2;
+	}
+	if (newy < 0)
+	{
+		newy = 0;
+	}
+	if (newy > (hw->html.doc_height - (int)hw->html.view_height))
+	{
+		newy = hw->html.doc_height - (int)hw->html.view_height;
+	}
+	if (newy < 0)
+	{
+		newy = 0;
+	}
+#ifdef MOTIF
+	XmScrollBarGetValues(hw->html.vbar, &val, &size, &inc, &pageinc);
+	XmScrollBarSetValues(hw->html.vbar, newy, size, inc, pageinc, True);
+	XmScrollBarGetValues(hw->html.hbar, &val, &size, &inc, &pageinc);
+	XmScrollBarSetValues(hw->html.hbar, 0, size, inc, pageinc, True);
+#else
+	ScrollToPos(hw->html.vbar, hw, newy);
+	ScrollToPos(hw->html.hbar, hw, 0);
+	setScrollBar(hw->html.vbar, newy, 
+		     hw->html.doc_height,
+		     (int)hw->html.view_height);
+#endif
+}
+
+
+/*
+ * Convenience function to return the position of the anchor
+ * based on the anchor NAME passed.
+ * Function returns 1 on success and fills in x,y pixel values.
+ * If there is no such element, x=0, y=0 and -1 is returned.
+ */
+int
+#ifdef _NO_PROTO
+HTMLAnchorToPosition(w, name, x, y)
+	Widget w;
+	char *name;
+	int *x, *y;
+#else
+HTMLAnchorToPosition(Widget w, char *name, int *x, int *y)
+#endif
+{
+	HTMLWidget hw = (HTMLWidget)w;
+	struct ele_rec *start;
+	struct ele_rec *eptr;
+
+	eptr = NULL;
+	start = hw->html.formatted_elements;
+	while (start != NULL)
+	{
+		if ((start->anchorName)&&
+		    (strcmp(start->anchorName, name) == 0))
+		{
+			eptr = start;
+			break;
+		}
+		start = start->next;
+	}
+
+	if (eptr == NULL)
+	{
+		*x = 0;
+		*y = 0;
+		return(-1);
+	}
+	else
+	{
+		*x = eptr->x;
+		*y = eptr->y;
+		return(1);
+	}
+}
+
+
+/*
+ * Convenience function to return the element id of the anchor
+ * based on the anchor NAME passed.
+ * Function returns id on success.
+ * If there is no such element, 0 is returned.
+ */
+int
+#ifdef _NO_PROTO
+HTMLAnchorToId(w, name)
+	Widget w;
+	char *name;
+#else
+HTMLAnchorToId(Widget w, char *name)
+#endif
+{
+	HTMLWidget hw = (HTMLWidget)w;
+	struct ele_rec *start;
+	struct ele_rec *eptr;
+
+	/*
+	 * Find the passed anchor name
+	 */
+	eptr = NULL;
+	start = hw->html.formatted_elements;
+	while (start != NULL)
+	{
+	    if ((start->anchorName)&&				/* MF023 */
+	      ((strcmp(start->anchorName, name) == 0) ||
+	      (*name == '#' && strcmp(start->anchorName, &(name[1])) == 0)) ) {
+	    	 eptr = start;
+	    	 break;
+	    }
+	    start = start->next;
+	}
+
+	if (eptr == NULL)
+	{
+		return(0);
+	}
+	else
+	{
+		return(eptr->ele_id);
+	}
+}
+
+
+/*
+ * Convenience function to return the HREFs of all active anchors in the
+ * document.
+ * Function returns an array of strings and fills num_hrefs passed.
+ * If there are no HREFs NULL returned.
+ */
+char **
+#ifdef _NO_PROTO
+HTMLGetHRefs(w, num_hrefs)
+	Widget w;
+	int *num_hrefs;
+#else
+HTMLGetHRefs(Widget w, int *num_hrefs)
+#endif
+{
+	HTMLWidget hw = (HTMLWidget)w;
+	int cnt;
+	struct ele_rec *start;
+	struct ele_rec *list;
+	struct ele_rec *eptr;
+	char **harray;
+
+	list = NULL;
+	cnt = 0;
+	/*
+	 * Construct a linked list of all the diffeent hrefs, counting
+	 * then as we go.
+	 */
+	start = hw->html.formatted_elements;
+	while (start != NULL)
+	{
+		/*
+		 * This one has an HREF
+		 */
+		if (start->anchorHRef != NULL)
+		{
+			/*
+			 * Check to see if we already have
+			 * this HREF in our list.
+			 */
+			eptr = list;
+			while (eptr != NULL)
+			{
+				if (strcmp(eptr->anchorHRef,
+					start->anchorHRef) == 0)
+				{
+					break;
+				}
+				eptr = eptr->next;
+			}
+			/*
+			 * This HREF is not, in our list.  Add it.
+			 * That is, if it's not an internal reference.
+			 */
+			if ((eptr == NULL)&&(start->internal == False))
+			{
+				eptr = (struct ele_rec *)
+					malloc(sizeof(struct ele_rec));
+				eptr->anchorHRef = start->anchorHRef;
+				eptr->next = list;
+				list = eptr;
+				cnt++;
+			}
+		}
+		start = start->next;
+	}
+
+	if (cnt == 0)
+	{
+		*num_hrefs = 0;
+		return(NULL);
+	}
+	else
+	{
+		*num_hrefs = cnt;
+		harray = (char **)malloc(sizeof(char *) * cnt);
+		eptr = list;
+		cnt--;
+		while (eptr != NULL)
+		{
+			harray[cnt] = (char *)
+				malloc(strlen(eptr->anchorHRef) + 1);
+			strcpy(harray[cnt], eptr->anchorHRef);
+			start = eptr;
+			eptr = eptr->next;
+			free((char *)start);
+			cnt--;
+		}
+		return(harray);
+	}
+}
+
+
+/*
+ * Convenience function to return the SRCs of all images in the
+ * document.
+ * Function returns an array of strings and fills num_srcs passed.
+ * If there are no SRCs NULL returned.
+ */
+char **
+#ifdef _NO_PROTO
+HTMLGetImageSrcs(w, num_srcs)
+	Widget w;
+	int *num_srcs;
+#else
+HTMLGetImageSrcs(Widget w, int *num_srcs)
+#endif
+{
+	HTMLWidget hw = (HTMLWidget)w;
+	struct mark_up *mptr;
+	int cnt;
+	char *tptr;
+	char **harray;
+
+	cnt = 0;
+	mptr = hw->html.html_objects;
+	while (mptr != NULL)
+	{
+		if (mptr->type == M_IMAGE)
+		{
+			tptr = ParseMarkTag(mptr->start, MT_IMAGE, "SRC");
+			if ((tptr != NULL)&&(*tptr != '\0'))
+			{
+				cnt++;
+				free(tptr);
+			}
+		}
+		mptr = mptr->next;
+	}
+
+	if (cnt == 0)
+	{
+		*num_srcs = 0;
+		return(NULL);
+	}
+	else
+	{
+		*num_srcs = cnt;
+		harray = (char **)malloc(sizeof(char *) * cnt);
+		mptr = hw->html.html_objects;
+		cnt = 0;
+		while (mptr != NULL)
+		{
+			if (mptr->type == M_IMAGE)
+			{
+				tptr = ParseMarkTag(mptr->start,MT_IMAGE,"SRC");
+				if ((tptr != NULL)&&(*tptr != '\0'))
+				{
+					harray[cnt] = tptr;
+					cnt++;
+				}
+			}
+			mptr = mptr->next;
+		}
+		return(harray);
+	}
+}
+
+
+/*
+ * Convenience function to return the link information
+ * for all the <LINK> tags in the document.
+ * Function returns an array of LinkInfo structures and fills
+ * num_links passed.
+ * If there are no LINKs NULL returned.
+ */
+LinkInfo *
+#ifdef _NO_PROTO
+HTMLGetLinks(w, num_links)
+	Widget w;
+	int *num_links;
+#else
+HTMLGetLinks(Widget w, int *num_links)
+#endif
+{
+	HTMLWidget hw = (HTMLWidget)w;
+	struct mark_up *mptr;
+	int cnt;
+	char *tptr;
+	LinkInfo *larray;
+
+	cnt = 0;
+	mptr = hw->html.html_objects;
+	while (mptr != NULL)
+	{
+		if (mptr->type == M_BASE)
+		{
+			cnt++;
+		}
+		mptr = mptr->next;
+	}
+
+	if (cnt == 0)
+	{
+		*num_links = 0;
+		return(NULL);
+	}
+	else
+	{
+		*num_links = cnt;
+		larray = (LinkInfo *)malloc(sizeof(LinkInfo) * cnt);
+		mptr = hw->html.html_objects;
+		cnt = 0;
+		while (mptr != NULL)
+		{
+			if (mptr->type == M_BASE)
+			{
+				tptr = ParseMarkTag(mptr->start,
+					MT_BASE, "HREF");
+				larray[cnt].href = tptr;
+				tptr = ParseMarkTag(mptr->start,
+					MT_BASE, "ROLE");
+				larray[cnt].role = tptr;
+				cnt++;
+			}
+			mptr = mptr->next;
+		}
+		return(larray);
+	}
+}
+
+
+
+void *
+#ifdef _NO_PROTO
+HTMLGetWidgetInfo(w)
+	Widget w;
+#else
+HTMLGetWidgetInfo(Widget w)
+#endif
+{
+	HTMLWidget hw = (HTMLWidget)w;
+
+	return((void *)hw->html.widget_list);
+}
+
+
+void
+#ifdef _NO_PROTO
+HTMLFreeImageInfo(w)
+	Widget w;
+#else
+HTMLFreeImageInfo(Widget w)
+#endif
+{
+	HTMLWidget hw = (HTMLWidget)w;
+
+	FreeColors(XtDisplay(w), DefaultColormapOfScreen(XtScreen(w)));
+	FreeImages(hw);
+}
+
+
+void
+#ifdef _NO_PROTO
+HTMLFreeWidgetInfo(ptr)
+	void *ptr;
+#else
+HTMLFreeWidgetInfo(void *ptr)
+#endif
+{
+	WidgetInfo *wptr = (WidgetInfo *)ptr;
+	WidgetInfo *tptr;
+
+	while (wptr != NULL)
+	{
+		tptr = wptr;
+		wptr = wptr->next;
+		if (tptr->w != NULL)
+		{
+			/*
+			 * This is REALLY DUMB, but X generates an expose event
+			 * for the destruction of the Widgte, even if it isn't
+			 * mapped at the time it is destroyed.
+			 * So I move the invisible widget to -1000,-1000
+			 * before destroying it, to avoid a visible flash.
+			 */
+			XtMoveWidget(tptr->w, -1000, -1000);
+			XtDestroyWidget(tptr->w);
+		}
+		if (tptr->name != NULL)
+		{
+			free(tptr->name);
+		}
+		if ((tptr->value != NULL)&&(tptr->type != W_OPTIONMENU))
+		{
+			free(tptr->value);
+		}
+		free((char *)tptr);
+	}
+}
+
+
+/*
+ * Convenience function to redraw all active anchors in the
+ * document.
+ * Can also pass a new predicate function to check visited
+ * anchors.  If NULL passed for function, uses default predicate
+ * function.
+ */
+void
+#ifdef _NO_PROTO
+HTMLRetestAnchors(w, testFunc, client_data)
+	Widget w;
+	visitTestProc testFunc;
+	XtPointer client_data;
+#else
+HTMLRetestAnchors(Widget w, visitTestProc testFunc, XtPointer client_data)
+#endif
+{
+	HTMLWidget hw = (HTMLWidget)w;
+	struct ele_rec *start;
+	int	stat = 0;
+
+	if (testFunc == NULL)
+	{
+		testFunc = (visitTestProc)hw->html.previously_visited_test;
+		client_data = hw->html.vt_client_data;
+	}
+
+	/*
+	 * Search all elements
+	 */
+	start = hw->html.formatted_elements;
+	while (start != NULL)
+	{
+		if ((start->internal == True)||
+		    (start->anchorHRef == NULL))
+		{
+			start = start->next;
+			continue;
+		}
+
+		if (testFunc != NULL)
+		{
+			if ((stat=(*testFunc)(hw, client_data, start->anchorHRef)))
+			{
+			    start->fg = hw->html.visitedAnchor_fg;
+			    start->underline_number =
+				hw->html.num_visitedAnchor_underlines;
+			    start->dashed_underline =
+				hw->html.dashed_visitedAnchor_lines;
+			}
+			else
+			{
+			    start->fg = hw->html.anchor_fg;
+			    start->underline_number =
+				hw->html.num_anchor_underlines;
+			    start->dashed_underline =
+				hw->html.dashed_anchor_lines;
+			}
+		}
+		else
+		{
+			start->fg = hw->html.anchor_fg;
+			start->underline_number =
+				hw->html.num_anchor_underlines;
+			start->dashed_underline =
+				hw->html.dashed_anchor_lines;
+		}
+
+		/*
+		 * Since the element may have changed, redraw it
+		 */
+		if (stat) {
+		    switch(start->type)
+		    {
+			case E_TEXT:
+				TextRefresh(hw, start,
+				     0, (start->edata_len - 2));
+				break;
+			case E_IMAGE:
+				ImageRefresh(hw, start);
+				break;
+			case E_BULLET:
+				BulletRefresh(hw, start);
+				break;
+			case E_LINEFEED:
+				LinefeedRefresh(hw, start);
+				break;
+		    }
+		}
+
+		start = start->next;
+	}
+}
+
+
+void
+#ifdef _NO_PROTO
+HTMLClearSelection (w)
+	Widget w;
+#else
+HTMLClearSelection(Widget w)
+#endif
+{
+	LoseSelection (w, NULL);
+}
+
+
+/*
+ * Set the current selection based on the ElementRefs passed in.
+ * Both refs must be valid.
+ */
+void
+#ifdef _NO_PROTO
+HTMLSetSelection (w, start, end)
+	Widget w;
+	ElementRef *start;
+	ElementRef *end;
+#else
+HTMLSetSelection(Widget w, ElementRef *start, ElementRef *end)
+#endif
+{
+	HTMLWidget hw = (HTMLWidget)w;
+	int found;
+	struct ele_rec *eptr;
+	struct ele_rec *e_start;
+	struct ele_rec *e_end;
+	int start_pos, end_pos;
+	Atom *atoms;
+	int i, buffer;
+	char *text;
+	char *params[2];
+
+	/*
+	 * If the starting position is not valid, fail the selection
+	 */
+	if ((start->id > 0)&&(start->pos >= 0))
+	{
+		found = 0;
+		eptr = hw->html.formatted_elements;
+
+		while (eptr != NULL)
+		{
+			if (eptr->ele_id == start->id)
+			{
+				e_start = eptr;
+				start_pos = start->pos;
+				found = 1;
+				break;
+			}
+			eptr = eptr->next;
+		}
+		if (!found)
+		{
+			return;
+		}
+	}
+
+	/*
+	 * If the ending position is not valid, fail the selection
+	 */
+	if ((end->id > 0)&&(end->pos >= 0))
+	{
+		found = 0;
+		eptr = hw->html.formatted_elements;
+
+		while (eptr != NULL)
+		{
+			if (eptr->ele_id == end->id)
+			{
+				e_end = eptr;
+				end_pos = end->pos;
+				found = 1;
+				break;
+			}
+			eptr = eptr->next;
+		}
+		if (!found)
+		{
+			return;
+		}
+	}
+
+	LoseSelection (w, NULL);
+
+	/*
+	 * We expect the ElementRefs came from HTMLSearchText, so we know
+	 * that the end_pos is one past what we want to select.
+	 */
+	end_pos = end_pos - 1;
+
+	/*
+	 * Sanify the position data
+	 */
+	if ((start_pos > 0)&&(start_pos >= e_start->edata_len - 1))
+	{
+		start_pos = e_start->edata_len - 2;
+	}
+	if ((end_pos > 0)&&(end_pos >= e_end->edata_len - 1))
+	{
+		end_pos = e_end->edata_len - 2;
+	}
+
+	hw->html.select_start = e_start;
+	hw->html.sel_start_pos = start_pos;
+	hw->html.select_end = e_end;
+	hw->html.sel_end_pos = end_pos;
+	SetSelection(hw);
+	hw->html.new_start = NULL;
+	hw->html.new_end = NULL;
+	hw->html.new_start_pos = 0;
+	hw->html.new_end_pos = 0;
+
+	/*
+	 * Do all the gunk from the end of the ExtendEnd function
+	 */
+	params[0] = "PRIMARY";
+	params[1] = "CUT_BUFFER0";
+	atoms = (Atom *)malloc(2 * sizeof(Atom));
+	if (atoms == NULL)
+	{
+		fprintf(stderr, "cannot allocate atom list\n");
+		return;
+	}
+	XmuInternStrings(XtDisplay((Widget)hw), params, 2, atoms);
+	hw->html.selection_time = CurrentTime;
+	for (i=0; i< 2; i++)
+	{
+		switch (atoms[i])
+		{
+			case XA_CUT_BUFFER0: buffer = 0; break;
+			case XA_CUT_BUFFER1: buffer = 1; break;
+			case XA_CUT_BUFFER2: buffer = 2; break;
+			case XA_CUT_BUFFER3: buffer = 3; break;
+			case XA_CUT_BUFFER4: buffer = 4; break;
+			case XA_CUT_BUFFER5: buffer = 5; break;
+			case XA_CUT_BUFFER6: buffer = 6; break;
+			case XA_CUT_BUFFER7: buffer = 7; break;
+			default: buffer = -1; break;
+		}
+		if (buffer >= 0)
+		{
+			if (hw->html.fancy_selections == True)
+			{
+			    text = ParseTextToPrettyString(hw,
+				hw->html.formatted_elements,
+				hw->html.select_start,
+				hw->html.select_end,
+				hw->html.sel_start_pos,
+				hw->html.sel_end_pos,
+				hw->html.font->max_bounds.width,
+				hw->html.margin_width);
+			}
+			else
+			{
+			    text = ParseTextToString(
+				hw->html.formatted_elements,
+				hw->html.select_start,
+				hw->html.select_end,
+				hw->html.sel_start_pos,
+				hw->html.sel_end_pos,
+				hw->html.font->max_bounds.width,
+				hw->html.margin_width);
+			}
+			XStoreBuffer(XtDisplay((Widget)hw),
+				text, strlen(text), buffer);
+			free(text);
+		}
+		else
+		{
+			XtOwnSelection((Widget)hw, atoms[i], CurrentTime,
+				       (XtConvertSelectionProc )ConvertSelection,
+				       (XtLoseSelectionProc )LoseSelection,
+				       (XtSelectionDoneProc )SelectionDone);
+		}
+	}
+	free((char *)atoms);
+}
+
+
+/*
+ * Convenience function to return the text of the HTML document as a single
+ * white space separated string, with pointers to the various start and
+ * end points of selections.
+ * This function allocates memory for the returned string, that it is up
+ * to the user to free.
+ */
+char *
+#ifdef _NO_PROTO
+HTMLGetTextAndSelection (w, startp, endp, insertp)
+	Widget w;
+	char **startp;
+	char **endp;
+	char **insertp;
+#else
+HTMLGetTextAndSelection(Widget w, char **startp, char **endp, char **insertp)
+#endif
+{
+	HTMLWidget hw = (HTMLWidget)w;
+	int length;
+	char *text;
+	char *tptr;
+	struct ele_rec *eptr;
+	struct ele_rec *sel_start;
+	struct ele_rec *sel_end;
+	struct ele_rec *insert_start;
+	int start_pos, end_pos, insert_pos;
+
+	if (SwapElements(hw->html.select_start, hw->html.select_end,
+		hw->html.sel_start_pos, hw->html.sel_end_pos))
+	{
+		sel_end = hw->html.select_start;
+		end_pos = hw->html.sel_start_pos;
+		sel_start = hw->html.select_end;
+		start_pos = hw->html.sel_end_pos;
+	}
+	else
+	{
+		sel_start = hw->html.select_start;
+		start_pos = hw->html.sel_start_pos;
+		sel_end = hw->html.select_end;
+		end_pos = hw->html.sel_end_pos;
+	}
+
+	insert_start = hw->html.new_start;
+	insert_pos = hw->html.new_start_pos;
+	*startp = NULL;
+	*endp = NULL;
+	*insertp = NULL;
+
+	length = 0;
+
+	eptr = hw->html.formatted_elements;
+	while (eptr != NULL)
+	{
+		/*
+		 * Skip the special internal text
+		 */
+		if (eptr->internal == True)
+		{
+			eptr = eptr->next;
+			continue;
+		}
+
+		if (eptr->type == E_TEXT)
+		{
+			length = length + eptr->edata_len - 1;
+		}
+		else if (eptr->type == E_LINEFEED)
+		{
+			length = length + 1;
+		}
+		eptr = eptr->next;
+	}
+
+	text = (char *)malloc(length + 1);
+	if (text == NULL)
+	{
+		fprintf(stderr, "No space for return string\n");
+		return(NULL);
+	}
+	strcpy(text, "");
+
+	tptr = text;
+
+	eptr = hw->html.formatted_elements;
+	while (eptr != NULL)
+	{
+		/*
+		 * Skip the special internal text
+		 */
+		if (eptr->internal == True)
+		{
+			eptr = eptr->next;
+			continue;
+		}
+
+		if (eptr->type == E_TEXT)
+		{
+			if (eptr == sel_start)
+			{
+				*startp = (char *)(tptr + start_pos);
+			}
+
+			if (eptr == sel_end)
+			{
+				*endp = (char *)(tptr + end_pos);
+			}
+
+			if (eptr == insert_start)
+			{
+				*insertp = (char *)(tptr + insert_pos);
+			}
+
+			strcat(text, (char *)eptr->edata);
+			tptr = tptr + eptr->edata_len - 1;
+		}
+		else if (eptr->type == E_LINEFEED)
+		{
+			if (eptr == sel_start)
+			{
+				*startp = tptr;
+			}
+
+			if (eptr == sel_end)
+			{
+				*endp = tptr;
+			}
+
+			if (eptr == insert_start)
+			{
+				*insertp = tptr;
+			}
+
+			strcat(text, " ");
+			tptr = tptr + 1;
+		}
+		eptr = eptr->next;
+	}
+	return(text);
+}
+
+
+/*
+ * Convenience function to set the raw text into the widget.
+ * Forces a reparse and a reformat.
+ * If any pointer is passed in as NULL that text is unchanged,
+ * if a pointer points to an empty string, that text is set to NULL;
+ * Also pass an element ID to set the view area to that section of the new
+ * text.  Finally pass an anchor NAME to set position of the new text
+ * to that anchor.
+ */
+void
+#ifdef _NO_PROTO
+HTMLSetText (w, text, header_text, footer_text, element_id, target_anchor, ptr)
+	Widget w;
+	char *text;
+	char *header_text;
+	char *footer_text;
+	int element_id;
+	char *target_anchor;
+	void *ptr;
+#else
+HTMLSetText(Widget w, char *text, char *header_text, char *footer_text, int element_id, char *target_anchor, void *ptr)
+#endif
+{
+	HTMLWidget hw = (HTMLWidget)w;
+	WidgetInfo *wptr = (WidgetInfo *)ptr;
+	struct ele_rec *start;
+	struct ele_rec *eptr;
+	int newy;
+
+	if ((text == NULL)&&(header_text == NULL)&&(footer_text == NULL))
+	{
+		return;
+	}
+
+	/*
+	 * Free up the old visited href list.
+	 */
+	FreeHRefs(hw->html.my_visited_hrefs);
+	hw->html.my_visited_hrefs = NULL;
+
+	/*
+	 * Free up the old visited delayed images list.
+	 */
+	FreeDelayedImages(hw->html.my_delayed_images);
+	hw->html.my_delayed_images = NULL;
+
+	/*
+	 * Hide any old widgets
+	 */
+	HideWidgets(hw);
+	hw->html.widget_list = wptr;
+	hw->html.form_list = NULL;
+
+	if (text != NULL)
+	{
+		if (*text == '\0')
+		{
+			text = NULL;
+		}
+		hw->html.raw_text = text;
+
+		/*
+		 * Free any old colors and pixmaps
+		 */
+		FreeColors(XtDisplay(hw),DefaultColormapOfScreen(XtScreen(hw)));
+		FreeImages(hw);
+
+		/*
+		 * Parse the raw text with the HTML parser
+		 */
+		hw->html.html_objects = HTMLParse(hw->html.html_objects,
+			hw->html.raw_text);
+		CallLinkCallbacks(hw);
+	}
+	if (header_text != NULL)
+	{
+		if (*header_text == '\0')
+		{
+			header_text = NULL;
+		}
+		hw->html.header_text = header_text;
+
+		/*
+		 * Parse the header text with the HTML parser
+		 */
+		hw->html.html_header_objects =
+			HTMLParse(hw->html.html_header_objects,
+			hw->html.header_text);
+	}
+	if (footer_text != NULL)
+	{
+		if (*footer_text == '\0')
+		{
+			footer_text = NULL;
+		}
+		hw->html.footer_text = footer_text;
+
+		/*
+		 * Parse the footer text with the HTML parser
+		 */
+		hw->html.html_footer_objects =
+			HTMLParse(hw->html.html_footer_objects,
+			hw->html.footer_text);
+	}
+
+	/*
+	 * Reformat the new text
+	 */
+	hw->html.max_pre_width = DocumentWidth(hw, hw->html.html_objects);
+	ReformatWindow(hw);
+
+	/*
+	 * If a target anchor is passed, override the element id
+	 * with the id of that anchor.
+	 */
+	if (target_anchor != NULL)
+	{
+		int id;
+
+		id = HTMLAnchorToId(w, target_anchor);
+		if (id != 0)
+		{
+			element_id = id;
+		}
+	}
+
+	/*
+	 * Position text at id specified, or at top if no position
+	 * specified.
+	 * Find the element corrsponding to the id passed in.
+	 */
+	eptr = NULL;
+	if (element_id != 0)
+	{
+		start = hw->html.formatted_elements;
+		while (start != NULL)
+		{
+			if (start->ele_id == element_id)
+			{
+				eptr = start;
+				break;
+			}
+			start = start->next;
+		}
+	}
+	if (eptr == NULL)
+	{
+		newy = 0;
+	}
+	else
+	{
+		newy = eptr->y - 2;
+	}
+	if (newy < 0)
+	{
+		newy = 0;
+	}
+	if (newy > (hw->html.doc_height - (int)hw->html.view_height))
+	{
+		newy = hw->html.doc_height - (int)hw->html.view_height;
+	}
+	if (newy < 0)
+	{
+		newy = 0;
+	}
+	hw->html.scroll_x = 0;
+	hw->html.scroll_y = newy;
+#ifdef DEBUG
+fprintf (stderr, "calling in HTMLSetText\n");
+#endif
+	ConfigScrollBars(hw);
+	ScrollWidgets(hw);
+
+	/*
+	 * Display the new text
+	 */
+	ViewClearAndRefresh(hw);
+
+	/*
+	 * Clear any previous selection
+	 */
+	hw->html.select_start = NULL;
+	hw->html.select_end = NULL;
+	hw->html.sel_start_pos = 0;
+	hw->html.sel_end_pos = 0;
+	hw->html.new_start = NULL;
+	hw->html.new_end = NULL;
+	hw->html.new_start_pos = 0;
+	hw->html.new_end_pos = 0;
+	hw->html.active_anchor = NULL;
+
+        hw->html.cached_tracked_ele = NULL;
+}
+
+
+/*
+ * To use faster TOLOWER as set up in HTMLparse.c
+ */
+#ifdef NOT_ASCII
+#define TOLOWER(x)      (tolower(x))
+#else
+extern char map_table[];
+#define TOLOWER(x)      (map_table[x])
+#endif /* NOT_ASCII */
+
+
+/*
+ * Convenience function to search the text of the HTML document as a single
+ * white space separated string. Linefeeds are converted into spaces.
+ *
+ * Takes a pattern, pointers to the start and end blocks to store the
+ * start and end of the match into.  Start is also used as the location to
+ * start the search from for incremental searching.  If start is an invalid
+ * position (id = 0).  Default start is the beginning of the document for
+ * forward searching, and the end of the document for backwards searching.
+ * The backward and caseless parameters I hope are self-explanatory.
+ *
+ * returns 1 on success
+ *      (and the start and end positions of the match).
+ * returns -1 otherwise (and start and end are unchanged).
+ */
+int
+#ifdef _NO_PROTO
+HTMLSearchText (w, pattern, m_start, m_end, backward, caseless)
+	Widget w;
+	char *pattern;
+	ElementRef *m_start;
+	ElementRef *m_end;
+	int backward;
+	int caseless;
+#else
+HTMLSearchText (Widget w, char *pattern, ElementRef *m_start, ElementRef *m_end,
+		int backward, int caseless)
+#endif
+{
+	HTMLWidget hw = (HTMLWidget)w;
+	int found, equal;
+	char *match;
+	char *tptr;
+	char *mptr;
+	char cval;
+	struct ele_rec *eptr;
+	int s_pos;
+	struct ele_rec *s_eptr;
+	ElementRef s_ref, e_ref;
+	ElementRef *start, *end;
+
+	/*
+	 * If bad parameters are passed, just fail the search
+	 */
+	if ((pattern == NULL)||(*pattern == '\0')||
+	    (m_start == NULL)||(m_end == NULL)) {
+	    return(-1);
+	}
+
+	/*
+	 * If we are caseless, make a lower case copy of the pattern to
+	 * match to use in compares.
+	 *
+	 * remember to free this before returning
+	 */
+	if (caseless) {
+	    match = (char *)malloc(strlen(pattern) + 1);
+	    tptr = pattern;
+	    mptr = match;
+	    while (*tptr != '\0') {
+	        *mptr = (char)TOLOWER((int)*tptr);
+	        mptr++;
+	        tptr++;
+	    }
+	    *mptr = '\0';
+	} else {
+	    match = pattern;
+	}
+
+	/*
+	 * Slimy coding.  I later decided I didn't want to change start and
+	 * end if the search failed.  Rather than changing all the code,
+	 * I just copy it into locals here, and copy it out again if a match
+	 * is found.
+	 */
+	start = &s_ref;
+	end = &e_ref;
+	start->id = m_start->id;
+	start->pos = m_start->pos;
+	end->id = m_end->id;
+	end->pos = m_end->pos;
+
+	/*
+	 * Find the user specified start position.
+	 */
+	if (start->id > 0) {
+	    found = 0;
+	    eptr = hw->html.formatted_elements;
+
+	    while (eptr != NULL) {
+/*	        if (eptr->ele_id > start->id) {*/	  	  /* MF031 */
+	        if ((!backward && eptr->ele_id > start->id) ||
+		    ( backward && eptr->ele_id == start->id)) {
+	                s_eptr = eptr;
+	                found = 1;
+	                break;
+	        }
+	        eptr = eptr->next;
+	    }
+	    /*
+	     * Bad start position, fail them out.
+	     */
+	    if (!found) {
+	        if (caseless) {
+	            free(match);
+	        }
+	        return(-1);
+	    }
+	    /*
+	     * Sanify the start position
+	     */
+	    s_pos = start->pos;
+	    if (s_pos >= s_eptr->edata_len - 1) {
+	        s_pos = s_eptr->edata_len - 2;
+	    }
+	    if (s_pos < 0) {
+	        s_pos = 0;
+	    }
+
+	} else {
+	    /*
+	     * Default search starts at end for backward, and
+	     * beginning for forwards.
+	     */
+	    if (backward) {
+	        s_eptr = hw->html.formatted_elements;
+	        while (s_eptr->next != NULL) {
+	            s_eptr = s_eptr->next;
+	        }
+	        s_pos = s_eptr->edata_len - 2;
+	    } else {
+	        s_eptr = hw->html.formatted_elements;
+	        s_pos = 0;
+	    }
+	}
+
+	if (backward) {
+	    char *mend;
+
+	    /*
+	     * Save the end of match here for easy end to start searching
+	     */
+	    mend = match;
+	    while (*mend != '\0') {
+	        mend++;
+	    }
+	    if (mend > match) {
+	        mend--;
+	    }
+	    found = 0;
+	    equal = 0;
+	    mptr = mend;
+
+	    if (s_eptr != NULL) {
+	        eptr = s_eptr;
+	    } else {
+	        eptr = hw->html.formatted_elements;
+	        while (eptr->next != NULL) {
+	            eptr = eptr->next;
+	        }
+	    }
+
+	    while (eptr != NULL) {
+	        /*
+	         * Skip the special internal text
+	         */
+	        if (eptr->internal == True) {
+	            eptr = eptr->prev;
+	            continue;
+	        }
+
+	        if (eptr->type == E_TEXT) {
+	            tptr = (char *)(eptr->edata + eptr->edata_len - 2);
+	            if (eptr == s_eptr) {
+	                tptr = (char *)(eptr->edata + s_pos);
+	            }
+	            while (tptr >= eptr->edata) {
+	            if (equal) {
+	                if (caseless) {
+	                    cval =(char)TOLOWER((int)*tptr);
+	                } else {
+	                    cval = *tptr;
+	                }
+	                while ((mptr >= match)&&
+	                    (tptr >= eptr->edata)&&
+	                    (cval == *mptr))
+	                {
+	                    tptr--;
+	                    mptr--;
+	                    if (tptr >= eptr->edata) {
+	                        if (caseless) {
+	                            cval =(char)TOLOWER((int)*tptr);
+	                        } else {
+	                            cval = *tptr;
+	                        }
+	                    }
+	                }
+	                if (mptr < match) {
+	                    found = 1;
+	                    start->id = eptr->ele_id;
+	                    start->pos = (int)
+	                        (tptr - eptr->edata + 1);
+	                    break;
+	                } else if (tptr < eptr->edata) {
+	                    break;
+	                } else {
+	                    equal = 0;
+	                }
+	            } else {
+	                mptr = mend;
+	                if (caseless) {
+	                    cval =(char)TOLOWER((int)*tptr);
+	                } else {
+	                    cval = *tptr;
+	                }
+	                while ((tptr >= eptr->edata)&&
+	                    (cval != *mptr))
+	                {
+	                    tptr--;
+	                    if (tptr >= eptr->edata) {
+	                        if (caseless) {
+	                            cval =(char)TOLOWER((int)*tptr);
+	                        } else {
+	                            cval = *tptr;
+	                        }
+	                    }
+	                }
+	                if ((tptr >= eptr->edata)&&
+	                    (cval == *mptr))
+	                {
+	                    equal = 1;
+	                    end->id = eptr->ele_id;
+	                    end->pos = (int)
+	                        (tptr - eptr->edata + 1);
+	                }
+	            }
+	            }
+	        }
+	        /*
+	         * Linefeeds match to single space characters.
+	         */
+	        else if (eptr->type == E_LINEFEED) {
+	            if (equal) {
+	                if (*mptr == ' ') {
+	                    mptr--;
+	                    if (mptr < match) {
+	                        found = 1;
+	                        start->id =eptr->ele_id;
+	                        start->pos = 0;
+	                    }
+	                } else {
+	                    equal = 0;
+	                }
+	            } else {
+	                mptr = mend;
+	                if (*mptr == ' ') {
+	                    equal = 1;
+	                    end->id = eptr->ele_id;
+	                    end->pos = 0;
+	                    mptr--;
+	                    if (mptr < match) {
+	                        found = 1;
+	                        start->id =eptr->ele_id;
+	                        start->pos = 0;
+	                    }
+	                }
+	            }
+	        }
+	        if (found) {
+	            break;
+	        }
+	        eptr = eptr->prev;
+	    }
+	}
+	else /* forward */
+	{
+	    found = 0;
+	    equal = 0;
+	    mptr = match;
+
+	    if (s_eptr != NULL) {
+	        eptr = s_eptr;
+	    } else {
+	        eptr = hw->html.formatted_elements;
+	    }
+
+	    while (eptr != NULL) {
+	        /*
+	         * Skip the special internal text
+	         */
+	        if (eptr->internal == True) {
+	            eptr = eptr->next;
+	            continue;
+	        }
+
+	        if (eptr->type == E_TEXT) {
+	            tptr = eptr->edata;
+	            if (eptr == s_eptr) {
+	                tptr = (char *)(tptr + s_pos);
+	            }
+	            while (*tptr != '\0') {
+	            if (equal) {
+	                if (caseless) {
+	                    cval =(char)TOLOWER((int)*tptr);
+	                } else {
+	                    cval = *tptr;
+	                }
+	                while ((*mptr != '\0')&&
+	                    (cval == *mptr))
+	                {
+	                    tptr++;
+	                    mptr++;
+	                    if (caseless) {
+	                        cval =(char)TOLOWER((int)*tptr);
+	                    } else {
+	                        cval = *tptr;
+	                    }
+	                }
+	                if (*mptr == '\0') {
+	                    found = 1;
+	                    end->id = eptr->ele_id;
+	                    end->pos = (int)
+	                        (tptr - eptr->edata);
+	                    break;
+	                } else if (*tptr == '\0') {
+	                    break;
+	                } else {
+	                    equal = 0;
+	                }
+	            } else {
+	                mptr = match;
+	                if (caseless) {
+	                    cval =(char)TOLOWER((int)*tptr);
+	                } else {
+	                    cval = *tptr;
+	                }
+	                while ((*tptr != '\0')&&
+	                    (cval != *mptr))
+	                {
+	                    tptr++;
+	                    if (caseless) {
+	                        cval =(char)TOLOWER((int)*tptr);
+	                    } else {
+	                        cval = *tptr;
+	                    }
+	                }
+	                if (cval == *mptr) {
+	                    equal = 1;
+	                    start->id = eptr->ele_id;
+	                    start->pos = (int)
+	                        (tptr - eptr->edata);
+	                }
+	            }
+	            }
+	        }
+	        else if (eptr->type == E_LINEFEED) {
+	            if (equal) {
+	                if (*mptr == ' ') {
+	                    mptr++;
+	                    if (*mptr == '\0') {
+	                        found = 1;
+	                        end->id = eptr->ele_id;
+	                        end->pos = 0;
+	                    }
+	                } else {
+	                    equal = 0;
+	                }
+	            } else {
+	                mptr = match;
+	                if (*mptr == ' ') {
+	                    equal = 1;
+	                    start->id = eptr->ele_id;
+	                    start->pos = 0;
+	                    mptr++;
+	                    if (*mptr == '\0') {
+	                        found = 1;
+	                        end->id = eptr->ele_id;
+	                        end->pos = 0;
+	                    }
+	                }
+	            }
+	        }
+	        if (found) {
+	            break;
+	        }
+	        eptr = eptr->next;
+	    }
+	}
+
+	if (found) {
+	    m_start->id = start->id;
+	    m_start->pos = start->pos;
+	    m_end->id = end->id;
+	    m_end->pos = end->pos;
+	}
+
+	if (caseless) {
+	    free(match);
+	}
+
+	if (found) {
+	    return(1);
+	} else {
+	    return(-1);
+	}
+}