Checked in initial draft of the new tree widget.

2000-10-04    <jrb@redhat.com>

	* gtk/gtk{tree,cell}?*.[ch]: Checked in initial draft of the new
	tree widget.

ChangeLog

+2000-10-04    <jrb@redhat.com>
+
+	* gtk/gtk{tree,cell}?*.[ch]: Checked in initial draft of the new
+	tree widget.
+
 2000-10-04  Jonathan Blandford  <jrb@redhat.com>
 
 	* gdk/gdkwindow.c (gdk_window_draw_arc): Fix obvious bug in circle

ChangeLog.pre-2-0

+2000-10-04    <jrb@redhat.com>
+
+	* gtk/gtk{tree,cell}?*.[ch]: Checked in initial draft of the new
+	tree widget.
+
 2000-10-04  Jonathan Blandford  <jrb@redhat.com>
 
 	* gdk/gdkwindow.c (gdk_window_draw_arc): Fix obvious bug in circle

ChangeLog.pre-2-10

+2000-10-04    <jrb@redhat.com>
+
+	* gtk/gtk{tree,cell}?*.[ch]: Checked in initial draft of the new
+	tree widget.
+
 2000-10-04  Jonathan Blandford  <jrb@redhat.com>
 
 	* gdk/gdkwindow.c (gdk_window_draw_arc): Fix obvious bug in circle

ChangeLog.pre-2-2

+2000-10-04    <jrb@redhat.com>
+
+	* gtk/gtk{tree,cell}?*.[ch]: Checked in initial draft of the new
+	tree widget.
+
 2000-10-04  Jonathan Blandford  <jrb@redhat.com>
 
 	* gdk/gdkwindow.c (gdk_window_draw_arc): Fix obvious bug in circle

ChangeLog.pre-2-4

+2000-10-04    <jrb@redhat.com>
+
+	* gtk/gtk{tree,cell}?*.[ch]: Checked in initial draft of the new
+	tree widget.
+
 2000-10-04  Jonathan Blandford  <jrb@redhat.com>
 
 	* gdk/gdkwindow.c (gdk_window_draw_arc): Fix obvious bug in circle

ChangeLog.pre-2-6

+2000-10-04    <jrb@redhat.com>
+
+	* gtk/gtk{tree,cell}?*.[ch]: Checked in initial draft of the new
+	tree widget.
+
 2000-10-04  Jonathan Blandford  <jrb@redhat.com>
 
 	* gdk/gdkwindow.c (gdk_window_draw_arc): Fix obvious bug in circle

ChangeLog.pre-2-8

+2000-10-04    <jrb@redhat.com>
+
+	* gtk/gtk{tree,cell}?*.[ch]: Checked in initial draft of the new
+	tree widget.
+
 2000-10-04  Jonathan Blandford  <jrb@redhat.com>
 
 	* gdk/gdkwindow.c (gdk_window_draw_arc): Fix obvious bug in circle

gtk/gtkcellrenderer.c

