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

   1 /* gtkellview.c
   2  * Copyright (C) 2002, 2003  Kristian Rietveld <kris@gtk.org>
   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 <string.h>
  22 #include "gtkcellview.h"
  23 #include "gtkcelllayout.h"
  24 #include "gtkcellareabox.h"
  25 #include "gtkintl.h"
  26 #include "gtkcellrenderertext.h"
  27 #include "gtkcellrendererpixbuf.h"
  28 #include "gtkprivate.h"
  29 #include "gtksizerequest.h"
  30 #include <gobject/gmarshal.h>
  31 #include "gtkbuildable.h"
  32
  33
  34 /**
  35  * SECTION:gtkcellview
  36  * @Short_description: A widget displaying a single row of a GtkTreeModel
  37  * @Title: GtkCellView
  38  *
  39  * A #GtkCellView displays a single row of a #GtkTreeModel, using
  40  * cell renderers just like #GtkTreeView. #GtkCellView doesn't support
  41  * some of the more complex features of #GtkTreeView, like cell editing
  42  * and drag and drop.
  43  */
  44
  45 struct _GtkCellViewPrivate
  46 {
  47   GtkTreeModel        *model;
  48   GtkTreeRowReference *displayed_row;
  49
  50   GtkCellArea         *area;
  51   GtkCellAreaContext  *context;
  52
  53   GdkRGBA              background;
  54   gboolean             background_set;
  55
  56   gulong               size_changed_id;
  57   gulong               row_changed_id;
  58 };
  59
  60
  61 static GObject    *gtk_cell_view_constructor              (GType                  type,
  62                                                            guint                  n_construct_properties,
  63                                                            GObjectConstructParam *construct_properties);
  64 static void        gtk_cell_view_get_property             (GObject           *object,
  65                                                            guint             param_id,
  66                                                            GValue           *value,
  67                                                            GParamSpec       *pspec);
  68 static void        gtk_cell_view_set_property             (GObject          *object,
  69                                                            guint             param_id,
  70                                                            const GValue     *value,
  71                                                            GParamSpec       *pspec);
  72 static void        gtk_cell_view_finalize                 (GObject          *object);
  73 static void        gtk_cell_view_dispose                  (GObject          *object);
  74 static void        gtk_cell_view_size_allocate            (GtkWidget        *widget,
  75                                                            GtkAllocation    *allocation);
  76 static gboolean    gtk_cell_view_draw                     (GtkWidget        *widget,
  77                                                            cairo_t          *cr);
  78 static void        gtk_cell_view_set_value                (GtkCellView     *cell_view,
  79                                                            GtkCellRenderer *renderer,
  80                                                            gchar           *property,
  81                                                            GValue          *value);
  82 static void        gtk_cell_view_set_cell_data            (GtkCellView      *cell_view);
  83
  84 /* celllayout */
  85 static void        gtk_cell_view_cell_layout_init         (GtkCellLayoutIface *iface);
  86 static GtkCellArea *gtk_cell_view_cell_layout_get_area         (GtkCellLayout         *layout);
  87
  88
  89 /* buildable */
  90 static void       gtk_cell_view_buildable_init                 (GtkBuildableIface     *iface);
  91 static gboolean   gtk_cell_view_buildable_custom_tag_start     (GtkBuildable          *buildable,
  92                                                                 GtkBuilder            *builder,
  93                                                                 GObject               *child,
  94                                                                 const gchar           *tagname,
  95                                                                 GMarkupParser         *parser,
  96                                                                 gpointer              *data);
  97 static void       gtk_cell_view_buildable_custom_tag_end       (GtkBuildable          *buildable,
  98                                                                 GtkBuilder            *builder,
  99                                                                 GObject               *child,
 100                                                                 const gchar           *tagname,
 101                                                                 gpointer              *data);
 102
 103 static void       gtk_cell_view_get_preferred_width            (GtkWidget             *widget,
 104                                                                 gint                  *minimum_size,
 105                                                                 gint                  *natural_size);
 106 static void       gtk_cell_view_get_preferred_height           (GtkWidget             *widget,
 107                                                                 gint                  *minimum_size,
 108                                                                 gint                  *natural_size);
 109 static void       gtk_cell_view_get_preferred_width_for_height (GtkWidget             *widget,
 110                                                                 gint                   avail_size,
 111                                                                 gint                  *minimum_size,
 112                                                                 gint                  *natural_size);
 113 static void       gtk_cell_view_get_preferred_height_for_width (GtkWidget             *widget,
 114                                                                 gint                   avail_size,
 115                                                                 gint                  *minimum_size,
 116                                                                 gint                  *natural_size);
 117
 118 static void       context_size_changed_cb                      (GtkCellAreaContext   *context,
 119                                                                 GParamSpec           *pspec,
 120                                                                 GtkWidget            *view);
 121 static void       row_changed_cb                               (GtkTreeModel         *model,
 122                                                                 GtkTreePath          *path,
 123                                                                 GtkTreeIter          *iter,
 124                                                                 GtkCellView          *view);
 125
 126 static GtkBuildableIface *parent_buildable_iface;
 127
 128 enum
 129 {
 130   PROP_0,
 131   PROP_BACKGROUND,
 132   PROP_BACKGROUND_GDK,
 133   PROP_BACKGROUND_RGBA,
 134   PROP_BACKGROUND_SET,
 135   PROP_MODEL,
 136   PROP_CELL_AREA,
 137   PROP_CELL_AREA_CONTEXT
 138 };
 139
 140 G_DEFINE_TYPE_WITH_CODE (GtkCellView, gtk_cell_view, GTK_TYPE_WIDGET,
 141                          G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_LAYOUT,
 142                                                 gtk_cell_view_cell_layout_init)
 143                          G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
 144                                                 gtk_cell_view_buildable_init))
 145
 146
 147 static void
 148 gtk_cell_view_class_init (GtkCellViewClass *klass)
 149 {
 150   GObjectClass   *gobject_class = G_OBJECT_CLASS (klass);
 151   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
 152
 153   gobject_class->constructor = gtk_cell_view_constructor;
 154   gobject_class->get_property = gtk_cell_view_get_property;
 155   gobject_class->set_property = gtk_cell_view_set_property;
 156   gobject_class->finalize = gtk_cell_view_finalize;
 157   gobject_class->dispose = gtk_cell_view_dispose;
 158
 159   widget_class->draw                           = gtk_cell_view_draw;
 160   widget_class->size_allocate                  = gtk_cell_view_size_allocate;
 161   widget_class->get_preferred_width            = gtk_cell_view_get_preferred_width;
 162   widget_class->get_preferred_height           = gtk_cell_view_get_preferred_height;
 163   widget_class->get_preferred_width_for_height = gtk_cell_view_get_preferred_width_for_height;
 164   widget_class->get_preferred_height_for_width = gtk_cell_view_get_preferred_height_for_width;
 165
 166   /* properties */
 167   g_object_class_install_property (gobject_class,
 168                                    PROP_BACKGROUND,
 169                                    g_param_spec_string ("background",
 170                                                         P_("Background color name"),
 171                                                         P_("Background color as a string"),
 172                                                         NULL,
 173                                                         GTK_PARAM_WRITABLE));
 174   g_object_class_install_property (gobject_class,
 175                                    PROP_BACKGROUND_GDK,
 176                                    g_param_spec_boxed ("background-gdk",
 177                                                       P_("Background color"),
 178                                                       P_("Background color as a GdkColor"),
 179                                                       GDK_TYPE_COLOR,
 180                                                       GTK_PARAM_READWRITE));
 181   /**
 182    * GtkCellView:background-rgba
 183    *
 184    * The background color as a #GdkRGBA
 185    *
 186    * Since: 3.0
 187    */
 188   g_object_class_install_property (gobject_class,
 189                                    PROP_BACKGROUND_RGBA,
 190                                    g_param_spec_boxed ("background-rgba",
 191                                                       P_("Background RGBA color"),
 192                                                       P_("Background color as a GdkRGBA"),
 193                                                       GDK_TYPE_RGBA,
 194                                                       GTK_PARAM_READWRITE));
 195
 196   /**
 197    * GtkCellView:model
 198    *
 199    * The model for cell view
 200    *
 201    * since 2.10
 202    */
 203   g_object_class_install_property (gobject_class,
 204                                    PROP_MODEL,
 205                                    g_param_spec_object  ("model",
 206                                                          P_("CellView model"),
 207                                                          P_("The model for cell view"),
 208                                                          GTK_TYPE_TREE_MODEL,
 209                                                          GTK_PARAM_READWRITE));
 210
 211
 212   /**
 213    * GtkCellView:cell-area
 214    *
 215    * The #GtkCellArea rendering cells
 216    *
 217    * since 3.0
 218    */
 219    g_object_class_install_property (gobject_class,
 220                                     PROP_CELL_AREA,
 221                                     g_param_spec_object ("cell-area",
 222                                                          P_("Cell Area"),
 223                                                          P_("The GtkCellArea used to layout cells"),
 224                                                          GTK_TYPE_CELL_AREA,
 225                                                          GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 226
 227   /**
 228    * GtkCellView:cell-area-context
 229    *
 230    * The #GtkCellAreaContext used to compute the geometry of the cell view.
 231    *
 232    * since 3.0
 233    */
 234    g_object_class_install_property (gobject_class,
 235                                     PROP_CELL_AREA_CONTEXT,
 236                                     g_param_spec_object ("cell-area-context",
 237                                                          P_("Cell Area Context"),
 238                                                          P_("The GtkCellAreaContext used to "
 239                                                             "compute the geometry of the cell view"),
 240                                                          GTK_TYPE_CELL_AREA_CONTEXT,
 241                                                          GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 242
 243
 244 #define ADD_SET_PROP(propname, propval, nick, blurb) g_object_class_install_property (gobject_class, propval, g_param_spec_boolean (propname, nick, blurb, FALSE, GTK_PARAM_READWRITE))
 245
 246   ADD_SET_PROP ("background-set", PROP_BACKGROUND_SET,
 247                 P_("Background set"),
 248                 P_("Whether this tag affects the background color"));
 249
 250   g_type_class_add_private (gobject_class, sizeof (GtkCellViewPrivate));
 251 }
 252
 253 static void
 254 gtk_cell_view_buildable_init (GtkBuildableIface *iface)
 255 {
 256   parent_buildable_iface = g_type_interface_peek_parent (iface);
 257   iface->add_child = _gtk_cell_layout_buildable_add_child;
 258   iface->custom_tag_start = gtk_cell_view_buildable_custom_tag_start;
 259   iface->custom_tag_end = gtk_cell_view_buildable_custom_tag_end;
 260 }
 261
 262 static void
 263 gtk_cell_view_cell_layout_init (GtkCellLayoutIface *iface)
 264 {
 265   iface->get_area = gtk_cell_view_cell_layout_get_area;
 266 }
 267
 268 static GObject *
 269 gtk_cell_view_constructor (GType                  type,
 270                            guint                  n_construct_properties,
 271                            GObjectConstructParam *construct_properties)
 272 {
 273   GObject            *object;
 274   GtkCellView        *view;
 275   GtkCellViewPrivate *priv;
 276
 277   object = G_OBJECT_CLASS (gtk_cell_view_parent_class)->constructor
 278     (type, n_construct_properties, construct_properties);
 279
 280   view = GTK_CELL_VIEW (object);
 281   priv = view->priv;
 282
 283   if (!priv->area)
 284     {
 285       GtkCellArea *area = gtk_cell_area_box_new ();
 286
 287       priv->area = g_object_ref_sink (area);
 288     }
 289
 290   if (!priv->context)
 291     priv->context = gtk_cell_area_create_context (priv->area);
 292
 293   priv->size_changed_id =
 294     g_signal_connect (priv->context, "notify",
 295                       G_CALLBACK (context_size_changed_cb), view);
 296
 297   return object;
 298 }
 299
 300 static void
 301 gtk_cell_view_get_property (GObject    *object,
 302                             guint       param_id,
 303                             GValue     *value,
 304                             GParamSpec *pspec)
 305 {
 306   GtkCellView *view = GTK_CELL_VIEW (object);
 307
 308   switch (param_id)
 309     {
 310       case PROP_BACKGROUND_GDK:
 311         {
 312           GdkColor color;
 313
 314           color.red = (guint) (view->priv->background.red * 65535);
 315           color.green = (guint) (view->priv->background.green * 65535);
 316           color.blue = (guint) (view->priv->background.blue * 65535);
 317           color.pixel = 0;
 318
 319           g_value_set_boxed (value, &color);
 320         }
 321         break;
 322       case PROP_BACKGROUND_RGBA:
 323         g_value_set_boxed (value, &view->priv->background);
 324         break;
 325       case PROP_BACKGROUND_SET:
 326         g_value_set_boolean (value, view->priv->background_set);
 327         break;
 328       case PROP_MODEL:
 329         g_value_set_object (value, view->priv->model);
 330         break;
 331       case PROP_CELL_AREA:
 332         g_value_set_object (value, view->priv->area);
 333         break;
 334       case PROP_CELL_AREA_CONTEXT:
 335         g_value_set_object (value, view->priv->context);
 336         break;
 337       default:
 338         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 339         break;
 340     }
 341 }
 342
 343 static void
 344 gtk_cell_view_set_property (GObject      *object,
 345                             guint         param_id,
 346                             const GValue *value,
 347                             GParamSpec   *pspec)
 348 {
 349   GtkCellView *view = GTK_CELL_VIEW (object);
 350   GtkCellArea *area;
 351   GtkCellAreaContext *context;
 352
 353   switch (param_id)
 354     {
 355       case PROP_BACKGROUND:
 356         {
 357           GdkColor color;
 358
 359           if (!g_value_get_string (value))
 360             gtk_cell_view_set_background_color (view, NULL);
 361           else if (gdk_color_parse (g_value_get_string (value), &color))
 362             gtk_cell_view_set_background_color (view, &color);
 363           else
 364             g_warning ("Don't know color `%s'", g_value_get_string (value));
 365
 366           g_object_notify (object, "background-gdk");
 367         }
 368         break;
 369       case PROP_BACKGROUND_GDK:
 370         gtk_cell_view_set_background_color (view, g_value_get_boxed (value));
 371         break;
 372       case PROP_BACKGROUND_RGBA:
 373         gtk_cell_view_set_background_rgba (view, g_value_get_boxed (value));
 374         break;
 375       case PROP_BACKGROUND_SET:
 376         view->priv->background_set = g_value_get_boolean (value);
 377         break;
 378       case PROP_MODEL:
 379         gtk_cell_view_set_model (view, g_value_get_object (value));
 380         break;
 381     case PROP_CELL_AREA:
 382       /* Construct-only, can only be assigned once */
 383       area = g_value_get_object (value);
 384
 385       if (area)
 386         view->priv->area = g_object_ref_sink (area);
 387       break;
 388     case PROP_CELL_AREA_CONTEXT:
 389       /* Construct-only, can only be assigned once */
 390       context = g_value_get_object (value);
 391
 392       if (context)
 393         view->priv->context = g_object_ref (context);
 394       break;
 395
 396     default:
 397         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 398         break;
 399     }
 400 }
 401
 402 static void
 403 gtk_cell_view_init (GtkCellView *cellview)
 404 {
 405   GtkCellViewPrivate *priv;
 406
 407   cellview->priv = G_TYPE_INSTANCE_GET_PRIVATE (cellview,
 408                                                 GTK_TYPE_CELL_VIEW,
 409                                                 GtkCellViewPrivate);
 410   priv = cellview->priv;
 411
 412   gtk_widget_set_has_window (GTK_WIDGET (cellview), FALSE);
 413 }
 414
 415 static void
 416 gtk_cell_view_finalize (GObject *object)
 417 {
 418   GtkCellView *cellview = GTK_CELL_VIEW (object);
 419
 420   if (cellview->priv->displayed_row)
 421      gtk_tree_row_reference_free (cellview->priv->displayed_row);
 422
 423   G_OBJECT_CLASS (gtk_cell_view_parent_class)->finalize (object);
 424 }
 425
 426 static void
 427 gtk_cell_view_dispose (GObject *object)
 428 {
 429   GtkCellView *cellview = GTK_CELL_VIEW (object);
 430
 431   if (cellview->priv->model)
 432     {
 433       g_object_unref (cellview->priv->model);
 434       cellview->priv->model = NULL;
 435     }
 436
 437   if (cellview->priv->area)
 438     {
 439       g_object_unref (cellview->priv->area);
 440       cellview->priv->area = NULL;
 441     }
 442
 443   if (cellview->priv->context)
 444     {
 445       g_signal_handler_disconnect (cellview->priv->context, cellview->priv->size_changed_id);
 446
 447       g_object_unref (cellview->priv->context);
 448       cellview->priv->context = NULL;
 449       cellview->priv->size_changed_id = 0;
 450     }
 451
 452   G_OBJECT_CLASS (gtk_cell_view_parent_class)->dispose (object);
 453 }
 454
 455 static void
 456 gtk_cell_view_size_allocate (GtkWidget     *widget,
 457                              GtkAllocation *allocation)
 458 {
 459   GtkCellView        *cellview = GTK_CELL_VIEW (widget);
 460   GtkCellViewPrivate *priv = cellview->priv;
 461   gint                alloc_width, alloc_height;
 462
 463   gtk_widget_set_allocation (widget, allocation);
 464
 465   gtk_cell_area_context_get_allocation (priv->context, &alloc_width, &alloc_height);
 466
 467   /* The first cell view in context is responsible for allocating the context at allocate time
 468    * (or the cellview has its own context and is not grouped with any other cell views) */
 469   if (alloc_width <= 0 && alloc_height <= 0)
 470     {
 471       gtk_cell_area_context_allocate_width (priv->context, allocation->width);
 472       gtk_cell_area_context_allocate_height (priv->context, allocation->height);
 473     }
 474 }
 475
 476 static gboolean
 477 gtk_cell_view_draw (GtkWidget *widget,
 478                     cairo_t   *cr)
 479 {
 480   GtkCellView *cellview;
 481   GdkRectangle area;
 482   GtkCellRendererState state;
 483
 484   cellview = GTK_CELL_VIEW (widget);
 485
 486   /* render cells */
 487   area.x = 0;
 488   area.y = 0;
 489   area.width  = gtk_widget_get_allocated_width (widget);
 490   area.height = gtk_widget_get_allocated_height (widget);
 491
 492   /* "blank" background */
 493   if (cellview->priv->background_set)
 494     {
 495       gdk_cairo_rectangle (cr, &area);
 496       gdk_cairo_set_source_rgba (cr, &cellview->priv->background);
 497       cairo_fill (cr);
 498     }
 499
 500   /* set cell data (if available) */
 501   if (cellview->priv->displayed_row)
 502     gtk_cell_view_set_cell_data (cellview);
 503   else if (cellview->priv->model)
 504     return FALSE;
 505
 506   if (gtk_widget_get_state_flags (widget) & GTK_STATE_FLAG_PRELIGHT)
 507     state = GTK_CELL_RENDERER_PRELIT;
 508   else if (gtk_widget_get_state_flags (widget) & GTK_STATE_FLAG_INSENSITIVE)
 509     state = GTK_CELL_RENDERER_INSENSITIVE;
 510   else
 511     state = 0;
 512
 513   /* Render the cells */
 514   gtk_cell_area_render (cellview->priv->area, cellview->priv->context,
 515                         widget, cr, &area, &area, state, FALSE);
 516
 517   return FALSE;
 518 }
 519
 520 static void
 521 gtk_cell_view_set_cell_data (GtkCellView *cell_view)
 522 {
 523   GtkTreeIter iter;
 524   GtkTreePath *path;
 525
 526   g_return_if_fail (cell_view->priv->displayed_row != NULL);
 527
 528   path = gtk_tree_row_reference_get_path (cell_view->priv->displayed_row);
 529   if (!path)
 530     return;
 531
 532   gtk_tree_model_get_iter (cell_view->priv->model, &iter, path);
 533   gtk_tree_path_free (path);
 534
 535   gtk_cell_area_apply_attributes (cell_view->priv->area,
 536                                   cell_view->priv->model,
 537                                   &iter, FALSE, FALSE);
 538 }
 539
 540 /* GtkCellLayout implementation */
 541 static GtkCellArea *
 542 gtk_cell_view_cell_layout_get_area (GtkCellLayout   *layout)
 543 {
 544   GtkCellView *cellview = GTK_CELL_VIEW (layout);
 545
 546   return cellview->priv->area;
 547 }
 548
 549 static void
 550 context_size_changed_cb (GtkCellAreaContext  *context,
 551                          GParamSpec          *pspec,
 552                          GtkWidget           *view)
 553 {
 554   if (!strcmp (pspec->name, "minimum-width") ||
 555       !strcmp (pspec->name, "natural-width") ||
 556       !strcmp (pspec->name, "minimum-height") ||
 557       !strcmp (pspec->name, "natural-height"))
 558     gtk_widget_queue_resize (view);
 559 }
 560
 561 static void
 562 row_changed_cb (GtkTreeModel         *model,
 563                 GtkTreePath          *path,
 564                 GtkTreeIter          *iter,
 565                 GtkCellView          *view)
 566 {
 567   GtkTreePath *row_path;
 568
 569   if (view->priv->displayed_row)
 570     {
 571       row_path =
 572         gtk_tree_row_reference_get_path (view->priv->displayed_row);
 573
 574       /* Resize everything in our context if our row changed */
 575       if (gtk_tree_path_compare (row_path, path) == 0)
 576         gtk_cell_area_context_flush (view->priv->context);
 577     }
 578 }
 579
 580 /**
 581  * gtk_cell_view_new:
 582  *
 583  * Creates a new #GtkCellView widget.
 584  *
 585  * Return value: A newly created #GtkCellView widget.
 586  *
 587  * Since: 2.6
 588  */
 589 GtkWidget *
 590 gtk_cell_view_new (void)
 591 {
 592   GtkCellView *cellview;
 593
 594   cellview = g_object_new (gtk_cell_view_get_type (), NULL);
 595
 596   return GTK_WIDGET (cellview);
 597 }
 598
 599
 600 /**
 601  * gtk_cell_view_new_with_context:
 602  * @area: the #GtkCellArea to layout cells
 603  * @context: the #GtkCellAreaContext in which to calculate cell geometry
 604  *
 605  * Creates a new #GtkCellView widget with a specific #GtkCellArea
 606  * to layout cells and a specific #GtkCellAreaContext.
 607  *
 608  * Specifying the same context for a handfull of cells lets
 609  * the underlying area synchronize the geometry for those cells,
 610  * in this way alignments with cellviews for other rows are
 611  * possible.
 612  *
 613  * Return value: A newly created #GtkCellView widget.
 614  *
 615  * Since: 2.6
 616  */
 617 GtkWidget *
 618 gtk_cell_view_new_with_context (GtkCellArea        *area,
 619                                 GtkCellAreaContext *context)
 620 {
 621   g_return_val_if_fail (GTK_IS_CELL_AREA (area), NULL);
 622   g_return_val_if_fail (context == NULL || GTK_IS_CELL_AREA_CONTEXT (context), NULL);
 623
 624   return (GtkWidget *)g_object_new (GTK_TYPE_CELL_VIEW,
 625                                     "cell-area", area,
 626                                     "cell-area-context", context,
 627                                     NULL);
 628 }
 629
 630 /**
 631  * gtk_cell_view_new_with_text:
 632  * @text: the text to display in the cell view
 633  *
 634  * Creates a new #GtkCellView widget, adds a #GtkCellRendererText
 635  * to it, and makes its show @text.
 636  *
 637  * Return value: A newly created #GtkCellView widget.
 638  *
 639  * Since: 2.6
 640  */
 641 GtkWidget *
 642 gtk_cell_view_new_with_text (const gchar *text)
 643 {
 644   GtkCellView *cellview;
 645   GtkCellRenderer *renderer;
 646   GValue value = {0, };
 647
 648   cellview = GTK_CELL_VIEW (gtk_cell_view_new ());
 649
 650   renderer = gtk_cell_renderer_text_new ();
 651   gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (cellview),
 652                               renderer, TRUE);
 653
 654   g_value_init (&value, G_TYPE_STRING);
 655   g_value_set_string (&value, text);
 656   gtk_cell_view_set_value (cellview, renderer, "text", &value);
 657   g_value_unset (&value);
 658
 659   return GTK_WIDGET (cellview);
 660 }
 661
 662 /**
 663  * gtk_cell_view_new_with_markup:
 664  * @markup: the text to display in the cell view
 665  *
 666  * Creates a new #GtkCellView widget, adds a #GtkCellRendererText
 667  * to it, and makes it show @markup. The text can be
 668  * marked up with the <link linkend="PangoMarkupFormat">Pango text
 669  * markup language</link>.
 670  *
 671  * Return value: A newly created #GtkCellView widget.
 672  *
 673  * Since: 2.6
 674  */
 675 GtkWidget *
 676 gtk_cell_view_new_with_markup (const gchar *markup)
 677 {
 678   GtkCellView *cellview;
 679   GtkCellRenderer *renderer;
 680   GValue value = {0, };
 681
 682   cellview = GTK_CELL_VIEW (gtk_cell_view_new ());
 683
 684   renderer = gtk_cell_renderer_text_new ();
 685   gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (cellview),
 686                               renderer, TRUE);
 687
 688   g_value_init (&value, G_TYPE_STRING);
 689   g_value_set_string (&value, markup);
 690   gtk_cell_view_set_value (cellview, renderer, "markup", &value);
 691   g_value_unset (&value);
 692
 693   return GTK_WIDGET (cellview);
 694 }
 695
 696 /**
 697  * gtk_cell_view_new_with_pixbuf:
 698  * @pixbuf: the image to display in the cell view
 699  *
 700  * Creates a new #GtkCellView widget, adds a #GtkCellRendererPixbuf
 701  * to it, and makes its show @pixbuf.
 702  *
 703  * Return value: A newly created #GtkCellView widget.
 704  *
 705  * Since: 2.6
 706  */
 707 GtkWidget *
 708 gtk_cell_view_new_with_pixbuf (GdkPixbuf *pixbuf)
 709 {
 710   GtkCellView *cellview;
 711   GtkCellRenderer *renderer;
 712   GValue value = {0, };
 713
 714   cellview = GTK_CELL_VIEW (gtk_cell_view_new ());
 715
 716   renderer = gtk_cell_renderer_pixbuf_new ();
 717   gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (cellview),
 718                               renderer, TRUE);
 719
 720   g_value_init (&value, GDK_TYPE_PIXBUF);
 721   g_value_set_object (&value, pixbuf);
 722   gtk_cell_view_set_value (cellview, renderer, "pixbuf", &value);
 723   g_value_unset (&value);
 724
 725   return GTK_WIDGET (cellview);
 726 }
 727
 728 /**
 729  * gtk_cell_view_set_value:
 730  * @cell_view: a #GtkCellView widget
 731  * @renderer: one of the renderers of @cell_view
 732  * @property: the name of the property of @renderer to set
 733  * @value: the new value to set the property to
 734  *
 735  * Sets a property of a cell renderer of @cell_view, and
 736  * makes sure the display of @cell_view is updated.
 737  *
 738  * Since: 2.6
 739  */
 740 static void
 741 gtk_cell_view_set_value (GtkCellView     *cell_view,
 742                          GtkCellRenderer *renderer,
 743                          gchar           *property,
 744                          GValue          *value)
 745 {
 746   g_object_set_property (G_OBJECT (renderer), property, value);
 747
 748   /* force resize and redraw */
 749   gtk_widget_queue_resize (GTK_WIDGET (cell_view));
 750   gtk_widget_queue_draw (GTK_WIDGET (cell_view));
 751 }
 752
 753 /**
 754  * gtk_cell_view_set_model:
 755  * @cell_view: a #GtkCellView
 756  * @model: (allow-none): a #GtkTreeModel
 757  *
 758  * Sets the model for @cell_view.  If @cell_view already has a model
 759  * set, it will remove it before setting the new model.  If @model is
 760  * %NULL, then it will unset the old model.
 761  *
 762  * Since: 2.6
 763  */
 764 void
 765 gtk_cell_view_set_model (GtkCellView  *cell_view,
 766                          GtkTreeModel *model)
 767 {
 768   g_return_if_fail (GTK_IS_CELL_VIEW (cell_view));
 769   g_return_if_fail (model == NULL || GTK_IS_TREE_MODEL (model));
 770
 771   if (cell_view->priv->model)
 772     {
 773       g_signal_handler_disconnect (cell_view->priv->model,
 774                                    cell_view->priv->row_changed_id);
 775       cell_view->priv->row_changed_id = 0;
 776
 777       if (cell_view->priv->displayed_row)
 778         gtk_tree_row_reference_free (cell_view->priv->displayed_row);
 779       cell_view->priv->displayed_row = NULL;
 780
 781       g_object_unref (cell_view->priv->model);
 782       cell_view->priv->model = NULL;
 783     }
 784
 785   cell_view->priv->model = model;
 786
 787   if (cell_view->priv->model)
 788     {
 789       g_object_ref (cell_view->priv->model);
 790
 791       cell_view->priv->row_changed_id =
 792         g_signal_connect (cell_view->priv->model, "row-changed",
 793                           G_CALLBACK (row_changed_cb), cell_view);
 794     }
 795 }
 796
 797 /**
 798  * gtk_cell_view_get_model:
 799  * @cell_view: a #GtkCellView
 800  *
 801  * Returns the model for @cell_view. If no model is used %NULL is
 802  * returned.
 803  *
 804  * Returns: (transfer none): a #GtkTreeModel used or %NULL
 805  *
 806  * Since: 2.16
 807  **/
 808 GtkTreeModel *
 809 gtk_cell_view_get_model (GtkCellView *cell_view)
 810 {
 811   g_return_val_if_fail (GTK_IS_CELL_VIEW (cell_view), NULL);
 812
 813   return cell_view->priv->model;
 814 }
 815
 816 /**
 817  * gtk_cell_view_set_displayed_row:
 818  * @cell_view: a #GtkCellView
 819  * @path: (allow-none): a #GtkTreePath or %NULL to unset.
 820  *
 821  * Sets the row of the model that is currently displayed
 822  * by the #GtkCellView. If the path is unset, then the
 823  * contents of the cellview "stick" at their last value;
 824  * this is not normally a desired result, but may be
 825  * a needed intermediate state if say, the model for
 826  * the #GtkCellView becomes temporarily empty.
 827  *
 828  * Since: 2.6
 829  **/
 830 void
 831 gtk_cell_view_set_displayed_row (GtkCellView *cell_view,
 832                                  GtkTreePath *path)
 833 {
 834   g_return_if_fail (GTK_IS_CELL_VIEW (cell_view));
 835   g_return_if_fail (GTK_IS_TREE_MODEL (cell_view->priv->model));
 836
 837   if (cell_view->priv->displayed_row)
 838     gtk_tree_row_reference_free (cell_view->priv->displayed_row);
 839
 840   if (path)
 841     {
 842       cell_view->priv->displayed_row =
 843         gtk_tree_row_reference_new (cell_view->priv->model, path);
 844     }
 845   else
 846     cell_view->priv->displayed_row = NULL;
 847
 848   /* force resize and redraw */
 849   gtk_widget_queue_resize (GTK_WIDGET (cell_view));
 850   gtk_widget_queue_draw (GTK_WIDGET (cell_view));
 851 }
 852
 853 /**
 854  * gtk_cell_view_get_displayed_row:
 855  * @cell_view: a #GtkCellView
 856  *
 857  * Returns a #GtkTreePath referring to the currently
 858  * displayed row. If no row is currently displayed,
 859  * %NULL is returned.
 860  *
 861  * Returns: the currently displayed row or %NULL
 862  *
 863  * Since: 2.6
 864  */
 865 GtkTreePath *
 866 gtk_cell_view_get_displayed_row (GtkCellView *cell_view)
 867 {
 868   g_return_val_if_fail (GTK_IS_CELL_VIEW (cell_view), NULL);
 869
 870   if (!cell_view->priv->displayed_row)
 871     return NULL;
 872
 873   return gtk_tree_row_reference_get_path (cell_view->priv->displayed_row);
 874 }
 875
 876 /**
 877  * gtk_cell_view_get_size_of_row:
 878  * @cell_view: a #GtkCellView
 879  * @path: a #GtkTreePath
 880  * @requisition: return location for the size
 881  *
 882  * Sets @requisition to the size needed by @cell_view to display
 883  * the model row pointed to by @path.
 884  *
 885  * Return value: %TRUE
 886  *
 887  * Since: 2.6
 888  *
 889  * Deprecated: 3.0: Use gtk_cell_view_get_desired_width_of_row() and
 890  * gtk_cell_view_get_desired_height_for_width_of_row() instead.
 891  */
 892 gboolean
 893 gtk_cell_view_get_size_of_row (GtkCellView    *cell_view,
 894                                GtkTreePath    *path,
 895                                GtkRequisition *requisition)
 896 {
 897   GtkRequisition req;
 898
 899   g_return_val_if_fail (GTK_IS_CELL_VIEW (cell_view), FALSE);
 900   g_return_val_if_fail (path != NULL, FALSE);
 901
 902   /* Return the minimum height for the minimum width */
 903   gtk_cell_view_get_desired_width_of_row (cell_view, path, &req.width, NULL);
 904   gtk_cell_view_get_desired_height_for_width_of_row (cell_view, path, req.width, &req.height, NULL);
 905
 906   if (requisition)
 907     *requisition = req;
 908
 909   return TRUE;
 910 }
 911
 912
 913 /**
 914  * gtk_cell_view_get_desired_width_of_row:
 915  * @cell_view: a #GtkCellView
 916  * @path: a #GtkTreePath
 917  * @minimum_size: location to store the minimum size
 918  * @natural_size: location to store the natural size
 919  *
 920  * Sets @minimum_size and @natural_size to the width desired by @cell_view
 921  * to display the model row pointed to by @path.
 922  *
 923  * Since: 3.0
 924  */
 925 void
 926 gtk_cell_view_get_desired_width_of_row (GtkCellView     *cell_view,
 927                                         GtkTreePath     *path,
 928                                         gint            *minimum_size,
 929                                         gint            *natural_size)
 930 {
 931   GtkTreeRowReference *tmp;
 932
 933   g_return_if_fail (GTK_IS_CELL_VIEW (cell_view));
 934   g_return_if_fail (path != NULL);
 935   g_return_if_fail (minimum_size != NULL || natural_size != NULL);
 936
 937   tmp = cell_view->priv->displayed_row;
 938   cell_view->priv->displayed_row =
 939     gtk_tree_row_reference_new (cell_view->priv->model, path);
 940
 941   gtk_cell_view_get_preferred_width (GTK_WIDGET (cell_view), minimum_size, natural_size);
 942
 943   gtk_tree_row_reference_free (cell_view->priv->displayed_row);
 944   cell_view->priv->displayed_row = tmp;
 945
 946   /* Restore active size (this will restore the cellrenderer info->width/requested_width's) */
 947   gtk_cell_view_get_preferred_width (GTK_WIDGET (cell_view), NULL, NULL);
 948 }
 949
 950
 951 /**
 952  * gtk_cell_view_get_desired_height_for_width_of_row:
 953  * @cell_view: a #GtkCellView
 954  * @path: a #GtkTreePath
 955  * @avail_size: available width
 956  * @minimum_size: location to store the minimum height
 957  * @natural_size: location to store the natural height
 958  *
 959  * Sets @minimum_size and @natural_size to the height desired by @cell_view
 960  * if it were allocated a width of @avail_size to display the model row
 961  * pointed to by @path.
 962  *
 963  * Since: 3.0
 964  */
 965 void
 966 gtk_cell_view_get_desired_height_for_width_of_row (GtkCellView     *cell_view,
 967                                                    GtkTreePath     *path,
 968                                                    gint             avail_size,
 969                                                    gint            *minimum_size,
 970                                                    gint            *natural_size)
 971 {
 972   GtkTreeRowReference *tmp;
 973
 974   g_return_if_fail (GTK_IS_CELL_VIEW (cell_view));
 975   g_return_if_fail (path != NULL);
 976   g_return_if_fail (minimum_size != NULL || natural_size != NULL);
 977
 978   tmp = cell_view->priv->displayed_row;
 979   cell_view->priv->displayed_row =
 980     gtk_tree_row_reference_new (cell_view->priv->model, path);
 981
 982   /* Then get the collective height_for_width based on the cached values */
 983   gtk_cell_view_get_preferred_height_for_width (GTK_WIDGET (cell_view), avail_size, minimum_size, natural_size);
 984
 985   gtk_tree_row_reference_free (cell_view->priv->displayed_row);
 986   cell_view->priv->displayed_row = tmp;
 987
 988   /* Restore active size (this will restore the cellrenderer info->width/requested_width's) */
 989   gtk_cell_view_get_preferred_width (GTK_WIDGET (cell_view), NULL, NULL);
 990 }
 991
 992 /**
 993  * gtk_cell_view_set_background_color:
 994  * @cell_view: a #GtkCellView
 995  * @color: the new background color
 996  *
 997  * Sets the background color of @view.
 998  *
 999  * Since: 2.6
1000  */
1001 void
1002 gtk_cell_view_set_background_color (GtkCellView    *cell_view,
1003                                     const GdkColor *color)
1004 {
1005   g_return_if_fail (GTK_IS_CELL_VIEW (cell_view));
1006
1007   if (color)
1008     {
1009       if (!cell_view->priv->background_set)
1010         {
1011           cell_view->priv->background_set = TRUE;
1012           g_object_notify (G_OBJECT (cell_view), "background-set");
1013         }
1014
1015       cell_view->priv->background.red = color->red / 65535.;
1016       cell_view->priv->background.green = color->green / 65535.;
1017       cell_view->priv->background.blue = color->blue / 65535.;
1018       cell_view->priv->background.alpha = 1;
1019     }
1020   else
1021     {
1022       if (cell_view->priv->background_set)
1023         {
1024           cell_view->priv->background_set = FALSE;
1025           g_object_notify (G_OBJECT (cell_view), "background-set");
1026         }
1027     }
1028
1029   gtk_widget_queue_draw (GTK_WIDGET (cell_view));
1030 }
1031
1032 /**
1033  * gtk_cell_view_set_background_rgba:
1034  * @cell_view: a #GtkCellView
1035  * @rgba: the new background color
1036  *
1037  * Sets the background color of @cell_view.
1038  *
1039  * Since: 3.0
1040  */
1041 void
1042 gtk_cell_view_set_background_rgba (GtkCellView   *cell_view,
1043                                    const GdkRGBA *rgba)
1044 {
1045   g_return_if_fail (GTK_IS_CELL_VIEW (cell_view));
1046
1047   if (rgba)
1048     {
1049       if (!cell_view->priv->background_set)
1050         {
1051           cell_view->priv->background_set = TRUE;
1052           g_object_notify (G_OBJECT (cell_view), "background-set");
1053         }
1054
1055       cell_view->priv->background = *rgba;
1056     }
1057   else
1058     {
1059       if (cell_view->priv->background_set)
1060         {
1061           cell_view->priv->background_set = FALSE;
1062           g_object_notify (G_OBJECT (cell_view), "background-set");
1063         }
1064     }
1065
1066   gtk_widget_queue_draw (GTK_WIDGET (cell_view));
1067 }
1068
1069 static gboolean
1070 gtk_cell_view_buildable_custom_tag_start (GtkBuildable  *buildable,
1071                                           GtkBuilder    *builder,
1072                                           GObject       *child,
1073                                           const gchar   *tagname,
1074                                           GMarkupParser *parser,
1075                                           gpointer      *data)
1076 {
1077   if (parent_buildable_iface->custom_tag_start &&
1078       parent_buildable_iface->custom_tag_start (buildable, builder, child,
1079                                                 tagname, parser, data))
1080     return TRUE;
1081
1082   return _gtk_cell_layout_buildable_custom_tag_start (buildable, builder, child,
1083                                                       tagname, parser, data);
1084 }
1085
1086 static void
1087 gtk_cell_view_buildable_custom_tag_end (GtkBuildable *buildable,
1088                                         GtkBuilder   *builder,
1089                                         GObject      *child,
1090                                         const gchar  *tagname,
1091                                         gpointer     *data)
1092 {
1093   if (strcmp (tagname, "attributes") == 0)
1094     _gtk_cell_layout_buildable_custom_tag_end (buildable, builder, child, tagname,
1095                                                data);
1096   else if (parent_buildable_iface->custom_tag_end)
1097     parent_buildable_iface->custom_tag_end (buildable, builder, child, tagname,
1098                                             data);
1099 }
1100
1101 static void
1102 gtk_cell_view_get_preferred_width  (GtkWidget *widget,
1103                                     gint      *minimum_size,
1104                                     gint      *natural_size)
1105 {
1106   GtkCellView        *cellview = GTK_CELL_VIEW (widget);
1107   GtkCellViewPrivate *priv = cellview->priv;
1108
1109   g_signal_handler_block (priv->context, priv->size_changed_id);
1110
1111   if (cellview->priv->displayed_row)
1112     gtk_cell_view_set_cell_data (cellview);
1113
1114   gtk_cell_area_get_preferred_width (priv->area, priv->context, widget, NULL, NULL);
1115   gtk_cell_area_context_sum_preferred_width (priv->context);
1116   gtk_cell_area_context_get_preferred_width (priv->context, minimum_size, natural_size);
1117
1118   g_signal_handler_unblock (priv->context, priv->size_changed_id);
1119 }
1120
1121 static void
1122 gtk_cell_view_get_preferred_height (GtkWidget *widget,
1123                                     gint      *minimum_size,
1124                                     gint      *natural_size)
1125 {
1126   GtkCellView        *cellview = GTK_CELL_VIEW (widget);
1127   GtkCellViewPrivate *priv = cellview->priv;
1128
1129   g_signal_handler_block (priv->context, priv->size_changed_id);
1130
1131   if (cellview->priv->displayed_row)
1132     gtk_cell_view_set_cell_data (cellview);
1133
1134   gtk_cell_area_get_preferred_height (priv->area, priv->context, widget, NULL, NULL);
1135   gtk_cell_area_context_sum_preferred_height (priv->context);
1136   gtk_cell_area_context_get_preferred_height (priv->context, minimum_size, natural_size);
1137
1138   g_signal_handler_unblock (priv->context, priv->size_changed_id);
1139 }
1140
1141 static void
1142 gtk_cell_view_get_preferred_width_for_height (GtkWidget *widget,
1143                                               gint       for_size,
1144                                               gint      *minimum_size,
1145                                               gint      *natural_size)
1146 {
1147   GtkCellView        *cellview = GTK_CELL_VIEW (widget);
1148   GtkCellViewPrivate *priv = cellview->priv;
1149
1150   if (cellview->priv->displayed_row)
1151     gtk_cell_view_set_cell_data (cellview);
1152
1153   gtk_cell_area_get_preferred_width_for_height (priv->area, priv->context, widget,
1154                                                 for_size, minimum_size, natural_size);
1155 }
1156
1157 static void
1158 gtk_cell_view_get_preferred_height_for_width (GtkWidget *widget,
1159                                               gint       for_size,
1160                                               gint      *minimum_size,
1161                                               gint      *natural_size)
1162 {
1163   GtkCellView        *cellview = GTK_CELL_VIEW (widget);
1164   GtkCellViewPrivate *priv = cellview->priv;
1165
1166   if (cellview->priv->displayed_row)
1167     gtk_cell_view_set_cell_data (cellview);
1168
1169   gtk_cell_area_get_preferred_height_for_width (priv->area, priv->context, widget,
1170                                                 for_size, minimum_size, natural_size);
1171 }