/*

 * 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:

 *		Chris Lahey <clahey@ximian.com>

 *		Miguel de Icaza <miguel@gnu.org>

 *

 * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)

 *

 */

#include "evolution-config.h"

#include "e-table-header-item.h"

#include <string.h>

#include <gtk/gtk.h>

#include <glib/gi18n.h>

#include <gdk/gdkkeysyms.h>

#include <gdk-pixbuf/gdk-pixbuf.h>

#include <libgnomecanvas/libgnomecanvas.h>

#include "e-canvas.h"

#include "e-popup-menu.h"

#include "e-table-col-dnd.h"

#include "e-table-config.h"

#include "e-table-defines.h"

#include "e-table-field-chooser-dialog.h"

#include "e-table-header-utils.h"

#include "e-table-header.h"

#include "e-table.h"

#include "e-xml-utils.h"

#include "data/xpm/arrow-up.xpm"

#include "data/xpm/arrow-down.xpm"

enum {

	BUTTON_PRESSED,

	LAST_SIGNAL

};

static guint ethi_signals[LAST_SIGNAL] = { 0, };

#define ARROW_DOWN_HEIGHT 16

#define ARROW_PTR          7

/* Defines the tolerance for proximity of the column division to the cursor position */

#define TOLERANCE 4

#define ETHI_RESIZING(x) ((x)->resize_col != -1)

#define ethi_get_type e_table_header_item_get_type

G_DEFINE_TYPE (ETableHeaderItem, ethi, GNOME_TYPE_CANVAS_ITEM)

#define d(x)

static void ethi_drop_table_header (ETableHeaderItem *ethi);

/*

 * They display the arrows for the drop location.

 */

static GtkWidget *arrow_up, *arrow_down;

enum {

	PROP_0,

	PROP_TABLE_HEADER,

	PROP_FULL_HEADER,

	PROP_DND_CODE,

	PROP_TABLE_FONT_DESC,

	PROP_SORT_INFO,

	PROP_TABLE,

	PROP_TREE

};

enum {

	ET_SCROLL_UP = 1 << 0,

	ET_SCROLL_DOWN = 1 << 1,

	ET_SCROLL_LEFT = 1 << 2,

	ET_SCROLL_RIGHT = 1 << 3

};

static void scroll_off (ETableHeaderItem *ethi);

static void scroll_on (ETableHeaderItem *ethi, guint scroll_direction);

static void

ethi_dispose (GObject *object)

{

	ETableHeaderItem *ethi = E_TABLE_HEADER_ITEM (object);

	ethi_drop_table_header (ethi);

	scroll_off (ethi);

	if (ethi->resize_cursor) {

		g_object_unref (ethi->resize_cursor);

		ethi->resize_cursor = NULL;

	}

	if (ethi->dnd_code) {

		g_free (ethi->dnd_code);

		ethi->dnd_code = NULL;

	}

	if (ethi->sort_info) {

		if (ethi->sort_info_changed_id)

			g_signal_handler_disconnect (

				ethi->sort_info, ethi->sort_info_changed_id);

		if (ethi->group_info_changed_id)

			g_signal_handler_disconnect (

				ethi->sort_info, ethi->group_info_changed_id);

		g_object_unref (ethi->sort_info);

		ethi->sort_info = NULL;

	}

	if (ethi->full_header)

		g_object_unref (ethi->full_header);

	ethi->full_header = NULL;

	if (ethi->etfcd.widget)

		g_object_remove_weak_pointer (

			G_OBJECT (ethi->etfcd.widget), &ethi->etfcd.pointer);

	if (ethi->config)

		g_object_unref (ethi->config);

	ethi->config = NULL;

	/* Chain up to parent's dispose() method. */

	G_OBJECT_CLASS (ethi_parent_class)->dispose (object);

}

static gint

e_table_header_item_get_height (ETableHeaderItem *ethi)

{

	ETableHeader *eth;

	gint numcols, col;

	gint maxheight;

	g_return_val_if_fail (ethi != NULL, 0);

	g_return_val_if_fail (E_IS_TABLE_HEADER_ITEM (ethi), 0);

	eth = ethi->eth;

	numcols = e_table_header_count (eth);

	maxheight = 0;

	for (col = 0; col < numcols; col++) {

		ETableCol *ecol = e_table_header_get_column (eth, col);

		gint height;

		height = e_table_header_compute_height (

			ecol, GTK_WIDGET (GNOME_CANVAS_ITEM (ethi)->canvas));

		if (height > maxheight)

			maxheight = height;

	}

	return maxheight;

}

