ROX-Filer/src/pixmaps.c

   1 /*
   2  * $Id$
   3  *
   4  * ROX-Filer, filer for the ROX desktop project
   5  * Copyright (C) 1999, Thomas Leonard, <tal197@ecs.soton.ac.uk>.
   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 pixmaps */
  23
  24 /* Remove pixmaps from the cache when they haven't been accessed for
  25  * this period of time (seconds).
  26  */
  27 #define PIXMAP_PURGE_TIME 600
  28
  29 #include <stdlib.h>
  30 #include <stdio.h>
  31 #include <errno.h>
  32
  33 #include <gtk/gtk.h>
  34 #include "collection.h"
  35
  36 #include "fscache.h"
  37 #include "support.h"
  38 #include "gui_support.h"
  39 #include "pixmaps.h"
  40
  41 static GFSCache *pixmap_cache = NULL;
  42
  43 static char * bad_xpm[] = {
  44 "12 12 3 1",
  45 "       c #000000000000",
  46 ".      c #FFFF00000000",
  47 "X      c #FFFFFFFFFFFF",
  48 "            ",
  49 " ..XXXXXX.. ",
  50 " ...XXXX... ",
  51 " X...XX...X ",
  52 " XX......XX ",
  53 " XXX....XXX ",
  54 " XXX....XXX ",
  55 " XX......XX ",
  56 " X...XX...X ",
  57 " ...XXXX... ",
  58 " ..XXXXXX.. ",
  59 "            "};
  60
  61 MaskedPixmap    default_pixmap[LAST_DEFAULT_PIXMAP];
  62
  63 /* Static prototypes */
  64
  65 static MaskedPixmap *load(char *pathname, gpointer data);
  66 static void ref(MaskedPixmap *mp, gpointer data);
  67 static void unref(MaskedPixmap *mp, gpointer data);
  68 static gint purge(gpointer data);
  69
  70
  71 /****************************************************************
  72  *                      EXTERNAL INTERFACE                      *
  73  ****************************************************************/
  74
  75 void pixmaps_init(void)
  76 {
  77         pixmap_cache = g_fscache_new((GFSLoadFunc) load,
  78                                         (GFSFunc) ref,
  79                                         (GFSFunc) unref,
  80                                         NULL);
  81
  82         gtk_timeout_add(10000, purge, NULL);
  83 }
  84
  85 /* Try to load the pixmap from the given path, allocate a MaskedPixmap
  86  * structure for it and return a pointer to the structure. NULL on failure.
  87  */
  88 MaskedPixmap *load_pixmap_from(GtkWidget *window, char *path)
  89 {
  90         MaskedPixmap    *masked_pixmap;
  91
  92         pixmap_cache->user_data = window;
  93         masked_pixmap = g_fscache_lookup(pixmap_cache, path);
  94         pixmap_cache->user_data = NULL;
  95
  96         return masked_pixmap;
  97 }
  98
  99 void load_pixmap(GdkWindow *window, char *name, MaskedPixmap *image)
 100 {
 101         image->pixmap = gdk_pixmap_create_from_xpm(window,
 102                                                    &image->mask,
 103                                                    0,
 104                            make_path(getenv("APP_DIR"), name)->str);
 105
 106         if (!image->pixmap)
 107         {
 108                 image->pixmap= gdk_pixmap_create_from_xpm_d(window,
 109                                 &image->mask, NULL, bad_xpm);
 110         }
 111 }
 112
 113 /* Load all the standard pixmaps */
 114 void load_default_pixmaps(GdkWindow *window)
 115 {
 116         static gboolean loaded = FALSE;
 117
 118         if (loaded)
 119                 return;
 120
 121         load_pixmap(window, "pixmaps/error.xpm",
 122                         default_pixmap + TYPE_ERROR);
 123         load_pixmap(window, "pixmaps/unknown.xpm",
 124                         default_pixmap + TYPE_UNKNOWN);
 125         load_pixmap(window, "pixmaps/symlink.xpm",
 126                         default_pixmap + TYPE_SYMLINK);
 127         load_pixmap(window, "pixmaps/file.xpm",
 128                         default_pixmap + TYPE_FILE);
 129         load_pixmap(window, "pixmaps/directory.xpm",
 130                         default_pixmap + TYPE_DIRECTORY);
 131         load_pixmap(window, "pixmaps/char.xpm",
 132                         default_pixmap + TYPE_CHAR_DEVICE);
 133         load_pixmap(window, "pixmaps/block.xpm",
 134                         default_pixmap + TYPE_BLOCK_DEVICE);
 135         load_pixmap(window, "pixmaps/pipe.xpm",
 136                         default_pixmap + TYPE_PIPE);
 137         load_pixmap(window, "pixmaps/socket.xpm",
 138                         default_pixmap + TYPE_SOCKET);
 139
 140         load_pixmap(window, "pixmaps/mount.xpm",
 141                         default_pixmap + TYPE_UNMOUNTED);
 142         load_pixmap(window, "pixmaps/mounted.xpm",
 143                         default_pixmap + TYPE_MOUNTED);
 144         load_pixmap(window, "pixmaps/multiple.xpm",
 145                         default_pixmap + TYPE_MULTIPLE);
 146         load_pixmap(window, "pixmaps/exec.xpm",
 147                         default_pixmap + TYPE_EXEC_FILE);
 148         load_pixmap(window, "pixmaps/application.xpm",
 149                         default_pixmap + TYPE_APPDIR);
 150
 151         loaded = TRUE;
 152 }
 153
 154 void pixmap_unref(MaskedPixmap *mp)
 155 {
 156         unref(mp, pixmap_cache->user_data);
 157 }
 158
 159 /****************************************************************
 160  *                      INTERNAL FUNCTIONS                      *
 161  ****************************************************************/
 162
 163 /* Try to load the pixmap from the given path, allocate a MaskedPixmap
 164  * structure for it and return a pointer to the structure. NULL on failure.
 165  */
 166 static MaskedPixmap *load(char *pathname, gpointer user_data)
 167 {
 168         GtkWidget       *window = (GtkWidget *) user_data;
 169         GdkPixmap       *pixmap;
 170         GdkBitmap       *mask;
 171         GtkStyle        *style;
 172         MaskedPixmap    *masked_pixmap;
 173
 174         style = gtk_widget_get_style(window);
 175
 176         pixmap = gdk_pixmap_create_from_xpm(window->window,
 177                         &mask,
 178                         &style->bg[GTK_STATE_NORMAL],
 179                         pathname);
 180         if (!pixmap)
 181                 return NULL;
 182
 183         masked_pixmap = g_new(MaskedPixmap, 1);
 184         masked_pixmap->pixmap = pixmap;
 185         masked_pixmap->mask = mask;
 186         masked_pixmap->ref = 1;
 187
 188         return masked_pixmap;
 189 }
 190
 191 static void ref(MaskedPixmap *mp, gpointer data)
 192 {
 193         if (mp)
 194                 mp->ref++;
 195 }
 196
 197 static void unref(MaskedPixmap *mp, gpointer data)
 198 {
 199         if (mp && --mp->ref == 0)
 200         {
 201                 gdk_pixmap_unref(mp->pixmap);
 202                 gdk_bitmap_unref(mp->mask);
 203                 g_free(mp);
 204         }
 205 }
 206
 207 /* Called now and then to clear out old pixmaps */
 208 static gint purge(gpointer data)
 209 {
 210         g_fscache_purge(pixmap_cache, PIXMAP_PURGE_TIME);
 211
 212         return TRUE;
 213 }