home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / e20313sr.zip / emacs / 20.3.1 / src / xselect.c < prev    next >
C/C++ Source or Header  |  1999-07-31  |  76KB  |  2,352 lines
  1. /* X Selection processing for Emacs.
  2.    Copyright (C) 1993, 1994, 1995, 1996, 1997 Free Software Foundation.
  3.  
  4. This file is part of GNU Emacs.
  5.  
  6. GNU Emacs is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 2, or (at your option)
  9. any later version.
  10.  
  11. GNU Emacs is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with GNU Emacs; see the file COPYING.  If not, write to
  18. the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19. Boston, MA 02111-1307, USA.  */
  20.  
  21.  
  22. /* Rewritten by jwz */
  23.  
  24. #include <config.h>
  25. #include "lisp.h"
  26. #include "xterm.h"    /* for all of the X includes */
  27. #include "dispextern.h"    /* frame.h seems to want this */
  28. #include "frame.h"    /* Need this to get the X window of selected_frame */
  29. #include "blockinput.h"
  30. #include "buffer.h"
  31. #include "charset.h"
  32. #include "coding.h"
  33. #include "process.h"
  34.  
  35. #define CUT_BUFFER_SUPPORT
  36.  
  37. Lisp_Object QPRIMARY, QSECONDARY, QSTRING, QINTEGER, QCLIPBOARD, QTIMESTAMP,
  38.   QTEXT, QDELETE, QMULTIPLE, QINCR, QEMACS_TMP, QTARGETS, QATOM, QNULL,
  39.   QATOM_PAIR;
  40.  
  41. Lisp_Object QCOMPOUND_TEXT;    /* This is a type of selection.  */
  42.  
  43. #ifdef CUT_BUFFER_SUPPORT
  44. Lisp_Object QCUT_BUFFER0, QCUT_BUFFER1, QCUT_BUFFER2, QCUT_BUFFER3,
  45.   QCUT_BUFFER4, QCUT_BUFFER5, QCUT_BUFFER6, QCUT_BUFFER7;
  46. #endif
  47.  
  48. static Lisp_Object Vx_lost_selection_hooks;
  49. static Lisp_Object Vx_sent_selection_hooks;
  50. /* Coding system for communicating with other X clients via cutbuffer,
  51.    selection, and clipboard.  */
  52. static Lisp_Object Vselection_coding_system;
  53.  
  54. /* Coding system for the next communicating with other X clients.  */
  55. static Lisp_Object Vnext_selection_coding_system;
  56.  
  57. /* If this is a smaller number than the max-request-size of the display,
  58.    emacs will use INCR selection transfer when the selection is larger
  59.    than this.  The max-request-size is usually around 64k, so if you want
  60.    emacs to use incremental selection transfers when the selection is 
  61.    smaller than that, set this.  I added this mostly for debugging the
  62.    incremental transfer stuff, but it might improve server performance.  */
  63. #define MAX_SELECTION_QUANTUM 0xFFFFFF
  64.  
  65. #ifdef HAVE_X11R4
  66. #define SELECTION_QUANTUM(dpy) ((XMaxRequestSize(dpy) << 2) - 100)
  67. #else
  68. #define SELECTION_QUANTUM(dpy) (((dpy)->max_request_size << 2) - 100)
  69. #endif
  70.  
  71. /* The timestamp of the last input event Emacs received from the X server.  */
  72. /* Defined in keyboard.c.  */
  73. extern unsigned long last_event_timestamp;
  74.  
  75. /* This is an association list whose elements are of the form
  76.      ( SELECTION-NAME SELECTION-VALUE SELECTION-TIMESTAMP FRAME)
  77.    SELECTION-NAME is a lisp symbol, whose name is the name of an X Atom.
  78.    SELECTION-VALUE is the value that emacs owns for that selection.
  79.      It may be any kind of Lisp object.
  80.    SELECTION-TIMESTAMP is the time at which emacs began owning this selection,
  81.      as a cons of two 16-bit numbers (making a 32 bit time.)
  82.    FRAME is the frame for which we made the selection.
  83.    If there is an entry in this alist, then it can be assumed that Emacs owns
  84.     that selection.
  85.    The only (eq) parts of this list that are visible from Lisp are the
  86.     selection-values.  */
  87. static Lisp_Object Vselection_alist;
  88.  
  89. /* This is an alist whose CARs are selection-types (whose names are the same
  90.    as the names of X Atoms) and whose CDRs are the names of Lisp functions to
  91.    call to convert the given Emacs selection value to a string representing 
  92.    the given selection type.  This is for Lisp-level extension of the emacs
  93.    selection handling.  */
  94. static Lisp_Object Vselection_converter_alist;
  95.  
  96. /* If the selection owner takes too long to reply to a selection request,
  97.    we give up on it.  This is in milliseconds (0 = no timeout.)  */
  98. static int x_selection_timeout;
  99.  
  100. /* Utility functions */
  101.  
  102. static void lisp_data_to_selection_data ();
  103. static Lisp_Object selection_data_to_lisp_data ();
  104. static Lisp_Object x_get_window_property_as_lisp_data ();
  105.  
  106. /* This converts a Lisp symbol to a server Atom, avoiding a server 
  107.    roundtrip whenever possible.  */
  108.  
  109. static Atom
  110. symbol_to_x_atom (dpyinfo, display, sym)
  111.      struct x_display_info *dpyinfo;
  112.      Display *display;
  113.      Lisp_Object sym;
  114. {
  115.   Atom val;
  116.   if (NILP (sym))        return 0;
  117.   if (EQ (sym, QPRIMARY))   return XA_PRIMARY;
  118.   if (EQ (sym, QSECONDARY)) return XA_SECONDARY;
  119.   if (EQ (sym, QSTRING))    return XA_STRING;
  120.   if (EQ (sym, QINTEGER))   return XA_INTEGER;
  121.   if (EQ (sym, QATOM))        return XA_ATOM;
  122.   if (EQ (sym, QCLIPBOARD)) return dpyinfo->Xatom_CLIPBOARD;
  123.   if (EQ (sym, QTIMESTAMP)) return dpyinfo->Xatom_TIMESTAMP;
  124.   if (EQ (sym, QTEXT))        return dpyinfo->Xatom_TEXT;
  125.   if (EQ (sym, QCOMPOUND_TEXT)) return dpyinfo->Xatom_COMPOUND_TEXT;
  126.   if (EQ (sym, QDELETE))    return dpyinfo->Xatom_DELETE;
  127.   if (EQ (sym, QMULTIPLE))  return dpyinfo->Xatom_MULTIPLE;
  128.   if (EQ (sym, QINCR))        return dpyinfo->Xatom_INCR;
  129.   if (EQ (sym, QEMACS_TMP)) return dpyinfo->Xatom_EMACS_TMP;
  130.   if (EQ (sym, QTARGETS))   return dpyinfo->Xatom_TARGETS;
  131.   if (EQ (sym, QNULL))        return dpyinfo->Xatom_NULL;
  132. #ifdef CUT_BUFFER_SUPPORT
  133.   if (EQ (sym, QCUT_BUFFER0)) return XA_CUT_BUFFER0;
  134.   if (EQ (sym, QCUT_BUFFER1)) return XA_CUT_BUFFER1;
  135.   if (EQ (sym, QCUT_BUFFER2)) return XA_CUT_BUFFER2;
  136.   if (EQ (sym, QCUT_BUFFER3)) return XA_CUT_BUFFER3;
  137.   if (EQ (sym, QCUT_BUFFER4)) return XA_CUT_BUFFER4;
  138.   if (EQ (sym, QCUT_BUFFER5)) return XA_CUT_BUFFER5;
  139.   if (EQ (sym, QCUT_BUFFER6)) return XA_CUT_BUFFER6;
  140.   if (EQ (sym, QCUT_BUFFER7)) return XA_CUT_BUFFER7;
  141. #endif
  142.   if (!SYMBOLP (sym)) abort ();
  143.  
  144. #if 0
  145.   fprintf (stderr, " XInternAtom %s\n", (char *) XSYMBOL (sym)->name->data);
  146. #endif
  147.   BLOCK_INPUT;
  148.   val = XInternAtom (display, (char *) XSYMBOL (sym)->name->data, False);
  149.   UNBLOCK_INPUT;
  150.   return val;
  151. }
  152.  
  153.  
  154. /* This converts a server Atom to a Lisp symbol, avoiding server roundtrips
  155.    and calls to intern whenever possible.  */
  156.  
  157. static Lisp_Object
  158. x_atom_to_symbol (dpyinfo, display, atom)
  159.      struct x_display_info *dpyinfo;
  160.      Display *display;
  161.      Atom atom;
  162. {
  163.   char *str;
  164.   Lisp_Object val;
  165.   if (! atom) return Qnil;
  166.   switch (atom)
  167.     {
  168.     case XA_PRIMARY:
  169.       return QPRIMARY;
  170.     case XA_SECONDARY:
  171.       return QSECONDARY;
  172.     case XA_STRING:
  173.       return QSTRING;
  174.     case XA_INTEGER:
  175.       return QINTEGER;
  176.     case XA_ATOM:
  177.       return QATOM;
  178. #ifdef CUT_BUFFER_SUPPORT
  179.     case XA_CUT_BUFFER0:
  180.       return QCUT_BUFFER0;
  181.     case XA_CUT_BUFFER1:
  182.       return QCUT_BUFFER1;
  183.     case XA_CUT_BUFFER2:
  184.       return QCUT_BUFFER2;
  185.     case XA_CUT_BUFFER3:
  186.       return QCUT_BUFFER3;
  187.     case XA_CUT_BUFFER4:
  188.       return QCUT_BUFFER4;
  189.     case XA_CUT_BUFFER5:
  190.       return QCUT_BUFFER5;
  191.     case XA_CUT_BUFFER6:
  192.       return QCUT_BUFFER6;
  193.     case XA_CUT_BUFFER7:
  194.       return QCUT_BUFFER7;
  195. #endif
  196.     }
  197.  
  198.   if (atom == dpyinfo->Xatom_CLIPBOARD)
  199.     return QCLIPBOARD;
  200.   if (atom == dpyinfo->Xatom_TIMESTAMP)
  201.     return QTIMESTAMP;
  202.   if (atom == dpyinfo->Xatom_TEXT)
  203.     return QTEXT;
  204.   if (atom == dpyinfo->Xatom_COMPOUND_TEXT)
  205.     return QCOMPOUND_TEXT;
  206.   if (atom == dpyinfo->Xatom_DELETE)
  207.     return QDELETE;
  208.   if (atom == dpyinfo->Xatom_MULTIPLE)
  209.     return QMULTIPLE;
  210.   if (atom == dpyinfo->Xatom_INCR)
  211.     return QINCR;
  212.   if (atom == dpyinfo->Xatom_EMACS_TMP)
  213.     return QEMACS_TMP;
  214.   if (atom == dpyinfo->Xatom_TARGETS)
  215.     return QTARGETS;
  216.   if (atom == dpyinfo->Xatom_NULL)
  217.     return QNULL;
  218.  
  219.   BLOCK_INPUT;
  220.   str = XGetAtomName (display, atom);
  221.   UNBLOCK_INPUT;
  222. #if 0
  223.   fprintf (stderr, " XGetAtomName --> %s\n", str);
  224. #endif
  225.   if (! str) return Qnil;
  226.   val = intern (str);
  227.   BLOCK_INPUT;
  228.   /* This was allocated by Xlib, so use XFree.  */
  229.   XFree (str);
  230.   UNBLOCK_INPUT;
  231.   return val;
  232. }
  233.  
  234. /* Do protocol to assert ourself as a selection owner.
  235.    Update the Vselection_alist so that we can reply to later requests for 
  236.    our selection.  */
  237.  
  238. static void
  239. x_own_selection (selection_name, selection_value)
  240.      Lisp_Object selection_name, selection_value;
  241. {
  242.   Window selecting_window = FRAME_X_WINDOW (selected_frame);
  243.   Display *display = FRAME_X_DISPLAY (selected_frame);
  244.   Time time = last_event_timestamp;
  245.   Atom selection_atom;
  246.   struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (selected_frame);
  247.   int count;
  248.  
  249.   CHECK_SYMBOL (selection_name, 0);
  250.   selection_atom = symbol_to_x_atom (dpyinfo, display, selection_name);
  251.  
  252.   BLOCK_INPUT;
  253.   count = x_catch_errors (display);
  254.   XSetSelectionOwner (display, selection_atom, selecting_window, time);
  255.   x_check_errors (display, "Can't set selection: %s");
  256.   x_uncatch_errors (display, count);
  257.   UNBLOCK_INPUT;
  258.  
  259.   /* Now update the local cache */
  260.   {
  261.     Lisp_Object selection_time;
  262.     Lisp_Object selection_data;
  263.     Lisp_Object prev_value;
  264.  
  265.     selection_time = long_to_cons ((unsigned long) time);
  266.     selection_data = Fcons (selection_name,
  267.                 Fcons (selection_value,
  268.                    Fcons (selection_time,
  269.                       Fcons (Fselected_frame (), Qnil))));
  270.     prev_value = assq_no_quit (selection_name, Vselection_alist);
  271.  
  272.     Vselection_alist = Fcons (selection_data, Vselection_alist);
  273.  
  274.     /* If we already owned the selection, remove the old selection data.
  275.        Perhaps we should destructively modify it instead.
  276.        Don't use Fdelq as that may QUIT.  */
  277.     if (!NILP (prev_value))
  278.       {
  279.     Lisp_Object rest;    /* we know it's not the CAR, so it's easy.  */
  280.     for (rest = Vselection_alist; !NILP (rest); rest = Fcdr (rest))
  281.       if (EQ (prev_value, Fcar (XCONS (rest)->cdr)))
  282.         {
  283.           XCONS (rest)->cdr = Fcdr (XCONS (rest)->cdr);
  284.           break;
  285.         }
  286.       }
  287.   }
  288. }
  289.  
  290. /* Given a selection-name and desired type, look up our local copy of
  291.    the selection value and convert it to the type.
  292.    The value is nil or a string.
  293.    This function is used both for remote requests
  294.    and for local x-get-selection-internal.
  295.  
  296.    This calls random Lisp code, and may signal or gc.  */
  297.  
  298. static Lisp_Object
  299. x_get_local_selection (selection_symbol, target_type)
  300.      Lisp_Object selection_symbol, target_type;
  301. {
  302.   Lisp_Object local_value;
  303.   Lisp_Object handler_fn, value, type, check;
  304.   int count;
  305.  
  306.   local_value = assq_no_quit (selection_symbol, Vselection_alist);
  307.  
  308.   if (NILP (local_value)) return Qnil;
  309.  
  310.   /* TIMESTAMP and MULTIPLE are special cases 'cause that's easiest.  */
  311.   if (EQ (target_type, QTIMESTAMP))
  312.     {
  313.       handler_fn = Qnil;
  314.       value = XCONS (XCONS (XCONS (local_value)->cdr)->cdr)->car;
  315.     }
  316. #if 0
  317.   else if (EQ (target_type, QDELETE))
  318.     {
  319.       handler_fn = Qnil;
  320.       Fx_disown_selection_internal
  321.     (selection_symbol,
  322.      XCONS (XCONS (XCONS (local_value)->cdr)->cdr)->car);
  323.       value = QNULL;
  324.     }
  325. #endif
  326.  
  327. #if 0 /* #### MULTIPLE doesn't work yet */
  328.   else if (CONSP (target_type)
  329.        && XCONS (target_type)->car == QMULTIPLE)
  330.     {
  331.       Lisp_Object pairs;
  332.       int size;
  333.       int i;
  334.       pairs = XCONS (target_type)->cdr;
  335.       size = XVECTOR (pairs)->size;
  336.       /* If the target is MULTIPLE, then target_type looks like
  337.       (MULTIPLE . [[SELECTION1 TARGET1] [SELECTION2 TARGET2] ... ])
  338.      We modify the second element of each pair in the vector and
  339.      return it as [[SELECTION1 <value1>] [SELECTION2 <value2>] ... ]
  340.        */
  341.       for (i = 0; i < size; i++)
  342.     {
  343.       Lisp_Object pair;
  344.       pair = XVECTOR (pairs)->contents [i];
  345.       XVECTOR (pair)->contents [1]
  346.         = x_get_local_selection (XVECTOR (pair)->contents [0],
  347.                      XVECTOR (pair)->contents [1]);
  348.     }
  349.       return pairs;
  350.     }
  351. #endif
  352.   else
  353.     {
  354.       /* Don't allow a quit within the converter.
  355.      When the user types C-g, he would be surprised
  356.      if by luck it came during a converter.  */
  357.       count = specpdl_ptr - specpdl;
  358.       specbind (Qinhibit_quit, Qt);
  359.  
  360.       CHECK_SYMBOL (target_type, 0);
  361.       handler_fn = Fcdr (Fassq (target_type, Vselection_converter_alist));
  362.       if (!NILP (handler_fn))
  363.     value = call3 (handler_fn,
  364.                selection_symbol, target_type,
  365.                XCONS (XCONS (local_value)->cdr)->car);
  366.       else
  367.     value = Qnil;
  368.       unbind_to (count, Qnil);
  369.     }
  370.  
  371.   /* Make sure this value is of a type that we could transmit
  372.      to another X client.  */
  373.  
  374.   check = value;
  375.   if (CONSP (value)
  376.       && SYMBOLP (XCONS (value)->car))
  377.     type = XCONS (value)->car,
  378.     check = XCONS (value)->cdr;
  379.   
  380.   if (STRINGP (check)
  381.       || VECTORP (check)
  382.       || SYMBOLP (check)
  383.       || INTEGERP (check)
  384.       || NILP (value))
  385.     return value;
  386.   /* Check for a value that cons_to_long could handle.  */
  387.   else if (CONSP (check)
  388.        && INTEGERP (XCONS (check)->car)
  389.        && (INTEGERP (XCONS (check)->cdr)
  390.            ||
  391.            (CONSP (XCONS (check)->cdr)
  392.         && INTEGERP (XCONS (XCONS (check)->cdr)->car)
  393.         && NILP (XCONS (XCONS (check)->cdr)->cdr))))
  394.     return value;
  395.   else
  396.     return
  397.       Fsignal (Qerror,
  398.            Fcons (build_string ("invalid data returned by selection-conversion function"),
  399.               Fcons (handler_fn, Fcons (value, Qnil))));
  400. }
  401.  
  402. /* Subroutines of x_reply_selection_request.  */
  403.  
  404. /* Send a SelectionNotify event to the requestor with property=None,
  405.    meaning we were unable to do what they wanted.  */
  406.  
  407. static void
  408. x_decline_selection_request (event)
  409.      struct input_event *event;
  410. {
  411.   XSelectionEvent reply;
  412.   reply.type = SelectionNotify;
  413.   reply.display = SELECTION_EVENT_DISPLAY (event);
  414.   reply.requestor = SELECTION_EVENT_REQUESTOR (event);
  415.   reply.selection = SELECTION_EVENT_SELECTION (event);
  416.   reply.time = SELECTION_EVENT_TIME (event);
  417.   reply.target = SELECTION_EVENT_TARGET (event);
  418.   reply.property = None;
  419.  
  420.   BLOCK_INPUT;
  421.   XSendEvent (reply.display, reply.requestor, False, 0L,
  422.           (XEvent *) &reply);
  423.   XFlush (reply.display);
  424.   UNBLOCK_INPUT;
  425. }
  426.  
  427. /* This is the selection request currently being processed.
  428.    It is set to zero when the request is fully processed.  */
  429. static struct input_event *x_selection_current_request;
  430.  
  431. /* Used as an unwind-protect clause so that, if a selection-converter signals
  432.    an error, we tell the requester that we were unable to do what they wanted
  433.    before we throw to top-level or go into the debugger or whatever.  */
  434.  
  435. static Lisp_Object
  436. x_selection_request_lisp_error (ignore)
  437.      Lisp_Object ignore;
  438. {
  439.   if (x_selection_current_request != 0)
  440.     x_decline_selection_request (x_selection_current_request);
  441.   return Qnil;
  442. }
  443.  
  444.  
  445. /* This stuff is so that INCR selections are reentrant (that is, so we can
  446.    be servicing multiple INCR selection requests simultaneously.)  I haven't
  447.    actually tested that yet.  */
  448.  
  449. /* Keep a list of the property changes that are awaited.  */
  450.  
  451. struct prop_location
  452. {
  453.   int identifier;
  454.   Display *display;
  455.   Window window;
  456.   Atom property;
  457.   int desired_state;
  458.   int arrived;
  459.   struct prop_location *next;
  460. };
  461.  
  462. static struct prop_location *expect_property_change ();
  463. static void wait_for_property_change ();
  464. static void unexpect_property_change ();
  465. static int waiting_for_other_props_on_window ();
  466.  
  467. static int prop_location_identifier;
  468.  
  469. static Lisp_Object property_change_reply;
  470.  
  471. static struct prop_location *property_change_reply_object;
  472.  
  473. static struct prop_location *property_change_wait_list;
  474.  
  475. static Lisp_Object
  476. queue_selection_requests_unwind (frame)
  477.      Lisp_Object frame;
  478. {
  479.   FRAME_PTR f = XFRAME (frame);
  480.  
  481.   if (! NILP (frame))
  482.     x_stop_queuing_selection_requests (FRAME_X_DISPLAY (f));
  483.   return Qnil;
  484. }
  485.  
  486. /* Return some frame whose display info is DPYINFO.
  487.    Return nil if there is none.  */
  488.  
  489. static Lisp_Object
  490. some_frame_on_display (dpyinfo)
  491.      struct x_display_info *dpyinfo;
  492. {
  493.   Lisp_Object list, frame;
  494.  
  495.   FOR_EACH_FRAME (list, frame)
  496.     {
  497.       if (FRAME_X_DISPLAY_INFO (XFRAME (frame)) == dpyinfo)
  498.     return frame;
  499.     }
  500.  
  501.   return Qnil;
  502. }
  503.  
  504. /* Send the reply to a selection request event EVENT.
  505.    TYPE is the type of selection data requested.
  506.    DATA and SIZE describe the data to send, already converted.
  507.    FORMAT is the unit-size (in bits) of the data to be transmitted.  */
  508.  
  509. static void
  510. x_reply_selection_request (event, format, data, size, type)
  511.      struct input_event *event;
  512.      int format, size;
  513.      unsigned char *data;
  514.      Atom type;
  515. {
  516.   XSelectionEvent reply;
  517.   Display *display = SELECTION_EVENT_DISPLAY (event);
  518.   Window window = SELECTION_EVENT_REQUESTOR (event);
  519.   int bytes_remaining;
  520.   int format_bytes = format/8;
  521.   int max_bytes = SELECTION_QUANTUM (display);
  522.   struct x_display_info *dpyinfo = x_display_info_for_display (display);
  523.   int count;
  524.  
  525.   if (max_bytes > MAX_SELECTION_QUANTUM)
  526.     max_bytes = MAX_SELECTION_QUANTUM;
  527.  
  528.   reply.type = SelectionNotify;
  529.   reply.display = display;
  530.   reply.requestor = window;
  531.   reply.selection = SELECTION_EVENT_SELECTION (event);
  532.   reply.time = SELECTION_EVENT_TIME (event);
  533.   reply.target = SELECTION_EVENT_TARGET (event);
  534.   reply.property = SELECTION_EVENT_PROPERTY (event);
  535.   if (reply.property == None)
  536.     reply.property = reply.target;
  537.  
  538.   /* #### XChangeProperty can generate BadAlloc, and we must handle it! */
  539.   BLOCK_INPUT;
  540.   count = x_catch_errors (display);
  541.  
  542.   /* Store the data on the requested property.
  543.      If the selection is large, only store the first N bytes of it.
  544.    */
  545.   bytes_remaining = size * format_bytes;
  546.   if (bytes_remaining <= max_bytes)
  547.     {
  548.       /* Send all the data at once, with minimal handshaking.  */
  549. #if 0
  550.       fprintf (stderr,"\nStoring all %d\n", bytes_remaining);
  551. #endif
  552.       XChangeProperty (display, window, reply.property, type, format,
  553.                PropModeReplace, data, size);
  554.       /* At this point, the selection was successfully stored; ack it.  */
  555.       XSendEvent (display, window, False, 0L, (XEvent *) &reply);
  556.     }
  557.   else
  558.     {
  559.       /* Send an INCR selection.  */
  560.       struct prop_location *wait_object;
  561.       int had_errors;
  562.       Lisp_Object frame;
  563.  
  564.       frame = some_frame_on_display (dpyinfo);
  565.  
  566.       /* If the display no longer has frames, we can't expect
  567.      to get many more selection requests from it, so don't
  568.      bother trying to queue them.  */
  569.       if (!NILP (frame))
  570.     {
  571.       x_start_queuing_selection_requests (display);
  572.  
  573.       record_unwind_protect (queue_selection_requests_unwind,
  574.                  frame);
  575.     }
  576.  
  577.       if (x_window_to_frame (dpyinfo, window)) /* #### debug */
  578.     error ("Attempt to transfer an INCR to ourself!");
  579. #if 0
  580.       fprintf (stderr, "\nINCR %d\n", bytes_remaining);
  581. #endif
  582.       wait_object = expect_property_change (display, window, reply.property,
  583.                         PropertyDelete);
  584.  
  585.       XChangeProperty (display, window, reply.property, dpyinfo->Xatom_INCR,
  586.                32, PropModeReplace,
  587.                (unsigned char *) &bytes_remaining, 1);
  588.       XSelectInput (display, window, PropertyChangeMask);
  589.       /* Tell 'em the INCR data is there...  */
  590.       XSendEvent (display, window, False, 0L, (XEvent *) &reply);
  591.       XFlush (display);
  592.  
  593.       had_errors = x_had_errors_p (display);
  594.       UNBLOCK_INPUT;
  595.  
  596.       /* First, wait for the requester to ack by deleting the property.
  597.      This can run random lisp code (process handlers) or signal.  */
  598.       if (! had_errors)
  599.     wait_for_property_change (wait_object);
  600.  
  601.       while (bytes_remaining)
  602.     {
  603.       int i = ((bytes_remaining < max_bytes)
  604.            ? bytes_remaining
  605.            : max_bytes);
  606.  
  607.       BLOCK_INPUT;
  608.  
  609.       wait_object
  610.         = expect_property_change (display, window, reply.property,
  611.                       PropertyDelete);
  612. #if 0
  613.       fprintf (stderr,"  INCR adding %d\n", i);
  614. #endif
  615.       /* Append the next chunk of data to the property.  */
  616.       XChangeProperty (display, window, reply.property, type, format,
  617.                PropModeAppend, data, i / format_bytes);
  618.       bytes_remaining -= i;
  619.       data += i;
  620.       XFlush (display);
  621.       had_errors = x_had_errors_p (display);
  622.       UNBLOCK_INPUT;
  623.  
  624.       if (had_errors)
  625.         break;
  626.  
  627.       /* Now wait for the requester to ack this chunk by deleting the
  628.          property.     This can run random lisp code or signal.
  629.        */
  630.       wait_for_property_change (wait_object);
  631.     }
  632.       /* Now write a zero-length chunk to the property to tell the requester
  633.      that we're done.  */
  634. #if 0
  635.       fprintf (stderr,"  INCR done\n");
  636. #endif
  637.       BLOCK_INPUT;
  638.       if (! waiting_for_other_props_on_window (display, window))
  639.     XSelectInput (display, window, 0L);
  640.  
  641.       XChangeProperty (display, window, reply.property, type, format,
  642.                PropModeReplace, data, 0);
  643.     }
  644.  
  645.   XFlush (display);
  646.   x_uncatch_errors (display, count);
  647.   UNBLOCK_INPUT;
  648. }
  649.  
  650. /* Handle a SelectionRequest event EVENT.
  651.    This is called from keyboard.c when such an event is found in the queue.  */
  652.  
  653. void
  654. x_handle_selection_request (event)
  655.      struct input_event *event;
  656. {
  657.   struct gcpro gcpro1, gcpro2, gcpro3;
  658.   Lisp_Object local_selection_data;
  659.   Lisp_Object selection_symbol;
  660.   Lisp_Object target_symbol;
  661.   Lisp_Object converted_selection;
  662.   Time local_selection_time;
  663.   Lisp_Object successful_p;
  664.   int count;
  665.   struct x_display_info *dpyinfo
  666.     = x_display_info_for_display (SELECTION_EVENT_DISPLAY (event));
  667.  
  668.   local_selection_data = Qnil;
  669.   target_symbol = Qnil;
  670.   converted_selection = Qnil;
  671.   successful_p = Qnil;
  672.  
  673.   GCPRO3 (local_selection_data, converted_selection, target_symbol);
  674.  
  675.   selection_symbol = x_atom_to_symbol (dpyinfo,
  676.                        SELECTION_EVENT_DISPLAY (event),
  677.                        SELECTION_EVENT_SELECTION (event));
  678.  
  679.   local_selection_data = assq_no_quit (selection_symbol, Vselection_alist);
  680.  
  681.   if (NILP (local_selection_data))
  682.     {
  683.       /* Someone asked for the selection, but we don't have it any more.
  684.        */
  685.       x_decline_selection_request (event);
  686.       goto DONE;
  687.     }
  688.  
  689.   local_selection_time = (Time)
  690.     cons_to_long (XCONS (XCONS (XCONS (local_selection_data)->cdr)->cdr)->car);
  691.  
  692.   if (SELECTION_EVENT_TIME (event) != CurrentTime
  693.       && local_selection_time > SELECTION_EVENT_TIME (event))
  694.     {
  695.       /* Someone asked for the selection, and we have one, but not the one
  696.      they're looking for.
  697.        */
  698.       x_decline_selection_request (event);
  699.       goto DONE;
  700.     }
  701.  
  702.   count = specpdl_ptr - specpdl;
  703.   x_selection_current_request = event;
  704.   record_unwind_protect (x_selection_request_lisp_error, Qnil);
  705.  
  706.   target_symbol = x_atom_to_symbol (dpyinfo, SELECTION_EVENT_DISPLAY (event),
  707.                     SELECTION_EVENT_TARGET (event));
  708.  
  709. #if 0 /* #### MULTIPLE doesn't work yet */
  710.   if (EQ (target_symbol, QMULTIPLE))
  711.     target_symbol = fetch_multiple_target (event);
  712. #endif
  713.   
  714.   /* Convert lisp objects back into binary data */
  715.   
  716.   converted_selection
  717.     = x_get_local_selection (selection_symbol, target_symbol);
  718.   
  719.   if (! NILP (converted_selection))
  720.     {
  721.       unsigned char *data;
  722.       unsigned int size;
  723.       int format;
  724.       Atom type;
  725.       int nofree;
  726.  
  727.       lisp_data_to_selection_data (SELECTION_EVENT_DISPLAY (event),
  728.                    converted_selection,
  729.                    &data, &type, &size, &format, &nofree);
  730.       
  731.       x_reply_selection_request (event, format, data, size, type);
  732.       successful_p = Qt;
  733.  
  734.       /* Indicate we have successfully processed this event.  */
  735.       x_selection_current_request = 0;
  736.  
  737.       /* Use xfree, not XFree, because lisp_data_to_selection_data
  738.      calls xmalloc itself.  */
  739.       if (!nofree)
  740.     xfree (data);
  741.     }
  742.   unbind_to (count, Qnil);
  743.  
  744.  DONE:
  745.  
  746.   UNGCPRO;
  747.  
  748.   /* Let random lisp code notice that the selection has been asked for.  */
  749.   {
  750.     Lisp_Object rest;
  751.     rest = Vx_sent_selection_hooks;
  752.     if (!EQ (rest, Qunbound))
  753.       for (; CONSP (rest); rest = Fcdr (rest))
  754.     call3 (Fcar (rest), selection_symbol, target_symbol, successful_p);
  755.   }
  756. }
  757.  
  758. /* Handle a SelectionClear event EVENT, which indicates that some other
  759.    client cleared out our previously asserted selection.
  760.    This is called from keyboard.c when such an event is found in the queue.  */
  761.  
  762. void
  763. x_handle_selection_clear (event)
  764.      struct input_event *event;
  765. {
  766.   Display *display = SELECTION_EVENT_DISPLAY (event);
  767.   Atom selection = SELECTION_EVENT_SELECTION (event);
  768.   Time changed_owner_time = SELECTION_EVENT_TIME (event);
  769.   
  770.   Lisp_Object selection_symbol, local_selection_data;
  771.   Time local_selection_time;
  772.   struct x_display_info *dpyinfo = x_display_info_for_display (display);
  773.  
  774.   selection_symbol = x_atom_to_symbol (dpyinfo, display, selection);
  775.  
  776.   local_selection_data = assq_no_quit (selection_symbol, Vselection_alist);
  777.  
  778.   /* Well, we already believe that we don't own it, so that's just fine.  */
  779.   if (NILP (local_selection_data)) return;
  780.  
  781.   local_selection_time = (Time)
  782.     cons_to_long (XCONS (XCONS (XCONS (local_selection_data)->cdr)->cdr)->car);
  783.  
  784.   /* This SelectionClear is for a selection that we no longer own, so we can
  785.      disregard it.  (That is, we have reasserted the selection since this
  786.      request was generated.)  */
  787.  
  788.   if (changed_owner_time != CurrentTime
  789.       && local_selection_time > changed_owner_time)
  790.     return;
  791.  
  792.   /* Otherwise, we're really honest and truly being told to drop it.
  793.      Don't use Fdelq as that may QUIT;.  */
  794.  
  795.   if (EQ (local_selection_data, Fcar (Vselection_alist)))
  796.     Vselection_alist = Fcdr (Vselection_alist);
  797.   else
  798.     {
  799.       Lisp_Object rest;
  800.       for (rest = Vselection_alist; !NILP (rest); rest = Fcdr (rest))
  801.     if (EQ (local_selection_data, Fcar (XCONS (rest)->cdr)))
  802.       {
  803.         XCONS (rest)->cdr = Fcdr (XCONS (rest)->cdr);
  804.         break;
  805.       }
  806.     }
  807.  
  808.   /* Let random lisp code notice that the selection has been stolen.  */
  809.  
  810.   {
  811.     Lisp_Object rest;
  812.     rest = Vx_lost_selection_hooks;
  813.     if (!EQ (rest, Qunbound))
  814.       {
  815.     for (; CONSP (rest); rest = Fcdr (rest))
  816.       call1 (Fcar (rest), selection_symbol);
  817.     prepare_menu_bars ();
  818.     redisplay_preserve_echo_area ();
  819.       }
  820.   }
  821. }
  822.  
  823. /* Clear all selections that were made from frame F.
  824.    We do this when about to delete a frame.  */
  825.  
  826. void
  827. x_clear_frame_selections (f)
  828.      FRAME_PTR f;
  829. {
  830.   Lisp_Object frame;
  831.   Lisp_Object rest;
  832.  
  833.   XSETFRAME (frame, f);
  834.  
  835.   /* Otherwise, we're really honest and truly being told to drop it.
  836.      Don't use Fdelq as that may QUIT;.  */
  837.  
  838.   /* Delete elements from the beginning of Vselection_alist.  */
  839.   while (!NILP (Vselection_alist)
  840.      && EQ (frame, Fcar (Fcdr (Fcdr (Fcdr (Fcar (Vselection_alist)))))))
  841.     {
  842.       /* Let random Lisp code notice that the selection has been stolen.  */
  843.       Lisp_Object hooks, selection_symbol;
  844.  
  845.       hooks = Vx_lost_selection_hooks;
  846.       selection_symbol = Fcar (Fcar (Vselection_alist));
  847.  
  848.       if (!EQ (hooks, Qunbound))
  849.     {
  850.       for (; CONSP (hooks); hooks = Fcdr (hooks))
  851.         call1 (Fcar (hooks), selection_symbol);
  852. #if 0 /* This can crash when deleting a frame
  853.      from x_connection_closed.  Anyway, it seems unnecessary;
  854.      something else should cause a redisplay.  */
  855.       redisplay_preserve_echo_area ();
  856. #endif
  857.     }
  858.  
  859.       Vselection_alist = Fcdr (Vselection_alist);
  860.     }
  861.  
  862.   /* Delete elements after the beginning of Vselection_alist.  */
  863.   for (rest = Vselection_alist; !NILP (rest); rest = Fcdr (rest))
  864.     if (EQ (frame, Fcar (Fcdr (Fcdr (Fcdr (Fcar (XCONS (rest)->cdr)))))))
  865.       {
  866.     /* Let random Lisp code notice that the selection has been stolen.  */
  867.     Lisp_Object hooks, selection_symbol;
  868.  
  869.     hooks = Vx_lost_selection_hooks;
  870.     selection_symbol = Fcar (Fcar (XCONS (rest)->cdr));
  871.  
  872.     if (!EQ (hooks, Qunbound))
  873.       {
  874.         for (; CONSP (hooks); hooks = Fcdr (hooks))
  875.           call1 (Fcar (hooks), selection_symbol);
  876. #if 0 /* See above */
  877.         redisplay_preserve_echo_area ();
  878. #endif
  879.       }
  880.     XCONS (rest)->cdr = Fcdr (XCONS (rest)->cdr);
  881.     break;
  882.       }
  883. }
  884.  
  885. /* Nonzero if any properties for DISPLAY and WINDOW
  886.    are on the list of what we are waiting for.  */
  887.  
  888. static int
  889. waiting_for_other_props_on_window (display, window)
  890.      Display *display;
  891.      Window window;
  892. {
  893.   struct prop_location *rest = property_change_wait_list;
  894.   while (rest)
  895.     if (rest->display == display && rest->window == window)
  896.       return 1;
  897.     else
  898.       rest = rest->next;
  899.   return 0;
  900. }
  901.  
  902. /* Add an entry to the list of property changes we are waiting for.
  903.    DISPLAY, WINDOW, PROPERTY, STATE describe what we will wait for.
  904.    The return value is a number that uniquely identifies
  905.    this awaited property change.  */
  906.  
  907. static struct prop_location *
  908. expect_property_change (display, window, property, state)
  909.      Display *display;
  910.      Window window;
  911.      Atom property;
  912.      int state;
  913. {
  914.   struct prop_location *pl
  915.     = (struct prop_location *) xmalloc (sizeof (struct prop_location));
  916.   pl->identifier = ++prop_location_identifier;
  917.   pl->display = display;
  918.   pl->window = window;
  919.   pl->property = property;
  920.   pl->desired_state = state;
  921.   pl->next = property_change_wait_list;
  922.   pl->arrived = 0;
  923.   property_change_wait_list = pl;
  924.   return pl;
  925. }
  926.  
  927. /* Delete an entry from the list of property changes we are waiting for.
  928.    IDENTIFIER is the number that uniquely identifies the entry.  */
  929.  
  930. static void
  931. unexpect_property_change (location)
  932.      struct prop_location *location;
  933. {
  934.   struct prop_location *prev = 0, *rest = property_change_wait_list;
  935.   while (rest)
  936.     {
  937.       if (rest == location)
  938.     {
  939.       if (prev)
  940.         prev->next = rest->next;
  941.       else
  942.         property_change_wait_list = rest->next;
  943.       xfree (rest);
  944.       return;
  945.     }
  946.       prev = rest;
  947.       rest = rest->next;
  948.     }
  949. }
  950.  
  951. /* Remove the property change expectation element for IDENTIFIER.  */
  952.  
  953. static Lisp_Object
  954. wait_for_property_change_unwind (identifierval)
  955.      Lisp_Object identifierval;
  956. {
  957.   unexpect_property_change ((struct prop_location *)
  958.                 (XFASTINT (XCONS (identifierval)->car) << 16
  959.                  | XFASTINT (XCONS (identifierval)->cdr)));
  960.   return Qnil;
  961. }
  962.  
  963. /* Actually wait for a property change.
  964.    IDENTIFIER should be the value that expect_property_change returned.  */
  965.  
  966. static void
  967. wait_for_property_change (location)
  968.      struct prop_location *location;
  969. {
  970.   int secs, usecs;
  971.   int count = specpdl_ptr - specpdl;
  972.   Lisp_Object tem;
  973.  
  974.   tem = Fcons (Qnil, Qnil);
  975.   XSETFASTINT (XCONS (tem)->car, (EMACS_UINT)location >> 16);
  976.   XSETFASTINT (XCONS (tem)->cdr, (EMACS_UINT)location & 0xffff);
  977.  
  978.   /* Make sure to do unexpect_property_change if we quit or err.  */
  979.   record_unwind_protect (wait_for_property_change_unwind, tem);
  980.  
  981.   XCONS (property_change_reply)->car = Qnil;
  982.  
  983.   property_change_reply_object = location;
  984.   /* If the event we are waiting for arrives beyond here, it will set
  985.      property_change_reply, because property_change_reply_object says so.  */
  986.   if (! location->arrived)
  987.     {
  988.       secs = x_selection_timeout / 1000;
  989.       usecs = (x_selection_timeout % 1000) * 1000;
  990.       wait_reading_process_input (secs, usecs, property_change_reply, 0);
  991.  
  992.       if (NILP (XCONS (property_change_reply)->car))
  993.     error ("Timed out waiting for property-notify event");
  994.     }
  995.  
  996.   unbind_to (count, Qnil);
  997. }
  998.  
  999. /* Called from XTread_socket in response to a PropertyNotify event.  */
  1000.  
  1001. void
  1002. x_handle_property_notify (event)
  1003.      XPropertyEvent *event;
  1004. {
  1005.   struct prop_location *prev = 0, *rest = property_change_wait_list;
  1006.   while (rest)
  1007.     {
  1008.       if (rest->property == event->atom
  1009.       && rest->window == event->window
  1010.       && rest->display == event->display
  1011.       && rest->desired_state == event->state)
  1012.     {
  1013. #if 0
  1014.       fprintf (stderr, "Saw expected prop-%s on %s\n",
  1015.            (event->state == PropertyDelete ? "delete" : "change"),
  1016.            (char *) XSYMBOL (x_atom_to_symbol (dpyinfo, event->display,
  1017.                                event->atom))
  1018.            ->name->data);
  1019. #endif
  1020.  
  1021.       rest->arrived = 1;
  1022.  
  1023.       /* If this is the one wait_for_property_change is waiting for,
  1024.          tell it to wake up.  */
  1025.       if (rest == property_change_reply_object)
  1026.         XCONS (property_change_reply)->car = Qt;
  1027.  
  1028.       if (prev)
  1029.         prev->next = rest->next;
  1030.       else
  1031.         property_change_wait_list = rest->next;
  1032.       xfree (rest);
  1033.       return;
  1034.     }
  1035.       prev = rest;
  1036.       rest = rest->next;
  1037.     }
  1038. #if 0
  1039.   fprintf (stderr, "Saw UNexpected prop-%s on %s\n",
  1040.        (event->state == PropertyDelete ? "delete" : "change"),
  1041.        (char *) XSYMBOL (x_atom_to_symbol (dpyinfo,
  1042.                            event->display, event->atom))
  1043.        ->name->data);
  1044. #endif
  1045. }
  1046.  
  1047.  
  1048.  
  1049. #if 0 /* #### MULTIPLE doesn't work yet */
  1050.  
  1051. static Lisp_Object
  1052. fetch_multiple_target (event)
  1053.      XSelectionRequestEvent *event;
  1054. {
  1055.   Display *display = event->display;
  1056.   Window window = event->requestor;
  1057.   Atom target = event->target;
  1058.   Atom selection_atom = event->selection;
  1059.   int result;
  1060.  
  1061.   return
  1062.     Fcons (QMULTIPLE,
  1063.        x_get_window_property_as_lisp_data (display, window, target,
  1064.                            QMULTIPLE, selection_atom));
  1065. }
  1066.  
  1067. static Lisp_Object
  1068. copy_multiple_data (obj)
  1069.      Lisp_Object obj;
  1070. {
  1071.   Lisp_Object vec;
  1072.   int i;
  1073.   int size;
  1074.   if (CONSP (obj))
  1075.     return Fcons (XCONS (obj)->car, copy_multiple_data (XCONS (obj)->cdr));
  1076.     
  1077.   CHECK_VECTOR (obj, 0);
  1078.   vec = Fmake_vector (size = XVECTOR (obj)->size, Qnil);
  1079.   for (i = 0; i < size; i++)
  1080.     {
  1081.       Lisp_Object vec2 = XVECTOR (obj)->contents [i];
  1082.       CHECK_VECTOR (vec2, 0);
  1083.       if (XVECTOR (vec2)->size != 2)
  1084.     /* ??? Confusing error message */
  1085.     Fsignal (Qerror, Fcons (build_string ("vectors must be of length 2"),
  1086.                 Fcons (vec2, Qnil)));
  1087.       XVECTOR (vec)->contents [i] = Fmake_vector (2, Qnil);
  1088.       XVECTOR (XVECTOR (vec)->contents [i])->contents [0]
  1089.     = XVECTOR (vec2)->contents [0];
  1090.       XVECTOR (XVECTOR (vec)->contents [i])->contents [1]
  1091.     = XVECTOR (vec2)->contents [1];
  1092.     }
  1093.   return vec;
  1094. }
  1095.  
  1096. #endif
  1097.  
  1098.  
  1099. /* Variables for communication with x_handle_selection_notify.  */
  1100. static Atom reading_which_selection;
  1101. static Lisp_Object reading_selection_reply;
  1102. static Window reading_selection_window;
  1103.  
  1104. /* Do protocol to read selection-data from the server.
  1105.    Converts this to Lisp data and returns it.  */
  1106.  
  1107. static Lisp_Object
  1108. x_get_foreign_selection (selection_symbol, target_type)
  1109.      Lisp_Object selection_symbol, target_type;
  1110. {
  1111.   Window requestor_window = FRAME_X_WINDOW (selected_frame);
  1112.   Display *display = FRAME_X_DISPLAY (selected_frame);
  1113.   struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (selected_frame);
  1114.   Time requestor_time = last_event_timestamp;
  1115.   Atom target_property = dpyinfo->Xatom_EMACS_TMP;
  1116.   Atom selection_atom = symbol_to_x_atom (dpyinfo, display, selection_symbol);
  1117.   Atom type_atom;
  1118.   int secs, usecs;
  1119.   int count;
  1120.   Lisp_Object frame;
  1121.  
  1122.   if (CONSP (target_type))
  1123.     type_atom = symbol_to_x_atom (dpyinfo, display, XCONS (target_type)->car);
  1124.   else
  1125.     type_atom = symbol_to_x_atom (dpyinfo, display, target_type);
  1126.  
  1127.   BLOCK_INPUT;
  1128.   count = x_catch_errors (display);
  1129.   XConvertSelection (display, selection_atom, type_atom, target_property,
  1130.              requestor_window, requestor_time);
  1131.   XFlush (display);
  1132.  
  1133.   /* Prepare to block until the reply has been read.  */
  1134.   reading_selection_window = requestor_window;
  1135.   reading_which_selection = selection_atom;
  1136.   XCONS (reading_selection_reply)->car = Qnil;
  1137.  
  1138.   frame = some_frame_on_display (dpyinfo);
  1139.  
  1140.   /* If the display no longer has frames, we can't expect
  1141.      to get many more selection requests from it, so don't
  1142.      bother trying to queue them.  */
  1143.   if (!NILP (frame))
  1144.     {
  1145.       x_start_queuing_selection_requests (display);
  1146.  
  1147.       record_unwind_protect (queue_selection_requests_unwind,
  1148.                  frame);
  1149.     }
  1150.   UNBLOCK_INPUT;
  1151.  
  1152.   /* This allows quits.  Also, don't wait forever.  */
  1153.   secs = x_selection_timeout / 1000;
  1154.   usecs = (x_selection_timeout % 1000) * 1000;
  1155.   wait_reading_process_input (secs, usecs, reading_selection_reply, 0);
  1156.  
  1157.   BLOCK_INPUT;
  1158.   x_check_errors (display, "Cannot get selection: %s");
  1159.   x_uncatch_errors (display, count);
  1160.   UNBLOCK_INPUT;
  1161.  
  1162.   if (NILP (XCONS (reading_selection_reply)->car))
  1163.     error ("Timed out waiting for reply from selection owner");
  1164.   if (EQ (XCONS (reading_selection_reply)->car, Qlambda))
  1165.     error ("No `%s' selection", XSYMBOL (selection_symbol)->name->data);
  1166.  
  1167.   /* Otherwise, the selection is waiting for us on the requested property.  */
  1168.   return
  1169.     x_get_window_property_as_lisp_data (display, requestor_window,
  1170.                     target_property, target_type,
  1171.                     selection_atom);
  1172. }
  1173.  
  1174. /* Subroutines of x_get_window_property_as_lisp_data */
  1175.  
  1176. /* Use xfree, not XFree, to free the data obtained with this function.  */
  1177.  
  1178. static void
  1179. x_get_window_property (display, window, property, data_ret, bytes_ret,
  1180.                actual_type_ret, actual_format_ret, actual_size_ret,
  1181.                delete_p)
  1182.      Display *display;
  1183.      Window window;
  1184.      Atom property;
  1185.      unsigned char **data_ret;
  1186.      int *bytes_ret;
  1187.      Atom *actual_type_ret;
  1188.      int *actual_format_ret;
  1189.      unsigned long *actual_size_ret;
  1190.      int delete_p;
  1191. {
  1192.   int total_size;
  1193.   unsigned long bytes_remaining;
  1194.   int offset = 0;
  1195.   unsigned char *tmp_data = 0;
  1196.   int result;
  1197.   int buffer_size = SELECTION_QUANTUM (display);
  1198.   if (buffer_size > MAX_SELECTION_QUANTUM) buffer_size = MAX_SELECTION_QUANTUM;
  1199.   
  1200.   BLOCK_INPUT;
  1201.   /* First probe the thing to find out how big it is.  */
  1202.   result = XGetWindowProperty (display, window, property,
  1203.                    0L, 0L, False, AnyPropertyType,
  1204.                    actual_type_ret, actual_format_ret,
  1205.                    actual_size_ret,
  1206.                    &bytes_remaining, &tmp_data);
  1207.   if (result != Success)
  1208.     {
  1209.       UNBLOCK_INPUT;
  1210.       *data_ret = 0;
  1211.       *bytes_ret = 0;
  1212.       return;
  1213.     }
  1214.   /* This was allocated by Xlib, so use XFree.  */
  1215.   XFree ((char *) tmp_data);
  1216.   
  1217.   if (*actual_type_ret == None || *actual_format_ret == 0)
  1218.     {
  1219.       UNBLOCK_INPUT;
  1220.       return;
  1221.     }
  1222.  
  1223.   total_size = bytes_remaining + 1;
  1224.   *data_ret = (unsigned char *) xmalloc (total_size);
  1225.   
  1226.   /* Now read, until we've gotten it all.  */
  1227.   while (bytes_remaining)
  1228.     {
  1229. #if 0
  1230.       int last = bytes_remaining;
  1231. #endif
  1232.       result
  1233.     = XGetWindowProperty (display, window, property,
  1234.                   (long)offset/4, (long)buffer_size/4,
  1235.                   False,
  1236.                   AnyPropertyType,
  1237.                   actual_type_ret, actual_format_ret,
  1238.                   actual_size_ret, &bytes_remaining, &tmp_data);
  1239. #if 0
  1240.       fprintf (stderr, "<< read %d\n", last-bytes_remaining);
  1241. #endif
  1242.       /* If this doesn't return Success at this point, it means that
  1243.      some clod deleted the selection while we were in the midst of
  1244.      reading it.  Deal with that, I guess....
  1245.        */
  1246.       if (result != Success) break;
  1247.       *actual_size_ret *= *actual_format_ret / 8;
  1248.       bcopy (tmp_data, (*data_ret) + offset, *actual_size_ret);
  1249.       offset += *actual_size_ret;
  1250.       /* This was allocated by Xlib, so use XFree.  */
  1251.       XFree ((char *) tmp_data);
  1252.     }
  1253.  
  1254.   XFlush (display);
  1255.   UNBLOCK_INPUT;
  1256.   *bytes_ret = offset;
  1257. }
  1258.  
  1259. /* Use xfree, not XFree, to free the data obtained with this function.  */
  1260.  
  1261. static void
  1262. receive_incremental_selection (display, window, property, target_type,
  1263.                    min_size_bytes, data_ret, size_bytes_ret,
  1264.                    type_ret, format_ret, size_ret)
  1265.      Display *display;
  1266.      Window window;
  1267.      Atom property;
  1268.      Lisp_Object target_type; /* for error messages only */
  1269.      unsigned int min_size_bytes;
  1270.      unsigned char **data_ret;
  1271.      int *size_bytes_ret;
  1272.      Atom *type_ret;
  1273.      unsigned long *size_ret;
  1274.      int *format_ret;
  1275. {
  1276.   int offset = 0;
  1277.   struct prop_location *wait_object;
  1278.   *size_bytes_ret = min_size_bytes;
  1279.   *data_ret = (unsigned char *) xmalloc (*size_bytes_ret);
  1280. #if 0
  1281.   fprintf (stderr, "\nread INCR %d\n", min_size_bytes);
  1282. #endif
  1283.  
  1284.   /* At this point, we have read an INCR property.
  1285.      Delete the property to ack it.
  1286.      (But first, prepare to receive the next event in this handshake.)
  1287.  
  1288.      Now, we must loop, waiting for the sending window to put a value on
  1289.      that property, then reading the property, then deleting it to ack.
  1290.      We are done when the sender places a property of length 0.
  1291.    */
  1292.   BLOCK_INPUT;
  1293.   XSelectInput (display, window, STANDARD_EVENT_SET | PropertyChangeMask);
  1294.   XDeleteProperty (display, window, property);
  1295.   wait_object = expect_property_change (display, window, property,
  1296.                     PropertyNewValue);
  1297.   XFlush (display);
  1298.   UNBLOCK_INPUT;
  1299.  
  1300.   while (1)
  1301.     {
  1302.       unsigned char *tmp_data;
  1303.       int tmp_size_bytes;
  1304.       wait_for_property_change (wait_object);
  1305.       /* expect it again immediately, because x_get_window_property may
  1306.      .. no it won't, I don't get it.
  1307.      .. Ok, I get it now, the Xt code that implements INCR is broken.
  1308.        */
  1309.       x_get_window_property (display, window, property,
  1310.                  &tmp_data, &tmp_size_bytes,
  1311.                  type_ret, format_ret, size_ret, 1);
  1312.  
  1313.       if (tmp_size_bytes == 0) /* we're done */
  1314.     {
  1315. #if 0
  1316.       fprintf (stderr, "  read INCR done\n");
  1317. #endif
  1318.       if (! waiting_for_other_props_on_window (display, window))
  1319.         XSelectInput (display, window, STANDARD_EVENT_SET);
  1320.       unexpect_property_change (wait_object);
  1321.       /* Use xfree, not XFree, because x_get_window_property
  1322.          calls xmalloc itself.  */
  1323.       if (tmp_data) xfree (tmp_data);
  1324.       break;
  1325.     }
  1326.  
  1327.       BLOCK_INPUT;
  1328.       XDeleteProperty (display, window, property);
  1329.       wait_object = expect_property_change (display, window, property,
  1330.                         PropertyNewValue);
  1331.       XFlush (display);
  1332.       UNBLOCK_INPUT;
  1333.  
  1334. #if 0
  1335.       fprintf (stderr, "  read INCR %d\n", tmp_size_bytes);
  1336. #endif
  1337.       if (*size_bytes_ret < offset + tmp_size_bytes)
  1338.     {
  1339. #if 0
  1340.       fprintf (stderr, "  read INCR realloc %d -> %d\n",
  1341.            *size_bytes_ret, offset + tmp_size_bytes);
  1342. #endif
  1343.       *size_bytes_ret = offset + tmp_size_bytes;
  1344.       *data_ret = (unsigned char *) xrealloc (*data_ret, *size_bytes_ret);
  1345.     }
  1346.       bcopy (tmp_data, (*data_ret) + offset, tmp_size_bytes);
  1347.       offset += tmp_size_bytes;
  1348.       /* Use xfree, not XFree, because x_get_window_property
  1349.      calls xmalloc itself.  */
  1350.       xfree (tmp_data);
  1351.     }
  1352. }
  1353.  
  1354. /* Once a requested selection is "ready" (we got a SelectionNotify event),
  1355.    fetch value from property PROPERTY of X window WINDOW on display DISPLAY.
  1356.    TARGET_TYPE and SELECTION_ATOM are used in error message if this fails.  */
  1357.  
  1358. static Lisp_Object
  1359. x_get_window_property_as_lisp_data (display, window, property, target_type,
  1360.                     selection_atom)
  1361.      Display *display;
  1362.      Window window;
  1363.      Atom property;
  1364.      Lisp_Object target_type;    /* for error messages only */
  1365.      Atom selection_atom;    /* for error messages only */
  1366. {
  1367.   Atom actual_type;
  1368.   int actual_format;
  1369.   unsigned long actual_size;
  1370.   unsigned char *data = 0;
  1371.   int bytes = 0;
  1372.   Lisp_Object val;
  1373.   struct x_display_info *dpyinfo = x_display_info_for_display (display);
  1374.  
  1375.   x_get_window_property (display, window, property, &data, &bytes,
  1376.              &actual_type, &actual_format, &actual_size, 1);
  1377.   if (! data)
  1378.     {
  1379.       int there_is_a_selection_owner;
  1380.       BLOCK_INPUT;
  1381.       there_is_a_selection_owner
  1382.     = XGetSelectionOwner (display, selection_atom);
  1383.       UNBLOCK_INPUT;
  1384.       Fsignal (Qerror,
  1385.            there_is_a_selection_owner
  1386.            ? Fcons (build_string ("selection owner couldn't convert"),
  1387.             actual_type
  1388.             ? Fcons (target_type,
  1389.                  Fcons (x_atom_to_symbol (dpyinfo, display,
  1390.                               actual_type),
  1391.                     Qnil))
  1392.             : Fcons (target_type, Qnil))
  1393.            : Fcons (build_string ("no selection"),
  1394.             Fcons (x_atom_to_symbol (dpyinfo, display,
  1395.                          selection_atom),
  1396.                    Qnil)));
  1397.     }
  1398.   
  1399.   if (actual_type == dpyinfo->Xatom_INCR)
  1400.     {
  1401.       /* That wasn't really the data, just the beginning.  */
  1402.  
  1403.       unsigned int min_size_bytes = * ((unsigned int *) data);
  1404.       BLOCK_INPUT;
  1405.       /* Use xfree, not XFree, because x_get_window_property
  1406.      calls xmalloc itself.  */
  1407.       xfree ((char *) data);
  1408.       UNBLOCK_INPUT;
  1409.       receive_incremental_selection (display, window, property, target_type,
  1410.                      min_size_bytes, &data, &bytes,
  1411.                      &actual_type, &actual_format,
  1412.                      &actual_size);
  1413.     }
  1414.  
  1415.   BLOCK_INPUT;
  1416.   XDeleteProperty (display, window, property);
  1417.   XFlush (display);
  1418.   UNBLOCK_INPUT;
  1419.  
  1420.   /* It's been read.  Now convert it to a lisp object in some semi-rational
  1421.      manner.  */
  1422.   val = selection_data_to_lisp_data (display, data, bytes,
  1423.                      actual_type, actual_format);
  1424.   
  1425.   /* Use xfree, not XFree, because x_get_window_property
  1426.      calls xmalloc itself.  */
  1427.   xfree ((char *) data);
  1428.   return val;
  1429. }
  1430.  
  1431. /* These functions convert from the selection data read from the server into
  1432.    something that we can use from Lisp, and vice versa.
  1433.  
  1434.     Type:    Format:    Size:        Lisp Type:
  1435.     -----    -------    -----        -----------
  1436.     *    8    *        String
  1437.     ATOM    32    1        Symbol
  1438.     ATOM    32    > 1        Vector of Symbols
  1439.     *    16    1        Integer
  1440.     *    16    > 1        Vector of Integers
  1441.     *    32    1        if <=16 bits: Integer
  1442.                     if > 16 bits: Cons of top16, bot16
  1443.     *    32    > 1        Vector of the above
  1444.  
  1445.    When converting a Lisp number to C, it is assumed to be of format 16 if
  1446.    it is an integer, and of format 32 if it is a cons of two integers.
  1447.  
  1448.    When converting a vector of numbers from Lisp to C, it is assumed to be
  1449.    of format 16 if every element in the vector is an integer, and is assumed
  1450.    to be of format 32 if any element is a cons of two integers.
  1451.  
  1452.    When converting an object to C, it may be of the form (SYMBOL . <data>)
  1453.    where SYMBOL is what we should claim that the type is.  Format and
  1454.    representation are as above.  */
  1455.  
  1456.  
  1457.  
  1458. static Lisp_Object
  1459. selection_data_to_lisp_data (display, data, size, type, format)
  1460.      Display *display;
  1461.      unsigned char *data;
  1462.      Atom type;
  1463.      int size, format;
  1464. {
  1465.   struct x_display_info *dpyinfo = x_display_info_for_display (display);
  1466.  
  1467.   if (type == dpyinfo->Xatom_NULL)
  1468.     return QNULL;
  1469.  
  1470.   /* Convert any 8-bit data to a string, for compactness.  */
  1471.   else if (format == 8)
  1472.     {
  1473.       Lisp_Object str;
  1474.       int require_encoding = 0;
  1475.  
  1476.       if (
  1477. #if 1
  1478.       1
  1479. #else
  1480.       ! NILP (buffer_defaults.enable_multibyte_characters)
  1481. #endif
  1482.       )
  1483.     {
  1484.       /* If TYPE is `TEXT' or `COMPOUND_TEXT', we should decode
  1485.          DATA to Emacs internal format because DATA may be encoded
  1486.          in compound text format.  In addtion, if TYPE is `STRING'
  1487.          and DATA contains any 8-bit Latin-1 code, we should also
  1488.          decode it.  */
  1489.       if (type == dpyinfo->Xatom_TEXT
  1490.           || type == dpyinfo->Xatom_COMPOUND_TEXT)
  1491.         require_encoding = 1;
  1492.       else if (type == XA_STRING)
  1493.         {
  1494.           int i;
  1495.           for (i = 0; i < size; i++)
  1496.         {
  1497.           if (data[i] >= 0x80)
  1498.             {
  1499.               require_encoding = 1;
  1500.               break;
  1501.             }
  1502.         }
  1503.         }
  1504.     }
  1505.       if (!require_encoding)
  1506.     {
  1507.       str = make_unibyte_string ((char *) data, size);
  1508.       Vlast_coding_system_used = Qraw_text;
  1509.     }
  1510.       else
  1511.     {
  1512.       int bufsize;
  1513.       unsigned char *buf;
  1514.       struct coding_system coding;
  1515.  
  1516.       if (NILP (Vnext_selection_coding_system))
  1517.         Vnext_selection_coding_system = Vselection_coding_system;
  1518.       setup_coding_system
  1519.         (Fcheck_coding_system(Vnext_selection_coding_system), &coding);
  1520.       Vnext_selection_coding_system = Qnil;
  1521.           coding.mode |= CODING_MODE_LAST_BLOCK;
  1522.       bufsize = decoding_buffer_size (&coding, size);
  1523.       buf = (unsigned char *) xmalloc (bufsize);
  1524.       decode_coding (&coding, data, buf, size, bufsize);
  1525.       size = (coding.fake_multibyte
  1526.           ? multibyte_chars_in_text (buf, coding.produced)
  1527.           : coding.produced_char);
  1528.       str = make_string_from_bytes ((char *) buf, size, coding.produced);
  1529.       xfree (buf);
  1530.       Vlast_coding_system_used = coding.symbol;
  1531.     }
  1532.       return str;
  1533.     }
  1534.   /* Convert a single atom to a Lisp_Symbol.  Convert a set of atoms to
  1535.      a vector of symbols.
  1536.    */
  1537.   else if (type == XA_ATOM)
  1538.     {
  1539.       int i;
  1540.       if (size == sizeof (Atom))
  1541.     return x_atom_to_symbol (dpyinfo, display, *((Atom *) data));
  1542.       else
  1543.     {
  1544.       Lisp_Object v = Fmake_vector (make_number (size / sizeof (Atom)),
  1545.                     make_number (0));
  1546.       for (i = 0; i < size / sizeof (Atom); i++)
  1547.         Faset (v, make_number (i),
  1548.            x_atom_to_symbol (dpyinfo, display, ((Atom *) data) [i]));
  1549.       return v;
  1550.     }
  1551.     }
  1552.  
  1553.   /* Convert a single 16 or small 32 bit number to a Lisp_Int.
  1554.      If the number is > 16 bits, convert it to a cons of integers,
  1555.      16 bits in each half.
  1556.    */
  1557.   else if (format == 32 && size == sizeof (long))
  1558.     return long_to_cons (((unsigned long *) data) [0]);
  1559.   else if (format == 16 && size == sizeof (short))
  1560.     return make_number ((int) (((unsigned short *) data) [0]));
  1561.  
  1562.   /* Convert any other kind of data to a vector of numbers, represented
  1563.      as above (as an integer, or a cons of two 16 bit integers.)
  1564.    */
  1565.   else if (format == 16)
  1566.     {
  1567.       int i;
  1568.       Lisp_Object v;
  1569.       v = Fmake_vector (make_number (size / 2), make_number (0));
  1570.       for (i = 0; i < size / 2; i++)
  1571.     {
  1572.       int j = (int) ((unsigned short *) data) [i];
  1573.       Faset (v, make_number (i), make_number (j));
  1574.     }
  1575.       return v;
  1576.     }
  1577.   else
  1578.     {
  1579.       int i;
  1580.       Lisp_Object v = Fmake_vector (make_number (size / 4), make_number (0));
  1581.       for (i = 0; i < size / 4; i++)
  1582.     {
  1583.       unsigned long j = ((unsigned long *) data) [i];
  1584.       Faset (v, make_number (i), long_to_cons (j));
  1585.     }
  1586.       return v;
  1587.     }
  1588. }
  1589.  
  1590.  
  1591. /* Use xfree, not XFree, to free the data obtained with this function.  */
  1592.  
  1593. static void
  1594. lisp_data_to_selection_data (display, obj,
  1595.                  data_ret, type_ret, size_ret,
  1596.                  format_ret, nofree_ret)
  1597.      Display *display;
  1598.      Lisp_Object obj;
  1599.      unsigned char **data_ret;
  1600.      Atom *type_ret;
  1601.      unsigned int *size_ret;
  1602.      int *format_ret;
  1603.      int *nofree_ret;
  1604. {
  1605.   Lisp_Object type = Qnil;
  1606.   struct x_display_info *dpyinfo = x_display_info_for_display (display);
  1607.  
  1608.   *nofree_ret = 0;
  1609.  
  1610.   if (CONSP (obj) && SYMBOLP (XCONS (obj)->car))
  1611.     {
  1612.       type = XCONS (obj)->car;
  1613.       obj = XCONS (obj)->cdr;
  1614.       if (CONSP (obj) && NILP (XCONS (obj)->cdr))
  1615.     obj = XCONS (obj)->car;
  1616.     }
  1617.  
  1618.   if (EQ (obj, QNULL) || (EQ (type, QNULL)))
  1619.     {                /* This is not the same as declining */
  1620.       *format_ret = 32;
  1621.       *size_ret = 0;
  1622.       *data_ret = 0;
  1623.       type = QNULL;
  1624.     }
  1625.   else if (STRINGP (obj))
  1626.     {
  1627.       /* Since we are now handling multilingual text, we must consider
  1628.      sending back compound text.  */
  1629.       int charsets[MAX_CHARSET + 1];
  1630.       int num;
  1631.  
  1632.       *format_ret = 8;
  1633.       *size_ret = STRING_BYTES (XSTRING (obj));
  1634.       *data_ret = XSTRING (obj)->data;
  1635.       bzero (charsets, (MAX_CHARSET + 1) * sizeof (int));
  1636.       num = ((*size_ret <= 1    /* Check the possibility of short cut.  */
  1637.           || !STRING_MULTIBYTE (obj)
  1638.           || *size_ret == XSTRING (obj)->size)
  1639.          ? 0
  1640.          : find_charset_in_str (*data_ret, *size_ret, charsets, Qnil, 1));
  1641.  
  1642.       if (!num || (num == 1 && charsets[CHARSET_ASCII]))
  1643.     {
  1644.       /* No multibyte character in OBJ.  We need not encode it.  */
  1645.       *nofree_ret = 1;
  1646.       if (NILP (type)) type = QSTRING;
  1647.       Vlast_coding_system_used = Qraw_text;
  1648.     }
  1649.       else
  1650.     {
  1651.       /* We must encode contents of OBJ to compound text format.
  1652.              The format is compatible with what the target `STRING'
  1653.              expects if OBJ contains only ASCII and Latin-1
  1654.              characters.  */
  1655.       int bufsize;
  1656.       unsigned char *buf;
  1657.       struct coding_system coding;
  1658.  
  1659.       if (NILP (Vnext_selection_coding_system))
  1660.         Vnext_selection_coding_system = Vselection_coding_system;
  1661.       setup_coding_system
  1662.         (Fcheck_coding_system (Vnext_selection_coding_system), &coding);
  1663.       Vnext_selection_coding_system = Qnil;
  1664.       coding.mode |= CODING_MODE_LAST_BLOCK;
  1665.       bufsize = encoding_buffer_size (&coding, *size_ret);
  1666.       buf = (unsigned char *) xmalloc (bufsize);
  1667.       encode_coding (&coding, *data_ret, buf, *size_ret, bufsize);
  1668.       *size_ret = coding.produced;
  1669.       *data_ret = buf;
  1670.           if (charsets[charset_latin_iso8859_1]
  1671.           && (num == 1 || (num == 2 && charsets[CHARSET_ASCII])))
  1672.         {
  1673.           /* Ok, we can return it as `STRING'.  */
  1674.           if (NILP (type)) type = QSTRING;
  1675.         }
  1676.       else
  1677.         {
  1678.           /* We must return it as `COMPOUND_TEXT'.  */
  1679.           if (NILP (type)) type = QCOMPOUND_TEXT;
  1680.         }
  1681.       Vlast_coding_system_used = coding.symbol;
  1682.     }
  1683.     }
  1684.   else if (SYMBOLP (obj))
  1685.     {
  1686.       *format_ret = 32;
  1687.       *size_ret = 1;
  1688.       *data_ret = (unsigned char *) xmalloc (sizeof (Atom) + 1);
  1689.       (*data_ret) [sizeof (Atom)] = 0;
  1690.       (*(Atom **) data_ret) [0] = symbol_to_x_atom (dpyinfo, display, obj);
  1691.       if (NILP (type)) type = QATOM;
  1692.     }
  1693.   else if (INTEGERP (obj)
  1694.        && XINT (obj) < 0xFFFF
  1695.        && XINT (obj) > -0xFFFF)
  1696.     {
  1697.       *format_ret = 16;
  1698.       *size_ret = 1;
  1699.       *data_ret = (unsigned char *) xmalloc (sizeof (short) + 1);
  1700.       (*data_ret) [sizeof (short)] = 0;
  1701.       (*(short **) data_ret) [0] = (short) XINT (obj);
  1702.       if (NILP (type)) type = QINTEGER;
  1703.     }
  1704.   else if (INTEGERP (obj)
  1705.        || (CONSP (obj) && INTEGERP (XCONS (obj)->car)
  1706.            && (INTEGERP (XCONS (obj)->cdr)
  1707.            || (CONSP (XCONS (obj)->cdr)
  1708.                && INTEGERP (XCONS (XCONS (obj)->cdr)->car)))))
  1709.     {
  1710.       *format_ret = 32;
  1711.       *size_ret = 1;
  1712.       *data_ret = (unsigned char *) xmalloc (sizeof (long) + 1);
  1713.       (*data_ret) [sizeof (long)] = 0;
  1714.       (*(unsigned long **) data_ret) [0] = cons_to_long (obj);
  1715.       if (NILP (type)) type = QINTEGER;
  1716.     }
  1717.   else if (VECTORP (obj))
  1718.     {
  1719.       /* Lisp_Vectors may represent a set of ATOMs;
  1720.      a set of 16 or 32 bit INTEGERs;
  1721.      or a set of ATOM_PAIRs (represented as [[A1 A2] [A3 A4] ...]
  1722.        */
  1723.       int i;
  1724.  
  1725.       if (SYMBOLP (XVECTOR (obj)->contents [0]))
  1726.     /* This vector is an ATOM set */
  1727.     {
  1728.       if (NILP (type)) type = QATOM;
  1729.       *size_ret = XVECTOR (obj)->size;
  1730.       *format_ret = 32;
  1731.       *data_ret = (unsigned char *) xmalloc ((*size_ret) * sizeof (Atom));
  1732.       for (i = 0; i < *size_ret; i++)
  1733.         if (SYMBOLP (XVECTOR (obj)->contents [i]))
  1734.           (*(Atom **) data_ret) [i]
  1735.         = symbol_to_x_atom (dpyinfo, display, XVECTOR (obj)->contents [i]);
  1736.         else
  1737.           Fsignal (Qerror, /* Qselection_error */
  1738.                Fcons (build_string
  1739.            ("all elements of selection vector must have same type"),
  1740.                   Fcons (obj, Qnil)));
  1741.     }
  1742. #if 0 /* #### MULTIPLE doesn't work yet */
  1743.       else if (VECTORP (XVECTOR (obj)->contents [0]))
  1744.     /* This vector is an ATOM_PAIR set */
  1745.     {
  1746.       if (NILP (type)) type = QATOM_PAIR;
  1747.       *size_ret = XVECTOR (obj)->size;
  1748.       *format_ret = 32;
  1749.       *data_ret = (unsigned char *)
  1750.         xmalloc ((*size_ret) * sizeof (Atom) * 2);
  1751.       for (i = 0; i < *size_ret; i++)
  1752.         if (VECTORP (XVECTOR (obj)->contents [i]))
  1753.           {
  1754.         Lisp_Object pair = XVECTOR (obj)->contents [i];
  1755.         if (XVECTOR (pair)->size != 2)
  1756.           Fsignal (Qerror,
  1757.                Fcons (build_string 
  1758.        ("elements of the vector must be vectors of exactly two elements"),
  1759.                   Fcons (pair, Qnil)));
  1760.         
  1761.         (*(Atom **) data_ret) [i * 2]
  1762.           = symbol_to_x_atom (dpyinfo, display,
  1763.                       XVECTOR (pair)->contents [0]);
  1764.         (*(Atom **) data_ret) [(i * 2) + 1]
  1765.           = symbol_to_x_atom (dpyinfo, display,
  1766.                       XVECTOR (pair)->contents [1]);
  1767.           }
  1768.         else
  1769.           Fsignal (Qerror,
  1770.                Fcons (build_string
  1771.            ("all elements of the vector must be of the same type"),
  1772.                   Fcons (obj, Qnil)));
  1773.       
  1774.     }
  1775. #endif
  1776.       else
  1777.     /* This vector is an INTEGER set, or something like it */
  1778.     {
  1779.       *size_ret = XVECTOR (obj)->size;
  1780.       if (NILP (type)) type = QINTEGER;
  1781.       *format_ret = 16;
  1782.       for (i = 0; i < *size_ret; i++)
  1783.         if (CONSP (XVECTOR (obj)->contents [i]))
  1784.           *format_ret = 32;
  1785.         else if (!INTEGERP (XVECTOR (obj)->contents [i]))
  1786.           Fsignal (Qerror, /* Qselection_error */
  1787.                Fcons (build_string
  1788.     ("elements of selection vector must be integers or conses of integers"),
  1789.                   Fcons (obj, Qnil)));
  1790.  
  1791.       *data_ret = (unsigned char *) xmalloc (*size_ret * (*format_ret/8));
  1792.       for (i = 0; i < *size_ret; i++)
  1793.         if (*format_ret == 32)
  1794.           (*((unsigned long **) data_ret)) [i]
  1795.         = cons_to_long (XVECTOR (obj)->contents [i]);
  1796.         else
  1797.           (*((unsigned short **) data_ret)) [i]
  1798.         = (unsigned short) cons_to_long (XVECTOR (obj)->contents [i]);
  1799.     }
  1800.     }
  1801.   else
  1802.     Fsignal (Qerror, /* Qselection_error */
  1803.          Fcons (build_string ("unrecognised selection data"),
  1804.             Fcons (obj, Qnil)));
  1805.  
  1806.   *type_ret = symbol_to_x_atom (dpyinfo, display, type);
  1807. }
  1808.  
  1809. static Lisp_Object
  1810. clean_local_selection_data (obj)
  1811.      Lisp_Object obj;
  1812. {
  1813.   if (CONSP (obj)
  1814.       && INTEGERP (XCONS (obj)->car)
  1815.       && CONSP (XCONS (obj)->cdr)
  1816.       && INTEGERP (XCONS (XCONS (obj)->cdr)->car)
  1817.       && NILP (XCONS (XCONS (obj)->cdr)->cdr))
  1818.     obj = Fcons (XCONS (obj)->car, XCONS (obj)->cdr);
  1819.  
  1820.   if (CONSP (obj)
  1821.       && INTEGERP (XCONS (obj)->car)
  1822.       && INTEGERP (XCONS (obj)->cdr))
  1823.     {
  1824.       if (XINT (XCONS (obj)->car) == 0)
  1825.     return XCONS (obj)->cdr;
  1826.       if (XINT (XCONS (obj)->car) == -1)
  1827.     return make_number (- XINT (XCONS (obj)->cdr));
  1828.     }
  1829.   if (VECTORP (obj))
  1830.     {
  1831.       int i;
  1832.       int size = XVECTOR (obj)->size;
  1833.       Lisp_Object copy;
  1834.       if (size == 1)
  1835.     return clean_local_selection_data (XVECTOR (obj)->contents [0]);
  1836.       copy = Fmake_vector (make_number (size), Qnil);
  1837.       for (i = 0; i < size; i++)
  1838.     XVECTOR (copy)->contents [i]
  1839.       = clean_local_selection_data (XVECTOR (obj)->contents [i]);
  1840.       return copy;
  1841.     }
  1842.   return obj;
  1843. }
  1844.  
  1845. /* Called from XTread_socket to handle SelectionNotify events.
  1846.    If it's the selection we are waiting for, stop waiting
  1847.    by setting the car of reading_selection_reply to non-nil.
  1848.    We store t there if the reply is successful, lambda if not.  */
  1849.  
  1850. void
  1851. x_handle_selection_notify (event)
  1852.      XSelectionEvent *event;
  1853. {
  1854.   if (event->requestor != reading_selection_window)
  1855.     return;
  1856.   if (event->selection != reading_which_selection)
  1857.     return;
  1858.  
  1859.   XCONS (reading_selection_reply)->car
  1860.     = (event->property != 0 ? Qt : Qlambda);
  1861. }
  1862.  
  1863.  
  1864. DEFUN ("x-own-selection-internal", Fx_own_selection_internal,
  1865.   Sx_own_selection_internal, 2, 2, 0,
  1866.   "Assert an X selection of the given TYPE with the given VALUE.\n\
  1867. TYPE is a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD'.\n\
  1868. \(Those are literal upper-case symbol names, since that's what X expects.)\n\
  1869. VALUE is typically a string, or a cons of two markers, but may be\n\
  1870. anything that the functions on `selection-converter-alist' know about.")
  1871.   (selection_name, selection_value)
  1872.      Lisp_Object selection_name, selection_value;
  1873. {
  1874.   check_x ();
  1875.   CHECK_SYMBOL (selection_name, 0);
  1876.   if (NILP (selection_value)) error ("selection-value may not be nil");
  1877.   x_own_selection (selection_name, selection_value);
  1878.   return selection_value;
  1879. }
  1880.  
  1881.  
  1882. /* Request the selection value from the owner.  If we are the owner,
  1883.    simply return our selection value.  If we are not the owner, this
  1884.    will block until all of the data has arrived.  */
  1885.  
  1886. DEFUN ("x-get-selection-internal", Fx_get_selection_internal,
  1887.   Sx_get_selection_internal, 2, 2, 0,
  1888.   "Return text selected from some X window.\n\
  1889. SELECTION is a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD'.\n\
  1890. \(Those are literal upper-case symbol names, since that's what X expects.)\n\
  1891. TYPE is the type of data desired, typically `STRING'.")
  1892.   (selection_symbol, target_type)
  1893.      Lisp_Object selection_symbol, target_type;
  1894. {
  1895.   Lisp_Object val = Qnil;
  1896.   struct gcpro gcpro1, gcpro2;
  1897.   GCPRO2 (target_type, val); /* we store newly consed data into these */
  1898.   check_x ();
  1899.   CHECK_SYMBOL (selection_symbol, 0);
  1900.  
  1901. #if 0 /* #### MULTIPLE doesn't work yet */
  1902.   if (CONSP (target_type)
  1903.       && XCONS (target_type)->car == QMULTIPLE)
  1904.     {
  1905.       CHECK_VECTOR (XCONS (target_type)->cdr, 0);
  1906.       /* So we don't destructively modify this...  */
  1907.       target_type = copy_multiple_data (target_type);
  1908.     }
  1909.   else
  1910. #endif
  1911.     CHECK_SYMBOL (target_type, 0);
  1912.  
  1913.   val = x_get_local_selection (selection_symbol, target_type);
  1914.  
  1915.   if (NILP (val))
  1916.     {
  1917.       val = x_get_foreign_selection (selection_symbol, target_type);
  1918.       goto DONE;
  1919.     }
  1920.  
  1921.   if (CONSP (val)
  1922.       && SYMBOLP (XCONS (val)->car))
  1923.     {
  1924.       val = XCONS (val)->cdr;
  1925.       if (CONSP (val) && NILP (XCONS (val)->cdr))
  1926.     val = XCONS (val)->car;
  1927.     }
  1928.   val = clean_local_selection_data (val);
  1929.  DONE:
  1930.   UNGCPRO;
  1931.   return val;
  1932. }
  1933.  
  1934. DEFUN ("x-disown-selection-internal", Fx_disown_selection_internal,
  1935.   Sx_disown_selection_internal, 1, 2, 0,
  1936.   "If we own the selection SELECTION, disown it.\n\
  1937. Disowning it means there is no such selection.")
  1938.   (selection, time)
  1939.      Lisp_Object selection;
  1940.      Lisp_Object time;
  1941. {
  1942.   Time timestamp;
  1943.   Atom selection_atom;
  1944.   struct selection_input_event event;
  1945.   Display *display;
  1946.   struct x_display_info *dpyinfo;
  1947.  
  1948.   check_x ();
  1949.   display = FRAME_X_DISPLAY (selected_frame);
  1950.   dpyinfo = FRAME_X_DISPLAY_INFO (selected_frame);
  1951.   CHECK_SYMBOL (selection, 0);
  1952.   if (NILP (time))
  1953.     timestamp = last_event_timestamp;
  1954.   else
  1955.     timestamp = cons_to_long (time);
  1956.  
  1957.   if (NILP (assq_no_quit (selection, Vselection_alist)))
  1958.     return Qnil;  /* Don't disown the selection when we're not the owner.  */
  1959.  
  1960.   selection_atom = symbol_to_x_atom (dpyinfo, display, selection);
  1961.  
  1962.   BLOCK_INPUT;
  1963.   XSetSelectionOwner (display, selection_atom, None, timestamp);
  1964.   UNBLOCK_INPUT;
  1965.  
  1966.   /* It doesn't seem to be guaranteed that a SelectionClear event will be
  1967.      generated for a window which owns the selection when that window sets
  1968.      the selection owner to None.  The NCD server does, the MIT Sun4 server
  1969.      doesn't.  So we synthesize one; this means we might get two, but
  1970.      that's ok, because the second one won't have any effect.  */
  1971.   SELECTION_EVENT_DISPLAY (&event) = display;
  1972.   SELECTION_EVENT_SELECTION (&event) = selection_atom;
  1973.   SELECTION_EVENT_TIME (&event) = timestamp;
  1974.   x_handle_selection_clear ((struct input_event *) &event);
  1975.  
  1976.   return Qt;
  1977. }
  1978.  
  1979. /* Get rid of all the selections in buffer BUFFER.
  1980.    This is used when we kill a buffer.  */
  1981.  
  1982. void
  1983. x_disown_buffer_selections (buffer)
  1984.      Lisp_Object buffer;
  1985. {
  1986.   Lisp_Object tail;
  1987.   struct buffer *buf = XBUFFER (buffer);
  1988.  
  1989.   for (tail = Vselection_alist; CONSP (tail); tail = XCONS (tail)->cdr)
  1990.     {
  1991.       Lisp_Object elt, value;
  1992.       elt = XCONS (tail)->car;
  1993.       value = XCONS (elt)->cdr;
  1994.       if (CONSP (value) && MARKERP (XCONS (value)->car)
  1995.       && XMARKER (XCONS (value)->car)->buffer == buf)
  1996.     Fx_disown_selection_internal (XCONS (elt)->car, Qnil);
  1997.     }
  1998. }
  1999.  
  2000. DEFUN ("x-selection-owner-p", Fx_selection_owner_p, Sx_selection_owner_p,
  2001.   0, 1, 0,
  2002.   "Whether the current Emacs process owns the given X Selection.\n\
  2003. The arg should be the name of the selection in question, typically one of\n\
  2004. the symbols `PRIMARY', `SECONDARY', or `CLIPBOARD'.\n\
  2005. \(Those are literal upper-case symbol names, since that's what X expects.)\n\
  2006. For convenience, the symbol nil is the same as `PRIMARY',\n\
  2007. and t is the same as `SECONDARY'.)")
  2008.   (selection)
  2009.      Lisp_Object selection;
  2010. {
  2011.   check_x ();
  2012.   CHECK_SYMBOL (selection, 0);
  2013.   if (EQ (selection, Qnil)) selection = QPRIMARY;
  2014.   if (EQ (selection, Qt)) selection = QSECONDARY;
  2015.   
  2016.   if (NILP (Fassq (selection, Vselection_alist)))
  2017.     return Qnil;
  2018.   return Qt;
  2019. }
  2020.  
  2021. DEFUN ("x-selection-exists-p", Fx_selection_exists_p, Sx_selection_exists_p,
  2022.   0, 1, 0,
  2023.   "Whether there is an owner for the given X Selection.\n\
  2024. The arg should be the name of the selection in question, typically one of\n\
  2025. the symbols `PRIMARY', `SECONDARY', or `CLIPBOARD'.\n\
  2026. \(Those are literal upper-case symbol names, since that's what X expects.)\n\
  2027. For convenience, the symbol nil is the same as `PRIMARY',\n\
  2028. and t is the same as `SECONDARY'.)")
  2029.   (selection)
  2030.      Lisp_Object selection;
  2031. {
  2032.   Window owner;
  2033.   Atom atom;
  2034.   Display *dpy;
  2035.  
  2036.   /* It should be safe to call this before we have an X frame.  */
  2037.   if (! FRAME_X_P (selected_frame))
  2038.     return Qnil;
  2039.  
  2040.   dpy = FRAME_X_DISPLAY (selected_frame);
  2041.   CHECK_SYMBOL (selection, 0);
  2042.   if (!NILP (Fx_selection_owner_p (selection)))
  2043.     return Qt;
  2044.   if (EQ (selection, Qnil)) selection = QPRIMARY;
  2045.   if (EQ (selection, Qt)) selection = QSECONDARY;
  2046.   atom = symbol_to_x_atom (FRAME_X_DISPLAY_INFO (selected_frame),
  2047.                dpy, selection);
  2048.   if (atom == 0)
  2049.     return Qnil;
  2050.   BLOCK_INPUT;
  2051.   owner = XGetSelectionOwner (dpy, atom);
  2052.   UNBLOCK_INPUT;
  2053.   return (owner ? Qt : Qnil);
  2054. }
  2055.  
  2056.  
  2057. #ifdef CUT_BUFFER_SUPPORT
  2058.  
  2059. /* Ensure that all 8 cut buffers exist.  ICCCM says we gotta...  */
  2060. static void
  2061. initialize_cut_buffers (display, window)
  2062.      Display *display;
  2063.      Window window;
  2064. {
  2065.   unsigned char *data = (unsigned char *) "";
  2066.   BLOCK_INPUT;
  2067. #define FROB(atom) XChangeProperty (display, window, atom, XA_STRING, 8, \
  2068.                     PropModeAppend, data, 0)
  2069.   FROB (XA_CUT_BUFFER0);
  2070.   FROB (XA_CUT_BUFFER1);
  2071.   FROB (XA_CUT_BUFFER2);
  2072.   FROB (XA_CUT_BUFFER3);
  2073.   FROB (XA_CUT_BUFFER4);
  2074.   FROB (XA_CUT_BUFFER5);
  2075.   FROB (XA_CUT_BUFFER6);
  2076.   FROB (XA_CUT_BUFFER7);
  2077. #undef FROB
  2078.   UNBLOCK_INPUT;
  2079. }
  2080.  
  2081.  
  2082. #define CHECK_CUT_BUFFER(symbol,n)                    \
  2083.   { CHECK_SYMBOL ((symbol), (n));                    \
  2084.     if (!EQ((symbol), QCUT_BUFFER0) && !EQ((symbol), QCUT_BUFFER1)    \
  2085.     && !EQ((symbol), QCUT_BUFFER2) && !EQ((symbol), QCUT_BUFFER3)    \
  2086.     && !EQ((symbol), QCUT_BUFFER4) && !EQ((symbol), QCUT_BUFFER5)    \
  2087.     && !EQ((symbol), QCUT_BUFFER6) && !EQ((symbol), QCUT_BUFFER7))    \
  2088.       Fsignal (Qerror,                            \
  2089.            Fcons (build_string ("doesn't name a cut buffer"),    \
  2090.                  Fcons ((symbol), Qnil)));            \
  2091.   }
  2092.  
  2093. DEFUN ("x-get-cut-buffer-internal", Fx_get_cut_buffer_internal,
  2094.   Sx_get_cut_buffer_internal, 1, 1, 0,
  2095.   "Returns the value of the named cut buffer (typically CUT_BUFFER0).")
  2096.   (buffer)
  2097.      Lisp_Object buffer;
  2098. {
  2099.   Window window;
  2100.   Atom buffer_atom;
  2101.   unsigned char *data;
  2102.   int bytes;
  2103.   Atom type;
  2104.   int format;
  2105.   unsigned long size;
  2106.   Lisp_Object ret;
  2107.   Display *display;
  2108.   struct x_display_info *dpyinfo;
  2109.  
  2110.   check_x ();
  2111.   display = FRAME_X_DISPLAY (selected_frame);
  2112.   dpyinfo = FRAME_X_DISPLAY_INFO (selected_frame);
  2113.   window = RootWindow (display, 0); /* Cut buffers are on screen 0 */
  2114.   CHECK_CUT_BUFFER (buffer, 0);
  2115.   buffer_atom = symbol_to_x_atom (dpyinfo, display, buffer);
  2116.  
  2117.   x_get_window_property (display, window, buffer_atom, &data, &bytes,
  2118.              &type, &format, &size, 0);
  2119.   if (!data || !format)
  2120.     return Qnil;
  2121.   
  2122.   if (format != 8 || type != XA_STRING)
  2123.     Fsignal (Qerror,
  2124.          Fcons (build_string ("cut buffer doesn't contain 8-bit data"),
  2125.             Fcons (x_atom_to_symbol (dpyinfo, display, type),
  2126.                Fcons (make_number (format), Qnil))));
  2127.  
  2128.   ret = (bytes ? make_string ((char *) data, bytes) : Qnil);
  2129.   /* Use xfree, not XFree, because x_get_window_property
  2130.      calls xmalloc itself.  */
  2131.   xfree (data);
  2132.   return ret;
  2133. }
  2134.  
  2135.  
  2136. DEFUN ("x-store-cut-buffer-internal", Fx_store_cut_buffer_internal,
  2137.   Sx_store_cut_buffer_internal, 2, 2, 0,
  2138.   "Sets the value of the named cut buffer (typically CUT_BUFFER0).")
  2139.   (buffer, string)
  2140.      Lisp_Object buffer, string;
  2141. {
  2142.   Window window;
  2143.   Atom buffer_atom;
  2144.   unsigned char *data;
  2145.   int bytes;
  2146.   int bytes_remaining;
  2147.   int max_bytes;
  2148.   Display *display;
  2149.  
  2150.   check_x ();
  2151.   display = FRAME_X_DISPLAY (selected_frame);
  2152.   window = RootWindow (display, 0); /* Cut buffers are on screen 0 */
  2153.  
  2154.   max_bytes = SELECTION_QUANTUM (display);
  2155.   if (max_bytes > MAX_SELECTION_QUANTUM)
  2156.     max_bytes = MAX_SELECTION_QUANTUM;
  2157.  
  2158.   CHECK_CUT_BUFFER (buffer, 0);
  2159.   CHECK_STRING (string, 0);
  2160.   buffer_atom = symbol_to_x_atom (FRAME_X_DISPLAY_INFO (selected_frame),
  2161.                   display, buffer);
  2162.   data = (unsigned char *) XSTRING (string)->data;
  2163.   bytes = STRING_BYTES (XSTRING (string));
  2164.   bytes_remaining = bytes;
  2165.  
  2166.   if (! FRAME_X_DISPLAY_INFO (selected_frame)->cut_buffers_initialized)
  2167.     {
  2168.       initialize_cut_buffers (display, window);
  2169.       FRAME_X_DISPLAY_INFO (selected_frame)->cut_buffers_initialized = 1;
  2170.     }
  2171.  
  2172.   BLOCK_INPUT;
  2173.  
  2174.   /* Don't mess up with an empty value.  */
  2175.   if (!bytes_remaining)
  2176.     XChangeProperty (display, window, buffer_atom, XA_STRING, 8,
  2177.              PropModeReplace, data, 0);
  2178.  
  2179.   while (bytes_remaining)
  2180.     {
  2181.       int chunk = (bytes_remaining < max_bytes
  2182.            ? bytes_remaining : max_bytes);
  2183.       XChangeProperty (display, window, buffer_atom, XA_STRING, 8,
  2184.                (bytes_remaining == bytes
  2185.             ? PropModeReplace
  2186.             : PropModeAppend),
  2187.                data, chunk);
  2188.       data += chunk;
  2189.       bytes_remaining -= chunk;
  2190.     }
  2191.   UNBLOCK_INPUT;
  2192.   return string;
  2193. }
  2194.  
  2195.  
  2196. DEFUN ("x-rotate-cut-buffers-internal", Fx_rotate_cut_buffers_internal,
  2197.   Sx_rotate_cut_buffers_internal, 1, 1, 0,
  2198.   "Rotate the values of the cut buffers by the given number of step.\n\
  2199. Positive means shift the values forward, negative means backward.")
  2200.   (n)
  2201.      Lisp_Object n;
  2202. {
  2203.   Window window;
  2204.   Atom props[8];
  2205.   Display *display;
  2206.  
  2207.   check_x ();
  2208.   display = FRAME_X_DISPLAY (selected_frame);
  2209.   window = RootWindow (display, 0); /* Cut buffers are on screen 0 */
  2210.   CHECK_NUMBER (n, 0);
  2211.   if (XINT (n) == 0)
  2212.     return n;
  2213.   if (! FRAME_X_DISPLAY_INFO (selected_frame)->cut_buffers_initialized)
  2214.     {
  2215.       initialize_cut_buffers (display, window);
  2216.       FRAME_X_DISPLAY_INFO (selected_frame)->cut_buffers_initialized = 1;
  2217.     }
  2218.  
  2219.   props[0] = XA_CUT_BUFFER0;
  2220.   props[1] = XA_CUT_BUFFER1;
  2221.   props[2] = XA_CUT_BUFFER2;
  2222.   props[3] = XA_CUT_BUFFER3;
  2223.   props[4] = XA_CUT_BUFFER4;
  2224.   props[5] = XA_CUT_BUFFER5;
  2225.   props[6] = XA_CUT_BUFFER6;
  2226.   props[7] = XA_CUT_BUFFER7;
  2227.   BLOCK_INPUT;
  2228.   XRotateWindowProperties (display, window, props, 8, XINT (n));
  2229.   UNBLOCK_INPUT;
  2230.   return n;
  2231. }
  2232.  
  2233. #endif
  2234.  
  2235. void
  2236. syms_of_xselect ()
  2237. {
  2238.   defsubr (&Sx_get_selection_internal);
  2239.   defsubr (&Sx_own_selection_internal);
  2240.   defsubr (&Sx_disown_selection_internal);
  2241.   defsubr (&Sx_selection_owner_p);
  2242.   defsubr (&Sx_selection_exists_p);
  2243.  
  2244. #ifdef CUT_BUFFER_SUPPORT
  2245.   defsubr (&Sx_get_cut_buffer_internal);
  2246.   defsubr (&Sx_store_cut_buffer_internal);
  2247.   defsubr (&Sx_rotate_cut_buffers_internal);
  2248. #endif
  2249.  
  2250.   reading_selection_reply = Fcons (Qnil, Qnil);
  2251.   staticpro (&reading_selection_reply);
  2252.   reading_selection_window = 0;
  2253.   reading_which_selection = 0;
  2254.  
  2255.   property_change_wait_list = 0;
  2256.   prop_location_identifier = 0;
  2257.   property_change_reply = Fcons (Qnil, Qnil);
  2258.   staticpro (&property_change_reply);
  2259.  
  2260.   Vselection_alist = Qnil;
  2261.   staticpro (&Vselection_alist);
  2262.  
  2263.   DEFVAR_LISP ("selection-converter-alist", &Vselection_converter_alist,
  2264.     "An alist associating X Windows selection-types with functions.\n\
  2265. These functions are called to convert the selection, with three args:\n\
  2266. the name of the selection (typically `PRIMARY', `SECONDARY', or `CLIPBOARD');\n\
  2267. a desired type to which the selection should be converted;\n\
  2268. and the local selection value (whatever was given to `x-own-selection').\n\
  2269. \n\
  2270. The function should return the value to send to the X server\n\
  2271. \(typically a string).  A return value of nil\n\
  2272. means that the conversion could not be done.\n\
  2273. A return value which is the symbol `NULL'\n\
  2274. means that a side-effect was executed,\n\
  2275. and there is no meaningful selection value.");
  2276.   Vselection_converter_alist = Qnil;
  2277.  
  2278.   DEFVAR_LISP ("x-lost-selection-hooks", &Vx_lost_selection_hooks,
  2279.     "A list of functions to be called when Emacs loses an X selection.\n\
  2280. \(This happens when some other X client makes its own selection\n\
  2281. or when a Lisp program explicitly clears the selection.)\n\
  2282. The functions are called with one argument, the selection type\n\
  2283. \(a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD').");
  2284.   Vx_lost_selection_hooks = Qnil;
  2285.  
  2286.   DEFVAR_LISP ("x-sent-selection-hooks", &Vx_sent_selection_hooks,
  2287.     "A list of functions to be called when Emacs answers a selection request.\n\
  2288. The functions are called with four arguments:\n\
  2289.   - the selection name (typically `PRIMARY', `SECONDARY', or `CLIPBOARD');\n\
  2290.   - the selection-type which Emacs was asked to convert the\n\
  2291.     selection into before sending (for example, `STRING' or `LENGTH');\n\
  2292.   - a flag indicating success or failure for responding to the request.\n\
  2293. We might have failed (and declined the request) for any number of reasons,\n\
  2294. including being asked for a selection that we no longer own, or being asked\n\
  2295. to convert into a type that we don't know about or that is inappropriate.\n\
  2296. This hook doesn't let you change the behavior of Emacs's selection replies,\n\
  2297. it merely informs you that they have happened.");
  2298.   Vx_sent_selection_hooks = Qnil;
  2299.  
  2300.   DEFVAR_LISP ("selection-coding-system", &Vselection_coding_system,
  2301.     "Coding system for communicating with other X clients.\n\
  2302. When sending or receiving text via cut_buffer, selection, and clipboard,\n\
  2303. the text is encoded or decoded by this coding system.\n\
  2304. A default value is `compound-text'");
  2305.   Vselection_coding_system = intern ("compound-text");
  2306.  
  2307.   DEFVAR_LISP ("next-selection-coding-system", &Vnext_selection_coding_system,
  2308.     "Coding system for the next communication with other X clients.\n\
  2309. Usually, `selection-coding-system' is used for communicating with\n\
  2310. other X clients.   But, if this variable is set, it is used for the\n\
  2311. next communication only.   After the communication, this variable is\n\
  2312. set to nil.");
  2313.   Vnext_selection_coding_system = Qnil;
  2314.  
  2315.   DEFVAR_INT ("x-selection-timeout", &x_selection_timeout,
  2316.     "Number of milliseconds to wait for a selection reply.\n\
  2317. If the selection owner doesn't reply in this time, we give up.\n\
  2318. A value of 0 means wait as long as necessary.  This is initialized from the\n\
  2319. \"*selectionTimeout\" resource.");
  2320.   x_selection_timeout = 0;
  2321.  
  2322.   QPRIMARY   = intern ("PRIMARY");    staticpro (&QPRIMARY);
  2323.   QSECONDARY = intern ("SECONDARY");    staticpro (&QSECONDARY);
  2324.   QSTRING    = intern ("STRING");    staticpro (&QSTRING);
  2325.   QINTEGER   = intern ("INTEGER");    staticpro (&QINTEGER);
  2326.   QCLIPBOARD = intern ("CLIPBOARD");    staticpro (&QCLIPBOARD);
  2327.   QTIMESTAMP = intern ("TIMESTAMP");    staticpro (&QTIMESTAMP);
  2328.   QTEXT      = intern ("TEXT");     staticpro (&QTEXT);
  2329.   QCOMPOUND_TEXT = intern ("COMPOUND_TEXT"); staticpro (&QCOMPOUND_TEXT);
  2330.   QTIMESTAMP = intern ("TIMESTAMP");    staticpro (&QTIMESTAMP);
  2331.   QDELETE    = intern ("DELETE");    staticpro (&QDELETE);
  2332.   QMULTIPLE  = intern ("MULTIPLE");    staticpro (&QMULTIPLE);
  2333.   QINCR      = intern ("INCR");        staticpro (&QINCR);
  2334.   QEMACS_TMP = intern ("_EMACS_TMP_");    staticpro (&QEMACS_TMP);
  2335.   QTARGETS   = intern ("TARGETS");    staticpro (&QTARGETS);
  2336.   QATOM         = intern ("ATOM");        staticpro (&QATOM);
  2337.   QATOM_PAIR = intern ("ATOM_PAIR");    staticpro (&QATOM_PAIR);
  2338.   QNULL         = intern ("NULL");        staticpro (&QNULL);
  2339.  
  2340. #ifdef CUT_BUFFER_SUPPORT
  2341.   QCUT_BUFFER0 = intern ("CUT_BUFFER0"); staticpro (&QCUT_BUFFER0);
  2342.   QCUT_BUFFER1 = intern ("CUT_BUFFER1"); staticpro (&QCUT_BUFFER1);
  2343.   QCUT_BUFFER2 = intern ("CUT_BUFFER2"); staticpro (&QCUT_BUFFER2);
  2344.   QCUT_BUFFER3 = intern ("CUT_BUFFER3"); staticpro (&QCUT_BUFFER3);
  2345.   QCUT_BUFFER4 = intern ("CUT_BUFFER4"); staticpro (&QCUT_BUFFER4);
  2346.   QCUT_BUFFER5 = intern ("CUT_BUFFER5"); staticpro (&QCUT_BUFFER5);
  2347.   QCUT_BUFFER6 = intern ("CUT_BUFFER6"); staticpro (&QCUT_BUFFER6);
  2348.   QCUT_BUFFER7 = intern ("CUT_BUFFER7"); staticpro (&QCUT_BUFFER7);
  2349. #endif
  2350.  
  2351. }
  2352.