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

/*
 * e-cell-combo.c: Combo cell renderer
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) version 3.
 *
 * 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with the program; if not, see <http://www.gnu.org/licenses/>
 *
 *
 * Authors:
 *      Damon Chaplin <damon@ximian.com>
 *
 * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
 *
 */

/*
 * ECellCombo - a subclass of ECellPopup used to support popup lists like a
 * GtkCombo widget. It only supports a basic popup list of strings at present,
 * with no auto-completion.
 */

/*
 * Notes: (handling pointer grabs and GTK+ grabs is a nightmare!)
 *
 * o We must grab the pointer when we show the popup, so that if any buttons
 *   are pressed outside the application we hide the popup.
 *
 * o We have to be careful when popping up any widgets which also grab the
 *   pointer at some point, since we will lose our own pointer grab.
 *   When we pop up a list it will grab the pointer itself when an item is
 *   selected, and release the grab when the button is released.
 *   Fortunately we hide the popup at this point, so it isn't a problem.
 *   But for other types of widgets in the popup it could cause trouble.
 *   - I think GTK+ should provide help for this (nested pointer grabs?).
 *
 * o We must set the 'owner_events' flag of the pointer grab to TRUE so that
 *   pointer events get reported to all the application windows as normal.
 *   If we don't do this then the widgets in the popup may not work properly.
 *
 * o We must do a gtk_grab_add() so that we only allow events to go to the
 *   widgets within the popup (though some special events still get reported
 *   to the widget owning the window). Doing th gtk_grab_add() on the toplevel
 *   popup window should be fine. We can then check for any events that should
 *   close the popup, like the Escape key, or a button press outside the popup.
 */

#include <config.h>

#include <string.h>

#include <gdk/gdkkeysyms.h>
#include <gtk/gtk.h>

#include <glib/gi18n.h>
#include "e-util/e-util.h"
#include "e-util/e-unicode.h"

#include "e-table-item.h"
#include "e-cell-combo.h"
#include "e-cell-text.h"

#define d(x)

/* The height to make the popup list if there aren't any items in it. */
#define E_CELL_COMBO_LIST_EMPTY_HEIGHT  15

static void e_cell_combo_dispose    (GObject    *object);

static gint e_cell_combo_do_popup   (ECellPopup *ecp,
                     GdkEvent   *event,
                     gint             row,
                     gint             view_col);
static void e_cell_combo_select_matching_item   (ECellCombo *ecc);
static void e_cell_combo_show_popup (ECellCombo *ecc,
                     gint             row,
                     gint             view_col);
static void e_cell_combo_get_popup_pos  (ECellCombo *ecc,
                     gint             row,
                     gint             view_col,
                     gint       *x,
                     gint       *y,
                     gint       *height,
                     gint       *width);

static void e_cell_combo_selection_changed (GtkTreeSelection *selection, ECellCombo *ecc);

static gint e_cell_combo_button_press   (GtkWidget  *popup_window,
                     GdkEvent   *event,
                     ECellCombo *ecc);
static gint e_cell_combo_button_release (GtkWidget  *popup_window,
                     GdkEventButton *event,
                     ECellCombo *ecc);
static gint e_cell_combo_key_press  (GtkWidget  *popup_window,
                     GdkEventKey    *event,
                     ECellCombo *ecc);

static void e_cell_combo_update_cell    (ECellCombo *ecc);
static void e_cell_combo_restart_edit   (ECellCombo *ecc);

G_DEFINE_TYPE (ECellCombo, e_cell_combo, E_TYPE_CELL_POPUP)

static void
e_cell_combo_class_init         (ECellComboClass    *class)
{
    ECellPopupClass *ecpc = E_CELL_POPUP_CLASS (class);
    GObjectClass *object_class = G_OBJECT_CLASS (class);

    object_class->dispose = e_cell_combo_dispose;

    ecpc->popup = e_cell_combo_do_popup;
}

