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

   1 /* gtkcellareabox.c
   2  *
   3  * Copyright (C) 2010 Openismus GmbH
   4  *
   5  * Authors:
   6  *      Tristan Van Berkom <tristanvb@openismus.com>
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public
  19  * License along with this library; if not, write to the
  20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  */
  23
  24 #include "config.h"
  25 #include "gtkintl.h"
  26 #include "gtkorientable.h"
  27 #include "gtkcelllayout.h"
  28 #include "gtkcellareabox.h"
  29 #include "gtkcellareaboxiter.h"
  30 #include "gtkprivate.h"
  31
  32
  33 /* GObjectClass */
  34 static void      gtk_cell_area_box_finalize                       (GObject              *object);
  35 static void      gtk_cell_area_box_dispose                        (GObject              *object);
  36 static void      gtk_cell_area_box_set_property                   (GObject              *object,
  37                                                                    guint                 prop_id,
  38                                                                    const GValue         *value,
  39                                                                    GParamSpec           *pspec);
  40 static void      gtk_cell_area_box_get_property                   (GObject              *object,
  41                                                                    guint                 prop_id,
  42                                                                    GValue               *value,
  43                                                                    GParamSpec           *pspec);
  44
  45 /* GtkCellAreaClass */
  46 static void      gtk_cell_area_box_add                            (GtkCellArea          *area,
  47                                                                    GtkCellRenderer      *renderer);
  48 static void      gtk_cell_area_box_remove                         (GtkCellArea          *area,
  49                                                                    GtkCellRenderer      *renderer);
  50 static void      gtk_cell_area_box_forall                         (GtkCellArea          *area,
  51                                                                    GtkCellCallback       callback,
  52                                                                    gpointer              callback_data);
  53 static void      gtk_cell_area_box_get_cell_allocation            (GtkCellArea          *area,
  54                                                                    GtkCellAreaIter      *iter,
  55                                                                    GtkWidget            *widget,
  56                                                                    GtkCellRenderer      *renderer,
  57                                                                    const GdkRectangle   *cell_area,
  58                                                                    GdkRectangle         *allocation);
  59 static gint      gtk_cell_area_box_event                          (GtkCellArea          *area,
  60                                                                    GtkCellAreaIter      *iter,
  61                                                                    GtkWidget            *widget,
  62                                                                    GdkEvent             *event,
  63                                                                    const GdkRectangle   *cell_area,
  64                                                                    GtkCellRendererState  flags);
  65 static void      gtk_cell_area_box_render                         (GtkCellArea          *area,
  66                                                                    GtkCellAreaIter      *iter,
  67                                                                    GtkWidget            *widget,
  68                                                                    cairo_t              *cr,
  69                                                                    const GdkRectangle   *background_area,
  70                                                                    const GdkRectangle   *cell_area,
  71                                                                    GtkCellRendererState  flags,
  72                                                                    gboolean              paint_focus);
  73 static void      gtk_cell_area_box_set_cell_property              (GtkCellArea          *area,
  74                                                                    GtkCellRenderer      *renderer,
  75                                                                    guint                 prop_id,
  76                                                                    const GValue         *value,
  77                                                                    GParamSpec           *pspec);
  78 static void      gtk_cell_area_box_get_cell_property              (GtkCellArea          *area,
  79                                                                    GtkCellRenderer      *renderer,
  80                                                                    guint                 prop_id,
  81                                                                    GValue               *value,
  82                                                                    GParamSpec           *pspec);
  83 static GtkCellAreaIter    *gtk_cell_area_box_create_iter          (GtkCellArea          *area);
  84 static GtkSizeRequestMode  gtk_cell_area_box_get_request_mode     (GtkCellArea          *area);
  85 static void      gtk_cell_area_box_get_preferred_width            (GtkCellArea          *area,
  86                                                                    GtkCellAreaIter      *iter,
  87                                                                    GtkWidget            *widget,
  88                                                                    gint                 *minimum_width,
  89                                                                    gint                 *natural_width);
  90 static void      gtk_cell_area_box_get_preferred_height           (GtkCellArea          *area,
  91                                                                    GtkCellAreaIter      *iter,
  92                                                                    GtkWidget            *widget,
  93                                                                    gint                 *minimum_height,
  94                                                                    gint                 *natural_height);
  95 static void      gtk_cell_area_box_get_preferred_height_for_width (GtkCellArea          *area,
  96                                                                    GtkCellAreaIter      *iter,
  97                                                                    GtkWidget            *widget,
  98                                                                    gint                  width,
  99                                                                    gint                 *minimum_height,
 100                                                                    gint                 *natural_height);
 101 static void      gtk_cell_area_box_get_preferred_width_for_height (GtkCellArea          *area,
 102                                                                    GtkCellAreaIter      *iter,
 103                                                                    GtkWidget            *widget,
 104                                                                    gint                  height,
 105                                                                    gint                 *minimum_width,
 106                                                                    gint                 *natural_width);
 107 static gboolean  gtk_cell_area_box_focus                          (GtkCellArea          *area,
 108                                                                    GtkDirectionType      direction);
 109
 110 /* GtkCellLayoutIface */
 111 static void      gtk_cell_area_box_cell_layout_init               (GtkCellLayoutIface *iface);
 112 static void      gtk_cell_area_box_layout_pack_start              (GtkCellLayout      *cell_layout,
 113                                                                    GtkCellRenderer    *renderer,
 114                                                                    gboolean            expand);
 115 static void      gtk_cell_area_box_layout_pack_end                (GtkCellLayout      *cell_layout,
 116                                                                    GtkCellRenderer    *renderer,
 117                                                                    gboolean            expand);
 118 static void      gtk_cell_area_box_layout_reorder                 (GtkCellLayout      *cell_layout,
 119                                                                    GtkCellRenderer    *renderer,
 120                                                                    gint                position);
 121
 122
 123 /* CellInfo/CellGroup metadata handling and convenience functions */
 124 typedef struct {
 125   GtkCellRenderer *renderer;
 126
 127   guint            expand : 1; /* Whether the cell expands */
 128   guint            pack   : 1; /* Whether the cell is packed from the start or end */
 129   guint            align  : 1; /* Whether to align this cell's position with adjacent rows */
 130 } CellInfo;
 131
 132 typedef struct {
 133   GList *cells;
 134
 135   guint  id           : 8;
 136   guint  n_cells      : 8;
 137   guint  expand_cells : 8;
 138 } CellGroup;
 139
 140 typedef struct {
 141   GtkCellRenderer *renderer;
 142
 143   gint             position;
 144   gint             size;
 145 } AllocatedCell;
 146
 147 static CellInfo      *cell_info_new          (GtkCellRenderer    *renderer,
 148                                               GtkPackType         pack,
 149                                               gboolean            expand,
 150                                               gboolean            align);
 151 static void           cell_info_free         (CellInfo           *info);
 152 static gint           cell_info_find         (CellInfo           *info,
 153                                               GtkCellRenderer    *renderer);
 154
 155 static AllocatedCell *allocated_cell_new     (GtkCellRenderer    *renderer,
 156                                               gint                position,
 157                                               gint                size);
 158 static void           allocated_cell_free    (AllocatedCell      *cell);
 159 static GList         *list_consecutive_cells (GtkCellAreaBox     *box);
 160 static gint           count_expand_groups    (GtkCellAreaBox     *box);
 161 static void           iter_weak_notify       (GtkCellAreaBox     *box,
 162                                               GtkCellAreaBoxIter *dead_iter);
 163 static void           flush_iters            (GtkCellAreaBox     *box);
 164 static void           init_iter_groups       (GtkCellAreaBox     *box);
 165 static void           init_iter_group        (GtkCellAreaBox     *box,
 166                                               GtkCellAreaBoxIter *iter);
 167 static GSList        *get_allocated_cells    (GtkCellAreaBox     *box,
 168                                               GtkCellAreaBoxIter *iter,
 169                                               GtkWidget          *widget);
 170
 171
 172 struct _GtkCellAreaBoxPrivate
 173 {
 174   GtkOrientation  orientation;
 175
 176   GList          *cells;
 177   GArray         *groups;
 178
 179   GSList         *iters;
 180
 181   gint            spacing;
 182 };
 183
 184 enum {
 185   PROP_0,
 186   PROP_ORIENTATION,
 187   PROP_SPACING
 188 };
 189
 190 enum {
 191   CELL_PROP_0,
 192   CELL_PROP_EXPAND,
 193   CELL_PROP_ALIGN,
 194   CELL_PROP_PACK_TYPE
 195 };
 196
 197 G_DEFINE_TYPE_WITH_CODE (GtkCellAreaBox, gtk_cell_area_box, GTK_TYPE_CELL_AREA,
 198                          G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_LAYOUT,
 199                                                 gtk_cell_area_box_cell_layout_init)
 200                          G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, NULL));
 201
 202 #define OPPOSITE_ORIENTATION(orientation)                       \
 203   ((orientation) == GTK_ORIENTATION_HORIZONTAL ?                \
 204    GTK_ORIENTATION_VERTICAL : GTK_ORIENTATION_HORIZONTAL)
 205
 206 static void
 207 gtk_cell_area_box_init (GtkCellAreaBox *box)
 208 {
 209   GtkCellAreaBoxPrivate *priv;
 210
 211   box->priv = G_TYPE_INSTANCE_GET_PRIVATE (box,
 212                                            GTK_TYPE_CELL_AREA_BOX,
 213                                            GtkCellAreaBoxPrivate);
 214   priv = box->priv;
 215
 216   priv->orientation = GTK_ORIENTATION_HORIZONTAL;
 217   priv->groups      = g_array_new (FALSE, TRUE, sizeof (CellGroup));
 218   priv->cells       = NULL;
 219   priv->iters       = NULL;
 220   priv->spacing     = 0;
 221 }
 222
 223 static void
 224 gtk_cell_area_box_class_init (GtkCellAreaBoxClass *class)
 225 {
 226   GObjectClass     *object_class = G_OBJECT_CLASS (class);
 227   GtkCellAreaClass *area_class   = GTK_CELL_AREA_CLASS (class);
 228
 229   /* GObjectClass */
 230   object_class->finalize     = gtk_cell_area_box_finalize;
 231   object_class->dispose      = gtk_cell_area_box_dispose;
 232   object_class->set_property = gtk_cell_area_box_set_property;
 233   object_class->get_property = gtk_cell_area_box_get_property;
 234
 235   /* GtkCellAreaClass */
 236   area_class->add                 = gtk_cell_area_box_add;
 237   area_class->remove              = gtk_cell_area_box_remove;
 238   area_class->forall              = gtk_cell_area_box_forall;
 239   area_class->get_cell_allocation = gtk_cell_area_box_get_cell_allocation;
 240   area_class->event               = gtk_cell_area_box_event;
 241   area_class->render              = gtk_cell_area_box_render;
 242   area_class->set_cell_property   = gtk_cell_area_box_set_cell_property;
 243   area_class->get_cell_property   = gtk_cell_area_box_get_cell_property;
 244
 245   area_class->create_iter                    = gtk_cell_area_box_create_iter;
 246   area_class->get_request_mode               = gtk_cell_area_box_get_request_mode;
 247   area_class->get_preferred_width            = gtk_cell_area_box_get_preferred_width;
 248   area_class->get_preferred_height           = gtk_cell_area_box_get_preferred_height;
 249   area_class->get_preferred_height_for_width = gtk_cell_area_box_get_preferred_height_for_width;
 250   area_class->get_preferred_width_for_height = gtk_cell_area_box_get_preferred_width_for_height;
 251
 252   area_class->focus = gtk_cell_area_box_focus;
 253
 254   /* Properties */
 255   g_object_class_override_property (object_class, PROP_ORIENTATION, "orientation");
 256
 257   g_object_class_install_property (object_class,
 258                                    PROP_SPACING,
 259                                    g_param_spec_int ("spacing",
 260                                                      P_("Spacing"),
 261                                                      P_("Space which is inserted between cells"),
 262                                                      0,
 263                                                      G_MAXINT,
 264                                                      0,
 265                                                      GTK_PARAM_READWRITE));
 266
 267   /* Cell Properties */
 268   gtk_cell_area_class_install_cell_property (area_class,
 269                                              CELL_PROP_EXPAND,
 270                                              g_param_spec_boolean
 271                                              ("expand",
 272                                               P_("Expand"),
 273                                               P_("Whether the cell expands"),
 274                                               FALSE,
 275                                               GTK_PARAM_READWRITE));
 276
 277   gtk_cell_area_class_install_cell_property (area_class,
 278                                              CELL_PROP_ALIGN,
 279                                              g_param_spec_boolean
 280                                              ("align",
 281                                               P_("Align"),
 282                                               P_("Whether cell should align with adjacent rows"),
 283                                               TRUE,
 284                                               GTK_PARAM_READWRITE));
 285
 286   gtk_cell_area_class_install_cell_property (area_class,
 287                                              CELL_PROP_PACK_TYPE,
 288                                              g_param_spec_enum
 289                                              ("pack-type",
 290                                               P_("Pack Type"),
 291                                               P_("A GtkPackType indicating whether the cell is packed with "
 292                                                  "reference to the start or end of the cell area"),
 293                                               GTK_TYPE_PACK_TYPE, GTK_PACK_START,
 294                                               GTK_PARAM_READWRITE));
 295
 296   g_type_class_add_private (object_class, sizeof (GtkCellAreaBoxPrivate));
 297 }
 298
 299
 300 /*************************************************************
 301  *    CellInfo/CellGroup basics and convenience functions    *
 302  *************************************************************/
 303 static CellInfo *
 304 cell_info_new  (GtkCellRenderer *renderer,
 305                 GtkPackType      pack,
 306                 gboolean         expand,
 307                 gboolean         align)
 308 {
 309   CellInfo *info = g_slice_new (CellInfo);
 310
 311   info->renderer = g_object_ref_sink (renderer);
 312   info->pack     = pack;
 313   info->expand   = expand;
 314   info->align    = align;
 315
 316   return info;
 317 }
 318
 319 static void
 320 cell_info_free (CellInfo *info)
 321 {
 322   g_object_unref (info->renderer);
 323
 324   g_slice_free (CellInfo, info);
 325 }
 326
 327 static gint
 328 cell_info_find (CellInfo        *info,
 329                 GtkCellRenderer *renderer)
 330 {
 331   return (info->renderer == renderer) ? 0 : -1;
 332 }
 333
 334 static AllocatedCell *
 335 allocated_cell_new (GtkCellRenderer *renderer,
 336                     gint             position,
 337                     gint             size)
 338 {
 339   AllocatedCell *cell = g_slice_new (AllocatedCell);
 340
 341   cell->renderer = renderer;
 342   cell->position = position;
 343   cell->size     = size;
 344
 345   return cell;
 346 }
 347
 348 static void
 349 allocated_cell_free (AllocatedCell *cell)
 350 {
 351   g_slice_free (AllocatedCell, cell);
 352 }
 353
 354 static GList *
 355 list_consecutive_cells (GtkCellAreaBox *box)
 356 {
 357   GtkCellAreaBoxPrivate *priv = box->priv;
 358   GList                 *l, *consecutive_cells = NULL, *pack_end_cells = NULL;
 359   CellInfo              *info;
 360
 361   /* List cells in consecutive order taking their
 362    * PACK_START/PACK_END options into account
 363    */
 364   for (l = priv->cells; l; l = l->next)
 365     {
 366       info = l->data;
 367
 368       if (info->pack == GTK_PACK_START)
 369         consecutive_cells = g_list_prepend (consecutive_cells, info);
 370     }
 371
 372   for (l = priv->cells; l; l = l->next)
 373     {
 374       info = l->data;
 375
 376       if (info->pack == GTK_PACK_END)
 377         pack_end_cells = g_list_prepend (pack_end_cells, info);
 378     }
 379
 380   consecutive_cells = g_list_reverse (consecutive_cells);
 381   consecutive_cells = g_list_concat (consecutive_cells, pack_end_cells);
 382
 383   return consecutive_cells;
 384 }
 385
 386 static void
 387 cell_groups_clear (GtkCellAreaBox     *box)
 388 {
 389   GtkCellAreaBoxPrivate *priv  = box->priv;
 390   gint                   i;
 391
 392   for (i = 0; i < priv->groups->len; i++)
 393     {
 394       CellGroup *group = &g_array_index (priv->groups, CellGroup, i);
 395
 396       g_list_free (group->cells);
 397     }
 398
 399   g_array_set_size (priv->groups, 0);
 400 }
 401
 402 static void
 403 cell_groups_rebuild (GtkCellAreaBox *box)
 404 {
 405   GtkCellAreaBoxPrivate *priv  = box->priv;
 406   CellGroup              group = { 0, };
 407   CellGroup             *group_ptr;
 408   GList                 *cells, *l;
 409   guint                  id = 0;
 410
 411   cell_groups_clear (box);
 412
 413   if (!priv->cells)
 414     return;
 415
 416   cells = list_consecutive_cells (box);
 417
 418   /* First group is implied */
 419   g_array_append_val (priv->groups, group);
 420   group_ptr = &g_array_index (priv->groups, CellGroup, id);
 421
 422   for (l = cells; l; l = l->next)
 423     {
 424       CellInfo *info = l->data;
 425
 426       /* A new group starts with any aligned cell, the first group is implied */
 427       if (info->align && l != cells)
 428         {
 429           memset (&group, 0x0, sizeof (CellGroup));
 430           group.id = ++id;
 431
 432           g_array_append_val (priv->groups, group);
 433           group_ptr = &g_array_index (priv->groups, CellGroup, id);
 434         }
 435
 436       group_ptr->cells = g_list_prepend (group_ptr->cells, info);
 437       group_ptr->n_cells++;
 438
 439       /* A group expands if it contains any expand cells */
 440       if (info->expand)
 441         group_ptr->expand_cells++;
 442     }
 443
 444   g_list_free (cells);
 445
 446   for (id = 0; id < priv->groups->len; id++)
 447     {
 448       group_ptr = &g_array_index (priv->groups, CellGroup, id);
 449
 450       group_ptr->cells = g_list_reverse (group_ptr->cells);
 451     }
 452
 453   /* Iters need to be updated with the new grouping information */
 454   init_iter_groups (box);
 455 }
 456
 457 static gint
 458 count_visible_cells (CellGroup *group,
 459                      gint      *expand_cells)
 460 {
 461   GList *l;
 462   gint   visible_cells = 0;
 463   gint   n_expand_cells = 0;
 464
 465   for (l = group->cells; l; l = l->next)
 466     {
 467       CellInfo *info = l->data;
 468
 469       if (gtk_cell_renderer_get_visible (info->renderer))
 470         {
 471           visible_cells++;
 472
 473           if (info->expand)
 474             n_expand_cells++;
 475         }
 476     }
 477
 478   if (expand_cells)
 479     *expand_cells = n_expand_cells;
 480
 481   return visible_cells;
 482 }
 483
 484 static gint
 485 count_expand_groups (GtkCellAreaBox  *box)
 486 {
 487   GtkCellAreaBoxPrivate *priv = box->priv;
 488   gint                   i;
 489   gint                   expand_groups = 0;
 490
 491   for (i = 0; i < priv->groups->len; i++)
 492     {
 493       CellGroup *group = &g_array_index (priv->groups, CellGroup, i);
 494
 495       if (group->expand_cells > 0)
 496         expand_groups++;
 497     }
 498
 499   return expand_groups;
 500 }
 501
 502 static void
 503 iter_weak_notify (GtkCellAreaBox     *box,
 504                   GtkCellAreaBoxIter *dead_iter)
 505 {
 506   GtkCellAreaBoxPrivate *priv = box->priv;
 507
 508   priv->iters = g_slist_remove (priv->iters, dead_iter);
 509 }
 510
 511 static void
 512 init_iter_group (GtkCellAreaBox     *box,
 513                  GtkCellAreaBoxIter *iter)
 514 {
 515   GtkCellAreaBoxPrivate *priv = box->priv;
 516   gint                  *expand_groups, i;
 517
 518   expand_groups = g_new (gboolean, priv->groups->len);
 519
 520   for (i = 0; i < priv->groups->len; i++)
 521     {
 522       CellGroup *group = &g_array_index (priv->groups, CellGroup, i);
 523
 524       expand_groups[i] = (group->expand_cells > 0);
 525     }
 526
 527   /* This call implies flushing the request info */
 528   gtk_cell_area_box_init_groups (iter, priv->groups->len, expand_groups);
 529   g_free (expand_groups);
 530 }
 531
 532 static void
 533 init_iter_groups (GtkCellAreaBox *box)
 534 {
 535   GtkCellAreaBoxPrivate *priv = box->priv;
 536   GSList                *l;
 537
 538   /* When the box's groups are reconstructed, iters need to
 539    * be reinitialized.
 540    */
 541   for (l = priv->iters; l; l = l->next)
 542     {
 543       GtkCellAreaBoxIter *iter = l->data;
 544
 545       init_iter_group (box, iter);
 546     }
 547 }
 548
 549 static void
 550 flush_iters (GtkCellAreaBox *box)
 551 {
 552   GtkCellAreaBoxPrivate *priv = box->priv;
 553   GSList                *l;
 554
 555   /* When the box layout changes, iters need to
 556    * be flushed and sizes for the box get requested again
 557    */
 558   for (l = priv->iters; l; l = l->next)
 559     {
 560       GtkCellAreaIter *iter = l->data;
 561
 562       gtk_cell_area_iter_flush (iter);
 563     }
 564 }
 565
 566 /* Returns an allocation for each cell in the orientation of the box,
 567  * used in ->render()/->event() implementations to get a straight-forward
 568  * list of allocated cells to operate on.
 569  */
 570 static GSList *
 571 get_allocated_cells (GtkCellAreaBox     *box,
 572                      GtkCellAreaBoxIter *iter,
 573                      GtkWidget          *widget)
 574 {
 575   const GtkCellAreaBoxAllocation *group_allocs;
 576   GtkCellArea                    *area = GTK_CELL_AREA (box);
 577   GtkCellAreaBoxPrivate          *priv = box->priv;
 578   GList                          *cell_list;
 579   GSList                         *allocated_cells = NULL;
 580   gint                            i, j, n_allocs;
 581
 582   group_allocs = gtk_cell_area_box_iter_get_orientation_allocs (iter, &n_allocs);
 583   if (!group_allocs)
 584     {
 585       g_warning ("Trying to operate on an unallocated GtkCellAreaIter, "
 586                  "GtkCellAreaBox requires that the iter be allocated at least "
 587                  "in the orientation of the box");
 588       return NULL;
 589     }
 590
 591   for (i = 0; i < n_allocs; i++)
 592     {
 593       /* We dont always allocate all groups, sometimes the requested group has only invisible
 594        * cells for every row, hence the usage of group_allocs[i].group_idx here
 595        */
 596       CellGroup *group = &g_array_index (priv->groups, CellGroup, group_allocs[i].group_idx);
 597
 598       /* Exception for single cell groups */
 599       if (group->n_cells == 1)
 600         {
 601           CellInfo      *info = group->cells->data;
 602           AllocatedCell *cell =
 603             allocated_cell_new (info->renderer, group_allocs[i].position, group_allocs[i].size);
 604
 605           allocated_cells = g_slist_prepend (allocated_cells, cell);
 606         }
 607       else
 608         {
 609           GtkRequestedSize *sizes;
 610           gint              avail_size, position;
 611           gint              visible_cells, expand_cells;
 612           gint              extra_size, extra_extra;
 613
 614           visible_cells = count_visible_cells (group, &expand_cells);
 615
 616           /* If this row has no visible cells in this group, just
 617            * skip the allocation */
 618           if (visible_cells == 0)
 619             continue;
 620
 621           /* Offset the allocation to the group position and allocate into
 622            * the group's available size */
 623           position   = group_allocs[i].position;
 624           avail_size = group_allocs[i].size;
 625
 626           sizes = g_new (GtkRequestedSize, visible_cells);
 627
 628           for (j = 0, cell_list = group->cells; cell_list; cell_list = cell_list->next)
 629             {
 630               CellInfo *info = cell_list->data;
 631
 632               if (!gtk_cell_renderer_get_visible (info->renderer))
 633                 continue;
 634
 635               gtk_cell_area_request_renderer (area, info->renderer,
 636                                               priv->orientation,
 637                                               widget, -1,
 638                                               &sizes[j].minimum_size,
 639                                               &sizes[j].natural_size);
 640
 641               sizes[j].data = info;
 642               avail_size   -= sizes[j].minimum_size;
 643
 644               j++;
 645             }
 646
 647           /* Distribute cells naturally within the group */
 648           avail_size -= (visible_cells - 1) * priv->spacing;
 649           avail_size = gtk_distribute_natural_allocation (avail_size, visible_cells, sizes);
 650
 651           /* Calculate/distribute expand for cells */
 652           if (expand_cells > 0)
 653             {
 654               extra_size  = avail_size / expand_cells;
 655               extra_extra = avail_size % expand_cells;
 656             }
 657           else
 658             extra_size = extra_extra = 0;
 659
 660           /* Create the allocated cells (loop only over visible cells here) */
 661           for (j = 0; j < visible_cells; j++)
 662             {
 663               CellInfo      *info = sizes[j].data;
 664               AllocatedCell *cell;
 665
 666               if (info->expand)
 667                 {
 668                   sizes[j].minimum_size += extra_size;
 669                   if (extra_extra)
 670                     {
 671                       sizes[j].minimum_size++;
 672                       extra_extra--;
 673                     }
 674                 }
 675
 676               cell = allocated_cell_new (info->renderer, position, sizes[j].minimum_size);
 677
 678               allocated_cells = g_slist_prepend (allocated_cells, cell);
 679
 680               position += sizes[j].minimum_size;
 681               position += priv->spacing;
 682             }
 683
 684           g_free (sizes);
 685         }
 686     }
 687
 688   /* Note it might not be important to reverse the list here at all,
 689    * we have the correct positions, no need to allocate from left to right */
 690   return g_slist_reverse (allocated_cells);
 691 }
 692
 693 /*************************************************************
 694  *                      GObjectClass                         *
 695  *************************************************************/
 696 static void
 697 gtk_cell_area_box_finalize (GObject *object)
 698 {
 699   GtkCellAreaBox        *box = GTK_CELL_AREA_BOX (object);
 700   GtkCellAreaBoxPrivate *priv = box->priv;
 701   GSList                *l;
 702
 703   /* Unref/free the iter list */
 704   for (l = priv->iters; l; l = l->next)
 705     g_object_weak_unref (G_OBJECT (l->data), (GWeakNotify)iter_weak_notify, box);
 706
 707   g_slist_free (priv->iters);
 708   priv->iters = NULL;
 709
 710   /* Free the cell grouping info */
 711   cell_groups_clear (box);
 712   g_array_free (priv->groups, TRUE);
 713
 714   G_OBJECT_CLASS (gtk_cell_area_box_parent_class)->finalize (object);
 715 }
 716
 717 static void
 718 gtk_cell_area_box_dispose (GObject *object)
 719 {
 720   G_OBJECT_CLASS (gtk_cell_area_box_parent_class)->dispose (object);
 721 }
 722
 723 static void
 724 gtk_cell_area_box_set_property (GObject       *object,
 725                                 guint          prop_id,
 726                                 const GValue  *value,
 727                                 GParamSpec    *pspec)
 728 {
 729   GtkCellAreaBox *box = GTK_CELL_AREA_BOX (object);
 730
 731   switch (prop_id)
 732     {
 733     case PROP_ORIENTATION:
 734       box->priv->orientation = g_value_get_enum (value);
 735
 736       /* Notify that size needs to be requested again */
 737       flush_iters (box);
 738       break;
 739     case PROP_SPACING:
 740       gtk_cell_area_box_set_spacing (box, g_value_get_int (value));
 741       break;
 742     default:
 743       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 744       break;
 745     }
 746 }
 747
 748 static void
 749 gtk_cell_area_box_get_property (GObject     *object,
 750                                 guint        prop_id,
 751                                 GValue      *value,
 752                                 GParamSpec  *pspec)
 753 {
 754   GtkCellAreaBox *box = GTK_CELL_AREA_BOX (object);
 755
 756   switch (prop_id)
 757     {
 758     case PROP_ORIENTATION:
 759       g_value_set_enum (value, box->priv->orientation);
 760       break;
 761     case PROP_SPACING:
 762       g_value_set_int (value, gtk_cell_area_box_get_spacing (box));
 763       break;
 764     default:
 765       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 766       break;
 767     }
 768 }
 769
 770 /*************************************************************
 771  *                    GtkCellAreaClass                       *
 772  *************************************************************/
 773 static void
 774 gtk_cell_area_box_add (GtkCellArea        *area,
 775                        GtkCellRenderer    *renderer)
 776 {
 777   gtk_cell_area_box_pack_start (GTK_CELL_AREA_BOX (area),
 778                                 renderer, FALSE, TRUE);
 779 }
 780
 781 static void
 782 gtk_cell_area_box_remove (GtkCellArea        *area,
 783                           GtkCellRenderer    *renderer)
 784 {
 785   GtkCellAreaBox        *box  = GTK_CELL_AREA_BOX (area);
 786   GtkCellAreaBoxPrivate *priv = box->priv;
 787   GList                 *node;
 788
 789   node = g_list_find_custom (priv->cells, renderer,
 790                              (GCompareFunc)cell_info_find);
 791
 792   if (node)
 793     {
 794       CellInfo *info = node->data;
 795
 796       cell_info_free (info);
 797
 798       priv->cells = g_list_delete_link (priv->cells, node);
 799
 800       /* Reconstruct cell groups */
 801       cell_groups_rebuild (box);
 802     }
 803   else
 804     g_warning ("Trying to remove a cell renderer that is not present GtkCellAreaBox");
 805 }
 806
 807 static void
 808 gtk_cell_area_box_forall (GtkCellArea        *area,
 809                           GtkCellCallback     callback,
 810                           gpointer            callback_data)
 811 {
 812   GtkCellAreaBox        *box  = GTK_CELL_AREA_BOX (area);
 813   GtkCellAreaBoxPrivate *priv = box->priv;
 814   GList                 *list;
 815
 816   for (list = priv->cells; list; list = list->next)
 817     {
 818       CellInfo *info = list->data;
 819
 820       callback (info->renderer, callback_data);
 821     }
 822 }
 823
 824 static void
 825 gtk_cell_area_box_get_cell_allocation (GtkCellArea          *area,
 826                                        GtkCellAreaIter      *iter,
 827                                        GtkWidget            *widget,
 828                                        GtkCellRenderer      *renderer,
 829                                        const GdkRectangle   *cell_area,
 830                                        GdkRectangle         *allocation)
 831 {
 832   GtkCellAreaBox        *box      = GTK_CELL_AREA_BOX (area);
 833   GtkCellAreaBoxPrivate *priv     = box->priv;
 834   GtkCellAreaBoxIter    *box_iter = GTK_CELL_AREA_BOX_ITER (iter);
 835   GSList                *allocated_cells, *l;
 836
 837   *allocation = *cell_area;
 838
 839   /* Get a list of cells with allocation sizes decided regardless
 840    * of alignments and pack order etc. */
 841   allocated_cells = get_allocated_cells (box, box_iter, widget);
 842
 843   for (l = allocated_cells; l; l = l->next)
 844     {
 845       AllocatedCell *cell = l->data;
 846
 847       if (cell->renderer == renderer)
 848         {
 849           if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
 850             {
 851               allocation->x     = cell_area->x + cell->position;
 852               allocation->width = cell->size;
 853             }
 854           else
 855             {
 856               allocation->y      = cell_area->y + cell->position;
 857               allocation->height = cell->size;
 858             }
 859
 860           break;
 861         }
 862     }
 863
 864   g_slist_foreach (allocated_cells, (GFunc)allocated_cell_free, NULL);
 865   g_slist_free (allocated_cells);
 866 }
 867
 868 enum {
 869   FOCUS_NONE,
 870   FOCUS_PREV,
 871   FOCUS_NEXT
 872 };
 873
 874 static gint
 875 gtk_cell_area_box_event (GtkCellArea          *area,
 876                          GtkCellAreaIter      *iter,
 877                          GtkWidget            *widget,
 878                          GdkEvent             *event,
 879                          const GdkRectangle   *cell_area,
 880                          GtkCellRendererState  flags)
 881 {
 882   gint retval;
 883
 884   /* First let the parent class handle activation of cells via keystrokes */
 885   retval =
 886     GTK_CELL_AREA_CLASS (gtk_cell_area_box_parent_class)->event (area, iter, widget,
 887                                                                  event, cell_area, flags);
 888
 889   if (retval)
 890     return retval;
 891
 892   /* Also detect mouse events, for mouse events we need to allocate the renderers
 893    * and find which renderer needs to be activated.
 894    */
 895   if (event->type == GDK_BUTTON_PRESS)
 896     {
 897       GdkEventButton *button_event = (GdkEventButton *)event;
 898
 899       if (button_event->button == 1)
 900         {
 901           GtkCellAreaBox        *box      = GTK_CELL_AREA_BOX (area);
 902           GtkCellAreaBoxPrivate *priv     = box->priv;
 903           GtkCellAreaBoxIter    *box_iter = GTK_CELL_AREA_BOX_ITER (iter);
 904           GSList                *allocated_cells, *l;
 905           GdkRectangle           cell_background, inner_area;
 906           GtkAllocation          allocation;
 907           gint                   event_x, event_y;
 908
 909           gtk_widget_get_allocation (widget, &allocation);
 910
 911           /* We may need some semantics to tell us the offset of the event
 912            * window we are handling events for (i.e. GtkTreeView has a bin_window) */
 913           event_x = button_event->x;
 914           event_y = button_event->y;
 915
 916           cell_background = *cell_area;
 917
 918           /* Get a list of cells with allocation sizes decided regardless
 919            * of alignments and pack order etc. */
 920           allocated_cells = get_allocated_cells (box, box_iter, widget);
 921
 922           for (l = allocated_cells; l; l = l->next)
 923             {
 924               AllocatedCell *cell = l->data;
 925
 926               if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
 927                 {
 928                   cell_background.x     = cell_area->x + cell->position;
 929                   cell_background.width = cell->size;
 930                 }
 931               else
 932                 {
 933                   cell_background.y      = cell_area->y + cell->position;
 934                   cell_background.height = cell->size;
 935                 }
 936
 937               /* Remove margins from the background area to produce the cell area
 938                */
 939               gtk_cell_area_inner_cell_area (area, &cell_background, &inner_area);
 940
 941               if (event_x >= inner_area.x && event_x <= inner_area.x + inner_area.width &&
 942                   event_y >= inner_area.y && event_y <= inner_area.y + inner_area.height)
 943                 {
 944                   GtkCellRenderer *event_renderer = NULL;
 945
 946                   if (gtk_cell_renderer_can_focus (cell->renderer))
 947                     event_renderer = cell->renderer;
 948                   else
 949                     {
 950                       GtkCellRenderer *focus_renderer;
 951
 952                       /* A renderer can have focus siblings but that renderer might not be
 953                        * focusable for every row... so we go on to check can_focus here. */
 954                       focus_renderer = gtk_cell_area_get_focus_from_sibling (area, cell->renderer);
 955
 956                       if (focus_renderer && gtk_cell_renderer_can_focus (focus_renderer))
 957                         event_renderer = focus_renderer;
 958                     }
 959
 960                   if (event_renderer)
 961                     {
 962                       if (gtk_cell_area_get_edited_cell (area))
 963                         {
 964                           /* XXX Was it really canceled in this case ? */
 965                           gtk_cell_area_stop_editing (area, TRUE);
 966                           gtk_cell_area_set_focus_cell (area, event_renderer);
 967                           retval = TRUE;
 968                         }
 969                       else
 970                         {
 971                           /* If we are activating via a focus sibling, we need to fix the
 972                            * cell area */
 973                           if (event_renderer != cell->renderer)
 974                             gtk_cell_area_inner_cell_area (area, cell_area, &cell_background);
 975
 976                           gtk_cell_area_set_focus_cell (area, event_renderer);
 977
 978                           retval = gtk_cell_area_activate_cell (area, widget, event_renderer,
 979                                                                 event, &cell_background, flags);
 980                         }
 981                       break;
 982                     }
 983                 }
 984             }
 985           g_slist_foreach (allocated_cells, (GFunc)allocated_cell_free, NULL);
 986           g_slist_free (allocated_cells);
 987         }
 988     }
 989
 990   return retval;
 991 }
 992
 993 static void
 994 gtk_cell_area_box_render (GtkCellArea          *area,
 995                           GtkCellAreaIter      *iter,
 996                           GtkWidget            *widget,
 997                           cairo_t              *cr,
 998                           const GdkRectangle   *background_area,
 999                           const GdkRectangle   *cell_area,
1000                           GtkCellRendererState  flags,
1001                           gboolean              paint_focus)
1002 {
1003   GtkCellAreaBox        *box      = GTK_CELL_AREA_BOX (area);
1004   GtkCellAreaBoxPrivate *priv     = box->priv;
1005   GtkCellAreaBoxIter    *box_iter = GTK_CELL_AREA_BOX_ITER (iter);
1006   GSList                *allocated_cells, *l;
1007   GdkRectangle           cell_background, inner_area;
1008   GtkCellRenderer       *focus_cell = NULL;
1009   GdkRectangle           focus_rect = { 0, };
1010   gboolean               first_focus_cell = TRUE;
1011
1012   if (flags & GTK_CELL_RENDERER_FOCUSED)
1013     {
1014       focus_cell = gtk_cell_area_get_focus_cell (area);
1015       flags &= ~GTK_CELL_RENDERER_FOCUSED;
1016     }
1017
1018   cell_background = *cell_area;
1019
1020   /* Get a list of cells with allocation sizes decided regardless
1021    * of alignments and pack order etc. */
1022   allocated_cells = get_allocated_cells (box, box_iter, widget);
1023
1024   for (l = allocated_cells; l; l = l->next)
1025     {
1026       AllocatedCell       *cell = l->data;
1027       GtkCellRendererState cell_fields = 0;
1028
1029       if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
1030         {
1031           cell_background.x     = cell_area->x + cell->position;
1032           cell_background.width = cell->size;
1033         }
1034       else
1035         {
1036           cell_background.y      = cell_area->y + cell->position;
1037           cell_background.height = cell->size;
1038         }
1039
1040       /* Remove margins from the background area to produce the cell area
1041        */
1042       gtk_cell_area_inner_cell_area (area, &cell_background, &inner_area);
1043
1044       /* XXX TODO Here after getting the inner area of the cell background,
1045        * add portions of the background area to the cell background */
1046
1047       if (focus_cell &&
1048           (cell->renderer == focus_cell ||
1049            gtk_cell_area_is_focus_sibling (area, focus_cell, cell->renderer)))
1050         {
1051           cell_fields |= GTK_CELL_RENDERER_FOCUSED;
1052
1053           if (paint_focus)
1054             {
1055               GdkRectangle cell_focus;
1056               gint         opposite_size, x_offset, y_offset;
1057
1058               cell_focus = inner_area;
1059
1060               /* Trim up the focus size */
1061               if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
1062                 {
1063                   gtk_cell_renderer_get_preferred_height_for_width (cell->renderer, widget,
1064                                                                     cell_focus.width,
1065                                                                     NULL, &opposite_size);
1066
1067                   cell_focus.height = MIN (opposite_size, cell_focus.height);
1068                 }
1069               else
1070                 {
1071                   gtk_cell_renderer_get_preferred_width_for_height (cell->renderer, widget,
1072                                                                     cell_focus.height,
1073                                                                     NULL, &opposite_size);
1074
1075                   cell_focus.width = MIN (opposite_size, cell_focus.width);
1076                 }
1077
1078               /* offset the cell position */
1079               _gtk_cell_renderer_calc_offset (cell->renderer, &inner_area, GTK_TEXT_DIR_LTR,
1080                                               cell_focus.width, cell_focus.height,
1081                                               &x_offset, &y_offset);
1082
1083               cell_focus.x += x_offset;
1084               cell_focus.y += y_offset;
1085
1086               /* Accumulate the focus rectangle for all focus siblings */
1087               if (first_focus_cell)
1088                 {
1089                   focus_rect       = cell_focus;
1090                   first_focus_cell = FALSE;
1091                 }
1092               else
1093                 gdk_rectangle_union (&focus_rect, &cell_focus, &focus_rect);
1094             }
1095         }
1096
1097       /* We have to do some per-cell considerations for the 'flags'
1098        * for focus handling */
1099       gtk_cell_renderer_render (cell->renderer, cr, widget,
1100                                 &cell_background, &inner_area,
1101                                 flags | cell_fields);
1102     }
1103
1104   if (paint_focus && focus_rect.width != 0 && focus_rect.height != 0)
1105     {
1106       GtkStateType renderer_state =
1107         flags & GTK_CELL_RENDERER_SELECTED ? GTK_STATE_SELECTED :
1108         (flags & GTK_CELL_RENDERER_PRELIT ? GTK_STATE_PRELIGHT :
1109          (flags & GTK_CELL_RENDERER_INSENSITIVE ? GTK_STATE_INSENSITIVE : GTK_STATE_NORMAL));
1110
1111       gtk_paint_focus (gtk_widget_get_style (widget),
1112                        cr, renderer_state,
1113                        widget,
1114                        /* XXX This hint should be a property on GtkCellArea I suppose */
1115                        "treeview",
1116                        focus_rect.x,
1117                        focus_rect.y,
1118                        focus_rect.width,
1119                        focus_rect.height);
1120     }
1121
1122
1123   g_slist_foreach (allocated_cells, (GFunc)allocated_cell_free, NULL);
1124   g_slist_free (allocated_cells);
1125 }
1126
1127 static void
1128 gtk_cell_area_box_set_cell_property (GtkCellArea        *area,
1129                                      GtkCellRenderer    *renderer,
1130                                      guint               prop_id,
1131                                      const GValue       *value,
1132                                      GParamSpec         *pspec)
1133 {
1134   GtkCellAreaBox        *box  = GTK_CELL_AREA_BOX (area);
1135   GtkCellAreaBoxPrivate *priv = box->priv;
1136   GList                 *node;
1137   CellInfo              *info;
1138   gboolean               rebuild = FALSE;
1139   gboolean               val;
1140   GtkPackType            pack_type;
1141
1142   node = g_list_find_custom (priv->cells, renderer,
1143                              (GCompareFunc)cell_info_find);
1144   if (!node)
1145     return;
1146
1147   info = node->data;
1148
1149   switch (prop_id)
1150     {
1151     case CELL_PROP_EXPAND:
1152       val = g_value_get_boolean (value);
1153
1154       if (info->expand != val)
1155         {
1156           info->expand = val;
1157           rebuild      = TRUE;
1158         }
1159       break;
1160
1161     case CELL_PROP_ALIGN:
1162       val = g_value_get_boolean (value);
1163
1164       if (info->align != val)
1165         {
1166           info->align = val;
1167           rebuild     = TRUE;
1168         }
1169       break;
1170
1171     case CELL_PROP_PACK_TYPE:
1172       pack_type = g_value_get_enum (value);
1173
1174       if (info->pack != pack_type)
1175         {
1176           info->pack = pack_type;
1177           rebuild    = TRUE;
1178         }
1179       break;
1180     default:
1181       GTK_CELL_AREA_WARN_INVALID_CHILD_PROPERTY_ID (area, prop_id, pspec);
1182       break;
1183     }
1184
1185   /* Groups need to be rebuilt */
1186   if (rebuild)
1187     cell_groups_rebuild (box);
1188 }
1189
1190 static void
1191 gtk_cell_area_box_get_cell_property (GtkCellArea        *area,
1192                                      GtkCellRenderer    *renderer,
1193                                      guint               prop_id,
1194                                      GValue             *value,
1195                                      GParamSpec         *pspec)
1196 {
1197   GtkCellAreaBox        *box  = GTK_CELL_AREA_BOX (area);
1198   GtkCellAreaBoxPrivate *priv = box->priv;
1199   GList                 *node;
1200   CellInfo              *info;
1201
1202   node = g_list_find_custom (priv->cells, renderer,
1203                              (GCompareFunc)cell_info_find);
1204   if (!node)
1205     return;
1206
1207   info = node->data;
1208
1209   switch (prop_id)
1210     {
1211     case CELL_PROP_EXPAND:
1212       g_value_set_boolean (value, info->expand);
1213       break;
1214
1215     case CELL_PROP_ALIGN:
1216       g_value_set_boolean (value, info->align);
1217       break;
1218
1219     case CELL_PROP_PACK_TYPE:
1220       g_value_set_enum (value, info->pack);
1221       break;
1222     default:
1223       GTK_CELL_AREA_WARN_INVALID_CHILD_PROPERTY_ID (area, prop_id, pspec);
1224       break;
1225     }
1226 }
1227
1228
1229 static GtkCellAreaIter *
1230 gtk_cell_area_box_create_iter (GtkCellArea *area)
1231 {
1232   GtkCellAreaBox        *box  = GTK_CELL_AREA_BOX (area);
1233   GtkCellAreaBoxPrivate *priv = box->priv;
1234   GtkCellAreaIter       *iter =
1235     (GtkCellAreaIter *)g_object_new (GTK_TYPE_CELL_AREA_BOX_ITER,
1236                                      "area", area, NULL);
1237
1238   priv->iters = g_slist_prepend (priv->iters, iter);
1239
1240   g_object_weak_ref (G_OBJECT (iter), (GWeakNotify)iter_weak_notify, box);
1241
1242   /* Tell the new group about our cell layout */
1243   init_iter_group (box, GTK_CELL_AREA_BOX_ITER (iter));
1244
1245   return iter;
1246 }
1247
1248 static GtkSizeRequestMode
1249 gtk_cell_area_box_get_request_mode (GtkCellArea *area)
1250 {
1251   GtkCellAreaBox        *box  = GTK_CELL_AREA_BOX (area);
1252   GtkCellAreaBoxPrivate *priv = box->priv;
1253
1254   return (priv->orientation) == GTK_ORIENTATION_HORIZONTAL ?
1255     GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH :
1256     GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT;
1257 }
1258
1259 static void
1260 compute_size (GtkCellAreaBox     *box,
1261               GtkOrientation      orientation,
1262               GtkCellAreaBoxIter *iter,
1263               GtkWidget          *widget,
1264               gint                for_size,
1265               gint               *minimum_size,
1266               gint               *natural_size)
1267 {
1268   GtkCellAreaBoxPrivate *priv = box->priv;
1269   GtkCellArea           *area = GTK_CELL_AREA (box);
1270   GList                 *list;
1271   gint                   i;
1272   gint                   min_size = 0;
1273   gint                   nat_size = 0;
1274
1275   for (i = 0; i < priv->groups->len; i++)
1276     {
1277       CellGroup *group = &g_array_index (priv->groups, CellGroup, i);
1278       gint       group_min_size = 0;
1279       gint       group_nat_size = 0;
1280
1281       for (list = group->cells; list; list = list->next)
1282         {
1283           CellInfo *info = list->data;
1284           gint      renderer_min_size, renderer_nat_size;
1285
1286           if (!gtk_cell_renderer_get_visible (info->renderer))
1287               continue;
1288
1289           gtk_cell_area_request_renderer (area, info->renderer, orientation, widget, for_size,
1290                                           &renderer_min_size, &renderer_nat_size);
1291
1292           if (orientation == priv->orientation)
1293             {
1294               if (min_size > 0)
1295                 {
1296                   min_size += priv->spacing;
1297                   nat_size += priv->spacing;
1298                 }
1299
1300               if (group_min_size > 0)
1301                 {
1302                   group_min_size += priv->spacing;
1303                   group_nat_size += priv->spacing;
1304                 }
1305
1306               min_size       += renderer_min_size;
1307               nat_size       += renderer_nat_size;
1308               group_min_size += renderer_min_size;
1309               group_nat_size += renderer_nat_size;
1310             }
1311           else
1312             {
1313               min_size       = MAX (min_size, renderer_min_size);
1314               nat_size       = MAX (nat_size, renderer_nat_size);
1315               group_min_size = MAX (group_min_size, renderer_min_size);
1316               group_nat_size = MAX (group_nat_size, renderer_nat_size);
1317             }
1318         }
1319
1320       if (orientation == GTK_ORIENTATION_HORIZONTAL)
1321         {
1322           if (for_size < 0)
1323             gtk_cell_area_box_iter_push_group_width (iter, group->id, group_min_size, group_nat_size);
1324           else
1325             gtk_cell_area_box_iter_push_group_width_for_height (iter, group->id, for_size,
1326                                                                 group_min_size, group_nat_size);
1327         }
1328       else
1329         {
1330           if (for_size < 0)
1331             gtk_cell_area_box_iter_push_group_height (iter, group->id, group_min_size, group_nat_size);
1332           else
1333             gtk_cell_area_box_iter_push_group_height_for_width (iter, group->id, for_size,
1334                                                                 group_min_size, group_nat_size);
1335         }
1336     }
1337
1338   *minimum_size = min_size;
1339   *natural_size = nat_size;
1340 }
1341
1342 GtkRequestedSize *
1343 get_group_sizes (GtkCellArea    *area,
1344                  CellGroup      *group,
1345                  GtkOrientation  orientation,
1346                  GtkWidget      *widget,
1347                  gint           *n_sizes)
1348 {
1349   GtkRequestedSize *sizes;
1350   GList            *l;
1351   gint              i;
1352
1353   *n_sizes = count_visible_cells (group, NULL);
1354   sizes    = g_new (GtkRequestedSize, *n_sizes);
1355
1356   for (l = group->cells, i = 0; l; l = l->next)
1357     {
1358       CellInfo *info = l->data;
1359
1360       if (!gtk_cell_renderer_get_visible (info->renderer))
1361         continue;
1362
1363       sizes[i].data = info;
1364
1365       gtk_cell_area_request_renderer (area, info->renderer,
1366                                       orientation, widget, -1,
1367                                       &sizes[i].minimum_size,
1368                                       &sizes[i].natural_size);
1369
1370       i++;
1371     }
1372
1373   return sizes;
1374 }
1375
1376 static void
1377 compute_group_size_for_opposing_orientation (GtkCellAreaBox     *box,
1378                                              CellGroup          *group,
1379                                              GtkWidget          *widget,
1380                                              gint                for_size,
1381                                              gint               *minimum_size,
1382                                              gint               *natural_size)
1383 {
1384   GtkCellAreaBoxPrivate *priv = box->priv;
1385   GtkCellArea           *area = GTK_CELL_AREA (box);
1386
1387   /* Exception for single cell groups */
1388   if (group->n_cells == 1)
1389     {
1390       CellInfo *info = group->cells->data;
1391
1392       gtk_cell_area_request_renderer (area, info->renderer,
1393                                       OPPOSITE_ORIENTATION (priv->orientation),
1394                                       widget, for_size, minimum_size, natural_size);
1395     }
1396   else
1397     {
1398       GtkRequestedSize *orientation_sizes;
1399       CellInfo         *info;
1400       gint              n_sizes, i;
1401       gint              avail_size     = for_size;
1402       gint              extra_size, extra_extra;
1403       gint              min_size = 0, nat_size = 0;
1404
1405       orientation_sizes = get_group_sizes (area, group, priv->orientation, widget, &n_sizes);
1406
1407       /* First naturally allocate the cells in the group into the for_size */
1408       avail_size -= (n_sizes - 1) * priv->spacing;
1409       for (i = 0; i < n_sizes; i++)
1410         avail_size -= orientation_sizes[i].minimum_size;
1411
1412       avail_size = gtk_distribute_natural_allocation (avail_size, n_sizes, orientation_sizes);
1413
1414       /* Calculate/distribute expand for cells */
1415       if (group->expand_cells > 0)
1416         {
1417           extra_size  = avail_size / group->expand_cells;
1418           extra_extra = avail_size % group->expand_cells;
1419         }
1420       else
1421         extra_size = extra_extra = 0;
1422
1423       for (i = 0; i < n_sizes; i++)
1424         {
1425           gint cell_min, cell_nat;
1426
1427           info = orientation_sizes[i].data;
1428
1429           if (info->expand)
1430             {
1431               orientation_sizes[i].minimum_size += extra_size;
1432               if (extra_extra)
1433                 {
1434                   orientation_sizes[i].minimum_size++;
1435                   extra_extra--;
1436                 }
1437             }
1438
1439           gtk_cell_area_request_renderer (area, info->renderer,
1440                                           OPPOSITE_ORIENTATION (priv->orientation),
1441                                           widget,
1442                                           orientation_sizes[i].minimum_size,
1443                                           &cell_min, &cell_nat);
1444
1445           min_size = MAX (min_size, cell_min);
1446           nat_size = MAX (nat_size, cell_nat);
1447         }
1448
1449       *minimum_size = min_size;
1450       *natural_size = nat_size;
1451
1452       g_free (orientation_sizes);
1453     }
1454 }
1455
1456 static void
1457 compute_size_for_opposing_orientation (GtkCellAreaBox     *box,
1458                                        GtkCellAreaBoxIter *iter,
1459                                        GtkWidget          *widget,
1460                                        gint                for_size,
1461                                        gint               *minimum_size,
1462                                        gint               *natural_size)
1463 {
1464   GtkCellAreaBoxPrivate *priv = box->priv;
1465   CellGroup             *group;
1466   GtkRequestedSize      *orientation_sizes;
1467   gint                   n_groups, n_expand_groups, i;
1468   gint                   avail_size = for_size;
1469   gint                   extra_size, extra_extra;
1470   gint                   min_size = 0, nat_size = 0;
1471
1472   n_expand_groups = count_expand_groups (box);
1473
1474   if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
1475     orientation_sizes = gtk_cell_area_box_iter_get_widths (iter, &n_groups);
1476   else
1477     orientation_sizes = gtk_cell_area_box_iter_get_heights (iter, &n_groups);
1478
1479   /* First start by naturally allocating space among groups of cells */
1480   avail_size -= (n_groups - 1) * priv->spacing;
1481   for (i = 0; i < n_groups; i++)
1482     avail_size -= orientation_sizes[i].minimum_size;
1483
1484   avail_size = gtk_distribute_natural_allocation (avail_size, n_groups, orientation_sizes);
1485
1486   /* Calculate/distribute expand for groups */
1487   if (n_expand_groups > 0)
1488     {
1489       extra_size  = avail_size / n_expand_groups;
1490       extra_extra = avail_size % n_expand_groups;
1491     }
1492   else
1493     extra_size = extra_extra = 0;
1494
1495   /* Now we need to naturally allocate sizes for cells in each group
1496    * and push the height-for-width for each group accordingly while accumulating
1497    * the overall height-for-width for this row.
1498    */
1499   for (i = 0; i < n_groups; i++)
1500     {
1501       gint group_min, group_nat;
1502       gint group_idx = GPOINTER_TO_INT (orientation_sizes[i].data);
1503
1504       group = &g_array_index (priv->groups, CellGroup, group_idx);
1505
1506       if (group->expand_cells > 0)
1507         {
1508           orientation_sizes[i].minimum_size += extra_size;
1509           if (extra_extra)
1510             {
1511               orientation_sizes[i].minimum_size++;
1512               extra_extra--;
1513             }
1514         }
1515
1516       /* Now we have the allocation for the group, request it's height-for-width */
1517       compute_group_size_for_opposing_orientation (box, group, widget,
1518                                                    orientation_sizes[i].minimum_size,
1519                                                    &group_min, &group_nat);
1520
1521       min_size = MAX (min_size, group_min);
1522       nat_size = MAX (nat_size, group_nat);
1523
1524       if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
1525         {
1526           gtk_cell_area_box_iter_push_group_height_for_width (iter, group_idx, for_size,
1527                                                               group_min, group_nat);
1528         }
1529       else
1530         {
1531           gtk_cell_area_box_iter_push_group_width_for_height (iter, group_idx, for_size,
1532                                                               group_min, group_nat);
1533         }
1534     }
1535
1536   *minimum_size = min_size;
1537   *natural_size = nat_size;
1538
1539   g_free (orientation_sizes);
1540 }
1541
1542
1543
1544 static void
1545 gtk_cell_area_box_get_preferred_width (GtkCellArea        *area,
1546                                        GtkCellAreaIter    *iter,
1547                                        GtkWidget          *widget,
1548                                        gint               *minimum_width,
1549                                        gint               *natural_width)
1550 {
1551   GtkCellAreaBox        *box = GTK_CELL_AREA_BOX (area);
1552   GtkCellAreaBoxIter    *box_iter;
1553   gint                   min_width, nat_width;
1554
1555   g_return_if_fail (GTK_IS_CELL_AREA_BOX_ITER (iter));
1556
1557   box_iter = GTK_CELL_AREA_BOX_ITER (iter);
1558
1559   /* Compute the size of all renderers for current row data,
1560    * bumping cell alignments in the iter along the way */
1561   compute_size (box, GTK_ORIENTATION_HORIZONTAL,
1562                 box_iter, widget, -1, &min_width, &nat_width);
1563
1564   if (minimum_width)
1565     *minimum_width = min_width;
1566
1567   if (natural_width)
1568     *natural_width = nat_width;
1569 }
1570
1571 static void
1572 gtk_cell_area_box_get_preferred_height (GtkCellArea        *area,
1573                                         GtkCellAreaIter    *iter,
1574                                         GtkWidget          *widget,
1575                                         gint               *minimum_height,
1576                                         gint               *natural_height)
1577 {
1578   GtkCellAreaBox        *box = GTK_CELL_AREA_BOX (area);
1579   GtkCellAreaBoxIter    *box_iter;
1580   gint                   min_height, nat_height;
1581
1582   g_return_if_fail (GTK_IS_CELL_AREA_BOX_ITER (iter));
1583
1584   box_iter = GTK_CELL_AREA_BOX_ITER (iter);
1585
1586   /* Compute the size of all renderers for current row data,
1587    * bumping cell alignments in the iter along the way */
1588   compute_size (box, GTK_ORIENTATION_VERTICAL,
1589                 box_iter, widget, -1, &min_height, &nat_height);
1590
1591   if (minimum_height)
1592     *minimum_height = min_height;
1593
1594   if (natural_height)
1595     *natural_height = nat_height;
1596 }
1597
1598 static void
1599 gtk_cell_area_box_get_preferred_height_for_width (GtkCellArea        *area,
1600                                                   GtkCellAreaIter    *iter,
1601                                                   GtkWidget          *widget,
1602                                                   gint                width,
1603                                                   gint               *minimum_height,
1604                                                   gint               *natural_height)
1605 {
1606   GtkCellAreaBox        *box = GTK_CELL_AREA_BOX (area);
1607   GtkCellAreaBoxIter    *box_iter;
1608   GtkCellAreaBoxPrivate *priv;
1609   gint                   min_height, nat_height;
1610
1611   g_return_if_fail (GTK_IS_CELL_AREA_BOX_ITER (iter));
1612
1613   box_iter = GTK_CELL_AREA_BOX_ITER (iter);
1614   priv     = box->priv;
1615
1616   if (priv->orientation == GTK_ORIENTATION_VERTICAL)
1617     {
1618       /* Add up vertical requests of height for width and push the overall
1619        * cached sizes for alignments */
1620       compute_size (box, priv->orientation, box_iter, widget, width, &min_height, &nat_height);
1621     }
1622   else
1623     {
1624       /* Juice: virtually allocate cells into the for_width using the
1625        * alignments and then return the overall height for that width, and cache it */
1626       compute_size_for_opposing_orientation (box, box_iter, widget, width, &min_height, &nat_height);
1627     }
1628
1629   if (minimum_height)
1630     *minimum_height = min_height;
1631
1632   if (natural_height)
1633     *natural_height = nat_height;
1634 }
1635
1636 static void
1637 gtk_cell_area_box_get_preferred_width_for_height (GtkCellArea        *area,
1638                                                   GtkCellAreaIter    *iter,
1639                                                   GtkWidget          *widget,
1640                                                   gint                height,
1641                                                   gint               *minimum_width,
1642                                                   gint               *natural_width)
1643 {
1644   GtkCellAreaBox        *box = GTK_CELL_AREA_BOX (area);
1645   GtkCellAreaBoxIter    *box_iter;
1646   GtkCellAreaBoxPrivate *priv;
1647   gint                   min_width, nat_width;
1648
1649   g_return_if_fail (GTK_IS_CELL_AREA_BOX_ITER (iter));
1650
1651   box_iter = GTK_CELL_AREA_BOX_ITER (iter);
1652   priv     = box->priv;
1653
1654   if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
1655     {
1656       /* Add up horizontal requests of width for height and push the overall
1657        * cached sizes for alignments */
1658       compute_size (box, priv->orientation, box_iter, widget, height, &min_width, &nat_width);
1659     }
1660   else
1661     {
1662       /* Juice: horizontally allocate cells into the for_height using the
1663        * alignments and then return the overall width for that height, and cache it */
1664       compute_size_for_opposing_orientation (box, box_iter, widget, height, &min_width, &nat_width);
1665     }
1666
1667   if (minimum_width)
1668     *minimum_width = min_width;
1669
1670   if (natural_width)
1671     *natural_width = nat_width;
1672 }
1673
1674 static gboolean
1675 gtk_cell_area_box_focus (GtkCellArea      *area,
1676                          GtkDirectionType  direction)
1677 {
1678   GtkCellAreaBox        *box   = GTK_CELL_AREA_BOX (area);
1679   GtkCellAreaBoxPrivate *priv  = box->priv;
1680   gint                   cycle = FOCUS_NONE;
1681   gboolean               cycled_focus = FALSE;
1682   GtkCellRenderer       *focus_cell;
1683
1684   focus_cell = gtk_cell_area_get_focus_cell (area);
1685
1686   switch (direction)
1687     {
1688     case GTK_DIR_TAB_FORWARD:
1689       cycle = FOCUS_NEXT;
1690       break;
1691     case GTK_DIR_TAB_BACKWARD:
1692       cycle = FOCUS_PREV;
1693       break;
1694     case GTK_DIR_UP:
1695       if (priv->orientation == GTK_ORIENTATION_VERTICAL || !focus_cell)
1696         cycle = FOCUS_PREV;
1697       break;
1698     case GTK_DIR_DOWN:
1699       if (priv->orientation == GTK_ORIENTATION_VERTICAL || !focus_cell)
1700         cycle = FOCUS_NEXT;
1701       break;
1702     case GTK_DIR_LEFT:
1703       if (priv->orientation == GTK_ORIENTATION_HORIZONTAL || !focus_cell)
1704         cycle = FOCUS_PREV;
1705       break;
1706     case GTK_DIR_RIGHT:
1707       if (priv->orientation == GTK_ORIENTATION_HORIZONTAL || !focus_cell)
1708         cycle = FOCUS_NEXT;
1709       break;
1710     default:
1711       break;
1712     }
1713
1714   if (cycle != FOCUS_NONE)
1715     {
1716       gboolean  found_cell = FALSE;
1717       GList    *list;
1718       gint      i;
1719
1720       /* If there is no focused cell, focus on the first (or last) one in the list */
1721       if (!focus_cell)
1722         found_cell = TRUE;
1723
1724       for (i = (cycle == FOCUS_NEXT) ? 0 : priv->groups->len -1;
1725            cycled_focus == FALSE && i >= 0 && i < priv->groups->len;
1726            i = (cycle == FOCUS_NEXT) ? i + 1 : i - 1)
1727         {
1728           CellGroup *group = &g_array_index (priv->groups, CellGroup, i);
1729
1730           for (list = (cycle == FOCUS_NEXT) ? g_list_first (group->cells) : g_list_last (group->cells);
1731                list; list = (cycle == FOCUS_NEXT) ? list->next : list->prev)
1732             {
1733               CellInfo *info = list->data;
1734
1735               if (info->renderer == focus_cell)
1736                 found_cell = TRUE;
1737               else if (found_cell)
1738                 {
1739                   if (gtk_cell_renderer_can_focus (info->renderer))
1740                     {
1741                       gtk_cell_area_set_focus_cell (area, info->renderer);
1742
1743                       cycled_focus = TRUE;
1744                       break;
1745                     }
1746                 }
1747             }
1748         }
1749     }
1750
1751   if (!cycled_focus)
1752     gtk_cell_area_set_focus_cell (area, NULL);
1753
1754   return cycled_focus;
1755 }
1756
1757
1758 /*************************************************************
1759  *                    GtkCellLayoutIface                     *
1760  *************************************************************/
1761 static void
1762 gtk_cell_area_box_cell_layout_init (GtkCellLayoutIface *iface)
1763 {
1764   iface->pack_start = gtk_cell_area_box_layout_pack_start;
1765   iface->pack_end   = gtk_cell_area_box_layout_pack_end;
1766   iface->reorder    = gtk_cell_area_box_layout_reorder;
1767 }
1768
1769 static void
1770 gtk_cell_area_box_layout_pack_start (GtkCellLayout      *cell_layout,
1771                                      GtkCellRenderer    *renderer,
1772                                      gboolean            expand)
1773 {
1774   gtk_cell_area_box_pack_start (GTK_CELL_AREA_BOX (cell_layout), renderer, expand, TRUE);
1775 }
1776
1777 static void
1778 gtk_cell_area_box_layout_pack_end (GtkCellLayout      *cell_layout,
1779                                    GtkCellRenderer    *renderer,
1780                                    gboolean            expand)
1781 {
1782   gtk_cell_area_box_pack_end (GTK_CELL_AREA_BOX (cell_layout), renderer, expand, TRUE);
1783 }
1784
1785 static void
1786 gtk_cell_area_box_layout_reorder (GtkCellLayout      *cell_layout,
1787                                   GtkCellRenderer    *renderer,
1788                                   gint                position)
1789 {
1790   GtkCellAreaBox        *box  = GTK_CELL_AREA_BOX (cell_layout);
1791   GtkCellAreaBoxPrivate *priv = box->priv;
1792   GList                 *node;
1793   CellInfo              *info;
1794
1795   node = g_list_find_custom (priv->cells, renderer,
1796                              (GCompareFunc)cell_info_find);
1797
1798   if (node)
1799     {
1800       info = node->data;
1801
1802       priv->cells = g_list_delete_link (priv->cells, node);
1803       priv->cells = g_list_insert (priv->cells, info, position);
1804
1805       cell_groups_rebuild (box);
1806     }
1807 }
1808
1809 /*************************************************************
1810  *                            API                            *
1811  *************************************************************/
1812 GtkCellArea *
1813 gtk_cell_area_box_new (void)
1814 {
1815   return (GtkCellArea *)g_object_new (GTK_TYPE_CELL_AREA_BOX, NULL);
1816 }
1817
1818 void
1819 gtk_cell_area_box_pack_start  (GtkCellAreaBox  *box,
1820                                GtkCellRenderer *renderer,
1821                                gboolean         expand,
1822                                gboolean         align)
1823 {
1824   GtkCellAreaBoxPrivate *priv;
1825   CellInfo              *info;
1826
1827   g_return_if_fail (GTK_IS_CELL_AREA_BOX (box));
1828   g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
1829
1830   priv = box->priv;
1831
1832   if (g_list_find_custom (priv->cells, renderer,
1833                           (GCompareFunc)cell_info_find))
1834     {
1835       g_warning ("Refusing to add the same cell renderer to a GtkCellAreaBox twice");
1836       return;
1837     }
1838
1839   info = cell_info_new (renderer, GTK_PACK_START, expand, align);
1840
1841   priv->cells = g_list_append (priv->cells, info);
1842
1843   cell_groups_rebuild (box);
1844 }
1845
1846 void
1847 gtk_cell_area_box_pack_end (GtkCellAreaBox  *box,
1848                             GtkCellRenderer *renderer,
1849                             gboolean         expand,
1850                             gboolean         align)
1851 {
1852   GtkCellAreaBoxPrivate *priv;
1853   CellInfo              *info;
1854
1855   g_return_if_fail (GTK_IS_CELL_AREA_BOX (box));
1856   g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
1857
1858   priv = box->priv;
1859
1860   if (g_list_find_custom (priv->cells, renderer,
1861                           (GCompareFunc)cell_info_find))
1862     {
1863       g_warning ("Refusing to add the same cell renderer to a GtkCellArea twice");
1864       return;
1865     }
1866
1867   info = cell_info_new (renderer, GTK_PACK_END, expand, align);
1868
1869   priv->cells = g_list_append (priv->cells, info);
1870
1871   cell_groups_rebuild (box);
1872 }
1873
1874 gint
1875 gtk_cell_area_box_get_spacing (GtkCellAreaBox  *box)
1876 {
1877   g_return_val_if_fail (GTK_IS_CELL_AREA_BOX (box), 0);
1878
1879   return box->priv->spacing;
1880 }
1881
1882 void
1883 gtk_cell_area_box_set_spacing (GtkCellAreaBox  *box,
1884                                gint             spacing)
1885 {
1886   GtkCellAreaBoxPrivate *priv;
1887
1888   g_return_if_fail (GTK_IS_CELL_AREA_BOX (box));
1889
1890   priv = box->priv;
1891
1892   if (priv->spacing != spacing)
1893     {
1894       priv->spacing = spacing;
1895
1896       g_object_notify (G_OBJECT (box), "spacing");
1897
1898       /* Notify that size needs to be requested again */
1899       flush_iters (box);
1900     }
1901 }