* Boston, MA 02111-1307, USA.
*/
+#include <config.h>
+#include <string.h>
#include "gtkcellview.h"
#include "gtkcelllayout.h"
#include "gtkintl.h"
#include "gtksignal.h"
#include "gtkcellrenderertext.h"
#include "gtkcellrendererpixbuf.h"
+#include "gtkprivate.h"
#include <gobject/gmarshal.h>
+#include "gtkbuildable.h"
+#include "gtkalias.h"
typedef struct _GtkCellViewCellInfo GtkCellViewCellInfo;
struct _GtkCellViewCellInfo
};
-static void gtk_cell_view_class_init (GtkCellViewClass *klass);
static void gtk_cell_view_cell_layout_init (GtkCellLayoutIface *iface);
static void gtk_cell_view_get_property (GObject *object,
guint param_id,
guint param_id,
const GValue *value,
GParamSpec *pspec);
-static void gtk_cell_view_init (GtkCellView *cellview);
static void gtk_cell_view_finalize (GObject *object);
-static void gtk_cell_view_style_set (GtkWidget *widget,
- GtkStyle *previous_style);
static void gtk_cell_view_size_request (GtkWidget *widget,
GtkRequisition *requisition);
static void gtk_cell_view_size_allocate (GtkWidget *widget,
GtkAllocation *allocation);
static gboolean gtk_cell_view_expose (GtkWidget *widget,
GdkEventExpose *event);
-static void gtk_cell_view_set_valuesv (GtkCellView *cellview,
- GtkCellRenderer *renderer,
- va_list args);
+static void gtk_cell_view_set_value (GtkCellView *cell_view,
+ GtkCellRenderer *renderer,
+ gchar *property,
+ GValue *value);
static GtkCellViewCellInfo *gtk_cell_view_get_cell_info (GtkCellView *cellview,
GtkCellRenderer *renderer);
-static void gtk_cell_view_set_cell_data (GtkCellView *cellview);
+static void gtk_cell_view_set_cell_data (GtkCellView *cell_view);
static void gtk_cell_view_cell_layout_pack_start (GtkCellLayout *layout,
static void gtk_cell_view_cell_layout_reorder (GtkCellLayout *layout,
GtkCellRenderer *cell,
gint position);
-
+static GList * gtk_cell_view_cell_layout_get_cells (GtkCellLayout *layout);
+
+/* buildable */
+static void gtk_cell_view_buildable_init (GtkBuildableIface *iface);
+static gboolean gtk_cell_view_buildable_custom_tag_start (GtkBuildable *buildable,
+ GtkBuilder *builder,
+ GObject *child,
+ const gchar *tagname,
+ GMarkupParser *parser,
+ gpointer *data);
+static void gtk_cell_view_buildable_custom_tag_end (GtkBuildable *buildable,
+ GtkBuilder *builder,
+ GObject *child,
+ const gchar *tagname,
+ gpointer *data);
+
+static GtkBuildableIface *parent_buildable_iface;
#define GTK_CELL_VIEW_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_CELL_VIEW, GtkCellViewPrivate))
PROP_0,
PROP_BACKGROUND,
PROP_BACKGROUND_GDK,
- PROP_BACKGROUND_SET
+ PROP_BACKGROUND_SET,
+ PROP_MODEL
};
-static GtkObjectClass *parent_class = NULL;
-
-
-GType
-gtk_cell_view_get_type (void)
-{
- static GType cell_view_type = 0;
-
- if (!cell_view_type)
- {
- static const GTypeInfo cell_view_info =
- {
- sizeof (GtkCellViewClass),
- NULL, /* base_init */
- NULL, /* base_finalize */
- (GClassInitFunc) gtk_cell_view_class_init,
- NULL, /* class_finalize */
- NULL, /* class_data */
- sizeof (GtkCellView),
- 0,
- (GInstanceInitFunc) gtk_cell_view_init
- };
-
- static const GInterfaceInfo cell_layout_info =
- {
- (GInterfaceInitFunc) gtk_cell_view_cell_layout_init,
- NULL,
- NULL
- };
-
- cell_view_type = g_type_register_static (GTK_TYPE_WIDGET, "GtkCellView",
- &cell_view_info, 0);
-
- g_type_add_interface_static (cell_view_type, GTK_TYPE_CELL_LAYOUT,
- &cell_layout_info);
- }
-
- return cell_view_type;
-}
+G_DEFINE_TYPE_WITH_CODE (GtkCellView, gtk_cell_view, GTK_TYPE_WIDGET,
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_LAYOUT,
+ gtk_cell_view_cell_layout_init)
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
+ gtk_cell_view_buildable_init))
static void
gtk_cell_view_class_init (GtkCellViewClass *klass)
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
- parent_class = g_type_class_peek_parent (klass);
-
gobject_class->get_property = gtk_cell_view_get_property;
gobject_class->set_property = gtk_cell_view_set_property;
gobject_class->finalize = gtk_cell_view_finalize;
widget_class->expose_event = gtk_cell_view_expose;
widget_class->size_allocate = gtk_cell_view_size_allocate;
widget_class->size_request = gtk_cell_view_size_request;
- widget_class->style_set = gtk_cell_view_style_set;
/* properties */
g_object_class_install_property (gobject_class,
P_("Background color name"),
P_("Background color as a string"),
NULL,
- G_PARAM_WRITABLE));
+ GTK_PARAM_WRITABLE));
g_object_class_install_property (gobject_class,
PROP_BACKGROUND_GDK,
- g_param_spec_boxed ("background_gdk",
+ g_param_spec_boxed ("background-gdk",
P_("Background color"),
P_("Background color as a GdkColor"),
GDK_TYPE_COLOR,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
-
-#define ADD_SET_PROP(propname, propval, nick, blurb) g_object_class_install_property (gobject_class, propval, g_param_spec_boolean (propname, nick, blurb, FALSE, G_PARAM_READABLE | G_PARAM_WRITABLE))
-
- ADD_SET_PROP ("background_set", PROP_BACKGROUND_SET,
+ GTK_PARAM_READWRITE));
+
+ /**
+ * GtkCellView:model
+ *
+ * The model for cell view
+ *
+ * since 2.10
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_MODEL,
+ g_param_spec_object ("model",
+ P_("CellView model"),
+ P_("The model for cell view"),
+ GTK_TYPE_TREE_MODEL,
+ GTK_PARAM_READWRITE));
+
+#define ADD_SET_PROP(propname, propval, nick, blurb) g_object_class_install_property (gobject_class, propval, g_param_spec_boolean (propname, nick, blurb, FALSE, GTK_PARAM_READWRITE))
+
+ ADD_SET_PROP ("background-set", PROP_BACKGROUND_SET,
P_("Background set"),
P_("Whether this tag affects the background color"));
g_type_class_add_private (gobject_class, sizeof (GtkCellViewPrivate));
}
+static void
+gtk_cell_view_buildable_init (GtkBuildableIface *iface)
+{
+ parent_buildable_iface = g_type_interface_peek_parent (iface);
+ iface->add_child = _gtk_cell_layout_buildable_add_child;
+ iface->custom_tag_start = gtk_cell_view_buildable_custom_tag_start;
+ iface->custom_tag_end = gtk_cell_view_buildable_custom_tag_end;
+}
+
static void
gtk_cell_view_cell_layout_init (GtkCellLayoutIface *iface)
{
iface->set_cell_data_func = gtk_cell_view_cell_layout_set_cell_data_func;
iface->clear_attributes = gtk_cell_view_cell_layout_clear_attributes;
iface->reorder = gtk_cell_view_cell_layout_reorder;
+ iface->get_cells = gtk_cell_view_cell_layout_get_cells;
}
static void
case PROP_BACKGROUND_SET:
g_value_set_boolean (value, view->priv->background_set);
break;
+ case PROP_MODEL:
+ g_value_set_object (value, view->priv->model);
+ break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
break;
else
g_warning ("Don't know color `%s'", g_value_get_string (value));
- g_object_notify (object, "background_gdk");
+ g_object_notify (object, "background-gdk");
}
break;
case PROP_BACKGROUND_GDK:
case PROP_BACKGROUND_SET:
view->priv->background_set = g_value_get_boolean (value);
break;
- default:
+ case PROP_MODEL:
+ gtk_cell_view_set_model (view, g_value_get_object (value));
+ break;
+ default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
break;
}
cellview->priv = GTK_CELL_VIEW_GET_PRIVATE (cellview);
}
-static void
-gtk_cell_view_style_set (GtkWidget *widget,
- GtkStyle *previous_style)
-{
- if (previous_style && GTK_WIDGET_REALIZED (widget))
- gdk_window_set_background (widget->window,
- &widget->style->base[GTK_WIDGET_STATE (widget)]);
-}
-
static void
gtk_cell_view_finalize (GObject *object)
{
- gtk_cell_view_cell_layout_clear (GTK_CELL_LAYOUT (object));
+ GtkCellView *cellview = GTK_CELL_VIEW (object);
+
+ gtk_cell_view_cell_layout_clear (GTK_CELL_LAYOUT (cellview));
- if (G_OBJECT_CLASS (parent_class)->finalize)
- (* G_OBJECT_CLASS (parent_class)->finalize) (object);
+ if (cellview->priv->model)
+ g_object_unref (cellview->priv->model);
+
+ if (cellview->priv->displayed_row)
+ gtk_tree_row_reference_free (cellview->priv->displayed_row);
+
+ (* G_OBJECT_CLASS (gtk_cell_view_parent_class)->finalize) (object);
}
static void
GList *i;
GtkCellView *cellview;
GdkRectangle area;
+ GtkCellRendererState state;
gboolean rtl = (gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL);
cellview = GTK_CELL_VIEW (widget);
/* "blank" background */
if (cellview->priv->background_set)
{
- GdkGC *gc;
-
- gc = gdk_gc_new (GTK_WIDGET (cellview)->window);
- gdk_gc_set_rgb_fg_color (gc, &cellview->priv->background);
+ cairo_t *cr = gdk_cairo_create (GTK_WIDGET (cellview)->window);
- gdk_draw_rectangle (GTK_WIDGET (cellview)->window,
- gc,
- TRUE,
+ gdk_cairo_rectangle (cr, &widget->allocation);
+ cairo_set_source_rgb (cr,
+ cellview->priv->background.red / 65535.,
+ cellview->priv->background.green / 65535.,
+ cellview->priv->background.blue / 65535.);
+ cairo_fill (cr);
- /*0, 0,*/
- widget->allocation.x,
- widget->allocation.y,
-
- widget->allocation.width,
- widget->allocation.height);
-
- g_object_unref (G_OBJECT (gc));
+ cairo_destroy (cr);
}
- /* set cell data (if applicable) */
+ /* set cell data (if available) */
if (cellview->priv->displayed_row)
gtk_cell_view_set_cell_data (cellview);
+ else if (cellview->priv->model)
+ return FALSE;
/* render cells */
area = widget->allocation;
area.x = widget->allocation.x + (rtl ? widget->allocation.width : 0);
area.y = widget->allocation.y;
+ if (GTK_WIDGET_STATE (widget) == GTK_STATE_PRELIGHT)
+ state = GTK_CELL_RENDERER_PRELIT;
+ else
+ state = 0;
+
/* PACK_START */
for (i = cellview->priv->cell_list; i; i = i->next)
{
event->window,
widget,
/* FIXME! */
- &area, &area, &event->area, 0);
+ &area, &area, &event->area, state);
if (!rtl)
area.x += info->real_width;
widget->window,
widget,
/* FIXME ! */
- &area, &area, &event->area, 0);
+ &area, &area, &event->area, state);
if (rtl)
area.x += info->real_width;
}
}
static void
-gtk_cell_view_set_cell_data (GtkCellView *cellview)
+gtk_cell_view_set_cell_data (GtkCellView *cell_view)
{
GList *i;
GtkTreeIter iter;
GtkTreePath *path;
- g_return_if_fail (cellview->priv->displayed_row != NULL);
+ g_return_if_fail (cell_view->priv->displayed_row != NULL);
+
+ path = gtk_tree_row_reference_get_path (cell_view->priv->displayed_row);
+ if (!path)
+ return;
- path = gtk_tree_row_reference_get_path (cellview->priv->displayed_row);
- gtk_tree_model_get_iter (cellview->priv->model, &iter, path);
+ gtk_tree_model_get_iter (cell_view->priv->model, &iter, path);
gtk_tree_path_free (path);
- for (i = cellview->priv->cell_list; i; i = i->next)
+ for (i = cell_view->priv->cell_list; i; i = i->next)
{
GSList *j;
GtkCellViewCellInfo *info = i->data;
- if (info->func)
- {
- (* info->func) (GTK_CELL_LAYOUT (cellview),
- info->cell,
- cellview->priv->model,
- &iter,
- info->func_data);
- continue;
- }
+ g_object_freeze_notify (G_OBJECT (info->cell));
for (j = info->attributes; j && j->next; j = j->next->next)
{
gint column = GPOINTER_TO_INT (j->next->data);
GValue value = {0, };
- gtk_tree_model_get_value (cellview->priv->model, &iter,
+ gtk_tree_model_get_value (cell_view->priv->model, &iter,
column, &value);
g_object_set_property (G_OBJECT (info->cell),
property, &value);
g_value_unset (&value);
}
+
+ if (info->func)
+ (* info->func) (GTK_CELL_LAYOUT (cell_view),
+ info->cell,
+ cell_view->priv->model,
+ &iter,
+ info->func_data);
+
+ g_object_thaw_notify (G_OBJECT (info->cell));
}
}
GtkCellViewCellInfo *info;
GtkCellView *cellview = GTK_CELL_VIEW (layout);
- g_return_if_fail (GTK_IS_CELL_VIEW (cellview));
- g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
g_return_if_fail (!gtk_cell_view_get_cell_info (cellview, renderer));
- g_object_ref (G_OBJECT (renderer));
- gtk_object_sink (GTK_OBJECT (renderer));
+ g_object_ref_sink (renderer);
info = g_new0 (GtkCellViewCellInfo, 1);
info->cell = renderer;
GtkCellViewCellInfo *info;
GtkCellView *cellview = GTK_CELL_VIEW (layout);
- g_return_if_fail (GTK_IS_CELL_VIEW (cellview));
- g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
g_return_if_fail (!gtk_cell_view_get_cell_info (cellview, renderer));
- g_object_ref (G_OBJECT (renderer));
- gtk_object_sink (GTK_OBJECT (renderer));
+ g_object_ref_sink (renderer);
info = g_new0 (GtkCellViewCellInfo, 1);
info->cell = renderer;
GtkCellViewCellInfo *info;
GtkCellView *cellview = GTK_CELL_VIEW (layout);
- g_return_if_fail (GTK_IS_CELL_VIEW (cellview));
info = gtk_cell_view_get_cell_info (cellview, renderer);
g_return_if_fail (info != NULL);
static void
gtk_cell_view_cell_layout_clear (GtkCellLayout *layout)
{
- GList *i;
GtkCellView *cellview = GTK_CELL_VIEW (layout);
- g_return_if_fail (GTK_IS_CELL_VIEW (cellview));
-
- for (i = cellview->priv->cell_list; i; i = i->next)
+ while (cellview->priv->cell_list)
{
- GtkCellViewCellInfo *info = (GtkCellViewCellInfo *)i->data;
+ GtkCellViewCellInfo *info = (GtkCellViewCellInfo *)cellview->priv->cell_list->data;
gtk_cell_view_cell_layout_clear_attributes (layout, info->cell);
- g_object_unref (G_OBJECT (info->cell));
+ g_object_unref (info->cell);
g_free (info);
+ cellview->priv->cell_list = g_list_delete_link (cellview->priv->cell_list,
+ cellview->priv->cell_list);
}
-
- g_list_free (cellview->priv->cell_list);
- cellview->priv->cell_list = NULL;
}
static void
GtkCellView *cellview = GTK_CELL_VIEW (layout);
GtkCellViewCellInfo *info;
- g_return_if_fail (GTK_IS_CELL_VIEW (cellview));
-
info = gtk_cell_view_get_cell_info (cellview, cell);
g_return_if_fail (info != NULL);
gtk_cell_view_cell_layout_clear_attributes (GtkCellLayout *layout,
GtkCellRenderer *renderer)
{
- GtkCellViewCellInfo *info;
GtkCellView *cellview = GTK_CELL_VIEW (layout);
+ GtkCellViewCellInfo *info;
GSList *list;
- g_return_if_fail (GTK_IS_CELL_VIEW (cellview));
- g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
-
info = gtk_cell_view_get_cell_info (cellview, renderer);
- g_return_if_fail (info != NULL);
-
- list = info->attributes;
-
- while (list && list->next)
+ if (info != NULL)
{
- g_free (list->data);
- list = list->next->next;
+ list = info->attributes;
+ while (list && list->next)
+ {
+ g_free (list->data);
+ list = list->next->next;
+ }
+
+ g_slist_free (info->attributes);
+ info->attributes = NULL;
}
- g_slist_free (list);
-
- info->attributes = NULL;
}
static void
GtkCellRenderer *cell,
gint position)
{
- GList *link;
- GtkCellViewCellInfo *info;
GtkCellView *cellview = GTK_CELL_VIEW (layout);
-
- g_return_if_fail (GTK_IS_CELL_VIEW (cellview));
- g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
+ GtkCellViewCellInfo *info;
+ GList *link;
info = gtk_cell_view_get_cell_info (cellview, cell);
g_return_if_fail (link != NULL);
- cellview->priv->cell_list = g_list_remove_link (cellview->priv->cell_list,
+ cellview->priv->cell_list = g_list_delete_link (cellview->priv->cell_list,
link);
cellview->priv->cell_list = g_list_insert (cellview->priv->cell_list,
info, position);
gtk_widget_queue_draw (GTK_WIDGET (cellview));
}
-/* public API */
+/**
+ * gtk_cell_view_new:
+ *
+ * Creates a new #GtkCellView widget.
+ *
+ * Return value: A newly created #GtkCellView widget.
+ *
+ * Since: 2.6
+ */
GtkWidget *
gtk_cell_view_new (void)
{
GtkCellView *cellview;
- cellview = GTK_CELL_VIEW (g_object_new (gtk_cell_view_get_type (), NULL));
+ cellview = g_object_new (gtk_cell_view_get_type (), NULL);
return GTK_WIDGET (cellview);
}
+/**
+ * gtk_cell_view_new_with_text:
+ * @text: the text to display in the cell view
+ *
+ * Creates a new #GtkCellView widget, adds a #GtkCellRendererText
+ * to it, and makes its show @text.
+ *
+ * Return value: A newly created #GtkCellView widget.
+ *
+ * Since: 2.6
+ */
GtkWidget *
gtk_cell_view_new_with_text (const gchar *text)
{
g_value_init (&value, G_TYPE_STRING);
g_value_set_string (&value, text);
- gtk_cell_view_set_values (cellview, renderer, "text", &value, NULL);
+ gtk_cell_view_set_value (cellview, renderer, "text", &value);
g_value_unset (&value);
return GTK_WIDGET (cellview);
}
+/**
+ * gtk_cell_view_new_with_markup:
+ * @markup: the text to display in the cell view
+ *
+ * Creates a new #GtkCellView widget, adds a #GtkCellRendererText
+ * to it, and makes its show @markup. The text can text can be
+ * marked up with the <link linkend="PangoMarkupFormat">Pango text
+ * markup language</link>.
+ *
+ * Return value: A newly created #GtkCellView widget.
+ *
+ * Since: 2.6
+ */
GtkWidget *
gtk_cell_view_new_with_markup (const gchar *markup)
{
g_value_init (&value, G_TYPE_STRING);
g_value_set_string (&value, markup);
- gtk_cell_view_set_values (cellview, renderer, "markup", &value, NULL);
+ gtk_cell_view_set_value (cellview, renderer, "markup", &value);
g_value_unset (&value);
return GTK_WIDGET (cellview);
}
+/**
+ * gtk_cell_view_new_with_pixbuf:
+ * @pixbuf: the image to display in the cell view
+ *
+ * Creates a new #GtkCellView widget, adds a #GtkCellRendererPixbuf
+ * to it, and makes its show @pixbuf.
+ *
+ * Return value: A newly created #GtkCellView widget.
+ *
+ * Since: 2.6
+ */
GtkWidget *
gtk_cell_view_new_with_pixbuf (GdkPixbuf *pixbuf)
{
g_value_init (&value, GDK_TYPE_PIXBUF);
g_value_set_object (&value, pixbuf);
- gtk_cell_view_set_values (cellview, renderer, "pixbuf", &value, NULL);
+ gtk_cell_view_set_value (cellview, renderer, "pixbuf", &value);
g_value_unset (&value);
return GTK_WIDGET (cellview);
}
-void
+/**
+ * gtk_cell_view_set_value:
+ * @cell_view: a #GtkCellView widget
+ * @renderer: one of the renderers of @cell_view
+ * @property: the name of the property of @renderer to set
+ * @value: the new value to set the property to
+ *
+ * Sets a property of a cell renderer of @cell_view, and
+ * makes sure the display of @cell_view is updated.
+ *
+ * Since: 2.6
+ */
+static void
gtk_cell_view_set_value (GtkCellView *cell_view,
GtkCellRenderer *renderer,
gchar *property,
GValue *value)
{
- g_return_if_fail (GTK_IS_CELL_VIEW (cell_view));
- g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
-
g_object_set_property (G_OBJECT (renderer), property, value);
/* force resize and redraw */
gtk_widget_queue_draw (GTK_WIDGET (cell_view));
}
-static void
-gtk_cell_view_set_valuesv (GtkCellView *cell_view,
- GtkCellRenderer *renderer,
- va_list args)
-{
- gchar *attribute;
- GValue *value;
-
- attribute = va_arg (args, gchar *);
-
- while (attribute)
- {
- value = va_arg (args, GValue *);
- gtk_cell_view_set_value (cell_view, renderer, attribute, value);
- attribute = va_arg (args, gchar *);
- }
-}
-
-void
-gtk_cell_view_set_values (GtkCellView *cell_view,
- GtkCellRenderer *renderer,
- ...)
-{
- va_list args;
-
- g_return_if_fail (GTK_IS_CELL_VIEW (cell_view));
- g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
- g_return_if_fail (gtk_cell_view_get_cell_info (cell_view, renderer));
-
- va_start (args, renderer);
- gtk_cell_view_set_valuesv (cell_view, renderer, args);
- va_end (args);
-}
-
+/**
+ * gtk_cell_view_set_model:
+ * @cell_view: a #GtkCellView
+ * @model: a #GtkTreeModel
+ *
+ * Sets the model for @cell_view. If @cell_view already has a model
+ * set, it will remove it before setting the new model. If @model is
+ * %NULL, then it will unset the old model.
+ *
+ * Since: 2.6
+ */
void
gtk_cell_view_set_model (GtkCellView *cell_view,
GtkTreeModel *model)
{
g_return_if_fail (GTK_IS_CELL_VIEW (cell_view));
- g_return_if_fail (GTK_IS_TREE_MODEL (model));
+ g_return_if_fail (model == NULL || GTK_IS_TREE_MODEL (model));
if (cell_view->priv->model)
{
gtk_tree_row_reference_free (cell_view->priv->displayed_row);
cell_view->priv->displayed_row = NULL;
- g_object_unref (G_OBJECT (cell_view->priv->model));
+ g_object_unref (cell_view->priv->model);
cell_view->priv->model = NULL;
}
cell_view->priv->model = model;
if (cell_view->priv->model)
- g_object_ref (G_OBJECT (cell_view->priv->model));
+ g_object_ref (cell_view->priv->model);
}
+/**
+ * gtk_cell_view_set_displayed_row:
+ * @cell_view: a #GtkCellView
+ * @path: a #GtkTreePath or %NULL to unset.
+ *
+ * Sets the row of the model that is currently displayed
+ * by the #GtkCellView. If the path is unset, then the
+ * contents of the cellview "stick" at their last value;
+ * this is not normally a desired result, but may be
+ * a needed intermediate state if say, the model for
+ * the #GtkCellView becomes temporarily empty.
+ *
+ * Since: 2.6
+ **/
void
gtk_cell_view_set_displayed_row (GtkCellView *cell_view,
GtkTreePath *path)
{
g_return_if_fail (GTK_IS_CELL_VIEW (cell_view));
g_return_if_fail (GTK_IS_TREE_MODEL (cell_view->priv->model));
- g_return_if_fail (path != NULL);
if (cell_view->priv->displayed_row)
gtk_tree_row_reference_free (cell_view->priv->displayed_row);
- cell_view->priv->displayed_row =
- gtk_tree_row_reference_new (cell_view->priv->model, path);
+ if (path)
+ {
+ cell_view->priv->displayed_row =
+ gtk_tree_row_reference_new (cell_view->priv->model, path);
+ }
+ else
+ cell_view->priv->displayed_row = NULL;
/* force resize and redraw */
gtk_widget_queue_resize (GTK_WIDGET (cell_view));
gtk_widget_queue_draw (GTK_WIDGET (cell_view));
}
+/**
+ * gtk_cell_view_get_displayed_row:
+ * @cell_view: a #GtkCellView
+ *
+ * Returns a #GtkTreePath referring to the currently
+ * displayed row. If no row is currently displayed,
+ * %NULL is returned.
+ *
+ * Returns: the currently displayed row or %NULL
+ *
+ * Since: 2.6
+ */
GtkTreePath *
gtk_cell_view_get_displayed_row (GtkCellView *cell_view)
{
return gtk_tree_row_reference_get_path (cell_view->priv->displayed_row);
}
+/**
+ * gtk_cell_view_get_size_of_row:
+ * @cell_view: a #GtkCellView
+ * @path: a #GtkTreePath
+ * @requisition: return location for the size
+ *
+ * Sets @requisition to the size needed by @cell_view to display
+ * the model row pointed to by @path.
+ *
+ * Return value: %TRUE
+ *
+ * Since: 2.6
+ */
gboolean
gtk_cell_view_get_size_of_row (GtkCellView *cell_view,
GtkTreePath *path,
GtkRequisition *requisition)
{
GtkTreeRowReference *tmp;
+ GtkRequisition req;
g_return_val_if_fail (GTK_IS_CELL_VIEW (cell_view), FALSE);
g_return_val_if_fail (path != NULL, FALSE);
gtk_tree_row_reference_free (cell_view->priv->displayed_row);
cell_view->priv->displayed_row = tmp;
+ /* restore actual size info */
+ gtk_cell_view_size_request (GTK_WIDGET (cell_view), &req);
+
return TRUE;
}
+/**
+ * gtk_cell_view_set_background_color:
+ * @cell_view: a #GtkCellView
+ * @color: the new background color
+ *
+ * Sets the background color of @view.
+ *
+ * Since: 2.6
+ */
void
-gtk_cell_view_set_background_color (GtkCellView *view,
- GdkColor *color)
+gtk_cell_view_set_background_color (GtkCellView *cell_view,
+ const GdkColor *color)
{
- g_return_if_fail (GTK_IS_CELL_VIEW (view));
+ g_return_if_fail (GTK_IS_CELL_VIEW (cell_view));
if (color)
{
- if (!view->priv->background_set)
+ if (!cell_view->priv->background_set)
{
- view->priv->background_set = TRUE;
- g_object_notify (G_OBJECT (view), "background_set");
+ cell_view->priv->background_set = TRUE;
+ g_object_notify (G_OBJECT (cell_view), "background-set");
}
- view->priv->background = *color;
+ cell_view->priv->background = *color;
}
else
{
- if (view->priv->background_set)
+ if (cell_view->priv->background_set)
{
- view->priv->background_set = FALSE;
- g_object_notify (G_OBJECT (view), "background_set");
+ cell_view->priv->background_set = FALSE;
+ g_object_notify (G_OBJECT (cell_view), "background-set");
}
}
+
+ gtk_widget_queue_draw (GTK_WIDGET (cell_view));
+}
+
+/**
+ * gtk_cell_view_get_cell_renderers:
+ * @cell_view: a #GtkCellView
+ *
+ * Returns the cell renderers which have been added to @cell_view.
+ *
+ * Return value: a list of cell renderers. The list, but not the
+ * renderers has been newly allocated and should be freed with
+ * g_list_free() when no longer needed.
+ *
+ * Since: 2.6
+ */
+GList *
+gtk_cell_view_get_cell_renderers (GtkCellView *cell_view)
+{
+ GList *retval = NULL, *list;
+
+ g_return_val_if_fail (cell_view != NULL, NULL);
+
+ gtk_cell_view_set_cell_data (cell_view);
+
+ for (list = cell_view->priv->cell_list; list; list = list->next)
+ {
+ GtkCellViewCellInfo *info = (GtkCellViewCellInfo *)list->data;
+
+ retval = g_list_prepend (retval, info->cell);
+ }
+
+ return g_list_reverse (retval);
+}
+
+static GList *
+gtk_cell_view_cell_layout_get_cells (GtkCellLayout *layout)
+{
+ return gtk_cell_view_get_cell_renderers (GTK_CELL_VIEW (layout));
+}
+
+
+static gboolean
+gtk_cell_view_buildable_custom_tag_start (GtkBuildable *buildable,
+ GtkBuilder *builder,
+ GObject *child,
+ const gchar *tagname,
+ GMarkupParser *parser,
+ gpointer *data)
+{
+ if (parent_buildable_iface->custom_tag_start (buildable, builder, child,
+ tagname, parser, data))
+ return TRUE;
+
+ return _gtk_cell_layout_buildable_custom_tag_start (buildable, builder, child,
+ tagname, parser, data);
}
+
+static void
+gtk_cell_view_buildable_custom_tag_end (GtkBuildable *buildable,
+ GtkBuilder *builder,
+ GObject *child,
+ const gchar *tagname,
+ gpointer *data)
+{
+ if (strcmp (tagname, "attributes") == 0)
+ _gtk_cell_layout_buildable_custom_tag_end (buildable, builder, child, tagname,
+ data);
+ else
+ parent_buildable_iface->custom_tag_end (buildable, builder, child, tagname,
+ data);
+}
+
+
+#define __GTK_CELL_VIEW_C__
+#include "gtkaliasdef.c"
projects / ~andy / gtk / blobdiff