3 * Copyright (C) 2010 Openismus GmbH
6 * Tristan Van Berkom <tristanvb@openismus.com>
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.
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.
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.
25 #include "cellareascaffold.h"
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,
34 static void cell_area_scaffold_get_property (GObject *object,
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,
44 static void cell_area_scaffold_size_allocate (GtkWidget *widget,
45 GtkAllocation *allocation);
46 static void cell_area_scaffold_get_preferred_width (GtkWidget *widget,
49 static void cell_area_scaffold_get_preferred_height_for_width (GtkWidget *widget,
53 static void cell_area_scaffold_get_preferred_height (GtkWidget *widget,
56 static void cell_area_scaffold_get_preferred_width_for_height (GtkWidget *widget,
60 static void cell_area_scaffold_map (GtkWidget *widget);
61 static void cell_area_scaffold_unmap (GtkWidget *widget);
62 static gint cell_area_scaffold_focus (GtkWidget *widget,
63 GtkDirectionType direction);
64 static gboolean cell_area_scaffold_button_press (GtkWidget *widget,
65 GdkEventButton *event);
67 /* GtkContainerClass */
68 static void cell_area_scaffold_forall (GtkContainer *container,
69 gboolean include_internals,
71 gpointer callback_data);
72 static void cell_area_scaffold_remove (GtkContainer *container,
74 static void cell_area_scaffold_put_edit_widget (CellAreaScaffold *scaffold,
75 GtkWidget *edit_widget,
81 /* CellAreaScaffoldClass */
82 static void cell_area_scaffold_activate (CellAreaScaffold *scaffold);
84 /* CellArea/GtkTreeModel callbacks */
85 static void size_changed_cb (GtkCellAreaContext *context,
87 CellAreaScaffold *scaffold);
88 static void focus_changed_cb (GtkCellArea *area,
89 GtkCellRenderer *renderer,
91 CellAreaScaffold *scaffold);
92 static void add_editable_cb (GtkCellArea *area,
93 GtkCellRenderer *renderer,
94 GtkCellEditable *edit_widget,
95 GdkRectangle *cell_area,
97 CellAreaScaffold *scaffold);
98 static void remove_editable_cb (GtkCellArea *area,
99 GtkCellRenderer *renderer,
100 GtkCellEditable *edit_widget,
101 CellAreaScaffold *scaffold);
102 static void row_changed_cb (GtkTreeModel *model,
105 CellAreaScaffold *scaffold);
106 static void row_inserted_cb (GtkTreeModel *model,
109 CellAreaScaffold *scaffold);
110 static void row_deleted_cb (GtkTreeModel *model,
112 CellAreaScaffold *scaffold);
113 static void rows_reordered_cb (GtkTreeModel *model,
117 CellAreaScaffold *scaffold);
120 gint size; /* The size of the row in the scaffold's opposing orientation */
123 struct _CellAreaScaffoldPrivate {
125 /* Window for catching events and dispatching them to the cell area */
126 GdkWindow *event_window;
128 /* The model we're showing data for */
130 gulong row_changed_id;
131 gulong row_inserted_id;
132 gulong row_deleted_id;
133 gulong rows_reordered_id;
135 /* The area rendering the data and a global context */
137 GtkCellAreaContext *context;
139 /* Cache some info about rows (hieghts etc) */
144 gulong focus_changed_id;
146 /* Check when the underlying area changes the size and
147 * we need to queue a redraw */
148 gulong size_changed_id;
150 /* Currently edited widget */
151 GtkWidget *edit_widget;
152 GdkRectangle edit_rect;
153 gulong add_editable_id;
154 gulong remove_editable_id;
171 static guint scaffold_signals[N_SIGNALS] = { 0 };
173 #define DIRECTION_STR(dir) \
174 ((dir) == GTK_DIR_TAB_FORWARD ? "tab forward" : \
175 (dir) == GTK_DIR_TAB_BACKWARD ? "tab backward" : \
176 (dir) == GTK_DIR_UP ? "up" : \
177 (dir) == GTK_DIR_DOWN ? "down" : \
178 (dir) == GTK_DIR_LEFT ? "left" : \
179 (dir) == GTK_DIR_RIGHT ? "right" : "invalid")
181 G_DEFINE_TYPE_WITH_CODE (CellAreaScaffold, cell_area_scaffold, GTK_TYPE_CONTAINER,
182 G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, NULL));
186 cell_area_scaffold_init (CellAreaScaffold *scaffold)
188 CellAreaScaffoldPrivate *priv;
190 scaffold->priv = G_TYPE_INSTANCE_GET_PRIVATE (scaffold,
191 TYPE_CELL_AREA_SCAFFOLD,
192 CellAreaScaffoldPrivate);
193 priv = scaffold->priv;
195 priv->area = gtk_cell_area_box_new ();
196 priv->context = gtk_cell_area_create_context (priv->area);
198 priv->row_data = g_array_new (FALSE, FALSE, sizeof (RowData));
200 gtk_widget_set_has_window (GTK_WIDGET (scaffold), FALSE);
201 gtk_widget_set_can_focus (GTK_WIDGET (scaffold), TRUE);
203 priv->size_changed_id =
204 g_signal_connect (priv->context, "notify",
205 G_CALLBACK (size_changed_cb), scaffold);
207 priv->focus_changed_id =
208 g_signal_connect (priv->area, "focus-changed",
209 G_CALLBACK (focus_changed_cb), scaffold);
211 priv->add_editable_id =
212 g_signal_connect (priv->area, "add-editable",
213 G_CALLBACK (add_editable_cb), scaffold);
215 priv->remove_editable_id =
216 g_signal_connect (priv->area, "remove-editable",
217 G_CALLBACK (remove_editable_cb), scaffold);
221 cell_area_scaffold_class_init (CellAreaScaffoldClass *class)
223 GObjectClass *gobject_class;
224 GtkWidgetClass *widget_class;
225 GtkContainerClass *container_class;
227 gobject_class = G_OBJECT_CLASS (class);
228 gobject_class->dispose = cell_area_scaffold_dispose;
229 gobject_class->finalize = cell_area_scaffold_finalize;
230 gobject_class->get_property = cell_area_scaffold_get_property;
231 gobject_class->set_property = cell_area_scaffold_set_property;
233 widget_class = GTK_WIDGET_CLASS (class);
234 widget_class->realize = cell_area_scaffold_realize;
235 widget_class->unrealize = cell_area_scaffold_unrealize;
236 widget_class->draw = cell_area_scaffold_draw;
237 widget_class->size_allocate = cell_area_scaffold_size_allocate;
238 widget_class->get_preferred_width = cell_area_scaffold_get_preferred_width;
239 widget_class->get_preferred_height_for_width = cell_area_scaffold_get_preferred_height_for_width;
240 widget_class->get_preferred_height = cell_area_scaffold_get_preferred_height;
241 widget_class->get_preferred_width_for_height = cell_area_scaffold_get_preferred_width_for_height;
242 widget_class->map = cell_area_scaffold_map;
243 widget_class->unmap = cell_area_scaffold_unmap;
244 widget_class->focus = cell_area_scaffold_focus;
245 widget_class->button_press_event = cell_area_scaffold_button_press;
247 container_class = GTK_CONTAINER_CLASS (class);
248 container_class->forall = cell_area_scaffold_forall;
249 container_class->remove = cell_area_scaffold_remove;
251 class->activate = cell_area_scaffold_activate;
253 g_object_class_override_property (gobject_class, PROP_ORIENTATION, "orientation");
255 scaffold_signals[ACTIVATE] =
256 g_signal_new ("activate",
257 G_OBJECT_CLASS_TYPE (gobject_class),
258 G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
259 G_STRUCT_OFFSET (CellAreaScaffoldClass, activate),
261 g_cclosure_marshal_VOID__VOID,
263 widget_class->activate_signal = scaffold_signals[ACTIVATE];
266 g_type_class_add_private (gobject_class, sizeof (CellAreaScaffoldPrivate));
269 /*********************************************************
271 *********************************************************/
273 cell_area_scaffold_finalize (GObject *object)
275 CellAreaScaffold *scaffold = CELL_AREA_SCAFFOLD (object);
276 CellAreaScaffoldPrivate *priv;
278 priv = scaffold->priv;
280 g_array_free (priv->row_data, TRUE);
282 G_OBJECT_CLASS (cell_area_scaffold_parent_class)->finalize (object);
286 cell_area_scaffold_dispose (GObject *object)
288 CellAreaScaffold *scaffold = CELL_AREA_SCAFFOLD (object);
289 CellAreaScaffoldPrivate *priv;
291 priv = scaffold->priv;
293 cell_area_scaffold_set_model (scaffold, NULL);
297 /* Disconnect signals */
298 g_signal_handler_disconnect (priv->context, priv->size_changed_id);
300 g_object_unref (priv->context);
301 priv->context = NULL;
302 priv->size_changed_id = 0;
307 /* Disconnect signals */
308 g_signal_handler_disconnect (priv->area, priv->focus_changed_id);
309 g_signal_handler_disconnect (priv->area, priv->add_editable_id);
310 g_signal_handler_disconnect (priv->area, priv->remove_editable_id);
312 g_object_unref (priv->area);
314 priv->focus_changed_id = 0;
317 G_OBJECT_CLASS (cell_area_scaffold_parent_class)->dispose (object);
321 cell_area_scaffold_set_property (GObject *object,
326 CellAreaScaffold *scaffold = CELL_AREA_SCAFFOLD (object);
327 CellAreaScaffoldPrivate *priv;
329 priv = scaffold->priv;
333 case PROP_ORIENTATION:
334 gtk_orientable_set_orientation (GTK_ORIENTABLE (priv->area),
335 g_value_get_enum (value));
338 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
344 cell_area_scaffold_get_property (GObject *object,
349 CellAreaScaffold *scaffold = CELL_AREA_SCAFFOLD (object);
350 CellAreaScaffoldPrivate *priv;
352 priv = scaffold->priv;
356 case PROP_ORIENTATION:
357 g_value_set_enum (value,
358 gtk_orientable_get_orientation (GTK_ORIENTABLE (priv->area)));
361 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
366 /*********************************************************
368 *********************************************************/
370 cell_area_scaffold_realize (GtkWidget *widget)
372 CellAreaScaffold *scaffold = CELL_AREA_SCAFFOLD (widget);
373 CellAreaScaffoldPrivate *priv = scaffold->priv;
374 GtkAllocation allocation;
376 GdkWindowAttr attributes;
377 gint attributes_mask;
379 gtk_widget_get_allocation (widget, &allocation);
381 gtk_widget_set_realized (widget, TRUE);
383 attributes.window_type = GDK_WINDOW_CHILD;
384 attributes.x = allocation.x;
385 attributes.y = allocation.y;
386 attributes.width = allocation.width;
387 attributes.height = allocation.height;
388 attributes.wclass = GDK_INPUT_ONLY;
389 attributes.event_mask = gtk_widget_get_events (widget);
390 attributes.event_mask |= (GDK_BUTTON_PRESS_MASK |
391 GDK_BUTTON_RELEASE_MASK |
393 GDK_KEY_RELEASE_MASK);
395 attributes_mask = GDK_WA_X | GDK_WA_Y;
397 window = gtk_widget_get_parent_window (widget);
398 gtk_widget_set_window (widget, window);
399 g_object_ref (window);
401 priv->event_window = gdk_window_new (window, &attributes, attributes_mask);
402 gdk_window_set_user_data (priv->event_window, widget);
404 gtk_widget_style_attach (widget);
408 cell_area_scaffold_unrealize (GtkWidget *widget)
410 CellAreaScaffold *scaffold = CELL_AREA_SCAFFOLD (widget);
411 CellAreaScaffoldPrivate *priv = scaffold->priv;
413 if (priv->event_window)
415 gdk_window_set_user_data (priv->event_window, NULL);
416 gdk_window_destroy (priv->event_window);
417 priv->event_window = NULL;
420 GTK_WIDGET_CLASS (cell_area_scaffold_parent_class)->unrealize (widget);
424 cell_area_scaffold_draw (GtkWidget *widget,
427 CellAreaScaffold *scaffold = CELL_AREA_SCAFFOLD (widget);
428 CellAreaScaffoldPrivate *priv = scaffold->priv;
429 GtkOrientation orientation;
432 GdkRectangle background_area;
433 GdkRectangle render_area;
434 GtkAllocation allocation;
437 GtkCellRendererState flags;
442 have_focus = gtk_widget_has_focus (widget);
443 orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (priv->area));
445 gtk_widget_get_allocation (widget, &allocation);
449 render_area.width = allocation.width;
450 render_area.height = allocation.height;
452 background_area = render_area;
454 if (orientation == GTK_ORIENTATION_HORIZONTAL)
456 render_area.x = priv->indent;
457 render_area.width -= priv->indent;
461 render_area.y = priv->indent;
462 render_area.height -= priv->indent;
465 valid = gtk_tree_model_get_iter_first (priv->model, &iter);
468 RowData *data = &g_array_index (priv->row_data, RowData, i);
470 if (have_focus && i == priv->focus_row)
471 flags = GTK_CELL_RENDERER_FOCUSED;
475 if (orientation == GTK_ORIENTATION_HORIZONTAL)
477 render_area.height = data->size;
479 background_area.height = render_area.height;
480 background_area.y = render_area.y;
484 background_area.height += priv->row_spacing / 2;
485 background_area.height += priv->row_spacing % 2;
487 else if (i == priv->row_data->len - 1)
489 background_area.y -= priv->row_spacing / 2;
490 background_area.height += priv->row_spacing / 2;
494 background_area.y -= priv->row_spacing / 2;
495 background_area.height += priv->row_spacing;
498 else /* GTK_ORIENTATION_VERTICAL */
500 render_area.width = data->size;
502 background_area.width = render_area.width;
503 background_area.x = render_area.x;
507 background_area.width += priv->row_spacing / 2;
508 background_area.width += priv->row_spacing % 2;
510 else if (i == priv->row_data->len - 1)
512 background_area.x -= priv->row_spacing / 2;
513 background_area.width += priv->row_spacing / 2;
517 background_area.x -= priv->row_spacing / 2;
518 background_area.width += priv->row_spacing;
522 gtk_cell_area_apply_attributes (priv->area, priv->model, &iter, FALSE, FALSE);
523 gtk_cell_area_render (priv->area, priv->context, widget, cr,
524 &background_area, &render_area, flags,
525 (have_focus && i == priv->focus_row));
527 if (orientation == GTK_ORIENTATION_HORIZONTAL)
529 render_area.y += data->size;
530 render_area.y += priv->row_spacing;
534 render_area.x += data->size;
535 render_area.x += priv->row_spacing;
539 valid = gtk_tree_model_iter_next (priv->model, &iter);
542 /* Draw the edit widget after drawing everything else */
543 GTK_WIDGET_CLASS (cell_area_scaffold_parent_class)->draw (widget, cr);
549 request_all_base (CellAreaScaffold *scaffold)
551 CellAreaScaffoldPrivate *priv = scaffold->priv;
552 GtkWidget *widget = GTK_WIDGET (scaffold);
553 GtkOrientation orientation;
560 g_signal_handler_block (priv->context, priv->size_changed_id);
562 orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (priv->area));
564 valid = gtk_tree_model_get_iter_first (priv->model, &iter);
569 gtk_cell_area_apply_attributes (priv->area, priv->model, &iter, FALSE, FALSE);
571 if (orientation == GTK_ORIENTATION_HORIZONTAL)
572 gtk_cell_area_get_preferred_width (priv->area, priv->context, widget, &min, &nat);
574 gtk_cell_area_get_preferred_height (priv->area, priv->context, widget, &min, &nat);
576 valid = gtk_tree_model_iter_next (priv->model, &iter);
579 if (orientation == GTK_ORIENTATION_HORIZONTAL)
580 gtk_cell_area_context_sum_preferred_width (priv->context);
582 gtk_cell_area_context_sum_preferred_height (priv->context);
584 g_signal_handler_unblock (priv->context, priv->size_changed_id);
588 get_row_sizes (CellAreaScaffold *scaffold,
592 CellAreaScaffoldPrivate *priv = scaffold->priv;
593 GtkWidget *widget = GTK_WIDGET (scaffold);
594 GtkOrientation orientation;
602 orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (priv->area));
604 valid = gtk_tree_model_get_iter_first (priv->model, &iter);
607 RowData *data = &g_array_index (array, RowData, i);
609 gtk_cell_area_apply_attributes (priv->area, priv->model, &iter, FALSE, FALSE);
611 if (orientation == GTK_ORIENTATION_HORIZONTAL)
612 gtk_cell_area_get_preferred_height_for_width (priv->area, priv->context, widget,
613 for_size, &data->size, NULL);
615 gtk_cell_area_get_preferred_width_for_height (priv->area, priv->context, widget,
616 for_size, &data->size, NULL);
619 valid = gtk_tree_model_iter_next (priv->model, &iter);
624 cell_area_scaffold_size_allocate (GtkWidget *widget,
625 GtkAllocation *allocation)
627 CellAreaScaffold *scaffold = CELL_AREA_SCAFFOLD (widget);
628 CellAreaScaffoldPrivate *priv = scaffold->priv;
629 GtkOrientation orientation;
631 gtk_widget_set_allocation (widget, allocation);
633 if (gtk_widget_get_realized (widget))
634 gdk_window_move_resize (priv->event_window,
640 /* Allocate the child GtkCellEditable widget if one is currently editing a row */
641 if (priv->edit_widget)
642 gtk_widget_size_allocate (priv->edit_widget, &priv->edit_rect);
647 orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (priv->area));
649 /* Cache the per-row sizes and allocate the context */
650 if (orientation == GTK_ORIENTATION_HORIZONTAL)
652 gtk_cell_area_context_allocate_width (priv->context, allocation->width - priv->indent);
653 get_row_sizes (scaffold, priv->row_data, allocation->width - priv->indent);
657 gtk_cell_area_context_allocate_height (priv->context, allocation->height - priv->indent);
658 get_row_sizes (scaffold, priv->row_data, allocation->height - priv->indent);
664 cell_area_scaffold_get_preferred_width (GtkWidget *widget,
668 CellAreaScaffold *scaffold = CELL_AREA_SCAFFOLD (widget);
669 CellAreaScaffoldPrivate *priv = scaffold->priv;
670 GtkOrientation orientation;
675 orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (priv->area));
677 if (orientation == GTK_ORIENTATION_HORIZONTAL)
679 request_all_base (scaffold);
681 gtk_cell_area_context_get_preferred_width (priv->context, minimum_size, natural_size);
683 *minimum_size += priv->indent;
684 *natural_size += priv->indent;
688 gint min_size, nat_size;
690 GTK_WIDGET_GET_CLASS (widget)->get_preferred_height (widget, &min_size, &nat_size);
691 GTK_WIDGET_GET_CLASS (widget)->get_preferred_width_for_height (widget, min_size,
692 minimum_size, natural_size);
697 cell_area_scaffold_get_preferred_height_for_width (GtkWidget *widget,
702 CellAreaScaffold *scaffold = CELL_AREA_SCAFFOLD (widget);
703 CellAreaScaffoldPrivate *priv = scaffold->priv;
704 GtkOrientation orientation;
709 orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (priv->area));
711 if (orientation == GTK_ORIENTATION_HORIZONTAL)
713 GArray *request_array;
714 gint n_rows, i, full_size = 0;
716 n_rows = gtk_tree_model_iter_n_children (priv->model, NULL);
718 /* Get an array for the contextual request */
719 request_array = g_array_new (FALSE, FALSE, sizeof (RowData));
720 g_array_set_size (request_array, n_rows);
721 memset (request_array->data, 0x0, n_rows * sizeof (RowData));
723 /* Gather each contextual size into the request array */
724 get_row_sizes (scaffold, request_array, for_size - priv->indent);
726 /* Sum up the size and add some row spacing */
727 for (i = 0; i < n_rows; i++)
729 RowData *data = &g_array_index (request_array, RowData, i);
731 full_size += data->size;
734 full_size += MAX (0, n_rows -1) * priv->row_spacing;
736 g_array_free (request_array, TRUE);
738 *minimum_size = full_size;
739 *natural_size = full_size;
743 GTK_WIDGET_GET_CLASS (widget)->get_preferred_height (widget, minimum_size, natural_size);
748 cell_area_scaffold_get_preferred_height (GtkWidget *widget,
752 CellAreaScaffold *scaffold = CELL_AREA_SCAFFOLD (widget);
753 CellAreaScaffoldPrivate *priv = scaffold->priv;
754 GtkOrientation orientation;
759 orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (priv->area));
761 if (orientation == GTK_ORIENTATION_VERTICAL)
763 request_all_base (scaffold);
765 gtk_cell_area_context_get_preferred_height (priv->context, minimum_size, natural_size);
767 *minimum_size += priv->indent;
768 *natural_size += priv->indent;
772 gint min_size, nat_size;
774 GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, &min_size, &nat_size);
775 GTK_WIDGET_GET_CLASS (widget)->get_preferred_height_for_width (widget, min_size,
776 minimum_size, natural_size);
781 cell_area_scaffold_get_preferred_width_for_height (GtkWidget *widget,
786 CellAreaScaffold *scaffold = CELL_AREA_SCAFFOLD (widget);
787 CellAreaScaffoldPrivate *priv = scaffold->priv;
788 GtkOrientation orientation;
793 orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (priv->area));
795 if (orientation == GTK_ORIENTATION_VERTICAL)
797 GArray *request_array;
798 gint n_rows, i, full_size = 0;
800 n_rows = gtk_tree_model_iter_n_children (priv->model, NULL);
802 /* Get an array for the contextual request */
803 request_array = g_array_new (FALSE, FALSE, sizeof (RowData));
804 g_array_set_size (request_array, n_rows);
805 memset (request_array->data, 0x0, n_rows * sizeof (RowData));
807 /* Gather each contextual size into the request array */
808 get_row_sizes (scaffold, request_array, for_size - priv->indent);
810 /* Sum up the size and add some row spacing */
811 for (i = 0; i < n_rows; i++)
813 RowData *data = &g_array_index (request_array, RowData, i);
815 full_size += data->size;
818 full_size += MAX (0, n_rows -1) * priv->row_spacing;
820 g_array_free (request_array, TRUE);
822 *minimum_size = full_size;
823 *natural_size = full_size;
827 GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, minimum_size, natural_size);
832 cell_area_scaffold_map (GtkWidget *widget)
834 CellAreaScaffold *scaffold = CELL_AREA_SCAFFOLD (widget);
835 CellAreaScaffoldPrivate *priv = scaffold->priv;
837 GTK_WIDGET_CLASS (cell_area_scaffold_parent_class)->map (widget);
839 if (priv->event_window)
840 gdk_window_show (priv->event_window);
844 cell_area_scaffold_unmap (GtkWidget *widget)
846 CellAreaScaffold *scaffold = CELL_AREA_SCAFFOLD (widget);
847 CellAreaScaffoldPrivate *priv = scaffold->priv;
849 GTK_WIDGET_CLASS (cell_area_scaffold_parent_class)->unmap (widget);
851 if (priv->event_window)
852 gdk_window_hide (priv->event_window);
857 cell_area_scaffold_focus (GtkWidget *widget,
858 GtkDirectionType direction)
860 CellAreaScaffold *scaffold = CELL_AREA_SCAFFOLD (widget);
861 CellAreaScaffoldPrivate *priv = scaffold->priv;
865 GtkOrientation orientation;
866 gboolean changed = FALSE;
868 /* Grab focus on ourself if we dont already have focus */
869 if (!gtk_widget_has_focus (widget))
870 gtk_widget_grab_focus (widget);
872 /* Move focus from cell to cell and row to row */
873 orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (priv->area));
875 focus_row = priv->focus_row;
877 g_signal_handler_block (priv->area, priv->focus_changed_id);
879 valid = gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, priv->focus_row);
882 gtk_cell_area_apply_attributes (priv->area, priv->model, &iter, FALSE, FALSE);
884 /* If focus stays in the area we dont need to do any more */
885 if (gtk_cell_area_focus (priv->area, direction))
887 priv->focus_row = focus_row;
889 /* XXX A smarter implementation would only invalidate the rectangles where
890 * focus was removed from and new focus was placed */
891 gtk_widget_queue_draw (widget);
897 if (orientation == GTK_ORIENTATION_HORIZONTAL)
899 if (direction == GTK_DIR_RIGHT ||
900 direction == GTK_DIR_LEFT)
902 else if (direction == GTK_DIR_UP ||
903 direction == GTK_DIR_TAB_BACKWARD)
909 /* XXX A real implementation should check if the
910 * previous row can focus with it's attributes setup */
912 valid = gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, focus_row);
915 else /* direction == GTK_DIR_DOWN || GTK_DIR_TAB_FORWARD */
917 if (focus_row == priv->row_data->len - 1)
921 /* XXX A real implementation should check if the
922 * previous row can focus with it's attributes setup */
924 valid = gtk_tree_model_iter_next (priv->model, &iter);
928 else /* (orientation == GTK_ORIENTATION_HORIZONTAL) */
930 if (direction == GTK_DIR_UP ||
931 direction == GTK_DIR_DOWN)
933 else if (direction == GTK_DIR_LEFT ||
934 direction == GTK_DIR_TAB_BACKWARD)
940 /* XXX A real implementation should check if the
941 * previous row can focus with it's attributes setup */
943 valid = gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, focus_row);
946 else /* direction == GTK_DIR_RIGHT || GTK_DIR_TAB_FORWARD */
948 if (focus_row == priv->row_data->len - 1)
952 /* XXX A real implementation should check if the
953 * previous row can focus with it's attributes setup */
955 valid = gtk_tree_model_iter_next (priv->model, &iter);
962 g_signal_handler_unblock (priv->area, priv->focus_changed_id);
964 /* XXX A smarter implementation would only invalidate the rectangles where
965 * focus was removed from and new focus was placed */
966 gtk_widget_queue_draw (widget);
972 cell_area_scaffold_button_press (GtkWidget *widget,
973 GdkEventButton *event)
975 CellAreaScaffold *scaffold = CELL_AREA_SCAFFOLD (widget);
976 CellAreaScaffoldPrivate *priv = scaffold->priv;
979 GtkOrientation orientation;
981 GdkRectangle event_area;
982 GtkAllocation allocation;
983 gboolean handled = FALSE;
985 /* Move focus from cell to cell and row to row */
986 orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (priv->area));
988 gtk_widget_get_allocation (widget, &allocation);
992 event_area.width = allocation.width;
993 event_area.height = allocation.height;
995 if (orientation == GTK_ORIENTATION_HORIZONTAL)
997 event_area.x = priv->indent;
998 event_area.width -= priv->indent;
1002 event_area.y = priv->indent;
1003 event_area.height -= priv->indent;
1006 valid = gtk_tree_model_get_iter_first (priv->model, &iter);
1009 RowData *data = &g_array_index (priv->row_data, RowData, i);
1011 if (orientation == GTK_ORIENTATION_HORIZONTAL)
1013 event_area.height = data->size;
1015 if (event->y >= event_area.y &&
1016 event->y <= event_area.y + event_area.height)
1018 /* XXX A real implementation would assemble GtkCellRendererState flags here */
1019 gtk_cell_area_apply_attributes (priv->area, priv->model, &iter, FALSE, FALSE);
1020 handled = gtk_cell_area_event (priv->area, priv->context, GTK_WIDGET (scaffold),
1021 (GdkEvent *)event, &event_area, 0);
1025 event_area.y += data->size;
1026 event_area.y += priv->row_spacing;
1030 event_area.width = data->size;
1032 if (event->x >= event_area.x &&
1033 event->x <= event_area.x + event_area.width)
1035 /* XXX A real implementation would assemble GtkCellRendererState flags here */
1036 gtk_cell_area_apply_attributes (priv->area, priv->model, &iter, FALSE, FALSE);
1037 handled = gtk_cell_area_event (priv->area, priv->context, GTK_WIDGET (scaffold),
1038 (GdkEvent *)event, &event_area, 0);
1042 event_area.x += data->size;
1043 event_area.x += priv->row_spacing;
1047 valid = gtk_tree_model_iter_next (priv->model, &iter);
1054 /*********************************************************
1055 * GtkContainerClass *
1056 *********************************************************/
1058 cell_area_scaffold_put_edit_widget (CellAreaScaffold *scaffold,
1059 GtkWidget *edit_widget,
1065 CellAreaScaffoldPrivate *priv = scaffold->priv;
1067 priv->edit_rect.x = x;
1068 priv->edit_rect.y = y;
1069 priv->edit_rect.width = width;
1070 priv->edit_rect.height = height;
1071 priv->edit_widget = edit_widget;
1073 gtk_widget_set_parent (edit_widget, GTK_WIDGET (scaffold));
1077 cell_area_scaffold_forall (GtkContainer *container,
1078 gboolean include_internals,
1079 GtkCallback callback,
1080 gpointer callback_data)
1082 CellAreaScaffold *scaffold = CELL_AREA_SCAFFOLD (container);
1083 CellAreaScaffoldPrivate *priv = scaffold->priv;
1085 if (priv->edit_widget)
1086 (* callback) (priv->edit_widget, callback_data);
1090 cell_area_scaffold_remove (GtkContainer *container,
1093 CellAreaScaffold *scaffold = CELL_AREA_SCAFFOLD (container);
1094 CellAreaScaffoldPrivate *priv = scaffold->priv;
1096 g_return_if_fail (child == priv->edit_widget);
1098 gtk_widget_unparent (priv->edit_widget);
1099 priv->edit_widget = NULL;
1102 /*********************************************************
1103 * CellAreaScaffoldClass *
1104 *********************************************************/
1106 cell_area_scaffold_activate (CellAreaScaffold *scaffold)
1108 CellAreaScaffoldPrivate *priv = scaffold->priv;
1109 GtkWidget *widget = GTK_WIDGET (scaffold);
1110 GtkAllocation allocation;
1111 GtkOrientation orientation;
1112 GdkRectangle cell_area;
1117 orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (priv->area));
1118 gtk_widget_get_allocation (widget, &allocation);
1122 cell_area.width = allocation.width;
1123 cell_area.height = allocation.height;
1125 if (orientation == GTK_ORIENTATION_HORIZONTAL)
1127 cell_area.x = priv->indent;
1128 cell_area.width -= priv->indent;
1132 cell_area.y = priv->indent;
1133 cell_area.height -= priv->indent;
1136 valid = gtk_tree_model_get_iter_first (priv->model, &iter);
1139 RowData *data = &g_array_index (priv->row_data, RowData, i);
1141 if (i == priv->focus_row)
1143 if (orientation == GTK_ORIENTATION_HORIZONTAL)
1144 cell_area.height = data->size;
1146 cell_area.width = data->size;
1148 gtk_cell_area_apply_attributes (priv->area, priv->model, &iter, FALSE, FALSE);
1149 gtk_cell_area_activate (priv->area, priv->context, widget, &cell_area, GTK_CELL_RENDERER_FOCUSED);
1154 if (orientation == GTK_ORIENTATION_HORIZONTAL)
1155 cell_area.y += data->size + priv->row_spacing;
1157 cell_area.x += data->size + priv->row_spacing;
1160 valid = gtk_tree_model_iter_next (priv->model, &iter);
1164 /*********************************************************
1165 * CellArea/GtkTreeModel callbacks *
1166 *********************************************************/
1168 size_changed_cb (GtkCellAreaContext *context,
1170 CellAreaScaffold *scaffold)
1172 if (!strcmp (pspec->name, "minimum-width") ||
1173 !strcmp (pspec->name, "natural-width") ||
1174 !strcmp (pspec->name, "minimum-height") ||
1175 !strcmp (pspec->name, "natural-height"))
1176 gtk_widget_queue_resize (GTK_WIDGET (scaffold));
1180 focus_changed_cb (GtkCellArea *area,
1181 GtkCellRenderer *renderer,
1183 CellAreaScaffold *scaffold)
1185 CellAreaScaffoldPrivate *priv = scaffold->priv;
1186 GtkWidget *widget = GTK_WIDGET (scaffold);
1187 GtkTreePath *treepath;
1193 /* We can be signaled that a renderer lost focus, here
1198 treepath = gtk_tree_path_new_from_string (path);
1199 indices = gtk_tree_path_get_indices (treepath);
1201 priv->focus_row = indices[0];
1203 gtk_tree_path_free (treepath);
1205 /* Make sure we have focus now */
1206 if (!gtk_widget_has_focus (widget))
1207 gtk_widget_grab_focus (widget);
1209 gtk_widget_queue_draw (widget);
1213 add_editable_cb (GtkCellArea *area,
1214 GtkCellRenderer *renderer,
1215 GtkCellEditable *edit_widget,
1216 GdkRectangle *cell_area,
1218 CellAreaScaffold *scaffold)
1220 GtkAllocation allocation;
1222 gtk_widget_get_allocation (GTK_WIDGET (scaffold), &allocation);
1224 cell_area_scaffold_put_edit_widget (scaffold, GTK_WIDGET (edit_widget),
1225 allocation.x + cell_area->x,
1226 allocation.y + cell_area->y,
1227 cell_area->width, cell_area->height);
1231 remove_editable_cb (GtkCellArea *area,
1232 GtkCellRenderer *renderer,
1233 GtkCellEditable *edit_widget,
1234 CellAreaScaffold *scaffold)
1236 gtk_container_remove (GTK_CONTAINER (scaffold), GTK_WIDGET (edit_widget));
1238 gtk_widget_grab_focus (GTK_WIDGET (scaffold));
1242 rebuild_and_flush_internals (CellAreaScaffold *scaffold)
1244 CellAreaScaffoldPrivate *priv = scaffold->priv;
1249 n_rows = gtk_tree_model_iter_n_children (priv->model, NULL);
1251 /* Clear/reset the array */
1252 g_array_set_size (priv->row_data, n_rows);
1253 memset (priv->row_data->data, 0x0, n_rows * sizeof (RowData));
1256 g_array_set_size (priv->row_data, 0);
1258 /* Data changed, lets flush the context and consequently queue resize and
1259 * start everything over again (note this is definitly far from optimized) */
1260 gtk_cell_area_context_flush (priv->context);
1264 row_changed_cb (GtkTreeModel *model,
1267 CellAreaScaffold *scaffold)
1269 rebuild_and_flush_internals (scaffold);
1273 row_inserted_cb (GtkTreeModel *model,
1276 CellAreaScaffold *scaffold)
1278 rebuild_and_flush_internals (scaffold);
1282 row_deleted_cb (GtkTreeModel *model,
1284 CellAreaScaffold *scaffold)
1286 rebuild_and_flush_internals (scaffold);
1290 rows_reordered_cb (GtkTreeModel *model,
1291 GtkTreePath *parent,
1294 CellAreaScaffold *scaffold)
1296 rebuild_and_flush_internals (scaffold);
1299 /*********************************************************
1301 *********************************************************/
1303 cell_area_scaffold_new (void)
1305 return (GtkWidget *)g_object_new (TYPE_CELL_AREA_SCAFFOLD, NULL);
1309 cell_area_scaffold_get_area (CellAreaScaffold *scaffold)
1311 CellAreaScaffoldPrivate *priv;
1313 g_return_val_if_fail (IS_CELL_AREA_SCAFFOLD (scaffold), NULL);
1315 priv = scaffold->priv;
1321 cell_area_scaffold_set_model (CellAreaScaffold *scaffold,
1322 GtkTreeModel *model)
1324 CellAreaScaffoldPrivate *priv;
1326 g_return_if_fail (IS_CELL_AREA_SCAFFOLD (scaffold));
1328 priv = scaffold->priv;
1330 if (priv->model != model)
1334 g_signal_handler_disconnect (priv->model, priv->row_changed_id);
1335 g_signal_handler_disconnect (priv->model, priv->row_inserted_id);
1336 g_signal_handler_disconnect (priv->model, priv->row_deleted_id);
1337 g_signal_handler_disconnect (priv->model, priv->rows_reordered_id);
1339 g_object_unref (priv->model);
1342 priv->model = model;
1346 g_object_ref (priv->model);
1348 priv->row_changed_id =
1349 g_signal_connect (priv->model, "row-changed",
1350 G_CALLBACK (row_changed_cb), scaffold);
1352 priv->row_inserted_id =
1353 g_signal_connect (priv->model, "row-inserted",
1354 G_CALLBACK (row_inserted_cb), scaffold);
1356 priv->row_deleted_id =
1357 g_signal_connect (priv->model, "row-deleted",
1358 G_CALLBACK (row_deleted_cb), scaffold);
1360 priv->rows_reordered_id =
1361 g_signal_connect (priv->model, "rows-reordered",
1362 G_CALLBACK (rows_reordered_cb), scaffold);
1365 rebuild_and_flush_internals (scaffold);
1370 cell_area_scaffold_get_model (CellAreaScaffold *scaffold)
1372 CellAreaScaffoldPrivate *priv;
1374 g_return_val_if_fail (IS_CELL_AREA_SCAFFOLD (scaffold), NULL);
1376 priv = scaffold->priv;
1383 cell_area_scaffold_set_row_spacing (CellAreaScaffold *scaffold,
1386 CellAreaScaffoldPrivate *priv;
1388 g_return_if_fail (IS_CELL_AREA_SCAFFOLD (scaffold));
1390 priv = scaffold->priv;
1392 if (priv->row_spacing != spacing)
1394 priv->row_spacing = spacing;
1395 gtk_widget_queue_resize (GTK_WIDGET (scaffold));
1400 cell_area_scaffold_get_row_spacing (CellAreaScaffold *scaffold)
1402 CellAreaScaffoldPrivate *priv;
1404 g_return_val_if_fail (IS_CELL_AREA_SCAFFOLD (scaffold), 0);
1406 priv = scaffold->priv;
1408 return priv->row_spacing;
1412 cell_area_scaffold_set_indentation (CellAreaScaffold *scaffold,
1415 CellAreaScaffoldPrivate *priv;
1417 g_return_if_fail (IS_CELL_AREA_SCAFFOLD (scaffold));
1419 priv = scaffold->priv;
1421 if (priv->indent != indent)
1423 priv->indent = indent;
1424 gtk_widget_queue_resize (GTK_WIDGET (scaffold));
1429 cell_area_scaffold_get_indentation (CellAreaScaffold *scaffold)
1431 CellAreaScaffoldPrivate *priv;
1433 g_return_val_if_fail (IS_CELL_AREA_SCAFFOLD (scaffold), 0);
1435 priv = scaffold->priv;
1437 return priv->indent;