ncurses 6.1 - patch 20190406
[ncurses.git] / ncurses / tinfo / lib_options.c
index 0bc14156d6744ab16be9037e505458f206ed5bff..826737bdd0ca393135fd9024e7b336803f7bc79d 100644 (file)
@@ -1,5 +1,5 @@
 /****************************************************************************
- * Copyright (c) 1998 Free Software Foundation, Inc.                        *
+ * Copyright (c) 1998-2014,2017 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            *
 /****************************************************************************
  *  Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995               *
  *     and: Eric S. Raymond <esr@snark.thyrsus.com>                         *
+ *     and: Thomas E. Dickey                        1996-on                 *
+ *     and: Juergen Pfeifer                         2009                    *
  ****************************************************************************/
 
-
 /*
 **     lib_options.c
 **
 
 #include <curses.priv.h>
 
-#include <term.h>      /* keypad_xmit, keypad_local, meta_on, meta_off */
-                       /* cursor_visible,cursor_normal,cursor_invisible */
+#ifndef CUR
+#define CUR SP_TERMTYPE
+#endif
 
-MODULE_ID("$Id: lib_options.c,v 1.36 1999/10/22 21:38:57 tom Exp $")
+MODULE_ID("$Id: lib_options.c,v 1.80 2017/06/24 23:13:09 tom Exp $")
 