+/* gtkcellrenderer.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 "gtkcellrenderer.h"
+
+#ifndef _
+#define _(x) x
+#endif
+
+static void gtk_cell_renderer_init       (GtkCellRenderer      *cell);
+static void gtk_cell_renderer_class_init (GtkCellRendererClass *class);
+static void gtk_cell_renderer_get_param  (GObject              *object,
+					  guint                 param_id,
+					  GValue               *value,
+					  GParamSpec           *pspec,
+					  const gchar          *trailer);
+static void gtk_cell_renderer_set_param  (GObject              *object,
+					  guint                 param_id,
+					  GValue               *value,
+					  GParamSpec           *pspec,
+					  const gchar          *trailer);
+
+
+enum {
+  PROP_ZERO,
+  PROP_XALIGN,
+  PROP_YALIGN,
+  PROP_XPAD,
+  PROP_YPAD
+};
+
+
+GtkType
+gtk_cell_renderer_get_type (void)
+{
+  static GtkType cell_type = 0;
+
+  if (!cell_type)
+    {
+      static const GTypeInfo cell_info =
+      {
+        sizeof (GtkCellRendererClass),
+	NULL,		/* base_init */
+	NULL,		/* base_finalize */
+        (GClassInitFunc) gtk_cell_renderer_class_init,
+	NULL,		/* class_finalize */
+	NULL,		/* class_data */
+        sizeof (GtkCellRenderer),
+	0,
+        (GInstanceInitFunc) gtk_cell_renderer_init,
+      };
+
+      cell_type = g_type_register_static (GTK_TYPE_OBJECT, "GtkCellRenderer", &cell_info);
+    }
+
+  return cell_type;
+}
+
+static void
+gtk_cell_renderer_init (GtkCellRenderer *cell)
+{
+  cell->xpad = 0;
+  cell->ypad = 0;
+  cell->xalign = 0.5;
+  cell->yalign = 0.5;
+}
+
+static void
+gtk_cell_renderer_class_init (GtkCellRendererClass *class)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
+
+  object_class->get_param = gtk_cell_renderer_get_param;
+  object_class->set_param = gtk_cell_renderer_set_param;
+
+  class->render = NULL;
+  class->get_size = NULL;
+
+
+  g_object_class_install_param (object_class,
+				PROP_XALIGN,
+				g_param_spec_float ("xalign",
+						    _("xalign"),
+						    _("The x-align."),
+						    0.0,
+						    1.0,
+						    0.0,
+						    G_PARAM_READABLE |
+						    G_PARAM_WRITABLE));
+
+  g_object_class_install_param (object_class,
+				PROP_YALIGN,
+				g_param_spec_float ("yalign",
+						    _("yalign"),
+						    _("The y-align."),
+						    0.0,
+						    1.0,
+						    0.5,
+						    G_PARAM_READABLE |
+						    G_PARAM_WRITABLE));
+
+  g_object_class_install_param (object_class,
+				PROP_XPAD,
+				g_param_spec_uint ("xpad",
+						   _("xpad"),
+						   _("The xpad."),
+						   0,
+						   100,
+						   2,
+						   G_PARAM_READABLE |
+						   G_PARAM_WRITABLE));
+
+  g_object_class_install_param (object_class,
+				PROP_YPAD,
+				g_param_spec_uint ("ypad",
+						   _("ypad"),
+						   _("The ypad."),
+						   0,
+						   100,
+						   2,
+						   G_PARAM_READABLE |
+						   G_PARAM_WRITABLE));
+}
+
+static void
+gtk_cell_renderer_get_param (GObject     *object,
+			     guint        param_id,
+			     GValue      *value,
+			     GParamSpec  *pspec,
+			     const gchar *trailer)
+{
+  GtkCellRenderer *cell = GTK_CELL_RENDERER (object);
+
+  switch (param_id)
+    {
+    case PROP_XALIGN:
+      g_value_init (value, G_TYPE_FLOAT);
+      g_value_set_float (value, cell->xalign);
+      break;
+    case PROP_YALIGN:
+      g_value_init (value, G_TYPE_FLOAT);
+      g_value_set_float (value, cell->yalign);
+      break;
+    case PROP_XPAD:
+      g_value_init (value, G_TYPE_INT);
+      g_value_set_float (value, cell->xpad);
+      break;
+    case PROP_YPAD:
+      g_value_init (value, G_TYPE_INT);
+      g_value_set_float (value, cell->ypad);
+      break;
+    default:
+      break;
+    }
+
+}
+
+static void
+gtk_cell_renderer_set_param (GObject     *object,
+			     guint        param_id,
+			     GValue      *value,
+			     GParamSpec  *pspec,
+			     const gchar *trailer)
+{
+  GtkCellRenderer *cell = GTK_CELL_RENDERER (object);
+
+  switch (param_id)
+    {
+    case PROP_XALIGN:
+      cell->xalign = g_value_get_float (value);
+      break;
+    case PROP_YALIGN:
+      cell->yalign = g_value_get_float (value);
+      break;
+    case PROP_XPAD:
+      cell->xpad = g_value_get_int (value);
+      break;
+    case PROP_YPAD:
+      cell->ypad = g_value_get_int (value);
+      break;
+    default:
+      break;
+    }
+}
+
+void
+gtk_cell_renderer_get_size (GtkCellRenderer *cell,
+			    GtkWidget *widget,
+			    gint      *width,
+			    gint      *height)
+{
+  /* It's actually okay to pass in a NULL cell, as we run into that
+   * a lot */
+  if (cell == NULL)
+    return;
+  g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
+  g_return_if_fail (GTK_CELL_RENDERER_GET_CLASS (cell)->get_size != NULL);
+
+  GTK_CELL_RENDERER_GET_CLASS (cell)->get_size (cell, widget, width, height);
+}
+
+void
+gtk_cell_renderer_render (GtkCellRenderer *cell,
+			  GdkWindow       *window,
+			  GtkWidget       *widget,
+			  GdkRectangle    *background_area,
+			  GdkRectangle    *cell_area,
+			  GdkRectangle    *expose_area,
+			  guint            flags)
+{
+  /* It's actually okay to pass in a NULL cell, as we run into that
+   * a lot */
+  if (cell == NULL)
+    return;
+  g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
+  g_return_if_fail (GTK_CELL_RENDERER_GET_CLASS (cell)->render != NULL);
+
+  GTK_CELL_RENDERER_GET_CLASS (cell)->render (cell,
+					      window,
+					      widget,
+					      background_area,
+					      cell_area,
+					      expose_area,
+					      flags);
+}
+
+gint
+gtk_cell_renderer_event (GtkCellRenderer *cell,
+			 GdkEvent        *event,
+			 GtkWidget       *widget,
+			 gchar           *path,
+			 GdkRectangle    *background_area,
+			 GdkRectangle    *cell_area,
+			 guint            flags)
+{
+  /* It's actually okay to pass in a NULL cell, as we run into that
+   * a lot */
+  if (cell == NULL)
+    return FALSE;
+  g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), FALSE);
+  if (GTK_CELL_RENDERER_GET_CLASS (cell)->event == NULL)
+    return FALSE;
+
+  return GTK_CELL_RENDERER_GET_CLASS (cell)->event (cell,
+						    event,
+						    widget,
+						    path,
+						    background_area,
+						    cell_area,
+						    flags);
+}
+

