X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtktreeview.c;h=df342e085540c8936834de091a00b85c18e6e8ff;hb=6a8d494ba193cd855d3c5850b75e2061d4806a0b;hp=4996d21bcbbfcfe993a4d594e19df79096bd6d18;hpb=43de55d7a96e5563b427e8fca075dce15b2ad36b;p=~andy%2Fgtk diff --git a/gtk/gtktreeview.c b/gtk/gtktreeview.c index 4996d21bc..df342e085 100644 --- a/gtk/gtktreeview.c +++ b/gtk/gtktreeview.c @@ -19,16 +19,16 @@ #include "config.h" + #include #include -#include #include "gtktreeview.h" #include "gtkrbtree.h" #include "gtktreednd.h" #include "gtktreeprivate.h" #include "gtkcellrenderer.h" -#include "gtkmain.h" +#include "gtkmainprivate.h" #include "gtkmarshalers.h" #include "gtkbuildable.h" #include "gtkbutton.h" @@ -49,6 +49,8 @@ #include "gtkprivate.h" #include "gtkwidgetprivate.h" #include "gtkentryprivate.h" +#include "gtkstylecontextprivate.h" +#include "gtktypebuiltins.h" /** @@ -134,19 +136,6 @@ * */ - -typedef enum -{ - GTK_TREE_VIEW_IS_LIST = 1 << 0, - GTK_TREE_VIEW_SHOW_EXPANDERS = 1 << 1, - GTK_TREE_VIEW_IN_COLUMN_RESIZE = 1 << 2, - GTK_TREE_VIEW_ARROW_PRELIT = 1 << 3, - GTK_TREE_VIEW_HEADERS_VISIBLE = 1 << 4, - GTK_TREE_VIEW_DRAW_KEYFOCUS = 1 << 5, - GTK_TREE_VIEW_MODEL_SETUP = 1 << 6, - GTK_TREE_VIEW_IN_COLUMN_DRAG = 1 << 7 -} GtkTreeViewFlags; - enum { DRAG_COLUMN_WINDOW_STATE_UNSET = 0, @@ -163,12 +152,6 @@ enum RUBBER_BAND_ACTIVE = 2 }; -#define GTK_TREE_VIEW_SET_FLAG(tree_view, flag) G_STMT_START{ (tree_view->priv->flags|=flag); }G_STMT_END -#define GTK_TREE_VIEW_UNSET_FLAG(tree_view, flag) G_STMT_START{ (tree_view->priv->flags&=~(flag)); }G_STMT_END -#define GTK_TREE_VIEW_FLAG_SET(tree_view, flag) ((tree_view->priv->flags&flag)==flag) -#define TREE_VIEW_COLUMN_REQUESTED_WIDTH(column) (CLAMP (column->requested_width, (column->min_width!=-1)?column->min_width:column->requested_width, (column->max_width!=-1)?column->max_width:column->requested_width)) -#define TREE_VIEW_DRAW_EXPANDERS(tree_view) (!GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IS_LIST)&>K_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_SHOW_EXPANDERS)) - /* 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. */ @@ -251,28 +234,12 @@ enum #define GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT 5000 #define AUTO_EXPAND_TIMEOUT 500 -/* The "background" areas of all rows/cells add up to cover the entire tree. - * The background includes all inter-row and inter-cell spacing. - * The "cell" areas are the cell_area passed in to gtk_cell_renderer_render(), - * i.e. just the cells, no spacing. - */ - -#define BACKGROUND_HEIGHT(node) (GTK_RBNODE_GET_HEIGHT (node)) -#define CELL_HEIGHT(node, separator) ((BACKGROUND_HEIGHT (node)) - (separator)) - /* Translate from bin_window coordinates to rbtree (tree coordinates) and * vice versa. */ #define TREE_WINDOW_Y_TO_RBTREE_Y(tree_view,y) ((y) + tree_view->priv->dy) #define RBTREE_Y_TO_TREE_WINDOW_Y(tree_view,y) ((y) - tree_view->priv->dy) -/* This is in bin_window coordinates */ -#define BACKGROUND_FIRST_PIXEL(tree_view,tree,node) (RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, _gtk_rbtree_node_find_offset ((tree), (node)))) -#define CELL_FIRST_PIXEL(tree_view,tree,node,separator) (BACKGROUND_FIRST_PIXEL (tree_view,tree,node) + separator/2) - -#define ROW_HEIGHT(tree_view,height) \ - ((height > 0) ? (height) : (tree_view)->priv->expander_size) - typedef struct _GtkTreeViewColumnReorder GtkTreeViewColumnReorder; struct _GtkTreeViewColumnReorder { @@ -311,7 +278,6 @@ struct _GtkTreeViewPrivate { GtkTreeModel *model; - guint flags; /* tree information */ GtkRBTree *tree; @@ -380,7 +346,6 @@ struct _GtkTreeViewPrivate GtkRBNode *expanded_collapsed_node; GtkRBTree *expanded_collapsed_tree; guint expand_collapse_timeout; - gint deepest_depth; /* Auto expand/collapse timeout in hover mode */ guint auto_expand_timeout; @@ -529,6 +494,16 @@ struct _GtkTreeViewPrivate * driving the scrollable adjustment values */ guint hscroll_policy : 1; guint vscroll_policy : 1; + + /* GtkTreeView flags */ + guint is_list : 1; + guint show_expanders : 1; + guint in_column_resize : 1; + guint arrow_prelit : 1; + guint headers_visible : 1; + guint draw_keyfocus : 1; + guint model_setup : 1; + guint in_column_drag : 1; }; @@ -602,7 +577,8 @@ 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); + GtkRequisition *requisition, + gboolean may_validate); static void gtk_tree_view_size_allocate (GtkWidget *widget, GtkAllocation *allocation); static gboolean gtk_tree_view_draw (GtkWidget *widget, @@ -628,6 +604,9 @@ static gboolean gtk_tree_view_configure (GtkWidget *widget, GdkEventConfigure *event); #endif +static GtkWidgetPath * gtk_tree_view_get_path_for_child (GtkContainer *container, + GtkWidget *child); + static void gtk_tree_view_set_focus_child (GtkContainer *container, GtkWidget *child); static gint gtk_tree_view_focus_out (GtkWidget *widget, @@ -635,12 +614,11 @@ static gint gtk_tree_view_focus_out (GtkWidget *widget, static gint gtk_tree_view_focus (GtkWidget *widget, GtkDirectionType direction); static void gtk_tree_view_grab_focus (GtkWidget *widget); -static void gtk_tree_view_style_set (GtkWidget *widget, - GtkStyle *previous_style); +static void gtk_tree_view_style_updated (GtkWidget *widget); static void gtk_tree_view_grab_notify (GtkWidget *widget, gboolean was_grabbed); -static void gtk_tree_view_state_changed (GtkWidget *widget, - GtkStateType previous_state); +static void gtk_tree_view_state_flags_changed (GtkWidget *widget, + GtkStateFlags previous_state); /* container signals */ static void gtk_tree_view_remove (GtkContainer *container, @@ -748,6 +726,7 @@ static void invalidate_empty_focus (GtkTreeView *tree_view); /* Internal functions */ static gboolean gtk_tree_view_is_expander_column (GtkTreeView *tree_view, GtkTreeViewColumn *column); +static inline gboolean gtk_tree_view_draw_expanders (GtkTreeView *tree_view); static void gtk_tree_view_add_move_binding (GtkBindingSet *binding_set, guint keyval, guint modmask, @@ -818,14 +797,6 @@ static gboolean gtk_tree_view_has_can_focus_cell (GtkTreeView static void column_sizing_notify (GObject *object, GParamSpec *pspec, gpointer data); -static gboolean expand_collapse_timeout (gpointer data); -static void add_expand_collapse_timeout (GtkTreeView *tree_view, - GtkRBTree *tree, - GtkRBNode *node, - gboolean expand); -static void remove_expand_collapse_timeout (GtkTreeView *tree_view); -static void cancel_arrow_animation (GtkTreeView *tree_view); -static gboolean do_expand_collapse (GtkTreeView *tree_view); static void gtk_tree_view_stop_rubber_band (GtkTreeView *tree_view); static void update_prelight (GtkTreeView *tree_view, int x, @@ -833,6 +804,20 @@ static void update_prelight (GtkTreeView static inline gint gtk_tree_view_get_effective_header_height (GtkTreeView *tree_view); +static inline gint gtk_tree_view_get_cell_area_y_offset (GtkTreeView *tree_view, + GtkRBTree *tree, + GtkRBNode *node, + gint vertical_separator); +static inline gint gtk_tree_view_get_cell_area_height (GtkTreeView *tree_view, + GtkRBNode *node, + gint vertical_separator); + +static inline gint gtk_tree_view_get_row_y_offset (GtkTreeView *tree_view, + GtkRBTree *tree, + GtkRBNode *node); +static inline gint gtk_tree_view_get_row_height (GtkTreeView *tree_view, + GtkRBNode *node); + /* interactive search */ static void gtk_tree_view_ensure_interactive_directory (GtkTreeView *tree_view); static void gtk_tree_view_search_dialog_hide (GtkWidget *search_dialog, @@ -886,7 +871,8 @@ static void gtk_tree_view_put (GtkTreeView *tree_ gint width, gint height); static gboolean gtk_tree_view_start_editing (GtkTreeView *tree_view, - GtkTreePath *cursor_path); + GtkTreePath *cursor_path, + gboolean edit_only); static void gtk_tree_view_stop_editing (GtkTreeView *tree_view, gboolean cancel_editing); static gboolean gtk_tree_view_real_start_interactive_search (GtkTreeView *tree_view, @@ -972,14 +958,15 @@ gtk_tree_view_class_init (GtkTreeViewClass *class) widget_class->drag_data_received = gtk_tree_view_drag_data_received; widget_class->focus = gtk_tree_view_focus; widget_class->grab_focus = gtk_tree_view_grab_focus; - widget_class->style_set = gtk_tree_view_style_set; + widget_class->style_updated = gtk_tree_view_style_updated; widget_class->grab_notify = gtk_tree_view_grab_notify; - widget_class->state_changed = gtk_tree_view_state_changed; + widget_class->state_flags_changed = gtk_tree_view_state_flags_changed; /* GtkContainer signals */ container_class->remove = gtk_tree_view_remove; container_class->forall = gtk_tree_view_forall; container_class->set_focus_child = gtk_tree_view_set_focus_child; + container_class->get_path_for_child = gtk_tree_view_get_path_for_child; class->move_cursor = gtk_tree_view_real_move_cursor; class->select_all = gtk_tree_view_real_select_all; @@ -1719,9 +1706,9 @@ gtk_tree_view_init (GtkTreeView *tree_view) gtk_widget_set_can_focus (GTK_WIDGET (tree_view), TRUE); gtk_widget_set_redraw_on_allocate (GTK_WIDGET (tree_view), FALSE); - tree_view->priv->flags = GTK_TREE_VIEW_SHOW_EXPANDERS - | GTK_TREE_VIEW_DRAW_KEYFOCUS - | GTK_TREE_VIEW_HEADERS_VISIBLE; + tree_view->priv->show_expanders = TRUE; + tree_view->priv->draw_keyfocus = TRUE; + tree_view->priv->headers_visible = TRUE; /* We need some padding */ tree_view->priv->dy = 0; @@ -1770,8 +1757,6 @@ gtk_tree_view_init (GtkTreeView *tree_view) tree_view->priv->event_last_x = -10000; tree_view->priv->event_last_y = -10000; - tree_view->priv->deepest_depth = 1; - gtk_tree_view_set_vadjustment (tree_view, NULL); gtk_tree_view_set_hadjustment (tree_view, NULL); } @@ -1922,7 +1907,7 @@ gtk_tree_view_get_property (GObject *object, g_value_set_boolean (value, tree_view->priv->hover_expand); break; case PROP_SHOW_EXPANDERS: - g_value_set_boolean (value, GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_SHOW_EXPANDERS)); + g_value_set_boolean (value, tree_view->priv->show_expanders); break; case PROP_LEVEL_INDENTATION: g_value_set_int (value, tree_view->priv->level_indentation); @@ -2129,7 +2114,7 @@ gtk_tree_view_map_buttons (GtkTreeView *tree_view) g_return_if_fail (gtk_widget_get_mapped (GTK_WIDGET (tree_view))); - if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE)) + if (tree_view->priv->headers_visible) { GtkTreeViewColumn *column; GtkWidget *button; @@ -2140,6 +2125,9 @@ gtk_tree_view_map_buttons (GtkTreeView *tree_view) column = list->data; button = gtk_tree_view_column_get_button (column); + if (gtk_tree_view_column_get_visible (column) && button) + gtk_widget_show_now (button); + if (gtk_widget_get_visible (button) && !gtk_widget_get_mapped (button)) gtk_widget_map (button); @@ -2194,7 +2182,7 @@ static void gtk_tree_view_realize (GtkWidget *widget) { GtkAllocation allocation; - GtkStyle *style; + GtkStyleContext *context; GtkTreeView *tree_view = GTK_TREE_VIEW (widget); GdkWindow *window; GdkWindowAttr attributes; @@ -2263,12 +2251,14 @@ gtk_tree_view_realize (GtkWidget *widget) &attributes, attributes_mask); gdk_window_set_user_data (tree_view->priv->header_window, widget); - /* Add them all up. */ - gtk_widget_style_attach (widget); - style = gtk_widget_get_style (widget); - gdk_window_set_background (tree_view->priv->bin_window, - &style->base[gtk_widget_get_state (widget)]); - gtk_style_set_background (style, tree_view->priv->header_window, GTK_STATE_NORMAL); + context = gtk_widget_get_style_context (widget); + + gtk_style_context_save (context); + gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW); + gtk_style_context_set_background (context, tree_view->priv->bin_window); + gtk_style_context_restore (context); + + gtk_style_context_set_background (context, tree_view->priv->header_window); tmp_list = tree_view->priv->children; while (tmp_list) @@ -2294,6 +2284,7 @@ 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,8 +2305,9 @@ gtk_tree_view_unrealize (GtkWidget *widget) priv->open_dest_timeout = 0; } - remove_expand_collapse_timeout (tree_view); - + 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); @@ -2433,22 +2425,24 @@ gtk_tree_view_update_size (GtkTreeView *tree_view) static void gtk_tree_view_size_request (GtkWidget *widget, - GtkRequisition *requisition) + GtkRequisition *requisition, + gboolean may_validate) { GtkTreeView *tree_view = GTK_TREE_VIEW (widget); - GList *tmp_list; - /* 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); + 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_size_request_columns (tree_view); gtk_tree_view_update_size (GTK_TREE_VIEW (widget)); requisition->width = tree_view->priv->width; requisition->height = tree_view->priv->height + gtk_tree_view_get_effective_header_height (tree_view); - - tmp_list = tree_view->priv->children; } static void @@ -2458,7 +2452,7 @@ gtk_tree_view_get_preferred_width (GtkWidget *widget, { GtkRequisition requisition; - gtk_tree_view_size_request (widget, &requisition); + gtk_tree_view_size_request (widget, &requisition, TRUE); *minimum = *natural = requisition.width; } @@ -2470,7 +2464,7 @@ gtk_tree_view_get_preferred_height (GtkWidget *widget, { GtkRequisition requisition; - gtk_tree_view_size_request (widget, &requisition); + gtk_tree_view_size_request (widget, &requisition, TRUE); *minimum = *natural = requisition.height; } @@ -2552,56 +2546,6 @@ invalidate_last_column (GtkTreeView *tree_view) } } -static gboolean -gtk_tree_view_column_is_edge (GtkTreeView *tree_view, - GtkTreeViewColumn *column) -{ - GtkTreeViewColumn *first_column = tree_view->priv->columns->data; - GtkTreeViewColumn *last_column = g_list_last (tree_view->priv->columns)->data; - - return (column == first_column || column == last_column); -} - -/* Gets the space in a column that is not actually distributed to - * the internal cell area, i.e. total indentation expander size - * grid line widths and horizontal separators */ -static gint -gtk_tree_view_get_column_padding (GtkTreeView *tree_view, - GtkTreeViewColumn *column) -{ - gint padding; - gint grid_line_width; - gint horizontal_separator; - - /* Get the deepest depth */ - - gtk_widget_style_get (GTK_WIDGET (tree_view), - "horizontal-separator", &horizontal_separator, - "grid-line-width", &grid_line_width, - NULL); - - padding = horizontal_separator; - - if (gtk_tree_view_is_expander_column (tree_view, column)) - { - padding += (tree_view->priv->deepest_depth - 1) * tree_view->priv->level_indentation; - - if (TREE_VIEW_DRAW_EXPANDERS (tree_view)) - padding += tree_view->priv->deepest_depth * tree_view->priv->expander_size; - } - - if (tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_VERTICAL || - tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH) - { - if (gtk_tree_view_column_is_edge (tree_view, column)) - padding += grid_line_width / 2.0; - else - padding += grid_line_width; - } - - return padding; -} - /* GtkWidget::size_allocate helper */ static void gtk_tree_view_size_allocate_columns (GtkWidget *widget, @@ -2692,7 +2636,6 @@ gtk_tree_view_size_allocate_columns (GtkWidget *widget, list != (rtl ? first_column->prev : last_column->next); list = (rtl ? list->prev : list->next)) { - gint column_cell_width = 0; gint old_width, column_width; column = list->data; @@ -2748,13 +2691,7 @@ gtk_tree_view_size_allocate_columns (GtkWidget *widget, if (extra_for_last > 0 && list == last_column) column_width += extra_for_last; - /* Remove any padding that we add to the column around the cell area - * and give the correct internal cell area to the column. - */ - column_cell_width = - column_width - gtk_tree_view_get_column_padding (tree_view, column); - - _gtk_tree_view_column_allocate (column, width, column_width, column_cell_width); + _gtk_tree_view_column_allocate (column, width, column_width); width += column_width; @@ -2822,7 +2759,7 @@ gtk_tree_view_size_allocate (GtkWidget *widget, allocation->width * 0.1); gtk_adjustment_set_lower (tree_view->priv->hadjustment, 0); gtk_adjustment_set_upper (tree_view->priv->hadjustment, - MAX (tree_view->priv->hadjustment->page_size, + MAX (gtk_adjustment_get_page_size (tree_view->priv->hadjustment), tree_view->priv->width)); g_object_thaw_notify (G_OBJECT (tree_view->priv->hadjustment)); @@ -2840,13 +2777,13 @@ gtk_tree_view_size_allocate (GtkWidget *widget, else if (allocation->width != old_width) { gtk_adjustment_set_value (tree_view->priv->hadjustment, - CLAMP (tree_view->priv->hadjustment->value - allocation->width + old_width, + CLAMP (gtk_adjustment_get_value (tree_view->priv->hadjustment) - allocation->width + old_width, 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 - tree_view->priv->hadjustment->value), + 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)); } @@ -2857,7 +2794,7 @@ gtk_tree_view_size_allocate (GtkWidget *widget, } } else - if (tree_view->priv->hadjustment->value + allocation->width > tree_view->priv->width) + if (gtk_adjustment_get_value (tree_view->priv->hadjustment) + allocation->width > tree_view->priv->width) gtk_adjustment_set_value (tree_view->priv->hadjustment, MAX (tree_view->priv->width - allocation->width, 0)); @@ -2867,21 +2804,21 @@ gtk_tree_view_size_allocate (GtkWidget *widget, allocation->height - gtk_tree_view_get_effective_header_height (tree_view)); gtk_adjustment_set_step_increment (tree_view->priv->vadjustment, - tree_view->priv->vadjustment->page_size * 0.1); + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) * 0.1); gtk_adjustment_set_page_increment (tree_view->priv->vadjustment, - tree_view->priv->vadjustment->page_size * 0.9); + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) * 0.9); gtk_adjustment_set_lower (tree_view->priv->vadjustment, 0); gtk_adjustment_set_upper (tree_view->priv->vadjustment, - MAX (tree_view->priv->vadjustment->page_size, + MAX (gtk_adjustment_get_page_size (tree_view->priv->vadjustment), tree_view->priv->height)); g_object_thaw_notify (G_OBJECT (tree_view->priv->vadjustment)); /* now the adjustments and window sizes are in sync, we can sync toprow/dy again */ - if (tree_view->priv->height <= tree_view->priv->vadjustment->page_size) + if (tree_view->priv->height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment)) gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0); - else if (tree_view->priv->vadjustment->value + tree_view->priv->vadjustment->page_size > tree_view->priv->height) + else if (gtk_adjustment_get_value (tree_view->priv->vadjustment) + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) > tree_view->priv->height) gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), - tree_view->priv->height - tree_view->priv->vadjustment->page_size); + tree_view->priv->height - gtk_adjustment_get_page_size (tree_view->priv->vadjustment)); else if (gtk_tree_row_reference_valid (tree_view->priv->top_row)) gtk_tree_view_top_row_to_dy (tree_view); else @@ -2893,12 +2830,12 @@ gtk_tree_view_size_allocate (GtkWidget *widget, allocation->x, allocation->y, allocation->width, allocation->height); gdk_window_move_resize (tree_view->priv->header_window, - - (gint) tree_view->priv->hadjustment->value, + - (gint) gtk_adjustment_get_value (tree_view->priv->hadjustment), 0, MAX (tree_view->priv->width, allocation->width), tree_view->priv->header_height); gdk_window_move_resize (tree_view->priv->bin_window, - - (gint) tree_view->priv->hadjustment->value, + - (gint) gtk_adjustment_get_value (tree_view->priv->hadjustment), gtk_tree_view_get_effective_header_height (tree_view), MAX (tree_view->priv->width, allocation->width), allocation->height - gtk_tree_view_get_effective_header_height (tree_view)); @@ -2960,7 +2897,7 @@ grab_focus_and_unset_draw_keyfocus (GtkTreeView *tree_view) if (gtk_widget_get_can_focus (widget) && !gtk_widget_has_focus (widget)) gtk_widget_grab_focus (widget); - GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS); + tree_view->priv->draw_keyfocus = 0; } static inline gboolean @@ -3039,8 +2976,8 @@ gtk_tree_view_button_press (GtkWidget *widget, /* are we in an arrow? */ if (tree_view->priv->prelight_node && - GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_ARROW_PRELIT) && - TREE_VIEW_DRAW_EXPANDERS (tree_view)) + tree_view->priv->arrow_prelit && + gtk_tree_view_draw_expanders (tree_view)) { if (event->button == 1) { @@ -3082,7 +3019,7 @@ gtk_tree_view_button_press (GtkWidget *widget, depth = gtk_tree_path_get_depth (path); background_area.y = y_offset + event->y; - background_area.height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node)); + background_area.height = gtk_tree_view_get_row_height (tree_view, node); background_area.x = 0; @@ -3117,7 +3054,7 @@ gtk_tree_view_button_press (GtkWidget *widget, cell_area.x += (depth - 1) * tree_view->priv->level_indentation; cell_area.width -= (depth - 1) * tree_view->priv->level_indentation; - if (TREE_VIEW_DRAW_EXPANDERS (tree_view)) + if (gtk_tree_view_draw_expanders (tree_view)) { if (!rtl) cell_area.x += depth * tree_view->priv->expander_size; @@ -3164,10 +3101,7 @@ gtk_tree_view_button_press (GtkWidget *widget, guint flags = 0; if (_gtk_tree_view_column_cell_event (column, - NULL, (GdkEvent *)event, - NULL, - &background_area, &cell_area, flags)) { GtkCellArea *area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column)); @@ -3188,17 +3122,33 @@ gtk_tree_view_button_press (GtkWidget *widget, /* select */ node_selected = GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED); - pre_val = tree_view->priv->vadjustment->value; + pre_val = gtk_adjustment_get_value (tree_view->priv->vadjustment); /* we only handle selection modifications on the first button press */ if (event->type == GDK_BUTTON_PRESS) { + GtkCellRenderer *focus_cell; + if ((event->state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK) tree_view->priv->ctrl_pressed = TRUE; if ((event->state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK) tree_view->priv->shift_pressed = TRUE; + /* We update the focus cell here, this is also needed if the + * column does not contain an editable cell. In this case, + * GtkCellArea did not receive the event for processing (and + * could not update the focus cell). + */ + focus_cell = _gtk_tree_view_column_get_cell_at_pos (column, + &cell_area, + &background_area, + event->x, + event->y); + + if (focus_cell) + gtk_tree_view_column_focus_cell (column, focus_cell); + if (event->state & GDK_CONTROL_MASK) { gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE); @@ -3222,7 +3172,7 @@ gtk_tree_view_button_press (GtkWidget *widget, * correct here */ - aft_val = tree_view->priv->vadjustment->value; + aft_val = gtk_adjustment_get_value (tree_view->priv->vadjustment); dval = pre_val - aft_val; cell_area.y += dval; @@ -3240,7 +3190,7 @@ gtk_tree_view_button_press (GtkWidget *widget, if (tree_view->priv->rubber_banding_enable && !node_selected - && tree_view->priv->selection->type == GTK_SELECTION_MULTIPLE) + && gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE) { tree_view->priv->press_start_y += tree_view->priv->dy; tree_view->priv->rubber_band_x = event->x; @@ -3330,15 +3280,19 @@ gtk_tree_view_button_press (GtkWidget *widget, return TRUE; } - if (gdk_pointer_grab (_gtk_tree_view_column_get_window (column), FALSE, - GDK_POINTER_MOTION_HINT_MASK | - GDK_BUTTON1_MOTION_MASK | - GDK_BUTTON_RELEASE_MASK, - NULL, NULL, event->time)) - return FALSE; + if (gdk_device_grab (gdk_event_get_device ((GdkEvent*)event), + _gtk_tree_view_column_get_window (column), + GDK_OWNERSHIP_NONE, + FALSE, + GDK_POINTER_MOTION_HINT_MASK + | GDK_BUTTON1_MOTION_MASK + | GDK_BUTTON_RELEASE_MASK, + NULL, + event->time) != GDK_GRAB_SUCCESS) + return FALSE; - gtk_grab_add (widget); - GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_IN_COLUMN_RESIZE); + 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); @@ -3374,12 +3328,15 @@ gtk_tree_view_button_release_drag_column (GtkWidget *widget, GtkWidget *button; GList *l; gboolean rtl; + GdkDevice *device, *other; tree_view = GTK_TREE_VIEW (widget); rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL); - gdk_display_pointer_ungrab (gtk_widget_get_display (widget), GDK_CURRENT_TIME); - gdk_display_keyboard_ungrab (gtk_widget_get_display (widget), GDK_CURRENT_TIME); + device = gdk_event_get_device ((GdkEvent*)event); + other = gdk_device_get_associated_device (device); + gdk_device_ungrab (device, event->time); + gdk_device_ungrab (other, event->time); /* Move the button back */ button = gtk_tree_view_column_get_button (tree_view->priv->drag_column); @@ -3427,7 +3384,7 @@ gtk_tree_view_button_release_drag_column (GtkWidget *widget, /* Reset our flags */ tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_UNSET; - GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_IN_COLUMN_DRAG); + tree_view->priv->in_column_drag = FALSE; return TRUE; } @@ -3452,10 +3409,9 @@ gtk_tree_view_button_release_column_resize (GtkWidget *widget, 0, 0, NULL, NULL, drag_data); - GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_IN_COLUMN_RESIZE); + tree_view->priv->in_column_resize = FALSE; gtk_grab_remove (widget); - gdk_display_pointer_ungrab (gdk_window_get_display (event->window), - event->time); + gdk_device_ungrab (gdk_event_get_device ((GdkEvent*)event), event->time); return TRUE; } @@ -3465,7 +3421,7 @@ gtk_tree_view_button_release (GtkWidget *widget, { GtkTreeView *tree_view = GTK_TREE_VIEW (widget); - if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_DRAG)) + if (tree_view->priv->in_column_drag) return gtk_tree_view_button_release_drag_column (widget, event); if (tree_view->priv->rubber_band_status) @@ -3474,7 +3430,7 @@ gtk_tree_view_button_release (GtkWidget *widget, if (tree_view->priv->pressed_button == event->button) tree_view->priv->pressed_button = -1; - if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_RESIZE)) + if (tree_view->priv->in_column_resize) return gtk_tree_view_button_release_column_resize (widget, event); if (tree_view->priv->button_pressed_node == NULL) @@ -3484,7 +3440,7 @@ gtk_tree_view_button_release (GtkWidget *widget, { gtk_grab_remove (widget); if (tree_view->priv->button_pressed_node == tree_view->priv->prelight_node && - GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_ARROW_PRELIT)) + tree_view->priv->arrow_prelit) { GtkTreePath *path = NULL; @@ -3517,10 +3473,10 @@ gtk_tree_view_grab_broken (GtkWidget *widget, { GtkTreeView *tree_view = GTK_TREE_VIEW (widget); - if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_DRAG)) + if (tree_view->priv->in_column_drag) gtk_tree_view_button_release_drag_column (widget, (GdkEventButton *)event); - if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_RESIZE)) + if (tree_view->priv->in_column_resize) gtk_tree_view_button_release_column_resize (widget, (GdkEventButton *)event); return TRUE; @@ -3560,9 +3516,8 @@ coords_are_over_arrow (GtkTreeView *tree_view, if ((node->flags & GTK_RBNODE_IS_PARENT) == 0) return FALSE; - arrow.y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node); - - arrow.height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node)); + arrow.y = gtk_tree_view_get_row_y_offset (tree_view, tree, node); + arrow.height = gtk_tree_view_get_row_height (tree_view, node); gtk_tree_view_get_arrow_xrange (tree_view, tree, &arrow.x, &x2); @@ -3623,23 +3578,18 @@ do_prelight (GtkTreeView *tree_view, /* We are still on the same node, but we might need to take care of the arrow */ - if (tree && node && TREE_VIEW_DRAW_EXPANDERS (tree_view)) + if (tree && node && gtk_tree_view_draw_expanders (tree_view)) { gboolean over_arrow; - gboolean flag_set; over_arrow = coords_are_over_arrow (tree_view, tree, node, x, y); - flag_set = GTK_TREE_VIEW_FLAG_SET (tree_view, - GTK_TREE_VIEW_ARROW_PRELIT); - if (over_arrow != flag_set) + if (over_arrow != tree_view->priv->arrow_prelit) { if (over_arrow) - GTK_TREE_VIEW_SET_FLAG (tree_view, - GTK_TREE_VIEW_ARROW_PRELIT); + tree_view->priv->arrow_prelit = TRUE; else - GTK_TREE_VIEW_UNSET_FLAG (tree_view, - GTK_TREE_VIEW_ARROW_PRELIT); + tree_view->priv->arrow_prelit = FALSE; gtk_tree_view_queue_draw_arrow (tree_view, tree, node); } @@ -3655,10 +3605,10 @@ do_prelight (GtkTreeView *tree_view, GTK_RBNODE_UNSET_FLAG (tree_view->priv->prelight_node, GTK_RBNODE_IS_PRELIT); - if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_ARROW_PRELIT) - && TREE_VIEW_DRAW_EXPANDERS (tree_view)) + if (tree_view->priv->arrow_prelit + && gtk_tree_view_draw_expanders (tree_view)) { - GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_ARROW_PRELIT); + tree_view->priv->arrow_prelit = FALSE; gtk_tree_view_queue_draw_arrow (tree_view, tree_view->priv->prelight_tree, @@ -3684,10 +3634,10 @@ do_prelight (GtkTreeView *tree_view, /* Prelight the new node and arrow */ - if (TREE_VIEW_DRAW_EXPANDERS (tree_view) + if (gtk_tree_view_draw_expanders (tree_view) && coords_are_over_arrow (tree_view, tree, node, x, y)) { - GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_ARROW_PRELIT); + tree_view->priv->arrow_prelit = TRUE; gtk_tree_view_queue_draw_arrow (tree_view, tree, node); } @@ -3729,7 +3679,7 @@ prelight_or_select (GtkTreeView *tree_view, gtk_tree_selection_select_path (tree_view->priv->selection, path); if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED)) { - GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS); + tree_view->priv->draw_keyfocus = FALSE; gtk_tree_view_real_set_cursor (tree_view, path, FALSE, FALSE); } gtk_tree_path_free (path); @@ -4088,7 +4038,7 @@ gtk_tree_view_motion_resize_column (GtkWidget *widget, x = event->x; if (tree_view->priv->hadjustment) - x += tree_view->priv->hadjustment->value; + 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); @@ -4155,7 +4105,7 @@ gtk_tree_view_vertical_autoscroll (GtkTreeView *tree_view) } gtk_adjustment_set_value (tree_view->priv->vadjustment, - MAX (tree_view->priv->vadjustment->value + offset, 0.0)); + MAX (gtk_adjustment_get_value (tree_view->priv->vadjustment) + offset, 0.0)); } static gboolean @@ -4180,7 +4130,7 @@ gtk_tree_view_horizontal_autoscroll (GtkTreeView *tree_view) offset = offset/3; gtk_adjustment_set_value (tree_view->priv->hadjustment, - MAX (tree_view->priv->hadjustment->value + offset, 0.0)); + MAX (gtk_adjustment_get_value (tree_view->priv->hadjustment) + offset, 0.0)); return TRUE; @@ -4528,30 +4478,31 @@ gtk_tree_view_paint_rubber_band (GtkTreeView *tree_view, cairo_t *cr) { GdkRectangle rect; - GtkStyle *style; + GtkStyleContext *context; cairo_save (cr); + context = gtk_widget_get_style_context (GTK_WIDGET (tree_view)); + + gtk_style_context_save (context); + gtk_style_context_add_class (context, GTK_STYLE_CLASS_RUBBERBAND); + rect.x = MIN (tree_view->priv->press_start_x, tree_view->priv->rubber_band_x); rect.y = MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y) - tree_view->priv->dy; rect.width = ABS (tree_view->priv->press_start_x - tree_view->priv->rubber_band_x) + 1; rect.height = ABS (tree_view->priv->press_start_y - tree_view->priv->rubber_band_y) + 1; - cairo_set_line_width (cr, 1.0); - - style = gtk_widget_get_style (GTK_WIDGET (tree_view)); - - gdk_cairo_set_source_color (cr, &style->fg[GTK_STATE_NORMAL]); - gdk_cairo_rectangle (cr, &rect); cairo_clip (cr); - cairo_paint_with_alpha (cr, 0.25); - cairo_rectangle (cr, - rect.x + 0.5, rect.y + 0.5, - rect.width - 1, rect.height - 1); - cairo_stroke (cr); + gtk_render_background (context, cr, + rect.x, rect.y, + rect.width, rect.height); + gtk_render_frame (context, cr, + rect.x, rect.y, + rect.width, rect.height); + gtk_style_context_restore (context); cairo_restore (cr); } @@ -4616,11 +4567,11 @@ gtk_tree_view_motion (GtkWidget *widget, tree_view = (GtkTreeView *) widget; /* Resizing a column */ - if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_RESIZE)) + if (tree_view->priv->in_column_resize) return gtk_tree_view_motion_resize_column (widget, event); /* Drag column */ - if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_DRAG)) + if (tree_view->priv->in_column_drag) return gtk_tree_view_motion_drag_column (widget, event); /* Sanity check it */ @@ -4664,12 +4615,20 @@ draw_empty_focus (GtkTreeView *tree_view, cairo_t *cr) h = gdk_window_get_height (tree_view->priv->bin_window) - 2; if (w > 0 && h > 0) - gtk_paint_focus (gtk_widget_get_style (widget), - cr, - gtk_widget_get_state (widget), - widget, - NULL, - 1, 1, w, h); + { + 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); + } } typedef enum { @@ -4711,9 +4670,19 @@ gtk_tree_view_draw_line (GtkTreeView *tree_view, g_assert_not_reached (); /* fall through */ case GTK_TREE_VIEW_FOREGROUND_LINE: - cairo_set_line_width (cr, 1.0); - gdk_cairo_set_source_color (cr, - >k_widget_get_style (GTK_WIDGET (tree_view))->fg[gtk_widget_get_state (GTK_WIDGET (tree_view))]); + { + GtkStyleContext *context; + GtkStateFlags state; + GdkRGBA color; + + context = gtk_widget_get_style_context (GTK_WIDGET (tree_view)); + state = gtk_widget_get_state_flags (GTK_WIDGET (tree_view)); + + cairo_set_line_width (cr, 1.0); + gtk_style_context_get_color (context, state, &color); + gdk_cairo_set_source_rgba (cr, &color); + } + break; } @@ -4770,7 +4739,6 @@ gtk_tree_view_bin_draw (GtkWidget *widget, { GtkTreeView *tree_view = GTK_TREE_VIEW (widget); GtkTreePath *path; - GtkStyle *style; GtkRBTree *tree; GList *list; GtkRBNode *node; @@ -4805,8 +4773,12 @@ gtk_tree_view_bin_draw (GtkWidget *widget, gint grid_line_width; gboolean got_pointer = FALSE; gboolean draw_vgrid_lines, draw_hgrid_lines; + GtkStyleContext *context; + GtkStateFlags state; 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, @@ -4821,8 +4793,6 @@ gtk_tree_view_bin_draw (GtkWidget *widget, return TRUE; } - style = gtk_widget_get_style (widget); - bin_window_width = gdk_window_get_width (tree_view->priv->bin_window); bin_window_height = gdk_window_get_height (tree_view->priv->bin_window); cairo_rectangle (cr, 0, 0, bin_window_width, bin_window_height); @@ -4838,15 +4808,16 @@ gtk_tree_view_bin_draw (GtkWidget *widget, if (tree_view->priv->height < bin_window_height) { - gtk_paint_flat_box (style, - cr, - gtk_widget_get_state (widget), - GTK_SHADOW_NONE, - widget, - "cell_even", - 0, tree_view->priv->height, - bin_window_width, - bin_window_height - tree_view->priv->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, + 0, tree_view->priv->height, + bin_window_width, + bin_window_height - tree_view->priv->height); + + gtk_style_context_restore (context); } if (node == NULL) @@ -4922,10 +4893,11 @@ gtk_tree_view_bin_draw (GtkWidget *widget, gboolean is_separator = FALSE; gboolean is_first = FALSE; gboolean is_last = FALSE; - + gint n_col = 0; + is_separator = row_is_separator (tree_view, &iter, NULL); - max_height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node)); + max_height = gtk_tree_view_get_row_height (tree_view, node); cell_offset = 0; highlight_x = 0; /* should match x coord of first cell */ @@ -4967,15 +4939,15 @@ gtk_tree_view_bin_draw (GtkWidget *widget, list = (rtl ? list->prev : list->next)) { GtkTreeViewColumn *column = list->data; - const gchar *detail = NULL; - gchar new_detail[128]; + GtkRegionFlags row_flags = 0, column_flags = 0; + GtkStateFlags state = 0; gint width; - GtkStateType state; gboolean draw_focus; if (!gtk_tree_view_column_get_visible (column)) continue; + n_col++; width = gtk_tree_view_column_get_width (column); if (cell_offset > clip.x + clip.width || @@ -5046,53 +5018,42 @@ gtk_tree_view_bin_draw (GtkWidget *widget, */ if (allow_rules && tree_view->priv->has_rules) { - if ((flags & GTK_CELL_RENDERER_SORTED) && - n_visible_columns >= 3) - { - if (parity) - detail = "cell_odd_ruled_sorted"; - else - detail = "cell_even_ruled_sorted"; - } + if (parity) + row_flags |= GTK_REGION_ODD; else - { - if (parity) - detail = "cell_odd_ruled"; - else - detail = "cell_even_ruled"; - } + row_flags |= GTK_REGION_EVEN; } + + if ((flags & GTK_CELL_RENDERER_SORTED) && + n_visible_columns >= 3) + column_flags |= GTK_REGION_SORTED; + + is_first = (rtl ? !list->next : !list->prev); + is_last = (rtl ? !list->prev : !list->next); + + if (is_first) + column_flags |= GTK_REGION_FIRST; + + if (is_last) + column_flags |= GTK_REGION_LAST; + + if ((n_col % 2) == 0) + column_flags |= GTK_REGION_EVEN; else - { - if ((flags & GTK_CELL_RENDERER_SORTED) && - n_visible_columns >= 3) - { - if (parity) - detail = "cell_odd_sorted"; - else - detail = "cell_even_sorted"; - } - else - { - if (parity) - detail = "cell_odd"; - else - detail = "cell_even"; - } - } + column_flags |= GTK_REGION_ODD; - g_assert (detail); + gtk_style_context_save (context); - if (gtk_widget_get_state (widget) == GTK_STATE_INSENSITIVE) - state = GTK_STATE_INSENSITIVE; - else if (flags & GTK_CELL_RENDERER_SELECTED) - state = GTK_STATE_SELECTED; - else - state = GTK_STATE_NORMAL; + state = gtk_cell_renderer_get_state (NULL, widget, flags); + gtk_style_context_set_state (context, state); + + gtk_style_context_add_class (context, GTK_STYLE_CLASS_CELL); + 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 && ((column == tree_view->priv->focus_column - && GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS) && + && tree_view->priv->draw_keyfocus && gtk_widget_has_focus (widget)) || (column == tree_view->priv->edited_column))) draw_focus = TRUE; @@ -5100,31 +5061,11 @@ gtk_tree_view_bin_draw (GtkWidget *widget, draw_focus = FALSE; /* Draw background */ - is_first = (rtl ? !list->next : !list->prev); - is_last = (rtl ? !list->prev : !list->next); - - /* (I don't like the snprintfs either, but couldn't find a - * less messy way). - */ - if (is_first && is_last) - g_snprintf (new_detail, 127, "%s", detail); - else if (is_first) - g_snprintf (new_detail, 127, "%s_start", detail); - else if (is_last) - g_snprintf (new_detail, 127, "%s_end", detail); - else - g_snprintf (new_detail, 127, "%s_middle", detail); - - gtk_paint_flat_box (style, - cr, - state, - GTK_SHADOW_NONE, - widget, - new_detail, - background_area.x, - background_area.y, - background_area.width, - background_area.height); + gtk_render_background (context, cr, + background_area.x, + background_area.y, + background_area.width, + background_area.height); if (gtk_tree_view_is_expander_column (tree_view, column)) { @@ -5132,7 +5073,7 @@ gtk_tree_view_bin_draw (GtkWidget *widget, cell_area.x += (depth - 1) * tree_view->priv->level_indentation; cell_area.width -= (depth - 1) * tree_view->priv->level_indentation; - if (TREE_VIEW_DRAW_EXPANDERS(tree_view)) + if (gtk_tree_view_draw_expanders (tree_view)) { if (!rtl) cell_area.x += depth * tree_view->priv->expander_size; @@ -5147,12 +5088,9 @@ gtk_tree_view_bin_draw (GtkWidget *widget, expander_cell_width = cell_area.width; if (is_separator) - gtk_paint_hline (style, - cr, - state, - widget, - NULL, - cell_area.x, + gtk_render_line (context, cr, + cell_area.x, + cell_area.y + cell_area.height / 2, cell_area.x + cell_area.width, cell_area.y + cell_area.height / 2); else @@ -5162,7 +5100,7 @@ gtk_tree_view_bin_draw (GtkWidget *widget, &cell_area, flags, draw_focus); - if (TREE_VIEW_DRAW_EXPANDERS(tree_view) + if (gtk_tree_view_draw_expanders (tree_view) && (node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT) { if (!got_pointer) @@ -5182,12 +5120,9 @@ gtk_tree_view_bin_draw (GtkWidget *widget, else { if (is_separator) - gtk_paint_hline (style, - cr, - state, - widget, - NULL, + gtk_render_line (context, cr, cell_area.x, + cell_area.y + cell_area.height / 2, cell_area.x + cell_area.width, cell_area.y + cell_area.height / 2); else @@ -5288,6 +5223,7 @@ gtk_tree_view_bin_draw (GtkWidget *widget, } } + gtk_style_context_restore (context); cell_offset += gtk_tree_view_column_get_width (column); } @@ -5318,17 +5254,11 @@ gtk_tree_view_bin_draw (GtkWidget *widget, if (tree == NULL) break; - gtk_paint_focus (style, - cr, - gtk_widget_get_state (widget), - widget, - (is_first - ? (is_last ? "treeview-drop-indicator" : "treeview-drop-indicator-left" ) - : (is_last ? "treeview-drop-indicator-right" : "tree-view-drop-indicator-middle" )), - 0, BACKGROUND_FIRST_PIXEL (tree_view, tree, node) + 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), - ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node)) + gtk_tree_view_get_row_height (tree_view, node) - focus_line_width + 1); break; } @@ -5346,39 +5276,34 @@ gtk_tree_view_bin_draw (GtkWidget *widget, /* draw the big row-spanning focus rectangle, if needed */ if (!has_can_focus_cell && node == cursor && - GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS) && + tree_view->priv->draw_keyfocus && gtk_widget_has_focus (widget)) { gint tmp_y, tmp_height; - GtkStateType focus_rect_state; + GtkStateFlags focus_rect_state = 0; - focus_rect_state = - flags & GTK_CELL_RENDERER_SELECTED ? GTK_STATE_SELECTED : - (flags & GTK_CELL_RENDERER_PRELIT ? GTK_STATE_PRELIGHT : - (flags & GTK_CELL_RENDERER_INSENSITIVE ? GTK_STATE_INSENSITIVE : - GTK_STATE_NORMAL)); + gtk_style_context_save (context); + + focus_rect_state = gtk_cell_renderer_get_state (NULL, widget, flags); + gtk_style_context_set_state (context, focus_rect_state); if (draw_hgrid_lines) { - tmp_y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node) + grid_line_width / 2; - tmp_height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node)) - grid_line_width; + tmp_y = gtk_tree_view_get_row_y_offset (tree_view, tree, node) + grid_line_width / 2; + tmp_height = gtk_tree_view_get_row_height (tree_view, node) - grid_line_width; } else { - tmp_y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node); - tmp_height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node)); + tmp_y = gtk_tree_view_get_row_y_offset (tree_view, tree, node); + tmp_height = gtk_tree_view_get_row_height (tree_view, node); } - gtk_paint_focus (style, - cr, - focus_rect_state, - widget, - (is_first - ? (is_last ? "treeview" : "treeview-left" ) - : (is_last ? "treeview-right" : "treeview-middle" )), - 0, tmp_y, - gdk_window_get_width (tree_view->priv->bin_window), - tmp_height); + gtk_render_focus (context, cr, + 0, tmp_y, + gdk_window_get_width (tree_view->priv->bin_window), + tmp_height); + + gtk_style_context_restore (context); } y_offset += max_height; @@ -5465,14 +5390,21 @@ gtk_tree_view_draw (GtkWidget *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 @@ -5749,7 +5681,7 @@ gtk_tree_view_key_press (GtkWidget *widget, return TRUE; } - if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_DRAG)) + if (tree_view->priv->in_column_drag) { if (event->keyval == GDK_KEY_Escape) { @@ -5759,7 +5691,7 @@ gtk_tree_view_key_press (GtkWidget *widget, return TRUE; } - if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE)) + if (tree_view->priv->headers_visible) { GList *focus_column; gboolean rtl; @@ -6103,7 +6035,7 @@ gtk_tree_view_node_queue_redraw (GtkTreeView *tree_view, gint y; y = _gtk_rbtree_node_find_offset (tree, node) - - tree_view->priv->vadjustment->value + - gtk_adjustment_get_value (tree_view->priv->vadjustment) + gtk_tree_view_get_effective_header_height (tree_view); gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation); @@ -6122,11 +6054,11 @@ node_is_visible (GtkTreeView *tree_view, int height; y = _gtk_rbtree_node_find_offset (tree, node); - height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node)); + height = gtk_tree_view_get_row_height (tree_view, node); - if (y >= tree_view->priv->vadjustment->value && - y + height <= (tree_view->priv->vadjustment->value - + tree_view->priv->vadjustment->page_size)) + if (y >= gtk_adjustment_get_value (tree_view->priv->vadjustment) && + y + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment) + + gtk_adjustment_get_page_size (tree_view->priv->vadjustment))) return TRUE; return FALSE; @@ -6192,8 +6124,10 @@ validate_row (GtkTreeView *tree_view, for (list = tree_view->priv->columns; list; list = list->next) { - gint tmp_width; - gint tmp_height; + gint padding = 0; + gint original_width; + gint new_width; + gint row_height; column = list->data; @@ -6204,17 +6138,19 @@ validate_row (GtkTreeView *tree_view, !_gtk_tree_view_column_cell_get_dirty (column)) continue; + original_width = _gtk_tree_view_column_get_requested_width (column); + gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, iter, GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT), node->children?TRUE:FALSE); gtk_tree_view_column_cell_get_size (column, NULL, NULL, NULL, - &tmp_width, &tmp_height); + NULL, &row_height); if (!is_separator) { - tmp_height += vertical_separator; - height = MAX (height, tmp_height); + row_height += vertical_separator; + height = MAX (height, row_height); height = MAX (height, tree_view->priv->expander_size); } else @@ -6227,27 +6163,28 @@ validate_row (GtkTreeView *tree_view, if (gtk_tree_view_is_expander_column (tree_view, column)) { - tmp_width = tmp_width + horizontal_separator + (depth - 1) * tree_view->priv->level_indentation; + padding += horizontal_separator + (depth - 1) * tree_view->priv->level_indentation; - if (TREE_VIEW_DRAW_EXPANDERS (tree_view)) - tmp_width += depth * tree_view->priv->expander_size; + if (gtk_tree_view_draw_expanders (tree_view)) + padding += depth * tree_view->priv->expander_size; } else - tmp_width = tmp_width + horizontal_separator; + padding += horizontal_separator; if (draw_vgrid_lines) { if (list->data == first_column || list->data == last_column) - tmp_width += grid_line_width / 2.0; + padding += grid_line_width / 2.0; else - tmp_width += grid_line_width; + padding += grid_line_width; } - if (tmp_width > _gtk_tree_view_column_get_requested_width (column)) - { - retval = TRUE; - _gtk_tree_view_column_set_requested_width (column, tmp_width); - } + /* Update the padding for the column */ + _gtk_tree_view_column_push_padding (column, padding); + new_width = _gtk_tree_view_column_get_requested_width (column); + + if (new_width > original_width) + retval = TRUE; } if (draw_hgrid_lines) @@ -6312,7 +6249,7 @@ validate_visible_area (GtkTreeView *tree_view) if (tree_view->priv->scroll_to_use_align) { - gint height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node)); + gint height = gtk_tree_view_get_row_height (tree_view, node); area_above = (total_height - height) * tree_view->priv->scroll_to_row_align; area_below = total_height - area_above - height; @@ -6326,43 +6263,43 @@ validate_visible_area (GtkTreeView *tree_view) * 2) row visible */ gint dy; - gint height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node)); + gint height = gtk_tree_view_get_row_height (tree_view, node); dy = _gtk_rbtree_node_find_offset (tree, node); - if (dy >= tree_view->priv->vadjustment->value && - dy + height <= (tree_view->priv->vadjustment->value - + tree_view->priv->vadjustment->page_size)) + if (dy >= gtk_adjustment_get_value (tree_view->priv->vadjustment) && + dy + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment) + + gtk_adjustment_get_page_size (tree_view->priv->vadjustment))) { /* row visible: keep the row at the same position */ - area_above = dy - tree_view->priv->vadjustment->value; - area_below = (tree_view->priv->vadjustment->value + - tree_view->priv->vadjustment->page_size) + area_above = dy - gtk_adjustment_get_value (tree_view->priv->vadjustment); + area_below = (gtk_adjustment_get_value (tree_view->priv->vadjustment) + + gtk_adjustment_get_page_size (tree_view->priv->vadjustment)) - dy - height; } else { /* row not visible */ if (dy >= 0 - && dy + height <= tree_view->priv->vadjustment->page_size) + && dy + height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment)) { /* row at the beginning -- fixed */ area_above = dy; - area_below = tree_view->priv->vadjustment->page_size + area_below = gtk_adjustment_get_page_size (tree_view->priv->vadjustment) - area_above - height; } - else if (dy >= (tree_view->priv->vadjustment->upper - - tree_view->priv->vadjustment->page_size)) + else if (dy >= (gtk_adjustment_get_upper (tree_view->priv->vadjustment) - + gtk_adjustment_get_page_size (tree_view->priv->vadjustment))) { /* row at the end -- fixed */ - area_above = dy - (tree_view->priv->vadjustment->upper - - tree_view->priv->vadjustment->page_size); - area_below = tree_view->priv->vadjustment->page_size - + area_above = dy - (gtk_adjustment_get_upper (tree_view->priv->vadjustment) - + gtk_adjustment_get_page_size (tree_view->priv->vadjustment)); + area_below = gtk_adjustment_get_page_size (tree_view->priv->vadjustment) - area_above - height; if (area_below < 0) { - area_above = tree_view->priv->vadjustment->page_size - height; + area_above = gtk_adjustment_get_page_size (tree_view->priv->vadjustment) - height; area_below = 0; } } @@ -6423,7 +6360,7 @@ validate_visible_area (GtkTreeView *tree_view) size_changed = TRUE; } area_above = 0; - area_below = total_height - ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node)); + area_below = total_height - gtk_tree_view_get_row_height (tree_view, node); } above_path = gtk_tree_path_copy (path); @@ -6534,7 +6471,7 @@ validate_visible_area (GtkTreeView *tree_view) size_changed = TRUE; } - area_below -= ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node)); + area_below -= gtk_tree_view_get_row_height (tree_view, node); } gtk_tree_path_free (path); @@ -6574,7 +6511,7 @@ validate_visible_area (GtkTreeView *tree_view) if (validate_row (tree_view, tree, node, &iter, above_path)) size_changed = TRUE; } - area_above -= ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node)); + area_above -= gtk_tree_view_get_row_height (tree_view, node); } /* if we scrolled to a path, we need to set the dy here, @@ -6587,7 +6524,7 @@ validate_visible_area (GtkTreeView *tree_view) need_redraw = TRUE; } - else if (tree_view->priv->height <= tree_view->priv->vadjustment->page_size) + else if (tree_view->priv->height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment)) { /* when we are not scrolling, we should never set dy to something * else than zero. we update top_row to be in sync with dy = 0. @@ -6595,9 +6532,9 @@ validate_visible_area (GtkTreeView *tree_view) gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0); gtk_tree_view_dy_to_top_row (tree_view); } - else if (tree_view->priv->vadjustment->value + tree_view->priv->vadjustment->page_size > tree_view->priv->height) + else if (gtk_adjustment_get_value (tree_view->priv->vadjustment) + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) > tree_view->priv->height) { - gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), tree_view->priv->height - tree_view->priv->vadjustment->page_size); + gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), tree_view->priv->height - gtk_adjustment_get_page_size (tree_view->priv->vadjustment)); gtk_tree_view_dy_to_top_row (tree_view); } else @@ -6614,10 +6551,10 @@ validate_visible_area (GtkTreeView *tree_view) gtk_widget_get_preferred_size (GTK_WIDGET (tree_view), &requisition, NULL); - tree_view->priv->hadjustment->upper = MAX (tree_view->priv->hadjustment->upper, (gfloat)requisition.width); - tree_view->priv->vadjustment->upper = MAX (tree_view->priv->vadjustment->upper, (gfloat)requisition.height); - gtk_adjustment_changed (tree_view->priv->hadjustment); - gtk_adjustment_changed (tree_view->priv->vadjustment); + gtk_adjustment_set_upper (tree_view->priv->hadjustment, + MAX (gtk_adjustment_get_upper (tree_view->priv->hadjustment), requisition.width)); + gtk_adjustment_set_upper (tree_view->priv->vadjustment, + MAX (gtk_adjustment_get_upper (tree_view->priv->vadjustment), requisition.height)); gtk_widget_queue_resize (GTK_WIDGET (tree_view)); } @@ -6662,7 +6599,7 @@ initialize_fixed_height_mode (GtkTreeView *tree_view) gtk_tree_path_free (path); - tree_view->priv->fixed_height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node)); + tree_view->priv->fixed_height = gtk_tree_view_get_row_height (tree_view, node); } _gtk_rbtree_set_fixed_height (tree_view->priv->tree, @@ -6774,7 +6711,7 @@ do_validate_rows (GtkTreeView *tree_view, gboolean queue_resize) { gint height; - height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node)); + height = gtk_tree_view_get_row_height (tree_view, node); if (prev_height < 0) prev_height = height; else if (prev_height != height) @@ -6812,12 +6749,12 @@ 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); + gtk_tree_view_size_request (GTK_WIDGET (tree_view), &requisition, FALSE); - tree_view->priv->hadjustment->upper = MAX (tree_view->priv->hadjustment->upper, (gfloat)requisition.width); - tree_view->priv->vadjustment->upper = MAX (tree_view->priv->vadjustment->upper, (gfloat)requisition.height); - gtk_adjustment_changed (tree_view->priv->hadjustment); - gtk_adjustment_changed (tree_view->priv->vadjustment); + gtk_adjustment_set_upper (tree_view->priv->hadjustment, + MAX (gtk_adjustment_get_upper (tree_view->priv->hadjustment), requisition.width)); + gtk_adjustment_set_upper (tree_view->priv->vadjustment, + MAX (gtk_adjustment_get_upper (tree_view->priv->vadjustment), requisition.height)); if (queue_resize) gtk_widget_queue_resize (GTK_WIDGET (tree_view)); @@ -6879,10 +6816,10 @@ do_presize_handler (GtkTreeView *tree_view) gtk_widget_get_preferred_size (GTK_WIDGET (tree_view), &requisition, NULL); - tree_view->priv->hadjustment->upper = MAX (tree_view->priv->hadjustment->upper, (gfloat)requisition.width); - tree_view->priv->vadjustment->upper = MAX (tree_view->priv->vadjustment->upper, (gfloat)requisition.height); - gtk_adjustment_changed (tree_view->priv->hadjustment); - gtk_adjustment_changed (tree_view->priv->vadjustment); + gtk_adjustment_set_upper (tree_view->priv->hadjustment, + MAX (gtk_adjustment_get_upper (tree_view->priv->hadjustment), requisition.width)); + gtk_adjustment_set_upper (tree_view->priv->vadjustment, + MAX (gtk_adjustment_get_upper (tree_view->priv->vadjustment), requisition.height)); gtk_widget_queue_resize (GTK_WIDGET (tree_view)); } @@ -6933,7 +6870,7 @@ gtk_tree_view_bin_process_updates (GtkTreeView *tree_view) static gboolean scroll_sync_handler (GtkTreeView *tree_view) { - if (tree_view->priv->height <= tree_view->priv->vadjustment->page_size) + if (tree_view->priv->height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment)) gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0); else if (gtk_tree_row_reference_valid (tree_view->priv->top_row)) gtk_tree_view_top_row_to_dy (tree_view); @@ -7047,7 +6984,7 @@ gtk_tree_view_top_row_to_dy (GtkTreeView *tree_view) return; } - if (ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node)) + if (gtk_tree_view_get_row_height (tree_view, node) < tree_view->priv->top_row_dy) { /* new top row -- do NOT install the idle handler */ @@ -7058,8 +6995,8 @@ gtk_tree_view_top_row_to_dy (GtkTreeView *tree_view) new_dy = _gtk_rbtree_node_find_offset (tree, node); new_dy += tree_view->priv->top_row_dy; - if (new_dy + tree_view->priv->vadjustment->page_size > tree_view->priv->height) - new_dy = tree_view->priv->height - tree_view->priv->vadjustment->page_size; + if (new_dy + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) > tree_view->priv->height) + new_dy = tree_view->priv->height - gtk_adjustment_get_page_size (tree_view->priv->vadjustment); new_dy = MAX (0, new_dy); @@ -7523,7 +7460,7 @@ out: { GtkWidget *source_widget; - *suggested_action = context->suggested_action; + *suggested_action = gdk_drag_context_get_suggested_action (context); source_widget = gtk_drag_get_source_widget (context); if (source_widget == widget) @@ -7531,7 +7468,7 @@ out: /* Default to MOVE, unless the user has * pressed ctrl or shift to affect available actions */ - if ((context->actions & GDK_ACTION_MOVE) != 0) + if ((gdk_drag_context_get_actions (context) & GDK_ACTION_MOVE) != 0) *suggested_action = GDK_ACTION_MOVE; } @@ -7763,7 +7700,7 @@ gtk_tree_view_drag_data_get (GtkWidget *widget, goto done; /* If drag_data_get does nothing, try providing row data. */ - if (selection_data->target == gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW")) + if (gtk_selection_data_get_target (selection_data) == gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW")) { gtk_tree_set_row_drag_data (selection_data, model, @@ -8043,7 +7980,7 @@ gtk_tree_view_drag_data_received (GtkWidget *widget, if (dest_row == NULL) return; - if (selection_data->length >= 0) + if (gtk_selection_data_get_length (selection_data) >= 0) { if (path_down_mode) { @@ -8054,7 +7991,7 @@ gtk_tree_view_drag_data_received (GtkWidget *widget, } } - if (selection_data->length >= 0) + if (gtk_selection_data_get_length (selection_data) >= 0) { if (gtk_tree_drag_dest_drag_data_received (GTK_TREE_DRAG_DEST (model), dest_row, @@ -8064,7 +8001,7 @@ gtk_tree_view_drag_data_received (GtkWidget *widget, gtk_drag_finish (context, accepted, - (context->action == GDK_ACTION_MOVE), + (gdk_drag_context_get_selected_action (context) == GDK_ACTION_MOVE), time); if (gtk_tree_path_get_depth (dest_row) == 1 @@ -8286,7 +8223,7 @@ gtk_tree_view_header_focus (GtkTreeView *tree_view, GList *tmp_list; gboolean rtl; - if (! GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE)) + if (! tree_view->priv->headers_visible) return FALSE; focus_child = gtk_container_get_focus_child (GTK_CONTAINER (tree_view)); @@ -8547,20 +8484,24 @@ gtk_tree_view_grab_focus (GtkWidget *widget) } static void -gtk_tree_view_style_set (GtkWidget *widget, - GtkStyle *previous_style) +gtk_tree_view_style_updated (GtkWidget *widget) { GtkTreeView *tree_view = GTK_TREE_VIEW (widget); - GtkStyle *style; GList *list; GtkTreeViewColumn *column; if (gtk_widget_get_realized (widget)) { - style = gtk_widget_get_style (widget); - gdk_window_set_background (tree_view->priv->bin_window, - &style->base[gtk_widget_get_state (widget)]); - gtk_style_set_background (style, tree_view->priv->header_window, GTK_STATE_NORMAL); + GtkStyleContext *context; + + context = gtk_widget_get_style_context (widget); + + gtk_style_context_save (context); + gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW); + gtk_style_context_set_background (context, tree_view->priv->bin_window); + gtk_style_context_restore (context); + + gtk_style_context_set_background (context, tree_view->priv->header_window); gtk_tree_view_set_grid_lines (tree_view, tree_view->priv->grid_lines); gtk_tree_view_set_enable_tree_lines (tree_view, tree_view->priv->tree_lines_enabled); @@ -8603,6 +8544,54 @@ gtk_tree_view_set_focus_child (GtkContainer *container, GTK_CONTAINER_CLASS (gtk_tree_view_parent_class)->set_focus_child (container, child); } +static GtkWidgetPath * +gtk_tree_view_get_path_for_child (GtkContainer *container, + GtkWidget *child) +{ + GtkTreeView *tree_view = GTK_TREE_VIEW (container); + GtkWidgetPath *path; + gboolean rtl; + GList *list; + 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)) + { + GtkTreeViewColumn *column = list->data; + GtkRegionFlags flags = 0; + + if (!gtk_tree_view_column_get_visible (column)) + continue; + + n_col++; + + if (gtk_tree_view_column_get_widget (column) != child && + gtk_tree_view_column_get_button (column) != child) + continue; + + if ((n_col % 2) == 0) + flags |= GTK_REGION_EVEN; + else + flags |= GTK_REGION_ODD; + + if (n_col == 1) + flags |= GTK_REGION_FIRST; + + if ((rtl && !list->prev) || + (!rtl && !list->next)) + flags |= GTK_REGION_LAST; + + gtk_widget_path_iter_add_region (path, -1, GTK_STYLE_REGION_COLUMN_HEADER, flags); + break; + } + + return path; +} + static gboolean gtk_tree_view_real_move_cursor (GtkTreeView *tree_view, GtkMovementStep step, @@ -8623,7 +8612,7 @@ gtk_tree_view_real_move_cursor (GtkTreeView *tree_view, return FALSE; gtk_tree_view_stop_editing (tree_view, FALSE); - GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS); + tree_view->priv->draw_keyfocus = TRUE; gtk_widget_grab_focus (GTK_WIDGET (tree_view)); if (gtk_get_current_event_state (&state)) @@ -8971,10 +8960,10 @@ gtk_tree_view_row_has_child_toggled (GtkTreeModel *model, else GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_PARENT); - if (has_child && GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IS_LIST)) + if (has_child && tree_view->priv->is_list) { - GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_IS_LIST); - if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_SHOW_EXPANDERS)) + tree_view->priv->is_list = FALSE; + if (tree_view->priv->show_expanders) { GList *list; @@ -9030,6 +9019,7 @@ gtk_tree_view_row_deleted (GtkTreeModel *model, GtkRBNode *node; GList *list; gint selection_changed = FALSE; + GtkStyleContext *context; g_return_if_fail (path != NULL); @@ -9056,9 +9046,6 @@ gtk_tree_view_row_deleted (GtkTreeModel *model, /* Cancel editting if we've started */ gtk_tree_view_stop_editing (tree_view, TRUE); - /* If we have a node expanded/collapsed timeout, remove it */ - remove_expand_collapse_timeout (tree_view); - if (tree_view->priv->destroy_count_func) { gint child_count = 0; @@ -9085,6 +9072,10 @@ 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)); @@ -9136,9 +9127,6 @@ gtk_tree_view_rows_reordered (GtkTreeModel *model, /* we need to be unprelighted */ ensure_unprelighted (tree_view); - /* clear the timeout */ - cancel_arrow_animation (tree_view); - _gtk_rbtree_reorder (tree, new_order, len); gtk_widget_queue_draw (GTK_WIDGET (tree_view)); @@ -9269,7 +9257,6 @@ gtk_tree_view_build_tree (GtkTreeView *tree_view, { GtkRBNode *temp = NULL; GtkTreePath *path = NULL; - gboolean is_list = GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IS_LIST); do { @@ -9285,7 +9272,7 @@ gtk_tree_view_build_tree (GtkTreeView *tree_view, } } - if (is_list) + if (tree_view->priv->is_list) continue; if (recurse) @@ -9340,11 +9327,11 @@ gtk_tree_view_clamp_node_visible (GtkTreeView *tree_view, /* just return if the node is visible, avoiding a costly expose */ node_dy = _gtk_rbtree_node_find_offset (tree, node); - height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node)); + height = gtk_tree_view_get_row_height (tree_view, node); if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) - && node_dy >= tree_view->priv->vadjustment->value - && node_dy + height <= (tree_view->priv->vadjustment->value - + tree_view->priv->vadjustment->page_size)) + && node_dy >= gtk_adjustment_get_value (tree_view->priv->vadjustment) + && node_dy + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment) + + gtk_adjustment_get_page_size (tree_view->priv->vadjustment))) return; path = _gtk_tree_view_find_path (tree_view, tree, node); @@ -9374,7 +9361,7 @@ gtk_tree_view_clamp_column_visible (GtkTreeView *tree_view, x = allocation.x; width = allocation.width; - if (width > tree_view->priv->hadjustment->page_size) + if (width > gtk_adjustment_get_page_size (tree_view->priv->hadjustment)) { /* The column is larger than the horizontal page size. If the * column has cells which can be focussed individually, then we make @@ -9382,51 +9369,40 @@ gtk_tree_view_clamp_column_visible (GtkTreeView *tree_view, * focus cell is bigger than the page size, we make sure the * left-hand side of the cell is visible). * - * If the column does not have those so-called special cells, we + * If the column does not have an activatable cell, we * make sure the left-hand side of the column is visible. */ if (focus_to_cell && gtk_tree_view_has_can_focus_cell (tree_view)) { - GtkTreePath *cursor_path; - GdkRectangle background_area, cell_area, focus_area; - - cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor); - - gtk_tree_view_get_cell_area (tree_view, - cursor_path, column, &cell_area); - gtk_tree_view_get_background_area (tree_view, - cursor_path, column, - &background_area); - - gtk_tree_path_free (cursor_path); - - _gtk_tree_view_column_get_focus_area (column, - &background_area, - &cell_area, - &focus_area); + GtkCellArea *cell_area; + GtkCellRenderer *focus_cell; - x = focus_area.x; - width = focus_area.width; + cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column)); + focus_cell = gtk_cell_area_get_focus_cell (cell_area); - if (width < tree_view->priv->hadjustment->page_size) - { - if ((tree_view->priv->hadjustment->value + tree_view->priv->hadjustment->page_size) < (x + width)) - gtk_adjustment_set_value (tree_view->priv->hadjustment, - x + width - tree_view->priv->hadjustment->page_size); - else if (tree_view->priv->hadjustment->value > x) - gtk_adjustment_set_value (tree_view->priv->hadjustment, x); - } - } + if (gtk_tree_view_column_cell_get_position (column, focus_cell, + &x, &width)) + { + if (width < gtk_adjustment_get_page_size (tree_view->priv->hadjustment)) + { + if (gtk_adjustment_get_value (tree_view->priv->hadjustment) + gtk_adjustment_get_page_size (tree_view->priv->hadjustment) < x + width) + gtk_adjustment_set_value (tree_view->priv->hadjustment, + x + width - gtk_adjustment_get_page_size (tree_view->priv->hadjustment)); + else if (gtk_adjustment_get_value (tree_view->priv->hadjustment) > x) + gtk_adjustment_set_value (tree_view->priv->hadjustment, x); + } + } + } gtk_adjustment_set_value (tree_view->priv->hadjustment, x); } else { - if ((tree_view->priv->hadjustment->value + tree_view->priv->hadjustment->page_size) < (x + width)) + if ((gtk_adjustment_get_value (tree_view->priv->hadjustment) + gtk_adjustment_get_page_size (tree_view->priv->hadjustment)) < (x + width)) gtk_adjustment_set_value (tree_view->priv->hadjustment, - x + width - tree_view->priv->hadjustment->page_size); - else if (tree_view->priv->hadjustment->value > x) + x + width - gtk_adjustment_get_page_size (tree_view->priv->hadjustment)); + else if (gtk_adjustment_get_value (tree_view->priv->hadjustment) > x) gtk_adjustment_set_value (tree_view->priv->hadjustment, x); } } @@ -9526,7 +9502,7 @@ gtk_tree_view_is_expander_column (GtkTreeView *tree_view, { GList *list; - if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IS_LIST)) + if (tree_view->priv->is_list) return FALSE; if (tree_view->priv->expander_column != NULL) @@ -9548,6 +9524,15 @@ gtk_tree_view_is_expander_column (GtkTreeView *tree_view, return FALSE; } +static inline gboolean +gtk_tree_view_draw_expanders (GtkTreeView *tree_view) +{ + if (!tree_view->priv->is_list && tree_view->priv->show_expanders) + return TRUE; + /* else */ + return FALSE; +} + static void gtk_tree_view_add_move_binding (GtkBindingSet *binding_set, guint keyval, @@ -9763,8 +9748,8 @@ _gtk_tree_view_column_start_drag (GtkTreeView *tree_view, GtkAllocation allocation; GtkAllocation button_allocation; GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (tree_view)); - GdkDisplay *display = gdk_screen_get_display (screen); GtkWidget *button; + GdkDevice *pointer, *keyboard; g_return_if_fail (tree_view->priv->column_drag_info == NULL); g_return_if_fail (tree_view->priv->cur_reorder == NULL); @@ -9794,13 +9779,24 @@ _gtk_tree_view_column_start_drag (GtkTreeView *tree_view, 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); + &attributes, + attributes_mask); gdk_window_set_user_data (tree_view->priv->drag_window, GTK_WIDGET (tree_view)); } - gdk_display_pointer_ungrab (display, GDK_CURRENT_TIME); - gdk_display_keyboard_ungrab (display, GDK_CURRENT_TIME); + if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD) + { + keyboard = device; + pointer = gdk_device_get_associated_device (device); + } + else + { + pointer = device; + keyboard = gdk_device_get_associated_device (device); + } + + gdk_device_ungrab (pointer, GDK_CURRENT_TIME); + gdk_device_ungrab (keyboard, GDK_CURRENT_TIME); gtk_grab_remove (button); @@ -9852,14 +9848,22 @@ _gtk_tree_view_column_start_drag (GtkTreeView *tree_view, while (gtk_events_pending ()) gtk_main_iteration (); - GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_IN_COLUMN_DRAG); - gdk_pointer_grab (tree_view->priv->drag_window, - FALSE, - GDK_POINTER_MOTION_MASK|GDK_BUTTON_RELEASE_MASK, - NULL, NULL, GDK_CURRENT_TIME); - gdk_keyboard_grab (tree_view->priv->drag_window, - FALSE, - GDK_CURRENT_TIME); + tree_view->priv->in_column_drag = TRUE; + + gdk_device_grab (pointer, + tree_view->priv->drag_window, + GDK_OWNERSHIP_NONE, + FALSE, + GDK_POINTER_MOTION_MASK|GDK_BUTTON_RELEASE_MASK, + NULL, + GDK_CURRENT_TIME); + gdk_device_grab (keyboard, + tree_view->priv->drag_window, + GDK_OWNERSHIP_NONE, + FALSE, + GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK, + NULL, + GDK_CURRENT_TIME); } static void @@ -9877,8 +9881,8 @@ gtk_tree_view_queue_draw_arrow (GtkTreeView *tree_view, rect.x = 0; rect.width = MAX (tree_view->priv->expander_size, MAX (tree_view->priv->width, allocation.width)); - rect.y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node); - rect.height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node)); + rect.y = gtk_tree_view_get_row_y_offset (tree_view, tree, node); + rect.height = gtk_tree_view_get_row_height (tree_view, node); gdk_window_invalidate_rect (tree_view->priv->bin_window, &rect, TRUE); } @@ -9899,8 +9903,8 @@ _gtk_tree_view_queue_draw_node (GtkTreeView *tree_view, rect.x = 0; rect.width = MAX (tree_view->priv->width, allocation.width); - rect.y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node); - rect.height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node)); + rect.y = gtk_tree_view_get_row_y_offset (tree_view, tree, node); + rect.height = gtk_tree_view_get_row_height (tree_view, node); if (clip_rect) { @@ -9919,7 +9923,7 @@ _gtk_tree_view_queue_draw_node (GtkTreeView *tree_view, static inline gint gtk_tree_view_get_effective_header_height (GtkTreeView *tree_view) { - if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE)) + if (tree_view->priv->headers_visible) return tree_view->priv->header_height; /* else */ return 0; @@ -9971,12 +9975,6 @@ _gtk_tree_view_get_rbtree (GtkTreeView *tree_view) return tree_view->priv->tree; } -GtkTreeViewColumn * -_gtk_tree_view_get_focus_column (GtkTreeView *tree_view) -{ - return tree_view->priv->focus_column; -} - GdkWindow * _gtk_tree_view_get_header_window (GtkTreeView *tree_view) { @@ -10017,15 +10015,16 @@ gtk_tree_view_draw_arrow (GtkTreeView *tree_view, gint y) { GdkRectangle area; - GtkStateType state; + GtkStateFlags state = 0; + GtkStyleContext *context; GtkWidget *widget; gint x_offset = 0; gint x2; gint vertical_separator; gint expander_size; - GtkExpanderStyle expander_style; widget = GTK_WIDGET (tree_view); + context = gtk_widget_get_style_context (widget); gtk_widget_style_get (widget, "vertical-separator", &vertical_separator, @@ -10038,48 +10037,42 @@ gtk_tree_view_draw_arrow (GtkTreeView *tree_view, gtk_tree_view_get_arrow_xrange (tree_view, tree, &x_offset, &x2); area.x = x_offset; - area.y = CELL_FIRST_PIXEL (tree_view, tree, node, vertical_separator); + area.y = gtk_tree_view_get_cell_area_y_offset (tree_view, tree, node, + vertical_separator); area.width = expander_size + 2; - area.height = MAX (CELL_HEIGHT (node, vertical_separator), (expander_size - vertical_separator)); + area.height = gtk_tree_view_get_cell_area_height (tree_view, node, + vertical_separator); - if (gtk_widget_get_state (widget) == GTK_STATE_INSENSITIVE) - { - state = GTK_STATE_INSENSITIVE; - } - else if (node == tree_view->priv->button_pressed_node) - { - if (x >= area.x && x <= (area.x + area.width) && - y >= area.y && y <= (area.y + area.height)) - state = GTK_STATE_ACTIVE; - else - state = GTK_STATE_NORMAL; - } + if (!gtk_widget_get_sensitive (widget)) + state |= GTK_STATE_FLAG_INSENSITIVE; else { + if (node == tree_view->priv->button_pressed_node && + x >= area.x && x <= (area.x + area.width) && + y >= area.y && y <= (area.y + area.height)) + state |= GTK_STATE_FLAG_SELECTED; + if (node == tree_view->priv->prelight_node && - GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_ARROW_PRELIT)) - state = GTK_STATE_PRELIGHT; - else - state = GTK_STATE_NORMAL; + tree_view->priv->arrow_prelit) + state |= GTK_STATE_FLAG_PRELIGHT; } - if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_EXPANDED)) - expander_style = GTK_EXPANDER_SEMI_EXPANDED; - else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_COLLAPSED)) - expander_style = GTK_EXPANDER_SEMI_COLLAPSED; - else if (node->children != NULL) - expander_style = GTK_EXPANDER_EXPANDED; - else - expander_style = GTK_EXPANDER_COLLAPSED; + if (node->children != NULL) + state |= GTK_STATE_FLAG_ACTIVE; - gtk_paint_expander (gtk_widget_get_style (widget), - cr, - state, - widget, - "treeview", - area.x + area.width / 2, - area.y + area.height / 2, - expander_style); + 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); } static void @@ -10126,7 +10119,7 @@ gtk_tree_view_focus_to_cursor (GtkTreeView *tree_view) if (cursor_path) { - if (tree_view->priv->selection->type == GTK_SELECTION_MULTIPLE) + 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); else gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE); @@ -10135,7 +10128,7 @@ gtk_tree_view_focus_to_cursor (GtkTreeView *tree_view) if (cursor_path) { - GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS); + tree_view->priv->draw_keyfocus = TRUE; gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL); gtk_tree_path_free (cursor_path); @@ -10147,7 +10140,22 @@ gtk_tree_view_focus_to_cursor (GtkTreeView *tree_view) { if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data))) { + GtkCellArea *cell_area; + tree_view->priv->focus_column = 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 */ + cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->focus_column)); + if (!gtk_cell_area_get_focus_cell (cell_area)) + { + gboolean rtl; + + rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL); + gtk_cell_area_focus (cell_area, + rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT); + } + break; } } @@ -10167,6 +10175,10 @@ gtk_tree_view_move_cursor_up_down (GtkTreeView *tree_view, GtkTreePath *cursor_path = NULL; gboolean grab_focus = TRUE; gboolean selectable; + GtkDirectionType direction; + GtkCellArea *cell_area = NULL; + GtkCellRenderer *last_focus_cell = NULL; + GtkTreeIter iter; if (! gtk_widget_has_focus (GTK_WIDGET (tree_view))) return; @@ -10184,13 +10196,37 @@ gtk_tree_view_move_cursor_up_down (GtkTreeView *tree_view, /* FIXME: we lost the cursor; should we get the first? */ return; + direction = count < 0 ? GTK_DIR_UP : GTK_DIR_DOWN; + + if (tree_view->priv->focus_column) + cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->focus_column)); + + /* If focus stays in the area for this row, then just return for this round */ + if (cell_area && (count == -1 || count == 1) && + gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path)) + { + 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); + + /* Save the last cell that had focus, if we hit the end of the view we'll give + * focus back to it. */ + last_focus_cell = gtk_cell_area_get_focus_cell (cell_area); + + /* If focus stays in the area, no need to change the cursor row */ + if (gtk_cell_area_focus (cell_area, direction)) + return; + } + 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, cursor_path); if (selection_count == 0 - && tree_view->priv->selection->type != GTK_SELECTION_NONE + && gtk_tree_selection_get_mode (tree_view->priv->selection) != GTK_SELECTION_NONE && !tree_view->priv->ctrl_pressed && selectable) { @@ -10228,7 +10264,7 @@ gtk_tree_view_move_cursor_up_down (GtkTreeView *tree_view, * If the list has only one item and multi-selection is set then select * the row (if not yet selected). */ - if (tree_view->priv->selection->type == GTK_SELECTION_MULTIPLE && + if (gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE && new_cursor_node == NULL) { if (count == -1) @@ -10255,6 +10291,10 @@ gtk_tree_view_move_cursor_up_down (GtkTreeView *tree_view, 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); gtk_tree_path_free (cursor_path); + + /* Give focus to the area in the new row */ + if (cell_area) + gtk_cell_area_focus (cell_area, direction); } else { @@ -10281,6 +10321,9 @@ gtk_tree_view_move_cursor_up_down (GtkTreeView *tree_view, { gtk_widget_error_bell (GTK_WIDGET (tree_view)); } + + if (cell_area) + gtk_cell_area_set_focus_cell (cell_area, last_focus_cell); } if (grab_focus) @@ -10325,8 +10368,8 @@ gtk_tree_view_move_cursor_page_up_down (GtkTreeView *tree_view, y = _gtk_rbtree_node_find_offset (cursor_tree, cursor_node); window_y = RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, y); y += tree_view->priv->cursor_offset; - y += count * (int)tree_view->priv->vadjustment->page_increment; - y = CLAMP (y, (gint)tree_view->priv->vadjustment->lower, (gint)tree_view->priv->vadjustment->upper - vertical_separator); + y += count * (int)gtk_adjustment_get_page_increment (tree_view->priv->vadjustment); + y = CLAMP (y, (gint)gtk_adjustment_get_lower (tree_view->priv->vadjustment), (gint)gtk_adjustment_get_upper (tree_view->priv->vadjustment) - vertical_separator); if (y >= tree_view->priv->height) y = tree_view->priv->height - 1; @@ -10342,11 +10385,12 @@ gtk_tree_view_move_cursor_page_up_down (GtkTreeView *tree_view, return; } - if (tree_view->priv->cursor_offset > BACKGROUND_HEIGHT (cursor_node)) + if (tree_view->priv->cursor_offset + > gtk_tree_view_get_row_height (tree_view, cursor_node)) { _gtk_rbtree_next_full (cursor_tree, cursor_node, &cursor_tree, &cursor_node); - tree_view->priv->cursor_offset -= BACKGROUND_HEIGHT (cursor_node); + tree_view->priv->cursor_offset -= gtk_tree_view_get_row_height (tree_view, cursor_node); } y -= tree_view->priv->cursor_offset; @@ -10408,6 +10452,9 @@ gtk_tree_view_move_cursor_left_right (GtkTreeView *tree_view, gboolean found_column = FALSE; gboolean rtl; GtkDirectionType direction; + GtkCellArea *cell_area; + GtkCellRenderer *last_focus_cell = NULL; + GtkCellArea *last_focus_area = NULL; rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL); @@ -10432,6 +10479,11 @@ gtk_tree_view_move_cursor_left_right (GtkTreeView *tree_view, list = rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns); if (tree_view->priv->focus_column) { + /* Save the cell/area we are moving focus from, if moving the cursor + * by one step hits the end we'll set focus back here */ + last_focus_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->focus_column)); + last_focus_cell = gtk_cell_area_get_focus_cell (last_focus_area); + for (; list; list = (rtl ? list->prev : list->next)) { if (list->data == tree_view->priv->focus_column) @@ -10439,21 +10491,10 @@ gtk_tree_view_move_cursor_left_right (GtkTreeView *tree_view, } } - switch (count) - { - case -1: - direction = rtl ? GTK_DIR_RIGHT : GTK_DIR_LEFT; - break; - - case 1: - direction = rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT; - break; - } + direction = count > 0 ? GTK_DIR_RIGHT : GTK_DIR_LEFT; while (list) { - gboolean left, right; - column = list->data; if (gtk_tree_view_column_get_visible (column) == FALSE) goto loop_end; @@ -10464,23 +10505,14 @@ gtk_tree_view_move_cursor_left_right (GtkTreeView *tree_view, GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT), cursor_node->children?TRUE:FALSE); - if (rtl) - { - right = list->prev ? TRUE : FALSE; - left = list->next ? TRUE : FALSE; - } - else - { - left = list->prev ? TRUE : FALSE; - right = list->next ? TRUE : FALSE; - - } - if (_gtk_tree_view_column_cell_focus (column, count, left, right)) + 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; found_column = TRUE; break; } + loop_end: if (count == 1) list = rtl ? list->prev : list->next; @@ -10501,6 +10533,9 @@ gtk_tree_view_move_cursor_left_right (GtkTreeView *tree_view, else { gtk_widget_error_bell (GTK_WIDGET (tree_view)); + + if (last_focus_area) + gtk_cell_area_set_focus_cell (last_focus_area, last_focus_cell); } gtk_tree_view_clamp_column_visible (tree_view, @@ -10580,7 +10615,7 @@ gtk_tree_view_real_select_all (GtkTreeView *tree_view) if (!gtk_widget_has_focus (GTK_WIDGET (tree_view))) return FALSE; - if (tree_view->priv->selection->type != GTK_SELECTION_MULTIPLE) + if (gtk_tree_selection_get_mode (tree_view->priv->selection) != GTK_SELECTION_MULTIPLE) return FALSE; gtk_tree_selection_select_all (tree_view->priv->selection); @@ -10594,7 +10629,7 @@ gtk_tree_view_real_unselect_all (GtkTreeView *tree_view) if (!gtk_widget_has_focus (GTK_WIDGET (tree_view))) return FALSE; - if (tree_view->priv->selection->type != GTK_SELECTION_MULTIPLE) + if (gtk_tree_selection_get_mode (tree_view->priv->selection) != GTK_SELECTION_MULTIPLE) return FALSE; gtk_tree_selection_unselect_all (tree_view->priv->selection); @@ -10634,7 +10669,7 @@ gtk_tree_view_real_select_cursor_row (GtkTreeView *tree_view, if (!tree_view->priv->shift_pressed && start_editing && tree_view->priv->focus_column) { - if (gtk_tree_view_start_editing (tree_view, cursor_path)) + if (gtk_tree_view_start_editing (tree_view, cursor_path, FALSE)) { gtk_tree_path_free (cursor_path); return TRUE; @@ -11182,15 +11217,16 @@ 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, - - tree_view->priv->hadjustment->value, + - gtk_adjustment_get_value (tree_view->priv->hadjustment), gtk_tree_view_get_effective_header_height (tree_view)); gdk_window_move (tree_view->priv->header_window, - - tree_view->priv->hadjustment->value, + - gtk_adjustment_get_value (tree_view->priv->hadjustment), 0); - dy = tree_view->priv->dy - (int) tree_view->priv->vadjustment->value; + dy = tree_view->priv->dy - (int) gtk_adjustment_get_value (tree_view->priv->vadjustment); if (dy) { update_prelight (tree_view, @@ -11224,10 +11260,13 @@ gtk_tree_view_adjustment_changed (GtkAdjustment *adjustment, } gdk_window_scroll (tree_view->priv->bin_window, 0, dy); - if (tree_view->priv->dy != (int) tree_view->priv->vadjustment->value) + 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 */ - tree_view->priv->dy = (int) tree_view->priv->vadjustment->value; + tree_view->priv->dy = (int) gtk_adjustment_get_value (tree_view->priv->vadjustment); if (!tree_view->priv->in_top_row_to_dy) gtk_tree_view_dy_to_top_row (tree_view); @@ -11318,11 +11357,13 @@ 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); - remove_expand_collapse_timeout (tree_view); + 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, @@ -11417,9 +11458,9 @@ gtk_tree_view_set_model (GtkTreeView *tree_view, flags = gtk_tree_model_get_flags (tree_view->priv->model); if ((flags & GTK_TREE_MODEL_LIST_ONLY) == GTK_TREE_MODEL_LIST_ONLY) - GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_IS_LIST); + tree_view->priv->is_list = TRUE; else - GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_IS_LIST); + tree_view->priv->is_list = FALSE; path = gtk_tree_path_new_first (); if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, path)) @@ -11598,7 +11639,7 @@ gtk_tree_view_get_headers_visible (GtkTreeView *tree_view) { g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE); - return GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE); + return tree_view->priv->headers_visible; } /** @@ -11622,13 +11663,10 @@ gtk_tree_view_set_headers_visible (GtkTreeView *tree_view, headers_visible = !! headers_visible; - if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE) == headers_visible) + if (tree_view->priv->headers_visible == headers_visible) return; - if (headers_visible) - GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE); - else - GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE); + tree_view->priv->headers_visible = headers_visible == TRUE; if (gtk_widget_get_realized (GTK_WIDGET (tree_view))) { @@ -11651,6 +11689,8 @@ gtk_tree_view_set_headers_visible (GtkTreeView *tree_view, { column = list->data; button = gtk_tree_view_column_get_button (column); + + gtk_widget_hide (button); gtk_widget_unmap (button); } gdk_window_hide (tree_view->priv->header_window); @@ -11658,11 +11698,13 @@ gtk_tree_view_set_headers_visible (GtkTreeView *tree_view, } gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation); - tree_view->priv->vadjustment->page_size = allocation.height - gtk_tree_view_get_effective_header_height (tree_view); - tree_view->priv->vadjustment->page_increment = (allocation.height - gtk_tree_view_get_effective_header_height (tree_view)) / 2; - tree_view->priv->vadjustment->lower = 0; - tree_view->priv->vadjustment->upper = tree_view->priv->height; - gtk_adjustment_changed (tree_view->priv->vadjustment); + gtk_adjustment_configure (tree_view->priv->vadjustment, + gtk_adjustment_get_value (tree_view->priv->vadjustment), + 0, + tree_view->priv->height, + gtk_adjustment_get_step_increment (tree_view->priv->vadjustment), + (allocation.height - gtk_tree_view_get_effective_header_height (tree_view)) / 2, + allocation.height - gtk_tree_view_get_effective_header_height (tree_view)); gtk_widget_queue_resize (GTK_WIDGET (tree_view)); @@ -11821,6 +11863,28 @@ gtk_tree_view_append_column (GtkTreeView *tree_view, return gtk_tree_view_insert_column (tree_view, column, -1); } +void +_gtk_tree_view_reset_header_styles (GtkTreeView *tree_view) +{ + GList *columns; + + for (columns = tree_view->priv->columns; columns; columns = columns->next) + { + GtkTreeViewColumn *column = columns->data; + GtkWidget *header_widget; + + if (gtk_tree_view_column_get_visible (column)) + continue; + + header_widget = gtk_tree_view_column_get_widget (column); + + if (!header_widget) + header_widget = gtk_tree_view_column_get_button (column); + + gtk_widget_reset_style (header_widget); + } +} + /** * gtk_tree_view_remove_column: @@ -11873,7 +11937,7 @@ gtk_tree_view_remove_column (GtkTreeView *tree_view, tmp_column = GTK_TREE_VIEW_COLUMN (list->data); if (gtk_tree_view_column_get_visible (tmp_column)) - _gtk_tree_view_column_cell_set_dirty (tmp_column, TRUE); + _gtk_tree_view_column_cell_set_dirty (tmp_column, TRUE); } if (tree_view->priv->n_columns == 0 && @@ -11883,6 +11947,8 @@ gtk_tree_view_remove_column (GtkTreeView *tree_view, gtk_widget_queue_resize (GTK_WIDGET (tree_view)); } + _gtk_tree_view_reset_header_styles (tree_view); + g_object_unref (column); g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0); @@ -11943,11 +12009,12 @@ gtk_tree_view_insert_column (GtkTreeView *tree_view, { column = GTK_TREE_VIEW_COLUMN (list->data); if (gtk_tree_view_column_get_visible (column)) - _gtk_tree_view_column_cell_set_dirty (column, TRUE); + _gtk_tree_view_column_cell_set_dirty (column, TRUE); } gtk_widget_queue_resize (GTK_WIDGET (tree_view)); } + _gtk_tree_view_reset_header_styles (tree_view); g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0); return tree_view->priv->n_columns; @@ -12149,6 +12216,7 @@ gtk_tree_view_move_column_after (GtkTreeView *tree_view, gtk_tree_view_size_allocate_columns (GTK_WIDGET (tree_view), NULL); } + _gtk_tree_view_reset_header_styles (tree_view); g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0); } @@ -12481,124 +12549,6 @@ gtk_tree_view_expand_all (GtkTreeView *tree_view) gtk_tree_path_free (path); } -/* Timeout to animate the expander during expands and collapses */ -static gboolean -expand_collapse_timeout (gpointer data) -{ - return do_expand_collapse (data); -} - -static void -add_expand_collapse_timeout (GtkTreeView *tree_view, - GtkRBTree *tree, - GtkRBNode *node, - gboolean expand) -{ - if (tree_view->priv->expand_collapse_timeout != 0) - return; - - tree_view->priv->expand_collapse_timeout = - gdk_threads_add_timeout (50, expand_collapse_timeout, tree_view); - tree_view->priv->expanded_collapsed_tree = tree; - tree_view->priv->expanded_collapsed_node = node; - - if (expand) - GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_SEMI_COLLAPSED); - else - GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_SEMI_EXPANDED); -} - -static void -remove_expand_collapse_timeout (GtkTreeView *tree_view) -{ - if (tree_view->priv->expand_collapse_timeout) - { - g_source_remove (tree_view->priv->expand_collapse_timeout); - tree_view->priv->expand_collapse_timeout = 0; - } - - if (tree_view->priv->expanded_collapsed_node != NULL) - { - GTK_RBNODE_UNSET_FLAG (tree_view->priv->expanded_collapsed_node, GTK_RBNODE_IS_SEMI_EXPANDED); - GTK_RBNODE_UNSET_FLAG (tree_view->priv->expanded_collapsed_node, GTK_RBNODE_IS_SEMI_COLLAPSED); - - tree_view->priv->expanded_collapsed_node = NULL; - } -} - -static void -cancel_arrow_animation (GtkTreeView *tree_view) -{ - if (tree_view->priv->expand_collapse_timeout) - { - while (do_expand_collapse (tree_view)); - - remove_expand_collapse_timeout (tree_view); - } -} - -static gboolean -do_expand_collapse (GtkTreeView *tree_view) -{ - GtkRBNode *node; - GtkRBTree *tree; - gboolean expanding; - gboolean redraw; - - redraw = FALSE; - expanding = TRUE; - - node = tree_view->priv->expanded_collapsed_node; - tree = tree_view->priv->expanded_collapsed_tree; - - if (node->children == NULL) - expanding = FALSE; - - if (expanding) - { - if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_COLLAPSED)) - { - GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_SEMI_COLLAPSED); - GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_SEMI_EXPANDED); - - redraw = TRUE; - - } - else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_EXPANDED)) - { - GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_SEMI_EXPANDED); - - redraw = TRUE; - } - } - else - { - if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_EXPANDED)) - { - GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_SEMI_EXPANDED); - GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_SEMI_COLLAPSED); - - redraw = TRUE; - } - else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_COLLAPSED)) - { - GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_SEMI_COLLAPSED); - - redraw = TRUE; - - } - } - - if (redraw) - { - gtk_tree_view_queue_draw_arrow (tree_view, tree, node); - - return TRUE; - } - - return FALSE; -} - /** * gtk_tree_view_collapse_all: * @tree_view: A #GtkTreeView. @@ -12759,14 +12709,21 @@ gtk_tree_view_real_expand_row (GtkTreeView *tree_view, gtk_tree_path_get_depth (path) + 1, open_all); - /* Update the deepest expanded row depth */ - if (tree_view->priv->deepest_depth < gtk_tree_path_get_depth (path) + 1) - tree_view->priv->deepest_depth = gtk_tree_path_get_depth (path) + 1; + if (animate) + { + GtkStyleContext *context; - remove_expand_collapse_timeout (tree_view); + context = gtk_widget_get_style_context (GTK_WIDGET (tree_view)); - if (animate) - add_expand_collapse_timeout (tree_view, tree, node, TRUE); + 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); + } install_presize_handler (tree_view); @@ -12817,17 +12774,6 @@ gtk_tree_view_expand_row (GtkTreeView *tree_view, return FALSE; } -static void -gtk_tree_view_deepest_expanded_depth (GtkTreeView *tree_view, - GtkTreePath *path, - gint *deepest) -{ - gint children_depth = gtk_tree_path_get_depth (path) + 1; - - if (children_depth > *deepest) - *deepest = children_depth; -} - static gboolean gtk_tree_view_real_collapse_row (GtkTreeView *tree_view, GtkTreePath *path, @@ -12934,8 +12880,6 @@ gtk_tree_view_real_collapse_row (GtkTreeView *tree_view, tree_view->priv->last_button_x = -1; tree_view->priv->last_button_y = -1; - remove_expand_collapse_timeout (tree_view); - if (gtk_tree_view_unref_and_check_selection_tree (tree_view, node->children)) { _gtk_rbtree_remove (node->children); @@ -12943,10 +12887,23 @@ gtk_tree_view_real_collapse_row (GtkTreeView *tree_view, } else _gtk_rbtree_remove (node->children); - + if (animate) - add_expand_collapse_timeout (tree_view, tree, node, FALSE); - + { + 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_style_context_invalidate_animation_areas (context); + gtk_style_context_restore (context); + } + if (gtk_widget_get_mapped (GTK_WIDGET (tree_view))) { gtk_widget_queue_resize (GTK_WIDGET (tree_view)); @@ -12980,17 +12937,6 @@ gtk_tree_view_real_collapse_row (GtkTreeView *tree_view, } } - /* If we're collapsing one of the deepest expanded rows, - * we need to recalculate the deepest_depth - */ - if (tree_view->priv->deepest_depth == gtk_tree_path_get_depth (path) + 1) - { - tree_view->priv->deepest_depth = 1; - gtk_tree_view_map_expanded_rows (tree_view, - (GtkTreeViewMappingFunc)gtk_tree_view_deepest_expanded_depth, - &tree_view->priv->deepest_depth); - } - return TRUE; } @@ -13266,8 +13212,8 @@ gtk_tree_view_real_set_cursor (GtkTreeView *tree_view, /** * gtk_tree_view_get_cursor: * @tree_view: A #GtkTreeView - * @path: (out) (allow-none): A pointer to be filled with the current cursor path, or %NULL - * @focus_column: (out) (allow-none): A pointer to be filled with the current focus column, or %NULL + * @path: (out) (transfer full) (allow-none): A pointer to be filled with the current cursor path, or %NULL + * @focus_column: (out) (transfer none) (allow-none): A pointer to be filled with the current focus column, or %NULL * * Fills in @path and @focus_column with the current path and focus column. If * the cursor isn't currently set, then *@path will be %NULL. If no column @@ -13396,7 +13342,7 @@ gtk_tree_view_set_cursor_on_cell (GtkTreeView *tree_view, if (focus_cell) gtk_tree_view_column_focus_cell (focus_column, focus_cell); if (start_editing) - gtk_tree_view_start_editing (tree_view, path); + gtk_tree_view_start_editing (tree_view, path, TRUE); } } @@ -13425,7 +13371,7 @@ gtk_tree_view_get_bin_window (GtkTreeView *tree_view) * @x: The x position to be identified (relative to bin_window). * @y: The y position to be identified (relative to bin_window). * @path: (out) (allow-none): A pointer to a #GtkTreePath pointer to be filled in, or %NULL - * @column: (out) (allow-none): A pointer to a #GtkTreeViewColumn pointer to be filled in, or %NULL + * @column: (out) (transfer none) (allow-none): A pointer to a #GtkTreeViewColumn pointer to be filled in, or %NULL * @cell_x: (out) (allow-none): A pointer where the X coordinate relative to the cell can be placed, or %NULL * @cell_y: (out) (allow-none): A pointer where the Y coordinate relative to the cell can be placed, or %NULL * @@ -13475,7 +13421,7 @@ gtk_tree_view_get_path_at_pos (GtkTreeView *tree_view, if (tree_view->priv->tree == NULL) return FALSE; - if (x > tree_view->priv->hadjustment->upper) + if (x > gtk_adjustment_get_upper (tree_view->priv->hadjustment)) return FALSE; if (x < 0 || y < 0) @@ -13555,12 +13501,48 @@ gtk_tree_view_get_path_at_pos (GtkTreeView *tree_view, } +static inline gint +gtk_tree_view_get_cell_area_height (GtkTreeView *tree_view, + GtkRBNode *node, + gint vertical_separator) +{ + int height; + + /* The "cell" areas are the cell_area passed in to gtk_cell_renderer_render(), + * i.e. just the cells, no spacing. + * + * The cell area height is at least expander_size - vertical_separator. + * For regular nodes, the height is then at least expander_size. We should + * be able to enforce the expander_size minimum here, because this + * 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; + + return height - vertical_separator; +} + +static inline gint +gtk_tree_view_get_cell_area_y_offset (GtkTreeView *tree_view, + GtkRBTree *tree, + GtkRBNode *node, + gint vertical_separator) +{ + int offset; + + offset = gtk_tree_view_get_row_y_offset (tree_view, tree, node); + offset += vertical_separator / 2; + + return offset; +} + /** * gtk_tree_view_get_cell_area: * @tree_view: a #GtkTreeView * @path: (allow-none): a #GtkTreePath for the row, or %NULL to get only horizontal coordinates * @column: (allow-none): a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordinates - * @rect: rectangle to fill with cell rect + * @rect: (out): rectangle to fill with cell rect * * Fills the bounding rectangle in bin_window coordinates for the cell at the * row specified by @path and the column specified by @column. If @path is @@ -13615,8 +13597,21 @@ gtk_tree_view_get_cell_area (GtkTreeView *tree_view, if ((!ret && tree == NULL) || ret) return; - rect->y = CELL_FIRST_PIXEL (tree_view, tree, node, vertical_separator); - rect->height = MAX (CELL_HEIGHT (node, vertical_separator), tree_view->priv->expander_size - vertical_separator); + if (row_is_separator (tree_view, NULL, path)) + { + /* There isn't really a "cell area" for separator, so we + * return the y, height values for background area instead. + */ + rect->y = gtk_tree_view_get_row_y_offset (tree_view, tree, node); + rect->height = gtk_tree_view_get_row_height (tree_view, node); + } + else + { + rect->y = gtk_tree_view_get_cell_area_y_offset (tree_view, tree, node, + vertical_separator); + rect->height = gtk_tree_view_get_cell_area_height (tree_view, node, + vertical_separator); + } if (column && gtk_tree_view_is_expander_column (tree_view, column)) @@ -13630,7 +13625,7 @@ gtk_tree_view_get_cell_area (GtkTreeView *tree_view, rect->x += (depth - 1) * tree_view->priv->level_indentation; rect->width -= (depth - 1) * tree_view->priv->level_indentation; - if (TREE_VIEW_DRAW_EXPANDERS (tree_view)) + if (gtk_tree_view_draw_expanders (tree_view)) { if (!rtl) rect->x += depth * tree_view->priv->expander_size; @@ -13642,12 +13637,45 @@ gtk_tree_view_get_cell_area (GtkTreeView *tree_view, } } +static inline gint +gtk_tree_view_get_row_height (GtkTreeView *tree_view, + GtkRBNode *node) +{ + int height; + + /* The "background" areas of all rows/cells add up to cover the entire tree. + * The background includes all inter-row and inter-cell spacing. + * + * If the row pointed at by node does not have a height set, we default + * to expander_size, which is the minimum height for regular nodes. + * Non-regular nodes (e.g. separators) can have a height set smaller + * than expander_size and should not be overruled here. + */ + height = GTK_RBNODE_GET_HEIGHT (node); + if (height <= 0) + height = tree_view->priv->expander_size; + + return height; +} + +static inline gint +gtk_tree_view_get_row_y_offset (GtkTreeView *tree_view, + GtkRBTree *tree, + GtkRBNode *node) +{ + int offset; + + offset = _gtk_rbtree_node_find_offset (tree, node); + + return RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, offset); +} + /** * gtk_tree_view_get_background_area: * @tree_view: a #GtkTreeView * @path: (allow-none): a #GtkTreePath for the row, or %NULL to get only horizontal coordinates * @column: (allow-none): a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordiantes - * @rect: rectangle to fill with cell background rect + * @rect: (out): rectangle to fill with cell background rect * * Fills the bounding rectangle in bin_window coordinates for the cell at the * row specified by @path and the column specified by @column. If @path is @@ -13686,9 +13714,8 @@ gtk_tree_view_get_background_area (GtkTreeView *tree_view, tree == NULL) return; - rect->y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node); - - rect->height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node)); + rect->y = gtk_tree_view_get_row_y_offset (tree_view, tree, node); + rect->height = gtk_tree_view_get_row_height (tree_view, node); } if (column) @@ -13703,7 +13730,7 @@ gtk_tree_view_get_background_area (GtkTreeView *tree_view, /** * gtk_tree_view_get_visible_rect: * @tree_view: a #GtkTreeView - * @visible_rect: rectangle to fill + * @visible_rect: (out): rectangle to fill * * Fills @visible_rect with the currently-visible region of the * buffer, in tree coordinates. Convert to bin_window coordinates with @@ -13725,8 +13752,8 @@ gtk_tree_view_get_visible_rect (GtkTreeView *tree_view, if (visible_rect) { gtk_widget_get_allocation (widget, &allocation); - visible_rect->x = tree_view->priv->hadjustment->value; - visible_rect->y = tree_view->priv->vadjustment->value; + visible_rect->x = gtk_adjustment_get_value (tree_view->priv->hadjustment); + visible_rect->y = gtk_adjustment_get_value (tree_view->priv->vadjustment); visible_rect->width = allocation.width; visible_rect->height = allocation.height - gtk_tree_view_get_effective_header_height (tree_view); } @@ -13737,8 +13764,8 @@ gtk_tree_view_get_visible_rect (GtkTreeView *tree_view, * @tree_view: a #GtkTreeView * @wx: X coordinate relative to the widget * @wy: Y coordinate relative to the widget - * @tx: return location for tree X coordinate - * @ty: return location for tree Y coordinate + * @tx: (out): return location for tree X coordinate + * @ty: (out): return location for tree Y coordinate * * Converts widget coordinates to coordinates for the * tree (the full scrollable area of the tree). @@ -13769,8 +13796,8 @@ gtk_tree_view_convert_widget_to_tree_coords (GtkTreeView *tree_view, * @tree_view: a #GtkTreeView * @tx: X coordinate relative to the tree * @ty: Y coordinate relative to the tree - * @wx: return location for widget X coordinate - * @wy: return location for widget Y coordinate + * @wx: (out): return location for widget X coordinate + * @wy: (out): return location for widget Y coordinate * * Converts tree coordinates (coordinates in full scrollable area of the tree) * to widget coordinates. @@ -13801,8 +13828,8 @@ gtk_tree_view_convert_tree_to_widget_coords (GtkTreeView *tree_view, * @tree_view: a #GtkTreeView * @wx: X coordinate relative to the widget * @wy: Y coordinate relative to the widget - * @bx: return location for bin_window X coordinate - * @by: return location for bin_window Y coordinate + * @bx: (out): return location for bin_window X coordinate + * @by: (out): return location for bin_window Y coordinate * * Converts widget coordinates to coordinates for the bin_window * (see gtk_tree_view_get_bin_window()). @@ -13819,7 +13846,7 @@ gtk_tree_view_convert_widget_to_bin_window_coords (GtkTreeView *tree_view, g_return_if_fail (GTK_IS_TREE_VIEW (tree_view)); if (bx) - *bx = wx + tree_view->priv->hadjustment->value; + *bx = wx + gtk_adjustment_get_value (tree_view->priv->hadjustment); if (by) *by = wy - gtk_tree_view_get_effective_header_height (tree_view); } @@ -13829,8 +13856,8 @@ gtk_tree_view_convert_widget_to_bin_window_coords (GtkTreeView *tree_view, * @tree_view: a #GtkTreeView * @bx: bin_window X coordinate * @by: bin_window Y coordinate - * @wx: return location for widget X coordinate - * @wy: return location for widget Y coordinate + * @wx: (out): return location for widget X coordinate + * @wy: (out): return location for widget Y coordinate * * Converts bin_window coordinates (see gtk_tree_view_get_bin_window()) * to widget relative coordinates. @@ -13847,7 +13874,7 @@ gtk_tree_view_convert_bin_window_to_widget_coords (GtkTreeView *tree_view, g_return_if_fail (GTK_IS_TREE_VIEW (tree_view)); if (wx) - *wx = bx - tree_view->priv->hadjustment->value; + *wx = bx - gtk_adjustment_get_value (tree_view->priv->hadjustment); if (wy) *wy = by + gtk_tree_view_get_effective_header_height (tree_view); } @@ -13857,8 +13884,8 @@ gtk_tree_view_convert_bin_window_to_widget_coords (GtkTreeView *tree_view, * @tree_view: a #GtkTreeView * @tx: tree X coordinate * @ty: tree Y coordinate - * @bx: return location for X coordinate relative to bin_window - * @by: return location for Y coordinate relative to bin_window + * @bx: (out): return location for X coordinate relative to bin_window + * @by: (out): return location for Y coordinate relative to bin_window * * Converts tree coordinates (coordinates in full scrollable area of the tree) * to bin_window coordinates. @@ -13885,8 +13912,8 @@ gtk_tree_view_convert_tree_to_bin_window_coords (GtkTreeView *tree_view, * @tree_view: a #GtkTreeView * @bx: X coordinate relative to bin_window * @by: Y coordinate relative to bin_window - * @tx: return location for tree X coordinate - * @ty: return location for tree Y coordinate + * @tx: (out): return location for tree X coordinate + * @ty: (out): return location for tree Y coordinate * * Converts bin_window coordinates to coordinates for the * tree (the full scrollable area of the tree). @@ -13913,8 +13940,9 @@ gtk_tree_view_convert_bin_window_to_tree_coords (GtkTreeView *tree_view, /** * gtk_tree_view_get_visible_range: * @tree_view: A #GtkTreeView - * @start_path: (allow-none): Return location for start of region, or %NULL. - * @end_path: (allow-none): Return location for end of region, or %NULL. + * @start_path: (out) (allow-none): Return location for start of region, + * or %NULL. + * @end_path: (out) (allow-none): Return location for end of region, or %NULL. * * Sets @start_path and @end_path to be the first and last visible path. * Note that there may be invisible paths in between. @@ -13956,10 +13984,10 @@ gtk_tree_view_get_visible_range (GtkTreeView *tree_view, { gint y; - if (tree_view->priv->height < tree_view->priv->vadjustment->page_size) + if (tree_view->priv->height < gtk_adjustment_get_page_size (tree_view->priv->vadjustment)) y = tree_view->priv->height - 1; else - y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, tree_view->priv->vadjustment->page_size) - 1; + y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, gtk_adjustment_get_page_size (tree_view->priv->vadjustment)) - 1; _gtk_rbtree_find_offset (tree_view->priv->tree, y, &tree, &node); if (node) @@ -13971,6 +13999,109 @@ gtk_tree_view_get_visible_range (GtkTreeView *tree_view, return retval; } +/** + * gtk_tree_view_is_blank_at_pos: + * @tree_view: A #GtkTreeView + * @x: The x position to be identified (relative to bin_window) + * @y: The y position to be identified (relative to bin_window) + * @path: (out) (allow-none): A pointer to a #GtkTreePath pointer to be filled in, or %NULL + * @column: (out) (allow-none): A pointer to a #GtkTreeViewColumn pointer to be filled in, or %NULL + * @cell_x: (out) (allow-none): A pointer where the X coordinate relative to the cell can be placed, or %NULL + * @cell_y: (out) (allow-none): A pointer where the Y coordinate relative to the cell can be placed, or %NULL + * + * Determine whether the point (@x, @y) in @tree_view is blank, that is no + * cell content nor an expander arrow is drawn at the location. If so, the + * location can be considered as the background. You might wish to take + * special action on clicks on the background, such as clearing a current + * selection, having a custom context menu or starting rubber banding. + * + * The @x and @y coordinate that are provided must be relative to bin_window + * coordinates. That is, @x and @y must come from an event on @tree_view + * where event->window == gtk_tree_view_get_bin_window (). + * + * For converting widget coordinates (eg. the ones you get from + * GtkWidget::query-tooltip), please see + * gtk_tree_view_convert_widget_to_bin_window_coords(). + * + * The @path, @column, @cell_x and @cell_y arguments will be filled in + * likewise as for gtk_tree_view_get_path_at_pos(). Please see + * gtk_tree_view_get_path_at_pos() for more information. + * + * Return value: %TRUE if the area at the given coordinates is blank, + * %FALSE otherwise. + * + * Since: 3.0 + */ +gboolean +gtk_tree_view_is_blank_at_pos (GtkTreeView *tree_view, + gint x, + gint y, + GtkTreePath **path, + GtkTreeViewColumn **column, + gint *cell_x, + gint *cell_y) +{ + GtkRBTree *tree; + GtkRBNode *node; + GtkTreeIter iter; + GtkTreePath *real_path; + GtkTreeViewColumn *real_column; + GdkRectangle cell_area, background_area; + + g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE); + + if (!gtk_tree_view_get_path_at_pos (tree_view, x, y, + &real_path, &real_column, + cell_x, cell_y)) + /* If there's no path here, it is blank */ + return TRUE; + + if (path) + *path = real_path; + + if (column) + *column = real_column; + + gtk_tree_model_get_iter (tree_view->priv->model, &iter, real_path); + _gtk_tree_view_find_node (tree_view, real_path, &tree, &node); + + /* Check if there's an expander arrow at (x, y) */ + if (real_column == tree_view->priv->expander_column + && gtk_tree_view_draw_expanders (tree_view)) + { + gboolean over_arrow; + + over_arrow = coords_are_over_arrow (tree_view, tree, node, x, y); + + if (over_arrow) + { + if (!path) + gtk_tree_path_free (real_path); + return FALSE; + } + } + + /* Otherwise, have the column see if there's a cell at (x, y) */ + gtk_tree_view_column_cell_set_cell_data (real_column, + tree_view->priv->model, + &iter, + GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT), + node->children ? TRUE : FALSE); + + gtk_tree_view_get_background_area (tree_view, real_path, real_column, + &background_area); + gtk_tree_view_get_cell_area (tree_view, real_path, real_column, + &cell_area); + + if (!path) + gtk_tree_path_free (real_path); + + return _gtk_tree_view_column_is_blank_at_pos (real_column, + &cell_area, + &background_area, + x, y); +} + static void unset_reorderable (GtkTreeView *tree_view) { @@ -14022,7 +14153,8 @@ gtk_tree_view_enable_model_drag_source (GtkTreeView *tree_view, /** * gtk_tree_view_enable_model_drag_dest: * @tree_view: a #GtkTreeView - * @targets: (array): the table of targets that the drag will support + * @targets: (array length=n_targets): the table of targets that + * the drag will support * @n_targets: the number of items in @targets * @actions: the bitmask of possible actions for a drag from this * widget @@ -14347,7 +14479,8 @@ gtk_tree_view_create_row_drag_icon (GtkTreeView *tree_view, GtkTreeIter iter; GtkRBTree *tree; GtkRBNode *node; - GtkStyle *style; + GtkStyleContext *context; + GtkStateFlags state; gint cell_offset; GList *list; GdkRectangle background_area; @@ -14358,7 +14491,7 @@ gtk_tree_view_create_row_drag_icon (GtkTreeView *tree_view, cairo_surface_t *surface; gint bin_window_width; gboolean is_separator = FALSE; - gboolean rtl; + gboolean rtl, allow_rules; cairo_t *cr; g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL); @@ -14384,14 +14517,38 @@ gtk_tree_view_create_row_drag_icon (GtkTreeView *tree_view, path)) return NULL; - style = gtk_widget_get_style (widget); + 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, + "allow-rules", &allow_rules, + NULL); + + if (allow_rules && tree_view->priv->has_rules) + { + GtkRegionFlags row_flags; + + if (_gtk_rbtree_node_find_parity (tree, node)) + row_flags = GTK_REGION_ODD; + else + row_flags = GTK_REGION_EVEN; + + gtk_style_context_add_region (context, GTK_STYLE_REGION_ROW, row_flags); + } is_separator = row_is_separator (tree_view, &iter, NULL); cell_offset = x; background_area.y = y; - background_area.height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node)); + background_area.height = gtk_tree_view_get_row_height (tree_view, node); bin_window_width = gdk_window_get_width (tree_view->priv->bin_window); @@ -14401,8 +14558,10 @@ gtk_tree_view_create_row_drag_icon (GtkTreeView *tree_view, background_area.height + 2); cr = cairo_create (surface); - gdk_cairo_set_source_color (cr, &style->base [gtk_widget_get_state (widget)]); - cairo_paint (cr); + + gtk_render_background (context, cr, 0, 0, + bin_window_width + 2, + background_area.height + 2); rtl = gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL; @@ -14439,7 +14598,7 @@ gtk_tree_view_create_row_drag_icon (GtkTreeView *tree_view, cell_area.x += (depth - 1) * tree_view->priv->level_indentation; cell_area.width -= (depth - 1) * tree_view->priv->level_indentation; - if (TREE_VIEW_DRAW_EXPANDERS(tree_view)) + if (gtk_tree_view_draw_expanders (tree_view)) { if (!rtl) cell_area.x += depth * tree_view->priv->expander_size; @@ -14450,14 +14609,11 @@ gtk_tree_view_create_row_drag_icon (GtkTreeView *tree_view, if (gtk_tree_view_column_cell_is_visible (column)) { if (is_separator) - gtk_paint_hline (style, - cr, - GTK_STATE_NORMAL, - widget, - NULL, - cell_area.x, - cell_area.x + cell_area.width, - cell_area.y + cell_area.height / 2); + gtk_render_line (context, cr, + cell_area.x, + cell_area.y + cell_area.height / 2, + cell_area.x + cell_area.width, + cell_area.y + cell_area.height / 2); else _gtk_tree_view_column_cell_render (column, cr, @@ -14480,6 +14636,8 @@ gtk_tree_view_create_row_drag_icon (GtkTreeView *tree_view, cairo_surface_set_device_offset (surface, 2, 2); + gtk_style_context_restore (context); + return surface; } @@ -14606,7 +14764,7 @@ gtk_tree_view_set_search_column (GtkTreeView *tree_view, } /** - * gtk_tree_view_get_search_equal_func: + * gtk_tree_view_get_search_equal_func: (skip) * @tree_view: A #GtkTreeView * * Returns the compare function currently in use. @@ -14773,7 +14931,7 @@ gtk_tree_view_set_search_position_func (GtkTreeView *tree_view } /** - * gtk_tree_view_get_search_position_func: + * gtk_tree_view_get_search_position_func: (skip) * @tree_view: A #GtkTreeView * * Returns the positioning function currently in use. @@ -15363,13 +15521,12 @@ _gtk_tree_view_remove_editable (GtkTreeView *tree_view, static gboolean gtk_tree_view_start_editing (GtkTreeView *tree_view, - GtkTreePath *cursor_path) + GtkTreePath *cursor_path, + gboolean edit_only) { GtkTreeIter iter; - GdkRectangle background_area; GdkRectangle cell_area; GtkTreeViewColumn *focus_column; - gchar *path_string; guint flags = 0; /* can be 0, as the flags are primarily for rendering */ gint retval = FALSE; GtkRBTree *cursor_tree; @@ -15385,30 +15542,25 @@ gtk_tree_view_start_editing (GtkTreeView *tree_view, cursor_node == NULL) return FALSE; - path_string = gtk_tree_path_to_string (cursor_path); gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path); validate_row (tree_view, cursor_tree, cursor_node, &iter, cursor_path); gtk_tree_view_column_cell_set_cell_data (focus_column, - tree_view->priv->model, - &iter, - GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT), - cursor_node->children?TRUE:FALSE); - gtk_tree_view_get_background_area (tree_view, - cursor_path, - focus_column, - &background_area); + tree_view->priv->model, + &iter, + GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT), + cursor_node->children ? TRUE : FALSE); gtk_tree_view_get_cell_area (tree_view, - cursor_path, - focus_column, - &cell_area); + cursor_path, + focus_column, + &cell_area); if (gtk_cell_area_activate (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (focus_column)), _gtk_tree_view_column_get_context (focus_column), GTK_WIDGET (tree_view), &cell_area, - flags)) + flags, edit_only)) retval = TRUE; return retval; @@ -15421,18 +15573,18 @@ _gtk_tree_view_add_editable (GtkTreeView *tree_view, GtkCellEditable *cell_editable, GdkRectangle *cell_area) { - gint pre_val = tree_view->priv->vadjustment->value; + gint pre_val = gtk_adjustment_get_value (tree_view->priv->vadjustment); GtkRequisition requisition; tree_view->priv->edited_column = column; gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE); - cell_area->y += pre_val - (int)tree_view->priv->vadjustment->value; + cell_area->y += pre_val - (int)gtk_adjustment_get_value (tree_view->priv->vadjustment); gtk_widget_get_preferred_size (GTK_WIDGET (cell_editable), &requisition, NULL); - GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS); + tree_view->priv->draw_keyfocus = TRUE; if (requisition.height < cell_area->height) { @@ -15627,7 +15779,7 @@ gtk_tree_view_is_rubber_banding_active (GtkTreeView *tree_view) } /** - * gtk_tree_view_get_row_separator_func: + * gtk_tree_view_get_row_separator_func: (skip) * @tree_view: a #GtkTreeView * * Returns the current row separator function. @@ -15696,15 +15848,16 @@ gtk_tree_view_grab_notify (GtkWidget *widget, } static void -gtk_tree_view_state_changed (GtkWidget *widget, - GtkStateType previous_state) +gtk_tree_view_state_flags_changed (GtkWidget *widget, + GtkStateFlags previous_state) { - GtkTreeView *tree_view = GTK_TREE_VIEW (widget); - if (gtk_widget_get_realized (widget)) { - gdk_window_set_background (tree_view->priv->bin_window, - >k_widget_get_style (widget)->base[gtk_widget_get_state (widget)]); + GtkTreeView *tree_view = GTK_TREE_VIEW (widget); + GtkStyleContext *context; + + context = gtk_widget_get_style_context (widget); + gtk_style_context_set_background (context, tree_view->priv->bin_window); } gtk_widget_queue_draw (widget); @@ -15909,12 +16062,9 @@ gtk_tree_view_set_show_expanders (GtkTreeView *tree_view, g_return_if_fail (GTK_IS_TREE_VIEW (tree_view)); enabled = enabled != FALSE; - was_enabled = GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_SHOW_EXPANDERS); + was_enabled = tree_view->priv->show_expanders; - if (enabled) - GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_SHOW_EXPANDERS); - else - GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_SHOW_EXPANDERS); + tree_view->priv->show_expanders = enabled == TRUE; if (enabled != was_enabled) gtk_widget_queue_draw (GTK_WIDGET (tree_view)); @@ -15936,7 +16086,7 @@ gtk_tree_view_get_show_expanders (GtkTreeView *tree_view) { g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE); - return GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_SHOW_EXPANDERS); + return tree_view->priv->show_expanders; } /** @@ -16093,7 +16243,7 @@ gtk_tree_view_set_tooltip_cell (GtkTreeView *tree_view, else { rect.y = 0; - rect.height = tree_view->priv->vadjustment->page_size; + rect.height = gtk_adjustment_get_page_size (tree_view->priv->vadjustment); } gtk_tooltip_set_tip_area (tooltip, &rect); @@ -16102,8 +16252,8 @@ gtk_tree_view_set_tooltip_cell (GtkTreeView *tree_view, /** * gtk_tree_view_get_tooltip_context: * @tree_view: a #GtkTreeView - * @x: the x coordinate (relative to widget coordinates) - * @y: the y coordinate (relative to widget coordinates) + * @x: (inout): the x coordinate (relative to widget coordinates) + * @y: (inout): the y coordinate (relative to widget coordinates) * @keyboard_tip: whether this is a keyboard tooltip or not * @model: (out) (allow-none): a pointer to receive a #GtkTreeModel or %NULL * @path: (out) (allow-none): a pointer to receive a #GtkTreePath or %NULL