/* vim: set sw=8: -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
 * gui-clipboard.c: Implements the X11 based copy/paste operations
 *
 * Author:
 *  Miguel de Icaza (miguel@gnu.org)
 *  Jody Goldberg (jody@gnome.org)
 */
#include <gnumeric-config.h>
#include "gnumeric.h"
#include "gui-clipboard.h"

#include "gui-util.h"
#include "clipboard.h"
#include "command-context-stderr.h"
#include "selection.h"
#include "application.h"
#include "workbook-control.h"
#include "wbc-gtk.h"
#include "workbook-priv.h"
#include "workbook.h"
#include "workbook-view.h"
#include "ranges.h"
#include "sheet.h"
#include "sheet-style.h"
#include "sheet-object.h"
#include "sheet-control-gui.h"
#include "sheet-view.h"
#include "commands.h"
#include "value.h"
#include "number-match.h"
#include "dialog-stf.h"
#include "stf-parse.h"
#include "mstyle.h"
#include "gnm-format.h"
#include "gnumeric-conf.h"
#include "xml-sax.h"
#include "gutils.h"

#include <goffice/goffice.h>
#include <gsf/gsf-input-memory.h>
#include <gsf/gsf-output-memory.h>
#include <gsf/gsf-utils.h>
#include <glib/gi18n-lib.h>
#include <libxml/globals.h>
#include <locale.h>
#include <string.h>
#include <unistd.h>

#define APP_CLIP_DISP_KEY "clipboard-displays"

static gboolean
debug_clipboard (void)
{
	static gboolean d_clipboard;
	static gboolean inited = FALSE;

	if (!inited) {
		inited = TRUE;
		d_clipboard = gnm_debug_flag ("clipboard");
	}

	return d_clipboard;
}

typedef struct {
	WBCGtk *wbcg;
	GnmPasteTarget        *paste_target;
	GdkAtom            image_atom;
	GdkAtom            string_atom;
} GnmGtkClipboardCtxt;

/* The name of our clipboard atom and the 'magic' info number */
#define GNUMERIC_ATOM_NAME "application/x-gnumeric"
#define GNUMERIC_ATOM_INFO 2001
#define GOFFICE_GRAPH_ATOM_NAME "application/x-goffice-graph"

/*
 * Emacs hack:
 * (x-get-selection-internal 'CLIPBOARD 'TARGETS)
 */

/* From MS Excel */
#define BIFF8_ATOM_NAME	"Biff8"
#define BIFF8_ATOM_NAME_CITRIX "_CITRIX_Biff8"
#define BIFF5_ATOM_NAME	"Biff5"
#define BIFF4_ATOM_NAME	"Biff4"
#define BIFF3_ATOM_NAME	"Biff3"
#define BIFF_ATOM_NAME	"Biff"

#define HTML_ATOM_NAME_UNIX "text/html"
#define HTML_ATOM_NAME_WINDOWS "HTML Format"
#ifdef G_OS_WIN32
#define HTML_ATOM_NAME HTML_ATOM_NAME_WINDOWS
#else
#define HTML_ATOM_NAME HTML_ATOM_NAME_UNIX
#endif

#define OOO_ATOM_NAME "application/x-openoffice;windows_formatname=\"Star Embed Source (XML)\""
#define OOO11_ATOM_NAME "application/x-openoffice-embed-source-xml;windows_formatname=\"Star Embed Source (XML)\""
#define OOO_ATOM_NAME_WINDOWS "Star Embed Source (XML)"

#define UTF8_ATOM_NAME "UTF8_STRING"
#define CTEXT_ATOM_NAME "COMPOUND_TEXT"
#define STRING_ATOM_NAME "STRING"

	/* See if this is a "single line + line end", a "multiline" or a "tab separated"
	 * string. If this is _not_ the case we won't invoke the STF, it is
	 * unlikely that the user will actually need it in this case. */
static gboolean
text_is_single_cell (gchar const *data, int data_len)
{
	int i;

	for (i = 0; i < data_len; i++)
		if (data[i] == '\n' || data[i] == '\t')
			return FALSE;
	return TRUE;
}


static GnmCellRegion *
text_to_cell_region (WBCGtk *wbcg,
		     gchar const *data, int data_len,
		     char const *opt_encoding,
		     gboolean fixed_encoding)
{
	Workbook *wb = wb_control_get_workbook (GNM_WBC (wbcg));
	DialogStfResult_t *dialogresult;
	GnmCellRegion *cr = NULL;
	gboolean oneline;
	char *data_converted = NULL;

	if (!data) {
		/*
		 * See Redhat #1160975.
		 *
		 * I'm unsure why someone get NULL here, but this is better
		 * than a crash.
		 */
		data = "";
		data_len = 0;
	}

	oneline = text_is_single_cell (data, data_len);

	if (oneline && (opt_encoding == NULL || strcmp (opt_encoding, "UTF-8") != 0)) {
		size_t bytes_written;
		char const *enc = opt_encoding ? opt_encoding : "ASCII";

		data_converted = g_convert (data, data_len,
					    "UTF-8", enc,
					    NULL, &bytes_written, NULL);
		if (data_converted) {
			data = data_converted;
			data_len = bytes_written;
		} else {
			/* Force STF import since we don't know the charset.  */
			oneline = FALSE;
			fixed_encoding = FALSE;
		}
	}

	if (oneline) {
		GODateConventions const *date_conv = workbook_date_conv (wb);
		GnmCellCopy *cc = gnm_cell_copy_new (
			(cr = gnm_cell_region_new (NULL)), 0, 0);
		char *tmp = g_strndup (data, data_len);

		g_free (data_converted);

		cc->val = format_match (tmp, NULL, date_conv);
		if (cc->val)
			g_free (tmp);
		else
			cc->val = value_new_string_nocopy (tmp);
		cc->texpr = NULL;

		cr->cols = cr->rows = 1;
	} else {
		dialogresult = stf_dialog (wbcg, opt_encoding, fixed_encoding,
					   NULL, FALSE,
					   _("clipboard"), data, data_len);

		if (dialogresult != NULL) {
			cr = stf_parse_region (dialogresult->parseoptions,
					       dialogresult->text, NULL, wb);
			g_return_val_if_fail (cr != NULL, gnm_cell_region_new (NULL));

			stf_dialog_result_attach_formats_to_cr (dialogresult, cr);

			stf_dialog_result_free (dialogresult);
		} else
			cr = gnm_cell_region_new (NULL);
	}

	return cr;
}