gtk/gtkcellrenderer.h

+/* gtkcellrenderer.h
+ * Copyright (C) 2000  Red Hat, Inc.,  Jonathan Blandford <jrb@redhat.com>
+ *
+ * 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_H__
+#define __GTK_CELL_RENDERER_H__
+
+#include <gtk/gtkobject.h>
+#include <gtk/gtkwidget.h>
+
+#ifdef __cplusplus
+extern "C" {
+
+#endif /* __cplusplus */
+
+typedef enum
+{
+  GTK_CELL_RENDERER_SELECTED = 1 << 0,
+  GTK_CELL_RENDERER_PRELIT = 1 << 1,
+  GTK_CELL_RENDERER_INSENSITIVE = 1 << 2
+} GtkCellRendererType;
+
+#define GTK_TYPE_CELL_RENDERER		  (gtk_cell_renderer_get_type ())
+#define GTK_CELL_RENDERER(obj)		  (GTK_CHECK_CAST ((obj), GTK_TYPE_CELL_RENDERER, GtkCellRenderer))
+#define GTK_CELL_RENDERER_CLASS(klass)	  (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_RENDERER, GtkCellRendererClass))
+#define GTK_IS_CELL_RENDERER(obj)	  (GTK_CHECK_TYPE ((obj), GTK_TYPE_CELL_RENDERER))
+#define GTK_IS_CELL_RENDERER_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((obj), GTK_TYPE_CELL_RENDERER))
+#define GTK_CELL_RENDERER_GET_CLASS(obj)  (GTK_CHECK_GET_CLASS ((obj), GTK_TYPE_CELL_RENDERER, GtkCellRendererClass))
+
+typedef struct _GtkCellRenderer GtkCellRenderer;
+typedef struct _GtkCellRendererClass GtkCellRendererClass;
+
+struct _GtkCellRenderer
+{
+  GtkObject parent;
+
+  gfloat xalign;
+  gfloat yalign;
+
+  guint16 xpad;
+  guint16 ypad;
+};
+
+struct _GtkCellRendererClass
+{
+  GtkObjectClass parent_class;
+
+  /* vtable - not signals */
+  void (* get_size) (GtkCellRenderer *cell,
+		     GtkWidget       *widget,
+		     gint            *width,
+		     gint            *height);
+  void (* render)   (GtkCellRenderer *cell,
+		     GdkWindow       *window,
+		     GtkWidget       *widget,
+		     GdkRectangle    *background_area,
+		     GdkRectangle    *cell_area,
+		     GdkRectangle    *expose_area,
+		     guint            flags);
+
+  gint (* event)    (GtkCellRenderer *cell,
+		     GdkEvent        *event,
+		     GtkWidget       *widget,
+		     gchar           *path,
+		     GdkRectangle    *background_area,
+		     GdkRectangle    *cell_area,
+		     guint            flags);
+};
+
+
+GtkType gtk_cell_renderer_get_type (void);
+void    gtk_cell_renderer_get_size (GtkCellRenderer *cell,
+				    GtkWidget       *widget,
+				    gint            *width,
+				    gint            *height);
+void    gtk_cell_renderer_render   (GtkCellRenderer *cell,
+				    GdkWindow       *window,
+				    GtkWidget       *widget,
+				    GdkRectangle    *background_area,
+				    GdkRectangle    *cell_area,
+				    GdkRectangle    *expose_area,
+				    guint            flags);
+gint    gtk_cell_renderer_event    (GtkCellRenderer *cell,
+				    GdkEvent        *event,
+				    GtkWidget       *widget,
+				    gchar           *path,
+				    GdkRectangle    *background_area,
+				    GdkRectangle    *cell_area,
+				    guint            flags);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GTK_CELL_RENDERER_H__ */