static void

ethi_update (GnomeCanvasItem *item,

             const cairo_matrix_t *i2c,

             gint flags)

{

	ETableHeaderItem *ethi = E_TABLE_HEADER_ITEM (item);

	gdouble x1, y1, x2, y2;

	if (GNOME_CANVAS_ITEM_CLASS (ethi_parent_class)->update)

		GNOME_CANVAS_ITEM_CLASS (ethi_parent_class)->update (

			item, i2c, flags);

	if (ethi->sort_info)

		ethi->group_indent_width =

			e_table_sort_info_grouping_get_count (ethi->sort_info)

			* GROUP_INDENT;

	else

		ethi->group_indent_width = 0;

	ethi->width =

		e_table_header_total_width (ethi->eth) +

		ethi->group_indent_width;

	x1 = y1 = 0;

	x2 = ethi->width;

	y2 = ethi->height;

	gnome_canvas_matrix_transform_rect (i2c, &x1, &y1, &x2, &y2;;

	if (item->x1 != x1 ||

	    item->y1 != y1 ||

	    item->x2 != x2 ||

	    item->y2 != y2) {

		gnome_canvas_request_redraw (

			item->canvas,

			item->x1, item->y1,

			item->x2, item->y2);

		item->x1 = x1;

		item->y1 = y1;

		item->x2 = x2;

		item->y2 = y2;

	}

	gnome_canvas_request_redraw (

		item->canvas, item->x1, item->y1, item->x2, item->y2);

}

static void

ethi_font_set (ETableHeaderItem *ethi,

               PangoFontDescription *font_desc)

{

	if (ethi->font_desc)

		pango_font_description_free (ethi->font_desc);

	ethi->font_desc = pango_font_description_copy (font_desc);

	ethi->height = e_table_header_item_get_height (ethi);

	e_canvas_item_request_reflow (GNOME_CANVAS_ITEM (ethi));

}

static void

ethi_drop_table_header (ETableHeaderItem *ethi)

{

	GObject *header;

	if (!ethi->eth)

		return;

	header = G_OBJECT (ethi->eth);

	g_signal_handler_disconnect (header, ethi->structure_change_id);

	g_signal_handler_disconnect (header, ethi->dimension_change_id);

	g_object_unref (header);

	ethi->eth = NULL;

	ethi->width = 0;

}

static void

structure_changed (ETableHeader *header,

                   ETableHeaderItem *ethi)

{

	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (ethi));

}

static void

dimension_changed (ETableHeader *header,

                   gint col,

                   ETableHeaderItem *ethi)

{

	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (ethi));

}

static void

ethi_add_table_header (ETableHeaderItem *ethi,

                       ETableHeader *header)

{

	ethi->eth = header;

	g_object_ref (ethi->eth);

	ethi->height = e_table_header_item_get_height (ethi);

	ethi->structure_change_id = g_signal_connect (

		header, "structure_change",

		G_CALLBACK (structure_changed), ethi);

	ethi->dimension_change_id = g_signal_connect (

		header, "dimension_change",

		G_CALLBACK (dimension_changed), ethi);

	e_canvas_item_request_reflow (GNOME_CANVAS_ITEM (ethi));

	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (ethi));

}

static void

ethi_sort_info_changed (ETableSortInfo *sort_info,

                        ETableHeaderItem *ethi)

{

	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (ethi));

}

static void

ethi_set_property (GObject *object,

                   guint property_id,

                   const GValue *value,

                   GParamSpec *pspec)

