From 4a9a6249d0c88c9ac829e6ac9eca0117fe01212d Mon Sep 17 00:00:00 2001 From: Jonathan Blandford Date: Sat, 8 Sep 2001 00:56:30 +0000 Subject: [PATCH] Removed 'fill' attribute. It was silly b/c that was a property of the cell Fri Sep 7 20:45:29 2001 Jonathan Blandford * gtk/gtktreeviewcolumn.c (gtk_tree_view_column_pack_{start,end}): Removed 'fill' attribute. It was silly b/c that was a property of the cell renderer, anyway. (gtk_tree_view_column_render): Actually render the packed renderers. * doc/tree-column-sizing.txt: initial devel documentation. * gtk/gtktreeview.c (gtk_tree_view_expand_all): Fix bug. * gtk/gtkcellrenderertextpixbuf.[ch]: removed. * tests/testtreefocus.c: fix up to reflect above changes. * tests/testtreeview.c: ditto * demos/gtk-demo/stock_browser.c: ditto --- ChangeLog | 15 ++ ChangeLog.pre-2-0 | 15 ++ ChangeLog.pre-2-10 | 15 ++ ChangeLog.pre-2-2 | 15 ++ ChangeLog.pre-2-4 | 15 ++ ChangeLog.pre-2-6 | 15 ++ ChangeLog.pre-2-8 | 15 ++ demos/gtk-demo/stock_browser.c | 58 ++++- docs/tree-column-sizing.txt | 67 +++++ gtk/Makefile.am | 2 - gtk/gtkcellrenderertextpixbuf.c | 443 -------------------------------- gtk/gtkcellrenderertextpixbuf.h | 62 ----- gtk/gtkrbtree.h | 2 + gtk/gtktreeview.c | 187 +++++++++----- gtk/gtktreeviewcolumn.c | 409 +++++++++++++++++++++-------- gtk/gtktreeviewcolumn.h | 20 +- tests/testtreefocus.c | 10 +- tests/testtreeview.c | 14 +- 18 files changed, 666 insertions(+), 713 deletions(-) create mode 100644 docs/tree-column-sizing.txt delete mode 100644 gtk/gtkcellrenderertextpixbuf.c delete mode 100644 gtk/gtkcellrenderertextpixbuf.h diff --git a/ChangeLog b/ChangeLog index d366c7711b..22ccf4b7c9 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,18 @@ +Fri Sep 7 20:45:29 2001 Jonathan Blandford + + * gtk/gtktreeviewcolumn.c (gtk_tree_view_column_pack_{start,end}): + Removed 'fill' attribute. It was silly b/c that was a property of + the cell renderer, anyway. + (gtk_tree_view_column_render): Actually render the packed + renderers. + * doc/tree-column-sizing.txt: initial devel documentation. + * gtk/gtktreeview.c (gtk_tree_view_expand_all): Fix bug. + * gtk/gtkcellrenderertextpixbuf.[ch]: removed. + + * tests/testtreefocus.c: fix up to reflect above changes. + * tests/testtreeview.c: ditto + * demos/gtk-demo/stock_browser.c: ditto + 2001-09-07 Alex Larsson * gdk/linux-fb/gdkcolor-fb.c: diff --git a/ChangeLog.pre-2-0 b/ChangeLog.pre-2-0 index d366c7711b..22ccf4b7c9 100644 --- a/ChangeLog.pre-2-0 +++ b/ChangeLog.pre-2-0 @@ -1,3 +1,18 @@ +Fri Sep 7 20:45:29 2001 Jonathan Blandford + + * gtk/gtktreeviewcolumn.c (gtk_tree_view_column_pack_{start,end}): + Removed 'fill' attribute. It was silly b/c that was a property of + the cell renderer, anyway. + (gtk_tree_view_column_render): Actually render the packed + renderers. + * doc/tree-column-sizing.txt: initial devel documentation. + * gtk/gtktreeview.c (gtk_tree_view_expand_all): Fix bug. + * gtk/gtkcellrenderertextpixbuf.[ch]: removed. + + * tests/testtreefocus.c: fix up to reflect above changes. + * tests/testtreeview.c: ditto + * demos/gtk-demo/stock_browser.c: ditto + 2001-09-07 Alex Larsson * gdk/linux-fb/gdkcolor-fb.c: diff --git a/ChangeLog.pre-2-10 b/ChangeLog.pre-2-10 index d366c7711b..22ccf4b7c9 100644 --- a/ChangeLog.pre-2-10 +++ b/ChangeLog.pre-2-10 @@ -1,3 +1,18 @@ +Fri Sep 7 20:45:29 2001 Jonathan Blandford + + * gtk/gtktreeviewcolumn.c (gtk_tree_view_column_pack_{start,end}): + Removed 'fill' attribute. It was silly b/c that was a property of + the cell renderer, anyway. + (gtk_tree_view_column_render): Actually render the packed + renderers. + * doc/tree-column-sizing.txt: initial devel documentation. + * gtk/gtktreeview.c (gtk_tree_view_expand_all): Fix bug. + * gtk/gtkcellrenderertextpixbuf.[ch]: removed. + + * tests/testtreefocus.c: fix up to reflect above changes. + * tests/testtreeview.c: ditto + * demos/gtk-demo/stock_browser.c: ditto + 2001-09-07 Alex Larsson * gdk/linux-fb/gdkcolor-fb.c: diff --git a/ChangeLog.pre-2-2 b/ChangeLog.pre-2-2 index d366c7711b..22ccf4b7c9 100644 --- a/ChangeLog.pre-2-2 +++ b/ChangeLog.pre-2-2 @@ -1,3 +1,18 @@ +Fri Sep 7 20:45:29 2001 Jonathan Blandford + + * gtk/gtktreeviewcolumn.c (gtk_tree_view_column_pack_{start,end}): + Removed 'fill' attribute. It was silly b/c that was a property of + the cell renderer, anyway. + (gtk_tree_view_column_render): Actually render the packed + renderers. + * doc/tree-column-sizing.txt: initial devel documentation. + * gtk/gtktreeview.c (gtk_tree_view_expand_all): Fix bug. + * gtk/gtkcellrenderertextpixbuf.[ch]: removed. + + * tests/testtreefocus.c: fix up to reflect above changes. + * tests/testtreeview.c: ditto + * demos/gtk-demo/stock_browser.c: ditto + 2001-09-07 Alex Larsson * gdk/linux-fb/gdkcolor-fb.c: diff --git a/ChangeLog.pre-2-4 b/ChangeLog.pre-2-4 index d366c7711b..22ccf4b7c9 100644 --- a/ChangeLog.pre-2-4 +++ b/ChangeLog.pre-2-4 @@ -1,3 +1,18 @@ +Fri Sep 7 20:45:29 2001 Jonathan Blandford + + * gtk/gtktreeviewcolumn.c (gtk_tree_view_column_pack_{start,end}): + Removed 'fill' attribute. It was silly b/c that was a property of + the cell renderer, anyway. + (gtk_tree_view_column_render): Actually render the packed + renderers. + * doc/tree-column-sizing.txt: initial devel documentation. + * gtk/gtktreeview.c (gtk_tree_view_expand_all): Fix bug. + * gtk/gtkcellrenderertextpixbuf.[ch]: removed. + + * tests/testtreefocus.c: fix up to reflect above changes. + * tests/testtreeview.c: ditto + * demos/gtk-demo/stock_browser.c: ditto + 2001-09-07 Alex Larsson * gdk/linux-fb/gdkcolor-fb.c: diff --git a/ChangeLog.pre-2-6 b/ChangeLog.pre-2-6 index d366c7711b..22ccf4b7c9 100644 --- a/ChangeLog.pre-2-6 +++ b/ChangeLog.pre-2-6 @@ -1,3 +1,18 @@ +Fri Sep 7 20:45:29 2001 Jonathan Blandford + + * gtk/gtktreeviewcolumn.c (gtk_tree_view_column_pack_{start,end}): + Removed 'fill' attribute. It was silly b/c that was a property of + the cell renderer, anyway. + (gtk_tree_view_column_render): Actually render the packed + renderers. + * doc/tree-column-sizing.txt: initial devel documentation. + * gtk/gtktreeview.c (gtk_tree_view_expand_all): Fix bug. + * gtk/gtkcellrenderertextpixbuf.[ch]: removed. + + * tests/testtreefocus.c: fix up to reflect above changes. + * tests/testtreeview.c: ditto + * demos/gtk-demo/stock_browser.c: ditto + 2001-09-07 Alex Larsson * gdk/linux-fb/gdkcolor-fb.c: diff --git a/ChangeLog.pre-2-8 b/ChangeLog.pre-2-8 index d366c7711b..22ccf4b7c9 100644 --- a/ChangeLog.pre-2-8 +++ b/ChangeLog.pre-2-8 @@ -1,3 +1,18 @@ +Fri Sep 7 20:45:29 2001 Jonathan Blandford + + * gtk/gtktreeviewcolumn.c (gtk_tree_view_column_pack_{start,end}): + Removed 'fill' attribute. It was silly b/c that was a property of + the cell renderer, anyway. + (gtk_tree_view_column_render): Actually render the packed + renderers. + * doc/tree-column-sizing.txt: initial devel documentation. + * gtk/gtktreeview.c (gtk_tree_view_expand_all): Fix bug. + * gtk/gtkcellrenderertextpixbuf.[ch]: removed. + + * tests/testtreefocus.c: fix up to reflect above changes. + * tests/testtreeview.c: ditto + * demos/gtk-demo/stock_browser.c: ditto + 2001-09-07 Alex Larsson * gdk/linux-fb/gdkcolor-fb.c: diff --git a/demos/gtk-demo/stock_browser.c b/demos/gtk-demo/stock_browser.c index 945d3ef335..2a68f1a02a 100644 --- a/demos/gtk-demo/stock_browser.c +++ b/demos/gtk-demo/stock_browser.c @@ -304,11 +304,11 @@ selection_changed (GtkTreeSelection *selection) } static void -macro_set_func (GtkTreeViewColumn *tree_column, - GtkCellRenderer *cell, - GtkTreeModel *model, - GtkTreeIter *iter, - gpointer data) +macro_set_func_text (GtkTreeViewColumn *tree_column, + GtkCellRenderer *cell, + GtkTreeModel *model, + GtkTreeIter *iter, + gpointer data) { StockItemInfo *info; @@ -318,6 +318,25 @@ macro_set_func (GtkTreeViewColumn *tree_column, g_object_set (GTK_CELL_RENDERER (cell), "text", info->macro, + NULL); + + stock_item_info_free (info); +} + +static void +macro_set_func_pixbuf (GtkTreeViewColumn *tree_column, + GtkCellRenderer *cell, + GtkTreeModel *model, + GtkTreeIter *iter, + gpointer data) +{ + StockItemInfo *info; + + gtk_tree_model_get (model, iter, + 0, &info, + -1); + + g_object_set (GTK_CELL_RENDERER (cell), "pixbuf", info->small_icon, NULL); @@ -399,7 +418,8 @@ do_stock_browser (void) GtkCellRenderer *cell_renderer; StockItemDisplay *display; GtkTreeSelection *selection; - + GtkTreeViewColumn *column; + window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "Stock Icons and Items"); @@ -423,15 +443,25 @@ do_stock_browser (void) gtk_container_add (GTK_CONTAINER (sw), treeview); - cell_renderer = gtk_cell_renderer_text_pixbuf_new (); + column = gtk_tree_view_column_new (); + gtk_tree_view_column_set_title (column, "Macro"); + + cell_renderer = gtk_cell_renderer_pixbuf_new (); + gtk_tree_view_column_pack_start (column, + cell_renderer, + FALSE); + gtk_tree_view_column_set_cell_data_func (column, cell_renderer, + macro_set_func_pixbuf, NULL, NULL); + cell_renderer = gtk_cell_renderer_text_new (); + gtk_tree_view_column_pack_start (column, + cell_renderer, + TRUE); + gtk_tree_view_column_set_cell_data_func (column, cell_renderer, + macro_set_func_text, NULL, NULL); + + gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), + column); - gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (treeview), - -1, - "Macro", - cell_renderer, - macro_set_func, - NULL, - NULL); cell_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (treeview), diff --git a/docs/tree-column-sizing.txt b/docs/tree-column-sizing.txt new file mode 100644 index 0000000000..367755fe53 --- /dev/null +++ b/docs/tree-column-sizing.txt @@ -0,0 +1,67 @@ +The way that the GtkTreeView calculates sizing is pretty confusing. +This is written down to help keep track of it in my head, and thus help +anyone who hopes to work with the code in the future. + +HOW THE GTKTREEVIEW CALCULATES SIZE: +==================================== +When the view is given a new model, the first thing it does is walk +through the model at the top level, creating an GtkRBNode for each +element of the model. Each node has a height of 0. The RBTree is kept +updated as the models structure changes. Additionally, the user can +expand, collapse, and select rows at this stage. The RBTree is accurate +-- it just doesn't have a height for any row. + +When the TreeView is realized, it calculates the actual height of each +row by walking the tree and measuring them. While doing so, it gets the +size of each column. + + + +Columns are initially marked as 'dirty'. When sized, +gtk_tree_view_check_dirty_and_clean () is called on each column. This +function walks through all visible columns, and sees if they're dirty or +not. If any are dirty, it then walks the tree, calling +gtk_tree_view_calc_size on each row. gtk_tree_view_calc_size requests +the size of every dirty column in the tree. Finally, it updates the +size of the widget (including adjustments). + + +HOW THE GTKTREEVIEWCOLUMN STORES SIZE: +====================================== + +There are a number of size related fields in the GtkTreeViewColumn +structure: + + sizing The sizing method to use when calculating the size + of the column. Can be grow_only, resizable, auto, and fixed. + + requested_width The width of the column as requested by the column + + width The actual width. This is requested width for all + columns but possibly the last one. + + fixed_width The requested fixed width for the column iff it's + sizing type is set to GTK_TREE_VIEW_COLUMN_FIXED. + + min_width The minimum width the column can be + + max_width The maximum width the column can be. This can be + overridden for the last column, if the tree_view is + actually wider than the sum of all of the columns + requested_widths. + +The following invariants are true: + +min_width is less than or equal to width + +max_width is greater than or equal to width + +(sizing == GTK_TREE_VIEW_COLUMN_FIXED) => (requested_width == fixed_width) + +(column != last visible column) => width == requested_width + + +/* Functions needed by gtktreeview for gtktreeviewcolumn */ +size_request_button +set_width (for resizing resizable columns) +calculate_width diff --git a/gtk/Makefile.am b/gtk/Makefile.am index b4124e6a64..42ebc87561 100644 --- a/gtk/Makefile.am +++ b/gtk/Makefile.am @@ -69,7 +69,6 @@ gtk_public_h_sources = @STRIP_BEGIN@ \ gtkcurve.h \ gtkcellrenderer.h \ gtkcellrenderertext.h \ - gtkcellrenderertextpixbuf.h \ gtkcellrenderertoggle.h \ gtkcellrendererpixbuf.h \ gtkdebug.h \ @@ -216,7 +215,6 @@ gtk_c_sources = @STRIP_BEGIN@ \ gtkcalendar.c \ gtkcellrenderer.c \ gtkcellrenderertext.c \ - gtkcellrenderertextpixbuf.c \ gtkcellrenderertoggle.c \ gtkcellrendererpixbuf.c \ gtkcheckbutton.c \ diff --git a/gtk/gtkcellrenderertextpixbuf.c b/gtk/gtkcellrenderertextpixbuf.c deleted file mode 100644 index c003f4e567..0000000000 --- a/gtk/gtkcellrenderertextpixbuf.c +++ /dev/null @@ -1,443 +0,0 @@ -/* gtkcellrenderertextpixbuf.c - * Copyright (C) 2000 Red Hat, Inc., Jonathan Blandford - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Library General Public - * License as published by the Free Software Foundation; either - * version 2 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Library General Public License for more details. - * - * You should have received a copy of the GNU Library General Public - * License along with this library; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. - */ - -#include -#include "gtkcellrenderertextpixbuf.h" -#include "gtkintl.h" - -enum { - PROP_ZERO, - PROP_PIXBUF_POS, - PROP_PIXBUF, - PROP_PIXBUF_XALIGN, - PROP_PIXBUF_YALIGN, - PROP_PIXBUF_XPAD, - PROP_PIXBUF_YPAD -}; - - -static void gtk_cell_renderer_text_pixbuf_get_property (GObject *object, - guint param_id, - GValue *value, - GParamSpec *pspec); -static void gtk_cell_renderer_text_pixbuf_set_property (GObject *object, - guint param_id, - const GValue *value, - GParamSpec *pspec); -static void gtk_cell_renderer_text_pixbuf_init (GtkCellRendererTextPixbuf *celltextpixbuf); -static void gtk_cell_renderer_text_pixbuf_class_init (GtkCellRendererTextPixbufClass *class); -static void gtk_cell_renderer_text_pixbuf_get_size (GtkCellRenderer *cell, - GtkWidget *view, - GdkRectangle *cell_area, - gint *x_offset, - gint *y_offset, - gint *width, - gint *height); -static void gtk_cell_renderer_text_pixbuf_render (GtkCellRenderer *cell, - GdkWindow *window, - GtkWidget *view, - GdkRectangle *background_area, - GdkRectangle *cell_area, - GdkRectangle *expose_area, - guint flags); - - -static GtkCellRendererTextClass *parent_class = NULL; - - -GtkType -gtk_cell_renderer_text_pixbuf_get_type (void) -{ - static GtkType cell_text_pixbuf_type = 0; - - if (!cell_text_pixbuf_type) - { - static const GTypeInfo cell_text_pixbuf_info = - { - sizeof (GtkCellRendererTextPixbufClass), - NULL, /* base_init */ - NULL, /* base_finalize */ - (GClassInitFunc) gtk_cell_renderer_text_pixbuf_class_init, - NULL, /* class_finalize */ - NULL, /* class_data */ - sizeof (GtkCellRendererTextPixbuf), - 0, /* n_preallocs */ - (GInstanceInitFunc) gtk_cell_renderer_text_pixbuf_init, - }; - - cell_text_pixbuf_type = g_type_register_static (GTK_TYPE_CELL_RENDERER_TEXT, "GtkCellRendererTextPixbuf", &cell_text_pixbuf_info, 0); - } - - return cell_text_pixbuf_type; -} - -static void -gtk_cell_renderer_text_pixbuf_init (GtkCellRendererTextPixbuf *celltextpixbuf) -{ - celltextpixbuf->pixbuf = GTK_CELL_RENDERER_PIXBUF (gtk_cell_renderer_pixbuf_new ()); - celltextpixbuf->pixbuf_pos = GTK_POS_LEFT; -} - -static void -gtk_cell_renderer_text_pixbuf_class_init (GtkCellRendererTextPixbufClass *class) -{ - GObjectClass *object_class = G_OBJECT_CLASS (class); - GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS (class); - - parent_class = g_type_class_peek_parent (class); - - object_class->get_property = gtk_cell_renderer_text_pixbuf_get_property; - object_class->set_property = gtk_cell_renderer_text_pixbuf_set_property; - - cell_class->get_size = gtk_cell_renderer_text_pixbuf_get_size; - cell_class->render = gtk_cell_renderer_text_pixbuf_render; - - g_object_class_install_property (object_class, - PROP_PIXBUF_POS, - g_param_spec_int ("pixbuf_pos", - _("Pixbuf location"), - _("The relative location of the pixbuf to the text."), - GTK_POS_LEFT, - GTK_POS_BOTTOM, - GTK_POS_LEFT, - G_PARAM_READABLE | - G_PARAM_WRITABLE)); - - g_object_class_install_property (object_class, - PROP_PIXBUF, - g_param_spec_object ("pixbuf", - _("Pixbuf Object"), - _("The pixbuf to render."), - GDK_TYPE_PIXBUF, - G_PARAM_READABLE | - G_PARAM_WRITABLE)); - - g_object_class_install_property (object_class, - PROP_PIXBUF_XALIGN, - g_param_spec_float ("pixbuf_xalign", - _("pixbuf xalign"), - _("The x-align of the pixbuf."), - 0.0, - 1.0, - 0.0, - G_PARAM_READABLE | - G_PARAM_WRITABLE)); - - g_object_class_install_property (object_class, - PROP_PIXBUF_YALIGN, - g_param_spec_float ("pixbuf_yalign", - _("pixbuf yalign"), - _("The y-align of the pixbuf."), - 0.0, - 1.0, - 0.5, - G_PARAM_READABLE | - G_PARAM_WRITABLE)); - - g_object_class_install_property (object_class, - PROP_PIXBUF_XPAD, - g_param_spec_uint ("pixbuf_xpad", - _("pixbuf xpad"), - _("The xpad of the pixbuf."), - 0, - 100, - 2, - G_PARAM_READABLE | - G_PARAM_WRITABLE)); - - g_object_class_install_property (object_class, - PROP_PIXBUF_YPAD, - g_param_spec_uint ("pixbuf_ypad", - _("pixbuf ypad"), - _("The ypad of the pixbuf."), - 0, - 100, - 2, - G_PARAM_READABLE | - G_PARAM_WRITABLE)); -} - -static void -gtk_cell_renderer_text_pixbuf_get_property (GObject *object, - guint param_id, - GValue *value, - GParamSpec *pspec) -{ - GtkCellRendererTextPixbuf *celltextpixbuf = GTK_CELL_RENDERER_TEXT_PIXBUF (object); - - switch (param_id) - { - case PROP_PIXBUF_POS: - g_value_set_int (value, celltextpixbuf->pixbuf_pos); - break; - case PROP_PIXBUF: - g_object_get_property (G_OBJECT (celltextpixbuf->pixbuf), - "pixbuf", - value); - break; - case PROP_PIXBUF_XALIGN: - g_object_get_property (G_OBJECT (celltextpixbuf->pixbuf), - "xalign", - value); - break; - case PROP_PIXBUF_YALIGN: - g_object_get_property (G_OBJECT (celltextpixbuf->pixbuf), - "yalign", - value); - break; - case PROP_PIXBUF_XPAD: - g_object_get_property (G_OBJECT (celltextpixbuf->pixbuf), - "xpad", - value); - break; - case PROP_PIXBUF_YPAD: - g_object_get_property (G_OBJECT (celltextpixbuf->pixbuf), - "ypad", - value); - break; - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec); - break; - } -} - -static void -gtk_cell_renderer_text_pixbuf_set_property (GObject *object, - guint param_id, - const GValue *value, - GParamSpec *pspec) -{ - GtkCellRendererTextPixbuf *celltextpixbuf = GTK_CELL_RENDERER_TEXT_PIXBUF (object); - - switch (param_id) - { - case PROP_PIXBUF: - g_object_set_property (G_OBJECT (celltextpixbuf->pixbuf), - "pixbuf", - value); - g_object_notify (G_OBJECT(object), "pixbuf"); - break; - case PROP_PIXBUF_POS: - celltextpixbuf->pixbuf_pos = g_value_get_int (value); - g_object_notify (G_OBJECT(object), "pixbuf_pos"); - break; - case PROP_PIXBUF_XALIGN: - g_object_set_property (G_OBJECT (celltextpixbuf->pixbuf), - "xalign", - value); - g_object_notify (G_OBJECT(object), "pixbuf_xalign"); - break; - case PROP_PIXBUF_YALIGN: - g_object_set_property (G_OBJECT (celltextpixbuf->pixbuf), - "yalign", - value); - g_object_notify (G_OBJECT(object), "pixbuf_yalign"); - break; - case PROP_PIXBUF_XPAD: - g_object_set_property (G_OBJECT (celltextpixbuf->pixbuf), - "xpad", - value); - g_object_notify (G_OBJECT(object), "pixbuf_xpad"); - break; - case PROP_PIXBUF_YPAD: - g_object_set_property (G_OBJECT (celltextpixbuf->pixbuf), - "ypad", - value); - g_object_notify (G_OBJECT(object), "pixbuf_ypad"); - break; - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec); - break; - } -} - -/** - * gtk_cell_renderer_text_pixbuf_new: - * - * Creates a new #GtkCellRendererTextPixbuf. Adjust rendering - * parameters using object properties. Object properties can be set - * globally (with g_object_set()). Also, with #GtkTreeViewColumn, you - * can bind a property to a value in a #GtkTreeModel. For example, you - * can bind the "text" property on the cell renderer to a string value - * in the model, thus rendering a different string in each row of the - * #GtkTreeView - * - * Return value: the new cell renderer - **/ -GtkCellRenderer * -gtk_cell_renderer_text_pixbuf_new (void) -{ - return GTK_CELL_RENDERER (gtk_type_new (gtk_cell_renderer_text_pixbuf_get_type ())); -} - -typedef void (* CellSizeFunc) (GtkCellRenderer *cell, - GtkWidget *widget, - GdkRectangle *rectangle, - gint *x_offset, - gint *y_offset, - gint *width, - gint *height); -typedef void (* CellRenderFunc) (GtkCellRenderer *cell, - GdkWindow *window, - GtkWidget *widget, - GdkRectangle *background_area, - GdkRectangle *cell_area, - GdkRectangle *expose_area, - guint flags); - -static void -gtk_cell_renderer_text_pixbuf_get_size (GtkCellRenderer *cell, - GtkWidget *widget, - GdkRectangle *cell_area, - gint *x_offset, - gint *y_offset, - gint *width, - gint *height) -{ - GtkCellRendererTextPixbuf *celltextpixbuf = (GtkCellRendererTextPixbuf *)cell; - gint pixbuf_width; - gint pixbuf_height; - gint text_width; - gint text_height; - gint calc_width; - gint calc_height; - - (* GTK_CELL_RENDERER_CLASS (parent_class)->get_size) (cell, widget, NULL, NULL, NULL, &text_width, &text_height); - (* GTK_CELL_RENDERER_CLASS (G_OBJECT_GET_CLASS (celltextpixbuf->pixbuf))->get_size) (GTK_CELL_RENDERER (celltextpixbuf->pixbuf), - widget, - NULL, NULL, NULL, - &pixbuf_width, - &pixbuf_height); - if (celltextpixbuf->pixbuf_pos == GTK_POS_LEFT || - celltextpixbuf->pixbuf_pos == GTK_POS_RIGHT) - { - calc_width = pixbuf_width + text_width; - calc_height = MAX (pixbuf_height, text_height); - } - else - { - calc_width = MAX (pixbuf_width, text_width); - calc_height = pixbuf_height + text_height; - } - - if (width) - *width = calc_width; - if (height) - *height = calc_height; - - if (cell_area) - { - if (x_offset) - { - *x_offset = cell->xalign * (cell_area->width - calc_width - (2 * cell->xpad)); - *x_offset = MAX (*x_offset, 0) + cell->xpad; - } - if (y_offset) - { - *y_offset = cell->yalign * (cell_area->height - calc_height - (2 * cell->ypad)); - *y_offset = MAX (*y_offset, 0) + cell->ypad; - } - } -} - -static void -gtk_cell_renderer_text_pixbuf_render (GtkCellRenderer *cell, - GdkWindow *window, - GtkWidget *widget, - GdkRectangle *background_area, - GdkRectangle *cell_area, - GdkRectangle *expose_area, - guint flags) - -{ - GtkCellRendererTextPixbuf *celltextpixbuf = (GtkCellRendererTextPixbuf *) cell; - CellSizeFunc size_func1, size_func2; - CellRenderFunc render_func1, render_func2; - GtkCellRenderer *cell1, *cell2; - gint tmp_width; - gint tmp_height; - GdkRectangle real_cell_area; - - if (celltextpixbuf->pixbuf_pos == GTK_POS_LEFT || - celltextpixbuf->pixbuf_pos == GTK_POS_TOP) - { - size_func1 = GTK_CELL_RENDERER_CLASS (G_OBJECT_GET_CLASS (celltextpixbuf->pixbuf))->get_size; - render_func1 = GTK_CELL_RENDERER_CLASS (G_OBJECT_GET_CLASS (celltextpixbuf->pixbuf))->render; - cell1 = GTK_CELL_RENDERER (celltextpixbuf->pixbuf); - - size_func2 = GTK_CELL_RENDERER_CLASS (parent_class)->get_size; - render_func2 = GTK_CELL_RENDERER_CLASS (parent_class)->render; - cell2 = cell; - } - else - { - size_func1 = GTK_CELL_RENDERER_CLASS (parent_class)->get_size; - render_func1 = GTK_CELL_RENDERER_CLASS (parent_class)->render; - cell1 = cell; - - size_func2 = GTK_CELL_RENDERER_CLASS (G_OBJECT_GET_CLASS (celltextpixbuf->pixbuf))->get_size; - render_func2 = GTK_CELL_RENDERER_CLASS (G_OBJECT_GET_CLASS (celltextpixbuf->pixbuf))->render; - cell2 = GTK_CELL_RENDERER (celltextpixbuf->pixbuf); - } - - (size_func1) (cell1, widget, NULL, NULL, NULL, &tmp_width, &tmp_height); - - real_cell_area.x = cell_area->x; - real_cell_area.y = cell_area->y; - - if (celltextpixbuf->pixbuf_pos == GTK_POS_LEFT || - celltextpixbuf->pixbuf_pos == GTK_POS_RIGHT) - { - real_cell_area.width = MIN (tmp_width, cell_area->width); - real_cell_area.height = cell_area->height; - } - else - { - real_cell_area.height = MIN (tmp_height, cell_area->height); - real_cell_area.width = cell_area->width; - } - - (render_func1) (cell1, - window, - widget, - background_area, - &real_cell_area, - expose_area, - flags); - - if (celltextpixbuf->pixbuf_pos == GTK_POS_LEFT || - celltextpixbuf->pixbuf_pos == GTK_POS_RIGHT) - { - real_cell_area.x = real_cell_area.x + real_cell_area.width; - real_cell_area.width = cell_area->width - real_cell_area.width; - } - else - { - real_cell_area.y = real_cell_area.y + real_cell_area.height; - real_cell_area.height = cell_area->height - real_cell_area.height; - } - - (render_func2 ) (cell2, - window, - widget, - background_area, - &real_cell_area, - expose_area, - flags); -} diff --git a/gtk/gtkcellrenderertextpixbuf.h b/gtk/gtkcellrenderertextpixbuf.h deleted file mode 100644 index d739a53612..0000000000 --- a/gtk/gtkcellrenderertextpixbuf.h +++ /dev/null @@ -1,62 +0,0 @@ -/* gtkcellrenderertextpixbuf.h - * Copyright (C) 2000 Red Hat, Inc., Jonathan Blandford - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Library General Public - * License as published by the Free Software Foundation; either - * version 2 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Library General Public License for more details. - * - * You should have received a copy of the GNU Library General Public - * License along with this library; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. - */ - -#ifndef __GTK_CELL_RENDERER_TEXT_PIXBUF_H__ -#define __GTK_CELL_RENDERER_TEXT_PIXBUF_H__ - -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -#define GTK_TYPE_CELL_RENDERER_TEXT_PIXBUF (gtk_cell_renderer_text_pixbuf_get_type ()) -#define GTK_CELL_RENDERER_TEXT_PIXBUF(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_CELL_RENDERER_TEXT_PIXBUF, GtkCellRendererTextPixbuf)) -#define GTK_CELL_RENDERER_TEXT_PIXBUF_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_RENDERER_TEXT_PIXBUF, GtkCellRendererTextPixbufClass)) -#define GTK_IS_CELL_RENDERER_TEXT_PIXBUF(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_CELL_RENDERER_TEXT_PIXBUF)) -#define GTK_IS_CELL_RENDERER_TEXT_PIXBUF_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((obj), GTK_TYPE_CELL_RENDERER_TEXT_PIXBUF)) -#define GTK_CELL_RENDERER_TEXT_PIXBUF_GET_CLASS(obj) (GTK_CHECK_GET_CLASS ((obj), GTK_TYPE_CELL_RENDERER_TEXT_PIXBUF, GtkCellRendererTextPixbufClass)) - -typedef struct _GtkCellRendererTextPixbuf GtkCellRendererTextPixbuf; -typedef struct _GtkCellRendererTextPixbufClass GtkCellRendererTextPixbufClass; - -struct _GtkCellRendererTextPixbuf -{ - GtkCellRendererText parent; - - /*< private >*/ - GtkCellRendererPixbuf *pixbuf; - GtkPositionType pixbuf_pos; -}; - -struct _GtkCellRendererTextPixbufClass -{ - GtkCellRendererTextClass parent_class; -}; - -GtkType gtk_cell_renderer_text_pixbuf_get_type (void); -GtkCellRenderer *gtk_cell_renderer_text_pixbuf_new (void); - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - - -#endif /* __GTK_CELL_RENDERER_TEXT_PIXBUF_H__ */ diff --git a/gtk/gtkrbtree.h b/gtk/gtkrbtree.h index a218c3e628..356668fcfa 100644 --- a/gtk/gtkrbtree.h +++ b/gtk/gtkrbtree.h @@ -17,6 +17,8 @@ * Boston, MA 02111-1307, USA. */ +/* A Red-Black Tree implementation used specifically by GtkTreeView. + */ #ifndef __GTK_RBTREE_H__ #define __GTK_RBTREE_H__ diff --git a/gtk/gtktreeview.c b/gtk/gtktreeview.c index 2ed597fe57..dbb5523166 100644 --- a/gtk/gtktreeview.c +++ b/gtk/gtktreeview.c @@ -314,7 +314,7 @@ static void gtk_tree_view_discover_dirty (GtkTreeView GtkRBTree *tree, GtkTreeIter *iter, gint depth); -static void gtk_tree_view_check_dirty (GtkTreeView *tree_view); +static void gtk_tree_view_check_dirty_and_clean (GtkTreeView *tree_view); static void gtk_tree_view_clamp_node_visible (GtkTreeView *tree_view, GtkRBTree *tree, GtkRBNode *node); @@ -1126,7 +1126,7 @@ gtk_tree_view_realize (GtkWidget *widget) tree_view = GTK_TREE_VIEW (widget); - gtk_tree_view_check_dirty (GTK_TREE_VIEW (widget)); + gtk_tree_view_check_dirty_and_clean (GTK_TREE_VIEW (widget)); GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED); /* Make the main, clipping window */ @@ -1380,7 +1380,7 @@ gtk_tree_view_size_allocate_buttons (GtkWidget *widget) continue; allocation.x = width; - allocation.width = column->displayed_width; + allocation.width = column->width; width += column->width; gtk_widget_size_allocate (column->button, &allocation); @@ -1405,7 +1405,7 @@ gtk_tree_view_size_allocate (GtkWidget *widget, tree_view = GTK_TREE_VIEW (widget); - gtk_tree_view_check_dirty (tree_view); + gtk_tree_view_check_dirty_and_clean (tree_view); tmp_list = tree_view->priv->children; @@ -1547,7 +1547,7 @@ gtk_tree_view_button_press (GtkWidget *widget, if (!column->visible) continue; - background_area.width = column->displayed_width; + background_area.width = column->width; if (gtk_tree_view_is_expander_column (tree_view, column) && TREE_VIEW_DRAW_EXPANDERS(tree_view)) { @@ -2419,7 +2419,7 @@ gtk_tree_view_draw_focus (GtkWidget *widget) cell_area.x = tree_view->priv->focus_column->button->allocation.x; cell_area.y = y; - cell_area.width = tree_view->priv->focus_column->displayed_width; + cell_area.width = tree_view->priv->focus_column->width; cell_area.height = CELL_HEIGHT (node, vertical_separator); gtk_tree_view_column_cell_get_size (tree_view->priv->focus_column, @@ -2482,7 +2482,7 @@ gtk_tree_view_bin_expose (GtkWidget *widget, if (tree_view->priv->tree == NULL) return TRUE; - gtk_tree_view_check_dirty (GTK_TREE_VIEW (widget)); + gtk_tree_view_check_dirty_and_clean (GTK_TREE_VIEW (widget)); /* we want to account for a potential HEADER offset. * That is, if the header exists, we want to offset our event by its * height to find the right node. @@ -2572,9 +2572,9 @@ gtk_tree_view_bin_expose (GtkWidget *widget, continue; if (cell_offset > event->area.x + event->area.width || - cell_offset + column->displayed_width < event->area.x) + cell_offset + column->width < event->area.x) { - cell_offset += column->displayed_width; + cell_offset += column->width; continue; } @@ -2591,7 +2591,7 @@ gtk_tree_view_bin_expose (GtkWidget *widget, background_area.x = cell_offset; - background_area.width = column->displayed_width; + background_area.width = column->width; cell_area = background_area; cell_area.y += vertical_separator / 2; @@ -2697,7 +2697,7 @@ gtk_tree_view_bin_expose (GtkWidget *widget, &event->area, flags); } - cell_offset += column->displayed_width; + cell_offset += column->width; } if (node == cursor && GTK_WIDGET_HAS_FOCUS (widget)) @@ -4477,6 +4477,7 @@ gtk_tree_view_has_child_toggled (GtkTreeModel *model, if (GTK_TREE_VIEW_COLUMN (list->data)->visible) { GTK_TREE_VIEW_COLUMN (list->data)->dirty = TRUE; + gtk_tree_view_column_cell_set_dirty (GTK_TREE_VIEW_COLUMN (list->data)); break; } } @@ -4530,7 +4531,7 @@ gtk_tree_view_deleted (GtkTreeModel *model, for (list = tree_view->priv->columns; list; list = list->next) if (((GtkTreeViewColumn *)list->data)->visible && ((GtkTreeViewColumn *)list->data)->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE) - ((GtkTreeViewColumn *)list->data)->dirty = TRUE; + gtk_tree_view_column_cell_set_dirty ((GtkTreeViewColumn *)list->data); /* Ensure we don't have a dangling pointer to a dead node */ ensure_unprelighted (tree_view); @@ -4717,7 +4718,7 @@ gtk_tree_view_get_cell_xrange (GtkTreeView *tree_view, if (x2) { if (column->visible) - *x2 = total_width + column->displayed_width; + *x2 = total_width + column->width; else *x2 = total_width; /* width of 0 */ } @@ -4959,12 +4960,13 @@ gtk_tree_view_discover_dirty_iter (GtkTreeView *tree_view, NULL, NULL, NULL, &width, NULL); } + if (gtk_tree_view_is_expander_column (tree_view, column) && TREE_VIEW_DRAW_EXPANDERS (tree_view)) { if (depth * tree_view->priv->tab_offset + width > column->width) { - column->dirty = TRUE; + gtk_tree_view_column_cell_set_dirty (column); retval = TRUE; } } @@ -4972,7 +4974,7 @@ gtk_tree_view_discover_dirty_iter (GtkTreeView *tree_view, { if (width > column->width) { - column->dirty = TRUE; + gtk_tree_view_column_cell_set_dirty (column); retval = TRUE; } } @@ -5029,8 +5031,14 @@ gtk_tree_view_discover_dirty (GtkTreeView *tree_view, } +/** + * gtk_tree_view_check_dirty_and_clean: + * @tree_view: A #GtkTreeView + * + * Does all the actual sizing for + **/ static void -gtk_tree_view_check_dirty (GtkTreeView *tree_view) +gtk_tree_view_check_dirty_and_clean (GtkTreeView *tree_view) { GtkTreePath *path; gboolean dirty = FALSE; @@ -5679,10 +5687,10 @@ _gtk_tree_view_update_col_width (GtkTreeView *tree_view) continue; width += column->width; - column->displayed_width = (CLAMP (column->width, (column->min_width!=-1)?column->min_width:column->width, (column->max_width!=-1)?column->max_width:column->width)); + column->width = (CLAMP (column->width, (column->min_width!=-1)?column->min_width:column->width, (column->max_width!=-1)?column->max_width:column->width)); } column = GTK_TREE_VIEW_COLUMN (last_column->data); - column->displayed_width = MAX (GTK_WIDGET (tree_view)->allocation.width, tree_view->priv->width) - width; + column->width = MAX (GTK_WIDGET (tree_view)->allocation.width, tree_view->priv->width) - width; } static void @@ -5805,19 +5813,72 @@ gtk_tree_view_move_cursor_left_right (GtkTreeView *tree_view, GtkRBTree *cursor_tree = NULL; GtkRBNode *cursor_node = NULL; GtkTreePath *cursor_path = NULL; - - g_print ("gtk_tree_view_move_cursor_left_right\n"); + GtkTreeViewColumn *column; + GtkTreeIter iter; + GList *list; + gboolean found_column = FALSE; if (gtk_tree_row_reference_valid (tree_view->priv->cursor)) cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor); else return; - _gtk_tree_view_find_node (tree_view, cursor_path, - &cursor_tree, &cursor_node); + _gtk_tree_view_find_node (tree_view, cursor_path, &cursor_tree, &cursor_node); + if (cursor_tree == NULL) + return; + if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path) == FALSE) + { + gtk_tree_path_free (cursor_path); + return; + } gtk_tree_path_free (cursor_path); + list = tree_view->priv->columns; + if (tree_view->priv->focus_column) + { + for (list = tree_view->priv->columns; list; list = list->next) + { + if (list->data == tree_view->priv->focus_column) + break; + } + } + + while (list) + { + column = list->data; + if (column->visible == FALSE) + goto loop_end; + gtk_tree_view_column_cell_set_cell_data (column, + tree_view->priv->model, + &iter, + GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT), + cursor_node->children?TRUE:FALSE); + if (gtk_tree_view_column_cell_can_focus (column)) + { + if (gtk_tree_view_column_cell_focus (column, count, FALSE)) + { + tree_view->priv->focus_column = column; + found_column = TRUE; + break; + } + } + loop_end: + if (count == 1) + list = list->next; + else + list = list->prev; + } + + if (found_column) + { + gtk_tree_view_queue_draw_node (tree_view, + cursor_tree, + cursor_node, + NULL); + return; + } + g_print ("scroll now!\n"); } static void @@ -6483,7 +6544,7 @@ gtk_tree_view_columns_autosize (GtkTreeView *tree_view) column = list->data; if (column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE) continue; - column->dirty = TRUE; + gtk_tree_view_column_cell_set_dirty (column); dirty = TRUE; } @@ -6626,7 +6687,7 @@ gtk_tree_view_remove_column (GtkTreeView *tree_view, tmp_column = GTK_TREE_VIEW_COLUMN (list->data); if (tmp_column->visible) - tmp_column->dirty = TRUE; + gtk_tree_view_column_cell_set_dirty (tmp_column); } if (tree_view->priv->n_columns == 0 && @@ -6688,7 +6749,7 @@ gtk_tree_view_insert_column (GtkTreeView *tree_view, { column = GTK_TREE_VIEW_COLUMN (list->data); if (column->visible) - column->dirty = TRUE; + gtk_tree_view_column_cell_set_dirty (column); } gtk_widget_queue_resize (GTK_WIDGET (tree_view)); } @@ -7178,35 +7239,6 @@ gtk_tree_view_expand_all (GtkTreeView *tree_view) _gtk_tree_view_update_size (tree_view); } -static void -gtk_tree_view_collapse_all_helper (GtkRBTree *tree, - GtkRBNode *node, - gpointer data) -{ - if (node->children) - { - GtkTreePath *path; - GtkTreeIter iter; - - path = _gtk_tree_view_find_path (GTK_TREE_VIEW (data), - node->children, - node->children->root); - gtk_tree_model_get_iter (GTK_TREE_VIEW (data)->priv->model, - &iter, - path); - gtk_tree_view_discover_dirty (GTK_TREE_VIEW (data), - node->children, - &iter, - gtk_tree_path_get_depth (path)); - - /* Ensure we don't have a dangling pointer to a dead node */ - ensure_unprelighted (GTK_TREE_VIEW (data)); - - _gtk_rbtree_remove (node->children); - gtk_tree_path_free (path); - } -} - /* Timeout to animate the expander during expands and collapses */ static gboolean expand_collapse_timeout (gpointer data) @@ -7286,17 +7318,32 @@ expand_collapse_timeout (gpointer data) void gtk_tree_view_collapse_all (GtkTreeView *tree_view) { + GtkRBTree *tree; + GtkRBNode *node; + GtkTreePath *path; + guint *indices; + g_return_if_fail (GTK_IS_TREE_VIEW (tree_view)); g_return_if_fail (tree_view->priv->tree != NULL); - _gtk_rbtree_traverse (tree_view->priv->tree, - tree_view->priv->tree->root, - G_PRE_ORDER, - gtk_tree_view_collapse_all_helper, - tree_view); + path = gtk_tree_path_new (); + gtk_tree_path_append_index (path, 0); + indices = gtk_tree_path_get_indices (path); - if (GTK_WIDGET_MAPPED (tree_view)) - gtk_widget_queue_draw (GTK_WIDGET (tree_view)); + tree = tree_view->priv->tree; + node = tree->root; + while (node && node->left != tree->nil) + node = node->left; + + while (node) + { + if (node->children) + gtk_tree_view_real_collapse_row (tree_view, path, tree, node); + indices[0]++; + node = _gtk_rbtree_next (tree, node); + } + + gtk_tree_path_free (path); } /* FIXME the bool return values for expand_row and collapse_row are @@ -7412,6 +7459,7 @@ gtk_tree_view_real_collapse_row (GtkTreeView *tree_view, GtkTreeIter children; gboolean collapse; gint x, y; + GList *list; gtk_tree_model_get_iter (tree_view->priv->model, &iter, path); @@ -7444,11 +7492,16 @@ gtk_tree_view_real_collapse_row (GtkTreeView *tree_view, TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_children (tree_view->priv->model, &children, &iter), FALSE); - gtk_tree_view_discover_dirty (tree_view, - node->children, - &children, - gtk_tree_path_get_depth (path)); + for (list = tree_view->priv->columns; list; list = list->next) + { + GtkTreeViewColumn *column = list->data; + if (column->visible == FALSE) + continue; + if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE) + gtk_tree_view_column_cell_set_dirty (column); + } + if (tree_view->priv->destroy_count_func) { GtkTreePath *child_path; @@ -8469,7 +8522,7 @@ gtk_tree_view_create_row_drag_icon (GtkTreeView *tree_view, node->children?TRUE:FALSE); background_area.x = cell_offset; - background_area.width = column->displayed_width; + background_area.width = column->width; cell_area = background_area; @@ -8492,7 +8545,7 @@ gtk_tree_view_create_row_drag_icon (GtkTreeView *tree_view, NULL, 0); - cell_offset += column->displayed_width; + cell_offset += column->width; } return drawable; diff --git a/gtk/gtktreeviewcolumn.c b/gtk/gtktreeviewcolumn.c index 860ec62ee4..4821e8eb24 100644 --- a/gtk/gtktreeviewcolumn.c +++ b/gtk/gtktreeviewcolumn.c @@ -33,8 +33,9 @@ enum { PROP_0, PROP_VISIBLE, - PROP_SIZING, PROP_WIDTH, + PROP_SIZING, + PROP_FIXED_WIDTH, PROP_MIN_WIDTH, PROP_MAX_WIDTH, PROP_TITLE, @@ -61,10 +62,9 @@ struct _GtkTreeViewColumnCellInfo gpointer func_data; GtkDestroyNotify destroy; gint requested_width; - guint16 padding; guint expand : 1; - guint fill : 1; guint pack : 1; + guint has_focus : 1; }; /* Type methods */ @@ -108,6 +108,10 @@ static void gtk_tree_view_column_set_attributesv (GtkTreeViewColum va_list args); static GtkTreeViewColumnCellInfo *gtk_tree_view_column_get_cell_info (GtkTreeViewColumn *tree_column, GtkCellRenderer *cell_renderer); +static void gtk_tree_view_column_cell_foreach (GtkTreeViewColumn *tree_column, + gboolean direction, + GFunc function, + gpointer data); @@ -173,6 +177,15 @@ gtk_tree_view_column_class_init (GtkTreeViewColumnClass *class) TRUE, 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"), + 0, + G_MAXINT, + 0, + G_PARAM_READABLE)); g_object_class_install_property (object_class, PROP_SIZING, g_param_spec_enum ("sizing", @@ -183,10 +196,10 @@ gtk_tree_view_column_class_init (GtkTreeViewColumnClass *class) 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"), + PROP_FIXED_WIDTH, + g_param_spec_int ("fixed_width", + _("Fixed Width"), + _("Current fixed width of the column"), 1, G_MAXINT, 1, /* not useful */ @@ -199,7 +212,7 @@ gtk_tree_view_column_class_init (GtkTreeViewColumnClass *class) _("Minimum allowed width of the column"), -1, G_MAXINT, - 1, + -1, G_PARAM_READABLE | G_PARAM_WRITABLE)); g_object_class_install_property (object_class, @@ -209,7 +222,7 @@ gtk_tree_view_column_class_init (GtkTreeViewColumnClass *class) _("Maximum allowed width of the column"), -1, G_MAXINT, - G_MAXINT, + -1, G_PARAM_READABLE | G_PARAM_WRITABLE)); g_object_class_install_property (object_class, @@ -279,11 +292,11 @@ gtk_tree_view_column_init (GtkTreeViewColumn *tree_column) { tree_column->button = NULL; tree_column->xalign = 0.0; - tree_column->width = 1; + tree_column->width = 0; tree_column->requested_width = -1; tree_column->min_width = -1; tree_column->max_width = -1; - tree_column->column_type = GTK_TREE_VIEW_COLUMN_AUTOSIZE; + tree_column->column_type = GTK_TREE_VIEW_COLUMN_GROW_ONLY; tree_column->visible = TRUE; tree_column->clickable = FALSE; tree_column->dirty = TRUE; @@ -340,9 +353,9 @@ gtk_tree_view_column_set_property (GObject *object, g_value_get_enum (value)); break; - case PROP_WIDTH: - gtk_tree_view_column_set_width (tree_column, - g_value_get_int (value)); + case PROP_FIXED_WIDTH: + gtk_tree_view_column_set_fixed_width (tree_column, + g_value_get_int (value)); break; case PROP_MIN_WIDTH: @@ -413,14 +426,19 @@ gtk_tree_view_column_get_property (GObject *object, gtk_tree_view_column_get_visible (tree_column)); break; + case PROP_WIDTH: + g_value_set_int (value, + gtk_tree_view_column_get_width (tree_column)); + break; + case PROP_SIZING: g_value_set_enum (value, gtk_tree_view_column_get_sizing (tree_column)); break; - case PROP_WIDTH: + case PROP_FIXED_WIDTH: g_value_set_int (value, - gtk_tree_view_column_get_width (tree_column)); + gtk_tree_view_column_get_fixed_width (tree_column)); break; case PROP_MIN_WIDTH: @@ -685,8 +703,7 @@ gtk_tree_view_column_update_button (GtkTreeViewColumn *tree_column) } } - tree_column->dirty = TRUE; - gtk_widget_queue_resize (tree_column->tree_view); + gtk_tree_view_column_cell_set_dirty (tree_column); } /* Button signal handlers @@ -1053,7 +1070,7 @@ void gtk_tree_view_column_set_cell_renderer (GtkTreeViewColumn *tree_column, GtkCellRenderer *cell) { - gtk_tree_view_column_pack_start (tree_column, cell, TRUE, TRUE, 0); + gtk_tree_view_column_pack_start (tree_column, cell, TRUE); } static GtkTreeViewColumnCellInfo * @@ -1067,22 +1084,18 @@ gtk_tree_view_column_get_cell_info (GtkTreeViewColumn *tree_column, return NULL; } + /** * 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. - * @fill: TRUE if @cell is to fill space allocated to it. - * @padding: extra space in pixels to place on the outside of the cell * - * Packs a cell into **/ void gtk_tree_view_column_pack_start (GtkTreeViewColumn *tree_column, GtkCellRenderer *cell, - gboolean expand, - gboolean fill, - guint padding) + gboolean expand) { GtkTreeViewColumnCellInfo *cell_info; @@ -1096,8 +1109,8 @@ gtk_tree_view_column_pack_start (GtkTreeViewColumn *tree_column, cell_info = g_new0 (GtkTreeViewColumnCellInfo, 1); cell_info->cell = cell; cell_info->expand = expand ? TRUE : FALSE; - cell_info->fill = fill ? 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); @@ -1106,9 +1119,7 @@ gtk_tree_view_column_pack_start (GtkTreeViewColumn *tree_column, void gtk_tree_view_column_pack_end (GtkTreeViewColumn *tree_column, GtkCellRenderer *cell, - gboolean expand, - gboolean fill, - guint padding) + gboolean expand) { GtkTreeViewColumnCellInfo *cell_info; @@ -1122,8 +1133,8 @@ gtk_tree_view_column_pack_end (GtkTreeViewColumn *tree_column, cell_info = g_new (GtkTreeViewColumnCellInfo, 1); cell_info->cell = cell; cell_info->expand = expand ? TRUE : FALSE; - cell_info->fill = fill ? 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); @@ -1192,10 +1203,7 @@ gtk_tree_view_column_add_attribute (GtkTreeViewColumn *tree_column, info->attributes = g_slist_prepend (info->attributes, g_strdup (attribute)); if (tree_column->tree_view) - { - tree_column->dirty = TRUE; - gtk_widget_queue_resize (tree_column->tree_view); - } + gtk_tree_view_column_cell_set_dirty (tree_column); } @@ -1286,10 +1294,7 @@ gtk_tree_view_column_set_cell_data_func (GtkTreeViewColumn *tree_column, info->destroy = destroy; if (tree_column->tree_view) - { - tree_column->dirty = TRUE; - gtk_widget_queue_resize (tree_column->tree_view); - } + gtk_tree_view_column_cell_set_dirty (tree_column); } @@ -1323,10 +1328,7 @@ gtk_tree_view_column_clear_attributes (GtkTreeViewColumn *tree_column, info->attributes = NULL; if (tree_column->tree_view) - { - tree_column->dirty = TRUE; - gtk_widget_queue_resize (tree_column->tree_view); - } + gtk_tree_view_column_cell_set_dirty (tree_column); } @@ -1350,10 +1352,7 @@ gtk_tree_view_column_set_spacing (GtkTreeViewColumn *tree_column, tree_column->spacing = spacing; if (tree_column->tree_view) - { - tree_column->dirty = TRUE; - gtk_widget_queue_resize (tree_column->tree_view); - } + gtk_tree_view_column_cell_set_dirty (tree_column); } /** @@ -1459,53 +1458,12 @@ gtk_tree_view_column_get_sizing (GtkTreeViewColumn *tree_column) } /** - * gtk_tree_view_column_get_size: + * gtk_tree_view_column_get_width: * @tree_column: A #GtkTreeViewColumn. * * Returns the current size of the @tree_column in pixels. * - * Return value: The current size of the @tree_column. - **/ -gint -gtk_tree_view_column_get_size (GtkTreeViewColumn *tree_column) -{ - g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0); - - return tree_column->width; -} - -/** - * gtk_tree_view_column_set_width: - * @tree_column: A #GtkTreeViewColumn. - * @width: The size to set the @tree_column to. - * - * Sets the size of the column in pixels, unless the the column type is - * #GTK_TREE_VIEW_COLUMN_AUTOSIZE. In this case, the value is discarded as the - * size of the column is based on the calculated width of the column. The - * width is clamped to the min/max width for the column. - **/ -void -gtk_tree_view_column_set_width (GtkTreeViewColumn *tree_column, - gint width) -{ - g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); - g_return_if_fail (width > 0); - - if (tree_column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE) - return; - - tree_column->requested_width = width; - _gtk_tree_view_column_set_width (tree_column, width); -} - -/** - * gtk_tree_view_column_get_width: - * @tree_column: a #GtkTreeViewColumn - * - * Gets the value set by gtk_tree_view_column_set_width(). This may not be the - * actual width of the column on the screen, just what is requested. - * - * Return value: the width of the column + * Return value: The current width of the @tree_column. **/ gint gtk_tree_view_column_get_width (GtkTreeViewColumn *tree_column) @@ -1515,6 +1473,48 @@ gtk_tree_view_column_get_width (GtkTreeViewColumn *tree_column) return tree_column->width; } +/** + * gtk_tree_view_column_set_fixed_width: + * @tree_column: A #GtkTreeViewColumn. + * @width: The size to set the @tree_column to. + * + * Sets the size of the column in pixels. This is meaningful only if the sizing + * type is #GTK_TREE_VIEW_COLUMN_FIXED. In this case, the value is discarded + * as the size of the column is based on the calculated width of the column. The + * width is clamped to the min/max width for the column. + **/ +void +gtk_tree_view_column_set_fixed_width (GtkTreeViewColumn *tree_column, + gint width) +{ + g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); + g_return_if_fail (width > 0); + + if (tree_column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE) + return; + + tree_column->fixed_width = width; + tree_column->requested_width = width; + _gtk_tree_view_column_set_width (tree_column, width); +} + +/** + * gtk_tree_view_column_get_fixed_width: + * @tree_column: a #GtkTreeViewColumn + * + * Gets the fixed width of the column. This value is only meaning may not be the + * actual width of the column on the screen, just what is requested. + * + * Return value: the fixed width of the column + **/ +gint +gtk_tree_view_column_get_fixed_width (GtkTreeViewColumn *tree_column) +{ + g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0); + + return tree_column->fixed_width; +} + /** * gtk_tree_view_column_set_min_width: * @tree_column: A #GtkTreeViewColumn. @@ -2065,7 +2065,7 @@ gtk_tree_view_column_cell_set_cell_data (GtkTreeViewColumn *tree_column, } } - +#if 0 /** * gtk_tree_view_column_cell_get_size: * @tree_column: A #GtkTreeViewColumn. @@ -2097,6 +2097,55 @@ gtk_tree_view_column_cell_get_size (GtkTreeViewColumn *tree_column, height); } +#endif +void +gtk_tree_view_column_cell_get_size (GtkTreeViewColumn *tree_column, + GdkRectangle *cell_area, + gint *x_offset, + gint *y_offset, + gint *width, + gint *height) +{ + GList *list; + gboolean first_cell = TRUE; + + g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); + + if (height) + * height = 0; + if (width) + * width = 0; + + for (list = tree_column->cell_list; list; list = list->next) + { + GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) list->data; + gboolean visible; + gint new_height = 0; + gint new_width = 0; + g_object_get (info->cell, "visible", &visible, NULL); + + if (visible == FALSE) + continue; + + if (first_cell == FALSE && *width) + *width += tree_column->spacing; + + gtk_cell_renderer_get_size (info->cell, + tree_column->tree_view, + cell_area, + x_offset, + y_offset, + &new_width, + &new_height); + + if (height) + * height = MAX (*height, new_height); + info->requested_width = MAX (info->requested_width, new_width); + if (width) + * width += info->requested_width; + first_cell = TRUE; + } +} /** * gtk_tree_view_column_cell_render: @@ -2118,18 +2167,84 @@ gtk_tree_view_column_cell_render (GtkTreeViewColumn *tree_column, GdkRectangle *expose_area, guint flags) { - gboolean visible; - g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); + GList *list; + GdkRectangle real_cell_area; + gint expand_cell_count = 0; + gint full_requested_width = 0; + gint extra_space; - g_object_get (G_OBJECT ((((GtkTreeViewColumnCellInfo *) tree_column->cell_list->data)->cell)), "visible", &visible, NULL); - if (visible) - gtk_cell_renderer_render (((GtkTreeViewColumnCellInfo *) tree_column->cell_list->data)->cell, - window, - tree_column->tree_view, - background_area, - cell_area, - expose_area, - flags); + g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); + g_return_if_fail (background_area != NULL); + g_return_if_fail (cell_area != NULL); + g_return_if_fail (expose_area != NULL); + + real_cell_area = *cell_area; + + /* Find out how my extra space we have to allocate */ + for (list = tree_column->cell_list; list; list = list->next) + { + GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) list->data; + gboolean visible; + + g_object_get (info->cell, "visible", &visible, NULL); + if (visible == FALSE) + continue; + + if (info->expand == TRUE) + expand_cell_count ++; + full_requested_width += info->requested_width; + } + + extra_space = cell_area->width - full_requested_width; + if (extra_space < 0) + extra_space = 0; + + for (list = tree_column->cell_list; list; list = list->next) + { + GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) list->data; + gboolean visible; + + if (info->pack == GTK_PACK_END) + continue; + + g_object_get (info->cell, "visible", &visible, NULL); + if (visible == FALSE) + continue; + + real_cell_area.width = info->requested_width + + (info->expand?extra_space:0); + gtk_cell_renderer_render (info->cell, + window, + tree_column->tree_view, + background_area, + &real_cell_area, + expose_area, + flags); + real_cell_area.x += (info->requested_width + tree_column->spacing); + } + for (list = g_list_last (tree_column->cell_list); list; list = list->prev) + { + GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) list->data; + gboolean visible; + + if (info->pack == GTK_PACK_START) + continue; + + g_object_get (info->cell, "visible", &visible, NULL); + if (visible == FALSE) + continue; + + real_cell_area.width = info->requested_width + + (info->expand?extra_space:0); + gtk_cell_renderer_render (info->cell, + window, + tree_column->tree_view, + background_area, + &real_cell_area, + expose_area, + flags); + real_cell_area.x += (info->requested_width + tree_column->spacing); + } } /** @@ -2176,6 +2291,18 @@ gtk_tree_view_column_cell_event (GtkTreeViewColumn *tree_column, return FALSE; } + +gboolean +gtk_tree_view_column_cell_focus (GtkTreeViewColumn *tree_column, + gint direction, + gboolean unfocus) +{ + GList *list; + gboolean visible; + gboolean can_activate; + +} + gboolean gtk_tree_view_column_cell_can_focus (GtkTreeViewColumn *tree_column) { @@ -2202,17 +2329,89 @@ gboolean gtk_tree_view_column_cell_is_visible (GtkTreeViewColumn *tree_column) { GList *list; - gboolean visible; for (list = tree_column->cell_list; list; list = list->next) { GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) list->data; - g_object_get (G_OBJECT (info->cell), - "visible", &visible, - NULL); + gboolean visible; + + g_object_get (G_OBJECT (info->cell), "visible", &visible, NULL); + if (visible) return TRUE; } return FALSE; } + +void +gtk_tree_view_column_cell_set_dirty (GtkTreeViewColumn *tree_column) +{ + GList *list; + + for (list = tree_column->cell_list; list; list = list->next) + { + GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) list->data; + + info->requested_width = 0; + } + tree_column->dirty = TRUE; + + g_print ("in gtk_tree_view_column_cell_set_dirty\n"); + if (tree_column->tree_view) + gtk_widget_queue_resize (tree_column->tree_view); +} + + +#if 0 +static void +gtk_tree_view_column_cell_foreach (GtkTreeViewColumn *tree_column, + gboolean direction, + GFunc function, + gpointer data) +{ + GList *list; + GtkTreeViewColumnCellInfo *info; + + if (direction == 1) + { + for (list = tree_column->cell_list; list; list = list->next) + { + info = list->data; + if (info->pack == GTK_PACK_END) + continue; + if ((*function) (info, data)) + return; + } + + for (list = g_list_llast (tree_column->cell_list); list; list = list->prev) + { + info = list->data; + if (info->pack == GTK_PACK_START) + continue; + if ((*function) (info, data)) + return; + } + } + else + { + for (list = g_list_llast (tree_column->cell_list); list; list = list->prev) + { + info = list->data; + if (info->pack == GTK_PACK_START) + continue; + if ((*function) (info, data)) + return; + } + for (list = tree_column->cell_list; list; list = list->next) + { + info = list->data; + if (info->pack == GTK_PACK_END) + continue; + if ((*function) (info, data)) + return; + } + + } +} +#endif diff --git a/gtk/gtktreeviewcolumn.h b/gtk/gtktreeviewcolumn.h index cccfb0d1e4..6f689226e4 100644 --- a/gtk/gtktreeviewcolumn.h +++ b/gtk/gtktreeviewcolumn.h @@ -38,6 +38,7 @@ extern "C" { typedef enum { + GTK_TREE_VIEW_COLUMN_GROW_ONLY, GTK_TREE_VIEW_COLUMN_RESIZABLE, GTK_TREE_VIEW_COLUMN_AUTOSIZE, GTK_TREE_VIEW_COLUMN_FIXED @@ -67,11 +68,11 @@ struct _GtkTreeViewColumn guint property_changed_signal; gint spacing; + gint fixed_width; gint width; gint requested_width; gint min_width; gint max_width; - gint displayed_width; /* dragging columns */ gint drag_x; @@ -112,14 +113,10 @@ void gtk_tree_view_column_set_cell_renderer (GtkTreeViewCol GtkCellRenderer *cell); void gtk_tree_view_column_pack_start (GtkTreeViewColumn *tree_column, GtkCellRenderer *cell, - gboolean expand, - gboolean fill, - guint padding); + gboolean expand); void gtk_tree_view_column_pack_end (GtkTreeViewColumn *tree_column, GtkCellRenderer *cell, - gboolean expand, - gboolean fill, - guint padding); + gboolean expand); void gtk_tree_view_column_clear (GtkTreeViewColumn *tree_column); GList *gtk_tree_view_column_get_cell_renderers (GtkTreeViewColumn *tree_column); void gtk_tree_view_column_add_attribute (GtkTreeViewColumn *tree_column, @@ -146,8 +143,9 @@ void gtk_tree_view_column_set_sizing (GtkTreeViewCol GtkTreeViewColumnSizing type); GtkTreeViewColumnSizing gtk_tree_view_column_get_sizing (GtkTreeViewColumn *tree_column); gint gtk_tree_view_column_get_width (GtkTreeViewColumn *tree_column); -void gtk_tree_view_column_set_width (GtkTreeViewColumn *tree_column, - gint width); +gint gtk_tree_view_column_get_fixed_width (GtkTreeViewColumn *tree_column); +void gtk_tree_view_column_set_fixed_width (GtkTreeViewColumn *tree_column, + gint fixed_width); void gtk_tree_view_column_set_min_width (GtkTreeViewColumn *tree_column, gint min_width); gint gtk_tree_view_column_get_min_width (GtkTreeViewColumn *tree_column); @@ -217,8 +215,12 @@ gboolean gtk_tree_view_column_cell_event (GtkTreeViewCol GdkRectangle *background_area, GdkRectangle *cell_area, guint flags); +gboolean gtk_tree_view_column_cell_focus (GtkTreeViewColumn *tree_column, + gint direction, + gboolean unfocus); gboolean gtk_tree_view_column_cell_can_focus (GtkTreeViewColumn *tree_column); gboolean gtk_tree_view_column_cell_is_visible (GtkTreeViewColumn *tree_column); +void gtk_tree_view_column_cell_set_dirty (GtkTreeViewColumn *tree_column); #ifdef __cplusplus diff --git a/tests/testtreefocus.c b/tests/testtreefocus.c index 59a2200b67..08a3207c4f 100644 --- a/tests/testtreefocus.c +++ b/tests/testtreefocus.c @@ -352,7 +352,7 @@ main (int argc, char *argv[]) NULL); column = gtk_tree_view_get_column (GTK_TREE_VIEW (tree_view), col_offset - 1); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), GTK_TREE_VIEW_COLUMN_FIXED); - gtk_tree_view_column_set_width (GTK_TREE_VIEW_COLUMN (column), 50); + gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 50); gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); /* Havoc Column */ @@ -368,7 +368,7 @@ main (int argc, char *argv[]) NULL); column = gtk_tree_view_get_column (GTK_TREE_VIEW (tree_view), col_offset - 1); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), GTK_TREE_VIEW_COLUMN_FIXED); - gtk_tree_view_column_set_width (GTK_TREE_VIEW_COLUMN (column), 50); + gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 50); gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); /* Tim Column */ @@ -386,7 +386,7 @@ main (int argc, char *argv[]) column = gtk_tree_view_get_column (GTK_TREE_VIEW (tree_view), col_offset - 1); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); - gtk_tree_view_column_set_width (GTK_TREE_VIEW_COLUMN (column), 50); + gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 50); /* Owen Column */ renderer = gtk_cell_renderer_toggle_new (); @@ -401,7 +401,7 @@ main (int argc, char *argv[]) column = gtk_tree_view_get_column (GTK_TREE_VIEW (tree_view), col_offset - 1); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); - gtk_tree_view_column_set_width (GTK_TREE_VIEW_COLUMN (column), 50); + gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 50); /* Owen Column */ renderer = gtk_cell_renderer_toggle_new (); @@ -415,7 +415,7 @@ main (int argc, char *argv[]) NULL); column = gtk_tree_view_get_column (GTK_TREE_VIEW (tree_view), col_offset - 1); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), GTK_TREE_VIEW_COLUMN_FIXED); - gtk_tree_view_column_set_width (GTK_TREE_VIEW_COLUMN (column), 50); + gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 50); gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); gtk_container_add (GTK_CONTAINER (scrolled_window), tree_view); diff --git a/tests/testtreeview.c b/tests/testtreeview.c index 79de1bbd0d..6367a5f320 100644 --- a/tests/testtreeview.c +++ b/tests/testtreeview.c @@ -279,13 +279,15 @@ set_columns_type (GtkTreeView *tree_view, ColumnsType type) gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); - rend = gtk_cell_renderer_text_pixbuf_new (); + col = gtk_tree_view_column_new(); + gtk_tree_view_column_set_title (col, "Column 2"); - col = gtk_tree_view_column_new_with_attributes ("Column 2", - rend, - "text", 0, - "pixbuf", 2, - NULL); + rend = gtk_cell_renderer_pixbuf_new (); + gtk_tree_view_column_pack_start (col, rend, FALSE); + gtk_tree_view_column_add_attribute (col, rend, "pixbuf", 2); + rend = gtk_cell_renderer_text_new (); + gtk_tree_view_column_pack_start (col, rend, TRUE); + gtk_tree_view_column_add_attribute (col, rend, "text", 0); setup_column (col);