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