#include "gtktreednd.h"
#include "gtktreeprivate.h"
#include "gtkcellrenderer.h"
-#include "gtkmainprivate.h"
#include "gtkmarshalers.h"
#include "gtkbuildable.h"
#include "gtkbutton.h"
#include "gtklabel.h"
-#include "gtkhbox.h"
-#include "gtkvbox.h"
+#include "gtkbox.h"
#include "gtkarrow.h"
#include "gtkintl.h"
#include "gtkbindings.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 "a11y/gtktreeviewaccessible.h"
gint rubber_band_status;
gint rubber_band_x;
gint rubber_band_y;
- gint rubber_band_shift;
- gint rubber_band_ctrl;
+ gint rubber_band_extend;
+ gint rubber_band_modify;
GtkRBNode *rubber_band_start_node;
GtkRBTree *rubber_band_start_tree;
/* for DnD */
guint empty_view_drop : 1;
- guint ctrl_pressed : 1;
- guint shift_pressed : 1;
+ guint modify_selection_pressed : 1;
+ guint extend_selection_pressed : 1;
guint init_hadjust_value : 1;
guint time);
/* tree_model signals */
-static void gtk_tree_view_set_hadjustment (GtkTreeView *tree_view,
- GtkAdjustment *adjustment);
-static void gtk_tree_view_set_vadjustment (GtkTreeView *tree_view,
- GtkAdjustment *adjustment);
static gboolean gtk_tree_view_real_move_cursor (GtkTreeView *tree_view,
GtkMovementStep step,
gint count);
static void gtk_tree_view_draw_arrow (GtkTreeView *tree_view,
cairo_t *cr,
GtkRBTree *tree,
- GtkRBNode *node,
- gint x,
- gint y);
+ GtkRBNode *node);
static void gtk_tree_view_get_arrow_xrange (GtkTreeView *tree_view,
GtkRBTree *tree,
gint *x1,
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);
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)
gboolean row_double_click = FALSE;
gboolean rtl;
gboolean node_selected;
+ GdkModifierType extend_mod_mask;
+ GdkModifierType modify_mod_mask;
/* Empty tree? */
if (tree_view->priv->tree == NULL)
gtk_tree_path_free (anchor);
}
+ extend_mod_mask =
+ gtk_widget_get_modifier_mask (widget, GDK_MODIFIER_INTENT_EXTEND_SELECTION);
+
+ modify_mod_mask =
+ gtk_widget_get_modifier_mask (widget, GDK_MODIFIER_INTENT_MODIFY_SELECTION);
+
/* select */
node_selected = GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED);
pre_val = gtk_adjustment_get_value (tree_view->priv->vadjustment);
{
GtkCellRenderer *focus_cell;
- if ((event->state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
- tree_view->priv->ctrl_pressed = TRUE;
- if ((event->state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK)
- tree_view->priv->shift_pressed = TRUE;
+ if ((event->state & modify_mod_mask) == modify_mod_mask)
+ tree_view->priv->modify_selection_pressed = TRUE;
+ if ((event->state & extend_mod_mask) == extend_mod_mask)
+ tree_view->priv->extend_selection_pressed = TRUE;
/* We update the focus cell here, this is also needed if the
* column does not contain an editable cell. In this case,
if (focus_cell)
gtk_tree_view_column_focus_cell (column, focus_cell);
- if (event->state & GDK_CONTROL_MASK)
+ if (event->state & modify_mod_mask)
{
gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
gtk_tree_view_real_toggle_cursor_row (tree_view);
}
- else if (event->state & GDK_SHIFT_MASK)
+ else if (event->state & extend_mod_mask)
{
gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
gtk_tree_view_real_select_cursor_row (tree_view, FALSE);
gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE);
}
- tree_view->priv->ctrl_pressed = FALSE;
- tree_view->priv->shift_pressed = FALSE;
+ tree_view->priv->modify_selection_pressed = FALSE;
+ tree_view->priv->extend_selection_pressed = FALSE;
}
/* the treeview may have been scrolled because of _set_cursor,
tree_view->priv->rubber_band_y = event->y + tree_view->priv->dy;
tree_view->priv->rubber_band_status = RUBBER_BAND_MAYBE_START;
- if ((event->state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
- tree_view->priv->rubber_band_ctrl = TRUE;
- if ((event->state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK)
- tree_view->priv->rubber_band_shift = TRUE;
+ if ((event->state & modify_mod_mask) == modify_mod_mask)
+ tree_view->priv->rubber_band_modify = TRUE;
+ if ((event->state & extend_mod_mask) == extend_mod_mask)
+ tree_view->priv->rubber_band_extend = TRUE;
}
}
column = gtk_tree_view_get_column (tree_view, tree_view->priv->drag_pos);
if (event->is_hint || event->window != gtk_widget_get_window (widget))
- gtk_widget_get_pointer (widget, &x, NULL);
+ gdk_window_get_device_position (gtk_widget_get_window (widget),
+ gdk_event_get_device ((GdkEvent *) event),
+ &x, NULL, NULL);
else
x = event->x;
static void
-gtk_tree_view_update_current_reorder (GtkTreeView *tree_view)
+gtk_tree_view_update_current_reorder (GtkTreeView *tree_view,
+ GdkEvent *event)
{
GtkTreeViewColumnReorder *reorder = NULL;
GList *list;
gint mouse_x;
- gdk_window_get_pointer (tree_view->priv->header_window, &mouse_x, NULL, NULL);
+ gdk_window_get_device_position (tree_view->priv->header_window,
+ gdk_event_get_device (event),
+ &mouse_x, NULL, NULL);
for (list = tree_view->priv->column_drag_info; list; list = list->next)
{
reorder = (GtkTreeViewColumnReorder *) list->data;
gint y;
gint offset;
- gdk_window_get_pointer (tree_view->priv->bin_window, NULL, &y, NULL);
+ gdk_window_get_device_position (tree_view->priv->bin_window,
+ gdk_device_manager_get_client_pointer (
+ gdk_display_get_device_manager (
+ gtk_widget_get_display (GTK_WIDGET (tree_view)))),
+ NULL, &y, NULL);
y += tree_view->priv->dy;
gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
}
static gboolean
-gtk_tree_view_horizontal_autoscroll (GtkTreeView *tree_view)
+gtk_tree_view_horizontal_autoscroll (GtkTreeView *tree_view,
+ GdkEvent *event)
{
GdkRectangle visible_rect;
gint x;
gint offset;
- gdk_window_get_pointer (tree_view->priv->bin_window, &x, NULL, NULL);
+ gdk_window_get_device_position (tree_view->priv->bin_window,
+ gdk_event_get_device (event),
+ &x, NULL, NULL);
gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
gdk_window_move (tree_view->priv->drag_window, x, y);
/* autoscroll, if needed */
- gtk_tree_view_horizontal_autoscroll (tree_view);
+ gtk_tree_view_horizontal_autoscroll (tree_view, (GdkEvent *) event);
/* Update the current reorder position and arrow; */
- gtk_tree_view_update_current_reorder (tree_view);
+ gtk_tree_view_update_current_reorder (tree_view, (GdkEvent *) event);
return TRUE;
}
/* Clear status variables */
tree_view->priv->rubber_band_status = RUBBER_BAND_OFF;
- tree_view->priv->rubber_band_shift = 0;
- tree_view->priv->rubber_band_ctrl = 0;
+ tree_view->priv->rubber_band_extend = FALSE;
+ tree_view->priv->rubber_band_modify = FALSE;
tree_view->priv->rubber_band_start_node = NULL;
tree_view->priv->rubber_band_start_tree = NULL;
if (select)
{
- if (tree_view->priv->rubber_band_shift)
- GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
- else if (tree_view->priv->rubber_band_ctrl)
+ if (tree_view->priv->rubber_band_extend)
+ GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
+ else if (tree_view->priv->rubber_band_modify)
{
/* Toggle the selection state */
if (GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
else
{
/* Mirror the above */
- if (tree_view->priv->rubber_band_shift)
+ if (tree_view->priv->rubber_band_extend)
GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
- else if (tree_view->priv->rubber_band_ctrl)
+ else if (tree_view->priv->rubber_band_modify)
{
/* Toggle the selection state */
if (GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
old_area.width = ABS (tree_view->priv->rubber_band_x - tree_view->priv->press_start_x) + 1;
old_area.height = ABS (tree_view->priv->rubber_band_y - tree_view->priv->press_start_y) + 1;
- gdk_window_get_pointer (tree_view->priv->bin_window, &x, &y, NULL);
+ gdk_window_get_device_position (tree_view->priv->bin_window,
+ gdk_device_manager_get_client_pointer (
+ gdk_display_get_device_manager (
+ gtk_widget_get_display (GTK_WIDGET (tree_view)))),
+ &x, &y, NULL);
x = MAX (x, 0);
y = MAX (y, 0) + tree_view->priv->dy;
GtkWidget *widget = GTK_WIDGET (tree_view);
gint w, h;
- if (!gtk_widget_has_focus (widget))
+ if (!gtk_widget_has_visible_focus (widget))
return;
w = gdk_window_get_width (tree_view->priv->bin_window) - 2;
gboolean has_can_focus_cell;
gboolean rtl;
gint n_visible_columns;
- gint pointer_x, pointer_y;
gint grid_line_width;
- gboolean got_pointer = FALSE;
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);
* 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.
if (node == cursor && has_can_focus_cell
&& ((column == tree_view->priv->focus_column
&& tree_view->priv->draw_keyfocus &&
- gtk_widget_has_focus (widget))
+ gtk_widget_has_visible_focus (widget))
|| (column == tree_view->priv->edited_column)))
draw_focus = TRUE;
else
expander_cell_width = cell_area.width;
if (is_separator)
- gtk_render_line (context, cr,
- cell_area.x,
- cell_area.y + cell_area.height / 2,
- cell_area.x + cell_area.width,
- cell_area.y + cell_area.height / 2);
+ {
+ gtk_style_context_save (context);
+ gtk_style_context_add_class (context, GTK_STYLE_CLASS_SEPARATOR);
+
+ gtk_render_line (context, cr,
+ cell_area.x,
+ cell_area.y + cell_area.height / 2,
+ cell_area.x + cell_area.width,
+ cell_area.y + cell_area.height / 2);
+
+ gtk_style_context_restore (context);
+ }
else
- _gtk_tree_view_column_cell_render (column,
- cr,
- &background_area,
- &cell_area,
- flags,
- draw_focus);
+ {
+ _gtk_tree_view_column_cell_render (column,
+ cr,
+ &background_area,
+ &cell_area,
+ flags,
+ draw_focus);
+ }
+
if (gtk_tree_view_draw_expanders (tree_view)
&& (node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT)
{
- if (!got_pointer)
- {
- gdk_window_get_pointer (tree_view->priv->bin_window,
- &pointer_x, &pointer_y, NULL);
- got_pointer = TRUE;
- }
-
gtk_tree_view_draw_arrow (GTK_TREE_VIEW (widget),
cr,
tree,
- node,
- pointer_x, pointer_y);
+ node);
}
}
else
/* draw the big row-spanning focus rectangle, if needed */
if (!has_can_focus_cell && node == cursor &&
tree_view->priv->draw_keyfocus &&
- gtk_widget_has_focus (widget))
+ gtk_widget_has_visible_focus (widget))
{
gint tmp_y, tmp_height;
GtkStateFlags focus_rect_state = 0;
button, cr);
}
- return TRUE;
+ return FALSE;
}
enum
tree_view = GTK_TREE_VIEW (data);
- gdk_window_get_pointer (tree_view->priv->bin_window,
- &x, &y, &state);
+ gdk_window_get_device_position (tree_view->priv->bin_window,
+ gdk_device_manager_get_client_pointer (
+ gdk_display_get_device_manager (
+ gtk_widget_get_display (GTK_WIDGET (tree_view)))),
+ &x, &y, &state);
gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
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_get_current_event_state (&state))
{
- if ((state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
- tree_view->priv->ctrl_pressed = TRUE;
- if ((state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK)
- tree_view->priv->shift_pressed = TRUE;
+ GdkModifierType extend_mod_mask;
+ GdkModifierType modify_mod_mask;
+
+ extend_mod_mask =
+ gtk_widget_get_modifier_mask (GTK_WIDGET (tree_view),
+ GDK_MODIFIER_INTENT_EXTEND_SELECTION);
+
+ modify_mod_mask =
+ gtk_widget_get_modifier_mask (GTK_WIDGET (tree_view),
+ GDK_MODIFIER_INTENT_MODIFY_SELECTION);
+
+ if ((state & modify_mod_mask) == modify_mod_mask)
+ tree_view->priv->modify_selection_pressed = TRUE;
+ if ((state & extend_mod_mask) == extend_mod_mask)
+ tree_view->priv->extend_selection_pressed = TRUE;
}
/* else we assume not pressed */
g_assert_not_reached ();
}
- tree_view->priv->ctrl_pressed = FALSE;
- tree_view->priv->shift_pressed = FALSE;
+ tree_view->priv->modify_selection_pressed = FALSE;
+ tree_view->priv->extend_selection_pressed = FALSE;
return TRUE;
}
{
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" \
goto done;
}
- tmptree = tmpnode->children;
- tree = tmptree;
+ tree = tmpnode->children;
i++;
}
if (tree_view->priv->tree == tree)
tree_view->priv->tree = NULL;
+ _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_tree_view_draw_arrow (GtkTreeView *tree_view,
cairo_t *cr,
GtkRBTree *tree,
- GtkRBNode *node,
- /* in bin_window coordinates */
- gint x,
- gint y)
+ GtkRBNode *node)
{
GdkRectangle area;
GtkStateFlags state = 0;
state = gtk_cell_renderer_get_state (NULL, widget, flags);
- if (node == tree_view->priv->button_pressed_node &&
- x >= area.x && x <= (area.x + area.width) &&
- y >= area.y && y <= (area.y + area.height))
- state |= GTK_STATE_FLAG_FOCUSED;
-
if (node == tree_view->priv->prelight_node &&
tree_view->priv->arrow_prelit)
state |= GTK_STATE_FLAG_PRELIGHT;
if (selection_count == 0
&& gtk_tree_selection_get_mode (tree_view->priv->selection) != GTK_SELECTION_NONE
- && !tree_view->priv->ctrl_pressed
+ && !tree_view->priv->modify_selection_pressed
&& selectable)
{
/* Don't move the cursor, but just select the current node */
{
gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
- if (!tree_view->priv->shift_pressed)
+ if (!tree_view->priv->extend_selection_pressed)
{
if (! gtk_widget_keynav_failed (GTK_WIDGET (tree_view),
count < 0 ?
return FALSE;
}
- if (!tree_view->priv->shift_pressed && start_editing &&
+ if (!tree_view->priv->extend_selection_pressed && start_editing &&
tree_view->priv->focus_column)
{
if (gtk_tree_view_start_editing (tree_view, cursor_path, FALSE))
}
}
- if (tree_view->priv->ctrl_pressed)
+ if (tree_view->priv->modify_selection_pressed)
mode |= GTK_TREE_SELECT_MODE_TOGGLE;
- if (tree_view->priv->shift_pressed)
+ if (tree_view->priv->extend_selection_pressed)
mode |= GTK_TREE_SELECT_MODE_EXTEND;
_gtk_tree_selection_internal_select_node (tree_view->priv->selection,
gtk_widget_grab_focus (GTK_WIDGET (tree_view));
_gtk_tree_view_queue_draw_node (tree_view, cursor_tree, cursor_node, NULL);
- if (!tree_view->priv->shift_pressed)
+ if (!tree_view->priv->extend_selection_pressed)
gtk_tree_view_row_activated (tree_view, cursor_path,
tree_view->priv->focus_column);
if (gtk_get_current_event_state (&state))
{
- if ((state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
- tree_view->priv->ctrl_pressed = TRUE;
+ GdkModifierType modify_mod_mask;
+
+ modify_mod_mask =
+ gtk_widget_get_modifier_mask (GTK_WIDGET (tree_view),
+ GDK_MODIFIER_INTENT_MODIFY_SELECTION);
+
+ if ((state & modify_mod_mask) == modify_mod_mask)
+ tree_view->priv->modify_selection_pressed = TRUE;
}
gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE);
gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
gtk_tree_path_free (cursor_path);
- tree_view->priv->ctrl_pressed = FALSE;
+ tree_view->priv->modify_selection_pressed = FALSE;
return TRUE;
}
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;
{
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);
_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;
/**
* gtk_tree_view_insert_column_with_attributes:
* @tree_view: A #GtkTreeView
- * @position: The position to insert the new column in.
- * @title: The title to set the header to.
- * @cell: The #GtkCellRenderer.
- * @Varargs: A %NULL-terminated list of attributes.
+ * @position: The position to insert the new column in
+ * @title: The title to set the header to
+ * @cell: The #GtkCellRenderer
+ * @...: A %NULL-terminated list of attributes
*
* Creates a new #GtkTreeViewColumn and inserts it into the @tree_view at
* @position. If @position is -1, then the newly created column is inserted at
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");
}
gboolean collapse;
gint x, y;
GList *list;
- GdkWindow *child, *parent;
+ GdkWindow *child;
if (animate)
g_object_get (gtk_widget_get_settings (GTK_WIDGET (tree_view)),
tree_view->priv->last_button_x = -1;
tree_view->priv->last_button_y = -1;
+ _gtk_tree_view_accessible_remove (tree_view, node->children, NULL);
+
if (gtk_tree_view_unref_and_check_selection_tree (tree_view, node->children))
{
_gtk_rbtree_remove (node->children);
/* now that we've collapsed all rows, we want to try to set the prelight
* again. To do this, we fake a motion event and send it to ourselves. */
- child = tree_view->priv->bin_window;
- parent = gdk_window_get_parent (child);
-
- if (gdk_window_get_pointer (parent, &x, &y, NULL) == child)
+ child = gdk_window_get_device_position (gdk_window_get_parent (tree_view->priv->bin_window),
+ gdk_device_manager_get_client_pointer (
+ gdk_display_get_device_manager (
+ gtk_widget_get_display (GTK_WIDGET (tree_view)))),
+ &x, &y, NULL);
+ if (child == tree_view->priv->bin_window)
{
GdkEventMotion event;
gint child_x, child_y;
* @reorderable: %TRUE, if the tree can be reordered.
*
* This function is a convenience function to allow you to reorder
- * models that support the #GtkDragSourceIface and the
- * #GtkDragDestIface. Both #GtkTreeStore and #GtkListStore support
+ * models that support the #GtkTreeDragSourceIface and the
+ * #GtkTreeDragDestIface. Both #GtkTreeStore and #GtkListStore support
* these. If @reorderable is %TRUE, then the user can reorder the
* model by dragging and dropping rows. The developer can listen to
* these changes by connecting to the model's row_inserted and
GtkRBTree *new_tree = NULL;
GtkRBNode *new_node = NULL;
- if (clear_and_select && !tree_view->priv->ctrl_pressed)
+ if (clear_and_select && !tree_view->priv->modify_selection_pressed)
{
GtkTreeSelectMode mode = 0;
- if (tree_view->priv->ctrl_pressed)
- mode |= GTK_TREE_SELECT_MODE_TOGGLE;
- if (tree_view->priv->shift_pressed)
+ if (tree_view->priv->extend_selection_pressed)
mode |= GTK_TREE_SELECT_MODE_EXTEND;
_gtk_tree_selection_internal_select_node (tree_view->priv->selection,
/**
* gtk_tree_view_set_drag_dest_row:
* @tree_view: a #GtkTreeView
- * @path: (allow-none): The path of the row to highlight, or %NULL.
+ * @path: (allow-none): The path of the row to highlight, or %NULL
* @pos: Specifies whether to drop before, after or into the row
- *
+ *
* Sets the row that is highlighted for feedback.
- **/
+ * If @path is %NULL, an existing highlight is removed.
+ */
void
gtk_tree_view_set_drag_dest_row (GtkTreeView *tree_view,
GtkTreePath *path,
{
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_column_cell_is_visible (column))
{
if (is_separator)
- gtk_render_line (context, cr,
- cell_area.x,
- cell_area.y + cell_area.height / 2,
- cell_area.x + cell_area.width,
- cell_area.y + cell_area.height / 2);
+ {
+ gtk_style_context_save (context);
+ gtk_style_context_add_class (context, GTK_STYLE_CLASS_SEPARATOR);
+
+ gtk_render_line (context, cr,
+ cell_area.x,
+ cell_area.y + cell_area.height / 2,
+ cell_area.x + cell_area.width,
+ cell_area.y + cell_area.height / 2);
+
+ gtk_style_context_restore (context);
+ }
else
- _gtk_tree_view_column_cell_render (column,
- cr,
- &background_area,
- &cell_area,
- 0, FALSE);
+ {
+ _gtk_tree_view_column_cell_render (column,
+ cr,
+ &background_area,
+ &cell_area,
+ 0, FALSE);
+ }
}
cell_offset += gtk_tree_view_column_get_width (column);
}
GdkEventKey *event,
GtkTreeView *tree_view)
{
- gboolean retval = FALSE;
+ GdkModifierType default_accel;
+ gboolean retval = FALSE;
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
return TRUE;
}
+ default_accel = gtk_widget_get_modifier_mask (widget,
+ GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR);
+
/* select previous matching iter */
if (event->keyval == GDK_KEY_Up || event->keyval == GDK_KEY_KP_Up)
{
retval = TRUE;
}
- if (((event->state & (GTK_DEFAULT_ACCEL_MOD_MASK | GDK_SHIFT_MASK)) == (GTK_DEFAULT_ACCEL_MOD_MASK | GDK_SHIFT_MASK))
+ if (((event->state & (default_accel | GDK_SHIFT_MASK)) == (default_accel | GDK_SHIFT_MASK))
&& (event->keyval == GDK_KEY_g || event->keyval == GDK_KEY_G))
{
if (!gtk_tree_view_search_move (widget, tree_view, TRUE))
retval = TRUE;
}
- if (((event->state & (GTK_DEFAULT_ACCEL_MOD_MASK | GDK_SHIFT_MASK)) == GTK_DEFAULT_ACCEL_MOD_MASK)
+ if (((event->state & (default_accel | GDK_SHIFT_MASK)) == default_accel)
&& (event->keyval == GDK_KEY_g || event->keyval == GDK_KEY_G))
{
if (!gtk_tree_view_search_move (widget, tree_view, FALSE))
gchar *normalized_key;
gchar *case_normalized_string = NULL;
gchar *case_normalized_key = NULL;
- GValue value = {0,};
- GValue transformed = {0,};
+ GValue value = G_VALUE_INIT;
+ GValue transformed = G_VALUE_INIT;
gtk_tree_model_get_value (model, iter, column, &value);
* @tree_view: a #GtkTreeView
* @hover: %TRUE to enable hover selection mode
*
- * Enables of disables the hover selection mode of @tree_view.
+ * Enables or disables the hover selection mode of @tree_view.
* Hover selection makes the selected row follow the pointer.
* Currently, this works only for the selection modes
* %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
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
*
GtkTooltip *tooltip,
gpointer data)
{
- GValue value = { 0, };
- GValue transformed = { 0, };
+ GValue value = G_VALUE_INIT;
+ GValue transformed = G_VALUE_INIT;
GtkTreeIter iter;
GtkTreePath *path;
GtkTreeModel *model;