X-Git-Url: https://ncurses.scripts.mit.edu/?p=ncurses.git;a=blobdiff_plain;f=ncurses%2Ftinfo%2Flib_options.c;h=908ee1b07a98bae4d2f07aacfb01c73923a9474a;hp=98aae24baacbfc1aca8a6fa8c4f536a56a76b36c;hb=5b7f4de105080e2a715b0564ede4bb7eb6767659;hpb=ed530db2c5b10aa19d06104dfe82cf248a813860 diff --git a/ncurses/tinfo/lib_options.c b/ncurses/tinfo/lib_options.c index 98aae24b..908ee1b0 100644 --- a/ncurses/tinfo/lib_options.c +++ b/ncurses/tinfo/lib_options.c @@ -1,5 +1,5 @@ /**************************************************************************** - * Copyright (c) 1998-2006,2008 Free Software Foundation, Inc. * + * Copyright (c) 1998-2008,2009 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 * @@ -30,6 +30,7 @@ * Author: Zeyd M. Ben-Halim 1992,1995 * * and: Eric S. Raymond * * and: Thomas E. Dickey 1996-on * + * and: Juergen Pfeifer 2009 * ****************************************************************************/ /* @@ -43,11 +44,20 @@ #include -MODULE_ID("$Id: lib_options.c,v 1.52 2008/05/03 23:09:20 tom Exp $") +#ifndef CUR +#define CUR SP_TERMTYPE +#endif + +MODULE_ID("$Id: lib_options.c,v 1.65 2009/07/04 18:14:31 tom Exp $") + +static int _nc_meta(SCREEN *, bool); NCURSES_EXPORT(int) idlok(WINDOW *win, bool flag) { +#if NCURSES_SP_FUNCS + SCREEN *sp = CURRENT_SCREEN; +#endif T((T_CALLED("idlok(%p,%d)"), win, flag)); if (win) { @@ -60,6 +70,9 @@ idlok(WINDOW *win, bool flag) NCURSES_EXPORT(void) idcok(WINDOW *win, bool flag) { +#if NCURSES_SP_FUNCS + SCREEN *sp = CURRENT_SCREEN; +#endif T((T_CALLED("idcok(%p,%d)"), win, flag)); if (win) @@ -69,18 +82,26 @@ idcok(WINDOW *win, bool flag) } NCURSES_EXPORT(int) -halfdelay(int t) +NCURSES_SP_NAME(halfdelay) (NCURSES_SP_DCLx int t) { T((T_CALLED("halfdelay(%d)"), t)); - if (t < 1 || t > 255 || SP == 0) + if (t < 1 || t > 255 || SP_PARM == 0) returnCode(ERR); cbreak(); - SP->_cbreak = t + 1; + SP_PARM->_cbreak = t + 1; returnCode(OK); } +#if NCURSES_SP_FUNCS +NCURSES_EXPORT(int) +halfdelay(int t) +{ + return NCURSES_SP_NAME(halfdelay) (CURRENT_SCREEN, t); +} +#endif + NCURSES_EXPORT(int) nodelay(WINDOW *win, bool flag) { @@ -134,83 +155,75 @@ keypad(WINDOW *win, bool flag) NCURSES_EXPORT(int) meta(WINDOW *win GCC_UNUSED, bool flag) { - int result = ERR; + int result; /* Ok, we stay relaxed and don't signal an error if win is NULL */ T((T_CALLED("meta(%p,%d)"), win, flag)); - - if (SP != 0) { - SP->_use_meta = flag; - - if (flag && meta_on) { - TPUTS_TRACE("meta_on"); - putp(meta_on); - } else if (!flag && meta_off) { - TPUTS_TRACE("meta_off"); - putp(meta_off); - } - result = OK; - } + result = _nc_meta(SP, flag); returnCode(result); } /* curs_set() moved here to narrow the kernel interface */ NCURSES_EXPORT(int) -curs_set(int vis) +NCURSES_SP_NAME(curs_set) (NCURSES_SP_DCLx int vis) { int result = ERR; - T((T_CALLED("curs_set(%d)"), vis)); - if (SP != 0 && vis >= 0 && vis <= 2) { - int cursor = SP->_cursor; + T((T_CALLED("curs_set(%p,%d)"), SP_PARM, vis)); + if (SP_PARM != 0 && vis >= 0 && vis <= 2) { + int cursor = SP_PARM->_cursor; if (vis == cursor) { result = cursor; } else { - result = (cursor == -1 ? 1 : cursor); switch (vis) { case 2: - if (cursor_visible) { - TPUTS_TRACE("cursor_visible"); - putp(cursor_visible); - } else - result = ERR; + result = _nc_putp_flush("cursor_visible", cursor_visible); break; case 1: - if (cursor_normal) { - TPUTS_TRACE("cursor_normal"); - putp(cursor_normal); - } else - result = ERR; + result = _nc_putp_flush("cursor_normal", cursor_normal); break; case 0: - if (cursor_invisible) { - TPUTS_TRACE("cursor_invisible"); - putp(cursor_invisible); - } else - result = ERR; + result = _nc_putp_flush("cursor_invisible", cursor_invisible); break; } - SP->_cursor = vis; - _nc_flush(); + if (result != ERR) + result = (cursor == -1 ? 1 : cursor); + SP_PARM->_cursor = vis; } } returnCode(result); } +#if NCURSES_SP_FUNCS NCURSES_EXPORT(int) -typeahead(int fd) +curs_set(int vis) +{ + return (NCURSES_SP_NAME(curs_set) (CURRENT_SCREEN, vis)); +} +#endif + +NCURSES_EXPORT(int) +NCURSES_SP_NAME(typeahead) (NCURSES_SP_DCLx int fd) { T((T_CALLED("typeahead(%d)"), fd)); - if (SP != 0) { - SP->_checkfd = fd; + if (SP_PARM != 0) { + SP_PARM->_checkfd = fd; returnCode(OK); } else { returnCode(ERR); } } +#if NCURSES_SP_FUNCS +NCURSES_EXPORT(int) +typeahead(int fd) +{ + return NCURSES_SP_NAME(typeahead) (CURRENT_SCREEN, fd); +} +#endif + /* ** has_key() ** @@ -231,14 +244,48 @@ has_key_internal(int keycode, TRIES * tp) || has_key_internal(keycode, tp->sibling)); } +NCURSES_EXPORT(int) +NCURSES_SP_NAME(has_key) (NCURSES_SP_DCLx int keycode) +{ + T((T_CALLED("has_key(%p,%d)"), SP_PARM, keycode)); + returnCode(SP != 0 ? has_key_internal(keycode, SP_PARM->_keytry) : FALSE); +} + +#if NCURSES_SP_FUNCS NCURSES_EXPORT(int) has_key(int keycode) { - T((T_CALLED("has_key(%d)"), keycode)); - returnCode(SP != 0 ? has_key_internal(keycode, SP->_keytry) : FALSE); + return NCURSES_SP_NAME(has_key) (CURRENT_SCREEN, keycode); } +#endif #endif /* NCURSES_EXT_FUNCS */ +/* + * Internal entrypoints use SCREEN* parameter to obtain capabilities rather + * than cur_term. + */ +#undef CUR +#define CUR SP_TERMTYPE + +NCURSES_EXPORT(int) +NCURSES_SP_NAME(_nc_putp_flush) (NCURSES_SP_DCLx + const char *name, const char *value) +{ + int rc = _nc_putp(name, value); + if (rc != ERR) { + _nc_flush(); + } + return rc; +} + +#if NCURSES_SP_FUNCS +NCURSES_EXPORT(int) +_nc_putp_flush(const char *name, const char *value) +{ + return NCURSES_SP_NAME(_nc_putp_flush) (CURRENT_SCREEN, name, value); +} +#endif + /* Turn the keypad on/off * * Note: we flush the output because changing this mode causes some terminals @@ -249,22 +296,61 @@ has_key(int keycode) NCURSES_EXPORT(int) _nc_keypad(SCREEN *sp, bool flag) { - if (flag && keypad_xmit) { - TPUTS_TRACE("keypad_xmit"); - putp(keypad_xmit); - _nc_flush(); - } else if (!flag && keypad_local) { - TPUTS_TRACE("keypad_local"); - putp(keypad_local); - _nc_flush(); + int rc = ERR; + + if (sp != 0) { +#ifdef USE_PTHREADS + /* + * We might have this situation in a multithreaded application that + * has wgetch() reading in more than one thread. putp() and below + * may use SP explicitly. + */ + if (_nc_use_pthreads && sp != CURRENT_SCREEN) { + SCREEN *save_sp; + + /* cannot use use_screen(), since that is not in tinfo library */ + _nc_lock_global(curses); + save_sp = CURRENT_SCREEN; + _nc_set_screen(sp); + rc = _nc_keypad(sp, flag); + _nc_set_screen(save_sp); + _nc_unlock_global(curses); + } else +#endif + { + if (flag) { + (void) _nc_putp_flush("keypad_xmit", keypad_xmit); + } else if (!flag && keypad_local) { + (void) _nc_putp_flush("keypad_local", keypad_local); + } + + if (flag && !sp->_tried) { + _nc_init_keytry(sp); + sp->_tried = TRUE; + } + sp->_keypad_on = flag; + rc = OK; + } } + return (rc); +} + +static int +_nc_meta(SCREEN *sp, bool flag) +{ + int result = ERR; + + /* Ok, we stay relaxed and don't signal an error if win is NULL */ if (sp != 0) { - if (flag && !sp->_tried) { - _nc_init_keytry(sp); - sp->_tried = TRUE; + sp->_use_meta = flag; + + if (flag) { + _nc_putp("meta_on", meta_on); + } else { + _nc_putp("meta_off", meta_off); } - sp->_keypad_on = flag; + result = OK; } - return (OK); + return result; }