X-Git-Url: https://ncurses.scripts.mit.edu/?p=ncurses.git;a=blobdiff_plain;f=ncurses%2Fbase%2Flib_getch.c;h=66c9f87e57d617efa80f0c3da0b3529839e921ae;hp=c5a5dc3ea588858bab4344acc197358f306fb18c;hb=119b5a6788c26bf7dcc99fcfd54e072946352a93;hpb=b1f61d9f3aa244512045a6b02e759825d7049d34 diff --git a/ncurses/base/lib_getch.c b/ncurses/base/lib_getch.c index c5a5dc3e..66c9f87e 100644 --- a/ncurses/base/lib_getch.c +++ b/ncurses/base/lib_getch.c @@ -1,5 +1,5 @@ /**************************************************************************** - * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. * + * Copyright (c) 1998-2018,2019 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,6 +29,8 @@ /**************************************************************************** * Author: Zeyd M. Ben-Halim 1992,1995 * * and: Eric S. Raymond * + * and: Thomas E. Dickey 1996-on * + * and: Juergen Pfeifer 2009 * ****************************************************************************/ /* @@ -40,218 +42,468 @@ #include -MODULE_ID("$Id: lib_getch.c,v 1.48 2000/07/08 11:21:51 tom Exp $") +MODULE_ID("$Id: lib_getch.c,v 1.138 2019/11/03 00:11:16 tom Exp $") #include -int ESCDELAY = 1000; /* max interval betw. chars in funkeys, in millisecs */ +#if USE_REENTRANT +#define GetEscdelay(sp) *_nc_ptr_Escdelay(sp) +NCURSES_EXPORT(int) +NCURSES_PUBLIC_VAR(ESCDELAY) (void) +{ + return *(_nc_ptr_Escdelay(CURRENT_SCREEN)); +} -#ifdef USE_EMX_MOUSE -# include -static int -kbd_mouse_read(unsigned char *p) +NCURSES_EXPORT(int *) +_nc_ptr_Escdelay(SCREEN *sp) { - fd_set fdset; - int nums = SP->_ifd + 1; + return ptrEscdelay(sp); +} +#else +#define GetEscdelay(sp) ESCDELAY +NCURSES_EXPORT_VAR(int) ESCDELAY = 1000; +#endif - for (;;) { - FD_ZERO(&fdset); - FD_SET(SP->_ifd, &fdset); - if (SP->_checkfd >= 0) { - FD_SET(SP->_checkfd, &fdset); - if (SP->_checkfd >= nums) - nums = SP->_checkfd + 1; - } - if (SP->_mouse_fd >= 0) { - FD_SET(SP->_mouse_fd, &fdset); - if (SP->_mouse_fd >= nums) - nums = SP->_mouse_fd + 1; +#if NCURSES_EXT_FUNCS +NCURSES_EXPORT(int) +NCURSES_SP_NAME(set_escdelay) (NCURSES_SP_DCLx int value) +{ + int code = OK; + if (value < 0) { + code = ERR; + } else { +#if USE_REENTRANT + if (SP_PARM) { + SET_ESCDELAY(value); + } else { + code = ERR; } - if (select(nums, &fdset, NULL, NULL, NULL) >= 0) { - int n; +#else + (void) SP_PARM; + ESCDELAY = value; +#endif + } + return code; +} - if (SP->_mouse_fd >= 0 - && FD_ISSET(SP->_mouse_fd, &fdset)) { /* Prefer mouse */ - n = read(SP->_mouse_fd, p, 1); - } else { - n = read(SP->_ifd, p, 1); - } - return n; - } - if (errno != EINTR) { - return -1; +#if NCURSES_SP_FUNCS +NCURSES_EXPORT(int) +set_escdelay(int value) +{ + int code; + if (value < 0) { + code = ERR; + } else { +#if USE_REENTRANT + code = NCURSES_SP_NAME(set_escdelay) (CURRENT_SCREEN, value); +#else + ESCDELAY = value; + code = OK; +#endif + } + return code; +} +#endif +#endif /* NCURSES_EXT_FUNCS */ + +#if NCURSES_EXT_FUNCS +NCURSES_EXPORT(int) +NCURSES_SP_NAME(get_escdelay) (NCURSES_SP_DCL0) +{ +#if !USE_REENTRANT + (void) SP_PARM; +#endif + return GetEscdelay(SP_PARM); +} + +#if NCURSES_SP_FUNCS +NCURSES_EXPORT(int) +get_escdelay(void) +{ + return NCURSES_SP_NAME(get_escdelay) (CURRENT_SCREEN); +} +#endif +#endif /* NCURSES_EXT_FUNCS */ + +static int +_nc_use_meta(WINDOW *win) +{ + SCREEN *sp = _nc_screen_of(win); + return (sp ? sp->_use_meta : 0); +} + +#ifdef USE_TERM_DRIVER +# ifdef _WIN32 +static HANDLE +_nc_get_handle(int fd) +{ + intptr_t value = _get_osfhandle(fd); + return (HANDLE) value; +} +# endif +#endif + +/* + * Check for mouse activity, returning nonzero if we find any. + */ +static int +check_mouse_activity(SCREEN *sp, int delay EVENTLIST_2nd(_nc_eventlist * evl)) +{ + int rc; + +#ifdef USE_TERM_DRIVER + TERMINAL_CONTROL_BLOCK *TCB = TCBOf(sp); + rc = TCBOf(sp)->drv->td_testmouse(TCBOf(sp), delay EVENTLIST_2nd(evl)); +# ifdef _WIN32 + /* if we emulate terminfo on console, we have to use the console routine */ + if (IsTermInfoOnConsole(sp)) { + HANDLE fd = _nc_get_handle(sp->_ifd); + rc = _nc_mingw_testmouse(sp, fd, delay EVENTLIST_2nd(evl)); + } else +# endif + rc = TCB->drv->td_testmouse(TCB, delay EVENTLIST_2nd(evl)); +#else +#if USE_SYSMOUSE + if ((sp->_mouse_type == M_SYSMOUSE) + && (sp->_sysmouse_head < sp->_sysmouse_tail)) { + rc = TW_MOUSE; + } else +#endif + { + rc = _nc_timed_wait(sp, + TWAIT_MASK, + delay, + (int *) 0 + EVENTLIST_2nd(evl)); +#if USE_SYSMOUSE + if ((sp->_mouse_type == M_SYSMOUSE) + && (sp->_sysmouse_head < sp->_sysmouse_tail) + && (rc == 0) + && (errno == EINTR)) { + rc |= TW_MOUSE; } +#endif } +#endif + return rc; } -#endif /* USE_EMX_MOUSE */ -static inline int -fifo_peek(void) +static NCURSES_INLINE int +fifo_peek(SCREEN *sp) { - int ch = SP->_fifo[peek]; - T(("peeking at %d", peek)); + int ch = (peek >= 0) ? sp->_fifo[peek] : ERR; + TR(TRACE_IEVENT, ("peeking at %d", peek)); p_inc(); return ch; } -static inline int -fifo_pull(void) +static NCURSES_INLINE int +fifo_pull(SCREEN *sp) { - int ch; - ch = SP->_fifo[head]; - T(("pulling %d from %d", ch, head)); + int ch = (head >= 0) ? sp->_fifo[head] : ERR; + + TR(TRACE_IEVENT, ("pulling %s from %d", _nc_tracechar(sp, ch), head)); if (peek == head) { h_inc(); peek = head; - } else + } else { h_inc(); + } #ifdef TRACE - if (_nc_tracing & TRACE_IEVENT) - _nc_fifo_dump(); + if (USE_TRACEF(TRACE_IEVENT)) { + _nc_fifo_dump(sp); + _nc_unlock_global(tracef); + } #endif return ch; } -static inline int -fifo_push(void) +static NCURSES_INLINE int +fifo_push(SCREEN *sp EVENTLIST_2nd(_nc_eventlist * evl)) { int n; - unsigned int ch; + int ch = 0; + int mask = 0; - if (tail == -1) + (void) mask; + if (tail < 0) return ERR; -#ifdef HIDE_EINTR - again: - errno = 0; +#ifdef NCURSES_WGETCH_EVENTS + if (evl +#if USE_GPM_SUPPORT || USE_EMX_MOUSE || USE_SYSMOUSE + || (sp->_mouse_fd >= 0) +#endif + ) { + mask = check_mouse_activity(sp, -1 EVENTLIST_2nd(evl)); + } else + mask = 0; + + if (mask & TW_EVENT) { + T(("fifo_push: ungetch KEY_EVENT")); + safe_ungetch(sp, KEY_EVENT); + return KEY_EVENT; + } +#elif USE_GPM_SUPPORT || USE_EMX_MOUSE || USE_SYSMOUSE + if (sp->_mouse_fd >= 0) { + mask = check_mouse_activity(sp, -1 EVENTLIST_2nd(evl)); + } #endif -#if USE_GPM_SUPPORT - if ((SP->_mouse_fd >= 0) - && (_nc_timed_wait(3, -1, (int *) 0) & 2)) { - SP->_mouse_event(SP); +#if USE_GPM_SUPPORT || USE_EMX_MOUSE + if ((sp->_mouse_fd >= 0) && (mask & TW_MOUSE)) { + sp->_mouse_event(sp); ch = KEY_MOUSE; n = 1; } else #endif - { - unsigned char c2 = 0; -#ifdef USE_EMX_MOUSE - n = kbd_mouse_read(&c2); +#if USE_SYSMOUSE + if ((sp->_mouse_type == M_SYSMOUSE) + && (sp->_sysmouse_head < sp->_sysmouse_tail)) { + sp->_mouse_event(sp); + ch = KEY_MOUSE; + n = 1; + } else if ((sp->_mouse_type == M_SYSMOUSE) + && (mask <= 0) && errno == EINTR) { + sp->_mouse_event(sp); + ch = KEY_MOUSE; + n = 1; + } else +#endif +#ifdef USE_TERM_DRIVER + if ((sp->_mouse_type == M_TERM_DRIVER) + && (sp->_drv_mouse_head < sp->_drv_mouse_tail)) { + sp->_mouse_event(sp); + ch = KEY_MOUSE; + n = 1; + } else +#endif +#if USE_KLIBC_KBD + if (NC_ISATTY(sp->_ifd) && sp->_cbreak) { + ch = _read_kbd(0, 1, !sp->_raw); + n = (ch == -1) ? -1 : 1; + sp->_extended_key = (ch == 0); + } else +#endif + { /* Can block... */ +#ifdef USE_TERM_DRIVER + int buf; +#ifdef _WIN32 + if (NC_ISATTY(sp->_ifd) && IsTermInfoOnConsole(sp) && sp->_cbreak) + n = _nc_mingw_console_read(sp, + _nc_get_handle(sp->_ifd), + &buf); + else +#endif + n = CallDriver_1(sp, td_read, &buf); + ch = buf; #else - n = read(SP->_ifd, &c2, 1); + unsigned char c2 = 0; +# if USE_PTHREADS_EINTR +# if USE_WEAK_SYMBOLS + if ((pthread_self) && (pthread_kill) && (pthread_equal)) +# endif + _nc_globals.read_thread = pthread_self(); +# endif + n = (int) read(sp->_ifd, &c2, (size_t) 1); +#if USE_PTHREADS_EINTR + _nc_globals.read_thread = 0; #endif - ch = c2 & 0xff; - } - -#ifdef HIDE_EINTR - /* - * Under System V curses with non-restarting signals, getch() returns - * with value ERR when a handled signal keeps it from completing. - * If signals restart system calls, OTOH, the signal is invisible - * except to its handler. - * - * We don't want this difference to show. This piece of code - * tries to make it look like we always have restarting signals. - */ - if (n <= 0 && errno == EINTR) - goto again; + ch = c2; #endif + } if ((n == -1) || (n == 0)) { - T(("read(%d,&ch,1)=%d, errno=%d", SP->_ifd, n, errno)); + TR(TRACE_IEVENT, ("read(%d,&ch,1)=%d, errno=%d", sp->_ifd, n, errno)); ch = ERR; } - T(("read %d characters", n)); + TR(TRACE_IEVENT, ("read %d characters", n)); - SP->_fifo[tail] = ch; - SP->_fifohold = 0; + sp->_fifo[tail] = ch; + sp->_fifohold = 0; if (head == -1) head = peek = tail; t_inc(); - T(("pushed %#x at %d", ch, tail)); + TR(TRACE_IEVENT, ("pushed %s at %d", _nc_tracechar(sp, ch), tail)); #ifdef TRACE - if (_nc_tracing & TRACE_IEVENT) - _nc_fifo_dump(); + if (USE_TRACEF(TRACE_IEVENT)) { + _nc_fifo_dump(sp); + _nc_unlock_global(tracef); + } #endif return ch; } -static inline void -fifo_clear(void) +static NCURSES_INLINE void +fifo_clear(SCREEN *sp) { - int i; - for (i = 0; i < FIFO_SIZE; i++) - SP->_fifo[i] = 0; + memset(sp->_fifo, 0, sizeof(sp->_fifo)); head = -1; tail = peek = 0; } -static int kgetch(WINDOW *); +static int kgetch(SCREEN *, bool EVENTLIST_2nd(_nc_eventlist *)); -#define wgetch_should_refresh(win) (\ - (is_wintouched(win) || (win->_flags & _HASMOVED)) \ - && !(win->_flags & _ISPAD)) +static void +recur_wrefresh(WINDOW *win) +{ +#ifdef USE_PTHREADS + SCREEN *sp = _nc_screen_of(win); + if (_nc_use_pthreads && sp != CURRENT_SCREEN) { + SCREEN *save_SP; + + /* temporarily switch to the window's screen to check/refresh */ + _nc_lock_global(curses); + save_SP = CURRENT_SCREEN; + _nc_set_screen(sp); + recur_wrefresh(win); + _nc_set_screen(save_SP); + _nc_unlock_global(curses); + } else +#endif + if ((is_wintouched(win) || (win->_flags & _HASMOVED)) + && !(win->_flags & _ISPAD)) { + wrefresh(win); + } +} -int -wgetch(WINDOW *win) +static int +recur_wgetnstr(WINDOW *win, char *buf) { + SCREEN *sp = _nc_screen_of(win); + int rc; + + if (sp != 0) { +#ifdef USE_PTHREADS + if (_nc_use_pthreads && sp != CURRENT_SCREEN) { + SCREEN *save_SP; + + /* temporarily switch to the window's screen to get cooked input */ + _nc_lock_global(curses); + save_SP = CURRENT_SCREEN; + _nc_set_screen(sp); + rc = recur_wgetnstr(win, buf); + _nc_set_screen(save_SP); + _nc_unlock_global(curses); + } else +#endif + { + sp->_called_wgetch = TRUE; + rc = wgetnstr(win, buf, MAXCOLUMNS); + sp->_called_wgetch = FALSE; + } + } else { + rc = ERR; + } + return rc; +} + +NCURSES_EXPORT(int) +_nc_wgetch(WINDOW *win, + int *result, + int use_meta + EVENTLIST_2nd(_nc_eventlist * evl)) +{ + SCREEN *sp; int ch; + int rc = 0; +#ifdef NCURSES_WGETCH_EVENTS + int event_delay = -1; +#endif + + T((T_CALLED("_nc_wgetch(%p)"), (void *) win)); - T((T_CALLED("wgetch(%p)"), win)); + *result = 0; - if (!win) + sp = _nc_screen_of(win); + if (win == 0 || sp == 0) { returnCode(ERR); + } if (cooked_key_in_fifo()) { - if (wgetch_should_refresh(win)) - wrefresh(win); - - ch = fifo_pull(); - T(("wgetch returning (pre-cooked): %#x = %s", ch, _trace_key(ch))); - returnCode(ch); + recur_wrefresh(win); + *result = fifo_pull(sp); + returnCode(*result >= KEY_MIN ? KEY_CODE_YES : OK); } +#ifdef NCURSES_WGETCH_EVENTS + if (evl && (evl->count == 0)) + evl = NULL; + event_delay = _nc_eventlist_timeout(evl); +#endif /* * Handle cooked mode. Grab a string from the screen, * stuff its contents in the FIFO queue, and pop off * the first character to return it. */ - if (head == -1 && !SP->_raw && !SP->_cbreak) { - char buf[MAXCOLUMNS], *sp; - - T(("filling queue in cooked mode")); + if (head == -1 && + !sp->_notty && + !sp->_raw && + !sp->_cbreak && + !sp->_called_wgetch) { + char buf[MAXCOLUMNS], *bufp; - wgetnstr(win, buf, MAXCOLUMNS); + TR(TRACE_IEVENT, ("filling queue in cooked mode")); /* ungetch in reverse order */ - ungetch('\n'); - for (sp = buf + strlen(buf); sp > buf; sp--) - ungetch(sp[-1]); +#ifdef NCURSES_WGETCH_EVENTS + rc = recur_wgetnstr(win, buf); + if (rc != KEY_EVENT && rc != ERR) + safe_ungetch(sp, '\n'); +#else + if (recur_wgetnstr(win, buf) != ERR) + safe_ungetch(sp, '\n'); +#endif + for (bufp = buf + strlen(buf); bufp > buf; bufp--) + safe_ungetch(sp, bufp[-1]); - returnCode(fifo_pull()); +#ifdef NCURSES_WGETCH_EVENTS + /* Return it first */ + if (rc == KEY_EVENT) { + *result = rc; + } else +#endif + *result = fifo_pull(sp); + returnCode(*result >= KEY_MIN ? KEY_CODE_YES : OK); } - if (wgetch_should_refresh(win)) - wrefresh(win); + if (win->_use_keypad != sp->_keypad_on) + _nc_keypad(sp, win->_use_keypad); - if (!win->_notimeout && (win->_delay >= 0 || SP->_cbreak > 1)) { - int delay; + recur_wrefresh(win); - T(("timed delay in wgetch()")); - if (SP->_cbreak > 1) - delay = (SP->_cbreak - 1) * 100; - else - delay = win->_delay; + if (win->_notimeout || (win->_delay >= 0) || (sp->_cbreak > 1)) { + if (head == -1) { /* fifo is empty */ + int delay; - T(("delay is %d milliseconds", delay)); + TR(TRACE_IEVENT, ("timed delay in wgetch()")); + if (sp->_cbreak > 1) + delay = (sp->_cbreak - 1) * 100; + else + delay = win->_delay; - if (head == -1) /* fifo is empty */ - if (!_nc_timed_wait(3, delay, (int *) 0)) - returnCode(ERR); +#ifdef NCURSES_WGETCH_EVENTS + if (event_delay >= 0 && delay > event_delay) + delay = event_delay; +#endif + + TR(TRACE_IEVENT, ("delay is %d milliseconds", delay)); + + rc = check_mouse_activity(sp, delay EVENTLIST_2nd(evl)); + +#ifdef NCURSES_WGETCH_EVENTS + if (rc & TW_EVENT) { + *result = KEY_EVENT; + returnCode(KEY_CODE_YES); + } +#endif + if (!rc) { + goto check_sigwinch; + } + } /* else go on to read data available */ } @@ -270,40 +522,63 @@ wgetch(WINDOW *win) int runcount = 0; do { - ch = kgetch(win); + ch = kgetch(sp, win->_notimeout EVENTLIST_2nd(evl)); if (ch == KEY_MOUSE) { ++runcount; - if (SP->_mouse_inline(SP)) + if (sp->_mouse_inline(sp)) break; } + if (sp->_maxclick < 0) + break; } while (ch == KEY_MOUSE - && (_nc_timed_wait(3, SP->_maxclick, (int *) 0) - || !SP->_mouse_parse(runcount))); + && (((rc = check_mouse_activity(sp, sp->_maxclick + EVENTLIST_2nd(evl))) != 0 + && !(rc & TW_EVENT)) + || !sp->_mouse_parse(sp, runcount))); +#ifdef NCURSES_WGETCH_EVENTS + if ((rc & TW_EVENT) && !(ch == KEY_EVENT)) { + safe_ungetch(sp, ch); + ch = KEY_EVENT; + } +#endif if (runcount > 0 && ch != KEY_MOUSE) { - /* mouse event sequence ended by keystroke, push it */ - ungetch(ch); - ch = KEY_MOUSE; +#ifdef NCURSES_WGETCH_EVENTS + /* mouse event sequence ended by an event, report event */ + if (ch == KEY_EVENT) { + safe_ungetch(sp, KEY_MOUSE); /* FIXME This interrupts a gesture... */ + } else +#endif + { + /* mouse event sequence ended by keystroke, store keystroke */ + safe_ungetch(sp, ch); + ch = KEY_MOUSE; + } } } else { if (head == -1) - fifo_push(); - ch = fifo_pull(); + fifo_push(sp EVENTLIST_2nd(evl)); + ch = fifo_pull(sp); } if (ch == ERR) { + check_sigwinch: #if USE_SIZECHANGE - if (SP->_sig_winch) { - _nc_update_screensize(); + if (_nc_handle_sigwinch(sp)) { + _nc_update_screensize(sp); /* resizeterm can push KEY_RESIZE */ if (cooked_key_in_fifo()) { - ch = fifo_pull(); - T(("wgetch returning (pre-cooked): %#x = %s", ch, _trace_key(ch))); - returnCode(ch); + *result = fifo_pull(sp); + /* + * Get the ERR from queue -- it is from WINCH, + * so we should take it out, the "error" is handled. + */ + if (fifo_peek(sp) == -1) + fifo_pull(sp); + returnCode(*result >= KEY_MIN ? KEY_CODE_YES : OK); } } #endif - T(("wgetch returning ERR")); returnCode(ERR); } @@ -314,7 +589,7 @@ wgetch(WINDOW *win) * * If carriage return is defined as a function key in the * terminfo, e.g., kent, then Solaris may return either ^J (or ^M - * if nonl() is set) or KEY_ENTER depending on the echo() mode. + * if nonl() is set) or KEY_ENTER depending on the echo() mode. * We echo before translating carriage return based on nonl(), * since the visual result simply moves the cursor to column 0. * @@ -325,8 +600,8 @@ wgetch(WINDOW *win) * However, we provide the same visual result as Solaris, moving the * cursor to the left. */ - if (SP->_echo && !(win->_flags & _ISPAD)) { - chtype backup = (ch == KEY_BACKSPACE) ? '\b' : ch; + if (sp->_echo && !(win->_flags & _ISPAD)) { + chtype backup = (chtype) ((ch == KEY_BACKSPACE) ? '\b' : ch); if (backup < KEY_MIN) wechochar(win, backup); } @@ -334,7 +609,7 @@ wgetch(WINDOW *win) /* * Simulate ICRNL mode */ - if ((ch == '\r') && SP->_nl) + if ((ch == '\r') && sp->_nl) ch = '\n'; /* Strip 8th-bit if so desired. We do this only for characters that @@ -342,13 +617,48 @@ wgetch(WINDOW *win) * that display only 7-bit characters. Note that 'ch' may be a * function key at this point, so we mustn't strip _those_. */ - if ((ch < KEY_MIN) && (ch & 0x80)) - if (!SP->_use_meta) + if (!use_meta) + if ((ch < KEY_MIN) && (ch & 0x80)) ch &= 0x7f; - T(("wgetch returning : %#x = %s", ch, _trace_key(ch))); + T(("wgetch returning : %s", _nc_tracechar(sp, ch))); + + *result = ch; + returnCode(ch >= KEY_MIN ? KEY_CODE_YES : OK); +} + +#ifdef NCURSES_WGETCH_EVENTS +NCURSES_EXPORT(int) +wgetch_events(WINDOW *win, _nc_eventlist * evl) +{ + int code; + int value; + + T((T_CALLED("wgetch_events(%p,%p)"), (void *) win, (void *) evl)); + code = _nc_wgetch(win, + &value, + _nc_use_meta(win) + EVENTLIST_2nd(evl)); + if (code != ERR) + code = value; + returnCode(code); +} +#endif - returnCode(ch); +NCURSES_EXPORT(int) +wgetch(WINDOW *win) +{ + int code; + int value; + + T((T_CALLED("wgetch(%p)"), (void *) win)); + code = _nc_wgetch(win, + &value, + _nc_use_meta(win) + EVENTLIST_2nd((_nc_eventlist *) 0)); + if (code != ERR) + code = value; + returnCode(code); } /* @@ -361,71 +671,94 @@ wgetch(WINDOW *win) ** sequence is received by the time the alarm goes off, pass through ** the sequence gotten so far. ** -** This function must be called when there is no cooked keys in queue. +** This function must be called when there are no cooked keys in queue. ** (that is head==-1 || peek==head) ** */ static int -kgetch(WINDOW *win GCC_UNUSED) +kgetch(SCREEN *sp, bool forever EVENTLIST_2nd(_nc_eventlist * evl)) { - struct tries *ptr; + TRIES *ptr; int ch = 0; - int timeleft = ESCDELAY; + int timeleft = forever ? 9999999 : GetEscdelay(sp); - TR(TRACE_IEVENT, ("kgetch(%p) called", win)); + TR(TRACE_IEVENT, ("kgetch() called")); - ptr = SP->_keytry; + ptr = sp->_keytry; for (;;) { - if (!raw_key_in_fifo()) { - if (fifo_push() == ERR) { + if (cooked_key_in_fifo() && sp->_fifo[head] >= KEY_MIN) { + break; + } else if (!raw_key_in_fifo()) { + ch = fifo_push(sp EVENTLIST_2nd(evl)); + if (ch == ERR) { peek = head; /* the keys stay uninterpreted */ return ERR; } +#ifdef NCURSES_WGETCH_EVENTS + else if (ch == KEY_EVENT) { + peek = head; /* the keys stay uninterpreted */ + return fifo_pull(sp); /* Remove KEY_EVENT from the queue */ + } +#endif } - ch = fifo_peek(); + + ch = fifo_peek(sp); if (ch >= KEY_MIN) { + /* If not first in queue, somebody put this key there on purpose in + * emergency. Consider it higher priority than the unfinished + * keysequence we are parsing. + */ peek = head; /* assume the key is the last in fifo */ t_dec(); /* remove the key */ return ch; } - TR(TRACE_IEVENT, ("ch: %s", _trace_key((unsigned char) ch))); + TR(TRACE_IEVENT, ("ch: %s", _nc_tracechar(sp, (unsigned char) ch))); while ((ptr != NULL) && (ptr->ch != (unsigned char) ch)) ptr = ptr->sibling; -#ifdef TRACE + if (ptr == NULL) { TR(TRACE_IEVENT, ("ptr is null")); - } else - TR(TRACE_IEVENT, ("ptr=%p, ch=%d, value=%d", - ptr, ptr->ch, ptr->value)); -#endif /* TRACE */ - - if (ptr == NULL) break; + } + TR(TRACE_IEVENT, ("ptr=%p, ch=%d, value=%d", + (void *) ptr, ptr->ch, ptr->value)); if (ptr->value != 0) { /* sequence terminated */ TR(TRACE_IEVENT, ("end of sequence")); - if (peek == tail) - fifo_clear(); - else + if (peek == tail) { + fifo_clear(sp); + } else { head = peek; + } return (ptr->value); } ptr = ptr->child; if (!raw_key_in_fifo()) { + int rc; + TR(TRACE_IEVENT, ("waiting for rest of sequence")); - if (!_nc_timed_wait(3, timeleft, &timeleft)) { + rc = check_mouse_activity(sp, timeleft EVENTLIST_2nd(evl)); +#ifdef NCURSES_WGETCH_EVENTS + if (rc & TW_EVENT) { + TR(TRACE_IEVENT, ("interrupted by a user event")); + /* FIXME Should have preserved remainder timeleft for reuse... */ + peek = head; /* Restart interpreting later */ + return KEY_EVENT; + } +#endif + if (!rc) { TR(TRACE_IEVENT, ("ran out of time")); break; } } } - ch = fifo_pull(); + ch = fifo_pull(sp); peek = head; return ch; }