ROX-Filer/src/pixmaps.c

   1 /*
   2  * $Id$
   3  *
   4  * ROX-Filer, filer for the ROX desktop project
   5  * Copyright (C) 2005, the ROX-Filer team.
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the Free
   9  * Software Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful, but WITHOUT
  13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  15  * more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along with
  18  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  19  * Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 /* pixmaps.c - code for handling pixbufs (despite the name!) */
  23
  24 #include "config.h"
  25 #define PIXMAPS_C
  26
  27 /* Remove pixmaps from the cache when they haven't been accessed for
  28  * this period of time (seconds).
  29  */
  30
  31 #define PIXMAP_PURGE_TIME 1200
  32 #define PIXMAP_THUMB_SIZE  128
  33 #define PIXMAP_THUMB_TOO_OLD_TIME  5
  34
  35 #include <stdlib.h>
  36 #include <stdio.h>
  37 #include <errno.h>
  38 #include <fcntl.h>
  39 #include <sys/types.h>
  40 #include <sys/stat.h>
  41 #include <string.h>
  42
  43 #include <gtk/gtk.h>
  44
  45 #include "global.h"
  46
  47 #include "fscache.h"
  48 #include "support.h"
  49 #include "gui_support.h"
  50 #include "pixmaps.h"
  51 #include "main.h"
  52 #include "filer.h"
  53 #include "dir.h"
  54 #include "diritem.h"
  55 #include "choices.h"
  56 #include "options.h"
  57 #include "action.h"
  58 #include "type.h"
  59
  60 GFSCache *pixmap_cache = NULL;
  61 GFSCache *desktop_icon_cache = NULL;
  62
  63 static const char * bad_xpm[] = {
  64 "12 12 3 1",
  65 "       c #000000000000",
  66 ".      c #FFFF00000000",
  67 "x      c #FFFFFFFFFFFF",
  68 "            ",
  69 " ..xxxxxx.. ",
  70 " ...xxxx... ",
  71 " x...xx...x ",
  72 " xx......xx ",
  73 " xxx....xxx ",
  74 " xxx....xxx ",
  75 " xx......xx ",
  76 " x...xx...x ",
  77 " ...xxxx... ",
  78 " ..xxxxxx.. ",
  79 "            "};
  80
  81 MaskedPixmap *im_error;
  82 MaskedPixmap *im_unknown;
  83 MaskedPixmap *im_symlink;
  84
  85 MaskedPixmap *im_unmounted;
  86 MaskedPixmap *im_mounted;
  87 MaskedPixmap *im_appdir;
  88 MaskedPixmap *im_xattr;
  89
  90 MaskedPixmap *im_dirs;
  91
  92 typedef struct _ChildThumbnail ChildThumbnail;
  93
  94 /* There is one of these for each active child process */
  95 struct _ChildThumbnail {
  96         gchar    *path;
  97         GFunc    callback;
  98         gpointer data;
  99 };
 100
 101 static const char *stocks[] = {
 102         ROX_STOCK_SHOW_DETAILS,
 103         ROX_STOCK_SHOW_HIDDEN,
 104         ROX_STOCK_SELECT,
 105         ROX_STOCK_MOUNT,
 106         ROX_STOCK_MOUNTED,
 107 };
 108
 109 static GtkIconSize mount_icon_size = -1;
 110
 111 /* Static prototypes */
 112
 113 static void load_default_pixmaps(void);
 114 static gint purge(gpointer data);
 115 static MaskedPixmap *image_from_file(const char *path);
 116 static MaskedPixmap *image_from_desktop_file(const char *path);
 117 static MaskedPixmap *get_bad_image(void);
 118 static GdkPixbuf *scale_pixbuf_up(GdkPixbuf *src, int max_w, int max_h);
 119 static GdkPixbuf *get_thumbnail_for(const char *path);
 120 static void thumbnail_child_done(ChildThumbnail *info);
 121 static void child_create_thumbnail(const gchar *path);
 122 static GList *thumbs_purge_cache(Option *option, xmlNode *node, guchar *label);
 123 static gchar *thumbnail_path(const gchar *path);
 124 static gchar *thumbnail_program(MIME_type *type);
 125
 126 /****************************************************************
 127  *                      EXTERNAL INTERFACE                      *
 128  ****************************************************************/
 129
 130 void pixmaps_init(void)
 131 {
 132         GtkIconFactory *factory;
 133         int i;
 134
 135         gtk_widget_push_colormap(gdk_rgb_get_colormap());
 136
 137         pixmap_cache = g_fscache_new((GFSLoadFunc) image_from_file, NULL, NULL);
 138         desktop_icon_cache = g_fscache_new((GFSLoadFunc) image_from_desktop_file, NULL, NULL);
 139
 140         g_timeout_add(10000, purge, NULL);
 141
 142         factory = gtk_icon_factory_new();
 143         for (i = 0; i < G_N_ELEMENTS(stocks); i++)
 144         {
 145                 GdkPixbuf *pixbuf;
 146                 GError *error = NULL;
 147                 gchar *path;
 148                 GtkIconSet *iset;
 149                 const gchar *name = stocks[i];
 150
 151                 path = g_strconcat(app_dir, "/images/", name, ".png", NULL);
 152                 pixbuf = gdk_pixbuf_new_from_file(path, &error);
 153                 if (!pixbuf)
 154                 {
 155                         g_warning("%s", error->message);
 156                         g_error_free(error);
 157                         pixbuf = gdk_pixbuf_new_from_xpm_data(bad_xpm);
 158                 }
 159                 g_free(path);
 160
 161                 iset = gtk_icon_set_new_from_pixbuf(pixbuf);
 162                 g_object_unref(G_OBJECT(pixbuf));
 163                 gtk_icon_factory_add(factory, name, iset);
 164                 gtk_icon_set_unref(iset);
 165         }
 166         gtk_icon_factory_add_default(factory);
 167
 168         mount_icon_size = gtk_icon_size_register("rox-mount-size", 14, 14);
 169
 170         load_default_pixmaps();
 171
 172         option_register_widget("thumbs-purge-cache", thumbs_purge_cache);
 173 }
 174
 175 /* Load image <appdir>/images/name.png.
 176  * Always returns with a valid image.
 177  */
 178 MaskedPixmap *load_pixmap(const char *name)
 179 {
 180         guchar *path;
 181         MaskedPixmap *retval;
 182
 183         path = g_strconcat(app_dir, "/images/", name, ".png", NULL);
 184         retval = image_from_file(path);
 185         g_free(path);
 186
 187         if (!retval)
 188                 retval = get_bad_image();
 189
 190         return retval;
 191 }
 192
 193 /* Create a MaskedPixmap from a GTK stock ID. Always returns
 194  * a valid image.
 195  */
 196 static MaskedPixmap *mp_from_stock(const char *stock_id, int size)
 197 {
 198         GtkIconSet *icon_set;
 199         GdkPixbuf  *pixbuf;
 200         MaskedPixmap *retval;
 201
 202         icon_set = gtk_icon_factory_lookup_default(stock_id);
 203         if (!icon_set)
 204                 return get_bad_image();
 205
 206         pixbuf = gtk_icon_set_render_icon(icon_set,
 207                                      gtk_widget_get_default_style(), /* Gtk bug */
 208                                      GTK_TEXT_DIR_LTR,
 209                                      GTK_STATE_NORMAL,
 210                                      size,
 211                                      NULL,
 212                                      NULL);
 213         retval = masked_pixmap_new(pixbuf);
 214         gdk_pixbuf_unref(pixbuf);
 215
 216         return retval;
 217 }
 218
 219 void pixmap_make_huge(MaskedPixmap *mp)
 220 {
 221         if (mp->huge_pixbuf)
 222                 return;
 223
 224         g_return_if_fail(mp->src_pixbuf != NULL);
 225
 226         /* Limit to small size now, otherwise they get scaled up in mixed mode.
 227          * Also looked ugly.
 228          */
 229         mp->huge_pixbuf = scale_pixbuf_up(mp->src_pixbuf,
 230                                           SMALL_WIDTH, SMALL_HEIGHT);
 231
 232         if (!mp->huge_pixbuf)
 233         {
 234                 mp->huge_pixbuf = mp->src_pixbuf;
 235                 g_object_ref(mp->huge_pixbuf);
 236         }
 237
 238         mp->huge_width = gdk_pixbuf_get_width(mp->huge_pixbuf);
 239         mp->huge_height = gdk_pixbuf_get_height(mp->huge_pixbuf);
 240 }
 241
 242 void pixmap_make_small(MaskedPixmap *mp)
 243 {
 244         if (mp->sm_pixbuf)
 245                 return;
 246
 247         g_return_if_fail(mp->src_pixbuf != NULL);
 248
 249         mp->sm_pixbuf = scale_pixbuf(mp->src_pixbuf, SMALL_WIDTH, SMALL_HEIGHT);
 250
 251         if (!mp->sm_pixbuf)
 252         {
 253                 mp->sm_pixbuf = mp->src_pixbuf;
 254                 g_object_ref(mp->sm_pixbuf);
 255         }
 256
 257         mp->sm_width = gdk_pixbuf_get_width(mp->sm_pixbuf);
 258         mp->sm_height = gdk_pixbuf_get_height(mp->sm_pixbuf);
 259 }
 260
 261 /* Load image 'path' in the background and insert into pixmap_cache.
 262  * Call callback(data, path) when done (path is NULL => error).
 263  * If the image is already uptodate, or being created already, calls the
 264  * callback right away.
 265  */
 266 void pixmap_background_thumb(const gchar *path, GFunc callback, gpointer data)
 267 {
 268         gboolean        found;
 269         MaskedPixmap    *image;
 270         GdkPixbuf       *pixbuf;
 271         pid_t           child;
 272         ChildThumbnail  *info;
 273         MIME_type       *type;
 274         gchar           *thumb_prog;
 275
 276
 277         image = g_fscache_lookup_full(pixmap_cache, path,
 278                                         FSCACHE_LOOKUP_ONLY_NEW, &found);
 279
 280         if (found)
 281         {
 282                 /* Thumbnail is known, or being created */
 283                 if (image)
 284                         g_object_unref(image);
 285                 callback(data, NULL);
 286                 return;
 287         }
 288
 289         g_return_if_fail(image == NULL);
 290
 291         pixbuf = get_thumbnail_for(path);
 292
 293         if (!pixbuf)
 294         {
 295                 struct stat info1, info2;
 296                 char *dir;
 297
 298                 dir = g_path_get_dirname(path);
 299
 300                 /* If the image itself is in ~/.thumbnails, load it now
 301                  * (ie, don't create thumbnails for thumbnails!).
 302                  */
 303                 if (mc_stat(dir, &info1) != 0)
 304                 {
 305                         callback(data, NULL);
 306                         g_free(dir);
 307                         return;
 308                 }
 309                 g_free(dir);
 310
 311                 if (mc_stat(make_path(home_dir, ".thumbnails/normal"),
 312                             &info2) == 0 &&
 313                             info1.st_dev == info2.st_dev &&
 314                             info1.st_ino == info2.st_ino)
 315                 {
 316                         pixbuf = rox_pixbuf_new_from_file_at_scale(path,
 317                                         PIXMAP_THUMB_SIZE, PIXMAP_THUMB_SIZE, TRUE, NULL);
 318                         if (!pixbuf)
 319                         {
 320                                 g_fscache_insert(pixmap_cache,
 321                                                  path, NULL, TRUE);
 322                                 callback(data, NULL);
 323                                 return;
 324                         }
 325                 }
 326         }
 327
 328         if (pixbuf)
 329         {
 330                 MaskedPixmap *image;
 331
 332                 image = masked_pixmap_new(pixbuf);
 333                 gdk_pixbuf_unref(pixbuf);
 334                 g_fscache_insert(pixmap_cache, path, image, TRUE);
 335                 callback(data, (gchar *) path);
 336                 g_object_unref(G_OBJECT(image));
 337                 return;
 338         }
 339
 340         type = type_from_path(path);
 341         if (!type)
 342                 type = text_plain;
 343
 344         /* Add an entry, set to NULL, so no-one else tries to load this
 345          * image.
 346          */
 347         g_fscache_insert(pixmap_cache, path, NULL, TRUE);
 348
 349         thumb_prog = thumbnail_program(type);
 350
 351         /* Only attempt to load 'images' types ourselves */
 352         if (thumb_prog == NULL && strcmp(type->media_type, "image") != 0)
 353         {
 354                 callback(data, NULL);
 355                 return;         /* Don't know how to handle this type */
 356         }
 357
 358         child = fork();
 359
 360         if (child == -1)
 361         {
 362                 g_free(thumb_prog);
 363                 delayed_error("fork(): %s", g_strerror(errno));
 364                 callback(data, NULL);
 365                 return;
 366         }
 367
 368         if (child == 0)
 369         {
 370                 /* We are the child process.  (We are sloppy with freeing
 371                  memory, but since we go away very quickly, that's ok.) */
 372                 if (thumb_prog)
 373                 {
 374                         DirItem *item;
 375
 376                         item = diritem_new(g_basename(thumb_prog));
 377
 378                         diritem_restat(thumb_prog, item, NULL);
 379                         if (item->flags & ITEM_FLAG_APPDIR)
 380                                 thumb_prog = g_strconcat(thumb_prog, "/AppRun",
 381                                                        NULL);
 382
 383                         execl(thumb_prog, thumb_prog, path,
 384                               thumbnail_path(path),
 385                               g_strdup_printf("%d", PIXMAP_THUMB_SIZE),
 386                               NULL);
 387                         _exit(1);
 388                 }
 389
 390                 child_create_thumbnail(path);
 391                 _exit(0);
 392         }
 393
 394         g_free(thumb_prog);
 395
 396         info = g_new(ChildThumbnail, 1);
 397         info->path = g_strdup(path);
 398         info->callback = callback;
 399         info->data = data;
 400         on_child_death(child, (CallbackFn) thumbnail_child_done, info);
 401 }
 402
 403 /****************************************************************
 404  *                      INTERNAL FUNCTIONS                      *
 405  ****************************************************************/
 406
 407 /* Create a thumbnail file for this image */
 408 static void save_thumbnail(const char *pathname, GdkPixbuf *full)
 409 {
 410         struct stat info;
 411         gchar *path;
 412         int original_width, original_height;
 413         GString *to;
 414         char *md5, *swidth, *sheight, *ssize, *smtime, *uri;
 415         mode_t old_mask;
 416         int name_len;
 417         GdkPixbuf *thumb;
 418
 419         thumb = scale_pixbuf(full, PIXMAP_THUMB_SIZE, PIXMAP_THUMB_SIZE);
 420
 421         original_width = gdk_pixbuf_get_width(full);
 422         original_height = gdk_pixbuf_get_height(full);
 423
 424         if (mc_stat(pathname, &info) != 0)
 425                 return;
 426
 427         swidth = g_strdup_printf("%d", original_width);
 428         sheight = g_strdup_printf("%d", original_height);
 429         ssize = g_strdup_printf("%" SIZE_FMT, info.st_size);
 430         smtime = g_strdup_printf("%ld", (long) info.st_mtime);
 431
 432         path = pathdup(pathname);
 433         uri = g_filename_to_uri(path, NULL, NULL);
 434         if (!uri)
 435                 uri = g_strconcat("file://", path, NULL);
 436         md5 = md5_hash(uri);
 437         g_free(path);
 438
 439         to = g_string_new(home_dir);
 440         g_string_append(to, "/.thumbnails");
 441         mkdir(to->str, 0700);
 442         g_string_append(to, "/normal/");
 443         mkdir(to->str, 0700);
 444         g_string_append(to, md5);
 445         name_len = to->len + 4; /* Truncate to this length when renaming */
 446         g_string_append_printf(to, ".png.ROX-Filer-%ld", (long) getpid());
 447
 448         g_free(md5);
 449
 450         old_mask = umask(0077);
 451         gdk_pixbuf_save(thumb, to->str, "png", NULL,
 452                         "tEXt::Thumb::Image::Width", swidth,
 453                         "tEXt::Thumb::Image::Height", sheight,
 454                         "tEXt::Thumb::Size", ssize,
 455                         "tEXt::Thumb::MTime", smtime,
 456                         "tEXt::Thumb::URI", uri,
 457                         "tEXt::Software", PROJECT,
 458                         NULL);
 459         umask(old_mask);
 460
 461         /* We create the file ###.png.ROX-Filer-PID and rename it to avoid
 462          * a race condition if two programs create the same thumb at
 463          * once.
 464          */
 465         {
 466                 gchar *final;
 467
 468                 final = g_strndup(to->str, name_len);
 469                 if (rename(to->str, final))
 470                         g_warning("Failed to rename '%s' to '%s': %s",
 471                                   to->str, final, g_strerror(errno));
 472                 g_free(final);
 473         }
 474
 475         g_string_free(to, TRUE);
 476         g_free(swidth);
 477         g_free(sheight);
 478         g_free(ssize);
 479         g_free(smtime);
 480         g_free(uri);
 481 }
 482
 483 static gchar *thumbnail_path(const char *path)
 484 {
 485         gchar *uri, *md5;
 486         GString *to;
 487         gchar *ans;
 488
 489         uri = g_filename_to_uri(path, NULL, NULL);
 490         if(!uri)
 491                uri = g_strconcat("file://", path, NULL);
 492         md5 = md5_hash(uri);
 493
 494         to = g_string_new(home_dir);
 495         g_string_append(to, "/.thumbnails");
 496         mkdir(to->str, 0700);
 497         g_string_append(to, "/normal/");
 498         mkdir(to->str, 0700);
 499         g_string_append(to, md5);
 500         g_string_append(to, ".png");
 501
 502         g_free(md5);
 503         g_free(uri);
 504
 505         ans=to->str;
 506         g_string_free(to, FALSE);
 507
 508         return ans;
 509 }
 510
 511 /* Return a program to create thumbnails for files of this type.
 512  * NULL to try to make it ourself (using gdk).
 513  * g_free the result.
 514  */
 515 static gchar *thumbnail_program(MIME_type *type)
 516 {
 517         gchar *leaf;
 518         gchar *path;
 519
 520         if (!type)
 521                 return NULL;
 522
 523         leaf = g_strconcat(type->media_type, "_", type->subtype, NULL);
 524         path = choices_find_xdg_path_load(leaf, "MIME-thumb", SITE);
 525         g_free(leaf);
 526         if (path)
 527         {
 528                 return path;
 529         }
 530
 531         path = choices_find_xdg_path_load(type->media_type, "MIME-thumb",
 532                                           SITE);
 533
 534         return path;
 535 }
 536
 537 /* Called in a subprocess. Load path and create the thumbnail
 538  * file. Parent will notice when we die.
 539  */
 540 static void child_create_thumbnail(const gchar *path)
 541 {
 542         GdkPixbuf *image;
 543
 544         image = rox_pixbuf_new_from_file_at_scale(path,
 545                         PIXMAP_THUMB_SIZE, PIXMAP_THUMB_SIZE, TRUE, NULL);
 546
 547         if (image)
 548                 save_thumbnail(path, image);
 549
 550         /* (no need to unref, as we're about to exit) */
 551 }
 552
 553 /* Called when the child process exits */
 554 static void thumbnail_child_done(ChildThumbnail *info)
 555 {
 556         GdkPixbuf *thumb;
 557
 558         thumb = get_thumbnail_for(info->path);
 559
 560         if (thumb)
 561         {
 562                 MaskedPixmap *image;
 563
 564                 image = masked_pixmap_new(thumb);
 565                 g_object_unref(thumb);
 566
 567                 g_fscache_insert(pixmap_cache, info->path, image, FALSE);
 568                 g_object_unref(image);
 569
 570                 info->callback(info->data, info->path);
 571         }
 572         else
 573                 info->callback(info->data, NULL);
 574
 575         g_free(info->path);
 576         g_free(info);
 577 }
 578
 579 /* Check if we have an up-to-date thumbnail for this image.
 580  * If so, return it. Otherwise, returns NULL.
 581  */
 582 static GdkPixbuf *get_thumbnail_for(const char *pathname)
 583 {
 584         GdkPixbuf *thumb = NULL;
 585         char *thumb_path, *md5, *uri, *path;
 586         const char *ssize, *smtime;
 587         struct stat info;
 588         time_t ttime, now;
 589
 590         path = pathdup(pathname);
 591         uri = g_filename_to_uri(path, NULL, NULL);
 592         if(!uri)
 593                 uri = g_strconcat("file://", path, NULL);
 594         md5 = md5_hash(uri);
 595         g_free(uri);
 596
 597         thumb_path = g_strdup_printf("%s/.thumbnails/normal/%s.png",
 598                                         home_dir, md5);
 599         g_free(md5);
 600
 601         thumb = gdk_pixbuf_new_from_file(thumb_path, NULL);
 602         if (!thumb)
 603                 goto err;
 604
 605         /* Note that these don't need freeing... */
 606         ssize = gdk_pixbuf_get_option(thumb, "tEXt::Thumb::Size");
 607         if (!ssize)
 608                 goto err;
 609
 610         smtime = gdk_pixbuf_get_option(thumb, "tEXt::Thumb::MTime");
 611         if (!smtime)
 612                 goto err;
 613
 614         if (mc_stat(path, &info) != 0)
 615                 goto err;
 616
 617         ttime=(time_t) atol(smtime);
 618         time(&now);
 619         if (info.st_mtime != ttime && now>ttime+PIXMAP_THUMB_TOO_OLD_TIME)
 620                 goto err;
 621
 622         if (info.st_size < atol(ssize))
 623                 goto err;
 624
 625         goto out;
 626 err:
 627         if (thumb)
 628                 gdk_pixbuf_unref(thumb);
 629         thumb = NULL;
 630 out:
 631         g_free(path);
 632         g_free(thumb_path);
 633         return thumb;
 634 }
 635
 636 /* Load the image 'path' and return a pointer to the resulting
 637  * MaskedPixmap. NULL on failure.
 638  * Doesn't check for thumbnails (this is for small icons).
 639  */
 640 static MaskedPixmap *image_from_file(const char *path)
 641 {
 642         GdkPixbuf       *pixbuf;
 643         MaskedPixmap    *image;
 644         GError          *error = NULL;
 645
 646         pixbuf = gdk_pixbuf_new_from_file(path, &error);
 647         if (!pixbuf)
 648         {
 649                 g_warning("%s\n", error->message);
 650                 g_error_free(error);
 651                 return NULL;
 652         }
 653
 654         image = masked_pixmap_new(pixbuf);
 655
 656         gdk_pixbuf_unref(pixbuf);
 657
 658         return image;
 659 }
 660
 661 /* Load this icon named by this .desktop file from the current theme.
 662  * NULL on failure.
 663  */
 664 static MaskedPixmap *image_from_desktop_file(const char *path)
 665 {
 666         GError *error = NULL;
 667         MaskedPixmap *image = NULL;
 668         char *icon = NULL;
 669
 670         icon = get_value_from_desktop_file(path,
 671                                         "Desktop Entry", "Icon", &error);
 672         if (error)
 673         {
 674                 g_warning("Failed to parse .desktop file '%s':\n%s",
 675                                 path, error->message);
 676                 goto err;
 677         }
 678         if (!icon)
 679                 goto err;
 680
 681         if (icon[0] == '/')
 682                 image = image_from_file(icon);
 683         else
 684         {
 685                 GdkPixbuf *pixbuf;
 686                 int tmp_fd;
 687
 688                 /* SVG reader is very noisy, so redirect stderr to stdout */
 689                 tmp_fd = dup(2);
 690                 dup2(1, 2);
 691                 pixbuf = gtk_icon_theme_load_icon(icon_theme, icon, HUGE_WIDTH,
 692                                                         0, NULL);
 693                 dup2(tmp_fd, 2);
 694                 close(tmp_fd);
 695
 696                 if (pixbuf == NULL)
 697                         goto err;       /* Might just not be in the theme */
 698
 699                 image = masked_pixmap_new(pixbuf);
 700                 g_object_unref(pixbuf);
 701         }
 702 err:
 703         if (error != NULL)
 704                 g_error_free(error);
 705         if (icon != NULL)
 706                 g_free(icon);
 707         return image;
 708 }
 709
 710 /* Scale src down to fit in max_w, max_h and return the new pixbuf.
 711  * If src is small enough, then ref it and return that.
 712  */
 713 GdkPixbuf *scale_pixbuf(GdkPixbuf *src, int max_w, int max_h)
 714 {
 715         int     w, h;
 716
 717         w = gdk_pixbuf_get_width(src);
 718         h = gdk_pixbuf_get_height(src);
 719
 720         if (w <= max_w && h <= max_h)
 721         {
 722                 gdk_pixbuf_ref(src);
 723                 return src;
 724         }
 725         else
 726         {
 727                 float scale_x = ((float) w) / max_w;
 728                 float scale_y = ((float) h) / max_h;
 729                 float scale = MAX(scale_x, scale_y);
 730                 int dest_w = w / scale;
 731                 int dest_h = h / scale;
 732
 733                 return gdk_pixbuf_scale_simple(src,
 734                                                 MAX(dest_w, 1),
 735                                                 MAX(dest_h, 1),
 736                                                 GDK_INTERP_BILINEAR);
 737         }
 738 }
 739
 740 /* Scale src up to fit in max_w, max_h and return the new pixbuf.
 741  * If src is that size or bigger, then ref it and return that.
 742  */
 743 static GdkPixbuf *scale_pixbuf_up(GdkPixbuf *src, int max_w, int max_h)
 744 {
 745         int     w, h;
 746
 747         w = gdk_pixbuf_get_width(src);
 748         h = gdk_pixbuf_get_height(src);
 749
 750         if (w == 0 || h == 0 || w >= max_w || h >= max_h)
 751         {
 752                 gdk_pixbuf_ref(src);
 753                 return src;
 754         }
 755         else
 756         {
 757                 float scale_x = max_w / ((float) w);
 758                 float scale_y = max_h / ((float) h);
 759                 float scale = MIN(scale_x, scale_y);
 760
 761                 return gdk_pixbuf_scale_simple(src,
 762                                                 w * scale,
 763                                                 h * scale,
 764                                                 GDK_INTERP_BILINEAR);
 765         }
 766 }
 767
 768 /* Return a pointer to the (static) bad image. The ref counter will ensure
 769  * that the image is never freed.
 770  */
 771 static MaskedPixmap *get_bad_image(void)
 772 {
 773         GdkPixbuf *bad;
 774         MaskedPixmap *mp;
 775
 776         bad = gdk_pixbuf_new_from_xpm_data(bad_xpm);
 777         mp = masked_pixmap_new(bad);
 778         gdk_pixbuf_unref(bad);
 779
 780         return mp;
 781 }
 782
 783 /* Called now and then to clear out old pixmaps */
 784 static gint purge(gpointer data)
 785 {
 786         g_fscache_purge(pixmap_cache, PIXMAP_PURGE_TIME);
 787
 788         return TRUE;
 789 }
 790
 791 static gpointer parent_class;
 792
 793 static void masked_pixmap_finialize(GObject *object)
 794 {
 795         MaskedPixmap *mp = (MaskedPixmap *) object;
 796
 797         if (mp->src_pixbuf)
 798         {
 799                 g_object_unref(mp->src_pixbuf);
 800                 mp->src_pixbuf = NULL;
 801         }
 802
 803         if (mp->huge_pixbuf)
 804         {
 805                 g_object_unref(mp->huge_pixbuf);
 806                 mp->huge_pixbuf = NULL;
 807         }
 808         if (mp->pixbuf)
 809         {
 810                 g_object_unref(mp->pixbuf);
 811                 mp->pixbuf = NULL;
 812         }
 813
 814         if (mp->sm_pixbuf)
 815         {
 816                 g_object_unref(mp->sm_pixbuf);
 817                 mp->sm_pixbuf = NULL;
 818         }
 819
 820         G_OBJECT_CLASS(parent_class)->finalize(object);
 821 }
 822
 823 static void masked_pixmap_class_init(gpointer gclass, gpointer data)
 824 {
 825         GObjectClass *object = (GObjectClass *) gclass;
 826
 827         parent_class = g_type_class_peek_parent(gclass);
 828
 829         object->finalize = masked_pixmap_finialize;
 830 }
 831
 832 static void masked_pixmap_init(GTypeInstance *object, gpointer gclass)
 833 {
 834         MaskedPixmap *mp = (MaskedPixmap *) object;
 835
 836         mp->src_pixbuf = NULL;
 837
 838         mp->huge_pixbuf = NULL;
 839         mp->huge_width = -1;
 840         mp->huge_height = -1;
 841
 842         mp->pixbuf = NULL;
 843         mp->width = -1;
 844         mp->height = -1;
 845
 846         mp->sm_pixbuf = NULL;
 847         mp->sm_width = -1;
 848         mp->sm_height = -1;
 849 }
 850
 851 static GType masked_pixmap_get_type(void)
 852 {
 853         static GType type = 0;
 854
 855         if (!type)
 856         {
 857                 static const GTypeInfo info =
 858                 {
 859                         sizeof (MaskedPixmapClass),
 860                         NULL,                   /* base_init */
 861                         NULL,                   /* base_finalise */
 862                         masked_pixmap_class_init,
 863                         NULL,                   /* class_finalise */
 864                         NULL,                   /* class_data */
 865                         sizeof(MaskedPixmap),
 866                         0,                      /* n_preallocs */
 867                         masked_pixmap_init
 868                 };
 869
 870                 type = g_type_register_static(G_TYPE_OBJECT, "MaskedPixmap",
 871                                               &info, 0);
 872         }
 873
 874         return type;
 875 }
 876
 877 MaskedPixmap *masked_pixmap_new(GdkPixbuf *full_size)
 878 {
 879         MaskedPixmap *mp;
 880         GdkPixbuf       *src_pixbuf, *normal_pixbuf;
 881
 882         g_return_val_if_fail(full_size != NULL, NULL);
 883
 884         src_pixbuf = scale_pixbuf(full_size, HUGE_WIDTH, HUGE_HEIGHT);
 885         g_return_val_if_fail(src_pixbuf != NULL, NULL);
 886
 887         normal_pixbuf = scale_pixbuf(src_pixbuf, ICON_WIDTH, ICON_HEIGHT);
 888         g_return_val_if_fail(normal_pixbuf != NULL, NULL);
 889
 890         mp = g_object_new(masked_pixmap_get_type(), NULL);
 891
 892         mp->src_pixbuf = src_pixbuf;
 893
 894         mp->pixbuf = normal_pixbuf;
 895         mp->width = gdk_pixbuf_get_width(normal_pixbuf);
 896         mp->height = gdk_pixbuf_get_height(normal_pixbuf);
 897
 898         return mp;
 899 }
 900
 901 /* Load all the standard pixmaps. Also sets the default window icon. */
 902 static void load_default_pixmaps(void)
 903 {
 904         GdkPixbuf *pixbuf;
 905         GError *error = NULL;
 906
 907         im_error = mp_from_stock(GTK_STOCK_DIALOG_WARNING,
 908                                  GTK_ICON_SIZE_DIALOG);
 909         im_unknown = mp_from_stock(GTK_STOCK_DIALOG_QUESTION,
 910                                    GTK_ICON_SIZE_DIALOG);
 911         im_symlink = load_pixmap("symlink");
 912
 913         im_unmounted = mp_from_stock(ROX_STOCK_MOUNT, mount_icon_size);
 914         im_mounted = mp_from_stock(ROX_STOCK_MOUNTED, mount_icon_size);
 915         im_appdir = load_pixmap("application");
 916         im_xattr = load_pixmap("rox-xattr");
 917
 918         im_dirs = load_pixmap("dirs");
 919
 920         pixbuf = gdk_pixbuf_new_from_file(
 921                         make_path(app_dir, ".DirIcon"), &error);
 922         if (pixbuf)
 923         {
 924                 GList *icon_list;
 925
 926                 icon_list = g_list_append(NULL, pixbuf);
 927                 gtk_window_set_default_icon_list(icon_list);
 928                 g_list_free(icon_list);
 929
 930                 g_object_unref(G_OBJECT(pixbuf));
 931         }
 932         else
 933         {
 934                 g_warning("%s\n", error->message);
 935                 g_error_free(error);
 936         }
 937 }
 938
 939 /* Also purges memory cache */
 940 static void purge_disk_cache(GtkWidget *button, gpointer data)
 941 {
 942         char *path;
 943         GList *list = NULL;
 944         DIR *dir;
 945         struct dirent *ent;
 946
 947         g_fscache_purge(pixmap_cache, 0);
 948
 949         path = g_strconcat(home_dir, "/.thumbnails/normal/", NULL);
 950
 951         dir = opendir(path);
 952         if (!dir)
 953         {
 954                 report_error(_("Can't delete thumbnails in %s:\n%s"),
 955                                 path, g_strerror(errno));
 956                 goto out;
 957         }
 958
 959         while ((ent = readdir(dir)))
 960         {
 961                 if (ent->d_name[0] == '.')
 962                         continue;
 963                 list = g_list_prepend(list,
 964                                       g_strconcat(path, ent->d_name, NULL));
 965         }
 966
 967         closedir(dir);
 968
 969         if (list)
 970         {
 971                 action_delete(list);
 972                 destroy_glist(&list);
 973         }
 974         else
 975                 info_message(_("There are no thumbnails to delete"));
 976 out:
 977         g_free(path);
 978 }
 979
 980 static GList *thumbs_purge_cache(Option *option, xmlNode *node, guchar *label)
 981 {
 982         GtkWidget *button, *align;
 983
 984         g_return_val_if_fail(option == NULL, NULL);
 985
 986         align = gtk_alignment_new(0, 0.5, 0, 0);
 987         button = button_new_mixed(GTK_STOCK_CLEAR,
 988                                   _("Purge thumbnails disk cache"));
 989         gtk_container_add(GTK_CONTAINER(align), button);
 990         g_signal_connect(button, "clicked", G_CALLBACK(purge_disk_cache), NULL);
 991
 992         return g_list_append(NULL, align);
 993 }