#include "gtkbindings.h"
#include "gtkcontainer.h"
#include "gtkentry.h"
+#include "gtktreemodelsort.h"
#include <string.h>
#include <gdk/gdkkeysyms.h>
#define GTK_TREE_VIEW_SEARCH_DIALOG_KEY "gtk-tree-view-search-dialog"
-
+#define GTK_TREE_VIEW_PRIORITY_VALIDATE (GDK_PRIORITY_REDRAW + 5)
+#define GTK_TREE_VIEW_NUM_ROWS_PER_IDLE 50
#define SCROLL_EDGE_SIZE 15
#define EXPANDER_EXTRA_PADDING 4
gint *new_order,
gpointer data);
+/* Incremental reflow */
+static gboolean validate_row (GtkTreeView *tree_view,
+ GtkRBTree *tree,
+ GtkRBNode *node,
+ GtkTreeIter *iter,
+ GtkTreePath *path);
+static void validate_visible_area (GtkTreeView *tree_view);
+static gboolean validate_rows_handler (GtkTreeView *tree_view);
+static gboolean presize_handler_callback (gpointer data);
+static void install_presize_handler (GtkTreeView *tree_view);
/* Internal functions */
gint *x);
static void gtk_tree_view_adjustment_changed (GtkAdjustment *adjustment,
GtkTreeView *tree_view);
-static gint gtk_tree_view_insert_iter_height (GtkTreeView *tree_view,
- GtkRBTree *tree,
- GtkTreeIter *iter,
- gint depth);
static void gtk_tree_view_build_tree (GtkTreeView *tree_view,
GtkRBTree *tree,
GtkTreeIter *iter,
gint depth,
- gboolean recurse,
- gboolean calc_bounds);
-static void gtk_tree_view_calc_size (GtkTreeView *priv,
- GtkRBTree *tree,
- GtkTreeIter *iter,
- gint depth);
+ gboolean recurse);
static gboolean gtk_tree_view_discover_dirty_iter (GtkTreeView *tree_view,
GtkTreeIter *iter,
gint depth,
GtkRBTree *tree,
GtkTreeIter *iter,
gint depth);
-static void gtk_tree_view_check_dirty_and_clean (GtkTreeView *tree_view);
static void gtk_tree_view_clamp_node_visible (GtkTreeView *tree_view,
GtkRBTree *tree,
GtkRBNode *node);
GtkTreeViewColumn *column);
static gboolean gtk_tree_view_maybe_begin_dragging_row (GtkTreeView *tree_view,
GdkEventMotion *event);
-static void _gtk_tree_view_update_col_width (GtkTreeView *tree_view);
static void gtk_tree_view_focus_to_cursor (GtkTreeView *tree_view);
static void gtk_tree_view_move_cursor_up_down (GtkTreeView *tree_view,
gint count);
tree_view->priv->press_start_x = -1;
tree_view->priv->press_start_y = -1;
tree_view->priv->reorderable = FALSE;
+ tree_view->priv->presize_handler_timer = 0;
gtk_tree_view_set_adjustments (tree_view, NULL, NULL);
tree_view->priv->selection = _gtk_tree_selection_new_with_tree_view (tree_view);
- _gtk_tree_view_update_size (tree_view);
tree_view->priv->enable_search = TRUE;
tree_view->priv->search_column = -1;
tree_view->priv->search_dialog_position_func = gtk_tree_view_search_position_func;
}
static void
-gtk_tree_view_get_property (GObject *object,
- guint prop_id,
- GValue *value,
- GParamSpec *pspec)
+gtk_tree_view_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
{
GtkTreeView *tree_view;
tree_view = GTK_TREE_VIEW (widget);
- gtk_tree_view_check_dirty_and_clean (GTK_TREE_VIEW (widget));
GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
/* Make the main, clipping window */
widget->style->black:widget->style->white);
values.function = GDK_XOR;
values.subwindow_mode = GDK_INCLUDE_INFERIORS;
- tree_view->priv->xor_gc = gdk_gc_new_with_values (widget->window,
- &values,
- GDK_GC_FOREGROUND |
- GDK_GC_FUNCTION |
- GDK_GC_SUBWINDOW);
+
/* Add them all up. */
widget->style = gtk_style_attach (widget->style, widget->window);
gdk_window_set_background (widget->window, &widget->style->base[widget->state]);
for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
_gtk_tree_view_column_realize_button (GTK_TREE_VIEW_COLUMN (tmp_list->data));
- _gtk_tree_view_update_size (GTK_TREE_VIEW (widget));
+ install_presize_handler (tree_view);
-if (GTK_WIDGET_CLASS (parent_class)->map)
+ if (GTK_WIDGET_CLASS (parent_class)->map)
(* GTK_WIDGET_CLASS (parent_class)->map) (widget);
}
gtk_timeout_remove (tree_view->priv->expand_collapse_timeout);
tree_view->priv->expand_collapse_timeout = 0;
}
+
+ if (tree_view->priv->presize_handler_timer != 0)
+ {
+ gtk_timeout_remove (tree_view->priv->presize_handler_timer);
+ tree_view->priv->presize_handler_timer = 0;
+ }
for (list = tree_view->priv->columns; list; list = list->next)
_gtk_tree_view_column_unrealize_button (GTK_TREE_VIEW_COLUMN (list->data));
tree_view->priv->drag_highlight_window = NULL;
}
- if (tree_view->priv->xor_gc)
- {
- gdk_gc_destroy (tree_view->priv->xor_gc);
- tree_view->priv->xor_gc = NULL;
- }
-
/* GtkWidget::unrealize destroys children and widget->window */
if (GTK_WIDGET_CLASS (parent_class)->unrealize)
(* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
/* GtkWidget::size_request helper */
static void
-gtk_tree_view_size_request_buttons (GtkTreeView *tree_view)
+gtk_tree_view_size_request_columns (GtkTreeView *tree_view)
{
GList *list;
- tree_view->priv->header_height = 1;
+ tree_view->priv->header_height = 0;
if (tree_view->priv->model)
{
continue;
column = list->data;
-
+
gtk_widget_size_request (column->button, &requisition);
-
- _gtk_tree_view_column_set_width (column, MAX (column->width, requisition.width));
+ column->button_request = requisition.width;
tree_view->priv->header_height = MAX (tree_view->priv->header_height, requisition.height);
}
}
}
+
+static void
+gtk_tree_view_update_size (GtkTreeView *tree_view)
+{
+ GList *list;
+ GtkTreeViewColumn *column;
+ gint i;
+
+ if (tree_view->priv->model == NULL)
+ {
+ tree_view->priv->width = 0;
+ tree_view->priv->height = 0;
+ return;
+ }
+
+ tree_view->priv->width = 0;
+ /* keep this in sync with size_allocate below */
+ for (list = tree_view->priv->columns, i = 0; list; list = list->next, i++)
+ {
+ gint real_requested_width = 0;
+ column = list->data;
+ if (!column->visible)
+ continue;
+
+ if (column->use_resized_width)
+ {
+ real_requested_width = column->resized_width;
+ }
+ else if (column->column_type == GTK_TREE_VIEW_COLUMN_FIXED)
+ {
+ real_requested_width = column->fixed_width;
+ }
+ else if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE))
+ {
+ real_requested_width = MAX (column->requested_width, column->button_request);
+ }
+ else
+ {
+ real_requested_width = column->requested_width;
+ }
+
+ if (column->min_width != -1)
+ real_requested_width = MAX (real_requested_width, column->min_width);
+ if (column->max_width != -1)
+ real_requested_width = MIN (real_requested_width, column->max_width);
+
+ tree_view->priv->width += real_requested_width;
+ }
+
+ if (tree_view->priv->tree == NULL)
+ tree_view->priv->height = 0;
+ else
+ tree_view->priv->height = tree_view->priv->tree->root->offset;
+}
+
static void
gtk_tree_view_size_request (GtkWidget *widget,
GtkRequisition *requisition)
tree_view = GTK_TREE_VIEW (widget);
- gtk_tree_view_size_request_buttons (tree_view);
+ 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 + tree_view->priv->header_height;
/* GtkWidget::size_allocate helper */
static void
-gtk_tree_view_size_allocate_buttons (GtkWidget *widget)
+gtk_tree_view_size_allocate_columns (GtkWidget *widget)
{
GtkTreeView *tree_view;
- GList *list;
+ GList *list, *last_column;
GtkTreeViewColumn *column;
GtkAllocation allocation;
gint width = 0;
tree_view = GTK_TREE_VIEW (widget);
+ for (last_column = g_list_last (tree_view->priv->columns);
+ last_column && !(GTK_TREE_VIEW_COLUMN (last_column->data)->visible);
+ last_column = last_column->prev)
+ ;
+ if (last_column == NULL)
+ return;
+
allocation.y = 0;
allocation.height = tree_view->priv->header_height;
- for (list = tree_view->priv->columns; list != NULL; list = list->next)
+ for (list = tree_view->priv->columns; list != last_column->next; list = list->next)
{
+ gint real_requested_width = 0;
column = list->data;
-
if (!column->visible)
continue;
+ if (column->use_resized_width)
+ {
+ real_requested_width = column->resized_width;
+ }
+ else if (column->column_type == GTK_TREE_VIEW_COLUMN_FIXED)
+ {
+ real_requested_width = column->fixed_width;
+ }
+ else if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE))
+ {
+ real_requested_width = MAX (column->requested_width, column->button_request);
+ }
+ else
+ {
+ real_requested_width = column->requested_width;
+ }
+
+ if (column->min_width != -1)
+ real_requested_width = MAX (real_requested_width, column->min_width);
+ if (column->max_width != -1)
+ real_requested_width = MIN (real_requested_width, column->max_width);
+
allocation.x = width;
+ column->width = real_requested_width;
+ if (list == last_column &&
+ width + real_requested_width < widget->allocation.width)
+ {
+ column->width += (widget->allocation.width - column->width - width);
+ }
+ g_object_notify (G_OBJECT (column), "width");
allocation.width = column->width;
width += column->width;
gtk_widget_size_allocate (column->button, &allocation);
-
if (column->window)
gdk_window_move_resize (column->window,
allocation.x + allocation.width - TREE_VIEW_DRAG_WIDTH/2,
tree_view = GTK_TREE_VIEW (widget);
- gtk_tree_view_check_dirty_and_clean (tree_view);
-
tmp_list = tree_view->priv->children;
while (tmp_list)
MAX (tree_view->priv->width, allocation->width),
tree_view->priv->header_height);
gdk_window_resize (tree_view->priv->bin_window,
- tree_view->priv->width,
+ MAX (tree_view->priv->width, allocation->width),
allocation->height);
- _gtk_tree_view_update_col_width (tree_view);
}
- gtk_tree_view_size_allocate_buttons (widget);
+ gtk_tree_view_size_allocate_columns (widget);
tree_view->priv->hadjustment->page_size = allocation->width;
tree_view->priv->hadjustment->page_increment = allocation->width;
}
tree_view->priv->scroll_to_column = NULL;
}
-
}
static gboolean
gtk_grab_add (widget);
GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_IN_COLUMN_RESIZE);
+ column->resized_width = column->width;
+ column->use_resized_width = TRUE;
/* block attached dnd signal handler */
drag_data = gtk_object_get_data (GTK_OBJECT (widget), "gtk-site-data");
tree_view->priv->drag_pos = i;
tree_view->priv->x_drag = (column->button->allocation.x + column->button->allocation.width);
+ break;
}
}
return TRUE;
{
GtkTreeView *tree_view;
gpointer drag_data;
- gint width;
gint x;
gint i;
gtk_grab_remove (widget);
gdk_pointer_ungrab (event->time);
- width = gtk_tree_view_new_column_width (GTK_TREE_VIEW (widget), i, &x);
- _gtk_tree_view_column_set_width (gtk_tree_view_get_column (GTK_TREE_VIEW (widget), i), width);
-
return TRUE;
}
{
gint x;
gint new_width;
+ GtkTreeViewColumn *column;
+
+ column = gtk_tree_view_get_column (GTK_TREE_VIEW (widget), GTK_TREE_VIEW (widget)->priv->drag_pos);
if (event->is_hint || event->window != widget->window)
gtk_widget_get_pointer (widget, &x, NULL);
new_width = gtk_tree_view_new_column_width (GTK_TREE_VIEW (widget),
GTK_TREE_VIEW (widget)->priv->drag_pos, &x);
- if (x != GTK_TREE_VIEW (widget)->priv->x_drag)
- _gtk_tree_view_column_set_width (gtk_tree_view_get_column (GTK_TREE_VIEW (widget), GTK_TREE_VIEW (widget)->priv->drag_pos), new_width);
+ if (x != GTK_TREE_VIEW (widget)->priv->x_drag &&
+ (new_width != column->fixed_width));
+ {
+ column->resized_width = new_width;
+ gtk_widget_queue_resize (widget);
+ }
- /* FIXME: Do we need to scroll */
- _gtk_tree_view_update_size (GTK_TREE_VIEW (widget));
return FALSE;
}
return TRUE;
}
- gtk_tree_view_check_dirty_and_clean (GTK_TREE_VIEW (widget));
-
- new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->area.y);
+ validate_visible_area (tree_view);
+
+ new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, event->area.y);
if (new_y < 0)
new_y = 0;
y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
return FALSE;
}
-/* Incremental Reflow */
+
+/* Incremental Reflow
+ */
+
+/* Returns TRUE if it updated the size
+ */
+static gboolean
+validate_row (GtkTreeView *tree_view,
+ GtkRBTree *tree,
+ GtkRBNode *node,
+ GtkTreeIter *iter,
+ GtkTreePath *path)
+{
+ GtkTreeViewColumn *column;
+ GList *list;
+ gint height = 0;
+ gint horizontal_separator;
+ gint depth = gtk_tree_path_get_depth (path);
+ gboolean retval = FALSE;
+
+
+ /* double check the row needs validating */
+ if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) &&
+ ! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
+ return FALSE;
+
+ gtk_widget_style_get (GTK_WIDGET (tree_view),
+ "horizontal_separator", &horizontal_separator,
+ NULL);
+
+ for (list = tree_view->priv->columns; list; list = list->next)
+ {
+ gint tmp_width;
+ gint tmp_height;
+
+ column = list->data;
+
+ if (! column->visible)
+ continue;
+
+ if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID) && !column->dirty)
+ continue;
+
+ if (column->column_type == GTK_TREE_VIEW_COLUMN_FIXED)
+ continue;
+
+ 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);
+ height = MAX (height, tmp_height);
+
+ if (gtk_tree_view_is_expander_column (tree_view, column) && TREE_VIEW_DRAW_EXPANDERS (tree_view))
+ tmp_width = tmp_width + horizontal_separator + depth * tree_view->priv->tab_offset;
+ else
+ tmp_width = tmp_width + horizontal_separator;
+
+ if (tmp_width > column->requested_width)
+ {
+ retval = TRUE;
+ column->requested_width = tmp_width;
+ }
+ }
+
+ if (height != GTK_RBNODE_GET_HEIGHT (node))
+ {
+ retval = TRUE;
+ _gtk_rbtree_node_set_height (tree, node, height);
+ }
+ _gtk_rbtree_node_mark_valid (tree, node);
+
+ return retval;
+}
+
static void
validate_visible_area (GtkTreeView *tree_view)
{
+ GtkTreePath *path;
+ GtkTreeIter iter;
+ GtkRBTree *tree;
+ GtkRBNode *node;
+ gint y, height, offset;
+ gboolean validated_area = FALSE;
+
+
+ if (tree_view->priv->tree == NULL)
+ return;
+
+ if (! GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
+ return;
+
+
+ height = GTK_WIDGET (tree_view)->allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view);
+
+ y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, TREE_VIEW_HEADER_HEIGHT (tree_view));
+
+ offset = _gtk_rbtree_find_offset (tree_view->priv->tree, y,
+ &tree, &node);
+ if (node == NULL)
+ {
+ path = gtk_tree_path_new_root ();
+ _gtk_tree_view_find_node (tree_view, path, &tree, &node);
+ }
+ else
+ {
+ path = _gtk_tree_view_find_path (tree_view, tree, node);
+ height += offset;
+ }
+
+ gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
+ do
+ {
+ validated_area = validate_row (tree_view, tree, node, &iter, path) || validated_area;
+ height -= GTK_RBNODE_GET_HEIGHT (node);
+ if (node->children)
+ {
+ GtkTreeIter parent = iter;
+ gboolean has_child;
+ tree = node->children;
+ node = tree->root;
+
+ g_assert (node != tree->nil);
+
+ while (node->left != tree->nil)
+ node = node->left;
+ has_child = gtk_tree_model_iter_children (tree_view->priv->model,
+ &iter,
+ &parent);
+ TREE_VIEW_INTERNAL_ASSERT_VOID (has_child);
+ gtk_tree_path_append_index (path, 0);
+ }
+ else
+ {
+ gboolean done = FALSE;
+ do
+ {
+ node = _gtk_rbtree_next (tree, node);
+ if (node != NULL)
+ {
+ gboolean has_next = gtk_tree_model_iter_next (tree_view->priv->model, &iter);
+ done = TRUE;
+
+ /* Sanity Check! */
+ TREE_VIEW_INTERNAL_ASSERT_VOID (has_next);
+ }
+ else
+ {
+ GtkTreeIter parent_iter = iter;
+ gboolean has_parent;
+
+ node = tree->parent_node;
+ tree = tree->parent_tree;
+ if (tree == NULL)
+ break;
+ has_parent = gtk_tree_model_iter_parent (tree_view->priv->model,
+ &iter,
+ &parent_iter);
+
+ /* Sanity check */
+ TREE_VIEW_INTERNAL_ASSERT_VOID (has_parent);
+ }
+ }
+ while (!done);
+ }
+ }
+ while (node && height > 0);
+
+ if (validated_area)
+ gtk_widget_queue_resize (GTK_WIDGET (tree_view));
}
+/* Our strategy for finding nodes to validate is a little convoluted. We find
+ * the left-most uninvalidated node. We then try walking right, validating
+ * nodes. Once we find a valid node, we repeat the previous process of finding
+ * the first invalid node.
+ */
+
static gboolean
validate_rows_handler (GtkTreeView *tree_view)
{
+ GtkRBTree *tree = NULL;
+ GtkRBNode *node = NULL;
+ gboolean validated_area = FALSE;
+ gint retval = TRUE;
+ GtkTreePath *path = NULL;
+ GtkTreeIter iter;
+ gint i = 0;
g_assert (tree_view);
+ g_return_val_if_fail (tree_view->priv->tree != NULL, FALSE);
- g_return_val_if_fail (tree_view->priv->tree != NULL, TRUE);
+ GDK_THREADS_ENTER ();
- if (! GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
- return TRUE;
+ do
+ {
+
+ if (! GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
+ {
+ retval = FALSE;
+ goto done;
+ }
+
+ if (path != NULL)
+ {
+ node = _gtk_rbtree_next (tree, node);
+ if (node != NULL)
+ {
+ TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_next (tree_view->priv->model, &iter), FALSE);
+ gtk_tree_path_next (path);
+ }
+ else
+ {
+ gtk_tree_path_free (path);
+ path = NULL;
+ }
+ }
+
+ if (path == NULL)
+ {
+ tree = tree_view->priv->tree;
+ node = tree_view->priv->tree->root;
+
+ g_assert (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_DESCENDANTS_INVALID));
+
+ do
+ {
+ if (node->left != tree->nil &&
+ GTK_RBNODE_FLAG_SET (node->left, GTK_RBNODE_DESCENDANTS_INVALID))
+ {
+ node = node->left;
+ }
+ else if (node->right != tree->nil &&
+ GTK_RBNODE_FLAG_SET (node->right, GTK_RBNODE_DESCENDANTS_INVALID))
+ {
+ node = node->right;
+ }
+ else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
+ GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
+ {
+ break;
+ }
+ else
+ {
+ tree = node->children;
+ node = tree->root;
+ }
+ }
+ while (TRUE);
+ path = _gtk_tree_view_find_path (tree_view, tree, node);
+ gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
+ }
+ validated_area = validate_row (tree_view, tree, node, &iter, path) | validated_area;
+ i++;
+ }
+ while (i < GTK_TREE_VIEW_NUM_ROWS_PER_IDLE);
+
+ done:
+ if (path) gtk_tree_path_free (path);
+ if (validated_area)
+ gtk_widget_queue_resize (GTK_WIDGET (tree_view));
+ if (! retval)
+ tree_view->priv->validate_rows_timer = 0;
+ GDK_THREADS_LEAVE ();
- return TRUE;
+ return retval;
}
static gboolean
presize_handler_callback (gpointer data)
{
+ GtkTreeView *tree_view = GTK_TREE_VIEW (data);
- return TRUE;
+ GDK_THREADS_ENTER ();
+
+ if (tree_view->priv->mark_rows_col_dirty)
+ {
+ _gtk_rbtree_column_invalid (tree_view->priv->tree);
+ tree_view->priv->mark_rows_col_dirty = FALSE;
+ }
+ validate_visible_area (tree_view);
+ tree_view->priv->presize_handler_timer = 0;
+
+ GDK_THREADS_LEAVE ();
+
+ return FALSE;
}
static void
install_presize_handler (GtkTreeView *tree_view)
{
+ if (! tree_view->priv->presize_handler_timer)
+ {
+ tree_view->priv->presize_handler_timer =
+ g_idle_add_full (GTK_PRIORITY_RESIZE - 2, presize_handler_callback, tree_view, NULL);
+ }
+ if (! tree_view->priv->validate_rows_timer)
+ {
+ tree_view->priv->validate_rows_timer =
+ g_idle_add_full (GTK_TREE_VIEW_PRIORITY_VALIDATE, (GSourceFunc) validate_rows_handler, tree_view, NULL);
+ }
+}
+
+
+void
+_gtk_tree_view_install_mark_rows_col_dirty (GtkTreeView *tree_view)
+{
+ tree_view->priv->mark_rows_col_dirty = TRUE;
+ install_presize_handler (tree_view);
}
/* Drag-and-drop */
static void
gtk_tree_view_row_changed (GtkTreeModel *model,
- GtkTreePath *path,
- GtkTreeIter *iter,
- gpointer data)
+ GtkTreePath *path,
+ GtkTreeIter *iter,
+ gpointer data)
{
GtkTreeView *tree_view = (GtkTreeView *)data;
GtkRBTree *tree;
GtkRBNode *node;
- gint height;
- gboolean dirty_marked;
gboolean free_path = FALSE;
gint vertical_separator;
-
+ GList *list;
g_return_if_fail (path != NULL || iter != NULL);
if (tree == NULL)
goto done;
- dirty_marked = gtk_tree_view_discover_dirty_iter (tree_view,
- iter,
- gtk_tree_path_get_depth (path),
- &height,
- node);
-
- if (height != -1 &&
- GTK_RBNODE_GET_HEIGHT (node) != height + vertical_separator)
- {
- _gtk_rbtree_node_set_height (tree, node, height + vertical_separator);
- gtk_widget_queue_resize (GTK_WIDGET (data));
- _gtk_tree_view_update_size (tree_view);
- goto done;
- }
- if (dirty_marked)
- {
- gtk_widget_queue_resize (GTK_WIDGET (data));
- }
- else
+ _gtk_rbtree_node_mark_invalid (tree, node);
+ for (list = tree_view->priv->columns; list; list = list->next)
{
- gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
+ GtkTreeViewColumn *column;
+
+ column = list->data;
+ if (! column->visible)
+ continue;
+
+ if (column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
+ {
+ gtk_tree_view_column_cell_set_dirty (column);
+ }
}
+ install_presize_handler (tree_view);
done:
if (free_path)
gint *indices;
GtkRBTree *tmptree, *tree;
GtkRBNode *tmpnode = NULL;
- gint max_height;
gint depth;
gint i = 0;
gboolean free_path = FALSE;
- if (tree_view->priv->tree == NULL)
- tree_view->priv->tree = _gtk_rbtree_new ();
-
- tmptree = tree = tree_view->priv->tree;
g_return_if_fail (path != NULL || iter != NULL);
if (path == NULL)
else if (iter == NULL)
gtk_tree_model_get_iter (model, iter, path);
+ if (tree_view->priv->tree == NULL)
+ tree_view->priv->tree = _gtk_rbtree_new ();
+
+ tmptree = tree = tree_view->priv->tree;
+
/* Update all row-references */
gtk_tree_row_reference_inserted (G_OBJECT (data), path);
depth = gtk_tree_path_get_depth (path);
/* ref the node */
gtk_tree_model_ref_node (tree_view->priv->model, iter);
- max_height = gtk_tree_view_insert_iter_height (tree_view,
- tree,
- iter,
- depth);
if (indices[depth - 1] == 0)
{
tmpnode = _gtk_rbtree_find_count (tree, 1);
- _gtk_rbtree_insert_before (tree, tmpnode, max_height);
+ _gtk_rbtree_insert_before (tree, tmpnode, 0, FALSE);
}
else
{
tmpnode = _gtk_rbtree_find_count (tree, indices[depth - 1]);
- _gtk_rbtree_insert_after (tree, tmpnode, max_height);
+ _gtk_rbtree_insert_after (tree, tmpnode, 0, FALSE);
}
-
- _gtk_tree_view_update_size (tree_view);
+ install_presize_handler (tree_view);
done:
if (free_path)
gtk_tree_path_free (path);
}
-#include "gtktreemodelsort.h"
+
static void
gtk_tree_view_row_has_child_toggled (GtkTreeModel *model,
GtkTreePath *path,
_gtk_rbtree_remove_node (tree, node);
}
- _gtk_tree_view_update_size (GTK_TREE_VIEW (data));
+ gtk_widget_queue_resize (GTK_WIDGET (tree_view));
if (selection_changed)
g_signal_emit_by_name (G_OBJECT (tree_view->priv->selection), "changed");
}
}
-static gint
-gtk_tree_view_insert_iter_height (GtkTreeView *tree_view,
- GtkRBTree *tree,
- GtkTreeIter *iter,
- gint depth)
-{
- GtkTreeViewColumn *column;
- GList *list;
- gint max_height = 0;
- gint vertical_separator;
-
- gtk_widget_style_get (GTK_WIDGET (tree_view), "vertical_separator", &vertical_separator, NULL);
-
- /* do stuff with node */
- for (list = tree_view->priv->columns; list; list = list->next)
- {
- gint height = 0, width = 0;
- column = list->data;
-
- if (!column->visible)
- continue;
-
- if (column->column_type == GTK_TREE_VIEW_COLUMN_FIXED)
- continue;
-
- gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, iter,
- gtk_tree_model_iter_has_child (tree_view->priv->model, iter),
- FALSE);
-
- gtk_tree_view_column_cell_get_size (column, NULL, NULL, NULL, &width, &height);
- max_height = MAX (max_height, vertical_separator + height);
-
- if (gtk_tree_view_is_expander_column (tree_view, column) &&
- TREE_VIEW_DRAW_EXPANDERS (tree_view))
- _gtk_tree_view_column_set_width (column,
- MAX (column->width, depth * tree_view->priv->tab_offset + width));
- else
- _gtk_tree_view_column_set_width (column,
- MAX (column->width, width));
- }
- return max_height;
-}
-
static void
gtk_tree_view_build_tree (GtkTreeView *tree_view,
GtkRBTree *tree,
GtkTreeIter *iter,
gint depth,
- gboolean recurse,
- gboolean calc_bounds)
+ gboolean recurse)
{
GtkRBNode *temp = NULL;
- gint max_height;
do
{
- max_height = 0;
- if (calc_bounds)
- max_height = gtk_tree_view_insert_iter_height (tree_view,
- tree,
- iter,
- depth);
-
gtk_tree_model_ref_node (tree_view->priv->model, iter);
- temp = _gtk_rbtree_insert_after (tree, temp, max_height);
+ temp = _gtk_rbtree_insert_after (tree, temp, 0, FALSE);
if (recurse)
{
GtkTreeIter child;
temp->children = _gtk_rbtree_new ();
temp->children->parent_tree = tree;
temp->children->parent_node = temp;
- gtk_tree_view_build_tree (tree_view, temp->children, &child, depth + 1, recurse, calc_bounds);
+ gtk_tree_view_build_tree (tree_view, temp->children, &child, depth + 1, recurse);
}
}
if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter))
while (gtk_tree_model_iter_next (tree_view->priv->model, iter));
}
-static void
-gtk_tree_view_calc_size (GtkTreeView *tree_view,
- GtkRBTree *tree,
- GtkTreeIter *iter,
- gint depth)
-{
- GtkRBNode *temp;
- GtkTreeIter child;
- GList *list;
- GtkTreeViewColumn *column;
- gint max_height;
- gint vertical_separator;
- gint horizontal_separator;
- TREE_VIEW_INTERNAL_ASSERT_VOID (tree != NULL);
-
- gtk_widget_style_get (GTK_WIDGET (tree_view),
- "vertical_separator", &vertical_separator,
- "horizontal_separator", &horizontal_separator,
- NULL);
-
- temp = tree->root;
- while (temp->left != tree->nil)
- temp = temp->left;
-
- do
- {
- max_height = 0;
- /* Do stuff with node */
- for (list = tree_view->priv->columns; list; list = list->next)
- {
- gint height = 0, width = 0;
- column = list->data;
-
- if (!column->visible)
- continue;
-
- gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, iter,
- GTK_RBNODE_FLAG_SET (temp, GTK_RBNODE_IS_PARENT),
- temp->children?TRUE:FALSE);
- gtk_tree_view_column_cell_get_size (column, NULL, NULL, NULL, &width, &height);
- max_height = MAX (max_height, vertical_separator + height);
-
- /* FIXME: I'm getting the width of all nodes here. )-: */
- if (column->dirty == FALSE)
- continue;
-
- if (column->column_type == GTK_TREE_VIEW_COLUMN_FIXED)
- {
- continue;
- }
- if (gtk_tree_view_is_expander_column (tree_view, column) &&
- TREE_VIEW_DRAW_EXPANDERS (tree_view))
- _gtk_tree_view_column_set_width (column,
- MAX (column->width, depth * tree_view->priv->tab_offset + width + horizontal_separator));
- else
- _gtk_tree_view_column_set_width (column, MAX (column->width, width + horizontal_separator));
- }
-
- _gtk_rbtree_node_set_height (tree, temp, max_height);
-
- if (temp->children != NULL &&
- gtk_tree_model_iter_children (tree_view->priv->model, &child, iter))
- gtk_tree_view_calc_size (tree_view, temp->children, &child, depth + 1);
- temp = _gtk_rbtree_next (tree, temp);
- }
- while (gtk_tree_model_iter_next (tree_view->priv->model, iter));
-}
-
/* If height is non-NULL, then we set it to be the new height. if it's all
* dirty, then height is -1. We know we'll remeasure dirty rows, anyways.
*/
}
-/**
- * gtk_tree_view_check_dirty_and_clean:
- * @tree_view: A #GtkTreeView
- *
- * Does all the actual sizing for
- **/
-static void
-gtk_tree_view_check_dirty_and_clean (GtkTreeView *tree_view)
-{
- GtkTreePath *path;
- gboolean dirty = FALSE;
- GList *list;
- GtkTreeViewColumn *column;
- GtkTreeIter iter;
-
- for (list = tree_view->priv->columns; list; list = list->next)
- {
- column = list->data;
- if (column->dirty)
- {
- dirty = TRUE;
- if (column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
- {
- gint w = 1;
-
- if (column->button)
- w = MAX (w, column->button->requisition.width);
-
- _gtk_tree_view_column_set_width (column, w);
- }
- }
- }
-
- if (dirty == FALSE)
- return;
-
- if (tree_view->priv->model == NULL)
- return;
-
- path = gtk_tree_path_new_root ();
- if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, path))
- {
- gtk_tree_view_calc_size (tree_view, tree_view->priv->tree, &iter, 1);
- _gtk_tree_view_update_size (tree_view);
- }
-
- gtk_tree_path_free (path);
-
- for (list = tree_view->priv->columns; list; list = list->next)
- {
- column = list->data;
- column->dirty = FALSE;
- }
-}
-
/* Make sure the node is visible vertically */
static void
gtk_tree_view_clamp_node_visible (GtkTreeView *tree_view,
{
GList *list;
+ if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IS_LIST))
+ return FALSE;
+
if (tree_view->priv->expander_column != NULL)
{
if (tree_view->priv->expander_column == column)
rect.y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node);
rect.height = BACKGROUND_HEIGHT (node);
+ // g_print ("gtk_tree_view_queue_draw_node: (%d %d) (%d %d)\n", rect.x, rect.y, rect.width, rect.height);
if (clip_rect)
{
expander_style);
}
-
-static void
-_gtk_tree_view_update_col_width (GtkTreeView *tree_view)
-{
- GList *list, *last_column;
- GtkTreeViewColumn *column;
- gint width = 0;
-
- for (last_column = g_list_last (tree_view->priv->columns);
- last_column &&
- !(GTK_TREE_VIEW_COLUMN (last_column->data)->visible) &&
- GTK_WIDGET_CAN_FOCUS (GTK_TREE_VIEW_COLUMN (last_column->data)->button);
- last_column = last_column->prev)
- ;
-
- if (last_column == NULL)
- return;
-
- for (list = tree_view->priv->columns; list != last_column; list = list->next)
- {
- column = GTK_TREE_VIEW_COLUMN (list->data);
- if (! column->visible)
- continue;
-
- width += column->width;
- column->width = (CLAMP (column->width, (column->min_width!=-1)?column->min_width:column->width, (column->max_width!=-1)?column->max_width:column->width));
- }
- column = GTK_TREE_VIEW_COLUMN (last_column->data);
- column->width = MAX (GTK_WIDGET (tree_view)->allocation.width, tree_view->priv->width) - width;
-}
-
static void
gtk_tree_view_focus_to_cursor (GtkTreeView *tree_view)
gtk_tree_view_search_init (entry, tree_view);
}
-void
-_gtk_tree_view_update_size (GtkTreeView *tree_view)
-{
- gint width, height;
- GList *list;
- GtkTreeViewColumn *column;
- gint vertical_separator;
- gint i;
-
- gtk_widget_style_get (GTK_WIDGET (tree_view), "vertical_separator", &vertical_separator, NULL);
-
- if (tree_view->priv->model == NULL)
- {
- tree_view->priv->width = 0;
- tree_view->priv->height = 0;
- gtk_widget_queue_draw (GTK_WIDGET (tree_view));
- return;
- }
-
- width = 0;
- for (list = tree_view->priv->columns, i = 0; list; list = list->next, i++)
- {
- column = list->data;
- if (!column->visible)
- continue;
- width += TREE_VIEW_COLUMN_WIDTH (column);
- }
-
- if (tree_view->priv->tree == NULL)
- height = 0;
- else
- height = tree_view->priv->tree->root->offset + vertical_separator;
-
- if (tree_view->priv->width != width)
- {
- tree_view->priv->width = width;
- tree_view->priv->hadjustment->upper = width;
- gtk_signal_emit_by_name (GTK_OBJECT (tree_view->priv->hadjustment), "changed");
- }
-
- if (tree_view->priv->height != height)
- {
- tree_view->priv->height = height;
- tree_view->priv->vadjustment->upper = tree_view->priv->height;
- gtk_signal_emit_by_name (GTK_OBJECT (tree_view->priv->vadjustment), "changed");
- }
-
- if (GTK_WIDGET_REALIZED (tree_view))
- {
- gdk_window_resize (tree_view->priv->bin_window, MAX (width, GTK_WIDGET (tree_view)->allocation.width), height + TREE_VIEW_HEADER_HEIGHT (tree_view));
- gdk_window_resize (tree_view->priv->header_window, MAX (width, GTK_WIDGET (tree_view)->allocation.width), tree_view->priv->header_height);
-
- _gtk_tree_view_update_col_width (tree_view);
- }
-
- gtk_widget_queue_resize (GTK_WIDGET (tree_view));
-}
-
/* this function returns the new width of the column being resized given
* the column and x position of the cursor; the x cursor position is passed
* in as a pointer and automagicly corrected if it's beyond min/max limits
if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, path))
{
tree_view->priv->tree = _gtk_rbtree_new ();
- gtk_tree_view_build_tree (tree_view, tree_view->priv->tree, &iter, 1, FALSE, GTK_WIDGET_REALIZED (tree_view));
+ gtk_tree_view_build_tree (tree_view, tree_view->priv->tree, &iter, 1, FALSE);
}
gtk_tree_path_free (path);
/* FIXME: do I need to do this? gtk_tree_view_create_buttons (tree_view); */
}
- if (GTK_WIDGET_REALIZED (tree_view))
- _gtk_tree_view_update_size (tree_view);
g_object_notify (G_OBJECT (tree_view), "model");
+
+ if (GTK_WIDGET_REALIZED (tree_view))
+ gtk_widget_queue_resize (GTK_WIDGET (tree_view));
}
/**
if (GTK_WIDGET_REALIZED (tree_view))
{
- /*gtk_widget_queue_resize (GTK_WIDGET (tree_view)); */
- _gtk_tree_view_update_size (tree_view);
- gtk_tree_view_size_allocate_buttons (GTK_WIDGET (tree_view));
+ gtk_widget_queue_resize (GTK_WIDGET (tree_view));
+ gtk_tree_view_size_allocate_columns (GTK_WIDGET (tree_view));
}
g_signal_emit (G_OBJECT (tree_view), tree_view_signals[COLUMNS_CHANGED], 0);
node->children,
&child,
gtk_tree_path_get_depth (path) + 1,
- TRUE,
- GTK_WIDGET_REALIZED (tree_view));
+ TRUE);
gtk_tree_path_free (path);
}
}
G_PRE_ORDER,
gtk_tree_view_expand_all_helper,
tree_view);
-
- _gtk_tree_view_update_size (tree_view);
}
/* Timeout to animate the expander during expands and collapses */
node->children,
&temp,
gtk_tree_path_get_depth (path) + 1,
- open_all,
- GTK_WIDGET_REALIZED (tree_view));
+ open_all);
if (tree_view->priv->expand_collapse_timeout)
{
}
if (GTK_WIDGET_MAPPED (tree_view))
- {
- gtk_widget_queue_draw (GTK_WIDGET (tree_view));
- _gtk_tree_view_update_size (tree_view);
- }
+ install_presize_handler (tree_view);
g_signal_emit (G_OBJECT (tree_view), tree_view_signals[ROW_EXPANDED], 0, &iter, path);
return TRUE;
if (GTK_WIDGET_MAPPED (tree_view))
{
- gtk_widget_queue_draw (GTK_WIDGET (tree_view));
- _gtk_tree_view_update_size (tree_view);
+ gtk_widget_queue_resize (GTK_WIDGET (tree_view));
}
if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
gtk_cell_editable_editing_done (tree_view->priv->edited_column->editable_widget);
gtk_cell_editable_remove_widget (tree_view->priv->edited_column->editable_widget);
}
-
tree_column->requested_width = -1;
tree_column->min_width = -1;
tree_column->max_width = -1;
+ tree_column->resized_width = 0;
tree_column->column_type = GTK_TREE_VIEW_COLUMN_GROW_ONLY;
tree_column->visible = TRUE;
tree_column->resizable = FALSE;
tree_column->sort_column_id = -1;
tree_column->reorderable = FALSE;
tree_column->maybe_reordered = FALSE;
+ tree_column->use_resized_width = FALSE;
}
static void
g_value_get_boolean (value));
break;
+ case PROP_RESIZABLE:
+ gtk_tree_view_column_set_resizable (tree_column,
+ g_value_get_boolean (value));
+ break;
+
case PROP_SIZING:
gtk_tree_view_column_set_sizing (tree_column,
g_value_get_enum (value));
gtk_tree_view_column_get_visible (tree_column));
break;
+ case PROP_RESIZABLE:
+ g_value_set_boolean (value,
+ gtk_tree_view_column_get_resizable (tree_column));
+ break;
+
case PROP_WIDTH:
g_value_set_int (value,
gtk_tree_view_column_get_width (tree_column));
}
}
}
-
- gtk_tree_view_column_cell_set_dirty (tree_column);
}
/* Button signal handlers
static void
gtk_tree_view_model_sort_column_changed (GtkTreeSortable *sortable,
- GtkTreeViewColumn *column)
+ GtkTreeViewColumn *column)
{
gint sort_column_id;
GtkSortType order;
column->button = NULL;
}
-void
-_gtk_tree_view_column_set_width (GtkTreeViewColumn *tree_column,
- gint width)
-{
- if (tree_column->min_width != -1 &&
- width <= tree_column->min_width)
- width = tree_column->min_width;
- else if (tree_column->max_width != -1 &&
- width > tree_column->max_width)
- width = tree_column->max_width;
-
- if (tree_column->width == width)
- return;
-
- tree_column->width = width;
-
- g_object_notify (G_OBJECT (tree_column), "width");
-
- if (tree_column->tree_view != NULL)
- gtk_widget_queue_resize (tree_column->tree_view);
-
-}
-
/* Public Functions */
}
+/**
+ * gtk_tree_view_column_clear:
+ * @tree_column: A #GtkTreeViewColumn
+ *
+ * Unsets all the mappings on all renderers on the @tree_column.
+ **/
void
gtk_tree_view_column_clear (GtkTreeViewColumn *tree_column)
{
tree_column->cell_list = NULL;
}
+/**
+ * gtk_tree_view_column_get_cell_renderers:
+ * @tree_column: A #GtkTreeViewColumn
+ *
+ * Returns a newly allocated #GList of all the cell renderers in the column, in no
+ * particular order. The list must be freed with g_list_free()
+ *
+ * Return value: A list of #GtkCellRenderers
+ **/
GList *
gtk_tree_view_column_get_cell_renderers (GtkTreeViewColumn *tree_column)
{
if (tree_column->resizable == resizable)
return;
+ tree_column->resizable = resizable;
+
if (resizable && tree_column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
gtk_tree_view_column_set_sizing (tree_column, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
return;
tree_column->fixed_width = fixed_width;
- tree_column->requested_width = fixed_width;
- _gtk_tree_view_column_set_width (tree_column, fixed_width);
+
+ if (tree_column->tree_view &&
+ GTK_WIDGET_REALIZED (tree_column->tree_view) &&
+ tree_column->column_type == GTK_TREE_VIEW_COLUMN_FIXED)
+ {
+ gtk_widget_queue_resize (tree_column->tree_view);
+ }
}
/**
* gtk_tree_view_column_get_fixed_width:
* @tree_column: a #GtkTreeViewColumn
*
- * Gets the fixed width of the column. This value is only meaning may not be the
- * actual width of the column on the screen, just what is requested.
+ * Gets the fixed width of the column. This value is only meaning may not be
+ * the actual width of the column on the screen, just what is requested.
*
* Return value: the fixed width of the column
**/
gtk_tree_view_column_set_min_width (GtkTreeViewColumn *tree_column,
gint min_width)
{
- gint real_min_width;
-
g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
g_return_if_fail (min_width >= -1);
if (min_width == tree_column->min_width)
return;
- if (tree_column->tree_view == NULL)
- {
- tree_column->min_width = min_width;
- return;
- }
-
- real_min_width = (tree_column->min_width == -1) ?
- tree_column->button->requisition.width : tree_column->min_width;
-
- /* We want to queue a resize if the either the old min_size or the
- * new min_size determined the size of the column */
- if (GTK_WIDGET_REALIZED (tree_column->tree_view))
+ if (tree_column->visible &&
+ tree_column->tree_view != NULL &&
+ GTK_WIDGET_REALIZED (tree_column->tree_view))
{
- if ((tree_column->min_width > tree_column->width) ||
- (tree_column->min_width == -1 &&
- tree_column->button->requisition.width > tree_column->width) ||
- (min_width > tree_column->width) ||
- (min_width == -1 &&
- tree_column->button->requisition.width > tree_column->width))
+ if (min_width > tree_column->width)
gtk_widget_queue_resize (tree_column->tree_view);
}
- if (tree_column->max_width != -1 && tree_column->max_width < real_min_width)
- tree_column->max_width = real_min_width;
-
tree_column->min_width = min_width;
-
+ if (tree_column->max_width != -1 && tree_column->max_width < min_width)
+ {
+ tree_column->max_width = min_width;
+ g_object_notify (G_OBJECT (tree_column), "max_width");
+ }
g_object_notify (G_OBJECT (tree_column), "min_width");
}
* Sets the maximum width of the @tree_column. If @max_width is -1, then the
* maximum width is unset. Note, the column can actually be wider than max
* width if it's the last column in a view. In this case, the column expands to
- * fill the view.
+ * fill any extra space.
**/
void
gtk_tree_view_column_set_max_width (GtkTreeViewColumn *tree_column,
gint max_width)
{
- gint real_max_width;
-
g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
g_return_if_fail (max_width >= -1);
if (max_width == tree_column->max_width)
return;
- if (tree_column->tree_view == NULL)
+ if (tree_column->visible &&
+ tree_column->tree_view != NULL &&
+ GTK_WIDGET_REALIZED (tree_column->tree_view))
{
- tree_column->max_width = max_width;
- return;
+ if (max_width != -1 && max_width < tree_column->width)
+ gtk_widget_queue_resize (tree_column->tree_view);
}
- real_max_width = tree_column->max_width == -1 ?
- tree_column->button->requisition.width : tree_column->max_width;
-
- if (tree_column->tree_view &&
- GTK_WIDGET_REALIZED (tree_column->tree_view) &&
- ((tree_column->max_width < tree_column->width) ||
- (max_width != -1 && max_width < tree_column->width)))
- gtk_widget_queue_resize (tree_column->tree_view);
-
tree_column->max_width = max_width;
-
- if (real_max_width > max_width)
- tree_column->max_width = max_width;
-
+ if (max_width != -1 && max_width < tree_column->min_width)
+ {
+ tree_column->min_width = max_width;
+ g_object_notify (G_OBJECT (tree_column), "min_width");
+ }
g_object_notify (G_OBJECT (tree_column), "max_width");
}
* @tree_column: a #GtkTreeViewColumn
*
* Emits the "clicked" signal on the column. This function will only work if
- * the user could have conceivably clicked on the button.
+ * @tree_column is clickable.
**/
void
gtk_tree_view_column_clicked (GtkTreeViewColumn *tree_column)
{
g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
- if (tree_column->clickable == (clickable?TRUE:FALSE))
+ clickable = !! clickable;
+ if (tree_column->clickable == clickable)
return;
- tree_column->clickable = (clickable?TRUE:FALSE);
+ tree_column->clickable = clickable;
gtk_tree_view_column_update_button (tree_column);
g_object_notify (G_OBJECT (tree_column), "clickable");
}
*
* Returns %TRUE if the user can click on the header for the column.
*
- * Return value: whether the user can click the column header
+ * Return value: TRUE if user can click the column header
**/
gboolean
gtk_tree_view_column_get_clickable (GtkTreeViewColumn *tree_column)
for (list = tree_column->cell_list; list; list = list->next)
{
GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) list->data;
- gboolean visible;
- g_object_get (info->cell, "visible", &visible, NULL);
- if (visible == FALSE)
+ if (! info->cell->visible)
continue;
if (info->expand == TRUE)
for (list = tree_column->cell_list; list; list = list->next)
{
GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) list->data;
- gboolean visible;
if (info->pack == GTK_PACK_END)
continue;
- g_object_get (info->cell, "visible", &visible, NULL);
- if (visible == FALSE)
+ if (! info->cell->visible)
continue;
real_cell_area.width = info->requested_width +
for (list = g_list_last (tree_column->cell_list); list; list = list->prev)
{
GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) list->data;
- gboolean visible;
if (info->pack == GTK_PACK_START)
continue;
- g_object_get (info->cell, "visible", &visible, NULL);
- if (visible == FALSE)
+ if (! info->cell->visible)
continue;
real_cell_area.width = info->requested_width +
for (list = tree_column->cell_list; list; list = list->next)
{
GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) list->data;
- gboolean visible;
- g_object_get (G_OBJECT (info->cell), "visible", &visible, NULL);
-
- if (visible)
+ if (info->cell->visible)
return TRUE;
}
info->requested_width = 0;
}
tree_column->dirty = TRUE;
+ tree_column->requested_width = 0;
- if (tree_column->tree_view)
- gtk_widget_queue_resize (tree_column->tree_view);
+ if (tree_column->tree_view &&
+ GTK_WIDGET_REALIZED (tree_column->tree_view))
+ {
+ _gtk_tree_view_install_mark_rows_col_dirty (GTK_TREE_VIEW (tree_column->tree_view));
+ gtk_widget_queue_resize (tree_column->tree_view);
+ }
}
void
projects / ~andy / gtk / commitdiff