[evolution/foocanvas: 3/4] Substitute FooCanvas identifiers for GnomeCanvas.



commit 5e20faf86c9214e62336c8e35325980bfe43a548
Author: Matthew Barnes <mbarnes redhat com>
Date:   Wed Jan 13 15:09:13 2010 -0500

    Substitute FooCanvas identifiers for GnomeCanvas.
    
    Changes here are purely automated substitutions: no hand edits.
    The hand edits are in the subsequent commit.  This is so we can
    easily distinguish the semantic changes between GnomeCanvas and
    FooCanvas from mere namespace changes.
    
    s/GnomeCanvas/FooCanvas/
    s/gnome_canvas/foo_canvas/
    s/gnome-canvas/foo-canvas/
    s/libgnomecanvas/libfoocanvas/
    s/GNOME_CANVAS/FOO_CANVAS/
    s/GNOME_IS_CANVAS/FOO_IS_CANVAS/
    s/GNOME_TYPE_CANVAS/FOO_TYPE_CANVAS/

 .../gui/widgets/e-addressbook-reflow-adapter.c     |   16 +-
 addressbook/gui/widgets/e-minicard-label.c         |   98 +++++-----
 addressbook/gui/widgets/e-minicard-label.h         |   16 +-
 addressbook/gui/widgets/e-minicard-view-widget.c   |   20 +-
 addressbook/gui/widgets/e-minicard-view-widget.h   |    4 +-
 addressbook/gui/widgets/e-minicard-view.c          |   20 +-
 addressbook/gui/widgets/e-minicard.c               |  150 +++++++-------
 addressbook/gui/widgets/e-minicard.h               |   16 +-
 addressbook/gui/widgets/ea-addressbook.c           |    2 +-
 addressbook/gui/widgets/ea-minicard-view.c         |    2 +-
 addressbook/gui/widgets/ea-minicard.c              |    2 +-
 calendar/gui/e-cal-list-view.c                     |    4 +-
 calendar/gui/e-calendar-view.h                     |    2 +-
 calendar/gui/e-day-view-main-item.c                |   18 +-
 calendar/gui/e-day-view-main-item.h                |    4 +-
 calendar/gui/e-day-view-time-item.c                |   42 ++--
 calendar/gui/e-day-view-time-item.h                |    4 +-
 calendar/gui/e-day-view-top-item.c                 |   18 +-
 calendar/gui/e-day-view-top-item.h                 |    4 +-
 calendar/gui/e-day-view.c                          |  210 ++++++++++----------
 calendar/gui/e-day-view.h                          |   36 ++--
 calendar/gui/e-meeting-time-sel-item.c             |   74 ++++----
 calendar/gui/e-meeting-time-sel-item.h             |    8 +-
 calendar/gui/e-meeting-time-sel.c                  |   36 ++--
 calendar/gui/e-meeting-time-sel.h                  |    6 +-
 calendar/gui/e-memo-table.c                        |    4 +-
 calendar/gui/e-task-table.c                        |    4 +-
 calendar/gui/e-week-view-event-item.c              |   44 ++--
 calendar/gui/e-week-view-event-item.h              |    4 +-
 calendar/gui/e-week-view-main-item.c               |   18 +-
 calendar/gui/e-week-view-main-item.h               |    4 +-
 calendar/gui/e-week-view-titles-item.c             |   18 +-
 calendar/gui/e-week-view-titles-item.h             |    4 +-
 calendar/gui/e-week-view.c                         |   94 +++++-----
 calendar/gui/e-week-view.h                         |   16 +-
 calendar/gui/ea-cal-view-event.c                   |   20 +-
 calendar/gui/ea-calendar-helpers.c                 |   16 +-
 calendar/gui/ea-calendar-helpers.h                 |    6 +-
 calendar/gui/ea-calendar.c                         |   16 +-
 calendar/gui/ea-day-view-cell.c                    |    4 +-
 calendar/gui/ea-jump-button.c                      |   20 +-
 calendar/gui/ea-week-view-cell.c                   |    4 +-
 calendar/gui/ea-week-view.c                        |    2 +-
 calendar/gui/goto.c                                |    4 +-
 calendar/gui/weekday-picker.c                      |   42 ++--
 calendar/gui/weekday-picker.h                      |    6 +-
 mail/message-list.c                                |    2 +-
 widgets/misc/e-calendar-item.c                     |  140 +++++++-------
 widgets/misc/e-calendar-item.h                     |    6 +-
 widgets/misc/e-calendar.c                          |   54 +++---
 widgets/misc/e-calendar.h                          |    6 +-
 widgets/misc/e-canvas-background.c                 |   60 +++---
 widgets/misc/e-canvas-background.h                 |    6 +-
 widgets/misc/e-canvas-utils.c                      |   40 ++--
 widgets/misc/e-canvas-utils.h                      |   10 +-
 widgets/misc/e-canvas-vbox.c                       |   72 ++++----
 widgets/misc/e-canvas-vbox.h                       |   16 +-
 widgets/misc/e-canvas.c                            |  132 ++++++------
 widgets/misc/e-canvas.h                            |   40 ++--
 widgets/misc/e-dateedit.c                          |   10 +-
 widgets/misc/ea-calendar-cell.c                    |    4 +-
 widgets/misc/ea-calendar-item.c                    |    8 +-
 widgets/table/e-cell-checkbox.c                    |    2 +-
 widgets/table/e-cell-combo.c                       |   10 +-
 widgets/table/e-cell-date-edit.c                   |   12 +-
 widgets/table/e-cell-hbox.h                        |    2 +-
 widgets/table/e-cell-pixbuf.c                      |    6 +-
 widgets/table/e-cell-popup.c                       |    2 +-
 widgets/table/e-cell-popup.h                       |    2 +-
 widgets/table/e-cell-text.c                        |   50 +++---
 widgets/table/e-cell-text.h                        |    6 +-
 widgets/table/e-cell-toggle.c                      |    6 +-
 widgets/table/e-cell-toggle.h                      |    2 +-
 widgets/table/e-cell-tree.c                        |    6 +-
 widgets/table/e-cell-tree.h                        |    2 +-
 widgets/table/e-cell-vbox.h                        |    2 +-
 widgets/table/e-table-click-to-add.c               |   64 +++---
 widgets/table/e-table-click-to-add.h               |   12 +-
 widgets/table/e-table-field-chooser-item.c         |   92 +++++-----
 widgets/table/e-table-field-chooser-item.h         |    6 +-
 widgets/table/e-table-field-chooser.c              |   26 ++--
 widgets/table/e-table-field-chooser.h              |    6 +-
 widgets/table/e-table-group-container.c            |   66 +++---
 widgets/table/e-table-group-container.h            |   12 +-
 widgets/table/e-table-group-leaf.c                 |   42 ++--
 widgets/table/e-table-group-leaf.h                 |    4 +-
 widgets/table/e-table-group.c                      |   22 +-
 widgets/table/e-table-group.h                      |   10 +-
 widgets/table/e-table-header-item.c                |  108 +++++-----
 widgets/table/e-table-header-item.h                |    8 +-
 widgets/table/e-table-item.c                       |  188 +++++++++---------
 widgets/table/e-table-item.h                       |    6 +-
 widgets/table/e-table-tooltip.h                    |    4 +-
 widgets/table/e-table.c                            |   94 +++++-----
 widgets/table/e-table.h                            |   14 +-
 widgets/table/e-tree.c                             |   82 ++++----
 widgets/table/e-tree.h                             |    4 +-
 widgets/table/gal-a11y-e-cell-popup.c              |    2 +-
 widgets/table/gal-a11y-e-cell-toggle.c             |    6 +-
 widgets/table/gal-a11y-e-cell.c                    |    4 +-
 widgets/table/gal-a11y-e-table-click-to-add.c      |    6 +-
 widgets/table/gal-a11y-e-table-item.c              |    4 +-
 widgets/table/gal-a11y-e-table.c                   |    8 +-
 widgets/text/e-reflow-model.c                      |   16 +-
 widgets/text/e-reflow-model.h                      |   16 +-
 widgets/text/e-reflow.c                            |  156 ++++++++--------
 widgets/text/e-reflow.h                            |   12 +-
 widgets/text/e-text.c                              |  166 ++++++++--------
 widgets/text/e-text.h                              |    8 +-
 widgets/text/gal-a11y-e-text.c                     |   14 +-
 110 files changed, 1583 insertions(+), 1583 deletions(-)
---
diff --git a/addressbook/gui/widgets/e-addressbook-reflow-adapter.c b/addressbook/gui/widgets/e-addressbook-reflow-adapter.c
index 5928f51..8a8d0a2 100644
--- a/addressbook/gui/widgets/e-addressbook-reflow-adapter.c
+++ b/addressbook/gui/widgets/e-addressbook-reflow-adapter.c
@@ -132,7 +132,7 @@ addressbook_count (EReflowModel *erm)
 
 /* This function returns the height of the minicontact in question */
 static gint
-addressbook_height (EReflowModel *erm, gint i, GnomeCanvasGroup *parent)
+addressbook_height (EReflowModel *erm, gint i, FooCanvasGroup *parent)
 {
 	EAddressbookReflowAdapter *adapter = E_ADDRESSBOOK_REFLOW_ADAPTER(erm);
 	EAddressbookReflowAdapterPrivate *priv = adapter->priv;
@@ -140,7 +140,7 @@ addressbook_height (EReflowModel *erm, gint i, GnomeCanvasGroup *parent)
 	gint count = 0;
 	gchar *string;
 	EContact *contact = (EContact*)e_addressbook_model_contact_at (priv->model, i);
-	PangoLayout *layout = gtk_widget_create_pango_layout (GTK_WIDGET (GNOME_CANVAS_ITEM (parent)->canvas), "");
+	PangoLayout *layout = gtk_widget_create_pango_layout (GTK_WIDGET (FOO_CANVAS_ITEM (parent)->canvas), "");
 	gint height;
 
 	string = e_contact_get(contact, E_CONTACT_FILE_AS);
@@ -239,14 +239,14 @@ adapter_open_contact (EMinicard *card,
 	g_signal_emit (adapter, signals[OPEN_CONTACT], 0, contact);
 }
 
-static GnomeCanvasItem *
-addressbook_incarnate (EReflowModel *erm, gint i, GnomeCanvasGroup *parent)
+static FooCanvasItem *
+addressbook_incarnate (EReflowModel *erm, gint i, FooCanvasGroup *parent)
 {
 	EAddressbookReflowAdapter *adapter = E_ADDRESSBOOK_REFLOW_ADAPTER(erm);
 	EAddressbookReflowAdapterPrivate *priv = adapter->priv;
-	GnomeCanvasItem *item;
+	FooCanvasItem *item;
 
-	item = gnome_canvas_item_new(parent,
+	item = foo_canvas_item_new(parent,
 				     e_minicard_get_type(),
 				     "contact", e_addressbook_model_contact_at (priv->model, i),
 				     "editable", e_addressbook_model_get_editable (priv->model),
@@ -267,12 +267,12 @@ addressbook_incarnate (EReflowModel *erm, gint i, GnomeCanvasGroup *parent)
 }
 
 static void
-addressbook_reincarnate (EReflowModel *erm, gint i, GnomeCanvasItem *item)
+addressbook_reincarnate (EReflowModel *erm, gint i, FooCanvasItem *item)
 {
 	EAddressbookReflowAdapter *adapter = E_ADDRESSBOOK_REFLOW_ADAPTER(erm);
 	EAddressbookReflowAdapterPrivate *priv = adapter->priv;
 
-	gnome_canvas_item_set(item,
+	foo_canvas_item_set(item,
 			      "contact", e_addressbook_model_contact_at (priv->model, i),
 			      NULL);
 }
diff --git a/addressbook/gui/widgets/e-minicard-label.c b/addressbook/gui/widgets/e-minicard-label.c
index 074bf9f..7617fb4 100644
--- a/addressbook/gui/widgets/e-minicard-label.c
+++ b/addressbook/gui/widgets/e-minicard-label.c
@@ -25,7 +25,7 @@
 #include "e-minicard-label.h"
 
 #include <gtk/gtk.h>
-#include <libgnomecanvas/gnome-canvas-rect-ellipse.h>
+#include <libfoocanvas/foo-canvas-rect-ellipse.h>
 #include <glib/gi18n.h>
 #include <e-util/e-util.h>
 #include <text/e-text.h>
@@ -37,17 +37,17 @@ static void e_minicard_label_init		(EMinicardLabel		 *card);
 static void e_minicard_label_class_init	(EMinicardLabelClass	 *klass);
 static void e_minicard_label_set_property  (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
 static void e_minicard_label_get_property  (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
-static gboolean e_minicard_label_event (GnomeCanvasItem *item, GdkEvent *event);
-static void e_minicard_label_realize (GnomeCanvasItem *item);
-static void e_minicard_label_unrealize (GnomeCanvasItem *item);
-static void e_minicard_label_reflow(GnomeCanvasItem *item, gint flags);
+static gboolean e_minicard_label_event (FooCanvasItem *item, GdkEvent *event);
+static void e_minicard_label_realize (FooCanvasItem *item);
+static void e_minicard_label_unrealize (FooCanvasItem *item);
+static void e_minicard_label_reflow(FooCanvasItem *item, gint flags);
 static void e_minicard_label_style_set (EMinicardLabel *label, GtkStyle *previous_style);
 
 static void e_minicard_label_resize_children( EMinicardLabel *e_minicard_label );
 
 static void set_colors (EMinicardLabel *label);
 
-static GnomeCanvasGroupClass *parent_class = NULL;
+static FooCanvasGroupClass *parent_class = NULL;
 
 /* The arguments we take */
 enum {
@@ -87,7 +87,7 @@ e_minicard_label_get_type (void)
 			(GInstanceInitFunc) e_minicard_label_init,
 		};
 
-		type = g_type_register_static (gnome_canvas_group_get_type (), "EMinicardLabel", &info, 0);
+		type = g_type_register_static (foo_canvas_group_get_type (), "EMinicardLabel", &info, 0);
 	}
 
 	return type;
@@ -97,10 +97,10 @@ static void
 e_minicard_label_class_init (EMinicardLabelClass *klass)
 {
 	GObjectClass *object_class;
-	GnomeCanvasItemClass *item_class;
+	FooCanvasItemClass *item_class;
 
 	object_class = G_OBJECT_CLASS (klass);
-	item_class = (GnomeCanvasItemClass *) klass;
+	item_class = (FooCanvasItemClass *) klass;
 
 	klass->style_set = e_minicard_label_style_set;
 
@@ -176,7 +176,7 @@ e_minicard_label_class_init (EMinicardLabelClass *klass)
 			      G_TYPE_NONE, 1,
 			      GTK_TYPE_STYLE);
 
-	/* GnomeCanvasItem method overrides */
+	/* FooCanvasItem method overrides */
 	item_class->realize     = e_minicard_label_realize;
 	item_class->unrealize   = e_minicard_label_unrealize;
 	item_class->event       = e_minicard_label_event;
@@ -193,17 +193,17 @@ e_minicard_label_init (EMinicardLabel *minicard_label)
 
   minicard_label->max_field_name_length = -1;
 
-  e_canvas_item_set_reflow_callback(GNOME_CANVAS_ITEM(minicard_label), e_minicard_label_reflow);
+  e_canvas_item_set_reflow_callback(FOO_CANVAS_ITEM(minicard_label), e_minicard_label_reflow);
 }
 
 static void
 e_minicard_label_set_property  (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
 {
 	EMinicardLabel *e_minicard_label;
-	GnomeCanvasItem *item;
+	FooCanvasItem *item;
 
 	e_minicard_label = E_MINICARD_LABEL (object);
-	item = GNOME_CANVAS_ITEM (object);
+	item = FOO_CANVAS_ITEM (object);
 
 	switch (prop_id) {
 	case PROP_WIDTH:
@@ -216,13 +216,13 @@ e_minicard_label_set_property  (GObject *object, guint prop_id, const GValue *va
 			e_canvas_item_grab_focus(e_minicard_label->field, FALSE);
 		break;
 	case PROP_FIELD:
-		gnome_canvas_item_set( e_minicard_label->field, "text", g_value_get_string (value), NULL );
+		foo_canvas_item_set( e_minicard_label->field, "text", g_value_get_string (value), NULL );
 		break;
 	case PROP_FIELDNAME:
-		gnome_canvas_item_set( e_minicard_label->fieldname, "text", g_value_get_string (value), NULL );
+		foo_canvas_item_set( e_minicard_label->fieldname, "text", g_value_get_string (value), NULL );
 		break;
 	case PROP_TEXT_MODEL:
-		gnome_canvas_item_set( e_minicard_label->field, "model", g_value_get_object (value), NULL);
+		foo_canvas_item_set( e_minicard_label->field, "model", g_value_get_object (value), NULL);
 		break;
 	case PROP_MAX_FIELD_NAME_WIDTH:
 		e_minicard_label->max_field_name_length = g_value_get_double (value);
@@ -279,22 +279,22 @@ e_minicard_label_get_property  (GObject *object, guint prop_id, GValue *value, G
 }
 
 static void
-e_minicard_label_realize (GnomeCanvasItem *item)
+e_minicard_label_realize (FooCanvasItem *item)
 {
 	EMinicardLabel *e_minicard_label;
-	GnomeCanvasGroup *group;
+	FooCanvasGroup *group;
 
 	e_minicard_label = E_MINICARD_LABEL (item);
-	group = GNOME_CANVAS_GROUP( item );
+	group = FOO_CANVAS_GROUP( item );
 
-	if (GNOME_CANVAS_ITEM_CLASS( parent_class )->realize)
-		(* GNOME_CANVAS_ITEM_CLASS( parent_class )->realize) (item);
+	if (FOO_CANVAS_ITEM_CLASS( parent_class )->realize)
+		(* FOO_CANVAS_ITEM_CLASS( parent_class )->realize) (item);
 
 	e_canvas_item_request_reflow(item);
 
 	e_minicard_label->rect =
-	  gnome_canvas_item_new( group,
-				 gnome_canvas_rect_get_type(),
+	  foo_canvas_item_new( group,
+				 foo_canvas_rect_get_type(),
 				 "x1", (double) 0,
 				 "y1", (double) 0,
 				 "x2", (double) e_minicard_label->width - 1,
@@ -302,7 +302,7 @@ e_minicard_label_realize (GnomeCanvasItem *item)
 				 "outline_color", NULL,
 				 NULL );
 	e_minicard_label->fieldname =
-	  gnome_canvas_item_new( group,
+	  foo_canvas_item_new( group,
 				 e_text_get_type(),
 				 "anchor", GTK_ANCHOR_NW,
 				 "clip_width", (double) ( e_minicard_label->width / 2 - 4 ),
@@ -315,7 +315,7 @@ e_minicard_label_realize (GnomeCanvasItem *item)
 	e_canvas_item_move_absolute(e_minicard_label->fieldname, 2, 1);
 
 	e_minicard_label->field =
-	  gnome_canvas_item_new( group,
+	  foo_canvas_item_new( group,
 				 e_text_get_type(),
 				 "anchor", GTK_ANCHOR_NW,
 				 "clip_width", (double) ( ( e_minicard_label->width + 1 ) / 2 - 4 ),
@@ -334,14 +334,14 @@ e_minicard_label_realize (GnomeCanvasItem *item)
 }
 
 static void
-e_minicard_label_unrealize (GnomeCanvasItem *item)
+e_minicard_label_unrealize (FooCanvasItem *item)
 {
-	if (GNOME_CANVAS_ITEM_CLASS( parent_class )->unrealize)
-		(* GNOME_CANVAS_ITEM_CLASS( parent_class )->unrealize) (item);
+	if (FOO_CANVAS_ITEM_CLASS( parent_class )->unrealize)
+		(* FOO_CANVAS_ITEM_CLASS( parent_class )->unrealize) (item);
 }
 
 static gboolean
-e_minicard_label_event (GnomeCanvasItem *item, GdkEvent *event)
+e_minicard_label_event (FooCanvasItem *item, GdkEvent *event)
 {
 	EMinicardLabel *e_minicard_label;
 
@@ -350,11 +350,11 @@ e_minicard_label_event (GnomeCanvasItem *item, GdkEvent *event)
 	switch ( event->type ) {
 	case GDK_KEY_PRESS:
 		if (event->key.keyval == GDK_Escape) {
-			GnomeCanvasItem *parent;
+			FooCanvasItem *parent;
 
 			e_text_cancel_editing (E_TEXT (e_minicard_label->field));
 
-			parent = GNOME_CANVAS_ITEM (e_minicard_label)->parent;
+			parent = FOO_CANVAS_ITEM (e_minicard_label)->parent;
 			if (parent)
 				e_canvas_item_grab_focus(parent, FALSE);
 		}
@@ -383,8 +383,8 @@ e_minicard_label_event (GnomeCanvasItem *item, GdkEvent *event)
 		break;
 	}
 
-	if (GNOME_CANVAS_ITEM_CLASS( parent_class )->event)
-		return (* GNOME_CANVAS_ITEM_CLASS( parent_class )->event) (item, event);
+	if (FOO_CANVAS_ITEM_CLASS( parent_class )->event)
+		return (* FOO_CANVAS_ITEM_CLASS( parent_class )->event) (item, event);
 	else
 		return 0;
 }
@@ -403,10 +403,10 @@ e_minicard_label_resize_children(EMinicardLabel *e_minicard_label)
 
 	fieldnamewidth = (double) MAX ( left_width, 0 );
 	fieldwidth = (double) MAX ( e_minicard_label->width - 8 - left_width, 0 );
-	gnome_canvas_item_set( e_minicard_label->fieldname,
+	foo_canvas_item_set( e_minicard_label->fieldname,
 			       "clip_width", is_rtl ? fieldwidth : fieldnamewidth,
 			       NULL );
-	gnome_canvas_item_set( e_minicard_label->field,
+	foo_canvas_item_set( e_minicard_label->field,
 			       "clip_width", is_rtl ? fieldnamewidth : fieldwidth,
 			       NULL );
 }
@@ -414,34 +414,34 @@ e_minicard_label_resize_children(EMinicardLabel *e_minicard_label)
 static void
 set_colors (EMinicardLabel *label)
 {
-	if ( (GTK_OBJECT_FLAGS( label ) & GNOME_CANVAS_ITEM_REALIZED) ) {
-		GtkWidget *canvas = GTK_WIDGET (GNOME_CANVAS_ITEM (label)->canvas);
+	if ( (GTK_OBJECT_FLAGS( label ) & FOO_CANVAS_ITEM_REALIZED) ) {
+		GtkWidget *canvas = GTK_WIDGET (FOO_CANVAS_ITEM (label)->canvas);
 		GtkStyle *style = gtk_widget_get_style (canvas);
 		if (label->has_focus) {
-			gnome_canvas_item_set (label->rect,
+			foo_canvas_item_set (label->rect,
 					       "outline_color_gdk", &style->mid[GTK_STATE_SELECTED],
 					       "fill_color_gdk", &style->bg[GTK_STATE_NORMAL],
 					       NULL);
 
-			gnome_canvas_item_set (label->field,
+			foo_canvas_item_set (label->field,
 					       "fill_color_gdk", &canvas->style->text[GTK_STATE_NORMAL],
 					       NULL);
 
-			gnome_canvas_item_set (label->fieldname,
+			foo_canvas_item_set (label->fieldname,
 					       "fill_color_gdk", &canvas->style->text[GTK_STATE_NORMAL],
 					       NULL);
 		}
 		else {
-			gnome_canvas_item_set (label->rect,
+			foo_canvas_item_set (label->rect,
 					       "outline_color_gdk", NULL,
 					       "fill_color_gdk", NULL,
 					       NULL);
 
-			gnome_canvas_item_set (label->field,
+			foo_canvas_item_set (label->field,
 					       "fill_color_gdk", &canvas->style->text[GTK_STATE_NORMAL],
 					       NULL);
 
-			gnome_canvas_item_set (label->fieldname,
+			foo_canvas_item_set (label->fieldname,
 					       "fill_color_gdk", &canvas->style->text[GTK_STATE_NORMAL],
 					       NULL);
 		}
@@ -455,7 +455,7 @@ e_minicard_label_style_set (EMinicardLabel *label, GtkStyle *previous_style)
 }
 
 static void
-e_minicard_label_reflow(GnomeCanvasItem *item, gint flags)
+e_minicard_label_reflow(FooCanvasItem *item, gint flags)
 {
 	EMinicardLabel *e_minicard_label = E_MINICARD_LABEL(item);
 
@@ -479,12 +479,12 @@ e_minicard_label_reflow(GnomeCanvasItem *item, gint flags)
 		e_minicard_label->height = text_height;
 	e_minicard_label->height += 3;
 
-	gnome_canvas_item_set( e_minicard_label->rect,
+	foo_canvas_item_set( e_minicard_label->rect,
 			       "x2", (double) e_minicard_label->width - 1,
 			       "y2", (double) e_minicard_label->height - 1,
 			       NULL );
 
-	gnome_canvas_item_set( e_minicard_label->fieldname,
+	foo_canvas_item_set( e_minicard_label->fieldname,
 			       "clip_height", (double) e_minicard_label->height - 3,
 			       NULL );
 
@@ -499,10 +499,10 @@ e_minicard_label_reflow(GnomeCanvasItem *item, gint flags)
 		e_canvas_item_request_parent_reflow(item);
 }
 
-GnomeCanvasItem *
-e_minicard_label_new(GnomeCanvasGroup *parent)
+FooCanvasItem *
+e_minicard_label_new(FooCanvasGroup *parent)
 {
-	GnomeCanvasItem *item = gnome_canvas_item_new(parent, e_minicard_label_get_type(), NULL);
+	FooCanvasItem *item = foo_canvas_item_new(parent, e_minicard_label_get_type(), NULL);
 	return item;
 }
 
diff --git a/addressbook/gui/widgets/e-minicard-label.h b/addressbook/gui/widgets/e-minicard-label.h
index 6031b80..d932af7 100644
--- a/addressbook/gui/widgets/e-minicard-label.h
+++ b/addressbook/gui/widgets/e-minicard-label.h
@@ -24,7 +24,7 @@
 #define __E_MINICARD_LABEL_H__
 
 #include <glib.h>
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 
 G_BEGIN_DECLS
 
@@ -51,30 +51,30 @@ typedef struct _EMinicardLabelClass  EMinicardLabelClass;
 
 struct _EMinicardLabel
 {
-	GnomeCanvasGroup parent;
+	FooCanvasGroup parent;
 
 	/* item specific fields */
 	double width;
 	double height;
 	double max_field_name_length;
 	guint editable : 1;
-	GnomeCanvasItem *fieldname;
-	GnomeCanvasItem *field;
-	GnomeCanvasItem *rect;
+	FooCanvasItem *fieldname;
+	FooCanvasItem *field;
+	FooCanvasItem *rect;
 
 	gboolean has_focus;
 };
 
 struct _EMinicardLabelClass
 {
-	GnomeCanvasGroupClass parent_class;
+	FooCanvasGroupClass parent_class;
 
 	void (* style_set) (EMinicardLabel *label, GtkStyle *previous_style);
 };
 
 GType      e_minicard_label_get_type (void);
-GnomeCanvasItem *e_minicard_label_new(GnomeCanvasGroup *parent);
-void e_minicard_label_construct (GnomeCanvasItem *item);
+FooCanvasItem *e_minicard_label_new(FooCanvasGroup *parent);
+void e_minicard_label_construct (FooCanvasItem *item);
 
 G_END_DECLS
 
diff --git a/addressbook/gui/widgets/e-minicard-view-widget.c b/addressbook/gui/widgets/e-minicard-view-widget.c
index cb39047..67171f6 100644
--- a/addressbook/gui/widgets/e-minicard-view-widget.c
+++ b/addressbook/gui/widgets/e-minicard-view-widget.c
@@ -363,7 +363,7 @@ e_minicard_view_widget_style_set (GtkWidget *widget, GtkStyle *previous_style)
 	EMinicardViewWidget *view = E_MINICARD_VIEW_WIDGET(widget);
 
 	if (view->background)
-		gnome_canvas_item_set (view->background,
+		foo_canvas_item_set (view->background,
 				       "fill_color_gdk", &widget->style->base[GTK_STATE_NORMAL],
 				       NULL );
 
@@ -377,13 +377,13 @@ e_minicard_view_widget_realize (GtkWidget *widget)
 	EMinicardViewWidget *view = E_MINICARD_VIEW_WIDGET(widget);
 	GtkStyle *style = gtk_widget_get_style (widget);
 
-	view->background = gnome_canvas_item_new(gnome_canvas_root( GNOME_CANVAS(view) ),
+	view->background = foo_canvas_item_new(foo_canvas_root( FOO_CANVAS(view) ),
 						 e_canvas_background_get_type(),
 						 "fill_color_gdk", &style->base[GTK_STATE_NORMAL],
 						 NULL );
 
-	view->emv = gnome_canvas_item_new(
-		gnome_canvas_root( GNOME_CANVAS(view) ),
+	view->emv = foo_canvas_item_new(
+		foo_canvas_root( FOO_CANVAS(view) ),
 		e_minicard_view_get_type(),
 		"height", (double) 100,
 		"minimum_width", (double) 100,
@@ -424,17 +424,17 @@ e_minicard_view_widget_size_allocate(GtkWidget *widget, GtkAllocation *allocatio
 		double width;
 		EMinicardViewWidget *view = E_MINICARD_VIEW_WIDGET(widget);
 
-		gnome_canvas_item_set( view->emv,
+		foo_canvas_item_set( view->emv,
 				       "height", (double) allocation->height,
 				       NULL );
-		gnome_canvas_item_set( view->emv,
+		foo_canvas_item_set( view->emv,
 				       "minimum_width", (double) allocation->width,
 				       NULL );
 		g_object_get(view->emv,
 			     "width", &width,
 			     NULL);
 		width = MAX(width, allocation->width);
-		gnome_canvas_set_scroll_region (GNOME_CANVAS (view), 0, 0, width - 1, allocation->height - 1);
+		foo_canvas_set_scroll_region (FOO_CANVAS (view), 0, 0, width - 1, allocation->height - 1);
 	}
 }
 
@@ -451,7 +451,7 @@ e_minicard_view_widget_reflow(ECanvas *canvas)
 		     "width", &width,
 		     NULL);
 	width = MAX(width, GTK_WIDGET(canvas)->allocation.width);
-	gnome_canvas_set_scroll_region(GNOME_CANVAS(canvas), 0, 0, width - 1, GTK_WIDGET(canvas)->allocation.height - 1);
+	foo_canvas_set_scroll_region(FOO_CANVAS(canvas), 0, 0, width - 1, GTK_WIDGET(canvas)->allocation.height - 1);
 }
 
 ESelectionModel *
@@ -475,10 +475,10 @@ e_minicard_view_widget_get_view             (EMinicardViewWidget       *view)
 static gboolean
 e_minicard_view_widget_real_focus_in_event(GtkWidget *widget, GdkEventFocus *event)
 {
-	GnomeCanvas *canvas;
+	FooCanvas *canvas;
 	EMinicardViewWidget *view;
 
-	canvas = GNOME_CANVAS (widget);
+	canvas = FOO_CANVAS (widget);
 	view = E_MINICARD_VIEW_WIDGET(widget);
 
 	if (!canvas->focused_item) {
diff --git a/addressbook/gui/widgets/e-minicard-view-widget.h b/addressbook/gui/widgets/e-minicard-view-widget.h
index bf9fe8d..72ea6c3 100644
--- a/addressbook/gui/widgets/e-minicard-view-widget.h
+++ b/addressbook/gui/widgets/e-minicard-view-widget.h
@@ -42,8 +42,8 @@ struct _EMinicardViewWidget
 {
 	ECanvas parent;
 
-	GnomeCanvasItem *background;
-	GnomeCanvasItem *emv;
+	FooCanvasItem *background;
+	FooCanvasItem *emv;
 
 	EAddressbookReflowAdapter *adapter;
 
diff --git a/addressbook/gui/widgets/e-minicard-view.c b/addressbook/gui/widgets/e-minicard-view.c
index c3c6cf1..45c752c 100644
--- a/addressbook/gui/widgets/e-minicard-view.c
+++ b/addressbook/gui/widgets/e-minicard-view.c
@@ -141,11 +141,11 @@ e_minicard_view_drag_begin (EAddressbookReflowAdapter *adapter,
 
 	target_list = gtk_target_list_new (drag_types, G_N_ELEMENTS (drag_types));
 
-	context = gtk_drag_begin (GTK_WIDGET (GNOME_CANVAS_ITEM (view)->canvas),
+	context = gtk_drag_begin (GTK_WIDGET (FOO_CANVAS_ITEM (view)->canvas),
 				  target_list, actions, 1/*XXX*/, event);
 
 	if (!view->canvas_drag_data_get_id)
-		view->canvas_drag_data_get_id = g_signal_connect (GNOME_CANVAS_ITEM (view)->canvas,
+		view->canvas_drag_data_get_id = g_signal_connect (FOO_CANVAS_ITEM (view)->canvas,
 								  "drag_data_get",
 								  G_CALLBACK (e_minicard_view_drag_data_get),
 								  view);
@@ -337,7 +337,7 @@ e_minicard_view_dispose (GObject *object)
 	clear_drag_data (view);
 
 	if (view->canvas_drag_data_get_id) {
-		g_signal_handler_disconnect (GNOME_CANVAS_ITEM (view)->canvas,
+		g_signal_handler_disconnect (FOO_CANVAS_ITEM (view)->canvas,
 					     view->canvas_drag_data_get_id);
 		view->canvas_drag_data_get_id = 0;
 	}
@@ -376,7 +376,7 @@ e_minicard_view_right_click (EMinicardView *view, GdkEvent *event)
 }
 
 static gboolean
-e_minicard_view_event (GnomeCanvasItem *item, GdkEvent *event)
+e_minicard_view_event (FooCanvasItem *item, GdkEvent *event)
 {
 	EMinicardView *view;
 
@@ -408,15 +408,15 @@ e_minicard_view_event (GnomeCanvasItem *item, GdkEvent *event)
 		break;
 	}
 
-	if (GNOME_CANVAS_ITEM_CLASS(parent_class)->event)
-		return GNOME_CANVAS_ITEM_CLASS(parent_class)->event(item, event);
+	if (FOO_CANVAS_ITEM_CLASS(parent_class)->event)
+		return FOO_CANVAS_ITEM_CLASS(parent_class)->event(item, event);
 	else
 		return FALSE;
 }
 
 static gint
 e_minicard_view_selection_event (EReflow *reflow,
-                                 GnomeCanvasItem *item,
+                                 FooCanvasItem *item,
                                  GdkEvent *event)
 {
 	EMinicardView *view;
@@ -509,11 +509,11 @@ static void
 e_minicard_view_class_init (EMinicardViewClass *klass)
 {
 	GObjectClass *object_class;
-	GnomeCanvasItemClass *item_class;
+	FooCanvasItemClass *item_class;
 	EReflowClass *reflow_class;
 
 	object_class = G_OBJECT_CLASS (klass);
-	item_class = (GnomeCanvasItemClass *) klass;
+	item_class = (FooCanvasItemClass *) klass;
 	reflow_class = (EReflowClass *) klass;
 
 	parent_class = g_type_class_peek_parent (klass);
@@ -578,7 +578,7 @@ e_minicard_view_class_init (EMinicardViewClass *klass)
 	item_class->event             = e_minicard_view_event;
 
 	reflow_class->selection_event = e_minicard_view_selection_event;
-	/* GnomeCanvasItem method overrides */
+	/* FooCanvasItem method overrides */
 
 	/* init the accessibility support for e_minicard_view */
 	e_minicard_view_a11y_init();
diff --git a/addressbook/gui/widgets/e-minicard.c b/addressbook/gui/widgets/e-minicard.c
index a3d7e3a..2a89989 100644
--- a/addressbook/gui/widgets/e-minicard.c
+++ b/addressbook/gui/widgets/e-minicard.c
@@ -24,8 +24,8 @@
 #include <string.h>
 #include <gdk/gdkkeysyms.h>
 #include <glib/gi18n.h>
-#include <libgnomecanvas/gnome-canvas-rect-ellipse.h>
-#include <libgnomecanvas/gnome-canvas-pixbuf.h>
+#include <libfoocanvas/foo-canvas-rect-ellipse.h>
+#include <libfoocanvas/foo-canvas-pixbuf.h>
 #include <text/e-text.h>
 #include <e-util/e-util.h>
 #include <misc/e-canvas-utils.h>
@@ -46,10 +46,10 @@ static void e_minicard_set_property  (GObject *object, guint prop_id, const GVal
 static void e_minicard_get_property  (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
 static void e_minicard_dispose (GObject *object);
 static void e_minicard_finalize (GObject *object);
-static gboolean e_minicard_event (GnomeCanvasItem *item, GdkEvent *event);
-static void e_minicard_realize (GnomeCanvasItem *item);
-static void e_minicard_unrealize (GnomeCanvasItem *item);
-static void e_minicard_reflow ( GnomeCanvasItem *item, gint flags );
+static gboolean e_minicard_event (FooCanvasItem *item, GdkEvent *event);
+static void e_minicard_realize (FooCanvasItem *item);
+static void e_minicard_unrealize (FooCanvasItem *item);
+static void e_minicard_reflow ( FooCanvasItem *item, gint flags );
 static void e_minicard_style_set (EMinicard *minicard, GtkStyle *previous_style);
 
 static void e_minicard_resize_children( EMinicard *e_minicard );
@@ -121,7 +121,7 @@ e_minicard_get_type (void)
 			(GInstanceInitFunc) e_minicard_init,
 		};
 
-		type = g_type_register_static (gnome_canvas_group_get_type (), "EMinicard", &info, 0);
+		type = g_type_register_static (foo_canvas_group_get_type (), "EMinicard", &info, 0);
 	}
 
 	return type;
@@ -131,7 +131,7 @@ static void
 e_minicard_class_init (EMinicardClass *class)
 {
 	GObjectClass *object_class;
-	GnomeCanvasItemClass *item_class;
+	FooCanvasItemClass *item_class;
 
 	parent_class = g_type_class_peek_parent (class);
 
@@ -141,7 +141,7 @@ e_minicard_class_init (EMinicardClass *class)
 	object_class->dispose = e_minicard_dispose;
 	object_class->finalize = e_minicard_finalize;
 
-	item_class = GNOME_CANVAS_ITEM_CLASS (class);
+	item_class = FOO_CANVAS_ITEM_CLASS (class);
 	item_class->realize = e_minicard_realize;
 	item_class->unrealize = e_minicard_unrealize;
 	item_class->event = e_minicard_event;
@@ -261,31 +261,31 @@ e_minicard_init (EMinicard *minicard)
 
 	minicard->changed          = FALSE;
 
-	e_canvas_item_set_reflow_callback(GNOME_CANVAS_ITEM(minicard), e_minicard_reflow);
+	e_canvas_item_set_reflow_callback(FOO_CANVAS_ITEM(minicard), e_minicard_reflow);
 }
 
 static void
 set_selected (EMinicard *minicard, gboolean selected)
 {
-	GtkWidget *canvas = GTK_WIDGET(GNOME_CANVAS_ITEM(minicard)->canvas);
+	GtkWidget *canvas = GTK_WIDGET(FOO_CANVAS_ITEM(minicard)->canvas);
 	if (selected) {
-		gnome_canvas_item_set (minicard->rect,
+		foo_canvas_item_set (minicard->rect,
 				       "outline_color_gdk", &canvas->style->bg[GTK_STATE_ACTIVE],
 				       NULL);
-		gnome_canvas_item_set (minicard->header_rect,
+		foo_canvas_item_set (minicard->header_rect,
 				       "fill_color_gdk", &canvas->style->bg[GTK_STATE_SELECTED],
 				       NULL);
-		gnome_canvas_item_set (minicard->header_text,
+		foo_canvas_item_set (minicard->header_text,
 				       "fill_color_gdk", &canvas->style->text[GTK_STATE_SELECTED],
 				       NULL);
 	} else {
-		gnome_canvas_item_set (minicard->rect,
+		foo_canvas_item_set (minicard->rect,
 				       "outline_color", NULL,
 				       NULL);
-		gnome_canvas_item_set (minicard->header_rect,
+		foo_canvas_item_set (minicard->header_rect,
 				       "fill_color_gdk", &canvas->style->bg[GTK_STATE_NORMAL],
 				       NULL);
-		gnome_canvas_item_set (minicard->header_text,
+		foo_canvas_item_set (minicard->header_text,
 				       "fill_color_gdk", &canvas->style->text[GTK_STATE_NORMAL],
 				       NULL);
 	}
@@ -296,19 +296,19 @@ static void
 set_has_cursor (EMinicard *minicard, gboolean has_cursor)
 {
 	if (!minicard->has_focus && has_cursor)
-		e_canvas_item_grab_focus(GNOME_CANVAS_ITEM (minicard), FALSE);
+		e_canvas_item_grab_focus(FOO_CANVAS_ITEM (minicard), FALSE);
 	minicard->has_cursor = has_cursor;
 }
 
 static void
 e_minicard_set_property  (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
 {
-	GnomeCanvasItem *item;
+	FooCanvasItem *item;
 	EMinicard *e_minicard;
 	EContact *contact;
 	GList *l;
 
-	item = GNOME_CANVAS_ITEM (object);
+	item = FOO_CANVAS_ITEM (object);
 	e_minicard = E_MINICARD (object);
 
 	switch (prop_id) {
@@ -316,7 +316,7 @@ e_minicard_set_property  (GObject *object, guint prop_id, const GValue *value, G
 		if (e_minicard->width != g_value_get_double (value)) {
 			e_minicard->width = g_value_get_double (value);
 			e_minicard_resize_children(e_minicard);
-			if ( GTK_OBJECT_FLAGS( e_minicard ) & GNOME_CANVAS_ITEM_REALIZED )
+			if ( GTK_OBJECT_FLAGS( e_minicard ) & FOO_CANVAS_ITEM_REALIZED )
 				e_canvas_item_request_reflow(item);
 		}
 	  break;
@@ -324,11 +324,11 @@ e_minicard_set_property  (GObject *object, guint prop_id, const GValue *value, G
 		if (e_minicard->fields) {
 			if ( g_value_get_int(value) == E_FOCUS_START ||
 			     g_value_get_int(value) == E_FOCUS_CURRENT) {
-				gnome_canvas_item_set(E_MINICARD_FIELD(e_minicard->fields->data)->label,
+				foo_canvas_item_set(E_MINICARD_FIELD(e_minicard->fields->data)->label,
 						      "has_focus", g_value_get_int (value),
 						      NULL);
 			} else if ( g_value_get_int (value) == E_FOCUS_END ) {
-				gnome_canvas_item_set(E_MINICARD_FIELD(g_list_last(e_minicard->fields)->data)->label,
+				foo_canvas_item_set(E_MINICARD_FIELD(g_list_last(e_minicard->fields)->data)->label,
 						      "has_focus", g_value_get_int (value),
 						      NULL);
 			}
@@ -462,27 +462,27 @@ e_minicard_finalize (GObject *object)
 static void
 e_minicard_style_set (EMinicard *minicard, GtkStyle *previous_style)
 {
-	if ( (GTK_OBJECT_FLAGS( minicard ) & GNOME_CANVAS_ITEM_REALIZED) )
+	if ( (GTK_OBJECT_FLAGS( minicard ) & FOO_CANVAS_ITEM_REALIZED) )
 		set_selected (minicard, minicard->selected);
 }
 
 static void
-e_minicard_realize (GnomeCanvasItem *item)
+e_minicard_realize (FooCanvasItem *item)
 {
 	EMinicard *e_minicard;
-	GnomeCanvasGroup *group;
+	FooCanvasGroup *group;
 	GtkWidget *canvas;
 
 	e_minicard = E_MINICARD (item);
-	group = GNOME_CANVAS_GROUP( item );
-	canvas = GTK_WIDGET (GNOME_CANVAS_ITEM (item)->canvas);
+	group = FOO_CANVAS_GROUP( item );
+	canvas = GTK_WIDGET (FOO_CANVAS_ITEM (item)->canvas);
 
-	if (GNOME_CANVAS_ITEM_CLASS(parent_class)->realize)
-		(* GNOME_CANVAS_ITEM_CLASS(parent_class)->realize) (item);
+	if (FOO_CANVAS_ITEM_CLASS(parent_class)->realize)
+		(* FOO_CANVAS_ITEM_CLASS(parent_class)->realize) (item);
 
 	e_minicard->rect =
-	  gnome_canvas_item_new( group,
-				 gnome_canvas_rect_get_type(),
+	  foo_canvas_item_new( group,
+				 foo_canvas_rect_get_type(),
 				 "x1", (double) 0,
 				 "y1", (double) 0,
 				 "x2", (double) MAX (e_minicard->width - 1, 0),
@@ -491,8 +491,8 @@ e_minicard_realize (GnomeCanvasItem *item)
 				 NULL );
 
 	e_minicard->header_rect =
-	  gnome_canvas_item_new( group,
-				 gnome_canvas_rect_get_type(),
+	  foo_canvas_item_new( group,
+				 foo_canvas_rect_get_type(),
 				 "x1", (double) 2,
 				 "y1", (double) 2,
 				 "x2", (double) MAX (e_minicard->width - 3, 0),
@@ -501,7 +501,7 @@ e_minicard_realize (GnomeCanvasItem *item)
 				 NULL );
 
 	e_minicard->header_text =
-	  gnome_canvas_item_new( group,
+	  foo_canvas_item_new( group,
 				 e_text_get_type(),
 				 "anchor", GTK_ANCHOR_NW,
 				 "width", (double) MAX( e_minicard->width - 12, 0 ),
@@ -515,8 +515,8 @@ e_minicard_realize (GnomeCanvasItem *item)
 	e_canvas_item_move_absolute(e_minicard->header_text, 6, 6);
 
 	e_minicard->list_icon =
-		gnome_canvas_item_new ( group,
-					gnome_canvas_pixbuf_get_type(),
+		foo_canvas_item_new ( group,
+					foo_canvas_pixbuf_get_type(),
 					"pixbuf", e_minicard->list_icon_pixbuf,
 					NULL);
 
@@ -527,10 +527,10 @@ e_minicard_realize (GnomeCanvasItem *item)
 }
 
 static void
-e_minicard_unrealize (GnomeCanvasItem *item)
+e_minicard_unrealize (FooCanvasItem *item)
 {
-	if (GNOME_CANVAS_ITEM_CLASS(parent_class)->unrealize)
-		(* GNOME_CANVAS_ITEM_CLASS(parent_class)->unrealize) (item);
+	if (FOO_CANVAS_ITEM_CLASS(parent_class)->unrealize)
+		(* FOO_CANVAS_ITEM_CLASS(parent_class)->unrealize) (item);
 }
 
 void
@@ -542,7 +542,7 @@ e_minicard_activate_editor (EMinicard *minicard)
 }
 
 static gboolean
-e_minicard_event (GnomeCanvasItem *item, GdkEvent *event)
+e_minicard_event (FooCanvasItem *item, GdkEvent *event)
 {
 	EMinicard *e_minicard;
 
@@ -575,11 +575,11 @@ e_minicard_event (GnomeCanvasItem *item, GdkEvent *event)
 
 			e_canvas_item_grab_focus(item, TRUE);
 
-			if (gnome_canvas_item_grab (GNOME_CANVAS_ITEM (e_minicard),
+			if (foo_canvas_item_grab (FOO_CANVAS_ITEM (e_minicard),
 						    mask, NULL, event->button.time)) {
 				return FALSE;
 			}
-			gtk_grab_add (GTK_WIDGET (GNOME_CANVAS_ITEM (e_minicard)->canvas));
+			gtk_grab_add (GTK_WIDGET (FOO_CANVAS_ITEM (e_minicard)->canvas));
 			e_minicard->button_x = event->button.x;
 			e_minicard->button_y = event->button.y;
 			e_minicard->drag_button = event->button.button;
@@ -600,9 +600,9 @@ e_minicard_event (GnomeCanvasItem *item, GdkEvent *event)
 			e_minicard->button_x = -1;
 			e_minicard->button_y = -1;
 
-			if (gtk_widget_has_grab (GTK_WIDGET (GNOME_CANVAS_ITEM (e_minicard)->canvas))) {
-				gtk_grab_remove (GTK_WIDGET (GNOME_CANVAS_ITEM (e_minicard)->canvas));
-				gnome_canvas_item_ungrab (GNOME_CANVAS_ITEM (e_minicard), event->button.time);
+			if (gtk_widget_has_grab (GTK_WIDGET (FOO_CANVAS_ITEM (e_minicard)->canvas))) {
+				gtk_grab_remove (GTK_WIDGET (FOO_CANVAS_ITEM (e_minicard)->canvas));
+				foo_canvas_item_ungrab (FOO_CANVAS_ITEM (e_minicard), event->button.time);
 			}
 		}
 		break;
@@ -654,7 +654,7 @@ e_minicard_event (GnomeCanvasItem *item, GdkEvent *event)
 
 					model_index = e_sorter_sorted_to_model (E_SORTER (reflow->sorter), view_index);
 					if (reflow->items[model_index] == NULL) {
-						reflow->items[model_index] = e_reflow_model_incarnate (reflow->model, model_index, GNOME_CANVAS_GROUP (reflow));
+						reflow->items[model_index] = e_reflow_model_incarnate (reflow->model, model_index, FOO_CANVAS_GROUP (reflow));
 						g_object_set (reflow->items[model_index],
 							      "width", (double) reflow->column_width,
 							      NULL);
@@ -680,7 +680,7 @@ e_minicard_event (GnomeCanvasItem *item, GdkEvent *event)
 
 					model_index = e_sorter_sorted_to_model (E_SORTER (reflow->sorter), view_index);
 					if (reflow->items[model_index] == NULL) {
-						reflow->items[model_index] = e_reflow_model_incarnate (reflow->model, model_index, GNOME_CANVAS_GROUP (reflow));
+						reflow->items[model_index] = e_reflow_model_incarnate (reflow->model, model_index, FOO_CANVAS_GROUP (reflow));
 						g_object_set (reflow->items[model_index],
 							      "width", (double) reflow->column_width,
 							      NULL);
@@ -701,8 +701,8 @@ e_minicard_event (GnomeCanvasItem *item, GdkEvent *event)
 		break;
 	}
 
-	if (GNOME_CANVAS_ITEM_CLASS( parent_class )->event)
-		return (* GNOME_CANVAS_ITEM_CLASS( parent_class )->event) (item, event);
+	if (FOO_CANVAS_ITEM_CLASS( parent_class )->event)
+		return (* FOO_CANVAS_ITEM_CLASS( parent_class )->event) (item, event);
 	else
 		return FALSE;
 }
@@ -714,7 +714,7 @@ e_minicard_resize_children( EMinicard *e_minicard )
 	gboolean is_list = GPOINTER_TO_INT (e_contact_get (e_minicard->contact, E_CONTACT_IS_LIST));
 
 	if (e_minicard->header_text) {
-		gnome_canvas_item_set( e_minicard->header_text,
+		foo_canvas_item_set( e_minicard->header_text,
 				       "width", ((double) e_minicard->width - 12
 						 - (is_list ? e_minicard->list_icon_size : 0.0)),
 				       NULL );
@@ -725,7 +725,7 @@ e_minicard_resize_children( EMinicard *e_minicard )
 					    3);
 	}
 	for ( list = e_minicard->fields; list; list = g_list_next( list ) ) {
-		gnome_canvas_item_set( E_MINICARD_FIELD( list->data )->label,
+		foo_canvas_item_set( E_MINICARD_FIELD( list->data )->label,
 				       "width", (double) e_minicard->width - 4.0,
 				       NULL );
 	}
@@ -734,14 +734,14 @@ e_minicard_resize_children( EMinicard *e_minicard )
 static void
 add_field (EMinicard *e_minicard, EContactField field, gdouble left_width)
 {
-	GnomeCanvasItem *new_item;
-	GnomeCanvasGroup *group;
+	FooCanvasItem *new_item;
+	FooCanvasGroup *group;
 	EMinicardField *minicard_field;
 	gchar *name;
 	gchar *string;
 	gboolean is_rtl = (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL);
 
-	group = GNOME_CANVAS_GROUP( e_minicard );
+	group = FOO_CANVAS_GROUP( e_minicard );
 
 	name = g_strdup_printf("%s:", e_contact_pretty_name (field));
 	string = e_contact_get (e_minicard->contact, field);
@@ -749,7 +749,7 @@ add_field (EMinicard *e_minicard, EContactField field, gdouble left_width)
 	new_item = e_minicard_label_new(group);
 
 	if (e_minicard->contact && e_contact_get (e_minicard->contact, E_CONTACT_IS_LIST))
-		gnome_canvas_item_set (new_item,
+		foo_canvas_item_set (new_item,
 					"fieldname", is_rtl ? "" : string,
 					"field", is_rtl ? string : "",
 					"max_field_name_length", left_width,
@@ -757,7 +757,7 @@ add_field (EMinicard *e_minicard, EContactField field, gdouble left_width)
 					"width", e_minicard->width - 4.0,
 					NULL );
 	else
-		gnome_canvas_item_set (new_item,
+		foo_canvas_item_set (new_item,
 					"fieldname", is_rtl ? string : name,
 					"field", is_rtl ? name : string,
 					"max_field_name_length", left_width,
@@ -800,15 +800,15 @@ get_email_location (EVCardAttribute *attr)
 static void
 add_email_field (EMinicard *e_minicard, GList *email_list, gdouble left_width, gint limit, gboolean is_list)
 {
-	GnomeCanvasItem *new_item;
-	GnomeCanvasGroup *group;
+	FooCanvasItem *new_item;
+	FooCanvasGroup *group;
 	EMinicardField *minicard_field;
 	gchar *name;
 	GList *l, *le;
 	gint count =0;
 	gboolean is_rtl = (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL);
 	GList *emails = e_contact_get (e_minicard->contact, E_CONTACT_EMAIL);
-	group = GNOME_CANVAS_GROUP( e_minicard );
+	group = FOO_CANVAS_GROUP( e_minicard );
 
 	for (l=email_list, le=emails; l!=NULL && count < limit && le!=NULL; l = l->next, le=le->next) {
 		const gchar *tmp;
@@ -836,7 +836,7 @@ add_email_field (EMinicard *e_minicard, GList *email_list, gdouble left_width, g
 
 		new_item = e_minicard_label_new(group);
 
-		gnome_canvas_item_set (new_item,
+		foo_canvas_item_set (new_item,
 				       "fieldname", is_rtl ? string : name,
 				       "field", is_rtl ? name : string,
 				       "max_field_name_length", left_width,
@@ -881,7 +881,7 @@ get_left_width (EMinicard *e_minicard, gboolean is_list)
 	if (is_list)
 		return 0;
 
-	layout = gtk_widget_create_pango_layout (GTK_WIDGET (GNOME_CANVAS_ITEM (e_minicard)->canvas), "");
+	layout = gtk_widget_create_pango_layout (GTK_WIDGET (FOO_CANVAS_ITEM (e_minicard)->canvas), "");
 	for (field = E_CONTACT_FULL_NAME; field != E_CONTACT_LAST_SIMPLE_STRING; field++) {
 		gint this_width;
 
@@ -903,7 +903,7 @@ static void
 remodel( EMinicard *e_minicard )
 {
 	gint count = 0;
-	if ( !(GTK_OBJECT_FLAGS( e_minicard ) & GNOME_CANVAS_ITEM_REALIZED) )
+	if ( !(GTK_OBJECT_FLAGS( e_minicard ) & FOO_CANVAS_ITEM_REALIZED) )
 		return;
 	if (e_minicard->contact) {
 		EContactField field;
@@ -915,7 +915,7 @@ remodel( EMinicard *e_minicard )
 
 		if (e_minicard->header_text) {
 			file_as = e_contact_get (e_minicard->contact, E_CONTACT_FILE_AS);
-			gnome_canvas_item_set (e_minicard->header_text,
+			foo_canvas_item_set (e_minicard->header_text,
 					       "text", file_as ? file_as : "",
 					       NULL );
 			g_free(file_as);
@@ -925,9 +925,9 @@ remodel( EMinicard *e_minicard )
 			is_list = TRUE;
 
 		if (is_list)
-			gnome_canvas_item_show (e_minicard->list_icon);
+			foo_canvas_item_show (e_minicard->list_icon);
 		else
-			gnome_canvas_item_hide (e_minicard->list_icon);
+			foo_canvas_item_hide (e_minicard->list_icon);
 
 		list = e_minicard->fields;
 		e_minicard->fields = NULL;
@@ -1002,10 +1002,10 @@ remodel( EMinicard *e_minicard )
 }
 
 static void
-e_minicard_reflow(GnomeCanvasItem *item, gint flags)
+e_minicard_reflow(FooCanvasItem *item, gint flags)
 {
 	EMinicard *e_minicard = E_MINICARD(item);
-	if (GTK_OBJECT_FLAGS (e_minicard) & GNOME_CANVAS_ITEM_REALIZED) {
+	if (GTK_OBJECT_FLAGS (e_minicard) & FOO_CANVAS_ITEM_REALIZED) {
 		GList *list;
 		gdouble text_height;
 		gint old_height;
@@ -1018,14 +1018,14 @@ e_minicard_reflow(GnomeCanvasItem *item, gint flags)
 
 		e_minicard->height = text_height + 10.0;
 
-		gnome_canvas_item_set(e_minicard->header_rect,
+		foo_canvas_item_set(e_minicard->header_rect,
 				       "y2", text_height + 9.0,
 				       NULL);
 
 		for (list = e_minicard->fields; list; list = g_list_next(list)) {
 			EMinicardField *field = E_MINICARD_FIELD(list->data);
 			/* Why not use the item that is passed in? */
-			GnomeCanvasItem *item = field->label;
+			FooCanvasItem *item = field->label;
 			g_object_get (item,
 				      "height", &text_height,
 				      NULL);
@@ -1034,11 +1034,11 @@ e_minicard_reflow(GnomeCanvasItem *item, gint flags)
 		}
 		e_minicard->height += 2;
 
-		gnome_canvas_item_set(e_minicard->rect,
+		foo_canvas_item_set(e_minicard->rect,
 				       "x2", (double) e_minicard->width - 1.0,
 				       "y2", (double) e_minicard->height - 1.0,
 				       NULL);
-		gnome_canvas_item_set(e_minicard->header_rect,
+		foo_canvas_item_set(e_minicard->header_rect,
 				       "x2", (double) e_minicard->width - 3.0,
 				       NULL);
 
@@ -1099,7 +1099,7 @@ gint
 e_minicard_selected (EMinicard *minicard, GdkEvent *event)
 {
 	gint ret_val = 0;
-	GnomeCanvasItem *item = GNOME_CANVAS_ITEM (minicard);
+	FooCanvasItem *item = FOO_CANVAS_ITEM (minicard);
 	if (item->parent) {
 		guint signal_id = g_signal_lookup ("selection_event", G_OBJECT_TYPE (item->parent));
 		/* We should probably check the signature here, but I
@@ -1119,12 +1119,12 @@ static gint
 e_minicard_drag_begin (EMinicard *minicard, GdkEvent *event)
 {
 	gint ret_val = 0;
-	GnomeCanvasItem *parent;
+	FooCanvasItem *parent;
 	g_signal_emit (minicard,
 		       signals[DRAG_BEGIN], 0,
 		       event, &ret_val);
 
-	parent = GNOME_CANVAS_ITEM (minicard)->parent;
+	parent = FOO_CANVAS_ITEM (minicard)->parent;
 	if (parent && E_IS_REFLOW (parent)) {
 		E_REFLOW (parent)->maybe_in_drag = FALSE;
 	}
diff --git a/addressbook/gui/widgets/e-minicard.h b/addressbook/gui/widgets/e-minicard.h
index 4135090..1720c88 100644
--- a/addressbook/gui/widgets/e-minicard.h
+++ b/addressbook/gui/widgets/e-minicard.h
@@ -24,7 +24,7 @@
 #define __E_MINICARD_H__
 
 #include <gtk/gtk.h>
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 #include <libebook/e-contact.h>
 
 G_BEGIN_DECLS
@@ -57,15 +57,15 @@ enum _EMinicardFocusType {
 
 struct _EMinicard
 {
-	GnomeCanvasGroup parent;
+	FooCanvasGroup parent;
 
 	/* item specific fields */
 	EContact *contact;
 
-	GnomeCanvasItem *rect;
-	GnomeCanvasItem *header_rect;
-	GnomeCanvasItem *header_text;
-	GnomeCanvasItem *list_icon;
+	FooCanvasItem *rect;
+	FooCanvasItem *header_rect;
+	FooCanvasItem *header_text;
+	FooCanvasItem *list_icon;
 
 	GdkPixbuf *list_icon_pixbuf;
 	double list_icon_size;
@@ -94,7 +94,7 @@ struct _EMinicard
 
 struct _EMinicardClass
 {
-	GnomeCanvasGroupClass parent_class;
+	FooCanvasGroupClass parent_class;
 
 	gint (* selected) (EMinicard *minicard, GdkEvent *event);
 	gint (* drag_begin) (EMinicard *minicard, GdkEvent *event);
@@ -107,7 +107,7 @@ typedef struct _EMinicardField EMinicardField;
 
 struct _EMinicardField {
 	EContactField field;
-	GnomeCanvasItem *label;
+	FooCanvasItem *label;
 };
 
 #define E_MINICARD_FIELD(field) ((EMinicardField *)(field))
diff --git a/addressbook/gui/widgets/ea-addressbook.c b/addressbook/gui/widgets/ea-addressbook.c
index 14fc4c1..6850b57 100644
--- a/addressbook/gui/widgets/ea-addressbook.c
+++ b/addressbook/gui/widgets/ea-addressbook.c
@@ -72,7 +72,7 @@ ea_addressbook_focus_watcher (GSignalInvocationHint *ihint,
 	event = g_value_get_boxed (param_values + 1);
 
 	if (E_IS_MINICARD (object)) {
-                GnomeCanvasItem *item = GNOME_CANVAS_ITEM (object);
+                FooCanvasItem *item = FOO_CANVAS_ITEM (object);
 		ea_event = atk_gobject_accessible_for_object (object);
 		if (event->type == GDK_FOCUS_CHANGE) {
 			if ((event->focus_change.in) && (E_IS_MINICARD (item->canvas->focused_item)))
diff --git a/addressbook/gui/widgets/ea-minicard-view.c b/addressbook/gui/widgets/ea-minicard-view.c
index ffccbfa..847bfb7 100644
--- a/addressbook/gui/widgets/ea-minicard-view.c
+++ b/addressbook/gui/widgets/ea-minicard-view.c
@@ -101,7 +101,7 @@ ea_minicard_view_get_type (void)
 		 * we are run-time deriving from (GailWidget, in this case) */
 
 		factory = atk_registry_get_factory (atk_get_default_registry (),
-							GNOME_TYPE_CANVAS_GROUP);
+							FOO_TYPE_CANVAS_GROUP);
 		derived_atk_type = atk_object_factory_get_accessible_type (factory);
 		g_type_query (derived_atk_type, &query);
 
diff --git a/addressbook/gui/widgets/ea-minicard.c b/addressbook/gui/widgets/ea-minicard.c
index 8791a68..d64b27f 100644
--- a/addressbook/gui/widgets/ea-minicard.c
+++ b/addressbook/gui/widgets/ea-minicard.c
@@ -83,7 +83,7 @@ ea_minicard_get_type (void)
 		 */
 
 		factory = atk_registry_get_factory (atk_get_default_registry (),
-						    GNOME_TYPE_CANVAS_GROUP);
+						    FOO_TYPE_CANVAS_GROUP);
 		derived_atk_type = atk_object_factory_get_accessible_type (factory);
 		g_type_query (derived_atk_type, &query);
 
diff --git a/calendar/gui/e-cal-list-view.c b/calendar/gui/e-cal-list-view.c
index 1097749..6b3492f 100644
--- a/calendar/gui/e-cal-list-view.c
+++ b/calendar/gui/e-cal-list-view.c
@@ -192,7 +192,7 @@ setup_e_table (ECalListView *cal_list_view)
 	ETableExtras *extras;
 	GList *strings;
 	ECell *cell, *popup_cell;
-	GnomeCanvas *canvas;
+	FooCanvas *canvas;
 	GtkStyle *style;
 	GtkWidget *container;
 	GtkWidget *widget;
@@ -303,7 +303,7 @@ setup_e_table (ECalListView *cal_list_view)
 
 	/* Make sure text is readable on top of our color coding */
 
-	canvas = GNOME_CANVAS (cal_list_view->table->table_canvas);
+	canvas = FOO_CANVAS (cal_list_view->table->table_canvas);
 	style = gtk_widget_get_style (GTK_WIDGET (canvas));
 
 	style->fg [GTK_STATE_SELECTED] = style->text [GTK_STATE_NORMAL];
diff --git a/calendar/gui/e-calendar-view.h b/calendar/gui/e-calendar-view.h
index d79a6fd..f2e1d44 100644
--- a/calendar/gui/e-calendar-view.h
+++ b/calendar/gui/e-calendar-view.h
@@ -70,7 +70,7 @@ typedef enum {
 } ECalViewMoveDirection;
 
 #define E_CALENDAR_VIEW_EVENT_FIELDS \
-	GnomeCanvasItem *canvas_item; \
+	FooCanvasItem *canvas_item; \
 	ECalModelComponent *comp_data; \
 	time_t start; \
 	time_t end; \
diff --git a/calendar/gui/e-day-view-main-item.c b/calendar/gui/e-day-view-main-item.c
index 16be4ff..d41e3e9 100644
--- a/calendar/gui/e-day-view-main-item.c
+++ b/calendar/gui/e-day-view-main-item.c
@@ -964,15 +964,15 @@ day_view_main_item_dispose (GObject *object)
 }
 
 static void
-day_view_main_item_update (GnomeCanvasItem *item,
+day_view_main_item_update (FooCanvasItem *item,
 			   gdouble *affine,
 			   ArtSVP *clip_path,
 			   gint flags)
 {
-	GnomeCanvasItemClass *canvas_item_class;
+	FooCanvasItemClass *canvas_item_class;
 
 	/* Chain up to parent's update() method. */
-	canvas_item_class = GNOME_CANVAS_ITEM_CLASS (parent_class);
+	canvas_item_class = FOO_CANVAS_ITEM_CLASS (parent_class);
 	canvas_item_class->update (item, affine, clip_path, flags);
 
 	/* The item covers the entire canvas area. */
@@ -983,7 +983,7 @@ day_view_main_item_update (GnomeCanvasItem *item,
 }
 
 static void
-day_view_main_item_draw (GnomeCanvasItem *canvas_item,
+day_view_main_item_draw (FooCanvasItem *canvas_item,
                          GdkDrawable *drawable,
                          gint x,
                          gint y,
@@ -1225,12 +1225,12 @@ day_view_main_item_draw (GnomeCanvasItem *canvas_item,
 }
 
 static gdouble
-day_view_main_item_point (GnomeCanvasItem *item,
+day_view_main_item_point (FooCanvasItem *item,
                           gdouble x,
                           gdouble y,
                           gint cx,
                           gint cy,
-                          GnomeCanvasItem **actual_item)
+                          FooCanvasItem **actual_item)
 {
 	/* This is supposed to return the nearest item to the point
 	 * and the distance.  Since we are the only item we just return
@@ -1245,7 +1245,7 @@ static void
 day_view_main_item_class_init (EDayViewMainItemClass *class)
 {
 	GObjectClass *object_class;
-	GnomeCanvasItemClass *item_class;
+	FooCanvasItemClass *item_class;
 
 	parent_class = g_type_class_peek_parent (class);
 	g_type_class_add_private (class, sizeof (EDayViewMainItemPrivate));
@@ -1255,7 +1255,7 @@ day_view_main_item_class_init (EDayViewMainItemClass *class)
 	object_class->get_property = day_view_main_item_get_property;
 	object_class->dispose = day_view_main_item_dispose;
 
-	item_class = GNOME_CANVAS_ITEM_CLASS (class);
+	item_class = FOO_CANVAS_ITEM_CLASS (class);
 	item_class->update = day_view_main_item_update;
 	item_class->draw = day_view_main_item_draw;
 	item_class->point = day_view_main_item_point;
@@ -1300,7 +1300,7 @@ e_day_view_main_item_get_type (void)
 		};
 
 		type = g_type_register_static (
-			GNOME_TYPE_CANVAS_ITEM, "EDayViewMainItem",
+			FOO_TYPE_CANVAS_ITEM, "EDayViewMainItem",
 			&type_info, 0);
 	}
 
diff --git a/calendar/gui/e-day-view-main-item.h b/calendar/gui/e-day-view-main-item.h
index 567565b..e286bbf 100644
--- a/calendar/gui/e-day-view-main-item.h
+++ b/calendar/gui/e-day-view-main-item.h
@@ -56,12 +56,12 @@ typedef struct _EDayViewMainItemClass EDayViewMainItemClass;
 typedef struct _EDayViewMainItemPrivate EDayViewMainItemPrivate;
 
 struct _EDayViewMainItem {
-	GnomeCanvasItem parent;
+	FooCanvasItem parent;
 	EDayViewMainItemPrivate *priv;
 };
 
 struct _EDayViewMainItemClass {
-	GnomeCanvasItemClass parent_class;
+	FooCanvasItemClass parent_class;
 };
 
 GType		e_day_view_main_item_get_type	(void);
diff --git a/calendar/gui/e-day-view-time-item.c b/calendar/gui/e-day-view-time-item.c
index 94f2327..9b666d1 100644
--- a/calendar/gui/e-day-view-time-item.c
+++ b/calendar/gui/e-day-view-time-item.c
@@ -73,18 +73,18 @@ struct _EDayViewTimeItemPrivate {
 	icaltimezone *second_zone;
 };
 
-static void e_day_view_time_item_update (GnomeCanvasItem *item,
+static void e_day_view_time_item_update (FooCanvasItem *item,
 					 double *affine,
 					 ArtSVP *clip_path, gint flags);
-static void e_day_view_time_item_draw (GnomeCanvasItem *item,
+static void e_day_view_time_item_draw (FooCanvasItem *item,
 				       GdkDrawable *drawable,
 				       gint x, gint y,
 				       gint width, gint height);
-static double e_day_view_time_item_point (GnomeCanvasItem *item,
+static double e_day_view_time_item_point (FooCanvasItem *item,
 					  double x, double y,
 					  gint cx, gint cy,
-					  GnomeCanvasItem **actual_item);
-static gint e_day_view_time_item_event (GnomeCanvasItem *item,
+					  FooCanvasItem **actual_item);
+static gint e_day_view_time_item_event (FooCanvasItem *item,
 					GdkEvent *event);
 static void e_day_view_time_item_increment_time	(gint	*hour,
 						 gint	*minute,
@@ -180,7 +180,7 @@ static void
 day_view_time_item_class_init (EDayViewTimeItemClass *class)
 {
 	GObjectClass *object_class;
-	GnomeCanvasItemClass *item_class;
+	FooCanvasItemClass *item_class;
 
 	parent_class = g_type_class_peek_parent (class);
 	g_type_class_add_private (class, sizeof (EDayViewTimeItemPrivate));
@@ -191,7 +191,7 @@ day_view_time_item_class_init (EDayViewTimeItemClass *class)
 	object_class->dispose = day_view_time_item_dispose;
 	object_class->finalize = day_view_time_item_finalize;
 
-	item_class = GNOME_CANVAS_ITEM_CLASS (class);
+	item_class = FOO_CANVAS_ITEM_CLASS (class);
 	item_class->update = e_day_view_time_item_update;
 	item_class->draw = e_day_view_time_item_draw;
 	item_class->point = e_day_view_time_item_point;
@@ -249,7 +249,7 @@ e_day_view_time_item_get_type (void)
 		};
 
 		type = g_type_register_static (
-			GNOME_TYPE_CANVAS_ITEM, "EDayViewTimeItem",
+			FOO_TYPE_CANVAS_ITEM, "EDayViewTimeItem",
 			&type_info, 0);
 	}
 
@@ -257,13 +257,13 @@ e_day_view_time_item_get_type (void)
 }
 
 static void
-e_day_view_time_item_update (GnomeCanvasItem *item,
+e_day_view_time_item_update (FooCanvasItem *item,
 			    double *affine,
 			    ArtSVP *clip_path,
 			    gint flags)
 {
-	if (GNOME_CANVAS_ITEM_CLASS (parent_class)->update)
-		(* GNOME_CANVAS_ITEM_CLASS (parent_class)->update) (item, affine, clip_path, flags);
+	if (FOO_CANVAS_ITEM_CLASS (parent_class)->update)
+		(* FOO_CANVAS_ITEM_CLASS (parent_class)->update) (item, affine, clip_path, flags);
 
 	/* The item covers the entire canvas area. */
 	item->x1 = 0;
@@ -276,7 +276,7 @@ e_day_view_time_item_update (GnomeCanvasItem *item,
  * DRAWING ROUTINES - functions to paint the canvas item.
  */
 static void
-edvti_draw_zone (GnomeCanvasItem   *canvas_item,
+edvti_draw_zone (FooCanvasItem   *canvas_item,
 		GdkDrawable	   *drawable,
 		gint		    x,
 		gint		    y,
@@ -614,7 +614,7 @@ edvti_draw_zone (GnomeCanvasItem   *canvas_item,
 }
 
 static void
-e_day_view_time_item_draw (GnomeCanvasItem *canvas_item,
+e_day_view_time_item_draw (FooCanvasItem *canvas_item,
 			   GdkDrawable	   *drawable,
 			   gint		    x,
 			   gint		    y,
@@ -650,16 +650,16 @@ e_day_view_time_item_increment_time	(gint	*hour,
 }
 
 static double
-e_day_view_time_item_point (GnomeCanvasItem *item, double x, double y,
+e_day_view_time_item_point (FooCanvasItem *item, double x, double y,
 			    gint cx, gint cy,
-			    GnomeCanvasItem **actual_item)
+			    FooCanvasItem **actual_item)
 {
 	*actual_item = item;
 	return 0.0;
 }
 
 static gint
-e_day_view_time_item_event (GnomeCanvasItem *item,
+e_day_view_time_item_event (FooCanvasItem *item,
 			    GdkEvent *event)
 {
 	EDayViewTimeItem *time_item;
@@ -854,13 +854,13 @@ e_day_view_time_item_on_button_press (EDayViewTimeItem *time_item,
 				      GdkEvent *event)
 {
 	EDayView *day_view;
-	GnomeCanvas *canvas;
+	FooCanvas *canvas;
 	gint row;
 
 	day_view = e_day_view_time_item_get_day_view (time_item);
 	g_return_if_fail (day_view != NULL);
 
-	canvas = GNOME_CANVAS_ITEM (time_item)->canvas;
+	canvas = FOO_CANVAS_ITEM (time_item)->canvas;
 
 	row = e_day_view_time_item_convert_position_to_row (time_item,
 							    event->button.y);
@@ -903,7 +903,7 @@ e_day_view_time_item_on_motion_notify (EDayViewTimeItem *time_item,
 				       GdkEvent *event)
 {
 	EDayView *day_view;
-	GnomeCanvas *canvas;
+	FooCanvas *canvas;
 	gdouble window_y;
 	gint y, row;
 
@@ -913,13 +913,13 @@ e_day_view_time_item_on_motion_notify (EDayViewTimeItem *time_item,
 	day_view = e_day_view_time_item_get_day_view (time_item);
 	g_return_if_fail (day_view != NULL);
 
-	canvas = GNOME_CANVAS_ITEM (time_item)->canvas;
+	canvas = FOO_CANVAS_ITEM (time_item)->canvas;
 
 	y = event->motion.y;
 	row = e_day_view_time_item_convert_position_to_row (time_item, y);
 
 	if (row != -1) {
-		gnome_canvas_world_to_window (canvas, 0, event->motion.y,
+		foo_canvas_world_to_window (canvas, 0, event->motion.y,
 					      NULL, &window_y);
 		e_day_view_update_selection (day_view, -1, row);
 		e_day_view_check_auto_scroll (day_view, -1, (gint) window_y);
diff --git a/calendar/gui/e-day-view-time-item.h b/calendar/gui/e-day-view-time-item.h
index 354a370..1e2601c 100644
--- a/calendar/gui/e-day-view-time-item.h
+++ b/calendar/gui/e-day-view-time-item.h
@@ -57,12 +57,12 @@ typedef struct _EDayViewTimeItemClass EDayViewTimeItemClass;
 typedef struct _EDayViewTimeItemPrivate EDayViewTimeItemPrivate;
 
 struct _EDayViewTimeItem {
-	GnomeCanvasItem parent;
+	FooCanvasItem parent;
 	EDayViewTimeItemPrivate *priv;
 };
 
 struct _EDayViewTimeItemClass {
-	GnomeCanvasItemClass parent_class;
+	FooCanvasItemClass parent_class;
 };
 
 GType		e_day_view_time_item_get_type	(void);
diff --git a/calendar/gui/e-day-view-top-item.c b/calendar/gui/e-day-view-top-item.c
index 211faa5..c9792c3 100644
--- a/calendar/gui/e-day-view-top-item.c
+++ b/calendar/gui/e-day-view-top-item.c
@@ -555,15 +555,15 @@ day_view_top_item_dispose (GObject *object)
 }
 
 static void
-day_view_top_item_update (GnomeCanvasItem *item,
+day_view_top_item_update (FooCanvasItem *item,
                           gdouble *affine,
                           ArtSVP *clip_path,
                           gint flags)
 {
-	GnomeCanvasItemClass *canvas_item_class;
+	FooCanvasItemClass *canvas_item_class;
 
 	/* Chain up to parent's update() method. */
-	canvas_item_class = GNOME_CANVAS_ITEM_CLASS (parent_class);
+	canvas_item_class = FOO_CANVAS_ITEM_CLASS (parent_class);
 	canvas_item_class->update (item, affine, clip_path, flags);
 
 	/* The item covers the entire canvas area. */
@@ -574,7 +574,7 @@ day_view_top_item_update (GnomeCanvasItem *item,
 }
 
 static void
-day_view_top_item_draw (GnomeCanvasItem *canvas_item,
+day_view_top_item_draw (FooCanvasItem *canvas_item,
                         GdkDrawable *drawable,
                         gint x,
                         gint y,
@@ -755,12 +755,12 @@ day_view_top_item_draw (GnomeCanvasItem *canvas_item,
 }
 
 static double
-day_view_top_item_point (GnomeCanvasItem *item,
+day_view_top_item_point (FooCanvasItem *item,
                          gdouble x,
                          gdouble y,
                          gint cx,
                          gint cy,
-                         GnomeCanvasItem **actual_item)
+                         FooCanvasItem **actual_item)
 {
 	/* This is supposed to return the nearest item the the point
 	 * and the distance.  Since we are the only item we just return
@@ -775,7 +775,7 @@ static void
 day_view_top_item_class_init (EDayViewTopItemClass *class)
 {
 	GObjectClass *object_class;
-	GnomeCanvasItemClass *item_class;
+	FooCanvasItemClass *item_class;
 
 	parent_class = g_type_class_peek_parent (class);
 	g_type_class_add_private (class, sizeof (EDayViewTopItemPrivate));
@@ -785,7 +785,7 @@ day_view_top_item_class_init (EDayViewTopItemClass *class)
 	object_class->get_property = day_view_top_item_get_property;
 	object_class->dispose = day_view_top_item_dispose;
 
-	item_class = GNOME_CANVAS_ITEM_CLASS (class);
+	item_class = FOO_CANVAS_ITEM_CLASS (class);
 	item_class->update = day_view_top_item_update;
 	item_class->draw = day_view_top_item_draw;
 	item_class->point = day_view_top_item_point;
@@ -837,7 +837,7 @@ e_day_view_top_item_get_type (void)
 		};
 
 		type = g_type_register_static (
-			GNOME_TYPE_CANVAS_ITEM, "EDayViewTopItem",
+			FOO_TYPE_CANVAS_ITEM, "EDayViewTopItem",
 			&type_info, 0);
 	}
 
diff --git a/calendar/gui/e-day-view-top-item.h b/calendar/gui/e-day-view-top-item.h
index 64d56b1..6836bc8 100644
--- a/calendar/gui/e-day-view-top-item.h
+++ b/calendar/gui/e-day-view-top-item.h
@@ -56,12 +56,12 @@ typedef struct _EDayViewTopItemClass EDayViewTopItemClass;
 typedef struct _EDayViewTopItemPrivate EDayViewTopItemPrivate;
 
 struct _EDayViewTopItem {
-	GnomeCanvasItem parent;
+	FooCanvasItem parent;
 	EDayViewTopItemPrivate *priv;
 };
 
 struct _EDayViewTopItemClass {
-	GnomeCanvasItemClass parent_class;
+	FooCanvasItemClass parent_class;
 };
 
 GType		e_day_view_top_item_get_type	(void);
diff --git a/calendar/gui/e-day-view.c b/calendar/gui/e-day-view.c
index 3df4e69..01d36cc 100644
--- a/calendar/gui/e-day-view.c
+++ b/calendar/gui/e-day-view.c
@@ -35,7 +35,7 @@
 #include <misc/e-canvas-utils.h>
 #include <misc/e-popup-menu.h>
 #include <e-util/e-unicode.h>
-#include <libgnomecanvas/gnome-canvas-rect-ellipse.h>
+#include <libfoocanvas/foo-canvas-rect-ellipse.h>
 #include <glib/gi18n.h>
 #include <e-util/e-binding.h>
 #include <e-util/e-categories-config.h>
@@ -331,7 +331,7 @@ static void e_day_view_start_editing_event (EDayView *day_view,
 					    gint event_num,
 					    GdkEventKey *key_event);
 static void e_day_view_stop_editing_event (EDayView *day_view);
-static gboolean e_day_view_on_text_item_event (GnomeCanvasItem *item,
+static gboolean e_day_view_on_text_item_event (FooCanvasItem *item,
 					       GdkEvent *event,
 					       EDayView *day_view);
 static gboolean e_day_view_event_move (ECalendarView *cal_view, ECalViewMoveDirection direction);
@@ -340,9 +340,9 @@ time_t end_dt);
 static void e_day_view_change_event_end_time_up (EDayView *day_view);
 static void e_day_view_change_event_end_time_down (EDayView *day_view);
 static void e_day_view_on_editing_started (EDayView *day_view,
-					   GnomeCanvasItem *item);
+					   FooCanvasItem *item);
 static void e_day_view_on_editing_stopped (EDayView *day_view,
-					   GnomeCanvasItem *item);
+					   FooCanvasItem *item);
 
 static time_t e_day_view_convert_grid_position_to_time (EDayView *day_view,
 							gint col,
@@ -1030,7 +1030,7 @@ static void
 e_day_view_init (EDayView *day_view)
 {
 	gint day;
-	GnomeCanvasGroup *canvas_group;
+	FooCanvasGroup *canvas_group;
 	GtkWidget *w;
 
 	GTK_WIDGET_SET_FLAGS (day_view, GTK_CAN_FOCUS);
@@ -1167,34 +1167,34 @@ e_day_view_init (EDayView *day_view)
 	g_signal_connect (day_view->top_canvas, "drag_data_received",
 			  G_CALLBACK (e_day_view_on_top_canvas_drag_data_received), day_view);
 
-	canvas_group = GNOME_CANVAS_GROUP (GNOME_CANVAS (day_view->top_dates_canvas)->root);
+	canvas_group = FOO_CANVAS_GROUP (FOO_CANVAS (day_view->top_dates_canvas)->root);
 
 	day_view->top_dates_canvas_item =
-		gnome_canvas_item_new (canvas_group,
+		foo_canvas_item_new (canvas_group,
 				       e_day_view_top_item_get_type (),
 				       "EDayViewTopItem::day_view", day_view,
 				       "EDayViewTopItem::show_dates", TRUE,
 				       NULL);
 	gtk_widget_set_size_request (day_view->top_dates_canvas, -1, day_view->top_row_height);
 
-	canvas_group = GNOME_CANVAS_GROUP (GNOME_CANVAS (day_view->top_canvas)->root);
+	canvas_group = FOO_CANVAS_GROUP (FOO_CANVAS (day_view->top_canvas)->root);
 
 	day_view->top_canvas_item =
-		gnome_canvas_item_new (canvas_group,
+		foo_canvas_item_new (canvas_group,
 				       e_day_view_top_item_get_type (),
 				       "EDayViewTopItem::day_view", day_view,
 				       "EDayViewTopItem::show_dates", FALSE,
 				       NULL);
 
 	day_view->drag_long_event_rect_item =
-		gnome_canvas_item_new (canvas_group,
-				       gnome_canvas_rect_get_type (),
+		foo_canvas_item_new (canvas_group,
+				       foo_canvas_rect_get_type (),
 				       "width_pixels", 1,
 				       NULL);
-	gnome_canvas_item_hide (day_view->drag_long_event_rect_item);
+	foo_canvas_item_hide (day_view->drag_long_event_rect_item);
 
 	day_view->drag_long_event_item =
-		gnome_canvas_item_new (canvas_group,
+		foo_canvas_item_new (canvas_group,
 				       e_text_get_type (),
 				       "anchor", GTK_ANCHOR_NW,
 				       "line_wrap", TRUE,
@@ -1202,9 +1202,9 @@ e_day_view_init (EDayView *day_view)
 				       "max_lines", 1,
 				       "editable", TRUE,
 				       "draw_background", FALSE,
-				       "fill_color_rgba", GNOME_CANVAS_COLOR(0, 0, 0),
+				       "fill_color_rgba", FOO_CANVAS_COLOR(0, 0, 0),
 				       NULL);
-	gnome_canvas_item_hide (day_view->drag_long_event_item);
+	foo_canvas_item_hide (day_view->drag_long_event_item);
 
 	/*
 	 * Main Canvas
@@ -1251,39 +1251,39 @@ e_day_view_init (EDayView *day_view)
 	g_signal_connect (day_view->main_canvas, "drag_data_received",
 			  G_CALLBACK (e_day_view_on_main_canvas_drag_data_received), day_view);
 
-	canvas_group = GNOME_CANVAS_GROUP (GNOME_CANVAS (day_view->main_canvas)->root);
+	canvas_group = FOO_CANVAS_GROUP (FOO_CANVAS (day_view->main_canvas)->root);
 
 	day_view->main_canvas_item =
-		gnome_canvas_item_new (canvas_group,
+		foo_canvas_item_new (canvas_group,
 				       e_day_view_main_item_get_type (),
 				       "EDayViewMainItem::day_view", day_view,
 				       NULL);
 
 	day_view->drag_rect_item =
-		gnome_canvas_item_new (canvas_group,
-				       gnome_canvas_rect_get_type (),
+		foo_canvas_item_new (canvas_group,
+				       foo_canvas_rect_get_type (),
 				       "width_pixels", 1,
 				       NULL);
-	gnome_canvas_item_hide (day_view->drag_rect_item);
+	foo_canvas_item_hide (day_view->drag_rect_item);
 
 	day_view->drag_bar_item =
-		gnome_canvas_item_new (canvas_group,
-				       gnome_canvas_rect_get_type (),
+		foo_canvas_item_new (canvas_group,
+				       foo_canvas_rect_get_type (),
 				       "width_pixels", 1,
 				       NULL);
-	gnome_canvas_item_hide (day_view->drag_bar_item);
+	foo_canvas_item_hide (day_view->drag_bar_item);
 
 	day_view->drag_item =
-		gnome_canvas_item_new (canvas_group,
+		foo_canvas_item_new (canvas_group,
 				       e_text_get_type (),
 				       "anchor", GTK_ANCHOR_NW,
 				       "line_wrap", TRUE,
 				       "clip", TRUE,
 				       "editable", TRUE,
 				       "draw_background", FALSE,
-				       "fill_color_rgba", GNOME_CANVAS_COLOR(0, 0, 0),
+				       "fill_color_rgba", FOO_CANVAS_COLOR(0, 0, 0),
 				       NULL);
-	gnome_canvas_item_hide (day_view->drag_item);
+	foo_canvas_item_hide (day_view->drag_item);
 
 	/*
 	 * Times Canvas
@@ -1298,10 +1298,10 @@ e_day_view_init (EDayView *day_view)
 	g_signal_connect_after (day_view->time_canvas, "scroll_event",
 				G_CALLBACK (e_day_view_on_time_canvas_scroll), day_view);
 
-	canvas_group = GNOME_CANVAS_GROUP (GNOME_CANVAS (day_view->time_canvas)->root);
+	canvas_group = FOO_CANVAS_GROUP (FOO_CANVAS (day_view->time_canvas)->root);
 
 	day_view->time_canvas_item =
-		gnome_canvas_item_new (canvas_group,
+		foo_canvas_item_new (canvas_group,
 				       e_day_view_time_item_get_type (),
 				       "EDayViewTimeItem::day_view", day_view,
 				       NULL);
@@ -1363,7 +1363,7 @@ init_model (EDayView *day_view, ECalModel *model)
 }
 
 /* Turn off the background of the canvas windows. This reduces flicker
-   considerably when scrolling. (Why isn't it in GnomeCanvas?). */
+   considerably when scrolling. (Why isn't it in FooCanvas?). */
 static void
 e_day_view_on_canvas_realized (GtkWidget *widget,
 			       EDayView *day_view)
@@ -1474,17 +1474,17 @@ e_day_view_realize (GtkWidget *widget)
 	day_view->attach_icon = e_icon_factory_get_icon ("mail-attachment", GTK_ICON_SIZE_MENU);
 
 	/* Set the canvas item colors. */
-	gnome_canvas_item_set (day_view->drag_long_event_rect_item,
+	foo_canvas_item_set (day_view->drag_long_event_rect_item,
 			       "fill_color_gdk", &day_view->colors[E_DAY_VIEW_COLOR_EVENT_BACKGROUND],
 			       "outline_color_gdk", &day_view->colors[E_DAY_VIEW_COLOR_EVENT_BORDER],
 			       NULL);
 
-	gnome_canvas_item_set (day_view->drag_rect_item,
+	foo_canvas_item_set (day_view->drag_rect_item,
 			       "fill_color_gdk", &day_view->colors[E_DAY_VIEW_COLOR_EVENT_BACKGROUND],
 			       "outline_color_gdk", &day_view->colors[E_DAY_VIEW_COLOR_EVENT_BORDER],
 			       NULL);
 
-	gnome_canvas_item_set (day_view->drag_bar_item,
+	foo_canvas_item_set (day_view->drag_bar_item,
 			       "fill_color_gdk", &day_view->colors[E_DAY_VIEW_COLOR_EVENT_VBAR],
 			       "outline_color_gdk", &day_view->colors[E_DAY_VIEW_COLOR_EVENT_BORDER],
 			       NULL);
@@ -1586,23 +1586,23 @@ e_day_view_update_top_scroll (EDayView *day_view, gboolean scroll_to_top)
 	}
 
 	/* Set the scroll region of the top canvas */
-	gnome_canvas_get_scroll_region (GNOME_CANVAS (day_view->top_canvas),
+	foo_canvas_get_scroll_region (FOO_CANVAS (day_view->top_canvas),
 					NULL, NULL, &old_x2, &old_y2);
 	new_x2 = day_view->top_canvas->allocation.width - 1;
 	new_y2 = (MAX (1, day_view->rows_in_top_display) + 1) * day_view->top_row_height - 1;
 	if (old_x2 != new_x2 || old_y2 != new_y2) {
-		gnome_canvas_set_scroll_region (GNOME_CANVAS (day_view->top_canvas),
+		foo_canvas_set_scroll_region (FOO_CANVAS (day_view->top_canvas),
 						0, 0, new_x2, new_y2);
 
 		if (scroll_to_top)
-			gnome_canvas_scroll_to (GNOME_CANVAS (day_view->top_canvas), 0, 0);
+			foo_canvas_scroll_to (FOO_CANVAS (day_view->top_canvas), 0, 0);
 	}
 	new_y2 = day_view->top_row_height - 1 - 2;
-	gnome_canvas_get_scroll_region (GNOME_CANVAS (day_view->top_dates_canvas), NULL, NULL, &old_x2, &old_y2);
+	foo_canvas_get_scroll_region (FOO_CANVAS (day_view->top_dates_canvas), NULL, NULL, &old_x2, &old_y2);
 
 	if (old_x2 != new_x2 || old_y2 != new_y2) {
-		gnome_canvas_set_scroll_region (GNOME_CANVAS (day_view->top_dates_canvas), 0, 0, new_x2, new_y2);
-		gnome_canvas_scroll_to (GNOME_CANVAS (day_view->top_dates_canvas), 0, 0);
+		foo_canvas_set_scroll_region (FOO_CANVAS (day_view->top_dates_canvas), 0, 0, new_x2, new_y2);
+		foo_canvas_scroll_to (FOO_CANVAS (day_view->top_dates_canvas), 0, 0);
 	}
 }
 
@@ -1638,7 +1638,7 @@ e_day_view_style_set (GtkWidget *widget,
 			event = &g_array_index (day_view->events[week_day], EDayViewEvent, event_num);
 			if (event->canvas_item) {
 				color = e_day_view_get_text_color (day_view, event, widget);
-				gnome_canvas_item_set (event->canvas_item,
+				foo_canvas_item_set (event->canvas_item,
 						"fill_color_gdk", &color,
 						NULL);
 			}
@@ -1648,7 +1648,7 @@ e_day_view_style_set (GtkWidget *widget,
 		event = &g_array_index (day_view->long_events, EDayViewEvent, event_num);
 		if (event->canvas_item) {
 			color = e_day_view_get_text_color (day_view, event, widget);
-			gnome_canvas_item_set (event->canvas_item,
+			foo_canvas_item_set (event->canvas_item,
 					"fill_color_gdk", &color,
 					NULL);
 		}
@@ -1799,7 +1799,7 @@ e_day_view_recalc_main_canvas_size (EDayView *day_view)
 	   allocation. */
 	if (day_view->scroll_to_work_day) {
 		scroll_y = e_day_view_convert_time_to_position (day_view, day_view->work_day_start_hour, day_view->work_day_start_minute);
-		gnome_canvas_scroll_to (GNOME_CANVAS (day_view->main_canvas),
+		foo_canvas_scroll_to (FOO_CANVAS (day_view->main_canvas),
 					0, scroll_y);
 		day_view->scroll_to_work_day = FALSE;
 	}
@@ -2126,7 +2126,7 @@ set_text_as_bold (EDayViewEvent *event)
 	   If the attendee is not present, it might have come through a mailing list.
 	   In that case, we never show the meeting as bold even if it is unaccepted. */
 	if (at && (at->status == ICAL_PARTSTAT_NEEDSACTION))
-		gnome_canvas_item_set (event->canvas_item, "bold", TRUE, NULL);
+		foo_canvas_item_set (event->canvas_item, "bold", TRUE, NULL);
 
 	e_cal_component_free_attendee_list (attendees);
 	g_free (address);
@@ -2177,7 +2177,7 @@ e_day_view_update_event_label (EDayView *day_view,
 		}
 	}
 
-	gnome_canvas_item_set (event->canvas_item,
+	foo_canvas_item_set (event->canvas_item,
 			       "text", text,
 			       NULL);
 
@@ -2206,7 +2206,7 @@ e_day_view_update_long_event_label (EDayView *day_view,
 
 	summary = e_calendar_view_get_icalcomponent_summary (event->comp_data->client, event->comp_data->icalcomp, &free_text);
 
-	gnome_canvas_item_set (event->canvas_item,
+	foo_canvas_item_set (event->canvas_item,
 			       "text", summary ? summary : "",
 			       NULL);
 
@@ -2223,7 +2223,7 @@ e_day_view_update_long_event_label (EDayView *day_view,
    Returns TRUE if the event was found. */
 gboolean
 e_day_view_find_event_from_item (EDayView *day_view,
-				 GnomeCanvasItem *item,
+				 FooCanvasItem *item,
 				 gint *day_return,
 				 gint *event_num_return)
 {
@@ -3036,18 +3036,18 @@ e_day_view_update_scroll_regions (EDayView *day_view)
 
 	/* Set the scroll region of the time canvas to its allocated width,
 	   but with the height the same as the main canvas. */
-	gnome_canvas_get_scroll_region (GNOME_CANVAS (day_view->time_canvas),
+	foo_canvas_get_scroll_region (FOO_CANVAS (day_view->time_canvas),
 					NULL, NULL, &old_x2, &old_y2);
 	new_x2 = day_view->time_canvas->allocation.width - 1;
 	new_y2 = MAX (day_view->rows * day_view->row_height,
 		      day_view->main_canvas->allocation.height) - 1;
 	if (old_x2 != new_x2 || old_y2 != new_y2)
-		gnome_canvas_set_scroll_region (GNOME_CANVAS (day_view->time_canvas),
+		foo_canvas_set_scroll_region (FOO_CANVAS (day_view->time_canvas),
 						0, 0, new_x2, new_y2);
 
 	/* Set the scroll region of the main canvas to its allocated width,
 	   but with the height depending on the number of rows needed. */
-	gnome_canvas_get_scroll_region (GNOME_CANVAS (day_view->main_canvas),
+	foo_canvas_get_scroll_region (FOO_CANVAS (day_view->main_canvas),
 					NULL, NULL, &old_x2, &old_y2);
 	new_x2 = day_view->main_canvas->allocation.width - 1;
 
@@ -3056,7 +3056,7 @@ e_day_view_update_scroll_regions (EDayView *day_view)
 
 	if (old_x2 != new_x2 || old_y2 != new_y2) {
 		need_reshape = TRUE;
-		gnome_canvas_set_scroll_region (GNOME_CANVAS (day_view->main_canvas),
+		foo_canvas_set_scroll_region (FOO_CANVAS (day_view->main_canvas),
 						0, 0, new_x2, new_y2);
 	}
 
@@ -3490,7 +3490,7 @@ e_day_view_on_long_event_click (EDayView *day_view,
 	/* Ignore clicks on the EText while editing. */
 	if (pos == E_CALENDAR_VIEW_POS_EVENT
 	    && E_TEXT (event->canvas_item)->editing) {
-		GNOME_CANVAS_ITEM_GET_CLASS (event->canvas_item)->event (event->canvas_item, (GdkEvent*)bevent);
+		FOO_CANVAS_ITEM_GET_CLASS (event->canvas_item)->event (event->canvas_item, (GdkEvent*)bevent);
 		return;
 	}
 
@@ -3524,7 +3524,7 @@ e_day_view_on_long_event_click (EDayView *day_view,
 			e_day_view_reshape_resize_long_event_rect_item (day_view);
 
 			/* Raise the event's item, above the rect as well. */
-			gnome_canvas_item_raise_to_top (event->canvas_item);
+			foo_canvas_item_raise_to_top (event->canvas_item);
 		}
 	} else if (e_day_view_get_long_event_position (day_view, event_num,
 						       &start_day, &end_day,
@@ -3563,7 +3563,7 @@ e_day_view_on_event_click (EDayView *day_view,
 	/* Ignore clicks on the EText while editing. */
 	if (pos == E_CALENDAR_VIEW_POS_EVENT
 	    && E_TEXT (event->canvas_item)->editing) {
-		GNOME_CANVAS_ITEM_GET_CLASS (event->canvas_item)->event (event->canvas_item, (GdkEvent*)bevent);
+		FOO_CANVAS_ITEM_GET_CLASS (event->canvas_item)->event (event->canvas_item, (GdkEvent*)bevent);
 		return;
 	}
 
@@ -3604,7 +3604,7 @@ e_day_view_on_event_click (EDayView *day_view,
 			e_day_view_reshape_main_canvas_resize_bars (day_view);
 
 			/* Raise the event's item, above the rect as well. */
-			gnome_canvas_item_raise_to_top (event->canvas_item);
+			foo_canvas_item_raise_to_top (event->canvas_item);
 		}
 
 	} else {
@@ -3954,7 +3954,7 @@ e_day_view_on_top_canvas_motion (GtkWidget *widget,
 		}
 
 		if (event && E_IS_TEXT (event->canvas_item) && E_TEXT (event->canvas_item)->editing) {
-			GNOME_CANVAS_ITEM_GET_CLASS (event->canvas_item)->event (event->canvas_item, (GdkEvent*)mevent);
+			FOO_CANVAS_ITEM_GET_CLASS (event->canvas_item)->event (event->canvas_item, (GdkEvent*)mevent);
 		}
 	}
 
@@ -4062,7 +4062,7 @@ e_day_view_on_main_canvas_motion (GtkWidget *widget,
 		}
 
 		if (event && E_IS_TEXT (event->canvas_item) && E_TEXT (event->canvas_item)->editing) {
-			GNOME_CANVAS_ITEM_GET_CLASS (event->canvas_item)->event (event->canvas_item, (GdkEvent*)mevent);
+			FOO_CANVAS_ITEM_GET_CLASS (event->canvas_item)->event (event->canvas_item, (GdkEvent*)mevent);
 		}
 	}
 
@@ -4818,7 +4818,7 @@ e_day_view_reshape_long_event (EDayView *day_view,
 		color = e_day_view_get_text_color (day_view, event, widget);
 
 		event->canvas_item =
-			gnome_canvas_item_new (GNOME_CANVAS_GROUP (GNOME_CANVAS (day_view->top_canvas)->root),
+			foo_canvas_item_new (FOO_CANVAS_GROUP (FOO_CANVAS (day_view->top_canvas)->root),
 					       e_text_get_type (),
 					       "anchor", GTK_ANCHOR_NW,
 					       "clip", TRUE,
@@ -4886,7 +4886,7 @@ e_day_view_reshape_long_event (EDayView *day_view,
 	}
 
 	text_w = MAX (text_w, 0);
-	gnome_canvas_item_set (event->canvas_item,
+	foo_canvas_item_set (event->canvas_item,
 			       "clip_width", (gdouble) text_w,
 			       "clip_height", (gdouble) item_h,
 			       NULL);
@@ -4998,7 +4998,7 @@ e_day_view_reshape_day_event (EDayView *day_view,
 			color = e_day_view_get_text_color (day_view, event, widget);
 
 			event->canvas_item =
-				gnome_canvas_item_new (GNOME_CANVAS_GROUP (GNOME_CANVAS (day_view->main_canvas)->root),
+				foo_canvas_item_new (FOO_CANVAS_GROUP (FOO_CANVAS (day_view->main_canvas)->root),
 						       e_text_get_type (),
 						       "anchor", GTK_ANCHOR_NW,
 						       "line_wrap", TRUE,
@@ -5020,7 +5020,7 @@ e_day_view_reshape_day_event (EDayView *day_view,
 		}
 
 		item_w = MAX (item_w, 0);
-		gnome_canvas_item_set (event->canvas_item,
+		foo_canvas_item_set (event->canvas_item,
 				       "clip_width", (gdouble) item_w,
 				       "clip_height", (gdouble) item_h,
 				       "x_offset", (gdouble) icons_offset,
@@ -6035,7 +6035,7 @@ e_day_view_start_editing_event (EDayView *day_view,
 			gchar *initial_text;
 
 			initial_text = e_utf8_from_gtk_event_key (GTK_WIDGET (day_view), key_event->keyval, key_event->string);
-			gnome_canvas_item_set (event->canvas_item,
+			foo_canvas_item_set (event->canvas_item,
 					       "text", initial_text,
 					       NULL);
 			if (initial_text)
@@ -6118,7 +6118,7 @@ tooltip_get_view_event (EDayView *day_view, gint day, gint event_num)
 }
 
 static void
-tooltip_destroy (EDayView *day_view, GnomeCanvasItem *item)
+tooltip_destroy (EDayView *day_view, FooCanvasItem *item)
 {
 	EDayViewEvent *pevent;
 	gint event_num = GPOINTER_TO_INT(g_object_get_data ((GObject *)item, "event-num"));
@@ -6141,7 +6141,7 @@ tooltip_destroy (EDayView *day_view, GnomeCanvasItem *item)
 }
 
 static gboolean
-e_day_view_on_text_item_event (GnomeCanvasItem *item,
+e_day_view_on_text_item_event (FooCanvasItem *item,
 			       GdkEvent *event,
 			       EDayView *day_view)
 {
@@ -6521,7 +6521,7 @@ e_day_view_change_event_end_time_down (EDayView *day_view)
 
 static void
 e_day_view_on_editing_started (EDayView *day_view,
-			       GnomeCanvasItem *item)
+			       FooCanvasItem *item)
 {
 	gint day, event_num;
 
@@ -6560,7 +6560,7 @@ e_day_view_on_editing_started (EDayView *day_view,
 			scroll_y = gtk_adjustment_get_value (GTK_LAYOUT (day_view->top_canvas)->vadjustment);
 			if (item_y + day_view->top_row_height > day_view->top_canvas->allocation.height + scroll_y ||
 			    item_y < scroll_y)
-				gnome_canvas_scroll_to (GNOME_CANVAS (day_view->top_canvas), 0, item_y);
+				foo_canvas_scroll_to (FOO_CANVAS (day_view->top_canvas), 0, item_y);
 		}
 	} else {
 		day_view->resize_bars_event_day = day;
@@ -6574,7 +6574,7 @@ e_day_view_on_editing_started (EDayView *day_view,
 
 static void
 e_day_view_on_editing_stopped (EDayView *day_view,
-			       GnomeCanvasItem *item)
+			       FooCanvasItem *item)
 {
 	gint day, event_num;
 	EDayViewEvent *event;
@@ -6822,7 +6822,7 @@ e_day_view_check_auto_scroll (EDayView *day_view,
 {
 	gint scroll_x, scroll_y;
 
-	gnome_canvas_get_scroll_offsets (GNOME_CANVAS (day_view->main_canvas),
+	foo_canvas_get_scroll_offsets (FOO_CANVAS (day_view->main_canvas),
 					 &scroll_x, &scroll_y);
 
 	event_x -= scroll_x;
@@ -6880,7 +6880,7 @@ e_day_view_auto_scroll_handler (gpointer data)
 		return TRUE;
 	}
 
-	gnome_canvas_get_scroll_offsets (GNOME_CANVAS (day_view->main_canvas),
+	foo_canvas_get_scroll_offsets (FOO_CANVAS (day_view->main_canvas),
 					 &scroll_x, &scroll_y);
 
 	adj = GTK_LAYOUT (day_view->main_canvas)->vadjustment;
@@ -6894,7 +6894,7 @@ e_day_view_auto_scroll_handler (gpointer data)
 	if (new_scroll_y != scroll_y) {
 		/* NOTE: This reduces flicker, but only works if we don't use
 		   canvas items which have X windows. */
-		gnome_canvas_scroll_to (GNOME_CANVAS (day_view->main_canvas),
+		foo_canvas_scroll_to (FOO_CANVAS (day_view->main_canvas),
 					scroll_x, new_scroll_y);
 	}
 
@@ -6921,7 +6921,7 @@ e_day_view_auto_scroll_handler (gpointer data)
 		} else if (day_view->resize_drag_pos != E_CALENDAR_VIEW_POS_NONE) {
 			e_day_view_update_resize (day_view, row);
 		} else if (day_view->drag_item->object.flags
-			   & GNOME_CANVAS_ITEM_VISIBLE) {
+			   & FOO_CANVAS_ITEM_VISIBLE) {
 			e_day_view_update_main_canvas_drag (day_view, row,
 							    day);
 		}
@@ -7242,7 +7242,7 @@ e_day_view_on_top_canvas_drag_motion (GtkWidget      *widget,
 {
 	gint scroll_x, scroll_y;
 
-	gnome_canvas_get_scroll_offsets (GNOME_CANVAS (widget),
+	foo_canvas_get_scroll_offsets (FOO_CANVAS (widget),
 					 &scroll_x, &scroll_y);
 	day_view->drag_event_x = x + scroll_x;
 	day_view->drag_event_y = y + scroll_y;
@@ -7314,7 +7314,7 @@ e_day_view_update_top_canvas_drag (EDayView *day_view,
 	/* If the position hasn't changed, just return. */
 	if (day_view->drag_last_day == day
 	    && (day_view->drag_long_event_item->object.flags
-		& GNOME_CANVAS_ITEM_VISIBLE))
+		& FOO_CANVAS_ITEM_VISIBLE))
 		return;
 
 	day_view->drag_last_day = day;
@@ -7326,14 +7326,14 @@ e_day_view_update_top_canvas_drag (EDayView *day_view,
 	item_h = day_view->top_row_height - E_DAY_VIEW_TOP_CANVAS_Y_GAP;
 
 	/* Set the positions of the event & associated items. */
-	gnome_canvas_item_set (day_view->drag_long_event_rect_item,
+	foo_canvas_item_set (day_view->drag_long_event_rect_item,
 			       "x1", item_x,
 			       "y1", item_y,
 			       "x2", item_x + item_w - 1,
 			       "y2", item_y + item_h - 1,
 			       NULL);
 
-	gnome_canvas_item_set (day_view->drag_long_event_item,
+	foo_canvas_item_set (day_view->drag_long_event_item,
 			       "clip_width", item_w - (E_DAY_VIEW_LONG_EVENT_BORDER_WIDTH + E_DAY_VIEW_LONG_EVENT_X_PAD) * 2,
 			       "clip_height", item_h - (E_DAY_VIEW_LONG_EVENT_BORDER_HEIGHT + E_DAY_VIEW_LONG_EVENT_Y_PAD) * 2,
 			       NULL);
@@ -7341,16 +7341,16 @@ e_day_view_update_top_canvas_drag (EDayView *day_view,
 				     item_x + E_DAY_VIEW_LONG_EVENT_BORDER_WIDTH + E_DAY_VIEW_LONG_EVENT_X_PAD,
 				     item_y + E_DAY_VIEW_LONG_EVENT_BORDER_HEIGHT + E_DAY_VIEW_LONG_EVENT_Y_PAD);
 
-	if (!(day_view->drag_long_event_rect_item->object.flags & GNOME_CANVAS_ITEM_VISIBLE)) {
-		gnome_canvas_item_raise_to_top (day_view->drag_long_event_rect_item);
-		gnome_canvas_item_show (day_view->drag_long_event_rect_item);
+	if (!(day_view->drag_long_event_rect_item->object.flags & FOO_CANVAS_ITEM_VISIBLE)) {
+		foo_canvas_item_raise_to_top (day_view->drag_long_event_rect_item);
+		foo_canvas_item_show (day_view->drag_long_event_rect_item);
 	}
 
 	/* Set the text, if necessary. We don't want to set the text every
 	   time it moves, so we check if it is currently invisible and only
 	   set the text then. */
 	if (!(day_view->drag_long_event_item->object.flags
-	      & GNOME_CANVAS_ITEM_VISIBLE)) {
+	      & FOO_CANVAS_ITEM_VISIBLE)) {
 		const gchar *summary;
 
 		if (event) {
@@ -7360,11 +7360,11 @@ e_day_view_update_top_canvas_drag (EDayView *day_view,
 			text = NULL;
 		}
 
-		gnome_canvas_item_set (day_view->drag_long_event_item,
+		foo_canvas_item_set (day_view->drag_long_event_item,
 				       "text", text ? text : "",
 				       NULL);
-		gnome_canvas_item_raise_to_top (day_view->drag_long_event_item);
-		gnome_canvas_item_show (day_view->drag_long_event_item);
+		foo_canvas_item_raise_to_top (day_view->drag_long_event_item);
+		foo_canvas_item_show (day_view->drag_long_event_item);
 
 		g_free (text);
 	}
@@ -7380,7 +7380,7 @@ e_day_view_on_main_canvas_drag_motion (GtkWidget      *widget,
 {
 	gint scroll_x, scroll_y;
 
-	gnome_canvas_get_scroll_offsets (GNOME_CANVAS (widget),
+	foo_canvas_get_scroll_offsets (FOO_CANVAS (widget),
 					 &scroll_x, &scroll_y);
 
 	day_view->drag_event_x = x + scroll_x;
@@ -7431,7 +7431,7 @@ e_day_view_update_main_canvas_drag (EDayView *day_view,
 	/* If the position hasn't changed, just return. */
 	if (day_view->drag_last_day == day
 	    && day_view->drag_last_row == row
-	    && (day_view->drag_item->object.flags & GNOME_CANVAS_ITEM_VISIBLE))
+	    && (day_view->drag_item->object.flags & FOO_CANVAS_ITEM_VISIBLE))
 		return;
 
 	day_view->drag_last_day = day;
@@ -7474,21 +7474,21 @@ e_day_view_update_main_canvas_drag (EDayView *day_view,
 	item_h = num_rows * day_view->row_height;
 
 	/* Set the positions of the event & associated items. */
-	gnome_canvas_item_set (day_view->drag_rect_item,
+	foo_canvas_item_set (day_view->drag_rect_item,
 			       "x1", item_x + E_DAY_VIEW_BAR_WIDTH - 1,
 			       "y1", item_y,
 			       "x2", item_x + item_w - 1,
 			       "y2", item_y + item_h - 1,
 			       NULL);
 
-	gnome_canvas_item_set (day_view->drag_bar_item,
+	foo_canvas_item_set (day_view->drag_bar_item,
 			       "x1", item_x,
 			       "y1", item_y,
 			       "x2", item_x + E_DAY_VIEW_BAR_WIDTH - 1,
 			       "y2", item_y + item_h - 1,
 			       NULL);
 
-	gnome_canvas_item_set (day_view->drag_item,
+	foo_canvas_item_set (day_view->drag_item,
 			       "clip_width", item_w - E_DAY_VIEW_BAR_WIDTH - E_DAY_VIEW_EVENT_X_PAD * 2,
 			       "clip_height", item_h - (E_DAY_VIEW_EVENT_BORDER_HEIGHT + E_DAY_VIEW_EVENT_Y_PAD) * 2,
 			       NULL);
@@ -7496,20 +7496,20 @@ e_day_view_update_main_canvas_drag (EDayView *day_view,
 				     item_x + E_DAY_VIEW_BAR_WIDTH + E_DAY_VIEW_EVENT_X_PAD,
 				     item_y + E_DAY_VIEW_EVENT_BORDER_HEIGHT + E_DAY_VIEW_EVENT_Y_PAD);
 
-	if (!(day_view->drag_bar_item->object.flags & GNOME_CANVAS_ITEM_VISIBLE)) {
-		gnome_canvas_item_raise_to_top (day_view->drag_bar_item);
-		gnome_canvas_item_show (day_view->drag_bar_item);
+	if (!(day_view->drag_bar_item->object.flags & FOO_CANVAS_ITEM_VISIBLE)) {
+		foo_canvas_item_raise_to_top (day_view->drag_bar_item);
+		foo_canvas_item_show (day_view->drag_bar_item);
 	}
 
-	if (!(day_view->drag_rect_item->object.flags & GNOME_CANVAS_ITEM_VISIBLE)) {
-		gnome_canvas_item_raise_to_top (day_view->drag_rect_item);
-		gnome_canvas_item_show (day_view->drag_rect_item);
+	if (!(day_view->drag_rect_item->object.flags & FOO_CANVAS_ITEM_VISIBLE)) {
+		foo_canvas_item_raise_to_top (day_view->drag_rect_item);
+		foo_canvas_item_show (day_view->drag_rect_item);
 	}
 
 	/* Set the text, if necessary. We don't want to set the text every
 	   time it moves, so we check if it is currently invisible and only
 	   set the text then. */
-	if (!(day_view->drag_item->object.flags & GNOME_CANVAS_ITEM_VISIBLE)) {
+	if (!(day_view->drag_item->object.flags & FOO_CANVAS_ITEM_VISIBLE)) {
 		const gchar *summary;
 
 		if (event) {
@@ -7519,11 +7519,11 @@ e_day_view_update_main_canvas_drag (EDayView *day_view,
 			text = NULL;
 		}
 
-		gnome_canvas_item_set (day_view->drag_item,
+		foo_canvas_item_set (day_view->drag_item,
 				       "text", text ? text : "",
 				       NULL);
-		gnome_canvas_item_raise_to_top (day_view->drag_item);
-		gnome_canvas_item_show (day_view->drag_item);
+		foo_canvas_item_raise_to_top (day_view->drag_item);
+		foo_canvas_item_show (day_view->drag_item);
 
 		g_free (text);
 	}
@@ -7537,8 +7537,8 @@ e_day_view_on_top_canvas_drag_leave (GtkWidget      *widget,
 {
 	day_view->drag_last_day = -1;
 
-	gnome_canvas_item_hide (day_view->drag_long_event_rect_item);
-	gnome_canvas_item_hide (day_view->drag_long_event_item);
+	foo_canvas_item_hide (day_view->drag_long_event_rect_item);
+	foo_canvas_item_hide (day_view->drag_long_event_item);
 }
 
 static void
@@ -7551,9 +7551,9 @@ e_day_view_on_main_canvas_drag_leave (GtkWidget      *widget,
 
 	e_day_view_stop_auto_scroll (day_view);
 
-	gnome_canvas_item_hide (day_view->drag_rect_item);
-	gnome_canvas_item_hide (day_view->drag_bar_item);
-	gnome_canvas_item_hide (day_view->drag_item);
+	foo_canvas_item_hide (day_view->drag_rect_item);
+	foo_canvas_item_hide (day_view->drag_bar_item);
+	foo_canvas_item_hide (day_view->drag_item);
 
 	/* Hide the resize bars if they are being used in the drag. */
 	if (day_view->drag_event_day == day_view->resize_bars_event_day
@@ -7585,7 +7585,7 @@ e_day_view_on_drag_begin (GtkWidget      *widget,
 
 	/* Hide the text item, since it will be shown in the special drag
 	   items. */
-	gnome_canvas_item_hide (event->canvas_item);
+	foo_canvas_item_hide (event->canvas_item);
 }
 
 static void
@@ -7615,7 +7615,7 @@ e_day_view_on_drag_end (GtkWidget      *widget,
 	}
 
 	/* Show the text item again. */
-	gnome_canvas_item_show (event->canvas_item);
+	foo_canvas_item_show (event->canvas_item);
 
 	day_view->drag_event_day = -1;
 	day_view->drag_event_num = -1;
@@ -7803,7 +7803,7 @@ e_day_view_on_top_canvas_drag_data_received  (GtkWidget          *widget,
 			/* Show the text item again, just in case it hasn't
 			   moved. If we don't do this it may not appear. */
 			if (event->canvas_item)
-				gnome_canvas_item_show (event->canvas_item);
+				foo_canvas_item_show (event->canvas_item);
 
 			e_cal_component_commit_sequence (comp);
 			if (e_cal_component_has_recurrences (comp)) {
@@ -7929,7 +7929,7 @@ e_day_view_on_main_canvas_drag_data_received  (GtkWidget          *widget,
 
 	client = e_cal_model_get_default_client (e_calendar_view_get_model (E_CALENDAR_VIEW (day_view)));
 
-	gnome_canvas_get_scroll_offsets (GNOME_CANVAS (widget),
+	foo_canvas_get_scroll_offsets (FOO_CANVAS (widget),
 					 &scroll_x, &scroll_y);
 	x += scroll_x;
 	y += scroll_y;
@@ -8008,7 +8008,7 @@ e_day_view_on_main_canvas_drag_data_received  (GtkWidget          *widget,
 			/* Show the text item again, just in case it hasn't
 			   moved. If we don't do this it may not appear. */
 			if (event->canvas_item)
-				gnome_canvas_item_show (event->canvas_item);
+				foo_canvas_item_show (event->canvas_item);
 
 			e_cal_component_commit_sequence (comp);
 			if (e_cal_component_has_recurrences (comp)) {
diff --git a/calendar/gui/e-day-view.h b/calendar/gui/e-day-view.h
index aee8be0..a85f49b 100644
--- a/calendar/gui/e-day-view.h
+++ b/calendar/gui/e-day-view.h
@@ -26,7 +26,7 @@
 
 #include <time.h>
 #include <gtk/gtk.h>
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 
 #include "e-calendar-view.h"
 #include "gnome-cal.h"
@@ -210,11 +210,11 @@ struct _EDayView {
 
 	/* The top canvas where the dates are shown. */
 	GtkWidget *top_dates_canvas;
-	GnomeCanvasItem *top_dates_canvas_item;
+	FooCanvasItem *top_dates_canvas_item;
 
 	/* The top canvas where the dates and long appointments are shown. */
 	GtkWidget *top_canvas;
-	GnomeCanvasItem *top_canvas_item;
+	FooCanvasItem *top_canvas_item;
 
 	/* scrollbar for top_canvas */
 	GtkWidget *tc_vscrollbar;
@@ -224,11 +224,11 @@ struct _EDayView {
 
 	/* The main canvas where the rest of the appointments are shown. */
 	GtkWidget *main_canvas;
-	GnomeCanvasItem *main_canvas_item;
+	FooCanvasItem *main_canvas_item;
 
 	/* The canvas displaying the times of the day. */
 	GtkWidget *time_canvas;
-	GnomeCanvasItem *time_canvas_item;
+	FooCanvasItem *time_canvas_item;
 
 	GtkWidget *vscrollbar;
 
@@ -381,19 +381,19 @@ struct _EDayView {
 	 */
 
 	/* The horizontal bars to resize events in the main canvas. */
-	GnomeCanvasItem *main_canvas_top_resize_bar_item;
-	GnomeCanvasItem *main_canvas_bottom_resize_bar_item;
+	FooCanvasItem *main_canvas_top_resize_bar_item;
+	FooCanvasItem *main_canvas_bottom_resize_bar_item;
 
 	/* The event currently being edited. The day is -1 if no event is
 	 being edited, or E_DAY_VIEW_LONG_EVENT if a long event is edited. */
 	gint editing_event_day;
 	gint editing_event_num;
 
-	/* This is a GnomeCanvasRect which is placed around an item while it
+	/* This is a FooCanvasRect which is placed around an item while it
 	   is being resized, so we can raise it above all other EText items. */
-	GnomeCanvasItem *resize_long_event_rect_item;
-	GnomeCanvasItem *resize_rect_item;
-	GnomeCanvasItem *resize_bar_item;
+	FooCanvasItem *resize_long_event_rect_item;
+	FooCanvasItem *resize_rect_item;
+	FooCanvasItem *resize_bar_item;
 
 	/* The event for which a popup menu is being displayed, as above. */
 	gint popup_event_day;
@@ -466,13 +466,13 @@ struct _EDayView {
 	gint drag_last_day;
 	gint drag_last_row;
 
-	/* This is a GnomeCanvasRect which is placed around an item while it
+	/* This is a FooCanvasRect which is placed around an item while it
 	   is being resized, so we can raise it above all other EText items. */
-	GnomeCanvasItem *drag_long_event_rect_item;
-	GnomeCanvasItem *drag_long_event_item;
-	GnomeCanvasItem *drag_rect_item;
-	GnomeCanvasItem *drag_bar_item;
-	GnomeCanvasItem *drag_item;
+	FooCanvasItem *drag_long_event_rect_item;
+	FooCanvasItem *drag_long_event_item;
+	FooCanvasItem *drag_rect_item;
+	FooCanvasItem *drag_bar_item;
+	FooCanvasItem *drag_item;
 
 	/* "am" and "pm" in the current locale, and their widths. */
 	gchar *am_string;
@@ -618,7 +618,7 @@ gint	   e_day_view_event_sort_func		(const void	*arg1,
 						 const void	*arg2);
 
 gboolean e_day_view_find_event_from_item (EDayView *day_view,
-					  GnomeCanvasItem *item,
+					  FooCanvasItem *item,
 					  gint *day_return,
 					  gint *event_num_return);
 void e_day_view_update_calendar_selection_time (EDayView *day_view);
diff --git a/calendar/gui/e-meeting-time-sel-item.c b/calendar/gui/e-meeting-time-sel-item.c
index 041ae6e..2fd01db 100644
--- a/calendar/gui/e-meeting-time-sel-item.c
+++ b/calendar/gui/e-meeting-time-sel-item.c
@@ -1,7 +1,7 @@
 /*
- * EMeetingTimeSelectorItem - A GnomeCanvasItem which is used for both the main
+ * EMeetingTimeSelectorItem - A FooCanvasItem which is used for both the main
  * display canvas and the top display (with the dates, times & All Attendees).
- * I didn't make these separate GnomeCanvasItems since they share a lot of
+ * I didn't make these separate FooCanvasItems since they share a lot of
  * code.
  *
  * This program is free software; you can redistribute it and/or
@@ -45,20 +45,20 @@ static void e_meeting_time_selector_item_set_property (GObject *object,
                                                        guint property_id,
                                                        const GValue *value,
                                                        GParamSpec *pspec);
-static void e_meeting_time_selector_item_realize (GnomeCanvasItem *item);
-static void e_meeting_time_selector_item_unrealize (GnomeCanvasItem *item);
-static void e_meeting_time_selector_item_update (GnomeCanvasItem *item,
+static void e_meeting_time_selector_item_realize (FooCanvasItem *item);
+static void e_meeting_time_selector_item_unrealize (FooCanvasItem *item);
+static void e_meeting_time_selector_item_update (FooCanvasItem *item,
 						 double *affine,
 						 ArtSVP *clip_path, gint flags);
-static void e_meeting_time_selector_item_draw (GnomeCanvasItem *item,
+static void e_meeting_time_selector_item_draw (FooCanvasItem *item,
 					       GdkDrawable *drawable,
 					       gint x, gint y,
 					       gint width, gint height);
-static double e_meeting_time_selector_item_point (GnomeCanvasItem *item,
+static double e_meeting_time_selector_item_point (FooCanvasItem *item,
 						  double x, double y,
 						  gint cx, gint cy,
-						  GnomeCanvasItem **actual_item);
-static gint e_meeting_time_selector_item_event (GnomeCanvasItem *item,
+						  FooCanvasItem **actual_item);
+static gint e_meeting_time_selector_item_event (FooCanvasItem *item,
 						GdkEvent *event);
 static gint e_meeting_time_selector_item_button_press (EMeetingTimeSelectorItem *mts_item,
 						       GdkEvent *event);
@@ -96,19 +96,19 @@ enum {
 	PROP_MEETING_TIME_SELECTOR
 };
 
-G_DEFINE_TYPE (EMeetingTimeSelectorItem, e_meeting_time_selector_item, GNOME_TYPE_CANVAS_ITEM)
+G_DEFINE_TYPE (EMeetingTimeSelectorItem, e_meeting_time_selector_item, FOO_TYPE_CANVAS_ITEM)
 
 static void
 e_meeting_time_selector_item_class_init (EMeetingTimeSelectorItemClass *class)
 {
 	GObjectClass *object_class;
-	GnomeCanvasItemClass *item_class;
+	FooCanvasItemClass *item_class;
 
 	object_class = G_OBJECT_CLASS (class);
 	object_class->dispose = e_meeting_time_selector_item_dispose;
 	object_class->set_property = e_meeting_time_selector_item_set_property;
 
-	item_class = GNOME_CANVAS_ITEM_CLASS (class);
+	item_class = FOO_CANVAS_ITEM_CLASS (class);
 	item_class->realize = e_meeting_time_selector_item_realize;
 	item_class->unrealize = e_meeting_time_selector_item_unrealize;
 	item_class->update = e_meeting_time_selector_item_update;
@@ -129,7 +129,7 @@ e_meeting_time_selector_item_class_init (EMeetingTimeSelectorItemClass *class)
 static void
 e_meeting_time_selector_item_init (EMeetingTimeSelectorItem *mts_item)
 {
-	GnomeCanvasItem *item = GNOME_CANVAS_ITEM (mts_item);
+	FooCanvasItem *item = FOO_CANVAS_ITEM (mts_item);
 
 	mts_item->mts = NULL;
 
@@ -191,14 +191,14 @@ e_meeting_time_selector_item_set_property (GObject *object,
 }
 
 static void
-e_meeting_time_selector_item_realize (GnomeCanvasItem *item)
+e_meeting_time_selector_item_realize (FooCanvasItem *item)
 {
-	GnomeCanvas *canvas;
+	FooCanvas *canvas;
 	GdkWindow *window;
 	EMeetingTimeSelectorItem *mts_item;
 
-	if (GNOME_CANVAS_ITEM_CLASS (e_meeting_time_selector_item_parent_class)->realize)
-		(*GNOME_CANVAS_ITEM_CLASS (e_meeting_time_selector_item_parent_class)->realize)(item);
+	if (FOO_CANVAS_ITEM_CLASS (e_meeting_time_selector_item_parent_class)->realize)
+		(*FOO_CANVAS_ITEM_CLASS (e_meeting_time_selector_item_parent_class)->realize)(item);
 
 	mts_item = E_MEETING_TIME_SELECTOR_ITEM (item);
 
@@ -210,7 +210,7 @@ e_meeting_time_selector_item_realize (GnomeCanvasItem *item)
 }
 
 static void
-e_meeting_time_selector_item_unrealize (GnomeCanvasItem *item)
+e_meeting_time_selector_item_unrealize (FooCanvasItem *item)
 {
 	EMeetingTimeSelectorItem *mts_item;
 
@@ -221,15 +221,15 @@ e_meeting_time_selector_item_unrealize (GnomeCanvasItem *item)
 	g_object_unref (mts_item->stipple_gc);
 	mts_item->stipple_gc = NULL;
 
-	if (GNOME_CANVAS_ITEM_CLASS (e_meeting_time_selector_item_parent_class)->unrealize)
-		(*GNOME_CANVAS_ITEM_CLASS (e_meeting_time_selector_item_parent_class)->unrealize)(item);
+	if (FOO_CANVAS_ITEM_CLASS (e_meeting_time_selector_item_parent_class)->unrealize)
+		(*FOO_CANVAS_ITEM_CLASS (e_meeting_time_selector_item_parent_class)->unrealize)(item);
 }
 
 static void
-e_meeting_time_selector_item_update (GnomeCanvasItem *item, double *affine, ArtSVP *clip_path, gint flags)
+e_meeting_time_selector_item_update (FooCanvasItem *item, double *affine, ArtSVP *clip_path, gint flags)
 {
-	if (GNOME_CANVAS_ITEM_CLASS (e_meeting_time_selector_item_parent_class)->update)
-		(* GNOME_CANVAS_ITEM_CLASS (e_meeting_time_selector_item_parent_class)->update) (item, affine, clip_path, flags);
+	if (FOO_CANVAS_ITEM_CLASS (e_meeting_time_selector_item_parent_class)->update)
+		(* FOO_CANVAS_ITEM_CLASS (e_meeting_time_selector_item_parent_class)->update) (item, affine, clip_path, flags);
 
 	/* The grid covers the entire canvas area. */
 	item->x1 = 0;
@@ -243,7 +243,7 @@ e_meeting_time_selector_item_update (GnomeCanvasItem *item, double *affine, ArtS
  */
 
 static void
-e_meeting_time_selector_item_draw (GnomeCanvasItem *item, GdkDrawable *drawable, gint x, gint y, gint width, gint height)
+e_meeting_time_selector_item_draw (FooCanvasItem *item, GdkDrawable *drawable, gint x, gint y, gint width, gint height)
 {
 	EMeetingTimeSelector *mts;
 	EMeetingTimeSelectorItem *mts_item;
@@ -314,7 +314,7 @@ e_meeting_time_selector_item_draw (GnomeCanvasItem *item, GdkDrawable *drawable,
 		gdk_gc_set_foreground (stipple_gc, &mts->grid_color);
 		gdk_gc_set_background (stipple_gc, &mts->stipple_bg_color);
 		gdk_gc_set_stipple (stipple_gc, mts->stipple);
-		gnome_canvas_set_stipple_origin (item->canvas, stipple_gc);
+		foo_canvas_set_stipple_origin (item->canvas, stipple_gc);
 		gdk_gc_set_fill (stipple_gc, GDK_OPAQUE_STIPPLED);
 		row = y / mts->row_height;
 		row_y = row * mts->row_height - y;
@@ -354,7 +354,7 @@ e_meeting_time_selector_item_draw (GnomeCanvasItem *item, GdkDrawable *drawable,
 	/* Now paint the visible days one by one. */
 	current_date = date;
 	for (;;) {
-		/* Currently we use the same GnomeCanvasItem class for the
+		/* Currently we use the same FooCanvasItem class for the
 		   top display and the main display. We may use separate
 		   classes in future if necessary. */
 		if (is_display_top)
@@ -775,23 +775,23 @@ e_meeting_time_selector_item_paint_attendee_busy_periods (EMeetingTimeSelectorIt
 }
 
 /*
- * CANVAS ITEM ROUTINES - functions to be a GnomeCanvasItem.
+ * CANVAS ITEM ROUTINES - functions to be a FooCanvasItem.
  */
 
 /* This is supposed to return the nearest item the the point and the distance.
    Since we are the only item we just return ourself and 0 for the distance.
    This is needed so that we get button/motion events. */
 static double
-e_meeting_time_selector_item_point (GnomeCanvasItem *item, double x, double y,
+e_meeting_time_selector_item_point (FooCanvasItem *item, double x, double y,
 				    gint cx, gint cy,
-				    GnomeCanvasItem **actual_item)
+				    FooCanvasItem **actual_item)
 {
 	*actual_item = item;
 	return 0.0;
 }
 
 static gint
-e_meeting_time_selector_item_event (GnomeCanvasItem *item, GdkEvent *event)
+e_meeting_time_selector_item_event (FooCanvasItem *item, GdkEvent *event)
 {
 	EMeetingTimeSelectorItem *mts_item;
 
@@ -817,7 +817,7 @@ e_meeting_time_selector_item_event (GnomeCanvasItem *item, GdkEvent *event)
 /* This handles all button press events for the item. If the cursor is over
    one of the meeting time vertical bars we start a drag. If not we set the
    meeting time to the nearest half-hour interval.
-   Note that GnomeCanvas converts the event coords to world coords,
+   Note that FooCanvas converts the event coords to world coords,
    i.e. relative to the entire canvas scroll area. */
 static gint
 e_meeting_time_selector_item_button_press (EMeetingTimeSelectorItem *mts_item,
@@ -837,7 +837,7 @@ e_meeting_time_selector_item_button_press (EMeetingTimeSelectorItem *mts_item,
 	position = e_meeting_time_selector_item_get_drag_position (mts_item,
 								   x, y);
 	if (position != E_MEETING_TIME_SELECTOR_POS_NONE) {
-		if (gnome_canvas_item_grab (GNOME_CANVAS_ITEM (mts_item),
+		if (foo_canvas_item_grab (FOO_CANVAS_ITEM (mts_item),
 					    GDK_POINTER_MOTION_MASK
 					    | GDK_BUTTON_RELEASE_MASK,
 					    mts_item->resize_cursor,
@@ -939,7 +939,7 @@ e_meeting_time_selector_item_button_release (EMeetingTimeSelectorItem *mts_item,
 	if (mts->dragging_position != E_MEETING_TIME_SELECTOR_POS_NONE) {
 		mts->dragging_position = E_MEETING_TIME_SELECTOR_POS_NONE;
 		e_meeting_time_selector_remove_timeout (mts);
-		gnome_canvas_item_ungrab (GNOME_CANVAS_ITEM (mts_item),
+		foo_canvas_item_ungrab (FOO_CANVAS_ITEM (mts_item),
 					  event->button.time);
 	}
 
@@ -948,7 +948,7 @@ e_meeting_time_selector_item_button_release (EMeetingTimeSelectorItem *mts_item,
 
 /* This handles all motion notify events for the item. If button1 is pressed
    we check if a drag is in progress. If not, we set the cursor if we are over
-   the meeting time vertical bars. Note that GnomeCanvas doesn't use motion
+   the meeting time vertical bars. Note that FooCanvas doesn't use motion
    hints, which may affect performance. */
 static gint
 e_meeting_time_selector_item_motion_notify (EMeetingTimeSelectorItem *mts_item,
@@ -983,7 +983,7 @@ e_meeting_time_selector_item_motion_notify (EMeetingTimeSelectorItem *mts_item,
 	/* Only set the cursor if it is different to the last one we set. */
 	if (mts_item->last_cursor_set != cursor) {
 		mts_item->last_cursor_set = cursor;
-		gdk_window_set_cursor (GTK_WIDGET (GNOME_CANVAS_ITEM (mts_item)->canvas)->window, cursor);
+		gdk_window_set_cursor (GTK_WIDGET (FOO_CANVAS_ITEM (mts_item)->canvas)->window, cursor);
 	}
 
 	return FALSE;
@@ -999,7 +999,7 @@ e_meeting_time_selector_item_get_drag_position (EMeetingTimeSelectorItem *mts_it
 
 	mts = mts_item->mts;
 
-	is_display_top = (GTK_WIDGET (GNOME_CANVAS_ITEM (mts_item)->canvas) == mts->display_top) ? TRUE : FALSE;
+	is_display_top = (GTK_WIDGET (FOO_CANVAS_ITEM (mts_item)->canvas) == mts->display_top) ? TRUE : FALSE;
 
 	if (is_display_top && y < mts->row_height * 2)
 		return E_MEETING_TIME_SELECTOR_POS_NONE;
@@ -1051,5 +1051,5 @@ e_meeting_time_selector_item_set_normal_cursor (EMeetingTimeSelectorItem *mts_it
 {
 	g_return_if_fail (IS_E_MEETING_TIME_SELECTOR_ITEM (mts_item));
 
-	gdk_window_set_cursor (GTK_WIDGET (GNOME_CANVAS_ITEM (mts_item)->canvas)->window, mts_item->normal_cursor);
+	gdk_window_set_cursor (GTK_WIDGET (FOO_CANVAS_ITEM (mts_item)->canvas)->window, mts_item->normal_cursor);
 }
diff --git a/calendar/gui/e-meeting-time-sel-item.h b/calendar/gui/e-meeting-time-sel-item.h
index 547f01a..5581858 100644
--- a/calendar/gui/e-meeting-time-sel-item.h
+++ b/calendar/gui/e-meeting-time-sel-item.h
@@ -22,9 +22,9 @@
  */
 
 /*
- * MeetingTimeSelectorItem - A GnomeCanvasItem which is used for both the main
+ * MeetingTimeSelectorItem - A FooCanvasItem which is used for both the main
  * display canvas and the top display (with the dates, times & All Attendees).
- * I didn't make these separate GnomeCanvasItems since they share a lot of
+ * I didn't make these separate FooCanvasItems since they share a lot of
  * code.
  */
 
@@ -44,7 +44,7 @@ typedef struct _EMeetingTimeSelectorItemClass  EMeetingTimeSelectorItemClass;
 
 struct _EMeetingTimeSelectorItem
 {
-	GnomeCanvasItem canvas_item;
+	FooCanvasItem canvas_item;
 
 	/* The parent EMeetingTimeSelector widget. */
 	EMeetingTimeSelector *mts;
@@ -65,7 +65,7 @@ struct _EMeetingTimeSelectorItem
 
 struct _EMeetingTimeSelectorItemClass
 {
-	GnomeCanvasItemClass parent_class;
+	FooCanvasItemClass parent_class;
 };
 
 GType e_meeting_time_selector_item_get_type (void);
diff --git a/calendar/gui/e-meeting-time-sel.c b/calendar/gui/e-meeting-time-sel.c
index 4bd1ed1..691a471 100644
--- a/calendar/gui/e-meeting-time-sel.c
+++ b/calendar/gui/e-meeting-time-sel.c
@@ -33,7 +33,7 @@
 #include <time.h>
 #include <gdk/gdkkeysyms.h>
 #include <glib/gi18n.h>
-#include <libgnomecanvas/gnome-canvas-widget.h>
+#include <libfoocanvas/foo-canvas-widget.h>
 
 #include "misc/e-canvas.h"
 #include "misc/e-canvas-utils.h"
@@ -480,9 +480,9 @@ e_meeting_time_selector_construct (EMeetingTimeSelector * mts, EMeetingStore *em
 	gtk_box_pack_start (GTK_BOX (mts->attendees_vbox), GTK_WIDGET (sw), TRUE, TRUE, 6);
 
 	/* The free/busy information */
-	mts->display_top = gnome_canvas_new ();
+	mts->display_top = foo_canvas_new ();
 	gtk_widget_set_size_request (mts->display_top, -1, mts->row_height * 3);
-	gnome_canvas_set_scroll_region (GNOME_CANVAS (mts->display_top),
+	foo_canvas_set_scroll_region (FOO_CANVAS (mts->display_top),
 					0, 0,
 					mts->day_width * E_MEETING_TIME_SELECTOR_DAYS_SHOWN,
 					mts->row_height * 3);
@@ -493,7 +493,7 @@ e_meeting_time_selector_construct (EMeetingTimeSelector * mts, EMeetingStore *em
 	g_signal_connect (mts->display_top, "realize",
 			  G_CALLBACK (e_meeting_time_selector_on_canvas_realized), mts);
 
-	mts->display_main = gnome_canvas_new ();
+	mts->display_main = foo_canvas_new ();
 	e_meeting_time_selector_update_main_canvas_scroll_region (mts);
 	/* Add some horizontal padding for the shadow around the display. */
 	gtk_table_attach (GTK_TABLE (mts), mts->display_main,
@@ -522,13 +522,13 @@ e_meeting_time_selector_construct (EMeetingTimeSelector * mts, EMeetingStore *em
 	gtk_widget_show (mts->vscrollbar);
 
 	/* Create the item in the top canvas. */
-	mts->item_top = gnome_canvas_item_new (GNOME_CANVAS_GROUP (GNOME_CANVAS (mts->display_top)->root),
+	mts->item_top = foo_canvas_item_new (FOO_CANVAS_GROUP (FOO_CANVAS (mts->display_top)->root),
 			       e_meeting_time_selector_item_get_type (),
 			       "EMeetingTimeSelectorItem::meeting_time_selector", mts,
 			       NULL);
 
 	/* Create the item in the main canvas. */
-	mts->item_main = gnome_canvas_item_new (GNOME_CANVAS_GROUP (GNOME_CANVAS (mts->display_main)->root),
+	mts->item_main = foo_canvas_item_new (FOO_CANVAS_GROUP (FOO_CANVAS (mts->display_main)->root),
 			       e_meeting_time_selector_item_get_type (),
 			       "EMeetingTimeSelectorItem::meeting_time_selector", mts,
 			       NULL);
@@ -2149,7 +2149,7 @@ e_meeting_time_selector_recalc_grid (EMeetingTimeSelector *mts)
 	/* Add one pixel for the extra vertical grid line. */
 	mts->day_width++;
 
-	gnome_canvas_set_scroll_region (GNOME_CANVAS (mts->display_top),
+	foo_canvas_set_scroll_region (FOO_CANVAS (mts->display_top),
 					0, 0,
 					mts->day_width * E_MEETING_TIME_SELECTOR_DAYS_SHOWN,
 					mts->row_height * 3);
@@ -2166,7 +2166,7 @@ e_meeting_time_selector_save_position (EMeetingTimeSelector *mts,
 {
 	gint scroll_x, scroll_y;
 
-	gnome_canvas_get_scroll_offsets (GNOME_CANVAS (mts->display_main),
+	foo_canvas_get_scroll_offsets (FOO_CANVAS (mts->display_main),
 					 &scroll_x, &scroll_y);
 	e_meeting_time_selector_calculate_time (mts, scroll_x, mtstime);
 }
@@ -2180,9 +2180,9 @@ e_meeting_time_selector_restore_position (EMeetingTimeSelector *mts,
 
 	new_scroll_x = e_meeting_time_selector_calculate_time_position (mts,
 									mtstime);
-	gnome_canvas_get_scroll_offsets (GNOME_CANVAS (mts->display_main),
+	foo_canvas_get_scroll_offsets (FOO_CANVAS (mts->display_main),
 					 &scroll_x, &scroll_y);
-	gnome_canvas_scroll_to (GNOME_CANVAS (mts->display_main),
+	foo_canvas_scroll_to (FOO_CANVAS (mts->display_main),
 				new_scroll_x, scroll_y);
 }
 
@@ -2331,7 +2331,7 @@ e_meeting_time_selector_recalc_date_format (EMeetingTimeSelector *mts)
 }
 
 /* Turn off the background of the canvas windows. This reduces flicker
-   considerably when scrolling. (Why isn't it in GnomeCanvas?). */
+   considerably when scrolling. (Why isn't it in FooCanvas?). */
 static void
 e_meeting_time_selector_on_canvas_realized (GtkWidget *widget,
 					    EMeetingTimeSelector *mts)
@@ -2492,7 +2492,7 @@ e_meeting_time_selector_update_main_canvas_scroll_region (EMeetingTimeSelector *
 
 	height = MAX (height,  canvas_height);
 
-	gnome_canvas_set_scroll_region (GNOME_CANVAS (mts->display_main),
+	foo_canvas_set_scroll_region (FOO_CANVAS (mts->display_main),
 					0, 0,
 					mts->day_width * E_MEETING_TIME_SELECTOR_DAYS_SHOWN,
 					height);
@@ -2512,7 +2512,7 @@ e_meeting_time_selector_drag_meeting_time (EMeetingTimeSelector *mts,
 	gboolean set_both_times = FALSE;
 
 	/* Get the x coords of visible part of the canvas. */
-	gnome_canvas_get_scroll_offsets (GNOME_CANVAS (mts->display_main),
+	foo_canvas_get_scroll_offsets (FOO_CANVAS (mts->display_main),
 					 &scroll_x, &scroll_y);
 	canvas_width = mts->display_main->allocation.width;
 
@@ -2672,7 +2672,7 @@ e_meeting_time_selector_timeout_handler (gpointer data)
 	}
 
 	/* Get the x coords of visible part of the canvas. */
-	gnome_canvas_get_scroll_offsets (GNOME_CANVAS (mts->display_main),
+	foo_canvas_get_scroll_offsets (FOO_CANVAS (mts->display_main),
 					 &scroll_x, &scroll_y);
 	canvas_width = mts->display_main->allocation.width;
 
@@ -2792,9 +2792,9 @@ e_meeting_time_selector_timeout_handler (gpointer data)
 	   get redrawn completely. Otherwise the pixels get scrolled left or
 	   right which is not good for us (since our vertical bars have been
 	   moved) and causes flicker. */
-	gnome_canvas_scroll_to (GNOME_CANVAS (mts->display_main),
+	foo_canvas_scroll_to (FOO_CANVAS (mts->display_main),
 				scroll_x, scroll_y);
-	gnome_canvas_scroll_to (GNOME_CANVAS (mts->display_top),
+	foo_canvas_scroll_to (FOO_CANVAS (mts->display_top),
 				scroll_x, scroll_y);
 
 	GDK_THREADS_LEAVE ();
@@ -2869,14 +2869,14 @@ e_meeting_time_selector_ensure_meeting_time_shown (EMeetingTimeSelector *mts)
 		start_x = e_meeting_time_selector_calculate_time_position (mts, &time);
 	}
 
-	gnome_canvas_get_scroll_offsets (GNOME_CANVAS (mts->display_main),
+	foo_canvas_get_scroll_offsets (FOO_CANVAS (mts->display_main),
 					 &scroll_x, &scroll_y);
 	canvas_width = mts->display_main->allocation.width;
 	if (start_x > scroll_x && end_x <= scroll_x + canvas_width)
 		return;
 
 	new_scroll_x = start_x;
-	gnome_canvas_scroll_to (GNOME_CANVAS (mts->display_main),
+	foo_canvas_scroll_to (FOO_CANVAS (mts->display_main),
 				new_scroll_x, scroll_y);
 }
 
diff --git a/calendar/gui/e-meeting-time-sel.h b/calendar/gui/e-meeting-time-sel.h
index 1c61353..bb56dd3 100644
--- a/calendar/gui/e-meeting-time-sel.h
+++ b/calendar/gui/e-meeting-time-sel.h
@@ -24,7 +24,7 @@
 #define E_MEETING_TIME_SELECTOR_H
 
 #include <gtk/gtk.h>
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 #include <text/e-text.h>
 #include <table/e-table-model.h>
 #include <table/e-table.h>
@@ -135,13 +135,13 @@ struct _EMeetingTimeSelector {
 	/* The canvas displaying the dates, times, and the summary
 	   'All Attendees' free/busy display. */
 	GtkWidget *display_top;
-	GnomeCanvasItem *item_top;
+	FooCanvasItem *item_top;
 
 	/* The canvas containing the free/busy displays of individual
 	   attendees. This is separate from display_top since it also scrolls
 	   vertically. */
 	GtkWidget *display_main;
-	GnomeCanvasItem *item_main;
+	FooCanvasItem *item_main;
 
 	/* The 'Add attendees from addressbook' button */
 	GtkWidget *add_attendees_button;
diff --git a/calendar/gui/e-memo-table.c b/calendar/gui/e-memo-table.c
index 5f2cd26..52d8492 100644
--- a/calendar/gui/e-memo-table.c
+++ b/calendar/gui/e-memo-table.c
@@ -909,8 +909,8 @@ memo_table_paste_clipboard (ESelectable *selectable)
 {
 	EMemoTable *memo_table;
 	GtkClipboard *clipboard;
-	GnomeCanvasItem *item;
-	GnomeCanvas *table_canvas;
+	FooCanvasItem *item;
+	FooCanvas *table_canvas;
 
 	memo_table = E_MEMO_TABLE (selectable);
 
diff --git a/calendar/gui/e-task-table.c b/calendar/gui/e-task-table.c
index 9f0962d..55dde71 100644
--- a/calendar/gui/e-task-table.c
+++ b/calendar/gui/e-task-table.c
@@ -1090,8 +1090,8 @@ task_table_paste_clipboard (ESelectable *selectable)
 {
 	ETaskTable *task_table;
 	GtkClipboard *clipboard;
-	GnomeCanvasItem *item;
-	GnomeCanvas *table_canvas;
+	FooCanvasItem *item;
+	FooCanvas *table_canvas;
 
 	task_table = E_TASK_TABLE (selectable);
 
diff --git a/calendar/gui/e-week-view-event-item.c b/calendar/gui/e-week-view-event-item.c
index f6560a4..dc0710b 100644
--- a/calendar/gui/e-week-view-event-item.c
+++ b/calendar/gui/e-week-view-event-item.c
@@ -86,9 +86,9 @@ week_view_event_item_get_position (EWeekViewEventItem *event_item,
                                    gdouble y)
 {
 	EWeekView *week_view;
-	GnomeCanvasItem *item;
+	FooCanvasItem *item;
 
-	item = GNOME_CANVAS_ITEM (event_item);
+	item = FOO_CANVAS_ITEM (event_item);
 
 	week_view = E_WEEK_VIEW (GTK_WIDGET (item->canvas)->parent);
 	g_return_val_if_fail (E_IS_WEEK_VIEW (week_view), E_CALENDAR_VIEW_POS_NONE);
@@ -119,9 +119,9 @@ week_view_event_item_double_click (EWeekViewEventItem *event_item,
 {
 	EWeekView *week_view;
 	EWeekViewEvent *event;
-	GnomeCanvasItem *item;
+	FooCanvasItem *item;
 
-	item = GNOME_CANVAS_ITEM (event_item);
+	item = FOO_CANVAS_ITEM (event_item);
 
 	week_view = E_WEEK_VIEW (GTK_WIDGET (item->canvas)->parent);
 	g_return_val_if_fail (E_IS_WEEK_VIEW (week_view), FALSE);
@@ -160,9 +160,9 @@ week_view_event_item_button_press (EWeekViewEventItem *event_item,
 	ECalendarViewPosition pos;
 	EWeekViewEvent *event;
 	EWeekViewEventSpan *span;
-	GnomeCanvasItem *item;
+	FooCanvasItem *item;
 
-	item = GNOME_CANVAS_ITEM (event_item);
+	item = FOO_CANVAS_ITEM (event_item);
 
 	week_view = E_WEEK_VIEW (GTK_WIDGET (item->canvas)->parent);
 	g_return_val_if_fail (E_IS_WEEK_VIEW (week_view), FALSE);
@@ -224,9 +224,9 @@ week_view_event_item_button_release (EWeekViewEventItem *event_item,
                                      GdkEvent *event)
 {
 	EWeekView *week_view;
-	GnomeCanvasItem *item;
+	FooCanvasItem *item;
 
-	item = GNOME_CANVAS_ITEM (event_item);
+	item = FOO_CANVAS_ITEM (event_item);
 
 	week_view = E_WEEK_VIEW (GTK_WIDGET (item->canvas)->parent);
 	g_return_val_if_fail (E_IS_WEEK_VIEW (week_view), FALSE);
@@ -366,7 +366,7 @@ week_view_event_item_draw_icons (EWeekViewEventItem *event_item,
 	GSList *categories_pixbufs = NULL, *pixbufs;
 	cairo_t *cr;
 
-	week_view = E_WEEK_VIEW (GTK_WIDGET (GNOME_CANVAS_ITEM (event_item)->canvas)->parent);
+	week_view = E_WEEK_VIEW (GTK_WIDGET (FOO_CANVAS_ITEM (event_item)->canvas)->parent);
 
 	event = &g_array_index (week_view->events, EWeekViewEvent,
 				event_item->priv->event_num);
@@ -480,7 +480,7 @@ week_view_event_item_draw_triangle (EWeekViewEventItem *event_item,
 	if (!can_draw_in_region (draw_region, x, y, w, h))
 		return;
 
-	week_view = E_WEEK_VIEW (GTK_WIDGET (GNOME_CANVAS_ITEM (event_item)->canvas)->parent);
+	week_view = E_WEEK_VIEW (GTK_WIDGET (FOO_CANVAS_ITEM (event_item)->canvas)->parent);
 
 	event = &g_array_index (week_view->events, EWeekViewEvent,
 				event_item->priv->event_num);
@@ -589,12 +589,12 @@ week_view_event_item_get_property (GObject *object,
 }
 
 static void
-week_view_event_item_update (GnomeCanvasItem *item,
+week_view_event_item_update (FooCanvasItem *item,
                              gdouble *affine,
                              ArtSVP *clip_path,
                              gint flags)
 {
-	GnomeCanvasItemClass *canvas_item_class;
+	FooCanvasItemClass *canvas_item_class;
 	EWeekViewEventItem *event_item;
 	EWeekView *week_view;
 	gint event_num, span_num;
@@ -605,7 +605,7 @@ week_view_event_item_update (GnomeCanvasItem *item,
 	g_return_if_fail (E_IS_WEEK_VIEW (week_view));
 
 	/* Chain up to parent's update() method. */
-	canvas_item_class = GNOME_CANVAS_ITEM_CLASS (parent_class);
+	canvas_item_class = FOO_CANVAS_ITEM_CLASS (parent_class);
 	canvas_item_class->update (item, affine, clip_path, flags);
 
 	item->x1 = 0;
@@ -629,7 +629,7 @@ week_view_event_item_update (GnomeCanvasItem *item,
 }
 
 static void
-week_view_event_item_draw (GnomeCanvasItem *canvas_item,
+week_view_event_item_draw (FooCanvasItem *canvas_item,
                            GdkDrawable *drawable,
                            gint x,
                            gint y,
@@ -1013,12 +1013,12 @@ week_view_event_item_draw (GnomeCanvasItem *canvas_item,
 }
 
 static double
-week_view_event_item_point (GnomeCanvasItem *item,
+week_view_event_item_point (FooCanvasItem *item,
                             gdouble x,
                             gdouble y,
                             gint cx,
                             gint cy,
-                            GnomeCanvasItem **actual_item)
+                            FooCanvasItem **actual_item)
 {
 	/* This is supposed to return the nearest item the the point
 	 * and the distance.  Since we are the only item we just return
@@ -1030,7 +1030,7 @@ week_view_event_item_point (GnomeCanvasItem *item,
 }
 
 static gint
-week_view_event_item_event (GnomeCanvasItem *item,
+week_view_event_item_event (FooCanvasItem *item,
                             GdkEvent *event)
 {
 	EWeekViewEventItem *event_item;
@@ -1057,7 +1057,7 @@ static void
 week_view_event_item_class_init (EWeekViewEventItemClass *class)
 {
 	GObjectClass *object_class;
-	GnomeCanvasItemClass *item_class;
+	FooCanvasItemClass *item_class;
 
 	parent_class = g_type_class_peek_parent (class);
 	g_type_class_add_private (class, sizeof (EWeekViewEventItemPrivate));
@@ -1066,7 +1066,7 @@ week_view_event_item_class_init (EWeekViewEventItemClass *class)
 	object_class->set_property = week_view_event_item_set_property;
 	object_class->get_property = week_view_event_item_get_property;
 
-	item_class = GNOME_CANVAS_ITEM_CLASS (class);
+	item_class = FOO_CANVAS_ITEM_CLASS (class);
 	item_class->update = week_view_event_item_update;
 	item_class->draw = week_view_event_item_draw;
 	item_class->point = week_view_event_item_point;
@@ -1126,7 +1126,7 @@ e_week_view_event_item_get_type (void)
 		};
 
 		type = g_type_register_static (
-			GNOME_TYPE_CANVAS_ITEM, "EWeekViewEventItem",
+			FOO_TYPE_CANVAS_ITEM, "EWeekViewEventItem",
 			&type_info, 0);
 	}
 
@@ -1148,7 +1148,7 @@ e_week_view_event_item_set_event_num (EWeekViewEventItem *event_item,
 	g_return_if_fail (E_IS_WEEK_VIEW_EVENT_ITEM (event_item));
 
 	event_item->priv->event_num = event_num;
-	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (event_item));
+	foo_canvas_item_request_update (FOO_CANVAS_ITEM (event_item));
 
 	g_object_notify (G_OBJECT (event_item), "event-num");
 }
@@ -1168,7 +1168,7 @@ e_week_view_event_item_set_span_num (EWeekViewEventItem *event_item,
 	g_return_if_fail (E_IS_WEEK_VIEW_EVENT_ITEM (event_item));
 
 	event_item->priv->span_num = span_num;
-	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (event_item));
+	foo_canvas_item_request_update (FOO_CANVAS_ITEM (event_item));
 
 	g_object_notify (G_OBJECT (event_item), "span-num");
 }
diff --git a/calendar/gui/e-week-view-event-item.h b/calendar/gui/e-week-view-event-item.h
index ff32eec..6548efa 100644
--- a/calendar/gui/e-week-view-event-item.h
+++ b/calendar/gui/e-week-view-event-item.h
@@ -58,12 +58,12 @@ typedef struct _EWeekViewEventItemClass EWeekViewEventItemClass;
 typedef struct _EWeekViewEventItemPrivate EWeekViewEventItemPrivate;
 
 struct _EWeekViewEventItem {
-	GnomeCanvasItem parent;
+	FooCanvasItem parent;
 	EWeekViewEventItemPrivate *priv;
 };
 
 struct _EWeekViewEventItemClass {
-	GnomeCanvasItemClass parent_class;
+	FooCanvasItemClass parent_class;
 };
 
 GType		e_week_view_event_item_get_type	(void);
diff --git a/calendar/gui/e-week-view-main-item.c b/calendar/gui/e-week-view-main-item.c
index 04b7731..d81cf4f 100644
--- a/calendar/gui/e-week-view-main-item.c
+++ b/calendar/gui/e-week-view-main-item.c
@@ -353,15 +353,15 @@ week_view_main_item_dispose (GObject *object)
 }
 
 static void
-week_view_main_item_update (GnomeCanvasItem *item,
+week_view_main_item_update (FooCanvasItem *item,
                             gdouble *affine,
                             ArtSVP *clip_path,
                             gint flags)
 {
-	GnomeCanvasItemClass *canvas_item_class;
+	FooCanvasItemClass *canvas_item_class;
 
 	/* Chain up to parent's update() method. */
-	canvas_item_class = GNOME_CANVAS_ITEM_CLASS (parent_class);
+	canvas_item_class = FOO_CANVAS_ITEM_CLASS (parent_class);
 	canvas_item_class->update (item, affine, clip_path, flags);
 
 	/* The item covers the entire canvas area. */
@@ -372,7 +372,7 @@ week_view_main_item_update (GnomeCanvasItem *item,
 }
 
 static void
-week_view_main_item_draw (GnomeCanvasItem *canvas_item,
+week_view_main_item_draw (FooCanvasItem *canvas_item,
                           GdkDrawable *drawable,
                           gint x,
                           gint y,
@@ -412,12 +412,12 @@ week_view_main_item_draw (GnomeCanvasItem *canvas_item,
 }
 
 static gdouble
-week_view_main_item_point (GnomeCanvasItem *item,
+week_view_main_item_point (FooCanvasItem *item,
                            gdouble x,
                            gdouble y,
                            gint cx,
                            gint cy,
-                           GnomeCanvasItem **actual_item)
+                           FooCanvasItem **actual_item)
 {
 	/* This is supposed to return the nearest item the the point
 	 * and the distance.  Since we are the only item we just return
@@ -432,7 +432,7 @@ static void
 week_view_main_item_class_init (EWeekViewMainItemClass *class)
 {
 	GObjectClass  *object_class;
-	GnomeCanvasItemClass *item_class;
+	FooCanvasItemClass *item_class;
 
 	parent_class = g_type_class_peek_parent (class);
 	g_type_class_add_private (class, sizeof (EWeekViewMainItemPrivate));
@@ -442,7 +442,7 @@ week_view_main_item_class_init (EWeekViewMainItemClass *class)
 	object_class->get_property = week_view_main_item_get_property;
 	object_class->dispose = week_view_main_item_dispose;
 
-	item_class = GNOME_CANVAS_ITEM_CLASS (class);
+	item_class = FOO_CANVAS_ITEM_CLASS (class);
 	item_class->update = week_view_main_item_update;
 	item_class->draw = week_view_main_item_draw;
 	item_class->point = week_view_main_item_point;
@@ -487,7 +487,7 @@ e_week_view_main_item_get_type (void)
 		};
 
 		type = g_type_register_static (
-			GNOME_TYPE_CANVAS_ITEM, "EWeekViewMainItem",
+			FOO_TYPE_CANVAS_ITEM, "EWeekViewMainItem",
 			&type_info, 0);
 	}
 
diff --git a/calendar/gui/e-week-view-main-item.h b/calendar/gui/e-week-view-main-item.h
index 7dc0187..a69790f 100644
--- a/calendar/gui/e-week-view-main-item.h
+++ b/calendar/gui/e-week-view-main-item.h
@@ -58,12 +58,12 @@ typedef struct _EWeekViewMainItemClass EWeekViewMainItemClass;
 typedef struct _EWeekViewMainItemPrivate EWeekViewMainItemPrivate;
 
 struct _EWeekViewMainItem {
-	GnomeCanvasItem parent;
+	FooCanvasItem parent;
 	EWeekViewMainItemPrivate *priv;
 };
 
 struct _EWeekViewMainItemClass {
-	GnomeCanvasItemClass parent_class;
+	FooCanvasItemClass parent_class;
 };
 
 GType		e_week_view_main_item_get_type	(void);
diff --git a/calendar/gui/e-week-view-titles-item.c b/calendar/gui/e-week-view-titles-item.c
index f2d90e7..2e62f1f 100644
--- a/calendar/gui/e-week-view-titles-item.c
+++ b/calendar/gui/e-week-view-titles-item.c
@@ -96,15 +96,15 @@ week_view_titles_item_dispose (GObject *object)
 }
 
 static void
-week_view_titles_item_update (GnomeCanvasItem *item,
+week_view_titles_item_update (FooCanvasItem *item,
                               gdouble *affine,
                               ArtSVP *clip_path,
                               gint flags)
 {
-	GnomeCanvasItemClass *canvas_item_class;
+	FooCanvasItemClass *canvas_item_class;
 
 	/* Chain up to parent's update() method. */
-	canvas_item_class = GNOME_CANVAS_ITEM_CLASS (parent_class);
+	canvas_item_class = FOO_CANVAS_ITEM_CLASS (parent_class);
 	canvas_item_class->update (item, affine, clip_path, flags);
 
 	/* The item covers the entire canvas area. */
@@ -115,7 +115,7 @@ week_view_titles_item_update (GnomeCanvasItem *item,
 }
 
 static void
-week_view_titles_item_draw (GnomeCanvasItem *canvas_item,
+week_view_titles_item_draw (FooCanvasItem *canvas_item,
                             GdkDrawable *drawable,
                             gint x,
                             gint y,
@@ -242,12 +242,12 @@ week_view_titles_item_draw (GnomeCanvasItem *canvas_item,
 }
 
 static double
-week_view_titles_item_point (GnomeCanvasItem *item,
+week_view_titles_item_point (FooCanvasItem *item,
                              gdouble x,
                              gdouble y,
                              gint cx,
                              gint cy,
-                             GnomeCanvasItem **actual_item)
+                             FooCanvasItem **actual_item)
 {
 	/* This is supposed to return the nearest item the the point
 	 * and the distance.  Since we are the only item we just return
@@ -262,7 +262,7 @@ static void
 week_view_titles_item_class_init (EWeekViewTitlesItemClass *class)
 {
 	GObjectClass  *object_class;
-	GnomeCanvasItemClass *item_class;
+	FooCanvasItemClass *item_class;
 
 	parent_class = g_type_class_peek_parent (class);
 	g_type_class_add_private (class, sizeof (EWeekViewTitlesItemPrivate));
@@ -272,7 +272,7 @@ week_view_titles_item_class_init (EWeekViewTitlesItemClass *class)
 	object_class->get_property = week_view_titles_item_get_property;
 	object_class->dispose = week_view_titles_item_dispose;
 
-	item_class = GNOME_CANVAS_ITEM_CLASS (class);
+	item_class = FOO_CANVAS_ITEM_CLASS (class);
 	item_class->update = week_view_titles_item_update;
 	item_class->draw = week_view_titles_item_draw;
 	item_class->point = week_view_titles_item_point;
@@ -314,7 +314,7 @@ e_week_view_titles_item_get_type (void)
 		};
 
 		type = g_type_register_static (
-			GNOME_TYPE_CANVAS_ITEM, "EWeekViewTitlesItem",
+			FOO_TYPE_CANVAS_ITEM, "EWeekViewTitlesItem",
 			&type_info, 0);
 	}
 
diff --git a/calendar/gui/e-week-view-titles-item.h b/calendar/gui/e-week-view-titles-item.h
index d4cc111..a5db208 100644
--- a/calendar/gui/e-week-view-titles-item.h
+++ b/calendar/gui/e-week-view-titles-item.h
@@ -57,12 +57,12 @@ typedef struct _EWeekViewTitlesItemClass EWeekViewTitlesItemClass;
 typedef struct _EWeekViewTitlesItemPrivate EWeekViewTitlesItemPrivate;
 
 struct _EWeekViewTitlesItem {
-	GnomeCanvasItem parent;
+	FooCanvasItem parent;
 	EWeekViewTitlesItemPrivate *priv;
 };
 
 struct _EWeekViewTitlesItemClass {
-	GnomeCanvasItemClass parent_class;
+	FooCanvasItemClass parent_class;
 };
 
 GType		e_week_view_titles_item_get_type(void);
diff --git a/calendar/gui/e-week-view.c b/calendar/gui/e-week-view.c
index 222bdba..868a974 100644
--- a/calendar/gui/e-week-view.c
+++ b/calendar/gui/e-week-view.c
@@ -35,7 +35,7 @@
 #include <math.h>
 #include <gdk/gdkkeysyms.h>
 #include <glib/gi18n.h>
-#include <libgnomecanvas/gnome-canvas-pixbuf.h>
+#include <libfoocanvas/foo-canvas-pixbuf.h>
 #include <text/e-text.h>
 #include <misc/e-canvas-utils.h>
 #include <e-util/e-binding.h>
@@ -148,9 +148,9 @@ static void e_week_view_reshape_event_span (EWeekView *week_view,
 static void e_week_view_recalc_day_starts (EWeekView *week_view,
 					   time_t lower);
 static void e_week_view_on_editing_started (EWeekView *week_view,
-					    GnomeCanvasItem *item);
+					    FooCanvasItem *item);
 static void e_week_view_on_editing_stopped (EWeekView *week_view,
-					    GnomeCanvasItem *item);
+					    FooCanvasItem *item);
 static gboolean e_week_view_find_event_from_uid (EWeekView	  *week_view,
 						 ECal             *client,
 						 const gchar	  *uid,
@@ -163,13 +163,13 @@ static void e_week_view_foreach_event_with_uid (EWeekView *week_view,
 						const gchar *uid,
 						EWeekViewForeachEventCallback callback,
 						gpointer data);
-static gboolean e_week_view_on_text_item_event (GnomeCanvasItem *item,
+static gboolean e_week_view_on_text_item_event (FooCanvasItem *item,
 						GdkEvent *event,
 						EWeekView *week_view);
 static gboolean e_week_view_event_move (ECalendarView *cal_view, ECalViewMoveDirection direction);
 static gint e_week_view_get_day_offset_of_event (EWeekView *week_view, time_t event_time);
 static void e_week_view_change_event_time (EWeekView *week_view, time_t start_dt, time_t end_dt, gboolean is_all_day);
-static gboolean e_week_view_on_jump_button_event (GnomeCanvasItem *item,
+static gboolean e_week_view_on_jump_button_event (FooCanvasItem *item,
 						  GdkEvent *event,
 						  EWeekView *week_view);
 static gboolean e_week_view_key_press (GtkWidget *widget, GdkEventKey *event);
@@ -691,7 +691,7 @@ e_week_view_class_init (EWeekViewClass *class)
 static void
 e_week_view_init (EWeekView *week_view)
 {
-	GnomeCanvasGroup *canvas_group;
+	FooCanvasGroup *canvas_group;
 	GtkObject *adjustment;
 	GdkPixbuf *pixbuf;
 	gint i;
@@ -763,10 +763,10 @@ e_week_view_init (EWeekView *week_view)
 	gtk_table_attach (GTK_TABLE (week_view), week_view->titles_canvas,
 			  1, 2, 0, 1, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
 
-	canvas_group = GNOME_CANVAS_GROUP (GNOME_CANVAS (week_view->titles_canvas)->root);
+	canvas_group = FOO_CANVAS_GROUP (FOO_CANVAS (week_view->titles_canvas)->root);
 
 	week_view->titles_canvas_item =
-		gnome_canvas_item_new (canvas_group,
+		foo_canvas_item_new (canvas_group,
 				       e_week_view_titles_item_get_type (),
 				       "EWeekViewTitlesItem::week_view", week_view,
 				       NULL);
@@ -780,10 +780,10 @@ e_week_view_init (EWeekView *week_view)
 			  GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 1, 1);
 	gtk_widget_show (week_view->main_canvas);
 
-	canvas_group = GNOME_CANVAS_GROUP (GNOME_CANVAS (week_view->main_canvas)->root);
+	canvas_group = FOO_CANVAS_GROUP (FOO_CANVAS (week_view->main_canvas)->root);
 
 	week_view->main_canvas_item =
-		gnome_canvas_item_new (canvas_group,
+		foo_canvas_item_new (canvas_group,
 				       e_week_view_main_item_get_type (),
 				       "EWeekViewMainItem::week_view", week_view,
 				       NULL);
@@ -801,10 +801,10 @@ e_week_view_init (EWeekView *week_view)
 	pixbuf = gdk_pixbuf_new_from_xpm_data ((const gchar **) jump_xpm);
 
 	for (i = 0; i < E_WEEK_VIEW_MAX_WEEKS * 7; i++) {
-		week_view->jump_buttons[i] = gnome_canvas_item_new
+		week_view->jump_buttons[i] = foo_canvas_item_new
 			(canvas_group,
-			 gnome_canvas_pixbuf_get_type (),
-			 "GnomeCanvasPixbuf::pixbuf", pixbuf,
+			 foo_canvas_pixbuf_get_type (),
+			 "FooCanvasPixbuf::pixbuf", pixbuf,
 			 NULL);
 
 		g_signal_connect (week_view->jump_buttons[i], "event",
@@ -1083,7 +1083,7 @@ e_week_view_style_set (GtkWidget *widget,
 			span = &g_array_index (week_view->spans,
 					EWeekViewEventSpan, span_num);
 			if (span->text_item) {
-				gnome_canvas_item_set (span->text_item,
+				foo_canvas_item_set (span->text_item,
 						"fill_color_gdk", &widget->style->text[GTK_STATE_NORMAL],
 						NULL);
 			}
@@ -1186,22 +1186,22 @@ e_week_view_size_allocate (GtkWidget *widget, GtkAllocation *allocation)
 	e_week_view_recalc_cell_sizes (week_view);
 
 	/* Set the scroll region of the top canvas to its allocated size. */
-	gnome_canvas_get_scroll_region (GNOME_CANVAS (week_view->titles_canvas),
+	foo_canvas_get_scroll_region (FOO_CANVAS (week_view->titles_canvas),
 					NULL, NULL, &old_x2, &old_y2);
 	new_x2 = week_view->titles_canvas->allocation.width - 1;
 	new_y2 = week_view->titles_canvas->allocation.height - 1;
 	if (old_x2 != new_x2 || old_y2 != new_y2)
-		gnome_canvas_set_scroll_region (GNOME_CANVAS (week_view->titles_canvas),
+		foo_canvas_set_scroll_region (FOO_CANVAS (week_view->titles_canvas),
 						0, 0, new_x2, new_y2);
 
 	/* Set the scroll region of the main canvas to its allocated width,
 	   but with the height depending on the number of rows needed. */
-	gnome_canvas_get_scroll_region (GNOME_CANVAS (week_view->main_canvas),
+	foo_canvas_get_scroll_region (FOO_CANVAS (week_view->main_canvas),
 					NULL, NULL, &old_x2, &old_y2);
 	new_x2 = week_view->main_canvas->allocation.width - 1;
 	new_y2 = week_view->main_canvas->allocation.height - 1;
 	if (old_x2 != new_x2 || old_y2 != new_y2)
-		gnome_canvas_set_scroll_region (GNOME_CANVAS (week_view->main_canvas),
+		foo_canvas_set_scroll_region (FOO_CANVAS (week_view->main_canvas),
 						0, 0, new_x2, new_y2);
 
 	/* Flag that we need to reshape the events. */
@@ -1512,7 +1512,7 @@ e_week_view_focus (GtkWidget *widget, GtkDirectionType direction)
 
 				/* focus go to the jump button */
 				e_week_view_stop_editing_event (week_view);
-				gnome_canvas_item_grab_focus (week_view->jump_buttons[current_day]);
+				foo_canvas_item_grab_focus (week_view->jump_buttons[current_day]);
 				return TRUE;
 			}
 		}
@@ -2109,7 +2109,7 @@ set_text_as_bold (EWeekViewEvent *event, EWeekViewEventSpan *span)
 	   If the attendee is not present, it might have come through a mailing list.
 	   In that case, we never show the meeting as bold even if it is unaccepted. */
 	if (at && (at->status == ICAL_PARTSTAT_NEEDSACTION))
-		gnome_canvas_item_set (span->text_item, "bold", TRUE, NULL);
+		foo_canvas_item_set (span->text_item, "bold", TRUE, NULL);
 
 	e_cal_component_free_attendee_list (attendees);
 	g_free (address);
@@ -2315,7 +2315,7 @@ ewv_pass_gdkevent_to_etext (EWeekView *week_view, GdkEvent *gevent)
 		span = &g_array_index (week_view->spans, EWeekViewEventSpan, event->spans_index + week_view->editing_span_num);
 
 		if (span->text_item && E_IS_TEXT (span->text_item)) {
-			GNOME_CANVAS_ITEM_GET_CLASS (span->text_item)->event (span->text_item, gevent);
+			FOO_CANVAS_ITEM_GET_CLASS (span->text_item)->event (span->text_item, gevent);
 			return TRUE;
 		}
 	}
@@ -2631,7 +2631,7 @@ e_week_view_free_events (EWeekView *week_view)
 
 	/* Hide all the jump buttons. */
 	for (day = 0; day < E_WEEK_VIEW_MAX_WEEKS * 7; day++) {
-		gnome_canvas_item_hide (week_view->jump_buttons[day]);
+		foo_canvas_item_hide (week_view->jump_buttons[day]);
 	}
 }
 
@@ -2817,24 +2817,24 @@ e_week_view_reshape_events (EWeekView *week_view)
 
 		/* Determine whether the jump button should be shown. */
 		if (week_view->rows_per_day[day] <= max_rows) {
-			gnome_canvas_item_hide (week_view->jump_buttons[day]);
+			foo_canvas_item_hide (week_view->jump_buttons[day]);
 		} else {
 			e_week_view_get_day_position (week_view, day,
 						      &day_x, &day_y,
 						      &day_w, &day_h);
 
-			gnome_canvas_item_set (week_view->jump_buttons[day],
-					       "GnomeCanvasPixbuf::x", (gdouble) (day_x + day_w - E_WEEK_VIEW_JUMP_BUTTON_X_PAD - E_WEEK_VIEW_JUMP_BUTTON_WIDTH),
-					       "GnomeCanvasPixbuf::y", (gdouble) (day_y + day_h - E_WEEK_VIEW_JUMP_BUTTON_Y_PAD - E_WEEK_VIEW_JUMP_BUTTON_HEIGHT),
+			foo_canvas_item_set (week_view->jump_buttons[day],
+					       "FooCanvasPixbuf::x", (gdouble) (day_x + day_w - E_WEEK_VIEW_JUMP_BUTTON_X_PAD - E_WEEK_VIEW_JUMP_BUTTON_WIDTH),
+					       "FooCanvasPixbuf::y", (gdouble) (day_y + day_h - E_WEEK_VIEW_JUMP_BUTTON_Y_PAD - E_WEEK_VIEW_JUMP_BUTTON_HEIGHT),
 					       NULL);
 
-			gnome_canvas_item_show (week_view->jump_buttons[day]);
-			gnome_canvas_item_raise_to_top (week_view->jump_buttons[day]);
+			foo_canvas_item_show (week_view->jump_buttons[day]);
+			foo_canvas_item_raise_to_top (week_view->jump_buttons[day]);
 		}
 	}
 
 	for (day = num_days; day < E_WEEK_VIEW_MAX_WEEKS * 7; day++) {
-		gnome_canvas_item_hide (week_view->jump_buttons[day]);
+		foo_canvas_item_hide (week_view->jump_buttons[day]);
 	}
 }
 
@@ -2849,7 +2849,7 @@ tooltip_get_view_event (EWeekView *week_view, gint day, gint event_num)
 }
 
 static void
-tooltip_destroy (EWeekView *week_view, GnomeCanvasItem *item)
+tooltip_destroy (EWeekView *week_view, FooCanvasItem *item)
 {
 	gint event_num = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (item), "event-num"));
 	EWeekViewEvent *pevent;
@@ -2873,7 +2873,7 @@ tooltip_destroy (EWeekView *week_view, GnomeCanvasItem *item)
 }
 
 static gboolean
-tooltip_event_cb (GnomeCanvasItem *item,
+tooltip_event_cb (FooCanvasItem *item,
 		  GdkEvent *event,
 		  EWeekView *view)
 {
@@ -2998,7 +2998,7 @@ e_week_view_reshape_event_span (EWeekView *week_view,
 	/* Create the background canvas item if necessary. */
 	if (!span->background_item) {
 		span->background_item =
-			gnome_canvas_item_new (GNOME_CANVAS_GROUP (GNOME_CANVAS (week_view->main_canvas)->root),
+			foo_canvas_item_new (FOO_CANVAS_GROUP (FOO_CANVAS (week_view->main_canvas)->root),
 					       e_week_view_event_item_get_type (),
 					       NULL);
 	}
@@ -3008,7 +3008,7 @@ e_week_view_reshape_event_span (EWeekView *week_view,
 			  G_CALLBACK (tooltip_event_cb),
 			  week_view);
 
-	gnome_canvas_item_set (span->background_item,
+	foo_canvas_item_set (span->background_item,
 			       "event_num", event_num,
 			       "span_num", span_num,
 			       NULL);
@@ -3026,7 +3026,7 @@ e_week_view_reshape_event_span (EWeekView *week_view,
 		summary = e_calendar_view_get_icalcomponent_summary (event->comp_data->client, event->comp_data->icalcomp, &free_text);
 
 		span->text_item =
-			gnome_canvas_item_new (GNOME_CANVAS_GROUP (GNOME_CANVAS (week_view->main_canvas)->root),
+			foo_canvas_item_new (FOO_CANVAS_GROUP (FOO_CANVAS (week_view->main_canvas)->root),
 					       e_text_get_type (),
 					       "anchor", GTK_ANCHOR_NW,
 					       "clip", TRUE,
@@ -3182,7 +3182,7 @@ e_week_view_reshape_event_span (EWeekView *week_view,
 	/* Make sure we don't try to use a negative width. */
 	text_w = MAX (text_w, 0);
 
-	gnome_canvas_item_set (span->text_item,
+	foo_canvas_item_set (span->text_item,
 			       "clip_width", (gdouble) text_w,
 			       "clip_height", (gdouble) text_h,
 			       NULL);
@@ -3231,7 +3231,7 @@ e_week_view_start_editing_event (EWeekView *week_view,
 	}
 
 	if (initial_text) {
-		gnome_canvas_item_set (span->text_item,
+		foo_canvas_item_set (span->text_item,
 				       "text", initial_text,
 				       NULL);
 	}
@@ -3320,7 +3320,7 @@ cancel_editing (EWeekView *week_view)
 }
 
 static gboolean
-e_week_view_on_text_item_event (GnomeCanvasItem *item,
+e_week_view_on_text_item_event (FooCanvasItem *item,
 				GdkEvent *gdkevent,
 				EWeekView *week_view)
 {
@@ -3697,7 +3697,7 @@ out:
 
 static void
 e_week_view_on_editing_started (EWeekView *week_view,
-				GnomeCanvasItem *item)
+				FooCanvasItem *item)
 {
 	gint event_num, span_num;
 
@@ -3724,7 +3724,7 @@ e_week_view_on_editing_started (EWeekView *week_view,
 
 static void
 e_week_view_on_editing_stopped (EWeekView *week_view,
-				GnomeCanvasItem *item)
+				FooCanvasItem *item)
 {
 	gint event_num, span_num;
 	EWeekViewEvent *event;
@@ -3882,7 +3882,7 @@ e_week_view_on_editing_stopped (EWeekView *week_view,
 
 gboolean
 e_week_view_find_event_from_item (EWeekView	  *week_view,
-				  GnomeCanvasItem *item,
+				  FooCanvasItem *item,
 				  gint		  *event_num_return,
 				  gint		  *span_num_return)
 {
@@ -4284,7 +4284,7 @@ e_week_view_popup_menu (GtkWidget *widget)
 }
 
 void
-e_week_view_jump_to_button_item (EWeekView *week_view, GnomeCanvasItem *item)
+e_week_view_jump_to_button_item (EWeekView *week_view, FooCanvasItem *item)
 {
 	gint day;
 	GnomeCalendar *calendar;
@@ -4304,7 +4304,7 @@ e_week_view_jump_to_button_item (EWeekView *week_view, GnomeCanvasItem *item)
 }
 
 static gboolean
-e_week_view_on_jump_button_event (GnomeCanvasItem *item,
+e_week_view_on_jump_button_event (FooCanvasItem *item,
 				  GdkEvent *event,
 				  EWeekView *week_view)
 {
@@ -4341,15 +4341,15 @@ e_week_view_on_jump_button_event (GnomeCanvasItem *item,
 		if (focus_event->in) {
 			week_view->focused_jump_button = day;
 			pixbuf = gdk_pixbuf_new_from_xpm_data ((const gchar **) jump_xpm_focused);
-			gnome_canvas_item_set (week_view->jump_buttons[day],
-					       "GnomeCanvasPixbuf::pixbuf",
+			foo_canvas_item_set (week_view->jump_buttons[day],
+					       "FooCanvasPixbuf::pixbuf",
 					       pixbuf, NULL);
 		}
 		else {
 			week_view->focused_jump_button = E_WEEK_VIEW_JUMP_BUTTON_NO_FOCUS;
 			pixbuf = gdk_pixbuf_new_from_xpm_data ((const gchar **) jump_xpm);
-			gnome_canvas_item_set (week_view->jump_buttons[day],
-					       "GnomeCanvasPixbuf::pixbuf",
+			foo_canvas_item_set (week_view->jump_buttons[day],
+					       "FooCanvasPixbuf::pixbuf",
 					       pixbuf, NULL);
 		}
 		if (pixbuf)
@@ -4462,7 +4462,7 @@ e_week_view_is_jump_button_visible (EWeekView *week_view, gint day)
 	g_return_val_if_fail (E_IS_WEEK_VIEW (week_view), FALSE);
 
 	if ((day >= 0) && (day < E_WEEK_VIEW_MAX_WEEKS * 7))
-		return week_view->jump_buttons[day]->object.flags & GNOME_CANVAS_ITEM_VISIBLE;
+		return week_view->jump_buttons[day]->object.flags & FOO_CANVAS_ITEM_VISIBLE;
 	return FALSE;
 }
 
diff --git a/calendar/gui/e-week-view.h b/calendar/gui/e-week-view.h
index 0712e1a..87442d8 100644
--- a/calendar/gui/e-week-view.h
+++ b/calendar/gui/e-week-view.h
@@ -24,7 +24,7 @@
 #define E_WEEK_VIEW_H
 
 #include <gtk/gtk.h>
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 
 #include "e-calendar-view.h"
 #include "gnome-cal.h"
@@ -154,8 +154,8 @@ struct _EWeekViewEventSpan {
 	guint start_day : 6;
 	guint num_days : 3;
 	guint row : 7;
-	GnomeCanvasItem *background_item;
-	GnomeCanvasItem *text_item;
+	FooCanvasItem *background_item;
+	FooCanvasItem *text_item;
 };
 
 typedef struct _EWeekViewEvent EWeekViewEvent;
@@ -174,13 +174,13 @@ struct _EWeekView {
 
 	/* The top canvas where the dates are shown. */
 	GtkWidget *titles_canvas;
-	GnomeCanvasItem *titles_canvas_item;
+	FooCanvasItem *titles_canvas_item;
 
 	/* The main canvas where the appointments are shown. */
 	GtkWidget *main_canvas;
-	GnomeCanvasItem *main_canvas_item;
+	FooCanvasItem *main_canvas_item;
 
-	GnomeCanvasItem *jump_buttons[E_WEEK_VIEW_MAX_WEEKS * 7];
+	FooCanvasItem *jump_buttons[E_WEEK_VIEW_MAX_WEEKS * 7];
 	gint focused_jump_button;
 
 	GtkWidget *vscrollbar;
@@ -458,7 +458,7 @@ gint		e_week_view_event_sort_func	(gconstpointer arg1,
 						 gconstpointer arg2);
 
 gboolean	e_week_view_find_event_from_item (EWeekView *week_view,
-						 GnomeCanvasItem *item,
+						 FooCanvasItem *item,
 						 gint *event_num_return,
 						 gint *span_num_return);
 
@@ -466,7 +466,7 @@ gboolean	e_week_view_is_jump_button_visible
 						(EWeekView *week_view,
 						 gint day);
 void		e_week_view_jump_to_button_item	(EWeekView *week_view,
-						 GnomeCanvasItem *item);
+						 FooCanvasItem *item);
 void		e_week_view_scroll_a_step	(EWeekView *week_view,
 						 ECalViewMoveDirection direction);
 
diff --git a/calendar/gui/ea-cal-view-event.c b/calendar/gui/ea-cal-view-event.c
index 4fbc93e..8139e49 100644
--- a/calendar/gui/ea-cal-view-event.c
+++ b/calendar/gui/ea-cal-view-event.c
@@ -167,7 +167,7 @@ ea_cal_view_event_new (GObject *obj)
 	ECalendarView *cal_view;
 
 	g_return_val_if_fail (E_IS_TEXT (obj), NULL);
-	cal_view = ea_calendar_helpers_get_cal_view_from (GNOME_CANVAS_ITEM (obj));
+	cal_view = ea_calendar_helpers_get_cal_view_from (FOO_CANVAS_ITEM (obj));
 	if (!cal_view)
 		return NULL;
 
@@ -181,7 +181,7 @@ ea_cal_view_event_new (GObject *obj)
 		 * the first span of the same event
 		 */
 		if (!e_week_view_find_event_from_item (week_view,
-						       GNOME_CANVAS_ITEM (obj),
+						       FOO_CANVAS_ITEM (obj),
 						       &event_num,
 						       &span_num))
 			return NULL;
@@ -255,7 +255,7 @@ ea_cal_view_event_get_name (AtkObject *accessible)
 	g_obj = atk_gobject_accessible_get_object (atk_gobj);
 	if (!g_obj || !E_IS_TEXT (g_obj))
 		return NULL;
-	event = ea_calendar_helpers_get_cal_view_event_from (GNOME_CANVAS_ITEM(g_obj));
+	event = ea_calendar_helpers_get_cal_view_event_from (FOO_CANVAS_ITEM(g_obj));
 
 	alarm_string = recur_string = meeting_string = "";
 	if (event && event->comp_data) {
@@ -304,7 +304,7 @@ ea_cal_view_event_get_parent (AtkObject *accessible)
 {
 	AtkGObjectAccessible *atk_gobj;
 	GObject *g_obj;
-	GnomeCanvasItem *canvas_item;
+	FooCanvasItem *canvas_item;
 	ECalendarView *cal_view;
 
 	g_return_val_if_fail (EA_IS_CAL_VIEW_EVENT (accessible), NULL);
@@ -314,7 +314,7 @@ ea_cal_view_event_get_parent (AtkObject *accessible)
 	if (g_obj == NULL)
 		/* Object is defunct */
 		return NULL;
-	canvas_item = GNOME_CANVAS_ITEM (g_obj);
+	canvas_item = FOO_CANVAS_ITEM (g_obj);
 
 	cal_view = ea_calendar_helpers_get_cal_view_from (canvas_item);
 
@@ -328,7 +328,7 @@ static gint
 ea_cal_view_event_get_index_in_parent (AtkObject *accessible)
 {
 	GObject *g_obj;
-	GnomeCanvasItem *canvas_item;
+	FooCanvasItem *canvas_item;
 	ECalendarView *cal_view;
 	ECalendarViewEvent *cal_view_event;
 
@@ -338,7 +338,7 @@ ea_cal_view_event_get_index_in_parent (AtkObject *accessible)
 		/* defunct object*/
 		return -1;
 
-	canvas_item = GNOME_CANVAS_ITEM (g_obj);
+	canvas_item = FOO_CANVAS_ITEM (g_obj);
 	cal_view = ea_calendar_helpers_get_cal_view_from (canvas_item);
 	if (!cal_view)
 		return -1;
@@ -426,7 +426,7 @@ ea_cal_view_get_extents (AtkComponent   *component,
                          AtkCoordType   coord_type)
 {
 	GObject *g_obj;
-	GnomeCanvasItem *canvas_item;
+	FooCanvasItem *canvas_item;
 	gint x_window, y_window;
 	gint scroll_x, scroll_y;
 	ECalendarView *cal_view;
@@ -441,7 +441,7 @@ ea_cal_view_get_extents (AtkComponent   *component,
 		return;
 	g_return_if_fail (E_IS_TEXT (g_obj));
 
-	canvas_item = GNOME_CANVAS_ITEM (g_obj);
+	canvas_item = FOO_CANVAS_ITEM (g_obj);
 	cal_view = ea_calendar_helpers_get_cal_view_from (canvas_item);
 	if (!cal_view)
 		return;
@@ -498,7 +498,7 @@ ea_cal_view_get_extents (AtkComponent   *component,
 
 	gdk_window_get_origin (canvas->window,
 			       &x_window, &y_window);
-	gnome_canvas_get_scroll_offsets (GNOME_CANVAS (canvas), &scroll_x, &scroll_y);
+	foo_canvas_get_scroll_offsets (FOO_CANVAS (canvas), &scroll_x, &scroll_y);
 
 	*x = item_x + x_window - scroll_x;
 	*y = item_y + y_window - scroll_y;
diff --git a/calendar/gui/ea-calendar-helpers.c b/calendar/gui/ea-calendar-helpers.c
index f07cdfa..70f4a0e 100644
--- a/calendar/gui/ea-calendar-helpers.c
+++ b/calendar/gui/ea-calendar-helpers.c
@@ -28,7 +28,7 @@
 #include "e-week-view.h"
 
 #include <text/e-text.h>
-#include <libgnomecanvas/gnome-canvas-pixbuf.h>
+#include <libfoocanvas/foo-canvas-pixbuf.h>
 
 /**
  * ea_calendar_helpers_get_accessible_for
@@ -37,12 +37,12 @@
  *
  **/
 AtkObject *
-ea_calendar_helpers_get_accessible_for (GnomeCanvasItem *canvas_item)
+ea_calendar_helpers_get_accessible_for (FooCanvasItem *canvas_item)
 {
 	AtkObject *atk_obj = NULL;
 	GObject *g_obj;
 
-	g_return_val_if_fail ((E_IS_TEXT (canvas_item)) || (GNOME_IS_CANVAS_ITEM (canvas_item)), NULL);;
+	g_return_val_if_fail ((E_IS_TEXT (canvas_item)) || (FOO_IS_CANVAS_ITEM (canvas_item)), NULL);;
 
 	g_obj = G_OBJECT (canvas_item);
 	/* we cannot use atk_gobject_accessible_for_object here,
@@ -54,7 +54,7 @@ ea_calendar_helpers_get_accessible_for (GnomeCanvasItem *canvas_item)
                 if (E_IS_TEXT (canvas_item)) {
 		atk_obj = ea_cal_view_event_new (g_obj);
                 }
-                else if (GNOME_IS_CANVAS_PIXBUF(canvas_item)) {
+                else if (FOO_IS_CANVAS_PIXBUF(canvas_item)) {
                         atk_obj = ea_jump_button_new (g_obj);
                 }
                 else
@@ -72,13 +72,13 @@ ea_calendar_helpers_get_accessible_for (GnomeCanvasItem *canvas_item)
  *
  **/
 ECalendarView *
-ea_calendar_helpers_get_cal_view_from (GnomeCanvasItem *canvas_item)
+ea_calendar_helpers_get_cal_view_from (FooCanvasItem *canvas_item)
 {
-	GnomeCanvas *canvas;
+	FooCanvas *canvas;
 	GtkWidget *view_widget = NULL;
 
 	g_return_val_if_fail (canvas_item, NULL);
-	g_return_val_if_fail ((E_IS_TEXT (canvas_item)) || (GNOME_IS_CANVAS_ITEM (canvas_item)), NULL);
+	g_return_val_if_fail ((E_IS_TEXT (canvas_item)) || (FOO_IS_CANVAS_ITEM (canvas_item)), NULL);
 
 	/* canvas_item is the e_text for the event */
 	/* canvas_item->canvas is the ECanvas for day view */
@@ -100,7 +100,7 @@ ea_calendar_helpers_get_cal_view_from (GnomeCanvasItem *canvas_item)
  *
  **/
 ECalendarViewEvent *
-ea_calendar_helpers_get_cal_view_event_from (GnomeCanvasItem *canvas_item)
+ea_calendar_helpers_get_cal_view_event_from (FooCanvasItem *canvas_item)
 {
 	ECalendarView *cal_view;
 	gboolean event_found;
diff --git a/calendar/gui/ea-calendar-helpers.h b/calendar/gui/ea-calendar-helpers.h
index a4045cd..780955b 100644
--- a/calendar/gui/ea-calendar-helpers.h
+++ b/calendar/gui/ea-calendar-helpers.h
@@ -30,12 +30,12 @@
 #include "ea-cal-view.h"
 
 AtkObject *
-ea_calendar_helpers_get_accessible_for (GnomeCanvasItem *canvas_item);
+ea_calendar_helpers_get_accessible_for (FooCanvasItem *canvas_item);
 
 ECalendarView *
-ea_calendar_helpers_get_cal_view_from (GnomeCanvasItem *canvas_item);
+ea_calendar_helpers_get_cal_view_from (FooCanvasItem *canvas_item);
 
 ECalendarViewEvent *
-ea_calendar_helpers_get_cal_view_event_from (GnomeCanvasItem *canvas_item);
+ea_calendar_helpers_get_cal_view_event_from (FooCanvasItem *canvas_item);
 
 #endif /* _EA_CALENDAR_HELPERS_H__ */
diff --git a/calendar/gui/ea-calendar.c b/calendar/gui/ea-calendar.c
index dcdf8bd..5980c16 100644
--- a/calendar/gui/ea-calendar.c
+++ b/calendar/gui/ea-calendar.c
@@ -21,7 +21,7 @@
  */
 
 #include <text/e-text.h>
-#include <libgnomecanvas/gnome-canvas-pixbuf.h>
+#include <libfoocanvas/foo-canvas-pixbuf.h>
 #include "ea-calendar-helpers.h"
 #include "a11y/ea-factory.h"
 #include "ea-calendar.h"
@@ -59,7 +59,7 @@ gnome_calendar_a11y_init (void)
 
 		/* force loading some types */
 		e_text_type = g_type_class_ref (E_TYPE_TEXT);
-		pixbuf_type = g_type_class_ref (GNOME_TYPE_CANVAS_PIXBUF);
+		pixbuf_type = g_type_class_ref (FOO_TYPE_CANVAS_PIXBUF);
 		e_day_view_type = g_type_class_ref (e_day_view_get_type ());
 		e_week_view_type = g_type_class_ref (E_TYPE_WEEK_VIEW);
 		e_day_view_main_item_type = g_type_class_ref (e_day_view_main_item_get_type ());
@@ -68,7 +68,7 @@ gnome_calendar_a11y_init (void)
 		g_signal_add_emission_hook (g_signal_lookup ("event", E_TYPE_TEXT),
 					    0, ea_calendar_focus_watcher,
 					    NULL, (GDestroyNotify) NULL);
-		g_signal_add_emission_hook (g_signal_lookup ("event", GNOME_TYPE_CANVAS_PIXBUF),
+		g_signal_add_emission_hook (g_signal_lookup ("event", FOO_TYPE_CANVAS_PIXBUF),
                                             0, ea_calendar_focus_watcher,
                                             NULL, (GDestroyNotify) NULL);
 		g_signal_add_emission_hook (g_signal_lookup ("event-after",
@@ -134,12 +134,12 @@ ea_calendar_focus_watcher (GSignalInvocationHint *ihint,
 	object = g_value_get_object (param_values + 0);
 	event = g_value_get_boxed (param_values + 1);
 
-	if ((E_IS_TEXT (object)) || (GNOME_IS_CANVAS_PIXBUF (object))) {
+	if ((E_IS_TEXT (object)) || (FOO_IS_CANVAS_PIXBUF (object))) {
 		/* "event" signal on canvas item
 		 */
-		GnomeCanvasItem *canvas_item;
+		FooCanvasItem *canvas_item;
 
-		canvas_item = GNOME_CANVAS_ITEM (object);
+		canvas_item = FOO_CANVAS_ITEM (object);
 		if (event->type == GDK_FOCUS_CHANGE) {
 			if (event->focus_change.in) {
 				ea_event =
@@ -157,7 +157,7 @@ ea_calendar_focus_watcher (GSignalInvocationHint *ihint,
 		if (event->type == GDK_FOCUS_CHANGE) {
 			if (event->focus_change.in) {
 				/* give main item chance to emit focus */
-				gnome_canvas_item_grab_focus (day_view->main_canvas_item);
+				foo_canvas_item_grab_focus (day_view->main_canvas_item);
 			}
 		}
 	}
@@ -180,7 +180,7 @@ ea_calendar_focus_watcher (GSignalInvocationHint *ihint,
 		if (event->type == GDK_FOCUS_CHANGE) {
 			if (event->focus_change.in) {
 				/* give main item chance to emit focus */
-				gnome_canvas_item_grab_focus (week_view->main_canvas_item);
+				foo_canvas_item_grab_focus (week_view->main_canvas_item);
 			}
 		}
 	}
diff --git a/calendar/gui/ea-day-view-cell.c b/calendar/gui/ea-day-view-cell.c
index 6760b7c..425ff04 100644
--- a/calendar/gui/ea-day-view-cell.c
+++ b/calendar/gui/ea-day-view-cell.c
@@ -207,7 +207,7 @@ ea_day_view_cell_get_name (AtkObject *accessible)
 
 	if (!accessible->name) {
 		AtkObject *ea_main_item;
-		GnomeCanvasItem *main_item;
+		FooCanvasItem *main_item;
 		gchar *new_name = g_strdup ("");
 		const gchar *row_label, *column_label;
 
@@ -351,7 +351,7 @@ component_interface_get_extents (AtkComponent *component,
 				   x, y,
 				   &day_view_width, &day_view_height,
 				   coord_type);
-	gnome_canvas_get_scroll_offsets (GNOME_CANVAS (day_view->main_canvas),
+	foo_canvas_get_scroll_offsets (FOO_CANVAS (day_view->main_canvas),
 					 &scroll_x, &scroll_y);
 	*x += day_view->day_offsets[cell->column] - scroll_x;
 	*y += day_view->row_height * cell->row
diff --git a/calendar/gui/ea-jump-button.c b/calendar/gui/ea-jump-button.c
index 67c7eeb..4f84568 100644
--- a/calendar/gui/ea-jump-button.c
+++ b/calendar/gui/ea-jump-button.c
@@ -25,7 +25,7 @@
 #include "ea-calendar-helpers.h"
 #include "ea-week-view.h"
 #include "e-week-view.h"
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 #include <glib/gi18n.h>
 
 static void ea_jump_button_class_init (EaJumpButtonClass *klass);
@@ -75,18 +75,18 @@ ea_jump_button_get_type (void)
 		/*
 		 * Figure out the size of the class and instance
 		 * we are run-time deriving from (atk object for
-		 * GNOME_TYPE_CANVAS_ITEM, in this case)
+		 * FOO_TYPE_CANVAS_ITEM, in this case)
 		 */
 
 		factory = atk_registry_get_factory (atk_get_default_registry (),
-						    GNOME_TYPE_CANVAS_ITEM);
+						    FOO_TYPE_CANVAS_ITEM);
 		derived_atk_type = atk_object_factory_get_accessible_type (factory);
 		g_type_query (derived_atk_type, &query);
 
 		tinfo.class_size = query.class_size;
 		tinfo.instance_size = query.instance_size;
 
-		/* we inherit the component and other interfaces from GNOME_TYPE_CANVAS_ITEM */
+		/* we inherit the component and other interfaces from FOO_TYPE_CANVAS_ITEM */
 		type = g_type_register_static (derived_atk_type,
 					       "EaJumpButton", &tinfo, 0);
 
@@ -114,7 +114,7 @@ ea_jump_button_new (GObject *obj)
 	AtkObject *atk_obj = NULL;
 	GObject *target_obj;
 
-	g_return_val_if_fail (GNOME_IS_CANVAS_ITEM (obj), NULL);
+	g_return_val_if_fail (FOO_IS_CANVAS_ITEM (obj), NULL);
 
 	target_obj = obj;
 	atk_obj = g_object_get_data (target_obj, "accessible-object");
@@ -129,7 +129,7 @@ ea_jump_button_new (GObject *obj)
 		atk_obj->role = event_role;
 	}
 
-	/* the registered factory for GNOME_TYPE_CANVAS_ITEM is cannot create a EaJumpbutton,
+	/* the registered factory for FOO_TYPE_CANVAS_ITEM is cannot create a EaJumpbutton,
 	 * we should save the EaJumpbutton object in it.
 	 */
 	g_object_set_data (obj, "accessible-object", atk_obj);
@@ -173,7 +173,7 @@ jump_button_do_action (AtkAction *action,
   gboolean return_value = TRUE;
   AtkGObjectAccessible *atk_gobj;
   GObject *g_obj;
-  GnomeCanvasItem *item;
+  FooCanvasItem *item;
   ECalendarView *cal_view;
   EWeekView *week_view;
 
@@ -182,14 +182,14 @@ jump_button_do_action (AtkAction *action,
   if (!g_obj)
 	  return FALSE;
 
-  item = GNOME_CANVAS_ITEM (g_obj);
-  cal_view = ea_calendar_helpers_get_cal_view_from (GNOME_CANVAS_ITEM (item));
+  item = FOO_CANVAS_ITEM (g_obj);
+  cal_view = ea_calendar_helpers_get_cal_view_from (FOO_CANVAS_ITEM (item));
   week_view = E_WEEK_VIEW (cal_view);
 
   switch (i)
     {
     case 0:
-	    e_week_view_jump_to_button_item (week_view, GNOME_CANVAS_ITEM (item));
+	    e_week_view_jump_to_button_item (week_view, FOO_CANVAS_ITEM (item));
 	    break;
     default:
 	    return_value = FALSE;
diff --git a/calendar/gui/ea-week-view-cell.c b/calendar/gui/ea-week-view-cell.c
index ea4c103..1a7ec47 100644
--- a/calendar/gui/ea-week-view-cell.c
+++ b/calendar/gui/ea-week-view-cell.c
@@ -207,7 +207,7 @@ ea_week_view_cell_get_name (AtkObject *accessible)
 
 	if (!accessible->name) {
 		AtkObject *ea_main_item;
-		GnomeCanvasItem *main_item;
+		FooCanvasItem *main_item;
 		gchar *new_name = g_strdup ("");
 		const gchar *row_label, *column_label;
                 gint new_column, new_row;
@@ -362,7 +362,7 @@ component_interface_get_extents (AtkComponent *component,
 				   x, y,
 				   &week_view_width, &week_view_height,
 				   coord_type);
-	gnome_canvas_get_scroll_offsets (GNOME_CANVAS (week_view->main_canvas),
+	foo_canvas_get_scroll_offsets (FOO_CANVAS (week_view->main_canvas),
 					 &scroll_x, &scroll_y);
         start_day = week_view->display_start_day;
         if (week_view->multi_week_view) {
diff --git a/calendar/gui/ea-week-view.c b/calendar/gui/ea-week-view.c
index 6e9751e..c4ff2d2 100644
--- a/calendar/gui/ea-week-view.c
+++ b/calendar/gui/ea-week-view.c
@@ -230,7 +230,7 @@ ea_week_view_get_n_children (AtkObject *accessible)
 
 	/* add the number of visible jump buttons */
 	for (i = 0; i < E_WEEK_VIEW_MAX_WEEKS * 7; i++) {
-		if (week_view->jump_buttons[i]->object.flags & GNOME_CANVAS_ITEM_VISIBLE)
+		if (week_view->jump_buttons[i]->object.flags & FOO_CANVAS_ITEM_VISIBLE)
 			++count;
 	}
 
diff --git a/calendar/gui/goto.c b/calendar/gui/goto.c
index 569c15f..60fbfae 100644
--- a/calendar/gui/goto.c
+++ b/calendar/gui/goto.c
@@ -147,7 +147,7 @@ create_ecal (GoToDialog *dlg)
 	dlg->ecal = E_CALENDAR (e_calendar_new ());
 	calitem = dlg->ecal->calitem;
 
-	gnome_canvas_item_set (GNOME_CANVAS_ITEM (calitem),
+	foo_canvas_item_set (FOO_CANVAS_ITEM (calitem),
 			"move_selection_when_moving", FALSE,
 			NULL);
 	e_calendar_item_set_display_popup (calitem, FALSE);
@@ -257,7 +257,7 @@ goto_dialog (GtkWindow *parent, GnomeCalendar *gcal)
 	/* Set week_start_day. Convert it to 0 (Mon) to 6 (Sun), which is what we use. */
 	dlg->ecal->calitem->week_start_day = (calendar_config_get_week_start_day () + 6) % 7;
 
-	gnome_canvas_item_grab_focus (GNOME_CANVAS_ITEM (dlg->ecal->calitem));
+	foo_canvas_item_grab_focus (FOO_CANVAS_ITEM (dlg->ecal->calitem));
 
 	b = gtk_dialog_run (GTK_DIALOG (dlg->dialog));
 	gtk_widget_destroy (dlg->dialog);
diff --git a/calendar/gui/weekday-picker.c b/calendar/gui/weekday-picker.c
index 75223ad..e72e452 100644
--- a/calendar/gui/weekday-picker.c
+++ b/calendar/gui/weekday-picker.c
@@ -30,8 +30,8 @@
 #include <gtk/gtk.h>
 #include <gdk/gdkkeysyms.h>
 #include <glib/gi18n.h>
-#include <libgnomecanvas/gnome-canvas-rect-ellipse.h>
-#include <libgnomecanvas/gnome-canvas-text.h>
+#include <libfoocanvas/foo-canvas-rect-ellipse.h>
+#include <libfoocanvas/foo-canvas-text.h>
 #include <e-util/e-util.h>
 #include "weekday-picker.h"
 
@@ -58,8 +58,8 @@ struct _WeekdayPickerPrivate {
 	gint max_letter_width;
 
 	/* Components */
-	GnomeCanvasItem *boxes[7];
-	GnomeCanvasItem *labels[7];
+	FooCanvasItem *boxes[7];
+	FooCanvasItem *labels[7];
 };
 
 
@@ -72,7 +72,7 @@ enum {
 
 static guint wp_signals[LAST_SIGNAL];
 
-G_DEFINE_TYPE (WeekdayPicker, weekday_picker, GNOME_TYPE_CANVAS)
+G_DEFINE_TYPE (WeekdayPicker, weekday_picker, FOO_TYPE_CANVAS)
 
 static gchar *
 get_day_text (gint day_index)
@@ -126,12 +126,12 @@ colorize_items (WeekdayPicker *wp)
 		else
 			o = outline;
 
-		gnome_canvas_item_set (priv->boxes[i],
+		foo_canvas_item_set (priv->boxes[i],
 				       "fill_color_gdk", f,
 				       "outline_color_gdk", o,
 				       NULL);
 
-		gnome_canvas_item_set (priv->labels[i],
+		foo_canvas_item_set (priv->labels[i],
 				       "fill_color_gdk", t,
 				       NULL);
 	}
@@ -160,7 +160,7 @@ configure_items (WeekdayPicker *wp)
 		if (day >= 7)
 			day -= 7;
 
-		gnome_canvas_item_set (priv->boxes[i],
+		foo_canvas_item_set (priv->boxes[i],
 				       "x1", (double) (i * box_width),
 				       "y1", (double) 0,
 				       "x2", (double) ((i + 1) * box_width),
@@ -169,7 +169,7 @@ configure_items (WeekdayPicker *wp)
 				       NULL);
 
 		c = get_day_text (day);
-		gnome_canvas_item_set (priv->labels[i],
+		foo_canvas_item_set (priv->labels[i],
 				       "text", c,
 				       "x", (double) (i * box_width) + box_width / 2.0,
 				       "y", (double) (1 + PADDING),
@@ -240,8 +240,8 @@ weekday_picker_size_allocate (GtkWidget *widget,
 	widget_class = GTK_WIDGET_CLASS (weekday_picker_parent_class);
 	widget_class->size_allocate (widget, allocation);
 
-	gnome_canvas_set_scroll_region (
-		GNOME_CANVAS (wp), 0, 0,
+	foo_canvas_set_scroll_region (
+		FOO_CANVAS (wp), 0, 0,
 		allocation->width, allocation->height);
 
 	configure_items (wp);
@@ -325,7 +325,7 @@ weekday_picker_focus (GtkWidget *widget,
 	}
 
 	priv->focus_day = priv->week_start_day;
-	gnome_canvas_item_grab_focus (priv->boxes[priv->focus_day]);
+	foo_canvas_item_grab_focus (priv->boxes[priv->focus_day]);
 	colorize_items (wp);
 
 	return TRUE;
@@ -407,13 +407,13 @@ handle_key_press_event (WeekdayPicker *wp, GdkEvent *event)
 		priv->focus_day = 6;
 
 	colorize_items (wp);
-	gnome_canvas_item_grab_focus (priv->boxes[priv->focus_day]);
+	foo_canvas_item_grab_focus (priv->boxes[priv->focus_day]);
 	return TRUE;
 }
 
 /* Event handler for the day items */
 static gint
-day_event_cb (GnomeCanvasItem *item, GdkEvent *event, gpointer data)
+day_event_cb (FooCanvasItem *item, GdkEvent *event, gpointer data)
 {
 	WeekdayPicker *wp;
 	WeekdayPickerPrivate *priv;
@@ -441,7 +441,7 @@ day_event_cb (GnomeCanvasItem *item, GdkEvent *event, gpointer data)
 		i -= 7;
 
 	priv->focus_day = i;
-	gnome_canvas_item_grab_focus (priv->boxes[i]);
+	foo_canvas_item_grab_focus (priv->boxes[i]);
 	day_clicked (wp, i);
 	return TRUE;
 }
@@ -453,21 +453,21 @@ static void
 create_items (WeekdayPicker *wp)
 {
 	WeekdayPickerPrivate *priv;
-	GnomeCanvasGroup *parent;
+	FooCanvasGroup *parent;
 	gint i;
 
 	priv = wp->priv;
 
-	parent = gnome_canvas_root (GNOME_CANVAS (wp));
+	parent = foo_canvas_root (FOO_CANVAS (wp));
 
 	for (i = 0; i < 7; i++) {
-		priv->boxes[i] = gnome_canvas_item_new (parent,
-							GNOME_TYPE_CANVAS_RECT,
+		priv->boxes[i] = foo_canvas_item_new (parent,
+							FOO_TYPE_CANVAS_RECT,
 							NULL);
 		g_signal_connect (priv->boxes[i], "event", G_CALLBACK (day_event_cb), wp);
 
-		priv->labels[i] = gnome_canvas_item_new (parent,
-							 GNOME_TYPE_CANVAS_TEXT,
+		priv->labels[i] = foo_canvas_item_new (parent,
+							 FOO_TYPE_CANVAS_TEXT,
 							 NULL);
 		g_signal_connect (priv->labels[i], "event", G_CALLBACK (day_event_cb), wp);
 	}
diff --git a/calendar/gui/weekday-picker.h b/calendar/gui/weekday-picker.h
index f92eb37..083d4d2 100644
--- a/calendar/gui/weekday-picker.h
+++ b/calendar/gui/weekday-picker.h
@@ -24,7 +24,7 @@
 #ifndef WEEKDAY_PICKER_H
 #define WEEKDAY_PICKER_H
 
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 
 G_BEGIN_DECLS
 
@@ -42,14 +42,14 @@ typedef struct _WeekdayPickerClass WeekdayPickerClass;
 typedef struct _WeekdayPickerPrivate WeekdayPickerPrivate;
 
 struct _WeekdayPicker {
-	GnomeCanvas canvas;
+	FooCanvas canvas;
 
 	/* Private data */
 	WeekdayPickerPrivate *priv;
 };
 
 struct _WeekdayPickerClass {
-	GnomeCanvasClass parent_class;
+	FooCanvasClass parent_class;
 
 	void (* changed) (WeekdayPicker *wp);
 };
diff --git a/mail/message-list.c b/mail/message-list.c
index 288b4a5..16b5765 100644
--- a/mail/message-list.c
+++ b/mail/message-list.c
@@ -1995,7 +1995,7 @@ message_list_setup_etree (MessageList *message_list, gboolean outgoing)
 		d(printf ("folder name is '%s'\n", name));
 
 		path = mail_config_folder_to_cachename (message_list->folder, "et-expanded-");
-		g_object_set_data (G_OBJECT (((GnomeCanvasItem *) item)->canvas), "freeze-cursor", &data);
+		g_object_set_data (G_OBJECT (((FooCanvasItem *) item)->canvas), "freeze-cursor", &data);
 
 		if (path && g_stat (path, &st) == 0 && st.st_size > 0 && S_ISREG (st.st_mode)) {
 			/* build based on saved file */
diff --git a/widgets/misc/e-calendar-item.c b/widgets/misc/e-calendar-item.c
index 6f54327..9310c28 100644
--- a/widgets/misc/e-calendar-item.c
+++ b/widgets/misc/e-calendar-item.c
@@ -53,14 +53,14 @@ static void e_calendar_item_set_property(GObject	 *object,
 					 guint		  property_id,
 					 const GValue	 *value,
 					 GParamSpec	 *pspec);
-static void e_calendar_item_realize	(GnomeCanvasItem *item);
-static void e_calendar_item_unrealize	(GnomeCanvasItem *item);
-static void e_calendar_item_unmap	(GnomeCanvasItem *item);
-static void e_calendar_item_update	(GnomeCanvasItem *item,
+static void e_calendar_item_realize	(FooCanvasItem *item);
+static void e_calendar_item_unrealize	(FooCanvasItem *item);
+static void e_calendar_item_unmap	(FooCanvasItem *item);
+static void e_calendar_item_update	(FooCanvasItem *item,
 					 double		 *affine,
 					 ArtSVP		 *clip_path,
 					 gint		  flags);
-static void e_calendar_item_draw	(GnomeCanvasItem *item,
+static void e_calendar_item_draw	(FooCanvasItem *item,
 					 GdkDrawable	 *drawable,
 					 gint		  x,
 					 gint		  y,
@@ -85,12 +85,12 @@ static void e_calendar_item_draw_day_numbers (ECalendarItem	*calitem,
 					      gint		 start_weekday,
 					      gint		 cells_x,
 					      gint		 cells_y);
-static double e_calendar_item_point	(GnomeCanvasItem *item,
+static double e_calendar_item_point	(FooCanvasItem *item,
 					 double		  x,
 					 double		  y,
 					 gint		  cx,
 					 gint		  cy,
-					 GnomeCanvasItem **actual_item);
+					 FooCanvasItem **actual_item);
 static void e_calendar_item_stop_selecting (ECalendarItem *calitem,
 					    guint32 time);
 static void e_calendar_item_selection_add_days (ECalendarItem *calitem,
@@ -98,9 +98,9 @@ static void e_calendar_item_selection_add_days (ECalendarItem *calitem,
 						gboolean multi_selection);
 static gint e_calendar_item_key_press_event (ECalendarItem *item,
 					     GdkEvent *event);
-static gint e_calendar_item_event	(GnomeCanvasItem *item,
+static gint e_calendar_item_event	(FooCanvasItem *item,
 					 GdkEvent	 *event);
-static void e_calendar_item_bounds (GnomeCanvasItem *item, double *x1, double *y1,
+static void e_calendar_item_bounds (FooCanvasItem *item, double *x1, double *y1,
 				    double *x2, double *y2);
 
 static gboolean e_calendar_item_button_press	(ECalendarItem	*calitem,
@@ -228,20 +228,20 @@ enum {
 
 static guint e_calendar_item_signals[LAST_SIGNAL] = { 0 };
 
-G_DEFINE_TYPE (ECalendarItem, e_calendar_item, GNOME_TYPE_CANVAS_ITEM)
+G_DEFINE_TYPE (ECalendarItem, e_calendar_item, FOO_TYPE_CANVAS_ITEM)
 
 static void
 e_calendar_item_class_init (ECalendarItemClass *class)
 {
 	GObjectClass  *object_class;
-	GnomeCanvasItemClass *item_class;
+	FooCanvasItemClass *item_class;
 
 	object_class = G_OBJECT_CLASS (class);
 	object_class->dispose = e_calendar_item_dispose;
 	object_class->get_property = e_calendar_item_get_property;
 	object_class->set_property = e_calendar_item_set_property;
 
-	item_class = GNOME_CANVAS_ITEM_CLASS (class);
+	item_class = FOO_CANVAS_ITEM_CLASS (class);
 	item_class->realize = e_calendar_item_realize;
 	item_class->unrealize = e_calendar_item_unrealize;
 	item_class->unmap = e_calendar_item_unmap;
@@ -701,14 +701,14 @@ e_calendar_item_set_property (GObject *object,
                               const GValue *value,
                               GParamSpec *pspec)
 {
-	GnomeCanvasItem *item;
+	FooCanvasItem *item;
 	ECalendarItem *calitem;
 	PangoFontDescription *font_desc;
 	gdouble dvalue;
 	gint ivalue;
 	gboolean bvalue;
 
-	item = GNOME_CANVAS_ITEM (object);
+	item = FOO_CANVAS_ITEM (object);
 	calitem = E_CALENDAR_ITEM (object);
 
 	switch (property_id) {
@@ -726,28 +726,28 @@ e_calendar_item_set_property (GObject *object,
 		dvalue = g_value_get_double (value);
 		if (calitem->x1 != dvalue) {
 			calitem->x1 = dvalue;
-			gnome_canvas_item_request_update (item);
+			foo_canvas_item_request_update (item);
 		}
 		return;
 	case PROP_Y1:
 		dvalue = g_value_get_double (value);
 		if (calitem->y1 != dvalue) {
 			calitem->y1 = dvalue;
-			gnome_canvas_item_request_update (item);
+			foo_canvas_item_request_update (item);
 		}
 		return;
 	case PROP_X2:
 		dvalue = g_value_get_double (value);
 		if (calitem->x2 != dvalue) {
 			calitem->x2 = dvalue;
-			gnome_canvas_item_request_update (item);
+			foo_canvas_item_request_update (item);
 		}
 		return;
 	case PROP_Y2:
 		dvalue = g_value_get_double (value);
 		if (calitem->y2 != dvalue) {
 			calitem->y2 = dvalue;
-			gnome_canvas_item_request_update (item);
+			foo_canvas_item_request_update (item);
 		}
 		return;
 	case PROP_FONT_DESC:
@@ -755,21 +755,21 @@ e_calendar_item_set_property (GObject *object,
 		if (calitem->font_desc)
 			pango_font_description_free (calitem->font_desc);
 		calitem->font_desc = pango_font_description_copy (font_desc);
-		gnome_canvas_item_request_update (item);
+		foo_canvas_item_request_update (item);
 		return;
 	case PROP_WEEK_NUMBER_FONT_DESC:
 		font_desc = g_value_get_boxed (value);
 		if (calitem->week_number_font_desc)
 			pango_font_description_free (calitem->week_number_font_desc);
 		calitem->week_number_font_desc = pango_font_description_copy (font_desc);
-		gnome_canvas_item_request_update (item);
+		foo_canvas_item_request_update (item);
 		return;
 	case PROP_MINIMUM_ROWS:
 		ivalue = g_value_get_int (value);
 		ivalue = MAX (1, ivalue);
 		if (calitem->min_rows != ivalue) {
 			calitem->min_rows = ivalue;
-			gnome_canvas_item_request_update (item);
+			foo_canvas_item_request_update (item);
 		}
 		return;
 	case PROP_MINIMUM_COLUMNS:
@@ -777,35 +777,35 @@ e_calendar_item_set_property (GObject *object,
 		ivalue = MAX (1, ivalue);
 		if (calitem->min_cols != ivalue) {
 			calitem->min_cols = ivalue;
-			gnome_canvas_item_request_update (item);
+			foo_canvas_item_request_update (item);
 		}
 		return;
 	case PROP_MAXIMUM_ROWS:
 		ivalue = g_value_get_int (value);
 		if (calitem->max_rows != ivalue) {
 			calitem->max_rows = ivalue;
-			gnome_canvas_item_request_update (item);
+			foo_canvas_item_request_update (item);
 		}
 		return;
 	case PROP_MAXIMUM_COLUMNS:
 		ivalue = g_value_get_int (value);
 		if (calitem->max_cols != ivalue) {
 			calitem->max_cols = ivalue;
-			gnome_canvas_item_request_update (item);
+			foo_canvas_item_request_update (item);
 		}
 		return;
 	case PROP_WEEK_START_DAY:
 		ivalue = g_value_get_int (value);
 		if (calitem->week_start_day != ivalue) {
 			calitem->week_start_day = ivalue;
-			gnome_canvas_item_request_update (item);
+			foo_canvas_item_request_update (item);
 		}
 		return;
 	case PROP_SHOW_WEEK_NUMBERS:
 		bvalue = g_value_get_boolean (value);
 		if (calitem->show_week_numbers != bvalue) {
 			calitem->show_week_numbers = bvalue;
-			gnome_canvas_item_request_update (item);
+			foo_canvas_item_request_update (item);
 		}
 		return;
 	case PROP_MAXIMUM_DAYS_SELECTED:
@@ -834,12 +834,12 @@ e_calendar_item_set_property (GObject *object,
 }
 
 static void
-e_calendar_item_realize		(GnomeCanvasItem *item)
+e_calendar_item_realize		(FooCanvasItem *item)
 {
 	ECalendarItem *calitem;
 
-	if (GNOME_CANVAS_ITEM_CLASS (e_calendar_item_parent_class)->realize)
-		(* GNOME_CANVAS_ITEM_CLASS (e_calendar_item_parent_class)->realize) (item);
+	if (FOO_CANVAS_ITEM_CLASS (e_calendar_item_parent_class)->realize)
+		(* FOO_CANVAS_ITEM_CLASS (e_calendar_item_parent_class)->realize) (item);
 
 	calitem = E_CALENDAR_ITEM (item);
 
@@ -847,7 +847,7 @@ e_calendar_item_realize		(GnomeCanvasItem *item)
 }
 
 static void
-e_calendar_item_unrealize	(GnomeCanvasItem *item)
+e_calendar_item_unrealize	(FooCanvasItem *item)
 {
 	ECalendarItem *calitem;
 	GdkColormap *colormap;
@@ -858,33 +858,33 @@ e_calendar_item_unrealize	(GnomeCanvasItem *item)
 
 	gdk_colormap_free_colors (colormap, calitem->colors, E_CALENDAR_ITEM_COLOR_LAST);
 
-	if (GNOME_CANVAS_ITEM_CLASS (e_calendar_item_parent_class)->unrealize)
-		(* GNOME_CANVAS_ITEM_CLASS (e_calendar_item_parent_class)->unrealize) (item);
+	if (FOO_CANVAS_ITEM_CLASS (e_calendar_item_parent_class)->unrealize)
+		(* FOO_CANVAS_ITEM_CLASS (e_calendar_item_parent_class)->unrealize) (item);
 }
 
 static void
-e_calendar_item_unmap		(GnomeCanvasItem *item)
+e_calendar_item_unmap		(FooCanvasItem *item)
 {
 	ECalendarItem *calitem;
 
 	calitem = E_CALENDAR_ITEM (item);
 
 	if (calitem->selecting) {
-		gnome_canvas_item_ungrab (item, GDK_CURRENT_TIME);
+		foo_canvas_item_ungrab (item, GDK_CURRENT_TIME);
 		calitem->selecting = FALSE;
 	}
 
-	if (GNOME_CANVAS_ITEM_CLASS (e_calendar_item_parent_class)->unmap)
-		(* GNOME_CANVAS_ITEM_CLASS (e_calendar_item_parent_class)->unmap) (item);
+	if (FOO_CANVAS_ITEM_CLASS (e_calendar_item_parent_class)->unmap)
+		(* FOO_CANVAS_ITEM_CLASS (e_calendar_item_parent_class)->unmap) (item);
 }
 
 static void
-e_calendar_item_update		(GnomeCanvasItem *item,
+e_calendar_item_update		(FooCanvasItem *item,
 				 double		 *affine,
 				 ArtSVP		 *clip_path,
 				 gint		  flags)
 {
-	GnomeCanvasItemClass *item_class;
+	FooCanvasItemClass *item_class;
 	ECalendarItem *calitem;
 	GtkStyle *style;
 	gint char_height, width, height, space, space_per_cal, space_per_cell;
@@ -893,7 +893,7 @@ e_calendar_item_update		(GnomeCanvasItem *item,
 	PangoContext *pango_context;
 	PangoFontMetrics *font_metrics;
 
-	item_class = GNOME_CANVAS_ITEM_CLASS (e_calendar_item_parent_class);
+	item_class = FOO_CANVAS_ITEM_CLASS (e_calendar_item_parent_class);
 	if (item_class->update != NULL)
 		item_class->update (item, affine, clip_path, flags);
 
@@ -1004,7 +1004,7 @@ e_calendar_item_update		(GnomeCanvasItem *item,
 	space = MAX (0, space);
 	calitem->x_offset = space / 2;
 
-	gnome_canvas_request_redraw (item->canvas, item->x1, item->y1,
+	foo_canvas_request_redraw (item->canvas, item->x1, item->y1,
 				     item->x2, item->y2);
 
 	pango_font_metrics_unref (font_metrics);
@@ -1014,7 +1014,7 @@ e_calendar_item_update		(GnomeCanvasItem *item,
  * DRAWING ROUTINES - functions to paint the canvas item.
  */
 static void
-e_calendar_item_draw		(GnomeCanvasItem *canvas_item,
+e_calendar_item_draw		(FooCanvasItem *canvas_item,
 				 GdkDrawable	 *drawable,
 				 gint		  x,
 				 gint		  y,
@@ -1146,7 +1146,7 @@ e_calendar_item_draw_month	(ECalendarItem   *calitem,
 				 gint		  row,
 				 gint		  col)
 {
-	GnomeCanvasItem *item;
+	FooCanvasItem *item;
 	GtkWidget *widget;
 	GtkStyle *style;
 	PangoFontDescription *font_desc;
@@ -1170,7 +1170,7 @@ e_calendar_item_draw_month	(ECalendarItem   *calitem,
 	g_print ("In e_calendar_item_draw_month: %i,%i %ix%i row:%i col:%i\n",
 		 x, y, width, height, row, col);
 #endif
-	item = GNOME_CANVAS_ITEM (calitem);
+	item = FOO_CANVAS_ITEM (calitem);
 	widget = GTK_WIDGET (item->canvas);
 	style = gtk_widget_get_style (widget);
 
@@ -1393,7 +1393,7 @@ e_calendar_item_draw_day_numbers (ECalendarItem	*calitem,
 				  gint		 cells_x,
 				  gint		 cells_y)
 {
-	GnomeCanvasItem *item;
+	FooCanvasItem *item;
 	GtkWidget *widget;
 	GtkStyle *style;
 	PangoFontDescription *font_desc, *wkfont_desc;
@@ -1417,7 +1417,7 @@ e_calendar_item_draw_day_numbers (ECalendarItem	*calitem,
 	PangoLayout *layout;
 	cairo_t *cr;
 
-	item = GNOME_CANVAS_ITEM (calitem);
+	item = FOO_CANVAS_ITEM (calitem);
 	widget = GTK_WIDGET (item->canvas);
 	style = gtk_widget_get_style (widget);
 
@@ -1760,9 +1760,9 @@ e_calendar_item_get_week_number	(ECalendarItem *calitem,
    Since we are the only item we just return ourself and 0 for the distance.
    This is needed so that we get button/motion events. */
 static double
-e_calendar_item_point (GnomeCanvasItem *item, double x, double y,
+e_calendar_item_point (FooCanvasItem *item, double x, double y,
 			   gint cx, gint cy,
-			   GnomeCanvasItem **actual_item)
+			   FooCanvasItem **actual_item)
 {
 	*actual_item = item;
 	return 0.0;
@@ -1774,7 +1774,7 @@ e_calendar_item_stop_selecting (ECalendarItem *calitem, guint32 time)
 	if (!calitem->selecting)
 		return;
 
-	gnome_canvas_item_ungrab (GNOME_CANVAS_ITEM (calitem), time);
+	foo_canvas_item_ungrab (FOO_CANVAS_ITEM (calitem), time);
 
 	calitem->selecting = FALSE;
 
@@ -1795,7 +1795,7 @@ e_calendar_item_stop_selecting (ECalendarItem *calitem, guint32 time)
 	}
 
 	e_calendar_item_queue_signal_emission (calitem);
-	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (calitem));
+	foo_canvas_item_request_update (FOO_CANVAS_ITEM (calitem));
 }
 
 static void
@@ -1898,7 +1898,7 @@ e_calendar_item_key_press_event (ECalendarItem *calitem, GdkEvent *event)
 }
 
 static gint
-e_calendar_item_event (GnomeCanvasItem *item, GdkEvent *event)
+e_calendar_item_event (FooCanvasItem *item, GdkEvent *event)
 {
 	ECalendarItem *calitem;
 
@@ -1912,7 +1912,7 @@ e_calendar_item_event (GnomeCanvasItem *item, GdkEvent *event)
 	case GDK_MOTION_NOTIFY:
 		return e_calendar_item_motion (calitem, event);
 	case GDK_FOCUS_CHANGE:
-		gnome_canvas_item_request_update (item);
+		foo_canvas_item_request_update (item);
 	case GDK_KEY_PRESS:
 		return e_calendar_item_key_press_event (calitem, event);
 	default:
@@ -1923,7 +1923,7 @@ e_calendar_item_event (GnomeCanvasItem *item, GdkEvent *event)
 }
 
 static void
-e_calendar_item_bounds (GnomeCanvasItem *item, double *x1, double *y1,
+e_calendar_item_bounds (FooCanvasItem *item, double *x1, double *y1,
 			double *x2, double *y2)
 {
 	ECalendarItem *calitem;
@@ -1942,7 +1942,7 @@ e_calendar_item_bounds (GnomeCanvasItem *item, double *x1, double *y1,
 static void
 e_calendar_item_recalc_sizes		(ECalendarItem *calitem)
 {
-	GnomeCanvasItem *canvas_item;
+	FooCanvasItem *canvas_item;
 	GtkStyle *style;
 	gint day, max_day_width, digit, max_digit_width, max_week_number_digit_width;
 	gint char_height, width, min_cell_width, min_cell_height;
@@ -1951,7 +1951,7 @@ e_calendar_item_recalc_sizes		(ECalendarItem *calitem)
 	PangoFontMetrics *font_metrics;
 	PangoLayout *layout;
 
-	canvas_item = GNOME_CANVAS_ITEM (calitem);
+	canvas_item = FOO_CANVAS_ITEM (calitem);
 	style = gtk_widget_get_style (GTK_WIDGET (canvas_item->canvas));
 
 	if (!style)
@@ -2061,7 +2061,7 @@ e_calendar_item_get_day_style		(ECalendarItem	*calitem,
 	GtkWidget *widget;
 	GtkStyle *style;
 
-	widget = GTK_WIDGET (GNOME_CANVAS_ITEM (calitem)->canvas);
+	widget = GTK_WIDGET (FOO_CANVAS_ITEM (calitem)->canvas);
 	style = gtk_widget_get_style (widget);
 
 	*bg_color = NULL;
@@ -2124,7 +2124,7 @@ e_calendar_item_button_press	(ECalendarItem	*calitem,
 	if (calitem->max_days_selected < 1)
 		return TRUE;
 
-	if (gnome_canvas_item_grab (GNOME_CANVAS_ITEM (calitem),
+	if (foo_canvas_item_grab (FOO_CANVAS_ITEM (calitem),
 				    GDK_POINTER_MOTION_MASK
 				    | GDK_BUTTON_RELEASE_MASK,
 				    NULL, event->button.time) != 0)
@@ -2169,7 +2169,7 @@ e_calendar_item_button_press	(ECalendarItem	*calitem,
 			calitem, &calitem->selection_start_month_offset,
 			&calitem->selection_start_day);
 
-	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (calitem));
+	foo_canvas_item_request_update (FOO_CANVAS_ITEM (calitem));
 
 	return TRUE;
 }
@@ -2289,7 +2289,7 @@ e_calendar_item_motion		(ECalendarItem	*calitem,
 	calitem->selection_end_month_offset = end_month;
 	calitem->selection_end_day = end_day;
 
-	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (calitem));
+	foo_canvas_item_request_update (FOO_CANVAS_ITEM (calitem));
 
 	return TRUE;
 }
@@ -2387,7 +2387,7 @@ e_calendar_item_convert_position_to_day	(ECalendarItem	*calitem,
 					 gint		*day,
 					 gboolean	*entire_week)
 {
-	GnomeCanvasItem *item;
+	FooCanvasItem *item;
 	GtkWidget *widget;
 	GtkStyle *style;
 	gint xthickness, ythickness, char_height;
@@ -2398,7 +2398,7 @@ e_calendar_item_convert_position_to_day	(ECalendarItem	*calitem,
 	PangoContext *pango_context;
 	PangoFontMetrics *font_metrics;
 
-	item = GNOME_CANVAS_ITEM (calitem);
+	item = FOO_CANVAS_ITEM (calitem);
 	widget = GTK_WIDGET (item->canvas);
 	style = gtk_widget_get_style (widget);
 
@@ -2702,7 +2702,7 @@ e_calendar_item_set_first_month(ECalendarItem	*calitem,
 	}
 
 	e_calendar_item_date_range_changed (calitem);
-	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (calitem));
+	foo_canvas_item_request_update (FOO_CANVAS_ITEM (calitem));
 }
 
 /* Get the maximum number of days selectable */
@@ -2718,7 +2718,7 @@ e_calendar_item_set_max_days_sel       (ECalendarItem	*calitem,
 					gint             days)
 {
 	calitem->max_days_selected = MAX (0, days);
-	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (calitem));
+	foo_canvas_item_request_update (FOO_CANVAS_ITEM (calitem));
 }
 
 /* Get the maximum number of days before whole weeks are selected */
@@ -2844,14 +2844,14 @@ e_calendar_item_get_date_range	(ECalendarItem	*calitem,
 void
 e_calendar_item_clear_marks	(ECalendarItem	*calitem)
 {
-	GnomeCanvasItem *item;
+	FooCanvasItem *item;
 
-	item = GNOME_CANVAS_ITEM (calitem);
+	item = FOO_CANVAS_ITEM (calitem);
 
 	g_free (calitem->styles);
 	calitem->styles = NULL;
 
-	gnome_canvas_request_redraw (item->canvas, item->x1, item->y1,
+	foo_canvas_request_redraw (item->canvas, item->x1, item->y1,
 				     item->x2, item->y2);
 }
 
@@ -2878,7 +2878,7 @@ e_calendar_item_mark_day	(ECalendarItem	*calitem,
 	calitem->styles[index] = day_style |
 		(add_day_style ? calitem->styles[index] : 0);
 
-	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (calitem));
+	foo_canvas_item_request_update (FOO_CANVAS_ITEM (calitem));
 }
 
 void
@@ -2946,7 +2946,7 @@ e_calendar_item_mark_days	(ECalendarItem	*calitem,
 		}
 	}
 
-	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (calitem));
+	foo_canvas_item_request_update (FOO_CANVAS_ITEM (calitem));
 }
 
 /* Rounds up the given day to the end of the week. */
@@ -3119,7 +3119,7 @@ e_calendar_item_set_selection_if_emission (ECalendarItem	*calitem,
 		calitem->selection_set = FALSE;
 		calitem->selection_changed = TRUE;
 		e_calendar_item_queue_signal_emission (calitem);
-		gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (calitem));
+		foo_canvas_item_request_update (FOO_CANVAS_ITEM (calitem));
 		return;
 	}
 
@@ -3175,7 +3175,7 @@ e_calendar_item_set_selection_if_emission (ECalendarItem	*calitem,
 	}
 
 	if (need_update)
-		gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (calitem));
+		foo_canvas_item_request_update (FOO_CANVAS_ITEM (calitem));
 }
 
 void
@@ -3209,7 +3209,7 @@ e_calendar_item_set_selection (ECalendarItem	*calitem,
 {
 	/* If the user is in the middle of a selection, we must abort it. */
 	if (calitem->selecting) {
-		gnome_canvas_item_ungrab (GNOME_CANVAS_ITEM (calitem),
+		foo_canvas_item_ungrab (FOO_CANVAS_ITEM (calitem),
 					  GDK_CURRENT_TIME);
 		calitem->selecting = FALSE;
 	}
diff --git a/widgets/misc/e-calendar-item.h b/widgets/misc/e-calendar-item.h
index 0ab34b3..7f0ef58 100644
--- a/widgets/misc/e-calendar-item.h
+++ b/widgets/misc/e-calendar-item.h
@@ -25,7 +25,7 @@
 #ifndef _E_CALENDAR_ITEM_H_
 #define _E_CALENDAR_ITEM_H_
 
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 
 G_BEGIN_DECLS
 
@@ -118,7 +118,7 @@ typedef struct tm (*ECalendarItemGetTimeCallback) (ECalendarItem *calitem,
 
 struct _ECalendarItem
 {
-	GnomeCanvasItem canvas_item;
+	FooCanvasItem canvas_item;
 
 	/* The year & month of the first calendar being displayed. */
 	gint year;
@@ -256,7 +256,7 @@ struct _ECalendarItem
 
 struct _ECalendarItemClass
 {
-	GnomeCanvasItemClass parent_class;
+	FooCanvasItemClass parent_class;
 
 	void (* date_range_changed)	(ECalendarItem *calitem);
 	void (* selection_changed)	(ECalendarItem *calitem);
diff --git a/widgets/misc/e-calendar.c b/widgets/misc/e-calendar.c
index 384d4ce..0933bda 100644
--- a/widgets/misc/e-calendar.c
+++ b/widgets/misc/e-calendar.c
@@ -25,7 +25,7 @@
  * ECalendar - displays a table of monthly calendars, allowing highlighting
  * and selection of one or more days. Like GtkCalendar with more features.
  * Most of the functionality is in the ECalendarItem canvas item, though
- * we also add GnomeCanvasWidget buttons to go to the previous/next month and
+ * we also add FooCanvasWidget buttons to go to the previous/next month and
  * to got to the current day.
  */
 
@@ -36,7 +36,7 @@
 #include "e-calendar.h"
 
 #include <gtk/gtk.h>
-#include <libgnomecanvas/gnome-canvas-widget.h>
+#include <libfoocanvas/foo-canvas-widget.h>
 #include <glib/gi18n.h>
 
 #define E_CALENDAR_SMALL_FONT_PTSIZE 6
@@ -122,7 +122,7 @@ e_calendar_class_init (ECalendarClass *class)
 static void
 e_calendar_init (ECalendar *cal)
 {
-	GnomeCanvasGroup *canvas_group;
+	FooCanvasGroup *canvas_group;
 	PangoFontDescription *small_font_desc;
 	GtkWidget *button, *pixmap;
 	AtkObject *a11y;
@@ -134,9 +134,9 @@ e_calendar_init (ECalendar *cal)
 	pango_font_description_set_size (small_font_desc,
 					 E_CALENDAR_SMALL_FONT_PTSIZE * PANGO_SCALE);
 
-	canvas_group = GNOME_CANVAS_GROUP (GNOME_CANVAS (cal)->root);
+	canvas_group = FOO_CANVAS_GROUP (FOO_CANVAS (cal)->root);
 
-	cal->calitem = E_CALENDAR_ITEM (gnome_canvas_item_new (canvas_group,
+	cal->calitem = E_CALENDAR_ITEM (foo_canvas_item_new (canvas_group,
 							       e_calendar_item_get_type (),
 							       "week_number_font_desc", small_font_desc,
 							       NULL));
@@ -161,8 +161,8 @@ e_calendar_init (ECalendar *cal)
 	gtk_widget_show (pixmap);
 	gtk_container_add (GTK_CONTAINER (button), pixmap);
 
-	cal->prev_item = gnome_canvas_item_new (canvas_group,
-						gnome_canvas_widget_get_type (),
+	cal->prev_item = foo_canvas_item_new (canvas_group,
+						foo_canvas_widget_get_type (),
 						"widget", button,
 						NULL);
 	a11y = gtk_widget_get_accessible (button);
@@ -185,8 +185,8 @@ e_calendar_init (ECalendar *cal)
 	gtk_widget_show (pixmap);
 	gtk_container_add (GTK_CONTAINER (button), pixmap);
 
-	cal->next_item = gnome_canvas_item_new (canvas_group,
-						gnome_canvas_widget_get_type (),
+	cal->next_item = foo_canvas_item_new (canvas_group,
+						foo_canvas_widget_get_type (),
 						"widget", button,
 						NULL);
 	a11y = gtk_widget_get_accessible (button);
@@ -329,17 +329,17 @@ e_calendar_size_allocate	(GtkWidget	*widget,
 						  pango_context_get_language (pango_context));
 
 	/* Set the scroll region to its allocated size, if changed. */
-	gnome_canvas_get_scroll_region (GNOME_CANVAS (cal),
+	foo_canvas_get_scroll_region (FOO_CANVAS (cal),
 					NULL, NULL, &old_x2, &old_y2);
 	gtk_widget_get_allocation (widget, &old_allocation);
 	new_x2 = old_allocation.width - 1;
 	new_y2 = old_allocation.height - 1;
 	if (old_x2 != new_x2 || old_y2 != new_y2)
-		gnome_canvas_set_scroll_region (GNOME_CANVAS (cal),
+		foo_canvas_set_scroll_region (FOO_CANVAS (cal),
 						0, 0, new_x2, new_y2);
 
 	/* Take off space for line & buttons if shown. */
-	gnome_canvas_item_set (GNOME_CANVAS_ITEM (cal->calitem),
+	foo_canvas_item_set (FOO_CANVAS_ITEM (cal->calitem),
 			       "x1", 0.0,
 			       "y1", 0.0,
 			       "x2", new_x2,
@@ -354,7 +354,7 @@ e_calendar_size_allocate	(GtkWidget	*widget,
 		+ E_CALENDAR_ITEM_YPAD_BELOW_MONTH_NAME
 		- E_CALENDAR_ARROW_BUTTON_Y_PAD * 2;
 
-	gnome_canvas_item_set (cal->prev_item,
+	foo_canvas_item_set (cal->prev_item,
 			       "x", (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
 			       ? new_x2 + 1 - xthickness * 2 - E_CALENDAR_ARROW_BUTTON_X_PAD
 				 - arrow_button_size
@@ -365,7 +365,7 @@ e_calendar_size_allocate	(GtkWidget	*widget,
 			       "height", arrow_button_size,
 			       NULL);
 
-	gnome_canvas_item_set (cal->next_item,
+	foo_canvas_item_set (cal->next_item,
 			       "x", (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
 			       ? xthickness * 2 + E_CALENDAR_ARROW_BUTTON_X_PAD
 			       : new_x2 + 1 - xthickness * 2 - E_CALENDAR_ARROW_BUTTON_X_PAD
@@ -389,7 +389,7 @@ e_calendar_set_minimum_size	(ECalendar	*cal,
 	cal->min_rows = rows;
 	cal->min_cols = cols;
 
-	gnome_canvas_item_set (GNOME_CANVAS_ITEM (cal->calitem),
+	foo_canvas_item_set (FOO_CANVAS_ITEM (cal->calitem),
 			       "minimum_rows", rows,
 			       "minimum_columns", cols,
 			       NULL);
@@ -407,7 +407,7 @@ e_calendar_set_maximum_size	(ECalendar	*cal,
 	cal->max_rows = rows;
 	cal->max_cols = cols;
 
-	gnome_canvas_item_set (GNOME_CANVAS_ITEM (cal->calitem),
+	foo_canvas_item_set (FOO_CANVAS_ITEM (cal->calitem),
 			       "maximum_rows", rows,
 			       "maximum_columns", cols,
 			       NULL);
@@ -558,8 +558,8 @@ e_calendar_button_has_focus (ECalendar	*cal)
 
 	g_return_val_if_fail (E_IS_CALENDAR (cal), FALSE);
 
-	prev_widget = GNOME_CANVAS_WIDGET(cal->prev_item)->widget;
-	next_widget = GNOME_CANVAS_WIDGET(cal->next_item)->widget;
+	prev_widget = FOO_CANVAS_WIDGET(cal->prev_item)->widget;
+	next_widget = FOO_CANVAS_WIDGET(cal->next_item)->widget;
 	ret_val = GTK_WIDGET_HAS_FOCUS (prev_widget) ||
 		GTK_WIDGET_HAS_FOCUS (next_widget);
 	return ret_val;
@@ -570,20 +570,20 @@ e_calendar_focus (GtkWidget *widget, GtkDirectionType direction)
 {
 #define E_CALENDAR_FOCUS_CHILDREN_NUM 3
 	ECalendar *cal;
-	GnomeCanvas *canvas;
-	GnomeCanvasItem *children[E_CALENDAR_FOCUS_CHILDREN_NUM];
+	FooCanvas *canvas;
+	FooCanvasItem *children[E_CALENDAR_FOCUS_CHILDREN_NUM];
 	gint focused_index = -1;
 	gint index;
 
 	g_return_val_if_fail (widget != NULL, FALSE);
 	g_return_val_if_fail (E_IS_CALENDAR (widget), FALSE);
 	cal = E_CALENDAR (widget);
-	canvas = GNOME_CANVAS (widget);
+	canvas = FOO_CANVAS (widget);
 
 	if (!gtk_widget_get_can_focus (widget))
 		return FALSE;
 
-	children[0] = GNOME_CANVAS_ITEM (cal->calitem);
+	children[0] = FOO_CANVAS_ITEM (cal->calitem);
 	children[1] = cal->prev_item;
 	children[2] = cal->next_item;
 
@@ -614,9 +614,9 @@ e_calendar_focus (GtkWidget *widget, GtkDirectionType direction)
 	    focused_index >= E_CALENDAR_FOCUS_CHILDREN_NUM)
 		/* move out of e-calendar */
 		return FALSE;
-	gnome_canvas_item_grab_focus (children[focused_index]);
-	if (GNOME_IS_CANVAS_WIDGET (children[focused_index])) {
-		widget = GNOME_CANVAS_WIDGET (children[focused_index])->widget;
+	foo_canvas_item_grab_focus (children[focused_index]);
+	if (FOO_IS_CANVAS_WIDGET (children[focused_index])) {
+		widget = FOO_CANVAS_WIDGET (children[focused_index])->widget;
 		gtk_widget_grab_focus (widget);
 	}
 	return TRUE;
@@ -629,8 +629,8 @@ e_calendar_set_focusable (ECalendar *cal, gboolean focusable)
 
 	g_return_if_fail (E_IS_CALENDAR (cal));
 
-	prev_widget = GNOME_CANVAS_WIDGET(cal->prev_item)->widget;
-	next_widget = GNOME_CANVAS_WIDGET(cal->next_item)->widget;
+	prev_widget = FOO_CANVAS_WIDGET(cal->prev_item)->widget;
+	next_widget = FOO_CANVAS_WIDGET(cal->next_item)->widget;
 
 	if (focusable) {
 		GTK_WIDGET_SET_FLAGS (cal, GTK_CAN_FOCUS);
diff --git a/widgets/misc/e-calendar.h b/widgets/misc/e-calendar.h
index d6b5020..7cbfb5b 100644
--- a/widgets/misc/e-calendar.h
+++ b/widgets/misc/e-calendar.h
@@ -33,7 +33,7 @@ G_BEGIN_DECLS
  * ECalendar - displays a table of monthly calendars, allowing highlighting
  * and selection of one or more days. Like GtkCalendar with more features.
  * Most of the functionality is in the ECalendarItem canvas item, though
- * we also add GnomeCanvasWidget buttons to go to the previous/next month and
+ * we also add FooCanvasWidget buttons to go to the previous/next month and
  * to got to the current day.
  */
 
@@ -65,8 +65,8 @@ struct _ECalendar
 
 	ECalendarItem *calitem;
 
-	GnomeCanvasItem *prev_item;
-	GnomeCanvasItem *next_item;
+	FooCanvasItem *prev_item;
+	FooCanvasItem *next_item;
 
 	gint min_rows;
 	gint min_cols;
diff --git a/widgets/misc/e-canvas-background.c b/widgets/misc/e-canvas-background.c
index f9879c2..9dc1408 100644
--- a/widgets/misc/e-canvas-background.c
+++ b/widgets/misc/e-canvas-background.c
@@ -41,7 +41,7 @@
 
 /* workaround for avoiding API broken */
 #define ecb_get_type e_canvas_background_get_type
-G_DEFINE_TYPE (ECanvasBackground, ecb, GNOME_TYPE_CANVAS_ITEM)
+G_DEFINE_TYPE (ECanvasBackground, ecb, FOO_TYPE_CANVAS_ITEM)
 
 #define d(x)
 
@@ -80,15 +80,15 @@ enum {
 static void
 get_color(ECanvasBackground *ecb)
 {
-	GnomeCanvasItem *item = GNOME_CANVAS_ITEM (ecb);
-	ecb->priv->color.pixel = gnome_canvas_get_color_pixel (item->canvas,
-		GNOME_CANVAS_COLOR (ecb->priv->color.red >> 8,
+	FooCanvasItem *item = FOO_CANVAS_ITEM (ecb);
+	ecb->priv->color.pixel = foo_canvas_get_color_pixel (item->canvas,
+		FOO_CANVAS_COLOR (ecb->priv->color.red >> 8,
 				   ecb->priv->color.green>> 8,
 				   ecb->priv->color.blue>> 8));
 }
 
 static void
-ecb_bounds (GnomeCanvasItem *item, double *x1, double *y1, double *x2, double *y2)
+ecb_bounds (FooCanvasItem *item, double *x1, double *y1, double *x2, double *y2)
 {
 	double   i2c [6];
 	ArtPoint c1, c2, i1, i2;
@@ -96,7 +96,7 @@ ecb_bounds (GnomeCanvasItem *item, double *x1, double *y1, double *x2, double *y
 
 	/* Wrong BBox's are the source of redraw nightmares */
 
-	gnome_canvas_item_i2c_affine (GNOME_CANVAS_ITEM (ecb), i2c);
+	foo_canvas_item_i2c_affine (FOO_CANVAS_ITEM (ecb), i2c);
 
 	i1.x = ecb->priv->x1;
 	i1.y = ecb->priv->y1;
@@ -124,16 +124,16 @@ ecb_bounds (GnomeCanvasItem *item, double *x1, double *y1, double *x2, double *y
 }
 
 /*
- * GnomeCanvasItem::update method
+ * FooCanvasItem::update method
  */
 static void
-ecb_update (GnomeCanvasItem *item, double *affine, ArtSVP *clip_path, gint flags)
+ecb_update (FooCanvasItem *item, double *affine, ArtSVP *clip_path, gint flags)
 {
 	ArtPoint o1, o2;
 	ECanvasBackground *ecb = E_CANVAS_BACKGROUND (item);
 
-	if (GNOME_CANVAS_ITEM_CLASS (ecb_parent_class)->update)
-		GNOME_CANVAS_ITEM_CLASS (ecb_parent_class)->update (item, affine, clip_path, flags);
+	if (FOO_CANVAS_ITEM_CLASS (ecb_parent_class)->update)
+		FOO_CANVAS_ITEM_CLASS (ecb_parent_class)->update (item, affine, clip_path, flags);
 
 	o1.x = item->x1;
 	o1.y = item->y1;
@@ -145,12 +145,12 @@ ecb_update (GnomeCanvasItem *item, double *affine, ArtSVP *clip_path, gint flags
 	    item->y1 != o1.y ||
 	    item->x2 != o2.x ||
 	    item->y2 != o2.y) {
-		gnome_canvas_request_redraw (item->canvas, o1.x, o1.y, o2.x, o2.y);
+		foo_canvas_request_redraw (item->canvas, o1.x, o1.y, o2.x, o2.y);
 		ecb->priv->needs_redraw = 1;
 	}
 
 	if (ecb->priv->needs_redraw) {
-		gnome_canvas_request_redraw (item->canvas, item->x1, item->y1,
+		foo_canvas_request_redraw (item->canvas, item->x1, item->y1,
 					     item->x2, item->y2);
 		ecb->priv->needs_redraw = 0;
 	}
@@ -202,14 +202,14 @@ ecb_set_property (GObject *object,
 		  const GValue *value,
 		  GParamSpec *pspec)
 {
-	GnomeCanvasItem *item;
+	FooCanvasItem *item;
 	ECanvasBackground *ecb;
 
 	GdkColor color = { 0, 0, 0, 0, };
 	GdkColor *pcolor;
 	gboolean color_changed = FALSE;
 
-	item = GNOME_CANVAS_ITEM (object);
+	item = FOO_CANVAS_ITEM (object);
 	ecb = E_CANVAS_BACKGROUND (object);
 
 	switch (prop_id) {
@@ -266,7 +266,7 @@ ecb_set_property (GObject *object,
 	if (color_changed) {
 		ecb->priv->color = color;
 
-		if (GNOME_CANVAS_ITEM_REALIZED & GTK_OBJECT_FLAGS(item)) {
+		if (FOO_CANVAS_ITEM_REALIZED & GTK_OBJECT_FLAGS(item)) {
 			get_color (ecb);
 			if (!item->canvas->aa) {
 				gdk_gc_set_foreground (ecb->priv->gc, &ecb->priv->color);
@@ -275,7 +275,7 @@ ecb_set_property (GObject *object,
 	}
 
 	ecb->priv->needs_redraw = 1;
-	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM(ecb));
+	foo_canvas_item_request_update (FOO_CANVAS_ITEM(ecb));
 }
 
 static void
@@ -334,13 +334,13 @@ ecb_init (ECanvasBackground *ecb)
 }
 
 static void
-ecb_realize (GnomeCanvasItem *item)
+ecb_realize (FooCanvasItem *item)
 {
 	ECanvasBackground *ecb = E_CANVAS_BACKGROUND (item);
 	GdkWindow *bin_window;
 
-	if (GNOME_CANVAS_ITEM_CLASS (ecb_parent_class)->realize)
-                GNOME_CANVAS_ITEM_CLASS (ecb_parent_class)->realize (item);
+	if (FOO_CANVAS_ITEM_CLASS (ecb_parent_class)->realize)
+                FOO_CANVAS_ITEM_CLASS (ecb_parent_class)->realize (item);
 
 	bin_window = gtk_layout_get_bin_window (GTK_LAYOUT (item->canvas));
 
@@ -352,23 +352,23 @@ ecb_realize (GnomeCanvasItem *item)
 	set_stipple (ecb, NULL, FALSE);
 
 	ecb->priv->needs_redraw = 1;
-	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (ecb));
+	foo_canvas_item_request_update (FOO_CANVAS_ITEM (ecb));
 }
 
 static void
-ecb_unrealize (GnomeCanvasItem *item)
+ecb_unrealize (FooCanvasItem *item)
 {
 	ECanvasBackground *ecb = E_CANVAS_BACKGROUND (item);
 
 	g_object_unref (ecb->priv->gc);
 	ecb->priv->gc = NULL;
 
-	if (GNOME_CANVAS_ITEM_CLASS (ecb_parent_class)->unrealize)
-                GNOME_CANVAS_ITEM_CLASS (ecb_parent_class)->unrealize (item);
+	if (FOO_CANVAS_ITEM_CLASS (ecb_parent_class)->unrealize)
+                FOO_CANVAS_ITEM_CLASS (ecb_parent_class)->unrealize (item);
 }
 
 static void
-ecb_draw (GnomeCanvasItem *item,
+ecb_draw (FooCanvasItem *item,
           GdkDrawable *drawable,
           gint x,
           gint y,
@@ -383,7 +383,7 @@ ecb_draw (GnomeCanvasItem *item,
 	/*
 	 * Find out our real position after grouping
 	 */
-	gnome_canvas_item_i2c_affine (item, i2c);
+	foo_canvas_item_i2c_affine (item, i2c);
 	ecb_base_point.x = ecb->priv->x1;
 	ecb_base_point.y = ecb->priv->y1;
 	art_affine_point (&upper_left, &ecb_base_point, i2c);
@@ -410,8 +410,8 @@ ecb_draw (GnomeCanvasItem *item,
 }
 
 static double
-ecb_point (GnomeCanvasItem *item, double x, double y, gint cx, gint cy,
-	   GnomeCanvasItem **actual_item)
+ecb_point (FooCanvasItem *item, double x, double y, gint cx, gint cy,
+	   FooCanvasItem **actual_item)
 {
 	ECanvasBackground *ecb = E_CANVAS_BACKGROUND (item);
 
@@ -432,7 +432,7 @@ static void
 ecb_style_set (ECanvasBackground *ecb,
                GtkStyle *previous_style)
 {
-	GnomeCanvasItem *item = GNOME_CANVAS_ITEM (ecb);
+	FooCanvasItem *item = FOO_CANVAS_ITEM (ecb);
 	GtkStyle *style;
 
 	style = gtk_widget_get_style (GTK_WIDGET (item->canvas));
@@ -440,14 +440,14 @@ ecb_style_set (ECanvasBackground *ecb,
 	if (GTK_WIDGET_REALIZED (item->canvas)) {
 		gdk_gc_set_foreground (
 			ecb->priv->gc, &style->base[GTK_STATE_NORMAL]);
-		gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (ecb));
+		foo_canvas_item_request_update (FOO_CANVAS_ITEM (ecb));
 	}
 }
 
 static void
 ecb_class_init (ECanvasBackgroundClass *ecb_class)
 {
-	GnomeCanvasItemClass *item_class = GNOME_CANVAS_ITEM_CLASS (ecb_class);
+	FooCanvasItemClass *item_class = FOO_CANVAS_ITEM_CLASS (ecb_class);
 	GObjectClass *object_class = G_OBJECT_CLASS (ecb_class);
 
 	object_class->dispose       = ecb_dispose;
diff --git a/widgets/misc/e-canvas-background.h b/widgets/misc/e-canvas-background.h
index 7e3ac19..a8eb2c6 100644
--- a/widgets/misc/e-canvas-background.h
+++ b/widgets/misc/e-canvas-background.h
@@ -25,7 +25,7 @@
 #ifndef E_CANVAS_BACKGROUND_H
 #define E_CANVAS_BACKGROUND_H
 
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 
 G_BEGIN_DECLS
 
@@ -53,13 +53,13 @@ typedef struct _ECanvasBackgroundClass ECanvasBackgroundClass;
 typedef struct _ECanvasBackgroundPrivate ECanvasBackgroundPrivate;
 
 struct _ECanvasBackground {
-	GnomeCanvasItem item;
+	FooCanvasItem item;
 
 	ECanvasBackgroundPrivate *priv;
 };
 
 struct _ECanvasBackgroundClass {
-	GnomeCanvasItemClass parent_class;
+	FooCanvasItemClass parent_class;
 	void        (*style_set)        (ECanvasBackground *eti, GtkStyle *previous_style);
 };
 
diff --git a/widgets/misc/e-canvas-utils.c b/widgets/misc/e-canvas-utils.c
index 9e097b0..264afb6 100644
--- a/widgets/misc/e-canvas-utils.c
+++ b/widgets/misc/e-canvas-utils.c
@@ -24,16 +24,16 @@
 #include "e-canvas-utils.h"
 
 void
-e_canvas_item_move_absolute (GnomeCanvasItem *item, double dx, double dy)
+e_canvas_item_move_absolute (FooCanvasItem *item, double dx, double dy)
 {
 	double translate[6];
 
 	g_return_if_fail (item != NULL);
-	g_return_if_fail (GNOME_IS_CANVAS_ITEM (item));
+	g_return_if_fail (FOO_IS_CANVAS_ITEM (item));
 
 	art_affine_translate (translate, dx, dy);
 
-	gnome_canvas_item_affine_absolute (item, translate);
+	foo_canvas_item_affine_absolute (item, translate);
 }
 
 static double
@@ -64,7 +64,7 @@ compute_offset(gint top, gint bottom, gint page_top, gint page_bottom)
 }
 
 static void
-e_canvas_show_area (GnomeCanvas *canvas, double x1, double y1, double x2, double y2)
+e_canvas_show_area (FooCanvas *canvas, double x1, double y1, double x2, double y2)
 {
 	GtkAdjustment *h, *v;
 	gint dx = 0, dy = 0;
@@ -74,7 +74,7 @@ e_canvas_show_area (GnomeCanvas *canvas, double x1, double y1, double x2, double
 	gdouble value;
 
 	g_return_if_fail (canvas != NULL);
-	g_return_if_fail (GNOME_IS_CANVAS (canvas));
+	g_return_if_fail (FOO_IS_CANVAS (canvas));
 
 	h = gtk_layout_get_hadjustment(GTK_LAYOUT(canvas));
 	page_size = gtk_adjustment_get_page_size (h);
@@ -96,19 +96,19 @@ e_canvas_show_area (GnomeCanvas *canvas, double x1, double y1, double x2, double
 }
 
 void
-e_canvas_item_show_area (GnomeCanvasItem *item, double x1, double y1, double x2, double y2)
+e_canvas_item_show_area (FooCanvasItem *item, double x1, double y1, double x2, double y2)
 {
 	g_return_if_fail (item != NULL);
-	g_return_if_fail (GNOME_IS_CANVAS_ITEM (item));
+	g_return_if_fail (FOO_IS_CANVAS_ITEM (item));
 
-	gnome_canvas_item_i2w(item, &x1, &y1);
-	gnome_canvas_item_i2w(item, &x2, &y2);
+	foo_canvas_item_i2w(item, &x1, &y1);
+	foo_canvas_item_i2w(item, &x2, &y2);
 
 	e_canvas_show_area(item->canvas, x1, y1, x2, y2);
 }
 
 static gboolean
-e_canvas_area_shown (GnomeCanvas *canvas, double x1, double y1, double x2, double y2)
+e_canvas_area_shown (FooCanvas *canvas, double x1, double y1, double x2, double y2)
 {
 	GtkAdjustment *h, *v;
 	gint dx = 0, dy = 0;
@@ -118,7 +118,7 @@ e_canvas_area_shown (GnomeCanvas *canvas, double x1, double y1, double x2, doubl
 	gdouble value;
 
 	g_return_val_if_fail (canvas != NULL, FALSE);
-	g_return_val_if_fail (GNOME_IS_CANVAS (canvas), FALSE);
+	g_return_val_if_fail (FOO_IS_CANVAS (canvas), FALSE);
 
 	h = gtk_layout_get_hadjustment(GTK_LAYOUT(canvas));
 	page_size = gtk_adjustment_get_page_size (h);
@@ -141,13 +141,13 @@ e_canvas_area_shown (GnomeCanvas *canvas, double x1, double y1, double x2, doubl
 }
 
 gboolean
-e_canvas_item_area_shown (GnomeCanvasItem *item, double x1, double y1, double x2, double y2)
+e_canvas_item_area_shown (FooCanvasItem *item, double x1, double y1, double x2, double y2)
 {
 	g_return_val_if_fail (item != NULL, FALSE);
-	g_return_val_if_fail (GNOME_IS_CANVAS_ITEM (item), FALSE);
+	g_return_val_if_fail (FOO_IS_CANVAS_ITEM (item), FALSE);
 
-	gnome_canvas_item_i2w(item, &x1, &y1);
-	gnome_canvas_item_i2w(item, &x2, &y2);
+	foo_canvas_item_i2w(item, &x1, &y1);
+	foo_canvas_item_i2w(item, &x2, &y2);
 
 	return e_canvas_area_shown(item->canvas, x1, y1, x2, y2);
 }
@@ -157,7 +157,7 @@ typedef struct {
 	double y1;
 	double x2;
 	double y2;
-	GnomeCanvas *canvas;
+	FooCanvas *canvas;
 } DoubsAndCanvas;
 
 static gboolean
@@ -172,15 +172,15 @@ show_area_timeout (gpointer data)
 }
 
 void
-e_canvas_item_show_area_delayed (GnomeCanvasItem *item, double x1, double y1, double x2, double y2, gint delay)
+e_canvas_item_show_area_delayed (FooCanvasItem *item, double x1, double y1, double x2, double y2, gint delay)
 {
 	DoubsAndCanvas *dac;
 
 	g_return_if_fail (item != NULL);
-	g_return_if_fail (GNOME_IS_CANVAS_ITEM (item));
+	g_return_if_fail (FOO_IS_CANVAS_ITEM (item));
 
-	gnome_canvas_item_i2w(item, &x1, &y1);
-	gnome_canvas_item_i2w(item, &x2, &y2);
+	foo_canvas_item_i2w(item, &x1, &y1);
+	foo_canvas_item_i2w(item, &x2, &y2);
 
 	dac = g_new(DoubsAndCanvas, 1);
 	dac->x1 = x1;
diff --git a/widgets/misc/e-canvas-utils.h b/widgets/misc/e-canvas-utils.h
index cda34e9..abbcdad 100644
--- a/widgets/misc/e-canvas-utils.h
+++ b/widgets/misc/e-canvas-utils.h
@@ -23,19 +23,19 @@
 #ifndef __E_CANVAS_UTILS__
 #define __E_CANVAS_UTILS__
 
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 
 G_BEGIN_DECLS
 
-void      e_canvas_item_move_absolute      (GnomeCanvasItem *item,
+void      e_canvas_item_move_absolute      (FooCanvasItem *item,
 					    double           dx,
 					    double           dy);
-void      e_canvas_item_show_area          (GnomeCanvasItem *item,
+void      e_canvas_item_show_area          (FooCanvasItem *item,
 					    double           x1,
 					    double           y1,
 					    double           x2,
 					    double           y2);
-void      e_canvas_item_show_area_delayed  (GnomeCanvasItem *item,
+void      e_canvas_item_show_area_delayed  (FooCanvasItem *item,
 					    double           x1,
 					    double           y1,
 					    double           x2,
@@ -44,7 +44,7 @@ void      e_canvas_item_show_area_delayed  (GnomeCanvasItem *item,
 /* Returns TRUE if the area is already shown on the screen (including
    spacing.)  This is equivelent to returning FALSE iff show_area
    would do anything. */
-gboolean  e_canvas_item_area_shown         (GnomeCanvasItem *item,
+gboolean  e_canvas_item_area_shown         (FooCanvasItem *item,
 					    double           x1,
 					    double           y1,
 					    double           x2,
diff --git a/widgets/misc/e-canvas-vbox.c b/widgets/misc/e-canvas-vbox.c
index af159b2..d38a9bb 100644
--- a/widgets/misc/e-canvas-vbox.c
+++ b/widgets/misc/e-canvas-vbox.c
@@ -38,14 +38,14 @@ static void e_canvas_vbox_set_property (GObject *object, guint prop_id, const GV
 static void e_canvas_vbox_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
 static void e_canvas_vbox_dispose (GObject *object);
 
-static gint e_canvas_vbox_event   (GnomeCanvasItem *item, GdkEvent *event);
-static void e_canvas_vbox_realize (GnomeCanvasItem *item);
+static gint e_canvas_vbox_event   (FooCanvasItem *item, GdkEvent *event);
+static void e_canvas_vbox_realize (FooCanvasItem *item);
 
-static void e_canvas_vbox_reflow (GnomeCanvasItem *item, gint flags);
+static void e_canvas_vbox_reflow (FooCanvasItem *item, gint flags);
 
-static void e_canvas_vbox_real_add_item(ECanvasVbox *e_canvas_vbox, GnomeCanvasItem *item);
-static void e_canvas_vbox_real_add_item_start(ECanvasVbox *e_canvas_vbox, GnomeCanvasItem *item);
-static void e_canvas_vbox_resize_children (GnomeCanvasItem *item);
+static void e_canvas_vbox_real_add_item(ECanvasVbox *e_canvas_vbox, FooCanvasItem *item);
+static void e_canvas_vbox_real_add_item_start(ECanvasVbox *e_canvas_vbox, FooCanvasItem *item);
+static void e_canvas_vbox_resize_children (FooCanvasItem *item);
 
 /* The arguments we take */
 enum {
@@ -56,16 +56,16 @@ enum {
 	PROP_SPACING
 };
 
-G_DEFINE_TYPE (ECanvasVbox, e_canvas_vbox, GNOME_TYPE_CANVAS_GROUP)
+G_DEFINE_TYPE (ECanvasVbox, e_canvas_vbox, FOO_TYPE_CANVAS_GROUP)
 
 static void
 e_canvas_vbox_class_init (ECanvasVboxClass *klass)
 {
 	GObjectClass *object_class;
-	GnomeCanvasItemClass *item_class;
+	FooCanvasItemClass *item_class;
 
 	object_class = (GObjectClass*) klass;
-	item_class = (GnomeCanvasItemClass *) klass;
+	item_class = (FooCanvasItemClass *) klass;
 
 	klass->add_item       = e_canvas_vbox_real_add_item;
 	klass->add_item_start = e_canvas_vbox_real_add_item_start;
@@ -74,7 +74,7 @@ e_canvas_vbox_class_init (ECanvasVboxClass *klass)
 	object_class->get_property = e_canvas_vbox_get_property;
 	object_class->dispose      = e_canvas_vbox_dispose;
 
-	/* GnomeCanvasItem method overrides */
+	/* FooCanvasItem method overrides */
 	item_class->event       = e_canvas_vbox_event;
 	item_class->realize     = e_canvas_vbox_realize;
 
@@ -114,16 +114,16 @@ e_canvas_vbox_init (ECanvasVbox *vbox)
 	vbox->height = 10;
 	vbox->spacing = 0;
 
-	e_canvas_item_set_reflow_callback(GNOME_CANVAS_ITEM(vbox), e_canvas_vbox_reflow);
+	e_canvas_item_set_reflow_callback(FOO_CANVAS_ITEM(vbox), e_canvas_vbox_reflow);
 }
 
 static void
 e_canvas_vbox_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
 {
-	GnomeCanvasItem *item;
+	FooCanvasItem *item;
 	ECanvasVbox *e_canvas_vbox;
 
-	item = GNOME_CANVAS_ITEM (object);
+	item = FOO_CANVAS_ITEM (object);
 	e_canvas_vbox = E_CANVAS_VBOX (object);
 
 	switch (prop_id) {
@@ -171,11 +171,11 @@ static void
 disconnect_item_cb (gpointer data, gpointer user_data)
 {
 	ECanvasVbox *vbox;
-	GnomeCanvasItem *item;
+	FooCanvasItem *item;
 
 	vbox = E_CANVAS_VBOX (user_data);
 
-	item = GNOME_CANVAS_ITEM (data);
+	item = FOO_CANVAS_ITEM (data);
 	g_signal_handlers_disconnect_matched (item,
 					      G_SIGNAL_MATCH_DATA,
 					      0, 0, NULL, NULL,
@@ -197,7 +197,7 @@ e_canvas_vbox_dispose (GObject *object)
 }
 
 static gint
-e_canvas_vbox_event (GnomeCanvasItem *item, GdkEvent *event)
+e_canvas_vbox_event (FooCanvasItem *item, GdkEvent *event)
 {
 	gint return_val = TRUE;
 
@@ -226,18 +226,18 @@ e_canvas_vbox_event (GnomeCanvasItem *item, GdkEvent *event)
 		break;
 	}
 	if (!return_val) {
-		if (GNOME_CANVAS_ITEM_CLASS(e_canvas_vbox_parent_class)->event)
-			return GNOME_CANVAS_ITEM_CLASS (e_canvas_vbox_parent_class)->event (item, event);
+		if (FOO_CANVAS_ITEM_CLASS(e_canvas_vbox_parent_class)->event)
+			return FOO_CANVAS_ITEM_CLASS (e_canvas_vbox_parent_class)->event (item, event);
 	}
 	return return_val;
 
 }
 
 static void
-e_canvas_vbox_realize (GnomeCanvasItem *item)
+e_canvas_vbox_realize (FooCanvasItem *item)
 {
-	if (GNOME_CANVAS_ITEM_CLASS(e_canvas_vbox_parent_class)->realize)
-		(* GNOME_CANVAS_ITEM_CLASS(e_canvas_vbox_parent_class)->realize) (item);
+	if (FOO_CANVAS_ITEM_CLASS(e_canvas_vbox_parent_class)->realize)
+		(* FOO_CANVAS_ITEM_CLASS(e_canvas_vbox_parent_class)->realize) (item);
 
 	e_canvas_vbox_resize_children(item);
 	e_canvas_item_request_reflow(item);
@@ -251,13 +251,13 @@ e_canvas_vbox_remove_item (gpointer data, GObject *where_object_was)
 }
 
 static void
-e_canvas_vbox_real_add_item(ECanvasVbox *e_canvas_vbox, GnomeCanvasItem *item)
+e_canvas_vbox_real_add_item(ECanvasVbox *e_canvas_vbox, FooCanvasItem *item)
 {
 	e_canvas_vbox->items = g_list_append(e_canvas_vbox->items, item);
 	g_object_weak_ref (G_OBJECT (item),
 			   e_canvas_vbox_remove_item, e_canvas_vbox);
-	if ( GTK_OBJECT_FLAGS( e_canvas_vbox ) & GNOME_CANVAS_ITEM_REALIZED ) {
-		gnome_canvas_item_set(item,
+	if ( GTK_OBJECT_FLAGS( e_canvas_vbox ) & FOO_CANVAS_ITEM_REALIZED ) {
+		foo_canvas_item_set(item,
 				      "width", (double) e_canvas_vbox->minimum_width,
 				      NULL);
 		e_canvas_item_request_reflow(item);
@@ -265,13 +265,13 @@ e_canvas_vbox_real_add_item(ECanvasVbox *e_canvas_vbox, GnomeCanvasItem *item)
 }
 
 static void
-e_canvas_vbox_real_add_item_start(ECanvasVbox *e_canvas_vbox, GnomeCanvasItem *item)
+e_canvas_vbox_real_add_item_start(ECanvasVbox *e_canvas_vbox, FooCanvasItem *item)
 {
 	e_canvas_vbox->items = g_list_prepend(e_canvas_vbox->items, item);
 	g_object_weak_ref (G_OBJECT (item),
 			   e_canvas_vbox_remove_item, e_canvas_vbox);
-	if ( GTK_OBJECT_FLAGS( e_canvas_vbox ) & GNOME_CANVAS_ITEM_REALIZED ) {
-		gnome_canvas_item_set(item,
+	if ( GTK_OBJECT_FLAGS( e_canvas_vbox ) & FOO_CANVAS_ITEM_REALIZED ) {
+		foo_canvas_item_set(item,
 				      "width", (double) e_canvas_vbox->minimum_width,
 				      NULL);
 		e_canvas_item_request_reflow(item);
@@ -279,25 +279,25 @@ e_canvas_vbox_real_add_item_start(ECanvasVbox *e_canvas_vbox, GnomeCanvasItem *i
 }
 
 static void
-e_canvas_vbox_resize_children (GnomeCanvasItem *item)
+e_canvas_vbox_resize_children (FooCanvasItem *item)
 {
 	GList *list;
 	ECanvasVbox *e_canvas_vbox;
 
 	e_canvas_vbox = E_CANVAS_VBOX (item);
 	for ( list = e_canvas_vbox->items; list; list = list->next ) {
-		GnomeCanvasItem *child = GNOME_CANVAS_ITEM(list->data);
-		gnome_canvas_item_set(child,
+		FooCanvasItem *child = FOO_CANVAS_ITEM(list->data);
+		foo_canvas_item_set(child,
 				      "width", (double) e_canvas_vbox->minimum_width,
 				      NULL);
 	}
 }
 
 static void
-e_canvas_vbox_reflow( GnomeCanvasItem *item, gint flags )
+e_canvas_vbox_reflow( FooCanvasItem *item, gint flags )
 {
 	ECanvasVbox *e_canvas_vbox = E_CANVAS_VBOX(item);
-	if ( GTK_OBJECT_FLAGS( e_canvas_vbox ) & GNOME_CANVAS_ITEM_REALIZED ) {
+	if ( GTK_OBJECT_FLAGS( e_canvas_vbox ) & FOO_CANVAS_ITEM_REALIZED ) {
 
 		gdouble old_height;
 		gdouble running_height;
@@ -321,7 +321,7 @@ e_canvas_vbox_reflow( GnomeCanvasItem *item, gint flags )
 				      "height", &item_height,
 				      "width", &item_width,
 				      NULL);
-			e_canvas_item_move_absolute(GNOME_CANVAS_ITEM(list->data),
+			e_canvas_item_move_absolute(FOO_CANVAS_ITEM(list->data),
 						    (double) 0,
 						    (double) running_height);
 			running_height += item_height;
@@ -337,7 +337,7 @@ e_canvas_vbox_reflow( GnomeCanvasItem *item, gint flags )
 					      "width", &item_width,
 					      NULL);
 
-				e_canvas_item_move_absolute(GNOME_CANVAS_ITEM(list->data),
+				e_canvas_item_move_absolute(FOO_CANVAS_ITEM(list->data),
 							    (double) 0,
 							    (double) running_height);
 
@@ -356,14 +356,14 @@ e_canvas_vbox_reflow( GnomeCanvasItem *item, gint flags )
 }
 
 void
-e_canvas_vbox_add_item(ECanvasVbox *e_canvas_vbox, GnomeCanvasItem *item)
+e_canvas_vbox_add_item(ECanvasVbox *e_canvas_vbox, FooCanvasItem *item)
 {
 	if (E_CANVAS_VBOX_CLASS(GTK_OBJECT_GET_CLASS(e_canvas_vbox))->add_item)
 		(E_CANVAS_VBOX_CLASS(GTK_OBJECT_GET_CLASS(e_canvas_vbox))->add_item) (e_canvas_vbox, item);
 }
 
 void
-e_canvas_vbox_add_item_start(ECanvasVbox *e_canvas_vbox, GnomeCanvasItem *item)
+e_canvas_vbox_add_item_start(ECanvasVbox *e_canvas_vbox, FooCanvasItem *item)
 {
 	if (E_CANVAS_VBOX_CLASS(GTK_OBJECT_GET_CLASS(e_canvas_vbox))->add_item_start)
 		(E_CANVAS_VBOX_CLASS(GTK_OBJECT_GET_CLASS(e_canvas_vbox))->add_item_start) (e_canvas_vbox, item);
diff --git a/widgets/misc/e-canvas-vbox.h b/widgets/misc/e-canvas-vbox.h
index b41b8f8..9c271a9 100644
--- a/widgets/misc/e-canvas-vbox.h
+++ b/widgets/misc/e-canvas-vbox.h
@@ -24,7 +24,7 @@
 #define __E_CANVAS_VBOX_H__
 
 #include <gtk/gtk.h>
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 
 G_BEGIN_DECLS
 
@@ -50,10 +50,10 @@ typedef struct _ECanvasVboxClass  ECanvasVboxClass;
 
 struct _ECanvasVbox
 {
-	GnomeCanvasGroup parent;
+	FooCanvasGroup parent;
 
 	/* item specific fields */
-	GList *items; /* Of type GnomeCanvasItem */
+	GList *items; /* Of type FooCanvasItem */
 
 	double width;
 	double minimum_width;
@@ -63,11 +63,11 @@ struct _ECanvasVbox
 
 struct _ECanvasVboxClass
 {
-	GnomeCanvasGroupClass parent_class;
+	FooCanvasGroupClass parent_class;
 
 	/* Virtual methods. */
-	void (* add_item) (ECanvasVbox *CanvasVbox, GnomeCanvasItem *item);
-	void (* add_item_start) (ECanvasVbox *CanvasVbox, GnomeCanvasItem *item);
+	void (* add_item) (ECanvasVbox *CanvasVbox, FooCanvasItem *item);
+	void (* add_item_start) (ECanvasVbox *CanvasVbox, FooCanvasItem *item);
 };
 
 /*
@@ -76,8 +76,8 @@ struct _ECanvasVboxClass
  * should also do an ECanvas parent CanvasVbox request if its size
  * changes.
  */
-void       e_canvas_vbox_add_item(ECanvasVbox *e_canvas_vbox, GnomeCanvasItem *item);
-void       e_canvas_vbox_add_item_start(ECanvasVbox *e_canvas_vbox, GnomeCanvasItem *item);
+void       e_canvas_vbox_add_item(ECanvasVbox *e_canvas_vbox, FooCanvasItem *item);
+void       e_canvas_vbox_add_item_start(ECanvasVbox *e_canvas_vbox, FooCanvasItem *item);
 GType      e_canvas_vbox_get_type (void);
 
 G_END_DECLS
diff --git a/widgets/misc/e-canvas.c b/widgets/misc/e-canvas.c
index f1b7713..0706346 100644
--- a/widgets/misc/e-canvas.c
+++ b/widgets/misc/e-canvas.c
@@ -48,7 +48,7 @@ static gint e_canvas_focus_out      (GtkWidget        *widget,
 static void e_canvas_style_set      (GtkWidget        *widget,
 				     GtkStyle         *previous_style);
 
-static gint emit_event (GnomeCanvas *canvas, GdkEvent *event);
+static gint emit_event (FooCanvas *canvas, GdkEvent *event);
 
 #define d(x)
 
@@ -59,7 +59,7 @@ enum {
 
 static guint e_canvas_signals [LAST_SIGNAL] = { 0, };
 
-G_DEFINE_TYPE (ECanvas, e_canvas, GNOME_TYPE_CANVAS)
+G_DEFINE_TYPE (ECanvas, e_canvas, FOO_TYPE_CANVAS)
 
 static void
 e_canvas_class_init (ECanvasClass *klass)
@@ -147,12 +147,12 @@ e_canvas_new (void)
  * item, or focused item, as appropriate.
  */
 static gint
-emit_event (GnomeCanvas *canvas, GdkEvent *event)
+emit_event (FooCanvas *canvas, GdkEvent *event)
 {
 	GdkEvent *ev;
 	gint finished;
-	GnomeCanvasItem *item;
-	GnomeCanvasItem *parent;
+	FooCanvasItem *item;
+	FooCanvasItem *parent;
 	guint mask;
 
 	/* Choose where we send the event */
@@ -218,7 +218,7 @@ emit_event (GnomeCanvas *canvas, GdkEvent *event)
 	switch (ev->type) {
 	case GDK_ENTER_NOTIFY:
 	case GDK_LEAVE_NOTIFY:
-		gnome_canvas_window_to_world (canvas,
+		foo_canvas_window_to_world (canvas,
 					      ev->crossing.x, ev->crossing.y,
 					      &ev->crossing.x, &ev->crossing.y);
 		break;
@@ -228,7 +228,7 @@ emit_event (GnomeCanvas *canvas, GdkEvent *event)
 	case GDK_2BUTTON_PRESS:
 	case GDK_3BUTTON_PRESS:
 	case GDK_BUTTON_RELEASE:
-		gnome_canvas_window_to_world (canvas,
+		foo_canvas_window_to_world (canvas,
 					      ev->motion.x, ev->motion.y,
 					      &ev->motion.x, &ev->motion.y);
 		break;
@@ -264,14 +264,14 @@ emit_event (GnomeCanvas *canvas, GdkEvent *event)
 static gint
 e_canvas_key (GtkWidget *widget, GdkEventKey *event)
 {
-	GnomeCanvas *canvas;
+	FooCanvas *canvas;
 	GdkEvent full_event;
 
 	g_return_val_if_fail (widget != NULL, FALSE);
-	g_return_val_if_fail (GNOME_IS_CANVAS (widget), FALSE);
+	g_return_val_if_fail (FOO_IS_CANVAS (widget), FALSE);
 	g_return_val_if_fail (event != NULL, FALSE);
 
-	canvas = GNOME_CANVAS (widget);
+	canvas = FOO_CANVAS (widget);
 
 	full_event.key = *event;
 
@@ -285,8 +285,8 @@ e_canvas_key (GtkWidget *widget, GdkEventKey *event)
 #define HACKISH_AFFINE
 
 static double
-gnome_canvas_item_invoke_point (GnomeCanvasItem *item, double x, double y, gint cx, gint cy,
-				GnomeCanvasItem **actual_item)
+foo_canvas_item_invoke_point (FooCanvasItem *item, double x, double y, gint cx, gint cy,
+				FooCanvasItem **actual_item)
 {
 #ifdef HACKISH_AFFINE
 	double i2w[6], w2c[6], i2c[6], c2i[6];
@@ -294,8 +294,8 @@ gnome_canvas_item_invoke_point (GnomeCanvasItem *item, double x, double y, gint
 #endif
 
 #ifdef HACKISH_AFFINE
-	gnome_canvas_item_i2w_affine (item, i2w);
-	gnome_canvas_w2c_affine (item->canvas, w2c);
+	foo_canvas_item_i2w_affine (item, i2w);
+	foo_canvas_w2c_affine (item->canvas, w2c);
 	art_affine_multiply (i2c, i2w, w2c);
 	art_affine_invert (c2i, i2c);
 	c.x = cx;
@@ -305,17 +305,17 @@ gnome_canvas_item_invoke_point (GnomeCanvasItem *item, double x, double y, gint
 	y = i.y;
 #endif
 
-	return (* GNOME_CANVAS_ITEM_CLASS (GTK_OBJECT_GET_CLASS (item))->point) (
+	return (* FOO_CANVAS_ITEM_CLASS (GTK_OBJECT_GET_CLASS (item))->point) (
 		item, x, y, cx, cy, actual_item);
 }
 
 /* Re-picks the current item in the canvas, based on the event's coordinates.
  * Also emits enter/leave events for items as appropriate.
  */
-#define DISPLAY_X1(canvas) (GNOME_CANVAS (canvas)->layout.xoffset)
-#define DISPLAY_Y1(canvas) (GNOME_CANVAS (canvas)->layout.yoffset)
+#define DISPLAY_X1(canvas) (FOO_CANVAS (canvas)->layout.xoffset)
+#define DISPLAY_Y1(canvas) (FOO_CANVAS (canvas)->layout.yoffset)
 static gint
-pick_current_item (GnomeCanvas *canvas, GdkEvent *event)
+pick_current_item (FooCanvas *canvas, GdkEvent *event)
 {
 	gint button_down;
 	double x, y;
@@ -400,8 +400,8 @@ pick_current_item (GnomeCanvas *canvas, GdkEvent *event)
 
 		/* find the closest item */
 
-		if (canvas->root->object.flags & GNOME_CANVAS_ITEM_VISIBLE)
-			gnome_canvas_item_invoke_point (canvas->root, x, y, cx, cy,
+		if (canvas->root->object.flags & FOO_CANVAS_ITEM_VISIBLE)
+			foo_canvas_item_invoke_point (canvas->root, x, y, cx, cy,
 							&canvas->new_current_item);
 		else
 			canvas->new_current_item = NULL;
@@ -457,18 +457,18 @@ pick_current_item (GnomeCanvas *canvas, GdkEvent *event)
 static gint
 e_canvas_button (GtkWidget *widget, GdkEventButton *event)
 {
-	GnomeCanvas *canvas;
+	FooCanvas *canvas;
 	GdkWindow *bin_window;
 	gint mask;
 	gint retval;
 
 	g_return_val_if_fail (widget != NULL, FALSE);
-	g_return_val_if_fail (GNOME_IS_CANVAS (widget), FALSE);
+	g_return_val_if_fail (FOO_IS_CANVAS (widget), FALSE);
 	g_return_val_if_fail (event != NULL, FALSE);
 
 	retval = FALSE;
 
-	canvas = GNOME_CANVAS (widget);
+	canvas = FOO_CANVAS (widget);
 	bin_window = gtk_layout_get_bin_window (GTK_LAYOUT (canvas));
 
 	d(g_print ("button %d, event type %d, grabbed=%p, current=%p\n",
@@ -556,14 +556,14 @@ e_canvas_visibility (GtkWidget *widget, GdkEventVisibility *event, ECanvas *canv
  * the focus and @widget_too is %TRUE, it grabs that focus as well.
  **/
 void
-e_canvas_item_grab_focus (GnomeCanvasItem *item, gboolean widget_too)
+e_canvas_item_grab_focus (FooCanvasItem *item, gboolean widget_too)
 {
-	GnomeCanvasItem *focused_item;
+	FooCanvasItem *focused_item;
 	GdkWindow *bin_window;
 	GdkEvent ev;
 
 	g_return_if_fail (item != NULL);
-	g_return_if_fail (GNOME_IS_CANVAS_ITEM (item));
+	g_return_if_fail (FOO_IS_CANVAS_ITEM (item));
 	g_return_if_fail (gtk_widget_get_can_focus (GTK_WIDGET (item->canvas)));
 
 	bin_window = gtk_layout_get_bin_window (GTK_LAYOUT (item->canvas));
@@ -599,11 +599,11 @@ e_canvas_item_grab_focus (GnomeCanvasItem *item, gboolean widget_too)
 static gint
 e_canvas_focus_in (GtkWidget *widget, GdkEventFocus *event)
 {
-	GnomeCanvas *canvas;
+	FooCanvas *canvas;
 	ECanvas *ecanvas;
 	GdkEvent full_event;
 
-	canvas = GNOME_CANVAS (widget);
+	canvas = FOO_CANVAS (widget);
 	ecanvas = E_CANVAS (widget);
 
 	GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS);
@@ -622,11 +622,11 @@ e_canvas_focus_in (GtkWidget *widget, GdkEventFocus *event)
 static gint
 e_canvas_focus_out (GtkWidget *widget, GdkEventFocus *event)
 {
-	GnomeCanvas *canvas;
+	FooCanvas *canvas;
 	ECanvas *ecanvas;
 	GdkEvent full_event;
 
-	canvas = GNOME_CANVAS (widget);
+	canvas = FOO_CANVAS (widget);
 	ecanvas = E_CANVAS (widget);
 
 	GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS);
@@ -642,7 +642,7 @@ e_canvas_focus_out (GtkWidget *widget, GdkEventFocus *event)
 }
 
 static void
-ec_style_set_recursive (GnomeCanvasItem *item, GtkStyle *previous_style)
+ec_style_set_recursive (FooCanvasItem *item, GtkStyle *previous_style)
 {
 	guint signal_id = g_signal_lookup ("style_set", G_OBJECT_TYPE (item));
 	if (signal_id >= 1) {
@@ -653,8 +653,8 @@ ec_style_set_recursive (GnomeCanvasItem *item, GtkStyle *previous_style)
 		}
 	}
 
-	if (GNOME_IS_CANVAS_GROUP (item) ) {
-		GList *items = GNOME_CANVAS_GROUP (item)->item_list;
+	if (FOO_IS_CANVAS_GROUP (item) ) {
+		GList *items = FOO_CANVAS_GROUP (item)->item_list;
 		for (; items; items = items->next)
 			ec_style_set_recursive (items->data, previous_style);
 	}
@@ -663,7 +663,7 @@ ec_style_set_recursive (GnomeCanvasItem *item, GtkStyle *previous_style)
 static void
 e_canvas_style_set (GtkWidget *widget, GtkStyle *previous_style)
 {
-	ec_style_set_recursive (GNOME_CANVAS_ITEM (gnome_canvas_root (GNOME_CANVAS (widget))), previous_style);
+	ec_style_set_recursive (FOO_CANVAS_ITEM (foo_canvas_root (FOO_CANVAS (widget))), previous_style);
 }
 
 static void
@@ -699,16 +699,16 @@ e_canvas_unrealize (GtkWidget *widget)
 }
 
 static void
-e_canvas_item_invoke_reflow (GnomeCanvasItem *item, gint flags)
+e_canvas_item_invoke_reflow (FooCanvasItem *item, gint flags)
 {
-	GnomeCanvasGroup *group;
+	FooCanvasGroup *group;
 	GList *list;
-	GnomeCanvasItem *child;
+	FooCanvasItem *child;
 
-	if (GNOME_IS_CANVAS_GROUP (item)) {
-		group = GNOME_CANVAS_GROUP (item);
+	if (FOO_IS_CANVAS_GROUP (item)) {
+		group = FOO_CANVAS_GROUP (item);
 		for (list = group->item_list; list; list = list->next) {
-			child = GNOME_CANVAS_ITEM (list->data);
+			child = FOO_CANVAS_ITEM (list->data);
 			if (child->object.flags & E_CANVAS_ITEM_DESCENDENT_NEEDS_REFLOW)
 				e_canvas_item_invoke_reflow (child, flags);
 		}
@@ -730,8 +730,8 @@ e_canvas_item_invoke_reflow (GnomeCanvasItem *item, gint flags)
 static void
 do_reflow (ECanvas *canvas)
 {
-	if (GNOME_CANVAS(canvas)->root->object.flags & E_CANVAS_ITEM_DESCENDENT_NEEDS_REFLOW)
-		e_canvas_item_invoke_reflow (GNOME_CANVAS(canvas)->root, 0);
+	if (FOO_CANVAS(canvas)->root->object.flags & E_CANVAS_ITEM_DESCENDENT_NEEDS_REFLOW)
+		e_canvas_item_invoke_reflow (FOO_CANVAS(canvas)->root, 0);
 }
 
 /* Idle handler for the e-canvas.  It deals with pending reflows. */
@@ -767,7 +767,7 @@ add_idle (ECanvas *canvas)
 }
 
 static void
-e_canvas_item_descendent_needs_reflow (GnomeCanvasItem *item)
+e_canvas_item_descendent_needs_reflow (FooCanvasItem *item)
 {
 	if (item->object.flags & E_CANVAS_ITEM_DESCENDENT_NEEDS_REFLOW)
 		return;
@@ -778,9 +778,9 @@ e_canvas_item_descendent_needs_reflow (GnomeCanvasItem *item)
 }
 
 void
-e_canvas_item_request_reflow (GnomeCanvasItem *item)
+e_canvas_item_request_reflow (FooCanvasItem *item)
 {
-	if (item->object.flags & GNOME_CANVAS_ITEM_REALIZED) {
+	if (item->object.flags & FOO_CANVAS_ITEM_REALIZED) {
 		item->object.flags |= E_CANVAS_ITEM_NEEDS_REFLOW;
 		e_canvas_item_descendent_needs_reflow(item);
 		add_idle(E_CANVAS(item->canvas));
@@ -788,33 +788,33 @@ e_canvas_item_request_reflow (GnomeCanvasItem *item)
 }
 
 void
-e_canvas_item_request_parent_reflow (GnomeCanvasItem *item)
+e_canvas_item_request_parent_reflow (FooCanvasItem *item)
 {
 	g_return_if_fail(item != NULL);
-	g_return_if_fail(GNOME_IS_CANVAS_ITEM(item));
+	g_return_if_fail(FOO_IS_CANVAS_ITEM(item));
 	e_canvas_item_request_reflow(item->parent);
 }
 
 void
-e_canvas_item_set_reflow_callback (GnomeCanvasItem *item, ECanvasItemReflowFunc func)
+e_canvas_item_set_reflow_callback (FooCanvasItem *item, ECanvasItemReflowFunc func)
 {
 	g_object_set_data(G_OBJECT(item), "ECanvasItem::reflow_callback", (gpointer) func);
 }
 
 void
-e_canvas_item_set_selection_callback (GnomeCanvasItem *item, ECanvasItemSelectionFunc func)
+e_canvas_item_set_selection_callback (FooCanvasItem *item, ECanvasItemSelectionFunc func)
 {
 	g_object_set_data(G_OBJECT(item), "ECanvasItem::selection_callback", (gpointer) func);
 }
 
 void
-e_canvas_item_set_selection_compare_callback (GnomeCanvasItem *item, ECanvasItemSelectionCompareFunc func)
+e_canvas_item_set_selection_compare_callback (FooCanvasItem *item, ECanvasItemSelectionCompareFunc func)
 {
 	g_object_set_data(G_OBJECT(item), "ECanvasItem::selection_compare_callback", (gpointer) func);
 }
 
 void
-e_canvas_item_set_cursor (GnomeCanvasItem *item, gpointer id)
+e_canvas_item_set_cursor (FooCanvasItem *item, gpointer id)
 {
 	GList *list;
 	gint flags;
@@ -823,7 +823,7 @@ e_canvas_item_set_cursor (GnomeCanvasItem *item, gpointer id)
 	ECanvasItemSelectionFunc func;
 
 	g_return_if_fail(item != NULL);
-	g_return_if_fail(GNOME_IS_CANVAS_ITEM(item));
+	g_return_if_fail(FOO_IS_CANVAS_ITEM(item));
 	g_return_if_fail(item->canvas != NULL);
 	g_return_if_fail(E_IS_CANVAS(item->canvas));
 
@@ -846,7 +846,7 @@ e_canvas_item_set_cursor (GnomeCanvasItem *item, gpointer id)
 
 	canvas->selection = NULL;
 
-	gnome_canvas_item_grab_focus(item);
+	foo_canvas_item_grab_focus(item);
 
 	info = g_new(ECanvasSelectionInfo, 1);
 	info->item = item;
@@ -865,12 +865,12 @@ e_canvas_item_set_cursor (GnomeCanvasItem *item, gpointer id)
 }
 
 void
-e_canvas_item_set_cursor_end (GnomeCanvasItem *item, gpointer id)
+e_canvas_item_set_cursor_end (FooCanvasItem *item, gpointer id)
 {
 }
 
 void
-e_canvas_item_add_selection (GnomeCanvasItem *item, gpointer id)
+e_canvas_item_add_selection (FooCanvasItem *item, gpointer id)
 {
 	gint flags;
 	ECanvas *canvas;
@@ -879,7 +879,7 @@ e_canvas_item_add_selection (GnomeCanvasItem *item, gpointer id)
 	GList *list;
 
 	g_return_if_fail(item != NULL);
-	g_return_if_fail(GNOME_IS_CANVAS_ITEM(item));
+	g_return_if_fail(FOO_IS_CANVAS_ITEM(item));
 	g_return_if_fail(item->canvas != NULL);
 	g_return_if_fail(E_IS_CANVAS(item->canvas));
 
@@ -893,7 +893,7 @@ e_canvas_item_add_selection (GnomeCanvasItem *item, gpointer id)
 			func(canvas->cursor->item, flags, canvas->cursor->id);
 	}
 
-	gnome_canvas_item_grab_focus(item);
+	foo_canvas_item_grab_focus(item);
 
 	flags = E_CANVAS_ITEM_SELECTION_SELECT | E_CANVAS_ITEM_SELECTION_CURSOR;
 
@@ -933,7 +933,7 @@ e_canvas_item_add_selection (GnomeCanvasItem *item, gpointer id)
 }
 
 void
-e_canvas_item_remove_selection (GnomeCanvasItem *item, gpointer id)
+e_canvas_item_remove_selection (FooCanvasItem *item, gpointer id)
 {
 	gint flags;
 	ECanvas *canvas;
@@ -941,7 +941,7 @@ e_canvas_item_remove_selection (GnomeCanvasItem *item, gpointer id)
 	GList *list;
 
 	g_return_if_fail(item != NULL);
-	g_return_if_fail(GNOME_IS_CANVAS_ITEM(item));
+	g_return_if_fail(FOO_IS_CANVAS_ITEM(item));
 	g_return_if_fail(item->canvas != NULL);
 	g_return_if_fail(E_IS_CANVAS(item->canvas));
 
@@ -1012,7 +1012,7 @@ grab_cancelled_check (gpointer data)
 {
 	ECanvas *canvas = data;
 
-	if (GNOME_CANVAS (canvas)->grabbed_item == NULL) {
+	if (FOO_CANVAS (canvas)->grabbed_item == NULL) {
 		canvas->grab_cancelled_cb = NULL;
 		canvas->grab_cancelled_check_id = 0;
 		canvas->grab_cancelled_time = 0;
@@ -1021,10 +1021,10 @@ grab_cancelled_check (gpointer data)
 	}
 
 	if (gtk_grab_get_current ()) {
-		gnome_canvas_item_ungrab(GNOME_CANVAS (canvas)->grabbed_item, canvas->grab_cancelled_time);
+		foo_canvas_item_ungrab(FOO_CANVAS (canvas)->grabbed_item, canvas->grab_cancelled_time);
 		if (canvas->grab_cancelled_cb) {
 			canvas->grab_cancelled_cb (canvas,
-						   GNOME_CANVAS (canvas)->grabbed_item,
+						   FOO_CANVAS (canvas)->grabbed_item,
 						   canvas->grab_cancelled_data);
 		}
 		canvas->grab_cancelled_cb = NULL;
@@ -1038,7 +1038,7 @@ grab_cancelled_check (gpointer data)
 
 gint
 e_canvas_item_grab (ECanvas *canvas,
-		    GnomeCanvasItem *item,
+		    FooCanvasItem *item,
 		    guint event_mask,
 		    GdkCursor *cursor,
 		    guint32 etime,
@@ -1048,7 +1048,7 @@ e_canvas_item_grab (ECanvas *canvas,
 	if (gtk_grab_get_current ()) {
 		return GDK_GRAB_ALREADY_GRABBED;
 	} else {
-		gint ret_val = gnome_canvas_item_grab (item, event_mask, cursor, etime);
+		gint ret_val = foo_canvas_item_grab (item, event_mask, cursor, etime);
 		if (ret_val == GDK_GRAB_SUCCESS) {
 			canvas->grab_cancelled_cb = cancelled_cb;
 			canvas->grab_cancelled_check_id =
@@ -1067,7 +1067,7 @@ e_canvas_item_grab (ECanvas *canvas,
 
 void
 e_canvas_item_ungrab (ECanvas *canvas,
-		      GnomeCanvasItem *item,
+		      FooCanvasItem *item,
 		      guint32 etime)
 {
 	if (canvas->grab_cancelled_check_id) {
@@ -1076,6 +1076,6 @@ e_canvas_item_ungrab (ECanvas *canvas,
 		canvas->grab_cancelled_check_id = 0;
 		canvas->grab_cancelled_time = 0;
 		canvas->grab_cancelled_data = NULL;
-		gnome_canvas_item_ungrab (item, etime);
+		foo_canvas_item_ungrab (item, etime);
 	}
 }
diff --git a/widgets/misc/e-canvas.h b/widgets/misc/e-canvas.h
index a78824e..ccc7ecc 100644
--- a/widgets/misc/e-canvas.h
+++ b/widgets/misc/e-canvas.h
@@ -24,7 +24,7 @@
 #define __E_CANVAS_H__
 
 #include <gtk/gtk.h>
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 
 G_BEGIN_DECLS
 
@@ -38,14 +38,14 @@ G_BEGIN_DECLS
 #define E_IS_CANVAS(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), E_CANVAS_TYPE))
 #define E_IS_CANVAS_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((obj), E_CANVAS_TYPE))
 
-typedef void		(*ECanvasItemReflowFunc)		(GnomeCanvasItem *item,
+typedef void		(*ECanvasItemReflowFunc)		(FooCanvasItem *item,
 								 gint	  flags);
 
-typedef void            (*ECanvasItemSelectionFunc)             (GnomeCanvasItem *item,
+typedef void            (*ECanvasItemSelectionFunc)             (FooCanvasItem *item,
 								 gint             flags,
 								 gpointer         user_data);
 /* Returns the same as strcmp does. */
-typedef gint            (*ECanvasItemSelectionCompareFunc)      (GnomeCanvasItem *item,
+typedef gint            (*ECanvasItemSelectionCompareFunc)      (FooCanvasItem *item,
 								 gpointer         data1,
 								 gpointer         data2,
 								 gint             flags);
@@ -66,15 +66,15 @@ enum {
 };
 
 typedef struct {
-	GnomeCanvasItem *item;
+	FooCanvasItem *item;
 	gpointer         id;
 } ECanvasSelectionInfo;
 
-typedef void (*ECanvasItemGrabCancelled) (ECanvas *canvas, GnomeCanvasItem *item, gpointer data);
+typedef void (*ECanvasItemGrabCancelled) (ECanvas *canvas, FooCanvasItem *item, gpointer data);
 
 struct _ECanvas
 {
-	GnomeCanvas parent;
+	FooCanvas parent;
 	gint                   idle_id;
 	GList                *selection;
 	ECanvasSelectionInfo *cursor;
@@ -96,7 +96,7 @@ struct _ECanvas
 
 struct _ECanvasClass
 {
-	GnomeCanvasClass parent_class;
+	FooCanvasClass parent_class;
 	void (* reflow) (ECanvas *canvas);
 };
 
@@ -106,36 +106,36 @@ GtkWidget *e_canvas_new                                  (void);
 /* Used to send all of the keystroke events to a specific item as well as
  * GDK_FOCUS_CHANGE events.
  */
-void       e_canvas_item_grab_focus                      (GnomeCanvasItem                 *item,
+void       e_canvas_item_grab_focus                      (FooCanvasItem                 *item,
 							  gboolean                         widget_too);
-void       e_canvas_item_request_reflow                  (GnomeCanvasItem                 *item);
-void       e_canvas_item_request_parent_reflow           (GnomeCanvasItem                 *item);
-void       e_canvas_item_set_reflow_callback             (GnomeCanvasItem                 *item,
+void       e_canvas_item_request_reflow                  (FooCanvasItem                 *item);
+void       e_canvas_item_request_parent_reflow           (FooCanvasItem                 *item);
+void       e_canvas_item_set_reflow_callback             (FooCanvasItem                 *item,
 							  ECanvasItemReflowFunc            func);
-void       e_canvas_item_set_selection_callback          (GnomeCanvasItem                 *item,
+void       e_canvas_item_set_selection_callback          (FooCanvasItem                 *item,
 							  ECanvasItemSelectionFunc         func);
-void       e_canvas_item_set_selection_compare_callback  (GnomeCanvasItem                 *item,
+void       e_canvas_item_set_selection_compare_callback  (FooCanvasItem                 *item,
 							  ECanvasItemSelectionCompareFunc  func);
-void       e_canvas_item_set_cursor                      (GnomeCanvasItem                 *item,
+void       e_canvas_item_set_cursor                      (FooCanvasItem                 *item,
 							  gpointer                         id);
-void       e_canvas_item_add_selection                   (GnomeCanvasItem                 *item,
+void       e_canvas_item_add_selection                   (FooCanvasItem                 *item,
 							  gpointer                         id);
-void       e_canvas_item_remove_selection                (GnomeCanvasItem                 *item,
+void       e_canvas_item_remove_selection                (FooCanvasItem                 *item,
 							  gpointer                         id);
 
 gint        e_canvas_item_grab                            (ECanvas                         *canvas,
-							  GnomeCanvasItem                 *item,
+							  FooCanvasItem                 *item,
 							  guint                            event_mask,
 							  GdkCursor                       *cursor,
 							  guint32                          etime,
 							  ECanvasItemGrabCancelled         cancelled,
 							  gpointer                         cancelled_data);
 void       e_canvas_item_ungrab                          (ECanvas                         *canvas,
-							  GnomeCanvasItem                 *item,
+							  FooCanvasItem                 *item,
 							  guint32                          etime);
 
 /* Not implemented yet. */
-void       e_canvas_item_set_cursor_end                  (GnomeCanvasItem                 *item,
+void       e_canvas_item_set_cursor_end                  (FooCanvasItem                 *item,
 							  gpointer                         id);
 void       e_canvas_popup_tooltip                        (ECanvas                         *canvas,
 							  GtkWidget                       *widget,
diff --git a/widgets/misc/e-dateedit.c b/widgets/misc/e-dateedit.c
index acc4cb3..0cc6d85 100644
--- a/widgets/misc/e-dateedit.c
+++ b/widgets/misc/e-dateedit.c
@@ -663,7 +663,7 @@ create_children			(EDateEdit	*dedit)
 
 	priv->calendar = e_calendar_new ();
 	calendar = E_CALENDAR (priv->calendar);
-	gnome_canvas_item_set (GNOME_CANVAS_ITEM (calendar->calitem),
+	foo_canvas_item_set (FOO_CANVAS_ITEM (calendar->calitem),
 			       "maximum_days_selected", 1,
 			       "move_selection_when_moving", FALSE,
 			       NULL);
@@ -1212,8 +1212,8 @@ e_date_edit_set_week_start_day (EDateEdit *dedit,
 {
 	g_return_if_fail (E_IS_DATE_EDIT (dedit));
 
-	gnome_canvas_item_set (
-		GNOME_CANVAS_ITEM (E_CALENDAR (dedit->priv->calendar)->calitem),
+	foo_canvas_item_set (
+		FOO_CANVAS_ITEM (E_CALENDAR (dedit->priv->calendar)->calitem),
 		"week_start_day", week_start_day, NULL);
 
 	g_object_notify (G_OBJECT (dedit), "week-start-day");
@@ -1240,8 +1240,8 @@ e_date_edit_set_show_week_numbers (EDateEdit *dedit,
 {
 	g_return_if_fail (E_IS_DATE_EDIT (dedit));
 
-	gnome_canvas_item_set (
-		GNOME_CANVAS_ITEM (E_CALENDAR (dedit->priv->calendar)->calitem),
+	foo_canvas_item_set (
+		FOO_CANVAS_ITEM (E_CALENDAR (dedit->priv->calendar)->calitem),
 		"show_week_numbers", show_week_numbers, NULL);
 
 	g_object_notify (G_OBJECT (dedit), "show-week-numbers");
diff --git a/widgets/misc/ea-calendar-cell.c b/widgets/misc/ea-calendar-cell.c
index 8728f49..7353ce9 100644
--- a/widgets/misc/ea-calendar-cell.c
+++ b/widgets/misc/ea-calendar-cell.c
@@ -376,8 +376,8 @@ component_interface_grab_focus (AtkComponent *component)
 	atk_selection_clear_selection (ATK_SELECTION (ea_calitem));
 	atk_selection_add_selection (ATK_SELECTION (ea_calitem), index);
 
-	gtk_widget_grab_focus (GTK_WIDGET (GNOME_CANVAS_ITEM (calitem)->canvas));
-	toplevel = gtk_widget_get_toplevel (GTK_WIDGET (GNOME_CANVAS_ITEM (calitem)->canvas));
+	gtk_widget_grab_focus (GTK_WIDGET (FOO_CANVAS_ITEM (calitem)->canvas));
+	toplevel = gtk_widget_get_toplevel (GTK_WIDGET (FOO_CANVAS_ITEM (calitem)->canvas));
 	if (toplevel && gtk_widget_is_toplevel (toplevel))
 		gtk_window_present (GTK_WINDOW (toplevel));
 
diff --git a/widgets/misc/ea-calendar-item.c b/widgets/misc/ea-calendar-item.c
index 17188ed..cb1eef7 100644
--- a/widgets/misc/ea-calendar-item.c
+++ b/widgets/misc/ea-calendar-item.c
@@ -23,7 +23,7 @@
 #include <stdio.h>
 #include <time.h>
 #include <string.h>
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 #include <glib.h>
 #include <e-util/e-util.h>
 #include <glib/gi18n.h>
@@ -174,7 +174,7 @@ ea_calendar_item_get_type (void)
 		 */
 
 		factory = atk_registry_get_factory (atk_get_default_registry (),
-						    GNOME_TYPE_CANVAS_ITEM);
+						    FOO_TYPE_CANVAS_ITEM);
 		derived_atk_type = atk_object_factory_get_accessible_type (factory);
 		g_type_query (derived_atk_type, &query);
 
@@ -1149,7 +1149,7 @@ e_calendar_item_get_day_extents (ECalendarItem *calitem,
 				 gint *x, gint *y,
 				 gint *width, gint *height)
 {
-	GnomeCanvasItem *item;
+	FooCanvasItem *item;
 	GtkWidget *widget;
 	GtkStyle *style;
 	PangoFontDescription *font_desc;
@@ -1164,7 +1164,7 @@ e_calendar_item_get_day_extents (ECalendarItem *calitem,
 
 	g_return_val_if_fail (E_IS_CALENDAR_ITEM (calitem), FALSE);
 
-	item = GNOME_CANVAS_ITEM (calitem);
+	item = FOO_CANVAS_ITEM (calitem);
 	widget = GTK_WIDGET (item->canvas);
 	style = gtk_widget_get_style (widget);
 
diff --git a/widgets/table/e-cell-checkbox.c b/widgets/table/e-cell-checkbox.c
index b01e6c1..55a1425 100644
--- a/widgets/table/e-cell-checkbox.c
+++ b/widgets/table/e-cell-checkbox.c
@@ -25,7 +25,7 @@
 
 #include <gdk/gdkkeysyms.h>
 #include <gtk/gtk.h>
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 
 #include "e-util/e-util.h"
 
diff --git a/widgets/table/e-cell-combo.c b/widgets/table/e-cell-combo.c
index af79261..f2f15e5 100644
--- a/widgets/table/e-cell-combo.c
+++ b/widgets/table/e-cell-combo.c
@@ -366,7 +366,7 @@ e_cell_combo_get_popup_pos		(ECellCombo	*ecc,
 {
 	ECellPopup *ecp = E_CELL_POPUP (ecc);
 	ETableItem *eti = E_TABLE_ITEM (ecp->popup_cell_view->cell_view.e_table_item_view);
-	GtkWidget *canvas = GTK_WIDGET (GNOME_CANVAS_ITEM (eti)->canvas);
+	GtkWidget *canvas = GTK_WIDGET (FOO_CANVAS_ITEM (eti)->canvas);
 	GtkBin *popwin;
 	GtkScrolledWindow *popup;
 	GtkRequisition list_requisition;
@@ -388,9 +388,9 @@ e_cell_combo_get_popup_pos		(ECellCombo	*ecc,
 						view_col + 1);
 	row_height = e_table_item_row_diff (eti, row,
 					    row + 1);
-	gnome_canvas_item_i2w (GNOME_CANVAS_ITEM (eti), &x1, &y1);
+	foo_canvas_item_i2w (FOO_CANVAS_ITEM (eti), &x1, &y1);
 
-	gnome_canvas_world_to_window (GNOME_CANVAS (canvas),
+	foo_canvas_world_to_window (FOO_CANVAS (canvas),
 				      x1,
 				      y1,
 				      &wx,
@@ -402,8 +402,8 @@ e_cell_combo_get_popup_pos		(ECellCombo	*ecc,
 	*x += x1;
 	/* The ETable positions don't include the grid lines, I think, so we add 1. */
 	*y += y1 + 1
-		- (gint)((GnomeCanvas *)canvas)->layout.vadjustment->value
-		+ ((GnomeCanvas *)canvas)->zoom_yofs;
+		- (gint)((FooCanvas *)canvas)->layout.vadjustment->value
+		+ ((FooCanvas *)canvas)->zoom_yofs;
 
 	scrollbar_width = popup->vscrollbar->requisition.width
 		+ GTK_SCROLLED_WINDOW_CLASS (GTK_OBJECT_GET_CLASS (popup))->scrollbar_spacing;
diff --git a/widgets/table/e-cell-date-edit.c b/widgets/table/e-cell-date-edit.c
index 88b0775..e25540e 100644
--- a/widgets/table/e-cell-date-edit.c
+++ b/widgets/table/e-cell-date-edit.c
@@ -243,7 +243,7 @@ e_cell_date_edit_init (ECellDateEdit *ecde)
         gtk_widget_show (hbox);
 
 	ecde->calendar = e_calendar_new ();
-	gnome_canvas_item_set (GNOME_CANVAS_ITEM (E_CALENDAR (ecde->calendar)->calitem),
+	foo_canvas_item_set (FOO_CANVAS_ITEM (E_CALENDAR (ecde->calendar)->calitem),
 			       "move_selection_when_moving", FALSE,
 			       NULL);
 	gtk_box_pack_start (GTK_BOX (hbox), ecde->calendar, TRUE, TRUE, 0);
@@ -626,7 +626,7 @@ e_cell_date_edit_get_popup_pos		(ECellDateEdit	*ecde,
 {
 	ECellPopup *ecp = E_CELL_POPUP (ecde);
 	ETableItem *eti = E_TABLE_ITEM (ecp->popup_cell_view->cell_view.e_table_item_view);
-	GtkWidget *canvas = GTK_WIDGET (GNOME_CANVAS_ITEM (eti)->canvas);
+	GtkWidget *canvas = GTK_WIDGET (FOO_CANVAS_ITEM (eti)->canvas);
 	GtkRequisition popup_requisition;
 	gint avail_height, screen_width, column_width, row_height;
 	double x1, y1, wx, wy;
@@ -639,9 +639,9 @@ e_cell_date_edit_get_popup_pos		(ECellDateEdit	*ecde,
 						view_col + 1);
 	row_height = e_table_item_row_diff (eti, row,
 					    row + 1);
-	gnome_canvas_item_i2w (GNOME_CANVAS_ITEM (eti), &x1, &y1);
+	foo_canvas_item_i2w (FOO_CANVAS_ITEM (eti), &x1, &y1);
 
-	gnome_canvas_world_to_window (GNOME_CANVAS (canvas),
+	foo_canvas_world_to_window (FOO_CANVAS (canvas),
 				      x1,
 				      y1,
 				      &wx,
@@ -654,8 +654,8 @@ e_cell_date_edit_get_popup_pos		(ECellDateEdit	*ecde,
 	/* The ETable positions don't include the grid lines, I think, so we
 	   add 1. */
 	*y += y1 + 1
-		- (gint)((GnomeCanvas *)canvas)->layout.vadjustment->value
-		+ ((GnomeCanvas *)canvas)->zoom_yofs;
+		- (gint)((FooCanvas *)canvas)->layout.vadjustment->value
+		+ ((FooCanvas *)canvas)->zoom_yofs;
 
 	avail_height = gdk_screen_height () - *y;
 
diff --git a/widgets/table/e-cell-hbox.h b/widgets/table/e-cell-hbox.h
index fda96de..e920e15 100644
--- a/widgets/table/e-cell-hbox.h
+++ b/widgets/table/e-cell-hbox.h
@@ -24,7 +24,7 @@
 #ifndef _E_CELL_HBOX_H_
 #define _E_CELL_HBOX_H_
 
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 #include <table/e-cell.h>
 
 G_BEGIN_DECLS
diff --git a/widgets/table/e-cell-pixbuf.c b/widgets/table/e-cell-pixbuf.c
index 666f556..666aac6 100644
--- a/widgets/table/e-cell-pixbuf.c
+++ b/widgets/table/e-cell-pixbuf.c
@@ -25,7 +25,7 @@
 
 #include <stdio.h>
 
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 
 #include <glib/gi18n.h>
 #include <gtk/gtk.h>
@@ -37,7 +37,7 @@ typedef struct _ECellPixbufView ECellPixbufView;
 
 struct _ECellPixbufView {
 	ECellView cell_view;
-	GnomeCanvas *canvas;
+	FooCanvas *canvas;
 };
 
 /* Object argument IDs */
@@ -80,7 +80,7 @@ pixbuf_new_view (ECell *ecell, ETableModel *table_model, gpointer e_table_item_v
 {
     ECellPixbufView *pixbuf_view = g_new0 (ECellPixbufView, 1);
     ETableItem *eti = E_TABLE_ITEM (e_table_item_view);
-    GnomeCanvas *canvas = GNOME_CANVAS_ITEM (eti)->canvas;
+    FooCanvas *canvas = FOO_CANVAS_ITEM (eti)->canvas;
 
     pixbuf_view->cell_view.ecell = ecell;
     pixbuf_view->cell_view.e_table_model = table_model;
diff --git a/widgets/table/e-cell-popup.c b/widgets/table/e-cell-popup.c
index c4ca572..688f32a 100644
--- a/widgets/table/e-cell-popup.c
+++ b/widgets/table/e-cell-popup.c
@@ -268,7 +268,7 @@ ecp_draw (ECellView *ecv, GdkDrawable *drawable,
 	GdkRectangle rect;
 	gboolean show_popup_arrow;
 
-	canvas = GTK_WIDGET (GNOME_CANVAS_ITEM (ecv->e_table_item_view)->canvas);
+	canvas = GTK_WIDGET (FOO_CANVAS_ITEM (ecv->e_table_item_view)->canvas);
 
 	/* Display the popup arrow if we are the cursor cell, or the popup
 	   is shown for this cell. */
diff --git a/widgets/table/e-cell-popup.h b/widgets/table/e-cell-popup.h
index 4ea1127..e36d231 100644
--- a/widgets/table/e-cell-popup.h
+++ b/widgets/table/e-cell-popup.h
@@ -32,7 +32,7 @@
 #ifndef _E_CELL_POPUP_H_
 #define _E_CELL_POPUP_H_
 
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 #include <table/e-cell.h>
 
 #define E_CELL_POPUP_TYPE        (e_cell_popup_get_type ())
diff --git a/widgets/table/e-cell-text.c b/widgets/table/e-cell-text.c
index dd8aeb9..b73e87c 100644
--- a/widgets/table/e-cell-text.c
+++ b/widgets/table/e-cell-text.c
@@ -19,9 +19,9 @@
  *
  * A lot of code taken from:
  *
- * Text item type for GnomeCanvas widget
+ * Text item type for FooCanvas widget
  *
- * GnomeCanvas is basically a port of the Tk toolkit's most excellent
+ * FooCanvas is basically a port of the Tk toolkit's most excellent
  * canvas widget.  Tk is copyrighted by the Regents of the University
  * of California, Sun Microsystems, and other parties.
  *
@@ -42,8 +42,8 @@
 
 #include <gdk/gdkkeysyms.h>
 #include <gtk/gtk.h>
-#include <libgnomecanvas/gnome-canvas.h>
-#include <libgnomecanvas/gnome-canvas-rect-ellipse.h>
+#include <libfoocanvas/foo-canvas.h>
+#include <libfoocanvas/foo-canvas-rect-ellipse.h>
 
 #include "gal-a11y-e-cell-registry.h"
 #include "gal-a11y-e-cell-text.h"
@@ -128,7 +128,7 @@ typedef struct {
 	GdkCursor *i_cursor;
 	GdkBitmap *stipple;		/* Stipple for text */
 
-	GnomeCanvas *canvas;
+	FooCanvas *canvas;
 
 	/*
 	 * During editing.
@@ -350,7 +350,7 @@ static ECellView *
 ect_new_view (ECell *ecell, ETableModel *table_model, gpointer e_table_item_view)
 {
 	ECellTextView *text_view = g_new0 (ECellTextView, 1);
-	GnomeCanvas *canvas = GNOME_CANVAS_ITEM (e_table_item_view)->canvas;
+	FooCanvas *canvas = FOO_CANVAS_ITEM (e_table_item_view)->canvas;
 
 	text_view->cell_view.ecell = ecell;
 	text_view->cell_view.e_table_model = table_model;
@@ -565,7 +565,7 @@ build_layout (ECellTextView *text_view, gint row, const gchar *text, gint width)
 	PangoContext *context;
 	cairo_font_options_t *font_options;
 
-	layout = gtk_widget_create_pango_layout (GTK_WIDGET (((GnomeCanvasItem *)ecell_view->e_table_item_view)->canvas), text);
+	layout = gtk_widget_create_pango_layout (GTK_WIDGET (((FooCanvasItem *)ecell_view->e_table_item_view)->canvas), text);
 
 	attrs = (PangoAttrList *) build_attr_list (text_view, row, text ? strlen (text) : 0);
 
@@ -596,7 +596,7 @@ build_layout (ECellTextView *text_view, gint row, const gchar *text, gint width)
 			fixed_points = !pango_font_description_get_size_is_absolute (fixed_desc);
 		}
 
-		desc = pango_font_description_copy (gtk_widget_get_style (GTK_WIDGET (((GnomeCanvasItem *)ecell_view->e_table_item_view)->canvas))->font_desc);
+		desc = pango_font_description_copy (gtk_widget_get_style (GTK_WIDGET (((FooCanvasItem *)ecell_view->e_table_item_view)->canvas))->font_desc);
 		pango_font_description_set_family (desc, fixed_family);
 		if (fixed_points)
 			pango_font_description_set_size (desc, fixed_size);
@@ -1489,12 +1489,12 @@ tooltip_event (GtkWidget *window,
 
 	switch (event->type) {
 	case GDK_LEAVE_NOTIFY:
-		e_canvas_hide_tooltip (E_CANVAS(GNOME_CANVAS_ITEM(tooltip->eti)->canvas));
+		e_canvas_hide_tooltip (E_CANVAS(FOO_CANVAS_ITEM(tooltip->eti)->canvas));
 		break;
 	case GDK_BUTTON_PRESS:
 	case GDK_BUTTON_RELEASE:
 		if (event->type == GDK_BUTTON_RELEASE) {
-			e_canvas_hide_tooltip (E_CANVAS(GNOME_CANVAS_ITEM(tooltip->eti)->canvas));
+			e_canvas_hide_tooltip (E_CANVAS(FOO_CANVAS_ITEM(tooltip->eti)->canvas));
 		}
 
 		event->button.x = tooltip->cx;
@@ -1502,15 +1502,15 @@ tooltip_event (GtkWidget *window,
 		g_signal_emit_by_name (tooltip->eti, "event",
 				       event, &ret_val);
 		if (!ret_val)
-			gtk_propagate_event (GTK_WIDGET(GNOME_CANVAS_ITEM(tooltip->eti)->canvas), event);
+			gtk_propagate_event (GTK_WIDGET(FOO_CANVAS_ITEM(tooltip->eti)->canvas), event);
 		ret_val = TRUE;
 		break;
 	case GDK_KEY_PRESS:
-		e_canvas_hide_tooltip (E_CANVAS(GNOME_CANVAS_ITEM(tooltip->eti)->canvas));
+		e_canvas_hide_tooltip (E_CANVAS(FOO_CANVAS_ITEM(tooltip->eti)->canvas));
 		g_signal_emit_by_name (tooltip->eti, "event",
 				       event, &ret_val);
 		if (!ret_val)
-			gtk_propagate_event (GTK_WIDGET(GNOME_CANVAS_ITEM(tooltip->eti)->canvas), event);
+			gtk_propagate_event (GTK_WIDGET(FOO_CANVAS_ITEM(tooltip->eti)->canvas), event);
 		ret_val = TRUE;
 		break;
 	default:
@@ -1534,12 +1534,12 @@ ect_show_tooltip (ECellView *ecell_view,
 	ArtPoint origin = {0, 0};
 	ArtPoint pixel_origin;
 	gint canvas_x, canvas_y;
-	GnomeCanvasItem *tooltip_text;
+	FooCanvasItem *tooltip_text;
 	double tooltip_width;
 	double tooltip_height;
 	double tooltip_x;
 	double tooltip_y;
-	GnomeCanvasItem *rect;
+	FooCanvasItem *rect;
 	ECellText *ect = E_CELL_TEXT(ecell_view->ecell);
 	GtkWidget *window;
 	PangoLayout *layout;
@@ -1554,7 +1554,7 @@ ect_show_tooltip (ECellView *ecell_view,
 		return;
 	}
 
-	gnome_canvas_item_i2c_affine (GNOME_CANVAS_ITEM (tooltip->eti), i2c);
+	foo_canvas_item_i2c_affine (FOO_CANVAS_ITEM (tooltip->eti), i2c);
 	art_affine_point (&pixel_origin, &origin, i2c);
 
 	gdk_window_get_origin (GTK_WIDGET (text_view->canvas)->window,
@@ -1573,8 +1573,8 @@ ect_show_tooltip (ECellView *ecell_view,
 	GTK_WIDGET_UNSET_FLAGS (canvas, GTK_CAN_FOCUS);
 	GTK_WIDGET_UNSET_FLAGS (window, GTK_CAN_FOCUS);
 
-	rect = gnome_canvas_item_new (gnome_canvas_root (GNOME_CANVAS (canvas)),
-				      gnome_canvas_rect_get_type (),
+	rect = foo_canvas_item_new (foo_canvas_root (FOO_CANVAS (canvas)),
+				      foo_canvas_rect_get_type (),
 				      "x1", (double) 0.0,
 				      "y1", (double) 0.0,
 				      "x2", (double) width + 4,
@@ -1582,7 +1582,7 @@ ect_show_tooltip (ECellView *ecell_view,
 				      "fill_color_gdk", tooltip->background,
 				      NULL);
 
-	tooltip_text = gnome_canvas_item_new (gnome_canvas_root (GNOME_CANVAS (canvas)),
+	tooltip_text = foo_canvas_item_new (foo_canvas_root (FOO_CANVAS (canvas)),
 					      e_text_get_type (),
 					      "anchor", GTK_ANCHOR_NW,
 					      "bold", (gboolean) ect->bold_column >= 0 && e_table_model_value_at(ecell_view->e_table_model, ect->bold_column, row),
@@ -1620,14 +1620,14 @@ ect_show_tooltip (ECellView *ecell_view,
 		break;
 	}
 
-	gnome_canvas_item_move (tooltip_text, 3.0, 1.0);
-	gnome_canvas_item_set (rect,
+	foo_canvas_item_move (tooltip_text, 3.0, 1.0);
+	foo_canvas_item_set (rect,
 			       "x2", (double) tooltip_width + 6,
 			       "y2", (double) tooltip->row_height + 1,
 			       NULL);
 	gtk_widget_set_size_request (window, tooltip_width + 6,
 				     tooltip->row_height + 1);
-	gnome_canvas_set_scroll_region (GNOME_CANVAS (canvas), 0.0, 0.0,
+	foo_canvas_set_scroll_region (FOO_CANVAS (canvas), 0.0, 0.0,
 					(double) tooltip_width + 6,
 					(double) tooltip_height);
 	gtk_widget_show (canvas);
@@ -1864,7 +1864,7 @@ e_cell_text_get_cursor_locations (ECellTextView *tv,
 	CellEdit *edit=tv->edit;
 	ECellView *cell_view = (ECellView *)tv;
 	ETableItem *item = E_TABLE_ITEM ((cell_view)->e_table_item_view);
-	GnomeCanvasItem *parent_item = GNOME_CANVAS_ITEM (item)->parent;
+	FooCanvasItem *parent_item = FOO_CANVAS_ITEM (item)->parent;
 	PangoRectangle pango_strong_pos;
 	PangoRectangle pango_weak_pos;
 	gint x, y, col, row;
@@ -1878,9 +1878,9 @@ e_cell_text_get_cursor_locations (ECellTextView *tv,
 	e_table_item_get_cell_geometry (item, &row, &col,
 					&x, &y, NULL, &area.height);
 
-	gnome_canvas_item_get_bounds (GNOME_CANVAS_ITEM (parent_item), &x1, &y1, NULL, NULL);
+	foo_canvas_item_get_bounds (FOO_CANVAS_ITEM (parent_item), &x1, &y1, NULL, NULL);
 
-	gnome_canvas_get_scroll_offsets (GNOME_CANVAS (GNOME_CANVAS_ITEM (parent_item)->canvas), &cx, &cy);
+	foo_canvas_get_scroll_offsets (FOO_CANVAS (FOO_CANVAS_ITEM (parent_item)->canvas), &cx, &cy);
 
 	index = edit->selection_end + edit->preedit_pos;
 
diff --git a/widgets/table/e-cell-text.h b/widgets/table/e-cell-text.h
index 740db82..79c4a6d 100644
--- a/widgets/table/e-cell-text.h
+++ b/widgets/table/e-cell-text.h
@@ -23,9 +23,9 @@
  *
  * A lot of code taken from:
  *
- * Text item type for GnomeCanvas widget
+ * Text item type for FooCanvas widget
  *
- * GnomeCanvas is basically a port of the Tk toolkit's most excellent
+ * FooCanvas is basically a port of the Tk toolkit's most excellent
  * canvas widget.  Tk is copyrighted by the Regents of the University
  * of California, Sun Microsystems, and other parties.
  *
@@ -39,7 +39,7 @@
 #define _E_CELL_TEXT_H_
 
 #include <gtk/gtk.h>
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 #include <table/e-cell.h>
 
 G_BEGIN_DECLS
diff --git a/widgets/table/e-cell-toggle.c b/widgets/table/e-cell-toggle.c
index 4903602..1ded145 100644
--- a/widgets/table/e-cell-toggle.c
+++ b/widgets/table/e-cell-toggle.c
@@ -26,7 +26,7 @@
 
 #include <gdk/gdkkeysyms.h>
 #include <gtk/gtk.h>
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 
 #include "art/empty.xpm"
 
@@ -56,7 +56,7 @@ G_DEFINE_TYPE (ECellToggle, e_cell_toggle, E_CELL_TYPE)
 typedef struct {
 	ECellView cell_view;
 	GdkGC *gc;
-	GnomeCanvas *canvas;
+	FooCanvas *canvas;
 } ECellToggleView;
 
 static void
@@ -142,7 +142,7 @@ cell_toggle_new_view (ECell *ecell,
 {
 	ECellToggleView *toggle_view = g_new0 (ECellToggleView, 1);
 	ETableItem *eti = E_TABLE_ITEM (e_table_item_view);
-	GnomeCanvas *canvas = GNOME_CANVAS_ITEM (eti)->canvas;
+	FooCanvas *canvas = FOO_CANVAS_ITEM (eti)->canvas;
 
 	toggle_view->cell_view.ecell = ecell;
 	toggle_view->cell_view.e_table_model = table_model;
diff --git a/widgets/table/e-cell-toggle.h b/widgets/table/e-cell-toggle.h
index dee110b..223a56b 100644
--- a/widgets/table/e-cell-toggle.h
+++ b/widgets/table/e-cell-toggle.h
@@ -26,7 +26,7 @@
 #ifndef E_CELL_TOGGLE_H
 #define E_CELL_TOGGLE_H
 
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 #include <gdk-pixbuf/gdk-pixbuf.h>
 #include <table/e-cell.h>
 
diff --git a/widgets/table/e-cell-tree.c b/widgets/table/e-cell-tree.c
index 0a1f433..2d872d2 100644
--- a/widgets/table/e-cell-tree.c
+++ b/widgets/table/e-cell-tree.c
@@ -36,7 +36,7 @@
 
 #include <gdk/gdkkeysyms.h>
 #include <gtk/gtk.h>
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 
 #include "gal-a11y-e-cell-registry.h"
 #include "gal-a11y-e-cell-tree.h"
@@ -58,7 +58,7 @@ typedef struct {
 	ECellView   *subcell_view;
 	GdkGC       *gc;
 
-	GnomeCanvas *canvas;
+	FooCanvas *canvas;
 	gboolean retro_look;
 	gboolean prelit;
 	gint animate_timeout;
@@ -126,7 +126,7 @@ ect_new_view (ECell *ecell, ETableModel *table_model, gpointer e_table_item_view
 {
 	ECellTree *ect = E_CELL_TREE (ecell);
 	ECellTreeView *tree_view = g_new0 (ECellTreeView, 1);
-	GnomeCanvas *canvas = GNOME_CANVAS_ITEM (e_table_item_view)->canvas;
+	FooCanvas *canvas = FOO_CANVAS_ITEM (e_table_item_view)->canvas;
 
 	tree_view->cell_view.ecell = ecell;
 	tree_view->cell_view.e_table_model = table_model;
diff --git a/widgets/table/e-cell-tree.h b/widgets/table/e-cell-tree.h
index 465af77..14a5ac0 100644
--- a/widgets/table/e-cell-tree.h
+++ b/widgets/table/e-cell-tree.h
@@ -31,7 +31,7 @@
 #ifndef _E_CELL_TREE_H_
 #define _E_CELL_TREE_H_
 
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 #include <table/e-cell.h>
 
 G_BEGIN_DECLS
diff --git a/widgets/table/e-cell-vbox.h b/widgets/table/e-cell-vbox.h
index 7762e62..1421e58 100644
--- a/widgets/table/e-cell-vbox.h
+++ b/widgets/table/e-cell-vbox.h
@@ -29,7 +29,7 @@
 #ifndef _E_CELL_VBOX_H_
 #define _E_CELL_VBOX_H_
 
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 #include <table/e-cell.h>
 
 G_BEGIN_DECLS
diff --git a/widgets/table/e-table-click-to-add.c b/widgets/table/e-table-click-to-add.c
index c71e10b..ffe7ba8 100644
--- a/widgets/table/e-table-click-to-add.c
+++ b/widgets/table/e-table-click-to-add.c
@@ -24,9 +24,9 @@
 
 #include <gdk/gdkkeysyms.h>
 #include <gtk/gtk.h>
-#include <libgnomecanvas/gnome-canvas.h>
-#include <libgnomecanvas/gnome-canvas-rect-ellipse.h>
-#include <libgnomecanvas/gnome-canvas-util.h>
+#include <libfoocanvas/foo-canvas.h>
+#include <libfoocanvas/foo-canvas-rect-ellipse.h>
+#include <libfoocanvas/foo-canvas-util.h>
 #include <gdk-pixbuf/gdk-pixbuf.h>
 
 #include "gal-a11y-e-table-click-to-add.h"
@@ -51,7 +51,7 @@ static guint etcta_signals [LAST_SIGNAL] = { 0 };
 
 /* workaround for avoiding APi breakage */
 #define etcta_get_type e_table_click_to_add_get_type
-G_DEFINE_TYPE (ETableClickToAdd, etcta, GNOME_TYPE_CANVAS_GROUP)
+G_DEFINE_TYPE (ETableClickToAdd, etcta, FOO_TYPE_CANVAS_GROUP)
 
 enum {
 	PROP_0,
@@ -73,10 +73,10 @@ etcta_cursor_change (GtkObject *object, gint row, gint col, ETableClickToAdd *et
 static void
 etcta_style_set (ETableClickToAdd *etcta, GtkStyle *previous_style)
 {
-	GtkWidget *widget = GTK_WIDGET(GNOME_CANVAS_ITEM(etcta)->canvas);
+	GtkWidget *widget = GTK_WIDGET(FOO_CANVAS_ITEM(etcta)->canvas);
 
 	if (etcta->rect) {
-		gnome_canvas_item_set (etcta->rect,
+		foo_canvas_item_set (etcta->rect,
 					"outline_color_gdk", &widget->style->fg[GTK_STATE_NORMAL],
 					"fill_color_gdk", &widget->style->bg[GTK_STATE_NORMAL],
 					NULL );
@@ -84,7 +84,7 @@ etcta_style_set (ETableClickToAdd *etcta, GtkStyle *previous_style)
 	}
 
 	if (etcta->text)
-		gnome_canvas_item_set (etcta->text,
+		foo_canvas_item_set (etcta->text,
 					"fill_color_gdk", &widget->style->text[GTK_STATE_NORMAL],
 					NULL);
 
@@ -97,7 +97,7 @@ etcta_add_table_header (ETableClickToAdd *etcta, ETableHeader *header)
 	if (etcta->eth)
 		g_object_ref (etcta->eth);
 	if (etcta->row)
-		gnome_canvas_item_set(GNOME_CANVAS_ITEM(etcta->row),
+		foo_canvas_item_set(FOO_CANVAS_ITEM(etcta->row),
 				      "ETableHeader", header,
 				      NULL);
 }
@@ -119,7 +119,7 @@ etcta_add_one (ETableClickToAdd *etcta, ETableModel *one)
 	if (etcta->one)
 		g_object_ref (etcta->one);
 	if (etcta->row)
-		gnome_canvas_item_set(GNOME_CANVAS_ITEM(etcta->row),
+		foo_canvas_item_set(FOO_CANVAS_ITEM(etcta->row),
 				      "ETableModel", one,
 				      NULL);
 	g_object_set(etcta->selection,
@@ -192,10 +192,10 @@ etcta_set_property (GObject *object,
                     const GValue *value,
                     GParamSpec *pspec)
 {
-	GnomeCanvasItem *item;
+	FooCanvasItem *item;
 	ETableClickToAdd *etcta;
 
-	item = GNOME_CANVAS_ITEM (object);
+	item = FOO_CANVAS_ITEM (object);
 	etcta = E_TABLE_CLICK_TO_ADD (object);
 
 	switch (prop_id) {
@@ -214,15 +214,15 @@ etcta_set_property (GObject *object,
 	case PROP_WIDTH:
 		etcta->width = g_value_get_double (value);
 		if (etcta->row)
-			gnome_canvas_item_set(etcta->row,
+			foo_canvas_item_set(etcta->row,
 					      "minimum_width", etcta->width,
 					      NULL);
 		if (etcta->text)
-			gnome_canvas_item_set(etcta->text,
+			foo_canvas_item_set(etcta->text,
 					      "width", etcta->width - 4,
 					      NULL);
 		if (etcta->rect)
-			gnome_canvas_item_set(etcta->rect,
+			foo_canvas_item_set(etcta->rect,
 					      "x2", etcta->width - 1,
 					      NULL);
 		break;
@@ -231,17 +231,17 @@ etcta_set_property (GObject *object,
 		return;
 
 	}
-	gnome_canvas_item_request_update(item);
+	foo_canvas_item_request_update(item);
 }
 
 static void
 create_rect_and_text (ETableClickToAdd *etcta)
 {
-	GtkWidget *widget = GTK_WIDGET (GNOME_CANVAS_ITEM(etcta)->canvas);
+	GtkWidget *widget = GTK_WIDGET (FOO_CANVAS_ITEM(etcta)->canvas);
 
 	if (!etcta->rect)
-		etcta->rect = gnome_canvas_item_new(GNOME_CANVAS_GROUP(etcta),
-					    gnome_canvas_rect_get_type(),
+		etcta->rect = foo_canvas_item_new(FOO_CANVAS_GROUP(etcta),
+					    foo_canvas_rect_get_type(),
 					    "x1", (double) 0,
 					    "y1", (double) 0,
 					    "x2", (double) etcta->width - 1,
@@ -251,7 +251,7 @@ create_rect_and_text (ETableClickToAdd *etcta)
 					    NULL);
 
 	if (!etcta->text)
-		etcta->text = gnome_canvas_item_new(GNOME_CANVAS_GROUP(etcta),
+		etcta->text = foo_canvas_item_new(FOO_CANVAS_GROUP(etcta),
 					    e_text_get_type(),
 					    "text", etcta->message ? etcta->message : "",
 					    "anchor", GTK_ANCHOR_NW,
@@ -291,24 +291,24 @@ etcta_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *p
 }
 
 static void
-etcta_realize (GnomeCanvasItem *item)
+etcta_realize (FooCanvasItem *item)
 {
 	ETableClickToAdd *etcta = E_TABLE_CLICK_TO_ADD (item);
 
 	create_rect_and_text (etcta);
 	e_canvas_item_move_absolute (etcta->text, 2, 2);
 
-	if (GNOME_CANVAS_ITEM_CLASS (etcta_parent_class)->realize)
-		(*GNOME_CANVAS_ITEM_CLASS (etcta_parent_class)->realize)(item);
+	if (FOO_CANVAS_ITEM_CLASS (etcta_parent_class)->realize)
+		(*FOO_CANVAS_ITEM_CLASS (etcta_parent_class)->realize)(item);
 
 	e_canvas_item_request_reflow (item);
 }
 
 static void
-etcta_unrealize (GnomeCanvasItem *item)
+etcta_unrealize (FooCanvasItem *item)
 {
-	if (GNOME_CANVAS_ITEM_CLASS (etcta_parent_class)->unrealize)
-		(*GNOME_CANVAS_ITEM_CLASS (etcta_parent_class)->unrealize)(item);
+	if (FOO_CANVAS_ITEM_CLASS (etcta_parent_class)->unrealize)
+		(*FOO_CANVAS_ITEM_CLASS (etcta_parent_class)->unrealize)(item);
 }
 
 static void finish_editing (ETableClickToAdd *etcta);
@@ -357,7 +357,7 @@ finish_editing (ETableClickToAdd *etcta)
 
 		e_selection_model_clear(E_SELECTION_MODEL(etcta->selection));
 
-		etcta->row = gnome_canvas_item_new(GNOME_CANVAS_GROUP(etcta),
+		etcta->row = foo_canvas_item_new(FOO_CANVAS_GROUP(etcta),
 						   e_table_item_get_type(),
 						   "ETableHeader", etcta->eth,
 						   "ETableModel", etcta->one,
@@ -378,7 +378,7 @@ finish_editing (ETableClickToAdd *etcta)
 /* Handles the events on the ETableClickToAdd, particularly
  * it creates the ETableItem and passes in some events. */
 static gint
-etcta_event (GnomeCanvasItem *item, GdkEvent *e)
+etcta_event (FooCanvasItem *item, GdkEvent *e)
 {
 	ETableClickToAdd *etcta = E_TABLE_CLICK_TO_ADD (item);
 
@@ -405,7 +405,7 @@ etcta_event (GnomeCanvasItem *item, GdkEvent *e)
 
 			e_selection_model_clear(E_SELECTION_MODEL(etcta->selection));
 
-			etcta->row = gnome_canvas_item_new(GNOME_CANVAS_GROUP(item),
+			etcta->row = foo_canvas_item_new(FOO_CANVAS_GROUP(item),
 							   e_table_item_get_type(),
 							   "ETableHeader", etcta->eth,
 							   "ETableModel", etcta->one,
@@ -419,7 +419,7 @@ etcta_event (GnomeCanvasItem *item, GdkEvent *e)
 			g_signal_connect(etcta->row, "key_press",
 					 G_CALLBACK (item_key_press), etcta);
 
-			e_canvas_item_grab_focus (GNOME_CANVAS_ITEM(etcta->row), TRUE);
+			e_canvas_item_grab_focus (FOO_CANVAS_ITEM(etcta->row), TRUE);
 
 			set_initial_selection (etcta);
 		}
@@ -454,7 +454,7 @@ etcta_event (GnomeCanvasItem *item, GdkEvent *e)
 }
 
 static void
-etcta_reflow (GnomeCanvasItem *item, gint flags)
+etcta_reflow (FooCanvasItem *item, gint flags)
 {
 	ETableClickToAdd *etcta = E_TABLE_CLICK_TO_ADD (item);
 
@@ -485,7 +485,7 @@ etcta_reflow (GnomeCanvasItem *item, gint flags)
 static void
 etcta_class_init (ETableClickToAddClass *klass)
 {
-	GnomeCanvasItemClass *item_class = GNOME_CANVAS_ITEM_CLASS(klass);
+	FooCanvasItemClass *item_class = FOO_CANVAS_ITEM_CLASS(klass);
 	GObjectClass *object_class = G_OBJECT_CLASS(klass);
 
 	klass->cursor_change = NULL;
@@ -574,7 +574,7 @@ etcta_init (ETableClickToAdd *etcta)
 	g_signal_connect(etcta->selection, "cursor_changed",
 			 G_CALLBACK (etcta_cursor_change), etcta);
 
-	e_canvas_item_set_reflow_callback (GNOME_CANVAS_ITEM (etcta), etcta_reflow);
+	e_canvas_item_set_reflow_callback (FOO_CANVAS_ITEM (etcta), etcta_reflow);
 
 	/* create its a11y object at this time if accessibility is enabled*/
 	if (atk_get_root () != NULL) {
diff --git a/widgets/table/e-table-click-to-add.h b/widgets/table/e-table-click-to-add.h
index 17ac7f7..581604f 100644
--- a/widgets/table/e-table-click-to-add.h
+++ b/widgets/table/e-table-click-to-add.h
@@ -24,7 +24,7 @@
 #define _E_TABLE_CLICK_TO_ADD_H_
 
 #include <libxml/tree.h>
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 #include <table/e-table-header.h>
 #include <table/e-table-sort-info.h>
 #include <table/e-table-item.h>
@@ -39,7 +39,7 @@ G_BEGIN_DECLS
 #define E_IS_TABLE_CLICK_TO_ADD_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TABLE_CLICK_TO_ADD_TYPE))
 
 typedef struct {
-	GnomeCanvasGroup  parent;
+	FooCanvasGroup  parent;
 
 	ETableModel      *one;    /* The ETableOne. */
 
@@ -48,9 +48,9 @@ typedef struct {
 
 	gchar             *message;
 
-	GnomeCanvasItem  *row;    /* If row is NULL, we're sitting with no data and a "Click here" message. */
-	GnomeCanvasItem  *text;   /* If text is NULL, row shouldn't be. */
-	GnomeCanvasItem  *rect;   /* What the heck.  Why not. */
+	FooCanvasItem  *row;    /* If row is NULL, we're sitting with no data and a "Click here" message. */
+	FooCanvasItem  *text;   /* If text is NULL, row shouldn't be. */
+	FooCanvasItem  *rect;   /* What the heck.  Why not. */
 
 	gdouble           width;
 	gdouble           height;
@@ -59,7 +59,7 @@ typedef struct {
 } ETableClickToAdd;
 
 typedef struct {
-	GnomeCanvasGroupClass parent_class;
+	FooCanvasGroupClass parent_class;
 
 	/*
 	 * signals
diff --git a/widgets/table/e-table-field-chooser-item.c b/widgets/table/e-table-field-chooser-item.c
index 5cd2f9e..6b5ec44 100644
--- a/widgets/table/e-table-field-chooser-item.c
+++ b/widgets/table/e-table-field-chooser-item.c
@@ -25,10 +25,10 @@
 #include <string.h>
 
 #include <gtk/gtk.h>
-#include <libgnomecanvas/gnome-canvas.h>
-#include <libgnomecanvas/gnome-canvas-util.h>
-#include <libgnomecanvas/gnome-canvas-polygon.h>
-#include <libgnomecanvas/gnome-canvas-rect-ellipse.h>
+#include <libfoocanvas/foo-canvas.h>
+#include <libfoocanvas/foo-canvas-util.h>
+#include <libfoocanvas/foo-canvas-polygon.h>
+#include <libfoocanvas/foo-canvas-rect-ellipse.h>
 #include <gdk-pixbuf/gdk-pixbuf.h>
 
 #include <glib/gi18n.h>
@@ -55,7 +55,7 @@ static guint etfci_signals [LAST_SIGNAL] = { 0, };
 
 /* workaround for avoiding API breakage */
 #define etfci_get_type e_table_field_chooser_item_get_type
-G_DEFINE_TYPE (ETableFieldChooserItem, etfci, GNOME_TYPE_CANVAS_ITEM)
+G_DEFINE_TYPE (ETableFieldChooserItem, etfci, FOO_TYPE_CANVAS_ITEM)
 
 static void etfci_drop_table_header (ETableFieldChooserItem *etfci);
 static void etfci_drop_full_header (ETableFieldChooserItem *etfci);
@@ -103,7 +103,7 @@ etfci_find_button (ETableFieldChooserItem *etfci, double loc)
 		ecol = e_table_header_get_column (etfci->combined_header, i);
 		if (ecol->disabled)
 			continue;
-		height += e_table_header_compute_height (ecol, GTK_WIDGET (GNOME_CANVAS_ITEM (etfci)->canvas));
+		height += e_table_header_compute_height (ecol, GTK_WIDGET (FOO_CANVAS_ITEM (etfci)->canvas));
 		if (height > loc)
 			return i;
 	}
@@ -145,7 +145,7 @@ etfci_rebuild_combined (ETableFieldChooserItem *etfci)
 }
 
 static void
-etfci_reflow (GnomeCanvasItem *item, gint flags)
+etfci_reflow (FooCanvasItem *item, gint flags)
 {
 	ETableFieldChooserItem *etfci = E_TABLE_FIELD_CHOOSER_ITEM (item);
 	double old_height;
@@ -164,7 +164,7 @@ etfci_reflow (GnomeCanvasItem *item, gint flags)
 		ecol = e_table_header_get_column (etfci->combined_header, i);
 		if (ecol->disabled)
 			continue;
-		height += e_table_header_compute_height (ecol, GTK_WIDGET (GNOME_CANVAS_ITEM (etfci)->canvas));
+		height += e_table_header_compute_height (ecol, GTK_WIDGET (FOO_CANVAS_ITEM (etfci)->canvas));
 	}
 
 	etfci->height = height;
@@ -172,24 +172,24 @@ etfci_reflow (GnomeCanvasItem *item, gint flags)
 	if (old_height != etfci->height)
 		e_canvas_item_request_parent_reflow(item);
 
-	gnome_canvas_item_request_update(item);
+	foo_canvas_item_request_update(item);
 }
 
 static void
-etfci_update (GnomeCanvasItem *item, double *affine, ArtSVP *clip_path, gint flags)
+etfci_update (FooCanvasItem *item, double *affine, ArtSVP *clip_path, gint flags)
 {
 	ETableFieldChooserItem *etfci = E_TABLE_FIELD_CHOOSER_ITEM (item);
 	double   i2c [6];
 	ArtPoint c1, c2, i1, i2;
 
-	if (GNOME_CANVAS_ITEM_CLASS (etfci_parent_class)->update)
-		(*GNOME_CANVAS_ITEM_CLASS (etfci_parent_class)->update)(item, affine, clip_path, flags);
+	if (FOO_CANVAS_ITEM_CLASS (etfci_parent_class)->update)
+		(*FOO_CANVAS_ITEM_CLASS (etfci_parent_class)->update)(item, affine, clip_path, flags);
 
 	i1.x = i1.y = 0;
 	i2.x = etfci->width;
 	i2.y = etfci->height;
 
-	gnome_canvas_item_i2c_affine (item, i2c);
+	foo_canvas_item_i2c_affine (item, i2c);
 	art_affine_point (&c1, &i1, i2c);
 	art_affine_point (&c2, &i2, i2c);
 
@@ -198,17 +198,17 @@ etfci_update (GnomeCanvasItem *item, double *affine, ArtSVP *clip_path, gint fla
 	     item->x2 != c2.x ||
 	     item->y2 != c2.y)
 		{
-			gnome_canvas_request_redraw (item->canvas, item->x1, item->y1, item->x2, item->y2);
+			foo_canvas_request_redraw (item->canvas, item->x1, item->y1, item->x2, item->y2);
 			item->x1 = c1.x;
 			item->y1 = c1.y;
 			item->x2 = c2.x;
 			item->y2 = c2.y;
 /* FIXME: Group Child bounds !? */
 #if 0
-			gnome_canvas_group_child_bounds (GNOME_CANVAS_GROUP (item->parent), item);
+			foo_canvas_group_child_bounds (FOO_CANVAS_GROUP (item->parent), item);
 #endif
 		}
-	gnome_canvas_request_redraw (item->canvas, item->x1, item->y1, item->x2, item->y2);
+	foo_canvas_request_redraw (item->canvas, item->x1, item->y1, item->x2, item->y2);
 }
 
 static void
@@ -219,7 +219,7 @@ etfci_font_load (ETableFieldChooserItem *etfci)
 	if (etfci->font_desc)
 		pango_font_description_free (etfci->font_desc);
 
-	style = GTK_WIDGET (GNOME_CANVAS_ITEM (etfci)->canvas)->style;
+	style = GTK_WIDGET (FOO_CANVAS_ITEM (etfci)->canvas)->style;
 	etfci->font_desc = pango_font_description_copy (style->font_desc);
 }
 
@@ -243,19 +243,19 @@ etfci_drop_full_header (ETableFieldChooserItem *etfci)
 		g_object_unref (header);
 	etfci->full_header = NULL;
 	etfci->height = 0;
-	e_canvas_item_request_reflow(GNOME_CANVAS_ITEM(etfci));
+	e_canvas_item_request_reflow(FOO_CANVAS_ITEM(etfci));
 }
 
 static void
 full_header_structure_changed (ETableHeader *header, ETableFieldChooserItem *etfci)
 {
-	e_canvas_item_request_reflow(GNOME_CANVAS_ITEM(etfci));
+	e_canvas_item_request_reflow(FOO_CANVAS_ITEM(etfci));
 }
 
 static void
 full_header_dimension_changed (ETableHeader *header, gint col, ETableFieldChooserItem *etfci)
 {
-	e_canvas_item_request_reflow(GNOME_CANVAS_ITEM(etfci));
+	e_canvas_item_request_reflow(FOO_CANVAS_ITEM(etfci));
 }
 
 static void
@@ -270,7 +270,7 @@ etfci_add_full_header (ETableFieldChooserItem *etfci, ETableHeader *header)
 	etfci->full_header_dimension_change_id = g_signal_connect (
 		header, "dimension_change",
 		G_CALLBACK(full_header_dimension_changed), etfci);
-	e_canvas_item_request_reflow(GNOME_CANVAS_ITEM(etfci));
+	e_canvas_item_request_reflow(FOO_CANVAS_ITEM(etfci));
 }
 
 static void
@@ -293,19 +293,19 @@ etfci_drop_table_header (ETableFieldChooserItem *etfci)
 		g_object_unref (header);
 	etfci->header = NULL;
 	etfci->height = 0;
-	e_canvas_item_request_reflow(GNOME_CANVAS_ITEM(etfci));
+	e_canvas_item_request_reflow(FOO_CANVAS_ITEM(etfci));
 }
 
 static void
 table_header_structure_changed (ETableHeader *header, ETableFieldChooserItem *etfci)
 {
-	e_canvas_item_request_reflow(GNOME_CANVAS_ITEM(etfci));
+	e_canvas_item_request_reflow(FOO_CANVAS_ITEM(etfci));
 }
 
 static void
 table_header_dimension_changed (ETableHeader *header, gint col, ETableFieldChooserItem *etfci)
 {
-	e_canvas_item_request_reflow(GNOME_CANVAS_ITEM(etfci));
+	e_canvas_item_request_reflow(FOO_CANVAS_ITEM(etfci));
 }
 
 static void
@@ -320,16 +320,16 @@ etfci_add_table_header (ETableFieldChooserItem *etfci, ETableHeader *header)
 	etfci->table_header_dimension_change_id = g_signal_connect (
 		header, "dimension_change",
 		G_CALLBACK(table_header_dimension_changed), etfci);
-	e_canvas_item_request_reflow(GNOME_CANVAS_ITEM(etfci));
+	e_canvas_item_request_reflow(FOO_CANVAS_ITEM(etfci));
 }
 
 static void
 etfci_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
 {
-	GnomeCanvasItem *item;
+	FooCanvasItem *item;
 	ETableFieldChooserItem *etfci;
 
-	item = GNOME_CANVAS_ITEM (object);
+	item = FOO_CANVAS_ITEM (object);
 	etfci = E_TABLE_FIELD_CHOOSER_ITEM (object);
 
 	switch (prop_id) {
@@ -352,7 +352,7 @@ etfci_set_property (GObject *object, guint prop_id, const GValue *value, GParamS
 
 	case PROP_WIDTH:
 		etfci->width = g_value_get_double (value);
-		gnome_canvas_item_request_update(item);
+		foo_canvas_item_request_update(item);
 		break;
 	}
 }
@@ -409,12 +409,12 @@ etfci_drag_end (GtkWidget      *canvas,
 }
 
 static void
-etfci_realize (GnomeCanvasItem *item)
+etfci_realize (FooCanvasItem *item)
 {
 	ETableFieldChooserItem *etfci = E_TABLE_FIELD_CHOOSER_ITEM (item);
 
-	if (GNOME_CANVAS_ITEM_CLASS (etfci_parent_class)-> realize)
-		(*GNOME_CANVAS_ITEM_CLASS (etfci_parent_class)->realize)(item);
+	if (FOO_CANVAS_ITEM_CLASS (etfci_parent_class)-> realize)
+		(*FOO_CANVAS_ITEM_CLASS (etfci_parent_class)->realize)(item);
 
 	if (!etfci->font_desc)
 		etfci_font_load (etfci);
@@ -425,11 +425,11 @@ etfci_realize (GnomeCanvasItem *item)
 	etfci->drag_data_get_id = g_signal_connect (
 		item->canvas, "drag_data_get",
 		G_CALLBACK (etfci_drag_data_get), etfci);
-	e_canvas_item_request_reflow(GNOME_CANVAS_ITEM(etfci));
+	e_canvas_item_request_reflow(FOO_CANVAS_ITEM(etfci));
 }
 
 static void
-etfci_unrealize (GnomeCanvasItem *item)
+etfci_unrealize (FooCanvasItem *item)
 {
 	ETableFieldChooserItem *etfci = E_TABLE_FIELD_CHOOSER_ITEM (item);
 
@@ -442,15 +442,15 @@ etfci_unrealize (GnomeCanvasItem *item)
 	g_signal_handler_disconnect (item->canvas, etfci->drag_data_get_id);
 	etfci->drag_data_get_id = 0;
 
-	if (GNOME_CANVAS_ITEM_CLASS (etfci_parent_class)->unrealize)
-		(*GNOME_CANVAS_ITEM_CLASS (etfci_parent_class)->unrealize)(item);
+	if (FOO_CANVAS_ITEM_CLASS (etfci_parent_class)->unrealize)
+		(*FOO_CANVAS_ITEM_CLASS (etfci_parent_class)->unrealize)(item);
 }
 
 static void
-etfci_draw (GnomeCanvasItem *item, GdkDrawable *drawable, gint x, gint y, gint width, gint height)
+etfci_draw (FooCanvasItem *item, GdkDrawable *drawable, gint x, gint y, gint width, gint height)
 {
 	ETableFieldChooserItem *etfci = E_TABLE_FIELD_CHOOSER_ITEM (item);
-	GnomeCanvas *canvas = item->canvas;
+	FooCanvas *canvas = item->canvas;
 	gint rows;
 	gint y1, y2;
 	gint row;
@@ -493,8 +493,8 @@ etfci_draw (GnomeCanvasItem *item, GdkDrawable *drawable, gint x, gint y, gint w
 }
 
 static double
-etfci_point (GnomeCanvasItem *item, double x, double y, gint cx, gint cy,
-	    GnomeCanvasItem **actual_item)
+etfci_point (FooCanvasItem *item, double x, double y, gint cx, gint cy,
+	    FooCanvasItem **actual_item)
 {
 	*actual_item = item;
 	return 0.0;
@@ -516,7 +516,7 @@ etfci_maybe_start_drag (ETableFieldChooserItem *etfci, gint x, gint y)
 static void
 etfci_start_drag (ETableFieldChooserItem *etfci, GdkEvent *event, double x, double y)
 {
-	GtkWidget *widget = GTK_WIDGET (GNOME_CANVAS_ITEM (etfci)->canvas);
+	GtkWidget *widget = GTK_WIDGET (FOO_CANVAS_ITEM (etfci)->canvas);
 	GtkTargetList *list;
 	GdkDragContext *context;
 	ETableCol *ecol;
@@ -574,22 +574,22 @@ etfci_start_drag (ETableFieldChooserItem *etfci, GdkEvent *event, double x, doub
  * Handles the events on the ETableFieldChooserItem
  */
 static gint
-etfci_event (GnomeCanvasItem *item, GdkEvent *e)
+etfci_event (FooCanvasItem *item, GdkEvent *e)
 {
 	ETableFieldChooserItem *etfci = E_TABLE_FIELD_CHOOSER_ITEM (item);
-	GnomeCanvas *canvas = item->canvas;
+	FooCanvas *canvas = item->canvas;
 	gint x, y;
 
 	switch (e->type) {
 	case GDK_MOTION_NOTIFY:
-		gnome_canvas_w2c (canvas, e->motion.x, e->motion.y, &x, &y);
+		foo_canvas_w2c (canvas, e->motion.x, e->motion.y, &x, &y);
 
 		if (etfci_maybe_start_drag (etfci, x, y))
 			etfci_start_drag (etfci, e, x, y);
 		break;
 
 	case GDK_BUTTON_PRESS:
-		gnome_canvas_w2c (canvas, e->button.x, e->button.y, &x, &y);
+		foo_canvas_w2c (canvas, e->button.x, e->button.y, &x, &y);
 
 		if (e->button.button == 1) {
 			etfci->click_x = x;
@@ -612,7 +612,7 @@ etfci_event (GnomeCanvasItem *item, GdkEvent *e)
 static void
 etfci_class_init (ETableFieldChooserItemClass *klass)
 {
-	GnomeCanvasItemClass *item_class = GNOME_CANVAS_ITEM_CLASS (klass);
+	FooCanvasItemClass *item_class = FOO_CANVAS_ITEM_CLASS (klass);
 	GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
 	object_class->dispose = etfci_dispose;
@@ -683,6 +683,6 @@ etfci_init (ETableFieldChooserItem *etfci)
 	etfci->maybe_drag = 0;
 	etfci->drag_end_id = 0;
 
-	e_canvas_item_set_reflow_callback(GNOME_CANVAS_ITEM (etfci), etfci_reflow);
+	e_canvas_item_set_reflow_callback(FOO_CANVAS_ITEM (etfci), etfci_reflow);
 }
 
diff --git a/widgets/table/e-table-field-chooser-item.h b/widgets/table/e-table-field-chooser-item.h
index d0cbbd9..1bc435e 100644
--- a/widgets/table/e-table-field-chooser-item.h
+++ b/widgets/table/e-table-field-chooser-item.h
@@ -24,7 +24,7 @@
 #ifndef _E_TABLE_FIELD_CHOOSER_ITEM_H_
 #define _E_TABLE_FIELD_CHOOSER_ITEM_H_
 
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 #include <libxml/tree.h>
 #include <table/e-table-header.h>
 
@@ -37,7 +37,7 @@ G_BEGIN_DECLS
 #define E_IS_TABLE_FIELD_CHOOSER_ITEM_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TABLE_FIELD_CHOOSER_ITEM_TYPE))
 
 typedef struct {
-	GnomeCanvasItem  parent;
+	FooCanvasItem  parent;
 	ETableHeader    *full_header;
 	ETableHeader    *header;
 	ETableHeader    *combined_header;
@@ -65,7 +65,7 @@ typedef struct {
 } ETableFieldChooserItem;
 
 typedef struct {
-	GnomeCanvasItemClass parent_class;
+	FooCanvasItemClass parent_class;
 } ETableFieldChooserItemClass;
 
 GType      e_table_field_chooser_item_get_type (void);
diff --git a/widgets/table/e-table-field-chooser.c b/widgets/table/e-table-field-chooser.c
index 8d6ddb5..4d0959f 100644
--- a/widgets/table/e-table-field-chooser.c
+++ b/widgets/table/e-table-field-chooser.c
@@ -23,7 +23,7 @@
 #include <config.h>
 
 #include <gtk/gtk.h>
-#include <libgnomecanvas/gnome-canvas-rect-ellipse.h>
+#include <libfoocanvas/foo-canvas-rect-ellipse.h>
 
 #include <glib/gi18n.h>
 #include "e-util/e-util.h"
@@ -103,22 +103,22 @@ static void allocate_callback(GtkWidget *canvas, GtkAllocation *allocation, ETab
 {
 	double height;
 	etfc->last_alloc = *allocation;
-	gnome_canvas_item_set( etfc->item,
+	foo_canvas_item_set( etfc->item,
 			       "width", (double) allocation->width,
 			       NULL );
 	g_object_get(etfc->item,
 		     "height", &height,
 		     NULL);
 	height = MAX(height, allocation->height);
-	gnome_canvas_set_scroll_region(GNOME_CANVAS( etfc->canvas ), 0, 0, allocation->width - 1, height - 1);
-	gnome_canvas_item_set( etfc->rect,
+	foo_canvas_set_scroll_region(FOO_CANVAS( etfc->canvas ), 0, 0, allocation->width - 1, height - 1);
+	foo_canvas_item_set( etfc->rect,
 			       "x2", (double) allocation->width,
 			       "y2", (double) height,
 			       NULL );
 	ensure_nonzero_step_increments (etfc);
 }
 
-static void resize(GnomeCanvas *canvas, ETableFieldChooser *etfc)
+static void resize(FooCanvas *canvas, ETableFieldChooser *etfc)
 {
 	double height;
 	g_object_get(etfc->item,
@@ -127,8 +127,8 @@ static void resize(GnomeCanvas *canvas, ETableFieldChooser *etfc)
 
 	height = MAX(height, etfc->last_alloc.height);
 
-	gnome_canvas_set_scroll_region (GNOME_CANVAS(etfc->canvas), 0, 0, etfc->last_alloc.width - 1, height - 1);
-	gnome_canvas_item_set( etfc->rect,
+	foo_canvas_set_scroll_region (FOO_CANVAS(etfc->canvas), 0, 0, etfc->last_alloc.width - 1, height - 1);
+	foo_canvas_item_set( etfc->rect,
 			       "x2", (double) etfc->last_alloc.width,
 			       "y2", (double) height,
 			       NULL );
@@ -136,7 +136,7 @@ static void resize(GnomeCanvas *canvas, ETableFieldChooser *etfc)
 }
 
 static GtkWidget *
-create_content (GnomeCanvas **canvas)
+create_content (FooCanvas **canvas)
 {
 	GtkWidget *vbox_top;
 	GtkWidget *label1;
@@ -165,7 +165,7 @@ create_content (GnomeCanvas **canvas)
 	GTK_WIDGET_UNSET_FLAGS (canvas_buttons, GTK_CAN_FOCUS);
 	GTK_WIDGET_UNSET_FLAGS (canvas_buttons, GTK_CAN_DEFAULT);
 
-	*canvas = GNOME_CANVAS (canvas_buttons);
+	*canvas = FOO_CANVAS (canvas_buttons);
 
 	return vbox_top;
 }
@@ -185,8 +185,8 @@ e_table_field_chooser_init (ETableFieldChooser *etfc)
 
 	gtk_widget_push_colormap (gdk_rgb_get_colormap ());
 
-	etfc->rect = gnome_canvas_item_new(gnome_canvas_root( GNOME_CANVAS( etfc->canvas ) ),
-					   gnome_canvas_rect_get_type(),
+	etfc->rect = foo_canvas_item_new(foo_canvas_root( FOO_CANVAS( etfc->canvas ) ),
+					   foo_canvas_rect_get_type(),
 					   "x1", (double) 0,
 					   "y1", (double) 0,
 					   "x2", (double) 100,
@@ -194,7 +194,7 @@ e_table_field_chooser_init (ETableFieldChooser *etfc)
 					   "fill_color", "white",
 					   NULL );
 
-	etfc->item = gnome_canvas_item_new(gnome_canvas_root(etfc->canvas),
+	etfc->item = foo_canvas_item_new(foo_canvas_root(etfc->canvas),
 					   e_table_field_chooser_item_get_type(),
 					   "width", (double) 100,
 					   "full_header", etfc->full_header,
@@ -206,7 +206,7 @@ e_table_field_chooser_init (ETableFieldChooser *etfc)
 			  G_CALLBACK ( resize ),
 			  etfc);
 
-	gnome_canvas_set_scroll_region ( GNOME_CANVAS( etfc->canvas ),
+	foo_canvas_set_scroll_region ( FOO_CANVAS( etfc->canvas ),
 					 0, 0,
 					 100, 100 );
 
diff --git a/widgets/table/e-table-field-chooser.h b/widgets/table/e-table-field-chooser.h
index 9d890de..0967ae7 100644
--- a/widgets/table/e-table-field-chooser.h
+++ b/widgets/table/e-table-field-chooser.h
@@ -51,10 +51,10 @@ struct _ETableFieldChooser
 	GtkVBox parent;
 
 	/* item specific fields */
-	GnomeCanvas *canvas;
-	GnomeCanvasItem *item;
+	FooCanvas *canvas;
+	FooCanvasItem *item;
 
-	GnomeCanvasItem *rect;
+	FooCanvasItem *rect;
 	GtkAllocation last_alloc;
 
 	gchar *dnd_code;
diff --git a/widgets/table/e-table-group-container.c b/widgets/table/e-table-group-container.c
index 43513dd..6b5912a 100644
--- a/widgets/table/e-table-group-container.c
+++ b/widgets/table/e-table-group-container.c
@@ -24,7 +24,7 @@
 
 #include <gtk/gtk.h>
 #include <gdk/gdkkeysyms.h>
-#include <libgnomecanvas/gnome-canvas-rect-ellipse.h>
+#include <libfoocanvas/foo-canvas-rect-ellipse.h>
 
 #include "text/e-text.h"
 #include <glib/gi18n.h>
@@ -127,7 +127,7 @@ etgc_dispose (GObject *object)
 
 /**
  * e_table_group_container_construct
- * @parent: The %GnomeCanvasGroup to create a child of.
+ * @parent: The %FooCanvasGroup to create a child of.
  * @etgc: The %ETableGroupContainer.
  * @full_header: The full header of the %ETable.
  * @header: The current header of the %ETable.
@@ -138,7 +138,7 @@ etgc_dispose (GObject *object)
  * This routine constructs the new %ETableGroupContainer.
  */
 void
-e_table_group_container_construct (GnomeCanvasGroup *parent, ETableGroupContainer *etgc,
+e_table_group_container_construct (FooCanvasGroup *parent, ETableGroupContainer *etgc,
 				   ETableHeader *full_header,
 				   ETableHeader     *header,
 				   ETableModel *model, ETableSortInfo *sort_info, gint n)
@@ -159,7 +159,7 @@ e_table_group_container_construct (GnomeCanvasGroup *parent, ETableGroupContaine
 	etgc->n = n;
 	etgc->ascending = column.ascending;
 
-	style = GTK_WIDGET (GNOME_CANVAS_ITEM (etgc)->canvas)->style;
+	style = GTK_WIDGET (FOO_CANVAS_ITEM (etgc)->canvas)->style;
 	etgc->font_desc = pango_font_description_copy (style->font_desc);
 
 	etgc->open = TRUE;
@@ -167,7 +167,7 @@ e_table_group_container_construct (GnomeCanvasGroup *parent, ETableGroupContaine
 
 /**
  * e_table_group_container_new
- * @parent: The %GnomeCanvasGroup to create a child of.
+ * @parent: The %FooCanvasGroup to create a child of.
  * @full_header: The full header of the %ETable.
  * @header: The current header of the %ETable.
  * @model: The %ETableModel of the %ETable.
@@ -181,7 +181,7 @@ e_table_group_container_construct (GnomeCanvasGroup *parent, ETableGroupContaine
  * Returns: The new %ETableGroupContainer.
  */
 ETableGroup *
-e_table_group_container_new (GnomeCanvasGroup *parent, ETableHeader *full_header,
+e_table_group_container_new (FooCanvasGroup *parent, ETableHeader *full_header,
 			     ETableHeader     *header,
 			     ETableModel *model, ETableSortInfo *sort_info, gint n)
 {
@@ -197,7 +197,7 @@ e_table_group_container_new (GnomeCanvasGroup *parent, ETableHeader *full_header
 }
 
 static gint
-etgc_event (GnomeCanvasItem *item, GdkEvent *event)
+etgc_event (FooCanvasItem *item, GdkEvent *event)
 {
 	ETableGroupContainer *etgc = E_TABLE_GROUP_CONTAINER(item);
 	gboolean return_val = TRUE;
@@ -303,8 +303,8 @@ etgc_event (GnomeCanvasItem *item, GdkEvent *event)
 		break;
 	}
 	if (return_val == FALSE) {
-		if (GNOME_CANVAS_ITEM_CLASS(etgc_parent_class)->event)
-			return GNOME_CANVAS_ITEM_CLASS (etgc_parent_class)->event (item, event);
+		if (FOO_CANVAS_ITEM_CLASS(etgc_parent_class)->event)
+			return FOO_CANVAS_ITEM_CLASS (etgc_parent_class)->event (item, event);
 	}
 	return return_val;
 
@@ -312,24 +312,24 @@ etgc_event (GnomeCanvasItem *item, GdkEvent *event)
 
 /* Realize handler for the text item */
 static void
-etgc_realize (GnomeCanvasItem *item)
+etgc_realize (FooCanvasItem *item)
 {
 	ETableGroupContainer *etgc;
 
-	if (GNOME_CANVAS_ITEM_CLASS (etgc_parent_class)->realize)
-		(* GNOME_CANVAS_ITEM_CLASS (etgc_parent_class)->realize) (item);
+	if (FOO_CANVAS_ITEM_CLASS (etgc_parent_class)->realize)
+		(* FOO_CANVAS_ITEM_CLASS (etgc_parent_class)->realize) (item);
 
 	etgc = E_TABLE_GROUP_CONTAINER (item);
 
-	e_canvas_item_request_reflow (GNOME_CANVAS_ITEM (etgc));
+	e_canvas_item_request_reflow (FOO_CANVAS_ITEM (etgc));
 }
 
 /* Unrealize handler for the etgc item */
 static void
-etgc_unrealize (GnomeCanvasItem *item)
+etgc_unrealize (FooCanvasItem *item)
 {
-	if (GNOME_CANVAS_ITEM_CLASS (etgc_parent_class)->unrealize)
-		(* GNOME_CANVAS_ITEM_CLASS (etgc_parent_class)->unrealize) (item);
+	if (FOO_CANVAS_ITEM_CLASS (etgc_parent_class)->unrealize)
+		(* FOO_CANVAS_ITEM_CLASS (etgc_parent_class)->unrealize) (item);
 }
 
 static void
@@ -350,7 +350,7 @@ compute_text (ETableGroupContainer *etgc, ETableGroupContainerChildNode *child_n
 					child_node->string,
 					(gint) child_node->count);
 	}
-	gnome_canvas_item_set (child_node->text,
+	foo_canvas_item_set (child_node->text,
 			       "text", text,
 			       NULL);
 	g_free (text);
@@ -413,20 +413,20 @@ create_child_node (ETableGroupContainer *etgc, gpointer val)
 	ETableGroup *etg = E_TABLE_GROUP(etgc);
 
 	child_node = g_new (ETableGroupContainerChildNode, 1);
-	child_node->rect = gnome_canvas_item_new (GNOME_CANVAS_GROUP (etgc),
-						  gnome_canvas_rect_get_type (),
+	child_node->rect = foo_canvas_item_new (FOO_CANVAS_GROUP (etgc),
+						  foo_canvas_rect_get_type (),
 						  "fill_color", "grey70",
 						  "outline_color", "grey50",
 						  NULL);
-	child_node->text = gnome_canvas_item_new (GNOME_CANVAS_GROUP (etgc),
+	child_node->text = foo_canvas_item_new (FOO_CANVAS_GROUP (etgc),
 						  e_text_get_type (),
 						  "anchor", GTK_ANCHOR_SW,
 						  "fill_color", "black",
 						  "draw_background", FALSE,
 						  NULL);
-	child = e_table_group_new (GNOME_CANVAS_GROUP (etgc), etg->full_header,
+	child = e_table_group_new (FOO_CANVAS_GROUP (etgc), etg->full_header,
 				   etg->header, etg->model, etgc->sort_info, etgc->n + 1);
-	gnome_canvas_item_set(GNOME_CANVAS_ITEM(child),
+	foo_canvas_item_set(FOO_CANVAS_ITEM(child),
 			      "alternating_row_colors", etgc->alternating_row_colors,
 			      "horizontal_draw_grid", etgc->horizontal_draw_grid,
 			      "vertical_draw_grid", etgc->vertical_draw_grid,
@@ -498,7 +498,7 @@ etgc_add (ETableGroup *etg, gint row)
 		etgc->children = g_list_append (etgc->children, child_node);
 
 	compute_text (etgc, child_node);
-	e_canvas_item_request_reflow (GNOME_CANVAS_ITEM (etgc));
+	e_canvas_item_request_reflow (FOO_CANVAS_ITEM (etgc));
 }
 
 static void
@@ -548,7 +548,7 @@ etgc_add_array (ETableGroup *etg, const gint *array, gint count)
 	etgc->children = g_list_append (etgc->children, child_node);
 	compute_text (etgc, child_node);
 
-	e_canvas_item_request_reflow (GNOME_CANVAS_ITEM (etgc));
+	e_canvas_item_request_reflow (FOO_CANVAS_ITEM (etgc));
 }
 
 static void
@@ -583,7 +583,7 @@ etgc_remove (ETableGroup *etg, gint row)
 			} else
 				compute_text (etgc, child_node);
 
-			e_canvas_item_request_reflow (GNOME_CANVAS_ITEM (etgc));
+			e_canvas_item_request_reflow (FOO_CANVAS_ITEM (etgc));
 
 			return TRUE;
 		}
@@ -745,7 +745,7 @@ etgc_get_cell_geometry (ETableGroup *etg, gint *row, gint *col, gint *x, gint *y
 
 static void etgc_thaw (ETableGroup *etg)
 {
-	e_canvas_item_request_reflow (GNOME_CANVAS_ITEM(etg));
+	e_canvas_item_request_reflow (FOO_CANVAS_ITEM(etg));
 }
 
 static void
@@ -893,7 +893,7 @@ etgc_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *ps
 static void
 etgc_class_init (ETableGroupContainerClass *klass)
 {
-	GnomeCanvasItemClass *item_class = GNOME_CANVAS_ITEM_CLASS (klass);
+	FooCanvasItemClass *item_class = FOO_CANVAS_ITEM_CLASS (klass);
 	GObjectClass *object_class = G_OBJECT_CLASS (klass);
 	ETableGroupClass *e_group_class = E_TABLE_GROUP_CLASS (klass);
 
@@ -1005,7 +1005,7 @@ etgc_class_init (ETableGroupContainerClass *klass)
 }
 
 static void
-etgc_reflow (GnomeCanvasItem *item, gint flags)
+etgc_reflow (FooCanvasItem *item, gint flags)
 {
 	ETableGroupContainer *etgc = E_TABLE_GROUP_CONTAINER(item);
 	gboolean frozen;
@@ -1017,7 +1017,7 @@ etgc_reflow (GnomeCanvasItem *item, gint flags)
 	if (frozen)
 		return;
 
-	if (GTK_OBJECT_FLAGS(etgc)& GNOME_CANVAS_ITEM_REALIZED) {
+	if (GTK_OBJECT_FLAGS(etgc)& FOO_CANVAS_ITEM_REALIZED) {
 		gdouble running_height = 0;
 		gdouble running_width = 0;
 		gdouble old_height;
@@ -1067,15 +1067,15 @@ etgc_reflow (GnomeCanvasItem *item, gint flags)
 					      "height", &item_height,
 					      NULL);
 
-				e_canvas_item_move_absolute (GNOME_CANVAS_ITEM(child_node->text),
+				e_canvas_item_move_absolute (FOO_CANVAS_ITEM(child_node->text),
 							    GROUP_INDENT,
 							    running_height - BUTTON_PADDING);
 
-				e_canvas_item_move_absolute (GNOME_CANVAS_ITEM(child),
+				e_canvas_item_move_absolute (FOO_CANVAS_ITEM(child),
 							    GROUP_INDENT,
 							    running_height);
 
-				gnome_canvas_item_set (GNOME_CANVAS_ITEM(child_node->rect),
+				foo_canvas_item_set (FOO_CANVAS_ITEM(child_node->rect),
 						      "x1", (double) 0,
 						      "x2", (double) running_width + GROUP_INDENT,
 						      "y1", (double) running_height - extra_height,
@@ -1099,7 +1099,7 @@ etgc_init (ETableGroupContainer *container)
 {
 	container->children = NULL;
 
-	e_canvas_item_set_reflow_callback (GNOME_CANVAS_ITEM(container), etgc_reflow);
+	e_canvas_item_set_reflow_callback (FOO_CANVAS_ITEM(container), etgc_reflow);
 
 	container->alternating_row_colors = 1;
 	container->horizontal_draw_grid = 1;
diff --git a/widgets/table/e-table-group-container.h b/widgets/table/e-table-group-container.h
index 911b7f3..4215dbb 100644
--- a/widgets/table/e-table-group-container.h
+++ b/widgets/table/e-table-group-container.h
@@ -24,7 +24,7 @@
 #ifndef _E_TABLE_GROUP_CONTAINER_H_
 #define _E_TABLE_GROUP_CONTAINER_H_
 
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 #include <table/e-table-model.h>
 #include <table/e-table-header.h>
 #include <table/e-table-group.h>
@@ -55,7 +55,7 @@ typedef struct {
 	/*
 	 * The canvas rectangle that contains the children
 	 */
-	GnomeCanvasItem *rect;
+	FooCanvasItem *rect;
 
 	PangoFontDescription *font_desc;
 
@@ -88,14 +88,14 @@ typedef struct {
         ETableGroup *child;
         gpointer key;
         gchar *string;
-        GnomeCanvasItem *text;
-        GnomeCanvasItem *rect;
+        FooCanvasItem *text;
+        FooCanvasItem *rect;
         gint count;
 } ETableGroupContainerChildNode;
 
-ETableGroup *e_table_group_container_new       (GnomeCanvasGroup *parent, ETableHeader *full_header, ETableHeader     *header,
+ETableGroup *e_table_group_container_new       (FooCanvasGroup *parent, ETableHeader *full_header, ETableHeader     *header,
 						ETableModel *model, ETableSortInfo *sort_info, gint n);
-void         e_table_group_container_construct (GnomeCanvasGroup *parent, ETableGroupContainer *etgc,
+void         e_table_group_container_construct (FooCanvasGroup *parent, ETableGroupContainer *etgc,
 						ETableHeader *full_header,
 						ETableHeader     *header,
 						ETableModel *model, ETableSortInfo *sort_info, gint n);
diff --git a/widgets/table/e-table-group-leaf.c b/widgets/table/e-table-group-leaf.c
index 61d357a..6b8a94a 100644
--- a/widgets/table/e-table-group-leaf.c
+++ b/widgets/table/e-table-group-leaf.c
@@ -24,7 +24,7 @@
 #include <config.h>
 
 #include <gtk/gtk.h>
-#include <libgnomecanvas/gnome-canvas-rect-ellipse.h>
+#include <libfoocanvas/foo-canvas-rect-ellipse.h>
 
 #include <glib/gi18n.h>
 #include "e-util/e-util.h"
@@ -111,7 +111,7 @@ etgl_dispose (GObject *object)
 }
 
 static void
-e_table_group_leaf_construct (GnomeCanvasGroup *parent,
+e_table_group_leaf_construct (FooCanvasGroup *parent,
 			      ETableGroupLeaf  *etgl,
 			      ETableHeader     *full_header,
 			      ETableHeader     *header,
@@ -134,7 +134,7 @@ e_table_group_leaf_construct (GnomeCanvasGroup *parent,
 
 /**
  * e_table_group_leaf_new
- * @parent: The %GnomeCanvasGroup to create a child of.
+ * @parent: The %FooCanvasGroup to create a child of.
  * @full_header: The full header of the %ETable.
  * @header: The current header of the %ETable.
  * @model: The %ETableModel of the %ETable.
@@ -146,7 +146,7 @@ e_table_group_leaf_construct (GnomeCanvasGroup *parent,
  * Returns: The new %ETableGroupLeaf.
  */
 ETableGroup *
-e_table_group_leaf_new       (GnomeCanvasGroup *parent,
+e_table_group_leaf_new       (FooCanvasGroup *parent,
 			      ETableHeader     *full_header,
 			      ETableHeader     *header,
 			      ETableModel      *model,
@@ -231,7 +231,7 @@ etgl_click (GtkObject *object, gint row, gint col, GdkEvent *event, ETableGroupL
 }
 
 static void
-etgl_reflow (GnomeCanvasItem *item, gint flags)
+etgl_reflow (FooCanvasItem *item, gint flags)
 {
 	ETableGroupLeaf *leaf = E_TABLE_GROUP_LEAF(item);
 
@@ -246,15 +246,15 @@ etgl_reflow (GnomeCanvasItem *item, gint flags)
 }
 
 static void
-etgl_realize (GnomeCanvasItem *item)
+etgl_realize (FooCanvasItem *item)
 {
 	ETableGroupLeaf *etgl = E_TABLE_GROUP_LEAF(item);
 
-	if (GNOME_CANVAS_ITEM_CLASS (etgl_parent_class)->realize)
-		GNOME_CANVAS_ITEM_CLASS (etgl_parent_class)->realize (item);
+	if (FOO_CANVAS_ITEM_CLASS (etgl_parent_class)->realize)
+		FOO_CANVAS_ITEM_CLASS (etgl_parent_class)->realize (item);
 
-	etgl->item = E_TABLE_ITEM(gnome_canvas_item_new (
-		GNOME_CANVAS_GROUP(etgl),
+	etgl->item = E_TABLE_ITEM(foo_canvas_item_new (
+		FOO_CANVAS_GROUP(etgl),
 		e_table_item_get_type (),
 		"ETableHeader", E_TABLE_GROUP(etgl)->header,
 		"ETableModel", etgl->ets,
@@ -442,7 +442,7 @@ etgl_set_property (GObject *object, guint prop_id, const GValue *value, GParamSp
 	case PROP_WIDTH:
 		etgl->minimum_width = g_value_get_double (value);
 		if (etgl->item) {
-			gnome_canvas_item_set (GNOME_CANVAS_ITEM(etgl->item),
+			foo_canvas_item_set (FOO_CANVAS_ITEM(etgl->item),
 					       "minimum_width", etgl->minimum_width,
 					       NULL);
 		}
@@ -450,7 +450,7 @@ etgl_set_property (GObject *object, guint prop_id, const GValue *value, GParamSp
 	case PROP_LENGTH_THRESHOLD:
 		etgl->length_threshold = g_value_get_int (value);
 		if (etgl->item) {
-			gnome_canvas_item_set (GNOME_CANVAS_ITEM(etgl->item),
+			foo_canvas_item_set (FOO_CANVAS_ITEM(etgl->item),
 					       "length_threshold", etgl->length_threshold,
 					       NULL);
 		}
@@ -463,7 +463,7 @@ etgl_set_property (GObject *object, guint prop_id, const GValue *value, GParamSp
 			g_object_ref(etgl->selection_model);
 		}
 		if (etgl->item) {
-			gnome_canvas_item_set (GNOME_CANVAS_ITEM(etgl->item),
+			foo_canvas_item_set (FOO_CANVAS_ITEM(etgl->item),
 					       "selection_model", etgl->selection_model,
 					       NULL);
 		}
@@ -472,7 +472,7 @@ etgl_set_property (GObject *object, guint prop_id, const GValue *value, GParamSp
 	case PROP_UNIFORM_ROW_HEIGHT:
 		etgl->uniform_row_height = g_value_get_boolean (value);
 		if (etgl->item) {
-			gnome_canvas_item_set (GNOME_CANVAS_ITEM(etgl->item),
+			foo_canvas_item_set (FOO_CANVAS_ITEM(etgl->item),
 					       "uniform_row_height", etgl->uniform_row_height,
 					       NULL);
 		}
@@ -481,7 +481,7 @@ etgl_set_property (GObject *object, guint prop_id, const GValue *value, GParamSp
 	case PROP_TABLE_ALTERNATING_ROW_COLORS:
 		etgl->alternating_row_colors = g_value_get_boolean (value);
 		if (etgl->item) {
-			gnome_canvas_item_set (GNOME_CANVAS_ITEM(etgl->item),
+			foo_canvas_item_set (FOO_CANVAS_ITEM(etgl->item),
 					       "alternating_row_colors", etgl->alternating_row_colors,
 					       NULL);
 		}
@@ -490,7 +490,7 @@ etgl_set_property (GObject *object, guint prop_id, const GValue *value, GParamSp
 	case PROP_TABLE_HORIZONTAL_DRAW_GRID:
 		etgl->horizontal_draw_grid = g_value_get_boolean (value);
 		if (etgl->item) {
-			gnome_canvas_item_set (GNOME_CANVAS_ITEM(etgl->item),
+			foo_canvas_item_set (FOO_CANVAS_ITEM(etgl->item),
 					       "horizontal_draw_grid", etgl->horizontal_draw_grid,
 					       NULL);
 		}
@@ -499,7 +499,7 @@ etgl_set_property (GObject *object, guint prop_id, const GValue *value, GParamSp
 	case PROP_TABLE_VERTICAL_DRAW_GRID:
 		etgl->vertical_draw_grid = g_value_get_boolean (value);
 		if (etgl->item) {
-			gnome_canvas_item_set (GNOME_CANVAS_ITEM(etgl->item),
+			foo_canvas_item_set (FOO_CANVAS_ITEM(etgl->item),
 					       "vertical_draw_grid", etgl->vertical_draw_grid,
 					       NULL);
 		}
@@ -508,7 +508,7 @@ etgl_set_property (GObject *object, guint prop_id, const GValue *value, GParamSp
 	case PROP_TABLE_DRAW_FOCUS:
 		etgl->draw_focus = g_value_get_boolean (value);
 		if (etgl->item) {
-			gnome_canvas_item_set (GNOME_CANVAS_ITEM(etgl->item),
+			foo_canvas_item_set (FOO_CANVAS_ITEM(etgl->item),
 					       "drawfocus", etgl->draw_focus,
 					       NULL);
 		}
@@ -517,7 +517,7 @@ etgl_set_property (GObject *object, guint prop_id, const GValue *value, GParamSp
 	case PROP_CURSOR_MODE:
 		etgl->cursor_mode = g_value_get_int (value);
 		if (etgl->item) {
-			gnome_canvas_item_set (GNOME_CANVAS_ITEM(etgl->item),
+			foo_canvas_item_set (FOO_CANVAS_ITEM(etgl->item),
 					       "cursor_mode", etgl->cursor_mode,
 					       NULL);
 		}
@@ -557,7 +557,7 @@ etgl_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *ps
 static void
 etgl_class_init (ETableGroupLeafClass *klass)
 {
-	GnomeCanvasItemClass *item_class = GNOME_CANVAS_ITEM_CLASS (klass);
+	FooCanvasItemClass *item_class = FOO_CANVAS_ITEM_CLASS (klass);
 	ETableGroupClass *e_group_class = E_TABLE_GROUP_CLASS (klass);
 	GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
@@ -694,6 +694,6 @@ etgl_init (ETableGroupLeaf *etgl)
 	etgl->selection_model = NULL;
 	etgl->uniform_row_height = FALSE;
 
-	e_canvas_item_set_reflow_callback (GNOME_CANVAS_ITEM (etgl), etgl_reflow);
+	e_canvas_item_set_reflow_callback (FOO_CANVAS_ITEM (etgl), etgl_reflow);
 }
 
diff --git a/widgets/table/e-table-group-leaf.h b/widgets/table/e-table-group-leaf.h
index d34f034..744bb9d 100644
--- a/widgets/table/e-table-group-leaf.h
+++ b/widgets/table/e-table-group-leaf.h
@@ -24,7 +24,7 @@
 #ifndef _E_TABLE_GROUP_LEAF_H_
 #define _E_TABLE_GROUP_LEAF_H_
 
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 #include <table/e-table-group.h>
 #include <table/e-table-subset.h>
 #include <table/e-table-item.h>
@@ -76,7 +76,7 @@ typedef struct {
 	ETableGroupClass parent_class;
 } ETableGroupLeafClass;
 
-ETableGroup *e_table_group_leaf_new       (GnomeCanvasGroup *parent,
+ETableGroup *e_table_group_leaf_new       (FooCanvasGroup *parent,
 					   ETableHeader *full_header,
 					   ETableHeader     *header,
 					   ETableModel *model,
diff --git a/widgets/table/e-table-group.c b/widgets/table/e-table-group.c
index ebf8616..8754f18 100644
--- a/widgets/table/e-table-group.c
+++ b/widgets/table/e-table-group.c
@@ -23,7 +23,7 @@
 #include <config.h>
 
 #include <gtk/gtk.h>
-#include <libgnomecanvas/gnome-canvas-rect-ellipse.h>
+#include <libfoocanvas/foo-canvas-rect-ellipse.h>
 
 #include "e-util/e-util.h"
 
@@ -34,7 +34,7 @@
 
 /* workaround for avoiding API breakage*/
 #define etg_get_type e_table_group_get_type
-G_DEFINE_TYPE (ETableGroup, etg, GNOME_TYPE_CANVAS_GROUP)
+G_DEFINE_TYPE (ETableGroup, etg, FOO_TYPE_CANVAS_GROUP)
 
 #define ETG_CLASS(e) (E_TABLE_GROUP_CLASS(GTK_OBJECT_GET_CLASS(e)))
 
@@ -79,7 +79,7 @@ etg_dispose (GObject *object)
 
 /**
  * e_table_group_new
- * @parent: The %GnomeCanvasGroup to create a child of.
+ * @parent: The %FooCanvasGroup to create a child of.
  * @full_header: The full header of the %ETable.
  * @header: The current header of the %ETable.
  * @model: The %ETableModel of the %ETable.
@@ -87,7 +87,7 @@ etg_dispose (GObject *object)
  * @n: The grouping information object to group by.
  *
  * %ETableGroup is a collection of rows of an %ETable.  It's a
- * %GnomeCanvasItem.  There are two different forms.  If n < the
+ * %FooCanvasItem.  There are two different forms.  If n < the
  * number of groupings in the given %ETableSortInfo, then the
  * %ETableGroup will need to contain other %ETableGroups, thus it
  * creates an %ETableGroupContainer.  Otherwise, it will just contain
@@ -96,7 +96,7 @@ etg_dispose (GObject *object)
  * Returns: The new %ETableGroup.
  */
 ETableGroup *
-e_table_group_new (GnomeCanvasGroup *parent,
+e_table_group_new (FooCanvasGroup *parent,
 		   ETableHeader     *full_header,
 		   ETableHeader     *header,
 		   ETableModel      *model,
@@ -114,7 +114,7 @@ e_table_group_new (GnomeCanvasGroup *parent,
 
 /**
  * e_table_group_construct
- * @parent: The %GnomeCanvasGroup to create a child of.
+ * @parent: The %FooCanvasGroup to create a child of.
  * @etg: The %ETableGroup to construct.
  * @full_header: The full header of the %ETable.
  * @header: The current header of the %ETable.
@@ -123,7 +123,7 @@ e_table_group_new (GnomeCanvasGroup *parent,
  * This routine does the base construction of the %ETableGroup.
  */
 void
-e_table_group_construct (GnomeCanvasGroup *parent,
+e_table_group_construct (FooCanvasGroup *parent,
 			 ETableGroup      *etg,
 			 ETableHeader     *full_header,
 			 ETableHeader     *header,
@@ -591,7 +591,7 @@ e_table_group_get_header (ETableGroup *etg)
 }
 
 static gint
-etg_event (GnomeCanvasItem *item, GdkEvent *event)
+etg_event (FooCanvasItem *item, GdkEvent *event)
 {
 	ETableGroup *etg = E_TABLE_GROUP (item);
 	gboolean return_val = TRUE;
@@ -606,8 +606,8 @@ etg_event (GnomeCanvasItem *item, GdkEvent *event)
 		return_val = FALSE;
 	}
 	if (return_val == FALSE) {
-		if (GNOME_CANVAS_ITEM_CLASS(etg_parent_class)->event)
-			return GNOME_CANVAS_ITEM_CLASS(etg_parent_class)->event (item, event);
+		if (FOO_CANVAS_ITEM_CLASS(etg_parent_class)->event)
+			return FOO_CANVAS_ITEM_CLASS(etg_parent_class)->event (item, event);
 	}
 	return return_val;
 
@@ -622,7 +622,7 @@ etg_get_focus (ETableGroup      *etg)
 static void
 etg_class_init (ETableGroupClass *klass)
 {
-	GnomeCanvasItemClass *item_class = GNOME_CANVAS_ITEM_CLASS (klass);
+	FooCanvasItemClass *item_class = FOO_CANVAS_ITEM_CLASS (klass);
 	GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
 	object_class->dispose = etg_dispose;
diff --git a/widgets/table/e-table-group.h b/widgets/table/e-table-group.h
index 7bf139e..36732d9 100644
--- a/widgets/table/e-table-group.h
+++ b/widgets/table/e-table-group.h
@@ -24,7 +24,7 @@
 #ifndef _E_TABLE_GROUP_H_
 #define _E_TABLE_GROUP_H_
 
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 #include <table/e-table-model.h>
 #include <table/e-table-header.h>
 #include <table/e-table-sort-info.h>
@@ -41,7 +41,7 @@ G_BEGIN_DECLS
 #define E_IS_TABLE_GROUP_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TABLE_GROUP_TYPE))
 
 typedef struct {
-	GnomeCanvasGroup group;
+	FooCanvasGroup group;
 
 	/*
 	 * The full header.
@@ -66,7 +66,7 @@ typedef struct {
 } ETableGroup;
 
 typedef struct {
-	GnomeCanvasGroupClass parent_class;
+	FooCanvasGroupClass parent_class;
 
 	/* Signals */
 	void        (*cursor_change)         (ETableGroup *etg, gint row);
@@ -133,13 +133,13 @@ void          e_table_group_get_cell_geometry (ETableGroup       *etg,
 					       gint               *y,
 					       gint               *width,
 					       gint               *height);
-ETableGroup  *e_table_group_new               (GnomeCanvasGroup  *parent,
+ETableGroup  *e_table_group_new               (FooCanvasGroup  *parent,
 					       ETableHeader      *full_header,
 					       ETableHeader      *header,
 					       ETableModel       *model,
 					       ETableSortInfo    *sort_info,
 					       gint                n);
-void          e_table_group_construct         (GnomeCanvasGroup  *parent,
+void          e_table_group_construct         (FooCanvasGroup  *parent,
 					       ETableGroup       *etg,
 					       ETableHeader      *full_header,
 					       ETableHeader      *header,
diff --git a/widgets/table/e-table-header-item.c b/widgets/table/e-table-header-item.c
index 067ce72..39385de 100644
--- a/widgets/table/e-table-header-item.c
+++ b/widgets/table/e-table-header-item.c
@@ -27,10 +27,10 @@
 #include <glib.h>
 
 #include <gtk/gtk.h>
-#include <libgnomecanvas/gnome-canvas.h>
-#include <libgnomecanvas/gnome-canvas-util.h>
-#include <libgnomecanvas/gnome-canvas-polygon.h>
-#include <libgnomecanvas/gnome-canvas-rect-ellipse.h>
+#include <libfoocanvas/foo-canvas.h>
+#include <libfoocanvas/foo-canvas-util.h>
+#include <libfoocanvas/foo-canvas-polygon.h>
+#include <libfoocanvas/foo-canvas-rect-ellipse.h>
 #include <gdk-pixbuf/gdk-pixbuf.h>
 #include <gdk/gdkkeysyms.h>
 
@@ -71,7 +71,7 @@ static guint ethi_signals [LAST_SIGNAL] = { 0, };
 #define ETHI_RESIZING(x) ((x)->resize_col != -1)
 
 #define ethi_get_type e_table_header_item_get_type
-G_DEFINE_TYPE (ETableHeaderItem, ethi, GNOME_TYPE_CANVAS_ITEM)
+G_DEFINE_TYPE (ETableHeaderItem, ethi, FOO_TYPE_CANVAS_ITEM)
 
 #define d(x)
 
@@ -173,7 +173,7 @@ e_table_header_item_get_height (ETableHeaderItem *ethi)
 		gint height;
 
 		height = e_table_header_compute_height (ecol,
-							GTK_WIDGET (GNOME_CANVAS_ITEM (ethi)->canvas));
+							GTK_WIDGET (FOO_CANVAS_ITEM (ethi)->canvas));
 
 		if (height > maxheight)
 			maxheight = height;
@@ -183,15 +183,15 @@ e_table_header_item_get_height (ETableHeaderItem *ethi)
 }
 
 static void
-ethi_update (GnomeCanvasItem *item, double *affine, ArtSVP *clip_path, gint flags)
+ethi_update (FooCanvasItem *item, double *affine, ArtSVP *clip_path, gint flags)
 {
 	ETableHeaderItem *ethi = E_TABLE_HEADER_ITEM (item);
 
 	double   i2c [6];
 	ArtPoint c1, c2, i1, i2;
 
-	if (GNOME_CANVAS_ITEM_CLASS (ethi_parent_class)->update)
-		(*GNOME_CANVAS_ITEM_CLASS (ethi_parent_class)->update)(item, affine, clip_path, flags);
+	if (FOO_CANVAS_ITEM_CLASS (ethi_parent_class)->update)
+		(*FOO_CANVAS_ITEM_CLASS (ethi_parent_class)->update)(item, affine, clip_path, flags);
 
 	if (ethi->sort_info)
 		ethi->group_indent_width = e_table_sort_info_grouping_get_count(ethi->sort_info) * GROUP_INDENT;
@@ -204,7 +204,7 @@ ethi_update (GnomeCanvasItem *item, double *affine, ArtSVP *clip_path, gint flag
 	i2.x = ethi->width;
 	i2.y = ethi->height;
 
-	gnome_canvas_item_i2c_affine (item, i2c);
+	foo_canvas_item_i2c_affine (item, i2c);
 	art_affine_point (&c1, &i1, i2c);
 	art_affine_point (&c2, &i2, i2c);
 
@@ -213,17 +213,17 @@ ethi_update (GnomeCanvasItem *item, double *affine, ArtSVP *clip_path, gint flag
 	    item->x2 != c2.x ||
 	    item->y2 != c2.y)
 		{
-			gnome_canvas_request_redraw (item->canvas, item->x1, item->y1, item->x2, item->y2);
+			foo_canvas_request_redraw (item->canvas, item->x1, item->y1, item->x2, item->y2);
 			item->x1 = c1.x;
 			item->y1 = c1.y;
 			item->x2 = c2.x;
 			item->y2 = c2.y;
 /* FIXME: Group Child bounds !? (FOO BAA) */
 #if 0
-			gnome_canvas_group_child_bounds (GNOME_CANVAS_GROUP (item->parent), item);
+			foo_canvas_group_child_bounds (FOO_CANVAS_GROUP (item->parent), item);
 #endif
 		}
-	gnome_canvas_request_redraw (item->canvas, item->x1, item->y1, item->x2, item->y2);
+	foo_canvas_request_redraw (item->canvas, item->x1, item->y1, item->x2, item->y2);
 }
 
 static void
@@ -235,7 +235,7 @@ ethi_font_set (ETableHeaderItem *ethi, PangoFontDescription *font_desc)
 	ethi->font_desc = pango_font_description_copy (font_desc);
 
 	ethi->height = e_table_header_item_get_height (ethi);
-	e_canvas_item_request_reflow(GNOME_CANVAS_ITEM(ethi));
+	e_canvas_item_request_reflow(FOO_CANVAS_ITEM(ethi));
 }
 
 static void
@@ -258,13 +258,13 @@ ethi_drop_table_header (ETableHeaderItem *ethi)
 static void
 structure_changed (ETableHeader *header, ETableHeaderItem *ethi)
 {
-	gnome_canvas_item_request_update(GNOME_CANVAS_ITEM(ethi));
+	foo_canvas_item_request_update(FOO_CANVAS_ITEM(ethi));
 }
 
 static void
 dimension_changed (ETableHeader *header, gint col, ETableHeaderItem *ethi)
 {
-	gnome_canvas_item_request_update(GNOME_CANVAS_ITEM(ethi));
+	foo_canvas_item_request_update(FOO_CANVAS_ITEM(ethi));
 }
 
 static void
@@ -281,14 +281,14 @@ ethi_add_table_header (ETableHeaderItem *ethi, ETableHeader *header)
 	ethi->dimension_change_id = g_signal_connect (
 		header, "dimension_change",
 		G_CALLBACK (dimension_changed), ethi);
-	e_canvas_item_request_reflow(GNOME_CANVAS_ITEM(ethi));
-	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM(ethi));
+	e_canvas_item_request_reflow(FOO_CANVAS_ITEM(ethi));
+	foo_canvas_item_request_update (FOO_CANVAS_ITEM(ethi));
 }
 
 static void
 ethi_sort_info_changed (ETableSortInfo *sort_info, ETableHeaderItem *ethi)
 {
-	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM(ethi));
+	foo_canvas_item_request_update (FOO_CANVAS_ITEM(ethi));
 }
 
 static void
@@ -297,10 +297,10 @@ ethi_set_property (GObject *object,
 		   const GValue *value,
 		   GParamSpec *pspec)
 {
-	GnomeCanvasItem *item;
+	FooCanvasItem *item;
 	ETableHeaderItem *ethi;
 
-	item = GNOME_CANVAS_ITEM (object);
+	item = FOO_CANVAS_ITEM (object);
 	ethi = E_TABLE_HEADER_ITEM (object);
 
 	switch (prop_id) {
@@ -363,7 +363,7 @@ ethi_set_property (GObject *object,
 			ethi->tree = NULL;
 		break;
 	}
-	gnome_canvas_item_request_update(item);
+	foo_canvas_item_request_update(item);
 }
 
 static void
@@ -505,11 +505,11 @@ ethi_add_drop_marker (ETableHeaderItem *ethi, gint col, gboolean recreate)
 	}
 
 	gdk_window_get_origin (
-		GTK_WIDGET (GNOME_CANVAS_ITEM (ethi)->canvas)->window,
+		GTK_WIDGET (FOO_CANVAS_ITEM (ethi)->canvas)->window,
 		&rx, &ry);
 
-	rx -= gtk_layout_get_hadjustment (GTK_LAYOUT (GNOME_CANVAS_ITEM (ethi)->canvas))->value;
-	ry -= gtk_layout_get_vadjustment (GTK_LAYOUT (GNOME_CANVAS_ITEM (ethi)->canvas))->value;
+	rx -= gtk_layout_get_hadjustment (GTK_LAYOUT (FOO_CANVAS_ITEM (ethi)->canvas))->value;
+	ry -= gtk_layout_get_vadjustment (GTK_LAYOUT (FOO_CANVAS_ITEM (ethi)->canvas))->value;
 
 	gtk_window_move (GTK_WINDOW (arrow_down), rx + x - ARROW_PTR, ry - ARROW_DOWN_HEIGHT);
 	gtk_widget_show_all (arrow_down);
@@ -539,9 +539,9 @@ ethi_add_destroy_marker (ETableHeaderItem *ethi)
 	if (ethi->drag_col > 0)
 		x1 += ethi->group_indent_width;
 
-	ethi->remove_item = gnome_canvas_item_new (
-		GNOME_CANVAS_GROUP (GNOME_CANVAS_ITEM (ethi)->canvas->root),
-		gnome_canvas_rect_get_type (),
+	ethi->remove_item = foo_canvas_item_new (
+		FOO_CANVAS_GROUP (FOO_CANVAS_ITEM (ethi)->canvas->root),
+		foo_canvas_rect_get_type (),
 		"x1", x1 + 1,
 		"y1", (double) 1,
 		"x2", (double) x1 + e_table_header_col_diff (
@@ -637,8 +637,8 @@ scroll_timeout (gpointer data)
 	if (ethi->scroll_direction & ET_SCROLL_LEFT)
 		dx -= 20;
 
-	h = GTK_LAYOUT(GNOME_CANVAS_ITEM (ethi)->canvas)->hadjustment;
-	v = GTK_LAYOUT(GNOME_CANVAS_ITEM (ethi)->canvas)->vadjustment;
+	h = GTK_LAYOUT(FOO_CANVAS_ITEM (ethi)->canvas)->hadjustment;
+	v = GTK_LAYOUT(FOO_CANVAS_ITEM (ethi)->canvas)->vadjustment;
 
 	value = h->value;
 
@@ -800,7 +800,7 @@ ethi_drag_data_received (GtkWidget *canvas,
 		}
 	}
 	ethi_remove_drop_marker (ethi);
-	gnome_canvas_item_request_update(GNOME_CANVAS_ITEM(ethi));
+	foo_canvas_item_request_update(FOO_CANVAS_ITEM(ethi));
 }
 
 static void
@@ -865,15 +865,15 @@ ethi_drag_leave (GtkWidget *widget, GdkDragContext *context, guint time, ETableH
 }
 
 static void
-ethi_realize (GnomeCanvasItem *item)
+ethi_realize (FooCanvasItem *item)
 {
 	ETableHeaderItem *ethi = E_TABLE_HEADER_ITEM (item);
 	GtkTargetEntry  ethi_drop_types [] = {
 		{ (gchar *) TARGET_ETABLE_COL_TYPE, 0, TARGET_ETABLE_COL_HEADER },
 	};
 
-	if (GNOME_CANVAS_ITEM_CLASS (ethi_parent_class)-> realize)
-		(*GNOME_CANVAS_ITEM_CLASS (ethi_parent_class)->realize)(item);
+	if (FOO_CANVAS_ITEM_CLASS (ethi_parent_class)-> realize)
+		(*FOO_CANVAS_ITEM_CLASS (ethi_parent_class)->realize)(item);
 
 	if (!ethi->font_desc)
 		ethi_font_set (ethi, GTK_WIDGET (item->canvas)->style->font_desc);
@@ -906,7 +906,7 @@ ethi_realize (GnomeCanvasItem *item)
 }
 
 static void
-ethi_unrealize (GnomeCanvasItem *item)
+ethi_unrealize (FooCanvasItem *item)
 {
 	ETableHeaderItem *ethi = E_TABLE_HEADER_ITEM (item);
 
@@ -930,15 +930,15 @@ ethi_unrealize (GnomeCanvasItem *item)
 		ethi->stipple = NULL;
 	}
 
-	if (GNOME_CANVAS_ITEM_CLASS (ethi_parent_class)->unrealize)
-		(*GNOME_CANVAS_ITEM_CLASS (ethi_parent_class)->unrealize)(item);
+	if (FOO_CANVAS_ITEM_CLASS (ethi_parent_class)->unrealize)
+		(*FOO_CANVAS_ITEM_CLASS (ethi_parent_class)->unrealize)(item);
 }
 
 static void
-ethi_draw (GnomeCanvasItem *item, GdkDrawable *drawable, gint x, gint y, gint width, gint height)
+ethi_draw (FooCanvasItem *item, GdkDrawable *drawable, gint x, gint y, gint width, gint height)
 {
 	ETableHeaderItem *ethi = E_TABLE_HEADER_ITEM (item);
-	GnomeCanvas *canvas = item->canvas;
+	FooCanvas *canvas = item->canvas;
 	const gint cols = e_table_header_count (ethi->eth);
 	gint x1, x2;
 	gint col;
@@ -1001,8 +1001,8 @@ ethi_draw (GnomeCanvasItem *item, GdkDrawable *drawable, gint x, gint y, gint wi
 }
 
 static double
-ethi_point (GnomeCanvasItem *item, double x, double y, gint cx, gint cy,
-	    GnomeCanvasItem **actual_item)
+ethi_point (FooCanvasItem *item, double x, double y, gint cx, gint cy,
+	    FooCanvasItem **actual_item)
 {
 	*actual_item = item;
 	return 0.0;
@@ -1048,13 +1048,13 @@ is_pointer_on_division (ETableHeaderItem *ethi, gint pos, gint *the_total, gint
 	return FALSE;
 }
 
-#define convert(c,sx,sy,x,y) gnome_canvas_w2c (c,sx,sy,x,y)
+#define convert(c,sx,sy,x,y) foo_canvas_w2c (c,sx,sy,x,y)
 
 static void
 set_cursor (ETableHeaderItem *ethi, gint pos)
 {
 	gint col;
-	GtkWidget *canvas = GTK_WIDGET (GNOME_CANVAS_ITEM (ethi)->canvas);
+	GtkWidget *canvas = GTK_WIDGET (FOO_CANVAS_ITEM (ethi)->canvas);
 	gboolean resizable = FALSE;
 
 	/* We might be invoked before we are realized */
@@ -1095,7 +1095,7 @@ ethi_end_resize (ETableHeaderItem *ethi)
 	ethi->resize_col = -1;
 	ethi->resize_guide = GINT_TO_POINTER (0);
 
-	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM(ethi));
+	foo_canvas_item_request_update (FOO_CANVAS_ITEM(ethi));
 }
 
 static gboolean
@@ -1119,7 +1119,7 @@ ethi_maybe_start_drag (ETableHeaderItem *ethi, GdkEventMotion *event)
 static void
 ethi_start_drag (ETableHeaderItem *ethi, GdkEvent *event)
 {
-	GtkWidget *widget = GTK_WIDGET (GNOME_CANVAS_ITEM (ethi)->canvas);
+	GtkWidget *widget = GTK_WIDGET (FOO_CANVAS_ITEM (ethi)->canvas);
 	GtkTargetList *list;
 	GdkDragContext *context;
 	ETableCol *ecol;
@@ -1395,7 +1395,7 @@ ethi_popup_best_fit(GtkWidget *widget, EthiHeaderInfo *info)
 	/* Add 10 to stop it from "..."ing */
 	e_table_header_set_size (ethi->eth, info->col, width + 10);
 
-	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM(ethi));
+	foo_canvas_item_request_update (FOO_CANVAS_ITEM(ethi));
 
 }
 
@@ -1685,10 +1685,10 @@ ethi_change_sort_state (ETableHeaderItem *ethi, ETableCol *col)
  * Handles the events on the ETableHeaderItem, particularly it handles resizing
  */
 static gint
-ethi_event (GnomeCanvasItem *item, GdkEvent *e)
+ethi_event (FooCanvasItem *item, GdkEvent *e)
 {
 	ETableHeaderItem *ethi = E_TABLE_HEADER_ITEM (item);
-	GnomeCanvas *canvas = item->canvas;
+	FooCanvas *canvas = item->canvas;
 	const gboolean resizing = ETHI_RESIZING (ethi);
 	gint x, y, start, col;
 	gint was_maybe_drag = 0;
@@ -1713,7 +1713,7 @@ ethi_event (GnomeCanvasItem *item, GdkEvent *e)
 				/* Quick hack until I actually bind the views */
 				ethi->resize_guide = GINT_TO_POINTER (1);
 
-				gnome_canvas_item_grab (item,
+				foo_canvas_item_grab (item,
 							GDK_POINTER_MOTION_MASK |
 							GDK_BUTTON_RELEASE_MASK,
 							ethi->resize_cursor,
@@ -1724,7 +1724,7 @@ ethi_event (GnomeCanvasItem *item, GdkEvent *e)
 
 			e_table_header_set_size (ethi->eth, ethi->resize_col, new_width);
 
-			gnome_canvas_item_request_update (GNOME_CANVAS_ITEM(ethi));
+			foo_canvas_item_request_update (FOO_CANVAS_ITEM(ethi));
 		} else if (ethi_maybe_start_drag (ethi, &e->motion)) {
 			ethi_start_drag (ethi, e);
 		} else
@@ -1784,7 +1784,7 @@ ethi_event (GnomeCanvasItem *item, GdkEvent *e)
 			/* Add 10 to stop it from "..."ing */
 			e_table_header_set_size (ethi->eth, ethi->resize_col, width + 10);
 
-			gnome_canvas_item_request_update (GNOME_CANVAS_ITEM(ethi));
+			foo_canvas_item_request_update (FOO_CANVAS_ITEM(ethi));
 			ethi->maybe_drag = FALSE;
 		}
 		break;
@@ -1807,7 +1807,7 @@ ethi_event (GnomeCanvasItem *item, GdkEvent *e)
 		}
 
 		if (needs_ungrab)
-			gnome_canvas_item_ungrab (item, e->button.time);
+			foo_canvas_item_ungrab (item, e->button.time);
 
 		break;
 	}
@@ -1870,7 +1870,7 @@ ethi_event (GnomeCanvasItem *item, GdkEvent *e)
 static void
 ethi_class_init (ETableHeaderItemClass *klass)
 {
-	GnomeCanvasItemClass *item_class = GNOME_CANVAS_ITEM_CLASS (klass);
+	FooCanvasItemClass *item_class = FOO_CANVAS_ITEM_CLASS (klass);
 	GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
 	object_class->dispose = ethi_dispose;
@@ -1958,7 +1958,7 @@ ethi_class_init (ETableHeaderItemClass *klass)
 static void
 ethi_init (ETableHeaderItem *ethi)
 {
-	GnomeCanvasItem *item = GNOME_CANVAS_ITEM (ethi);
+	FooCanvasItem *item = FOO_CANVAS_ITEM (ethi);
 
 	ethi->resize_cursor = gdk_cursor_new (GDK_SB_H_DOUBLE_ARROW);
 
diff --git a/widgets/table/e-table-header-item.h b/widgets/table/e-table-header-item.h
index 17e6e96..c4d313e 100644
--- a/widgets/table/e-table-header-item.h
+++ b/widgets/table/e-table-header-item.h
@@ -26,7 +26,7 @@
 
 #include <table/e-table.h>
 #include <table/e-tree.h>
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 #include <libxml/tree.h>
 #include <table/e-table-header.h>
 #include <table/e-table-sort-info.h>
@@ -40,7 +40,7 @@ G_BEGIN_DECLS
 #define E_IS_TABLE_HEADER_ITEM_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TABLE_HEADER_ITEM_TYPE))
 
 typedef struct {
-	GnomeCanvasItem  parent;
+	FooCanvasItem  parent;
 	ETableHeader    *eth;
 
 	GdkCursor       *change_cursor;
@@ -74,7 +74,7 @@ typedef struct {
 	gint              drag_col, drop_col, drag_mark;
         guint            drag_motion_id, drag_end_id, drag_leave_id, drag_drop_id, drag_data_received_id, drag_data_get_id;
 	guint            sort_info_changed_id, group_info_changed_id;
-	GnomeCanvasItem *remove_item;
+	FooCanvasItem *remove_item;
 	GdkBitmap       *stipple;
 
 	gchar           *dnd_code;
@@ -108,7 +108,7 @@ typedef struct {
 } ETableHeaderItem;
 
 typedef struct {
-	GnomeCanvasItemClass parent_class;
+	FooCanvasItemClass parent_class;
 
 	/*
 	 * signals
diff --git a/widgets/table/e-table-item.c b/widgets/table/e-table-item.c
index a534ef2..9756baa 100644
--- a/widgets/table/e-table-item.c
+++ b/widgets/table/e-table-item.c
@@ -50,7 +50,7 @@
 
 /* workaround for avoiding API breakage */
 #define eti_get_type e_table_item_get_type
-G_DEFINE_TYPE (ETableItem, eti, GNOME_TYPE_CANVAS_ITEM)
+G_DEFINE_TYPE (ETableItem, eti, FOO_TYPE_CANVAS_ITEM)
 
 #define FOCUSED_BORDER 2
 
@@ -178,7 +178,7 @@ view_to_model_col(ETableItem *eti, gint col)
 }
 
 static void
-grab_cancelled (ECanvas *canvas, GnomeCanvasItem *item, gpointer data)
+grab_cancelled (ECanvas *canvas, FooCanvasItem *item, gpointer data)
 {
 	ETableItem *eti = data;
 
@@ -188,7 +188,7 @@ grab_cancelled (ECanvas *canvas, GnomeCanvasItem *item, gpointer data)
 inline static void
 eti_grab (ETableItem *eti, guint32 time)
 {
-	GnomeCanvasItem *item = GNOME_CANVAS_ITEM (eti);
+	FooCanvasItem *item = FOO_CANVAS_ITEM (eti);
 	d(g_print ("%s: time: %d\n", __FUNCTION__, time));
 	if (eti->grabbed_count == 0) {
 		eti->gtk_grabbed = FALSE;
@@ -211,7 +211,7 @@ eti_grab (ETableItem *eti, guint32 time)
 inline static void
 eti_ungrab (ETableItem *eti, guint32 time)
 {
-	GnomeCanvasItem *item = GNOME_CANVAS_ITEM (eti);
+	FooCanvasItem *item = FOO_CANVAS_ITEM (eti);
 	d(g_print ("%s: time: %d\n", __FUNCTION__, time));
 	eti->grabbed_count --;
 	if (eti->grabbed_count == 0) {
@@ -223,7 +223,7 @@ eti_ungrab (ETableItem *eti, guint32 time)
 				gtk_grab_remove (GTK_WIDGET (item->canvas));
 				eti->gtk_grabbed = FALSE;
 			}
-			gnome_canvas_item_ungrab(item, time);
+			foo_canvas_item_ungrab(item, time);
 			eti->grabbed_col = -1;
 			eti->grabbed_row = -1;
 		}
@@ -245,7 +245,7 @@ inline static GdkColor *
 eti_get_cell_background_color (ETableItem *eti, gint row, gint col, gboolean selected, gboolean *allocatedp)
 {
 	ECellView *ecell_view = eti->cell_views [col];
-	GtkWidget *canvas = GTK_WIDGET(GNOME_CANVAS_ITEM(eti)->canvas);
+	GtkWidget *canvas = GTK_WIDGET(FOO_CANVAS_ITEM(eti)->canvas);
 	GdkColor *background, bg;
 	gchar *color_spec = NULL;
 	gboolean allocated = FALSE;
@@ -292,7 +292,7 @@ eti_get_cell_background_color (ETableItem *eti, gint row, gint col, gboolean sel
 inline static GdkColor *
 eti_get_cell_foreground_color (ETableItem *eti, gint row, gint col, gboolean selected, gboolean *allocated)
 {
-	GtkWidget *canvas = GTK_WIDGET(GNOME_CANVAS_ITEM(eti)->canvas);
+	GtkWidget *canvas = GTK_WIDGET(FOO_CANVAS_ITEM(eti)->canvas);
 	GdkColor *foreground;
 
 	if (allocated)
@@ -340,7 +340,7 @@ eti_realize_cell_views ( ETableItem *eti)
 	if (eti->cell_views_realized)
 		return;
 
-	if (!(GTK_OBJECT_FLAGS(eti) & GNOME_CANVAS_ITEM_REALIZED))
+	if (!(GTK_OBJECT_FLAGS(eti) & FOO_CANVAS_ITEM_REALIZED))
 		return;
 
 	for (i = 0; i < eti->n_cells; i++)
@@ -377,9 +377,9 @@ eti_attach_cell_views (ETableItem *eti)
 	}
 
 	eti->needs_compute_height = 1;
-	e_canvas_item_request_reflow (GNOME_CANVAS_ITEM (eti));
+	e_canvas_item_request_reflow (FOO_CANVAS_ITEM (eti));
 	eti->needs_redraw = 1;
-	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (eti));
+	foo_canvas_item_request_update (FOO_CANVAS_ITEM (eti));
 }
 
 /*
@@ -419,7 +419,7 @@ eti_detach_cell_views (ETableItem *eti)
 }
 
 static void
-eti_bounds (GnomeCanvasItem *item, double *x1, double *y1, double *x2, double *y2)
+eti_bounds (FooCanvasItem *item, double *x1, double *y1, double *x2, double *y2)
 {
 	double   i2c [6];
 	ArtPoint c1, c2, i1, i2;
@@ -427,7 +427,7 @@ eti_bounds (GnomeCanvasItem *item, double *x1, double *y1, double *x2, double *y
 
 	/* Wrong BBox's are the source of redraw nightmares */
 
-	gnome_canvas_item_i2c_affine (GNOME_CANVAS_ITEM (eti), i2c);
+	foo_canvas_item_i2c_affine (FOO_CANVAS_ITEM (eti), i2c);
 
 	i1.x = eti->x1;
 	i1.y = eti->y1;
@@ -443,7 +443,7 @@ eti_bounds (GnomeCanvasItem *item, double *x1, double *y1, double *x2, double *y
 }
 
 static void
-eti_reflow (GnomeCanvasItem *item, gint flags)
+eti_reflow (FooCanvasItem *item, gint flags)
 {
 	ETableItem *eti = E_TABLE_ITEM (item);
 
@@ -452,9 +452,9 @@ eti_reflow (GnomeCanvasItem *item, gint flags)
 
 		if (new_height != eti->height) {
 			eti->height = new_height;
-			e_canvas_item_request_parent_reflow (GNOME_CANVAS_ITEM (eti));
+			e_canvas_item_request_parent_reflow (FOO_CANVAS_ITEM (eti));
 			eti->needs_redraw = 1;
-			gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (eti));
+			foo_canvas_item_request_update (FOO_CANVAS_ITEM (eti));
 		}
 		eti->needs_compute_height = 0;
 	}
@@ -462,25 +462,25 @@ eti_reflow (GnomeCanvasItem *item, gint flags)
 		gint new_width = e_table_header_total_width(eti->header);
 		if (new_width != eti->width) {
 			eti->width = new_width;
-			e_canvas_item_request_parent_reflow (GNOME_CANVAS_ITEM (eti));
+			e_canvas_item_request_parent_reflow (FOO_CANVAS_ITEM (eti));
 			eti->needs_redraw = 1;
-			gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (eti));
+			foo_canvas_item_request_update (FOO_CANVAS_ITEM (eti));
 		}
 		eti->needs_compute_width = 0;
 	}
 }
 
 /*
- * GnomeCanvasItem::update method
+ * FooCanvasItem::update method
  */
 static void
-eti_update (GnomeCanvasItem *item, double *affine, ArtSVP *clip_path, gint flags)
+eti_update (FooCanvasItem *item, double *affine, ArtSVP *clip_path, gint flags)
 {
 	ArtPoint o1, o2;
 	ETableItem *eti = E_TABLE_ITEM (item);
 
-	if (GNOME_CANVAS_ITEM_CLASS (eti_parent_class)->update)
-		(*GNOME_CANVAS_ITEM_CLASS (eti_parent_class)->update)(item, affine, clip_path, flags);
+	if (FOO_CANVAS_ITEM_CLASS (eti_parent_class)->update)
+		(*FOO_CANVAS_ITEM_CLASS (eti_parent_class)->update)(item, affine, clip_path, flags);
 
 	o1.x = item->x1;
 	o1.y = item->y1;
@@ -492,12 +492,12 @@ eti_update (GnomeCanvasItem *item, double *affine, ArtSVP *clip_path, gint flags
 	    item->y1 != o1.y ||
 	    item->x2 != o2.x ||
 	    item->y2 != o2.y) {
-		gnome_canvas_request_redraw (item->canvas, o1.x, o1.y, o2.x, o2.y);
+		foo_canvas_request_redraw (item->canvas, o1.x, o1.y, o2.x, o2.y);
 		eti->needs_redraw = 1;
 	}
 
 	if (eti->needs_redraw) {
-		gnome_canvas_request_redraw (item->canvas, item->x1, item->y1,
+		foo_canvas_request_redraw (item->canvas, item->x1, item->y1,
 					     item->x2, item->y2);
 		eti->needs_redraw = 0;
 	}
@@ -665,7 +665,7 @@ height_cache_idle(ETableItem *eti)
 static void
 free_height_cache (ETableItem *eti)
 {
-	if (GNOME_CANVAS_ITEM_REALIZED & GTK_OBJECT_FLAGS (eti)) {
+	if (FOO_CANVAS_ITEM_REALIZED & GTK_OBJECT_FLAGS (eti)) {
 		if (eti->height_cache)
 			g_free (eti->height_cache);
 		eti->height_cache = NULL;
@@ -712,7 +712,7 @@ eti_row_height (ETableItem *eti, gint row)
 			    eti->rows > eti->length_threshold &&
 			    eti->height_cache[row] != eti_row_height(eti, 0)) {
 				eti->needs_compute_height = 1;
-				e_canvas_item_request_reflow(GNOME_CANVAS_ITEM(eti));
+				e_canvas_item_request_reflow(FOO_CANVAS_ITEM(eti));
 			}
 		}
 		return eti->height_cache[row];
@@ -780,7 +780,7 @@ eti_get_height (ETableItem *eti)
 static void
 eti_item_region_redraw (ETableItem *eti, gint x0, gint y0, gint x1, gint y1)
 {
-	GnomeCanvasItem *item = GNOME_CANVAS_ITEM (eti);
+	FooCanvasItem *item = FOO_CANVAS_ITEM (eti);
 	ArtDRect rect;
 	double i2c [6];
 
@@ -789,10 +789,10 @@ eti_item_region_redraw (ETableItem *eti, gint x0, gint y0, gint x1, gint y1)
 	rect.x1 = x1;
 	rect.y1 = y1;
 
-	gnome_canvas_item_i2c_affine (item, i2c);
+	foo_canvas_item_i2c_affine (item, i2c);
 	art_drect_affine_transform (&rect, &rect, i2c);
 
-	gnome_canvas_request_redraw (item->canvas, rect.x0, rect.y0, rect.x1, rect.y1);
+	foo_canvas_request_redraw (item->canvas, rect.x0, rect.y0, rect.x1, rect.y1);
 }
 
 /*
@@ -893,9 +893,9 @@ eti_request_region_show (ETableItem *eti,
 			&x1, &y1, &x2, &y2);
 
 	if (delay)
-		e_canvas_item_show_area_delayed(GNOME_CANVAS_ITEM(eti), x1, y1, x2, y2, delay);
+		e_canvas_item_show_area_delayed(FOO_CANVAS_ITEM(eti), x1, y1, x2, y2, delay);
 	else
-		e_canvas_item_show_area(GNOME_CANVAS_ITEM(eti), x1, y1, x2, y2);
+		e_canvas_item_show_area(FOO_CANVAS_ITEM(eti), x1, y1, x2, y2);
 }
 
 static void
@@ -903,7 +903,7 @@ eti_show_cursor (ETableItem *eti, gint delay)
 {
 	gint cursor_row;
 
-	if (!((GTK_OBJECT_FLAGS(eti) & GNOME_CANVAS_ITEM_REALIZED) && eti->cell_views_realized))
+	if (!((GTK_OBJECT_FLAGS(eti) & FOO_CANVAS_ITEM_REALIZED) && eti->cell_views_realized))
 		return;
 
 	if (eti->frozen_count > 0) {
@@ -935,14 +935,14 @@ eti_check_cursor_bounds (ETableItem *eti)
 	gint x1, y1, x2, y2;
 	gint cursor_row;
 
-	if (!((GTK_OBJECT_FLAGS(eti) & GNOME_CANVAS_ITEM_REALIZED) && eti->cell_views_realized))
+	if (!((GTK_OBJECT_FLAGS(eti) & FOO_CANVAS_ITEM_REALIZED) && eti->cell_views_realized))
 		return;
 
 	if (eti->frozen_count > 0) {
 		return;
 	}
 
-	if (!((GTK_OBJECT_FLAGS(eti) & GNOME_CANVAS_ITEM_REALIZED) && eti->cell_views_realized))
+	if (!((GTK_OBJECT_FLAGS(eti) & FOO_CANVAS_ITEM_REALIZED) && eti->cell_views_realized))
 		return;
 
 	if (eti->frozen_count > 0) {
@@ -975,7 +975,7 @@ eti_check_cursor_bounds (ETableItem *eti)
 	eti->cursor_y1 = y1;
 	eti->cursor_x2 = x2;
 	eti->cursor_y2 = y2;
-	eti->cursor_on_screen = e_canvas_item_area_shown (GNOME_CANVAS_ITEM(eti), x1, y1, x2, y2);
+	eti->cursor_on_screen = e_canvas_item_area_shown (FOO_CANVAS_ITEM(eti), x1, y1, x2, y2);
 
 	d(g_print ("%s: cursor on screen: %s\n", __FUNCTION__, eti->cursor_on_screen ? "TRUE" : "FALSE"));
 }
@@ -1081,7 +1081,7 @@ eti_table_model_no_change (ETableModel *table_model, ETableItem *eti)
 static void
 eti_table_model_changed (ETableModel *table_model, ETableItem *eti)
 {
-	if (!(GTK_OBJECT_FLAGS(eti) & GNOME_CANVAS_ITEM_REALIZED)) {
+	if (!(GTK_OBJECT_FLAGS(eti) & FOO_CANVAS_ITEM_REALIZED)) {
 		eti_unfreeze (eti);
 		return;
 	}
@@ -1093,9 +1093,9 @@ eti_table_model_changed (ETableModel *table_model, ETableItem *eti)
 	eti_unfreeze (eti);
 
 	eti->needs_compute_height = 1;
-	e_canvas_item_request_reflow (GNOME_CANVAS_ITEM (eti));
+	e_canvas_item_request_reflow (FOO_CANVAS_ITEM (eti));
 	eti->needs_redraw = 1;
-	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (eti));
+	foo_canvas_item_request_update (FOO_CANVAS_ITEM (eti));
 
 	eti_idle_maybe_show_cursor(eti);
 }
@@ -1103,7 +1103,7 @@ eti_table_model_changed (ETableModel *table_model, ETableItem *eti)
 static void
 eti_table_model_row_changed (ETableModel *table_model, gint row, ETableItem *eti)
 {
-	if (!(GTK_OBJECT_FLAGS(eti) & GNOME_CANVAS_ITEM_REALIZED)) {
+	if (!(GTK_OBJECT_FLAGS(eti) & FOO_CANVAS_ITEM_REALIZED)) {
 		eti_unfreeze (eti);
 		return;
 	}
@@ -1121,7 +1121,7 @@ eti_table_model_row_changed (ETableModel *table_model, gint row, ETableItem *eti
 static void
 eti_table_model_cell_changed (ETableModel *table_model, gint col, gint row, ETableItem *eti)
 {
-	if (!(GTK_OBJECT_FLAGS(eti) & GNOME_CANVAS_ITEM_REALIZED)) {
+	if (!(GTK_OBJECT_FLAGS(eti) & FOO_CANVAS_ITEM_REALIZED)) {
 		eti_unfreeze (eti);
 		return;
 	}
@@ -1139,7 +1139,7 @@ eti_table_model_cell_changed (ETableModel *table_model, gint col, gint row, ETab
 static void
 eti_table_model_rows_inserted (ETableModel *table_model, gint row, gint count, ETableItem *eti)
 {
-	if (!(GTK_OBJECT_FLAGS(eti) & GNOME_CANVAS_ITEM_REALIZED)) {
+	if (!(GTK_OBJECT_FLAGS(eti) & FOO_CANVAS_ITEM_REALIZED)) {
 		eti_unfreeze (eti);
 		return;
 	}
@@ -1158,15 +1158,15 @@ eti_table_model_rows_inserted (ETableModel *table_model, gint row, gint count, E
 	eti_idle_maybe_show_cursor(eti);
 
 	eti->needs_compute_height = 1;
-	e_canvas_item_request_reflow (GNOME_CANVAS_ITEM (eti));
+	e_canvas_item_request_reflow (FOO_CANVAS_ITEM (eti));
 	eti->needs_redraw = 1;
-	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (eti));
+	foo_canvas_item_request_update (FOO_CANVAS_ITEM (eti));
 }
 
 static void
 eti_table_model_rows_deleted (ETableModel *table_model, gint row, gint count, ETableItem *eti)
 {
-	if (!(GTK_OBJECT_FLAGS(eti) & GNOME_CANVAS_ITEM_REALIZED)) {
+	if (!(GTK_OBJECT_FLAGS(eti) & FOO_CANVAS_ITEM_REALIZED)) {
 		eti_unfreeze (eti);
 		return;
 	}
@@ -1182,9 +1182,9 @@ eti_table_model_rows_deleted (ETableModel *table_model, gint row, gint count, ET
 	eti_idle_maybe_show_cursor(eti);
 
 	eti->needs_compute_height = 1;
-	e_canvas_item_request_reflow (GNOME_CANVAS_ITEM (eti));
+	e_canvas_item_request_reflow (FOO_CANVAS_ITEM (eti));
 	eti->needs_redraw = 1;
-	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (eti));
+	foo_canvas_item_request_update (FOO_CANVAS_ITEM (eti));
 }
 
 /**
@@ -1319,9 +1319,9 @@ static void
 eti_header_dim_changed (ETableHeader *eth, gint col, ETableItem *eti)
 {
 	eti->needs_compute_width = 1;
-	e_canvas_item_request_reflow (GNOME_CANVAS_ITEM (eti));
+	e_canvas_item_request_reflow (FOO_CANVAS_ITEM (eti));
 	eti->needs_redraw = 1;
-	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (eti));
+	foo_canvas_item_request_update (FOO_CANVAS_ITEM (eti));
 }
 
 static void
@@ -1346,9 +1346,9 @@ eti_header_structure_changed (ETableHeader *eth, ETableItem *eti)
 		}
 	}
 	eti->needs_compute_width = 1;
-	e_canvas_item_request_reflow (GNOME_CANVAS_ITEM (eti));
+	e_canvas_item_request_reflow (FOO_CANVAS_ITEM (eti));
 	eti->needs_redraw = 1;
-	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (eti));
+	foo_canvas_item_request_update (FOO_CANVAS_ITEM (eti));
 }
 
 static gint
@@ -1413,8 +1413,8 @@ eti_dispose (GObject *object)
 		g_free (eti->height_cache);
 	eti->height_cache = NULL;
 
-	if (E_CANVAS(GNOME_CANVAS_ITEM(eti)->canvas))
-		e_canvas_hide_tooltip (E_CANVAS(GNOME_CANVAS_ITEM(eti)->canvas));
+	if (E_CANVAS(FOO_CANVAS_ITEM(eti)->canvas))
+		e_canvas_hide_tooltip (E_CANVAS(FOO_CANVAS_ITEM(eti)->canvas));
 
 	if (eti->tooltip) {
 		if (eti->tooltip->background)
@@ -1493,7 +1493,7 @@ eti_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpe
 		if ((eti->minimum_width == eti->width && g_value_get_double(value) > eti->width) ||
 		    g_value_get_double(value) < eti->width) {
 			eti->needs_compute_width = 1;
-			e_canvas_item_request_reflow (GNOME_CANVAS_ITEM(eti));
+			e_canvas_item_request_reflow (FOO_CANVAS_ITEM(eti));
 		}
 		eti->minimum_width = g_value_get_double (value);
 		break;
@@ -1507,18 +1507,18 @@ eti_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpe
 	case PROP_UNIFORM_ROW_HEIGHT:
 		if (eti->uniform_row_height != g_value_get_boolean (value)) {
 			eti->uniform_row_height = g_value_get_boolean (value);
-			if (GTK_OBJECT_FLAGS(eti) & GNOME_CANVAS_ITEM_REALIZED) {
+			if (GTK_OBJECT_FLAGS(eti) & FOO_CANVAS_ITEM_REALIZED) {
 				free_height_cache(eti);
 				eti->needs_compute_height = 1;
-				e_canvas_item_request_reflow (GNOME_CANVAS_ITEM (eti));
+				e_canvas_item_request_reflow (FOO_CANVAS_ITEM (eti));
 				eti->needs_redraw = 1;
-				gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (eti));
+				foo_canvas_item_request_update (FOO_CANVAS_ITEM (eti));
 			}
 		}
 		break;
 	}
 	eti->needs_redraw = 1;
-	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM(eti));
+	foo_canvas_item_request_update (FOO_CANVAS_ITEM(eti));
 }
 
 static void
@@ -1599,7 +1599,7 @@ eti_init (ETableItem *eti)
 
 	eti->tooltip                   = g_new0 (ETableTooltip, 1);
 	eti->tooltip->timer            = 0;
-	eti->tooltip->eti              = GNOME_CANVAS_ITEM (eti);
+	eti->tooltip->eti              = FOO_CANVAS_ITEM (eti);
 	eti->tooltip->background       = NULL;
 	eti->tooltip->foreground       = NULL;
 
@@ -1627,7 +1627,7 @@ eti_init (ETableItem *eti)
 	eti->frozen_count              = 0;
 	eti->queue_show_cursor         = FALSE;
 
-	e_canvas_item_set_reflow_callback (GNOME_CANVAS_ITEM (eti), eti_reflow);
+	e_canvas_item_set_reflow_callback (FOO_CANVAS_ITEM (eti), eti_reflow);
 }
 
 #define gray50_width 2
@@ -1646,14 +1646,14 @@ eti_tree_unfreeze (GtkWidget *widget,  GdkEvent *event, ETableItem *eti)
 }
 
 static void
-eti_realize (GnomeCanvasItem *item)
+eti_realize (FooCanvasItem *item)
 {
 	ETableItem *eti = E_TABLE_ITEM (item);
 	GtkWidget *canvas_widget = GTK_WIDGET (item->canvas);
 	GdkWindow *window;
 
-	if (GNOME_CANVAS_ITEM_CLASS (eti_parent_class)->realize)
-                (*GNOME_CANVAS_ITEM_CLASS (eti_parent_class)->realize)(item);
+	if (FOO_CANVAS_ITEM_CLASS (eti_parent_class)->realize)
+                (*FOO_CANVAS_ITEM_CLASS (eti_parent_class)->realize)(item);
 
 	eti->rows = e_table_model_row_count (eti->table_model);
 
@@ -1697,13 +1697,13 @@ eti_realize (GnomeCanvasItem *item)
 
 	eti->needs_compute_height = 1;
 	eti->needs_compute_width = 1;
-	e_canvas_item_request_reflow (GNOME_CANVAS_ITEM (eti));
+	e_canvas_item_request_reflow (FOO_CANVAS_ITEM (eti));
 	eti->needs_redraw = 1;
-	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (eti));
+	foo_canvas_item_request_update (FOO_CANVAS_ITEM (eti));
 }
 
 static void
-eti_unrealize (GnomeCanvasItem *item)
+eti_unrealize (FooCanvasItem *item)
 {
 	ETableItem *eti = E_TABLE_ITEM (item);
 
@@ -1725,7 +1725,7 @@ eti_unrealize (GnomeCanvasItem *item)
 	eti->height_cache = NULL;
 	eti->height_cache_idle_count = 0;
 
-	e_canvas_hide_tooltip (E_CANVAS(GNOME_CANVAS_ITEM(eti)->canvas));
+	e_canvas_hide_tooltip (E_CANVAS(FOO_CANVAS_ITEM(eti)->canvas));
 	if (eti->tooltip) {
 		if (eti->tooltip->background) {
 			gdk_color_free (eti->tooltip->background);
@@ -1754,12 +1754,12 @@ eti_unrealize (GnomeCanvasItem *item)
 
 	eti->height = 0;
 
-	if (GNOME_CANVAS_ITEM_CLASS (eti_parent_class)->unrealize)
-                (*GNOME_CANVAS_ITEM_CLASS (eti_parent_class)->unrealize)(item);
+	if (FOO_CANVAS_ITEM_CLASS (eti_parent_class)->unrealize)
+                (*FOO_CANVAS_ITEM_CLASS (eti_parent_class)->unrealize)(item);
 }
 
 static void
-eti_draw (GnomeCanvasItem *item, GdkDrawable *drawable, gint x, gint y, gint width, gint height)
+eti_draw (FooCanvasItem *item, GdkDrawable *drawable, gint x, gint y, gint width, gint height)
 {
 	ETableItem *eti = E_TABLE_ITEM (item);
 	const gint rows = eti->rows;
@@ -1781,7 +1781,7 @@ eti_draw (GnomeCanvasItem *item, GdkDrawable *drawable, gint x, gint y, gint wid
 	/*
 	 * Find out our real position after grouping
 	 */
-	gnome_canvas_item_i2c_affine (item, i2c);
+	foo_canvas_item_i2c_affine (item, i2c);
 	eti_base_item.x = eti->x1;
 	eti_base_item.y = eti->y1;
 	art_affine_point (&eti_base, &eti_base_item, i2c);
@@ -2057,8 +2057,8 @@ exit:
 }
 
 static double
-eti_point (GnomeCanvasItem *item, double x, double y, gint cx, gint cy,
-	   GnomeCanvasItem **actual_item)
+eti_point (FooCanvasItem *item, double x, double y, gint cx, gint cy,
+	   FooCanvasItem **actual_item)
 {
 	*actual_item = item;
 
@@ -2175,7 +2175,7 @@ _do_tooltip (ETableItem *eti)
 	gboolean selected;
 	gint cursor_row, cursor_col;
 
-	e_canvas_hide_tooltip (E_CANVAS(GNOME_CANVAS_ITEM(eti)->canvas));
+	e_canvas_hide_tooltip (E_CANVAS(FOO_CANVAS_ITEM(eti)->canvas));
 
 	if (eti_editing (eti))
 		return FALSE;
@@ -2257,7 +2257,7 @@ eti_e_cell_event     (ETableItem *item, ECellView *ecell_view, GdkEvent *event,
 
 /* FIXME: cursor */
 static gint
-eti_event (GnomeCanvasItem *item, GdkEvent *e)
+eti_event (FooCanvasItem *item, GdkEvent *e)
 {
 	ETableItem *eti = E_TABLE_ITEM (item);
 	ECellView *ecell_view;
@@ -2289,8 +2289,8 @@ eti_event (GnomeCanvasItem *item, GdkEvent *e)
 		switch (e->button.button) {
 		case 1: /* Fall through. */
 		case 2:
-			e_canvas_item_grab_focus(GNOME_CANVAS_ITEM(eti), TRUE);
-			gnome_canvas_item_w2i (item, &e->button.x, &e->button.y);
+			e_canvas_item_grab_focus(FOO_CANVAS_ITEM(eti), TRUE);
+			foo_canvas_item_w2i (item, &e->button.x, &e->button.y);
 
 			realx = e->button.x;
 			realy = e->button.y;
@@ -2379,8 +2379,8 @@ eti_event (GnomeCanvasItem *item, GdkEvent *e)
 
 			break;
 		case 3:
-			e_canvas_item_grab_focus(GNOME_CANVAS_ITEM(eti), TRUE);
-			gnome_canvas_item_w2i (item, &e->button.x, &e->button.y);
+			e_canvas_item_grab_focus(FOO_CANVAS_ITEM(eti), TRUE);
+			foo_canvas_item_w2i (item, &e->button.x, &e->button.y);
 			if (!find_cell (eti, e->button.x, e->button.y, &col, &row, &x1, &y1))
 				return TRUE;
 
@@ -2426,12 +2426,12 @@ eti_event (GnomeCanvasItem *item, GdkEvent *e)
 			g_source_remove (eti->tooltip->timer);
 			eti->tooltip->timer = 0;
 		}
-		e_canvas_hide_tooltip (E_CANVAS(GNOME_CANVAS_ITEM(eti)->canvas));
+		e_canvas_hide_tooltip (E_CANVAS(FOO_CANVAS_ITEM(eti)->canvas));
 		switch (e->button.button) {
 		case 1: /* Fall through. */
 		case 2:
 
-			gnome_canvas_item_w2i (item, &e->button.x, &e->button.y);
+			foo_canvas_item_w2i (item, &e->button.x, &e->button.y);
 #if d(!)0
 			{
 				gboolean cell_found = find_cell (eti, e->button.x, e->button.y, &col, &row, &x1, &y1);
@@ -2496,7 +2496,7 @@ eti_event (GnomeCanvasItem *item, GdkEvent *e)
 
 		if (eti->click_count >= 2) {
 
-			gnome_canvas_item_w2i (item, &e->button.x, &e->button.y);
+			foo_canvas_item_w2i (item, &e->button.x, &e->button.y);
 
 #if 0
 			if (!find_cell (eti, e->button.x, e->button.y, &current_col, &current_row, &x1, &y1))
@@ -2542,7 +2542,7 @@ eti_event (GnomeCanvasItem *item, GdkEvent *e)
 		double x1, y1;
 		gint cursor_col, cursor_row;
 
-		gnome_canvas_item_w2i (item, &e->motion.x, &e->motion.y);
+		foo_canvas_item_w2i (item, &e->motion.x, &e->motion.y);
 
 		if (eti->maybe_in_drag) {
 			if (abs (e->motion.x - eti->drag_x) >= 3 ||
@@ -2580,7 +2580,7 @@ eti_event (GnomeCanvasItem *item, GdkEvent *e)
 			     "cursor_col", &cursor_col,
 			     NULL);
 
-		e_canvas_hide_tooltip (E_CANVAS(GNOME_CANVAS_ITEM(eti)->canvas));
+		e_canvas_hide_tooltip (E_CANVAS(FOO_CANVAS_ITEM(eti)->canvas));
 
 #ifdef DO_TOOLTIPS
 		if (!g_getenv ("GAL_DONT_DO_TOOLTIPS")) {
@@ -2627,7 +2627,7 @@ eti_event (GnomeCanvasItem *item, GdkEvent *e)
 			g_source_remove (eti->tooltip->timer);
 			eti->tooltip->timer = 0;
 		}
-		e_canvas_hide_tooltip (E_CANVAS(GNOME_CANVAS_ITEM(eti)->canvas));
+		e_canvas_hide_tooltip (E_CANVAS(FOO_CANVAS_ITEM(eti)->canvas));
 
 		if (cursor_row == -1 && cursor_col == -1)
 			return FALSE;
@@ -2894,7 +2894,7 @@ eti_event (GnomeCanvasItem *item, GdkEvent *e)
 static void
 eti_style_set (ETableItem *eti, GtkStyle *previous_style)
 {
-	if (!(GTK_OBJECT_FLAGS(eti) & GNOME_CANVAS_ITEM_REALIZED))
+	if (!(GTK_OBJECT_FLAGS(eti) & FOO_CANVAS_ITEM_REALIZED))
 		return;
 
 	if (eti->cell_views_realized) {
@@ -2907,9 +2907,9 @@ eti_style_set (ETableItem *eti, GtkStyle *previous_style)
 	}
 
 	eti->needs_compute_height = 1;
-	e_canvas_item_request_reflow (GNOME_CANVAS_ITEM (eti));
+	e_canvas_item_request_reflow (FOO_CANVAS_ITEM (eti));
 	eti->needs_redraw = 1;
-	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (eti));
+	foo_canvas_item_request_update (FOO_CANVAS_ITEM (eti));
 
 	free_height_cache (eti);
 
@@ -2919,7 +2919,7 @@ eti_style_set (ETableItem *eti, GtkStyle *previous_style)
 static void
 eti_class_init (ETableItemClass *klass)
 {
-	GnomeCanvasItemClass *item_class = GNOME_CANVAS_ITEM_CLASS (klass);
+	FooCanvasItemClass *item_class = FOO_CANVAS_ITEM_CLASS (klass);
 	GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
 	object_class->dispose       = eti_dispose;
@@ -3205,7 +3205,7 @@ eti_cursor_change (ESelectionModel *selection, gint row, gint col, ETableItem *e
 {
 	gint view_row;
 
-	if (!(GTK_OBJECT_FLAGS(eti) & GNOME_CANVAS_ITEM_REALIZED))
+	if (!(GTK_OBJECT_FLAGS(eti) & FOO_CANVAS_ITEM_REALIZED))
 		return;
 
 	view_row = model_to_view_row(eti, row);
@@ -3227,7 +3227,7 @@ eti_cursor_change (ESelectionModel *selection, gint row, gint col, ETableItem *e
 		}
 	}
 
-	e_canvas_item_grab_focus(GNOME_CANVAS_ITEM(eti), FALSE);
+	e_canvas_item_grab_focus(FOO_CANVAS_ITEM(eti), FALSE);
 	if (eti_editing(eti))
 		e_table_item_leave_edit_(eti);
 	g_signal_emit (eti, eti_signals [CURSOR_CHANGE], 0,
@@ -3244,7 +3244,7 @@ eti_cursor_activated (ESelectionModel *selection, gint row, gint col, ETableItem
 	gint view_row;
 	gint view_col;
 
-	if (!(GTK_OBJECT_FLAGS(eti) & GNOME_CANVAS_ITEM_REALIZED))
+	if (!(GTK_OBJECT_FLAGS(eti) & FOO_CANVAS_ITEM_REALIZED))
 		return;
 
 	view_row = model_to_view_row(eti, row);
@@ -3272,17 +3272,17 @@ eti_cursor_activated (ESelectionModel *selection, gint row, gint col, ETableItem
 static void
 eti_selection_change (ESelectionModel *selection, ETableItem *eti)
 {
-	if (!(GTK_OBJECT_FLAGS(eti) & GNOME_CANVAS_ITEM_REALIZED))
+	if (!(GTK_OBJECT_FLAGS(eti) & FOO_CANVAS_ITEM_REALIZED))
 		return;
 
 	eti->needs_redraw = TRUE;
-	gnome_canvas_item_request_update(GNOME_CANVAS_ITEM(eti));
+	foo_canvas_item_request_update(FOO_CANVAS_ITEM(eti));
 }
 
 static void
 eti_selection_row_change (ESelectionModel *selection, gint row, ETableItem *eti)
 {
-	if (!(GTK_OBJECT_FLAGS(eti) & GNOME_CANVAS_ITEM_REALIZED))
+	if (!(GTK_OBJECT_FLAGS(eti) & FOO_CANVAS_ITEM_REALIZED))
 		return;
 
 	if (!eti->needs_redraw) {
@@ -3403,7 +3403,7 @@ e_table_item_compute_mouse_over (ETableItem        *eti,
 	realx = x;
 	realy = y;
 
-	gnome_canvas_item_w2i (GNOME_CANVAS_ITEM (eti), &realx, &realy);
+	foo_canvas_item_w2i (FOO_CANVAS_ITEM (eti), &realx, &realy);
 
 	if (!find_cell (eti, (gint)realx, (gint)realy, col, row, NULL, NULL)) {
 		*row = -1;
diff --git a/widgets/table/e-table-item.h b/widgets/table/e-table-item.h
index 8cc4b54..9cb53b1 100644
--- a/widgets/table/e-table-item.h
+++ b/widgets/table/e-table-item.h
@@ -25,7 +25,7 @@
 #ifndef _E_TABLE_ITEM_H_
 #define _E_TABLE_ITEM_H_
 
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 #include <table/e-table-model.h>
 #include <table/e-table-header.h>
 #include <table/e-table-defines.h>
@@ -42,7 +42,7 @@ G_BEGIN_DECLS
 #define E_IS_TABLE_ITEM_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TABLE_ITEM_TYPE))
 
 typedef struct {
-	GnomeCanvasItem  parent;
+	FooCanvasItem  parent;
 	ETableModel     *table_model;
 	ETableHeader    *header;
 
@@ -167,7 +167,7 @@ typedef struct {
 } ETableItem;
 
 typedef struct {
-	GnomeCanvasItemClass parent_class;
+	FooCanvasItemClass parent_class;
 
 	void        (*cursor_change)    (ETableItem *eti, gint row);
 	void        (*cursor_activated) (ETableItem *eti, gint row);
diff --git a/widgets/table/e-table-tooltip.h b/widgets/table/e-table-tooltip.h
index 27dcf26..ec397f9 100644
--- a/widgets/table/e-table-tooltip.h
+++ b/widgets/table/e-table-tooltip.h
@@ -23,7 +23,7 @@
 #ifndef _E_TABLE_TOOLTIP_H_
 #define _E_TABLE_TOOLTIP_H_
 
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 
 G_BEGIN_DECLS
 
@@ -35,7 +35,7 @@ typedef struct {
 	gint cx, cy;
 	GdkColor *foreground;
 	GdkColor *background;
-	GnomeCanvasItem *eti;
+	FooCanvasItem *eti;
 } ETableTooltip;
 
 G_END_DECLS
diff --git a/widgets/table/e-table.c b/widgets/table/e-table.c
index 2656f7f..ece6c30 100644
--- a/widgets/table/e-table.c
+++ b/widgets/table/e-table.c
@@ -33,8 +33,8 @@
 #include <glib/gstdio.h>
 #include <gdk/gdkkeysyms.h>
 #include <gtk/gtk.h>
-#include <libgnomecanvas/gnome-canvas.h>
-#include <libgnomecanvas/gnome-canvas-rect-ellipse.h>
+#include <libfoocanvas/foo-canvas.h>
+#include <libfoocanvas/foo-canvas-rect-ellipse.h>
 
 #include "gal-a11y-e-table.h"
 #include <glib/gi18n.h>
@@ -598,15 +598,15 @@ set_header_canvas_width (ETable *e_table)
 	if (!(e_table->header_item && e_table->header_canvas && e_table->table_canvas))
 		return;
 
-	gnome_canvas_get_scroll_region (GNOME_CANVAS (e_table->table_canvas),
+	foo_canvas_get_scroll_region (FOO_CANVAS (e_table->table_canvas),
 					NULL, NULL, &width, NULL);
-	gnome_canvas_get_scroll_region (GNOME_CANVAS (e_table->header_canvas),
+	foo_canvas_get_scroll_region (FOO_CANVAS (e_table->header_canvas),
 					NULL, NULL, &oldwidth, &oldheight);
 
 	if (oldwidth != width ||
 	    oldheight != E_TABLE_HEADER_ITEM (e_table->header_item)->height - 1)
-		gnome_canvas_set_scroll_region (
-						GNOME_CANVAS (e_table->header_canvas),
+		foo_canvas_set_scroll_region (
+						FOO_CANVAS (e_table->header_canvas),
 						0, 0, width, /*  COLUMN_HEADER_HEIGHT - 1 */
 						E_TABLE_HEADER_ITEM (e_table->header_item)->height - 1);
 
@@ -656,14 +656,14 @@ static void
 e_table_setup_header (ETable *e_table)
 {
 	gchar *pointer;
-	e_table->header_canvas = GNOME_CANVAS (e_canvas_new ());
+	e_table->header_canvas = FOO_CANVAS (e_canvas_new ());
 
 	gtk_widget_show (GTK_WIDGET (e_table->header_canvas));
 
 	pointer = g_strdup_printf("%p", (gpointer) e_table);
 
-	e_table->header_item = gnome_canvas_item_new (
-		gnome_canvas_root (e_table->header_canvas),
+	e_table->header_item = foo_canvas_item_new (
+		foo_canvas_root (e_table->header_canvas),
 		e_table_header_item_get_type (),
 		"ETableHeader", e_table->header,
 		"full_header", e_table->full_header,
@@ -697,12 +697,12 @@ table_canvas_reflow_idle (ETable *e_table)
 	height = MAX ((gint)height, alloc->height);
 	width = MAX((gint)width, alloc->width);
 	/* I have no idea why this needs to be -1, but it works. */
-	gnome_canvas_get_scroll_region (GNOME_CANVAS (e_table->table_canvas),
+	foo_canvas_get_scroll_region (FOO_CANVAS (e_table->table_canvas),
 					NULL, NULL, &oldwidth, &oldheight);
 
 	if (oldwidth != width - 1 ||
 	    oldheight != height - 1) {
-		gnome_canvas_set_scroll_region (GNOME_CANVAS (e_table->table_canvas),
+		foo_canvas_set_scroll_region (FOO_CANVAS (e_table->table_canvas),
 						0, 0, width - 1, height - 1);
 		set_header_canvas_width (e_table);
 	}
@@ -737,7 +737,7 @@ table_canvas_size_allocate (GtkWidget *widget, GtkAllocation *alloc,
 }
 
 static void
-table_canvas_reflow (GnomeCanvas *canvas, ETable *e_table)
+table_canvas_reflow (FooCanvas *canvas, ETable *e_table)
 {
 	if (!e_table->reflow_idle_id)
 		e_table->reflow_idle_id = g_idle_add_full (400, (GSourceFunc) table_canvas_reflow_idle, e_table, NULL);
@@ -924,7 +924,7 @@ et_build_groups (ETable *et)
 
 	et->is_grouped = e_table_sort_info_grouping_get_count(et->sort_info) > 0;
 
-	et->group = e_table_group_new (GNOME_CANVAS_GROUP (et->canvas_vbox),
+	et->group = e_table_group_new (FOO_CANVAS_GROUP (et->canvas_vbox),
 				       et->full_header,
 				       et->header,
 				       et->model,
@@ -932,11 +932,11 @@ et_build_groups (ETable *et)
 				       0);
 
 	if (et->use_click_to_add_end)
-		e_canvas_vbox_add_item_start(E_CANVAS_VBOX(et->canvas_vbox), GNOME_CANVAS_ITEM(et->group));
+		e_canvas_vbox_add_item_start(E_CANVAS_VBOX(et->canvas_vbox), FOO_CANVAS_ITEM(et->group));
 	else
-		e_canvas_vbox_add_item(E_CANVAS_VBOX(et->canvas_vbox), GNOME_CANVAS_ITEM(et->group));
+		e_canvas_vbox_add_item(E_CANVAS_VBOX(et->canvas_vbox), FOO_CANVAS_ITEM(et->group));
 
-	gnome_canvas_item_set(GNOME_CANVAS_ITEM(et->group),
+	foo_canvas_item_set(FOO_CANVAS_ITEM(et->group),
 			      "alternating_row_colors", et->alternating_row_colors,
 			      "horizontal_draw_grid", et->horizontal_draw_grid,
 			      "vertical_draw_grid", et->vertical_draw_grid,
@@ -1015,7 +1015,7 @@ changed_idle (gpointer data)
 static void
 et_canvas_realize (GtkWidget *canvas, ETable *e_table)
 {
-	gnome_canvas_item_set(
+	foo_canvas_item_set(
 		e_table->white_item,
 		"fill_color_gdk", &GTK_WIDGET(e_table->table_canvas)->style->base[GTK_STATE_NORMAL],
 		NULL);
@@ -1025,7 +1025,7 @@ et_canvas_realize (GtkWidget *canvas, ETable *e_table)
 }
 
 static gint
-white_item_event (GnomeCanvasItem *white_item, GdkEvent *event, ETable *e_table)
+white_item_event (FooCanvasItem *white_item, GdkEvent *event, ETable *e_table)
 {
 	gint return_val = 0;
 	g_signal_emit (GTK_OBJECT (e_table), et_signals [WHITE_SPACE_EVENT], 0,
@@ -1036,10 +1036,10 @@ white_item_event (GnomeCanvasItem *white_item, GdkEvent *event, ETable *e_table)
 static void
 et_eti_leave_edit (ETable *et)
 {
-	GnomeCanvas *canvas = et->table_canvas;
+	FooCanvas *canvas = et->table_canvas;
 
 	if (GTK_WIDGET_HAS_FOCUS(canvas)) {
-		GnomeCanvasItem *item = GNOME_CANVAS(canvas)->focused_item;
+		FooCanvasItem *item = FOO_CANVAS(canvas)->focused_item;
 
 		if (E_IS_TABLE_ITEM(item)) {
 			e_table_item_leave_edit_(E_TABLE_ITEM(item));
@@ -1048,7 +1048,7 @@ et_eti_leave_edit (ETable *et)
 }
 
 static gint
-et_canvas_root_event (GnomeCanvasItem *root, GdkEvent *event, ETable *e_table)
+et_canvas_root_event (FooCanvasItem *root, GdkEvent *event, ETable *e_table)
 {
 	switch (event->type) {
 	case GDK_BUTTON_PRESS:
@@ -1070,21 +1070,21 @@ et_canvas_root_event (GnomeCanvasItem *root, GdkEvent *event, ETable *e_table)
 static void
 focus_first_etable_item (ETableGroup *group)
 {
-	GnomeCanvasGroup *cgroup;
+	FooCanvasGroup *cgroup;
 	GList *l;
 
-	cgroup = GNOME_CANVAS_GROUP (group);
+	cgroup = FOO_CANVAS_GROUP (group);
 
 	for (l = cgroup->item_list; l; l = l->next) {
-		GnomeCanvasItem *i;
+		FooCanvasItem *i;
 
-		i = GNOME_CANVAS_ITEM (l->data);
+		i = FOO_CANVAS_ITEM (l->data);
 
 		if (E_IS_TABLE_GROUP (i))
 			focus_first_etable_item (E_TABLE_GROUP (i));
 		else if (E_IS_TABLE_ITEM (i)) {
 			e_table_item_set_cursor (E_TABLE_ITEM (i), 0, 0);
-			gnome_canvas_item_grab_focus (i);
+			foo_canvas_item_grab_focus (i);
 		}
 	}
 }
@@ -1095,12 +1095,12 @@ focus_first_etable_item (ETableGroup *group)
 static gint
 table_canvas_focus_event_cb (GtkWidget *widget, GdkEventFocus *event, gpointer data)
 {
-	GnomeCanvas *canvas;
+	FooCanvas *canvas;
 	ECanvas *ecanvas;
 	ETable *etable;
 
 	gtk_widget_queue_draw (widget);
-	canvas = GNOME_CANVAS (widget);
+	canvas = FOO_CANVAS (widget);
 	ecanvas = E_CANVAS (widget);
 
 	if (!event->in) {
@@ -1115,8 +1115,8 @@ table_canvas_focus_event_cb (GtkWidget *widget, GdkEventFocus *event, gpointer d
 	if (e_table_model_row_count(etable->model) < 1
 	    && (etable->click_to_add)
 	    && !(E_TABLE_CLICK_TO_ADD(etable->click_to_add)->row)) {
-		gnome_canvas_item_grab_focus (etable->canvas_vbox);
-		gnome_canvas_item_grab_focus (etable->click_to_add);
+		foo_canvas_item_grab_focus (etable->canvas_vbox);
+		foo_canvas_item_grab_focus (etable->click_to_add);
 	} else if (!canvas->focused_item && etable->group) {
 		focus_first_etable_item (etable->group);
 	} else if (canvas->focused_item) {
@@ -1124,7 +1124,7 @@ table_canvas_focus_event_cb (GtkWidget *widget, GdkEventFocus *event, gpointer d
 
 		/* check whether click_to_add already got the focus */
 		if (etable->click_to_add) {
-			GnomeCanvasItem *row = E_TABLE_CLICK_TO_ADD(etable->click_to_add)->row;
+			FooCanvasItem *row = E_TABLE_CLICK_TO_ADD(etable->click_to_add)->row;
 			if (canvas->focused_item == row)
 				return TRUE;
 		}
@@ -1148,7 +1148,7 @@ canvas_vbox_event (ECanvasVbox *vbox, GdkEventKey *key, ETable *etable)
 		case GDK_KP_Tab:
 		case GDK_ISO_Left_Tab:
 			if ((key->state & GDK_CONTROL_MASK) && etable->click_to_add) {
-				gnome_canvas_item_grab_focus (etable->click_to_add);
+				foo_canvas_item_grab_focus (etable->click_to_add);
 				break;
 			}
 		default:
@@ -1190,7 +1190,7 @@ static void
 e_table_setup_table (ETable *e_table, ETableHeader *full_header, ETableHeader *header,
 		     ETableModel *model)
 {
-	e_table->table_canvas = GNOME_CANVAS (e_canvas_new ());
+	e_table->table_canvas = FOO_CANVAS (e_canvas_new ());
 	g_signal_connect (
 		G_OBJECT (e_table->table_canvas), "size_allocate",
 		G_CALLBACK (table_canvas_size_allocate), e_table);
@@ -1231,8 +1231,8 @@ e_table_setup_table (ETable *e_table, ETableHeader *full_header, ETableHeader *h
 
 	gtk_widget_show (GTK_WIDGET (e_table->table_canvas));
 
-	e_table->white_item = gnome_canvas_item_new(
-		gnome_canvas_root(e_table->table_canvas),
+	e_table->white_item = foo_canvas_item_new(
+		foo_canvas_root(e_table->table_canvas),
 		e_canvas_background_get_type(),
 		"fill_color_gdk", &GTK_WIDGET(e_table->table_canvas)->style->base[GTK_STATE_NORMAL],
 		NULL);
@@ -1243,11 +1243,11 @@ e_table_setup_table (ETable *e_table, ETableHeader *full_header, ETableHeader *h
 	g_signal_connect (G_OBJECT(e_table->table_canvas), "realize",
 			  G_CALLBACK(et_canvas_realize), e_table);
 
-	g_signal_connect (G_OBJECT(gnome_canvas_root (e_table->table_canvas)), "event",
+	g_signal_connect (G_OBJECT(foo_canvas_root (e_table->table_canvas)), "event",
 			  G_CALLBACK(et_canvas_root_event), e_table);
 
-	e_table->canvas_vbox = gnome_canvas_item_new(
-		gnome_canvas_root(e_table->table_canvas),
+	e_table->canvas_vbox = foo_canvas_item_new(
+		foo_canvas_root(e_table->table_canvas),
 		e_canvas_vbox_get_type(),
 		"spacing", 10.0,
 		NULL);
@@ -1259,8 +1259,8 @@ e_table_setup_table (ETable *e_table, ETableHeader *full_header, ETableHeader *h
 	et_build_groups(e_table);
 
 	if (e_table->use_click_to_add) {
-		e_table->click_to_add = gnome_canvas_item_new (
-			GNOME_CANVAS_GROUP(e_table->canvas_vbox),
+		e_table->click_to_add = foo_canvas_item_new (
+			FOO_CANVAS_GROUP(e_table->canvas_vbox),
 			e_table_click_to_add_get_type (),
 			"header", e_table->header,
 			"model", e_table->model,
@@ -2161,7 +2161,7 @@ et_set_property (GObject *object,
 	case PROP_LENGTH_THRESHOLD:
 		etable->length_threshold = g_value_get_int (value);
 		if (etable->group) {
-			gnome_canvas_item_set (GNOME_CANVAS_ITEM(etable->group),
+			foo_canvas_item_set (FOO_CANVAS_ITEM(etable->group),
 					       "length_threshold", etable->length_threshold,
 					       NULL);
 		}
@@ -2169,7 +2169,7 @@ et_set_property (GObject *object,
 	case PROP_UNIFORM_ROW_HEIGHT:
 		etable->uniform_row_height = g_value_get_boolean (value);
 		if (etable->group) {
-			gnome_canvas_item_set (GNOME_CANVAS_ITEM(etable->group),
+			foo_canvas_item_set (FOO_CANVAS_ITEM(etable->group),
 					       "uniform_row_height", etable->uniform_row_height,
 					       NULL);
 		}
@@ -2189,8 +2189,8 @@ et_set_property (GObject *object,
 		clear_current_search_col (etable);
 
 		if (etable->use_click_to_add) {
-			etable->click_to_add = gnome_canvas_item_new
-				(GNOME_CANVAS_GROUP(etable->canvas_vbox),
+			etable->click_to_add = foo_canvas_item_new
+				(FOO_CANVAS_GROUP(etable->canvas_vbox),
 				 e_table_click_to_add_get_type (),
 				 "header", etable->header,
 				 "model", etable->model,
@@ -2577,15 +2577,15 @@ e_table_drag_highlight (ETable *table,
 
 		if (table->drop_highlight == NULL) {
 			table->drop_highlight =
-				gnome_canvas_item_new (gnome_canvas_root (table->table_canvas),
-						       gnome_canvas_rect_get_type (),
+				foo_canvas_item_new (foo_canvas_root (table->table_canvas),
+						       foo_canvas_rect_get_type (),
 						       "fill_color", NULL,
 						       /*						       "outline_color", "black",
 						       "width_pixels", 1,*/
 						       "outline_color_gdk", &(GTK_WIDGET (table)->style->fg[GTK_STATE_NORMAL]),
 						       NULL);
 		}
-		gnome_canvas_item_set (table->drop_highlight,
+		foo_canvas_item_set (table->drop_highlight,
 				       "x1", (double) x,
 				       "x2", (double) x + width - 1,
 				       "y1", (double) y,
diff --git a/widgets/table/e-table.h b/widgets/table/e-table.h
index bb82ef1..2282caa 100644
--- a/widgets/table/e-table.h
+++ b/widgets/table/e-table.h
@@ -24,7 +24,7 @@
 #ifndef _E_TABLE_H_
 #define _E_TABLE_H_
 
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 #include <gtk/gtk.h>
 #include <libxml/tree.h>
 #include <table/e-table-model.h>
@@ -63,7 +63,7 @@ typedef struct {
 
 	ETableHeader *full_header, *header;
 
-	GnomeCanvasItem *canvas_vbox;
+	FooCanvasItem *canvas_vbox;
 	ETableGroup  *group;
 
 	ETableSortInfo *sort_info;
@@ -96,11 +96,11 @@ typedef struct {
 	gint reflow_idle_id;
 	gint scroll_idle_id;
 
-	GnomeCanvas *header_canvas, *table_canvas;
+	FooCanvas *header_canvas, *table_canvas;
 
-	GnomeCanvasItem *header_item, *root;
+	FooCanvasItem *header_item, *root;
 
-	GnomeCanvasItem *white_item;
+	FooCanvasItem *white_item;
 
 	gint length_threshold;
 
@@ -132,7 +132,7 @@ typedef struct {
 	guint search_col_set : 1;
 
 	gchar *click_to_add_message;
-	GnomeCanvasItem *click_to_add;
+	FooCanvasItem *click_to_add;
 	gboolean use_click_to_add;
 	gboolean use_click_to_add_end;
 
@@ -140,7 +140,7 @@ typedef struct {
 
 	gint drop_row;
 	gint drop_col;
-	GnomeCanvasItem *drop_highlight;
+	FooCanvasItem *drop_highlight;
 	gint last_drop_x;
 	gint last_drop_y;
 	gint last_drop_time;
diff --git a/widgets/table/e-tree.c b/widgets/table/e-tree.c
index ba50be0..13c0ce8 100644
--- a/widgets/table/e-tree.c
+++ b/widgets/table/e-tree.c
@@ -28,7 +28,7 @@
 
 #include <gdk/gdkkeysyms.h>
 #include <gtk/gtk.h>
-#include <libgnomecanvas/gnome-canvas-rect-ellipse.h>
+#include <libfoocanvas/foo-canvas-rect-ellipse.h>
 
 #include "gal-a11y-e-tree.h"
 #include <glib/gi18n.h>
@@ -142,15 +142,15 @@ struct ETreePriv {
 	gint table_cell_change_id;
 	gint table_rows_delete_id;
 
-	GnomeCanvasItem *info_text;
+	FooCanvasItem *info_text;
 	guint info_text_resize_id;
 
-	GnomeCanvas *header_canvas, *table_canvas;
+	FooCanvas *header_canvas, *table_canvas;
 
-	GnomeCanvasItem *header_item, *root;
+	FooCanvasItem *header_item, *root;
 
-	GnomeCanvasItem *white_item;
-	GnomeCanvasItem *item;
+	FooCanvasItem *white_item;
+	FooCanvasItem *item;
 
 	gint length_threshold;
 
@@ -180,7 +180,7 @@ struct ETreePriv {
 	ETreePath drop_path;
 	gint drop_col;
 
-	GnomeCanvasItem *drop_highlight;
+	FooCanvasItem *drop_highlight;
 	gint last_drop_x;
 	gint last_drop_y;
 	gint last_drop_time;
@@ -670,15 +670,15 @@ set_header_canvas_width (ETree *e_tree)
 	if (!(e_tree->priv->header_item && e_tree->priv->header_canvas && e_tree->priv->table_canvas))
 		return;
 
-	gnome_canvas_get_scroll_region (GNOME_CANVAS (e_tree->priv->table_canvas),
+	foo_canvas_get_scroll_region (FOO_CANVAS (e_tree->priv->table_canvas),
 					NULL, NULL, &width, NULL);
-	gnome_canvas_get_scroll_region (GNOME_CANVAS (e_tree->priv->header_canvas),
+	foo_canvas_get_scroll_region (FOO_CANVAS (e_tree->priv->header_canvas),
 					NULL, NULL, &oldwidth, &oldheight);
 
 	if (oldwidth != width ||
 	    oldheight != E_TABLE_HEADER_ITEM (e_tree->priv->header_item)->height - 1)
-		gnome_canvas_set_scroll_region (
-						GNOME_CANVAS (e_tree->priv->header_canvas),
+		foo_canvas_set_scroll_region (
+						FOO_CANVAS (e_tree->priv->header_canvas),
 						0, 0, width, /*  COLUMN_HEADER_HEIGHT - 1 */
 						E_TABLE_HEADER_ITEM (e_tree->priv->header_item)->height - 1);
 
@@ -703,15 +703,15 @@ static void
 e_tree_setup_header (ETree *e_tree)
 {
 	gchar *pointer;
-	e_tree->priv->header_canvas = GNOME_CANVAS (e_canvas_new ());
+	e_tree->priv->header_canvas = FOO_CANVAS (e_canvas_new ());
 	GTK_WIDGET_UNSET_FLAGS (e_tree->priv->header_canvas, GTK_CAN_FOCUS);
 
 	gtk_widget_show (GTK_WIDGET (e_tree->priv->header_canvas));
 
 	pointer = g_strdup_printf("%p", (gpointer) e_tree);
 
-	e_tree->priv->header_item = gnome_canvas_item_new (
-		gnome_canvas_root (e_tree->priv->header_canvas),
+	e_tree->priv->header_item = foo_canvas_item_new (
+		foo_canvas_root (e_tree->priv->header_canvas),
 		e_table_header_item_get_type (),
 		"ETableHeader", e_tree->priv->header,
 		"full_header", e_tree->priv->full_header,
@@ -745,12 +745,12 @@ tree_canvas_reflow_idle (ETree *e_tree)
 	height = MAX ((gint)height, alloc->height);
 	width = MAX((gint)width, alloc->width);
 	/* I have no idea why this needs to be -1, but it works. */
-	gnome_canvas_get_scroll_region (GNOME_CANVAS (e_tree->priv->table_canvas),
+	foo_canvas_get_scroll_region (FOO_CANVAS (e_tree->priv->table_canvas),
 					NULL, NULL, &oldwidth, &oldheight);
 
 	if (oldwidth != width - 1 ||
 	    oldheight != height - 1) {
-		gnome_canvas_set_scroll_region (GNOME_CANVAS (e_tree->priv->table_canvas),
+		foo_canvas_set_scroll_region (FOO_CANVAS (e_tree->priv->table_canvas),
 						0, 0, width - 1, height - 1);
 		set_header_canvas_width (e_tree);
 	}
@@ -802,7 +802,7 @@ tree_canvas_size_allocate (GtkWidget *widget, GtkAllocation *alloc,
 }
 
 static void
-tree_canvas_reflow (GnomeCanvas *canvas, ETree *e_tree)
+tree_canvas_reflow (FooCanvas *canvas, ETree *e_tree)
 {
 	if (!e_tree->priv->reflow_idle_id)
 		e_tree->priv->reflow_idle_id = g_idle_add_full (400, (GSourceFunc) tree_canvas_reflow_idle, e_tree, NULL);
@@ -980,7 +980,7 @@ et_selection_model_selection_row_changed (ETableSelectionModel *etsm, gint row,
 static void
 et_build_item (ETree *et)
 {
-	et->priv->item = gnome_canvas_item_new(GNOME_CANVAS_GROUP (gnome_canvas_root(et->priv->table_canvas)),
+	et->priv->item = foo_canvas_item_new(FOO_CANVAS_GROUP (foo_canvas_root(et->priv->table_canvas)),
 					 e_table_item_get_type(),
 					 "ETableHeader", et->priv->header,
 					 "ETableModel", et->priv->etta,
@@ -1013,14 +1013,14 @@ et_build_item (ETree *et)
 static void
 et_canvas_style_set (GtkWidget *widget, GtkStyle *prev_style)
 {
-	gnome_canvas_item_set(
+	foo_canvas_item_set(
 		E_TREE(widget)->priv->white_item,
 		"fill_color_gdk", &widget->style->base[GTK_STATE_NORMAL],
 		NULL);
 }
 
 static gint
-white_item_event (GnomeCanvasItem *white_item, GdkEvent *event, ETree *e_tree)
+white_item_event (FooCanvasItem *white_item, GdkEvent *event, ETree *e_tree)
 {
 	gint return_val = 0;
 	g_signal_emit (e_tree,
@@ -1030,7 +1030,7 @@ white_item_event (GnomeCanvasItem *white_item, GdkEvent *event, ETree *e_tree)
 }
 
 static gint
-et_canvas_root_event (GnomeCanvasItem *root, GdkEvent *event, ETree *e_tree)
+et_canvas_root_event (FooCanvasItem *root, GdkEvent *event, ETree *e_tree)
 {
 	switch (event->type) {
 	case GDK_BUTTON_PRESS:
@@ -1038,7 +1038,7 @@ et_canvas_root_event (GnomeCanvasItem *root, GdkEvent *event, ETree *e_tree)
 	case GDK_BUTTON_RELEASE:
 		if (event->button.button != 4 && event->button.button != 5) {
 			if (GTK_WIDGET_HAS_FOCUS(root->canvas)) {
-				GnomeCanvasItem *item = GNOME_CANVAS(root->canvas)->focused_item;
+				FooCanvasItem *item = FOO_CANVAS(root->canvas)->focused_item;
 
 				if (E_IS_TABLE_ITEM(item)) {
 					e_table_item_leave_edit_(E_TABLE_ITEM(item));
@@ -1060,7 +1060,7 @@ et_canvas_root_event (GnomeCanvasItem *root, GdkEvent *event, ETree *e_tree)
 static gint
 table_canvas_focus_event_cb (GtkWidget *widget, GdkEventFocus *event, gpointer data)
 {
-	GnomeCanvas *canvas;
+	FooCanvas *canvas;
 	ETree *tree;
 
 	gtk_widget_queue_draw (widget);
@@ -1068,12 +1068,12 @@ table_canvas_focus_event_cb (GtkWidget *widget, GdkEventFocus *event, gpointer d
 	if (!event->in)
 		return TRUE;
 
-	canvas = GNOME_CANVAS (widget);
+	canvas = FOO_CANVAS (widget);
 	tree = E_TREE (data);
 
 	if (!canvas->focused_item || (e_selection_model_cursor_row (tree->priv->selection) == -1)) {
 		e_table_item_set_cursor (E_TABLE_ITEM (tree->priv->item), 0, 0);
-		gnome_canvas_item_grab_focus (tree->priv->item);
+		foo_canvas_item_grab_focus (tree->priv->item);
 	}
 
 	return TRUE;
@@ -1082,7 +1082,7 @@ table_canvas_focus_event_cb (GtkWidget *widget, GdkEventFocus *event, gpointer d
 static void
 e_tree_setup_table (ETree *e_tree)
 {
-	e_tree->priv->table_canvas = GNOME_CANVAS (e_canvas_new ());
+	e_tree->priv->table_canvas = FOO_CANVAS (e_canvas_new ());
 	g_signal_connect (
 		e_tree->priv->table_canvas, "size_allocate",
 		G_CALLBACK (tree_canvas_size_allocate), e_tree);
@@ -1123,8 +1123,8 @@ e_tree_setup_table (ETree *e_tree)
 
 	gtk_widget_show (GTK_WIDGET (e_tree->priv->table_canvas));
 
-	e_tree->priv->white_item = gnome_canvas_item_new(
-		gnome_canvas_root(e_tree->priv->table_canvas),
+	e_tree->priv->white_item = foo_canvas_item_new(
+		foo_canvas_root(e_tree->priv->table_canvas),
 		e_canvas_background_get_type(),
 		"fill_color_gdk", &GTK_WIDGET(e_tree->priv->table_canvas)->style->base[GTK_STATE_NORMAL],
 		NULL);
@@ -1132,7 +1132,7 @@ e_tree_setup_table (ETree *e_tree)
 	g_signal_connect (e_tree->priv->white_item, "event",
 			  G_CALLBACK (white_item_event), e_tree);
 	g_signal_connect (
-		gnome_canvas_root (e_tree->priv->table_canvas), "event",
+		foo_canvas_root (e_tree->priv->table_canvas), "event",
 		G_CALLBACK(et_canvas_root_event), e_tree);
 
 	et_build_item(e_tree);
@@ -1845,7 +1845,7 @@ et_set_property (GObject *object,
 	case PROP_LENGTH_THRESHOLD:
 		etree->priv->length_threshold = g_value_get_int (value);
 		if (etree->priv->item) {
-			gnome_canvas_item_set (GNOME_CANVAS_ITEM(etree->priv->item),
+			foo_canvas_item_set (FOO_CANVAS_ITEM(etree->priv->item),
 					       "length_threshold", etree->priv->length_threshold,
 					       NULL);
 		}
@@ -1854,7 +1854,7 @@ et_set_property (GObject *object,
 	case PROP_HORIZONTAL_DRAW_GRID:
 		etree->priv->horizontal_draw_grid = g_value_get_boolean (value);
 		if (etree->priv->item) {
-			gnome_canvas_item_set (GNOME_CANVAS_ITEM(etree->priv->item),
+			foo_canvas_item_set (FOO_CANVAS_ITEM(etree->priv->item),
 					       "horizontal_draw_grid", etree->priv->horizontal_draw_grid,
 					       NULL);
 		}
@@ -1863,7 +1863,7 @@ et_set_property (GObject *object,
 	case PROP_VERTICAL_DRAW_GRID:
 		etree->priv->vertical_draw_grid = g_value_get_boolean (value);
 		if (etree->priv->item) {
-			gnome_canvas_item_set (GNOME_CANVAS_ITEM(etree->priv->item),
+			foo_canvas_item_set (FOO_CANVAS_ITEM(etree->priv->item),
 					       "vertical_draw_grid", etree->priv->vertical_draw_grid,
 					       NULL);
 		}
@@ -1872,7 +1872,7 @@ et_set_property (GObject *object,
 	case PROP_DRAW_FOCUS:
 		etree->priv->draw_focus = g_value_get_boolean (value);
 		if (etree->priv->item) {
-			gnome_canvas_item_set (GNOME_CANVAS_ITEM(etree->priv->item),
+			foo_canvas_item_set (FOO_CANVAS_ITEM(etree->priv->item),
 					       "drawfocus", etree->priv->draw_focus,
 					       NULL);
 		}
@@ -1881,7 +1881,7 @@ et_set_property (GObject *object,
 	case PROP_UNIFORM_ROW_HEIGHT:
 		etree->priv->uniform_row_height = g_value_get_boolean (value);
 		if (etree->priv->item) {
-			gnome_canvas_item_set (GNOME_CANVAS_ITEM(etree->priv->item),
+			foo_canvas_item_set (FOO_CANVAS_ITEM(etree->priv->item),
 					       "uniform_row_height", etree->priv->uniform_row_height,
 					       NULL);
 		}
@@ -2243,7 +2243,7 @@ e_tree_get_item(ETree * et)
 	return E_TABLE_ITEM (et->priv->item);
 }
 
-GnomeCanvasItem *
+FooCanvasItem *
 e_tree_get_header_item(ETree * et)
 {
 	g_return_val_if_fail (et != NULL, NULL);
@@ -2371,15 +2371,15 @@ e_tree_drag_highlight (ETree *tree,
 
 		if (tree->priv->drop_highlight == NULL) {
 			tree->priv->drop_highlight =
-				gnome_canvas_item_new (gnome_canvas_root (tree->priv->table_canvas),
-						       gnome_canvas_rect_get_type (),
+				foo_canvas_item_new (foo_canvas_root (tree->priv->table_canvas),
+						       foo_canvas_rect_get_type (),
 						       "fill_color", NULL,
 						       /*						       "outline_color", "black",
 						       "width_pixels", 1,*/
 						       "outline_color_gdk", &(GTK_WIDGET (tree)->style->fg[GTK_STATE_NORMAL]),
 						       NULL);
 		}
-		gnome_canvas_item_set (tree->priv->drop_highlight,
+		foo_canvas_item_set (tree->priv->drop_highlight,
 				       "x1", (double) x,
 				       "x2", (double) x + width - 1,
 				       "y1", (double) y,
@@ -3407,7 +3407,7 @@ tree_size_allocate (GtkWidget *widget, GtkAllocation *alloc, ETree *tree)
 	g_return_if_fail (tree->priv != NULL);
 	g_return_if_fail (tree->priv->info_text != NULL);
 
-	gnome_canvas_get_scroll_region (GNOME_CANVAS (tree->priv->table_canvas), NULL, NULL, &width, NULL);
+	foo_canvas_get_scroll_region (FOO_CANVAS (tree->priv->table_canvas), NULL, NULL, &width, NULL);
 
 	width -= 60.0;
 
@@ -3438,7 +3438,7 @@ e_tree_set_info_message (ETree *tree, const gchar *info_message)
 	}
 
 	if (!tree->priv->info_text) {
-		tree->priv->info_text = gnome_canvas_item_new (GNOME_CANVAS_GROUP (gnome_canvas_root (tree->priv->table_canvas)),
+		tree->priv->info_text = foo_canvas_item_new (FOO_CANVAS_GROUP (foo_canvas_root (tree->priv->table_canvas)),
 						e_text_get_type (),
 						"anchor", GTK_ANCHOR_NW,
 						"line_wrap", TRUE,
@@ -3454,5 +3454,5 @@ e_tree_set_info_message (ETree *tree, const gchar *info_message)
 
 		tree->priv->info_text_resize_id = g_signal_connect (tree, "size_allocate", G_CALLBACK (tree_size_allocate), tree);
 	} else
-		gnome_canvas_item_set (tree->priv->info_text, "text", info_message, NULL);
+		foo_canvas_item_set (tree->priv->info_text, "text", info_message, NULL);
 }
diff --git a/widgets/table/e-tree.h b/widgets/table/e-tree.h
index b746156..2c558e9 100644
--- a/widgets/table/e-tree.h
+++ b/widgets/table/e-tree.h
@@ -25,7 +25,7 @@
 
 #include <gtk/gtk.h>
 #include <libxml/tree.h>
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 #include <misc/e-printable.h>
 
 #include <table/e-table-extras.h>
@@ -309,7 +309,7 @@ void            e_tree_right_click_up             (ETree                *et);
 
 ETableItem *	e_tree_get_item(ETree * et);
 
-GnomeCanvasItem * e_tree_get_header_item(ETree * et);
+FooCanvasItem * e_tree_get_header_item(ETree * et);
 
 void e_tree_set_info_message (ETree *tree, const gchar *info_message);
 
diff --git a/widgets/table/gal-a11y-e-cell-popup.c b/widgets/table/gal-a11y-e-cell-popup.c
index 141ce17..2341cbd 100644
--- a/widgets/table/gal-a11y-e-cell-popup.c
+++ b/widgets/table/gal-a11y-e-cell-popup.c
@@ -134,7 +134,7 @@ popup_cell_action (GalA11yECell *cell)
 	GdkEvent event;
 
 	event.key.type = GDK_KEY_PRESS;
-	event.key.window = GTK_LAYOUT(GNOME_CANVAS_ITEM(cell->item)->canvas)->bin_window;;
+	event.key.window = GTK_LAYOUT(FOO_CANVAS_ITEM(cell->item)->canvas)->bin_window;;
 	event.key.send_event = TRUE;
 	event.key.time = GDK_CURRENT_TIME;
 	event.key.state = GDK_MOD1_MASK;
diff --git a/widgets/table/gal-a11y-e-cell-toggle.c b/widgets/table/gal-a11y-e-cell-toggle.c
index fa23f6c..d0d5e95 100644
--- a/widgets/table/gal-a11y-e-cell-toggle.c
+++ b/widgets/table/gal-a11y-e-cell-toggle.c
@@ -100,11 +100,11 @@ toggle_cell_action (GalA11yECell *cell)
 	e_table_item_get_cell_geometry (cell->item, &row, &col,
 					&x, &y, &width, &height);
 
-	event.x = x + width / 2 + (gint)(GNOME_CANVAS_ITEM (cell->item)->x1);
-	event.y = y + height / 2 + (gint)(GNOME_CANVAS_ITEM (cell->item)->y1);
+	event.x = x + width / 2 + (gint)(FOO_CANVAS_ITEM (cell->item)->x1);
+	event.y = y + height / 2 + (gint)(FOO_CANVAS_ITEM (cell->item)->y1);
 
 	event.type = GDK_BUTTON_PRESS;
-	event.window = GTK_LAYOUT(GNOME_CANVAS_ITEM(cell->item)->canvas)->bin_window;
+	event.window = GTK_LAYOUT(FOO_CANVAS_ITEM(cell->item)->canvas)->bin_window;
         event.button = 1;
         event.send_event = TRUE;
         event.time = GDK_CURRENT_TIME;
diff --git a/widgets/table/gal-a11y-e-cell.c b/widgets/table/gal-a11y-e-cell.c
index e9e5eb0..4e44c04 100644
--- a/widgets/table/gal-a11y-e-cell.c
+++ b/widgets/table/gal-a11y-e-cell.c
@@ -209,9 +209,9 @@ gal_a11y_e_cell_grab_focus (AtkComponent *component)
 	atk_selection_add_selection (ATK_SELECTION (a11yTableItem), index);
 
 	gtk_widget_grab_focus (
-		GTK_WIDGET (GNOME_CANVAS_ITEM (a11y->item)->canvas));
+		GTK_WIDGET (FOO_CANVAS_ITEM (a11y->item)->canvas));
 	toplevel = gtk_widget_get_toplevel (
-		GTK_WIDGET (GNOME_CANVAS_ITEM (a11y->item)->canvas));
+		GTK_WIDGET (FOO_CANVAS_ITEM (a11y->item)->canvas));
 	if (toplevel && gtk_widget_is_toplevel (toplevel))
 		gtk_window_present (GTK_WINDOW (toplevel));
 
diff --git a/widgets/table/gal-a11y-e-table-click-to-add.c b/widgets/table/gal-a11y-e-table-click-to-add.c
index 225f24c..ddc6595 100644
--- a/widgets/table/gal-a11y-e-table-click-to-add.c
+++ b/widgets/table/gal-a11y-e-table-click-to-add.c
@@ -85,7 +85,7 @@ idle_do_action (gpointer data)
 	event.y = 0;
 
         event.type = GDK_BUTTON_PRESS;
-        event.window = GTK_LAYOUT(GNOME_CANVAS_ITEM(etcta)->canvas)->bin_window;
+        event.window = GTK_LAYOUT(FOO_CANVAS_ITEM(etcta)->canvas)->bin_window;
         event.button = 1;
         event.send_event = TRUE;
         event.time = GDK_CURRENT_TIME;
@@ -230,7 +230,7 @@ gal_a11y_e_table_click_to_add_get_type (void)
 			NULL
 		};
 
-                factory = atk_registry_get_factory (atk_get_default_registry (), GNOME_TYPE_CANVAS_ITEM);
+                factory = atk_registry_get_factory (atk_get_default_registry (), FOO_TYPE_CANVAS_ITEM);
 
 		parent_type = atk_object_factory_get_accessible_type (factory);
                 type = gal_a11y_type_register_static_with_private (PARENT_TYPE,
@@ -245,7 +245,7 @@ gal_a11y_e_table_click_to_add_get_type (void)
 }
 
 static gboolean
-etcta_event (GnomeCanvasItem *item, GdkEvent *e, gpointer data)
+etcta_event (FooCanvasItem *item, GdkEvent *e, gpointer data)
 {
         ETableClickToAdd *etcta = E_TABLE_CLICK_TO_ADD (item);
 	GalA11yETableClickToAdd *a11y;
diff --git a/widgets/table/gal-a11y-e-table-item.c b/widgets/table/gal-a11y-e-table-item.c
index 37f55f6..1e7aecd 100644
--- a/widgets/table/gal-a11y-e-table-item.c
+++ b/widgets/table/gal-a11y-e-table-item.c
@@ -995,7 +995,7 @@ gal_a11y_e_table_item_get_type (void)
 			NULL
 		};
 
-		factory = atk_registry_get_factory (atk_get_default_registry (), GNOME_TYPE_CANVAS_ITEM);
+		factory = atk_registry_get_factory (atk_get_default_registry (), FOO_TYPE_CANVAS_ITEM);
 		parent_type = atk_object_factory_get_accessible_type (factory);
 
 		type = gal_a11y_type_register_static_with_private (PARENT_TYPE, "GalA11yETableItem", &info, 0,
@@ -1240,7 +1240,7 @@ selection_add_selection (AtkSelection *selection, gint index)
 
 	if (model_row != cursor_row) {
 		/* we need to make the item get focus */
-		e_canvas_item_grab_focus (GNOME_CANVAS_ITEM (item), TRUE);
+		e_canvas_item_grab_focus (FOO_CANVAS_ITEM (item), TRUE);
 
 		/* FIXME, currently we only support single row selection */
 		atk_selection_clear_selection (selection);
diff --git a/widgets/table/gal-a11y-e-table.c b/widgets/table/gal-a11y-e-table.c
index bf75227..df1fc8d 100644
--- a/widgets/table/gal-a11y-e-table.c
+++ b/widgets/table/gal-a11y-e-table.c
@@ -48,15 +48,15 @@ struct _GalA11yETablePrivate {
 static ETableItem *
 find_first_table_item (ETableGroup *group)
 {
-	GnomeCanvasGroup *cgroup;
+	FooCanvasGroup *cgroup;
 	GList *l;
 
-	cgroup = GNOME_CANVAS_GROUP (group);
+	cgroup = FOO_CANVAS_GROUP (group);
 
 	for (l = cgroup->item_list; l; l = l->next) {
-		GnomeCanvasItem *i;
+		FooCanvasItem *i;
 
-		i = GNOME_CANVAS_ITEM (l->data);
+		i = FOO_CANVAS_ITEM (l->data);
 
 		if (E_IS_TABLE_GROUP (i))
 			return find_first_table_item (E_TABLE_GROUP (i));
diff --git a/widgets/text/e-reflow-model.c b/widgets/text/e-reflow-model.c
index 1eaccda..13d5f15 100644
--- a/widgets/text/e-reflow-model.c
+++ b/widgets/text/e-reflow-model.c
@@ -76,12 +76,12 @@ e_reflow_model_count (EReflowModel *e_reflow_model)
  * e_reflow_model_height:
  * @e_reflow_model: The e-reflow-model to operate on
  * @n: The item number to get the height of.
- * @parent: The parent GnomeCanvasItem.
+ * @parent: The parent FooCanvasItem.
  *
  * Returns: the height of the nth item.
  */
 gint
-e_reflow_model_height (EReflowModel *e_reflow_model, gint n, GnomeCanvasGroup *parent)
+e_reflow_model_height (EReflowModel *e_reflow_model, gint n, FooCanvasGroup *parent)
 {
 	g_return_val_if_fail (e_reflow_model != NULL, 0);
 	g_return_val_if_fail (E_IS_REFLOW_MODEL (e_reflow_model), 0);
@@ -93,14 +93,14 @@ e_reflow_model_height (EReflowModel *e_reflow_model, gint n, GnomeCanvasGroup *p
  * e_reflow_model_incarnate:
  * @e_reflow_model: The e-reflow-model to operate on
  * @n: The item to create.
- * @parent: The parent GnomeCanvasItem to create a child of.
+ * @parent: The parent FooCanvasItem to create a child of.
  *
- * Create a GnomeCanvasItem to represent the nth piece of data.
+ * Create a FooCanvasItem to represent the nth piece of data.
  *
- * Returns: the new GnomeCanvasItem.
+ * Returns: the new FooCanvasItem.
  */
-GnomeCanvasItem *
-e_reflow_model_incarnate (EReflowModel *e_reflow_model, gint n, GnomeCanvasGroup *parent)
+FooCanvasItem *
+e_reflow_model_incarnate (EReflowModel *e_reflow_model, gint n, FooCanvasGroup *parent)
 {
 	g_return_val_if_fail (e_reflow_model != NULL, NULL);
 	g_return_val_if_fail (E_IS_REFLOW_MODEL (e_reflow_model), NULL);
@@ -138,7 +138,7 @@ e_reflow_model_compare (EReflowModel *e_reflow_model, gint n1, gint n2)
  * Update item to represent the nth piece of data.
  */
 void
-e_reflow_model_reincarnate (EReflowModel *e_reflow_model, gint n, GnomeCanvasItem *item)
+e_reflow_model_reincarnate (EReflowModel *e_reflow_model, gint n, FooCanvasItem *item)
 {
 	g_return_if_fail (e_reflow_model != NULL);
 	g_return_if_fail (E_IS_REFLOW_MODEL (e_reflow_model));
diff --git a/widgets/text/e-reflow-model.h b/widgets/text/e-reflow-model.h
index ebbf3c1..214dcb7 100644
--- a/widgets/text/e-reflow-model.h
+++ b/widgets/text/e-reflow-model.h
@@ -25,7 +25,7 @@
 #define _E_REFLOW_MODEL_H_
 
 #include <glib-object.h>
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 
 G_BEGIN_DECLS
 
@@ -49,10 +49,10 @@ typedef struct {
 	void             (*set_width)      (EReflowModel *etm, gint width);
 
 	gint              (*count)          (EReflowModel *etm);
-	gint              (*height)         (EReflowModel *etm, gint n, GnomeCanvasGroup *parent);
-	GnomeCanvasItem *(*incarnate)      (EReflowModel *etm, gint n, GnomeCanvasGroup *parent);
+	gint              (*height)         (EReflowModel *etm, gint n, FooCanvasGroup *parent);
+	FooCanvasItem *(*incarnate)      (EReflowModel *etm, gint n, FooCanvasGroup *parent);
 	gint              (*compare)        (EReflowModel *etm, gint n1, gint n2);
-	void             (*reincarnate)    (EReflowModel *etm, gint n, GnomeCanvasItem *item);
+	void             (*reincarnate)    (EReflowModel *etm, gint n, FooCanvasItem *item);
 
 	/*
 	 * Signals
@@ -79,16 +79,16 @@ void             e_reflow_model_set_width       (EReflowModel     *e_reflow_mode
 gint              e_reflow_model_count           (EReflowModel     *e_reflow_model);
 gint              e_reflow_model_height          (EReflowModel     *e_reflow_model,
 						 gint               n,
-						 GnomeCanvasGroup *parent);
-GnomeCanvasItem *e_reflow_model_incarnate       (EReflowModel     *e_reflow_model,
+						 FooCanvasGroup *parent);
+FooCanvasItem *e_reflow_model_incarnate       (EReflowModel     *e_reflow_model,
 						 gint               n,
-						 GnomeCanvasGroup *parent);
+						 FooCanvasGroup *parent);
 gint              e_reflow_model_compare         (EReflowModel     *e_reflow_model,
 						 gint               n1,
 						 gint               n2);
 void             e_reflow_model_reincarnate     (EReflowModel     *e_reflow_model,
 						 gint               n,
-						 GnomeCanvasItem  *item);
+						 FooCanvasItem  *item);
 
 /*
  * Routines for emitting signals on the e_reflow
diff --git a/widgets/text/e-reflow.c b/widgets/text/e-reflow.c
index 705678b..9dfd7b1 100644
--- a/widgets/text/e-reflow.c
+++ b/widgets/text/e-reflow.c
@@ -37,23 +37,23 @@
 #include "e-reflow.h"
 #include "misc/e-selection-model-simple.h"
 
-static gboolean e_reflow_event (GnomeCanvasItem *item, GdkEvent *event);
-static void e_reflow_realize (GnomeCanvasItem *item);
-static void e_reflow_unrealize (GnomeCanvasItem *item);
-static void e_reflow_draw (GnomeCanvasItem *item, GdkDrawable *drawable,
+static gboolean e_reflow_event (FooCanvasItem *item, GdkEvent *event);
+static void e_reflow_realize (FooCanvasItem *item);
+static void e_reflow_unrealize (FooCanvasItem *item);
+static void e_reflow_draw (FooCanvasItem *item, GdkDrawable *drawable,
 				    gint x, gint y, gint width, gint height);
-static void e_reflow_update (GnomeCanvasItem *item, double affine[6], ArtSVP *clip_path, gint flags);
-static double e_reflow_point (GnomeCanvasItem *item, double x, double y, gint cx, gint cy, GnomeCanvasItem **actual_item);
-static void e_reflow_reflow (GnomeCanvasItem *item, gint flags);
+static void e_reflow_update (FooCanvasItem *item, double affine[6], ArtSVP *clip_path, gint flags);
+static double e_reflow_point (FooCanvasItem *item, double x, double y, gint cx, gint cy, FooCanvasItem **actual_item);
+static void e_reflow_reflow (FooCanvasItem *item, gint flags);
 static void set_empty(EReflow *reflow);
 
-static void e_reflow_resize_children (GnomeCanvasItem *item);
+static void e_reflow_resize_children (FooCanvasItem *item);
 
 #define E_REFLOW_DIVIDER_WIDTH 2
 #define E_REFLOW_BORDER_WIDTH 7
 #define E_REFLOW_FULL_GUTTER (E_REFLOW_DIVIDER_WIDTH + E_REFLOW_BORDER_WIDTH * 2)
 
-G_DEFINE_TYPE (EReflow, e_reflow, GNOME_TYPE_CANVAS_GROUP)
+G_DEFINE_TYPE (EReflow, e_reflow, FOO_TYPE_CANVAS_GROUP)
 
 /* The arguments we take */
 enum {
@@ -90,7 +90,7 @@ e_reflow_pick_line (EReflow *reflow, double x)
 }
 
 static gint
-er_find_item (EReflow *reflow, GnomeCanvasItem *item)
+er_find_item (EReflow *reflow, FooCanvasItem *item)
 {
 	gint i;
 	for (i = 0; i < reflow->count; i++) {
@@ -101,7 +101,7 @@ er_find_item (EReflow *reflow, GnomeCanvasItem *item)
 }
 
 static void
-e_reflow_resize_children (GnomeCanvasItem *item)
+e_reflow_resize_children (FooCanvasItem *item)
 {
 	EReflow *reflow;
 	gint i;
@@ -112,7 +112,7 @@ e_reflow_resize_children (GnomeCanvasItem *item)
 	count = reflow->count;
 	for (i = 0; i < count; i++) {
 		if (reflow->items[i])
-			gnome_canvas_item_set(reflow->items[i],
+			foo_canvas_item_set(reflow->items[i],
 					      "width", (double) reflow->column_width,
 					      NULL);
 	}
@@ -126,7 +126,7 @@ e_reflow_update_selection_row (EReflow *reflow, gint row)
 			     "selected", e_selection_model_is_row_selected(E_SELECTION_MODEL(reflow->selection), row),
 			     NULL);
 	} else if (e_selection_model_is_row_selected (E_SELECTION_MODEL (reflow->selection), row)) {
-		reflow->items[row] = e_reflow_model_incarnate (reflow->model, row, GNOME_CANVAS_GROUP (reflow));
+		reflow->items[row] = e_reflow_model_incarnate (reflow->model, row, FOO_CANVAS_GROUP (reflow));
 		g_object_set (reflow->items[row],
 			      "selected", e_selection_model_is_row_selected(E_SELECTION_MODEL(reflow->selection), row),
 			      "width", (double) reflow->column_width,
@@ -170,7 +170,7 @@ do_adjustment (gpointer user_data)
 	if (row == -1)
 		return FALSE;
 
-	adj = gtk_layout_get_hadjustment (GTK_LAYOUT (GNOME_CANVAS_ITEM (reflow)->canvas));
+	adj = gtk_layout_get_hadjustment (GTK_LAYOUT (FOO_CANVAS_ITEM (reflow)->canvas));
 	value = adj->value;
 
 	if ((!reflow->items) || (!reflow->items[row]))
@@ -216,7 +216,7 @@ cursor_changed (ESelectionModel *selection, gint row, gint col, EReflow *reflow)
 				      "has_cursor", TRUE,
 				      NULL);
 		} else {
-			reflow->items[row] = e_reflow_model_incarnate (reflow->model, row, GNOME_CANVAS_GROUP (reflow));
+			reflow->items[row] = e_reflow_model_incarnate (reflow->model, row, FOO_CANVAS_GROUP (reflow));
 			g_object_set (reflow->items[row],
 				      "has_cursor", TRUE,
 				      "width", (double) reflow->column_width,
@@ -238,7 +238,7 @@ incarnate (EReflow *reflow)
 	gint first_cell;
 	gint last_cell;
 	gint i;
-	GtkAdjustment *adjustment = gtk_layout_get_hadjustment (GTK_LAYOUT (GNOME_CANVAS_ITEM (reflow)->canvas));
+	GtkAdjustment *adjustment = gtk_layout_get_hadjustment (GTK_LAYOUT (FOO_CANVAS_ITEM (reflow)->canvas));
 
 	column_width = reflow->column_width;
 
@@ -263,7 +263,7 @@ incarnate (EReflow *reflow)
 		gint unsorted = e_sorter_sorted_to_model (E_SORTER (reflow->sorter), i);
 		if (reflow->items[unsorted] == NULL) {
 			if (reflow->model) {
-				reflow->items[unsorted] = e_reflow_model_incarnate (reflow->model, unsorted, GNOME_CANVAS_GROUP (reflow));
+				reflow->items[unsorted] = e_reflow_model_incarnate (reflow->model, unsorted, FOO_CANVAS_GROUP (reflow));
 				g_object_set (reflow->items[unsorted],
 					      "selected", e_selection_model_is_row_selected(E_SELECTION_MODEL(reflow->selection), unsorted),
 					      "width", (double) reflow->column_width,
@@ -354,13 +354,13 @@ item_changed (EReflowModel *model, gint i, EReflow *reflow)
 	if (i < 0 || i >= reflow->count)
 		return;
 
-	reflow->heights[i] = e_reflow_model_height (reflow->model, i, GNOME_CANVAS_GROUP (reflow));
+	reflow->heights[i] = e_reflow_model_height (reflow->model, i, FOO_CANVAS_GROUP (reflow));
 	if (reflow->items[i] != NULL)
 		e_reflow_model_reincarnate (model, i, reflow->items[i]);
 	e_sorter_array_clean (reflow->sorter);
 	reflow->reflow_from_column = -1;
 	reflow->need_reflow_columns = TRUE;
-	e_canvas_item_request_reflow(GNOME_CANVAS_ITEM (reflow));
+	e_canvas_item_request_reflow(FOO_CANVAS_ITEM (reflow));
 }
 
 static void
@@ -389,7 +389,7 @@ item_removed (EReflowModel *model, gint i, EReflow *reflow)
 		gtk_object_destroy (GTK_OBJECT (reflow->items[i]));
 
 	memmove (reflow->heights + i, reflow->heights + i + 1, (reflow->count - i - 1) * sizeof (gint));
-	memmove (reflow->items + i, reflow->items + i + 1, (reflow->count - i - 1) * sizeof (GnomeCanvasItem *));
+	memmove (reflow->items + i, reflow->items + i + 1, (reflow->count - i - 1) * sizeof (FooCanvasItem *));
 
 	reflow->count --;
 
@@ -398,7 +398,7 @@ item_removed (EReflowModel *model, gint i, EReflow *reflow)
 
 	reflow->need_reflow_columns = TRUE;
 	set_empty (reflow);
-	e_canvas_item_request_reflow(GNOME_CANVAS_ITEM (reflow));
+	e_canvas_item_request_reflow(FOO_CANVAS_ITEM (reflow));
 
 	e_sorter_array_set_count (reflow->sorter, reflow->count);
 
@@ -421,13 +421,13 @@ items_inserted (EReflowModel *model, gint position, gint count, EReflow *reflow)
 		while (reflow->count > reflow->allocated_count)
 			reflow->allocated_count += 256;
 		reflow->heights = g_renew (int, reflow->heights, reflow->allocated_count);
-		reflow->items = g_renew (GnomeCanvasItem *, reflow->items, reflow->allocated_count);
+		reflow->items = g_renew (FooCanvasItem *, reflow->items, reflow->allocated_count);
 	}
 	memmove (reflow->heights + position + count, reflow->heights + position, (reflow->count - position - count) * sizeof (gint));
-	memmove (reflow->items + position + count, reflow->items + position, (reflow->count - position - count) * sizeof (GnomeCanvasItem *));
+	memmove (reflow->items + position + count, reflow->items + position, (reflow->count - position - count) * sizeof (FooCanvasItem *));
 	for (i = position; i < position + count; i++) {
 		reflow->items[i] = NULL;
-		reflow->heights[i] = e_reflow_model_height (reflow->model, i, GNOME_CANVAS_GROUP (reflow));
+		reflow->heights[i] = e_reflow_model_height (reflow->model, i, FOO_CANVAS_GROUP (reflow));
 	}
 
 	e_selection_model_simple_set_row_count (E_SELECTION_MODEL_SIMPLE (reflow->selection), reflow->count);
@@ -455,7 +455,7 @@ items_inserted (EReflowModel *model, gint position, gint count, EReflow *reflow)
 
 	reflow->need_reflow_columns = TRUE;
 	set_empty (reflow);
-	e_canvas_item_request_reflow(GNOME_CANVAS_ITEM (reflow));
+	e_canvas_item_request_reflow(FOO_CANVAS_ITEM (reflow));
 }
 
 static void
@@ -476,13 +476,13 @@ model_changed (EReflowModel *model, EReflow *reflow)
 	g_free (reflow->heights);
 	reflow->count = e_reflow_model_count (model);
 	reflow->allocated_count = reflow->count;
-	reflow->items = g_new (GnomeCanvasItem *, reflow->count);
+	reflow->items = g_new (FooCanvasItem *, reflow->count);
 	reflow->heights = g_new (int, reflow->count);
 
 	count = reflow->count;
 	for (i = 0; i < count; i++) {
 		reflow->items[i] = NULL;
-		reflow->heights[i] = e_reflow_model_height (reflow->model, i, GNOME_CANVAS_GROUP (reflow));
+		reflow->heights[i] = e_reflow_model_height (reflow->model, i, FOO_CANVAS_GROUP (reflow));
 	}
 
 	e_selection_model_simple_set_row_count (E_SELECTION_MODEL_SIMPLE (reflow->selection), count);
@@ -492,7 +492,7 @@ model_changed (EReflowModel *model, EReflow *reflow)
 	if (oldcount > reflow->count)
 		reflow_columns (reflow);
 	set_empty (reflow);
-	e_canvas_item_request_reflow(GNOME_CANVAS_ITEM (reflow));
+	e_canvas_item_request_reflow(FOO_CANVAS_ITEM (reflow));
 }
 
 static void
@@ -501,7 +501,7 @@ comparison_changed (EReflowModel *model, EReflow *reflow)
 	e_sorter_array_clean (reflow->sorter);
 	reflow->reflow_from_column = -1;
 	reflow->need_reflow_columns = TRUE;
-	e_canvas_item_request_reflow(GNOME_CANVAS_ITEM (reflow));
+	e_canvas_item_request_reflow(FOO_CANVAS_ITEM (reflow));
 }
 
 static void
@@ -510,7 +510,7 @@ set_empty(EReflow *reflow)
 	if (reflow->count == 0) {
 		if (reflow->empty_text) {
 			if (reflow->empty_message) {
-				gnome_canvas_item_set(reflow->empty_text,
+				foo_canvas_item_set(reflow->empty_text,
 						      "width", reflow->minimum_width,
 						      "text", reflow->empty_message,
 						      NULL);
@@ -524,7 +524,7 @@ set_empty(EReflow *reflow)
 		} else {
 			if (reflow->empty_message) {
 				reflow->empty_text =
-					gnome_canvas_item_new(GNOME_CANVAS_GROUP(reflow),
+					foo_canvas_item_new(FOO_CANVAS_GROUP(reflow),
 							      e_text_get_type(),
 							      "anchor", GTK_ANCHOR_N,
 							      "width", reflow->minimum_width,
@@ -676,7 +676,7 @@ static void
 connect_set_adjustment (EReflow *reflow)
 {
 	reflow->set_scroll_adjustments_id =
-		g_signal_connect (GNOME_CANVAS_ITEM (reflow)->canvas,
+		g_signal_connect (FOO_CANVAS_ITEM (reflow)->canvas,
 				  "set_scroll_adjustments",
 				  G_CALLBACK (set_scroll_adjustments), reflow);
 }
@@ -686,7 +686,7 @@ static void
 disconnect_set_adjustment (EReflow *reflow)
 {
 	if (reflow->set_scroll_adjustments_id != 0) {
-		g_signal_handler_disconnect (GNOME_CANVAS_ITEM (reflow)->canvas,
+		g_signal_handler_disconnect (FOO_CANVAS_ITEM (reflow)->canvas,
 					     reflow->set_scroll_adjustments_id);
 		reflow->set_scroll_adjustments_id = 0;
 	}
@@ -704,10 +704,10 @@ column_width_changed (EReflow *reflow)
 static void
 e_reflow_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
 {
-	GnomeCanvasItem *item;
+	FooCanvasItem *item;
 	EReflow *reflow;
 
-	item = GNOME_CANVAS_ITEM (object);
+	item = FOO_CANVAS_ITEM (object);
 	reflow = E_REFLOW (object);
 
 	switch (prop_id) {
@@ -718,14 +718,14 @@ e_reflow_set_property (GObject *object, guint prop_id, const GValue *value, GPar
 		break;
 	case PROP_MINIMUM_WIDTH:
 		reflow->minimum_width = g_value_get_double (value);
-		if (GNOME_CANVAS_ITEM_REALIZED & GTK_OBJECT_FLAGS(object))
+		if (FOO_CANVAS_ITEM_REALIZED & GTK_OBJECT_FLAGS(object))
 			set_empty(reflow);
 		e_canvas_item_request_reflow(item);
 		break;
 	case PROP_EMPTY_MESSAGE:
 		g_free(reflow->empty_message);
 		reflow->empty_message = g_strdup(g_value_get_string (value));
-		if (GNOME_CANVAS_ITEM_REALIZED & GTK_OBJECT_FLAGS(object))
+		if (FOO_CANVAS_ITEM_REALIZED & GTK_OBJECT_FLAGS(object))
 			set_empty(reflow);
 		break;
 	case PROP_MODEL:
@@ -744,7 +744,7 @@ e_reflow_set_property (GObject *object, guint prop_id, const GValue *value, GPar
 			e_canvas_item_request_reflow(item);
 
 			reflow->need_column_resize = TRUE;
-			gnome_canvas_item_request_update(item);
+			foo_canvas_item_request_update(item);
 
 			if (old_width != reflow->column_width)
 				column_width_changed (reflow);
@@ -823,7 +823,7 @@ e_reflow_dispose (GObject *object)
 }
 
 static void
-e_reflow_realize (GnomeCanvasItem *item)
+e_reflow_realize (FooCanvasItem *item)
 {
 	EReflow *reflow;
 	GtkAdjustment *adjustment;
@@ -832,8 +832,8 @@ e_reflow_realize (GnomeCanvasItem *item)
 
 	reflow = E_REFLOW (item);
 
-	if (GNOME_CANVAS_ITEM_CLASS(e_reflow_parent_class)->realize)
-		(* GNOME_CANVAS_ITEM_CLASS(e_reflow_parent_class)->realize) (item);
+	if (FOO_CANVAS_ITEM_CLASS(e_reflow_parent_class)->realize)
+		(* FOO_CANVAS_ITEM_CLASS(e_reflow_parent_class)->realize) (item);
 
 	reflow->arrow_cursor = gdk_cursor_new (GDK_SB_H_DOUBLE_ARROW);
 	reflow->default_cursor = gdk_cursor_new (GDK_LEFT_PTR);
@@ -841,7 +841,7 @@ e_reflow_realize (GnomeCanvasItem *item)
 	count = reflow->count;
 	for (i = 0; i < count; i++) {
 		if (reflow->items[i])
-			gnome_canvas_item_set(reflow->items[i],
+			foo_canvas_item_set(reflow->items[i],
 					      "width", reflow->column_width,
 					      NULL);
 	}
@@ -867,7 +867,7 @@ e_reflow_realize (GnomeCanvasItem *item)
 }
 
 static void
-e_reflow_unrealize (GnomeCanvasItem *item)
+e_reflow_unrealize (FooCanvasItem *item)
 {
 	EReflow *reflow;
 
@@ -887,12 +887,12 @@ e_reflow_unrealize (GnomeCanvasItem *item)
 	disconnect_set_adjustment (reflow);
 	disconnect_adjustment (reflow);
 
-	if (GNOME_CANVAS_ITEM_CLASS(e_reflow_parent_class)->unrealize)
-		(* GNOME_CANVAS_ITEM_CLASS(e_reflow_parent_class)->unrealize) (item);
+	if (FOO_CANVAS_ITEM_CLASS(e_reflow_parent_class)->unrealize)
+		(* FOO_CANVAS_ITEM_CLASS(e_reflow_parent_class)->unrealize) (item);
 }
 
 static gboolean
-e_reflow_event (GnomeCanvasItem *item, GdkEvent *event)
+e_reflow_event (FooCanvasItem *item, GdkEvent *event)
 {
 	EReflow *reflow;
 	gint return_val = FALSE;
@@ -913,7 +913,7 @@ e_reflow_event (GnomeCanvasItem *item, GdkEvent *event)
 				count = reflow->count;
 				for (i = 0; i < count; i++) {
 					gint unsorted = e_sorter_sorted_to_model (E_SORTER (reflow->sorter), i);
-					GnomeCanvasItem *item = reflow->items[unsorted];
+					FooCanvasItem *item = reflow->items[unsorted];
 					EFocus has_focus;
 					if (item) {
 						g_object_get(item,
@@ -932,11 +932,11 @@ e_reflow_event (GnomeCanvasItem *item, GdkEvent *event)
 
 							unsorted = e_sorter_sorted_to_model (E_SORTER (reflow->sorter), i);
 							if (reflow->items[unsorted] == NULL) {
-								reflow->items[unsorted] = e_reflow_model_incarnate (reflow->model, unsorted, GNOME_CANVAS_GROUP (reflow));
+								reflow->items[unsorted] = e_reflow_model_incarnate (reflow->model, unsorted, FOO_CANVAS_GROUP (reflow));
 							}
 
 							item = reflow->items[unsorted];
-							gnome_canvas_item_set(item,
+							foo_canvas_item_set(item,
 									      "has_focus", (event->key.state & GDK_SHIFT_MASK) ? E_FOCUS_END : E_FOCUS_START,
 									      NULL);
 							return TRUE;
@@ -965,14 +965,14 @@ e_reflow_event (GnomeCanvasItem *item, GdkEvent *event)
 							reflow->temp_column_width = reflow->column_width;
 							reflow->column_drag = TRUE;
 
-							gnome_canvas_item_grab (item,
+							foo_canvas_item_grab (item,
 										GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK,
 										reflow->arrow_cursor,
 										button->time);
 
 							reflow->previous_temp_column_width = -1;
 							reflow->need_column_resize = TRUE;
-							gnome_canvas_item_request_update(item);
+							foo_canvas_item_request_update(item);
 							return TRUE;
 						}
 					}
@@ -1015,12 +1015,12 @@ e_reflow_event (GnomeCanvasItem *item, GdkEvent *event)
 					gtk_adjustment_changed(adjustment);
 					e_reflow_resize_children(item);
 					e_canvas_item_request_reflow(item);
-					gnome_canvas_request_redraw(item->canvas, 0, 0, reflow->width, reflow->height);
+					foo_canvas_request_redraw(item->canvas, 0, 0, reflow->width, reflow->height);
 					column_width_changed (reflow);
 				}
 				reflow->need_column_resize = TRUE;
-				gnome_canvas_item_request_update(item);
-				gnome_canvas_item_ungrab (item, button->time);
+				foo_canvas_item_request_update(item);
+				foo_canvas_item_ungrab (item, button->time);
 				return TRUE;
 			}
 			break;
@@ -1035,7 +1035,7 @@ e_reflow_event (GnomeCanvasItem *item, GdkEvent *event)
 					reflow->temp_column_width = 50;
 				if (old_width != reflow->temp_column_width) {
 					reflow->need_column_resize = TRUE;
-					gnome_canvas_item_request_update(item);
+					foo_canvas_item_request_update(item);
 				}
 				return TRUE;
 			} else {
@@ -1095,13 +1095,13 @@ e_reflow_event (GnomeCanvasItem *item, GdkEvent *event)
 		}
 	if (return_val)
 		return return_val;
-	else if (GNOME_CANVAS_ITEM_CLASS( e_reflow_parent_class )->event)
-		return (* GNOME_CANVAS_ITEM_CLASS( e_reflow_parent_class )->event) (item, event);
+	else if (FOO_CANVAS_ITEM_CLASS( e_reflow_parent_class )->event)
+		return (* FOO_CANVAS_ITEM_CLASS( e_reflow_parent_class )->event) (item, event);
 	else
 		return FALSE;
 }
 
-static void e_reflow_draw (GnomeCanvasItem *item, GdkDrawable *drawable,
+static void e_reflow_draw (FooCanvasItem *item, GdkDrawable *drawable,
 				    gint x, gint y, gint width, gint height)
 {
 	gint x_rect, y_rect, width_rect, height_rect;
@@ -1110,8 +1110,8 @@ static void e_reflow_draw (GnomeCanvasItem *item, GdkDrawable *drawable,
 	gint i;
 	double column_width;
 
-	if (GNOME_CANVAS_ITEM_CLASS(e_reflow_parent_class)->draw)
-		GNOME_CANVAS_ITEM_CLASS(e_reflow_parent_class)->draw (item, drawable, x, y, width, height);
+	if (FOO_CANVAS_ITEM_CLASS(e_reflow_parent_class)->draw)
+		FOO_CANVAS_ITEM_CLASS(e_reflow_parent_class)->draw (item, drawable, x, y, width, height);
 	column_width = reflow->column_width;
 	running_width = E_REFLOW_BORDER_WIDTH + column_width + E_REFLOW_BORDER_WIDTH;
 	x_rect = running_width;
@@ -1176,15 +1176,15 @@ static void e_reflow_draw (GnomeCanvasItem *item, GdkDrawable *drawable,
 }
 
 static void
-e_reflow_update (GnomeCanvasItem *item, double affine[6], ArtSVP *clip_path, gint flags)
+e_reflow_update (FooCanvasItem *item, double affine[6], ArtSVP *clip_path, gint flags)
 {
 	EReflow *reflow;
 	double x0, x1, y0, y1;
 
 	reflow = E_REFLOW (item);
 
-	if (GNOME_CANVAS_ITEM_CLASS(e_reflow_parent_class)->update)
-		GNOME_CANVAS_ITEM_CLASS(e_reflow_parent_class)->update (item, affine, clip_path, flags);
+	if (FOO_CANVAS_ITEM_CLASS(e_reflow_parent_class)->update)
+		FOO_CANVAS_ITEM_CLASS(e_reflow_parent_class)->update (item, affine, clip_path, flags);
 
 	x0 = item->x1;
 	y0 = item->y1;
@@ -1211,7 +1211,7 @@ e_reflow_update (GnomeCanvasItem *item, double affine[6], ArtSVP *clip_path, gin
 		if ( x1 < E_REFLOW(item)->height )
 			x1 = E_REFLOW(item)->height;
 
-		gnome_canvas_request_redraw(item->canvas, x0, y0, x1, y1);
+		foo_canvas_request_redraw(item->canvas, x0, y0, x1, y1);
 		reflow->need_height_update = FALSE;
 	} else if (reflow->need_column_resize) {
 		gint x_rect, y_rect, width_rect, height_rect;
@@ -1232,7 +1232,7 @@ e_reflow_update (GnomeCanvasItem *item, double affine[6], ArtSVP *clip_path, gin
 
 			for ( i = 0; i < reflow->column_count; i++) {
 				x_rect = running_width;
-				gnome_canvas_request_redraw(item->canvas, x_rect, y_rect, x_rect + width_rect, y_rect + height_rect);
+				foo_canvas_request_redraw(item->canvas, x_rect, y_rect, x_rect + width_rect, y_rect + height_rect);
 				running_width += E_REFLOW_DIVIDER_WIDTH + E_REFLOW_BORDER_WIDTH + column_width + E_REFLOW_BORDER_WIDTH;
 			}
 		}
@@ -1248,7 +1248,7 @@ e_reflow_update (GnomeCanvasItem *item, double affine[6], ArtSVP *clip_path, gin
 
 			for ( i = 0; i < reflow->column_count; i++) {
 				x_rect = running_width;
-				gnome_canvas_request_redraw(item->canvas, x_rect, y_rect, x_rect + width_rect, y_rect + height_rect);
+				foo_canvas_request_redraw(item->canvas, x_rect, y_rect, x_rect + width_rect, y_rect + height_rect);
 				running_width += E_REFLOW_DIVIDER_WIDTH + E_REFLOW_BORDER_WIDTH + column_width + E_REFLOW_BORDER_WIDTH;
 			}
 		}
@@ -1259,16 +1259,16 @@ e_reflow_update (GnomeCanvasItem *item, double affine[6], ArtSVP *clip_path, gin
 }
 
 static double
-e_reflow_point (GnomeCanvasItem *item,
+e_reflow_point (FooCanvasItem *item,
 		double x, double y, gint cx, gint cy,
-		GnomeCanvasItem **actual_item)
+		FooCanvasItem **actual_item)
 {
 	double distance = 1;
 
 	*actual_item = NULL;
 
-	if (GNOME_CANVAS_ITEM_CLASS(e_reflow_parent_class)->point)
-		distance = GNOME_CANVAS_ITEM_CLASS(e_reflow_parent_class)->point (item, x, y, cx, cy, actual_item);
+	if (FOO_CANVAS_ITEM_CLASS(e_reflow_parent_class)->point)
+		distance = FOO_CANVAS_ITEM_CLASS(e_reflow_parent_class)->point (item, x, y, cx, cy, actual_item);
 	if ((gint) (distance * item->canvas->pixels_per_unit + 0.5) <= item->canvas->close_enough && *actual_item)
 		return distance;
 
@@ -1290,7 +1290,7 @@ e_reflow_point (GnomeCanvasItem *item,
 }
 
 static void
-e_reflow_reflow( GnomeCanvasItem *item, gint flags )
+e_reflow_reflow( FooCanvasItem *item, gint flags )
 {
 	EReflow *reflow = E_REFLOW(item);
 	gdouble old_width;
@@ -1299,7 +1299,7 @@ e_reflow_reflow( GnomeCanvasItem *item, gint flags )
 	gint next_column;
 	gint i;
 
-	if (! (GTK_OBJECT_FLAGS (reflow) & GNOME_CANVAS_ITEM_REALIZED))
+	if (! (GTK_OBJECT_FLAGS (reflow) & FOO_CANVAS_ITEM_REALIZED))
 		return;
 
 	if (reflow->need_reflow_columns) {
@@ -1322,7 +1322,7 @@ e_reflow_reflow( GnomeCanvasItem *item, gint flags )
 		}
 
 		if (unsorted >= 0 && reflow->items[unsorted]) {
-			e_canvas_item_move_absolute(GNOME_CANVAS_ITEM(reflow->items[unsorted]),
+			e_canvas_item_move_absolute(FOO_CANVAS_ITEM(reflow->items[unsorted]),
 						    (double) running_width,
 						    (double) running_height);
 			running_height += reflow->heights[unsorted] + E_REFLOW_BORDER_WIDTH;
@@ -1336,7 +1336,7 @@ e_reflow_reflow( GnomeCanvasItem *item, gint flags )
 }
 
 static gint
-e_reflow_selection_event_real (EReflow *reflow, GnomeCanvasItem *item, GdkEvent *event)
+e_reflow_selection_event_real (EReflow *reflow, FooCanvasItem *item, GdkEvent *event)
 {
 	gint row;
 	gint return_val = TRUE;
@@ -1389,16 +1389,16 @@ static void
 e_reflow_class_init (EReflowClass *klass)
 {
 	GObjectClass *object_class;
-	GnomeCanvasItemClass *item_class;
+	FooCanvasItemClass *item_class;
 
 	object_class = (GObjectClass*) klass;
-	item_class = (GnomeCanvasItemClass *) klass;
+	item_class = (FooCanvasItemClass *) klass;
 
 	object_class->set_property  = e_reflow_set_property;
 	object_class->get_property  = e_reflow_get_property;
 	object_class->dispose  = e_reflow_dispose;
 
-	/* GnomeCanvasItem method overrides */
+	/* FooCanvasItem method overrides */
 	item_class->event      = e_reflow_event;
 	item_class->realize    = e_reflow_realize;
 	item_class->unrealize  = e_reflow_unrealize;
@@ -1527,5 +1527,5 @@ e_reflow_init (EReflow *reflow)
 		g_signal_connect(reflow->selection, "cursor_changed",
 				 G_CALLBACK (cursor_changed), reflow);
 
-	e_canvas_item_set_reflow_callback(GNOME_CANVAS_ITEM(reflow), e_reflow_reflow);
+	e_canvas_item_set_reflow_callback(FOO_CANVAS_ITEM(reflow), e_reflow_reflow);
 }
diff --git a/widgets/text/e-reflow.h b/widgets/text/e-reflow.h
index 1559ad6..c20f5ee 100644
--- a/widgets/text/e-reflow.h
+++ b/widgets/text/e-reflow.h
@@ -23,7 +23,7 @@
 #ifndef __E_REFLOW_H__
 #define __E_REFLOW_H__
 
-#include <libgnomecanvas/gnome-canvas.h>
+#include <libfoocanvas/foo-canvas.h>
 #include <text/e-reflow-model.h>
 #include <misc/e-selection-model.h>
 #include <e-util/e-sorter-array.h>
@@ -54,7 +54,7 @@ typedef struct _EReflowClass  EReflowClass;
 
 struct _EReflow
 {
-	GnomeCanvasGroup parent;
+	FooCanvasGroup parent;
 
 	/* item specific fields */
 	EReflowModel *model;
@@ -76,14 +76,14 @@ struct _EReflow
 	guint set_scroll_adjustments_id;
 
 	gint *heights;
-	GnomeCanvasItem **items;
+	FooCanvasItem **items;
 	gint count;
 	gint allocated_count;
 
 	gint *columns;
 	gint column_count; /* Number of columnns */
 
-	GnomeCanvasItem *empty_text;
+	FooCanvasItem *empty_text;
 	gchar *empty_message;
 
 	double minimum_width;
@@ -121,9 +121,9 @@ struct _EReflow
 
 struct _EReflowClass
 {
-	GnomeCanvasGroupClass parent_class;
+	FooCanvasGroupClass parent_class;
 
-	gint (*selection_event) (EReflow *reflow, GnomeCanvasItem *item, GdkEvent *event);
+	gint (*selection_event) (EReflow *reflow, FooCanvasItem *item, GdkEvent *event);
 	void (*column_width_changed) (EReflow *reflow, double width);
 };
 
diff --git a/widgets/text/e-text.c b/widgets/text/e-text.c
index 7e91650..f84b32b 100644
--- a/widgets/text/e-text.c
+++ b/widgets/text/e-text.c
@@ -9,9 +9,9 @@
  *
  * A majority of code taken from:
  *
- * Text item type for GnomeCanvas widget
+ * Text item type for FooCanvas widget
  *
- * GnomeCanvas is basically a port of the Tk toolkit's most excellent
+ * FooCanvas is basically a port of the Tk toolkit's most excellent
  * canvas widget.  Tk is copyrighted by the Regents of the University
  * of California, Sun Microsystems, and other parties.
  *
@@ -44,7 +44,7 @@
 #include <glib-object.h>
 #include <gdk/gdkkeysyms.h>
 #include <gtk/gtk.h>
-#include <libgnomecanvas/gnome-canvas-rect-ellipse.h>
+#include <libfoocanvas/foo-canvas-rect-ellipse.h>
 
 #include "gal-a11y-e-text.h"
 #include "misc/e-canvas.h"
@@ -56,7 +56,7 @@
 
 #include "e-text.h"
 
-G_DEFINE_TYPE (EText, e_text, GNOME_TYPE_CANVAS_ITEM)
+G_DEFINE_TYPE (EText, e_text, FOO_TYPE_CANVAS_ITEM)
 
 #define BORDER_INDENT 3
 #define d(x)
@@ -181,7 +181,7 @@ e_text_style_set (EText *text, GtkStyle *previous_style)
 	} else {
 		text->needs_calc_height = 1;
 	}
-	e_canvas_item_request_reflow (GNOME_CANVAS_ITEM (text));
+	e_canvas_item_request_reflow (FOO_CANVAS_ITEM (text));
 }
 #endif
 
@@ -196,7 +196,7 @@ e_text_dispose (GObject *object)
 	text = E_TEXT (object);
 
 	if (text->tooltip_owner)
-		e_canvas_hide_tooltip (E_CANVAS(GNOME_CANVAS_ITEM(text)->canvas));
+		e_canvas_hide_tooltip (E_CANVAS(FOO_CANVAS_ITEM(text)->canvas));
 	text->tooltip_owner = 0;
 
 	if (text->model_changed_signal_id)
@@ -396,7 +396,7 @@ reset_layout_attrs (EText *text)
 static void
 create_layout (EText *text)
 {
-	GnomeCanvasItem *item = GNOME_CANVAS_ITEM (text);
+	FooCanvasItem *item = FOO_CANVAS_ITEM (text);
 
 	if (text->layout)
 		return;
@@ -410,7 +410,7 @@ create_layout (EText *text)
 static void
 reset_layout (EText *text)
 {
-	GnomeCanvasItem *item = GNOME_CANVAS_ITEM (text);
+	FooCanvasItem *item = FOO_CANVAS_ITEM (text);
 	cairo_font_options_t *font_options;
 	PangoContext *context;
 
@@ -473,8 +473,8 @@ e_text_text_model_changed (ETextModel *model, EText *text)
 	text->needs_reset_layout = 1;
 	text->needs_split_into_lines = 1;
 	text->needs_redraw = 1;
-	e_canvas_item_request_reflow (GNOME_CANVAS_ITEM(text));
-	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (text));
+	e_canvas_item_request_reflow (FOO_CANVAS_ITEM(text));
+	foo_canvas_item_request_update (FOO_CANVAS_ITEM (text));
 
 	g_signal_emit (text, e_text_signals[E_TEXT_CHANGED], 0);
 }
@@ -503,18 +503,18 @@ e_text_text_model_reposition (ETextModel *model, ETextModelReposFn fn, gpointer
 static void
 get_bounds (EText *text, double *px1, double *py1, double *px2, double *py2)
 {
-	GnomeCanvasItem *item;
+	FooCanvasItem *item;
 	double wx, wy, clip_width, clip_height;
 
-	item = GNOME_CANVAS_ITEM (text);
+	item = FOO_CANVAS_ITEM (text);
 
 	/* Get canvas pixel coordinates for text position */
 
 	wx = 0;
 	wy = 0;
-	gnome_canvas_item_i2w (item, &wx, &wy);
-	gnome_canvas_w2c (item->canvas, wx, wy, &text->cx, &text->cy);
-	gnome_canvas_w2c (item->canvas, wx, wy, &text->clip_cx, &text->clip_cy);
+	foo_canvas_item_i2w (item, &wx, &wy);
+	foo_canvas_w2c (item->canvas, wx, wy, &text->cx, &text->cy);
+	foo_canvas_w2c (item->canvas, wx, wy, &text->clip_cx, &text->clip_cy);
 
 	if (text->clip_width < 0)
 		clip_width = text->width;
@@ -600,13 +600,13 @@ get_bounds (EText *text, double *px1, double *py1, double *px2, double *py2)
 static void
 calc_height (EText *text)
 {
-	GnomeCanvasItem *item;
+	FooCanvasItem *item;
 	gint old_height;
 	gint old_width;
 	gint width = 0;
 	gint height = 0;
 
-	item = GNOME_CANVAS_ITEM (text);
+	item = FOO_CANVAS_ITEM (text);
 
 	/* Calculate text dimensions */
 
@@ -628,7 +628,7 @@ calc_ellipsis (EText *text)
 {
 /* FIXME: a pango layout per calc_ellipsis sucks */
 	gint width;
-	PangoLayout *layout = gtk_widget_create_pango_layout (GTK_WIDGET (GNOME_CANVAS_ITEM (text)->canvas),
+	PangoLayout *layout = gtk_widget_create_pango_layout (GTK_WIDGET (FOO_CANVAS_ITEM (text)->canvas),
 							      text->ellipsis ? text->ellipsis : "...");
 	pango_layout_get_size (layout, &width, NULL);
 
@@ -680,7 +680,7 @@ e_text_set_property (GObject *object,
                     const GValue *value,
                     GParamSpec *pspec)
 {
-	GnomeCanvasItem *item;
+	FooCanvasItem *item;
 	EText *text;
 	GdkColor color = { 0, 0, 0, 0, };
 	GdkColor *pcolor;
@@ -689,7 +689,7 @@ e_text_set_property (GObject *object,
 	gboolean needs_update = 0;
 	gboolean needs_reflow = 0;
 
-	item = GNOME_CANVAS_ITEM (object);
+	item = FOO_CANVAS_ITEM (object);
 	text = E_TEXT (object);
 
 	color_changed = FALSE;
@@ -1015,7 +1015,7 @@ e_text_set_property (GObject *object,
 	if ( needs_reflow )
 		e_canvas_item_request_reflow (item);
 	if ( needs_update )
-		gnome_canvas_item_request_update (item);
+		foo_canvas_item_request_update (item);
 }
 
 /* Get_arg handler for the text item */
@@ -1171,7 +1171,7 @@ e_text_get_property (GObject *object,
 
 /* Update handler for the text item */
 static void
-e_text_reflow (GnomeCanvasItem *item, gint flags)
+e_text_reflow (FooCanvasItem *item, gint flags)
 {
 	EText *text;
 
@@ -1192,7 +1192,7 @@ e_text_reflow (GnomeCanvasItem *item, gint flags)
 
 	if ( text->needs_calc_height ) {
 		calc_height (text);
-		gnome_canvas_item_request_update(item);
+		foo_canvas_item_request_update(item);
 		text->needs_calc_height = 0;
 		text->needs_recalc_bounds = 1;
 	}
@@ -1200,18 +1200,18 @@ e_text_reflow (GnomeCanvasItem *item, gint flags)
 
 /* Update handler for the text item */
 static void
-e_text_update (GnomeCanvasItem *item, double *affine, ArtSVP *clip_path, gint flags)
+e_text_update (FooCanvasItem *item, double *affine, ArtSVP *clip_path, gint flags)
 {
 	EText *text;
 	double x1, y1, x2, y2;
 
 	text = E_TEXT (item);
 
-	if (GNOME_CANVAS_ITEM_CLASS (e_text_parent_class)->update)
-		(* GNOME_CANVAS_ITEM_CLASS (e_text_parent_class)->update) (item, affine, clip_path, flags);
+	if (FOO_CANVAS_ITEM_CLASS (e_text_parent_class)->update)
+		(* FOO_CANVAS_ITEM_CLASS (e_text_parent_class)->update) (item, affine, clip_path, flags);
 
 	if ( text->needs_recalc_bounds
-	     || (flags & GNOME_CANVAS_UPDATE_AFFINE)) {
+	     || (flags & FOO_CANVAS_UPDATE_AFFINE)) {
 		if (!item->canvas->aa) {
 			set_text_gc_foreground (text);
 			set_stipple (text, text->stipple, TRUE);
@@ -1220,7 +1220,7 @@ e_text_update (GnomeCanvasItem *item, double *affine, ArtSVP *clip_path, gint fl
 			     item->x2 != x2 ||
 			     item->y1 != y1 ||
 			     item->y2 != y2 ) {
-				gnome_canvas_request_redraw (item->canvas, item->x1, item->y1, item->x2, item->y2);
+				foo_canvas_request_redraw (item->canvas, item->x1, item->y1, item->x2, item->y2);
 				item->x1 = x1;
 				item->y1 = y1;
 				item->x2 = x2;
@@ -1234,22 +1234,22 @@ e_text_update (GnomeCanvasItem *item, double *affine, ArtSVP *clip_path, gint fl
 		text->needs_recalc_bounds = 0;
 	}
 	if ( text->needs_redraw ) {
-		gnome_canvas_request_redraw (item->canvas, item->x1, item->y1, item->x2, item->y2);
+		foo_canvas_request_redraw (item->canvas, item->x1, item->y1, item->x2, item->y2);
 		text->needs_redraw = 0;
 	}
 }
 
 /* Realize handler for the text item */
 static void
-e_text_realize (GnomeCanvasItem *item)
+e_text_realize (FooCanvasItem *item)
 {
 	EText *text;
 	GdkWindow *bin_window;
 
 	text = E_TEXT (item);
 
-	if (GNOME_CANVAS_ITEM_CLASS (e_text_parent_class)->realize)
-		(* GNOME_CANVAS_ITEM_CLASS (e_text_parent_class)->realize) (item);
+	if (FOO_CANVAS_ITEM_CLASS (e_text_parent_class)->realize)
+		(* FOO_CANVAS_ITEM_CLASS (e_text_parent_class)->realize) (item);
 
 	create_layout (text);
 
@@ -1268,7 +1268,7 @@ e_text_realize (GnomeCanvasItem *item)
 
 /* Unrealize handler for the text item */
 static void
-e_text_unrealize (GnomeCanvasItem *item)
+e_text_unrealize (FooCanvasItem *item)
 {
 	EText *text;
 
@@ -1282,8 +1282,8 @@ e_text_unrealize (GnomeCanvasItem *item)
 	gdk_cursor_unref (text->default_cursor);
 	text->default_cursor = NULL;
 
-	if (GNOME_CANVAS_ITEM_CLASS (e_text_parent_class)->unrealize)
-		(* GNOME_CANVAS_ITEM_CLASS (e_text_parent_class)->unrealize) (item);
+	if (FOO_CANVAS_ITEM_CLASS (e_text_parent_class)->unrealize)
+		(* FOO_CANVAS_ITEM_CLASS (e_text_parent_class)->unrealize) (item);
 }
 
 static void
@@ -1378,21 +1378,21 @@ show_pango_rectangle (EText *text, PangoRectangle rect)
 
 /* Draw handler for the text item */
 static void
-e_text_draw (GnomeCanvasItem *item, GdkDrawable *drawable,
+e_text_draw (FooCanvasItem *item, GdkDrawable *drawable,
 	     gint x, gint y, gint width, gint height)
 {
 	EText *text;
 	GdkRectangle rect, *clip_rect;
 	gint xpos, ypos;
 	GdkGC *main_gc;
-	GnomeCanvas *canvas;
+	FooCanvas *canvas;
 	GtkWidget *widget;
 	GdkWindow *window;
 	GtkStyle *style;
 	GtkStateType state;
 
 	text = E_TEXT (item);
-	canvas = GNOME_CANVAS_ITEM(text)->canvas;
+	canvas = FOO_CANVAS_ITEM(text)->canvas;
 	widget = GTK_WIDGET(canvas);
 	state = gtk_widget_get_state (widget);
 	style = gtk_widget_get_style (widget);
@@ -1551,7 +1551,7 @@ e_text_draw (GnomeCanvasItem *item, GdkDrawable *drawable,
 		return;
 
 	if (text->stipple)
-		gnome_canvas_set_stipple_origin (item->canvas, main_gc);
+		foo_canvas_set_stipple_origin (item->canvas, main_gc);
 
 	xpos = text->text_cx;
 	ypos = text->text_cy;
@@ -1687,8 +1687,8 @@ e_text_draw (GnomeCanvasItem *item, GdkDrawable *drawable,
 
 /* Point handler for the text item */
 static double
-e_text_point (GnomeCanvasItem *item, double x, double y,
-	      gint cx, gint cy, GnomeCanvasItem **actual_item)
+e_text_point (FooCanvasItem *item, double x, double y,
+	      gint cx, gint cy, FooCanvasItem **actual_item)
 {
 	EText *text;
 	double clip_width;
@@ -1737,7 +1737,7 @@ e_text_point (GnomeCanvasItem *item, double x, double y,
 
 /* Bounds handler for the text item */
 static void
-e_text_bounds (GnomeCanvasItem *item, double *x1, double *y1, double *x2, double *y2)
+e_text_bounds (FooCanvasItem *item, double *x1, double *y1, double *x2, double *y2)
 {
 	EText *text;
 	double width, height;
@@ -1908,7 +1908,7 @@ _blink_scroll_timeout (gpointer data)
 	}
 	if (redraw) {
 		text->needs_redraw = 1;
-		gnome_canvas_item_request_update (GNOME_CANVAS_ITEM(text));
+		foo_canvas_item_request_update (FOO_CANVAS_ITEM(text));
 	}
 	return TRUE;
 }
@@ -1923,18 +1923,18 @@ tooltip_event(GtkWidget *tooltip, GdkEvent *event, EText *text)
 
 	switch (event->type) {
 	case GDK_LEAVE_NOTIFY:
-		e_canvas_hide_tooltip (E_CANVAS(GNOME_CANVAS_ITEM(text)->canvas));
+		e_canvas_hide_tooltip (E_CANVAS(FOO_CANVAS_ITEM(text)->canvas));
 		break;
 	case GDK_BUTTON_PRESS:
 	case GDK_BUTTON_RELEASE:
 		if (event->type == GDK_BUTTON_RELEASE) {
-			e_canvas_hide_tooltip (E_CANVAS(GNOME_CANVAS_ITEM(text)->canvas));
+			e_canvas_hide_tooltip (E_CANVAS(FOO_CANVAS_ITEM(text)->canvas));
 		}
 		/* Forward events to the text item */
 		g_signal_emit_by_name (text, "event", event,
 				       &ret_val);
 		if (!ret_val)
-			gtk_propagate_event (GTK_WIDGET(GNOME_CANVAS_ITEM(text)->canvas), event);
+			gtk_propagate_event (GTK_WIDGET(FOO_CANVAS_ITEM(text)->canvas), event);
 		ret_val = TRUE;
 	default:
 		break;
@@ -1947,9 +1947,9 @@ tooltip_ungrab (GtkWidget *tooltip, GdkEvent *event, EText *text)
 {
 	gdk_keyboard_ungrab(GDK_CURRENT_TIME);
 
-	e_canvas_hide_tooltip (E_CANVAS(GNOME_CANVAS_ITEM(text)->canvas));
+	e_canvas_hide_tooltip (E_CANVAS(FOO_CANVAS_ITEM(text)->canvas));
 
-	gtk_propagate_event (GTK_WIDGET(GNOME_CANVAS_ITEM(text)->canvas), event);
+	gtk_propagate_event (GTK_WIDGET(FOO_CANVAS_ITEM(text)->canvas), event);
 
 	return TRUE;
 }
@@ -1975,8 +1975,8 @@ _do_tooltip (gpointer data)
 	ArtPoint origin = {0, 0};
 	ArtPoint pixel_origin;
 	gint canvas_x, canvas_y;
-	GnomeCanvas *text_canvas;
-	GnomeCanvasItem *tooltip_text;
+	FooCanvas *text_canvas;
+	FooCanvasItem *tooltip_text;
 	double tooltip_width;
 	double tooltip_height;
 	double tooltip_x;
@@ -1984,14 +1984,14 @@ _do_tooltip (gpointer data)
 #if 0
 	double x1, x2, y1, y2;
 #endif
-	GnomeCanvasItem *rect;
+	FooCanvasItem *rect;
 	GtkAdjustment *adjustment;
 	GtkWidget *tooltip_window;      /* GtkWindow for displaying the tooltip */
 	GdkWindow *window;
 
 	text->tooltip_count = 0;
 
-	text_canvas = GNOME_CANVAS_ITEM (text)->canvas;
+	text_canvas = FOO_CANVAS_ITEM (text)->canvas;
 
 	if (E_CANVAS(text_canvas)->tooltip_window || text->editing || !text->num_lines) {
 		text->tooltip_timeout = 0;
@@ -2015,7 +2015,7 @@ _do_tooltip (gpointer data)
 		return FALSE;
 	}
 
-	gnome_canvas_item_i2c_affine(GNOME_CANVAS_ITEM(text), i2c);
+	foo_canvas_item_i2c_affine(FOO_CANVAS_ITEM(text), i2c);
 	art_affine_point (&pixel_origin, &origin, i2c);
 
 	window = gtk_widget_get_window (GTK_WIDGET (text_canvas));
@@ -2038,15 +2038,15 @@ _do_tooltip (gpointer data)
 	/* Get the longest line length */
 	pango_layout_get_size (text->layout, &max_width, NULL);
 
-	rect = gnome_canvas_item_new (gnome_canvas_root (GNOME_CANVAS (canvas)),
-				      gnome_canvas_rect_get_type (),
+	rect = foo_canvas_item_new (foo_canvas_root (FOO_CANVAS (canvas)),
+				      foo_canvas_rect_get_type (),
 				      "x1", (double) 0,
 				      "y1", (double) 0,
 				      "x2", (double) max_width + 4,
 				      "y2", (double) text->height + 4,
 				      NULL);
 
-	tooltip_text = gnome_canvas_item_new (gnome_canvas_root (GNOME_CANVAS (canvas)),
+	tooltip_text = foo_canvas_item_new (foo_canvas_root (FOO_CANVAS (canvas)),
 					      e_text_get_type (),
 					      "anchor", GTK_ANCHOR_NW,
 					      "bold", text->bold,
@@ -2070,7 +2070,7 @@ _do_tooltip (gpointer data)
 	split_into_lines (E_TEXT(tooltip_text));
 	calc_height (E_TEXT(tooltip_text));
 
-	gnome_canvas_item_set (tooltip_text,
+	foo_canvas_item_set (tooltip_text,
 			       "clip_height", (double) E_TEXT(tooltip_text)->height,
 			       "clip_width", (double) E_TEXT(tooltip_text)->width,
 			       NULL);
@@ -2128,7 +2128,7 @@ _do_tooltip (gpointer data)
 		break;
 	}
 
-	gnome_canvas_item_set(rect,
+	foo_canvas_item_set(rect,
 			      "x2", (double) tooltip_width + 4 + (text->draw_borders ? BORDER_INDENT * 2 : 0),
 			      "y2", (double) tooltip_height + 4 + (text->draw_borders ? BORDER_INDENT * 2 : 0),
 			      NULL);
@@ -2139,7 +2139,7 @@ _do_tooltip (gpointer data)
 	gtk_widget_set_size_request (tooltip_window,
 				     tooltip_width + 4 + (text->draw_borders ? BORDER_INDENT * 2 : 0),
 				     tooltip_height + 4 + (text->draw_borders ? BORDER_INDENT * 2 : 0));
-	gnome_canvas_set_scroll_region (GNOME_CANVAS(canvas), 0.0, 0.0,
+	foo_canvas_set_scroll_region (FOO_CANVAS(canvas), 0.0, 0.0,
 					tooltip_width + (text->draw_borders ? BORDER_INDENT * 2 : 0),
 					(double)tooltip_height + (text->draw_borders ? BORDER_INDENT * 2 : 0));
 	g_signal_connect (tooltip_window, "event",
@@ -2182,7 +2182,7 @@ start_editing (EText *text)
 		GdkWindow *window;
 
 		window = gtk_widget_get_window (
-			GTK_WIDGET (GNOME_CANVAS_ITEM (text)->canvas));
+			GTK_WIDGET (FOO_CANVAS_ITEM (text)->canvas));
 
 		if (text->default_cursor_shown && (!text->draw_borders)) {
 			gdk_window_set_cursor (window, text->i_cursor);
@@ -2213,7 +2213,7 @@ e_text_stop_editing (EText *text)
 		GdkWindow *window;
 
 		window = gtk_widget_get_window (
-			GTK_WIDGET (GNOME_CANVAS_ITEM (text)->canvas));
+			GTK_WIDGET (FOO_CANVAS_ITEM (text)->canvas));
 		gdk_window_set_cursor (window, text->default_cursor);
 		text->default_cursor_shown = TRUE;
 	}
@@ -2240,7 +2240,7 @@ _click (gpointer data)
 }
 
 static gint
-e_text_event (GnomeCanvasItem *item, GdkEvent *event)
+e_text_event (FooCanvasItem *item, GdkEvent *event)
 {
 	EText *text = E_TEXT(item);
 	ETextEventProcessorEvent e_tep_event;
@@ -2320,12 +2320,12 @@ e_text_event (GnomeCanvasItem *item, GdkEvent *event)
 				if (text->show_cursor || text->draw_borders) {
 					text->show_cursor = FALSE;
 					text->needs_redraw = 1;
-					gnome_canvas_item_request_update (GNOME_CANVAS_ITEM(text));
+					foo_canvas_item_request_update (FOO_CANVAS_ITEM(text));
 				}
 			}
 			if ( text->line_wrap )
 				text->needs_split_into_lines = 1;
-			e_canvas_item_request_reflow (GNOME_CANVAS_ITEM(text));
+			e_canvas_item_request_reflow (FOO_CANVAS_ITEM(text));
 		}
 		return_val = 0;
 		break;
@@ -2404,7 +2404,7 @@ e_text_event (GnomeCanvasItem *item, GdkEvent *event)
 			g_source_remove (text->tooltip_timeout);
 			text->tooltip_timeout = 0;
 		}
-		e_canvas_hide_tooltip (E_CANVAS(GNOME_CANVAS_ITEM(text)->canvas));
+		e_canvas_hide_tooltip (E_CANVAS(FOO_CANVAS_ITEM(text)->canvas));
 #if 0
 		if ((!text->editing)
 		    && text->editable
@@ -2447,7 +2447,7 @@ e_text_event (GnomeCanvasItem *item, GdkEvent *event)
 		}
 
 		/* Create our own double and triple click events,
-		   as gnome-canvas doesn't forward them to us */
+		   as foo-canvas doesn't forward them to us */
 		if (event->type == GDK_BUTTON_PRESS) {
 			if (text->dbl_timeout == 0 &&
 			    text->tpl_timeout == 0) {
@@ -2538,8 +2538,8 @@ e_text_event (GnomeCanvasItem *item, GdkEvent *event)
 	}
 	if (return_val)
 		return return_val;
-	if (GNOME_CANVAS_ITEM_CLASS(e_text_parent_class)->event)
-		return GNOME_CANVAS_ITEM_CLASS(e_text_parent_class)->event(item, event);
+	if (FOO_CANVAS_ITEM_CLASS(e_text_parent_class)->event)
+		return FOO_CANVAS_ITEM_CLASS(e_text_parent_class)->event(item, event);
 	else
 		return 0;
 }
@@ -2558,7 +2558,7 @@ e_text_copy_clipboard (EText *text)
 	selection_end_pos = g_utf8_offset_to_pointer (text->text, selection_end_pos) - text->text;
 
 	gtk_clipboard_set_text (
-				gtk_widget_get_clipboard (GTK_WIDGET (GNOME_CANVAS_ITEM (text)->canvas),
+				gtk_widget_get_clipboard (GTK_WIDGET (FOO_CANVAS_ITEM (text)->canvas),
 							  GDK_SELECTION_CLIPBOARD),
 				text->text + selection_start_pos,
 				selection_end_pos - selection_start_pos);
@@ -2652,7 +2652,7 @@ e_text_update_primary_selection (EText *text)
 	};
 	GtkClipboard *clipboard;
 
-	clipboard = gtk_widget_get_clipboard (GTK_WIDGET (GNOME_CANVAS_ITEM (text)->canvas), GDK_SELECTION_PRIMARY);
+	clipboard = gtk_widget_get_clipboard (GTK_WIDGET (FOO_CANVAS_ITEM (text)->canvas), GDK_SELECTION_PRIMARY);
 
 	if (text->selection_start != text->selection_end) {
 		if (!gtk_clipboard_set_with_owner (clipboard, targets, G_N_ELEMENTS (targets),
@@ -2688,7 +2688,7 @@ e_text_paste (EText *text, GdkAtom selection)
 	g_object_ref (text);
 	gtk_clipboard_request_text (
 
-				    gtk_widget_get_clipboard (GTK_WIDGET (GNOME_CANVAS_ITEM (text)->canvas),
+				    gtk_widget_get_clipboard (GTK_WIDGET (FOO_CANVAS_ITEM (text)->canvas),
 							      selection),
 				    paste_received, text);
 }
@@ -2709,8 +2709,8 @@ static void
 popup_menu_placement_cb (GtkMenu *menu, gint *x, gint *y, gboolean *push_in, gpointer user_data)
 {
 	EText *text = E_TEXT(user_data);
-	GnomeCanvasItem *item = &text->item;
-	GnomeCanvas *parent = item->canvas;
+	FooCanvasItem *item = &text->item;
+	FooCanvas *parent = item->canvas;
 
 	if (parent) {
 		GdkWindow *window;
@@ -2739,7 +2739,7 @@ popup_targets_received (GtkClipboard     *clipboard,
 	g_free (closure);
 
 	gtk_menu_attach_to_widget (GTK_MENU (popup_menu),
-				   GTK_WIDGET(GNOME_CANVAS_ITEM (text)->canvas),
+				   GTK_WIDGET(FOO_CANVAS_ITEM (text)->canvas),
 				   popup_menu_detach);
 
 	/* cut menu item */
@@ -2822,7 +2822,7 @@ e_text_do_popup (EText *text, GdkEventButton *button, gint position)
 
 	gtk_clipboard_request_contents (
 
-					gtk_widget_get_clipboard (GTK_WIDGET (GNOME_CANVAS_ITEM (text)->canvas),
+					gtk_widget_get_clipboard (GTK_WIDGET (FOO_CANVAS_ITEM (text)->canvas),
 								  GDK_SELECTION_CLIPBOARD),
 					gdk_atom_intern ("TARGETS", FALSE),
 					popup_targets_received,
@@ -3394,8 +3394,8 @@ e_text_command(ETextEventProcessor *tep, ETextEventProcessorCommand *command, gp
 		text->select_by_word = command->value;
 		break;
 	case E_TEP_GRAB:
-		e_canvas_item_grab (E_CANVAS (GNOME_CANVAS_ITEM(text)->canvas),
-				    GNOME_CANVAS_ITEM(text),
+		e_canvas_item_grab (E_CANVAS (FOO_CANVAS_ITEM(text)->canvas),
+				    FOO_CANVAS_ITEM(text),
 				    GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK,
 				    text->i_cursor,
 				    command->time,
@@ -3404,8 +3404,8 @@ e_text_command(ETextEventProcessor *tep, ETextEventProcessorCommand *command, gp
 		scroll = FALSE;
 		break;
 	case E_TEP_UNGRAB:
-		e_canvas_item_ungrab (E_CANVAS (GNOME_CANVAS_ITEM(text)->canvas),
-				      GNOME_CANVAS_ITEM(text),
+		e_canvas_item_ungrab (E_CANVAS (FOO_CANVAS_ITEM(text)->canvas),
+				      FOO_CANVAS_ITEM(text),
 				      command->time);
 		scroll = FALSE;
 		break;
@@ -3522,7 +3522,7 @@ e_text_command(ETextEventProcessor *tep, ETextEventProcessorCommand *command, gp
 	}
 
 	text->needs_redraw = 1;
-	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM(text));
+	foo_canvas_item_request_update (FOO_CANVAS_ITEM(text));
 }
 
 /* Class initialization function for the text item */
@@ -3530,10 +3530,10 @@ static void
 e_text_class_init (ETextClass *klass)
 {
 	GObjectClass *gobject_class;
-	GnomeCanvasItemClass *item_class;
+	FooCanvasItemClass *item_class;
 
 	gobject_class = (GObjectClass *) klass;
-	item_class = (GnomeCanvasItemClass *) klass;
+	item_class = (FooCanvasItemClass *) klass;
 
 	gobject_class->dispose = e_text_dispose;
 	gobject_class->set_property = e_text_set_property;
@@ -3921,7 +3921,7 @@ e_text_init (EText *text)
 
 	text->handle_popup            = FALSE;
 
-	e_canvas_item_set_reflow_callback(GNOME_CANVAS_ITEM(text), e_text_reflow);
+	e_canvas_item_set_reflow_callback(FOO_CANVAS_ITEM(text), e_text_reflow);
 }
 
 /* IM Context Callbacks */
diff --git a/widgets/text/e-text.h b/widgets/text/e-text.h
index 057ff50..3780d00 100644
--- a/widgets/text/e-text.h
+++ b/widgets/text/e-text.h
@@ -21,9 +21,9 @@
  *
  * A majority of code taken from:
  *
- * Text item type for GnomeCanvas widget
+ * Text item type for FooCanvas widget
  *
- * GnomeCanvas is basically a port of the Tk toolkit's most excellent
+ * FooCanvas is basically a port of the Tk toolkit's most excellent
  * canvas widget.  Tk is copyrighted by the Regents of the University
  * of California, Sun Microsystems, and other parties.
  *
@@ -100,7 +100,7 @@ typedef struct _EText EText;
 typedef struct _ETextClass ETextClass;
 
 struct _EText {
-	GnomeCanvasItem item;
+	FooCanvasItem item;
 
 	ETextModel *model;
 	gint model_changed_signal_id;
@@ -220,7 +220,7 @@ struct _EText {
 };
 
 struct _ETextClass {
-	GnomeCanvasItemClass parent_class;
+	FooCanvasItemClass parent_class;
 
 	void (* changed)         (EText *text);
 	void (* activate)        (EText *text);
diff --git a/widgets/text/gal-a11y-e-text.c b/widgets/text/gal-a11y-e-text.c
index 113c503..cb6eaf5 100644
--- a/widgets/text/gal-a11y-e-text.c
+++ b/widgets/text/gal-a11y-e-text.c
@@ -519,7 +519,7 @@ et_get_character_extents (AtkText *text,
 {
         GObject *obj;
         EText *etext;
-        GnomeCanvas *canvas;
+        FooCanvas *canvas;
         gint x_widget, y_widget, x_window, y_window;
         GdkWindow *window;
         GtkWidget *widget;
@@ -531,7 +531,7 @@ et_get_character_extents (AtkText *text,
             return;
         g_return_if_fail (E_IS_TEXT (obj));
         etext = E_TEXT(obj);
-        canvas = GNOME_CANVAS_ITEM(etext)->canvas;
+        canvas = FOO_CANVAS_ITEM(etext)->canvas;
         widget = GTK_WIDGET(canvas);
         window = widget->window;
         gdk_window_get_origin (window, &x_widget, &y_widget);
@@ -596,7 +596,7 @@ et_get_offset_at_point (AtkText *text,
 {
         GObject *obj;
         EText *etext;
-        GnomeCanvas *canvas;
+        FooCanvas *canvas;
 	gint x_widget, y_widget, x_window, y_window;
 	GdkWindow *window;
         GtkWidget *widget;
@@ -609,7 +609,7 @@ et_get_offset_at_point (AtkText *text,
             return -1;
         g_return_val_if_fail (E_IS_TEXT (obj), -1);
         etext = E_TEXT(obj);
-        canvas = GNOME_CANVAS_ITEM(etext)->canvas;
+        canvas = FOO_CANVAS_ITEM(etext)->canvas;
         widget = GTK_WIDGET(canvas);
 	window = widget->window;
 	gdk_window_get_origin (window, &x_widget, &y_widget);
@@ -721,8 +721,8 @@ et_add_selection (AtkText *text,
 		etext->selection_start = real_start;
 		etext->selection_end = real_end;
 
-		gnome_canvas_item_grab_focus (GNOME_CANVAS_ITEM (etext));
-		gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (etext));
+		foo_canvas_item_grab_focus (FOO_CANVAS_ITEM (etext));
+		foo_canvas_item_request_update (FOO_CANVAS_ITEM (etext));
 
 		g_signal_emit_by_name (ATK_OBJECT (text), "text_selection_changed");
 
@@ -1096,7 +1096,7 @@ gal_a11y_e_text_get_type (void)
 			NULL
 		};
 
-		factory = atk_registry_get_factory (atk_get_default_registry (), GNOME_TYPE_CANVAS_ITEM);
+		factory = atk_registry_get_factory (atk_get_default_registry (), FOO_TYPE_CANVAS_ITEM);
 		parent_type = atk_object_factory_get_accessible_type (factory);
 
 		type = gal_a11y_type_register_static_with_private (PARENT_TYPE, "GalA11yEText", &info, 0,



[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]