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, 3284 insertions, 0 deletions

diff --git a/nx-X11/programs/xterm/button.c b/nx-X11/programs/xterm/button.c
new file mode 100644
index 000000000..d8d0b32b3
--- /dev/null
+++ b/nx-X11/programs/xterm/button.c
@@ -0,0 +1,3284 @@
+/* $XTermId: button.c,v 1.197 2005/11/03 13:17:27 tom Exp $ */
+
+/* $Xorg: button.c,v 1.3 2000/08/17 19:55:08 cpqbld Exp $ */
+/*
+ * Copyright 1999-2004,2005 by Thomas E. Dickey
+ *
+ *                         All Rights Reserved
+ *
+ * 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 ABOVE LISTED COPYRIGHT HOLDER(S) 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(s) of the above copyright
+ * holders shall not be used in advertising or otherwise to promote the
+ * sale, use or other dealings in this Software without prior written
+ * authorization.
+ *
+ *
+ * Copyright 1987 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 Equipment
+ * Corporation 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.
+ */
+/* $XFree86: xc/programs/xterm/button.c,v 3.82 2005/11/03 13:17:27 dickey Exp $ */
+
+/*
+button.c	Handles button events in the terminal emulator.
+		does cut/paste operations, change modes via menu,
+		passes button events through to some applications.
+				J. Gettys.
+*/
+
+#include <xterm.h>
+
+#include <stdio.h>
+
+#include <X11/Xatom.h>
+#include <X11/Xmu/Atoms.h>
+#include <X11/Xmu/StdSel.h>
+
+#include <xutf8.h>
+
+#include <data.h>
+#include <error.h>
+#include <menu.h>
+#include <xcharmouse.h>
+#include <charclass.h>
+
+#if OPT_WIDE_CHARS
+#include <wcwidth.h>
+#else
+#define CharacterClass(value) \
+	charClass[value & ((sizeof(charClass)/sizeof(charClass[0]))-1)]
+#endif
+
+#define XTERM_CELL(row,col) getXtermCell(screen, row + screen->topline, col)
+#define XTERM_CELL_C1(row,col) getXtermCellComb1(screen, row + screen->topline, col)
+#define XTERM_CELL_C2(row,col) getXtermCellComb2(screen, row + screen->topline, col)
+
+      /*
+       * We reserve shift modifier for cut/paste operations.  In principle we
+       * can pass through control and meta modifiers, but in practice, the
+       * popup menu uses control, and the window manager is likely to use meta,
+       * so those events are not delivered to SendMousePosition.
+       */
+#define OurModifiers (ShiftMask | ControlMask | Mod1Mask)
+#define AllModifiers (ShiftMask | LockMask | ControlMask | Mod1Mask | \
+		      Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask)
+
+#define KeyModifiers (event->xbutton.state & OurModifiers)
+
+#define KeyState(x) (((x) & (ShiftMask|ControlMask)) + (((x) & Mod1Mask) ? 2 : 0))
+    /* adds together the bits:
+       shift key -> 1
+       meta key  -> 2
+       control key -> 4 */
+
+#define	Coordinate(r,c)		((r) * MaxCols(&(term->screen)) + (c))
+
+#if OPT_DEC_LOCATOR
+static ANSI reply;
+#endif
+
+/* Selection/extension variables */
+
+/* Raw char position where the selection started */
+static int rawRow, rawCol;
+
+/* Selected area before CHAR, WORD, LINE selectUnit processing */
+static int startRRow, startRCol, endRRow, endRCol = 0;
+
+/* Selected area after CHAR, WORD, LINE selectUnit processing */
+static int startSRow, startSCol, endSRow, endSCol = 0;
+
+/* Valid rows for selection clipping */
+static int firstValidRow, lastValidRow;
+
+/* Start, end of extension */
+static int startERow, startECol, endERow, endECol;
+
+/* Saved values of raw selection for extend to restore to */
+static int saveStartRRow, saveStartRCol, saveEndRRow, saveEndRCol;
+
+/* Saved value of WORD selection for LINE processing to restore to */
+static int saveStartWRow, saveStartWCol;
+
+/* Multi-click handling */
+static int numberOfClicks = 0;
+static Time lastButtonUpTime = 0;
+
+#if OPT_READLINE
+static Time lastButtonDownTime = 0;
+static int ExtendingSelection = 0;
+static Time lastButton3UpTime = 0;
+static Time lastButton3DoubleDownTime = 0;
+static int lastButton3row, lastButton3col;	/* At the release time */
+#endif /* OPT_READLINE */
+
+typedef int SelectUnit;
+
+#define SELECTCHAR 0
+#define SELECTWORD 1
+#define SELECTLINE 2
+#define NSELECTUNITS 3
+static SelectUnit selectUnit;
+
+/* Send emacs escape code when done selecting or extending? */
+static int replyToEmacs;
+
+static Char *SaveText(TScreen * screen, int row, int scol, int ecol, Char *
+		      lp, int *eol);
+static int Length(TScreen * screen, int row, int scol, int ecol);
+static void ComputeSelect(int startRow, int startCol, int endRow, int
+			  endCol, Bool extend);
+static void EditorButton(XButtonEvent * event);
+static void EndExtend(Widget w, XEvent * event, String * params, Cardinal
+		      num_params, Bool use_cursor_loc);
+static void ExtendExtend(int row, int col);
+static void PointToRowCol(int y, int x, int *r, int *c);
+static void ReHiliteText(int frow, int fcol, int trow, int tcol);
+static void SaltTextAway(int crow, int ccol, int row, int col, String *
+			 params, Cardinal num_params);
+static void SelectSet(Widget w, XEvent * event, String * params, Cardinal num_params);
+static void SelectionReceived PROTO_XT_SEL_CB_ARGS;
+static void StartSelect(int startrow, int startcol);
+static void TrackDown(XButtonEvent * event);
+static void _OwnSelection(XtermWidget termw, String * selections, Cardinal count);
+static void do_select_end(Widget w, XEvent * event, String * params,
+			  Cardinal *num_params, Bool use_cursor_loc);
+
+Bool
+SendMousePosition(Widget w, XEvent * event)
+{
+    TScreen *screen;
+
+    if (!IsXtermWidget(w))
+	return False;
+
+    screen = &((XtermWidget) w)->screen;
+
+    /* If send_mouse_pos mode isn't on, we shouldn't be here */
+    if (screen->send_mouse_pos == MOUSE_OFF)
+	return False;
+
+#if OPT_DEC_LOCATOR
+    if (screen->send_mouse_pos == DEC_LOCATOR) {
+	return (SendLocatorPosition(w, event));
+    }
+#endif /* OPT_DEC_LOCATOR */
+
+    /* Make sure the event is an appropriate type */
+    if ((screen->send_mouse_pos != BTN_EVENT_MOUSE)
+	&& (screen->send_mouse_pos != ANY_EVENT_MOUSE)
+	&& event->type != ButtonPress
+	&& event->type != ButtonRelease)
+	return False;
+
+    switch (screen->send_mouse_pos) {
+    case X10_MOUSE:		/* X10 compatibility sequences */
+
+	if (KeyModifiers == 0) {
+	    if (event->type == ButtonPress)
+		EditorButton((XButtonEvent *) event);
+	    return True;
+	}
+	return False;
+
+    case VT200_HIGHLIGHT_MOUSE:	/* DEC vt200 hilite tracking */
+	if (event->type == ButtonPress &&
+	    KeyModifiers == 0 &&
+	    event->xbutton.button == Button1) {
+	    TrackDown((XButtonEvent *) event);
+	    return True;
+	}
+	if (KeyModifiers == 0 || KeyModifiers == ControlMask) {
+	    EditorButton((XButtonEvent *) event);
+	    return True;
+	}
+	return False;
+
+    case VT200_MOUSE:		/* DEC vt200 compatible */
+
+	/* xterm extension for motion reporting. June 1998 */
+	/* EditorButton() will distinguish between the modes */
+    case BTN_EVENT_MOUSE:
+    case ANY_EVENT_MOUSE:
+	if (KeyModifiers == 0 || KeyModifiers == ControlMask) {
+	    EditorButton((XButtonEvent *) event);
+	    return True;
+	}
+	return False;
+
+    default:
+	return False;
+    }
+}
+
+#if OPT_DEC_LOCATOR
+
+#define	LocatorCoords( row, col, x, y, oor )			\
+    if( screen->locator_pixels ) {				\
+	(oor)=False; (row) = (y)+1; (col) = (x)+1;		\
+	/* Limit to screen dimensions */			\
+	if ((row) < 1) (row) = 1,(oor)=True;			\
+	else if ((row) > screen->border*2+Height(screen))	\
+	    (row) = screen->border*2+Height(screen),(oor)=True;	\
+	if ((col) < 1) (col) = 1,(oor)=True;			\
+	else if ((col) > OriginX(screen)*2+Width(screen))	\
+	    (col) = OriginX(screen)*2+Width(screen),(oor)=True;	\
+    } else {							\
+	(oor)=False;						\
+	/* Compute character position of mouse pointer */	\
+	(row) = ((y) - screen->border) / FontHeight(screen);	\
+	(col) = ((x) - OriginX(screen)) / FontWidth(screen);	\
+	/* Limit to screen dimensions */			\
+	if ((row) < 0) (row) = 0,(oor)=True;			\
+	else if ((row) > screen->max_row)			\
+	    (row) = screen->max_row,(oor)=True;			\
+	if ((col) < 0) (col) = 0,(oor)=True;			\
+	else if ((col) > screen->max_col)			\
+	    (col) = screen->max_col,(oor)=True;			\
+	(row)++; (col)++;					\
+    }
+
+Bool
+SendLocatorPosition(Widget w, XEvent * event)
+{
+    TScreen *screen = &((XtermWidget) w)->screen;
+    int row, col;
+    Bool oor;
+    int button;
+    int state;
+
+    /* Make sure the event is an appropriate type */
+    if ((event->type != ButtonPress &&
+	 event->type != ButtonRelease &&
+	 !screen->loc_filter) ||
+	(KeyModifiers != 0 && KeyModifiers != ControlMask))
+	return (False);
+
+    if ((event->type == ButtonPress &&
+	 !(screen->locator_events & LOC_BTNS_DN)) ||
+	(event->type == ButtonRelease &&
+	 !(screen->locator_events & LOC_BTNS_UP)))
+	return (True);
+
+    if (event->type == MotionNotify) {
+	CheckLocatorPosition(w, event);
+	return (True);
+    }
+
+    /* get button # */
+    button = event->xbutton.button - 1;
+
+    LocatorCoords(row, col, event->xbutton.x, event->xbutton.y, oor);
+
+    /*
+     * DECterm mouse:
+     *
+     * ESCAPE '[' event ; mask ; row ; column '&' 'w'
+     */
+    reply.a_type = CSI;
+
+    if (oor) {
+	reply.a_nparam = 1;
+	reply.a_param[0] = 0;	/* Event - 0 = locator unavailable */
+	reply.a_inters = '&';
+	reply.a_final = 'w';
+	unparseseq(&reply, screen->respond);
+
+	if (screen->locator_reset) {
+	    MotionOff(screen, term);
+	    screen->send_mouse_pos = MOUSE_OFF;
+	}
+	return (True);
+    }
+
+    /*
+     * event:
+     *        1       no buttons
+     *        2       left button down
+     *        3       left button up
+     *        4       middle button down
+     *        5       middle button up
+     *        6       right button down
+     *        7       right button up
+     *        8       M4 down
+     *        9       M4 up
+     */
+    reply.a_nparam = 4;
+    switch (event->type) {
+    case ButtonPress:
+	reply.a_param[0] = 2 + (button << 1);
+	break;
+    case ButtonRelease:
+	reply.a_param[0] = 3 + (button << 1);
+	break;
+    default:
+	return (True);
+    }
+    /*
+     * mask:
+     * bit 7   bit 6   bit 5   bit 4   bit 3   bit 2       bit 1         bit 0
+     *                                 M4 down left down   middle down   right down
+     *
+     * Notice that Button1 (left) and Button3 (right) are swapped in the mask.
+     * Also, mask should be the state after the button press/release,
+     * X provides the state not including the button press/release.
+     */
+    state = (event->xbutton.state
+	     & (Button1Mask | Button2Mask | Button3Mask | Button4Mask)) >> 8;
+    state ^= 1 << button;	/* update mask to "after" state */
+    state = (state & ~(4 | 1)) | ((state & 1) ? 4 : 0) | ((state & 4) ? 1 : 0);		/* swap Button1 & Button3 */
+
+    reply.a_param[1] = state;
+    reply.a_param[2] = row;
+    reply.a_param[3] = col;
+    reply.a_inters = '&';
+    reply.a_final = 'w';
+
+    unparseseq(&reply, screen->respond);
+
+    if (screen->locator_reset) {
+	MotionOff(screen, term);
+	screen->send_mouse_pos = MOUSE_OFF;
+    }
+
+    /*
+     * DECterm turns the Locator off if a button is pressed while a filter rectangle
+     * is active. This might be a bug, but I don't know, so I'll emulate it anyways.
+     */
+    if (screen->loc_filter) {
+	screen->send_mouse_pos = MOUSE_OFF;
+	screen->loc_filter = False;
+	screen->locator_events = 0;
+	MotionOff(screen, term);
+    }
+
+    return (True);
+}
+
+/*
+ * mask:
+ * bit 7   bit 6   bit 5   bit 4   bit 3   bit 2       bit 1         bit 0
+ *                                 M4 down left down   middle down   right down
+ *
+ * Button1 (left) and Button3 (right) are swapped in the mask relative to X.
+ */
+#define	ButtonState(state, mask)	\
+{ (state) = ((mask) & (Button1Mask | Button2Mask | Button3Mask | Button4Mask)) >> 8;	\
+  /* swap Button1 & Button3 */								\
+  (state) = ((state) & ~(4|1)) | (((state)&1)?4:0) | (((state)&4)?1:0);			\
+}
+
+void
+GetLocatorPosition(XtermWidget w)
+{
+    TScreen *screen = &w->screen;
+    Window root, child;
+    int rx, ry, x, y;
+    unsigned int mask;
+    int row = 0, col = 0;
+    Bool oor = False;
+    Bool ret = False;
+    int state;
+
+    /*
+     * DECterm turns the Locator off if the position is requested while a filter rectangle
+     * is active.  This might be a bug, but I don't know, so I'll emulate it anyways.
+     */
+    if (screen->loc_filter) {
+	screen->send_mouse_pos = MOUSE_OFF;
+	screen->loc_filter = False;
+	screen->locator_events = 0;
+	MotionOff(screen, term);
+    }
+
+    reply.a_type = CSI;
+
+    if (screen->send_mouse_pos == DEC_LOCATOR) {
+	ret = XQueryPointer(screen->display, VWindow(screen), &root,
+			    &child, &rx, &ry, &x, &y, &mask);
+	if (ret) {
+	    LocatorCoords(row, col, x, y, oor);
+	}
+    }
+    if (ret == False || oor) {
+	reply.a_nparam = 1;
+	reply.a_param[0] = 0;	/* Event - 0 = locator unavailable */
+	reply.a_inters = '&';
+	reply.a_final = 'w';
+	unparseseq(&reply, screen->respond);
+
+	if (screen->locator_reset) {
+	    MotionOff(screen, term);
+	    screen->send_mouse_pos = MOUSE_OFF;
+	}
+	return;
+    }
+
+    ButtonState(state, mask);
+
+    reply.a_nparam = 4;
+    reply.a_param[0] = 1;	/* Event - 1 = response to locator request */
+    reply.a_param[1] = state;
+    reply.a_param[2] = row;
+    reply.a_param[3] = col;
+    reply.a_inters = '&';
+    reply.a_final = 'w';
+    unparseseq(&reply, screen->respond);
+
+    if (screen->locator_reset) {
+	MotionOff(screen, term);
+	screen->send_mouse_pos = MOUSE_OFF;
+    }
+}
+
+void
+InitLocatorFilter(XtermWidget w)
+{
+    TScreen *screen = &w->screen;
+    Window root, child;
+    int rx, ry, x, y;
+    unsigned int mask;
+    int row = 0, col = 0;
+    Bool oor = 0;
+    Bool ret;
+    int state;
+
+    ret = XQueryPointer(screen->display, VWindow(screen),
+			&root, &child, &rx, &ry, &x, &y, &mask);
+    if (ret) {
+	LocatorCoords(row, col, x, y, oor);
+    }
+    if (ret == False || oor) {
+	/* Locator is unavailable */
+
+	if (screen->loc_filter_top != LOC_FILTER_POS ||
+	    screen->loc_filter_left != LOC_FILTER_POS ||
+	    screen->loc_filter_bottom != LOC_FILTER_POS ||
+	    screen->loc_filter_right != LOC_FILTER_POS) {
+	    /*
+	     * If any explicit coordinates were received,
+	     * report immediately with no coordinates.
+	     */
+	    reply.a_type = CSI;
+	    reply.a_nparam = 1;
+	    reply.a_param[0] = 0;	/* Event - 0 = locator unavailable */
+	    reply.a_inters = '&';
+	    reply.a_final = 'w';
+	    unparseseq(&reply, screen->respond);
+
+	    if (screen->locator_reset) {
+		MotionOff(screen, term);
+		screen->send_mouse_pos = MOUSE_OFF;
+	    }
+	} else {
+	    /*
+	     * No explicit coordinates were received, and the pointer is
+	     * unavailable.  Report when the pointer re-enters the window.
+	     */
+	    screen->loc_filter = True;
+	    MotionOn(screen, term);
+	}
+	return;
+    }
+
+    /*
+     * Adjust rectangle coordinates:
+     *  1. Replace "LOC_FILTER_POS" with current coordinates
+     *  2. Limit coordinates to screen size
+     *  3. make sure top and left are less than bottom and right, resp.
+     */
+    if (screen->locator_pixels) {
+	rx = OriginX(screen) * 2 + Width(screen);
+	ry = screen->border * 2 + Height(screen);
+    } else {
+	rx = screen->max_col;
+	ry = screen->max_row;
+    }
+
+#define	Adjust( coord, def, max )				\
+	if( (coord) == LOC_FILTER_POS )	(coord) = (def);	\
+	else if ((coord) < 1)		(coord) = 1;		\
+	else if ((coord) > (max))	(coord) = (max)
+
+    Adjust(screen->loc_filter_top, row, ry);
+    Adjust(screen->loc_filter_left, col, rx);
+    Adjust(screen->loc_filter_bottom, row, ry);
+    Adjust(screen->loc_filter_right, col, rx);
+
+    if (screen->loc_filter_top > screen->loc_filter_bottom) {
+	ry = screen->loc_filter_top;
+	screen->loc_filter_top = screen->loc_filter_bottom;
+	screen->loc_filter_bottom = ry;
+    }
+
+    if (screen->loc_filter_left > screen->loc_filter_right) {
+	rx = screen->loc_filter_left;
+	screen->loc_filter_left = screen->loc_filter_right;
+	screen->loc_filter_right = rx;
+    }
+
+    if ((col < screen->loc_filter_left) ||
+	(col > screen->loc_filter_right) ||
+	(row < screen->loc_filter_top) ||
+	(row > screen->loc_filter_bottom)) {
+	/* Pointer is already outside the rectangle - report immediately */
+	ButtonState(state, mask);
+
+	reply.a_type = CSI;
+	reply.a_nparam = 4;
+	reply.a_param[0] = 10;	/* Event - 10 = locator outside filter */
+	reply.a_param[1] = state;
+	reply.a_param[2] = row;
+	reply.a_param[3] = col;
+	reply.a_inters = '&';
+	reply.a_final = 'w';
+	unparseseq(&reply, screen->respond);
+
+	if (screen->locator_reset) {
+	    MotionOff(screen, term);
+	    screen->send_mouse_pos = MOUSE_OFF;
+	}
+	return;
+    }
+
+    /*
+     * Rectangle is set up.  Allow pointer tracking
+     * to detect if the mouse leaves the rectangle.
+     */
+    screen->loc_filter = True;
+    MotionOn(screen, term);
+}
+
+void
+CheckLocatorPosition(Widget w, XEvent * event)
+{
+    TScreen *screen = &((XtermWidget) w)->screen;
+    int row, col;
+    Bool oor;
+    int state;
+
+    LocatorCoords(row, col, event->xbutton.x, event->xbutton.y, oor);
+
+    /*
+     * Send report if the pointer left the filter rectangle, if
+     * the pointer left the window, or if the filter rectangle
+     * had no coordinates and the pointer re-entered the window.
+     */
+    if (oor || (screen->loc_filter_top == LOC_FILTER_POS) ||
+	(col < screen->loc_filter_left) ||
+	(col > screen->loc_filter_right) ||
+	(row < screen->loc_filter_top) ||
+	(row > screen->loc_filter_bottom)) {
+	/* Filter triggered - disable it */
+	screen->loc_filter = False;
+	MotionOff(screen, term);
+
+	reply.a_type = CSI;
+	if (oor) {
+	    reply.a_nparam = 1;
+	    reply.a_param[0] = 0;	/* Event - 0 = locator unavailable */
+	} else {
+	    ButtonState(state, event->xbutton.state);
+
+	    reply.a_nparam = 4;
+	    reply.a_param[0] = 10;	/* Event - 10 = locator outside filter */
+	    reply.a_param[1] = state;
+	    reply.a_param[2] = row;
+	    reply.a_param[3] = col;
+	}
+
+	reply.a_inters = '&';
+	reply.a_final = 'w';
+	unparseseq(&reply, screen->respond);
+
+	if (screen->locator_reset) {
+	    MotionOff(screen, term);
+	    screen->send_mouse_pos = MOUSE_OFF;
+	}
+    }
+}
+#endif /* OPT_DEC_LOCATOR */
+
+#if OPT_READLINE
+static int
+isClick1_clean(XEvent * event)
+{
+    TScreen *screen = &term->screen;
+    int delta;
+
+    if (!(event->type == ButtonPress || event->type == ButtonRelease)
+    /* Disable on Shift-Click-1, including the application-mouse modes */
+	|| (KeyModifiers & ShiftMask)
+	|| (screen->send_mouse_pos != MOUSE_OFF)	/* Kinda duplicate... */
+	||ExtendingSelection)	/* Was moved */
+	return 0;
+    if (event->type != ButtonRelease)
+	return 0;
+    if (lastButtonDownTime == (Time) 0)		/* first time or once in a blue moon */
+	delta = term->screen.multiClickTime + 1;
+    else if (event->xbutton.time > lastButtonDownTime)	/* most of the time */
+	delta = event->xbutton.time - lastButtonDownTime;
+    else			/* time has rolled over since lastButtonUpTime */
+	delta = (((Time) ~ 0) - lastButtonDownTime) + event->xbutton.time;
+    return delta <= term->screen.multiClickTime;
+}
+
+static int
+isDoubleClick3(XEvent * event)
+{
+    int delta;
+
+    if (event->type != ButtonRelease
+	|| (KeyModifiers & ShiftMask)
+	|| event->xbutton.button != Button3) {
+	lastButton3UpTime = 0;	/* Disable the cached info */
+	return 0;
+    }
+    /* Process Btn3Release. */
+    if (lastButton3DoubleDownTime == (Time) 0)	/* No previous click
+						   or once in a blue moon */
+	delta = term->screen.multiClickTime + 1;
+    else if (event->xbutton.time > lastButton3DoubleDownTime)	/* most of the time */
+	delta = event->xbutton.time - lastButton3DoubleDownTime;
+    else			/* time has rolled over since lastButton3DoubleDownTime */
+	delta = (((Time) ~ 0) - lastButton3DoubleDownTime) + event->xbutton.time;
+    if (delta <= term->screen.multiClickTime) {
+	/* Double click */
+	int row, col;
+
+	/* Cannot check ExtendingSelection, since mouse-3 always sets it */
+	PointToRowCol(event->xbutton.y, event->xbutton.x, &row, &col);
+	if (row == lastButton3row && col == lastButton3col) {
+	    lastButton3DoubleDownTime = 0;	/* Disable the third click */
+	    return 1;
+	}
+    }
+    /* Not a double click, memorize for future check. */
+    lastButton3UpTime = event->xbutton.time;
+    PointToRowCol(event->xbutton.y, event->xbutton.x,
+		  &lastButton3row, &lastButton3col);
+    return 0;
+}
+
+static int
+CheckSecondPress3(XEvent * event)
+{
+    int delta, row, col;
+
+    if (event->type != ButtonPress
+	|| (KeyModifiers & ShiftMask)
+	|| event->xbutton.button != Button3) {
+	lastButton3DoubleDownTime = 0;	/* Disable the cached info */
+	return 0;
+    }
+    /* Process Btn3Press. */
+    if (lastButton3UpTime == (Time) 0)	/* No previous click
+					   or once in a blue moon */
+	delta = term->screen.multiClickTime + 1;
+    else if (event->xbutton.time > lastButton3UpTime)	/* most of the time */
+	delta = event->xbutton.time - lastButton3UpTime;
+    else			/* time has rolled over since lastButton3UpTime */
+	delta = (((Time) ~ 0) - lastButton3UpTime) + event->xbutton.time;
+    if (delta <= term->screen.multiClickTime) {
+	PointToRowCol(event->xbutton.y, event->xbutton.x, &row, &col);
+	if (row == lastButton3row && col == lastButton3col) {
+	    /* A candidate for a double-click */
+	    lastButton3DoubleDownTime = event->xbutton.time;
+	    PointToRowCol(event->xbutton.y, event->xbutton.x,
+			  &lastButton3row, &lastButton3col);
+	    return 1;
+	}
+	lastButton3UpTime = 0;	/* Disable the info about the previous click */
+    }
+    /* Either too long, or moved, disable. */
+    lastButton3DoubleDownTime = 0;
+    return 0;
+}
+
+static int
+rowOnCurrentLine(int line, int *deltap)		/* must be XButtonEvent */
+{
+    TScreen *screen = &term->screen;
+    int l1, l2;
+
+    *deltap = 0;
+    if (line == screen->cur_row)
+	return 1;
+
+    if (line < screen->cur_row)
+	l1 = line, l2 = screen->cur_row;
+    else
+	l2 = line, l1 = screen->cur_row;
+    l1--;
+    while (++l1 < l2)
+	if (!ScrnTstWrapped(screen, l1))
+	    return 0;
+    /* Everything is on one "wrapped line" now */
+    *deltap = line - screen->cur_row;
+    return 1;
+}
+
+static int
+eventRow(XEvent * event)	/* must be XButtonEvent */
+{
+    TScreen *screen = &term->screen;
+
+    return (event->xbutton.y - screen->border) / FontHeight(screen);
+}
+
+static int
+eventColBetween(XEvent * event)	/* must be XButtonEvent */
+{
+    TScreen *screen = &term->screen;
+
+    /* Correct by half a width - we are acting on a boundary, not on a cell. */
+    return ((event->xbutton.x - OriginX(screen) + (FontWidth(screen) - 1) / 2)
+	    / FontWidth(screen));
+}
+
+static int
+ReadLineMovePoint(int col, int ldelta)
+{
+    TScreen *screen = &term->screen;
+    Char line[6];
+    unsigned count = 0;
+
+    col += ldelta * MaxCols(screen) - screen->cur_col;
+    if (col == 0)
+	return 0;
+    if (screen->control_eight_bits) {
+	line[count++] = CSI;
+    } else {
+	line[count++] = ESC;
+	line[count++] = '[';	/* XXX maybe sometimes O is better? */
+    }
+    line[count++] = (col > 0 ? 'C' : 'D');
+    if (col < 0)
+	col = -col;
+    while (col--)
+	v_write(screen->respond, line, 3);
+    return 1;
+}
+
+static int
+ReadLineDelete(int r1, int c1, int r2, int c2)
+{
+    TScreen *screen = &term->screen;
+    int del;
+
+    del = c2 - c1 + (r2 - r1) * MaxCols(screen);
+    if (del <= 0)		/* Just in case... */
+	return 0;
+    while (del--)
+	v_write(screen->respond, (Char *) "\177", 1);
+    return 1;
+}
+#endif /* OPT_READLINE */
+
+/* ^XM-G<line+' '><col+' '> */
+void
+DiredButton(Widget w GCC_UNUSED,
+	    XEvent * event,	/* must be XButtonEvent */
+	    String * params GCC_UNUSED,		/* selections */
+	    Cardinal *num_params GCC_UNUSED)
+{
+    TScreen *screen = &term->screen;
+    Char Line[6];
+    unsigned line, col;
+
+    if (event->type == ButtonPress || event->type == ButtonRelease) {
+	line = (event->xbutton.y - screen->border) / FontHeight(screen);
+	col = (event->xbutton.x - OriginX(screen)) / FontWidth(screen);
+	Line[0] = CONTROL('X');
+	Line[1] = ESC;
+	Line[2] = 'G';
+	Line[3] = ' ' + col;
+	Line[4] = ' ' + line;
+	v_write(screen->respond, Line, 5);
+    }
+}
+
+#if OPT_READLINE
+void
+ReadLineButton(Widget w GCC_UNUSED,
+	       XEvent * event,	/* must be XButtonEvent */
+	       String * params GCC_UNUSED,	/* selections */
+	       Cardinal *num_params GCC_UNUSED)
+{
+    TScreen *screen = &term->screen;
+    Char Line[6];
+    int line, col, ldelta = 0;
+
+    if (!(event->type == ButtonPress || event->type == ButtonRelease)
+	|| (screen->send_mouse_pos != MOUSE_OFF) || ExtendingSelection)
+	goto finish;
+    if (event->type == ButtonRelease) {
+	int delta;
+
+	if (lastButtonDownTime == (Time) 0)	/* first time and once in a blue moon */
+	    delta = screen->multiClickTime + 1;
+	else if (event->xbutton.time > lastButtonDownTime)	/* most of the time */
+	    delta = event->xbutton.time - lastButtonDownTime;
+	else			/* time has rolled over since lastButtonUpTime */
+	    delta = (((Time) ~ 0) - lastButtonDownTime) + event->xbutton.time;
+	if (delta > screen->multiClickTime)
+	    goto finish;	/* All this work for this... */
+    }
+    line = (event->xbutton.y - screen->border) / FontHeight(screen);
+    if (line != screen->cur_row) {
+	int l1, l2;
+
+	if (line < screen->cur_row)
+	    l1 = line, l2 = screen->cur_row;
+	else
+	    l2 = line, l1 = screen->cur_row;
+	l1--;
+	while (++l1 < l2)
+	    if (!ScrnTstWrapped(screen, l1))
+		goto finish;
+	/* Everything is on one "wrapped line" now */
+	ldelta = line - screen->cur_row;
+    }
+    /* Correct by half a width - we are acting on a boundary, not on a cell. */
+    col = (event->xbutton.x - OriginX(screen) + (FontWidth(screen) - 1) / 2)
+	/ FontWidth(screen) - screen->cur_col + ldelta * MaxCols(screen);
+    if (col == 0)
+	goto finish;
+    Line[0] = ESC;
+    /* XXX: sometimes it is better to send '['? */
+    Line[1] = 'O';
+    Line[2] = (col > 0 ? 'C' : 'D');
+    if (col < 0)
+	col = -col;
+    while (col--)
+	v_write(screen->respond, Line, 3);
+  finish:
+    if (event->type == ButtonRelease)
+	do_select_end(w, event, params, num_params, False);
+}
+#endif /* OPT_READLINE */
+
+/* repeats <ESC>n or <ESC>p */
+void
+ViButton(Widget w GCC_UNUSED,
+	 XEvent * event,	/* must be XButtonEvent */
+	 String * params GCC_UNUSED,	/* selections */
+	 Cardinal *num_params GCC_UNUSED)
+{
+    TScreen *screen = &term->screen;
+    int pty = screen->respond;
+    Char Line[6];
+    int line;
+
+    if (event->type == ButtonPress || event->type == ButtonRelease) {
+
+	line = screen->cur_row -
+	    ((event->xbutton.y - screen->border) / FontHeight(screen));
+	if (line != 0) {
+	    Line[0] = ESC;	/* force an exit from insert-mode */
+	    v_write(pty, Line, 1);
+
+	    if (line < 0) {
+		line = -line;
+		Line[0] = CONTROL('n');
+	    } else {
+		Line[0] = CONTROL('p');
+	    }
+	    while (--line >= 0)
+		v_write(pty, Line, 1);
+	}
+    }
+}
+
+/*
+ * This function handles button-motion events
+ */
+/*ARGSUSED*/
+void
+HandleSelectExtend(Widget w,
+		   XEvent * event,	/* must be XMotionEvent */
+		   String * params GCC_UNUSED,
+		   Cardinal *num_params GCC_UNUSED)
+{
+    TScreen *screen;
+    int row, col;
+
+    if (!IsXtermWidget(w))
+	return;
+
+    screen = &((XtermWidget) w)->screen;
+    screen->selection_time = event->xmotion.time;
+    switch (eventMode) {
+	/* If not in one of the DEC mouse-reporting modes */
+    case LEFTEXTENSION:
+    case RIGHTEXTENSION:
+	PointToRowCol(event->xmotion.y, event->xmotion.x,
+		      &row, &col);
+	ExtendExtend(row, col);
+	break;
+
+	/* If in motion reporting mode, send mouse position to
+	   character process as a key sequence \E[M... */
+    case NORMAL:
+	/* will get here if send_mouse_pos != MOUSE_OFF */
+	if (screen->send_mouse_pos == BTN_EVENT_MOUSE
+	    || screen->send_mouse_pos == ANY_EVENT_MOUSE) {
+	    (void) SendMousePosition(w, event);
+	}
+	break;
+    }
+}
+
+void
+HandleKeyboardSelectExtend(Widget w,
+			   XEvent * event GCC_UNUSED,	/* must be XButtonEvent */
+			   String * params GCC_UNUSED,
+			   Cardinal *num_params GCC_UNUSED)
+{
+    TScreen *screen;
+
+    if (!IsXtermWidget(w))
+	return;
+
+    screen = &((XtermWidget) w)->screen;
+    ExtendExtend(screen->cursor_row, screen->cursor_col);
+}
+
+static void
+do_select_end(Widget w,
+	      XEvent * event,	/* must be XButtonEvent */
+	      String * params,	/* selections */
+	      Cardinal *num_params,
+	      Bool use_cursor_loc)
+{
+#if OPT_READLINE
+    int ldelta1, ldelta2;
+    TScreen *screen = &term->screen;
+#endif
+
+    if (!IsXtermWidget(w)) {
+	return;
+    }
+
+    ((XtermWidget) w)->screen.selection_time = event->xbutton.time;
+    switch (eventMode) {
+    case NORMAL:
+	(void) SendMousePosition(w, event);
+	break;
+    case LEFTEXTENSION:
+    case RIGHTEXTENSION:
+	EndExtend(w, event, params, *num_params, use_cursor_loc);
+#if OPT_READLINE
+	if (isClick1_clean(event)
+	    && SCREEN_FLAG(screen, click1_moves)
+	    && rowOnCurrentLine(eventRow(event), &ldelta1)) {
+	    ReadLineMovePoint(eventColBetween(event), ldelta1);
+	}
+	if (isDoubleClick3(event)
+	    && SCREEN_FLAG(screen, dclick3_deletes)
+	    && rowOnCurrentLine(startSRow, &ldelta1)
+	    && rowOnCurrentLine(endSRow, &ldelta2)) {
+	    ReadLineMovePoint(endSCol, ldelta2);
+	    ReadLineDelete(startSRow, startSCol, endSRow, endSCol);
+	}
+#endif /* OPT_READLINE */
+	break;
+    }
+}
+
+void
+HandleSelectEnd(Widget w,
+		XEvent * event,	/* must be XButtonEvent */
+		String * params,	/* selections */
+		Cardinal *num_params)
+{
+    do_select_end(w, event, params, num_params, False);
+}
+
+void
+HandleKeyboardSelectEnd(Widget w,
+			XEvent * event,		/* must be XButtonEvent */
+			String * params,	/* selections */
+			Cardinal *num_params)
+{
+    do_select_end(w, event, params, num_params, True);
+}
+
+struct _SelectionList {
+    String *params;
+    Cardinal count;
+    Atom *targets;
+    Time time;
+};
+
+/* convert a UTF-8 string to Latin-1, replacing non Latin-1 characters
+ * by `#'. */
+
+#if OPT_WIDE_CHARS
+static Char *
+UTF8toLatin1(Char * s, unsigned len, unsigned long *result)
+{
+    static Char *buffer;
+    static size_t used;
+
+    Char *p = s;
+    Char *q;
+
+    if (used == 0) {
+	buffer = (Char *) XtMalloc(used = len);
+    } else if (len > used) {
+	buffer = (Char *) XtRealloc((char *) buffer, used = len);
+    }
+    q = buffer;
+
+    /* We're assuming that the xterm widget never contains Unicode
+       control characters. */
+
+    while (p < s + len) {
+	if ((*p & 0x80) == 0) {
+	    *q++ = *p++;
+	} else if ((*p & 0x7C) == 0x40 && p < s + len - 1) {
+	    *q++ = ((*p & 0x03) << 6) | (p[1] & 0x3F);
+	    p += 2;
+	} else if ((*p & 0x60) == 0x40) {
+	    *q++ = '#';
+	    p += 2;
+	} else if ((*p & 0x50) == 0x40) {
+	    *q++ = '#';
+	    p += 3;
+	} else {		/* this cannot happen */
+	    *q++ = '#';
+	    p++;
+	}
+    }
+    *result = q - buffer;
+    return buffer;
+}
+#endif /* OPT_WIDE_CHARS */
+
+static Atom *
+_SelectionTargets(Widget w)
+{
+    static Atom *eightBitSelectionTargets = NULL;
+    TScreen *screen;
+    int n;
+
+    if (!IsXtermWidget(w))
+	return NULL;
+
+    screen = &((XtermWidget) w)->screen;
+
+#if OPT_WIDE_CHARS
+    if (screen->wide_chars) {
+	static Atom *utf8SelectionTargets = NULL;
+
+	if (utf8SelectionTargets == NULL) {
+	    utf8SelectionTargets = (Atom *) XtMalloc(5 * sizeof(Atom));
+	    if (utf8SelectionTargets == NULL) {
+		TRACE(("Couldn't allocate utf8SelectionTargets\n"));
+		return NULL;
+	    }
+	    n = 0;
+	    utf8SelectionTargets[n++] = XA_UTF8_STRING(XtDisplay(w));
+#ifdef X_HAVE_UTF8_STRING
+	    if (screen->i18nSelections) {
+		utf8SelectionTargets[n++] = XA_TEXT(XtDisplay(w));
+		utf8SelectionTargets[n++] = XA_COMPOUND_TEXT(XtDisplay(w));
+	    }
+#endif
+	    utf8SelectionTargets[n++] = XA_STRING;
+	    utf8SelectionTargets[n] = None;
+	}
+	return utf8SelectionTargets;
+    }
+#endif
+
+    /* not screen->wide_chars */
+    if (eightBitSelectionTargets == NULL) {
+	eightBitSelectionTargets = (Atom *) XtMalloc(5 * sizeof(Atom));
+	if (eightBitSelectionTargets == NULL) {
+	    TRACE(("Couldn't allocate eightBitSelectionTargets\n"));
+	    return NULL;
+	}
+	n = 0;
+#ifdef X_HAVE_UTF8_STRING
+	eightBitSelectionTargets[n++] = XA_UTF8_STRING(XtDisplay(w));
+#endif
+	if (screen->i18nSelections) {
+	    eightBitSelectionTargets[n++] = XA_TEXT(XtDisplay(w));
+	    eightBitSelectionTargets[n++] = XA_COMPOUND_TEXT(XtDisplay(w));
+	}
+	eightBitSelectionTargets[n++] = XA_STRING;
+	eightBitSelectionTargets[n] = None;
+    }
+    return eightBitSelectionTargets;
+}
+
+/*
+ * Lookup the cut-buffer number, which will be in the range 0-7.
+ * If it is not a cut-buffer, it is the primary selection (-1).
+ */
+static int
+CutBuffer(unsigned code)
+{
+    int cutbuffer;
+    switch (code) {
+    case XA_CUT_BUFFER0:
+	cutbuffer = 0;
+	break;
+    case XA_CUT_BUFFER1:
+	cutbuffer = 1;
+	break;
+    case XA_CUT_BUFFER2:
+	cutbuffer = 2;
+	break;
+    case XA_CUT_BUFFER3:
+	cutbuffer = 3;
+	break;
+    case XA_CUT_BUFFER4:
+	cutbuffer = 4;
+	break;
+    case XA_CUT_BUFFER5:
+	cutbuffer = 5;
+	break;
+    case XA_CUT_BUFFER6:
+	cutbuffer = 6;
+	break;
+    case XA_CUT_BUFFER7:
+	cutbuffer = 7;
+	break;
+    default:
+	cutbuffer = -1;
+	break;
+    }
+    return cutbuffer;
+}
+
+#define ResetPaste64() term->screen.base64_paste = 0
+
+#if !OPT_PASTE64
+static
+#endif
+void
+xtermGetSelection(Widget w,
+		  Time ev_time,
+		  String * params,	/* selections in precedence order */
+		  Cardinal num_params,
+		  Atom * targets)
+{
+    Atom selection;
+    int cutbuffer;
+    Atom target;
+
+    if (!IsXtermWidget(w))
+	return;
+
+#if OPT_TRACE
+    TRACE(("xtermGetSelection\n"));
+    if (num_params > 0) {
+	Cardinal n;
+	for (n = 0; n < num_params; ++n) {
+	    TRACE(("param[%d]:%s\n", n, params[n]));
+	}
+    }
+#endif
+
+    XmuInternStrings(XtDisplay(w), params, (Cardinal) 1, &selection);
+    cutbuffer = CutBuffer(selection);
+    TRACE(("Cutbuffer: %d, target: %lu\n", cutbuffer,
+	   targets ? (unsigned long) targets[0] : 0));
+    if (cutbuffer >= 0) {
+	int inbytes;
+	unsigned long nbytes;
+	int fmt8 = 8;
+	Atom type = XA_STRING;
+	char *line;
+
+	/* 'line' is freed in SelectionReceived */
+	line = XFetchBuffer(XtDisplay(w), &inbytes, cutbuffer);
+	nbytes = (unsigned long) inbytes;
+
+	if (nbytes > 0)
+	    SelectionReceived(w, NULL, &selection, &type, (XtPointer) line,
+			      &nbytes, &fmt8);
+	else if (num_params > 1)
+	    xtermGetSelection(w, ev_time, params + 1, num_params - 1, NULL);
+#if OPT_PASTE64
+	else
+	    ResetPaste64();
+#endif
+	return;
+    } else {
+	struct _SelectionList *list;
+
+	if (targets == NULL || targets[0] == None) {
+	    targets = _SelectionTargets(w);
+	}
+
+	if (targets != 0) {
+	    target = targets[0];
+
+	    if (targets[1] == None) {	/* last target in list */
+		params++;
+		num_params--;
+		targets = _SelectionTargets(w);
+	    } else {
+		targets = &(targets[1]);
+	    }
+
+	    if (num_params) {
+		/* 'list' is freed in SelectionReceived */
+		list = XtNew(struct _SelectionList);
+		if (list != 0) {
+		    list->params = params;
+		    list->count = num_params;
+		    list->targets = targets;
+		    list->time = ev_time;
+		}
+	    } else {
+		list = NULL;
+	    }
+
+	    XtGetSelectionValue(w, selection,
+				target,
+				SelectionReceived,
+				(XtPointer) list, ev_time);
+	}
+    }
+}
+
+#if OPT_TRACE && OPT_WIDE_CHARS
+static void
+GettingSelection(Display * dpy, Atom type, Char * line, unsigned long len)
+{
+    Char *cp;
+    char *name;
+
+    name = XGetAtomName(dpy, type);
+
+    TRACE(("Getting %s (%ld)\n", name, (long int) type));
+    for (cp = line; cp < line + len; cp++) {
+	TRACE(("[%d:%lu]", cp + 1 - line, len));
+	if (isprint(*cp)) {
+	    TRACE(("%c\n", *cp));
+	} else {
+	    TRACE(("\\x%02x\n", *cp));
+	}
+    }
+}
+#else
+#define GettingSelection(dpy,type,line,len)	/* nothing */
+#endif
+
+#ifdef VMS
+#  define tty_vwrite(pty,lag,l)		tt_write(lag,l)
+#else /* !( VMS ) */
+#  define tty_vwrite(pty,lag,l)		v_write(pty,lag,l)
+#endif /* defined VMS */
+
+#if OPT_PASTE64
+/* Return base64 code character given 6-bit number */
+static const char base64_code[] = "\
+ABCDEFGHIJKLMNOPQRSTUVWXYZ\
+abcdefghijklmnopqrstuvwxyz\
+0123456789+/";
+static void
+base64_flush(TScreen * screen)
+{
+    Char x;
+    switch (screen->base64_count) {
+    case 0:
+	break;
+    case 2:
+	x = base64_code[screen->base64_accu << 4];
+	tty_vwrite(screen->respond, &x, 1);
+	break;
+    case 4:
+	x = base64_code[screen->base64_accu << 2];
+	tty_vwrite(screen->respond, &x, 1);
+	break;
+    }
+    if (screen->base64_pad & 3)
+	tty_vwrite(screen->respond,
+		   (Char *) "===",
+		   4 - (screen->base64_pad & 3));
+    screen->base64_count = 0;
+    screen->base64_accu = 0;
+    screen->base64_pad = 0;
+}
+#endif /* OPT_PASTE64 */
+
+static void
+_qWriteSelectionData(TScreen * screen, Char * lag, unsigned length)
+{
+#if OPT_PASTE64
+    if (screen->base64_paste) {
+	/* Send data as base64 */
+	Char *p = lag;
+	Char buf[64];
+	unsigned x = 0;
+	while (length--) {
+	    switch (screen->base64_count) {
+	    case 0:
+		buf[x++] = base64_code[*p >> 2];
+		screen->base64_accu = (*p & 0x3);
+		screen->base64_count = 2;
+		++p;
+		break;
+	    case 2:
+		buf[x++] = base64_code[(screen->base64_accu << 4) + (*p >> 4)];
+		screen->base64_accu = (*p & 0xF);
+		screen->base64_count = 4;
+		++p;
+		break;
+	    case 4:
+		buf[x++] = base64_code[(screen->base64_accu << 2) + (*p >> 6)];
+		buf[x++] = base64_code[*p & 0x3F];
+		screen->base64_accu = 0;
+		screen->base64_count = 0;
+		++p;
+		break;
+	    }
+	    if (x >= 63) {
+		/* Write 63 or 64 characters */
+		screen->base64_pad += x;
+		tty_vwrite(screen->respond, buf, x);
+		x = 0;
+	    }
+	}
+	if (x != 0) {
+	    screen->base64_pad += x;
+	    tty_vwrite(screen->respond, buf, x);
+	}
+    } else
+#endif /* OPT_PASTE64 */
+#if OPT_READLINE
+    if (SCREEN_FLAG(screen, paste_quotes)) {
+	while (length--) {
+	    tty_vwrite(screen->respond, (Char *) "\026", 1);	/* Control-V */
+	    tty_vwrite(screen->respond, lag++, 1);
+	}
+    } else
+#endif
+	tty_vwrite(screen->respond, lag, length);
+}
+
+static void
+_WriteSelectionData(TScreen * screen, Char * line, int length)
+{
+    /* Write data to pty a line at a time. */
+    /* Doing this one line at a time may no longer be necessary
+       because v_write has been re-written. */
+
+    Char *lag, *end;
+
+    /* in the VMS version, if tt_pasting isn't set to True then qio
+       reads aren't blocked and an infinite loop is entered, where the
+       pasted text shows up as new input, goes in again, shows up
+       again, ad nauseum. */
+#ifdef VMS
+    tt_pasting = True;
+#endif
+
+    end = &line[length];
+    lag = line;
+
+#if OPT_PASTE64
+    if (screen->base64_paste) {
+	_qWriteSelectionData(screen, lag, (unsigned) (end - lag));
+	base64_flush(screen);
+    } else
+#endif
+    {
+	if (!SCREEN_FLAG(screen, paste_literal_nl)) {
+	    Char *cp;
+	    for (cp = line; cp != end; cp++) {
+		if (*cp == '\n') {
+		    *cp = '\r';
+		    _qWriteSelectionData(screen, lag, (unsigned) (cp - lag + 1));
+		    lag = cp + 1;
+		}
+	    }
+	}
+
+	if (lag != end) {
+	    _qWriteSelectionData(screen, lag, (unsigned) (end - lag));
+	}
+    }
+#ifdef VMS
+    tt_pasting = False;
+    tt_start_read();		/* reenable reads or a character may be lost */
+#endif
+}
+
+#if OPT_READLINE
+static void
+_WriteKey(TScreen * screen, Char * in)
+{
+    Char line[16];
+    unsigned count = 0;
+    unsigned length = strlen((char *) in);
+
+    if (screen->control_eight_bits) {
+	line[count++] = CSI;
+    } else {
+	line[count++] = ESC;
+	line[count++] = '[';
+    }
+    while (length--)
+	line[count++] = *in++;
+    line[count++] = '~';
+    tty_vwrite(screen->respond, line, count);
+}
+#endif /* OPT_READLINE */
+
+/* SelectionReceived: stuff received selection text into pty */
+
+/* ARGSUSED */
+static void
+SelectionReceived(Widget w,
+		  XtPointer client_data,
+		  Atom * selection GCC_UNUSED,
+		  Atom * type,
+		  XtPointer value,
+		  unsigned long *length,
+		  int *format GCC_UNUSED)
+{
+    char **text_list = NULL;
+    int text_list_count;
+    XTextProperty text_prop;
+    TScreen *screen;
+    Display *dpy;
+#if OPT_TRACE && OPT_WIDE_CHARS
+    Char *line = (Char *) value;
+#endif
+
+    if (!IsXtermWidget(w))
+	return;
+    screen = &((XtermWidget) w)->screen;
+    dpy = XtDisplay(w);
+
+    if (*type == 0		/*XT_CONVERT_FAIL */
+	|| *length == 0
+	|| value == NULL)
+	goto fail;
+
+    text_prop.value = (unsigned char *) value;
+    text_prop.encoding = *type;
+    text_prop.format = *format;
+    text_prop.nitems = *length;
+
+#if OPT_WIDE_CHARS
+    if (screen->wide_chars) {
+	if (*type == XA_UTF8_STRING(XtDisplay(w)) ||
+	    *type == XA_STRING ||
+	    *type == XA_COMPOUND_TEXT(XtDisplay(w))) {
+	    GettingSelection(dpy, *type, line, *length);
+	    if (Xutf8TextPropertyToTextList(dpy, &text_prop,
+					    &text_list,
+					    &text_list_count) < 0) {
+		TRACE(("Conversion failed\n"));
+		text_list = NULL;
+	    }
+	}
+    } else
+#endif /* OPT_WIDE_CHARS */
+    {
+	/* Convert the selection to locale's multibyte encoding. */
+
+	/* There's no need to special-case UTF8_STRING.  If Xlib
+	   doesn't know about it, we didn't request it.  If a broken
+	   selection holder sends it anyhow, the conversion function
+	   will fail. */
+
+	if (*type == XA_UTF8_STRING(XtDisplay(w)) ||
+	    *type == XA_STRING ||
+	    *type == XA_COMPOUND_TEXT(XtDisplay(w))) {
+	    Status rc;
+	    GettingSelection(dpy, *type, line, *length);
+	    if (*type == XA_STRING && screen->brokenSelections) {
+		rc = XTextPropertyToStringList(&text_prop,
+					       &text_list, &text_list_count);
+	    } else {
+		rc = XmbTextPropertyToTextList(dpy, &text_prop,
+					       &text_list,
+					       &text_list_count);
+	    }
+	    if (rc < 0) {
+		TRACE(("Conversion failed\n"));
+		text_list = NULL;
+	    }
+	}
+    }
+
+    if (text_list != NULL && text_list_count != 0) {
+	int i;
+
+#if OPT_PASTE64
+	if (screen->base64_paste) {
+	    ;
+	} else
+#endif
+#if OPT_READLINE
+	if (SCREEN_FLAG(screen, paste_brackets)) {
+	    _WriteKey(screen, (Char *) "200");
+	}
+#endif
+	for (i = 0; i < text_list_count; i++) {
+	    int len = strlen(text_list[i]);
+	    _WriteSelectionData(screen, (Char *) text_list[i], len);
+	}
+#if OPT_PASTE64
+	if (screen->base64_paste) {
+	    ResetPaste64();
+	} else
+#endif
+#if OPT_READLINE
+	if (SCREEN_FLAG(screen, paste_brackets)) {
+	    _WriteKey(screen, (Char *) "201");
+	}
+#endif
+	XFreeStringList(text_list);
+    } else
+	goto fail;
+
+    XtFree((char *) client_data);
+    XtFree((char *) value);
+
+    return;
+
+  fail:
+    if (client_data != 0) {
+	struct _SelectionList *list = (struct _SelectionList *) client_data;
+	xtermGetSelection(w, list->time,
+			  list->params, list->count, list->targets);
+	XtFree((char *) client_data);
+#if OPT_PASTE64
+    } else {
+	ResetPaste64();
+#endif
+    }
+    return;
+}
+
+void
+HandleInsertSelection(Widget w,
+		      XEvent * event,	/* assumed to be XButtonEvent* */
+		      String * params,	/* selections in precedence order */
+		      Cardinal *num_params)
+{
+#if OPT_READLINE
+    int ldelta;
+    TScreen *screen = &((XtermWidget) w)->screen;
+#endif
+
+    if (SendMousePosition(w, event))
+	return;
+
+#if OPT_READLINE
+    if ((event->type == ButtonPress || event->type == ButtonRelease)
+    /* Disable on Shift-mouse, including the application-mouse modes */
+	&& !(KeyModifiers & ShiftMask)
+	&& (screen->send_mouse_pos == MOUSE_OFF)
+	&& SCREEN_FLAG(screen, paste_moves)
+	&& rowOnCurrentLine(eventRow(event), &ldelta))
+	ReadLineMovePoint(eventColBetween(event), ldelta);
+#endif /* OPT_READLINE */
+
+    xtermGetSelection(w, event->xbutton.time, params, *num_params, NULL);
+}
+
+static SelectUnit
+EvalSelectUnit(Time buttonDownTime, SelectUnit defaultUnit)
+{
+    int delta;
+
+    if (lastButtonUpTime == (Time) 0)	/* first time and once in a blue moon */
+	delta = term->screen.multiClickTime + 1;
+    else if (buttonDownTime > lastButtonUpTime)		/* most of the time */
+	delta = buttonDownTime - lastButtonUpTime;
+    else			/* time has rolled over since lastButtonUpTime */
+	delta = (((Time) ~ 0) - lastButtonUpTime) + buttonDownTime;
+
+    if (delta > term->screen.multiClickTime) {
+	numberOfClicks = 1;
+	return defaultUnit;
+    } else {
+	++numberOfClicks;
+	return ((selectUnit + 1) % NSELECTUNITS);
+    }
+}
+
+static void
+do_select_start(Widget w,
+		XEvent * event,	/* must be XButtonEvent* */
+		int startrow,
+		int startcol)
+{
+    if (SendMousePosition(w, event))
+	return;
+    selectUnit = EvalSelectUnit(event->xbutton.time, SELECTCHAR);
+    replyToEmacs = False;
+
+#if OPT_READLINE
+    lastButtonDownTime = event->xbutton.time;
+#endif
+
+    StartSelect(startrow, startcol);
+}
+
+/* ARGSUSED */
+void
+HandleSelectStart(Widget w,
+		  XEvent * event,	/* must be XButtonEvent* */
+		  String * params GCC_UNUSED,
+		  Cardinal *num_params GCC_UNUSED)
+{
+    TScreen *screen;
+    int startrow, startcol;
+
+    if (!IsXtermWidget(w))
+	return;
+
+    screen = &((XtermWidget) w)->screen;
+    firstValidRow = 0;
+    lastValidRow = screen->max_row;
+    PointToRowCol(event->xbutton.y, event->xbutton.x, &startrow, &startcol);
+
+#if OPT_READLINE
+    ExtendingSelection = 0;
+#endif
+
+    do_select_start(w, event, startrow, startcol);
+}
+
+/* ARGSUSED */
+void
+HandleKeyboardSelectStart(Widget w,
+			  XEvent * event,	/* must be XButtonEvent* */
+			  String * params GCC_UNUSED,
+			  Cardinal *num_params GCC_UNUSED)
+{
+    TScreen *screen;
+
+    if (!IsXtermWidget(w))
+	return;
+
+    screen = &((XtermWidget) w)->screen;
+    do_select_start(w, event, screen->cursor_row, screen->cursor_col);
+}
+
+static void
+TrackDown(XButtonEvent * event)
+{
+    int startrow, startcol;
+
+    selectUnit = EvalSelectUnit(event->time, SELECTCHAR);
+    if (numberOfClicks > 1) {
+	PointToRowCol(event->y, event->x, &startrow, &startcol);
+	replyToEmacs = True;
+	StartSelect(startrow, startcol);
+    } else {
+	waitingForTrackInfo = True;
+	EditorButton((XButtonEvent *) event);
+    }
+}
+
+#define boundsCheck(x)	if (x < 0) \
+			    x = 0; \
+			else if (x >= screen->max_row) \
+			    x = screen->max_row
+
+void
+TrackMouse(int func, int startrow, int startcol, int firstrow, int lastrow)
+{
+    TScreen *screen = &term->screen;
+
+    if (!waitingForTrackInfo) {	/* Timed out, so ignore */
+	return;
+    }
+    waitingForTrackInfo = False;
+    if (func == 0)
+	return;
+    boundsCheck(startrow);
+    boundsCheck(firstrow);
+    boundsCheck(lastrow);
+    firstValidRow = firstrow;
+    lastValidRow = lastrow;
+    replyToEmacs = True;
+    StartSelect(startrow, startcol);
+}
+
+static void
+StartSelect(int startrow, int startcol)
+{
+    TScreen *screen = &term->screen;
+
+    TRACE(("StartSelect row=%d, col=%d\n", startrow, startcol));
+    if (screen->cursor_state)
+	HideCursor();
+    if (numberOfClicks == 1) {
+	/* set start of selection */
+	rawRow = startrow;
+	rawCol = startcol;
+
+    }
+    /* else use old values in rawRow, Col */
+    saveStartRRow = startERow = rawRow;
+    saveStartRCol = startECol = rawCol;
+    saveEndRRow = endERow = rawRow;
+    saveEndRCol = endECol = rawCol;
+    if (Coordinate(startrow, startcol) < Coordinate(rawRow, rawCol)) {
+	eventMode = LEFTEXTENSION;
+	startERow = startrow;
+	startECol = startcol;
+    } else {
+	eventMode = RIGHTEXTENSION;
+	endERow = startrow;
+	endECol = startcol;
+    }
+    ComputeSelect(startERow, startECol, endERow, endECol, False);
+}
+
+static void
+EndExtend(Widget w,
+	  XEvent * event,	/* must be XButtonEvent */
+	  String * params,	/* selections */
+	  Cardinal num_params,
+	  Bool use_cursor_loc)
+{
+    int row, col;
+    unsigned count;
+    TScreen *screen = &term->screen;
+    Char line[9];
+
+    if (use_cursor_loc) {
+	row = screen->cursor_row;
+	col = screen->cursor_col;
+    } else {
+	PointToRowCol(event->xbutton.y, event->xbutton.x, &row, &col);
+    }
+    ExtendExtend(row, col);
+    lastButtonUpTime = event->xbutton.time;
+    if (startSRow != endSRow || startSCol != endSCol) {
+	if (replyToEmacs) {
+	    count = 0;
+	    if (screen->control_eight_bits) {
+		line[count++] = CSI;
+	    } else {
+		line[count++] = ESC;
+		line[count++] = '[';
+	    }
+	    if (rawRow == startSRow && rawCol == startSCol
+		&& row == endSRow && col == endSCol) {
+		/* Use short-form emacs select */
+		line[count++] = 't';
+		line[count++] = ' ' + endSCol + 1;
+		line[count++] = ' ' + endSRow + 1;
+	    } else {
+		/* long-form, specify everything */
+		line[count++] = 'T';
+		line[count++] = ' ' + startSCol + 1;
+		line[count++] = ' ' + startSRow + 1;
+		line[count++] = ' ' + endSCol + 1;
+		line[count++] = ' ' + endSRow + 1;
+		line[count++] = ' ' + col + 1;
+		line[count++] = ' ' + row + 1;
+	    }
+	    v_write(screen->respond, line, count);
+	    TrackText(0, 0, 0, 0);
+	}
+    }
+    SelectSet(w, event, params, num_params);
+    eventMode = NORMAL;
+}
+
+void
+HandleSelectSet(Widget w,
+		XEvent * event,
+		String * params,
+		Cardinal *num_params)
+{
+    SelectSet(w, event, params, *num_params);
+}
+
+/* ARGSUSED */
+static void
+SelectSet(Widget w GCC_UNUSED,
+	  XEvent * event GCC_UNUSED,
+	  String * params,
+	  Cardinal num_params)
+{
+    TRACE(("SelectSet\n"));
+    /* Only do select stuff if non-null select */
+    if (startSRow != endSRow || startSCol != endSCol) {
+	SaltTextAway(startSRow, startSCol, endSRow, endSCol,
+		     params, num_params);
+    } else {
+	DisownSelection(term);
+    }
+}
+
+#define Abs(x)		((x) < 0 ? -(x) : (x))
+
+/* ARGSUSED */
+static void
+do_start_extend(Widget w,
+		XEvent * event,	/* must be XButtonEvent* */
+		String * params GCC_UNUSED,
+		Cardinal *num_params GCC_UNUSED,
+		Bool use_cursor_loc)
+{
+    TScreen *screen;
+    int row, col, coord;
+
+    if (!IsXtermWidget(w))
+	return;
+
+    screen = &((XtermWidget) w)->screen;
+    if (SendMousePosition(w, event))
+	return;
+    firstValidRow = 0;
+    lastValidRow = screen->max_row;
+#if OPT_READLINE
+    if ((KeyModifiers & ShiftMask)
+	|| event->xbutton.button != Button3
+	|| !(SCREEN_FLAG(screen, dclick3_deletes)))
+#endif
+	selectUnit = EvalSelectUnit(event->xbutton.time, selectUnit);
+    replyToEmacs = False;
+
+#if OPT_READLINE
+    CheckSecondPress3(event);
+#endif
+
+    if (numberOfClicks == 1
+	|| (SCREEN_FLAG(screen, dclick3_deletes)	/* Dclick special */
+	    &&!(KeyModifiers & ShiftMask))) {
+	/* Save existing selection so we can reestablish it if the guy
+	   extends past the other end of the selection */
+	saveStartRRow = startERow = startRRow;
+	saveStartRCol = startECol = startRCol;
+	saveEndRRow = endERow = endRRow;
+	saveEndRCol = endECol = endRCol;
+    } else {
+	/* He just needed the selection mode changed, use old values. */
+	startERow = startRRow = saveStartRRow;
+	startECol = startRCol = saveStartRCol;
+	endERow = endRRow = saveEndRRow;
+	endECol = endRCol = saveEndRCol;
+
+    }
+    if (use_cursor_loc) {
+	row = screen->cursor_row;
+	col = screen->cursor_col;
+    } else {
+	PointToRowCol(event->xbutton.y, event->xbutton.x, &row, &col);
+    }
+    coord = Coordinate(row, col);
+
+    if (Abs(coord - Coordinate(startSRow, startSCol))
+	< Abs(coord - Coordinate(endSRow, endSCol))
+	|| coord < Coordinate(startSRow, startSCol)) {
+	/* point is close to left side of selection */
+	eventMode = LEFTEXTENSION;
+	startERow = row;
+	startECol = col;
+    } else {
+	/* point is close to left side of selection */
+	eventMode = RIGHTEXTENSION;
+	endERow = row;
+	endECol = col;
+    }
+    ComputeSelect(startERow, startECol, endERow, endECol, True);
+
+#if OPT_READLINE
+    if (startSRow != endSRow || startSCol != endSCol)
+	ExtendingSelection = 1;
+#endif
+}
+
+static void
+ExtendExtend(int row, int col)
+{
+    int coord = Coordinate(row, col);
+
+    TRACE(("ExtendExtend row=%d, col=%d\n", row, col));
+    if (eventMode == LEFTEXTENSION
+	&& (coord + (selectUnit != SELECTCHAR)) > Coordinate(endSRow, endSCol)) {
+	/* Whoops, he's changed his mind.  Do RIGHTEXTENSION */
+	eventMode = RIGHTEXTENSION;
+	startERow = saveStartRRow;
+	startECol = saveStartRCol;
+    } else if (eventMode == RIGHTEXTENSION
+	       && coord < Coordinate(startSRow, startSCol)) {
+	/* Whoops, he's changed his mind.  Do LEFTEXTENSION */
+	eventMode = LEFTEXTENSION;
+	endERow = saveEndRRow;
+	endECol = saveEndRCol;
+    }
+    if (eventMode == LEFTEXTENSION) {
+	startERow = row;
+	startECol = col;
+    } else {
+	endERow = row;
+	endECol = col;
+    }
+    ComputeSelect(startERow, startECol, endERow, endECol, False);
+
+#if OPT_READLINE
+    if (startSRow != endSRow || startSCol != endSCol)
+	ExtendingSelection = 1;
+#endif
+}
+
+void
+HandleStartExtend(Widget w,
+		  XEvent * event,	/* must be XButtonEvent* */
+		  String * params,	/* unused */
+		  Cardinal *num_params)		/* unused */
+{
+    do_start_extend(w, event, params, num_params, False);
+}
+
+void
+HandleKeyboardStartExtend(Widget w,
+			  XEvent * event,	/* must be XButtonEvent* */
+			  String * params,	/* unused */
+			  Cardinal *num_params)		/* unused */
+{
+    do_start_extend(w, event, params, num_params, True);
+}
+
+void
+ScrollSelection(TScreen * screen, int amount, Bool always)
+{
+    int minrow = -screen->savedlines - screen->topline;
+    int maxrow = screen->max_row - screen->topline;
+    int maxcol = screen->max_col;
+
+#define scroll_update_one(row, col) \
+	row += amount; \
+	if (row < minrow) { \
+	    row = minrow; \
+	    col = 0; \
+	} \
+	if (row > maxrow) { \
+	    row = maxrow; \
+	    col = maxcol; \
+	}
+
+    scroll_update_one(startRRow, startRCol);
+    scroll_update_one(endRRow, endRCol);
+    scroll_update_one(startSRow, startSCol);
+    scroll_update_one(endSRow, endSCol);
+
+    scroll_update_one(rawRow, rawCol);
+
+    /*
+     * If we are told to scroll the selection but it lies outside the scrolling
+     * margins, then that could cause the selection to move (bad).  It is not
+     * simple to fix, because this function is called both for the scrollbar
+     * actions as well as application scrolling.  The 'always' flag is set in
+     * the former case.  The rest of the logic handles the latter.
+     */
+    if (ScrnHaveSelection(screen)) {
+	int adjust;
+
+	adjust = screen->startHRow + screen->topline;
+	if (always
+	    || !ScrnHaveLineMargins(screen)
+	    || ScrnIsLineInMargins(screen, adjust)) {
+	    scroll_update_one(screen->startHRow, screen->startHCol);
+	}
+	adjust = screen->endHRow + screen->topline;
+	if (always
+	    || !ScrnHaveLineMargins(screen)
+	    || ScrnIsLineInMargins(screen, adjust)) {
+	    scroll_update_one(screen->endHRow, screen->endHCol);
+	}
+    }
+
+    screen->startHCoord = Coordinate(screen->startHRow, screen->startHCol);
+    screen->endHCoord = Coordinate(screen->endHRow, screen->endHCol);
+}
+
+/*ARGSUSED*/
+void
+ResizeSelection(TScreen * screen GCC_UNUSED, int rows, int cols)
+{
+    rows--;			/* decr to get 0-max */
+    cols--;
+
+    if (startRRow > rows)
+	startRRow = rows;
+    if (startSRow > rows)
+	startSRow = rows;
+    if (endRRow > rows)
+	endRRow = rows;
+    if (endSRow > rows)
+	endSRow = rows;
+    if (rawRow > rows)
+	rawRow = rows;
+
+    if (startRCol > cols)
+	startRCol = cols;
+    if (startSCol > cols)
+	startSCol = cols;
+    if (endRCol > cols)
+	endRCol = cols;
+    if (endSCol > cols)
+	endSCol = cols;
+    if (rawCol > cols)
+	rawCol = cols;
+}
+
+#if OPT_WIDE_CHARS
+Bool
+iswide(int i)
+{
+    return (i == HIDDEN_CHAR) || (my_wcwidth(i) == 2);
+}
+
+#define isWideCell(row, col) iswide((int)XTERM_CELL(row, col))
+#endif
+
+static void
+PointToRowCol(int y,
+	      int x,
+	      int *r,
+	      int *c)
+/* Convert pixel coordinates to character coordinates.
+   Rows are clipped between firstValidRow and lastValidRow.
+   Columns are clipped between to be 0 or greater, but are not clipped to some
+       maximum value. */
+{
+    TScreen *screen = &term->screen;
+    int row, col;
+
+    row = (y - screen->border) / FontHeight(screen);
+    if (row < firstValidRow)
+	row = firstValidRow;
+    else if (row > lastValidRow)
+	row = lastValidRow;
+    col = (x - OriginX(screen)) / FontWidth(screen);
+    if (col < 0)
+	col = 0;
+    else if (col > MaxCols(screen)) {
+	col = MaxCols(screen);
+    }
+#if OPT_WIDE_CHARS
+    /*
+     * If we got a click on the right half of a doublewidth character,
+     * pretend it happened on the left half.
+     */
+    if (col > 0
+	&& isWideCell(row, col - 1)
+	&& (XTERM_CELL(row, col) == HIDDEN_CHAR)) {
+	col -= 1;
+    }
+#endif
+    *r = row;
+    *c = col;
+}
+
+static int
+LastTextCol(int row)
+{
+    TScreen *screen = &term->screen;
+    int i;
+    Char *ch;
+
+    if ((row += screen->topline) + screen->savedlines >= 0) {
+	for (i = screen->max_col,
+	     ch = SCRN_BUF_ATTRS(screen, row) + i;
+	     i >= 0 && !(*ch & CHARDRAWN);
+	     ch--, i--) ;
+#if OPT_DEC_CHRSET
+	if (CSET_DOUBLE(SCRN_BUF_CSETS(screen, row)[0])) {
+	    i *= 2;
+	}
+#endif
+    } else {
+	i = -1;
+    }
+    return (i);
+}
+
+#if !OPT_WIDE_CHARS
+/*
+** double click table for cut and paste in 8 bits
+**
+** This table is divided in four parts :
+**
+**	- control characters	[0,0x1f] U [0x80,0x9f]
+**	- separators		[0x20,0x3f] U [0xa0,0xb9]
+**	- binding characters	[0x40,0x7f] U [0xc0,0xff]
+**	- exceptions
+*/
+/* *INDENT-OFF* */
+static int charClass[256] =
+{
+/* NUL  SOH  STX  ETX  EOT  ENQ  ACK  BEL */
+    32,  1,    1,   1,   1,   1,   1,   1,
+/*  BS   HT   NL   VT   NP   CR   SO   SI */
+     1,  32,   1,   1,   1,   1,   1,   1,
+/* DLE  DC1  DC2  DC3  DC4  NAK  SYN  ETB */
+     1,   1,   1,   1,   1,   1,   1,   1,
+/* CAN   EM  SUB  ESC   FS   GS   RS   US */
+     1,   1,   1,   1,   1,   1,   1,   1,
+/*  SP    !    "    #    $    %    &    ' */
+    32,  33,  34,  35,  36,  37,  38,  39,
+/*   (    )    *    +    ,    -    .    / */
+    40,  41,  42,  43,  44,  45,  46,  47,
+/*   0    1    2    3    4    5    6    7 */
+    48,  48,  48,  48,  48,  48,  48,  48,
+/*   8    9    :    ;    <    =    >    ? */
+    48,  48,  58,  59,  60,  61,  62,  63,
+/*   @    A    B    C    D    E    F    G */
+    64,  48,  48,  48,  48,  48,  48,  48,
+/*   H    I    J    K    L    M    N    O */
+    48,  48,  48,  48,  48,  48,  48,  48,
+/*   P    Q    R    S    T    U    V    W */
+    48,  48,  48,  48,  48,  48,  48,  48,
+/*   X    Y    Z    [    \    ]    ^    _ */
+    48,  48,  48,  91,  92,  93,  94,  48,
+/*   `    a    b    c    d    e    f    g */
+    96,  48,  48,  48,  48,  48,  48,  48,
+/*   h    i    j    k    l    m    n    o */
+    48,  48,  48,  48,  48,  48,  48,  48,
+/*   p    q    r    s    t    u    v    w */
+    48,  48,  48,  48,  48,  48,  48,  48,
+/*   x    y    z    {    |    }    ~  DEL */
+    48,  48,  48, 123, 124, 125, 126,   1,
+/* x80  x81  x82  x83  IND  NEL  SSA  ESA */
+    1,    1,   1,   1,   1,   1,   1,   1,
+/* HTS  HTJ  VTS  PLD  PLU   RI  SS2  SS3 */
+    1,    1,   1,   1,   1,   1,   1,   1,
+/* DCS  PU1  PU2  STS  CCH   MW  SPA  EPA */
+    1,    1,   1,   1,   1,   1,   1,   1,
+/* x98  x99  x9A  CSI   ST  OSC   PM  APC */
+    1,    1,   1,   1,   1,   1,   1,   1,
+/*   -    i   c/    L   ox   Y-    |   So */
+    160, 161, 162, 163, 164, 165, 166, 167,
+/*  ..   c0   ip   <<    _        R0    - */
+    168, 169, 170, 171, 172, 173, 174, 175,
+/*   o   +-    2    3    '    u   q|    . */
+    176, 177, 178, 179, 180, 181, 182, 183,
+/*   ,    1    2   >>  1/4  1/2  3/4    ? */
+    184, 185, 186, 187, 188, 189, 190, 191,
+/*  A`   A'   A^   A~   A:   Ao   AE   C, */
+     48,  48,  48,  48,  48,  48,  48,  48,
+/*  E`   E'   E^   E:   I`   I'   I^   I: */
+     48,  48,  48,  48,  48,  48,  48,  48,
+/*  D-   N~   O`   O'   O^   O~   O:    X */
+     48,  48,  48,  48,  48,  48,  48, 215,
+/*  O/   U`   U'   U^   U:   Y'    P    B */
+     48,  48,  48,  48,  48,  48,  48,  48,
+/*  a`   a'   a^   a~   a:   ao   ae   c, */
+     48,  48,  48,  48,  48,  48,  48,  48,
+/*  e`   e'   e^   e:    i`  i'   i^   i: */
+     48,  48,  48,  48,  48,  48,  48,  48,
+/*   d   n~   o`   o'   o^   o~   o:   -: */
+     48,  48,  48,  48,  48,  48,  48, 247,
+/*  o/   u`   u'   u^   u:   y'    P   y: */
+     48,  48,  48,  48,  48,  48,  48,  48};
+/* *INDENT-ON* */
+
+int
+SetCharacterClassRange(int low,	/* in range of [0..255] */
+		       int high,
+		       int value)	/* arbitrary */
+{
+
+    if (low < 0 || high > 255 || high < low)
+	return (-1);
+
+    for (; low <= high; low++)
+	charClass[low] = value;
+
+    return (0);
+}
+#endif
+
+#if OPT_WIDE_CHARS
+static int
+class_of(TScreen * screen, int row, int col)
+{
+    int value;
+#if OPT_DEC_CHRSET
+    if (CSET_DOUBLE(SCRN_BUF_CSETS(screen, row + screen->topline)[0])) {
+	col /= 2;
+    }
+#endif
+    value = XTERM_CELL(row, col);
+    if_OPT_WIDE_CHARS(screen, {
+	return CharacterClass(value);
+    });
+    return CharacterClass(value);
+}
+#define ClassSelects(screen, row, col, cclass) \
+	 (class_of(screen, row, col) == cclass \
+	 || XTERM_CELL(row, col) == HIDDEN_CHAR)
+#else
+#define class_of(screen,row,col) charClass[XTERM_CELL(row, col)]
+#define ClassSelects(screen, row, col, cclass) \
+	 (class_of(screen,row, col) == cclass)
+#endif
+
+/*
+ * sets startSRow startSCol endSRow endSCol
+ * ensuring that they have legal values
+ */
+static void
+ComputeSelect(int startRow,
+	      int startCol,
+	      int endRow,
+	      int endCol,
+	      Bool extend)
+{
+    TScreen *screen = &term->screen;
+    int length;
+    int cclass;
+
+    TRACE(("ComputeSelect(startRow=%d, startCol=%d, endRow=%d, endCol=%d, %sextend)\n",
+	   startRow, startCol, endRow, endCol, extend ? "" : "no"));
+
+#if OPT_WIDE_CHARS
+    if (startCol > 1
+	&& isWideCell(startRow, startCol - 1)
+	&& XTERM_CELL(startRow, startCol - 0) == HIDDEN_CHAR) {
+	fprintf(stderr, "Adjusting start. Changing downwards from %i.\n", startCol);
+	startCol -= 1;
+	if (endCol == (startCol + 1))
+	    endCol--;
+    }
+
+    if (endCol > 1
+	&& isWideCell(endRow, endCol - 1)
+	&& XTERM_CELL(endRow, endCol) == HIDDEN_CHAR) {
+	endCol += 1;
+    }
+#endif
+
+    if (Coordinate(startRow, startCol) <= Coordinate(endRow, endCol)) {
+	startSRow = startRRow = startRow;
+	startSCol = startRCol = startCol;
+	endSRow = endRRow = endRow;
+	endSCol = endRCol = endCol;
+    } else {			/* Swap them */
+	startSRow = startRRow = endRow;
+	startSCol = startRCol = endCol;
+	endSRow = endRRow = startRow;
+	endSCol = endRCol = startCol;
+    }
+
+    switch (selectUnit) {
+    case SELECTCHAR:
+	if (startSCol > (LastTextCol(startSRow) + 1)) {
+	    startSCol = 0;
+	    startSRow++;
+	}
+	if (endSCol > (LastTextCol(endSRow) + 1)) {
+	    endSCol = 0;
+	    endSRow++;
+	}
+	break;
+    case SELECTWORD:
+	if (startSCol > (LastTextCol(startSRow) + 1)) {
+	    startSCol = 0;
+	    startSRow++;
+	} else {
+	    cclass = class_of(screen, startSRow, startSCol);
+	    do {
+		--startSCol;
+		if (startSCol < 0
+		    && ScrnTstWrapped(screen, startSRow - 1)) {
+		    --startSRow;
+		    startSCol = LastTextCol(startSRow);
+		}
+	    } while (startSCol >= 0
+		     && ClassSelects(screen, startSRow, startSCol, cclass));
+	    ++startSCol;
+	}
+
+#if OPT_WIDE_CHARS
+	if (startSCol && XTERM_CELL(startSRow, startSCol) == HIDDEN_CHAR)
+	    startSCol++;
+#endif
+
+	if (endSCol > (LastTextCol(endSRow) + 1)) {
+	    endSCol = 0;
+	    endSRow++;
+	} else {
+	    length = LastTextCol(endSRow);
+	    cclass = class_of(screen, endSRow, endSCol);
+	    do {
+		++endSCol;
+		if (endSCol > length
+		    && ScrnTstWrapped(screen, endSRow)) {
+		    endSCol = 0;
+		    ++endSRow;
+		    length = LastTextCol(endSRow);
+		}
+	    } while (endSCol <= length
+		     && ClassSelects(screen, endSRow, endSCol, cclass));
+	    /* Word select selects if pointing to any char
+	       in "word", especially in that it includes
+	       the last character in a word.  So no --endSCol
+	       and do special eol handling */
+	    if (endSCol > length + 1) {
+		endSCol = 0;
+		++endSRow;
+	    }
+	}
+
+#if OPT_WIDE_CHARS
+	if (endSCol && XTERM_CELL(endSRow, endSCol) == HIDDEN_CHAR)
+	    endSCol++;
+#endif
+
+	saveStartWRow = startSRow;
+	saveStartWCol = startSCol;
+	break;
+    case SELECTLINE:
+	while (ScrnTstWrapped(screen, endSRow)) {
+	    ++endSRow;
+	}
+	if (term->screen.cutToBeginningOfLine
+	    || startSRow < saveStartWRow) {
+	    startSCol = 0;
+	    while (ScrnTstWrapped(screen, startSRow - 1)) {
+		--startSRow;
+	    }
+	} else if (!extend) {
+	    if ((startRow < saveStartWRow)
+		|| (startRow == saveStartWRow
+		    && startCol < saveStartWCol)) {
+		startSCol = 0;
+		while (ScrnTstWrapped(screen, startSRow - 1)) {
+		    --startSRow;
+		}
+	    } else {
+		startSRow = saveStartWRow;
+		startSCol = saveStartWCol;
+	    }
+	}
+	if (term->screen.cutNewline) {
+	    endSCol = 0;
+	    ++endSRow;
+	} else {
+	    endSCol = LastTextCol(endSRow) + 1;
+	}
+	break;
+    }
+
+    /* check boundaries */
+    ScrollSelection(screen, 0, False);
+
+    TrackText(startSRow, startSCol, endSRow, endSCol);
+    return;
+}
+
+void
+TrackText(int frow,
+	  int fcol,
+	  int trow,
+	  int tcol)
+    /* Guaranteed (frow, fcol) <= (trow, tcol) */
+{
+    int from, to;
+    TScreen *screen = &term->screen;
+    int old_startrow, old_startcol, old_endrow, old_endcol;
+
+    TRACE(("TrackText(frow=%d, fcol=%d, trow=%d, tcol=%d)\n",
+	   frow, fcol, trow, tcol));
+
+    old_startrow = screen->startHRow;
+    old_startcol = screen->startHCol;
+    old_endrow = screen->endHRow;
+    old_endcol = screen->endHCol;
+    if (frow == old_startrow && fcol == old_startcol &&
+	trow == old_endrow && tcol == old_endcol)
+	return;
+    screen->startHRow = frow;
+    screen->startHCol = fcol;
+    screen->endHRow = trow;
+    screen->endHCol = tcol;
+    from = Coordinate(frow, fcol);
+    to = Coordinate(trow, tcol);
+    if (to <= screen->startHCoord || from > screen->endHCoord) {
+	/* No overlap whatsoever between old and new hilite */
+	ReHiliteText(old_startrow, old_startcol, old_endrow, old_endcol);
+	ReHiliteText(frow, fcol, trow, tcol);
+    } else {
+	if (from < screen->startHCoord) {
+	    /* Extend left end */
+	    ReHiliteText(frow, fcol, old_startrow, old_startcol);
+	} else if (from > screen->startHCoord) {
+	    /* Shorten left end */
+	    ReHiliteText(old_startrow, old_startcol, frow, fcol);
+	}
+	if (to > screen->endHCoord) {
+	    /* Extend right end */
+	    ReHiliteText(old_endrow, old_endcol, trow, tcol);
+	} else if (to < screen->endHCoord) {
+	    /* Shorten right end */
+	    ReHiliteText(trow, tcol, old_endrow, old_endcol);
+	}
+    }
+    screen->startHCoord = from;
+    screen->endHCoord = to;
+}
+
+static void
+ReHiliteText(int frow,
+	     int fcol,
+	     int trow,
+	     int tcol)
+    /* Guaranteed that (frow, fcol) <= (trow, tcol) */
+{
+    TScreen *screen = &term->screen;
+    int i;
+
+    TRACE(("ReHiliteText from %d.%d to %d.%d\n", frow, fcol, trow, tcol));
+
+    if (frow < 0)
+	frow = fcol = 0;
+    else if (frow > screen->max_row)
+	return;			/* nothing to do, since trow >= frow */
+
+    if (trow < 0)
+	return;			/* nothing to do, since frow <= trow */
+    else if (trow > screen->max_row) {
+	trow = screen->max_row;
+	tcol = MaxCols(screen);
+    }
+    if (frow == trow && fcol == tcol)
+	return;
+
+    if (frow != trow) {		/* do multiple rows */
+	if ((i = screen->max_col - fcol + 1) > 0) {	/* first row */
+	    ScrnRefresh(screen, frow, fcol, 1, i, True);
+	}
+	if ((i = trow - frow - 1) > 0) {	/* middle rows */
+	    ScrnRefresh(screen, frow + 1, 0, i, MaxCols(screen), True);
+	}
+	if (tcol > 0 && trow <= screen->max_row) {	/* last row */
+	    ScrnRefresh(screen, trow, 0, 1, tcol, True);
+	}
+    } else {			/* do single row */
+	ScrnRefresh(screen, frow, fcol, 1, tcol - fcol, True);
+    }
+}
+
+static void
+SaltTextAway(int crow, int ccol, int row, int col,
+	     String * params,	/* selections */
+	     Cardinal num_params)
+    /* Guaranteed that (crow, ccol) <= (row, col), and that both points are valid
+       (may have row = screen->max_row+1, col = 0) */
+{
+    TScreen *screen = &term->screen;
+    int i, j = 0;
+    int eol;
+    Char *line;
+    Char *lp;
+
+    if (crow == row && ccol > col) {
+	int tmp = ccol;
+	ccol = col;
+	col = tmp;
+    }
+
+    --col;
+    /* first we need to know how long the string is before we can save it */
+
+    if (row == crow) {
+	j = Length(screen, crow, ccol, col);
+    } else {			/* two cases, cut is on same line, cut spans multiple lines */
+	j += Length(screen, crow, ccol, screen->max_col) + 1;
+	for (i = crow + 1; i < row; i++)
+	    j += Length(screen, i, 0, screen->max_col) + 1;
+	if (col >= 0)
+	    j += Length(screen, row, 0, col);
+    }
+
+    /* UTF-8 may require more space */
+    if_OPT_WIDE_CHARS(screen, {
+	j *= 4;
+    });
+
+    /* now get some memory to save it in */
+
+    if (screen->selection_size <= j) {
+	if ((line = (Char *) malloc((unsigned) j + 1)) == 0)
+	    SysError(ERROR_BMALLOC2);
+	XtFree((char *) screen->selection_data);
+	screen->selection_data = line;
+	screen->selection_size = j + 1;
+    } else {
+	line = screen->selection_data;
+    }
+
+    if ((line == 0)
+	|| (j < 0))
+	return;
+
+    line[j] = '\0';		/* make sure it is null terminated */
+    lp = line;			/* lp points to where to save the text */
+    if (row == crow) {
+	lp = SaveText(screen, row, ccol, col, lp, &eol);
+    } else {
+	lp = SaveText(screen, crow, ccol, screen->max_col, lp, &eol);
+	if (eol)
+	    *lp++ = '\n';	/* put in newline at end of line */
+	for (i = crow + 1; i < row; i++) {
+	    lp = SaveText(screen, i, 0, screen->max_col, lp, &eol);
+	    if (eol)
+		*lp++ = '\n';
+	}
+	if (col >= 0)
+	    lp = SaveText(screen, row, 0, col, lp, &eol);
+    }
+    *lp = '\0';			/* make sure we have end marked */
+
+    TRACE(("Salted TEXT:%d:%.*s\n", lp - line, lp - line, line));
+    screen->selection_length = (lp - line);
+    _OwnSelection(term, params, num_params);
+}
+
+#if OPT_PASTE64
+void
+ClearSelectionBuffer()
+{
+    TScreen *screen = &term->screen;
+    screen->selection_length = 0;
+    screen->base64_count = 0;
+}
+
+static void
+AppendStrToSelectionBuffer(Char * text, int len)
+{
+    TScreen *screen = &term->screen;
+    if (len != 0) {
+	int j = screen->selection_length + len;		/* New length */
+	int k = j + (j >> 2) + 80;	/* New size if we grow buffer: grow by ~50% */
+	if (j + 1 >= screen->selection_size) {
+	    if (!screen->selection_length) {
+		/* New buffer */
+		Char *line;
+		if ((line = (Char *) malloc((unsigned) k)) == 0)
+		    SysError(ERROR_BMALLOC2);
+		XtFree((char *) screen->selection_data);
+		screen->selection_data = line;
+	    } else {
+		/* Realloc buffer */
+		screen->selection_data = (Char *)
+		    realloc(screen->selection_data,
+			    (unsigned) k);
+		if (screen->selection_data == 0)
+		    SysError(ERROR_BMALLOC2);
+	    }
+	    screen->selection_size = k;
+	}
+	memcpy(screen->selection_data + screen->selection_length, text, len);
+	screen->selection_length += len;
+	screen->selection_data[screen->selection_length] = 0;
+    }
+}
+
+void
+AppendToSelectionBuffer(TScreen * screen, unsigned c)
+{
+    int six;
+    Char ch;
+
+    /* Decode base64 character */
+    if (c >= 'A' && c <= 'Z')
+	six = c - 'A';
+    else if (c >= 'a' && c <= 'z')
+	six = c - 'a' + 26;
+    else if (c >= '0' && c <= '9')
+	six = c - '0' + 52;
+    else if (c == '+')
+	six = 62;
+    else if (c == '/')
+	six = 63;
+    else
+	return;
+
+    /* Accumulate bytes */
+    switch (screen->base64_count) {
+    case 0:
+	screen->base64_accu = six;
+	screen->base64_count = 6;
+	break;
+
+    case 2:
+	ch = (screen->base64_accu << 6) + six;
+	screen->base64_count = 0;
+	AppendStrToSelectionBuffer(&ch, 1);
+	break;
+
+    case 4:
+	ch = (screen->base64_accu << 4) + (six >> 2);
+	screen->base64_accu = (six & 0x3);
+	screen->base64_count = 2;
+	AppendStrToSelectionBuffer(&ch, 1);
+	break;
+
+    case 6:
+	ch = (screen->base64_accu << 2) + (six >> 4);
+	screen->base64_accu = (six & 0xF);
+	screen->base64_count = 4;
+	AppendStrToSelectionBuffer(&ch, 1);
+	break;
+    }
+}
+
+void
+CompleteSelection(char **args, Cardinal len)
+{
+    term->screen.base64_count = 0;
+    term->screen.base64_accu = 0;
+    _OwnSelection(term, args, len);
+}
+#endif /* OPT_PASTE64 */
+
+static Bool
+_ConvertSelectionHelper(Widget w,
+			Atom * type, XtPointer *value,
+			unsigned long *length, int *format,
+			int (*conversion_function) (Display *,
+						    char **, int,
+						    XICCEncodingStyle,
+						    XTextProperty *),
+			XICCEncodingStyle conversion_style)
+{
+    Display *d = XtDisplay(w);
+    TScreen *screen;
+    XTextProperty textprop;
+
+    if (!IsXtermWidget(w))
+	return False;
+
+    screen = &((XtermWidget) w)->screen;
+
+    if (conversion_function(d, (char **) &screen->selection_data, 1,
+			    conversion_style,
+			    &textprop) < Success)
+	return False;
+    *value = (XtPointer) textprop.value;
+    *length = textprop.nitems;
+    *type = textprop.encoding;
+    *format = textprop.format;
+    return True;
+}
+
+static Boolean
+ConvertSelection(Widget w,
+		 Atom * selection,
+		 Atom * target,
+		 Atom * type,
+		 XtPointer *value,
+		 unsigned long *length,
+		 int *format)
+{
+    Display *d = XtDisplay(w);
+    TScreen *screen;
+    Bool result = False;
+
+    if (!IsXtermWidget(w))
+	return False;
+
+    screen = &((XtermWidget) w)->screen;
+
+    if (screen->selection_data == NULL)
+	return False;		/* can this happen? */
+
+    if (*target == XA_TARGETS(d)) {
+	Atom *targetP;
+	Atom *std_targets;
+	XPointer std_return = 0;
+	unsigned long std_length;
+	if (XmuConvertStandardSelection(w, screen->selection_time, selection,
+					target, type, &std_return,
+					&std_length, format)) {
+	    std_targets = (Atom *) (std_return);
+	    *length = std_length + 6;
+	    targetP = (Atom *) XtMalloc(sizeof(Atom) * (*length));
+	    *value = (XtPointer) targetP;
+	    *targetP++ = XA_STRING;
+	    *targetP++ = XA_TEXT(d);
+#ifdef X_HAVE_UTF8_STRING
+	    *targetP++ = XA_COMPOUND_TEXT(d);
+	    *targetP++ = XA_UTF8_STRING(d);
+#else
+	    *targetP = XA_COMPOUND_TEXT(d);
+	    if_OPT_WIDE_CHARS(screen, {
+		*targetP = XA_UTF8_STRING(d);
+	    });
+	    targetP++;
+#endif
+	    *targetP++ = XA_LENGTH(d);
+	    *targetP++ = XA_LIST_LENGTH(d);
+	    memcpy(targetP, std_targets, sizeof(Atom) * std_length);
+	    XtFree((char *) std_targets);
+	    *type = XA_ATOM;
+	    *format = 32;
+	    result = True;
+	}
+    }
+#if OPT_WIDE_CHARS
+    else if (screen->wide_chars && *target == XA_STRING) {
+	result =
+	    _ConvertSelectionHelper(w,
+				    type, value, length, format,
+				    Xutf8TextListToTextProperty,
+				    XStringStyle);
+    } else if (screen->wide_chars && *target == XA_UTF8_STRING(d)) {
+	result =
+	    _ConvertSelectionHelper(w,
+				    type, value, length, format,
+				    Xutf8TextListToTextProperty,
+				    XUTF8StringStyle);
+    } else if (screen->wide_chars && *target == XA_TEXT(d)) {
+	result =
+	    _ConvertSelectionHelper(w,
+				    type, value, length, format,
+				    Xutf8TextListToTextProperty,
+				    XStdICCTextStyle);
+    } else if (screen->wide_chars && *target == XA_COMPOUND_TEXT(d)) {
+	result =
+	    _ConvertSelectionHelper(w,
+				    type, value, length, format,
+				    Xutf8TextListToTextProperty,
+				    XCompoundTextStyle);
+    }
+#endif
+
+    else if (*target == XA_STRING) {	/* not wide_chars */
+	/* We can only reach this point if the selection requestor
+	   requested STRING before any of TEXT, COMPOUND_TEXT or
+	   UTF8_STRING.  We therefore assume that the requestor is not
+	   properly internationalised, and dump raw eight-bit data
+	   with no conversion into the selection.  Yes, this breaks
+	   the ICCCM in non-Latin-1 locales. */
+	*type = XA_STRING;
+	*value = (XtPointer) screen->selection_data;
+	*length = screen->selection_length;
+	*format = 8;
+	result = True;
+    } else if (*target == XA_TEXT(d)) {		/* not wide_chars */
+	result =
+	    _ConvertSelectionHelper(w,
+				    type, value, length, format,
+				    XmbTextListToTextProperty,
+				    XStdICCTextStyle);
+    } else if (*target == XA_COMPOUND_TEXT(d)) {	/* not wide_chars */
+	result =
+	    _ConvertSelectionHelper(w,
+				    type, value, length, format,
+				    XmbTextListToTextProperty,
+				    XCompoundTextStyle);
+    }
+#ifdef X_HAVE_UTF8_STRING
+    else if (*target == XA_UTF8_STRING(d)) {	/* not wide_chars */
+	result =
+	    _ConvertSelectionHelper(w,
+				    type, value, length, format,
+				    XmbTextListToTextProperty,
+				    XUTF8StringStyle);
+    }
+#endif
+    else if (*target == XA_LIST_LENGTH(d)) {
+	*value = XtMalloc(4);
+	if (sizeof(long) == 4)
+	     *(long *) *value = 1;
+	else {
+	    long temp = 1;
+	    memcpy((char *) *value, ((char *) &temp) + sizeof(long) - 4, 4);
+	}
+	*type = XA_INTEGER;
+	*length = 1;
+	*format = 32;
+	result = True;
+    } else if (*target == XA_LENGTH(d)) {
+	/* This value is wrong if we have UTF-8 text */
+	*value = XtMalloc(4);
+	if (sizeof(long) == 4) {
+	    *(long *) *value = screen->selection_length;
+	} else {
+	    long temp = screen->selection_length;
+	    memcpy((char *) *value, ((char *) &temp) + sizeof(long) - 4, 4);
+	}
+	*type = XA_INTEGER;
+	*length = 1;
+	*format = 32;
+	result = True;
+    } else if (XmuConvertStandardSelection(w,
+					   screen->selection_time, selection,
+					   target, type, (XPointer *) value,
+					   length, format)) {
+	result = True;
+    }
+
+    /* else */
+    return result;
+}
+
+static void
+LoseSelection(Widget w, Atom * selection)
+{
+    TScreen *screen;
+    Atom *atomP;
+    Cardinal i;
+
+    if (!IsXtermWidget(w))
+	return;
+
+    screen = &((XtermWidget) w)->screen;
+    for (i = 0, atomP = screen->selection_atoms;
+	 i < screen->selection_count; i++, atomP++) {
+	if (*selection == *atomP)
+	    *atomP = (Atom) 0;
+	if (CutBuffer(*atomP) >= 0) {
+	    *atomP = (Atom) 0;
+	}
+    }
+
+    for (i = screen->selection_count; i; i--) {
+	if (screen->selection_atoms[i - 1] != 0)
+	    break;
+    }
+    screen->selection_count = i;
+
+    for (i = 0, atomP = screen->selection_atoms;
+	 i < screen->selection_count; i++, atomP++) {
+	if (*atomP == (Atom) 0) {
+	    *atomP = screen->selection_atoms[--screen->selection_count];
+	}
+    }
+
+    if (screen->selection_count == 0)
+	TrackText(0, 0, 0, 0);
+}
+
+/* ARGSUSED */
+static void
+SelectionDone(Widget w GCC_UNUSED,
+	      Atom * selection GCC_UNUSED,
+	      Atom * target GCC_UNUSED)
+{
+    /* empty proc so Intrinsics know we want to keep storage */
+}
+
+static void
+_OwnSelection(XtermWidget termw,
+	      String * selections,
+	      Cardinal count)
+{
+    Atom *atoms = termw->screen.selection_atoms;
+    Cardinal i;
+    Bool have_selection = False;
+
+    if (termw->screen.selection_length < 0)
+	return;
+
+    if (count > termw->screen.sel_atoms_size) {
+	XtFree((char *) atoms);
+	atoms = (Atom *) XtMalloc(count * sizeof(Atom));
+	termw->screen.selection_atoms = atoms;
+	termw->screen.sel_atoms_size = count;
+    }
+    XmuInternStrings(XtDisplay((Widget) termw), selections, count, atoms);
+    for (i = 0; i < count; i++) {
+	int cutbuffer = CutBuffer(atoms[i]);
+	if (cutbuffer >= 0) {
+	    if (termw->screen.selection_length >
+		4 * XMaxRequestSize(XtDisplay((Widget) termw)) - 32) {
+		fprintf(stderr,
+			"%s: selection too big (%d bytes), not storing in CUT_BUFFER%d\n",
+			xterm_name, termw->screen.selection_length, cutbuffer);
+	    } else {
+		/* This used to just use the UTF-8 data, which was totally
+		 * broken as not even the corresponding paste code in Xterm
+		 * understood this!  So now it converts to Latin1 first.
+		 *   Robert Brady, 2000-09-05
+		 */
+		unsigned long length = termw->screen.selection_length;
+		Char *data = termw->screen.selection_data;
+		if_OPT_WIDE_CHARS((&(termw->screen)), {
+		    data = UTF8toLatin1(data, length, &length);
+		});
+		TRACE(("XStoreBuffer(%d)\n", cutbuffer));
+		XStoreBuffer(XtDisplay((Widget) termw),
+			     (char *) data,
+			     (int) length,
+			     cutbuffer);
+	    }
+	} else if (!replyToEmacs) {
+	    have_selection |=
+		XtOwnSelection((Widget) termw, atoms[i],
+			       termw->screen.selection_time,
+			       ConvertSelection, LoseSelection, SelectionDone);
+	}
+    }
+    if (!replyToEmacs)
+	termw->screen.selection_count = count;
+    if (!have_selection)
+	TrackText(0, 0, 0, 0);
+}
+
+static void
+ResetSelectionState(TScreen * screen)
+{
+    screen->selection_count = 0;
+    screen->startHRow = screen->startHCol = 0;
+    screen->endHRow = screen->endHCol = 0;
+}
+
+void
+DisownSelection(XtermWidget termw)
+{
+    TScreen *screen = &(termw->screen);
+    Atom *atoms = screen->selection_atoms;
+    Cardinal count = screen->selection_count;
+    Cardinal i;
+
+    TRACE(("DisownSelection count %d, start %d.%d, end %d.%d\n",
+	   count,
+	   screen->startHRow,
+	   screen->startHCol,
+	   screen->endHRow,
+	   screen->endHCol));
+
+    for (i = 0; i < count; i++) {
+	int cutbuffer = CutBuffer(atoms[i]);
+	if (cutbuffer < 0) {
+	    XtDisownSelection((Widget) termw, atoms[i],
+			      screen->selection_time);
+	}
+    }
+    /*
+     * If none of the callbacks via XtDisownSelection() reset highlighting
+     * do it now.
+     */
+    if (ScrnHaveSelection(screen)) {
+	/* save data which will be reset */
+	int start_row = screen->startHRow;
+	int start_col = screen->startHCol;
+	int end_row = screen->endHRow;
+	int end_col = screen->endHCol;
+
+	ResetSelectionState(screen);
+	ReHiliteText(start_row, start_col, end_row, end_col);
+    } else {
+	ResetSelectionState(screen);
+    }
+}
+
+/* returns number of chars in line from scol to ecol out */
+/* ARGSUSED */
+static int
+Length(TScreen * screen GCC_UNUSED,
+       int row,
+       int scol,
+       int ecol)
+{
+    int lastcol = LastTextCol(row);
+
+    if (ecol > lastcol)
+	ecol = lastcol;
+    return (ecol - scol + 1);
+}
+
+/* copies text into line, preallocated */
+static Char *
+SaveText(TScreen * screen,
+	 int row,
+	 int scol,
+	 int ecol,
+	 Char * lp,		/* pointer to where to put the text */
+	 int *eol)
+{
+    int i = 0;
+    unsigned c;
+    Char *result = lp;
+#if OPT_WIDE_CHARS
+    int previous = 0;
+    unsigned c_1 = 0, c_2 = 0;
+#endif
+
+    i = Length(screen, row, scol, ecol);
+    ecol = scol + i;
+#if OPT_DEC_CHRSET
+    if (CSET_DOUBLE(SCRN_BUF_CSETS(screen, row + screen->topline)[0])) {
+	scol = (scol + 0) / 2;
+	ecol = (ecol + 1) / 2;
+    }
+#endif
+    *eol = !ScrnTstWrapped(screen, row);
+    for (i = scol; i < ecol; i++) {
+	c = E2A(XTERM_CELL(row, i));
+#if OPT_WIDE_CHARS
+	if (screen->utf8_mode != uFalse) {
+	    c_1 = E2A(XTERM_CELL_C1(row, i));
+	    c_2 = E2A(XTERM_CELL_C2(row, i));
+	}
+
+	/* We want to strip out every occurrence of HIDDEN_CHAR AFTER a
+	 * wide character.
+	 */
+	if (c == HIDDEN_CHAR && iswide(previous)) {
+	    previous = c;
+	    /* Combining characters attached to double-width characters
+	       are in memory attached to the HIDDEN_CHAR */
+	    if (c_1) {
+		lp = convertToUTF8(lp, c_1);
+		if (c_2)
+		    lp = convertToUTF8(lp, c_2);
+	    }
+	    continue;
+	}
+	previous = c;
+	if (screen->utf8_mode != uFalse) {
+	    lp = convertToUTF8(lp, (c != 0) ? c : ' ');
+	    if (c_1) {
+		lp = convertToUTF8(lp, c_1);
+		if (c_2)
+		    lp = convertToUTF8(lp, c_2);
+	    }
+	} else
+#endif
+	{
+	    if (c == 0) {
+		c = E2A(' ');
+	    } else if (c < E2A(' ')) {
+		if (c == XPOUND)
+		    c = 0x23;	/* char on screen is pound sterling */
+		else
+		    c += 0x5f;	/* char is from DEC drawing set */
+	    } else if (c == 0x7f) {
+		c = 0x5f;
+	    }
+	    *lp++ = A2E(c);
+	}
+	if (c != E2A(' '))
+	    result = lp;
+    }
+
+    /*
+     * If requested, trim trailing blanks from selected lines.  Do not do this
+     * if the line is wrapped.
+     */
+    if (!*eol || !screen->trim_selection)
+	result = lp;
+
+    return (result);
+}
+
+/* 32 + following 7-bit word:
+
+   1:0  Button no: 0, 1, 2.  3=release.
+     2  shift
+     3  meta
+     4  ctrl
+     5  set for motion notify
+     6  set for wheel
+*/
+
+/* Position: 32 - 255. */
+
+static int
+BtnCode(XButtonEvent * event, int button)
+{
+    int result = 32 + (KeyState(event->state) << 2);
+
+    if (button < 0 || button > 5) {
+	result += 3;
+    } else {
+	if (button > 3)
+	    result += (64 - 4);
+	if (event->type == MotionNotify)
+	    result += 32;
+	result += button;
+    }
+    return result;
+}
+
+#define MOUSE_LIMIT (255 - 32)
+
+static void
+EditorButton(XButtonEvent * event)
+{
+    TScreen *screen = &term->screen;
+    int pty = screen->respond;
+    Char line[6];
+    int row, col;
+    int button;
+    unsigned count = 0;
+
+    /* If button event, get button # adjusted for DEC compatibility */
+    button = event->button - 1;
+    if (button >= 3)
+	button++;
+
+    /* Compute character position of mouse pointer */
+    row = (event->y - screen->border) / FontHeight(screen);
+    col = (event->x - OriginX(screen)) / FontWidth(screen);
+
+    /* Limit to screen dimensions */
+    if (row < 0)
+	row = 0;
+    else if (row > screen->max_row)
+	row = screen->max_row;
+    else if (row > MOUSE_LIMIT)
+	row = MOUSE_LIMIT;
+
+    if (col < 0)
+	col = 0;
+    else if (col > screen->max_col)
+	col = screen->max_col;
+    else if (col > MOUSE_LIMIT)
+	col = MOUSE_LIMIT;
+
+    /* Build key sequence starting with \E[M */
+    if (screen->control_eight_bits) {
+	line[count++] = CSI;
+    } else {
+	line[count++] = ESC;
+	line[count++] = '[';
+    }
+    line[count++] = 'M';
+
+    /* Add event code to key sequence */
+    if (screen->send_mouse_pos == X10_MOUSE) {
+	line[count++] = ' ' + button;
+    } else {
+	/* Button-Motion events */
+	switch (event->type) {
+	case ButtonPress:
+	    line[count++] = BtnCode(event, screen->mouse_button = button);
+	    break;
+	case ButtonRelease:
+	    /*
+	     * Wheel mouse interface generates release-events for buttons
+	     * 4 and 5, coded here as 3 and 4 respectively.  We change the
+	     * release for buttons 1..3 to a -1.
+	     */
+	    if (button < 3)
+		button = -1;
+	    line[count++] = BtnCode(event, screen->mouse_button = button);
+	    break;
+	case MotionNotify:
+	    /* BTN_EVENT_MOUSE and ANY_EVENT_MOUSE modes send motion
+	     * events only if character cell has changed.
+	     */
+	    if ((row == screen->mouse_row)
+		&& (col == screen->mouse_col))
+		return;
+	    line[count++] = BtnCode(event, screen->mouse_button);
+	    break;
+	default:
+	    return;
+	}
+    }
+
+    screen->mouse_row = row;
+    screen->mouse_col = col;
+
+    /* Add pointer position to key sequence */
+    line[count++] = ' ' + col + 1;
+    line[count++] = ' ' + row + 1;
+
+    TRACE(("mouse at %d,%d button+mask = %#x\n", row, col,
+	   (screen->control_eight_bits) ? line[2] : line[3]));
+
+    /* Transmit key sequence to process running under xterm */
+    v_write(pty, line, count);
+}
+
+/*ARGSUSED*/
+#if OPT_TEK4014
+void
+HandleGINInput(Widget w GCC_UNUSED,
+	       XEvent * event GCC_UNUSED,
+	       String * param_list,
+	       Cardinal *nparamsp)
+{
+    if (term->screen.TekGIN && *nparamsp == 1) {
+	int c = param_list[0][0];
+	switch (c) {
+	case 'l':
+	case 'm':
+	case 'r':
+	case 'L':
+	case 'M':
+	case 'R':
+	    break;
+	default:
+	    Bell(XkbBI_MinorError, 0);	/* let them know they goofed */
+	    c = 'l';		/* provide a default */
+	}
+	TekEnqMouse(c | 0x80);
+	TekGINoff();
+    } else {
+	Bell(XkbBI_MinorError, 0);
+    }
+}
+#endif /* OPT_TEK4014 */
+
+/* ARGSUSED */
+void
+HandleSecure(Widget w GCC_UNUSED,
+	     XEvent * event,	/* unused */
+	     String * params GCC_UNUSED,	/* [0] = volume */
+	     Cardinal *param_count GCC_UNUSED)	/* 0 or 1 */
+{
+    Time ev_time = CurrentTime;
+
+    if ((event->xany.type == KeyPress) ||
+	(event->xany.type == KeyRelease))
+	ev_time = event->xkey.time;
+    else if ((event->xany.type == ButtonPress) ||
+	     (event->xany.type == ButtonRelease))
+	ev_time = event->xbutton.time;
+    DoSecureKeyboard(ev_time);
+}