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

   1 /* gtkcellrenderer.c
   2  * Copyright (C) 2000  Red Hat, Inc. Jonathan Blandford
   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 "gtkcellrenderer.h"
  22 #include "gtkintl.h"
  23 #include "gtkmarshalers.h"
  24 #include "gtktypebuiltins.h"
  25 #include "gtkprivate.h"
  26 #include "gtktreeprivate.h"
  27 #include "a11y/gtkrenderercellaccessible.h"
  28
  29
  30 /**
  31  * SECTION:gtkcellrenderer
  32  * @Short_description: An object for rendering a single cell
  33  * @Title: GtkCellRenderer
  34  * @See_also: #GtkCellRendererText, #GtkCellRendererPixbuf, #GtkCellRendererToggle
  35  *
  36  * The #GtkCellRenderer is a base class of a set of objects used for
  37  * rendering a cell to a #cairo_t.  These objects are used primarily by
  38  * the #GtkTreeView widget, though they aren't tied to them in any
  39  * specific way.  It is worth noting that #GtkCellRenderer is not a
  40  * #GtkWidget and cannot be treated as such.
  41  *
  42  * The primary use of a #GtkCellRenderer is for drawing a certain graphical
  43  * elements on a #cairo_t. Typically, one cell renderer is used to
  44  * draw many cells on the screen.  To this extent, it isn't expected that a
  45  * CellRenderer keep any permanent state around.  Instead, any state is set
  46  * just prior to use using #GObject<!-- -->s property system.  Then, the
  47  * cell is measured using gtk_cell_renderer_get_size(). Finally, the cell
  48  * is rendered in the correct location using gtk_cell_renderer_render().
  49  *
  50  * There are a number of rules that must be followed when writing a new
  51  * #GtkCellRenderer.  First and formost, its important that a certain set
  52  * of properties will always yield a cell renderer of the same size,
  53  * barring a #GtkStyle change.  The #GtkCellRenderer also has a number of
  54  * generic properties that are expected to be honored by all children.
  55  *
  56  * Beyond merely rendering a cell, cell renderers can optionally
  57  * provide active user interface elements. A cell renderer can be
  58  * <firstterm>activatable</firstterm> like #GtkCellRendererToggle,
  59  * which toggles when it gets activated by a mouse click, or it can be
  60  * <firstterm>editable</firstterm> like #GtkCellRendererText, which
  61  * allows the user to edit the text using a #GtkEntry.
  62  * To make a cell renderer activatable or editable, you have to
  63  * implement the #GtkCellRendererClass.activate or
  64  * #GtkCellRendererClass.start_editing virtual functions, respectively.
  65  */
  66
  67
  68 #define DEBUG_CELL_SIZE_REQUEST 0
  69
  70 static void gtk_cell_renderer_init          (GtkCellRenderer      *cell);
  71 static void gtk_cell_renderer_class_init    (GtkCellRendererClass *class);
  72 static void gtk_cell_renderer_get_property  (GObject              *object,
  73                                              guint                 param_id,
  74                                              GValue               *value,
  75                                              GParamSpec           *pspec);
  76 static void gtk_cell_renderer_set_property  (GObject              *object,
  77                                              guint                 param_id,
  78                                              const GValue         *value,
  79                                              GParamSpec           *pspec);
  80 static void set_cell_bg_color               (GtkCellRenderer      *cell,
  81                                              GdkRGBA              *rgba);
  82
  83 /* Fallback GtkCellRenderer    implementation to use remaining ->get_size() implementations */
  84 static GtkSizeRequestMode gtk_cell_renderer_real_get_request_mode(GtkCellRenderer         *cell);
  85 static void gtk_cell_renderer_real_get_preferred_width           (GtkCellRenderer         *cell,
  86                                                                   GtkWidget               *widget,
  87                                                                   gint                    *minimum_size,
  88                                                                   gint                    *natural_size);
  89 static void gtk_cell_renderer_real_get_preferred_height          (GtkCellRenderer         *cell,
  90                                                                   GtkWidget               *widget,
  91                                                                   gint                    *minimum_size,
  92                                                                   gint                    *natural_size);
  93 static void gtk_cell_renderer_real_get_preferred_height_for_width(GtkCellRenderer         *cell,
  94                                                                   GtkWidget               *widget,
  95                                                                   gint                     width,
  96                                                                   gint                    *minimum_height,
  97                                                                   gint                    *natural_height);
  98 static void gtk_cell_renderer_real_get_preferred_width_for_height(GtkCellRenderer         *cell,
  99                                                                   GtkWidget               *widget,
 100                                                                   gint                     height,
 101                                                                   gint                    *minimum_width,
 102                                                                   gint                    *natural_width);
 103 static void gtk_cell_renderer_real_get_aligned_area              (GtkCellRenderer         *cell,
 104                                                                   GtkWidget               *widget,
 105                                                                   GtkCellRendererState     flags,
 106                                                                   const GdkRectangle      *cell_area,
 107                                                                   GdkRectangle            *aligned_area);
 108
 109
 110 struct _GtkCellRendererPrivate
 111 {
 112   gfloat xalign;
 113   gfloat yalign;
 114
 115   gint width;
 116   gint height;
 117
 118   guint16 xpad;
 119   guint16 ypad;
 120
 121   guint mode                : 2;
 122   guint visible             : 1;
 123   guint is_expander         : 1;
 124   guint is_expanded         : 1;
 125   guint cell_background_set : 1;
 126   guint sensitive           : 1;
 127   guint editing             : 1;
 128
 129   GdkRGBA cell_background;
 130 };
 131
 132 struct _GtkCellRendererClassPrivate
 133 {
 134   GType accessible_type;
 135 };
 136
 137 enum {
 138   PROP_0,
 139   PROP_MODE,
 140   PROP_VISIBLE,
 141   PROP_SENSITIVE,
 142   PROP_XALIGN,
 143   PROP_YALIGN,
 144   PROP_XPAD,
 145   PROP_YPAD,
 146   PROP_WIDTH,
 147   PROP_HEIGHT,
 148   PROP_IS_EXPANDER,
 149   PROP_IS_EXPANDED,
 150   PROP_CELL_BACKGROUND,
 151   PROP_CELL_BACKGROUND_GDK,
 152   PROP_CELL_BACKGROUND_RGBA,
 153   PROP_CELL_BACKGROUND_SET,
 154   PROP_EDITING
 155 };
 156
 157 /* Signal IDs */
 158 enum {
 159   EDITING_CANCELED,
 160   EDITING_STARTED,
 161   LAST_SIGNAL
 162 };
 163
 164 static guint  cell_renderer_signals[LAST_SIGNAL] = { 0 };
 165
 166 static void
 167 gtk_cell_renderer_init (GtkCellRenderer *cell)
 168 {
 169   GtkCellRendererPrivate *priv;
 170
 171   cell->priv = G_TYPE_INSTANCE_GET_PRIVATE (cell,
 172                                             GTK_TYPE_CELL_RENDERER,
 173                                             GtkCellRendererPrivate);
 174   priv = cell->priv;
 175
 176   priv->mode = GTK_CELL_RENDERER_MODE_INERT;
 177   priv->visible = TRUE;
 178   priv->width = -1;
 179   priv->height = -1;
 180   priv->xalign = 0.5;
 181   priv->yalign = 0.5;
 182   priv->xpad = 0;
 183   priv->ypad = 0;
 184   priv->sensitive = TRUE;
 185   priv->is_expander = FALSE;
 186   priv->is_expanded = FALSE;
 187   priv->editing = FALSE;
 188 }
 189
 190 static void
 191 gtk_cell_renderer_class_init (GtkCellRendererClass *class)
 192 {
 193   GObjectClass *object_class = G_OBJECT_CLASS (class);
 194
 195   object_class->get_property = gtk_cell_renderer_get_property;
 196   object_class->set_property = gtk_cell_renderer_set_property;
 197
 198   class->render = NULL;
 199   class->get_size = NULL;
 200   class->get_request_mode               = gtk_cell_renderer_real_get_request_mode;
 201   class->get_preferred_width            = gtk_cell_renderer_real_get_preferred_width;
 202   class->get_preferred_height           = gtk_cell_renderer_real_get_preferred_height;
 203   class->get_preferred_width_for_height = gtk_cell_renderer_real_get_preferred_width_for_height;
 204   class->get_preferred_height_for_width = gtk_cell_renderer_real_get_preferred_height_for_width;
 205   class->get_aligned_area               = gtk_cell_renderer_real_get_aligned_area;
 206
 207   /**
 208    * GtkCellRenderer::editing-canceled:
 209    * @renderer: the object which received the signal
 210    *
 211    * This signal gets emitted when the user cancels the process of editing a
 212    * cell.  For example, an editable cell renderer could be written to cancel
 213    * editing when the user presses Escape.
 214    *
 215    * See also: gtk_cell_renderer_stop_editing().
 216    *
 217    * Since: 2.4
 218    */
 219   cell_renderer_signals[EDITING_CANCELED] =
 220     g_signal_new (I_("editing-canceled"),
 221                   G_OBJECT_CLASS_TYPE (object_class),
 222                   G_SIGNAL_RUN_FIRST,
 223                   G_STRUCT_OFFSET (GtkCellRendererClass, editing_canceled),
 224                   NULL, NULL,
 225                   _gtk_marshal_VOID__VOID,
 226                   G_TYPE_NONE, 0);
 227
 228   /**
 229    * GtkCellRenderer::editing-started:
 230    * @renderer: the object which received the signal
 231    * @editable: the #GtkCellEditable
 232    * @path: the path identifying the edited cell
 233    *
 234    * This signal gets emitted when a cell starts to be edited.
 235    * The intended use of this signal is to do special setup
 236    * on @editable, e.g. adding a #GtkEntryCompletion or setting
 237    * up additional columns in a #GtkComboBox.
 238    *
 239    * Note that GTK+ doesn't guarantee that cell renderers will
 240    * continue to use the same kind of widget for editing in future
 241    * releases, therefore you should check the type of @editable
 242    * before doing any specific setup, as in the following example:
 243    * |[
 244    * static void
 245    * text_editing_started (GtkCellRenderer *cell,
 246    *                       GtkCellEditable *editable,
 247    *                       const gchar     *path,
 248    *                       gpointer         data)
 249    * {
 250    *   if (GTK_IS_ENTRY (editable))
 251    *     {
 252    *       GtkEntry *entry = GTK_ENTRY (editable);
 253    *
 254    *       /&ast; ... create a GtkEntryCompletion &ast;/
 255    *
 256    *       gtk_entry_set_completion (entry, completion);
 257    *     }
 258    * }
 259    * ]|
 260    *
 261    * Since: 2.6
 262    */
 263   cell_renderer_signals[EDITING_STARTED] =
 264     g_signal_new (I_("editing-started"),
 265                   G_OBJECT_CLASS_TYPE (object_class),
 266                   G_SIGNAL_RUN_FIRST,
 267                   G_STRUCT_OFFSET (GtkCellRendererClass, editing_started),
 268                   NULL, NULL,
 269                   _gtk_marshal_VOID__OBJECT_STRING,
 270                   G_TYPE_NONE, 2,
 271                   GTK_TYPE_CELL_EDITABLE,
 272                   G_TYPE_STRING);
 273
 274   g_object_class_install_property (object_class,
 275                                    PROP_MODE,
 276                                    g_param_spec_enum ("mode",
 277                                                       P_("mode"),
 278                                                       P_("Editable mode of the CellRenderer"),
 279                                                       GTK_TYPE_CELL_RENDERER_MODE,
 280                                                       GTK_CELL_RENDERER_MODE_INERT,
 281                                                       GTK_PARAM_READWRITE));
 282
 283   g_object_class_install_property (object_class,
 284                                    PROP_VISIBLE,
 285                                    g_param_spec_boolean ("visible",
 286                                                          P_("visible"),
 287                                                          P_("Display the cell"),
 288                                                          TRUE,
 289                                                          GTK_PARAM_READWRITE));
 290   g_object_class_install_property (object_class,
 291                                    PROP_SENSITIVE,
 292                                    g_param_spec_boolean ("sensitive",
 293                                                          P_("Sensitive"),
 294                                                          P_("Display the cell sensitive"),
 295                                                          TRUE,
 296                                                          GTK_PARAM_READWRITE));
 297
 298   g_object_class_install_property (object_class,
 299                                    PROP_XALIGN,
 300                                    g_param_spec_float ("xalign",
 301                                                        P_("xalign"),
 302                                                        P_("The x-align"),
 303                                                        0.0,
 304                                                        1.0,
 305                                                        0.5,
 306                                                        GTK_PARAM_READWRITE));
 307
 308   g_object_class_install_property (object_class,
 309                                    PROP_YALIGN,
 310                                    g_param_spec_float ("yalign",
 311                                                        P_("yalign"),
 312                                                        P_("The y-align"),
 313                                                        0.0,
 314                                                        1.0,
 315                                                        0.5,
 316                                                        GTK_PARAM_READWRITE));
 317
 318   g_object_class_install_property (object_class,
 319                                    PROP_XPAD,
 320                                    g_param_spec_uint ("xpad",
 321                                                       P_("xpad"),
 322                                                       P_("The xpad"),
 323                                                       0,
 324                                                       G_MAXUINT,
 325                                                       0,
 326                                                       GTK_PARAM_READWRITE));
 327
 328   g_object_class_install_property (object_class,
 329                                    PROP_YPAD,
 330                                    g_param_spec_uint ("ypad",
 331                                                       P_("ypad"),
 332                                                       P_("The ypad"),
 333                                                       0,
 334                                                       G_MAXUINT,
 335                                                       0,
 336                                                       GTK_PARAM_READWRITE));
 337
 338   g_object_class_install_property (object_class,
 339                                    PROP_WIDTH,
 340                                    g_param_spec_int ("width",
 341                                                      P_("width"),
 342                                                      P_("The fixed width"),
 343                                                      -1,
 344                                                      G_MAXINT,
 345                                                      -1,
 346                                                      GTK_PARAM_READWRITE));
 347
 348   g_object_class_install_property (object_class,
 349                                    PROP_HEIGHT,
 350                                    g_param_spec_int ("height",
 351                                                      P_("height"),
 352                                                      P_("The fixed height"),
 353                                                      -1,
 354                                                      G_MAXINT,
 355                                                      -1,
 356                                                      GTK_PARAM_READWRITE));
 357
 358   g_object_class_install_property (object_class,
 359                                    PROP_IS_EXPANDER,
 360                                    g_param_spec_boolean ("is-expander",
 361                                                          P_("Is Expander"),
 362                                                          P_("Row has children"),
 363                                                          FALSE,
 364                                                          GTK_PARAM_READWRITE));
 365
 366
 367   g_object_class_install_property (object_class,
 368                                    PROP_IS_EXPANDED,
 369                                    g_param_spec_boolean ("is-expanded",
 370                                                          P_("Is Expanded"),
 371                                                          P_("Row is an expander row, and is expanded"),
 372                                                          FALSE,
 373                                                          GTK_PARAM_READWRITE));
 374
 375   g_object_class_install_property (object_class,
 376                                    PROP_CELL_BACKGROUND,
 377                                    g_param_spec_string ("cell-background",
 378                                                         P_("Cell background color name"),
 379                                                         P_("Cell background color as a string"),
 380                                                         NULL,
 381                                                         GTK_PARAM_WRITABLE));
 382
 383   /**
 384    * GtkCellRenderer:cell-background-gdk:
 385    *
 386    * Cell background as a #GdkColor
 387    *
 388    * Deprecated: 3.4: Use #GtkCellRenderer:cell-background-rgba instead.
 389    */
 390   g_object_class_install_property (object_class,
 391                                    PROP_CELL_BACKGROUND_GDK,
 392                                    g_param_spec_boxed ("cell-background-gdk",
 393                                                        P_("Cell background color"),
 394                                                        P_("Cell background color as a GdkColor"),
 395                                                        GDK_TYPE_COLOR,
 396                                                        GTK_PARAM_READWRITE | G_PARAM_DEPRECATED));
 397   /**
 398    * GtkCellRenderer:cell-background-rgba:
 399    *
 400    * Cell background as a #GdkRGBA
 401    *
 402    * Since: 3.0
 403    */
 404   g_object_class_install_property (object_class,
 405                                    PROP_CELL_BACKGROUND_RGBA,
 406                                    g_param_spec_boxed ("cell-background-rgba",
 407                                                        P_("Cell background RGBA color"),
 408                                                        P_("Cell background color as a GdkRGBA"),
 409                                                        GDK_TYPE_RGBA,
 410                                                        GTK_PARAM_READWRITE));
 411
 412   g_object_class_install_property (object_class,
 413                                    PROP_EDITING,
 414                                    g_param_spec_boolean ("editing",
 415                                                          P_("Editing"),
 416                                                          P_("Whether the cell renderer is currently in editing mode"),
 417                                                          FALSE,
 418                                                          GTK_PARAM_READABLE));
 419
 420
 421 #define ADD_SET_PROP(propname, propval, nick, blurb) g_object_class_install_property (object_class, propval, g_param_spec_boolean (propname, nick, blurb, FALSE, GTK_PARAM_READWRITE))
 422
 423   ADD_SET_PROP ("cell-background-set", PROP_CELL_BACKGROUND_SET,
 424                 P_("Cell background set"),
 425                 P_("Whether this tag affects the cell background color"));
 426
 427   g_type_class_add_private (class, sizeof (GtkCellRendererPrivate));
 428
 429   _gtk_cell_renderer_class_set_accessible_type (class, GTK_TYPE_RENDERER_CELL_ACCESSIBLE);
 430 }
 431
 432 static void
 433 gtk_cell_renderer_base_class_init (gpointer g_class)
 434 {
 435   GtkCellRendererClass *klass = g_class;
 436
 437   klass->priv = G_TYPE_CLASS_GET_PRIVATE (g_class, GTK_TYPE_CELL_RENDERER, GtkCellRendererClassPrivate);
 438 }
 439
 440 GType
 441 gtk_cell_renderer_get_type (void)
 442 {
 443   static GType cell_renderer_type = 0;
 444
 445   if (G_UNLIKELY (cell_renderer_type == 0))
 446     {
 447       const GTypeInfo cell_renderer_info =
 448       {
 449         sizeof (GtkCellRendererClass),
 450         gtk_cell_renderer_base_class_init,
 451         NULL,
 452         (GClassInitFunc) gtk_cell_renderer_class_init,
 453         NULL,           /* class_finalize */
 454         NULL,           /* class_init */
 455         sizeof (GtkWidget),
 456         0,              /* n_preallocs */
 457         (GInstanceInitFunc) gtk_cell_renderer_init,
 458         NULL,           /* value_table */
 459       };
 460       cell_renderer_type = g_type_register_static (G_TYPE_INITIALLY_UNOWNED, "GtkCellRenderer",
 461                                                    &cell_renderer_info, G_TYPE_FLAG_ABSTRACT);
 462
 463       g_type_add_class_private (cell_renderer_type, sizeof (GtkCellRendererClassPrivate));
 464     }
 465
 466   return cell_renderer_type;
 467 }
 468
 469 static void
 470 gtk_cell_renderer_get_property (GObject     *object,
 471                                 guint        param_id,
 472                                 GValue      *value,
 473                                 GParamSpec  *pspec)
 474 {
 475   GtkCellRenderer *cell = GTK_CELL_RENDERER (object);
 476   GtkCellRendererPrivate *priv = cell->priv;
 477
 478   switch (param_id)
 479     {
 480     case PROP_MODE:
 481       g_value_set_enum (value, priv->mode);
 482       break;
 483     case PROP_VISIBLE:
 484       g_value_set_boolean (value, priv->visible);
 485       break;
 486     case PROP_SENSITIVE:
 487       g_value_set_boolean (value, priv->sensitive);
 488       break;
 489     case PROP_EDITING:
 490       g_value_set_boolean (value, priv->editing);
 491       break;
 492     case PROP_XALIGN:
 493       g_value_set_float (value, priv->xalign);
 494       break;
 495     case PROP_YALIGN:
 496       g_value_set_float (value, priv->yalign);
 497       break;
 498     case PROP_XPAD:
 499       g_value_set_uint (value, priv->xpad);
 500       break;
 501     case PROP_YPAD:
 502       g_value_set_uint (value, priv->ypad);
 503       break;
 504     case PROP_WIDTH:
 505       g_value_set_int (value, priv->width);
 506       break;
 507     case PROP_HEIGHT:
 508       g_value_set_int (value, priv->height);
 509       break;
 510     case PROP_IS_EXPANDER:
 511       g_value_set_boolean (value, priv->is_expander);
 512       break;
 513     case PROP_IS_EXPANDED:
 514       g_value_set_boolean (value, priv->is_expanded);
 515       break;
 516     case PROP_CELL_BACKGROUND_GDK:
 517       {
 518         GdkColor color;
 519
 520         color.red = (guint16) (priv->cell_background.red * 65535);
 521         color.green = (guint16) (priv->cell_background.green * 65535);
 522         color.blue = (guint16) (priv->cell_background.blue * 65535);
 523
 524         g_value_set_boxed (value, &color);
 525       }
 526       break;
 527     case PROP_CELL_BACKGROUND_RGBA:
 528       g_value_set_boxed (value, &priv->cell_background);
 529       break;
 530     case PROP_CELL_BACKGROUND_SET:
 531       g_value_set_boolean (value, priv->cell_background_set);
 532       break;
 533     case PROP_CELL_BACKGROUND:
 534     default:
 535       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 536       break;
 537     }
 538
 539 }
 540
 541 static void
 542 gtk_cell_renderer_set_property (GObject      *object,
 543                                 guint         param_id,
 544                                 const GValue *value,
 545                                 GParamSpec   *pspec)
 546 {
 547   GtkCellRenderer *cell = GTK_CELL_RENDERER (object);
 548   GtkCellRendererPrivate *priv = cell->priv;
 549
 550   switch (param_id)
 551     {
 552     case PROP_MODE:
 553       priv->mode = g_value_get_enum (value);
 554       break;
 555     case PROP_VISIBLE:
 556       priv->visible = g_value_get_boolean (value);
 557       break;
 558     case PROP_SENSITIVE:
 559       priv->sensitive = g_value_get_boolean (value);
 560       break;
 561     case PROP_EDITING:
 562       priv->editing = g_value_get_boolean (value);
 563       break;
 564     case PROP_XALIGN:
 565       priv->xalign = g_value_get_float (value);
 566       break;
 567     case PROP_YALIGN:
 568       priv->yalign = g_value_get_float (value);
 569       break;
 570     case PROP_XPAD:
 571       priv->xpad = g_value_get_uint (value);
 572       break;
 573     case PROP_YPAD:
 574       priv->ypad = g_value_get_uint (value);
 575       break;
 576     case PROP_WIDTH:
 577       priv->width = g_value_get_int (value);
 578       break;
 579     case PROP_HEIGHT:
 580       priv->height = g_value_get_int (value);
 581       break;
 582     case PROP_IS_EXPANDER:
 583       priv->is_expander = g_value_get_boolean (value);
 584       break;
 585     case PROP_IS_EXPANDED:
 586       priv->is_expanded = g_value_get_boolean (value);
 587       break;
 588     case PROP_CELL_BACKGROUND:
 589       {
 590         GdkRGBA rgba;
 591
 592         if (!g_value_get_string (value))
 593           set_cell_bg_color (cell, NULL);
 594         else if (gdk_rgba_parse (&rgba, g_value_get_string (value)))
 595           set_cell_bg_color (cell, &rgba);
 596         else
 597           g_warning ("Don't know color `%s'", g_value_get_string (value));
 598
 599         g_object_notify (object, "cell-background-gdk");
 600       }
 601       break;
 602     case PROP_CELL_BACKGROUND_GDK:
 603       {
 604         GdkColor *color;
 605
 606         color = g_value_get_boxed (value);
 607         if (color)
 608           {
 609             GdkRGBA rgba;
 610
 611             rgba.red = color->red / 65535.;
 612             rgba.green = color->green / 65535.;
 613             rgba.blue = color->blue / 65535.;
 614             rgba.alpha = 1;
 615
 616             set_cell_bg_color (cell, &rgba);
 617           }
 618         else
 619           {
 620             set_cell_bg_color (cell, NULL);
 621           }
 622       }
 623       break;
 624     case PROP_CELL_BACKGROUND_RGBA:
 625       set_cell_bg_color (cell, g_value_get_boxed (value));
 626       break;
 627     case PROP_CELL_BACKGROUND_SET:
 628       priv->cell_background_set = g_value_get_boolean (value);
 629       break;
 630     default:
 631       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 632       break;
 633     }
 634 }
 635
 636 static void
 637 set_cell_bg_color (GtkCellRenderer *cell,
 638                    GdkRGBA         *rgba)
 639 {
 640   GtkCellRendererPrivate *priv = cell->priv;
 641
 642   if (rgba)
 643     {
 644       if (!priv->cell_background_set)
 645         {
 646           priv->cell_background_set = TRUE;
 647           g_object_notify (G_OBJECT (cell), "cell-background-set");
 648         }
 649
 650       priv->cell_background = *rgba;
 651     }
 652   else
 653     {
 654       if (priv->cell_background_set)
 655         {
 656           priv->cell_background_set = FALSE;
 657           g_object_notify (G_OBJECT (cell), "cell-background-set");
 658         }
 659     }
 660 }
 661
 662 /**
 663  * gtk_cell_renderer_get_size:
 664  * @cell: a #GtkCellRenderer
 665  * @widget: the widget the renderer is rendering to
 666  * @cell_area: (allow-none): The area a cell will be allocated, or %NULL
 667  * @x_offset: (out) (allow-none): location to return x offset of cell relative to @cell_area, or %NULL
 668  * @y_offset: (out) (allow-none): location to return y offset of cell relative to @cell_area, or %NULL
 669  * @width: (out) (allow-none): location to return width needed to render a cell, or %NULL
 670  * @height: (out) (allow-none): location to return height needed to render a cell, or %NULL
 671  *
 672  * Obtains the width and height needed to render the cell. Used by view
 673  * widgets to determine the appropriate size for the cell_area passed to
 674  * gtk_cell_renderer_render().  If @cell_area is not %NULL, fills in the
 675  * x and y offsets (if set) of the cell relative to this location.
 676  *
 677  * Please note that the values set in @width and @height, as well as those
 678  * in @x_offset and @y_offset are inclusive of the xpad and ypad properties.
 679  *
 680  *
 681  * Deprecated: 3.0: Use gtk_cell_renderer_get_preferred_size() instead.
 682  **/
 683 void
 684 gtk_cell_renderer_get_size (GtkCellRenderer    *cell,
 685                             GtkWidget          *widget,
 686                             const GdkRectangle *cell_area,
 687                             gint               *x_offset,
 688                             gint               *y_offset,
 689                             gint               *width,
 690                             gint               *height)
 691 {
 692   GtkRequisition request;
 693
 694   g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
 695
 696   gtk_cell_renderer_get_preferred_size (cell, widget, &request, NULL);
 697
 698   if (width)
 699     *width = request.width;
 700
 701   if (height)
 702     *height = request.height;
 703
 704   if (cell_area)
 705     _gtk_cell_renderer_calc_offset (cell, cell_area, gtk_widget_get_direction (widget),
 706                                     request.width, request.height, x_offset, y_offset);
 707 }
 708
 709 /**
 710  * gtk_cell_renderer_render:
 711  * @cell: a #GtkCellRenderer
 712  * @cr: a cairo context to draw to
 713  * @widget: the widget owning @window
 714  * @background_area: entire cell area (including tree expanders and maybe
 715  *    padding on the sides)
 716  * @cell_area: area normally rendered by a cell renderer
 717  * @flags: flags that affect rendering
 718  *
 719  * Invokes the virtual render function of the #GtkCellRenderer. The three
 720  * passed-in rectangles are areas in @cr. Most renderers will draw within
 721  * @cell_area; the xalign, yalign, xpad, and ypad fields of the #GtkCellRenderer
 722  * should be honored with respect to @cell_area. @background_area includes the
 723  * blank space around the cell, and also the area containing the tree expander;
 724  * so the @background_area rectangles for all cells tile to cover the entire
 725  * @window.
 726  **/
 727 void
 728 gtk_cell_renderer_render (GtkCellRenderer      *cell,
 729                           cairo_t              *cr,
 730                           GtkWidget            *widget,
 731                           const GdkRectangle   *background_area,
 732                           const GdkRectangle   *cell_area,
 733                           GtkCellRendererState  flags)
 734 {
 735   gboolean selected = FALSE;
 736   GtkCellRendererPrivate *priv = cell->priv;
 737   GtkStyleContext *context;
 738   GtkStateFlags state;
 739
 740   g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
 741   g_return_if_fail (GTK_CELL_RENDERER_GET_CLASS (cell)->render != NULL);
 742   g_return_if_fail (cr != NULL);
 743
 744   selected = (flags & GTK_CELL_RENDERER_SELECTED) == GTK_CELL_RENDERER_SELECTED;
 745
 746   cairo_save (cr);
 747
 748   if (priv->cell_background_set && !selected)
 749     {
 750       gdk_cairo_rectangle (cr, background_area);
 751       gdk_cairo_set_source_rgba (cr, &priv->cell_background);
 752       cairo_fill (cr);
 753     }
 754
 755   gdk_cairo_rectangle (cr, background_area);
 756   cairo_clip (cr);
 757
 758   context = gtk_widget_get_style_context (widget);
 759
 760   gtk_style_context_save (context);
 761   gtk_style_context_add_class (context, GTK_STYLE_CLASS_CELL);
 762
 763   state = gtk_cell_renderer_get_state (cell, widget, flags);
 764   gtk_style_context_set_state (context, state);
 765
 766   GTK_CELL_RENDERER_GET_CLASS (cell)->render (cell,
 767                                               cr,
 768                                               widget,
 769                                               background_area,
 770                                               cell_area,
 771                                               flags);
 772   gtk_style_context_restore (context);
 773   cairo_restore (cr);
 774 }
 775
 776 /**
 777  * gtk_cell_renderer_activate:
 778  * @cell: a #GtkCellRenderer
 779  * @event: a #GdkEvent
 780  * @widget: widget that received the event
 781  * @path: widget-dependent string representation of the event location;
 782  *    e.g. for #GtkTreeView, a string representation of #GtkTreePath
 783  * @background_area: background area as passed to gtk_cell_renderer_render()
 784  * @cell_area: cell area as passed to gtk_cell_renderer_render()
 785  * @flags: render flags
 786  *
 787  * Passes an activate event to the cell renderer for possible processing.
 788  * Some cell renderers may use events; for example, #GtkCellRendererToggle
 789  * toggles when it gets a mouse click.
 790  *
 791  * Return value: %TRUE if the event was consumed/handled
 792  **/
 793 gboolean
 794 gtk_cell_renderer_activate (GtkCellRenderer      *cell,
 795                             GdkEvent             *event,
 796                             GtkWidget            *widget,
 797                             const gchar          *path,
 798                             const GdkRectangle   *background_area,
 799                             const GdkRectangle   *cell_area,
 800                             GtkCellRendererState  flags)
 801 {
 802   GtkCellRendererPrivate *priv;
 803
 804   g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), FALSE);
 805
 806   priv = cell->priv;
 807
 808   if (priv->mode != GTK_CELL_RENDERER_MODE_ACTIVATABLE)
 809     return FALSE;
 810
 811   if (GTK_CELL_RENDERER_GET_CLASS (cell)->activate == NULL)
 812     return FALSE;
 813
 814   return GTK_CELL_RENDERER_GET_CLASS (cell)->activate (cell,
 815                                                        event,
 816                                                        widget,
 817                                                        path,
 818                                                        (GdkRectangle *) background_area,
 819                                                        (GdkRectangle *) cell_area,
 820                                                        flags);
 821 }
 822
 823 /**
 824  * gtk_cell_renderer_start_editing:
 825  * @cell: a #GtkCellRenderer
 826  * @event: a #GdkEvent
 827  * @widget: widget that received the event
 828  * @path: widget-dependent string representation of the event location;
 829  *    e.g. for #GtkTreeView, a string representation of #GtkTreePath
 830  * @background_area: background area as passed to gtk_cell_renderer_render()
 831  * @cell_area: cell area as passed to gtk_cell_renderer_render()
 832  * @flags: render flags
 833  *
 834  * Passes an activate event to the cell renderer for possible processing.
 835  *
 836  * Return value: (transfer none): A new #GtkCellEditable, or %NULL
 837  **/
 838 GtkCellEditable *
 839 gtk_cell_renderer_start_editing (GtkCellRenderer      *cell,
 840                                  GdkEvent             *event,
 841                                  GtkWidget            *widget,
 842                                  const gchar          *path,
 843                                  const GdkRectangle   *background_area,
 844                                  const GdkRectangle   *cell_area,
 845                                  GtkCellRendererState  flags)
 846
 847 {
 848   GtkCellRendererPrivate *priv;
 849   GtkCellEditable *editable;
 850
 851   g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), NULL);
 852
 853   priv = cell->priv;
 854
 855   if (priv->mode != GTK_CELL_RENDERER_MODE_EDITABLE)
 856     return NULL;
 857
 858   if (GTK_CELL_RENDERER_GET_CLASS (cell)->start_editing == NULL)
 859     return NULL;
 860
 861   editable = GTK_CELL_RENDERER_GET_CLASS (cell)->start_editing (cell,
 862                                                                 event,
 863                                                                 widget,
 864                                                                 path,
 865                                                                 (GdkRectangle *) background_area,
 866                                                                 (GdkRectangle *) cell_area,
 867                                                                 flags);
 868
 869   g_signal_emit (cell,
 870                  cell_renderer_signals[EDITING_STARTED], 0,
 871                  editable, path);
 872
 873   priv->editing = TRUE;
 874
 875   return editable;
 876 }
 877
 878 /**
 879  * gtk_cell_renderer_set_fixed_size:
 880  * @cell: A #GtkCellRenderer
 881  * @width: the width of the cell renderer, or -1
 882  * @height: the height of the cell renderer, or -1
 883  *
 884  * Sets the renderer size to be explicit, independent of the properties set.
 885  **/
 886 void
 887 gtk_cell_renderer_set_fixed_size (GtkCellRenderer *cell,
 888                                   gint             width,
 889                                   gint             height)
 890 {
 891   GtkCellRendererPrivate *priv;
 892
 893   g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
 894   g_return_if_fail (width >= -1 && height >= -1);
 895
 896   priv = cell->priv;
 897
 898   if ((width != priv->width) || (height != priv->height))
 899     {
 900       g_object_freeze_notify (G_OBJECT (cell));
 901
 902       if (width != priv->width)
 903         {
 904           priv->width = width;
 905           g_object_notify (G_OBJECT (cell), "width");
 906         }
 907
 908       if (height != priv->height)
 909         {
 910           priv->height = height;
 911           g_object_notify (G_OBJECT (cell), "height");
 912         }
 913
 914       g_object_thaw_notify (G_OBJECT (cell));
 915     }
 916 }
 917
 918 /**
 919  * gtk_cell_renderer_get_fixed_size:
 920  * @cell: A #GtkCellRenderer
 921  * @width: (out) (allow-none): location to fill in with the fixed width of the cell, or %NULL
 922  * @height: (out) (allow-none): location to fill in with the fixed height of the cell, or %NULL
 923  *
 924  * Fills in @width and @height with the appropriate size of @cell.
 925  **/
 926 void
 927 gtk_cell_renderer_get_fixed_size (GtkCellRenderer *cell,
 928                                   gint            *width,
 929                                   gint            *height)
 930 {
 931   GtkCellRendererPrivate *priv;
 932
 933   g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
 934
 935   priv = cell->priv;
 936
 937   if (width)
 938     *width = priv->width;
 939   if (height)
 940     *height = priv->height;
 941 }
 942
 943 /**
 944  * gtk_cell_renderer_set_alignment:
 945  * @cell: A #GtkCellRenderer
 946  * @xalign: the x alignment of the cell renderer
 947  * @yalign: the y alignment of the cell renderer
 948  *
 949  * Sets the renderer's alignment within its available space.
 950  *
 951  * Since: 2.18
 952  **/
 953 void
 954 gtk_cell_renderer_set_alignment (GtkCellRenderer *cell,
 955                                  gfloat           xalign,
 956                                  gfloat           yalign)
 957 {
 958   GtkCellRendererPrivate *priv;
 959
 960   g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
 961   g_return_if_fail (xalign >= 0.0 && xalign <= 1.0);
 962   g_return_if_fail (yalign >= 0.0 && yalign <= 1.0);
 963
 964   priv = cell->priv;
 965
 966   if ((xalign != priv->xalign) || (yalign != priv->yalign))
 967     {
 968       g_object_freeze_notify (G_OBJECT (cell));
 969
 970       if (xalign != priv->xalign)
 971         {
 972           priv->xalign = xalign;
 973           g_object_notify (G_OBJECT (cell), "xalign");
 974         }
 975
 976       if (yalign != priv->yalign)
 977         {
 978           priv->yalign = yalign;
 979           g_object_notify (G_OBJECT (cell), "yalign");
 980         }
 981
 982       g_object_thaw_notify (G_OBJECT (cell));
 983     }
 984 }
 985
 986 /**
 987  * gtk_cell_renderer_get_alignment:
 988  * @cell: A #GtkCellRenderer
 989  * @xalign: (out) (allow-none): location to fill in with the x alignment of the cell, or %NULL
 990  * @yalign: (out) (allow-none): location to fill in with the y alignment of the cell, or %NULL
 991  *
 992  * Fills in @xalign and @yalign with the appropriate values of @cell.
 993  *
 994  * Since: 2.18
 995  **/
 996 void
 997 gtk_cell_renderer_get_alignment (GtkCellRenderer *cell,
 998                                  gfloat          *xalign,
 999                                  gfloat          *yalign)