{

	GnomeCanvasItem *item;

	ETableHeaderItem *ethi;

	item = GNOME_CANVAS_ITEM (object);

	ethi = E_TABLE_HEADER_ITEM (object);

	switch (property_id) {

	case PROP_TABLE_HEADER:

		ethi_drop_table_header (ethi);

		ethi_add_table_header (ethi, E_TABLE_HEADER (g_value_get_object (value)));

		break;

	case PROP_FULL_HEADER:

		if (ethi->full_header)

			g_object_unref (ethi->full_header);

		ethi->full_header = E_TABLE_HEADER (g_value_get_object (value));

		if (ethi->full_header)

			g_object_ref (ethi->full_header);

		break;

	case PROP_DND_CODE:

		g_free (ethi->dnd_code);

		ethi->dnd_code = g_strdup (g_value_get_string (value));

		break;

	case PROP_TABLE_FONT_DESC:

		ethi_font_set (ethi, g_value_get_boxed (value));

		break;

	case PROP_SORT_INFO:

		if (ethi->sort_info) {

			if (ethi->sort_info_changed_id)

				g_signal_handler_disconnect (

					ethi->sort_info,

					ethi->sort_info_changed_id);

			if (ethi->group_info_changed_id)

				g_signal_handler_disconnect (

					ethi->sort_info,

					ethi->group_info_changed_id);

			g_object_unref (ethi->sort_info);

		}

		ethi->sort_info = g_value_get_object (value);

		g_object_ref (ethi->sort_info);

		ethi->sort_info_changed_id =

			g_signal_connect (

				ethi->sort_info, "sort_info_changed",

				G_CALLBACK (ethi_sort_info_changed), ethi);

		ethi->group_info_changed_id =

			g_signal_connect (

				ethi->sort_info, "group_info_changed",

				G_CALLBACK (ethi_sort_info_changed), ethi);

		break;

	case PROP_TABLE:

		if (g_value_get_object (value))

			ethi->table = E_TABLE (g_value_get_object (value));

		else

			ethi->table = NULL;

		break;

	case PROP_TREE:

		if (g_value_get_object (value))

			ethi->tree = E_TREE (g_value_get_object (value));

		else

			ethi->tree = NULL;

		break;

	}

	gnome_canvas_item_request_update (item);

}

static void

ethi_get_property (GObject *object,

                   guint property_id,

                   GValue *value,

                   GParamSpec *pspec)

{

	ETableHeaderItem *ethi;

	ethi = E_TABLE_HEADER_ITEM (object);

	switch (property_id) {

	case PROP_FULL_HEADER:

		g_value_set_object (value, ethi->full_header);

		break;

	case PROP_DND_CODE:

		g_value_set_string (value, ethi->dnd_code);

		break;

	default:

		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

		break;

	}

}

static gint

ethi_find_col_by_x (ETableHeaderItem *ethi,

                    gint x)

{

	const gint cols = e_table_header_count (ethi->eth);

	gint x1 = 0;

	gint col;

	d (g_print ("%s:%d: x = %d, x1 = %d\n", G_STRFUNC, __LINE__, x, x1));

	x1 += ethi->group_indent_width;

	if (x < x1) {

		d (g_print ("%s:%d: Returning 0\n", G_STRFUNC, __LINE__));

		return 0;

	}

	for (col = 0; col < cols; col++) {

		ETableCol *ecol = e_table_header_get_column (ethi->eth, col);

		if ((x >= x1) && (x <= x1 + ecol->width)) {

			d (g_print ("%s:%d: Returning %d\n", G_STRFUNC, __LINE__, col));

			return col;

		}

		x1 += ecol->width;

	}

	d (g_print ("%s:%d: Returning %d\n", G_STRFUNC, __LINE__, cols - 1));

	return cols - 1;

}

static gint

ethi_find_col_by_x_nearest (ETableHeaderItem *ethi,

                            gint x)

{

	const gint cols = e_table_header_count (ethi->eth);

	gint x1 = 0;

	gint col;

	x1 += ethi->group_indent_width;

	if (x < x1)

		return 0;

	for (col = 0; col < cols; col++) {

		ETableCol *ecol = e_table_header_get_column (ethi->eth, col);

		x1 += (ecol->width / 2);

		if (x <= x1)

			return col;

		x1 += (ecol->width + 1) / 2;

	}

	return col;

}

static void

ethi_remove_drop_marker (ETableHeaderItem *ethi)

{

	if (ethi->drag_mark == -1)

		return;

	gtk_widget_hide (arrow_up);

	gtk_widget_hide (arrow_down);

	ethi->drag_mark = -1;

}

static GtkWidget *

make_shaped_window_from_xpm (const gchar **xpm)

