[gtk+/resolution-independence: 18/24] port GtkTreeView, GtkIconView, GtkComboBox and all GtkCellRenderer's to RI
- From: Davyd Madeley <davyd src gnome org>
- To: svn-commits-list gnome org
- Subject: [gtk+/resolution-independence: 18/24] port GtkTreeView, GtkIconView, GtkComboBox and all GtkCellRenderer's to RI
- Date: Sat, 2 May 2009 02:18:32 -0400 (EDT)
commit 42efae2d47b003b698d7df1b3e128fc4b4ddf56b
Author: David Zeuthen <davidz redhat com>
Date: Wed Aug 13 16:05:48 2008 -0400
port GtkTreeView, GtkIconView, GtkComboBox and all GtkCellRenderer's to RI
min/max for GtkCellRenderer
min/max for GtkCellRendererToggle
min/max for GtkComboBox
min/max for GtkIconView
min/max for GtkTreeView
min/max for GtkTreeViewColumn
fixed gtkcellrenderer.c
fixed gtkcellrenderertoggle.c
fixed gtkcombobox.c
fixed gtkiconview.c
fixed gtktreeview.c
fixed gtktreeviewcolumn.c
---
docs/reference/gtk/gtk-sections.txt | 14 ++
gtk/gtk.symbols | 14 ++
gtk/gtkcellrenderer.c | 215 +++++++++++++++++++++++++++------
gtk/gtkcellrenderer.h | 29 ++++-
gtk/gtkcellrendererpixbuf.c | 7 +-
gtk/gtkcellrenderertoggle.c | 23 ++--
gtk/gtkcombobox.c | 27 +++-
gtk/gtkiconview.c | 230 ++++++++++++++++++++++++-----------
gtk/gtkiconview.h | 15 ++-
gtk/gtktreeprivate.h | 2 +
gtk/gtktreeview.c | 198 ++++++++++++++++++++----------
gtk/gtktreeview.h | 1 +
gtk/gtktreeviewcolumn.c | 185 +++++++++++++++++++---------
gtk/gtktreeviewcolumn.h | 21 ++--
14 files changed, 706 insertions(+), 275 deletions(-)
diff --git a/docs/reference/gtk/gtk-sections.txt b/docs/reference/gtk/gtk-sections.txt
index 9a00b66..ba84000 100644
--- a/docs/reference/gtk/gtk-sections.txt
+++ b/docs/reference/gtk/gtk-sections.txt
@@ -1936,14 +1936,19 @@ gtk_icon_view_set_columns
gtk_icon_view_get_columns
gtk_icon_view_set_item_width
gtk_icon_view_get_item_width
+gtk_icon_view_get_item_width_unit
gtk_icon_view_set_spacing
gtk_icon_view_get_spacing
+gtk_icon_view_get_spacing_unit
gtk_icon_view_set_row_spacing
gtk_icon_view_get_row_spacing
+gtk_icon_view_get_row_spacing_unit
gtk_icon_view_set_column_spacing
gtk_icon_view_get_column_spacing
+gtk_icon_view_get_column_spacing_unit
gtk_icon_view_set_margin
gtk_icon_view_get_margin
+gtk_icon_view_get_margin_unit
gtk_icon_view_select_path
gtk_icon_view_unselect_path
gtk_icon_view_path_is_selected
@@ -4734,6 +4739,7 @@ gtk_tree_view_column_set_cell_data_func
gtk_tree_view_column_clear_attributes
gtk_tree_view_column_set_spacing
gtk_tree_view_column_get_spacing
+gtk_tree_view_column_get_spacing_unit
gtk_tree_view_column_set_visible
gtk_tree_view_column_get_visible
gtk_tree_view_column_set_resizable
@@ -4742,11 +4748,14 @@ gtk_tree_view_column_set_sizing
gtk_tree_view_column_get_sizing
gtk_tree_view_column_get_width
gtk_tree_view_column_get_fixed_width
+gtk_tree_view_column_get_fixed_width_unit
gtk_tree_view_column_set_fixed_width
gtk_tree_view_column_set_min_width
gtk_tree_view_column_get_min_width
+gtk_tree_view_column_get_min_width_unit
gtk_tree_view_column_set_max_width
gtk_tree_view_column_get_max_width
+gtk_tree_view_column_get_max_width_unit
gtk_tree_view_column_clicked
gtk_tree_view_column_set_title
gtk_tree_view_column_get_title
@@ -4795,6 +4804,7 @@ GtkTreeViewMappingFunc
GtkTreeViewSearchEqualFunc
gtk_tree_view_new
gtk_tree_view_get_level_indentation
+gtk_tree_view_get_level_indentation_unit
gtk_tree_view_get_show_expanders
gtk_tree_view_set_level_indentation
gtk_tree_view_set_show_expanders
@@ -4969,13 +4979,17 @@ GtkCellRendererMode
GtkCellRenderer
GtkCellRendererClass
gtk_cell_renderer_get_size
+gtk_cell_renderer_get_size_unit
gtk_cell_renderer_render
gtk_cell_renderer_activate
gtk_cell_renderer_start_editing
gtk_cell_renderer_editing_canceled
gtk_cell_renderer_stop_editing
gtk_cell_renderer_get_fixed_size
+gtk_cell_renderer_get_fixed_size_unit
gtk_cell_renderer_set_fixed_size
+gtk_cell_renderer_get_tree_view_column
+gtk_cell_renderer_get_tree_view
<SUBSECTION Standard>
GTK_CELL_RENDERER
diff --git a/gtk/gtk.symbols b/gtk/gtk.symbols
index d6bb1b6..b016602 100644
--- a/gtk/gtk.symbols
+++ b/gtk/gtk.symbols
@@ -628,12 +628,16 @@ gtk_cell_renderer_activate
gtk_cell_renderer_editing_canceled
#endif
gtk_cell_renderer_get_fixed_size
+gtk_cell_renderer_get_fixed_size_unit
gtk_cell_renderer_get_size
+gtk_cell_renderer_get_size_unit
gtk_cell_renderer_get_type G_GNUC_CONST
gtk_cell_renderer_render
gtk_cell_renderer_set_fixed_size
gtk_cell_renderer_start_editing
gtk_cell_renderer_stop_editing
+gtk_cell_renderer_get_tree_view_column
+gtk_cell_renderer_get_tree_view
#endif
#endif
@@ -1959,10 +1963,13 @@ gtk_icon_theme_set_search_path_utf8
#if IN_HEADER(__GTK_ICON_VIEW_H__)
#if IN_FILE(__GTK_ICON_VIEW_C__)
gtk_icon_view_get_column_spacing
+gtk_icon_view_get_column_spacing_unit
gtk_icon_view_get_columns
gtk_icon_view_get_cursor
gtk_icon_view_get_item_width
+gtk_icon_view_get_item_width_unit
gtk_icon_view_get_margin
+gtk_icon_view_get_margin_unit
gtk_icon_view_get_markup_column
gtk_icon_view_get_model
gtk_icon_view_get_orientation
@@ -1971,9 +1978,11 @@ gtk_icon_view_get_item_at_pos
gtk_icon_view_convert_widget_to_bin_window_coords
gtk_icon_view_get_pixbuf_column
gtk_icon_view_get_row_spacing
+gtk_icon_view_get_row_spacing_unit
gtk_icon_view_get_selected_items
gtk_icon_view_get_selection_mode
gtk_icon_view_get_spacing
+gtk_icon_view_get_spacing_unit
gtk_icon_view_get_text_column
gtk_icon_view_get_type G_GNUC_CONST
gtk_icon_view_get_visible_range
@@ -4616,8 +4625,11 @@ gtk_tree_view_column_get_cell_renderers
gtk_tree_view_column_get_clickable
gtk_tree_view_column_get_expand
gtk_tree_view_column_get_fixed_width
+gtk_tree_view_column_get_fixed_width_unit
gtk_tree_view_column_get_max_width
+gtk_tree_view_column_get_max_width_unit
gtk_tree_view_column_get_min_width
+gtk_tree_view_column_get_min_width_unit
gtk_tree_view_column_get_reorderable
gtk_tree_view_column_get_resizable
gtk_tree_view_column_get_sizing
@@ -4625,6 +4637,7 @@ gtk_tree_view_column_get_sort_column_id
gtk_tree_view_column_get_sort_indicator
gtk_tree_view_column_get_sort_order
gtk_tree_view_column_get_spacing
+gtk_tree_view_column_get_spacing_unit
gtk_tree_view_column_get_title
gtk_tree_view_column_get_tree_view
gtk_tree_view_column_get_type G_GNUC_CONST
@@ -4693,6 +4706,7 @@ gtk_tree_view_get_headers_visible
gtk_tree_view_get_hover_expand
gtk_tree_view_get_hover_selection
gtk_tree_view_get_level_indentation
+gtk_tree_view_get_level_indentation_unit
gtk_tree_view_get_model
gtk_tree_view_get_path_at_pos
gtk_tree_view_get_reorderable
diff --git a/gtk/gtkcellrenderer.c b/gtk/gtkcellrenderer.c
index c41a7f8..ac7f691 100644
--- a/gtk/gtkcellrenderer.c
+++ b/gtk/gtkcellrenderer.c
@@ -43,6 +43,9 @@ typedef struct _GtkCellRendererPrivate GtkCellRendererPrivate;
struct _GtkCellRendererPrivate
{
GdkColor cell_background;
+ GtkUSize xpad_unit;
+ GtkUSize ypad_unit;
+ GtkTreeViewColumn *column;
};
@@ -79,6 +82,8 @@ G_DEFINE_ABSTRACT_TYPE (GtkCellRenderer, gtk_cell_renderer, GTK_TYPE_OBJECT)
static void
gtk_cell_renderer_init (GtkCellRenderer *cell)
{
+ GtkCellRendererPrivate *priv = GTK_CELL_RENDERER_GET_PRIVATE (cell);
+
cell->mode = GTK_CELL_RENDERER_MODE_INERT;
cell->visible = TRUE;
cell->width = -1;
@@ -87,6 +92,8 @@ gtk_cell_renderer_init (GtkCellRenderer *cell)
cell->yalign = 0.5;
cell->xpad = 0;
cell->ypad = 0;
+ priv->xpad_unit = 0;
+ priv->ypad_unit = 0;
cell->sensitive = TRUE;
cell->is_expander = FALSE;
cell->is_expanded = FALSE;
@@ -217,43 +224,35 @@ gtk_cell_renderer_class_init (GtkCellRendererClass *class)
g_object_class_install_property (object_class,
PROP_XPAD,
- g_param_spec_uint ("xpad",
- P_("xpad"),
- P_("The xpad"),
- 0,
- G_MAXUINT,
- 0,
- GTK_PARAM_READWRITE));
+ gtk_param_spec_usize ("xpad",
+ P_("xpad"),
+ P_("The xpad"),
+ 0, G_MAXINT, 0,
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_YPAD,
- g_param_spec_uint ("ypad",
- P_("ypad"),
- P_("The ypad"),
- 0,
- G_MAXUINT,
- 0,
- GTK_PARAM_READWRITE));
+ gtk_param_spec_usize ("ypad",
+ P_("ypad"),
+ P_("The ypad"),
+ 0, G_MAXINT, 0,
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_WIDTH,
- g_param_spec_int ("width",
- P_("width"),
- P_("The fixed width"),
- -1,
- G_MAXINT,
- -1,
- GTK_PARAM_READWRITE));
+ gtk_param_spec_size ("width",
+ P_("width"),
+ P_("The fixed width"),
+ -1, G_MAXINT, -1,
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_HEIGHT,
- g_param_spec_int ("height",
- P_("height"),
- P_("The fixed height"),
- -1,
- G_MAXINT,
- -1,
- GTK_PARAM_READWRITE));
+ gtk_param_spec_size ("height",
+ P_("height"),
+ P_("The fixed height"),
+ -1, G_MAXINT, -1,
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_IS_EXPANDER,
@@ -336,16 +335,16 @@ gtk_cell_renderer_get_property (GObject *object,
g_value_set_float (value, cell->yalign);
break;
case PROP_XPAD:
- g_value_set_uint (value, cell->xpad);
+ gtk_value_set_usize (value, priv->xpad_unit, gtk_cell_renderer_get_tree_view (cell));
break;
case PROP_YPAD:
- g_value_set_uint (value, cell->ypad);
+ gtk_value_set_usize (value, priv->ypad_unit, gtk_cell_renderer_get_tree_view (cell));
break;
case PROP_WIDTH:
- g_value_set_int (value, cell->width);
+ gtk_value_set_size (value, cell->width, gtk_cell_renderer_get_tree_view (cell));
break;
case PROP_HEIGHT:
- g_value_set_int (value, cell->height);
+ gtk_value_set_size (value, cell->height, gtk_cell_renderer_get_tree_view (cell));
break;
case PROP_IS_EXPANDER:
g_value_set_boolean (value, cell->is_expander);
@@ -382,6 +381,7 @@ gtk_cell_renderer_set_property (GObject *object,
GParamSpec *pspec)
{
GtkCellRenderer *cell = GTK_CELL_RENDERER (object);
+ GtkCellRendererPrivate *priv = GTK_CELL_RENDERER_GET_PRIVATE (object);
switch (param_id)
{
@@ -404,16 +404,18 @@ gtk_cell_renderer_set_property (GObject *object,
cell->yalign = g_value_get_float (value);
break;
case PROP_XPAD:
- cell->xpad = g_value_get_uint (value);
+ priv->xpad_unit = gtk_value_get_usize (value);
+ cell->xpad = gtk_widget_size_to_pixel (gtk_cell_renderer_get_tree_view (cell), priv->xpad_unit);
break;
case PROP_YPAD:
- cell->ypad = g_value_get_uint (value);
+ priv->ypad_unit = gtk_value_get_usize (value);
+ cell->ypad = gtk_widget_size_to_pixel (gtk_cell_renderer_get_tree_view (cell), priv->ypad_unit);
break;
case PROP_WIDTH:
- cell->width = g_value_get_int (value);
+ cell->width = gtk_value_get_size (value);
break;
case PROP_HEIGHT:
- cell->height = g_value_get_int (value);
+ cell->height = gtk_value_get_size (value);
break;
case PROP_IS_EXPANDER:
cell->is_expander = g_value_get_boolean (value);
@@ -511,6 +513,59 @@ gtk_cell_renderer_get_size (GtkCellRenderer *cell,
if (width && cell->width != -1)
{
real_width = NULL;
+ *width = gtk_widget_size_to_pixel (widget, cell->width);
+ }
+ if (height && cell->height != -1)
+ {
+ real_height = NULL;
+ *height = gtk_widget_size_to_pixel (widget, cell->height);
+ }
+
+ GTK_CELL_RENDERER_GET_CLASS (cell)->get_size (cell,
+ widget,
+ (GdkRectangle *) cell_area,
+ x_offset,
+ y_offset,
+ real_width,
+ real_height);
+ if (real_width)
+ *real_width = gtk_widget_size_to_pixel (widget, *real_width);
+ if (real_height)
+ *real_height = gtk_widget_size_to_pixel (widget, *real_height);
+}
+
+/**
+ * gtk_cell_renderer_get_size_unit:
+ * @cell: a #GtkCellRenderer
+ * @widget: the widget the renderer is rendering to
+ * @cell_area: The area a cell will be allocated, or %NULL
+ * @x_offset: location to return x offset of cell relative to @cell_area, or %NULL
+ * @y_offset: location to return y offset of cell relative to @cell_area, or %NULL
+ * @width: location to return width needed to render a cell, or %NULL
+ * @height: location to return height needed to render a cell, or %NULL
+ *
+ * Like gtk_cell_renderer_get_size() but preserves the units.
+ *
+ * Since: 2.14
+ **/
+void
+gtk_cell_renderer_get_size_unit (GtkCellRenderer *cell,
+ GtkWidget *widget,
+ const GdkRectangle *cell_area,
+ gint *x_offset,
+ gint *y_offset,
+ GtkSize *width,
+ GtkSize *height)
+{
+ gint *real_width = width;
+ gint *real_height = height;
+
+ g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
+ g_return_if_fail (GTK_CELL_RENDERER_GET_CLASS (cell)->get_size != NULL);
+
+ if (width && cell->width != -1)
+ {
+ real_width = NULL;
*width = cell->width;
}
if (height && cell->height != -1)
@@ -689,8 +744,8 @@ gtk_cell_renderer_start_editing (GtkCellRenderer *cell,
**/
void
gtk_cell_renderer_set_fixed_size (GtkCellRenderer *cell,
- gint width,
- gint height)
+ GtkSize width,
+ GtkSize height)
{
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
g_return_if_fail (width >= -1 && height >= -1);
@@ -731,6 +786,29 @@ gtk_cell_renderer_get_fixed_size (GtkCellRenderer *cell,
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
if (width)
+ (* width) = gtk_widget_size_to_pixel (gtk_cell_renderer_get_tree_view (cell), cell->width);
+ if (height)
+ (* height) = gtk_widget_size_to_pixel (gtk_cell_renderer_get_tree_view (cell), cell->height);
+}
+
+/**
+ * gtk_cell_renderer_get_fixed_size_unit:
+ * @cell: A #GtkCellRenderer
+ * @width: location to fill in with the fixed width of the widget, or %NULL
+ * @height: location to fill in with the fixed height of the widget, or %NULL
+ *
+ * Like gtk_cell_renderer_get_fixed_size_unit() but preserves the unit information.
+ *
+ * Since: 2.14
+ **/
+void
+gtk_cell_renderer_get_fixed_size_unit (GtkCellRenderer *cell,
+ GtkSize *width,
+ GtkSize *height)
+{
+ g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
+
+ if (width)
(* width) = cell->width;
if (height)
(* height) = cell->height;
@@ -787,5 +865,66 @@ gtk_cell_renderer_stop_editing (GtkCellRenderer *cell,
}
}
+void
+_gtk_cell_renderer_set_tree_view_column (GtkCellRenderer *cell,
+ GtkTreeViewColumn *column)
+{
+ GtkCellRendererPrivate *priv = GTK_CELL_RENDERER_GET_PRIVATE (cell);
+ priv->column = column;
+}
+
+/**
+ * gtk_cell_renderer_get_tree_view_column:
+ * @cell: A #GtkCellRenderer
+ *
+ * Gets the #GtkTreeViewColumn wherein @cell has been
+ * inserted. Returns %NULL if @cell is currently not inserted into any
+ * tree column.
+ *
+ * Returns: the #GtkTreeViewColumn that @cell has been inserted into,
+ * %NULL otherwise
+ *
+ * Since: 2.14
+ **/
+GtkTreeViewColumn *
+gtk_cell_renderer_get_tree_view_column (GtkCellRenderer *cell)
+{
+ GtkCellRendererPrivate *priv;
+
+ g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), NULL);
+
+ priv = GTK_CELL_RENDERER_GET_PRIVATE (cell);
+
+ return priv->column;
+}
+
+/**
+ * gtk_cell_renderer_get_tree_view:
+ * @cell: A #GtkCellRenderer
+ *
+ * Gets the #GtkTreeView wherein the column that @cell has been
+ * inserted belongs to. Returns %NULL if @cell is currently not
+ * inserted into any tree column or if the tree column is currently
+ * not inserted into any tree.
+ *
+ * Returns: a #GtkTreeView
+ *
+ * Since: 2.14
+ */
+GtkWidget *
+gtk_cell_renderer_get_tree_view (GtkCellRenderer *cell)
+{
+ GtkCellRendererPrivate *priv;
+
+ g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), NULL);
+
+ priv = GTK_CELL_RENDERER_GET_PRIVATE (cell);
+
+ if (priv->column == NULL)
+ return NULL;
+
+ return gtk_tree_view_column_get_tree_view (priv->column);
+}
+
#define __GTK_CELL_RENDERER_C__
#include "gtkaliasdef.c"
diff --git a/gtk/gtkcellrenderer.h b/gtk/gtkcellrenderer.h
index 8b54292..5484bcc 100644
--- a/gtk/gtkcellrenderer.h
+++ b/gtk/gtkcellrenderer.h
@@ -26,6 +26,9 @@
#include <gtk/gtkcelleditable.h>
+/* forward declaration */
+typedef struct _GtkTreeViewColumn GtkTreeViewColumn;
+
G_BEGIN_DECLS
typedef enum
@@ -62,8 +65,8 @@ struct _GtkCellRenderer
gfloat GSEAL (xalign);
gfloat GSEAL (yalign);
- gint GSEAL (width);
- gint GSEAL (height);
+ GtkSize GSEAL (width);
+ GtkSize GSEAL (height);
guint16 GSEAL (xpad);
guint16 GSEAL (ypad);
@@ -87,8 +90,8 @@ struct _GtkCellRendererClass
GdkRectangle *cell_area,
gint *x_offset,
gint *y_offset,
- gint *width,
- gint *height);
+ GtkSize *width,
+ GtkSize *height);
void (* render) (GtkCellRenderer *cell,
GdkDrawable *window,
GtkWidget *widget,
@@ -131,6 +134,13 @@ void gtk_cell_renderer_get_size (GtkCellRenderer *cell,
gint *y_offset,
gint *width,
gint *height);
+void gtk_cell_renderer_get_size_unit (GtkCellRenderer *cell,
+ GtkWidget *widget,
+ const GdkRectangle *cell_area,
+ gint *x_offset,
+ gint *y_offset,
+ GtkSize *width,
+ GtkSize *height);
void gtk_cell_renderer_render (GtkCellRenderer *cell,
GdkWindow *window,
GtkWidget *widget,
@@ -153,11 +163,18 @@ GtkCellEditable *gtk_cell_renderer_start_editing (GtkCellRenderer *cell,
const GdkRectangle *cell_area,
GtkCellRendererState flags);
void gtk_cell_renderer_set_fixed_size (GtkCellRenderer *cell,
- gint width,
- gint height);
+ GtkSize width,
+ GtkSize height);
void gtk_cell_renderer_get_fixed_size (GtkCellRenderer *cell,
gint *width,
gint *height);
+void gtk_cell_renderer_get_fixed_size_unit (GtkCellRenderer *cell,
+ GtkSize *width,
+ GtkSize *height);
+
+GtkTreeViewColumn *gtk_cell_renderer_get_tree_view_column (GtkCellRenderer *cell);
+
+GtkWidget *gtk_cell_renderer_get_tree_view (GtkCellRenderer *cell);
/* For use by cell renderer implementations only */
#ifndef GTK_DISABLE_DEPRECATED
diff --git a/gtk/gtkcellrendererpixbuf.c b/gtk/gtkcellrendererpixbuf.c
index 0431295..71f9de9 100644
--- a/gtk/gtkcellrendererpixbuf.c
+++ b/gtk/gtkcellrendererpixbuf.c
@@ -431,9 +431,10 @@ gtk_cell_renderer_pixbuf_create_themed_pixbuf (GtkCellRendererPixbuf *cellpixbuf
icon_theme = gtk_icon_theme_get_for_screen (screen);
settings = gtk_settings_get_for_screen (screen);
- if (!gtk_icon_size_lookup_for_settings (settings,
- priv->stock_size,
- &width, &height))
+ if (!gtk_icon_size_lookup_for_settings_for_monitor (settings,
+ gtk_widget_get_monitor_num (widget),
+ priv->stock_size,
+ &width, &height))
{
g_warning ("Invalid icon size %u\n", priv->stock_size);
width = height = 24;
diff --git a/gtk/gtkcellrenderertoggle.c b/gtk/gtkcellrenderertoggle.c
index 5cc826c..9e4159b 100644
--- a/gtk/gtkcellrenderertoggle.c
+++ b/gtk/gtkcellrenderertoggle.c
@@ -71,7 +71,7 @@ enum {
PROP_INDICATOR_SIZE
};
-#define TOGGLE_WIDTH 13
+#define TOGGLE_WIDTH GTK_SIZE_ONE_TWELFTH_EM(13)
static guint toggle_cell_signals[LAST_SIGNAL] = { 0 };
@@ -154,13 +154,11 @@ gtk_cell_renderer_toggle_class_init (GtkCellRendererToggleClass *class)
g_object_class_install_property (object_class,
PROP_INDICATOR_SIZE,
- g_param_spec_int ("indicator-size",
- P_("Indicator size"),
- P_("Size of check or radio indicator"),
- 0,
- G_MAXINT,
- TOGGLE_WIDTH,
- GTK_PARAM_READWRITE));
+ gtk_param_spec_size ("indicator-size",
+ P_("Indicator size"),
+ P_("Size of check or radio indicator"),
+ 0, G_MAXINT, TOGGLE_WIDTH,
+ GTK_PARAM_READWRITE));
/**
@@ -210,7 +208,8 @@ gtk_cell_renderer_toggle_get_property (GObject *object,
g_value_set_boolean (value, celltoggle->radio);
break;
case PROP_INDICATOR_SIZE:
- g_value_set_int (value, priv->indicator_size);
+ gtk_value_set_size (value, priv->indicator_size,
+ gtk_cell_renderer_get_tree_view (GTK_CELL_RENDERER (celltoggle)));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
@@ -245,7 +244,7 @@ gtk_cell_renderer_toggle_set_property (GObject *object,
celltoggle->radio = g_value_get_boolean (value);
break;
case PROP_INDICATOR_SIZE:
- priv->indicator_size = g_value_get_int (value);
+ priv->indicator_size = gtk_value_get_size (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
@@ -287,8 +286,8 @@ gtk_cell_renderer_toggle_get_size (GtkCellRenderer *cell,
priv = GTK_CELL_RENDERER_TOGGLE_GET_PRIVATE (cell);
- calc_width = (gint) cell->xpad * 2 + priv->indicator_size;
- calc_height = (gint) cell->ypad * 2 + priv->indicator_size;
+ calc_width = (gint) cell->xpad * 2 + gtk_widget_size_to_pixel (widget, priv->indicator_size);
+ calc_height = (gint) cell->ypad * 2 + gtk_widget_size_to_pixel (widget, priv->indicator_size);
if (width)
*width = calc_width;
diff --git a/gtk/gtkcombobox.c b/gtk/gtkcombobox.c
index 57a975d..1648c1d 100644
--- a/gtk/gtkcombobox.c
+++ b/gtk/gtkcombobox.c
@@ -243,6 +243,7 @@ static void gtk_combo_box_add (GtkContainer *container,
GtkWidget *widget);
static void gtk_combo_box_remove (GtkContainer *container,
GtkWidget *widget);
+static void gtk_combo_box_unit_changed (GtkWidget *widget);
static ComboCellInfo *gtk_combo_box_get_cell_info (GtkComboBox *combo_box,
GtkCellRenderer *cell);
@@ -499,6 +500,7 @@ gtk_combo_box_class_init (GtkComboBoxClass *klass)
widget_class->grab_focus = gtk_combo_box_grab_focus;
widget_class->style_set = gtk_combo_box_style_set;
widget_class->state_changed = gtk_combo_box_state_changed;
+ widget_class->unit_changed = gtk_combo_box_unit_changed;
gtk_object_class = (GtkObjectClass *)klass;
gtk_object_class->destroy = gtk_combo_box_destroy;
@@ -861,13 +863,11 @@ gtk_combo_box_class_init (GtkComboBoxClass *klass)
* Since: 2.12
*/
gtk_widget_class_install_style_property (widget_class,
- g_param_spec_int ("arrow-size",
- P_("Arrow Size"),
- P_("The minimum size of the arrow in the combo box"),
- 0,
- G_MAXINT,
- 15,
- GTK_PARAM_READABLE));
+ gtk_param_spec_size ("arrow-size",
+ P_("Arrow Size"),
+ P_("The minimum size of the arrow in the combo box"),
+ 0, G_MAXINT, GTK_SIZE_ONE_TWELFTH_EM (15),
+ GTK_PARAM_READABLE));
/**
* GtkComboBox:shadow-type:
@@ -5924,5 +5924,18 @@ gtk_combo_box_buildable_custom_tag_end (GtkBuildable *buildable,
data);
}
+static void
+gtk_combo_box_unit_changed (GtkWidget *widget)
+{
+ GtkComboBox *combo_box = GTK_COMBO_BOX (widget);
+
+ gtk_combo_box_check_appearance (combo_box);
+
+ /* must chain up */
+ if (GTK_WIDGET_CLASS (gtk_combo_box_parent_class)->unit_changed != NULL)
+ GTK_WIDGET_CLASS (gtk_combo_box_parent_class)->unit_changed (widget);
+}
+
+
#define __GTK_COMBO_BOX_C__
#include "gtkaliasdef.c"
diff --git a/gtk/gtkiconview.c b/gtk/gtkiconview.c
index aa1d16e..40ae71e 100644
--- a/gtk/gtkiconview.c
+++ b/gtk/gtkiconview.c
@@ -45,8 +45,8 @@
#undef DEBUG_ICON_VIEW
-#define SCROLL_EDGE_SIZE 15
-#define ITEM_PADDING 6
+#define SCROLL_EDGE_SIZE GTK_SIZE_ONE_TWELFTH_EM(15)
+#define ITEM_PADDING GTK_SIZE_ONE_TWELFTH_EM(6)
#define GTK_ICON_VIEW_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_ICON_VIEW, GtkIconViewPrivate))
@@ -644,11 +644,11 @@ gtk_icon_view_class_init (GtkIconViewClass *klass)
*/
g_object_class_install_property (gobject_class,
PROP_ITEM_WIDTH,
- g_param_spec_int ("item-width",
- P_("Width for each item"),
- P_("The width used for each item"),
- -1, G_MAXINT, -1,
- GTK_PARAM_READWRITE));
+ gtk_param_spec_size ("item-width",
+ P_("Width for each item"),
+ P_("The width used for each item"),
+ -1, G_MAXINT, -1,
+ GTK_PARAM_READWRITE));
/**
* GtkIconView:spacing:
@@ -660,11 +660,11 @@ gtk_icon_view_class_init (GtkIconViewClass *klass)
*/
g_object_class_install_property (gobject_class,
PROP_SPACING,
- g_param_spec_int ("spacing",
- P_("Spacing"),
- P_("Space which is inserted between cells of an item"),
- 0, G_MAXINT, 0,
- GTK_PARAM_READWRITE));
+ gtk_param_spec_size ("spacing",
+ P_("Spacing"),
+ P_("Space which is inserted between cells of an item"),
+ 0, G_MAXINT, 0,
+ GTK_PARAM_READWRITE));
/**
* GtkIconView:row-spacing:
@@ -676,11 +676,11 @@ gtk_icon_view_class_init (GtkIconViewClass *klass)
*/
g_object_class_install_property (gobject_class,
PROP_ROW_SPACING,
- g_param_spec_int ("row-spacing",
- P_("Row Spacing"),
- P_("Space which is inserted between grid rows"),
- 0, G_MAXINT, 6,
- GTK_PARAM_READWRITE));
+ gtk_param_spec_size ("row-spacing",
+ P_("Row Spacing"),
+ P_("Space which is inserted between grid rows"),
+ 0, G_MAXINT, GTK_SIZE_ONE_TWELFTH_EM (6),
+ GTK_PARAM_READWRITE));
/**
* GtkIconView:column-spacing:
@@ -692,11 +692,11 @@ gtk_icon_view_class_init (GtkIconViewClass *klass)
*/
g_object_class_install_property (gobject_class,
PROP_COLUMN_SPACING,
- g_param_spec_int ("column-spacing",
- P_("Column Spacing"),
- P_("Space which is inserted between grid columns"),
- 0, G_MAXINT, 6,
- GTK_PARAM_READWRITE));
+ gtk_param_spec_size ("column-spacing",
+ P_("Column Spacing"),
+ P_("Space which is inserted between grid columns"),
+ 0, G_MAXINT, GTK_SIZE_ONE_TWELFTH_EM (6),
+ GTK_PARAM_READWRITE));
/**
* GtkIconView:margin:
@@ -708,11 +708,11 @@ gtk_icon_view_class_init (GtkIconViewClass *klass)
*/
g_object_class_install_property (gobject_class,
PROP_MARGIN,
- g_param_spec_int ("margin",
- P_("Margin"),
- P_("Space which is inserted at the edges of the icon view"),
- 0, G_MAXINT, 6,
- GTK_PARAM_READWRITE));
+ gtk_param_spec_size ("margin",
+ P_("Margin"),
+ P_("Space which is inserted at the edges of the icon view"),
+ 0, G_MAXINT, GTK_SIZE_ONE_TWELFTH_EM (6),
+ GTK_PARAM_READWRITE));
/**
@@ -1103,9 +1103,9 @@ gtk_icon_view_init (GtkIconView *icon_view)
icon_view->priv->columns = -1;
icon_view->priv->item_width = -1;
icon_view->priv->spacing = 0;
- icon_view->priv->row_spacing = 6;
- icon_view->priv->column_spacing = 6;
- icon_view->priv->margin = 6;
+ icon_view->priv->row_spacing = GTK_SIZE_ONE_TWELFTH_EM (6);
+ icon_view->priv->column_spacing = GTK_SIZE_ONE_TWELFTH_EM (6);
+ icon_view->priv->margin = GTK_SIZE_ONE_TWELFTH_EM (6);
icon_view->priv->draw_focus = TRUE;
}
@@ -1194,19 +1194,19 @@ gtk_icon_view_set_property (GObject *object,
gtk_icon_view_set_columns (icon_view, g_value_get_int (value));
break;
case PROP_ITEM_WIDTH:
- gtk_icon_view_set_item_width (icon_view, g_value_get_int (value));
+ gtk_icon_view_set_item_width (icon_view, gtk_value_get_size (value));
break;
case PROP_SPACING:
- gtk_icon_view_set_spacing (icon_view, g_value_get_int (value));
+ gtk_icon_view_set_spacing (icon_view, gtk_value_get_size (value));
break;
case PROP_ROW_SPACING:
- gtk_icon_view_set_row_spacing (icon_view, g_value_get_int (value));
+ gtk_icon_view_set_row_spacing (icon_view, gtk_value_get_size (value));
break;
case PROP_COLUMN_SPACING:
- gtk_icon_view_set_column_spacing (icon_view, g_value_get_int (value));
+ gtk_icon_view_set_column_spacing (icon_view, gtk_value_get_size (value));
break;
case PROP_MARGIN:
- gtk_icon_view_set_margin (icon_view, g_value_get_int (value));
+ gtk_icon_view_set_margin (icon_view, gtk_value_get_size (value));
break;
case PROP_REORDERABLE:
gtk_icon_view_set_reorderable (icon_view, g_value_get_boolean (value));
@@ -1256,19 +1256,19 @@ gtk_icon_view_get_property (GObject *object,
g_value_set_int (value, icon_view->priv->columns);
break;
case PROP_ITEM_WIDTH:
- g_value_set_int (value, icon_view->priv->item_width);
+ gtk_value_set_size (value, icon_view->priv->item_width, icon_view);
break;
case PROP_SPACING:
- g_value_set_int (value, icon_view->priv->spacing);
+ gtk_value_set_size (value, icon_view->priv->spacing, icon_view);
break;
case PROP_ROW_SPACING:
- g_value_set_int (value, icon_view->priv->row_spacing);
+ gtk_value_set_size (value, icon_view->priv->row_spacing, icon_view);
break;
case PROP_COLUMN_SPACING:
- g_value_set_int (value, icon_view->priv->column_spacing);
+ gtk_value_set_size (value, icon_view->priv->column_spacing, icon_view);
break;
case PROP_MARGIN:
- g_value_set_int (value, icon_view->priv->margin);
+ gtk_value_set_size (value, icon_view->priv->margin, icon_view);
break;
case PROP_REORDERABLE:
g_value_set_boolean (value, icon_view->priv->reorderable);
@@ -2658,8 +2658,8 @@ gtk_icon_view_layout_single_row (GtkIconView *icon_view,
"focus-line-width", &focus_width,
NULL);
- x += icon_view->priv->margin + focus_width;
- current_width += 2 * (icon_view->priv->margin + focus_width);
+ x += gtk_widget_size_to_pixel (icon_view, icon_view->priv->margin) + focus_width;
+ current_width += 2 * (gtk_widget_size_to_pixel (icon_view, icon_view->priv->margin) + focus_width);
items = first_item;
while (items)
@@ -2667,9 +2667,9 @@ gtk_icon_view_layout_single_row (GtkIconView *icon_view,
GtkIconViewItem *item = items->data;
gtk_icon_view_calculate_item_size (icon_view, item);
- colspan = 1 + (item->width - 1) / (item_width + icon_view->priv->column_spacing);
+ colspan = 1 + (item->width - 1) / (item_width + gtk_widget_size_to_pixel (icon_view, icon_view->priv->column_spacing));
- item->width = colspan * item_width + (colspan - 1) * icon_view->priv->column_spacing;
+ item->width = colspan * item_width + (colspan - 1) * gtk_widget_size_to_pixel (icon_view, icon_view->priv->column_spacing);
current_width += item->width;
@@ -2680,12 +2680,12 @@ gtk_icon_view_layout_single_row (GtkIconView *icon_view,
break;
}
- current_width += icon_view->priv->column_spacing + 2 * focus_width;
+ current_width += gtk_widget_size_to_pixel (icon_view, icon_view->priv->column_spacing) + 2 * focus_width;
item->y = *y + focus_width;
item->x = x;
- x = current_width - (icon_view->priv->margin + focus_width);
+ x = current_width - (gtk_widget_size_to_pixel (icon_view, icon_view->priv->margin) + focus_width);
for (i = 0; i < icon_view->priv->n_cells; i++)
max_height[i] = MAX (max_height[i], item->box[i].height);
@@ -2716,8 +2716,8 @@ gtk_icon_view_layout_single_row (GtkIconView *icon_view,
gtk_icon_view_calculate_item_size2 (icon_view, item, max_height);
/* We may want to readjust the new y coordinate. */
- if (item->y + item->height + focus_width + icon_view->priv->row_spacing > *y)
- *y = item->y + item->height + focus_width + icon_view->priv->row_spacing;
+ if (item->y + item->height + focus_width + gtk_widget_size_to_pixel (icon_view, icon_view->priv->row_spacing) > *y)
+ *y = item->y + item->height + focus_width + gtk_widget_size_to_pixel (icon_view, icon_view->priv->row_spacing);
}
g_free (max_height);
@@ -2769,7 +2769,7 @@ gtk_icon_view_layout (GtkIconView *icon_view)
widget = GTK_WIDGET (icon_view);
- item_width = icon_view->priv->item_width;
+ item_width = gtk_widget_size_to_pixel (icon_view, icon_view->priv->item_width);
if (item_width < 0)
{
@@ -2783,7 +2783,7 @@ gtk_icon_view_layout (GtkIconView *icon_view)
icons = icon_view->priv->items;
- y += icon_view->priv->margin;
+ y += gtk_widget_size_to_pixel (icon_view, icon_view->priv->margin);
row = 0;
if (icons)
@@ -2804,7 +2804,7 @@ gtk_icon_view_layout (GtkIconView *icon_view)
if (maximum_width != icon_view->priv->width)
icon_view->priv->width = maximum_width;
- y += icon_view->priv->margin;
+ y += gtk_widget_size_to_pixel (icon_view, icon_view->priv->margin);
if (y != icon_view->priv->height)
icon_view->priv->height = y;
@@ -2905,22 +2905,22 @@ adjust_wrap_width (GtkIconView *icon_view,
NULL);
- if (icon_view->priv->item_width > 0)
- item_width = icon_view->priv->item_width;
+ if (gtk_widget_size_to_pixel (icon_view, icon_view->priv->item_width) > 0)
+ item_width = gtk_widget_size_to_pixel (icon_view, icon_view->priv->item_width);
else
item_width = item->width;
if (item->width == -1)
{
if (item_width > 0)
- wrap_width = item_width - pixbuf_width - icon_view->priv->spacing;
+ wrap_width = item_width - pixbuf_width - gtk_widget_size_to_pixel (icon_view, icon_view->priv->spacing);
else
wrap_width = MAX (2 * pixbuf_width, 50);
}
else if (icon_view->priv->orientation == GTK_ORIENTATION_VERTICAL)
wrap_width = item_width;
else
- wrap_width = item_width - pixbuf_width - icon_view->priv->spacing;
+ wrap_width = item_width - pixbuf_width - gtk_widget_size_to_pixel (icon_view, icon_view->priv->spacing);
wrap_width -= ITEM_PADDING * 2;
@@ -2954,7 +2954,7 @@ gtk_icon_view_calculate_item_size (GtkIconView *icon_view,
gtk_icon_view_set_cell_data (icon_view, item);
- spacing = icon_view->priv->spacing;
+ spacing = gtk_widget_size_to_pixel (icon_view, icon_view->priv->spacing);
item->width = 0;
item->height = 0;
@@ -3002,7 +3002,7 @@ gtk_icon_view_calculate_item_size2 (GtkIconView *icon_view,
gtk_icon_view_set_cell_data (icon_view, item);
- spacing = icon_view->priv->spacing;
+ spacing = gtk_widget_size_to_pixel (icon_view, icon_view->priv->spacing);
item->height = 0;
for (i = 0; i < icon_view->priv->n_cells; i++)
@@ -3445,8 +3445,8 @@ gtk_icon_view_get_item_at_coords (GtkIconView *icon_view,
{
GtkIconViewItem *item = items->data;
- if (x >= item->x - icon_view->priv->column_spacing/2 && x <= item->x + item->width + icon_view->priv->column_spacing/2 &&
- y >= item->y - icon_view->priv->row_spacing/2 && y <= item->y + item->height + icon_view->priv->row_spacing/2)
+ if (x >= item->x - gtk_widget_size_to_pixel (icon_view, icon_view->priv->column_spacing)/2 && x <= item->x + item->width + gtk_widget_size_to_pixel (icon_view, icon_view->priv->column_spacing)/2 &&
+ y >= item->y - gtk_widget_size_to_pixel (icon_view, icon_view->priv->row_spacing)/2 && y <= item->y + item->height + gtk_widget_size_to_pixel (icon_view, icon_view->priv->row_spacing)/2)
{
if (only_in_cell || cell_at_pos)
{
@@ -6011,7 +6011,7 @@ gtk_icon_view_get_columns (GtkIconView *icon_view)
*/
void
gtk_icon_view_set_item_width (GtkIconView *icon_view,
- gint item_width)
+ GtkSize item_width)
{
g_return_if_fail (GTK_IS_ICON_VIEW (icon_view));
@@ -6044,6 +6044,24 @@ gtk_icon_view_get_item_width (GtkIconView *icon_view)
{
g_return_val_if_fail (GTK_IS_ICON_VIEW (icon_view), -1);
+ return gtk_widget_size_to_pixel (icon_view, icon_view->priv->item_width);
+}
+
+/**
+ * gtk_icon_view_get_item_width_unit:
+ * @icon_view: a #GtkIconView
+ *
+ * Like gtk_icon_view_get_item_width() but preserves the unit.
+ *
+ * Return value: the width_unit of a single item, or -1
+ *
+ * Since: 2.14
+ */
+GtkSize
+gtk_icon_view_get_item_width_unit (GtkIconView *icon_view)
+{
+ g_return_val_if_fail (GTK_IS_ICON_VIEW (icon_view), -1);
+
return icon_view->priv->item_width;
}
@@ -6061,7 +6079,7 @@ gtk_icon_view_get_item_width (GtkIconView *icon_view)
*/
void
gtk_icon_view_set_spacing (GtkIconView *icon_view,
- gint spacing)
+ GtkSize spacing)
{
g_return_if_fail (GTK_IS_ICON_VIEW (icon_view));
@@ -6092,6 +6110,24 @@ gtk_icon_view_get_spacing (GtkIconView *icon_view)
{
g_return_val_if_fail (GTK_IS_ICON_VIEW (icon_view), -1);
+ return gtk_widget_size_to_pixel (icon_view, icon_view->priv->spacing);
+}
+
+/**
+ * gtk_icon_view_get_spacing_unit:
+ * @icon_view: a #GtkIconView
+ *
+ * Like gtk_icon_view_get_spacing() but preserves the unit.
+ *
+ * Return value: the space between cells
+ *
+ * Since: 2.14
+ */
+GtkSize
+gtk_icon_view_get_spacing_unit (GtkIconView *icon_view)
+{
+ g_return_val_if_fail (GTK_IS_ICON_VIEW (icon_view), -1);
+
return icon_view->priv->spacing;
}
@@ -6107,7 +6143,7 @@ gtk_icon_view_get_spacing (GtkIconView *icon_view)
*/
void
gtk_icon_view_set_row_spacing (GtkIconView *icon_view,
- gint row_spacing)
+ GtkSize row_spacing)
{
g_return_if_fail (GTK_IS_ICON_VIEW (icon_view));
@@ -6138,6 +6174,24 @@ gtk_icon_view_get_row_spacing (GtkIconView *icon_view)
{
g_return_val_if_fail (GTK_IS_ICON_VIEW (icon_view), -1);
+ return gtk_widget_size_to_pixel (icon_view, icon_view->priv->row_spacing);
+}
+
+/**
+ * gtk_icon_view_get_row_spacing_unit:
+ * @icon_view: a #GtkIconView
+ *
+ * Like gtk_icon_view_get_row_spacing() but preserves the unit.
+ *
+ * Return value: the space between rows
+ *
+ * Since: 2.14
+ */
+GtkSize
+gtk_icon_view_get_row_spacing_unit (GtkIconView *icon_view)
+{
+ g_return_val_if_fail (GTK_IS_ICON_VIEW (icon_view), -1);
+
return icon_view->priv->row_spacing;
}
@@ -6153,7 +6207,7 @@ gtk_icon_view_get_row_spacing (GtkIconView *icon_view)
*/
void
gtk_icon_view_set_column_spacing (GtkIconView *icon_view,
- gint column_spacing)
+ GtkSize column_spacing)
{
g_return_if_fail (GTK_IS_ICON_VIEW (icon_view));
@@ -6184,6 +6238,24 @@ gtk_icon_view_get_column_spacing (GtkIconView *icon_view)
{
g_return_val_if_fail (GTK_IS_ICON_VIEW (icon_view), -1);
+ return gtk_widget_size_to_pixel (icon_view, icon_view->priv->column_spacing);
+}
+
+/**
+ * gtk_icon_view_get_column_spacing_unit:
+ * @icon_view: a #GtkIconView
+ *
+ * Like gtk_icon_view_get_column_spacing() but preserves the unit.
+ *
+ * Return value: the space between columns
+ *
+ * Since: 2.14
+ */
+GtkSize
+gtk_icon_view_get_column_spacing_unit (GtkIconView *icon_view)
+{
+ g_return_val_if_fail (GTK_IS_ICON_VIEW (icon_view), -1);
+
return icon_view->priv->column_spacing;
}
@@ -6200,7 +6272,7 @@ gtk_icon_view_get_column_spacing (GtkIconView *icon_view)
*/
void
gtk_icon_view_set_margin (GtkIconView *icon_view,
- gint margin)
+ GtkSize margin)
{
g_return_if_fail (GTK_IS_ICON_VIEW (icon_view));
@@ -6231,6 +6303,24 @@ gtk_icon_view_get_margin (GtkIconView *icon_view)
{
g_return_val_if_fail (GTK_IS_ICON_VIEW (icon_view), -1);
+ return gtk_widget_size_to_pixel (icon_view, icon_view->priv->margin);
+}
+
+/**
+ * gtk_icon_view_get_margin_unit:
+ * @icon_view: a #GtkIconView
+ *
+ * Like gtk_icon_view_get_margin() but preserves the unit.
+ *
+ * Return value: the space at the borders
+ *
+ * Since: 2.14
+ */
+GtkSize
+gtk_icon_view_get_margin_unit (GtkIconView *icon_view)
+{
+ g_return_val_if_fail (GTK_IS_ICON_VIEW (icon_view), -1);
+
return icon_view->priv->margin;
}
@@ -6409,13 +6499,13 @@ gtk_icon_view_autoscroll (GtkIconView *icon_view)
gdk_window_get_geometry (GTK_WIDGET (icon_view)->window, &x, &y, &width, &height, NULL);
/* see if we are near the edge. */
- voffset = py - (y + 2 * SCROLL_EDGE_SIZE);
+ voffset = py - (y + 2 * gtk_widget_size_to_pixel (icon_view, SCROLL_EDGE_SIZE));
if (voffset > 0)
- voffset = MAX (py - (y + height - 2 * SCROLL_EDGE_SIZE), 0);
+ voffset = MAX (py - (y + height - 2 * gtk_widget_size_to_pixel (icon_view, SCROLL_EDGE_SIZE)), 0);
- hoffset = px - (x + 2 * SCROLL_EDGE_SIZE);
+ hoffset = px - (x + 2 * gtk_widget_size_to_pixel (icon_view, SCROLL_EDGE_SIZE));
if (hoffset > 0)
- hoffset = MAX (px - (x + width - 2 * SCROLL_EDGE_SIZE), 0);
+ hoffset = MAX (px - (x + width - 2 * gtk_widget_size_to_pixel (icon_view, SCROLL_EDGE_SIZE)), 0);
if (voffset != 0)
gtk_adjustment_set_value (icon_view->priv->vadjustment,
@@ -8277,7 +8367,7 @@ gtk_icon_view_item_accessible_text_get_character_extents (AtkText *text,
atk_component_get_position (ATK_COMPONENT (text), x, y, coord_type);
*x += item->item->layout_x - item->item->x + char_rect.x / PANGO_SCALE;
/* Look at gtk_icon_view_paint_item() to see where the text is. */
- *x -= ((item->item->width - item->item->layout_width) / 2) + (MAX (item->item->pixbuf_width, icon_view->priv->item_width) - item->item->width) / 2,
+ *x -= ((item->item->width - item->item->layout_width) / 2) + (MAX (item->item->pixbuf_width, gtk_widget_size_to_pixel (icon_view, icon_view->priv->item_width)) - gtk_widget_size_to_pixel (icon_view, item->item->width)) / 2,
*y += item->item->layout_y - item->item->y + char_rect.y / PANGO_SCALE;
*width = char_rect.width / PANGO_SCALE;
*height = char_rect.height / PANGO_SCALE;
@@ -8313,7 +8403,7 @@ gtk_icon_view_item_accessible_text_get_offset_at_point (AtkText *text,
gtk_icon_view_update_item_text (icon_view, item->item);
atk_component_get_position (ATK_COMPONENT (text), &l_x, &l_y, coord_type);
x -= l_x + item->item->layout_x - item->item->x;
- x += ((item->item->width - item->item->layout_width) / 2) + (MAX (item->item->pixbuf_width, icon_view->priv->item_width) - item->item->width) / 2,
+ x += ((item->item->width - item->item->layout_width) / 2) + (MAX (item->item->pixbuf_width, gtk_widget_size_to_pixel (icon_view, icon_view->priv->item_width)) - gtk_widget_size_to_pixel (icon_view, item->item->width)) / 2,
y -= l_y + item->item->layout_y - item->item->y;
item_text = pango_layout_get_text (icon_view->priv->layout);
if (!pango_layout_xy_to_index (icon_view->priv->layout,
diff --git a/gtk/gtkiconview.h b/gtk/gtkiconview.h
index 65b0588..38ab561 100644
--- a/gtk/gtkiconview.h
+++ b/gtk/gtkiconview.h
@@ -111,20 +111,25 @@ void gtk_icon_view_set_columns (GtkIconView *icon_view,
gint columns);
gint gtk_icon_view_get_columns (GtkIconView *icon_view);
void gtk_icon_view_set_item_width (GtkIconView *icon_view,
- gint item_width);
+ GtkSize item_width);
gint gtk_icon_view_get_item_width (GtkIconView *icon_view);
+GtkSize gtk_icon_view_get_item_width_unit (GtkIconView *icon_view);
void gtk_icon_view_set_spacing (GtkIconView *icon_view,
- gint spacing);
+ GtkSize spacing);
gint gtk_icon_view_get_spacing (GtkIconView *icon_view);
+GtkSize gtk_icon_view_get_spacing_unit (GtkIconView *icon_view);
void gtk_icon_view_set_row_spacing (GtkIconView *icon_view,
- gint row_spacing);
+ GtkSize row_spacing);
gint gtk_icon_view_get_row_spacing (GtkIconView *icon_view);
+GtkSize gtk_icon_view_get_row_spacing_unit (GtkIconView *icon_view);
void gtk_icon_view_set_column_spacing (GtkIconView *icon_view,
- gint column_spacing);
+ GtkSize column_spacing);
gint gtk_icon_view_get_column_spacing (GtkIconView *icon_view);
+GtkSize gtk_icon_view_get_column_spacing_unit (GtkIconView *icon_view);
void gtk_icon_view_set_margin (GtkIconView *icon_view,
- gint margin);
+ GtkSize margin);
gint gtk_icon_view_get_margin (GtkIconView *icon_view);
+GtkSize gtk_icon_view_get_margin_unit (GtkIconView *icon_view);
GtkTreePath * gtk_icon_view_get_path_at_pos (GtkIconView *icon_view,
diff --git a/gtk/gtktreeprivate.h b/gtk/gtktreeprivate.h
index 384c176..460a3ce 100644
--- a/gtk/gtktreeprivate.h
+++ b/gtk/gtktreeprivate.h
@@ -440,6 +440,8 @@ void _gtk_tree_view_column_get_neighbor_sizes (GtkTreeViewColumn *c
gint *left,
gint *right);
+void _gtk_cell_renderer_set_tree_view_column (GtkCellRenderer *cell,
+ GtkTreeViewColumn *column);
G_END_DECLS
diff --git a/gtk/gtktreeview.c b/gtk/gtktreeview.c
index 5078cdb..d83e6d4 100644
--- a/gtk/gtktreeview.c
+++ b/gtk/gtktreeview.c
@@ -46,11 +46,13 @@
#include "gtkprivate.h"
#include "gtkalias.h"
+#define MAKE_EVEN(x) do {x = (((x&1) == 0) ? x : x + 1);} while (0)
+
#define GTK_TREE_VIEW_PRIORITY_VALIDATE (GDK_PRIORITY_REDRAW + 5)
#define GTK_TREE_VIEW_PRIORITY_SCROLL_SYNC (GTK_TREE_VIEW_PRIORITY_VALIDATE + 2)
#define GTK_TREE_VIEW_NUM_ROWS_PER_IDLE 500
#define SCROLL_EDGE_SIZE 15
-#define EXPANDER_EXTRA_PADDING 4
+#define EXPANDER_EXTRA_PADDING GTK_SIZE_ONE_TWELFTH_EM(4)
#define GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT 5000
#define AUTO_EXPAND_TIMEOUT 500
@@ -205,6 +207,7 @@ static void gtk_tree_view_grab_notify (GtkWidget *widget,
gboolean was_grabbed);
static void gtk_tree_view_state_changed (GtkWidget *widget,
GtkStateType previous_state);
+static void gtk_tree_view_unit_changed (GtkWidget *widget);
/* container signals */
static void gtk_tree_view_remove (GtkContainer *container,
@@ -546,6 +549,7 @@ gtk_tree_view_class_init (GtkTreeViewClass *class)
widget_class->style_set = gtk_tree_view_style_set;
widget_class->grab_notify = gtk_tree_view_grab_notify;
widget_class->state_changed = gtk_tree_view_state_changed;
+ widget_class->unit_changed = gtk_tree_view_unit_changed;
/* GtkContainer signals */
container_class->remove = gtk_tree_view_remove;
@@ -730,13 +734,11 @@ gtk_tree_view_class_init (GtkTreeViewClass *class)
*/
g_object_class_install_property (o_class,
PROP_LEVEL_INDENTATION,
- g_param_spec_int ("level-indentation",
- P_("Level Indentation"),
- P_("Extra indentation for each level"),
- 0,
- G_MAXINT,
- 0,
- GTK_PARAM_READWRITE));
+ gtk_param_spec_size ("level-indentation",
+ P_("Level Indentation"),
+ P_("Extra indentation for each level"),
+ 0, G_MAXINT, 0,
+ GTK_PARAM_READWRITE));
g_object_class_install_property (o_class,
PROP_RUBBER_BANDING,
@@ -774,36 +776,30 @@ gtk_tree_view_class_init (GtkTreeViewClass *class)
GTK_PARAM_READWRITE));
/* Style properties */
-#define _TREE_VIEW_EXPANDER_SIZE 12
+#define _TREE_VIEW_EXPANDER_SIZE GTK_SIZE_ONE_TWELFTH_EM(12)
#define _TREE_VIEW_VERTICAL_SEPARATOR 2
#define _TREE_VIEW_HORIZONTAL_SEPARATOR 2
gtk_widget_class_install_style_property (widget_class,
- g_param_spec_int ("expander-size",
- P_("Expander Size"),
- P_("Size of the expander arrow"),
- 0,
- G_MAXINT,
- _TREE_VIEW_EXPANDER_SIZE,
- GTK_PARAM_READABLE));
+ gtk_param_spec_size ("expander-size",
+ P_("Expander Size"),
+ P_("Size of the expander arrow"),
+ 0, G_MAXINT, _TREE_VIEW_EXPANDER_SIZE,
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
- g_param_spec_int ("vertical-separator",
- P_("Vertical Separator Width"),
- P_("Vertical space between cells. Must be an even number"),
- 0,
- G_MAXINT,
- _TREE_VIEW_VERTICAL_SEPARATOR,
- GTK_PARAM_READABLE));
+ gtk_param_spec_size ("vertical-separator",
+ P_("Vertical Separator Width"),
+ P_("Vertical space between cells. Must be an even number"),
+ 0, G_MAXINT, _TREE_VIEW_VERTICAL_SEPARATOR,
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
- g_param_spec_int ("horizontal-separator",
- P_("Horizontal Separator Width"),
- P_("Horizontal space between cells. Must be an even number"),
- 0,
- G_MAXINT,
- _TREE_VIEW_HORIZONTAL_SEPARATOR,
- GTK_PARAM_READABLE));
+ gtk_param_spec_size ("horizontal-separator",
+ P_("Horizontal Separator Width"),
+ P_("Horizontal space between cells. Must be an even number"),
+ 0, G_MAXINT, _TREE_VIEW_HORIZONTAL_SEPARATOR,
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_boolean ("allow-rules",
@@ -841,18 +837,18 @@ gtk_tree_view_class_init (GtkTreeViewClass *class)
GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
- g_param_spec_int ("grid-line-width",
- P_("Grid line width"),
- P_("Width, in pixels, of the tree view grid lines"),
- 0, G_MAXINT, 1,
- GTK_PARAM_READABLE));
+ gtk_param_spec_size ("grid-line-width",
+ P_("Grid line width"),
+ P_("Width, in pixels, of the tree view grid lines"),
+ 0, G_MAXINT, GTK_SIZE_ONE_TWELFTH_EM (1),
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
- g_param_spec_int ("tree-line-width",
- P_("Tree line width"),
- P_("Width, in pixels, of the tree view lines"),
- 0, G_MAXINT, 1,
- GTK_PARAM_READABLE));
+ gtk_param_spec_size ("tree-line-width",
+ P_("Tree line width"),
+ P_("Width, in pixels, of the tree view lines"),
+ 0, G_MAXINT, GTK_SIZE_ONE_TWELFTH_EM (1),
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_string ("grid-line-pattern",
@@ -1443,7 +1439,7 @@ gtk_tree_view_set_property (GObject *object,
gtk_tree_view_set_show_expanders (tree_view, g_value_get_boolean (value));
break;
case PROP_LEVEL_INDENTATION:
- tree_view->priv->level_indentation = g_value_get_int (value);
+ tree_view->priv->level_indentation = gtk_value_get_size (value);
break;
case PROP_RUBBER_BANDING:
tree_view->priv->rubber_banding_enable = g_value_get_boolean (value);
@@ -1518,7 +1514,7 @@ gtk_tree_view_get_property (GObject *object,
g_value_set_boolean (value, GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_SHOW_EXPANDERS));
break;
case PROP_LEVEL_INDENTATION:
- g_value_set_int (value, tree_view->priv->level_indentation);
+ gtk_value_set_size (value, tree_view->priv->level_indentation, tree_view);
break;
case PROP_RUBBER_BANDING:
g_value_set_boolean (value, tree_view->priv->rubber_banding_enable);
@@ -1856,6 +1852,8 @@ gtk_tree_view_realize (GtkWidget *widget)
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_tree_view_unit_changed (widget);
+
install_presize_handler (tree_view);
}
@@ -2011,7 +2009,7 @@ gtk_tree_view_update_size (GtkTreeView *tree_view)
}
else if (column->column_type == GTK_TREE_VIEW_COLUMN_FIXED)
{
- real_requested_width = column->fixed_width;
+ real_requested_width = gtk_widget_size_to_pixel (tree_view, column->fixed_width);
}
else if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE))
{
@@ -2023,9 +2021,9 @@ gtk_tree_view_update_size (GtkTreeView *tree_view)
}
if (column->min_width != -1)
- real_requested_width = MAX (real_requested_width, column->min_width);
+ real_requested_width = MAX (real_requested_width, gtk_widget_size_to_pixel (tree_view, column->min_width));
if (column->max_width != -1)
- real_requested_width = MIN (real_requested_width, column->max_width);
+ real_requested_width = MIN (real_requested_width, gtk_widget_size_to_pixel (tree_view, column->max_width));
tree_view->priv->width += real_requested_width;
}
@@ -2136,7 +2134,7 @@ gtk_tree_view_get_real_requested_width_from_column (GtkTreeView *tree_view
}
else if (column->column_type == GTK_TREE_VIEW_COLUMN_FIXED)
{
- real_requested_width = column->fixed_width;
+ real_requested_width = gtk_widget_size_to_pixel (tree_view, column->fixed_width);
}
else if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE))
{
@@ -2150,9 +2148,9 @@ gtk_tree_view_get_real_requested_width_from_column (GtkTreeView *tree_view
}
if (column->min_width != -1)
- real_requested_width = MAX (real_requested_width, column->min_width);
+ real_requested_width = MAX (real_requested_width, gtk_widget_size_to_pixel (tree_view, column->min_width));
if (column->max_width != -1)
- real_requested_width = MIN (real_requested_width, column->max_width);
+ real_requested_width = MIN (real_requested_width, gtk_widget_size_to_pixel (tree_view, column->max_width));
return real_requested_width;
}
@@ -2520,6 +2518,8 @@ gtk_tree_view_button_press (GtkWidget *widget,
"vertical-separator", &vertical_separator,
"horizontal-separator", &horizontal_separator,
NULL);
+ MAKE_EVEN (vertical_separator);
+ MAKE_EVEN (horizontal_separator);
/* Because grab_focus can cause reentrancy, we delay grab_focus until after
@@ -2630,8 +2630,8 @@ gtk_tree_view_button_press (GtkWidget *widget,
if (gtk_tree_view_is_expander_column (tree_view, column))
{
if (!rtl)
- cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
- cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
+ cell_area.x += (depth - 1) * gtk_widget_size_to_pixel (tree_view, tree_view->priv->level_indentation);
+ cell_area.width -= (depth - 1) * gtk_widget_size_to_pixel (tree_view, tree_view->priv->level_indentation);
if (TREE_VIEW_DRAW_EXPANDERS (tree_view))
{
@@ -3578,7 +3578,7 @@ gtk_tree_view_motion_resize_column (GtkWidget *widget,
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 != column->fixed_width))
+ (new_width != gtk_widget_size_to_pixel (tree_view, column->fixed_width)))
{
column->use_resized_width = TRUE;
column->resized_width = new_width;
@@ -4245,6 +4245,8 @@ gtk_tree_view_bin_expose (GtkWidget *widget,
"focus-line-width", &focus_line_width,
"row-ending-details", &row_ending_details,
NULL);
+ MAKE_EVEN (vertical_separator);
+ MAKE_EVEN (horizontal_separator);
if (tree_view->priv->tree == NULL)
{
@@ -4653,8 +4655,8 @@ gtk_tree_view_bin_expose (GtkWidget *widget,
if (gtk_tree_view_is_expander_column (tree_view, column))
{
if (!rtl)
- cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
- cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
+ cell_area.x += (depth - 1) * gtk_widget_size_to_pixel (tree_view, tree_view->priv->level_indentation);
+ cell_area.width -= (depth - 1) * gtk_widget_size_to_pixel (tree_view, tree_view->priv->level_indentation);
if (TREE_VIEW_DRAW_EXPANDERS(tree_view))
{
@@ -5279,12 +5281,12 @@ gtk_tree_view_key_press (GtkWidget *widget,
column->resized_width = MAX (column->button->requisition.width,
column->resized_width);
else
- column->resized_width = MAX (column->min_width,
+ column->resized_width = MAX (gtk_widget_size_to_pixel (tree_view, column->min_width),
column->resized_width);
if (column->max_width != -1)
column->resized_width = MIN (column->resized_width,
- column->max_width);
+ gtk_widget_size_to_pixel (tree_view, column->max_width));
column->use_resized_width = TRUE;
@@ -5304,7 +5306,7 @@ gtk_tree_view_key_press (GtkWidget *widget,
if (column->max_width != -1)
column->resized_width = MIN (column->resized_width,
- column->max_width);
+ gtk_widget_size_to_pixel (tree_view, column->max_width));
column->use_resized_width = TRUE;
@@ -5608,6 +5610,8 @@ validate_row (GtkTreeView *tree_view,
"wide-separators", &wide_separators,
"separator-height", &separator_height,
NULL);
+ MAKE_EVEN (vertical_separator);
+ MAKE_EVEN (horizontal_separator);
draw_vgrid_lines =
tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_VERTICAL
@@ -5662,7 +5666,7 @@ validate_row (GtkTreeView *tree_view,
if (gtk_tree_view_is_expander_column (tree_view, column))
{
- tmp_width = tmp_width + horizontal_separator + (depth - 1) * tree_view->priv->level_indentation;
+ tmp_width = tmp_width + horizontal_separator + (depth - 1) * gtk_widget_size_to_pixel (tree_view, tree_view->priv->level_indentation);
if (TREE_VIEW_DRAW_EXPANDERS (tree_view))
tmp_width += depth * tree_view->priv->expander_size;
@@ -7931,7 +7935,7 @@ gtk_tree_view_style_set (GtkWidget *widget,
gtk_widget_style_get (widget,
"expander-size", &tree_view->priv->expander_size,
NULL);
- tree_view->priv->expander_size += EXPANDER_EXTRA_PADDING;
+ tree_view->priv->expander_size += gtk_widget_size_to_pixel (tree_view, EXPANDER_EXTRA_PADDING);
for (list = tree_view->priv->columns; list; list = list->next)
{
@@ -8803,7 +8807,7 @@ gtk_tree_view_discover_dirty_iter (GtkTreeView *tree_view,
{
int tmp = 0;
- tmp = horizontal_separator + width + (depth - 1) * tree_view->priv->level_indentation;
+ tmp = horizontal_separator + width + (depth - 1) * gtk_widget_size_to_pixel (tree_view, tree_view->priv->level_indentation);
if (TREE_VIEW_DRAW_EXPANDERS (tree_view))
tmp += depth * tree_view->priv->expander_size;
@@ -9495,7 +9499,8 @@ gtk_tree_view_draw_arrow (GtkTreeView *tree_view,
gtk_widget_style_get (GTK_WIDGET (tree_view),
"vertical-separator", &vertical_separator,
NULL);
- expander_size = tree_view->priv->expander_size - EXPANDER_EXTRA_PADDING;
+ MAKE_EVEN (vertical_separator);
+ expander_size = tree_view->priv->expander_size - gtk_widget_size_to_pixel (tree_view, EXPANDER_EXTRA_PADDING);
if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
return;
@@ -9779,6 +9784,7 @@ gtk_tree_view_move_cursor_page_up_down (GtkTreeView *tree_view,
return;
gtk_widget_style_get (GTK_WIDGET (tree_view), "vertical-separator", &vertical_separator, NULL);
+ MAKE_EVEN (vertical_separator);
_gtk_tree_view_find_node (tree_view, old_cursor_path,
&cursor_tree, &cursor_node);
@@ -10357,7 +10363,7 @@ gtk_tree_view_ensure_interactive_directory (GtkTreeView *tree_view)
vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox);
gtk_container_add (GTK_CONTAINER (frame), vbox);
- gtk_container_set_border_width (GTK_CONTAINER (vbox), 3);
+ gtk_container_set_border_width (GTK_CONTAINER (vbox), GTK_SIZE_ONE_TWELFTH_EM (3));
/* add entry */
tree_view->priv->search_entry = gtk_entry_new ();
@@ -10494,10 +10500,10 @@ gtk_tree_view_new_column_width (GtkTreeView *tree_view,
width = MAX (column->button->requisition.width,
width);
else
- width = MAX (column->min_width,
+ width = MAX (gtk_widget_size_to_pixel (tree_view, column->min_width),
width);
if (column->max_width != -1)
- width = MIN (width, column->max_width);
+ width = MIN (width, gtk_widget_size_to_pixel (tree_view, column->max_width));
*x = rtl ? (column->button->allocation.x + column->button->allocation.width - width) : (column->button->allocation.x + width);
@@ -12898,6 +12904,8 @@ gtk_tree_view_get_cell_area (GtkTreeView *tree_view,
"vertical-separator", &vertical_separator,
"horizontal-separator", &horizontal_separator,
NULL);
+ MAKE_EVEN (vertical_separator);
+ MAKE_EVEN (horizontal_separator);
rect->x = 0;
rect->y = 0;
@@ -12930,8 +12938,8 @@ gtk_tree_view_get_cell_area (GtkTreeView *tree_view,
rtl = gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL;
if (!rtl)
- rect->x += (depth - 1) * tree_view->priv->level_indentation;
- rect->width -= (depth - 1) * tree_view->priv->level_indentation;
+ rect->x += (depth - 1) * gtk_widget_size_to_pixel (tree_view, tree_view->priv->level_indentation);
+ rect->width -= (depth - 1) * gtk_widget_size_to_pixel (tree_view, tree_view->priv->level_indentation);
if (TREE_VIEW_DRAW_EXPANDERS (tree_view))
{
@@ -13795,6 +13803,7 @@ gtk_tree_view_create_row_drag_icon (GtkTreeView *tree_view,
gtk_widget_style_get (widget,
"vertical-separator", &vertical_separator,
NULL);
+ MAKE_EVEN (vertical_separator);
cell_area = background_area;
@@ -13804,8 +13813,8 @@ gtk_tree_view_create_row_drag_icon (GtkTreeView *tree_view,
if (gtk_tree_view_is_expander_column (tree_view, column))
{
if (!rtl)
- cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
- cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
+ cell_area.x += (depth - 1) * gtk_widget_size_to_pixel (tree_view, tree_view->priv->level_indentation);
+ cell_area.width -= (depth - 1) * gtk_widget_size_to_pixel (tree_view, tree_view->priv->level_indentation);
if (TREE_VIEW_DRAW_EXPANDERS(tree_view))
{
@@ -15355,7 +15364,7 @@ gtk_tree_view_get_show_expanders (GtkTreeView *tree_view)
*/
void
gtk_tree_view_set_level_indentation (GtkTreeView *tree_view,
- gint indentation)
+ GtkSize indentation)
{
tree_view->priv->level_indentation = indentation;
@@ -15379,6 +15388,25 @@ gtk_tree_view_get_level_indentation (GtkTreeView *tree_view)
{
g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
+ return gtk_widget_size_to_pixel (tree_view, tree_view->priv->level_indentation);
+}
+
+/**
+ * gtk_tree_view_get_level_indentation_unit:
+ * @tree_view: a #GtkTreeView.
+ *
+ * Like gtk_tree_view_get_level_indentation() but preserves the unit.
+ *
+ * Return value: the amount of extra indentation for child levels in
+ * @tree_view. A return value of 0 means that this feature is disabled.
+ *
+ * Since: 2.14
+ */
+GtkSize
+gtk_tree_view_get_level_indentation_unit (GtkTreeView *tree_view)
+{
+ g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
+
return tree_view->priv->level_indentation;
}
@@ -15696,5 +15724,39 @@ gtk_tree_view_get_tooltip_column (GtkTreeView *tree_view)
return tree_view->priv->tooltip_column;
}
+static void
+gtk_tree_view_unit_changed (GtkWidget *widget)
+{
+ GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
+ GtkTreeViewPrivate *priv = tree_view->priv;
+ GList *l;
+
+ /* must chain up */
+ if (GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->unit_changed != NULL)
+ GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->unit_changed (widget);
+
+ /* no need to do this unless we're realized since our realize method does this too */
+ if (!GTK_WIDGET_REALIZED (widget))
+ return;
+
+ gtk_widget_style_get (widget,
+ "expander-size", &tree_view->priv->expander_size,
+ NULL);
+ tree_view->priv->expander_size += gtk_widget_size_to_pixel (tree_view, EXPANDER_EXTRA_PADDING);
+
+ /* rows in the column possibly changed size; mark them as dirty */
+ for (l = priv->columns; l != NULL; l = l->next)
+ {
+ GtkTreeViewColumn *tree_column = GTK_TREE_VIEW_COLUMN (l->data);
+ _gtk_tree_view_column_cell_set_dirty (tree_column, FALSE);
+ }
+
+ do_presize_handler (tree_view);
+ while (validate_rows (tree_view))
+ ;
+
+ gtk_widget_queue_resize (GTK_WIDGET (tree_view));
+}
+
#define __GTK_TREE_VIEW_C__
#include "gtkaliasdef.c"
diff --git a/gtk/gtktreeview.h b/gtk/gtktreeview.h
index 098ab5c..fb24055 100644
--- a/gtk/gtktreeview.h
+++ b/gtk/gtktreeview.h
@@ -404,6 +404,7 @@ gboolean gtk_tree_view_get_show_expanders (GtkTreeView
void gtk_tree_view_set_level_indentation (GtkTreeView *tree_view,
gint indentation);
gint gtk_tree_view_get_level_indentation (GtkTreeView *tree_view);
+GtkSize gtk_tree_view_get_level_indentation_unit (GtkTreeView *tree_view);
/* Convenience functions for setting tooltips */
void gtk_tree_view_set_tooltip_row (GtkTreeView *tree_view,
diff --git a/gtk/gtktreeviewcolumn.c b/gtk/gtktreeviewcolumn.c
index 24f99e4..015369c 100644
--- a/gtk/gtktreeviewcolumn.c
+++ b/gtk/gtktreeviewcolumn.c
@@ -212,13 +212,11 @@ gtk_tree_view_column_class_init (GtkTreeViewColumnClass *class)
GTK_PARAM_READABLE));
g_object_class_install_property (object_class,
PROP_SPACING,
- g_param_spec_int ("spacing",
- P_("Spacing"),
- P_("Space which is inserted between cells"),
- 0,
- G_MAXINT,
- 0,
- GTK_PARAM_READWRITE));
+ gtk_param_spec_size ("spacing",
+ P_("Spacing"),
+ P_("Space which is inserted between cells"),
+ 0, G_MAXINT, 0,
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_SIZING,
g_param_spec_enum ("sizing",
@@ -230,33 +228,27 @@ gtk_tree_view_column_class_init (GtkTreeViewColumnClass *class)
g_object_class_install_property (object_class,
PROP_FIXED_WIDTH,
- g_param_spec_int ("fixed-width",
- P_("Fixed Width"),
- P_("Current fixed width of the column"),
- 1,
- G_MAXINT,
- 1, /* not useful */
- GTK_PARAM_READWRITE));
+ gtk_param_spec_size ("fixed-width",
+ P_("Fixed Width"),
+ P_("Current fixed width of the column"),
+ 0, G_MAXINT, 1, /* not useful */
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_MIN_WIDTH,
- g_param_spec_int ("min-width",
- P_("Minimum Width"),
- P_("Minimum allowed width of the column"),
- -1,
- G_MAXINT,
- -1,
- GTK_PARAM_READWRITE));
+ gtk_param_spec_size ("min-width",
+ P_("Minimum Width"),
+ P_("Minimum allowed width of the column"),
+ -1, G_MAXINT, -1,
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_MAX_WIDTH,
- g_param_spec_int ("max-width",
- P_("Maximum Width"),
- P_("Maximum allowed width of the column"),
- -1,
- G_MAXINT,
- -1,
- GTK_PARAM_READWRITE));
+ gtk_param_spec_size ("max-width",
+ P_("Maximum Width"),
+ P_("Maximum allowed width of the column"),
+ -1, G_MAXINT, -1,
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_TITLE,
@@ -439,22 +431,22 @@ gtk_tree_view_column_set_property (GObject *object,
case PROP_FIXED_WIDTH:
gtk_tree_view_column_set_fixed_width (tree_column,
- g_value_get_int (value));
+ gtk_value_get_size (value));
break;
case PROP_MIN_WIDTH:
gtk_tree_view_column_set_min_width (tree_column,
- g_value_get_int (value));
+ gtk_value_get_size (value));
break;
case PROP_MAX_WIDTH:
gtk_tree_view_column_set_max_width (tree_column,
- g_value_get_int (value));
+ gtk_value_get_size (value));
break;
case PROP_SPACING:
gtk_tree_view_column_set_spacing (tree_column,
- g_value_get_int (value));
+ gtk_value_get_size (value));
break;
case PROP_TITLE:
@@ -531,8 +523,8 @@ gtk_tree_view_column_get_property (GObject *object,
break;
case PROP_SPACING:
- g_value_set_int (value,
- gtk_tree_view_column_get_spacing (tree_column));
+ gtk_value_set_size (value,
+ gtk_tree_view_column_get_spacing_unit (tree_column), tree_column->tree_view);
break;
case PROP_SIZING:
@@ -541,18 +533,18 @@ gtk_tree_view_column_get_property (GObject *object,
break;
case PROP_FIXED_WIDTH:
- g_value_set_int (value,
- gtk_tree_view_column_get_fixed_width (tree_column));
+ gtk_value_set_size (value,
+ gtk_tree_view_column_get_fixed_width_unit (tree_column), tree_column->tree_view);
break;
case PROP_MIN_WIDTH:
- g_value_set_int (value,
- gtk_tree_view_column_get_min_width (tree_column));
+ gtk_value_set_size (value,
+ gtk_tree_view_column_get_min_width_unit (tree_column), tree_column->tree_view);
break;
case PROP_MAX_WIDTH:
- g_value_set_int (value,
- gtk_tree_view_column_get_max_width (tree_column));
+ gtk_value_set_size (value,
+ gtk_tree_view_column_get_max_width_unit (tree_column), tree_column->tree_view);
break;
case PROP_TITLE:
@@ -626,6 +618,8 @@ gtk_tree_view_column_cell_layout_pack_start (GtkCellLayout *cell_layout,
cell_info->attributes = NULL;
column->cell_list = g_list_append (column->cell_list, cell_info);
+
+ _gtk_cell_renderer_set_tree_view_column (cell, column);
}
static void
@@ -650,6 +644,8 @@ gtk_tree_view_column_cell_layout_pack_end (GtkCellLayout *cell_layout,
cell_info->attributes = NULL;
column->cell_list = g_list_append (column->cell_list, cell_info);
+
+ _gtk_cell_renderer_set_tree_view_column (cell, column);
}
static void
@@ -825,7 +821,7 @@ gtk_tree_view_column_create_button (GtkTreeViewColumn *tree_column)
tree_column->alignment = gtk_alignment_new (tree_column->xalign, 0.5, 0.0, 0.0);
- hbox = gtk_hbox_new (FALSE, 2);
+ hbox = gtk_hbox_new (FALSE, GTK_SIZE_ONE_TWELFTH_EM (2));
tree_column->arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_IN);
if (tree_column->child)
@@ -1698,7 +1694,7 @@ gtk_tree_view_column_clear_attributes (GtkTreeViewColumn *tree_column,
**/
void
gtk_tree_view_column_set_spacing (GtkTreeViewColumn *tree_column,
- gint spacing)
+ GtkSize spacing)
{
g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
g_return_if_fail (spacing >= 0);
@@ -1724,6 +1720,24 @@ gtk_tree_view_column_get_spacing (GtkTreeViewColumn *tree_column)
{
g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0);
+ return gtk_widget_size_to_pixel (tree_column->tree_view, tree_column->spacing);
+}
+
+/**
+ * gtk_tree_view_column_get_spacing_unit:
+ * @tree_column: A #GtkTreeViewColumn.
+ *
+ * Like gtk_tree_view_column_get_spacing() but preserve the unit.
+ *
+ * Return value: the spacing of @tree_column.
+ *
+ * Since: 2.14
+ **/
+GtkSize
+gtk_tree_view_column_get_spacing_unit (GtkTreeViewColumn *tree_column)
+{
+ g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0);
+
return tree_column->spacing;
}
@@ -1902,7 +1916,7 @@ gtk_tree_view_column_get_width (GtkTreeViewColumn *tree_column)
**/
void
gtk_tree_view_column_set_fixed_width (GtkTreeViewColumn *tree_column,
- gint fixed_width)
+ GtkSize fixed_width)
{
g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
g_return_if_fail (fixed_width > 0);
@@ -1934,6 +1948,24 @@ gtk_tree_view_column_get_fixed_width (GtkTreeViewColumn *tree_column)
{
g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0);
+ return gtk_widget_size_to_pixel (tree_column->tree_view, tree_column->fixed_width);
+}
+
+/**
+ * gtk_tree_view_column_get_fixed_width_unit:
+ * @tree_column: a #GtkTreeViewColumn
+ *
+ * Like gtk_tree_view_column_get_fixed_width() but preserves the unit.
+ *
+ * Return value: the fixed width of the column
+ *
+ * Since: 2.14
+ **/
+GtkSize
+gtk_tree_view_column_get_fixed_width_unit (GtkTreeViewColumn *tree_column)
+{
+ g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0);
+
return tree_column->fixed_width;
}
@@ -1947,7 +1979,7 @@ gtk_tree_view_column_get_fixed_width (GtkTreeViewColumn *tree_column)
**/
void
gtk_tree_view_column_set_min_width (GtkTreeViewColumn *tree_column,
- gint min_width)
+ GtkSize min_width)
{
g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
g_return_if_fail (min_width >= -1);
@@ -1959,13 +1991,13 @@ gtk_tree_view_column_set_min_width (GtkTreeViewColumn *tree_column,
tree_column->tree_view != NULL &&
GTK_WIDGET_REALIZED (tree_column->tree_view))
{
- if (min_width > tree_column->width)
+ if (gtk_widget_size_to_pixel (tree_column->tree_view, min_width) > tree_column->width)
gtk_widget_queue_resize (tree_column->tree_view);
}
tree_column->min_width = min_width;
g_object_freeze_notify (G_OBJECT (tree_column));
- if (tree_column->max_width != -1 && tree_column->max_width < min_width)
+ if (tree_column->max_width != -1 && gtk_widget_size_to_pixel (tree_column->tree_view, tree_column->max_width) < gtk_widget_size_to_pixel (tree_column->tree_view, min_width))
{
tree_column->max_width = min_width;
g_object_notify (G_OBJECT (tree_column), "max-width");
@@ -1992,6 +2024,24 @@ gtk_tree_view_column_get_min_width (GtkTreeViewColumn *tree_column)
{
g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), -1);
+ return gtk_widget_size_to_pixel (tree_column->tree_view, tree_column->min_width);
+}
+
+/**
+ * gtk_tree_view_column_get_min_width_unit:
+ * @tree_column: A #GtkTreeViewColumn.
+ *
+ * Like gtk_tree_view_column_get_min_width() but preserves the unit.
+ *
+ * Return value: The minimum width of the @tree_column.
+ *
+ * Since: 2.14
+ **/
+GtkSize
+gtk_tree_view_column_get_min_width_unit (GtkTreeViewColumn *tree_column)
+{
+ g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), -1);
+
return tree_column->min_width;
}
@@ -2007,7 +2057,7 @@ gtk_tree_view_column_get_min_width (GtkTreeViewColumn *tree_column)
**/
void
gtk_tree_view_column_set_max_width (GtkTreeViewColumn *tree_column,
- gint max_width)
+ GtkSize max_width)
{
g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
g_return_if_fail (max_width >= -1);
@@ -2019,13 +2069,13 @@ gtk_tree_view_column_set_max_width (GtkTreeViewColumn *tree_column,
tree_column->tree_view != NULL &&
GTK_WIDGET_REALIZED (tree_column->tree_view))
{
- if (max_width != -1 && max_width < tree_column->width)
+ if (max_width != -1 && gtk_widget_size_to_pixel (tree_column->tree_view, max_width) < tree_column->width)
gtk_widget_queue_resize (tree_column->tree_view);
}
tree_column->max_width = max_width;
g_object_freeze_notify (G_OBJECT (tree_column));
- if (max_width != -1 && max_width < tree_column->min_width)
+ if (max_width != -1 && gtk_widget_size_to_pixel (tree_column->tree_view, max_width) < gtk_widget_size_to_pixel (tree_column->tree_view, tree_column->min_width))
{
tree_column->min_width = max_width;
g_object_notify (G_OBJECT (tree_column), "min-width");
@@ -2052,6 +2102,24 @@ gtk_tree_view_column_get_max_width (GtkTreeViewColumn *tree_column)
{
g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), -1);
+ return gtk_widget_size_to_pixel (tree_column->tree_view, tree_column->max_width);
+}
+
+/**
+ * gtk_tree_view_column_get_max_width_unit:
+ * @tree_column: A #GtkTreeViewColumn.
+ *
+ * Like gtk_tree_view_column_get_max_width() but preserves the unit.
+ *
+ * Return value: The maximum width of the @tree_column.
+ *
+ * Since: 2.14
+ **/
+GtkSize
+gtk_tree_view_column_get_max_width_unit (GtkTreeViewColumn *tree_column)
+{
+ g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), -1);
+
return tree_column->max_width;
}
@@ -2585,6 +2653,7 @@ gtk_tree_view_column_cell_get_size (GtkTreeViewColumn *tree_column,
GList *list;
gboolean first_cell = TRUE;
gint focus_line_width;
+ gint spacing_pixels;
g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
@@ -2594,6 +2663,8 @@ gtk_tree_view_column_cell_get_size (GtkTreeViewColumn *tree_column,
* width = 0;
gtk_widget_style_get (tree_column->tree_view, "focus-line-width", &focus_line_width, NULL);
+
+ spacing_pixels = gtk_widget_size_to_pixel (tree_column->tree_view, tree_column->spacing);
for (list = tree_column->cell_list; list; list = list->next)
{
@@ -2607,7 +2678,7 @@ gtk_tree_view_column_cell_get_size (GtkTreeViewColumn *tree_column,
continue;
if (first_cell == FALSE && width)
- *width += tree_column->spacing;
+ *width += spacing_pixels;
gtk_cell_renderer_get_size (info->cell,
tree_column->tree_view,
@@ -2736,7 +2807,7 @@ gtk_tree_view_column_cell_process_action (GtkTreeViewColumn *tree_column,
full_requested_width += info->requested_width;
if (!first_cell)
- full_requested_width += tree_column->spacing;
+ full_requested_width += gtk_widget_size_to_pixel (tree_column->tree_view, tree_column->spacing);
first_cell = FALSE;
}
@@ -2915,8 +2986,8 @@ gtk_tree_view_column_cell_process_action (GtkTreeViewColumn *tree_column,
flags &= ~GTK_CELL_RENDERER_FOCUSED;
- real_cell_area.x += (real_cell_area.width + 2 * focus_line_width + tree_column->spacing);
- real_background_area.x += real_background_area.width + tree_column->spacing;
+ real_cell_area.x += (real_cell_area.width + 2 * focus_line_width + gtk_widget_size_to_pixel (tree_column->tree_view, tree_column->spacing));
+ real_background_area.x += real_background_area.width + gtk_widget_size_to_pixel (tree_column->tree_view, tree_column->spacing);
/* Only needed for first cell */
depth = 0;
@@ -3079,8 +3150,8 @@ gtk_tree_view_column_cell_process_action (GtkTreeViewColumn *tree_column,
flags &= ~GTK_CELL_RENDERER_FOCUSED;
- real_cell_area.x += (real_cell_area.width + 2 * focus_line_width + tree_column->spacing);
- real_background_area.x += (real_background_area.width + tree_column->spacing);
+ real_cell_area.x += (real_cell_area.width + 2 * focus_line_width + gtk_widget_size_to_pixel (tree_column->tree_view, tree_column->spacing));
+ real_background_area.x += (real_background_area.width + gtk_widget_size_to_pixel (tree_column->tree_view, tree_column->spacing));
/* Only needed for first cell */
depth = 0;
@@ -3641,7 +3712,7 @@ _gtk_tree_view_column_get_neighbor_sizes (GtkTreeViewColumn *column,
break;
if (info->cell->visible)
- l += info->real_width + column->spacing;
+ l += info->real_width + gtk_widget_size_to_pixel (column->tree_view, column->spacing);
}
while (list)
@@ -3651,7 +3722,7 @@ _gtk_tree_view_column_get_neighbor_sizes (GtkTreeViewColumn *column,
list = gtk_tree_view_column_cell_next (column, list);
if (info->cell->visible)
- r += info->real_width + column->spacing;
+ r += info->real_width + gtk_widget_size_to_pixel (column->tree_view, column->spacing);
}
rtl = (gtk_widget_get_direction (GTK_WIDGET (column->tree_view)) == GTK_TEXT_DIR_RTL);
diff --git a/gtk/gtktreeviewcolumn.h b/gtk/gtktreeviewcolumn.h
index 9238a62..343aae6 100644
--- a/gtk/gtktreeviewcolumn.h
+++ b/gtk/gtktreeviewcolumn.h
@@ -49,7 +49,6 @@ typedef enum
GTK_TREE_VIEW_COLUMN_FIXED
} GtkTreeViewColumnSizing;
-typedef struct _GtkTreeViewColumn GtkTreeViewColumn;
typedef struct _GtkTreeViewColumnClass GtkTreeViewColumnClass;
typedef void (* GtkTreeCellDataFunc) (GtkTreeViewColumn *tree_column,
@@ -72,7 +71,7 @@ struct _GtkTreeViewColumn
GtkCellEditable *GSEAL (editable_widget);
gfloat GSEAL (xalign);
guint GSEAL (property_changed_signal);
- gint GSEAL (spacing);
+ GtkSize GSEAL (spacing);
/* Sizing fields */
/* see gtk+/doc/tree-column-sizing.txt for more information on them */
@@ -81,9 +80,9 @@ struct _GtkTreeViewColumn
gint GSEAL (button_request);
gint GSEAL (resized_width);
gint GSEAL (width);
- gint GSEAL (fixed_width);
- gint GSEAL (min_width);
- gint GSEAL (max_width);
+ GtkSize GSEAL (fixed_width);
+ GtkSize GSEAL (min_width);
+ GtkSize GSEAL (max_width);
/* dragging columns */
gint GSEAL (drag_x);
@@ -151,8 +150,9 @@ void gtk_tree_view_column_set_cell_data_func (GtkTreeViewCol
void gtk_tree_view_column_clear_attributes (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell_renderer);
void gtk_tree_view_column_set_spacing (GtkTreeViewColumn *tree_column,
- gint spacing);
+ GtkSize spacing);
gint gtk_tree_view_column_get_spacing (GtkTreeViewColumn *tree_column);
+GtkSize gtk_tree_view_column_get_spacing_unit (GtkTreeViewColumn *tree_column);
void gtk_tree_view_column_set_visible (GtkTreeViewColumn *tree_column,
gboolean visible);
gboolean gtk_tree_view_column_get_visible (GtkTreeViewColumn *tree_column);
@@ -164,14 +164,17 @@ void gtk_tree_view_column_set_sizing (GtkTreeViewCol
GtkTreeViewColumnSizing gtk_tree_view_column_get_sizing (GtkTreeViewColumn *tree_column);
gint gtk_tree_view_column_get_width (GtkTreeViewColumn *tree_column);
gint gtk_tree_view_column_get_fixed_width (GtkTreeViewColumn *tree_column);
+GtkSize gtk_tree_view_column_get_fixed_width_unit(GtkTreeViewColumn *tree_column);
void gtk_tree_view_column_set_fixed_width (GtkTreeViewColumn *tree_column,
- gint fixed_width);
+ GtkSize fixed_width);
void gtk_tree_view_column_set_min_width (GtkTreeViewColumn *tree_column,
- gint min_width);
+ GtkSize min_width);
gint gtk_tree_view_column_get_min_width (GtkTreeViewColumn *tree_column);
+GtkSize gtk_tree_view_column_get_min_width_unit (GtkTreeViewColumn *tree_column);
void gtk_tree_view_column_set_max_width (GtkTreeViewColumn *tree_column,
- gint max_width);
+ GtkSize max_width);
gint gtk_tree_view_column_get_max_width (GtkTreeViewColumn *tree_column);
+GtkSize gtk_tree_view_column_get_max_width_unit (GtkTreeViewColumn *tree_column);
void gtk_tree_view_column_clicked (GtkTreeViewColumn *tree_column);
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