static void
text_content_received (GtkClipboard *clipboard,  GtkSelectionData *sel,
		       gpointer closure)
{
	GnmGtkClipboardCtxt *ctxt = closure;
	WBCGtk *wbcg = ctxt->wbcg;
	WorkbookControl	   *wbc  = GNM_WBC (wbcg);
	GnmPasteTarget	   *pt   = ctxt->paste_target;
	GnmCellRegion *content = NULL;
	GdkAtom target = gtk_selection_data_get_target (sel);

	if (debug_clipboard ()) {
		int maxlen = 1024;
		char *name = gdk_atom_name (gtk_selection_data_get_target (sel));
		g_printerr ("Received %d bytes of text for target %s\n",
			    gtk_selection_data_get_length (sel),
			    name);
		g_free (name);
		if (gtk_selection_data_get_length (sel) > 0) {
			gsf_mem_dump (gtk_selection_data_get_data (sel), MIN (gtk_selection_data_get_length (sel), maxlen));
			if (gtk_selection_data_get_length (sel) > maxlen)
				g_printerr ("...\n");
		}
	}

	/* Nothing on clipboard? */
	if (gtk_selection_data_get_length (sel) < 0) {
		;
	} else if (target == gdk_atom_intern (UTF8_ATOM_NAME, FALSE)) {
		content = text_to_cell_region (wbcg, (const char *)gtk_selection_data_get_data (sel),
					       gtk_selection_data_get_length (sel), "UTF-8", TRUE);
	} else if (target == gdk_atom_intern (CTEXT_ATOM_NAME, FALSE)) {
		/* COMPOUND_TEXT is icky.  Just let GTK+ do the work.  */
		char *data_utf8 = (char *)gtk_selection_data_get_text (sel);
		content = text_to_cell_region (wbcg, data_utf8, strlen (data_utf8), "UTF-8", TRUE);
		g_free (data_utf8);
	} else if (target == gdk_atom_intern (STRING_ATOM_NAME, FALSE)) {
		char const *locale_encoding;
		g_get_charset (&locale_encoding);

		content = text_to_cell_region (wbcg, (const char *)gtk_selection_data_get_data (sel),
					       gtk_selection_data_get_length (sel), locale_encoding, FALSE);
	}
	if (content) {
		/*
		 * if the conversion from the X selection -> a cellregion
		 * was canceled this may have content sized -1,-1
		 */
		if (content->cols > 0 && content->rows > 0)
			cmd_paste_copy (wbc, pt, content);

		/* Release the resources we used */
		cellregion_unref (content);
	}
	g_free (ctxt->paste_target);
	g_free (ctxt);
}

static void
utf8_content_received (GtkClipboard *clipboard,  const gchar *text,
		       gpointer closure)
{
	GnmGtkClipboardCtxt *ctxt = closure;
	WBCGtk *wbcg = ctxt->wbcg;
	WorkbookControl	   *wbc  = GNM_WBC (wbcg);
	GnmPasteTarget	   *pt   = ctxt->paste_target;
	GnmCellRegion *content = NULL;

	/* Nothing on clipboard? */
	if (!text || strlen(text) == 0) {
		;
	} else {
		content = text_to_cell_region (wbcg, text, strlen(text), "UTF-8", TRUE);
	}
	if (content) {
		/*
		 * if the conversion from the X selection -> a cellregion
		 * was canceled this may have content sized -1,-1
		 */
		if (content->cols > 0 && content->rows > 0)
			cmd_paste_copy (wbc, pt, content);

		/* Release the resources we used */
		cellregion_unref (content);
	}
	g_free (ctxt->paste_target);
	g_free (ctxt);
}

/*
 * Use the file_opener plugin service to read into a temporary workbook, in
 * order to copy from it to the paste target. A temporary sheet would do just
 * as well, but the file_opener service makes workbooks, not sheets.
 *
 * We use the file_opener service by wrapping the selection data in a GsfInput,
 * and calling workbook_view_new_from_input.
 **/
