Unref UI manager when done
[rodin/chimara.git] / interpreters / frotz / stream.c
1 /* stream.c - IO stream implementation
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 /* glkify */
24 zchar console_read_input (int max, zchar *buf, zword timeout, bool continued)
25 {
26     return os_read_line(max, buf, timeout, max, continued);
27 }
28 zchar console_read_key (zword timeout)
29 {
30     return os_read_key(timeout, 0);
31 }
32
33 extern bool validate_click (void);
34
35 extern void replay_open (void);
36 extern void replay_close (void);
37 extern void memory_open (zword, zword, bool);
38 extern void memory_close (void);
39 extern void record_open (void);
40 extern void record_close (void);
41 extern void script_open (void);
42 extern void script_close (void);
43
44 extern void memory_word (const zchar *);
45 extern void memory_new_line (void);
46 extern void record_write_key (zchar);
47 extern void record_write_input (const zchar *, zchar);
48 extern void script_char (zchar);
49 extern void script_word (const zchar *);
50 extern void script_new_line (void);
51 extern void script_write_input (const zchar *, zchar);
52 extern void script_erase_input (const zchar *);
53 extern void script_mssg_on (void);
54 extern void script_mssg_off (void);
55 extern void screen_char (zchar);
56 extern void screen_word (const zchar *);
57 extern void screen_new_line (void);
58 extern void screen_write_input (const zchar *, zchar);
59 extern void screen_erase_input (const zchar *);
60 extern void screen_mssg_on (void);
61 extern void screen_mssg_off (void);
62
63 extern zchar replay_read_key (void);
64 extern zchar replay_read_input (zchar *);
65 extern zchar console_read_key (zword);
66 extern zchar console_read_input (int, zchar *, zword, bool);
67
68 extern int direct_call (zword);
69
70 /*
71  * stream_mssg_on
72  *
73  * Start printing a "debugging" message.
74  *
75  */
76
77 void stream_mssg_on (void)
78 {
79
80     flush_buffer ();
81
82     if (ostream_screen)
83             screen_mssg_on ();
84     if (ostream_script && enable_scripting)
85         script_mssg_on ();
86
87     message = TRUE;
88
89 }/* stream_mssg_on */
90
91 /*
92  * stream_mssg_off
93  *
94  * Stop printing a "debugging" message.
95  *
96  */
97
98 void stream_mssg_off (void)
99 {
100
101     flush_buffer ();
102
103     if (ostream_screen)
104         screen_mssg_off ();
105     if (ostream_script && enable_scripting)
106         script_mssg_off ();
107
108     message = FALSE;
109
110 }/* stream_mssg_off */
111
112 /*
113  * z_output_stream, open or close an output stream.
114  *
115  *      zargs[0] = stream to open (positive) or close (negative)
116  *      zargs[1] = address to redirect output to (stream 3 only)
117  *      zargs[2] = width of redirected output (stream 3 only, optional)
118  *
119  */
120
121 void z_output_stream (void)
122 {
123
124     flush_buffer ();
125
126     switch ((short) zargs[0]) {
127
128     case  1: ostream_screen = TRUE;
129              break;
130     case -1: ostream_screen = FALSE;
131              break;
132     case  2: if (!ostream_script) script_open ();
133              break;
134     case -2: if (ostream_script) script_close ();
135              break;
136     case  3: memory_open (zargs[1], zargs[2], zargc >= 3);
137              break;
138     case -3: memory_close ();
139              break;
140     case  4: if (!ostream_record) record_open ();
141              break;
142     case -4: if (ostream_record) record_close ();
143              break;
144
145     }
146
147 }/* z_output_stream */
148
149 /*
150  * stream_char
151  *
152  * Send a single character to the output stream.
153  *
154  */
155
156 void stream_char (zchar c)
157 {
158
159     if (ostream_screen)
160         screen_char (c);
161     if (ostream_script && enable_scripting)
162         script_char (c);
163
164 }/* stream_char */
165
166 /*
167  * stream_word
168  *
169  * Send a string of characters to the output streams.
170  *
171  */
172
173 void stream_word (const zchar *s)
174 {
175
176     if (ostream_memory && !message)
177
178         memory_word (s);
179
180     else {
181
182         if (ostream_screen)
183             screen_word (s);
184         if (ostream_script && enable_scripting)
185             script_word (s);
186
187     }
188
189 }/* stream_word */
190
191 /*
192  * stream_new_line
193  *
194  * Send a newline to the output streams.
195  *
196  */
197
198 void stream_new_line (void)
199 {
200
201     if (ostream_memory && !message)
202
203         memory_new_line ();
204
205     else {
206
207         if (ostream_screen)
208             screen_new_line ();
209         if (ostream_script && enable_scripting)
210             script_new_line ();
211
212     }
213
214 }/* stream_new_line */
215
216 /*
217  * z_input_stream, select an input stream.
218  *
219  *      zargs[0] = input stream to be selected
220  *
221  */
222
223 void z_input_stream (void)
224 {
225
226     flush_buffer ();
227
228     if (zargs[0] == 0 && istream_replay)
229         replay_close ();
230     if (zargs[0] == 1 && !istream_replay)
231         replay_open ();
232
233 }/* z_input_stream */
234
235 /*
236  * stream_read_key
237  *
238  * Read a single keystroke from the current input stream.
239  *
240  */
241
242 zchar stream_read_key ( zword timeout, zword routine )
243 {
244     zchar key = ZC_BAD;
245
246     flush_buffer ();
247
248     /* Read key from current input stream */
249
250 continue_input:
251
252     do {
253
254         if (istream_replay)
255             key = replay_read_key ();
256         else
257             key = console_read_key (timeout);
258
259     } while (key == ZC_BAD);
260
261     /* Verify mouse clicks */
262
263 /* glkify
264     if (key == ZC_SINGLE_CLICK || key == ZC_DOUBLE_CLICK)
265         if (!validate_click ())
266             goto continue_input;
267 */
268
269     /* Copy key to the command file */
270
271     if (ostream_record && !istream_replay)
272         record_write_key (key);
273
274     /* Handle timeouts */
275
276     if (key == ZC_TIME_OUT)
277         if (direct_call (routine) == 0)
278             goto continue_input;
279
280     /* Return key */
281
282     return key;
283
284 }/* stream_read_key */
285
286 /*
287  * stream_read_input
288  *
289  * Read a line of input from the current input stream.
290  *
291  */
292
293 zchar stream_read_input ( int max, zchar *buf,
294                           zword timeout, zword routine,
295                           bool no_scripting )
296 {
297     zchar key = ZC_BAD;
298
299     flush_buffer ();
300
301     /* Remove initial input from the transscript file or from the screen */
302
303     if (ostream_script && enable_scripting && !no_scripting)
304         script_erase_input (buf);
305 //glkify    if (istream_replay)
306 //glkify        screen_erase_input (buf);
307
308     /* Read input line from current input stream */
309
310 continue_input:
311
312     do {
313
314         if (istream_replay)
315             key = replay_read_input (buf);
316         else
317             key = console_read_input (max, buf, timeout, key != ZC_BAD);
318
319     } while (key == ZC_BAD);
320
321     /* Verify mouse clicks */
322
323 /* glkify
324     if (key == ZC_SINGLE_CLICK || key == ZC_DOUBLE_CLICK)
325         if (!validate_click ())
326             goto continue_input;
327 */
328
329     /* Copy input line to the command file */
330
331     if (ostream_record && !istream_replay)
332         record_write_input (buf, key);
333
334     /* Handle timeouts */
335
336     if (key == ZC_TIME_OUT)
337         if (direct_call (routine) == 0)
338             goto continue_input;
339
340     /* Copy input line to transscript file or to the screen */
341
342     if (ostream_script && enable_scripting && !no_scripting)
343         script_write_input (buf, key);
344 //glkify    if (istream_replay)
345 //glkify        screen_write_input (buf, key);
346
347     /* Return terminating key */
348
349     return key;
350
351 }/* stream_read_input */