path: root/widgets/shortcut-bar/e-icon-bar-text-item.c

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */

/* 
 * Author : 
 *  Damon Chaplin <damon@helixcode.com>
 *
 * 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;
    }
}