static GnmCellRegion *
table_cellregion_read (WorkbookControl *wbc, char const *reader_id,
		       GnmPasteTarget *pt, const guchar *buffer, int length)
{
	WorkbookView *wb_view = NULL;
	Workbook *wb = NULL;
	GnmCellRegion *ret = NULL;
	const GOFileOpener *reader = go_file_opener_for_id (reader_id);
	GOIOContext *ioc;
	GsfInput *input;

	if (!reader) {
		g_warning ("No file opener for %s", reader_id);
		return NULL;
	}

	ioc = go_io_context_new (GO_CMD_CONTEXT (wbc));
	input = gsf_input_memory_new (buffer, length, FALSE);
	wb_view = workbook_view_new_from_input  (input, NULL, reader, ioc, NULL);
	if (go_io_error_occurred (ioc) || wb_view == NULL) {
		go_io_error_display (ioc);
		goto out;
	}

	wb = wb_view_get_workbook (wb_view);
	if (workbook_sheet_count (wb) > 0) {
		GnmRange r;
		Sheet *tmpsheet = workbook_sheet_by_index (wb, 0);
		GnmRange *rp = g_object_get_data (G_OBJECT (tmpsheet),
						  "DIMENSION");
		if (rp) {
			r = *rp;
		} else {
			r.start.col = 0;
			r.start.row = 0;
			r.end.col = tmpsheet->cols.max_used;
			r.end.row = tmpsheet->rows.max_used;
		}
		ret = clipboard_copy_range (tmpsheet, &r);
	}

	/* This isn't particularly right, but we are going to delete
	   the workbook shortly.  See #490479.  */
	WORKBOOK_FOREACH_SHEET (wb, sheet, {
		cellregion_invalidate_sheet (ret, sheet);
	});

out:
	if (wb_view)
		g_object_unref (wb_view);
	if (wb)
		g_object_unref (wb);
	g_object_unref (ioc);
	g_object_unref (input);

	return ret;
}

static void
image_content_received (GtkClipboard *clipboard, GtkSelectionData *sel,
			  gpointer closure)
{
	GnmGtkClipboardCtxt *ctxt = closure;
	WBCGtk *wbcg = ctxt->wbcg;
	GnmPasteTarget	   *pt   = ctxt->paste_target;

	if (debug_clipboard ()) {
		int maxlen = 1024;
		char *name = gdk_atom_name (gtk_selection_data_get_target (sel));
		g_printerr ("Received %d bytes of image for target %s\n",
			    gtk_selection_data_get_length (sel),
			    name);
		g_free (name);
		if (gtk_selection_data_get_length (sel) > 0) {
			gsf_mem_dump (gtk_selection_data_get_data (sel), MIN (gtk_selection_data_get_length (sel), maxlen));
			if (gtk_selection_data_get_length (sel) > maxlen)
				g_printerr ("...\n");
		}
	}

	if (gtk_selection_data_get_length (sel) > 0) {
		scg_paste_image (wbcg_cur_scg (wbcg), &pt->range,
				 gtk_selection_data_get_data (sel), gtk_selection_data_get_length (sel));
		g_free (ctxt->paste_target);
		g_free (ctxt);
	} else  if (ctxt->string_atom !=  GDK_NONE) {
		gtk_clipboard_request_contents (clipboard, ctxt->string_atom,
						text_content_received, ctxt);
	} else {
		g_free (ctxt->paste_target);
		g_free (ctxt);
	}
}

static void
parse_ms_headers (const char *data, size_t length, size_t *start, size_t *end)
{
	GHashTable *headers = g_hash_table_new_full
		(g_str_hash, g_str_equal, g_free, g_free);
	size_t limit = length;
	size_t i = 0;
	char *key = NULL;
	char *value = NULL;
	long sf, ef;
	const char *v;

	while (i < limit && data[i] != '<') {
		size_t j, k;

		for (j = i; j < limit; j++) {
			if (data[j] == ':') {
				key = g_strndup (data + i, j - i);
				break;
			}
			if (g_ascii_isspace (data[j]))
				goto bad;
		}
		if (j >= limit)
			goto bad;
		j++;

		for (k = j; k < limit; k++) {
			if (data[k] == '\n' || data[k] == '\r') {
				value = g_strndup (data + j, k - j);
				break;
			}
		}
		if (k >= limit)
			goto bad;
		while (g_ascii_isspace (data[k]))
			k++;

		i = k;

		if (debug_clipboard ())
			g_printerr ("MS HTML Header [%s] => [%s]\n", key, value);

		if (strcmp (key, "StartHTML") == 0) {
			long l = strtol (value, NULL, 10);
			limit = MIN (limit, (size_t)MAX (0, l));
		}

		g_hash_table_replace (headers, key, value);
		key = value = NULL;
	}

	v = g_hash_table_lookup (headers, "StartFragment");
	sf = v ? strtol (v, NULL, 10) : -1;
	if (sf < (long)limit)
		goto bad;

	v = g_hash_table_lookup (headers, "EndFragment");
	ef = v ? strtol (v, NULL, 10) : -1;
	if (ef < sf || ef > (long)length)
		goto bad;

	*start = sf;
	*end = ef;
	goto out;

 bad:
	g_free (key);
	g_free (value);
	*start = 0;
	*end = length;

 out:
	g_hash_table_destroy (headers);
}


