xemacs-beta: src/select.c comparison

comparison src/select.c @ 442:abe6d1db359e r21-2-36

Import from CVS: tag r21-2-36

author	cvs
date	Mon, 13 Aug 2007 11:35:02 +0200
parents	8de8e3f6228a
children	576fb035e263

comparison

equal deleted inserted replaced

-:72a7cfa4a488
+:abe6d1db359e
 #include <config.h>
 #include "lisp.h"
 #include "buffer.h"
 #include "device.h"
+#include "extents.h"
 #include "console.h"
 #include "objects.h"
 #include "frame.h"
 #include "opaque.h"
 #include "select.h"
+/* X Atoms */
 Lisp_Object QPRIMARY, QSECONDARY, QSTRING, QINTEGER, QCLIPBOARD, QTIMESTAMP,
 QTEXT, QDELETE, QMULTIPLE, QINCR, QEMACS_TMP, QTARGETS, QATOM, QNULL,
 QATOM_PAIR, QCOMPOUND_TEXT;
+/* Windows clipboard formats */
+Lisp_Object QCF_TEXT, QCF_BITMAP, QCF_METAFILEPICT, QCF_SYLK, QCF_DIF,
+QCF_TIFF, QCF_OEMTEXT, QCF_DIB, QCF_DIBV5, QCF_PALETTE, QCF_PENDATA,
+QCF_RIFF, QCF_WAVE, QCF_UNICODETEXT, QCF_ENHMETAFILE, QCF_HDROP, QCF_LOCALE,
+QCF_OWNERDISPLAY, QCF_DSPTEXT, QCF_DSPBITMAP, QCF_DSPMETAFILEPICT,
+QCF_DSPENHMETAFILE;
+/* Selection strategy symbols */
+Lisp_Object Qreplace_all, Qreplace_existing;
 /* "Selection owner couldn't convert selection" */
 Lisp_Object Qselection_conversion_error;
-/* This is an alist whose CARs are selection-types (whose names are the same
+/* A couple of Lisp functions */
-as the names of X Atoms) and whose CDRs are the names of Lisp functions to
+Lisp_Object Qselect_convert_in, Qselect_convert_out, Qselect_coerce;
-call to convert the given Emacs selection value to a string representing
-the given selection type.  This is for elisp-level extension of the emacs
+/* These are alists whose CARs are selection-types (whose names are the same
-selection handling.
+as the names of X Atoms or Windows clipboard formats) and whose CDRs are
+the names of Lisp functions to call to convert the given Emacs selection
+value to a string representing the given selection type.  This is for
+elisp-level extension of the emacs selection handling.
 */
-Lisp_Object Vselection_converter_alist;
+Lisp_Object Vselection_converter_out_alist;
+Lisp_Object Vselection_converter_in_alist;
+Lisp_Object Vselection_coercion_alist;
+Lisp_Object Vselection_appender_alist;
+Lisp_Object Vselection_buffer_killed_alist;
+Lisp_Object Vselection_coercible_types;
 Lisp_Object Vlost_selection_hooks;
 /* This is an association list whose elements are of the form
 ( selection-name selection-value selection-timestamp )
 selection-name is a lisp symbol, whose name is the name of an X Atom.
-selection-value is the value that emacs owns for that selection.
+selection-value is a list of cons pairs that emacs owns for that selection.
-It may be any kind of Lisp object.
+Each pair consists of (type . value), where type is nil or a
+selection data type, and value is any type of Lisp object.
 selection-timestamp is the time at which emacs began owning this selection,
 as a cons of two 16-bit numbers (making a 32 bit time).
 If there is an entry in this alist, then it can be assumed that emacs owns
 that selection.
 The only (eq) parts of this list that are visible from elisp are the
 selection-values.
 */
 Lisp_Object Vselection_alist;
+/* Given a selection-name and desired type, this looks up our local copy of
+the selection value and converts it to the type. */
 static Lisp_Object
