ROX-Filer/src/cell_icon.c

   1 /*
   2  * $Id$
   3  *
   4  * ROX-Filer, filer for the ROX desktop project
   5  * Copyright (C) 2003, 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 /* cell_icon.c - a GtkCellRenderer used for the icons in details mode
  23  *
  24  * Based on gtkcellrendererpixbuf.c.
  25  */
  26
  27 #include "config.h"
  28
  29 #include <gtk/gtk.h>
  30 #include <string.h>
  31
  32 #include "global.h"
  33
  34 #include "view_details.h"
  35 #include "cell_icon.h"
  36 #include "display.h"
  37 #include "diritem.h"
  38 #include "pixmaps.h"
  39 #include "filer.h"
  40 #include "type.h"
  41 #include "support.h"
  42 #include "fscache.h"
  43
  44 typedef struct _CellIcon CellIcon;
  45 typedef struct _CellIconClass CellIconClass;
  46
  47 struct _CellIcon {
  48         GtkCellRenderer parent;
  49
  50         ViewDetails *view_details;
  51         ViewItem *item;
  52         GdkColor background;
  53 };
  54
  55 struct _CellIconClass {
  56         GtkCellRendererClass parent_class;
  57 };
  58
  59
  60 /* Static prototypes */
  61 static void cell_icon_set_property(GObject *object, guint param_id,
  62                                        const GValue *value, GParamSpec *pspec);
  63 static void cell_icon_init       (CellIcon *cell);
  64 static void cell_icon_class_init (CellIconClass *class);
  65 static void cell_icon_get_size   (GtkCellRenderer       *cell,
  66                                       GtkWidget         *widget,
  67                                       GdkRectangle      *rectangle,
  68                                       gint              *x_offset,
  69                                       gint              *y_offset,
  70                                       gint              *width,
  71                                       gint              *height);
  72 static void cell_icon_render     (GtkCellRenderer               *cell,
  73                                       GdkWindow         *window,
  74                                       GtkWidget         *widget,
  75                                       GdkRectangle      *background_area,
  76                                       GdkRectangle      *cell_area,
  77                                       GdkRectangle      *expose_area,
  78                                       guint             flags);
  79 static GtkType cell_icon_get_type(void);
  80
  81 enum {
  82         PROP_ZERO,
  83         PROP_ITEM,
  84         PROP_BACKGROUND_GDK,
  85 };
  86
  87 /****************************************************************
  88  *                      EXTERNAL INTERFACE                      *
  89  ****************************************************************/
  90
  91 GtkCellRenderer *cell_icon_new(ViewDetails *view_details)
  92 {
  93         GtkCellRenderer *cell;
  94
  95         cell = GTK_CELL_RENDERER(g_object_new(cell_icon_get_type(), NULL));
  96         ((CellIcon *) cell)->view_details = view_details;
  97
  98         return cell;
  99 }
 100
 101 /****************************************************************
 102  *                      INTERNAL FUNCTIONS                      *
 103  ****************************************************************/
 104
 105
 106 static GtkType cell_icon_get_type(void)
 107 {
 108         static GtkType cell_icon_type = 0;
 109
 110         if (!cell_icon_type)
 111         {
 112                 static const GTypeInfo cell_icon_info =
 113                 {
 114                         sizeof (CellIconClass),
 115                         NULL,           /* base_init */
 116                         NULL,           /* base_finalize */
 117                         (GClassInitFunc) cell_icon_class_init,
 118                         NULL,           /* class_finalize */
 119                         NULL,           /* class_data */
 120                         sizeof (CellIcon),
 121                         0,              /* n_preallocs */
 122                         (GInstanceInitFunc) cell_icon_init,
 123                 };
 124
 125                 cell_icon_type = g_type_register_static(GTK_TYPE_CELL_RENDERER,
 126                                                         "CellIcon",
 127                                                         &cell_icon_info, 0);
 128         }
 129
 130         return cell_icon_type;
 131 }
 132
 133 static void cell_icon_init(CellIcon *icon)
 134 {
 135         icon->view_details = NULL;
 136 }
 137
 138 static void cell_icon_class_init(CellIconClass *class)
 139 {
 140         GObjectClass *object_class = G_OBJECT_CLASS(class);
 141         GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS(class);
 142
 143         object_class->set_property = cell_icon_set_property;
 144
 145         cell_class->get_size = cell_icon_get_size;
 146         cell_class->render = cell_icon_render;
 147
 148         g_object_class_install_property(object_class,
 149                         PROP_ITEM,
 150                         g_param_spec_pointer("item",
 151                                 "DirItem",
 152                                 "The item to render.",
 153                                 G_PARAM_WRITABLE));
 154
 155         g_object_class_install_property(object_class,
 156                         PROP_BACKGROUND_GDK,
 157                         g_param_spec_boxed("background_gdk",
 158                                 "Background color",
 159                                 "Background color as a GdkColor",
 160                                 GDK_TYPE_COLOR,
 161                                 G_PARAM_WRITABLE));
 162 }
 163
 164 static void cell_icon_set_property(GObject *object, guint param_id,
 165                                        const GValue *value, GParamSpec *pspec)
 166 {
 167         CellIcon *icon = (CellIcon *) object;
 168
 169         switch (param_id)
 170         {
 171                 case PROP_ITEM:
 172                         icon->item = (ViewItem *) g_value_get_pointer(value);
 173                         break;
 174                 case PROP_BACKGROUND_GDK:
 175                 {
 176                         GdkColor *bg = g_value_get_boxed(value);
 177                         if (bg)
 178                         {
 179                                 icon->background.red = bg->red;
 180                                 icon->background.green = bg->green;
 181                                 icon->background.blue = bg->blue;
 182                         }
 183                         break;
 184                 }
 185                 default:
 186                         G_OBJECT_WARN_INVALID_PROPERTY_ID(object,
 187                                                           param_id, pspec);
 188                         break;
 189         }
 190 }
 191
 192 /* Return the size to display this icon at. If huge, ensures that the image
 193  * exists in that size, if present at all.
 194  */
 195 static DisplayStyle get_style(GtkCellRenderer *cell)
 196 {
 197         CellIcon *icon = (CellIcon *) cell;
 198         ViewItem *view_item = icon->item;
 199         DisplayStyle size;
 200         DirItem *item = view_item->item;
 201
 202         if (!view_item->image)
 203         {
 204                 FilerWindow *filer_window = icon->view_details->filer_window;
 205
 206                 if (filer_window->show_thumbs && item->base_type == TYPE_FILE &&
 207                         strcmp(item->mime_type->media_type, "image") == 0)
 208                 {
 209                         const guchar    *path;
 210
 211                         path = make_path(filer_window->real_path,
 212                                          item->leafname);
 213
 214                         view_item->image = g_fscache_lookup_full(pixmap_cache,
 215                                         path, FSCACHE_LOOKUP_ONLY_NEW, NULL);
 216                 }
 217                 if (!view_item->image)
 218                 {
 219                         view_item->image = item->image;
 220                         if (view_item->image)
 221                                 g_object_ref(view_item->image);
 222                 }
 223         }
 224
 225         size = icon->view_details->filer_window->display_style_wanted;
 226
 227         if (size == AUTO_SIZE_ICONS)
 228         {
 229                 if (!view_item->image || view_item->image == item->image)
 230                         size = SMALL_ICONS;
 231                 else
 232                         size = HUGE_ICONS;
 233         }
 234         if (size == HUGE_ICONS && view_item->image &&
 235             !view_item->image->huge_pixbuf)
 236                 pixmap_make_huge(view_item->image);
 237
 238         return size;
 239 }
 240
 241 static void cell_icon_get_size(GtkCellRenderer *cell,
 242                                    GtkWidget       *widget,
 243                                    GdkRectangle    *cell_area,
 244                                    gint            *x_offset,
 245                                    gint            *y_offset,
 246                                    gint            *width,
 247                                    gint            *height)
 248 {
 249         MaskedPixmap *image;
 250         DisplayStyle size;
 251         int w, h;
 252
 253         size = get_style(cell);
 254         image = ((CellIcon *) cell)->item->image;
 255
 256         if (x_offset)
 257                 *x_offset = 0;
 258         if (y_offset)
 259                 *y_offset = 0;
 260
 261         switch (size)
 262         {
 263                 case SMALL_ICONS:
 264                         w = SMALL_WIDTH;
 265                         h = SMALL_HEIGHT;
 266                         break;
 267                 case LARGE_ICONS:
 268                         if (image)
 269                         {
 270                                 w = image->width;
 271                                 h = image->height;
 272                         }
 273                         else
 274                         {
 275                                 w = ICON_WIDTH;
 276                                 h = ICON_HEIGHT;
 277                         }
 278                         break;
 279                 case HUGE_ICONS:
 280                         if (image)
 281                         {
 282                                 w = image->huge_width;
 283                                 h = image->huge_height;
 284                         }
 285                         else
 286                         {
 287                                 w = HUGE_WIDTH;
 288                                 h = HUGE_HEIGHT;
 289                         }
 290                         break;
 291                 default:
 292                         w = 2;
 293                         h = 2;
 294                         break;
 295         }
 296
 297         if (width)
 298                 *width = w;
 299         if (height)
 300                 *height = h;
 301 }
 302
 303 static void cell_icon_render(GtkCellRenderer    *cell,
 304                              GdkWindow          *window,
 305                              GtkWidget          *widget,
 306                              GdkRectangle       *background_area,
 307                              GdkRectangle       *cell_area,
 308                              GdkRectangle       *expose_area,
 309                              guint              flags)
 310 {
 311         CellIcon *icon = (CellIcon *) cell;
 312         ViewItem *view_item = icon->item;
 313         DirItem *item;
 314         DisplayStyle size;
 315         gboolean selected = (flags & GTK_CELL_RENDERER_SELECTED) != 0;
 316
 317         g_return_if_fail(view_item != NULL);
 318
 319         item = view_item->item;
 320         size = get_style(cell);
 321
 322         /* Draw the icon */
 323
 324         if (!view_item->image)
 325                 return;
 326
 327         switch (size)
 328         {
 329                 case SMALL_ICONS:
 330                 {
 331                         GdkRectangle area = *cell_area;
 332                         area.width = MIN(area.width, SMALL_WIDTH);
 333                         area.x = cell_area->x + cell_area->width - area.width;
 334                         draw_small_icon(window, &area, item,
 335                                         view_item->image, selected);
 336
 337                         break;
 338                 }
 339                 case LARGE_ICONS:
 340                         draw_large_icon(window, cell_area, item,
 341                                         view_item->image, selected);
 342                         break;
 343                 case HUGE_ICONS:
 344                         if (!item->image->huge_pixbuf)
 345                                 pixmap_make_huge(item->image);
 346                         draw_huge_icon(window, cell_area, item,
 347                                         view_item->image, selected);
 348                         break;
 349                 default:
 350                         g_warning("Unknown size %d\n", size);
 351                         break;
 352         }
 353 }