4f85a1eb76
Change-Id: If881ec130833c7e7e62caa3d31e350a531f5bc8e Signed-off-by: Stefan Reinauer <stefan.reinauer@coreboot.org> Reviewed-on: http://review.coreboot.org/12398 Tested-by: build bot (Jenkins) Reviewed-by: Patrick Georgi <pgeorgi@google.com>
322 lines
8.0 KiB
C
322 lines
8.0 KiB
C
/* Public Domain Curses */
|
|
|
|
#include <curspriv.h>
|
|
|
|
RCSID("$Id: inopts.c,v 1.43 2008/07/13 16:08:18 wmcbrine Exp $")
|
|
|
|
/*man-start**************************************************************
|
|
|
|
Name: inopts
|
|
|
|
Synopsis:
|
|
int cbreak(void);
|
|
int nocbreak(void);
|
|
int echo(void);
|
|
int noecho(void);
|
|
int halfdelay(int tenths);
|
|
int intrflush(WINDOW *win, bool bf);
|
|
int keypad(WINDOW *win, bool bf);
|
|
int meta(WINDOW *win, bool bf);
|
|
int nl(void);
|
|
int nonl(void);
|
|
int nodelay(WINDOW *win, bool bf);
|
|
int notimeout(WINDOW *win, bool bf);
|
|
int raw(void);
|
|
int noraw(void);
|
|
void noqiflush(void);
|
|
void qiflush(void);
|
|
void timeout(int delay);
|
|
void wtimeout(WINDOW *win, int delay);
|
|
int typeahead(int fildes);
|
|
|
|
int crmode(void);
|
|
int nocrmode(void);
|
|
|
|
Description:
|
|
cbreak() and nocbreak() toggle cbreak mode. In cbreak mode,
|
|
characters typed by the user are made available immediately, and
|
|
erase/kill character processing is not performed. In nocbreak
|
|
mode, typed characters are buffered until a newline or carriage
|
|
return. Interrupt and flow control characters are unaffected by
|
|
this mode. PDCurses always starts in cbreak mode.
|
|
|
|
echo() and noecho() control whether typed characters are echoed
|
|
by the input routine. Initially, input characters are echoed.
|
|
Subsequent calls to echo() and noecho() do not flush type-ahead.
|
|
|
|
halfdelay() is similar to cbreak(), but allows for a time limit
|
|
to be specified, in tenths of a second. This causes getch() to
|
|
block for that period before returning ERR if no key has been
|
|
received. tenths must be between 1 and 255.
|
|
|
|
keypad() controls whether getch() returns function/special keys
|
|
as single key codes (e.g., the left arrow key as KEY_LEFT). Per
|
|
X/Open, the default for keypad mode is OFF. You'll probably want
|
|
it on. With keypad mode off, if a special key is pressed,
|
|
getch() does nothing or returns ERR.
|
|
|
|
nodelay() controls whether wgetch() is a non-blocking call. If
|
|
the option is enabled, and no input is ready, wgetch() will
|
|
return ERR. If disabled, wgetch() will hang until input is
|
|
ready.
|
|
|
|
nl() enables the translation of a carriage return into a newline
|
|
on input. nonl() disables this. Initially, the translation does
|
|
occur.
|
|
|
|
raw() and noraw() toggle raw mode. Raw mode is similar to cbreak
|
|
mode, in that characters typed are immediately passed through to
|
|
the user program. The difference is that in raw mode, the INTR,
|
|
QUIT, SUSP, and STOP characters are passed through without being
|
|
interpreted, and without generating a signal.
|
|
|
|
In PDCurses, the meta() function sets raw mode on or off.
|
|
|
|
timeout() and wtimeout() set blocking or non-blocking reads for
|
|
the specified window. The delay is measured in milliseconds. If
|
|
it's negative, a blocking read is used; if zero, then non-
|
|
blocking reads are done -- if no input is waiting, ERR is
|
|
returned immediately. If the delay is positive, the read blocks
|
|
for the delay period; if the period expires, ERR is returned.
|
|
|
|
intrflush(), notimeout(), noqiflush(), qiflush() and typeahead()
|
|
do nothing in PDCurses, but are included for compatibility with
|
|
other curses implementations.
|
|
|
|
crmode() and nocrmode() are archaic equivalents to cbreak() and
|
|
nocbreak(), respectively.
|
|
|
|
Return Value:
|
|
All functions return OK on success and ERR on error.
|
|
|
|
Portability X/Open BSD SYS V
|
|
cbreak Y Y Y
|
|
nocbreak Y Y Y
|
|
echo Y Y Y
|
|
noecho Y Y Y
|
|
halfdelay Y - Y
|
|
intrflush Y - Y
|
|
keypad Y - Y
|
|
meta Y - Y
|
|
nl Y Y Y
|
|
nonl Y Y Y
|
|
nodelay Y - Y
|
|
notimeout Y - Y
|
|
raw Y Y Y
|
|
noraw Y Y Y
|
|
noqiflush Y - Y
|
|
qiflush Y - Y
|
|
timeout Y - Y
|
|
wtimeout Y - Y
|
|
typeahead Y - Y
|
|
crmode -
|
|
nocrmode -
|
|
|
|
**man-end****************************************************************/
|
|
|
|
int cbreak(void)
|
|
{
|
|
PDC_LOG(("cbreak() - called\n"));
|
|
|
|
SP->cbreak = TRUE;
|
|
|
|
return OK;
|
|
}
|
|
|
|
int nocbreak(void)
|
|
{
|
|
PDC_LOG(("nocbreak() - called\n"));
|
|
|
|
SP->cbreak = FALSE;
|
|
SP->delaytenths = 0;
|
|
|
|
return OK;
|
|
}
|
|
|
|
int echo(void)
|
|
{
|
|
PDC_LOG(("echo() - called\n"));
|
|
|
|
SP->echo = TRUE;
|
|
|
|
return OK;
|
|
}
|
|
|
|
int noecho(void)
|
|
{
|
|
PDC_LOG(("noecho() - called\n"));
|
|
|
|
SP->echo = FALSE;
|
|
|
|
return OK;
|
|
}
|
|
|
|
int halfdelay(int tenths)
|
|
{
|
|
PDC_LOG(("halfdelay() - called\n"));
|
|
|
|
if (tenths < 1 || tenths > 255)
|
|
return ERR;
|
|
|
|
SP->delaytenths = tenths;
|
|
|
|
return OK;
|
|
}
|
|
|
|
int intrflush(WINDOW *win, bool bf)
|
|
{
|
|
PDC_LOG(("intrflush() - called\n"));
|
|
|
|
return OK;
|
|
}
|
|
|
|
int keypad(WINDOW *win, bool bf)
|
|
{
|
|
PDC_LOG(("keypad() - called\n"));
|
|
|
|
if (!win)
|
|
return ERR;
|
|
|
|
win->_use_keypad = bf;
|
|
|
|
return OK;
|
|
}
|
|
|
|
int meta(WINDOW *win, bool bf)
|
|
{
|
|
PDC_LOG(("meta() - called\n"));
|
|
|
|
SP->raw_inp = bf;
|
|
|
|
return OK;
|
|
}
|
|
|
|
int nl(void)
|
|
{
|
|
PDC_LOG(("nl() - called\n"));
|
|
|
|
SP->autocr = TRUE;
|
|
|
|
return OK;
|
|
}
|
|
|
|
int nonl(void)
|
|
{
|
|
PDC_LOG(("nonl() - called\n"));
|
|
|
|
SP->autocr = FALSE;
|
|
|
|
return OK;
|
|
}
|
|
|
|
int nodelay(WINDOW *win, bool flag)
|
|
{
|
|
PDC_LOG(("nodelay() - called\n"));
|
|
|
|
if (!win)
|
|
return ERR;
|
|
|
|
win->_nodelay = flag;
|
|
|
|
return OK;
|
|
}
|
|
|
|
int notimeout(WINDOW *win, bool flag)
|
|
{
|
|
PDC_LOG(("notimeout() - called\n"));
|
|
|
|
return OK;
|
|
}
|
|
|
|
int raw(void)
|
|
{
|
|
PDC_LOG(("raw() - called\n"));
|
|
|
|
PDC_set_keyboard_binary(TRUE);
|
|
SP->raw_inp = TRUE;
|
|
|
|
return OK;
|
|
}
|
|
|
|
int noraw(void)
|
|
{
|
|
PDC_LOG(("noraw() - called\n"));
|
|
|
|
PDC_set_keyboard_binary(FALSE);
|
|
SP->raw_inp = FALSE;
|
|
|
|
return OK;
|
|
}
|
|
|
|
void noqiflush(void)
|
|
{
|
|
PDC_LOG(("noqiflush() - called\n"));
|
|
}
|
|
|
|
void qiflush(void)
|
|
{
|
|
PDC_LOG(("qiflush() - called\n"));
|
|
}
|
|
|
|
int typeahead(int fildes)
|
|
{
|
|
PDC_LOG(("typeahead() - called\n"));
|
|
|
|
return OK;
|
|
}
|
|
|
|
void wtimeout(WINDOW *win, int delay)
|
|
{
|
|
PDC_LOG(("wtimeout() - called\n"));
|
|
|
|
if (!win)
|
|
return;
|
|
|
|
if (delay < 0)
|
|
{
|
|
/* This causes a blocking read on the window, so turn on delay
|
|
mode */
|
|
|
|
win->_nodelay = FALSE;
|
|
win->_delayms = 0;
|
|
}
|
|
else if (!delay)
|
|
{
|
|
/* This causes a non-blocking read on the window, so turn off
|
|
delay mode */
|
|
|
|
win->_nodelay = TRUE;
|
|
win->_delayms = 0;
|
|
}
|
|
else
|
|
{
|
|
/* This causes the read on the window to delay for the number of
|
|
milliseconds. Also forces the window into non-blocking read
|
|
mode */
|
|
|
|
/*win->_nodelay = TRUE;*/
|
|
win->_delayms = delay;
|
|
}
|
|
}
|
|
|
|
void timeout(int delay)
|
|
{
|
|
PDC_LOG(("timeout() - called\n"));
|
|
|
|
wtimeout(stdscr, delay);
|
|
}
|
|
|
|
int crmode(void)
|
|
{
|
|
PDC_LOG(("crmode() - called\n"));
|
|
|
|
return cbreak();
|
|
}
|
|
|
|
int nocrmode(void)
|
|
{
|
|
PDC_LOG(("nocrmode() - called\n"));
|
|
|
|
return nocbreak();
|
|
}
|