aboutsummaryrefslogtreecommitdiff
path: root/nx-X11/programs/xterm/button.c
diff options
context:
space:
mode:
Diffstat (limited to 'nx-X11/programs/xterm/button.c')
-rw-r--r--nx-X11/programs/xterm/button.c3284
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);
+}