Pileus Git - ~andy/gtk/blob - tests/cellareascaffold.c

   1 /* cellareascaffold.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 <string.h>
  25 #include "cellareascaffold.h"
  26
  27 /* GObjectClass */
  28 static void      cell_area_scaffold_finalize                       (GObject              *object);
  29 static void      cell_area_scaffold_dispose                        (GObject              *object);
  30 static void      cell_area_scaffold_set_property                   (GObject              *object,
  31                                                                     guint                 prop_id,
  32                                                                     const GValue         *value,
  33                                                                     GParamSpec           *pspec);
  34 static void      cell_area_scaffold_get_property                   (GObject              *object,
  35                                                                     guint                 prop_id,
  36                                                                     GValue               *value,
  37                                                                     GParamSpec           *pspec);
  38
  39 /* GtkWidgetClass */
  40 static void      cell_area_scaffold_realize                        (GtkWidget       *widget);
  41 static void      cell_area_scaffold_unrealize                      (GtkWidget       *widget);
  42 static gboolean  cell_area_scaffold_draw                           (GtkWidget       *widget,
  43                                                                     cairo_t         *cr);
  44 static void      cell_area_scaffold_size_allocate                  (GtkWidget       *widget,
  45                                                                     GtkAllocation   *allocation);
  46 static void      cell_area_scaffold_get_preferred_width            (GtkWidget       *widget,
  47                                                                     gint            *minimum_size,
  48                                                                     gint            *natural_size);
  49 static void      cell_area_scaffold_get_preferred_height_for_width (GtkWidget       *widget,
  50                                                                     gint             for_size,
  51                                                                     gint            *minimum_size,
  52                                                                     gint            *natural_size);
  53 static void      cell_area_scaffold_get_preferred_height           (GtkWidget       *widget,
  54                                                                     gint            *minimum_size,
  55                                                                     gint            *natural_size);
  56 static void      cell_area_scaffold_get_preferred_width_for_height (GtkWidget       *widget,
  57                                                                     gint             for_size,
  58                                                                     gint            *minimum_size,
  59                                                                     gint            *natural_size);
  60 static gint      cell_area_scaffold_focus                          (GtkWidget       *widget,
  61                                                                     GtkDirectionType direction);
  62
  63 /* CellAreaScaffoldClass */
  64 static void      cell_area_scaffold_activate                       (CellAreaScaffold *scaffold);
  65
  66 /* CellArea/GtkTreeModel callbacks */
  67 static void      size_changed_cb                                   (GtkCellAreaIter *iter,
  68                                                                     GParamSpec       *pspec,
  69                                                                     CellAreaScaffold *scaffold);
  70 static void      row_changed_cb                                    (GtkTreeModel     *model,
  71                                                                     GtkTreePath      *path,
  72                                                                     GtkTreeIter      *iter,
  73                                                                     CellAreaScaffold *scaffold);
  74 static void      row_inserted_cb                                    (GtkTreeModel     *model,
  75                                                                      GtkTreePath      *path,
  76                                                                      GtkTreeIter      *iter,
  77                                                                      CellAreaScaffold *scaffold);
  78 static void      row_deleted_cb                                     (GtkTreeModel     *model,
  79                                                                      GtkTreePath      *path,
  80                                                                      CellAreaScaffold *scaffold);
  81 static void      rows_reordered_cb                                  (GtkTreeModel     *model,
  82                                                                      GtkTreePath      *parent,
  83                                                                      GtkTreeIter      *iter,
  84                                                                      gint             *new_order,
  85                                                                      CellAreaScaffold *scaffold);
  86
  87 typedef struct {
  88   gint    size; /* The size of the row in the scaffold's opposing orientation */
  89 } RowData;
  90
  91 struct _CellAreaScaffoldPrivate {
  92
  93   /* Window for catching events and dispatching them to the cell area */
  94   GdkWindow       *event_window;
  95
  96   /* The model we're showing data for */
  97   GtkTreeModel    *model;
  98   gulong           row_changed_id;
  99   gulong           row_inserted_id;
 100   gulong           row_deleted_id;
 101   gulong           rows_reordered_id;
 102
 103   /* The area rendering the data and a global iter */
 104   GtkCellArea     *area;
 105   GtkCellAreaIter *iter;
 106
 107   /* Cache some info about rows (hieghts etc) */
 108   GArray          *row_data;
 109
 110   /* Focus handling */
 111   gint             focus_row;
 112
 113   /* Check when the underlying area changes the size and
 114    * we need to queue a redraw */
 115   gulong           size_changed_id;
 116
 117
 118 };
 119
 120 enum {
 121   PROP_0,
 122   PROP_ORIENTATION
 123 };
 124
 125 enum {
 126   ACTIVATE,
 127   N_SIGNALS
 128 };
 129
 130 static guint scaffold_signals[N_SIGNALS] = { 0 };
 131
 132 #define ROW_SPACING  2
 133
 134 #define DIRECTION_STR(dir)                              \
 135   ((dir) == GTK_DIR_TAB_FORWARD  ? "tab forward" :      \
 136    (dir) == GTK_DIR_TAB_BACKWARD ? "tab backward" :     \
 137    (dir) == GTK_DIR_UP           ? "up" :               \
 138    (dir) == GTK_DIR_DOWN         ? "down" :             \
 139    (dir) == GTK_DIR_LEFT         ? "left" :             \
 140    (dir) == GTK_DIR_RIGHT        ? "right" : "invalid")
 141
 142 G_DEFINE_TYPE_WITH_CODE (CellAreaScaffold, cell_area_scaffold, GTK_TYPE_WIDGET,
 143                          G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, NULL));
 144
 145
 146 static void
 147 cell_area_scaffold_init (CellAreaScaffold *scaffold)
 148 {
 149   CellAreaScaffoldPrivate *priv;
 150
 151   scaffold->priv = G_TYPE_INSTANCE_GET_PRIVATE (scaffold,
 152                                                 TYPE_CELL_AREA_SCAFFOLD,
 153                                                 CellAreaScaffoldPrivate);
 154   priv = scaffold->priv;
 155
 156   priv->area = gtk_cell_area_box_new ();
 157   priv->iter = gtk_cell_area_create_iter (priv->area);
 158
 159   priv->row_data = g_array_new (FALSE, FALSE, sizeof (RowData));
 160
 161   gtk_widget_set_has_window (GTK_WIDGET (scaffold), FALSE);
 162   gtk_widget_set_can_focus (GTK_WIDGET (scaffold), TRUE);
 163
 164   priv->size_changed_id =
 165     g_signal_connect (priv->iter, "notify",
 166                       G_CALLBACK (size_changed_cb), scaffold);
 167 }
 168
 169 static void
 170 cell_area_scaffold_class_init (CellAreaScaffoldClass *class)
 171 {
 172   GObjectClass   *gobject_class;
 173   GtkWidgetClass *widget_class;
 174
 175   gobject_class = G_OBJECT_CLASS(class);
 176   gobject_class->dispose = cell_area_scaffold_dispose;
 177   gobject_class->finalize = cell_area_scaffold_finalize;
 178   gobject_class->get_property = cell_area_scaffold_get_property;
 179   gobject_class->set_property = cell_area_scaffold_set_property;
 180
 181   widget_class = GTK_WIDGET_CLASS(class);
 182   widget_class->realize = cell_area_scaffold_realize;
 183   widget_class->unrealize = cell_area_scaffold_unrealize;
 184   widget_class->draw = cell_area_scaffold_draw;
 185   widget_class->size_allocate = cell_area_scaffold_size_allocate;
 186   widget_class->get_preferred_width = cell_area_scaffold_get_preferred_width;
 187   widget_class->get_preferred_height_for_width = cell_area_scaffold_get_preferred_height_for_width;
 188   widget_class->get_preferred_height = cell_area_scaffold_get_preferred_height;
 189   widget_class->get_preferred_width_for_height = cell_area_scaffold_get_preferred_width_for_height;
 190   widget_class->focus = cell_area_scaffold_focus;
 191
 192   class->activate = cell_area_scaffold_activate;
 193
 194   g_object_class_override_property (gobject_class, PROP_ORIENTATION, "orientation");
 195
 196   scaffold_signals[ACTIVATE] =
 197     g_signal_new ("activate",
 198                   G_OBJECT_CLASS_TYPE (gobject_class),
 199                   G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
 200                   G_STRUCT_OFFSET (CellAreaScaffoldClass, activate),
 201                   NULL, NULL,
 202                   g_cclosure_marshal_VOID__VOID,
 203                   G_TYPE_NONE, 0);
 204   widget_class->activate_signal = scaffold_signals[ACTIVATE];
 205
 206
 207   g_type_class_add_private (gobject_class, sizeof (CellAreaScaffoldPrivate));
 208 }
 209
 210 /*********************************************************
 211  *                    GObjectClass                       *
 212  *********************************************************/
 213 static void
 214 cell_area_scaffold_finalize (GObject *object)
 215 {
 216   CellAreaScaffold        *scaffold = CELL_AREA_SCAFFOLD (object);
 217   CellAreaScaffoldPrivate *priv;
 218
 219   priv = scaffold->priv;
 220
 221   g_array_free (priv->row_data, TRUE);
 222
 223   G_OBJECT_CLASS (cell_area_scaffold_parent_class)->finalize (object);
 224 }
 225
 226 static void
 227 cell_area_scaffold_dispose (GObject *object)
 228 {
 229   CellAreaScaffold        *scaffold = CELL_AREA_SCAFFOLD (object);
 230   CellAreaScaffoldPrivate *priv;
 231
 232   priv = scaffold->priv;
 233
 234   cell_area_scaffold_set_model (scaffold, NULL);
 235
 236   if (priv->iter)
 237     {
 238       /* Disconnect signals */
 239       g_signal_handler_disconnect (priv->iter, priv->size_changed_id);
 240
 241       g_object_unref (priv->iter);
 242       priv->iter = NULL;
 243       priv->size_changed_id = 0;
 244     }
 245
 246   if (priv->area)
 247     {
 248       /* Disconnect signals */
 249       g_object_unref (priv->area);
 250       priv->area = NULL;
 251     }
 252
 253   G_OBJECT_CLASS (cell_area_scaffold_parent_class)->dispose (object);
 254 }
 255
 256 static void
 257 cell_area_scaffold_set_property (GObject      *object,
 258                                  guint         prop_id,
 259                                  const GValue *value,
 260                                  GParamSpec   *pspec)
 261 {
 262   CellAreaScaffold        *scaffold = CELL_AREA_SCAFFOLD (object);
 263   CellAreaScaffoldPrivate *priv;
 264
 265   priv = scaffold->priv;
 266
 267   switch (prop_id)
 268     {
 269     case PROP_ORIENTATION:
 270       gtk_orientable_set_orientation (GTK_ORIENTABLE (priv->area),
 271                                       g_value_get_enum (value));
 272       break;
 273     default:
 274       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 275       break;
 276     }
 277 }
 278
 279 static void
 280 cell_area_scaffold_get_property (GObject    *object,
 281                                  guint       prop_id,
 282                                  GValue     *value,
 283                                  GParamSpec *pspec)
 284 {
 285   CellAreaScaffold        *scaffold = CELL_AREA_SCAFFOLD (object);
 286   CellAreaScaffoldPrivate *priv;
 287
 288   priv = scaffold->priv;
 289
 290   switch (prop_id)
 291     {
 292     case PROP_ORIENTATION:
 293       g_value_set_enum (value,
 294                         gtk_orientable_get_orientation (GTK_ORIENTABLE (priv->area)));
 295       break;
 296     default:
 297       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 298       break;
 299     }
 300 }
 301
 302 /*********************************************************
 303  *                    GtkWidgetClass                     *
 304  *********************************************************/
 305 static void
 306 cell_area_scaffold_realize (GtkWidget *widget)
 307 {
 308   CellAreaScaffold        *scaffold = CELL_AREA_SCAFFOLD (widget);
 309   CellAreaScaffoldPrivate *priv     = scaffold->priv;
 310   GtkAllocation            allocation;
 311   GdkWindow               *window;
 312   GdkWindowAttr            attributes;
 313   gint                     attributes_mask;
 314
 315   gtk_widget_get_allocation (widget, &allocation);
 316
 317   gtk_widget_set_realized (widget, TRUE);
 318
 319   attributes.window_type = GDK_WINDOW_CHILD;
 320   attributes.x = allocation.x;
 321   attributes.y = allocation.y;
 322   attributes.width = allocation.width;
 323   attributes.height = allocation.height;
 324   attributes.wclass = GDK_INPUT_ONLY;
 325   attributes.event_mask = gtk_widget_get_events (widget);
 326   attributes.event_mask |= (GDK_BUTTON_PRESS_MASK |
 327                             GDK_BUTTON_RELEASE_MASK |
 328                             GDK_KEY_PRESS_MASK |
 329                             GDK_KEY_RELEASE_MASK);
 330
 331   attributes_mask = GDK_WA_X | GDK_WA_Y;
 332
 333   window = gtk_widget_get_parent_window (widget);
 334   gtk_widget_set_window (widget, window);
 335   g_object_ref (window);
 336
 337   priv->event_window = gdk_window_new (window,
 338                                        &attributes, attributes_mask);
 339   gdk_window_set_user_data (priv->event_window, widget);
 340
 341   gtk_widget_style_attach (widget);
 342 }
 343
 344 static void
 345 cell_area_scaffold_unrealize (GtkWidget *widget)
 346 {
 347   CellAreaScaffold        *scaffold = CELL_AREA_SCAFFOLD (widget);
 348   CellAreaScaffoldPrivate *priv     = scaffold->priv;
 349
 350   if (priv->event_window)
 351     {
 352       gdk_window_set_user_data (priv->event_window, NULL);
 353       gdk_window_destroy (priv->event_window);
 354       priv->event_window = NULL;
 355     }
 356
 357   GTK_WIDGET_CLASS (cell_area_scaffold_parent_class)->unrealize (widget);
 358 }
 359
 360 static gboolean
 361 cell_area_scaffold_draw (GtkWidget       *widget,
 362                          cairo_t         *cr)
 363 {
 364   CellAreaScaffold        *scaffold = CELL_AREA_SCAFFOLD (widget);
 365   CellAreaScaffoldPrivate *priv     = scaffold->priv;
 366   GtkOrientation           orientation;
 367   GtkTreeIter              iter;
 368   gboolean                 valid;
 369   GdkRectangle             render_area;
 370   GtkAllocation            allocation;
 371   gint                     i = 0;
 372   gboolean                 have_focus;
 373   GtkCellRendererState     flags;
 374
 375   if (!priv->model)
 376     return FALSE;
 377
 378   have_focus  = gtk_widget_has_focus (widget);
 379   orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (priv->area));
 380
 381   gtk_widget_get_allocation (widget, &allocation);
 382
 383   render_area.x      = 0;
 384   render_area.y      = 0;
 385   render_area.width  = allocation.width;
 386   render_area.height = allocation.height;
 387
 388   valid = gtk_tree_model_get_iter_first (priv->model, &iter);
 389   while (valid)
 390     {
 391       RowData *data = &g_array_index (priv->row_data, RowData, i);
 392
 393       if (have_focus && i == priv->focus_row)
 394         flags = GTK_CELL_RENDERER_FOCUSED;
 395       else
 396         flags = 0;
 397
 398       if (orientation == GTK_ORIENTATION_HORIZONTAL)
 399         {
 400           render_area.height = data->size;
 401         }
 402       else
 403         {
 404           render_area.width = data->size;
 405         }
 406
 407       gtk_cell_area_apply_attributes (priv->area, priv->model, &iter, FALSE, FALSE);
 408       gtk_cell_area_render (priv->area, priv->iter, widget, cr, &render_area, flags);
 409
 410       if (orientation == GTK_ORIENTATION_HORIZONTAL)
 411         {
 412           render_area.y += data->size;
 413           render_area.y += ROW_SPACING;
 414         }
 415       else
 416         {
 417           render_area.x += data->size;
 418           render_area.x += ROW_SPACING;
 419         }
 420
 421       i++;
 422       valid = gtk_tree_model_iter_next (priv->model, &iter);
 423     }
 424
 425   return FALSE;
 426 }
 427
 428 static void
 429 request_all_base (CellAreaScaffold *scaffold)
 430 {
 431   CellAreaScaffoldPrivate *priv = scaffold->priv;
 432   GtkWidget               *widget = GTK_WIDGET (scaffold);
 433   GtkOrientation           orientation;
 434   GtkTreeIter              iter;
 435   gboolean                 valid;
 436
 437   if (!priv->model)
 438     return;
 439
 440   g_signal_handler_block (priv->iter, priv->size_changed_id);
 441
 442   orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (priv->area));
 443
 444   valid = gtk_tree_model_get_iter_first (priv->model, &iter);
 445   while (valid)
 446     {
 447       gint min, nat;
 448
 449       gtk_cell_area_apply_attributes (priv->area, priv->model, &iter, FALSE, FALSE);
 450
 451       if (orientation == GTK_ORIENTATION_HORIZONTAL)
 452         gtk_cell_area_get_preferred_width (priv->area, priv->iter, widget, &min, &nat);
 453       else
 454         gtk_cell_area_get_preferred_height (priv->area, priv->iter, widget, &min, &nat);
 455
 456       valid = gtk_tree_model_iter_next (priv->model, &iter);
 457     }
 458
 459   if (orientation == GTK_ORIENTATION_HORIZONTAL)
 460     gtk_cell_area_iter_sum_preferred_width (priv->iter);
 461   else
 462     gtk_cell_area_iter_sum_preferred_height (priv->iter);
 463
 464   g_signal_handler_unblock (priv->iter, priv->size_changed_id);
 465 }
 466
 467 static void
 468 get_row_sizes (CellAreaScaffold *scaffold,
 469                GArray           *array,
 470                gint              for_size)
 471 {
 472   CellAreaScaffoldPrivate *priv = scaffold->priv;
 473   GtkWidget               *widget = GTK_WIDGET (scaffold);
 474   GtkOrientation           orientation;
 475   GtkTreeIter              iter;
 476   gboolean                 valid;
 477   gint                     i = 0;
 478
 479   if (!priv->model)
 480     return;
 481
 482   orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (priv->area));
 483
 484   valid = gtk_tree_model_get_iter_first (priv->model, &iter);
 485   while (valid)
 486     {
 487       RowData *data = &g_array_index (array, RowData, i);
 488
 489       gtk_cell_area_apply_attributes (priv->area, priv->model, &iter, FALSE, FALSE);
 490
 491       if (orientation == GTK_ORIENTATION_HORIZONTAL)
 492         gtk_cell_area_get_preferred_height_for_width (priv->area, priv->iter, widget,
 493                                                       for_size, &data->size, NULL);
 494       else
 495         gtk_cell_area_get_preferred_width_for_height (priv->area, priv->iter, widget,
 496                                                       for_size, &data->size, NULL);
 497
 498       i++;
 499       valid = gtk_tree_model_iter_next (priv->model, &iter);
 500     }
 501 }
 502
 503 static void
 504 cell_area_scaffold_size_allocate (GtkWidget           *widget,
 505                                   GtkAllocation       *allocation)
 506 {
 507   CellAreaScaffold        *scaffold = CELL_AREA_SCAFFOLD (widget);
 508   CellAreaScaffoldPrivate *priv     = scaffold->priv;
 509   GtkOrientation           orientation;
 510
 511   if (!priv->model)
 512     return;
 513
 514   gtk_widget_set_allocation (widget, allocation);
 515
 516   if (gtk_widget_get_realized (widget))
 517     gdk_window_move_resize (priv->event_window,
 518                             allocation->x,
 519                             allocation->y,
 520                             allocation->width,
 521                             allocation->height);
 522
 523   orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (priv->area));
 524
 525   /* Cache the per-row sizes and allocate the iter */
 526   if (orientation == GTK_ORIENTATION_HORIZONTAL)
 527     {
 528       get_row_sizes (scaffold, priv->row_data, allocation->width);
 529       gtk_cell_area_iter_allocate_width (priv->iter, allocation->width);
 530     }
 531   else
 532     {
 533       get_row_sizes (scaffold, priv->row_data, allocation->height);
 534       gtk_cell_area_iter_allocate_height (priv->iter, allocation->height);
 535     }
 536 }
 537
 538
 539 static void
 540 cell_area_scaffold_get_preferred_width (GtkWidget       *widget,
 541                                         gint            *minimum_size,
 542                                         gint            *natural_size)
 543 {
 544   CellAreaScaffold        *scaffold = CELL_AREA_SCAFFOLD (widget);
 545   CellAreaScaffoldPrivate *priv     = scaffold->priv;
 546   GtkOrientation           orientation;
 547
 548   if (!priv->model)
 549     return;
 550
 551   orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (priv->area));
 552
 553   if (orientation == GTK_ORIENTATION_HORIZONTAL)
 554     {
 555       request_all_base (scaffold);
 556
 557       gtk_cell_area_iter_get_preferred_width (priv->iter, minimum_size, natural_size);
 558     }
 559   else
 560     {
 561       gint min_size, nat_size;
 562
 563       GTK_WIDGET_GET_CLASS (widget)->get_preferred_height (widget, &min_size, &nat_size);
 564       GTK_WIDGET_GET_CLASS (widget)->get_preferred_width_for_height (widget, min_size,
 565                                                                      minimum_size, natural_size);
 566     }
 567 }
 568
 569 static void
 570 cell_area_scaffold_get_preferred_height_for_width (GtkWidget       *widget,
 571                                                    gint             for_size,
 572                                                    gint            *minimum_size,
 573                                                    gint            *natural_size)
 574 {
 575   CellAreaScaffold        *scaffold = CELL_AREA_SCAFFOLD (widget);
 576   CellAreaScaffoldPrivate *priv     = scaffold->priv;
 577   GtkOrientation           orientation;
 578
 579   if (!priv->model)
 580     return;
 581
 582   orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (priv->area));
 583
 584   if (orientation == GTK_ORIENTATION_HORIZONTAL)
 585     {
 586       GArray *request_array;
 587       gint    n_rows, i, full_size = 0;
 588
 589       n_rows = gtk_tree_model_iter_n_children (priv->model, NULL);
 590
 591       /* Get an array for the contextual request */
 592       request_array = g_array_new (FALSE, FALSE, sizeof (RowData));
 593       g_array_set_size (request_array, n_rows);
 594       memset (request_array->data, 0x0, n_rows * sizeof (RowData));
 595
 596       /* Gather each contextual size into the request array */
 597       get_row_sizes (scaffold, request_array, for_size);
 598
 599       /* Sum up the size and add some row spacing */
 600       for (i = 0; i < n_rows; i++)
 601         {
 602           RowData *data = &g_array_index (request_array, RowData, i);
 603
 604           full_size += data->size;
 605         }
 606
 607       full_size += MAX (0, n_rows -1) * ROW_SPACING;
 608
 609       g_array_free (request_array, TRUE);
 610
 611       *minimum_size = full_size;
 612       *natural_size = full_size;
 613     }
 614   else
 615     {
 616       GTK_WIDGET_GET_CLASS (widget)->get_preferred_height (widget, minimum_size, natural_size);
 617     }
 618 }
 619
 620 static void
 621 cell_area_scaffold_get_preferred_height (GtkWidget       *widget,
 622                                          gint            *minimum_size,
 623                                          gint            *natural_size)
 624 {
 625   CellAreaScaffold        *scaffold = CELL_AREA_SCAFFOLD (widget);
 626   CellAreaScaffoldPrivate *priv     = scaffold->priv;
 627   GtkOrientation           orientation;
 628
 629   if (!priv->model)
 630     return;
 631
 632   orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (priv->area));
 633
 634   if (orientation == GTK_ORIENTATION_VERTICAL)
 635     {
 636       request_all_base (scaffold);
 637
 638       gtk_cell_area_iter_get_preferred_height (priv->iter, minimum_size, natural_size);
 639     }
 640   else
 641     {
 642       gint min_size, nat_size;
 643
 644       GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, &min_size, &nat_size);
 645       GTK_WIDGET_GET_CLASS (widget)->get_preferred_height_for_width (widget, min_size,
 646                                                                      minimum_size, natural_size);
 647     }
 648 }
 649
 650 static void
 651 cell_area_scaffold_get_preferred_width_for_height (GtkWidget       *widget,
 652                                                    gint             for_size,
 653                                                    gint            *minimum_size,
 654                                                    gint            *natural_size)
 655 {
 656   CellAreaScaffold        *scaffold = CELL_AREA_SCAFFOLD (widget);
 657   CellAreaScaffoldPrivate *priv     = scaffold->priv;
 658   GtkOrientation           orientation;
 659
 660   if (!priv->model)
 661     return;
 662
 663   orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (priv->area));
 664
 665   if (orientation == GTK_ORIENTATION_VERTICAL)
 666     {
 667       GArray *request_array;
 668       gint    n_rows, i, full_size = 0;
 669
 670       n_rows = gtk_tree_model_iter_n_children (priv->model, NULL);
 671
 672       /* Get an array for the contextual request */
 673       request_array = g_array_new (FALSE, FALSE, sizeof (RowData));
 674       g_array_set_size (request_array, n_rows);
 675       memset (request_array->data, 0x0, n_rows * sizeof (RowData));
 676
 677       /* Gather each contextual size into the request array */
 678       get_row_sizes (scaffold, request_array, for_size);
 679
 680       /* Sum up the size and add some row spacing */
 681       for (i = 0; i < n_rows; i++)
 682         {
 683           RowData *data = &g_array_index (request_array, RowData, i);
 684
 685           full_size += data->size;
 686         }
 687
 688       full_size += MAX (0, n_rows -1) * ROW_SPACING;
 689
 690       g_array_free (request_array, TRUE);
 691
 692       *minimum_size = full_size;
 693       *natural_size = full_size;
 694     }
 695   else
 696     {
 697       GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, minimum_size, natural_size);
 698     }
 699 }
 700
 701 static gint
 702 cell_area_scaffold_focus (GtkWidget       *widget,
 703                           GtkDirectionType direction)
 704 {
 705   CellAreaScaffold        *scaffold = CELL_AREA_SCAFFOLD (widget);
 706   CellAreaScaffoldPrivate *priv     = scaffold->priv;
 707   GtkTreeIter              iter;
 708   gboolean                 valid;
 709   gint                     focus_row;
 710   GtkOrientation           orientation;
 711
 712   /* Grab focus on ourself if we dont already have focus */
 713   if (!gtk_widget_has_focus (widget))
 714     gtk_widget_grab_focus (widget);
 715
 716   /* Move focus from cell to cell and row to row */
 717   orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (priv->area));
 718
 719   focus_row = priv->focus_row;
 720
 721   valid = gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, priv->focus_row);
 722   while (valid)
 723     {
 724       gtk_cell_area_apply_attributes (priv->area, priv->model, &iter, FALSE, FALSE);
 725
 726       /* If focus stays in the area we dont need to do any more */
 727       if (gtk_cell_area_focus (priv->area, direction))
 728         {
 729           GtkCellRenderer *renderer = gtk_cell_area_get_focus_cell (priv->area);
 730
 731           priv->focus_row = focus_row;
 732
 733           g_print ("focusing in direction %s: focus set on a %s in row %d\n",
 734                    DIRECTION_STR (direction), G_OBJECT_TYPE_NAME (renderer), priv->focus_row);
 735
 736           return TRUE;
 737         }
 738       else
 739         {
 740           if (orientation == GTK_ORIENTATION_HORIZONTAL)
 741             {
 742               if (direction == GTK_DIR_RIGHT ||
 743                   direction == GTK_DIR_LEFT)
 744                 break;
 745               else if (direction == GTK_DIR_UP ||
 746                        direction == GTK_DIR_TAB_BACKWARD)
 747                 {
 748                   if (focus_row == 0)
 749                     break;
 750                   else
 751                     {
 752                       /* XXX A real implementation should check if the
 753                        * previous row can focus with it's attributes setup */
 754                       focus_row--;
 755                       valid = gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, focus_row);
 756                     }
 757                 }
 758               else /* direction == GTK_DIR_DOWN || GTK_DIR_TAB_FORWARD */
 759                 {
 760                   if (focus_row == priv->row_data->len - 1)
 761                     break;
 762                   else
 763                     {
 764                       /* XXX A real implementation should check if the
 765                        * previous row can focus with it's attributes setup */
 766                       focus_row++;
 767                       valid = gtk_tree_model_iter_next (priv->model, &iter);
 768                     }
 769                 }
 770             }
 771           else  /* (orientation == GTK_ORIENTATION_HORIZONTAL) */
 772             {
 773               if (direction == GTK_DIR_UP ||
 774                   direction == GTK_DIR_DOWN)
 775                 break;
 776               else if (direction == GTK_DIR_LEFT ||
 777                        direction == GTK_DIR_TAB_BACKWARD)
 778                 {
 779                   if (focus_row == 0)
 780                     break;
 781                   else
 782                     {
 783                       /* XXX A real implementation should check if the
 784                        * previous row can focus with it's attributes setup */
 785                       focus_row--;
 786                       valid = gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, focus_row);
 787                     }
 788                 }
 789               else /* direction == GTK_DIR_RIGHT || GTK_DIR_TAB_FORWARD */
 790                 {
 791                   if (focus_row == priv->row_data->len - 1)
 792                     break;
 793                   else
 794                     {
 795                       /* XXX A real implementation should check if the
 796                        * previous row can focus with it's attributes setup */
 797                       focus_row++;
 798                       valid = gtk_tree_model_iter_next (priv->model, &iter);
 799                     }
 800                 }
 801             }
 802         }
 803     }
 804
 805   g_print ("focus leaving with no cells in focus (direction %s, focus_row %d)\n",
 806            DIRECTION_STR (direction), priv->focus_row);
 807
 808   return FALSE;
 809 }
 810
 811 /*********************************************************
 812  *                CellAreaScaffoldClass                  *
 813  *********************************************************/
 814 static void
 815 cell_area_scaffold_activate (CellAreaScaffold *scaffold)
 816 {
 817   CellAreaScaffoldPrivate *priv     = scaffold->priv;
 818   GtkWidget               *widget   = GTK_WIDGET (scaffold);
 819   GtkAllocation            allocation;
 820   GtkOrientation           orientation;
 821   GdkRectangle             cell_area;
 822   GtkTreeIter              iter;
 823   gboolean                 valid;
 824   gint                     i = 0;
 825
 826   orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (priv->area));
 827   gtk_widget_get_allocation (widget, &allocation);
 828
 829   cell_area.x = 0;
 830   cell_area.y = 0;
 831   cell_area.width  = allocation.width;
 832   cell_area.height = allocation.height;
 833
 834   valid = gtk_tree_model_get_iter_first (priv->model, &iter);
 835   while (valid)
 836     {
 837       RowData *data = &g_array_index (priv->row_data, RowData, i);
 838
 839       if (i == priv->focus_row)
 840         {
 841           if (orientation == GTK_ORIENTATION_HORIZONTAL)
 842             cell_area.height = data->size;
 843           else
 844             cell_area.width = data->size;
 845
 846           gtk_cell_area_apply_attributes (priv->area, priv->model, &iter, FALSE, FALSE);
 847           gtk_cell_area_activate (priv->area, priv->iter, widget, &cell_area, GTK_CELL_RENDERER_FOCUSED);
 848
 849           break;
 850         }
 851
 852       if (orientation == GTK_ORIENTATION_HORIZONTAL)
 853         cell_area.y += data->size + ROW_SPACING;
 854       else
 855         cell_area.x += data->size + ROW_SPACING;
 856
 857       i++;
 858       valid = gtk_tree_model_iter_next (priv->model, &iter);
 859     }
 860 }
 861
 862 /*********************************************************
 863  *           CellArea/GtkTreeModel callbacks             *
 864  *********************************************************/
 865 static void
 866 size_changed_cb (GtkCellAreaIter  *iter,
 867                  GParamSpec       *pspec,
 868                  CellAreaScaffold *scaffold)
 869 {
 870   if (!strcmp (pspec->name, "minimum-width") ||
 871       !strcmp (pspec->name, "natural-width") ||
 872       !strcmp (pspec->name, "minimum-height") ||
 873       !strcmp (pspec->name, "natural-height"))
 874     gtk_widget_queue_resize (GTK_WIDGET (scaffold));
 875 }
 876
 877 static void
 878 rebuild_and_flush_internals (CellAreaScaffold *scaffold)
 879 {
 880   CellAreaScaffoldPrivate *priv = scaffold->priv;
 881   gint n_rows;
 882
 883   if (priv->model)
 884     {
 885       n_rows = gtk_tree_model_iter_n_children (priv->model, NULL);
 886
 887       /* Clear/reset the array */
 888       g_array_set_size (priv->row_data, n_rows);
 889       memset (priv->row_data->data, 0x0, n_rows * sizeof (RowData));
 890     }
 891   else
 892     g_array_set_size (priv->row_data, 0);
 893
 894   /* Data changed, lets flush the iter and consequently queue resize and
 895    * start everything over again (note this is definitly far from optimized) */
 896   gtk_cell_area_iter_flush (priv->iter);
 897 }
 898
 899 static void
 900 row_changed_cb (GtkTreeModel     *model,
 901                 GtkTreePath      *path,
 902                 GtkTreeIter      *iter,
 903                 CellAreaScaffold *scaffold)
 904 {
 905   rebuild_and_flush_internals (scaffold);
 906 }
 907
 908 static void
 909 row_inserted_cb (GtkTreeModel     *model,
 910                  GtkTreePath      *path,
 911                  GtkTreeIter      *iter,
 912                  CellAreaScaffold *scaffold)
 913 {
 914   rebuild_and_flush_internals (scaffold);
 915 }
 916
 917 static void
 918 row_deleted_cb (GtkTreeModel     *model,
 919                 GtkTreePath      *path,
 920                 CellAreaScaffold *scaffold)
 921 {
 922   rebuild_and_flush_internals (scaffold);
 923 }
 924
 925 static void
 926 rows_reordered_cb (GtkTreeModel     *model,
 927                    GtkTreePath      *parent,
 928                    GtkTreeIter      *iter,
 929                    gint             *new_order,
 930                    CellAreaScaffold *scaffold)
 931 {
 932   rebuild_and_flush_internals (scaffold);
 933 }
 934
 935 /*********************************************************
 936  *                         API                           *
 937  *********************************************************/
 938 GtkWidget *
 939 cell_area_scaffold_new (void)
 940 {
 941   return (GtkWidget *)g_object_new (TYPE_CELL_AREA_SCAFFOLD, NULL);
 942 }
 943
 944 GtkCellArea  *
 945 cell_area_scaffold_get_area (CellAreaScaffold *scaffold)
 946 {
 947   CellAreaScaffoldPrivate *priv;
 948
 949   g_return_val_if_fail (IS_CELL_AREA_SCAFFOLD (scaffold), NULL);
 950
 951   priv = scaffold->priv;
 952
 953   return priv->area;
 954 }
 955
 956 void
 957 cell_area_scaffold_set_model (CellAreaScaffold *scaffold,
 958                               GtkTreeModel     *model)
 959 {
 960   CellAreaScaffoldPrivate *priv;
 961
 962   g_return_if_fail (IS_CELL_AREA_SCAFFOLD (scaffold));
 963
 964   priv = scaffold->priv;
 965
 966   if (priv->model != model)
 967     {
 968       if (priv->model)
 969         {
 970           g_signal_handler_disconnect (priv->model, priv->row_changed_id);
 971           g_signal_handler_disconnect (priv->model, priv->row_inserted_id);
 972           g_signal_handler_disconnect (priv->model, priv->row_deleted_id);
 973           g_signal_handler_disconnect (priv->model, priv->rows_reordered_id);
 974
 975           g_object_unref (priv->model);
 976         }
 977
 978       priv->model = model;
 979
 980       if (priv->model)
 981         {
 982           g_object_ref (priv->model);
 983
 984           priv->row_changed_id =
 985             g_signal_connect (priv->model, "row-changed",
 986                               G_CALLBACK (row_changed_cb), scaffold);
 987
 988           priv->row_inserted_id =
 989             g_signal_connect (priv->model, "row-inserted",
 990                               G_CALLBACK (row_inserted_cb), scaffold);
 991
 992           priv->row_deleted_id =
 993             g_signal_connect (priv->model, "row-deleted",
 994                               G_CALLBACK (row_deleted_cb), scaffold);
 995
 996           priv->rows_reordered_id =
 997             g_signal_connect (priv->model, "rows-reordered",
 998                               G_CALLBACK (rows_reordered_cb), scaffold);
 999         }
1000
1001       rebuild_and_flush_internals (scaffold);
1002     }
1003 }
1004
1005 GtkTreeModel *
1006 cell_area_scaffold_get_model (CellAreaScaffold *scaffold)
1007 {
1008   CellAreaScaffoldPrivate *priv;
1009
1010   g_return_val_if_fail (IS_CELL_AREA_SCAFFOLD (scaffold), NULL);
1011
1012   priv = scaffold->priv;
1013
1014   return priv->model;
1015 }