static void
e_cell_combo_init           (ECellCombo *ecc)
{
    GtkWidget *frame;
    AtkObject *a11y;
    GtkListStore *store;
    GtkTreeSelection *selection;
    GtkScrolledWindow *scrolled_window;

    /* We create one popup window for the ECell, since there will only
       ever be one popup in use at a time. */
    ecc->popup_window = gtk_window_new (GTK_WINDOW_POPUP);

    gtk_window_set_type_hint (GTK_WINDOW (ecc->popup_window), GDK_WINDOW_TYPE_HINT_COMBO);
    gtk_window_set_resizable (GTK_WINDOW (ecc->popup_window), TRUE);

    frame = gtk_frame_new (NULL);
    gtk_container_add (GTK_CONTAINER (ecc->popup_window), frame);
    gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
    gtk_widget_show (frame);

    ecc->popup_scrolled_window = gtk_scrolled_window_new (NULL, NULL);
    scrolled_window = GTK_SCROLLED_WINDOW (ecc->popup_scrolled_window);

    gtk_scrolled_window_set_policy (scrolled_window,
                    GTK_POLICY_AUTOMATIC,
                    GTK_POLICY_AUTOMATIC);
    gtk_widget_set_can_focus (gtk_scrolled_window_get_hscrollbar (scrolled_window), FALSE);
    gtk_widget_set_can_focus (gtk_scrolled_window_get_vscrollbar (scrolled_window), FALSE);
    gtk_container_add (GTK_CONTAINER (frame), ecc->popup_scrolled_window);
    gtk_widget_show (ecc->popup_scrolled_window);

    store = gtk_list_store_new (1, G_TYPE_STRING);
    ecc->popup_tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
    g_object_unref (store);

    gtk_tree_view_append_column (
        GTK_TREE_VIEW (ecc->popup_tree_view),
        gtk_tree_view_column_new_with_attributes ("Text", gtk_cell_renderer_text_new (), "text", 0, NULL));

    gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (ecc->popup_tree_view), FALSE);

    selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (ecc->popup_tree_view));
    gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
    gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (ecc->popup_scrolled_window), ecc->popup_tree_view);
    gtk_container_set_focus_vadjustment (GTK_CONTAINER (ecc->popup_tree_view),
                         gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (ecc->popup_scrolled_window)));
    gtk_container_set_focus_hadjustment (GTK_CONTAINER (ecc->popup_tree_view),
                         gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (ecc->popup_scrolled_window)));
    gtk_widget_show (ecc->popup_tree_view);

    a11y = gtk_widget_get_accessible (ecc->popup_tree_view);
    atk_object_set_name (a11y, _("popup list"));

    g_signal_connect (selection,
              "changed",
              G_CALLBACK (e_cell_combo_selection_changed),
              ecc);
    g_signal_connect (ecc->popup_window,
              "button_press_event",
              G_CALLBACK (e_cell_combo_button_press),
              ecc);
    /* We use connect_after here so the list updates the selection before
       we hide the popup and update the cell. */
    g_signal_connect (ecc->popup_window,
              "button_release_event",
              G_CALLBACK (e_cell_combo_button_release),
              ecc);
    g_signal_connect (ecc->popup_window,
              "key_press_event",
              G_CALLBACK (e_cell_combo_key_press), ecc);
}

/**
 * e_cell_combo_new:
 *
 * Creates a new ECellCombo renderer.
 *
 * Returns: an ECellCombo object.
 */
ECell *
e_cell_combo_new (void)
{
    return g_object_new (E_TYPE_CELL_COMBO, NULL);
}

/*
 * GObject::dispose method
 */
static void
e_cell_combo_dispose            (GObject *object)
{
    ECellCombo *ecc = E_CELL_COMBO (object);

    if (ecc->popup_window)
        gtk_widget_destroy (ecc->popup_window);
    ecc->popup_window = NULL;

    G_OBJECT_CLASS (e_cell_combo_parent_class)->dispose (object);
}

void
e_cell_combo_set_popdown_strings    (ECellCombo *ecc,
                     GList      *strings)
{
    GList *elem;
    GtkListStore *store;

    g_return_if_fail (E_IS_CELL_COMBO (ecc));
    g_return_if_fail (strings != NULL);

    store = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (ecc->popup_tree_view)));
    gtk_list_store_clear (store);

    for (elem = strings; elem; elem = elem->next) {
        GtkTreeIter iter;
        gchar *utf8_text = elem->data;

        gtk_list_store_append (store, &iter);
        gtk_list_store_set (store, &iter, 0, utf8_text, -1);
    }
}