gtk/gtkcellrendererpixbuf.c

+/* gtkcellrendererpixbuf.c
+ * Copyright (C) 2000  Red Hat, Inc.,  Jonathan Blandford <jrb@redhat.com>
+ *
+ * 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 <stdlib.h>
+#include "gtkcellrendererpixbuf.h"
+
+#ifndef _
+#define _(x) x
+#endif
+
+
+static void gtk_cell_renderer_pixbuf_get_param  (GObject                    *object,
+						 guint                       param_id,
+						 GValue                     *value,
+						 GParamSpec                 *pspec,
+						 const gchar                *trailer);
+static void gtk_cell_renderer_pixbuf_set_param  (GObject                    *object,
+						 guint                       param_id,
+						 GValue                     *value,
+						 GParamSpec                 *pspec,
+						 const gchar                *trailer);
+static void gtk_cell_renderer_pixbuf_init       (GtkCellRendererPixbuf      *celltext);
+static void gtk_cell_renderer_pixbuf_class_init (GtkCellRendererPixbufClass *class);
+static void gtk_cell_renderer_pixbuf_get_size   (GtkCellRenderer            *cell,
+						 GtkWidget                  *widget,
+						 gint                       *width,
+						 gint                       *height);
+static void gtk_cell_renderer_pixbuf_render     (GtkCellRenderer            *cell,
+						 GdkWindow                  *window,
+						 GtkWidget                  *widget,
+						 GdkRectangle               *background_area,
+						 GdkRectangle               *cell_area,
+						 GdkRectangle               *expose_area,
+						 guint                       flags);
+
+
+enum {
+	PROP_ZERO,
+	PROP_PIXBUF
+};
+
+
+GtkType
+gtk_cell_renderer_pixbuf_get_type (void)
+{
+	static GtkType cell_pixbuf_type = 0;
+
+	if (!cell_pixbuf_type)
+	{
+		static const GTypeInfo cell_pixbuf_info =
+		{
+			sizeof (GtkCellRendererPixbufClass),
+			NULL,		/* base_init */
+			NULL,		/* base_finalize */
+			(GClassInitFunc) gtk_cell_renderer_pixbuf_class_init,
+			NULL,		/* class_finalize */
+			NULL,		/* class_data */
+			sizeof (GtkCellRendererPixbuf),
+			0,              /* n_preallocs */
+			(GInstanceInitFunc) gtk_cell_renderer_pixbuf_init,
+		};
+
+		cell_pixbuf_type = g_type_register_static (GTK_TYPE_CELL_RENDERER, "GtkCellRendererPixbuf", &cell_pixbuf_info);
+	}
+
+	return cell_pixbuf_type;
+}
+
+static void
+gtk_cell_renderer_pixbuf_init (GtkCellRendererPixbuf *cellpixbuf)
+{
+}
+
+static void
+gtk_cell_renderer_pixbuf_class_init (GtkCellRendererPixbufClass *class)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS (class);
+	GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS (class);
+
+	object_class->get_param = gtk_cell_renderer_pixbuf_get_param;
+	object_class->set_param = gtk_cell_renderer_pixbuf_set_param;
+
+	cell_class->get_size = gtk_cell_renderer_pixbuf_get_size;
+	cell_class->render = gtk_cell_renderer_pixbuf_render;
+
+	g_object_class_install_param (object_class,
+				      PROP_PIXBUF,
+				      g_param_spec_object ("pixbuf",
+							   _("Pixbuf Object"),
+							   _("The pixbuf to render."),
+							   GDK_TYPE_PIXBUF,
+							   G_PARAM_READABLE |
+							   G_PARAM_WRITABLE));
+}
+
+static void
+gtk_cell_renderer_pixbuf_get_param (GObject        *object,
+				    guint           param_id,
+				    GValue         *value,
+				    GParamSpec     *pspec,
+				    const gchar    *trailer)
+{
+	GtkCellRendererPixbuf *cellpixbuf = GTK_CELL_RENDERER_PIXBUF (object);
+
+	switch (param_id)
+	{
+	case PROP_PIXBUF:
+		g_value_init (value, G_TYPE_OBJECT);
+		g_value_set_object (value, G_OBJECT (cellpixbuf->pixbuf));
+		break;
+	default:
+		break;
+	}
+}
+
+
+static void
+gtk_cell_renderer_pixbuf_set_param (GObject     *object,
+				    guint        param_id,
+				    GValue      *value,
+				    GParamSpec  *pspec,
+				    const gchar *trailer)
+{
+	GdkPixbuf *pixbuf;
+	GtkCellRendererPixbuf *cellpixbuf = GTK_CELL_RENDERER_PIXBUF (object);
+
+	switch (param_id)
+	{
+	case PROP_PIXBUF:
+		pixbuf = GDK_PIXBUF (g_value_get_object (value));
+		g_object_ref (G_OBJECT (pixbuf));
+		if (cellpixbuf->pixbuf)
+			g_object_unref (G_OBJECT (cellpixbuf->pixbuf));
+		cellpixbuf->pixbuf = pixbuf;
+		break;
+	default:
+		break;
+	}
+}
+
+GtkCellRenderer *
+gtk_cell_renderer_pixbuf_new (void)
+{
+	return GTK_CELL_RENDERER (gtk_type_new (gtk_cell_renderer_pixbuf_get_type ()));
+}
+
+static void
+gtk_cell_renderer_pixbuf_get_size (GtkCellRenderer *cell,
+				   GtkWidget       *widget,
+				   gint            *width,
+				   gint            *height)
+{
+	GtkCellRendererPixbuf *cellpixbuf = (GtkCellRendererPixbuf *) cell;
+
+	if (width)
+		*width = (gint) GTK_CELL_RENDERER (cellpixbuf)->xpad * 2 +
+			(cellpixbuf->pixbuf ? gdk_pixbuf_get_width (cellpixbuf->pixbuf) : 0);
+
+	if (height)
+		*height = (gint) GTK_CELL_RENDERER (cellpixbuf)->ypad * 2 +
+			(cellpixbuf->pixbuf ? gdk_pixbuf_get_height (cellpixbuf->pixbuf) : 0);
+}
+
+static void
+gtk_cell_renderer_pixbuf_render (GtkCellRenderer    *cell,
+				 GdkWindow          *window,
+				 GtkWidget          *widget,
+				 GdkRectangle       *background_area,
+				 GdkRectangle       *cell_area,
+				 GdkRectangle       *expose_area,
+				 guint               flags)
+
+{
+	GtkCellRendererPixbuf *cellpixbuf = (GtkCellRendererPixbuf *) cell;
+	GdkPixbuf *pixbuf;
+	guchar *pixels;
+	gint rowstride;
+	gint real_xoffset;
+	gint real_yoffset;
+	GdkGC *bg_gc = NULL;
+
+	pixbuf = cellpixbuf->pixbuf;
+
+	if (!pixbuf)
+		return;
+
+	if ((flags & GTK_CELL_RENDERER_SELECTED) == GTK_CELL_RENDERER_SELECTED)
+		bg_gc = widget->style->bg_gc [GTK_STATE_SELECTED];
+	else
+		bg_gc = widget->style->base_gc [GTK_STATE_NORMAL];
+
+	gdk_gc_set_clip_rectangle (bg_gc, cell_area);
+
+	rowstride = gdk_pixbuf_get_rowstride (pixbuf);
+	pixels = gdk_pixbuf_get_pixels (pixbuf);
+
+	real_xoffset = GTK_CELL_RENDERER (cellpixbuf)->xalign * (cell_area->width - gdk_pixbuf_get_width (pixbuf) - (2 * GTK_CELL_RENDERER (cellpixbuf)->xpad));
+	real_xoffset = MAX (real_xoffset, 0) + GTK_CELL_RENDERER (cellpixbuf)->xpad;
+	real_yoffset = GTK_CELL_RENDERER (cellpixbuf)->yalign * (cell_area->height - gdk_pixbuf_get_height (pixbuf) - (2 * GTK_CELL_RENDERER (cellpixbuf)->ypad));
+	real_yoffset = MAX (real_yoffset, 0) + GTK_CELL_RENDERER (cellpixbuf)->ypad;
+
+	if (gdk_pixbuf_get_has_alpha (pixbuf))
+		gdk_draw_rgb_32_image (window,
+				       bg_gc,
+				       cell_area->x + real_xoffset,
+				       cell_area->y + real_yoffset,
+				       gdk_pixbuf_get_width (pixbuf),
+				       gdk_pixbuf_get_height (pixbuf),
+				       GDK_RGB_DITHER_NORMAL,
+				       pixels,
+				       rowstride);
+	else
+		gdk_draw_rgb_image (window,
+				    bg_gc,
+				    cell_area->x + real_xoffset,
+				    cell_area->y + real_yoffset,
+				    gdk_pixbuf_get_width (pixbuf),
+				    gdk_pixbuf_get_height (pixbuf),
+				    GDK_RGB_DITHER_NORMAL,
+				    pixels,
+				    rowstride);
+
+	gdk_gc_set_clip_rectangle (bg_gc, NULL);
+}

