path: root/widgets/e-table/e-cell-text.c

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/* e-cell-text.c - Text cell renderer
 * Copyright (C) 2000 Helix Code, Inc.
 *
 * Authors: Miguel de Icaza (miguel@kernel.org)
 *          Chris Lahey <clahey@umich.edu>
 *         
 *
 * A majority of code taken from:
 *
 * Text item type for GnomeCanvas widget
 *
 * GnomeCanvas is basically a port of the Tk toolkit's most excellent
 * canvas widget.  Tk is copyrighted by the Regents of the University
 * of California, Sun Microsystems, and other parties.
 *
 * Copyright (C) 1998 The Free Software Foundation
 *
 * Author: Federico Mena <federico@nuclecu.unam.mx>
 */
#include <config.h>
#include <gtk/gtkenums.h>
#include <gtk/gtkentry.h>
#include <gtk/gtkwindow.h>
#include <gtk/gtkinvisible.h>
#include <gtk/gtksignal.h>
#include <gdk/gdkkeysyms.h>
#include <libgnomeui/gnome-canvas.h>
#include <stdio.h>
#include "e-cell-text.h"
#include "e-util/e-util.h"
#include "e-table-item.h"
#include "e-text-event-processor-emacs-like.h"

#include <gdk/gdkx.h> /* for BlackPixel */
#include <ctype.h>
#include <math.h>



/* This defines a line of text */
struct line {
    char *text; /* Line's text, it is a pointer into the text->text string */
    int length; /* Line's length in characters */
    int width;  /* Line's width in pixels */
    int ellipsis_length;  /* Length before adding ellipsis */
};



/* Object argument IDs */
enum {
    ARG_0,
    ARG_TEXT,
    ARG_X,
    ARG_Y,
    ARG_FONT,
        ARG_FONTSET,
    ARG_FONT_GDK,
    ARG_ANCHOR,
    ARG_JUSTIFICATION,
    ARG_CLIP_WIDTH,
    ARG_CLIP_HEIGHT,
    ARG_CLIP,
    ARG_X_OFFSET,
    ARG_Y_OFFSET,
    ARG_FILL_COLOR,
    ARG_FILL_COLOR_GDK,
    ARG_FILL_COLOR_RGBA,
    ARG_FILL_STIPPLE,
    ARG_TEXT_WIDTH,
    ARG_TEXT_HEIGHT,
    ARG_EDITABLE,
    ARG_USE_ELLIPSIS,
    ARG_ELLIPSIS
};


enum {
    E_SELECTION_PRIMARY,
    E_SELECTION_CLIPBOARD
};

static GdkAtom clipboard_atom = GDK_NONE;



#define PARENT_TYPE e_cell_get_type()

#define TEXT_PAD 4

typedef struct {
    gpointer lines;         /* Text split into lines (private field) */
    int num_lines;          /* Number of lines of text */
    int max_width;
    int ref_count;
} ECellTextLineBreaks;
    

typedef struct _CellEdit CellEdit;

typedef struct {
    ECellView    cell_view;
    GdkGC       *gc;
    GdkFont     *font;
    GdkCursor *i_cursor;
    GdkBitmap *stipple;     /* Stipple for text */
    
    GnomeCanvas *canvas;

    /*
     * During editing.
     */
    CellEdit    *edit;


    int xofs, yofs;                 /* This gets added to the x
                                           and y for the cell text. */
    double ellipsis_width;          /* The width of the ellipsis. */

} ECellTextView;

typedef struct _CurrentCell{
    ECellTextView *text_view;
    int            width;
    gchar         *text;
    int            model_col, view_col, row;
    ECellTextLineBreaks *breaks;
} CurrentCell;

#define CURRENT_CELL(x) ((CurrentCell *)(x))

struct _CellEdit {
    CurrentCell cell;

    char         *old_text;

    /*
     * Where the editing is taking place
     */

    int xofs_edit, yofs_edit;       /* Offset because of editing.
                                           This is negative compared
                                           to the other offsets. */

    /* This needs to be reworked a bit once we get line wrapping. */
    int selection_start;            /* Start of selection */
    int selection_end;              /* End of selection */
    gboolean select_by_word;        /* Current selection is by word */

    /* This section is for drag scrolling and blinking cursor. */
    /* Cursor handling. */
    gint timeout_id;                /* Current timeout id for scrolling */
    GTimer *timer;                  /* Timer for blinking cursor and scrolling */

    gint lastx, lasty;              /* Last x and y motion events */
    gint last_state;                /* Last state */
    gulong scroll_start;            /* Starting time for scroll (microseconds) */

    gint show_cursor;               /* Is cursor currently shown */
    gboolean button_down;           /* Is mouse button 1 down */

    ETextEventProcessor *tep;       /* Text Event Processor */

    GtkWidget *invisible;           /* For selection handling */
    gboolean has_selection;         /* TRUE if we have the selection */
    gchar *primary_selection;       /* Primary selection text */
    gint primary_length;            /* Primary selection text length */
    gchar *clipboard_selection;     /* Clipboard selection text */
    gint clipboard_length;          /* Clipboard selection text length*/

    guint pointer_in : 1;
    guint default_cursor_shown : 1;
};

static void e_cell_text_view_command(ETextEventProcessor *tep, ETextEventProcessorCommand *command, gpointer data);

static void e_cell_text_view_get_selection(CellEdit *edit, GdkAtom selection, guint32 time);
static void e_cell_text_view_supply_selection (CellEdit *edit, guint time, GdkAtom selection, guchar *data, gint length);

static GtkWidget *e_cell_text_view_get_invisible(CellEdit *edit);
static void _selection_clear_event (GtkInvisible *invisible,
                    GdkEventSelection *event,
                    CellEdit *edit);
static void _selection_get (GtkInvisible *invisible,
                GtkSelectionData *selection_data,
                guint info,
                guint time_stamp,
                CellEdit *edit);
static void _selection_received (GtkInvisible *invisible,
                 GtkSelectionData *selection_data,
                 guint time,
                 CellEdit *edit);
static void split_into_lines (CurrentCell *cell);
static void unref_lines(CurrentCell *cell);
static void calc_line_widths (CurrentCell *cell);
static int get_line_ypos (CurrentCell *cell, struct line *line);
static int get_line_xpos (CurrentCell *cell, struct line *line);
static void _get_tep(CellEdit *edit);

static gint _get_position_from_xy (CurrentCell *cell, gint x, gint y);
static void _get_xy_from_position (CurrentCell *cell, gint position, gint *xp, gint *yp);
static gboolean _blink_scroll_timeout (gpointer data);

static void build_current_cell (CurrentCell *cell, ECellTextView *text_view, int model_col, int view_col, int row);
static void calc_ellipsis (ECellTextView *text_view);

static ECellClass *parent_class;

static void
ect_queue_redraw (ECellTextView *text_view, int view_col, int view_row)
{
    e_table_item_redraw_range (
        text_view->cell_view.e_table_item_view,
        view_col, view_row, view_col, view_row);
}

/*
 * Accept the currently edited text
 */
static void
ect_accept_edits (ECellTextView *text_view)
{
    CurrentCell *cell = (CurrentCell *) text_view->edit;
    
    e_table_model_set_value_at (text_view->cell_view.e_table_model, cell->model_col, cell->row, cell->text);
}