static gint
e_cell_combo_do_popup           (ECellPopup *ecp,
                     GdkEvent   *event,
                     gint             row,
                     gint             view_col)
{
    ECellCombo *ecc = E_CELL_COMBO (ecp);
    guint32 time;
    gint error_code;
    GtkTreeSelection *selection;

    selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (ecc->popup_tree_view));

    g_signal_handlers_block_by_func (selection, e_cell_combo_selection_changed, ecc);
    e_cell_combo_show_popup (ecc, row, view_col);
    e_cell_combo_select_matching_item (ecc);
    g_signal_handlers_unblock_by_func (selection, e_cell_combo_selection_changed, ecc);

    if (event->type == GDK_BUTTON_PRESS) {
        time = event->button.time;
    } else {
        time = event->key.time;
    }

    error_code = gdk_pointer_grab (gtk_widget_get_window (ecc->popup_tree_view), TRUE,
                       GDK_ENTER_NOTIFY_MASK |
                       GDK_BUTTON_PRESS_MASK |
                       GDK_BUTTON_RELEASE_MASK |
                       GDK_POINTER_MOTION_HINT_MASK |
                       GDK_BUTTON1_MOTION_MASK,
                       NULL, NULL, time);
    if (error_code != 0)
        g_warning ("Failed to get pointer grab (%i)", error_code);
    gtk_grab_add (ecc->popup_window);
    gdk_keyboard_grab (gtk_widget_get_window (ecc->popup_tree_view), TRUE, time);

    return TRUE;
}

static void
e_cell_combo_select_matching_item   (ECellCombo *ecc)
{
    ECellPopup *ecp = E_CELL_POPUP (ecc);
    ECellView *ecv = (ECellView*) ecp->popup_cell_view;
    ECellText *ecell_text = E_CELL_TEXT (ecp->child);
    ETableItem *eti = E_TABLE_ITEM (ecp->popup_cell_view->cell_view.e_table_item_view);
    ETableCol *ecol;
    gboolean found = FALSE;
    gchar *cell_text;
    gboolean valid;
    GtkTreeSelection *selection;
    GtkTreeIter iter;
    GtkTreeModel *model;

    ecol = e_table_header_get_column (eti->header, ecp->popup_view_col);
    cell_text = e_cell_text_get_text (ecell_text, ecv->e_table_model,
                      ecol->col_idx, ecp->popup_row);

    model = gtk_tree_view_get_model (GTK_TREE_VIEW (ecc->popup_tree_view));
    selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (ecc->popup_tree_view));

    for (valid = gtk_tree_model_get_iter_first (model, &iter);
         valid && !found;
         valid = gtk_tree_model_iter_next (model, &iter)) {
        gchar *str = NULL;

        gtk_tree_model_get (model, &iter, 0, &str, -1);

        if (str && g_str_equal (str, cell_text)) {
            GtkTreePath *path = gtk_tree_model_get_path (model, &iter);

            gtk_tree_view_set_cursor (GTK_TREE_VIEW (ecc->popup_tree_view), path, NULL, FALSE);
            gtk_tree_path_free (path);

            found = TRUE;
        }

        g_free (str);
    }

    if (!found)
        gtk_tree_selection_unselect_all (selection);

    e_cell_text_free_text (ecell_text, cell_text);
}

static void
e_cell_combo_show_popup         (ECellCombo *ecc, gint row, gint view_col)
{
    GdkWindow *window;
    GtkAllocation allocation;
    gint x, y, width, height, old_width, old_height;

    gtk_widget_get_allocation (ecc->popup_window, &allocation);

    /* This code is practically copied from GtkCombo. */
    old_width = allocation.width;
    old_height = allocation.height;

    e_cell_combo_get_popup_pos (ecc, row, view_col, &x, &y, &height, &width);

    /* workaround for gtk_scrolled_window_size_allocate bug */
    if (old_width != width || old_height != height) {
        gtk_widget_hide (
            gtk_scrolled_window_get_hscrollbar (
            GTK_SCROLLED_WINDOW (ecc->popup_scrolled_window)));
        gtk_widget_hide (
            gtk_scrolled_window_get_vscrollbar (
            GTK_SCROLLED_WINDOW (ecc->popup_scrolled_window)));
    }

    gtk_window_move (GTK_WINDOW (ecc->popup_window), x, y);
    gtk_widget_set_size_request (ecc->popup_window, width, height);
    gtk_widget_realize (ecc->popup_window);
    window = gtk_widget_get_window (ecc->popup_window);
    gdk_window_resize (window, width, height);
    gtk_widget_show (ecc->popup_window);

    e_cell_popup_set_shown (E_CELL_POPUP (ecc), TRUE);
    d(g_print("%s: popup_shown = TRUE\n", __FUNCTION__));
}