gtk/gtkcellrendererpixbuf.h

+/* gtkcellrendererpixbuf.h
+ * Copyright (C) 2000  Red Hat, Inc.,  Jonathan Blandford <jrb@redhat.com>
+ *
+ * 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_PIXBUF_H__
+#define __GTK_CELL_RENDERER_PIXBUF_H__
+
+#include <gtk/gtkcellrenderer.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+#define GTK_TYPE_CELL_RENDERER_PIXBUF			(gtk_cell_renderer_pixbuf_get_type ())
+#define GTK_CELL_RENDERER_PIXBUF(obj)			(GTK_CHECK_CAST ((obj), GTK_TYPE_CELL_RENDERER_PIXBUF, GtkCellRendererPixbuf))
+#define GTK_CELL_RENDERER_PIXBUF_CLASS(klass)		(GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_RENDERER_PIXBUF, GtkCellRendererPixbufClass))
+#define GTK_IS_CELL_RENDERER_PIXBUF(obj)		(GTK_CHECK_TYPE ((obj), GTK_TYPE_CELL_RENDERER_PIXBUF))
+#define GTK_IS_CELL_RENDERER_PIXBUF_CLASS(klass)	(GTK_CHECK_CLASS_TYPE ((obj), GTK_TYPE_CELL_RENDERER_PIXBUF))
+
+typedef struct _GtkCellRendererPixbuf GtkCellRendererPixbuf;
+typedef struct _GtkCellRendererPixbufClass GtkCellRendererPixbufClass;