1000 {
1001   GtkCellRendererPrivate *priv;
1002
1003   g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1004
1005   priv = cell->priv;
1006
1007   if (xalign)
1008     *xalign = priv->xalign;
1009   if (yalign)
1010     *yalign = priv->yalign;
1011 }
1012
1013 /**
1014  * gtk_cell_renderer_set_padding:
1015  * @cell: A #GtkCellRenderer
1016  * @xpad: the x padding of the cell renderer
1017  * @ypad: the y padding of the cell renderer
1018  *
1019  * Sets the renderer's padding.
1020  *
1021  * Since: 2.18
1022  **/
1023 void
1024 gtk_cell_renderer_set_padding (GtkCellRenderer *cell,
1025                                gint             xpad,
1026                                gint             ypad)
1027 {
1028   GtkCellRendererPrivate *priv;
1029
1030   g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1031   g_return_if_fail (xpad >= 0 && xpad >= 0);
1032
1033   priv = cell->priv;
1034
1035   if ((xpad != priv->xpad) || (ypad != priv->ypad))
1036     {
1037       g_object_freeze_notify (G_OBJECT (cell));
1038
1039       if (xpad != priv->xpad)
1040         {
1041           priv->xpad = xpad;
1042           g_object_notify (G_OBJECT (cell), "xpad");
1043         }
1044
1045       if (ypad != priv->ypad)
1046         {
1047           priv->ypad = ypad;
1048           g_object_notify (G_OBJECT (cell), "ypad");
1049         }
1050
1051       g_object_thaw_notify (G_OBJECT (cell));
1052     }
1053 }
1054
1055 /**
1056  * gtk_cell_renderer_get_padding:
1057  * @cell: A #GtkCellRenderer
1058  * @xpad: (out) (allow-none): location to fill in with the x padding of the cell, or %NULL
1059  * @ypad: (out) (allow-none): location to fill in with the y padding of the cell, or %NULL
1060  *
1061  * Fills in @xpad and @ypad with the appropriate values of @cell.
1062  *
1063  * Since: 2.18
1064  **/
1065 void
1066 gtk_cell_renderer_get_padding (GtkCellRenderer *cell,
1067                                gint            *xpad,
1068                                gint            *ypad)
1069 {
1070   GtkCellRendererPrivate *priv;
1071
1072   g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1073
1074   priv = cell->priv;
1075
1076   if (xpad)
1077     *xpad = priv->xpad;
1078   if (ypad)
1079     *ypad = priv->ypad;
1080 }
1081
1082 /**
1083  * gtk_cell_renderer_set_visible:
1084  * @cell: A #GtkCellRenderer
1085  * @visible: the visibility of the cell
1086  *
1087  * Sets the cell renderer's visibility.
1088  *
1089  * Since: 2.18
1090  **/
1091 void
1092 gtk_cell_renderer_set_visible (GtkCellRenderer *cell,
1093                                gboolean         visible)
1094 {
1095   GtkCellRendererPrivate *priv;
1096
1097   g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1098
1099   priv = cell->priv;
1100
1101   if (priv->visible != visible)
1102     {
1103       priv->visible = visible ? TRUE : FALSE;
1104       g_object_notify (G_OBJECT (cell), "visible");
1105     }
1106 }
1107
1108 /**
1109  * gtk_cell_renderer_get_visible:
1110  * @cell: A #GtkCellRenderer
1111  *
1112  * Returns the cell renderer's visibility.
1113  *
1114  * Returns: %TRUE if the cell renderer is visible
1115  *
1116  * Since: 2.18
1117  */
1118 gboolean
1119 gtk_cell_renderer_get_visible (GtkCellRenderer *cell)
1120 {
1121   g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), FALSE);
1122
1123   return cell->priv->visible;
1124 }
1125
1126 /**
1127  * gtk_cell_renderer_set_sensitive:
1128  * @cell: A #GtkCellRenderer
1129  * @sensitive: the sensitivity of the cell
1130  *
1131  * Sets the cell renderer's sensitivity.
1132  *
1133  * Since: 2.18
1134  **/
1135 void
1136 gtk_cell_renderer_set_sensitive (GtkCellRenderer *cell,
1137                                  gboolean         sensitive)
1138 {
1139   GtkCellRendererPrivate *priv;
1140
1141   g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1142
1143   priv = cell->priv;
1144
1145   if (priv->sensitive != sensitive)
1146     {
1147       priv->sensitive = sensitive ? TRUE : FALSE;
1148       g_object_notify (G_OBJECT (cell), "sensitive");
1149     }
1150 }
1151
1152 /**
1153  * gtk_cell_renderer_get_sensitive:
1154  * @cell: A #GtkCellRenderer
1155  *
1156  * Returns the cell renderer's sensitivity.
1157  *
1158  * Returns: %TRUE if the cell renderer is sensitive
1159  *
1160  * Since: 2.18
1161  */
1162 gboolean
1163 gtk_cell_renderer_get_sensitive (GtkCellRenderer *cell)
1164 {
1165   g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), FALSE);
1166
1167   return cell->priv->sensitive;
1168 }
1169
1170
1171 /**
1172  * gtk_cell_renderer_is_activatable:
1173  * @cell: A #GtkCellRenderer
1174  *
1175  * Checks whether the cell renderer can do something when activated.
1176  *
1177  * Returns: %TRUE if the cell renderer can do anything when activated
1178  *
1179  * Since: 3.0
1180  */
1181 gboolean
1182 gtk_cell_renderer_is_activatable (GtkCellRenderer *cell)
1183 {
1184   GtkCellRendererPrivate *priv;
1185
1186   g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), FALSE);
1187
1188   priv = cell->priv;
1189
1190   return (priv->visible &&
1191           (priv->mode == GTK_CELL_RENDERER_MODE_EDITABLE ||
1192            priv->mode == GTK_CELL_RENDERER_MODE_ACTIVATABLE));
1193 }
1194
1195
1196 /**
1197  * gtk_cell_renderer_stop_editing:
1198  * @cell: A #GtkCellRenderer
1199  * @canceled: %TRUE if the editing has been canceled
1200  *
1201  * Informs the cell renderer that the editing is stopped.
1202  * If @canceled is %TRUE, the cell renderer will emit the
1203  * #GtkCellRenderer::editing-canceled signal.
1204  *
1205  * This function should be called by cell renderer implementations
1206  * in response to the #GtkCellEditable::editing-done signal of
1207  * #GtkCellEditable.
1208  *
1209  * Since: 2.6
1210  **/
1211 void
1212 gtk_cell_renderer_stop_editing (GtkCellRenderer *cell,
1213                                 gboolean         canceled)
1214 {
1215   GtkCellRendererPrivate *priv;
1216
1217   g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1218
1219   priv = cell->priv;
1220
1221   if (priv->editing)
1222     {
1223       priv->editing = FALSE;
1224       if (canceled)
1225         g_signal_emit (cell, cell_renderer_signals[EDITING_CANCELED], 0);
1226     }
1227 }
1228
1229 static void
1230 gtk_cell_renderer_real_get_preferred_size (GtkCellRenderer   *cell,
1231                                            GtkWidget         *widget,
1232                                            GtkOrientation     orientation,
1233                                            gint              *minimum_size,
1234                                            gint              *natural_size)
1235 {
1236   GtkRequisition min_req;
1237
1238   /* Fallback on the old API to get the size. */
1239   if (GTK_CELL_RENDERER_GET_CLASS (cell)->get_size)
1240     GTK_CELL_RENDERER_GET_CLASS (cell)->get_size (GTK_CELL_RENDERER (cell), widget, NULL, NULL, NULL,
1241                                                   &min_req.width, &min_req.height);
1242   else
1243     {
1244       min_req.width = 0;
1245       min_req.height = 0;
1246     }
1247
1248   if (orientation == GTK_ORIENTATION_HORIZONTAL)
1249     {
1250       if (minimum_size)
1251         *minimum_size = min_req.width;
1252
1253       if (natural_size)
1254         *natural_size = min_req.width;
1255     }
1256   else
1257     {
1258       if (minimum_size)
1259         *minimum_size = min_req.height;
1260
1261       if (natural_size)
1262         *natural_size = min_req.height;
1263     }
1264 }
1265
1266 static GtkSizeRequestMode
1267 gtk_cell_renderer_real_get_request_mode (GtkCellRenderer *cell)
1268 {
1269   /* By default cell renderers are height-for-width. */
1270   return GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH;
1271 }
1272
1273 static void
1274 gtk_cell_renderer_real_get_preferred_width (GtkCellRenderer *cell,
1275                                             GtkWidget       *widget,
1276                                             gint            *minimum_size,
1277                                             gint            *natural_size)
1278 {
1279   gtk_cell_renderer_real_get_preferred_size (cell, widget, GTK_ORIENTATION_HORIZONTAL,
1280                                              minimum_size, natural_size);
1281 }
1282
1283 static void
1284 gtk_cell_renderer_real_get_preferred_height (GtkCellRenderer *cell,
1285                                              GtkWidget       *widget,
1286                                              gint            *minimum_size,
1287                                              gint            *natural_size)
1288 {
1289   gtk_cell_renderer_real_get_preferred_size (cell, widget, GTK_ORIENTATION_VERTICAL,
1290                                              minimum_size, natural_size);
1291 }
1292
1293
1294 static void
1295 gtk_cell_renderer_real_get_preferred_height_for_width (GtkCellRenderer *cell,
1296                                                        GtkWidget       *widget,
1297                                                        gint             width,
1298                                                        gint            *minimum_height,
1299                                                        gint            *natural_height)
1300 {
1301   /* Fall back on the height reported from ->get_size() */
1302   gtk_cell_renderer_get_preferred_height (cell, widget, minimum_height, natural_height);
1303 }
1304
1305 static void
1306 gtk_cell_renderer_real_get_preferred_width_for_height (GtkCellRenderer *cell,
1307                                                        GtkWidget       *widget,
1308                                                        gint             height,
1309                                                        gint            *minimum_width,
1310                                                        gint            *natural_width)
1311 {
1312   /* Fall back on the width reported from ->get_size() */
1313   gtk_cell_renderer_get_preferred_width (cell, widget, minimum_width, natural_width);
1314 }
1315
1316
1317 /* Default implementation assumes that a cell renderer will never use more
1318  * space than its natural size (this is fine for toggles and pixbufs etc
1319  * but needs to be overridden from wrapping/ellipsizing text renderers) */
1320 static void
1321 gtk_cell_renderer_real_get_aligned_area (GtkCellRenderer         *cell,
1322                                          GtkWidget               *widget,
1323                                          GtkCellRendererState     flags,
1324                                          const GdkRectangle      *cell_area,
1325                                          GdkRectangle            *aligned_area)
1326 {
1327   gint opposite_size, x_offset, y_offset;
1328   gint natural_size;
1329
1330   g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1331   g_return_if_fail (GTK_IS_WIDGET (widget));
1332   g_return_if_fail (cell_area != NULL);
1333   g_return_if_fail (aligned_area != NULL);
1334
1335   *aligned_area = *cell_area;
1336
1337   /* Trim up the aligned size */
1338   if (gtk_cell_renderer_get_request_mode (cell) == GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH)
1339     {
1340       gtk_cell_renderer_get_preferred_width (cell, widget,
1341                                              NULL, &natural_size);
1342
1343       aligned_area->width = MIN (aligned_area->width, natural_size);
1344
1345       gtk_cell_renderer_get_preferred_height_for_width (cell, widget,
1346                                                         aligned_area->width,
1347                                                         NULL, &opposite_size);
1348
1349       aligned_area->height = MIN (opposite_size, aligned_area->height);
1350     }
1351   else
1352     {
1353       gtk_cell_renderer_get_preferred_height (cell, widget,
1354                                               NULL, &natural_size);
1355
1356       aligned_area->height = MIN (aligned_area->width, natural_size);
1357
1358       gtk_cell_renderer_get_preferred_width_for_height (cell, widget,
1359                                                         aligned_area->height,
1360                                                         NULL, &opposite_size);
1361
1362       aligned_area->width = MIN (opposite_size, aligned_area->width);
1363     }
1364
1365   /* offset the cell position */
1366   _gtk_cell_renderer_calc_offset (cell, cell_area,
1367                                   gtk_widget_get_direction (widget),
1368                                   aligned_area->width,
1369                                   aligned_area->height,
1370                                   &x_offset, &y_offset);
1371
1372   aligned_area->x += x_offset;
1373   aligned_area->y += y_offset;
1374 }
1375
1376
1377 /* An internal convenience function for some containers to peek at the
1378  * cell alignment in a target allocation (used to draw focus and align
1379  * cells in the icon view).
1380  *
1381  * Note this is only a trivial 'align * (allocation - request)' operation.
1382  */
1383 void
1384 _gtk_cell_renderer_calc_offset    (GtkCellRenderer      *cell,
1385                                    const GdkRectangle   *cell_area,
1386                                    GtkTextDirection      direction,
1387                                    gint                  width,
1388                                    gint                  height,
1389                                    gint                 *x_offset,
1390                                    gint                 *y_offset)
1391 {
1392   GtkCellRendererPrivate *priv;
1393
1394   g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1395   g_return_if_fail (cell_area != NULL);
1396   g_return_if_fail (x_offset || y_offset);
1397
1398   priv = cell->priv;
1399
1400   if (x_offset)
1401     {
1402       *x_offset = (((direction == GTK_TEXT_DIR_RTL) ?
1403                     (1.0 - priv->xalign) : priv->xalign) *
1404                    (cell_area->width - width));
1405       *x_offset = MAX (*x_offset, 0);
1406     }
1407   if (y_offset)
1408     {
1409       *y_offset = (priv->yalign *
1410                    (cell_area->height - height));
1411       *y_offset = MAX (*y_offset, 0);
1412     }
1413 }
1414
1415 /**
1416  * gtk_cell_renderer_get_request_mode:
1417  * @cell: a #GtkCellRenderer    instance
1418  *
1419  * Gets whether the cell renderer prefers a height-for-width layout
1420  * or a width-for-height layout.
1421  *
1422  * Returns: The #GtkSizeRequestMode preferred by this renderer.
1423  *
1424  * Since: 3.0
1425  */
1426 GtkSizeRequestMode
1427 gtk_cell_renderer_get_request_mode (GtkCellRenderer *cell)
1428 {
1429   g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), FALSE);
1430
1431   return GTK_CELL_RENDERER_GET_CLASS (cell)->get_request_mode (cell);
1432 }
1433
1434 /**
1435  * gtk_cell_renderer_get_preferred_width:
1436  * @cell: a #GtkCellRenderer instance
1437  * @widget: the #GtkWidget this cell will be rendering to
1438  * @minimum_size: (out) (allow-none): location to store the minimum size, or %NULL
1439  * @natural_size: (out) (allow-none): location to store the natural size, or %NULL
1440  *
1441  * Retreives a renderer's natural size when rendered to @widget.
1442  *
1443  * Since: 3.0
1444  */
1445 void
1446 gtk_cell_renderer_get_preferred_width (GtkCellRenderer *cell,
1447                                        GtkWidget       *widget,
1448                                        gint            *minimum_size,
1449                                        gint            *natural_size)
1450 {
1451   GtkCellRendererClass *klass;
1452   gint width;
1453
1454   g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1455   g_return_if_fail (GTK_IS_WIDGET (widget));
1456   g_return_if_fail (NULL != minimum_size || NULL != natural_size);
1457
1458   gtk_cell_renderer_get_fixed_size (GTK_CELL_RENDERER (cell), &width, NULL);
1459
1460   if (width < 0)
1461     {
1462       klass = GTK_CELL_RENDERER_GET_CLASS (cell);
1463       klass->get_preferred_width (cell, widget, minimum_size, natural_size);
1464     }
1465   else
1466     {
1467       if (minimum_size)
1468         *minimum_size = width;
1469       if (natural_size)
1470         *natural_size = width;
1471     }
1472
1473 #if DEBUG_CELL_SIZE_REQUEST
1474   g_message ("%s returning minimum width: %d and natural width: %d",
1475              G_OBJECT_TYPE_NAME (cell),
1476              minimum_size ? *minimum_size : 20000,
1477              natural_size ? *natural_size : 20000);
1478 #endif
1479 }
1480
1481
1482 /**
1483  * gtk_cell_renderer_get_preferred_height:
1484  * @cell: a #GtkCellRenderer instance
1485  * @widget: the #GtkWidget this cell will be rendering to
1486  * @minimum_size: (out) (allow-none): location to store the minimum size, or %NULL
1487  * @natural_size: (out) (allow-none): location to store the natural size, or %NULL
1488  *
1489  * Retreives a renderer's natural size when rendered to @widget.
1490  *
1491  * Since: 3.0
1492  */
1493 void
1494 gtk_cell_renderer_get_preferred_height (GtkCellRenderer *cell,
1495                                         GtkWidget       *widget,
1496                                         gint            *minimum_size,
1497                                         gint            *natural_size)
1498 {
1499   GtkCellRendererClass *klass;
1500   gint height;
1501
1502   g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1503   g_return_if_fail (GTK_IS_WIDGET (widget));
1504   g_return_if_fail (NULL != minimum_size || NULL != natural_size);
1505
1506   gtk_cell_renderer_get_fixed_size (GTK_CELL_RENDERER (cell), NULL, &height);
1507
1508   if (height < 0)
1509     {
1510       klass = GTK_CELL_RENDERER_GET_CLASS (cell);
1511       klass->get_preferred_height (cell, widget, minimum_size, natural_size);
1512     }
1513   else
1514     {
1515       if (minimum_size)
1516         *minimum_size = height;
1517       if (natural_size)
1518         *natural_size = height;
1519     }
1520
1521 #if DEBUG_CELL_SIZE_REQUEST
1522   g_message ("%s returning minimum height: %d and natural height: %d",
1523              G_OBJECT_TYPE_NAME (cell),
1524              minimum_size ? *minimum_size : 20000,
1525              natural_size ? *natural_size : 20000);
1526 #endif
1527 }
1528
1529
1530 /**
1531  * gtk_cell_renderer_get_preferred_width_for_height:
1532  * @cell: a #GtkCellRenderer instance
1533  * @widget: the #GtkWidget this cell will be rendering to
1534  * @height: the size which is available for allocation
1535  * @minimum_width: (out) (allow-none): location for storing the minimum size, or %NULL
1536  * @natural_width: (out) (allow-none): location for storing the preferred size, or %NULL
1537  *
1538  * Retreives a cell renderers's minimum and natural width if it were rendered to
1539  * @widget with the specified @height.
1540  *
1541  * Since: 3.0
1542  */
1543 void
1544 gtk_cell_renderer_get_preferred_width_for_height (GtkCellRenderer *cell,
1545                                                   GtkWidget       *widget,
1546                                                   gint             height,
1547                                                   gint            *minimum_width,
1548                                                   gint            *natural_width)
1549 {
1550   GtkCellRendererClass *klass;
1551   gint width;
1552
1553   g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1554   g_return_if_fail (GTK_IS_WIDGET (widget));
1555   g_return_if_fail (NULL != minimum_width || NULL != natural_width);
1556
1557   gtk_cell_renderer_get_fixed_size (GTK_CELL_RENDERER (cell), &width, NULL);
1558
1559   if (width < 0)
1560     {
1561       klass = GTK_CELL_RENDERER_GET_CLASS (cell);
1562       klass->get_preferred_width_for_height (cell, widget, height, minimum_width, natural_width);
1563     }
1564   else
1565     {
1566       if (minimum_width)
1567         *minimum_width = width;
1568       if (natural_width)
1569         *natural_width = width;
1570     }
1571
1572 #if DEBUG_CELL_SIZE_REQUEST
1573   g_message ("%s width for height: %d is minimum %d and natural: %d",
1574              G_OBJECT_TYPE_NAME (cell), height,
1575              minimum_width ? *minimum_width : 20000,
1576              natural_width ? *natural_width : 20000);
1577 #endif
1578 }
1579
1580 /**
1581  * gtk_cell_renderer_get_preferred_height_for_width:
1582  * @cell: a #GtkCellRenderer instance
1583  * @widget: the #GtkWidget this cell will be rendering to
1584  * @width: the size which is available for allocation
1585  * @minimum_height: (out) (allow-none): location for storing the minimum size, or %NULL
1586  * @natural_height: (out) (allow-none): location for storing the preferred size, or %NULL
1587  *
1588  * Retreives a cell renderers's minimum and natural height if it were rendered to
1589  * @widget with the specified @width.
1590  *
1591  * Since: 3.0
1592  */
1593 void
1594 gtk_cell_renderer_get_preferred_height_for_width (GtkCellRenderer *cell,
1595                                                   GtkWidget       *widget,
1596                                                   gint             width,
1597                                                   gint            *minimum_height,
1598                                                   gint            *natural_height)
1599 {
1600   GtkCellRendererClass *klass;
1601   gint height;
1602
1603   g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1604   g_return_if_fail (GTK_IS_WIDGET (widget));
1605   g_return_if_fail (NULL != minimum_height || NULL != natural_height);
1606
1607   gtk_cell_renderer_get_fixed_size (GTK_CELL_RENDERER (cell), NULL, &height);
1608
1609   if (height < 0)
1610     {
1611       klass = GTK_CELL_RENDERER_GET_CLASS (cell);
1612       klass->get_preferred_height_for_width (cell, widget, width, minimum_height, natural_height);
1613     }
1614   else
1615     {
1616       if (minimum_height)
1617         *minimum_height = height;
1618       if (natural_height)
1619         *natural_height = height;
1620     }
1621
1622 #if DEBUG_CELL_SIZE_REQUEST
1623   g_message ("%s height for width: %d is minimum %d and natural: %d",
1624              G_OBJECT_TYPE_NAME (cell), width,
1625              minimum_height ? *minimum_height : 20000,
1626              natural_height ? *natural_height : 20000);
1627 #endif
1628 }
1629
1630 /**
1631  * gtk_cell_renderer_get_preferred_size:
1632  * @cell: a #GtkCellRenderer instance
1633  * @widget: the #GtkWidget this cell will be rendering to
1634  * @minimum_size: (out) (allow-none): location for storing the minimum size, or %NULL
1635  * @natural_size: (out) (allow-none): location for storing the natural size, or %NULL
1636  *
1637  * Retrieves the minimum and natural size of a cell taking
1638  * into account the widget's preference for height-for-width management.
1639  *
1640  * Since: 3.0
1641  */
1642 void
1643 gtk_cell_renderer_get_preferred_size (GtkCellRenderer *cell,
1644                                       GtkWidget       *widget,
1645                                       GtkRequisition  *minimum_size,
1646                                       GtkRequisition  *natural_size)
1647 {
1648   gint min_width, nat_width;
1649   gint min_height, nat_height;
1650
1651   g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1652
1653   if (gtk_cell_renderer_get_request_mode (cell) == GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH)
1654     {
1655       gtk_cell_renderer_get_preferred_width (cell, widget, &min_width, &nat_width);
1656
1657       if (minimum_size)
1658         {
1659           minimum_size->width = min_width;
1660           gtk_cell_renderer_get_preferred_height_for_width (cell, widget, min_width,
1661                                                             &minimum_size->height, NULL);
1662         }
1663
1664       if (natural_size)
1665         {
1666           natural_size->width = nat_width;
1667           gtk_cell_renderer_get_preferred_height_for_width (cell, widget, nat_width,
1668                                                             NULL, &natural_size->height);
1669         }
1670     }
1671   else /* GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT */
1672     {
1673       gtk_cell_renderer_get_preferred_height (cell, widget, &min_height, &nat_height);
1674
1675       if (minimum_size)
1676         {
1677           minimum_size->height = min_height;
1678           gtk_cell_renderer_get_preferred_width_for_height (cell, widget, min_height,
1679                                                             &minimum_size->width, NULL);
1680         }
1681
1682       if (natural_size)
1683         {
1684           natural_size->height = nat_height;
1685           gtk_cell_renderer_get_preferred_width_for_height (cell, widget, nat_height,
1686                                                             NULL, &natural_size->width);
1687         }
1688     }
1689 }
1690
1691 /**
1692  * gtk_cell_renderer_get_aligned_area:
1693  * @cell: a #GtkCellRenderer instance
1694  * @widget: the #GtkWidget this cell will be rendering to
1695  * @flags: render flags
1696  * @cell_area: cell area which would be passed to gtk_cell_renderer_render()
1697  * @aligned_area: (out): the return location for the space inside @cell_area
1698  *                that would acually be used to render.
1699  *
1700  * Gets the aligned area used by @cell inside @cell_area. Used for finding
1701  * the appropriate edit and focus rectangle.
1702  *
1703  * Since: 3.0
1704  */
1705 void
1706 gtk_cell_renderer_get_aligned_area (GtkCellRenderer      *cell,
1707                                     GtkWidget            *widget,
1708                                     GtkCellRendererState  flags,
1709                                     const GdkRectangle   *cell_area,
1710                                     GdkRectangle         *aligned_area)
1711 {
1712   GtkCellRendererClass *klass;
1713
1714   g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1715   g_return_if_fail (GTK_IS_WIDGET (widget));
1716   g_return_if_fail (cell_area != NULL);
1717   g_return_if_fail (aligned_area != NULL);
1718
1719   klass = GTK_CELL_RENDERER_GET_CLASS (cell);
1720   klass->get_aligned_area (cell, widget, flags, cell_area, aligned_area);
1721
1722   g_assert (aligned_area->x >= cell_area->x && aligned_area->x <= cell_area->x + cell_area->width);
1723   g_assert (aligned_area->y >= cell_area->y && aligned_area->y <= cell_area->y + cell_area->height);
1724   g_assert ((aligned_area->x - cell_area->x) + aligned_area->width <= cell_area->width);
1725   g_assert ((aligned_area->y - cell_area->y) + aligned_area->height <= cell_area->height);
1726 }
1727
1728 /**
1729  * gtk_cell_renderer_get_state:
1730  * @cell: a #GtkCellRenderer, or %NULL
1731  * @widget: a #GtkWidget, or %NULL
1732  * @cell_state: cell renderer state
1733  *
1734  * Translates the cell renderer state to #GtkStateFlags,
1735  * based on the cell renderer and widget sensitivity, and
1736  * the given #GtkCellRendererState.
1737  *
1738  * Returns: the widget state flags applying to @cell
1739  *
1740  * Since: 3.0
1741  **/
1742 GtkStateFlags
1743 gtk_cell_renderer_get_state (GtkCellRenderer      *cell,
1744                              GtkWidget            *widget,
1745                              GtkCellRendererState  cell_state)
1746 {
1747   GtkStateFlags state = 0;
1748
1749   g_return_val_if_fail (!cell || GTK_IS_CELL_RENDERER (cell), 0);
1750   g_return_val_if_fail (!widget || GTK_IS_WIDGET (widget), 0);
1751
1752   if (widget)
1753     state |= gtk_widget_get_state_flags (widget);
1754
1755   state &= ~(GTK_STATE_FLAG_FOCUSED | GTK_STATE_FLAG_PRELIGHT | GTK_STATE_FLAG_SELECTED);
1756
1757   if ((state & GTK_STATE_FLAG_INSENSITIVE) != 0 ||
1758       (cell && !gtk_cell_renderer_get_sensitive (cell)) ||
1759       (cell_state & GTK_CELL_RENDERER_INSENSITIVE) != 0)
1760     {
1761       state |= GTK_STATE_FLAG_INSENSITIVE;
1762     }
1763   else
1764     {
1765       if ((widget && gtk_widget_has_focus (widget)) &&
1766           (cell_state & GTK_CELL_RENDERER_FOCUSED) != 0)
1767         state |= GTK_STATE_FLAG_FOCUSED;
1768
1769       if ((cell_state & GTK_CELL_RENDERER_PRELIT) != 0)
1770         state |= GTK_STATE_FLAG_PRELIGHT;
1771     }
1772
1773   if ((cell_state & GTK_CELL_RENDERER_SELECTED) != 0)
1774     state |= GTK_STATE_FLAG_SELECTED;
1775
1776   return state;
1777 }
1778
1779 /*
1780  * _gtk_cell_renderer_class_set_accessible_type:
1781  * @renderer_class: class to set the accessible type for
1782  * @type: The object type that implements the accessible for @widget_class.
1783  *     The type must be a subtype of #GtkRendererCellAccessible
1784  *
1785  * Sets the type to be used for creating accessibles for cells rendered by
1786  * cell renderers of @renderer_class. Note that multiple accessibles will
1787  * be created.
1788  *
1789  * This function should only be called from class init functions of cell
1790  * renderers.
1791  **/
1792 void
1793 _gtk_cell_renderer_class_set_accessible_type (GtkCellRendererClass *renderer_class,
1794                                               GType                 type)
1795 {
1796   GtkCellRendererClassPrivate *priv;
1797
1798   g_return_if_fail (GTK_IS_CELL_RENDERER_CLASS (renderer_class));
1799   g_return_if_fail (g_type_is_a (type, GTK_TYPE_RENDERER_CELL_ACCESSIBLE));
1800
1801   priv = renderer_class->priv;
1802
1803   priv->accessible_type = type;
1804 }
1805
1806 GType
1807 _gtk_cell_renderer_get_accessible_type (GtkCellRenderer *renderer)
1808 {
1809   g_return_val_if_fail (GTK_IS_CELL_RENDERER (renderer), GTK_TYPE_RENDERER_CELL_ACCESSIBLE);
1810
1811   return GTK_CELL_RENDERER_GET_CLASS (renderer)->priv->accessible_type;
1812 }
1813