-int idlok(WINDOW *win,  bool flag)
+NCURSES_EXPORT(int)
+idlok(WINDOW *win, bool flag)
 {
-       T((T_CALLED("idlok(%p,%d)"), win, flag));
-
-       if (win) {
-         _nc_idlok = win->_idlok = flag && (has_il() || change_scroll_region);
-         returnCode(OK);
+    int res = ERR;
+    T((T_CALLED("idlok(%p,%d)"), (void *) win, flag));
+
+    if (win) {
+       SCREEN *sp = _nc_screen_of(win);
+       if (sp != 0
+#ifdef USE_TERM_DRIVER
+           && IsTermInfo(sp)
+#endif
+           ) {
+           sp->_nc_sp_idlok =
+               win->_idlok = (flag && (NCURSES_SP_NAME(has_il) (NCURSES_SP_ARG)
+                                       || change_scroll_region));
+           res = OK;
        }
-       else
-         returnCode(ERR);
+    }
+    returnCode(res);
 }
 
-
-void idcok(WINDOW *win, bool flag)
+NCURSES_EXPORT(void)
+idcok(WINDOW *win, bool flag)
 {
-       T((T_CALLED("idcok(%p,%d)"), win, flag));
+    T((T_CALLED("idcok(%p,%d)"), (void *) win, flag));
 
-       if (win)
-         _nc_idcok = win->_idcok = flag && has_ic();
-
-       returnVoid;
+    if (win) {
+       SCREEN *sp = _nc_screen_of(win);
+       sp->_nc_sp_idcok = win->_idcok = (flag && NCURSES_SP_NAME(has_ic) (NCURSES_SP_ARG));
+    }
+    returnVoid;
 }
 
-int halfdelay(int t)
+NCURSES_EXPORT(int)
+NCURSES_SP_NAME(halfdelay) (NCURSES_SP_DCLx int t)
 {
-       T((T_CALLED("halfdelay(%d)"), t));
+    T((T_CALLED("halfdelay(%p,%d)"), (void *) SP_PARM, t));
 
-       if (t < 1 || t > 255)
-               returnCode(ERR);
+    if (t < 1 || t > 255 || !SP_PARM || !IsValidTIScreen(SP_PARM))
+       returnCode(ERR);
 
-       cbreak();
-       SP->_cbreak = t+1;
-       returnCode(OK);
+    NCURSES_SP_NAME(cbreak) (NCURSES_SP_ARG);
+    SP_PARM->_cbreak = t + 1;
+    returnCode(OK);
 }
 
-int nodelay(WINDOW *win, bool flag)
+#if NCURSES_SP_FUNCS
+NCURSES_EXPORT(int)
+halfdelay(int t)
 {
-       T((T_CALLED("nodelay(%p,%d)"), win, flag));
-
-       if (win) {
-         if (flag == TRUE)
-           win->_delay = 0;
-         else win->_delay = -1;
-         returnCode(OK);
-       }
-       else
-         returnCode(ERR);
+    return NCURSES_SP_NAME(halfdelay) (CURRENT_SCREEN, t);
 }
+#endif
 
-int notimeout(WINDOW *win, bool f)
+NCURSES_EXPORT(int)
+nodelay(WINDOW *win, bool flag)
 {
-       T((T_CALLED("notimout(%p,%d)"), win, f));
+    T((T_CALLED("nodelay(%p,%d)"), (void *) win, flag));
 
-       if (win) {
-         win->_notimeout = f;
-         returnCode(OK);
-       }
+    if (win) {
+       if (flag == TRUE)
+           win->_delay = 0;
        else
-         returnCode(ERR);
+           win->_delay = -1;
+       returnCode(OK);
+    } else
+       returnCode(ERR);
 }
 
-void wtimeout(WINDOW *win, int delay)
+NCURSES_EXPORT(int)
+notimeout(WINDOW *win, bool f)
 {
-       T((T_CALLED("wtimeout(%p,%d)"), win, delay));
+    T((T_CALLED("notimeout(%p,%d)"), (void *) win, f));
 
-       if (win) {
-         win->_delay = delay;
-       }
+    if (win) {
+       win->_notimeout = f;
+       returnCode(OK);
+    } else
+       returnCode(ERR);
 }
 
-int keypad(WINDOW *win, bool flag)
+NCURSES_EXPORT(void)
+wtimeout(WINDOW *win, int delay)
 {
-       T((T_CALLED("keypad(%p,%d)"), win, flag));
+    T((T_CALLED("wtimeout(%p,%d)"), (void *) win, delay));
 
-       if (win) {
-         win->_use_keypad = flag;
-         returnCode(_nc_keypad(flag));
-       }
-       else
-         returnCode(ERR);
+    if (win) {
+       win->_delay = delay;
+    }
+    returnVoid;
 }
 
-
-int meta(WINDOW *win GCC_UNUSED, bool flag)
+NCURSES_EXPORT(int)
+keypad(WINDOW *win, bool flag)
 {
-        /* Ok, we stay relaxed and don't signal an error if win is NULL */
-       T((T_CALLED("meta(%p,%d)"), win, flag));
+    T((T_CALLED("keypad(%p,%d)"), (void *) win, flag));
 
-       SP->_use_meta = flag;
+    if (win) {
+       win->_use_keypad = flag;
+       returnCode(_nc_keypad(_nc_screen_of(win), flag));
+    } else
+       returnCode(ERR);
+}
 
-       if (flag  &&  meta_on)
-       {
-           TPUTS_TRACE("meta_on");
-           putp(meta_on);
+NCURSES_EXPORT(int)
+meta(WINDOW *win GCC_UNUSED, bool flag)
+{
+    int result = ERR;
+    SCREEN *sp = (win == 0) ? CURRENT_SCREEN : _nc_screen_of(win);
+
+    /* Ok, we stay relaxed and don't signal an error if win is NULL */
+    T((T_CALLED("meta(%p,%d)"), (void *) win, flag));
+
+    /* Ok, we stay relaxed and don't signal an error if win is NULL */
+
+    if (sp != 0) {
+       sp->_use_meta = flag;
+#ifdef USE_TERM_DRIVER
+       if (IsTermInfo(sp)) {
+           if (flag) {
+               NCURSES_PUTP2("meta_on", meta_on);
+           } else {
+               NCURSES_PUTP2("meta_off", meta_off);
+           }
        }
-       else if (! flag  &&  meta_off)
-       {
-           TPUTS_TRACE("meta_off");
-           putp(meta_off);
+#else
+       if (flag) {
+           NCURSES_PUTP2("meta_on", meta_on);
+       } else {
+           NCURSES_PUTP2("meta_off", meta_off);
        }
-       returnCode(OK);
+#endif
+       result = OK;
+    }
+    returnCode(result);
 }
 
 /* curs_set() moved here to narrow the kernel interface */
 
-int curs_set(int vis)
+NCURSES_EXPORT(int)
+NCURSES_SP_NAME(curs_set) (NCURSES_SP_DCLx int vis)
 {
-int cursor = SP->_cursor;
-
-       T((T_CALLED("curs_set(%d)"), vis));
-
-       if (vis < 0 || vis > 2)
-               returnCode(ERR);
-
-       if (vis == cursor)
-               returnCode(cursor);
-
-       switch(vis) {
-       case 2:
-               if (cursor_visible)
-               {
-                       TPUTS_TRACE("cursor_visible");
-                       putp(cursor_visible);
-               }
-               else
-                       returnCode(ERR);
-               break;
-       case 1:
-               if (cursor_normal)
-               {
-                       TPUTS_TRACE("cursor_normal");
-                       putp(cursor_normal);
+    int code = ERR;
+    T((T_CALLED("curs_set(%p,%d)"), (void *) SP_PARM, vis));
+
+    if (SP_PARM != 0 && vis >= 0 && vis <= 2) {
+       int cursor = SP_PARM->_cursor;
+       if (vis == cursor) {
+           code = cursor;
+       } else {
+#ifdef USE_TERM_DRIVER
+           code = CallDriver_1(SP_PARM, td_cursorSet, vis);
+#else
+           if (IsValidTIScreen(SP_PARM)) {
+               switch (vis) {
+               case 2:
+                   code = NCURSES_PUTP2_FLUSH("cursor_visible",
+                                              cursor_visible);
+                   break;
+               case 1:
+                   code = NCURSES_PUTP2_FLUSH("cursor_normal",
+                                              cursor_normal);
+                   break;
+               case 0:
+                   code = NCURSES_PUTP2_FLUSH("cursor_invisible",
+                                              cursor_invisible);
+                   break;
                }
-               else
-                       returnCode(ERR);
-               break;
-       case 0:
-               if (cursor_invisible)
-               {
-                       TPUTS_TRACE("cursor_invisible");
-                       putp(cursor_invisible);
-               }
-               else
-                       returnCode(ERR);
-               break;
+           } else {
+               code = ERR;
+           }
+#endif
+           if (code != ERR)
+               code = (cursor == -1 ? 1 : cursor);
+           SP_PARM->_cursor = vis;
        }
-       SP->_cursor = vis;
-       _nc_flush();
+    }
+    returnCode(code);
+}
 
-       returnCode(cursor==-1 ? 1 : cursor);
+#if NCURSES_SP_FUNCS
+NCURSES_EXPORT(int)
+curs_set(int vis)
+{
+    return (NCURSES_SP_NAME(curs_set) (CURRENT_SCREEN, vis));
 }
+#endif
 
-int typeahead(int fd)
+NCURSES_EXPORT(int)
+NCURSES_SP_NAME(typeahead) (NCURSES_SP_DCLx int fd)
 {
-       T((T_CALLED("typeahead(%d)"), fd));
-       SP->_checkfd = fd;
+    T((T_CALLED("typeahead(%p, %d)"), (void *) SP_PARM, fd));
+    if (SP_PARM && IsValidTIScreen(SP_PARM)) {
+       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()
 **
@@ -212,25 +264,63 @@ int typeahead(int fd)
 **
 */
 
-#ifdef NCURSES_EXT_FUNCS
-static int has_key_internal(int keycode, struct tries *tp)
+#if NCURSES_EXT_FUNCS
+static int
+has_key_internal(int keycode, TRIES * tp)
 {
     if (tp == 0)
-       return(FALSE);
+       return (FALSE);
     else if (tp->value == keycode)
-       return(TRUE);
+       return (TRUE);
     else
-       return(has_key_internal(keycode, tp->child)
-              || has_key_internal(keycode, tp->sibling));
+       return (has_key_internal(keycode, tp->child)
+               || has_key_internal(keycode, tp->sibling));
 }
 
-int has_key(int keycode)
+#ifdef USE_TERM_DRIVER
+NCURSES_EXPORT(int)
+TINFO_HAS_KEY(SCREEN *sp, int keycode)
+{
+    return IsValidTIScreen(sp) ?
+       has_key_internal(keycode, sp->_keytry) : 0;
+}
+#else
+NCURSES_EXPORT(int)
+NCURSES_SP_NAME(has_key) (NCURSES_SP_DCLx int keycode)
 {
-    T((T_CALLED("has_key(%d)"), keycode));
-    returnCode(has_key_internal(keycode, SP->_keytry));
+    T((T_CALLED("has_key(%p,%d)"), (void *) 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)
+{
+    return NCURSES_SP_NAME(has_key) (CURRENT_SCREEN, keycode);
+}
+#endif
+#endif
 #endif /* NCURSES_EXT_FUNCS */
 
+NCURSES_EXPORT(int)
+NCURSES_SP_NAME(_nc_putp_flush) (NCURSES_SP_DCLx
+                                const char *name, const char *value)
+{
+    int rc = NCURSES_PUTP2(name, value);
+    if (rc != ERR) {
+       _nc_flush();
+    }
+    return rc;
+}
+
+#if 0 && 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
@@ -238,24 +328,50 @@ int has_key(int keycode)
  * flush, then the next wgetch may get the escape sequence that corresponds to
  * the terminal state _before_ switching modes.
  */
-int _nc_keypad(bool flag)
+NCURSES_EXPORT(int)
+_nc_keypad(SCREEN *sp, int flag)
 {
-       if (flag  &&  keypad_xmit)
-       {
-           TPUTS_TRACE("keypad_xmit");
-           putp(keypad_xmit);
-           _nc_flush();
-       }
-       else if (! flag  &&  keypad_local)
+    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
        {
-           TPUTS_TRACE("keypad_local");
-           putp(keypad_local);
-           _nc_flush();
-       }
-
-       if (flag && !SP->_tried) {
-           _nc_init_keytry();
-           SP->_tried = TRUE;
+#ifdef USE_TERM_DRIVER
+           rc = CallDriver_1(sp, td_kpad, flag);
+           if (rc == OK)
+               sp->_keypad_on = flag;
+#else
+           if (flag) {
+               (void) NCURSES_PUTP2_FLUSH("keypad_xmit", keypad_xmit);
+           } else if (!flag && keypad_local) {
+               (void) NCURSES_PUTP2_FLUSH("keypad_local", keypad_local);
+           }
+
+           if (flag && !sp->_tried) {
+               _nc_init_keytry(sp);
+               sp->_tried = TRUE;
+           }
+           sp->_keypad_on = flag;
+           rc = OK;
+#endif
        }
-       return(OK);
+    }
+    return (rc);
 }