X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;ds=sidebyside;f=gtk%2Fgtktreeviewcolumn.c;h=70349d964643ca2173959a5361421451df0190e2;hb=11396cb71fead96005e002d60c7065bc944bafce;hp=9fdfc74f3438619b8ece0f27a580249edf1eb0a1;hpb=bf2e5fc154f9c002273c0fd1caeb769ca2ef3200;p=~andy%2Fgtk diff --git a/gtk/gtktreeviewcolumn.c b/gtk/gtktreeviewcolumn.c index 9fdfc74f3..70349d964 100644 --- a/gtk/gtktreeviewcolumn.c +++ b/gtk/gtktreeviewcolumn.c @@ -17,10 +17,13 @@ * Boston, MA 02111-1307, USA. */ +#include #include +#include "gtkalias.h" #include "gtktreeviewcolumn.h" #include "gtktreeview.h" #include "gtktreeprivate.h" +#include "gtkcelllayout.h" #include "gtkbutton.h" #include "gtkalignment.h" #include "gtklabel.h" @@ -35,6 +38,7 @@ enum PROP_VISIBLE, PROP_RESIZABLE, PROP_WIDTH, + PROP_SPACING, PROP_SIZING, PROP_FIXED_WIDTH, PROP_MIN_WIDTH, @@ -74,6 +78,7 @@ struct _GtkTreeViewColumnCellInfo /* Type methods */ static void gtk_tree_view_column_init (GtkTreeViewColumn *tree_column); static void gtk_tree_view_column_class_init (GtkTreeViewColumnClass *klass); +static void gtk_tree_view_column_cell_layout_init (GtkCellLayoutIface *iface); /* GObject methods */ static void gtk_tree_view_column_set_property (GObject *object, @@ -86,6 +91,29 @@ static void gtk_tree_view_column_get_property (GObject GParamSpec *pspec); static void gtk_tree_view_column_finalize (GObject *object); +/* GtkCellLayout implementation */ +static void gtk_tree_view_column_cell_layout_pack_start (GtkCellLayout *cell_layout, + GtkCellRenderer *cell, + gboolean expand); +static void gtk_tree_view_column_cell_layout_pack_end (GtkCellLayout *cell_layout, + GtkCellRenderer *cell, + gboolean expand); +static void gtk_tree_view_column_cell_layout_clear (GtkCellLayout *cell_layout); +static void gtk_tree_view_column_cell_layout_add_attribute (GtkCellLayout *cell_layout, + GtkCellRenderer *cell, + const gchar *attribute, + gint column); +static void gtk_tree_view_column_cell_layout_set_cell_data_func (GtkCellLayout *cell_layout, + GtkCellRenderer *cell, + GtkCellLayoutDataFunc func, + gpointer func_data, + GDestroyNotify destroy); +static void gtk_tree_view_column_cell_layout_clear_attributes (GtkCellLayout *cell_layout, + GtkCellRenderer *cell); +static void gtk_tree_view_column_cell_layout_reorder (GtkCellLayout *cell_layout, + GtkCellRenderer *cell, + gint position); + /* Button handling code */ static void gtk_tree_view_column_create_button (GtkTreeViewColumn *tree_column); static void gtk_tree_view_column_update_button (GtkTreeViewColumn *tree_column); @@ -145,12 +173,23 @@ gtk_tree_view_column_get_type (void) NULL, /* class_data */ sizeof (GtkTreeViewColumn), 0, - (GInstanceInitFunc) gtk_tree_view_column_init, + (GInstanceInitFunc) gtk_tree_view_column_init + }; + + static const GInterfaceInfo cell_layout_info = + { + (GInterfaceInitFunc) gtk_tree_view_column_cell_layout_init, + NULL, + NULL }; tree_column_type = g_type_register_static (GTK_TYPE_OBJECT, "GtkTreeViewColumn", &tree_column_info, 0); + + g_type_add_interface_static (tree_column_type, + GTK_TYPE_CELL_LAYOUT, + &cell_layout_info); } return tree_column_type; @@ -183,42 +222,51 @@ gtk_tree_view_column_class_init (GtkTreeViewColumnClass *class) g_object_class_install_property (object_class, PROP_VISIBLE, g_param_spec_boolean ("visible", - _("Visible"), - _("Whether to display the column"), + P_("Visible"), + P_("Whether to display the column"), TRUE, G_PARAM_READABLE | G_PARAM_WRITABLE)); g_object_class_install_property (object_class, PROP_RESIZABLE, g_param_spec_boolean ("resizable", - _("Resizable"), - _("Column is user-resizable"), + P_("Resizable"), + P_("Column is user-resizable"), FALSE, G_PARAM_READABLE | G_PARAM_WRITABLE)); g_object_class_install_property (object_class, PROP_WIDTH, g_param_spec_int ("width", - _("Width"), - _("Current width of the column"), + P_("Width"), + P_("Current width of the column"), 0, G_MAXINT, 0, G_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, + G_PARAM_READWRITE)); g_object_class_install_property (object_class, PROP_SIZING, g_param_spec_enum ("sizing", - _("Sizing"), - _("Resize mode of the column"), + P_("Sizing"), + P_("Resize mode of the column"), GTK_TYPE_TREE_VIEW_COLUMN_SIZING, - GTK_TREE_VIEW_COLUMN_AUTOSIZE, + GTK_TREE_VIEW_COLUMN_GROW_ONLY, G_PARAM_READABLE | G_PARAM_WRITABLE)); g_object_class_install_property (object_class, PROP_FIXED_WIDTH, g_param_spec_int ("fixed_width", - _("Fixed Width"), - _("Current fixed width of the column"), + P_("Fixed Width"), + P_("Current fixed width of the column"), 1, G_MAXINT, 1, /* not useful */ @@ -227,8 +275,8 @@ gtk_tree_view_column_class_init (GtkTreeViewColumnClass *class) g_object_class_install_property (object_class, PROP_MIN_WIDTH, g_param_spec_int ("min_width", - _("Minimum Width"), - _("Minimum allowed width of the column"), + P_("Minimum Width"), + P_("Minimum allowed width of the column"), -1, G_MAXINT, -1, @@ -237,8 +285,8 @@ gtk_tree_view_column_class_init (GtkTreeViewColumnClass *class) g_object_class_install_property (object_class, PROP_MAX_WIDTH, g_param_spec_int ("max_width", - _("Maximum Width"), - _("Maximum allowed width of the column"), + P_("Maximum Width"), + P_("Maximum allowed width of the column"), -1, G_MAXINT, -1, @@ -247,79 +295,92 @@ gtk_tree_view_column_class_init (GtkTreeViewColumnClass *class) g_object_class_install_property (object_class, PROP_TITLE, g_param_spec_string ("title", - _("Title"), - _("Title to appear in column header"), + P_("Title"), + P_("Title to appear in column header"), "", G_PARAM_READABLE | G_PARAM_WRITABLE)); g_object_class_install_property (object_class, PROP_EXPAND, g_param_spec_boolean ("expand", - _("Expand"), - _("Column gets share of extra width allocated to the widget"), + P_("Expand"), + P_("Column gets share of extra width allocated to the widget"), FALSE, G_PARAM_READABLE | G_PARAM_WRITABLE)); g_object_class_install_property (object_class, PROP_CLICKABLE, g_param_spec_boolean ("clickable", - _("Clickable"), - _("Whether the header can be clicked"), - TRUE, + P_("Clickable"), + P_("Whether the header can be clicked"), + FALSE, G_PARAM_READABLE | G_PARAM_WRITABLE)); g_object_class_install_property (object_class, PROP_WIDGET, g_param_spec_object ("widget", - _("Widget"), - _("Widget to put in column header button instead of column title"), + P_("Widget"), + P_("Widget to put in column header button instead of column title"), GTK_TYPE_WIDGET, G_PARAM_READABLE | G_PARAM_WRITABLE)); g_object_class_install_property (object_class, PROP_ALIGNMENT, g_param_spec_float ("alignment", - _("Alignment"), - _("X Alignment of the column header text or widget"), + P_("Alignment"), + P_("X Alignment of the column header text or widget"), 0.0, 1.0, - 0.5, + 0.0, G_PARAM_READABLE | G_PARAM_WRITABLE)); g_object_class_install_property (object_class, PROP_REORDERABLE, g_param_spec_boolean ("reorderable", - _("Reorderable"), - _("Whether the column can be reordered around the headers"), + P_("Reorderable"), + P_("Whether the column can be reordered around the headers"), FALSE, G_PARAM_READABLE | G_PARAM_WRITABLE)); g_object_class_install_property (object_class, PROP_SORT_INDICATOR, g_param_spec_boolean ("sort_indicator", - _("Sort indicator"), - _("Whether to show a sort indicator"), + P_("Sort indicator"), + P_("Whether to show a sort indicator"), FALSE, G_PARAM_READABLE | G_PARAM_WRITABLE)); g_object_class_install_property (object_class, PROP_SORT_ORDER, g_param_spec_enum ("sort_order", - _("Sort order"), - _("Sort direction the sort indicator should indicate"), + P_("Sort order"), + P_("Sort direction the sort indicator should indicate"), GTK_TYPE_SORT_TYPE, GTK_SORT_ASCENDING, G_PARAM_READABLE | G_PARAM_WRITABLE)); } +static void +gtk_tree_view_column_cell_layout_init (GtkCellLayoutIface *iface) +{ + iface->pack_start = gtk_tree_view_column_cell_layout_pack_start; + iface->pack_end = gtk_tree_view_column_cell_layout_pack_end; + iface->clear = gtk_tree_view_column_cell_layout_clear; + iface->add_attribute = gtk_tree_view_column_cell_layout_add_attribute; + iface->set_cell_data_func = gtk_tree_view_column_cell_layout_set_cell_data_func; + iface->clear_attributes = gtk_tree_view_column_cell_layout_clear_attributes; + iface->reorder = gtk_tree_view_column_cell_layout_reorder; +} + static void gtk_tree_view_column_init (GtkTreeViewColumn *tree_column) { tree_column->button = NULL; tree_column->xalign = 0.0; tree_column->width = 0; + tree_column->spacing = 0; tree_column->requested_width = -1; tree_column->min_width = -1; tree_column->max_width = -1; @@ -327,6 +388,7 @@ gtk_tree_view_column_init (GtkTreeViewColumn *tree_column) tree_column->column_type = GTK_TREE_VIEW_COLUMN_GROW_ONLY; tree_column->visible = TRUE; tree_column->resizable = FALSE; + tree_column->expand = FALSE; tree_column->clickable = FALSE; tree_column->dirty = TRUE; tree_column->sort_order = GTK_SORT_ASCENDING; @@ -337,7 +399,9 @@ gtk_tree_view_column_init (GtkTreeViewColumn *tree_column) tree_column->sort_column_id = -1; tree_column->reorderable = FALSE; tree_column->maybe_reordered = FALSE; + tree_column->fixed_width = 1; tree_column->use_resized_width = FALSE; + tree_column->title = g_strdup (""); } static void @@ -413,6 +477,11 @@ gtk_tree_view_column_set_property (GObject *object, g_value_get_int (value)); break; + case PROP_SPACING: + gtk_tree_view_column_set_spacing (tree_column, + g_value_get_int (value)); + break; + case PROP_TITLE: gtk_tree_view_column_set_title (tree_column, g_value_get_string (value)); @@ -486,6 +555,11 @@ gtk_tree_view_column_get_property (GObject *object, gtk_tree_view_column_get_width (tree_column)); break; + case PROP_SPACING: + g_value_set_int (value, + gtk_tree_view_column_get_spacing (tree_column)); + break; + case PROP_SIZING: g_value_set_enum (value, gtk_tree_view_column_get_sizing (tree_column)); @@ -552,6 +626,194 @@ gtk_tree_view_column_get_property (GObject *object, } } +/* Implementation of GtkCellLayout interface + */ + +static void +gtk_tree_view_column_cell_layout_pack_start (GtkCellLayout *cell_layout, + GtkCellRenderer *cell, + gboolean expand) +{ + GtkTreeViewColumn *column; + GtkTreeViewColumnCellInfo *cell_info; + + g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (cell_layout)); + column = GTK_TREE_VIEW_COLUMN (cell_layout); + g_return_if_fail (! gtk_tree_view_column_get_cell_info (column, cell)); + + g_object_ref (cell); + gtk_object_sink (GTK_OBJECT (cell)); + + cell_info = g_new0 (GtkTreeViewColumnCellInfo, 1); + cell_info->cell = cell; + cell_info->expand = expand ? TRUE : FALSE; + cell_info->pack = GTK_PACK_START; + cell_info->has_focus = 0; + cell_info->attributes = NULL; + + column->cell_list = g_list_append (column->cell_list, cell_info); +} + +static void +gtk_tree_view_column_cell_layout_pack_end (GtkCellLayout *cell_layout, + GtkCellRenderer *cell, + gboolean expand) +{ + GtkTreeViewColumn *column; + GtkTreeViewColumnCellInfo *cell_info; + + g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (cell_layout)); + column = GTK_TREE_VIEW_COLUMN (cell_layout); + g_return_if_fail (! gtk_tree_view_column_get_cell_info (column, cell)); + + g_object_ref (cell); + gtk_object_sink (GTK_OBJECT (cell)); + + cell_info = g_new0 (GtkTreeViewColumnCellInfo, 1); + cell_info->cell = cell; + cell_info->expand = expand ? TRUE : FALSE; + cell_info->pack = GTK_PACK_END; + cell_info->has_focus = 0; + cell_info->attributes = NULL; + + column->cell_list = g_list_append (column->cell_list, cell_info); +} + +static void +gtk_tree_view_column_cell_layout_clear (GtkCellLayout *cell_layout) +{ + GtkTreeViewColumn *column; + + g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (cell_layout)); + column = GTK_TREE_VIEW_COLUMN (cell_layout); + + while (column->cell_list) + { + GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *)column->cell_list->data; + + gtk_tree_view_column_cell_layout_clear_attributes (cell_layout, info->cell); + g_object_unref (G_OBJECT (info->cell)); + g_free (info); + column->cell_list = g_list_delete_link (column->cell_list, + column->cell_list); + } +} + +static void +gtk_tree_view_column_cell_layout_add_attribute (GtkCellLayout *cell_layout, + GtkCellRenderer *cell, + const gchar *attribute, + gint column) +{ + GtkTreeViewColumn *tree_column; + GtkTreeViewColumnCellInfo *info; + + g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (cell_layout)); + tree_column = GTK_TREE_VIEW_COLUMN (cell_layout); + + info = gtk_tree_view_column_get_cell_info (tree_column, cell); + g_return_if_fail (info != NULL); + + info->attributes = g_slist_prepend (info->attributes, GINT_TO_POINTER (column)); + info->attributes = g_slist_prepend (info->attributes, g_strdup (attribute)); + + if (tree_column->tree_view) + _gtk_tree_view_column_cell_set_dirty (tree_column, TRUE); +} + +static void +gtk_tree_view_column_cell_layout_set_cell_data_func (GtkCellLayout *cell_layout, + GtkCellRenderer *cell, + GtkCellLayoutDataFunc func, + gpointer func_data, + GDestroyNotify destroy) +{ + GtkTreeViewColumn *column; + GtkTreeViewColumnCellInfo *info; + + g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (cell_layout)); + column = GTK_TREE_VIEW_COLUMN (cell_layout); + + info = gtk_tree_view_column_get_cell_info (column, cell); + g_return_if_fail (info != NULL); + + if (info->destroy) + { + GDestroyNotify d = info->destroy; + + info->destroy = NULL; + d (info->func_data); + } + + info->func = (GtkTreeCellDataFunc)func; + info->func_data = func_data; + info->destroy = destroy; + + if (column->tree_view) + _gtk_tree_view_column_cell_set_dirty (column, TRUE); +} + +static void +gtk_tree_view_column_cell_layout_clear_attributes (GtkCellLayout *cell_layout, + GtkCellRenderer *cell_renderer) +{ + GtkTreeViewColumn *column; + GtkTreeViewColumnCellInfo *info; + + g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (cell_layout)); + column = GTK_TREE_VIEW_COLUMN (cell_layout); + + info = gtk_tree_view_column_get_cell_info (column, cell_renderer); + gtk_tree_view_column_clear_attributes_by_info (column, info); +} + +static void +gtk_tree_view_column_cell_layout_reorder (GtkCellLayout *cell_layout, + GtkCellRenderer *cell, + gint position) +{ + GList *link; + GtkTreeViewColumn *column; + GtkTreeViewColumnCellInfo *info; + + g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (cell_layout)); + column = GTK_TREE_VIEW_COLUMN (cell_layout); + + info = gtk_tree_view_column_get_cell_info (column, cell); + + g_return_if_fail (info != NULL); + g_return_if_fail (position >= 0); + + link = g_list_find (column->cell_list, info); + + g_return_if_fail (link != NULL); + + column->cell_list = g_list_remove_link (column->cell_list, link); + column->cell_list = g_list_insert (column->cell_list, info, position); + + gtk_widget_queue_draw (column->tree_view); +} + +static void +gtk_tree_view_column_clear_attributes_by_info (GtkTreeViewColumn *tree_column, + GtkTreeViewColumnCellInfo *info) +{ + GSList *list; + + list = info->attributes; + + while (list && list->next) + { + g_free (list->data); + list = list->next->next; + } + g_slist_free (info->attributes); + info->attributes = NULL; + + if (tree_column->tree_view) + _gtk_tree_view_column_cell_set_dirty (tree_column, TRUE); +} + /* Helper functions */ @@ -980,8 +1242,10 @@ _gtk_tree_view_column_realize_button (GtkTreeViewColumn *column) GtkTreeView *tree_view; GdkWindowAttr attr; guint attributes_mask; + gboolean rtl; tree_view = (GtkTreeView *)column->tree_view; + rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL); g_return_if_fail (GTK_IS_TREE_VIEW (tree_view)); g_return_if_fail (GTK_WIDGET_REALIZED (tree_view)); @@ -997,8 +1261,8 @@ _gtk_tree_view_column_realize_button (GtkTreeViewColumn *column) attr.wclass = GDK_INPUT_ONLY; attr.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view)); attr.colormap = gtk_widget_get_colormap (GTK_WIDGET (tree_view)); - attr.event_mask = gtk_widget_get_events (GTK_WIDGET (tree_view)); - attr.event_mask = (GDK_BUTTON_PRESS_MASK | + attr.event_mask = gtk_widget_get_events (GTK_WIDGET (tree_view)) | + (GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | @@ -1010,8 +1274,7 @@ _gtk_tree_view_column_realize_button (GtkTreeViewColumn *column) attr.width = TREE_VIEW_DRAG_WIDTH; attr.height = tree_view->priv->header_height; - attr.x = (column->button->allocation.x + column->button->allocation.width) - 3; - + attr.x = (column->button->allocation.x + (rtl ? 0 : column->button->allocation.width)) - 3; column->window = gdk_window_new (tree_view->priv->header_window, &attr, attributes_mask); gdk_window_set_user_data (column->window, tree_view); @@ -1235,71 +1498,38 @@ gtk_tree_view_column_get_cell_info (GtkTreeViewColumn *tree_column, * gtk_tree_view_column_pack_start: * @tree_column: A #GtkTreeViewColumn. * @cell: The #GtkCellRenderer. - * @expand: %TRUE if @cell is to be given extra space allocated to box. + * @expand: %TRUE if @cell is to be given extra space allocated to @tree_column. * - * Packs the @cell into the beginning of the column. If @expand is FALSE, then + * Packs the @cell into the beginning of the column. If @expand is %FALSE, then * the @cell is allocated no more space than it needs. Any unused space is divided - * evenly between cells for which @expand is TRUE. + * evenly between cells for which @expand is %TRUE. **/ void gtk_tree_view_column_pack_start (GtkTreeViewColumn *tree_column, GtkCellRenderer *cell, gboolean expand) { - GtkTreeViewColumnCellInfo *cell_info; - - g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); - g_return_if_fail (GTK_IS_CELL_RENDERER (cell)); - g_return_if_fail (! gtk_tree_view_column_get_cell_info (tree_column, cell)); - - g_object_ref (cell); - gtk_object_sink (GTK_OBJECT (cell)); - - cell_info = g_new0 (GtkTreeViewColumnCellInfo, 1); - cell_info->cell = cell; - cell_info->expand = expand ? TRUE : FALSE; - cell_info->pack = GTK_PACK_START; - cell_info->has_focus = 0; - cell_info->attributes = NULL; - - tree_column->cell_list = g_list_append (tree_column->cell_list, cell_info); + gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (tree_column), cell, expand); } /** * gtk_tree_view_column_pack_end: * @tree_column: A #GtkTreeViewColumn. * @cell: The #GtkCellRenderer. - * @expand: %TRUE if @cell is to be given extra space allocated to box. + * @expand: %TRUE if @cell is to be given extra space allocated to @tree_column. * - * Adds the @cell to end of the column. If @expand is FALSE, then the @cell + * Adds the @cell to end of the column. If @expand is %FALSE, then the @cell * is allocated no more space than it needs. Any unused space is divided - * evenly between cells for which @expand is TRUE. + * evenly between cells for which @expand is %TRUE. **/ void gtk_tree_view_column_pack_end (GtkTreeViewColumn *tree_column, GtkCellRenderer *cell, gboolean expand) { - GtkTreeViewColumnCellInfo *cell_info; - - g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); - g_return_if_fail (GTK_IS_CELL_RENDERER (cell)); - g_return_if_fail (! gtk_tree_view_column_get_cell_info (tree_column, cell)); - - g_object_ref (cell); - gtk_object_sink (GTK_OBJECT (cell)); - - cell_info = g_new0 (GtkTreeViewColumnCellInfo, 1); - cell_info->cell = cell; - cell_info->expand = expand ? TRUE : FALSE; - cell_info->pack = GTK_PACK_END; - cell_info->has_focus = 0; - cell_info->attributes = NULL; - - tree_column->cell_list = g_list_append (tree_column->cell_list, cell_info); + gtk_cell_layout_pack_end (GTK_CELL_LAYOUT (tree_column), cell, expand); } - /** * gtk_tree_view_column_clear: * @tree_column: A #GtkTreeViewColumn @@ -1309,20 +1539,7 @@ gtk_tree_view_column_pack_end (GtkTreeViewColumn *tree_column, void gtk_tree_view_column_clear (GtkTreeViewColumn *tree_column) { - GList *list; - g_return_if_fail (tree_column != NULL); - - for (list = tree_column->cell_list; list; list = list->next) - { - GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *)list->data; - - gtk_tree_view_column_clear_attributes (tree_column, info->cell); - g_object_unref (info->cell); - g_free (info); - } - - g_list_free (tree_column->cell_list); - tree_column->cell_list = NULL; + gtk_cell_layout_clear (GTK_CELL_LAYOUT (tree_column)); } /** @@ -1371,18 +1588,8 @@ gtk_tree_view_column_add_attribute (GtkTreeViewColumn *tree_column, const gchar *attribute, gint column) { - GtkTreeViewColumnCellInfo *info; - - g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); - info = gtk_tree_view_column_get_cell_info (tree_column, cell_renderer); - g_return_if_fail (info != NULL); - - info->attributes = g_slist_prepend (info->attributes, GINT_TO_POINTER (column)); - info->attributes = g_slist_prepend (info->attributes, g_strdup (attribute)); - - if (tree_column->tree_view) - _gtk_tree_view_column_cell_set_dirty (tree_column, TRUE); - + gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (tree_column), + cell_renderer, attribute, column); } static void @@ -1454,28 +1661,10 @@ gtk_tree_view_column_set_cell_data_func (GtkTreeViewColumn *tree_column, gpointer func_data, GtkDestroyNotify destroy) { - GtkTreeViewColumnCellInfo *info; - - g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); - g_return_if_fail (GTK_IS_CELL_RENDERER (cell_renderer)); - info = gtk_tree_view_column_get_cell_info (tree_column, cell_renderer); - - g_return_if_fail (info != NULL); - - if (info->destroy) - { - GtkDestroyNotify d = info->destroy; - - info->destroy = NULL; - d (info->func_data); - } - - info->func = func; - info->func_data = func_data; - info->destroy = destroy; - - if (tree_column->tree_view) - _gtk_tree_view_column_cell_set_dirty (tree_column, TRUE); + gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (tree_column), + cell_renderer, + (GtkCellLayoutDataFunc)func, + func_data, destroy); } @@ -1491,37 +1680,10 @@ void gtk_tree_view_column_clear_attributes (GtkTreeViewColumn *tree_column, GtkCellRenderer *cell_renderer) { - GtkTreeViewColumnCellInfo *info; - - g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); - g_return_if_fail (GTK_IS_CELL_RENDERER (cell_renderer)); - - info = gtk_tree_view_column_get_cell_info (tree_column, cell_renderer); - - gtk_tree_view_column_clear_attributes_by_info (tree_column, info); + gtk_cell_layout_clear_attributes (GTK_CELL_LAYOUT (tree_column), + cell_renderer); } -static void -gtk_tree_view_column_clear_attributes_by_info (GtkTreeViewColumn *tree_column, - GtkTreeViewColumnCellInfo *info) -{ - GSList *list; - - list = info->attributes; - - while (list && list->next) - { - g_free (list->data); - list = list->next->next; - } - g_slist_free (info->attributes); - info->attributes = NULL; - - if (tree_column->tree_view) - _gtk_tree_view_column_cell_set_dirty (tree_column, TRUE); -} - - /** * gtk_tree_view_column_set_spacing: * @tree_column: A #GtkTreeViewColumn. @@ -1613,7 +1775,7 @@ gtk_tree_view_column_get_visible (GtkTreeViewColumn *tree_column) * @resizable: %TRUE, if the column can be resized * * If @resizable is %TRUE, then the user can explicitly resize the column by - * grabbing the outer edge of the column button. If resizable is TRUE and + * grabbing the outer edge of the column button. If resizable is %TRUE and * sizing mode of the column is #GTK_TREE_VIEW_COLUMN_AUTOSIZE, then the sizing * mode is changed to #GTK_TREE_VIEW_COLUMN_GROW_ONLY. **/ @@ -1742,6 +1904,7 @@ gtk_tree_view_column_set_fixed_width (GtkTreeViewColumn *tree_column, g_return_if_fail (fixed_width > 0); tree_column->fixed_width = fixed_width; + tree_column->use_resized_width = FALSE; if (tree_column->tree_view && GTK_WIDGET_REALIZED (tree_column->tree_view) && @@ -1918,13 +2081,13 @@ void gtk_tree_view_column_set_title (GtkTreeViewColumn *tree_column, const gchar *title) { + gchar *new_title; + g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); + new_title = g_strdup (title); g_free (tree_column->title); - if (title) - tree_column->title = g_strdup (title); - else - tree_column->title = NULL; + tree_column->title = new_title; gtk_tree_view_column_update_button (tree_column); g_object_notify (G_OBJECT (tree_column), "title"); @@ -2355,7 +2518,6 @@ gtk_tree_view_column_cell_set_cell_data (GtkTreeViewColumn *tree_column, GList *cell_list; g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); - g_return_if_fail (tree_column->cell_list != NULL); if (tree_model == NULL) return; @@ -2368,7 +2530,12 @@ gtk_tree_view_column_cell_set_cell_data (GtkTreeViewColumn *tree_column, list = info->attributes; g_object_freeze_notify (cell); - g_object_set (cell, "is_expander", is_expander, "is_expanded", is_expanded, NULL); + + if (info->cell->is_expander != is_expander) + g_object_set (cell, "is_expander", is_expander, NULL); + + if (info->cell->is_expanded != is_expanded) + g_object_set (cell, "is_expanded", is_expanded, NULL); while (list && list->next) { @@ -2431,7 +2598,7 @@ gtk_tree_view_column_cell_get_size (GtkTreeViewColumn *tree_column, if (visible == FALSE) continue; - if (first_cell == FALSE && *width) + if (first_cell == FALSE && width) *width += tree_column->spacing; gtk_cell_renderer_get_size (info->cell, @@ -2477,6 +2644,7 @@ gtk_tree_view_column_cell_process_action (GtkTreeViewColumn *tree_column, GList *list; GdkRectangle real_cell_area; GdkRectangle real_background_area; + GdkRectangle real_expose_area = *cell_area; gint expand_cell_count = 0; gint full_requested_width = 0; gint extra_space; @@ -2526,7 +2694,7 @@ gtk_tree_view_column_cell_process_action (GtkTreeViewColumn *tree_column, gtk_widget_style_get (GTK_WIDGET (tree_column->tree_view), "focus-line-width", &focus_line_width, - "horizontal-seperator", &horizontal_separator, + "horizontal-separator", &horizontal_separator, NULL); real_cell_area = *cell_area; @@ -2534,7 +2702,7 @@ gtk_tree_view_column_cell_process_action (GtkTreeViewColumn *tree_column, real_cell_area.x += focus_line_width; - /* Find out how many extra space we have to allocate */ + /* Find out how much extra space we have to allocate */ for (list = tree_column->cell_list; list; list = list->next) { GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *)list->data; @@ -2593,7 +2761,7 @@ gtk_tree_view_column_cell_process_action (GtkTreeViewColumn *tree_column, tree_column->tree_view, &rtl_background_area, &rtl_cell_area, - expose_area, + &real_expose_area, flags); } @@ -2670,8 +2838,8 @@ gtk_tree_view_column_cell_process_action (GtkTreeViewColumn *tree_column, event, tree_column->tree_view, path_string, - background_area, - cell_area, + &rtl_background_area, + &rtl_cell_area, flags)) { flags &= ~GTK_CELL_RENDERER_FOCUSED; @@ -2685,8 +2853,8 @@ gtk_tree_view_column_cell_process_action (GtkTreeViewColumn *tree_column, event, tree_column->tree_view, path_string, - background_area, - cell_area, + &rtl_background_area, + &rtl_cell_area, flags); if (*editable_widget != NULL) @@ -2748,7 +2916,7 @@ gtk_tree_view_column_cell_process_action (GtkTreeViewColumn *tree_column, tree_column->tree_view, &rtl_background_area, &rtl_cell_area, - expose_area, + &real_expose_area, flags); } /* FOCUS */ @@ -2824,8 +2992,8 @@ gtk_tree_view_column_cell_process_action (GtkTreeViewColumn *tree_column, event, tree_column->tree_view, path_string, - background_area, - cell_area, + &rtl_background_area, + &rtl_cell_area, flags)) { flags &= ~GTK_CELL_RENDERER_FOCUSED; @@ -2839,8 +3007,8 @@ gtk_tree_view_column_cell_process_action (GtkTreeViewColumn *tree_column, event, tree_column->tree_view, path_string, - background_area, - cell_area, + &rtl_background_area, + &rtl_cell_area, flags); if (*editable_widget != NULL) @@ -3206,7 +3374,7 @@ _gtk_tree_view_column_cell_draw_focus (GtkTreeViewColumn *tree_column, gtk_paint_focus (tree_column->tree_view->style, window, cell_state, - NULL, + cell_area, tree_column->tree_view, "treeview", focus_rectangle.x, @@ -3349,10 +3517,22 @@ _gtk_tree_view_column_get_neighbor_sizes (GtkTreeViewColumn *column, gint *right) { GList *list; + gint *rtl_left, *rtl_right; + + if (gtk_widget_get_direction (GTK_WIDGET (column->tree_view)) == GTK_TEXT_DIR_RTL) + { + rtl_left = right; + rtl_right = left; + } + else + { + rtl_left = left; + rtl_right = right; + } - if (left) + if (rtl_left) { - *left = 0; + *rtl_left = 0; list = gtk_tree_view_column_cell_first (column); for (; list; list = gtk_tree_view_column_cell_next (column, list)) @@ -3364,15 +3544,15 @@ _gtk_tree_view_column_get_neighbor_sizes (GtkTreeViewColumn *column, break; if (info->cell->visible) - *left += info->real_width; + *rtl_left += info->real_width; } } - if (right) + if (rtl_right) { GList *next; - *right = 0; + *rtl_right = 0; list = gtk_tree_view_column_cell_first (column); for (; list; list = gtk_tree_view_column_cell_next (column, list)) @@ -3395,7 +3575,7 @@ _gtk_tree_view_column_get_neighbor_sizes (GtkTreeViewColumn *column, (GtkTreeViewColumnCellInfo *)list->data; if (info->cell->visible) - *right += info->real_width; + *rtl_right += info->real_width; } } }