aboutsummaryrefslogtreecommitdiffstats
path: root/widgets/shortcut-bar/e-icon-bar-text-item.c
diff options
context:
space:
mode:
Diffstat (limited to 'widgets/shortcut-bar/e-icon-bar-text-item.c')
-rw-r--r--widgets/shortcut-bar/e-icon-bar-text-item.c1696
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;
+ }
+}