1*671612efSrin /* $NetBSD: get_wch.c,v 1.26 2021/09/06 07:45:48 rin Exp $ */
2fa0b432bSblymn
3fa0b432bSblymn /*
4fa0b432bSblymn * Copyright (c) 2005 The NetBSD Foundation Inc.
5fa0b432bSblymn * All rights reserved.
6fa0b432bSblymn *
7fa0b432bSblymn * This code is derived from code donated to the NetBSD Foundation
8fa0b432bSblymn * by Ruibiao Qiu <ruibiao@arl.wustl.edu,ruibiao@gmail.com>.
9fa0b432bSblymn *
10fa0b432bSblymn *
11fa0b432bSblymn * Redistribution and use in source and binary forms, with or without
12fa0b432bSblymn * modification, are permitted provided that the following conditions
13fa0b432bSblymn * are met:
14fa0b432bSblymn * 1. Redistributions of source code must retain the above copyright
15fa0b432bSblymn * notice, this list of conditions and the following disclaimer.
16fa0b432bSblymn * 2. Redistributions in binary form must reproduce the above copyright
17fa0b432bSblymn * notice, this list of conditions and the following disclaimer in the
18fa0b432bSblymn * documentation and/or other materials provided with the distribution.
19fa0b432bSblymn * 3. Neither the name of the NetBSD Foundation nor the names of its
20fa0b432bSblymn * contributors may be used to endorse or promote products derived
21fa0b432bSblymn * from this software without specific prior written permission.
22fa0b432bSblymn *
23fa0b432bSblymn * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
24fa0b432bSblymn * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
25fa0b432bSblymn * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
26fa0b432bSblymn * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27fa0b432bSblymn * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28fa0b432bSblymn * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29fa0b432bSblymn * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30fa0b432bSblymn * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31fa0b432bSblymn * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32fa0b432bSblymn * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33fa0b432bSblymn * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34fa0b432bSblymn * SUCH DAMAGE.
35fa0b432bSblymn */
36fa0b432bSblymn
37fa0b432bSblymn #include <sys/cdefs.h>
38fa0b432bSblymn #ifndef lint
39*671612efSrin __RCSID("$NetBSD: get_wch.c,v 1.26 2021/09/06 07:45:48 rin Exp $");
40fa0b432bSblymn #endif /* not lint */
41fa0b432bSblymn
428df9a300Srin #include <errno.h>
43fa0b432bSblymn #include <string.h>
44fa0b432bSblymn #include <stdlib.h>
45fa0b432bSblymn #include <unistd.h>
46fa0b432bSblymn #include <stdio.h>
47fa0b432bSblymn #include "curses.h"
48fa0b432bSblymn #include "curses_private.h"
49fa0b432bSblymn #include "keymap.h"
50fa0b432bSblymn
51fa0b432bSblymn static short wstate; /* state of the wcinkey function */
522a9f52daSrin extern short _cursesi_state; /* storage declared in getch.c */
53fa0b432bSblymn
54fa0b432bSblymn /* prototypes for private functions */
55fa0b432bSblymn static int inkey(wchar_t *wc, int to, int delay);
564aeb00ceSroy static wint_t __fgetwc_resize(FILE *infd, bool *resized);
57fa0b432bSblymn
58fa0b432bSblymn /*
59fa0b432bSblymn * __init_get_wch - initialise all the pointers & structures needed to make
60fa0b432bSblymn * get_wch work in keypad mode.
61fa0b432bSblymn *
62fa0b432bSblymn */
63fa0b432bSblymn void
__init_get_wch(SCREEN * screen)64fa0b432bSblymn __init_get_wch(SCREEN *screen)
65fa0b432bSblymn {
66fa0b432bSblymn wstate = INKEY_NORM;
67414be921Sblymn memset(&screen->cbuf, 0, sizeof(screen->cbuf));
68fa0b432bSblymn screen->cbuf_head = screen->cbuf_tail = screen->cbuf_cur = 0;
69fa0b432bSblymn }
70fa0b432bSblymn
71fa0b432bSblymn
72fa0b432bSblymn /*
73fa0b432bSblymn * inkey - do the work to process keyboard input, check for multi-key
74fa0b432bSblymn * sequences and return the appropriate symbol if we get a match.
75fa0b432bSblymn *
76fa0b432bSblymn */
77619b7f0eSjdc static int
inkey(wchar_t * wc,int to,int delay)78fa0b432bSblymn inkey(wchar_t *wc, int to, int delay)
79fa0b432bSblymn {
80fa0b432bSblymn wchar_t k = 0;
81fa0b432bSblymn int c, mapping, ret = 0;
82fa0b432bSblymn size_t mlen = 0;
83fa0b432bSblymn keymap_t *current = _cursesi_screen->base_keymap;
84fa0b432bSblymn FILE *infd = _cursesi_screen->infd;
85fa0b432bSblymn int *start = &_cursesi_screen->cbuf_head,
86fa0b432bSblymn *working = &_cursesi_screen->cbuf_cur,
87fa0b432bSblymn *end = &_cursesi_screen->cbuf_tail;
88fa0b432bSblymn char *inbuf = &_cursesi_screen->cbuf[ 0 ];
89fa0b432bSblymn
907cc6075bSjdc __CTRACE(__CTRACE_INPUT, "inkey (%p, %d, %d)\n", wc, to, delay);
91fa0b432bSblymn for (;;) { /* loop until we get a complete key sequence */
92fa0b432bSblymn if (wstate == INKEY_NORM) {
93fa0b432bSblymn if (delay && __timeout(delay) == ERR)
94fa0b432bSblymn return ERR;
954aeb00ceSroy c = __fgetc_resize(infd);
964aeb00ceSroy if (c == ERR || c == KEY_RESIZE) {
97fa0b432bSblymn clearerr(infd);
984aeb00ceSroy return c;
99fa0b432bSblymn }
100fa0b432bSblymn
101fa0b432bSblymn if (delay && (__notimeout() == ERR))
102fa0b432bSblymn return ERR;
103fa0b432bSblymn
104fa0b432bSblymn k = (wchar_t)c;
105e124de36Sblymn __CTRACE(__CTRACE_INPUT,
106e124de36Sblymn "inkey (wstate normal) got '%s'\n", unctrl(k));
107fa0b432bSblymn
108fa0b432bSblymn inbuf[*end] = k;
109fa0b432bSblymn *end = (*end + 1) % MAX_CBUF_SIZE;
110fa0b432bSblymn *working = *start;
111fa0b432bSblymn wstate = INKEY_ASSEMBLING; /* go to assembling state */
112e124de36Sblymn __CTRACE(__CTRACE_INPUT,
113e124de36Sblymn "inkey: NORM=>ASSEMBLING: start(%d), "
114e124de36Sblymn "current(%d), end(%d)\n", *start, *working, *end);
115fa0b432bSblymn } else if (wstate == INKEY_BACKOUT) {
116fa0b432bSblymn k = inbuf[*working];
117fa0b432bSblymn *working = (*working + 1) % MAX_CBUF_SIZE;
118fa0b432bSblymn if (*working == *end) { /* see if run out of keys */
119fa0b432bSblymn /* if so, switch to assembling */
120fa0b432bSblymn wstate = INKEY_ASSEMBLING;
121e124de36Sblymn __CTRACE(__CTRACE_INPUT,
122e124de36Sblymn "inkey: BACKOUT=>ASSEMBLING, start(%d), "
123e124de36Sblymn "current(%d), end(%d)\n",
124fa0b432bSblymn *start, *working, *end);
125fa0b432bSblymn }
126fa0b432bSblymn } else if (wstate == INKEY_ASSEMBLING) {
127fa0b432bSblymn /* assembling a key sequence */
128fa0b432bSblymn if (delay) {
129d3b3f557Sroy if (__timeout(to ? (ESCDELAY / 100) : delay)
130fa0b432bSblymn == ERR)
131fa0b432bSblymn return ERR;
132fa0b432bSblymn } else {
133d3b3f557Sroy if (to && (__timeout(ESCDELAY / 100) == ERR))
134fa0b432bSblymn return ERR;
135fa0b432bSblymn }
136fa0b432bSblymn
1374aeb00ceSroy c = __fgetc_resize(infd);
138fa0b432bSblymn if (ferror(infd)) {
139fa0b432bSblymn clearerr(infd);
1404aeb00ceSroy return c;
141fa0b432bSblymn }
142fa0b432bSblymn
143fa0b432bSblymn if ((to || delay) && (__notimeout() == ERR))
144fa0b432bSblymn return ERR;
145fa0b432bSblymn
146fa0b432bSblymn k = (wchar_t)c;
147e124de36Sblymn __CTRACE(__CTRACE_INPUT,
148e124de36Sblymn "inkey (wstate assembling) got '%s'\n", unctrl(k));
149fa0b432bSblymn if (feof(infd)) { /* inter-char T/O, start backout */
150fa0b432bSblymn clearerr(infd);
151fa0b432bSblymn if (*start == *end)
152fa0b432bSblymn /* no chars in the buffer, restart */
153fa0b432bSblymn continue;
154fa0b432bSblymn
155fa0b432bSblymn k = inbuf[*start];
156fa0b432bSblymn wstate = INKEY_TIMEOUT;
157e124de36Sblymn __CTRACE(__CTRACE_INPUT,
158e124de36Sblymn "inkey: ASSEMBLING=>TIMEOUT, start(%d), "
159e124de36Sblymn "current(%d), end(%d)\n",
160fa0b432bSblymn *start, *working, *end);
161fa0b432bSblymn } else {
162fa0b432bSblymn inbuf[*end] = k;
163fa0b432bSblymn *working = *end;
164fa0b432bSblymn *end = (*end + 1) % MAX_CBUF_SIZE;
165e124de36Sblymn __CTRACE(__CTRACE_INPUT,
166e124de36Sblymn "inkey: ASSEMBLING: start(%d), "
167e124de36Sblymn "current(%d), end(%d)",
168fa0b432bSblymn *start, *working, *end);
169fa0b432bSblymn }
170fa0b432bSblymn } else if (wstate == INKEY_WCASSEMBLING) {
1710f41cbdbSwiz /* assembling a wide-char sequence */
172fa0b432bSblymn if (delay) {
173d3b3f557Sroy if (__timeout(to ? (ESCDELAY / 100) : delay)
174fa0b432bSblymn == ERR)
175fa0b432bSblymn return ERR;
176fa0b432bSblymn } else {
177d3b3f557Sroy if (to && (__timeout(ESCDELAY / 100) == ERR))
178fa0b432bSblymn return ERR;
179fa0b432bSblymn }
180fa0b432bSblymn
1814aeb00ceSroy c = __fgetc_resize(infd);
182fa0b432bSblymn if (ferror(infd)) {
183fa0b432bSblymn clearerr(infd);
1844aeb00ceSroy return c;
185fa0b432bSblymn }
186fa0b432bSblymn
187fa0b432bSblymn if ((to || delay) && (__notimeout() == ERR))
188fa0b432bSblymn return ERR;
189fa0b432bSblymn
190fa0b432bSblymn k = (wchar_t)c;
191e124de36Sblymn __CTRACE(__CTRACE_INPUT,
192e124de36Sblymn "inkey (wstate wcassembling) got '%s'\n",
193fa0b432bSblymn unctrl(k));
194fa0b432bSblymn if (feof(infd)) { /* inter-char T/O, start backout */
195fa0b432bSblymn clearerr(infd);
196fa0b432bSblymn if (*start == *end)
197fa0b432bSblymn /* no chars in the buffer, restart */
198fa0b432bSblymn continue;
199fa0b432bSblymn
200fa0b432bSblymn *wc = inbuf[*start];
20180b412b0Sroy *working = *start = (*start +1) % MAX_CBUF_SIZE;
202fa0b432bSblymn if (*start == *end) {
2032a9f52daSrin _cursesi_state = wstate = INKEY_NORM;
204e124de36Sblymn __CTRACE(__CTRACE_INPUT,
205e124de36Sblymn "inkey: WCASSEMBLING=>NORM, "
206e124de36Sblymn "start(%d), current(%d), end(%d)",
207fa0b432bSblymn *start, *working, *end);
208fa0b432bSblymn } else {
2092a9f52daSrin _cursesi_state = wstate = INKEY_BACKOUT;
210e124de36Sblymn __CTRACE(__CTRACE_INPUT,
211e124de36Sblymn "inkey: WCASSEMBLING=>BACKOUT, "
212e124de36Sblymn "start(%d), current(%d), end(%d)",
213fa0b432bSblymn *start, *working, *end);
214fa0b432bSblymn }
215fa0b432bSblymn return OK;
216fa0b432bSblymn } else {
217fa0b432bSblymn /* assembling wide characters */
218fa0b432bSblymn inbuf[*end] = k;
219fa0b432bSblymn *working = *end;
220fa0b432bSblymn *end = (*end + 1) % MAX_CBUF_SIZE;
221e124de36Sblymn __CTRACE(__CTRACE_INPUT,
222e124de36Sblymn "inkey: WCASSEMBLING[head(%d), "
223e124de36Sblymn "urrent(%d), tail(%d)]\n",
224fa0b432bSblymn *start, *working, *end);
225070937beSblymn ret = (int)mbrtowc(wc, inbuf + (*working), 1,
226fa0b432bSblymn &_cursesi_screen->sp);
227e124de36Sblymn __CTRACE(__CTRACE_INPUT,
228e124de36Sblymn "inkey: mbrtowc returns %d, wc(%x)\n",
229fa0b432bSblymn ret, *wc);
230fa0b432bSblymn if (ret == -2) {
23180b412b0Sroy *working = (*working+1) % MAX_CBUF_SIZE;
232fa0b432bSblymn continue;
233fa0b432bSblymn }
234fa0b432bSblymn if ( ret == 0 )
235fa0b432bSblymn ret = 1;
236fa0b432bSblymn if ( ret == -1 ) {
237fa0b432bSblymn /* return the 1st character we know */
238fa0b432bSblymn *wc = inbuf[*start];
239*671612efSrin *working = *start =
240*671612efSrin (*start + 1) % MAX_CBUF_SIZE;
241e124de36Sblymn __CTRACE(__CTRACE_INPUT,
242e124de36Sblymn "inkey: Invalid wide char(%x) "
243e124de36Sblymn "[head(%d), current(%d), "
244e124de36Sblymn "tail(%d)]\n",
245fa0b432bSblymn *wc, *start, *working, *end);
246fa0b432bSblymn } else { /* > 0 */
247fa0b432bSblymn /* return the wide character */
248*671612efSrin *start = *working =
249*671612efSrin (*working + ret) % MAX_CBUF_SIZE;
250e124de36Sblymn __CTRACE(__CTRACE_INPUT,
251e124de36Sblymn "inkey: Wide char found(%x) "
252e124de36Sblymn "[head(%d), current(%d), "
253e124de36Sblymn "tail(%d)]\n",
254fa0b432bSblymn *wc, *start, *working, *end);
255fa0b432bSblymn }
256fa0b432bSblymn
25780b412b0Sroy if (*start == *end) {
25880b412b0Sroy /* only one char processed */
2592a9f52daSrin _cursesi_state = wstate = INKEY_NORM;
260e124de36Sblymn __CTRACE(__CTRACE_INPUT,
261e124de36Sblymn "inkey: WCASSEMBLING=>NORM, "
262e124de36Sblymn "start(%d), current(%d), end(%d)",
263fa0b432bSblymn *start, *working, *end);
264fa0b432bSblymn } else {
26580b412b0Sroy /* otherwise we must have more than
26680b412b0Sroy * one char to backout */
2672a9f52daSrin _cursesi_state = wstate = INKEY_BACKOUT;
268e124de36Sblymn __CTRACE(__CTRACE_INPUT,
269e124de36Sblymn "inkey: WCASSEMBLING=>BACKOUT, "
270e124de36Sblymn "start(%d), current(%d), end(%d)",
271fa0b432bSblymn *start, *working, *end);
272fa0b432bSblymn }
273fa0b432bSblymn return OK;
274fa0b432bSblymn }
275fa0b432bSblymn } else {
276fa0b432bSblymn fprintf(stderr, "Inkey wstate screwed - exiting!!!");
277fa0b432bSblymn exit(2);
278fa0b432bSblymn }
279fa0b432bSblymn
280fa0b432bSblymn /*
281fa0b432bSblymn * Check key has no special meaning and we have not
282fa0b432bSblymn * timed out and the key has not been disabled
283fa0b432bSblymn */
284fa0b432bSblymn mapping = current->mapping[k];
285fa0b432bSblymn if (((wstate == INKEY_TIMEOUT) || (mapping < 0))
286fa0b432bSblymn || ((current->key[mapping]->type
287fa0b432bSblymn == KEYMAP_LEAF)
28880b412b0Sroy && (current->key[mapping]->enable == FALSE)))
28980b412b0Sroy {
2900f41cbdbSwiz /* wide-character specific code */
291e124de36Sblymn __CTRACE(__CTRACE_INPUT,
292e124de36Sblymn "inkey: Checking for wide char\n");
293fa0b432bSblymn mbrtowc(NULL, NULL, 1, &_cursesi_screen->sp);
294fa0b432bSblymn *working = *start;
295fa0b432bSblymn mlen = *end > *working ?
296fa0b432bSblymn *end - *working : MAX_CBUF_SIZE - *working;
297fa0b432bSblymn if (!mlen)
298fa0b432bSblymn return ERR;
299e124de36Sblymn __CTRACE(__CTRACE_INPUT,
300e124de36Sblymn "inkey: Check wide char[head(%d), "
301*671612efSrin "current(%d), tail(%d), mlen(%zu)]\n",
302*671612efSrin *start, *working, *end, mlen);
303070937beSblymn ret = (int)mbrtowc(wc, inbuf + (*working), mlen,
304fa0b432bSblymn &_cursesi_screen->sp);
305e124de36Sblymn __CTRACE(__CTRACE_INPUT,
306e124de36Sblymn "inkey: mbrtowc returns %d, wc(%x)\n", ret, *wc);
307fa0b432bSblymn if (ret == -2 && *end < *working) {
308fa0b432bSblymn /* second half of a wide character */
309fa0b432bSblymn *working = 0;
310fa0b432bSblymn mlen = *end;
311fa0b432bSblymn if (mlen)
312070937beSblymn ret = (int)mbrtowc(wc, inbuf, mlen,
313fa0b432bSblymn &_cursesi_screen->sp);
314fa0b432bSblymn }
315fa0b432bSblymn if (ret == -2 && wstate != INKEY_TIMEOUT) {
316*671612efSrin *working =
317*671612efSrin (*working + (int) mlen) % MAX_CBUF_SIZE;
318fa0b432bSblymn wstate = INKEY_WCASSEMBLING;
319fa0b432bSblymn continue;
320fa0b432bSblymn }
321fa0b432bSblymn if (ret == 0)
322fa0b432bSblymn ret = 1;
323fa0b432bSblymn if (ret == -1) {
324fa0b432bSblymn /* return the first key we know about */
325fa0b432bSblymn *wc = inbuf[*start];
326*671612efSrin *working = *start =
327*671612efSrin (*start + 1) % MAX_CBUF_SIZE;
328e124de36Sblymn __CTRACE(__CTRACE_INPUT,
329e124de36Sblymn "inkey: Invalid wide char(%x)[head(%d), "
330e124de36Sblymn "current(%d), tail(%d)]\n",
331fa0b432bSblymn *wc, *start, *working, *end);
332fa0b432bSblymn } else { /* > 0 */
333fa0b432bSblymn /* return the wide character */
334*671612efSrin *start = *working =
335*671612efSrin (*working + ret) % MAX_CBUF_SIZE;
336e124de36Sblymn __CTRACE(__CTRACE_INPUT,
337e124de36Sblymn "inkey: Wide char found(%x)[head(%d), "
338e124de36Sblymn "current(%d), tail(%d)]\n",
339fa0b432bSblymn *wc, *start, *working, *end);
340fa0b432bSblymn }
341fa0b432bSblymn
342fa0b432bSblymn if (*start == *end) { /* only one char processed */
3432a9f52daSrin _cursesi_state = wstate = INKEY_NORM;
344e124de36Sblymn __CTRACE(__CTRACE_INPUT,
345e124de36Sblymn "inkey: Empty cbuf=>NORM, "
346e124de36Sblymn "start(%d), current(%d), end(%d)\n",
347fa0b432bSblymn *start, *working, *end);
348fa0b432bSblymn } else {
34980b412b0Sroy /* otherwise we must have more than one
35080b412b0Sroy * char to backout */
3512a9f52daSrin _cursesi_state = wstate = INKEY_BACKOUT;
352e124de36Sblymn __CTRACE(__CTRACE_INPUT,
353e124de36Sblymn "inkey: Non-empty cbuf=>BACKOUT, "
354e124de36Sblymn "start(%d), current(%d), end(%d)\n",
355fa0b432bSblymn *start, *working, *end);
356fa0b432bSblymn }
357fa0b432bSblymn return OK;
358fa0b432bSblymn } else { /* must be part of a multikey sequence */
359fa0b432bSblymn /* check for completed key sequence */
360fa0b432bSblymn if (current->key[current->mapping[k]]->type
361fa0b432bSblymn == KEYMAP_LEAF) {
362fa0b432bSblymn /* eat the key sequence in cbuf */
363*671612efSrin *start = *working =
364*671612efSrin (*working + 1) % MAX_CBUF_SIZE;
365fa0b432bSblymn
366fa0b432bSblymn /* check if inbuf empty now */
367e124de36Sblymn __CTRACE(__CTRACE_INPUT,
368e124de36Sblymn "inkey: Key found(%s)\n",
369fa0b432bSblymn key_name(current->key[mapping]->value.symbol));
370fa0b432bSblymn if (*start == *end) {
371fa0b432bSblymn /* if it is go back to normal */
3722a9f52daSrin _cursesi_state = wstate = INKEY_NORM;
373e124de36Sblymn __CTRACE(__CTRACE_INPUT,
374e124de36Sblymn "[inkey]=>NORM, start(%d), "
375e124de36Sblymn "current(%d), end(%d)",
376fa0b432bSblymn *start, *working, *end);
377fa0b432bSblymn } else {
378fa0b432bSblymn /* otherwise go to backout state */
3792a9f52daSrin _cursesi_state = wstate = INKEY_BACKOUT;
380e124de36Sblymn __CTRACE(__CTRACE_INPUT,
381e124de36Sblymn "[inkey]=>BACKOUT, start(%d), "
382e124de36Sblymn "current(%d), end(%d)",
383fa0b432bSblymn *start, *working, *end);
384fa0b432bSblymn }
385fa0b432bSblymn
386fa0b432bSblymn /* return the symbol */
387fa0b432bSblymn *wc = current->key[mapping]->value.symbol;
388fa0b432bSblymn return KEY_CODE_YES;
389fa0b432bSblymn } else {
390fa0b432bSblymn /* Step to next part of multi-key sequence */
391fa0b432bSblymn current = current->key[current->mapping[k]]->value.next;
392fa0b432bSblymn }
393fa0b432bSblymn }
394fa0b432bSblymn }
395fa0b432bSblymn }
396fa0b432bSblymn
397fa0b432bSblymn /*
398fa0b432bSblymn * get_wch --
399fa0b432bSblymn * Read in a wide character from stdscr.
400fa0b432bSblymn */
401fa0b432bSblymn int
get_wch(wint_t * ch)402fa0b432bSblymn get_wch(wint_t *ch)
403fa0b432bSblymn {
404fa0b432bSblymn return wget_wch(stdscr, ch);
405fa0b432bSblymn }
406fa0b432bSblymn
407fa0b432bSblymn /*
408fa0b432bSblymn * mvget_wch --
409fa0b432bSblymn * Read in a character from stdscr at the given location.
410fa0b432bSblymn */
411fa0b432bSblymn int
mvget_wch(int y,int x,wint_t * ch)412fa0b432bSblymn mvget_wch(int y, int x, wint_t *ch)
413fa0b432bSblymn {
414fa0b432bSblymn return mvwget_wch(stdscr, y, x, ch);
415fa0b432bSblymn }
416fa0b432bSblymn
417fa0b432bSblymn /*
418fa0b432bSblymn * mvwget_wch --
419fa0b432bSblymn * Read in a character from stdscr at the given location in the
420fa0b432bSblymn * given window.
421fa0b432bSblymn */
422fa0b432bSblymn int
mvwget_wch(WINDOW * win,int y,int x,wint_t * ch)423fa0b432bSblymn mvwget_wch(WINDOW *win, int y, int x, wint_t *ch)
424fa0b432bSblymn {
425a5d2c93aSblymn if (wmove(win, y, x) == ERR)
426fa0b432bSblymn return ERR;
427fa0b432bSblymn
428fa0b432bSblymn return wget_wch(win, ch);
429fa0b432bSblymn }
430fa0b432bSblymn
431fa0b432bSblymn /*
432fa0b432bSblymn * wget_wch --
433fa0b432bSblymn * Read in a wide character from the window.
434fa0b432bSblymn */
435fa0b432bSblymn int
wget_wch(WINDOW * win,wint_t * ch)436fa0b432bSblymn wget_wch(WINDOW *win, wint_t *ch)
437fa0b432bSblymn {
438fa0b432bSblymn int ret, weset;
439fa0b432bSblymn int c;
440fa0b432bSblymn FILE *infd = _cursesi_screen->infd;
441fa0b432bSblymn cchar_t wc;
442fa0b432bSblymn wchar_t inp, ws[2];
443fa0b432bSblymn
44480b412b0Sroy if (!(win->flags & __SCROLLOK)
44580b412b0Sroy && (win->flags & __FULLWIN)
446fa0b432bSblymn && win->curx == win->maxx - 1
447fa0b432bSblymn && win->cury == win->maxy - 1
448fa0b432bSblymn && __echoit)
44980b412b0Sroy return ERR;
450fa0b432bSblymn
451d6782af8Suwe if (!(win->flags & __ISPAD) && is_wintouched(win))
452fa0b432bSblymn wrefresh(win);
453e124de36Sblymn __CTRACE(__CTRACE_INPUT, "wget_wch: __echoit = %d, "
454e124de36Sblymn "__rawmode = %d, __nl = %d, flags = %#.4x\n",
455fa0b432bSblymn __echoit, __rawmode, _cursesi_screen->nl, win->flags);
4567cc6075bSjdc if (_cursesi_screen->resized) {
4574f781456Sroy resizeterm(LINES, COLS);
4581f380abcSroy _cursesi_screen->resized = 0;
4597cc6075bSjdc *ch = KEY_RESIZE;
4607cc6075bSjdc return KEY_CODE_YES;
4617cc6075bSjdc }
4627cc6075bSjdc if (_cursesi_screen->unget_pos) {
4637cc6075bSjdc __CTRACE(__CTRACE_INPUT, "wget_wch returning char at %d\n",
4647cc6075bSjdc _cursesi_screen->unget_pos);
4657cc6075bSjdc _cursesi_screen->unget_pos--;
4667cc6075bSjdc *ch = _cursesi_screen->unget_list[_cursesi_screen->unget_pos];
4677cc6075bSjdc if (__echoit) {
4687cc6075bSjdc ws[0] = *ch, ws[1] = L'\0';
4697cc6075bSjdc setcchar(&wc, ws, win->wattr, 0, NULL);
4707cc6075bSjdc wadd_wch(win, &wc);
4717cc6075bSjdc }
4727cc6075bSjdc return KEY_CODE_YES;
4737cc6075bSjdc }
474fa0b432bSblymn if (__echoit && !__rawmode) {
475fa0b432bSblymn cbreak();
476fa0b432bSblymn weset = 1;
477fa0b432bSblymn } else
478fa0b432bSblymn weset = 0;
479fa0b432bSblymn
480fa0b432bSblymn __save_termios();
481fa0b432bSblymn
482fa0b432bSblymn if (win->flags & __KEYPAD) {
483fa0b432bSblymn switch (win->delay) {
484fa0b432bSblymn case -1:
485fa0b432bSblymn ret = inkey(&inp,
486fa0b432bSblymn win->flags & __NOTIMEOUT ? 0 : 1, 0);
487fa0b432bSblymn break;
488fa0b432bSblymn case 0:
489905b39a9Sdsl if (__nodelay() == ERR)
490fa0b432bSblymn return ERR;
491fa0b432bSblymn ret = inkey(&inp, 0, 0);
492fa0b432bSblymn break;
493fa0b432bSblymn default:
494fa0b432bSblymn ret = inkey(&inp,
495fa0b432bSblymn win->flags & __NOTIMEOUT ? 0 : 1,
496fa0b432bSblymn win->delay);
497fa0b432bSblymn break;
498fa0b432bSblymn }
499fa0b432bSblymn if ( ret == ERR )
500fa0b432bSblymn return ERR;
501fa0b432bSblymn } else {
5024aeb00ceSroy bool resized;
5034aeb00ceSroy
504fa0b432bSblymn switch (win->delay) {
505fa0b432bSblymn case -1:
506fa0b432bSblymn break;
507fa0b432bSblymn case 0:
508905b39a9Sdsl if (__nodelay() == ERR)
509fa0b432bSblymn return ERR;
510fa0b432bSblymn break;
511fa0b432bSblymn default:
512905b39a9Sdsl if (__timeout(win->delay) == ERR)
513fa0b432bSblymn return ERR;
514fa0b432bSblymn break;
515fa0b432bSblymn }
516fa0b432bSblymn
5174aeb00ceSroy c = __fgetwc_resize(infd, &resized);
5184aeb00ceSroy if (c == WEOF) {
519fa0b432bSblymn clearerr(infd);
520fa0b432bSblymn __restore_termios();
5214aeb00ceSroy if (resized) {
5228df9a300Srin *ch = KEY_RESIZE;
5238df9a300Srin return KEY_CODE_YES;
5248df9a300Srin } else
525fa0b432bSblymn return ERR;
526fa0b432bSblymn } else {
527fa0b432bSblymn ret = c;
528fa0b432bSblymn inp = c;
529fa0b432bSblymn }
530fa0b432bSblymn }
531fa0b432bSblymn #ifdef DEBUG
532fa0b432bSblymn if (inp > 255)
533fa0b432bSblymn /* we have a key symbol - treat it differently */
534fa0b432bSblymn /* XXXX perhaps __unctrl should be expanded to include
535fa0b432bSblymn * XXXX the keysyms in the table....
536fa0b432bSblymn */
537e124de36Sblymn __CTRACE(__CTRACE_INPUT, "wget_wch assembled keysym 0x%x\n",
538e124de36Sblymn inp);
539fa0b432bSblymn else
540e124de36Sblymn __CTRACE(__CTRACE_INPUT, "wget_wch got '%s'\n", unctrl(inp));
541fa0b432bSblymn #endif
542fa0b432bSblymn if (win->delay > -1) {
543905b39a9Sdsl if (__delay() == ERR)
544fa0b432bSblymn return ERR;
545fa0b432bSblymn }
546fa0b432bSblymn
547fa0b432bSblymn __restore_termios();
548fa0b432bSblymn
549fa0b432bSblymn if (__echoit) {
550fa0b432bSblymn if ( ret == KEY_CODE_YES ) {
551fa0b432bSblymn /* handle [DEL], [BS], and [LEFT] */
552fa0b432bSblymn if ( win->curx &&
553fa0b432bSblymn ( inp == KEY_DC ||
554fa0b432bSblymn inp == KEY_BACKSPACE ||
555fa0b432bSblymn inp == KEY_LEFT )) {
556a5d2c93aSblymn wmove( win, win->cury, win->curx - 1);
557fa0b432bSblymn wdelch( win );
558fa0b432bSblymn }
559fa0b432bSblymn } else {
560fa0b432bSblymn ws[ 0 ] = inp, ws[ 1 ] = L'\0';
561fa0b432bSblymn setcchar( &wc, ws, win->wattr, 0, NULL );
562fa0b432bSblymn wadd_wch( win, &wc );
563fa0b432bSblymn }
564fa0b432bSblymn }
565fa0b432bSblymn
566fa0b432bSblymn if (weset)
567fa0b432bSblymn nocbreak();
568fa0b432bSblymn
569fa0b432bSblymn if (_cursesi_screen->nl && inp == 13)
570fa0b432bSblymn inp = 10;
571fa0b432bSblymn
572fa0b432bSblymn *ch = inp;
573fa0b432bSblymn
574fa0b432bSblymn if ( ret == KEY_CODE_YES )
575fa0b432bSblymn return KEY_CODE_YES;
57680b412b0Sroy return inp < 0 ? ERR : OK;
577fa0b432bSblymn }
578fa0b432bSblymn
579fa0b432bSblymn /*
580fa0b432bSblymn * unget_wch --
581fa0b432bSblymn * Put the wide character back into the input queue.
582fa0b432bSblymn */
583fa0b432bSblymn int
unget_wch(const wchar_t c)584fa0b432bSblymn unget_wch(const wchar_t c)
585fa0b432bSblymn {
5867cc6075bSjdc return __unget((wint_t)c);
587fa0b432bSblymn }
5884aeb00ceSroy
5894aeb00ceSroy /*
5904aeb00ceSroy * __fgetwc_resize --
5914aeb00ceSroy * Any call to fgetwc(3) should use this function instead.
5924aeb00ceSroy */
5934aeb00ceSroy static wint_t
__fgetwc_resize(FILE * infd,bool * resized)5944aeb00ceSroy __fgetwc_resize(FILE *infd, bool *resized)
5954aeb00ceSroy {
5964aeb00ceSroy wint_t c;
5974aeb00ceSroy
5984aeb00ceSroy c = fgetwc(infd);
5994aeb00ceSroy if (c != WEOF)
6004aeb00ceSroy return c;
6014aeb00ceSroy
6024aeb00ceSroy if (!ferror(infd) || errno != EINTR || !_cursesi_screen->resized)
6034aeb00ceSroy return ERR;
6044aeb00ceSroy __CTRACE(__CTRACE_INPUT, "__fgetwc_resize returning KEY_RESIZE\n");
6054f781456Sroy resizeterm(LINES, COLS);
6061f380abcSroy _cursesi_screen->resized = 0;
6074aeb00ceSroy *resized = true;
6084aeb00ceSroy return c;
6094aeb00ceSroy }
610