/*
 * Shuts down the editing process
 */
static void
ect_stop_editing (ECellTextView *text_view)
{
    CellEdit *edit = text_view->edit;
    int row, view_col;

    if ( !edit )
        return;

    row = edit->cell.row;
    view_col = edit->cell.view_col;
    
    g_free (edit->old_text);
    edit->old_text = NULL;
    g_free (edit->cell.text);
    edit->cell.text = NULL;
    if (edit->invisible)
        gtk_widget_unref (edit->invisible);
    if (edit->tep)
        gtk_object_unref (GTK_OBJECT(edit->tep));
    if (edit->primary_selection)
        g_free(edit->primary_selection);
    if (edit->clipboard_selection)
        g_free(edit->clipboard_selection);
    if ( ! edit->default_cursor_shown ) {
        gdk_window_set_cursor(GTK_WIDGET(text_view->canvas)->window, NULL);
        edit->default_cursor_shown = TRUE;
    }
    if (edit->timeout_id) {
        g_source_remove(edit->timeout_id);
        edit->timeout_id = 0;
    }
    if (edit->timer) {
        g_timer_stop(edit->timer);
        g_timer_destroy(edit->timer);
        edit->timer = NULL;
    }

    g_free (edit);
    
    text_view->edit = NULL;
    ect_queue_redraw (text_view, view_col, row);
}

/*
 * Cancels the edits
 */
static void
ect_cancel_edit (ECellTextView *text_view)
{
    ect_stop_editing (text_view);
}

/*
 * ECell::new_view method
 */
static ECellView *
ect_new_view (ECell *ecell, ETableModel *table_model, void *e_table_item_view)
{
    ECellText *ect = E_CELL_TEXT (ecell);
    ECellTextView *text_view = g_new0 (ECellTextView, 1);
    GnomeCanvas *canvas = GNOME_CANVAS_ITEM (e_table_item_view)->canvas;
    
    text_view->cell_view.ecell = ecell;
    text_view->cell_view.e_table_model = table_model;
    text_view->cell_view.e_table_item_view = e_table_item_view;
    
    if (ect->font_name){
        GdkFont *f;

        f = gdk_fontset_load (ect->font_name);
        text_view->font = f;
    }
    if (!text_view->font){
        text_view->font = GTK_WIDGET (canvas)->style->font;
        
        gdk_font_ref (text_view->font);
    }

    text_view->canvas = canvas;

    text_view->xofs = 0.0;
    text_view->yofs = 0.0;
    
    return (ECellView *)text_view;
}

/*
 * ECell::kill_view method
 */
static void
ect_kill_view (ECellView *ecv)
{
    ECellTextView *text_view = (ECellTextView *) ecv;

    g_free(text_view);
}

/*
 * ECell::realize method
 */
static void
ect_realize (ECellView *ecell_view)
{
    ECellTextView *text_view = (ECellTextView *) ecell_view;
    
    text_view->gc = gdk_gc_new (GTK_WIDGET (text_view->canvas)->window);

    text_view->i_cursor = gdk_cursor_new (GDK_XTERM);
    
    calc_ellipsis (text_view);

    if (parent_class->realize)
        (* parent_class->realize) (ecell_view);
}

/*
 * ECell::unrealize method
 */
static void
ect_unrealize (ECellView *ecv)
{
    ECellTextView *text_view = (ECellTextView *) ecv;

    gdk_gc_unref (text_view->gc);
    text_view->gc = NULL;

    if ( text_view->edit ) {
        ect_cancel_edit (text_view);
    }

    if (text_view->font)
        gdk_font_unref (text_view->font);
    
    if (text_view->stipple)
        gdk_bitmap_unref (text_view->stipple);

    gdk_cursor_destroy (text_view->i_cursor);

    if (parent_class->unrealize)
        (* parent_class->unrealize) (ecv);
}

/*
 * ECell::draw method
 */
