* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include <string.h>
#include "gtktreeview.h"
+
+#include "gtkadjustment.h"
#include "gtkrbtree.h"
#include "gtktreednd.h"
#include "gtktreeprivate.h"
#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 "gtksettings.h"
+#include "gtkwidgetpath.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.
*/
guint scroll_sync_timer;
/* Indentation and expander layout */
- gint expander_size;
GtkTreeViewColumn *expander_column;
gint level_indentation;
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_set_background (context, gtk_widget_get_window (GTK_WIDGET (tree_view)));
+ 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.height = allocation.height;
attributes.event_mask = (GDK_EXPOSURE_MASK |
GDK_SCROLL_MASK |
+ GDK_SMOOTH_SCROLL_MASK |
GDK_POINTER_MOTION_MASK |
GDK_ENTER_NOTIFY_MASK |
GDK_LEAVE_NOTIFY_MASK |
&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)
{
GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
GtkTreeViewPrivate *priv = tree_view->priv;
- GtkStyleContext *context;
GList *list;
if (priv->scroll_timeout != 0)
priv->open_dest_timeout = 0;
}
- context = gtk_widget_get_style_context (widget);
- gtk_style_context_cancel_animations (context, NULL);
-
if (priv->presize_handler_timer != 0)
{
g_source_remove (priv->presize_handler_timer);
return is_separator;
}
+static int
+gtk_tree_view_get_expander_size (GtkTreeView *tree_view)
+{
+ gint expander_size;
+
+ gtk_widget_style_get (GTK_WIDGET (tree_view),
+ "expander-size", &expander_size,
+ NULL);
+ expander_size += EXPANDER_EXTRA_PADDING;
+
+ return expander_size;
+}
+
static gboolean
gtk_tree_view_button_press (GtkWidget *widget,
GdkEventButton *event)
"horizontal-separator", &horizontal_separator,
NULL);
+ /* Don't handle extra mouse buttons events, let them bubble up */
+ if (event->button > 5)
+ return FALSE;
+
/* Because grab_focus can cause reentrancy, we delay grab_focus until after
* we're done handling the button press.
*/
tree_view->priv->arrow_prelit &&
gtk_tree_view_draw_expanders (tree_view))
{
- if (event->button == 1)
+ if (event->button == GDK_BUTTON_PRIMARY)
{
gtk_grab_add (widget);
tree_view->priv->button_pressed_node = tree_view->priv->prelight_node;
}
/* 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)
if (gtk_tree_view_draw_expanders (tree_view))
{
+ gint expander_size = gtk_tree_view_get_expander_size (tree_view);
if (!rtl)
- cell_area.x += depth * tree_view->priv->expander_size;
- cell_area.width -= depth * tree_view->priv->expander_size;
+ cell_area.x += depth * expander_size;
+ cell_area.width -= depth * expander_size;
}
}
break;
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->type == GDK_BUTTON_PRESS && event->button == GDK_BUTTON_PRIMARY &&
!(event->state & gtk_accelerator_get_default_mod_mask ()))
{
GtkTreePath *anchor;
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;
}
/* Test if a double click happened on the same row. */
- if (event->button == 1 && event->type == GDK_BUTTON_PRESS)
+ if (event->button == GDK_BUTTON_PRIMARY && event->type == GDK_BUTTON_PRESS)
{
int double_click_time, double_click_distance;
tree_view->priv->cur_reorder->left_column);
}
tree_view->priv->drag_column = NULL;
- gdk_window_hide (tree_view->priv->drag_window);
+ gdk_window_destroy (tree_view->priv->drag_window);
+ tree_view->priv->drag_window = NULL;
for (l = tree_view->priv->column_drag_info; l != NULL; l = l->next)
g_slice_free (GtkTreeViewColumnReorder, l->data);
if (tree_view->priv->button_pressed_node == NULL)
return FALSE;
- if (event->button == 1)
+ if (event->button == GDK_BUTTON_PRIMARY)
{
if (tree_view->priv->button_pressed_node == tree_view->priv->prelight_node &&
tree_view->priv->arrow_prelit)
{
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);
}
GtkAllocation button_allocation;
GtkWidget *button;
- width = tree_view->priv->expander_size;
+ width = gtk_tree_view_get_expander_size (tree_view);
/* Get x, y, width, height of arrow */
gdk_window_get_origin (tree_view->priv->header_window, &x, &y);
x += button_allocation.x - width/2;
height = button_allocation.height;
}
- y -= tree_view->priv->expander_size/2; /* The arrow takes up only half the space */
- height += tree_view->priv->expander_size;
+ y -= width/2; /* The arrow takes up only half the space */
+ height += width;
/* Create the new window */
if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW)
{
GtkAllocation allocation;
GtkWidget *button;
+ gint expander_size;
- width = tree_view->priv->expander_size;
+ expander_size = gtk_tree_view_get_expander_size (tree_view);
/* Get x, y, width, height of arrow */
- width = width/2; /* remember, the arrow only takes half the available width */
+ width = expander_size/2; /* remember, the arrow only takes half the available width */
gdk_window_get_origin (gtk_widget_get_window (widget),
&x, &y);
if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
height = allocation.height;
}
- y -= tree_view->priv->expander_size;
- height += 2*tree_view->priv->expander_size;
+ y -= expander_size;
+ height += 2 * expander_size;
/* Create the new window */
if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT &&
attributes.y = y;
attributes.width = width;
attributes.height = height;
- tree_view->priv->drag_highlight_window = gdk_window_new (NULL, &attributes, attributes_mask);
+ tree_view->priv->drag_highlight_window = gdk_window_new (gtk_widget_get_root_window (widget), &attributes, attributes_mask);
gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
}
cairo_move_to (cr, 0, 0);
cairo_line_to (cr, width, width);
- cairo_line_to (cr, 0, tree_view->priv->expander_size);
+ cairo_line_to (cr, 0, expander_size);
cairo_move_to (cr, 0, height);
cairo_line_to (cr, width, height - width);
- cairo_line_to (cr, 0, height - tree_view->priv->expander_size);
+ cairo_line_to (cr, 0, height - expander_size);
cairo_fill (cr);
cairo_destroy (cr);
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 horizontal_separator;
- gint focus_line_width;
gboolean allow_rules;
gboolean has_can_focus_cell;
gboolean rtl;
gint n_visible_columns;
gint grid_line_width;
+ gint expander_size;
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,
"vertical-separator", &vertical_separator,
"allow-rules", &allow_rules,
- "focus-line-width", &focus_line_width,
NULL);
if (tree_view->priv->tree == NULL)
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);
draw_hgrid_lines =
tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_HORIZONTAL
|| tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
+ expander_size = gtk_tree_view_get_expander_size (tree_view);
if (draw_vgrid_lines || draw_hgrid_lines)
gtk_widget_style_get (widget, "grid-line-width", &grid_line_width, NULL);
* 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))
if (gtk_tree_view_draw_expanders (tree_view))
{
+ int expander_size = gtk_tree_view_get_expander_size (tree_view);
if (!rtl)
- cell_area.x += depth * tree_view->priv->expander_size;
- cell_area.width -= depth * tree_view->priv->expander_size;
+ cell_area.x += depth * expander_size;
+ cell_area.width -= depth * expander_size;
}
/* If we have an expander column, the highlight underline
{
gtk_tree_view_draw_line (tree_view, cr,
GTK_TREE_VIEW_TREE_LINE,
- x + tree_view->priv->expander_size * (depth - 1.5) * mult,
+ x + expander_size * (depth - 1.5) * mult,
y1,
- x + tree_view->priv->expander_size * (depth - 1.1) * mult,
+ x + expander_size * (depth - 1.1) * mult,
y1);
}
else if (depth > 1)
{
gtk_tree_view_draw_line (tree_view, cr,
GTK_TREE_VIEW_TREE_LINE,
- x + tree_view->priv->expander_size * (depth - 1.5) * mult,
+ x + expander_size * (depth - 1.5) * mult,
y1,
- x + tree_view->priv->expander_size * (depth - 0.5) * mult,
+ x + expander_size * (depth - 0.5) * mult,
y1);
}
if (!_gtk_rbtree_next (tree, node))
gtk_tree_view_draw_line (tree_view, cr,
GTK_TREE_VIEW_TREE_LINE,
- x + tree_view->priv->expander_size * (depth - 1.5) * mult,
+ x + expander_size * (depth - 1.5) * mult,
y0,
- x + tree_view->priv->expander_size * (depth - 1.5) * mult,
+ x + expander_size * (depth - 1.5) * mult,
y1);
else
gtk_tree_view_draw_line (tree_view, cr,
GTK_TREE_VIEW_TREE_LINE,
- x + tree_view->priv->expander_size * (depth - 1.5) * mult,
+ x + expander_size * (depth - 1.5) * mult,
y0,
- x + tree_view->priv->expander_size * (depth - 1.5) * mult,
+ x + expander_size * (depth - 1.5) * mult,
y2);
tmp_node = tree->parent_node;
if (_gtk_rbtree_next (tmp_tree, tmp_node))
gtk_tree_view_draw_line (tree_view, cr,
GTK_TREE_VIEW_TREE_LINE,
- x + tree_view->priv->expander_size * (i - 0.5) * mult,
+ x + expander_size * (i - 0.5) * mult,
y0,
- x + tree_view->priv->expander_size * (i - 0.5) * mult,
+ x + expander_size * (i - 0.5) * mult,
y2);
tmp_node = tmp_tree->parent_node;
GtkRBTree *tree = NULL;
GtkRBNode *node = NULL;
+ gtk_style_context_save (context);
+ gtk_style_context_add_class (context, GTK_STYLE_CLASS_DND);
+
switch (tree_view->priv->drag_dest_pos)
{
case GTK_TREE_VIEW_DROP_BEFORE:
if (tree == NULL)
break;
- gtk_render_focus (context, cr,
- 0, gtk_tree_view_get_row_y_offset (tree_view, tree, node)
- - focus_line_width / 2,
- gdk_window_get_width (tree_view->priv->bin_window),
- gtk_tree_view_get_row_height (tree_view, node)
- - focus_line_width + 1);
+ gtk_render_frame (context, cr,
+ 0, gtk_tree_view_get_row_y_offset (tree_view, tree, node),
+ gdk_window_get_width (tree_view->priv->bin_window),
+ gtk_tree_view_get_row_height (tree_view, node));
break;
}
rtl ? 0 : bin_window_width,
highlight_y);
}
+
+ gtk_style_context_restore (context);
}
/* 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;
+ node = _gtk_rbtree_first (tree);
- g_assert (node != tree->nil);
-
- 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);
gint grid_line_width;
gboolean wide_separators;
gint separator_height;
+ gint expander_size;
/* double check the row needs validating */
if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) &&
draw_hgrid_lines =
tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_HORIZONTAL
|| tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
+ expander_size = gtk_tree_view_get_expander_size (tree_view);
for (last_column = g_list_last (tree_view->priv->columns);
last_column &&
{
row_height += vertical_separator;
height = MAX (height, row_height);
- height = MAX (height, tree_view->priv->expander_size);
+ height = MAX (height, expander_size);
}
else
{
padding += horizontal_separator + (depth - 1) * tree_view->priv->level_indentation;
if (gtk_tree_view_draw_expanders (tree_view))
- padding += depth * tree_view->priv->expander_size;
+ padding += depth * expander_size;
}
else
padding += horizontal_separator;
}
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);
}
}
}
-static void
-gtk_tree_view_bin_process_updates (GtkTreeView *tree_view)
-{
- /* Prior to drawing, we make sure the visible area is validated. */
- if (tree_view->priv->presize_handler_timer)
- {
- g_source_remove (tree_view->priv->presize_handler_timer);
- tree_view->priv->presize_handler_timer = 0;
-
- do_presize_handler (tree_view);
- }
-
- gdk_window_process_updates (tree_view->priv->bin_window, TRUE);
-}
-
static gboolean
scroll_sync_handler (GtkTreeView *tree_view)
{
}
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);
}
GtkTreeViewColumn *column = NULL;
GdkRectangle visible_rect;
- GDK_THREADS_ENTER ();
+ gdk_threads_enter ();
tree_view = GTK_TREE_VIEW (data);
}
}
- GDK_THREADS_LEAVE ();
+ gdk_threads_leave ();
return TRUE;
}
&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);
}
- gtk_widget_style_get (widget,
- "expander-size", &tree_view->priv->expander_size,
- NULL);
- tree_view->priv->expander_size += EXPANDER_EXTRA_PADDING;
-
for (list = tree_view->priv->columns; list; list = list->next)
{
column = list->data;
{
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;
}
}
GtkTreeView *tree_view = GTK_TREE_VIEW (container);
GtkWidgetPath *path;
gboolean rtl;
- GList *list;
+ GList *list, *visible_columns = NULL;
gint n_col = 0;
path = GTK_CONTAINER_CLASS (gtk_tree_view_parent_class)->get_path_for_child (container, child);
rtl = (gtk_widget_get_direction (GTK_WIDGET (container)) == GTK_TEXT_DIR_RTL);
- for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
- list;
- list = (rtl ? list->prev : list->next))
+ for (list = tree_view->priv->columns; list; list = list->next)
{
GtkTreeViewColumn *column = list->data;
- GtkRegionFlags flags = 0;
- if (!gtk_tree_view_column_get_visible (column))
- continue;
+ if (gtk_tree_view_column_get_visible (column))
+ visible_columns = g_list_prepend (visible_columns, column);
+ }
+
+ if (!rtl)
+ visible_columns = g_list_reverse (visible_columns);
+
+ for (list = visible_columns; list != NULL; list = list->next)
+ {
+ GtkTreeViewColumn *column = list->data;
+ GtkRegionFlags flags = 0;
n_col++;
if (n_col == 1)
flags |= GTK_REGION_FIRST;
- if ((rtl && !list->prev) ||
- (!rtl && !list->next))
+ if (!list->next)
flags |= GTK_REGION_LAST;
- gtk_widget_path_iter_add_region (path, -1, GTK_STYLE_REGION_COLUMN_HEADER, flags);
+ gtk_widget_path_iter_add_region (path, gtk_widget_path_length (path) - 2, GTK_STYLE_REGION_COLUMN_HEADER, flags);
break;
}
-
- gtk_widget_path_append_for_widget (path, child);
+ g_list_free (visible_columns);
return path;
}
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;
- GtkStyleContext *context;
+ gboolean selection_changed = FALSE, cursor_changed = FALSE;
+ GtkRBTree *cursor_tree = NULL;
+ GtkRBNode *cursor_node = NULL;
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);
}
tree_view->priv->top_row = NULL;
}
- /* Cancel any ongoing animation happening within the row */
- context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
- gtk_style_context_cancel_animations (context, node);
-
install_scroll_sync_handler (tree_view);
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);
GList *list;
GtkTreeViewColumn *tmp_column = NULL;
gint total_width;
+ gint expander_size;
gboolean indent_expanders;
gboolean rtl;
rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
+ expander_size = gtk_tree_view_get_expander_size (tree_view);
total_width = 0;
for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
if (gtk_tree_view_is_expander_column (tree_view, tmp_column))
{
if (rtl)
- x_offset = total_width + gtk_tree_view_column_get_width (tmp_column) - tree_view->priv->expander_size;
+ x_offset = total_width + gtk_tree_view_column_get_width (tmp_column) - expander_size;
else
x_offset = total_width;
break;
if (indent_expanders)
{
if (rtl)
- x_offset -= tree_view->priv->expander_size * _gtk_rbtree_get_depth (tree);
+ x_offset -= expander_size * _gtk_rbtree_get_depth (tree);
else
- x_offset += tree_view->priv->expander_size * _gtk_rbtree_get_depth (tree);
+ x_offset += expander_size * _gtk_rbtree_get_depth (tree);
}
*x1 = x_offset;
if (tmp_column &&
gtk_tree_view_column_get_visible (tmp_column))
/* +1 because x2 isn't included in the range. */
- *x2 = *x1 + tree_view->priv->expander_size + 1;
+ *x2 = *x1 + expander_size + 1;
else
*x2 = *x1;
}
+ 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.
- * if this is removed, we get a "selection streak" at the bottom. */
- gtk_tree_view_bin_process_updates (tree_view);
-
gtk_tree_view_scroll_to_cell (tree_view, path, NULL, FALSE, 0.0, 0.0);
gtk_tree_path_free (path);
}
/* 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);
GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
GtkWidget *button;
GdkDevice *pointer, *keyboard;
+ GdkWindowAttr attributes;
+ guint attributes_mask;
g_return_if_fail (tree_view->priv->column_drag_info == NULL);
g_return_if_fail (tree_view->priv->cur_reorder == NULL);
+ g_return_if_fail (tree_view->priv->drag_window == NULL);
gtk_tree_view_set_column_drag_info (tree_view, column);
button = gtk_tree_view_column_get_button (column);
- if (tree_view->priv->drag_window == NULL)
- {
- GdkWindowAttr attributes;
- guint attributes_mask;
-
- gtk_widget_get_allocation (button, &button_allocation);
+ gtk_widget_get_allocation (button, &button_allocation);
- attributes.window_type = GDK_WINDOW_CHILD;
- attributes.wclass = GDK_INPUT_OUTPUT;
- attributes.x = button_allocation.x;
- attributes.y = 0;
- attributes.width = button_allocation.width;
- attributes.height = button_allocation.height;
- attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
- attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
- attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
+ attributes.window_type = GDK_WINDOW_CHILD;
+ attributes.wclass = GDK_INPUT_OUTPUT;
+ attributes.x = button_allocation.x;
+ attributes.y = 0;
+ attributes.width = button_allocation.width;
+ attributes.height = button_allocation.height;
+ attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
+ attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
+ attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
- tree_view->priv->drag_window = gdk_window_new (tree_view->priv->bin_window,
- &attributes,
- attributes_mask);
- gdk_window_set_user_data (tree_view->priv->drag_window, GTK_WIDGET (tree_view));
- }
+ tree_view->priv->drag_window = gdk_window_new (tree_view->priv->bin_window,
+ &attributes,
+ attributes_mask);
+ gdk_window_set_user_data (tree_view->priv->drag_window, GTK_WIDGET (tree_view));
if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
{
send_event->button.y = -1;
send_event->button.axes = NULL;
send_event->button.state = 0;
- send_event->button.button = 1;
+ send_event->button.button = GDK_BUTTON_PRIMARY;
send_event->button.x_root = 0;
send_event->button.y_root = 0;
gdk_event_set_device (send_event, device);
gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
rect.x = 0;
- rect.width = MAX (tree_view->priv->expander_size, MAX (tree_view->priv->width, allocation.width));
+ rect.width = gtk_tree_view_get_expander_size (tree_view);
+ rect.width = MAX (rect.width, MAX (tree_view->priv->width, allocation.width));
rect.y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
rect.height = gtk_tree_view_get_row_height (tree_view, node);
return tree_view->priv->tree;
}
+gboolean
+_gtk_tree_view_get_cursor_node (GtkTreeView *tree_view,
+ GtkRBTree **tree,
+ GtkRBNode **node)
+{
+ GtkTreeViewPrivate *priv;
+
+ priv = tree_view->priv;
+
+ if (priv->cursor_node == NULL)
+ return FALSE;
+
+ *tree = priv->cursor_tree;
+ *node = priv->cursor_node;
+
+ return TRUE;
+}
+
GdkWindow *
_gtk_tree_view_get_header_window (GtkTreeView *tree_view)
{
return tree_view->priv->header_window;
}
+GtkTreeViewColumn *
+_gtk_tree_view_get_focus_column (GtkTreeView *tree_view)
+{
+ return tree_view->priv->focus_column;
+}
+
void
_gtk_tree_view_set_focus_column (GtkTreeView *tree_view,
GtkTreeViewColumn *column)
{
+ GtkTreeViewColumn *old_column = tree_view->priv->focus_column;
+
+ if (old_column == column)
+ return;
+
tree_view->priv->focus_column = column;
+
+ _gtk_tree_view_accessible_update_focus_column (tree_view,
+ old_column,
+ column);
}
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);
gtk_widget_style_get (widget,
- "vertical-separator", &vertical_separator,
- NULL);
- expander_size = tree_view->priv->expander_size - EXPANDER_EXTRA_PADDING;
+ "vertical-separator", &vertical_separator,
+ NULL);
+ expander_size = gtk_tree_view_get_expander_size (tree_view) - EXPANDER_EXTRA_PADDING;
if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
return;
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);
gtk_style_context_set_state (context, state);
gtk_style_context_add_class (context, GTK_STYLE_CLASS_EXPANDER);
- gtk_style_context_push_animatable_region (context, node);
-
gtk_render_expander (context, cr,
area.x, area.y,
area.width, area.height);
- gtk_style_context_pop_animatable_region (context);
gtk_style_context_restore (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;
{
if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
{
- GtkStyleContext *context;
gint dy;
gdk_window_move (tree_view->priv->bin_window,
}
gdk_window_scroll (tree_view->priv->bin_window, 0, dy);
- context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
- gtk_style_context_scroll_animations (context, tree_view->priv->bin_window, 0, dy);
-
if (tree_view->priv->dy != (int) gtk_adjustment_get_value (tree_view->priv->vadjustment))
{
/* update our dy and top_row */
if (!tree_view->priv->in_top_row_to_dy)
gtk_tree_view_dy_to_top_row (tree_view);
}
-
- gdk_window_process_updates (tree_view->priv->header_window, TRUE);
- gtk_tree_view_bin_process_updates (tree_view);
}
}
/**
* gtk_tree_view_set_model:
- * @tree_view: A #GtkTreeNode.
+ * @tree_view: A #GtkTreeView.
* @model: (allow-none): The model.
*
* Sets the model for a #GtkTreeView. If the @tree_view already has a model
tree_view->priv->scroll_to_path = NULL;
}
+ if (tree_view->priv->rubber_band_status)
+ gtk_tree_view_stop_rubber_band (tree_view);
+
if (tree_view->priv->model)
{
GList *tmplist = tree_view->priv->columns;
- GtkStyleContext *context;
gtk_tree_view_unref_and_check_selection_tree (tree_view, tree_view->priv->tree);
gtk_tree_view_stop_editing (tree_view, TRUE);
- context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
- gtk_style_context_cancel_animations (context, NULL);
-
g_signal_handlers_disconnect_by_func (tree_view->priv->model,
gtk_tree_view_row_changed,
tree_view);
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_set_rules_hint
+ * gtk_tree_view_set_rules_hint:
* @tree_view: a #GtkTreeView
* @setting: %TRUE if the tree requires reading across rows
*
}
/**
- * gtk_tree_view_get_rules_hint
+ * gtk_tree_view_get_rules_hint:
* @tree_view: a #GtkTreeView
*
* Gets the setting set by gtk_tree_view_set_rules_hint().
GtkTreeViewColumn *column = columns->data;
GtkWidget *header_widget;
- if (gtk_tree_view_column_get_visible (column))
+ if (!gtk_tree_view_column_get_visible (column))
continue;
header_widget = gtk_tree_view_column_get_widget (column);
if (!header_widget)
header_widget = gtk_tree_view_column_get_button (column);
- gtk_widget_reset_style (header_widget);
+ _gtk_widget_invalidate_style_context (header_widget, GTK_CSS_CHANGE_PARENT_REGION);
}
}
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);
}
/**
* @dnotify: destroy notifier for @data
*
* Convenience function that inserts a new column into the #GtkTreeView
- * with the given cell renderer and a #GtkCellDataFunc to set cell renderer
+ * with the given cell renderer and a #GtkTreeCellDataFunc to set cell renderer
* attributes (normally using data from the model). See also
* gtk_tree_view_column_set_cell_data_func(), gtk_tree_view_column_pack_start().
* If @tree_view has "fixed_height" mode enabled, then the new column will have its
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);
- if (animate)
- {
- 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_EXPANDER);
-
- gtk_style_context_notify_state_change (context, tree_view->priv->bin_window,
- node, GTK_STATE_ACTIVE, TRUE);
-
- _gtk_style_context_invalidate_animation_areas (context);
- gtk_style_context_restore (context);
- }
+ _gtk_tree_view_accessible_add (tree_view, node->children, NULL);
+ _gtk_tree_view_accessible_add_state (tree_view,
+ tree, node,
+ GTK_CELL_RENDERER_EXPANDED);
install_presize_handler (tree_view);
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);
-
- if (animate)
- {
- GtkStyleContext *context;
-
- context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
+ _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_style_context_save (context);
- gtk_style_context_add_class (context, GTK_STYLE_CLASS_EXPANDER);
-
- gtk_style_context_notify_state_change (context, tree_view->priv->bin_window,
- node, GTK_STATE_ACTIVE, FALSE);
+ _gtk_rbtree_remove (node->children);
- _gtk_style_context_invalidate_animation_areas (context);
- gtk_style_context_restore (context);
- }
+ 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 (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
{
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_accessible_remove_state (tree_view,
+ tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node,
+ GTK_CELL_RENDERER_FOCUSED);
+ _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);
}
+
+ _gtk_tree_view_accessible_add_state (tree_view,
+ tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node,
+ GTK_CELL_RENDERER_FOCUSED);
}
g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
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;
}
GtkRBNode *node,
gint vertical_separator)
{
+ int expander_size = gtk_tree_view_get_expander_size (tree_view);
int height;
/* The "cell" areas are the cell_area passed in to gtk_cell_renderer_render(),
* function will not be called for irregular (e.g. separator) rows.
*/
height = gtk_tree_view_get_row_height (tree_view, node);
- if (height < tree_view->priv->expander_size)
- height = tree_view->priv->expander_size;
+ if (height < expander_size)
+ height = expander_size;
return height - vertical_separator;
}
if (gtk_tree_view_draw_expanders (tree_view))
{
+ int expander_size = gtk_tree_view_get_expander_size (tree_view);
if (!rtl)
- rect->x += depth * tree_view->priv->expander_size;
- rect->width -= depth * tree_view->priv->expander_size;
+ rect->x += depth * expander_size;
+ rect->width -= depth * expander_size;
}
rect->width = MAX (rect->width, 0);
gtk_tree_view_get_row_height (GtkTreeView *tree_view,
GtkRBNode *node)
{
+ int expander_size = gtk_tree_view_get_expander_size (tree_view);
int height;
/* The "background" areas of all rows/cells add up to cover the entire tree.
*/
height = GTK_RBNODE_GET_HEIGHT (node);
if (height <= 0)
- height = tree_view->priv->expander_size;
+ height = expander_size;
return height;
}
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;
if (gtk_tree_view_draw_expanders (tree_view))
{
+ int expander_size = gtk_tree_view_get_expander_size (tree_view);
if (!rtl)
- cell_area.x += depth * tree_view->priv->expander_size;
- cell_area.width -= depth * tree_view->priv->expander_size;
+ cell_area.x += depth * expander_size;
+ cell_area.width -= depth * expander_size;
}
}
* 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),
* @tree_view: a #GtkTreeView
* @expand: %TRUE to enable hover selection mode
*
- * Enables of disables the hover expansion mode of @tree_view.
+ * Enables or disables the hover expansion mode of @tree_view.
* Hover expansion makes rows expand or collapse if the pointer
* moves over them.
*
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
*
projects / ~andy / gtk / blobdiff