ncurses/tinfo/lib_options.c

   1 /****************************************************************************
   2  * Copyright 2020 Thomas E. Dickey                                          *
   3  * Copyright 1998-2014,2017 Free Software Foundation, Inc.                  *
   4  *                                                                          *
   5  * Permission is hereby granted, free of charge, to any person obtaining a  *
   6  * copy of this software and associated documentation files (the            *
   7  * "Software"), to deal in the Software without restriction, including      *
   8  * without limitation the rights to use, copy, modify, merge, publish,      *
   9  * distribute, distribute with modifications, sublicense, and/or sell       *
  10  * copies of the Software, and to permit persons to whom the Software is    *
  11  * furnished to do so, subject to the following conditions:                 *
  12  *                                                                          *
  13  * The above copyright notice and this permission notice shall be included  *
  14  * in all copies or substantial portions of the Software.                   *
  15  *                                                                          *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
  17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
  18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
  19  * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
  20  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
  21  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
  22  * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
  23  *                                                                          *
  24  * Except as contained in this notice, the name(s) of the above copyright   *
  25  * holders shall not be used in advertising or otherwise to promote the     *
  26  * sale, use or other dealings in this Software without prior written       *
  27  * authorization.                                                           *
  28  ****************************************************************************/
  29
  30 /****************************************************************************
  31  *  Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995               *
  32  *     and: Eric S. Raymond <esr@snark.thyrsus.com>                         *
  33  *     and: Thomas E. Dickey                        1996-on                 *
  34  *     and: Juergen Pfeifer                         2009                    *
  35  ****************************************************************************/
  36
  37 /*
  38 **      lib_options.c
  39 **
  40 **      The routines to handle option setting.
  41 **
  42 */
  43
  44 #include <curses.priv.h>
  45
  46 #ifndef CUR
  47 #define CUR SP_TERMTYPE
  48 #endif
  49
  50 MODULE_ID("$Id: lib_options.c,v 1.81 2020/02/02 23:34:34 tom Exp $")
  51
  52 NCURSES_EXPORT(int)
  53 idlok(WINDOW *win, bool flag)
  54 {
  55     int res = ERR;
  56     T((T_CALLED("idlok(%p,%d)"), (void *) win, flag));
  57
  58     if (win) {
  59         SCREEN *sp = _nc_screen_of(win);
  60         if (sp != 0
  61 #ifdef USE_TERM_DRIVER
  62             && IsTermInfo(sp)
  63 #endif
  64             ) {
  65             sp->_nc_sp_idlok =
  66                 win->_idlok = (flag && (NCURSES_SP_NAME(has_il) (NCURSES_SP_ARG)
  67                                         || change_scroll_region));
  68             res = OK;
  69         }
  70     }
  71     returnCode(res);
  72 }
  73
  74 NCURSES_EXPORT(void)
  75 idcok(WINDOW *win, bool flag)
  76 {
  77     T((T_CALLED("idcok(%p,%d)"), (void *) win, flag));
  78
  79     if (win) {
  80         SCREEN *sp = _nc_screen_of(win);
  81         sp->_nc_sp_idcok = win->_idcok = (flag && NCURSES_SP_NAME(has_ic) (NCURSES_SP_ARG));
  82     }
  83     returnVoid;
  84 }
  85
  86 NCURSES_EXPORT(int)
  87 NCURSES_SP_NAME(halfdelay) (NCURSES_SP_DCLx int t)
  88 {
  89     T((T_CALLED("halfdelay(%p,%d)"), (void *) SP_PARM, t));
  90
  91     if (t < 1 || t > 255 || !SP_PARM || !IsValidTIScreen(SP_PARM))
  92         returnCode(ERR);
  93
  94     NCURSES_SP_NAME(cbreak) (NCURSES_SP_ARG);
  95     SP_PARM->_cbreak = t + 1;
  96     returnCode(OK);
  97 }
  98
  99 #if NCURSES_SP_FUNCS
 100 NCURSES_EXPORT(int)
 101 halfdelay(int t)
 102 {
 103     return NCURSES_SP_NAME(halfdelay) (CURRENT_SCREEN, t);
 104 }
 105 #endif
 106
 107 NCURSES_EXPORT(int)
 108 nodelay(WINDOW *win, bool flag)
 109 {
 110     T((T_CALLED("nodelay(%p,%d)"), (void *) win, flag));
 111
 112     if (win) {
 113         if (flag == TRUE)
 114             win->_delay = 0;
 115         else
 116             win->_delay = -1;
 117         returnCode(OK);
 118     } else
 119         returnCode(ERR);
 120 }
 121
 122 NCURSES_EXPORT(int)
 123 notimeout(WINDOW *win, bool f)
 124 {
 125     T((T_CALLED("notimeout(%p,%d)"), (void *) win, f));
 126
 127     if (win) {
 128         win->_notimeout = f;
 129         returnCode(OK);
 130     } else
 131         returnCode(ERR);
 132 }
 133
 134 NCURSES_EXPORT(void)
 135 wtimeout(WINDOW *win, int delay)
 136 {
 137     T((T_CALLED("wtimeout(%p,%d)"), (void *) win, delay));
 138
 139     if (win) {
 140         win->_delay = delay;
 141     }
 142     returnVoid;
 143 }
 144
 145 NCURSES_EXPORT(int)
 146 keypad(WINDOW *win, bool flag)
 147 {
 148     T((T_CALLED("keypad(%p,%d)"), (void *) win, flag));
 149
 150     if (win) {
 151         win->_use_keypad = flag;
 152         returnCode(_nc_keypad(_nc_screen_of(win), flag));
 153     } else
 154         returnCode(ERR);
 155 }
 156
 157 NCURSES_EXPORT(int)
 158 meta(WINDOW *win GCC_UNUSED, bool flag)
 159 {
 160     int result = ERR;
 161     SCREEN *sp = (win == 0) ? CURRENT_SCREEN : _nc_screen_of(win);
 162
 163     /* Ok, we stay relaxed and don't signal an error if win is NULL */
 164     T((T_CALLED("meta(%p,%d)"), (void *) win, flag));
 165
 166     /* Ok, we stay relaxed and don't signal an error if win is NULL */
 167
 168     if (sp != 0) {
 169         sp->_use_meta = flag;
 170 #ifdef USE_TERM_DRIVER
 171         if (IsTermInfo(sp)) {
 172             if (flag) {
 173                 NCURSES_PUTP2("meta_on", meta_on);
 174             } else {
 175                 NCURSES_PUTP2("meta_off", meta_off);
 176             }
 177         }
 178 #else
 179         if (flag) {
 180             NCURSES_PUTP2("meta_on", meta_on);
 181         } else {
 182             NCURSES_PUTP2("meta_off", meta_off);
 183         }
 184 #endif
 185         result = OK;
 186     }
 187     returnCode(result);
 188 }
 189
 190 /* curs_set() moved here to narrow the kernel interface */
 191
 192 NCURSES_EXPORT(int)
 193 NCURSES_SP_NAME(curs_set) (NCURSES_SP_DCLx int vis)
 194 {
 195     int code = ERR;
 196     T((T_CALLED("curs_set(%p,%d)"), (void *) SP_PARM, vis));
 197
 198     if (SP_PARM != 0 && vis >= 0 && vis <= 2) {
 199         int cursor = SP_PARM->_cursor;
 200         if (vis == cursor) {
 201             code = cursor;
 202         } else {
 203 #ifdef USE_TERM_DRIVER
 204             code = CallDriver_1(SP_PARM, td_cursorSet, vis);
 205 #else
 206             if (IsValidTIScreen(SP_PARM)) {
 207                 switch (vis) {
 208                 case 2:
 209                     code = NCURSES_PUTP2_FLUSH("cursor_visible",
 210                                                cursor_visible);
 211                     break;
 212                 case 1:
 213                     code = NCURSES_PUTP2_FLUSH("cursor_normal",
 214                                                cursor_normal);
 215                     break;
 216                 case 0:
 217                     code = NCURSES_PUTP2_FLUSH("cursor_invisible",
 218                                                cursor_invisible);
 219                     break;
 220                 }
 221             } else {
 222                 code = ERR;
 223             }
 224 #endif
 225             if (code != ERR)
 226                 code = (cursor == -1 ? 1 : cursor);
 227             SP_PARM->_cursor = vis;
 228         }
 229     }
 230     returnCode(code);
 231 }
 232
 233 #if NCURSES_SP_FUNCS
 234 NCURSES_EXPORT(int)
 235 curs_set(int vis)
 236 {
 237     return (NCURSES_SP_NAME(curs_set) (CURRENT_SCREEN, vis));
 238 }
 239 #endif
 240
 241 NCURSES_EXPORT(int)
 242 NCURSES_SP_NAME(typeahead) (NCURSES_SP_DCLx int fd)
 243 {
 244     T((T_CALLED("typeahead(%p, %d)"), (void *) SP_PARM, fd));
 245     if (SP_PARM && IsValidTIScreen(SP_PARM)) {
 246         SP_PARM->_checkfd = fd;
 247         returnCode(OK);
 248     } else {
 249         returnCode(ERR);
 250     }
 251 }
 252
 253 #if NCURSES_SP_FUNCS
 254 NCURSES_EXPORT(int)
 255 typeahead(int fd)
 256 {
 257     return NCURSES_SP_NAME(typeahead) (CURRENT_SCREEN, fd);
 258 }
 259 #endif
 260
 261 /*
 262 **      has_key()
 263 **
 264 **      Return TRUE if the current terminal has the given key
 265 **
 266 */
 267
 268 #if NCURSES_EXT_FUNCS
 269 static int
 270 has_key_internal(int keycode, TRIES * tp)
 271 {
 272     if (tp == 0)
 273         return (FALSE);
 274     else if (tp->value == keycode)
 275         return (TRUE);
 276     else
 277         return (has_key_internal(keycode, tp->child)
 278                 || has_key_internal(keycode, tp->sibling));
 279 }
 280
 281 #ifdef USE_TERM_DRIVER
 282 NCURSES_EXPORT(int)
 283 TINFO_HAS_KEY(SCREEN *sp, int keycode)
 284 {
 285     return IsValidTIScreen(sp) ?
 286         has_key_internal(keycode, sp->_keytry) : 0;
 287 }
 288 #else
 289 NCURSES_EXPORT(int)
 290 NCURSES_SP_NAME(has_key) (NCURSES_SP_DCLx int keycode)
 291 {
 292     T((T_CALLED("has_key(%p,%d)"), (void *) SP_PARM, keycode));
 293     returnCode(SP != 0 ? has_key_internal(keycode, SP_PARM->_keytry) : FALSE);
 294 }
 295
 296 #if NCURSES_SP_FUNCS
 297 NCURSES_EXPORT(int)
 298 has_key(int keycode)
 299 {
 300     return NCURSES_SP_NAME(has_key) (CURRENT_SCREEN, keycode);
 301 }
 302 #endif
 303 #endif
 304 #endif /* NCURSES_EXT_FUNCS */
 305
 306 NCURSES_EXPORT(int)
 307 NCURSES_SP_NAME(_nc_putp_flush) (NCURSES_SP_DCLx
 308                                  const char *name, const char *value)
 309 {
 310     int rc = NCURSES_PUTP2(name, value);
 311     if (rc != ERR) {
 312         _nc_flush();
 313     }
 314     return rc;
 315 }
 316
 317 #if 0 && NCURSES_SP_FUNCS
 318 NCURSES_EXPORT(int)
 319 _nc_putp_flush(const char *name, const char *value)
 320 {
 321     return NCURSES_SP_NAME(_nc_putp_flush) (CURRENT_SCREEN, name, value);
 322 }
 323 #endif
 324
 325 /* Turn the keypad on/off
 326  *
 327  * Note:  we flush the output because changing this mode causes some terminals
 328  * to emit different escape sequences for cursor and keypad keys.  If we don't
 329  * flush, then the next wgetch may get the escape sequence that corresponds to
 330  * the terminal state _before_ switching modes.
 331  */
 332 NCURSES_EXPORT(int)
 333 _nc_keypad(SCREEN *sp, int flag)
 334 {
 335     int rc = ERR;
 336
 337     if (sp != 0) {
 338 #ifdef USE_PTHREADS
 339         /*
 340          * We might have this situation in a multithreaded application that
 341          * has wgetch() reading in more than one thread.  putp() and below
 342          * may use SP explicitly.
 343          */
 344         if (_nc_use_pthreads && sp != CURRENT_SCREEN) {
 345             SCREEN *save_sp;
 346
 347             /* cannot use use_screen(), since that is not in tinfo library */
 348             _nc_lock_global(curses);
 349             save_sp = CURRENT_SCREEN;
 350             _nc_set_screen(sp);
 351             rc = _nc_keypad(sp, flag);
 352             _nc_set_screen(save_sp);
 353             _nc_unlock_global(curses);
 354         } else
 355 #endif
 356         {
 357 #ifdef USE_TERM_DRIVER
 358             rc = CallDriver_1(sp, td_kpad, flag);
 359             if (rc == OK)
 360                 sp->_keypad_on = flag;
 361 #else
 362             if (flag) {
 363                 (void) NCURSES_PUTP2_FLUSH("keypad_xmit", keypad_xmit);
 364             } else if (!flag && keypad_local) {
 365                 (void) NCURSES_PUTP2_FLUSH("keypad_local", keypad_local);
 366             }
 367
 368             if (flag && !sp->_tried) {
 369                 _nc_init_keytry(sp);
 370                 sp->_tried = TRUE;
 371             }
 372             sp->_keypad_on = flag;
 373             rc = OK;
 374 #endif
 375         }
 376     }
 377     return (rc);
 378 }