static void
ect_draw (ECellView *ecell_view, GdkDrawable *drawable,
      int model_col, int view_col, int row, gboolean selected,
      int x1, int y1, int x2, int y2)
{
    /* New ECellText */
    ECellText *ect = E_CELL_TEXT (ecell_view->ecell);
    ECellTextView *text_view = (ECellTextView *) ecell_view;
    GtkWidget *canvas = GTK_WIDGET (text_view->canvas);
    GdkRectangle rect, *clip_rect;
    struct line *lines;
    int i;
    int xpos, ypos;
    int start_char, end_char;
    int sel_start, sel_end;
    GdkRectangle sel_rect;
    GdkGC *fg_gc;
    GdkFont *font = text_view->font;
    const int height = font->ascent + font->descent;
    CellEdit *edit = text_view->edit;
    gboolean edit_display = FALSE;
    ECellTextLineBreaks *linebreaks;
    GdkColor *background, *foreground;


    if (edit){
        
        if ((edit->cell.view_col == view_col) && (edit->cell.row == row)) {
            edit_display = TRUE;
            fg_gc = canvas->style->fg_gc[edit->has_selection ? GTK_STATE_SELECTED : GTK_STATE_ACTIVE];
        } else
            fg_gc = canvas->style->fg_gc[GTK_STATE_ACTIVE];
    } else {
        fg_gc = canvas->style->fg_gc[GTK_STATE_ACTIVE];
    }

    /*
     * Be a nice citizen: clip to the region we are supposed to draw on
     */
    rect.x = x1;
    rect.y = y1;
    rect.width = x2 - x1;
    rect.height = y2 - y1;
    
    gdk_gc_set_clip_rectangle (text_view->gc, &rect);
    gdk_gc_set_clip_rectangle (fg_gc, &rect);
    clip_rect = &rect;

    
    if (selected){
        background = &canvas->style->bg [GTK_STATE_SELECTED];
        foreground = &canvas->style->text [GTK_STATE_SELECTED];
    } else {
        background = &canvas->style->base [GTK_STATE_NORMAL];
        foreground = &canvas->style->text [GTK_STATE_NORMAL];
    }
    gdk_gc_set_foreground (text_view->gc, background);
    gdk_draw_rectangle (drawable, text_view->gc, TRUE,
                rect.x, rect.y, rect.width, rect.height);
    gdk_gc_set_foreground (text_view->gc, foreground);

    x1 += 4;
    y1 += 1;
    x2 -= 4;
    y2 -= 1;

    rect.x = x1;
    rect.y = y1;
    rect.width = x2 - x1;
    rect.height = y2 - y1;
    
    gdk_gc_set_clip_rectangle (text_view->gc, &rect);
    gdk_gc_set_clip_rectangle (fg_gc, &rect);
    clip_rect = &rect;

    if ( edit_display ) {
        CellEdit *edit = text_view->edit;
        CurrentCell *cell = CURRENT_CELL(edit);

        cell->width = x2 - x1;
        
        split_into_lines(cell);

        linebreaks = cell->breaks;
        
        lines = linebreaks->lines;
        ypos = get_line_ypos (cell, lines);
        ypos += font->ascent;
        ypos -= edit->yofs_edit;

        for (i = 0; i < linebreaks->num_lines; i++) {
            xpos = get_line_xpos (cell, lines);
            xpos -= edit->xofs_edit;
            start_char = lines->text - cell->text;
            end_char = start_char + lines->length;
            sel_start = edit->selection_start;
            sel_end = edit->selection_end;
            if (sel_start > sel_end ) {
                sel_start ^= sel_end;
                sel_end ^= sel_start;
                sel_start ^= sel_end;
            }
            if ( sel_start < start_char )
                sel_start = start_char;
            if ( sel_end > end_char )
                sel_end = end_char;
            if ( sel_start < sel_end ) {
                sel_rect.x = xpos + x1 + gdk_text_width (font,
                                    lines->text,
                                    sel_start - start_char);
                sel_rect.y = ypos + y1 - font->ascent;
                sel_rect.width = gdk_text_width (font,
                                 lines->text + sel_start - start_char,
                                 sel_end - sel_start);
                sel_rect.height = height;
                gtk_paint_flat_box(canvas->style,
                           drawable,
                           edit->has_selection ?
                           GTK_STATE_SELECTED :
                           GTK_STATE_ACTIVE,
                           GTK_SHADOW_NONE,
                           clip_rect,
                           canvas,
                           "text",
                           sel_rect.x,
                           sel_rect.y,
                           sel_rect.width,
                           sel_rect.height);
                gdk_draw_text (drawable,
                           font,
                           text_view->gc,
                           xpos + x1,
                           ypos + y1,
                           lines->text,
                           sel_start - start_char);
                gdk_draw_text (drawable,
                           font,
                           fg_gc,
                           xpos + x1 + gdk_text_width (font,
                                      lines->text,
                                      sel_start - start_char),
                           ypos + y1,
                           lines->text + sel_start - start_char,
                           sel_end - sel_start);
                gdk_draw_text (drawable,
                           font,
                           text_view->gc,
                           xpos + x1 + gdk_text_width (font,
                                      lines->text,
                                      sel_end - start_char),
                           ypos + y1,
                           lines->text + sel_end - start_char,
                           end_char - sel_end);
            } else {
                gdk_draw_text (drawable,
                           font,
                           text_view->gc,
                           xpos + x1,
                           ypos + y1,
                           lines->text,
                           lines->length);
            }
            if (edit->selection_start == edit->selection_end &&
                edit->selection_start >= start_char &&
                edit->selection_start <= end_char &&
                edit->show_cursor) {
                gdk_draw_rectangle (drawable,
                            text_view->gc,
                            TRUE,
                            xpos + x1 + gdk_text_width (font, 
                                           lines->text,
                                           sel_start - start_char),
                            ypos + y1 - font->ascent,
                            1,
                            height);
            }
        }
        unref_lines(cell);
    } else {
        
        ECellTextLineBreaks *linebreaks;
        CurrentCell cell;
        build_current_cell ( &cell, text_view, model_col, view_col, row );
        
        cell.width = x2 - x1;
        
        split_into_lines(&cell);
        
        linebreaks = cell.breaks;
        lines = linebreaks->lines;
        ypos = get_line_ypos(&cell, lines);
        ypos += font->ascent;
        
        
        for (i = 0; i < linebreaks->num_lines; i++) {
            xpos = get_line_xpos (&cell, lines);
            if ( ect->use_ellipsis && lines->ellipsis_length < lines->length) {
                gdk_draw_text (drawable,
                           font,
                           text_view->gc,
                           xpos + x1,
                           ypos + y1,
                           lines->text,
                           lines->ellipsis_length);
                gdk_draw_text (drawable,
                           font,
                           text_view->gc,
                           xpos + x1 + 
                           lines->width - text_view->ellipsis_width,
                           ypos + y1,
                           ect->ellipsis ? ect->ellipsis : "...",
                           ect->ellipsis ? strlen (ect->ellipsis) : 3);
            } else {
                gdk_draw_text (drawable,
                           font,
                           text_view->gc,
                           xpos + x1,
                           ypos + y1,
                           lines->text,
                           lines->length);
            }
        }
        
        ypos += height;
        lines++;
        unref_lines(&cell);
    }

    gdk_gc_set_clip_rectangle (text_view->gc, NULL);
    gdk_gc_set_clip_rectangle (fg_gc, NULL);
#if 0
    /* Old ECellText */

    int xoff;
    gboolean edit_display = FALSE;

    /*
     * Figure if this cell is being edited
     */
    if (edit_display){
        CellEdit *edit = text_view->edit;
        const char *text = gtk_entry_get_text (edit->entry);
        GdkWChar *p, *text_wc = g_new (GdkWChar, strlen (text) + 1);
        int text_wc_len = gdk_mbstowcs (text_wc, text, strlen (text));
        const int cursor_pos = GTK_EDITABLE (edit->entry)->current_pos;
        const int left_len = gdk_text_width_wc (text_view->font, text_wc, cursor_pos);

        text_wc [text_wc_len] = 0;
        /*
         * Paint
         */
        gdk_gc_set_foreground (text_view->gc, &w->style->base [GTK_STATE_NORMAL]);
        gdk_draw_rectangle (drawable, text_view->gc, TRUE,
                    rect.x, rect.y, rect.width, rect.height);
        gdk_gc_set_foreground (text_view->gc, &w->style->text [GTK_STATE_NORMAL]);

        {
            GdkGC *gc = text_view->gc;
            const int y = y2 - font->descent - ((y2-y1-height)/2);
            int px, i;

            /*
             * Border
             */
            x1 += 2;
            x2--;
            
            px = x1;

            /*
             * If the cursor is outside the visible range
             *
             * FIXME: we really want a better behaviour.
             */
            if ((px + left_len) > x2)
                px -= left_len - (x2-x1);

            /*
             * Draw
             */
            for (i = 0, p = text_wc; *p; p++, i++){
                gdk_draw_text_wc (
                    drawable, font, gc, px, y, p, 1);

                if (i == cursor_pos){
                    gdk_draw_line (
                        drawable, gc,
                        px, y - font->ascent,
                        px, y + font->descent - 1);
                }

                px += gdk_text_width_wc (font, p, 1);
            }

            if (i == cursor_pos){
                gdk_draw_line (
                    drawable, gc,
                    px, y - font->ascent,
                    px, y + font->descent - 1);
            }
        }
        g_free (text_wc);
    } else {
        /*
         * Regular cell
         */
        GdkColor *background, *foreground;
        int width;

        /*
         * Border
         */
        x1++;
        x2--;
        
        /*
         * Compute draw mode
         */
        switch (ect->justify){
        case GTK_JUSTIFY_LEFT:
            xoff = 1;
            break;
            
        case GTK_JUSTIFY_RIGHT:
            width = 1 + gdk_text_width (font, str, strlen (str));
            xoff = (x2 - x1) - width;
            break;
            
        case GTK_JUSTIFY_CENTER:
            xoff = ((x2 - x1) - gdk_text_width (font, str, strlen (str))) / 2;
            break;
        default:
            xoff = 0;
            g_warning ("Can not handle GTK_JUSTIFY_FILL");
            break;
        }
        
        
        if (selected){
            background = &w->style->bg [GTK_STATE_SELECTED];
            foreground = &w->style->text [GTK_STATE_SELECTED];
        } else {
            background = &w->style->base [GTK_STATE_NORMAL];
            foreground = &w->style->text [GTK_STATE_NORMAL];
        }
        
        gdk_gc_set_foreground (text_view->gc, background); 
        gdk_draw_rectangle (drawable, text_view->gc, TRUE,
                    rect.x, rect.y, rect.width, rect.height);
        gdk_gc_set_foreground (text_view->gc, foreground);

        gdk_draw_string (
            drawable, font, text_view->gc,
            x1 + xoff,
            y2 - font->descent - ((y2-y1-height)/2), str);
    }
#endif
}