-clean_local_selection_data (Lisp_Object obj)
-{
-if (CONSP (obj) &&
-INTP (XCAR (obj)) &&
-CONSP (XCDR (obj)) &&
-INTP (XCAR (XCDR (obj))) &&
-NILP (XCDR (XCDR (obj))))
-obj = Fcons (XCAR (obj), XCDR (obj));
-if (CONSP (obj) &&
-INTP (XCAR (obj)) &&
-INTP (XCDR (obj)))
-{
-if (XINT (XCAR (obj)) == 0)
-	return XCDR (obj);
-if (XINT (XCAR (obj)) == -1)
-	return make_int (- XINT (XCDR (obj)));
-}
-if (VECTORP (obj))
-{
-int i;
-int len = XVECTOR_LENGTH (obj);
-Lisp_Object copy;
-if (len == 1)
-	return clean_local_selection_data (XVECTOR_DATA (obj) [0]);
-copy = make_vector (len, Qnil);
-for (i = 0; i < len; i++)
-	XVECTOR_DATA (copy) [i] =
-	  clean_local_selection_data (XVECTOR_DATA (obj) [i]);
-return copy;
-}
-return obj;
-}
-/* Given a selection-name and desired type, this looks up our local copy of
-the selection value and converts it to the type.  It returns nil or a
-string.  This calls random elisp code, and may signal or gc.
-*/
-Lisp_Object
 get_local_selection (Lisp_Object selection_symbol, Lisp_Object target_type)
 {
-/* This function can GC */
-Lisp_Object handler_fn, value, check;
 Lisp_Object local_value = assq_no_quit (selection_symbol, Vselection_alist);
-if (NILP (local_value)) return Qnil;
+if (!NILP (local_value))
+{
-/* TIMESTAMP and MULTIPLE are special cases 'cause that's easiest. */
+Lisp_Object value_list = XCAR (XCDR (local_value));
-if (EQ (target_type, QTIMESTAMP))
+Lisp_Object value;
-{
-handler_fn = Qnil;
+/* First try to find an entry of the appropriate type */
-value = XCAR (XCDR (XCDR (local_value)));
+value = assq_no_quit (target_type, value_list);
-}
+if (!NILP (value))
-#if 0 /* #### MULTIPLE doesn't work yet and probably never will */
+	return XCDR (value);
-else if (CONSP (target_type) &&
+}
-	   XCAR (target_type) == QMULTIPLE)
-{
+return Qnil;
-Lisp_Object pairs = XCDR (target_type);
+}
-int len = XVECTOR_LENGTH (pairs);
-int i;
+/* #### Should perhaps handle 'MULTIPLE. The code below is now completely
-/* If the target is MULTIPLE, then target_type looks like
+broken due to a re-organization of get_local_selection, but I've left
-	  (MULTIPLE . [[SELECTION1 TARGET1] [SELECTION2 TARGET2] ... ])
+it here should anyone show an interest - ajh */
-	 We modify the second element of each pair in the vector and
+#if 0
-	 return it as [[SELECTION1 <value1>] [SELECTION2 <value2>] ... ]
+else if (CONSP (target_type) &&
-*/
+	       XCAR (target_type) == QMULTIPLE)
-for (i = 0; i < len; i++)
 	{
-	  Lisp_Object pair = XVECTOR_DATA (pairs) [i];
+	  Lisp_Object pairs = XCDR (target_type);
-	  XVECTOR_DATA (pair) [1] =
+	  int len = XVECTOR_LENGTH (pairs);
-	    x_get_local_selection (XVECTOR_DATA (pair) [0],
+	  int i;
-				   XVECTOR_DATA (pair) [1]);
+	  /* If the target is MULTIPLE, then target_type looks like
+	     (MULTIPLE . [[SELECTION1 TARGET1] [SELECTION2 TARGET2] ... ])
+	     We modify the second element of each pair in the vector and
+	     return it as [[SELECTION1 <value1>] [SELECTION2 <value2>] ... ]
+	  */
+	  for (i = 0; i < len; i++)
+	    {
+	      Lisp_Object pair = XVECTOR_DATA (pairs) [i];
+	      XVECTOR_DATA (pair) [1] =
+		x_get_local_selection (XVECTOR_DATA (pair) [0],
+				       XVECTOR_DATA (pair) [1]);
+	    }
+	  return pairs;
 	}
-return pairs;
-}
 #endif