static void
table_content_received (GtkClipboard *clipboard, GtkSelectionData *sel,
			gpointer closure)
{
	GnmGtkClipboardCtxt *ctxt = closure;
	WBCGtk *wbcg = ctxt->wbcg;
	WorkbookControl	   *wbc  = GNM_WBC (wbcg);
	GnmPasteTarget	   *pt   = ctxt->paste_target;
	GnmCellRegion *content = NULL;
	GdkAtom target = gtk_selection_data_get_target (sel);

	if (debug_clipboard ()) {
		int maxlen = 1024;
		char *name = gdk_atom_name (gtk_selection_data_get_target (sel));
		g_printerr ("Received %d bytes of table for target %s\n",
			    gtk_selection_data_get_length (sel),
			    name);
		g_free (name);
		if (gtk_selection_data_get_length (sel) > 0) {
			gsf_mem_dump (gtk_selection_data_get_data (sel), MIN (gtk_selection_data_get_length (sel), maxlen));
			if (gtk_selection_data_get_length (sel) > maxlen)
				g_printerr ("...\n");
		}
	}

	/* Nothing on clipboard? */
	if (gtk_selection_data_get_length (sel) < 0) {
		;
	} else if (target == gdk_atom_intern (GNUMERIC_ATOM_NAME, FALSE)) {
		/* The data is the gnumeric specific XML interchange format */
		GOIOContext *io_context =
			go_io_context_new (GO_CMD_CONTEXT (wbcg));
		content = gnm_xml_cellregion_read
			(wbc, io_context,
			 pt->sheet,
			 (const char *)gtk_selection_data_get_data (sel), gtk_selection_data_get_length (sel));
		g_object_unref (io_context);
	} else if (target == gdk_atom_intern (OOO_ATOM_NAME, FALSE) ||
		   target == gdk_atom_intern (OOO_ATOM_NAME_WINDOWS, FALSE) ||
		   target == gdk_atom_intern (OOO11_ATOM_NAME, FALSE)) {
		content = table_cellregion_read (wbc, "Gnumeric_OpenCalc:openoffice",
						 pt, gtk_selection_data_get_data (sel),
						 gtk_selection_data_get_length (sel));
	} else if (target == gdk_atom_intern (HTML_ATOM_NAME_UNIX, FALSE) ||
		   target == gdk_atom_intern (HTML_ATOM_NAME_WINDOWS, FALSE)) {
		size_t length = gtk_selection_data_get_length (sel);
		size_t start = 0, end = length;

		if (target == gdk_atom_intern (HTML_ATOM_NAME_WINDOWS, FALSE)) {
			/* See bug 143084 */
			parse_ms_headers (gtk_selection_data_get_data (sel), length, &start, &end);
		}

		content = table_cellregion_read (wbc, "Gnumeric_html:html",
						 pt,
						 gtk_selection_data_get_data (sel) + start,
						 end - start);
	} else if ((target == gdk_atom_intern ( BIFF8_ATOM_NAME, FALSE)) ||
		   (target == gdk_atom_intern ( BIFF8_ATOM_NAME_CITRIX, FALSE)) ||
		   (target == gdk_atom_intern ( BIFF5_ATOM_NAME, FALSE)) ||
		   (target == gdk_atom_intern ( BIFF4_ATOM_NAME, FALSE)) ||
		   (target == gdk_atom_intern ( BIFF3_ATOM_NAME, FALSE)) ||
		   (target == gdk_atom_intern ( BIFF_ATOM_NAME,  FALSE))) {
		content = table_cellregion_read (wbc, "Gnumeric_Excel:excel",
						 pt, gtk_selection_data_get_data (sel),
						 gtk_selection_data_get_length (sel));
	}
	if (content) {
		/*
		 * if the conversion from the X selection -> a cellregion
		 * was canceled this may have content sized -1,-1
		 */
		if ((content->cols > 0 && content->rows > 0) ||
		    content->objects != NULL)
			cmd_paste_copy (wbc, pt, content);

		/* Release the resources we used */
		cellregion_unref (content);
		g_free (ctxt->paste_target);
		g_free (ctxt);
	} else if (ctxt->image_atom != GDK_NONE) {
		gtk_clipboard_request_contents (clipboard, ctxt->image_atom,
						image_content_received, ctxt);
	} else if (ctxt->string_atom != GDK_NONE) {
		gtk_clipboard_request_contents (clipboard, ctxt->string_atom,
						text_content_received, ctxt);
	} else {
		g_free (ctxt->paste_target);
		g_free (ctxt);
	}
}

/**
 * x_targets_received:
 *
 * Invoked when the selection has been received by our application.
 * This is triggered by a call we do to gtk_clipboard_request_contents.
 *
 * We try to import a spreadsheet/table, next an image, and finally fall back
 * to a string format if the others fail, e.g. for html which does not
 * contain a table.
 */
