Imported nx-X11-3.1.0-1.tar.gznx-X11/3.1.0-1

Summary: Imported nx-X11-3.1.0-1.tar.gz
Keywords:

Imported nx-X11-3.1.0-1.tar.gz
into Git repository

1 files changed, 4164 insertions, 0 deletions

diff --git a/nx-X11/lib/Xaw/Text.c b/nx-X11/lib/Xaw/Text.c
new file mode 100644
index 000000000..7d7dd2e61
--- /dev/null
+++ b/nx-X11/lib/Xaw/Text.c
@@ -0,0 +1,4164 @@
+/* $Xorg: Text.c,v 1.4 2001/02/09 02:03:46 xorgcvs Exp $ */
+
+/***********************************************************
+
+Copyright 1987, 1988, 1994, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+
+Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its 
+documentation for any purpose and without fee is hereby granted, 
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in 
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.  
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+
+/*
+ * Copyright (c) 1998 by The XFree86 Project, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE XFREE86 PROJECT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Except as contained in this notice, the name of the XFree86 Project shall
+ * not be used in advertising or otherwise to promote the sale, use or other
+ * dealings in this Software without prior written authorization from the
+ * XFree86 Project.
+ */
+
+/* $XFree86: xc/lib/Xaw/Text.c,v 3.53tsi Exp $ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <stdio.h>
+#include <X11/IntrinsicP.h>
+#include <X11/StringDefs.h>
+#include <X11/Shell.h>
+#include <X11/Xatom.h>
+#include <X11/Xfuncs.h>
+#include <X11/Xutil.h>
+#include <X11/Xmu/Misc.h>
+#include <X11/Xmu/SysUtil.h>
+#include <X11/Xmu/Xmu.h>
+#include <X11/Xaw/Cardinals.h>
+#include <X11/Xaw/MultiSinkP.h>
+#include <X11/Xaw/TextP.h>
+#include <X11/Xaw/TextSrcP.h>
+#include <X11/Xaw/TextSinkP.h>
+#include <X11/Xaw/Scrollbar.h>
+#include <X11/Xaw/XawImP.h>
+#include <X11/Xaw/XawInit.h>
+#include "Private.h"
+#include "XawI18n.h"
+
+#ifndef MAX_LEN_CT
+#define MAX_LEN_CT	6	/* for sequence: ESC $ ( A \xx \xx */
+#endif
+
+unsigned long FMT8BIT = 0L;
+unsigned long XawFmt8Bit = 0L;
+unsigned long XawFmtWide = 0L;
+
+#define SinkClearToBG		_XawTextSinkClearToBackground
+
+#define SrcScan			XawTextSourceScan
+#define SrcRead			XawTextSourceRead
+#define SrcReplace		XawTextSourceReplace
+#define SrcSearch		XawTextSourceSearch
+#define SrcCvtSel		XawTextSourceConvertSelection
+#define SrcSetSelection		XawTextSourceSetSelection
+
+#define MULTI_CLICK_TIME	500L
+
+#define SRC_CHANGE_NONE		0
+#define SRC_CHANGE_AFTER	1
+#define SRC_CHANGE_BEFORE	2
+#define SRC_CHANGE_OVERLAP	3
+
+#define Superclass (&simpleClassRec)
+
+/*
+ * Compute a the maximum length of a cut buffer that we can pass at any
+ * time.  The 64 allows for the overhead of the Change Property request.
+ */
+#define MAX_CUT_LEN(dpy)  (XMaxRequestSize(dpy) - 64)
+
+#define	ClearWindow(ctx)						     \
+     _XawTextNeedsUpdating((ctx),					     \
+			   (ctx)->text.lt.top,				     \
+			   (ctx)->text.lt.info[ctx->text.lt.lines].position)
+
+/*
+ * Class Methods
+ */
+static void XawTextClassInitialize(void);
+static void XawTextInitialize(Widget, Widget, ArgList, Cardinal*);
+static void XawTextRealize(Widget, XtValueMask*, XSetWindowAttributes*);
+static void XawTextDestroy(Widget);
+static void XawTextResize(Widget);
+static void XawTextExpose(Widget, XEvent*, Region);
+static Boolean XawTextSetValues(Widget, Widget, Widget, ArgList, Cardinal*);
+static void XawTextGetValuesHook(Widget, ArgList, Cardinal*);
+static Bool XawTextChangeSensitive(Widget);
+
+/*
+ * Prototypes
+ */
+static XawTextPosition _BuildLineTable(TextWidget, XawTextPosition, int);
+static void _CreateCutBuffers(Display*);
+static Boolean TextConvertSelection(Widget, Atom*, Atom*, Atom*, XtPointer*,
+				unsigned long*, int*);
+static int CountLines(TextWidget, XawTextPosition, XawTextPosition);
+static void CreateHScrollBar(TextWidget);
+static void CreateVScrollBar(TextWidget);
+static void CvtStringToScrollMode(XrmValuePtr, Cardinal*,
+				  XrmValuePtr, XrmValuePtr);
+static Boolean CvtScrollModeToString(Display*, XrmValue*, Cardinal*,
+				     XrmValue*, XrmValue*, XtPointer*);
+static void CvtStringToWrapMode(XrmValuePtr, Cardinal*,
+				XrmValuePtr, XrmValuePtr);
+static Boolean CvtWrapModeToString(Display*, XrmValue*, Cardinal*,
+				   XrmValue*, XrmValue*, XtPointer*);
+static Boolean CvtStringToJustifyMode(Display*, XrmValue*, Cardinal*,
+				      XrmValue*, XrmValue*, XtPointer*);
+static Boolean CvtJustifyModeToString(Display*, XrmValue*, Cardinal*,
+				      XrmValue*, XrmValue*, XtPointer*);
+static void DestroyHScrollBar(TextWidget);
+static void DestroyVScrollBar(TextWidget);
+#ifndef OLDXAW
+static void DisplayText(Widget, XawTextPosition, XawTextPosition);
+#endif
+static void OldDisplayText(Widget, XawTextPosition, XawTextPosition);
+static void DisplayTextWindow(Widget);
+static void DoCopyArea(TextWidget, int, int, unsigned int, unsigned int,
+		       int, int);
+static void DoSelection(TextWidget, XawTextPosition, Time, Bool);
+static void ExtendSelection(TextWidget, XawTextPosition, Bool);
+static XawTextPosition FindGoodPosition(TextWidget, XawTextPosition);
+static void FlushUpdate(TextWidget);
+static int GetCutBufferNumber(Atom);
+static int GetMaxTextWidth(TextWidget);
+static unsigned int GetWidestLine(TextWidget);
+static void HScroll(Widget, XtPointer, XtPointer);
+static void HJump(Widget, XtPointer, XtPointer);
+static void InsertCursor(Widget, XawTextInsertState);
+static Bool LineAndXYForPosition(TextWidget, XawTextPosition, int*,
+				 int*, int*);
+static int LineForPosition(TextWidget, XawTextPosition);
+static void TextLoseSelection(Widget, Atom*);
+static Bool MatchSelection(Atom, XawTextSelection*);
+static void ModifySelection(TextWidget, XawTextPosition, XawTextPosition);
+static XawTextPosition PositionForXY(TextWidget, int, int);
+static void PositionHScrollBar(TextWidget);
+static void PositionVScrollBar(TextWidget);
+#ifndef OLDXAW
+static int ResolveColumnNumber(TextWidget);
+static int ResolveLineNumber(TextWidget);
+#endif
+static void _SetSelection(TextWidget, XawTextPosition, XawTextPosition,
+			  Atom*, Cardinal);
+static void TextSinkResize(Widget);
+static void UpdateTextInRectangle(TextWidget, XRectangle*);
+static void UpdateTextInLine(TextWidget, int, int, int);
+static void VScroll(Widget, XtPointer, XtPointer);
+static void VJump(Widget, XtPointer, XtPointer);
+
+/*
+ * External
+ */
+void _XawTextAlterSelection(TextWidget,
+			    XawTextSelectionMode, XawTextSelectionAction,
+			    String*, Cardinal*);
+void _XawTextCheckResize(TextWidget);
+void _XawTextClearAndCenterDisplay(TextWidget);
+void _XawTextExecuteUpdate(TextWidget);
+char *_XawTextGetText(TextWidget, XawTextPosition, XawTextPosition);
+void _XawTextPrepareToUpdate(TextWidget);
+int _XawTextReplace(TextWidget, XawTextPosition, XawTextPosition,
+		    XawTextBlock*);
+Atom *_XawTextSelectionList(TextWidget, String*, Cardinal);
+void _XawTextSetScrollBars(TextWidget);
+void _XawTextSetSelection(TextWidget, XawTextPosition, XawTextPosition,
+			  String*, Cardinal);
+void _XawTextVScroll(TextWidget, int);
+void XawTextScroll(TextWidget, int, int);
+void _XawTextSetSource(Widget, Widget, XawTextPosition, XawTextPosition);
+#ifndef OLDXAW
+void _XawTextSetLineAndColumnNumber(TextWidget, Bool);
+#endif
+void _XawTextSourceChanged(Widget, XawTextPosition, XawTextPosition,
+			   XawTextBlock*, int);
+
+/* Not used by other modules, but were extern on previous versions
+ * of the library
+ */
+void _XawTextShowPosition(TextWidget);
+
+/*
+ * From TextAction.c
+ */
+extern void _XawTextZapSelection(TextWidget, XEvent*, Bool);
+
+/*
+ * From TextSrc.c
+ */
+void _XawSourceAddText(Widget, Widget);
+void _XawSourceRemoveText(Widget, Widget, Bool);
+Bool _XawTextSourceNewLineAtEOF(Widget);
+
+/*
+ * From TextSink.c
+ */
+void _XawTextSinkClearToBackground(Widget, int, int, unsigned, unsigned);
+void _XawTextSinkDisplayText(Widget, int, int, XawTextPosition, XawTextPosition,
+			     Bool);
+
+/****************************************************************
+ *
+ * Full class record constant
+ *
+ ****************************************************************/
+/*
+ * From TextTr.c
+ */
+extern char _XawDefaultTextTranslations[];
+
+static XawTextSelectType defaultSelectTypes[] = {
+  XawselectPosition,  XawselectAlphaNumeric, XawselectWord, XawselectLine,
+  XawselectParagraph, XawselectAll,	     XawselectNull,
+};
+
+static XPointer defaultSelectTypesPtr = (XPointer)defaultSelectTypes;
+static Dimension defWidth = 100;
+static Dimension defHeight = DEFAULT_TEXT_HEIGHT;
+
+#define offset(field) XtOffsetOf(TextRec, field)
+static XtResource resources[] = {
+  {
+    XtNwidth,
+    XtCWidth,
+    XtRDimension,
+    sizeof(Dimension),
+    offset(core.width),
+    XtRDimension,
+    (XtPointer)&defWidth
+  },
+  {
+    XtNcursor,
+    XtCCursor,
+    XtRCursor,
+    sizeof(Cursor),
+    offset(simple.cursor),
+    XtRString,
+    "xterm"
+  },
+  {
+    XtNheight,
+    XtCHeight,
+    XtRDimension,
+    sizeof(Dimension),
+    offset(core.height),
+    XtRDimension,
+    (XtPointer)&defHeight
+  },
+  {
+    XtNdisplayPosition,
+    XtCTextPosition,
+    XtRInt,
+    sizeof(XawTextPosition), 
+    offset(text.lt.top),
+    XtRImmediate,
+    (XtPointer)0
+  },
+  {
+    XtNinsertPosition,
+    XtCTextPosition,
+    XtRInt,
+    sizeof(XawTextPosition),
+    offset(text.insertPos),
+    XtRImmediate,
+    (XtPointer)0
+  },
+  {
+    XtNleftMargin,
+    XtCMargin,
+    XtRPosition,
+    sizeof(Position),
+    offset(text.r_margin.left),
+    XtRImmediate,
+    (XtPointer)2
+  },
+  {
+    XtNrightMargin,
+    XtCMargin,
+    XtRPosition,
+    sizeof(Position),
+    offset(text.r_margin.right),
+    XtRImmediate,
+    (XtPointer)4
+  },
+  {
+    XtNtopMargin,
+    XtCMargin,
+    XtRPosition,
+    sizeof(Position),
+    offset(text.r_margin.top),
+    XtRImmediate,
+    (XtPointer)2
+  },
+  {
+    XtNbottomMargin,
+    XtCMargin,
+    XtRPosition,
+    sizeof(Position),
+    offset(text.r_margin.bottom),
+    XtRImmediate,
+    (XtPointer)2
+  },
+  {
+    XtNselectTypes,
+    XtCSelectTypes,
+    XtRPointer,
+    sizeof(XawTextSelectType*),
+    offset(text.sarray),
+    XtRPointer,
+    (XtPointer)&defaultSelectTypesPtr
+  },
+  {
+    XtNtextSource,
+    XtCTextSource,
+    XtRWidget,
+    sizeof(Widget),
+    offset(text.source),
+    XtRImmediate,
+    NULL
+  },
+  {
+    XtNtextSink,
+    XtCTextSink,
+    XtRWidget,
+    sizeof(Widget),
+    offset(text.sink),
+    XtRImmediate,
+    NULL
+  },
+  {
+    XtNdisplayCaret,
+    XtCOutput,
+    XtRBoolean,
+    sizeof(Boolean),
+    offset(text.display_caret),
+    XtRImmediate,
+    (XtPointer)True
+  },
+  {
+    XtNscrollVertical,
+    XtCScroll,
+    XtRScrollMode,
+    sizeof(XawTextScrollMode),
+    offset(text.scroll_vert),
+    XtRImmediate,
+    (XtPointer)False
+  },
+  {
+    XtNscrollHorizontal,
+    XtCScroll,
+    XtRScrollMode,
+    sizeof(XawTextScrollMode),
+    offset(text.scroll_horiz),
+    XtRImmediate,
+    (XtPointer)False
+  },
+  {
+    XtNwrap,
+    XtCWrap,
+    XtRWrapMode,
+    sizeof(XawTextWrapMode),
+    offset(text.wrap),
+    XtRImmediate,
+    (XtPointer)XawtextWrapNever
+  },
+  {
+    XtNautoFill,
+    XtCAutoFill,
+    XtRBoolean,
+    sizeof(Boolean),
+    offset(text.auto_fill),
+    XtRImmediate,
+    (XtPointer)False
+  },
+#ifndef OLDXAW
+  {
+    XtNpositionCallback,
+    XtCCallback,
+    XtRCallback,
+    sizeof(XtPointer),
+    offset(text.position_callbacks),
+    XtRCallback,
+    NULL
+  },
+  {
+    XtNleftColumn,
+    XtCColumn,
+    XtRShort,
+    sizeof(short),
+    offset(text.left_column),
+    XtRImmediate,
+    (XtPointer)0
+  },
+  {
+    XtNrightColumn,
+    XtCColumn,
+    XtRShort,
+    sizeof(short),
+    offset(text.right_column),
+    XtRImmediate,
+    (XtPointer)0
+  },
+  {
+    XtNjustifyMode,
+    XtCJustifyMode,
+    XtRJustifyMode,
+    sizeof(XawTextJustifyMode),
+    offset(text.justify),
+    XtRImmediate,
+    (XtPointer)XawjustifyLeft
+  },
+#endif /* OLDXAW */
+};
+#undef offset
+
+#define done(address, type) \
+	{ toVal->size = sizeof(type); toVal->addr = (XPointer)address; }
+
+static XrmQuark QWrapNever, QWrapLine, QWrapWord;
+#ifndef notdef
+static XrmQuark QScrollNever, QScrollWhenNeeded, QScrollAlways;
+#endif
+static XrmQuark QJustifyLeft, QJustifyRight, QJustifyCenter, QJustifyFull;
+
+/*ARGSUSED*/
+static void
+CvtStringToScrollMode(XrmValuePtr args, Cardinal *num_args,
+		      XrmValuePtr fromVal, XrmValuePtr toVal)
+{
+    static XawTextScrollMode scrollMode = XawtextScrollNever;
+    XrmQuark q;
+    char name[32];
+
+    XmuNCopyISOLatin1Lowered(name, (char *)fromVal->addr, sizeof(name));
+    q = XrmStringToQuark(name);
+
+    if (q == QScrollNever || q == QScrollWhenNeeded)
+	scrollMode = XawtextScrollNever;
+    else if (q == QScrollAlways)
+	scrollMode = XawtextScrollAlways;
+    else if (strcmp(name, "true") == 0 || strcmp(name, "1") == 0)
+	scrollMode = XawtextScrollAlways;
+    else if (strcmp(name, "false") == 0 || strcmp(name, "0") == 0)
+	scrollMode = XawtextScrollNever;
+    else
+	XtStringConversionWarning((char *)fromVal->addr, XtRScrollMode);
+
+    done(&scrollMode, XawTextScrollMode);
+}
+
+/*ARGSUSED*/
+static Boolean
+CvtScrollModeToString(Display *dpy, XrmValue *args, Cardinal *num_args,
+		      XrmValue *fromVal, XrmValue *toVal, XtPointer *data)
+{
+    static char *buffer;
+    Cardinal size;
+
+    switch (*(XawTextScrollMode *)fromVal->addr) {
+	case XawtextScrollNever:
+	case XawtextScrollWhenNeeded:
+	    buffer = XtEtextScrollNever;
+	    break;
+	case XawtextScrollAlways:
+	    buffer = XtEtextScrollAlways;
+	    break;
+	default:
+	    XawTypeToStringWarning(dpy, XtRScrollMode);
+	    toVal->addr = NULL;
+	    toVal->size = 0;
+	    return (False);
+    }
+    size = strlen(buffer) + 1;
+    if (toVal->addr != NULL) {
+	if (toVal->size < size)	{
+	    toVal->size = size;
+	    return (False);
+	}
+	strcpy((char *)toVal->addr, buffer);
+    }
+    else
+	toVal->addr = (XPointer)buffer;
+    toVal->size = sizeof(String);
+
+    return (True);
+}
+
+/*ARGSUSED*/
+static void
+CvtStringToWrapMode(XrmValuePtr args, Cardinal *num_args,
+		    XrmValuePtr fromVal, XrmValuePtr toVal)
+{
+    static XawTextWrapMode wrapMode = XawtextWrapNever;
+    XrmQuark q;
+    char lowerName[6];
+
+    XmuNCopyISOLatin1Lowered(lowerName, (char *)fromVal->addr,
+			     sizeof(lowerName));
+    q = XrmStringToQuark(lowerName);
+
+    if (q == QWrapNever)
+	wrapMode = XawtextWrapNever;
+    else if (q == QWrapLine)
+	wrapMode = XawtextWrapLine;
+    else if (q == QWrapWord)
+	wrapMode = XawtextWrapWord;
+    else
+	XtStringConversionWarning((char *)fromVal->addr, XtRWrapMode);
+
+    done(&wrapMode, XawTextWrapMode);
+}
+
+/*ARGSUSED*/
+static Boolean
+CvtWrapModeToString(Display *dpy, XrmValue *args, Cardinal *num_args,
+		    XrmValue *fromVal, XrmValue *toVal, XtPointer *data)
+{
+    static char *buffer;
+    Cardinal size;
+
+    switch (*(XawTextWrapMode *)fromVal->addr) {
+	case XawtextWrapNever:
+	    buffer = XtEtextWrapNever;
+	    break;
+	case XawtextWrapLine:
+	    buffer = XtEtextWrapLine;
+	    break;
+	case XawtextWrapWord:
+	    buffer = XtEtextWrapWord;
+	    break;
+	default:
+	    XawTypeToStringWarning(dpy, XtRWrapMode);
+	    toVal->addr = NULL;
+	    toVal->size = 0;
+	    return (False);
+    }
+    size = strlen(buffer) + 1;
+    if (toVal->addr != NULL) {
+	if (toVal->size < size)	{
+	    toVal->size = size;
+	    return (False);
+	}
+	strcpy((char *)toVal->addr, buffer);
+    }
+    else
+	toVal->addr = (XPointer)buffer;
+    toVal->size = sizeof(String);
+
+    return (True);
+}
+
+/*ARGSUSED*/
+static Boolean
+CvtStringToJustifyMode(Display *dpy, XrmValue *args, Cardinal *num_args,
+		       XrmValue *fromVal, XrmValue *toVal, XtPointer *data)
+{
+    XawTextJustifyMode justify;
+    XrmQuark q;
+    char lowerName[8];
+
+    XmuNCopyISOLatin1Lowered(lowerName, (char *)fromVal->addr,
+			   sizeof(lowerName));
+    q = XrmStringToQuark(lowerName);
+
+    if (q == QJustifyLeft)
+	justify = XawjustifyLeft;
+    else if (q == QJustifyRight)
+	justify = XawjustifyRight;
+    else if (q == QJustifyCenter)
+	justify = XawjustifyCenter;
+    else if(q ==  QJustifyFull)
+	justify = XawjustifyFull;
+    else {
+	XtStringConversionWarning((char *)fromVal->addr, XtRJustifyMode);
+	return (False);
+    }
+
+    toVal->size = sizeof(XawTextJustifyMode);
+    *(XawTextJustifyMode *)(toVal->addr) = justify;
+
+    return (True);
+}
+
+
+/*ARGSUSED*/
+static Boolean
+CvtJustifyModeToString(Display *dpy, XrmValue *args, Cardinal *num_args,
+		       XrmValue *fromVal, XrmValue *toVal, XtPointer *data)
+{
+    static char *buffer;
+    Cardinal size;
+
+    switch (*(XawTextJustifyMode *)fromVal->addr) {
+	case XawjustifyLeft:
+	    buffer = XtEtextJustifyLeft;
+	    break;
+	case XawjustifyRight:
+	    buffer = XtEtextJustifyRight;
+	    break;
+	case XawjustifyCenter:
+	    buffer = XtEtextJustifyCenter;
+	    break;
+	case XawjustifyFull:
+	    buffer = XtEtextJustifyFull;
+	    break;
+	default:
+	    XawTypeToStringWarning(dpy, XtRJustifyMode);
+	    toVal->addr = NULL;
+	    toVal->size = 0;
+	    return (False);
+    }
+    size = strlen(buffer) + 1;
+    if (toVal->addr != NULL) {
+	if (toVal->size < size)	{
+	    toVal->size = size;
+	    return (False);
+	}
+	strcpy((char *)toVal->addr, buffer);
+    }
+    else
+	toVal->addr = (XPointer)buffer;
+    toVal->size = sizeof(String);
+
+    return (True);
+}
+
+#undef done
+
+static void
+XawTextClassInitialize(void)
+{
+    if (!XawFmt8Bit)
+	FMT8BIT = XawFmt8Bit = XrmPermStringToQuark("FMT8BIT");
+    if (!XawFmtWide)
+	XawFmtWide = XrmPermStringToQuark("FMTWIDE");
+
+    XawInitializeWidgetSet();
+
+    textClassRec.core_class.num_actions = _XawTextActionsTableCount;
+  
+    QWrapNever	= XrmPermStringToQuark(XtEtextWrapNever);
+    QWrapLine	= XrmPermStringToQuark(XtEtextWrapLine);
+    QWrapWord	= XrmPermStringToQuark(XtEtextWrapWord);
+    XtAddConverter(XtRString, XtRWrapMode, CvtStringToWrapMode, NULL, 0);
+    XtSetTypeConverter(XtRWrapMode, XtRString, CvtWrapModeToString,
+		       NULL, 0, XtCacheNone, NULL);
+    QScrollNever = XrmPermStringToQuark(XtEtextScrollNever);
+    QScrollWhenNeeded = XrmPermStringToQuark(XtEtextScrollWhenNeeded);
+    QScrollAlways = XrmPermStringToQuark(XtEtextScrollAlways);
+    XtAddConverter(XtRString, XtRScrollMode, CvtStringToScrollMode,
+		   NULL, 0);
+    XtSetTypeConverter(XtRScrollMode, XtRString, CvtScrollModeToString,
+		       NULL, 0, XtCacheNone, NULL);
+    QJustifyLeft   = XrmPermStringToQuark(XtEtextJustifyLeft);
+    QJustifyRight  = XrmPermStringToQuark(XtEtextJustifyRight);
+    QJustifyCenter = XrmPermStringToQuark(XtEtextJustifyCenter);
+    QJustifyFull   = XrmPermStringToQuark(XtEtextJustifyFull);
+    XtSetTypeConverter(XtRString, XtRJustifyMode, CvtStringToJustifyMode,
+		       NULL, 0, XtCacheNone, NULL);
+    XtSetTypeConverter(XtRJustifyMode, XtRString, CvtJustifyModeToString,
+		       NULL, 0, XtCacheNone, NULL);
+}
+
+/*
+ * Function:
+ *	PositionHScrollBar
+ *
+ * Parameters:
+ *	ctx - text widget
+ *
+ * Description:
+ *	Positions the Horizontal scrollbar.
+ */
+static void
+PositionHScrollBar(TextWidget ctx)
+{
+    Widget hbar = ctx->text.hbar, vbar = ctx->text.vbar;
+    Position x, y;
+    Dimension width, height;
+
+    if (ctx->text.hbar == NULL)
+	return;
+
+    if (vbar != NULL)
+	x = XtWidth(vbar);
+    else
+	x = -XtBorderWidth(hbar);
+    y = XtHeight(ctx) - XtHeight(hbar) - XtBorderWidth(hbar);
+    if (vbar != NULL) {
+	width = XtWidth(ctx) - XtWidth(vbar) - XtBorderWidth(vbar);
+	if (width > XtWidth(ctx))
+	    width = XtWidth(ctx);
+    }
+    else
+	width = XtWidth(ctx);
+    height = XtHeight(hbar);
+
+    XtConfigureWidget(hbar, x, y, width, height, XtBorderWidth(hbar));
+}
+
+/*
+ * Function:
+ *	PositionVScrollBar
+ *
+ * Parameters:
+ *	ctx - text widget
+ *
+ * Description:
+ *	Positions the Vertical scrollbar.
+ */
+static void
+PositionVScrollBar(TextWidget ctx)
+{
+    Widget vbar = ctx->text.vbar;
+    Position x, y;
+    Dimension width, height;
+
+    if (vbar == NULL)
+	return;
+
+    x = y = -XtBorderWidth(vbar);
+    height = XtHeight(ctx);
+    width = XtWidth(vbar);
+
+    XtConfigureWidget(vbar, x, y, width, height, XtBorderWidth(vbar));
+}
+
+static void
+CreateVScrollBar(TextWidget ctx)
+{
+    Widget vbar;
+
+    if (ctx->text.vbar != NULL)
+	return;
+
+    ctx->text.vbar = vbar =
+	XtCreateWidget("vScrollbar", scrollbarWidgetClass, (Widget)ctx, NULL, 0);
+    XtAddCallback(vbar, XtNscrollProc, VScroll, (XtPointer)ctx);
+    XtAddCallback(vbar, XtNjumpProc, VJump, (XtPointer)ctx);
+
+    ctx->text.r_margin.left += XtWidth(vbar) + XtBorderWidth(vbar);
+    ctx->text.left_margin = ctx->text.margin.left = ctx->text.r_margin.left;
+
+    PositionVScrollBar(ctx);
+    PositionHScrollBar(ctx);
+    TextSinkResize(ctx->text.sink);
+
+    if (XtIsRealized((Widget)ctx)) {
+	XtRealizeWidget(vbar);
+	XtMapWidget(vbar);
+    }
+    XtSetKeyboardFocus(vbar, (Widget)ctx);
+}
+
+/*
+ * Function:
+ *	DestroyVScrollBar
+ *
+ * Parameters:
+ *	ctx - parent text widget
+ *
+ * Description:
+ *	Removes vertical ScrollBar.
+ */
+static void
+DestroyVScrollBar(TextWidget ctx)
+{
+    Widget vbar = ctx->text.vbar;
+
+    if (vbar == NULL)
+	return;
+
+    ctx->text.r_margin.left -= XtWidth(vbar) + XtBorderWidth(vbar);
+    ctx->text.left_margin = ctx->text.margin.left = ctx->text.r_margin.left;
+
+    XtDestroyWidget(vbar);
+    ctx->text.vbar = NULL;
+    if (!ctx->core.being_destroyed) {
+	PositionHScrollBar(ctx);
+	TextSinkResize(ctx->text.sink);
+    }
+}
+
+static void
+CreateHScrollBar(TextWidget ctx)
+{
+    Arg args[1];
+    Widget hbar;
+    int bottom;
+
+    if (ctx->text.hbar != NULL)
+	return;
+
+    XtSetArg(args[0], XtNorientation, XtorientHorizontal);
+    ctx->text.hbar = hbar =
+	XtCreateWidget("hScrollbar", scrollbarWidgetClass, (Widget)ctx, args, 1);
+    XtAddCallback(hbar, XtNscrollProc, HScroll, (XtPointer)ctx);
+    XtAddCallback(hbar, XtNjumpProc, HJump, (XtPointer)ctx);
+
+    bottom = ctx->text.r_margin.bottom + XtHeight(hbar) + XtBorderWidth(hbar);
+
+    ctx->text.margin.bottom = ctx->text.r_margin.bottom = bottom;
+
+    PositionHScrollBar(ctx);
+    TextSinkResize(ctx->text.sink);
+
+    if (XtIsRealized((Widget)ctx)) {
+	XtRealizeWidget(hbar);
+	XtMapWidget(hbar);
+    }
+    XtSetKeyboardFocus(hbar, (Widget)ctx);
+}
+
+/*
+ * Function:
+ *	DestroyHScrollBar
+ *
+ * Parameters:
+ *	ctx - parent text widget
+ *
+ * Description:
+ *	Removes horizontal ScrollBar.
+ */
+static void
+DestroyHScrollBar(TextWidget ctx)
+{
+    Widget hbar = ctx->text.hbar;
+
+    if (hbar == NULL)
+	return;
+
+    ctx->text.r_margin.bottom -= XtHeight(hbar) + XtBorderWidth(hbar);
+    ctx->text.margin.bottom = ctx->text.r_margin.bottom;
+
+    XtDestroyWidget(hbar);
+    ctx->text.hbar = NULL;
+    if (!ctx->core.being_destroyed)
+	TextSinkResize(ctx->text.sink);
+}
+
+/*ARGSUSED*/
+static void
+XawTextInitialize(Widget request, Widget cnew,
+		  ArgList args, Cardinal *num_args)
+{
+    TextWidget ctx = (TextWidget)cnew;
+
+    ctx->text.lt.lines = 0;
+    ctx->text.lt.info = (XawTextLineTableEntry *)
+	XtCalloc(1, sizeof(XawTextLineTableEntry));
+#ifndef OLDXAW
+    ctx->text.lt.base_line = 1;
+#endif
+    (void)bzero(&ctx->text.origSel, sizeof(XawTextSelection));
+    (void)bzero(&ctx->text.s, sizeof(XawTextSelection));
+    ctx->text.s.type = XawselectPosition;
+    ctx->text.salt = NULL;
+    ctx->text.hbar = ctx->text.vbar = NULL;
+    ctx->text.lasttime = 0;
+    ctx->text.time = 0;
+    ctx->text.showposition = True;
+    ctx->text.lastPos = ctx->text.source != NULL ?
+			XawTextGetLastPosition(ctx) : 0;
+    ctx->text.file_insert = NULL;
+    ctx->text.search = NULL;
+    ctx->text.update = XmuNewScanline(0, 0, 0);
+    ctx->text.gc = XtGetGC(cnew, 0, 0);
+    ctx->text.hasfocus = False;
+    ctx->text.margin = ctx->text.r_margin; /* Strucure copy */
+    ctx->text.left_margin = ctx->text.r_margin.left;
+    ctx->text.update_disabled = False;
+    ctx->text.clear_to_eol = True;
+    ctx->text.old_insert = -1;
+    ctx->text.mult = 1;
+    ctx->text.salt2 = NULL;
+    ctx->text.from_left = -1;
+
+#ifndef OLDXAW
+    ctx->text.numeric = False;
+    ctx->text.selection_state = False;
+    ctx->text.kill_ring = 0;
+
+    ctx->text.line_number = -1;
+    ctx->text.column_number = -1;
+    ctx->text.source_changed = SRC_CHANGE_NONE;
+
+    ctx->text.kill_ring_ptr = NULL;
+    ctx->text.overwrite = False;
+#endif
+
+    if (XtHeight(ctx) == DEFAULT_TEXT_HEIGHT) {
+	XtHeight(ctx) = VMargins(ctx);
+	if (ctx->text.sink != NULL)
+	    XtHeight(ctx) += XawTextSinkMaxHeight(ctx->text.sink, 1);
+    }
+
+    if (ctx->text.scroll_vert == XawtextScrollAlways)
+	CreateVScrollBar(ctx);
+    if (ctx->text.scroll_horiz == XawtextScrollAlways)
+	CreateHScrollBar(ctx);
+
+#ifndef OLDXAW
+    if (ctx->text.left_column < 0)
+	ctx->text.left_column = 0;
+    if (ctx->text.right_column < 0)
+	ctx->text.right_column = 0;
+#endif
+}
+
+static void
+XawTextRealize(Widget w, XtValueMask *mask, XSetWindowAttributes *attr)
+{
+    TextWidget ctx = (TextWidget)w;
+
+    (*textClassRec.core_class.superclass->core_class.realize)(w, mask, attr);
+  
+    if (ctx->text.hbar != NULL) {
+	XtRealizeWidget(ctx->text.hbar);
+	XtMapWidget(ctx->text.hbar);
+    }
+
+    if (ctx->text.vbar != NULL) {
+	XtRealizeWidget(ctx->text.vbar);
+	XtMapWidget(ctx->text.vbar);
+    }
+
+    _XawTextBuildLineTable(ctx, ctx->text.lt.top, True);
+
+#ifndef OLDXAW
+    _XawTextSetLineAndColumnNumber(ctx, True);
+#endif
+}
+
+/* Utility routines for support of Text */
+static void
+_CreateCutBuffers(Display *d)
+{
+    static struct _DisplayRec {
+	struct _DisplayRec *next;
+	Display *dpy;
+    } *dpy_list = NULL;
+    struct _DisplayRec *dpy_ptr;
+
+    for (dpy_ptr = dpy_list; dpy_ptr != NULL; dpy_ptr = dpy_ptr->next)
+	if (dpy_ptr->dpy == d)
+	    return;
+
+    dpy_ptr = XtNew(struct _DisplayRec);
+    dpy_ptr->next = dpy_list;
+    dpy_ptr->dpy = d;
+    dpy_list = dpy_ptr;
+
+#define Create(buffer) \
+  XChangeProperty(d, RootWindow(d, 0), buffer, XA_STRING, 8, \
+		  PropModeAppend, NULL, 0);
+
+    Create(XA_CUT_BUFFER0);
+    Create(XA_CUT_BUFFER1);
+    Create(XA_CUT_BUFFER2);
+    Create(XA_CUT_BUFFER3);
+    Create(XA_CUT_BUFFER4);
+    Create(XA_CUT_BUFFER5);
+    Create(XA_CUT_BUFFER6);
+    Create(XA_CUT_BUFFER7);
+
+#undef Create
+}
+
+/*
+ * Procedure to manage insert cursor visibility for editable text.  It uses
+ * the value of ctx->insertPos and an implicit argument. In the event that
+ * position is immediately preceded by an eol graphic, then the insert cursor
+ * is displayed at the beginning of the next line.
+ */
+static void
+InsertCursor(Widget w, XawTextInsertState state)
+{
+    TextWidget ctx = (TextWidget)w;
+    int x, y;
+    int line;
+
+    if (ctx->text.lt.lines < 1)
+	return;
+
+    if (ctx->text.display_caret &&
+	LineAndXYForPosition(ctx, ctx->text.insertPos, &line, &x, &y)) {
+	if (line < ctx->text.lt.lines)
+	    y += (ctx->text.lt.info[line + 1].y - ctx->text.lt.info[line].y) + 1;
+	else
+	    y += (ctx->text.lt.info[line].y - ctx->text.lt.info[line - 1].y) + 1;
+
+	XawTextSinkInsertCursor(ctx->text.sink, x, y, state);
+    }
+
+    /* Keep Input Method up to speed  */
+    if (ctx->simple.international) {
+	Arg list[1];
+
+	XtSetArg(list[0], XtNinsertPosition, ctx->text.insertPos);
+	_XawImSetValues(w, list, 1);
+    }
+}
+
+/*
+ * Procedure to register a span of text that is no longer valid on the display
+ * It is used to avoid a number of small, and potentially overlapping, screen
+ * updates.
+*/
+void
+_XawTextNeedsUpdating(TextWidget ctx,
+		      XawTextPosition left, XawTextPosition right)
+{
+    XmuSegment segment;
+
+    if (left >= right)
+	return;
+
+    segment.x1 = (int)left;
+    segment.x2 = (int)right;
+    (void)XmuScanlineOrSegment(ctx->text.update, &segment);
+}
+
+/*
+ * Procedure to read a span of text in Ascii form. This is purely a hack and
+ * we probably need to add a function to sources to provide this functionality.
+ * [note: this is really a private procedure but is used in multiple modules].
+ */
+char *
+_XawTextGetText(TextWidget ctx, XawTextPosition left, XawTextPosition right)
+{
+    char *result, *tempResult;
+    XawTextBlock text;
+    int bytes;
+
+    if (XawTextFormat(ctx, XawFmt8Bit))
+	bytes = sizeof(unsigned char);
+    else if (XawTextFormat(ctx, XawFmtWide)) 
+	bytes = sizeof(wchar_t);
+    else /* if there is another fomat, add here */
+	bytes = 1;
+
+    /* leave space for ZERO */
+    tempResult = result = XtMalloc((unsigned)(right - left + ONE) * bytes);
+
+    while (left < right) {
+	left = SrcRead(ctx->text.source, left, &text, (int)(right - left));
+	if (!text.length)
+	    break;
+	memmove(tempResult, text.ptr, (unsigned)(text.length * bytes));
+	tempResult += text.length * bytes;
+    }
+
+    if (bytes == sizeof(wchar_t))
+	*((wchar_t*)tempResult) = (wchar_t)0;
+    else
+	*tempResult = '\0';
+
+    return (result);
+}
+
+/* Like _XawTextGetText, but enforces ICCCM STRING type encoding.  This
+ * routine is currently used to put just the ASCII chars in the selection
+ * into a cut buffer.
+ */
+char *
+_XawTextGetSTRING(TextWidget ctx, XawTextPosition left, XawTextPosition right)
+{
+    unsigned char *s;
+    unsigned char c;
+    long i, j, n;
+    wchar_t *ws, wc;
+
+    /* allow ESC in accordance with ICCCM */
+    if (XawTextFormat(ctx, XawFmtWide)) {
+	MultiSinkObject sink = (MultiSinkObject)ctx->text.sink;
+	ws = (wchar_t *)_XawTextGetText(ctx, left, right);
+	n = wcslen(ws);
+	for (j = 0, i = 0; j < n; j++) {
+	    wc = ws[j];
+	    if (XwcTextEscapement (sink->multi_sink.fontset, &wc, 1)
+		|| (wc == _Xaw_atowc(XawTAB)) || (wc == _Xaw_atowc(XawLF))
+		|| (wc == _Xaw_atowc(XawESC)))
+		ws[i++] = wc;
+	}
+	ws[i] = (wchar_t)0;
+	return ((char *)ws);
+    }
+    else {
+	s = (unsigned char *)_XawTextGetText(ctx, left, right);
+	/* only HT and NL control chars are allowed, strip out others */
+	n = strlen((char *)s);
+	i = 0;
+	for (j = 0; j < n; j++)	{
+	    c = s[j];
+	    if (((c >= 0x20) && c <= 0x7f)
+		||(c >= 0xa0) || (c == XawTAB) || (c == XawLF)
+		|| (c == XawESC)) {
+		s[i] = c;
+		i++;
+	    }
+	}
+	s[i] = 0;
+
+	return ((char *)s);
+    }
+}
+
+/* 
+ * This routine maps an x and y position in a window that is displaying text
+ * into the corresponding position in the source.
+ */
+static XawTextPosition
+PositionForXY(TextWidget ctx, int x, int y)
+{
+    int fromx, line, width, height;
+    XawTextPosition position;
+
+    if (ctx->text.lt.lines == 0)
+	return (0);
+
+    for (line = 0; line < ctx->text.lt.lines - 1; line++) {
+	if (y <= ctx->text.lt.info[line + 1].y)
+	    break;
+    }
+    position = ctx->text.lt.info[line].position;
+    if (position >= ctx->text.lastPos)
+	return (ctx->text.lastPos);
+    fromx = ctx->text.left_margin;
+    XawTextSinkFindPosition(ctx->text.sink, position, fromx, x - fromx,
+			    False, &position, &width, &height);
+
+    if (position > ctx->text.lastPos)
+	return (ctx->text.lastPos);
+
+    if (position >= ctx->text.lt.info[line + 1].position)
+	position = SrcScan(ctx->text.source, ctx->text.lt.info[line + 1].position,
+			   XawstPositions, XawsdLeft, 1, True);
+
+    return (position);
+}
+
+/*
+ * This routine maps a source position in to the corresponding line number
+ * of the text that is displayed in the window.
+ */
+static int
+LineForPosition(TextWidget ctx, XawTextPosition position)
+{
+    int line;
+
+    for (line = 0; line < ctx->text.lt.lines; line++)
+	if (position < ctx->text.lt.info[line + 1].position)
+	    break;
+
+    return (line);
+}
+
+/*
+ * This routine maps a source position into the corresponding line number
+ * and the x, y coordinates of the text that is displayed in the window.
+ */
+static Bool
+LineAndXYForPosition(TextWidget ctx, XawTextPosition pos,
+		     int *line, int *x, int *y)
+{
+    XawTextPosition linePos, endPos;
+    Boolean visible;
+    int realW, realH;
+
+    *line = 0;
+    *x = ctx->text.left_margin;
+    *y = ctx->text.margin.top + 1;
+    if ((visible = IsPositionVisible(ctx, pos)) != False) {
+	*line = LineForPosition(ctx, pos);
+	*y = ctx->text.lt.info[*line].y;
+	linePos = ctx->text.lt.info[*line].position;
+	XawTextSinkFindDistance(ctx->text.sink, linePos,
+				*x, pos, &realW, &endPos, &realH);
+	*x += realW;
+    }
+
+    return (visible);
+}
+
+/*
+ * This routine builds a line table. It does this by starting at the
+ * specified position and measuring text to determine the staring position
+ * of each line to be displayed. It also determines and saves in the
+ * linetable all the required metrics for displaying a given line (e.g.
+ * x offset, y offset, line length, etc.).
+ */
+void
+_XawTextBuildLineTable(TextWidget ctx, XawTextPosition position,
+		       _XtBoolean force_rebuild)
+{
+    Dimension height = 0;
+    int lines = 0;
+    Cardinal size;
+
+    if ((int)XtHeight(ctx) > VMargins(ctx)) {
+	height = XtHeight(ctx) - VMargins(ctx);
+	lines = XawTextSinkMaxLines(ctx->text.sink, height);
+    }
+    size = sizeof(XawTextLineTableEntry) * (lines + 1);
+
+    if (lines != ctx->text.lt.lines || ctx->text.lt.info == NULL) {
+	ctx->text.lt.info = (XawTextLineTableEntry *)
+	    XtRealloc((char *)ctx->text.lt.info, size);
+	ctx->text.lt.lines = lines;
+	force_rebuild = True;
+    }
+
+    if (force_rebuild) {
+	(void)bzero((char *)ctx->text.lt.info, size);
+	/* force a text update in the first text line if it is visible */
+	ctx->text.lt.info[0].position = (XawTextPosition)-1;
+    }
+    if (position != ctx->text.lt.info[0].position) {
+	(void)_BuildLineTable(ctx, position, 0);
+	ctx->text.clear_to_eol = True;
+    }
+}
+
+/*
+ * We may need to resize the line table here, since there maybe lines with
+ * different fonts (that can be shorter or taller than the default one)
+ */
+static XawTextPosition
+_BuildLineTable(TextWidget ctx, XawTextPosition position, int line)
+{
+    XawTextLineTableEntry *lt = ctx->text.lt.info + line;
+    XawTextPosition end, update_from = -1;
+    Position y;
+    int wwidth, width, height;
+#ifndef OLDXAW
+    Widget src = ctx->text.source;
+#endif
+    int max_y = (int)XtHeight(ctx) - (int)ctx->text.margin.bottom;
+
+    if (ctx->text.wrap == XawtextWrapNever)
+	wwidth = 0x7fffffff;
+    else
+	wwidth = GetMaxTextWidth(ctx);
+
+    /* XXX y may change, due to font size changes. See later */
+    y = line == 0 ? ctx->text.margin.top : lt->y;
+
+#ifndef OLDXAW
+    if (ctx->text.lt.base_line < 0) {
+	if (line == 0)
+	    ctx->text.lt.top = position;
+    }
+    else if (line == 0) {
+	XawTextPosition pos = ctx->text.lt.top;
+	int base_line = ctx->text.lt.base_line;
+
+	if (position == 0)
+	    base_line = 1;
+	else if (ctx->text.lt.base_line == 0 ||
+		 ctx->text.source_changed == SRC_CHANGE_OVERLAP) {
+	    pos = 0;
+	    base_line = 1;
+
+	    while (pos < position) {
+		pos = SrcScan(src, pos, XawstEOL, XawsdRight, 1, True);
+		if (pos <= position) {
+		    ++base_line;
+		    if (pos == ctx->text.lastPos) {
+			base_line -= !_XawTextSourceNewLineAtEOF(src);
+			break;
+		    }
+		}
+	    }
+	}
+	else if (ctx->text.wrap == XawtextWrapNever
+		 && IsPositionVisible(ctx, position))
+	    base_line += LineForPosition(ctx, position);
+	else if (pos < position) {
+	    while (pos < position) {
+		pos = SrcScan(src, pos, XawstEOL, XawsdRight, 1, True);
+		if (pos <= position) {
+		    ++base_line;
+		    if (pos == ctx->text.lastPos) {
+			base_line -= !_XawTextSourceNewLineAtEOF(src);
+			break;
+		    }
+		}
+	    }
+	}
+	else if (pos > position) {
+	    while (pos > position) {
+		pos = SrcScan(src, pos, XawstEOL, XawsdLeft, 1, False);
+		if (--pos >= position)
+		    --base_line;
+	    }
+	}
+
+	ctx->text.lt.top = position;
+	ctx->text.lt.base_line = base_line;
+    }
+#else
+    if (line == 0)
+	ctx->text.lt.top = position;
+#endif
+
+    /* CONSTCOND */
+    while (True) {
+	XawTextSinkFindPosition(ctx->text.sink, position, ctx->text.left_margin,
+				wwidth, ctx->text.wrap == XawtextWrapWord,
+				&end, &width, &height);
+
+	if (lt->position != position) {
+	    _XawTextNeedsUpdating(ctx, position,
+				  end <= position ? position + 1 : end);
+	    ctx->text.clear_to_eol = True;
+	    lt->position = position;
+	}
+	if (lt->y != y) {
+	    if (update_from < 0)
+		update_from = line == 0 ?
+		    ctx->text.lt.info[0].position :
+		    ctx->text.lt.info[line - 1].position;
+	    lt->y = y;
+	    ctx->text.clear_to_eol = True;
+	}
+	if (lt->textWidth != width) {
+	    if (lt->textWidth > width)
+		ctx->text.clear_to_eol = True;
+	    lt->textWidth = width;
+	}
+	y += height;
+
+	if (end > ctx->text.lastPos) {
+	    position = end;
+	    ctx->text.clear_to_eol = True;
+	    _XawTextNeedsUpdating(ctx, end, end + ctx->text.lt.lines - line);
+	    while (line++ < ctx->text.lt.lines) {
+		if (line > 1 && y > max_y) {
+		    ctx->text.lt.lines = line - 1;
+		    break;
+		}
+		++lt;
+		if (lt->y != y) {
+		    if (update_from < 0)
+			update_from = line < 2 ?
+			    ctx->text.lt.info[0].position :
+			    ctx->text.lt.info[line - 2].position;
+		    lt->y = y;
+		}
+		lt->position = ++position;
+		lt->textWidth = 0;
+		y += height;
+	    }
+	    if (update_from >= 0)
+		_XawTextNeedsUpdating(ctx, update_from,
+				      ctx->text.lt.info[ctx->text.lt.lines].position);
+	    _XawTextSetScrollBars(ctx);
+
+	    return (ctx->text.lastPos);
+	}
+
+	if (line && y > max_y)
+	    /* will return in the next loop */
+	    ctx->text.lt.lines = line;
+
+	if (++line > ctx->text.lt.lines && y < max_y) {
+	/* grow the line table */
+	    ctx->text.lt.info = (XawTextLineTableEntry *)
+		XtRealloc((char *)ctx->text.lt.info,
+			  sizeof(XawTextLineTableEntry) * (line + 1));
+	    lt = ctx->text.lt.info + line;
+	    bzero(lt, sizeof(XawTextLineTableEntry));
+	    ++ctx->text.lt.lines;
+	}
+	else
+	    ++lt;
+	if (position == end)
+	    ++position;
+	else
+	    position = end;
+
+	if (line > ctx->text.lt.lines) {
+	    if (update_from >= 0)
+		_XawTextNeedsUpdating(ctx, update_from,
+				      ctx->text.lt.info[ctx->text.lt.lines].position);
+	    _XawTextSetScrollBars(ctx);
+
+	    return (position);
+	}
+    }
+    /*NOTREACHED*/
+}
+
+/*
+ * Function:
+ *	GetWidestLine
+ *
+ * Parameters:
+ *	ctx - text widget
+ *
+ * Description:
+ *	  Returns the width (in pixels) of the widest line that
+ *		     is currently visable.
+ *
+ * Returns:
+ *	The width of the widest line
+ */
+static unsigned int
+GetWidestLine(TextWidget ctx)
+{
+    int i;
+    unsigned int widest;
+    XawTextLineTablePtr lt = &(ctx->text.lt);
+
+    for (i = 0, widest = 0; i < lt->lines; i++)
+	if (widest < lt->info[i].textWidth)
+	    widest = lt->info[i].textWidth;
+
+    return (widest);
+}
+
+/*
+ * This routine is used by Text to notify an associated scrollbar of the
+ * correct metrics (position and shown fraction) for the text being currently
+ * displayed in the window.
+ */
+void
+_XawTextSetScrollBars(TextWidget ctx)
+{
+    float first, last, denom, widest;
+
+    if (ctx->text.scroll_vert == XawtextScrollAlways) {
+	if (ctx->text.lastPos == 0)
+	    first = 0.0;
+	else
+	    first = ctx->text.lt.top / (float)ctx->text.lastPos;
+
+	if (ctx->text.lt.info[ctx->text.lt.lines].position < ctx->text.lastPos)
+	    last = ctx->text.lt.info[ctx->text.lt.lines].position /
+		   (float)ctx->text.lastPos;
+	else
+	    last = 1.0;
+
+	XawScrollbarSetThumb(ctx->text.vbar, first, last - first);
+    }
+
+    if (ctx->text.scroll_horiz == XawtextScrollAlways) {
+	denom = GetWidestLine(ctx);
+	if (denom <= 0)
+	    denom = (int)XtWidth(ctx) - RHMargins(ctx);
+	if (denom <= 0)
+	    denom = 1;
+	widest = ((int)XtWidth(ctx) - RHMargins(ctx)) / denom;
+	first = ctx->text.r_margin.left - ctx->text.left_margin;
+	first /= denom;
+
+	XawScrollbarSetThumb(ctx->text.hbar, first, widest);
+    }
+}
+
+static void
+DoCopyArea(TextWidget ctx, int src_x, int src_y,
+	   unsigned int width, unsigned int height, int dst_x, int dst_y)
+{
+    int x1, y1, x2, y2;
+
+    x1 = ctx->text.r_margin.left;
+    y1 = ctx->text.r_margin.top;
+    x2 = XtWidth(ctx) - ctx->text.r_margin.right;
+    y2 = XtHeight(ctx) - ctx->text.r_margin.bottom;
+
+    if (x1 >= x2 || y1 >= y2)
+	return;
+
+    src_x = XawMax(x1, XawMin(src_x, x2));
+    src_y = XawMax(y1, XawMin(src_y, y2));
+    dst_x = XawMax(x1, XawMin(dst_x, x2));
+    dst_y = XawMax(y1, XawMin(dst_y, y2));
+    width = XawMax(0, XawMin(x2 - dst_x, (int)width));
+    height = XawMax(0, XawMin(y2 - dst_y, (int)height));
+
+    XCopyArea(XtDisplay(ctx), XtWindow(ctx), XtWindow(ctx), ctx->text.gc,
+	      src_x, src_y, width, height, dst_x, dst_y);
+}
+
+/*
+ * Function:
+ *	XawTextScroll
+ *
+ * Parameters:
+ *	ctx	- text widget
+ *	vlines	- number of lines to scroll vertically
+ *	hpixels	- number of pixels to scroll horizontally
+ *
+ * Description:
+ *	Generic function for scrolling the text window.
+ *	Allows vertical and horizontal scroll at the same time.
+ */
+void
+XawTextScroll(TextWidget ctx, int vlines, int hpixels)
+{
+    XawTextPosition top, tmp, update_from, update_to;
+    XawTextLineTable *lt;
+    Arg arglist[1];
+    int y0, y1, y2, count, dim, wwidth, lines = ctx->text.lt.lines;
+    int vwidth, vheight;	/* visible width and height */
+    Bool scroll;
+
+    vwidth = (int)XtWidth(ctx) - RHMargins(ctx);
+    vheight = (int)XtHeight(ctx) - RVMargins(ctx);
+    lt = &ctx->text.lt;
+
+    if (!lt || vwidth <= 0 || vheight <= 0)
+	return;
+
+    if ((scroll = ctx->core.background_pixmap == XtUnspecifiedPixmap) == True) {
+	dim = lt->info[1].y - lt->info[0].y;
+	for (count = 1; count < lt->lines - 1; count++)
+	    if (lt->info[count + 1].y - lt->info[count].y != dim) {
+		scroll = False;
+		break;
+	    }
+    }
+
+    wwidth = GetMaxTextWidth(ctx);
+
+    /*
+     * Do the horizontall scrolling
+     */
+    if (hpixels < 0 && ctx->text.left_margin - hpixels > ctx->text.r_margin.left)
+	hpixels = ctx->text.left_margin - ctx->text.r_margin.left;
+    ctx->text.left_margin -= hpixels;
+
+    update_from = lt->top;	/* remember the old value */
+    /*
+     *	 Checks the requested number of lines and calculates the top
+     * of the line table
+     */
+    if (vlines < 0) {		  /* VScroll Up */
+	if (IsPositionVisible(ctx, 0))
+	    vlines = 0;
+	else if (ctx->text.wrap != XawtextWrapNever) {
+	    XawTextPosition end;
+	    int n_lines = 0;
+
+	    count = -vlines;
+	    end = lt->top;
+	    while (n_lines < count) {
+		top = SrcScan(ctx->text.source, end, XawstEOL,
+			      XawsdLeft, 2, False);
+		n_lines += CountLines(ctx, top, end);
+		end = top;
+	    }
+
+	    while (count++ < n_lines) {
+		tmp = top;
+		XawTextSinkFindPosition(ctx->text.sink, top,
+					ctx->text.left_margin,
+					wwidth,ctx->text.wrap == XawtextWrapWord,
+					&top, &dim, &dim);
+		if (tmp == top)
+		    ++top;
+	    }
+	}
+	else
+	    top = SrcScan(ctx->text.source, lt->top, XawstEOL,
+			  XawsdLeft, -vlines + 1, False);
+	if (-vlines >= ctx->text.lt.lines)
+	  scroll = False;
+     }
+    else if (vlines > 0) {	  /* VScroll Down */
+	if (LineForPosition(ctx, ctx->text.lastPos) == 0)
+	    vlines = 0;
+	if (vlines < lt->lines)
+	    top = XawMin(lt->info[vlines].position, ctx->text.lastPos);
+	else if (ctx->text.wrap == XawtextWrapNever)
+	    top = SrcScan(ctx->text.source,
+			  SrcScan(ctx->text.source, lt->top,
+				  XawstEOL, XawsdRight, vlines,
+				  True),
+			  XawstEOL, XawsdLeft, 1, False);
+	else {
+	    top = lt->top;
+	    count = 0;
+	    while (count++ < vlines) {
+		tmp = top;
+		XawTextSinkFindPosition(ctx->text.sink, top,
+					ctx->text.left_margin,
+					wwidth, ctx->text.wrap == XawtextWrapWord,
+					&top, &dim, &dim);
+		if (tmp == top)
+		    ++top;
+	    }
+	}
+	if (vlines >= ctx->text.lt.lines
+	    || lt->info[vlines].position >= ctx->text.lastPos)
+	    scroll = False;
+    }
+
+    if (!vlines) {
+	if (hpixels) {
+	    ClearWindow(ctx);
+	    ctx->text.clear_to_eol = True;
+	}
+	_XawTextSetScrollBars(ctx);
+	return;
+    }
+
+    /* Flushes any pending updates. Normally, there may be a call to
+     * XawTextUnsetSelection not yet updated.
+     */
+    if (!hpixels && scroll) {
+	ctx->text.clear_to_eol = True;
+	FlushUpdate(ctx);
+    }
+
+    /*
+     * Rebuild the line table, doing the vertical scroll
+     */
+    (void)_BuildLineTable(ctx, top, 0);
+    lt = &ctx->text.lt;
+    if (scroll) {
+	for (count = 0; count < lt->lines - 1; count++)
+	    if (lt->info[count + 1].y - lt->info[count].y != dim) {
+		scroll = False;
+		break;
+	    }
+    }
+
+    XtSetArg(arglist[0], XtNinsertPosition, lt->top + lt->lines);
+    _XawImSetValues((Widget)ctx, arglist, 1);
+
+    if (hpixels || !scroll || lines != lt->lines)
+	return;
+
+    /* _BuildLineTable updates everything if the top position changes.
+     * It is not required here.
+     */
+    (void)XmuScanlineXor(ctx->text.update, ctx->text.update);
+    if (vlines < 0 && IsPositionVisible(ctx, 0))
+	vlines = -LineForPosition(ctx, update_from);
+
+    y0 = ctx->text.r_margin.top;
+    if (vlines < 0) {
+	update_from = lt->top;
+	update_to = lt->info[-vlines + 1].position - 1;
+	y1 = lt->info[lt->lines + vlines].y;
+	y2 = lt->info[-vlines].y;
+	DoCopyArea(ctx, ctx->text.r_margin.left, y0, vwidth,
+		   y1 - y0,
+		   ctx->text.r_margin.left, y2);
+    }
+    else {
+	update_from = lt->info[lt->lines - vlines].position;
+	update_to = lt->info[lt->lines].position;
+	y1 = lt->info[lt->lines - vlines].y;
+	y2 = lt->info[vlines].y;
+	DoCopyArea(ctx, ctx->text.r_margin.left, y2,
+		   vwidth, lt->info[lt->lines].y - y2,
+		   ctx->text.r_margin.left, y0);
+    }
+    _XawTextNeedsUpdating(ctx, update_from, update_to);
+    ctx->text.clear_to_eol = True;
+}
+
+/*
+ * The routine will scroll the displayed text by lines.  If the arg  is
+ * positive, move up; otherwise, move down. [note: this is really a private
+ * procedure but is used in multiple modules].
+ */
+void
+_XawTextVScroll(TextWidget ctx, int n)
+{
+  XawTextScroll(ctx, n, 0);
+}
+
+/*ARGSUSED*/
+static void
+HScroll(Widget w, XtPointer closure, XtPointer callData)
+{
+    TextWidget ctx = (TextWidget)closure;
+    long pixels = (long)callData;
+
+    if (pixels > 0) {
+	long max;
+
+	max = (int)GetWidestLine(ctx) + ctx->text.left_margin -
+	      ctx->text.r_margin.left;
+	max = XawMax(0, max);
+	pixels = XawMin(pixels, max);
+    }
+
+    if (pixels) {
+	_XawTextPrepareToUpdate(ctx);
+	XawTextScroll(ctx, 0, pixels);
+	_XawTextExecuteUpdate(ctx);
+    }
+}
+
+/*ARGSUSED*/
+static void
+HJump(Widget w, XtPointer closure, XtPointer callData)
+{
+    TextWidget ctx = (TextWidget)closure;
+    float percent = *(float *)callData;
+    long pixels;
+
+    pixels = ctx->text.left_margin -
+	     (ctx->text.r_margin.left - (int)(percent * GetWidestLine(ctx)));
+
+    HScroll(w, (XtPointer)ctx, (XtPointer)pixels);
+}
+
+/*
+ * Function:
+ *	UpdateTextInLine
+ *
+ * Parameters:
+ *	ctx  - text widget
+ *	line - line to update
+ *	x1   - left pixel
+ *	x2   - right pixel
+ *
+ * Description:
+ *	Updates the text in the given line and pixel interval
+ */
+static void
+UpdateTextInLine(TextWidget ctx, int line, int x1, int x2)
+{
+    XawTextLineTableEntry *lt = ctx->text.lt.info + line;
+    XawTextPosition left, right;
+    int from_x, width, height;
+
+    if (lt->position >= ctx->text.lastPos
+	|| ctx->text.left_margin > x2
+	|| (int)lt->textWidth + ctx->text.left_margin < x1) {
+	/* Mark line to be cleared */
+	if (ctx->text.clear_to_eol)
+	    _XawTextNeedsUpdating(ctx, lt->position, lt->position + 1);
+	return;
+    }
+
+    from_x = ctx->text.left_margin;
+    XawTextSinkFindPosition(ctx->text.sink, lt->position,
+			    from_x, x1 - from_x,
+			    False, &left, &width, &height);
+    if (line == ctx->text.lt.lines)
+	right = -1;
+    else if (x2 >= lt->textWidth - from_x)
+	right = lt[1].position - 1;
+    else {
+	from_x += width;
+	XawTextSinkFindPosition(ctx->text.sink, left,
+				from_x, x2 - from_x,
+				False, &right, &width, &height);
+    }
+
+    if ((right < 0) || (right + 1 <= lt[1].position))
+	++right;
+
+    /* Mark text interval to be repainted */
+    _XawTextNeedsUpdating(ctx, left, right);
+}
+
+/*
+ * The routine will scroll the displayed text by pixels.  If the calldata is
+ * positive, move up; otherwise, move down.
+ */
+/*ARGSUSED*/
+static void
+VScroll(Widget w, XtPointer closure, XtPointer callData)
+{
+    TextWidget ctx = (TextWidget)closure;
+    long height, lines = (long)callData;
+
+    height = XtHeight(ctx) - VMargins(ctx);
+    if (height < 1)
+	height = 1;
+    lines = (lines * ctx->text.lt.lines) / height;
+    _XawTextPrepareToUpdate(ctx);
+    XawTextScroll(ctx, lines, 0);
+    _XawTextExecuteUpdate(ctx);
+}
+
+/*ARGSUSED*/
+static void
+VJump(Widget w, XtPointer closure, XtPointer callData)
+{
+    float percent = *(float *)callData;
+    TextWidget ctx = (TextWidget)closure;
+    XawTextPosition top, last, position, tmp;
+    XawTextLineTable *lt = &(ctx->text.lt);
+    int dim, vlines = 0, wwidth = GetMaxTextWidth(ctx);
+    Bool scroll = True;
+
+    position = percent * ctx->text.lastPos;
+    top = lt->top;
+
+    if (!lt->lines || (position >= lt->top && position < lt->info[1].position)) {
+	_XawTextSetScrollBars(ctx);
+	return;
+    }
+
+#ifndef OLDXAW
+    ctx->text.lt.base_line = -1;
+#endif
+
+    if (position > lt->top) {	  /* VScroll Up */
+	if (position > lt->top && position < lt->info[lt->lines].position)
+	    vlines = LineForPosition(ctx, position);
+	else {
+	    scroll = False;
+	    top = SrcScan(ctx->text.source, position, XawstEOL,
+			  XawsdLeft, 1, False);
+	    if (ctx->text.wrap != XawtextWrapNever) {
+		last = top;
+		while (last < position) {
+		    tmp = last;
+		    XawTextSinkFindPosition(ctx->text.sink, last,
+					    ctx->text.left_margin, wwidth,
+					    ctx->text.wrap == XawtextWrapWord,
+					    &last, &dim, &dim);
+		    if (last == tmp)
+			++last;
+		    if (last < position)
+			top = last;
+		}
+	    }
+	}
+    }
+    else {		  /* VScroll Down */
+	/*
+	 * Calculates the number of lines
+	 */
+	while (top > position) {
+	    last = top;
+	    top = SrcScan(ctx->text.source, top, XawstEOL,
+			  XawsdLeft, 2, False);
+	    vlines -= CountLines(ctx, top, last);
+	    if (-vlines >= ctx->text.lt.lines) {
+		scroll = False;
+		top = SrcScan(ctx->text.source, position, XawstEOL,
+			      XawsdLeft, 1, False);
+		break;
+	      }
+	  }
+	/*
+	 * Normalize
+	 */
+	if (ctx->text.wrap != XawtextWrapNever) {
+	    last = top;
+	    while (last < position) {
+		tmp = last;
+		XawTextSinkFindPosition(ctx->text.sink, last,
+					ctx->text.left_margin,
+					wwidth,
+					ctx->text.wrap == XawtextWrapWord,
+					&last, &dim, &dim);
+		if (last == tmp)
+		    ++last;
+		if (last < position)
+		    top = last;
+		++vlines;
+	    }
+	}
+    }
+
+    if (vlines || !scroll) {
+	_XawTextPrepareToUpdate(ctx);
+	if (scroll)
+	    XawTextScroll(ctx, vlines, 0);
+	else
+	    _BuildLineTable(ctx, top, 0);
+	_XawTextExecuteUpdate(ctx);
+    }
+}
+
+static Bool
+MatchSelection(Atom selection, XawTextSelection *s)
+{
+    Atom *match;
+    int count;
+
+    for (count = 0, match = s->selections; count < s->atom_count;
+       match++, count++)
+    if (*match == selection)
+	return (True);
+
+  return (False);
+}
+
+static Boolean
+TextConvertSelection(Widget w, Atom *selection, Atom *target, Atom *type,
+		 XtPointer *value, unsigned long *length, int *format)
+{
+    Display *d = XtDisplay(w);
+    TextWidget ctx = (TextWidget)w;
+    Widget src = ctx->text.source;
+    XawTextEditType edit_mode;
+    Arg args[1];
+    XawTextSelectionSalt *salt = NULL;
+    XawTextSelection *s;
+
+    if (*target == XA_TARGETS(d)) {
+	Atom *targetP, *std_targets;
+	unsigned long std_length;
+
+	if (SrcCvtSel(src, selection, target, type, value, length, format))
+	    return (True);
+
+	XtSetArg(args[0], XtNeditType, &edit_mode);
+	XtGetValues(src, args, ONE);
+
+	XmuConvertStandardSelection(w, ctx->text.time, selection,
+				    target, type, (XPointer*)&std_targets,
+				    &std_length, format);
+
+	*length = 7 + (edit_mode == XawtextEdit) + std_length;
+	*value = XtMalloc((unsigned)sizeof(Atom)*(*length));
+	targetP = *(Atom**)value;
+	*targetP++ = XA_STRING;
+	*targetP++ = XA_TEXT(d);
+	*targetP++ = XA_UTF8_STRING(d);
+	*targetP++ = XA_COMPOUND_TEXT(d);
+	*targetP++ = XA_LENGTH(d);
+	*targetP++ = XA_LIST_LENGTH(d);
+	*targetP++ = XA_CHARACTER_POSITION(d);
+	if (edit_mode == XawtextEdit) {
+	    *targetP++ = XA_DELETE(d);
+	}
+	(void)memmove((char*)targetP, (char*)std_targets,
+		      sizeof(Atom) * std_length);
+	XtFree((char*)std_targets);
+	*type = XA_ATOM;
+	*format = 32;
+	return (True);
+    }
+
+    if (SrcCvtSel(src, selection, target, type, value, length, format))
+	return (True);
+
+    if (MatchSelection(*selection, &ctx->text.s))
+	s = &ctx->text.s;
+    else {
+	for (salt = ctx->text.salt; salt; salt = salt->next)
+	    if (MatchSelection(*selection, &salt->s))
+		break;
+	if (!salt)
+	    return (False);
+	s = &salt->s;
+    }
+    if (*target == XA_STRING
+	|| *target == XA_TEXT(d)
+	|| *target == XA_UTF8_STRING(d)
+	|| *target == XA_COMPOUND_TEXT(d)) {
+	if (*target == XA_TEXT(d)) {
+	    if (XawTextFormat(ctx, XawFmtWide))
+		*type = XA_COMPOUND_TEXT(d);
+	    else
+		*type = XA_STRING;
+	}
+	else
+	    *type = *target;
+	/* 
+	 * If salt is True, the salt->contents stores CT string,
+	 * its length is measured in bytes.
+	 * Refer to _XawTextSaltAwaySelection().
+	 *
+	 * by Li Yuhong, Mar. 20, 1991.
+	 */
+	if (!salt) {
+	    *value = _XawTextGetSTRING(ctx, s->left, s->right);
+	    if (XawTextFormat(ctx, XawFmtWide)) {
+		XTextProperty textprop;
+		if (XwcTextListToTextProperty(d, (wchar_t **)value, 1,
+					      XCompoundTextStyle, &textprop)
+		    <  Success) {
+		    XtFree((char *)*value);
+		    return (False);
+		}
+	 	XtFree((char *)*value);
+		*value = (XtPointer)textprop.value;
+		*length = textprop.nitems;
+	    }
+	    else
+	        *length = strlen((char *)*value);
+	}
+	else {
+	    *value = XtMalloc((salt->length + 1) * sizeof(unsigned char));
+	    strcpy ((char *)*value, salt->contents);
+	    *length = salt->length;
+	}
+	/* Got *value,*length, now in COMPOUND_TEXT format. */
+	if (XawTextFormat(ctx, XawFmtWide) && *type == XA_STRING) {
+	    XTextProperty textprop;
+	    wchar_t **wlist;
+	    int count;
+
+	    textprop.encoding = XA_COMPOUND_TEXT(d);
+	    textprop.value = (unsigned char *)*value;
+	    textprop.nitems = strlen(*value);
+	    textprop.format = 8;
+	    if (XwcTextPropertyToTextList(d, &textprop, &wlist, &count)
+		 < Success
+		|| count < 1) {
+		XtFree((char *)*value);
+		return (False);
+	    }
+	    XtFree((char *)*value);
+	    if (XwcTextListToTextProperty(d, wlist, 1, XStringStyle, &textprop)
+		 < Success) {
+		XwcFreeStringList((wchar_t**) wlist);
+		return (False);
+	    }
+	    *value = (XtPointer)textprop.value;
+	    *length = textprop.nitems;
+	    XwcFreeStringList(wlist);
+	} else if (*type == XA_UTF8_STRING(d)) {
+	    XTextProperty textprop;
+	    char **list;
+	    int count;
+
+	    textprop.encoding = XA_COMPOUND_TEXT(d);
+	    textprop.value = (unsigned char *)*value;
+	    textprop.nitems = strlen(*value);
+	    textprop.format = 8;
+	    if (Xutf8TextPropertyToTextList(d, &textprop, &list, &count)
+		 < Success
+		|| count < 1) {
+		XtFree((char *)*value);
+		return (False);
+	    }
+	    XtFree((char *)*value);
+	    *value = *list;
+	    *length = strlen(*list);
+	    XFree(list);
+	}
+	*format = 8;
+	return (True);
+    }
+
+    if ((*target == XA_LIST_LENGTH(d)) || (*target == XA_LENGTH(d))) {
+	long * temp;
+
+	temp = (long *)XtMalloc((unsigned)sizeof(long));
+	if (*target == XA_LIST_LENGTH(d))
+	    *temp = 1L;
+	else			/* *target == XA_LENGTH(d) */
+	    *temp = (long) (s->right - s->left);
+
+	*value = (XPointer)temp;
+	*type = XA_INTEGER;
+	*length = 1L;
+	*format = 32;
+	return (True);
+    }
+
+    if (*target == XA_CHARACTER_POSITION(d)) {
+	long * temp;
+
+	temp = (long *)XtMalloc((unsigned)(2 * sizeof(long)));
+	temp[0] = (long)(s->left + 1);
+	temp[1] = s->right;
+	*value = (XPointer)temp;
+	*type = XA_SPAN(d);
+	*length = 2L;
+	*format = 32;
+	return (True);
+    }
+
+    if (*target == XA_DELETE(d)) {
+	if (!salt)
+	    _XawTextZapSelection(ctx, NULL, True);
+	*value = NULL;
+	*type = XA_NULL(d);
+	*length = 0;
+	*format = 32;
+	return (True);
+    }
+
+    if (XmuConvertStandardSelection(w, ctx->text.time, selection, target, type,
+				    (XPointer *)value, length, format))
+	return (True);
+
+    /* else */
+    return (False);
+}
+
+/*
+ * Function:
+ *	GetCutBuffferNumber
+ *
+ * Parameters:
+ *	atom - atom to check
+ *
+ * Description:
+ *	Returns the number of the cut buffer.
+ *
+ * Returns:
+ *	The number of the cut buffer representing this atom or NOT_A_CUT_BUFFER
+ */
+#define NOT_A_CUT_BUFFER -1
+static int
+GetCutBufferNumber(Atom atom)
+{
+    if (atom == XA_CUT_BUFFER0) return (0);
+    if (atom == XA_CUT_BUFFER1) return (1);
+    if (atom == XA_CUT_BUFFER2) return (2);
+    if (atom == XA_CUT_BUFFER3) return (3);
+    if (atom == XA_CUT_BUFFER4) return (4);
+    if (atom == XA_CUT_BUFFER5) return (5);
+    if (atom == XA_CUT_BUFFER6) return (6);
+    if (atom == XA_CUT_BUFFER7) return (7);
+    return (NOT_A_CUT_BUFFER);
+}
+
+static void
+TextLoseSelection(Widget w, Atom *selection)
+{
+    TextWidget ctx = (TextWidget)w;
+    Atom *atomP;
+    int i;
+    XawTextSelectionSalt*salt, *prevSalt, *nextSalt;
+
+    atomP = ctx->text.s.selections;
+    for (i = 0 ; i < ctx->text.s.atom_count; i++, atomP++)
+	if ((*selection == *atomP)
+	    || (GetCutBufferNumber(*atomP) != NOT_A_CUT_BUFFER))
+	    *atomP = (Atom)0;
+
+    while (ctx->text.s.atom_count
+	   && ctx->text.s.selections[ctx->text.s.atom_count - 1] == 0)
+	ctx->text.s.atom_count--;
+
+    /*
+     * Must walk the selection list in opposite order from UnsetSelection
+     */
+    atomP = ctx->text.s.selections;
+    for (i = 0 ; i < ctx->text.s.atom_count; i++, atomP++)
+	if (*atomP == (Atom)0) {
+	    *atomP = ctx->text.s.selections[--ctx->text.s.atom_count];
+	    while (ctx->text.s.atom_count
+		   && ctx->text.s.selections[ctx->text.s.atom_count-1] == 0)
+		ctx->text.s.atom_count--;
+	}
+
+    if (ctx->text.s.atom_count == 0)
+	ModifySelection(ctx, ctx->text.insertPos, ctx->text.insertPos);
+
+    prevSalt = 0;
+    for (salt = ctx->text.salt; salt; salt = nextSalt) {
+	atomP = salt->s.selections;
+	nextSalt = salt->next;
+	for (i = 0 ; i < salt->s.atom_count; i++, atomP++)
+	    if (*selection == *atomP)
+		*atomP = (Atom)0;
+
+	while (salt->s.atom_count
+	       && salt->s.selections[salt->s.atom_count-1] == 0)
+	    salt->s.atom_count--;
+    	
+	/*
+	 * Must walk the selection list in opposite order from UnsetSelection
+	 */
+	atomP = salt->s.selections;
+	for (i = 0 ; i < salt->s.atom_count; i++, atomP++)
+	    if (*atomP == (Atom)0) {
+		*atomP = salt->s.selections[--salt->s.atom_count];
+		while (salt->s.atom_count
+		       && salt->s.selections[salt->s.atom_count-1] == 0)
+		    salt->s.atom_count--;
+	    }
+
+	if (salt->s.atom_count == 0) {
+	    XtFree ((char *) salt->s.selections);
+	    XtFree (salt->contents);
+	    if (prevSalt)
+		prevSalt->next = nextSalt;
+	    else
+		ctx->text.salt = nextSalt;
+	    XtFree((char *)salt);
+	}
+	else
+	    prevSalt = salt;
+    }
+}
+
+void
+_XawTextSaltAwaySelection(TextWidget ctx, Atom *selections, int num_atoms)
+{
+    XawTextSelectionSalt *salt;
+    int i, j;
+
+    for (i = 0; i < num_atoms; i++)
+	TextLoseSelection((Widget)ctx, selections + i);
+    if (num_atoms == 0)
+	return;
+    salt = (XawTextSelectionSalt *)
+	XtMalloc((unsigned)sizeof(XawTextSelectionSalt));
+    if (!salt)
+	return;
+    salt->s.selections = (Atom *)XtMalloc((unsigned)(num_atoms * sizeof(Atom)));
+    if (!salt->s.selections) {
+	XtFree((char *)salt);
+	return;
+    }
+    salt->s.left = ctx->text.s.left;
+    salt->s.right = ctx->text.s.right;
+    salt->s.type = ctx->text.s.type;
+    salt->contents = _XawTextGetSTRING(ctx, ctx->text.s.left, ctx->text.s.right);
+    if (XawTextFormat(ctx, XawFmtWide)) {
+	XTextProperty textprop;
+	if (XwcTextListToTextProperty(XtDisplay((Widget)ctx),
+				      (wchar_t**)(&(salt->contents)), 1,
+				      XCompoundTextStyle,
+				      &textprop) < Success) {
+	    XtFree(salt->contents);
+	    salt->length = 0;
+	    return;
+	}
+	XtFree(salt->contents);
+	salt->contents = (char *)textprop.value;
+	salt->length = textprop.nitems;
+    }
+    else
+	salt->length = strlen (salt->contents);
+    salt->next = ctx->text.salt;
+    ctx->text.salt = salt;
+    j = 0;
+    for (i = 0; i < num_atoms; i++) {
+	if (GetCutBufferNumber (selections[i]) == NOT_A_CUT_BUFFER) {
+	    salt->s.selections[j++] = selections[i];
+	    XtOwnSelection((Widget)ctx, selections[i], ctx->text.time,
+			   TextConvertSelection, TextLoseSelection, NULL);
+	}
+    }
+    salt->s.atom_count = j;
+}
+
+static void
+_SetSelection(TextWidget ctx, XawTextPosition left, XawTextPosition right,
+	      Atom *selections, Cardinal count)
+{
+#ifndef OLDXAW
+    Cardinal i;
+    XawTextPosition pos;
+    TextSrcObject src = (TextSrcObject)ctx->text.source;
+
+    for (i = 0; i < src->textSrc.num_text; i++) {
+	TextWidget tw = (TextWidget)src->textSrc.text[i];
+	Bool needs_updating = tw->text.old_insert < 0;
+	Bool showposition = tw->text.showposition;
+
+	if (needs_updating) {
+	    tw->text.showposition = False;
+	    _XawTextPrepareToUpdate(tw);
+	}
+#else
+	TextWidget tw = ctx;
+	XawTextPosition pos;
+#endif /* OLDXAW */
+
+	if (left < tw->text.s.left) {
+	    pos = Min(right, tw->text.s.left);
+	    _XawTextNeedsUpdating(tw, left, pos);
+	}
+	if (left > tw->text.s.left) {
+	    pos = Min(left, tw->text.s.right);
+	    _XawTextNeedsUpdating(tw, tw->text.s.left, pos);
+	}
+	if (right < tw->text.s.right) {
+	    pos = Max(right, tw->text.s.left);
+	    _XawTextNeedsUpdating(tw, pos, tw->text.s.right);
+	}
+	if (right > tw->text.s.right) {
+	    pos = Max(left, tw->text.s.right);
+	    _XawTextNeedsUpdating(tw, pos, right);
+	}
+
+	tw->text.s.left = left;
+	tw->text.s.right = right;
+
+#ifndef OLDXAW
+	if (needs_updating) {
+	    _XawTextExecuteUpdate(tw);
+	    tw->text.showposition = showposition;
+	}
+    }
+#endif /* OLDXAW */
+
+    SrcSetSelection(ctx->text.source, left, right,
+		    (count == 0) ? None : selections[0]);
+
+    if (left < right) {
+	Widget w = (Widget)ctx;
+	int buffer;
+
+	while (count) {
+	    Atom selection = selections[--count];
+
+	    /*
+	     * If this is a cut buffer
+	     */
+	    if ((buffer = GetCutBufferNumber(selection)) != NOT_A_CUT_BUFFER) {
+		unsigned char *ptr, *tptr;
+		unsigned int amount, max_len = MAX_CUT_LEN(XtDisplay(w));
+		unsigned long len;
+
+		tptr= ptr= (unsigned char *)_XawTextGetSTRING(ctx,
+							      ctx->text.s.left,
+							      ctx->text.s.right);
+		if (XawTextFormat(ctx, XawFmtWide)) {
+		    /*
+		     * Only XA_STRING(Latin 1) is allowed in CUT_BUFFER,
+		     * so we get it from wchar string, then free the wchar string
+		     */
+		    XTextProperty textprop;
+
+		    if (XwcTextListToTextProperty(XtDisplay(w), (wchar_t**)&ptr,
+						  1, XStringStyle, &textprop)
+			<  Success){
+			XtFree((char *)ptr);
+			return;
+		    }
+		    XtFree((char *)ptr);
+		    tptr = ptr = textprop.value;
+		}
+		if (buffer == 0) {
+		    _CreateCutBuffers(XtDisplay(w));
+		    XRotateBuffers(XtDisplay(w), 1);
+		}
+		amount = Min ((len = strlen((char *)ptr)), max_len);
+		XChangeProperty(XtDisplay(w), RootWindow(XtDisplay(w), 0),
+				selection, XA_STRING, 8, PropModeReplace,
+				ptr, amount);
+
+		while (len > max_len) {
+		    len -= max_len;
+		    tptr += max_len;
+		    amount = Min (len, max_len);
+		    XChangeProperty(XtDisplay(w), RootWindow(XtDisplay(w), 0),
+				    selection, XA_STRING, 8, PropModeAppend,
+				    tptr, amount);
+		}
+		XtFree ((char *)ptr);
+	    }
+	    else		/* This is a real selection */
+		XtOwnSelection(w, selection, ctx->text.time, TextConvertSelection,
+			       TextLoseSelection, NULL);
+	}
+    }
+    else
+	XawTextUnsetSelection((Widget)ctx);
+}
+
+#ifndef OLDXAW
+void
+_XawTextSetLineAndColumnNumber(TextWidget ctx, Bool force)
+{
+    int line_number, column_number;
+
+    if (ctx->text.old_insert != ctx->text.insertPos &&
+	ctx->text.lt.base_line < 0) {
+	ctx->text.lt.base_line = 0;
+	(void)_BuildLineTable(ctx, ctx->text.lt.top, 0);
+    }
+
+    line_number = ResolveLineNumber(ctx);
+    column_number = ResolveColumnNumber(ctx);
+
+    if (force || (ctx->text.column_number != column_number
+		  || ctx->text.line_number != line_number)) {
+	XawTextPositionInfo info;
+
+	ctx->text.line_number = info.line_number = line_number;
+	ctx->text.column_number = info.column_number = column_number;
+	info.insert_position = ctx->text.insertPos;
+	info.last_position = ctx->text.lastPos;
+	info.overwrite_mode = ctx->text.overwrite;
+
+	XtCallCallbacks((Widget)ctx, XtNpositionCallback, (XtPointer)&info);
+    }
+}
+
+static int
+ResolveColumnNumber(TextWidget ctx)
+{
+    Widget src = ctx->text.source;
+    short column_number = 0;
+    XawTextPosition position;
+    XawTextBlock block;
+    unsigned long format = _XawTextFormat(ctx);
+    TextSinkObject sink = (TextSinkObject)ctx->text.sink;
+    short *char_tabs = sink->text_sink.char_tabs;
+    int tab_count = sink->text_sink.tab_count;
+    int tab_index = 0, tab_column = 0, tab_base = 0;
+
+    if (ctx->text.lt.base_line < 1)
+	return (ctx->text.column_number);
+
+    position = SrcScan(src, ctx->text.insertPos, XawstEOL, XawsdLeft, 1, False);
+    XawTextSourceRead(src, position, &block, ctx->text.insertPos - position);
+
+    for (; position < ctx->text.insertPos; position++) {
+	if (position - block.firstPos >= block.length)
+	    XawTextSourceRead(src, position, &block, ctx->text.insertPos - position);
+	if ((format == XawFmt8Bit && block.ptr[position - block.firstPos] == '\t') ||
+	    (format == XawFmtWide && ((wchar_t*)block.ptr)[position - block.firstPos] == _Xaw_atowc(XawTAB))) {
+	    while (tab_base + tab_column <= column_number) {
+		if (tab_count) {
+		    for (; tab_index < tab_count; ++tab_index)
+			if (tab_base + char_tabs[tab_index] > column_number) {
+			    tab_column = char_tabs[tab_index];
+			    break;
+			}
+		    if (tab_index >= tab_count) {
+			tab_base += char_tabs[tab_count - 1];
+			tab_column = tab_index = 0;
+		    }
+		}
+		else
+		    tab_column += DEFAULT_TAB_SIZE;
+	    }
+	    column_number = tab_base + tab_column;
+	}
+	else
+	    ++column_number;
+	if (column_number >= 16384) {
+	    column_number = 16383;
+	    break;
+	}
+    }
+
+    return (column_number);
+}
+#endif /* OLDXAW */
+
+void
+_XawTextSourceChanged(Widget w, XawTextPosition left, XawTextPosition right,
+		      XawTextBlock *block, int lines)
+{
+    TextWidget ctx = (TextWidget)w;
+    Widget src = ctx->text.source;
+    XawTextPosition update_from, update_to, top;
+    Boolean update_disabled;
+    int delta, line, line_from;
+
+    if (left < ctx->text.old_insert) {
+	XawTextPosition old_insert = ctx->text.old_insert;
+
+	if (right < ctx->text.old_insert)
+	    old_insert -= right - left;
+	else
+	    old_insert = left;
+
+	ctx->text.insertPos = old_insert + block->length;
+    }
+#ifndef OLDXAW
+    if (left <= ctx->text.lt.top) {
+	if (left + block->length - (right - left) < ctx->text.lt.top) {
+	    ctx->text.source_changed = SRC_CHANGE_BEFORE;
+	    ctx->text.lt.base_line += lines;
+	}
+	else
+	    ctx->text.source_changed = SRC_CHANGE_OVERLAP;
+    }
+    else
+	ctx->text.source_changed = SRC_CHANGE_AFTER;
+#endif
+
+    update_from = left;
+    update_to = left + block->length;
+    update_to = SrcScan(src, update_to, XawstEOL, XawsdRight, 1, False);
+    delta = block->length - (right - left);
+    if (delta < 0)
+	ctx->text.clear_to_eol = True;
+    if (update_to == update_from)
+	++update_to;
+    update_disabled = ctx->text.update_disabled;
+    ctx->text.update_disabled = True;
+    ctx->text.lastPos = XawTextGetLastPosition(ctx);
+    top = ctx->text.lt.info[0].position;
+
+    XawTextUnsetSelection((Widget)ctx);
+
+    if (delta) {
+	int i;
+	XmuSegment *seg;
+
+	for (seg = ctx->text.update->segment; seg; seg = seg->next) {
+	    if (seg->x1 > (int)left)
+		break;
+	    else if (seg->x2 > (int)left) {
+		seg->x2 += delta;
+		seg = seg->next;
+		break;
+	    }
+	}
+	for (; seg; seg = seg->next) {
+	    seg->x1 += delta;
+	    seg->x2 += delta;
+	}
+	XmuOptimizeScanline(ctx->text.update);
+
+	for (i = 0; i <= ctx->text.lt.lines; i++)
+	    if (ctx->text.lt.info[i].position > left)
+		break;
+	for (; i <= ctx->text.lt.lines; i++)
+	    ctx->text.lt.info[i].position += delta;
+    }
+
+    if (top != ctx->text.lt.info[0].position) {
+	line_from = line = 0;
+	ctx->text.lt.top = top = SrcScan(src, ctx->text.lt.info[0].position,
+					 XawstEOL, XawsdLeft, 1, False);
+	update_from = top;
+    }
+    else {
+	line_from = line = LineForPosition(ctx, update_from + delta);
+	top = ctx->text.lt.info[line].position;
+    }
+
+    if (line > 0 && ctx->text.wrap == XawtextWrapWord) {
+	--line;
+	top = ctx->text.lt.info[line].position;
+    }
+
+    (void)_BuildLineTable(ctx, top, line);
+
+    if (ctx->text.wrap == XawtextWrapWord) {
+	if (line_from != LineForPosition(ctx, update_from)
+	    || line_from != LineForPosition(ctx, update_to)) {
+	    ctx->text.clear_to_eol = True;
+	    update_from = SrcScan(src, update_from,
+				  XawstWhiteSpace, XawsdLeft, 1, True);
+	    if (update_to >= ctx->text.lastPos)
+	    /* this is not an error, it just tells _BuildLineTable to
+	     * clear to the bottom of the window. The value of update_to
+	     * should not be > ctx->text.lastPos.
+	     */
+		++update_to;
+	}
+    }
+    else if (!ctx->text.clear_to_eol) {
+	if (LineForPosition(ctx, update_from)
+	    != LineForPosition(ctx, update_to))
+	    ctx->text.clear_to_eol = True;
+    }
+
+    _XawTextNeedsUpdating(ctx, update_from, update_to);
+    ctx->text.update_disabled = update_disabled;
+}
+
+/*
+ * Function:
+ *	_XawTextReplace
+ *
+ * Parameters:
+ *	ctx   - text widget
+ *	left  - left offset
+ *	right - right offset
+ *	block - text block
+ *
+ * Description:
+ *	  Replaces the text between left and right by the text in block.
+ *	  Does all the required calculations of offsets, and rebuild the
+ *	the line table, from the insertion point (or previous line, if
+ *	wrap mode is 'word').
+ *
+ * Returns:
+ *	XawEditDone     - success
+ *	any other value - error code
+ */
+int
+_XawTextReplace(TextWidget ctx, XawTextPosition left, XawTextPosition right,
+		XawTextBlock *block)
+{
+    Arg args[1];
+    Widget src;
+    XawTextEditType edit_mode;
+
+    if (left == right && block->length == 0)
+	return (XawEditDone);
+
+    src = ctx->text.source;
+    XtSetArg(args[0], XtNeditType, &edit_mode);
+    XtGetValues(src, args, 1);
+
+    if (edit_mode == XawtextAppend) {
+	if (block->length == 0)
+	    return (XawEditError);
+	ctx->text.insertPos = ctx->text.lastPos;
+    }
+
+#ifndef OLDXAW
+    return (SrcReplace(src, left, right, block));
+#else
+    if (SrcReplace(src, left, right, block) == XawEditDone) {
+	_XawTextSourceChanged((Widget)ctx, left, right, block, 0);
+
+	return (XawEditDone);
+    }
+
+    return (XawEditError);
+#endif
+}
+
+/*
+ * This routine will display text between two arbitrary source positions.
+ * In the event that this span contains highlighted text for the selection,
+ * only that portion will be displayed highlighted.
+ */
+static void
+OldDisplayText(Widget w, XawTextPosition left, XawTextPosition right)
+{
+    static XmuSegment segment;
+    static XmuScanline next;
+    static XmuScanline scanline = {0, &segment, &next};
+    static XmuArea area = {&scanline};
+
+    TextWidget ctx = (TextWidget)w;
+    int x, y, line;
+    XawTextPosition start, end, last, final;
+    XmuScanline *scan;
+    XmuSegment *seg;
+    XmuArea *clip = NULL;
+    Bool cleol = ctx->text.clear_to_eol;
+    Bool has_selection = ctx->text.s.right > ctx->text.s.left;
+
+    left = left < ctx->text.lt.top ? ctx->text.lt.top : left;
+
+    if (left > right || !LineAndXYForPosition(ctx, left, &line, &x, &y))
+	return;
+
+    last = XawTextGetLastPosition(ctx);
+    segment.x2 = (int)XtWidth(ctx) - ctx->text.r_margin.right;
+
+    if (cleol)
+	clip = XmuCreateArea();
+
+    for (start = left; start < right && line < ctx->text.lt.lines; line++) {
+	if ((end = ctx->text.lt.info[line + 1].position) > right)
+	    end = right;
+
+	final = end;
+	if (end > last)
+	    end = last;
+
+	if (end > start) {
+	    if (!has_selection
+		|| (start >= ctx->text.s.right || end <= ctx->text.s.left))
+		_XawTextSinkDisplayText(ctx->text.sink, x, y, start, end, False);
+	    else if (start >= ctx->text.s.left && end <= ctx->text.s.right)
+		_XawTextSinkDisplayText(ctx->text.sink, x, y, start, end, True);
+	    else {
+		OldDisplayText(w, start, ctx->text.s.left);
+		OldDisplayText(w, Max(start, ctx->text.s.left),
+			       Min(end, ctx->text.s.right));
+		OldDisplayText(w, ctx->text.s.right, end);
+	    }
+	}
+
+	x = ctx->text.left_margin;
+	if (cleol) {
+	    segment.x1 = ctx->text.lt.info[line].textWidth + x;
+	    if (XmuValidSegment(&segment)) {
+		scanline.y = y;
+		next.y = ctx->text.lt.info[line + 1].y;
+		XmuAreaOr(clip, &area);
+	    }
+	}
+
+	start = final;
+	y = ctx->text.lt.info[line + 1].y;
+    }
+
+    if (cleol)  {
+	for (scan = clip->scanline; scan && scan->next; scan = scan->next)
+	    for (seg = scan->segment; seg; seg = seg->next)
+		SinkClearToBG(ctx->text.sink,
+			      seg->x1, scan->y,
+			      seg->x2 - seg->x1, scan->next->y - scan->y);
+	XmuDestroyArea(clip);
+    }
+}
+
+#ifndef OLDXAW
+/*ARGSUSED*/
+static void
+DisplayText(Widget w, XawTextPosition left, XawTextPosition right)
+{
+    static XmuSegment segment;
+    static XmuScanline next;
+    static XmuScanline scanline = {0, &segment, &next};
+    static XmuArea area = {&scanline};
+
+    TextWidget ctx = (TextWidget)w;
+    int y, line;
+    XawTextPosition from, to, lastPos;
+    Bool cleol = ctx->text.clear_to_eol;
+    Bool has_selection = ctx->text.s.right > ctx->text.s.left;
+    XawTextPaintList *paint_list;
+
+    left = left < ctx->text.lt.top ? ctx->text.lt.top : left;
+
+    if (left > right || !IsPositionVisible(ctx, left))
+	return;
+
+    line = LineForPosition(ctx, left);
+    y = ctx->text.lt.info[line].y;
+    segment.x2 = (int)XtWidth(ctx) - ctx->text.r_margin.right;
+    lastPos = XawTextGetLastPosition(ctx);
+
+    paint_list = ((TextSinkObject)ctx->text.sink)->text_sink.paint;
+
+    for (from = left; from < right && line < ctx->text.lt.lines; line++) {
+	if ((to = ctx->text.lt.info[line + 1].position) > right)
+	    to = right;
+
+	if (to > lastPos)
+	    to = lastPos;
+
+	if (from < to) {
+	    if (!has_selection
+		|| (from >= ctx->text.s.right || to <= ctx->text.s.left))
+		XawTextSinkPreparePaint(ctx->text.sink, y, line, from, to, False);
+	    else if (from >= ctx->text.s.left && to <= ctx->text.s.right)
+		XawTextSinkPreparePaint(ctx->text.sink, y, line, from, to, True);
+	    else {
+		XawTextSinkPreparePaint(ctx->text.sink, y, line, from,
+					ctx->text.s.left, False);
+		XawTextSinkPreparePaint(ctx->text.sink, y, line,
+					XawMax(from, ctx->text.s.left),
+					XawMin(to, ctx->text.s.right), True);
+		XawTextSinkPreparePaint(ctx->text.sink, y, line,
+					ctx->text.s.right, to, False);
+	    }
+	}
+
+	if (cleol) {
+	    segment.x1 = ctx->text.lt.info[line].textWidth + ctx->text.left_margin;
+	    if (XmuValidSegment(&segment)) {
+		scanline.y = y;
+		next.y = ctx->text.lt.info[line + 1].y;
+		XmuAreaOr(paint_list->clip, &area);
+	    }
+	}
+	y = ctx->text.lt.info[line + 1].y;
+	from = to;
+    }
+
+    /* clear to the bottom of the window */
+    if (cleol && line >= ctx->text.lt.lines) {
+	segment.x1 = ctx->text.left_margin;
+	if (XmuValidSegment(&segment)) {
+	    scanline.y = y;
+	    next.y = (int)XtHeight(ctx) - (int)ctx->text.margin.bottom;
+	    XmuAreaOr(paint_list->clip, &area);
+	}
+    }
+}
+#endif
+
+/*
+ * This routine implements multi-click selection in a hardwired manner.
+ * It supports multi-click entity cycling (char, word, line, file) and mouse
+ * motion adjustment of the selected entitie (i.e. select a word then, with
+ * button still down, adjust wich word you really meant by moving the mouse).
+ * [NOTE: This routine is to be replaced by a set of procedures that
+ * will allows clients to implements a wide class of draw through and
+ * multi-click selection user interfaces.]
+ */
+static void
+DoSelection(TextWidget ctx, XawTextPosition pos, Time time, Bool motion)
+{
+    XawTextPosition newLeft, newRight;
+    XawTextSelectType newType, *sarray;
+    Widget src = ctx->text.source;
+
+    if (motion)
+	newType = ctx->text.s.type;
+    else {
+	if ((abs((long) time - (long) ctx->text.lasttime) < MULTI_CLICK_TIME)
+	    && (pos >= ctx->text.s.left && pos <= ctx->text.s.right)) {
+	    sarray = ctx->text.sarray;
+	    for (; *sarray != XawselectNull && *sarray != ctx->text.s.type;
+		 sarray++)
+		;
+	    if (*sarray == XawselectNull)
+		newType = *(ctx->text.sarray);
+	    else {
+		newType = *(sarray + 1);
+		if (newType == XawselectNull)
+		    newType = *(ctx->text.sarray);
+	    }
+	}
+	else		/* single-click event */
+	    newType = *(ctx->text.sarray);
+
+	ctx->text.lasttime = time;
+    }
+    switch (newType) {
+	case XawselectPosition:
+	    newLeft = newRight = pos;
+	    break;
+	case XawselectChar:
+	    newLeft = pos;
+	    newRight = SrcScan(src, pos, XawstPositions, XawsdRight, 1, False);
+	    break;
+	case XawselectWord:
+	case XawselectParagraph:
+	case XawselectAlphaNumeric: {
+	    XawTextScanType stype;
+
+	    if (newType == XawselectWord)
+		stype = XawstWhiteSpace;
+	    else if (newType == XawselectParagraph)
+		stype = XawstParagraph;
+	    else
+		stype = XawstAlphaNumeric;
+
+	    /*
+	     * Somewhat complicated, but basically I treat the space between
+	     * two objects as another object.  The object that I am currently
+	     * in then becomes the end of the selection.
+	     *
+	     * Chris Peterson - 4/19/90.
+	     */
+	    newRight = SrcScan(ctx->text.source, pos, stype,
+			       XawsdRight, 1, False);
+	    newRight = SrcScan(ctx->text.source, newRight, stype,
+			       XawsdLeft, 1, False);
+
+	    if (pos != newRight)
+		newLeft = SrcScan(ctx->text.source, pos, stype,
+				  XawsdLeft, 1, False);
+	    else
+		newLeft = pos;
+
+	    newLeft =SrcScan(ctx->text.source, newLeft, stype,
+			     XawsdRight, 1, False);
+
+	    if (newLeft > newRight) {
+		XawTextPosition temp = newLeft;
+		newLeft = newRight;
+		newRight = temp;
+	    }
+	}   break;
+	case XawselectLine:
+	    newLeft = SrcScan(src, pos, XawstEOL, XawsdLeft, 1, False);
+	    newRight = SrcScan(src, pos, XawstEOL, XawsdRight, 1, False);
+	    break;
+	case XawselectAll:
+	    newLeft = SrcScan(src, pos, XawstAll, XawsdLeft, 1, False);
+	    newRight = SrcScan(src, pos, XawstAll, XawsdRight, 1, False);
+	    break;
+	default:
+	    XtAppWarning(XtWidgetToApplicationContext((Widget) ctx),
+			 "Text Widget: empty selection array.");
+	    return;
+    }
+
+    if (newLeft != ctx->text.s.left || newRight != ctx->text.s.right
+	|| newType != ctx->text.s.type) {
+	ModifySelection(ctx, newLeft, newRight);
+	if (pos - ctx->text.s.left < ctx->text.s.right - pos)
+	    ctx->text.insertPos = newLeft;
+	else
+	    ctx->text.insertPos = newRight;
+	ctx->text.s.type = newType;
+    }
+    if (!motion) {	/* setup so we can freely mix select extend calls*/
+	ctx->text.origSel.type = ctx->text.s.type;
+	ctx->text.origSel.left = ctx->text.s.left;
+	ctx->text.origSel.right = ctx->text.s.right;
+
+	if (pos >= ctx->text.s.left + (ctx->text.s.right - ctx->text.s.left) / 2)
+	    ctx->text.extendDir = XawsdRight;
+	else
+	    ctx->text.extendDir = XawsdLeft;
+    }
+}
+
+/*
+ * This routine implements extension of the currently selected text in
+ * the "current" mode (i.e. char word, line, etc.). It worries about
+ * extending from either end of the selection and handles the case when you
+ * cross through the "center" of the current selection (e.g. switch which
+ * end you are extending!).
+ */
+static void
+ExtendSelection(TextWidget ctx, XawTextPosition pos, Bool motion)
+{
+    XawTextScanDirection dir;
+
+    if (!motion) {	/* setup for extending selection */
+	if (ctx->text.s.left == ctx->text.s.right) /* no current selection. */
+	    ctx->text.s.left = ctx->text.s.right = ctx->text.insertPos;
+	else {
+	    ctx->text.origSel.left = ctx->text.s.left;
+	    ctx->text.origSel.right = ctx->text.s.right;
+	}
+
+	ctx->text.origSel.type = ctx->text.s.type;
+
+	if (pos >= ctx->text.s.left + (ctx->text.s.right - ctx->text.s.left) / 2)
+	    ctx->text.extendDir = XawsdRight;
+	else
+	    ctx->text.extendDir = XawsdLeft;
+    }
+    else	/* check for change in extend direction */
+	if ((ctx->text.extendDir == XawsdRight &&
+	     pos <= ctx->text.origSel.left) ||
+	    (ctx->text.extendDir == XawsdLeft &&
+	     pos >= ctx->text.origSel.right)) {
+	    ctx->text.extendDir = (ctx->text.extendDir == XawsdRight) ?
+		XawsdLeft : XawsdRight;
+	    ModifySelection(ctx, ctx->text.origSel.left, ctx->text.origSel.right);
+	}
+
+    dir = ctx->text.extendDir;
+    switch (ctx->text.s.type) {
+	case XawselectWord:
+	case XawselectParagraph:
+	case XawselectAlphaNumeric: {
+	    XawTextPosition left_pos, right_pos;
+	    XawTextScanType stype;
+
+	    if (ctx->text.s.type == XawselectWord)
+	        stype = XawstWhiteSpace;
+	    else if (ctx->text.s.type == XawselectParagraph)
+	        stype = XawstParagraph;
+	    else
+	        stype = XawstAlphaNumeric;
+
+	    /*
+	     * Somewhat complicated, but basically I treat the space between
+	     * two objects as another object.  The object that I am currently
+	     * in then becomes the end of the selection.
+	     *
+	     * Chris Peterson - 4/19/90.
+	     */
+	    right_pos = SrcScan(ctx->text.source, pos, stype,
+				XawsdRight, 1, False);
+	    right_pos =SrcScan(ctx->text.source, right_pos, stype,
+			       XawsdLeft, 1, False);
+
+	    if (pos != right_pos)
+		left_pos = SrcScan(ctx->text.source, pos, stype,
+				   XawsdLeft, 1, False);
+	    else
+		left_pos = pos;
+
+	    left_pos =SrcScan(ctx->text.source, left_pos, stype,
+			      XawsdRight, 1, False);
+
+	    if (dir == XawsdLeft)
+		pos = Min(left_pos, right_pos);
+	    else	/* dir == XawsdRight */
+		pos = Max(left_pos, right_pos);
+	}   break;
+	case XawselectLine:
+	    pos = SrcScan(ctx->text.source, pos, XawstEOL,
+			  dir, 1, dir == XawsdRight);
+	    break;
+	case XawselectAll:
+	    pos = ctx->text.insertPos;
+	    /*FALLTHROUGH*/
+	case XawselectPosition:
+	default:
+	    break;
+    }
+
+    if (dir == XawsdRight)
+	ModifySelection(ctx, ctx->text.s.left, pos);
+    else
+	ModifySelection(ctx, pos, ctx->text.s.right);
+
+    ctx->text.insertPos = pos;
+}
+
+/*
+ * Function:
+ *	_XawTextClearAndCenterDisplay
+ *
+ * Parameters:
+ *	ctx - text widget
+ *
+ * Description:
+ *	  Redraws the display with the cursor in insert point
+ *		     centered vertically.
+ */
+void
+_XawTextClearAndCenterDisplay(TextWidget ctx)
+{
+    int left_margin = ctx->text.left_margin;
+    Bool visible = IsPositionVisible(ctx, ctx->text.insertPos);
+
+    _XawTextShowPosition(ctx);
+
+    if (XtIsRealized((Widget)ctx) && visible &&
+	left_margin == ctx->text.left_margin) {
+	int insert_line = LineForPosition(ctx, ctx->text.insertPos);
+	int scroll_by = insert_line - (ctx->text.lt.lines >> 1);
+	Boolean clear_to_eol = ctx->text.clear_to_eol;
+
+	XawTextScroll(ctx, scroll_by, 0);
+	SinkClearToBG(ctx->text.sink, 0, 0, XtWidth(ctx), XtHeight(ctx));
+	ClearWindow(ctx);
+	clear_to_eol = ctx->text.clear_to_eol;
+	ctx->text.clear_to_eol = False;
+	FlushUpdate(ctx);
+	ctx->text.clear_to_eol = clear_to_eol;
+    }
+}
+
+/*
+ * Internal redisplay entire window
+ * Legal to call only if widget is realized
+ */
+static void
+DisplayTextWindow(Widget w)
+{
+    TextWidget ctx = (TextWidget)w;
+
+    _XawTextBuildLineTable(ctx, ctx->text.lt.top, False);
+    ClearWindow(ctx);
+}
+
+static void
+TextSinkResize(Widget w)
+{
+    if (w && XtClass(w)->core_class.resize)
+	XtClass(w)->core_class.resize(w);
+}
+
+/* ARGSUSED */
+void
+_XawTextCheckResize(TextWidget ctx)
+{
+    return;
+}
+
+/*
+ * Converts (params, num_params) to a list of atoms & caches the
+ * list in the TextWidget instance.
+ */
+Atom *
+_XawTextSelectionList(TextWidget ctx, String *list, Cardinal nelems)
+{
+    Atom *sel = ctx->text.s.selections;
+    Display *dpy = XtDisplay((Widget)ctx);
+    int n;
+
+    if (nelems > (Cardinal)ctx->text.s.array_size) {
+	sel = (Atom *)XtRealloc((char *)sel, sizeof(Atom) * nelems);
+	ctx->text.s.array_size = nelems;
+	ctx->text.s.selections = sel;
+    }
+    for (n = nelems; --n >= 0; sel++, list++)
+	*sel = XInternAtom(dpy, *list, False);
+    ctx->text.s.atom_count = nelems;
+
+    return (ctx->text.s.selections);
+}
+
+/*
+ * Function:
+ *	SetSelection
+ *
+ * Parameters:
+ *	ctx	   - text widget
+ *	defaultSel - default selection
+ *	l	   - left and right ends of the selection
+ *	r	   - ""
+ *	list	   - the selection list (as strings).
+ *	nelems	   - ""
+ *
+ * Description:
+ *	Sets the current selection.
+ *
+ * Note:
+ *	if (ctx->text.s.left >= ctx->text.s.right) then the selection is unset
+ */
+void
+_XawTextSetSelection(TextWidget ctx, XawTextPosition l, XawTextPosition r,
+		     String *list, Cardinal nelems)
+{
+    if (nelems == 1 && !strcmp (list[0], "none"))
+	return;
+    if (nelems == 0) {
+	String defaultSel = "PRIMARY";
+	list = &defaultSel;
+	nelems = 1;
+    }
+    _SetSelection(ctx, l, r, _XawTextSelectionList(ctx, list, nelems), nelems);
+}
+
+/*
+ * Function:
+ *	ModifySelection
+ *
+ * Parameters:
+ *	ctx   - text widget
+ *	left  - left and right ends of the selection
+ *	right - ""
+ *
+ * Description:
+ *	Modifies the current selection.
+ *
+ * Note:
+ *	if (ctx->text.s.left >= ctx->text.s.right) then the selection is unset
+ */
+static void
+ModifySelection(TextWidget ctx, XawTextPosition left, XawTextPosition right)
+{
+    if (left == right)
+	ctx->text.insertPos = left;
+    _SetSelection(ctx, left, right, NULL, 0);
+}
+
+/*
+ * This routine is used to perform various selection functions. The goal is
+ * to be able to specify all the more popular forms of draw-through and
+ * multi-click selection user interfaces from the outside.
+ */
+void
+_XawTextAlterSelection(TextWidget ctx, XawTextSelectionMode mode,
+		       XawTextSelectionAction action, String *params,
+		       Cardinal *num_params)
+{
+    XawTextPosition position;
+    Boolean flag;
+
+    /*
+     * This flag is used by TextPop.c:DoReplace() to determine if the selection
+     * is okay to use, or if it has been modified.
+     */
+    if (ctx->text.search != NULL)
+	ctx->text.search->selection_changed = True;
+
+    position = PositionForXY(ctx, (int) ctx->text.ev_x, (int) ctx->text.ev_y);
+
+    flag = (action != XawactionStart);
+    if (mode == XawsmTextSelect)
+	DoSelection(ctx, position, ctx->text.time, flag);
+    else		/* mode == XawsmTextExtend */
+	ExtendSelection (ctx, position, flag);
+
+    if (action == XawactionEnd)
+	_XawTextSetSelection(ctx, ctx->text.s.left, ctx->text.s.right,
+			     params, *num_params);
+}
+
+/*
+ * Function:
+ *	UpdateTextInRectangle
+ *
+ * Parameters:
+ *	ctx  - the text widget
+ *	rect - rectangle
+ *
+ * Description:
+ *	Updates the text in the given rectangle
+ */
+static void
+UpdateTextInRectangle(TextWidget ctx, XRectangle *rect)
+{
+    XawTextLineTable *lt;
+    int line, y1, y2, x2;
+
+    y1 = rect->y;
+    y2 = y1 + rect->height;
+    x2 = rect->x + rect->width;
+
+    for (line = 0, lt = &ctx->text.lt; line < lt->lines; line++)
+	if (lt->info[line + 1].y > y1)
+	    break;
+    for (; line <= lt->lines; line++) {
+	if (lt->info[line].y > y2)
+	    break;
+	UpdateTextInLine(ctx, line, rect->x, x2);
+    }
+}
+
+/*
+ * This routine processes all "expose region" XEvents. In general, its job
+ * is to the best job at minimal re-paint of the text, displayed in the
+ * window, that it can.
+ */
+/* ARGSUSED */
+static void
+XawTextExpose(Widget w, XEvent *event, Region region)
+{
+    TextWidget ctx = (TextWidget)w;
+    Boolean clear_to_eol;
+    XRectangle expose;
+
+    if (event->type == Expose) {
+	expose.x = event->xexpose.x;
+	expose.y = event->xexpose.y;
+	expose.width = event->xexpose.width;
+	expose.height = event->xexpose.height;
+    }
+    else if (event->type == GraphicsExpose) {
+	expose.x = event->xgraphicsexpose.x;
+	expose.y = event->xgraphicsexpose.y;
+	expose.width = event->xgraphicsexpose.width;
+	expose.height = event->xgraphicsexpose.height;
+    }
+    else
+	return;
+
+    _XawTextPrepareToUpdate(ctx);
+
+    if (Superclass->core_class.expose)
+	(*Superclass->core_class.expose)(w, event, region);
+
+    clear_to_eol = ctx->text.clear_to_eol;
+    ctx->text.clear_to_eol = False;
+
+    UpdateTextInRectangle(ctx, &expose);
+    XawTextSinkGetCursorBounds(ctx->text.sink, &expose);
+    UpdateTextInRectangle(ctx, &expose);
+    SinkClearToBG(ctx->text.sink, expose.x, expose.y,
+		  expose.width, expose.height);
+    _XawTextExecuteUpdate(ctx);
+    ctx->text.clear_to_eol = clear_to_eol;
+}
+
+/*
+ * This routine does all setup required to syncronize batched screen updates
+ */
+void
+_XawTextPrepareToUpdate(TextWidget ctx)
+{
+    if (ctx->text.old_insert < 0) {
+	InsertCursor((Widget)ctx, XawisOff);
+	ctx->text.showposition = False;
+	ctx->text.old_insert = ctx->text.insertPos;
+	ctx->text.clear_to_eol = False;
+#ifndef OLDXAW
+	ctx->text.source_changed = SRC_CHANGE_NONE;
+#endif
+    }
+}
+
+/*
+ * This is a private utility routine used by _XawTextExecuteUpdate. It
+ * processes all the outstanding update requests and merges update
+ * ranges where possible.
+ */
+static void
+FlushUpdate(TextWidget ctx)
+{
+    XmuSegment *seg;
+    void (*display_text)(Widget, XawTextPosition, XawTextPosition);
+
+    if (XtIsRealized((Widget)ctx)) {
+	ctx->text.s.right = XawMin(ctx->text.s.right, ctx->text.lastPos);
+	ctx->text.s.left = XawMin(ctx->text.s.left, ctx->text.s.right);
+
+#ifndef OLDXAW
+	if (XawTextSinkBeginPaint(ctx->text.sink) == False)
+#endif
+	    display_text = OldDisplayText;
+#ifndef OLDXAW
+	else
+	    display_text = DisplayText;
+#endif
+	for (seg = ctx->text.update->segment; seg; seg = seg->next)
+	    (*display_text)((Widget)ctx,
+			    (XawTextPosition)seg->x1,
+			    (XawTextPosition)seg->x2);
+#ifndef OLDXAW
+	if (display_text != OldDisplayText) {
+	    XawTextSinkDoPaint(ctx->text.sink);
+	    XawTextSinkEndPaint(ctx->text.sink);
+	}
+#endif
+    }
+    (void)XmuScanlineXor(ctx->text.update, ctx->text.update);
+}
+
+static int
+CountLines(TextWidget ctx, XawTextPosition left, XawTextPosition right)
+{
+    if (ctx->text.wrap == XawtextWrapNever || left >= right)
+	return (1);
+    else {
+	XawTextPosition tmp;
+	int dim, lines = 0, wwidth = GetMaxTextWidth(ctx);
+
+	while (left < right) {
+	    tmp = left;
+	    XawTextSinkFindPosition(ctx->text.sink, left,
+				    ctx->text.left_margin,
+				    wwidth, ctx->text.wrap == XawtextWrapWord,
+				    &left, &dim, &dim);
+	    ++lines;
+	    if (tmp == left)
+	      ++left;
+	}
+
+	return (lines);
+    }
+    /*NOTREACHED*/
+}
+
+static int
+GetMaxTextWidth(TextWidget ctx)
+{
+    XRectangle cursor;
+    int width;
+
+    XawTextSinkGetCursorBounds(ctx->text.sink, &cursor);
+    width = (int)XtWidth(ctx) - RHMargins(ctx) - cursor.width;
+
+    return (XawMax(0, width));
+}
+
+/*
+ * Function:
+ *	_XawTextShowPosition
+ *
+ * Parameters:
+ *	ctx - the text widget to show the position
+ *
+ * Description:
+ *	  Makes sure the text cursor visible, scrolling the text window
+ *	if required.
+ */
+void
+_XawTextShowPosition(TextWidget ctx)
+{
+    /*
+     * Variable scroll is used to avoid scanning large files to calculate
+     * line offsets
+     */
+    int hpixels, vlines;
+    XawTextPosition first, last, top, tmp;
+    Bool visible, scroll;
+
+    if (!XtIsRealized((Widget)ctx))
+	return;
+
+    /*
+     * Checks if a horizontal scroll is required
+     */
+    if (ctx->text.wrap == XawtextWrapNever) {
+	int x, vwidth, distance, dim;
+	XRectangle rect;
+
+	vwidth = (int)XtWidth(ctx) - RHMargins(ctx);
+	last = SrcScan(ctx->text.source, ctx->text.insertPos,
+		       XawstEOL, XawsdLeft, 1, False);
+	XawTextSinkFindDistance(ctx->text.sink, last,
+				ctx->text.left_margin,
+				ctx->text.insertPos,
+				&distance, &first, &dim);
+	XawTextSinkGetCursorBounds(ctx->text.sink, &rect);
+	x = ctx->text.left_margin - ctx->text.r_margin.left;
+
+	if (x + distance + rect.width > vwidth)
+	    hpixels = x + distance + rect.width - vwidth + (vwidth >> 2);
+	else if (x + distance < 0)
+	    hpixels = x + distance - (vwidth >> 2);
+	else
+	    hpixels = 0;
+    }
+    else
+	hpixels = 0;
+
+    visible = IsPositionVisible(ctx, ctx->text.insertPos);
+
+    /*
+     * If the cursor is already visible
+     */
+    if (!hpixels && visible)
+	return;
+
+    scroll = ctx->core.background_pixmap == XtUnspecifiedPixmap && !hpixels;
+    vlines = 0;
+    first = ctx->text.lt.top;
+
+    /*
+     * Needs to scroll the text window
+     */
+    if (visible)
+      top = ctx->text.lt.top;
+    else {
+        top = SrcScan(ctx->text.source, ctx->text.insertPos,
+		      XawstEOL, XawsdLeft, 1, False);
+
+	/*
+	 * Finds the nearest left position from ctx->text.insertPos
+	 */
+	if (ctx->text.wrap != XawtextWrapNever) {
+	    int dim, vwidth = GetMaxTextWidth(ctx);
+
+	    last = top;
+	    /*CONSTCOND*/
+	    while (1) {
+		tmp = last;
+		XawTextSinkFindPosition(ctx->text.sink, last,
+					ctx->text.left_margin, vwidth,
+					ctx->text.wrap == XawtextWrapWord,
+					&last, &dim, &dim);
+		if (last == tmp)
+		    ++last;
+		if (last <= ctx->text.insertPos)
+		    top = last;
+		else
+		    break;
+	    }
+	}
+    }
+
+    if (scroll) {
+	if (ctx->text.insertPos < first) {	/* Scroll Down */
+	    while (first > top) {
+		last = first;
+		first = SrcScan(ctx->text.source, first,
+				XawstEOL, XawsdLeft, 2, False);
+		vlines -= CountLines(ctx, first, last);
+		if (-vlines >= ctx->text.lt.lines) {
+		    scroll = False;
+		    break;
+		}
+	    }
+	}
+	else if (!visible) {			/* Scroll Up */
+	    while (first < top) {
+		last = first;
+		first = SrcScan(ctx->text.source, first,
+				XawstEOL, XawsdRight, 1, True);
+		vlines += CountLines(ctx, last, first);
+		if (vlines > ctx->text.lt.lines) {
+		    scroll = False;
+		    break;
+		}
+	    }
+	}
+	else
+	    scroll = False;
+    }
+
+    /*
+     * If a portion of the text that will be scrolled is visible
+     */
+    if (scroll)
+	XawTextScroll(ctx, vlines ? vlines - (ctx->text.lt.lines >> 1) : 0, 0);
+    /*
+     * Else redraw the entire text window
+     */
+    else {
+	ctx->text.left_margin -= hpixels;
+	if (ctx->text.left_margin > ctx->text.r_margin.left)
+	    ctx->text.left_margin = ctx->text.margin.left =
+		ctx->text.r_margin.left;
+
+	if (!visible) {
+	    vlines = ctx->text.lt.lines >> 1;
+	    if (vlines)
+		top = SrcScan(ctx->text.source, ctx->text.insertPos,
+			      XawstEOL, XawsdLeft, vlines + 1, False);
+
+	    if (ctx->text.wrap != XawtextWrapNever) {
+		int dim;
+		int n_lines = CountLines(ctx, top, ctx->text.insertPos);
+		int vwidth = GetMaxTextWidth(ctx);
+
+		while (n_lines-- > vlines) {
+		    tmp = top;
+		    XawTextSinkFindPosition(ctx->text.sink, top,
+					    ctx->text.left_margin,
+					    vwidth,
+					    ctx->text.wrap == XawtextWrapWord,
+					    &top, &dim, &dim);
+		    if (tmp == top)
+			++top;
+		}
+	    }
+	    _XawTextBuildLineTable(ctx, top, True);
+	}
+	else
+	    ClearWindow(ctx);
+    }
+    ctx->text.clear_to_eol = True;
+}
+
+#ifndef OLDXAW
+static int
+ResolveLineNumber(TextWidget ctx)
+{
+    int line_number = ctx->text.lt.base_line;
+    XawTextPosition position = ctx->text.lt.top;
+
+    if (ctx->text.lt.base_line < 1)
+	return (ctx->text.line_number);
+
+    if (ctx->text.wrap == XawtextWrapNever
+	&& IsPositionVisible(ctx, ctx->text.insertPos))
+	line_number += LineForPosition(ctx, ctx->text.insertPos);
+    else if (position < ctx->text.insertPos) {
+	while (position < ctx->text.insertPos) {
+	    position = SrcScan(ctx->text.source, position,
+			       XawstEOL, XawsdRight, 1, True);
+	    if (position <= ctx->text.insertPos) {
+		++line_number;
+		if (position == ctx->text.lastPos) {
+		    line_number -= !_XawTextSourceNewLineAtEOF(ctx->text.source);
+		    break;
+		}
+	    }
+	}
+    }
+    else if (position > ctx->text.insertPos) {
+	while (position > ctx->text.insertPos) {
+	    position = SrcScan(ctx->text.source, position,
+			       XawstEOL, XawsdLeft, 1, False);
+	    if (--position >= ctx->text.insertPos)
+		--line_number;
+	}
+    }
+
+    return (line_number);
+}
+#endif
+
+/*
+ * This routine causes all batched screen updates to be performed
+ */
+void
+_XawTextExecuteUpdate(TextWidget ctx)
+{
+    if (ctx->text.update_disabled || ctx->text.old_insert < 0)
+	return;
+
+    if(ctx->text.old_insert != ctx->text.insertPos || ctx->text.showposition)
+	_XawTextShowPosition(ctx);
+
+    FlushUpdate(ctx);
+    InsertCursor((Widget)ctx, XawisOn);
+    ctx->text.old_insert = -1;
+#ifndef OLDXAW
+    _XawTextSetLineAndColumnNumber(ctx, False);
+#endif
+}
+
+static void
+XawTextDestroy(Widget w)
+{
+    TextWidget ctx = (TextWidget)w;
+
+    DestroyHScrollBar(ctx);
+    DestroyVScrollBar(ctx);
+
+    XtFree((char *)ctx->text.s.selections);
+    XtFree((char *)ctx->text.lt.info);
+    XtFree((char *)ctx->text.search);
+    XmuDestroyScanline(ctx->text.update);
+    XtReleaseGC((Widget)ctx, ctx->text.gc);
+}
+
+/*
+ * by the time we are managed (and get this far) we had better
+ * have both a source and a sink 
+ */
+static void
+XawTextResize(Widget w)
+{
+    TextWidget ctx = (TextWidget)w;
+
+    PositionVScrollBar(ctx);
+    PositionHScrollBar(ctx);
+    TextSinkResize(ctx->text.sink);
+
+    ctx->text.showposition = True;
+    _XawTextBuildLineTable(ctx, ctx->text.lt.top, True);
+}
+
+/*
+ * This routine allow the application program to Set attributes.
+ */
+/*ARGSUSED*/
+static Boolean
+XawTextSetValues(Widget current, Widget request, Widget cnew,
+		 ArgList args, Cardinal *num_args)
+{
+    TextWidget oldtw = (TextWidget)current;
+    TextWidget newtw = (TextWidget)cnew;
+    Boolean redisplay = False;
+    Boolean display_caret = newtw->text.display_caret;
+#ifndef OLDXAW
+    Boolean show_lc = False;
+#endif
+
+    newtw->text.display_caret = oldtw->text.display_caret;
+    _XawTextPrepareToUpdate(newtw);
+    newtw->text.display_caret = display_caret;
+
+    if (oldtw->text.r_margin.left != newtw->text.r_margin.left) {
+	newtw->text.left_margin = newtw->text.margin.left =
+	    newtw->text.r_margin.left;
+	if (newtw->text.vbar != NULL) {
+	    newtw->text.left_margin += XtWidth(newtw->text.vbar) +
+		XtBorderWidth(newtw->text.vbar);
+	}
+	redisplay = True;
+    }
+
+    if (oldtw->text.scroll_vert != newtw->text.scroll_vert) {
+	if (newtw->text.scroll_vert == XawtextScrollAlways)
+	    CreateVScrollBar(newtw);
+	else
+	    DestroyVScrollBar(newtw);
+
+	redisplay = True;
+    }
+
+    if (oldtw->text.r_margin.bottom != newtw->text.r_margin.bottom) {
+	newtw->text.margin.bottom = newtw->text.r_margin.bottom;
+	if (newtw->text.hbar != NULL)
+	    newtw->text.margin.bottom += newtw->text.hbar->core.height +
+		newtw->text.hbar->core.border_width;
+	redisplay = True;
+    }
+
+    if (oldtw->text.scroll_horiz != newtw->text.scroll_horiz) {
+	if (newtw->text.scroll_horiz == XawtextScrollAlways)
+	    CreateHScrollBar(newtw);
+	else
+	    DestroyHScrollBar(newtw);
+
+	redisplay = True;
+    }
+
+    if (oldtw->text.source != newtw->text.source) {
+#ifndef OLDXAW
+	show_lc = True;
+	_XawSourceRemoveText(oldtw->text.source, cnew,
+			     oldtw->text.source &&
+			     XtParent(oldtw->text.source) == cnew);
+	_XawSourceAddText(newtw->text.source, cnew);
+#endif
+	_XawTextSetSource((Widget)newtw, newtw->text.source, newtw->text.lt.top,
+			  newtw->text.insertPos);
+    }
+
+    newtw->text.redisplay_needed = False;
+    XtSetValues((Widget)newtw->text.source, args, *num_args);
+    XtSetValues((Widget)newtw->text.sink, args, *num_args);
+
+    if (oldtw->text.wrap != newtw->text.wrap
+	|| oldtw->text.lt.top != newtw->text.lt.top
+	|| oldtw->text.insertPos != newtw->text.insertPos
+	|| oldtw->text.r_margin.right != newtw->text.r_margin.right
+	|| oldtw->text.r_margin.top != newtw->text.r_margin.top
+	|| oldtw->text.sink != newtw->text.sink
+	|| newtw->text.redisplay_needed) {
+	if (oldtw->text.wrap != newtw->text.wrap) {
+	    newtw->text.left_margin = newtw->text.margin.left =
+		newtw->text.r_margin.left;
+	    if (oldtw->text.lt.top == newtw->text.lt.top)
+		newtw->text.lt.top = SrcScan(newtw->text.source, 0, XawstEOL,
+					     XawsdLeft, 1, False);
+	}
+	newtw->text.showposition = True;
+#ifndef OLDXAW
+	show_lc = True;
+	newtw->text.source_changed = SRC_CHANGE_OVERLAP;
+#endif
+	_XawTextBuildLineTable(newtw, newtw->text.lt.top, True);
+	redisplay = True;
+    }
+
+#ifndef OLDXAW
+    if (newtw->text.left_column < 0)
+	newtw->text.left_column = 0;
+    if (newtw->text.right_column < 0)
+	newtw->text.right_column = 0;
+#endif
+
+    _XawTextExecuteUpdate(newtw);
+
+#ifndef OLDXAW
+    if (show_lc)
+	_XawTextSetLineAndColumnNumber(newtw, True);
+#endif
+
+    if (redisplay)
+	_XawTextSetScrollBars(newtw);
+
+    return (redisplay);
+}
+
+/* invoked by the Simple widget's SetValues */
+static Bool
+XawTextChangeSensitive(Widget w)
+{
+    Arg args[1];
+    TextWidget tw = (TextWidget)w;
+
+    (*(&simpleClassRec)->simple_class.change_sensitive)(w);
+
+    XtSetArg(args[0], XtNancestorSensitive,
+	     (tw->core.ancestor_sensitive && tw->core.sensitive));
+    if (tw->text.vbar)
+	XtSetValues(tw->text.vbar, args, ONE);
+    if (tw->text.hbar)
+	XtSetValues(tw->text.hbar, args, ONE);
+    return (False);
+}
+
+/*
+ * Function:
+ *	XawTextGetValuesHook
+ *
+ * Parameters:
+ *	w	 - Text Widget
+ *	args	 - argument list
+ *	num_args - number of args
+ *
+ * Description:
+ *	  This is a get values hook routine that gets the
+ *		     values in the text source and sink.
+ */
+static void
+XawTextGetValuesHook(Widget w, ArgList args, Cardinal *num_args)
+{
+    XtGetValues(((TextWidget)w)->text.source, args, *num_args);
+    XtGetValues(((TextWidget)w)->text.sink, args, *num_args);
+}
+
+/*
+ * Function:
+ *	FindGoodPosition
+ *
+ * Parameters:
+ *	pos - any position
+ *
+ * Description:
+ *	Returns a valid position given any postition.
+ *
+ * Returns:
+ *	A position between (0 and lastPos)
+ */
+static XawTextPosition
+FindGoodPosition(TextWidget ctx, XawTextPosition pos)
+{
+    if (pos < 0)
+	return (0);
+    return (((pos > ctx->text.lastPos) ? ctx->text.lastPos : pos));
+}
+
+/* Li wrote this so the IM can find a given text position's screen position */
+void
+_XawTextPosToXY(Widget w, XawTextPosition pos, Position *x, Position *y)
+{
+    int line, ix, iy;
+
+    LineAndXYForPosition((TextWidget)w, pos, &line, &ix, &iy);
+    *x = ix;
+    *y = iy;
+}
+
+/*******************************************************************
+The following routines provide procedural interfaces to Text window state
+setting and getting. They need to be redone so than the args code can use
+them. I suggest we create a complete set that takes the context as an
+argument and then have the public version lookup the context and call the
+internal one. The major value of this set is that they have actual application
+clients and therefore the functionality provided is required for any future
+version of Text.
+********************************************************************/
+void
+XawTextDisplay(Widget w)
+{
+    TextWidget ctx = (TextWidget)w;
+
+    if (!XtIsRealized(w))
+	return;
+
+    _XawTextPrepareToUpdate(ctx);
+    ctx->text.clear_to_eol = True;
+    DisplayTextWindow(w);
+    _XawTextExecuteUpdate(ctx);
+}
+
+void
+XawTextSetSelectionArray(Widget w, XawTextSelectType *sarray)
+{
+    ((TextWidget)w)->text.sarray = sarray;
+}
+
+void
+XawTextGetSelectionPos(Widget w, XawTextPosition *left, XawTextPosition *right)
+{
+    *left = ((TextWidget)w)->text.s.left;
+    *right = ((TextWidget)w)->text.s.right;
+}
+
+void
+_XawTextSetSource(Widget w, Widget source,
+		  XawTextPosition top, XawTextPosition startPos)
+{
+    TextWidget ctx = (TextWidget)w;
+#ifndef OLDXAW
+    Bool resolve = False;
+#endif
+
+#ifndef OLDXAW
+    if (source != ctx->text.source)
+	_XawSourceRemoveText(ctx->text.source, w, ctx->text.source &&
+			     XtParent(ctx->text.source) == w);
+    _XawSourceAddText(source, w);
+
+    if (source != ctx->text.source || ctx->text.insertPos != startPos)
+	resolve = True;
+
+    ctx->text.source_changed = SRC_CHANGE_OVERLAP;
+#endif
+    ctx->text.source = source;
+    ctx->text.s.left = ctx->text.s.right = 0;
+    ctx->text.lastPos = GETLASTPOS;
+    top = FindGoodPosition(ctx, top);
+    startPos = FindGoodPosition(ctx, startPos);
+    ctx->text.insertPos = ctx->text.old_insert = startPos;
+    _XawTextPrepareToUpdate(ctx);
+
+    _XawTextBuildLineTable(ctx, top, True);
+
+    _XawTextExecuteUpdate(ctx);
+#ifndef OLDXAW
+    if (resolve)
+	_XawTextSetLineAndColumnNumber(ctx, True);
+#endif
+}
+
+void
+XawTextSetSource(Widget w, Widget source, XawTextPosition top)
+{
+    _XawTextSetSource(w, source, top, top);
+}
+
+/*
+ * This public routine deletes the text from startPos to endPos in a source and
+ * then inserts, at startPos, the text that was passed. As a side effect it
+ * "invalidates" that portion of the displayed text (if any), so that things
+ * will be repainted properly.
+ */
+int
+XawTextReplace(Widget w, XawTextPosition startPos, XawTextPosition endPos,
+	       XawTextBlock *text)
+{
+    TextWidget ctx = (TextWidget)w;
+    int result;
+#ifndef OLDXAW
+    Cardinal i;
+    TextSrcObject src = (TextSrcObject)ctx->text.source;
+
+    for (i = 0; i < src->textSrc.num_text; i++)
+	_XawTextPrepareToUpdate((TextWidget)src->textSrc.text[i]);
+#else
+    _XawTextPrepareToUpdate(ctx);
+#endif
+
+    endPos = FindGoodPosition(ctx, endPos);
+    startPos = FindGoodPosition(ctx, startPos);
+    result = _XawTextReplace(ctx, startPos, endPos, text);
+
+#ifndef OLDXAW
+    for (i = 0; i < src->textSrc.num_text; i++)
+	_XawTextExecuteUpdate((TextWidget)src->textSrc.text[i]);
+#else
+    _XawTextExecuteUpdate(ctx);
+#endif
+
+    return (result);
+}
+
+XawTextPosition 
+XawTextTopPosition(Widget w)
+{
+    return (((TextWidget)w)->text.lt.top);
+}
+
+XawTextPosition 
+XawTextLastPosition(Widget w)
+{
+    return (((TextWidget)w)->text.lastPos);
+}
+
+void
+XawTextSetInsertionPoint(Widget w, XawTextPosition position)
+{
+    TextWidget ctx = (TextWidget)w;
+
+    _XawTextPrepareToUpdate(ctx);
+    ctx->text.insertPos = FindGoodPosition(ctx, position);
+    ctx->text.showposition = True;
+    ctx->text.from_left = -1;
+
+    _XawTextExecuteUpdate(ctx);
+#ifndef OLDXAW
+    _XawTextSetLineAndColumnNumber(ctx, False);
+#endif
+}
+
+XawTextPosition
+XawTextGetInsertionPoint(Widget w)
+{
+    return (((TextWidget)w)->text.insertPos);
+}
+
+/*
+ * Note: Must walk the selection list in opposite order from TextLoseSelection
+ */
+void
+XawTextUnsetSelection(Widget w)
+{
+    TextWidget ctx = (TextWidget)w;
+
+    while (ctx->text.s.atom_count != 0) {
+	Atom sel = ctx->text.s.selections[ctx->text.s.atom_count - 1];
+
+	if (sel != (Atom) 0) {
+	    /*
+	     * As selections are lost the atom_count will decrement
+	     */
+	    if (GetCutBufferNumber(sel) == NOT_A_CUT_BUFFER)
+		XtDisownSelection(w, sel, ctx->text.time);
+	    TextLoseSelection(w, &sel); /* In case this is a cut buffer, or
+					   XtDisownSelection failed to call us */
+	}
+    }
+}
+
+void
+XawTextSetSelection(Widget w, XawTextPosition left, XawTextPosition right)
+{
+    TextWidget ctx = (TextWidget)w;
+
+    _XawTextPrepareToUpdate(ctx);
+    _XawTextSetSelection(ctx, FindGoodPosition(ctx, left),
+			 FindGoodPosition(ctx, right), NULL, 0);
+    _XawTextExecuteUpdate(ctx);
+}
+
+void
+XawTextInvalidate(Widget w, XawTextPosition from, XawTextPosition to)
+{
+    TextWidget ctx = (TextWidget)w;
+
+    from = FindGoodPosition(ctx, from);
+    to = FindGoodPosition(ctx, to);
+    ctx->text.lastPos = GETLASTPOS;
+    _XawTextPrepareToUpdate(ctx);
+    _XawTextNeedsUpdating(ctx, from, to);
+    _XawTextExecuteUpdate(ctx);
+}
+
+/*ARGSUSED*/
+void
+XawTextDisableRedisplay(Widget w)
+{
+    ((TextWidget)w)->text.update_disabled = True;
+    _XawTextPrepareToUpdate((TextWidget)w);
+}
+
+void 
+XawTextEnableRedisplay(Widget w)
+{
+    TextWidget ctx = (TextWidget)w;
+    XawTextPosition lastPos;
+
+    if (!ctx->text.update_disabled)
+	return;
+
+    ctx->text.update_disabled = False;
+    lastPos = ctx->text.lastPos = GETLASTPOS;
+    ctx->text.lt.top = FindGoodPosition(ctx, ctx->text.lt.top);
+    ctx->text.insertPos = FindGoodPosition(ctx, ctx->text.insertPos);
+
+    if (ctx->text.s.left > lastPos || ctx->text.s.right > lastPos)
+	ctx->text.s.left = ctx->text.s.right = 0;
+
+    _XawTextExecuteUpdate(ctx);
+}
+
+Widget
+XawTextGetSource(Widget w)
+{
+    return (((TextWidget)w)->text.source);
+}
+
+Widget
+XawTextGetSink(Widget w)
+{
+    return (((TextWidget)w)->text.sink);
+}
+
+void
+XawTextDisplayCaret(Widget w,
+#if NeedWidePrototypes
+	int display_caret
+#else
+	Boolean display_caret
+#endif
+)
+{
+    TextWidget ctx = (TextWidget)w;
+
+    if (XtIsRealized(w)) {
+	_XawTextPrepareToUpdate(ctx);
+	ctx->text.display_caret = display_caret;
+	_XawTextExecuteUpdate(ctx);
+    }
+    else
+	ctx->text.display_caret = display_caret;
+}
+
+/*
+ * Function:
+ *	XawTextSearch
+ *
+ * Parameters:
+ *	w    - text widget
+ *	dir  - direction to search
+ *	text - text block containing info about the string to search for
+ *
+ * Description:
+ *	Searches for the given text block.
+ *
+ * Returns:
+ *	The position of the text found, or XawTextSearchError on an error
+ */
+XawTextPosition
+XawTextSearch(Widget w,
+#if NeedWidePrototypes
+	int dir,
+#else
+	XawTextScanDirection dir,
+#endif
+	XawTextBlock *text)
+{
+    TextWidget ctx = (TextWidget)w;
+
+    return (SrcSearch(ctx->text.source, ctx->text.insertPos, dir, text));
+}
+
+TextClassRec textClassRec = {
+  /* core */
+  {
+    (WidgetClass)&simpleClassRec,	/* superclass */ 
+    "Text",				/* class_name */
+    sizeof(TextRec),			/* widget_size */
+    XawTextClassInitialize,		/* class_initialize */
+    NULL,				/* class_part_init */
+    False,				/* class_inited */
+    XawTextInitialize,			/* initialize */
+    NULL,				/* initialize_hook */
+    XawTextRealize,			/* realize */
+    _XawTextActionsTable,		/* actions */
+    0,					/* num_actions */
+    resources,				/* resources */
+    XtNumber(resources),		/* num_resource */
+    NULLQUARK,				/* xrm_class */
+    True,				/* compress_motion */
+    XtExposeGraphicsExpose |		/* compress_exposure */
+	XtExposeNoExpose,
+    True,				/* compress_enterleave */
+    False,				/* visible_interest */
+    XawTextDestroy,			/* destroy */
+    XawTextResize,			/* resize */
+    XawTextExpose,			/* expose */
+    XawTextSetValues,			/* set_values */
+    NULL,				/* set_values_hook */
+    XtInheritSetValuesAlmost,		/* set_values_almost */
+    XawTextGetValuesHook,		/* get_values_hook */
+    NULL,				/* accept_focus */
+    XtVersion,				/* version */
+    NULL,				/* callback_private */
+    _XawDefaultTextTranslations,	/* tm_table */
+    XtInheritQueryGeometry,		/* query_geometry */
+    XtInheritDisplayAccelerator,	/* display_accelerator */
+    NULL,				/* extension */
+  },
+  /* simple */
+  {
+    XawTextChangeSensitive,		/* change_sensitive */
+  },
+  /* text */
+  {
+    NULL,				/* extension */
+  }
+};
+
+WidgetClass textWidgetClass = (WidgetClass)&textClassRec;