{

	GdkPixbuf *pixbuf;

	GtkWidget *win, *pix;

	pixbuf = gdk_pixbuf_new_from_xpm_data (xpm);

	win = gtk_window_new (GTK_WINDOW_POPUP);

	gtk_window_set_type_hint (GTK_WINDOW (win), GDK_WINDOW_TYPE_HINT_NOTIFICATION);

	gtk_window_set_resizable (GTK_WINDOW (win), FALSE);

	gtk_widget_set_size_request (win, gdk_pixbuf_get_width (pixbuf), gdk_pixbuf_get_height (pixbuf));

	pix = gtk_image_new_from_pixbuf (pixbuf);

	gtk_widget_realize (win);

	gtk_container_add (GTK_CONTAINER (win), pix);

	g_object_unref (pixbuf);

	return win;

}

static void

ethi_add_drop_marker (ETableHeaderItem *ethi,

                      gint col,

                      gboolean recreate)

{

	GnomeCanvas *canvas;

	GtkAdjustment *adjustment;

	GdkWindow *window;

	GtkWidget *toplevel;

	gint rx, ry;

	gint x;

	if (!recreate && ethi->drag_mark == col)

		return;

	ethi->drag_mark = col;

	x = e_table_header_col_diff (ethi->eth, 0, col);

	if (col > 0)

		x += ethi->group_indent_width;

	if (!arrow_up) {

		arrow_up = make_shaped_window_from_xpm (arrow_up_xpm);

		arrow_down = make_shaped_window_from_xpm (arrow_down_xpm);

	}

	canvas = GNOME_CANVAS_ITEM (ethi)->canvas;

	toplevel = gtk_widget_get_toplevel (GTK_WIDGET (canvas));

	if (GTK_IS_WINDOW (toplevel)) {

		gtk_window_set_transient_for (GTK_WINDOW (arrow_up), GTK_WINDOW (toplevel));

		gtk_window_set_transient_for (GTK_WINDOW (arrow_down), GTK_WINDOW (toplevel));

	}

	window = gtk_widget_get_window (GTK_WIDGET (canvas));

	gdk_window_get_origin (window, &rx, &ry;;

	adjustment = gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (canvas));

	rx -= gtk_adjustment_get_value (adjustment);

	adjustment = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (canvas));

	ry -= gtk_adjustment_get_value (adjustment);

	gtk_window_move (

		GTK_WINDOW (arrow_down),

		rx + x - ARROW_PTR,

		ry - ARROW_DOWN_HEIGHT);

	gtk_widget_show_all (arrow_down);

	gtk_window_move (

		GTK_WINDOW (arrow_up),

		rx + x - ARROW_PTR,

		ry + ethi->height);

	gtk_widget_show_all (arrow_up);

}

static void

ethi_add_destroy_marker (ETableHeaderItem *ethi)

{

	gdouble x1;

	if (ethi->remove_item)

		g_object_run_dispose (G_OBJECT (ethi->remove_item));

	x1 = (gdouble) e_table_header_col_diff (ethi->eth, 0, ethi->drag_col);

	if (ethi->drag_col > 0)

		x1 += ethi->group_indent_width;

	ethi->remove_item = gnome_canvas_item_new (

		GNOME_CANVAS_GROUP (GNOME_CANVAS_ITEM (ethi)->canvas->root),

		gnome_canvas_rect_get_type (),

		"x1", x1 + 1,

		"y1", (gdouble) 1,

		"x2", (gdouble) x1 + e_table_header_col_diff (

			ethi->eth, ethi->drag_col, ethi->drag_col + 1) - 2,

		"y2", (gdouble) ethi->height - 2,

		"fill_color_rgba", 0xFF000080,

		NULL);

}

static void

ethi_remove_destroy_marker (ETableHeaderItem *ethi)

{

	if (!ethi->remove_item)

		return;

	g_object_run_dispose (G_OBJECT (ethi->remove_item));

	ethi->remove_item = NULL;

}

static void

do_drag_motion (ETableHeaderItem *ethi,

                GdkDragContext *context,

                gint x,

                gint y,

                guint time,

                gboolean recreate)

