src/image-overlay.c

   1 /*
   2  * GQview
   3  * (C) 2006 John Ellis
   4  *
   5  * Author: John Ellis
   6  *
   7  * This software is released under the GNU General Public License (GNU GPL).
   8  * Please read the included file COPYING for more information.
   9  * This software comes with no warranty of any kind, use at your own risk!
  10  */
  11
  12 #include "gqview.h"
  13 #include "image-overlay.h"
  14
  15 #include "collect.h"
  16 #include "filelist.h"
  17 #include "image.h"
  18 #include "img-view.h"
  19 #include "layout.h"
  20 #include "pixbuf-renderer.h"
  21 #include "pixbuf_util.h"
  22
  23
  24 /*
  25  *----------------------------------------------------------------------------
  26  * image overlay
  27  *----------------------------------------------------------------------------
  28  */
  29
  30 typedef struct _OverlayStateData OverlayStateData;
  31 struct _OverlayStateData {
  32         ImageWindow *imd;
  33         ImageState changed_states;
  34
  35         gint show_info;
  36         gint show_status;
  37
  38         gint ovl_info;
  39
  40         gint icon_time[IMAGE_OSD_COUNT];
  41         gint icon_id[IMAGE_OSD_COUNT];
  42
  43         gint idle_id;
  44         gint timer_id;
  45         gulong destroy_id;
  46 };
  47
  48
  49 typedef struct _OSDIcon OSDIcon;
  50 struct _OSDIcon {
  51         gint x;
  52         gint y;
  53         gchar *key;
  54 };
  55
  56 static OSDIcon osd_icons[] = {
  57         { 0, -10, PIXBUF_INLINE_ICON },
  58         { -10, -10, "IMAGE_OSD_ROTATE_USER" },
  59         { -10, -10, "IMAGE_OSD_ROTATE_AUTO" },
  60         { -40, -10, "IMAGE_OSD_COLOR" },
  61         { -70, -10, "IMAGE_OSD_FIRST" },
  62         { -70, -10, "IMAGE_OSD_LAST" },
  63         { 0, 0, NULL }
  64 };
  65
  66 #define OSD_DATA "overlay-data"
  67
  68 #define OSD_INFO_X 10
  69 #define OSD_INFO_Y -10
  70
  71 #define IMAGE_OSD_DEFAULT_DURATION 30
  72
  73
  74 static void image_osd_timer_schedule(OverlayStateData *osd);
  75
  76
  77 static GdkPixbuf *image_osd_info_render(ImageWindow *imd)
  78 {
  79         GdkPixbuf *pixbuf;
  80         gint width, height;
  81         PangoLayout *layout;
  82         const gchar *name;
  83         gchar *name_escaped;
  84         gchar *text;
  85         gchar *size;
  86         gint n, t;
  87         CollectionData *cd;
  88         CollectInfo *info;
  89         gchar *ct;
  90
  91         name = image_get_name(imd);
  92         if (name)
  93                 {
  94                 name_escaped = g_markup_escape_text(name, -1);
  95                 }
  96         else
  97                 {
  98                 name_escaped = NULL;
  99                 }
 100
 101         cd = image_get_collection(imd, &info);
 102         if (cd)
 103                 {
 104                 gchar *buf;
 105
 106                 t = g_list_length(cd->list);
 107                 n = g_list_index(cd->list, info) + 1;
 108                 buf = g_markup_escape_text((cd->name) ? cd->name : _("Untitled"), -1);
 109                 ct = g_strdup_printf("<i>%s</i>\n", buf);
 110                 g_free(buf);
 111                 }
 112         else
 113                 {
 114                 LayoutWindow *lw;
 115
 116                 lw = layout_find_by_image(imd);
 117                 if (lw)
 118                         {
 119                         if (lw->slideshow)
 120                                 {
 121                                 n = g_list_length(lw->slideshow->list_done);
 122                                 t = n + g_list_length(lw->slideshow->list);
 123                                 if (n == 0) n = t;
 124                                 }
 125                         else
 126                                 {
 127                                 t = layout_list_count(lw, NULL);
 128                                 n = layout_list_get_index(lw, image_get_path(lw->image)) + 1;
 129                                 }
 130                         }
 131                 else if (view_window_find_image(imd, &n, &t))
 132                         {
 133                         n++;
 134                         }
 135                 else
 136                         {
 137                         t = 1;
 138                         n = 1;
 139                         }
 140
 141                 if (n < 1) n = 1;
 142                 if (t < 1) t = 1;
 143
 144                 ct = g_strdup("");
 145                 }
 146
 147         size = text_from_size_abrev(imd->size);
 148         if (!name_escaped)
 149                 {
 150                 text = g_strdup_printf(_("Untitled"));
 151                 }
 152         else if (imd->unknown)
 153                 {
 154                 text = g_strdup_printf("%s(%d/%d) <b>%s</b>\n%s - %s", ct,
 155                                        n, t, name_escaped,
 156                                        text_from_time(imd->mtime), size);
 157                 }
 158         else
 159                 {
 160                 gint w, h;
 161
 162                 if (imd->delay_flip &&
 163                     imd->il && imd->il->pixbuf &&
 164                     image_get_pixbuf(imd) != imd->il->pixbuf)
 165                         {
 166                         w = gdk_pixbuf_get_width(imd->il->pixbuf);
 167                         h = gdk_pixbuf_get_height(imd->il->pixbuf);
 168                         }
 169                 else
 170                         {
 171                         pixbuf_renderer_get_image_size(PIXBUF_RENDERER(imd->pr), &w, &h);
 172                         }
 173
 174                 text = g_strdup_printf("%s(%d/%d) <b>%s</b>\n%d x %d - %s - %s", ct,
 175                                        n, t, name_escaped,
 176                                        w, h,
 177                                        text_from_time(imd->mtime), size);
 178                 }
 179         g_free(size);
 180         g_free(ct);
 181         g_free(name_escaped);
 182
 183         layout = gtk_widget_create_pango_layout(imd->pr, NULL);
 184         pango_layout_set_markup(layout, text, -1);
 185         g_free(text);
 186
 187         pango_layout_get_pixel_size(layout, &width, &height);
 188
 189         width += 10;
 190         height += 10;
 191
 192         pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, width, height);
 193         pixbuf_set_rect_fill(pixbuf, 3, 3, width-6, height-6, 240, 240, 240, 210);
 194         pixbuf_set_rect(pixbuf, 0, 0, width, height, 240, 240, 240, 80, 1, 1, 1, 1);
 195         pixbuf_set_rect(pixbuf, 1, 1, width-2, height-2, 240, 240, 240, 130, 1, 1, 1, 1);
 196         pixbuf_set_rect(pixbuf, 2, 2, width-4, height-4, 240, 240, 240, 180, 1, 1, 1, 1);
 197         pixbuf_pixel_set(pixbuf, 0, 0, 0, 0, 0, 0);
 198         pixbuf_pixel_set(pixbuf, width - 1, 0, 0, 0, 0, 0);
 199         pixbuf_pixel_set(pixbuf, 0, height - 1, 0, 0, 0, 0);
 200         pixbuf_pixel_set(pixbuf, width - 1, height - 1, 0, 0, 0, 0);
 201
 202         pixbuf_draw_layout(pixbuf, layout, imd->pr, 5, 5, 0, 0, 0, 255);
 203
 204         g_object_unref(G_OBJECT(layout));
 205
 206         return pixbuf;
 207 }
 208
 209 static GdkPixbuf *image_osd_icon_pixbuf(ImageOSDFlag flag)
 210 {
 211         static GdkPixbuf **icons = NULL;
 212         GdkPixbuf *icon = NULL;
 213
 214         if (!icons) icons = g_new0(GdkPixbuf *, IMAGE_OSD_COUNT);
 215         if (icons[flag]) return icons[flag];
 216
 217         icon = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, 24, 24);
 218         pixbuf_set_rect_fill(icon, 1, 1, 22, 22, 255, 255, 255, 200);
 219         pixbuf_set_rect(icon, 0, 0, 24, 24, 0, 0, 0, 128, 1, 1, 1, 1);
 220         switch (flag)
 221                 {
 222                 case IMAGE_OSD_COLOR:
 223                         pixbuf_set_rect_fill(icon, 3, 3, 18, 6, 200, 0, 0, 255);
 224                         pixbuf_set_rect_fill(icon, 3, 9, 18, 6, 0, 200, 0, 255);
 225                         pixbuf_set_rect_fill(icon, 3, 15, 18, 6, 0, 0, 200, 255);
 226                         break;
 227                 case IMAGE_OSD_FIRST:
 228                         pixbuf_set_rect(icon, 3, 3, 18, 18, 0, 0, 0, 200, 3, 3, 3, 0);
 229                         pixbuf_draw_triangle(icon, 6, 5, 12, 6,
 230                                              12, 5, 18, 11, 6, 11,
 231                                              0, 0, 0, 255);
 232                         break;
 233                 case IMAGE_OSD_LAST:
 234                         pixbuf_set_rect(icon, 3, 3, 18, 18, 0, 0, 0, 200, 3, 3, 0, 3);
 235                         pixbuf_draw_triangle(icon, 6, 12, 12, 6,
 236                                              12, 18, 6, 12, 18, 12,
 237                                              0, 0, 0, 255);
 238                         break;
 239                 default:
 240                         break;
 241                 }
 242
 243         icons[flag] = icon;
 244
 245         return icon;
 246 }
 247
 248 static void image_osd_icon_show(OverlayStateData *osd, ImageOSDFlag flag)
 249 {
 250         GdkPixbuf *pixbuf;
 251
 252         if (osd->icon_id[flag]) return;
 253
 254         pixbuf = image_osd_icon_pixbuf(flag);
 255         if (!pixbuf) return;
 256
 257         osd->icon_id[flag] = image_overlay_add(osd->imd, pixbuf,
 258                                                osd_icons[flag].x, osd_icons[flag].y,
 259                                                TRUE, FALSE);
 260 }
 261
 262 static void image_osd_icon_hide(OverlayStateData *osd, ImageOSDFlag flag)
 263 {
 264         if (osd->icon_id[flag])
 265                 {
 266                 image_overlay_remove(osd->imd, osd->icon_id[flag]);
 267                 osd->icon_id[flag] = 0;
 268                 }
 269 }
 270
 271 static gint image_osd_update_cb(gpointer data)
 272 {
 273         OverlayStateData *osd = data;
 274
 275         if (osd->show_info)
 276                 {
 277                 if (osd->changed_states & IMAGE_STATE_IMAGE)
 278                         {
 279                         GdkPixbuf *pixbuf;
 280
 281                         pixbuf = image_osd_info_render(osd->imd);
 282                         if (osd->ovl_info == 0)
 283                                 {
 284                                 osd->ovl_info = image_overlay_add(osd->imd, pixbuf,
 285                                                                   OSD_INFO_X, OSD_INFO_Y, TRUE, FALSE);
 286                                 }
 287                         else
 288                                 {
 289                                 image_overlay_set(osd->imd, osd->ovl_info, pixbuf, OSD_INFO_X, OSD_INFO_Y);
 290                                 }
 291                         g_object_unref(pixbuf);
 292                         }
 293                 }
 294         else
 295                 {
 296                 if (osd->ovl_info)
 297                         {
 298                         image_overlay_remove(osd->imd, osd->ovl_info);
 299                         osd->ovl_info = 0;
 300                         }
 301                 }
 302
 303         if (osd->show_status)
 304                 {
 305                 gint i;
 306
 307                 if (osd->changed_states & IMAGE_STATE_IMAGE)
 308                         {
 309                         for (i = 0; i < IMAGE_OSD_COUNT; i++) osd->icon_time[i] = 0;
 310                         }
 311
 312                 if (osd->changed_states & IMAGE_STATE_COLOR_ADJ)
 313                         {
 314                         osd->icon_time[IMAGE_OSD_COLOR] = IMAGE_OSD_DEFAULT_DURATION + 1;
 315                         image_osd_timer_schedule(osd);
 316                         }
 317
 318                 for (i = 0; i < IMAGE_OSD_COUNT; i++)
 319                         {
 320                         if (osd->icon_time[i] > 0)
 321                                 {
 322                                 image_osd_icon_show(osd, i);
 323                                 }
 324                         else
 325                                 {
 326                                 image_osd_icon_hide(osd, i);
 327                                 }
 328                         }
 329                 }
 330         else
 331                 {
 332                 gint i;
 333
 334                 for (i = 0; i < IMAGE_OSD_COUNT; i++)
 335                         {
 336                         image_osd_icon_hide(osd, i);
 337                         }
 338                 }
 339
 340         osd->changed_states = IMAGE_STATE_NONE;
 341         osd->idle_id = -1;
 342         return FALSE;
 343 }
 344
 345 static void image_osd_update_schedule(OverlayStateData *osd, gint force)
 346 {
 347         if (force) osd->changed_states |= IMAGE_STATE_IMAGE;
 348
 349         if (osd->idle_id == -1)
 350                 {
 351                 osd->idle_id = g_idle_add_full(G_PRIORITY_HIGH, image_osd_update_cb, osd, NULL);
 352                 }
 353 }
 354
 355 void image_osd_update(ImageWindow *imd)
 356 {
 357         OverlayStateData *osd;
 358
 359         if (!imd) return;
 360
 361         osd = g_object_get_data(G_OBJECT(imd->pr), "IMAGE_OVERLAY_DATA");
 362         if (!osd) return;
 363
 364         image_osd_update_schedule(osd, TRUE);
 365 }
 366
 367 static gint image_osd_timer_cb(gpointer data)
 368 {
 369         OverlayStateData *osd = data;
 370         gint done = TRUE;
 371         gint changed = FALSE;
 372         gint i;
 373
 374         for (i = 0; i < IMAGE_OSD_COUNT; i++)
 375                 {
 376                 if (osd->icon_time[i] > 1)
 377                         {
 378                         osd->icon_time[i]--;
 379                         if (osd->icon_time[i] < 2)
 380                                 {
 381                                 osd->icon_time[i] = 0;
 382                                 changed = TRUE;
 383                                 }
 384                         else
 385                                 {
 386                                 done = FALSE;
 387                                 }
 388                         }
 389                 }
 390
 391         if (changed) image_osd_update_schedule(osd, FALSE);
 392
 393         if (done)
 394                 {
 395                 osd->timer_id = -1;
 396                 return FALSE;
 397                 }
 398
 399         return TRUE;
 400 }
 401
 402 static void image_osd_timer_schedule(OverlayStateData *osd)
 403 {
 404         if (osd->timer_id == -1)
 405                 {
 406                 osd->timer_id = g_timeout_add(100, image_osd_timer_cb, osd);
 407                 }
 408 }
 409
 410 static void image_osd_state_cb(ImageWindow *imd, ImageState state, gpointer data)
 411 {
 412         OverlayStateData *osd = data;
 413
 414         osd->changed_states |= state;
 415         image_osd_update_schedule(osd, FALSE);
 416 }
 417
 418 static void image_osd_free(OverlayStateData *osd)
 419 {
 420         if (!osd) return;
 421
 422         if (osd->idle_id != -1) g_source_remove(osd->idle_id);
 423         if (osd->timer_id != -1) g_source_remove(osd->timer_id);
 424
 425         if (osd->imd)
 426                 {
 427                 gint i;
 428
 429                 g_object_set_data(G_OBJECT(osd->imd->pr), "IMAGE_OVERLAY_DATA", NULL);
 430                 g_signal_handler_disconnect(osd->imd->pr, osd->destroy_id);
 431
 432                 image_set_state_func(osd->imd, NULL, NULL);
 433                 image_overlay_remove(osd->imd, osd->ovl_info);
 434
 435                 for (i = 0; i < IMAGE_OSD_COUNT; i++)
 436                         {
 437                         image_osd_icon_hide(osd, i);
 438                         }
 439                 }
 440
 441         g_free(osd);
 442 }
 443
 444 static void image_osd_remove(ImageWindow *imd)
 445 {
 446         OverlayStateData *osd;
 447
 448         osd = g_object_get_data(G_OBJECT(imd->pr), "IMAGE_OVERLAY_DATA");
 449         image_osd_free(osd);
 450 }
 451
 452 static void image_osd_destroy_cb(GtkWidget *widget, gpointer data)
 453 {
 454         OverlayStateData *osd = data;
 455
 456         osd->imd = NULL;
 457         image_osd_free(osd);
 458 }
 459
 460 static void image_osd_enable(ImageWindow *imd, gint info, gint status)
 461 {
 462         OverlayStateData *osd;
 463
 464         osd = g_object_get_data(G_OBJECT(imd->pr), "IMAGE_OVERLAY_DATA");
 465         if (!osd)
 466                 {
 467                 osd = g_new0(OverlayStateData, 1);
 468                 osd->imd = imd;
 469                 osd->idle_id = -1;
 470                 osd->timer_id = -1;
 471
 472                 osd->destroy_id = g_signal_connect(G_OBJECT(imd->pr), "destroy",
 473                                                    G_CALLBACK(image_osd_destroy_cb), osd);
 474                 g_object_set_data(G_OBJECT(imd->pr), "IMAGE_OVERLAY_DATA", osd);
 475
 476                 image_set_state_func(osd->imd, image_osd_state_cb, osd);
 477                 }
 478
 479         if (osd->show_info != info ||
 480             osd->show_status != status)
 481                 {
 482                 osd->show_info = info;
 483                 osd->show_status = status;
 484
 485                 image_osd_update_schedule(osd, TRUE);
 486                 }
 487 }
 488
 489 void image_osd_set(ImageWindow *imd, gint info, gint status)
 490 {
 491         if (!imd) return;
 492
 493         if (!info && !status)
 494                 {
 495                 image_osd_remove(imd);
 496                 return;
 497                 }
 498
 499         image_osd_enable(imd, info, status);
 500 }
 501
 502 gint image_osd_get(ImageWindow *imd, gint *info, gint *status)
 503 {
 504         OverlayStateData *osd;
 505
 506         if (!imd) return FALSE;
 507
 508         osd = g_object_get_data(G_OBJECT(imd->pr), "IMAGE_OVERLAY_DATA");
 509         if (!osd) return FALSE;
 510
 511         if (info) *info = osd->show_info;
 512         if (status) *status = osd->show_status;
 513
 514         return TRUE;
 515 }
 516
 517 /* duration:
 518     0 = hide
 519     1 = show
 520    2+ = show for duration tenths of a second
 521    -1 = use default duration
 522  */
 523 void image_osd_icon(ImageWindow *imd, ImageOSDFlag flag, gint duration)
 524 {
 525         OverlayStateData *osd;
 526
 527         if (!imd) return;
 528
 529         osd = g_object_get_data(G_OBJECT(imd->pr), "IMAGE_OVERLAY_DATA");
 530         if (!osd) return;
 531
 532         if (flag < IMAGE_OSD_NONE || flag >= IMAGE_OSD_COUNT) return;
 533         if (duration < 0) duration = IMAGE_OSD_DEFAULT_DURATION;
 534         if (duration > 1) duration += 1;
 535
 536         osd->icon_time[flag] = duration;
 537
 538         image_osd_update_schedule(osd, FALSE);
 539         image_osd_timer_schedule(osd);
 540 }
 541