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