ncurses/base/lib_mouse.c

   1 /****************************************************************************
   2  * Copyright (c) 1998-2000,2002 Free Software Foundation, Inc.              *
   3  *                                                                          *
   4  * Permission is hereby granted, free of charge, to any person obtaining a  *
   5  * copy of this software and associated documentation files (the            *
   6  * "Software"), to deal in the Software without restriction, including      *
   7  * without limitation the rights to use, copy, modify, merge, publish,      *
   8  * distribute, distribute with modifications, sublicense, and/or sell       *
   9  * copies of the Software, and to permit persons to whom the Software is    *
  10  * furnished to do so, subject to the following conditions:                 *
  11  *                                                                          *
  12  * The above copyright notice and this permission notice shall be included  *
  13  * in all copies or substantial portions of the Software.                   *
  14  *                                                                          *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
  16  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
  17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
  18  * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
  19  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
  20  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
  21  * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
  22  *                                                                          *
  23  * Except as contained in this notice, the name(s) of the above copyright   *
  24  * holders shall not be used in advertising or otherwise to promote the     *
  25  * sale, use or other dealings in this Software without prior written       *
  26  * authorization.                                                           *
  27  ****************************************************************************/
  28
  29 /****************************************************************************
  30  *  Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995               *
  31  *     and: Eric S. Raymond <esr@snark.thyrsus.com>                         *
  32  ****************************************************************************/
  33
  34 /*
  35  * This module is intended to encapsulate ncurses's interface to pointing
  36  * devices.
  37  *
  38  * The first method used is xterm's internal mouse-tracking facility.
  39  * The second is Alessandro Rubini's GPM server.
  40  *
  41  * Notes for implementors of new mouse-interface methods:
  42  *
  43  * The code is logically split into a lower level that accepts event reports
  44  * in a device-dependent format and an upper level that parses mouse gestures
  45  * and filters events.  The mediating data structure is a circular queue of
  46  * MEVENT structures.
  47  *
  48  * Functionally, the lower level's job is to pick up primitive events and
  49  * put them on the circular queue.  This can happen in one of two ways:
  50  * either (a) _nc_mouse_event() detects a series of incoming mouse reports
  51  * and queues them, or (b) code in lib_getch.c detects the kmous prefix in
  52  * the keyboard input stream and calls _nc_mouse_inline to queue up a series
  53  * of adjacent mouse reports.
  54  *
  55  * In either case, _nc_mouse_parse() should be called after the series is
  56  * accepted to parse the digested mouse reports (low-level MEVENTs) into
  57  * a gesture (a high-level or composite MEVENT).
  58  *
  59  * Don't be too shy about adding new event types or modifiers, if you can find
  60  * room for them in the 32-bit mask.  The API is written so that users get
  61  * feedback on which theoretical event types they won't see when they call
  62  * mousemask. There's one bit per button (the RESERVED_EVENT bit) not being
  63  * used yet, and a couple of bits open at the high end.
  64  */
  65
  66 #ifdef __EMX__
  67 #  include <io.h>
  68 #  define  INCL_DOS
  69 #  define  INCL_VIO
  70 #  define  INCL_KBD
  71 #  define  INCL_MOU
  72 #  define  INCL_DOSPROCESS
  73 #  include <os2.h>              /* Need to include before the others */
  74 #endif
  75
  76 #include <curses.priv.h>
  77 #include <term.h>
  78
  79 #if USE_GPM_SUPPORT
  80 #ifndef LINT                    /* don't need this for llib-lncurses */
  81 #undef buttons                  /* term.h defines this, and gpm uses it! */
  82 #include <gpm.h>
  83 #include <linux/keyboard.h>     /* defines KG_* macros */
  84 #endif
  85 #endif
  86
  87 MODULE_ID("$Id: lib_mouse.c,v 1.61 2002/09/28 16:08:58 tom Exp $")
  88
  89 #define MY_TRACE TRACE_ICALLS|TRACE_IEVENT
  90
  91 #define INVALID_EVENT   -1
  92
  93 static int mousetype;
  94 #define M_XTERM         -1      /* use xterm's mouse tracking? */
  95 #define M_NONE          0       /* no mouse device */
  96 #define M_GPM           1       /* use GPM */
  97 #define M_QNX           2       /* QNX mouse on console */
  98 #define M_QNX_TERM      3       /* QNX mouse on pterm/xterm (using qansi-m) */
  99
 100 #if USE_GPM_SUPPORT
 101 #ifndef LINT
 102 static Gpm_Connect gpm_connect;
 103 #endif
 104 #endif
 105
 106 static mmask_t eventmask;       /* current event mask */
 107
 108 static bool _nc_mouse_parse(int);
 109 static void _nc_mouse_resume(SCREEN *);
 110 static void _nc_mouse_wrap(SCREEN *);
 111
 112 /* maintain a circular list of mouse events */
 113
 114 /* The definition of the circular list size (EV_MAX), is in curses.priv.h, so
 115  * wgetch() may refer to the size and call _nc_mouse_parse() before circular
 116  * list overflow.
 117  */
 118 static MEVENT events[EV_MAX];   /* hold the last mouse event seen */
 119 static MEVENT *eventp = events; /* next free slot in event queue */
 120 #define NEXT(ep)        ((ep == events + EV_MAX - 1) ? events : ep + 1)
 121 #define PREV(ep)        ((ep == events) ? events + EV_MAX - 1 : ep - 1)
 122
 123 #ifdef TRACE
 124 static void
 125 _trace_slot(const char *tag)
 126 {
 127     MEVENT *ep;
 128
 129     _tracef(tag);
 130
 131     for (ep = events; ep < events + EV_MAX; ep++)
 132         _tracef("mouse event queue slot %ld = %s",
 133                 (long) (ep - events),
 134                 _tracemouse(ep));
 135 }
 136 #endif
 137
 138 #ifdef USE_EMX_MOUSE
 139
 140 #  define TOP_ROW          0
 141 #  define LEFT_COL         0
 142
 143 static int mouse_wfd;
 144 static int mouse_thread;
 145 static int mouse_activated;
 146 static char mouse_buttons[] =
 147 {0, 1, 3, 2};
 148
 149 #  define M_FD(sp) sp->_mouse_fd
 150
 151 static void
 152 write_event(int down, int button, int x, int y)
 153 {
 154     char buf[6];
 155     unsigned long ignore;
 156
 157     strncpy(buf, key_mouse, 3); /* should be "\033[M" */
 158     buf[3] = ' ' + (button - 1) + (down ? 0 : 0x40);
 159     buf[4] = ' ' + x - LEFT_COL + 1;
 160     buf[5] = ' ' + y - TOP_ROW + 1;
 161     DosWrite(mouse_wfd, buf, 6, &ignore);
 162 }
 163
 164 static void
 165 mouse_server(unsigned long ignored GCC_UNUSED)
 166 {
 167     unsigned short fWait = MOU_WAIT;
 168     /* NOPTRRECT mourt = { 0,0,24,79 }; */
 169     MOUEVENTINFO mouev;
 170     HMOU hmou;
 171     unsigned short mask = MOUSE_BN1_DOWN | MOUSE_BN2_DOWN | MOUSE_BN3_DOWN;
 172     int nbuttons = 3;
 173     int oldstate = 0;
 174     char err[80];
 175     unsigned long rc;
 176
 177     /* open the handle for the mouse */
 178     if (MouOpen(NULL, &hmou) == 0) {
 179         rc = MouSetEventMask(&mask, hmou);
 180         if (rc) {               /* retry with 2 buttons */
 181             mask = MOUSE_BN1_DOWN | MOUSE_BN2_DOWN;
 182             rc = MouSetEventMask(&mask, hmou);
 183             nbuttons = 2;
 184         }
 185         if (rc == 0 && MouDrawPtr(hmou) == 0) {
 186             for (;;) {
 187                 /* sit and wait on the event queue */
 188                 rc = MouReadEventQue(&mouev, &fWait, hmou);
 189                 if (rc) {
 190                     sprintf(err, "Error reading mouse queue, rc=%lu.\r\n", rc);
 191                     break;
 192                 }
 193                 if (!mouse_activated)
 194                     goto finish;
 195
 196                 /*
 197                  * OS/2 numbers a 3-button mouse inconsistently from other
 198                  * platforms:
 199                  *      1 = left
 200                  *      2 = right
 201                  *      3 = middle.
 202                  */
 203                 if ((mouev.fs ^ oldstate) & MOUSE_BN1_DOWN)
 204                     write_event(mouev.fs & MOUSE_BN1_DOWN,
 205                                 mouse_buttons[1], mouev.col, mouev.row);
 206                 if ((mouev.fs ^ oldstate) & MOUSE_BN2_DOWN)
 207                     write_event(mouev.fs & MOUSE_BN2_DOWN,
 208                                 mouse_buttons[3], mouev.col, mouev.row);
 209                 if ((mouev.fs ^ oldstate) & MOUSE_BN3_DOWN)
 210                     write_event(mouev.fs & MOUSE_BN3_DOWN,
 211                                 mouse_buttons[2], mouev.col, mouev.row);
 212
 213               finish:
 214                 oldstate = mouev.fs;
 215             }
 216         } else
 217             sprintf(err, "Error setting event mask, buttons=%d, rc=%lu.\r\n",
 218                     nbuttons, rc);
 219
 220         DosWrite(2, err, strlen(err), &rc);
 221         MouClose(hmou);
 222     }
 223     DosExit(EXIT_THREAD, 0L);
 224 }
 225
 226 static void
 227 server_state(const int state)
 228 {                               /* It would be nice to implement pointer-off and stop looping... */
 229     mouse_activated = state;
 230 }
 231
 232 #endif
 233
 234 static int initialized;
 235
 236 static void
 237 initialize_mousetype(void)
 238 {
 239     static const char *xterm_kmous = "\033[M";
 240
 241     /* Try gpm first, because gpm may be configured to run in xterm */
 242 #if USE_GPM_SUPPORT
 243     /* GPM: initialize connection to gpm server */
 244     gpm_connect.eventMask = GPM_DOWN | GPM_UP;
 245     gpm_connect.defaultMask = ~(gpm_connect.eventMask | GPM_HARD);
 246     gpm_connect.minMod = 0;
 247     gpm_connect.maxMod = ~((1 << KG_SHIFT) | (1 << KG_SHIFTL) | (1 << KG_SHIFTR));
 248     if (Gpm_Open(&gpm_connect, 0) >= 0) {       /* returns the file-descriptor */
 249         mousetype = M_GPM;
 250         SP->_mouse_fd = gpm_fd;
 251         return;
 252     }
 253 #endif
 254
 255     /* OS/2 VIO */
 256 #ifdef USE_EMX_MOUSE
 257     if (!mouse_thread
 258         && strstr(cur_term->type.term_names, "xterm") == 0
 259         && key_mouse) {
 260         int handles[2];
 261
 262         if (pipe(handles) < 0) {
 263             perror("mouse pipe error");
 264             return;
 265         } else {
 266             int rc;
 267
 268             if (!mouse_buttons[0]) {
 269                 char *s = getenv("MOUSE_BUTTONS_123");
 270
 271                 mouse_buttons[0] = 1;
 272                 if (s && strlen(s) >= 3) {
 273                     mouse_buttons[1] = s[0] - '0';
 274                     mouse_buttons[2] = s[1] - '0';
 275                     mouse_buttons[3] = s[2] - '0';
 276                 }
 277             }
 278             mouse_wfd = handles[1];
 279             M_FD(SP) = handles[0];
 280             /* Needed? */
 281             setmode(handles[0], O_BINARY);
 282             setmode(handles[1], O_BINARY);
 283             /* Do not use CRT functions, we may single-threaded. */
 284             rc = DosCreateThread((unsigned long *) &mouse_thread,
 285                                  mouse_server, 0, 0, 8192);
 286             if (rc) {
 287                 printf("mouse thread error %d=%#x", rc, rc);
 288                 return;
 289             } else {
 290                 mousetype = M_XTERM;
 291                 return;
 292             }
 293         }
 294     }
 295 #endif
 296
 297     /* we know how to recognize mouse events under "xterm" */
 298     if (key_mouse != 0) {
 299         if (!strcmp(key_mouse, xterm_kmous)) {
 300             mousetype = M_XTERM;
 301             return;
 302         }
 303     } else if (strstr(cur_term->type.term_names, "xterm") != 0) {
 304         (void) _nc_add_to_try(&(SP->_keytry), xterm_kmous, KEY_MOUSE);
 305         mousetype = M_XTERM;
 306         return;
 307     }
 308 }
 309
 310 static void
 311 _nc_mouse_init(void)
 312 /* initialize the mouse */
 313 {
 314     int i;
 315
 316     if (!initialized) {
 317         initialized = TRUE;
 318
 319         TR(MY_TRACE, ("_nc_mouse_init() called"));
 320
 321         for (i = 0; i < EV_MAX; i++)
 322             events[i].id = INVALID_EVENT;
 323
 324         initialize_mousetype();
 325
 326         T(("_nc_mouse_init() set mousetype to %d", mousetype));
 327     }
 328 }
 329
 330 /*
 331  * Query to see if there is a pending mouse event.  This is called from
 332  * fifo_push() in lib_getch.c
 333  */
 334 static bool
 335 _nc_mouse_event(SCREEN * sp GCC_UNUSED)
 336 {
 337 #if USE_GPM_SUPPORT
 338     /* GPM: query server for event, return TRUE if we find one */
 339     Gpm_Event ev;
 340
 341     if (Gpm_GetEvent(&ev) == 1) {
 342         eventp->id = 0;         /* there's only one mouse... */
 343
 344         eventp->bstate = 0;
 345         switch (ev.type & 0x0f) {
 346         case (GPM_DOWN):
 347             if (ev.buttons & GPM_B_LEFT)
 348                 eventp->bstate |= BUTTON1_PRESSED;
 349             if (ev.buttons & GPM_B_MIDDLE)
 350                 eventp->bstate |= BUTTON2_PRESSED;
 351             if (ev.buttons & GPM_B_RIGHT)
 352                 eventp->bstate |= BUTTON3_PRESSED;
 353             break;
 354         case (GPM_UP):
 355             if (ev.buttons & GPM_B_LEFT)
 356                 eventp->bstate |= BUTTON1_RELEASED;
 357             if (ev.buttons & GPM_B_MIDDLE)
 358                 eventp->bstate |= BUTTON2_RELEASED;
 359             if (ev.buttons & GPM_B_RIGHT)
 360                 eventp->bstate |= BUTTON3_RELEASED;
 361             break;
 362         default:
 363             break;
 364         }
 365
 366         eventp->x = ev.x - 1;
 367         eventp->y = ev.y - 1;
 368         eventp->z = 0;
 369
 370         /* bump the next-free pointer into the circular list */
 371         eventp = NEXT(eventp);
 372         return (TRUE);
 373     }
 374 #endif
 375
 376 #ifdef USE_EMX_MOUSE
 377     {
 378         char kbuf[3];
 379
 380         int i, res = read(M_FD(sp), &kbuf, 3);  /* Eat the prefix */
 381         if (res != 3)
 382             printf("Got %d chars instead of 3 for prefix.\n", res);
 383         for (i = 0; i < res; i++) {
 384             if (kbuf[i] != key_mouse[i])
 385                 printf("Got char %d instead of %d for prefix.\n",
 386                        (int) kbuf[i], (int) key_mouse[i]);
 387         }
 388         return TRUE;
 389     }
 390 #endif /* USE_EMX_MOUSE */
 391
 392     /* xterm: never have to query, mouse events are in the keyboard stream */
 393     return (FALSE);             /* no event waiting */
 394 }
 395
 396 static bool
 397 _nc_mouse_inline(SCREEN * sp)
 398 /* mouse report received in the keyboard stream -- parse its info */
 399 {
 400     TR(MY_TRACE, ("_nc_mouse_inline() called"));
 401
 402     if (mousetype == M_XTERM) {
 403         unsigned char kbuf[4];
 404         MEVENT *prev;
 405         size_t grabbed;
 406         int res;
 407
 408         /* This code requires that your xterm entry contain the kmous
 409          * capability and that it be set to the \E[M documented in the
 410          * Xterm Control Sequences reference.  This is how we
 411          * arrange for mouse events to be reported via a KEY_MOUSE
 412          * return value from wgetch().  After this value is received,
 413          * _nc_mouse_inline() gets called and is immediately
 414          * responsible for parsing the mouse status information
 415          * following the prefix.
 416          *
 417          * The following quotes from the ctrlseqs.ms document in the
 418          * X distribution, describing the X mouse tracking feature:
 419          *
 420          * Parameters for all mouse tracking escape sequences
 421          * generated by xterm encode numeric parameters in a single
 422          * character as value+040.  For example, !  is 1.
 423          *
 424          * On button press or release, xterm sends ESC [ M CbCxCy.
 425          * The low two bits of Cb encode button information: 0=MB1
 426          * pressed, 1=MB2 pressed, 2=MB3 pressed, 3=release.  The
 427          * upper bits encode what modifiers were down when the
 428          * button was pressed and are added together.  4=Shift,
 429          * 8=Meta, 16=Control.  Cx and Cy are the x and y coordinates
 430          * of the mouse event.  The upper left corner is (1,1).
 431          *
 432          * (End quote)  By the time we get here, we've eaten the
 433          * key prefix.  FYI, the loop below is necessary because
 434          * mouse click info isn't guaranteed to present as a
 435          * single clist item.  It always does under Linux but often
 436          * fails to under Solaris.
 437          */
 438         for (grabbed = 0; grabbed < 3; grabbed += res) {
 439
 440             /* For VIO mouse we add extra bit 64 to disambiguate button-up. */
 441 #ifdef USE_EMX_MOUSE
 442             res = read(M_FD(sp) >= 0 ? M_FD(sp) : sp->_ifd, &kbuf, 3);
 443 #else
 444             res = read(sp->_ifd, kbuf + grabbed, 3 - grabbed);
 445 #endif
 446             if (res == -1)
 447                 break;
 448         }
 449         kbuf[3] = '\0';
 450
 451         TR(TRACE_IEVENT,
 452            ("_nc_mouse_inline sees the following xterm data: '%s'", kbuf));
 453
 454         eventp->id = 0;         /* there's only one mouse... */
 455
 456         /* processing code goes here */
 457         eventp->bstate = 0;
 458         switch (kbuf[0] & 0x3) {
 459         case 0x0:
 460             eventp->bstate = BUTTON1_PRESSED;
 461 #ifdef USE_EMX_MOUSE
 462             if (kbuf[0] & 0x40)
 463                 eventp->bstate = BUTTON1_RELEASED;
 464 #endif
 465             break;
 466
 467         case 0x1:
 468             eventp->bstate = BUTTON2_PRESSED;
 469 #ifdef USE_EMX_MOUSE
 470             if (kbuf[0] & 0x40)
 471                 eventp->bstate = BUTTON2_RELEASED;
 472 #endif
 473             break;
 474
 475         case 0x2:
 476             eventp->bstate = BUTTON3_PRESSED;
 477 #ifdef USE_EMX_MOUSE
 478             if (kbuf[0] & 0x40)
 479                 eventp->bstate = BUTTON3_RELEASED;
 480 #endif
 481             break;
 482
 483         case 0x3:
 484             /*
 485              * Release events aren't reported for individual buttons,
 486              * just for the button set as a whole...
 487              */
 488             eventp->bstate =
 489                 (BUTTON1_RELEASED |
 490                  BUTTON2_RELEASED |
 491                  BUTTON3_RELEASED);
 492             /*
 493              * ...however, because there are no kinds of mouse events under
 494              * xterm that can intervene between press and release, we can
 495              * deduce which buttons were actually released by looking at the
 496              * previous event.
 497              */
 498             prev = PREV(eventp);
 499             if (!(prev->bstate & BUTTON1_PRESSED))
 500                 eventp->bstate &= ~BUTTON1_RELEASED;
 501             if (!(prev->bstate & BUTTON2_PRESSED))
 502                 eventp->bstate &= ~BUTTON2_RELEASED;
 503             if (!(prev->bstate & BUTTON3_PRESSED))
 504                 eventp->bstate &= ~BUTTON3_RELEASED;
 505             break;
 506         }
 507
 508         if (kbuf[0] & 4) {
 509             eventp->bstate |= BUTTON_SHIFT;
 510         }
 511         if (kbuf[0] & 8) {
 512             eventp->bstate |= BUTTON_ALT;
 513         }
 514         if (kbuf[0] & 16) {
 515             eventp->bstate |= BUTTON_CTRL;
 516         }
 517
 518         eventp->x = (kbuf[1] - ' ') - 1;
 519         eventp->y = (kbuf[2] - ' ') - 1;
 520         TR(MY_TRACE,
 521            ("_nc_mouse_inline: primitive mouse-event %s has slot %ld",
 522             _tracemouse(eventp),
 523             (long) (eventp - events)));
 524
 525         /* bump the next-free pointer into the circular list */
 526         eventp = NEXT(eventp);
 527 #if 0                           /* this return would be needed for QNX's mods to lib_getch.c */
 528         return (TRUE);
 529 #endif
 530     }
 531
 532     return (FALSE);
 533 }
 534
 535 static void
 536 mouse_activate(bool on)
 537 {
 538     if (!on && !initialized)
 539         return;
 540
 541     _nc_mouse_init();
 542
 543     if (on) {
 544
 545         switch (mousetype) {
 546         case M_XTERM:
 547 #if NCURSES_EXT_FUNCS
 548             keyok(KEY_MOUSE, on);
 549 #endif
 550             TPUTS_TRACE("xterm mouse initialization");
 551 #ifdef USE_EMX_MOUSE
 552             server_state(1);
 553 #else
 554             putp("\033[?1000h");
 555 #endif
 556             break;
 557 #if USE_GPM_SUPPORT
 558         case M_GPM:
 559             SP->_mouse_fd = gpm_fd;
 560             break;
 561 #endif
 562         }
 563         /* Make runtime binding to cut down on object size of applications that
 564          * do not use the mouse (e.g., 'clear').
 565          */
 566         SP->_mouse_event = _nc_mouse_event;
 567         SP->_mouse_inline = _nc_mouse_inline;
 568         SP->_mouse_parse = _nc_mouse_parse;
 569         SP->_mouse_resume = _nc_mouse_resume;
 570         SP->_mouse_wrap = _nc_mouse_wrap;
 571
 572     } else {
 573
 574         switch (mousetype) {
 575         case M_XTERM:
 576             TPUTS_TRACE("xterm mouse deinitialization");
 577 #ifdef USE_EMX_MOUSE
 578             server_state(0);
 579 #else
 580             putp("\033[?1000l");
 581 #endif
 582             break;
 583 #if USE_GPM_SUPPORT
 584         case M_GPM:
 585             break;
 586 #endif
 587         }
 588     }
 589     _nc_flush();
 590 }
 591
 592 /**************************************************************************
 593  *
 594  * Device-independent code
 595  *
 596  **************************************************************************/
 597
 598 static bool
 599 _nc_mouse_parse(int runcount)
 600 /* parse a run of atomic mouse events into a gesture */
 601 {
 602     MEVENT *ep, *runp, *next, *prev = PREV(eventp);
 603     int n;
 604     bool merge;
 605
 606     TR(MY_TRACE, ("_nc_mouse_parse(%d) called", runcount));
 607
 608     /*
 609      * When we enter this routine, the event list next-free pointer
 610      * points just past a run of mouse events that we know were separated
 611      * in time by less than the critical click interval. The job of this
 612      * routine is to collaps this run into a single higher-level event
 613      * or gesture.
 614      *
 615      * We accomplish this in two passes.  The first pass merges press/release
 616      * pairs into click events.  The second merges runs of click events into
 617      * double or triple-click events.
 618      *
 619      * It's possible that the run may not resolve to a single event (for
 620      * example, if the user quadruple-clicks).  If so, leading events
 621      * in the run are ignored.
 622      *
 623      * Note that this routine is independent of the format of the specific
 624      * format of the pointing-device's reports.  We can use it to parse
 625      * gestures on anything that reports press/release events on a per-
 626      * button basis, as long as the device-dependent mouse code puts stuff
 627      * on the queue in MEVENT format.
 628      */
 629     if (runcount == 1) {
 630         TR(MY_TRACE,
 631            ("_nc_mouse_parse: returning simple mouse event %s at slot %ld",
 632             _tracemouse(prev),
 633             (long) (prev - events)));
 634         return (prev->id >= 0)
 635             ? ((prev->bstate & eventmask) ? TRUE : FALSE)
 636             : FALSE;
 637     }
 638
 639     /* find the start of the run */
 640     runp = eventp;
 641     for (n = runcount; n > 0; n--) {
 642         runp = PREV(runp);
 643     }
 644
 645 #ifdef TRACE
 646     if (_nc_tracing & TRACE_IEVENT) {
 647         _trace_slot("before mouse press/release merge:");
 648         _tracef("_nc_mouse_parse: run starts at %ld, ends at %ld, count %d",
 649                 (long) (runp - events),
 650                 (long) ((eventp - events) + (EV_MAX - 1)) % EV_MAX,
 651                 runcount);
 652     }
 653 #endif /* TRACE */
 654
 655     /* first pass; merge press/release pairs */
 656     do {
 657         merge = FALSE;
 658         for (ep = runp; (next = NEXT(ep)) != eventp; ep = next) {
 659             if (ep->x == next->x && ep->y == next->y
 660                 && (ep->bstate & (BUTTON1_PRESSED | BUTTON2_PRESSED | BUTTON3_PRESSED))
 661                 && (!(ep->bstate & BUTTON1_PRESSED)
 662                     == !(next->bstate & BUTTON1_RELEASED))
 663                 && (!(ep->bstate & BUTTON2_PRESSED)
 664                     == !(next->bstate & BUTTON2_RELEASED))
 665                 && (!(ep->bstate & BUTTON3_PRESSED)
 666                     == !(next->bstate & BUTTON3_RELEASED))
 667                 ) {
 668                 if ((eventmask & BUTTON1_CLICKED)
 669                     && (ep->bstate & BUTTON1_PRESSED)) {
 670                     ep->bstate &= ~BUTTON1_PRESSED;
 671                     ep->bstate |= BUTTON1_CLICKED;
 672                     merge = TRUE;
 673                 }
 674                 if ((eventmask & BUTTON2_CLICKED)
 675                     && (ep->bstate & BUTTON2_PRESSED)) {
 676                     ep->bstate &= ~BUTTON2_PRESSED;
 677                     ep->bstate |= BUTTON2_CLICKED;
 678                     merge = TRUE;
 679                 }
 680                 if ((eventmask & BUTTON3_CLICKED)
 681                     && (ep->bstate & BUTTON3_PRESSED)) {
 682                     ep->bstate &= ~BUTTON3_PRESSED;
 683                     ep->bstate |= BUTTON3_CLICKED;
 684                     merge = TRUE;
 685                 }
 686                 if (merge)
 687                     next->id = INVALID_EVENT;
 688             }
 689         }
 690     } while
 691         (merge);
 692
 693 #ifdef TRACE
 694     if (_nc_tracing & TRACE_IEVENT) {
 695         _trace_slot("before mouse click merge:");
 696         _tracef("_nc_mouse_parse: run starts at %ld, ends at %ld, count %d",
 697                 (long) (runp - events),
 698                 (long) ((eventp - events) + (EV_MAX - 1)) % EV_MAX,
 699                 runcount);
 700     }
 701 #endif /* TRACE */
 702
 703     /*
 704      * Second pass; merge click runs.  At this point, click events are
 705      * each followed by one invalid event. We merge click events
 706      * forward in the queue.
 707      *
 708      * NOTE: There is a problem with this design!  If the application
 709      * allows enough click events to pile up in the circular queue so
 710      * they wrap around, it will cheerfully merge the newest forward
 711      * into the oldest, creating a bogus doubleclick and confusing
 712      * the queue-traversal logic rather badly.  Generally this won't
 713      * happen, because calling getmouse() marks old events invalid and
 714      * ineligible for merges.  The true solution to this problem would
 715      * be to timestamp each MEVENT and perform the obvious sanity check,
 716      * but the timer element would have to have sub-second resolution,
 717      * which would get us into portability trouble.
 718      */
 719     do {
 720         MEVENT *follower;
 721
 722         merge = FALSE;
 723         for (ep = runp; (next = NEXT(ep)) != eventp; ep = next)
 724             if (ep->id != INVALID_EVENT) {
 725                 if (next->id != INVALID_EVENT)
 726                     continue;
 727                 follower = NEXT(next);
 728                 if (follower->id == INVALID_EVENT)
 729                     continue;
 730
 731                 /* merge click events forward */
 732                 if ((ep->bstate &
 733                      (BUTTON1_CLICKED | BUTTON2_CLICKED | BUTTON3_CLICKED))
 734                     && (follower->bstate &
 735                         (BUTTON1_CLICKED | BUTTON2_CLICKED | BUTTON3_CLICKED))) {
 736                     if ((eventmask & BUTTON1_DOUBLE_CLICKED)
 737                         && (follower->bstate & BUTTON1_CLICKED)) {
 738                         follower->bstate &= ~BUTTON1_CLICKED;
 739                         follower->bstate |= BUTTON1_DOUBLE_CLICKED;
 740                         merge = TRUE;
 741                     }
 742                     if ((eventmask & BUTTON2_DOUBLE_CLICKED)
 743                         && (follower->bstate & BUTTON2_CLICKED)) {
 744                         follower->bstate &= ~BUTTON2_CLICKED;
 745                         follower->bstate |= BUTTON2_DOUBLE_CLICKED;
 746                         merge = TRUE;
 747                     }
 748                     if ((eventmask & BUTTON3_DOUBLE_CLICKED)
 749                         && (follower->bstate & BUTTON3_CLICKED)) {
 750                         follower->bstate &= ~BUTTON3_CLICKED;
 751                         follower->bstate |= BUTTON3_DOUBLE_CLICKED;
 752                         merge = TRUE;
 753                     }
 754                     if (merge)
 755                         ep->id = INVALID_EVENT;
 756                 }
 757
 758                 /* merge double-click events forward */
 759                 if ((ep->bstate &
 760                      (BUTTON1_DOUBLE_CLICKED
 761                       | BUTTON2_DOUBLE_CLICKED
 762                       | BUTTON3_DOUBLE_CLICKED))
 763                     && (follower->bstate &
 764                         (BUTTON1_CLICKED | BUTTON2_CLICKED | BUTTON3_CLICKED))) {
 765                     if ((eventmask & BUTTON1_TRIPLE_CLICKED)
 766                         && (follower->bstate & BUTTON1_CLICKED)) {
 767                         follower->bstate &= ~BUTTON1_CLICKED;
 768                         follower->bstate |= BUTTON1_TRIPLE_CLICKED;
 769                         merge = TRUE;
 770                     }
 771                     if ((eventmask & BUTTON2_TRIPLE_CLICKED)
 772                         && (follower->bstate & BUTTON2_CLICKED)) {
 773                         follower->bstate &= ~BUTTON2_CLICKED;
 774                         follower->bstate |= BUTTON2_TRIPLE_CLICKED;
 775                         merge = TRUE;
 776                     }
 777                     if ((eventmask & BUTTON3_TRIPLE_CLICKED)
 778                         && (follower->bstate & BUTTON3_CLICKED)) {
 779                         follower->bstate &= ~BUTTON3_CLICKED;
 780                         follower->bstate |= BUTTON3_TRIPLE_CLICKED;
 781                         merge = TRUE;
 782                     }
 783                     if (merge)
 784                         ep->id = INVALID_EVENT;
 785                 }
 786             }
 787     } while
 788         (merge);
 789
 790 #ifdef TRACE
 791     if (_nc_tracing & TRACE_IEVENT) {
 792         _trace_slot("before mouse event queue compaction:");
 793         _tracef("_nc_mouse_parse: run starts at %ld, ends at %ld, count %d",
 794                 (long) (runp - events),
 795                 (long) ((eventp - events) + (EV_MAX - 1)) % EV_MAX,
 796                 runcount);
 797     }
 798 #endif /* TRACE */
 799
 800     /*
 801      * Now try to throw away trailing events flagged invalid, or that
 802      * don't match the current event mask.
 803      */
 804     for (; runcount; prev = PREV(eventp), runcount--)
 805         if (prev->id == INVALID_EVENT || !(prev->bstate & eventmask)) {
 806             eventp = prev;
 807         }
 808 #ifdef TRACE
 809     if (_nc_tracing & TRACE_IEVENT) {
 810         _trace_slot("after mouse event queue compaction:");
 811         _tracef("_nc_mouse_parse: run starts at %ld, ends at %ld, count %d",
 812                 (long) (runp - events),
 813                 (long) ((eventp - events) + (EV_MAX - 1)) % EV_MAX,
 814                 runcount);
 815     }
 816     for (ep = runp; ep != eventp; ep = NEXT(ep))
 817         if (ep->id != INVALID_EVENT)
 818             TR(MY_TRACE,
 819                ("_nc_mouse_parse: returning composite mouse event %s at slot %ld",
 820                 _tracemouse(ep),
 821                 (long) (ep - events)));
 822 #endif /* TRACE */
 823
 824     /* after all this, do we have a valid event? */
 825     return (PREV(eventp)->id != INVALID_EVENT);
 826 }
 827
 828 static void
 829 _nc_mouse_wrap(SCREEN * sp GCC_UNUSED)
 830 /* release mouse -- called by endwin() before shellout/exit */
 831 {
 832     TR(MY_TRACE, ("_nc_mouse_wrap() called"));
 833
 834     switch (mousetype) {
 835     case M_XTERM:
 836         if (eventmask)
 837             mouse_activate(FALSE);
 838         break;
 839 #if USE_GPM_SUPPORT
 840         /* GPM: pass all mouse events to next client */
 841     case M_GPM:
 842         break;
 843 #endif
 844     }
 845 }
 846
 847 static void
 848 _nc_mouse_resume(SCREEN * sp GCC_UNUSED)
 849 /* re-connect to mouse -- called by doupdate() after shellout */
 850 {
 851     TR(MY_TRACE, ("_nc_mouse_resume() called"));
 852
 853     /* xterm: re-enable reporting */
 854     if (mousetype == M_XTERM && eventmask)
 855         mouse_activate(TRUE);
 856
 857     /* GPM: reclaim our event set */
 858 }
 859
 860 /**************************************************************************
 861  *
 862  * Mouse interface entry points for the API
 863  *
 864  **************************************************************************/
 865
 866 NCURSES_EXPORT(int)
 867 getmouse(MEVENT * aevent)
 868 /* grab a copy of the current mouse event */
 869 {
 870     T((T_CALLED("getmouse(%p)"), aevent));
 871
 872     if (aevent && (mousetype != M_NONE)) {
 873         /* compute the current-event pointer */
 874         MEVENT *prev = PREV(eventp);
 875
 876         /* copy the event we find there */
 877         *aevent = *prev;
 878
 879         TR(TRACE_IEVENT, ("getmouse: returning event %s from slot %ld",
 880                           _tracemouse(prev),
 881                           (long) (prev - events)));
 882
 883         prev->id = INVALID_EVENT;       /* so the queue slot becomes free */
 884         returnCode(OK);
 885     }
 886     returnCode(ERR);
 887 }
 888
 889 NCURSES_EXPORT(int)
 890 ungetmouse(MEVENT * aevent)
 891 /* enqueue a synthesized mouse event to be seen by the next wgetch() */
 892 {
 893     T((T_CALLED("ungetmouse(%p)"), aevent));
 894
 895     /* stick the given event in the next-free slot */
 896     *eventp = *aevent;
 897
 898     /* bump the next-free pointer into the circular list */
 899     eventp = NEXT(eventp);
 900
 901     /* push back the notification event on the keyboard queue */
 902     returnCode(ungetch(KEY_MOUSE));
 903 }
 904
 905 NCURSES_EXPORT(mmask_t)
 906 mousemask(mmask_t newmask, mmask_t * oldmask)
 907 /* set the mouse event mask */
 908 {
 909     mmask_t result = 0;
 910
 911     T((T_CALLED("mousemask(%#lx,%p)"), newmask, oldmask));
 912
 913     if (oldmask)
 914         *oldmask = eventmask;
 915
 916     if (!newmask && !initialized)
 917         returnBits(0);
 918
 919     _nc_mouse_init();
 920     if (mousetype != M_NONE) {
 921         eventmask = newmask &
 922             (BUTTON_ALT | BUTTON_CTRL | BUTTON_SHIFT
 923              | BUTTON1_PRESSED | BUTTON1_RELEASED | BUTTON1_CLICKED
 924              | BUTTON1_DOUBLE_CLICKED | BUTTON1_TRIPLE_CLICKED
 925              | BUTTON2_PRESSED | BUTTON2_RELEASED | BUTTON2_CLICKED
 926              | BUTTON2_DOUBLE_CLICKED | BUTTON2_TRIPLE_CLICKED
 927              | BUTTON3_PRESSED | BUTTON3_RELEASED | BUTTON3_CLICKED
 928              | BUTTON3_DOUBLE_CLICKED | BUTTON3_TRIPLE_CLICKED);
 929
 930         mouse_activate(eventmask != 0);
 931
 932         result = eventmask;
 933     }
 934
 935     returnBits(result);
 936 }
 937
 938 NCURSES_EXPORT(bool)
 939 wenclose(const WINDOW *win, int y, int x)
 940 /* check to see if given window encloses given screen location */
 941 {
 942     bool result = FALSE;
 943
 944     T((T_CALLED("wenclose(%p,%d,%d)"), win, y, x));
 945
 946     if (win != 0) {
 947         y -= win->_yoffset;
 948         result = ((win->_begy <= y &&
 949                    win->_begx <= x &&
 950                    (win->_begx + win->_maxx) >= x &&
 951                    (win->_begy + win->_maxy) >= y) ? TRUE : FALSE);
 952     }
 953     returnBool(result);
 954 }
 955
 956 NCURSES_EXPORT(int)
 957 mouseinterval(int maxclick)
 958 /* set the maximum mouse interval within which to recognize a click */
 959 {
 960     int oldval;
 961
 962     T((T_CALLED("mouseinterval(%d)"), maxclick));
 963
 964     if (SP != 0) {
 965         oldval = SP->_maxclick;
 966         if (maxclick >= 0)
 967             SP->_maxclick = maxclick;
 968     } else {
 969         oldval = DEFAULT_MAXCLICK;
 970     }
 971
 972     returnCode(oldval);
 973 }
 974
 975 /* This may be used by other routines to ask for the existence of mouse
 976    support */
 977 NCURSES_EXPORT(int)
 978 _nc_has_mouse(void)
 979 {
 980     return (mousetype == M_NONE ? 0 : 1);
 981 }
 982
 983 NCURSES_EXPORT(bool)
 984 wmouse_trafo(const WINDOW *win, int *pY, int *pX, bool to_screen)
 985 {
 986     bool result = FALSE;
 987
 988     T((T_CALLED("wmouse_trafo(%p,%p,%p,%d)"), win, pY, pX, to_screen));
 989
 990     if (win && pY && pX) {
 991         int y = *pY;
 992         int x = *pX;
 993
 994         if (to_screen) {
 995             y += win->_begy + win->_yoffset;
 996             x += win->_begx;
 997             if (wenclose(win, y, x))
 998                 result = TRUE;
 999         } else {
1000             if (wenclose(win, y, x)) {
1001                 y -= (win->_begy + win->_yoffset);
1002                 x -= win->_begx;
1003                 result = TRUE;
1004             }
1005         }
1006         if (result) {
1007             *pX = x;
1008             *pY = y;
1009         }
1010     }
1011     returnBool(result);
1012 }
1013
1014 /* lib_mouse.c ends here */