2 #include "chimara-glk-private.h"
5 #define BUFFER_SIZE (1024)
7 extern GPrivate *glk_data_key;
8 void on_size_prepared(GdkPixbufLoader *loader, gint width, gint height, struct image_info *info);
9 void on_pixbuf_closed(GdkPixbufLoader *loader, gpointer data);
10 glui32 draw_image_common(winid_t win, GdkPixbuf *pixbuf, glsi32 val1, glsi32 val2);
12 static gboolean image_loaded;
13 static gboolean size_determined;
15 static struct image_info*
16 load_image_from_blorb(giblorb_result_t resource, glui32 image, gint width, gint height)
18 ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
19 GError *pixbuf_error = NULL;
22 struct image_info *info = g_new0(struct image_info, 1);
23 info->resource_number = image;
25 /* Load the resource */
26 GdkPixbufLoader *loader = gdk_pixbuf_loader_new();
27 g_signal_connect( loader, "size-prepared", G_CALLBACK(on_size_prepared), info );
28 g_signal_connect( loader, "closed", G_CALLBACK(on_pixbuf_closed), NULL );
30 /* Scale image if necessary */
31 if(width > 0 && height > 0) {
32 gdk_pixbuf_loader_set_size(loader, width, height);
36 glk_stream_set_position(glk_data->resource_file, resource.data.startpos, seekmode_Start);
37 buffer = g_malloc( BUFFER_SIZE * sizeof(guchar) );
39 guint32 total_read = 0;
41 while(total_read < resource.length && !image_loaded) {
42 guint32 num_read = glk_get_buffer_stream(glk_data->resource_file, (char *) buffer, BUFFER_SIZE);
44 if( !gdk_pixbuf_loader_write(loader, buffer, MIN(BUFFER_SIZE, num_read), &pixbuf_error) ) {
45 WARNING_S("Cannot read image", pixbuf_error->message);
46 giblorb_unload_chunk(glk_data->resource_map, image);
47 gdk_pixbuf_loader_close(loader, &pixbuf_error);
52 total_read += num_read;
54 gdk_pixbuf_loader_close(loader, &pixbuf_error);
55 giblorb_unload_chunk(glk_data->resource_map, resource.chunknum);
58 /* Wait for the PixbufLoader to finish loading the image */
59 g_mutex_lock(glk_data->resource_lock);
60 while(!image_loaded) {
61 g_cond_wait(glk_data->resource_loaded, glk_data->resource_lock);
63 g_mutex_unlock(glk_data->resource_lock);
65 info->pixbuf = gdk_pixbuf_loader_get_pixbuf(loader);
66 gdk_pixbuf_ref(info->pixbuf);
68 g_object_unref(loader);
72 static struct image_info *
73 load_image_from_file(const gchar *filename, glui32 image, gint width, gint height)
77 struct image_info *info = g_new0(struct image_info, 1);
78 info->resource_number = image;
80 if(width > 0 && height > 0) {
82 info->pixbuf = gdk_pixbuf_new_from_file_at_size(filename, width, height, &err);
84 info->pixbuf = gdk_pixbuf_new_from_file(filename, &err);
87 IO_WARNING("Error loading resource from alternative location", filename, err->message);
92 gdk_pixbuf_ref(info->pixbuf);
97 static struct image_info*
98 load_image_in_cache(glui32 image, gint width, gint height)
100 ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
101 struct image_info *info = NULL;
103 /* Lookup the proper resource */
104 if(!glk_data->resource_map) {
105 if(!glk_data->resource_load_callback) {
106 WARNING("No resource map has been loaded yet.");
109 gchar *filename = glk_data->resource_load_callback(CHIMARA_RESOURCE_IMAGE, image, glk_data->resource_load_callback_data);
111 WARNING("Error loading resource from alternative location");
114 info = load_image_from_file(filename, image, width, height);
117 giblorb_result_t resource;
118 giblorb_err_t blorb_error = giblorb_load_resource(glk_data->resource_map, giblorb_method_FilePos, &resource, giblorb_ID_Pict, image);
119 if(blorb_error != giblorb_err_None) {
120 WARNING_S( "Error loading resource", giblorb_get_error_message(blorb_error) );
123 info = load_image_from_blorb(resource, image, width, height);
126 /* Store the image in the cache */
129 if( g_slist_length(glk_data->image_cache) >= IMAGE_CACHE_MAX_NUM ) {
130 struct image_info *head = (struct image_info*) glk_data->image_cache->data;
131 gdk_pixbuf_unref(head->pixbuf);
133 glk_data->image_cache = g_slist_remove_link(glk_data->image_cache, glk_data->image_cache);
135 info->width = gdk_pixbuf_get_width(info->pixbuf);
136 info->height = gdk_pixbuf_get_height(info->pixbuf);
137 glk_data->image_cache = g_slist_prepend(glk_data->image_cache, info);
144 on_size_prepared(GdkPixbufLoader *loader, gint width, gint height, struct image_info *info)
146 ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
148 g_mutex_lock(glk_data->resource_lock);
150 info->height = height;
151 size_determined = TRUE;
152 g_cond_broadcast(glk_data->resource_info_available);
153 g_mutex_unlock(glk_data->resource_lock);
157 on_pixbuf_closed(GdkPixbufLoader *loader, gpointer data)
161 ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
163 g_mutex_lock(glk_data->resource_lock);
165 g_cond_broadcast(glk_data->resource_loaded);
166 g_mutex_unlock(glk_data->resource_lock);
173 clear_image_cache(struct image_info *data, gpointer user_data)
175 gdk_pixbuf_unref(data->pixbuf);
179 static struct image_info*
180 image_cache_find(struct image_info* to_find)
182 ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
183 GSList *link = glk_data->image_cache;
193 /* Iterate over the cache to find the correct image and size */
194 struct image_info *match = NULL;
196 struct image_info *info = (struct image_info*) link->data;
197 if(info->resource_number == to_find->resource_number) {
198 /* Check size: are we looking for a scaled version or the original one? */
199 if(to_find->scaled) {
201 if(info->width == to_find->width && info->height == to_find->height) {
202 /* Prescaled image found */
206 else if(info->width >= to_find->width && info->height >= to_find->height) {
207 /* Larger image found, needs to be scaled down in order to work */
214 return info; /* Found a match */
218 } while( (link = g_slist_next(link)) );
226 * glk_image_get_info:
227 * @image: An image resource number.
228 * @width: Pointer to a location at which to store the image's width.
229 * @height: Pointer to a location at which to store the image's height.
231 * This gets information about the image resource with the given identifier. It
232 * returns %TRUE (1) if there is such an image, and %FALSE (0) if not. You can
233 * also pass pointers to width and height variables; if the image exists, the
234 * variables will be filled in with the width and height of the image, in
235 * pixels. (You can pass %NULL for either width or height if you don't care
236 * about that information.)
239 * You should always use this function to measure the size of images when you
240 * are creating your display. Do this even if you created the images, and you
241 * know how big they <quote>should</quote> be. This is because images may be
242 * scaled in translating from one platform to another, or even from one
243 * machine to another. A Glk library might display all images larger than
244 * their original size, because of screen resolution or player preference.
245 * Images will be scaled proportionally, but you still need to call
246 * glk_image_get_info() to determine their absolute size.
249 * Returns: %TRUE if @image is a valid identifier, %FALSE if not.
252 glk_image_get_info(glui32 image, glui32 *width, glui32 *height)
254 struct image_info *to_find = g_new0(struct image_info, 1);
255 struct image_info *found;
256 to_find->resource_number = image;
257 to_find->scaled = FALSE; /* we want the original image size */
259 if( !(found = image_cache_find(to_find)) ) {
260 found = load_image_in_cache(image, 0, 0);
266 *width = found->width;
268 *height = found->height;
274 * @win: A graphics or text buffer window.
275 * @image: An image resource number.
276 * @val1: The x coordinate at which to draw the image (if @win is a graphics
277 * window); or, an <link linkend="chimara-imagealign-InlineUp">image
278 * alignment</link> constant (if @win is a text window).
279 * @val2: The y coordinate at which to draw the image (if @win is a graphics
280 * window); this parameter is ignored if @win is a text buffer window.
282 * This draws the given image resource in the given window. The position of the
283 * image is given by @val1 and @val2, but their meaning varies depending on what
284 * kind of window you are drawing in. See <link
285 * linkend="chimara-Graphics-in-Graphics-Windows">Graphics in Graphics
286 * Windows</link> and <link linkend="Graphics-in-Text-Buffer-Windows">Graphics
287 * in Text Buffer Windows</link>.
289 * This function returns a flag indicating whether the drawing operation
292 * A %FALSE result can occur for many reasons. The image data might be
293 * corrupted; the library may not have enough memory to operate; there may be
294 * no image with the given identifier; the window might not support image
295 * display; and so on.
298 * Returns: %TRUE if the operation succeeded, %FALSE if not.
301 glk_image_draw(winid_t win, glui32 image, glsi32 val1, glsi32 val2)
303 VALID_WINDOW(win, return FALSE);
304 g_return_val_if_fail(win->type == wintype_Graphics || win->type == wintype_TextBuffer, FALSE);
306 struct image_info *to_find = g_new0(struct image_info, 1);
307 struct image_info *info;
309 /* Lookup the proper resource */
310 to_find->resource_number = image;
311 to_find->scaled = FALSE; /* we want the original image size */
313 if( !(info = image_cache_find(to_find)) ) {
314 info = load_image_in_cache(image, 0, 0);
319 return draw_image_common(win, info->pixbuf, val1, val2);
323 * glk_image_draw_scaled:
324 * @win: A graphics or text buffer window.
325 * @image: An image resource number.
326 * @val1: The x coordinate at which to draw the image (if @win is a graphics
327 * window); or, an <link linkend="chimara-imagealign-InlineUp">image
328 * alignment</link> constant (if @win is a text window).
329 * @val2: The y coordinate at which to draw the image (if @win is a graphics
330 * window); this parameter is ignored if @win is a text buffer window.
331 * @width: The width of the image.
332 * @height: The height of the image.
334 * This is similar to glk_image_draw(), but it scales the image to the given
335 * @width and @height, instead of using the image's standard size. (You can
336 * measure the standard size with glk_image_get_info().)
338 * If @width or @height is zero, nothing is drawn. Since those arguments are
339 * unsigned integers, they cannot be negative. If you pass in a negative number,
340 * it will be interpreted as a very large positive number, which is almost
341 * certain to end badly.
343 * Returns: %TRUE if the operation succeeded, %FALSE otherwise.
346 glk_image_draw_scaled(winid_t win, glui32 image, glsi32 val1, glsi32 val2, glui32 width, glui32 height)
348 VALID_WINDOW(win, return FALSE);
349 g_return_val_if_fail(win->type == wintype_Graphics || win->type == wintype_TextBuffer, FALSE);
351 ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
352 struct image_info *to_find = g_new0(struct image_info, 1);
353 struct image_info *info;
354 struct image_info *scaled_info;
356 /* Lookup the proper resource */
357 to_find->resource_number = image;
358 to_find->scaled = TRUE; /* any image size equal or larger than requested will do */
360 if( !(info = image_cache_find(to_find)) ) {
361 info = load_image_in_cache(image, width, height);
366 /* Scale the image if necessary */
367 if(info->width != width || info->height != height) {
368 GdkPixbuf *scaled = gdk_pixbuf_scale_simple(info->pixbuf, width, height, GDK_INTERP_BILINEAR);
370 /* Add the scaled image into the image cache */
371 scaled_info = g_new0(struct image_info, 1);
372 scaled_info->resource_number = info->resource_number;
373 scaled_info->width = gdk_pixbuf_get_width(scaled);
374 scaled_info->height = gdk_pixbuf_get_width(scaled);
375 scaled_info->pixbuf = scaled;
376 scaled_info->scaled = TRUE;
377 glk_data->image_cache = g_slist_prepend(glk_data->image_cache, scaled_info);
379 /* Continue working with the scaled version */
383 return draw_image_common(win, info->pixbuf, val1, val2);
386 /* Internal function: draws a pixbuf to a graphics window of text buffer */
388 draw_image_common(winid_t win, GdkPixbuf *pixbuf, glsi32 val1, glsi32 val2)
391 case wintype_Graphics:
397 gtk_image_get_pixmap( GTK_IMAGE(win->widget), &canvas, NULL );
399 WARNING("Could not get pixmap");
403 gdk_draw_pixbuf( GDK_DRAWABLE(canvas), NULL, pixbuf, 0, 0, val1, val2, -1, -1, GDK_RGB_DITHER_NONE, 0, 0 );
405 /* Update the screen */
406 gtk_widget_queue_draw(win->widget);
412 case wintype_TextBuffer:
414 flush_window_buffer(win);
418 GtkTextBuffer *buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(win->widget) );
419 GtkTextIter end, start;
420 gtk_text_buffer_get_end_iter(buffer, &end);
422 gtk_text_buffer_insert_pixbuf(buffer, &end, pixbuf);
424 gtk_text_iter_forward_char(&end);
428 case imagealign_InlineDown:
429 height -= win->unit_height;
431 case imagealign_InlineCenter:
432 height = -win->unit_height / 2;
434 case imagealign_InlineUp:
440 GtkTextTag *tag = gtk_text_buffer_create_tag(buffer, NULL, "rise", PANGO_SCALE * (-height), NULL);
441 gtk_text_buffer_apply_tag(buffer, tag, &start, &end);
452 * glk_window_set_background_color:
453 * @win: A graphics window.
454 * @color: a 32-bit RGB color value.
456 * This sets the window's background color. It does not change what is currently
457 * displayed; it only affects subsequent clears and resizes. The initial
458 * background color of each window is white.
460 * Colors are encoded in a 32-bit value: the top 8 bits must be zero, the next 8
461 * bits are the red value, the next 8 bits are the green value, and the bottom 8
462 * bits are the blue value. Color values range from 0 to 255.
464 * So <code>0x00000000</code> is black, <code>0x00FFFFFF</code> is white, and
465 * <code>0x00FF0000</code> is bright red.
469 * This function may only be used with graphics windows. To set background
470 * colors in a text window, use text styles with color hints; see <link
471 * linkend="chimara-Styles">Styles</link>.
475 glk_window_set_background_color(winid_t win, glui32 color)
477 VALID_WINDOW(win, return);
478 g_return_if_fail(win->type == wintype_Graphics);
480 win->background_color = color;
484 * glk_window_fill_rect:
485 * @win: A graphics window.
486 * @color: A 32-bit RGB color value, see glk_window_set_background_color().
487 * @left: The x coordinate of the top left corner of the rectangle.
488 * @top: The y coordinate of the top left corner of the rectangle.
489 * @width: The width of the rectangle.
490 * @height: The height of the rectangle.
492 * This fills the given rectangle with the given color. It is legitimate for
493 * part of the rectangle to fall outside the window. If width or height is zero,
497 glk_window_fill_rect(winid_t win, glui32 color, glsi32 left, glsi32 top, glui32 width, glui32 height)
499 VALID_WINDOW(win, return);
500 g_return_if_fail(win->type == wintype_Graphics);
505 gtk_image_get_pixmap( GTK_IMAGE(win->widget), &map, NULL );
507 GdkGC *gc = gdk_gc_new(map);
509 glkcolor_to_gdkcolor(color, &gdkcolor);
510 gdk_gc_set_rgb_fg_color(gc, &gdkcolor);
511 gdk_draw_rectangle( GDK_DRAWABLE(map), gc, TRUE, left, top, width, height);
512 gtk_widget_queue_draw(win->widget);
519 * glk_window_erase_rect:
520 * @win: A graphics window.
521 * @left: The x coordinate of the top left corner of the rectangle.
522 * @top: The y coordinate of the top left corner of the rectangle.
523 * @width: The width of the rectangle.
524 * @height: The height of the rectangle.
526 * This fills the given rectangle with the window's background color.
528 * You can also fill an entire graphics window with its background color by
529 * calling glk_window_clear().
532 glk_window_erase_rect(winid_t win, glsi32 left, glsi32 top, glui32 width, glui32 height)
534 glk_window_fill_rect(win, win->background_color, left, top, width, height);
538 * glk_window_flow_break:
541 * You may wish to <quote>break</quote> the stream of text down below the
542 * current margin image. Since lines of text can be in any font and size, you
543 * cannot do this by counting newlines. Instead, use this function.
545 * If the current point in the text is indented around a margin-aligned image,
546 * this acts like the correct number of newlines to start a new line below the
547 * image. (If there are several margin-aligned images, it goes below all of
548 * them.) If the current point is not beside a margin-aligned image, this call
551 * When a text buffer window is resized, a flow-break behaves cleverly; it may
552 * become active or inactive as necessary. You can consider this function to
553 * insert an invisible mark in the text stream. The mark works out how many
554 * newlines it needs to be whenever the text is formatted for display.
556 * An example of the use of glk_window_flow_break(): If you display a
557 * left-margin image at the start of every line, they can stack up in a strange
558 * diagonal way that eventually squeezes all the text off the screen.
560 * If you can't picture this, draw some diagrams. Make the margin images more
561 * than one line tall, so that each line starts already indented around the
564 * To avoid this problem, call glk_window_flow_break() immediately before
565 * glk_image_draw() for every margin-aligned image.
567 * In all windows other than text buffers, glk_window_flow_break() has no
571 * This function is not implemented yet.
574 void glk_window_flow_break(winid_t win)
576 VALID_WINDOW(win, return);
579 /*** Called when the graphics window is resized. Resize the backing pixmap if necessary ***/
581 on_graphics_size_allocate(GtkWidget *widget, GtkAllocation *allocation, winid_t win)
584 gtk_image_get_pixmap( GTK_IMAGE(widget), &oldmap, NULL );
588 /* Determine whether a pixmap exists with the correct size */
589 gboolean needs_resize = FALSE;
593 gdk_drawable_get_size( GDK_DRAWABLE(oldmap), &oldwidth, &oldheight );
594 if(oldwidth != allocation->width || oldheight != allocation->height)
599 /* Create a new pixmap */
600 GdkPixmap *newmap = gdk_pixmap_new(widget->window, allocation->width, allocation->height, -1);
601 gdk_draw_rectangle( GDK_DRAWABLE(newmap), widget->style->white_gc, TRUE, 0, 0, allocation->width, allocation->height);
603 /* Copy the contents of the old pixmap */
605 gdk_draw_drawable( GDK_DRAWABLE(newmap), widget->style->white_gc, GDK_DRAWABLE(oldmap), 0, 0, 0, 0, oldwidth, oldheight);
607 /* Use the new pixmap */
608 gtk_image_set_from_pixmap( GTK_IMAGE(widget), newmap, NULL );
609 g_object_unref(newmap);