#include "gtkcontainer.h"
#include "gtkentry.h"
#include "gtkframe.h"
+#include "gtkmain.h"
#include "gtktreemodelsort.h"
#include "gtktooltip.h"
#include "gtkscrollable.h"
#include "gtkentryprivate.h"
#include "gtkstylecontextprivate.h"
#include "gtktypebuiltins.h"
+#include "gtkmain.h"
#include "a11y/gtktreeviewaccessible.h"
RUBBER_BAND_ACTIVE = 2
};
+typedef enum {
+ CLEAR_AND_SELECT = (1 << 0),
+ CLAMP_NODE = (1 << 1),
+ CURSOR_INVALID = (1 << 2)
+} SetCursorFlags;
+
/* This lovely little value is used to determine how far away from the title bar
* you can move the mouse and still have a column drag work.
*/
gint cursor_offset;
GtkTreeRowReference *anchor;
- GtkTreeRowReference *cursor;
+ GtkRBNode *cursor_node;
+ GtkRBTree *cursor_tree;
GtkTreeViewColumn *focus_column;
gboolean animate);
static void gtk_tree_view_real_set_cursor (GtkTreeView *tree_view,
GtkTreePath *path,
- gboolean clear_and_select,
- gboolean clamp_node);
+ SetCursorFlags flags);
static gboolean gtk_tree_view_has_can_focus_cell (GtkTreeView *tree_view);
static void column_sizing_notify (GObject *object,
GParamSpec *pspec,
const gchar *childname);
static void gtk_tree_view_buildable_init (GtkBuildableIface *iface);
+static GtkAdjustment *gtk_tree_view_do_get_hadjustment (GtkTreeView *tree_view);
+static void gtk_tree_view_do_set_hadjustment (GtkTreeView *tree_view,
+ GtkAdjustment *adjustment);
+static GtkAdjustment *gtk_tree_view_do_get_vadjustment (GtkTreeView *tree_view);
+static void gtk_tree_view_do_set_vadjustment (GtkTreeView *tree_view,
+ GtkAdjustment *adjustment);
static gboolean scroll_row_timeout (gpointer data);
static void add_scroll_timeout (GtkTreeView *tree_view);
tree_view->priv->event_last_x = -10000;
tree_view->priv->event_last_y = -10000;
- gtk_tree_view_set_vadjustment (tree_view, NULL);
- gtk_tree_view_set_hadjustment (tree_view, NULL);
+ gtk_tree_view_do_set_vadjustment (tree_view, NULL);
+ gtk_tree_view_do_set_hadjustment (tree_view, NULL);
}
\f
gtk_tree_view_set_model (tree_view, g_value_get_object (value));
break;
case PROP_HADJUSTMENT:
- gtk_tree_view_set_hadjustment (tree_view, g_value_get_object (value));
+ gtk_tree_view_do_set_hadjustment (tree_view, g_value_get_object (value));
break;
case PROP_VADJUSTMENT:
- gtk_tree_view_set_vadjustment (tree_view, g_value_get_object (value));
+ gtk_tree_view_do_set_vadjustment (tree_view, g_value_get_object (value));
break;
case PROP_HSCROLL_POLICY:
tree_view->priv->hscroll_policy = g_value_get_enum (value);
tree_view->priv->destroy_count_data = NULL;
}
- gtk_tree_row_reference_free (tree_view->priv->cursor);
- tree_view->priv->cursor = NULL;
-
gtk_tree_row_reference_free (tree_view->priv->anchor);
tree_view->priv->anchor = NULL;
gdk_window_show (gtk_widget_get_window (widget));
}
+static void
+gtk_tree_view_ensure_background (GtkTreeView *tree_view)
+{
+ GtkStyleContext *context;
+
+ context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
+
+ gtk_style_context_save (context);
+ gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW);
+ gtk_style_context_set_background (context, tree_view->priv->bin_window);
+ gtk_style_context_restore (context);
+
+ gtk_style_context_set_background (context, tree_view->priv->header_window);
+}
+
static void
gtk_tree_view_realize (GtkWidget *widget)
{
GtkAllocation allocation;
- GtkStyleContext *context;
GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
GdkWindow *window;
GdkWindowAttr attributes;
&attributes, attributes_mask);
gdk_window_set_user_data (tree_view->priv->header_window, widget);
- context = gtk_widget_get_style_context (widget);
-
- gtk_style_context_save (context);
- gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW);
- gtk_style_context_set_background (context, tree_view->priv->bin_window);
- gtk_style_context_restore (context);
-
- gtk_style_context_set_background (context, tree_view->priv->header_window);
+ gtk_tree_view_ensure_background (tree_view);
tmp_list = tree_view->priv->children;
while (tmp_list)
}
/* Get the path and the node */
- path = _gtk_tree_view_find_path (tree_view, tree, node);
+ path = _gtk_tree_path_new_from_rbtree (tree, node);
path_is_selectable = !row_is_separator (tree_view, NULL, path);
if (!path_is_selectable)
return FALSE;
}
- tree_view->priv->focus_column = column;
+ _gtk_tree_view_set_focus_column (tree_view, column);
/* decide if we edit */
if (event->type == GDK_BUTTON_PRESS && event->button == 1 &&
if (event->state & modify_mod_mask)
{
- gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
+ gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
gtk_tree_view_real_toggle_cursor_row (tree_view);
}
else if (event->state & extend_mod_mask)
{
- gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
+ gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
gtk_tree_view_real_select_cursor_row (tree_view, FALSE);
}
else
{
- gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE);
+ gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CLAMP_NODE);
}
tree_view->priv->modify_selection_pressed = FALSE;
{
GtkTreePath *path = NULL;
- path = _gtk_tree_view_find_path (tree_view,
- tree_view->priv->button_pressed_tree,
- tree_view->priv->button_pressed_node);
+ path = _gtk_tree_path_new_from_rbtree (tree_view->priv->button_pressed_tree,
+ tree_view->priv->button_pressed_node);
/* Actually activate the node */
if (tree_view->priv->button_pressed_node->children == NULL)
gtk_tree_view_real_expand_row (tree_view, path,
if (tree_view->priv->prelight_node)
{
- path = _gtk_tree_view_find_path (tree_view,
- tree_view->priv->prelight_tree,
- tree_view->priv->prelight_node);
+ path = _gtk_tree_path_new_from_rbtree (tree_view->priv->prelight_tree,
+ tree_view->priv->prelight_node);
if (tree_view->priv->prelight_node->children)
gtk_tree_view_collapse_row (tree_view, path);
{
GtkTreePath *path;
- path = _gtk_tree_view_find_path (tree_view, tree, node);
+ path = _gtk_tree_path_new_from_rbtree (tree, node);
gtk_tree_selection_select_path (tree_view->priv->selection, path);
if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
{
tree_view->priv->draw_keyfocus = FALSE;
- gtk_tree_view_real_set_cursor (tree_view, path, FALSE, FALSE);
+ gtk_tree_view_real_set_cursor (tree_view, path, 0);
}
gtk_tree_path_free (path);
}
gtk_widget_queue_draw (GTK_WIDGET (tree_view));
/* The anchor path should be set to the start path */
- tmp_path = _gtk_tree_view_find_path (tree_view,
- tree_view->priv->rubber_band_start_tree,
- tree_view->priv->rubber_band_start_node);
+ tmp_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->rubber_band_start_tree,
+ tree_view->priv->rubber_band_start_node);
if (tree_view->priv->anchor)
gtk_tree_row_reference_free (tree_view->priv->anchor);
gtk_tree_path_free (tmp_path);
/* ... and the cursor to the end path */
- tmp_path = _gtk_tree_view_find_path (tree_view,
- tree_view->priv->rubber_band_end_tree,
- tree_view->priv->rubber_band_end_node);
- gtk_tree_view_real_set_cursor (GTK_TREE_VIEW (tree_view), tmp_path, FALSE, FALSE);
+ tmp_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->rubber_band_end_tree,
+ tree_view->priv->rubber_band_end_node);
+ gtk_tree_view_real_set_cursor (GTK_TREE_VIEW (tree_view), tmp_path, 0);
gtk_tree_path_free (tmp_path);
_gtk_tree_selection_emit_changed (tree_view->priv->selection);
GtkTreePath *path;
gboolean selectable;
- path = _gtk_tree_view_find_path (tree_view, start_tree, start_node);
+ path = _gtk_tree_path_new_from_rbtree (start_tree, start_node);
selectable = _gtk_tree_selection_row_is_selectable (tree_view->priv->selection, start_node, path);
gtk_tree_path_free (path);
if (start_node->children)
{
start_tree = start_node->children;
- start_node = start_tree->root;
- while (start_node->left != start_tree->nil)
- start_node = start_node->left;
+ start_node = _gtk_rbtree_first (start_tree);
}
else
{
if (w > 0 && h > 0)
{
GtkStyleContext *context;
- GtkStateFlags state;
context = gtk_widget_get_style_context (widget);
- state = gtk_widget_get_state_flags (widget);
-
- gtk_style_context_save (context);
- gtk_style_context_set_state (context, state);
gtk_render_focus (context, cr, 1, 1, w, h);
-
- gtk_style_context_restore (context);
}
}
GtkRBTree *tree;
GList *list;
GtkRBNode *node;
- GtkRBNode *cursor = NULL;
- GtkRBTree *cursor_tree = NULL;
GtkRBNode *drag_highlight = NULL;
GtkRBTree *drag_highlight_tree = NULL;
GtkTreeIter iter;
gint expander_cell_width;
gint bin_window_width;
gint bin_window_height;
- GtkTreePath *cursor_path;
GtkTreePath *drag_dest_path;
GList *first_column, *last_column;
gint vertical_separator;
gint grid_line_width;
gboolean draw_vgrid_lines, draw_hgrid_lines;
GtkStyleContext *context;
- GtkStateFlags state;
+ gboolean parity;
rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
context = gtk_widget_get_style_context (widget);
- state = gtk_widget_get_state_flags (widget);
gtk_widget_style_get (widget,
"horizontal-separator", &horizontal_separator,
if (tree_view->priv->height < bin_window_height)
{
gtk_style_context_save (context);
- gtk_style_context_set_state (context, state);
gtk_style_context_add_class (context, GTK_STYLE_CLASS_CELL);
gtk_render_background (context, cr,
return TRUE;
/* find the path for the node */
- path = _gtk_tree_view_find_path ((GtkTreeView *)widget,
- tree,
- node);
+ path = _gtk_tree_path_new_from_rbtree (tree, node);
gtk_tree_model_get_iter (tree_view->priv->model,
&iter,
path);
depth = gtk_tree_path_get_depth (path);
gtk_tree_path_free (path);
- cursor_path = NULL;
drag_dest_path = NULL;
- if (tree_view->priv->cursor)
- cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
-
- if (cursor_path)
- _gtk_tree_view_find_node (tree_view, cursor_path,
- &cursor_tree, &cursor);
-
if (tree_view->priv->drag_dest_row)
drag_dest_path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
* start at the first node of the event, and walk the tree in
* order, drawing each successive node.
*/
+
+ parity = !(_gtk_rbtree_node_get_index (tree, node) % 2);
do
{
- gboolean parity;
gboolean is_separator = FALSE;
gboolean is_first = FALSE;
gboolean is_last = FALSE;
gint n_col = 0;
+ parity = !parity;
is_separator = row_is_separator (tree_view, &iter, NULL);
max_height = gtk_tree_view_get_row_height (tree_view, node);
if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
flags |= GTK_CELL_RENDERER_SELECTED;
- parity = _gtk_rbtree_node_find_parity (tree, node);
-
/* we *need* to set cell data on all cells before the call
* to _has_can_focus_cell, else _has_can_focus_cell() does not
* return a correct value.
else
flags &= ~GTK_CELL_RENDERER_SORTED;
- if (cursor == node)
+ if (tree_view->priv->cursor_node == node)
flags |= GTK_CELL_RENDERER_FOCUSED;
else
flags &= ~GTK_CELL_RENDERER_FOCUSED;
+ if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
+ flags |= GTK_CELL_RENDERER_EXPANDABLE;
+ else
+ flags &= ~GTK_CELL_RENDERER_EXPANDABLE;
+
+ if (node->children)
+ flags |= GTK_CELL_RENDERER_EXPANDED;
+ else
+ flags &= ~GTK_CELL_RENDERER_EXPANDED;
+
background_area.x = cell_offset;
background_area.width = width;
gtk_style_context_add_region (context, GTK_STYLE_REGION_ROW, row_flags);
gtk_style_context_add_region (context, GTK_STYLE_REGION_COLUMN, column_flags);
- if (node == cursor && has_can_focus_cell
+ if (node == tree_view->priv->cursor_node && has_can_focus_cell
&& ((column == tree_view->priv->focus_column
&& tree_view->priv->draw_keyfocus &&
gtk_widget_has_visible_focus (widget))
}
/* draw the big row-spanning focus rectangle, if needed */
- if (!has_can_focus_cell && node == cursor &&
+ if (!has_can_focus_cell && node == tree_view->priv->cursor_node &&
tree_view->priv->draw_keyfocus &&
gtk_widget_has_visible_focus (widget))
{
gboolean has_child;
tree = node->children;
- node = tree->root;
-
- g_assert (node != tree->nil);
+ node = _gtk_rbtree_first (tree);
- while (node->left != tree->nil)
- node = node->left;
has_child = gtk_tree_model_iter_children (tree_view->priv->model,
&iter,
&parent);
if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
gtk_tree_view_paint_rubber_band (tree_view, cr);
- if (cursor_path)
- gtk_tree_path_free (cursor_path);
-
if (drag_dest_path)
gtk_tree_path_free (drag_dest_path);
{
GtkTreeView *tree_view;
- if (event->mode == GDK_CROSSING_GRAB)
+ if (event->mode == GDK_CROSSING_GRAB ||
+ event->mode == GDK_CROSSING_GTK_GRAB ||
+ event->mode == GDK_CROSSING_GTK_UNGRAB)
return TRUE;
tree_view = GTK_TREE_VIEW (widget);
}
else
{
- path = _gtk_tree_view_find_path (tree_view, tree, node);
+ path = _gtk_tree_path_new_from_rbtree (tree, node);
total_height += offset;
}
GtkTreePath *tmppath;
GtkTreeIter tmpiter;
- tmppath = _gtk_tree_view_find_path (tree_view, tmptree, tmpnode);
+ tmppath = _gtk_tree_path_new_from_rbtree (tmptree, tmpnode);
gtk_tree_model_get_iter (tree_view->priv->model, &tmpiter, tmppath);
if (GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_INVALID) ||
gboolean has_child;
tree = node->children;
- node = tree->root;
-
- g_assert (node != tree->nil);
+ node = _gtk_rbtree_first (tree);
- while (node->left != tree->nil)
- node = node->left;
has_child = gtk_tree_model_iter_children (tree_view->priv->model,
&iter,
&parent);
break;
gtk_tree_path_free (above_path);
- above_path = _gtk_tree_view_find_path (tree_view, tree, node);
+ above_path = _gtk_tree_path_new_from_rbtree (tree, node);
gtk_tree_model_get_iter (tree_view->priv->model, &iter, above_path);
tree = tree_view->priv->tree;
node = tree->root;
- path = _gtk_tree_view_find_path (tree_view, tree, node);
+ path = _gtk_tree_path_new_from_rbtree (tree, node);
gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
validate_row (tree_view, tree, node, &iter, path);
do
{
- if (node->left != tree->nil &&
+ if (!_gtk_rbtree_is_nil (node->left) &&
GTK_RBNODE_FLAG_SET (node->left, GTK_RBNODE_DESCENDANTS_INVALID))
{
node = node->left;
}
- else if (node->right != tree->nil &&
+ else if (!_gtk_rbtree_is_nil (node->right) &&
GTK_RBNODE_FLAG_SET (node->right, GTK_RBNODE_DESCENDANTS_INVALID))
{
node = node->right;
g_assert_not_reached ();
}
while (TRUE);
- path = _gtk_tree_view_find_path (tree_view, tree, node);
+ path = _gtk_tree_path_new_from_rbtree (tree, node);
gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
}
}
else
{
- path = _gtk_tree_view_find_path (tree_view, tree, node);
+ path = _gtk_tree_path_new_from_rbtree (tree, node);
gtk_tree_view_set_top_row (tree_view, path, offset);
gtk_tree_path_free (path);
}
&cell_x,
&cell_y);
- g_return_if_fail (path != NULL);
+ /* If path is NULL, there's nothing we can drag. For now, we silently
+ * bail out. Actually, dragging should not be possible from an empty
+ * tree view, but there's no way we can cancel that from here.
+ * Automatically unsetting the tree view as drag source for empty models
+ * is something that would likely break other people's code ...
+ */
+ if (!path)
+ return;
row_pix = gtk_tree_view_create_row_drag_icon (tree_view,
path);
(gdk_drag_context_get_selected_action (context) == GDK_ACTION_MOVE),
time);
- if (gtk_tree_path_get_depth (dest_row) == 1
- && gtk_tree_path_get_indices (dest_row)[0] == 0)
+ if (gtk_tree_path_get_depth (dest_row) == 1 &&
+ gtk_tree_path_get_indices (dest_row)[0] == 0 &&
+ gtk_tree_model_iter_n_children (tree_view->priv->model, NULL) != 0)
{
/* special special case drag to "0", scroll to first item */
if (!tree_view->priv->scroll_to_path)
for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
if (gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (tmp_list->data)) == focus_child)
{
- tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
+ _gtk_tree_view_set_focus_column (tree_view, GTK_TREE_VIEW_COLUMN (tmp_list->data));
break;
}
gtk_tree_path_free (*path);
if (node)
- *path = _gtk_tree_view_find_path (tree_view, tree, node);
+ *path = _gtk_tree_path_new_from_rbtree (tree, node);
else
*path = NULL;
}
if (gtk_widget_get_realized (widget))
{
- GtkStyleContext *context;
-
- context = gtk_widget_get_style_context (widget);
-
- gtk_style_context_save (context);
- gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW);
- gtk_style_context_set_background (context, tree_view->priv->bin_window);
- gtk_style_context_restore (context);
-
- gtk_style_context_set_background (context, tree_view->priv->header_window);
+ gtk_tree_view_ensure_background (tree_view);
gtk_tree_view_set_grid_lines (tree_view, tree_view->priv->grid_lines);
gtk_tree_view_set_enable_tree_lines (tree_view, tree_view->priv->tree_lines_enabled);
{
if (gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (list->data)) == child)
{
- tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (list->data);
+ _gtk_tree_view_set_focus_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data));
break;
}
}
g_return_if_fail (path != NULL || iter != NULL);
- if (tree_view->priv->cursor != NULL)
- cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
+ if (tree_view->priv->cursor_node != NULL)
+ cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node);
else
cursor_path = NULL;
if (tree == NULL)
goto done;
+ _gtk_tree_view_accessible_changed (tree_view, tree, node);
+
if (tree_view->priv->fixed_height_mode
&& tree_view->priv->fixed_height >= 0)
{
{
GtkTreeView *tree_view = (GtkTreeView *) data;
gint *indices;
- GtkRBTree *tmptree, *tree;
+ GtkRBTree *tree;
GtkRBNode *tmpnode = NULL;
gint depth;
gint i = 0;
if (tree_view->priv->tree == NULL)
tree_view->priv->tree = _gtk_rbtree_new ();
- tmptree = tree = tree_view->priv->tree;
+ tree = tree_view->priv->tree;
/* Update all row-references */
gtk_tree_row_reference_inserted (G_OBJECT (data), path);
/* First, find the parent tree */
while (i < depth - 1)
{
- if (tmptree == NULL)
+ if (tree == NULL)
{
/* We aren't showing the node */
node_visible = FALSE;
goto done;
}
- tmpnode = _gtk_rbtree_find_count (tmptree, indices[i] + 1);
+ tmpnode = _gtk_rbtree_find_count (tree, indices[i] + 1);
if (tmpnode == NULL)
{
g_warning ("A node was inserted with a parent that's not in the tree.\n" \
/* In theory, the model should have emitted has_child_toggled here. We
* try to catch it anyway, just to be safe, in case the model hasn't.
*/
- GtkTreePath *tmppath = _gtk_tree_view_find_path (tree_view,
- tree,
- tmpnode);
+ GtkTreePath *tmppath = _gtk_tree_path_new_from_rbtree (tree, tmpnode);
gtk_tree_view_row_has_child_toggled (model, tmppath, NULL, data);
gtk_tree_path_free (tmppath);
goto done;
}
- tmptree = tmpnode->children;
- tree = tmptree;
+ tree = tmpnode->children;
i++;
}
tmpnode = _gtk_rbtree_insert_after (tree, tmpnode, height, FALSE);
}
+ _gtk_tree_view_accessible_add (tree_view, tree, tmpnode);
+
done:
if (height > 0)
{
goto done;
if (has_child)
- GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PARENT);
+ {
+ GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PARENT);
+ _gtk_tree_view_accessible_add_state (tree_view, tree, node, GTK_CELL_RENDERER_EXPANDABLE);
+ }
else
- GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_PARENT);
+ {
+ GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_PARENT);
+ _gtk_tree_view_accessible_remove_state (tree_view, tree, node, GTK_CELL_RENDERER_EXPANDABLE);
+ }
if (has_child && tree_view->priv->is_list)
{
{
gint *value = (gint *)data;
- *value = GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED);
+ *value |= GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED);
if (node->children && !*value)
_gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, check_selection_helper, data);
GtkRBTree *tree;
GtkRBNode *node;
GList *list;
- gint selection_changed = FALSE;
+ gboolean selection_changed = FALSE, cursor_changed = FALSE;
+ GtkRBTree *cursor_tree = NULL;
+ GtkRBNode *cursor_node = NULL;
GtkStyleContext *context;
g_return_if_fail (path != NULL);
/* Cancel editting if we've started */
gtk_tree_view_stop_editing (tree_view, TRUE);
+ /* If the cursor row got deleted, move the cursor to the next row */
+ if (tree_view->priv->cursor_node &&
+ (tree_view->priv->cursor_node == node ||
+ (node->children && (tree_view->priv->cursor_tree == node->children ||
+ _gtk_rbtree_contains (node->children, tree_view->priv->cursor_tree)))))
+ {
+ GtkTreePath *cursor_path;
+
+ cursor_tree = tree;
+ cursor_node = _gtk_rbtree_next (tree, node);
+ /* find the first node that is not going to be deleted */
+ while (cursor_node == NULL && cursor_tree->parent_tree)
+ {
+ cursor_node = _gtk_rbtree_next (cursor_tree->parent_tree,
+ cursor_tree->parent_node);
+ cursor_tree = cursor_tree->parent_tree;
+ }
+
+ if (cursor_node != NULL)
+ cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
+ else
+ cursor_path = NULL;
+
+ if (cursor_path == NULL ||
+ ! search_first_focusable_path (tree_view, &cursor_path, TRUE,
+ &cursor_tree, &cursor_node))
+ {
+ /* It looks like we reached the end of the view without finding
+ * a focusable row. We will step backwards to find the last
+ * focusable row.
+ */
+ _gtk_rbtree_prev_full (tree, node, &cursor_tree, &cursor_node);
+ if (cursor_node)
+ {
+ cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
+ if (! search_first_focusable_path (tree_view, &cursor_path, FALSE,
+ &cursor_tree, &cursor_node))
+ cursor_node = NULL;
+ gtk_tree_path_free (cursor_path);
+ }
+ }
+ else if (cursor_path)
+ gtk_tree_path_free (cursor_path);
+
+ cursor_changed = TRUE;
+ }
+
if (tree_view->priv->destroy_count_func)
{
gint child_count = 0;
if (tree_view->priv->tree == tree)
tree_view->priv->tree = NULL;
+ _gtk_tree_view_accessible_remove_state (tree_view,
+ tree->parent_tree, tree->parent_node,
+ GTK_CELL_RENDERER_EXPANDED);
+ _gtk_tree_view_accessible_remove (tree_view, tree, NULL);
_gtk_rbtree_remove (tree);
}
else
{
+ _gtk_tree_view_accessible_remove (tree_view, tree, node);
_gtk_rbtree_remove_node (tree, node);
}
gtk_widget_queue_resize (GTK_WIDGET (tree_view));
+ if (cursor_changed)
+ {
+ if (cursor_node)
+ {
+ GtkTreePath *cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
+ gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT | CURSOR_INVALID);
+ gtk_tree_path_free (cursor_path);
+ }
+ else
+ gtk_tree_view_real_set_cursor (tree_view, NULL, CLEAR_AND_SELECT | CURSOR_INVALID);
+ }
if (selection_changed)
g_signal_emit_by_name (tree_view->priv->selection, "changed");
}
_gtk_rbtree_reorder (tree, new_order, len);
+ _gtk_tree_view_accessible_reorder (tree_view);
+
gtk_widget_queue_draw (GTK_WIDGET (tree_view));
gtk_tree_view_dy_to_top_row (tree_view);
+ gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
return;
- path = _gtk_tree_view_find_path (tree_view, tree, node);
+ path = _gtk_tree_path_new_from_rbtree (tree, node);
if (path)
{
/* We process updates because we want to clear old selected items when we scroll.
/* This function could be more efficient. I'll optimize it if profiling seems
* to imply that it is important */
GtkTreePath *
-_gtk_tree_view_find_path (GtkTreeView *tree_view,
- GtkRBTree *tree,
- GtkRBNode *node)
+_gtk_tree_path_new_from_rbtree (GtkRBTree *tree,
+ GtkRBNode *node)
{
GtkTreePath *path;
GtkRBTree *tmp_tree;
path = gtk_tree_path_new ();
g_return_val_if_fail (node != NULL, path);
- g_return_val_if_fail (node != tree->nil, path);
count = 1 + node->left->count;
tmp_tree = tree;
while (tmp_tree)
{
- while (tmp_node != tmp_tree->nil)
+ while (!_gtk_rbtree_is_nil (tmp_node))
{
if (tmp_node->right == last)
count += 1 + tmp_node->left->count;
GtkRBNode *new_node;
new_tree = node->children;
- new_node = new_tree->root;
-
- while (new_node && new_node->left != new_tree->nil)
- new_node = new_node->left;
+ new_node = _gtk_rbtree_first (new_tree);
if (!gtk_tree_model_iter_children (model, &child, iter))
return FALSE;
- retval = retval || gtk_tree_view_unref_tree_helper (model, &child, new_tree, new_node);
+ retval = gtk_tree_view_unref_tree_helper (model, &child, new_tree, new_node) | retval;
}
if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
if (!tree)
return FALSE;
- node = tree->root;
- while (node && node->left != tree->nil)
- node = node->left;
+ node = _gtk_rbtree_first (tree);
g_return_val_if_fail (node != NULL, FALSE);
- path = _gtk_tree_view_find_path (tree_view, tree, node);
+ path = _gtk_tree_path_new_from_rbtree (tree, node);
gtk_tree_model_get_iter (GTK_TREE_MODEL (tree_view->priv->model),
&iter, path);
retval = gtk_tree_view_unref_tree_helper (GTK_TREE_MODEL (tree_view->priv->model), &iter, tree, node);
gint x2;
gint vertical_separator;
gint expander_size;
- GtkCellRendererState flags;
+ GtkCellRendererState flags = 0;
widget = GTK_WIDGET (tree_view);
context = gtk_widget_get_style_context (widget);
area.height = gtk_tree_view_get_cell_area_height (tree_view, node,
vertical_separator);
- if (!gtk_widget_get_sensitive (widget))
- state |= GTK_STATE_FLAG_INSENSITIVE;
- else
- {
- flags = 0;
+ if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
+ flags |= GTK_CELL_RENDERER_SELECTED;
- if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
- flags |= GTK_CELL_RENDERER_SELECTED;
+ if (node == tree_view->priv->prelight_node &&
+ tree_view->priv->arrow_prelit)
+ flags |= GTK_CELL_RENDERER_PRELIT;
- state = gtk_cell_renderer_get_state (NULL, widget, flags);
-
- if (node == tree_view->priv->prelight_node &&
- tree_view->priv->arrow_prelit)
- state |= GTK_STATE_FLAG_PRELIGHT;
- }
+ state = gtk_cell_renderer_get_state (NULL, widget, flags);
if (node->children != NULL)
state |= GTK_STATE_FLAG_ACTIVE;
+ else
+ state &= ~(GTK_STATE_FLAG_ACTIVE);
gtk_style_context_save (context);
return;
cursor_path = NULL;
- if (tree_view->priv->cursor)
- cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
+ if (tree_view->priv->cursor_node)
+ cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node);
if (cursor_path == NULL)
{
if (selected_rows)
{
cursor_path = gtk_tree_path_copy((const GtkTreePath *)(selected_rows->data));
- g_list_foreach (selected_rows, (GFunc)gtk_tree_path_free, NULL);
- g_list_free (selected_rows);
+ g_list_free_full (selected_rows, (GDestroyNotify) gtk_tree_path_free);
}
else
{
TRUE, NULL, NULL);
}
- gtk_tree_row_reference_free (tree_view->priv->cursor);
- tree_view->priv->cursor = NULL;
-
if (cursor_path)
{
if (gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE)
- gtk_tree_view_real_set_cursor (tree_view, cursor_path, FALSE, FALSE);
+ gtk_tree_view_real_set_cursor (tree_view, cursor_path, 0);
else
- gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE);
+ gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT);
}
}
{
GtkCellArea *cell_area;
- tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (list->data);
+ _gtk_tree_view_set_focus_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data));
/* This happens when the treeview initially grabs focus and there
* is no column in focus, here we explicitly focus into the first cell */
gint count)
{
gint selection_count;
- GtkRBTree *cursor_tree = NULL;
- GtkRBNode *cursor_node = NULL;
GtkRBTree *new_cursor_tree = NULL;
GtkRBNode *new_cursor_node = NULL;
GtkTreePath *cursor_path = NULL;
if (! gtk_widget_has_focus (GTK_WIDGET (tree_view)))
return;
- cursor_path = NULL;
- if (!gtk_tree_row_reference_valid (tree_view->priv->cursor))
- /* FIXME: we lost the cursor; should we get the first? */
+ if (tree_view->priv->cursor_node == NULL)
return;
- cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
- _gtk_tree_view_find_node (tree_view, cursor_path,
- &cursor_tree, &cursor_node);
-
- if (cursor_tree == NULL)
- /* FIXME: we lost the cursor; should we get the first? */
- return;
+ cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node);
direction = count < 0 ? GTK_DIR_UP : GTK_DIR_DOWN;
{
gtk_tree_view_column_cell_set_cell_data (tree_view->priv->focus_column,
tree_view->priv->model,
- &iter,
- GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT),
- cursor_node->children?TRUE:FALSE);
+ &iter,
+ GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_PARENT),
+ tree_view->priv->cursor_node->children ? TRUE : FALSE);
/* Save the last cell that had focus, if we hit the end of the view we'll give
* focus back to it. */
selection_count = gtk_tree_selection_count_selected_rows (tree_view->priv->selection);
selectable = _gtk_tree_selection_row_is_selectable (tree_view->priv->selection,
- cursor_node,
+ tree_view->priv->cursor_node,
cursor_path);
if (selection_count == 0
&& selectable)
{
/* Don't move the cursor, but just select the current node */
- new_cursor_tree = cursor_tree;
- new_cursor_node = cursor_node;
+ new_cursor_tree = tree_view->priv->cursor_tree;
+ new_cursor_node = tree_view->priv->cursor_node;
}
else
{
if (count == -1)
- _gtk_rbtree_prev_full (cursor_tree, cursor_node,
+ _gtk_rbtree_prev_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
&new_cursor_tree, &new_cursor_node);
else
- _gtk_rbtree_next_full (cursor_tree, cursor_node,
+ _gtk_rbtree_next_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
&new_cursor_tree, &new_cursor_node);
}
if (new_cursor_node)
{
- cursor_path = _gtk_tree_view_find_path (tree_view,
- new_cursor_tree, new_cursor_node);
+ cursor_path = _gtk_tree_path_new_from_rbtree (new_cursor_tree, new_cursor_node);
search_first_focusable_path (tree_view, &cursor_path,
(count != -1),
new_cursor_node == NULL)
{
if (count == -1)
- _gtk_rbtree_next_full (cursor_tree, cursor_node,
+ _gtk_rbtree_next_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
&new_cursor_tree, &new_cursor_node);
else
- _gtk_rbtree_prev_full (cursor_tree, cursor_node,
+ _gtk_rbtree_prev_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
&new_cursor_tree, &new_cursor_node);
if (new_cursor_node == NULL
- && !GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_SELECTED))
+ && !GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_SELECTED))
{
- new_cursor_node = cursor_node;
- new_cursor_tree = cursor_tree;
+ new_cursor_node = tree_view->priv->cursor_node;
+ new_cursor_tree = tree_view->priv->cursor_tree;
}
else
{
+ new_cursor_tree = NULL;
new_cursor_node = NULL;
}
}
if (new_cursor_node)
{
- cursor_path = _gtk_tree_view_find_path (tree_view, new_cursor_tree, new_cursor_node);
- gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, TRUE);
+ cursor_path = _gtk_tree_path_new_from_rbtree (new_cursor_tree, new_cursor_node);
+ gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT | CLAMP_NODE);
gtk_tree_path_free (cursor_path);
/* Give focus to the area in the new row */
}
else
{
- gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
+ gtk_tree_view_clamp_node_visible (tree_view,
+ tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node);
if (!tree_view->priv->extend_selection_pressed)
{
gtk_tree_view_move_cursor_page_up_down (GtkTreeView *tree_view,
gint count)
{
- GtkRBTree *cursor_tree = NULL;
- GtkRBNode *cursor_node = NULL;
GtkTreePath *old_cursor_path = NULL;
GtkTreePath *cursor_path = NULL;
GtkRBTree *start_cursor_tree = NULL;
GtkRBNode *start_cursor_node = NULL;
+ GtkRBTree *cursor_tree;
+ GtkRBNode *cursor_node;
gint y;
gint window_y;
gint vertical_separator;
if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
return;
- if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
- old_cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
- else
- /* This is sorta weird. Focus in should give us a cursor */
+ if (tree_view->priv->cursor_node == NULL)
return;
- gtk_widget_style_get (GTK_WIDGET (tree_view), "vertical-separator", &vertical_separator, NULL);
- _gtk_tree_view_find_node (tree_view, old_cursor_path,
- &cursor_tree, &cursor_node);
+ old_cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node);
- if (cursor_tree == NULL)
- {
- /* FIXME: we lost the cursor. Should we try to get one? */
- gtk_tree_path_free (old_cursor_path);
- return;
- }
- g_return_if_fail (cursor_node != NULL);
+ gtk_widget_style_get (GTK_WIDGET (tree_view), "vertical-separator", &vertical_separator, NULL);
- y = _gtk_rbtree_node_find_offset (cursor_tree, cursor_node);
+ y = _gtk_rbtree_node_find_offset (tree_view->priv->cursor_tree, tree_view->priv->cursor_node);
window_y = RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, y);
y += tree_view->priv->cursor_offset;
y += count * (int)gtk_adjustment_get_page_increment (tree_view->priv->vadjustment);
}
y -= tree_view->priv->cursor_offset;
- cursor_path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
+ cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
start_cursor_tree = cursor_tree;
start_cursor_node = cursor_node;
*/
cursor_tree = start_cursor_tree;
cursor_node = start_cursor_node;
- cursor_path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
+ cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
search_first_focusable_path (tree_view, &cursor_path,
(count == -1),
/* update y */
y = _gtk_rbtree_node_find_offset (cursor_tree, cursor_node);
- gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE);
+ gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT);
y -= window_y;
gtk_tree_view_scroll_to_point (tree_view, -1, y);
gtk_tree_view_move_cursor_left_right (GtkTreeView *tree_view,
gint count)
{
- GtkRBTree *cursor_tree = NULL;
- GtkRBNode *cursor_node = NULL;
GtkTreePath *cursor_path = NULL;
GtkTreeViewColumn *column;
GtkTreeIter iter;
if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
return;
- if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
- cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
- else
+ if (tree_view->priv->cursor_node == NULL)
return;
- _gtk_tree_view_find_node (tree_view, cursor_path, &cursor_tree, &cursor_node);
- if (cursor_tree == NULL)
- return;
+ cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node);
+
if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path) == FALSE)
{
gtk_tree_path_free (cursor_path);
gtk_tree_view_column_cell_set_cell_data (column,
tree_view->priv->model,
&iter,
- GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT),
- cursor_node->children?TRUE:FALSE);
+ GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_PARENT),
+ tree_view->priv->cursor_node->children ? TRUE : FALSE);
cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
if (gtk_cell_area_focus (cell_area, direction))
{
- tree_view->priv->focus_column = column;
+ _gtk_tree_view_set_focus_column (tree_view, column);
found_column = TRUE;
break;
}
{
if (!gtk_tree_view_has_can_focus_cell (tree_view))
_gtk_tree_view_queue_draw_node (tree_view,
- cursor_tree,
- cursor_node,
+ tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node,
NULL);
g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
gtk_widget_grab_focus (GTK_WIDGET (tree_view));
gtk_tree_view_get_cursor (tree_view, &old_path, NULL);
cursor_tree = tree_view->priv->tree;
- cursor_node = cursor_tree->root;
if (count == -1)
{
- while (cursor_node && cursor_node->left != cursor_tree->nil)
- cursor_node = cursor_node->left;
+ cursor_node = _gtk_rbtree_first (cursor_tree);
/* Now go forward to find the first focusable row. */
- path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
+ path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
search_first_focusable_path (tree_view, &path,
TRUE, &cursor_tree, &cursor_node);
}
else
{
+ cursor_node = cursor_tree->root;
+
do
{
- while (cursor_node && cursor_node->right != cursor_tree->nil)
+ while (cursor_node && !_gtk_rbtree_is_nil (cursor_node->right))
cursor_node = cursor_node->right;
if (cursor_node->children == NULL)
break;
while (1);
/* Now go backwards to find last focusable row. */
- path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
+ path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
search_first_focusable_path (tree_view, &path,
FALSE, &cursor_tree, &cursor_node);
}
if (gtk_tree_path_compare (old_path, path))
{
- gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE);
+ gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CLAMP_NODE);
gtk_widget_grab_focus (GTK_WIDGET (tree_view));
}
else
if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
return FALSE;
- if (tree_view->priv->cursor)
- cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
-
- if (cursor_path == NULL)
+ if (tree_view->priv->cursor_node == NULL)
return FALSE;
+ cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node);
+
_gtk_tree_view_find_node (tree_view, cursor_path,
&cursor_tree, &cursor_node);
{
GtkRBTree *new_tree = NULL;
GtkRBNode *new_node = NULL;
- GtkRBTree *cursor_tree = NULL;
- GtkRBNode *cursor_node = NULL;
GtkTreePath *cursor_path = NULL;
if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
return FALSE;
- cursor_path = NULL;
- if (tree_view->priv->cursor)
- cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
-
- if (cursor_path == NULL)
+ if (tree_view->priv->cursor_node == NULL)
return FALSE;
- _gtk_tree_view_find_node (tree_view, cursor_path,
- &cursor_tree, &cursor_node);
- if (cursor_tree == NULL)
- {
- gtk_tree_path_free (cursor_path);
- return FALSE;
- }
+ cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node);
_gtk_tree_selection_internal_select_node (tree_view->priv->selection,
- cursor_node,
- cursor_tree,
+ tree_view->priv->cursor_node,
+ tree_view->priv->cursor_tree,
cursor_path,
GTK_TREE_SELECT_MODE_TOGGLE,
FALSE);
*/
_gtk_tree_view_find_node (tree_view, cursor_path, &new_tree, &new_node);
- if (cursor_tree != new_tree || cursor_node != new_node)
+ if (tree_view->priv->cursor_node != new_node)
return FALSE;
- gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
+ gtk_tree_view_clamp_node_visible (tree_view,
+ tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node);
gtk_widget_grab_focus (GTK_WIDGET (tree_view));
gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
gboolean open_all)
{
GtkTreePath *cursor_path = NULL;
- GtkRBTree *tree;
- GtkRBNode *node;
if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
return FALSE;
- cursor_path = NULL;
- if (tree_view->priv->cursor)
- cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
-
- if (cursor_path == NULL)
+ if (tree_view->priv->cursor_node == NULL)
return FALSE;
- if (_gtk_tree_view_find_node (tree_view, cursor_path, &tree, &node))
- return FALSE;
+ cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node);
/* Don't handle the event if we aren't an expander */
- if (!((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT))
+ if (!GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_PARENT))
return FALSE;
if (!logical
expand = !expand;
if (expand)
- gtk_tree_view_real_expand_row (tree_view, cursor_path, tree, node, open_all, TRUE);
+ gtk_tree_view_real_expand_row (tree_view,
+ cursor_path,
+ tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node,
+ open_all,
+ TRUE);
else
- gtk_tree_view_real_collapse_row (tree_view, cursor_path, tree, node, TRUE);
+ gtk_tree_view_real_collapse_row (tree_view,
+ cursor_path,
+ tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node,
+ TRUE);
gtk_tree_path_free (cursor_path);
static gboolean
gtk_tree_view_real_select_cursor_parent (GtkTreeView *tree_view)
{
- GtkRBTree *cursor_tree = NULL;
- GtkRBNode *cursor_node = NULL;
GtkTreePath *cursor_path = NULL;
GdkModifierType state;
if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
goto out;
- cursor_path = NULL;
- if (tree_view->priv->cursor)
- cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
-
- if (cursor_path == NULL)
+ if (tree_view->priv->cursor_node == NULL)
goto out;
- _gtk_tree_view_find_node (tree_view, cursor_path,
- &cursor_tree, &cursor_node);
- if (cursor_tree == NULL)
- {
- gtk_tree_path_free (cursor_path);
- goto out;
- }
+ cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node);
- if (cursor_tree->parent_node)
+ if (tree_view->priv->cursor_tree->parent_node)
{
gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
- cursor_node = cursor_tree->parent_node;
- cursor_tree = cursor_tree->parent_tree;
gtk_tree_path_up (cursor_path);
tree_view->priv->modify_selection_pressed = TRUE;
}
- gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE);
- gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
+ gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT | CLAMP_NODE);
+ gtk_tree_path_free (cursor_path);
gtk_widget_grab_focus (GTK_WIDGET (tree_view));
- gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
- gtk_tree_path_free (cursor_path);
tree_view->priv->modify_selection_pressed = FALSE;
gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
tree_view->priv->drag_dest_row = NULL;
- gtk_tree_row_reference_free (tree_view->priv->cursor);
- tree_view->priv->cursor = NULL;
gtk_tree_row_reference_free (tree_view->priv->anchor);
tree_view->priv->anchor = NULL;
gtk_tree_row_reference_free (tree_view->priv->top_row);
{
tree_view->priv->tree = _gtk_rbtree_new ();
gtk_tree_view_build_tree (tree_view, tree_view->priv->tree, &iter, 1, FALSE);
+ _gtk_tree_view_accessible_add (tree_view, tree_view->priv->tree, NULL);
}
gtk_tree_path_free (path);
install_presize_handler (tree_view);
}
+ gtk_tree_view_real_set_cursor (tree_view, NULL, CURSOR_INVALID);
+
g_object_notify (G_OBJECT (tree_view), "model");
if (tree_view->priv->selection)
{
g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
+ return gtk_tree_view_do_get_hadjustment (tree_view);
+}
+
+static GtkAdjustment *
+gtk_tree_view_do_get_hadjustment (GtkTreeView *tree_view)
+{
return tree_view->priv->hadjustment;
}
gtk_tree_view_set_hadjustment (GtkTreeView *tree_view,
GtkAdjustment *adjustment)
{
- GtkTreeViewPrivate *priv = tree_view->priv;
-
g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
g_return_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment));
+ gtk_tree_view_do_set_hadjustment (tree_view, adjustment);
+}
+
+static void
+gtk_tree_view_do_set_hadjustment (GtkTreeView *tree_view,
+ GtkAdjustment *adjustment)
+{
+ GtkTreeViewPrivate *priv = tree_view->priv;
+
if (adjustment && priv->hadjustment == adjustment)
return;
{
g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
+ return gtk_tree_view_do_get_vadjustment (tree_view);
+}
+
+static GtkAdjustment *
+gtk_tree_view_do_get_vadjustment (GtkTreeView *tree_view)
+{
return tree_view->priv->vadjustment;
}
gtk_tree_view_set_vadjustment (GtkTreeView *tree_view,
GtkAdjustment *adjustment)
{
- GtkTreeViewPrivate *priv = tree_view->priv;
-
g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
g_return_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment));
+ gtk_tree_view_do_set_vadjustment (tree_view, adjustment);
+}
+
+static void
+gtk_tree_view_do_set_vadjustment (GtkTreeView *tree_view,
+ GtkAdjustment *adjustment)
+{
+ GtkTreeViewPrivate *priv = tree_view->priv;
+
if (adjustment && priv->vadjustment == adjustment)
return;
gtk_tree_view_remove_column (GtkTreeView *tree_view,
GtkTreeViewColumn *column)
{
+ guint position;
+
g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
g_return_val_if_fail (gtk_tree_view_column_get_tree_view (column) == GTK_WIDGET (tree_view), -1);
if (tree_view->priv->focus_column == column)
- tree_view->priv->focus_column = NULL;
+ _gtk_tree_view_set_focus_column (tree_view, NULL);
if (tree_view->priv->edited_column == column)
{
_gtk_tree_view_column_unset_tree_view (column);
+ position = g_list_index (tree_view->priv->columns, column);
+
tree_view->priv->columns = g_list_remove (tree_view->priv->columns, column);
tree_view->priv->n_columns--;
_gtk_tree_view_reset_header_styles (tree_view);
+ _gtk_tree_view_accessible_remove_column (tree_view, column, position);
+
g_object_unref (column);
g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
g_return_val_if_fail (gtk_tree_view_column_get_sizing (column)
== GTK_TREE_VIEW_COLUMN_FIXED, -1);
+ if (position < 0 || position > tree_view->priv->n_columns)
+ position = tree_view->priv->n_columns;
+
g_object_ref_sink (column);
if (tree_view->priv->n_columns == 0 &&
}
_gtk_tree_view_reset_header_styles (tree_view);
+
+ _gtk_tree_view_accessible_add_column (tree_view, column, position);
+
g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
return tree_view->priv->n_columns;
va_end (args);
- gtk_tree_view_insert_column (tree_view, column, position);
-
- return tree_view->priv->n_columns;
+ return gtk_tree_view_insert_column (tree_view, column, position);
}
/**
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_set_cell_data_func (column, cell, func, data, dnotify);
- gtk_tree_view_insert_column (tree_view, column, position);
+ return gtk_tree_view_insert_column (tree_view, column, position);
+}
+
+/**
+ * gtk_tree_view_get_n_columns:
+ * @tree_view: a #GtkTreeView
+ *
+ * Queries the number of columns in the given @tree_view.
+ *
+ * Returns: The number of columns in the @tree_view
+ *
+ * Since: 3.4
+ **/
+guint
+gtk_tree_view_get_n_columns (GtkTreeView *tree_view)
+{
+ g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
return tree_view->priv->n_columns;
}
}
_gtk_tree_view_reset_header_styles (tree_view);
+
+ _gtk_tree_view_accessible_reorder_column (tree_view, column);
+
g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
}
{
g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
+ g_return_if_fail (column == NULL || gtk_tree_view_column_get_tree_view (column) == GTK_WIDGET (tree_view));
if (tree_view->priv->expander_column != column)
{
- GList *list;
-
- if (column)
- {
- /* Confirm that column is in tree_view */
- for (list = tree_view->priv->columns; list; list = list->next)
- if (list->data == column)
- break;
- g_return_if_fail (list != NULL);
- }
-
tree_view->priv->expander_column = column;
g_object_notify (G_OBJECT (tree_view), "expander-column");
}
GtkTreePath *path;
GtkTreeIter iter;
- path = _gtk_tree_view_find_path (tree_view, tree, node);
+ path = _gtk_tree_path_new_from_rbtree (tree, node);
gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path);
indices = gtk_tree_path_get_indices (path);
tree = tree_view->priv->tree;
- node = tree->root;
- while (node && node->left != tree->nil)
- node = node->left;
+ node = _gtk_rbtree_first (tree);
while (node)
{
gtk_tree_path_append_index (tmp_path, 0);
tree = node->children;
- node = tree->root;
- while (node->left != tree->nil)
- node = node->left;
+ node = _gtk_rbtree_first (tree);
/* try to expand the children */
do
{
gtk_tree_path_get_depth (path) + 1,
open_all);
+ _gtk_tree_view_accessible_add (tree_view, node->children, NULL);
+ _gtk_tree_view_accessible_add_state (tree_view,
+ tree, node,
+ GTK_CELL_RENDERER_EXPANDED);
+
if (animate)
{
GtkStyleContext *context;
gint x, y;
GList *list;
GdkWindow *child;
+ gboolean selection_changed, cursor_changed;
if (animate)
g_object_get (gtk_widget_get_settings (GTK_WIDGET (tree_view)),
gtk_tree_path_free (child_path);
}
- if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
+ if (tree_view->priv->cursor_node)
{
- GtkTreePath *cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
-
- if (gtk_tree_path_is_ancestor (path, cursor_path))
- {
- gtk_tree_row_reference_free (tree_view->priv->cursor);
- tree_view->priv->cursor = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
- tree_view->priv->model,
- path);
- }
- gtk_tree_path_free (cursor_path);
+ cursor_changed = (node->children == tree_view->priv->cursor_tree)
+ || _gtk_rbtree_contains (node->children, tree_view->priv->cursor_tree);
}
+ else
+ cursor_changed = FALSE;
if (gtk_tree_row_reference_valid (tree_view->priv->anchor))
{
gtk_tree_path_free (anchor_path);
}
+ selection_changed = gtk_tree_view_unref_and_check_selection_tree (tree_view, node->children);
+
/* Stop a pending double click */
tree_view->priv->last_button_x = -1;
tree_view->priv->last_button_y = -1;
- if (gtk_tree_view_unref_and_check_selection_tree (tree_view, node->children))
- {
- _gtk_rbtree_remove (node->children);
- g_signal_emit_by_name (tree_view->priv->selection, "changed");
- }
- else
- _gtk_rbtree_remove (node->children);
+ _gtk_tree_view_accessible_remove (tree_view, node->children, NULL);
+ _gtk_tree_view_accessible_remove_state (tree_view,
+ tree, node,
+ GTK_CELL_RENDERER_EXPANDED);
+
+ _gtk_rbtree_remove (node->children);
+
+ if (cursor_changed)
+ gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CURSOR_INVALID);
+ if (selection_changed)
+ g_signal_emit_by_name (tree_view->priv->selection, "changed");
if (animate)
{
if (tree == NULL || tree->root == NULL)
return;
- node = tree->root;
-
- while (node && node->left != tree->nil)
- node = node->left;
+ node = _gtk_rbtree_first (tree);
while (node)
{
static void
gtk_tree_view_real_set_cursor (GtkTreeView *tree_view,
GtkTreePath *path,
- gboolean clear_and_select,
- gboolean clamp_node)
+ SetCursorFlags flags)
{
- GtkRBTree *tree = NULL;
- GtkRBNode *node = NULL;
-
- if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
+ if (!(flags & CURSOR_INVALID) && tree_view->priv->cursor_node)
{
- GtkTreePath *cursor_path;
- cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
- gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
- gtk_tree_path_free (cursor_path);
+ _gtk_tree_view_queue_draw_node (tree_view,
+ tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node,
+ NULL);
}
- gtk_tree_row_reference_free (tree_view->priv->cursor);
- tree_view->priv->cursor = NULL;
-
/* One cannot set the cursor on a separator. Also, if
* _gtk_tree_view_find_node returns TRUE, it ran out of tree
* before finding the tree and node belonging to path. The
* path maps to a non-existing path and we will silently bail out.
* We unset tree and node to avoid further processing.
*/
- if (!row_is_separator (tree_view, NULL, path)
- && _gtk_tree_view_find_node (tree_view, path, &tree, &node) == FALSE)
+ if (path == NULL ||
+ row_is_separator (tree_view, NULL, path)
+ || _gtk_tree_view_find_node (tree_view,
+ path,
+ &tree_view->priv->cursor_tree,
+ &tree_view->priv->cursor_node))
{
- tree_view->priv->cursor =
- gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
- tree_view->priv->model,
- path);
- }
- else
- {
- tree = NULL;
- node = NULL;
+ tree_view->priv->cursor_tree = NULL;
+ tree_view->priv->cursor_node = NULL;
}
- if (tree != NULL)
+ if (tree_view->priv->cursor_node != NULL)
{
GtkRBTree *new_tree = NULL;
GtkRBNode *new_node = NULL;
- if (clear_and_select && !tree_view->priv->modify_selection_pressed)
+ if ((flags & CLEAR_AND_SELECT) && !tree_view->priv->modify_selection_pressed)
{
GtkTreeSelectMode mode = 0;
mode |= GTK_TREE_SELECT_MODE_EXTEND;
_gtk_tree_selection_internal_select_node (tree_view->priv->selection,
- node, tree, path, mode,
+ tree_view->priv->cursor_node,
+ tree_view->priv->cursor_tree,
+ path,
+ mode,
FALSE);
}
*/
_gtk_tree_view_find_node (tree_view, path, &new_tree, &new_node);
- if (tree != new_tree || node != new_node)
+ if (tree_view->priv->cursor_node != new_node)
return;
- if (clamp_node)
+ if (flags & CLAMP_NODE)
{
- gtk_tree_view_clamp_node_visible (tree_view, tree, node);
- _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
+ gtk_tree_view_clamp_node_visible (tree_view,
+ tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node);
+ _gtk_tree_view_queue_draw_node (tree_view,
+ tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node,
+ NULL);
}
}
if (path)
{
- if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
- *path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
+ if (tree_view->priv->cursor_node)
+ *path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node);
else
*path = NULL;
}
(gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->edited_column))))
gtk_tree_view_stop_editing (tree_view, TRUE);
- gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE);
+ gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CLAMP_NODE);
if (focus_column &&
gtk_tree_view_column_get_visible (focus_column))
break;
}
g_return_if_fail (column_in_tree);
- tree_view->priv->focus_column = focus_column;
+ _gtk_tree_view_set_focus_column (tree_view, focus_column);
if (focus_cell)
gtk_tree_view_column_focus_cell (focus_column, focus_cell);
if (start_editing)
*cell_y = y_offset;
if (path)
- *path = _gtk_tree_view_find_path (tree_view, tree, node);
+ *path = _gtk_tree_path_new_from_rbtree (tree, node);
return TRUE;
}
TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, 0),
&tree, &node);
if (node)
- *start_path = _gtk_tree_view_find_path (tree_view, tree, node);
+ *start_path = _gtk_tree_path_new_from_rbtree (tree, node);
else
retval = FALSE;
}
_gtk_rbtree_find_offset (tree_view->priv->tree, y, &tree, &node);
if (node)
- *end_path = _gtk_tree_view_find_path (tree_view, tree, node);
+ *end_path = _gtk_tree_path_new_from_rbtree (tree, node);
else
retval = FALSE;
}
GtkRBTree *tree;
GtkRBNode *node;
GtkStyleContext *context;
- GtkStateFlags state;
gint cell_offset;
GList *list;
GdkRectangle background_area;
gtk_style_context_save (context);
- state = gtk_widget_get_state_flags (widget);
- gtk_style_context_set_state (context, state);
-
gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW);
gtk_style_context_add_region (context, GTK_STYLE_REGION_COLUMN, 0);
{
GtkRegionFlags row_flags;
- if (_gtk_rbtree_node_find_parity (tree, node))
+ if ((_gtk_rbtree_node_get_index (tree, node) % 2))
row_flags = GTK_REGION_ODD;
else
row_flags = GTK_REGION_EVEN;
* This function should almost never be used. It is meant for private use by
* ATK for determining the number of visible children that are removed when the
* user collapses a row, or a row is deleted.
+ *
+ * Deprecated: 3.4: Accessibility does not need the function anymore.
**/
void
gtk_tree_view_set_destroy_count_func (GtkTreeView *tree_view,
GdkRectangle monitor;
monitor_num = gdk_screen_get_monitor_at_window (screen, tree_window);
- gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
+ gdk_screen_get_monitor_workarea (screen, monitor_num, &monitor);
gtk_widget_realize (search_dialog);
GtkTreeView *tree_view)
{
GtkTreePath *path;
- GtkRBNode *node;
- GtkRBTree *tree;
gtk_tree_view_search_dialog_hide (tree_view->priv->search_window,
tree_view,
/* If we have a row selected and it's the cursor row, we activate
* the row XXX */
- if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
+ if (tree_view->priv->cursor_node &&
+ GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_SELECTED))
{
- path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
-
- _gtk_tree_view_find_node (tree_view, path, &tree, &node);
+ path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node);
- if (node && GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
- gtk_tree_view_row_activated (tree_view, path, tree_view->priv->focus_column);
+ gtk_tree_view_row_activated (tree_view, path, tree_view->priv->focus_column);
gtk_tree_path_free (path);
}
gtk_tree_view_scroll_to_cell (tree_view, path, NULL,
TRUE, 0.5, 0.0);
gtk_tree_selection_select_iter (selection, iter);
- gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
+ gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
if (path)
gtk_tree_path_free (path);
GtkTreeIter tmp;
tree = node->children;
- node = tree->root;
-
- while (node->left != tree->nil)
- node = node->left;
+ node = _gtk_rbtree_first (tree);
tmp = *iter;
has_child = gtk_tree_model_iter_children (model, iter, &tmp);
tree_view->priv->edited_column = column;
- gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
+ gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
cell_area->y += pre_val - (int)gtk_adjustment_get_value (tree_view->priv->vadjustment);
gtk_widget_get_preferred_size (GTK_WIDGET (cell_editable),
GtkStateFlags previous_state)
{
if (gtk_widget_get_realized (widget))
- {
- GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
- GtkStyleContext *context;
-
- context = gtk_widget_get_style_context (widget);
- gtk_style_context_set_background (context, tree_view->priv->bin_window);
- }
+ gtk_tree_view_ensure_background (GTK_TREE_VIEW (widget));
gtk_widget_queue_draw (widget);
}
* @x: (inout): the x coordinate (relative to widget coordinates)
* @y: (inout): the y coordinate (relative to widget coordinates)
* @keyboard_tip: whether this is a keyboard tooltip or not
- * @model: (out) (allow-none): a pointer to receive a #GtkTreeModel or %NULL
+ * @model: (out) (allow-none) (transfer none): a pointer to receive a
+ * #GtkTreeModel or %NULL
* @path: (out) (allow-none): a pointer to receive a #GtkTreePath or %NULL
* @iter: (out) (allow-none): a pointer to receive a #GtkTreeIter or %NULL
*