ncurses/base/lib_getch.c

   1 /****************************************************************************
   2  * Copyright (c) 1998-2006,2007 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  *     and: Thomas E. Dickey                        1996-on                 *
  33  ****************************************************************************/
  34
  35 /*
  36 **      lib_getch.c
  37 **
  38 **      The routine getch().
  39 **
  40 */
  41
  42 #include <curses.priv.h>
  43
  44 MODULE_ID("$Id: lib_getch.c,v 1.79 2007/04/19 20:57:49 tom Exp $")
  45
  46 #include <fifo_defs.h>
  47
  48 #if USE_REENTRANT
  49 NCURSES_EXPORT(int)
  50 NCURSES_PUBLIC_VAR(ESCDELAY) (void)
  51 {
  52     return SP ? SP->_ESCDELAY : 1000;
  53 }
  54 #else
  55 NCURSES_EXPORT_VAR(int)
  56 ESCDELAY = 1000;                /* max interval betw. chars in funkeys, in millisecs */
  57 #endif
  58
  59 #ifdef NCURSES_WGETCH_EVENTS
  60 #define TWAIT_MASK 7
  61 #else
  62 #define TWAIT_MASK 3
  63 #endif
  64
  65 /*
  66  * Check for mouse activity, returning nonzero if we find any.
  67  */
  68 static int
  69 check_mouse_activity(int delay EVENTLIST_2nd(_nc_eventlist * evl))
  70 {
  71     int rc;
  72
  73 #if USE_SYSMOUSE
  74     if ((SP->_mouse_type == M_SYSMOUSE)
  75         && (SP->_sysmouse_head < SP->_sysmouse_tail)) {
  76         return 2;
  77     }
  78 #endif
  79     rc = _nc_timed_wait(TWAIT_MASK, delay, (int *) 0 EVENTLIST_2nd(evl));
  80 #if USE_SYSMOUSE
  81     if ((SP->_mouse_type == M_SYSMOUSE)
  82         && (SP->_sysmouse_head < SP->_sysmouse_tail)
  83         && (rc == 0)
  84         && (errno == EINTR)) {
  85         rc |= 2;
  86     }
  87 #endif
  88     return rc;
  89 }
  90
  91 static NCURSES_INLINE int
  92 fifo_peek(void)
  93 {
  94     int ch = SP->_fifo[peek];
  95     TR(TRACE_IEVENT, ("peeking at %d", peek));
  96
  97     p_inc();
  98     return ch;
  99 }
 100
 101 static NCURSES_INLINE int
 102 fifo_pull(void)
 103 {
 104     int ch;
 105     ch = SP->_fifo[head];
 106     TR(TRACE_IEVENT, ("pulling %s from %d", _tracechar(ch), head));
 107
 108     if (peek == head) {
 109         h_inc();
 110         peek = head;
 111     } else
 112         h_inc();
 113
 114 #ifdef TRACE
 115     if (_nc_tracing & TRACE_IEVENT)
 116         _nc_fifo_dump();
 117 #endif
 118     return ch;
 119 }
 120
 121 static NCURSES_INLINE int
 122 fifo_push(EVENTLIST_0th(_nc_eventlist * evl))
 123 {
 124     int n;
 125     int ch = 0;
 126     int mask = 0;
 127
 128     (void) mask;
 129     if (tail == -1)
 130         return ERR;
 131
 132 #ifdef HIDE_EINTR
 133   again:
 134     errno = 0;
 135 #endif
 136
 137 #ifdef NCURSES_WGETCH_EVENTS
 138     if (evl
 139 #if USE_GPM_SUPPORT || USE_EMX_MOUSE || USE_SYSMOUSE
 140         || (SP->_mouse_fd >= 0)
 141 #endif
 142         ) {
 143         mask = check_mouse_activity(-1 EVENTLIST_2nd(evl));
 144     } else
 145         mask = 0;
 146
 147     if (mask & 4) {
 148         T(("fifo_push: ungetch KEY_EVENT"));
 149         ungetch(KEY_EVENT);
 150         return KEY_EVENT;
 151     }
 152 #elif USE_GPM_SUPPORT || USE_EMX_MOUSE || USE_SYSMOUSE
 153     if (SP->_mouse_fd >= 0) {
 154         mask = check_mouse_activity(-1 EVENTLIST_2nd(evl));
 155     }
 156 #endif
 157
 158 #if USE_GPM_SUPPORT || USE_EMX_MOUSE
 159     if ((SP->_mouse_fd >= 0) && (mask & 2)) {
 160         SP->_mouse_event(SP);
 161         ch = KEY_MOUSE;
 162         n = 1;
 163     } else
 164 #endif
 165 #if USE_SYSMOUSE
 166         if ((SP->_mouse_type == M_SYSMOUSE)
 167             && (SP->_sysmouse_head < SP->_sysmouse_tail)) {
 168         SP->_mouse_event(SP);
 169         ch = KEY_MOUSE;
 170         n = 1;
 171     } else if ((SP->_mouse_type == M_SYSMOUSE)
 172                && (mask <= 0) && errno == EINTR) {
 173         SP->_mouse_event(SP);
 174         ch = KEY_MOUSE;
 175         n = 1;
 176     } else
 177 #endif
 178     {                           /* Can block... */
 179         unsigned char c2 = 0;
 180         n = read(SP->_ifd, &c2, 1);
 181         ch = c2;
 182     }
 183
 184 #ifdef HIDE_EINTR
 185     /*
 186      * Under System V curses with non-restarting signals, getch() returns
 187      * with value ERR when a handled signal keeps it from completing.
 188      * If signals restart system calls, OTOH, the signal is invisible
 189      * except to its handler.
 190      *
 191      * We don't want this difference to show.  This piece of code
 192      * tries to make it look like we always have restarting signals.
 193      */
 194     if (n <= 0 && errno == EINTR)
 195         goto again;
 196 #endif
 197
 198     if ((n == -1) || (n == 0)) {
 199         TR(TRACE_IEVENT, ("read(%d,&ch,1)=%d, errno=%d", SP->_ifd, n, errno));
 200         ch = ERR;
 201     }
 202     TR(TRACE_IEVENT, ("read %d characters", n));
 203
 204     SP->_fifo[tail] = ch;
 205     SP->_fifohold = 0;
 206     if (head == -1)
 207         head = peek = tail;
 208     t_inc();
 209     TR(TRACE_IEVENT, ("pushed %s at %d", _tracechar(ch), tail));
 210 #ifdef TRACE
 211     if (_nc_tracing & TRACE_IEVENT)
 212         _nc_fifo_dump();
 213 #endif
 214     return ch;
 215 }
 216
 217 static NCURSES_INLINE void
 218 fifo_clear(void)
 219 {
 220     memset(SP->_fifo, 0, sizeof(SP->_fifo));
 221     head = -1;
 222     tail = peek = 0;
 223 }
 224
 225 static int kgetch(EVENTLIST_0th(_nc_eventlist * evl));
 226
 227 #define wgetch_should_refresh(win) (\
 228         (is_wintouched(win) || (win->_flags & _HASMOVED)) \
 229         && !(win->_flags & _ISPAD))
 230
 231 NCURSES_EXPORT(int)
 232 _nc_wgetch(WINDOW *win,
 233            unsigned long *result,
 234            int use_meta
 235            EVENTLIST_2nd(_nc_eventlist * evl))
 236 {
 237     int ch;
 238 #ifdef NCURSES_WGETCH_EVENTS
 239     long event_delay = -1;
 240 #endif
 241
 242     T((T_CALLED("_nc_wgetch(%p)"), win));
 243
 244     *result = 0;
 245     if (win == 0 || SP == 0) {
 246         returnCode(ERR);
 247     }
 248
 249     if (cooked_key_in_fifo()) {
 250         if (wgetch_should_refresh(win))
 251             wrefresh(win);
 252
 253         *result = fifo_pull();
 254         returnCode(*result >= KEY_MIN ? KEY_CODE_YES : OK);
 255     }
 256 #ifdef NCURSES_WGETCH_EVENTS
 257     if (evl && (evl->count == 0))
 258         evl = NULL;
 259     event_delay = _nc_eventlist_timeout(evl);
 260 #endif
 261
 262     /*
 263      * Handle cooked mode.  Grab a string from the screen,
 264      * stuff its contents in the FIFO queue, and pop off
 265      * the first character to return it.
 266      */
 267     if (head == -1 &&
 268         !SP->_notty &&
 269         !SP->_raw &&
 270         !SP->_cbreak &&
 271         !SP->_called_wgetch) {
 272         char buf[MAXCOLUMNS], *sp;
 273         int rc;
 274
 275         TR(TRACE_IEVENT, ("filling queue in cooked mode"));
 276
 277         SP->_called_wgetch = TRUE;
 278         rc = wgetnstr(win, buf, MAXCOLUMNS);
 279         SP->_called_wgetch = FALSE;
 280
 281         /* ungetch in reverse order */
 282 #ifdef NCURSES_WGETCH_EVENTS
 283         if (rc != KEY_EVENT)
 284 #endif
 285             ungetch('\n');
 286         for (sp = buf + strlen(buf); sp > buf; sp--)
 287             ungetch(sp[-1]);
 288
 289 #ifdef NCURSES_WGETCH_EVENTS
 290         /* Return it first */
 291         if (rc == KEY_EVENT) {
 292             *result = rc;
 293         } else
 294 #endif
 295             *result = fifo_pull();
 296         returnCode(*result >= KEY_MIN ? KEY_CODE_YES : OK);
 297     }
 298
 299     if (win->_use_keypad != SP->_keypad_on)
 300         _nc_keypad(win->_use_keypad);
 301
 302     if (wgetch_should_refresh(win))
 303         wrefresh(win);
 304
 305     if (!win->_notimeout && (win->_delay >= 0 || SP->_cbreak > 1)) {
 306         if (head == -1) {       /* fifo is empty */
 307             int delay;
 308             int rc;
 309
 310             TR(TRACE_IEVENT, ("timed delay in wgetch()"));
 311             if (SP->_cbreak > 1)
 312                 delay = (SP->_cbreak - 1) * 100;
 313             else
 314                 delay = win->_delay;
 315
 316 #ifdef NCURSES_WGETCH_EVENTS
 317             if (event_delay >= 0 && delay > event_delay)
 318                 delay = event_delay;
 319 #endif
 320
 321             TR(TRACE_IEVENT, ("delay is %d milliseconds", delay));
 322
 323             rc = check_mouse_activity(delay EVENTLIST_2nd(evl));
 324
 325 #ifdef NCURSES_WGETCH_EVENTS
 326             if (rc & 4) {
 327                 *result = KEY_EVENT;
 328                 returnCode(KEY_CODE_YES);
 329             }
 330 #endif
 331             if (!rc)
 332                 returnCode(ERR);
 333         }
 334         /* else go on to read data available */
 335     }
 336
 337     if (win->_use_keypad) {
 338         /*
 339          * This is tricky.  We only want to get special-key
 340          * events one at a time.  But we want to accumulate
 341          * mouse events until either (a) the mouse logic tells
 342          * us it's picked up a complete gesture, or (b)
 343          * there's a detectable time lapse after one.
 344          *
 345          * Note: if the mouse code starts failing to compose
 346          * press/release events into clicks, you should probably
 347          * increase the wait with mouseinterval().
 348          */
 349         int runcount = 0;
 350         int rc;
 351
 352         do {
 353             ch = kgetch(EVENTLIST_1st(evl));
 354             if (ch == KEY_MOUSE) {
 355                 ++runcount;
 356                 if (SP->_mouse_inline(SP))
 357                     break;
 358             }
 359             if (SP->_maxclick < 0)
 360                 break;
 361         } while
 362             (ch == KEY_MOUSE
 363              && (((rc = check_mouse_activity(SP->_maxclick
 364                                              EVENTLIST_2nd(evl))) != 0
 365                   && !(rc & 4))
 366                  || !SP->_mouse_parse(runcount)));
 367 #ifdef NCURSES_WGETCH_EVENTS
 368         if ((rc & 4) && !ch == KEY_EVENT) {
 369             ungetch(ch);
 370             ch = KEY_EVENT;
 371         }
 372 #endif
 373         if (runcount > 0 && ch != KEY_MOUSE) {
 374 #ifdef NCURSES_WGETCH_EVENTS
 375             /* mouse event sequence ended by an event, report event */
 376             if (ch == KEY_EVENT) {
 377                 ungetch(KEY_MOUSE);     /* FIXME This interrupts a gesture... */
 378             } else
 379 #endif
 380             {
 381                 /* mouse event sequence ended by keystroke, store keystroke */
 382                 ungetch(ch);
 383                 ch = KEY_MOUSE;
 384             }
 385         }
 386     } else {
 387         if (head == -1)
 388             fifo_push(EVENTLIST_1st(evl));
 389         ch = fifo_pull();
 390     }
 391
 392     if (ch == ERR) {
 393 #if USE_SIZECHANGE
 394         if (_nc_handle_sigwinch(FALSE)) {
 395             _nc_update_screensize();
 396             /* resizeterm can push KEY_RESIZE */
 397             if (cooked_key_in_fifo()) {
 398                 *result = fifo_pull();
 399                 returnCode(*result >= KEY_MIN ? KEY_CODE_YES : OK);
 400             }
 401         }
 402 #endif
 403         returnCode(ERR);
 404     }
 405
 406     /*
 407      * If echo() is in effect, display the printable version of the
 408      * key on the screen.  Carriage return and backspace are treated
 409      * specially by Solaris curses:
 410      *
 411      * If carriage return is defined as a function key in the
 412      * terminfo, e.g., kent, then Solaris may return either ^J (or ^M
 413      * if nonl() is set) or KEY_ENTER depending on the echo() mode.
 414      * We echo before translating carriage return based on nonl(),
 415      * since the visual result simply moves the cursor to column 0.
 416      *
 417      * Backspace is a different matter.  Solaris curses does not
 418      * translate it to KEY_BACKSPACE if kbs=^H.  This does not depend
 419      * on the stty modes, but appears to be a hardcoded special case.
 420      * This is a difference from ncurses, which uses the terminfo entry.
 421      * However, we provide the same visual result as Solaris, moving the
 422      * cursor to the left.
 423      */
 424     if (SP->_echo && !(win->_flags & _ISPAD)) {
 425         chtype backup = (ch == KEY_BACKSPACE) ? '\b' : ch;
 426         if (backup < KEY_MIN)
 427             wechochar(win, backup);
 428     }
 429
 430     /*
 431      * Simulate ICRNL mode
 432      */
 433     if ((ch == '\r') && SP->_nl)
 434         ch = '\n';
 435
 436     /* Strip 8th-bit if so desired.  We do this only for characters that
 437      * are in the range 128-255, to provide compatibility with terminals
 438      * that display only 7-bit characters.  Note that 'ch' may be a
 439      * function key at this point, so we mustn't strip _those_.
 440      */
 441     if (!use_meta)
 442         if ((ch < KEY_MIN) && (ch & 0x80))
 443             ch &= 0x7f;
 444
 445     T(("wgetch returning : %s", _tracechar(ch)));
 446
 447     *result = ch;
 448     returnCode(ch >= KEY_MIN ? KEY_CODE_YES : OK);
 449 }
 450
 451 #ifdef NCURSES_WGETCH_EVENTS
 452 NCURSES_EXPORT(int)
 453 wgetch_events(WINDOW *win, _nc_eventlist * evl)
 454 {
 455     int code;
 456     unsigned long value;
 457
 458     T((T_CALLED("wgetch_events(%p,%p)"), win, evl));
 459     code = _nc_wgetch(win,
 460                       &value,
 461                       SP->_use_meta
 462                       EVENTLIST_2nd(evl));
 463     if (code != ERR)
 464         code = value;
 465     returnCode(code);
 466 }
 467 #endif
 468
 469 NCURSES_EXPORT(int)
 470 wgetch(WINDOW *win)
 471 {
 472     int code;
 473     unsigned long value;
 474
 475     T((T_CALLED("wgetch(%p)"), win));
 476     code = _nc_wgetch(win,
 477                       &value,
 478                       (SP ? SP->_use_meta : 0)
 479                       EVENTLIST_2nd((_nc_eventlist *) 0));
 480     if (code != ERR)
 481         code = value;
 482     returnCode(code);
 483 }
 484
 485 /*
 486 **      int
 487 **      kgetch()
 488 **
 489 **      Get an input character, but take care of keypad sequences, returning
 490 **      an appropriate code when one matches the input.  After each character
 491 **      is received, set an alarm call based on ESCDELAY.  If no more of the
 492 **      sequence is received by the time the alarm goes off, pass through
 493 **      the sequence gotten so far.
 494 **
 495 **      This function must be called when there are no cooked keys in queue.
 496 **      (that is head==-1 || peek==head)
 497 **
 498 */
 499
 500 static int
 501 kgetch(EVENTLIST_0th(_nc_eventlist * evl))
 502 {
 503     TRIES *ptr;
 504     int ch = 0;
 505     int timeleft = ESCDELAY;
 506
 507     TR(TRACE_IEVENT, ("kgetch() called"));
 508
 509     ptr = SP->_keytry;
 510
 511     for (;;) {
 512         if (cooked_key_in_fifo() && SP->_fifo[head] >= KEY_MIN) {
 513             break;
 514         } else if (!raw_key_in_fifo()) {
 515             ch = fifo_push(EVENTLIST_1st(evl));
 516             if (ch == ERR) {
 517                 peek = head;    /* the keys stay uninterpreted */
 518                 return ERR;
 519             }
 520 #ifdef NCURSES_WGETCH_EVENTS
 521             else if (ch == KEY_EVENT) {
 522                 peek = head;    /* the keys stay uninterpreted */
 523                 return fifo_pull();     /* Remove KEY_EVENT from the queue */
 524             }
 525 #endif
 526         }
 527
 528         ch = fifo_peek();
 529         if (ch >= KEY_MIN) {
 530             /* If not first in queue, somebody put this key there on purpose in
 531              * emergency.  Consider it higher priority than the unfinished
 532              * keysequence we are parsing.
 533              */
 534             peek = head;
 535             /* assume the key is the last in fifo */
 536             t_dec();            /* remove the key */
 537             return ch;
 538         }
 539
 540         TR(TRACE_IEVENT, ("ch: %s", _tracechar((unsigned char) ch)));
 541         while ((ptr != NULL) && (ptr->ch != (unsigned char) ch))
 542             ptr = ptr->sibling;
 543
 544         if (ptr == NULL) {
 545             TR(TRACE_IEVENT, ("ptr is null"));
 546             break;
 547         }
 548         TR(TRACE_IEVENT, ("ptr=%p, ch=%d, value=%d",
 549                           ptr, ptr->ch, ptr->value));
 550
 551         if (ptr->value != 0) {  /* sequence terminated */
 552             TR(TRACE_IEVENT, ("end of sequence"));
 553             if (peek == tail)
 554                 fifo_clear();
 555             else
 556                 head = peek;
 557             return (ptr->value);
 558         }
 559
 560         ptr = ptr->child;
 561
 562         if (!raw_key_in_fifo()) {
 563             int rc;
 564
 565             TR(TRACE_IEVENT, ("waiting for rest of sequence"));
 566             rc = check_mouse_activity(timeleft EVENTLIST_2nd(evl));
 567 #ifdef NCURSES_WGETCH_EVENTS
 568             if (rc & 4) {
 569                 TR(TRACE_IEVENT, ("interrupted by a user event"));
 570                 /* FIXME Should have preserved remainder timeleft for reuse... */
 571                 peek = head;    /* Restart interpreting later */
 572                 return KEY_EVENT;
 573             }
 574 #endif
 575             if (!rc) {
 576                 TR(TRACE_IEVENT, ("ran out of time"));
 577                 break;
 578             }
 579         }
 580     }
 581     ch = fifo_pull();
 582     peek = head;
 583     return ch;
 584 }