* 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 "gtkwidgetprivate.h"
#include "gtkentryprivate.h"
#include "gtkstylecontextprivate.h"
+#include "gtkcssstylepropertyprivate.h"
#include "gtktypebuiltins.h"
#include "gtkmain.h"
-#include "a11y/gtktreeviewaccessible.h"
+#include "gtksettings.h"
+#include "gtkwidgetpath.h"
+#include "a11y/gtktreeviewaccessibleprivate.h"
/**
RUBBER_BAND_ACTIVE = 2
};
+typedef enum {
+ CLEAR_AND_SELECT = (1 << 0),
+ CLAMP_NODE = (1 << 1),
+ CURSOR_INVALID = (1 << 2)
+} SetCursorFlags;
+
/* This lovely little value is used to determine how far away from the title bar
* you can move the mouse and still have a column drag work.
*/
guint scroll_sync_timer;
/* Indentation and expander layout */
- gint expander_size;
GtkTreeViewColumn *expander_column;
gint level_indentation;
gint cursor_offset;
GtkTreeRowReference *anchor;
- GtkTreeRowReference *cursor;
+ GtkRBNode *cursor_node;
+ GtkRBTree *cursor_tree;
GtkTreeViewColumn *focus_column;
gint drag_pos;
gint x_drag;
- /* Non-interactive Header Resizing, expand flag support */
- gint prev_width;
-
- gint last_extra_space;
- gint last_extra_space_per_column;
- gint last_number_of_expand_columns;
+ /* Column width allocation */
+ gint minimum_width;
+ gint natural_width;
+ gint n_expand_columns;
/* ATK Hack */
GtkTreeDestroyCountFunc destroy_count_func;
guint fixed_height_mode : 1;
guint fixed_height_check : 1;
+ guint activate_on_single_click : 1;
guint reorderable : 1;
guint header_has_focus : 1;
guint drag_column_window_state : 3;
guint in_grab : 1;
- guint post_validation_flag : 1;
-
/* Whether our key press handler is to avoid sending an unhandled binding to the search entry */
guint search_entry_avoid_unhandled_binding : 1;
PROP_RUBBER_BANDING,
PROP_ENABLE_GRID_LINES,
PROP_ENABLE_TREE_LINES,
- PROP_TOOLTIP_COLUMN
+ PROP_TOOLTIP_COLUMN,
+ PROP_ACTIVATE_ON_SINGLE_CLICK
};
/* object signals */
static void gtk_tree_view_get_preferred_height (GtkWidget *widget,
gint *minimum,
gint *natural);
-static void gtk_tree_view_size_request (GtkWidget *widget,
- GtkRequisition *requisition,
- gboolean may_validate);
static void gtk_tree_view_size_allocate (GtkWidget *widget,
GtkAllocation *allocation);
static gboolean gtk_tree_view_draw (GtkWidget *widget,
static void validate_visible_area (GtkTreeView *tree_view);
static gboolean validate_rows_handler (GtkTreeView *tree_view);
static gboolean do_validate_rows (GtkTreeView *tree_view,
- gboolean size_request);
+ gboolean queue_resize);
static gboolean validate_rows (GtkTreeView *tree_view);
static gboolean presize_handler_callback (gpointer data);
static void install_presize_handler (GtkTreeView *tree_view);
GtkRBTree *tree,
gint *x1,
gint *x2);
-static gint gtk_tree_view_new_column_width (GtkTreeView *tree_view,
- gint i,
- gint *x);
static void gtk_tree_view_adjustment_changed (GtkAdjustment *adjustment,
GtkTreeView *tree_view);
static void gtk_tree_view_build_tree (GtkTreeView *tree_view,
gboolean animate);
static void gtk_tree_view_real_set_cursor (GtkTreeView *tree_view,
GtkTreePath *path,
- gboolean clear_and_select,
- gboolean clamp_node);
+ SetCursorFlags flags);
static gboolean gtk_tree_view_has_can_focus_cell (GtkTreeView *tree_view);
static void column_sizing_notify (GObject *object,
GParamSpec *pspec,
-1,
GTK_PARAM_READWRITE));
+ /**
+ * GtkTreeView:activate-on-single-click:
+ *
+ * The activate-on-single-click property specifies whether the "row-activated" signal
+ * will be emitted after a single click.
+ *
+ * Since: 3.8
+ */
+ g_object_class_install_property (o_class,
+ PROP_ACTIVATE_ON_SINGLE_CLICK,
+ g_param_spec_boolean ("activate-on-single-click",
+ P_("Activate on Single Click"),
+ P_("Activate row on a single click"),
+ FALSE,
+ GTK_PARAM_READWRITE));
+
/* Style properties */
#define _TREE_VIEW_EXPANDER_SIZE 14
#define _TREE_VIEW_VERTICAL_SEPARATOR 2
* @column: the #GtkTreeViewColumn in which the activation occurred
*
* The "row-activated" signal is emitted when the method
- * gtk_tree_view_row_activated() is called or the user double clicks
- * a treeview row. It is also emitted when a non-editable row is
- * selected and one of the keys: Space, Shift+Space, Return or
- * Enter is pressed.
+ * gtk_tree_view_row_activated() is called, when the user double
+ * clicks a treeview row with the "activate-on-single-click"
+ * property set to %FALSE, or when the user single clicks a row when
+ * the "activate-on-single-click" property set to %TRUE. It is also
+ * emitted when a non-editable row is selected and one of the keys:
+ * Space, Shift+Space, Return or Enter is pressed.
*
* For selection handling refer to the <link linkend="TreeWidget">tree
* widget conceptual overview</link> as well as #GtkTreeSelection.
tree_view->priv->show_expanders = TRUE;
tree_view->priv->draw_keyfocus = TRUE;
tree_view->priv->headers_visible = TRUE;
+ tree_view->priv->activate_on_single_click = FALSE;
/* We need some padding */
tree_view->priv->dy = 0;
tree_view->priv->header_height = 1;
tree_view->priv->x_drag = 0;
tree_view->priv->drag_pos = -1;
+ tree_view->priv->minimum_width = 0;
+ tree_view->priv->natural_width = 0;
+ tree_view->priv->n_expand_columns = 0;
tree_view->priv->header_has_focus = FALSE;
tree_view->priv->pressed_button = -1;
tree_view->priv->press_start_x = -1;
tree_view->priv->tooltip_column = -1;
- tree_view->priv->post_validation_flag = FALSE;
-
tree_view->priv->last_button_x = -1;
tree_view->priv->last_button_y = -1;
gtk_tree_view_do_set_vadjustment (tree_view, NULL);
gtk_tree_view_do_set_hadjustment (tree_view, NULL);
+
+ gtk_style_context_add_class (gtk_widget_get_style_context (GTK_WIDGET (tree_view)),
+ GTK_STYLE_CLASS_VIEW);
}
\f
case PROP_TOOLTIP_COLUMN:
gtk_tree_view_set_tooltip_column (tree_view, g_value_get_int (value));
break;
+ case PROP_ACTIVATE_ON_SINGLE_CLICK:
+ gtk_tree_view_set_activate_on_single_click (tree_view, g_value_get_boolean (value));
+ break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
case PROP_TOOLTIP_COLUMN:
g_value_set_int (value, tree_view->priv->tooltip_column);
break;
+ case PROP_ACTIVATE_ON_SINGLE_CLICK:
+ g_value_set_boolean (value, tree_view->priv->activate_on_single_click);
+ break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
tree_view->priv->destroy_count_data = NULL;
}
- gtk_tree_row_reference_free (tree_view->priv->cursor);
- tree_view->priv->cursor = NULL;
-
gtk_tree_row_reference_free (tree_view->priv->anchor);
tree_view->priv->anchor = NULL;
{
GtkStyleContext *context;
- context = gtk_widget_get_style_context (widget);
+ context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
- gtk_style_context_save (context);
- gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW);
gtk_style_context_set_background (context, tree_view->priv->bin_window);
- gtk_style_context_restore (context);
-
+ gtk_style_context_set_background (context, gtk_widget_get_window (GTK_WIDGET (tree_view)));
gtk_style_context_set_background (context, tree_view->priv->header_window);
}
gtk_tree_view_realize (GtkWidget *widget)
{
GtkAllocation allocation;
- GtkStyleContext *context;
GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
GdkWindow *window;
GdkWindowAttr attributes;
window = gdk_window_new (gtk_widget_get_parent_window (widget),
&attributes, attributes_mask);
gtk_widget_set_window (widget, window);
- gdk_window_set_user_data (window, widget);
+ gtk_widget_register_window (widget, window);
gtk_widget_get_allocation (widget, &allocation);
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 |
tree_view->priv->bin_window = gdk_window_new (window,
&attributes, attributes_mask);
- gdk_window_set_user_data (tree_view->priv->bin_window, widget);
+ gtk_widget_register_window (widget, tree_view->priv->bin_window);
gtk_widget_get_allocation (widget, &allocation);
tree_view->priv->header_window = gdk_window_new (window,
&attributes, attributes_mask);
- gdk_window_set_user_data (tree_view->priv->header_window, widget);
-
- context = gtk_widget_get_style_context (widget);
+ gtk_widget_register_window (widget, tree_view->priv->header_window);
- 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_ensure_background (tree_view);
tmp_list = tree_view->priv->children;
while (tmp_list)
{
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);
for (list = priv->columns; list; list = list->next)
_gtk_tree_view_column_unrealize_button (GTK_TREE_VIEW_COLUMN (list->data));
- gdk_window_set_user_data (priv->bin_window, NULL);
+ gtk_widget_unregister_window (widget, priv->bin_window);
gdk_window_destroy (priv->bin_window);
priv->bin_window = NULL;
- gdk_window_set_user_data (priv->header_window, NULL);
+ gtk_widget_unregister_window (widget, priv->header_window);
gdk_window_destroy (priv->header_window);
priv->header_window = NULL;
if (priv->drag_window)
{
- gdk_window_set_user_data (priv->drag_window, NULL);
+ gtk_widget_unregister_window (widget, priv->drag_window);
gdk_window_destroy (priv->drag_window);
priv->drag_window = NULL;
}
if (priv->drag_highlight_window)
{
- gdk_window_set_user_data (priv->drag_highlight_window, NULL);
+ gtk_widget_unregister_window (widget, priv->drag_highlight_window);
gdk_window_destroy (priv->drag_highlight_window);
priv->drag_highlight_window = NULL;
}
GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->unrealize (widget);
}
-/* GtkWidget::size_request helper */
+/* GtkWidget::get_preferred_height helper */
static void
-gtk_tree_view_size_request_columns (GtkTreeView *tree_view)
+gtk_tree_view_update_height (GtkTreeView *tree_view)
{
GList *list;
gtk_widget_get_preferred_size (button, &requisition, NULL);
tree_view->priv->header_height = MAX (tree_view->priv->header_height, requisition.height);
}
-}
+ if (tree_view->priv->tree == NULL)
+ tree_view->priv->height = 0;
+ else
+ tree_view->priv->height = tree_view->priv->tree->root->offset;
+}
-/* Called only by ::size_request */
static void
-gtk_tree_view_update_size (GtkTreeView *tree_view)
+gtk_tree_view_get_preferred_width (GtkWidget *widget,
+ gint *minimum,
+ gint *natural)
{
+ GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
GList *list;
GtkTreeViewColumn *column;
- gint i;
-
- if (tree_view->priv->model == NULL)
- {
- tree_view->priv->width = 0;
- tree_view->priv->prev_width = 0;
- tree_view->priv->height = 0;
- return;
- }
+ gint column_minimum, column_natural;
- tree_view->priv->prev_width = tree_view->priv->width;
- tree_view->priv->width = 0;
+ /* we validate some rows initially just to make sure we have some size.
+ * In practice, with a lot of static lists, this should get a good width.
+ */
+ do_validate_rows (tree_view, FALSE);
+
+ tree_view->priv->minimum_width = 0;
+ tree_view->priv->natural_width = 0;
+ tree_view->priv->n_expand_columns = 0;
/* keep this in sync with size_allocate below */
- for (list = tree_view->priv->columns, i = 0; list; list = list->next, i++)
+ for (list = tree_view->priv->columns; list; list = list->next)
{
column = list->data;
- if (!gtk_tree_view_column_get_visible (column))
+ if (!gtk_tree_view_column_get_visible (column) || column == tree_view->priv->drag_column)
continue;
- tree_view->priv->width += _gtk_tree_view_column_request_width (column);
+ _gtk_tree_view_column_request_width (column, &column_minimum, &column_natural);
+ tree_view->priv->minimum_width += column_minimum;
+ tree_view->priv->natural_width += column_natural;
+
+ if (gtk_tree_view_column_get_expand (column))
+ tree_view->priv->n_expand_columns++;
}
- if (tree_view->priv->tree == NULL)
- tree_view->priv->height = 0;
- else
- tree_view->priv->height = tree_view->priv->tree->root->offset;
+ if (minimum != NULL)
+ *minimum = tree_view->priv->minimum_width;
+ if (natural != NULL)
+ *natural = tree_view->priv->natural_width;
}
static void
-gtk_tree_view_size_request (GtkWidget *widget,
- GtkRequisition *requisition,
- gboolean may_validate)
+gtk_tree_view_get_preferred_height (GtkWidget *widget,
+ gint *minimum,
+ gint *natural)
{
GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
+ gint height;
- if (may_validate)
- {
- /* we validate some rows initially just to make sure we have some size.
- * In practice, with a lot of static lists, this should get a good width.
- */
- do_validate_rows (tree_view, FALSE);
- }
+ gtk_tree_view_update_height (tree_view);
- gtk_tree_view_size_request_columns (tree_view);
- gtk_tree_view_update_size (GTK_TREE_VIEW (widget));
+ height = tree_view->priv->height + gtk_tree_view_get_effective_header_height (tree_view);
- requisition->width = tree_view->priv->width;
- requisition->height = tree_view->priv->height + gtk_tree_view_get_effective_header_height (tree_view);
+ if (minimum != NULL)
+ *minimum = height;
+ if (natural != NULL)
+ *natural = height;
}
static void
-gtk_tree_view_get_preferred_width (GtkWidget *widget,
- gint *minimum,
- gint *natural)
+gtk_tree_view_modify_column_width (GtkTreeView *tree_view,
+ GtkTreeViewColumn *column,
+ gint width)
{
- GtkRequisition requisition;
+ gboolean is_expand;
+ gint n_expand_others;
+ gint minimum, natural, natural_others;
+ gint expand;
- gtk_tree_view_size_request (widget, &requisition, TRUE);
+ is_expand = gtk_tree_view_column_get_expand (column);
+ n_expand_others = tree_view->priv->n_expand_columns - (is_expand ? 1 : 0);
- *minimum = *natural = requisition.width;
-}
+ _gtk_tree_view_column_request_width (column, &minimum, &natural);
+ natural_others = tree_view->priv->natural_width - natural;
-static void
-gtk_tree_view_get_preferred_height (GtkWidget *widget,
- gint *minimum,
- gint *natural)
-{
- GtkRequisition requisition;
+ if (natural_others + width < tree_view->priv->width)
+ {
+ /* There is extra space that needs to be taken up by letting some other
+ * column(s) expand: by default, the last column. */
+ if (!n_expand_others)
+ {
+ GList *last = g_list_last (tree_view->priv->columns);
+ while (!gtk_tree_view_column_get_visible (last->data))
+ last = last->prev;
- gtk_tree_view_size_request (widget, &requisition, TRUE);
+ if (column == last->data)
+ return;
- *minimum = *natural = requisition.height;
+ gtk_tree_view_column_set_expand (last->data, TRUE);
+ n_expand_others++;
+ }
+
+ /* Now try to make this column expandable also. Solving the following
+ * equations reveals what the natural width should be to achieve the
+ * desired width after expanding:
+ *
+ * 1. natural + expand = desired_width
+ * 2. natural + natural_others + expand * (n_expand_others + 1) = total_width
+ *
+ * Solution:
+ * expand = (total_width - natural_others - desired_width) / n_expand_others
+ *
+ * It is possible for the solved natural width to be less than the
+ * minimum; in that case, we cannot let the column expand.
+ */
+ expand = (tree_view->priv->width - natural_others - width) / n_expand_others;
+
+ if (minimum + expand > width)
+ {
+ if (is_expand)
+ gtk_tree_view_column_set_expand (column, FALSE);
+ }
+ else
+ {
+ if (!is_expand)
+ gtk_tree_view_column_set_expand (column, TRUE);
+
+ width -= expand;
+ }
+ }
+
+ gtk_tree_view_column_set_fixed_width (column, width);
}
static int
GList *list, *first_column, *last_column;
GtkTreeViewColumn *column;
GtkAllocation widget_allocation;
- gint width = 0;
- gint extra, extra_per_column, extra_for_last;
- gint full_requested_width = 0;
- gint number_of_expand_columns = 0;
+ gint minimum_width, natural_width, n_expand_columns, width;
+ gint column_minimum, column_natural, column_width;
gboolean rtl;
- gboolean update_expand;
tree_view = GTK_TREE_VIEW (widget);
rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
- /* find out how many extra space and expandable columns we have */
- for (list = tree_view->priv->columns; list != last_column->next; list = list->next)
- {
- column = (GtkTreeViewColumn *)list->data;
-
- if (!gtk_tree_view_column_get_visible (column))
- continue;
-
- full_requested_width += _gtk_tree_view_column_request_width (column);
-
- if (gtk_tree_view_column_get_expand (column))
- number_of_expand_columns++;
- }
-
- /* Only update the expand value if the width of the widget has changed,
- * or the number of expand columns has changed, or if there are no expand
- * columns, or if we didn't have an size-allocation yet after the
- * last validated node.
- */
- update_expand = (width_changed && *width_changed == TRUE)
- || number_of_expand_columns != tree_view->priv->last_number_of_expand_columns
- || number_of_expand_columns == 0
- || tree_view->priv->post_validation_flag == TRUE;
-
- tree_view->priv->post_validation_flag = FALSE;
-
gtk_widget_get_allocation (widget, &widget_allocation);
- if (!update_expand)
- {
- extra = tree_view->priv->last_extra_space;
- extra_for_last = MAX (widget_allocation.width - full_requested_width - extra, 0);
- }
- else
- {
- extra = MAX (widget_allocation.width - full_requested_width, 0);
- extra_for_last = 0;
- tree_view->priv->last_extra_space = extra;
- }
+ minimum_width = tree_view->priv->minimum_width;
+ natural_width = tree_view->priv->natural_width;
+ n_expand_columns = tree_view->priv->n_expand_columns;
- if (number_of_expand_columns > 0)
- extra_per_column = extra/number_of_expand_columns;
- else
- extra_per_column = 0;
+ width = MAX (widget_allocation.width, minimum_width);
- if (update_expand)
+ /* We change the width here. The user might have been resizing columns,
+ * which changes the total width of the tree view. This is of
+ * importance for getting the horizontal scroll bar right.
+ */
+ if (tree_view->priv->width != width)
{
- tree_view->priv->last_extra_space_per_column = extra_per_column;
- tree_view->priv->last_number_of_expand_columns = number_of_expand_columns;
+ tree_view->priv->width = width;
+ if (width_changed)
+ *width_changed = TRUE;
}
- for (list = (rtl ? last_column : first_column);
- list != (rtl ? first_column->prev : last_column->next);
- list = (rtl ? list->prev : list->next))
+ /* iterate through columns in reverse order */
+ for (list = (rtl ? first_column : last_column);
+ list != (rtl ? last_column->next : first_column->prev);
+ list = (rtl ? list->next : list->prev))
{
- gint column_width;
-
column = list->data;
- if (!gtk_tree_view_column_get_visible (column))
+ if (!gtk_tree_view_column_get_visible (column) || column == tree_view->priv->drag_column)
continue;
- /* We need to handle the dragged button specially.
- */
- if (column == tree_view->priv->drag_column)
- {
- GtkAllocation drag_allocation;
- GtkWidget *button;
-
- button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
-
- drag_allocation.x = 0;
- drag_allocation.y = 0;
- drag_allocation.width = gdk_window_get_width (tree_view->priv->drag_window);
- drag_allocation.height = gdk_window_get_height (tree_view->priv->drag_window);
- gtk_widget_size_allocate (button, &drag_allocation);
- width += drag_allocation.width;
- continue;
- }
-
- column_width = _gtk_tree_view_column_request_width (column);
+ _gtk_tree_view_column_request_width (column, &column_minimum, &column_natural);
+
+ column_width = column_natural;
- if (gtk_tree_view_column_get_expand (column))
- {
- if (number_of_expand_columns == 1)
+ if (width > natural_width)
+ {
+ /* We need to expand some columns. If there are none marked to
+ * expand, give all the extra space to the last column. */
+ if (n_expand_columns == 0)
{
- /* We add the remander to the last column as
- * */
- column_width += extra;
+ column_width = column_natural + (width - natural_width);
}
- else
+ else if (gtk_tree_view_column_get_expand (column))
{
- column_width += extra_per_column;
- extra -= extra_per_column;
- number_of_expand_columns --;
+ column_width = column_natural + (width - natural_width) / n_expand_columns;
+ n_expand_columns--;
}
- }
- else if (number_of_expand_columns == 0 &&
- list == last_column)
+ }
+ else if (width < natural_width)
{
- column_width += extra;
+ /* We need to shrink some columns. Starting with later columns,
+ * shrink each one down to its minimum width as necessary. */
+ column_width = MAX (column_natural + (width - natural_width), column_minimum);
}
+
+ _gtk_tree_view_column_allocate (column, width - column_width, column_width);
+
+ minimum_width -= column_minimum;
+ natural_width -= column_natural;
+ width -= column_width;
+ }
+}
- /* In addition to expand, the last column can get even more
- * extra space so all available space is filled up.
- */
- if (extra_for_last > 0 && list == last_column)
- column_width += extra_for_last;
+/* GtkWidget::size_allocate helper */
+static void
+gtk_tree_view_size_allocate_drag_column (GtkWidget *widget)
+{
+ GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
+ GtkAllocation drag_allocation;
+ GtkWidget *button;
- _gtk_tree_view_column_allocate (column, width, column_width);
+ if (tree_view->priv->drag_column == NULL)
+ return;
- width += column_width;
- }
+ button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
- /* We change the width here. The user might have been resizing columns,
- * which changes the total width of the tree view. This is of
- * importance for getting the horizontal scroll bar right.
- */
- if (tree_view->priv->width != width)
- {
- tree_view->priv->width = width;
- if (width_changed)
- *width_changed = TRUE;
- }
+ drag_allocation.x = 0;
+ drag_allocation.y = 0;
+ drag_allocation.width = gdk_window_get_width (tree_view->priv->drag_window);
+ drag_allocation.height = gdk_window_get_height (tree_view->priv->drag_window);
+ gtk_widget_size_allocate (button, &drag_allocation);
}
-
static void
gtk_tree_view_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
* tree view (used in updating the adjustments below) might change.
*/
gtk_tree_view_size_allocate_columns (widget, &width_changed);
+ gtk_tree_view_size_allocate_drag_column (widget);
g_object_freeze_notify (G_OBJECT (tree_view->priv->hadjustment));
gtk_adjustment_set_page_size (tree_view->priv->hadjustment,
0,
tree_view->priv->width - allocation->width));
}
- else
- gtk_adjustment_set_value (tree_view->priv->hadjustment,
- CLAMP (tree_view->priv->width - (tree_view->priv->prev_width - gtk_adjustment_get_value (tree_view->priv->hadjustment)),
- 0,
- tree_view->priv->width - allocation->width));
}
else
{
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;
}
/* Get the path and the node */
- path = _gtk_tree_view_find_path (tree_view, tree, node);
+ path = _gtk_tree_path_new_from_rbtree (tree, node);
path_is_selectable = !row_is_separator (tree_view, NULL, path);
if (!path_is_selectable)
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;
if (event->state & modify_mod_mask)
{
- gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
+ gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
gtk_tree_view_real_toggle_cursor_row (tree_view);
}
else if (event->state & extend_mod_mask)
{
- gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
+ gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
gtk_tree_view_real_select_cursor_row (tree_view, FALSE);
}
else
{
- gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE);
+ gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CLAMP_NODE);
}
tree_view->priv->modify_selection_pressed = FALSE;
}
}
- /* Test if a double click happened on the same row. */
- if (event->button == 1 && event->type == GDK_BUTTON_PRESS)
+ if (event->button == GDK_BUTTON_PRIMARY && event->type == GDK_BUTTON_PRESS)
{
- int double_click_time, double_click_distance;
-
- g_object_get (gtk_settings_get_default (),
- "gtk-double-click-time", &double_click_time,
- "gtk-double-click-distance", &double_click_distance,
- NULL);
- /* Same conditions as _gdk_event_button_generate */
- if (tree_view->priv->last_button_x != -1 &&
- (event->time < tree_view->priv->last_button_time + double_click_time) &&
- (ABS (event->x - tree_view->priv->last_button_x) <= double_click_distance) &&
- (ABS (event->y - tree_view->priv->last_button_y) <= double_click_distance))
+ /* Test if a double click happened on the same row. */
+ if (!tree_view->priv->activate_on_single_click)
{
- /* We do no longer compare paths of this row and the
- * row clicked previously. We use the double click
- * distance to decide whether this is a valid click,
- * allowing the mouse to slightly move over another row.
- */
- row_double_click = TRUE;
-
- tree_view->priv->last_button_time = 0;
- tree_view->priv->last_button_x = -1;
- tree_view->priv->last_button_y = -1;
+ int double_click_time, double_click_distance;
+
+ g_object_get (gtk_settings_get_default (),
+ "gtk-double-click-time", &double_click_time,
+ "gtk-double-click-distance", &double_click_distance,
+ NULL);
+
+ /* Same conditions as _gdk_event_button_generate */
+ if (tree_view->priv->last_button_x != -1 &&
+ (event->time < tree_view->priv->last_button_time + double_click_time) &&
+ (ABS (event->x - tree_view->priv->last_button_x) <= double_click_distance) &&
+ (ABS (event->y - tree_view->priv->last_button_y) <= double_click_distance))
+ {
+ /* We do no longer compare paths of this row and the
+ * row clicked previously. We use the double click
+ * distance to decide whether this is a valid click,
+ * allowing the mouse to slightly move over another row.
+ */
+ row_double_click = TRUE;
+
+ tree_view->priv->last_button_time = 0;
+ tree_view->priv->last_button_x = -1;
+ tree_view->priv->last_button_y = -1;
+ }
+ else
+ {
+ tree_view->priv->last_button_time = event->time;
+ tree_view->priv->last_button_x = event->x;
+ tree_view->priv->last_button_y = event->y;
+ }
}
else
{
- tree_view->priv->last_button_time = event->time;
- tree_view->priv->last_button_x = event->x;
- tree_view->priv->last_button_y = event->y;
+ tree_view->priv->button_pressed_node = tree_view->priv->prelight_node;
+ tree_view->priv->button_pressed_tree = tree_view->priv->prelight_tree;
}
}
_gtk_tree_view_column_get_window (column))
{
gpointer drag_data;
+ gint column_width, x;
if (event->type == GDK_2BUTTON_PRESS &&
gtk_tree_view_column_get_sizing (column) != GTK_TREE_VIEW_COLUMN_AUTOSIZE)
{
- _gtk_tree_view_column_set_use_resized_width (column, FALSE);
+ gtk_tree_view_column_set_fixed_width (column, -1);
+ gtk_tree_view_column_set_expand (column, FALSE);
_gtk_tree_view_column_autosize (tree_view, column);
return TRUE;
}
gtk_grab_add (widget);
tree_view->priv->in_column_resize = TRUE;
- _gtk_tree_view_column_set_resized_width (column, gtk_tree_view_column_get_width (column) -
- tree_view->priv->last_extra_space_per_column);
-
/* block attached dnd signal handler */
drag_data = g_object_get_data (G_OBJECT (widget), "gtk-site-data");
if (drag_data)
0, 0, NULL, NULL,
drag_data);
+ column_width = gtk_tree_view_column_get_width (column);
+ gdk_window_get_device_position (tree_view->priv->bin_window,
+ gdk_event_get_device ((GdkEvent *) event),
+ &x, NULL, NULL);
+
tree_view->priv->drag_pos = i;
- tree_view->priv->x_drag = gtk_tree_view_column_get_x_offset (column) + (rtl ? 0 : gtk_tree_view_column_get_width (column));
+ tree_view->priv->x_drag = x + (rtl ? column_width : -column_width);
if (!gtk_widget_has_focus (widget))
gtk_widget_grab_focus (widget);
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, GTK_STYLE_CLASS_DND);
+
g_object_ref (button);
gtk_container_remove (GTK_CONTAINER (tree_view), button);
gtk_widget_set_parent_window (button, tree_view->priv->header_window);
tree_view->priv->cur_reorder->left_column);
}
tree_view->priv->drag_column = NULL;
- gdk_window_hide (tree_view->priv->drag_window);
+ gtk_widget_unregister_window (widget, tree_view->priv->drag_window);
+ gdk_window_destroy (tree_view->priv->drag_window);
+ tree_view->priv->drag_window = NULL;
for (l = tree_view->priv->column_drag_info; l != NULL; l = l->next)
g_slice_free (GtkTreeViewColumnReorder, l->data);
return TRUE;
}
+static gboolean
+button_event_modifies_selection (GdkEventButton *event)
+{
+ return (event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK)) != 0;
+}
+
static gboolean
gtk_tree_view_button_release (GtkWidget *widget,
GdkEventButton *event)
if (tree_view->priv->button_pressed_node == NULL)
return FALSE;
- if (event->button == 1)
+ if (event->button == GDK_BUTTON_PRIMARY
+ && tree_view->priv->button_pressed_node == tree_view->priv->prelight_node)
{
- if (tree_view->priv->button_pressed_node == tree_view->priv->prelight_node &&
- tree_view->priv->arrow_prelit)
+ if (tree_view->priv->arrow_prelit)
{
GtkTreePath *path = NULL;
- path = _gtk_tree_view_find_path (tree_view,
- tree_view->priv->button_pressed_tree,
- tree_view->priv->button_pressed_node);
+ path = _gtk_tree_path_new_from_rbtree (tree_view->priv->button_pressed_tree,
+ tree_view->priv->button_pressed_node);
/* Actually activate the node */
if (tree_view->priv->button_pressed_node->children == NULL)
gtk_tree_view_real_expand_row (tree_view, path,
tree_view->priv->button_pressed_node, TRUE);
gtk_tree_path_free (path);
}
+ else if (tree_view->priv->activate_on_single_click
+ && !button_event_modifies_selection (event))
+ {
+ GtkTreePath *path = NULL;
+
+ path = _gtk_tree_path_new_from_rbtree (tree_view->priv->button_pressed_tree,
+ tree_view->priv->button_pressed_node);
+ gtk_tree_view_row_activated (tree_view, path, tree_view->priv->focus_column);
+ gtk_tree_path_free (path);
+ }
gtk_grab_remove (widget);
tree_view->priv->button_pressed_tree = NULL;
if (tree_view->priv->prelight_node)
{
- path = _gtk_tree_view_find_path (tree_view,
- tree_view->priv->prelight_tree,
- tree_view->priv->prelight_node);
+ path = _gtk_tree_path_new_from_rbtree (tree_view->priv->prelight_tree,
+ tree_view->priv->prelight_node);
if (tree_view->priv->prelight_node->children)
gtk_tree_view_collapse_row (tree_view, path);
{
GtkTreePath *path;
- path = _gtk_tree_view_find_path (tree_view, tree, node);
+ path = _gtk_tree_path_new_from_rbtree (tree, node);
gtk_tree_selection_select_path (tree_view->priv->selection, path);
if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
{
tree_view->priv->draw_keyfocus = FALSE;
- gtk_tree_view_real_set_cursor (tree_view, path, FALSE, FALSE);
+ gtk_tree_view_real_set_cursor (tree_view, path, 0);
}
gtk_tree_path_free (path);
}
if (tree_view->priv->drag_highlight_window)
{
- gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
- NULL);
+ gtk_widget_unregister_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
gdk_window_destroy (tree_view->priv->drag_highlight_window);
}
attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
tree_view->priv->drag_highlight_window = gdk_window_new (tree_view->priv->header_window, &attributes, attributes_mask);
- gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
+ gtk_widget_register_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
cr = cairo_create (mask_image);
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)
{
if (tree_view->priv->drag_highlight_window)
{
- gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
- NULL);
+ gtk_widget_unregister_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
gdk_window_destroy (tree_view->priv->drag_highlight_window);
}
attributes.height = height;
tree_view->priv->drag_highlight_window = gdk_window_new (gtk_widget_get_root_window (widget),
&attributes, attributes_mask);
- gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
+ gtk_widget_register_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
{
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 &&
{
if (tree_view->priv->drag_highlight_window)
{
- gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
- NULL);
+ gtk_widget_unregister_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
gdk_window_destroy (tree_view->priv->drag_highlight_window);
}
attributes.y = y;
attributes.width = width;
attributes.height = height;
- tree_view->priv->drag_highlight_window = gdk_window_new (NULL, &attributes, attributes_mask);
- gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
+ tree_view->priv->drag_highlight_window = gdk_window_new (gtk_widget_get_root_window (widget), &attributes, attributes_mask);
+ gtk_widget_register_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
}
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);
column = gtk_tree_view_get_column (tree_view, tree_view->priv->drag_pos);
- if (event->is_hint || event->window != gtk_widget_get_window (widget))
- gdk_window_get_device_position (gtk_widget_get_window (widget),
- gdk_event_get_device ((GdkEvent *) event),
- &x, NULL, NULL);
- else
- x = event->x;
-
- if (tree_view->priv->hadjustment)
- x += gtk_adjustment_get_value (tree_view->priv->hadjustment);
-
- new_width = gtk_tree_view_new_column_width (tree_view,
- tree_view->priv->drag_pos, &x);
- if (x != tree_view->priv->x_drag &&
- (new_width != gtk_tree_view_column_get_fixed_width (column)))
- {
- _gtk_tree_view_column_set_use_resized_width (column, TRUE);
-
- if (gtk_tree_view_column_get_expand (column))
- new_width -= tree_view->priv->last_extra_space_per_column;
+ gdk_window_get_device_position (tree_view->priv->bin_window,
+ gdk_event_get_device ((GdkEvent *) event),
+ &x, NULL, NULL);
- _gtk_tree_view_column_set_resized_width (column, new_width);
+ if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
+ new_width = MAX (tree_view->priv->x_drag - x, 0);
+ else
+ new_width = MAX (x - tree_view->priv->x_drag, 0);
-
- gtk_widget_queue_resize (widget);
- }
+ if (new_width != gtk_tree_view_column_get_width (column))
+ gtk_tree_view_modify_column_width (tree_view, column, new_width);
return FALSE;
}
gtk_widget_queue_draw (GTK_WIDGET (tree_view));
/* The anchor path should be set to the start path */
- tmp_path = _gtk_tree_view_find_path (tree_view,
- tree_view->priv->rubber_band_start_tree,
- tree_view->priv->rubber_band_start_node);
+ tmp_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->rubber_band_start_tree,
+ tree_view->priv->rubber_band_start_node);
if (tree_view->priv->anchor)
gtk_tree_row_reference_free (tree_view->priv->anchor);
gtk_tree_path_free (tmp_path);
/* ... and the cursor to the end path */
- tmp_path = _gtk_tree_view_find_path (tree_view,
- tree_view->priv->rubber_band_end_tree,
- tree_view->priv->rubber_band_end_node);
- gtk_tree_view_real_set_cursor (GTK_TREE_VIEW (tree_view), tmp_path, FALSE, FALSE);
+ tmp_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->rubber_band_end_tree,
+ tree_view->priv->rubber_band_end_node);
+ gtk_tree_view_real_set_cursor (GTK_TREE_VIEW (tree_view), tmp_path, 0);
gtk_tree_path_free (tmp_path);
_gtk_tree_selection_emit_changed (tree_view->priv->selection);
GtkTreePath *path;
gboolean selectable;
- path = _gtk_tree_view_find_path (tree_view, start_tree, start_node);
+ path = _gtk_tree_path_new_from_rbtree (start_tree, start_node);
selectable = _gtk_tree_selection_row_is_selectable (tree_view->priv->selection, start_node, path);
gtk_tree_path_free (path);
if (start_node->children)
{
start_tree = start_node->children;
- start_node = start_tree->root;
- while (start_node->left != start_tree->nil)
- start_node = start_node->left;
+ start_node = _gtk_rbtree_first (start_tree);
}
else
{
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);
}
}
GtkRBTree *tree;
GList *list;
GtkRBNode *node;
- GtkRBNode *cursor = NULL;
- GtkRBTree *cursor_tree = NULL;
GtkRBNode *drag_highlight = NULL;
GtkRBTree *drag_highlight_tree = NULL;
GtkTreeIter iter;
gint expander_cell_width;
gint bin_window_width;
gint bin_window_height;
- GtkTreePath *cursor_path;
GtkTreePath *drag_dest_path;
GList *first_column, *last_column;
gint vertical_separator;
gint horizontal_separator;
- gint focus_line_width;
gboolean allow_rules;
gboolean has_can_focus_cell;
gboolean rtl;
gint n_visible_columns;
gint grid_line_width;
+ gint expander_size;
gboolean draw_vgrid_lines, draw_hgrid_lines;
GtkStyleContext *context;
- GtkStateFlags state;
gboolean parity;
rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
context = gtk_widget_get_style_context (widget);
- state = gtk_widget_get_state_flags (widget);
gtk_widget_style_get (widget,
"horizontal-separator", &horizontal_separator,
"vertical-separator", &vertical_separator,
"allow-rules", &allow_rules,
- "focus-line-width", &focus_line_width,
NULL);
if (tree_view->priv->tree == NULL)
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,
return TRUE;
/* find the path for the node */
- path = _gtk_tree_view_find_path ((GtkTreeView *)widget,
- tree,
- node);
+ path = _gtk_tree_path_new_from_rbtree (tree, node);
gtk_tree_model_get_iter (tree_view->priv->model,
&iter,
path);
depth = gtk_tree_path_get_depth (path);
gtk_tree_path_free (path);
- cursor_path = NULL;
drag_dest_path = NULL;
- if (tree_view->priv->cursor)
- cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
-
- if (cursor_path)
- _gtk_tree_view_find_node (tree_view, cursor_path,
- &cursor_tree, &cursor);
-
if (tree_view->priv->drag_dest_row)
drag_dest_path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
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_SORTED;
- if (cursor == node)
+ if (tree_view->priv->cursor_node == node)
flags |= GTK_CELL_RENDERER_FOCUSED;
else
flags &= ~GTK_CELL_RENDERER_FOCUSED;
+ if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
+ flags |= GTK_CELL_RENDERER_EXPANDABLE;
+ else
+ flags &= ~GTK_CELL_RENDERER_EXPANDABLE;
+
+ if (node->children)
+ flags |= GTK_CELL_RENDERER_EXPANDED;
+ else
+ flags &= ~GTK_CELL_RENDERER_EXPANDED;
+
background_area.x = cell_offset;
background_area.width = width;
gtk_style_context_add_region (context, GTK_STYLE_REGION_ROW, row_flags);
gtk_style_context_add_region (context, GTK_STYLE_REGION_COLUMN, column_flags);
- if (node == cursor && has_can_focus_cell
+ if (node == tree_view->priv->cursor_node && has_can_focus_cell
&& ((column == tree_view->priv->focus_column
&& tree_view->priv->draw_keyfocus &&
gtk_widget_has_visible_focus (widget))
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 */
- if (!has_can_focus_cell && node == cursor &&
+ if (!has_can_focus_cell && node == tree_view->priv->cursor_node &&
tree_view->priv->draw_keyfocus &&
gtk_widget_has_visible_focus (widget))
{
gboolean has_child;
tree = node->children;
- node = tree->root;
-
- g_assert (node != tree->nil);
+ node = _gtk_rbtree_first (tree);
- while (node->left != tree->nil)
- node = node->left;
has_child = gtk_tree_model_iter_children (tree_view->priv->model,
&iter,
&parent);
if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
gtk_tree_view_paint_rubber_band (tree_view, cr);
- if (cursor_path)
- gtk_tree_path_free (cursor_path);
-
if (drag_dest_path)
gtk_tree_path_free (drag_dest_path);
{
GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
GtkWidget *button;
+ GtkStyleContext *context;
+
+ context = gtk_widget_get_style_context (widget);
+ gtk_render_background (context, cr,
+ 0, 0,
+ gtk_widget_get_allocated_width (widget),
+ gtk_widget_get_allocated_height (widget));
if (gtk_cairo_should_draw_window (cr, tree_view->priv->bin_window))
{
- GtkStyleContext *context;
GList *tmp_list;
- context = gtk_widget_get_style_context (widget);
-
cairo_save (cr);
- gtk_style_context_save (context);
- gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW);
-
gtk_cairo_transform_to_window (cr, widget, tree_view->priv->bin_window);
-
gtk_tree_view_bin_draw (widget, cr);
- gtk_style_context_restore (context);
cairo_restore (cr);
/* We can't just chain up to Container::draw as it will try to send the
}
}
+ gtk_style_context_save (context);
+ gtk_style_context_remove_class (context, GTK_STYLE_CLASS_VIEW);
+
if (gtk_cairo_should_draw_window (cr, tree_view->priv->header_window))
{
GList *list;
button, cr);
}
+ gtk_style_context_restore (context);
+
return FALSE;
}
|| event->keyval == GDK_KEY_Right || event->keyval == GDK_KEY_KP_Right))
{
GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
- gint max_width, min_width;
+ gint column_width;
if (!gtk_tree_view_column_get_resizable (column))
{
return TRUE;
}
+ column_width = gtk_tree_view_column_get_width (column);
+
if (event->keyval == (rtl ? GDK_KEY_Right : GDK_KEY_Left)
|| event->keyval == (rtl ? GDK_KEY_KP_Right : GDK_KEY_KP_Left))
{
- GtkRequisition button_req;
- gint old_width = _gtk_tree_view_column_get_resized_width (column);
- gint new_width;
-
- button = gtk_tree_view_column_get_button (column);
-
- gtk_widget_get_preferred_size (button, &button_req, NULL);
-
- new_width = MAX (old_width, gtk_tree_view_column_get_width (column));
- new_width -= 2;
- if (new_width < 0)
- new_width = 0;
-
- _gtk_tree_view_column_set_resized_width (column, new_width);
-
- min_width = gtk_tree_view_column_get_min_width (column);
- if (min_width == -1)
- new_width = MAX (button_req.width, new_width);
- else
- {
- new_width = MAX (min_width, new_width);
- }
-
- max_width = gtk_tree_view_column_get_max_width (column);
- if (max_width != -1)
- new_width = MIN (new_width, max_width);
-
- _gtk_tree_view_column_set_use_resized_width (column, TRUE);
-
- if (new_width != old_width)
- {
- _gtk_tree_view_column_set_resized_width (column, new_width);
- gtk_widget_queue_resize (widget);
- }
- else
- gtk_widget_error_bell (widget);
+ column_width = MAX (column_width - 2, 0);
}
else if (event->keyval == (rtl ? GDK_KEY_Left : GDK_KEY_Right)
|| event->keyval == (rtl ? GDK_KEY_KP_Left : GDK_KEY_KP_Right))
{
- gint old_width = _gtk_tree_view_column_get_resized_width (column);
- gint new_width;
-
- new_width = MAX (old_width, gtk_tree_view_column_get_width (column));
- new_width += 2;
-
- max_width = gtk_tree_view_column_get_max_width (column);
- if (max_width != -1)
- new_width = MIN (new_width, max_width);
-
- _gtk_tree_view_column_set_use_resized_width (column, TRUE);
-
- if (new_width != old_width)
- {
- _gtk_tree_view_column_set_resized_width (column, new_width);
- gtk_widget_queue_resize (widget);
- }
- else
- gtk_widget_error_bell (widget);
+ column_width = column_width + 2;
}
+ gtk_tree_view_modify_column_width (tree_view, column, column_width);
return TRUE;
}
{
GtkTreeView *tree_view;
- if (event->mode == GDK_CROSSING_GRAB)
+ if (event->mode == GDK_CROSSING_GRAB ||
+ event->mode == GDK_CROSSING_GTK_GRAB ||
+ event->mode == GDK_CROSSING_GTK_UNGRAB)
return TRUE;
tree_view = GTK_TREE_VIEW (widget);
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;
_gtk_rbtree_node_set_height (tree, node, height);
}
_gtk_rbtree_node_mark_valid (tree, node);
- tree_view->priv->post_validation_flag = TRUE;
return retval;
}
}
else
{
- path = _gtk_tree_view_find_path (tree_view, tree, node);
+ path = _gtk_tree_path_new_from_rbtree (tree, node);
total_height += offset;
}
GtkTreePath *tmppath;
GtkTreeIter tmpiter;
- tmppath = _gtk_tree_view_find_path (tree_view, tmptree, tmpnode);
+ tmppath = _gtk_tree_path_new_from_rbtree (tmptree, tmpnode);
gtk_tree_model_get_iter (tree_view->priv->model, &tmpiter, tmppath);
if (GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_INVALID) ||
gboolean has_child;
tree = node->children;
- node = tree->root;
+ node = _gtk_rbtree_first (tree);
- g_assert (node != tree->nil);
-
- while (node->left != tree->nil)
- node = node->left;
has_child = gtk_tree_model_iter_children (tree_view->priv->model,
&iter,
&parent);
break;
gtk_tree_path_free (above_path);
- above_path = _gtk_tree_view_find_path (tree_view, tree, node);
+ above_path = _gtk_tree_path_new_from_rbtree (tree, node);
gtk_tree_model_get_iter (tree_view->priv->model, &iter, above_path);
tree = tree_view->priv->tree;
node = tree->root;
- path = _gtk_tree_view_find_path (tree_view, tree, node);
+ path = _gtk_tree_path_new_from_rbtree (tree, node);
gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
validate_row (tree_view, tree, node, &iter, path);
static gboolean
do_validate_rows (GtkTreeView *tree_view, gboolean queue_resize)
{
+ static gboolean prevent_recursion_hack = FALSE;
+
GtkRBTree *tree = NULL;
GtkRBNode *node = NULL;
gboolean validated_area = FALSE;
g_assert (tree_view);
+ /* prevent infinite recursion via get_preferred_width() */
+ if (prevent_recursion_hack)
+ return FALSE;
+
if (tree_view->priv->tree == NULL)
return FALSE;
do
{
- if (node->left != tree->nil &&
+ if (!_gtk_rbtree_is_nil (node->left) &&
GTK_RBNODE_FLAG_SET (node->left, GTK_RBNODE_DESCENDANTS_INVALID))
{
node = node->left;
}
- else if (node->right != tree->nil &&
+ else if (!_gtk_rbtree_is_nil (node->right) &&
GTK_RBNODE_FLAG_SET (node->right, GTK_RBNODE_DESCENDANTS_INVALID))
{
node = node->right;
g_assert_not_reached ();
}
while (TRUE);
- path = _gtk_tree_view_find_path (tree_view, tree, node);
+ path = _gtk_tree_path_new_from_rbtree (tree, node);
gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
}
* Currently bypassing this but the real solution is to not update the scroll adjustments
* untill we've recieved an allocation (never update scroll adjustments from size-requests).
*/
- gtk_tree_view_size_request (GTK_WIDGET (tree_view), &requisition, FALSE);
+ prevent_recursion_hack = TRUE;
+ gtk_tree_view_get_preferred_width (GTK_WIDGET (tree_view), &requisition.width, NULL);
+ gtk_tree_view_get_preferred_height (GTK_WIDGET (tree_view), &requisition.height, NULL);
+ prevent_recursion_hack = FALSE;
/* If rows above the current position have changed height, this has
* affected the current view and thus needs a redraw.
}
}
-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)
{
}
else
{
- path = _gtk_tree_view_find_path (tree_view, tree, node);
+ path = _gtk_tree_path_new_from_rbtree (tree, node);
gtk_tree_view_set_top_row (tree_view, path, offset);
gtk_tree_path_free (path);
}
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;
}
&cell_x,
&cell_y);
- g_return_if_fail (path != NULL);
+ /* If path is NULL, there's nothing we can drag. For now, we silently
+ * bail out. Actually, dragging should not be possible from an empty
+ * tree view, but there's no way we can cancel that from here.
+ * Automatically unsetting the tree view as drag source for empty models
+ * is something that would likely break other people's code ...
+ */
+ if (!path)
+ return;
row_pix = gtk_tree_view_create_row_drag_icon (tree_view,
path);
(gdk_drag_context_get_selected_action (context) == GDK_ACTION_MOVE),
time);
- if (gtk_tree_path_get_depth (dest_row) == 1
- && gtk_tree_path_get_indices (dest_row)[0] == 0)
+ if (gtk_tree_path_get_depth (dest_row) == 1 &&
+ gtk_tree_path_get_indices (dest_row)[0] == 0 &&
+ gtk_tree_model_iter_n_children (tree_view->priv->model, NULL) != 0)
{
/* special special case drag to "0", scroll to first item */
if (!tree_view->priv->scroll_to_path)
{
tree_view->priv->fixed_height_mode = 0;
tree_view->priv->fixed_height = -1;
-
- /* force a revalidation */
- install_presize_handler (tree_view);
}
else
{
tree_view->priv->fixed_height_mode = 1;
tree_view->priv->fixed_height = -1;
-
- if (tree_view->priv->tree)
- initialize_fixed_height_mode (tree_view);
}
+ /* force a revalidation */
+ install_presize_handler (tree_view);
+
g_object_notify (G_OBJECT (tree_view), "fixed-height-mode");
}
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_path_free (*path);
if (node)
- *path = _gtk_tree_view_find_path (tree_view, tree, node);
+ *path = _gtk_tree_path_new_from_rbtree (tree, node);
else
*path = NULL;
}
GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
GList *list;
GtkTreeViewColumn *column;
+ GtkStyleContext *style_context;
+ const GtkBitmask *changes;
GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->style_updated (widget);
if (gtk_widget_get_realized (widget))
{
- 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_ensure_background (tree_view);
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);
}
- gtk_widget_style_get (widget,
- "expander-size", &tree_view->priv->expander_size,
- NULL);
- tree_view->priv->expander_size += EXPANDER_EXTRA_PADDING;
-
- for (list = tree_view->priv->columns; list; list = list->next)
+ style_context = gtk_widget_get_style_context (widget);
+ changes = _gtk_style_context_get_changes (style_context);
+ if (changes == NULL || _gtk_css_style_property_changes_affect_size (changes))
{
- column = list->data;
- _gtk_tree_view_column_cell_set_dirty (column, TRUE);
- }
-
- tree_view->priv->fixed_height = -1;
- _gtk_rbtree_mark_invalid (tree_view->priv->tree);
+ for (list = tree_view->priv->columns; list; list = list->next)
+ {
+ column = list->data;
+ _gtk_tree_view_column_cell_set_dirty (column, TRUE);
+ }
- gtk_widget_queue_resize (widget);
+ tree_view->priv->fixed_height = -1;
+ _gtk_rbtree_mark_invalid (tree_view->priv->tree);
+ }
}
{
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;
}
g_return_if_fail (path != NULL || iter != NULL);
- if (tree_view->priv->cursor != NULL)
- cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
+ if (tree_view->priv->cursor_node != NULL)
+ cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node);
else
cursor_path = NULL;
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)
{
/* In theory, the model should have emitted has_child_toggled here. We
* try to catch it anyway, just to be safe, in case the model hasn't.
*/
- GtkTreePath *tmppath = _gtk_tree_view_find_path (tree_view,
- tree,
- tmpnode);
+ GtkTreePath *tmppath = _gtk_tree_path_new_from_rbtree (tree, tmpnode);
gtk_tree_view_row_has_child_toggled (model, tmppath, NULL, data);
gtk_tree_path_free (tmppath);
goto done;
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);
GtkRBTree *tree;
GtkRBNode *node;
GList *list;
- gint selection_changed = FALSE;
- GtkStyleContext *context;
+ gboolean selection_changed = FALSE, cursor_changed = FALSE;
+ GtkRBTree *cursor_tree = NULL;
+ GtkRBNode *cursor_node = NULL;
g_return_if_fail (path != NULL);
gtk_tree_view_column_get_sizing (GTK_TREE_VIEW_COLUMN (list->data)) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
_gtk_tree_view_column_cell_set_dirty ((GtkTreeViewColumn *)list->data, TRUE);
- /* Ensure we don't have a dangling pointer to a dead node */
- ensure_unprelighted (tree_view);
+ /* Ensure we don't have a dangling pointer to a dead node */
+ ensure_unprelighted (tree_view);
+
+ /* Cancel editting if we've started */
+ gtk_tree_view_stop_editing (tree_view, TRUE);
+
+ /* If the cursor row got deleted, move the cursor to the next row */
+ if (tree_view->priv->cursor_node &&
+ (tree_view->priv->cursor_node == node ||
+ (node->children && (tree_view->priv->cursor_tree == node->children ||
+ _gtk_rbtree_contains (node->children, tree_view->priv->cursor_tree)))))
+ {
+ GtkTreePath *cursor_path;
+
+ cursor_tree = tree;
+ cursor_node = _gtk_rbtree_next (tree, node);
+ /* find the first node that is not going to be deleted */
+ while (cursor_node == NULL && cursor_tree->parent_tree)
+ {
+ cursor_node = _gtk_rbtree_next (cursor_tree->parent_tree,
+ cursor_tree->parent_node);
+ cursor_tree = cursor_tree->parent_tree;
+ }
+
+ if (cursor_node != NULL)
+ cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
+ else
+ cursor_path = NULL;
+
+ if (cursor_path == NULL ||
+ ! search_first_focusable_path (tree_view, &cursor_path, TRUE,
+ &cursor_tree, &cursor_node))
+ {
+ /* It looks like we reached the end of the view without finding
+ * a focusable row. We will step backwards to find the last
+ * focusable row.
+ */
+ _gtk_rbtree_prev_full (tree, node, &cursor_tree, &cursor_node);
+ if (cursor_node)
+ {
+ cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
+ if (! search_first_focusable_path (tree_view, &cursor_path, FALSE,
+ &cursor_tree, &cursor_node))
+ cursor_node = NULL;
+ gtk_tree_path_free (cursor_path);
+ }
+ }
+ else if (cursor_path)
+ gtk_tree_path_free (cursor_path);
- /* Cancel editting if we've started */
- gtk_tree_view_stop_editing (tree_view, TRUE);
+ cursor_changed = TRUE;
+ }
if (tree_view->priv->destroy_count_func)
{
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_changed)
+ {
+ if (cursor_node)
+ {
+ GtkTreePath *cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
+ gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT | CURSOR_INVALID);
+ gtk_tree_path_free (cursor_path);
+ }
+ else
+ gtk_tree_view_real_set_cursor (tree_view, NULL, CLEAR_AND_SELECT | CURSOR_INVALID);
+ }
if (selection_changed)
g_signal_emit_by_name (tree_view->priv->selection, "changed");
}
_gtk_rbtree_reorder (tree, new_order, len);
+ _gtk_tree_view_accessible_reorder (tree_view);
+
gtk_widget_queue_draw (GTK_WIDGET (tree_view));
gtk_tree_view_dy_to_top_row (tree_view);
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;
}
+ gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
return;
- path = _gtk_tree_view_find_path (tree_view, tree, node);
+ path = _gtk_tree_path_new_from_rbtree (tree, node);
if (path)
{
- /* We process updates because we want to clear old selected items when we scroll.
- * if this is removed, we get a "selection streak" at the bottom. */
- gtk_tree_view_bin_process_updates (tree_view);
-
gtk_tree_view_scroll_to_cell (tree_view, path, NULL, FALSE, 0.0, 0.0);
gtk_tree_path_free (path);
}
/* This function could be more efficient. I'll optimize it if profiling seems
* to imply that it is important */
GtkTreePath *
-_gtk_tree_view_find_path (GtkTreeView *tree_view,
- GtkRBTree *tree,
- GtkRBNode *node)
+_gtk_tree_path_new_from_rbtree (GtkRBTree *tree,
+ GtkRBNode *node)
{
GtkTreePath *path;
GtkRBTree *tmp_tree;
path = gtk_tree_path_new ();
g_return_val_if_fail (node != NULL, path);
- g_return_val_if_fail (node != tree->nil, path);
count = 1 + node->left->count;
tmp_tree = tree;
while (tmp_tree)
{
- while (tmp_node != tmp_tree->nil)
+ while (!_gtk_rbtree_is_nil (tmp_node))
{
if (tmp_node->right == last)
count += 1 + tmp_node->left->count;
GtkRBNode *new_node;
new_tree = node->children;
- new_node = new_tree->root;
-
- while (new_node && new_node->left != new_tree->nil)
- new_node = new_node->left;
+ new_node = _gtk_rbtree_first (new_tree);
if (!gtk_tree_model_iter_children (model, &child, iter))
return FALSE;
- retval = retval || gtk_tree_view_unref_tree_helper (model, &child, new_tree, new_node);
+ retval = gtk_tree_view_unref_tree_helper (model, &child, new_tree, new_node) | retval;
}
if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
if (!tree)
return FALSE;
- node = tree->root;
- while (node && node->left != tree->nil)
- node = node->left;
+ node = _gtk_rbtree_first (tree);
g_return_val_if_fail (node != NULL, FALSE);
- path = _gtk_tree_view_find_path (tree_view, tree, node);
+ path = _gtk_tree_path_new_from_rbtree (tree, node);
gtk_tree_model_get_iter (GTK_TREE_MODEL (tree_view->priv->model),
&iter, path);
retval = gtk_tree_view_unref_tree_helper (GTK_TREE_MODEL (tree_view->priv->model), &iter, tree, node);
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, GTK_STYLE_CLASS_DND);
- gtk_widget_get_allocation (button, &button_allocation);
+ gtk_widget_get_allocation (button, &button_allocation);
- attributes.window_type = GDK_WINDOW_CHILD;
- attributes.wclass = GDK_INPUT_OUTPUT;
- attributes.x = button_allocation.x;
- attributes.y = 0;
- attributes.width = button_allocation.width;
- attributes.height = button_allocation.height;
- attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
- attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
- attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
+ attributes.window_type = GDK_WINDOW_CHILD;
+ attributes.wclass = GDK_INPUT_OUTPUT;
+ attributes.x = button_allocation.x;
+ attributes.y = 0;
+ attributes.width = button_allocation.width;
+ attributes.height = button_allocation.height;
+ attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
+ attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
+ attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
- tree_view->priv->drag_window = gdk_window_new (tree_view->priv->bin_window,
- &attributes,
- attributes_mask);
- gdk_window_set_user_data (tree_view->priv->drag_window, GTK_WIDGET (tree_view));
- }
+ tree_view->priv->drag_window = gdk_window_new (tree_view->priv->header_window,
+ &attributes,
+ attributes_mask);
+ gtk_widget_register_window (GTK_WIDGET (tree_view), tree_view->priv->drag_window);
if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
{
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;
- state = gtk_cell_renderer_get_state (NULL, widget, flags);
+ if (node == tree_view->priv->prelight_node &&
+ tree_view->priv->arrow_prelit)
+ flags |= GTK_CELL_RENDERER_PRELIT;
- if (node == tree_view->priv->prelight_node &&
- tree_view->priv->arrow_prelit)
- state |= GTK_STATE_FLAG_PRELIGHT;
- }
+ state = gtk_cell_renderer_get_state (NULL, widget, flags);
if (node->children != NULL)
state |= GTK_STATE_FLAG_ACTIVE;
+ else
+ state &= ~(GTK_STATE_FLAG_ACTIVE);
gtk_style_context_save (context);
gtk_style_context_set_state (context, state);
gtk_style_context_add_class (context, GTK_STYLE_CLASS_EXPANDER);
- gtk_style_context_push_animatable_region (context, node);
-
gtk_render_expander (context, cr,
area.x, area.y,
area.width, area.height);
- gtk_style_context_pop_animatable_region (context);
gtk_style_context_restore (context);
}
return;
cursor_path = NULL;
- if (tree_view->priv->cursor)
- cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
+ if (tree_view->priv->cursor_node)
+ cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node);
if (cursor_path == NULL)
{
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
{
TRUE, NULL, NULL);
}
- gtk_tree_row_reference_free (tree_view->priv->cursor);
- tree_view->priv->cursor = NULL;
-
if (cursor_path)
{
if (gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE)
- gtk_tree_view_real_set_cursor (tree_view, cursor_path, FALSE, FALSE);
+ gtk_tree_view_real_set_cursor (tree_view, cursor_path, 0);
else
- gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE);
+ gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT);
}
}
{
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 */
gint count)
{
gint selection_count;
- GtkRBTree *cursor_tree = NULL;
- GtkRBNode *cursor_node = NULL;
GtkRBTree *new_cursor_tree = NULL;
GtkRBNode *new_cursor_node = NULL;
GtkTreePath *cursor_path = NULL;
if (! gtk_widget_has_focus (GTK_WIDGET (tree_view)))
return;
- cursor_path = NULL;
- if (!gtk_tree_row_reference_valid (tree_view->priv->cursor))
- /* FIXME: we lost the cursor; should we get the first? */
+ if (tree_view->priv->cursor_node == NULL)
return;
- cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
- _gtk_tree_view_find_node (tree_view, cursor_path,
- &cursor_tree, &cursor_node);
-
- if (cursor_tree == NULL)
- /* FIXME: we lost the cursor; should we get the first? */
- return;
+ cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node);
direction = count < 0 ? GTK_DIR_UP : GTK_DIR_DOWN;
{
gtk_tree_view_column_cell_set_cell_data (tree_view->priv->focus_column,
tree_view->priv->model,
- &iter,
- GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT),
- cursor_node->children?TRUE:FALSE);
+ &iter,
+ GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_PARENT),
+ tree_view->priv->cursor_node->children ? TRUE : FALSE);
/* Save the last cell that had focus, if we hit the end of the view we'll give
* focus back to it. */
selection_count = gtk_tree_selection_count_selected_rows (tree_view->priv->selection);
selectable = _gtk_tree_selection_row_is_selectable (tree_view->priv->selection,
- cursor_node,
+ tree_view->priv->cursor_node,
cursor_path);
if (selection_count == 0
&& selectable)
{
/* Don't move the cursor, but just select the current node */
- new_cursor_tree = cursor_tree;
- new_cursor_node = cursor_node;
+ new_cursor_tree = tree_view->priv->cursor_tree;
+ new_cursor_node = tree_view->priv->cursor_node;
}
else
{
if (count == -1)
- _gtk_rbtree_prev_full (cursor_tree, cursor_node,
+ _gtk_rbtree_prev_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
&new_cursor_tree, &new_cursor_node);
else
- _gtk_rbtree_next_full (cursor_tree, cursor_node,
+ _gtk_rbtree_next_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
&new_cursor_tree, &new_cursor_node);
}
if (new_cursor_node)
{
- cursor_path = _gtk_tree_view_find_path (tree_view,
- new_cursor_tree, new_cursor_node);
+ cursor_path = _gtk_tree_path_new_from_rbtree (new_cursor_tree, new_cursor_node);
search_first_focusable_path (tree_view, &cursor_path,
(count != -1),
new_cursor_node == NULL)
{
if (count == -1)
- _gtk_rbtree_next_full (cursor_tree, cursor_node,
+ _gtk_rbtree_next_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
&new_cursor_tree, &new_cursor_node);
else
- _gtk_rbtree_prev_full (cursor_tree, cursor_node,
+ _gtk_rbtree_prev_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
&new_cursor_tree, &new_cursor_node);
if (new_cursor_node == NULL
- && !GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_SELECTED))
+ && !GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_SELECTED))
{
- new_cursor_node = cursor_node;
- new_cursor_tree = cursor_tree;
+ new_cursor_node = tree_view->priv->cursor_node;
+ new_cursor_tree = tree_view->priv->cursor_tree;
}
else
{
+ new_cursor_tree = NULL;
new_cursor_node = NULL;
}
}
if (new_cursor_node)
{
- cursor_path = _gtk_tree_view_find_path (tree_view, new_cursor_tree, new_cursor_node);
- gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, TRUE);
+ cursor_path = _gtk_tree_path_new_from_rbtree (new_cursor_tree, new_cursor_node);
+ gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT | CLAMP_NODE);
gtk_tree_path_free (cursor_path);
/* Give focus to the area in the new row */
}
else
{
- gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
+ gtk_tree_view_clamp_node_visible (tree_view,
+ tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node);
if (!tree_view->priv->extend_selection_pressed)
{
gtk_tree_view_move_cursor_page_up_down (GtkTreeView *tree_view,
gint count)
{
- GtkRBTree *cursor_tree = NULL;
- GtkRBNode *cursor_node = NULL;
GtkTreePath *old_cursor_path = NULL;
GtkTreePath *cursor_path = NULL;
GtkRBTree *start_cursor_tree = NULL;
GtkRBNode *start_cursor_node = NULL;
+ GtkRBTree *cursor_tree;
+ GtkRBNode *cursor_node;
gint y;
gint window_y;
gint vertical_separator;
if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
return;
- if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
- old_cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
- else
- /* This is sorta weird. Focus in should give us a cursor */
+ if (tree_view->priv->cursor_node == NULL)
return;
- gtk_widget_style_get (GTK_WIDGET (tree_view), "vertical-separator", &vertical_separator, NULL);
- _gtk_tree_view_find_node (tree_view, old_cursor_path,
- &cursor_tree, &cursor_node);
+ old_cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node);
- if (cursor_tree == NULL)
- {
- /* FIXME: we lost the cursor. Should we try to get one? */
- gtk_tree_path_free (old_cursor_path);
- return;
- }
- g_return_if_fail (cursor_node != NULL);
+ gtk_widget_style_get (GTK_WIDGET (tree_view), "vertical-separator", &vertical_separator, NULL);
- y = _gtk_rbtree_node_find_offset (cursor_tree, cursor_node);
+ y = _gtk_rbtree_node_find_offset (tree_view->priv->cursor_tree, tree_view->priv->cursor_node);
window_y = RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, y);
y += tree_view->priv->cursor_offset;
y += count * (int)gtk_adjustment_get_page_increment (tree_view->priv->vadjustment);
}
y -= tree_view->priv->cursor_offset;
- cursor_path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
+ cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
start_cursor_tree = cursor_tree;
start_cursor_node = cursor_node;
*/
cursor_tree = start_cursor_tree;
cursor_node = start_cursor_node;
- cursor_path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
+ cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
search_first_focusable_path (tree_view, &cursor_path,
(count == -1),
/* update y */
y = _gtk_rbtree_node_find_offset (cursor_tree, cursor_node);
- gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE);
+ gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT);
y -= window_y;
gtk_tree_view_scroll_to_point (tree_view, -1, y);
gtk_tree_view_move_cursor_left_right (GtkTreeView *tree_view,
gint count)
{
- GtkRBTree *cursor_tree = NULL;
- GtkRBNode *cursor_node = NULL;
GtkTreePath *cursor_path = NULL;
GtkTreeViewColumn *column;
GtkTreeIter iter;
if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
return;
- if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
- cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
- else
+ if (tree_view->priv->cursor_node == NULL)
return;
- _gtk_tree_view_find_node (tree_view, cursor_path, &cursor_tree, &cursor_node);
- if (cursor_tree == NULL)
- return;
+ cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node);
+
if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path) == FALSE)
{
gtk_tree_path_free (cursor_path);
gtk_tree_view_column_cell_set_cell_data (column,
tree_view->priv->model,
&iter,
- GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT),
- cursor_node->children?TRUE:FALSE);
+ GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_PARENT),
+ tree_view->priv->cursor_node->children ? TRUE : FALSE);
cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
if (gtk_cell_area_focus (cell_area, direction))
{
- tree_view->priv->focus_column = column;
+ _gtk_tree_view_set_focus_column (tree_view, column);
found_column = TRUE;
break;
}
{
if (!gtk_tree_view_has_can_focus_cell (tree_view))
_gtk_tree_view_queue_draw_node (tree_view,
- cursor_tree,
- cursor_node,
+ tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node,
NULL);
g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
gtk_widget_grab_focus (GTK_WIDGET (tree_view));
gtk_tree_view_get_cursor (tree_view, &old_path, NULL);
cursor_tree = tree_view->priv->tree;
- cursor_node = cursor_tree->root;
if (count == -1)
{
- while (cursor_node && cursor_node->left != cursor_tree->nil)
- cursor_node = cursor_node->left;
+ cursor_node = _gtk_rbtree_first (cursor_tree);
/* Now go forward to find the first focusable row. */
- path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
+ path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
search_first_focusable_path (tree_view, &path,
TRUE, &cursor_tree, &cursor_node);
}
else
{
+ cursor_node = cursor_tree->root;
+
do
{
- while (cursor_node && cursor_node->right != cursor_tree->nil)
+ while (cursor_node && !_gtk_rbtree_is_nil (cursor_node->right))
cursor_node = cursor_node->right;
if (cursor_node->children == NULL)
break;
while (1);
/* Now go backwards to find last focusable row. */
- path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
+ path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
search_first_focusable_path (tree_view, &path,
FALSE, &cursor_tree, &cursor_node);
}
if (gtk_tree_path_compare (old_path, path))
{
- gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE);
+ gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CLAMP_NODE);
gtk_widget_grab_focus (GTK_WIDGET (tree_view));
}
else
if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
return FALSE;
- if (tree_view->priv->cursor)
- cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
-
- if (cursor_path == NULL)
+ if (tree_view->priv->cursor_node == NULL)
return FALSE;
+ cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node);
+
_gtk_tree_view_find_node (tree_view, cursor_path,
&cursor_tree, &cursor_node);
{
GtkRBTree *new_tree = NULL;
GtkRBNode *new_node = NULL;
- GtkRBTree *cursor_tree = NULL;
- GtkRBNode *cursor_node = NULL;
GtkTreePath *cursor_path = NULL;
if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
return FALSE;
- cursor_path = NULL;
- if (tree_view->priv->cursor)
- cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
-
- if (cursor_path == NULL)
+ if (tree_view->priv->cursor_node == NULL)
return FALSE;
- _gtk_tree_view_find_node (tree_view, cursor_path,
- &cursor_tree, &cursor_node);
- if (cursor_tree == NULL)
- {
- gtk_tree_path_free (cursor_path);
- return FALSE;
- }
+ cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node);
_gtk_tree_selection_internal_select_node (tree_view->priv->selection,
- cursor_node,
- cursor_tree,
+ tree_view->priv->cursor_node,
+ tree_view->priv->cursor_tree,
cursor_path,
GTK_TREE_SELECT_MODE_TOGGLE,
FALSE);
*/
_gtk_tree_view_find_node (tree_view, cursor_path, &new_tree, &new_node);
- if (cursor_tree != new_tree || cursor_node != new_node)
+ if (tree_view->priv->cursor_node != new_node)
return FALSE;
- gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
+ gtk_tree_view_clamp_node_visible (tree_view,
+ tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node);
gtk_widget_grab_focus (GTK_WIDGET (tree_view));
gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
gboolean open_all)
{
GtkTreePath *cursor_path = NULL;
- GtkRBTree *tree;
- GtkRBNode *node;
if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
return FALSE;
- cursor_path = NULL;
- if (tree_view->priv->cursor)
- cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
-
- if (cursor_path == NULL)
+ if (tree_view->priv->cursor_node == NULL)
return FALSE;
- if (_gtk_tree_view_find_node (tree_view, cursor_path, &tree, &node))
- return FALSE;
+ cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node);
/* Don't handle the event if we aren't an expander */
- if (!((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT))
+ if (!GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_PARENT))
return FALSE;
if (!logical
expand = !expand;
if (expand)
- gtk_tree_view_real_expand_row (tree_view, cursor_path, tree, node, open_all, TRUE);
+ gtk_tree_view_real_expand_row (tree_view,
+ cursor_path,
+ tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node,
+ open_all,
+ TRUE);
else
- gtk_tree_view_real_collapse_row (tree_view, cursor_path, tree, node, TRUE);
+ gtk_tree_view_real_collapse_row (tree_view,
+ cursor_path,
+ tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node,
+ TRUE);
gtk_tree_path_free (cursor_path);
static gboolean
gtk_tree_view_real_select_cursor_parent (GtkTreeView *tree_view)
{
- GtkRBTree *cursor_tree = NULL;
- GtkRBNode *cursor_node = NULL;
GtkTreePath *cursor_path = NULL;
GdkModifierType state;
if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
goto out;
- cursor_path = NULL;
- if (tree_view->priv->cursor)
- cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
-
- if (cursor_path == NULL)
+ if (tree_view->priv->cursor_node == NULL)
goto out;
- _gtk_tree_view_find_node (tree_view, cursor_path,
- &cursor_tree, &cursor_node);
- if (cursor_tree == NULL)
- {
- gtk_tree_path_free (cursor_path);
- goto out;
- }
+ cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node);
- if (cursor_tree->parent_node)
+ if (tree_view->priv->cursor_tree->parent_node)
{
gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
- cursor_node = cursor_tree->parent_node;
- cursor_tree = cursor_tree->parent_tree;
gtk_tree_path_up (cursor_path);
tree_view->priv->modify_selection_pressed = TRUE;
}
- gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE);
- gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
+ gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT | CLAMP_NODE);
+ gtk_tree_path_free (cursor_path);
gtk_widget_grab_focus (GTK_WIDGET (tree_view));
- gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
- gtk_tree_path_free (cursor_path);
tree_view->priv->modify_selection_pressed = FALSE;
TRUE);
}
-/* this function returns the new width of the column being resized given
- * the column and x position of the cursor; the x cursor position is passed
- * in as a pointer and automagicly corrected if it's beyond min/max limits
- */
-static gint
-gtk_tree_view_new_column_width (GtkTreeView *tree_view,
- gint i,
- gint *x)
-{
- GtkAllocation allocation;
- GtkTreeViewColumn *column;
- GtkRequisition button_req;
- gint max_width, min_width;
- gint width;
- gboolean rtl;
-
- /* first translate the x position from widget->window
- * to clist->clist_window
- */
- rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
- column = g_list_nth (tree_view->priv->columns, i)->data;
- gtk_widget_get_allocation (gtk_tree_view_column_get_button (column), &allocation);
- width = rtl ? (allocation.x + allocation.width - *x) : (*x - allocation.x);
-
- /* Clamp down the value */
- min_width = gtk_tree_view_column_get_min_width (column);
- if (min_width == -1)
- {
- gtk_widget_get_preferred_size (gtk_tree_view_column_get_button (column), &button_req, NULL);
- width = MAX (button_req.width, width);
- }
- else
- width = MAX (min_width, width);
-
- max_width = gtk_tree_view_column_get_max_width (column);
- if (max_width != -1)
- width = MIN (width, max_width);
-
- *x = rtl ? (allocation.x + allocation.width - width) : (allocation.x + width);
-
- return width;
-}
-
-
/* FIXME this adjust_allocation is a big cut-and-paste from
* GtkCList, needs to be some "official" way to do this
* factored out.
{
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;
- gtk_tree_row_reference_free (tree_view->priv->cursor);
- tree_view->priv->cursor = NULL;
gtk_tree_row_reference_free (tree_view->priv->anchor);
tree_view->priv->anchor = NULL;
gtk_tree_row_reference_free (tree_view->priv->top_row);
{
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().
return tree_view->priv->has_rules;
}
+
+/**
+ * gtk_tree_view_set_activate_on_single_click:
+ * @tree_view: a #GtkTreeView
+ * @single: %TRUE to emit row-activated on a single click
+ *
+ * Cause the #GtkTreeView::row-activated signal to be emitted
+ * on a single click instead of a double click.
+ *
+ * Since: 3.8
+ **/
+void
+gtk_tree_view_set_activate_on_single_click (GtkTreeView *tree_view,
+ gboolean single)
+{
+ g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
+
+ single = single != FALSE;
+
+ if (tree_view->priv->activate_on_single_click == single)
+ return;
+
+ tree_view->priv->activate_on_single_click = single;
+ g_object_notify (G_OBJECT (tree_view), "activate-on-single-click");
+}
+
+/**
+ * gtk_tree_view_get_activate_on_single_click:
+ * @tree_view: a #GtkTreeView
+ *
+ * Gets the setting set by gtk_tree_view_set_activate_on_single_click().
+ *
+ * Return value: %TRUE if row-activated will be emitted on a single click
+ *
+ * Since: 3.8
+ **/
+gboolean
+gtk_tree_view_get_activate_on_single_click (GtkTreeView *tree_view)
+{
+ g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
+
+ return tree_view->priv->activate_on_single_click;
+}
+
/* Public Column functions
*/
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
GtkTreePath *path;
GtkTreeIter iter;
- path = _gtk_tree_view_find_path (tree_view, tree, node);
+ path = _gtk_tree_path_new_from_rbtree (tree, node);
gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path);
indices = gtk_tree_path_get_indices (path);
tree = tree_view->priv->tree;
- node = tree->root;
- while (node && node->left != tree->nil)
- node = node->left;
+ node = _gtk_rbtree_first (tree);
while (node)
{
gtk_tree_path_append_index (tmp_path, 0);
tree = node->children;
- node = tree->root;
- while (node->left != tree->nil)
- node = node->left;
+ node = _gtk_rbtree_first (tree);
/* try to expand the children */
do
{
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);
gint x, y;
GList *list;
GdkWindow *child;
+ gboolean selection_changed, cursor_changed;
if (animate)
g_object_get (gtk_widget_get_settings (GTK_WIDGET (tree_view)),
gtk_tree_path_free (child_path);
}
- if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
+ if (tree_view->priv->cursor_node)
{
- GtkTreePath *cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
-
- if (gtk_tree_path_is_ancestor (path, cursor_path))
- {
- gtk_tree_row_reference_free (tree_view->priv->cursor);
- tree_view->priv->cursor = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
- tree_view->priv->model,
- path);
- }
- gtk_tree_path_free (cursor_path);
+ cursor_changed = (node->children == tree_view->priv->cursor_tree)
+ || _gtk_rbtree_contains (node->children, tree_view->priv->cursor_tree);
}
+ else
+ cursor_changed = FALSE;
if (gtk_tree_row_reference_valid (tree_view->priv->anchor))
{
gtk_tree_path_free (anchor_path);
}
+ selection_changed = gtk_tree_view_unref_and_check_selection_tree (tree_view, node->children);
+
/* Stop a pending double click */
tree_view->priv->last_button_x = -1;
tree_view->priv->last_button_y = -1;
_gtk_tree_view_accessible_remove (tree_view, node->children, NULL);
+ _gtk_tree_view_accessible_remove_state (tree_view,
+ tree, node,
+ GTK_CELL_RENDERER_EXPANDED);
- if (gtk_tree_view_unref_and_check_selection_tree (tree_view, node->children))
- {
- _gtk_rbtree_remove (node->children);
- g_signal_emit_by_name (tree_view->priv->selection, "changed");
- }
- else
- _gtk_rbtree_remove (node->children);
-
- if (animate)
- {
- GtkStyleContext *context;
-
- context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
-
- gtk_style_context_save (context);
- gtk_style_context_add_class (context, GTK_STYLE_CLASS_EXPANDER);
-
- gtk_style_context_notify_state_change (context, tree_view->priv->bin_window,
- node, GTK_STATE_ACTIVE, FALSE);
+ _gtk_rbtree_remove (node->children);
- _gtk_style_context_invalidate_animation_areas (context);
- gtk_style_context_restore (context);
- }
+ if (cursor_changed)
+ gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CURSOR_INVALID);
+ if (selection_changed)
+ g_signal_emit_by_name (tree_view->priv->selection, "changed");
if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
{
if (tree == NULL || tree->root == NULL)
return;
- node = tree->root;
-
- while (node && node->left != tree->nil)
- node = node->left;
+ node = _gtk_rbtree_first (tree);
while (node)
{
static void
gtk_tree_view_real_set_cursor (GtkTreeView *tree_view,
GtkTreePath *path,
- gboolean clear_and_select,
- gboolean clamp_node)
+ SetCursorFlags flags)
{
- GtkRBTree *tree = NULL;
- GtkRBNode *node = NULL;
-
- if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
+ if (!(flags & CURSOR_INVALID) && tree_view->priv->cursor_node)
{
- GtkTreePath *cursor_path;
- cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
- gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
- gtk_tree_path_free (cursor_path);
+ _gtk_tree_view_accessible_remove_state (tree_view,
+ tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node,
+ GTK_CELL_RENDERER_FOCUSED);
+ _gtk_tree_view_queue_draw_node (tree_view,
+ tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node,
+ NULL);
}
- gtk_tree_row_reference_free (tree_view->priv->cursor);
- tree_view->priv->cursor = NULL;
-
/* One cannot set the cursor on a separator. Also, if
* _gtk_tree_view_find_node returns TRUE, it ran out of tree
* before finding the tree and node belonging to path. The
* path maps to a non-existing path and we will silently bail out.
* We unset tree and node to avoid further processing.
*/
- if (!row_is_separator (tree_view, NULL, path)
- && _gtk_tree_view_find_node (tree_view, path, &tree, &node) == FALSE)
- {
- tree_view->priv->cursor =
- gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
- tree_view->priv->model,
- path);
- }
- else
+ if (path == NULL ||
+ row_is_separator (tree_view, NULL, path)
+ || _gtk_tree_view_find_node (tree_view,
+ path,
+ &tree_view->priv->cursor_tree,
+ &tree_view->priv->cursor_node))
{
- tree = NULL;
- node = NULL;
+ tree_view->priv->cursor_tree = NULL;
+ tree_view->priv->cursor_node = NULL;
}
- if (tree != NULL)
+ if (tree_view->priv->cursor_node != NULL)
{
GtkRBTree *new_tree = NULL;
GtkRBNode *new_node = NULL;
- if (clear_and_select && !tree_view->priv->modify_selection_pressed)
+ if ((flags & CLEAR_AND_SELECT) && !tree_view->priv->modify_selection_pressed)
{
GtkTreeSelectMode mode = 0;
mode |= GTK_TREE_SELECT_MODE_EXTEND;
_gtk_tree_selection_internal_select_node (tree_view->priv->selection,
- node, tree, path, mode,
+ tree_view->priv->cursor_node,
+ tree_view->priv->cursor_tree,
+ path,
+ mode,
FALSE);
}
*/
_gtk_tree_view_find_node (tree_view, path, &new_tree, &new_node);
- if (tree != new_tree || node != new_node)
+ if (tree_view->priv->cursor_node != new_node)
return;
- if (clamp_node)
+ if (flags & CLAMP_NODE)
{
- gtk_tree_view_clamp_node_visible (tree_view, tree, node);
- _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
+ gtk_tree_view_clamp_node_visible (tree_view,
+ tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node);
+ _gtk_tree_view_queue_draw_node (tree_view,
+ tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node,
+ NULL);
}
+
+ _gtk_tree_view_accessible_add_state (tree_view,
+ tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node,
+ GTK_CELL_RENDERER_FOCUSED);
}
g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
if (path)
{
- if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
- *path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
+ if (tree_view->priv->cursor_node)
+ *path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node);
else
*path = NULL;
}
(gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->edited_column))))
gtk_tree_view_stop_editing (tree_view, TRUE);
- gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE);
+ gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CLAMP_NODE);
if (focus_column &&
gtk_tree_view_column_get_visible (focus_column))
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)
*cell_y = y_offset;
if (path)
- *path = _gtk_tree_view_find_path (tree_view, tree, node);
+ *path = _gtk_tree_path_new_from_rbtree (tree, node);
return TRUE;
}
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;
}
TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, 0),
&tree, &node);
if (node)
- *start_path = _gtk_tree_view_find_path (tree_view, tree, node);
+ *start_path = _gtk_tree_path_new_from_rbtree (tree, node);
else
retval = FALSE;
}
_gtk_rbtree_find_offset (tree_view->priv->tree, y, &tree, &node);
if (node)
- *end_path = _gtk_tree_view_find_path (tree_view, tree, node);
+ *end_path = _gtk_tree_path_new_from_rbtree (tree, node);
else
retval = FALSE;
}
GtkRBTree *tree;
GtkRBNode *node;
GtkStyleContext *context;
- GtkStateFlags state;
gint cell_offset;
GList *list;
GdkRectangle background_area;
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,
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);
GtkTreeView *tree_view)
{
GtkTreePath *path;
- GtkRBNode *node;
- GtkRBTree *tree;
gtk_tree_view_search_dialog_hide (tree_view->priv->search_window,
tree_view,
/* If we have a row selected and it's the cursor row, we activate
* the row XXX */
- if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
+ if (tree_view->priv->cursor_node &&
+ GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_SELECTED))
{
- path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
-
- _gtk_tree_view_find_node (tree_view, path, &tree, &node);
+ path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
+ tree_view->priv->cursor_node);
- if (node && GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
- gtk_tree_view_row_activated (tree_view, path, tree_view->priv->focus_column);
+ gtk_tree_view_row_activated (tree_view, path, tree_view->priv->focus_column);
gtk_tree_path_free (path);
}
gtk_tree_view_scroll_to_cell (tree_view, path, NULL,
TRUE, 0.5, 0.0);
gtk_tree_selection_select_iter (selection, iter);
- gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
+ gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
if (path)
gtk_tree_path_free (path);
GtkTreeIter tmp;
tree = node->children;
- node = tree->root;
-
- while (node->left != tree->nil)
- node = node->left;
+ node = _gtk_rbtree_first (tree);
tmp = *iter;
has_child = gtk_tree_model_iter_children (model, iter, &tmp);
tree_view->priv->edited_column = column;
- gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
+ gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
cell_area->y += pre_val - (int)gtk_adjustment_get_value (tree_view->priv->vadjustment);
gtk_widget_get_preferred_size (GTK_WIDGET (cell_editable),
* @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.
*
GtkStateFlags previous_state)
{
if (gtk_widget_get_realized (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_tree_view_ensure_background (GTK_TREE_VIEW (widget));
gtk_widget_queue_draw (widget);
}
* for you. @column should be set to the column in @tree_view's model
* containing the tooltip texts, or -1 to disable this feature.
*
- * When enabled, #GtkWidget::has-tooltip will be set to %TRUE and
+ * When enabled, #GtkWidget:has-tooltip will be set to %TRUE and
* @tree_view will connect a #GtkWidget::query-tooltip signal handler.
*
* Note that the signal handler sets the text with gtk_tooltip_set_markup(),