/* Calculates the size and position of the popup window (like GtkCombo). */
static void
e_cell_combo_get_popup_pos      (ECellCombo *ecc,
                     gint             row,
                     gint             view_col,
                     gint       *x,
                     gint       *y,
                     gint       *height,
                     gint       *width)
{
    ECellPopup *ecp = E_CELL_POPUP (ecc);
    ETableItem *eti = E_TABLE_ITEM (ecp->popup_cell_view->cell_view.e_table_item_view);
    GtkWidget *canvas = GTK_WIDGET (GNOME_CANVAS_ITEM (eti)->canvas);
    GtkWidget *widget;
    GtkWidget *popwin_child;
    GtkWidget *popup_child;
    GtkStyle *popwin_style;
    GtkStyle *popup_style;
    GdkWindow *window;
    GtkBin *popwin;
    GtkScrolledWindow *popup;
    GtkRequisition requisition;
    GtkRequisition list_requisition;
    gboolean show_vscroll = FALSE, show_hscroll = FALSE;
    gint avail_height, avail_width, min_height, work_height, screen_width;
    gint column_width, row_height, scrollbar_width;
    gdouble x1, y1;
    gdouble wx, wy;

    /* This code is practically copied from GtkCombo. */
    popup  = GTK_SCROLLED_WINDOW (ecc->popup_scrolled_window);
    popwin = GTK_BIN (ecc->popup_window);

    window = gtk_widget_get_window (canvas);
    gdk_window_get_origin (window, x, y);

    x1 = e_table_header_col_diff (eti->header, 0, view_col + 1);
    y1 = e_table_item_row_diff (eti, 0, row + 1);
    column_width = e_table_header_col_diff (eti->header, view_col,
                        view_col + 1);
    row_height = e_table_item_row_diff (eti, row,
                        row + 1);
    gnome_canvas_item_i2w (GNOME_CANVAS_ITEM (eti), &x1, &y1);

    gnome_canvas_world_to_window (GNOME_CANVAS (canvas),
                      x1,
                      y1,
                      &wx,
                      &wy);

    x1 = wx;
    y1 = wy;

    *x += x1;
    /* The ETable positions don't include the grid lines, I think, so we add 1. */
    *y += y1 + 1
        - (gint)gtk_adjustment_get_value (
            gtk_scrollable_get_vadjustment (
            GTK_SCROLLABLE (&((GnomeCanvas *)canvas)->layout)))
        + ((GnomeCanvas *)canvas)->zoom_yofs;

    widget = gtk_scrolled_window_get_vscrollbar (popup);
    gtk_widget_get_child_requisition (widget, &requisition);

    scrollbar_width =
        requisition.width
        + GTK_SCROLLED_WINDOW_CLASS (G_OBJECT_GET_CLASS (popup))->scrollbar_spacing;

    avail_height = gdk_screen_height () - *y;

    /* We'll use the entire screen width if needed, but we save space for
       the vertical scrollbar in case we need to show that. */
    screen_width = gdk_screen_width ();
    avail_width = screen_width - scrollbar_width;

    widget = gtk_scrolled_window_get_vscrollbar (popup);
    gtk_widget_get_child_requisition (widget, &requisition);

    gtk_widget_get_preferred_size (ecc->popup_tree_view, &list_requisition, NULL);
    min_height = MIN (list_requisition.height, requisition.height);
    if (!gtk_tree_model_iter_n_children (gtk_tree_view_get_model (GTK_TREE_VIEW (ecc->popup_tree_view)), NULL))
        list_requisition.height += E_CELL_COMBO_LIST_EMPTY_HEIGHT;

    popwin_child = gtk_bin_get_child (popwin);
    popwin_style = gtk_widget_get_style (popwin_child);

    popup_child = gtk_bin_get_child (GTK_BIN (popup));
    popup_style = gtk_widget_get_style (popup_child);

    /* Calculate the desired width. */
    *width = list_requisition.width
        + 2 * popwin_style->xthickness
        + 2 * gtk_container_get_border_width (GTK_CONTAINER (popwin_child))
        + 2 * gtk_container_get_border_width (GTK_CONTAINER (popup))
        + 2 * gtk_container_get_border_width (GTK_CONTAINER (popup_child))
        + 2 * popup_style->xthickness;

    /* Use at least the same width as the column. */
    if (*width < column_width)
        *width = column_width;

    /* If it is larger than the available width, use that instead and show
       the horizontal scrollbar. */
    if (*width > avail_width) {
        *width = avail_width;
        show_hscroll = TRUE;
    }

    /* Calculate all the borders etc. that we need to add to the height. */
    work_height = (2 * popwin_style->ythickness
               + 2 * gtk_container_get_border_width (GTK_CONTAINER (popwin_child))
               + 2 * gtk_container_get_border_width (GTK_CONTAINER (popup))
               + 2 * gtk_container_get_border_width (GTK_CONTAINER (popup_child))
               + 2 * popup_style->xthickness);

    widget = gtk_scrolled_window_get_hscrollbar (popup);
    gtk_widget_get_child_requisition (widget, &requisition);

    /* Add on the height of the horizontal scrollbar if we need it. */
    if (show_hscroll)
        work_height +=
            requisition.height +
            GTK_SCROLLED_WINDOW_CLASS (G_OBJECT_GET_CLASS (popup))->scrollbar_spacing;

    /* Check if it fits in the available height. */
    if (work_height + list_requisition.height > avail_height) {
        /* It doesn't fit, so we see if we have the minimum space
           needed. */
        if (work_height + min_height > avail_height
            && *y - row_height > avail_height) {
            /* We don't, so we show the popup above the cell
               instead of below it. */
            avail_height = *y - row_height;
            *y -= (work_height + list_requisition.height
                   + row_height);
            if (*y < 0)
                *y = 0;
        }
    }

    /* Check if we still need the vertical scrollbar. */
    if (work_height + list_requisition.height > avail_height) {
        *width += scrollbar_width;
        show_vscroll = TRUE;
    }

    /* We try to line it up with the right edge of the column, but we don't
       want it to go off the edges of the screen. */
    if (*x > screen_width)
        *x = screen_width;
    *x -= *width;
    if (*x < 0)
        *x = 0;

    if (show_vscroll)
        *height = avail_height;
    else
        *height = work_height + list_requisition.height;
}