/*
 * Selects the entire string
 */
static void
ect_edit_select_all (ECellTextView *text_view)
{
    g_assert (text_view->edit);
    
    text_view->edit->selection_start = 0;
    text_view->edit->selection_end = strlen(text_view->edit->cell.text);
}

/*
 * ECell::event method
 */
static gint
ect_event (ECellView *ecell_view, GdkEvent *event, int model_col, int view_col, int row)
{
    ECellTextView *text_view = (ECellTextView *) ecell_view;
    ECellText *ect = E_CELL_TEXT (ecell_view->ecell);
    ETextEventProcessorEvent e_tep_event;
    gboolean edit_display = FALSE;
    CellEdit *edit = text_view->edit;
    GtkWidget *canvas = GTK_WIDGET (text_view->canvas);
    gint return_val = 0;

    CurrentCell cell, *cellptr;
    build_current_cell ( &cell, text_view, model_col, view_col, row );
    

    if (edit){
        if ((edit->cell.view_col == view_col) && (edit->cell.row == row)) {
            edit_display = TRUE;
            cellptr = CURRENT_CELL(edit);
        } else {
            cellptr = &cell;
        }
    } else {
        cellptr = &cell;
    }

    e_tep_event.type = event->type;
    switch (event->type) {
    case GDK_FOCUS_CHANGE:
        break;
    case GDK_KEY_PRESS: /* Fall Through */
    case GDK_KEY_RELEASE:
        if (event->key.keyval == GDK_Escape){
            ect_cancel_edit (text_view);
            return TRUE;
        }
        
        if ((!edit_display) && ect->editable) {
              e_table_item_enter_edit (text_view->cell_view.e_table_item_view, view_col, row);
              ect_edit_select_all (text_view);
              edit = text_view->edit;
              cellptr = CURRENT_CELL(edit);
              edit_display = TRUE;
        }       
        if (edit_display) {
            GdkEventKey key = event->key;
            if ( key.keyval == GDK_KP_Enter || key.keyval == GDK_Return ) {
                e_table_item_leave_edit (text_view->cell_view.e_table_item_view);
            } else {
                e_tep_event.key.time = key.time;
                e_tep_event.key.state = key.state;
                e_tep_event.key.keyval = key.keyval;
                e_tep_event.key.length = key.length;
                e_tep_event.key.string = key.string;
                _get_tep(edit);
                return e_text_event_processor_handle_event (edit->tep,
                                        &e_tep_event);
            }
        }

        else
            return 0;
        break;
    case GDK_BUTTON_PRESS: /* Fall Through */
    case GDK_BUTTON_RELEASE:
        event->button.x -= 4;
        event->button.y -= 1;
        if ((!edit_display) 
            && ect->editable
            && event->type == GDK_BUTTON_RELEASE
            && event->button.button == 1) {
            GdkEventButton button = event->button;

            e_table_item_enter_edit (text_view->cell_view.e_table_item_view, view_col, row);
            edit = text_view->edit;
            cellptr = CURRENT_CELL(edit);
            edit_display = TRUE;
            
            e_tep_event.button.type = GDK_BUTTON_PRESS;
            e_tep_event.button.time = button.time;
            e_tep_event.button.state = button.state;
            e_tep_event.button.button = button.button;
            e_tep_event.button.position = _get_position_from_xy(cellptr, button.x, button.y);
            _get_tep(edit);
            return_val = e_text_event_processor_handle_event (edit->tep,
                                      &e_tep_event);
            if (event->button.button == 1) {
                if (event->type == GDK_BUTTON_PRESS)
                    edit->button_down = TRUE;
                else
                    edit->button_down = FALSE;
            }
            edit->lastx = button.x;
            edit->lasty = button.y;
            edit->last_state = button.state;

            e_tep_event.button.type = GDK_BUTTON_RELEASE;
        }       
        if (edit_display) {
            GdkEventButton button = event->button;
            e_tep_event.button.time = button.time;
            e_tep_event.button.state = button.state;
            e_tep_event.button.button = button.button;
            e_tep_event.button.position = _get_position_from_xy(cellptr, button.x, button.y);
            _get_tep(edit);
            return_val = e_text_event_processor_handle_event (edit->tep,
                                      &e_tep_event);
            if (event->button.button == 1) {
                if (event->type == GDK_BUTTON_PRESS)
                    edit->button_down = TRUE;
                else
                    edit->button_down = FALSE;
            }
            edit->lastx = button.x;
            edit->lasty = button.y;
            edit->last_state = button.state;
        }
        break;
    case GDK_MOTION_NOTIFY:
        event->motion.x -= 4;
        event->motion.y -= 1;
        if (edit_display) {
            GdkEventMotion motion = event->motion;
            e_tep_event.motion.time = motion.time;
            e_tep_event.motion.state = motion.state;
            e_tep_event.motion.position = _get_position_from_xy(cellptr, motion.x, motion.y);
            _get_tep(edit);
            return_val = e_text_event_processor_handle_event (edit->tep,
                                      &e_tep_event);
            edit->lastx = motion.x;
            edit->lasty = motion.y;
            edit->last_state = motion.state;
        }
        break;
    case GDK_ENTER_NOTIFY:
#if 0
        edit->pointer_in = TRUE;
#endif
        if (edit_display) {
            if ( edit->default_cursor_shown ) {
                gdk_window_set_cursor(canvas->window, text_view->i_cursor);
                edit->default_cursor_shown = FALSE;
            }
        }
        break;
    case GDK_LEAVE_NOTIFY:
#if 0
        text_view->pointer_in = FALSE;
#endif
        if (edit_display) {
            if ( ! edit->default_cursor_shown ) {
                gdk_window_set_cursor(canvas->window, NULL);
                edit->default_cursor_shown = TRUE;
            }
        }
        break;
    default:
        break;
    }
    if (return_val)
        return return_val;
#if 0
    if (GNOME_CANVAS_ITEM_CLASS(parent_class)->event)
        return GNOME_CANVAS_ITEM_CLASS(parent_class)->event(item, event);
#endif
    else
        return 0;
    
#if 0
    switch (event->type){
    case GDK_BUTTON_PRESS:
        /*
         * Adjust for the border we use
         */
        event->button.x++;
        
        printf ("Button pressed at %g %g\n", event->button.x, event->button.y);
        if (text_view->edit){
            printf ("FIXME: Should handle click here\n");
        } else 
            e_table_item_enter_edit (text_view->cell_view.e_table_item_view, view_col, row);
        break;

    case GDK_KEY_PRESS:
        if (event->key.keyval == GDK_Escape){
            ect_cancel_edit (text_view);
            return TRUE;
        }
        
        if (!text_view->edit){
            e_table_item_enter_edit (text_view->cell_view.e_table_item_view, view_col, row);
            ect_edit_select_all (text_view);
        }

        gtk_widget_event (GTK_WIDGET (text_view->edit->entry), event);
        ect_queue_redraw (text_view, view_col, row);
        break;
#endif
}

/*
 * ECell::height method
 */
static int
ect_height (ECellView *ecell_view, int model_col, int view_col, int row) 
{
    ECellTextView *text_view = (ECellTextView *) ecell_view;
    CurrentCell cell;
    int return_val;

    build_current_cell ( &cell, text_view, model_col, view_col, row );
    split_into_lines( &cell );
    
    return_val = (text_view->font->ascent + text_view->font->descent) * cell.breaks->num_lines + TEXT_PAD;
    
    unref_lines( &cell );
    
    return return_val;
}

/*
 * ECellView::enter_edit method
 */
static void *
ect_enter_edit (ECellView *ecell_view, int model_col, int view_col, int row)
{
    ECellTextView *text_view = (ECellTextView *) ecell_view;
    const char *str = e_table_model_value_at (ecell_view->e_table_model, model_col, row);
    CellEdit *edit;

    edit = g_new (CellEdit, 1);
    text_view->edit = edit;

    build_current_cell ( CURRENT_CELL(edit), text_view, model_col, view_col, row );

    edit->xofs_edit = 0.0;
    edit->yofs_edit = 0.0;
    
    edit->selection_start = 0;
    edit->selection_end = 0;
    edit->select_by_word = FALSE;

    edit->timeout_id = g_timeout_add(10, _blink_scroll_timeout, text_view);
    edit->timer = g_timer_new();
    g_timer_elapsed(edit->timer, &(edit->scroll_start));
    g_timer_start(edit->timer);

    edit->lastx = 0;
    edit->lasty = 0;
    edit->last_state = 0;

    edit->scroll_start = 0;
    edit->show_cursor = TRUE;
    edit->button_down = FALSE;
    
    edit->tep = NULL;

    edit->has_selection = FALSE;
    
    edit->invisible = NULL;
    edit->primary_selection = NULL;
    edit->primary_length = 0;
    edit->clipboard_selection = NULL;
    edit->clipboard_length = 0;

    edit->pointer_in = FALSE;
    edit->default_cursor_shown = TRUE;
    
    edit->old_text = g_strdup (str);
    edit->cell.text = g_strdup (str);

#if 0
    if ( edit->pointer_in ) {
        if ( edit->default_cursor_shown ) {
            gdk_window_set_cursor(GTK_WIDGET(item->canvas)->window, text_view->i_cursor);
            edit->default_cursor_shown = FALSE;
        }
    }
#endif

    ect_queue_redraw (text_view, view_col, row);
    
    return NULL;
}

/*
 * ECellView::leave_edit method
 */
static void
ect_leave_edit (ECellView *ecell_view, int model_col, int view_col, int row, void *edit_context)
{
    ECellTextView *text_view = (ECellTextView *) ecell_view;
    CellEdit *edit = text_view->edit;

    if (edit){
        ect_accept_edits (text_view);
        ect_stop_editing (text_view);
    } else {
        /*
         * We did invoke this leave edit internally
         */
    }
}

/*
 * GtkObject::destroy method
 */
static void
ect_destroy (GtkObject *object)
{
    ECellText *ect = E_CELL_TEXT (object);

    g_free (ect->font_name);

    GTK_OBJECT_CLASS (parent_class)->destroy (object);
}

static void
e_cell_text_class_init (GtkObjectClass *object_class)
{
    ECellClass *ecc = (ECellClass *) object_class;

    object_class->destroy = ect_destroy;

    ecc->new_view   = ect_new_view;
    ecc->kill_view  = ect_kill_view;
    ecc->realize    = ect_realize;
    ecc->unrealize  = ect_unrealize;
    ecc->draw       = ect_draw;
    ecc->event      = ect_event;
    ecc->height     = ect_height;
    ecc->enter_edit = ect_enter_edit;
    ecc->leave_edit = ect_leave_edit;

    parent_class = gtk_type_class (PARENT_TYPE);

    if (!clipboard_atom)
        clipboard_atom = gdk_atom_intern ("CLIPBOARD", FALSE);
}

E_MAKE_TYPE(e_cell_text, "ECellText", ECellText, e_cell_text_class_init, NULL, PARENT_TYPE);

ECell *
e_cell_text_new (ETableModel *etm, const char *fontname, GtkJustification justify, gboolean editable)
{
    ECellText *ect = gtk_type_new (e_cell_text_get_type ());

    ect->ellipsis = NULL;
    ect->use_ellipsis = TRUE;

    ect->editable = editable;

    ect->font_name = g_strdup (fontname);
    ect->justify = justify;
      
    return (ECell *) ect;
}

/* Calculates the x position of the specified line of text, based on the text's justification */
static int
get_line_xpos (CurrentCell *cell, struct line *line)
{
    int x;
    
    ECellTextView *text_view = cell->text_view;
    ECellText *ect = E_CELL_TEXT (((ECellView *)cell->text_view)->ecell);
    
    x = text_view->xofs + ect->x;

    switch (ect->justify) {
    case GTK_JUSTIFY_RIGHT:
        x += cell->width - line->width;
        break;

    case GTK_JUSTIFY_CENTER:
        x += (cell->width - line->width) / 2;
        break;

    default:
        /* For GTK_JUSTIFY_LEFT, we don't have to do anything.  We do not support
         * GTK_JUSTIFY_FILL, yet.
         */
        break;
    }

    return x;
}

/* Calculates the x position of the specified line of text, based on the text's justification */
static int
get_line_ypos (CurrentCell *cell, struct line *line)
{
    int y;

    ECellTextView *text_view = cell->text_view;
    ECellText *ect = E_CELL_TEXT (((ECellView *)cell->text_view)->ecell);
    ECellTextLineBreaks *linebreaks = cell->breaks;

    struct line *lines = linebreaks->lines;

    y = text_view->yofs + ect->y;
    y += (line - lines) * (text_view->font->ascent + text_view->font->descent);

    return y;
}

static void
_get_xy_from_position (CurrentCell *cell, gint position, gint *xp, gint *yp)
{
    if (xp || yp) {
        struct line *lines;
        int x, y;
        int j;
        ECellTextView *text_view = cell->text_view;
        GdkFont *font = text_view->font;
        ECellTextLineBreaks *linebreaks;
        
        split_into_lines(cell);
        
        linebreaks = cell->breaks;
        lines = linebreaks->lines;

        x = get_line_xpos (cell, lines);
        y = get_line_ypos (cell, lines);
        for (j = 0, lines = linebreaks->lines; j < linebreaks->num_lines; lines++, j++) {
            if (lines->text > cell->text + position)
                break;
            y += font->ascent + font->descent;
        }
        lines --;
        y -= font->descent;
        
        x += gdk_text_width (font,
                     lines->text,
                     position - (lines->text - cell->text));
        if ( (CellEdit *) cell == cell->text_view->edit ) {
            x -= ((CellEdit *)cell)->xofs_edit;
            y -= ((CellEdit *)cell)->yofs_edit;
        }
        if (xp)
            *xp = x;
        if (yp)
            *yp = y;
        unref_lines(cell);
    }
}

static gint
_get_position_from_xy (CurrentCell *cell, gint x, gint y)
{
    int i, j;
    int xpos, ypos;
    struct line *lines;
    int return_val;

    ECellTextView *text_view = cell->text_view;
    GdkFont *font = text_view->font;
    ECellTextLineBreaks *linebreaks;

    split_into_lines(cell);
    
    linebreaks = cell->breaks;

    lines = linebreaks->lines;

    if ( (CellEdit *) cell == cell->text_view->edit ) {
        x += ((CellEdit *)cell)->xofs_edit;
        y += ((CellEdit *)cell)->yofs_edit;
    }
    
    ypos = get_line_ypos (cell, linebreaks->lines);
    j = 0;
    while (y > ypos) {
        ypos += font->ascent + font->descent;
        j ++;
    }
    j--;
    if (j >= linebreaks->num_lines)
        j = linebreaks->num_lines - 1;
    if (j < 0)
        j = 0;
    i = 0;

    lines += j;
    xpos = get_line_xpos (cell, lines);
    for(i = 0; i < lines->length; i++) {
        int charwidth = gdk_text_width(font,
                           lines->text + i,
                           1);
        xpos += charwidth / 2;
        if (xpos > x) {
            break;
        }
        xpos += (charwidth + 1) / 2;
    }
    
    return_val = lines->text + i - cell->text;

    unref_lines(cell);

    return return_val;
}

#define SCROLL_WAIT_TIME 30000

static gboolean
_blink_scroll_timeout (gpointer data)
{
    CurrentCell *cell = CURRENT_CELL(data);
    ECellTextView *text_view = (ECellTextView *) data;
    ECellText *ect = E_CELL_TEXT (((ECellView *)text_view)->ecell);
    CellEdit *edit = text_view->edit;
    ECellTextLineBreaks *linebreaks = cell->breaks;

    gulong current_time;
    gboolean scroll = FALSE;
    gboolean redraw = FALSE;
    
    g_timer_elapsed(edit->timer, &current_time);

    if (edit->scroll_start + SCROLL_WAIT_TIME > 1000000) {
        if (current_time > edit->scroll_start - (1000000 - SCROLL_WAIT_TIME) &&
            current_time < edit->scroll_start)
            scroll = TRUE;
    } else {
        if (current_time > edit->scroll_start + SCROLL_WAIT_TIME ||
            current_time < edit->scroll_start)
            scroll = TRUE;
    }
    if (scroll && edit->button_down) {
        /* FIXME: Copy this for y. */
        if (edit->lastx - ect->x > cell->width &&
            edit->xofs_edit < linebreaks->max_width - cell->width) {
            edit->xofs_edit += 4;
            if (edit->xofs_edit > linebreaks->max_width - cell->width + 1)
                edit->xofs_edit = linebreaks->max_width - cell->width + 1;
            redraw = TRUE;
        }
        if (edit->lastx - ect->x < 0 &&
            edit->xofs_edit > 0) {
            edit->xofs_edit -= 4;
            if (edit->xofs_edit < 0)
                edit->xofs_edit = 0;
            redraw = TRUE;
        }
        if (redraw) {
            ETextEventProcessorEvent e_tep_event;
            e_tep_event.type = GDK_MOTION_NOTIFY;
            e_tep_event.motion.state = edit->last_state;
            e_tep_event.motion.time = 0;
            e_tep_event.motion.position = _get_position_from_xy(cell, edit->lastx, edit->lasty);
            _get_tep(edit);
            e_text_event_processor_handle_event (edit->tep,
                                 &e_tep_event);
            edit->scroll_start = current_time;
        }
    }

    if (!((current_time / 500000) % 2)) {
        if (!edit->show_cursor)
            redraw = TRUE;
        edit->show_cursor = TRUE;
    } else {
        if (edit->show_cursor)
            redraw = TRUE;
        edit->show_cursor = FALSE;
    }
    if ( redraw ) {
        ect_queue_redraw (text_view, edit->cell.view_col, edit->cell.row);
    }
    return TRUE;
}

static int
_get_position(ECellTextView *text_view, ETextEventProcessorCommand *command)
{
    int i;
    int length;
    int x, y;
    CellEdit *edit = text_view->edit;
    CurrentCell *cell = CURRENT_CELL(edit);
    
    switch (command->position) {
        
    case E_TEP_VALUE:
        return command->value;

    case E_TEP_SELECTION:
        return edit->selection_end;

    case E_TEP_START_OF_BUFFER:
        return 0;
    case E_TEP_END_OF_BUFFER:
        return strlen(cell->text);

    case E_TEP_START_OF_LINE:
        for (i = edit->selection_end - 2; i > 0; i--)
            if (cell->text[i] == '\n') {
                i++;
                break;
            }
        return i;
    case E_TEP_END_OF_LINE:
        length = strlen(cell->text);
        for (i = edit->selection_end + 1; i < length; i++)
            if (cell->text[i] == '\n') {
                break;
            }
        if (i > length)
            i = length;
        return i;

    case E_TEP_FORWARD_CHARACTER:
        length = strlen(cell->text);
        i = edit->selection_end + 1;
        if (i > length)
            i = length;
        return i;
    case E_TEP_BACKWARD_CHARACTER:
        i = edit->selection_end - 1;
        if (i < 0)
            i = 0;
        return i;

    case E_TEP_FORWARD_WORD:
        length = strlen(cell->text);
        for (i = edit->selection_end + 1; i < length; i++)
            if (isspace(cell->text[i])) {
                break;
            }
        if (i > length)
            i = length;
        return i;
    case E_TEP_BACKWARD_WORD:
        for (i = edit->selection_end - 2; i > 0; i--)
            if (isspace(cell->text[i])) {
                i++;
                break;
            }
        if (i < 0)
            i = 0;
        return i;

    case E_TEP_FORWARD_LINE:
        _get_xy_from_position(cell, edit->selection_end, &x, &y);
        y += text_view->font->ascent + text_view->font->descent;
        return _get_position_from_xy(cell, x, y);
    case E_TEP_BACKWARD_LINE:
        _get_xy_from_position(cell, edit->selection_end, &x, &y);
        y -= text_view->font->ascent + text_view->font->descent;
        return _get_position_from_xy(cell, x, y);

    case E_TEP_FORWARD_PARAGRAPH:
    case E_TEP_BACKWARD_PARAGRAPH:
        
    case E_TEP_FORWARD_PAGE:
    case E_TEP_BACKWARD_PAGE:
        return edit->selection_end;
    default:
        return edit->selection_end;
        }
}

static void
_delete_selection(ECellTextView *text_view)
{
    CellEdit *edit = text_view->edit;
    CurrentCell *cell = CURRENT_CELL(edit);
    gint length = strlen(cell->text);
    if (edit->selection_end == edit->selection_start)
        return;
    if (edit->selection_end < edit->selection_start) {
        edit->selection_end ^= edit->selection_start;
        edit->selection_start ^= edit->selection_end;
        edit->selection_end ^= edit->selection_start;
    }
    memmove( cell->text + edit->selection_start,
         cell->text + edit->selection_end,
         length - edit->selection_end + 1 );
    length -= edit->selection_end - edit->selection_start;
    edit->selection_end = edit->selection_start;
}

static void
_insert(ECellTextView *text_view, char *string, int value)
{
    if (value > 0) {
        char *temp;
        CellEdit *edit = text_view->edit;
        CurrentCell *cell = CURRENT_CELL(edit);
        gint length = strlen(cell->text);
        temp = g_new(gchar, length + value + 1);
        strncpy(temp, cell->text, edit->selection_start);
        strncpy(temp + edit->selection_start, string, value);
        strcpy(temp + edit->selection_start + value, cell->text + edit->selection_start);
        g_free(cell->text);
        cell->text = temp;
        edit->selection_start += value;
        edit->selection_end = edit->selection_start;
    }
}

static void
e_cell_text_view_command(ETextEventProcessor *tep, ETextEventProcessorCommand *command, gpointer data)
{
    CellEdit *edit = (CellEdit *) data;
    CurrentCell *cell = CURRENT_CELL(edit);
    ECellTextView *text_view = cell->text_view;

    gboolean change = FALSE;
    gboolean redraw = FALSE;

    int sel_start, sel_end;
    switch (command->action) {
    case E_TEP_MOVE:
        edit->selection_start = _get_position(text_view, command);
        edit->selection_end = edit->selection_start;
        if (edit->timer) {
            g_timer_reset(edit->timer);
        }
        redraw = TRUE;
        break;
    case E_TEP_SELECT:
        edit->selection_end = _get_position(text_view, command);
        sel_start = MIN(edit->selection_start, edit->selection_end);
        sel_end = MAX(edit->selection_start, edit->selection_end);
        if (sel_start != sel_end) {
            e_cell_text_view_supply_selection (edit, command->time, GDK_SELECTION_PRIMARY, cell->text + sel_start, sel_end - sel_start);
        } else if (edit->timer) {
            g_timer_reset(edit->timer);
        }
        redraw = TRUE;
        break;
    case E_TEP_DELETE:
        if (edit->selection_end == edit->selection_start) {
            edit->selection_end = _get_position(text_view, command);
        }
        _delete_selection(text_view);
        if (edit->timer) {
            g_timer_reset(edit->timer);
        }
        redraw = TRUE;
        change = TRUE;
        break;

    case E_TEP_INSERT:
        if (edit->selection_end != edit->selection_start) {
            _delete_selection(text_view);
        }
        _insert(text_view, command->string, command->value);
        if (edit->timer) {
            g_timer_reset(edit->timer);
        }
        redraw = TRUE;
        change = TRUE;
        break;
    case E_TEP_COPY:
        sel_start = MIN(edit->selection_start, edit->selection_end);
        sel_end = MAX(edit->selection_start, edit->selection_end);
        if (sel_start != sel_end) {
            e_cell_text_view_supply_selection (edit, command->time, clipboard_atom, cell->text + sel_start, sel_end - sel_start);
        }
        if (edit->timer) {
            g_timer_reset(edit->timer);
        }
        break;
    case E_TEP_PASTE:
        e_cell_text_view_get_selection (edit, clipboard_atom, command->time);
        if (edit->timer) {
            g_timer_reset(edit->timer);
        }
        redraw = TRUE;
        change = TRUE;
        break;
    case E_TEP_GET_SELECTION:
        e_cell_text_view_get_selection (edit, GDK_SELECTION_PRIMARY, command->time);
        break;
    case E_TEP_ACTIVATE:
        e_table_item_leave_edit (text_view->cell_view.e_table_item_view);
        break;
    case E_TEP_SET_SELECT_BY_WORD:
        edit->select_by_word = command->value;
        break;
    case E_TEP_GRAB:
    case E_TEP_UNGRAB:
#if 0
    case E_TEP_GRAB:
        gnome_canvas_item_grab (GNOME_CANVAS_ITEM(text), 
                    GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK,
                    text_view->i_cursor,
                    command->time);
        break;
        gnome_canvas_item_ungrab (GNOME_CANVAS_ITEM(text), command->time);
        break;
#endif
    case E_TEP_NOP:
        break;
    }

    if (!edit->button_down) {
        int x;
        int i;
        struct line *lines;
        ECellTextLineBreaks *linebreaks;
        
        split_into_lines(cell);
        
        linebreaks = cell->breaks;
    
        for (lines = linebreaks->lines, i = 0; i < linebreaks->num_lines ; i++, lines ++) {
            if (lines->text - cell->text > edit->selection_end) {
                break;
            }
        }
        lines --;
        x = gdk_text_width(text_view->font,
                   lines->text,
                   edit->selection_end - (lines->text - cell->text));
        

        if (x < edit->xofs_edit) {
            edit->xofs_edit = x;
            redraw = TRUE;
        }

        if (2 + x - cell->width > edit->xofs_edit) {
            edit->xofs_edit = 2 + x - cell->width;
            redraw = TRUE;
        }
        unref_lines(cell);
    }

    if ( redraw ) {
        ect_queue_redraw (text_view, edit->cell.view_col, edit->cell.row);
    }
#if 0
    gnome_canvas_item_request_update (GNOME_CANVAS_ITEM(text));
#endif
}

static void _invisible_destroy (GtkInvisible *invisible,
                CellEdit *edit)
{
    edit->invisible = NULL;
}

static GtkWidget *e_cell_text_view_get_invisible(CellEdit *edit)
{   
    GtkWidget *invisible;
    if (edit->invisible) {
        invisible = edit->invisible;
    } else {
        invisible = gtk_invisible_new();
        edit->invisible = invisible;
        
        gtk_selection_add_target (invisible,
                      GDK_SELECTION_PRIMARY,
                      GDK_SELECTION_TYPE_STRING,
                      E_SELECTION_PRIMARY);
        gtk_selection_add_target (invisible,
                      clipboard_atom,
                      GDK_SELECTION_TYPE_STRING,
                      E_SELECTION_CLIPBOARD);
        
        gtk_signal_connect (GTK_OBJECT(invisible), "selection_get",
                    GTK_SIGNAL_FUNC (_selection_get), 
                    edit);
        gtk_signal_connect (GTK_OBJECT(invisible), "selection_clear_event",
                    GTK_SIGNAL_FUNC (_selection_clear_event),
                    edit);
        gtk_signal_connect (GTK_OBJECT(invisible), "selection_received",
                    GTK_SIGNAL_FUNC (_selection_received),
                    edit);
        
        gtk_signal_connect (GTK_OBJECT(invisible), "destroy",
                    GTK_SIGNAL_FUNC (_invisible_destroy),
                    edit);
    }
    return invisible;
}

static void
_selection_clear_event (GtkInvisible *invisible,
            GdkEventSelection *event,
            CellEdit *edit)
{
    if (event->selection == GDK_SELECTION_PRIMARY) {
        g_free (edit->primary_selection);
        edit->primary_selection = NULL;
        edit->primary_length = 0;

        edit->has_selection = FALSE;
#if 0
        gnome_canvas_item_request_update (GNOME_CANVAS_ITEM(text));
#endif

    } else if (event->selection == clipboard_atom) {
        g_free (edit->clipboard_selection);
        edit->clipboard_selection = NULL;
        edit->clipboard_length = 0;
    }
}

static void
_selection_get (GtkInvisible *invisible,
        GtkSelectionData *selection_data,
        guint info,
        guint time_stamp,
        CellEdit *edit)
{
    switch (info) {
    case E_SELECTION_PRIMARY:
        gtk_selection_data_set (selection_data, GDK_SELECTION_TYPE_STRING,
                    8, edit->primary_selection, edit->primary_length);
        break;
    case E_SELECTION_CLIPBOARD:
        gtk_selection_data_set (selection_data, GDK_SELECTION_TYPE_STRING,
                    8, edit->clipboard_selection, edit->clipboard_length);
        break;
    }
}

static void
_selection_received (GtkInvisible *invisible,
             GtkSelectionData *selection_data,
             guint time,
             CellEdit *edit)
{
    if (selection_data->length < 0 || selection_data->type != GDK_SELECTION_TYPE_STRING) {
        return;
    } else {
        ETextEventProcessorCommand command;
        command.action = E_TEP_INSERT;
        command.position = E_TEP_SELECTION;
        command.string = selection_data->data;
        command.value = selection_data->length;
        command.time = time;
        e_cell_text_view_command(edit->tep, &command, edit);
    }
}

static void e_cell_text_view_supply_selection (CellEdit *edit, guint time, GdkAtom selection, guchar *data, gint length)
{
    gboolean successful;
    GtkWidget *invisible;

    invisible = e_cell_text_view_get_invisible(edit);

    if (selection == GDK_SELECTION_PRIMARY ) {
        if (edit->primary_selection) {
            g_free (edit->primary_selection);
        }
        edit->primary_selection = g_strndup(data, length);
        edit->primary_length = length;
    } else if (selection == clipboard_atom) {
        if (edit->clipboard_selection) {
            g_free (edit->clipboard_selection);
        }
        edit->clipboard_selection = g_strndup(data, length);
        edit->clipboard_length = length;
    }

    successful = gtk_selection_owner_set (invisible,
                          selection,
                          time);
    
    if (selection == GDK_SELECTION_PRIMARY)
        edit->has_selection = successful;
}

static void
e_cell_text_view_get_selection(CellEdit *edit, GdkAtom selection, guint32 time)
{
    GtkWidget *invisible;
    invisible = e_cell_text_view_get_invisible(edit);
    gtk_selection_convert(invisible,
                  selection,
                  GDK_SELECTION_TYPE_STRING,
                  time);
}

static void
_get_tep(CellEdit *edit)
{
    if (!edit->tep) {
        edit->tep = e_text_event_processor_emacs_like_new();
        gtk_object_ref (GTK_OBJECT (edit->tep));
        gtk_object_sink (GTK_OBJECT (edit->tep));
        gtk_signal_connect(GTK_OBJECT(edit->tep),
                   "command",
                   GTK_SIGNAL_FUNC(e_cell_text_view_command),
                   (gpointer) edit);
    }
}

/* Splits the text of the text item into lines */
static void
split_into_lines (CurrentCell *cell)
{
    char *p;
    struct line *lines;
    int len;

    gchar *text = cell->text;
    ECellTextLineBreaks *linebreaks = cell->breaks;

    if (! cell->breaks) {
        cell->breaks = g_new(ECellTextLineBreaks, 1);
        cell->breaks->ref_count = 1;
    } else {
        cell->breaks->ref_count ++;
        return;
    }
    linebreaks = cell->breaks;

    /* Check if already split. */

    linebreaks->lines = NULL;
    linebreaks->num_lines = 0;
    
    if (!text)
        return;
    
    /* First, count the number of lines */
    
    for (p = text; *p; p++)
        if (*p == '\n')
            linebreaks->num_lines++;
    
    linebreaks->num_lines++;
    
    /* Allocate array of lines and calculate split positions */
    
    linebreaks->lines = lines = g_new0 (struct line, linebreaks->num_lines);
    len = 0;
    
    for (p = text; *p; p++) {
        if (len == 0)
            lines->text = p;
        if (*p == '\n') {
            lines->length = len;
            lines++;
            len = 0;
        } else
            len++;
    }
    
    if (len == 0)
        lines->text = p;
    lines->length = len;
    
    calc_line_widths (cell);
}

/* Free lines structure. */
static void
unref_lines(CurrentCell *cell)
{
    if ( cell->breaks ) {
        cell->breaks->ref_count --;
        if ( cell->breaks->ref_count <= 0 ) {
            g_free(cell->breaks->lines);
            g_free(cell->breaks);
            cell->breaks = NULL;
        }
    }
}

static void
calc_ellipsis (ECellTextView *text_view)
{
    ECellText *ect = E_CELL_TEXT (((ECellView *)text_view)->ecell);
    if (text_view->font)
        text_view->ellipsis_width = 
            gdk_text_width (text_view->font,
                    ect->ellipsis ? ect->ellipsis : "...",
                    ect->ellipsis ? strlen (ect->ellipsis) : 3);
}

/* Calculates the line widths (in pixels) of the text's splitted lines */
static void
calc_line_widths (CurrentCell *cell)
{
    ECellTextView *text_view = cell->text_view;
    ECellText *ect = E_CELL_TEXT (((ECellView *)text_view)->ecell);
    GdkFont *font = text_view->font;
    ECellTextLineBreaks *linebreaks = cell->breaks;
    struct line *lines;
    int i;
    int j;
    
    

    lines = linebreaks->lines;
    linebreaks->max_width = 0;

    if (!lines)
        return;

    for (i = 0; i < linebreaks->num_lines; i++) {
        if (lines->length != 0) {
            if (font) {
                lines->width = gdk_text_width (font,
                                   lines->text, lines->length);
                lines->ellipsis_length = 0;
            } else {
                lines->width = 0;
            }
            
            if (ect->use_ellipsis &&
                (!(text_view->edit &&
                   cell->row == text_view->edit->cell.row &&
                   cell->view_col == text_view->edit->cell.view_col)) &&
                lines->width > cell->width) {
                if (font) {
                    lines->ellipsis_length = 0;
                    for (j = 0; j < lines->length; j++ ) {
                        if (gdk_text_width (font, lines->text, j) + text_view->ellipsis_width <= cell->width)
                            lines->ellipsis_length = j;
                        else
                            break;
                    }
                }
                else
                    lines->ellipsis_length = 0;
                lines->width = gdk_text_width (font, lines->text, lines->ellipsis_length) +
                    text_view->ellipsis_width;
            }
            else
                lines->ellipsis_length = lines->length;

            if (lines->width > linebreaks->max_width)
                linebreaks->max_width = lines->width;
        } else {
            lines->width = 0;
            lines->ellipsis_length = 0;
        }

        lines++;
    }
}

static void
build_current_cell (CurrentCell *cell, ECellTextView *text_view, int model_col, int view_col, int row)
{
    ECellView *ecell_view = (ECellView *) text_view;
    cell->text_view = text_view;
    cell->model_col = model_col;
    cell->view_col = view_col;
    cell->row = row;
    cell->breaks = NULL;
    cell->text = e_table_model_value_at (ecell_view->e_table_model, model_col, row);
    cell->width = e_table_header_get_column(((ETableItem *)ecell_view->e_table_item_view)->header, view_col)->width - 8;
}