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 } }