static void
x_targets_received (GtkClipboard *clipboard, GdkAtom *targets,
		    gint n_targets, gpointer closure)
{
	GnmGtkClipboardCtxt *ctxt = closure;
	GdkAtom table_atom = GDK_NONE;
	gint i, j;

	/* in order of preference */
	static char const *table_fmts [] = {
		GNUMERIC_ATOM_NAME,

		BIFF8_ATOM_NAME,
		BIFF8_ATOM_NAME_CITRIX,
		BIFF5_ATOM_NAME,
		BIFF4_ATOM_NAME,
		BIFF3_ATOM_NAME,
		BIFF_ATOM_NAME,

		OOO_ATOM_NAME,
		OOO11_ATOM_NAME,
		OOO_ATOM_NAME_WINDOWS,

		HTML_ATOM_NAME_UNIX,
		HTML_ATOM_NAME_WINDOWS,
		NULL
	};
	static char const *string_fmts [] = {
		UTF8_ATOM_NAME,
		STRING_ATOM_NAME,
		CTEXT_ATOM_NAME,
		NULL
	};

	/* Nothing on clipboard? */
	if (targets == NULL || n_targets == 0) {
		gtk_clipboard_request_text (clipboard, utf8_content_received,
					    ctxt);
		return;
	}

	if (debug_clipboard ()) {
		int j;

		for (j = 0; j < n_targets; j++)
			g_printerr ("Clipboard target %d is %s\n",
				    j, gdk_atom_name (targets[j]));
	}

	/* The data is a list of atoms */
	/* Find the best table format offered */
	for (i = 0 ; table_fmts[i] && table_atom == GDK_NONE ; i++) {
		/* Look for one we can use */
		GdkAtom atom = gdk_atom_intern (table_fmts[i], FALSE);
		/* is it on offer? */
		for (j = 0; j < n_targets && table_atom == GDK_NONE; j++) {
			if (targets [j] == atom)
				table_atom = atom;
		}
	}

	if (table_atom == GDK_NONE) {
		GtkTargetList *tl = gtk_target_list_new (NULL, 0);
		gboolean found = FALSE;

		gtk_target_list_add_image_targets (tl, 0, FALSE);

		/* Find an image format */
		for (i = 0 ; i < n_targets && !found; i++) {
			if (gtk_target_list_find (tl, targets[i], NULL)) {
				ctxt->image_atom = targets[i];
				found = TRUE;
			}
		}
		gtk_target_list_unref (tl);
	}

	/* Find a string format to fall back to */
	for (i = 0 ; string_fmts[i] && ctxt->string_atom == GDK_NONE ; i++) {
		/* Look for one we can use */
		GdkAtom atom = gdk_atom_intern (string_fmts[i],	FALSE);
		/* is it on offer? */
		for (j = 0; j < n_targets && ctxt->string_atom == GDK_NONE;
		     j++) {
			if (targets [j] == atom)
				ctxt->string_atom = atom;
		}
		if (ctxt->string_atom != GDK_NONE)
			break;
	}

	if (table_atom != GDK_NONE)
		gtk_clipboard_request_contents (clipboard, table_atom,
						table_content_received, ctxt);
	else if (ctxt->image_atom != GDK_NONE)
		gtk_clipboard_request_contents (clipboard, ctxt->image_atom,
						image_content_received, ctxt);
	else if (ctxt->string_atom != GDK_NONE)
		gtk_clipboard_request_contents (clipboard, ctxt->string_atom,
						text_content_received, ctxt);
	else {
		g_free (ctxt->paste_target);
		g_free (ctxt);
	}
}

/* Cheezy implementation: paste into a temporary workbook, save that. */
static guchar *
table_cellregion_write (GOCmdContext *ctx, GnmCellRegion *cr,
			char * saver_id, int *size)
{
	guchar *ret = NULL;
	const GOFileSaver *saver = go_file_saver_for_id (saver_id);
	GsfOutput *output;
	GOIOContext *ioc;
	Workbook *wb;
	WorkbookView *wb_view;
	Sheet *sheet;
	GnmPasteTarget pt;
	GnmRange r;

	*size = 0;
	if (!saver)
		return NULL;

	output = gsf_output_memory_new ();
	ioc = go_io_context_new (ctx);

	{
		int cols = cr->cols;
		int rows = cr->rows;
		gnm_sheet_suggest_size (&cols, &rows);
		wb = workbook_new ();
		workbook_sheet_add (wb, -1, cols, rows);
	}

	wb_view = workbook_view_new (wb);

	sheet = workbook_sheet_by_index (wb, 0);
	memset (&r, 0, sizeof r);
	r.end.col = cr->cols - 1;
	r.end.row = cr->rows - 1;

	paste_target_init (&pt, sheet, &r,
			   PASTE_AS_VALUES | PASTE_FORMATS |
			   PASTE_COMMENTS | PASTE_OBJECTS);
	if (clipboard_paste_region (cr, &pt, ctx) == FALSE) {
		go_file_saver_save (saver, ioc, GO_VIEW (wb_view), output);
		if (!go_io_error_occurred (ioc)) {
			GsfOutputMemory *omem = GSF_OUTPUT_MEMORY (output);
			gsf_off_t osize = gsf_output_size (output);

			*size = osize;
			if (*size == osize) {
				ret = g_malloc (*size);
				memcpy (ret,
					gsf_output_memory_get_bytes (omem),
					*size);
			} else {
				g_warning ("Overflow");	/* Far fetched! */
			}
		}
	}
	gsf_output_close (output);
	g_object_unref (wb_view);
	g_object_unref (wb);
	g_object_unref (ioc);
	g_object_unref (output);

	return ret;
}

static guchar *
image_write (GnmCellRegion *cr, gchar const *mime_type, int *size)
{
	guchar *ret = NULL;
	SheetObject *so = NULL;
	char *format;
	GsfOutput *output;
	GsfOutputMemory *omem;
	gsf_off_t osize;
	GSList *l;

	*size = -1;

	g_return_val_if_fail (cr->objects != NULL, NULL);
	so = GNM_SO (cr->objects->data);
	g_return_val_if_fail (so != NULL, NULL);

	if (strncmp (mime_type, "image/", 6) != 0)
		return ret;
	for (l = cr->objects; l != NULL; l = l->next) {
		if (GNM_IS_SO_IMAGEABLE (GNM_SO (l->data))) {
			so = GNM_SO (l->data);
			break;
		}
	}
	if (so == NULL) {
		g_warning ("non imageable object requested as image\n");
		return ret;
	}

	format = go_mime_to_image_format (mime_type);
	if (!format) {
		g_warning ("No image format for %s\n", mime_type);
		g_free (format);
		return ret;
	}
	output = gsf_output_memory_new ();
	omem   = GSF_OUTPUT_MEMORY (output);
	sheet_object_write_image (so, format, 150.0, output, NULL);
	osize = gsf_output_size (output);

	*size = osize;
	if (*size == osize) {
		ret = g_malloc (*size);
		memcpy (ret, gsf_output_memory_get_bytes (omem), *size);
	} else {
		g_warning ("Overflow");	/* Far fetched! */
	}
	gsf_output_close (output);
	g_object_unref (output);
	g_free (format);

	return ret;
}

