#include "gtktreemodelsort.h"
#include "gtktooltip.h"
#include "gtkprivate.h"
-#include "gtkalias.h"
#define GTK_TREE_VIEW_PRIORITY_VALIDATE (GDK_PRIORITY_REDRAW + 5)
#define GTK_TREE_VIEW_PRIORITY_SCROLL_SYNC (GTK_TREE_VIEW_PRIORITY_VALIDATE + 2)
static void cancel_arrow_animation (GtkTreeView *tree_view);
static gboolean do_expand_collapse (GtkTreeView *tree_view);
static void gtk_tree_view_stop_rubber_band (GtkTreeView *tree_view);
+static void update_prelight (GtkTreeView *tree_view,
+ int x,
+ int y);
/* interactive search */
static void gtk_tree_view_ensure_interactive_directory (GtkTreeView *tree_view);
-static void gtk_tree_view_search_dialog_hide (GtkWidget *search_dialog,
- GtkTreeView *tree_view);
+static void gtk_tree_view_search_dialog_hide (GtkWidget *search_dialog,
+ GtkTreeView *tree_view,
+ GdkDevice *device);
static void gtk_tree_view_search_position_func (GtkTreeView *tree_view,
GtkWidget *search_dialog,
gpointer user_data);
static void gtk_tree_view_stop_editing (GtkTreeView *tree_view,
gboolean cancel_editing);
static gboolean gtk_tree_view_real_start_interactive_search (GtkTreeView *tree_view,
+ GdkDevice *device,
gboolean keybinding);
static gboolean gtk_tree_view_start_interactive_search (GtkTreeView *tree_view);
static GtkTreeViewColumn *gtk_tree_view_get_drop_column (GtkTreeView *tree_view,
gint drop_position);
/* GtkBuildable */
-static void gtk_tree_view_buildable_add_child (GtkBuildable *tree_view,
- GtkBuilder *builder,
- GObject *child,
- const gchar *type);
-static void gtk_tree_view_buildable_init (GtkBuildableIface *iface);
+static void gtk_tree_view_buildable_add_child (GtkBuildable *tree_view,
+ GtkBuilder *builder,
+ GObject *child,
+ const gchar *type);
+static GObject *gtk_tree_view_buildable_get_internal_child (GtkBuildable *buildable,
+ GtkBuilder *builder,
+ const gchar *childname);
+static void gtk_tree_view_buildable_init (GtkBuildableIface *iface);
static gboolean scroll_row_timeout (gpointer data);
g_type_class_add_private (o_class, sizeof (GtkTreeViewPrivate));
}
-static void
-gtk_tree_view_buildable_init (GtkBuildableIface *iface)
-{
- iface->add_child = gtk_tree_view_buildable_add_child;
-}
-
static void
gtk_tree_view_init (GtkTreeView *tree_view)
{
tree_view->priv = G_TYPE_INSTANCE_GET_PRIVATE (tree_view, GTK_TYPE_TREE_VIEW, GtkTreeViewPrivate);
- GTK_WIDGET_SET_FLAGS (tree_view, GTK_CAN_FOCUS);
-
+ gtk_widget_set_can_focus (GTK_WIDGET (tree_view), TRUE);
gtk_widget_set_redraw_on_allocate (GTK_WIDGET (tree_view), FALSE);
tree_view->priv->flags = GTK_TREE_VIEW_SHOW_EXPANDERS
tree_view->priv->tooltip_column = -1;
tree_view->priv->post_validation_flag = FALSE;
+
+ tree_view->priv->last_button_x = -1;
+ tree_view->priv->last_button_y = -1;
+
+ tree_view->priv->event_last_x = -10000;
+ tree_view->priv->event_last_y = -10000;
}
\f
G_OBJECT_CLASS (gtk_tree_view_parent_class)->finalize (object);
}
-\f
+
+static GtkBuildableIface *parent_buildable_iface;
+
+static void
+gtk_tree_view_buildable_init (GtkBuildableIface *iface)
+{
+ parent_buildable_iface = g_type_interface_peek_parent (iface);
+ iface->add_child = gtk_tree_view_buildable_add_child;
+ iface->get_internal_child = gtk_tree_view_buildable_get_internal_child;
+}
static void
gtk_tree_view_buildable_add_child (GtkBuildable *tree_view,
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), GTK_TREE_VIEW_COLUMN (child));
}
+static GObject *
+gtk_tree_view_buildable_get_internal_child (GtkBuildable *buildable,
+ GtkBuilder *builder,
+ const gchar *childname)
+{
+ if (strcmp (childname, "selection") == 0)
+ return G_OBJECT (GTK_TREE_VIEW (buildable)->priv->selection);
+
+ return parent_buildable_iface->get_internal_child (buildable,
+ builder,
+ childname);
+}
+
/* GtkObject Methods
*/
tree_view->priv->drag_dest_row = NULL;
}
- if (tree_view->priv->last_button_press != NULL)
- {
- gtk_tree_row_reference_free (tree_view->priv->last_button_press);
- tree_view->priv->last_button_press = NULL;
- }
-
- if (tree_view->priv->last_button_press_2 != NULL)
- {
- gtk_tree_row_reference_free (tree_view->priv->last_button_press_2);
- tree_view->priv->last_button_press_2 = NULL;
- }
-
if (tree_view->priv->top_row != NULL)
{
gtk_tree_row_reference_free (tree_view->priv->top_row);
{
GList *list;
- g_return_if_fail (GTK_WIDGET_MAPPED (tree_view));
+ g_return_if_fail (gtk_widget_get_mapped (GTK_WIDGET (tree_view)));
if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE))
{
for (list = tree_view->priv->columns; list; list = list->next)
{
column = list->data;
- if (GTK_WIDGET_VISIBLE (column->button) &&
- !GTK_WIDGET_MAPPED (column->button))
+ if (gtk_widget_get_visible (column->button) &&
+ !gtk_widget_get_mapped (column->button))
gtk_widget_map (column->button);
}
for (list = tree_view->priv->columns; list; list = list->next)
GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
GList *tmp_list;
- GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
+ gtk_widget_set_mapped (widget, TRUE);
tmp_list = tree_view->priv->children;
while (tmp_list)
GtkTreeViewChild *child = tmp_list->data;
tmp_list = tmp_list->next;
- if (GTK_WIDGET_VISIBLE (child->widget))
+ if (gtk_widget_get_visible (child->widget))
{
- if (!GTK_WIDGET_MAPPED (child->widget))
+ if (!gtk_widget_get_mapped (child->widget))
gtk_widget_map (child->widget);
}
}
GdkWindowAttr attributes;
gint attributes_mask;
- GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
+ gtk_widget_set_realized (widget, TRUE);
/* Make the main, clipping window */
attributes.window_type = GDK_WINDOW_CHILD;
attributes.height = tree_view->priv->header_height;
attributes.event_mask = (GDK_EXPOSURE_MASK |
GDK_SCROLL_MASK |
+ GDK_ENTER_NOTIFY_MASK |
+ GDK_LEAVE_NOTIFY_MASK |
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_KEY_PRESS_MASK |
tmp_list = tmp_list->next;
- if (GTK_WIDGET_VISIBLE (child->widget))
+ if (gtk_widget_get_visible (child->widget))
gtk_widget_size_request (child->widget, &child_requisition);
}
}
+static int
+gtk_tree_view_calculate_width_before_expander (GtkTreeView *tree_view)
+{
+ int width = 0;
+ GList *list;
+ gboolean rtl;
+
+ rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
+ for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
+ list->data != tree_view->priv->expander_column;
+ list = (rtl ? list->prev : list->next))
+ {
+ GtkTreeViewColumn *column = list->data;
+
+ width += column->width;
+ }
+
+ return width;
+}
static void
invalidate_column (GtkTreeView *tree_view,
GtkWidget *widget = GTK_WIDGET (tree_view);
gboolean rtl;
- if (!GTK_WIDGET_REALIZED (widget))
+ if (!gtk_widget_get_realized (widget))
return;
rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
else
gtk_tree_view_dy_to_top_row (tree_view);
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gdk_window_move_resize (widget->window,
allocation->x, allocation->y,
if (tree_view->priv->tree == NULL)
invalidate_empty_focus (tree_view);
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gboolean has_expand_column = FALSE;
for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
}
}
+ if (width_changed && tree_view->priv->expander_column)
+ {
+ /* Might seem awkward, but is the best heuristic I could come up
+ * with. Only if the width of the columns before the expander
+ * changes, we will update the prelight status. It is this
+ * width that makes the expander move vertically. Always updating
+ * prelight status causes trouble with hover selections.
+ */
+ gint width_before_expander;
+
+ width_before_expander = gtk_tree_view_calculate_width_before_expander (tree_view);
+
+ if (tree_view->priv->prev_width_before_expander
+ != width_before_expander)
+ update_prelight (tree_view,
+ tree_view->priv->event_last_x,
+ tree_view->priv->event_last_y);
+
+ tree_view->priv->prev_width_before_expander = width_before_expander;
+ }
+
/* This little hack only works if we have an LTR locale, and no column has the */
if (width_changed)
{
static void
grab_focus_and_unset_draw_keyfocus (GtkTreeView *tree_view)
{
- if (GTK_WIDGET_CAN_FOCUS (tree_view) && !GTK_WIDGET_HAS_FOCUS (tree_view))
- gtk_widget_grab_focus (GTK_WIDGET (tree_view));
+ GtkWidget *widget = GTK_WIDGET (tree_view);
+
+ if (gtk_widget_get_can_focus (widget) && !gtk_widget_has_focus (widget))
+ gtk_widget_grab_focus (widget);
GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS);
}
}
/* Test if a double click happened on the same row. */
- if (event->button == 1)
+ if (event->button == 1 && event->type == GDK_BUTTON_PRESS)
{
- /* We also handle triple clicks here, because a user could have done
- * a first click and a second double click on different rows.
- */
- if ((event->type == GDK_2BUTTON_PRESS
- || event->type == GDK_3BUTTON_PRESS)
- && tree_view->priv->last_button_press)
+ int double_click_time, double_click_distance;
+
+ g_object_get (gtk_settings_get_default (),
+ "gtk-double-click-time", &double_click_time,
+ "gtk-double-click-distance", &double_click_distance,
+ NULL);
+
+ /* Same conditions as _gdk_event_button_generate */
+ if (tree_view->priv->last_button_x != -1 &&
+ (event->time < tree_view->priv->last_button_time + double_click_time) &&
+ (ABS (event->x - tree_view->priv->last_button_x) <= double_click_distance) &&
+ (ABS (event->y - tree_view->priv->last_button_y) <= double_click_distance))
{
- GtkTreePath *lsc;
-
- lsc = gtk_tree_row_reference_get_path (tree_view->priv->last_button_press);
-
- if (lsc)
- {
- row_double_click = !gtk_tree_path_compare (lsc, path);
- gtk_tree_path_free (lsc);
- }
- }
+ /* We do no longer compare paths of this row and the
+ * row clicked previously. We use the double click
+ * distance to decide whether this is a valid click,
+ * allowing the mouse to slightly move over another row.
+ */
+ row_double_click = TRUE;
- if (row_double_click)
- {
- if (tree_view->priv->last_button_press)
- gtk_tree_row_reference_free (tree_view->priv->last_button_press);
- if (tree_view->priv->last_button_press_2)
- gtk_tree_row_reference_free (tree_view->priv->last_button_press_2);
- tree_view->priv->last_button_press = NULL;
- tree_view->priv->last_button_press_2 = NULL;
+ tree_view->priv->last_button_time = 0;
+ tree_view->priv->last_button_x = -1;
+ tree_view->priv->last_button_y = -1;
}
else
{
- if (tree_view->priv->last_button_press)
- gtk_tree_row_reference_free (tree_view->priv->last_button_press);
- tree_view->priv->last_button_press = tree_view->priv->last_button_press_2;
- tree_view->priv->last_button_press_2 = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
+ tree_view->priv->last_button_time = event->time;
+ tree_view->priv->last_button_x = event->x;
+ tree_view->priv->last_button_y = event->y;
}
}
tree_view->priv->drag_pos = i;
tree_view->priv->x_drag = column->button->allocation.x + (rtl ? 0 : column->button->allocation.width);
- if (!GTK_WIDGET_HAS_FOCUS (widget))
+ if (!gtk_widget_has_focus (widget))
gtk_widget_grab_focus (widget);
return TRUE;
GdkRectangle arrow;
gint x2;
- if (!GTK_WIDGET_REALIZED (tree_view))
+ if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
return FALSE;
if ((node->flags & GTK_RBNODE_IS_PARENT) == 0)
g_assert (tree_view->priv->prelight_node == NULL);
}
+static void
+update_prelight (GtkTreeView *tree_view,
+ gint x,
+ gint y)
+{
+ int new_y;
+ GtkRBTree *tree;
+ GtkRBNode *node;
+
+ if (tree_view->priv->tree == NULL)
+ return;
+
+ if (x == -10000)
+ {
+ ensure_unprelighted (tree_view);
+ return;
+ }
+
+ new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, y);
+ if (new_y < 0)
+ new_y = 0;
+
+ _gtk_rbtree_find_offset (tree_view->priv->tree,
+ new_y, &tree, &node);
+
+ if (node)
+ prelight_or_select (tree_view, tree, node, x, y);
+}
+
GdkRectangle visible_rect;
gint y;
gint offset;
- gfloat value;
gdk_window_get_pointer (tree_view->priv->bin_window, NULL, &y, NULL);
y += tree_view->priv->dy;
return;
}
- value = CLAMP (tree_view->priv->vadjustment->value + offset, 0.0,
- tree_view->priv->vadjustment->upper - tree_view->priv->vadjustment->page_size);
- gtk_adjustment_set_value (tree_view->priv->vadjustment, value);
+ gtk_adjustment_set_value (tree_view->priv->vadjustment,
+ MAX (tree_view->priv->vadjustment->value + offset, 0.0));
}
static gboolean
GdkRectangle visible_rect;
gint x;
gint offset;
- gfloat value;
gdk_window_get_pointer (tree_view->priv->bin_window, &x, NULL, NULL);
}
offset = offset/3;
- value = CLAMP (tree_view->priv->hadjustment->value + offset,
- 0.0, tree_view->priv->hadjustment->upper - tree_view->priv->hadjustment->page_size);
- gtk_adjustment_set_value (tree_view->priv->hadjustment, value);
+ gtk_adjustment_set_value (tree_view->priv->hadjustment,
+ MAX (tree_view->priv->hadjustment->value + offset, 0.0));
return TRUE;
GdkRectangle old_area;
GdkRectangle new_area;
GdkRectangle common;
- GdkRegion *invalid_region;
+ cairo_region_t *invalid_region;
old_area.x = MIN (tree_view->priv->press_start_x, tree_view->priv->rubber_band_x);
old_area.y = MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y) - tree_view->priv->dy;
new_area.width = ABS (x - tree_view->priv->press_start_x) + 1;
new_area.height = ABS (y - tree_view->priv->press_start_y) + 1;
- invalid_region = gdk_region_rectangle (&old_area);
- gdk_region_union_with_rect (invalid_region, &new_area);
+ invalid_region = cairo_region_create_rectangle (&old_area);
+ cairo_region_union_rectangle (invalid_region, &new_area);
gdk_rectangle_intersect (&old_area, &new_area, &common);
if (common.width > 2 && common.height > 2)
{
- GdkRegion *common_region;
+ cairo_region_t *common_region;
/* make sure the border is invalidated */
common.x += 1;
common.width -= 2;
common.height -= 2;
- common_region = gdk_region_rectangle (&common);
+ common_region = cairo_region_create_rectangle (&common);
- gdk_region_subtract (invalid_region, common_region);
- gdk_region_destroy (common_region);
+ cairo_region_subtract (invalid_region, common_region);
+ cairo_region_destroy (common_region);
}
gdk_window_invalidate_region (tree_view->priv->bin_window, invalid_region, TRUE);
- gdk_region_destroy (invalid_region);
+ cairo_region_destroy (invalid_region);
tree_view->priv->rubber_band_x = x;
tree_view->priv->rubber_band_y = y;
(tree_view->priv->button_pressed_node != node))
node = NULL;
+ tree_view->priv->event_last_x = event->x;
+ tree_view->priv->event_last_y = event->y;
+
prelight_or_select (tree_view, tree, node, event->x, event->y);
return TRUE;
{
GdkRectangle area;
- if (!GTK_WIDGET_HAS_FOCUS (tree_view))
+ if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
return;
area.x = 0;
static void
draw_empty_focus (GtkTreeView *tree_view, GdkRectangle *clip_area)
{
+ GtkWidget *widget = GTK_WIDGET (tree_view);
gint w, h;
- if (!GTK_WIDGET_HAS_FOCUS (tree_view))
+ if (!gtk_widget_has_focus (widget))
return;
gdk_drawable_get_size (tree_view->priv->bin_window, &w, &h);
h -= 2;
if (w > 0 && h > 0)
- gtk_paint_focus (GTK_WIDGET (tree_view)->style,
+ gtk_paint_focus (gtk_widget_get_style (widget),
tree_view->priv->bin_window,
- GTK_WIDGET_STATE (tree_view),
+ gtk_widget_get_state (widget),
clip_area,
- GTK_WIDGET (tree_view),
+ widget,
NULL,
1, 1, w, h);
}
cell_area.height -= grid_line_width;
}
- if (gdk_region_rect_in (event->region, &background_area) == GDK_OVERLAP_RECTANGLE_OUT)
+ if (cairo_region_contains_rectangle (event->region, &background_area) == CAIRO_REGION_OVERLAP_OUT)
{
cell_offset += column->width;
continue;
background_area.y + max_height);
}
- if (gtk_tree_view_is_expander_column (tree_view, column) &&
- tree_view->priv->tree_lines_enabled)
- {
- gint x = background_area.x;
- gint mult = rtl ? -1 : 1;
- gint y0 = background_area.y;
- gint y1 = background_area.y + background_area.height/2;
- gint y2 = background_area.y + background_area.height;
-
- if (rtl)
- x += background_area.width - 1;
-
- if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT
- && depth > 1)
- {
- gdk_draw_line (event->window,
- tree_view->priv->tree_line_gc,
- x + tree_view->priv->expander_size * (depth - 1.5) * mult,
- y1,
- x + tree_view->priv->expander_size * (depth - 1.1) * mult,
- y1);
- }
- else if (depth > 1)
- {
- gdk_draw_line (event->window,
- tree_view->priv->tree_line_gc,
- x + tree_view->priv->expander_size * (depth - 1.5) * mult,
- y1,
- x + tree_view->priv->expander_size * (depth - 0.5) * mult,
- y1);
- }
-
- if (depth > 1)
- {
- gint i;
- GtkRBNode *tmp_node;
- GtkRBTree *tmp_tree;
-
- if (!_gtk_rbtree_next (tree, node))
- gdk_draw_line (event->window,
- tree_view->priv->tree_line_gc,
- x + tree_view->priv->expander_size * (depth - 1.5) * mult,
- y0,
- x + tree_view->priv->expander_size * (depth - 1.5) * mult,
- y1);
- else
- gdk_draw_line (event->window,
- tree_view->priv->tree_line_gc,
- x + tree_view->priv->expander_size * (depth - 1.5) * mult,
- y0,
- x + tree_view->priv->expander_size * (depth - 1.5) * mult,
- y2);
-
- tmp_node = tree->parent_node;
- tmp_tree = tree->parent_tree;
-
- for (i = depth - 2; i > 0; i--)
- {
- if (_gtk_rbtree_next (tmp_tree, tmp_node))
- gdk_draw_line (event->window,
- tree_view->priv->tree_line_gc,
- x + tree_view->priv->expander_size * (i - 0.5) * mult,
- y0,
- x + tree_view->priv->expander_size * (i - 0.5) * mult,
- y2);
-
- tmp_node = tmp_tree->parent_node;
- tmp_tree = tmp_tree->parent_tree;
- }
- }
- }
-
if (gtk_tree_view_is_expander_column (tree_view, column))
{
if (!rtl)
&event->area,
flags);
}
+
+ if (gtk_tree_view_is_expander_column (tree_view, column) &&
+ tree_view->priv->tree_lines_enabled)
+ {
+ gint x = background_area.x;
+ gint mult = rtl ? -1 : 1;
+ gint y0 = background_area.y;
+ gint y1 = background_area.y + background_area.height/2;
+ gint y2 = background_area.y + background_area.height;
+
+ if (rtl)
+ x += background_area.width - 1;
+
+ if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT
+ && depth > 1)
+ {
+ gdk_draw_line (event->window,
+ tree_view->priv->tree_line_gc,
+ x + tree_view->priv->expander_size * (depth - 1.5) * mult,
+ y1,
+ x + tree_view->priv->expander_size * (depth - 1.1) * mult,
+ y1);
+ }
+ else if (depth > 1)
+ {
+ gdk_draw_line (event->window,
+ tree_view->priv->tree_line_gc,
+ x + tree_view->priv->expander_size * (depth - 1.5) * mult,
+ y1,
+ x + tree_view->priv->expander_size * (depth - 0.5) * mult,
+ y1);
+ }
+
+ if (depth > 1)
+ {
+ gint i;
+ GtkRBNode *tmp_node;
+ GtkRBTree *tmp_tree;
+
+ if (!_gtk_rbtree_next (tree, node))
+ gdk_draw_line (event->window,
+ tree_view->priv->tree_line_gc,
+ x + tree_view->priv->expander_size * (depth - 1.5) * mult,
+ y0,
+ x + tree_view->priv->expander_size * (depth - 1.5) * mult,
+ y1);
+ else
+ gdk_draw_line (event->window,
+ tree_view->priv->tree_line_gc,
+ x + tree_view->priv->expander_size * (depth - 1.5) * mult,
+ y0,
+ x + tree_view->priv->expander_size * (depth - 1.5) * mult,
+ y2);
+
+ tmp_node = tree->parent_node;
+ tmp_tree = tree->parent_tree;
+
+ for (i = depth - 2; i > 0; i--)
+ {
+ if (_gtk_rbtree_next (tmp_tree, tmp_node))
+ gdk_draw_line (event->window,
+ tree_view->priv->tree_line_gc,
+ x + tree_view->priv->expander_size * (i - 0.5) * mult,
+ y0,
+ x + tree_view->priv->expander_size * (i - 0.5) * mult,
+ y2);
+
+ tmp_node = tmp_tree->parent_node;
+ tmp_tree = tmp_tree->parent_tree;
+ }
+ }
+ }
+
if (node == cursor && has_special_cell &&
((column == tree_view->priv->focus_column &&
GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS) &&
- GTK_WIDGET_HAS_FOCUS (widget)) ||
+ gtk_widget_has_focus (widget)) ||
(column == tree_view->priv->edited_column)))
{
_gtk_tree_view_column_cell_draw_focus (column,
&event->area,
flags);
}
+
cell_offset += column->width;
}
if (row_ending_details)
gtk_paint_focus (widget->style,
tree_view->priv->bin_window,
- GTK_WIDGET_STATE (widget),
+ gtk_widget_get_state (widget),
&event->area,
widget,
(is_first
else
gtk_paint_focus (widget->style,
tree_view->priv->bin_window,
- GTK_WIDGET_STATE (widget),
+ gtk_widget_get_state (widget),
&event->area,
widget,
"treeview-drop-indicator",
if (highlight_y >= 0)
{
gdk_draw_line (event->window,
- widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
+ widget->style->fg_gc[gtk_widget_get_state (widget)],
rtl ? highlight_x + expander_cell_width : highlight_x,
highlight_y,
rtl ? 0 : bin_window_width,
/* draw the big row-spanning focus rectangle, if needed */
if (!has_special_cell && node == cursor &&
GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS) &&
- GTK_WIDGET_HAS_FOCUS (widget))
+ gtk_widget_has_focus (widget))
{
gint tmp_y, tmp_height;
gint width;
done:
gtk_tree_view_draw_grid_lines (tree_view, event, n_visible_columns);
- if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
- {
- GdkRectangle *rectangles;
- gint n_rectangles;
-
- gdk_region_get_rectangles (event->region,
- &rectangles,
- &n_rectangles);
-
- while (n_rectangles--)
- gtk_tree_view_paint_rubber_band (tree_view, &rectangles[n_rectangles]);
-
- g_free (rectangles);
- }
+ if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
+ {
+ GdkRectangle rectangle;
+ gint n_rectangles;
+
+ n_rectangles = cairo_region_num_rectangles (event->region);
+
+ while (n_rectangles--)
+ {
+ cairo_region_get_rectangle (event->region, n_rectangles, &rectangle);
+ gtk_tree_view_paint_rubber_band (tree_view, &rectangle);
+ }
+ }
if (cursor_path)
gtk_tree_path_free (cursor_path);
{
GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
- if (GTK_WIDGET_HAS_FOCUS (column->button))
+ if (gtk_widget_has_focus (column->button))
break;
}
/* We pass the event to the search_entry. If its text changes, then we start
* the typeahead find capabilities. */
- if (GTK_WIDGET_HAS_FOCUS (tree_view)
+ if (gtk_widget_has_focus (GTK_WIDGET (tree_view))
&& tree_view->priv->enable_search
&& !tree_view->priv->search_custom_entry_set)
{
if (tree_view->priv->imcontext_changed || /* we're in a preedit */
(retval && text_modified)) /* ...or the text was modified */
{
- if (gtk_tree_view_real_start_interactive_search (tree_view, FALSE))
+ if (gtk_tree_view_real_start_interactive_search (tree_view,
+ gdk_event_get_device ((GdkEvent *) event),
+ FALSE))
{
gtk_widget_grab_focus (GTK_WIDGET (tree_view));
return TRUE;
if (tree_view->priv->tree == NULL)
return FALSE;
+ if (event->mode == GDK_CROSSING_GRAB ||
+ event->mode == GDK_CROSSING_GTK_GRAB ||
+ event->mode == GDK_CROSSING_GTK_UNGRAB ||
+ event->mode == GDK_CROSSING_STATE_CHANGED)
+ return TRUE;
+
/* find the node internally */
new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
if (new_y < 0)
new_y = 0;
_gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
+ tree_view->priv->event_last_x = event->x;
+ tree_view->priv->event_last_y = event->y;
+
if ((tree_view->priv->button_pressed_node == NULL) ||
(tree_view->priv->button_pressed_node == node))
prelight_or_select (tree_view, tree, node, event->x, event->y);
tree_view->priv->prelight_node,
NULL);
+ tree_view->priv->event_last_x = -10000;
+ tree_view->priv->event_last_y = -10000;
+
prelight_or_select (tree_view,
NULL, NULL,
-1000, -1000); /* coords not possibly over an arrow */
/* destroy interactive search dialog */
if (tree_view->priv->search_window)
- gtk_tree_view_search_dialog_hide (tree_view->priv->search_window, tree_view);
+ gtk_tree_view_search_dialog_hide (tree_view->priv->search_window, tree_view,
+ gdk_event_get_device ((GdkEvent *) event));
return FALSE;
}
while (area_above > 0)
{
_gtk_rbtree_prev_full (tree, node, &tree, &node);
- if (! gtk_tree_path_prev (above_path) && node != NULL)
- {
- gtk_tree_path_free (above_path);
- above_path = _gtk_tree_view_find_path (tree_view, tree, node);
- }
- gtk_tree_model_get_iter (tree_view->priv->model, &iter, above_path);
+
+ /* Always find the new path in the tree. We cannot just assume
+ * a gtk_tree_path_prev() is enough here, as there might be children
+ * in between this node and the previous sibling node. If this
+ * appears to be a performance hotspot in profiles, we can look into
+ * intrigate logic for keeping path, node and iter in sync like
+ * we do for forward walks. (Which will be hard because of the lacking
+ * iter_prev).
+ */
if (node == NULL)
break;
+ gtk_tree_path_free (above_path);
+ above_path = _gtk_tree_view_find_path (tree_view, tree, node);
+
+ gtk_tree_model_get_iter (tree_view->priv->model, &iter, above_path);
+
if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
{
gtk_adjustment_changed (tree_view->priv->vadjustment);
if (queue_resize)
- gtk_widget_queue_resize_no_redraw (GTK_WIDGET (tree_view));
+ gtk_widget_queue_resize (GTK_WIDGET (tree_view));
}
if (path) gtk_tree_path_free (path);
static void
install_presize_handler (GtkTreeView *tree_view)
{
- if (! GTK_WIDGET_REALIZED (tree_view))
+ if (! gtk_widget_get_realized (GTK_WIDGET (tree_view)))
return;
if (! tree_view->priv->presize_handler_timer)
static void
install_scroll_sync_handler (GtkTreeView *tree_view)
{
- if (! GTK_WIDGET_REALIZED (tree_view))
+ if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
return;
if (!tree_view->priv->scroll_sync_timer)
if (tree == NULL)
{
- tree_view->priv->top_row = NULL;
- tree_view->priv->top_row_dy = 0;
+ gtk_tree_view_set_top_row (tree_view, NULL, 0);
}
else
{
GtkRBNode *node;
int new_dy;
+ /* Avoid recursive calls */
+ if (tree_view->priv->in_top_row_to_dy)
+ return;
+
if (tree_view->priv->top_row)
path = gtk_tree_row_reference_get_path (tree_view->priv->top_row);
else
if (! GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE))
return FALSE;
- focus_child = GTK_CONTAINER (tree_view)->focus_child;
+ focus_child = gtk_container_get_focus_child (GTK_CONTAINER (tree_view));
first_column = tree_view->priv->columns;
while (first_column)
{
- if (GTK_WIDGET_CAN_FOCUS (GTK_TREE_VIEW_COLUMN (first_column->data)->button) &&
+ if (gtk_widget_get_can_focus (GTK_TREE_VIEW_COLUMN (first_column->data)->button) &&
GTK_TREE_VIEW_COLUMN (first_column->data)->visible &&
(GTK_TREE_VIEW_COLUMN (first_column->data)->clickable ||
GTK_TREE_VIEW_COLUMN (first_column->data)->reorderable))
last_column = g_list_last (tree_view->priv->columns);
while (last_column)
{
- if (GTK_WIDGET_CAN_FOCUS (GTK_TREE_VIEW_COLUMN (last_column->data)->button) &&
+ if (gtk_widget_get_can_focus (GTK_TREE_VIEW_COLUMN (last_column->data)->button) &&
GTK_TREE_VIEW_COLUMN (last_column->data)->visible &&
(GTK_TREE_VIEW_COLUMN (last_column->data)->clickable ||
GTK_TREE_VIEW_COLUMN (last_column->data)->reorderable))
case GTK_DIR_DOWN:
if (focus_child == NULL)
{
- if (tree_view->priv->focus_column != NULL && GTK_WIDGET_CAN_FOCUS (tree_view->priv->focus_column->button))
+ if (tree_view->priv->focus_column != NULL &&
+ gtk_widget_get_can_focus (tree_view->priv->focus_column->button))
focus_child = tree_view->priv->focus_column->button;
else
focus_child = GTK_TREE_VIEW_COLUMN (first_column->data)->button;
column = tmp_list->data;
if (column->button &&
column->visible &&
- GTK_WIDGET_CAN_FOCUS (column->button))
+ gtk_widget_get_can_focus (column->button))
{
focus_child = column->button;
gtk_widget_grab_focus (column->button);
GtkContainer *container = GTK_CONTAINER (widget);
GtkWidget *focus_child;
- if (!GTK_WIDGET_IS_SENSITIVE (container) || !GTK_WIDGET_CAN_FOCUS (widget))
+ if (!gtk_widget_is_sensitive (widget) || !gtk_widget_get_can_focus (widget))
return FALSE;
- focus_child = container->focus_child;
+ focus_child = gtk_container_get_focus_child (container);
gtk_tree_view_stop_editing (GTK_TREE_VIEW (widget), FALSE);
/* Case 1. Headers currently have focus. */
}
/* Case 2. We don't have focus at all. */
- if (!GTK_WIDGET_HAS_FOCUS (container))
+ if (!gtk_widget_has_focus (widget))
{
if (!gtk_tree_view_header_focus (tree_view, direction, FALSE))
gtk_widget_grab_focus (widget);
GList *list;
GtkTreeViewColumn *column;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gdk_window_set_back_pixmap (widget->window, NULL, FALSE);
gdk_window_set_background (tree_view->priv->bin_window, &widget->style->base[widget->state]);
if (tree_view->priv->tree == NULL)
return FALSE;
- if (!GTK_WIDGET_HAS_FOCUS (GTK_WIDGET (tree_view)))
+ if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
return FALSE;
gtk_tree_view_stop_editing (tree_view, FALSE);
tree_view->priv->children = g_list_append (tree_view->priv->children, child);
- if (GTK_WIDGET_REALIZED (tree_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
gtk_widget_set_parent (child_widget, GTK_WIDGET (tree_view));
allocation.width = child->width = width;
allocation.height = child->height = height;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gtk_widget_size_allocate (widget, &allocation);
}
&& tree_view->priv->fixed_height >= 0)
{
_gtk_rbtree_node_set_height (tree, node, tree_view->priv->fixed_height);
- if (GTK_WIDGET_REALIZED (tree_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
gtk_tree_view_node_queue_redraw (tree_view, tree, node);
}
else
}
done:
- if (GTK_WIDGET_REALIZED (tree_view) && !tree_view->priv->fixed_height_mode)
+ if (!tree_view->priv->fixed_height_mode &&
+ gtk_widget_get_realized (GTK_WIDGET (tree_view)))
install_presize_handler (tree_view);
if (free_path)
gtk_tree_path_free (path);
gint node_dy, height;
GtkTreePath *path = NULL;
- if (!GTK_WIDGET_REALIZED (tree_view))
+ if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
return;
/* just return if the node is visible, avoiding a costly expose */
}
}
- gtk_adjustment_set_value (tree_view->priv->hadjustment,
- CLAMP (x,
- tree_view->priv->hadjustment->lower,
- tree_view->priv->hadjustment->upper
- - tree_view->priv->hadjustment->page_size));
+ gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
}
else
{
void
_gtk_tree_view_column_start_drag (GtkTreeView *tree_view,
- GtkTreeViewColumn *column)
+ GtkTreeViewColumn *column,
+ GdkDevice *device)
{
GdkEvent *send_event;
GtkAllocation allocation;
send_event->crossing.subwindow = NULL;
send_event->crossing.detail = GDK_NOTIFY_ANCESTOR;
send_event->crossing.time = GDK_CURRENT_TIME;
+ gdk_event_set_device (send_event, device);
gtk_propagate_event (column->button, send_event);
gdk_event_free (send_event);
send_event->button.axes = NULL;
send_event->button.state = 0;
send_event->button.button = 1;
- send_event->button.device = gdk_display_get_core_pointer (display);
send_event->button.x_root = 0;
send_event->button.y_root = 0;
+ gdk_event_set_device (send_event, device);
gtk_propagate_event (column->button, send_event);
gdk_event_free (send_event);
{
GdkRectangle rect;
- if (!GTK_WIDGET_REALIZED (tree_view))
+ if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
return;
rect.x = 0;
{
GdkRectangle rect;
- if (!GTK_WIDGET_REALIZED (tree_view))
+ if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
return;
rect.x = 0;
gint expander_size;
GtkExpanderStyle expander_style;
- gtk_widget_style_get (GTK_WIDGET (tree_view),
+ widget = GTK_WIDGET (tree_view);
+
+ gtk_widget_style_get (widget,
"vertical-separator", &vertical_separator,
NULL);
expander_size = tree_view->priv->expander_size - EXPANDER_EXTRA_PADDING;
if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
return;
- widget = GTK_WIDGET (tree_view);
-
gtk_tree_view_get_arrow_xrange (tree_view, tree, &x_offset, &x2);
area.x = x_offset;
area.width = expander_size + 2;
area.height = MAX (CELL_HEIGHT (node, vertical_separator), (expander_size - vertical_separator));
- if (GTK_WIDGET_STATE (tree_view) == GTK_STATE_INSENSITIVE)
+ if (gtk_widget_get_state (widget) == GTK_STATE_INSENSITIVE)
{
state = GTK_STATE_INSENSITIVE;
}
GtkTreePath *cursor_path;
if ((tree_view->priv->tree == NULL) ||
- (! GTK_WIDGET_REALIZED (tree_view)))
+ (! gtk_widget_get_realized (GTK_WIDGET (tree_view))))
return;
cursor_path = NULL;
gboolean grab_focus = TRUE;
gboolean selectable;
- if (! GTK_WIDGET_HAS_FOCUS (tree_view))
+ if (! gtk_widget_has_focus (GTK_WIDGET (tree_view)))
return;
cursor_path = NULL;
gint window_y;
gint vertical_separator;
- if (! GTK_WIDGET_HAS_FOCUS (tree_view))
+ if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
return;
if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
if (!gtk_tree_path_compare (old_cursor_path, cursor_path))
gtk_widget_error_bell (GTK_WIDGET (tree_view));
+ gtk_widget_grab_focus (GTK_WIDGET (tree_view));
+
cleanup:
gtk_tree_path_free (old_cursor_path);
gtk_tree_path_free (cursor_path);
rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
- if (! GTK_WIDGET_HAS_FOCUS (tree_view))
+ if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
return;
if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
cursor_node,
NULL);
g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
+ gtk_widget_grab_focus (GTK_WIDGET (tree_view));
}
else
{
GtkTreePath *path;
GtkTreePath *old_path;
- if (! GTK_WIDGET_HAS_FOCUS (tree_view))
+ if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
return;
g_return_if_fail (tree_view->priv->tree != NULL);
if (gtk_tree_path_compare (old_path, path))
{
gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE);
+ gtk_widget_grab_focus (GTK_WIDGET (tree_view));
}
else
{
static gboolean
gtk_tree_view_real_select_all (GtkTreeView *tree_view)
{
- if (! GTK_WIDGET_HAS_FOCUS (tree_view))
+ if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
return FALSE;
if (tree_view->priv->selection->type != GTK_SELECTION_MULTIPLE)
static gboolean
gtk_tree_view_real_unselect_all (GtkTreeView *tree_view)
{
- if (! GTK_WIDGET_HAS_FOCUS (tree_view))
+ if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
return FALSE;
if (tree_view->priv->selection->type != GTK_SELECTION_MULTIPLE)
GtkTreePath *cursor_path = NULL;
GtkTreeSelectMode mode = 0;
- if (! GTK_WIDGET_HAS_FOCUS (tree_view))
+ if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
return FALSE;
if (tree_view->priv->cursor)
GtkRBNode *cursor_node = NULL;
GtkTreePath *cursor_path = NULL;
- if (! GTK_WIDGET_HAS_FOCUS (tree_view))
+ if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
return FALSE;
cursor_path = NULL;
GtkRBTree *tree;
GtkRBNode *node;
- if (! GTK_WIDGET_HAS_FOCUS (tree_view))
+ if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
return FALSE;
cursor_path = NULL;
GtkTreePath *cursor_path = NULL;
GdkModifierType state;
- if (! GTK_WIDGET_HAS_FOCUS (tree_view))
+ if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
goto out;
cursor_path = NULL;
static gboolean
gtk_tree_view_search_entry_flush_timeout (GtkTreeView *tree_view)
{
- gtk_tree_view_search_dialog_hide (tree_view->priv->search_window, tree_view);
+ gtk_tree_view_search_dialog_hide (tree_view->priv->search_window, tree_view, NULL);
tree_view->priv->typeselect_flush_timeout = 0;
return FALSE;
/* Cut and paste from gtkwindow.c */
static void
send_focus_change (GtkWidget *widget,
+ GdkDevice *device,
gboolean in)
{
- GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+ GdkDeviceManager *device_manager;
+ GList *devices, *d;
- g_object_ref (widget);
-
- if (in)
- GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS);
- else
- GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS);
+ device_manager = gdk_display_get_device_manager (gtk_widget_get_display (widget));
+ devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
+ devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_SLAVE));
+ devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_FLOATING));
- fevent->focus_change.type = GDK_FOCUS_CHANGE;
- fevent->focus_change.window = g_object_ref (widget->window);
- fevent->focus_change.in = in;
-
- gtk_widget_event (widget, fevent);
-
- g_object_notify (G_OBJECT (widget), "has-focus");
+ for (d = devices; d; d = d->next)
+ {
+ GdkDevice *dev = d->data;
+ GdkEvent *fevent;
+
+ if (dev->source != GDK_SOURCE_KEYBOARD)
+ continue;
+
+ /* Skip non-master keyboards that haven't
+ * selected for events from this window
+ */
+ if (gdk_device_get_device_type (dev) != GDK_DEVICE_TYPE_MASTER &&
+ !gdk_window_get_device_events (widget->window, dev))
+ continue;
+
+ fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+
+ fevent->focus_change.type = GDK_FOCUS_CHANGE;
+ fevent->focus_change.window = g_object_ref (widget->window);
+ fevent->focus_change.in = in;
+ gdk_event_set_device (fevent, device);
- g_object_unref (widget);
- gdk_event_free (fevent);
+ gtk_widget_send_focus_change (widget, fevent);
+
+ gdk_event_free (fevent);
+ }
}
static void
*/
static gboolean
gtk_tree_view_real_start_interactive_search (GtkTreeView *tree_view,
+ GdkDevice *device,
gboolean keybinding)
{
/* We only start interactive search if we have focus or the columns
return FALSE;
if (tree_view->priv->search_window != NULL &&
- GTK_WIDGET_VISIBLE (tree_view->priv->search_window))
+ gtk_widget_get_visible (tree_view->priv->search_window))
return TRUE;
for (list = tree_view->priv->columns; list; list = list->next)
if (! column->visible)
continue;
- if (GTK_WIDGET_HAS_FOCUS (column->button))
+ if (gtk_widget_has_focus (column->button))
{
found_focus = TRUE;
break;
}
}
- if (GTK_WIDGET_HAS_FOCUS (tree_view))
+ if (gtk_widget_has_focus (GTK_WIDGET (tree_view)))
found_focus = TRUE;
if (!found_focus)
(entry_parent_class->grab_focus) (tree_view->priv->search_entry);
/* send focus-in event */
- send_focus_change (tree_view->priv->search_entry, TRUE);
+ send_focus_change (tree_view->priv->search_entry, device, TRUE);
/* search first matching iter */
gtk_tree_view_search_init (tree_view->priv->search_entry, tree_view);
static gboolean
gtk_tree_view_start_interactive_search (GtkTreeView *tree_view)
{
- return gtk_tree_view_real_start_interactive_search (tree_view, TRUE);
+ return gtk_tree_view_real_start_interactive_search (tree_view,
+ gtk_get_current_event_device (),
+ TRUE);
}
/* this function returns the new width of the column being resized given
/* The window to which widget->window is relative */
#define ALLOCATION_WINDOW(widget) \
- (GTK_WIDGET_NO_WINDOW (widget) ? \
+ (!gtk_widget_get_has_window (widget) ? \
(widget)->window : \
gdk_window_get_parent ((widget)->window))
* into widget->allocation if the widget is not realized.
* FIXME someone figure out why this was.
*/
- if (!GTK_WIDGET_REALIZED (widget))
+ if (!gtk_widget_get_realized (widget))
{
- if (GTK_WIDGET_VISIBLE (widget))
+ if (gtk_widget_get_visible (widget))
{
GdkRectangle tmp_rectangle = widget->allocation;
tmp_rectangle.x += scroll_data->dx;
{
ScrollData scroll_data;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
scroll_data.window = ALLOCATION_WINDOW (widget);
else
scroll_data.window = NULL;
gtk_tree_view_adjustment_changed (GtkAdjustment *adjustment,
GtkTreeView *tree_view)
{
- if (GTK_WIDGET_REALIZED (tree_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
{
gint dy;
- tree_view->priv->hadjustment->value,
0);
dy = tree_view->priv->dy - (int) tree_view->priv->vadjustment->value;
- if (dy && tree_view->priv->edited_column)
+ if (dy)
{
- if (GTK_IS_WIDGET (tree_view->priv->edited_column->editable_widget))
+ update_prelight (tree_view,
+ tree_view->priv->event_last_x,
+ tree_view->priv->event_last_y - dy);
+
+ if (tree_view->priv->edited_column &&
+ GTK_IS_WIDGET (tree_view->priv->edited_column->editable_widget))
{
GList *list;
GtkWidget *widget;
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);
+ gdk_window_process_updates (tree_view->priv->bin_window, TRUE);
}
}
* Returns the model the #GtkTreeView is based on. Returns %NULL if the
* model is unset.
*
- * Return value: A #GtkTreeModel, or %NULL if none is currently being used.
+ * Return value: (transfer none): A #GtkTreeModel, or %NULL if none is currently being used.
**/
GtkTreeModel *
gtk_tree_view_get_model (GtkTreeView *tree_view)
/**
* gtk_tree_view_set_model:
* @tree_view: A #GtkTreeNode.
- * @model: The model.
+ * @model: (allow-none): The model.
*
* Sets the model for a #GtkTreeView. If the @tree_view already has a model
- * set, it will remove it before setting the new model. If @model is %NULL,
+ * set, it will remove it before setting the new model. If @model is %NULL,
* then it will unset the old model.
**/
void
tree_view->priv->anchor = NULL;
gtk_tree_row_reference_free (tree_view->priv->top_row);
tree_view->priv->top_row = NULL;
- gtk_tree_row_reference_free (tree_view->priv->last_button_press);
- tree_view->priv->last_button_press = NULL;
- gtk_tree_row_reference_free (tree_view->priv->last_button_press_2);
- tree_view->priv->last_button_press_2 = NULL;
gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
tree_view->priv->scroll_to_path = NULL;
tree_view->priv->fixed_height_check = 0;
tree_view->priv->fixed_height = -1;
tree_view->priv->dy = tree_view->priv->top_row_dy = 0;
+ tree_view->priv->last_button_x = -1;
+ tree_view->priv->last_button_y = -1;
}
tree_view->priv->model = model;
if (tree_view->priv->selection)
_gtk_tree_selection_emit_changed (tree_view->priv->selection);
- if (GTK_WIDGET_REALIZED (tree_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
gtk_widget_queue_resize (GTK_WIDGET (tree_view));
}
*
* Gets the #GtkTreeSelection associated with @tree_view.
*
- * Return value: A #GtkTreeSelection object.
+ * Return value: (transfer none): A #GtkTreeSelection object.
**/
GtkTreeSelection *
gtk_tree_view_get_selection (GtkTreeView *tree_view)
/**
* gtk_tree_view_set_hadjustment:
* @tree_view: A #GtkTreeView
- * @adjustment: The #GtkAdjustment to set, or %NULL
+ * @adjustment: (allow-none): The #GtkAdjustment to set, or %NULL
*
* Sets the #GtkAdjustment for the current horizontal aspect.
**/
/**
* gtk_tree_view_set_vadjustment:
* @tree_view: A #GtkTreeView
- * @adjustment: The #GtkAdjustment to set, or %NULL
+ * @adjustment: (allow-none): The #GtkAdjustment to set, or %NULL
*
* Sets the #GtkAdjustment for the current vertical aspect.
**/
else
GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE);
- if (GTK_WIDGET_REALIZED (tree_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
{
gdk_window_get_position (tree_view->priv->bin_window, &x, &y);
if (headers_visible)
{
gdk_window_move_resize (tree_view->priv->bin_window, x, y + TREE_VIEW_HEADER_HEIGHT (tree_view), tree_view->priv->width, GTK_WIDGET (tree_view)->allocation.height - + TREE_VIEW_HEADER_HEIGHT (tree_view));
- if (GTK_WIDGET_MAPPED (tree_view))
+ if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
gtk_tree_view_map_buttons (tree_view);
}
else
tree_view->priv->edited_column = NULL;
}
+ if (tree_view->priv->expander_column == column)
+ tree_view->priv->expander_column = NULL;
+
g_signal_handlers_disconnect_by_func (column,
G_CALLBACK (column_sizing_notify),
tree_view);
tree_view->priv->columns = g_list_remove (tree_view->priv->columns, column);
tree_view->priv->n_columns--;
- if (GTK_WIDGET_REALIZED (tree_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
{
GList *list;
g_object_ref_sink (column);
if (tree_view->priv->n_columns == 0 &&
- GTK_WIDGET_REALIZED (tree_view) &&
+ gtk_widget_get_realized (GTK_WIDGET (tree_view)) &&
gtk_tree_view_get_headers_visible (tree_view))
{
gdk_window_show (tree_view->priv->header_window);
_gtk_tree_view_column_set_tree_view (column, tree_view);
- if (GTK_WIDGET_REALIZED (tree_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
{
GList *list;
* Returns a #GList of all the #GtkTreeViewColumn s currently in @tree_view.
* The returned list must be freed with g_list_free ().
*
- * Return value: A list of #GtkTreeViewColumn s
+ * Return value: (element-type GtkTreeViewColumn) (transfer container): A list of #GtkTreeViewColumn s
**/
GList *
gtk_tree_view_get_columns (GtkTreeView *tree_view)
* gtk_tree_view_move_column_after:
* @tree_view: A #GtkTreeView
* @column: The #GtkTreeViewColumn to be moved.
- * @base_column: The #GtkTreeViewColumn to be moved relative to, or %NULL.
+ * @base_column: (allow-none): The #GtkTreeViewColumn to be moved relative to, or %NULL.
*
* Moves @column to be after to @base_column. If @base_column is %NULL, then
* @column is placed in the first position.
base_el->next = column_list_el;
}
- if (GTK_WIDGET_REALIZED (tree_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
{
gtk_widget_queue_resize (GTK_WIDGET (tree_view));
gtk_tree_view_size_allocate_columns (GTK_WIDGET (tree_view), NULL);
/**
* gtk_tree_view_set_column_drag_function:
* @tree_view: A #GtkTreeView.
- * @func: A function to determine which columns are reorderable, or %NULL.
- * @user_data: User data to be passed to @func, or %NULL
- * @destroy: Destroy notifier for @user_data, or %NULL
+ * @func: (allow-none): A function to determine which columns are reorderable, or %NULL.
+ * @user_data: (allow-none): User data to be passed to @func, or %NULL
+ * @destroy: (allow-none): Destroy notifier for @user_data, or %NULL
*
* Sets a user function for determining where a column may be dropped when
* dragged. This function is called on every column pair in turn at the
GtkAdjustment *vadj;
g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
- g_return_if_fail (GTK_WIDGET_REALIZED (tree_view));
+ g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tree_view)));
hadj = tree_view->priv->hadjustment;
vadj = tree_view->priv->vadjustment;
if (tree_x != -1)
- gtk_adjustment_set_value (hadj, CLAMP (tree_x, hadj->lower, hadj->upper - hadj->page_size));
+ gtk_adjustment_set_value (hadj, tree_x);
if (tree_y != -1)
- gtk_adjustment_set_value (vadj, CLAMP (tree_y, vadj->lower, vadj->upper - vadj->page_size));
+ gtk_adjustment_set_value (vadj, tree_y);
}
/**
* gtk_tree_view_scroll_to_cell:
* @tree_view: A #GtkTreeView.
- * @path: The path of the row to move to, or %NULL.
- * @column: The #GtkTreeViewColumn to move horizontally to, or %NULL.
+ * @path: (allow-none): The path of the row to move to, or %NULL.
+ * @column: (allow-none): The #GtkTreeViewColumn to move horizontally to, or %NULL.
* @use_align: whether to use alignment arguments, or %FALSE.
* @row_align: The vertical alignment of the row specified by @path.
* @col_align: The horizontal alignment of the column specified by @column.
* scrolling code, we short-circuit validate_visible_area's immplementation as
* it is much slower than just going to the point.
*/
- if (! GTK_WIDGET_VISIBLE (tree_view) ||
- ! GTK_WIDGET_REALIZED (tree_view) ||
+ if (!gtk_widget_get_visible (GTK_WIDGET (tree_view)) ||
+ !gtk_widget_get_realized (GTK_WIDGET (tree_view)) ||
GTK_WIDGET_ALLOC_NEEDED (tree_view) ||
GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
{
gtk_tree_path_free (anchor_path);
}
- if (gtk_tree_row_reference_valid (tree_view->priv->last_button_press))
- {
- GtkTreePath *lsc = gtk_tree_row_reference_get_path (tree_view->priv->last_button_press);
- if (gtk_tree_path_is_ancestor (path, lsc))
- {
- gtk_tree_row_reference_free (tree_view->priv->last_button_press);
- tree_view->priv->last_button_press = NULL;
- }
- gtk_tree_path_free (lsc);
- }
-
- if (gtk_tree_row_reference_valid (tree_view->priv->last_button_press_2))
- {
- GtkTreePath *lsc = gtk_tree_row_reference_get_path (tree_view->priv->last_button_press_2);
- if (gtk_tree_path_is_ancestor (path, lsc))
- {
- gtk_tree_row_reference_free (tree_view->priv->last_button_press_2);
- tree_view->priv->last_button_press_2 = NULL;
- }
- gtk_tree_path_free (lsc);
- }
+ /* Stop a pending double click */
+ tree_view->priv->last_button_x = -1;
+ tree_view->priv->last_button_y = -1;
remove_expand_collapse_timeout (tree_view);
if (animate)
add_expand_collapse_timeout (tree_view, tree, node, FALSE);
- if (GTK_WIDGET_MAPPED (tree_view))
+ if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
{
gtk_widget_queue_resize (GTK_WIDGET (tree_view));
}
g_signal_emit (tree_view, tree_view_signals[ROW_COLLAPSED], 0, &iter, path);
- if (GTK_WIDGET_MAPPED (tree_view))
+ if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
{
/* 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. */
gtk_tree_row_reference_free (tree_view->priv->cursor);
tree_view->priv->cursor = NULL;
- /* One cannot set the cursor on a separator. */
- if (!row_is_separator (tree_view, NULL, path))
+ /* 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)
{
tree_view->priv->cursor =
- gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
- tree_view->priv->model,
- path);
- _gtk_tree_view_find_node (tree_view, path, &tree, &node);
+ gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
+ tree_view->priv->model,
+ path);
+ }
+ else
+ {
+ tree = NULL;
+ node = NULL;
}
if (tree != NULL)
/**
* gtk_tree_view_get_cursor:
* @tree_view: A #GtkTreeView
- * @path: A pointer to be filled with the current cursor path, or %NULL
- * @focus_column: A pointer to be filled with the current focus column, or %NULL
+ * @path: (out) (allow-none): A pointer to be filled with the current cursor path, or %NULL
+ * @focus_column: (out) (allow-none): A pointer to be filled with the current focus column, or %NULL
*
* Fills in @path and @focus_column with the current path and focus column. If
* the cursor isn't currently set, then *@path will be %NULL. If no column
* gtk_tree_view_set_cursor:
* @tree_view: A #GtkTreeView
* @path: A #GtkTreePath
- * @focus_column: A #GtkTreeViewColumn, or %NULL
+ * @focus_column: (allow-none): A #GtkTreeViewColumn, or %NULL
* @start_editing: %TRUE if the specified cell should start being edited.
*
* Sets the current keyboard focus to be at @path, and selects it. This is
* gtk_tree_view_set_cursor_on_cell:
* @tree_view: A #GtkTreeView
* @path: A #GtkTreePath
- * @focus_column: A #GtkTreeViewColumn, or %NULL
- * @focus_cell: A #GtkCellRenderer, or %NULL
+ * @focus_column: (allow-none): A #GtkTreeViewColumn, or %NULL
+ * @focus_cell: (allow-none): A #GtkCellRenderer, or %NULL
* @start_editing: %TRUE if the specified cell should start being edited.
*
* Sets the current keyboard focus to be at @path, and selects it. This is
* @tree_view: A #GtkTreeView.
* @x: The x position to be identified (relative to bin_window).
* @y: The y position to be identified (relative to bin_window).
- * @path: A pointer to a #GtkTreePath pointer to be filled in, or %NULL
- * @column: A pointer to a #GtkTreeViewColumn pointer to be filled in, or %NULL
- * @cell_x: A pointer where the X coordinate relative to the cell can be placed, or %NULL
- * @cell_y: A pointer where the Y coordinate relative to the cell can be placed, or %NULL
+ * @path: (out) (allow-none): A pointer to a #GtkTreePath pointer to be filled in, or %NULL
+ * @column: (out) (allow-none): A pointer to a #GtkTreeViewColumn pointer to be filled in, or %NULL
+ * @cell_x: (out) (allow-none): A pointer where the X coordinate relative to the cell can be placed, or %NULL
+ * @cell_y: (out) (allow-none): A pointer where the Y coordinate relative to the cell can be placed, or %NULL
*
* Finds the path at the point (@x, @y), relative to bin_window coordinates
* (please see gtk_tree_view_get_bin_window()).
* with the column at that point. @cell_x and @cell_y return the coordinates
* relative to the cell background (i.e. the @background_area passed to
* gtk_cell_renderer_render()). This function is only meaningful if
- * @tree_view is realized.
+ * @tree_view is realized. Therefore this function will always return %FALSE
+ * if @tree_view is not realized or does not have a model.
*
* For converting widget coordinates (eg. the ones you get from
* GtkWidget::query-tooltip), please see
gint y_offset;
g_return_val_if_fail (tree_view != NULL, FALSE);
- g_return_val_if_fail (tree_view->priv->bin_window != NULL, FALSE);
if (path)
*path = NULL;
if (column)
*column = NULL;
+ if (tree_view->priv->bin_window == NULL)
+ return FALSE;
+
if (tree_view->priv->tree == NULL)
return FALSE;
/**
* gtk_tree_view_get_cell_area:
* @tree_view: a #GtkTreeView
- * @path: a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
- * @column: a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordinates
+ * @path: (allow-none): a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
+ * @column: (allow-none): a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordinates
* @rect: rectangle to fill with cell rect
*
* Fills the bounding rectangle in bin_window coordinates for the cell at the
g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
g_return_if_fail (rect != NULL);
g_return_if_fail (!column || column->tree_view == (GtkWidget *) tree_view);
- g_return_if_fail (GTK_WIDGET_REALIZED (tree_view));
+ g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tree_view)));
gtk_widget_style_get (GTK_WIDGET (tree_view),
"vertical-separator", &vertical_separator,
/**
* gtk_tree_view_get_background_area:
* @tree_view: a #GtkTreeView
- * @path: a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
- * @column: a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordiantes
+ * @path: (allow-none): a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
+ * @column: (allow-none): a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordiantes
* @rect: rectangle to fill with cell background rect
*
* Fills the bounding rectangle in bin_window coordinates for the cell at the
}
}
-/**
- * gtk_tree_view_widget_to_tree_coords:
- * @tree_view: a #GtkTreeView
- * @wx: X coordinate relative to bin_window
- * @wy: Y coordinate relative to bin_window
- * @tx: return location for tree X coordinate
- * @ty: return location for tree Y coordinate
- *
- * Converts bin_window coordinates to coordinates for the
- * tree (the full scrollable area of the tree).
- *
- * Deprecated: 2.12: Due to historial reasons the name of this function is
- * incorrect. For converting coordinates relative to the widget to
- * bin_window coordinates, please see
- * gtk_tree_view_convert_widget_to_bin_window_coords().
- *
- **/
-void
-gtk_tree_view_widget_to_tree_coords (GtkTreeView *tree_view,
- gint wx,
- gint wy,
- gint *tx,
- gint *ty)
-{
- g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
-
- if (tx)
- *tx = wx + tree_view->priv->hadjustment->value;
- if (ty)
- *ty = wy + tree_view->priv->dy;
-}
-
-/**
- * gtk_tree_view_tree_to_widget_coords:
- * @tree_view: a #GtkTreeView
- * @tx: tree X coordinate
- * @ty: tree Y coordinate
- * @wx: return location for X coordinate relative to bin_window
- * @wy: return location for Y coordinate relative to bin_window
- *
- * Converts tree coordinates (coordinates in full scrollable area of the tree)
- * to bin_window coordinates.
- *
- * Deprecated: 2.12: Due to historial reasons the name of this function is
- * incorrect. For converting bin_window coordinates to coordinates relative
- * to bin_window, please see
- * gtk_tree_view_convert_bin_window_to_widget_coords().
- *
- **/
-void
-gtk_tree_view_tree_to_widget_coords (GtkTreeView *tree_view,
- gint tx,
- gint ty,
- gint *wx,
- gint *wy)
-{
- g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
-
- if (wx)
- *wx = tx - tree_view->priv->hadjustment->value;
- if (wy)
- *wy = ty - tree_view->priv->dy;
-}
-
-
/**
* gtk_tree_view_convert_widget_to_tree_coords:
* @tree_view: a #GtkTreeView
/**
* gtk_tree_view_get_visible_range:
* @tree_view: A #GtkTreeView
- * @start_path: Return location for start of region, or %NULL.
- * @end_path: Return location for end of region, or %NULL.
+ * @start_path: (allow-none): Return location for start of region, or %NULL.
+ * @end_path: (allow-none): Return location for end of region, or %NULL.
*
* Sets @start_path and @end_path to be the first and last visible path.
* Note that there may be invisible paths in between.
/**
* gtk_tree_view_set_drag_dest_row:
* @tree_view: a #GtkTreeView
- * @path: 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.
/**
* gtk_tree_view_get_drag_dest_row:
* @tree_view: a #GtkTreeView
- * @path: Return location for the path of the highlighted row, or %NULL.
- * @pos: Return location for the drop position, or %NULL
+ * @path: (out) (allow-none): Return location for the path of the highlighted row, or %NULL.
+ * @pos: (out) (allow-none): Return location for the drop position, or %NULL
*
* Gets information about the row that is highlighted for feedback.
**/
* @tree_view: a #GtkTreeView
* @drag_x: the position to determine the destination row for
* @drag_y: the position to determine the destination row for
- * @path: Return location for the path of the highlighted row, or %NULL.
- * @pos: Return location for the drop position, or %NULL
+ * @path: (out) (allow-none): Return location for the path of the highlighted row, or %NULL.
+ * @pos: (out) (allow-none): Return location for the drop position, or %NULL
*
* Determines the destination row for a given position. @drag_x and
- * @drag_y are expected to be in widget coordinates.
+ * @drag_y are expected to be in widget coordinates. This function is only
+ * meaningful if @tree_view is realized. Therefore this function will always
+ * return %FALSE if @tree_view is not realized or does not have a model.
*
- * Return value: whether there is a row at the given position.
+ * Return value: whether there is a row at the given position, %TRUE if this
+ * is indeed the case.
**/
gboolean
gtk_tree_view_get_dest_row_at_pos (GtkTreeView *tree_view,
g_return_val_if_fail (tree_view != NULL, FALSE);
g_return_val_if_fail (drag_x >= 0, FALSE);
g_return_val_if_fail (drag_y >= 0, FALSE);
- g_return_val_if_fail (tree_view->priv->bin_window != NULL, FALSE);
-
if (path)
*path = NULL;
+ if (tree_view->priv->bin_window == NULL)
+ return FALSE;
+
if (tree_view->priv->tree == NULL)
return FALSE;
widget = GTK_WIDGET (tree_view);
- if (!GTK_WIDGET_REALIZED (tree_view))
+ if (!gtk_widget_get_realized (widget))
return NULL;
depth = gtk_tree_path_get_depth (path);
expose_area.height = background_area.height + 2;
gdk_draw_rectangle (drawable,
- widget->style->base_gc [GTK_WIDGET_STATE (widget)],
+ widget->style->base_gc [gtk_widget_get_state (widget)],
TRUE,
0, 0,
bin_window_width + 2,
/**
* gtk_tree_view_set_destroy_count_func:
* @tree_view: A #GtkTreeView
- * @func: Function to be called when a view row is destroyed, or %NULL
- * @data: User data to be passed to @func, or %NULL
- * @destroy: Destroy notifier for @data, or %NULL
+ * @func: (allow-none): Function to be called when a view row is destroyed, or %NULL
+ * @data: (allow-none): User data to be passed to @func, or %NULL
+ * @destroy: (allow-none): Destroy notifier for @data, or %NULL
*
* 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
* gtk_tree_view_set_search_equal_func:
* @tree_view: A #GtkTreeView
* @search_equal_func: the compare function to use during the search
- * @search_user_data: user data to pass to @search_equal_func, or %NULL
- * @search_destroy: Destroy notifier for @search_user_data, or %NULL
+ * @search_user_data: (allow-none): user data to pass to @search_equal_func, or %NULL
+ * @search_destroy: (allow-none): Destroy notifier for @search_user_data, or %NULL
*
* Sets the compare function for the interactive search capabilities; note
* that somewhat like strcmp() returning 0 for equality
/**
* gtk_tree_view_set_search_entry:
* @tree_view: A #GtkTreeView
- * @entry: the entry the interactive search code of @tree_view should use or %NULL
+ * @entry: (allow-none): the entry the interactive search code of @tree_view should use or %NULL
*
* Sets the entry which the interactive search code will use for this
* @tree_view. This is useful when you want to provide a search entry
/**
* gtk_tree_view_set_search_position_func:
* @tree_view: A #GtkTreeView
- * @func: the function to use to position the search dialog, or %NULL
+ * @func: (allow-none): the function to use to position the search dialog, or %NULL
* to use the default search position function
- * @data: user data to pass to @func, or %NULL
- * @destroy: Destroy notifier for @data, or %NULL
+ * @data: (allow-none): user data to pass to @func, or %NULL
+ * @destroy: (allow-none): Destroy notifier for @data, or %NULL
*
* Sets the function to use when positioning the search dialog.
*
static void
gtk_tree_view_search_dialog_hide (GtkWidget *search_dialog,
- GtkTreeView *tree_view)
+ GtkTreeView *tree_view,
+ GdkDevice *device)
{
if (tree_view->priv->disable_popdown)
return;
tree_view->priv->typeselect_flush_timeout = 0;
}
- if (GTK_WIDGET_VISIBLE (search_dialog))
+ if (gtk_widget_get_visible (search_dialog))
{
/* send focus-in event */
- send_focus_change (GTK_WIDGET (tree_view->priv->search_entry), FALSE);
+ send_focus_change (GTK_WIDGET (tree_view->priv->search_entry), device, FALSE);
gtk_widget_hide (search_dialog);
gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
- send_focus_change (GTK_WIDGET (tree_view), TRUE);
+ send_focus_change (GTK_WIDGET (tree_view), device, TRUE);
}
}
GtkRBTree *tree;
gtk_tree_view_search_dialog_hide (tree_view->priv->search_window,
- tree_view);
+ tree_view,
+ gtk_get_current_event_device ());
/* If we have a row selected and it's the cursor row, we activate
* the row XXX */
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
- gtk_tree_view_search_dialog_hide (widget, tree_view);
+ gtk_tree_view_search_dialog_hide (widget, tree_view, NULL);
return TRUE;
}
GdkEventButton *event,
GtkTreeView *tree_view)
{
+ GdkDevice *keyb_device;
+
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
- gtk_tree_view_search_dialog_hide (widget, tree_view);
+ keyb_device = gdk_device_get_associated_device (event->device);
+ gtk_tree_view_search_dialog_hide (widget, tree_view, keyb_device);
if (event->window == tree_view->priv->bin_window)
gtk_tree_view_button_press (GTK_WIDGET (tree_view), event);
event->keyval == GDK_KP_Tab ||
event->keyval == GDK_ISO_Left_Tab))
{
- gtk_tree_view_search_dialog_hide (widget, tree_view);
+ gtk_tree_view_search_dialog_hide (widget, tree_view,
+ gdk_event_get_device ((GdkEvent *) event));
return TRUE;
}
retval = TRUE;
}
- if (((event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK)) == (GDK_CONTROL_MASK | GDK_SHIFT_MASK))
+ if (((event->state & (GTK_DEFAULT_ACCEL_MOD_MASK | GDK_SHIFT_MASK)) == (GTK_DEFAULT_ACCEL_MOD_MASK | GDK_SHIFT_MASK))
&& (event->keyval == GDK_g || event->keyval == GDK_G))
{
if (!gtk_tree_view_search_move (widget, tree_view, TRUE))
retval = TRUE;
}
- if (((event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK)) == GDK_CONTROL_MASK)
+ if (((event->state & (GTK_DEFAULT_ACCEL_MOD_MASK | GDK_SHIFT_MASK)) == GTK_DEFAULT_ACCEL_MOD_MASK)
&& (event->keyval == GDK_g || event->keyval == GDK_G))
{
if (!gtk_tree_view_search_move (widget, tree_view, FALSE))
_gtk_tree_view_column_stop_editing (tree_view->priv->edited_column);
tree_view->priv->edited_column = NULL;
- if (GTK_WIDGET_HAS_FOCUS (cell_editable))
+ if (gtk_widget_has_focus (GTK_WIDGET (cell_editable)))
gtk_widget_grab_focus (GTK_WIDGET (tree_view));
g_signal_handlers_disconnect_by_func (cell_editable,
g_assert (tree_view->priv->focus_column);
- if (! GTK_WIDGET_REALIZED (tree_view))
+ if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
return FALSE;
if (_gtk_tree_view_find_node (tree_view, cursor_path, &cursor_tree, &cursor_node) ||
* gtk_tree_view_set_row_separator_func:
* @tree_view: a #GtkTreeView
* @func: a #GtkTreeViewRowSeparatorFunc
- * @data: user data to pass to @func, or %NULL
- * @destroy: destroy notifier for @data, or %NULL
+ * @data: (allow-none): user data to pass to @func, or %NULL
+ * @destroy: (allow-none): destroy notifier for @data, or %NULL
*
* Sets the row separator function, which is used to determine
* whether a row should be drawn as a separator. If the row separator
tree_view->priv->row_separator_func = func;
tree_view->priv->row_separator_data = data;
tree_view->priv->row_separator_destroy = destroy;
+
+ /* Have the tree recalculate heights */
+ _gtk_rbtree_mark_invalid (tree_view->priv->tree);
+ gtk_widget_queue_resize (GTK_WIDGET (tree_view));
}
{
GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gdk_window_set_back_pixmap (widget->window, NULL, FALSE);
gdk_window_set_background (tree_view->priv->bin_window, &widget->style->base[widget->state]);
old_grid_lines = priv->grid_lines;
priv->grid_lines = grid_lines;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
if (grid_lines == GTK_TREE_VIEW_GRID_LINES_NONE &&
priv->grid_line_gc)
priv->tree_lines_enabled = enabled;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
if (!enabled && priv->tree_line_gc)
{
* gtk_tree_view_set_tooltip_cell:
* @tree_view: a #GtkTreeView
* @tooltip: a #GtkTooltip
- * @path: a #GtkTreePath or %NULL
- * @column: a #GtkTreeViewColumn or %NULL
- * @cell: a #GtkCellRenderer or %NULL
+ * @path: (allow-none): a #GtkTreePath or %NULL
+ * @column: (allow-none): a #GtkTreeViewColumn or %NULL
+ * @cell: (allow-none): a #GtkCellRenderer or %NULL
*
* Sets the tip area of @tooltip to the area @path, @column and @cell have
* in common. For example if @path is %NULL and @column is set, the tip
* @x: the x coordinate (relative to widget coordinates)
* @y: the y coordinate (relative to widget coordinates)
* @keyboard_tip: whether this is a keyboard tooltip or not
- * @model: a pointer to receive a #GtkTreeModel or %NULL
- * @path: a pointer to receive a #GtkTreePath or %NULL
- * @iter: a pointer to receive a #GtkTreeIter or %NULL
+ * @model: (out) (allow-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
*
* This function is supposed to be used in a #GtkWidget::query-tooltip
* signal handler for #GtkTreeView. The @x, @y and @keyboard_tip values
return tree_view->priv->tooltip_column;
}
-
-#define __GTK_TREE_VIEW_C__
-#include "gtkaliasdef.c"
projects / ~andy / gtk / blobdiff