Bug fixes
[rodin/chimara.git] / interpreters / nitfol / io.c
1 /*  Nitfol - z-machine interpreter using Glk for output.
2     Copyright (C) 1999  Evin Robertson
3
4     This program is free software; you can redistribute it and/or modify
5     it under the terms of the GNU General Public License as published by
6     the Free Software Foundation; either version 2 of the License, or
7     (at your option) any later version.
8
9     This program is distributed in the hope that it will be useful,
10     but WITHOUT ANY WARRANTY; without even the implied warranty of
11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12     GNU General Public License for more details.
13
14     You should have received a copy of the GNU General Public License
15     along with this program; if not, write to the Free Software
16     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
17
18     The author can be reached at nitfol@deja.com
19 */
20 #include "nitfol.h"
21 #include "io.h"
22
23 #ifdef HEADER
24
25 typedef struct z_window *zwinid;
26
27 #endif
28
29 BOOL is_fixed;       /* If we are forcing output to be fixed-width */
30
31
32 /* descriptions of z-machine colors, in glk 0x00rrggbb style.
33    -1 means to call glk_stylehint_clear instead of glk_stylehint_set.
34    The 'current color' will be overwritten on calls to set_colour.
35
36    Go ahead and customize these (making background colors lighter than
37    foreground colors might be interesting)
38 */
39
40 glsi32 bgcolortable[] = {
41   -1L,          /* current color */
42   -1L,          /* defualt setting */
43   0x00000000L,  /* black */
44   0x00ff0000L,  /* red */
45   0x00008000L,  /* green */
46   0x00ffff00L,  /* yellow */
47   0x000000ffL,  /* blue */
48   0x00ff00ffL,  /* magenta */
49   0x0000ffffL,  /* cyan */
50   0x00ffffffL,  /* white */
51   0x00c0c0c0L,  /* light grey */
52   0x00808080L,  /* medium grey */
53   0x00404040L   /* dark grey */
54 };
55
56 glsi32 fgcolortable[] = {
57   -1L,          /* current color */
58   -1L,          /* defualt setting */
59   0x00000000L,  /* black */
60   0x00ff0000L,  /* red */
61   0x00008000L,  /* green */
62   0x00ffff00L,  /* yellow */
63   0x000000ffL,  /* blue */
64   0x00ff00ffL,  /* magenta */
65   0x0000ffffL,  /* cyan */
66   0x00ffffffL,  /* white */
67   0x00c0c0c0L,  /* light grey */
68   0x00808080L,  /* medium grey */
69   0x00404040L   /* dark grey */
70 };
71
72
73 static void killglkwithcolor(glui32 styl, int fore, int back)
74 {
75   if(fgcolortable[fore] == -1)
76     glk_stylehint_clear(wintype_AllTypes, styl,
77                         stylehint_TextColor);
78   else
79     glk_stylehint_set(wintype_AllTypes, styl,
80                       stylehint_TextColor, fgcolortable[fore]);
81
82   if(bgcolortable[back] == -1)
83     glk_stylehint_clear(wintype_AllTypes, styl,
84                         stylehint_BackColor);
85   else
86     glk_stylehint_set(wintype_AllTypes, styl,
87                       stylehint_BackColor, bgcolortable[back]);
88 }
89
90
91 static void set_stylehints(char fore, char back)
92 {
93   glui32 n;
94   for(n = 0; n < style_NUMSTYLES; n++)
95     killglkwithcolor(n, fore, back);
96
97   /* Subheader will be used for bold */
98   glk_stylehint_set(wintype_TextBuffer, style_Subheader,
99                     stylehint_Weight, 1);
100
101   /* BlockQuote will be used for reverse proportional text */
102   glk_stylehint_set(wintype_TextBuffer, style_BlockQuote,
103                     stylehint_Proportional, 0);
104   glk_stylehint_set(wintype_TextBuffer, style_BlockQuote,
105                     stylehint_Justification, stylehint_just_Centered);
106 #ifdef stylehint_ReverseColor
107   glk_stylehint_set(wintype_TextBuffer, style_BlockQuote,
108                     stylehint_ReverseColor, 1);
109 #endif
110
111   /* User1 will be used for bold italics */
112   glk_stylehint_set(wintype_TextBuffer, style_User1,
113                     stylehint_Weight, 1);
114   glk_stylehint_set(wintype_TextBuffer, style_User1,
115                     stylehint_Oblique, 1);
116
117   /* User2 will be used for proportional bold/italic */
118   glk_stylehint_set(wintype_TextBuffer, style_User2,
119                     stylehint_Proportional, 0);
120   glk_stylehint_set(wintype_TextBuffer, style_User2,
121                     stylehint_Weight, 1);
122 }
123
124 #define sBOLD 1
125 #define sITAL 2
126 #define sFIXE 4
127 #define sREVE 8
128
129 #if 0
130
131 static glui32 bitmap_to_style[16] = {
132   style_Normal,
133   style_Subheader,   /* sBOLD */
134   style_Emphasized,  /* sITAL */
135   style_User1,       /* sBOLD | sITAL */
136   style_Preformatted,/* sFIXE */
137   style_User2,       /* sFIXE | sBOLD */
138   style_User2,       /* sFIXE | sITAL */
139   style_User2,       /* sFIXE | sBOLD | sITAL*/
140   style_BlockQuote,  /* sREVE */
141   style_BlockQuote,  /* sREVE | sBOLD */
142   style_BlockQuote,  /* sREVE | sITAL */
143   style_BlockQuote,  /* sREVE | sBOLD | sITAL */
144   style_BlockQuote,  /* sFIXE | sREVE */
145   style_BlockQuote,  /* sFIXE | sREVE | sBOLD */
146   style_BlockQuote,  /* sFIXE | sREVE | sITAL */
147   style_BlockQuote   /* sFIXE | sREVE | sBOLD | sITAL */
148 };
149
150 #else
151
152 static glui32 bitmap_to_style[16] = {
153   style_Normal,
154   style_Subheader,   /* sBOLD */
155   style_Emphasized,  /* sITAL */
156   style_Subheader,   /* sBOLD | sITAL */
157   style_Preformatted,/* sFIXE */
158   style_Subheader,   /* sFIXE | sBOLD */
159   style_Emphasized,  /* sFIXE | sITAL */
160   style_Subheader,   /* sFIXE | sBOLD | sITAL*/
161   style_Normal,
162   style_Subheader,   /* sBOLD */
163   style_Emphasized,  /* sITAL */
164   style_Subheader,   /* sBOLD | sITAL */
165   style_Preformatted,/* sFIXE */
166   style_Subheader,   /* sFIXE | sBOLD */
167   style_Emphasized,  /* sFIXE | sITAL */
168   style_Subheader    /* sFIXE | sBOLD | sITAL*/
169 };
170
171 #endif
172
173 typedef struct {
174   char fore;
175   char back;
176   unsigned char style;
177 } colorstyle;
178
179 typedef struct {
180   glui32 image_num;
181   glui32 x, y;
182   glui32 width, height;
183 } z_image;
184
185
186 struct z_window {
187   winid_t win;
188   strid_t str;
189   glui32 wintype;
190   glui32 method;
191
192   strid_t transcript;
193
194   BOOL glk_input_pending;
195   glui32 pending_input_type;
196   glui32 pending_input_length;
197
198   /* for upper window of v3 - returns # of lines drawn */
199   glui32 (*draw_callback)(winid_t win, glui32 width, glui32 height);
200   BOOL (*mouse_callback)(BOOL is_char_event, winid_t win, glui32 x, glui32 y);
201   
202   glui32 width, height;
203   glui32 x1, y1, x2, y2;
204
205   glui32 last_height;   /* What the height was last time we got input */
206   glui32 biggest_height;/* The biggest it's been since */
207
208   glui32 curr_offset;   /* offset into text_buffer/color_buffer */
209   glui32 max_offset;    /* curr_offset must stay < max_offset */
210   glui32 buffer_size;   /* max_offset must stay < buffer_size */
211
212   BOOL dirty;           /* Has window been changed since last redraw? */
213   BOOL defined;         /* Is our location well defined? */
214
215   unsigned char *text_buffer;  /* whole window for grid, current line for buffer */
216   colorstyle *color_buffer;
217
218   z_image images[12];
219
220   colorstyle current;
221   colorstyle actual;
222 };
223
224
225 #define num_z_windows 16
226
227 static struct z_window game_windows[num_z_windows];
228
229 static glui32 upper_width, upper_height;
230
231
232 static int waitforinput(zwinid window, glui32 *val,
233                         BOOL (*timer_callback)(zword), zword timer_arg);
234
235
236 void set_glk_stream_current(void)
237 {
238   z_flush_text(&game_windows[0]);
239   glk_stream_set_current(game_windows[0].str);
240 }
241
242 void draw_intext_picture(zwinid window, glui32 picture, glui32 alignment)
243 {
244   z_flush_text(window);
245   wrap_glk_image_draw(window->win, picture, alignment, 0);
246 }
247
248 void draw_picture(zwinid window, glui32 picture, glui32 x, glui32 y)
249 {
250   int i;
251   int useimage = -1;
252   glui32 width, height;
253
254   wrap_glk_image_get_info(operand[0], &width, &height);
255
256   for(i = 0; i < 12; i++) {
257     if(is_in_bounds(window->images[i].x, window->images[i].y,
258                     window->images[i].width, window->images[i].height,
259                     x, y, width, height))
260       useimage = i;
261   }
262   if(useimage == -1)
263     for(i = 0; i < 12; i++)
264       if(window->images[i].image_num == 0)
265         useimage = i;
266   if(useimage == -1)
267     return;
268
269   window->images[useimage].image_num = picture;
270   window->images[useimage].x = x;
271   window->images[useimage].y = y;
272   window->images[useimage].width = width;
273   window->images[useimage].height = height;
274 }
275
276
277 static int showstuffcount = 0;
278
279 /* Show an interpreter message */
280 void showstuff(const char *title, const char *type, const char *message, offset number)
281 {
282   static BOOL loopy = FALSE;
283   if(loopy) {
284     loopy = FALSE;
285     n_show_fatal(E_SYSTEM, "loopy message reporting", 0);
286   }
287   loopy = TRUE;
288
289   z_pause_timed_input(&game_windows[0]);
290   z_flush_text(&game_windows[0]);
291   glk_stream_set_current(game_windows[0].str);
292
293   glk_set_style(style_Alert);
294   w_glk_put_string("\n[");
295   w_glk_put_string(title);
296   w_glk_put_string(": ");
297   w_glk_put_string(type);
298   w_glk_put_string("]: ");
299   w_glk_put_string(message);
300   w_glk_put_string(" (");
301   g_print_snumber(number);
302   w_glk_put_string(") ");
303
304 #ifdef DEBUGGING
305   infix_gprint_loc(stack_get_depth(), 0);
306 #else
307   w_glk_put_string("PC=");
308   g_print_number(oldPC);
309   glk_put_char('\n');
310 #endif
311
312   if(++showstuffcount == 100) {
313     w_glk_put_string("[pausing every 100 errors]\n");
314     z_wait_for_key(&game_windows[0]);
315   }
316
317   glk_set_style(style_Normal);
318
319   loopy = FALSE;
320 }
321
322
323 void init_lower(zwinid *lower)
324 {
325   zwinid lower_win = &game_windows[0];
326   glui32 i;
327
328   if(lower)
329     *lower = lower_win;
330
331   if(lower_win->win) {
332     z_pause_timed_input(lower_win);
333     glk_window_close(lower_win->win, NULL);
334   }
335
336   set_stylehints(lower_win->current.fore,
337                  lower_win->current.back);
338
339
340   lower_win->dirty = TRUE;
341   lower_win->wintype = wintype_TextBuffer;
342   lower_win->method = winmethod_Below;
343   lower_win->curr_offset = 0;
344   lower_win->max_offset = 80 * 24;
345   lower_win->buffer_size = lower_win->max_offset;
346
347   if(!lower_win->text_buffer)
348     lower_win->text_buffer = (unsigned char *) n_malloc(lower_win->buffer_size);
349   if(!lower_win->color_buffer)
350     lower_win->color_buffer = (colorstyle *) n_malloc(lower_win->buffer_size * sizeof(colorstyle));
351
352   for(i = 0; i < lower_win->buffer_size; i++) {
353     lower_win->text_buffer[i] = ' ';
354     lower_win->color_buffer[i] = lower_win->current;
355   }
356
357   lower_win->actual = lower_win->current;
358
359   lower_win->win = glk_window_open(game_windows[1].win,
360                                     winmethod_Below | winmethod_Proportional,
361                                     50,  /* Percent doesn't matter */
362                                     wintype_TextBuffer, 0);
363
364
365   if(lower_win->win == 0) {
366     n_show_fatal(E_OUTPUT, "cannot open lower window", 0);
367     return;
368   }
369
370   lower_win->str = glk_window_get_stream(lower_win->win);
371
372   if(lower_win->transcript)
373     glk_window_set_echo_stream(lower_win->win, lower_win->transcript);
374 }
375
376
377 void init_upper(zwinid *upper)
378 {
379   zwinid upper_win = &game_windows[1];
380   glui32 i;
381
382   if(upper)
383     *upper = upper_win;
384
385   if(upper_win->win) {
386     z_pause_timed_input(upper_win);
387     glk_window_close(upper_win->win, NULL);
388   }
389
390   upper_win->dirty = TRUE;
391   upper_win->wintype = wintype_TextGrid;
392   upper_win->method = winmethod_Above | winmethod_Fixed;
393   upper_win->height = 0;
394   upper_win->width = upper_width;
395   upper_win->curr_offset = 0;
396   upper_win->max_offset = upper_height * upper_width;
397   upper_win->buffer_size = upper_win->max_offset;
398
399   if(!upper_win->text_buffer)
400     upper_win->text_buffer = (unsigned char *) n_malloc(upper_win->buffer_size);
401   if(!upper_win->color_buffer)
402     upper_win->color_buffer = (colorstyle *) n_malloc(upper_win->buffer_size * sizeof(colorstyle));
403
404   for(i = 0; i < upper_win->buffer_size; i++) {
405     upper_win->text_buffer[i] = ' ';
406     upper_win->color_buffer[i] = upper_win->current;
407   }
408
409   upper_win->actual = upper_win->current;
410
411   upper_win->win = glk_window_open(game_windows[0].win,
412                                     winmethod_Above | winmethod_Fixed,
413                                     1, /* XXX huh? upper_height, */
414                                     wintype_TextGrid, 1);
415
416   if(upper_win->win == 0) {
417     upper_win->str = 0;
418     return;
419   }
420
421   upper_win->str = glk_window_get_stream(upper_win->win);
422
423   if(upper_win->str == 0) {
424     glk_window_close(upper_win->win, NULL);
425     upper_win->win = 0;
426     return;
427   }
428 }
429
430
431 void z_init_windows(BOOL dofixed,
432                     glui32 (*draw_callback)(winid_t, glui32, glui32),
433                     BOOL (*mouse_callback)(BOOL, winid_t, glui32, glui32),
434                     glui32 maxwidth, glui32 maxheight,
435                     zwinid *upper, zwinid *lower)
436 {
437   colorstyle defaultstyle;
438   defaultstyle.fore = 1; defaultstyle.back = 1; defaultstyle.style = 0;
439
440   is_fixed = dofixed;
441
442   kill_windows();
443
444   upper_width = maxwidth; upper_height = maxheight;
445
446   game_windows[0].current = game_windows[1].current = defaultstyle;
447   game_windows[1].draw_callback  = draw_callback;
448   game_windows[1].mouse_callback = mouse_callback;
449
450   init_lower(lower);
451   init_upper(upper);
452 }
453
454
455 zwinid z_split_screen(glui32 wintype, glui32 method,
456                       glui32 (*draw_callback)(winid_t, glui32, glui32),
457                       BOOL (*mouse_callback)(BOOL, winid_t, glui32, glui32))
458 {
459   int i;
460   for(i = 0; i < num_z_windows; i++) {
461     if(!game_windows[i].win) {
462       winid_t root = glk_window_get_root();
463       game_windows[i].win = glk_window_open(root, method, 0, wintype, 0);
464       game_windows[i].str = glk_window_get_stream(game_windows[i].win);
465       game_windows[i].wintype = wintype;
466       game_windows[i].method = method;
467       game_windows[i].transcript = NULL;
468       game_windows[i].glk_input_pending = FALSE;
469       game_windows[i].draw_callback = draw_callback;
470       game_windows[i].mouse_callback = mouse_callback;
471       game_windows[i].width = 0;
472       game_windows[i].height = 0;
473       game_windows[i].curr_offset = 0;
474       game_windows[i].max_offset = 1;
475       game_windows[i].buffer_size = 2;
476       game_windows[i].text_buffer = n_malloc(2);
477       game_windows[i].color_buffer = n_malloc(2);
478       game_windows[i].dirty = TRUE;
479       return &game_windows[i];
480     }
481   }
482   return NULL;
483 }
484
485
486 void z_kill_window(zwinid win)
487 {
488   if(!win)
489     return;
490   n_free(win->text_buffer);
491   win->text_buffer = NULL;
492   n_free(win->color_buffer);
493   win->color_buffer = NULL;
494   win->transcript = NULL;
495   glk_window_close(win->win, NULL);
496   win->win = NULL;
497   win->str = NULL;
498 }
499
500
501 /* close any open windows */
502 void kill_windows(void)
503 {
504   int i;
505   
506   for(i = 0; i < num_z_windows; i++)
507     z_clear_window(&game_windows[i]);
508
509   free_windows();
510   for(i = 0; i < num_z_windows; i++) {
511     if(game_windows[i].win) {
512       game_windows[i].transcript = NULL;
513
514       glk_window_close(game_windows[i].win, NULL);
515       game_windows[i].win = NULL;
516       game_windows[i].str = NULL;
517     }
518   }
519   showstuffcount = 0;
520 }
521
522
523 /* free memory space used by windows, but don't close them */
524 void free_windows(void)
525 {
526   int i;
527
528   z_flush_all_windows();
529
530   for(i = 0; i < num_z_windows; i++) {
531     if(game_windows[i].win) {
532       n_free(game_windows[i].text_buffer);
533       game_windows[i].text_buffer = NULL;
534
535       n_free(game_windows[i].color_buffer);
536       game_windows[i].color_buffer = NULL;
537     }
538   }
539 }
540
541 zwinid z_find_win(winid_t win)
542 {
543   int i;
544   for(i = 0; i < num_z_windows; i++) {
545     if(game_windows[i].win == win)
546       return &game_windows[i];
547   }
548   return NULL;
549 }
550
551
552 static BOOL coloreq(colorstyle a, colorstyle b) /* return true if colors are equivalent */
553 {
554   return (fgcolortable[(int) a.fore] == fgcolortable[(int) b.fore]) &&
555          (bgcolortable[(int) a.back] == bgcolortable[(int) b.back]);
556 }
557
558
559 static void checkforblockquote(zwinid window, zwinid dest_win)
560 {
561   if(window->biggest_height > window->last_height &&
562      window->biggest_height > window->height) {
563     /* find borders of the blockquote */
564     unsigned leftx = window->width, rightx = 0;
565     unsigned topy = window->biggest_height;
566     unsigned bottomy = window->height;
567     unsigned x, y, i;
568
569     i = window->height * window->width;
570     for(y = window->height; y < window->biggest_height; y++)
571       for(x = 0; x < window->width; x++)
572         if(window->text_buffer[i++] != ' ') {
573           if(x < leftx)
574             leftx = x;
575           if(x > rightx)
576             rightx = x;
577           if(y < topy)
578             topy = y;
579           if(y > bottomy)
580             bottomy = y;
581         }
582     
583     z_pause_timed_input(dest_win);
584     glk_stream_set_current(game_windows[1].str);
585     glk_put_char(10);
586     glk_set_style(style_BlockQuote);
587     
588     /* draw the blockquote */
589     for(y = topy; y <= bottomy; y++) {
590       i = y * window->width + leftx;
591       for(x = leftx; x <= rightx; x++)
592         glk_put_char(window->text_buffer[i++]);
593       glk_put_char(10);
594     }
595   }
596 }
597
598
599 void z_pause_timed_input(zwinid window)
600 {
601   event_t eep;
602   if(window->glk_input_pending) {
603     window->glk_input_pending = FALSE;
604
605     switch(window->pending_input_type) {
606     case evtype_CharInput:
607       glk_cancel_char_event(window->win);
608       break;
609     case evtype_LineInput:
610       glk_cancel_line_event(window->win, &eep);
611       window->pending_input_length = eep.val1;
612     }
613   }
614 }
615
616
617 void z_flush_all_windows(void)
618 {
619   int window;
620   for(window = 0; window < num_z_windows; window++) {
621     if(game_windows[window].dirty) {
622       z_pause_timed_input(&game_windows[window]);
623       
624       switch(game_windows[window].wintype) {
625       case wintype_TextBuffer:
626         z_flush_text(&game_windows[window]);
627         break;
628       case wintype_TextGrid:
629         z_flush_fixed(&game_windows[window]);
630         break;
631       case wintype_Graphics:
632         z_flush_graphics(&game_windows[window]);
633         break;
634       }
635     }
636   }
637 }
638
639 void z_draw_all_windows(void)
640 {
641   int window;
642   for(window = 0; window < num_z_windows; window++) {
643     if(game_windows[window].wintype == wintype_TextGrid) {
644       game_windows[window].dirty = TRUE;
645       z_flush_fixed(&game_windows[window]);
646     }
647   }
648 }
649
650
651 static void z_put_styled_string(zwinid window, unsigned char *text,
652                                 colorstyle *color, glui32 length)
653 {
654   glui32 n;
655   colorstyle laststyle = color[0];
656
657   if(!length)
658     return;
659
660   glk_set_style_stream(window->str, bitmap_to_style[laststyle.style]);
661
662   for(n = 0; n < length; n++) {
663     if(color[n].style != laststyle.style)
664       glk_set_style_stream(window->str, bitmap_to_style[color[n].style]);
665     glk_put_char_stream(window->str, text[n]);
666     laststyle = color[n];
667   }
668 }
669
670 void z_flush_fixed(zwinid window)
671 {
672   glui32 winx, winy;
673   winid_t o;
674   glui32 start_line, end_line;
675
676   /* If there's no such window, give up */
677   if(!window->win || !window->str ||
678      !window->text_buffer || !window->color_buffer)
679     return;
680
681   /* glk doesn't allow writing to a window while input is pending */
682   z_pause_timed_input(window);
683
684   end_line = window->height;
685
686   /* Has the window grown and shrunk?  If so, probably because someone wants
687      to draw a box quote - don't let them shrink the window quite so fast */
688   if(window->biggest_height > window->last_height &&
689      window->biggest_height > window->height)
690     end_line = window->biggest_height;
691   
692   /* For v3 games, there's a callback function to draw the room name and
693      score; if this is present, we start drawing at a lower position */
694   start_line = 0;
695   if(window->draw_callback)
696     start_line = window->draw_callback(NULL, 0, 0);
697   end_line += start_line;
698
699   o = glk_window_get_parent(window->win);
700   glk_window_set_arrangement(o, window->method,
701                              end_line, window->win);
702   glk_window_get_size(window->win, &winx, &winy);
703
704   if(window->draw_callback) {
705     glk_stream_set_current(window->str);
706     glk_window_clear(window->win);
707     glk_window_move_cursor(window->win, 0, 0);
708     window->draw_callback(window->win, winx, winy);
709   }
710
711   if(end_line > start_line && window->dirty) {
712
713     unsigned padleft = 0, padmiddle = 0, padright = 0;
714     unsigned skipleft = 0, skipmiddle = 0, skipright = 0;
715     unsigned width;
716     unsigned firstwidth, lastwidth;
717
718     unsigned x, y, i;
719
720     /* Calculate how much space is used for margins */
721
722     unsigned left_margin = window->width, right_margin = window->width;
723
724     i = 0;
725     for(y = start_line; y < end_line; y++) {
726       
727       for(x = 0; x < window->width; x++)
728         if(window->text_buffer[i + x] != ' ') {
729           if(x < left_margin)
730             left_margin = x;
731           break;
732         }
733       
734       for(x = 0; x < window->width; x++)
735         if(window->text_buffer[i + window->width - x - 1] != ' ') {
736           if(x < right_margin)
737             right_margin = x;
738           break;
739         }
740       
741       i += window->width;
742     }
743     
744     firstwidth = window->width; lastwidth = 0;
745     
746     if(start_line + 1 == end_line) {
747       unsigned longestx = 0;
748       unsigned longestlen = 0;
749       unsigned thisx = 0;
750       unsigned thislen = 0;
751       colorstyle lastcolor;
752       width = window->width;
753       
754       for(x = skipleft; x < width + skipleft; x++) {
755         if(window->text_buffer[x] == ' '
756            && (!thislen || coloreq(window->color_buffer[x], lastcolor))) {
757           if(!thislen)
758             thisx = x;
759           thislen++;
760           lastcolor = window->color_buffer[x];
761         } else {
762           if(thislen > longestlen) {
763             longestx = thisx;
764             longestlen = thislen;
765           }
766           thislen = 0;
767         }
768       }
769       if(longestlen > 4) {
770         firstwidth = longestx - skipleft;
771         skipmiddle = longestlen - 1;
772         lastwidth = width - firstwidth - skipmiddle;
773       }
774     }
775     
776     if(skipmiddle && winx < firstwidth + 2 + lastwidth)
777       padmiddle = 2;
778     
779     if(lastwidth && winx >= firstwidth + padmiddle + lastwidth) {
780       padmiddle = winx - firstwidth - lastwidth;
781     } else {
782       if(winx >= window->width)
783         width = window->width;
784       else
785         width = winx;
786       
787       if(right_margin + left_margin) {
788         if(winx > window->width)
789           padleft = (unsigned) ((winx - window->width) * (((float) left_margin) / (right_margin + left_margin)));
790         else
791           skipleft = (unsigned) ((window->width - winx) * (((float) left_margin) / (right_margin + left_margin)));
792       }
793       else {
794         padleft = winx - window->width;
795       }
796       
797       if(skipleft > left_margin)
798         skipleft = left_margin;
799       
800       if(winx > window->width)
801         padright = winx - window->width - padleft;
802       else
803         skipright = window->width - winx - skipleft;
804       
805       if(width < firstwidth + padmiddle) {
806         firstwidth = width;
807         padmiddle = 0;
808         lastwidth = 0;
809       } else if(width < firstwidth + padmiddle + lastwidth) {
810         lastwidth = width - firstwidth - padmiddle;
811       }
812     }
813
814     
815     glk_stream_set_current(window->str);
816     glk_window_move_cursor(window->win, 0, start_line);
817
818     /* draw to the upper window */
819     i = 0;
820     for(y = start_line; y < end_line; y++) {
821
822       for(x = 0; x < padleft; x++)
823         glk_put_char(' ');
824
825       i += skipleft;
826
827       z_put_styled_string(window, window->text_buffer + i,
828                           window->color_buffer + i, firstwidth);
829       i += firstwidth;
830
831       for(x = 0; x < padmiddle; x++)
832         glk_put_char(' ');
833       i += skipmiddle;
834       
835       z_put_styled_string(window, window->text_buffer + i,
836                           window->color_buffer + i, lastwidth);
837       i += lastwidth;
838
839       for(x = 0; x < padright; x++)
840         glk_put_char(' ');
841
842       i += skipright;
843     }
844
845     /* Bureaucracy needs the cursor positioned and visible in upper window. */
846     glk_window_move_cursor(window->win,
847                            window->curr_offset % window->width,
848                            window->curr_offset / window->width);
849     window->dirty = FALSE;
850   }
851 }
852
853
854 void z_flush_text(zwinid window)
855 {
856   z_pause_timed_input(window);
857
858   if(!window->win || !window->str
859      || !window->text_buffer || !window->color_buffer
860      || window->curr_offset == 0) {
861     window->curr_offset = 0;
862     return;
863   }
864   
865   z_put_styled_string(window, window->text_buffer, window->color_buffer,
866                       window->curr_offset);
867
868   window->curr_offset = 0;
869   window->dirty = FALSE;
870 }
871
872
873 void z_flush_graphics(zwinid window)
874 {
875   int i;
876   glui32 winx, winy;
877   float xratio, yratio;
878   winid_t parent;
879
880   if(!window->win)
881     return;
882
883   glk_window_get_size(window->win, &winx, &winy);
884   xratio = ((float) winx) / window->width;
885   yratio = ((float) winy) / window->height;
886
887   parent = glk_window_get_parent(window->win);
888
889   /* We want the window to maintain its original height/width ratio */
890   switch(window->method & winmethod_DirMask) {
891   case winmethod_Left:   /* Left and right splits mean height is fixed - */
892   case winmethod_Right:  /* adjust width to the yratio */
893     glk_window_set_arrangement(parent, window->method,
894                                (glui32) (window->width * yratio), 0);
895     break;
896   case winmethod_Above:  /* Above and below splits mean width is fixed - */
897   case winmethod_Below:  /* adjust height to the xratio */
898     glk_window_set_arrangement(parent, window->method,
899                                (glui32) (window->height * xratio), 0);
900     break;
901   }
902
903   /* Check to see what it became, and if it's still off, don't worry */
904   glk_window_get_size(window->win, &winx, &winy);
905   xratio = ((float) winx) / window->width;
906   yratio = ((float) winy) / window->height;
907
908   for(i = 0; i < 12; i++) {
909     if(window->images[i].image_num) {
910       wrap_glk_image_draw_scaled(window->win, window->images[i].image_num,
911                                  (glui32) (window->images[i].x * xratio),
912                                  (glui32) (window->images[i].y * yratio),
913                                  (glui32) (window->images[i].width * xratio),
914                                  (glui32) (window->images[i].height * yratio));
915     }
916   }
917 }
918
919 void z_print_number(zwinid window, int number)
920 {
921   int i;
922   char buffer[12];
923   int length = n_to_decimal(buffer, number);
924
925   for(i = length - 1; i >= 0; i--)
926     z_put_char(window, buffer[i]);
927 }
928
929 void z_put_char(zwinid window, unsigned c)
930 {
931   colorstyle color = window->current;
932   if(is_fixed)
933     color.style |= sFIXE;
934
935   if(c == 0)     /* Section 3.8.2.1 */
936     return;
937
938   window->dirty = TRUE;
939
940   if((c < 32 && c != 13) || (c >= 127 && c <= 159)) {  /*Undefined in latin-1*/
941     switch(window->wintype) {
942     case wintype_TextBuffer:
943       z_put_char(window, '[');
944       z_print_number(window, c);
945       z_put_char(window, ']');
946       return;
947     case wintype_TextGrid:
948       c = '?';
949     }
950   }
951
952   switch(c) {
953   case 0x152:
954     z_put_char(window, 'O');
955     c = 'E';
956     break;
957   case 0x153:
958     z_put_char(window, 'o');
959     c = 'e';
960     break;
961   }
962
963
964   if(c > 255)    /* Section 3.8.5.4.3 */
965     c = '?';
966
967   if(c == 13) {  /* Section 7.1.2.2.1 */
968     switch(window->wintype) {
969     case wintype_TextBuffer:
970       window->text_buffer[window->curr_offset] = 10;
971       window->curr_offset++;
972       z_flush_text(window);
973       break;
974     case wintype_TextGrid:
975       window->curr_offset += window->width;
976       window->curr_offset -= window->curr_offset % window->width;
977     }
978   } else {
979     window->text_buffer[window->curr_offset] = c;
980     window->color_buffer[window->curr_offset] = color;
981     window->curr_offset++;
982   }
983
984   if(window->curr_offset >= window->max_offset) {
985     switch(window->wintype) {
986     case wintype_TextBuffer:
987       z_flush_text(window);
988       break;
989     case wintype_TextGrid:
990       if(!window->defined)                  /* Section 8.6.2 */
991         n_show_port(E_OUTPUT, "writing past end of window", c);
992       
993       if(window->max_offset)
994         window->curr_offset = window->max_offset - 1;
995       else
996         window->curr_offset = 0;
997
998       window->defined = FALSE;
999     }
1000   }
1001 }
1002
1003 void z_setxy(zwinid window, zword x, zword y)
1004 {
1005   window->curr_offset = (y - 1) * window->width + (x - 1);
1006   window->defined = TRUE;
1007 }
1008
1009 void z_getxy(zwinid window, zword *x, zword *y)
1010 {
1011   if(window->width) {
1012     *x = (window->curr_offset % window->width) + 1;
1013     *y = (window->curr_offset / window->width) + 1;
1014   } else {
1015     *x = window->curr_offset + 1;
1016     *y = 1;
1017   }
1018 }
1019
1020 void z_getsize(zwinid window, unsigned *width, unsigned *height)
1021 {
1022   *width = window->width;
1023   *height = window->height;
1024 }
1025
1026 void z_find_size(glui32 *wid, glui32 *hei)
1027 {
1028   glui32 oldwid, oldhei;
1029   zwinid upper = &game_windows[1];
1030   winid_t o = glk_window_get_parent(upper->win);
1031   glk_window_get_size(upper->win, &oldwid, &oldhei);
1032   glk_window_set_arrangement(o, (upper->method & ~winmethod_Fixed) |
1033                              winmethod_Proportional, 100, upper->win);
1034   glk_window_get_size(upper->win, wid, hei);
1035   glk_window_set_arrangement(o, upper->method, oldhei, upper->win);
1036
1037   upper_width = *wid; upper_height = *hei;
1038   init_upper(&upper);
1039 }
1040
1041 void z_set_height(zwinid window, unsigned height)
1042 {
1043   unsigned x;
1044   if(height * window->width > window->buffer_size) {
1045     n_show_error(E_OUTPUT, "height too large", height);
1046     return;
1047   }
1048
1049   window->height = height;
1050   if(height > window->biggest_height)
1051     window->biggest_height = height;
1052
1053   x = window->max_offset;
1054   window->max_offset = height * window->width;
1055
1056   for(; x < window->max_offset; x++) {
1057     window->text_buffer[x] = ' ';
1058     window->color_buffer[x] = window->current;
1059   }
1060
1061   window->dirty = TRUE;
1062 }
1063
1064 void z_set_color(zwinid window, unsigned fore, unsigned back)
1065 {
1066   if(fore >= sizeof(fgcolortable) / sizeof(*fgcolortable)) {
1067     n_show_error(E_OUTPUT, "illegal foreground color", fore);
1068     return;
1069   }
1070   if(back >= sizeof(bgcolortable) / sizeof(*bgcolortable)) {
1071     n_show_error(E_OUTPUT, "illegal background color", back);
1072     return;
1073   }
1074
1075   fgcolortable[0] = fgcolortable[fore];
1076   bgcolortable[0] = bgcolortable[back];
1077   
1078   window->current.fore = fore;
1079   window->current.back = back;
1080 }
1081
1082 void z_set_style(zwinid window, int style)
1083 {
1084   switch(style) {
1085   case 0: window->current.style = 0; break;
1086   case 1: window->current.style |= sREVE; break;
1087   case 2: window->current.style |= sBOLD; break;
1088   case 4: window->current.style |= sITAL; break;
1089   case 8: window->current.style |= sFIXE; break;
1090   default: n_show_error(E_OUTPUT, "undefined style", style);
1091   }
1092 }
1093
1094 void set_fixed(BOOL p)
1095 {
1096   if(!p) {
1097     is_fixed = FALSE;
1098   } else {
1099     is_fixed = TRUE;
1100   }
1101 }
1102
1103 void z_set_transcript(zwinid window, strid_t stream)
1104 {
1105   window->transcript = stream;
1106   glk_window_set_echo_stream(window->win, stream);
1107 }
1108
1109 void z_clear_window(zwinid window)
1110 {
1111   glui32 i;
1112
1113   if(window == &game_windows[0] && showstuffcount) {
1114     z_pause_timed_input(&game_windows[0]);
1115     z_flush_text(&game_windows[0]);
1116     glk_stream_set_current(game_windows[0].str);
1117     w_glk_put_string("[pausing to show unread error message]\n");
1118     z_wait_for_key(&game_windows[0]);
1119   }
1120
1121   window->dirty = TRUE;
1122   window->curr_offset = 0;
1123
1124   if(window->win && window->text_buffer && window->color_buffer) {
1125     switch(window->wintype) {
1126     case wintype_TextGrid:
1127       for(i = 0; i < window->max_offset; i++) {
1128         window->text_buffer[i] = ' ';
1129         window->color_buffer[i] = window->current;
1130       }
1131       window->curr_offset = 0;
1132       window->dirty = TRUE;
1133       break;
1134     case wintype_TextBuffer:
1135       z_pause_timed_input(window);
1136       z_flush_text(window);
1137       if(coloreq(window->actual, window->current)) {
1138         glk_window_clear(window->win);
1139       } else {
1140         init_lower(NULL); /* **FIXME** This is wrong, but deal with it later */
1141       }
1142     }
1143   }
1144 }
1145
1146 void z_erase_line(zwinid window)
1147 {
1148   if(window->wintype == wintype_TextGrid) {
1149     int i;
1150     int x = window->curr_offset % window->width;
1151     int endoffset = window->curr_offset + (window->width - x);
1152     
1153     window->dirty = TRUE;
1154     for(i = window->curr_offset; i < endoffset; i++) {
1155       window->text_buffer[i] = ' ';
1156       window->color_buffer[i] = window->current;
1157     }
1158   }
1159 }
1160
1161
1162 /* Waits for input or timeout
1163  * Returns:
1164  *   0 - output during wait; may need to redraw or somesuch
1165  *  -1 - callback routine said to stop
1166  *  10 - read input
1167  * 254 - mouse input
1168  * char and line events will be canceled by the time it exits
1169  */
1170 static int waitforinput(zwinid window, glui32 *val,
1171                         BOOL (*timer_callback)(zword), zword timer_arg)
1172 {
1173   int i;
1174   event_t moo;
1175   zwinid t;
1176   
1177   showstuffcount = 0;
1178
1179   for(i = 0; i < num_z_windows; i++)
1180     if(game_windows[i].mouse_callback && game_windows[i].win)
1181       glk_request_mouse_event(game_windows[i].win);
1182   
1183   window->glk_input_pending = TRUE;
1184
1185   while(window->glk_input_pending) {
1186     glk_select(&moo);
1187
1188     check_sound(moo);
1189
1190     switch(moo.type) {
1191     case evtype_Timer:
1192       if(timer_callback && timer_callback(timer_arg)) {
1193         if(window->pending_input_type == evtype_CharInput) {
1194           glk_cancel_char_event(window->win);
1195           *val = 0;
1196         } else {
1197           glk_cancel_line_event(window->win, &moo);
1198           *val = moo.val1;
1199         }
1200         window->glk_input_pending = FALSE;
1201         return -1;
1202       }
1203       break;
1204
1205     case evtype_CharInput:
1206       *val = moo.val1;
1207       window->glk_input_pending = FALSE;
1208       return 10;
1209
1210     case evtype_LineInput:
1211       *val = moo.val1;
1212       window->glk_input_pending = FALSE;
1213       return 10;
1214
1215     case evtype_MouseInput:
1216       t = z_find_win(moo.win);
1217       if(t && t->mouse_callback &&
1218          t->mouse_callback(window->pending_input_type == evtype_CharInput,
1219                            moo.win, moo.val1, moo.val2)) {
1220         if(window->pending_input_type == evtype_CharInput) {
1221           glk_cancel_char_event(window->win);
1222           *val = 254;
1223         } else {
1224           glk_cancel_line_event(window->win, &moo);
1225           *val = moo.val1;
1226         }
1227         window->glk_input_pending = FALSE;
1228         return 254;
1229       }
1230       glk_request_mouse_event(moo.win);
1231       break;
1232     
1233     case evtype_Arrange:
1234       z_draw_all_windows();
1235     }
1236
1237     z_flush_all_windows();
1238   }
1239
1240   if(window->pending_input_type == evtype_LineInput)
1241     *val = window->pending_input_length;
1242   else
1243     *val = 0;
1244
1245   return 0;
1246 }
1247
1248
1249 void z_wait_for_key(zwinid window)
1250 {
1251   glui32 ch;
1252   do {
1253     z_draw_all_windows();
1254     glk_request_char_event(window->win);
1255     window->pending_input_type = evtype_CharInput;
1256   } while(waitforinput(window, &ch, NULL, 0) == 0);
1257   window->pending_input_type = 0;
1258 }
1259
1260
1261 zwinid check_valid_for_input(zwinid window)
1262 {  
1263   glui32 y, i;
1264   if(!window->win) {
1265     zwinid newwin = NULL;
1266     for(i = 0; i < num_z_windows; i++) {
1267       if(game_windows[i].win) {
1268         newwin = &game_windows[i];
1269         break;
1270       }
1271     }
1272     if(!newwin)
1273       return NULL;
1274
1275     if(window->wintype == wintype_TextGrid) {
1276       i = 0;
1277       for(y = 0; y < window->height; y++) {
1278         z_put_char(newwin, 13);
1279         z_put_styled_string(newwin, window->text_buffer + i,
1280                             window->color_buffer + i, window->width);
1281         i += window->width;
1282       }
1283       z_put_char(newwin, 13);
1284     }
1285
1286     window = newwin;
1287   }
1288   return window;
1289 }
1290
1291
1292 /* returns number of characters read */
1293 int z_read(zwinid window, char *dest, unsigned maxlen, unsigned initlen,
1294            zword timer, BOOL (*timer_callback)(zword), zword timer_arg,
1295            unsigned char *terminator)
1296 {
1297   /* FIXME: support terminating characters when (if) glk gets support for
1298      them */
1299   unsigned i;
1300   unsigned ux, uy;
1301   glui32 length;
1302   BOOL done;
1303
1304   if(automap_unexplore()) {
1305     read_abort = TRUE;
1306     return 0;
1307   }
1308   
1309   read_abort = FALSE;
1310
1311   if(initlen > maxlen) {
1312     n_show_error(E_OUTPUT, "initlen > maxlen", initlen);
1313     return 0;
1314   }
1315
1316   if(window == 0)
1317     window = &game_windows[0];
1318   
1319   if(window->pending_input_type != 0) {
1320     n_show_error(E_OUTPUT, "nested input attempted", 0);
1321     return 0;
1322   }
1323
1324 #ifdef DEBUGGING
1325
1326   if(do_automap) {
1327     const char *dir = automap_explore();
1328     if(dir) {
1329       length = n_strlen(dir);
1330       if(length > maxlen)
1331         length = maxlen;
1332       n_strncpy(dest, dir, length);
1333       return length;
1334     }
1335   }
1336 #endif
1337
1338   glk_request_timer_events(timer * 100);  /* if time is zero, does nothing */
1339     
1340   if(initlen != 0 && window->wintype == wintype_TextBuffer) {
1341     BOOL good = FALSE;
1342     if(initlen <= window->curr_offset) {
1343       good = TRUE;
1344       for(i = 0; i < initlen; i++)  /* check the end of the linebuffer */
1345         if(window->text_buffer[window->curr_offset - initlen + i] != dest[i]) {
1346           good = FALSE;
1347           break;
1348         }
1349     }
1350     if(!good) {
1351       /* bleah */
1352       /* argh */
1353       /* oof */
1354     } else {
1355       window->curr_offset -= initlen; /* Remove initial text from linebuffer */
1356     }
1357   }
1358   
1359   if(window->wintype == wintype_TextGrid) {
1360     ux = window->curr_offset % window->width;
1361     uy = window->curr_offset / window->width;
1362   }
1363
1364   z_flush_all_windows();
1365   window = check_valid_for_input(window);
1366
1367   done = FALSE;
1368   length = initlen;
1369   while(!done) {
1370     int t;
1371
1372     if(window->wintype == wintype_TextGrid)
1373       glk_window_move_cursor(window->win, ux, uy);
1374
1375     if(input_stream1) {
1376       glui32 len = maxlen;
1377       *terminator = transcript_getline(dest, &len);
1378       length = len;
1379     }
1380     if(input_stream1) { /* If didn't EOF, input_stream1 will be non-zero */
1381       glk_stream_set_current(window->str);
1382       set_glk_stream_current();
1383       glk_set_style(style_Input);
1384       glk_put_buffer(dest, length);
1385       glk_put_char(10);
1386       done = TRUE;
1387     } else {
1388       glk_request_line_event(window->win, dest, maxlen, length);
1389       window->pending_input_type = evtype_LineInput;
1390     
1391       t = waitforinput(window, &length, timer_callback, timer_arg);
1392       if(t != 0) {
1393         if(t == -1)
1394           *terminator = 0;
1395         else
1396           *terminator = t;
1397         done = TRUE;
1398       }
1399     }
1400
1401     if(done)
1402       stream4line(dest, length, *terminator);
1403
1404 #ifdef DEBUGGING
1405     if(done && length >= 2 && dest[0] == '/') {
1406       if(dest[1] == '/') {  /* "//" means no command, but start with "/" */
1407         for(i = 1; i < length; i++)
1408           dest[i-1] = dest[i];
1409         length--;
1410       } else {
1411         done = FALSE;
1412         dest[length] = 0;
1413         
1414         process_debug_command(dest+1);
1415
1416         if(read_abort)
1417           done = TRUE;
1418
1419         length = 0;
1420       }
1421     }
1422 #endif
1423   }
1424   glk_request_timer_events(0);  /* stop timer */
1425
1426   window->pending_input_type = 0;
1427
1428   for(i = 0; i < num_z_windows; i++)
1429     game_windows[i].biggest_height = game_windows[i].last_height = game_windows[i].height;
1430
1431   return length;
1432 }
1433
1434 zword z_read_char(zwinid window,
1435                   zword timer, BOOL (*timer_callback)(zword), zword timer_arg)
1436 {
1437   unsigned i;
1438   glui32 ch;
1439   zword validch = 0;
1440
1441   if(automap_unexplore()) {
1442     read_abort = TRUE;
1443     return 0;
1444   }
1445
1446   if(input_stream1) {
1447     unsigned num;
1448     validch = transcript_getchar(&num);
1449     if(!validch)
1450       validch = num;
1451   }
1452   if(input_stream1) {
1453     return validch;
1454   }
1455   
1456   read_abort = FALSE;
1457
1458   glk_request_timer_events(timer * 100);
1459
1460   z_flush_all_windows();
1461   window = check_valid_for_input(window);
1462
1463   do {
1464     do {
1465       z_draw_all_windows();
1466       glk_request_char_event(window->win);
1467       window->pending_input_type = evtype_CharInput;
1468     } while(waitforinput(window, &ch, timer_callback, timer_arg) == 0);
1469     
1470     if(' ' <= ch && ch <= '~')
1471       validch = ch;
1472     
1473     switch(ch) {
1474     case 8:
1475     case keycode_Delete: validch = 8; break;
1476     case 9:
1477     case keycode_Tab:    validch = 9; break;
1478     case 13:
1479     case keycode_Return: validch = 13; break;
1480 /*  case 21:
1481       if(restoreundo()) {
1482         read_abort = TRUE;
1483         return 0;
1484       }
1485       break; */
1486     case 27:
1487     case keycode_Escape: validch = 27; break;
1488     case 16:
1489     case keycode_Up:     validch = 129; break;
1490     case 14:
1491     case keycode_Down:   validch = 130; break;
1492     case 2:
1493     case keycode_Left:   validch = 131; break;
1494     case 6:
1495     case keycode_Right:  validch = 132; break;
1496     case keycode_Func1:  validch = 133; break;
1497     case keycode_Func2:  validch = 134; break;
1498     case keycode_Func3:  validch = 135; break;
1499     case keycode_Func4:  validch = 136; break;
1500     case keycode_Func5:  validch = 137; break;
1501     case keycode_Func6:  validch = 138; break;
1502     case keycode_Func7:  validch = 139; break;
1503     case keycode_Func8:  validch = 140; break;
1504     case keycode_Func9:  validch = 141; break;
1505     case keycode_Func10: validch = 142; break;
1506     case keycode_Func11: validch = 143; break;
1507     case keycode_Func12: validch = 144; break;
1508     }
1509   } while(!(validch || ch == 0));
1510
1511   glk_request_timer_events(0);     /* stop timer */
1512
1513   window->pending_input_type = 0;
1514
1515   for(i = 0; i < num_z_windows; i++)
1516     game_windows[i].biggest_height = game_windows[i].last_height = game_windows[i].height;
1517
1518   return validch;
1519 }
1520
1521
1522 /*
1523 void zwin_init(int number, glui32 wintype,
1524                glui32 x_coord, glui32 y_coord, glui32 x_size, glui32 y_size)
1525 {
1526   zwinid self = game_windows + number;
1527
1528   if(x_coord == self->x1) {
1529     if(y_coord == self->y1) {
1530       
1531
1532   if(game_windows[number].win) {
1533     z_pause_timed_input(game_windows[number].win);
1534     glk_window_close(game_windows[number].win, NULL);
1535   }
1536   set_style_hints();
1537   game_windows[number].win = glk_window_open(
1538 }
1539 */