X-Git-Url: https://ncurses.scripts.mit.edu/?p=ncurses.git;a=blobdiff_plain;f=ncurses%2Fbase%2Flib_mouse.c;h=c2cbf211a2e28309b91e9f13e30abcbce562b240;hp=08af6a6867b5d83f4cc50a69a12f51b5cf692d93;hb=76a479337308b4b5e749fa8c38b7b7f482998c5b;hpb=7d3e03f12f3e179f5780f733fa5b78d981080d48 diff --git a/ncurses/base/lib_mouse.c b/ncurses/base/lib_mouse.c index 08af6a68..c2cbf211 100644 --- a/ncurses/base/lib_mouse.c +++ b/ncurses/base/lib_mouse.c @@ -1,5 +1,5 @@ /**************************************************************************** - * Copyright (c) 1998-2013,2014 Free Software Foundation, Inc. * + * Copyright (c) 1998-2015,2016 Free Software Foundation, Inc. * * * * Permission is hereby granted, free of charge, to any person obtaining a * * copy of this software and associated documentation files (the * @@ -84,7 +84,7 @@ #define CUR SP_TERMTYPE #endif -MODULE_ID("$Id: lib_mouse.c,v 1.143 2014/04/26 18:47:20 juergen Exp $") +MODULE_ID("$Id: lib_mouse.c,v 1.169 2016/05/28 23:11:26 tom Exp $") #include @@ -376,9 +376,46 @@ static void init_xterm_mouse(SCREEN *sp) { sp->_mouse_type = M_XTERM; + sp->_mouse_format = MF_X10; sp->_mouse_xtermcap = tigetstr("XM"); - if (!VALID_STRING(sp->_mouse_xtermcap)) + if (VALID_STRING(sp->_mouse_xtermcap)) { + char *code = strstr(sp->_mouse_xtermcap, "[?"); + if (code != 0) { + code += 2; + while ((*code >= '0') && (*code <= '9')) { + char *next = code; + while ((*next >= '0') && (*next <= '9')) { + ++next; + } + if (!strncmp(code, "1006", (size_t) (next - code))) { + sp->_mouse_format = MF_SGR1006; + } +#ifdef EXP_XTERM_1005 + if (!strncmp(code, "1005", (size_t) (next - code))) { + sp->_mouse_format = MF_XTERM_1005; + } +#endif + if (*next == ';') { + while (*next == ';') { + ++next; + } + code = next; + } else { + break; + } + } + } + } else { + int code = tigetnum("XM"); + switch (code) { + case 1006: + break; + default: + code = 1000; + break; + } sp->_mouse_xtermcap = "\033[?1000%?%p1%{1}%=%th%el%;"; + } } #endif @@ -395,7 +432,7 @@ enable_xterm_mouse(SCREEN *sp, int enable) #if USE_GPM_SUPPORT static bool -allow_gpm_mouse(SCREEN *sp) +allow_gpm_mouse(SCREEN *sp GCC_UNUSED) { bool result = FALSE; @@ -409,8 +446,8 @@ allow_gpm_mouse(SCREEN *sp) #endif /* GPM does printf's without checking if stdout is a terminal */ if (NC_ISATTY(fileno(stdout))) { - char *list = getenv("NCURSES_GPM_TERMS"); - char *env = getenv("TERM"); + const char *list = getenv("NCURSES_GPM_TERMS"); + const char *env = getenv("TERM"); if (list != 0) { if (env != 0) { result = _nc_name_match(list, env, "|:"); @@ -571,7 +608,7 @@ initialize_mousetype(SCREEN *sp) int rc; if (!sp->_emxmouse_buttons[0]) { - char *s = getenv("MOUSE_BUTTONS_123"); + const char *s = getenv("MOUSE_BUTTONS_123"); sp->_emxmouse_buttons[0] = 1; if (s && strlen(s) >= 3) { @@ -604,13 +641,14 @@ initialize_mousetype(SCREEN *sp) #if USE_SYSMOUSE { + static char dev_tty[] = "/dev/tty"; struct mouse_info the_mouse; char *the_device = 0; if (NC_ISATTY(sp->_ifd)) the_device = ttyname(sp->_ifd); if (the_device == 0) - the_device = "/dev/tty"; + the_device = dev_tty; sp->_mouse_fd = open(the_device, O_RDWR); @@ -690,10 +728,11 @@ _nc_mouse_init(SCREEN *sp) /* initialize the mouse */ { bool result = FALSE; - int i; if (sp != 0) { if (!sp->_mouse_initialized) { + int i; + sp->_mouse_initialized = TRUE; TR(MY_TRACE, ("_nc_mouse_init() called")); @@ -846,173 +885,421 @@ _nc_mouse_event(SCREEN *sp) return result; /* true if we found an event */ } +#if USE_EMX_MOUSE +#define PRESS_POSITION(n) \ + do { \ + eventp->bstate = MASK_PRESS(n); \ + sp->_mouse_bstate |= MASK_PRESS(n); \ + if (button & 0x40) { \ + eventp->bstate = MASK_RELEASE(n); \ + sp->_mouse_bstate &= ~MASK_PRESS(n); \ + } \ + } while (0) +#else +#define PRESS_POSITION(n) \ + do { \ + eventp->bstate = (mmask_t) ((sp->_mouse_bstate & MASK_PRESS(n)) \ + ? REPORT_MOUSE_POSITION \ + : MASK_PRESS(n)); \ + sp->_mouse_bstate |= MASK_PRESS(n); \ + } while (0) +#endif + static bool -_nc_mouse_inline(SCREEN *sp) -/* mouse report received in the keyboard stream -- parse its info */ +handle_wheel(SCREEN *sp, MEVENT * eventp, int button, int wheel) { - int b; - bool result = FALSE; - MEVENT *eventp = sp->_mouse_eventp; + bool result = TRUE; + + switch (button & 3) { + case 0: + if (wheel) { + eventp->bstate = MASK_PRESS(4); + /* Do not record in sp->_mouse_bstate; there will be no + * corresponding release event. + */ + } else { + PRESS_POSITION(1); + } + break; + case 1: + if (wheel) { +#if NCURSES_MOUSE_VERSION == 2 + eventp->bstate = MASK_PRESS(5); + /* See comment above for button 4 */ +#else + /* Ignore this event as it is not a true press of the button */ + eventp->bstate = REPORT_MOUSE_POSITION; +#endif + } else { + PRESS_POSITION(2); + } + break; + case 2: + PRESS_POSITION(3); + break; + default: + result = FALSE; + break; + } + return result; +} - TR(MY_TRACE, ("_nc_mouse_inline() called")); +static bool +decode_X10_bstate(SCREEN *sp, MEVENT * eventp, unsigned intro) +{ + bool result; - if (sp->_mouse_type == M_XTERM) { - unsigned char kbuf[4]; - size_t grabbed; - int res; + eventp->bstate = 0; + + if (!handle_wheel(sp, eventp, (int) intro, (intro & 96) == 96)) { - /* This code requires that your xterm entry contain the kmous - * capability and that it be set to the \E[M documented in the - * Xterm Control Sequences reference. This is how we - * arrange for mouse events to be reported via a KEY_MOUSE - * return value from wgetch(). After this value is received, - * _nc_mouse_inline() gets called and is immediately - * responsible for parsing the mouse status information - * following the prefix. - * - * The following quotes from the ctrlseqs.ms document in the - * X distribution, describing the X mouse tracking feature: - * - * Parameters for all mouse tracking escape sequences - * generated by xterm encode numeric parameters in a single - * character as value+040. For example, ! is 1. - * - * On button press or release, xterm sends ESC [ M CbCxCy. - * The low two bits of Cb encode button information: 0=MB1 - * pressed, 1=MB2 pressed, 2=MB3 pressed, 3=release. The - * upper bits encode what modifiers were down when the - * button was pressed and are added together. 4=Shift, - * 8=Meta, 16=Control. Cx and Cy are the x and y coordinates - * of the mouse event. The upper left corner is (1,1). - * - * (End quote) By the time we get here, we've eaten the - * key prefix. FYI, the loop below is necessary because - * mouse click info isn't guaranteed to present as a - * single clist item. - * - * Wheel mice may return buttons 4 and 5 when the wheel is turned. - * We encode those as button presses. + /* + * Release events aren't reported for individual buttons, just for + * the button set as a whole. However, because there are normally + * no mouse events under xterm that intervene between press and + * release, we can infer the button actually released by looking at + * the previous event. */ + if (sp->_mouse_bstate & BUTTON_PRESSED) { + int b; + + eventp->bstate = BUTTON_RELEASED; + for (b = 1; b <= MAX_BUTTONS; ++b) { + if (!(sp->_mouse_bstate & MASK_PRESS(b))) + eventp->bstate &= ~MASK_RELEASE(b); + } + sp->_mouse_bstate = 0; + } else { + /* + * xterm will return a stream of release-events to let the + * application know where the mouse is going, if private mode + * 1002 or 1003 is enabled. + */ + eventp->bstate = REPORT_MOUSE_POSITION; + } + } + + if (intro & 4) { + eventp->bstate |= BUTTON_SHIFT; + } + if (intro & 8) { + eventp->bstate |= BUTTON_ALT; + } + if (intro & 16) { + eventp->bstate |= BUTTON_CTRL; + } + result = (eventp->bstate & REPORT_MOUSE_POSITION) ? TRUE : FALSE; + return result; +} + +/* This code requires that your xterm entry contain the kmous capability and + * that it be set to the \E[M documented in the Xterm Control Sequences + * reference. This is how we arrange for mouse events to be reported via a + * KEY_MOUSE return value from wgetch(). After this value is received, + * _nc_mouse_inline() gets called and is immediately responsible for parsing + * the mouse status information following the prefix. + * + * The following quotes from the ctlseqs.ms document in the XTerm distribution, + * describing the mouse tracking feature: + * + * Parameters for all mouse tracking escape sequences generated by xterm encode + * numeric parameters in a single character as value+040. For example, ! is + * 1. + * + * On button press or release, xterm sends ESC [ M CbCxCy. The low two bits of + * Cb encode button information: 0=MB1 pressed, 1=MB2 pressed, 2=MB3 pressed, + * 3=release. The upper bits encode what modifiers were down when the button + * was pressed and are added together. 4=Shift, 8=Meta, 16=Control. Cx and Cy + * are the x and y coordinates of the mouse event. The upper left corner is + * (1,1). + * + * (End quote) By the time we get here, we've eaten the key prefix. FYI, the + * loop below is necessary because mouse click info isn't guaranteed to present + * as a single clist item. + * + * Wheel mice may return buttons 4 and 5 when the wheel is turned. We encode + * those as button presses. + */ +static bool +decode_xterm_X10(SCREEN *sp, MEVENT * eventp) +{ + unsigned char kbuf[4]; + size_t grabbed; + int res; + bool result; + # if USE_PTHREADS_EINTR # if USE_WEAK_SYMBOLS - if ((pthread_self) && (pthread_kill) && (pthread_equal)) + if ((pthread_self) && (pthread_kill) && (pthread_equal)) # endif - _nc_globals.read_thread = pthread_self(); + _nc_globals.read_thread = pthread_self(); # endif - for (grabbed = 0; grabbed < 3; grabbed += (size_t) res) { + for (grabbed = 0; grabbed < 3; grabbed += (size_t) res) { - /* For VIO mouse we add extra bit 64 to disambiguate button-up. */ + /* For VIO mouse we add extra bit 64 to disambiguate button-up. */ + res = (int) read( #if USE_EMX_MOUSE - res = (int) read(M_FD(sp) >= 0 ? M_FD(sp) : sp->_ifd, &kbuf, 3); + (M_FD(sp) >= 0) ? M_FD(sp) : sp->_ifd, #else - res = (int) read(sp->_ifd, kbuf + grabbed, 3 - grabbed); + sp->_ifd, #endif - if (res == -1) - break; - } + kbuf + grabbed, 3 - grabbed); + if (res == -1) + break; + } #if USE_PTHREADS_EINTR - _nc_globals.read_thread = 0; + _nc_globals.read_thread = 0; #endif - kbuf[3] = '\0'; + kbuf[3] = '\0'; - TR(TRACE_IEVENT, - ("_nc_mouse_inline sees the following xterm data: '%s'", kbuf)); + TR(TRACE_IEVENT, + ("_nc_mouse_inline sees the following xterm data: '%s'", kbuf)); - /* there's only one mouse... */ - eventp->id = NORMAL_EVENT; + /* there's only one mouse... */ + eventp->id = NORMAL_EVENT; + + result = decode_X10_bstate(sp, eventp, kbuf[0]); + + eventp->x = (kbuf[1] - ' ') - 1; + eventp->y = (kbuf[2] - ' ') - 1; + + return result; +} + +#ifdef EXP_XTERM_1005 +/* + * This is identical to X10/X11 responses except that there are two UTF-8 + * characters storing the ordinates instead of two bytes. + */ +static bool +decode_xterm_1005(SCREEN *sp, MEVENT * eventp) +{ + char kbuf[80]; + size_t grabbed; + size_t limit = (sizeof(kbuf) - 1); + unsigned coords[2]; + bool result; + + coords[0] = 0; + coords[1] = 0; - /* processing code goes here */ - eventp->bstate = 0; +# if USE_PTHREADS_EINTR +# if USE_WEAK_SYMBOLS + if ((pthread_self) && (pthread_kill) && (pthread_equal)) +# endif + _nc_globals.read_thread = pthread_self(); +# endif + for (grabbed = 0; grabbed < limit;) { + int res; + res = (int) read( #if USE_EMX_MOUSE -#define PRESS_POSITION(n) \ - do { \ - eventp->bstate = MASK_PRESS(n); \ - sp->_mouse_bstate |= MASK_PRESS(n); \ - if (kbuf[0] & 0x40) { \ - eventp->bstate = MASK_RELEASE(n); \ - sp->_mouse_bstate &= ~MASK_PRESS(n); \ - } \ - } while (0) + (M_FD(sp) >= 0) ? M_FD(sp) : sp->_ifd, #else -#define PRESS_POSITION(n) \ - do { \ - eventp->bstate = (mmask_t) (sp->_mouse_bstate & MASK_PRESS(n) \ - ? REPORT_MOUSE_POSITION \ - : MASK_PRESS(n)); \ - sp->_mouse_bstate |= MASK_PRESS(n); \ - } while (0) + sp->_ifd, #endif + kbuf + grabbed, 1); + if (res == -1) + break; + grabbed += (size_t) res; + if (grabbed > 1) { + size_t check = 1; + int n; - switch (kbuf[0] & 0x3) { - case 0x0: - if ((kbuf[0] & 96) == 96) { - eventp->bstate = MASK_PRESS(4); - /* Do not record in sp->_mouse_bstate; there will be no - * corresponding release event. - */ - } else { - PRESS_POSITION(1); + for (n = 0; n < 2; ++n) { + int rc; + + if (check >= grabbed) + break; + rc = _nc_conv_to_utf32(&coords[n], kbuf + check, (unsigned) + (grabbed - check)); + if (!rc) + break; + check += (size_t) rc; } - break; + if (n >= 2) + break; + } + } +#if USE_PTHREADS_EINTR + _nc_globals.read_thread = 0; +#endif - case 0x1: - if ((kbuf[0] & 96) == 96) { -#if NCURSES_MOUSE_VERSION == 2 - eventp->bstate = MASK_PRESS(5); - /* See comment above for button 4 */ + TR(TRACE_IEVENT, + ("_nc_mouse_inline sees the following xterm data: %s", + _nc_visbufn(kbuf, (int) grabbed))); + + /* there's only one mouse... */ + eventp->id = NORMAL_EVENT; + + result = decode_X10_bstate(sp, eventp, UChar(kbuf[0])); + + eventp->x = (int) (coords[0] - ' ') - 1; + eventp->y = (int) (coords[1] - ' ') - 1; + + return result; +} +#endif /* EXP_XTERM_1005 */ + +/* + * ECMA-48 section 5.4 + */ +#define isInter(c) ((c) >= 0x20 && (c) <= 0x2f) +#define isParam(c) ((c) >= 0x30 && (c) <= 0x3f) +#define isFinal(c) ((c) >= 0x40 && (c) <= 0x7e) + +#define MAX_PARAMS 9 + +typedef struct { + int nerror; /* nonzero if there are unexpected chars */ + int nparam; /* number of numeric parameters */ + int params[MAX_PARAMS]; + int final; /* the final-character */ +} SGR_DATA; + +static bool +read_SGR(SCREEN *sp, SGR_DATA * result) +{ + char kbuf[80]; /* bigger than any possible mouse response */ + int grabbed = 0; + int ch = 0; + int now = -1; + int marker = 1; + + memset(result, 0, sizeof(*result)); +# if USE_PTHREADS_EINTR +# if USE_WEAK_SYMBOLS + if ((pthread_self) && (pthread_kill) && (pthread_equal)) +# endif + _nc_globals.read_thread = pthread_self(); +# endif + + do { + int res; + + res = (int) read( +#if USE_EMX_MOUSE + (M_FD(sp) >= 0) ? M_FD(sp) : sp->_ifd, #else - /* Ignore this event as it is not a true press of the button */ - eventp->bstate = REPORT_MOUSE_POSITION; + sp->_ifd, #endif + kbuf + grabbed, 1); + if (res == -1) + break; + if ((grabbed + 3) >= (int) sizeof(kbuf)) { + result->nerror++; + break; + } + ch = UChar(kbuf[grabbed]); + kbuf[grabbed + 1] = 0; + switch (ch) { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + if (marker) { + ++now; + result->nparam = (now + 1); + } + marker = 0; + result->params[now] = (result->params[now] * 10) + (ch - '0'); + break; + case ';': + if (marker) { + ++now; + result->nparam = (now + 1); + } + marker = 1; + break; + default: + if (ch < 32 || ch > 126) { + /* + * Technically other characters could be interspersed in the + * response. Ignore those for now. + */ + result->nerror++; + continue; + } else if (isFinal(ch)) { + if (marker) { + result->nparam++; + } + result->final = ch; } else { - PRESS_POSITION(2); + result->nerror++; } break; + } + ++grabbed; + } while (!isFinal(ch)); +#if USE_PTHREADS_EINTR + _nc_globals.read_thread = 0; +#endif - case 0x2: - PRESS_POSITION(3); - break; + kbuf[++grabbed] = 0; + TR(TRACE_IEVENT, + ("_nc_mouse_inline sees the following xterm data: '%s'", kbuf)); + return (grabbed > 0) && (result->nerror == 0); +} - case 0x3: - /* - * Release events aren't reported for individual buttons, just for - * the button set as a whole. However, because there are normally - * no mouse events under xterm that intervene between press and - * release, we can infer the button actually released by looking at - * the previous event. - */ - if (sp->_mouse_bstate & BUTTON_PRESSED) { - eventp->bstate = BUTTON_RELEASED; - for (b = 1; b <= MAX_BUTTONS; ++b) { - if (!(sp->_mouse_bstate & MASK_PRESS(b))) - eventp->bstate &= ~MASK_RELEASE(b); - } - sp->_mouse_bstate = 0; +static bool +decode_xterm_SGR1006(SCREEN *sp, MEVENT * eventp) +{ + SGR_DATA data; + bool result = FALSE; + if (read_SGR(sp, &data)) { + int b = data.params[0]; + int b3 = 1 + (b & 3); + + eventp->id = NORMAL_EVENT; + if (data.final == 'M') { + (void) handle_wheel(sp, eventp, b, (b & 64) == 64); + } else { + mmask_t pressed = (mmask_t) NCURSES_MOUSE_MASK(b3, NCURSES_BUTTON_PRESSED); + mmask_t release = (mmask_t) NCURSES_MOUSE_MASK(b3, NCURSES_BUTTON_RELEASED); + if (sp->_mouse_bstate & pressed) { + eventp->bstate = release; + sp->_mouse_bstate &= ~pressed; } else { - /* - * XFree86 xterm will return a stream of release-events to - * let the application know where the mouse is going, if the - * private mode 1002 or 1003 is enabled. - */ eventp->bstate = REPORT_MOUSE_POSITION; } - break; } result = (eventp->bstate & REPORT_MOUSE_POSITION) ? TRUE : FALSE; + eventp->x = (data.params[1] ? (data.params[1] - 1) : 0); + eventp->y = (data.params[2] ? (data.params[2] - 1) : 0); + } + return result; +} - if (kbuf[0] & 4) { - eventp->bstate |= BUTTON_SHIFT; - } - if (kbuf[0] & 8) { - eventp->bstate |= BUTTON_ALT; - } - if (kbuf[0] & 16) { - eventp->bstate |= BUTTON_CTRL; +static bool +_nc_mouse_inline(SCREEN *sp) +/* mouse report received in the keyboard stream -- parse its info */ +{ + bool result = FALSE; + MEVENT *eventp = sp->_mouse_eventp; + + TR(MY_TRACE, ("_nc_mouse_inline() called")); + + if (sp->_mouse_type == M_XTERM) { + switch (sp->_mouse_format) { + case MF_X10: + result = decode_xterm_X10(sp, eventp); + break; + case MF_SGR1006: + result = decode_xterm_SGR1006(sp, eventp); + break; +#ifdef EXP_XTERM_1005 + case MF_XTERM_1005: + result = decode_xterm_1005(sp, eventp); + break; +#endif } - eventp->x = (kbuf[1] - ' ') - 1; - eventp->y = (kbuf[2] - ' ') - 1; TR(MY_TRACE, ("_nc_mouse_inline: primitive mouse-event %s has slot %ld", _nc_tracemouse(sp, eventp), @@ -1020,9 +1307,23 @@ _nc_mouse_inline(SCREEN *sp) /* bump the next-free pointer into the circular list */ sp->_mouse_eventp = NEXT(eventp); -#if 0 /* this return would be needed for QNX's mods to lib_getch.c */ - return (TRUE); -#endif + + if (!result) { + /* If this event is from a wheel-mouse, treat it like position + * reports and avoid waiting for the release-events which will + * never come. + */ + if (eventp->bstate & BUTTON_PRESSED) { + int b; + + for (b = 4; b <= MAX_BUTTONS; ++b) { + if ((eventp->bstate & MASK_PRESS(b))) { + result = TRUE; + break; + } + } + } + } } return (result); @@ -1530,7 +1831,6 @@ NCURSES_SP_NAME(mousemask) (NCURSES_SP_DCLx mmask_t newmask, mmask_t * oldmask) /* set the mouse event mask */ { mmask_t result = 0; - int b; T((T_CALLED("mousemask(%p,%#lx,%p)"), (void *) SP_PARM, @@ -1543,7 +1843,10 @@ NCURSES_SP_NAME(mousemask) (NCURSES_SP_DCLx mmask_t newmask, mmask_t * oldmask) if (newmask || SP_PARM->_mouse_initialized) { _nc_mouse_init(SP_PARM); + if (SP_PARM->_mouse_type != M_NONE) { + int b; + result = newmask & (REPORT_MOUSE_POSITION | BUTTON_ALT