static guchar *
object_write (GnmCellRegion *cr, gchar const *mime_type, int *size)
{
	guchar *ret = NULL;
	SheetObject *so = NULL;
	GsfOutput *output;
	GsfOutputMemory *omem;
	gsf_off_t osize;
	GSList *l;

	*size = -1;

	g_return_val_if_fail (cr->objects != NULL, NULL);
	so = GNM_SO (cr->objects->data);
	g_return_val_if_fail (so != NULL, NULL);

	for (l = cr->objects; l != NULL; l = l->next) {
		if (GNM_IS_SO_EXPORTABLE (GNM_SO (l->data))) {
			so = GNM_SO (l->data);
			break;
		}
	}
	if (so == NULL) {
		g_warning ("non exportable object requested\n");
		return ret;
	}
	output = gsf_output_memory_new ();
	omem   = GSF_OUTPUT_MEMORY (output);
	sheet_object_write_object (so, mime_type, output, NULL,
				   gnm_conventions_default);
	osize = gsf_output_size (output);

	*size = osize;
	if (*size == osize)
		ret = g_memdup (gsf_output_memory_get_bytes (omem), *size);
	else
		g_warning ("Overflow");	/* Far fetched! */
	gsf_output_close (output);
	g_object_unref (output);

	return ret;
}

/*
 * x_clipboard_get_cb
 *
 * Callback invoked when another application requests we render the selection.
 */
static void
x_clipboard_get_cb (GtkClipboard *gclipboard, GtkSelectionData *selection_data,
		    guint info, GObject *app)
{
	gboolean to_gnumeric = FALSE, content_needs_free = FALSE;
	GnmCellRegion *clipboard = gnm_app_clipboard_contents_get ();
	Sheet *sheet = gnm_app_clipboard_sheet_get ();
	GnmRange const *a = gnm_app_clipboard_area_get ();
	GOCmdContext *ctx = gnm_cmd_context_stderr_new ();
	GdkAtom target = gtk_selection_data_get_target (selection_data);
	gchar *target_name = gdk_atom_name (target);

	if (debug_clipboard ())
		g_printerr ("clipboard target=%s\n", target_name);

	/*
	 * There are 4 cases. What variables are valid depends on case:
	 * source is
	 *   a cut: clipboard NULL, sheet, area non NULL.
         *   a copy: clipboard, sheet, area all non NULL.
	 *   a cut, source closed: clipboard, sheet, area all NULL.
	 *   a copy, source closed: clipboard non NULL, sheet, area non NULL.
	 *
	 * If the source is a cut, we copy it for pasting.  We
	 * postpone clearing it until after the selection has been
	 * rendered to the requested format.
	 */
	if (clipboard == NULL && sheet != NULL) {
		content_needs_free = TRUE;
		clipboard = clipboard_copy_range (sheet, a);
	}

	if (clipboard == NULL)
		goto out;

	/* What format does the other application want? */
	if (target == gdk_atom_intern (GNUMERIC_ATOM_NAME, FALSE)) {
		GsfOutputMemory *output  = gnm_cellregion_to_xml (clipboard);
		if (output) {
			gsf_off_t size = gsf_output_size (GSF_OUTPUT (output));
			if (debug_clipboard ())
				g_printerr ("clipboard .gnumeric of %d bytes\n",
					   (int)size);
			gtk_selection_data_set
				(selection_data, target, 8,
				 gsf_output_memory_get_bytes (output),
				 size);
			g_object_unref (output);
			to_gnumeric = TRUE;
		}
	} else if (target == gdk_atom_intern (HTML_ATOM_NAME, FALSE)) {
		char *saver_id = (char *) "Gnumeric_html:xhtml_range";
		int buffer_size;
		guchar *buffer = table_cellregion_write (ctx, clipboard,
							 saver_id,
							 &buffer_size);
		if (debug_clipboard ())
			g_message ("clipboard html of %d bytes",
				    buffer_size);
		gtk_selection_data_set (selection_data,
					target, 8,
					(guchar *) buffer, buffer_size);
		g_free (buffer);
	} else if (strcmp (target_name, "application/x-goffice-graph") == 0 ||
	           g_slist_find_custom (go_components_get_mime_types (), target_name, (GCompareFunc) strcmp) != NULL) {
		int buffer_size;
		guchar *buffer = object_write (clipboard, target_name,
					      &buffer_size);
		if (debug_clipboard ())
			g_message ("clipboard graph of %d bytes",
				   buffer_size);
		gtk_selection_data_set (selection_data,
					target, 8,
					(guchar *) buffer, buffer_size);
		g_free (buffer);
	} else if (strncmp (target_name, "image/", 6) == 0) {
		int buffer_size;
		guchar *buffer = image_write (clipboard, target_name,
					      &buffer_size);
		if (debug_clipboard ())
			g_message ("clipboard image of %d bytes",
				    buffer_size);
		gtk_selection_data_set (selection_data,
					target, 8,
					(guchar *) buffer, buffer_size);
		g_free (buffer);
	} else if (strcmp (target_name, "SAVE_TARGETS") == 0) {
		/* We implicitly registered this when calling
		 * gtk_clipboard_set_can_store. We're supposed to
		 * ignore it. */
	} else if (clipboard->origin_sheet) {
		Workbook *wb = clipboard->origin_sheet->workbook;
		GString *res = cellregion_to_string (clipboard,
			TRUE, workbook_date_conv (wb));
		if (res != NULL) {
			if (debug_clipboard ())
				g_message ("clipboard text of %d bytes",
					   (int)res->len);
			gtk_selection_data_set_text (selection_data,
				res->str, res->len);
			g_string_free (res, TRUE);
		} else {
			if (debug_clipboard ())
				g_message ("clipboard empty text");
			gtk_selection_data_set_text (selection_data, "", 0);
		}
	} else
		gtk_selection_data_set_text (selection_data, "", 0);

	/*
	 * If this was a CUT operation we need to clear the content that
	 * was pasted into another application and release the stuff on
	 * the clipboard
	 */
	if (content_needs_free) {

		/* If the other app was a gnumeric, emulate a cut */
		if (to_gnumeric) {
			GOUndo *redo, *undo;
			GnmSheetRange *sr    = gnm_sheet_range_new (sheet, a);
			SheetView const *sv  = gnm_app_clipboard_sheet_view_get ();
			SheetControl *sc     = g_ptr_array_index (sv->controls, 0);
			WorkbookControl *wbc = sc_wbc (sc);
			char *name;
			char *text;

			redo = sheet_clear_region_undo
				(sr,
				 CLEAR_VALUES|CLEAR_COMMENTS|CLEAR_RECALC_DEPS);
			undo = clipboard_copy_range_undo (sheet, a);
			name = undo_range_name (sheet, a);
			text = g_strdup_printf (_("Cut of %s"), name);
			g_free (name);
			cmd_generic (wbc, text, undo, redo);
			g_free (text);
			gnm_app_clipboard_clear (TRUE);
		}

		cellregion_unref (clipboard);
	}
 out:
	g_free (target_name);
	g_object_unref (ctx);
}

