Implemented the 'waiting' signal on the ChimaraGlk widget to let listeners know when...
[projects/chimara/chimara.git] / interpreters / frotz / glkscreen.c
1 /******************************************************************************
2  *                                                                            *
3  * Copyright (C) 2006-2009 by Tor Andersson.                                  *
4  *                                                                            *
5  * This file is part of Gargoyle.                                             *
6  *                                                                            *
7  * Gargoyle is free software; you can redistribute it and/or modify           *
8  * it under the terms of the GNU General Public License as published by       *
9  * the Free Software Foundation; either version 2 of the License, or          *
10  * (at your option) any later version.                                        *
11  *                                                                            *
12  * Gargoyle is distributed in the hope that it will be useful,                *
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of             *
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              *
15  * GNU General Public License for more details.                               *
16  *                                                                            *
17  * You should have received a copy of the GNU General Public License          *
18  * along with Gargoyle; if not, write to the Free Software                    *
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA *
20  *                                                                            *
21  *****************************************************************************/
22
23 /* screen.c - Generic screen manipulation
24  *
25  *  Portions copyright (c) 1995-1997 Stefan Jokisch.
26  */
27
28 #include "glkfrotz.h"
29
30 static unsigned char statusline[256];
31 static int oldstyle = 0;
32 static int curstyle = 0;
33 static int upperstyle = 0;
34 static int lowerstyle = 0;
35 static int cury = 1;
36 static int curx = 1;
37
38 int curr_fg = 0;
39 int curr_bg = 0;
40
41 /* To make the common code happy */
42
43 int os_char_width (zchar z)
44 {
45         return 1;
46 }
47
48 int os_string_width (const zchar *s)
49 {
50         int width = 0;
51         zchar c;
52         while ((c = *s++) != 0)
53                 if (c == ZC_NEW_STYLE || c == ZC_NEW_FONT)
54                         s++;
55                 else
56                         width += os_char_width(c);
57         return width;
58 }
59
60 void os_prepare_sample (int a)
61 {
62         glk_sound_load_hint(a, 1);
63 }
64
65 void os_finish_with_sample (int a)
66 {
67         glk_sound_load_hint(a, 0);
68 }
69
70 /*
71  * os_start_sample
72  *
73  * Play the given sample at the given volume (ranging from 1 to 8 and
74  * 255 meaning a default volume). The sound is played once or several
75  * times in the background (255 meaning forever). In Z-code 3 the
76  * repeats value is always 0 and the number of repeats is taken from
77  * the sound file itself. The end_of_sound function is called as soon
78  * as the sound finishes.
79  *
80  */
81
82 void os_start_sample (int number, int volume, int repeats, zword eos)
83 {
84         int vol;
85
86         if (!gos_channel)
87         {
88                 gos_channel = glk_schannel_create(0);
89                 if (!gos_channel)
90                         return;
91         }
92
93         switch (volume)
94         {
95         case   1: vol = 0x02000; break;
96         case   2: vol = 0x04000; break;
97         case   3: vol = 0x06000; break;
98         case   4: vol = 0x08000; break;
99         case   5: vol = 0x0a000; break;
100         case   6: vol = 0x0c000; break;
101         case   7: vol = 0x0e000; break;
102         case   8: vol = 0x10000; break;
103         default:  vol = 0x20000; break;
104         }
105
106         /* we dont do repeating or eos-callback for now... */
107         glk_schannel_play_ext(gos_channel, number, 1, 0);
108         glk_schannel_set_volume(gos_channel, vol);
109 }
110
111 void os_stop_sample (int a)
112 {
113         if (!gos_channel)
114                 return;
115         glk_schannel_stop(gos_channel);
116 }
117
118 void os_beep (int volume)
119 {
120 }
121
122 void gos_update_width(void)
123 {
124         glui32 width;
125         if (gos_upper)
126         {
127                 glk_window_get_size(gos_upper, &width, NULL);
128                 h_screen_cols = width;
129                 SET_BYTE(H_SCREEN_COLS, width);
130                 if (curx > width)
131                 {
132                         glk_window_move_cursor(gos_upper, 0, cury-1);
133                         curx = 1;
134                 }
135         }
136 }
137
138 void gos_update_height(void)
139 {
140         glui32 height_upper;
141         glui32 height_lower;
142         if (gos_curwin)
143         {
144                 glk_window_get_size(gos_upper, NULL, &height_upper);
145                 glk_window_get_size(gos_lower, NULL, &height_lower);
146                 h_screen_rows = height_upper + height_lower + 1;
147                 SET_BYTE(H_SCREEN_ROWS, h_screen_rows);
148         }
149 }
150
151 void reset_status_ht(void)
152 {
153         glui32 height;
154         if (gos_upper)
155         {
156                 glk_window_get_size(gos_upper, NULL, &height);
157                 if (mach_status_ht != height)
158                         glk_window_set_arrangement(
159                                 glk_window_get_parent(gos_upper),
160                                 winmethod_Above | winmethod_Fixed,
161                                 mach_status_ht, NULL);
162         }
163 }
164
165 void erase_window (int w)
166 {
167         if (w == 0)
168                 glk_window_clear(gos_lower);
169         else if (gos_upper)
170         {
171                 memset(statusline, ' ', sizeof statusline);
172                 glk_window_clear(gos_upper);
173                 reset_status_ht();
174                 curr_status_ht = 0;
175         }
176 }
177
178 void split_window (int lines)
179 {
180         if (!gos_upper)
181                 return;
182         /* The top line is always set for V1 to V3 games */
183         if (h_version < V4)
184                 lines++;
185
186         if (!lines || lines > curr_status_ht)
187         {
188                 glui32 height;
189
190                 glk_window_get_size(gos_upper, NULL, &height);
191                 if (lines != height)
192                         glk_window_set_arrangement(
193                                 glk_window_get_parent(gos_upper),
194                                 winmethod_Above | winmethod_Fixed,
195                                 lines, NULL);
196                 curr_status_ht = lines;
197         }
198         mach_status_ht = lines;
199         if (cury > lines)
200         {
201                 glk_window_move_cursor(gos_upper, 0, 0);
202                 curx = cury = 1;
203         }
204         gos_update_width();
205
206         if (h_version == V3)
207                 glk_window_clear(gos_upper);
208 }
209
210 void restart_screen (void)
211 {
212         erase_window(0);
213         erase_window(1);
214         split_window(0);
215 }
216
217 /*
218  * statusline overflowed the window size ... bad game!
219  * so ... split status text into regions, reformat and print anew.
220  */
221
222 void packspaces(unsigned char *src, unsigned char *dst)
223 {
224         int killing = 0;
225         while (*src)
226         {
227                 if (*src == ' ')
228                         killing++;
229                 else
230                         killing = 0;
231                 if (killing > 2)
232                         src++;
233                 else
234                         *dst++ = *src++;
235         }
236         *dst = 0;
237 }
238
239 void smartstatusline (void)
240 {
241         unsigned char packed[256];
242         unsigned char buf[256];
243         unsigned char *a, *b, *c, *d;
244         int roomlen, scorelen, scoreofs;
245         int len;
246
247         statusline[curx - 1] = 0; /* terminate! */
248
249         packspaces(statusline, packed);
250         //strcpy(packed, statusline);
251         len = strlen(packed);
252
253         a = packed;
254         while (a[0] == ' ')
255                 a ++;
256
257         b = a;
258         while (b[0] != 0 && !(b[0] == ' ' && b[1] == ' '))
259                 b ++;
260
261         c = b;
262         while (c[0] == ' ')
263                 c ++;
264
265         d = packed + len - 1;
266         while (d[0] == ' ' && d > c)
267                 d --;
268         if (d[0] != ' ' && d[0] != 0)
269                 d ++;
270         if (d < c)
271                 d = c;
272
273         //printf("smart '%s'\n", packed);
274         //printf("smart %d %d %d %d\n",a-packed,b-packed,c-packed,d-packed);
275
276         roomlen = b - a;
277         scorelen = d - c;
278         scoreofs = h_screen_cols - scorelen - 2;
279         if (scoreofs <= roomlen)
280                 scoreofs = roomlen + 2;
281
282         memset(buf, ' ', h_screen_cols);
283         memcpy(buf + 1 + scoreofs, c, scorelen);
284         memcpy(buf + 1, a, roomlen);
285         //if (roomlen >= scoreofs)
286         //      buf[roomlen + 1] = '|';
287
288         glk_window_move_cursor(gos_upper, 0, 0);
289         glk_set_style(style_User1);
290         glk_put_buffer(buf, h_screen_cols);
291         glk_window_move_cursor(gos_upper, cury - 1, curx - 1);
292 }
293
294 void screen_char (zchar c)
295 {
296         if (gos_linepending && (gos_curwin == gos_linewin))
297         {
298                 gos_cancel_pending_line();
299                 if (gos_curwin == gos_upper)
300                 {
301                         curx = 1;
302                         cury ++;
303                 }
304                 if (c == '\n')
305                         return;
306         }
307
308         if (gos_upper && gos_curwin == gos_upper) {
309                 if (cury > mach_status_ht) {
310                         mach_status_ht = cury;
311                         reset_status_ht();
312                 }
313         }
314
315         /* check fixed flag in header, game can change it at whim */
316         if (gos_curwin == gos_lower)
317         {
318                 static int forcefix = -1;
319                 int curfix = h_flags & FIXED_FONT_FLAG;
320                 if (forcefix != curfix)
321                 {
322                         forcefix = curfix;
323                         zargs[0] = 0xf000;      /* tickle tickle! */
324                         z_set_text_style();
325                 }
326         }
327
328         if (gos_upper && gos_curwin == gos_upper)
329         {
330                 if (c == '\n' || c == ZC_RETURN) {
331                         glk_put_char('\n');
332                         curx = 1;
333                         cury ++;
334                 }
335                 else {
336                         if (cury == 1)
337                         {
338                                 if (curx < sizeof statusline)
339                                         statusline[curx - 1] = c;
340                                 curx++;
341                                 if (curx <= h_screen_cols)
342                                         glk_put_char(c);
343                                 else
344                                         smartstatusline();
345                         }
346                         else
347                         {
348                                 glk_put_char(c);
349                                 curx++;
350                                 if (curx > h_screen_cols) {
351                                         curx = 1;
352                                         cury++;
353                                 }
354                         }
355                 }
356         }
357         else if (gos_curwin == gos_lower)
358         {
359                 if (c == ZC_RETURN)
360                         glk_put_char('\n');
361                 else glk_put_char(c);
362         }
363 }
364
365 void screen_new_line (void)
366 {
367         screen_char('\n');
368 }
369
370 void screen_word (const zchar *s)
371 {
372         zchar c;
373         while ((c = *s++) != 0)
374                 if (c == ZC_NEW_FONT)
375                         s++;
376                 else if (c == ZC_NEW_STYLE)
377                         s++;
378                 else
379                         screen_char (c); 
380 }
381
382 void screen_mssg_on (void)
383 {
384         if (gos_curwin == gos_lower)
385         {
386                 oldstyle = curstyle;
387                 glk_set_style(style_Preformatted);
388                 glk_put_string("\n    ");
389         }
390 }
391
392 void screen_mssg_off (void)
393 {
394         if (gos_curwin == gos_lower)
395         {
396                 glk_put_char('\n');
397                 zargs[0] = 0;
398                 z_set_text_style();
399                 zargs[0] = oldstyle;
400                 z_set_text_style();
401         }
402 }
403
404 /*
405  * z_buffer_mode, turn text buffering on/off.
406  *
407  *              zargs[0] = new text buffering flag (0 or 1)
408  *
409  */
410
411 void z_buffer_mode (void)
412 {
413 }
414
415 /*
416  * z_erase_line, erase the line starting at the cursor position.
417  *
418  *              zargs[0] = 1 + #units to erase (1 clears to the end of the line)
419  *
420  */
421
422 void z_erase_line (void)
423 {
424         int i;
425
426         if (gos_upper && gos_curwin == gos_upper)
427         {
428                 for (i = 0; i < h_screen_cols + 1 - curx; i++)
429                         glk_put_char(' ');
430                 glk_window_move_cursor(gos_curwin, curx - 1, cury - 1);
431         }
432 }
433
434 /*
435  * z_erase_window, erase a window or the screen to background colour.
436  *
437  *              zargs[0] = window (-3 current, -2 screen, -1 screen & unsplit)
438  *
439  */
440
441 void z_erase_window (void)
442 {
443         short w = zargs[0];
444         if (w == -2)
445         {
446                 if (gos_upper) {
447                         glk_set_window(gos_upper);
448 #ifdef GARGLK
449                         garglk_set_zcolors(curr_fg, curr_bg);
450 #endif /* GARGLK */
451                         glk_window_clear(gos_upper);
452                         glk_set_window(gos_curwin);
453                 }
454                 glk_window_clear(gos_lower);
455         }
456         if (w == -1)
457         {
458                 if (gos_upper) {
459                         glk_set_window(gos_upper);
460 #ifdef GARGLK
461                         garglk_set_zcolors(curr_fg, curr_bg);
462 #endif /* GARGLK */
463                         glk_window_clear(gos_upper);
464                 }
465                 glk_window_clear(gos_lower);
466                 split_window(0);
467                 glk_set_window(gos_lower);
468                 gos_curwin = gos_lower;
469         }
470         if (w == 0)
471                 glk_window_clear(gos_lower);
472         if (w == 1 && gos_upper)
473                 glk_window_clear(gos_upper);
474 }
475
476 /*
477  * z_get_cursor, write the cursor coordinates into a table.
478  *
479  *              zargs[0] = address to write information to
480  *
481  */
482
483 void z_get_cursor (void)
484 {
485         storew ((zword) (zargs[0] + 0), cury);
486         storew ((zword) (zargs[0] + 2), curx);
487 }
488
489 /*
490  * z_print_table, print ASCII text in a rectangular area.
491  *
492  *              zargs[0] = address of text to be printed
493  *              zargs[1] = width of rectangular area
494  *              zargs[2] = height of rectangular area (optional)
495  *              zargs[3] = number of char's to skip between lines (optional)
496  *
497  */
498
499 void z_print_table (void)
500 {
501         zword addr = zargs[0];
502         zword x;
503         int i, j;
504
505         /* Supply default arguments */
506
507         if (zargc < 3)
508                 zargs[2] = 1;
509         if (zargc < 4)
510                 zargs[3] = 0;
511
512         /* Write text in width x height rectangle */
513
514         x = curx;
515
516         for (i = 0; i < zargs[2]; i++) {
517
518                 if (i != 0) {
519                         cury += 1;
520                         curx = x;
521                 }
522
523                 for (j = 0; j < zargs[1]; j++) {
524
525                         zbyte c;
526
527                         LOW_BYTE (addr, c)
528                         addr++;
529
530                         print_char (c);
531                 }
532
533                 addr += zargs[3];
534         }
535 }
536
537 /*
538  * z_set_colour, set the foreground and background colours.
539  *
540  *              zargs[0] = foreground colour
541  *              zargs[1] = background colour
542  *              zargs[2] = window (-3 is the current one, optional)
543  *
544  */
545
546 void z_set_colour (void)
547 {
548         int zfore = zargs[0];
549         int zback = zargs[1];
550
551
552         if (!(zfore == 0 && zback == 0)) {
553 #ifdef GARGLK
554                 garglk_set_zcolors(zfore, zback);
555 #endif /* GARGLK */
556         }
557
558         curr_fg = zfore;
559         curr_bg = zback;
560 }
561
562 /*
563  * z_set_font, set the font for text output and store the previous font.
564  *
565  *               zargs[0] = number of font or 0 to keep current font
566  *
567  */
568
569 void z_set_font (void)
570 {
571 }
572
573 /*
574  * z_set_cursor, set the cursor position or turn the cursor on/off.
575  *
576  *              zargs[0] = y-coordinate or -2/-1 for cursor on/off
577  *              zargs[1] = x-coordinate
578  *              zargs[2] = window (-3 is the current one, optional)
579  *
580  */
581
582 void z_set_cursor (void)
583 {
584         cury = zargs[0];
585         curx = zargs[1];
586         if (gos_upper)
587                 glk_window_move_cursor(gos_upper, curx - 1, cury - 1);
588 }
589
590 /*
591  * z_set_text_style, set the style for text output.
592  *
593  *               zargs[0] = style flags to set or 0 to reset text style
594  *
595  */
596
597 void z_set_text_style (void)
598 {
599         int style;
600
601         if (zargs[0] == 0)
602                 curstyle = 0;
603         else if (zargs[0] != 0xf000) /* not tickle time */
604                 curstyle |= zargs[0];
605
606         if (h_flags & FIXED_FONT_FLAG)
607                 style = curstyle | FIXED_WIDTH_STYLE;
608         else
609                 style = curstyle;
610
611         if (gos_linepending && gos_curwin == gos_linewin)
612                 return;
613
614         if (style & REVERSE_STYLE)
615         {
616                 if (gos_curwin == gos_upper && gos_upper) {
617                         glk_set_style(style_User1);
618                 }
619 #ifdef GARGLK
620                 garglk_set_reversevideo(TRUE);
621 #endif /* GARGLK */
622         }
623         else if (style & FIXED_WIDTH_STYLE)
624                 glk_set_style(style_Preformatted);
625         else if (style & BOLDFACE_STYLE && style & EMPHASIS_STYLE)
626                 glk_set_style(style_Alert);
627         else if (style & BOLDFACE_STYLE)
628                 glk_set_style(style_Subheader);
629         else if (style & EMPHASIS_STYLE)
630                 glk_set_style(style_Emphasized);
631         else
632                 glk_set_style(style_Normal);
633
634         if (curstyle == 0) {
635 #ifdef GARGLK
636                 garglk_set_reversevideo(FALSE);
637 #endif /* GARGLK */
638         }
639 }
640
641 /*
642  * z_set_window, select the current window.
643  *
644  *              zargs[0] = window to be selected (-3 is the current one)
645  *
646  */
647
648 void z_set_window (void)
649 {
650         int win = zargs[0];
651
652         if (gos_curwin == gos_lower)
653                 lowerstyle = curstyle;
654         else
655                 upperstyle = curstyle;
656
657         if (win == 0)
658         {
659                 glk_set_window(gos_lower);
660                 gos_curwin = gos_lower;
661                 curstyle = lowerstyle;
662         }
663         else
664         {
665                 if (gos_upper)
666                         glk_set_window(gos_upper);
667                 gos_curwin = gos_upper;
668                 curstyle = upperstyle;
669         }
670
671         if (win == 0)
672             enable_scripting = TRUE;
673         else
674             enable_scripting = FALSE;
675 }
676
677 /*
678  * z_show_status, display the status line for V1 to V3 games.
679  *
680  *              no zargs used
681  *
682  */
683
684 static void pad_status_line (int column)
685 {
686         int spaces;
687         spaces = (h_screen_cols + 1 - curx) - column;
688         while (spaces-- > 0)
689                 print_char(' ');
690 }
691
692 void z_show_status (void)
693 {
694         zword global0;
695         zword global1;
696         zword global2;
697         zword addr;
698
699         bool brief = FALSE;
700
701         if (!gos_upper)
702                 return;
703
704         /* One V5 game (Wishbringer Solid Gold) contains this opcode by
705            accident, so just return if the version number does not fit */
706
707         if (h_version >= V4)
708                 return;
709
710         /* Read all relevant global variables from the memory of the
711            Z-machine into local variables */
712
713         addr = h_globals;
714         LOW_WORD (addr, global0)
715         addr += 2;
716         LOW_WORD (addr, global1)
717         addr += 2;
718         LOW_WORD (addr, global2)
719
720         /* Move to top of the status window, and print in reverse style. */
721
722         glk_set_window(gos_upper);
723         gos_curwin = gos_upper;
724
725         curx = cury = 1;
726         glk_window_move_cursor(gos_upper, 0, 0);
727         glk_set_style(style_User1);
728
729         /* If the screen width is below 55 characters then we have to use
730            the brief status line format */
731
732         if (h_screen_cols < 55)
733                 brief = TRUE;
734
735         /* Print the object description for the global variable 0 */
736
737         print_char (' ');
738         print_object (global0);
739
740         /* A header flag tells us whether we have to display the current
741            time or the score/moves information */
742
743         if (h_config & CONFIG_TIME) {           /* print hours and minutes */
744
745                 zword hours = (global1 + 11) % 12 + 1;
746
747                 pad_status_line (brief ? 15 : 20);
748
749                 print_string ("Time: ");
750
751                 if (hours < 10)
752                         print_char (' ');
753                 print_num (hours);
754
755                 print_char (':');
756
757                 if (global2 < 10)
758                         print_char ('0');
759                 print_num (global2);
760
761                 print_char (' ');
762
763                 print_char ((global1 >= 12) ? 'p' : 'a');
764                 print_char ('m');
765
766         } else {                                                                /* print score and moves */
767
768                 pad_status_line (brief ? 15 : 30);
769
770                 print_string (brief ? "S: " : "Score: ");
771                 print_num (global1);
772
773                 pad_status_line (brief ? 8 : 14);
774
775                 print_string (brief ? "M: " : "Moves: ");
776                 print_num (global2);
777
778         }
779
780         /* Pad the end of the status line with spaces */
781
782         pad_status_line (0);
783
784         /* Return to the lower window */
785
786         glk_set_window(gos_lower);
787         gos_curwin = gos_lower;
788 }
789
790 /*
791  * z_split_window, split the screen into an upper (1) and lower (0) window.
792  *
793  *              zargs[0] = height of upper window in screen units (V6) or #lines
794  *
795  */
796
797 void z_split_window (void)
798 {
799         split_window(zargs[0]);
800 }
801