-else
-{
+DEFUN ("own-selection-internal", Fown_selection_internal, 2, 5, 0, /*
-CHECK_SYMBOL (target_type);
+Assert a selection of the given NAME with the given VALUE, and
-handler_fn = Fcdr (Fassq (target_type, Vselection_converter_alist));
+optional window-system DATA-TYPE. HOW-TO-ADD specifies how the
-if (NILP (handler_fn)) return Qnil;
+selection will be combined with any existing selection(s) - see
-value = call3 (handler_fn,
+`own-selection' for more information.
-		     selection_symbol, target_type,
+NAME is a symbol, typically PRIMARY, SECONDARY, or CLIPBOARD.
-		     XCAR (XCDR (local_value)));
-}
-/* This lets the selection function to return (TYPE . VALUE).  For example,
-when the selected type is LINE_NUMBER, the returned type is SPAN, not
-INTEGER.
-*/
-check = value;
-if (CONSP (value) && SYMBOLP (XCAR (value)))
-check = XCDR (value);
-/* Strings, vectors, and symbols are converted to selection data format in
-the obvious way.  Integers are converted to 16 bit quantities if they're
-small enough, otherwise 32 bits are used.
-*/
-if (STRINGP (check) ||
-VECTORP (check) ||
-SYMBOLP (check) ||
-INTP    (check) ||
-CHARP   (check) ||
-NILP (value))
-return value;
-/* (N . M) or (N M) get turned into a 32 bit quantity.  So if you want to
-always return a small quantity as 32 bits, your converter routine needs
-to return a cons.
-*/
-else if (CONSP (check) &&
-	   INTP (XCAR (check)) &&
-	   (INTP (XCDR (check)) ||
-	    (CONSP (XCDR (check)) &&
-	     INTP (XCAR (XCDR (check))) &&
-	     NILP (XCDR (XCDR (check))))))
-return value;
-/* Otherwise the lisp converter function returned something unrecognized.
-*/
-else
-signal_error (Qerror,
-list3 (build_string
-			 ("unrecognized selection-conversion type"),
-handler_fn,
-value));
-return Qnil;	/* suppress compiler warning */
-}
-DEFUN ("own-selection-internal", Fown_selection_internal, 2, 3, 0, /*
-Assert a selection of the given TYPE with the given VALUE.
-TYPE is a symbol, typically PRIMARY, SECONDARY, or CLIPBOARD.
 VALUE is typically a string, or a cons of two markers, but may be
-anything that the functions on selection-converter-alist know about.
+anything that the functions on selection-converter-out-alist know about.
 */
-(selection_name, selection_value, device))
+(selection_name, selection_value, how_to_add, data_type, device))
 {
-Lisp_Object selection_time, selection_data, prev_value;
+Lisp_Object selection_time, selection_data, prev_value = Qnil,
+value_list = Qnil;
+Lisp_Object prev_real_value = Qnil;
 struct gcpro gcpro1;
 CHECK_SYMBOL (selection_name);
 if (NILP (selection_value)) error ("selection-value may not be nil.");
 if (NILP (device))
 device = Fselected_device (Qnil);
-/* Now update the local cache */
+if (!EQ (how_to_add, Qappend) && !EQ (how_to_add, Qt)
-selection_data = list3 (selection_name,
+&& !EQ (how_to_add, Qreplace_existing)
-			  selection_value,
+&& !EQ (how_to_add, Qreplace_all) && !NILP (how_to_add))
-			  Qnil);
+error ("how-to-add must be nil, append, replace_all, "
-GCPRO1 (selection_data);
+	   "replace_existing or t.");
-prev_value = assq_no_quit (selection_name, Vselection_alist);
+#ifdef MULE
-Vselection_alist = Fcons (selection_data, Vselection_alist);
+if (NILP (data_type))
+data_type = QCOMPOUND_TEXT;
-/* If we already owned the selection, remove the old selection data.
+#else
-Perhaps we should destructively modify it instead.
+if (NILP (data_type))
-Don't use Fdelq() as that may QUIT;.
+data_type = QSTRING;
-*/
+#endif
-if (!NILP (prev_value))
-{
+/* Examine the how-to-add argument */
-Lisp_Object rest;	/* we know it's not the CAR, so it's easy. */
+if (EQ (how_to_add, Qreplace_all) || NILP (how_to_add))
-for (rest = Vselection_alist; !NILP (rest); rest = Fcdr (rest))
+{
-	if (EQ (prev_value, Fcar (XCDR (rest))))
+Lisp_Object local_selection_data = assq_no_quit (selection_name,
+						       Vselection_alist);
+if (!NILP (local_selection_data))
+	{
+	  /* Don't use Fdelq() as that may QUIT;. */
+	  if (EQ (local_selection_data, Fcar (Vselection_alist)))
+	    Vselection_alist = Fcdr (Vselection_alist);
+	  else
+	    {
+	      Lisp_Object rest;
+	      for (rest = Vselection_alist; !NILP (rest); rest = Fcdr (rest))
+		if (EQ (local_selection_data, Fcar (XCDR (rest))))
+		  {
+		    XCDR (rest) = Fcdr (XCDR (rest));
+		    break;
+		  }
+	    }
+	}
+}
+else
+{
+/* Look for a previous value */
+prev_value = assq_no_quit (selection_name, Vselection_alist);
+if (!NILP (prev_value))
+	value_list = XCAR (XCDR (prev_value));
+if (!NILP (value_list))
+	prev_real_value = assq_no_quit (data_type, value_list);
+}
+/* Append values if necessary */
+if (!NILP (value_list) && (EQ (how_to_add, Qappend) || EQ (how_to_add, Qt)))
+{
+/* Did we have anything of this type previously? */
+if (!NILP (prev_real_value))
+	{
+	  if ((NILP (data_type) && STRINGP (selection_value)
+	       && STRINGP (XCDR (prev_real_value)))
+	      || !NILP (data_type))
+	    {
+	      Lisp_Object function = assq_no_quit (data_type,
+						   Vselection_appender_alist);
+	      if (NILP (function))
+		error ("cannot append selections of supplied types.");
+	      function = XCDR (function);
+	      selection_value = call4 (function,
+				       selection_name,
+				       data_type,
+				       XCDR (prev_real_value),
+				       selection_value);
+	      if (NILP (selection_value))
+		error ("cannot append selections of supplied types.");
+	    }
+	  else
+	    error ("cannot append selections of supplied types.");
+	}
+selection_data = Fcons (data_type, selection_value);
+value_list = Fcons (selection_data, value_list);
+}
+if (!NILP (prev_real_value))
+{
+Lisp_Object rest; /* We know it isn't the CAR, so it's easy. */
+/* Delete the old type entry from the list */
+for (rest = value_list; !NILP (rest); rest = Fcdr (rest))
+	if (EQ (prev_real_value, Fcar (XCDR (rest))))
 	  {
 	    XCDR (rest) = Fcdr (XCDR (rest));
 	    break;
 	  }
 }
+else
-/* have to do device specific stuff last so that methods can access the
+{
+value_list = Fcons (Fcons (data_type, selection_value),
+			  value_list);
+}
+/* Complete the local cache update; note that we destructively
+modify the current list entry if there is one */
+if (NILP (prev_value))
+{
+selection_data = list3 (selection_name, value_list, Qnil);
+Vselection_alist = Fcons (selection_data, Vselection_alist);
+}
+else
+{
+selection_data = prev_value;
+Fsetcar (XCDR (selection_data), value_list);
+}
+GCPRO1 (selection_data);
+/* have to do device specific stuff last so that methods can access the
 selection_alist */
 if (HAS_DEVMETH_P (XDEVICE (device), own_selection))
 selection_time = DEVMETH (XDEVICE (device), own_selection,
-			      (selection_name, selection_value));
+			      (selection_name, selection_value,
+			       how_to_add, data_type));
 else
 selection_time = Qnil;
 Fsetcar (XCDR (XCDR (selection_data)), selection_time);
 UNGCPRO;
 return selection_value;
+}
+DEFUN ("register-selection-data-type", Fregister_selection_data_type, 1,2,0, /*
+Register a new selection data type DATA-TYPE, optionally on the specified
+DEVICE. Returns the device-specific data type identifier, or nil if the
+device does not support this feature or the registration fails. */
+(data_type, device))
+{
+/* Check arguments */
+CHECK_STRING (data_type);
+if (NILP (device))
+device = Fselected_device (Qnil);
+if (HAS_DEVMETH_P (XDEVICE (device), register_selection_data_type))
+return DEVMETH (XDEVICE (device), register_selection_data_type,
+		    (data_type));
+else
+return Qnil;
+}
+DEFUN ("selection-data-type-name", Fselection_data_type_name, 1, 2, 0, /*
+Retrieve the name of the specified selection data type DATA-TYPE, optionally
+on the specified DEVICE. Returns either a string or a symbol on success, and
+nil if the device does not support this feature or the type is not known. */
+(data_type, device))
+{
+if (NILP (device))
+device = Fselected_device (Qnil);
+if (HAS_DEVMETH_P (XDEVICE (device), selection_data_type_name))
+return DEVMETH (XDEVICE (device), selection_data_type_name, (data_type));
+else
+return Qnil;
+}
+DEFUN ("available-selection-types", Favailable_selection_types, 1, 2, 0, /*
+Retrieve a list of currently available types of selection associated with
+the given SELECTION-NAME, optionally on the specified DEVICE. This list
+does not take into account any possible conversions that might take place,
+so it should be taken as a minimal estimate of what is available.
+*/
+(selection_name, device))
+{
+Lisp_Object types = Qnil, rest;
+struct gcpro gcpro1;
+CHECK_SYMBOL (selection_name);
+if (NILP (device))
+device = Fselected_device (Qnil);
+GCPRO1 (types);
+/* First check the device */
+if (HAS_DEVMETH_P (XDEVICE (device), available_selection_types))
+types = DEVMETH (XDEVICE (device), available_selection_types,
+		     (selection_name));
+/* Now look in the list */
+rest = assq_no_quit (selection_name, Vselection_alist);
+if (NILP (rest))
+{
+UNGCPRO;
+return types;
+}
+/* Examine the types and cons them onto the front of the list */
+for (rest = XCAR (XCDR (rest)); !NILP (rest); rest = XCDR (rest))
+{
+Lisp_Object value = XCDR (XCAR (rest));
+Lisp_Object type = XCAR (XCAR (rest));
+types = Fcons (type, types);
+if ((STRINGP (value) || EXTENTP (value))
+	  && (NILP (type) || EQ (type, QSTRING)
+	      || EQ (type, QTEXT) || EQ (type, QCOMPOUND_TEXT)))
+	types = Fcons (QTEXT, Fcons (QCOMPOUND_TEXT, Fcons (QSTRING, types)));
+else if (INTP (value) && NILP (type))
+	types = Fcons (QINTEGER, types);
+else if (SYMBOLP (value) && NILP (type))
+	types = Fcons (QATOM, types);
+}
+UNGCPRO;
+return types;
 }
 /* remove a selection from our local copy
 */
 void
 handle_selection_clear (Lisp_Object selection_symbol)
 {
-Lisp_Object local_selection_data = assq_no_quit (selection_symbol, Vselection_alist);
+Lisp_Object local_selection_data = assq_no_quit (selection_symbol,
+						   Vselection_alist);
 /* Well, we already believe that we don't own it, so that's just fine. */
 if (NILP (local_selection_data)) return;
 /* Otherwise, we're really honest and truly being told to drop it.
 if (NILP (device))
 device = Fselected_device (Qnil);
 MAYBE_DEVMETH (XDEVICE (device), disown_selection,
 		 (selection_name, selection_time));
 handle_selection_clear (selection_name);
 return Qt;
 }
 else if (EQ (selection, Qt))   selection = QSECONDARY;
 return NILP (Fassq (selection, Vselection_alist)) ? Qnil : Qt;
 }
-DEFUN ("selection-exists-p", Fselection_exists_p, 0, 2, 0, /*
+DEFUN ("selection-exists-p", Fselection_exists_p, 0, 3, 0, /*
 Whether there is an owner for the given Selection.
 The arg should be the name of the selection in question, typically one of
 the symbols PRIMARY, SECONDARY, or CLIPBOARD.  (For convenience, the symbol
 nil is the same as PRIMARY, and t is the same as SECONDARY.)
+Optionally the DEVICE and the window-system DATA-TYPE may be specified.
 */
-(selection, device))
+(selection, data_type, device))
 {
 CHECK_SYMBOL (selection);
-if (!NILP (Fselection_owner_p (selection)))
+if (NILP (data_type)
+&& !NILP (Fselection_owner_p (selection)))
 return Qt;
 if (NILP (device))
 device = Fselected_device (Qnil);
 return HAS_DEVMETH_P (XDEVICE (device), selection_exists_p) ?
-DEVMETH (XDEVICE (device), selection_exists_p, (selection))
+DEVMETH (XDEVICE (device), selection_exists_p, (selection, data_type))
 : Qnil;
+}
+/* Get the timestamp of the given selection */
+DEFUN ("get-selection-timestamp", Fget_selection_timestamp, 1, 1, 0, /*
+Return the timestamp associated with the specified SELECTION, if it exists.
+Note that the timestamp is a device-specific object, and may not actually be
+visible from Lisp.
+*/
+(selection))
+{
+Lisp_Object local_value = assq_no_quit (selection, Vselection_alist);
+if (!NILP (local_value))
+return XCAR (XCDR (XCDR (local_value)));
+return Qnil;
 }
 /* Request the selection value from the owner.  If we are the owner,
 simply return our selection value.  If we are not the owner, this
 will block until all of the data has arrived.
 (selection_symbol, target_type, device))
 {
 /* This function can GC */
 Lisp_Object val = Qnil;
 struct gcpro gcpro1, gcpro2;