{

	if ((x >= 0) && (x <= (ethi->width)) &&

	    (y >= 0) && (y <= (ethi->height))) {

		GdkDragAction suggested_action;

		gint col;

		d (g_print ("In header\n"));

		col = ethi_find_col_by_x_nearest (ethi, x);

		suggested_action = gdk_drag_context_get_suggested_action (context);

		if (ethi->drag_col != -1 && (col == ethi->drag_col || col == ethi->drag_col + 1)) {

			ethi_remove_destroy_marker (ethi);

			ethi_remove_drop_marker (ethi);

			gdk_drag_status (context, suggested_action, time);

		} else if (col != -1) {

			if (ethi->drag_col != -1)

				ethi_remove_destroy_marker (ethi);

			ethi_add_drop_marker (ethi, col, recreate);

			gdk_drag_status (context, suggested_action, time);

		} else {

			ethi_remove_drop_marker (ethi);

			if (ethi->drag_col != -1)

				ethi_add_destroy_marker (ethi);

		}

	} else {

		ethi_remove_drop_marker (ethi);

		if (ethi->drag_col != -1)

			ethi_add_destroy_marker (ethi);

	}

}

static gboolean

scroll_timeout (gpointer data)

{

	ETableHeaderItem *ethi = data;

	gint dx = 0;

	GtkAdjustment *adjustment;

	GtkScrollable *scrollable;

	gdouble hadjustment_value;

	gdouble vadjustment_value;

	gdouble page_size;

	gdouble lower;

	gdouble upper;

	gdouble value;

	if (ethi->scroll_direction & ET_SCROLL_RIGHT)

		dx += 20;

	if (ethi->scroll_direction & ET_SCROLL_LEFT)

		dx -= 20;

	scrollable = GTK_SCROLLABLE (GNOME_CANVAS_ITEM (ethi)->canvas);

	adjustment = gtk_scrollable_get_hadjustment (scrollable);

	hadjustment_value = gtk_adjustment_get_value (adjustment);

	adjustment = gtk_scrollable_get_vadjustment (scrollable);

	vadjustment_value = gtk_adjustment_get_value (adjustment);

	value = hadjustment_value;

	adjustment = gtk_scrollable_get_hadjustment (scrollable);

	page_size = gtk_adjustment_get_page_size (adjustment);

	lower = gtk_adjustment_get_lower (adjustment);

	upper = gtk_adjustment_get_upper (adjustment);

	gtk_adjustment_set_value (

		adjustment, CLAMP (

		hadjustment_value + dx, lower, upper - page_size));

	hadjustment_value = gtk_adjustment_get_value (adjustment);

	if (hadjustment_value != value)

		do_drag_motion (

			ethi,

			ethi->last_drop_context,

			ethi->last_drop_x + hadjustment_value,

			ethi->last_drop_y + vadjustment_value,

			ethi->last_drop_time,

			TRUE);

	return TRUE;

}

static void

scroll_on (ETableHeaderItem *ethi,

           guint scroll_direction)

{

	if (ethi->scroll_idle_id == 0 || scroll_direction != ethi->scroll_direction) {

		if (ethi->scroll_idle_id != 0)

			g_source_remove (ethi->scroll_idle_id);

		ethi->scroll_direction = scroll_direction;

		ethi->scroll_idle_id = e_named_timeout_add (

			100, scroll_timeout, ethi);

	}

}

static void

scroll_off (ETableHeaderItem *ethi)

{

	if (ethi->scroll_idle_id) {

		g_source_remove (ethi->scroll_idle_id);

		ethi->scroll_idle_id = 0;

	}

}

static void

context_destroyed (gpointer data)

{

	ETableHeaderItem *ethi = data;

	ethi->last_drop_x = 0;

	ethi->last_drop_y = 0;

	ethi->last_drop_time = 0;

	ethi->last_drop_context = NULL;

	scroll_off (ethi);

	g_object_unref (ethi);

}

static void

context_connect (ETableHeaderItem *ethi,

                 GdkDragContext *context)

{

	if (g_dataset_get_data (context, "e-table-header-item") == NULL)

		g_dataset_set_data_full (

			context, "e-table-header-item",

			g_object_ref (ethi), context_destroyed);

}

static gboolean

ethi_drag_motion (GtkWidget *widget,

                  GdkDragContext *context,

                  gint x,

                  gint y,

                  guint time,

                  ETableHeaderItem *ethi)

