Pileus Git - ~andy/gtk/blob - gtk/gtkcellrendererpixbuf.c

   1 /* gtkcellrendererpixbuf.c
   2  * Copyright (C) 2000  Red Hat, Inc.,  Jonathan Blandford <jrb@redhat.com>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include "config.h"
  21 #include <stdlib.h>
  22 #include "gtkcellrendererpixbuf.h"
  23 #include "gtkiconfactory.h"
  24 #include "gtkicontheme.h"
  25 #include "gtkintl.h"
  26 #include "gtkprivate.h"
  27 #include "gtkalias.h"
  28
  29 static void gtk_cell_renderer_pixbuf_get_property  (GObject                    *object,
  30                                                     guint                       param_id,
  31                                                     GValue                     *value,
  32                                                     GParamSpec                 *pspec);
  33 static void gtk_cell_renderer_pixbuf_set_property  (GObject                    *object,
  34                                                     guint                       param_id,
  35                                                     const GValue               *value,
  36                                                     GParamSpec                 *pspec);
  37 static void gtk_cell_renderer_pixbuf_finalize   (GObject                    *object);
  38 static void gtk_cell_renderer_pixbuf_create_stock_pixbuf (GtkCellRendererPixbuf *cellpixbuf,
  39                                                           GtkWidget             *widget);
  40 static void gtk_cell_renderer_pixbuf_get_size   (GtkCellRenderer            *cell,
  41                                                  GtkWidget                  *widget,
  42                                                  GdkRectangle               *rectangle,
  43                                                  gint                       *x_offset,
  44                                                  gint                       *y_offset,
  45                                                  gint                       *width,
  46                                                  gint                       *height);
  47 static void gtk_cell_renderer_pixbuf_render     (GtkCellRenderer            *cell,
  48                                                  GdkDrawable                *window,
  49                                                  GtkWidget                  *widget,
  50                                                  GdkRectangle               *background_area,
  51                                                  GdkRectangle               *cell_area,
  52                                                  GdkRectangle               *expose_area,
  53                                                  GtkCellRendererState        flags);
  54
  55
  56 enum {
  57   PROP_0,
  58   PROP_PIXBUF,
  59   PROP_PIXBUF_EXPANDER_OPEN,
  60   PROP_PIXBUF_EXPANDER_CLOSED,
  61   PROP_STOCK_ID,
  62   PROP_STOCK_SIZE,
  63   PROP_STOCK_DETAIL,
  64   PROP_FOLLOW_STATE,
  65   PROP_ICON_NAME,
  66   PROP_GICON
  67 };
  68
  69
  70 #define GTK_CELL_RENDERER_PIXBUF_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_CELL_RENDERER_PIXBUF, GtkCellRendererPixbufPrivate))
  71
  72 typedef struct _GtkCellRendererPixbufPrivate GtkCellRendererPixbufPrivate;
  73 struct _GtkCellRendererPixbufPrivate
  74 {
  75   gchar *stock_id;
  76   GtkIconSize stock_size;
  77   gchar *stock_detail;
  78   gboolean follow_state;
  79   gchar *icon_name;
  80   GIcon *gicon;
  81 };
  82
  83 G_DEFINE_TYPE (GtkCellRendererPixbuf, gtk_cell_renderer_pixbuf, GTK_TYPE_CELL_RENDERER)
  84
  85 static void
  86 gtk_cell_renderer_pixbuf_init (GtkCellRendererPixbuf *cellpixbuf)
  87 {
  88   GtkCellRendererPixbufPrivate *priv;
  89
  90   priv = GTK_CELL_RENDERER_PIXBUF_GET_PRIVATE (cellpixbuf);
  91   priv->stock_size = GTK_ICON_SIZE_MENU;
  92 }
  93
  94 static void
  95 gtk_cell_renderer_pixbuf_class_init (GtkCellRendererPixbufClass *class)
  96 {
  97   GObjectClass *object_class = G_OBJECT_CLASS (class);
  98   GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS (class);
  99
 100   object_class->finalize = gtk_cell_renderer_pixbuf_finalize;
 101
 102   object_class->get_property = gtk_cell_renderer_pixbuf_get_property;
 103   object_class->set_property = gtk_cell_renderer_pixbuf_set_property;
 104
 105   cell_class->get_size = gtk_cell_renderer_pixbuf_get_size;
 106   cell_class->render = gtk_cell_renderer_pixbuf_render;
 107
 108   g_object_class_install_property (object_class,
 109                                    PROP_PIXBUF,
 110                                    g_param_spec_object ("pixbuf",
 111                                                         P_("Pixbuf Object"),
 112                                                         P_("The pixbuf to render"),
 113                                                         GDK_TYPE_PIXBUF,
 114                                                         GTK_PARAM_READWRITE));
 115
 116   g_object_class_install_property (object_class,
 117                                    PROP_PIXBUF_EXPANDER_OPEN,
 118                                    g_param_spec_object ("pixbuf-expander-open",
 119                                                         P_("Pixbuf Expander Open"),
 120                                                         P_("Pixbuf for open expander"),
 121                                                         GDK_TYPE_PIXBUF,
 122                                                         GTK_PARAM_READWRITE));
 123
 124   g_object_class_install_property (object_class,
 125                                    PROP_PIXBUF_EXPANDER_CLOSED,
 126                                    g_param_spec_object ("pixbuf-expander-closed",
 127                                                         P_("Pixbuf Expander Closed"),
 128                                                         P_("Pixbuf for closed expander"),
 129                                                         GDK_TYPE_PIXBUF,
 130                                                         GTK_PARAM_READWRITE));
 131
 132   g_object_class_install_property (object_class,
 133                                    PROP_STOCK_ID,
 134                                    g_param_spec_string ("stock-id",
 135                                                         P_("Stock ID"),
 136                                                         P_("The stock ID of the stock icon to render"),
 137                                                         NULL,
 138                                                         GTK_PARAM_READWRITE));
 139
 140   g_object_class_install_property (object_class,
 141                                    PROP_STOCK_SIZE,
 142                                    g_param_spec_uint ("stock-size",
 143                                                       P_("Size"),
 144                                                       P_("The GtkIconSize value that specifies the size of the rendered icon"),
 145                                                       0,
 146                                                       G_MAXUINT,
 147                                                       GTK_ICON_SIZE_MENU,
 148                                                       GTK_PARAM_READWRITE));
 149
 150   g_object_class_install_property (object_class,
 151                                    PROP_STOCK_DETAIL,
 152                                    g_param_spec_string ("stock-detail",
 153                                                         P_("Detail"),
 154                                                         P_("Render detail to pass to the theme engine"),
 155                                                         NULL,
 156                                                         GTK_PARAM_READWRITE));
 157
 158
 159   /**
 160    * GtkCellRendererPixbuf:icon-name:
 161    *
 162    * The name of the themed icon to display.
 163    * This property only has an effect if not overridden by "stock_id"
 164    * or "pixbuf" properties.
 165    *
 166    * Since: 2.8
 167    */
 168   g_object_class_install_property (object_class,
 169                                    PROP_ICON_NAME,
 170                                    g_param_spec_string ("icon-name",
 171                                                         P_("Icon Name"),
 172                                                         P_("The name of the icon from the icon theme"),
 173                                                         NULL,
 174                                                         GTK_PARAM_READWRITE));
 175
 176   /**
 177    * GtkCellRendererPixbuf:follow-state:
 178    *
 179    * Specifies whether the rendered pixbuf should be colorized
 180    * according to the #GtkCellRendererState.
 181    *
 182    * Since: 2.8
 183    */
 184   g_object_class_install_property (object_class,
 185                                    PROP_FOLLOW_STATE,
 186                                    g_param_spec_boolean ("follow-state",
 187                                                          P_("Follow State"),
 188                                                          P_("Whether the rendered pixbuf should be "
 189                                                             "colorized according to the state"),
 190                                                          FALSE,
 191                                                          GTK_PARAM_READWRITE));
 192
 193   /**
 194    * GtkCellRendererPixbuf:gicon:
 195    *
 196    * The GIcon representing the icon to display.
 197    * If the icon theme is changed, the image will be updated
 198    * automatically.
 199    *
 200    * Since: 2.14
 201    */
 202   g_object_class_install_property (object_class,
 203                                    PROP_GICON,
 204                                    g_param_spec_object ("gicon",
 205                                                         P_("Icon"),
 206                                                         P_("The GIcon being displayed"),
 207                                                         G_TYPE_ICON,
 208                                                         GTK_PARAM_READWRITE));
 209
 210
 211
 212   g_type_class_add_private (object_class, sizeof (GtkCellRendererPixbufPrivate));
 213 }
 214
 215 static void
 216 gtk_cell_renderer_pixbuf_finalize (GObject *object)
 217 {
 218   GtkCellRendererPixbuf *cellpixbuf = GTK_CELL_RENDERER_PIXBUF (object);
 219   GtkCellRendererPixbufPrivate *priv;
 220
 221   priv = GTK_CELL_RENDERER_PIXBUF_GET_PRIVATE (object);
 222
 223   if (cellpixbuf->pixbuf)
 224     g_object_unref (cellpixbuf->pixbuf);
 225   if (cellpixbuf->pixbuf_expander_open)
 226     g_object_unref (cellpixbuf->pixbuf_expander_open);
 227   if (cellpixbuf->pixbuf_expander_closed)
 228     g_object_unref (cellpixbuf->pixbuf_expander_closed);
 229
 230   g_free (priv->stock_id);
 231   g_free (priv->stock_detail);
 232   g_free (priv->icon_name);
 233
 234   if (priv->gicon)
 235     g_object_unref (priv->gicon);
 236
 237   G_OBJECT_CLASS (gtk_cell_renderer_pixbuf_parent_class)->finalize (object);
 238 }
 239
 240 static void
 241 gtk_cell_renderer_pixbuf_get_property (GObject        *object,
 242                                        guint           param_id,
 243                                        GValue         *value,
 244                                        GParamSpec     *pspec)
 245 {
 246   GtkCellRendererPixbuf *cellpixbuf = GTK_CELL_RENDERER_PIXBUF (object);
 247   GtkCellRendererPixbufPrivate *priv;
 248
 249   priv = GTK_CELL_RENDERER_PIXBUF_GET_PRIVATE (object);
 250
 251   switch (param_id)
 252     {
 253     case PROP_PIXBUF:
 254       g_value_set_object (value, cellpixbuf->pixbuf);
 255       break;
 256     case PROP_PIXBUF_EXPANDER_OPEN:
 257       g_value_set_object (value, cellpixbuf->pixbuf_expander_open);
 258       break;
 259     case PROP_PIXBUF_EXPANDER_CLOSED:
 260       g_value_set_object (value, cellpixbuf->pixbuf_expander_closed);
 261       break;
 262     case PROP_STOCK_ID:
 263       g_value_set_string (value, priv->stock_id);
 264       break;
 265     case PROP_STOCK_SIZE:
 266       g_value_set_uint (value, priv->stock_size);
 267       break;
 268     case PROP_STOCK_DETAIL:
 269       g_value_set_string (value, priv->stock_detail);
 270       break;
 271     case PROP_FOLLOW_STATE:
 272       g_value_set_boolean (value, priv->follow_state);
 273       break;
 274     case PROP_ICON_NAME:
 275       g_value_set_string (value, priv->icon_name);
 276       break;
 277     case PROP_GICON:
 278       g_value_set_object (value, priv->gicon);
 279       break;
 280     default:
 281       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 282       break;
 283     }
 284 }
 285
 286 static void
 287 gtk_cell_renderer_pixbuf_set_property (GObject      *object,
 288                                        guint         param_id,
 289                                        const GValue *value,
 290                                        GParamSpec   *pspec)
 291 {
 292   GtkCellRendererPixbuf *cellpixbuf = GTK_CELL_RENDERER_PIXBUF (object);
 293   GtkCellRendererPixbufPrivate *priv;
 294
 295   priv = GTK_CELL_RENDERER_PIXBUF_GET_PRIVATE (object);
 296
 297   switch (param_id)
 298     {
 299     case PROP_PIXBUF:
 300       if (cellpixbuf->pixbuf)
 301         g_object_unref (cellpixbuf->pixbuf);
 302       cellpixbuf->pixbuf = (GdkPixbuf*) g_value_dup_object (value);
 303       if (cellpixbuf->pixbuf)
 304         {
 305           if (priv->stock_id)
 306             {
 307               g_free (priv->stock_id);
 308               priv->stock_id = NULL;
 309               g_object_notify (object, "stock-id");
 310             }
 311           if (priv->icon_name)
 312             {
 313               g_free (priv->icon_name);
 314               priv->icon_name = NULL;
 315               g_object_notify (object, "icon-name");
 316             }
 317           if (priv->gicon)
 318             {
 319               g_object_unref (priv->gicon);
 320               priv->gicon = NULL;
 321               g_object_notify (object, "gicon");
 322             }
 323         }
 324       break;
 325     case PROP_PIXBUF_EXPANDER_OPEN:
 326       if (cellpixbuf->pixbuf_expander_open)
 327         g_object_unref (cellpixbuf->pixbuf_expander_open);
 328       cellpixbuf->pixbuf_expander_open = (GdkPixbuf*) g_value_dup_object (value);
 329       break;
 330     case PROP_PIXBUF_EXPANDER_CLOSED:
 331       if (cellpixbuf->pixbuf_expander_closed)
 332         g_object_unref (cellpixbuf->pixbuf_expander_closed);
 333       cellpixbuf->pixbuf_expander_closed = (GdkPixbuf*) g_value_dup_object (value);
 334       break;
 335     case PROP_STOCK_ID:
 336       if (priv->stock_id)
 337         {
 338           if (cellpixbuf->pixbuf)
 339             {
 340               g_object_unref (cellpixbuf->pixbuf);
 341               cellpixbuf->pixbuf = NULL;
 342               g_object_notify (object, "pixbuf");
 343             }
 344           g_free (priv->stock_id);
 345         }
 346       priv->stock_id = g_value_dup_string (value);
 347       if (priv->stock_id)
 348         {
 349           if (cellpixbuf->pixbuf)
 350             {
 351               g_object_unref (cellpixbuf->pixbuf);
 352               cellpixbuf->pixbuf = NULL;
 353               g_object_notify (object, "pixbuf");
 354             }
 355           if (priv->icon_name)
 356             {
 357               g_free (priv->icon_name);
 358               priv->icon_name = NULL;
 359               g_object_notify (object, "icon-name");
 360             }
 361           if (priv->gicon)
 362             {
 363               g_object_unref (priv->gicon);
 364               priv->gicon = NULL;
 365               g_object_notify (object, "gicon");
 366             }
 367         }
 368       break;
 369     case PROP_STOCK_SIZE:
 370       priv->stock_size = g_value_get_uint (value);
 371       break;
 372     case PROP_STOCK_DETAIL:
 373       g_free (priv->stock_detail);
 374       priv->stock_detail = g_value_dup_string (value);
 375       break;
 376     case PROP_ICON_NAME:
 377       if (priv->icon_name)
 378         {
 379           if (cellpixbuf->pixbuf)
 380             {
 381               g_object_unref (cellpixbuf->pixbuf);
 382               cellpixbuf->pixbuf = NULL;
 383               g_object_notify (object, "pixbuf");
 384             }
 385           g_free (priv->icon_name);
 386         }
 387       priv->icon_name = g_value_dup_string (value);
 388       if (priv->icon_name)
 389         {
 390           if (cellpixbuf->pixbuf)
 391             {
 392               g_object_unref (cellpixbuf->pixbuf);
 393               cellpixbuf->pixbuf = NULL;
 394               g_object_notify (object, "pixbuf");
 395             }
 396           if (priv->stock_id)
 397             {
 398               g_free (priv->stock_id);
 399               priv->stock_id = NULL;
 400               g_object_notify (object, "stock-id");
 401             }
 402           if (priv->gicon)
 403             {
 404               g_object_unref (priv->gicon);
 405               priv->gicon = NULL;
 406               g_object_notify (object, "gicon");
 407             }
 408         }
 409       break;
 410     case PROP_FOLLOW_STATE:
 411       priv->follow_state = g_value_get_boolean (value);
 412       break;
 413     case PROP_GICON:
 414       if (priv->gicon)
 415         {
 416           if (cellpixbuf->pixbuf)
 417             {
 418               g_object_unref (cellpixbuf->pixbuf);
 419               cellpixbuf->pixbuf = NULL;
 420               g_object_notify (object, "pixbuf");
 421             }
 422           g_object_unref (priv->gicon);
 423         }
 424       priv->gicon = (GIcon *) g_value_dup_object (value);
 425       if (priv->gicon)
 426         {
 427           if (cellpixbuf->pixbuf)
 428             {
 429               g_object_unref (cellpixbuf->pixbuf);
 430               cellpixbuf->pixbuf = NULL;
 431               g_object_notify (object, "pixbuf");
 432             }
 433           if (priv->stock_id)
 434             {
 435               g_free (priv->stock_id);
 436               priv->stock_id = NULL;
 437               g_object_notify (object, "stock-id");
 438             }
 439           if (priv->icon_name)
 440             {
 441               g_free (priv->icon_name);
 442               priv->icon_name = NULL;
 443               g_object_notify (object, "icon-name");
 444             }
 445         }
 446       break;
 447     default:
 448       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 449       break;
 450     }
 451 }
 452
 453 /**
 454  * gtk_cell_renderer_pixbuf_new:
 455  *
 456  * Creates a new #GtkCellRendererPixbuf. Adjust rendering
 457  * parameters using object properties. Object properties can be set
 458  * globally (with g_object_set()). Also, with #GtkTreeViewColumn, you
 459  * can bind a property to a value in a #GtkTreeModel. For example, you
 460  * can bind the "pixbuf" property on the cell renderer to a pixbuf value
 461  * in the model, thus rendering a different image in each row of the
 462  * #GtkTreeView.
 463  *
 464  * Return value: the new cell renderer
 465  **/
 466 GtkCellRenderer *
 467 gtk_cell_renderer_pixbuf_new (void)
 468 {
 469   return g_object_new (GTK_TYPE_CELL_RENDERER_PIXBUF, NULL);
 470 }
 471
 472 static void
 473 gtk_cell_renderer_pixbuf_create_stock_pixbuf (GtkCellRendererPixbuf *cellpixbuf,
 474                                               GtkWidget             *widget)
 475 {
 476   GtkCellRendererPixbufPrivate *priv;
 477
 478   priv = GTK_CELL_RENDERER_PIXBUF_GET_PRIVATE (cellpixbuf);
 479
 480   if (cellpixbuf->pixbuf)
 481     g_object_unref (cellpixbuf->pixbuf);
 482
 483   cellpixbuf->pixbuf = gtk_widget_render_icon (widget,
 484                                                priv->stock_id,
 485                                                priv->stock_size,
 486                                                priv->stock_detail);
 487
 488   g_object_notify (G_OBJECT (cellpixbuf), "pixbuf");
 489 }
 490
 491 static void
 492 gtk_cell_renderer_pixbuf_create_themed_pixbuf (GtkCellRendererPixbuf *cellpixbuf,
 493                                                GtkWidget             *widget)
 494 {
 495   GtkCellRendererPixbufPrivate *priv;
 496   GdkScreen *screen;
 497   GtkIconTheme *icon_theme;
 498   GtkSettings *settings;
 499   gint width, height;
 500   GtkIconInfo *info;
 501
 502   priv = GTK_CELL_RENDERER_PIXBUF_GET_PRIVATE (cellpixbuf);
 503
 504   if (cellpixbuf->pixbuf)
 505     {
 506       g_object_unref (cellpixbuf->pixbuf);
 507       cellpixbuf->pixbuf = NULL;
 508     }
 509
 510   screen = gtk_widget_get_screen (GTK_WIDGET (widget));
 511   icon_theme = gtk_icon_theme_get_for_screen (screen);
 512   settings = gtk_settings_get_for_screen (screen);
 513
 514   if (!gtk_icon_size_lookup_for_settings (settings,
 515                                           priv->stock_size,
 516                                           &width, &height))
 517     {
 518       g_warning ("Invalid icon size %u\n", priv->stock_size);
 519       width = height = 24;
 520     }
 521
 522   if (priv->icon_name)
 523     info = gtk_icon_theme_lookup_icon (icon_theme,
 524                                        priv->icon_name,
 525                                        MIN (width, height),
 526                                        GTK_ICON_LOOKUP_USE_BUILTIN);
 527   else if (priv->gicon)
 528     info = gtk_icon_theme_lookup_by_gicon (icon_theme,
 529                                            priv->gicon,
 530                                            MIN (width, height),
 531                                            GTK_ICON_LOOKUP_USE_BUILTIN);
 532   else
 533     info = NULL;
 534
 535   if (info)
 536     {
 537       GdkColor error_color, warning_color, success_color;
 538       GdkColor *error_ptr, *warning_ptr, *success_ptr;
 539       GtkStyle *style;
 540
 541       style = gtk_widget_get_style (GTK_WIDGET (widget));
 542       if (!gtk_style_lookup_color (style, "error_color", &error_color))
 543         error_ptr = NULL;
 544       else
 545         error_ptr = &error_color;
 546       if (!gtk_style_lookup_color (style, "warning_color", &warning_color))
 547         warning_ptr = NULL;
 548       else
 549         warning_ptr = &warning_color;
 550       if (!gtk_style_lookup_color (style, "success_color", &success_color))
 551         success_ptr = NULL;
 552       else
 553         success_ptr = &success_color;
 554
 555       cellpixbuf->pixbuf = gtk_icon_info_load_symbolic (info,
 556                                                         &style->fg[GTK_STATE_NORMAL],
 557                                                         success_ptr,
 558                                                         warning_ptr,
 559                                                         error_ptr,
 560                                                         NULL,
 561                                                         NULL);
 562       gtk_icon_info_free (info);
 563     }
 564
 565   g_object_notify (G_OBJECT (cellpixbuf), "pixbuf");
 566 }
 567
 568 static GdkPixbuf *
 569 create_symbolic_pixbuf (GtkCellRendererPixbuf *cellpixbuf,
 570                         GtkWidget             *widget,
 571                         GdkColor              *fg)
 572 {
 573   GtkCellRendererPixbufPrivate *priv;
 574   GdkScreen *screen;
 575   GtkIconTheme *icon_theme;
 576   GtkSettings *settings;
 577   gint width, height;
 578   GtkIconInfo *info;
 579   GdkPixbuf *pixbuf;
 580
 581   priv = GTK_CELL_RENDERER_PIXBUF_GET_PRIVATE (cellpixbuf);
 582
 583   /* Not a named symbolic icon? */
 584   if (priv->icon_name) {
 585     if (!g_str_has_suffix (priv->icon_name, "-symbolic"))
 586       return NULL;
 587   } else if (priv->gicon) {
 588     const gchar * const *names;
 589     if (!G_IS_THEMED_ICON (priv->gicon))
 590       return NULL;
 591     names = g_themed_icon_get_names (G_THEMED_ICON (priv->gicon));
 592     if (names == NULL || !g_str_has_suffix (names[0], "-symbolic"))
 593       return NULL;
 594   } else {
 595     return NULL;
 596   }
 597
 598   screen = gtk_widget_get_screen (GTK_WIDGET (widget));
 599   icon_theme = gtk_icon_theme_get_for_screen (screen);
 600   settings = gtk_settings_get_for_screen (screen);
 601
 602   if (!gtk_icon_size_lookup_for_settings (settings,
 603                                           priv->stock_size,
 604                                           &width, &height))
 605     {
 606       g_warning ("Invalid icon size %u\n", priv->stock_size);
 607       width = height = 24;
 608     }
 609
 610
 611   if (priv->icon_name)
 612     info = gtk_icon_theme_lookup_icon (icon_theme,
 613                                        priv->icon_name,
 614                                        MIN (width, height),
 615                                        GTK_ICON_LOOKUP_USE_BUILTIN);
 616   else if (priv->gicon)
 617     info = gtk_icon_theme_lookup_by_gicon (icon_theme,
 618                                            priv->gicon,
 619                                            MIN (width, height),
 620                                            GTK_ICON_LOOKUP_USE_BUILTIN);
 621   else
 622     return NULL;
 623
 624   if (info)
 625     {
 626       GdkColor error_color, warning_color, success_color;
 627       GdkColor *error_ptr, *warning_ptr, *success_ptr;
 628       GtkStyle *style;
 629
 630       style = gtk_widget_get_style (GTK_WIDGET (widget));
 631       if (!gtk_style_lookup_color (style, "error_color", &error_color))
 632         error_ptr = NULL;
 633       else
 634         error_ptr = &error_color;
 635       if (!gtk_style_lookup_color (style, "warning_color", &warning_color))
 636         warning_ptr = NULL;
 637       else
 638         warning_ptr = &warning_color;
 639       if (!gtk_style_lookup_color (style, "success_color", &success_color))
 640         success_ptr = NULL;
 641       else
 642         success_ptr = &success_color;
 643
 644       pixbuf = gtk_icon_info_load_symbolic (info,
 645                                             fg,
 646                                             success_ptr,
 647                                             warning_ptr,
 648                                             error_ptr,
 649                                             NULL,
 650                                             NULL);
 651       gtk_icon_info_free (info);
 652       return pixbuf;
 653     }
 654   return NULL;
 655 }
 656
 657 static GdkPixbuf *
 658 create_colorized_pixbuf (GdkPixbuf *src,
 659                          GdkColor  *new_color)
 660 {
 661   gint i, j;
 662   gint width, height, has_alpha, src_row_stride, dst_row_stride;
 663   gint red_value, green_value, blue_value;
 664   guchar *target_pixels;
 665   guchar *original_pixels;
 666   guchar *pixsrc;
 667   guchar *pixdest;
 668   GdkPixbuf *dest;
 669
 670   red_value = new_color->red / 255.0;
 671   green_value = new_color->green / 255.0;
 672   blue_value = new_color->blue / 255.0;
 673
 674   dest = gdk_pixbuf_new (gdk_pixbuf_get_colorspace (src),
 675                          gdk_pixbuf_get_has_alpha (src),
 676                          gdk_pixbuf_get_bits_per_sample (src),
 677                          gdk_pixbuf_get_width (src),
 678                          gdk_pixbuf_get_height (src));
 679
 680   has_alpha = gdk_pixbuf_get_has_alpha (src);
 681   width = gdk_pixbuf_get_width (src);
 682   height = gdk_pixbuf_get_height (src);
 683   src_row_stride = gdk_pixbuf_get_rowstride (src);
 684   dst_row_stride = gdk_pixbuf_get_rowstride (dest);
 685   target_pixels = gdk_pixbuf_get_pixels (dest);
 686   original_pixels = gdk_pixbuf_get_pixels (src);
 687
 688   for (i = 0; i < height; i++) {
 689     pixdest = target_pixels + i*dst_row_stride;
 690     pixsrc = original_pixels + i*src_row_stride;
 691     for (j = 0; j < width; j++) {
 692       *pixdest++ = (*pixsrc++ * red_value) >> 8;
 693       *pixdest++ = (*pixsrc++ * green_value) >> 8;
 694       *pixdest++ = (*pixsrc++ * blue_value) >> 8;
 695       if (has_alpha) {
 696         *pixdest++ = *pixsrc++;
 697       }
 698     }
 699   }
 700   return dest;
 701 }
 702
 703
 704 static void
 705 gtk_cell_renderer_pixbuf_get_size (GtkCellRenderer *cell,
 706                                    GtkWidget       *widget,
 707                                    GdkRectangle    *cell_area,
 708                                    gint            *x_offset,
 709                                    gint            *y_offset,
 710                                    gint            *width,
 711                                    gint            *height)
 712 {
 713   GtkCellRendererPixbuf *cellpixbuf = (GtkCellRendererPixbuf *) cell;
 714   GtkCellRendererPixbufPrivate *priv;
 715   gint pixbuf_width  = 0;
 716   gint pixbuf_height = 0;
 717   gint calc_width;
 718   gint calc_height;
 719
 720   priv = GTK_CELL_RENDERER_PIXBUF_GET_PRIVATE (cell);
 721
 722   if (!cellpixbuf->pixbuf)
 723     {
 724       if (priv->stock_id)
 725         gtk_cell_renderer_pixbuf_create_stock_pixbuf (cellpixbuf, widget);
 726       else if (priv->icon_name || priv->gicon)
 727         gtk_cell_renderer_pixbuf_create_themed_pixbuf (cellpixbuf, widget);
 728     }
 729
 730   if (cellpixbuf->pixbuf)
 731     {
 732       pixbuf_width  = gdk_pixbuf_get_width (cellpixbuf->pixbuf);
 733       pixbuf_height = gdk_pixbuf_get_height (cellpixbuf->pixbuf);
 734     }
 735   if (cellpixbuf->pixbuf_expander_open)
 736     {
 737       pixbuf_width  = MAX (pixbuf_width, gdk_pixbuf_get_width (cellpixbuf->pixbuf_expander_open));
 738       pixbuf_height = MAX (pixbuf_height, gdk_pixbuf_get_height (cellpixbuf->pixbuf_expander_open));
 739     }
 740   if (cellpixbuf->pixbuf_expander_closed)
 741     {
 742       pixbuf_width  = MAX (pixbuf_width, gdk_pixbuf_get_width (cellpixbuf->pixbuf_expander_closed));
 743       pixbuf_height = MAX (pixbuf_height, gdk_pixbuf_get_height (cellpixbuf->pixbuf_expander_closed));
 744     }
 745
 746   calc_width  = (gint) cell->xpad * 2 + pixbuf_width;
 747   calc_height = (gint) cell->ypad * 2 + pixbuf_height;
 748
 749   if (cell_area && pixbuf_width > 0 && pixbuf_height > 0)
 750     {
 751       if (x_offset)
 752         {
 753           *x_offset = (((gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) ?
 754                         (1.0 - cell->xalign) : cell->xalign) *
 755                        (cell_area->width - calc_width));
 756           *x_offset = MAX (*x_offset, 0);
 757         }
 758       if (y_offset)
 759         {
 760           *y_offset = (cell->yalign *
 761                        (cell_area->height - calc_height));
 762           *y_offset = MAX (*y_offset, 0);
 763         }
 764     }
 765   else
 766     {
 767       if (x_offset) *x_offset = 0;
 768       if (y_offset) *y_offset = 0;
 769     }
 770
 771   if (width)
 772     *width = calc_width;
 773
 774   if (height)
 775     *height = calc_height;
 776 }
 777
 778 static void
 779 gtk_cell_renderer_pixbuf_render (GtkCellRenderer      *cell,
 780                                  GdkWindow            *window,
 781                                  GtkWidget            *widget,
 782                                  GdkRectangle         *background_area,
 783                                  GdkRectangle         *cell_area,
 784                                  GdkRectangle         *expose_area,
 785                                  GtkCellRendererState  flags)
 786
 787 {
 788   GtkCellRendererPixbuf *cellpixbuf = (GtkCellRendererPixbuf *) cell;
 789   GtkCellRendererPixbufPrivate *priv;
 790   GdkPixbuf *pixbuf;
 791   GdkPixbuf *invisible = NULL;
 792   GdkPixbuf *colorized = NULL;
 793   GdkPixbuf *symbolic = NULL;
 794   GdkRectangle pix_rect;
 795   GdkRectangle draw_rect;
 796   cairo_t *cr;
 797
 798   priv = GTK_CELL_RENDERER_PIXBUF_GET_PRIVATE (cell);
 799
 800   gtk_cell_renderer_pixbuf_get_size (cell, widget, cell_area,
 801                                      &pix_rect.x,
 802                                      &pix_rect.y,
 803                                      &pix_rect.width,
 804                                      &pix_rect.height);
 805
 806   pix_rect.x += cell_area->x + cell->xpad;
 807   pix_rect.y += cell_area->y + cell->ypad;
 808   pix_rect.width  -= cell->xpad * 2;
 809   pix_rect.height -= cell->ypad * 2;
 810
 811   if (!gdk_rectangle_intersect (cell_area, &pix_rect, &draw_rect) ||
 812       !gdk_rectangle_intersect (expose_area, &draw_rect, &draw_rect))
 813     return;
 814
 815   pixbuf = cellpixbuf->pixbuf;
 816
 817   if (cell->is_expander)
 818     {
 819       if (cell->is_expanded &&
 820           cellpixbuf->pixbuf_expander_open != NULL)
 821         pixbuf = cellpixbuf->pixbuf_expander_open;
 822       else if (!cell->is_expanded &&
 823                cellpixbuf->pixbuf_expander_closed != NULL)
 824         pixbuf = cellpixbuf->pixbuf_expander_closed;
 825     }
 826
 827   if (!pixbuf)
 828     return;
 829
 830   if (gtk_widget_get_state (widget) == GTK_STATE_INSENSITIVE || !cell->sensitive)
 831     {
 832       GtkIconSource *source;
 833
 834       source = gtk_icon_source_new ();
 835       gtk_icon_source_set_pixbuf (source, pixbuf);
 836       /* The size here is arbitrary; since size isn't
 837        * wildcarded in the source, it isn't supposed to be
 838        * scaled by the engine function
 839        */
 840       gtk_icon_source_set_size (source, GTK_ICON_SIZE_SMALL_TOOLBAR);
 841       gtk_icon_source_set_size_wildcarded (source, FALSE);
 842
 843      invisible = gtk_style_render_icon (widget->style,
 844                                         source,
 845                                         gtk_widget_get_direction (widget),
 846                                         GTK_STATE_INSENSITIVE,
 847                                         /* arbitrary */
 848                                         (GtkIconSize)-1,
 849                                         widget,
 850                                         "gtkcellrendererpixbuf");
 851
 852      gtk_icon_source_free (source);
 853
 854      pixbuf = invisible;
 855     }
 856   else if (priv->follow_state &&
 857            (flags & (GTK_CELL_RENDERER_SELECTED|GTK_CELL_RENDERER_PRELIT)) != 0)
 858     {
 859       GtkStateType state;
 860
 861       if ((flags & GTK_CELL_RENDERER_SELECTED) != 0)
 862         {
 863           if (gtk_widget_has_focus (widget))
 864             state = GTK_STATE_SELECTED;
 865           else
 866             state = GTK_STATE_ACTIVE;
 867         }
 868       else
 869         state = GTK_STATE_PRELIGHT;
 870
 871       symbolic = create_symbolic_pixbuf (cellpixbuf, widget, &widget->style->fg[state]);
 872       if (!symbolic) {
 873         colorized = create_colorized_pixbuf (pixbuf,
 874                                              &widget->style->base[state]);
 875
 876         pixbuf = colorized;
 877       } else {
 878         pixbuf = symbolic;
 879       }
 880     }
 881
 882   cr = gdk_cairo_create (window);
 883
 884   gdk_cairo_set_source_pixbuf (cr, pixbuf, pix_rect.x, pix_rect.y);
 885   gdk_cairo_rectangle (cr, &draw_rect);
 886   cairo_fill (cr);
 887
 888   cairo_destroy (cr);
 889
 890   if (invisible)
 891     g_object_unref (invisible);
 892
 893   if (colorized)
 894     g_object_unref (colorized);
 895
 896   if (symbolic)
 897     g_object_unref (symbolic);
 898 }
 899
 900 #define __GTK_CELL_RENDERER_PIXBUF_C__
 901 #include "gtkaliasdef.c"