-GCPRO2 (target_type, val); /* we store newly consed data into these */
+GCPRO2 (target_type, val);
 CHECK_SYMBOL (selection_symbol);
 if (NILP (device))
 device = Fselected_device (Qnil);
+#ifdef MULE
+if (NILP (target_type))
+target_type = QCOMPOUND_TEXT;
+#else
+if (NILP (target_type))
+target_type = QSTRING;
+#endif
 #if 0 /* #### MULTIPLE doesn't work yet and probably never will */
 if (CONSP (target_type) &&
 XCAR (target_type) == QMULTIPLE)
 {
 CHECK_VECTOR (XCDR (target_type));
 /* So we don't destructively modify this... */
 target_type = copy_multiple_data (target_type);
 }
-else
 #endif
-CHECK_SYMBOL (target_type);
+/* Used to check that target_type was a symbol. This is no longer
+necessarily the case, because the type might be registered with
+the device (in which case target_type would be a device-specific
+identifier - probably an integer) - ajh */
 val = get_local_selection (selection_symbol, target_type);
-if (NILP (val) && (HAS_DEVMETH_P (XDEVICE (device), get_foreign_selection)))
+if (!NILP (val))
 {
+/* If we get something from the local cache, we may need to convert
+it slightly - to do this, we call select-coerce */
+val = call3 (Qselect_coerce, selection_symbol, target_type, val);
+}
+else if (HAS_DEVMETH_P (XDEVICE (device), get_foreign_selection))
+{
+/* Nothing in the local cache; try the window system */
 val = DEVMETH (XDEVICE (device), get_foreign_selection,
 		     (selection_symbol, target_type));
 }
