path: root/e-util/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.
 *
 * 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 Lesser General Public License
 * along with this 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.
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include "e-cell-combo.h"

#include <string.h>

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

#include "e-cell-text.h"
#include "e-table-item.h"
#include "e-unicode.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 *button_event,
						 ECellCombo *ecc);
static gint	e_cell_combo_button_release	(GtkWidget *popup_window,
						 GdkEvent *button_event,
						 ECellCombo *ecc);
static gint	e_cell_combo_key_press		(GtkWidget *popup_window,
						 GdkEvent *key_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);
	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 != NULL) {
		gtk_widget_destroy (ecc->popup_window);
		ecc->popup_window = NULL;
	}

	if (ecc->grabbed_keyboard != NULL) {
		gdk_device_ungrab (ecc->grabbed_keyboard, GDK_CURRENT_TIME);
		g_object_unref (ecc->grabbed_keyboard);
		ecc->grabbed_keyboard = NULL;
	}

	if (ecc->grabbed_pointer != NULL) {
		gdk_device_ungrab (ecc->grabbed_pointer, GDK_CURRENT_TIME);
		g_object_unref (ecc->grabbed_pointer);
		ecc->grabbed_pointer = 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);
	GtkTreeSelection *selection;
	GdkGrabStatus grab_status;
	GdkWindow *window;
	GdkDevice *keyboard;
	GdkDevice *pointer;
	GdkDevice *event_device;
	guint32 event_time;

	g_return_val_if_fail (ecc->grabbed_keyboard == NULL, FALSE);
	g_return_val_if_fail (ecc->grabbed_pointer == NULL, FALSE);

	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);

	window = gtk_widget_get_window (ecc->popup_tree_view);

	event_device = gdk_event_get_device (event);
	event_time = gdk_event_get_time (event);

	if (gdk_device_get_source (event_device) == GDK_SOURCE_KEYBOARD) {
		keyboard = event_device;
		pointer = gdk_device_get_associated_device (event_device);
	} else {
		keyboard = gdk_device_get_associated_device (event_device);
		pointer = event_device;
	}

	if (pointer != NULL) {
		grab_status = gdk_device_grab (
			pointer,
			window,
			GDK_OWNERSHIP_NONE,
			TRUE,
			GDK_ENTER_NOTIFY_MASK |
			GDK_BUTTON_PRESS_MASK |
			GDK_BUTTON_RELEASE_MASK |
			GDK_POINTER_MOTION_HINT_MASK |
			GDK_BUTTON1_MOTION_MASK,
			NULL,
			event_time);

		if (grab_status != GDK_GRAB_SUCCESS)
			return FALSE;

		ecc->grabbed_pointer = g_object_ref (pointer);
	}

	gtk_grab_add (ecc->popup_window);

	if (keyboard != NULL) {
		grab_status = gdk_device_grab (
			keyboard,
			window,
			GDK_OWNERSHIP_NONE,
			TRUE,
			GDK_KEY_PRESS_MASK |
			GDK_KEY_RELEASE_MASK,
			NULL,
			event_time);

		if (grab_status != GDK_GRAB_SUCCESS) {
			if (ecc->grabbed_pointer != NULL) {
				gdk_device_ungrab (
					ecc->grabbed_pointer,
					event_time);
				g_object_unref (ecc->grabbed_pointer);
				ecc->grabbed_pointer = NULL;
			}
			return FALSE;
		}

		ecc->grabbed_keyboard = g_object_ref (keyboard);
	}

	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;
	ETableCol *ecol;
	gboolean found = FALSE;
	gchar *cell_text;
	gboolean valid;
	GtkTreeSelection *selection;
	GtkTreeIter iter;
	GtkTreeModel *model;

	eti = E_TABLE_ITEM (ecp->popup_cell_view->cell_view.e_table_item_view);

	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->spec->model_col, 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;

			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, ecv->e_table_model,
		ecol->spec->model_col, 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", G_STRFUNC));
}

