#define GTK_TREE_VIEW_PRIORITY_SCROLL_SYNC (GTK_TREE_VIEW_PRIORITY_VALIDATE + 2)
#define GTK_TREE_VIEW_TIME_MS_PER_IDLE 30
#define SCROLL_EDGE_SIZE 15
-#define EXPANDER_EXTRA_PADDING 4
#define GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT 5000
#define AUTO_EXPAND_TIMEOUT 500
gint drag_pos;
gint x_drag;
- /* Non-interactive Header Resizing, expand flag support */
- 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 */
-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;
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;
GtkStyleContext *context;
context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
+
+ gtk_style_context_set_background (context, tree_view->priv->bin_window);
+ gtk_style_context_set_background (context, gtk_widget_get_window (GTK_WIDGET (tree_view)));
gtk_style_context_set_background (context, tree_view->priv->header_window);
}
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);
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);
+ gtk_widget_register_window (widget, tree_view->priv->header_window);
gtk_tree_view_ensure_background (tree_view);
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;
}
GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
GList *list;
GtkTreeViewColumn *column;
- gint width = 0;
+ gint column_minimum, column_natural;
/* 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; 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;
- 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++;
}
- *minimum = *natural = width;
+ if (minimum != NULL)
+ *minimum = tree_view->priv->minimum_width;
+ if (natural != NULL)
+ *natural = tree_view->priv->natural_width;
}
static void
height = tree_view->priv->height + gtk_tree_view_get_effective_header_height (tree_view);
- *minimum = *natural = height;
+ if (minimum != NULL)
+ *minimum = height;
+ if (natural != NULL)
+ *natural = height;
+}
+
+static void
+gtk_tree_view_modify_column_width (GtkTreeView *tree_view,
+ GtkTreeViewColumn *column,
+ gint width)
+{
+ gboolean is_expand;
+ gint n_expand_others;
+ gint minimum, natural, natural_others;
+ gint expand;
+
+ is_expand = gtk_tree_view_column_get_expand (column);
+ n_expand_others = tree_view->priv->n_expand_columns - (is_expand ? 1 : 0);
+
+ _gtk_tree_view_column_request_width (column, &minimum, &natural);
+ natural_others = tree_view->priv->natural_width - natural;
+
+ 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;
+
+ if (column == last->data)
+ return;
+
+ gtk_tree_view_column_set_expand (last->data, TRUE);
+ n_expand_others++;
+ }
+
+ /* Now try to make this column expandable also. Solving the following
+ * equations reveals what the natural width should be to achieve the
+ * desired width after expanding:
+ *
+ * 1. natural + expand = desired_width
+ * 2. natural + natural_others + expand * (n_expand_others + 1) = total_width
+ *
+ * Solution:
+ * expand = (total_width - natural_others - desired_width) / n_expand_others
+ *
+ * It is possible for the solved natural width to be less than the
+ * minimum; in that case, we cannot let the column expand.
+ */
+ expand = (tree_view->priv->width - natural_others - width) / n_expand_others;
+
+ if (minimum + expand > width)
+ {
+ if (is_expand)
+ gtk_tree_view_column_set_expand (column, FALSE);
+ }
+ else
+ {
+ if (!is_expand)
+ gtk_tree_view_column_set_expand (column, TRUE);
+
+ 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,
gtk_tree_view_get_expander_size (GtkTreeView *tree_view)
{
gint expander_size;
+ gint horizontal_separator;
gtk_widget_style_get (GTK_WIDGET (tree_view),
"expander-size", &expander_size,
+ "horizontal-separator", &horizontal_separator,
NULL);
- expander_size += EXPANDER_EXTRA_PADDING;
- return expander_size;
+ return expander_size + (horizontal_separator / 2);
}
static gboolean
}
}
- /* Test if a double click happened on the same row. */
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;
}
}
drag_data);
column_width = gtk_tree_view_column_get_width (column);
- gtk_tree_view_column_set_fixed_width (column, column_width);
- gtk_tree_view_column_set_expand (column, FALSE);
-
gdk_window_get_device_position (tree_view->priv->bin_window,
gdk_event_get_device ((GdkEvent *) event),
&x, NULL, NULL);
tree_view->priv->cur_reorder->left_column);
}
tree_view->priv->drag_column = NULL;
+ gtk_widget_unregister_window (widget, tree_view->priv->drag_window);
gdk_window_destroy (tree_view->priv->drag_window);
tree_view->priv->drag_window = NULL;
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 == GDK_BUTTON_PRIMARY)
+ 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;
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->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);
{
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);
{
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.width = width;
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);
gdk_window_get_device_position (tree_view->priv->bin_window,
gdk_event_get_device ((GdkEvent *) event),
&x, NULL, NULL);
-
+
if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
new_width = MAX (tree_view->priv->x_drag - x, 0);
else
new_width = MAX (x - tree_view->priv->x_drag, 0);
-
- if (new_width != gtk_tree_view_column_get_fixed_width (column))
- gtk_tree_view_column_set_fixed_width (column, new_width);
+
+ if (new_width != gtk_tree_view_column_get_width (column))
+ gtk_tree_view_modify_column_width (tree_view, column, new_width);
return FALSE;
}
column_width = column_width + 2;
}
- gtk_tree_view_column_set_fixed_width (column, column_width);
- gtk_tree_view_column_set_expand (column, FALSE);
+ gtk_tree_view_modify_column_width (tree_view, column, column_width);
return TRUE;
}
_gtk_rbtree_node_set_height (tree, node, height);
}
_gtk_rbtree_node_mark_valid (tree, node);
- tree_view->priv->post_validation_flag = TRUE;
return retval;
}
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;
done:
if (validated_area)
{
+ GtkRequisition requisition;
+
+ /* We temporarily guess a size, under the assumption that it will be the
+ * same when we get our next size_allocate. If we don't do this, we'll be
+ * in an inconsistent state when we call top_row_to_dy. */
+
+ /* FIXME: This is called from size_request, for some reason it is not infinitely
+ * recursing, we cannot call gtk_widget_get_preferred_size() here because that's
+ * not allowed (from inside ->get_preferred_width/height() implementations, one
+ * should call the vfuncs directly). However what is desired here is the full
+ * size including any margins and limited by any alignment (i.e. after
+ * GtkWidget:adjust_size_request() is called).
+ *
+ * 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).
+ */
+ 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.
*/
if (y != -1 && y < gtk_adjustment_get_value (tree_view->priv->vadjustment))
gtk_widget_queue_draw (GTK_WIDGET (tree_view));
+ gtk_adjustment_set_upper (tree_view->priv->hadjustment,
+ MAX (gtk_adjustment_get_upper (tree_view->priv->hadjustment), requisition.width));
+ gtk_adjustment_set_upper (tree_view->priv->vadjustment,
+ MAX (gtk_adjustment_get_upper (tree_view->priv->vadjustment), requisition.height));
+
if (queue_resize)
gtk_widget_queue_resize_no_redraw (GTK_WIDGET (tree_view));
}
GList *list;
GtkTreeViewColumn *tmp_column = NULL;
gint total_width;
- gint expander_size;
+ gint expander_size, expander_render_size;
+ gint horizontal_separator;
gboolean indent_expanders;
gboolean rtl;
+ gtk_widget_style_get (GTK_WIDGET (tree_view),
+ "indent-expanders", &indent_expanders,
+ "horizontal-separator", &horizontal_separator,
+ NULL);
+
rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
expander_size = gtk_tree_view_get_expander_size (tree_view);
+ expander_render_size = expander_size - (horizontal_separator / 2);
total_width = 0;
for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
total_width += gtk_tree_view_column_get_width (tmp_column);
}
- gtk_widget_style_get (GTK_WIDGET (tree_view),
- "indent-expanders", &indent_expanders,
- NULL);
+ x_offset += (expander_size - expander_render_size);
if (indent_expanders)
{
if (tmp_column &&
gtk_tree_view_column_get_visible (tmp_column))
/* +1 because x2 isn't included in the range. */
- *x2 = *x1 + expander_size + 1;
+ *x2 = *x1 + expander_render_size + 1;
else
*x2 = *x1;
}
tree_view->priv->drag_window = gdk_window_new (tree_view->priv->header_window,
&attributes,
attributes_mask);
- gdk_window_set_user_data (tree_view->priv->drag_window, GTK_WIDGET (tree_view));
+ gtk_widget_register_window (GTK_WIDGET (tree_view), tree_view->priv->drag_window);
if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
{
gint x_offset = 0;
gint x2;
gint vertical_separator;
- gint expander_size;
GtkCellRendererState flags = 0;
widget = GTK_WIDGET (tree_view);
gtk_widget_style_get (widget,
"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.x = x_offset;
area.y = gtk_tree_view_get_cell_area_y_offset (tree_view, tree, node,
vertical_separator);
- area.width = expander_size;
+ area.width = x2 - x_offset;
area.height = gtk_tree_view_get_cell_area_height (tree_view, node,
vertical_separator);
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
*/
projects / ~andy / gtk / blobdiff