ROX-Filer/src/usericons.c

   1 /*
   2  * ROX-Filer, filer for the ROX desktop project
   3  * Copyright (C) 2006, Thomas Leonard and others (see changelog for details).
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License as published by the Free
   7  * Software Foundation; either version 2 of the License, or (at your option)
   8  * any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13  * more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along with
  16  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  17  * Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19
  20 /* usericons.c - handle user-defined icons. Diego Zamboni, Feb 7, 2001. */
  21
  22 #include "config.h"
  23
  24 #include <gtk/gtk.h>
  25 #include <errno.h>
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <unistd.h>
  29 #include <fnmatch.h>
  30 #include <libxml/parser.h>
  31 #include <time.h>
  32
  33 #include "global.h"
  34
  35 #include "fscache.h"
  36 #include "diritem.h"
  37 #include "dir.h"
  38 #include "gui_support.h"
  39 #include "choices.h"
  40 #include "pixmaps.h"
  41 #include "type.h"
  42 #include "run.h"
  43 #include "dnd.h"
  44 #include "support.h"
  45 #include "usericons.h"
  46 #include "main.h"
  47 #include "menu.h"
  48 #include "filer.h"
  49 #include "action.h"
  50 #include "display.h"
  51 #include "xml.h"
  52 #include "dropbox.h"
  53
  54 #define SET_MEDIA 2
  55 #define SET_TYPE 1
  56 #define SET_PATH 0              /* Store in globicons */
  57 #define SET_COPY 3              /* Create .DirIcon */
  58
  59 static GHashTable *glob_icons = NULL; /* Pathname -> Icon pathname */
  60
  61 /* Static prototypes */
  62 static const char *process_globicons_line(gchar *line);
  63 static gboolean free_globicon(gpointer key, gpointer value, gpointer data);
  64 static void write_globicons(void);
  65 static void drag_icon_dropped(GtkWidget *drop_box,
  66                                   const guchar  *path,
  67                                   GtkWidget     *dialog);
  68 static gboolean set_icon_for_type(MIME_type *type, const gchar *iconpath,
  69                                   gboolean just_media);
  70 static gboolean convert_to_png(const gchar *src, const gchar *dest);
  71 static void radios_changed(Radios *radios, gpointer data);
  72
  73 /****************************************************************
  74  *                      EXTERNAL INTERFACE                      *
  75  ****************************************************************/
  76
  77 /* Read glob-pattern -> icon mappings from "globicons" in Choices */
  78 void read_globicons()
  79 {
  80         static time_t last_read = (time_t) 0;
  81         struct stat info;
  82         guchar *path;
  83         xmlDocPtr doc;
  84
  85         if (!glob_icons)
  86                 glob_icons = g_hash_table_new(g_str_hash, g_str_equal);
  87
  88         path = choices_find_xdg_path_load("globicons", PROJECT, SITE);
  89         if (!path)
  90                 return; /* Nothing to load */
  91
  92         if (mc_stat(path, &info))
  93                 goto out;
  94
  95         if (info.st_mtime <= last_read)
  96                 goto out;  /* File hasn't been modified since we last read it */
  97
  98         g_hash_table_foreach_remove(glob_icons, free_globicon, NULL);
  99
 100         doc = xmlParseFile(path);
 101         if (doc)
 102         {
 103                 xmlNodePtr node, icon, root;
 104                 char       *match;
 105
 106                 root = xmlDocGetRootElement(doc);
 107
 108                 /* Handle the new XML file format */
 109                 for (node = root->xmlChildrenNode; node; node = node->next)
 110                 {
 111                         gchar *path, *icon_path;
 112
 113                         if (node->type != XML_ELEMENT_NODE)
 114                                 continue;
 115                         if (strcmp(node->name, "rule") != 0)
 116                                 continue;
 117                         icon = get_subnode(node, NULL, "icon");
 118                         if (!icon)
 119                                 continue;
 120                         match = xmlGetProp(node, "match");
 121                         if (!match)
 122                                 continue;
 123
 124                         icon_path = xmlNodeGetContent(icon);
 125                         path = expand_path(match);
 126                         g_hash_table_insert(glob_icons, path, icon_path);
 127                         g_free(match);
 128                 }
 129
 130                 xmlFreeDoc(doc);
 131         }
 132         else
 133         {
 134                 /* Handle the old non-XML format */
 135                 parse_file(path, process_globicons_line);
 136                 if (g_hash_table_size(glob_icons))
 137                         write_globicons();      /* Upgrade to new format */
 138         }
 139
 140         last_read = time(NULL);   /* Update time stamp */
 141 out:
 142         g_free(path);
 143 }
 144
 145 /* Set an item's image field according to the globicons patterns if
 146  * it matches one of them and the file exists.
 147  */
 148 void check_globicon(const guchar *path, DirItem *item)
 149 {
 150         gchar *gi;
 151
 152         g_return_if_fail(item && !item->_image);
 153
 154         gi = g_hash_table_lookup(glob_icons, path);
 155         if (gi)
 156                 item->_image = g_fscache_lookup(pixmap_cache, gi);
 157 }
 158
 159 static gboolean create_diricon(const guchar *filepath, const guchar *iconpath)
 160 {
 161         if (!convert_to_png(iconpath, make_path(filepath, ".DirIcon")))
 162                 return FALSE;
 163
 164         dir_check_this(filepath);
 165         icons_may_update(filepath);
 166
 167         return TRUE;
 168 }
 169
 170 /* Add a globicon mapping for the given file to the given icon path */
 171 static gboolean set_icon_path(const guchar *filepath, const guchar *iconpath)
 172 {
 173         MaskedPixmap *pic;
 174
 175         /* Check if file exists */
 176         if (!file_exists(iconpath))
 177         {
 178                 delayed_error(_("The pathname you gave does not exist. "
 179                                     "The icon has not been changed."));
 180                 return FALSE;
 181         }
 182
 183         /* Check if we can load the image, warn the user if not. */
 184         pic = g_fscache_lookup(pixmap_cache, iconpath);
 185         if (!pic)
 186         {
 187                 delayed_error(
 188                         _("Unable to load image file -- maybe it's not in a "
 189                           "format I understand, or maybe the permissions are "
 190                           "wrong?\n"
 191                           "The icon has not been changed."));
 192                 return FALSE;
 193         }
 194         g_object_unref(pic);
 195
 196         /* Add the globicon mapping and update visible icons */
 197         add_globicon(filepath, iconpath);
 198
 199         return TRUE;
 200 }
 201
 202 static void dialog_response(GtkWidget *dialog, gint response, gpointer data)
 203 {
 204         gtk_widget_destroy(dialog);
 205 }
 206
 207 static void clear_icon(DropBox *drop_box, GObject *dialog)
 208 {
 209         Radios *radios;
 210         const guchar *pathname;
 211
 212         pathname = g_object_get_data(G_OBJECT(dialog), "pathname");
 213         g_return_if_fail(pathname != NULL);
 214
 215         radios = g_object_get_data(G_OBJECT(dialog), "radios");
 216         g_return_if_fail(radios != NULL);
 217
 218         if (radios_get_value(radios) == SET_PATH)
 219         {
 220                 delete_globicon(pathname);
 221         }
 222         else
 223         {
 224                 const guchar *path;
 225                 guchar *tmp;
 226                 DropBox *drop_box;
 227
 228                 drop_box = g_object_get_data(G_OBJECT(dialog), "rox-dropbox");
 229                 g_return_if_fail(drop_box != NULL);
 230
 231                 path = drop_box_get_path(drop_box);
 232                 g_return_if_fail(path != NULL);
 233
 234                 tmp = g_strdup_printf(_("Really delete icon '%s'?"), path);
 235                 if (confirm(tmp, GTK_STOCK_DELETE, NULL))
 236                 {
 237                         if (unlink(path))
 238                                 delayed_error(_("Can't delete '%s':\n%s"),
 239                                                 path, g_strerror(errno));
 240                         else
 241                         {
 242                                 dir_check_this(pathname);
 243                                 icons_may_update(pathname);
 244                         }
 245                 }
 246                 g_free(tmp);
 247         }
 248
 249         full_refresh();
 250         radios_changed(g_object_get_data(dialog, "radios"), dialog);
 251 }
 252
 253 /* Display a dialog box allowing the user to set the icon for
 254  * a file or directory.
 255  */
 256 void icon_set_handler_dialog(DirItem *item, const guchar *path)
 257 {
 258         struct stat     info;
 259         GtkDialog       *dialog;
 260         GtkWidget       *frame;
 261         Radios          *radios;
 262
 263         g_return_if_fail(item != NULL && path != NULL);
 264
 265         dialog = GTK_DIALOG(gtk_dialog_new());
 266         gtk_dialog_set_has_separator(dialog, FALSE);
 267         gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_MOUSE);
 268         g_object_set_data_full(G_OBJECT(dialog), "pathname",
 269                                  strdup(path), g_free);
 270
 271         gtk_window_set_title(GTK_WINDOW(dialog), _("Set icon"));
 272
 273         radios = radios_new(radios_changed, dialog);
 274
 275         g_object_set_data(G_OBJECT(dialog), "radios", radios);
 276         g_object_set_data(G_OBJECT(dialog), "mime-type", item->mime_type);
 277
 278 #if 0
 279         radios_add(radios,
 280                         _("Use a copy of the image as the default for all "
 281                           "files of these MIME types."), SET_MEDIA,
 282                         _("Set icon for all `%s/<anything>'"),
 283                         item->mime_type->media_type);
 284 #endif
 285
 286         radios_add(radios,
 287                         _("Use a copy of the image for all files of this MIME "
 288                           "type."), SET_TYPE,
 289                         _("For all files of type `%s' (%s/%s)"),
 290                         mime_type_comment(item->mime_type),
 291                         item->mime_type->media_type,
 292                         item->mime_type->subtype);
 293
 294         radios_add(radios,
 295                         _("Add the file and image filenames to your "
 296                         "personal list. The setting will be lost if the image "
 297                         "or the file is moved."), SET_PATH,
 298                         _("Only for the file `%s'"), path);
 299
 300         radios_set_value(radios, SET_PATH);
 301
 302         /* If it's a directory, offer to create a .DirIcon */
 303         if (mc_stat(path, &info) == 0 && S_ISDIR(info.st_mode))
 304         {
 305                 radios_add(radios,
 306                         _("Copy the image inside the directory, as "
 307                         "a hidden file called '.DirIcon'. "
 308                         "All users will then see the "
 309                         "icon, and you can move the directory around safely. "
 310                         "This is usually the best option if you can write to "
 311                         "the directory."), SET_COPY,
 312                         _("Copy image into directory"));
 313                 if (access(path, W_OK) == 0)
 314                         radios_set_value(radios, SET_COPY);
 315         }
 316
 317
 318         frame = drop_box_new(_("Drop an icon file here"));
 319         g_object_set_data(G_OBJECT(dialog), "rox-dropbox", frame);
 320
 321         /* Make sure rox-dropbox is set before packing (calls changed) */
 322         radios_pack(radios, GTK_BOX(dialog->vbox));
 323         gtk_box_pack_start(GTK_BOX(dialog->vbox), frame, TRUE, TRUE, 4);
 324
 325         g_signal_connect(frame, "path_dropped",
 326                         G_CALLBACK(drag_icon_dropped), dialog);
 327         g_signal_connect(frame, "clear",
 328                         G_CALLBACK(clear_icon), dialog);
 329
 330         gtk_dialog_add_buttons(dialog,
 331                         GTK_STOCK_CLOSE, GTK_RESPONSE_OK,
 332                         NULL);
 333         g_signal_connect(dialog, "response", G_CALLBACK(dialog_response), NULL);
 334         gtk_dialog_set_default_response(dialog, GTK_RESPONSE_OK);
 335
 336         gtk_widget_show_all(GTK_WIDGET(dialog));
 337 }
 338
 339
 340 /****************************************************************
 341  *                      INTERNAL FUNCTIONS                      *
 342  ****************************************************************/
 343
 344 /* The dropbox shows the path for the currently selected radio setting.
 345  */
 346 static void radios_changed(Radios *radios, gpointer data)
 347 {
 348         GObject *dialog = G_OBJECT(data);
 349         DropBox *drop_box;
 350         const guchar *path;
 351         MIME_type *mime_type;
 352
 353         path = g_object_get_data(dialog, "pathname");
 354         drop_box = g_object_get_data(dialog, "rox-dropbox");
 355         mime_type = g_object_get_data(dialog, "mime-type");
 356
 357         g_return_if_fail(radios != NULL);
 358         g_return_if_fail(path != NULL);
 359         g_return_if_fail(drop_box != NULL);
 360         g_return_if_fail(mime_type != NULL);
 361
 362         switch (radios_get_value(radios))
 363         {
 364                 case SET_MEDIA:
 365                 {
 366                         char *path, *type;
 367
 368                         type = g_strconcat(mime_type->media_type, ".png", NULL);
 369                         path = choices_find_xdg_path_load(type, "MIME-icons",
 370                                                           SITE);
 371                         g_free(type);
 372                         drop_box_set_path(drop_box, path);
 373                         g_free(path);
 374                         break;
 375                 }
 376                 case SET_TYPE:
 377                 {
 378                         char *path, *type;
 379
 380                         type = g_strconcat(mime_type->media_type, "_",
 381                                            mime_type->subtype, ".png", NULL);
 382                         path = choices_find_xdg_path_load(type, "MIME-icons",
 383                                                           SITE);
 384                         g_free(type);
 385                         drop_box_set_path(drop_box, path);
 386                         g_free(path);
 387                         break;
 388                 }
 389                 case SET_PATH:
 390                 {
 391                         const char      *gi;
 392                         gi = g_hash_table_lookup(glob_icons, path);
 393                         drop_box_set_path(drop_box, gi);
 394                         break;
 395                 }
 396                 case SET_COPY:
 397                 {
 398                         const char *diricon;
 399                         diricon = make_path(path, ".DirIcon");
 400                         if (file_exists(diricon))
 401                                 drop_box_set_path(drop_box, diricon);
 402                         else
 403                                 drop_box_set_path(drop_box, NULL);
 404                         break;
 405                 }
 406                 default:
 407                         drop_box_set_path(drop_box, NULL);
 408                         break;
 409         }
 410 }
 411
 412 static gboolean free_globicon(gpointer key, gpointer value, gpointer data)
 413 {
 414         g_free(key);
 415         g_free(value);
 416
 417         return TRUE;            /* For g_hash_table_foreach_remove() */
 418 }
 419
 420 static void write_globicon(gpointer key, gpointer value, gpointer data)
 421 {
 422         xmlNodePtr doc = (xmlNodePtr) data;
 423         xmlNodePtr tree;
 424
 425         tree = xmlNewTextChild(doc, NULL, "rule", NULL);
 426         xmlSetProp(tree, "match", key);
 427         xmlNewTextChild(tree, NULL, "icon", value);
 428 }
 429
 430 /* Write globicons file */
 431 static void write_globicons(void)
 432 {
 433         gchar *save = NULL, *save_new = NULL;
 434         xmlDocPtr doc = NULL;
 435
 436         save = choices_find_xdg_path_save("globicons", PROJECT, SITE, TRUE);
 437
 438         if (!save)
 439                 return;         /* Saving is disabled */
 440
 441         save_new = g_strconcat(save, ".new", NULL);
 442
 443         doc = xmlNewDoc("1.0");
 444         xmlDocSetRootElement(doc,
 445                              xmlNewDocNode(doc, NULL, "special-files", NULL));
 446
 447         g_hash_table_foreach(glob_icons, write_globicon,
 448                              xmlDocGetRootElement(doc));
 449
 450         if (save_xml_file(doc, save_new) || rename(save_new, save))
 451                 delayed_error(_("Error saving %s: %s"),
 452                                 save, g_strerror(errno));
 453
 454         g_free(save_new);
 455         g_free(save);
 456
 457         if (doc)
 458                 xmlFreeDoc(doc);
 459 }
 460
 461 /* Process a globicon line. Format:
 462         glob-pattern    icon-path
 463    Example:
 464        /home/<*>/Mail   /usr/local/icons/mailbox.xpm
 465          (<*> represents a single asterisk, enclosed in brackets to not break
 466          the C comment).
 467 */
 468 static const char *process_globicons_line(gchar *line)
 469 {
 470         guchar *pattern, *iconpath;
 471
 472         pattern = strtok(line, " \t");
 473         /* We ignore empty lines, but they are no cause for a message */
 474         if (pattern == NULL)
 475                 return NULL;
 476
 477         iconpath = strtok(NULL, " \t");
 478
 479         /* If there is no icon, then we worry */
 480         g_return_val_if_fail(iconpath != NULL,
 481                         "Invalid line in globicons: no icon specified");
 482
 483         g_hash_table_insert(glob_icons, g_strdup(pattern), g_strdup(iconpath));
 484
 485         return NULL;
 486 }
 487
 488 /* Add a globicon entry to the list. If another one with the same
 489  * path exists, it is replaced. Otherwise, the new entry is
 490  * added to the top of the list (so that it takes precedence over
 491  * other entries).
 492  */
 493 void add_globicon(const gchar *path, const gchar *icon)
 494 {
 495         g_hash_table_insert(glob_icons, g_strdup(path), g_strdup(icon));
 496
 497         /* Rewrite the globicons file */
 498         write_globicons();
 499
 500         /* Make sure any visible icons for the file are updated */
 501         examine(path);
 502 }
 503
 504 /* Remove the globicon for a certain path */
 505 void delete_globicon(const gchar *path)
 506 {
 507         gpointer key, value;
 508
 509         if (!g_hash_table_lookup_extended(glob_icons, path, &key, &value))
 510                 return;
 511
 512         g_hash_table_remove(glob_icons, path);
 513
 514         g_free(key);
 515         g_free(value);
 516
 517         write_globicons();
 518         examine(path);
 519 }
 520
 521 /* Set the icon for this dialog's file to 'icon' */
 522 static void do_set_icon(GtkWidget *dialog, const gchar *icon)
 523 {
 524         guchar  *path = NULL;
 525         Radios *radios;
 526         int op;
 527
 528         path = g_object_get_data(G_OBJECT(dialog), "pathname");
 529         g_return_if_fail(path != NULL);
 530
 531         radios = g_object_get_data(G_OBJECT(dialog), "radios");
 532         g_return_if_fail(radios != NULL);
 533
 534         op = radios_get_value(radios);
 535
 536         if (op == SET_PATH)
 537         {
 538                 if (!set_icon_path(path, icon))
 539                         return;
 540         }
 541         else if (op == SET_COPY)
 542         {
 543                 if (!create_diricon(path, icon))
 544                         return;
 545         }
 546         else
 547         {
 548                 gboolean just_media = (op == SET_MEDIA);
 549                 MIME_type *type;
 550
 551                 type = g_object_get_data(G_OBJECT(dialog), "mime-type");
 552
 553                 if (!set_icon_for_type(type, icon, just_media))
 554                         return;
 555         }
 556
 557         destroy_on_idle(dialog);
 558 }
 559
 560 /* Called when a URI list is dropped onto the box in the Set Icon
 561  * dialog. Make that the default icon.
 562  */
 563 static void drag_icon_dropped(GtkWidget *drop_box,
 564                               const guchar *path,
 565                               GtkWidget *dialog)
 566 {
 567         do_set_icon(dialog, path);
 568 }
 569
 570 /* Set the icon for the given MIME type.  We copy the file. */
 571 static gboolean set_icon_for_type(MIME_type *type, const gchar *iconpath,
 572                                   gboolean just_media)
 573 {
 574         gchar *target;
 575         gchar *leaf;
 576
 577         if (just_media)
 578                 leaf = g_strconcat(type->media_type, ".png", NULL);
 579         else
 580                 leaf = g_strconcat(type->media_type, "_", type->subtype,
 581                                                                 ".png", NULL);
 582
 583         target = choices_find_xdg_path_save(leaf, "MIME-icons", SITE, TRUE);
 584         g_free(leaf);
 585
 586         if (!target)
 587         {
 588                 delayed_error(_("Setting icon disabled by CHOICESPATH"));
 589                 return FALSE;
 590         }
 591
 592         if (!convert_to_png(iconpath, target))
 593         {
 594                 g_free(target);
 595                 return FALSE;
 596         }
 597
 598         g_free(target);
 599
 600         full_refresh();
 601
 602         return TRUE;
 603 }
 604
 605 /* Load image 'src', and save it as an icon-sized image in png format.
 606  * TRUE on success, error is already reported on failure.
 607  */
 608 static gboolean convert_to_png(const gchar *src, const gchar *dest)
 609 {
 610         MaskedPixmap *pic;
 611         GError  *error = NULL;
 612
 613         pic = g_fscache_lookup(pixmap_cache, src);
 614         if (!pic)
 615         {
 616                 delayed_error(
 617                         _("Unable to load image file -- maybe it's not in a "
 618                           "format I understand, or maybe the permissions are "
 619                           "wrong?\n"
 620                           "The icon has not been changed."));
 621                 return FALSE;
 622         }
 623
 624         gdk_pixbuf_save(pic->src_pixbuf, dest,
 625                         "png", &error,
 626                         "tEXt::Software", PROJECT,
 627                         NULL);
 628         g_object_unref(pic);
 629
 630         if (error)
 631         {
 632                 delayed_error(_("Error creating image '%s':\n%s"),
 633                                 dest, error->message);
 634                 g_error_free(error);
 635                 return FALSE;
 636         }
 637
 638         return TRUE;
 639 }