OpenSolaris_b135/lib/libcurses/screen/tgetch.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/* Copyright (c) 1988 AT&T */
/* All Rights Reserved */
/*
* University Copyright- Copyright (c) 1982, 1986, 1988
* The Regents of the University of California
* All Rights Reserved
*
* University Acknowledgment- Portions of this document are derived from
* software developed by the University of California, Berkeley, and its
* contributors.
*/
/*LINTLIBRARY*/
#include "curses_inc.h"
#include <signal.h>
#include <unistd.h>
#ifdef DEBUG
#include <ctype.h>
#endif /* DEBUG */
/*
* Read a key typed from the terminal
*
* interpret: = 0 for single-char key only
* = 1 for matching function key and macro patterns.
* = 2 same as 1 but no time-out for funckey matching.
*/
static int _getkey(int, chtype *);
static int _fpk(void);
static int _pk(void);
chtype
tgetch(int interpret)
{
int i = 0, j, collapse = 1;
#define WAIT3 333
chtype inp;
chtype *inputQ = cur_term->_input_queue;
char *chars_onQ = &(cur_term->_chars_on_queue);
#ifdef SYSV
/*
* Register the fact that getch is being used so
* that typeahead checking can be done.
* This code should GO AWAY when a poll() or FIONREAD can
* be done on the file descriptor as then the check
* will be non-destructive.
*/
cur_term->fl_typeahdok = TRUE;
#endif /* SYSV */
/* ask for input */
if (cur_term->_ungotten > 0) {
cur_term->_ungotten--;
/* decode an ungetch()'d character */
inp = -inputQ[0];
} else {
/* Only read a character if there is no typeahead/peekahead. */
if (*chars_onQ == 0) {
/* (*chars_onQ)++; MR */
#ifdef FIONREAD
inp = _readchar();
#else /* FIONREAD */
inp = (chtype) _pk();
if ((int)inp == ERR) {
/*
* interpret is set to 0 so that down below we don't
* drop into getkey since we already know there can't be
* a key that starts with -1. Also, we don't want to
* access funckeystarter[-1].
*/
interpret = FALSE;
}
#endif /* FIONREAD */
(*chars_onQ)++;
} else
inp = inputQ[0];
#ifdef DEBUG
if (outf)
fprintf(outf, "TGETCH read '%s'\n", unctrl(inp));
#endif /* DEBUG */
/* Check for arrow and function keys */
if (interpret && cur_term->funckeystarter[inp])
collapse = _getkey(interpret - 1, &inp);
}
/* Collapse the input queue to remove the escape */
/* sequence from the stack. */
j = *chars_onQ;
(*chars_onQ) -= collapse;
while (collapse < j)
inputQ[i++] = inputQ[collapse++];
return (inp);
}
#ifdef FIONREAD
static int
_readchar()
{
int i;
unsigned char c;
if (cur_term->_delay == 0) {
int arg;
(void) ioctl(cur_term->_inputfd, FIONREAD, &arg);
#ifdef DEBUG
if (outf)
fprintf(outf, "FIONREAD returns %d\n", arg);
#endif /* DEBUG */
if (arg < 1)
return (-1);
} else
if (cur_term->_delay > 0) {
char c;
int infd;
infd = 1 << cur_term->_inputfd;
t.tv_sec = cur_term->_delay / 1000;
t.tv_usec = (cur_term->_delay % 1000) * 1000;
i = select(20, &infd, (int *)NULL, (int *)NULL, &t);
if (i < 0)
return (ERR);
i = read(cur_term->_inputfd, &c, 1);
} else
i = read(cur_term->_inputfd, &c, 1);
#ifdef DEBUG
if (outf)
fprintf(outf, "read from %d returns %d chars, first %o\n",
cur_term->_inputfd, i, c);
#endif /* DEBUG */
if (i > 0)
return (c);
else
return (ERR);
}
#endif /* !FIONREAD */
#ifdef DEBUG
extern char *_asciify();
#endif /* DEBUG */
static int get_xterm_mouse(int, int *);
static void _map_button(chtype *);
/*
* This algorithm is a "learning" algorithm. The premise is
* that keys used once are like to be used again and again.
* Since the time for a linear search of the table is so
* expensive, we move keys that are found up to the top of
* the list, making the access to a repeated key very fast and
* keys that have been used before close to the top.
*/
static int
_getkey(int blockpeek, chtype *inp)
{
_KEY_MAP **kp = cur_term->_keys;
int key, num_keys = cur_term->_ksz;
int i;
chtype *inputQ = cur_term->_input_queue;
char *chars_onQ = &(cur_term->_chars_on_queue);
char flag = cur_term->funckeystarter[*inp];
int first, collapse = 1;
#ifdef DEBUG
if (outf)
fprintf(outf, "getkey(): looking in linear table, "
"inp=%d\n", *inp);
#endif /* DEBUG */
if (flag & _KEY)
key = 0;
else {
key = cur_term->_first_macro;
blockpeek = TRUE;
}
first = key;
for (; key < num_keys; key++) {
if (kp[key]->_sends[0] == *inp) {
for (i = 1; i < INP_QSIZE; i++) {
/* found it? */
if (kp[key]->_sends[i] == '\0')
break;
/* partial match? peek ahead. */
if (*chars_onQ == i) {
(*chars_onQ)++;
inputQ[i] = (blockpeek) ?
_pk() : _fpk();
switch ((int)inputQ[i]) {
case -2:
/*
* Since -2 signifies a timeout we don't really
* want to put it on the queue so we decrement
* our counter.
*/
(*chars_onQ)--;
#ifdef DEBUG
if (outf)
fprintf(outf, "Timed out\n");
#endif /* DEBUG */
if (flag & _MACRO) {
#ifdef DEBUG
if (outf)
fprintf(outf,
"Found macro\n");
#endif /* DEBUG */
/*
* We have to decrement one because key will be
* incremented at the bottom of the out loop.
*/
key = (first = blockpeek =
cur_term->_first_macro) -
1;
goto outerloop;
}
/*FALLTHROUGH*/
case -1:
goto ret;
}
}
/* not this one? */
if (kp[key]->_sends[i] != inputQ[i])
goto outerloop;
}
/* SS-mouse */
if (kp[key]->_keyval == KEY_MOUSE) {
MOUSE_STATUS old_mouse;
int rc;
old_mouse = Mouse_status;
/* read the mouse status information */
if (mouse_info)
rc = -3; /* NOT IMPLEMENTED */
else
rc = get_xterm_mouse(blockpeek, &i);
if (rc == -1) /* read error */
goto ret;
else if (rc == -2 || rc == -3) /* timeout */
/* or not mouse */
goto outerloop;
else if (rc == 0) /* report mouse pos */
Mouse_status.changes |= 020;
else if (rc >= 1 && rc <= 3)
/* mouse button event */
Mouse_status.changes =
(((MOUSE_X_POS != old_mouse.x ||
MOUSE_Y_POS != old_mouse.y) << 3) |
((Mouse_status.button[2] !=
old_mouse.button[2]) << 2) |
((Mouse_status.button[1] !=
old_mouse.button[1]) << 1) |
(Mouse_status.button[0] !=
old_mouse.button[0]));
}
/* We found it! Read in any chars left in _sends */
if ((collapse = i) == INP_QSIZE)
for (; kp[key]->_sends[i]; i++)
(void) _fpk();
/* move key to top of ordered list */
if (key != first) {
_KEY_MAP *savekey = kp[key];
short *lorder;
int j;
if (key > cur_term->_first_macro)
lorder = &(cur_term->_lastmacro_ordered);
else
lorder = &(cur_term->_lastkey_ordered);
/*
* If we're below the last ordered key, swap next unordered
* key with this one and ripple from there.
*/
if (key > *lorder)
kp[key] = kp[(i = ++(*lorder))];
else
i = key;
/* ripple the ordered keys down */
for (j = i--; j > first; )
kp[j--] = kp[i--];
kp[first] = savekey;
}
*inp = kp[first]->_keyval;
/*
* SS-mouse support: if mouse button event
* occured on top of the soft label, we may
* have to return the function key corresponding
* to that soft label
*/
if (*inp == KEY_MOUSE && A_BUTTON_CHANGED &&
(MOUSE_Y_POS == LINES) &&
(SP->slk != (SLK_MAP *) NULL) &&
(SP->_map_mbe_to_key != 0)) {
_map_button(inp);
}
goto ret;
}
outerloop:
;
}
ret:
/* key not found */
#ifdef DEBUG
if (outf)
if (key == num_keys)
fprintf(outf, "Did not match anything.\n");
#endif /* DEBUG */
return (collapse);
}
/* SS-mouse */
/* this function tries to read in information that follows KEY_MOUSE: */
/* the first character identifies what button is involved (1,2,or 3) */
/* if the first character is 0, we are dealing with report_mouse_pos */
/*
* The routine returns the following:
* -3: not a mouse button event
* -2: read timed out
* -1: the read failed
* [0, 1, 2, 3] - the first character in the mouse event
*/
static int
get_xterm_mouse(int blockpeek, int *i)
{
chtype *inputQ = cur_term->_input_queue; /* ??? */
/* LINTED */
chtype *chars_onQ = (chtype *) &(cur_term->_chars_on_queue);
int j, mx, my;
int char1, char2, c1, c2;
/* the first character should be 0, 1, 2, or 4 */
char1 = (inputQ[(*i)++] = (blockpeek) ? _pk() : _fpk());
/* read error or timeout */
if (char1 < 0)
return (char1);
(*chars_onQ)++;
if (char1 < '0' || char1 > '3')
return (-3);
/* if the character is 1, 2, or 3 it must be followed by */
/* P, R, C, D, or T */
if (char1 != '0') {
char2 = (inputQ[(*i)++] = (blockpeek) ? _pk() : _fpk());
if (char2 < 0)
return (char2);
(*chars_onQ)++;
if (char2 != 'P' && char2 != 'R' && char2 != 'C' &&
char2 != 'D' && char2 != 'T')
return (-3);
}
/* read X and Y coordinates of the mouse */
for (j = 0; j < 2; j++) {
c1 = (inputQ[(*i)++] = (blockpeek) ? _pk() : _fpk());
if (c1 < 0)
return (c1);
(*chars_onQ)++;
if (c1 >= ' ' && c1 <= '~') { /* ascii char */
if (j == 0)
mx = c1 - ' ';
else
my = c1 - ' ';
} else if (char1 == 01 || char1 == 02) { /* ^A || ^B */
c2 = (inputQ[(*i)++] = (blockpeek) ? _pk() : _fpk());
if (c2 < 0)
return (c2);
(*chars_onQ)++;
if (c2 >= ' ' && c2 <= '~') {
if (j == 0)
mx = c1 * (c2 - ' ');
else
my = c1 * (c2 - ' ');
} else
return (-3);
} else
return (-3);
}
/* read complete mouse event: update the Mouse_status structure */
MOUSE_X_POS = mx;
MOUSE_Y_POS = my;
j = char1 - '0';
if (j != 0) {
switch (char2) {
case 'P':
BUTTON_STATUS(j) = BUTTON_PRESSED;
break;
case 'R':
BUTTON_STATUS(j) = BUTTON_RELEASED;
break;
case 'C':
BUTTON_STATUS(j) = BUTTON_CLICKED;
break;
case 'D':
BUTTON_STATUS(j) = BUTTON_DOUBLE_CLICKED;
break;
case 'T':
BUTTON_STATUS(j) = BUTTON_TRIPLE_CLICKED;
break;
}
}
return (j);
}
/* SS-mouse-end */
/*
* Fast peek key. Like getchar but if the right flags are set, times out
* quickly if there is nothing waiting, returning -1.
* f is an output stdio descriptor, we read from the fileno.
* We wait for long enough for a terminal to send another character
* (at 15cps repeat rate, this is 67 ms, I'm using 100ms to allow
* a bit of a fudge factor) and time out more quickly.
* -2 is returned if we time out, -1 is returned if interrupted, and the
* character is returned otherwise.
*/
#ifndef FIONREAD
/*
* Traditional implementation. The best resolution we have is 1 second,
* so we set a 1 second alarm and try to read. If we fail for 1 second,
* we assume there is no key waiting. Problem here is that 1 second is
* too long; people can type faster than this.
*
* Another possible implementation of changing VMIN/VTIME before and
* after each read does not work because the tty driver's timeout
* mechanism is too unreliable when the timeouts are changed too quickly.
*/
static char sig_caught;
static
#ifdef SIGPOLL /* Vr3 and beyond */
void
#endif /* SIGPOLL */
/* The following line causes a lint warning for "dummy" which is not used. */
_catch_alarm(int dummy)
{
sig_caught = 1;
}
static int
_fpk(void)
{
unsigned char c;
int infd = cur_term->_inputfd;
ssize_t rc;
#ifdef SIGPOLL /* Vr3 and beyond */
void (*oldsig)(int);
#else /* SIGPOLL */
int (*oldsig)(int);
#endif /* SIGPOLL */
unsigned int oldalarm, alarm(unsigned);
/* turn off any user alarms and set our own */
oldalarm = alarm(0);
sig_caught = 0;
oldsig = signal(SIGALRM, _catch_alarm);
(void) alarm(1);
rc = read(cur_term->_inputfd, (char *)&c, 1);
(void) alarm(0);
/*
* This code is to take care of the possibility of
* the process getting swapped out in the middle of
* read() call above. The interrupt will cause the
* read() call to retur, even if a character is really
* on the clist. So we do a non-blocking read() to make
* sure that there really isn't a character there.
*/
if (sig_caught && rc != 1)
if (cur_term->_check_fd != -1)
rc = read(cur_term->_check_fd, (char *)&c, 1);
else {
#include <fcntl.h>
int fcflags = fcntl(infd, F_GETFL, 0);
(void) fcntl(infd, F_SETFL, fcflags | O_NDELAY);
rc = read(infd, (char *)&c, 1);
(void) fcntl(infd, F_SETFL, fcflags);
}
/* restore the user alarms */
(void) signal(SIGALRM, oldsig);
if (sig_caught && oldalarm > 1)
oldalarm--;
(void) alarm(oldalarm);
if (rc == 1) /* got a character */
return (c);
else
if (sig_caught) /* timed out */
return (-2);
else /* EOF or got interrupted */
return (-1);
}
#else /* FIONREAD */
/*
* If we have the select system call, we can do much better than the
* traditional method. Even if we don't have the real 4.2BSD select, we
* can emulate it with napms and FIONREAD. napms might be done with only
* 1 second resolution, but this is no worse than what we have in the
* traditional implementation.
*/
static
_fpk()
{
int infd, rc;
int *outfd, *exfd;
unsigned char c;
struct timeval t;
infd = 1 << cur_term->_inputfd;
outfd = exfd = (int *)NULL;
t.tv_sec = 0;
t.tv_usec = 100000; /* 100 milliseconds */
rc = select(20, &infd, outfd, exfd, &t);
if (rc < 0)
return (-2);
rc = read(fileno(f), &c, 1);
return (rc == 1 ? c : -1);
}
#endif /* FIONREAD */
/*
* Plain peekchar function. Nothing fancy. This is just like _fpk
* but will wait forever rather than time out.
*/
static int
_pk(void)
{
unsigned char c;
return ((read(cur_term->_inputfd, (char *)&c, 1) == 1) ? c : ERR);
}
/*
* SS-mouse: check if this mouse button event should map into
* function key
*/
static void
_map_button(chtype *inp)
{
SLK_MAP *slk = SP->slk;
int num = slk->_num;
int len = slk->_len;
int i;
/* first determine if this mouse button event should be */
/* mapped into function key */
if (!(SP->_map_mbe_to_key &
((BUTTON_CHANGED(3) << (10 + BUTTON_STATUS(3))) |
(BUTTON_CHANGED(2) << (5 + BUTTON_STATUS(2))) |
(BUTTON_CHANGED(1) << BUTTON_STATUS(1)))))
return;
for (i = 0; i < num; i++) {
if (MOUSE_X_POS < slk->_labx[i])
break;
if (MOUSE_X_POS > slk->_labx[i] + len)
continue;
*inp = KEY_F(1) + i;
break;
}
}