2 * Copyright (C) 2000 Red Hat, Inc., Jonathan Blandford <jrb@redhat.com>
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
21 #include "gtktreeview.h"
22 #include "gtkrbtree.h"
23 #include "gtktreeprivate.h"
24 #include "gtkcellrenderer.h"
25 #include "gtksignal.h"
27 #include "gtkbutton.h"
28 #include "gtkalignment.h"
31 #include <gdk/gdkkeysyms.h>
34 /* the width of the column resize windows */
35 #define TREE_VIEW_DRAG_WIDTH 6
36 #define TREE_VIEW_EXPANDER_WIDTH 14
37 #define TREE_VIEW_EXPANDER_HEIGHT 14
38 #define TREE_VIEW_VERTICAL_SEPARATOR 2
39 #define TREE_VIEW_HORIZONTAL_SEPARATOR 0
42 typedef struct _GtkTreeViewChild GtkTreeViewChild;
44 struct _GtkTreeViewChild
52 static void gtk_tree_view_init (GtkTreeView *tree_view);
53 static void gtk_tree_view_class_init (GtkTreeViewClass *klass);
56 static void gtk_tree_view_setup_model (GtkTreeView *tree_view);
57 static void gtk_tree_view_realize (GtkWidget *widget);
58 static void gtk_tree_view_unrealize (GtkWidget *widget);
59 static void gtk_tree_view_map (GtkWidget *widget);
60 static void gtk_tree_view_size_request (GtkWidget *widget,
61 GtkRequisition *requisition);
62 static void gtk_tree_view_size_allocate (GtkWidget *widget,
63 GtkAllocation *allocation);
64 static gboolean gtk_tree_view_expose (GtkWidget *widget,
65 GdkEventExpose *event);
66 static gboolean gtk_tree_view_motion (GtkWidget *widget,
67 GdkEventMotion *event);
68 static gboolean gtk_tree_view_enter_notify (GtkWidget *widget,
69 GdkEventCrossing *event);
70 static gboolean gtk_tree_view_leave_notify (GtkWidget *widget,
71 GdkEventCrossing *event);
72 static gboolean gtk_tree_view_button_press (GtkWidget *widget,
73 GdkEventButton *event);
74 static gboolean gtk_tree_view_button_release (GtkWidget *widget,
75 GdkEventButton *event);
76 static void gtk_tree_view_draw_focus (GtkWidget *widget);
77 static gint gtk_tree_view_focus_in (GtkWidget *widget,
78 GdkEventFocus *event);
79 static gint gtk_tree_view_focus_out (GtkWidget *widget,
80 GdkEventFocus *event);
81 static gint gtk_tree_view_focus (GtkContainer *container,
82 GtkDirectionType direction);
84 /* container signals */
85 static void gtk_tree_view_remove (GtkContainer *container,
87 static void gtk_tree_view_forall (GtkContainer *container,
88 gboolean include_internals,
90 gpointer callback_data);
92 /* tree_model signals */
93 static void gtk_tree_view_set_adjustments (GtkTreeView *tree_view,
96 static void gtk_tree_view_changed (GtkTreeModel *model,
100 static void gtk_tree_view_inserted (GtkTreeModel *model,
104 static void gtk_tree_view_child_toggled (GtkTreeModel *model,
108 static void gtk_tree_view_deleted (GtkTreeModel *model,
112 /* Internal functions */
113 static void gtk_tree_view_draw_arrow (GtkTreeView *tree_view,
118 static gint gtk_tree_view_new_column_width (GtkTreeView *tree_view,
121 static void gtk_tree_view_adjustment_changed (GtkAdjustment *adjustment,
122 GtkTreeView *tree_view);
123 static gint gtk_tree_view_insert_iter_height (GtkTreeView *tree_view,
127 static void gtk_tree_view_build_tree (GtkTreeView *tree_view,
132 gboolean calc_bounds);
133 static void gtk_tree_view_calc_size (GtkTreeView *priv,
137 static gboolean gtk_tree_view_discover_dirty_iter (GtkTreeView *tree_view,
141 static void gtk_tree_view_discover_dirty (GtkTreeView *tree_view,
145 static void gtk_tree_view_check_dirty (GtkTreeView *tree_view);
146 static void gtk_tree_view_create_button (GtkTreeView *tree_view,
148 static void gtk_tree_view_create_buttons (GtkTreeView *tree_view);
149 static void gtk_tree_view_button_clicked (GtkWidget *widget,
151 static void gtk_tree_view_clamp_node_visible (GtkTreeView *tree_view,
157 static GtkContainerClass *parent_class = NULL;
160 /* Class Functions */
162 gtk_tree_view_get_type (void)
164 static GtkType tree_view_type = 0;
168 static const GTypeInfo tree_view_info =
170 sizeof (GtkTreeViewClass),
171 NULL, /* base_init */
172 NULL, /* base_finalize */
173 (GClassInitFunc) gtk_tree_view_class_init,
174 NULL, /* class_finalize */
175 NULL, /* class_data */
176 sizeof (GtkTreeView),
178 (GInstanceInitFunc) gtk_tree_view_init
181 tree_view_type = g_type_register_static (GTK_TYPE_CONTAINER, "GtkTreeView", &tree_view_info, 0);
184 return tree_view_type;
188 gtk_tree_view_class_init (GtkTreeViewClass *class)
190 GtkObjectClass *object_class;
191 GtkWidgetClass *widget_class;
192 GtkContainerClass *container_class;
194 object_class = (GtkObjectClass*) class;
195 widget_class = (GtkWidgetClass*) class;
196 container_class = (GtkContainerClass*) class;
197 parent_class = g_type_class_peek_parent (class);
199 widget_class->realize = gtk_tree_view_realize;
200 widget_class->unrealize = gtk_tree_view_unrealize;
201 widget_class->map = gtk_tree_view_map;
202 widget_class->size_request = gtk_tree_view_size_request;
203 widget_class->size_allocate = gtk_tree_view_size_allocate;
204 widget_class->expose_event = gtk_tree_view_expose;
205 widget_class->motion_notify_event = gtk_tree_view_motion;
206 widget_class->enter_notify_event = gtk_tree_view_enter_notify;
207 widget_class->leave_notify_event = gtk_tree_view_leave_notify;
208 widget_class->button_press_event = gtk_tree_view_button_press;
209 widget_class->button_release_event = gtk_tree_view_button_release;
210 widget_class->draw_focus = gtk_tree_view_draw_focus;
211 widget_class->focus_in_event = gtk_tree_view_focus_in;
212 widget_class->focus_out_event = gtk_tree_view_focus_out;
214 container_class->forall = gtk_tree_view_forall;
215 container_class->remove = gtk_tree_view_remove;
216 container_class->focus = gtk_tree_view_focus;
218 class->set_scroll_adjustments = gtk_tree_view_set_adjustments;
220 widget_class->set_scroll_adjustments_signal =
221 gtk_signal_new ("set_scroll_adjustments",
223 GTK_CLASS_TYPE (object_class),
224 GTK_SIGNAL_OFFSET (GtkTreeViewClass, set_scroll_adjustments),
225 gtk_marshal_VOID__POINTER_POINTER,
227 GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);
231 gtk_tree_view_init (GtkTreeView *tree_view)
233 tree_view->priv = g_new0 (GtkTreeViewPrivate, 1);
235 GTK_WIDGET_SET_FLAGS (tree_view, GTK_CAN_FOCUS);
237 tree_view->priv->flags = GTK_TREE_VIEW_IS_LIST | GTK_TREE_VIEW_SHOW_EXPANDERS | GTK_TREE_VIEW_DRAW_KEYFOCUS | GTK_TREE_VIEW_HEADERS_VISIBLE;
238 tree_view->priv->tab_offset = TREE_VIEW_EXPANDER_WIDTH;
239 tree_view->priv->n_columns = 0;
240 tree_view->priv->columns = NULL;
241 tree_view->priv->button_pressed_node = NULL;
242 tree_view->priv->button_pressed_tree = NULL;
243 tree_view->priv->prelight_node = NULL;
244 tree_view->priv->prelight_offset = 0;
245 tree_view->priv->header_height = 1;
246 tree_view->priv->x_drag = 0;
247 tree_view->priv->drag_pos = -1;
248 tree_view->priv->selection = NULL;
249 tree_view->priv->anchor = NULL;
250 tree_view->priv->cursor = NULL;
251 gtk_tree_view_set_adjustments (tree_view, NULL, NULL);
252 _gtk_tree_view_set_size (tree_view, 0, 0);
259 gtk_tree_view_realize_buttons (GtkTreeView *tree_view)
262 GtkTreeViewColumn *column;
264 guint attributes_mask;
266 g_return_if_fail (GTK_WIDGET_REALIZED (tree_view));
267 g_return_if_fail (tree_view->priv->header_window != NULL);
269 attr.window_type = GDK_WINDOW_CHILD;
270 attr.wclass = GDK_INPUT_ONLY;
271 attr.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
272 attr.colormap = gtk_widget_get_colormap (GTK_WIDGET (tree_view));
273 attr.event_mask = gtk_widget_get_events (GTK_WIDGET (tree_view));
274 attr.event_mask = (GDK_BUTTON_PRESS_MASK |
275 GDK_BUTTON_RELEASE_MASK |
276 GDK_POINTER_MOTION_MASK |
277 GDK_POINTER_MOTION_HINT_MASK |
279 attributes_mask = GDK_WA_CURSOR | GDK_WA_X | GDK_WA_Y;
280 attr.cursor = gdk_cursor_new (GDK_SB_H_DOUBLE_ARROW);
281 tree_view->priv->cursor_drag = attr.cursor;
284 attr.width = TREE_VIEW_DRAG_WIDTH;
285 attr.height = tree_view->priv->header_height;
287 for (list = tree_view->priv->columns; list; list = list->next)
292 if (column->visible == FALSE)
294 if (column->window != NULL)
297 gtk_widget_set_parent_window (column->button,
298 tree_view->priv->header_window);
300 attr.x = (column->button->allocation.x + column->button->allocation.width) - 3;
302 column->window = gdk_window_new (tree_view->priv->header_window,
303 &attr, attributes_mask);
304 gdk_window_set_user_data (column->window, tree_view);
310 gtk_tree_view_realize (GtkWidget *widget)
313 GtkTreeView *tree_view;
315 GdkWindowAttr attributes;
316 gint attributes_mask;
318 g_return_if_fail (widget != NULL);
319 g_return_if_fail (GTK_IS_TREE_VIEW (widget));
321 tree_view = GTK_TREE_VIEW (widget);
323 if (!GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_MODEL_SETUP) &&
324 tree_view->priv->model)
325 gtk_tree_view_setup_model (tree_view);
327 gtk_tree_view_check_dirty (GTK_TREE_VIEW (widget));
328 GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
330 /* Make the main, clipping window */
331 attributes.window_type = GDK_WINDOW_CHILD;
332 attributes.x = widget->allocation.x;
333 attributes.y = widget->allocation.y;
334 attributes.width = widget->allocation.width;
335 attributes.height = widget->allocation.height;
336 attributes.wclass = GDK_INPUT_OUTPUT;
337 attributes.visual = gtk_widget_get_visual (widget);
338 attributes.colormap = gtk_widget_get_colormap (widget);
339 attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK;
341 attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
343 widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
344 &attributes, attributes_mask);
345 gdk_window_set_user_data (widget->window, widget);
347 /* Make the window for the tree */
350 attributes.width = tree_view->priv->width;
351 attributes.height = tree_view->priv->height + TREE_VIEW_HEADER_HEIGHT (tree_view);
352 attributes.event_mask = GDK_EXPOSURE_MASK |
354 GDK_POINTER_MOTION_MASK |
355 GDK_ENTER_NOTIFY_MASK |
356 GDK_LEAVE_NOTIFY_MASK |
357 GDK_BUTTON_PRESS_MASK |
358 GDK_BUTTON_RELEASE_MASK |
359 gtk_widget_get_events (widget);
361 tree_view->priv->bin_window = gdk_window_new (widget->window,
362 &attributes, attributes_mask);
363 gdk_window_set_user_data (tree_view->priv->bin_window, widget);
365 /* Make the column header window */
368 attributes.width = MAX (tree_view->priv->width, widget->allocation.width);
369 attributes.height = tree_view->priv->header_height;
370 attributes.event_mask = (GDK_EXPOSURE_MASK |
372 GDK_BUTTON_PRESS_MASK |
373 GDK_BUTTON_RELEASE_MASK |
375 GDK_KEY_RELEASE_MASK) |
376 gtk_widget_get_events (widget);
378 tree_view->priv->header_window = gdk_window_new (widget->window,
379 &attributes, attributes_mask);
380 gdk_window_set_user_data (tree_view->priv->header_window, widget);
383 values.foreground = (widget->style->white.pixel==0 ?
384 widget->style->black:widget->style->white);
385 values.function = GDK_XOR;
386 values.subwindow_mode = GDK_INCLUDE_INFERIORS;
387 tree_view->priv->xor_gc = gdk_gc_new_with_values (widget->window,
392 /* Add them all up. */
393 widget->style = gtk_style_attach (widget->style, widget->window);
394 gdk_window_set_background (widget->window, &widget->style->base[widget->state]);
395 gdk_window_set_background (tree_view->priv->bin_window, &widget->style->base[widget->state]);
396 gtk_style_set_background (widget->style, tree_view->priv->header_window, GTK_STATE_NORMAL);
398 tmp_list = tree_view->priv->children;
401 GtkTreeViewChild *child = tmp_list->data;
402 tmp_list = tmp_list->next;
404 gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
406 gtk_tree_view_realize_buttons (GTK_TREE_VIEW (widget));
407 _gtk_tree_view_set_size (GTK_TREE_VIEW (widget), -1, -1);
411 gtk_tree_view_unrealize (GtkWidget *widget)
413 GtkTreeView *tree_view;
415 g_return_if_fail (widget != NULL);
416 g_return_if_fail (GTK_IS_TREE_VIEW (widget));
418 tree_view = GTK_TREE_VIEW (widget);
420 /* FIXME where do we clear column->window for each column? */
422 gdk_window_set_user_data (tree_view->priv->bin_window, NULL);
423 gdk_window_destroy (tree_view->priv->bin_window);
424 tree_view->priv->bin_window = NULL;
426 gdk_window_set_user_data (tree_view->priv->header_window, NULL);
427 gdk_window_destroy (tree_view->priv->header_window);
428 tree_view->priv->header_window = NULL;
430 gdk_gc_destroy (tree_view->priv->xor_gc);
432 /* GtkWidget::unrealize destroys children and widget->window */
434 if (GTK_WIDGET_CLASS (parent_class)->unrealize)
435 (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
439 gtk_tree_view_map_buttons (GtkTreeView *tree_view)
443 g_return_if_fail (GTK_WIDGET_MAPPED (tree_view));
445 if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE))
447 GtkTreeViewColumn *column;
449 for (list = tree_view->priv->columns; list; list = list->next)
452 if (GTK_WIDGET_VISIBLE (column->button) &&
453 !GTK_WIDGET_MAPPED (column->button))
454 gtk_widget_map (column->button);
456 for (list = tree_view->priv->columns; list; list = list->next)
459 if (column->visible == FALSE)
461 if (column->column_type == GTK_TREE_VIEW_COLUMN_RESIZEABLE)
463 gdk_window_raise (column->window);
464 gdk_window_show (column->window);
467 gdk_window_hide (column->window);
469 gdk_window_show (tree_view->priv->header_window);
474 gtk_tree_view_map (GtkWidget *widget)
477 GtkTreeView *tree_view;
479 g_return_if_fail (widget != NULL);
480 g_return_if_fail (GTK_IS_TREE_VIEW (widget));
482 tree_view = GTK_TREE_VIEW (widget);
484 GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
486 tmp_list = tree_view->priv->children;
489 GtkTreeViewChild *child = tmp_list->data;
490 tmp_list = tmp_list->next;
492 if (GTK_WIDGET_VISIBLE (child->widget))
494 if (!GTK_WIDGET_MAPPED (child->widget))
495 gtk_widget_map (child->widget);
498 gdk_window_show (tree_view->priv->bin_window);
500 gtk_tree_view_map_buttons (tree_view);
502 gdk_window_show (widget->window);
506 gtk_tree_view_size_request_buttons (GtkTreeView *tree_view)
510 tree_view->priv->header_height = 1;
512 if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_MODEL_SETUP))
514 for (list = tree_view->priv->columns; list; list = list->next)
516 GtkRequisition requisition;
517 GtkTreeViewColumn *column;
521 gtk_widget_size_request (column->button, &requisition);
523 column->width = MAX (column->width, requisition.width);
524 tree_view->priv->header_height = MAX (tree_view->priv->header_height, requisition.height);
530 gtk_tree_view_size_request (GtkWidget *widget,
531 GtkRequisition *requisition)
533 GtkTreeView *tree_view;
536 g_return_if_fail (widget != NULL);
537 g_return_if_fail (GTK_IS_TREE_VIEW (widget));
539 tree_view = GTK_TREE_VIEW (widget);
541 requisition->width = 200;
542 requisition->height = 200;
544 tmp_list = tree_view->priv->children;
548 GtkTreeViewChild *child = tmp_list->data;
549 GtkRequisition child_requisition;
551 tmp_list = tmp_list->next;
553 if (GTK_WIDGET_VISIBLE (child->widget))
554 gtk_widget_size_request (child->widget, &child_requisition);
557 gtk_tree_view_size_request_buttons (tree_view);
561 gtk_tree_view_size_allocate_buttons (GtkWidget *widget)
563 GtkTreeView *tree_view;
566 GtkTreeViewColumn *column;
567 GtkAllocation allocation;
570 tree_view = GTK_TREE_VIEW (widget);
573 allocation.height = tree_view->priv->header_height;
575 for (last_column = g_list_last (tree_view->priv->columns);
576 last_column && !(GTK_TREE_VIEW_COLUMN (last_column->data)->visible);
577 last_column = last_column->prev)
580 if (last_column == NULL)
583 for (list = tree_view->priv->columns; list != last_column; list = list->next)
587 if (!column->visible)
590 allocation.x = width;
591 allocation.width = column->width;
592 width += column->width;
593 gtk_widget_size_allocate (column->button, &allocation);
596 gdk_window_move_resize (column->window,
597 width - TREE_VIEW_DRAG_WIDTH/2, allocation.y,
598 TREE_VIEW_DRAG_WIDTH, allocation.height);
601 allocation.x = width;
602 allocation.width = MAX (widget->allocation.width, tree_view->priv->width) - width;
603 gtk_widget_size_allocate (column->button, &allocation);
605 gdk_window_move_resize (column->window,
606 allocation.x + allocation.width - TREE_VIEW_DRAG_WIDTH/2,
608 TREE_VIEW_DRAG_WIDTH, allocation.height);
612 gtk_tree_view_size_allocate (GtkWidget *widget,
613 GtkAllocation *allocation)
616 GtkTreeView *tree_view;
618 g_return_if_fail (widget != NULL);
619 g_return_if_fail (GTK_IS_TREE_VIEW (widget));
621 widget->allocation = *allocation;
623 tree_view = GTK_TREE_VIEW (widget);
625 tmp_list = tree_view->priv->children;
629 GtkAllocation allocation;
630 GtkRequisition requisition;
632 GtkTreeViewChild *child = tmp_list->data;
633 tmp_list = tmp_list->next;
635 allocation.x = child->x;
636 allocation.y = child->y;
637 gtk_widget_get_child_requisition (child->widget, &requisition);
638 allocation.width = requisition.width;
639 allocation.height = requisition.height;
641 gtk_widget_size_allocate (child->widget, &allocation);
644 if (GTK_WIDGET_REALIZED (widget))
646 gdk_window_move_resize (widget->window,
647 allocation->x, allocation->y,
648 allocation->width, allocation->height);
649 gdk_window_move_resize (tree_view->priv->header_window,
651 MAX (tree_view->priv->width, allocation->width),
652 tree_view->priv->header_height);
655 /* FIXME I don't think the invariant that the model must be setup
656 * before touching the buttons is maintained in most of the
657 * rest of the code, e.g. in realize, so something is wrong
659 if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_MODEL_SETUP))
660 gtk_tree_view_size_allocate_buttons (widget);
662 tree_view->priv->hadjustment->page_size = allocation->width;
663 tree_view->priv->hadjustment->page_increment = allocation->width / 2;
664 tree_view->priv->hadjustment->lower = 0;
665 tree_view->priv->hadjustment->upper = tree_view->priv->width;
666 if (tree_view->priv->hadjustment->value + allocation->width > tree_view->priv->width)
667 tree_view->priv->hadjustment->value = MAX (tree_view->priv->width - allocation->width, 0);
668 gtk_signal_emit_by_name (GTK_OBJECT (tree_view->priv->hadjustment), "changed");
670 tree_view->priv->vadjustment->page_size = allocation->height - TREE_VIEW_HEADER_HEIGHT (tree_view);
671 tree_view->priv->vadjustment->page_increment = (allocation->height - TREE_VIEW_HEADER_HEIGHT (tree_view)) / 2;
672 tree_view->priv->vadjustment->lower = 0;
673 tree_view->priv->vadjustment->upper = tree_view->priv->height;
674 if (tree_view->priv->vadjustment->value + allocation->height > tree_view->priv->height)
675 gtk_adjustment_set_value (tree_view->priv->vadjustment,
676 (gfloat) MAX (tree_view->priv->height - allocation->height, 0));
677 gtk_signal_emit_by_name (GTK_OBJECT (tree_view->priv->vadjustment), "changed");
680 /* Warning: Very scary function.
681 * Modify at your own risk
684 gtk_tree_view_bin_expose (GtkWidget *widget,
685 GdkEventExpose *event)
687 GtkTreeView *tree_view;
691 GtkRBNode *node, *last_node = NULL;
692 GtkRBNode *cursor = NULL;
693 GtkRBTree *cursor_tree = NULL, *last_tree = NULL;
695 GtkCellRenderer *cell;
697 gint y_offset, x_offset, cell_offset;
700 GdkRectangle background_area;
701 GdkRectangle cell_area;
703 gboolean last_selected;
705 g_return_val_if_fail (widget != NULL, FALSE);
706 g_return_val_if_fail (GTK_IS_TREE_VIEW (widget), FALSE);
708 tree_view = GTK_TREE_VIEW (widget);
710 if (tree_view->priv->tree == NULL)
713 gtk_tree_view_check_dirty (GTK_TREE_VIEW (widget));
714 /* we want to account for a potential HEADER offset.
715 * That is, if the header exists, we want to offset our event by its
716 * height to find the right node.
718 new_y = (event->area.y<TREE_VIEW_HEADER_HEIGHT (tree_view))?TREE_VIEW_HEADER_HEIGHT (tree_view):event->area.y;
719 y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree,
720 new_y - TREE_VIEW_HEADER_HEIGHT (tree_view),
722 &node) + new_y - event->area.y;
726 /* See if the last node was selected */
727 _gtk_rbtree_prev_full (tree, node, &last_tree, &last_node);
728 last_selected = (last_node && GTK_RBNODE_FLAG_SET (last_node, GTK_RBNODE_IS_SELECTED));
730 /* find the path for the node */
731 path = _gtk_tree_view_find_path ((GtkTreeView *)widget,
734 gtk_tree_model_get_iter (tree_view->priv->model,
737 depth = gtk_tree_path_get_depth (path);
738 gtk_tree_path_free (path);
740 if (tree_view->priv->cursor)
741 _gtk_tree_view_find_node (tree_view, tree_view->priv->cursor, &cursor_tree, &cursor);
743 /* Actually process the expose event. To do this, we want to
744 * start at the first node of the event, and walk the tree in
745 * order, drawing each successive node.
750 /* Need to think about this more.
751 if (tree_view->priv->show_expanders)
752 max_height = MAX (TREE_VIEW_EXPANDER_MIN_HEIGHT, GTK_RBNODE_GET_HEIGHT (node));
755 max_height = GTK_RBNODE_GET_HEIGHT (node);
757 x_offset = -event->area.x;
760 background_area.y = y_offset + event->area.y + TREE_VIEW_VERTICAL_SEPARATOR;
761 background_area.height = max_height - TREE_VIEW_VERTICAL_SEPARATOR;
764 if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PRELIT))
765 flags |= GTK_CELL_RENDERER_PRELIT;
767 if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
769 flags |= GTK_CELL_RENDERER_SELECTED;
771 /* Draw the selection */
772 gdk_draw_rectangle (event->window,
773 GTK_WIDGET (tree_view)->style->bg_gc [GTK_STATE_SELECTED],
776 background_area.y - (last_selected?TREE_VIEW_VERTICAL_SEPARATOR:0),
778 background_area.height + (last_selected?TREE_VIEW_VERTICAL_SEPARATOR:0));
779 last_selected = TRUE;
783 last_selected = FALSE;
786 for (i = 0, list = tree_view->priv->columns; i < tree_view->priv->n_columns; i++, list = list->next)
788 GtkTreeViewColumn *column = list->data;
790 if (!column->visible)
794 gtk_tree_view_column_set_cell_data (column,
795 tree_view->priv->model,
798 background_area.x = cell_offset;
799 background_area.width = TREE_VIEW_COLUMN_WIDTH (column);
800 if (i == 0 && TREE_VIEW_DRAW_EXPANDERS(tree_view))
802 cell_area = background_area;
803 cell_area.x += depth*tree_view->priv->tab_offset;
804 cell_area.width -= depth*tree_view->priv->tab_offset;
805 gtk_cell_renderer_render (cell,
812 if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT)
815 gdk_window_get_pointer (tree_view->priv->bin_window, &x, &y, 0);
816 gtk_tree_view_draw_arrow (GTK_TREE_VIEW (widget),
818 event->area.y + y_offset,
824 cell_area = background_area;
825 gtk_cell_renderer_render (cell,
833 cell_offset += TREE_VIEW_COLUMN_WIDTH (column);
836 if (node == cursor &&
837 GTK_WIDGET_HAS_FOCUS (widget))
838 gtk_tree_view_draw_focus (widget);
840 y_offset += max_height;
843 GtkTreeIter parent = iter;
846 tree = node->children;
848 while (node->left != tree->nil)
850 has_child = gtk_tree_model_iter_children (tree_view->priv->model,
853 cell = gtk_tree_view_get_column (tree_view, 0)->cell;
857 TREE_VIEW_INTERNAL_ASSERT (has_child, FALSE);
861 gboolean done = FALSE;
864 node = _gtk_rbtree_next (tree, node);
867 gboolean has_next = gtk_tree_model_iter_next (tree_view->priv->model, &iter);
868 cell = gtk_tree_view_get_column (tree_view, 0)->cell;
872 TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
876 GtkTreeIter parent_iter = iter;
879 node = tree->parent_node;
880 tree = tree->parent_tree;
882 /* we've run out of tree. It's okay to return though, as
883 * we'd only break out of the while loop below. */
885 has_parent = gtk_tree_model_iter_parent (tree_view->priv->model,
891 TREE_VIEW_INTERNAL_ASSERT (has_parent, FALSE);
897 while (y_offset < event->area.height);
903 gtk_tree_view_expose (GtkWidget *widget,
904 GdkEventExpose *event)
906 GtkTreeView *tree_view;
908 g_return_val_if_fail (widget != NULL, FALSE);
909 g_return_val_if_fail (GTK_IS_TREE_VIEW (widget), FALSE);
911 tree_view = GTK_TREE_VIEW (widget);
913 if (event->window == tree_view->priv->bin_window)
914 return gtk_tree_view_bin_expose (widget, event);
920 gtk_tree_view_motion (GtkWidget *widget,
921 GdkEventMotion *event)
923 GtkTreeView *tree_view;
929 g_return_val_if_fail (widget != NULL, FALSE);
930 g_return_val_if_fail (GTK_IS_TREE_VIEW (widget), FALSE);
932 tree_view = GTK_TREE_VIEW (widget);
934 if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_RESIZE))
939 if (event->is_hint || event->window != widget->window)
940 gtk_widget_get_pointer (widget, &x, NULL);
944 new_width = gtk_tree_view_new_column_width (GTK_TREE_VIEW (widget), tree_view->priv->drag_pos, &x);
945 if (x != tree_view->priv->x_drag)
947 gtk_tree_view_column_set_width (gtk_tree_view_get_column (GTK_TREE_VIEW (widget), tree_view->priv->drag_pos), new_width);
950 /* FIXME: Do we need to scroll */
951 _gtk_tree_view_set_size (GTK_TREE_VIEW (widget), -1, tree_view->priv->height);
955 /* Sanity check it */
956 if (event->window != tree_view->priv->bin_window)
958 if (tree_view->priv->tree == NULL)
961 if (tree_view->priv->prelight_node != NULL)
963 if ((((gint) event->y - TREE_VIEW_HEADER_HEIGHT (tree_view) < tree_view->priv->prelight_offset) ||
964 ((gint) event->y - TREE_VIEW_HEADER_HEIGHT (tree_view) >=
965 (tree_view->priv->prelight_offset + GTK_RBNODE_GET_HEIGHT (tree_view->priv->prelight_node))) ||
966 ((gint) event->x > tree_view->priv->tab_offset)))
967 /* We need to unprelight the old one. */
969 if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_ARROW_PRELIT))
971 GTK_RBNODE_UNSET_FLAG (tree_view->priv->prelight_node, GTK_RBNODE_IS_PRELIT);
972 gtk_tree_view_draw_arrow (GTK_TREE_VIEW (widget),
973 tree_view->priv->prelight_node,
974 tree_view->priv->prelight_offset,
977 GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_ARROW_PRELIT);
980 GTK_RBNODE_UNSET_FLAG (tree_view->priv->prelight_node, GTK_RBNODE_IS_PRELIT);
981 tree_view->priv->prelight_node = NULL;
982 tree_view->priv->prelight_tree = NULL;
983 tree_view->priv->prelight_offset = 0;
987 new_y = ((gint)event->y<TREE_VIEW_HEADER_HEIGHT (tree_view))?TREE_VIEW_HEADER_HEIGHT (tree_view):(gint)event->y;
988 y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree, new_y - TREE_VIEW_HEADER_HEIGHT (tree_view),
990 &node) + new_y - (gint)event->y;
995 /* If we are currently pressing down a button, we don't want to prelight anything else. */
996 if ((tree_view->priv->button_pressed_node != NULL) &&
997 (tree_view->priv->button_pressed_node != node))
1000 /* Do we want to prelight a tab? */
1001 GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_ARROW_PRELIT);
1002 if (event->x <= tree_view->priv->tab_offset &&
1004 ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT))
1006 tree_view->priv->prelight_offset = event->y+y_offset;
1007 GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_ARROW_PRELIT);
1010 tree_view->priv->prelight_node = node;
1011 tree_view->priv->prelight_tree = tree;
1012 tree_view->priv->prelight_offset = event->y+y_offset;
1014 GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PRELIT);
1016 gtk_widget_queue_draw (widget);
1021 /* FIXME Is this function necessary? Can I get an enter_notify event
1022 * w/o either an expose event or a mouse motion event?
1025 gtk_tree_view_enter_notify (GtkWidget *widget,
1026 GdkEventCrossing *event)
1028 GtkTreeView *tree_view;
1034 g_return_val_if_fail (widget != NULL, FALSE);
1035 g_return_val_if_fail (GTK_IS_TREE_VIEW (widget), FALSE);
1037 tree_view = GTK_TREE_VIEW (widget);
1039 /* Sanity check it */
1040 if (event->window != tree_view->priv->bin_window)
1042 if (tree_view->priv->tree == NULL)
1045 if ((tree_view->priv->button_pressed_node != NULL) &&
1046 (tree_view->priv->button_pressed_node != node))
1049 /* find the node internally */
1050 new_y = ((gint)event->y<TREE_VIEW_HEADER_HEIGHT (tree_view))?TREE_VIEW_HEADER_HEIGHT (tree_view):(gint)event->y;
1051 y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree,
1052 new_y - TREE_VIEW_HEADER_HEIGHT (tree_view),
1054 &node) + new_y - (gint)event->y;
1059 /* Do we want to prelight a tab? */
1060 GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_ARROW_PRELIT);
1061 if (event->x <= tree_view->priv->tab_offset &&
1063 ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT))
1065 tree_view->priv->prelight_offset = event->y+y_offset;
1066 GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_ARROW_PRELIT);
1069 tree_view->priv->prelight_node = node;
1070 tree_view->priv->prelight_tree = tree;
1071 tree_view->priv->prelight_offset = event->y+y_offset;
1073 GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PRELIT);
1075 gtk_widget_queue_draw (widget);
1081 gtk_tree_view_leave_notify (GtkWidget *widget,
1082 GdkEventCrossing *event)
1084 GtkTreeView *tree_view;
1086 g_return_val_if_fail (widget != NULL, FALSE);
1087 g_return_val_if_fail (GTK_IS_TREE_VIEW (widget), FALSE);
1089 tree_view = GTK_TREE_VIEW (widget);
1091 if (tree_view->priv->prelight_node != NULL)
1093 GTK_RBNODE_UNSET_FLAG (tree_view->priv->prelight_node, GTK_RBNODE_IS_PRELIT);
1094 tree_view->priv->prelight_node = NULL;
1095 tree_view->priv->prelight_tree = NULL;
1096 tree_view->priv->prelight_offset = 0;
1097 GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_ARROW_PRELIT);
1099 gtk_widget_queue_draw (widget);
1105 gtk_tree_view_button_press (GtkWidget *widget,
1106 GdkEventButton *event)
1108 GtkTreeView *tree_view;
1110 GtkTreeViewColumn *column;
1112 GdkRectangle background_area;
1113 GdkRectangle cell_area;
1115 g_return_val_if_fail (widget != NULL, FALSE);
1116 g_return_val_if_fail (GTK_IS_TREE_VIEW (widget), FALSE);
1117 g_return_val_if_fail (event != NULL, FALSE);
1119 tree_view = GTK_TREE_VIEW (widget);
1121 if (event->window == tree_view->priv->bin_window)
1131 if (!GTK_WIDGET_HAS_FOCUS (widget))
1132 gtk_widget_grab_focus (widget);
1133 GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS);
1134 /* are we in an arrow? */
1135 if (tree_view->priv->prelight_node != FALSE && GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_ARROW_PRELIT))
1137 if (event->button == 1)
1139 gtk_grab_add (widget);
1140 tree_view->priv->button_pressed_node = tree_view->priv->prelight_node;
1141 tree_view->priv->button_pressed_tree = tree_view->priv->prelight_tree;
1142 gtk_tree_view_draw_arrow (GTK_TREE_VIEW (widget),
1143 tree_view->priv->prelight_node,
1144 tree_view->priv->prelight_offset,
1151 /* find the node that was clicked */
1152 new_y = ((gint)event->y<TREE_VIEW_HEADER_HEIGHT (tree_view))?TREE_VIEW_HEADER_HEIGHT (tree_view):(gint)event->y;
1153 y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree,
1154 new_y - TREE_VIEW_HEADER_HEIGHT (tree_view),
1156 &node) + new_y - (gint)event->y;
1159 /* We clicked in dead space */
1162 /* Get the path and the node */
1163 path = _gtk_tree_view_find_path (tree_view, tree, node);
1164 depth = gtk_tree_path_get_depth (path);
1165 background_area.y = y_offset + event->y + TREE_VIEW_VERTICAL_SEPARATOR;
1166 background_area.height = GTK_RBNODE_GET_HEIGHT (node) - TREE_VIEW_VERTICAL_SEPARATOR;
1167 background_area.x = 0;
1168 /* Let the cell have a chance at selecting it. */
1170 for (i = 0, list = tree_view->priv->columns; i < tree_view->priv->n_columns; i++, list = list->next)
1172 GtkTreeViewColumn *column = list->data;
1173 GtkCellRenderer *cell;
1176 if (!column->visible)
1179 background_area.width = TREE_VIEW_COLUMN_WIDTH (column);
1180 if (i == 0 && TREE_VIEW_DRAW_EXPANDERS(tree_view))
1182 cell_area = background_area;
1183 cell_area.x += depth*tree_view->priv->tab_offset;
1184 cell_area.width -= depth*tree_view->priv->tab_offset;
1188 cell_area = background_area;
1191 cell = column->cell;
1193 if ((background_area.x > (gint) event->x) ||
1194 (background_area.y > (gint) event->y) ||
1195 (background_area.x + background_area.width <= (gint) event->x) ||
1196 (background_area.y + background_area.height <= (gint) event->y))
1198 background_area.x += background_area.width;
1202 gtk_tree_model_get_iter (tree_view->priv->model,
1205 gtk_tree_view_column_set_cell_data (column,
1206 tree_view->priv->model,
1209 path_string = gtk_tree_path_to_string (path);
1210 if (gtk_cell_renderer_event (cell,
1219 g_free (path_string);
1220 gtk_tree_path_free (path);
1225 g_free (path_string);
1229 /* Handle the selection */
1230 if (tree_view->priv->selection == NULL)
1231 tree_view->priv->selection =
1232 _gtk_tree_selection_new_with_tree_view (tree_view);
1234 _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
1239 gtk_tree_path_free (path);
1243 for (i = 0, list = tree_view->priv->columns; list; list = list->next, i++)
1245 column = list->data;
1246 if (event->window == column->window &&
1247 column->column_type == GTK_TREE_VIEW_COLUMN_RESIZEABLE &&
1252 if (gdk_pointer_grab (column->window, FALSE,
1253 GDK_POINTER_MOTION_HINT_MASK |
1254 GDK_BUTTON1_MOTION_MASK |
1255 GDK_BUTTON_RELEASE_MASK,
1256 NULL, NULL, event->time))
1259 gtk_grab_add (widget);
1260 GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_IN_COLUMN_RESIZE);
1262 /* block attached dnd signal handler */
1263 drag_data = gtk_object_get_data (GTK_OBJECT (widget), "gtk-site-data");
1265 gtk_signal_handler_block_by_data (GTK_OBJECT (widget), drag_data);
1267 if (!GTK_WIDGET_HAS_FOCUS (widget))
1268 gtk_widget_grab_focus (widget);
1270 tree_view->priv->drag_pos = i;
1271 tree_view->priv->x_drag = (column->button->allocation.x + column->button->allocation.width);
1278 gtk_tree_view_button_release (GtkWidget *widget,
1279 GdkEventButton *event)
1281 GtkTreeView *tree_view;
1283 g_return_val_if_fail (widget != NULL, FALSE);
1284 g_return_val_if_fail (GTK_IS_TREE_VIEW (widget), FALSE);
1285 g_return_val_if_fail (event != NULL, FALSE);
1287 tree_view = GTK_TREE_VIEW (widget);
1289 if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_RESIZE))
1296 i = tree_view->priv->drag_pos;
1297 tree_view->priv->drag_pos = -1;
1299 /* unblock attached dnd signal handler */
1300 drag_data = gtk_object_get_data (GTK_OBJECT (widget), "gtk-site-data");
1302 gtk_signal_handler_unblock_by_data (GTK_OBJECT (widget), drag_data);
1304 GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_IN_COLUMN_RESIZE);
1305 gtk_widget_get_pointer (widget, &x, NULL);
1306 gtk_grab_remove (widget);
1307 gdk_pointer_ungrab (event->time);
1309 width = gtk_tree_view_new_column_width (GTK_TREE_VIEW (widget), i, &x);
1310 gtk_tree_view_column_set_width (gtk_tree_view_get_column (GTK_TREE_VIEW (widget), i), width);
1314 if (tree_view->priv->button_pressed_node == NULL)
1317 if (event->button == 1)
1319 gtk_grab_remove (widget);
1320 if (tree_view->priv->button_pressed_node == tree_view->priv->prelight_node && GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_ARROW_PRELIT))
1325 /* Actually activate the node */
1326 if (tree_view->priv->button_pressed_node->children == NULL)
1329 path = _gtk_tree_view_find_path (GTK_TREE_VIEW (widget),
1330 tree_view->priv->button_pressed_tree,
1331 tree_view->priv->button_pressed_node);
1332 tree_view->priv->button_pressed_node->children = _gtk_rbtree_new ();
1333 tree_view->priv->button_pressed_node->children->parent_tree = tree_view->priv->button_pressed_tree;
1334 tree_view->priv->button_pressed_node->children->parent_node = tree_view->priv->button_pressed_node;
1335 gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
1336 gtk_tree_model_iter_children (tree_view->priv->model, &child, &iter);
1338 gtk_tree_view_build_tree (tree_view,
1339 tree_view->priv->button_pressed_node->children,
1341 gtk_tree_path_get_depth (path) + 1,
1343 GTK_WIDGET_REALIZED (widget));
1347 path = _gtk_tree_view_find_path (GTK_TREE_VIEW (widget),
1348 tree_view->priv->button_pressed_node->children,
1349 tree_view->priv->button_pressed_node->children->root);
1350 gtk_tree_model_get_iter (tree_view->priv->model,
1354 gtk_tree_view_discover_dirty (GTK_TREE_VIEW (widget),
1355 tree_view->priv->button_pressed_node->children,
1357 gtk_tree_path_get_depth (path));
1358 _gtk_rbtree_remove (tree_view->priv->button_pressed_node->children);
1360 gtk_tree_path_free (path);
1362 _gtk_tree_view_set_size (GTK_TREE_VIEW (widget), -1, -1);
1365 tree_view->priv->button_pressed_node = NULL;
1373 gtk_tree_view_draw_focus (GtkWidget *widget)
1375 GtkTreeView *tree_view;
1376 GtkRBTree *cursor_tree = NULL;
1377 GtkRBNode *cursor = NULL;
1379 g_return_if_fail (widget != NULL);
1380 g_return_if_fail (GTK_IS_TREE_VIEW (widget));
1382 tree_view = GTK_TREE_VIEW (widget);
1384 if (! GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS))
1386 if (tree_view->priv->cursor == NULL)
1389 _gtk_tree_view_find_node (tree_view, tree_view->priv->cursor, &cursor_tree, &cursor);
1393 /* FIXME need a style function appropriate for this */
1394 gdk_draw_rectangle (tree_view->priv->bin_window,
1395 widget->style->fg_gc[GTK_STATE_NORMAL],
1398 _gtk_rbtree_node_find_offset (cursor_tree, cursor) + TREE_VIEW_HEADER_HEIGHT (tree_view),
1399 (gint) MAX (tree_view->priv->width, tree_view->priv->hadjustment->upper),
1400 GTK_RBNODE_GET_HEIGHT (cursor));
1405 gtk_tree_view_focus_in (GtkWidget *widget,
1406 GdkEventFocus *event)
1408 GtkTreeView *tree_view;
1410 g_return_val_if_fail (widget != NULL, FALSE);
1411 g_return_val_if_fail (GTK_IS_TREE_VIEW (widget), FALSE);
1412 g_return_val_if_fail (event != NULL, FALSE);
1414 tree_view = GTK_TREE_VIEW (widget);
1416 GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS);
1418 /* FIXME don't redraw so much */
1419 gtk_widget_queue_draw (widget);
1426 gtk_tree_view_focus_out (GtkWidget *widget,
1427 GdkEventFocus *event)
1429 g_return_val_if_fail (widget != NULL, FALSE);
1430 g_return_val_if_fail (GTK_IS_TREE_VIEW (widget), FALSE);
1431 g_return_val_if_fail (event != NULL, FALSE);
1433 GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS);
1435 /* FIXME don't redraw so much */
1436 gtk_widget_queue_draw (widget);
1441 /* FIXME: It would be neat to someday make the headers a seperate widget that
1442 * can be shared between various apps. Wishful thinking, though...
1444 /* Returns TRUE if the focus is within the headers, after the focus operation is
1448 gtk_tree_view_header_focus (GtkTreeView *tree_view,
1449 GtkDirectionType dir)
1451 GtkWidget *focus_child;
1452 GtkContainer *container;
1454 GList *last_column, *first_column;
1457 if (! GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE))
1460 focus_child = GTK_CONTAINER (tree_view)->focus_child;
1461 container = GTK_CONTAINER (tree_view);
1463 for (last_column = g_list_last (tree_view->priv->columns);
1465 !(GTK_TREE_VIEW_COLUMN (last_column->data)->visible) &&
1466 GTK_WIDGET_CAN_FOCUS (GTK_TREE_VIEW_COLUMN (last_column->data)->button);
1467 last_column = last_column->prev)
1470 for (first_column = tree_view->priv->columns;
1472 !(GTK_TREE_VIEW_COLUMN (first_column->data)->visible) &&
1473 GTK_WIDGET_CAN_FOCUS (GTK_TREE_VIEW_COLUMN (first_column->data)->button);
1474 first_column = first_column->next)
1477 /* no headers are visible, or are focussable. We can't focus in or out.
1478 * I wonder if focussable is a real word...
1480 if (last_column == NULL)
1483 /* First thing we want to handle is entering and leaving the headers.
1487 case GTK_DIR_TAB_BACKWARD:
1490 focus_child = GTK_TREE_VIEW_COLUMN (last_column->data)->button;
1491 gtk_widget_grab_focus (focus_child);
1494 if (focus_child == GTK_TREE_VIEW_COLUMN (first_column->data)->button)
1501 case GTK_DIR_TAB_FORWARD:
1504 focus_child = GTK_TREE_VIEW_COLUMN (first_column->data)->button;
1505 gtk_widget_grab_focus (focus_child);
1508 if (focus_child == GTK_TREE_VIEW_COLUMN (last_column->data)->button)
1518 focus_child = GTK_TREE_VIEW_COLUMN (last_column->data)->button;
1519 gtk_widget_grab_focus (focus_child);
1522 if (focus_child == GTK_TREE_VIEW_COLUMN (first_column->data)->button)
1532 focus_child = GTK_TREE_VIEW_COLUMN (first_column->data)->button;
1533 gtk_widget_grab_focus (focus_child);
1536 if (focus_child == GTK_TREE_VIEW_COLUMN (last_column->data)->button)
1546 focus_child = GTK_TREE_VIEW_COLUMN (first_column->data)->button;
1547 gtk_widget_grab_focus (focus_child);
1558 focus_child = GTK_TREE_VIEW_COLUMN (first_column->data)->button;
1559 gtk_widget_grab_focus (focus_child);
1568 /* We need to move the focus to the next button. */
1571 for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
1572 if (GTK_TREE_VIEW_COLUMN (tmp_list->data)->button == focus_child)
1574 if (gtk_container_focus (GTK_CONTAINER (GTK_TREE_VIEW_COLUMN (tmp_list->data)->button), dir))
1576 /* The focus moves inside the button. */
1577 /* This is probably a great example of bad UI */
1583 /* We need to move the focus among the row of buttons. */
1586 GtkTreeViewColumn *column;
1588 if (dir == GTK_DIR_RIGHT || dir == GTK_DIR_TAB_FORWARD)
1589 tmp_list = tmp_list->next;
1591 tmp_list = tmp_list->prev;
1593 if (tmp_list == NULL)
1595 g_warning ("Internal button not found");
1598 column = tmp_list->data;
1599 if (column->button &&
1601 GTK_WIDGET_CAN_FOCUS (column->button))
1603 focus_child = column->button;
1604 gtk_widget_grab_focus (column->button);
1611 /* if focus child is non-null, we assume it's been set to the current focus child
1615 /* If the following isn't true, then the view is smaller then the scrollpane.
1617 if ((focus_child->allocation.x + focus_child->allocation.width) <=
1618 (tree_view->priv->hadjustment->upper))
1620 /* Scroll to the button, if needed */
1621 if ((tree_view->priv->hadjustment->value + tree_view->priv->hadjustment->page_size) <
1622 (focus_child->allocation.x + focus_child->allocation.width))
1623 gtk_adjustment_set_value (tree_view->priv->hadjustment,
1624 focus_child->allocation.x + focus_child->allocation.width -
1625 tree_view->priv->hadjustment->page_size);
1626 else if (tree_view->priv->hadjustment->value > focus_child->allocation.x)
1627 gtk_adjustment_set_value (tree_view->priv->hadjustment,
1628 focus_child->allocation.x);
1632 return (focus_child != NULL);
1635 /* WARNING: Scary function */
1637 gtk_tree_view_focus (GtkContainer *container,
1638 GtkDirectionType direction)
1640 GtkTreeView *tree_view;
1641 GtkWidget *focus_child;
1643 GtkRBTree *cursor_tree;
1644 GtkRBNode *cursor_node;
1646 g_return_val_if_fail (container != NULL, FALSE);
1647 g_return_val_if_fail (GTK_IS_TREE_VIEW (container), FALSE);
1648 g_return_val_if_fail (GTK_WIDGET_VISIBLE (container), FALSE);
1650 tree_view = GTK_TREE_VIEW (container);
1652 if (!GTK_WIDGET_IS_SENSITIVE (container))
1654 if (tree_view->priv->tree == NULL)
1657 focus_child = container->focus_child;
1659 /* Case 1. Headers have focus. */
1665 case GTK_DIR_TAB_BACKWARD:
1666 return (gtk_tree_view_header_focus (tree_view, direction));
1669 case GTK_DIR_TAB_FORWARD:
1672 if (direction != GTK_DIR_DOWN)
1674 if (gtk_tree_view_header_focus (tree_view, direction))
1677 GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS);
1678 gtk_widget_grab_focus (GTK_WIDGET (container));
1680 if (tree_view->priv->selection == NULL)
1681 tree_view->priv->selection =
1682 _gtk_tree_selection_new_with_tree_view (tree_view);
1684 /* if there is no keyboard focus yet, we select the first node
1686 if (tree_view->priv->cursor == NULL)
1687 tree_view->priv->cursor = gtk_tree_path_new_root ();
1688 if (tree_view->priv->cursor)
1689 gtk_tree_selection_select_path (tree_view->priv->selection,
1690 tree_view->priv->cursor);
1691 /* FIXME make this more efficient */
1692 gtk_widget_queue_draw (GTK_WIDGET (tree_view));
1697 /* Case 2. We don't have focus at all. */
1698 if (!GTK_WIDGET_HAS_FOCUS (container))
1700 if ((direction == GTK_DIR_TAB_FORWARD) ||
1701 (direction == GTK_DIR_RIGHT) ||
1702 (direction == GTK_DIR_DOWN))
1704 if (gtk_tree_view_header_focus (tree_view, direction))
1708 /* The headers didn't want the focus, so we take it. */
1709 GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS);
1710 gtk_widget_grab_focus (GTK_WIDGET (container));
1712 if (tree_view->priv->selection == NULL)
1713 tree_view->priv->selection =
1714 _gtk_tree_selection_new_with_tree_view (tree_view);
1716 if (tree_view->priv->cursor == NULL)
1717 tree_view->priv->cursor = gtk_tree_path_new_root ();
1719 if (tree_view->priv->cursor)
1720 gtk_tree_selection_select_path (tree_view->priv->selection,
1721 tree_view->priv->cursor);
1722 /* FIXME make this more efficient */
1723 gtk_widget_queue_draw (GTK_WIDGET (tree_view));
1727 /* Case 3. We have focus already, but no cursor. We pick the first one
1728 * and run with it. */
1729 if (tree_view->priv->cursor == NULL)
1731 /* We lost our cursor somehow. Arbitrarily select the first node, and
1734 tree_view->priv->cursor = gtk_tree_path_new_root ();
1736 if (tree_view->priv->cursor)
1737 gtk_tree_selection_select_path (tree_view->priv->selection,
1738 tree_view->priv->cursor);
1739 gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment),
1741 /* FIXME make this more efficient */
1742 gtk_widget_queue_draw (GTK_WIDGET (tree_view));
1747 /* Case 3. We have focus already. Move the cursor. */
1748 if (direction == GTK_DIR_LEFT)
1751 val = tree_view->priv->hadjustment->value - tree_view->priv->hadjustment->page_size/2;
1752 val = MAX (val, 0.0);
1753 gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->hadjustment), val);
1754 gtk_widget_grab_focus (GTK_WIDGET (tree_view));
1757 if (direction == GTK_DIR_RIGHT)
1760 val = tree_view->priv->hadjustment->value + tree_view->priv->hadjustment->page_size/2;
1761 val = MIN (tree_view->priv->hadjustment->upper - tree_view->priv->hadjustment->page_size, val);
1762 gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->hadjustment), val);
1763 gtk_widget_grab_focus (GTK_WIDGET (tree_view));
1769 _gtk_tree_view_find_node (tree_view, tree_view->priv->cursor,
1774 case GTK_DIR_TAB_BACKWARD:
1776 _gtk_rbtree_prev_full (cursor_tree,
1781 case GTK_DIR_TAB_FORWARD:
1783 _gtk_rbtree_next_full (cursor_tree,
1794 GdkModifierType state = 0;
1796 event = gtk_get_current_event ();
1798 gdk_event_get_state (event, &state);
1801 gdk_event_free (event);
1802 gtk_tree_path_free (tree_view->priv->cursor);
1804 tree_view->priv->cursor = _gtk_tree_view_find_path (tree_view,
1807 if (tree_view->priv->cursor)
1808 _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
1811 tree_view->priv->cursor,
1813 gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
1814 gtk_widget_grab_focus (GTK_WIDGET (tree_view));
1815 /* FIXME make this more efficient */
1816 gtk_widget_queue_draw (GTK_WIDGET (tree_view));
1820 /* At this point, we've progressed beyond the edge of the rows. */
1822 if ((direction == GTK_DIR_LEFT) ||
1823 (direction == GTK_DIR_TAB_BACKWARD) ||
1824 (direction == GTK_DIR_UP))
1825 /* We can't go back anymore. Try the headers */
1826 return (gtk_tree_view_header_focus (tree_view, direction));
1828 /* we've reached the end of the tree. Go on. */
1835 gtk_tree_view_remove (GtkContainer *container,
1838 GtkTreeView *tree_view;
1839 GtkTreeViewChild *child = NULL;
1842 g_return_if_fail (container != NULL);
1843 g_return_if_fail (GTK_IS_TREE_VIEW (container));
1845 tree_view = GTK_TREE_VIEW (container);
1847 tmp_list = tree_view->priv->children;
1850 child = tmp_list->data;
1851 if (child->widget == widget)
1853 tmp_list = tmp_list->next;
1858 gtk_widget_unparent (widget);
1860 tree_view->priv->children = g_list_remove_link (tree_view->priv->children, tmp_list);
1861 g_list_free_1 (tmp_list);
1867 gtk_tree_view_forall (GtkContainer *container,
1868 gboolean include_internals,
1869 GtkCallback callback,
1870 gpointer callback_data)
1872 GtkTreeView *tree_view;
1873 GtkTreeViewChild *child = NULL;
1874 GtkTreeViewColumn *column;
1877 g_return_if_fail (container != NULL);
1878 g_return_if_fail (GTK_IS_TREE_VIEW (container));
1879 g_return_if_fail (callback != NULL);
1881 tree_view = GTK_TREE_VIEW (container);
1883 tmp_list = tree_view->priv->children;
1886 child = tmp_list->data;
1887 tmp_list = tmp_list->next;
1889 (* callback) (child->widget, callback_data);
1891 if (include_internals == FALSE)
1894 for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
1896 column = tmp_list->data;
1898 (* callback) (column->button, callback_data);
1902 /* TreeModel Callbacks
1906 gtk_tree_view_changed (GtkTreeModel *model,
1911 GtkTreeView *tree_view = (GtkTreeView *)data;
1915 gboolean dirty_marked;
1917 g_return_if_fail (path != NULL || iter != NULL);
1920 path = gtk_tree_model_get_path (model, iter);
1921 else if (iter == NULL)
1922 gtk_tree_model_get_iter (model, iter, path);
1924 if (_gtk_tree_view_find_node (tree_view,
1928 /* We aren't actually showing the node */
1931 dirty_marked = gtk_tree_view_discover_dirty_iter (tree_view,
1933 gtk_tree_path_get_depth (path),
1936 if (GTK_RBNODE_GET_HEIGHT (node) != height + TREE_VIEW_VERTICAL_SEPARATOR)
1938 _gtk_rbtree_node_set_height (tree, node, height + TREE_VIEW_VERTICAL_SEPARATOR);
1939 gtk_widget_queue_resize (GTK_WIDGET (data));
1943 gtk_widget_queue_resize (GTK_WIDGET (data));
1946 /* FIXME: just redraw the node */
1947 gtk_widget_queue_draw (GTK_WIDGET (data));
1952 gtk_tree_view_inserted (GtkTreeModel *model,
1957 GtkTreeView *tree_view = (GtkTreeView *) data;
1959 GtkRBTree *tmptree, *tree;
1960 GtkRBNode *tmpnode = NULL;
1965 tmptree = tree = tree_view->priv->tree;
1966 g_return_if_fail (path != NULL || iter != NULL);
1969 path = gtk_tree_model_get_path (model, iter);
1970 else if (iter == NULL)
1971 gtk_tree_model_get_iter (model, iter, path);
1973 depth = gtk_tree_path_get_depth (path);
1974 indices = gtk_tree_path_get_indices (path);
1976 /* First, find the parent tree */
1977 while (i < depth - 1)
1979 if (tmptree == NULL)
1981 /* We aren't showing the node */
1985 tmpnode = _gtk_rbtree_find_count (tmptree, indices[i] + 1);
1986 if (tmpnode == NULL)
1988 g_warning ("A node was inserted with a parent that's not in the tree.\n" \
1989 "This possibly means that a GtkTreeModel inserted a child node\n" \
1990 "before the parent was inserted.");
1993 else if (!GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_IS_PARENT))
1995 /* FIXME enforce correct behavior on model, probably */
1996 /* In theory, the model should have emitted child_toggled here. We
1997 * try to catch it anyway, just to be safe, in case the model hasn't.
1999 GtkTreePath *tmppath = _gtk_tree_view_find_path (tree_view,
2002 gtk_tree_view_child_toggled (model, tmppath, NULL, data);
2003 gtk_tree_path_free (tmppath);
2007 tmptree = tmpnode->children;
2015 /* next, update the selection */
2016 if (tree_view->priv->anchor)
2018 gint *select_indices = gtk_tree_path_get_indices (tree_view->priv->anchor);
2019 gint select_depth = gtk_tree_path_get_depth (tree_view->priv->anchor);
2021 for (i = 0; i < depth && i < select_depth; i++)
2023 if (indices[i] < select_indices[i])
2025 select_indices[i]++;
2028 else if (indices[i] > select_indices[i])
2030 else if (i == depth - 1)
2032 select_indices[i]++;
2039 gtk_tree_model_ref_iter (tree_view->priv->model, iter);
2040 max_height = gtk_tree_view_insert_iter_height (tree_view,
2044 if (indices[depth - 1] == 0)
2046 tmpnode = _gtk_rbtree_find_count (tree, 1);
2047 _gtk_rbtree_insert_before (tree, tmpnode, max_height);
2051 tmpnode = _gtk_rbtree_find_count (tree, indices[depth - 1]);
2052 _gtk_rbtree_insert_after (tree, tmpnode, max_height);
2055 _gtk_tree_view_set_size (tree_view, -1, tree_view->priv->height + max_height);
2059 gtk_tree_view_child_toggled (GtkTreeModel *model,
2064 GtkTreeView *tree_view = (GtkTreeView *)data;
2065 GtkTreeIter real_iter;
2070 g_return_if_fail (path != NULL || iter != NULL);
2076 path = gtk_tree_model_get_path (model, iter);
2077 else if (iter == NULL)
2078 gtk_tree_model_get_iter (model, &real_iter, path);
2080 if (_gtk_tree_view_find_node (tree_view,
2084 /* We aren't actually showing the node */
2087 has_child = gtk_tree_model_iter_has_child (model, &real_iter);
2090 if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT) == has_child)
2094 GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PARENT);
2096 GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_PARENT);
2098 if (has_child && GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IS_LIST))
2100 GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_IS_LIST);
2101 if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_SHOW_EXPANDERS))
2104 for (list = tree_view->priv->columns; list; list = list->next)
2105 if (GTK_TREE_VIEW_COLUMN (list->data)->visible)
2107 GTK_TREE_VIEW_COLUMN (list->data)->dirty = TRUE;
2111 gtk_widget_queue_resize (GTK_WIDGET (tree_view));
2115 /* FIXME: Just redraw the node */
2116 gtk_widget_queue_draw (GTK_WIDGET (tree_view));
2121 gtk_tree_view_deleted (GtkTreeModel *model,
2125 GtkTreeView *tree_view = (GtkTreeView *)data;
2130 g_return_if_fail (path != NULL);
2132 if (_gtk_tree_view_find_node (tree_view, path, &tree, &node))
2135 /* next, update the selection */
2136 if (tree_view->priv->anchor)
2139 gint depth = gtk_tree_path_get_depth (path);
2140 gint *indices = gtk_tree_path_get_indices (path);
2141 gint select_depth = gtk_tree_path_get_depth (tree_view->priv->anchor);
2142 gint *select_indices = gtk_tree_path_get_indices (tree_view->priv->anchor);
2144 if (gtk_tree_path_compare (path, tree_view->priv->anchor) == 0)
2146 if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED) &&
2147 tree_view->priv->selection)
2148 gtk_signal_emit_by_name (GTK_OBJECT (tree_view->priv->selection),
2149 "selection_changed");
2153 for (i = 0; i < depth && i < select_depth; i++)
2155 if (indices[i] < select_indices[i])
2157 select_indices[i] = MAX (select_indices[i], 0);
2160 else if (indices[i] > select_indices[i])
2162 else if (i == depth - 1)
2164 select_indices[i] = MAX (select_indices[i], 0);
2171 for (list = tree_view->priv->columns; list; list = list->next)
2172 if (((GtkTreeViewColumn *)list->data)->visible &&
2173 ((GtkTreeViewColumn *)list->data)->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
2174 ((GtkTreeViewColumn *)list->data)->dirty = TRUE;
2176 if (tree->root->count == 1)
2177 _gtk_rbtree_remove (tree);
2179 _gtk_rbtree_remove_node (tree, node);
2181 _gtk_tree_view_set_size (GTK_TREE_VIEW (data), -1, -1);
2184 /* Internal tree functions */
2186 gtk_tree_view_insert_iter_height (GtkTreeView *tree_view,
2191 GtkTreeViewColumn *column;
2192 GtkCellRenderer *cell;
2193 gboolean first = TRUE;
2195 gint max_height = 0;
2197 /* do stuff with node */
2198 for (list = tree_view->priv->columns; list; list = list->next)
2200 gint height = 0, width = 0;
2201 column = list->data;
2203 if (!column->visible)
2205 if (column->column_type == GTK_TREE_VIEW_COLUMN_FIXED)
2211 cell = column->cell;
2212 gtk_tree_view_column_set_cell_data (column, tree_view->priv->model, iter);
2214 gtk_cell_renderer_get_size (cell, GTK_WIDGET (tree_view), &width, &height);
2215 max_height = MAX (max_height, TREE_VIEW_VERTICAL_SEPARATOR + height);
2217 if (first == TRUE && TREE_VIEW_DRAW_EXPANDERS (tree_view))
2218 column->width = MAX (column->width, depth * tree_view->priv->tab_offset + width);
2220 column->width = MAX (column->width, width);
2229 gtk_tree_view_build_tree (GtkTreeView *tree_view,
2234 gboolean calc_bounds)
2236 GtkRBNode *temp = NULL;
2243 max_height = gtk_tree_view_insert_iter_height (tree_view,
2248 gtk_tree_model_ref_iter (tree_view->priv->model, iter);
2249 temp = _gtk_rbtree_insert_after (tree, temp, max_height);
2254 if (gtk_tree_model_iter_children (tree_view->priv->model, &child, iter))
2256 temp->children = _gtk_rbtree_new ();
2257 temp->children->parent_tree = tree;
2258 temp->children->parent_node = temp;
2259 gtk_tree_view_build_tree (tree_view, temp->children, &child, depth + 1, recurse, calc_bounds);
2262 if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter))
2264 if ((temp->flags>K_RBNODE_IS_PARENT) != GTK_RBNODE_IS_PARENT)
2265 temp->flags ^= GTK_RBNODE_IS_PARENT;
2266 GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_IS_LIST);
2269 while (gtk_tree_model_iter_next (tree_view->priv->model, iter));
2273 gtk_tree_view_calc_size (GtkTreeView *tree_view,
2278 GtkRBNode *temp = tree->root;
2280 GtkCellRenderer *cell;
2282 GtkTreeViewColumn *column;
2286 TREE_VIEW_INTERNAL_ASSERT_VOID (tree != NULL);
2288 while (temp->left != tree->nil)
2294 /* Do stuff with node */
2295 for (list = tree_view->priv->columns, i = 0; i < tree_view->priv->n_columns; list = list->next, i++)
2297 gint height = 0, width = 0;
2298 column = list->data;
2300 if (!column->visible)
2303 gtk_tree_view_column_set_cell_data (column, tree_view->priv->model, iter);
2304 cell = column->cell;
2305 gtk_cell_renderer_get_size (cell, GTK_WIDGET (tree_view), &width, &height);
2306 max_height = MAX (max_height, TREE_VIEW_VERTICAL_SEPARATOR + height);
2308 /* FIXME: I'm getting the width of all nodes here. )-: */
2309 if (column->dirty == FALSE || column->column_type == GTK_TREE_VIEW_COLUMN_FIXED)
2312 if (i == 0 && TREE_VIEW_DRAW_EXPANDERS (tree_view))
2313 column->width = MAX (column->width, depth * tree_view->priv->tab_offset + width);
2315 column->width = MAX (column->width, width);
2317 _gtk_rbtree_node_set_height (tree, temp, max_height);
2318 if (temp->children != NULL &&
2319 gtk_tree_model_iter_children (tree_view->priv->model, &child, iter))
2320 gtk_tree_view_calc_size (tree_view, temp->children, &child, depth + 1);
2321 temp = _gtk_rbtree_next (tree, temp);
2323 while (gtk_tree_model_iter_next (tree_view->priv->model, iter));
2327 gtk_tree_view_discover_dirty_iter (GtkTreeView *tree_view,
2332 GtkCellRenderer *cell;
2333 GtkTreeViewColumn *column;
2336 gint retval = FALSE;
2342 for (i = 0, list = tree_view->priv->columns; list; list = list->next, i++)
2345 column = list->data;
2346 if (column->dirty == TRUE || column->column_type == GTK_TREE_VIEW_COLUMN_FIXED)
2348 if (!column->visible)
2351 cell = column->cell;
2352 gtk_tree_view_column_set_cell_data (column, tree_view->priv->model, iter);
2356 gtk_cell_renderer_get_size (cell, GTK_WIDGET (tree_view), &width, &tmpheight);
2357 *height = MAX (*height, tmpheight);
2361 gtk_cell_renderer_get_size (cell, GTK_WIDGET (tree_view), &width, NULL);
2363 if (i == 0 && TREE_VIEW_DRAW_EXPANDERS (tree_view))
2365 if (depth * tree_view->priv->tab_offset + width > column->width)
2367 column->dirty = TRUE;
2373 if (width > column->width)
2375 column->dirty = TRUE;
2385 gtk_tree_view_discover_dirty (GtkTreeView *tree_view,
2390 GtkRBNode *temp = tree->root;
2391 GtkTreeViewColumn *column;
2394 gboolean is_all_dirty;
2396 TREE_VIEW_INTERNAL_ASSERT_VOID (tree != NULL);
2398 while (temp->left != tree->nil)
2403 is_all_dirty = TRUE;
2404 for (list = tree_view->priv->columns; list; list = list->next)
2406 column = list->data;
2407 if (column->dirty == FALSE)
2409 is_all_dirty = FALSE;
2417 gtk_tree_view_discover_dirty_iter (tree_view,
2421 if (gtk_tree_model_iter_children (tree_view->priv->model, &child, iter) &&
2422 temp->children != NULL)
2423 gtk_tree_view_discover_dirty (tree_view, temp->children, &child, depth + 1);
2424 temp = _gtk_rbtree_next (tree, temp);
2426 while (gtk_tree_model_iter_next (tree_view->priv->model, iter));
2431 gtk_tree_view_check_dirty (GtkTreeView *tree_view)
2434 gboolean dirty = FALSE;
2436 GtkTreeViewColumn *column;
2438 for (list = tree_view->priv->columns; list; list = list->next)
2440 column = list->data;
2444 if (column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
2446 column->width = column->button->requisition.width;
2453 path = gtk_tree_path_new_root ();
2458 gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
2459 gtk_tree_path_free (path);
2460 gtk_tree_view_calc_size (tree_view, tree_view->priv->tree, &iter, 1);
2461 _gtk_tree_view_set_size (tree_view, -1, -1);
2464 for (list = tree_view->priv->columns; list; list = list->next)
2466 column = list->data;
2467 column->dirty = FALSE;
2472 gtk_tree_view_create_button (GtkTreeView *tree_view,
2476 GtkTreeViewColumn *column;
2478 column = g_list_nth (tree_view->priv->columns, i)->data;
2479 gtk_widget_push_composite_child ();
2480 button = column->button = gtk_button_new ();
2481 gtk_widget_pop_composite_child ();
2483 gtk_widget_set_parent (button, GTK_WIDGET (tree_view));
2485 gtk_signal_connect (GTK_OBJECT (button), "clicked",
2486 (GtkSignalFunc) gtk_tree_view_button_clicked,
2487 (gpointer) tree_view);
2489 gtk_widget_show (button);
2493 gtk_tree_view_create_buttons (GtkTreeView *tree_view)
2495 GtkWidget *alignment;
2497 GtkRequisition requisition;
2499 GtkTreeViewColumn *column;
2502 for (list = tree_view->priv->columns, i = 0; list; list = list->next, i++)
2504 column = list->data;
2506 if (column->button != NULL)
2509 gtk_tree_view_create_button (tree_view, i);
2510 switch (column->justification)
2512 case GTK_JUSTIFY_LEFT:
2513 alignment = gtk_alignment_new (0.0, 0.5, 0.0, 0.0);
2515 case GTK_JUSTIFY_RIGHT:
2516 alignment = gtk_alignment_new (1.0, 0.5, 0.0, 0.0);
2518 case GTK_JUSTIFY_CENTER:
2519 alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
2521 case GTK_JUSTIFY_FILL:
2523 alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
2526 label = gtk_label_new (column->title);
2528 gtk_container_add (GTK_CONTAINER (alignment), label);
2529 gtk_container_add (GTK_CONTAINER (column->button), alignment);
2531 gtk_widget_show (label);
2532 gtk_widget_show (alignment);
2535 gtk_tree_view_size_request_buttons (tree_view);
2537 if (GTK_WIDGET_REALIZED (tree_view))
2538 gtk_tree_view_realize_buttons (tree_view);
2540 if (GTK_WIDGET_MAPPED (tree_view))
2541 gtk_tree_view_map_buttons (tree_view);
2545 gtk_tree_view_button_clicked (GtkWidget *widget,
2549 GtkTreeView *tree_view;
2551 g_return_if_fail (widget != NULL);
2552 g_return_if_fail (GTK_IS_TREE_VIEW (data));
2554 tree_view = GTK_TREE_VIEW (data);
2556 /* find the column whose button was pressed */
2557 for (list = tree_view->priv->columns; list; list = list->next)
2558 if (GTK_TREE_VIEW_COLUMN (list->data)->button == widget)
2562 gtk_tree_view_column_clicked (GTK_TREE_VIEW_COLUMN (list->data));
2565 /* Make sure the node is visible vertically */
2567 gtk_tree_view_clamp_node_visible (GtkTreeView *tree_view,
2573 offset = _gtk_rbtree_node_find_offset (tree, node);
2575 /* we reverse the order, b/c in the unusual case of the
2576 * node's height being taller then the visible area, we'd rather
2577 * have the node flush to the top
2579 if (offset + GTK_RBNODE_GET_HEIGHT (node) >
2580 tree_view->priv->vadjustment->value + tree_view->priv->vadjustment->page_size)
2581 gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment),
2582 offset + GTK_RBNODE_GET_HEIGHT (node) -
2583 tree_view->priv->vadjustment->page_size);
2584 if (offset < tree_view->priv->vadjustment->value)
2585 gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment),
2589 /* This function could be more efficient.
2590 * I'll optimize it if profiling seems to imply that
2594 _gtk_tree_view_find_path (GtkTreeView *tree_view,
2599 GtkRBTree *tmp_tree;
2600 GtkRBNode *tmp_node, *last;
2603 path = gtk_tree_path_new ();
2605 g_return_val_if_fail (node != NULL, path);
2606 g_return_val_if_fail (node != tree->nil, path);
2608 count = 1 + node->left->count;
2611 tmp_node = node->parent;
2615 while (tmp_node != tmp_tree->nil)
2617 if (tmp_node->right == last)
2618 count += 1 + tmp_node->left->count;
2620 tmp_node = tmp_node->parent;
2622 gtk_tree_path_prepend_index (path, count - 1);
2623 last = tmp_tree->parent_node;
2624 tmp_tree = tmp_tree->parent_tree;
2627 count = 1 + last->left->count;
2628 tmp_node = last->parent;
2634 /* Returns whether or not it's a parent, or not */
2636 _gtk_tree_view_find_node (GtkTreeView *tree_view,
2641 GtkRBNode *tmpnode = NULL;
2642 GtkRBTree *tmptree = tree_view->priv->tree;
2643 gint *indices = gtk_tree_path_get_indices (path);
2644 gint depth = gtk_tree_path_get_depth (path);
2652 if (tmptree == NULL)
2658 tmpnode = _gtk_rbtree_find_count (tmptree, indices[i] + 1);
2665 tmptree = tmpnode->children;
2670 /* x and y are the mouse position
2673 gtk_tree_view_draw_arrow (GtkTreeView *tree_view,
2684 if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
2687 widget = GTK_WIDGET (tree_view);
2690 area.y = offset + TREE_VIEW_VERTICAL_SEPARATOR;
2691 area.width = tree_view->priv->tab_offset - 2;
2692 area.height = GTK_RBNODE_GET_HEIGHT (node) - TREE_VIEW_VERTICAL_SEPARATOR;
2694 if (node == tree_view->priv->button_pressed_node)
2696 if (x >= area.x && x <= (area.x + area.width) &&
2697 y >= area.y && y <= (area.y + area.height))
2698 state = GTK_STATE_ACTIVE;
2700 state = GTK_STATE_NORMAL;
2704 state = (node==tree_view->priv->prelight_node&>K_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_ARROW_PRELIT)?GTK_STATE_PRELIGHT:GTK_STATE_NORMAL);
2707 /* FIXME expander size should come from a style property */
2708 #define EXPANDER_SIZE 8
2709 gtk_paint_expander (widget->style,
2710 tree_view->priv->bin_window,
2716 (area.y + (area.height - EXPANDER_SIZE) / 2 - (area.height + 1) % 2),
2717 node->children != NULL);
2718 #undef EXPANDER_SIZE
2722 _gtk_tree_view_set_size (GtkTreeView *tree_view,
2727 GtkTreeViewColumn *column;
2730 if (width == tree_view->priv->width &&
2731 height == tree_view->priv->height)
2734 if (tree_view->priv->model == NULL)
2736 tree_view->priv->width = width;
2737 tree_view->priv->height = height;
2738 gtk_widget_queue_draw (GTK_WIDGET (tree_view));
2744 for (list = tree_view->priv->columns, i = 0; list; list = list->next, i++)
2746 column = list->data;
2747 if (!column->visible)
2749 width += TREE_VIEW_COLUMN_WIDTH (column);
2753 height = tree_view->priv->tree->root->offset + TREE_VIEW_VERTICAL_SEPARATOR;
2755 tree_view->priv->width = width;
2756 tree_view->priv->height = height;
2758 if (tree_view->priv->hadjustment->upper != tree_view->priv->width)
2760 tree_view->priv->hadjustment->upper = tree_view->priv->width;
2761 gtk_signal_emit_by_name (GTK_OBJECT (tree_view->priv->hadjustment), "changed");
2764 if (tree_view->priv->vadjustment->upper != tree_view->priv->height)
2766 tree_view->priv->vadjustment->upper = tree_view->priv->height;
2767 gtk_signal_emit_by_name (GTK_OBJECT (tree_view->priv->vadjustment), "changed");
2770 if (GTK_WIDGET_REALIZED (tree_view))
2772 gdk_window_resize (tree_view->priv->bin_window, MAX (width, GTK_WIDGET (tree_view)->allocation.width), height + TREE_VIEW_HEADER_HEIGHT (tree_view));
2773 gdk_window_resize (tree_view->priv->header_window, MAX (width, GTK_WIDGET (tree_view)->allocation.width), tree_view->priv->header_height);
2775 gtk_widget_queue_resize (GTK_WIDGET (tree_view));
2778 /* this function returns the new width of the column being resized given
2779 * the column and x position of the cursor; the x cursor position is passed
2780 * in as a pointer and automagicly corrected if it's beyond min/max limits
2783 gtk_tree_view_new_column_width (GtkTreeView *tree_view,
2787 GtkTreeViewColumn *column;
2790 /* first translate the x position from widget->window
2791 * to clist->clist_window
2794 column = g_list_nth (tree_view->priv->columns, i)->data;
2795 width = *x - column->button->allocation.x;
2797 /* Clamp down the value */
2798 if (column->min_width == -1)
2799 width = MAX (column->button->requisition.width,
2802 width = MAX (column->min_width,
2804 if (column->max_width != -1)
2805 width = MIN (width, column->max_width != -1);
2806 *x = column->button->allocation.x + width;
2813 gtk_tree_view_adjustment_changed (GtkAdjustment *adjustment,
2814 GtkTreeView *tree_view)
2816 if (GTK_WIDGET_REALIZED (tree_view))
2818 gdk_window_move (tree_view->priv->bin_window,
2819 - tree_view->priv->hadjustment->value,
2820 - tree_view->priv->vadjustment->value);
2821 gdk_window_move (tree_view->priv->header_window,
2822 - tree_view->priv->hadjustment->value,
2825 gdk_window_process_updates (tree_view->priv->bin_window, TRUE);
2826 gdk_window_process_updates (tree_view->priv->header_window, TRUE);
2836 * gtk_tree_view_new:
2838 * Creates a new #GtkTreeView widget.
2840 * Return value: A newly created #GtkTreeView widget.
2843 gtk_tree_view_new (void)
2845 GtkTreeView *tree_view;
2847 tree_view = GTK_TREE_VIEW (gtk_type_new (gtk_tree_view_get_type ()));
2849 return GTK_WIDGET (tree_view);
2853 * gtk_tree_view_new_with_model:
2854 * @model: the model.
2856 * Creates a new #GtkTreeView widget with the model initialized to @model.
2858 * Return value: A newly created #GtkTreeView widget.
2861 gtk_tree_view_new_with_model (GtkTreeModel *model)
2863 GtkTreeView *tree_view;
2865 tree_view = GTK_TREE_VIEW (gtk_type_new (gtk_tree_view_get_type ()));
2866 gtk_tree_view_set_model (tree_view, model);
2868 return GTK_WIDGET (tree_view);
2872 * gtk_tree_view_get_model:
2873 * @tree_view: a #GtkTreeView
2875 * Returns the model the the #GtkTreeView is based on. Returns NULL if the
2878 * Return value: A #GtkTreeModel, or NULL if none is currently being used.
2881 gtk_tree_view_get_model (GtkTreeView *tree_view)
2883 g_return_val_if_fail (tree_view != NULL, NULL);
2884 g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
2886 return tree_view->priv->model;
2890 gtk_tree_view_setup_model (GtkTreeView *tree_view)
2895 tree_view->priv->tree = _gtk_rbtree_new ();
2897 gtk_signal_connect (GTK_OBJECT (tree_view->priv->model),
2899 gtk_tree_view_changed,
2901 gtk_signal_connect (GTK_OBJECT (tree_view->priv->model),
2903 gtk_tree_view_inserted,
2905 gtk_signal_connect (GTK_OBJECT (tree_view->priv->model),
2907 gtk_tree_view_child_toggled,
2909 gtk_signal_connect (GTK_OBJECT (tree_view->priv->model),
2911 gtk_tree_view_deleted,
2914 if (tree_view->priv->columns == NULL)
2917 path = gtk_tree_path_new_root ();
2918 gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
2919 gtk_tree_path_free (path);
2921 gtk_tree_view_build_tree (tree_view, tree_view->priv->tree, &iter, 1, FALSE, GTK_WIDGET_REALIZED (tree_view));
2923 gtk_tree_view_create_buttons (tree_view);
2925 GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_MODEL_SETUP);
2929 * gtk_tree_view_set_model:
2930 * @tree_view: A #GtkTreeNode.
2931 * @model: The model.
2933 * Sets the model for a #GtkTreeView. If the @tree_view already has a model
2934 * set, it will remove it before setting the new model. If @model is NULL, then
2935 * it will unset the old model.
2938 gtk_tree_view_set_model (GtkTreeView *tree_view,
2939 GtkTreeModel *model)
2942 GtkTreeViewColumn *column;
2944 g_return_if_fail (tree_view != NULL);
2945 g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
2947 if (tree_view->priv->model != NULL)
2950 /* No longer do this. */
2952 for (list = tree_view->priv->columns; list; list = list->next)
2954 column = list->data;
2957 gtk_widget_unparent (column->button);
2958 gdk_window_set_user_data (column->window, NULL);
2959 gdk_window_destroy (column->window);
2963 if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_MODEL_SETUP))
2965 gtk_signal_disconnect_by_func (GTK_OBJECT (tree_view->priv->model),
2966 gtk_tree_view_changed,
2968 gtk_signal_disconnect_by_func (GTK_OBJECT (tree_view->priv->model),
2969 gtk_tree_view_inserted,
2971 gtk_signal_disconnect_by_func (GTK_OBJECT (tree_view->priv->model),
2972 gtk_tree_view_child_toggled,
2974 gtk_signal_disconnect_by_func (GTK_OBJECT (tree_view->priv->model),
2975 gtk_tree_view_deleted,
2977 _gtk_rbtree_free (tree_view->priv->tree);
2980 g_list_free (tree_view->priv->columns);
2981 tree_view->priv->columns = NULL;
2983 GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_MODEL_SETUP);
2986 tree_view->priv->model = model;
2989 tree_view->priv->tree = NULL;
2990 if (GTK_WIDGET_REALIZED (tree_view))
2991 _gtk_tree_view_set_size (tree_view, 0, 0);
2994 else if (GTK_WIDGET_REALIZED (tree_view))
2996 gtk_tree_view_setup_model (tree_view);
2997 _gtk_tree_view_set_size (tree_view, -1, -1);
3002 * gtk_tree_view_get_selection:
3003 * @tree_view: A #GtkTreeView.
3005 * Gets the #GtkTreeSelection associated with @tree_view.
3007 * Return value: A #GtkTreeSelection object.
3010 gtk_tree_view_get_selection (GtkTreeView *tree_view)
3012 g_return_val_if_fail (tree_view != NULL, NULL);
3013 g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
3015 if (tree_view->priv->selection == NULL)
3016 tree_view->priv->selection =
3017 _gtk_tree_selection_new_with_tree_view (tree_view);
3019 return tree_view->priv->selection;
3023 * gtk_tree_view_get_hadjustment:
3024 * @tree_view: A #GtkTreeView
3026 * Gets the #GtkAdjustment currently being used for the horizontal aspect.
3028 * Return value: A #GtkAdjustment object, or NULL if none is currently being
3032 gtk_tree_view_get_hadjustment (GtkTreeView *tree_view)
3034 g_return_val_if_fail (tree_view != NULL, NULL);
3035 g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
3037 if (tree_view->priv->hadjustment == NULL)
3038 gtk_tree_view_set_hadjustment (tree_view, NULL);
3040 return tree_view->priv->hadjustment;
3044 * gtk_tree_view_set_hadjustment:
3045 * @tree_view: A #GtkTreeView
3046 * @adjustment: The #GtkAdjustment to set, or NULL
3048 * Sets the #GtkAdjustment for the current horizontal aspect.
3051 gtk_tree_view_set_hadjustment (GtkTreeView *tree_view,
3052 GtkAdjustment *adjustment)
3054 g_return_if_fail (tree_view != NULL);
3055 g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
3057 gtk_tree_view_set_adjustments (tree_view,
3059 tree_view->priv->vadjustment);
3063 * gtk_tree_view_get_vadjustment:
3064 * @tree_view: A #GtkTreeView
3066 * Gets the #GtkAdjustment currently being used for the vertical aspect.
3068 * Return value: A #GtkAdjustment object, or NULL if none is currently being
3072 gtk_tree_view_get_vadjustment (GtkTreeView *tree_view)
3074 g_return_val_if_fail (tree_view != NULL, NULL);
3075 g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
3077 if (tree_view->priv->vadjustment == NULL)
3078 gtk_tree_view_set_vadjustment (tree_view, NULL);
3080 return tree_view->priv->vadjustment;
3084 * gtk_tree_view_set_vadjustment:
3085 * @tree_view: A #GtkTreeView
3086 * @adjustment: The #GtkAdjustment to set, or NULL
3088 * Sets the #GtkAdjustment for the current vertical aspect.
3091 gtk_tree_view_set_vadjustment (GtkTreeView *tree_view,
3092 GtkAdjustment *adjustment)
3094 g_return_if_fail (tree_view != NULL);
3095 g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
3097 gtk_tree_view_set_adjustments (tree_view,
3098 tree_view->priv->hadjustment,
3103 * gtk_tree_view_set_adjustments:
3104 * @tree_view: A #GtkTreeView
3105 * @hadj: The horizontal #GtkAdjustment to set, or NULL
3106 * @vadj: The vertical #GtkAdjustment to set, or NULL
3108 * Sets the horizonal and or vertical #GtkAdjustment.
3111 gtk_tree_view_set_adjustments (GtkTreeView *tree_view,
3112 GtkAdjustment *hadj,
3113 GtkAdjustment *vadj)
3115 gboolean need_adjust = FALSE;
3117 g_return_if_fail (tree_view != NULL);
3118 g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
3121 g_return_if_fail (GTK_IS_ADJUSTMENT (hadj));
3123 hadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
3125 g_return_if_fail (GTK_IS_ADJUSTMENT (vadj));
3127 vadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
3129 if (tree_view->priv->hadjustment && (tree_view->priv->hadjustment != hadj))
3131 gtk_signal_disconnect_by_data (GTK_OBJECT (tree_view->priv->hadjustment), tree_view);
3132 gtk_object_unref (GTK_OBJECT (tree_view->priv->hadjustment));
3135 if (tree_view->priv->vadjustment && (tree_view->priv->vadjustment != vadj))
3137 gtk_signal_disconnect_by_data (GTK_OBJECT (tree_view->priv->vadjustment), tree_view);
3138 gtk_object_unref (GTK_OBJECT (tree_view->priv->vadjustment));
3141 if (tree_view->priv->hadjustment != hadj)
3143 tree_view->priv->hadjustment = hadj;
3144 gtk_object_ref (GTK_OBJECT (tree_view->priv->hadjustment));
3145 gtk_object_sink (GTK_OBJECT (tree_view->priv->hadjustment));
3147 gtk_signal_connect (GTK_OBJECT (tree_view->priv->hadjustment), "value_changed",
3148 (GtkSignalFunc) gtk_tree_view_adjustment_changed,
3153 if (tree_view->priv->vadjustment != vadj)
3155 tree_view->priv->vadjustment = vadj;
3156 gtk_object_ref (GTK_OBJECT (tree_view->priv->vadjustment));
3157 gtk_object_sink (GTK_OBJECT (tree_view->priv->vadjustment));
3159 gtk_signal_connect (GTK_OBJECT (tree_view->priv->vadjustment), "value_changed",
3160 (GtkSignalFunc) gtk_tree_view_adjustment_changed,
3166 gtk_tree_view_adjustment_changed (NULL, tree_view);
3170 /* Column and header operations */
3173 * gtk_tree_view_get_headers_visible:
3174 * @tree_view: A #GtkTreeView.
3176 * Returns TRUE if the headers on the @tree_view are visible.
3178 * Return value: Whether the headers are visible or not.
3181 gtk_tree_view_get_headers_visible (GtkTreeView *tree_view)
3183 g_return_val_if_fail (tree_view != NULL, FALSE);
3184 g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
3186 return GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE);
3190 * gtk_tree_view_set_headers_visible:
3191 * @tree_view: A #GtkTreeView.
3192 * @headers_visible: TRUE if the headers are visible
3194 * Sets the the visibility state of the headers.
3197 gtk_tree_view_set_headers_visible (GtkTreeView *tree_view,
3198 gboolean headers_visible)
3202 GtkTreeViewColumn *column;
3204 g_return_if_fail (tree_view != NULL);
3205 g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
3207 headers_visible = !! headers_visible;
3209 if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE) == headers_visible)
3212 if (headers_visible)
3213 GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE);
3215 GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE);
3217 if (GTK_WIDGET_REALIZED (tree_view))
3219 gdk_window_get_position (tree_view->priv->bin_window, &x, &y);
3220 if (headers_visible)
3222 gdk_window_move_resize (tree_view->priv->bin_window, x, y, tree_view->priv->width, tree_view->priv->height + TREE_VIEW_HEADER_HEIGHT (tree_view));
3224 if (GTK_WIDGET_MAPPED (tree_view))
3225 gtk_tree_view_map_buttons (tree_view);
3229 gdk_window_move_resize (tree_view->priv->bin_window, x, y, tree_view->priv->width, tree_view->priv->height);
3231 for (list = tree_view->priv->columns; list; list = list->next)
3233 column = list->data;
3234 gtk_widget_unmap (column->button);
3236 gdk_window_hide (tree_view->priv->header_window);
3240 tree_view->priv->vadjustment->page_size = GTK_WIDGET (tree_view)->allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view);
3241 tree_view->priv->vadjustment->page_increment = (GTK_WIDGET (tree_view)->allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view)) / 2;
3242 tree_view->priv->vadjustment->lower = 0;
3243 tree_view->priv->vadjustment->upper = tree_view->priv->height;
3244 gtk_signal_emit_by_name (GTK_OBJECT (tree_view->priv->vadjustment), "changed");
3246 gtk_widget_queue_resize (GTK_WIDGET (tree_view));
3251 * gtk_tree_view_columns_autosize:
3252 * @tree_view: A #GtkTreeView.
3254 * Resizes all columns to their optimal width.
3257 gtk_tree_view_columns_autosize (GtkTreeView *tree_view)
3259 gboolean dirty = FALSE;
3261 GtkTreeViewColumn *column;
3263 g_return_if_fail (tree_view != NULL);
3264 g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
3266 for (list = tree_view->priv->columns; list; list = list->next)
3268 column = list->data;
3269 if (column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
3271 column->dirty = TRUE;
3276 gtk_widget_queue_resize (GTK_WIDGET (tree_view));
3279 /* FIXME let's rename this to be "interactive" or something,
3280 * "active" is confusing since it also is a widget state
3283 * gtk_tree_view_set_headers_clickable:
3284 * @tree_view: A #GtkTreeView.
3285 * @setting: TRUE if the columns are clickable.
3287 * Allow the column title buttons to be clicked.
3290 gtk_tree_view_set_headers_clickable (GtkTreeView *tree_view,
3295 g_return_if_fail (tree_view != NULL);
3296 g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
3297 g_return_if_fail (tree_view->priv->model != NULL);
3299 for (list = tree_view->priv->columns; list; list = list->next)
3300 gtk_tree_view_column_set_header_clickable (GTK_TREE_VIEW_COLUMN (list->data), setting);
3304 * gtk_tree_view_append_column:
3305 * @tree_view: A #GtkTreeView.
3306 * @column: The #GtkTreeViewColumn to add.
3308 * Appends @column to the list of columns.
3310 * Return value: The number of columns in @tree_view after appending.
3313 gtk_tree_view_append_column (GtkTreeView *tree_view,
3314 GtkTreeViewColumn *column)
3316 g_return_val_if_fail (tree_view != NULL, -1);
3317 g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
3318 g_return_val_if_fail (column != NULL, -1);
3319 g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
3320 g_return_val_if_fail (column->tree_view == NULL, -1);
3322 g_object_ref (G_OBJECT (column));
3323 tree_view->priv->columns = g_list_append (tree_view->priv->columns,
3325 column->tree_view = GTK_WIDGET (tree_view);
3327 tree_view->priv->n_columns++;
3329 /* FIXME create header for the new column! */
3331 return tree_view->priv->n_columns;
3336 * gtk_tree_view_remove_column:
3337 * @tree_view: A #GtkTreeView.
3338 * @column: The #GtkTreeViewColumn to remove.
3340 * Removes @column from @tree_view.
3342 * Return value: The number of columns in @tree_view after removing.
3345 gtk_tree_view_remove_column (GtkTreeView *tree_view,
3346 GtkTreeViewColumn *column)
3348 g_return_val_if_fail (tree_view != NULL, -1);
3349 g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
3350 g_return_val_if_fail (column != NULL, -1);
3351 g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
3352 g_return_val_if_fail (column->tree_view == GTK_WIDGET (tree_view), -1);
3354 tree_view->priv->columns = g_list_remove (tree_view->priv->columns,
3356 column->tree_view = NULL;
3357 g_object_unref (G_OBJECT (column));
3359 tree_view->priv->n_columns--;
3361 /* FIXME destroy header for the column! */
3363 return tree_view->priv->n_columns;
3367 * gtk_tree_view_insert_column:
3368 * @tree_view: A #GtkTreeView.
3369 * @column: The #GtkTreeViewColumn to be inserted.
3370 * @position: The position to insert @column in.
3372 * This inserts the @column into the @tree_view at @position.
3374 * Return value: The number of columns in @tree_view after insertion.
3377 gtk_tree_view_insert_column (GtkTreeView *tree_view,
3378 GtkTreeViewColumn *column,
3381 g_return_val_if_fail (tree_view != NULL, -1);
3382 g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
3383 g_return_val_if_fail (column != NULL, -1);
3384 g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
3385 g_return_val_if_fail (column->tree_view == NULL, -1);
3387 g_object_ref (G_OBJECT (column));
3388 tree_view->priv->columns = g_list_insert (tree_view->priv->columns,
3390 column->tree_view = GTK_WIDGET (tree_view);
3392 tree_view->priv->n_columns++;
3394 /* FIXME create header for the column! */
3396 return tree_view->priv->n_columns;
3400 * gtk_tree_view_get_column:
3401 * @tree_view: A #GtkTreeView.
3402 * @n: The position of the column, counting from 0.
3404 * Gets the #GtkTreeViewColumn at the given position in the #tree_view.
3406 * Return value: The #GtkTreeViewColumn, or NULL if the position is outside the
3410 gtk_tree_view_get_column (GtkTreeView *tree_view,
3413 g_return_val_if_fail (tree_view != NULL, NULL);
3414 g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
3415 g_return_val_if_fail (tree_view->priv->model != NULL, NULL);
3417 if (n < 0 || n >= tree_view->priv->n_columns)
3420 if (tree_view->priv->columns == NULL)
3423 return GTK_TREE_VIEW_COLUMN (g_list_nth (tree_view->priv->columns, n)->data);
3427 * gtk_tree_view_move_to:
3428 * @tree_view: A #GtkTreeView.
3429 * @path: The path of the row to move to.
3430 * @column: The #GtkTreeViewColumn to move horizontally to.
3431 * @row_align: The vertical alignment of the row specified by @path.
3432 * @col_align: The horizontal alignment of the column specified by @column.
3434 * Moves the alignments of @tree_view to the position specified by
3435 * @column and @path. If @column is NULL, then the first visible
3436 * column is assumed, and the @tree_view is left justified. Likewise,
3437 * if @path is NULL the first row is assumed, and the @tree_view is
3438 * top justified. @row_align determines where the row is placed, and
3439 * @col_align determines where @column is placed. Both are expected
3440 * to be between 0.0 and 1.0. 0.0 means left/top alignment, 1.0 means
3441 * right/bottom alignment, 0.5 means center.
3444 gtk_tree_view_move_to (GtkTreeView *tree_view,
3446 GtkTreeViewColumn *column,
3450 GtkRBNode *node = NULL;
3451 GtkRBTree *tree = NULL;
3453 g_return_if_fail (tree_view != NULL);
3454 g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
3456 row_align = CLAMP (row_align, 0, 1);
3457 col_align = CLAMP (col_align, 0, 1);
3461 _gtk_tree_view_find_node (tree_view, path,
3463 /* Should we justify it to the bottom? */
3468 if (tree_view->priv->hadjustment && column >= 0)
3470 /* FIXME -- write */
3475 * gtk_tree_view_get_path_at_pos:
3476 * @tree_view: A #GtkTreeView.
3477 * @window: The #GtkWindow to check against.
3478 * @x: The x position to be identified.
3479 * @y: The y position to be identified.
3480 * @path: A pointer to a #GtkTreePath pointer to be filled in, or NULL
3481 * @column: A pointer to a #GtkTreeViewColumn pointer to be filled in, or NULL
3483 * Finds the path at the point (@x, @y) relative to @window. If @window is
3484 * NULL, then the point is found relative to the widget coordinates. This
3485 * function is expected to be called after an event, with event->window being
3486 * passed in as @window. It is primarily for things like popup menus. If @path
3487 * is non-NULL, then it will be filled with the #GtkTreePath at that point.
3488 * This path should be freed with #gtk_tree_path_free. If @column is non-NULL,
3489 * then it will be filled with the column at that point.
3491 * Return value: TRUE if a row exists at that coordinate.
3494 gtk_tree_view_get_path_at_pos (GtkTreeView *tree_view,
3499 GtkTreeViewColumn **column)
3505 g_return_val_if_fail (tree_view != NULL, FALSE);
3506 g_return_val_if_fail (tree_view->priv->tree != NULL, FALSE);
3507 g_return_val_if_fail (x >= 0, FALSE);
3508 g_return_val_if_fail (y >= 0, FALSE);
3509 g_return_val_if_fail (tree_view->priv->bin_window != NULL, FALSE);
3512 g_return_val_if_fail (window == tree_view->priv->bin_window, FALSE);
3519 if (x > tree_view->priv->hadjustment->upper)
3524 GtkTreeViewColumn *tmp_column;
3525 GtkTreeViewColumn *last_column = NULL;
3528 for (list = tree_view->priv->columns; list; list = list->next)
3530 tmp_column = list->data;
3532 if (tmp_column->visible == FALSE)
3535 last_column = tmp_column;
3536 if (x <= tmp_column->width)
3538 *column = tmp_column;
3541 x -= tmp_column->width;
3544 if (*column == NULL)
3545 *column = last_column;
3550 _gtk_rbtree_find_offset (tree_view->priv->tree,
3551 y - TREE_VIEW_HEADER_HEIGHT (tree_view),
3556 if (y < TREE_VIEW_HEADER_HEIGHT (tree_view))
3559 _gtk_rbtree_find_offset (tree_view->priv->tree, y - TREE_VIEW_HEADER_HEIGHT (tree_view) +
3560 tree_view->priv->vadjustment->value,
3568 *path = _gtk_tree_view_find_path (tree_view, tree, node);
3574 gtk_tree_view_expand_all_helper (GtkRBTree *tree,
3578 GtkTreeView *tree_view = data;
3581 _gtk_rbtree_traverse (node->children,
3582 node->children->root,
3584 gtk_tree_view_expand_all_helper,
3586 else if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT && node->children == NULL)
3592 node->children = _gtk_rbtree_new ();
3593 node->children->parent_tree = tree;
3594 node->children->parent_node = node;
3595 path = _gtk_tree_view_find_path (tree_view, tree, node);
3596 gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
3597 gtk_tree_model_iter_children (tree_view->priv->model, &child, &iter);
3598 gtk_tree_view_build_tree (tree_view,
3601 gtk_tree_path_get_depth (path) + 1,
3603 GTK_WIDGET_REALIZED (tree_view));
3604 gtk_tree_path_free (path);
3609 * gtk_tree_view_expand_all:
3610 * @tree_view: A #GtkTreeView.
3612 * Recursively expands all nodes in the @tree_view.
3615 gtk_tree_view_expand_all (GtkTreeView *tree_view)
3617 g_return_if_fail (tree_view != NULL);
3618 g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
3619 g_return_if_fail (tree_view->priv->tree != NULL);
3621 _gtk_rbtree_traverse (tree_view->priv->tree,
3622 tree_view->priv->tree->root,
3624 gtk_tree_view_expand_all_helper,
3627 _gtk_tree_view_set_size (tree_view, -1,-1);
3631 gtk_tree_view_collapse_all_helper (GtkRBTree *tree,
3640 path = _gtk_tree_view_find_path (GTK_TREE_VIEW (data),
3642 node->children->root);
3643 gtk_tree_model_get_iter (GTK_TREE_VIEW (data)->priv->model,
3646 gtk_tree_view_discover_dirty (GTK_TREE_VIEW (data),
3649 gtk_tree_path_get_depth (path));
3650 _gtk_rbtree_remove (node->children);
3651 gtk_tree_path_free (path);
3656 * gtk_tree_view_collapse_all:
3657 * @tree_view: A #GtkTreeView.
3659 * Recursively collapses all visible, expanded nodes in @tree_view.
3662 gtk_tree_view_collapse_all (GtkTreeView *tree_view)
3664 g_return_if_fail (tree_view != NULL);
3665 g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
3666 g_return_if_fail (tree_view->priv->tree != NULL);
3668 _gtk_rbtree_traverse (tree_view->priv->tree,
3669 tree_view->priv->tree->root,
3671 gtk_tree_view_collapse_all_helper,
3674 if (GTK_WIDGET_MAPPED (tree_view))
3675 gtk_widget_queue_draw (GTK_WIDGET (tree_view));
3678 /* FIXME the bool return values for expand_row and collapse_row are
3679 * not analagous; they should be TRUE if the row had children and
3680 * was not already in the requested state.
3684 * gtk_tree_view_expand_row:
3685 * @tree_view: a #GtkTreeView
3686 * @path: path to a row
3687 * @open_all: whether to recursively expand, or just expand immediate children
3689 * Opens the row so its children are visible
3691 * Return value: %TRUE if the row existed and had children
3694 gtk_tree_view_expand_row (GtkTreeView *tree_view,
3703 g_return_val_if_fail (tree_view != NULL, FALSE);
3704 g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
3705 g_return_val_if_fail (tree_view->priv->model != NULL, FALSE);
3706 g_return_val_if_fail (path != NULL, FALSE);
3708 if (_gtk_tree_view_find_node (tree_view,
3714 gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
3715 if (! gtk_tree_model_iter_has_child (tree_view->priv->model, &iter))
3718 node->children = _gtk_rbtree_new ();
3719 node->children->parent_tree = tree;
3720 node->children->parent_node = node;
3722 gtk_tree_model_iter_children (tree_view->priv->model, &child, &iter);
3723 gtk_tree_view_build_tree (tree_view,
3726 gtk_tree_path_get_depth (path) + 1,
3728 GTK_WIDGET_REALIZED (tree_view));
3730 if (GTK_WIDGET_MAPPED (tree_view))
3731 gtk_widget_queue_draw (GTK_WIDGET (tree_view));
3737 * gtk_tree_view_collapse_row:
3738 * @tree_view: a #GtkTreeView
3739 * @path: path to a row in the @tree_view
3741 * Collapses a row (hides its child rows).
3743 * Return value: %TRUE if the row was expanded
3746 gtk_tree_view_collapse_row (GtkTreeView *tree_view,
3753 g_return_val_if_fail (tree_view != NULL, FALSE);
3754 g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
3755 g_return_val_if_fail (tree_view->priv->tree != NULL, FALSE);
3756 g_return_val_if_fail (path != NULL, FALSE);
3758 if (_gtk_tree_view_find_node (tree_view,
3764 if (node->children == NULL)
3767 gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
3768 gtk_tree_view_discover_dirty (tree_view,
3771 gtk_tree_path_get_depth (path));
3772 _gtk_rbtree_remove (node->children);
3774 if (GTK_WIDGET_MAPPED (tree_view))
3775 gtk_widget_queue_draw (GTK_WIDGET (tree_view));