Lots of reorganization to get the Evolution shell to begin its life. It

Lots of reorganization to get the Evolution shell to begin its life.
It also includes a new evolution widget from Damon.

Miguel.

svn path=/trunk/; revision=1536

1 files changed, 1696 insertions, 0 deletions

diff --git a/widgets/shortcut-bar/e-icon-bar-text-item.c b/widgets/shortcut-bar/e-icon-bar-text-item.c
new file mode 100644
index 0000000000..5548c630b3
--- /dev/null
+++ b/widgets/shortcut-bar/e-icon-bar-text-item.c
@@ -0,0 +1,1696 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/* 
+ * Author : 
+ *  Damon Chaplin <damon@gtk.org>
+ *
+ * Copyright 1999, Helix Code, Inc.
+ *
+ * This program is free software; you can redistribute it and/or 
+ * modify it under the terms of the GNU General Public License as 
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
+
+/*
+ * Based on gnome-icon-text-item:  an editable text block with word wrapping
+ * for the GNOME canvas.
+ *
+ * Copyright (C) 1998, 1999 The Free Software Foundation
+ *
+ * Authors: Miguel de Icaza <miguel@gnu.org>
+ *          Federico Mena <federico@gimp.org>
+ */
+
+/*
+ * EIconBarTextItem - An editable canvas text item for the EIconBar.
+ */
+
+#include <math.h>
+#include <gdk/gdkkeysyms.h>
+#include <gtk/gtkmain.h>
+#include <gtk/gtksignal.h>
+#include <gtk/gtkwindow.h>
+#include <libgnome/gnome-defs.h>
+#include <libgnome/gnome-i18n.h>
+
+#include "e-icon-bar-text-item.h"
+
+
+/* Margins used to display the information */
+#define MARGIN_X 2
+#define MARGIN_Y 2
+
+/* Default fontset to be used if the user specified fontset is not found */
+#define DEFAULT_FONT_NAME "-adobe-helvetica-medium-r-normal--*-100-*-*-*-*-*-*,"	\
+			  "-*-*-medium-r-normal--10-*-*-*-*-*-*-*,*"
+
+/* Separators for text layout */
+#define DEFAULT_SEPARATORS " \t-.[]#"
+
+/* This is the string to draw when the text is clipped, e.g. '...'. */
+static gchar *e_icon_bar_text_item_ellipsis;
+
+/* Aliases to minimize screen use in my laptop */
+#define ITI(x)       E_ICON_BAR_TEXT_ITEM (x)
+#define ITI_CLASS(x) E_ICON_BAR_TEXT_ITEM_CLASS (x)
+#define IS_ITI(x)    E_IS_ICON_BAR_TEXT_ITEM (x)
+
+
+typedef EIconBarTextItem Iti;
+
+/* Private part of the EIconBarTextItem structure */
+typedef struct {
+	/* Font */
+	GdkFont *font;
+
+	/* Hack: create an offscreen window and place an entry inside it */
+	GtkEntry *entry;
+	GtkWidget *entry_top;
+
+	/* Whether the user pressed the mouse while the item was unselected */
+	guint unselected_click : 1;
+
+	/* Whether we need to update the position */
+	guint need_pos_update : 1;
+
+	/* Whether we need to update the font */
+	guint need_font_update : 1;
+
+	/* Whether we need to update the text */
+	guint need_text_update : 1;
+
+	/* Whether we need to update because the editing/selected state changed */
+	guint need_state_update : 1;
+} ItiPrivate;
+
+typedef struct _EIconBarTextItemInfoRow   EIconBarTextItemInfoRow;
+
+struct _EIconBarTextItemInfoRow {
+	gchar *text;
+	gint width;
+	GdkWChar *text_wc;	/* text in wide characters */
+	gint text_length;	/* number of characters */
+};
+
+struct _EIconBarTextItemInfo {
+	GList *rows;
+	GdkFont *font;
+	gint width;
+	gint height;
+	gint baseline_skip;
+};
+
+static GnomeCanvasItemClass *parent_class;
+
+enum {
+	ARG_0,
+	ARG_XALIGN,
+	ARG_JUSTIFY,
+	ARG_MAX_LINES,
+	ARG_SHOW_ELLIPSIS
+};
+
+enum {
+	TEXT_CHANGED,
+	HEIGHT_CHANGED,
+	WIDTH_CHANGED,
+	EDITING_STARTED,
+	EDITING_STOPPED,
+	SELECTION_STARTED,
+	SELECTION_STOPPED,
+	LAST_SIGNAL
+};
+
+static guint iti_signals [LAST_SIGNAL] = { 0 };
+
+static GdkFont *default_font;
+
+static void e_icon_bar_text_item_free_info (EIconBarTextItemInfo *ti);
+static EIconBarTextItemInfo *e_icon_bar_text_item_layout_text (EIconBarTextItem *iti, GdkFont *font, const gchar *text, const gchar *separators, gint max_width, gboolean confine);
+static void e_icon_bar_text_item_paint_text (EIconBarTextItem	  *iti,
+					     EIconBarTextItemInfo *ti,
+					     GdkDrawable	  *drawable,
+					     GdkGC		  *gc,
+					     gint		   x,
+					     gint		   y,
+					     GtkJustification	   just);
+
+
+/* Stops the editing state of an icon text item */
+static void
+iti_stop_editing (Iti *iti)
+{
+	ItiPrivate *priv;
+
+	priv = iti->priv;
+
+	iti->editing = FALSE;
+
+	gtk_widget_destroy (priv->entry_top);
+	priv->entry = NULL;
+	priv->entry_top = NULL;
+
+	priv->need_state_update = TRUE;
+	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (iti));
+
+	gtk_signal_emit (GTK_OBJECT (iti), iti_signals[EDITING_STOPPED]);
+}
+
+/* Lays out the text in an icon item */
+static void
+layout_text (Iti *iti)
+{
+	ItiPrivate *priv;
+	char *text;
+	int old_width, old_height;
+	int width, height;
+
+	priv = iti->priv;
+
+	/* Save old size */
+
+	if (iti->ti) {
+		old_width = iti->ti->width + 2 * MARGIN_X;
+		old_height = iti->ti->height + 2 * MARGIN_Y;
+
+		e_icon_bar_text_item_free_info (iti->ti);
+	} else {
+		old_width = 2 * MARGIN_X;
+		old_height = 2 * MARGIN_Y;
+	}
+
+	/* Change the text layout */
+
+	if (iti->editing)
+		text = gtk_entry_get_text (priv->entry);
+	else
+		text = iti->text;
+
+	iti->ti = e_icon_bar_text_item_layout_text (iti, priv->font,
+						    text,
+						    DEFAULT_SEPARATORS,
+						    iti->width - 2 * MARGIN_X,
+						    TRUE);
+
+	/* Check the sizes and see if we need to emit any signals */
+
+	width = iti->ti->width + 2 * MARGIN_X;
+	height = iti->ti->height + 2 * MARGIN_Y;
+
+	if (width != old_width)
+		gtk_signal_emit (GTK_OBJECT (iti), iti_signals[WIDTH_CHANGED]);
+
+	if (height != old_height)
+		gtk_signal_emit (GTK_OBJECT (iti), iti_signals[HEIGHT_CHANGED]);
+}
+
+/* Accepts the text in the off-screen entry of an icon text item */
+static void
+iti_edition_accept (Iti *iti)
+{
+	ItiPrivate *priv;
+	gboolean accept;
+
+	priv = iti->priv;
+	accept = TRUE;
+
+	gtk_signal_emit (GTK_OBJECT (iti), iti_signals [TEXT_CHANGED], &accept);
+
+	if (iti->editing){
+		if (accept) {
+			if (iti->is_text_allocated)
+				g_free (iti->text);
+
+			iti->text = g_strdup (gtk_entry_get_text (priv->entry));
+			iti->is_text_allocated = 1;
+		}
+
+		iti_stop_editing (iti);
+	}
+
+	priv->need_text_update = TRUE;
+	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (iti));
+}
+
+/* Callback used when the off-screen entry of an icon text item is activated.
+ * When this happens, we have to accept edition.
+ */
+static void
+iti_entry_activate (GtkWidget *entry, Iti *iti)
+{
+	iti_edition_accept (iti);
+}
+
+/* Starts the editing state of an icon text item */
+static void
+iti_start_editing (Iti *iti)
+{
+	ItiPrivate *priv;
+
+	priv = iti->priv;
+
+	if (iti->editing)
+		return;
+
+	/* Trick: The actual edition of the entry takes place in a GtkEntry
+	 * which is placed offscreen.  That way we get all of the advantages
+	 * from GtkEntry without duplicating code.  Yes, this is a hack.
+	 */
+	priv->entry = (GtkEntry *) gtk_entry_new ();
+	gtk_entry_set_text (priv->entry, iti->text);
+	gtk_signal_connect (GTK_OBJECT (priv->entry), "activate",
+			    GTK_SIGNAL_FUNC (iti_entry_activate), iti);
+
+	priv->entry_top = gtk_window_new (GTK_WINDOW_POPUP);
+	gtk_container_add (GTK_CONTAINER (priv->entry_top), GTK_WIDGET (priv->entry));
+	gtk_widget_set_uposition (priv->entry_top, 20000, 20000);
+	gtk_widget_show_all (priv->entry_top);
+
+	gtk_editable_select_region (GTK_EDITABLE (priv->entry), 0, -1);
+
+	iti->editing = TRUE;
+
+	priv->need_text_update = TRUE;
+	priv->need_state_update = TRUE;
+	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (iti));
+
+	gtk_signal_emit (GTK_OBJECT (iti), iti_signals[EDITING_STARTED]);
+}
+
+/* Destroy method handler for the icon text item */
+static void
+iti_destroy (GtkObject *object)
+{
+	Iti *iti;
+	ItiPrivate *priv;
+	GnomeCanvasItem *item;
+
+	g_return_if_fail (object != NULL);
+	g_return_if_fail (IS_ITI (object));
+
+	iti = ITI (object);
+	priv = iti->priv;
+	item = GNOME_CANVAS_ITEM (object);
+
+	/* FIXME: stop selection and editing */
+
+	/* Queue redraw of bounding box */
+
+	gnome_canvas_request_redraw (item->canvas, item->x1, item->y1, item->x2, item->y2);
+
+	/* Free everything */
+
+	if (iti->fontname)
+		g_free (iti->fontname);
+
+	if (iti->text && iti->is_text_allocated)
+		g_free (iti->text);
+
+	if (iti->ti)
+		e_icon_bar_text_item_free_info (iti->ti);
+
+	if (priv->font)
+		gdk_font_unref (priv->font);
+
+	if (priv->entry_top)
+		gtk_widget_destroy (priv->entry_top);
+
+	g_free (priv);
+
+	if (GTK_OBJECT_CLASS (parent_class)->destroy)
+		(* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
+}
+
+/* set_arg handler for the icon text item */
+static void
+iti_set_arg (GtkObject *object, GtkArg *arg, guint arg_id)
+{
+	Iti *iti;
+	GnomeCanvasItem *item;
+	ItiPrivate *priv;
+	gfloat xalign;
+	gint max_lines;
+	gboolean show_ellipsis;
+	GtkJustification justification;
+
+	iti = ITI (object);
+	item = GNOME_CANVAS_ITEM (object);
+	priv = iti->priv;
+
+	switch (arg_id) {
+	case ARG_XALIGN:
+		xalign = GTK_VALUE_FLOAT (*arg);
+		if (iti->xalign != xalign) {
+			iti->xalign = xalign;
+			priv->need_pos_update = TRUE;
+			gnome_canvas_item_request_update (item);
+		}
+		break;
+	case ARG_JUSTIFY:
+		justification = GTK_VALUE_ENUM (*arg);
+		if (iti->justification != justification) {
+			iti->justification = justification;
+			priv->need_text_update = TRUE;
+			gnome_canvas_item_request_update (item);
+		}
+		break;
+	case ARG_MAX_LINES:
+		max_lines = GTK_VALUE_INT (*arg);
+		if (iti->max_lines != max_lines) {
+			iti->max_lines = max_lines;
+			priv->need_text_update = TRUE;
+			gnome_canvas_item_request_update (item);
+		}
+		break;
+	case ARG_SHOW_ELLIPSIS:
+		show_ellipsis = GTK_VALUE_BOOL (*arg);
+		if (iti->show_ellipsis != show_ellipsis) {
+			iti->show_ellipsis = show_ellipsis;
+			priv->need_text_update = TRUE;
+			gnome_canvas_item_request_update (item);
+		}
+		break;
+	default:
+		break;
+	}
+}
+
+static void
+iti_get_arg (GtkObject *object, GtkArg *arg, guint arg_id)
+{
+	Iti *iti;
+	ItiPrivate *priv;
+
+	iti = ITI (object);
+	priv = iti->priv;
+
+	switch (arg_id)	{
+	case ARG_XALIGN:
+		GTK_VALUE_FLOAT (*arg) = iti->xalign;
+		break;
+	case ARG_JUSTIFY:
+		GTK_VALUE_ENUM (*arg) = iti->justification;
+		break;
+	case ARG_MAX_LINES:
+		GTK_VALUE_INT (*arg) = iti->max_lines;
+		break;
+	case ARG_SHOW_ELLIPSIS:
+		GTK_VALUE_BOOL (*arg) = iti->show_ellipsis;
+		break;
+	default:
+		arg->type = GTK_TYPE_INVALID;
+		break;
+	}
+}
+
+/* Loads the default font for icon text items if necessary */
+static GdkFont *
+get_default_font (void)
+{
+	if (!default_font) {
+		/* FIXME: this is never unref-ed */
+		default_font = gdk_fontset_load (DEFAULT_FONT_NAME);
+		g_assert (default_font != NULL);
+	}
+
+	return gdk_font_ref (default_font);
+}
+
+/* Recomputes the bounding box of an icon text item */
+static void
+recompute_bounding_box (Iti *iti)
+{
+	GnomeCanvasItem *item;
+	double affine[6];
+	ArtPoint p, q;
+	int x1, y1, x2, y2;
+	int width, height;
+
+	item = GNOME_CANVAS_ITEM (iti);
+
+	/* Compute width, height, position */
+
+	width = iti->ti->width + 2 * MARGIN_X;
+	height = iti->ti->height + 2 * MARGIN_Y;
+
+	x1 = iti->x + (iti->width - width) * iti->xalign;
+	y1 = iti->y;
+	x2 = x1 + width;
+	y2 = y1 + height;
+
+	/* Translate to world coordinates */
+
+	gnome_canvas_item_i2w_affine (item, affine);
+
+	p.x = x1;
+	p.y = y1;
+	art_affine_point (&q, &p, affine);
+	item->x1 = q.x;
+	item->y1 = q.y;
+
+	p.x = x2;
+	p.y = y2;
+	art_affine_point (&q, &p, affine);
+	item->x2 = q.x;
+	item->y2 = q.y;
+}
+
+/* Update method for the icon text item */
+static void
+iti_update (GnomeCanvasItem *item, double *affine, ArtSVP *clip_path, int flags)
+{
+	Iti *iti;
+	ItiPrivate *priv;
+
+	iti = ITI (item);
+	priv = iti->priv;
+
+	if (parent_class->update)
+		(* parent_class->update) (item, affine, clip_path, flags);
+
+	/* If necessary, queue a redraw of the old bounding box */
+
+	if ((flags & GNOME_CANVAS_UPDATE_VISIBILITY)
+	    || (flags & GNOME_CANVAS_UPDATE_AFFINE)
+	    || priv->need_pos_update
+	    || priv->need_font_update
+	    || priv->need_text_update)
+		gnome_canvas_request_redraw (item->canvas, item->x1, item->y1, item->x2, item->y2);
+
+	 if (priv->need_text_update)
+		 layout_text (iti);
+
+	/* Compute new bounds */
+
+	if (priv->need_pos_update
+	    || priv->need_font_update
+	    || priv->need_text_update)
+		recompute_bounding_box (iti);
+
+	/* Queue redraw */
+
+	gnome_canvas_request_redraw (item->canvas, item->x1, item->y1, item->x2, item->y2);
+
+	priv->need_pos_update = FALSE;
+	priv->need_font_update = FALSE;
+	priv->need_text_update = FALSE;
+	priv->need_state_update = FALSE;
+}
+
+/* Draw the icon text item's text when it is being edited */
+static void
+iti_paint_text (Iti *iti, GdkDrawable *drawable, int x, int y)
+{
+	ItiPrivate *priv;
+        EIconBarTextItemInfoRow *row;
+	EIconBarTextItemInfo *ti;
+	GtkStyle *style;
+	GdkGC *fg_gc, *bg_gc;
+	GdkGC *gc, *bgc, *sgc, *bsgc;
+        GList *item;
+        int xpos, len;
+
+	priv = iti->priv;
+	style = GTK_WIDGET (GNOME_CANVAS_ITEM (iti)->canvas)->style;
+
+	ti = iti->ti;
+	len = 0;
+        y += ti->font->ascent;
+
+	/*
+	 * Pointers to all of the GCs we use
+	 */
+	gc = style->black_gc;
+	bgc = style->white_gc;
+	sgc = style->fg_gc [GTK_STATE_SELECTED];
+	bsgc = style->bg_gc [GTK_STATE_SELECTED];
+
+        for (item = ti->rows; item; item = item->next, len += (row ? row->text_length : 0)) {
+		GdkWChar *text_wc;
+		int text_length;
+		int cursor, offset, i;
+		int sel_start, sel_end;
+
+		row = item->data;
+
+                if (!row) {
+			y += ti->baseline_skip;
+			continue;
+		}
+
+		text_wc = row->text_wc;
+		text_length = row->text_length;
+
+		switch (iti->justification) {
+		case GTK_JUSTIFY_LEFT:
+			xpos = 0;
+			break;
+
+		case GTK_JUSTIFY_RIGHT:
+			xpos = ti->width - row->width;
+			break;
+
+		case GTK_JUSTIFY_CENTER:
+			xpos = (ti->width - row->width) / 2;
+			break;
+
+		default:
+			/* Anyone care to implement GTK_JUSTIFY_FILL? */
+			g_warning ("Justification type %d not supported.  Using left-justification.",
+				   (int) iti->justification);
+			xpos = 0;
+		}
+
+		sel_start = GTK_EDITABLE (priv->entry)->selection_start_pos - len;
+		sel_end = GTK_EDITABLE (priv->entry)->selection_end_pos - len;
+		offset = 0;
+		cursor = GTK_EDITABLE (priv->entry)->current_pos - len;
+
+		for (i = 0; *text_wc; text_wc++, i++) {
+			int size, px;
+
+			size = gdk_text_width_wc (ti->font, text_wc, 1);
+
+			if (i >= sel_start && i < sel_end) {
+				fg_gc = sgc;
+				bg_gc = bsgc;
+			} else {
+				fg_gc = gc;
+				bg_gc = bgc;
+			}
+
+			px = x + xpos + offset;
+			gdk_draw_rectangle (drawable,
+					    bg_gc,
+					    TRUE,
+					    px,
+					    y - ti->font->ascent,
+					    size, ti->baseline_skip);
+
+			gdk_draw_text_wc (drawable,
+					  ti->font,
+					  fg_gc,
+					  px, y,
+					  text_wc, 1);
+
+			if (cursor == i)
+				gdk_draw_line (drawable,
+					       gc,
+					       px - 1,
+					       y - ti->font->ascent,
+					       px - 1,
+					       y + ti->font->descent - 1);
+
+			offset += size;
+		}
+
+		if (cursor == i) {
+			int px = x + xpos + offset;
+
+			gdk_draw_line (drawable,
+				       gc,
+				       px - 1,
+				       y - ti->font->ascent,
+				       px - 1,
+				       y + ti->font->descent - 1);
+		}
+
+		y += ti->baseline_skip;
+        }
+}
+
+/* Draw method handler for the icon text item */
+static void
+iti_draw (GnomeCanvasItem *item, GdkDrawable *drawable, int x, int y, int width, int height)
+{
+	Iti *iti;
+	GtkStyle *style;
+	int w, h;
+	int xofs, yofs;
+
+	iti = ITI (item);
+
+	if (iti->ti) {
+		w = iti->ti->width + 2 * MARGIN_X;
+		h = iti->ti->height + 2 * MARGIN_Y;
+	} else {
+		w = 2 * MARGIN_X;
+		h = 2 * MARGIN_Y;
+	}
+
+	xofs = item->x1 - x;
+	yofs = item->y1 - y;
+
+	style = GTK_WIDGET (item->canvas)->style;
+
+	if (iti->selected && !iti->editing)
+		gdk_draw_rectangle (drawable,
+				    style->bg_gc[GTK_STATE_SELECTED],
+				    TRUE,
+				    xofs, yofs,
+				    w, h);
+
+	if (iti->editing) {
+		gdk_draw_rectangle (drawable,
+				    style->white_gc,
+				    TRUE,
+				    xofs + 1, yofs + 1,
+				    w - 2, h - 2);
+		gdk_draw_rectangle (drawable,
+				    style->black_gc,
+				    FALSE,
+				    xofs, yofs,
+				    w - 1, h - 1);
+
+		iti_paint_text (iti, drawable, xofs + MARGIN_X, yofs + MARGIN_Y);
+	} else
+		e_icon_bar_text_item_paint_text (iti, iti->ti,
+						 drawable,
+						 style->fg_gc[(iti->selected
+							       ? GTK_STATE_SELECTED
+							       : GTK_STATE_NORMAL)],
+						 xofs + MARGIN_X,
+						 yofs + MARGIN_Y,
+						 iti->justification);
+}
+
+/* Point method handler for the icon text item */
+static double
+iti_point (GnomeCanvasItem *item, double x, double y, int cx, int cy, GnomeCanvasItem **actual_item)
+{
+	double dx, dy;
+
+	*actual_item = item;
+
+	if (cx < item->x1)
+		dx = item->x1 - cx;
+	else if (cx > item->x2)
+		dx = cx - item->x2;
+	else
+		dx = 0.0;
+
+	if (cy < item->y1)
+		dy = item->y1 - cy;
+	else if (cy > item->y2)
+		dy = cy - item->y2;
+	else
+		dy = 0.0;
+
+	return sqrt (dx * dx + dy * dy);
+}
+
+/* Given X, Y, a mouse position, return a valid index inside the edited text */
+static int
+iti_idx_from_x_y (Iti *iti, int x, int y)
+{
+	ItiPrivate *priv;
+        EIconBarTextItemInfoRow *row;
+	int lines;
+	int line, col, i, idx;
+	GList *l;
+
+	priv = iti->priv;
+
+	if (iti->ti->rows == NULL)
+		return 0;
+
+	lines = g_list_length (iti->ti->rows);
+	line = y / iti->ti->baseline_skip;
+
+	if (line < 0)
+		line = 0;
+	else if (lines < line + 1)
+		line = lines - 1;
+
+	/* Compute the base index for this line */
+	for (l = iti->ti->rows, idx = i = 0; i < line; l = l->next, i++) {
+		row = l->data;
+		idx += row->text_length;
+	}
+
+	row = g_list_nth (iti->ti->rows, line)->data;
+	col = 0;
+	if (row != NULL) {
+		int first_char;
+		int last_char;
+
+		first_char = (iti->ti->width - row->width) / 2;
+		last_char = first_char + row->width;
+
+		if (x < first_char) {
+			/* nothing */
+		} else if (x > last_char) {
+			col = row->text_length;
+		} else {
+			GdkWChar *s = row->text_wc;
+			int pos = first_char;
+
+			while (pos < last_char) {
+				pos += gdk_text_width_wc (iti->ti->font, s, 1);
+				if (pos > x)
+					break;
+				col++;
+				s++;
+			}
+		}
+	}
+
+	idx += col;
+
+	g_assert (idx <= priv->entry->text_size);
+
+	return idx;
+}
+
+/* Starts the selection state in the icon text item */
+static void
+iti_start_selecting (Iti *iti, int idx, guint32 event_time)
+{
+	ItiPrivate *priv;
+	GtkEditable *e;
+	GdkCursor *ibeam;
+
+	priv = iti->priv;
+	e = GTK_EDITABLE (priv->entry);
+
+	gtk_editable_select_region (e, idx, idx);
+	gtk_editable_set_position (e, idx);
+	ibeam = gdk_cursor_new (GDK_XTERM);
+	gnome_canvas_item_grab (GNOME_CANVAS_ITEM (iti),
+				GDK_BUTTON_RELEASE_MASK |
+				GDK_POINTER_MOTION_MASK,
+				ibeam, event_time);
+	gdk_cursor_destroy (ibeam);
+
+	gtk_editable_select_region (e, idx, idx);
+	e->current_pos = e->selection_start_pos;
+	e->has_selection = TRUE;
+	iti->selecting = TRUE;
+
+	priv->need_state_update = TRUE;
+	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (iti));
+
+	gtk_signal_emit (GTK_OBJECT (iti), iti_signals[SELECTION_STARTED]);
+}
+
+/* Stops the selection state in the icon text item */
+static void
+iti_stop_selecting (Iti *iti, guint32 event_time)
+{
+	ItiPrivate *priv;
+	GnomeCanvasItem *item;
+	GtkEditable *e;
+
+	priv = iti->priv;
+	item = GNOME_CANVAS_ITEM (iti);
+	e = GTK_EDITABLE (priv->entry);
+
+	gnome_canvas_item_ungrab (item, event_time);
+	e->has_selection = FALSE;
+	iti->selecting = FALSE;
+
+	priv->need_state_update = TRUE;
+	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (iti));
+	gtk_signal_emit (GTK_OBJECT (iti), iti_signals[SELECTION_STOPPED]);
+}
+
+/* Handles selection range changes on the icon text item */
+static void
+iti_selection_motion (Iti *iti, int idx)
+{
+	ItiPrivate *priv;
+	GtkEditable *e;
+
+	priv = iti->priv;
+	e = GTK_EDITABLE (priv->entry);
+
+	if (idx < e->current_pos) {
+		e->selection_start_pos = idx;
+		e->selection_end_pos   = e->current_pos;
+	} else {
+		e->selection_start_pos = e->current_pos;
+		e->selection_end_pos  = idx;
+	}
+
+	priv->need_state_update = TRUE;
+	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (iti));
+}
+
+/* Event handler for icon text items */
+static gint
+iti_event (GnomeCanvasItem *item, GdkEvent *event)
+{
+	Iti *iti;
+	ItiPrivate *priv;
+	int idx;
+	double x, y;
+
+	iti = ITI (item);
+	priv = iti->priv;
+
+	switch (event->type) {
+	case GDK_KEY_PRESS:
+		if (!iti->editing)
+			break;
+
+		if (event->key.keyval == GDK_Escape)
+			iti_stop_editing (iti);
+		else
+			gtk_widget_event (GTK_WIDGET (priv->entry), event);
+
+		priv->need_text_update = TRUE;
+		gnome_canvas_item_request_update (item);
+		return TRUE;
+
+	case GDK_BUTTON_PRESS:
+		if (!iti->editing)
+			break;
+
+		if (iti->editing && event->button.button == 1) {
+			x = event->button.x - (item->x1 + MARGIN_X);
+			y = event->button.y - (item->y1 + MARGIN_Y);
+			idx = iti_idx_from_x_y (iti, x, y);
+
+			iti_start_selecting (iti, idx, event->button.time);
+		}
+
+		return TRUE;
+
+	case GDK_MOTION_NOTIFY:
+		if (!iti->selecting)
+			break;
+
+		x = event->motion.x - (item->x1 + MARGIN_X);
+		y = event->motion.y - (item->y1 + MARGIN_Y);
+		idx = iti_idx_from_x_y (iti, x, y);
+		iti_selection_motion (iti, idx);
+		return TRUE;
+
+	case GDK_BUTTON_RELEASE:
+		if (iti->selecting && event->button.button == 1)
+			iti_stop_selecting (iti, event->button.time);
+		else
+			break;
+
+		return TRUE;
+
+	default:
+		break;
+	}
+
+	return FALSE;
+}
+
+/* Bounds method handler for the icon text item */
+static void
+iti_bounds (GnomeCanvasItem *item, double *x1, double *y1, double *x2, double *y2)
+{
+	Iti *iti;
+	ItiPrivate *priv;
+	int width, height;
+
+	iti = ITI (item);
+	priv = iti->priv;
+
+	if (priv->need_text_update) {
+		layout_text (iti);
+		priv->need_text_update = FALSE;
+	}
+
+	if (iti->ti) {
+		width = iti->ti->width + 2 * MARGIN_X;
+		height = iti->ti->height + 2 * MARGIN_Y;
+	} else {
+		width = 2 * MARGIN_X;
+		height = 2 * MARGIN_Y;
+	}
+
+	*x1 = iti->x + (iti->width - width) * iti->xalign;
+	*y1 = iti->y;
+	*x2 = *x1 + width;
+	*y2 = *y1 + height;
+}
+
+/* Class initialization function for the icon text item */
+static void
+iti_class_init (EIconBarTextItemClass *text_item_class)
+{
+	GtkObjectClass  *object_class;
+	GnomeCanvasItemClass *item_class;
+
+	object_class = (GtkObjectClass *) text_item_class;
+	item_class   = (GnomeCanvasItemClass *) text_item_class;
+
+	parent_class = gtk_type_class (gnome_canvas_item_get_type ());
+
+	gtk_object_add_arg_type ("EIconBarTextItem::xalign", GTK_TYPE_FLOAT, GTK_ARG_READWRITE, ARG_XALIGN);
+	gtk_object_add_arg_type ("EIconBarTextItem::justify", GTK_TYPE_JUSTIFICATION, GTK_ARG_READWRITE, ARG_JUSTIFY);
+	gtk_object_add_arg_type ("EIconBarTextItem::max_lines", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_MAX_LINES);
+	gtk_object_add_arg_type ("EIconBarTextItem::show_ellipsis", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_SHOW_ELLIPSIS);
+
+	iti_signals [TEXT_CHANGED] =
+		gtk_signal_new (
+			"text_changed",
+			GTK_RUN_LAST,
+			object_class->type,
+			GTK_SIGNAL_OFFSET (EIconBarTextItemClass, text_changed),
+			gtk_marshal_BOOL__NONE,
+			GTK_TYPE_BOOL, 0);
+
+	iti_signals [HEIGHT_CHANGED] =
+		gtk_signal_new (
+			"height_changed",
+			GTK_RUN_LAST,
+			object_class->type,
+			GTK_SIGNAL_OFFSET (EIconBarTextItemClass, height_changed),
+			gtk_marshal_NONE__NONE,
+			GTK_TYPE_NONE, 0);
+
+	iti_signals [WIDTH_CHANGED] =
+		gtk_signal_new (
+			"width_changed",
+			GTK_RUN_LAST,
+			object_class->type,
+			GTK_SIGNAL_OFFSET (EIconBarTextItemClass, width_changed),
+			gtk_marshal_NONE__NONE,
+			GTK_TYPE_NONE, 0);
+
+	iti_signals[EDITING_STARTED] =
+		gtk_signal_new (
+			"editing_started",
+			GTK_RUN_LAST,
+			object_class->type,
+			GTK_SIGNAL_OFFSET (EIconBarTextItemClass, editing_started),
+			gtk_marshal_NONE__NONE,
+			GTK_TYPE_NONE, 0);
+
+	iti_signals[EDITING_STOPPED] =
+		gtk_signal_new (
+			"editing_stopped",
+			GTK_RUN_LAST,
+			object_class->type,
+			GTK_SIGNAL_OFFSET (EIconBarTextItemClass, editing_stopped),
+			gtk_marshal_NONE__NONE,
+			GTK_TYPE_NONE, 0);
+
+	iti_signals[SELECTION_STARTED] =
+		gtk_signal_new (
+			"selection_started",
+			GTK_RUN_FIRST,
+			object_class->type,
+			GTK_SIGNAL_OFFSET (EIconBarTextItemClass, selection_started),
+			gtk_marshal_NONE__NONE,
+			GTK_TYPE_NONE, 0);
+
+	iti_signals[SELECTION_STOPPED] =
+		gtk_signal_new (
+			"selection_stopped",
+			GTK_RUN_FIRST,
+			object_class->type,
+			GTK_SIGNAL_OFFSET (EIconBarTextItemClass, selection_stopped),
+			gtk_marshal_NONE__NONE,
+			GTK_TYPE_NONE, 0);
+
+	gtk_object_class_add_signals (object_class, iti_signals, LAST_SIGNAL);
+
+	object_class->destroy = iti_destroy;
+	object_class->get_arg = iti_get_arg;
+	object_class->set_arg = iti_set_arg;
+
+	item_class->update = iti_update;
+	item_class->draw = iti_draw;
+	item_class->point = iti_point;
+	item_class->bounds = iti_bounds;
+	item_class->event = iti_event;
+
+	e_icon_bar_text_item_ellipsis = _("...");
+}
+
+/* Object initialization function for the icon text item */
+static void
+iti_init (EIconBarTextItem *iti)
+{
+	ItiPrivate *priv;
+
+	priv = g_new0 (ItiPrivate, 1);
+	iti->priv = priv;
+
+	iti->xalign = 0.5;
+	iti->justification = GTK_JUSTIFY_CENTER;
+	iti->max_lines = -1;
+	iti->show_ellipsis = TRUE;
+}
+
+/**
+ * e_icon_bar_text_item_configure:
+ * @iti: An #EIconBarTextItem.
+ * @x: X position in which to place the item.
+ * @y: Y position in which to place the item.
+ * @width: Maximum width allowed for this item, to be used for word wrapping.
+ * @fontname: Name of the fontset that should be used to display the text.
+ * @text: Text that is going to be displayed.
+ * @is_static: Whether @text points to a static string or not.
+ *
+ * This routine is used to configure an #EIconBarTextItem.
+ *
+ * @x and @y specify the coordinates where the item is placed in the canvas.
+ * The @x coordinate should be the leftmost position that the item can
+ * assume at any one time, that is, the left margin of the column in which the
+ * icon is to be placed.  The @y coordinate specifies the top of the item.
+ *
+ * @width is the maximum width allowed for this icon text item. The coordinates
+ * define the upper-left corner of an item with maximum width; this may
+ * actually be outside the bounding box of the item if the text is narrower
+ * than the maximum width.
+ *
+ * If @is_static is true, it means that there is no need for the item to
+ * allocate memory for the string (it is a guarantee that the text is allocated
+ * by the caller and it will not be deallocated during the lifetime of this
+ * item).  This is an optimization to reduce memory usage for large icon sets.
+ */
+void
+e_icon_bar_text_item_configure (EIconBarTextItem *iti, int x, int y,
+				int width, const char *fontname,
+				const char *text,
+				gboolean is_static)
+{
+	ItiPrivate *priv;
+
+	g_return_if_fail (iti != NULL);
+	g_return_if_fail (IS_ITI (iti));
+	g_return_if_fail (width > 2 * MARGIN_X);
+	g_return_if_fail (text != NULL);
+
+	priv = iti->priv;
+
+	iti->x = x;
+	iti->y = y;
+	iti->width = width;
+
+	if (iti->text && iti->is_text_allocated)
+		g_free (iti->text);
+
+	iti->is_text_allocated = !is_static;
+
+	/* This cast is to shut up the compiler */
+	if (is_static)
+		iti->text = (char *) text;
+	else
+		iti->text = g_strdup (text);
+
+	if (iti->fontname)
+		g_free (iti->fontname);
+
+	iti->fontname = g_strdup (fontname ? fontname : DEFAULT_FONT_NAME);
+
+	if (priv->font)
+		gdk_font_unref (priv->font);
+
+	priv->font = NULL;
+	if (fontname)
+		priv->font = gdk_fontset_load (iti->fontname);
+	if (!priv->font)
+		priv->font = get_default_font ();
+
+	/* Request update */
+
+	priv->need_pos_update = TRUE;
+	priv->need_font_update = TRUE;
+	priv->need_text_update = TRUE;
+	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (iti));
+}
+
+/**
+ * e_icon_bar_text_item_set_width:
+ * @iti: An #EIconBarTextItem.
+ * @width: Maximum width allowed for this item, to be used for word wrapping.
+ *
+ * This routine is used to set the maximum width of an #EIconBarTextItem.
+ */
+void
+e_icon_bar_text_item_set_width (EIconBarTextItem *iti, int width)
+{
+	ItiPrivate *priv;
+
+	g_return_if_fail (iti != NULL);
+	g_return_if_fail (IS_ITI (iti));
+	g_return_if_fail (width > 2 * MARGIN_X);
+
+	priv = iti->priv;
+
+	if (iti->width == width)
+		return;
+
+	iti->width = width;
+
+	/* Request update */
+	priv->need_text_update = TRUE;
+	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (iti));
+}
+
+/**
+ * e_icon_bar_text_item_setxy:
+ * @iti: An #EIconBarTextItem.
+ * @x: X position.
+ * @y: Y position.
+ *
+ * Sets the coordinates at which the #EIconBarTextItem should be placed.
+ *
+ * See also: e_icon_bar_text_item_configure().
+ */
+void
+e_icon_bar_text_item_setxy (EIconBarTextItem *iti, int x, int y)
+{
+	ItiPrivate *priv;
+
+	g_return_if_fail (iti != NULL);
+	g_return_if_fail (IS_ITI (iti));
+
+	priv = iti->priv;
+
+	iti->x = x;
+	iti->y = y;
+
+	priv->need_pos_update = TRUE;
+	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (iti));
+}
+
+/**
+ * e_icon_bar_text_item_select:
+ * @iti: An #EIconBarTextItem.
+ * @sel: Whether the item should be displayed as selected.
+ *
+ * This function is used to control whether an icon text item is displayed as
+ * selected or not. Mouse events are ignored by the item when it is unselected;
+ * when the user clicks on a selected icon text item, it will start the text
+ * editing process.
+ */
+void
+e_icon_bar_text_item_select (EIconBarTextItem *iti, int sel)
+{
+	ItiPrivate *priv;
+
+	g_return_if_fail (iti != NULL);
+	g_return_if_fail (IS_ITI (iti));
+
+	priv = iti->priv;
+
+	if (!iti->selected == !sel)
+		return;
+
+	iti->selected = sel ? TRUE : FALSE;
+
+	if (!iti->selected && iti->editing)
+		iti_edition_accept (iti);
+
+	priv->need_state_update = TRUE;
+	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (iti));
+}
+
+/**
+ * e_icon_bar_text_item_get_text:
+ * @iti: An #EIconBarTextItem.
+ *
+ * Returns the current text.  The client should not free this string, as it is
+ * internal to the #EIconBarTextItem.
+ */
+char *
+e_icon_bar_text_item_get_text (EIconBarTextItem *iti)
+{
+	ItiPrivate *priv;
+
+	g_return_val_if_fail (iti != NULL, NULL);
+	g_return_val_if_fail (IS_ITI (iti), NULL);
+
+	priv = iti->priv;
+
+	if (iti->editing)
+		return gtk_entry_get_text (priv->entry);
+	else
+		return iti->text;
+}
+
+
+/**
+ * e_icon_bar_text_item_set_text:
+ * @iti: An #EIconBarTextItem.
+ * @text: Text that is going to be displayed.
+ * @is_static: Whether @text points to a static string or not.
+ *
+ * If @is_static is true, it means that there is no need for the item to
+ * allocate memory for the string (it is a guarantee that the text is allocated
+ * by the caller and it will not be deallocated during the lifetime of this
+ * item).  This is an optimization to reduce memory usage for large icon sets.
+ */
+void
+e_icon_bar_text_item_set_text (EIconBarTextItem *iti, const char *text,
+			       gboolean is_static)
+{
+	ItiPrivate *priv;
+
+	g_return_if_fail (iti != NULL);
+	g_return_if_fail (IS_ITI (iti));
+	g_return_if_fail (text != NULL);
+
+	priv = iti->priv;
+
+	if (iti->text && iti->is_text_allocated)
+		g_free (iti->text);
+
+	iti->is_text_allocated = !is_static;
+
+	/* This cast is to shut up the compiler */
+	if (is_static)
+		iti->text = (char *) text;
+	else
+		iti->text = g_strdup (text);
+
+	/* Request update */
+
+	priv->need_text_update = TRUE;
+	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (iti));
+}
+
+
+/**
+ * e_icon_bar_text_item_start_editing:
+ * @iti: An #EIconBarTextItem.
+ *
+ * Starts the editing state of an #EIconBarTextItem.
+ **/
+void
+e_icon_bar_text_item_start_editing (EIconBarTextItem *iti)
+{
+	g_return_if_fail (iti != NULL);
+	g_return_if_fail (IS_ITI (iti));
+
+	if (iti->editing)
+		return;
+
+	iti->selected = TRUE; /* Ensure that we are selected */
+	gnome_canvas_item_grab_focus (GNOME_CANVAS_ITEM (iti));
+	iti_start_editing (iti);
+}
+
+/**
+ * e_icon_bar_text_item_stop_editing:
+ * @iti: An #EIconBarTextItem.
+ * @accept: Whether to accept the current text or to discard it.
+ *
+ * Terminates the editing state of an icon text item.  The @accept argument
+ * controls whether the item's current text should be accepted or discarded.
+ * If it is discarded, then the icon's original text will be restored.
+ **/
+void
+e_icon_bar_text_item_stop_editing (EIconBarTextItem *iti,
+				   gboolean accept)
+{
+	g_return_if_fail (iti != NULL);
+	g_return_if_fail (IS_ITI (iti));
+
+	if (!iti->editing)
+		return;
+
+	if (accept)
+		iti_edition_accept (iti);
+	else
+		iti_stop_editing (iti);
+}
+
+
+/**
+ * e_icon_bar_text_item_get_type:
+ *
+ * Registers the &EIconBarTextItem class if necessary, and returns the type ID
+ * associated to it.
+ *
+ * Return value: the type ID of the #EIconBarTextItem class.
+ **/
+GtkType
+e_icon_bar_text_item_get_type (void)
+{
+	static GtkType iti_type = 0;
+
+	if (!iti_type) {
+		static const GtkTypeInfo iti_info = {
+			"EIconBarTextItem",
+			sizeof (EIconBarTextItem),
+			sizeof (EIconBarTextItemClass),
+			(GtkClassInitFunc) iti_class_init,
+			(GtkObjectInitFunc) iti_init,
+			NULL, /* reserved_1 */
+			NULL, /* reserved_2 */
+			(GtkClassInitFunc) NULL
+		};
+
+		iti_type = gtk_type_unique (gnome_canvas_item_get_type (), &iti_info);
+	}
+
+	return iti_type;
+}
+
+
+static void
+free_row (gpointer data, gpointer user_data)
+{
+	EIconBarTextItemInfoRow *row;
+
+	if (data) {
+		row = data;
+		g_free (row->text);
+		g_free (row->text_wc);
+		g_free (row);
+	}
+}
+
+/*
+ * e_icon_bar_text_item_free_info:
+ * @ti: An icon text info structure.
+ *
+ * Frees a &EIconBarTextItemInfo structure.  You should call this instead of
+ * freeing the structure yourself.
+ */
+static void
+e_icon_bar_text_item_free_info (EIconBarTextItemInfo *ti)
+{
+	g_list_foreach (ti->rows, free_row, NULL);
+	g_list_free (ti->rows);
+	g_free (ti);
+}
+
+/*
+ * e_icon_bar_text_item_layout_text:
+ * @font:       Name of the font that will be used to render the text.
+ * @text:       Text to be formatted.
+ * @separators: Separators used for word wrapping, can be NULL.
+ * @max_width:  Width in pixels to be used for word wrapping.
+ * @confine:    Whether it is mandatory to wrap at @max_width.
+ *
+ * Creates a new &EIconBarTextItemInfo structure by wrapping the specified
+ * text.  If non-NULL, the @separators argument defines a set of characters
+ * to be used as word delimiters for performing word wrapping.  If it is
+ * NULL, then only spaces will be used as word delimiters.
+ *
+ * The @max_width argument is used to specify the width at which word
+ * wrapping will be performed.  If there is a very long word that does not
+ * fit in a single line, the @confine argument can be used to specify
+ * whether the word should be unconditionally split to fit or whether
+ * the maximum width should be increased as necessary.
+ *
+ * Return value: A newly-created &EIconBarTextItemInfo structure.
+ */
+static EIconBarTextItemInfo *
+e_icon_bar_text_item_layout_text (EIconBarTextItem *iti, GdkFont *font,
+				  const gchar *text, const gchar *separators,
+				  gint max_width, gboolean confine)
+{
+	EIconBarTextItemInfo *ti;
+	EIconBarTextItemInfoRow *row;
+	GdkWChar *row_end;
+	GdkWChar *s, *word_start, *word_end, *old_word_end;
+	GdkWChar *sub_text;
+	int i, w_len, w;
+	GdkWChar *text_wc, *text_iter, *separators_wc;
+	int text_len_wc, separators_len_wc;
+	gboolean restrict_lines;
+	int lines;
+
+	g_return_val_if_fail (font != NULL, NULL);
+	g_return_val_if_fail (text != NULL, NULL);
+
+	if (!separators)
+		separators = " ";
+
+	text_wc = g_new (GdkWChar, strlen (text) + 1);
+	text_len_wc = gdk_mbstowcs (text_wc, text, strlen (text));
+	if (text_len_wc < 0) text_len_wc = 0;
+	text_wc[text_len_wc] = 0;
+
+	separators_wc = g_new (GdkWChar, strlen (separators) + 1);
+	separators_len_wc = gdk_mbstowcs (separators_wc, separators, strlen (separators));
+	if (separators_len_wc < 0) separators_len_wc = 0;
+	separators_wc[separators_len_wc] = 0;
+	
+	ti = g_new (EIconBarTextItemInfo, 1);
+
+	ti->rows = NULL;
+	ti->font = font;
+	ti->width = 0;
+	ti->height = 0;
+	ti->baseline_skip = font->ascent + font->descent;
+
+	word_end = NULL;
+
+	if (!iti->editing && iti->max_lines != -1)
+		restrict_lines = TRUE;
+	else
+		restrict_lines = FALSE;
+
+	text_iter = text_wc;
+	lines = 0;
+	while (*text_iter) {
+		/* If we are restricting the height, and this is the last line,
+		   and we are displaying the ellipsis, then subtract the width
+		   of the ellipsis from our max_width. */
+		if (restrict_lines && lines == iti->max_lines - 1
+		    && iti->show_ellipsis) {
+			max_width -= gdk_string_measure (font, e_icon_bar_text_item_ellipsis);
+		}
+
+		for (row_end = text_iter; *row_end != 0 && *row_end != '\n'; row_end++);
+
+		/* Accumulate words from this row until they don't fit in the max_width */
+
+		s = text_iter;
+
+		while (s < row_end) {
+			word_start = s;
+			old_word_end = word_end;
+			for (word_end = word_start; *word_end; word_end++) {
+				GdkWChar *p;
+				for (p = separators_wc; *p; p++) {
+					if (*word_end == *p)
+						goto found;
+				}
+			}
+		  found:
+			if (word_end < row_end)
+				word_end++;
+
+			if (gdk_text_width_wc (font, text_iter, word_end - text_iter) > max_width) {
+				if (word_start == text_iter
+				    || (restrict_lines
+					&& lines == iti->max_lines - 1)) {
+					if (confine) {
+						/* We must force-split the word.  Look for a proper
+                                                 * place to do it.
+						 */
+
+						w_len = word_end - text_iter;
+
+						for (i = 1; i < w_len; i++) {
+							w = gdk_text_width_wc (font, text_iter, i);
+							if (w > max_width) {
+								if (i == 1)
+									/* Shit, not even a single character fits */
+									max_width = w;
+								else
+									break;
+							}
+						}
+
+						/* Create sub-row with the chars that fit */
+
+						sub_text = g_new (GdkWChar, i);
+						memcpy (sub_text, text_iter, (i - 1) * sizeof (GdkWChar));
+						sub_text[i - 1] = 0;
+						
+						row = g_new (EIconBarTextItemInfoRow, 1);
+						row->text_wc = sub_text;
+						row->text_length = i - 1;
+						row->width = gdk_text_width_wc (font, sub_text, i - 1);
+						row->text = gdk_wcstombs(sub_text);
+						if (row->text == NULL)
+							row->text = g_strdup("");
+
+						ti->rows = g_list_append (ti->rows, row);
+
+						if (row->width > ti->width)
+							ti->width = row->width;
+
+						ti->height += ti->baseline_skip;
+
+						/* Bump the text pointer */
+
+						text_iter += i - 1;
+						s = text_iter;
+
+						lines++;
+						if (restrict_lines
+						    && lines >= iti->max_lines)
+							break;
+
+						continue;
+					} else
+						max_width = gdk_text_width_wc (font, word_start, word_end - word_start);
+
+					continue; /* Retry split */
+				} else {
+					word_end = old_word_end; /* Restore to region that does fit */
+					break; /* Stop the loop because we found something that doesn't fit */
+				}
+			}
+
+			s = word_end;
+		}
+
+		if (restrict_lines && lines >= iti->max_lines)
+			break;
+
+		/* Append row */
+
+		if (text_iter == row_end) {
+			/* We are on a newline, so append an empty row */
+
+			ti->rows = g_list_append (ti->rows, NULL);
+			ti->height += ti->baseline_skip;
+
+			/* Next! */
+
+			text_iter = row_end + 1;
+
+			lines++;
+			if (restrict_lines && lines >= iti->max_lines)
+				break;
+
+		} else {
+			/* Create subrow and append it to the list */
+
+			int sub_len;
+			sub_len = word_end - text_iter;
+
+			sub_text = g_new (GdkWChar, sub_len + 1);
+			memcpy (sub_text, text_iter, sub_len * sizeof (GdkWChar));
+			sub_text[sub_len] = 0;
+
+			row = g_new (EIconBarTextItemInfoRow, 1);
+			row->text_wc = sub_text;
+			row->text_length = sub_len;
+			row->width = gdk_text_width_wc (font, sub_text, sub_len);
+			row->text = gdk_wcstombs(sub_text);
+			if (row->text == NULL)
+				row->text = g_strdup("");
+
+			ti->rows = g_list_append (ti->rows, row);
+
+			if (row->width > ti->width)
+				ti->width = row->width;
+
+			ti->height += ti->baseline_skip;
+
+			/* Next! */
+
+			text_iter = word_end;
+
+			lines++;
+			if (restrict_lines && lines >= iti->max_lines)
+				break;
+		}
+	}
+
+	/* Check if we've had to clip the text. */
+	iti->is_clipped = *text_iter ? TRUE : FALSE;
+
+	g_free (text_wc);
+	g_free (separators_wc);
+	return ti;
+}
+
+/*
+ * e_icon_bar_text_item_paint_text:
+ * @ti:       An icon text info structure.
+ * @drawable: Target drawable.
+ * @gc:       GC used to render the string.
+ * @x:        Left coordinate for text.
+ * @y:        Upper coordinate for text.
+ * @just:     Justification for text.
+ *
+ * Paints the formatted text in the icon text info structure onto a drawable.
+ * This is just a sample implementation; applications can choose to use other
+ * rendering functions.
+ */
+static void
+e_icon_bar_text_item_paint_text (EIconBarTextItem *iti,
+				 EIconBarTextItemInfo *ti,
+				 GdkDrawable *drawable, GdkGC *gc,
+				 gint x, gint y, GtkJustification just)
+{
+	GList *item;
+	EIconBarTextItemInfoRow *row;
+	int xpos, line, width;
+	gboolean show_ellipsis;
+
+	g_return_if_fail (ti != NULL);
+	g_return_if_fail (drawable != NULL);
+	g_return_if_fail (gc != NULL);
+
+	y += ti->font->ascent;
+
+	for (item = ti->rows, line = 1; item; item = item->next, line++) {
+
+		if (item->data) {
+			row = item->data;
+			width = row->width;
+		}
+
+		/* If this is the last line, and the text has been clipped,
+		   and show_ellipsis is TRUE, display '...' */
+		if (line == iti->max_lines && iti->is_clipped) {
+			show_ellipsis = TRUE;
+			width += gdk_string_measure (ti->font, e_icon_bar_text_item_ellipsis);
+		} else {
+			show_ellipsis = FALSE;
+		}
+
+		switch (just) {
+		case GTK_JUSTIFY_LEFT:
+			xpos = 0;
+			break;
+
+		case GTK_JUSTIFY_RIGHT:
+			xpos = ti->width - width;
+			break;
+
+		case GTK_JUSTIFY_CENTER:
+			xpos = (ti->width - width) / 2;
+			break;
+
+		default:
+			/* Anyone care to implement GTK_JUSTIFY_FILL? */
+			g_warning ("Justification type %d not supported.  Using left-justification.",
+				   (int) just);
+			xpos = 0;
+		}
+
+		if (item->data)
+			gdk_draw_text_wc (drawable, ti->font, gc, x + xpos, y, row->text_wc, row->text_length);
+
+		if (show_ellipsis)
+			gdk_draw_string (drawable, ti->font, gc,
+					 x + xpos + row->width, y,
+					 e_icon_bar_text_item_ellipsis);
+			
+		y += ti->baseline_skip;
+	}
+}