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
 896
 897   return 0;
 898 }
 899
 900 static void
 901 gtk_cell_area_box_render (GtkCellArea          *area,
 902                           GtkCellAreaIter      *iter,
 903                           GtkWidget            *widget,
 904                           cairo_t              *cr,
 905                           const GdkRectangle   *background_area,
 906                           const GdkRectangle   *cell_area,
 907                           GtkCellRendererState  flags,
 908                           gboolean              paint_focus)
 909 {
 910   GtkCellAreaBox        *box      = GTK_CELL_AREA_BOX (area);
 911   GtkCellAreaBoxPrivate *priv     = box->priv;
 912   GtkCellAreaBoxIter    *box_iter = GTK_CELL_AREA_BOX_ITER (iter);
 913   GSList                *allocated_cells, *l;
 914   GdkRectangle           cell_background, inner_area;
 915   GtkCellRenderer       *focus_cell = NULL;
 916   GdkRectangle           focus_rect = { 0, };
 917   gboolean               first_focus_cell = TRUE;
 918
 919   if (flags & GTK_CELL_RENDERER_FOCUSED)
 920     {
 921       focus_cell = gtk_cell_area_get_focus_cell (area);
 922       flags &= ~GTK_CELL_RENDERER_FOCUSED;
 923     }
 924
 925   cell_background = *cell_area;
 926
 927   /* Get a list of cells with allocation sizes decided regardless
 928    * of alignments and pack order etc. */
 929   allocated_cells = get_allocated_cells (box, box_iter, widget);
 930
 931   for (l = allocated_cells; l; l = l->next)
 932     {
 933       AllocatedCell       *cell = l->data;
 934       GtkCellRendererState cell_fields = 0;
 935
 936       if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
 937         {
 938           cell_background.x     = cell_area->x + cell->position;
 939           cell_background.width = cell->size;
 940         }
 941       else
 942         {
 943           cell_background.y      = cell_area->y + cell->position;
 944           cell_background.height = cell->size;
 945         }
 946
 947       /* Remove margins from the background area to produce the cell area
 948        */
 949       gtk_cell_area_inner_cell_area (area, &cell_background, &inner_area);
 950
 951       if (focus_cell &&
 952           (cell->renderer == focus_cell ||
 953            gtk_cell_area_is_focus_sibling (area, focus_cell, cell->renderer)))
 954         {
 955           cell_fields |= GTK_CELL_RENDERER_FOCUSED;
 956
 957           if (paint_focus)
 958             {
 959               GdkRectangle cell_focus;
 960               gint         opposite_size, x_offset, y_offset;
 961
 962               cell_focus = inner_area;
 963
 964               /* Trim up the focus size */
 965               if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
 966                 {
 967                   gtk_cell_renderer_get_preferred_height_for_width (cell->renderer, widget,
 968                                                                     cell_focus.width,
 969                                                                     NULL, &opposite_size);
 970
 971                   cell_focus.height = MIN (opposite_size, cell_focus.height);
 972                 }
 973               else
 974                 {
 975                   gtk_cell_renderer_get_preferred_width_for_height (cell->renderer, widget,
 976                                                                     cell_focus.height,
 977                                                                     NULL, &opposite_size);
 978
 979                   cell_focus.width = MIN (opposite_size, cell_focus.width);
 980                 }
 981
 982               /* offset the cell position */
 983               _gtk_cell_renderer_calc_offset (cell->renderer, &inner_area, GTK_TEXT_DIR_LTR,
 984                                               cell_focus.width, cell_focus.height,
 985                                               &x_offset, &y_offset);
 986
 987               cell_focus.x += x_offset;
 988               cell_focus.y += y_offset;
 989
 990               /* Accumulate the focus rectangle for all focus siblings */
 991               if (first_focus_cell)
 992                 {
 993                   focus_rect       = cell_focus;
 994                   first_focus_cell = FALSE;
 995                 }
 996               else
 997                 gdk_rectangle_union (&focus_rect, &cell_focus, &focus_rect);
 998             }
 999         }
1000
1001       /* We have to do some per-cell considerations for the 'flags'
1002        * for focus handling */
1003       gtk_cell_renderer_render (cell->renderer, cr, widget,
1004                                 &cell_background, &inner_area,
1005                                 flags | cell_fields);
1006     }
1007
1008   if (paint_focus && focus_rect.width != 0 && focus_rect.height != 0)
1009     {
1010       GtkStateType renderer_state =
1011         flags & GTK_CELL_RENDERER_SELECTED ? GTK_STATE_SELECTED :
1012         (flags & GTK_CELL_RENDERER_PRELIT ? GTK_STATE_PRELIGHT :
1013          (flags & GTK_CELL_RENDERER_INSENSITIVE ? GTK_STATE_INSENSITIVE : GTK_STATE_NORMAL));
1014
1015       gtk_paint_focus (gtk_widget_get_style (widget),
1016                        cr, renderer_state,
1017                        widget,
1018                        /* XXX This hint should be a property on GtkCellArea I suppose */
1019                        "treeview",
1020                        focus_rect.x,
1021                        focus_rect.y,
1022                        focus_rect.width,
1023                        focus_rect.height);
1024     }
1025
1026
1027   g_slist_foreach (allocated_cells, (GFunc)allocated_cell_free, NULL);
1028   g_slist_free (allocated_cells);
1029 }
1030
1031 static void
1032 gtk_cell_area_box_set_cell_property (GtkCellArea        *area,
1033                                      GtkCellRenderer    *renderer,
1034                                      guint               prop_id,
1035                                      const GValue       *value,
1036                                      GParamSpec         *pspec)
1037 {
1038   GtkCellAreaBox        *box  = GTK_CELL_AREA_BOX (area);
1039   GtkCellAreaBoxPrivate *priv = box->priv;
1040   GList                 *node;
1041   CellInfo              *info;
1042   gboolean               rebuild = FALSE;
1043   gboolean               val;
1044   GtkPackType            pack_type;
1045
1046   node = g_list_find_custom (priv->cells, renderer,
1047                              (GCompareFunc)cell_info_find);
1048   if (!node)
1049     return;
1050
1051   info = node->data;
1052
1053   switch (prop_id)
1054     {
1055     case CELL_PROP_EXPAND:
1056       val = g_value_get_boolean (value);
1057
1058       if (info->expand != val)
1059         {
1060           info->expand = val;
1061           rebuild      = TRUE;
1062         }
1063       break;
1064
1065     case CELL_PROP_ALIGN:
1066       val = g_value_get_boolean (value);
1067
1068       if (info->align != val)
1069         {
1070           info->align = val;
1071           rebuild     = TRUE;
1072         }
1073       break;
1074
1075     case CELL_PROP_PACK_TYPE:
1076       pack_type = g_value_get_enum (value);
1077
1078       if (info->pack != pack_type)
1079         {
1080           info->pack = pack_type;
1081           rebuild    = TRUE;
1082         }
1083       break;
1084     default:
1085       GTK_CELL_AREA_WARN_INVALID_CHILD_PROPERTY_ID (area, prop_id, pspec);
1086       break;
1087     }
1088
1089   /* Groups need to be rebuilt */
1090   if (rebuild)
1091     cell_groups_rebuild (box);
1092 }
1093
1094 static void
1095 gtk_cell_area_box_get_cell_property (GtkCellArea        *area,
1096                                      GtkCellRenderer    *renderer,
1097                                      guint               prop_id,
1098                                      GValue             *value,
1099                                      GParamSpec         *pspec)
1100 {
1101   GtkCellAreaBox        *box  = GTK_CELL_AREA_BOX (area);
1102   GtkCellAreaBoxPrivate *priv = box->priv;
1103   GList                 *node;
1104   CellInfo              *info;
1105
1106   node = g_list_find_custom (priv->cells, renderer,
1107                              (GCompareFunc)cell_info_find);
1108   if (!node)
1109     return;
1110
1111   info = node->data;
1112
1113   switch (prop_id)
1114     {
1115     case CELL_PROP_EXPAND:
1116       g_value_set_boolean (value, info->expand);
1117       break;
1118
1119     case CELL_PROP_ALIGN:
1120       g_value_set_boolean (value, info->align);
1121       break;
1122
1123     case CELL_PROP_PACK_TYPE:
1124       g_value_set_enum (value, info->pack);
1125       break;
1126     default:
1127       GTK_CELL_AREA_WARN_INVALID_CHILD_PROPERTY_ID (area, prop_id, pspec);
1128       break;
1129     }
1130 }
1131
1132
1133 static GtkCellAreaIter *
1134 gtk_cell_area_box_create_iter (GtkCellArea *area)
1135 {
1136   GtkCellAreaBox        *box  = GTK_CELL_AREA_BOX (area);
1137   GtkCellAreaBoxPrivate *priv = box->priv;
1138   GtkCellAreaIter       *iter =
1139     (GtkCellAreaIter *)g_object_new (GTK_TYPE_CELL_AREA_BOX_ITER,
1140                                      "area", area, NULL);
1141
1142   priv->iters = g_slist_prepend (priv->iters, iter);
1143
1144   g_object_weak_ref (G_OBJECT (iter), (GWeakNotify)iter_weak_notify, box);
1145
1146   /* Tell the new group about our cell layout */
1147   init_iter_group (box, GTK_CELL_AREA_BOX_ITER (iter));
1148
1149   return iter;
1150 }
1151
1152 static GtkSizeRequestMode
1153 gtk_cell_area_box_get_request_mode (GtkCellArea *area)
1154 {
1155   GtkCellAreaBox        *box  = GTK_CELL_AREA_BOX (area);
1156   GtkCellAreaBoxPrivate *priv = box->priv;
1157
1158   return (priv->orientation) == GTK_ORIENTATION_HORIZONTAL ?
1159     GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH :
1160     GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT;
1161 }
1162
1163 static void
1164 compute_size (GtkCellAreaBox     *box,
1165               GtkOrientation      orientation,
1166               GtkCellAreaBoxIter *iter,
1167               GtkWidget          *widget,
1168               gint                for_size,
1169               gint               *minimum_size,
1170               gint               *natural_size)
1171 {
1172   GtkCellAreaBoxPrivate *priv = box->priv;
1173   GtkCellArea           *area = GTK_CELL_AREA (box);
1174   GList                 *list;
1175   gint                   i;
1176   gint                   min_size = 0;
1177   gint                   nat_size = 0;
1178
1179   for (i = 0; i < priv->groups->len; i++)
1180     {
1181       CellGroup *group = &g_array_index (priv->groups, CellGroup, i);
1182       gint       group_min_size = 0;
1183       gint       group_nat_size = 0;
1184
1185       for (list = group->cells; list; list = list->next)
1186         {
1187           CellInfo *info = list->data;
1188           gint      renderer_min_size, renderer_nat_size;
1189
1190           if (!gtk_cell_renderer_get_visible (info->renderer))
1191               continue;
1192
1193           gtk_cell_area_request_renderer (area, info->renderer, orientation, widget, for_size,
1194                                           &renderer_min_size, &renderer_nat_size);
1195
1196           if (orientation == priv->orientation)
1197             {
1198               if (min_size > 0)
1199                 {
1200                   min_size += priv->spacing;
1201                   nat_size += priv->spacing;
1202                 }
1203
1204               if (group_min_size > 0)
1205                 {
1206                   group_min_size += priv->spacing;
1207                   group_nat_size += priv->spacing;
1208                 }
1209
1210               min_size       += renderer_min_size;
1211               nat_size       += renderer_nat_size;
1212               group_min_size += renderer_min_size;
1213               group_nat_size += renderer_nat_size;
1214             }
1215           else
1216             {
1217               min_size       = MAX (min_size, renderer_min_size);
1218               nat_size       = MAX (nat_size, renderer_nat_size);
1219               group_min_size = MAX (group_min_size, renderer_min_size);
1220               group_nat_size = MAX (group_nat_size, renderer_nat_size);
1221             }
1222         }
1223
1224       if (orientation == GTK_ORIENTATION_HORIZONTAL)
1225         {
1226           if (for_size < 0)
1227             gtk_cell_area_box_iter_push_group_width (iter, group->id, group_min_size, group_nat_size);
1228           else
1229             gtk_cell_area_box_iter_push_group_width_for_height (iter, group->id, for_size,
1230                                                                 group_min_size, group_nat_size);
1231         }
1232       else
1233         {
1234           if (for_size < 0)
1235             gtk_cell_area_box_iter_push_group_height (iter, group->id, group_min_size, group_nat_size);
1236           else
1237             gtk_cell_area_box_iter_push_group_height_for_width (iter, group->id, for_size,
1238                                                                 group_min_size, group_nat_size);
1239         }
1240     }
1241
1242   *minimum_size = min_size;
1243   *natural_size = nat_size;
1244 }
1245
1246 GtkRequestedSize *
1247 get_group_sizes (GtkCellArea    *area,
1248                  CellGroup      *group,
1249                  GtkOrientation  orientation,
1250                  GtkWidget      *widget,
1251                  gint           *n_sizes)
1252 {
1253   GtkRequestedSize *sizes;
1254   GList            *l;
1255   gint              i;
1256
1257   *n_sizes = count_visible_cells (group, NULL);
1258   sizes    = g_new (GtkRequestedSize, *n_sizes);
1259
1260   for (l = group->cells, i = 0; l; l = l->next)
1261     {
1262       CellInfo *info = l->data;
1263
1264       if (!gtk_cell_renderer_get_visible (info->renderer))
1265         continue;
1266
1267       sizes[i].data = info;
1268
1269       gtk_cell_area_request_renderer (area, info->renderer,
1270                                       orientation, widget, -1,
1271                                       &sizes[i].minimum_size,
1272                                       &sizes[i].natural_size);
1273
1274       i++;
1275     }
1276
1277   return sizes;
1278 }
1279
1280 static void
1281 compute_group_size_for_opposing_orientation (GtkCellAreaBox     *box,
1282                                              CellGroup          *group,
1283                                              GtkWidget          *widget,
1284                                              gint                for_size,
1285                                              gint               *minimum_size,
1286                                              gint               *natural_size)
1287 {
1288   GtkCellAreaBoxPrivate *priv = box->priv;
1289   GtkCellArea           *area = GTK_CELL_AREA (box);
1290
1291   /* Exception for single cell groups */
1292   if (group->n_cells == 1)
1293     {
1294       CellInfo *info = group->cells->data;
1295
1296       gtk_cell_area_request_renderer (area, info->renderer,
1297                                       OPPOSITE_ORIENTATION (priv->orientation),
1298                                       widget, for_size, minimum_size, natural_size);
1299     }
1300   else
1301     {
1302       GtkRequestedSize *orientation_sizes;
1303       CellInfo         *info;
1304       gint              n_sizes, i;
1305       gint              avail_size     = for_size;
1306       gint              extra_size, extra_extra;
1307       gint              min_size = 0, nat_size = 0;
1308
1309       orientation_sizes = get_group_sizes (area, group, priv->orientation, widget, &n_sizes);
1310
1311       /* First naturally allocate the cells in the group into the for_size */
1312       avail_size -= (n_sizes - 1) * priv->spacing;
1313       for (i = 0; i < n_sizes; i++)
1314         avail_size -= orientation_sizes[i].minimum_size;
1315
1316       avail_size = gtk_distribute_natural_allocation (avail_size, n_sizes, orientation_sizes);
1317
1318       /* Calculate/distribute expand for cells */
1319       if (group->expand_cells > 0)
1320         {
1321           extra_size  = avail_size / group->expand_cells;
1322           extra_extra = avail_size % group->expand_cells;
1323         }
1324       else
1325         extra_size = extra_extra = 0;
1326
1327       for (i = 0; i < n_sizes; i++)
1328         {
1329           gint cell_min, cell_nat;
1330
1331           info = orientation_sizes[i].data;
1332
1333           if (info->expand)
1334             {
1335               orientation_sizes[i].minimum_size += extra_size;
1336               if (extra_extra)
1337                 {
1338                   orientation_sizes[i].minimum_size++;
1339                   extra_extra--;
1340                 }
1341             }
1342
1343           gtk_cell_area_request_renderer (area, info->renderer,
1344                                           OPPOSITE_ORIENTATION (priv->orientation),
1345                                           widget,
1346                                           orientation_sizes[i].minimum_size,
1347                                           &cell_min, &cell_nat);
1348
1349           min_size = MAX (min_size, cell_min);
1350           nat_size = MAX (nat_size, cell_nat);
1351         }
1352
1353       *minimum_size = min_size;
1354       *natural_size = nat_size;
1355
1356       g_free (orientation_sizes);
1357     }
1358 }
1359
1360 static void
1361 compute_size_for_opposing_orientation (GtkCellAreaBox     *box,
1362                                        GtkCellAreaBoxIter *iter,
1363                                        GtkWidget          *widget,
1364                                        gint                for_size,
1365                                        gint               *minimum_size,
1366                                        gint               *natural_size)
1367 {
1368   GtkCellAreaBoxPrivate *priv = box->priv;
1369   CellGroup             *group;
1370   GtkRequestedSize      *orientation_sizes;
1371   gint                   n_groups, n_expand_groups, i;
1372   gint                   avail_size = for_size;
1373   gint                   extra_size, extra_extra;
1374   gint                   min_size = 0, nat_size = 0;
1375
1376   n_expand_groups = count_expand_groups (box);
1377
1378   if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
1379     orientation_sizes = gtk_cell_area_box_iter_get_widths (iter, &n_groups);
1380   else
1381     orientation_sizes = gtk_cell_area_box_iter_get_heights (iter, &n_groups);
1382
1383   /* First start by naturally allocating space among groups of cells */
1384   avail_size -= (n_groups - 1) * priv->spacing;
1385   for (i = 0; i < n_groups; i++)
1386     avail_size -= orientation_sizes[i].minimum_size;
1387
1388   avail_size = gtk_distribute_natural_allocation (avail_size, n_groups, orientation_sizes);
1389
1390   /* Calculate/distribute expand for groups */
1391   if (n_expand_groups > 0)
1392     {
1393       extra_size  = avail_size / n_expand_groups;
1394       extra_extra = avail_size % n_expand_groups;
1395     }
1396   else
1397     extra_size = extra_extra = 0;
1398
1399   /* Now we need to naturally allocate sizes for cells in each group
1400    * and push the height-for-width for each group accordingly while accumulating
1401    * the overall height-for-width for this row.
1402    */
1403   for (i = 0; i < n_groups; i++)
1404     {
1405       gint group_min, group_nat;
1406       gint group_idx = GPOINTER_TO_INT (orientation_sizes[i].data);
1407
1408       group = &g_array_index (priv->groups, CellGroup, group_idx);
1409
1410       if (group->expand_cells > 0)
1411         {
1412           orientation_sizes[i].minimum_size += extra_size;
1413           if (extra_extra)
1414             {
1415               orientation_sizes[i].minimum_size++;
1416               extra_extra--;
1417             }
1418         }
1419
1420       /* Now we have the allocation for the group, request it's height-for-width */
1421       compute_group_size_for_opposing_orientation (box, group, widget,
1422                                                    orientation_sizes[i].minimum_size,
1423                                                    &group_min, &group_nat);
1424
1425       min_size = MAX (min_size, group_min);
1426       nat_size = MAX (nat_size, group_nat);
1427
1428       if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
1429         {
1430           gtk_cell_area_box_iter_push_group_height_for_width (iter, group_idx, for_size,
1431                                                               group_min, group_nat);
1432         }
1433       else
1434         {
1435           gtk_cell_area_box_iter_push_group_width_for_height (iter, group_idx, for_size,
1436                                                               group_min, group_nat);
1437         }
1438     }
1439
1440   *minimum_size = min_size;
1441   *natural_size = nat_size;
1442
1443   g_free (orientation_sizes);
1444 }
1445
1446
1447
1448 static void
1449 gtk_cell_area_box_get_preferred_width (GtkCellArea        *area,
1450                                        GtkCellAreaIter    *iter,
1451                                        GtkWidget          *widget,
1452                                        gint               *minimum_width,
1453                                        gint               *natural_width)
1454 {
1455   GtkCellAreaBox        *box = GTK_CELL_AREA_BOX (area);
1456   GtkCellAreaBoxIter    *box_iter;
1457   gint                   min_width, nat_width;
1458
1459   g_return_if_fail (GTK_IS_CELL_AREA_BOX_ITER (iter));
1460
1461   box_iter = GTK_CELL_AREA_BOX_ITER (iter);
1462
1463   /* Compute the size of all renderers for current row data,
1464    * bumping cell alignments in the iter along the way */
1465   compute_size (box, GTK_ORIENTATION_HORIZONTAL,
1466                 box_iter, widget, -1, &min_width, &nat_width);
1467
1468   if (minimum_width)
1469     *minimum_width = min_width;
1470
1471   if (natural_width)
1472     *natural_width = nat_width;
1473 }
1474
1475 static void
1476 gtk_cell_area_box_get_preferred_height (GtkCellArea        *area,
1477                                         GtkCellAreaIter    *iter,
1478                                         GtkWidget          *widget,
1479                                         gint               *minimum_height,
1480                                         gint               *natural_height)
1481 {
1482   GtkCellAreaBox        *box = GTK_CELL_AREA_BOX (area);
1483   GtkCellAreaBoxIter    *box_iter;
1484   gint                   min_height, nat_height;
1485
1486   g_return_if_fail (GTK_IS_CELL_AREA_BOX_ITER (iter));
1487
1488   box_iter = GTK_CELL_AREA_BOX_ITER (iter);
1489
1490   /* Compute the size of all renderers for current row data,
1491    * bumping cell alignments in the iter along the way */
1492   compute_size (box, GTK_ORIENTATION_VERTICAL,
1493                 box_iter, widget, -1, &min_height, &nat_height);
1494
1495   if (minimum_height)
1496     *minimum_height = min_height;
1497
1498   if (natural_height)
1499     *natural_height = nat_height;
1500 }
1501
1502 static void
1503 gtk_cell_area_box_get_preferred_height_for_width (GtkCellArea        *area,
1504                                                   GtkCellAreaIter    *iter,
1505                                                   GtkWidget          *widget,
1506                                                   gint                width,
1507                                                   gint               *minimum_height,
1508                                                   gint               *natural_height)
1509 {
1510   GtkCellAreaBox        *box = GTK_CELL_AREA_BOX (area);
1511   GtkCellAreaBoxIter    *box_iter;
1512   GtkCellAreaBoxPrivate *priv;
1513   gint                   min_height, nat_height;
1514
1515   g_return_if_fail (GTK_IS_CELL_AREA_BOX_ITER (iter));
1516
1517   box_iter = GTK_CELL_AREA_BOX_ITER (iter);
1518   priv     = box->priv;
1519
1520   if (priv->orientation == GTK_ORIENTATION_VERTICAL)
1521     {
1522       /* Add up vertical requests of height for width and push the overall
1523        * cached sizes for alignments */
1524       compute_size (box, priv->orientation, box_iter, widget, width, &min_height, &nat_height);
1525     }
1526   else
1527     {
1528       /* Juice: virtually allocate cells into the for_width using the
1529        * alignments and then return the overall height for that width, and cache it */
1530       compute_size_for_opposing_orientation (box, box_iter, widget, width, &min_height, &nat_height);
1531     }
1532
1533   if (minimum_height)
1534     *minimum_height = min_height;
1535
1536   if (natural_height)
1537     *natural_height = nat_height;
1538 }
1539
1540 static void
1541 gtk_cell_area_box_get_preferred_width_for_height (GtkCellArea        *area,
1542                                                   GtkCellAreaIter    *iter,
1543                                                   GtkWidget          *widget,
1544                                                   gint                height,
1545                                                   gint               *minimum_width,
1546                                                   gint               *natural_width)
1547 {
1548   GtkCellAreaBox        *box = GTK_CELL_AREA_BOX (area);
1549   GtkCellAreaBoxIter    *box_iter;
1550   GtkCellAreaBoxPrivate *priv;
1551   gint                   min_width, nat_width;
1552
1553   g_return_if_fail (GTK_IS_CELL_AREA_BOX_ITER (iter));
1554
1555   box_iter = GTK_CELL_AREA_BOX_ITER (iter);
1556   priv     = box->priv;
1557
1558   if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
1559     {
1560       /* Add up horizontal requests of width for height and push the overall
1561        * cached sizes for alignments */
1562       compute_size (box, priv->orientation, box_iter, widget, height, &min_width, &nat_width);
1563     }
1564   else
1565     {
1566       /* Juice: horizontally allocate cells into the for_height using the
1567        * alignments and then return the overall width for that height, and cache it */
1568       compute_size_for_opposing_orientation (box, box_iter, widget, height, &min_width, &nat_width);
1569     }
1570
1571   if (minimum_width)
1572     *minimum_width = min_width;
1573
1574   if (natural_width)
1575     *natural_width = nat_width;
1576 }
1577
1578 static gboolean
1579 gtk_cell_area_box_focus (GtkCellArea      *area,
1580                          GtkDirectionType  direction)
1581 {
1582   GtkCellAreaBox        *box   = GTK_CELL_AREA_BOX (area);
1583   GtkCellAreaBoxPrivate *priv  = box->priv;
1584   gint                   cycle = FOCUS_NONE;
1585   gboolean               cycled_focus = FALSE;
1586   GtkCellRenderer       *focus_cell;
1587
1588   focus_cell = gtk_cell_area_get_focus_cell (area);
1589
1590   switch (direction)
1591     {
1592     case GTK_DIR_TAB_FORWARD:
1593       cycle = FOCUS_NEXT;
1594       break;
1595     case GTK_DIR_TAB_BACKWARD:
1596       cycle = FOCUS_PREV;
1597       break;
1598     case GTK_DIR_UP:
1599       if (priv->orientation == GTK_ORIENTATION_VERTICAL || !focus_cell)
1600         cycle = FOCUS_PREV;
1601       break;
1602     case GTK_DIR_DOWN:
1603       if (priv->orientation == GTK_ORIENTATION_VERTICAL || !focus_cell)
1604         cycle = FOCUS_NEXT;
1605       break;
1606     case GTK_DIR_LEFT:
1607       if (priv->orientation == GTK_ORIENTATION_HORIZONTAL || !focus_cell)
1608         cycle = FOCUS_PREV;
1609       break;
1610     case GTK_DIR_RIGHT:
1611       if (priv->orientation == GTK_ORIENTATION_HORIZONTAL || !focus_cell)
1612         cycle = FOCUS_NEXT;
1613       break;
1614     default:
1615       break;
1616     }
1617
1618   if (cycle != FOCUS_NONE)
1619     {
1620       gboolean  found_cell = FALSE;
1621       GList    *list;
1622       gint      i;
1623
1624       /* If there is no focused cell, focus on the first (or last) one in the list */
1625       if (!focus_cell)
1626         found_cell = TRUE;
1627
1628       for (i = (cycle == FOCUS_NEXT) ? 0 : priv->groups->len -1;
1629            cycled_focus == FALSE && i >= 0 && i < priv->groups->len;
1630            i = (cycle == FOCUS_NEXT) ? i + 1 : i - 1)
1631         {
1632           CellGroup *group = &g_array_index (priv->groups, CellGroup, i);
1633
1634           for (list = (cycle == FOCUS_NEXT) ? g_list_first (group->cells) : g_list_last (group->cells);
1635                list; list = (cycle == FOCUS_NEXT) ? list->next : list->prev)
1636             {
1637               CellInfo *info = list->data;
1638
1639               if (info->renderer == focus_cell)
1640                 found_cell = TRUE;
1641               else if (found_cell)
1642                 {
1643                   if (gtk_cell_renderer_can_focus (info->renderer))
1644                     {
1645                       gtk_cell_area_set_focus_cell (area, info->renderer);
1646
1647                       cycled_focus = TRUE;
1648                       break;
1649                     }
1650                 }
1651             }
1652         }
1653     }
1654
1655   if (!cycled_focus)
1656     gtk_cell_area_set_focus_cell (area, NULL);
1657
1658   return cycled_focus;
1659 }
1660
1661
1662 /*************************************************************
1663  *                    GtkCellLayoutIface                     *
1664  *************************************************************/
1665 static void
1666 gtk_cell_area_box_cell_layout_init (GtkCellLayoutIface *iface)
1667 {
1668   iface->pack_start = gtk_cell_area_box_layout_pack_start;
1669   iface->pack_end   = gtk_cell_area_box_layout_pack_end;
1670   iface->reorder    = gtk_cell_area_box_layout_reorder;
1671 }
1672
1673 static void
1674 gtk_cell_area_box_layout_pack_start (GtkCellLayout      *cell_layout,
1675                                      GtkCellRenderer    *renderer,
1676                                      gboolean            expand)
1677 {
1678   gtk_cell_area_box_pack_start (GTK_CELL_AREA_BOX (cell_layout), renderer, expand, TRUE);
1679 }
1680
1681 static void
1682 gtk_cell_area_box_layout_pack_end (GtkCellLayout      *cell_layout,
1683                                    GtkCellRenderer    *renderer,
1684                                    gboolean            expand)
1685 {
1686   gtk_cell_area_box_pack_end (GTK_CELL_AREA_BOX (cell_layout), renderer, expand, TRUE);
1687 }
1688
1689 static void
1690 gtk_cell_area_box_layout_reorder (GtkCellLayout      *cell_layout,
1691                                   GtkCellRenderer    *renderer,
1692                                   gint                position)
1693 {
1694   GtkCellAreaBox        *box  = GTK_CELL_AREA_BOX (cell_layout);
1695   GtkCellAreaBoxPrivate *priv = box->priv;
1696   GList                 *node;
1697   CellInfo              *info;
1698
1699   node = g_list_find_custom (priv->cells, renderer,
1700                              (GCompareFunc)cell_info_find);
1701
1702   if (node)
1703     {
1704       info = node->data;
1705
1706       priv->cells = g_list_delete_link (priv->cells, node);
1707       priv->cells = g_list_insert (priv->cells, info, position);
1708
1709       cell_groups_rebuild (box);
1710     }
1711 }
1712
1713 /*************************************************************
1714  *                            API                            *
1715  *************************************************************/
1716 GtkCellArea *
1717 gtk_cell_area_box_new (void)
1718 {
1719   return (GtkCellArea *)g_object_new (GTK_TYPE_CELL_AREA_BOX, NULL);
1720 }
1721
1722 void
1723 gtk_cell_area_box_pack_start  (GtkCellAreaBox  *box,
1724                                GtkCellRenderer *renderer,
1725                                gboolean         expand,
1726                                gboolean         align)
1727 {
1728   GtkCellAreaBoxPrivate *priv;
1729   CellInfo              *info;
1730
1731   g_return_if_fail (GTK_IS_CELL_AREA_BOX (box));
1732   g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
1733
1734   priv = box->priv;
1735
1736   if (g_list_find_custom (priv->cells, renderer,
1737                           (GCompareFunc)cell_info_find))
1738     {
1739       g_warning ("Refusing to add the same cell renderer to a GtkCellAreaBox twice");
1740       return;
1741     }
1742
1743   info = cell_info_new (renderer, GTK_PACK_START, expand, align);
1744
1745   priv->cells = g_list_append (priv->cells, info);
1746
1747   cell_groups_rebuild (box);
1748 }
1749
1750 void
1751 gtk_cell_area_box_pack_end (GtkCellAreaBox  *box,
1752                             GtkCellRenderer *renderer,
1753                             gboolean         expand,
1754                             gboolean         align)
1755 {
1756   GtkCellAreaBoxPrivate *priv;
1757   CellInfo              *info;
1758
1759   g_return_if_fail (GTK_IS_CELL_AREA_BOX (box));
1760   g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
1761
1762   priv = box->priv;
1763
1764   if (g_list_find_custom (priv->cells, renderer,
1765                           (GCompareFunc)cell_info_find))
1766     {
1767       g_warning ("Refusing to add the same cell renderer to a GtkCellArea twice");
1768       return;
1769     }
1770
1771   info = cell_info_new (renderer, GTK_PACK_END, expand, align);
1772
1773   priv->cells = g_list_append (priv->cells, info);
1774
1775   cell_groups_rebuild (box);
1776 }
1777
1778 gint
1779 gtk_cell_area_box_get_spacing (GtkCellAreaBox  *box)
1780 {
1781   g_return_val_if_fail (GTK_IS_CELL_AREA_BOX (box), 0);
1782
1783   return box->priv->spacing;
1784 }
1785
1786 void
1787 gtk_cell_area_box_set_spacing (GtkCellAreaBox  *box,
1788                                gint             spacing)
1789 {
1790   GtkCellAreaBoxPrivate *priv;
1791
1792   g_return_if_fail (GTK_IS_CELL_AREA_BOX (box));
1793
1794   priv = box->priv;
1795
1796   if (priv->spacing != spacing)
1797     {
1798       priv->spacing = spacing;
1799
1800       g_object_notify (G_OBJECT (box), "spacing");
1801
1802       /* Notify that size needs to be requested again */
1803       flush_iters (box);
1804     }
1805 }