* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include <string.h>
#include "gtktreeview.h"
+
+#include "gtkadjustment.h"
#include "gtkrbtree.h"
#include "gtktreednd.h"
#include "gtktreeprivate.h"
#include "gtkstylecontextprivate.h"
#include "gtktypebuiltins.h"
#include "gtkmain.h"
+#include "gtksettings.h"
+#include "gtkwidgetpath.h"
#include "a11y/gtktreeviewaccessible.h"
typedef enum {
CLEAR_AND_SELECT = (1 << 0),
- CLAMP_NODE = (1 << 1)
+ CLAMP_NODE = (1 << 1),
+ CURSOR_INVALID = (1 << 2)
} SetCursorFlags;
/* This lovely little value is used to determine how far away from the title bar
guint scroll_sync_timer;
/* Indentation and expander layout */
- gint expander_size;
GtkTreeViewColumn *expander_column;
gint level_indentation;
gtk_style_context_save (context);
gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW);
gtk_style_context_set_background (context, tree_view->priv->bin_window);
+ gtk_style_context_set_background (context, gtk_widget_get_window (GTK_WIDGET (tree_view)));
gtk_style_context_restore (context);
gtk_style_context_set_background (context, tree_view->priv->header_window);
attributes.height = allocation.height;
attributes.event_mask = (GDK_EXPOSURE_MASK |
GDK_SCROLL_MASK |
+ GDK_SMOOTH_SCROLL_MASK |
GDK_POINTER_MOTION_MASK |
GDK_ENTER_NOTIFY_MASK |
GDK_LEAVE_NOTIFY_MASK |
{
GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
GtkTreeViewPrivate *priv = tree_view->priv;
- GtkStyleContext *context;
GList *list;
if (priv->scroll_timeout != 0)
priv->open_dest_timeout = 0;
}
- context = gtk_widget_get_style_context (widget);
- gtk_style_context_cancel_animations (context, NULL);
-
if (priv->presize_handler_timer != 0)
{
g_source_remove (priv->presize_handler_timer);
return is_separator;
}
+static int
+gtk_tree_view_get_expander_size (GtkTreeView *tree_view)
+{
+ gint expander_size;
+
+ gtk_widget_style_get (GTK_WIDGET (tree_view),
+ "expander-size", &expander_size,
+ NULL);
+ expander_size += EXPANDER_EXTRA_PADDING;
+
+ return expander_size;
+}
+
static gboolean
gtk_tree_view_button_press (GtkWidget *widget,
GdkEventButton *event)
"horizontal-separator", &horizontal_separator,
NULL);
+ /* Don't handle extra mouse buttons events, let them bubble up */
+ if (event->button > 5)
+ return FALSE;
+
/* Because grab_focus can cause reentrancy, we delay grab_focus until after
* we're done handling the button press.
*/
tree_view->priv->arrow_prelit &&
gtk_tree_view_draw_expanders (tree_view))
{
- if (event->button == 1)
+ if (event->button == GDK_BUTTON_PRIMARY)
{
gtk_grab_add (widget);
tree_view->priv->button_pressed_node = tree_view->priv->prelight_node;
if (gtk_tree_view_draw_expanders (tree_view))
{
+ gint expander_size = gtk_tree_view_get_expander_size (tree_view);
if (!rtl)
- cell_area.x += depth * tree_view->priv->expander_size;
- cell_area.width -= depth * tree_view->priv->expander_size;
+ cell_area.x += depth * expander_size;
+ cell_area.width -= depth * expander_size;
}
}
break;
return FALSE;
}
- tree_view->priv->focus_column = column;
+ _gtk_tree_view_set_focus_column (tree_view, column);
/* decide if we edit */
- if (event->type == GDK_BUTTON_PRESS && event->button == 1 &&
+ if (event->type == GDK_BUTTON_PRESS && event->button == GDK_BUTTON_PRIMARY &&
!(event->state & gtk_accelerator_get_default_mod_mask ()))
{
GtkTreePath *anchor;
}
/* Test if a double click happened on the same row. */
- if (event->button == 1 && event->type == GDK_BUTTON_PRESS)
+ if (event->button == GDK_BUTTON_PRIMARY && event->type == GDK_BUTTON_PRESS)
{
int double_click_time, double_click_distance;
GList *l;
gboolean rtl;
GdkDevice *device, *other;
+ GtkStyleContext *context;
tree_view = GTK_TREE_VIEW (widget);
/* Move the button back */
button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
+
+ context = gtk_widget_get_style_context (button);
+ gtk_style_context_remove_class (context, STYLE_CLASS_DND);
+
g_object_ref (button);
gtk_container_remove (GTK_CONTAINER (tree_view), button);
gtk_widget_set_parent_window (button, tree_view->priv->header_window);
tree_view->priv->cur_reorder->left_column);
}
tree_view->priv->drag_column = NULL;
- gdk_window_hide (tree_view->priv->drag_window);
+ gdk_window_destroy (tree_view->priv->drag_window);
+ tree_view->priv->drag_window = NULL;
for (l = tree_view->priv->column_drag_info; l != NULL; l = l->next)
g_slice_free (GtkTreeViewColumnReorder, l->data);
if (tree_view->priv->button_pressed_node == NULL)
return FALSE;
- if (event->button == 1)
+ if (event->button == GDK_BUTTON_PRIMARY)
{
if (tree_view->priv->button_pressed_node == tree_view->priv->prelight_node &&
tree_view->priv->arrow_prelit)
GtkAllocation button_allocation;
GtkWidget *button;
- width = tree_view->priv->expander_size;
+ width = gtk_tree_view_get_expander_size (tree_view);
/* Get x, y, width, height of arrow */
gdk_window_get_origin (tree_view->priv->header_window, &x, &y);
x += button_allocation.x - width/2;
height = button_allocation.height;
}
- y -= tree_view->priv->expander_size/2; /* The arrow takes up only half the space */
- height += tree_view->priv->expander_size;
+ y -= width/2; /* The arrow takes up only half the space */
+ height += width;
/* Create the new window */
if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW)
{
GtkAllocation allocation;
GtkWidget *button;
+ gint expander_size;
- width = tree_view->priv->expander_size;
+ expander_size = gtk_tree_view_get_expander_size (tree_view);
/* Get x, y, width, height of arrow */
- width = width/2; /* remember, the arrow only takes half the available width */
+ width = expander_size/2; /* remember, the arrow only takes half the available width */
gdk_window_get_origin (gtk_widget_get_window (widget),
&x, &y);
if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
height = allocation.height;
}
- y -= tree_view->priv->expander_size;
- height += 2*tree_view->priv->expander_size;
+ y -= expander_size;
+ height += 2 * expander_size;
/* Create the new window */
if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT &&
attributes.y = y;
attributes.width = width;
attributes.height = height;
- tree_view->priv->drag_highlight_window = gdk_window_new (NULL, &attributes, attributes_mask);
+ tree_view->priv->drag_highlight_window = gdk_window_new (gtk_widget_get_root_window (widget), &attributes, attributes_mask);
gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
}
cairo_move_to (cr, 0, 0);
cairo_line_to (cr, width, width);
- cairo_line_to (cr, 0, tree_view->priv->expander_size);
+ cairo_line_to (cr, 0, expander_size);
cairo_move_to (cr, 0, height);
cairo_line_to (cr, width, height - width);
- cairo_line_to (cr, 0, height - tree_view->priv->expander_size);
+ cairo_line_to (cr, 0, height - expander_size);
cairo_fill (cr);
cairo_destroy (cr);
if (w > 0 && h > 0)
{
GtkStyleContext *context;
- GtkStateFlags state;
context = gtk_widget_get_style_context (widget);
- state = gtk_widget_get_state_flags (widget);
-
- gtk_style_context_save (context);
- gtk_style_context_set_state (context, state);
gtk_render_focus (context, cr, 1, 1, w, h);
-
- gtk_style_context_restore (context);
}
}
GList *first_column, *last_column;
gint vertical_separator;
gint horizontal_separator;
- gint focus_line_width;
gboolean allow_rules;
gboolean has_can_focus_cell;
gboolean rtl;
gint n_visible_columns;
gint grid_line_width;
+ gint expander_size;
gboolean draw_vgrid_lines, draw_hgrid_lines;
GtkStyleContext *context;
- GtkStateFlags state;
gboolean parity;
rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
context = gtk_widget_get_style_context (widget);
- state = gtk_widget_get_state_flags (widget);
gtk_widget_style_get (widget,
"horizontal-separator", &horizontal_separator,
"vertical-separator", &vertical_separator,
"allow-rules", &allow_rules,
- "focus-line-width", &focus_line_width,
NULL);
if (tree_view->priv->tree == NULL)
if (tree_view->priv->height < bin_window_height)
{
gtk_style_context_save (context);
- gtk_style_context_set_state (context, state);
gtk_style_context_add_class (context, GTK_STYLE_CLASS_CELL);
gtk_render_background (context, cr,
draw_hgrid_lines =
tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_HORIZONTAL
|| tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
+ expander_size = gtk_tree_view_get_expander_size (tree_view);
if (draw_vgrid_lines || draw_hgrid_lines)
gtk_widget_style_get (widget, "grid-line-width", &grid_line_width, NULL);
else
flags &= ~GTK_CELL_RENDERER_FOCUSED;
+ if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
+ flags |= GTK_CELL_RENDERER_EXPANDABLE;
+ else
+ flags &= ~GTK_CELL_RENDERER_EXPANDABLE;
+
+ if (node->children)
+ flags |= GTK_CELL_RENDERER_EXPANDED;
+ else
+ flags &= ~GTK_CELL_RENDERER_EXPANDED;
+
background_area.x = cell_offset;
background_area.width = width;
if (gtk_tree_view_draw_expanders (tree_view))
{
+ int expander_size = gtk_tree_view_get_expander_size (tree_view);
if (!rtl)
- cell_area.x += depth * tree_view->priv->expander_size;
- cell_area.width -= depth * tree_view->priv->expander_size;
+ cell_area.x += depth * expander_size;
+ cell_area.width -= depth * expander_size;
}
/* If we have an expander column, the highlight underline
{
gtk_tree_view_draw_line (tree_view, cr,
GTK_TREE_VIEW_TREE_LINE,
- x + tree_view->priv->expander_size * (depth - 1.5) * mult,
+ x + expander_size * (depth - 1.5) * mult,
y1,
- x + tree_view->priv->expander_size * (depth - 1.1) * mult,
+ x + expander_size * (depth - 1.1) * mult,
y1);
}
else if (depth > 1)
{
gtk_tree_view_draw_line (tree_view, cr,
GTK_TREE_VIEW_TREE_LINE,
- x + tree_view->priv->expander_size * (depth - 1.5) * mult,
+ x + expander_size * (depth - 1.5) * mult,
y1,
- x + tree_view->priv->expander_size * (depth - 0.5) * mult,
+ x + expander_size * (depth - 0.5) * mult,
y1);
}
if (!_gtk_rbtree_next (tree, node))
gtk_tree_view_draw_line (tree_view, cr,
GTK_TREE_VIEW_TREE_LINE,
- x + tree_view->priv->expander_size * (depth - 1.5) * mult,
+ x + expander_size * (depth - 1.5) * mult,
y0,
- x + tree_view->priv->expander_size * (depth - 1.5) * mult,
+ x + expander_size * (depth - 1.5) * mult,
y1);
else
gtk_tree_view_draw_line (tree_view, cr,
GTK_TREE_VIEW_TREE_LINE,
- x + tree_view->priv->expander_size * (depth - 1.5) * mult,
+ x + expander_size * (depth - 1.5) * mult,
y0,
- x + tree_view->priv->expander_size * (depth - 1.5) * mult,
+ x + expander_size * (depth - 1.5) * mult,
y2);
tmp_node = tree->parent_node;
if (_gtk_rbtree_next (tmp_tree, tmp_node))
gtk_tree_view_draw_line (tree_view, cr,
GTK_TREE_VIEW_TREE_LINE,
- x + tree_view->priv->expander_size * (i - 0.5) * mult,
+ x + expander_size * (i - 0.5) * mult,
y0,
- x + tree_view->priv->expander_size * (i - 0.5) * mult,
+ x + expander_size * (i - 0.5) * mult,
y2);
tmp_node = tmp_tree->parent_node;
GtkRBTree *tree = NULL;
GtkRBNode *node = NULL;
+ gtk_style_context_save (context);
+ gtk_style_context_add_class (context, GTK_STYLE_CLASS_DND);
+
switch (tree_view->priv->drag_dest_pos)
{
case GTK_TREE_VIEW_DROP_BEFORE:
if (tree == NULL)
break;
- gtk_render_focus (context, cr,
- 0, gtk_tree_view_get_row_y_offset (tree_view, tree, node)
- - focus_line_width / 2,
- gdk_window_get_width (tree_view->priv->bin_window),
- gtk_tree_view_get_row_height (tree_view, node)
- - focus_line_width + 1);
+ gtk_render_frame (context, cr,
+ 0, gtk_tree_view_get_row_y_offset (tree_view, tree, node),
+ gdk_window_get_width (tree_view->priv->bin_window),
+ gtk_tree_view_get_row_height (tree_view, node));
break;
}
rtl ? 0 : bin_window_width,
highlight_y);
}
+
+ gtk_style_context_restore (context);
}
/* draw the big row-spanning focus rectangle, if needed */
gint grid_line_width;
gboolean wide_separators;
gint separator_height;
+ gint expander_size;
/* double check the row needs validating */
if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) &&
draw_hgrid_lines =
tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_HORIZONTAL
|| tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
+ expander_size = gtk_tree_view_get_expander_size (tree_view);
for (last_column = g_list_last (tree_view->priv->columns);
last_column &&
{
row_height += vertical_separator;
height = MAX (height, row_height);
- height = MAX (height, tree_view->priv->expander_size);
+ height = MAX (height, expander_size);
}
else
{
padding += horizontal_separator + (depth - 1) * tree_view->priv->level_indentation;
if (gtk_tree_view_draw_expanders (tree_view))
- padding += depth * tree_view->priv->expander_size;
+ padding += depth * expander_size;
}
else
padding += horizontal_separator;
}
}
-static void
-gtk_tree_view_bin_process_updates (GtkTreeView *tree_view)
-{
- /* Prior to drawing, we make sure the visible area is validated. */
- if (tree_view->priv->presize_handler_timer)
- {
- g_source_remove (tree_view->priv->presize_handler_timer);
- tree_view->priv->presize_handler_timer = 0;
-
- do_presize_handler (tree_view);
- }
-
- gdk_window_process_updates (tree_view->priv->bin_window, TRUE);
-}
-
static gboolean
scroll_sync_handler (GtkTreeView *tree_view)
{
GtkTreeViewColumn *column = NULL;
GdkRectangle visible_rect;
- GDK_THREADS_ENTER ();
+ gdk_threads_enter ();
tree_view = GTK_TREE_VIEW (data);
}
}
- GDK_THREADS_LEAVE ();
+ gdk_threads_leave ();
return TRUE;
}
for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
if (gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (tmp_list->data)) == focus_child)
{
- tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
+ _gtk_tree_view_set_focus_column (tree_view, GTK_TREE_VIEW_COLUMN (tmp_list->data));
break;
}
gtk_tree_view_set_enable_tree_lines (tree_view, tree_view->priv->tree_lines_enabled);
}
- gtk_widget_style_get (widget,
- "expander-size", &tree_view->priv->expander_size,
- NULL);
- tree_view->priv->expander_size += EXPANDER_EXTRA_PADDING;
-
for (list = tree_view->priv->columns; list; list = list->next)
{
column = list->data;
{
if (gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (list->data)) == child)
{
- tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (list->data);
+ _gtk_tree_view_set_focus_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data));
break;
}
}
GtkTreeView *tree_view = GTK_TREE_VIEW (container);
GtkWidgetPath *path;
gboolean rtl;
- GList *list;
+ GList *list, *visible_columns = NULL;
gint n_col = 0;
path = GTK_CONTAINER_CLASS (gtk_tree_view_parent_class)->get_path_for_child (container, child);
rtl = (gtk_widget_get_direction (GTK_WIDGET (container)) == GTK_TEXT_DIR_RTL);
- for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
- list;
- list = (rtl ? list->prev : list->next))
+ for (list = tree_view->priv->columns; list; list = list->next)
{
GtkTreeViewColumn *column = list->data;
- GtkRegionFlags flags = 0;
- if (!gtk_tree_view_column_get_visible (column))
- continue;
+ if (gtk_tree_view_column_get_visible (column))
+ visible_columns = g_list_prepend (visible_columns, column);
+ }
+
+ if (!rtl)
+ visible_columns = g_list_reverse (visible_columns);
+
+ for (list = visible_columns; list != NULL; list = list->next)
+ {
+ GtkTreeViewColumn *column = list->data;
+ GtkRegionFlags flags = 0;
n_col++;
if (n_col == 1)
flags |= GTK_REGION_FIRST;
- if ((rtl && !list->prev) ||
- (!rtl && !list->next))
+ if (!list->next)
flags |= GTK_REGION_LAST;
- gtk_widget_path_iter_add_region (path, -1, GTK_STYLE_REGION_COLUMN_HEADER, flags);
+ gtk_widget_path_iter_add_region (path, gtk_widget_path_length (path) - 2, GTK_STYLE_REGION_COLUMN_HEADER, flags);
break;
}
-
- gtk_widget_path_append_for_widget (path, child);
+ g_list_free (visible_columns);
return path;
}
if (tree == NULL)
goto done;
+ _gtk_tree_view_accessible_changed (tree_view, tree, node);
+
if (tree_view->priv->fixed_height_mode
&& tree_view->priv->fixed_height >= 0)
{
tmpnode = _gtk_rbtree_insert_after (tree, tmpnode, height, FALSE);
}
+ _gtk_tree_view_accessible_add (tree_view, tree, tmpnode);
+
done:
if (height > 0)
{
goto done;
if (has_child)
- GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PARENT);
+ {
+ GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PARENT);
+ _gtk_tree_view_accessible_add_state (tree_view, tree, node, GTK_CELL_RENDERER_EXPANDABLE);
+ }
else
- GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_PARENT);
+ {
+ GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_PARENT);
+ _gtk_tree_view_accessible_remove_state (tree_view, tree, node, GTK_CELL_RENDERER_EXPANDABLE);
+ }
if (has_child && tree_view->priv->is_list)
{
{
gint *value = (gint *)data;
- *value = GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED);
+ *value |= GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED);
if (node->children && !*value)
_gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, check_selection_helper, data);
gboolean selection_changed = FALSE, cursor_changed = FALSE;
GtkRBTree *cursor_tree = NULL;
GtkRBNode *cursor_node = NULL;
- GtkStyleContext *context;
g_return_if_fail (path != NULL);
/* If the cursor row got deleted, move the cursor to the next row */
if (tree_view->priv->cursor_node &&
(tree_view->priv->cursor_node == node ||
- (node->children && _gtk_rbtree_contains (node->children, tree_view->priv->cursor_tree))))
+ (node->children && (tree_view->priv->cursor_tree == node->children ||
+ _gtk_rbtree_contains (node->children, tree_view->priv->cursor_tree)))))
{
GtkTreePath *cursor_path;
if (tree_view->priv->tree == tree)
tree_view->priv->tree = NULL;
+ _gtk_tree_view_accessible_remove_state (tree_view,
+ tree->parent_tree, tree->parent_node,
+ GTK_CELL_RENDERER_EXPANDED);
_gtk_tree_view_accessible_remove (tree_view, tree, NULL);
_gtk_rbtree_remove (tree);
}
tree_view->priv->top_row = NULL;
}
- /* Cancel any ongoing animation happening within the row */
- context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
- gtk_style_context_cancel_animations (context, node);
-
install_scroll_sync_handler (tree_view);
gtk_widget_queue_resize (GTK_WIDGET (tree_view));
if (cursor_node)
{
GtkTreePath *cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
- tree_view->priv->cursor_node = NULL;
- gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT);
+ gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT | CURSOR_INVALID);
gtk_tree_path_free (cursor_path);
}
else
- gtk_tree_view_real_set_cursor (tree_view, NULL, CLEAR_AND_SELECT);
+ gtk_tree_view_real_set_cursor (tree_view, NULL, CLEAR_AND_SELECT | CURSOR_INVALID);
}
- else if (selection_changed)
+ if (selection_changed)
g_signal_emit_by_name (tree_view->priv->selection, "changed");
}
GList *list;
GtkTreeViewColumn *tmp_column = NULL;
gint total_width;
+ gint expander_size;
gboolean indent_expanders;
gboolean rtl;
rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
+ expander_size = gtk_tree_view_get_expander_size (tree_view);
total_width = 0;
for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
if (gtk_tree_view_is_expander_column (tree_view, tmp_column))
{
if (rtl)
- x_offset = total_width + gtk_tree_view_column_get_width (tmp_column) - tree_view->priv->expander_size;
+ x_offset = total_width + gtk_tree_view_column_get_width (tmp_column) - expander_size;
else
x_offset = total_width;
break;
if (indent_expanders)
{
if (rtl)
- x_offset -= tree_view->priv->expander_size * _gtk_rbtree_get_depth (tree);
+ x_offset -= expander_size * _gtk_rbtree_get_depth (tree);
else
- x_offset += tree_view->priv->expander_size * _gtk_rbtree_get_depth (tree);
+ x_offset += expander_size * _gtk_rbtree_get_depth (tree);
}
*x1 = x_offset;
if (tmp_column &&
gtk_tree_view_column_get_visible (tmp_column))
/* +1 because x2 isn't included in the range. */
- *x2 = *x1 + tree_view->priv->expander_size + 1;
+ *x2 = *x1 + expander_size + 1;
else
*x2 = *x1;
}
path = _gtk_tree_path_new_from_rbtree (tree, node);
if (path)
{
- /* We process updates because we want to clear old selected items when we scroll.
- * if this is removed, we get a "selection streak" at the bottom. */
- gtk_tree_view_bin_process_updates (tree_view);
-
gtk_tree_view_scroll_to_cell (tree_view, path, NULL, FALSE, 0.0, 0.0);
gtk_tree_path_free (path);
}
if (!gtk_tree_model_iter_children (model, &child, iter))
return FALSE;
- retval = retval || gtk_tree_view_unref_tree_helper (model, &child, new_tree, new_node);
+ retval = gtk_tree_view_unref_tree_helper (model, &child, new_tree, new_node) | retval;
}
if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
GtkWidget *button;
GdkDevice *pointer, *keyboard;
+ GdkWindowAttr attributes;
+ guint attributes_mask;
+ GtkStyleContext *context;
g_return_if_fail (tree_view->priv->column_drag_info == NULL);
g_return_if_fail (tree_view->priv->cur_reorder == NULL);
+ g_return_if_fail (tree_view->priv->drag_window == NULL);
gtk_tree_view_set_column_drag_info (tree_view, column);
button = gtk_tree_view_column_get_button (column);
- if (tree_view->priv->drag_window == NULL)
- {
- GdkWindowAttr attributes;
- guint attributes_mask;
+ context = gtk_widget_get_style_context (button);
+ gtk_style_context_add_class (context, STYLE_CLASS_DND);
- gtk_widget_get_allocation (button, &button_allocation);
+ gtk_widget_get_allocation (button, &button_allocation);
- attributes.window_type = GDK_WINDOW_CHILD;
- attributes.wclass = GDK_INPUT_OUTPUT;
- attributes.x = button_allocation.x;
- attributes.y = 0;
- attributes.width = button_allocation.width;
- attributes.height = button_allocation.height;
- attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
- attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
- attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
+ attributes.window_type = GDK_WINDOW_CHILD;
+ attributes.wclass = GDK_INPUT_OUTPUT;
+ attributes.x = button_allocation.x;
+ attributes.y = 0;
+ attributes.width = button_allocation.width;
+ attributes.height = button_allocation.height;
+ attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
+ attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
+ attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
- tree_view->priv->drag_window = gdk_window_new (tree_view->priv->bin_window,
- &attributes,
- attributes_mask);
- gdk_window_set_user_data (tree_view->priv->drag_window, GTK_WIDGET (tree_view));
- }
+ tree_view->priv->drag_window = gdk_window_new (tree_view->priv->header_window,
+ &attributes,
+ attributes_mask);
+ gdk_window_set_user_data (tree_view->priv->drag_window, GTK_WIDGET (tree_view));
if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
{
send_event->button.y = -1;
send_event->button.axes = NULL;
send_event->button.state = 0;
- send_event->button.button = 1;
+ send_event->button.button = GDK_BUTTON_PRIMARY;
send_event->button.x_root = 0;
send_event->button.y_root = 0;
gdk_event_set_device (send_event, device);
gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
rect.x = 0;
- rect.width = MAX (tree_view->priv->expander_size, MAX (tree_view->priv->width, allocation.width));
+ rect.width = gtk_tree_view_get_expander_size (tree_view);
+ rect.width = MAX (rect.width, MAX (tree_view->priv->width, allocation.width));
rect.y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
rect.height = gtk_tree_view_get_row_height (tree_view, node);
return tree_view->priv->tree;
}
+gboolean
+_gtk_tree_view_get_cursor_node (GtkTreeView *tree_view,
+ GtkRBTree **tree,
+ GtkRBNode **node)
+{
+ GtkTreeViewPrivate *priv;
+
+ priv = tree_view->priv;
+
+ if (priv->cursor_node == NULL)
+ return FALSE;
+
+ *tree = priv->cursor_tree;
+ *node = priv->cursor_node;
+
+ return TRUE;
+}
+
GdkWindow *
_gtk_tree_view_get_header_window (GtkTreeView *tree_view)
{
return tree_view->priv->header_window;
}
+GtkTreeViewColumn *
+_gtk_tree_view_get_focus_column (GtkTreeView *tree_view)
+{
+ return tree_view->priv->focus_column;
+}
+
void
_gtk_tree_view_set_focus_column (GtkTreeView *tree_view,
GtkTreeViewColumn *column)
{
+ GtkTreeViewColumn *old_column = tree_view->priv->focus_column;
+
+ if (old_column == column)
+ return;
+
tree_view->priv->focus_column = column;
+
+ _gtk_tree_view_accessible_update_focus_column (tree_view,
+ old_column,
+ column);
}
gint x2;
gint vertical_separator;
gint expander_size;
- GtkCellRendererState flags;
+ GtkCellRendererState flags = 0;
widget = GTK_WIDGET (tree_view);
context = gtk_widget_get_style_context (widget);
gtk_widget_style_get (widget,
- "vertical-separator", &vertical_separator,
- NULL);
- expander_size = tree_view->priv->expander_size - EXPANDER_EXTRA_PADDING;
+ "vertical-separator", &vertical_separator,
+ NULL);
+ expander_size = gtk_tree_view_get_expander_size (tree_view) - EXPANDER_EXTRA_PADDING;
if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
return;
area.height = gtk_tree_view_get_cell_area_height (tree_view, node,
vertical_separator);
- if (!gtk_widget_get_sensitive (widget))
- state |= GTK_STATE_FLAG_INSENSITIVE;
- else
- {
- flags = 0;
+ if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
+ flags |= GTK_CELL_RENDERER_SELECTED;
- if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
- flags |= GTK_CELL_RENDERER_SELECTED;
+ if (node == tree_view->priv->prelight_node &&
+ tree_view->priv->arrow_prelit)
+ flags |= GTK_CELL_RENDERER_PRELIT;
- state = gtk_cell_renderer_get_state (NULL, widget, flags);
-
- if (node == tree_view->priv->prelight_node &&
- tree_view->priv->arrow_prelit)
- state |= GTK_STATE_FLAG_PRELIGHT;
- }
+ state = gtk_cell_renderer_get_state (NULL, widget, flags);
if (node->children != NULL)
state |= GTK_STATE_FLAG_ACTIVE;
+ else
+ state &= ~(GTK_STATE_FLAG_ACTIVE);
gtk_style_context_save (context);
gtk_style_context_set_state (context, state);
gtk_style_context_add_class (context, GTK_STYLE_CLASS_EXPANDER);
- gtk_style_context_push_animatable_region (context, node);
-
gtk_render_expander (context, cr,
area.x, area.y,
area.width, area.height);
- gtk_style_context_pop_animatable_region (context);
gtk_style_context_restore (context);
}
if (selected_rows)
{
cursor_path = gtk_tree_path_copy((const GtkTreePath *)(selected_rows->data));
- g_list_foreach (selected_rows, (GFunc)gtk_tree_path_free, NULL);
- g_list_free (selected_rows);
+ g_list_free_full (selected_rows, (GDestroyNotify) gtk_tree_path_free);
}
else
{
{
GtkCellArea *cell_area;
- tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (list->data);
+ _gtk_tree_view_set_focus_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data));
/* This happens when the treeview initially grabs focus and there
* is no column in focus, here we explicitly focus into the first cell */
cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
if (gtk_cell_area_focus (cell_area, direction))
{
- tree_view->priv->focus_column = column;
+ _gtk_tree_view_set_focus_column (tree_view, column);
found_column = TRUE;
break;
}
{
GtkRBTree *new_tree = NULL;
GtkRBNode *new_node = NULL;
- GtkRBTree *cursor_tree = NULL;
- GtkRBNode *cursor_node = NULL;
GtkTreePath *cursor_path = NULL;
if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
tree_view->priv->cursor_node);
_gtk_tree_selection_internal_select_node (tree_view->priv->selection,
- cursor_node,
- cursor_tree,
+ tree_view->priv->cursor_node,
+ tree_view->priv->cursor_tree,
cursor_path,
GTK_TREE_SELECT_MODE_TOGGLE,
FALSE);
{
if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
{
- GtkStyleContext *context;
gint dy;
gdk_window_move (tree_view->priv->bin_window,
}
gdk_window_scroll (tree_view->priv->bin_window, 0, dy);
- context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
- gtk_style_context_scroll_animations (context, tree_view->priv->bin_window, 0, dy);
-
if (tree_view->priv->dy != (int) gtk_adjustment_get_value (tree_view->priv->vadjustment))
{
/* update our dy and top_row */
if (!tree_view->priv->in_top_row_to_dy)
gtk_tree_view_dy_to_top_row (tree_view);
}
-
- gdk_window_process_updates (tree_view->priv->header_window, TRUE);
- gtk_tree_view_bin_process_updates (tree_view);
}
}
/**
* gtk_tree_view_set_model:
- * @tree_view: A #GtkTreeNode.
+ * @tree_view: A #GtkTreeView.
* @model: (allow-none): The model.
*
* Sets the model for a #GtkTreeView. If the @tree_view already has a model
if (tree_view->priv->model)
{
GList *tmplist = tree_view->priv->columns;
- GtkStyleContext *context;
gtk_tree_view_unref_and_check_selection_tree (tree_view, tree_view->priv->tree);
gtk_tree_view_stop_editing (tree_view, TRUE);
- context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
- gtk_style_context_cancel_animations (context, NULL);
-
g_signal_handlers_disconnect_by_func (tree_view->priv->model,
gtk_tree_view_row_changed,
tree_view);
gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
tree_view->priv->drag_dest_row = NULL;
- tree_view->priv->cursor_tree = NULL;
- tree_view->priv->cursor_node = NULL;
gtk_tree_row_reference_free (tree_view->priv->anchor);
tree_view->priv->anchor = NULL;
gtk_tree_row_reference_free (tree_view->priv->top_row);
{
tree_view->priv->tree = _gtk_rbtree_new ();
gtk_tree_view_build_tree (tree_view, tree_view->priv->tree, &iter, 1, FALSE);
+ _gtk_tree_view_accessible_add (tree_view, tree_view->priv->tree, NULL);
}
gtk_tree_path_free (path);
install_presize_handler (tree_view);
}
+ gtk_tree_view_real_set_cursor (tree_view, NULL, CURSOR_INVALID);
+
g_object_notify (G_OBJECT (tree_view), "model");
if (tree_view->priv->selection)
}
/**
- * gtk_tree_view_set_rules_hint
+ * gtk_tree_view_set_rules_hint:
* @tree_view: a #GtkTreeView
* @setting: %TRUE if the tree requires reading across rows
*
}
/**
- * gtk_tree_view_get_rules_hint
+ * gtk_tree_view_get_rules_hint:
* @tree_view: a #GtkTreeView
*
* Gets the setting set by gtk_tree_view_set_rules_hint().
GtkTreeViewColumn *column = columns->data;
GtkWidget *header_widget;
- if (gtk_tree_view_column_get_visible (column))
+ if (!gtk_tree_view_column_get_visible (column))
continue;
header_widget = gtk_tree_view_column_get_widget (column);
if (!header_widget)
header_widget = gtk_tree_view_column_get_button (column);
- gtk_widget_reset_style (header_widget);
+ _gtk_widget_invalidate_style_context (header_widget, GTK_CSS_CHANGE_PARENT_REGION);
}
}
g_return_val_if_fail (gtk_tree_view_column_get_tree_view (column) == GTK_WIDGET (tree_view), -1);
if (tree_view->priv->focus_column == column)
- tree_view->priv->focus_column = NULL;
+ _gtk_tree_view_set_focus_column (tree_view, NULL);
if (tree_view->priv->edited_column == column)
{
* @dnotify: destroy notifier for @data
*
* Convenience function that inserts a new column into the #GtkTreeView
- * with the given cell renderer and a #GtkCellDataFunc to set cell renderer
+ * with the given cell renderer and a #GtkTreeCellDataFunc to set cell renderer
* attributes (normally using data from the model). See also
* gtk_tree_view_column_set_cell_data_func(), gtk_tree_view_column_pack_start().
* If @tree_view has "fixed_height" mode enabled, then the new column will have its
gtk_tree_path_get_depth (path) + 1,
open_all);
- if (animate)
- {
- GtkStyleContext *context;
-
- context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
-
- gtk_style_context_save (context);
- gtk_style_context_add_class (context, GTK_STYLE_CLASS_EXPANDER);
-
- gtk_style_context_notify_state_change (context, tree_view->priv->bin_window,
- node, GTK_STATE_ACTIVE, TRUE);
-
- _gtk_style_context_invalidate_animation_areas (context);
- gtk_style_context_restore (context);
- }
+ _gtk_tree_view_accessible_add (tree_view, node->children, NULL);
+ _gtk_tree_view_accessible_add_state (tree_view,
+ tree, node,
+ GTK_CELL_RENDERER_EXPANDED);
install_presize_handler (tree_view);
cursor_changed = (node->children == tree_view->priv->cursor_tree)
|| _gtk_rbtree_contains (node->children, tree_view->priv->cursor_tree);
}
+ else
+ cursor_changed = FALSE;
if (gtk_tree_row_reference_valid (tree_view->priv->anchor))
{
tree_view->priv->last_button_y = -1;
_gtk_tree_view_accessible_remove (tree_view, node->children, NULL);
+ _gtk_tree_view_accessible_remove_state (tree_view,
+ tree, node,
+ GTK_CELL_RENDERER_EXPANDED);
_gtk_rbtree_remove (node->children);
- /* if we change the cursor, we also change the selection,
- * so no need to emit selection-changed. */
if (cursor_changed)
- gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT);
- else if (selection_changed)
+ gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CURSOR_INVALID);
+ if (selection_changed)
g_signal_emit_by_name (tree_view->priv->selection, "changed");
- if (animate)
- {
- GtkStyleContext *context;
-
- context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
-
- gtk_style_context_save (context);
- gtk_style_context_add_class (context, GTK_STYLE_CLASS_EXPANDER);
-
- gtk_style_context_notify_state_change (context, tree_view->priv->bin_window,
- node, GTK_STATE_ACTIVE, FALSE);
-
- _gtk_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));
GtkTreePath *path,
SetCursorFlags flags)
{
- if (tree_view->priv->cursor_node)
+ if (!(flags & CURSOR_INVALID) && tree_view->priv->cursor_node)
{
+ _gtk_tree_view_accessible_remove_state (tree_view,
+ tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node,
+ GTK_CELL_RENDERER_FOCUSED);
_gtk_tree_view_queue_draw_node (tree_view,
tree_view->priv->cursor_tree,
tree_view->priv->cursor_node,
* path maps to a non-existing path and we will silently bail out.
* We unset tree and node to avoid further processing.
*/
- if (row_is_separator (tree_view, NULL, path)
+ if (path == NULL ||
+ row_is_separator (tree_view, NULL, path)
|| _gtk_tree_view_find_node (tree_view,
path,
&tree_view->priv->cursor_tree,
tree_view->priv->cursor_node,
NULL);
}
+
+ _gtk_tree_view_accessible_add_state (tree_view,
+ tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node,
+ GTK_CELL_RENDERER_FOCUSED);
}
g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
break;
}
g_return_if_fail (column_in_tree);
- tree_view->priv->focus_column = focus_column;
+ _gtk_tree_view_set_focus_column (tree_view, focus_column);
if (focus_cell)
gtk_tree_view_column_focus_cell (focus_column, focus_cell);
if (start_editing)
GtkRBNode *node,
gint vertical_separator)
{
+ int expander_size = gtk_tree_view_get_expander_size (tree_view);
int height;
/* The "cell" areas are the cell_area passed in to gtk_cell_renderer_render(),
* function will not be called for irregular (e.g. separator) rows.
*/
height = gtk_tree_view_get_row_height (tree_view, node);
- if (height < tree_view->priv->expander_size)
- height = tree_view->priv->expander_size;
+ if (height < expander_size)
+ height = expander_size;
return height - vertical_separator;
}
if (gtk_tree_view_draw_expanders (tree_view))
{
+ int expander_size = gtk_tree_view_get_expander_size (tree_view);
if (!rtl)
- rect->x += depth * tree_view->priv->expander_size;
- rect->width -= depth * tree_view->priv->expander_size;
+ rect->x += depth * expander_size;
+ rect->width -= depth * expander_size;
}
rect->width = MAX (rect->width, 0);
gtk_tree_view_get_row_height (GtkTreeView *tree_view,
GtkRBNode *node)
{
+ int expander_size = gtk_tree_view_get_expander_size (tree_view);
int height;
/* The "background" areas of all rows/cells add up to cover the entire tree.
*/
height = GTK_RBNODE_GET_HEIGHT (node);
if (height <= 0)
- height = tree_view->priv->expander_size;
+ height = expander_size;
return height;
}
GtkRBTree *tree;
GtkRBNode *node;
GtkStyleContext *context;
- GtkStateFlags state;
gint cell_offset;
GList *list;
GdkRectangle background_area;
gtk_style_context_save (context);
- state = gtk_widget_get_state_flags (widget);
- gtk_style_context_set_state (context, state);
-
gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW);
gtk_style_context_add_region (context, GTK_STYLE_REGION_COLUMN, 0);
if (gtk_tree_view_draw_expanders (tree_view))
{
+ int expander_size = gtk_tree_view_get_expander_size (tree_view);
if (!rtl)
- cell_area.x += depth * tree_view->priv->expander_size;
- cell_area.width -= depth * tree_view->priv->expander_size;
+ cell_area.x += depth * expander_size;
+ cell_area.width -= depth * expander_size;
}
}
* This function should almost never be used. It is meant for private use by
* ATK for determining the number of visible children that are removed when the
* user collapses a row, or a row is deleted.
+ *
+ * Deprecated: 3.4: Accessibility does not need the function anymore.
**/
void
gtk_tree_view_set_destroy_count_func (GtkTreeView *tree_view,
GdkRectangle monitor;
monitor_num = gdk_screen_get_monitor_at_window (screen, tree_window);
- gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
+ gdk_screen_get_monitor_workarea (screen, monitor_num, &monitor);
gtk_widget_realize (search_dialog);
* @tree_view: a #GtkTreeView
* @expand: %TRUE to enable hover selection mode
*
- * Enables of disables the hover expansion mode of @tree_view.
+ * Enables or disables the hover expansion mode of @tree_view.
* Hover expansion makes rows expand or collapse if the pointer
* moves over them.
*
projects / ~andy / gtk / blobdiff