/**
 * x_clipboard_clear_cb:
 *
 * Callback for the "we lost the X selection" signal.
 */
static gint
x_clipboard_clear_cb (GtkClipboard *clipboard,
		      GObject *obj)
{
	if (debug_clipboard ())
		g_printerr ("Lost clipboard ownership.\n");

	gnm_app_clipboard_clear (FALSE);

	return TRUE;
}

void
gnm_x_request_clipboard (WBCGtk *wbcg, GnmPasteTarget const *pt)
{
	GnmGtkClipboardCtxt *ctxt;
	GdkDisplay *display = gtk_widget_get_display (GTK_WIDGET (wbcg_toplevel (wbcg)));
	GtkClipboard *clipboard =
		gtk_clipboard_get_for_display
		(display,
		 gnm_conf_get_cut_and_paste_prefer_clipboard ()
		 ? GDK_SELECTION_CLIPBOARD
		 : GDK_SELECTION_PRIMARY);

	ctxt = g_new (GnmGtkClipboardCtxt, 1);
	ctxt->wbcg = wbcg;
	ctxt->paste_target = g_new (GnmPasteTarget, 1);
	*ctxt->paste_target = *pt;
	ctxt->image_atom = GDK_NONE;
	ctxt->string_atom = GDK_NONE;

	/* Query the formats, This will callback x_targets_received */
	gtk_clipboard_request_targets (clipboard,
				       x_targets_received, ctxt);
}

/* Restrict the	set of formats offered to clipboard manager. */
/* We include bmp in the whitelist because that's the only image format
 * we share with OOo over clipboard (!) */
static void
set_clipman_targets (GdkDisplay *disp, GtkTargetEntry *targets, guint n_targets)
{
	static GtkTargetEntry clipman_whitelist[] = {
		{ (char *) GNUMERIC_ATOM_NAME, 0, GNUMERIC_ATOM_INFO },
		{ (char *) HTML_ATOM_NAME, 0, 0 },
		{ (char *)"UTF8_STRING", 0, 0 },
		{ (char *)"application/x-goffice-graph", 0, 0 },
		{ (char *)"image/svg+xml", 0, 0 },
		{ (char *)"image/x-wmf", 0, 0 },
		{ (char *)"image/x-emf", 0, 0 },
		{ (char *)"image/png", 0, 0 },
		{ (char *)"image/jpeg", 0, 0 },
		{ (char *)"image/bmp", 0, 0 },
	};
	guint n_whitelist = G_N_ELEMENTS (clipman_whitelist);
	int n_allowed;
	GtkTargetList *tl = gtk_target_list_new (NULL, 0);
	GtkTargetEntry *t, *wt, *t_allowed;

	for (t = targets; t < targets + n_targets; t++) {
		for (wt = clipman_whitelist;
		     wt < clipman_whitelist + n_whitelist; wt++) {
			if (strcmp(t->target, wt->target) == 0) {
				gtk_target_list_add
					(tl, gdk_atom_intern (t->target, FALSE),
					 t->flags, t->info);
				break;
			}
		}
	}

	t_allowed = gtk_target_table_new_from_list (tl, &n_allowed);
	gtk_target_list_unref (tl);

	gtk_clipboard_set_can_store (
			gtk_clipboard_get_for_display (
				disp, GDK_SELECTION_CLIPBOARD),
				t_allowed, n_allowed);
	gtk_target_table_free (t_allowed, n_allowed);
	t_allowed = NULL;
}

