NCURSES_SP_NAME(_nc_get_tty_mode) (NCURSES_SP_DCLx TTY * buf)
{
int result = OK;
if (buf == 0 || SP_PARM == 0) {
result = ERR;
} else {
TERMINAL *termp = TerminalOf(SP_PARM);
if (0 == termp) {
result = ERR;
} else {
#ifdef USE_TERM_DRIVER
result = CallDriver_2(SP_PARM, sgmode, FALSE, buf);
#else
for (;;) {
if (GET_TTY(termp->Filedes, buf) != 0) {
if (errno == EINTR)
continue;
result = ERR;
}
break;
}
#endif
}
if (result == ERR)
memset(buf, 0, sizeof(*buf));
TR(TRACE_BITS, ("_nc_get_tty_mode(%d): %s",
termp ? termp->Filedes : -1,
_nc_trace_ttymode(buf)));
}
return (result);
}
NCURSES_SP_NAME(tgetnum) (NCURSES_SP_DCLx NCURSES_CONST char *id)
{
int result = ABSENT_NUMERIC;
int i, j;
T((T_CALLED("tgetnum(%p, %s)"), (void *) SP_PARM, id));
if (HasTInfoTerminal(SP_PARM)) {
TERMTYPE *tp = &(TerminalOf(SP_PARM)->type);
struct name_table_entry const *entry_ptr;
entry_ptr = _nc_find_type_entry(id, NUMBER, TRUE);
if (entry_ptr != 0) {
j = entry_ptr->nte_index;
}
#if NCURSES_XNAMES
else {
j = -1;
for_each_ext_number(i, tp) {
const char *capname = ExtNumname(tp, i, numcodes);
if (same_tcname(id, capname)) {
j = i;
break;
}
}
}
#endif
if (j >= 0) {
if (VALID_NUMERIC(tp->Numbers[j]))
result = tp->Numbers[j];
}
}
returnCode(result);
}
NCURSES_SP_NAME(def_prog_mode) (NCURSES_SP_DCL0)
{
int rc = ERR;
TERMINAL *termp = TerminalOf(SP_PARM);
T((T_CALLED("def_prog_mode(%p)"), (void *) SP_PARM));
if (termp != 0) {
#ifdef USE_TERM_DRIVER
rc = CallDriver_2(SP_PARM, mode, TRUE, TRUE);
#else
/*
* Turn off the XTABS bit in the tty structure if it was on.
*/
if (_nc_get_tty_mode(&termp->Nttyb) == OK) {
#ifdef TERMIOS
termp->Nttyb.c_oflag &= (unsigned) (~OFLAGS_TABS);
#else
termp->Nttyb.sg_flags &= (unsigned) (~XTABS);
#endif
rc = OK;
}
#endif
}
returnCode(rc);
}
NCURSES_SP_NAME(tigetstr) (NCURSES_SP_DCLx NCURSES_CONST char *str)
{
char *result = CANCELLED_STRING;
int j = -1;
T((T_CALLED("tigetstr(%p, %s)"), (void *) SP_PARM, str));
if (HasTInfoTerminal(SP_PARM)) {
TERMTYPE *tp = &(TerminalOf(SP_PARM)->type);
struct name_table_entry const *entry_ptr;
entry_ptr = _nc_find_type_entry(str, STRING, FALSE);
if (entry_ptr != 0) {
j = entry_ptr->nte_index;
}
#if NCURSES_XNAMES
else {
int i;
for_each_ext_string(i, tp) {
const char *capname = ExtStrname(tp, i, strnames);
if (same_name(str, capname)) {
j = i;
break;
}
}
}
#endif
if (j >= 0) {
/* note: setupterm forces cancelled strings to null */
result = tp->Strings[j];
}
}
returnPtr(result);
}
NCURSES_SP_NAME(tigetflag) (NCURSES_SP_DCLx NCURSES_CONST char *str)
{
int result = ABSENT_BOOLEAN;
int j = -1;
T((T_CALLED("tigetflag(%p, %s)"), (void *) SP_PARM, str));
if (HasTInfoTerminal(SP_PARM)) {
TERMTYPE *tp = &(TerminalOf(SP_PARM)->type);
struct name_table_entry const *entry_ptr;
entry_ptr = _nc_find_type_entry(str, BOOLEAN, FALSE);
if (entry_ptr != 0) {
j = entry_ptr->nte_index;
}
#if NCURSES_XNAMES
else {
int i;
for_each_ext_boolean(i, tp) {
const char *capname = ExtBoolname(tp, i, boolnames);
if (same_name(str, capname)) {
j = i;
break;
}
}
}
#endif
if (j >= 0) {
/* note: setupterm forces invalid booleans to false */
result = tp->Booleans[j];
}
}
returnCode(result);
}
/*
* SVr4/XSI Curses specify that hardware echo is turned off in initscr, and not
* restored during the curses session. The library simulates echo in software.
* (The behavior is unspecified if the application enables hardware echo).
*
* The newterm function also initializes terminal settings, and since initscr
* is supposed to behave as if it calls newterm, we do it here.
*/
static NCURSES_INLINE int
_nc_initscr(NCURSES_SP_DCL0)
{
int result = ERR;
TERMINAL *term = TerminalOf(SP_PARM);
/* for extended XPG4 conformance requires cbreak() at this point */
/* (SVr4 curses does this anyway) */
if (NCURSES_SP_NAME(cbreak) (NCURSES_SP_ARG) == OK) {
TTY buf;
buf = term->Nttyb;
#ifdef TERMIOS
buf.c_lflag &= ~(ECHO | ECHONL);
buf.c_iflag &= ~(ICRNL | INLCR | IGNCR);
buf.c_oflag &= ~(ONLCR);
#elif HAVE_SGTTY_H
buf.sg_flags &= ~(ECHO | CRMOD);
#else
memset(&buf, 0, sizeof(buf));
#endif
result = NCURSES_SP_NAME(_nc_set_tty_mode) (NCURSES_SP_ARGx &buf);
if (result == OK)
term->Nttyb = buf;
}
return result;
}
NCURSES_SP_NAME(tgetflag) (NCURSES_SP_DCLx NCURSES_CONST char *id)
{
int result = 0; /* Solaris returns zero for missing flag */
T((T_CALLED("tgetflag(%p, %s)"), (void *) SP_PARM, id));
if (HasTInfoTerminal(SP_PARM) && ValidCap(id)) {
TERMTYPE2 *tp = &TerminalType(TerminalOf(SP_PARM));
struct name_table_entry const *entry_ptr;
int j = -1;
entry_ptr = _nc_find_type_entry(id, BOOLEAN, TRUE);
if (entry_ptr != 0) {
j = entry_ptr->nte_index;
}
#if NCURSES_XNAMES
else {
int i;
for_each_ext_boolean(i, tp) {
const char *capname = ExtBoolname(tp, i, boolcodes);
if (same_tcname(id, capname) && ValidExt(capname)) {
j = i;
break;
}
}
}
#endif
if (j >= 0) {
/* note: setupterm forces invalid booleans to false */
result = tp->Booleans[j];
}
}
NCURSES_SP_NAME(def_shell_mode) (NCURSES_SP_DCL0)
{
int rc = ERR;
TERMINAL *termp = TerminalOf(SP_PARM);
T((T_CALLED("def_shell_mode(%p)"), (void *) SP_PARM));
if (termp != 0) {
#ifdef USE_TERM_DRIVER
rc = CallDriver_2(SP_PARM, mode, FALSE, TRUE);
#else
/*
* If XTABS was on, remove the tab and backtab capabilities.
*/
if (_nc_get_tty_mode(&termp->Ottyb) == OK) {
#ifdef TERMIOS
if (termp->Ottyb.c_oflag & OFLAGS_TABS)
tab = back_tab = NULL;
#else
if (termp->Ottyb.sg_flags & XTABS)
tab = back_tab = NULL;
#endif
rc = OK;
}
#endif
}
returnCode(rc);
}
NCURSES_SP_NAME(termname) (NCURSES_SP_DCL0)
{
char *name = 0;
T((T_CALLED("termname()")));
#if NCURSES_SP_FUNCS
if (TerminalOf(SP_PARM) != 0) {
name = TerminalOf(SP_PARM)->_termname;
}
#else
if (cur_term != 0)
name = cur_term->_termname;
#endif
returnPtr(name);
}
NCURSES_SP_NAME(_nc_mcprint) (SCREEN *sp, char *data, int len)
{
int code = ERR;
if (0 != TerminalOf(sp))
code = CallDriver_2(sp, print, data, len);
return (code);
}
_nc_leaks_tinfo(void)
{
#if NO_LEAKS
char *s;
#endif
T((T_CALLED("_nc_free_tinfo()")));
#if NO_LEAKS
_nc_globals.leak_checking = TRUE;
_nc_free_tparm();
_nc_tgetent_leaks();
if (TerminalOf(CURRENT_SCREEN) != 0) {
del_curterm(TerminalOf(CURRENT_SCREEN));
}
_nc_forget_prescr();
_nc_comp_captab_leaks();
_nc_free_entries(_nc_head);
_nc_get_type(0);
_nc_first_name(0);
_nc_db_iterator_leaks();
_nc_keyname_leaks();
#if BROKEN_LINKER || USE_REENTRANT
_nc_names_leaks();
_nc_codes_leaks();
FreeIfNeeded(_nc_prescreen.real_acs_map);
#endif
_nc_comp_error_leaks();
if ((s = _nc_home_terminfo()) != 0)
free(s);
#ifdef TRACE
T((T_RETURN("")));
trace(0);
_nc_trace_buf(-1, (size_t) 0);
#endif
#endif /* NO_LEAKS */
returnVoid;
}
NCURSES_SP_NAME(baudrate) (NCURSES_SP_DCL0)
{
int result;
T((T_CALLED("baudrate(%p)"), (void *) SP_PARM));
/*
* In debugging, allow the environment symbol to override when we're
* redirecting to a file, so we can construct repeatable test-cases
* that take into account costs that depend on baudrate.
*/
#ifdef TRACE
if (IsValidTIScreen(SP_PARM)
&& !NC_ISATTY(fileno(SP_PARM ? SP_PARM->_ofp : stdout))
&& getenv("BAUDRATE") != 0) {
int ret;
if ((ret = _nc_getenv_num("BAUDRATE")) <= 0)
ret = 9600;
ospeed = (NCURSES_OSPEED) _nc_ospeed(ret);
returnCode(ret);
}
#endif
if (IsValidTIScreen(SP_PARM)) {
#ifdef USE_OLD_TTY
result = (int) cfgetospeed(&(TerminalOf(SP_PARM)->Nttyb));
ospeed = (NCURSES_OSPEED) _nc_ospeed(result);
#else /* !USE_OLD_TTY */
#ifdef TERMIOS
ospeed = (NCURSES_OSPEED) cfgetospeed(&(TerminalOf(SP_PARM)->Nttyb));
#else
ospeed = (NCURSES_OSPEED) TerminalOf(SP_PARM)->Nttyb.sg_ospeed;
#endif
result = _nc_baudrate(ospeed);
#endif
TerminalOf(SP_PARM)->_baudrate = result;
} else {
result = ERR;
}
returnCode(result);
}
NCURSES_SP_NAME(tgetstr) (NCURSES_SP_DCLx NCURSES_CONST char *id, char **area)
{
char *result = NULL;
int i, j;
T((T_CALLED("tgetstr(%s,%p)"), id, (void *) area));
if (HasTInfoTerminal(SP_PARM)) {
TERMTYPE *tp = &(TerminalOf(SP_PARM)->type);
struct name_table_entry const *entry_ptr;
entry_ptr = _nc_find_type_entry(id, STRING, TRUE);
if (entry_ptr != 0) {
j = entry_ptr->nte_index;
}
#if NCURSES_XNAMES
else {
j = -1;
for_each_ext_string(i, tp) {
const char *capname = ExtStrname(tp, i, strcodes);
if (same_tcname(id, capname)) {
j = i;
break;
}
}
}
#endif
if (j >= 0) {
result = tp->Strings[j];
TR(TRACE_DATABASE, ("found match : %s", _nc_visbuf(result)));
/* setupterm forces canceled strings to null */
if (VALID_STRING(result)) {
if (result == exit_attribute_mode
&& FIX_SGR0 != 0) {
result = FIX_SGR0;
TR(TRACE_DATABASE, ("altered to : %s", _nc_visbuf(result)));
}
if (area != 0
&& *area != 0) {
(void) strcpy(*area, result);
result = *area;
*area += strlen(*area) + 1;
}
}
}
}
returnPtr(result);
}
NCURSES_PUBLIC_VAR(ttytype) (void)
{
static char empty[] = "";
char *result = empty;
#if NCURSES_SP_FUNCS
if (CURRENT_SCREEN) {
TERMINAL *termp = TerminalOf(CURRENT_SCREEN);
if (termp != 0) {
result = termp->type.term_names;
}
}
#else
if (cur_term != 0) {
result = cur_term->type.term_names;
}
#endif
return result;
}
NCURSES_SP_NAME(reset_shell_mode) (NCURSES_SP_DCL0)
{
int rc = ERR;
TERMINAL *termp = TerminalOf(SP_PARM);
T((T_CALLED("reset_shell_mode(%p)"), (void *) SP_PARM));
if (termp != 0) {
#ifdef USE_TERM_DRIVER
rc = CallDriver_2(SP_PARM, mode, FALSE, FALSE);
#else
if (SP_PARM) {
_nc_keypad(SP_PARM, FALSE);
_nc_flush();
NC_BUFFERED(SP_PARM, FALSE);
}
rc = _nc_set_tty_mode(&termp->Ottyb);
#endif
}
returnCode(rc);
}
NCURSES_SP_NAME(reset_prog_mode) (NCURSES_SP_DCL0)
{
int rc = ERR;
TERMINAL *termp = TerminalOf(SP_PARM);
T((T_CALLED("reset_prog_mode(%p)"), (void *) SP_PARM));
if (termp != 0) {
#ifdef USE_TERM_DRIVER
rc = CallDriver_2(SP_PARM, mode, TRUE, FALSE);
#else
if (_nc_set_tty_mode(&termp->Nttyb) == OK) {
if (SP_PARM) {
if (SP_PARM->_keypad_on)
_nc_keypad(SP_PARM, TRUE);
NC_BUFFERED(SP_PARM, TRUE);
}
rc = OK;
}
#endif
}
returnCode(rc);
}
NCURSES_SP_NAME(_nc_set_tty_mode) (NCURSES_SP_DCLx TTY * buf)
{
int result = OK;
if (buf == 0 || SP_PARM == 0) {
result = ERR;
} else {
TERMINAL *termp = TerminalOf(SP_PARM);
if (0 == termp) {
result = ERR;
} else {
#ifdef USE_TERM_DRIVER
result = CallDriver_2(SP_PARM, sgmode, TRUE, buf);
#else
for (;;) {
if ((SET_TTY(termp->Filedes, buf) != 0)
#if USE_KLIBC_KBD
&& !isatty(termp->Filedes)
#endif
) {
if (errno == EINTR)
continue;
if ((errno == ENOTTY) && (SP_PARM != 0))
SP_PARM->_notty = TRUE;
result = ERR;
}
break;
}
#endif
}
TR(TRACE_BITS, ("_nc_set_tty_mode(%d): %s",
termp ? termp->Filedes : -1,
_nc_trace_ttymode(buf)));
}
return (result);
}
NCURSES_SP_NAME(tigetnum) (NCURSES_SP_DCLx NCURSES_CONST char *str)
{
int j = -1;
int result = CANCELLED_NUMERIC; /* Solaris returns a -1 on error */
T((T_CALLED("tigetnum(%p, %s)"), (void *) SP_PARM, str));
if (HasTInfoTerminal(SP_PARM)) {
TERMTYPE *tp = &(TerminalOf(SP_PARM)->type);
struct name_table_entry const *entry_ptr;
entry_ptr = _nc_find_type_entry(str, NUMBER, FALSE);
if (entry_ptr != 0) {
j = entry_ptr->nte_index;
}
#if NCURSES_XNAMES
else {
int i;
for_each_ext_number(i, tp) {
const char *capname = ExtNumname(tp, i, numnames);
if (same_name(str, capname)) {
j = i;
break;
}
}
}
#endif
if (j >= 0) {
if (VALID_NUMERIC(tp->Numbers[j]))
result = tp->Numbers[j];
else
result = ABSENT_NUMERIC;
}
}
returnCode(result);
}
_nc_slk_initialize(WINDOW *stwin, int cols)
{
int i;
int res = OK;
unsigned max_length;
SCREEN *sp;
TERMINAL *term;
int numlab;
T((T_CALLED("_nc_slk_initialize()")));
assert(stwin);
sp = _nc_screen_of(stwin);
if (0 == sp)
returnCode(ERR);
term = TerminalOf(SP_PARM);
assert(term);
numlab = NumLabels;
if (SP_PARM->_slk) { /* we did this already, so simply return */
returnCode(OK);
} else if ((SP_PARM->_slk = typeCalloc(SLK, 1)) == 0)
returnCode(ERR);
if (!SP_PARM->slk_format)
SP_PARM->slk_format = _nc_globals.slk_format;
/*
* If we use colors, vidputs() will suppress video attributes that conflict
* with colors. In that case, we're still guaranteed that "reverse" would
* work.
*/
if ((NoColorVideo & 1) == 0)
SetAttr(SP_PARM->_slk->attr, A_STANDOUT);
else
SetAttr(SP_PARM->_slk->attr, A_REVERSE);
SP_PARM->_slk->maxlab = ((numlab > 0)
? numlab
: MAX_SKEY(SP_PARM->slk_format));
SP_PARM->_slk->maxlen = ((numlab > 0)
? LabelWidth * LabelHeight
: MAX_SKEY_LEN(SP_PARM->slk_format));
SP_PARM->_slk->labcnt = ((SP_PARM->_slk->maxlab < MAX_SKEY(SP_PARM->slk_format))
? MAX_SKEY(SP_PARM->slk_format)
: SP_PARM->_slk->maxlab);
if (SP_PARM->_slk->maxlen <= 0
|| SP_PARM->_slk->labcnt <= 0
|| (SP_PARM->_slk->ent = typeCalloc(slk_ent,
(unsigned) SP_PARM->_slk->labcnt))
== NULL)
returnCode(slk_failed(NCURSES_SP_ARG));
max_length = SP_PARM->_slk->maxlen;
for (i = 0; i < SP_PARM->_slk->labcnt; i++) {
size_t used = max_length + 1;
SP_PARM->_slk->ent[i].ent_text = (char *) _nc_doalloc(0, used);
if (SP_PARM->_slk->ent[i].ent_text == 0)
returnCode(slk_failed(NCURSES_SP_ARG));
memset(SP_PARM->_slk->ent[i].ent_text, 0, used);
SP_PARM->_slk->ent[i].form_text = (char *) _nc_doalloc(0, used);
if (SP_PARM->_slk->ent[i].form_text == 0)
returnCode(slk_failed(NCURSES_SP_ARG));
memset(SP_PARM->_slk->ent[i].form_text, 0, used);
memset(SP_PARM->_slk->ent[i].form_text, ' ', max_length);
SP_PARM->_slk->ent[i].visible = (char) (i < SP_PARM->_slk->maxlab);
}
res = _nc_format_slks(NCURSES_SP_ARGx cols);
if ((SP_PARM->_slk->win = stwin) == NULL) {
returnCode(slk_failed(NCURSES_SP_ARG));
}
/* We now reset the format so that the next newterm has again
* per default no SLK keys and may call slk_init again to
* define a new layout. (juergen 03-Mar-1999)
*/
_nc_globals.slk_format = 0;
returnCode(res);
}
NCURSES_SP_NAME(tgetent) (NCURSES_SP_DCLx char *bufp, const char *name)
{
int rc = ERR;
int n;
bool found_cache = FALSE;
#ifdef USE_TERM_DRIVER
TERMINAL *termp = 0;
#endif
START_TRACE();
T((T_CALLED("tgetent()")));
TINFO_SETUP_TERM(&termp, (NCURSES_CONST char *) name,
STDOUT_FILENO, &rc, TRUE);
#ifdef USE_TERM_DRIVER
if (termp == 0 ||
!((TERMINAL_CONTROL_BLOCK *) termp)->drv->isTerminfo)
returnCode(rc);
#endif
/*
* In general we cannot tell if the fixed sgr0 is still used by the
* caller, but if tgetent() is called with the same buffer, that is
* good enough, since the previous data would be invalidated by the
* current call.
*
* bufp may be a null pointer, e.g., GNU termcap. That allocates data,
* which is good until the next tgetent() call. The conventional termcap
* is inconvenient because of the fixed buffer size, but because it uses
* caller-supplied buffers, can have multiple terminal descriptions in
* use at a given time.
*/
for (n = 0; n < TGETENT_MAX; ++n) {
bool same_result = (MyCache[n].last_used && MyCache[n].last_bufp == bufp);
if (same_result) {
CacheInx = n;
if (FIX_SGR0 != 0) {
FreeAndNull(FIX_SGR0);
}
/*
* Also free the terminfo data that we loaded (much bigger leak).
*/
if (LAST_TRM != 0 && LAST_TRM != TerminalOf(SP_PARM)) {
TERMINAL *trm = LAST_TRM;
NCURSES_SP_NAME(del_curterm) (NCURSES_SP_ARGx LAST_TRM);
for (CacheInx = 0; CacheInx < TGETENT_MAX; ++CacheInx)
if (LAST_TRM == trm)
LAST_TRM = 0;
CacheInx = n;
}
found_cache = TRUE;
break;
}
}
if (!found_cache) {
int best = 0;
for (CacheInx = 0; CacheInx < TGETENT_MAX; ++CacheInx) {
if (LAST_SEQ < MyCache[best].sequence) {
best = CacheInx;
}
}
CacheInx = best;
}
if (rc == 1) {
LAST_TRM = TerminalOf(SP_PARM);
LAST_SEQ = ++CacheSeq;
} else {
LAST_TRM = 0;
}
PC = 0;
UP = 0;
BC = 0;
FIX_SGR0 = 0; /* don't free it - application may still use */
if (rc == 1) {
if (cursor_left)
if ((backspaces_with_bs = (char) !strcmp(cursor_left, "\b")) == 0)
backspace_if_not_bs = cursor_left;
/* we're required to export these */
if (pad_char != NULL)
PC = pad_char[0];
if (cursor_up != NULL)
UP = cursor_up;
if (backspace_if_not_bs != NULL)
BC = backspace_if_not_bs;
if ((FIX_SGR0 = _nc_trim_sgr0(&TerminalType(TerminalOf(SP_PARM))))
!= 0) {
if (!strcmp(FIX_SGR0, exit_attribute_mode)) {
if (FIX_SGR0 != exit_attribute_mode) {
free(FIX_SGR0);
}
FIX_SGR0 = 0;
}
}
LAST_BUF = bufp;
LAST_USE = TRUE;
SetNoPadding(SP_PARM);
(void) NCURSES_SP_NAME(baudrate) (NCURSES_SP_ARG); /* sets ospeed as a side-effect */
/* LINT_PREPRO
#if 0*/
#include <capdefaults.c>
/* LINT_PREPRO
#endif*/
}
returnCode(rc);
}
safe_keyname (SCREEN *sp, int c)
{
int i;
char name[20];
char *p;
NCURSES_CONST char *result = 0;
if (c == -1) {
result = "-1";
} else {
for (i = 0; _nc_key_names[i].offset != -1; i++) {
if (_nc_key_names[i].code == c) {
result = (NCURSES_CONST char *)key_names + _nc_key_names[i].offset;
break;
}
}
if (result == 0 && (c >= 0 && c < SIZEOF_TABLE)) {
if (MyTable == 0)
MyTable = typeCalloc(char *, SIZEOF_TABLE);
if (MyTable != 0) {
int m_prefix = (sp == 0 || sp->_use_meta);
/* if sense of meta() changed, discard cached data */
if (MyInit != (m_prefix + 1)) {
MyInit = m_prefix + 1;
for (i = 0; i < SIZEOF_TABLE; ++i) {
if (MyTable[i]) {
FreeAndNull(MyTable[i]);
}
}
}
/* create and cache result as needed */
if (MyTable[c] == 0) {
int cc = c;
p = name;
#define P_LIMIT (sizeof(name) - (size_t) (p - name))
if (cc >= 128 && m_prefix) {
_nc_STRCPY(p, "M-", P_LIMIT);
p += 2;
cc -= 128;
}
if (cc < 32)
_nc_SPRINTF(p, _nc_SLIMIT(P_LIMIT) "^%c", cc + '@');
else if (cc == 127)
_nc_STRCPY(p, "^?", P_LIMIT);
else
_nc_SPRINTF(p, _nc_SLIMIT(P_LIMIT) "%c", cc);
MyTable[c] = strdup(name);
}
result = MyTable[c];
}
#if NCURSES_EXT_FUNCS && NCURSES_XNAMES
} else if (result == 0 && HasTerminal(sp)) {
int j, k;
char * bound;
TERMTYPE *tp = &(TerminalOf(sp)->type);
unsigned save_trace = _nc_tracing;
_nc_tracing = 0; /* prevent recursion via keybound() */
for (j = 0; (bound = NCURSES_SP_NAME(keybound)(NCURSES_SP_ARGx c, j)) != 0; ++j) {
for(k = STRCOUNT; k < (int) NUM_STRINGS(tp); k++) {
if (tp->Strings[k] != 0 && !strcmp(bound, tp->Strings[k])) {
result = ExtStrname(tp, k, strnames);
break;
}
}
free(bound);
if (result != 0)
break;
}
_nc_tracing = save_trace;
#endif
}
}
NCURSES_SP_NAME(_nc_get_cur_term) (NCURSES_SP_DCL0)
{
return ((0 != TerminalOf(SP_PARM)) ? TerminalOf(SP_PARM) : CurTerm);
}
static void
initialize_mousetype(SCREEN *sp)
{
T((T_CALLED("initialize_mousetype()")));
/* Try gpm first, because gpm may be configured to run in xterm */
#if USE_GPM_SUPPORT
if (allow_gpm_mouse()) {
if (!sp->_mouse_gpm_loaded) {
#ifdef HAVE_LIBDL
load_gpm_library(sp);
#else /* !HAVE_LIBDL */
sp->_mouse_gpm_found = TRUE;
sp->_mouse_gpm_loaded = TRUE;
#endif
}
/*
* The gpm_fd file-descriptor may be negative (xterm). So we have to
* maintain our notion of whether the mouse connection is active
* without testing the file-descriptor.
*/
if (sp->_mouse_gpm_found && enable_gpm_mouse(sp, TRUE)) {
sp->_mouse_type = M_GPM;
sp->_mouse_fd = *(my_gpm_fd);
T(("GPM mouse_fd %d", sp->_mouse_fd));
returnVoid;
}
}
#endif /* USE_GPM_SUPPORT */
/* OS/2 VIO */
#if USE_EMX_MOUSE
if (!sp->_emxmouse_thread
&& strstr(TerminalOf(sp)->type.term_names, "xterm") == 0
&& key_mouse) {
int handles[2];
if (pipe(handles) < 0) {
perror("mouse pipe error");
returnVoid;
} else {
int rc;
if (!sp->_emxmouse_buttons[0]) {
char *s = getenv("MOUSE_BUTTONS_123");
sp->_emxmouse_buttons[0] = 1;
if (s && strlen(s) >= 3) {
sp->_emxmouse_buttons[1] = s[0] - '0';
sp->_emxmouse_buttons[2] = s[1] - '0';
sp->_emxmouse_buttons[3] = s[2] - '0';
} else {
sp->_emxmouse_buttons[1] = 1;
sp->_emxmouse_buttons[2] = 3;
sp->_emxmouse_buttons[3] = 2;
}
}
sp->_emxmouse_wfd = handles[1];
M_FD(sp) = handles[0];
/* Needed? */
setmode(handles[0], O_BINARY);
setmode(handles[1], O_BINARY);
/* Do not use CRT functions, we may single-threaded. */
rc = DosCreateThread((unsigned long *) &sp->_emxmouse_thread,
mouse_server, (long) sp, 0, 8192);
if (rc) {
printf("mouse thread error %d=%#x", rc, rc);
} else {
sp->_mouse_type = M_XTERM;
}
returnVoid;
}
}
#endif /* USE_EMX_MOUSE */
#if USE_SYSMOUSE
{
struct mouse_info the_mouse;
char *the_device = 0;
if (isatty(sp->_ifd))
the_device = ttyname(sp->_ifd);
if (the_device == 0)
the_device = "/dev/tty";
sp->_mouse_fd = open(the_device, O_RDWR);
if (sp->_mouse_fd >= 0) {
/*
* sysmouse does not have a usable user interface for obtaining
* mouse events. The logical way to proceed (reading data on a
* stream) only works if one opens the device as root. Even in
* that mode, careful examination shows we lose events
* occasionally. The interface provided for user programs is to
* establish a signal handler. really.
*
* Take over SIGUSR2 for this purpose since SIGUSR1 is more
* likely to be used by an application. getch() will have to
* handle the misleading EINTR's.
*/
signal(SIGUSR2, SIG_IGN);
the_mouse.operation = MOUSE_MODE;
the_mouse.u.mode.mode = 0;
the_mouse.u.mode.signal = SIGUSR2;
if (ioctl(sp->_mouse_fd, CONS_MOUSECTL, &the_mouse) != -1) {
signal(SIGUSR2, handle_sysmouse);
the_mouse.operation = MOUSE_SHOW;
ioctl(sp->_mouse_fd, CONS_MOUSECTL, &the_mouse);
#if defined(FBIO_MODEINFO) || defined(CONS_MODEINFO) /* FreeBSD > 2.x */
{
#ifndef FBIO_GETMODE /* FreeBSD 3.x */
#define FBIO_GETMODE CONS_GET
#define FBIO_MODEINFO CONS_MODEINFO
#endif /* FBIO_GETMODE */
video_info_t the_video;
if (ioctl(sp->_mouse_fd,
FBIO_GETMODE,
&the_video.vi_mode) != -1
&& ioctl(sp->_mouse_fd,
FBIO_MODEINFO,
&the_video) != -1) {
sp->_sysmouse_char_width = the_video.vi_cwidth;
sp->_sysmouse_char_height = the_video.vi_cheight;
}
}
#endif /* defined(FBIO_MODEINFO) || defined(CONS_MODEINFO) */
if (sp->_sysmouse_char_width <= 0)
sp->_sysmouse_char_width = 8;
if (sp->_sysmouse_char_height <= 0)
sp->_sysmouse_char_height = 16;
sp->_mouse_type = M_SYSMOUSE;
returnVoid;
}
}
}
#endif /* USE_SYSMOUSE */
#ifdef USE_TERM_DRIVER
CallDriver(sp, initmouse);
#else
/* we know how to recognize mouse events under "xterm" */
if (key_mouse != 0) {
if (!strcmp(key_mouse, xterm_kmous)
|| strstr(TerminalOf(sp)->type.term_names, "xterm") != 0) {
init_xterm_mouse(sp);
}
} else if (strstr(TerminalOf(sp)->type.term_names, "xterm") != 0) {
if (_nc_add_to_try(&(sp->_keytry), xterm_kmous, KEY_MOUSE) == OK)
init_xterm_mouse(sp);
}
#endif
returnVoid;
}
safe_keyname (SCREEN *sp, int c)
{
int i;
char name[20];
char *p;
NCURSES_CONST char *result = 0;
if (c == -1) {
result = "-1";
} else {
for (i = 0; _nc_key_names[i].offset != -1; i++) {
if (_nc_key_names[i].code == c) {
result = (NCURSES_CONST char *)key_names + _nc_key_names[i].offset;
break;
}
}
if (result == 0 && (c >= 0 && c < SIZEOF_TABLE)) {
if (MyTable == 0)
MyTable = typeCalloc(char *, SIZEOF_TABLE);
if (MyTable != 0) {
if (MyTable[c] == 0) {
int cc = c;
p = name;
if (cc >= 128 && (sp == 0 || sp->_use_meta)) {
strcpy(p, "M-");
p += 2;
cc -= 128;
}
if (cc < 32)
sprintf(p, "^%c", cc + '@');
else if (cc == 127)
strcpy(p, "^?");
else
sprintf(p, "%c", cc);
MyTable[c] = strdup(name);
}
result = MyTable[c];
}
#if NCURSES_EXT_FUNCS && NCURSES_XNAMES
} else if (result == 0 && HasTerminal(sp)) {
int j, k;
char * bound;
TERMTYPE *tp = &(TerminalOf(sp)->type);
unsigned save_trace = _nc_tracing;
_nc_tracing = 0; /* prevent recursion via keybound() */
for (j = 0; (bound = NCURSES_SP_NAME(keybound)(NCURSES_SP_ARGx c, j)) != 0; ++j) {
for(k = STRCOUNT; k < (int) NUM_STRINGS(tp); k++) {
if (tp->Strings[k] != 0 && !strcmp(bound, tp->Strings[k])) {
result = ExtStrname(tp, k, strnames);
break;
}
}
free(bound);
if (result != 0)
break;
}
_nc_tracing = save_trace;
#endif
}
}