static void
e_cell_combo_selection_changed (GtkTreeSelection *selection, ECellCombo *ecc)
{
    GtkTreeIter iter;
    GtkTreeModel *model;

    if (!gtk_widget_get_realized (ecc->popup_window) || !gtk_tree_selection_get_selected (selection, &model, &iter))
        return;

    e_cell_combo_update_cell (ecc);
    e_cell_combo_restart_edit (ecc);
}

/* This handles button press events in the popup window.
   Note that since we have a pointer grab on this window, we also get button
   press events for windows outside the application here, so we hide the popup
   window if that happens. We also get propagated events from child widgets
   which we ignore. */
static gint
e_cell_combo_button_press       (GtkWidget  *popup_window,
                     GdkEvent   *event,
                     ECellCombo *ecc)
{
    GtkWidget *event_widget;

    event_widget = gtk_get_event_widget (event);

    /* If the button press was for a widget inside the popup list, but
       not the popup window itself, then we ignore the event and return
       FALSE. Otherwise we will hide the popup.
       Note that since we have a pointer grab on the popup list, button
       presses outside the application will be reported to this window,
       which is why we hide the popup in this case. */
    while (event_widget) {
        event_widget = gtk_widget_get_parent (event_widget);
        if (event_widget == ecc->popup_tree_view)
            return FALSE;
    }

    gtk_grab_remove (ecc->popup_window);
    gdk_pointer_ungrab (event->button.time);
    gdk_keyboard_ungrab (event->button.time);
    gtk_widget_hide (ecc->popup_window);

    e_cell_popup_set_shown (E_CELL_POPUP (ecc), FALSE);
    d(g_print("%s: popup_shown = FALSE\n", __FUNCTION__));

    /* We don't want to update the cell here. Since the list is in browse
       mode there will always be one item selected, so when we popup the
       list one item is selected even if it doesn't match the current text
       in the cell. So if you click outside the popup (which is what has
       happened here) it is better to not update the cell. */
    /*e_cell_combo_update_cell (ecc);*/
    e_cell_combo_restart_edit (ecc);

    return TRUE;
}

/* This handles button release events in the popup window. If the button is
   released inside the list, we want to hide the popup window and update the
   cell with the new selection. */
