xemacs-beta: src/select-x.c comparison

comparison src/select-x.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
 if (EQ (sym, QCUT_BUFFER6))	return XA_CUT_BUFFER6;
 if (EQ (sym, QCUT_BUFFER7))	return XA_CUT_BUFFER7;
 #endif /* CUT_BUFFER_SUPPORT */
 {
-CONST char *nameext;
+const char *nameext;
-TO_EXTERNAL_FORMAT (LISP_STRING, Fsymbol_name (sym),
+LISP_STRING_TO_EXTERNAL (Fsymbol_name (sym), nameext, Qctext);
-			C_STRING_ALLOCA, nameext,
-			Qctext);
 return XInternAtom (display, nameext, only_if_exists ? True : False);
 }
 }
 }
 }
 /* Do protocol to assert ourself as a selection owner.
-Update the Vselection_alist so that we can reply to later requests for
-our selection.
 */
 static Lisp_Object
-x_own_selection (Lisp_Object selection_name, Lisp_Object selection_value)
+x_own_selection (Lisp_Object selection_name, Lisp_Object selection_value,
+		 Lisp_Object how_to_add, Lisp_Object selection_type)
 {
 struct device *d = decode_x_device (Qnil);
 Display *display = DEVICE_X_DISPLAY (d);
 struct frame *sel_frame = selected_frame ();
 Window selecting_window = XtWindow (FRAME_X_TEXT_WIDGET (sel_frame));
 /* We do NOT use time_to_lisp() here any more, like we used to.
 That assumed equivalence of time_t and Time, which is not
 necessarily the case (e.g. under OSF on the Alphas, where
 Time is a 64-bit quantity and time_t is a 32-bit quantity).
 Opaque pointers are the clean way to go here.
 */
 selection_time = make_opaque (&thyme, sizeof (thyme));
 #ifdef MOTIF_CLIPBOARDS
 static void
 hack_motif_clipboard_selection (Atom selection_atom,
 				Lisp_Object selection_value,
 				Time thyme,
 				Display *display,
-Window selecting_window)
+				Window selecting_window)
 /*				Bool owned_p)*/
 {
 struct device *d = get_device_from_display (display);
 /* Those Motif wankers can't be bothered to follow the ICCCM, and do
 their own non-Xlib non-Xt clipboard processing.  So we have to do
 #else
 int dataid;	/* 1.2 wants long, but 1.1.5 wants int... */
 #endif
 XmString fmh;
 String encoding = "STRING";
-CONST Extbyte *data  = XSTRING_DATA (selection_value);
+const Extbyte *data  = XSTRING_DATA (selection_value);
 Extcount bytes = XSTRING_LENGTH (selection_value);
 #ifdef MULE
 {
 	enum { ASCII, LATIN_1, WORLD } chartypes = ASCII;
-	CONST Bufbyte *ptr = data, *end = ptr + bytes;
+	const Bufbyte *ptr = data, *end = ptr + bytes;
 	/* Optimize for the common ASCII case */
 	while (ptr <= end)
 	  {
 	    if (BYTE_ASCII_P (*ptr))
 	      {
 {
 case XmCR_CLIPBOARD_DATA_REQUEST:
 {
 	Display *dpy = XtDisplay (widget);
 	Window window = (Window) *private_id;
-	Lisp_Object selection = assq_no_quit (QCLIPBOARD, Vselection_alist);
+	Lisp_Object selection = select_convert_out (QCLIPBOARD, Qnil, Qnil);
-	if (NILP (selection)) abort ();
-	selection = XCDR (selection);
+	/* Whichever lazy git wrote this originally just called abort()
-	if (!STRINGP (selection)) abort ();
+	   when anything didn't go their way... */
+	/* Try some other text types */
+	if (NILP (selection))
+	  selection = select_convert_out (QCLIPBOARD, QSTRING, Qnil);
+	if (NILP (selection))
+	  selection = select_convert_out (QCLIPBOARD, QTEXT, Qnil);
+	if (NILP (selection))
+	  selection = select_convert_out (QCLIPBOARD, QCOMPOUND_TEXT, Qnil);
+	if (CONSP (selection) && SYMBOLP (XCAR (selection))
+	    && (EQ (XCAR (selection), QSTRING)
+		|| EQ (XCAR (selection), QTEXT)
+		|| EQ (XCAR (selection), QCOMPOUND_TEXT)))
+	  selection = XCDR (selection);
+	if (NILP (selection))
+	  signal_error (Qselection_conversion_error,
+			build_string ("no selection"));
+	if (!STRINGP (selection))
+	  signal_error (Qselection_conversion_error,
+			build_string ("couldn't convert selection to string"));
 	XmClipboardCopyByName (dpy, window, *data_id,
 			       (char *) XSTRING_DATA (selection),
 			       XSTRING_LENGTH (selection) + 1,
 			       0);
 }
 */
 void
 x_handle_selection_request (XSelectionRequestEvent *event)
 {
 /* This function can GC */
-struct gcpro gcpro1, gcpro2, gcpro3;
+struct gcpro gcpro1, gcpro2;
-Lisp_Object local_selection_data = Qnil;
+Lisp_Object temp_obj;
 Lisp_Object selection_symbol;
 Lisp_Object target_symbol = Qnil;
 Lisp_Object converted_selection = Qnil;
 Time local_selection_time;
 Lisp_Object successful_p = Qnil;
 int count;
 struct device *d = get_device_from_display (event->display);
-GCPRO3 (local_selection_data, converted_selection, target_symbol);
+GCPRO2 (converted_selection, target_symbol);
 selection_symbol = x_atom_to_symbol (d, event->selection);
+target_symbol = x_atom_to_symbol (d, event->target);
-local_selection_data = assq_no_quit (selection_symbol, Vselection_alist);
+#if 0 /* #### MULTIPLE doesn't work yet */
-#if 0
+if (EQ (target_symbol, QMULTIPLE))
-/* This list isn't user-visible, so it can't "go bad." */
+target_symbol = fetch_multiple_target (event);
-assert (CONSP (local_selection_data));
+#endif
-assert (CONSP (XCDR (local_selection_data)));
-assert (CONSP (XCDR (XCDR (local_selection_data))));
+temp_obj = Fget_selection_timestamp (selection_symbol);
-assert (NILP  (XCDR (XCDR (XCDR (local_selection_data)))));
-assert (CONSP (XCAR (XCDR (XCDR (local_selection_data)))));
+if (NILP (temp_obj))
-assert (INTP  (XCAR (XCAR (XCDR (XCDR (local_selection_data))))));
+{
-assert (INTP  (XCDR (XCAR (XCDR (XCDR (local_selection_data))))));
+/* We don't appear to have the selection. */
-#endif
-if (NILP (local_selection_data))
-{
-/* Someone asked for the selection, but we don't have it any more. */
 x_decline_selection_request (event);
 goto DONE_LABEL;
 }
-local_selection_time =
+local_selection_time = * (Time *) XOPAQUE_DATA (temp_obj);
-* (Time *) XOPAQUE_DATA (XCAR (XCDR (XCDR (local_selection_data))));
 if (event->time != CurrentTime &&
 local_selection_time > event->time)
 {
 /* Someone asked for the selection, and we have one, but not the one
 	 they're looking for. */
 x_decline_selection_request (event);
 goto DONE_LABEL;
 }
+converted_selection = select_convert_out (selection_symbol,
+					    target_symbol, Qnil);
+/* #### Is this the right thing to do? I'm no X expert. -- ajh */
+if (NILP (converted_selection))
+{
+/* We don't appear to have a selection in that data type. */
+x_decline_selection_request (event);
+goto DONE_LABEL;
+}
 count = specpdl_depth ();
 record_unwind_protect (x_selection_request_lisp_error,
 			 make_opaque_ptr (event));
-target_symbol = x_atom_to_symbol (d, event->target);
+{
-#if 0 /* #### MULTIPLE doesn't work yet */
+unsigned char *data;
-if (EQ (target_symbol, QMULTIPLE))
+unsigned int size;
-target_symbol = fetch_multiple_target (event);
+int format;
-#endif
+Atom type;
+lisp_data_to_selection_data (d, converted_selection,
-/* Convert lisp objects back into binary data */
+				 &data, &type, &size, &format);
-converted_selection =
+x_reply_selection_request (event, format, data, size, type);
-get_local_selection (selection_symbol, target_symbol);
+successful_p = Qt;
+/* Tell x_selection_request_lisp_error() it's cool. */
-if (! NILP (converted_selection))
+event->type = 0;
-{
+xfree (data);
-unsigned char *data;
+}
-unsigned int size;
-int format;
-Atom type;
-lisp_data_to_selection_data (d, converted_selection,
-				   &data, &type, &size, &format);
-x_reply_selection_request (event, format, data, size, type);
-successful_p = Qt;
-/* Tell x_selection_request_lisp_error() it's cool. */      event->type = 0;
-xfree (data);
-}
 unbind_to (count, Qnil);
 DONE_LABEL:
 UNGCPRO;
 /* Let random lisp code notice that the selection has been asked for. */
 {
-Lisp_Object rest;
 Lisp_Object val = Vx_sent_selection_hooks;
 if (!UNBOUNDP (val) && !NILP (val))
 {
+	Lisp_Object rest;
 	if (CONSP (val) && !EQ (XCAR (val), Qlambda))
 	  for (rest = val; !NILP (rest); rest = Fcdr (rest))
-	    call3 (Fcar(rest), selection_symbol, target_symbol,
+	    call3 (Fcar (rest), selection_symbol, target_symbol, successful_p);
-		   successful_p);
 	else
-	  call3 (val, selection_symbol, target_symbol,
+	  call3 (val, selection_symbol, target_symbol, successful_p);
-		 successful_p);
 }
 }
 }
 Display *display = event->display;
 struct device *d = get_device_from_display (display);
 Atom selection = event->selection;
 Time changed_owner_time = event->time;
-Lisp_Object selection_symbol, local_selection_data;
+Lisp_Object selection_symbol, local_selection_time_lisp;
 Time local_selection_time;
 selection_symbol = x_atom_to_symbol (d, selection);
-local_selection_data = assq_no_quit (selection_symbol, Vselection_alist);
+local_selection_time_lisp = Fget_selection_timestamp (selection_symbol);
-/* Well, we already believe that we don't own it, so that's just fine. */
+/* We don't own the selection, so that's fine. */
-if (NILP (local_selection_data)) return;
+if (NILP (local_selection_time_lisp))
+return;
-local_selection_time =
-* (Time *) XOPAQUE_DATA (XCAR (XCDR (XCDR (local_selection_data))));
+local_selection_time = * (Time *) XOPAQUE_DATA (local_selection_time_lisp);
 /* This SelectionClear is for a selection that we no longer own, so we can
 disregard it.  (That is, we have reasserted the selection since this
 request was generated.)
 */
 if (changed_owner_time != CurrentTime &&
 local_selection_time > changed_owner_time)
 return;
 handle_selection_clear (selection_symbol);
 }
 /* This stuff is so that INCR selections are reentrant (that is, so we can
 error ("timed out waiting for reply from selection owner");
 unbind_to (speccount, Qnil);
 /* otherwise, the selection is waiting for us on the requested property. */
-return
-x_get_window_property_as_lisp_data (display, requestor_window,
+return select_convert_in (selection_symbol,
-					target_property, target_type,
+			    target_type,
-					selection_atom);
+			    x_get_window_property_as_lisp_data(display,
+							       requestor_window,
+							       target_property,
+							       target_type,
+							       selection_atom));
 }
 static void
 x_get_window_property (Display *display, Window window, Atom property,
 xfree (data);
 return val;
 }
+/* #### These are going to move into Lisp code(!) with the aid of
+some new functions I'm working on - ajh */
 /* These functions convert from the selection data read from the server into
 something that we can use from elisp, and vice versa.
 	Type:	Format:	Size:		Elisp Type:
 	-----	-------	-----		-----------
 *data_ret = 0;
 type = QNULL;
 }
 else if (STRINGP (obj))
 {
-CONST Extbyte *extval;
+const Extbyte *extval;
 Extcount extvallen;
 TO_EXTERNAL_FORMAT (LISP_STRING, obj,
 			  ALLOCA, (extval, extvallen),
 			  (NILP (type) ? Qctext : Qbinary));
 }
 else if (CHARP (obj))
 {
 Bufbyte buf[MAX_EMCHAR_LEN];
 Bytecount len;
-CONST Extbyte *extval;
+const Extbyte *extval;
 Extcount extvallen;
 *format_ret = 8;
 len = set_charptr_emchar (buf, XCHAR (obj));
 TO_EXTERNAL_FORMAT (DATA, (buf, len),
 XSetSelectionOwner (display, selection_atom, None, timestamp);
 }
 static Lisp_Object
-x_selection_exists_p (Lisp_Object selection)
+x_selection_exists_p (Lisp_Object selection,
+		      Lisp_Object selection_type)
 {
 struct device *d = decode_x_device (Qnil);
 Display *dpy = DEVICE_X_DISPLAY (d);
 return XGetSelectionOwner (dpy, symbol_to_x_atom (d, selection, 0)) != None ?
 Qt : Qnil;
 /* Ensure that all 8 cut buffers exist.  ICCCM says we gotta... */
 static void
 initialize_cut_buffers (Display *display, Window window)
 {
-static unsigned CONST char * CONST data = (unsigned CONST char *) "";
+static unsigned const char * const data = (unsigned const char *) "";
 #define FROB(atom) XChangeProperty (display, window, atom, XA_STRING, 8, \
 				    PropModeAppend, data, 0)
 FROB (XA_CUT_BUFFER0);
 FROB (XA_CUT_BUFFER1);
 FROB (XA_CUT_BUFFER2);
 {
 struct device *d = decode_x_device (Qnil);
 Display *display = DEVICE_X_DISPLAY (d);
 Window window = RootWindow (display, 0); /* Cutbuffers are on frame 0 */
 Atom cut_buffer_atom;
-CONST Extbyte *data  = XSTRING_DATA (string);
+const Extbyte *data  = XSTRING_DATA (string);
 Extcount bytes = XSTRING_LENGTH (string);
 Extcount bytes_remaining;
 int max_bytes = SELECTION_QUANTUM (display);
 #ifdef MULE
-CONST Bufbyte *ptr, *end;
+const Bufbyte *ptr, *end;
 enum { ASCII, LATIN_1, WORLD } chartypes = ASCII;
 #endif
 if (max_bytes > MAX_SELECTION_QUANTUM)
 max_bytes = MAX_SELECTION_QUANTUM;
 DEVICE_XATOM_INCR          (d) = XInternAtom (D, "INCR",          False);
 DEVICE_XATOM_TARGETS       (d) = XInternAtom (D, "TARGETS",       False);
 DEVICE_XATOM_NULL          (d) = XInternAtom (D, "NULL",          False);
 DEVICE_XATOM_ATOM_PAIR     (d) = XInternAtom (D, "ATOM_PAIR",     False);
 DEVICE_XATOM_COMPOUND_TEXT (d) = XInternAtom (D, "COMPOUND_TEXT", False);
+/* #### I don't like the looks of this... what is it for? - ajh */
 DEVICE_XATOM_EMACS_TMP     (d) = XInternAtom (D, "_EMACS_TMP_",   False);
 }

Mercurial > hg > xemacs-beta

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