/* 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;
	GtkWidget *canvas;
	GtkWidget *widget;
	GtkWidget *popwin_child;
	GtkWidget *popup_child;
	GtkBorder popwin_padding;
	GtkBorder popup_padding;
	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;

	eti = E_TABLE_ITEM (ecp->popup_cell_view->cell_view.e_table_item_view);
	canvas = GTK_WIDGET (GNOME_CANVAS_ITEM (eti)->canvas);

	/* 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_preferred_size (widget, &requisition, NULL);

	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_preferred_size (widget, &requisition, NULL);

	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);
	gtk_style_context_get_padding (gtk_widget_get_style_context (popwin_child), 0, &popwin_padding);

	popup_child = gtk_bin_get_child (GTK_BIN (popup));
	gtk_style_context_get_padding (gtk_widget_get_style_context (popup_child), 0, &popup_padding);

	/* Calculate the desired width. */
	*width = list_requisition.width
		+ 2 * popwin_padding.left
		+ 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_padding.left;

	/* 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_padding.top
		       + 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_padding.top);

	widget = gtk_scrolled_window_get_hscrollbar (popup);
	gtk_widget_get_preferred_size (widget, &requisition, NULL);

	/* Add on the height of the horizontal scrollbar if we need it. */
	if (show_hscroll)
		work_height +=
			requisition.height +
			GTK_SCROLLED_WINDOW_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 *button_event,
                           ECellCombo *ecc)
{
	GtkWidget *event_widget;
	guint32 event_time;

	event_time = gdk_event_get_time (button_event);
	event_widget = gtk_get_event_widget (button_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);

	if (ecc->grabbed_keyboard != NULL) {
		gdk_device_ungrab (ecc->grabbed_keyboard, event_time);
		g_object_unref (ecc->grabbed_keyboard);
		ecc->grabbed_keyboard = NULL;
	}

	if (ecc->grabbed_pointer != NULL) {
		gdk_device_ungrab (ecc->grabbed_pointer, event_time);
		g_object_unref (ecc->grabbed_pointer);
		ecc->grabbed_pointer = NULL;
	}

	gtk_widget_hide (ecc->popup_window);

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

	/* 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,
                             GdkEvent *button_event,
                             ECellCombo *ecc)
{
	GtkWidget *event_widget;
	guint32 event_time;

	event_time = gdk_event_get_time (button_event);
	event_widget = gtk_get_event_widget (button_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);

	if (ecc->grabbed_keyboard != NULL) {
		gdk_device_ungrab (ecc->grabbed_keyboard, event_time);
		g_object_unref (ecc->grabbed_keyboard);
		ecc->grabbed_keyboard = NULL;
	}

	if (ecc->grabbed_pointer != NULL) {
		gdk_device_ungrab (ecc->grabbed_pointer, event_time);
		g_object_unref (ecc->grabbed_pointer);
		ecc->grabbed_pointer = NULL;
	}

	gtk_widget_hide (ecc->popup_window);

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

	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,
                        GdkEvent *key_event,
                        ECellCombo *ecc)
{
	guint event_keyval = 0;
	guint32 event_time;

	gdk_event_get_keyval (key_event, &event_keyval);
	event_time = gdk_event_get_time (key_event);

	/* 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);

	if (ecc->grabbed_keyboard != NULL) {
		gdk_device_ungrab (ecc->grabbed_keyboard, event_time);
		g_object_unref (ecc->grabbed_keyboard);
		ecc->grabbed_keyboard = NULL;
	}

	if (ecc->grabbed_pointer != NULL) {
		gdk_device_ungrab (ecc->grabbed_pointer, event_time);
		g_object_unref (ecc->grabbed_pointer);
		ecc->grabbed_pointer = NULL;
	}

	gtk_widget_hide (ecc->popup_window);

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

	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->spec->model_col, 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->spec->model_col, ecp->popup_row, text);
	}

	e_cell_text_free_text (ecell_text, ecv->e_table_model,
		ecol->spec->model_col, 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
}