static gint
e_cell_combo_button_release     (GtkWidget  *popup_window,
                     GdkEventButton *event,
                     ECellCombo *ecc)
{
    GtkWidget *event_widget;

    event_widget = gtk_get_event_widget ((GdkEvent*) event);

    /* See if the button was released in the list (or its children). */
    while (event_widget && event_widget != ecc->popup_tree_view)
        event_widget = gtk_widget_get_parent (event_widget);

    /* If it wasn't, then we just ignore the event. */
    if (event_widget != ecc->popup_tree_view)
        return FALSE;

    /* The button was released inside the list, so we hide the popup and
       update the cell to reflect the new selection. */
    gtk_grab_remove (ecc->popup_window);
    gdk_pointer_ungrab (event->time);
    gdk_keyboard_ungrab (event->time);
    gtk_widget_hide (ecc->popup_window);

    e_cell_popup_set_shown (E_CELL_POPUP (ecc), FALSE);
    d(g_print("%s: popup_shown = FALSE\n", __FUNCTION__));

    e_cell_combo_update_cell (ecc);
    e_cell_combo_restart_edit (ecc);

    return TRUE;
}

/* This handles key press events in the popup window. If the Escape key is
   pressed we hide the popup, and do not change the cell contents. */
static gint
e_cell_combo_key_press          (GtkWidget  *popup_window,
                     GdkEventKey    *event,
                     ECellCombo *ecc)
{
    /* If the Escape key is pressed we hide the popup. */
    if (event->keyval != GDK_KEY_Escape
        && event->keyval != GDK_KEY_Return
        && event->keyval != GDK_KEY_KP_Enter
        && event->keyval != GDK_KEY_ISO_Enter
        && event->keyval != GDK_KEY_3270_Enter)
        return FALSE;

    if (event->keyval == GDK_KEY_Escape && (!ecc->popup_window||!gtk_widget_get_visible (ecc->popup_window)))
        return FALSE;

    gtk_grab_remove (ecc->popup_window);
    gdk_pointer_ungrab (event->time);
    gdk_keyboard_ungrab (event->time);
    gtk_widget_hide (ecc->popup_window);

    e_cell_popup_set_shown (E_CELL_POPUP (ecc), FALSE);
    d(g_print("%s: popup_shown = FALSE\n", __FUNCTION__));

    if (event->keyval != GDK_KEY_Escape)
        e_cell_combo_update_cell (ecc);

    e_cell_combo_restart_edit (ecc);

    return TRUE;
}

static void
e_cell_combo_update_cell        (ECellCombo *ecc)
{
    ECellPopup *ecp = E_CELL_POPUP (ecc);
    ECellView *ecv = (ECellView*) ecp->popup_cell_view;
    ECellText *ecell_text = E_CELL_TEXT (ecp->child);
    ETableItem *eti = E_TABLE_ITEM (ecv->e_table_item_view);
    ETableCol *ecol;
    GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (ecc->popup_tree_view));
    GtkTreeModel *model;
    GtkTreeIter iter;
    gchar *text = NULL, *old_text;

    /* Return if no item is selected. */
    if (!gtk_tree_selection_get_selected (selection, &model, &iter))
        return;

    /* Get the text of the selected item. */
    gtk_tree_model_get (model, &iter, 0, &text, -1);
    g_return_if_fail (text != NULL);

    /* Compare it with the existing cell contents. */
    ecol = e_table_header_get_column (eti->header, ecp->popup_view_col);

    old_text = e_cell_text_get_text (ecell_text, ecv->e_table_model,
                     ecol->col_idx, ecp->popup_row);

    /* If they are different, update the cell contents. */
    if (old_text && strcmp (old_text, text)) {
        e_cell_text_set_value (ecell_text, ecv->e_table_model,
                       ecol->col_idx, ecp->popup_row, text);
    }

    e_cell_text_free_text (ecell_text, old_text);
    g_free (text);
}

static void
e_cell_combo_restart_edit       (ECellCombo *ecc)
{
    /* This doesn't work. ETable stops the edit straight-away again. */
#if 0
    ECellView *ecv = (ECellView*) ecc->popup_cell_view;
    ETableItem *eti = E_TABLE_ITEM (ecv->e_table_item_view);

    e_table_item_enter_edit (eti, ecc->popup_view_col, ecc->popup_row);
#endif
}