X-Git-Url: https://ncurses.scripts.mit.edu/?p=ncurses.git;a=blobdiff_plain;f=ncurses%2Fbase%2Flib_mouse.c;h=aace7deb4c7fc7a334d15a169cc6a5198bdf2195;hp=3b85635039798abc655864baac28b9dfd589e581;hb=88d50b5d7057d4f59c586c93ff290d0a39528f70;hpb=c633e5103a29a38532cf1925257b91cea33fd090 diff --git a/ncurses/base/lib_mouse.c b/ncurses/base/lib_mouse.c index 3b856350..aace7deb 100644 --- a/ncurses/base/lib_mouse.c +++ b/ncurses/base/lib_mouse.c @@ -1,5 +1,5 @@ /**************************************************************************** - * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. * + * Copyright (c) 1998-2006,2007 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 * @@ -29,14 +29,18 @@ /**************************************************************************** * Author: Zeyd M. Ben-Halim 1992,1995 * * and: Eric S. Raymond * + * and: Thomas E. Dickey 1996-on * ****************************************************************************/ /* * This module is intended to encapsulate ncurses's interface to pointing * devices. * - * The first method used is xterm's internal mouse-tracking facility. - * The second is Alessandro Rubini's GPM server. + * The primary method used is xterm's internal mouse-tracking facility. + * Additional methods depend on the platform: + * Alessandro Rubini's GPM server (Linux) + * sysmouse (FreeBSD) + * special-purpose mouse interface for OS/2 EMX. * * Notes for implementors of new mouse-interface methods: * @@ -74,36 +78,81 @@ #endif #include + +MODULE_ID("$Id: lib_mouse.c,v 1.88 2007/09/29 21:50:04 tom Exp $") + #include +#include #if USE_GPM_SUPPORT -#ifndef LINT /* don't need this for llib-lncurses */ -#undef buttons /* term.h defines this, and gpm uses it! */ -#include #include /* defines KG_* macros */ + +#ifdef HAVE_LIBDL +/* use dynamic loader to avoid linkage dependency */ +#include + +#ifdef RTLD_NOW +#define my_RTLD RTLD_NOW +#else +#ifdef RTLD_LAZY +#define my_RTLD RTLD_LAZY +#else +make an error #endif +#endif /* RTLD_NOW */ +#endif /* HAVE_LIBDL */ + +#endif /* USE_GPM_SUPPORT */ + +#if USE_SYSMOUSE +#undef buttons /* symbol conflict in consio.h */ +#undef mouse_info /* symbol conflict in consio.h */ +#include +#if (__FreeBSD_version >= 400017) +#include +#include +#else +#include #endif - -MODULE_ID("$Id: lib_mouse.c,v 1.55 2000/10/10 00:07:28 Ilya.Zakharevich Exp $") +#endif /* use_SYSMOUSE */ #define MY_TRACE TRACE_ICALLS|TRACE_IEVENT -#define INVALID_EVENT -1 +#define MASK_RELEASE(x) NCURSES_MOUSE_MASK(x, 001) +#define MASK_PRESS(x) NCURSES_MOUSE_MASK(x, 002) +#define MASK_CLICK(x) NCURSES_MOUSE_MASK(x, 004) +#define MASK_DOUBLE_CLICK(x) NCURSES_MOUSE_MASK(x, 010) +#define MASK_TRIPLE_CLICK(x) NCURSES_MOUSE_MASK(x, 020) +#define MASK_RESERVED_EVENT(x) NCURSES_MOUSE_MASK(x, 040) + +#if NCURSES_MOUSE_VERSION == 1 +#define BUTTON_CLICKED (BUTTON1_CLICKED | BUTTON2_CLICKED | BUTTON3_CLICKED | BUTTON4_CLICKED) +#define BUTTON_PRESSED (BUTTON1_PRESSED | BUTTON2_PRESSED | BUTTON3_PRESSED | BUTTON4_PRESSED) +#define BUTTON_RELEASED (BUTTON1_RELEASED | BUTTON2_RELEASED | BUTTON3_RELEASED | BUTTON4_RELEASED) +#define BUTTON_DOUBLE_CLICKED (BUTTON1_DOUBLE_CLICKED | BUTTON2_DOUBLE_CLICKED | BUTTON3_DOUBLE_CLICKED | BUTTON4_DOUBLE_CLICKED) +#define BUTTON_TRIPLE_CLICKED (BUTTON1_TRIPLE_CLICKED | BUTTON2_TRIPLE_CLICKED | BUTTON3_TRIPLE_CLICKED | BUTTON4_TRIPLE_CLICKED) +#define MAX_BUTTONS 4 +#else +#define BUTTON_CLICKED (BUTTON1_CLICKED | BUTTON2_CLICKED | BUTTON3_CLICKED | BUTTON4_CLICKED | BUTTON5_CLICKED) +#define BUTTON_PRESSED (BUTTON1_PRESSED | BUTTON2_PRESSED | BUTTON3_PRESSED | BUTTON4_PRESSED | BUTTON5_PRESSED) +#define BUTTON_RELEASED (BUTTON1_RELEASED | BUTTON2_RELEASED | BUTTON3_RELEASED | BUTTON4_RELEASED | BUTTON5_RELEASED) +#define BUTTON_DOUBLE_CLICKED (BUTTON1_DOUBLE_CLICKED | BUTTON2_DOUBLE_CLICKED | BUTTON3_DOUBLE_CLICKED | BUTTON4_DOUBLE_CLICKED | BUTTON5_DOUBLE_CLICKED) +#define BUTTON_TRIPLE_CLICKED (BUTTON1_TRIPLE_CLICKED | BUTTON2_TRIPLE_CLICKED | BUTTON3_TRIPLE_CLICKED | BUTTON4_TRIPLE_CLICKED | BUTTON5_TRIPLE_CLICKED) +#define MAX_BUTTONS 5 +#endif -static int mousetype; -#define M_XTERM -1 /* use xterm's mouse tracking? */ -#define M_NONE 0 /* no mouse device */ -#define M_GPM 1 /* use GPM */ -#define M_QNX 2 /* QNX mouse on console */ -#define M_QNX_TERM 3 /* QNX mouse on pterm/xterm (using qansi-m) */ +#define INVALID_EVENT -1 +#define NORMAL_EVENT 0 #if USE_GPM_SUPPORT -#ifndef LINT -static Gpm_Connect gpm_connect; -#endif + +#ifndef LIBGPM_SONAME +#define LIBGPM_SONAME "libgpm.so" #endif -static mmask_t eventmask; /* current event mask */ +#define GET_DLSYM(name) (my_##name = (TYPE_##name) dlsym(obj, #name)) + +#endif /* USE_GPM_SUPPORT */ static bool _nc_mouse_parse(int); static void _nc_mouse_resume(SCREEN *); @@ -111,14 +160,15 @@ static void _nc_mouse_wrap(SCREEN *); /* maintain a circular list of mouse events */ -/* The definition of the circular list size (EV_MAX), is in curses.priv.h, so - * wgetch() may refer to the size and call _nc_mouse_parse() before circular - * list overflow. - */ -static MEVENT events[EV_MAX]; /* hold the last mouse event seen */ -static MEVENT *eventp = events; /* next free slot in event queue */ -#define NEXT(ep) ((ep == events + EV_MAX - 1) ? events : ep + 1) -#define PREV(ep) ((ep == events) ? events + EV_MAX - 1 : ep - 1) +#undef NEXT +#define NEXT(ep) ((ep == SP->_mouse_events + EV_MAX - 1) \ + ? SP->_mouse_events \ + : ep + 1) + +#undef PREV +#define PREV(ep) ((ep == SP->_mouse_events) \ + ? SP->_mouse_events + EV_MAX - 1 \ + : ep - 1) #ifdef TRACE static void @@ -128,24 +178,18 @@ _trace_slot(const char *tag) _tracef(tag); - for (ep = events; ep < events + EV_MAX; ep++) + for (ep = SP->_mouse_events; ep < SP->_mouse_events + EV_MAX; ep++) _tracef("mouse event queue slot %ld = %s", - (long) (ep - events), + (long) (ep - SP->_mouse_events), _tracemouse(ep)); } #endif -#ifdef USE_EMX_MOUSE +#if USE_EMX_MOUSE # define TOP_ROW 0 # define LEFT_COL 0 -static int mouse_wfd; -static int mouse_thread; -static int mouse_activated; -static char mouse_buttons[] = -{0, 1, 3, 2}; - # define M_FD(sp) sp->_mouse_fd static void @@ -158,7 +202,7 @@ write_event(int down, int button, int x, int y) buf[3] = ' ' + (button - 1) + (down ? 0 : 0x40); buf[4] = ' ' + x - LEFT_COL + 1; buf[5] = ' ' + y - TOP_ROW + 1; - DosWrite(mouse_wfd, buf, 6, &ignore); + DosWrite(SP->_emxmouse_wfd, buf, 6, &ignore); } static void @@ -190,7 +234,7 @@ mouse_server(unsigned long ignored GCC_UNUSED) sprintf(err, "Error reading mouse queue, rc=%lu.\r\n", rc); break; } - if (!mouse_activated) + if (!SP->_emxmouse_activated) goto finish; /* @@ -202,13 +246,13 @@ mouse_server(unsigned long ignored GCC_UNUSED) */ if ((mouev.fs ^ oldstate) & MOUSE_BN1_DOWN) write_event(mouev.fs & MOUSE_BN1_DOWN, - mouse_buttons[1], mouev.col, mouev.row); + SP->_emxmouse_buttons[1], mouev.col, mouev.row); if ((mouev.fs ^ oldstate) & MOUSE_BN2_DOWN) write_event(mouev.fs & MOUSE_BN2_DOWN, - mouse_buttons[3], mouev.col, mouev.row); + SP->_emxmouse_buttons[3], mouev.col, mouev.row); if ((mouev.fs ^ oldstate) & MOUSE_BN3_DOWN) write_event(mouev.fs & MOUSE_BN3_DOWN, - mouse_buttons[2], mouev.col, mouev.row); + SP->_emxmouse_buttons[2], mouev.col, mouev.row); finish: oldstate = mouev.fs; @@ -223,185 +267,455 @@ mouse_server(unsigned long ignored GCC_UNUSED) DosExit(EXIT_THREAD, 0L); } +#endif /* USE_EMX_MOUSE */ + +#if USE_SYSMOUSE +static void +handle_sysmouse(int sig GCC_UNUSED) +{ + struct mouse_info the_mouse; + MEVENT *work; + + the_mouse.operation = MOUSE_GETINFO; + if (SP != 0 + && SP->_mouse_fd >= 0 + && SP->_sysmouse_tail < FIFO_SIZE + && ioctl(SP->_mouse_fd, CONS_MOUSECTL, &the_mouse) != -1) { + + if (SP->_sysmouse_head > SP->_sysmouse_tail) { + SP->_sysmouse_tail = 0; + SP->_sysmouse_head = 0; + } + work = &(SP->_sysmouse_fifo[SP->_sysmouse_tail]); + memset(work, 0, sizeof(*work)); + work->id = NORMAL_EVENT; /* there's only one mouse... */ + + SP->_sysmouse_old_buttons = SP->_sysmouse_new_buttons; + SP->_sysmouse_new_buttons = the_mouse.u.data.buttons & 0x7; + + if (SP->_sysmouse_new_buttons) { + if (SP->_sysmouse_new_buttons & 1) + work->bstate |= BUTTON1_PRESSED; + if (SP->_sysmouse_new_buttons & 2) + work->bstate |= BUTTON2_PRESSED; + if (SP->_sysmouse_new_buttons & 4) + work->bstate |= BUTTON3_PRESSED; + } else { + if (SP->_sysmouse_old_buttons & 1) + work->bstate |= BUTTON1_RELEASED; + if (SP->_sysmouse_old_buttons & 2) + work->bstate |= BUTTON2_RELEASED; + if (SP->_sysmouse_old_buttons & 4) + work->bstate |= BUTTON3_RELEASED; + } + + /* for cosmetic bug in syscons.c on FreeBSD 3.[34] */ + the_mouse.operation = MOUSE_HIDE; + ioctl(SP->_mouse_fd, CONS_MOUSECTL, &the_mouse); + the_mouse.operation = MOUSE_SHOW; + ioctl(SP->_mouse_fd, CONS_MOUSECTL, &the_mouse); + + /* + * We're only interested if the button is pressed or released. + * FIXME: implement continuous event-tracking. + */ + if (SP->_sysmouse_new_buttons != SP->_sysmouse_old_buttons) { + SP->_sysmouse_tail += 1; + } + work->x = the_mouse.u.data.x / SP->_sysmouse_char_width; + work->y = the_mouse.u.data.y / SP->_sysmouse_char_height; + } +} +#endif /* USE_SYSMOUSE */ + static void -server_state(const int state) -{ /* It would be nice to implement pointer-off and stop looping... */ - mouse_activated = state; +init_xterm_mouse(void) +{ + SP->_mouse_type = M_XTERM; + SP->_mouse_xtermcap = tigetstr("XM"); + if (!VALID_STRING(SP->_mouse_xtermcap)) + SP->_mouse_xtermcap = "\033[?1000%?%p1%{1}%=%th%el%;"; } +static void +enable_xterm_mouse(int enable) +{ +#if USE_EMX_MOUSE + SP->_emxmouse_activated = enable; +#else + putp(TPARM_1(SP->_mouse_xtermcap, enable)); #endif + SP->_mouse_active = enable; +} + +#if USE_GPM_SUPPORT +static int +allow_gpm_mouse(void) +{ + /* GPM does printf's without checking if stdout is a terminal */ + if (isatty(fileno(stdout))) { + char *env = getenv("TERM"); + /* GPM checks the beginning of the $TERM variable to decide if + * it should pass xterm events through. There is no real advantage + * in allowing GPM to do this. + */ + if (env == 0 || strncmp(env, "xterm", 5)) + return TRUE; + } + return FALSE; +} + +static bool +enable_gpm_mouse(int enable) +{ + bool result; + + T((T_CALLED("enable_gpm_mouse(%d)"), enable)); + + if (enable && !SP->_mouse_active) { + /* GPM: initialize connection to gpm server */ + SP->_mouse_gpm_connect.eventMask = GPM_DOWN | GPM_UP; + SP->_mouse_gpm_connect.defaultMask = + ~(SP->_mouse_gpm_connect.eventMask | GPM_HARD); + SP->_mouse_gpm_connect.minMod = 0; + SP->_mouse_gpm_connect.maxMod = + (unsigned short) (~((1 << KG_SHIFT) | + (1 << KG_SHIFTL) | + (1 << KG_SHIFTR))); + /* + * Note: GPM hardcodes \E[?1001s and \E[?1000h during its open. + * The former is recognized by wscons (SunOS), and the latter by + * xterm. Those will not show up in ncurses' traces. + */ + result = (my_Gpm_Open(&SP->_mouse_gpm_connect, 0) >= 0); + SP->_mouse_active = result; + T(("GPM open %s", result ? "succeeded" : "failed")); + } else { + if (!enable && SP->_mouse_active) { + /* GPM: close connection to gpm server */ + my_Gpm_Close(); + SP->_mouse_active = FALSE; + T(("GPM closed")); + } + result = FALSE; + } + returnBool(result); +} +#endif /* USE_GPM_SUPPORT */ -static int initialized; +#define xterm_kmous "\033[M" static void initialize_mousetype(void) { - static const char *xterm_kmous = "\033[M"; + T((T_CALLED("initialize_mousetype()"))); /* Try gpm first, because gpm may be configured to run in xterm */ #if USE_GPM_SUPPORT - /* GPM: initialize connection to gpm server */ - gpm_connect.eventMask = GPM_DOWN | GPM_UP; - gpm_connect.defaultMask = ~(gpm_connect.eventMask | GPM_HARD); - gpm_connect.minMod = 0; - gpm_connect.maxMod = ~((1 << KG_SHIFT) | (1 << KG_SHIFTL) | (1 << KG_SHIFTR)); - if (Gpm_Open(&gpm_connect, 0) >= 0) { /* returns the file-descriptor */ - mousetype = M_GPM; - SP->_mouse_fd = gpm_fd; - return; - } + if (allow_gpm_mouse()) { + if (!SP->_mouse_gpm_loaded) { +#ifdef HAVE_LIBDL + void *obj; + + if ((obj = dlopen(LIBGPM_SONAME, my_RTLD)) != 0) { + if (GET_DLSYM(gpm_fd) == 0 || + GET_DLSYM(Gpm_Open) == 0 || + GET_DLSYM(Gpm_Close) == 0 || + GET_DLSYM(Gpm_GetEvent) == 0) { + T(("GPM initialization failed: %s", dlerror())); + dlclose(obj); + } else { + SP->_mouse_gpm_found = TRUE; + } + } +#else /* !HAVE_LIBDL */ + SP->_mouse_gpm_found = TRUE; #endif + SP->_mouse_gpm_loaded = TRUE; + } + + /* + * The gpm_fd file-descriptor may be negative (xterm). So we have to + * maintain our notion of whether the mouse connection is active + * without testing the file-descriptor. + */ + if (SP->_mouse_gpm_found && enable_gpm_mouse(TRUE)) { + SP->_mouse_type = M_GPM; + SP->_mouse_fd = *(my_gpm_fd); + T(("GPM mouse_fd %d", SP->_mouse_fd)); + returnVoid; + } + } +#endif /* USE_GPM_SUPPORT */ /* OS/2 VIO */ -#ifdef USE_EMX_MOUSE - if (!mouse_thread +#if USE_EMX_MOUSE + if (!SP->_emxmouse_thread && strstr(cur_term->type.term_names, "xterm") == 0 && key_mouse) { int handles[2]; if (pipe(handles) < 0) { perror("mouse pipe error"); - return; + returnVoid; } else { int rc; - if (!mouse_buttons[0]) { + if (!SP->_emxmouse_buttons[0]) { char *s = getenv("MOUSE_BUTTONS_123"); - mouse_buttons[0] = 1; + SP->_emxmouse_buttons[0] = 1; if (s && strlen(s) >= 3) { - mouse_buttons[1] = s[0] - '0'; - mouse_buttons[2] = s[1] - '0'; - mouse_buttons[3] = s[2] - '0'; + SP->_emxmouse_buttons[1] = s[0] - '0'; + SP->_emxmouse_buttons[2] = s[1] - '0'; + SP->_emxmouse_buttons[3] = s[2] - '0'; + } else { + SP->_emxmouse_buttons[1] = 1; + SP->_emxmouse_buttons[2] = 3; + SP->_emxmouse_buttons[3] = 2; } } - mouse_wfd = handles[1]; + SP->_emxmouse_wfd = handles[1]; M_FD(SP) = handles[0]; /* Needed? */ setmode(handles[0], O_BINARY); setmode(handles[1], O_BINARY); /* Do not use CRT functions, we may single-threaded. */ - rc = DosCreateThread((unsigned long *) &mouse_thread, + rc = DosCreateThread((unsigned long *) &SP->_emxmouse_thread, mouse_server, 0, 0, 8192); if (rc) { printf("mouse thread error %d=%#x", rc, rc); - return; } else { - mousetype = M_XTERM; - return; + SP->_mouse_type = M_XTERM; } + returnVoid; } } -#endif +#endif /* USE_EMX_MOUSE */ + +#if USE_SYSMOUSE + { + struct mouse_info the_mouse; + char *the_device = 0; + + if (isatty(SP->_ifd)) + the_device = ttyname(SP->_ifd); + if (the_device == 0) + the_device = "/dev/tty"; + + SP->_mouse_fd = open(the_device, O_RDWR); + + if (SP->_mouse_fd >= 0) { + /* + * sysmouse does not have a usable user interface for obtaining + * mouse events. The logical way to proceed (reading data on a + * stream) only works if one opens the device as root. Even in + * that mode, careful examination shows we lose events + * occasionally. The interface provided for user programs is to + * establish a signal handler. really. + * + * Take over SIGUSR2 for this purpose since SIGUSR1 is more + * likely to be used by an application. getch() will have to + * handle the misleading EINTR's. + */ + signal(SIGUSR2, SIG_IGN); + the_mouse.operation = MOUSE_MODE; + the_mouse.u.mode.mode = 0; + the_mouse.u.mode.signal = SIGUSR2; + if (ioctl(SP->_mouse_fd, CONS_MOUSECTL, &the_mouse) != -1) { + signal(SIGUSR2, handle_sysmouse); + the_mouse.operation = MOUSE_SHOW; + ioctl(SP->_mouse_fd, CONS_MOUSECTL, &the_mouse); + +#if defined(FBIO_MODEINFO) || defined(CONS_MODEINFO) /* FreeBSD > 2.x */ + { +#ifndef FBIO_GETMODE /* FreeBSD 3.x */ +#define FBIO_GETMODE CONS_GET +#define FBIO_MODEINFO CONS_MODEINFO +#endif /* FBIO_GETMODE */ + video_info_t the_video; + + if (ioctl(SP->_mouse_fd, + FBIO_GETMODE, + &the_video.vi_mode) != -1 + && ioctl(SP->_mouse_fd, + FBIO_MODEINFO, + &the_video) != -1) { + SP->_sysmouse_char_width = the_video.vi_cwidth; + SP->_sysmouse_char_height = the_video.vi_cheight; + } + } +#endif /* defined(FBIO_MODEINFO) || defined(CONS_MODEINFO) */ + + if (SP->_sysmouse_char_width <= 0) + SP->_sysmouse_char_width = 8; + if (SP->_sysmouse_char_height <= 0) + SP->_sysmouse_char_height = 16; + SP->_mouse_type = M_SYSMOUSE; + returnVoid; + } + } + } +#endif /* USE_SYSMOUSE */ /* we know how to recognize mouse events under "xterm" */ if (key_mouse != 0) { - if (!strcmp(key_mouse, xterm_kmous)) { - mousetype = M_XTERM; - return; + if (!strcmp(key_mouse, xterm_kmous) + || strstr(cur_term->type.term_names, "xterm") != 0) { + init_xterm_mouse(); } } else if (strstr(cur_term->type.term_names, "xterm") != 0) { - (void) _nc_add_to_try(&(SP->_keytry), xterm_kmous, KEY_MOUSE); - mousetype = M_XTERM; - return; + if (_nc_add_to_try(&(SP->_keytry), xterm_kmous, KEY_MOUSE) == OK) + init_xterm_mouse(); } + returnVoid; } -static void +static bool _nc_mouse_init(void) /* initialize the mouse */ { + bool result = FALSE; int i; - if (!initialized) { - initialized = TRUE; + if (SP != 0) { + if (!SP->_mouse_initialized) { + SP->_mouse_initialized = TRUE; - TR(MY_TRACE, ("_nc_mouse_init() called")); + TR(MY_TRACE, ("_nc_mouse_init() called")); - for (i = 0; i < EV_MAX; i++) - events[i].id = INVALID_EVENT; + SP->_mouse_eventp = SP->_mouse_events; + for (i = 0; i < EV_MAX; i++) + SP->_mouse_events[i].id = INVALID_EVENT; - initialize_mousetype(); + initialize_mousetype(); - T(("_nc_mouse_init() set mousetype to %d", mousetype)); + T(("_nc_mouse_init() set mousetype to %d", SP->_mouse_type)); + } + result = SP->_mouse_initialized; } + return result; } +/* + * Query to see if there is a pending mouse event. This is called from + * fifo_push() in lib_getch.c + */ static bool -_nc_mouse_event(SCREEN * sp GCC_UNUSED) -/* query to see if there is a pending mouse event */ +_nc_mouse_event(SCREEN *sp GCC_UNUSED) { -#if USE_GPM_SUPPORT - /* GPM: query server for event, return TRUE if we find one */ - Gpm_Event ev; + MEVENT *eventp = SP->_mouse_eventp; + bool result = FALSE; - if (gpm_fd >= 0 - && (_nc_timed_wait(3, 0, (int *) 0) & 2) != 0 - && Gpm_GetEvent(&ev) == 1) { - eventp->id = 0; /* there's only one mouse... */ + (void) eventp; - eventp->bstate = 0; - switch (ev.type & 0x0f) { - case (GPM_DOWN): - if (ev.buttons & GPM_B_LEFT) - eventp->bstate |= BUTTON1_PRESSED; - if (ev.buttons & GPM_B_MIDDLE) - eventp->bstate |= BUTTON2_PRESSED; - if (ev.buttons & GPM_B_RIGHT) - eventp->bstate |= BUTTON3_PRESSED; - break; - case (GPM_UP): - if (ev.buttons & GPM_B_LEFT) - eventp->bstate |= BUTTON1_RELEASED; - if (ev.buttons & GPM_B_MIDDLE) - eventp->bstate |= BUTTON2_RELEASED; - if (ev.buttons & GPM_B_RIGHT) - eventp->bstate |= BUTTON3_RELEASED; - break; - default: - break; + switch (SP->_mouse_type) { + case M_XTERM: + /* xterm: never have to query, mouse events are in the keyboard stream */ +#if USE_EMX_MOUSE + { + char kbuf[3]; + + int i, res = read(M_FD(sp), &kbuf, 3); /* Eat the prefix */ + if (res != 3) + printf("Got %d chars instead of 3 for prefix.\n", res); + for (i = 0; i < res; i++) { + if (kbuf[i] != key_mouse[i]) + printf("Got char %d instead of %d for prefix.\n", + (int) kbuf[i], (int) key_mouse[i]); + } + result = TRUE; } +#endif /* USE_EMX_MOUSE */ + break; - eventp->x = ev.x - 1; - eventp->y = ev.y - 1; - eventp->z = 0; +#if USE_GPM_SUPPORT + case M_GPM: + { + /* query server for event, return TRUE if we find one */ + Gpm_Event ev; + + if (my_Gpm_GetEvent(&ev) == 1) { + /* there's only one mouse... */ + eventp->id = NORMAL_EVENT; + + eventp->bstate = 0; + switch (ev.type & 0x0f) { + case (GPM_DOWN): + if (ev.buttons & GPM_B_LEFT) + eventp->bstate |= BUTTON1_PRESSED; + if (ev.buttons & GPM_B_MIDDLE) + eventp->bstate |= BUTTON2_PRESSED; + if (ev.buttons & GPM_B_RIGHT) + eventp->bstate |= BUTTON3_PRESSED; + break; + case (GPM_UP): + if (ev.buttons & GPM_B_LEFT) + eventp->bstate |= BUTTON1_RELEASED; + if (ev.buttons & GPM_B_MIDDLE) + eventp->bstate |= BUTTON2_RELEASED; + if (ev.buttons & GPM_B_RIGHT) + eventp->bstate |= BUTTON3_RELEASED; + break; + default: + break; + } - /* bump the next-free pointer into the circular list */ - eventp = NEXT(eventp); - return (TRUE); - } + eventp->x = ev.x - 1; + eventp->y = ev.y - 1; + eventp->z = 0; + + /* bump the next-free pointer into the circular list */ + SP->_mouse_eventp = eventp = NEXT(eventp); + result = TRUE; + } + } + break; #endif -#ifdef USE_EMX_MOUSE - if (SP->_mouse_fd >= 0 - && (_nc_timed_wait(3, 0, (int *) 0) & 2) != 0) { - char kbuf[3]; - - int i, res = read(M_FD(sp), &kbuf, 3); /* Eat the prefix */ - if (res != 3) - printf("Got %d chars instead of 3 for prefix.\n", res); - for (i = 0; i < res; i++) { - if (kbuf[i] != key_mouse[i]) - printf("Got char %d instead of %d for prefix.\n", - (int) kbuf[i], (int) key_mouse[i]); +#if USE_SYSMOUSE + case M_SYSMOUSE: + if (SP->_sysmouse_head < SP->_sysmouse_tail) { + *eventp = SP->_sysmouse_fifo[SP->_sysmouse_head]; + + /* + * Point the fifo-head to the next possible location. If there + * are none, reset the indices. This may be interrupted by the + * signal handler, doing essentially the same reset. + */ + SP->_sysmouse_head += 1; + if (SP->_sysmouse_head == SP->_sysmouse_tail) { + SP->_sysmouse_tail = 0; + SP->_sysmouse_head = 0; + } + + /* bump the next-free pointer into the circular list */ + SP->_mouse_eventp = eventp = NEXT(eventp); + result = TRUE; } - return TRUE; + break; +#endif /* USE_SYSMOUSE */ + + case M_NONE: + break; } -#endif /* USE_EMX_MOUSE */ - /* xterm: never have to query, mouse events are in the keyboard stream */ - return (FALSE); /* no event waiting */ + return result; /* true if we found an event */ } static bool -_nc_mouse_inline(SCREEN * sp) +_nc_mouse_inline(SCREEN *sp) /* mouse report received in the keyboard stream -- parse its info */ { + int b; + bool result = FALSE; + MEVENT *eventp = SP->_mouse_eventp; + TR(MY_TRACE, ("_nc_mouse_inline() called")); - if (mousetype == M_XTERM) { + if (SP->_mouse_type == M_XTERM) { unsigned char kbuf[4]; - MEVENT *prev; + mmask_t prev; size_t grabbed; int res; @@ -432,13 +746,15 @@ _nc_mouse_inline(SCREEN * sp) * (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. It always does under Linux but often - * fails to under Solaris. + * single clist item. + * + * Wheel mice may return buttons 4 and 5 when the wheel is turned. + * We encode those as button presses. */ for (grabbed = 0; grabbed < 3; grabbed += res) { /* For VIO mouse we add extra bit 64 to disambiguate button-up. */ -#ifdef USE_EMX_MOUSE +#if USE_EMX_MOUSE res = read(M_FD(sp) >= 0 ? M_FD(sp) : sp->_ifd, &kbuf, 3); #else res = read(sp->_ifd, kbuf + grabbed, 3 - grabbed); @@ -451,59 +767,71 @@ _nc_mouse_inline(SCREEN * sp) TR(TRACE_IEVENT, ("_nc_mouse_inline sees the following xterm data: '%s'", kbuf)); - eventp->id = 0; /* there's only one mouse... */ + /* there's only one mouse... */ + eventp->id = NORMAL_EVENT; /* processing code goes here */ eventp->bstate = 0; + prev = PREV(eventp)->bstate; + +#if USE_EMX_MOUSE +#define PRESS_POSITION(n) \ + eventp->bstate = MASK_PRESS(n); \ + if (kbuf[0] & 0x40) \ + eventp->bstate = MASK_RELEASE(n) +#else +#define PRESS_POSITION(n) \ + eventp->bstate = (prev & MASK_PRESS(n) \ + ? REPORT_MOUSE_POSITION \ + : MASK_PRESS(n)) +#endif + switch (kbuf[0] & 0x3) { case 0x0: - eventp->bstate = BUTTON1_PRESSED; -#ifdef USE_EMX_MOUSE - if (kbuf[0] & 0x40) - eventp->bstate = BUTTON1_RELEASED; -#endif + if (kbuf[0] & 64) + eventp->bstate = MASK_PRESS(4); + else + PRESS_POSITION(1); break; case 0x1: - eventp->bstate = BUTTON2_PRESSED; -#ifdef USE_EMX_MOUSE - if (kbuf[0] & 0x40) - eventp->bstate = BUTTON2_RELEASED; +#if NCURSES_MOUSE_VERSION == 2 + if (kbuf[0] & 64) + eventp->bstate = MASK_PRESS(5); + else #endif + PRESS_POSITION(2); break; case 0x2: - eventp->bstate = BUTTON3_PRESSED; -#ifdef USE_EMX_MOUSE - if (kbuf[0] & 0x40) - eventp->bstate = BUTTON3_RELEASED; -#endif + PRESS_POSITION(3); break; case 0x3: /* - * Release events aren't reported for individual buttons, - * just for the button set as a whole... + * 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. */ - eventp->bstate = - (BUTTON1_RELEASED | - BUTTON2_RELEASED | - BUTTON3_RELEASED); - /* - * ...however, because there are no kinds of mouse events under - * xterm that can intervene between press and release, we can - * deduce which buttons were actually released by looking at the - * previous event. - */ - prev = PREV(eventp); - if (!(prev->bstate & BUTTON1_PRESSED)) - eventp->bstate &= ~BUTTON1_RELEASED; - if (!(prev->bstate & BUTTON2_PRESSED)) - eventp->bstate &= ~BUTTON2_RELEASED; - if (!(prev->bstate & BUTTON3_PRESSED)) - eventp->bstate &= ~BUTTON3_RELEASED; + if (prev & (BUTTON_PRESSED | BUTTON_RELEASED)) { + eventp->bstate = BUTTON_RELEASED; + for (b = 1; b <= MAX_BUTTONS; ++b) { + if (!(prev & MASK_PRESS(b))) + eventp->bstate &= ~MASK_RELEASE(b); + } + } 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; if (kbuf[0] & 4) { eventp->bstate |= BUTTON_SHIFT; @@ -520,45 +848,53 @@ _nc_mouse_inline(SCREEN * sp) TR(MY_TRACE, ("_nc_mouse_inline: primitive mouse-event %s has slot %ld", _tracemouse(eventp), - (long) (eventp - events))); + (long) (eventp - SP->_mouse_events))); /* bump the next-free pointer into the circular list */ - eventp = NEXT(eventp); + SP->_mouse_eventp = NEXT(eventp); #if 0 /* this return would be needed for QNX's mods to lib_getch.c */ return (TRUE); #endif } - return (FALSE); + return (result); } static void mouse_activate(bool on) { - if (!on && !initialized) + if (!on && !SP->_mouse_initialized) return; - _nc_mouse_init(); + if (!_nc_mouse_init()) + return; if (on) { - switch (mousetype) { + switch (SP->_mouse_type) { case M_XTERM: #if NCURSES_EXT_FUNCS keyok(KEY_MOUSE, on); #endif TPUTS_TRACE("xterm mouse initialization"); -#ifdef USE_EMX_MOUSE - server_state(1); -#else - putp("\033[?1000h"); -#endif + enable_xterm_mouse(1); break; #if USE_GPM_SUPPORT case M_GPM: - SP->_mouse_fd = gpm_fd; + if (enable_gpm_mouse(1)) { + SP->_mouse_fd = *(my_gpm_fd); + T(("GPM mouse_fd %d", SP->_mouse_fd)); + } + break; +#endif +#if USE_SYSMOUSE + case M_SYSMOUSE: + signal(SIGUSR2, handle_sysmouse); + SP->_mouse_active = TRUE; break; #endif + case M_NONE: + return; } /* Make runtime binding to cut down on object size of applications that * do not use the mouse (e.g., 'clear'). @@ -568,22 +904,26 @@ mouse_activate(bool on) SP->_mouse_parse = _nc_mouse_parse; SP->_mouse_resume = _nc_mouse_resume; SP->_mouse_wrap = _nc_mouse_wrap; - } else { - switch (mousetype) { + switch (SP->_mouse_type) { case M_XTERM: TPUTS_TRACE("xterm mouse deinitialization"); -#ifdef USE_EMX_MOUSE - server_state(0); -#else - putp("\033[?1000l"); -#endif + enable_xterm_mouse(0); break; #if USE_GPM_SUPPORT case M_GPM: + enable_gpm_mouse(0); + break; +#endif +#if USE_SYSMOUSE + case M_SYSMOUSE: + signal(SIGUSR2, SIG_IGN); + SP->_mouse_active = FALSE; break; #endif + case M_NONE: + return; } } _nc_flush(); @@ -599,8 +939,10 @@ static bool _nc_mouse_parse(int runcount) /* parse a run of atomic mouse events into a gesture */ { + MEVENT *eventp = SP->_mouse_eventp; MEVENT *ep, *runp, *next, *prev = PREV(eventp); int n; + int b; bool merge; TR(MY_TRACE, ("_nc_mouse_parse(%d) called", runcount)); @@ -609,7 +951,7 @@ _nc_mouse_parse(int runcount) * When we enter this routine, the event list next-free pointer * points just past a run of mouse events that we know were separated * in time by less than the critical click interval. The job of this - * routine is to collaps this run into a single higher-level event + * routine is to collapse this run into a single higher-level event * or gesture. * * We accomplish this in two passes. The first pass merges press/release @@ -630,9 +972,9 @@ _nc_mouse_parse(int runcount) TR(MY_TRACE, ("_nc_mouse_parse: returning simple mouse event %s at slot %ld", _tracemouse(prev), - (long) (prev - events))); - return (prev->id >= 0) - ? ((prev->bstate & eventmask) ? TRUE : FALSE) + (long) (prev - SP->_mouse_events))); + return (prev->id >= NORMAL_EVENT) + ? ((prev->bstate & SP->_mouse_mask) ? TRUE : FALSE) : FALSE; } @@ -643,45 +985,41 @@ _nc_mouse_parse(int runcount) } #ifdef TRACE - if (_nc_tracing & TRACE_IEVENT) { + if (USE_TRACEF(TRACE_IEVENT)) { _trace_slot("before mouse press/release merge:"); _tracef("_nc_mouse_parse: run starts at %ld, ends at %ld, count %d", - (long) (runp - events), - (long) ((eventp - events) + (EV_MAX - 1)) % EV_MAX, + (long) (runp - SP->_mouse_events), + (long) ((eventp - SP->_mouse_events) + (EV_MAX - 1)) % EV_MAX, runcount); + _nc_unlock_global(tracef); } #endif /* TRACE */ /* first pass; merge press/release pairs */ do { merge = FALSE; - for (ep = runp; next = NEXT(ep), next != eventp; ep = next) { + for (ep = runp; (next = NEXT(ep)) != eventp; ep = next) { + +#define MASK_CHANGED(x) (!(ep->bstate & MASK_PRESS(x)) \ + == !(next->bstate & MASK_RELEASE(x))) + if (ep->x == next->x && ep->y == next->y - && (ep->bstate & (BUTTON1_PRESSED | BUTTON2_PRESSED | BUTTON3_PRESSED)) - && (!(ep->bstate & BUTTON1_PRESSED) - == !(next->bstate & BUTTON1_RELEASED)) - && (!(ep->bstate & BUTTON2_PRESSED) - == !(next->bstate & BUTTON2_RELEASED)) - && (!(ep->bstate & BUTTON3_PRESSED) - == !(next->bstate & BUTTON3_RELEASED)) + && (ep->bstate & BUTTON_PRESSED) + && MASK_CHANGED(1) + && MASK_CHANGED(2) + && MASK_CHANGED(3) + && MASK_CHANGED(4) +#if NCURSES_MOUSE_VERSION == 2 + && MASK_CHANGED(5) +#endif ) { - if ((eventmask & BUTTON1_CLICKED) - && (ep->bstate & BUTTON1_PRESSED)) { - ep->bstate &= ~BUTTON1_PRESSED; - ep->bstate |= BUTTON1_CLICKED; - merge = TRUE; - } - if ((eventmask & BUTTON2_CLICKED) - && (ep->bstate & BUTTON2_PRESSED)) { - ep->bstate &= ~BUTTON2_PRESSED; - ep->bstate |= BUTTON2_CLICKED; - merge = TRUE; - } - if ((eventmask & BUTTON3_CLICKED) - && (ep->bstate & BUTTON3_PRESSED)) { - ep->bstate &= ~BUTTON3_PRESSED; - ep->bstate |= BUTTON3_CLICKED; - merge = TRUE; + for (b = 1; b <= MAX_BUTTONS; ++b) { + if ((SP->_mouse_mask & MASK_CLICK(b)) + && (ep->bstate & MASK_PRESS(b))) { + ep->bstate &= ~MASK_PRESS(b); + ep->bstate |= MASK_CLICK(b); + merge = TRUE; + } } if (merge) next->id = INVALID_EVENT; @@ -691,12 +1029,13 @@ _nc_mouse_parse(int runcount) (merge); #ifdef TRACE - if (_nc_tracing & TRACE_IEVENT) { + if (USE_TRACEF(TRACE_IEVENT)) { _trace_slot("before mouse click merge:"); _tracef("_nc_mouse_parse: run starts at %ld, ends at %ld, count %d", - (long) (runp - events), - (long) ((eventp - events) + (EV_MAX - 1)) % EV_MAX, + (long) (runp - SP->_mouse_events), + (long) ((eventp - SP->_mouse_events) + (EV_MAX - 1)) % EV_MAX, runcount); + _nc_unlock_global(tracef); } #endif /* TRACE */ @@ -720,7 +1059,7 @@ _nc_mouse_parse(int runcount) MEVENT *follower; merge = FALSE; - for (ep = runp; next = NEXT(ep), next != eventp; ep = next) + for (ep = runp; (next = NEXT(ep)) != eventp; ep = next) if (ep->id != INVALID_EVENT) { if (next->id != INVALID_EVENT) continue; @@ -729,56 +1068,30 @@ _nc_mouse_parse(int runcount) continue; /* merge click events forward */ - if ((ep->bstate & - (BUTTON1_CLICKED | BUTTON2_CLICKED | BUTTON3_CLICKED)) - && (follower->bstate & - (BUTTON1_CLICKED | BUTTON2_CLICKED | BUTTON3_CLICKED))) { - if ((eventmask & BUTTON1_DOUBLE_CLICKED) - && (follower->bstate & BUTTON1_CLICKED)) { - follower->bstate &= ~BUTTON1_CLICKED; - follower->bstate |= BUTTON1_DOUBLE_CLICKED; - merge = TRUE; - } - if ((eventmask & BUTTON2_DOUBLE_CLICKED) - && (follower->bstate & BUTTON2_CLICKED)) { - follower->bstate &= ~BUTTON2_CLICKED; - follower->bstate |= BUTTON2_DOUBLE_CLICKED; - merge = TRUE; - } - if ((eventmask & BUTTON3_DOUBLE_CLICKED) - && (follower->bstate & BUTTON3_CLICKED)) { - follower->bstate &= ~BUTTON3_CLICKED; - follower->bstate |= BUTTON3_DOUBLE_CLICKED; - merge = TRUE; + if ((ep->bstate & BUTTON_CLICKED) + && (follower->bstate & BUTTON_CLICKED)) { + for (b = 1; b <= MAX_BUTTONS; ++b) { + if ((SP->_mouse_mask & MASK_DOUBLE_CLICK(b)) + && (follower->bstate & MASK_CLICK(b))) { + follower->bstate &= ~MASK_CLICK(b); + follower->bstate |= MASK_DOUBLE_CLICK(b); + merge = TRUE; + } } if (merge) ep->id = INVALID_EVENT; } /* merge double-click events forward */ - if ((ep->bstate & - (BUTTON1_DOUBLE_CLICKED - | BUTTON2_DOUBLE_CLICKED - | BUTTON3_DOUBLE_CLICKED)) - && (follower->bstate & - (BUTTON1_CLICKED | BUTTON2_CLICKED | BUTTON3_CLICKED))) { - if ((eventmask & BUTTON1_TRIPLE_CLICKED) - && (follower->bstate & BUTTON1_CLICKED)) { - follower->bstate &= ~BUTTON1_CLICKED; - follower->bstate |= BUTTON1_TRIPLE_CLICKED; - merge = TRUE; - } - if ((eventmask & BUTTON2_TRIPLE_CLICKED) - && (follower->bstate & BUTTON2_CLICKED)) { - follower->bstate &= ~BUTTON2_CLICKED; - follower->bstate |= BUTTON2_TRIPLE_CLICKED; - merge = TRUE; - } - if ((eventmask & BUTTON3_TRIPLE_CLICKED) - && (follower->bstate & BUTTON3_CLICKED)) { - follower->bstate &= ~BUTTON3_CLICKED; - follower->bstate |= BUTTON3_TRIPLE_CLICKED; - merge = TRUE; + if ((ep->bstate & BUTTON_DOUBLE_CLICKED) + && (follower->bstate & BUTTON_CLICKED)) { + for (b = 1; b <= MAX_BUTTONS; ++b) { + if ((SP->_mouse_mask & MASK_TRIPLE_CLICK(b)) + && (follower->bstate & MASK_CLICK(b))) { + follower->bstate &= ~MASK_CLICK(b); + follower->bstate |= MASK_TRIPLE_CLICK(b); + merge = TRUE; + } } if (merge) ep->id = INVALID_EVENT; @@ -788,12 +1101,13 @@ _nc_mouse_parse(int runcount) (merge); #ifdef TRACE - if (_nc_tracing & TRACE_IEVENT) { + if (USE_TRACEF(TRACE_IEVENT)) { _trace_slot("before mouse event queue compaction:"); _tracef("_nc_mouse_parse: run starts at %ld, ends at %ld, count %d", - (long) (runp - events), - (long) ((eventp - events) + (EV_MAX - 1)) % EV_MAX, + (long) (runp - SP->_mouse_events), + (long) ((eventp - SP->_mouse_events) + (EV_MAX - 1)) % EV_MAX, runcount); + _nc_unlock_global(tracef); } #endif /* TRACE */ @@ -802,23 +1116,24 @@ _nc_mouse_parse(int runcount) * don't match the current event mask. */ for (; runcount; prev = PREV(eventp), runcount--) - if (prev->id == INVALID_EVENT || !(prev->bstate & eventmask)) { - eventp = prev; + if (prev->id == INVALID_EVENT || !(prev->bstate & SP->_mouse_mask)) { + SP->_mouse_eventp = eventp = prev; } #ifdef TRACE - if (_nc_tracing & TRACE_IEVENT) { + if (USE_TRACEF(TRACE_IEVENT)) { _trace_slot("after mouse event queue compaction:"); _tracef("_nc_mouse_parse: run starts at %ld, ends at %ld, count %d", - (long) (runp - events), - (long) ((eventp - events) + (EV_MAX - 1)) % EV_MAX, + (long) (runp - SP->_mouse_events), + (long) ((eventp - SP->_mouse_events) + (EV_MAX - 1)) % EV_MAX, runcount); + _nc_unlock_global(tracef); } for (ep = runp; ep != eventp; ep = NEXT(ep)) if (ep->id != INVALID_EVENT) TR(MY_TRACE, ("_nc_mouse_parse: returning composite mouse event %s at slot %ld", _tracemouse(ep), - (long) (ep - events))); + (long) (ep - SP->_mouse_events))); #endif /* TRACE */ /* after all this, do we have a valid event? */ @@ -826,35 +1141,62 @@ _nc_mouse_parse(int runcount) } static void -_nc_mouse_wrap(SCREEN * sp GCC_UNUSED) +_nc_mouse_wrap(SCREEN *sp GCC_UNUSED) /* release mouse -- called by endwin() before shellout/exit */ { TR(MY_TRACE, ("_nc_mouse_wrap() called")); - switch (mousetype) { + switch (SP->_mouse_type) { case M_XTERM: - if (eventmask) + if (SP->_mouse_mask) mouse_activate(FALSE); break; #if USE_GPM_SUPPORT /* GPM: pass all mouse events to next client */ case M_GPM: + if (SP->_mouse_mask) + mouse_activate(FALSE); + break; +#endif +#if USE_SYSMOUSE + case M_SYSMOUSE: + mouse_activate(FALSE); break; #endif + case M_NONE: + break; } } static void -_nc_mouse_resume(SCREEN * sp GCC_UNUSED) +_nc_mouse_resume(SCREEN *sp GCC_UNUSED) /* re-connect to mouse -- called by doupdate() after shellout */ { TR(MY_TRACE, ("_nc_mouse_resume() called")); - /* xterm: re-enable reporting */ - if (mousetype == M_XTERM && eventmask) - mouse_activate(TRUE); + switch (SP->_mouse_type) { + case M_XTERM: + /* xterm: re-enable reporting */ + if (SP->_mouse_mask) + mouse_activate(TRUE); + break; - /* GPM: reclaim our event set */ +#if USE_GPM_SUPPORT + case M_GPM: + /* GPM: reclaim our event set */ + if (SP->_mouse_mask) + mouse_activate(TRUE); + break; +#endif + +#if USE_SYSMOUSE + case M_SYSMOUSE: + mouse_activate(TRUE); + break; +#endif + case M_NONE: + break; + } } /************************************************************************** @@ -863,13 +1205,14 @@ _nc_mouse_resume(SCREEN * sp GCC_UNUSED) * **************************************************************************/ -int +NCURSES_EXPORT(int) getmouse(MEVENT * aevent) /* grab a copy of the current mouse event */ { T((T_CALLED("getmouse(%p)"), aevent)); - if (aevent && (mousetype != M_NONE)) { + if ((aevent != 0) && (SP != 0) && (SP->_mouse_type != M_NONE)) { + MEVENT *eventp = SP->_mouse_eventp; /* compute the current-event pointer */ MEVENT *prev = PREV(eventp); @@ -878,7 +1221,7 @@ getmouse(MEVENT * aevent) TR(TRACE_IEVENT, ("getmouse: returning event %s from slot %ld", _tracemouse(prev), - (long) (prev - events))); + (long) (prev - SP->_mouse_events))); prev->id = INVALID_EVENT; /* so the queue slot becomes free */ returnCode(OK); @@ -886,73 +1229,93 @@ getmouse(MEVENT * aevent) returnCode(ERR); } -int +NCURSES_EXPORT(int) ungetmouse(MEVENT * aevent) /* enqueue a synthesized mouse event to be seen by the next wgetch() */ { - /* stick the given event in the next-free slot */ - *eventp = *aevent; + int result = ERR; + + T((T_CALLED("ungetmouse(%p)"), aevent)); - /* bump the next-free pointer into the circular list */ - eventp = NEXT(eventp); + if (aevent != 0 && SP != 0) { + MEVENT *eventp = SP->_mouse_eventp; - /* push back the notification event on the keyboard queue */ - return ungetch(KEY_MOUSE); + /* stick the given event in the next-free slot */ + *eventp = *aevent; + + /* bump the next-free pointer into the circular list */ + SP->_mouse_eventp = NEXT(eventp); + + /* push back the notification event on the keyboard queue */ + result = ungetch(KEY_MOUSE); + } + returnCode(result); } -mmask_t +NCURSES_EXPORT(mmask_t) mousemask(mmask_t newmask, mmask_t * oldmask) /* set the mouse event mask */ { mmask_t result = 0; - T((T_CALLED("mousemask(%#lx,%p)"), newmask, oldmask)); + T((T_CALLED("mousemask(%#lx,%p)"), (unsigned long) newmask, oldmask)); - if (oldmask) - *oldmask = eventmask; - - if (!newmask && !initialized) - returnCode(0); - - _nc_mouse_init(); - if (mousetype != M_NONE) { - eventmask = newmask & - (BUTTON_ALT | BUTTON_CTRL | BUTTON_SHIFT - | BUTTON1_PRESSED | BUTTON1_RELEASED | BUTTON1_CLICKED - | BUTTON1_DOUBLE_CLICKED | BUTTON1_TRIPLE_CLICKED - | BUTTON2_PRESSED | BUTTON2_RELEASED | BUTTON2_CLICKED - | BUTTON2_DOUBLE_CLICKED | BUTTON2_TRIPLE_CLICKED - | BUTTON3_PRESSED | BUTTON3_RELEASED | BUTTON3_CLICKED - | BUTTON3_DOUBLE_CLICKED | BUTTON3_TRIPLE_CLICKED); - - mouse_activate(eventmask != 0); - - result = eventmask; + if (SP != 0) { + if (oldmask) + *oldmask = SP->_mouse_mask; + + if (newmask || SP->_mouse_initialized) { + _nc_mouse_init(); + if (SP->_mouse_type != M_NONE) { + result = newmask & + (REPORT_MOUSE_POSITION + | BUTTON_ALT + | BUTTON_CTRL + | BUTTON_SHIFT + | BUTTON_PRESSED + | BUTTON_RELEASED + | BUTTON_CLICKED + | BUTTON_DOUBLE_CLICKED + | BUTTON_TRIPLE_CLICKED); + + mouse_activate((bool) (result != 0)); + + SP->_mouse_mask = result; + } + } + } else { + if (oldmask) + *oldmask = SP->_mouse_mask; } - - returnCode(result); + returnBits(result); } -bool +NCURSES_EXPORT(bool) wenclose(const WINDOW *win, int y, int x) /* check to see if given window encloses given screen location */ { - if (win) { + bool result = FALSE; + + T((T_CALLED("wenclose(%p,%d,%d)"), win, y, x)); + + if (win != 0) { y -= win->_yoffset; - return ((win->_begy <= y && - win->_begx <= x && - (win->_begx + win->_maxx) >= x && - (win->_begy + win->_maxy) >= y) ? TRUE : FALSE); + result = ((win->_begy <= y && + win->_begx <= x && + (win->_begx + win->_maxx) >= x && + (win->_begy + win->_maxy) >= y) ? TRUE : FALSE); } - return FALSE; + returnBool(result); } -int +NCURSES_EXPORT(int) mouseinterval(int maxclick) /* set the maximum mouse interval within which to recognize a click */ { int oldval; + T((T_CALLED("mouseinterval(%d)"), maxclick)); + if (SP != 0) { oldval = SP->_maxclick; if (maxclick >= 0) @@ -961,22 +1324,24 @@ mouseinterval(int maxclick) oldval = DEFAULT_MAXCLICK; } - return (oldval); + returnCode(oldval); } /* This may be used by other routines to ask for the existence of mouse support */ -int +NCURSES_EXPORT(int) _nc_has_mouse(void) { - return (mousetype == M_NONE ? 0 : 1); + return (SP->_mouse_type == M_NONE ? 0 : 1); } -bool +NCURSES_EXPORT(bool) wmouse_trafo(const WINDOW *win, int *pY, int *pX, bool to_screen) { bool result = FALSE; + T((T_CALLED("wmouse_trafo(%p,%p,%p,%d)"), win, pY, pX, to_screen)); + if (win && pY && pX) { int y = *pY; int x = *pX; @@ -998,7 +1363,5 @@ wmouse_trafo(const WINDOW *win, int *pY, int *pX, bool to_screen) *pY = y; } } - return (result); + returnBool(result); } - -/* lib_mouse.c ends here */