X-Git-Url: https://git.stderr.nl/gitweb?a=blobdiff_plain;f=libchimara%2Fchimara-glk.c;h=19925569823b16569e2246a0f457a74f974348cb;hb=f7db20369cdd1b699742a2037ca3ab99afe47ab2;hp=59f99ac8f4c9069b450d3f42c193667cdeb93f9d;hpb=19063a2e128c97aed872972abbf7b90db964d3c9;p=projects%2Fchimara%2Fchimara.git diff --git a/libchimara/chimara-glk.c b/libchimara/chimara-glk.c index 59f99ac..1992556 100644 --- a/libchimara/chimara-glk.c +++ b/libchimara/chimara-glk.c @@ -11,6 +11,7 @@ #include #include #include +#include #include "chimara-glk.h" #include "chimara-glk-private.h" #include "chimara-marshallers.h" @@ -22,6 +23,7 @@ #include "glkunix.h" #include "init.h" #include "magic.h" +#include "style.h" #define CHIMARA_GLK_MIN_WIDTH 0 #define CHIMARA_GLK_MIN_HEIGHT 0 @@ -30,7 +32,6 @@ * SECTION:chimara-glk * @short_description: Widget which executes a Glk program * @stability: Unstable - * @include: libchimara/chimara-glk.h * * The #ChimaraGlk widget opens and runs a Glk program. The program must be * compiled as a plugin module, with a function glk_main() @@ -70,13 +71,6 @@ * #include * #include * - * static gboolean - * quit(void) - * { - * gtk_main_quit(); - * return TRUE; - * } - * * int * main(int argc, char *argv[]) * { @@ -93,10 +87,15 @@ * /* Construct the window and its contents. We quit the GTK main loop * * when the window's close button is clicked. */ * window = gtk_window_new(GTK_WINDOW_TOPLEVEL); - * g_signal_connect(window, "delete-event", G_CALLBACK(quit), NULL); + * g_signal_connect(window, "delete-event", G_CALLBACK(gtk_main_quit), NULL); * glk = chimara_glk_new(); * gtk_container_add(GTK_CONTAINER(window), glk); * gtk_widget_show_all(window); + * + * /* Add a reference to the ChimaraGlk widget, since we want it to + * * persist after the window's delete-event -- otherwise it will be destroyed + * * with the window. */ + * g_object_ref(glk); * * /* Start the Glk program in a separate thread */ * if(!chimara_glk_run(CHIMARA_GLK(glk), "./plugin.so", 2, plugin_argv, &error)) @@ -111,6 +110,7 @@ * * it is still running, and wait for it to exit. */ * chimara_glk_stop(CHIMARA_GLK(glk)); * chimara_glk_wait(CHIMARA_GLK(glk)); + * g_object_unref(glk); * * return 0; * } @@ -137,6 +137,7 @@ enum { CHAR_INPUT, LINE_INPUT, TEXT_BUFFER_OUTPUT, + ILIAD_SCREEN_UPDATE, LAST_SIGNAL }; @@ -155,8 +156,8 @@ chimara_glk_init(ChimaraGlk *self) priv->self = self; priv->interactive = TRUE; priv->protect = FALSE; - priv->default_styles = g_new0(StyleSet,1); - priv->current_styles = g_new0(StyleSet,1); + priv->styles = g_new0(StyleSet,1); + priv->glk_styles = g_new0(StyleSet,1); priv->pager_attr_list = pango_attr_list_new(); priv->final_message = g_strdup("[ The game has finished ]"); priv->running = FALSE; @@ -176,10 +177,13 @@ chimara_glk_init(ChimaraGlk *self) priv->ignore_next_arrange_event = FALSE; priv->char_input_queue = g_async_queue_new(); priv->line_input_queue = g_async_queue_new(); - /* Should be g_async_queue_new_full(g_free); but only in GTK >= 2.16 */ + /* FIXME Should be g_async_queue_new_full(g_free); but only in GTK >= 2.16 */ + priv->resource_map = NULL; priv->resource_lock = g_mutex_new(); priv->resource_loaded = g_cond_new(); priv->resource_info_available = g_cond_new(); + priv->resource_load_callback = NULL; + priv->resource_load_callback_data = NULL; priv->image_cache = NULL; priv->program_name = NULL; priv->program_info = NULL; @@ -256,10 +260,10 @@ chimara_glk_finalize(GObject *object) /* Free widget properties */ g_free(priv->final_message); /* Free styles */ - g_hash_table_destroy(priv->default_styles->text_buffer); - g_hash_table_destroy(priv->default_styles->text_grid); - g_hash_table_destroy(priv->current_styles->text_buffer); - g_hash_table_destroy(priv->current_styles->text_grid); + g_hash_table_destroy(priv->styles->text_buffer); + g_hash_table_destroy(priv->styles->text_grid); + g_hash_table_destroy(priv->glk_styles->text_buffer); + g_hash_table_destroy(priv->glk_styles->text_grid); pango_attr_list_unref(priv->pager_attr_list); /* Free the event queue */ @@ -298,12 +302,17 @@ chimara_glk_finalize(GObject *object) /* Unref input queues (this should destroy them since any Glk thread has stopped by now */ g_async_queue_unref(priv->char_input_queue); g_async_queue_unref(priv->line_input_queue); + /* Destroy callback data if ownership retained */ + if(priv->resource_load_callback_destroy_data) + priv->resource_load_callback_destroy_data(priv->resource_load_callback_data); /* Free other stuff */ g_free(priv->current_dir); g_free(priv->program_name); g_free(priv->program_info); g_free(priv->story_name); + g_free(priv->styles); + g_free(priv->glk_styles); /* Chain up to parent */ G_OBJECT_CLASS(chimara_glk_parent_class)->finalize(object); @@ -322,7 +331,8 @@ request_recurse(winid_t win, GtkRequisition *requisition, guint spacing) glui32 division = win->split_method & winmethod_DivisionMask; glui32 direction = win->split_method & winmethod_DirMask; - + unsigned border = ((win->split_method & winmethod_BorderMask) == winmethod_NoBorder)? 0 : spacing; + /* If the split is fixed, get the size of the fixed child */ if(division == winmethod_Fixed) { @@ -356,13 +366,13 @@ request_recurse(winid_t win, GtkRequisition *requisition, guint spacing) { case winmethod_Left: case winmethod_Right: - requisition->width = child1.width + child2.width + spacing; + requisition->width = child1.width + child2.width + border; requisition->height = MAX(child1.height, child2.height); break; case winmethod_Above: case winmethod_Below: requisition->width = MAX(child1.width, child2.width); - requisition->height = child1.height + child2.height + spacing; + requisition->height = child1.height + child2.height + border; break; } } @@ -406,12 +416,13 @@ allocate_recurse(winid_t win, GtkAllocation *allocation, guint spacing) { glui32 division = win->split_method & winmethod_DivisionMask; glui32 direction = win->split_method & winmethod_DirMask; + unsigned border = ((win->split_method & winmethod_BorderMask) == winmethod_NoBorder)? 0 : spacing; /* If the space gets too small to honor the spacing property, then just ignore spacing in this window and below. */ - if( (spacing > allocation->width && (direction == winmethod_Left || direction == winmethod_Right)) - || (spacing > allocation->height && (direction == winmethod_Above || direction == winmethod_Below)) ) - spacing = 0; + if( (border > allocation->width && (direction == winmethod_Left || direction == winmethod_Right)) + || (border > allocation->height && (direction == winmethod_Above || direction == winmethod_Below)) ) + border = 0; GtkAllocation child1, child2; child1.x = allocation->x; @@ -425,22 +436,22 @@ allocate_recurse(winid_t win, GtkAllocation *allocation, guint spacing) { case winmethod_Left: child1.width = win->key_window? - CLAMP(win->constraint_size * win->key_window->unit_width, 0, allocation->width - spacing) + CLAMP(win->constraint_size * win->key_window->unit_width, 0, allocation->width - border) : 0; break; case winmethod_Right: child2.width = win->key_window? - CLAMP(win->constraint_size * win->key_window->unit_width, 0, allocation->width - spacing) + CLAMP(win->constraint_size * win->key_window->unit_width, 0, allocation->width - border) : 0; break; case winmethod_Above: child1.height = win->key_window? - CLAMP(win->constraint_size * win->key_window->unit_height, 0, allocation->height - spacing) + CLAMP(win->constraint_size * win->key_window->unit_height, 0, allocation->height - border) : 0; break; case winmethod_Below: child2.height = win->key_window? - CLAMP(win->constraint_size * win->key_window->unit_height, 0, allocation->height - spacing) + CLAMP(win->constraint_size * win->key_window->unit_height, 0, allocation->height - border) : 0; break; } @@ -451,16 +462,16 @@ allocate_recurse(winid_t win, GtkAllocation *allocation, guint spacing) switch(direction) { case winmethod_Left: - child1.width = MAX(0, (gint)ceil(fraction * (allocation->width - spacing)) ); + child1.width = MAX(0, (gint)ceil(fraction * (allocation->width - border)) ); break; case winmethod_Right: - child2.width = MAX(0, (gint)ceil(fraction * (allocation->width - spacing)) ); + child2.width = MAX(0, (gint)ceil(fraction * (allocation->width - border)) ); break; case winmethod_Above: - child1.height = MAX(0, (gint)ceil(fraction * (allocation->height - spacing)) ); + child1.height = MAX(0, (gint)ceil(fraction * (allocation->height - border)) ); break; case winmethod_Below: - child2.height = MAX(0, (gint)ceil(fraction * (allocation->height - spacing)) ); + child2.height = MAX(0, (gint)ceil(fraction * (allocation->height - border)) ); break; } } @@ -469,27 +480,27 @@ allocate_recurse(winid_t win, GtkAllocation *allocation, guint spacing) switch(direction) { case winmethod_Left: - child2.width = MAX(0, allocation->width - spacing - child1.width); - child2.x = child1.x + child1.width + spacing; + child2.width = MAX(0, allocation->width - border - child1.width); + child2.x = child1.x + child1.width + border; child2.y = child1.y; child1.height = child2.height = allocation->height; break; case winmethod_Right: - child1.width = MAX(0, allocation->width - spacing - child2.width); - child2.x = child1.x + child1.width + spacing; + child1.width = MAX(0, allocation->width - border - child2.width); + child2.x = child1.x + child1.width + border; child2.y = child1.y; child1.height = child2.height = allocation->height; break; case winmethod_Above: - child2.height = MAX(0, allocation->height - spacing - child1.height); + child2.height = MAX(0, allocation->height - border - child1.height); child2.x = child1.x; - child2.y = child1.y + child1.height + spacing; + child2.y = child1.y + child1.height + border; child1.width = child2.width = allocation->width; break; case winmethod_Below: - child1.height = MAX(0, allocation->height - spacing - child2.height); + child1.height = MAX(0, allocation->height - border - child2.height); child2.x = child1.x; - child2.y = child1.y + child1.height + spacing; + child2.y = child1.y + child1.height + border; child1.width = child2.width = allocation->width; break; } @@ -687,6 +698,12 @@ chimara_glk_text_buffer_output(ChimaraGlk *self, guint window_rock, gchar *text) /* Default signal handler */ } +static void +chimara_glk_iliad_screen_update(ChimaraGlk *self, gboolean typing) +{ + /* Default signal handler */ +} + /* COMPAT: G_PARAM_STATIC_STRINGS only appeared in GTK 2.13.0 */ #ifndef G_PARAM_STATIC_STRINGS @@ -722,6 +739,8 @@ chimara_glk_class_init(ChimaraGlkClass *klass) klass->char_input = chimara_glk_char_input; klass->line_input = chimara_glk_line_input; klass->text_buffer_output = chimara_glk_text_buffer_output; + klass->iliad_screen_update = chimara_glk_iliad_screen_update; + /** * ChimaraGlk::stopped: * @glk: The widget that received the signal @@ -768,7 +787,7 @@ chimara_glk_class_init(ChimaraGlkClass *klass) chimara_glk_signals[CHAR_INPUT] = g_signal_new("char-input", G_OBJECT_CLASS_TYPE(klass), 0, G_STRUCT_OFFSET(ChimaraGlkClass, char_input), NULL, NULL, - chimara_marshal_VOID__UINT_UINT, + _chimara_marshal_VOID__UINT_UINT, G_TYPE_NONE, 2, G_TYPE_UINT, G_TYPE_UINT); /** * ChimaraGlk::line-input: @@ -782,7 +801,7 @@ chimara_glk_class_init(ChimaraGlkClass *klass) chimara_glk_signals[LINE_INPUT] = g_signal_new("line-input", G_OBJECT_CLASS_TYPE(klass), 0, G_STRUCT_OFFSET(ChimaraGlkClass, line_input), NULL, NULL, - chimara_marshal_VOID__UINT_STRING, + _chimara_marshal_VOID__UINT_STRING, G_TYPE_NONE, 2, G_TYPE_UINT, G_TYPE_STRING); /** * ChimaraGlk::text-buffer-output: @@ -795,8 +814,22 @@ chimara_glk_class_init(ChimaraGlkClass *klass) chimara_glk_signals[TEXT_BUFFER_OUTPUT] = g_signal_new("text-buffer-output", G_OBJECT_CLASS_TYPE(klass), 0, G_STRUCT_OFFSET(ChimaraGlkClass, text_buffer_output), NULL, NULL, - chimara_marshal_VOID__UINT_STRING, + _chimara_marshal_VOID__UINT_STRING, G_TYPE_NONE, 2, G_TYPE_UINT, G_TYPE_STRING); + /** + * ChimaraGlk::iliad-screen-update: + * @self: The widget that received the signal + * @typing: Whether to perform a typing or full screen update + * + * Iliad specific signal which is emitted whenever the screen needs to be updated. + * Since iliad screen updates are very slow, updating should only be done when + * necessary. + */ + chimara_glk_signals[ILIAD_SCREEN_UPDATE] = g_signal_new("iliad-screen-update", + G_OBJECT_CLASS_TYPE(klass), 0, + G_STRUCT_OFFSET(ChimaraGlkClass, iliad_screen_update), NULL, NULL, + _chimara_marshal_VOID__BOOLEAN, + G_TYPE_NONE, 1, G_TYPE_BOOLEAN); /* Properties */ /** @@ -831,7 +864,10 @@ chimara_glk_class_init(ChimaraGlkClass *klass) /** * ChimaraGlk:spacing: * - * The amount of space between the Glk windows. + * The amount of space between the Glk windows. This space forms a visible + * border between windows; however, if you open a window using the + * %winmethod_NoBorder flag, there will be no spacing between it and its + * sibling window, no matter what the value of this property is. */ g_object_class_install_property(object_class, PROP_SPACING, g_param_spec_uint("spacing", _("Spacing"), @@ -1034,8 +1070,9 @@ chimara_glk_set_css_from_file(ChimaraGlk *glk, const gchar *filename, GError **e int fd = open(filename, O_RDONLY); if(fd == -1) { - *error = g_error_new(G_IO_ERROR, g_io_error_from_errno(errno), - _("Error opening file \"%s\": %s"), filename, g_strerror(errno)); + if(error) + *error = g_error_new(G_IO_ERROR, g_io_error_from_errno(errno), + _("Error opening file \"%s\": %s"), filename, g_strerror(errno)); return FALSE; } @@ -1044,13 +1081,10 @@ chimara_glk_set_css_from_file(ChimaraGlk *glk, const gchar *filename, GError **e scanner->input_name = filename; scan_css_file(scanner, glk); - /* Set the current style to a copy of the default style */ - /* FIXME this is not correct */ - copy_default_styles_to_current_styles(glk); - if(close(fd) == -1) { - *error = g_error_new(G_IO_ERROR, g_io_error_from_errno(errno), - _("Error closing file \"%s\": %s"), filename, g_strerror(errno)); + if(error) + *error = g_error_new(G_IO_ERROR, g_io_error_from_errno(errno), + _("Error closing file \"%s\": %s"), filename, g_strerror(errno)); return FALSE; } return TRUE; @@ -1076,10 +1110,6 @@ chimara_glk_set_css_from_string(ChimaraGlk *glk, const gchar *css) g_scanner_input_text(scanner, css, strlen(css)); scanner->input_name = ""; scan_css_file(scanner, glk); - - /* Set the current style to a copy of the default style */ - /* FIXME this is not correct */ - copy_default_styles_to_current_styles(glk); } /** @@ -1345,8 +1375,8 @@ chimara_glk_feed_char_input(ChimaraGlk *glk, guint keyval) * request. @text does not need to end with a newline. You can call this * function even when no window has requested line input, in which case the text * will be saved for the following window that requests line input. This has the - * disadvantage that if more than one window has requested character input, it - * is arbitrary which one gets the text. + * disadvantage that if more than one window has requested line input, it is + * arbitrary which one gets the text. */ void chimara_glk_feed_line_input(ChimaraGlk *glk, const gchar *text) @@ -1357,3 +1387,175 @@ chimara_glk_feed_line_input(ChimaraGlk *glk, const gchar *text) g_async_queue_push(priv->line_input_queue, g_strdup(text)); event_throw(glk, evtype_ForcedLineInput, NULL, 0, 0); } + +/** + * chimara_glk_is_char_input_pending: + * @glk: a #ChimaraGlk widget + * + * Use this function to tell if character input forced by + * chimara_glk_feed_char_input() has been passed to an input request or not. + * + * Returns: %TRUE if forced character input is pending, %FALSE otherwise. + */ +gboolean +chimara_glk_is_char_input_pending(ChimaraGlk *glk) +{ + g_return_val_if_fail(glk || CHIMARA_IS_GLK(glk), FALSE); + CHIMARA_GLK_USE_PRIVATE(glk, priv); + return g_async_queue_length(priv->char_input_queue) > 0; +} + +/** + * chimara_glk_is_line_input_pending: + * @glk: a #ChimaraGlk widget + * + * Use this function to tell if line input forced by + * chimara_glk_feed_line_input() has been passed to an input request or not. + * + * Returns: %TRUE if forced line input is pending, %FALSE otherwise. + */ +gboolean +chimara_glk_is_line_input_pending(ChimaraGlk *glk) +{ + g_return_val_if_fail(glk || CHIMARA_IS_GLK(glk), FALSE); + CHIMARA_GLK_USE_PRIVATE(glk, priv); + return g_async_queue_length(priv->line_input_queue) > 0; +} + +/** + * chimara_glk_get_tag: + * @glk: a #ChimaraGlk widget + * @window: The type of window to retrieve the tag for + * @name: The name of the tag to retrieve + * + * Use this function to get a #GtkTextTag so style properties can be changed. + * See also chimara_glk_set_css_from_string(). + * + * The layout of the text in Chimara is controlled by two sets of tags: one set + * describing the style in text buffers and one for text grids. See also the + * Glk specification for the difference between the two. The main narrative of + * a game is usually rendered in text buffers, whereas text grids are mostly + * used for status bars and in game menus. + * + * The following tag names are supported: + * + * normal + * emphasized + * preformatted + * header + * subheader + * alert + * note + * block-quote + * input + * user1 + * user2 + * hyperlink + * pager + * + * + * Returns: (transfer none): The #GtkTextTag corresponding to @name in the + * styles of @window. + */ +GtkTextTag * +chimara_glk_get_tag(ChimaraGlk *glk, ChimaraGlkWindowType window, const gchar *name) +{ + CHIMARA_GLK_USE_PRIVATE(glk, priv); + + switch(window) { + case CHIMARA_GLK_TEXT_BUFFER: + return GTK_TEXT_TAG( g_hash_table_lookup(priv->styles->text_buffer, name) ); + break; + case CHIMARA_GLK_TEXT_GRID: + return GTK_TEXT_TAG( g_hash_table_lookup(priv->styles->text_grid, name) ); + break; + default: + ILLEGAL_PARAM("Unknown window type: %u", window); + return NULL; + } +} + +/** + * chimara_glk_get_tag_names: + * @glk: a #ChimaraGlk widget + * @num_tags: Return location for the number of tag names retrieved. + * + * Retrieves the possible tag names to use in chimara_glk_get_tag(). + * + * Returns: (transfer none) (array length=num_tags) (element-type utf8): + * Array of strings containing the tag names. This array is owned by Chimara, + * do not free it. + */ +const gchar ** +chimara_glk_get_tag_names(ChimaraGlk *glk, unsigned int *num_tags) +{ + g_return_val_if_fail(num_tags != NULL, NULL); + + *num_tags = CHIMARA_NUM_STYLES; + return style_get_tag_names(); +} + +/** + * chimara_glk_update_style: + * @glk: a #ChimaraGlk widget + * + * Processes style updates and updates the widget to reflect the new style. + * Call this every time you change a property of a #GtkTextTag retrieved by + * chimara_glk_get_tag(). + */ +void +chimara_glk_update_style(ChimaraGlk *glk) +{ + CHIMARA_GLK_USE_PRIVATE(glk, priv); + style_update(glk); + + /* Schedule a redraw */ + g_mutex_lock(priv->arrange_lock); + priv->needs_rearrange = TRUE; + priv->ignore_next_arrange_event = TRUE; + g_mutex_unlock(priv->arrange_lock); + gtk_widget_queue_resize( GTK_WIDGET(priv->self) ); +} + +/** + * chimara_glk_set_resource_load_callback: + * @glk: a #ChimaraGlk widget + * @func: a function to call for loading resources, or %NULL + * @user_data: user data to pass to @func, or %NULL + * @destroy_user_data: a function to call for freeing @user_data, or %NULL + * + * Sometimes it is preferable to load image and sound resources from somewhere + * else than a Blorb file, for example while developing a game. Section 14 of + * the Blorb + * specification allows for this possibility. This function sets @func + * to be called when the Glk program requests loading an image or sound without + * a Blorb resource map having been loaded, optionally passing @user_data as an + * extra parameter. + * + * Note that @func is only called if no Blorb resource map has been set; having + * a resource map in place overrides this function. + * + * If you pass non-%NULL for @destroy_user_data, then @glk takes ownership of + * @user_data. When it is not needed anymore, it will be freed by calling + * @destroy_user_data on it. If you wish to retain ownership of @user_data, pass + * %NULL for @destroy_user_data. + * + * To deactivate the callback, call this function with @func set to %NULL. + */ +void +chimara_glk_set_resource_load_callback(ChimaraGlk *glk, ChimaraResourceLoadFunc func, gpointer user_data, GDestroyNotify destroy_user_data) +{ + CHIMARA_GLK_USE_PRIVATE(glk, priv); + + if(priv->resource_load_callback == func + && priv->resource_load_callback_data == user_data + && priv->resource_load_callback_destroy_data == destroy_user_data) + return; + + if(priv->resource_load_callback_destroy_data) + priv->resource_load_callback_destroy_data(priv->resource_load_callback_data); + + priv->resource_load_callback = func; + priv->resource_load_callback_data = user_data; + priv->resource_load_callback_destroy_data = destroy_user_data; +}