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