1 /* Public Domain Curses */
2
3 #include <curspriv.h>
4
5 RCSID("$Id: inopts.c,v 1.43 2008/07/13 16:08:18 wmcbrine Exp $")
6
7 /*man-start**************************************************************
8
9 Name: inopts
10
11 Synopsis:
12 int cbreak(void);
13 int nocbreak(void);
14 int echo(void);
15 int noecho(void);
16 int halfdelay(int tenths);
17 int intrflush(WINDOW *win, bool bf);
18 int keypad(WINDOW *win, bool bf);
19 int meta(WINDOW *win, bool bf);
20 int nl(void);
21 int nonl(void);
22 int nodelay(WINDOW *win, bool bf);
23 int notimeout(WINDOW *win, bool bf);
24 int raw(void);
25 int noraw(void);
26 void noqiflush(void);
27 void qiflush(void);
28 void timeout(int delay);
29 void wtimeout(WINDOW *win, int delay);
30 int typeahead(int fildes);
31
32 int crmode(void);
33 int nocrmode(void);
34
35 Description:
36 cbreak() and nocbreak() toggle cbreak mode. In cbreak mode,
37 characters typed by the user are made available immediately, and
38 erase/kill character processing is not performed. In nocbreak
39 mode, typed characters are buffered until a newline or carriage
40 return. Interrupt and flow control characters are unaffected by
41 this mode. PDCurses always starts in cbreak mode.
42
43 echo() and noecho() control whether typed characters are echoed
44 by the input routine. Initially, input characters are echoed.
45 Subsequent calls to echo() and noecho() do not flush type-ahead.
46
47 halfdelay() is similar to cbreak(), but allows for a time limit
48 to be specified, in tenths of a second. This causes getch() to
49 block for that period before returning ERR if no key has been
50 received. tenths must be between 1 and 255.
51
52 keypad() controls whether getch() returns function/special keys
53 as single key codes (e.g., the left arrow key as KEY_LEFT). Per
54 X/Open, the default for keypad mode is OFF. You'll probably want
55 it on. With keypad mode off, if a special key is pressed,
56 getch() does nothing or returns ERR.
57
58 nodelay() controls whether wgetch() is a non-blocking call. If
59 the option is enabled, and no input is ready, wgetch() will
60 return ERR. If disabled, wgetch() will hang until input is
61 ready.
62
63 nl() enables the translation of a carriage return into a newline
64 on input. nonl() disables this. Initially, the translation does
65 occur.
66
67 raw() and noraw() toggle raw mode. Raw mode is similar to cbreak
68 mode, in that characters typed are immediately passed through to
69 the user program. The difference is that in raw mode, the INTR,
70 QUIT, SUSP, and STOP characters are passed through without being
71 interpreted, and without generating a signal.
72
73 In PDCurses, the meta() function sets raw mode on or off.
74
75 timeout() and wtimeout() set blocking or non-blocking reads for
76 the specified window. The delay is measured in milliseconds. If
77 it's negative, a blocking read is used; if zero, then non-
78 blocking reads are done -- if no input is waiting, ERR is
79 returned immediately. If the delay is positive, the read blocks
80 for the delay period; if the period expires, ERR is returned.
81
82 intrflush(), notimeout(), noqiflush(), qiflush() and typeahead()
83 do nothing in PDCurses, but are included for compatibility with
84 other curses implementations.
85
86 crmode() and nocrmode() are archaic equivalents to cbreak() and
87 nocbreak(), respectively.
88
89 Return Value:
90 All functions return OK on success and ERR on error.
91
92 Portability X/Open BSD SYS V
93 cbreak Y Y Y
94 nocbreak Y Y Y
95 echo Y Y Y
96 noecho Y Y Y
97 halfdelay Y - Y
98 intrflush Y - Y
99 keypad Y - Y
100 meta Y - Y
101 nl Y Y Y
102 nonl Y Y Y
103 nodelay Y - Y
104 notimeout Y - Y
105 raw Y Y Y
106 noraw Y Y Y
107 noqiflush Y - Y
108 qiflush Y - Y
109 timeout Y - Y
110 wtimeout Y - Y
111 typeahead Y - Y
112 crmode -
113 nocrmode -
114
115 **man-end****************************************************************/
116
cbreak(void)117 int cbreak(void)
118 {
119 PDC_LOG(("cbreak() - called\n"));
120
121 SP->cbreak = TRUE;
122
123 return OK;
124 }
125
nocbreak(void)126 int nocbreak(void)
127 {
128 PDC_LOG(("nocbreak() - called\n"));
129
130 SP->cbreak = FALSE;
131 SP->delaytenths = 0;
132
133 return OK;
134 }
135
echo(void)136 int echo(void)
137 {
138 PDC_LOG(("echo() - called\n"));
139
140 SP->echo = TRUE;
141
142 return OK;
143 }
144
noecho(void)145 int noecho(void)
146 {
147 PDC_LOG(("noecho() - called\n"));
148
149 SP->echo = FALSE;
150
151 return OK;
152 }
153
halfdelay(int tenths)154 int halfdelay(int tenths)
155 {
156 PDC_LOG(("halfdelay() - called\n"));
157
158 if (tenths < 1 || tenths > 255)
159 return ERR;
160
161 SP->delaytenths = tenths;
162
163 return OK;
164 }
165
intrflush(WINDOW * win,bool bf)166 int intrflush(WINDOW *win, bool bf)
167 {
168 PDC_LOG(("intrflush() - called\n"));
169
170 return OK;
171 }
172
keypad(WINDOW * win,bool bf)173 int keypad(WINDOW *win, bool bf)
174 {
175 PDC_LOG(("keypad() - called\n"));
176
177 if (!win)
178 return ERR;
179
180 win->_use_keypad = bf;
181
182 return OK;
183 }
184
meta(WINDOW * win,bool bf)185 int meta(WINDOW *win, bool bf)
186 {
187 PDC_LOG(("meta() - called\n"));
188
189 SP->raw_inp = bf;
190
191 return OK;
192 }
193
nl(void)194 int nl(void)
195 {
196 PDC_LOG(("nl() - called\n"));
197
198 SP->autocr = TRUE;
199
200 return OK;
201 }
202
nonl(void)203 int nonl(void)
204 {
205 PDC_LOG(("nonl() - called\n"));
206
207 SP->autocr = FALSE;
208
209 return OK;
210 }
211
nodelay(WINDOW * win,bool flag)212 int nodelay(WINDOW *win, bool flag)
213 {
214 PDC_LOG(("nodelay() - called\n"));
215
216 if (!win)
217 return ERR;
218
219 win->_nodelay = flag;
220
221 return OK;
222 }
223
notimeout(WINDOW * win,bool flag)224 int notimeout(WINDOW *win, bool flag)
225 {
226 PDC_LOG(("notimeout() - called\n"));
227
228 return OK;
229 }
230
raw(void)231 int raw(void)
232 {
233 PDC_LOG(("raw() - called\n"));
234
235 PDC_set_keyboard_binary(TRUE);
236 SP->raw_inp = TRUE;
237
238 return OK;
239 }
240
noraw(void)241 int noraw(void)
242 {
243 PDC_LOG(("noraw() - called\n"));
244
245 PDC_set_keyboard_binary(FALSE);
246 SP->raw_inp = FALSE;
247
248 return OK;
249 }
250
noqiflush(void)251 void noqiflush(void)
252 {
253 PDC_LOG(("noqiflush() - called\n"));
254 }
255
qiflush(void)256 void qiflush(void)
257 {
258 PDC_LOG(("qiflush() - called\n"));
259 }
260
typeahead(int fildes)261 int typeahead(int fildes)
262 {
263 PDC_LOG(("typeahead() - called\n"));
264
265 return OK;
266 }
267
wtimeout(WINDOW * win,int delay)268 void wtimeout(WINDOW *win, int delay)
269 {
270 PDC_LOG(("wtimeout() - called\n"));
271
272 if (!win)
273 return;
274
275 if (delay < 0)
276 {
277 /* This causes a blocking read on the window, so turn on delay
278 mode */
279
280 win->_nodelay = FALSE;
281 win->_delayms = 0;
282 }
283 else if (!delay)
284 {
285 /* This causes a non-blocking read on the window, so turn off
286 delay mode */
287
288 win->_nodelay = TRUE;
289 win->_delayms = 0;
290 }
291 else
292 {
293 /* This causes the read on the window to delay for the number of
294 milliseconds. Also forces the window into non-blocking read
295 mode */
296
297 /*win->_nodelay = TRUE;*/
298 win->_delayms = delay;
299 }
300 }
301
timeout(int delay)302 void timeout(int delay)
303 {
304 PDC_LOG(("timeout() - called\n"));
305
306 wtimeout(stdscr, delay);
307 }
308
crmode(void)309 int crmode(void)
310 {
311 PDC_LOG(("crmode() - called\n"));
312
313 return cbreak();
314 }
315
nocrmode(void)316 int nocrmode(void)
317 {
318 PDC_LOG(("nocrmode() - called\n"));
319
320 return nocbreak();
321 }
322