{

	GtkAllocation allocation;

	GtkAdjustment *adjustment;

	GList *targets, *link;

	gdouble hadjustment_value;

	gdouble vadjustment_value;

	gchar *headertype;

	guint direction = 0;

	gdk_drag_status (context, 0, time);

	headertype = g_strdup_printf ("%s-%s", TARGET_ETABLE_COL_TYPE, ethi->dnd_code);

	targets = gdk_drag_context_list_targets (context);

	for (link = targets; link; link = g_list_next (link)) {

		gchar *droptype;

		droptype = gdk_atom_name (GDK_POINTER_TO_ATOM (link->data));

		if (g_strcmp0 (droptype, headertype) == 0) {

			g_free (droptype);

			break;

		}

		g_free (droptype);

	}

	if (!link) {

		g_free (headertype);

		return FALSE;

	}

	g_free (headertype);

	gtk_widget_get_allocation (widget, &allocation);

	if (x < 20)

		direction |= ET_SCROLL_LEFT;

	if (x > allocation.width - 20)

		direction |= ET_SCROLL_RIGHT;

	ethi->last_drop_x = x;

	ethi->last_drop_y = y;

	ethi->last_drop_time = time;

	ethi->last_drop_context = context;

	context_connect (ethi, context);

	adjustment = gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (widget));

	hadjustment_value = gtk_adjustment_get_value (adjustment);

	adjustment = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (widget));

	vadjustment_value = gtk_adjustment_get_value (adjustment);

	do_drag_motion (

		ethi, context,

		x + hadjustment_value,

		y + vadjustment_value,

		time, FALSE);

	if (direction != 0)

		scroll_on (ethi, direction);

	else

		scroll_off (ethi);

	return TRUE;

}

static void

ethi_drag_end (GtkWidget *canvas,

               GdkDragContext *context,

               ETableHeaderItem *ethi)

{

	ethi_remove_drop_marker (ethi);

	ethi_remove_destroy_marker (ethi);

	ethi->drag_col = -1;

	scroll_off (ethi);

}

static void

ethi_drag_data_received (GtkWidget *canvas,

                         GdkDragContext *drag_context,

                         gint x,

                         gint y,

                         GtkSelectionData *selection_data,

                         guint info,

                         guint time,

                         ETableHeaderItem *ethi)

{

	const guchar *data;

	gint found = FALSE;

	gint count;

	gint column;

	gint drop_col;

	gint i;

	data = gtk_selection_data_get_data (selection_data);

	if (data != NULL) {

		count = e_table_header_count (ethi->eth);

		column = atoi ((gchar *) data);

		drop_col = ethi->drop_col;

		ethi->drop_col = -1;

		if (column >= 0) {

			for (i = 0; i < count; i++) {

				ETableCol *ecol = e_table_header_get_column (ethi->eth, i);

				if (ecol->spec->model_col == column) {

					e_table_header_move (ethi->eth, i, drop_col);

					found = TRUE;

					break;

				}

			}

			if (!found) {

				count = e_table_header_count (ethi->full_header);

				for (i = 0; i < count; i++) {

					ETableCol *ecol;

					ecol = e_table_header_get_column (

						ethi->full_header, i);

					if (ecol->spec->model_col == column) {

						e_table_header_add_column (

							ethi->eth, ecol,

							drop_col);

						break;

					}

				}

			}

		}

	}

	ethi_remove_drop_marker (ethi);

	gnome_canvas_item_request_update (GNOME_CANVAS_ITEM (ethi));

}

static void

ethi_drag_data_get (GtkWidget *canvas,

                    GdkDragContext *context,

                    GtkSelectionData *selection_data,

                    guint info,

                    guint time,

                    ETableHeaderItem *ethi)

{

	if (ethi->drag_col != -1) {

		ETableCol *ecol = e_table_header_get_column (ethi->eth, ethi->drag_col);

		gchar *string = g_strdup_printf ("%d", ecol->spec->model_col);

		gtk_selection_data_set (

			selection_data,

			GDK_SELECTION_TYPE_STRING,

			sizeof (string[0]),

			(guchar *) string,

			strlen (string));

		g_free (string);

	}

}

static gboolean

ethi_drag_drop (GtkWidget *canvas,

                GdkDragContext *context,

                gint x,

                gint y,

                guint time,

                ETableHeaderItem *ethi)

{

	gboolean successful = FALSE;

	if ((x >= 0) && (x <= (ethi->width)) &&

	    (y >= 0) && (y <= (ethi->height))) {