X-Git-Url: https://git.stderr.nl/gitweb?a=blobdiff_plain;f=libchimara%2Fchimara-glk.c;h=8fd1a1e81b752a430537961253813191dd685ba4;hb=59f3bc1e4f21377c362c1f497fb225711127d7a0;hp=ca01f44510d7c7dd86a0db2fa9698385cea1197b;hpb=28c8862dc3d26a9a3735d0c2eb22ceb04be632c8;p=projects%2Fchimara%2Fchimara.git diff --git a/libchimara/chimara-glk.c b/libchimara/chimara-glk.c index ca01f44..8fd1a1e 100644 --- a/libchimara/chimara-glk.c +++ b/libchimara/chimara-glk.c @@ -32,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() @@ -128,7 +127,8 @@ enum { PROP_SPACING, PROP_PROGRAM_NAME, PROP_PROGRAM_INFO, - PROP_STORY_NAME + PROP_STORY_NAME, + PROP_RUNNING }; enum { @@ -150,7 +150,9 @@ G_DEFINE_TYPE(ChimaraGlk, chimara_glk, GTK_TYPE_CONTAINER); static void chimara_glk_init(ChimaraGlk *self) { - GTK_WIDGET_SET_FLAGS(GTK_WIDGET(self), GTK_NO_WINDOW); + chimara_init(); /* This is a library entry point */ + + gtk_widget_set_has_window(GTK_WIDGET(self), FALSE); ChimaraGlkPrivate *priv = CHIMARA_GLK_PRIVATE(self); @@ -178,7 +180,7 @@ 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(); @@ -247,6 +249,9 @@ chimara_glk_get_property(GObject *object, guint prop_id, GValue *value, GParamSp case PROP_STORY_NAME: g_value_set_string(value, priv->story_name); break; + case PROP_RUNNING: + g_value_set_boolean(value, priv->running); + break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); } @@ -303,6 +308,9 @@ 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); @@ -329,7 +337,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) { @@ -363,13 +372,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; } } @@ -379,7 +388,9 @@ request_recurse(winid_t win, GtkRequisition *requisition, guint spacing) gtk_widget_size_request(win->frame, requisition); } -/* Overrides gtk_widget_size_request */ +/* Old GTK 2 functionality overriding gtk_widget_size_request(); +get_preferred_width() and get_preferred_height() are implemented in terms of +this function. */ static void chimara_glk_size_request(GtkWidget *widget, GtkRequisition *requisition) { @@ -389,20 +400,51 @@ chimara_glk_size_request(GtkWidget *widget, GtkRequisition *requisition) ChimaraGlkPrivate *priv = CHIMARA_GLK_PRIVATE(widget); + guint border_width = gtk_container_get_border_width(GTK_CONTAINER(widget)); /* For now, just pass the size request on to the root Glk window */ if(priv->root_window) { request_recurse(priv->root_window->data, requisition, priv->spacing); - requisition->width += 2 * GTK_CONTAINER(widget)->border_width; - requisition->height += 2 * GTK_CONTAINER(widget)->border_width; + requisition->width += 2 * border_width; + requisition->height += 2 * border_width; } else { - requisition->width = CHIMARA_GLK_MIN_WIDTH + 2 * GTK_CONTAINER(widget)->border_width; - requisition->height = CHIMARA_GLK_MIN_HEIGHT + 2 * GTK_CONTAINER(widget)->border_width; + requisition->width = CHIMARA_GLK_MIN_WIDTH + 2 * border_width; + requisition->height = CHIMARA_GLK_MIN_HEIGHT + 2 * border_width; } } +/* Minimal implementation of width-for-height request, in terms of the old +GTK 2 mechanism. FIXME: make this more efficient. */ +static void +chimara_glk_get_preferred_width(GtkWidget *widget, int *minimal, int *natural) +{ + g_return_if_fail(widget || CHIMARA_IS_GLK(widget)); + g_return_if_fail(minimal); + g_return_if_fail(natural); + + GtkRequisition requisition; + + chimara_glk_size_request(widget, &requisition); + *minimal = *natural = requisition.width; +} + +/* Minimal implementation of height-for-width request, in terms of the old +GTK 2 mechanism. FIXME: make this more efficient. */ +static void +chimara_glk_get_preferred_height(GtkWidget *widget, int *minimal, int *natural) +{ + g_return_if_fail(widget || CHIMARA_IS_GLK(widget)); + g_return_if_fail(minimal); + g_return_if_fail(natural); + + GtkRequisition requisition; + + chimara_glk_size_request(widget, &requisition); + *minimal = *natural = requisition.height; +} + /* Recursively give the Glk windows their allocated space. Returns a window containing all children of this window that must be redrawn, or NULL if there are no children that require redrawing. */ @@ -413,12 +455,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; @@ -432,22 +475,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; } @@ -458,16 +501,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; } } @@ -476,27 +519,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; } @@ -518,8 +561,10 @@ allocate_recurse(winid_t win, GtkAllocation *allocation, guint spacing) /* It says in the spec that when a text grid window is resized smaller, the bottom or right area is thrown away; when it is resized larger, the bottom or right area is filled with blanks. */ - glui32 newwidth = (glui32)(win->widget->allocation.width / win->unit_width); - glui32 newheight = (glui32)(win->widget->allocation.height / win->unit_height); + GtkAllocation widget_allocation; + gtk_widget_get_allocation(win->widget, &widget_allocation); + glui32 newwidth = (glui32)(widget_allocation.width / win->unit_width); + glui32 newheight = (glui32)(widget_allocation.height / win->unit_height); gint line; GtkTextBuffer *textbuffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) ); GtkTextIter start, end; @@ -594,14 +639,15 @@ chimara_glk_size_allocate(GtkWidget *widget, GtkAllocation *allocation) ChimaraGlkPrivate *priv = CHIMARA_GLK_PRIVATE(widget); - widget->allocation = *allocation; + gtk_widget_set_allocation(widget, allocation); if(priv->root_window) { GtkAllocation child; - child.x = allocation->x + GTK_CONTAINER(widget)->border_width; - child.y = allocation->y + GTK_CONTAINER(widget)->border_width; - child.width = CLAMP(allocation->width - 2 * GTK_CONTAINER(widget)->border_width, 0, allocation->width); - child.height = CLAMP(allocation->height - 2 * GTK_CONTAINER(widget)->border_width, 0, allocation->height); + guint border_width = gtk_container_get_border_width(GTK_CONTAINER(widget)); + child.x = allocation->x + border_width; + child.y = allocation->y + border_width; + child.width = CLAMP(allocation->width - 2 * border_width, 0, allocation->width); + child.height = CLAMP(allocation->height - 2 * border_width, 0, allocation->height); winid_t arrange = allocate_recurse(priv->root_window->data, &child, priv->spacing); /* arrange points to a window that contains all text grid and graphics @@ -700,18 +746,6 @@ 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 - -/* COMPAT: G_PARAM_STATIC_NAME and friends only appeared in GTK 2.8 */ -#if GTK_CHECK_VERSION(2,8,0) -#define G_PARAM_STATIC_STRINGS (G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB) -#else -#define G_PARAM_STATIC_STRINGS (0) -#endif - -#endif - static void chimara_glk_class_init(ChimaraGlkClass *klass) { @@ -722,7 +756,8 @@ chimara_glk_class_init(ChimaraGlkClass *klass) object_class->finalize = chimara_glk_finalize; GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(klass); - widget_class->size_request = chimara_glk_size_request; + widget_class->get_preferred_width = chimara_glk_get_preferred_width; + widget_class->get_preferred_height = chimara_glk_get_preferred_height; widget_class->size_allocate = chimara_glk_size_allocate; GtkContainerClass *container_class = GTK_CONTAINER_CLASS(klass); @@ -813,7 +848,7 @@ chimara_glk_class_init(ChimaraGlkClass *klass) _chimara_marshal_VOID__UINT_STRING, G_TYPE_NONE, 2, G_TYPE_UINT, G_TYPE_STRING); /** - * ChimaraGlk::iliad-update-screen: + * ChimaraGlk::iliad-screen-update: * @self: The widget that received the signal * @typing: Whether to perform a typing or full screen update * @@ -860,7 +895,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"), @@ -915,6 +953,17 @@ chimara_glk_class_init(ChimaraGlkClass *klass) NULL, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS) ); + /** + * ChimaraGlk:running: + * + * Whether this Glk widget is currently running a game or not. + */ + g_object_class_install_property(object_class, PROP_RUNNING, + g_param_spec_boolean("running", _("Running"), + _("Whether there is a program currently running"), + FALSE, + G_PARAM_READABLE | G_PARAM_STATIC_STRINGS) ); + /* Private data */ g_type_class_add_private(klass, sizeof(ChimaraGlkPrivate)); } @@ -1063,8 +1112,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; } @@ -1074,8 +1124,9 @@ chimara_glk_set_css_from_file(ChimaraGlk *glk, const gchar *filename, GError **e scan_css_file(scanner, 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; @@ -1223,8 +1274,7 @@ chimara_glk_run(ChimaraGlk *glk, const gchar *plugin, int argc, char *argv[], GE g_assert( g_module_supported() ); /* If there is already a module loaded, free it first -- you see, we want to * keep modules loaded as long as possible to avoid crashes in stack unwinding */ - if( priv->program && !g_module_close(priv->program) ) - g_warning( "Error closing module :%s", g_module_error() ); + chimara_glk_unload_plugin(glk); /* Open the module to run */ priv->program = g_module_open(plugin, G_MODULE_BIND_LAZY); @@ -1266,6 +1316,35 @@ chimara_glk_run(ChimaraGlk *glk, const gchar *plugin, int argc, char *argv[], GE return !(priv->thread == NULL); } +/** + * chimara_glk_run_file: + * @self: a #ChimaraGlk widget + * @plugin_file: a #GFile pointing to a plugin module compiled with glk.h + * @argc: Number of command line arguments in @argv + * @argv: Array of command line arguments to pass to the plugin + * @error: location to store a GError, or %NULL + * + * Opens a Glk program compiled as a plugin, from a #GFile. See + * chimara_glk_run() for details. + * + * Return value: %TRUE if the Glk program was started successfully. + */ +gboolean +chimara_glk_run_file(ChimaraGlk *self, GFile *plugin_file, int argc, char *argv[], GError **error) +{ + g_return_val_if_fail(self || CHIMARA_IS_GLK(self), FALSE); + g_return_val_if_fail(plugin_file || G_IS_FILE(plugin_file), FALSE); + g_return_val_if_fail(error == NULL || *error == NULL, FALSE); + + char *path = g_file_get_path(plugin_file); + gboolean retval = chimara_glk_run(self, path, argc, argv, error); + g_free(path); + + return retval; +} + /** * chimara_glk_stop: * @glk: a #ChimaraGlk widget @@ -1273,6 +1352,8 @@ chimara_glk_run(ChimaraGlk *glk, const gchar *plugin, int argc, char *argv[], GE * Signals the Glk program running in @glk to abort. Note that if the program is * caught in an infinite loop in which glk_tick() is not called, this may not * work. + * + * This function does nothing if no Glk program is running. */ void chimara_glk_stop(ChimaraGlk *glk) @@ -1303,6 +1384,8 @@ chimara_glk_stop(ChimaraGlk *glk) * * Holds up the main thread and waits for the Glk program running in @glk to * finish. + * + * This function does nothing if no Glk program is running. */ void chimara_glk_wait(ChimaraGlk *glk) @@ -1318,6 +1401,26 @@ chimara_glk_wait(ChimaraGlk *glk) gdk_threads_enter(); } +/** + * chimara_glk_unload_plugin: + * @glk: a #ChimaraGlk widget + * + * The plugin containing the Glk program is unloaded as late as possible before + * loading a new plugin, in order to prevent crashes while printing stack + * backtraces during debugging. Sometimes this behavior is not desirable. This + * function forces @glk to unload the plugin running in it. + * + * This function does nothing if there is no plugin loaded. + */ +void +chimara_glk_unload_plugin(ChimaraGlk *glk) +{ + g_return_if_fail(glk || CHIMARA_IS_GLK(glk)); + CHIMARA_GLK_USE_PRIVATE(glk, priv); + if( priv->program && !g_module_close(priv->program) ) + g_warning( "Error closing module :%s", g_module_error() ); +} + /** * chimara_glk_get_running: * @glk: a #ChimaraGlk widget @@ -1415,16 +1518,16 @@ chimara_glk_is_line_input_pending(ChimaraGlk *glk) /** * chimara_glk_get_tag: - * @glk: a #ChimarGlk widget + * @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. + * 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 + * 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. * @@ -1443,9 +1546,12 @@ chimara_glk_is_line_input_pending(ChimaraGlk *glk) * user2 * hyperlink * pager - * + * + * + * Returns: (transfer none): The #GtkTextTag corresponding to @name in the + * styles of @window. */ -GtkTextTag* +GtkTextTag * chimara_glk_get_tag(ChimaraGlk *glk, ChimaraGlkWindowType window, const gchar *name) { CHIMARA_GLK_USE_PRIVATE(glk, priv); @@ -1464,27 +1570,23 @@ chimara_glk_get_tag(ChimaraGlk *glk, ChimaraGlkWindowType window, const gchar *n } /** - * chimara_glk_get_tag: - * @glk: a #ChimarGlk widget - * - * Retrieves the possible tag names to use in #chimara_glk_get_tag. - */ -const gchar** -chimara_glk_get_tag_names(ChimaraGlk *glk) -{ - return style_get_tag_names(); -} - -/** - * chimara_glk_get_num_tag_names: + * 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(). * - * Retrieves the number of style tags returned by #chimara_glk_get_tag_names. + * 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. */ -gint -chimara_glk_get_num_tag_names(ChimaraGlk *glk) +const gchar ** +chimara_glk_get_tag_names(ChimaraGlk *glk, unsigned int *num_tags) { - return CHIMARA_NUM_STYLES; + g_return_val_if_fail(num_tags != NULL, NULL); + + *num_tags = CHIMARA_NUM_STYLES; + return style_get_tag_names(); } /** @@ -1493,7 +1595,7 @@ chimara_glk_get_num_tag_names(ChimaraGlk *glk) * * 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. + * chimara_glk_get_tag(). */ void chimara_glk_update_style(ChimaraGlk *glk) @@ -1514,6 +1616,7 @@ chimara_glk_update_style(ChimaraGlk *glk) * @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 @@ -1526,12 +1629,27 @@ chimara_glk_update_style(ChimaraGlk *glk) * 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) +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; }