Keep track of input and output in multiple windows in the player
[projects/chimara/chimara.git] / libchimara / garglk.c
1 #include <glib.h>
2 #include <glib/gi18n.h>
3 #include <glib/gprintf.h>
4 #include <libchimara/glk.h>
5 #include "chimara-glk-private.h"
6 #include "stream.h"
7 #include "fileref.h"
8 #include "style.h"
9 #include "garglk.h"
10
11 extern GPrivate glk_data_key;
12
13 /**
14  * garglk_fileref_get_name:
15  * @fref: A file reference.
16  *
17  * Gets the actual disk filename that @fref refers to, in the platform's
18  * native filename encoding. The string is owned by @fref and must not be
19  * changed or freed.
20  *
21  * Returns: a string in filename encoding.
22  */
23 char * 
24 garglk_fileref_get_name(frefid_t fref)
25 {
26         VALID_FILEREF(fref, return NULL);
27         return fref->filename;
28 }
29
30 /**
31  * garglk_set_program_name:
32  * @name: Name of the Glk program that is running.
33  *
34  * This function is used to let the library know the name of the currently
35  * running Glk program, in case it wants to display this information somewhere
36  * &mdash; for example, in the title bar of a window. A typical use of this
37  * function would be:
38  * |[ garglk_set_program_name("SuperGlkFrotz 0.1"); ]|
39  */
40 void 
41 garglk_set_program_name(const char *name)
42 {
43         ChimaraGlkPrivate *glk_data = g_private_get(&glk_data_key);
44         glk_data->program_name = g_strdup(name);
45         g_object_notify(G_OBJECT(glk_data->self), "program-name");
46 }
47
48 /**
49  * garglk_set_program_info:
50  * @info: Information about the Glk program that is running.
51  *
52  * This function is used to provide the library with additional information
53  * about the currently running Glk program, in case it wants to display this
54  * information somewhere &mdash; for example, in an About box. A typical use of
55  * this function would be:
56  * |[ 
57  * garglk_set_program_info("SuperGlkFrotz, version 0.1\n"
58  *     "Original Frotz by Stefan Jokisch\n"
59  *     "Unix port by Jim Dunleavy and David Griffith\n"
60  *     "Glk port by Tor Andersson\n"
61  *     "Animation, networking, and evil AI by Sven Metcalfe");
62  * ]|
63  */
64 void 
65 garglk_set_program_info(const char *info)
66 {
67         ChimaraGlkPrivate *glk_data = g_private_get(&glk_data_key);
68         glk_data->program_info = g_strdup(info);
69         g_object_notify(G_OBJECT(glk_data->self), "program-info");
70 }
71
72 /**
73  * garglk_set_story_name:
74  * @name: Name of the story that the Glk program is currently interpreting.
75  *
76  * If the Glk program running is an interactive fiction interpreter, then this
77  * function can be used to let the library know the name of the story currently
78  * loaded in the interpreter, in case it wants to display this information
79  * anywhere &mdash; for example, in the title bar of a window. A typical use of
80  * this function would be:
81  * |[ garglk_set_story_name("Lighan Ses Lion, el Zarf"); ]|
82  */
83 void 
84 garglk_set_story_name(const char *name)
85 {
86         ChimaraGlkPrivate *glk_data = g_private_get(&glk_data_key);
87         glk_data->story_name = g_strdup(name);
88         g_object_notify(G_OBJECT(glk_data->self), "story-name");
89 }
90
91 /**
92  * garglk_set_story_title:
93  * @title: Title bar text for the currently running story.
94  *
95  * This function is a hint to the library to put @title in the title bar of the
96  * window that the Glk program is running in. It overrides
97  * garglk_set_program_name() and garglk_set_story_name(), if they were displayed
98  * in the title bar, although they may still be displayed somewhere else.
99  *
100  * <warning><para>This function is not currently implemented.</para></warning>
101  */
102 void
103 garglk_set_story_title(const char *title)
104 {
105         WARNING(_("Not implemented"));
106 }
107
108 /**
109  * garglk_unput_string:
110  * @str: a null-terminated string.
111  *
112  * Removes @str from the end of the current stream, if indeed it is there. The
113  * stream's write count is decreased accordingly, and the stream's echo stream
114  * is also modified, if it has one.
115  *
116  * <warning><para>This function is not currently implemented.</para></warning>
117  */
118 void 
119 garglk_unput_string(char *str)
120 {
121         ChimaraGlkPrivate *glk_data = g_private_get(&glk_data_key);
122         g_return_if_fail(glk_data->current_stream != NULL);
123
124         WARNING(_("Not implemented"));
125 }
126
127 /**
128  * garglk_unput_string_uni:
129  * @str: a zero-terminated array of Unicode code points.
130  *
131  * Like garglk_unput_string(), but for Unicode streams.
132  *
133  * <warning><para>This function is not currently implemented.</para></warning>
134  */
135 void 
136 garglk_unput_string_uni(glui32 *str)
137 {
138         ChimaraGlkPrivate *glk_data = g_private_get(&glk_data_key);
139         g_return_if_fail(glk_data->current_stream != NULL);
140         
141         WARNING(_("Not implemented"));
142 }
143
144 /**
145  * garglk_set_zcolors_stream:
146  * @str: a stream.
147  * @fg: a 24-bit foreground color.
148  * @bg: a 24-bit background color.
149  *
150  * This function changes the foreground color of @str to @fg and the background
151  * color to @bg. @fg and @bg are encoded the same way as described in
152  * %stylehint_TextColor. See garglk_set_zcolors() for more information.
153  */
154 void
155 garglk_set_zcolors_stream(strid_t str, glui32 fg, glui32 bg)
156 {
157 #ifdef DEBUG_STYLES
158         g_printf("garglk_set_zcolors_stream(str->rock=%d, fg=%08X, bg=%08X)\n", str->rock, fg, bg);
159 #endif
160
161         VALID_STREAM(str, return);
162         g_return_if_fail(str->window != NULL);
163
164         winid_t window = str->window;
165
166         gdk_threads_enter();
167
168         GtkTextBuffer *buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(window->widget) );
169         GtkTextTagTable *tags = gtk_text_buffer_get_tag_table(buffer);
170         GdkColor fore, back;
171         GdkColor *fore_pointer = NULL;
172         GdkColor *back_pointer = NULL;
173         gchar *fore_name;
174         gchar *back_name;
175
176         switch(fg) {
177         case zcolor_Transparent:
178         case zcolor_Cursor:
179                 WARNING(_("zcolor_Transparent, zcolor_Cursor not implemented"));
180                 // Fallthrough to default
181         case zcolor_Default:
182                 fore_name = g_strdup("default");
183                 break;
184         case zcolor_Current:
185         {
186                 if(window->zcolor) {
187                         // Get the current foreground color
188                         GdkColor *current_color;
189                         g_object_get(window->zcolor, "foreground-gdk", &current_color, NULL);
190                         fore_name = gdkcolor_to_hex(current_color);
191
192                         // Copy the color and use it
193                         fore.red = current_color->red;
194                         fore.green = current_color->green;
195                         fore.blue = current_color->blue;
196                         fore_pointer = &fore;
197                 } else {
198                         fore_name = g_strdup("default");
199                 }
200                 break;
201         }
202         default:
203                 glkcolor_to_gdkcolor(fg, &fore);
204                 fore_pointer = &fore;
205                 fore_name = glkcolor_to_hex(fg);
206         }
207
208         switch(bg) {
209         case zcolor_Transparent:
210         case zcolor_Cursor:
211                 WARNING(_("zcolor_Transparent, zcolor_Cursor not implemented"));
212                 // Fallthrough to default
213         case zcolor_Default:
214                 back_name = g_strdup("default");
215                 break;
216         case zcolor_Current:
217         {
218                 if(window->zcolor) {
219                         // Get the current background color
220                         GdkColor *current_color;
221                         g_object_get(window->zcolor, "background-gdk", &current_color, NULL);
222                         back_name = gdkcolor_to_hex(current_color);
223
224                         // Copy the color and use it
225                         back.red = current_color->red;
226                         back.green = current_color->green;
227                         back.blue = current_color->blue;
228                         back_pointer = &back;
229                 } else {
230                         back_name = g_strdup("default");
231                 }
232                 break;
233         }
234         default:
235                 glkcolor_to_gdkcolor(bg, &back);
236                 back_pointer = &back;
237                 back_name = glkcolor_to_hex(bg);
238         }
239
240         if(fore_pointer == NULL && back_pointer == NULL) {
241                 // NULL value means to ignore the zcolor property altogether
242                 window->zcolor = NULL;
243         } else {
244                 char *name = g_strdup_printf("zcolor:#%s/#%s", fore_name, back_name);
245                 g_free(fore_name);
246                 g_free(back_name);
247
248                 // See if we have used this color combination before
249                 GtkTextTag *tag = gtk_text_tag_table_lookup(tags, name);
250
251                 if(tag == NULL) {
252                         // Create a new texttag with the specified colors
253                         tag = gtk_text_buffer_create_tag(
254                                 buffer,
255                                 name,
256                                 "foreground-gdk", fore_pointer,
257                                 "foreground-set", fore_pointer != NULL,
258                                 "background-gdk", back_pointer,
259                                 "background-set", back_pointer != NULL,
260                                 NULL
261                         );
262                 }
263
264                 // From now on, text will be drawn in the specified colors
265                 window->zcolor = tag;
266
267                 // Update the reversed version if necessary
268                 if(str->window->zcolor_reversed) {
269                         gint reversed = GPOINTER_TO_INT( g_object_get_data( G_OBJECT(str->window->zcolor_reversed), "reverse-color" ) );
270
271                         gdk_threads_leave();
272                         garglk_set_reversevideo_stream(str, reversed != 0);
273                         gdk_threads_enter();
274                 }
275         
276         }
277
278         gdk_threads_leave();
279 }
280
281 /**
282  * garglk_set_zcolors:
283  * @fg: a 24-bit foreground color.
284  * @bg: a 24-bit background color.
285  *
286  * Glk works with styles, not specific colors. This is not quite compatible with
287  * the Z-machine, so this Glk extension implements Z-machine style colors.
288  *
289  * This function changes the foreground color of the current stream to @fg and 
290  * the background color to @bg. @fg and @bg are encoded the same way as
291  * described in %stylehint_TextColor.
292  */
293 void 
294 garglk_set_zcolors(glui32 fg, glui32 bg)
295 {
296         ChimaraGlkPrivate *glk_data = g_private_get(&glk_data_key);
297         g_return_if_fail(glk_data->current_stream != NULL);
298
299         garglk_set_zcolors_stream(glk_data->current_stream, fg, bg);
300 }
301
302 /**
303  * garglk_set_reversevideo_stream:
304  * @str: a stream.
305  * @reverse: nonzero for reverse colors, zero for normal colors.
306  *
307  * If @reverse is not zero, uses the foreground color of @str as its background
308  * and vice versa. If @reverse is zero, changes the colors of @str back to
309  * normal.
310  */
311 void
312 garglk_set_reversevideo_stream(strid_t str, glui32 reverse)
313 {
314 #ifdef DEBUG_STYLES
315         g_printf("garglk_set_reversevideo_stream(str->rock=%d, reverse=%d)\n", str->rock, reverse);
316 #endif
317
318         VALID_STREAM(str, return);
319         g_return_if_fail(str->window != NULL);
320         g_return_if_fail(str->window->type != wintype_TextBuffer || str->window->type != wintype_TextGrid);
321
322         // Determine the current colors
323         
324         // If all fails, use black/white
325         // FIXME: Use system theme here
326         GdkColor foreground, background;
327         gdk_color_parse("black", &foreground);
328         gdk_color_parse("white", &background);
329         GdkColor *current_foreground = &foreground;
330         GdkColor *current_background = &background;
331
332         gdk_threads_enter();
333
334         style_stream_colors(str, &current_foreground, &current_background);
335
336         if(reverse) {
337                 GdkColor *temp = current_foreground;
338                 current_foreground = current_background;
339                 current_background = temp;
340         }
341
342         // Name the color
343         gchar *name = g_strdup_printf(
344                 "zcolor:#%04X%04X%04X/#%04X%04X%04X",
345                 current_foreground->red,
346                 current_foreground->green,
347                 current_foreground->blue,
348                 current_background->red,
349                 current_background->green,
350                 current_background->blue
351         );
352
353         // Create a tag for the new colors if it doesn't exist yet
354         GtkTextBuffer *buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(str->window->widget) ); 
355         GtkTextTagTable *tags = gtk_text_buffer_get_tag_table(buffer);
356         GtkTextTag *tag = gtk_text_tag_table_lookup(tags, name);
357         if(tag == NULL) {
358                 tag = gtk_text_buffer_create_tag(
359                         buffer,
360                         name,
361                         "foreground-gdk", current_foreground,
362                         "foreground-set", TRUE,
363                         "background-gdk", current_background,
364                         "background-set", TRUE,
365                         NULL
366                 );
367                 g_object_set_data( G_OBJECT(tag), "reverse-color", GINT_TO_POINTER(reverse) );
368         }
369
370         // From now on, text will be drawn in the specified colors
371         str->window->zcolor_reversed = tag;
372
373         // Update the background of the gtktextview to correspond with the current background color
374         if(current_background != NULL) {
375                 gtk_widget_modify_base(str->window->widget, GTK_STATE_NORMAL, current_background);
376         }
377
378         gdk_threads_leave();
379 }
380
381 /**
382  * garglk_set_reversevideo:
383  * @reverse: nonzero for reverse colors, zero for normal colors.
384  *
385  * If @reverse is not zero, uses the foreground color of the current stream as
386  * its background and vice versa. If @reverse is zero, changes the colors of the
387  * current stream back to normal.
388  */
389 void 
390 garglk_set_reversevideo(glui32 reverse)
391 {
392         ChimaraGlkPrivate *glk_data = g_private_get(&glk_data_key);
393         g_return_if_fail(glk_data->current_stream != NULL);
394         g_return_if_fail(glk_data->current_stream->window != NULL);
395
396         garglk_set_reversevideo_stream(glk_data->current_stream, reverse);
397 }