gboolean
gnm_x_claim_clipboard (GdkDisplay *display)
{
	GnmCellRegion *content = gnm_app_clipboard_contents_get ();
	SheetObject *imageable = NULL, *exportable = NULL;
	GtkTargetEntry *targets = NULL;
	int n_targets;
	gboolean ret;
	GObject *app = gnm_app_get_app ();

	static GtkTargetEntry const table_targets[] = {
		{ (char *) GNUMERIC_ATOM_NAME, 0, GNUMERIC_ATOM_INFO },
		{ (char *) HTML_ATOM_NAME, 0, 0 },
		{ (char *)"UTF8_STRING", 0, 0 },
		{ (char *)"COMPOUND_TEXT", 0, 0 },
		{ (char *)"STRING", 0, 0 },
	};

	targets = (GtkTargetEntry *) table_targets;
	n_targets = G_N_ELEMENTS (table_targets);
	if (content &&
	    (content->cols <= 0 || content->rows <= 0)) {
		GSList *ptr;
		for (ptr = content->objects; ptr != NULL;
		     ptr = ptr->next) {
			SheetObject *candidate = GNM_SO (ptr->data);
			if (exportable == NULL && GNM_IS_SO_EXPORTABLE (candidate))
				exportable = candidate;
			if (imageable == NULL && GNM_IS_SO_IMAGEABLE (candidate))
				imageable = candidate;
		}
		/* Currently, we can't render sheet objects as text or html */
		n_targets = 1;
	}
	if (exportable) {
		GtkTargetList *tl =
			sheet_object_exportable_get_target_list (exportable);
		/* _add_table prepends to target_list */
		gtk_target_list_add_table (tl, table_targets, 1);
		targets = gtk_target_table_new_from_list (tl, &n_targets);
		gtk_target_list_unref (tl);
	}
	if (imageable) {
		GtkTargetList *tl =
			sheet_object_get_target_list (imageable);
		/* _add_table prepends to target_list */
		gtk_target_list_add_table (tl, targets, (exportable)? n_targets: 1);
		targets = gtk_target_table_new_from_list (tl, &n_targets);
		gtk_target_list_unref (tl);
	}
	/* Register a x_clipboard_clear_cb only for CLIPBOARD, not for
	 * PRIMARY */
	ret = gtk_clipboard_set_with_owner (
		gtk_clipboard_get_for_display (display, GDK_SELECTION_CLIPBOARD),
		targets, n_targets,
		(GtkClipboardGetFunc) x_clipboard_get_cb,
		(GtkClipboardClearFunc) x_clipboard_clear_cb,
		app);
	if (ret) {
		if (debug_clipboard ())
			g_printerr ("Clipboard successfully claimed.\n");

		g_object_set_data_full (app, APP_CLIP_DISP_KEY,
					g_slist_prepend (g_object_steal_data (app, APP_CLIP_DISP_KEY),
							 display),
					(GDestroyNotify)g_slist_free);


		set_clipman_targets (display, targets, n_targets);
		(void)gtk_clipboard_set_with_owner (
			gtk_clipboard_get_for_display (display,
						       GDK_SELECTION_PRIMARY),
			targets, n_targets,
			(GtkClipboardGetFunc) x_clipboard_get_cb,
			NULL,
			app);
	} else {
		if (debug_clipboard ())
			g_printerr ("Failed to claim clipboard.\n");
	}
	if (exportable || imageable)
		gtk_target_table_free (targets, n_targets);

	return ret;
}

void
gnm_x_disown_clipboard (void)
{
	GObject *app = gnm_app_get_app ();
	GSList *displays = g_object_steal_data (app, APP_CLIP_DISP_KEY);
	GSList *l;

	for (l = displays; l; l = l->next) {
		GdkDisplay *display = l->data;
		gtk_selection_owner_set_for_display (display, NULL,
						     GDK_SELECTION_PRIMARY,
						     GDK_CURRENT_TIME);
		gtk_selection_owner_set_for_display (display, NULL,
						     GDK_SELECTION_CLIPBOARD,
						     GDK_CURRENT_TIME);
	}
	g_slist_free (displays);
}

/* Hand clipboard off to clipboard manager. To be called before workbook
 * object is destroyed.
 */
void
gnm_x_store_clipboard_if_needed (Workbook *wb)
{
	Sheet *sheet = gnm_app_clipboard_sheet_get ();
	WBCGtk *wbcg = NULL;

	g_return_if_fail (GNM_IS_WORKBOOK (wb));

	if (sheet && sheet->workbook == wb) {
		WORKBOOK_FOREACH_CONTROL (wb, view, control, {
			if (GNM_IS_WBC_GTK (control)) {
				wbcg = WBC_GTK (control);
			}
		});

		if (wbcg) {
			GtkClipboard *clip = gtk_clipboard_get_for_display
				(gtk_widget_get_display
				 (GTK_WIDGET (wbcg_toplevel (wbcg))),
				 GDK_SELECTION_CLIPBOARD);
			if (gtk_clipboard_get_owner (clip) == gnm_app_get_app ()) {
				if (debug_clipboard ())
					g_printerr ("Handing off clipboard\n");
				gtk_clipboard_store (clip);
			}
		}
	}
}

