X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtktreeview.c;h=505f41b588eca0e786c522e7b97655ae0de34240;hb=17d3775555888151780fa404242e734a8e7f6b21;hp=7c4192c3438ddde19e68fb93083607fdbf9f203c;hpb=e60fa49fa775fdda251c43709b9d4a0a6b5371aa;p=~andy%2Fgtk diff --git a/gtk/gtktreeview.c b/gtk/gtktreeview.c index 7c4192c34..505f41b58 100644 --- a/gtk/gtktreeview.c +++ b/gtk/gtktreeview.c @@ -12,9 +12,7 @@ * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public - * License along with this library; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. + * License along with this library. If not, see . */ @@ -24,6 +22,8 @@ #include #include "gtktreeview.h" + +#include "gtkadjustment.h" #include "gtkrbtree.h" #include "gtktreednd.h" #include "gtktreeprivate.h" @@ -48,9 +48,12 @@ #include "gtkwidgetprivate.h" #include "gtkentryprivate.h" #include "gtkstylecontextprivate.h" +#include "gtkcssstylepropertyprivate.h" #include "gtktypebuiltins.h" #include "gtkmain.h" -#include "a11y/gtktreeviewaccessible.h" +#include "gtksettings.h" +#include "gtkwidgetpath.h" +#include "a11y/gtktreeviewaccessibleprivate.h" /** @@ -152,6 +155,12 @@ enum RUBBER_BAND_ACTIVE = 2 }; +typedef enum { + CLEAR_AND_SELECT = (1 << 0), + CLAMP_NODE = (1 << 1), + CURSOR_INVALID = (1 << 2) +} SetCursorFlags; + /* This lovely little value is used to determine how far away from the title bar * you can move the mouse and still have a column drag work. */ @@ -230,7 +239,6 @@ enum #define GTK_TREE_VIEW_PRIORITY_SCROLL_SYNC (GTK_TREE_VIEW_PRIORITY_VALIDATE + 2) #define GTK_TREE_VIEW_TIME_MS_PER_IDLE 30 #define SCROLL_EDGE_SIZE 15 -#define EXPANDER_EXTRA_PADDING 4 #define GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT 5000 #define AUTO_EXPAND_TIMEOUT 500 @@ -308,7 +316,6 @@ struct _GtkTreeViewPrivate guint scroll_sync_timer; /* Indentation and expander layout */ - gint expander_size; GtkTreeViewColumn *expander_column; gint level_indentation; @@ -317,7 +324,8 @@ struct _GtkTreeViewPrivate gint cursor_offset; GtkTreeRowReference *anchor; - GtkTreeRowReference *cursor; + GtkRBNode *cursor_node; + GtkRBTree *cursor_tree; GtkTreeViewColumn *focus_column; @@ -376,12 +384,10 @@ struct _GtkTreeViewPrivate gint drag_pos; gint x_drag; - /* Non-interactive Header Resizing, expand flag support */ - gint prev_width; - - gint last_extra_space; - gint last_extra_space_per_column; - gint last_number_of_expand_columns; + /* Column width allocation */ + gint minimum_width; + gint natural_width; + gint n_expand_columns; /* ATK Hack */ GtkTreeDestroyCountFunc destroy_count_func; @@ -455,6 +461,7 @@ struct _GtkTreeViewPrivate guint fixed_height_mode : 1; guint fixed_height_check : 1; + guint activate_on_single_click : 1; guint reorderable : 1; guint header_has_focus : 1; guint drag_column_window_state : 3; @@ -485,8 +492,6 @@ struct _GtkTreeViewPrivate guint in_grab : 1; - guint post_validation_flag : 1; - /* Whether our key press handler is to avoid sending an unhandled binding to the search entry */ guint search_entry_avoid_unhandled_binding : 1; @@ -551,7 +556,8 @@ enum { PROP_RUBBER_BANDING, PROP_ENABLE_GRID_LINES, PROP_ENABLE_TREE_LINES, - PROP_TOOLTIP_COLUMN + PROP_TOOLTIP_COLUMN, + PROP_ACTIVATE_ON_SINGLE_CLICK }; /* object signals */ @@ -576,9 +582,6 @@ static void gtk_tree_view_get_preferred_width (GtkWidget *widget, static void gtk_tree_view_get_preferred_height (GtkWidget *widget, gint *minimum, gint *natural); -static void gtk_tree_view_size_request (GtkWidget *widget, - GtkRequisition *requisition, - gboolean may_validate); static void gtk_tree_view_size_allocate (GtkWidget *widget, GtkAllocation *allocation); static gboolean gtk_tree_view_draw (GtkWidget *widget, @@ -707,7 +710,7 @@ static gboolean validate_row (GtkTreeView *tree_view, static void validate_visible_area (GtkTreeView *tree_view); static gboolean validate_rows_handler (GtkTreeView *tree_view); static gboolean do_validate_rows (GtkTreeView *tree_view, - gboolean size_request); + gboolean queue_resize); static gboolean validate_rows (GtkTreeView *tree_view); static gboolean presize_handler_callback (gpointer data); static void install_presize_handler (GtkTreeView *tree_view); @@ -745,9 +748,6 @@ static void gtk_tree_view_get_arrow_xrange (GtkTreeView GtkRBTree *tree, gint *x1, gint *x2); -static gint gtk_tree_view_new_column_width (GtkTreeView *tree_view, - gint i, - gint *x); static void gtk_tree_view_adjustment_changed (GtkAdjustment *adjustment, GtkTreeView *tree_view); static void gtk_tree_view_build_tree (GtkTreeView *tree_view, @@ -785,8 +785,7 @@ static gboolean gtk_tree_view_real_expand_row (GtkTreeView gboolean animate); static void gtk_tree_view_real_set_cursor (GtkTreeView *tree_view, GtkTreePath *path, - gboolean clear_and_select, - gboolean clamp_node); + SetCursorFlags flags); static gboolean gtk_tree_view_has_can_focus_cell (GtkTreeView *tree_view); static void column_sizing_notify (GObject *object, GParamSpec *pspec, @@ -1177,6 +1176,22 @@ gtk_tree_view_class_init (GtkTreeViewClass *class) -1, GTK_PARAM_READWRITE)); + /** + * GtkTreeView:activate-on-single-click: + * + * The activate-on-single-click property specifies whether the "row-activated" signal + * will be emitted after a single click. + * + * Since: 3.8 + */ + g_object_class_install_property (o_class, + PROP_ACTIVATE_ON_SINGLE_CLICK, + g_param_spec_boolean ("activate-on-single-click", + P_("Activate on Single Click"), + P_("Activate row on a single click"), + FALSE, + GTK_PARAM_READWRITE)); + /* Style properties */ #define _TREE_VIEW_EXPANDER_SIZE 14 #define _TREE_VIEW_VERTICAL_SEPARATOR 2 @@ -1273,10 +1288,12 @@ gtk_tree_view_class_init (GtkTreeViewClass *class) * @column: the #GtkTreeViewColumn in which the activation occurred * * The "row-activated" signal is emitted when the method - * gtk_tree_view_row_activated() is called or the user double clicks - * a treeview row. It is also emitted when a non-editable row is - * selected and one of the keys: Space, Shift+Space, Return or - * Enter is pressed. + * gtk_tree_view_row_activated() is called, when the user double + * clicks a treeview row with the "activate-on-single-click" + * property set to %FALSE, or when the user single clicks a row when + * the "activate-on-single-click" property set to %TRUE. It is also + * emitted when a non-editable row is selected and one of the keys: + * Space, Shift+Space, Return or Enter is pressed. * * For selection handling refer to the tree * widget conceptual overview as well as #GtkTreeSelection. @@ -1711,6 +1728,7 @@ gtk_tree_view_init (GtkTreeView *tree_view) tree_view->priv->show_expanders = TRUE; tree_view->priv->draw_keyfocus = TRUE; tree_view->priv->headers_visible = TRUE; + tree_view->priv->activate_on_single_click = FALSE; /* We need some padding */ tree_view->priv->dy = 0; @@ -1719,6 +1737,9 @@ gtk_tree_view_init (GtkTreeView *tree_view) tree_view->priv->header_height = 1; tree_view->priv->x_drag = 0; tree_view->priv->drag_pos = -1; + tree_view->priv->minimum_width = 0; + tree_view->priv->natural_width = 0; + tree_view->priv->n_expand_columns = 0; tree_view->priv->header_has_focus = FALSE; tree_view->priv->pressed_button = -1; tree_view->priv->press_start_x = -1; @@ -1751,8 +1772,6 @@ gtk_tree_view_init (GtkTreeView *tree_view) 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; @@ -1761,6 +1780,9 @@ gtk_tree_view_init (GtkTreeView *tree_view) gtk_tree_view_do_set_vadjustment (tree_view, NULL); gtk_tree_view_do_set_hadjustment (tree_view, NULL); + + gtk_style_context_add_class (gtk_widget_get_style_context (GTK_WIDGET (tree_view)), + GTK_STYLE_CLASS_VIEW); } @@ -1845,6 +1867,9 @@ gtk_tree_view_set_property (GObject *object, case PROP_TOOLTIP_COLUMN: gtk_tree_view_set_tooltip_column (tree_view, g_value_get_int (value)); break; + case PROP_ACTIVATE_ON_SINGLE_CLICK: + gtk_tree_view_set_activate_on_single_click (tree_view, g_value_get_boolean (value)); + break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; @@ -1926,6 +1951,9 @@ gtk_tree_view_get_property (GObject *object, case PROP_TOOLTIP_COLUMN: g_value_set_int (value, tree_view->priv->tooltip_column); break; + case PROP_ACTIVATE_ON_SINGLE_CLICK: + g_value_set_boolean (value, tree_view->priv->activate_on_single_click); + break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; @@ -2055,9 +2083,6 @@ gtk_tree_view_destroy (GtkWidget *widget) tree_view->priv->destroy_count_data = NULL; } - gtk_tree_row_reference_free (tree_view->priv->cursor); - tree_view->priv->cursor = NULL; - gtk_tree_row_reference_free (tree_view->priv->anchor); tree_view->priv->anchor = NULL; @@ -2187,11 +2212,8 @@ gtk_tree_view_ensure_background (GtkTreeView *tree_view) 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, gtk_widget_get_window (GTK_WIDGET (tree_view))); gtk_style_context_set_background (context, tree_view->priv->header_window); } @@ -2224,7 +2246,7 @@ gtk_tree_view_realize (GtkWidget *widget) window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask); gtk_widget_set_window (widget, window); - gdk_window_set_user_data (window, widget); + gtk_widget_register_window (widget, window); gtk_widget_get_allocation (widget, &allocation); @@ -2235,6 +2257,7 @@ gtk_tree_view_realize (GtkWidget *widget) attributes.height = allocation.height; attributes.event_mask = (GDK_EXPOSURE_MASK | GDK_SCROLL_MASK | + GDK_SMOOTH_SCROLL_MASK | GDK_POINTER_MOTION_MASK | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | @@ -2244,7 +2267,7 @@ gtk_tree_view_realize (GtkWidget *widget) tree_view->priv->bin_window = gdk_window_new (window, &attributes, attributes_mask); - gdk_window_set_user_data (tree_view->priv->bin_window, widget); + gtk_widget_register_window (widget, tree_view->priv->bin_window); gtk_widget_get_allocation (widget, &allocation); @@ -2265,7 +2288,7 @@ gtk_tree_view_realize (GtkWidget *widget) tree_view->priv->header_window = gdk_window_new (window, &attributes, attributes_mask); - gdk_window_set_user_data (tree_view->priv->header_window, widget); + gtk_widget_register_window (widget, tree_view->priv->header_window); gtk_tree_view_ensure_background (tree_view); @@ -2293,7 +2316,6 @@ gtk_tree_view_unrealize (GtkWidget *widget) { GtkTreeView *tree_view = GTK_TREE_VIEW (widget); GtkTreeViewPrivate *priv = tree_view->priv; - GtkStyleContext *context; GList *list; if (priv->scroll_timeout != 0) @@ -2314,9 +2336,6 @@ gtk_tree_view_unrealize (GtkWidget *widget) priv->open_dest_timeout = 0; } - context = gtk_widget_get_style_context (widget); - gtk_style_context_cancel_animations (context, NULL); - if (priv->presize_handler_timer != 0) { g_source_remove (priv->presize_handler_timer); @@ -2344,24 +2363,24 @@ gtk_tree_view_unrealize (GtkWidget *widget) for (list = priv->columns; list; list = list->next) _gtk_tree_view_column_unrealize_button (GTK_TREE_VIEW_COLUMN (list->data)); - gdk_window_set_user_data (priv->bin_window, NULL); + gtk_widget_unregister_window (widget, priv->bin_window); gdk_window_destroy (priv->bin_window); priv->bin_window = NULL; - gdk_window_set_user_data (priv->header_window, NULL); + gtk_widget_unregister_window (widget, priv->header_window); gdk_window_destroy (priv->header_window); priv->header_window = NULL; if (priv->drag_window) { - gdk_window_set_user_data (priv->drag_window, NULL); + gtk_widget_unregister_window (widget, priv->drag_window); gdk_window_destroy (priv->drag_window); priv->drag_window = NULL; } if (priv->drag_highlight_window) { - gdk_window_set_user_data (priv->drag_highlight_window, NULL); + gtk_widget_unregister_window (widget, priv->drag_highlight_window); gdk_window_destroy (priv->drag_highlight_window); priv->drag_highlight_window = NULL; } @@ -2369,9 +2388,9 @@ gtk_tree_view_unrealize (GtkWidget *widget) GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->unrealize (widget); } -/* GtkWidget::size_request helper */ +/* GtkWidget::get_preferred_height helper */ static void -gtk_tree_view_size_request_columns (GtkTreeView *tree_view) +gtk_tree_view_update_height (GtkTreeView *tree_view) { GList *list; @@ -2389,88 +2408,134 @@ gtk_tree_view_size_request_columns (GtkTreeView *tree_view) gtk_widget_get_preferred_size (button, &requisition, NULL); tree_view->priv->header_height = MAX (tree_view->priv->header_height, requisition.height); } -} + if (tree_view->priv->tree == NULL) + tree_view->priv->height = 0; + else + tree_view->priv->height = tree_view->priv->tree->root->offset; +} -/* Called only by ::size_request */ static void -gtk_tree_view_update_size (GtkTreeView *tree_view) +gtk_tree_view_get_preferred_width (GtkWidget *widget, + gint *minimum, + gint *natural) { + GtkTreeView *tree_view = GTK_TREE_VIEW (widget); GList *list; GtkTreeViewColumn *column; - gint i; + gint column_minimum, column_natural; - if (tree_view->priv->model == NULL) - { - tree_view->priv->width = 0; - tree_view->priv->prev_width = 0; - tree_view->priv->height = 0; - return; - } - - tree_view->priv->prev_width = tree_view->priv->width; - tree_view->priv->width = 0; + /* we validate some rows initially just to make sure we have some size. + * In practice, with a lot of static lists, this should get a good width. + */ + do_validate_rows (tree_view, FALSE); + + tree_view->priv->minimum_width = 0; + tree_view->priv->natural_width = 0; + tree_view->priv->n_expand_columns = 0; /* keep this in sync with size_allocate below */ - for (list = tree_view->priv->columns, i = 0; list; list = list->next, i++) + for (list = tree_view->priv->columns; list; list = list->next) { column = list->data; - if (!gtk_tree_view_column_get_visible (column)) + if (!gtk_tree_view_column_get_visible (column) || column == tree_view->priv->drag_column) continue; - tree_view->priv->width += _gtk_tree_view_column_request_width (column); + _gtk_tree_view_column_request_width (column, &column_minimum, &column_natural); + tree_view->priv->minimum_width += column_minimum; + tree_view->priv->natural_width += column_natural; + + if (gtk_tree_view_column_get_expand (column)) + tree_view->priv->n_expand_columns++; } - if (tree_view->priv->tree == NULL) - tree_view->priv->height = 0; - else - tree_view->priv->height = tree_view->priv->tree->root->offset; + if (minimum != NULL) + *minimum = tree_view->priv->minimum_width; + if (natural != NULL) + *natural = tree_view->priv->natural_width; } static void -gtk_tree_view_size_request (GtkWidget *widget, - GtkRequisition *requisition, - gboolean may_validate) +gtk_tree_view_get_preferred_height (GtkWidget *widget, + gint *minimum, + gint *natural) { GtkTreeView *tree_view = GTK_TREE_VIEW (widget); + gint height; - if (may_validate) - { - /* we validate some rows initially just to make sure we have some size. - * In practice, with a lot of static lists, this should get a good width. - */ - do_validate_rows (tree_view, FALSE); - } + gtk_tree_view_update_height (tree_view); - gtk_tree_view_size_request_columns (tree_view); - gtk_tree_view_update_size (GTK_TREE_VIEW (widget)); + height = tree_view->priv->height + gtk_tree_view_get_effective_header_height (tree_view); - requisition->width = tree_view->priv->width; - requisition->height = tree_view->priv->height + gtk_tree_view_get_effective_header_height (tree_view); + if (minimum != NULL) + *minimum = height; + if (natural != NULL) + *natural = height; } static void -gtk_tree_view_get_preferred_width (GtkWidget *widget, - gint *minimum, - gint *natural) +gtk_tree_view_modify_column_width (GtkTreeView *tree_view, + GtkTreeViewColumn *column, + gint width) { - GtkRequisition requisition; + gboolean is_expand; + gint n_expand_others; + gint minimum, natural, natural_others; + gint expand; - gtk_tree_view_size_request (widget, &requisition, TRUE); + is_expand = gtk_tree_view_column_get_expand (column); + n_expand_others = tree_view->priv->n_expand_columns - (is_expand ? 1 : 0); - *minimum = *natural = requisition.width; -} + _gtk_tree_view_column_request_width (column, &minimum, &natural); + natural_others = tree_view->priv->natural_width - natural; -static void -gtk_tree_view_get_preferred_height (GtkWidget *widget, - gint *minimum, - gint *natural) -{ - GtkRequisition requisition; + if (natural_others + width < tree_view->priv->width) + { + /* There is extra space that needs to be taken up by letting some other + * column(s) expand: by default, the last column. */ + if (!n_expand_others) + { + GList *last = g_list_last (tree_view->priv->columns); + while (!gtk_tree_view_column_get_visible (last->data)) + last = last->prev; - gtk_tree_view_size_request (widget, &requisition, TRUE); + if (column == last->data) + return; + + gtk_tree_view_column_set_expand (last->data, TRUE); + n_expand_others++; + } + + /* Now try to make this column expandable also. Solving the following + * equations reveals what the natural width should be to achieve the + * desired width after expanding: + * + * 1. natural + expand = desired_width + * 2. natural + natural_others + expand * (n_expand_others + 1) = total_width + * + * Solution: + * expand = (total_width - natural_others - desired_width) / n_expand_others + * + * It is possible for the solved natural width to be less than the + * minimum; in that case, we cannot let the column expand. + */ + expand = (tree_view->priv->width - natural_others - width) / n_expand_others; + + if (minimum + expand > width) + { + if (is_expand) + gtk_tree_view_column_set_expand (column, FALSE); + } + else + { + if (!is_expand) + gtk_tree_view_column_set_expand (column, TRUE); - *minimum = *natural = requisition.height; + width -= expand; + } + } + + gtk_tree_view_column_set_fixed_width (column, width); } static int @@ -2502,12 +2567,9 @@ gtk_tree_view_size_allocate_columns (GtkWidget *widget, GList *list, *first_column, *last_column; GtkTreeViewColumn *column; GtkAllocation widget_allocation; - gint width = 0; - gint extra, extra_per_column, extra_for_last; - gint full_requested_width = 0; - gint number_of_expand_columns = 0; + gint minimum_width, natural_width, n_expand_columns, width; + gint column_minimum, column_natural, column_width; gboolean rtl; - gboolean update_expand; tree_view = GTK_TREE_VIEW (widget); @@ -2527,133 +2589,88 @@ gtk_tree_view_size_allocate_columns (GtkWidget *widget, rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL); - /* find out how many extra space and expandable columns we have */ - for (list = tree_view->priv->columns; list != last_column->next; list = list->next) - { - column = (GtkTreeViewColumn *)list->data; - - if (!gtk_tree_view_column_get_visible (column)) - continue; - - full_requested_width += _gtk_tree_view_column_request_width (column); - - if (gtk_tree_view_column_get_expand (column)) - number_of_expand_columns++; - } - - /* Only update the expand value if the width of the widget has changed, - * or the number of expand columns has changed, or if there are no expand - * columns, or if we didn't have an size-allocation yet after the - * last validated node. - */ - update_expand = (width_changed && *width_changed == TRUE) - || number_of_expand_columns != tree_view->priv->last_number_of_expand_columns - || number_of_expand_columns == 0 - || tree_view->priv->post_validation_flag == TRUE; - - tree_view->priv->post_validation_flag = FALSE; - gtk_widget_get_allocation (widget, &widget_allocation); - if (!update_expand) - { - extra = tree_view->priv->last_extra_space; - extra_for_last = MAX (widget_allocation.width - full_requested_width - extra, 0); - } - else - { - extra = MAX (widget_allocation.width - full_requested_width, 0); - extra_for_last = 0; - tree_view->priv->last_extra_space = extra; - } + minimum_width = tree_view->priv->minimum_width; + natural_width = tree_view->priv->natural_width; + n_expand_columns = tree_view->priv->n_expand_columns; - if (number_of_expand_columns > 0) - extra_per_column = extra/number_of_expand_columns; - else - extra_per_column = 0; + width = MAX (widget_allocation.width, minimum_width); - if (update_expand) + /* We change the width here. The user might have been resizing columns, + * which changes the total width of the tree view. This is of + * importance for getting the horizontal scroll bar right. + */ + if (tree_view->priv->width != width) { - tree_view->priv->last_extra_space_per_column = extra_per_column; - tree_view->priv->last_number_of_expand_columns = number_of_expand_columns; + tree_view->priv->width = width; + if (width_changed) + *width_changed = TRUE; } - for (list = (rtl ? last_column : first_column); - list != (rtl ? first_column->prev : last_column->next); - list = (rtl ? list->prev : list->next)) + /* iterate through columns in reverse order */ + for (list = (rtl ? first_column : last_column); + list != (rtl ? last_column->next : first_column->prev); + list = (rtl ? list->next : list->prev)) { - gint column_width; - column = list->data; - if (!gtk_tree_view_column_get_visible (column)) + if (!gtk_tree_view_column_get_visible (column) || column == tree_view->priv->drag_column) continue; - /* We need to handle the dragged button specially. - */ - if (column == tree_view->priv->drag_column) - { - GtkAllocation drag_allocation; - GtkWidget *button; - - button = gtk_tree_view_column_get_button (tree_view->priv->drag_column); - - drag_allocation.x = 0; - drag_allocation.y = 0; - drag_allocation.width = gdk_window_get_width (tree_view->priv->drag_window); - drag_allocation.height = gdk_window_get_height (tree_view->priv->drag_window); - gtk_widget_size_allocate (button, &drag_allocation); - width += drag_allocation.width; - continue; - } - - column_width = _gtk_tree_view_column_request_width (column); + _gtk_tree_view_column_request_width (column, &column_minimum, &column_natural); + + column_width = column_natural; - if (gtk_tree_view_column_get_expand (column)) - { - if (number_of_expand_columns == 1) + if (width > natural_width) + { + /* We need to expand some columns. If there are none marked to + * expand, give all the extra space to the last column. */ + if (n_expand_columns == 0) { - /* We add the remander to the last column as - * */ - column_width += extra; + column_width = column_natural + (width - natural_width); } - else + else if (gtk_tree_view_column_get_expand (column)) { - column_width += extra_per_column; - extra -= extra_per_column; - number_of_expand_columns --; + column_width = column_natural + (width - natural_width) / n_expand_columns; + n_expand_columns--; } - } - else if (number_of_expand_columns == 0 && - list == last_column) + } + else if (width < natural_width) { - column_width += extra; + /* We need to shrink some columns. Starting with later columns, + * shrink each one down to its minimum width as necessary. */ + column_width = MAX (column_natural + (width - natural_width), column_minimum); } + + _gtk_tree_view_column_allocate (column, width - column_width, column_width); + + minimum_width -= column_minimum; + natural_width -= column_natural; + width -= column_width; + } +} - /* In addition to expand, the last column can get even more - * extra space so all available space is filled up. - */ - if (extra_for_last > 0 && list == last_column) - column_width += extra_for_last; +/* GtkWidget::size_allocate helper */ +static void +gtk_tree_view_size_allocate_drag_column (GtkWidget *widget) +{ + GtkTreeView *tree_view = GTK_TREE_VIEW (widget); + GtkAllocation drag_allocation; + GtkWidget *button; - _gtk_tree_view_column_allocate (column, width, column_width); + if (tree_view->priv->drag_column == NULL) + return; - width += column_width; - } + button = gtk_tree_view_column_get_button (tree_view->priv->drag_column); - /* We change the width here. The user might have been resizing columns, - * which changes the total width of the tree view. This is of - * importance for getting the horizontal scroll bar right. - */ - if (tree_view->priv->width != width) - { - tree_view->priv->width = width; - if (width_changed) - *width_changed = TRUE; - } + drag_allocation.x = 0; + drag_allocation.y = 0; + drag_allocation.width = gdk_window_get_width (tree_view->priv->drag_window); + drag_allocation.height = gdk_window_get_height (tree_view->priv->drag_window); + gtk_widget_size_allocate (button, &drag_allocation); } - static void gtk_tree_view_size_allocate (GtkWidget *widget, GtkAllocation *allocation) @@ -2692,6 +2709,7 @@ gtk_tree_view_size_allocate (GtkWidget *widget, * tree view (used in updating the adjustments below) might change. */ gtk_tree_view_size_allocate_columns (widget, &width_changed); + gtk_tree_view_size_allocate_drag_column (widget); g_object_freeze_notify (G_OBJECT (tree_view->priv->hadjustment)); gtk_adjustment_set_page_size (tree_view->priv->hadjustment, @@ -2724,11 +2742,6 @@ gtk_tree_view_size_allocate (GtkWidget *widget, 0, tree_view->priv->width - allocation->width)); } - else - gtk_adjustment_set_value (tree_view->priv->hadjustment, - CLAMP (tree_view->priv->width - (tree_view->priv->prev_width - gtk_adjustment_get_value (tree_view->priv->hadjustment)), - 0, - tree_view->priv->width - allocation->width)); } else { @@ -2847,6 +2860,20 @@ row_is_separator (GtkTreeView *tree_view, return is_separator; } +static int +gtk_tree_view_get_expander_size (GtkTreeView *tree_view) +{ + gint expander_size; + gint horizontal_separator; + + gtk_widget_style_get (GTK_WIDGET (tree_view), + "expander-size", &expander_size, + "horizontal-separator", &horizontal_separator, + NULL); + + return expander_size + (horizontal_separator / 2); +} + static gboolean gtk_tree_view_button_press (GtkWidget *widget, GdkEventButton *event) @@ -2869,6 +2896,10 @@ gtk_tree_view_button_press (GtkWidget *widget, "horizontal-separator", &horizontal_separator, NULL); + /* Don't handle extra mouse buttons events, let them bubble up */ + if (event->button > 5) + return FALSE; + /* Because grab_focus can cause reentrancy, we delay grab_focus until after * we're done handling the button press. */ @@ -2903,7 +2934,7 @@ gtk_tree_view_button_press (GtkWidget *widget, tree_view->priv->arrow_prelit && gtk_tree_view_draw_expanders (tree_view)) { - if (event->button == 1) + if (event->button == GDK_BUTTON_PRIMARY) { gtk_grab_add (widget); tree_view->priv->button_pressed_node = tree_view->priv->prelight_node; @@ -2931,7 +2962,7 @@ gtk_tree_view_button_press (GtkWidget *widget, } /* Get the path and the node */ - path = _gtk_tree_view_find_path (tree_view, tree, node); + path = _gtk_tree_path_new_from_rbtree (tree, node); path_is_selectable = !row_is_separator (tree_view, NULL, path); if (!path_is_selectable) @@ -2980,9 +3011,10 @@ gtk_tree_view_button_press (GtkWidget *widget, if (gtk_tree_view_draw_expanders (tree_view)) { + gint expander_size = gtk_tree_view_get_expander_size (tree_view); if (!rtl) - cell_area.x += depth * tree_view->priv->expander_size; - cell_area.width -= depth * tree_view->priv->expander_size; + cell_area.x += depth * expander_size; + cell_area.width -= depth * expander_size; } } break; @@ -2995,10 +3027,10 @@ gtk_tree_view_button_press (GtkWidget *widget, return FALSE; } - tree_view->priv->focus_column = column; + _gtk_tree_view_set_focus_column (tree_view, column); /* decide if we edit */ - if (event->type == GDK_BUTTON_PRESS && event->button == 1 && + if (event->type == GDK_BUTTON_PRESS && event->button == GDK_BUTTON_PRIMARY && !(event->state & gtk_accelerator_get_default_mod_mask ())) { GtkTreePath *anchor; @@ -3081,17 +3113,17 @@ gtk_tree_view_button_press (GtkWidget *widget, if (event->state & modify_mod_mask) { - gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE); + gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE); gtk_tree_view_real_toggle_cursor_row (tree_view); } else if (event->state & extend_mod_mask) { - gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE); + gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE); gtk_tree_view_real_select_cursor_row (tree_view, FALSE); } else { - gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE); + gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CLAMP_NODE); } tree_view->priv->modify_selection_pressed = FALSE; @@ -3134,38 +3166,47 @@ gtk_tree_view_button_press (GtkWidget *widget, } } - /* Test if a double click happened on the same row. */ - if (event->button == 1 && event->type == GDK_BUTTON_PRESS) + if (event->button == GDK_BUTTON_PRIMARY && event->type == GDK_BUTTON_PRESS) { - int double_click_time, double_click_distance; - - 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)) + /* Test if a double click happened on the same row. */ + if (!tree_view->priv->activate_on_single_click) { - /* 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; - - tree_view->priv->last_button_time = 0; - tree_view->priv->last_button_x = -1; - tree_view->priv->last_button_y = -1; + 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)) + { + /* 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; + + tree_view->priv->last_button_time = 0; + tree_view->priv->last_button_x = -1; + tree_view->priv->last_button_y = -1; + } + else + { + tree_view->priv->last_button_time = event->time; + tree_view->priv->last_button_x = event->x; + tree_view->priv->last_button_y = event->y; + } } else { - 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->button_pressed_node = tree_view->priv->prelight_node; + tree_view->priv->button_pressed_tree = tree_view->priv->prelight_tree; } } @@ -3199,11 +3240,13 @@ gtk_tree_view_button_press (GtkWidget *widget, _gtk_tree_view_column_get_window (column)) { gpointer drag_data; + gint column_width, x; if (event->type == GDK_2BUTTON_PRESS && gtk_tree_view_column_get_sizing (column) != GTK_TREE_VIEW_COLUMN_AUTOSIZE) { - _gtk_tree_view_column_set_use_resized_width (column, FALSE); + gtk_tree_view_column_set_fixed_width (column, -1); + gtk_tree_view_column_set_expand (column, FALSE); _gtk_tree_view_column_autosize (tree_view, column); return TRUE; } @@ -3222,9 +3265,6 @@ gtk_tree_view_button_press (GtkWidget *widget, gtk_grab_add (widget); tree_view->priv->in_column_resize = TRUE; - _gtk_tree_view_column_set_resized_width (column, gtk_tree_view_column_get_width (column) - - tree_view->priv->last_extra_space_per_column); - /* block attached dnd signal handler */ drag_data = g_object_get_data (G_OBJECT (widget), "gtk-site-data"); if (drag_data) @@ -3233,8 +3273,13 @@ gtk_tree_view_button_press (GtkWidget *widget, 0, 0, NULL, NULL, drag_data); + column_width = gtk_tree_view_column_get_width (column); + gdk_window_get_device_position (tree_view->priv->bin_window, + gdk_event_get_device ((GdkEvent *) event), + &x, NULL, NULL); + tree_view->priv->drag_pos = i; - tree_view->priv->x_drag = gtk_tree_view_column_get_x_offset (column) + (rtl ? 0 : gtk_tree_view_column_get_width (column)); + tree_view->priv->x_drag = x + (rtl ? column_width : -column_width); if (!gtk_widget_has_focus (widget)) gtk_widget_grab_focus (widget); @@ -3255,6 +3300,7 @@ gtk_tree_view_button_release_drag_column (GtkWidget *widget, GList *l; gboolean rtl; GdkDevice *device, *other; + GtkStyleContext *context; tree_view = GTK_TREE_VIEW (widget); @@ -3266,6 +3312,10 @@ gtk_tree_view_button_release_drag_column (GtkWidget *widget, /* Move the button back */ button = gtk_tree_view_column_get_button (tree_view->priv->drag_column); + + context = gtk_widget_get_style_context (button); + gtk_style_context_remove_class (context, GTK_STYLE_CLASS_DND); + g_object_ref (button); gtk_container_remove (GTK_CONTAINER (tree_view), button); gtk_widget_set_parent_window (button, tree_view->priv->header_window); @@ -3297,7 +3347,9 @@ gtk_tree_view_button_release_drag_column (GtkWidget *widget, tree_view->priv->cur_reorder->left_column); } tree_view->priv->drag_column = NULL; - gdk_window_hide (tree_view->priv->drag_window); + gtk_widget_unregister_window (widget, tree_view->priv->drag_window); + gdk_window_destroy (tree_view->priv->drag_window); + tree_view->priv->drag_window = NULL; for (l = tree_view->priv->column_drag_info; l != NULL; l = l->next) g_slice_free (GtkTreeViewColumnReorder, l->data); @@ -3341,6 +3393,12 @@ gtk_tree_view_button_release_column_resize (GtkWidget *widget, return TRUE; } +static gboolean +button_event_modifies_selection (GdkEventButton *event) +{ + return (event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK)) != 0; +} + static gboolean gtk_tree_view_button_release (GtkWidget *widget, GdkEventButton *event) @@ -3362,16 +3420,15 @@ gtk_tree_view_button_release (GtkWidget *widget, if (tree_view->priv->button_pressed_node == NULL) return FALSE; - if (event->button == 1) + if (event->button == GDK_BUTTON_PRIMARY + && tree_view->priv->button_pressed_node == tree_view->priv->prelight_node) { - if (tree_view->priv->button_pressed_node == tree_view->priv->prelight_node && - tree_view->priv->arrow_prelit) + if (tree_view->priv->arrow_prelit) { GtkTreePath *path = NULL; - path = _gtk_tree_view_find_path (tree_view, - tree_view->priv->button_pressed_tree, - tree_view->priv->button_pressed_node); + path = _gtk_tree_path_new_from_rbtree (tree_view->priv->button_pressed_tree, + tree_view->priv->button_pressed_node); /* Actually activate the node */ if (tree_view->priv->button_pressed_node->children == NULL) gtk_tree_view_real_expand_row (tree_view, path, @@ -3384,6 +3441,16 @@ gtk_tree_view_button_release (GtkWidget *widget, tree_view->priv->button_pressed_node, TRUE); gtk_tree_path_free (path); } + else if (tree_view->priv->activate_on_single_click + && !button_event_modifies_selection (event)) + { + GtkTreePath *path = NULL; + + path = _gtk_tree_path_new_from_rbtree (tree_view->priv->button_pressed_tree, + tree_view->priv->button_pressed_node); + gtk_tree_view_row_activated (tree_view, path, tree_view->priv->focus_column); + gtk_tree_path_free (path); + } gtk_grab_remove (widget); tree_view->priv->button_pressed_tree = NULL; @@ -3463,9 +3530,8 @@ auto_expand_timeout (gpointer data) if (tree_view->priv->prelight_node) { - path = _gtk_tree_view_find_path (tree_view, - tree_view->priv->prelight_tree, - tree_view->priv->prelight_node); + path = _gtk_tree_path_new_from_rbtree (tree_view->priv->prelight_tree, + tree_view->priv->prelight_node); if (tree_view->priv->prelight_node->children) gtk_tree_view_collapse_row (tree_view, path); @@ -3601,12 +3667,12 @@ prelight_or_select (GtkTreeView *tree_view, { GtkTreePath *path; - path = _gtk_tree_view_find_path (tree_view, tree, node); + path = _gtk_tree_path_new_from_rbtree (tree, node); gtk_tree_selection_select_path (tree_view->priv->selection, path); if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED)) { tree_view->priv->draw_keyfocus = FALSE; - gtk_tree_view_real_set_cursor (tree_view, path, FALSE, FALSE); + gtk_tree_view_real_set_cursor (tree_view, path, 0); } gtk_tree_path_free (path); } @@ -3742,8 +3808,7 @@ gtk_tree_view_motion_draw_column_motion_arrow (GtkTreeView *tree_view) if (tree_view->priv->drag_highlight_window) { - gdk_window_set_user_data (tree_view->priv->drag_highlight_window, - NULL); + gtk_widget_unregister_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window); gdk_window_destroy (tree_view->priv->drag_highlight_window); } @@ -3759,7 +3824,7 @@ gtk_tree_view_motion_draw_column_motion_arrow (GtkTreeView *tree_view) attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK; attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL; tree_view->priv->drag_highlight_window = gdk_window_new (tree_view->priv->header_window, &attributes, attributes_mask); - gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view)); + gtk_widget_register_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window); mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height); cr = cairo_create (mask_image); @@ -3783,7 +3848,7 @@ gtk_tree_view_motion_draw_column_motion_arrow (GtkTreeView *tree_view) GtkAllocation button_allocation; GtkWidget *button; - width = tree_view->priv->expander_size; + width = gtk_tree_view_get_expander_size (tree_view); /* Get x, y, width, height of arrow */ gdk_window_get_origin (tree_view->priv->header_window, &x, &y); @@ -3801,16 +3866,15 @@ gtk_tree_view_motion_draw_column_motion_arrow (GtkTreeView *tree_view) x += button_allocation.x - width/2; height = button_allocation.height; } - y -= tree_view->priv->expander_size/2; /* The arrow takes up only half the space */ - height += tree_view->priv->expander_size; + y -= width/2; /* The arrow takes up only half the space */ + height += width; /* Create the new window */ if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW) { if (tree_view->priv->drag_highlight_window) { - gdk_window_set_user_data (tree_view->priv->drag_highlight_window, - NULL); + gtk_widget_unregister_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window); gdk_window_destroy (tree_view->priv->drag_highlight_window); } @@ -3825,7 +3889,7 @@ gtk_tree_view_motion_draw_column_motion_arrow (GtkTreeView *tree_view) attributes.height = height; tree_view->priv->drag_highlight_window = gdk_window_new (gtk_widget_get_root_window (widget), &attributes, attributes_mask); - gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view)); + gtk_widget_register_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window); mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height); @@ -3855,11 +3919,12 @@ gtk_tree_view_motion_draw_column_motion_arrow (GtkTreeView *tree_view) { GtkAllocation allocation; GtkWidget *button; + gint expander_size; - width = tree_view->priv->expander_size; + expander_size = gtk_tree_view_get_expander_size (tree_view); /* Get x, y, width, height of arrow */ - width = width/2; /* remember, the arrow only takes half the available width */ + width = expander_size/2; /* remember, the arrow only takes half the available width */ gdk_window_get_origin (gtk_widget_get_window (widget), &x, &y); if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT) @@ -3881,8 +3946,8 @@ gtk_tree_view_motion_draw_column_motion_arrow (GtkTreeView *tree_view) height = allocation.height; } - y -= tree_view->priv->expander_size; - height += 2*tree_view->priv->expander_size; + y -= expander_size; + height += 2 * expander_size; /* Create the new window */ if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT && @@ -3890,8 +3955,7 @@ gtk_tree_view_motion_draw_column_motion_arrow (GtkTreeView *tree_view) { if (tree_view->priv->drag_highlight_window) { - gdk_window_set_user_data (tree_view->priv->drag_highlight_window, - NULL); + gtk_widget_unregister_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window); gdk_window_destroy (tree_view->priv->drag_highlight_window); } @@ -3904,8 +3968,8 @@ gtk_tree_view_motion_draw_column_motion_arrow (GtkTreeView *tree_view) attributes.y = y; attributes.width = width; attributes.height = height; - tree_view->priv->drag_highlight_window = gdk_window_new (NULL, &attributes, attributes_mask); - gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view)); + tree_view->priv->drag_highlight_window = gdk_window_new (gtk_widget_get_root_window (widget), &attributes, attributes_mask); + gtk_widget_register_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window); mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height); @@ -3918,10 +3982,10 @@ gtk_tree_view_motion_draw_column_motion_arrow (GtkTreeView *tree_view) } cairo_move_to (cr, 0, 0); cairo_line_to (cr, width, width); - cairo_line_to (cr, 0, tree_view->priv->expander_size); + cairo_line_to (cr, 0, expander_size); cairo_move_to (cr, 0, height); cairo_line_to (cr, width, height - width); - cairo_line_to (cr, 0, height - tree_view->priv->expander_size); + cairo_line_to (cr, 0, height - expander_size); cairo_fill (cr); cairo_destroy (cr); @@ -3958,31 +4022,17 @@ gtk_tree_view_motion_resize_column (GtkWidget *widget, column = gtk_tree_view_get_column (tree_view, tree_view->priv->drag_pos); - if (event->is_hint || event->window != gtk_widget_get_window (widget)) - gdk_window_get_device_position (gtk_widget_get_window (widget), - gdk_event_get_device ((GdkEvent *) event), - &x, NULL, NULL); - else - x = event->x; - - if (tree_view->priv->hadjustment) - x += gtk_adjustment_get_value (tree_view->priv->hadjustment); - - new_width = gtk_tree_view_new_column_width (tree_view, - tree_view->priv->drag_pos, &x); - if (x != tree_view->priv->x_drag && - (new_width != gtk_tree_view_column_get_fixed_width (column))) - { - _gtk_tree_view_column_set_use_resized_width (column, TRUE); - - if (gtk_tree_view_column_get_expand (column)) - new_width -= tree_view->priv->last_extra_space_per_column; - - _gtk_tree_view_column_set_resized_width (column, new_width); + gdk_window_get_device_position (tree_view->priv->bin_window, + gdk_event_get_device ((GdkEvent *) event), + &x, NULL, NULL); + if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) + new_width = MAX (tree_view->priv->x_drag - x, 0); + else + new_width = MAX (x - tree_view->priv->x_drag, 0); - gtk_widget_queue_resize (widget); - } + if (new_width != gtk_tree_view_column_get_width (column)) + gtk_tree_view_modify_column_width (tree_view, column, new_width); return FALSE; } @@ -4120,9 +4170,8 @@ gtk_tree_view_stop_rubber_band (GtkTreeView *tree_view) gtk_widget_queue_draw (GTK_WIDGET (tree_view)); /* The anchor path should be set to the start path */ - tmp_path = _gtk_tree_view_find_path (tree_view, - tree_view->priv->rubber_band_start_tree, - tree_view->priv->rubber_band_start_node); + tmp_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->rubber_band_start_tree, + tree_view->priv->rubber_band_start_node); if (tree_view->priv->anchor) gtk_tree_row_reference_free (tree_view->priv->anchor); @@ -4135,10 +4184,9 @@ gtk_tree_view_stop_rubber_band (GtkTreeView *tree_view) gtk_tree_path_free (tmp_path); /* ... and the cursor to the end path */ - tmp_path = _gtk_tree_view_find_path (tree_view, - tree_view->priv->rubber_band_end_tree, - tree_view->priv->rubber_band_end_node); - gtk_tree_view_real_set_cursor (GTK_TREE_VIEW (tree_view), tmp_path, FALSE, FALSE); + tmp_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->rubber_band_end_tree, + tree_view->priv->rubber_band_end_node); + gtk_tree_view_real_set_cursor (GTK_TREE_VIEW (tree_view), tmp_path, 0); gtk_tree_path_free (tmp_path); _gtk_tree_selection_emit_changed (tree_view->priv->selection); @@ -4182,7 +4230,7 @@ gtk_tree_view_update_rubber_band_selection_range (GtkTreeView *tree_view, GtkTreePath *path; gboolean selectable; - path = _gtk_tree_view_find_path (tree_view, start_tree, start_node); + path = _gtk_tree_path_new_from_rbtree (start_tree, start_node); selectable = _gtk_tree_selection_row_is_selectable (tree_view->priv->selection, start_node, path); gtk_tree_path_free (path); @@ -4233,9 +4281,7 @@ skip_first: if (start_node->children) { start_tree = start_node->children; - start_node = start_tree->root; - while (start_node->left != start_tree->nil) - start_node = start_node->left; + start_node = _gtk_rbtree_first (start_tree); } else { @@ -4559,17 +4605,10 @@ draw_empty_focus (GtkTreeView *tree_view, cairo_t *cr) if (w > 0 && h > 0) { GtkStyleContext *context; - GtkStateFlags state; context = gtk_widget_get_style_context (widget); - state = gtk_widget_get_state_flags (widget); - - gtk_style_context_save (context); - gtk_style_context_set_state (context, state); gtk_render_focus (context, cr, 1, 1, w, h); - - gtk_style_context_restore (context); } } @@ -4684,8 +4723,6 @@ gtk_tree_view_bin_draw (GtkWidget *widget, GtkRBTree *tree; GList *list; GtkRBNode *node; - GtkRBNode *cursor = NULL; - GtkRBTree *cursor_tree = NULL; GtkRBNode *drag_highlight = NULL; GtkRBTree *drag_highlight_tree = NULL; GtkTreeIter iter; @@ -4701,31 +4738,27 @@ gtk_tree_view_bin_draw (GtkWidget *widget, gint expander_cell_width; gint bin_window_width; gint bin_window_height; - GtkTreePath *cursor_path; GtkTreePath *drag_dest_path; GList *first_column, *last_column; gint vertical_separator; gint horizontal_separator; - gint focus_line_width; gboolean allow_rules; gboolean has_can_focus_cell; gboolean rtl; gint n_visible_columns; gint grid_line_width; + gint expander_size; gboolean draw_vgrid_lines, draw_hgrid_lines; GtkStyleContext *context; - GtkStateFlags state; gboolean parity; rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL); context = gtk_widget_get_style_context (widget); - state = gtk_widget_get_state_flags (widget); gtk_widget_style_get (widget, "horizontal-separator", &horizontal_separator, "vertical-separator", &vertical_separator, "allow-rules", &allow_rules, - "focus-line-width", &focus_line_width, NULL); if (tree_view->priv->tree == NULL) @@ -4750,7 +4783,6 @@ gtk_tree_view_bin_draw (GtkWidget *widget, if (tree_view->priv->height < bin_window_height) { gtk_style_context_save (context); - gtk_style_context_set_state (context, state); gtk_style_context_add_class (context, GTK_STYLE_CLASS_CELL); gtk_render_background (context, cr, @@ -4765,25 +4797,15 @@ gtk_tree_view_bin_draw (GtkWidget *widget, return TRUE; /* find the path for the node */ - path = _gtk_tree_view_find_path ((GtkTreeView *)widget, - tree, - node); + path = _gtk_tree_path_new_from_rbtree (tree, node); gtk_tree_model_get_iter (tree_view->priv->model, &iter, path); depth = gtk_tree_path_get_depth (path); gtk_tree_path_free (path); - cursor_path = NULL; drag_dest_path = NULL; - if (tree_view->priv->cursor) - cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor); - - if (cursor_path) - _gtk_tree_view_find_node (tree_view, cursor_path, - &cursor_tree, &cursor); - if (tree_view->priv->drag_dest_row) drag_dest_path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row); @@ -4797,6 +4819,7 @@ gtk_tree_view_bin_draw (GtkWidget *widget, draw_hgrid_lines = tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_HORIZONTAL || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH; + expander_size = gtk_tree_view_get_expander_size (tree_view); if (draw_vgrid_lines || draw_hgrid_lines) gtk_widget_style_get (widget, "grid-line-width", &grid_line_width, NULL); @@ -4903,11 +4926,21 @@ gtk_tree_view_bin_draw (GtkWidget *widget, else flags &= ~GTK_CELL_RENDERER_SORTED; - if (cursor == node) + if (tree_view->priv->cursor_node == node) flags |= GTK_CELL_RENDERER_FOCUSED; else flags &= ~GTK_CELL_RENDERER_FOCUSED; + if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT)) + flags |= GTK_CELL_RENDERER_EXPANDABLE; + else + flags &= ~GTK_CELL_RENDERER_EXPANDABLE; + + if (node->children) + flags |= GTK_CELL_RENDERER_EXPANDED; + else + flags &= ~GTK_CELL_RENDERER_EXPANDED; + background_area.x = cell_offset; background_area.width = width; @@ -4992,7 +5025,7 @@ gtk_tree_view_bin_draw (GtkWidget *widget, gtk_style_context_add_region (context, GTK_STYLE_REGION_ROW, row_flags); gtk_style_context_add_region (context, GTK_STYLE_REGION_COLUMN, column_flags); - if (node == cursor && has_can_focus_cell + if (node == tree_view->priv->cursor_node && has_can_focus_cell && ((column == tree_view->priv->focus_column && tree_view->priv->draw_keyfocus && gtk_widget_has_visible_focus (widget)) @@ -5023,9 +5056,10 @@ gtk_tree_view_bin_draw (GtkWidget *widget, if (gtk_tree_view_draw_expanders (tree_view)) { + int expander_size = gtk_tree_view_get_expander_size (tree_view); if (!rtl) - cell_area.x += depth * tree_view->priv->expander_size; - cell_area.width -= depth * tree_view->priv->expander_size; + cell_area.x += depth * expander_size; + cell_area.width -= depth * expander_size; } /* If we have an expander column, the highlight underline @@ -5125,18 +5159,18 @@ gtk_tree_view_bin_draw (GtkWidget *widget, { gtk_tree_view_draw_line (tree_view, cr, GTK_TREE_VIEW_TREE_LINE, - x + tree_view->priv->expander_size * (depth - 1.5) * mult, + x + expander_size * (depth - 1.5) * mult, y1, - x + tree_view->priv->expander_size * (depth - 1.1) * mult, + x + expander_size * (depth - 1.1) * mult, y1); } else if (depth > 1) { gtk_tree_view_draw_line (tree_view, cr, GTK_TREE_VIEW_TREE_LINE, - x + tree_view->priv->expander_size * (depth - 1.5) * mult, + x + expander_size * (depth - 1.5) * mult, y1, - x + tree_view->priv->expander_size * (depth - 0.5) * mult, + x + expander_size * (depth - 0.5) * mult, y1); } @@ -5149,16 +5183,16 @@ gtk_tree_view_bin_draw (GtkWidget *widget, if (!_gtk_rbtree_next (tree, node)) gtk_tree_view_draw_line (tree_view, cr, GTK_TREE_VIEW_TREE_LINE, - x + tree_view->priv->expander_size * (depth - 1.5) * mult, + x + expander_size * (depth - 1.5) * mult, y0, - x + tree_view->priv->expander_size * (depth - 1.5) * mult, + x + expander_size * (depth - 1.5) * mult, y1); else gtk_tree_view_draw_line (tree_view, cr, GTK_TREE_VIEW_TREE_LINE, - x + tree_view->priv->expander_size * (depth - 1.5) * mult, + x + expander_size * (depth - 1.5) * mult, y0, - x + tree_view->priv->expander_size * (depth - 1.5) * mult, + x + expander_size * (depth - 1.5) * mult, y2); tmp_node = tree->parent_node; @@ -5169,9 +5203,9 @@ gtk_tree_view_bin_draw (GtkWidget *widget, if (_gtk_rbtree_next (tmp_tree, tmp_node)) gtk_tree_view_draw_line (tree_view, cr, GTK_TREE_VIEW_TREE_LINE, - x + tree_view->priv->expander_size * (i - 0.5) * mult, + x + expander_size * (i - 0.5) * mult, y0, - x + tree_view->priv->expander_size * (i - 0.5) * mult, + x + expander_size * (i - 0.5) * mult, y2); tmp_node = tmp_tree->parent_node; @@ -5192,6 +5226,9 @@ gtk_tree_view_bin_draw (GtkWidget *widget, GtkRBTree *tree = NULL; GtkRBNode *node = NULL; + gtk_style_context_save (context); + gtk_style_context_add_class (context, GTK_STYLE_CLASS_DND); + switch (tree_view->priv->drag_dest_pos) { case GTK_TREE_VIEW_DROP_BEFORE: @@ -5211,12 +5248,10 @@ gtk_tree_view_bin_draw (GtkWidget *widget, if (tree == NULL) break; - gtk_render_focus (context, cr, - 0, gtk_tree_view_get_row_y_offset (tree_view, tree, node) - - focus_line_width / 2, - gdk_window_get_width (tree_view->priv->bin_window), - gtk_tree_view_get_row_height (tree_view, node) - - focus_line_width + 1); + gtk_render_frame (context, cr, + 0, gtk_tree_view_get_row_y_offset (tree_view, tree, node), + gdk_window_get_width (tree_view->priv->bin_window), + gtk_tree_view_get_row_height (tree_view, node)); break; } @@ -5229,10 +5264,12 @@ gtk_tree_view_bin_draw (GtkWidget *widget, rtl ? 0 : bin_window_width, highlight_y); } + + gtk_style_context_restore (context); } /* draw the big row-spanning focus rectangle, if needed */ - if (!has_can_focus_cell && node == cursor && + if (!has_can_focus_cell && node == tree_view->priv->cursor_node && tree_view->priv->draw_keyfocus && gtk_widget_has_visible_focus (widget)) { @@ -5270,12 +5307,8 @@ gtk_tree_view_bin_draw (GtkWidget *widget, gboolean has_child; tree = node->children; - node = tree->root; + node = _gtk_rbtree_first (tree); - g_assert (node != tree->nil); - - while (node->left != tree->nil) - node = node->left; has_child = gtk_tree_model_iter_children (tree_view->priv->model, &iter, &parent); @@ -5329,9 +5362,6 @@ done: if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE) gtk_tree_view_paint_rubber_band (tree_view, cr); - if (cursor_path) - gtk_tree_path_free (cursor_path); - if (drag_dest_path) gtk_tree_path_free (drag_dest_path); @@ -5344,24 +5374,23 @@ gtk_tree_view_draw (GtkWidget *widget, { GtkTreeView *tree_view = GTK_TREE_VIEW (widget); GtkWidget *button; + GtkStyleContext *context; + + context = gtk_widget_get_style_context (widget); + gtk_render_background (context, cr, + 0, 0, + gtk_widget_get_allocated_width (widget), + gtk_widget_get_allocated_height (widget)); if (gtk_cairo_should_draw_window (cr, tree_view->priv->bin_window)) { - GtkStyleContext *context; GList *tmp_list; - context = gtk_widget_get_style_context (widget); - cairo_save (cr); - gtk_style_context_save (context); - gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW); - gtk_cairo_transform_to_window (cr, widget, tree_view->priv->bin_window); - gtk_tree_view_bin_draw (widget, cr); - gtk_style_context_restore (context); cairo_restore (cr); /* We can't just chain up to Container::draw as it will try to send the @@ -5378,6 +5407,9 @@ gtk_tree_view_draw (GtkWidget *widget, } } + gtk_style_context_save (context); + gtk_style_context_remove_class (context, GTK_STYLE_CLASS_VIEW); + if (gtk_cairo_should_draw_window (cr, tree_view->priv->header_window)) { GList *list; @@ -5406,6 +5438,8 @@ gtk_tree_view_draw (GtkWidget *widget, button, cr); } + gtk_style_context_restore (context); + return FALSE; } @@ -5672,7 +5706,7 @@ gtk_tree_view_key_press (GtkWidget *widget, || event->keyval == GDK_KEY_Right || event->keyval == GDK_KEY_KP_Right)) { GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data); - gint max_width, min_width; + gint column_width; if (!gtk_tree_view_column_get_resizable (column)) { @@ -5680,70 +5714,20 @@ gtk_tree_view_key_press (GtkWidget *widget, return TRUE; } + column_width = gtk_tree_view_column_get_width (column); + if (event->keyval == (rtl ? GDK_KEY_Right : GDK_KEY_Left) || event->keyval == (rtl ? GDK_KEY_KP_Right : GDK_KEY_KP_Left)) { - GtkRequisition button_req; - gint old_width = _gtk_tree_view_column_get_resized_width (column); - gint new_width; - - button = gtk_tree_view_column_get_button (column); - - gtk_widget_get_preferred_size (button, &button_req, NULL); - - new_width = MAX (old_width, gtk_tree_view_column_get_width (column)); - new_width -= 2; - if (new_width < 0) - new_width = 0; - - _gtk_tree_view_column_set_resized_width (column, new_width); - - min_width = gtk_tree_view_column_get_min_width (column); - if (min_width == -1) - new_width = MAX (button_req.width, new_width); - else - { - new_width = MAX (min_width, new_width); - } - - max_width = gtk_tree_view_column_get_max_width (column); - if (max_width != -1) - new_width = MIN (new_width, max_width); - - _gtk_tree_view_column_set_use_resized_width (column, TRUE); - - if (new_width != old_width) - { - _gtk_tree_view_column_set_resized_width (column, new_width); - gtk_widget_queue_resize (widget); - } - else - gtk_widget_error_bell (widget); + column_width = MAX (column_width - 2, 0); } else if (event->keyval == (rtl ? GDK_KEY_Left : GDK_KEY_Right) || event->keyval == (rtl ? GDK_KEY_KP_Left : GDK_KEY_KP_Right)) { - gint old_width = _gtk_tree_view_column_get_resized_width (column); - gint new_width; - - new_width = MAX (old_width, gtk_tree_view_column_get_width (column)); - new_width += 2; - - max_width = gtk_tree_view_column_get_max_width (column); - if (max_width != -1) - new_width = MIN (new_width, max_width); - - _gtk_tree_view_column_set_use_resized_width (column, TRUE); - - if (new_width != old_width) - { - _gtk_tree_view_column_set_resized_width (column, new_width); - gtk_widget_queue_resize (widget); - } - else - gtk_widget_error_bell (widget); + column_width = column_width + 2; } + gtk_tree_view_modify_column_width (tree_view, column, column_width); return TRUE; } @@ -6045,6 +6029,7 @@ validate_row (GtkTreeView *tree_view, gint grid_line_width; gboolean wide_separators; gint separator_height; + gint expander_size; /* double check the row needs validating */ if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) && @@ -6068,6 +6053,7 @@ validate_row (GtkTreeView *tree_view, draw_hgrid_lines = tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_HORIZONTAL || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH; + expander_size = gtk_tree_view_get_expander_size (tree_view); for (last_column = g_list_last (tree_view->priv->columns); last_column && @@ -6110,7 +6096,7 @@ validate_row (GtkTreeView *tree_view, { row_height += vertical_separator; height = MAX (height, row_height); - height = MAX (height, tree_view->priv->expander_size); + height = MAX (height, expander_size); } else { @@ -6125,7 +6111,7 @@ validate_row (GtkTreeView *tree_view, padding += horizontal_separator + (depth - 1) * tree_view->priv->level_indentation; if (gtk_tree_view_draw_expanders (tree_view)) - padding += depth * tree_view->priv->expander_size; + padding += depth * expander_size; } else padding += horizontal_separator; @@ -6155,7 +6141,6 @@ validate_row (GtkTreeView *tree_view, _gtk_rbtree_node_set_height (tree, node, height); } _gtk_rbtree_node_mark_valid (tree, node); - tree_view->priv->post_validation_flag = TRUE; return retval; } @@ -6305,7 +6290,7 @@ validate_visible_area (GtkTreeView *tree_view) } else { - path = _gtk_tree_view_find_path (tree_view, tree, node); + path = _gtk_tree_path_new_from_rbtree (tree, node); total_height += offset; } @@ -6343,7 +6328,7 @@ validate_visible_area (GtkTreeView *tree_view) GtkTreePath *tmppath; GtkTreeIter tmpiter; - tmppath = _gtk_tree_view_find_path (tree_view, tmptree, tmpnode); + tmppath = _gtk_tree_path_new_from_rbtree (tmptree, tmpnode); gtk_tree_model_get_iter (tree_view->priv->model, &tmpiter, tmppath); if (GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_INVALID) || @@ -6371,12 +6356,8 @@ validate_visible_area (GtkTreeView *tree_view) gboolean has_child; tree = node->children; - node = tree->root; - - g_assert (node != tree->nil); + node = _gtk_rbtree_first (tree); - while (node->left != tree->nil) - node = node->left; has_child = gtk_tree_model_iter_children (tree_view->priv->model, &iter, &parent); @@ -6459,7 +6440,7 @@ validate_visible_area (GtkTreeView *tree_view) break; gtk_tree_path_free (above_path); - above_path = _gtk_tree_view_find_path (tree_view, tree, node); + above_path = _gtk_tree_path_new_from_rbtree (tree, node); gtk_tree_model_get_iter (tree_view->priv->model, &iter, above_path); @@ -6551,7 +6532,7 @@ initialize_fixed_height_mode (GtkTreeView *tree_view) tree = tree_view->priv->tree; node = tree->root; - path = _gtk_tree_view_find_path (tree_view, tree, node); + path = _gtk_tree_path_new_from_rbtree (tree, node); gtk_tree_model_get_iter (tree_view->priv->model, &iter, path); validate_row (tree_view, tree, node, &iter, path); @@ -6574,6 +6555,8 @@ initialize_fixed_height_mode (GtkTreeView *tree_view) static gboolean do_validate_rows (GtkTreeView *tree_view, gboolean queue_resize) { + static gboolean prevent_recursion_hack = FALSE; + GtkRBTree *tree = NULL; GtkRBNode *node = NULL; gboolean validated_area = FALSE; @@ -6589,6 +6572,10 @@ do_validate_rows (GtkTreeView *tree_view, gboolean queue_resize) g_assert (tree_view); + /* prevent infinite recursion via get_preferred_width() */ + if (prevent_recursion_hack) + return FALSE; + if (tree_view->priv->tree == NULL) return FALSE; @@ -6637,12 +6624,12 @@ do_validate_rows (GtkTreeView *tree_view, gboolean queue_resize) do { - if (node->left != tree->nil && + if (!_gtk_rbtree_is_nil (node->left) && GTK_RBNODE_FLAG_SET (node->left, GTK_RBNODE_DESCENDANTS_INVALID)) { node = node->left; } - else if (node->right != tree->nil && + else if (!_gtk_rbtree_is_nil (node->right) && GTK_RBNODE_FLAG_SET (node->right, GTK_RBNODE_DESCENDANTS_INVALID)) { node = node->right; @@ -6662,7 +6649,7 @@ do_validate_rows (GtkTreeView *tree_view, gboolean queue_resize) g_assert_not_reached (); } while (TRUE); - path = _gtk_tree_view_find_path (tree_view, tree, node); + path = _gtk_tree_path_new_from_rbtree (tree, node); gtk_tree_model_get_iter (tree_view->priv->model, &iter, path); } @@ -6719,7 +6706,10 @@ do_validate_rows (GtkTreeView *tree_view, gboolean queue_resize) * Currently bypassing this but the real solution is to not update the scroll adjustments * untill we've recieved an allocation (never update scroll adjustments from size-requests). */ - gtk_tree_view_size_request (GTK_WIDGET (tree_view), &requisition, FALSE); + prevent_recursion_hack = TRUE; + gtk_tree_view_get_preferred_width (GTK_WIDGET (tree_view), &requisition.width, NULL); + gtk_tree_view_get_preferred_height (GTK_WIDGET (tree_view), &requisition.height, NULL); + prevent_recursion_hack = FALSE; /* If rows above the current position have changed height, this has * affected the current view and thus needs a redraw. @@ -6828,21 +6818,6 @@ install_presize_handler (GtkTreeView *tree_view) } } -static void -gtk_tree_view_bin_process_updates (GtkTreeView *tree_view) -{ - /* Prior to drawing, we make sure the visible area is validated. */ - if (tree_view->priv->presize_handler_timer) - { - g_source_remove (tree_view->priv->presize_handler_timer); - tree_view->priv->presize_handler_timer = 0; - - do_presize_handler (tree_view); - } - - gdk_window_process_updates (tree_view->priv->bin_window, TRUE); -} - static gboolean scroll_sync_handler (GtkTreeView *tree_view) { @@ -6917,7 +6892,7 @@ gtk_tree_view_dy_to_top_row (GtkTreeView *tree_view) } else { - path = _gtk_tree_view_find_path (tree_view, tree, node); + path = _gtk_tree_path_new_from_rbtree (tree, node); gtk_tree_view_set_top_row (tree_view, path, offset); gtk_tree_path_free (path); } @@ -7184,7 +7159,7 @@ drag_scan_timeout (gpointer data) GtkTreeViewColumn *column = NULL; GdkRectangle visible_rect; - GDK_THREADS_ENTER (); + gdk_threads_enter (); tree_view = GTK_TREE_VIEW (data); @@ -7222,7 +7197,7 @@ drag_scan_timeout (gpointer data) } } - GDK_THREADS_LEAVE (); + gdk_threads_leave (); return TRUE; } @@ -8150,9 +8125,6 @@ gtk_tree_view_set_fixed_height_mode (GtkTreeView *tree_view, { tree_view->priv->fixed_height_mode = 0; tree_view->priv->fixed_height = -1; - - /* force a revalidation */ - install_presize_handler (tree_view); } else { @@ -8171,11 +8143,11 @@ gtk_tree_view_set_fixed_height_mode (GtkTreeView *tree_view, tree_view->priv->fixed_height_mode = 1; tree_view->priv->fixed_height = -1; - - if (tree_view->priv->tree) - initialize_fixed_height_mode (tree_view); } + /* force a revalidation */ + install_presize_handler (tree_view); + g_object_notify (G_OBJECT (tree_view), "fixed-height-mode"); } @@ -8347,7 +8319,7 @@ gtk_tree_view_header_focus (GtkTreeView *tree_view, for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next) if (gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (tmp_list->data)) == focus_child) { - tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (tmp_list->data); + _gtk_tree_view_set_focus_column (tree_view, GTK_TREE_VIEW_COLUMN (tmp_list->data)); break; } @@ -8394,7 +8366,7 @@ search_first_focusable_path (GtkTreeView *tree_view, gtk_tree_path_free (*path); if (node) - *path = _gtk_tree_view_find_path (tree_view, tree, node); + *path = _gtk_tree_path_new_from_rbtree (tree, node); else *path = NULL; } @@ -8476,6 +8448,8 @@ gtk_tree_view_style_updated (GtkWidget *widget) GtkTreeView *tree_view = GTK_TREE_VIEW (widget); GList *list; GtkTreeViewColumn *column; + GtkStyleContext *style_context; + const GtkBitmask *changes; GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->style_updated (widget); @@ -8487,21 +8461,19 @@ gtk_tree_view_style_updated (GtkWidget *widget) gtk_tree_view_set_enable_tree_lines (tree_view, tree_view->priv->tree_lines_enabled); } - gtk_widget_style_get (widget, - "expander-size", &tree_view->priv->expander_size, - NULL); - tree_view->priv->expander_size += EXPANDER_EXTRA_PADDING; - - for (list = tree_view->priv->columns; list; list = list->next) + style_context = gtk_widget_get_style_context (widget); + changes = _gtk_style_context_get_changes (style_context); + if (changes == NULL || _gtk_css_style_property_changes_affect_size (changes)) { - column = list->data; - _gtk_tree_view_column_cell_set_dirty (column, TRUE); - } - - tree_view->priv->fixed_height = -1; - _gtk_rbtree_mark_invalid (tree_view->priv->tree); + for (list = tree_view->priv->columns; list; list = list->next) + { + column = list->data; + _gtk_tree_view_column_cell_set_dirty (column, TRUE); + } - gtk_widget_queue_resize (widget); + tree_view->priv->fixed_height = -1; + _gtk_rbtree_mark_invalid (tree_view->priv->tree); + } } @@ -8516,7 +8488,7 @@ gtk_tree_view_set_focus_child (GtkContainer *container, { if (gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (list->data)) == child) { - tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (list->data); + _gtk_tree_view_set_focus_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data)); break; } } @@ -8531,21 +8503,27 @@ gtk_tree_view_get_path_for_child (GtkContainer *container, GtkTreeView *tree_view = GTK_TREE_VIEW (container); GtkWidgetPath *path; gboolean rtl; - GList *list; + GList *list, *visible_columns = NULL; gint n_col = 0; path = GTK_CONTAINER_CLASS (gtk_tree_view_parent_class)->get_path_for_child (container, child); rtl = (gtk_widget_get_direction (GTK_WIDGET (container)) == GTK_TEXT_DIR_RTL); - for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns)); - list; - list = (rtl ? list->prev : list->next)) + for (list = tree_view->priv->columns; list; list = list->next) { GtkTreeViewColumn *column = list->data; - GtkRegionFlags flags = 0; - if (!gtk_tree_view_column_get_visible (column)) - continue; + if (gtk_tree_view_column_get_visible (column)) + visible_columns = g_list_prepend (visible_columns, column); + } + + if (!rtl) + visible_columns = g_list_reverse (visible_columns); + + for (list = visible_columns; list != NULL; list = list->next) + { + GtkTreeViewColumn *column = list->data; + GtkRegionFlags flags = 0; n_col++; @@ -8561,15 +8539,13 @@ gtk_tree_view_get_path_for_child (GtkContainer *container, if (n_col == 1) flags |= GTK_REGION_FIRST; - if ((rtl && !list->prev) || - (!rtl && !list->next)) + if (!list->next) flags |= GTK_REGION_LAST; - gtk_widget_path_iter_add_region (path, -1, GTK_STYLE_REGION_COLUMN_HEADER, flags); + gtk_widget_path_iter_add_region (path, gtk_widget_path_length (path) - 2, GTK_STYLE_REGION_COLUMN_HEADER, flags); break; } - - gtk_widget_path_append_for_widget (path, child); + g_list_free (visible_columns); return path; } @@ -8728,8 +8704,9 @@ gtk_tree_view_row_changed (GtkTreeModel *model, g_return_if_fail (path != NULL || iter != NULL); - if (tree_view->priv->cursor != NULL) - cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor); + if (tree_view->priv->cursor_node != NULL) + cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree, + tree_view->priv->cursor_node); else cursor_path = NULL; @@ -8758,6 +8735,8 @@ gtk_tree_view_row_changed (GtkTreeModel *model, if (tree == NULL) goto done; + _gtk_tree_view_accessible_changed (tree_view, tree, node); + if (tree_view->priv->fixed_height_mode && tree_view->priv->fixed_height >= 0) { @@ -8857,9 +8836,7 @@ gtk_tree_view_row_inserted (GtkTreeModel *model, /* In theory, the model should have emitted has_child_toggled here. We * try to catch it anyway, just to be safe, in case the model hasn't. */ - GtkTreePath *tmppath = _gtk_tree_view_find_path (tree_view, - tree, - tmpnode); + GtkTreePath *tmppath = _gtk_tree_path_new_from_rbtree (tree, tmpnode); gtk_tree_view_row_has_child_toggled (model, tmppath, NULL, data); gtk_tree_path_free (tmppath); goto done; @@ -8888,6 +8865,8 @@ gtk_tree_view_row_inserted (GtkTreeModel *model, tmpnode = _gtk_rbtree_insert_after (tree, tmpnode, height, FALSE); } + _gtk_tree_view_accessible_add (tree_view, tree, tmpnode); + done: if (height > 0) { @@ -8948,9 +8927,15 @@ gtk_tree_view_row_has_child_toggled (GtkTreeModel *model, goto done; if (has_child) - GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PARENT); + { + GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PARENT); + _gtk_tree_view_accessible_add_state (tree_view, tree, node, GTK_CELL_RENDERER_EXPANDABLE); + } else - GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_PARENT); + { + GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_PARENT); + _gtk_tree_view_accessible_remove_state (tree_view, tree, node, GTK_CELL_RENDERER_EXPANDABLE); + } if (has_child && tree_view->priv->is_list) { @@ -8995,7 +8980,7 @@ check_selection_helper (GtkRBTree *tree, { gint *value = (gint *)data; - *value = GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED); + *value |= GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED); if (node->children && !*value) _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, check_selection_helper, data); @@ -9010,8 +8995,9 @@ gtk_tree_view_row_deleted (GtkTreeModel *model, GtkRBTree *tree; GtkRBNode *node; GList *list; - gint selection_changed = FALSE; - GtkStyleContext *context; + gboolean selection_changed = FALSE, cursor_changed = FALSE; + GtkRBTree *cursor_tree = NULL; + GtkRBNode *cursor_node = NULL; g_return_if_fail (path != NULL); @@ -9035,8 +9021,55 @@ gtk_tree_view_row_deleted (GtkTreeModel *model, /* Ensure we don't have a dangling pointer to a dead node */ ensure_unprelighted (tree_view); - /* Cancel editting if we've started */ - gtk_tree_view_stop_editing (tree_view, TRUE); + /* Cancel editting if we've started */ + gtk_tree_view_stop_editing (tree_view, TRUE); + + /* If the cursor row got deleted, move the cursor to the next row */ + if (tree_view->priv->cursor_node && + (tree_view->priv->cursor_node == node || + (node->children && (tree_view->priv->cursor_tree == node->children || + _gtk_rbtree_contains (node->children, tree_view->priv->cursor_tree))))) + { + GtkTreePath *cursor_path; + + cursor_tree = tree; + cursor_node = _gtk_rbtree_next (tree, node); + /* find the first node that is not going to be deleted */ + while (cursor_node == NULL && cursor_tree->parent_tree) + { + cursor_node = _gtk_rbtree_next (cursor_tree->parent_tree, + cursor_tree->parent_node); + cursor_tree = cursor_tree->parent_tree; + } + + if (cursor_node != NULL) + cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node); + else + cursor_path = NULL; + + if (cursor_path == NULL || + ! search_first_focusable_path (tree_view, &cursor_path, TRUE, + &cursor_tree, &cursor_node)) + { + /* It looks like we reached the end of the view without finding + * a focusable row. We will step backwards to find the last + * focusable row. + */ + _gtk_rbtree_prev_full (tree, node, &cursor_tree, &cursor_node); + if (cursor_node) + { + cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node); + if (! search_first_focusable_path (tree_view, &cursor_path, FALSE, + &cursor_tree, &cursor_node)) + cursor_node = NULL; + gtk_tree_path_free (cursor_path); + } + } + else if (cursor_path) + gtk_tree_path_free (cursor_path); + + cursor_changed = TRUE; + } if (tree_view->priv->destroy_count_func) { @@ -9051,6 +9084,9 @@ gtk_tree_view_row_deleted (GtkTreeModel *model, if (tree_view->priv->tree == tree) tree_view->priv->tree = NULL; + _gtk_tree_view_accessible_remove_state (tree_view, + tree->parent_tree, tree->parent_node, + GTK_CELL_RENDERER_EXPANDED); _gtk_tree_view_accessible_remove (tree_view, tree, NULL); _gtk_rbtree_remove (tree); } @@ -9066,14 +9102,21 @@ gtk_tree_view_row_deleted (GtkTreeModel *model, tree_view->priv->top_row = NULL; } - /* Cancel any ongoing animation happening within the row */ - context = gtk_widget_get_style_context (GTK_WIDGET (tree_view)); - gtk_style_context_cancel_animations (context, node); - install_scroll_sync_handler (tree_view); gtk_widget_queue_resize (GTK_WIDGET (tree_view)); + if (cursor_changed) + { + if (cursor_node) + { + GtkTreePath *cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node); + gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT | CURSOR_INVALID); + gtk_tree_path_free (cursor_path); + } + else + gtk_tree_view_real_set_cursor (tree_view, NULL, CLEAR_AND_SELECT | CURSOR_INVALID); + } if (selection_changed) g_signal_emit_by_name (tree_view->priv->selection, "changed"); } @@ -9123,6 +9166,8 @@ gtk_tree_view_rows_reordered (GtkTreeModel *model, _gtk_rbtree_reorder (tree, new_order, len); + _gtk_tree_view_accessible_reorder (tree_view); + gtk_widget_queue_draw (GTK_WIDGET (tree_view)); gtk_tree_view_dy_to_top_row (tree_view); @@ -9195,10 +9240,19 @@ gtk_tree_view_get_arrow_xrange (GtkTreeView *tree_view, GList *list; GtkTreeViewColumn *tmp_column = NULL; gint total_width; + gint expander_size, expander_render_size; + gint horizontal_separator; gboolean indent_expanders; gboolean rtl; + gtk_widget_style_get (GTK_WIDGET (tree_view), + "indent-expanders", &indent_expanders, + "horizontal-separator", &horizontal_separator, + NULL); + rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL); + expander_size = gtk_tree_view_get_expander_size (tree_view); + expander_render_size = expander_size - (horizontal_separator / 2); total_width = 0; for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns)); @@ -9210,7 +9264,7 @@ gtk_tree_view_get_arrow_xrange (GtkTreeView *tree_view, if (gtk_tree_view_is_expander_column (tree_view, tmp_column)) { if (rtl) - x_offset = total_width + gtk_tree_view_column_get_width (tmp_column) - tree_view->priv->expander_size; + x_offset = total_width + gtk_tree_view_column_get_width (tmp_column) - expander_size; else x_offset = total_width; break; @@ -9220,16 +9274,14 @@ gtk_tree_view_get_arrow_xrange (GtkTreeView *tree_view, total_width += gtk_tree_view_column_get_width (tmp_column); } - gtk_widget_style_get (GTK_WIDGET (tree_view), - "indent-expanders", &indent_expanders, - NULL); + x_offset += (expander_size - expander_render_size); if (indent_expanders) { if (rtl) - x_offset -= tree_view->priv->expander_size * _gtk_rbtree_get_depth (tree); + x_offset -= expander_size * _gtk_rbtree_get_depth (tree); else - x_offset += tree_view->priv->expander_size * _gtk_rbtree_get_depth (tree); + x_offset += expander_size * _gtk_rbtree_get_depth (tree); } *x1 = x_offset; @@ -9237,7 +9289,7 @@ gtk_tree_view_get_arrow_xrange (GtkTreeView *tree_view, if (tmp_column && gtk_tree_view_column_get_visible (tmp_column)) /* +1 because x2 isn't included in the range. */ - *x2 = *x1 + tree_view->priv->expander_size + 1; + *x2 = *x1 + expander_render_size + 1; else *x2 = *x1; } @@ -9328,13 +9380,9 @@ gtk_tree_view_clamp_node_visible (GtkTreeView *tree_view, + gtk_adjustment_get_page_size (tree_view->priv->vadjustment))) return; - path = _gtk_tree_view_find_path (tree_view, tree, node); + path = _gtk_tree_path_new_from_rbtree (tree, node); if (path) { - /* We process updates because we want to clear old selected items when we scroll. - * if this is removed, we get a "selection streak" at the bottom. */ - gtk_tree_view_bin_process_updates (tree_view); - gtk_tree_view_scroll_to_cell (tree_view, path, NULL, FALSE, 0.0, 0.0); gtk_tree_path_free (path); } @@ -9404,9 +9452,8 @@ gtk_tree_view_clamp_column_visible (GtkTreeView *tree_view, /* This function could be more efficient. I'll optimize it if profiling seems * to imply that it is important */ GtkTreePath * -_gtk_tree_view_find_path (GtkTreeView *tree_view, - GtkRBTree *tree, - GtkRBNode *node) +_gtk_tree_path_new_from_rbtree (GtkRBTree *tree, + GtkRBNode *node) { GtkTreePath *path; GtkRBTree *tmp_tree; @@ -9416,7 +9463,6 @@ _gtk_tree_view_find_path (GtkTreeView *tree_view, path = gtk_tree_path_new (); g_return_val_if_fail (node != NULL, path); - g_return_val_if_fail (node != tree->nil, path); count = 1 + node->left->count; @@ -9425,7 +9471,7 @@ _gtk_tree_view_find_path (GtkTreeView *tree_view, tmp_tree = tree; while (tmp_tree) { - while (tmp_node != tmp_tree->nil) + while (!_gtk_rbtree_is_nil (tmp_node)) { if (tmp_node->right == last) count += 1 + tmp_node->left->count; @@ -9579,15 +9625,12 @@ gtk_tree_view_unref_tree_helper (GtkTreeModel *model, GtkRBNode *new_node; new_tree = node->children; - new_node = new_tree->root; - - while (new_node && new_node->left != new_tree->nil) - new_node = new_node->left; + new_node = _gtk_rbtree_first (new_tree); if (!gtk_tree_model_iter_children (model, &child, iter)) return FALSE; - retval = retval || gtk_tree_view_unref_tree_helper (model, &child, new_tree, new_node); + retval = gtk_tree_view_unref_tree_helper (model, &child, new_tree, new_node) | retval; } if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED)) @@ -9612,12 +9655,10 @@ gtk_tree_view_unref_and_check_selection_tree (GtkTreeView *tree_view, if (!tree) return FALSE; - node = tree->root; - while (node && node->left != tree->nil) - node = node->left; + node = _gtk_rbtree_first (tree); g_return_val_if_fail (node != NULL, FALSE); - path = _gtk_tree_view_find_path (tree_view, tree, node); + path = _gtk_tree_path_new_from_rbtree (tree, node); gtk_tree_model_get_iter (GTK_TREE_MODEL (tree_view->priv->model), &iter, path); retval = gtk_tree_view_unref_tree_helper (GTK_TREE_MODEL (tree_view->priv->model), &iter, tree, node); @@ -9744,9 +9785,13 @@ _gtk_tree_view_column_start_drag (GtkTreeView *tree_view, GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (tree_view)); GtkWidget *button; GdkDevice *pointer, *keyboard; + GdkWindowAttr attributes; + guint attributes_mask; + GtkStyleContext *context; g_return_if_fail (tree_view->priv->column_drag_info == NULL); g_return_if_fail (tree_view->priv->cur_reorder == NULL); + g_return_if_fail (tree_view->priv->drag_window == NULL); gtk_tree_view_set_column_drag_info (tree_view, column); @@ -9755,28 +9800,25 @@ _gtk_tree_view_column_start_drag (GtkTreeView *tree_view, button = gtk_tree_view_column_get_button (column); - if (tree_view->priv->drag_window == NULL) - { - GdkWindowAttr attributes; - guint attributes_mask; + context = gtk_widget_get_style_context (button); + gtk_style_context_add_class (context, GTK_STYLE_CLASS_DND); - gtk_widget_get_allocation (button, &button_allocation); + gtk_widget_get_allocation (button, &button_allocation); - attributes.window_type = GDK_WINDOW_CHILD; - attributes.wclass = GDK_INPUT_OUTPUT; - attributes.x = button_allocation.x; - attributes.y = 0; - attributes.width = button_allocation.width; - attributes.height = button_allocation.height; - attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view)); - attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK; - attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL; + attributes.window_type = GDK_WINDOW_CHILD; + attributes.wclass = GDK_INPUT_OUTPUT; + attributes.x = button_allocation.x; + attributes.y = 0; + attributes.width = button_allocation.width; + attributes.height = button_allocation.height; + attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view)); + attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK; + attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL; - tree_view->priv->drag_window = gdk_window_new (tree_view->priv->bin_window, - &attributes, - attributes_mask); - gdk_window_set_user_data (tree_view->priv->drag_window, GTK_WIDGET (tree_view)); - } + tree_view->priv->drag_window = gdk_window_new (tree_view->priv->header_window, + &attributes, + attributes_mask); + gtk_widget_register_window (GTK_WIDGET (tree_view), tree_view->priv->drag_window); if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD) { @@ -9813,7 +9855,7 @@ _gtk_tree_view_column_start_drag (GtkTreeView *tree_view, send_event->button.y = -1; send_event->button.axes = NULL; send_event->button.state = 0; - send_event->button.button = 1; + send_event->button.button = GDK_BUTTON_PRIMARY; send_event->button.x_root = 0; send_event->button.y_root = 0; gdk_event_set_device (send_event, device); @@ -9873,7 +9915,8 @@ gtk_tree_view_queue_draw_arrow (GtkTreeView *tree_view, gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation); rect.x = 0; - rect.width = MAX (tree_view->priv->expander_size, MAX (tree_view->priv->width, allocation.width)); + rect.width = gtk_tree_view_get_expander_size (tree_view); + rect.width = MAX (rect.width, MAX (tree_view->priv->width, allocation.width)); rect.y = gtk_tree_view_get_row_y_offset (tree_view, tree, node); rect.height = gtk_tree_view_get_row_height (tree_view, node); @@ -9969,17 +10012,50 @@ _gtk_tree_view_get_rbtree (GtkTreeView *tree_view) return tree_view->priv->tree; } +gboolean +_gtk_tree_view_get_cursor_node (GtkTreeView *tree_view, + GtkRBTree **tree, + GtkRBNode **node) +{ + GtkTreeViewPrivate *priv; + + priv = tree_view->priv; + + if (priv->cursor_node == NULL) + return FALSE; + + *tree = priv->cursor_tree; + *node = priv->cursor_node; + + return TRUE; +} + GdkWindow * _gtk_tree_view_get_header_window (GtkTreeView *tree_view) { return tree_view->priv->header_window; } +GtkTreeViewColumn * +_gtk_tree_view_get_focus_column (GtkTreeView *tree_view) +{ + return tree_view->priv->focus_column; +} + void _gtk_tree_view_set_focus_column (GtkTreeView *tree_view, GtkTreeViewColumn *column) { + GtkTreeViewColumn *old_column = tree_view->priv->focus_column; + + if (old_column == column) + return; + tree_view->priv->focus_column = column; + + _gtk_tree_view_accessible_update_focus_column (tree_view, + old_column, + column); } @@ -10012,16 +10088,14 @@ gtk_tree_view_draw_arrow (GtkTreeView *tree_view, gint x_offset = 0; gint x2; gint vertical_separator; - gint expander_size; - GtkCellRendererState flags; + GtkCellRendererState flags = 0; widget = GTK_WIDGET (tree_view); context = gtk_widget_get_style_context (widget); gtk_widget_style_get (widget, - "vertical-separator", &vertical_separator, - NULL); - expander_size = tree_view->priv->expander_size - EXPANDER_EXTRA_PADDING; + "vertical-separator", &vertical_separator, + NULL); if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT)) return; @@ -10031,41 +10105,33 @@ gtk_tree_view_draw_arrow (GtkTreeView *tree_view, area.x = x_offset; area.y = gtk_tree_view_get_cell_area_y_offset (tree_view, tree, node, vertical_separator); - area.width = expander_size; + area.width = x2 - x_offset; area.height = gtk_tree_view_get_cell_area_height (tree_view, node, vertical_separator); - if (!gtk_widget_get_sensitive (widget)) - state |= GTK_STATE_FLAG_INSENSITIVE; - else - { - flags = 0; - - if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED)) - flags |= GTK_CELL_RENDERER_SELECTED; + if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED)) + flags |= GTK_CELL_RENDERER_SELECTED; - state = gtk_cell_renderer_get_state (NULL, widget, flags); + if (node == tree_view->priv->prelight_node && + tree_view->priv->arrow_prelit) + flags |= GTK_CELL_RENDERER_PRELIT; - if (node == tree_view->priv->prelight_node && - tree_view->priv->arrow_prelit) - state |= GTK_STATE_FLAG_PRELIGHT; - } + state = gtk_cell_renderer_get_state (NULL, widget, flags); if (node->children != NULL) state |= GTK_STATE_FLAG_ACTIVE; + else + state &= ~(GTK_STATE_FLAG_ACTIVE); gtk_style_context_save (context); gtk_style_context_set_state (context, state); gtk_style_context_add_class (context, GTK_STYLE_CLASS_EXPANDER); - gtk_style_context_push_animatable_region (context, node); - gtk_render_expander (context, cr, area.x, area.y, area.width, area.height); - gtk_style_context_pop_animatable_region (context); gtk_style_context_restore (context); } @@ -10080,8 +10146,9 @@ gtk_tree_view_focus_to_cursor (GtkTreeView *tree_view) return; cursor_path = NULL; - if (tree_view->priv->cursor) - cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor); + if (tree_view->priv->cursor_node) + cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree, + tree_view->priv->cursor_node); if (cursor_path == NULL) { @@ -10098,8 +10165,7 @@ gtk_tree_view_focus_to_cursor (GtkTreeView *tree_view) if (selected_rows) { cursor_path = gtk_tree_path_copy((const GtkTreePath *)(selected_rows->data)); - g_list_foreach (selected_rows, (GFunc)gtk_tree_path_free, NULL); - g_list_free (selected_rows); + g_list_free_full (selected_rows, (GDestroyNotify) gtk_tree_path_free); } else { @@ -10108,15 +10174,12 @@ gtk_tree_view_focus_to_cursor (GtkTreeView *tree_view) TRUE, NULL, NULL); } - gtk_tree_row_reference_free (tree_view->priv->cursor); - tree_view->priv->cursor = NULL; - if (cursor_path) { if (gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE) - gtk_tree_view_real_set_cursor (tree_view, cursor_path, FALSE, FALSE); + gtk_tree_view_real_set_cursor (tree_view, cursor_path, 0); else - gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE); + gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT); } } @@ -10136,7 +10199,7 @@ gtk_tree_view_focus_to_cursor (GtkTreeView *tree_view) { GtkCellArea *cell_area; - tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (list->data); + _gtk_tree_view_set_focus_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data)); /* This happens when the treeview initially grabs focus and there * is no column in focus, here we explicitly focus into the first cell */ @@ -10162,8 +10225,6 @@ gtk_tree_view_move_cursor_up_down (GtkTreeView *tree_view, gint count) { gint selection_count; - GtkRBTree *cursor_tree = NULL; - GtkRBNode *cursor_node = NULL; GtkRBTree *new_cursor_tree = NULL; GtkRBNode *new_cursor_node = NULL; GtkTreePath *cursor_path = NULL; @@ -10177,18 +10238,11 @@ gtk_tree_view_move_cursor_up_down (GtkTreeView *tree_view, if (! gtk_widget_has_focus (GTK_WIDGET (tree_view))) return; - cursor_path = NULL; - if (!gtk_tree_row_reference_valid (tree_view->priv->cursor)) - /* FIXME: we lost the cursor; should we get the first? */ + if (tree_view->priv->cursor_node == NULL) return; - cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor); - _gtk_tree_view_find_node (tree_view, cursor_path, - &cursor_tree, &cursor_node); - - if (cursor_tree == NULL) - /* FIXME: we lost the cursor; should we get the first? */ - return; + cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree, + tree_view->priv->cursor_node); direction = count < 0 ? GTK_DIR_UP : GTK_DIR_DOWN; @@ -10201,9 +10255,9 @@ gtk_tree_view_move_cursor_up_down (GtkTreeView *tree_view, { gtk_tree_view_column_cell_set_cell_data (tree_view->priv->focus_column, tree_view->priv->model, - &iter, - GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT), - cursor_node->children?TRUE:FALSE); + &iter, + GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_PARENT), + tree_view->priv->cursor_node->children ? TRUE : FALSE); /* Save the last cell that had focus, if we hit the end of the view we'll give * focus back to it. */ @@ -10216,7 +10270,7 @@ gtk_tree_view_move_cursor_up_down (GtkTreeView *tree_view, selection_count = gtk_tree_selection_count_selected_rows (tree_view->priv->selection); selectable = _gtk_tree_selection_row_is_selectable (tree_view->priv->selection, - cursor_node, + tree_view->priv->cursor_node, cursor_path); if (selection_count == 0 @@ -10225,16 +10279,16 @@ gtk_tree_view_move_cursor_up_down (GtkTreeView *tree_view, && selectable) { /* Don't move the cursor, but just select the current node */ - new_cursor_tree = cursor_tree; - new_cursor_node = cursor_node; + new_cursor_tree = tree_view->priv->cursor_tree; + new_cursor_node = tree_view->priv->cursor_node; } else { if (count == -1) - _gtk_rbtree_prev_full (cursor_tree, cursor_node, + _gtk_rbtree_prev_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node, &new_cursor_tree, &new_cursor_node); else - _gtk_rbtree_next_full (cursor_tree, cursor_node, + _gtk_rbtree_next_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node, &new_cursor_tree, &new_cursor_node); } @@ -10242,8 +10296,7 @@ gtk_tree_view_move_cursor_up_down (GtkTreeView *tree_view, if (new_cursor_node) { - cursor_path = _gtk_tree_view_find_path (tree_view, - new_cursor_tree, new_cursor_node); + cursor_path = _gtk_tree_path_new_from_rbtree (new_cursor_tree, new_cursor_node); search_first_focusable_path (tree_view, &cursor_path, (count != -1), @@ -10262,28 +10315,29 @@ gtk_tree_view_move_cursor_up_down (GtkTreeView *tree_view, new_cursor_node == NULL) { if (count == -1) - _gtk_rbtree_next_full (cursor_tree, cursor_node, + _gtk_rbtree_next_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node, &new_cursor_tree, &new_cursor_node); else - _gtk_rbtree_prev_full (cursor_tree, cursor_node, + _gtk_rbtree_prev_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node, &new_cursor_tree, &new_cursor_node); if (new_cursor_node == NULL - && !GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_SELECTED)) + && !GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_SELECTED)) { - new_cursor_node = cursor_node; - new_cursor_tree = cursor_tree; + new_cursor_node = tree_view->priv->cursor_node; + new_cursor_tree = tree_view->priv->cursor_tree; } else { + new_cursor_tree = NULL; new_cursor_node = NULL; } } if (new_cursor_node) { - cursor_path = _gtk_tree_view_find_path (tree_view, new_cursor_tree, new_cursor_node); - gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, TRUE); + cursor_path = _gtk_tree_path_new_from_rbtree (new_cursor_tree, new_cursor_node); + gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT | CLAMP_NODE); gtk_tree_path_free (cursor_path); /* Give focus to the area in the new row */ @@ -10292,7 +10346,9 @@ gtk_tree_view_move_cursor_up_down (GtkTreeView *tree_view, } else { - gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node); + gtk_tree_view_clamp_node_visible (tree_view, + tree_view->priv->cursor_tree, + tree_view->priv->cursor_node); if (!tree_view->priv->extend_selection_pressed) { @@ -10328,12 +10384,12 @@ static void gtk_tree_view_move_cursor_page_up_down (GtkTreeView *tree_view, gint count) { - GtkRBTree *cursor_tree = NULL; - GtkRBNode *cursor_node = NULL; GtkTreePath *old_cursor_path = NULL; GtkTreePath *cursor_path = NULL; GtkRBTree *start_cursor_tree = NULL; GtkRBNode *start_cursor_node = NULL; + GtkRBTree *cursor_tree; + GtkRBNode *cursor_node; gint y; gint window_y; gint vertical_separator; @@ -10341,25 +10397,15 @@ gtk_tree_view_move_cursor_page_up_down (GtkTreeView *tree_view, if (!gtk_widget_has_focus (GTK_WIDGET (tree_view))) return; - if (gtk_tree_row_reference_valid (tree_view->priv->cursor)) - old_cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor); - else - /* This is sorta weird. Focus in should give us a cursor */ + if (tree_view->priv->cursor_node == NULL) return; - gtk_widget_style_get (GTK_WIDGET (tree_view), "vertical-separator", &vertical_separator, NULL); - _gtk_tree_view_find_node (tree_view, old_cursor_path, - &cursor_tree, &cursor_node); + old_cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree, + tree_view->priv->cursor_node); - if (cursor_tree == NULL) - { - /* FIXME: we lost the cursor. Should we try to get one? */ - gtk_tree_path_free (old_cursor_path); - return; - } - g_return_if_fail (cursor_node != NULL); + gtk_widget_style_get (GTK_WIDGET (tree_view), "vertical-separator", &vertical_separator, NULL); - y = _gtk_rbtree_node_find_offset (cursor_tree, cursor_node); + y = _gtk_rbtree_node_find_offset (tree_view->priv->cursor_tree, tree_view->priv->cursor_node); window_y = RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, y); y += tree_view->priv->cursor_offset; y += count * (int)gtk_adjustment_get_page_increment (tree_view->priv->vadjustment); @@ -10388,7 +10434,7 @@ gtk_tree_view_move_cursor_page_up_down (GtkTreeView *tree_view, } y -= tree_view->priv->cursor_offset; - cursor_path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node); + cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node); start_cursor_tree = cursor_tree; start_cursor_node = cursor_node; @@ -10403,7 +10449,7 @@ gtk_tree_view_move_cursor_page_up_down (GtkTreeView *tree_view, */ cursor_tree = start_cursor_tree; cursor_node = start_cursor_node; - cursor_path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node); + cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node); search_first_focusable_path (tree_view, &cursor_path, (count == -1), @@ -10416,7 +10462,7 @@ gtk_tree_view_move_cursor_page_up_down (GtkTreeView *tree_view, /* update y */ y = _gtk_rbtree_node_find_offset (cursor_tree, cursor_node); - gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE); + gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT); y -= window_y; gtk_tree_view_scroll_to_point (tree_view, -1, y); @@ -10437,8 +10483,6 @@ static void gtk_tree_view_move_cursor_left_right (GtkTreeView *tree_view, gint count) { - GtkRBTree *cursor_tree = NULL; - GtkRBNode *cursor_node = NULL; GtkTreePath *cursor_path = NULL; GtkTreeViewColumn *column; GtkTreeIter iter; @@ -10455,14 +10499,12 @@ gtk_tree_view_move_cursor_left_right (GtkTreeView *tree_view, if (!gtk_widget_has_focus (GTK_WIDGET (tree_view))) return; - if (gtk_tree_row_reference_valid (tree_view->priv->cursor)) - cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor); - else + if (tree_view->priv->cursor_node == NULL) return; - _gtk_tree_view_find_node (tree_view, cursor_path, &cursor_tree, &cursor_node); - if (cursor_tree == NULL) - return; + cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree, + tree_view->priv->cursor_node); + if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path) == FALSE) { gtk_tree_path_free (cursor_path); @@ -10496,13 +10538,13 @@ gtk_tree_view_move_cursor_left_right (GtkTreeView *tree_view, gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, &iter, - GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT), - cursor_node->children?TRUE:FALSE); + GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_PARENT), + tree_view->priv->cursor_node->children ? TRUE : FALSE); cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column)); if (gtk_cell_area_focus (cell_area, direction)) { - tree_view->priv->focus_column = column; + _gtk_tree_view_set_focus_column (tree_view, column); found_column = TRUE; break; } @@ -10518,8 +10560,8 @@ gtk_tree_view_move_cursor_left_right (GtkTreeView *tree_view, { if (!gtk_tree_view_has_can_focus_cell (tree_view)) _gtk_tree_view_queue_draw_node (tree_view, - cursor_tree, - cursor_node, + tree_view->priv->cursor_tree, + tree_view->priv->cursor_node, NULL); g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0); gtk_widget_grab_focus (GTK_WIDGET (tree_view)); @@ -10553,23 +10595,23 @@ gtk_tree_view_move_cursor_start_end (GtkTreeView *tree_view, gtk_tree_view_get_cursor (tree_view, &old_path, NULL); cursor_tree = tree_view->priv->tree; - cursor_node = cursor_tree->root; if (count == -1) { - while (cursor_node && cursor_node->left != cursor_tree->nil) - cursor_node = cursor_node->left; + cursor_node = _gtk_rbtree_first (cursor_tree); /* Now go forward to find the first focusable row. */ - path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node); + path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node); search_first_focusable_path (tree_view, &path, TRUE, &cursor_tree, &cursor_node); } else { + cursor_node = cursor_tree->root; + do { - while (cursor_node && cursor_node->right != cursor_tree->nil) + while (cursor_node && !_gtk_rbtree_is_nil (cursor_node->right)) cursor_node = cursor_node->right; if (cursor_node->children == NULL) break; @@ -10580,7 +10622,7 @@ gtk_tree_view_move_cursor_start_end (GtkTreeView *tree_view, while (1); /* Now go backwards to find last focusable row. */ - path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node); + path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node); search_first_focusable_path (tree_view, &path, FALSE, &cursor_tree, &cursor_node); } @@ -10590,7 +10632,7 @@ gtk_tree_view_move_cursor_start_end (GtkTreeView *tree_view, if (gtk_tree_path_compare (old_path, path)) { - gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE); + gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CLAMP_NODE); gtk_widget_grab_focus (GTK_WIDGET (tree_view)); } else @@ -10645,12 +10687,12 @@ gtk_tree_view_real_select_cursor_row (GtkTreeView *tree_view, if (!gtk_widget_has_focus (GTK_WIDGET (tree_view))) return FALSE; - if (tree_view->priv->cursor) - cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor); - - if (cursor_path == NULL) + if (tree_view->priv->cursor_node == NULL) return FALSE; + cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree, + tree_view->priv->cursor_node); + _gtk_tree_view_find_node (tree_view, cursor_path, &cursor_tree, &cursor_node); @@ -10710,31 +10752,20 @@ gtk_tree_view_real_toggle_cursor_row (GtkTreeView *tree_view) { GtkRBTree *new_tree = NULL; GtkRBNode *new_node = NULL; - GtkRBTree *cursor_tree = NULL; - GtkRBNode *cursor_node = NULL; GtkTreePath *cursor_path = NULL; if (!gtk_widget_has_focus (GTK_WIDGET (tree_view))) return FALSE; - cursor_path = NULL; - if (tree_view->priv->cursor) - cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor); - - if (cursor_path == NULL) + if (tree_view->priv->cursor_node == NULL) return FALSE; - _gtk_tree_view_find_node (tree_view, cursor_path, - &cursor_tree, &cursor_node); - if (cursor_tree == NULL) - { - gtk_tree_path_free (cursor_path); - return FALSE; - } + cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree, + tree_view->priv->cursor_node); _gtk_tree_selection_internal_select_node (tree_view->priv->selection, - cursor_node, - cursor_tree, + tree_view->priv->cursor_node, + tree_view->priv->cursor_tree, cursor_path, GTK_TREE_SELECT_MODE_TOGGLE, FALSE); @@ -10745,10 +10776,12 @@ gtk_tree_view_real_toggle_cursor_row (GtkTreeView *tree_view) */ _gtk_tree_view_find_node (tree_view, cursor_path, &new_tree, &new_node); - if (cursor_tree != new_tree || cursor_node != new_node) + if (tree_view->priv->cursor_node != new_node) return FALSE; - gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node); + gtk_tree_view_clamp_node_visible (tree_view, + tree_view->priv->cursor_tree, + tree_view->priv->cursor_node); gtk_widget_grab_focus (GTK_WIDGET (tree_view)); gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL); @@ -10764,24 +10797,18 @@ gtk_tree_view_real_expand_collapse_cursor_row (GtkTreeView *tree_view, gboolean open_all) { GtkTreePath *cursor_path = NULL; - GtkRBTree *tree; - GtkRBNode *node; if (!gtk_widget_has_focus (GTK_WIDGET (tree_view))) return FALSE; - cursor_path = NULL; - if (tree_view->priv->cursor) - cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor); - - if (cursor_path == NULL) + if (tree_view->priv->cursor_node == NULL) return FALSE; - if (_gtk_tree_view_find_node (tree_view, cursor_path, &tree, &node)) - return FALSE; + cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree, + tree_view->priv->cursor_node); /* Don't handle the event if we aren't an expander */ - if (!((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT)) + if (!GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_PARENT)) return FALSE; if (!logical @@ -10789,9 +10816,18 @@ gtk_tree_view_real_expand_collapse_cursor_row (GtkTreeView *tree_view, expand = !expand; if (expand) - gtk_tree_view_real_expand_row (tree_view, cursor_path, tree, node, open_all, TRUE); + gtk_tree_view_real_expand_row (tree_view, + cursor_path, + tree_view->priv->cursor_tree, + tree_view->priv->cursor_node, + open_all, + TRUE); else - gtk_tree_view_real_collapse_row (tree_view, cursor_path, tree, node, TRUE); + gtk_tree_view_real_collapse_row (tree_view, + cursor_path, + tree_view->priv->cursor_tree, + tree_view->priv->cursor_node, + TRUE); gtk_tree_path_free (cursor_path); @@ -10801,34 +10837,21 @@ gtk_tree_view_real_expand_collapse_cursor_row (GtkTreeView *tree_view, static gboolean gtk_tree_view_real_select_cursor_parent (GtkTreeView *tree_view) { - GtkRBTree *cursor_tree = NULL; - GtkRBNode *cursor_node = NULL; GtkTreePath *cursor_path = NULL; GdkModifierType state; if (!gtk_widget_has_focus (GTK_WIDGET (tree_view))) goto out; - cursor_path = NULL; - if (tree_view->priv->cursor) - cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor); - - if (cursor_path == NULL) + if (tree_view->priv->cursor_node == NULL) goto out; - _gtk_tree_view_find_node (tree_view, cursor_path, - &cursor_tree, &cursor_node); - if (cursor_tree == NULL) - { - gtk_tree_path_free (cursor_path); - goto out; - } + cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree, + tree_view->priv->cursor_node); - if (cursor_tree->parent_node) + if (tree_view->priv->cursor_tree->parent_node) { gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL); - cursor_node = cursor_tree->parent_node; - cursor_tree = cursor_tree->parent_tree; gtk_tree_path_up (cursor_path); @@ -10844,12 +10867,10 @@ gtk_tree_view_real_select_cursor_parent (GtkTreeView *tree_view) tree_view->priv->modify_selection_pressed = TRUE; } - gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE); - gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node); + gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT | CLAMP_NODE); + gtk_tree_path_free (cursor_path); gtk_widget_grab_focus (GTK_WIDGET (tree_view)); - gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL); - gtk_tree_path_free (cursor_path); tree_view->priv->modify_selection_pressed = FALSE; @@ -11094,50 +11115,6 @@ gtk_tree_view_start_interactive_search (GtkTreeView *tree_view) TRUE); } -/* this function returns the new width of the column being resized given - * the column and x position of the cursor; the x cursor position is passed - * in as a pointer and automagicly corrected if it's beyond min/max limits - */ -static gint -gtk_tree_view_new_column_width (GtkTreeView *tree_view, - gint i, - gint *x) -{ - GtkAllocation allocation; - GtkTreeViewColumn *column; - GtkRequisition button_req; - gint max_width, min_width; - gint width; - gboolean rtl; - - /* first translate the x position from widget->window - * to clist->clist_window - */ - rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL); - column = g_list_nth (tree_view->priv->columns, i)->data; - gtk_widget_get_allocation (gtk_tree_view_column_get_button (column), &allocation); - width = rtl ? (allocation.x + allocation.width - *x) : (*x - allocation.x); - - /* Clamp down the value */ - min_width = gtk_tree_view_column_get_min_width (column); - if (min_width == -1) - { - gtk_widget_get_preferred_size (gtk_tree_view_column_get_button (column), &button_req, NULL); - width = MAX (button_req.width, width); - } - else - width = MAX (min_width, width); - - max_width = gtk_tree_view_column_get_max_width (column); - if (max_width != -1) - width = MIN (width, max_width); - - *x = rtl ? (allocation.x + allocation.width - width) : (allocation.x + width); - - return width; -} - - /* FIXME this adjust_allocation is a big cut-and-paste from * GtkCList, needs to be some "official" way to do this * factored out. @@ -11219,7 +11196,6 @@ gtk_tree_view_adjustment_changed (GtkAdjustment *adjustment, { if (gtk_widget_get_realized (GTK_WIDGET (tree_view))) { - GtkStyleContext *context; gint dy; gdk_window_move (tree_view->priv->bin_window, @@ -11262,9 +11238,6 @@ gtk_tree_view_adjustment_changed (GtkAdjustment *adjustment, } gdk_window_scroll (tree_view->priv->bin_window, 0, dy); - context = gtk_widget_get_style_context (GTK_WIDGET (tree_view)); - gtk_style_context_scroll_animations (context, tree_view->priv->bin_window, 0, dy); - if (tree_view->priv->dy != (int) gtk_adjustment_get_value (tree_view->priv->vadjustment)) { /* update our dy and top_row */ @@ -11273,9 +11246,6 @@ gtk_tree_view_adjustment_changed (GtkAdjustment *adjustment, if (!tree_view->priv->in_top_row_to_dy) gtk_tree_view_dy_to_top_row (tree_view); } - - gdk_window_process_updates (tree_view->priv->header_window, TRUE); - gtk_tree_view_bin_process_updates (tree_view); } } @@ -11333,7 +11303,7 @@ gtk_tree_view_get_model (GtkTreeView *tree_view) /** * gtk_tree_view_set_model: - * @tree_view: A #GtkTreeNode. + * @tree_view: A #GtkTreeView. * @model: (allow-none): The model. * * Sets the model for a #GtkTreeView. If the @tree_view already has a model @@ -11362,14 +11332,10 @@ gtk_tree_view_set_model (GtkTreeView *tree_view, if (tree_view->priv->model) { GList *tmplist = tree_view->priv->columns; - GtkStyleContext *context; gtk_tree_view_unref_and_check_selection_tree (tree_view, tree_view->priv->tree); gtk_tree_view_stop_editing (tree_view, TRUE); - context = gtk_widget_get_style_context (GTK_WIDGET (tree_view)); - gtk_style_context_cancel_animations (context, NULL); - g_signal_handlers_disconnect_by_func (tree_view->priv->model, gtk_tree_view_row_changed, tree_view); @@ -11395,8 +11361,6 @@ gtk_tree_view_set_model (GtkTreeView *tree_view, gtk_tree_row_reference_free (tree_view->priv->drag_dest_row); tree_view->priv->drag_dest_row = NULL; - gtk_tree_row_reference_free (tree_view->priv->cursor); - tree_view->priv->cursor = NULL; gtk_tree_row_reference_free (tree_view->priv->anchor); tree_view->priv->anchor = NULL; gtk_tree_row_reference_free (tree_view->priv->top_row); @@ -11472,6 +11436,7 @@ gtk_tree_view_set_model (GtkTreeView *tree_view, { tree_view->priv->tree = _gtk_rbtree_new (); gtk_tree_view_build_tree (tree_view, tree_view->priv->tree, &iter, 1, FALSE); + _gtk_tree_view_accessible_add (tree_view, tree_view->priv->tree, NULL); } gtk_tree_path_free (path); @@ -11479,6 +11444,8 @@ gtk_tree_view_set_model (GtkTreeView *tree_view, install_presize_handler (tree_view); } + gtk_tree_view_real_set_cursor (tree_view, NULL, CURSOR_INVALID); + g_object_notify (G_OBJECT (tree_view), "model"); if (tree_view->priv->selection) @@ -11818,7 +11785,7 @@ gtk_tree_view_get_headers_clickable (GtkTreeView *tree_view) } /** - * gtk_tree_view_set_rules_hint + * gtk_tree_view_set_rules_hint: * @tree_view: a #GtkTreeView * @setting: %TRUE if the tree requires reading across rows * @@ -11854,7 +11821,7 @@ gtk_tree_view_set_rules_hint (GtkTreeView *tree_view, } /** - * gtk_tree_view_get_rules_hint + * gtk_tree_view_get_rules_hint: * @tree_view: a #GtkTreeView * * Gets the setting set by gtk_tree_view_set_rules_hint(). @@ -11869,6 +11836,50 @@ gtk_tree_view_get_rules_hint (GtkTreeView *tree_view) return tree_view->priv->has_rules; } + +/** + * gtk_tree_view_set_activate_on_single_click: + * @tree_view: a #GtkTreeView + * @single: %TRUE to emit row-activated on a single click + * + * Cause the #GtkTreeView::row-activated signal to be emitted + * on a single click instead of a double click. + * + * Since: 3.8 + **/ +void +gtk_tree_view_set_activate_on_single_click (GtkTreeView *tree_view, + gboolean single) +{ + g_return_if_fail (GTK_IS_TREE_VIEW (tree_view)); + + single = single != FALSE; + + if (tree_view->priv->activate_on_single_click == single) + return; + + tree_view->priv->activate_on_single_click = single; + g_object_notify (G_OBJECT (tree_view), "activate-on-single-click"); +} + +/** + * gtk_tree_view_get_activate_on_single_click: + * @tree_view: a #GtkTreeView + * + * Gets the setting set by gtk_tree_view_set_activate_on_single_click(). + * + * Return value: %TRUE if row-activated will be emitted on a single click + * + * Since: 3.8 + **/ +gboolean +gtk_tree_view_get_activate_on_single_click (GtkTreeView *tree_view) +{ + g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE); + + return tree_view->priv->activate_on_single_click; +} + /* Public Column functions */ @@ -11904,7 +11915,7 @@ _gtk_tree_view_reset_header_styles (GtkTreeView *tree_view) GtkTreeViewColumn *column = columns->data; GtkWidget *header_widget; - if (gtk_tree_view_column_get_visible (column)) + if (!gtk_tree_view_column_get_visible (column)) continue; header_widget = gtk_tree_view_column_get_widget (column); @@ -11912,7 +11923,7 @@ _gtk_tree_view_reset_header_styles (GtkTreeView *tree_view) if (!header_widget) header_widget = gtk_tree_view_column_get_button (column); - gtk_widget_reset_style (header_widget); + _gtk_widget_invalidate_style_context (header_widget, GTK_CSS_CHANGE_PARENT_REGION); } } @@ -11937,7 +11948,7 @@ gtk_tree_view_remove_column (GtkTreeView *tree_view, g_return_val_if_fail (gtk_tree_view_column_get_tree_view (column) == GTK_WIDGET (tree_view), -1); if (tree_view->priv->focus_column == column) - tree_view->priv->focus_column = NULL; + _gtk_tree_view_set_focus_column (tree_view, NULL); if (tree_view->priv->edited_column == column) { @@ -12127,7 +12138,7 @@ gtk_tree_view_insert_column_with_attributes (GtkTreeView *tree_view, * @dnotify: destroy notifier for @data * * Convenience function that inserts a new column into the #GtkTreeView - * with the given cell renderer and a #GtkCellDataFunc to set cell renderer + * with the given cell renderer and a #GtkTreeCellDataFunc to set cell renderer * attributes (normally using data from the model). See also * gtk_tree_view_column_set_cell_data_func(), gtk_tree_view_column_pack_start(). * If @tree_view has "fixed_height" mode enabled, then the new column will have its @@ -12552,7 +12563,7 @@ gtk_tree_view_expand_all_emission_helper (GtkRBTree *tree, GtkTreePath *path; GtkTreeIter iter; - path = _gtk_tree_view_find_path (tree_view, tree, node); + path = _gtk_tree_path_new_from_rbtree (tree, node); gtk_tree_model_get_iter (tree_view->priv->model, &iter, path); g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path); @@ -12623,9 +12634,7 @@ gtk_tree_view_collapse_all (GtkTreeView *tree_view) indices = gtk_tree_path_get_indices (path); tree = tree_view->priv->tree; - node = tree->root; - while (node && node->left != tree->nil) - node = node->left; + node = _gtk_rbtree_first (tree); while (node) { @@ -12717,9 +12726,7 @@ gtk_tree_view_real_expand_row (GtkTreeView *tree_view, gtk_tree_path_append_index (tmp_path, 0); tree = node->children; - node = tree->root; - while (node->left != tree->nil) - node = node->left; + node = _gtk_rbtree_first (tree); /* try to expand the children */ do { @@ -12759,21 +12766,10 @@ gtk_tree_view_real_expand_row (GtkTreeView *tree_view, gtk_tree_path_get_depth (path) + 1, open_all); - if (animate) - { - GtkStyleContext *context; - - context = gtk_widget_get_style_context (GTK_WIDGET (tree_view)); - - gtk_style_context_save (context); - gtk_style_context_add_class (context, GTK_STYLE_CLASS_EXPANDER); - - gtk_style_context_notify_state_change (context, tree_view->priv->bin_window, - node, GTK_STATE_ACTIVE, TRUE); - - _gtk_style_context_invalidate_animation_areas (context); - gtk_style_context_restore (context); - } + _gtk_tree_view_accessible_add (tree_view, node->children, NULL); + _gtk_tree_view_accessible_add_state (tree_view, + tree, node, + GTK_CELL_RENDERER_EXPANDED); install_presize_handler (tree_view); @@ -12837,6 +12833,7 @@ gtk_tree_view_real_collapse_row (GtkTreeView *tree_view, gint x, y; GList *list; GdkWindow *child; + gboolean selection_changed, cursor_changed; if (animate) g_object_get (gtk_widget_get_settings (GTK_WIDGET (tree_view)), @@ -12900,19 +12897,13 @@ gtk_tree_view_real_collapse_row (GtkTreeView *tree_view, gtk_tree_path_free (child_path); } - if (gtk_tree_row_reference_valid (tree_view->priv->cursor)) + if (tree_view->priv->cursor_node) { - GtkTreePath *cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor); - - if (gtk_tree_path_is_ancestor (path, cursor_path)) - { - gtk_tree_row_reference_free (tree_view->priv->cursor); - tree_view->priv->cursor = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), - tree_view->priv->model, - path); - } - gtk_tree_path_free (cursor_path); + cursor_changed = (node->children == tree_view->priv->cursor_tree) + || _gtk_rbtree_contains (node->children, tree_view->priv->cursor_tree); } + else + cursor_changed = FALSE; if (gtk_tree_row_reference_valid (tree_view->priv->anchor)) { @@ -12925,35 +12916,23 @@ gtk_tree_view_real_collapse_row (GtkTreeView *tree_view, gtk_tree_path_free (anchor_path); } + selection_changed = gtk_tree_view_unref_and_check_selection_tree (tree_view, node->children); + /* Stop a pending double click */ tree_view->priv->last_button_x = -1; tree_view->priv->last_button_y = -1; _gtk_tree_view_accessible_remove (tree_view, node->children, NULL); + _gtk_tree_view_accessible_remove_state (tree_view, + tree, node, + GTK_CELL_RENDERER_EXPANDED); - if (gtk_tree_view_unref_and_check_selection_tree (tree_view, node->children)) - { - _gtk_rbtree_remove (node->children); - g_signal_emit_by_name (tree_view->priv->selection, "changed"); - } - else - _gtk_rbtree_remove (node->children); - - if (animate) - { - GtkStyleContext *context; - - context = gtk_widget_get_style_context (GTK_WIDGET (tree_view)); - - gtk_style_context_save (context); - gtk_style_context_add_class (context, GTK_STYLE_CLASS_EXPANDER); - - gtk_style_context_notify_state_change (context, tree_view->priv->bin_window, - node, GTK_STATE_ACTIVE, FALSE); + _gtk_rbtree_remove (node->children); - _gtk_style_context_invalidate_animation_areas (context); - gtk_style_context_restore (context); - } + if (cursor_changed) + gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CURSOR_INVALID); + if (selection_changed) + g_signal_emit_by_name (tree_view->priv->selection, "changed"); if (gtk_widget_get_mapped (GTK_WIDGET (tree_view))) { @@ -13037,10 +13016,7 @@ gtk_tree_view_map_expanded_rows_helper (GtkTreeView *tree_view, if (tree == NULL || tree->root == NULL) return; - node = tree->root; - - while (node && node->left != tree->nil) - node = node->left; + node = _gtk_rbtree_first (tree); while (node) { @@ -13187,49 +13163,43 @@ gtk_tree_view_set_reorderable (GtkTreeView *tree_view, static void gtk_tree_view_real_set_cursor (GtkTreeView *tree_view, GtkTreePath *path, - gboolean clear_and_select, - gboolean clamp_node) + SetCursorFlags flags) { - GtkRBTree *tree = NULL; - GtkRBNode *node = NULL; - - if (gtk_tree_row_reference_valid (tree_view->priv->cursor)) + if (!(flags & CURSOR_INVALID) && tree_view->priv->cursor_node) { - GtkTreePath *cursor_path; - cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor); - gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL); - gtk_tree_path_free (cursor_path); + _gtk_tree_view_accessible_remove_state (tree_view, + tree_view->priv->cursor_tree, + tree_view->priv->cursor_node, + GTK_CELL_RENDERER_FOCUSED); + _gtk_tree_view_queue_draw_node (tree_view, + tree_view->priv->cursor_tree, + tree_view->priv->cursor_node, + NULL); } - gtk_tree_row_reference_free (tree_view->priv->cursor); - tree_view->priv->cursor = NULL; - /* One cannot set the cursor on a separator. Also, if * _gtk_tree_view_find_node returns TRUE, it ran out of tree * before finding the tree and node belonging to path. The * path maps to a non-existing path and we will silently bail out. * We unset tree and node to avoid further processing. */ - if (!row_is_separator (tree_view, NULL, path) - && _gtk_tree_view_find_node (tree_view, path, &tree, &node) == FALSE) - { - tree_view->priv->cursor = - gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), - tree_view->priv->model, - path); - } - else + if (path == NULL || + row_is_separator (tree_view, NULL, path) + || _gtk_tree_view_find_node (tree_view, + path, + &tree_view->priv->cursor_tree, + &tree_view->priv->cursor_node)) { - tree = NULL; - node = NULL; + tree_view->priv->cursor_tree = NULL; + tree_view->priv->cursor_node = NULL; } - if (tree != NULL) + if (tree_view->priv->cursor_node != NULL) { GtkRBTree *new_tree = NULL; GtkRBNode *new_node = NULL; - if (clear_and_select && !tree_view->priv->modify_selection_pressed) + if ((flags & CLEAR_AND_SELECT) && !tree_view->priv->modify_selection_pressed) { GtkTreeSelectMode mode = 0; @@ -13237,7 +13207,10 @@ gtk_tree_view_real_set_cursor (GtkTreeView *tree_view, mode |= GTK_TREE_SELECT_MODE_EXTEND; _gtk_tree_selection_internal_select_node (tree_view->priv->selection, - node, tree, path, mode, + tree_view->priv->cursor_node, + tree_view->priv->cursor_tree, + path, + mode, FALSE); } @@ -13247,14 +13220,24 @@ gtk_tree_view_real_set_cursor (GtkTreeView *tree_view, */ _gtk_tree_view_find_node (tree_view, path, &new_tree, &new_node); - if (tree != new_tree || node != new_node) + if (tree_view->priv->cursor_node != new_node) return; - if (clamp_node) + if (flags & CLAMP_NODE) { - gtk_tree_view_clamp_node_visible (tree_view, tree, node); - _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL); + gtk_tree_view_clamp_node_visible (tree_view, + tree_view->priv->cursor_tree, + tree_view->priv->cursor_node); + _gtk_tree_view_queue_draw_node (tree_view, + tree_view->priv->cursor_tree, + tree_view->priv->cursor_node, + NULL); } + + _gtk_tree_view_accessible_add_state (tree_view, + tree_view->priv->cursor_tree, + tree_view->priv->cursor_node, + GTK_CELL_RENDERER_FOCUSED); } g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0); @@ -13282,8 +13265,9 @@ gtk_tree_view_get_cursor (GtkTreeView *tree_view, if (path) { - if (gtk_tree_row_reference_valid (tree_view->priv->cursor)) - *path = gtk_tree_row_reference_get_path (tree_view->priv->cursor); + if (tree_view->priv->cursor_node) + *path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree, + tree_view->priv->cursor_node); else *path = NULL; } @@ -13374,7 +13358,7 @@ gtk_tree_view_set_cursor_on_cell (GtkTreeView *tree_view, (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->edited_column)))) gtk_tree_view_stop_editing (tree_view, TRUE); - gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE); + gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CLAMP_NODE); if (focus_column && gtk_tree_view_column_get_visible (focus_column)) @@ -13389,7 +13373,7 @@ gtk_tree_view_set_cursor_on_cell (GtkTreeView *tree_view, break; } g_return_if_fail (column_in_tree); - tree_view->priv->focus_column = focus_column; + _gtk_tree_view_set_focus_column (tree_view, focus_column); if (focus_cell) gtk_tree_view_column_focus_cell (focus_column, focus_cell); if (start_editing) @@ -13546,7 +13530,7 @@ gtk_tree_view_get_path_at_pos (GtkTreeView *tree_view, *cell_y = y_offset; if (path) - *path = _gtk_tree_view_find_path (tree_view, tree, node); + *path = _gtk_tree_path_new_from_rbtree (tree, node); return TRUE; } @@ -13557,6 +13541,7 @@ gtk_tree_view_get_cell_area_height (GtkTreeView *tree_view, GtkRBNode *node, gint vertical_separator) { + int expander_size = gtk_tree_view_get_expander_size (tree_view); int height; /* The "cell" areas are the cell_area passed in to gtk_cell_renderer_render(), @@ -13568,8 +13553,8 @@ gtk_tree_view_get_cell_area_height (GtkTreeView *tree_view, * function will not be called for irregular (e.g. separator) rows. */ height = gtk_tree_view_get_row_height (tree_view, node); - if (height < tree_view->priv->expander_size) - height = tree_view->priv->expander_size; + if (height < expander_size) + height = expander_size; return height - vertical_separator; } @@ -13676,9 +13661,10 @@ gtk_tree_view_get_cell_area (GtkTreeView *tree_view, if (gtk_tree_view_draw_expanders (tree_view)) { + int expander_size = gtk_tree_view_get_expander_size (tree_view); if (!rtl) - rect->x += depth * tree_view->priv->expander_size; - rect->width -= depth * tree_view->priv->expander_size; + rect->x += depth * expander_size; + rect->width -= depth * expander_size; } rect->width = MAX (rect->width, 0); @@ -13690,6 +13676,7 @@ static inline gint gtk_tree_view_get_row_height (GtkTreeView *tree_view, GtkRBNode *node) { + int expander_size = gtk_tree_view_get_expander_size (tree_view); int height; /* The "background" areas of all rows/cells add up to cover the entire tree. @@ -13702,7 +13689,7 @@ gtk_tree_view_get_row_height (GtkTreeView *tree_view, */ height = GTK_RBNODE_GET_HEIGHT (node); if (height <= 0) - height = tree_view->priv->expander_size; + height = expander_size; return height; } @@ -14024,7 +14011,7 @@ gtk_tree_view_get_visible_range (GtkTreeView *tree_view, TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, 0), &tree, &node); if (node) - *start_path = _gtk_tree_view_find_path (tree_view, tree, node); + *start_path = _gtk_tree_path_new_from_rbtree (tree, node); else retval = FALSE; } @@ -14040,7 +14027,7 @@ gtk_tree_view_get_visible_range (GtkTreeView *tree_view, _gtk_rbtree_find_offset (tree_view->priv->tree, y, &tree, &node); if (node) - *end_path = _gtk_tree_view_find_path (tree_view, tree, node); + *end_path = _gtk_tree_path_new_from_rbtree (tree, node); else retval = FALSE; } @@ -14530,7 +14517,6 @@ gtk_tree_view_create_row_drag_icon (GtkTreeView *tree_view, GtkRBTree *tree; GtkRBNode *node; GtkStyleContext *context; - GtkStateFlags state; gint cell_offset; GList *list; GdkRectangle background_area; @@ -14570,11 +14556,6 @@ gtk_tree_view_create_row_drag_icon (GtkTreeView *tree_view, context = gtk_widget_get_style_context (widget); gtk_style_context_save (context); - - state = gtk_widget_get_state_flags (widget); - gtk_style_context_set_state (context, state); - - gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW); gtk_style_context_add_region (context, GTK_STYLE_REGION_COLUMN, 0); gtk_widget_style_get (widget, @@ -14650,9 +14631,10 @@ gtk_tree_view_create_row_drag_icon (GtkTreeView *tree_view, if (gtk_tree_view_draw_expanders (tree_view)) { + int expander_size = gtk_tree_view_get_expander_size (tree_view); if (!rtl) - cell_area.x += depth * tree_view->priv->expander_size; - cell_area.width -= depth * tree_view->priv->expander_size; + cell_area.x += depth * expander_size; + cell_area.width -= depth * expander_size; } } @@ -14711,6 +14693,8 @@ gtk_tree_view_create_row_drag_icon (GtkTreeView *tree_view, * This function should almost never be used. It is meant for private use by * ATK for determining the number of visible children that are removed when the * user collapses a row, or a row is deleted. + * + * Deprecated: 3.4: Accessibility does not need the function anymore. **/ void gtk_tree_view_set_destroy_count_func (GtkTreeView *tree_view, @@ -15053,7 +15037,7 @@ gtk_tree_view_search_position_func (GtkTreeView *tree_view, GdkRectangle monitor; monitor_num = gdk_screen_get_monitor_at_window (screen, tree_window); - gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor); + gdk_screen_get_monitor_workarea (screen, monitor_num, &monitor); gtk_widget_realize (search_dialog); @@ -15115,8 +15099,6 @@ gtk_tree_view_search_activate (GtkEntry *entry, GtkTreeView *tree_view) { GtkTreePath *path; - GtkRBNode *node; - GtkRBTree *tree; gtk_tree_view_search_dialog_hide (tree_view->priv->search_window, tree_view, @@ -15124,14 +15106,13 @@ gtk_tree_view_search_activate (GtkEntry *entry, /* If we have a row selected and it's the cursor row, we activate * the row XXX */ - if (gtk_tree_row_reference_valid (tree_view->priv->cursor)) + if (tree_view->priv->cursor_node && + GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_SELECTED)) { - path = gtk_tree_row_reference_get_path (tree_view->priv->cursor); + path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree, + tree_view->priv->cursor_node); - _gtk_tree_view_find_node (tree_view, path, &tree, &node); - - if (node && GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED)) - gtk_tree_view_row_activated (tree_view, path, tree_view->priv->focus_column); + gtk_tree_view_row_activated (tree_view, path, tree_view->priv->focus_column); gtk_tree_path_free (path); } @@ -15434,7 +15415,7 @@ gtk_tree_view_search_iter (GtkTreeModel *model, gtk_tree_view_scroll_to_cell (tree_view, path, NULL, TRUE, 0.5, 0.0); gtk_tree_selection_select_iter (selection, iter); - gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE); + gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE); if (path) gtk_tree_path_free (path); @@ -15449,10 +15430,7 @@ gtk_tree_view_search_iter (GtkTreeModel *model, GtkTreeIter tmp; tree = node->children; - node = tree->root; - - while (node->left != tree->nil) - node = node->left; + node = _gtk_rbtree_first (tree); tmp = *iter; has_child = gtk_tree_model_iter_children (model, iter, &tmp); @@ -15641,7 +15619,7 @@ _gtk_tree_view_add_editable (GtkTreeView *tree_view, tree_view->priv->edited_column = column; - gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE); + gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE); cell_area->y += pre_val - (int)gtk_adjustment_get_value (tree_view->priv->vadjustment); gtk_widget_get_preferred_size (GTK_WIDGET (cell_editable), @@ -15738,7 +15716,7 @@ gtk_tree_view_get_hover_selection (GtkTreeView *tree_view) * @tree_view: a #GtkTreeView * @expand: %TRUE to enable hover selection mode * - * Enables of disables the hover expansion mode of @tree_view. + * Enables or disables the hover expansion mode of @tree_view. * Hover expansion makes rows expand or collapse if the pointer * moves over them. * @@ -16443,7 +16421,7 @@ gtk_tree_view_set_tooltip_query_cb (GtkWidget *widget, * for you. @column should be set to the column in @tree_view's model * containing the tooltip texts, or -1 to disable this feature. * - * When enabled, #GtkWidget::has-tooltip will be set to %TRUE and + * When enabled, #GtkWidget:has-tooltip will be set to %TRUE and * @tree_view will connect a #GtkWidget::query-tooltip signal handler. * * Note that the signal handler sets the text with gtk_tooltip_set_markup(),