-else
-{
+if (NILP (val))
-if (CONSP (val) && SYMBOLP (XCAR (val)))
+{
+/* Still nothing. Try coercion. */
+/* Try looking in selection-coercible-types to see if any of
+	 them are present for this selection. We try them *in order*;
+	 the first for which a conversion succeeds gets returned. */
+EXTERNAL_LIST_LOOP_2 (element, Vselection_coercible_types)
 	{
-	  val = XCDR (val);
+	  val = get_local_selection (selection_symbol, element);
-	  if (CONSP (val) && NILP (XCDR (val)))
-	    val = XCAR (val);
+	  if (NILP (val))
+	    continue;
+	  val = call3 (Qselect_coerce, selection_symbol, target_type, val);
+	  if (!NILP (val))
+	    break;
 	}
-val = clean_local_selection_data (val);
+}
-}
+/* Used to call clean_local_selection here... but that really belonged
+in Lisp (so the equivalent is now built-in to the INTEGER conversion
+function select-convert-from-integer) - ajh */
 UNGCPRO;
 return val;
 }
+/* These are convenient interfaces to the lisp code in select.el;
+this way we can rename them easily rather than having to hunt everywhere.
+Also, this gives us access to get_local_selection so that convert_out
+can retrieve the internal selection value automatically if passed a
+value of Qnil. */
+Lisp_Object
+select_convert_in (Lisp_Object selection,
+		   Lisp_Object type,
+		   Lisp_Object value)
+{
+return call3 (Qselect_convert_in, selection, type, value);
+}
+Lisp_Object
+select_coerce (Lisp_Object selection,
+	       Lisp_Object type,
+	       Lisp_Object value)
+{
+return call3 (Qselect_coerce, selection, type, value);
+}
+Lisp_Object
+select_convert_out (Lisp_Object selection,
+		    Lisp_Object type,
+		    Lisp_Object value)
+{
+if (NILP (value))
+value = get_local_selection (selection, type);
+if (NILP (value))
+{
+/* Try looking in selection-coercible-types to see if any of
+	 them are present for this selection. We try them *in order*;
+	 the first for which a conversion succeeds gets returned. */
+EXTERNAL_LIST_LOOP_2 (element, Vselection_coercible_types)
+	{
+	  Lisp_Object ret;
+	  value = get_local_selection (selection, element);
+	  if (NILP (value))
+	    continue;
+	  ret = call3 (Qselect_convert_out, selection, type, value);
+	  if (!NILP (ret))
+	    return ret;
+	}
+return Qnil;
+}
+return call3 (Qselect_convert_out, selection, type, value);
+}
+/* Gets called from kill-buffer; this lets us dispose of buffer-dependent
+selections (or alternatively make them independent of the buffer) when
+it gets vaped. */
+void
+select_notify_buffer_kill (Lisp_Object buffer)
+{
+Lisp_Object rest;
+struct gcpro gcpro1, gcpro2, gcpro3;
+/* For each element of Vselection_alist */
+for (rest = Vselection_alist;
+!NILP (rest);)
+{
+Lisp_Object selection, values, prev = Qnil;
+selection = XCAR (rest);
+for (values = XCAR (XCDR (selection));
+	   !NILP (values);
+	   values = XCDR (values))
+	{
+	  Lisp_Object value, handler_fn;
+	  /* Extract the (type . value) pair. */
+	  value = XCAR (values);
+	  /* Find the handler function (if any). */
+	  handler_fn = Fcdr (Fassq (XCAR (value),
+				    Vselection_buffer_killed_alist));
+	  if (!NILP (handler_fn))
+	    {
+	      Lisp_Object newval;
+	      /* Protect ourselves, just in case some tomfool calls
+		 own-selection from with the buffer-killed handler, then
+		 causes a GC. Just as a note, *don't do this*. */
+	      GCPRO3 (rest, values, value);
+	      newval = call4 (handler_fn, XCAR (selection), XCAR (value),
+			      XCDR (value), buffer);
+	      UNGCPRO;
+	      /* Set or delete the value (by destructively modifying
+		 the list). */
+	      if (!NILP (newval))
+		{
+		  Fsetcdr (value, newval);
+		  prev = values;
+		}
+	      else
+		{
+		  if (NILP (prev))
+		    Fsetcar (XCDR (selection), XCDR (values));
+		  else
+		    Fsetcdr (prev, XCDR (values));
+		}
+	    }
+	  else
+	    prev = values;
+	}
+/* If we have no values for this selection */
+if (NILP (XCAR (XCDR (selection))))
+	{
+	  /* Move on to the next element *first* */
+	  rest = XCDR (rest);
+	  /* Protect it and disown this selection */
+	  GCPRO1 (rest);
+	  Fdisown_selection_internal (XCAR (selection), Qnil, Qnil);
+	  UNGCPRO;
+	}
+else
+	rest = XCDR (rest);
+}
+}
 void
 syms_of_select (void)
 {
 DEFSUBR (Fown_selection_internal);
 DEFSUBR (Fget_selection_internal);
+DEFSUBR (Fget_selection_timestamp);
 DEFSUBR (Fselection_exists_p);
 DEFSUBR (Fdisown_selection_internal);
 DEFSUBR (Fselection_owner_p);
+DEFSUBR (Favailable_selection_types);
+DEFSUBR (Fregister_selection_data_type);
+DEFSUBR (Fselection_data_type_name);
+/* Lisp Functions */
+defsymbol (&Qselect_convert_in, "select-convert-in");
+defsymbol (&Qselect_convert_out, "select-convert-out");
+defsymbol (&Qselect_coerce, "select-coerce");
+/* X Atoms */
 defsymbol (&QPRIMARY, "PRIMARY");
 defsymbol (&QSECONDARY, "SECONDARY");
 defsymbol (&QSTRING, "STRING");
 defsymbol (&QINTEGER, "INTEGER");
 defsymbol (&QCLIPBOARD, "CLIPBOARD");
 defsymbol (&QATOM, "ATOM");
 defsymbol (&QATOM_PAIR, "ATOM_PAIR");
 defsymbol (&QCOMPOUND_TEXT, "COMPOUND_TEXT");
 defsymbol (&QNULL, "NULL");
-deferror (&Qselection_conversion_error,
+/* Windows formats - these all start with CF_ */
-	    "selection-conversion-error",
+defsymbol (&QCF_TEXT, "CF_TEXT");
-	    "selection-conversion error", Qio_error);
+defsymbol (&QCF_BITMAP, "CF_BITMAP");
+defsymbol (&QCF_METAFILEPICT, "CF_METAFILEPICT");
+defsymbol (&QCF_SYLK, "CF_SYLK");
+defsymbol (&QCF_DIF, "CF_DIF");
+defsymbol (&QCF_TIFF, "CF_TIFF");
+defsymbol (&QCF_OEMTEXT, "CF_OEMTEXT");
+defsymbol (&QCF_DIB, "CF_DIB");
+defsymbol (&QCF_DIBV5, "CF_DIBV5");
+defsymbol (&QCF_PALETTE, "CF_PALETTE");
+defsymbol (&QCF_PENDATA, "CF_PENDATA");
+defsymbol (&QCF_RIFF, "CF_RIFF");
+defsymbol (&QCF_WAVE, "CF_WAVE");
+defsymbol (&QCF_UNICODETEXT, "CF_UNICODETEXT");
+defsymbol (&QCF_ENHMETAFILE, "CF_ENHMETAFILE");
+defsymbol (&QCF_HDROP, "CF_HDROP");
+defsymbol (&QCF_LOCALE, "CF_LOCALE");
+defsymbol (&QCF_OWNERDISPLAY, "CF_OWNERDISPLAY");
+defsymbol (&QCF_DSPTEXT, "CF_DSPTEXT");
+defsymbol (&QCF_DSPBITMAP, "CF_DSPBITMAP");
+defsymbol (&QCF_DSPMETAFILEPICT, "CF_DSPMETAFILEPICT");
+defsymbol (&QCF_DSPENHMETAFILE, "CF_DSPENHMETAFILE");
+/* Selection strategies */
+defsymbol (&Qreplace_all, "replace-all");
+defsymbol (&Qreplace_existing, "replace-existing");
+DEFERROR_STANDARD (Qselection_conversion_error, Qio_error);
 }
 void
 vars_of_select (void)
 {
 Vselection_alist = Qnil;
 staticpro (&Vselection_alist);
-DEFVAR_LISP ("selection-converter-alist", &Vselection_converter_alist /*
+DEFVAR_LISP ("selection-converter-alist", &Vselection_converter_out_alist /*
+An alist associating selection-types (such as STRING and TIMESTAMP) with
+functions.  This is an alias for `selection-converter-out-alist', and should
+be considered obsolete.  Use the new name instead. */ );
+DEFVAR_LISP ("selection-converter-out-alist",
+	       &Vselection_converter_out_alist /*
 An alist associating selection-types (such as STRING and TIMESTAMP) with
 functions.  These functions will be called with three args: the name
 of the selection (typically PRIMARY, SECONDARY, or CLIPBOARD); a
 desired type to which the selection should be converted; and the local
-selection value (whatever had been passed to `own-selection').  For
+selection value (whatever had been passed to `own-selection').
-historical reasons these functions should return the value to send to
-an X server, which should be one of:
+The return type of these functions depends upon the device in question;
+for mswindows, a string should be returned containing data in the requested
+format, or nil to indicate that the conversion could not be done.  Additionally,
+it is permissible to return a cons of the form (DATA-TYPE . STRING) suggesting
+a new data type to use instead.
+For X, the return value should be one of:
 -- nil (the conversion could not be done)
 -- a cons of a symbol and any of the following values; the symbol
 explicitly specifies the type that will be sent.
 -- a string (If the type is not specified, then if Mule support exists,
 If the type is not specified, a type of 'INTEGER
 			 will be sent.)
 -- a vector of integers and/or conses (HIGH . LOW) of integers
 (Will be converted into a list of 16-bit integers.
 If the type is not specified, a type of 'INTEGER
-			 will be sent.)  */ );
+			 will be sent.)
-Vselection_converter_alist = Qnil;
+*/ );
+Vselection_converter_out_alist = Qnil;
+DEFVAR_LISP ("selection-converter-in-alist",
+	       &Vselection_converter_in_alist /*
+An alist associating selection-types (such as STRING and TIMESTAMP) with
+functions.  These functions will be called with three args: the name
+of the selection (typically PRIMARY, SECONDARY or CLIPBOARD); the
+type from which the selection should be converted; and the selection
+value.  These functions should return a suitable representation of the
+value, or nil to indicate that the conversion was not possible.
+See also `selection-converter-out-alist'. */ );
+Vselection_converter_in_alist = Qnil;
+DEFVAR_LISP ("selection-coercion-alist",
+	       &Vselection_coercion_alist /*
+An alist associating selection-types (such as STRING and TIMESTAMP) with
+functions.  These functions will be called with three args; the name
+of the selection (typically PRIMARY, SECONDARY or CLIPBOARD); the type
+from which the selection should be converted, and the selection value.
+The value passed will be *exactly the same value* that was given to
+`own-selection'; it should be converted into something suitable for
+return to a program calling `get-selection' with the appropriate
+parameters.
+See also `selection-converter-in-alist' and
+`selection-converter-out-alist'. */);
+Vselection_coercion_alist = Qnil;
+DEFVAR_LISP ("selection-appender-alist",
+	       &Vselection_appender_alist /*
+An alist associating selection-types (such as STRING and TIMESTAMP) with
+functions.  These functions will be called with four args; the name
+of the selection (typically PRIMARY, SECONDARY or CLIPBOARD); the type
+of the selection; and two selection values.  The functions are expected to
+return a value representing the catenation of the two values, or nil to
+indicate that this was not possible. */ );
+Vselection_appender_alist = Qnil;
+DEFVAR_LISP ("selection-buffer-killed-alist",
+	       &Vselection_buffer_killed_alist /*
+An alist associating selection-types (such as STRING and TIMESTAMP) with
+functions.  These functions will be called whenever a buffer is killed,
+with four args: the name of the selection (typically PRIMARY, SECONDARY
+or CLIPBOARD); the type of the selection; the value of the selection; and
+the buffer that has just been killed.  These functions should return a new
+selection value, or nil to indicate that the selection value should be
+deleted. */ );
+Vselection_buffer_killed_alist = Qnil;
+DEFVAR_LISP ("selection-coercible-types",
+	       &Vselection_coercible_types /*
+A list of selection types that are coercible---that is, types that may be
+automatically converted to another type. Selection values with types in this
+list may be subject to conversion attempts to other types. */ );
+Vselection_coercible_types = Qnil;
 DEFVAR_LISP ("lost-selection-hooks", &Vlost_selection_hooks /*
 A function or functions to be called after we have been notified
 that we have lost the selection.  The function(s) will be called with one
 argument, a symbol naming the selection (typically PRIMARY, SECONDARY, or
 CLIPBOARD).
 */ );
 Vlost_selection_hooks = Qunbound;
 }

Mercurial > hg > xemacs-beta

comparison src/select.c @ 442:abe6d1db359e r21-2-36