Unref UI manager when done
[rodin/chimara.git] / interpreters / frotz / input.c
1 /* input.c - High level input functions
2  *      Copyright (c) 1995-1997 Stefan Jokisch
3  *
4  * This file is part of Frotz.
5  *
6  * Frotz is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * Frotz is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include "frotz.h"
22
23 extern int save_undo (void);
24
25 extern zchar stream_read_key (zword, zword);
26 extern zchar stream_read_input (int, zchar *, zword, zword, bool);
27
28 extern void tokenise_line (zword, zword, zword, bool);
29
30 /*
31  * is_terminator
32  *
33  * Check if the given key is an input terminator.
34  *
35  */
36
37 bool is_terminator (zchar key)
38 {
39
40     if (key == ZC_TIME_OUT)
41         return TRUE;
42     if (key == ZC_RETURN)
43         return TRUE;
44     if (key >= ZC_HKEY_MIN && key <= ZC_HKEY_MAX)
45         return TRUE;
46
47     if (h_terminating_keys != 0)
48
49         if (key >= ZC_ARROW_MIN && key <= ZC_MENU_CLICK) {
50
51             zword addr = h_terminating_keys;
52             zbyte c;
53
54             do {
55                 LOW_BYTE (addr, c)
56                 if (c == 255 || key == translate_from_zscii (c))
57                     return TRUE;
58                 addr++;
59             } while (c != 0);
60
61         }
62
63     return FALSE;
64
65 }/* is_terminator */
66
67 /*
68  * z_make_menu, add or remove a menu and branch if successful.
69  *
70  *      zargs[0] = number of menu
71  *      zargs[1] = table of menu entries or 0 to remove menu
72  *
73  */
74
75 void z_make_menu (void)
76 {
77
78     /* This opcode was only used for the Macintosh version of Journey.
79        It controls menus with numbers greater than 2 (menus 0, 1 and 2
80        are system menus). Frotz doesn't implement menus yet. */
81
82     branch (FALSE);
83
84 }/* z_make_menu */
85
86 /*
87  * read_yes_or_no
88  *
89  * Ask the user a question; return true if the answer is yes.
90  *
91  */
92
93 bool read_yes_or_no (const char *s)
94 {
95     zchar key;
96
97     print_string (s);
98     print_string ("? (y/n) >");
99
100     key = stream_read_key (0, 0);
101
102     if (key == 'y' || key == 'Y') {
103         print_string ("y\n");
104         return TRUE;
105     } else {
106         print_string ("n\n");
107         return FALSE;
108     }
109
110 }/* read_yes_or_no */
111
112 /*
113  * read_string
114  *
115  * Read a string from the current input stream.
116  *
117  */
118
119 void read_string (int max, zchar *buffer)
120 {
121     zchar key;
122
123     buffer[0] = 0;
124
125     do {
126
127         key = stream_read_input (max, buffer, 0, 0, FALSE);
128
129     } while (key != ZC_RETURN);
130
131 }/* read_string */
132
133 /*
134  * read_number
135  *
136  * Ask the user to type in a number and return it.
137  *
138  */
139
140 int read_number (void)
141 {
142     zchar buffer[6];
143     int value = 0;
144     int i;
145
146     read_string (5, buffer);
147
148     for (i = 0; buffer[i] != 0; i++)
149         if (buffer[i] >= '0' && buffer[i] <= '9')
150             value = 10 * value + buffer[i] - '0';
151
152     return value;
153
154 }/* read_number */
155
156 /*
157  * z_read, read a line of input and (in V5+) store the terminating key.
158  *
159  *      zargs[0] = address of text buffer
160  *      zargs[1] = address of token buffer
161  *      zargs[2] = timeout in tenths of a second (optional)
162  *      zargs[3] = packed address of routine to be called on timeout
163  *
164  */
165
166 void z_read (void)
167 {
168     zchar buffer[INPUT_BUFFER_SIZE];
169     zword addr;
170     zchar key;
171     zbyte max, size;
172     zbyte c;
173     int i;
174
175     /* Supply default arguments */
176
177     if (zargc < 3)
178         zargs[2] = 0;
179
180     /* Get maximum input size */
181
182     addr = zargs[0];
183
184     LOW_BYTE (addr, max)
185
186     if (h_version <= V4)
187         max--;
188
189     if (max >= INPUT_BUFFER_SIZE)
190         max = INPUT_BUFFER_SIZE - 1;
191
192     /* Get initial input size */
193
194     if (h_version >= V5) {
195         addr++;
196         LOW_BYTE (addr, size)
197     } else size = 0;
198
199     /* Copy initial input to local buffer */
200
201     for (i = 0; i < size; i++) {
202         addr++;
203         LOW_BYTE (addr, c)
204         buffer[i] = translate_from_zscii (c);
205     }
206
207     buffer[i] = 0;
208
209     /* Draw status line for V1 to V3 games */
210
211     if (h_version <= V3)
212         z_show_status ();
213
214     /* Read input from current input stream */
215
216     key = stream_read_input (
217         max, buffer,            /* buffer and size */
218         zargs[2],               /* timeout value   */
219         zargs[3],               /* timeout routine */
220         h_version == V6);       /* no script in V6 */
221
222     if (key == ZC_BAD)
223         return;
224
225     /* Perform save_undo for V1 to V4 games */
226
227     if (h_version <= V4)
228         save_undo ();
229
230     /* Copy local buffer back to dynamic memory */
231
232     for (i = 0; buffer[i] != 0; i++) {
233
234         if (key == ZC_RETURN) {
235
236             if (buffer[i] >= 'A' && buffer[i] <= 'Z')
237                 buffer[i] += 'a' - 'A';
238             if (buffer[i] >= 0xc0 && buffer[i] <= 0xde && buffer[i] != 0xd7)
239                 buffer[i] += 0x20;
240
241         }
242
243         storeb ((zword) (zargs[0] + ((h_version <= V4) ? 1 : 2) + i), translate_to_zscii (buffer[i]));
244
245     }
246
247     /* Add null character (V1-V4) or write input length into 2nd byte */
248
249     if (h_version <= V4)
250         storeb ((zword) (zargs[0] + 1 + i), 0);
251     else
252         storeb ((zword) (zargs[0] + 1), i);
253
254     /* Tokenise line if a token buffer is present */
255
256     if (key == ZC_RETURN && zargs[1] != 0)
257         tokenise_line (zargs[0], zargs[1], 0, FALSE);
258
259     /* Store key */
260
261     if (h_version >= V5)
262         store (translate_to_zscii (key));
263
264 }/* z_read */
265
266 /*
267  * z_read_char, read and store a key.
268  *
269  *      zargs[0] = input device (must be 1)
270  *      zargs[1] = timeout in tenths of a second (optional)
271  *      zargs[2] = packed address of routine to be called on timeout
272  *
273  */
274
275 void z_read_char (void)
276 {
277     zchar key;
278
279     /* Supply default arguments */
280
281     if (zargc < 2)
282         zargs[1] = 0;
283
284     /* Read input from the current input stream */
285
286     key = stream_read_key (
287         zargs[1],       /* timeout value   */
288         zargs[2]);      /* timeout routine */
289
290     if (key == ZC_BAD)
291         return;
292
293     /* Store key */
294
295     store (translate_to_zscii (key));
296
297 }/* z_read_char */
298