Mercurial > emacs
annotate src/=xselect.c.old @ 6063:233fffcfb6c8
(Fget_char_property): New function.
author | Karl Heuer <kwzh@gnu.org> |
---|---|
date | Thu, 24 Feb 1994 19:18:32 +0000 |
parents | 04fb1d3d6992 |
children |
rev | line source |
---|---|
159 | 1 /* X Selection processing for emacs |
1821
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
2 Copyright (C) 1990, 1992, 1993 Free Software Foundation. |
159 | 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 | |
648 | 8 the Free Software Foundation; either version 2, or (at your option) |
159 | 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, 675 Mass Ave, Cambridge, MA 02139, USA. */ | |
19 | |
20 #include "config.h" | |
21 #include "lisp.h" | |
22 #include "xterm.h" | |
641 | 23 #include "buffer.h" |
771 | 24 #include "frame.h" |
159 | 25 |
26 #ifdef HAVE_X11 | |
27 | |
28 /* Macros for X Selections */ | |
641 | 29 #define MAX_SELECTION(dpy) (((dpy)->max_request_size << 2) - 100) |
30 #define SELECTION_LENGTH(len,format) ((len) * ((format) >> 2)) | |
159 | 31 |
708 | 32 /* The timestamp of the last input event we received from the X server. */ |
33 unsigned long last_event_timestamp; | |
648 | 34 |
159 | 35 /* t if a mouse button is depressed. */ |
36 extern Lisp_Object Vmouse_grabbed; | |
37 | |
38 /* When emacs became the PRIMARY selection owner. */ | |
39 Time x_begin_selection_own; | |
40 | |
641 | 41 /* When emacs became the SECONDARY selection owner. */ |
42 Time x_begin_secondary_selection_own; | |
43 | |
159 | 44 /* When emacs became the CLIPBOARD selection owner. */ |
45 Time x_begin_clipboard_own; | |
46 | |
47 /* The value of the current CLIPBOARD selection. */ | |
48 Lisp_Object Vx_clipboard_value; | |
49 | |
50 /* The value of the current PRIMARY selection. */ | |
51 Lisp_Object Vx_selection_value; | |
52 | |
641 | 53 /* The value of the current SECONDARY selection. */ |
54 Lisp_Object Vx_secondary_selection_value; | |
55 | |
1268
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
56 /* Types of selections we may make. */ |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
57 Lisp_Object Qprimary, Qsecondary, Qclipboard; |
641 | 58 |
59 /* Emacs' selection property identifiers. */ | |
159 | 60 Atom Xatom_emacs_selection; |
641 | 61 Atom Xatom_emacs_secondary_selection; |
159 | 62 |
63 /* Clipboard selection atom. */ | |
64 Atom Xatom_clipboard_selection; | |
65 | |
66 /* Clipboard atom. */ | |
67 Atom Xatom_clipboard; | |
68 | |
69 /* Atom for indicating incremental selection transfer. */ | |
70 Atom Xatom_incremental; | |
71 | |
72 /* Atom for indicating multiple selection request list */ | |
73 Atom Xatom_multiple; | |
74 | |
75 /* Atom for what targets emacs handles. */ | |
76 Atom Xatom_targets; | |
77 | |
78 /* Atom for indicating timstamp selection request */ | |
79 Atom Xatom_timestamp; | |
80 | |
81 /* Atom requesting we delete our selection. */ | |
82 Atom Xatom_delete; | |
83 | |
84 /* Selection magic. */ | |
85 Atom Xatom_insert_selection; | |
86 | |
87 /* Type of property for INSERT_SELECTION. */ | |
88 Atom Xatom_pair; | |
89 | |
90 /* More selection magic. */ | |
91 Atom Xatom_insert_property; | |
92 | |
93 /* Atom for indicating property type TEXT */ | |
94 Atom Xatom_text; | |
95 | |
641 | 96 /* Kinds of protocol things we may receive. */ |
97 Atom Xatom_wm_take_focus; | |
98 Atom Xatom_wm_save_yourself; | |
99 Atom Xatom_wm_delete_window; | |
100 | |
101 /* Communication with window managers. */ | |
102 Atom Xatom_wm_protocols; | |
103 | |
159 | 104 /* These are to handle incremental selection transfer. */ |
105 Window incr_requestor; | |
106 Atom incr_property; | |
107 int incr_nbytes; | |
108 unsigned char *incr_value; | |
109 unsigned char *incr_ptr; | |
110 | |
1268
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
111 /* Declarations for handling cut buffers. |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
112 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
113 Whenever we set a cut buffer or read a cut buffer's value, we cache |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
114 it in cut_buffer_value. We look for PropertyNotify events about |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
115 the CUT_BUFFER properties, and invalidate our cache accordingly. |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
116 We ignore PropertyNotify events that we suspect were caused by our |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
117 own changes to the cut buffers, so we can keep the cache valid |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
118 longer. |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
119 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
120 IS ALL THIS HAIR WORTH IT? Well, these functions get called every |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
121 time an element goes into or is retrieved from the kill ring, and |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
122 those ought to be quick. It's not fun in time or space to wait for |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
123 50k cut buffers to fly back and forth across the net. */ |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
124 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
125 /* The number of CUT_BUFFER properties defined under X. */ |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
126 #define NUM_CUT_BUFFERS (8) |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
127 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
128 /* cut_buffer_atom[n] is the atom naming the nth cut buffer. */ |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
129 static Atom cut_buffer_atom[NUM_CUT_BUFFERS] = { |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
130 XA_CUT_BUFFER0, XA_CUT_BUFFER1, XA_CUT_BUFFER2, XA_CUT_BUFFER3, |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
131 XA_CUT_BUFFER4, XA_CUT_BUFFER5, XA_CUT_BUFFER6, XA_CUT_BUFFER7 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
132 }; |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
133 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
134 /* cut_buffer_value is an eight-element vector; |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
135 (aref cut_buffer_value n) is the cached value of cut buffer n, or |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
136 Qnil if cut buffer n is unset. */ |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
137 static Lisp_Object cut_buffer_value; |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
138 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
139 /* Bit N of cut_buffer_cached is true if (aref cut_buffer_value n) is |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
140 known to be valid. This is cleared by PropertyNotify events |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
141 handled by x_invalidate_cut_buffer_cache. It would be wonderful if |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
142 that routine could just set the appropriate element of |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
143 cut_buffer_value to some special value meaning "uncached", but that |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
144 would lose if a GC happened to be in progress. |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
145 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
146 Bit N of cut_buffer_just_set is true if cut buffer N has been set since |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
147 the last PropertyNotify event; since we get an event even when we set |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
148 the property ourselves, we should ignore one event after setting |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
149 a cut buffer, so we don't have to throw away our cache. */ |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
150 #ifdef __STDC__ |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
151 volatile |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
152 #endif |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
153 static cut_buffer_cached, cut_buffer_just_set; |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
154 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
155 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
156 /* Acquiring ownership of a selection. */ |
159 | 157 |
641 | 158 |
159 /* Request selection ownership if we do not already have it. */ | |
160 | |
161 static int | |
162 own_selection (selection_type, time) | |
163 Atom selection_type; | |
164 Time time; | |
165 { | |
166 Window owner_window, selecting_window; | |
167 | |
1529
d73ee126c15d
* xselect.c (own_selection): selection_type is an X Atom value,
Jim Blandy <jimb@redhat.com>
parents:
1268
diff
changeset
|
168 if ((selection_type == XA_PRIMARY |
d73ee126c15d
* xselect.c (own_selection): selection_type is an X Atom value,
Jim Blandy <jimb@redhat.com>
parents:
1268
diff
changeset
|
169 && !NILP (Vx_selection_value)) |
d73ee126c15d
* xselect.c (own_selection): selection_type is an X Atom value,
Jim Blandy <jimb@redhat.com>
parents:
1268
diff
changeset
|
170 || (selection_type == XA_SECONDARY |
d73ee126c15d
* xselect.c (own_selection): selection_type is an X Atom value,
Jim Blandy <jimb@redhat.com>
parents:
1268
diff
changeset
|
171 && !NILP (Vx_secondary_selection_value)) |
d73ee126c15d
* xselect.c (own_selection): selection_type is an X Atom value,
Jim Blandy <jimb@redhat.com>
parents:
1268
diff
changeset
|
172 || (selection_type == Xatom_clipboard |
d73ee126c15d
* xselect.c (own_selection): selection_type is an X Atom value,
Jim Blandy <jimb@redhat.com>
parents:
1268
diff
changeset
|
173 && !NILP (Vx_clipboard_value))) |
641 | 174 return 1; |
175 | |
1053
a411429c4140
* xselect.c: Use the FRAME_X_WINDOW macro, for readability.
Jim Blandy <jimb@redhat.com>
parents:
847
diff
changeset
|
176 selecting_window = FRAME_X_WINDOW (selected_frame); |
641 | 177 XSetSelectionOwner (x_current_display, selection_type, |
178 selecting_window, time); | |
179 owner_window = XGetSelectionOwner (x_current_display, selection_type); | |
180 | |
648 | 181 if (owner_window != selecting_window) |
641 | 182 return 0; |
183 | |
184 return 1; | |
185 } | |
186 | |
159 | 187 /* Become the selection owner and make our data the selection value. |
188 If we are already the owner, merely change data and timestamp values. | |
189 This avoids generating SelectionClear events for ourselves. */ | |
190 | |
1821
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
191 DEFUN ("x-set-selection", Fx_set_selection, Sx_set_selection, |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
192 2, 2, "", |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
193 "Set the value of SELECTION to STRING.\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
194 SELECTION may be `primary', `secondary', or `clipboard'.\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
195 \n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
196 Selections are a mechanism for cutting and pasting information between\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
197 X Windows clients. Emacs's kill ring commands set the `primary'\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
198 selection to the top string of the kill ring, making it available to\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
199 other clients, like xterm. Those commands also use the `primary'\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
200 selection to retrieve information from other clients.\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
201 \n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
202 According to the Inter-Client Communications Conventions Manual:\n\ |
708 | 203 \n\ |
1821
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
204 The `primary' selection \"... is used for all commands that take only a\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
205 single argument and is the principal means of communication between\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
206 clients that use the selection mechanism.\" In Emacs, this means\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
207 that the kill ring commands set the primary selection to the text\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
208 put in the kill ring.\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
209 \n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
210 The `secondary' selection \"... is used as the second argument to\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
211 commands taking two arguments (for example, `exchange primary and\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
212 secondary selections'), and as a means of obtaining data when there\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
213 is a primary selection and the user does not want to disturb it.\"\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
214 I am not sure how Emacs should use the secondary selection; if you\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
215 come up with ideas, this function will at least let you get at it.\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
216 \n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
217 The `clipboard' selection \"... is used to hold data that is being\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
218 transferred between clients, that is, data that usually is being\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
219 cut or copied, and then pasted.\" It seems that the `clipboard'\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
220 selection is for the most part equivalent to the `primary'\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
221 selection, so Emacs sets them both.\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
222 \n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
223 Also see `x-selection', and the `interprogram-cut-function' variable.") |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
224 (selection, string) |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
225 register Lisp_Object selection, string; |
159 | 226 { |
641 | 227 Atom selection_type; |
228 Lisp_Object val; | |
708 | 229 Time event_time = last_event_timestamp; |
159 | 230 CHECK_STRING (string, 0); |
231 | |
839 | 232 val = Qnil; |
233 | |
1821
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
234 if (NILP (selection) || EQ (selection, Qprimary)) |
159 | 235 { |
641 | 236 BLOCK_INPUT; |
237 if (own_selection (XA_PRIMARY, event_time)) | |
238 { | |
239 x_begin_selection_own = event_time; | |
240 val = Vx_selection_value = string; | |
241 } | |
708 | 242 UNBLOCK_INPUT; |
641 | 243 } |
1821
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
244 else if (EQ (selection, Qsecondary)) |
641 | 245 { |
246 BLOCK_INPUT; | |
247 if (own_selection (XA_SECONDARY, event_time)) | |
159 | 248 { |
641 | 249 x_begin_secondary_selection_own = event_time; |
250 val = Vx_secondary_selection_value = string; | |
159 | 251 } |
641 | 252 UNBLOCK_INPUT; |
159 | 253 } |
1821
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
254 else if (EQ (selection, Qclipboard)) |
641 | 255 { |
256 BLOCK_INPUT; | |
257 if (own_selection (Xatom_clipboard, event_time)) | |
258 { | |
708 | 259 x_begin_clipboard_own = event_time; |
641 | 260 val = Vx_clipboard_value = string; |
261 } | |
708 | 262 UNBLOCK_INPUT; |
263 } | |
641 | 264 else |
265 error ("Invalid X selection type"); | |
159 | 266 |
641 | 267 return val; |
159 | 268 } |
269 | |
270 /* Clear our selection ownership data, as some other client has | |
271 become the owner. */ | |
272 | |
273 void | |
274 x_disown_selection (old_owner, selection, changed_owner_time) | |
275 Window *old_owner; | |
276 Atom selection; | |
277 Time changed_owner_time; | |
278 { | |
771 | 279 struct frame *s = x_window_to_frame (old_owner); |
159 | 280 |
281 if (s) /* We are the owner */ | |
282 { | |
283 if (selection == XA_PRIMARY) | |
284 { | |
285 x_begin_selection_own = 0; | |
286 Vx_selection_value = Qnil; | |
287 } | |
641 | 288 else if (selection == XA_SECONDARY) |
289 { | |
290 x_begin_secondary_selection_own = 0; | |
291 Vx_secondary_selection_value = Qnil; | |
292 } | |
159 | 293 else if (selection == Xatom_clipboard) |
294 { | |
295 x_begin_clipboard_own = 0; | |
296 Vx_clipboard_value = Qnil; | |
297 } | |
298 else | |
299 abort (); | |
300 } | |
301 else | |
302 abort (); /* Inconsistent state. */ | |
303 } | |
304 | |
1268
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
305 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
306 /* Answering selection requests. */ |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
307 |
159 | 308 int x_selection_alloc_error; |
309 int x_converting_selection; | |
310 | |
1268
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
311 /* Reply to some client's request for our selection data. |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
312 Data is placed in a property supplied by the requesting window. |
159 | 313 |
314 If the data exceeds the maximum amount the server can send, | |
315 then prepare to send it incrementally, and reply to the client with | |
316 the total size of the data. | |
317 | |
318 But first, check for all the other crufty stuff we could get. */ | |
319 | |
320 void | |
321 x_answer_selection_request (event) | |
322 XSelectionRequestEvent event; | |
323 { | |
324 Time emacs_own_time; | |
325 Lisp_Object selection_value; | |
326 XSelectionEvent evt; | |
327 int format = 8; /* We have only byte sized (text) data. */ | |
328 | |
329 evt.type = SelectionNotify; /* Construct reply event */ | |
330 evt.display = event.display; | |
331 evt.requestor = event.requestor; | |
332 evt.selection = event.selection; | |
333 evt.time = event.time; | |
334 evt.target = event.target; | |
335 | |
336 if (event.selection == XA_PRIMARY) | |
337 { | |
338 emacs_own_time = x_begin_selection_own; | |
339 selection_value = Vx_selection_value; | |
340 } | |
641 | 341 else if (event.selection == XA_SECONDARY) |
342 { | |
343 emacs_own_time = x_begin_secondary_selection_own; | |
344 selection_value = Vx_secondary_selection_value; | |
345 } | |
159 | 346 else if (event.selection == Xatom_clipboard) |
347 { | |
348 emacs_own_time = x_begin_clipboard_own; | |
349 selection_value = Vx_clipboard_value; | |
350 } | |
351 else | |
352 abort (); | |
353 | |
354 if (event.time != CurrentTime | |
355 && event.time < emacs_own_time) | |
356 evt.property = None; | |
357 else | |
358 { | |
359 if (event.property == None) /* obsolete client */ | |
360 evt.property = event.target; | |
361 else | |
362 evt.property = event.property; | |
363 } | |
364 | |
365 if (event.target == Xatom_targets) /* Send List of target atoms */ | |
366 { | |
367 } | |
368 else if (event.target == Xatom_multiple) /* Recvd list: <target, prop> */ | |
369 { | |
370 Atom type; | |
371 int return_format; | |
372 unsigned long items, bytes_left; | |
373 unsigned char *data; | |
374 int result, i; | |
375 | |
641 | 376 if (event.property == 0 /* 0 == NILP */ |
159 | 377 || event.property == None) |
378 return; | |
379 | |
380 result = XGetWindowProperty (event.display, event.requestor, | |
381 event.property, 0L, 10000000L, | |
382 True, Xatom_pair, &type, &return_format, | |
383 &items, &bytes_left, &data); | |
384 | |
385 if (result == Success && type == Xatom_pair) | |
386 for (i = items; i > 0; i--) | |
387 { | |
388 /* Convert each element of the list. */ | |
389 } | |
390 | |
391 (void) XSendEvent (x_current_display, evt.requestor, False, | |
392 0L, (XEvent *) &evt); | |
393 return; | |
394 } | |
395 else if (event.target == Xatom_timestamp) /* Send ownership timestamp */ | |
396 { | |
397 if (! emacs_own_time) | |
398 abort (); | |
399 | |
400 format = 32; | |
401 XChangeProperty (evt.display, evt.requestor, evt.property, | |
402 evt.target, format, PropModeReplace, | |
641 | 403 (unsigned char *) &emacs_own_time, 1); |
159 | 404 return; |
405 } | |
406 else if (event.target == Xatom_delete) /* Delete our selection. */ | |
407 { | |
408 if (EQ (Qnil, selection_value)) | |
409 abort (); | |
410 | |
411 x_disown_selection (event.owner, event.selection, event.time); | |
412 | |
641 | 413 /* Now return property of type NILP, length 0. */ |
159 | 414 XChangeProperty (event.display, event.requestor, event.property, |
415 0, format, PropModeReplace, (unsigned char *) 0, 0); | |
416 return; | |
417 } | |
418 else if (event.target == Xatom_insert_selection) | |
419 { | |
420 Atom type; | |
421 int return_format; | |
422 unsigned long items, bytes_left; | |
423 unsigned char *data; | |
424 int result = XGetWindowProperty (event.display, event.requestor, | |
425 event.property, 0L, 10000000L, | |
426 True, Xatom_pair, &type, &return_format, | |
427 &items, &bytes_left, &data); | |
428 if (result == Success && type == Xatom_pair) | |
429 { | |
430 /* Convert the first atom to (a selection) to the target | |
431 indicated by the second atom. */ | |
432 } | |
433 } | |
434 else if (event.target == Xatom_insert_property) | |
435 { | |
436 Atom type; | |
437 int return_format; | |
438 unsigned long items, bytes_left; | |
439 unsigned char *data; | |
440 int result = XGetWindowProperty (event.display, event.requestor, | |
441 event.property, 0L, 10000000L, | |
442 True, XA_STRING, &type, &return_format, | |
443 &items, &bytes_left, &data); | |
444 | |
445 if (result == Success && type == XA_STRING && return_format == 8) | |
446 { | |
447 if (event.selection == Xatom_emacs_selection) | |
448 Vx_selection_value = make_string (data); | |
641 | 449 else if (event.selection == Xatom_emacs_secondary_selection) |
450 Vx_secondary_selection_value = make_string (data); | |
159 | 451 else if (event.selection == Xatom_clipboard_selection) |
452 Vx_clipboard_value = make_string (data); | |
453 else | |
454 abort (); | |
455 } | |
456 | |
457 return; | |
458 } | |
459 else if ((event.target == Xatom_text | |
460 || event.target == XA_STRING)) | |
461 { | |
462 int size = XSTRING (selection_value)->size; | |
463 unsigned char *data = XSTRING (selection_value)->data; | |
464 | |
465 if (EQ (Qnil, selection_value)) | |
466 abort (); | |
467 | |
468 /* Place data on requestor window's property. */ | |
469 if (SELECTION_LENGTH (size, format) | |
470 <= MAX_SELECTION (x_current_display)) | |
471 { | |
472 x_converting_selection = 1; | |
473 XChangeProperty (evt.display, evt.requestor, evt.property, | |
474 evt.target, format, PropModeReplace, | |
475 data, size); | |
476 if (x_selection_alloc_error) | |
477 { | |
478 x_selection_alloc_error = 0; | |
479 abort (); | |
480 } | |
481 x_converting_selection = 0; | |
482 } | |
483 else /* Send incrementally */ | |
484 { | |
485 evt.target = Xatom_incremental; | |
486 incr_requestor = evt.requestor; | |
487 incr_property = evt.property; | |
488 x_converting_selection = 1; | |
489 | |
490 /* Need to handle Alloc errors on these requests. */ | |
491 XChangeProperty (evt.display, incr_requestor, incr_property, | |
492 Xatom_incremental, 32, | |
493 PropModeReplace, | |
494 (unsigned char *) &size, 1); | |
495 if (x_selection_alloc_error) | |
496 { | |
497 x_selection_alloc_error = 0; | |
498 x_converting_selection = 0; | |
499 abort (); | |
500 /* Now abort the send. */ | |
501 } | |
502 | |
503 incr_nbytes = size; | |
504 incr_value = data; | |
505 incr_ptr = data; | |
506 | |
507 /* Ask for notification when requestor deletes property. */ | |
508 XSelectInput (x_current_display, incr_requestor, PropertyChangeMask); | |
509 | |
510 /* If we're sending incrementally, perhaps block here | |
511 until all sent? */ | |
512 } | |
513 } | |
514 else | |
515 evt.property = None; | |
516 | |
517 /* Don't do this if there was an Alloc error: abort the transfer | |
518 by sending None. */ | |
519 (void) XSendEvent (x_current_display, evt.requestor, False, | |
520 0L, (XEvent *) &evt); | |
521 } | |
522 | |
523 /* Send an increment of selection data in response to a PropertyNotify event. | |
524 The increment is placed in a property on the requestor's window. | |
525 When the requestor has processed the increment, it deletes the property, | |
526 which sends us another PropertyNotify event. | |
527 | |
528 When there is no more data to send, we send a zero-length increment. */ | |
529 | |
530 void | |
531 x_send_incremental (event) | |
532 XPropertyEvent event; | |
533 { | |
534 if (incr_requestor | |
535 && incr_requestor == event.window | |
536 && incr_property == event.atom | |
537 && event.state == PropertyDelete) | |
538 { | |
539 int format = 8; | |
540 int length = MAX_SELECTION (x_current_display); | |
541 int bytes_left = (incr_nbytes - (incr_ptr - incr_value)); | |
542 | |
543 if (length > bytes_left) /* Also sends 0 len when finished. */ | |
544 length = bytes_left; | |
545 XChangeProperty (x_current_display, incr_requestor, | |
546 incr_property, XA_STRING, format, | |
547 PropModeAppend, incr_ptr, length); | |
548 if (x_selection_alloc_error) | |
549 { | |
550 x_selection_alloc_error = 0; | |
551 x_converting_selection = 0; | |
552 /* Abandon the transmission. */ | |
553 abort (); | |
554 } | |
555 if (length > 0) | |
556 incr_ptr += length; | |
557 else | |
558 { /* Everything's sent */ | |
559 XSelectInput (x_current_display, incr_requestor, 0L); | |
560 incr_requestor = (Window) 0; | |
561 incr_property = (Atom) 0; | |
562 incr_nbytes = 0; | |
563 incr_value = (unsigned char *) 0; | |
564 incr_ptr = (unsigned char *) 0; | |
565 x_converting_selection = 0; | |
566 } | |
567 } | |
568 } | |
569 | |
1268
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
570 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
571 /* Requesting the value of a selection. */ |
159 | 572 |
1529
d73ee126c15d
* xselect.c (own_selection): selection_type is an X Atom value,
Jim Blandy <jimb@redhat.com>
parents:
1268
diff
changeset
|
573 static Lisp_Object x_selection_arrival (); |
d73ee126c15d
* xselect.c (own_selection): selection_type is an X Atom value,
Jim Blandy <jimb@redhat.com>
parents:
1268
diff
changeset
|
574 |
159 | 575 /* Predicate function used to match a requested event. */ |
576 | |
577 Bool | |
578 XCheckSelectionEvent (dpy, event, window) | |
579 Display *dpy; | |
580 XEvent *event; | |
581 char *window; | |
582 { | |
583 if (event->type == SelectionNotify) | |
584 if (event->xselection.requestor == (Window) window) | |
585 return True; | |
586 | |
587 return False; | |
588 } | |
589 | |
641 | 590 /* Request a selection value from its owner. This will block until |
591 all the data is arrived. */ | |
159 | 592 |
641 | 593 static Lisp_Object |
594 get_selection_value (type) | |
595 Atom type; | |
159 | 596 { |
597 XEvent event; | |
598 Lisp_Object val; | |
599 Time requestor_time; /* Timestamp of selection request. */ | |
600 Window requestor_window; | |
601 | |
602 BLOCK_INPUT; | |
708 | 603 requestor_time = last_event_timestamp; |
1053
a411429c4140
* xselect.c: Use the FRAME_X_WINDOW macro, for readability.
Jim Blandy <jimb@redhat.com>
parents:
847
diff
changeset
|
604 requestor_window = FRAME_X_WINDOW (selected_frame); |
641 | 605 XConvertSelection (x_current_display, type, XA_STRING, |
159 | 606 Xatom_emacs_selection, requestor_window, requestor_time); |
607 XIfEvent (x_current_display, | |
608 &event, | |
609 XCheckSelectionEvent, | |
610 (char *) requestor_window); | |
611 val = x_selection_arrival (&event, requestor_window, requestor_time); | |
612 UNBLOCK_INPUT; | |
613 | |
614 return val; | |
615 } | |
616 | |
641 | 617 /* Request a selection value from the owner. If we are the owner, |
618 simply return our selection value. If we are not the owner, this | |
619 will block until all of the data has arrived. */ | |
159 | 620 |
1821
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
621 DEFUN ("x-selection", Fx_selection, Sx_selection, |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
622 1, 1, "", |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
623 "Return the value of SELECTION.\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
624 SELECTION is one of `primary', `secondary', or `clipboard'.\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
625 \n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
626 Selections are a mechanism for cutting and pasting information between\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
627 X Windows clients. When the user selects text in an X application,\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
628 the application should set the primary selection to that text; Emacs's\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
629 kill ring commands will then check the value of the `primary'\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
630 selection, and return it as the most recent kill.\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
631 The documentation for `x-set-selection' gives more information on how\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
632 the different selection types are intended to be used.\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
633 Also see the `interprogram-paste-function' variable.") |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
634 (selection) |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
635 register Lisp_Object selection; |
159 | 636 { |
641 | 637 Atom selection_type; |
638 | |
1821
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
639 if (NILP (selection) || EQ (selection, Qprimary)) |
641 | 640 { |
641 if (!NILP (Vx_selection_value)) | |
1268
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
642 return Vx_selection_value; |
159 | 643 |
641 | 644 return get_selection_value (XA_PRIMARY); |
645 } | |
1821
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
646 else if (EQ (selection, Qsecondary)) |
641 | 647 { |
648 if (!NILP (Vx_secondary_selection_value)) | |
649 return Vx_secondary_selection_value; | |
159 | 650 |
641 | 651 return get_selection_value (XA_SECONDARY); |
652 } | |
1821
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
653 else if (EQ (selection, Qclipboard)) |
641 | 654 { |
655 if (!NILP (Vx_clipboard_value)) | |
656 return Vx_clipboard_value; | |
159 | 657 |
641 | 658 return get_selection_value (Xatom_clipboard); |
659 } | |
660 else | |
661 error ("Invalid X selection type"); | |
159 | 662 } |
663 | |
1529
d73ee126c15d
* xselect.c (own_selection): selection_type is an X Atom value,
Jim Blandy <jimb@redhat.com>
parents:
1268
diff
changeset
|
664 static Lisp_Object |
159 | 665 x_selection_arrival (event, requestor_window, requestor_time) |
666 register XSelectionEvent *event; | |
667 Window requestor_window; | |
668 Time requestor_time; | |
669 { | |
670 int result; | |
671 Atom type, selection; | |
672 int format; | |
673 unsigned long items; | |
674 unsigned long bytes_left; | |
675 unsigned char *data = 0; | |
676 int offset = 0; | |
677 | |
678 if (event->selection == XA_PRIMARY) | |
679 selection = Xatom_emacs_selection; | |
641 | 680 else if (event->selection == XA_SECONDARY) |
681 selection = Xatom_emacs_secondary_selection; | |
159 | 682 else if (event->selection == Xatom_clipboard) |
683 selection = Xatom_clipboard_selection; | |
684 else | |
685 abort (); | |
686 | |
687 if (event->requestor == requestor_window | |
688 && event->time == requestor_time | |
689 && event->property != None) | |
690 if (event->target != Xatom_incremental) | |
691 { | |
692 unsigned char *return_string = | |
693 (unsigned char *) alloca (MAX_SELECTION (x_current_display)); | |
694 | |
695 do | |
696 { | |
641 | 697 result = XGetWindowProperty (x_current_display, requestor_window, |
159 | 698 event->property, 0L, |
699 10000000L, True, XA_STRING, | |
700 &type, &format, &items, | |
701 &bytes_left, &data); | |
702 if (result == Success && type == XA_STRING && format == 8 | |
703 && offset < MAX_SELECTION (x_current_display)) | |
704 { | |
705 bcopy (data, return_string + offset, items); | |
706 offset += items; | |
707 } | |
708 XFree ((char *) data); | |
709 } | |
710 while (bytes_left); | |
711 | |
712 return make_string (return_string, offset); | |
713 } | |
714 else /* Prepare incremental transfer. */ | |
715 { | |
716 unsigned char *increment_value; | |
717 unsigned char *increment_ptr; | |
718 int total_size; | |
719 int *increment_nbytes = 0; | |
720 | |
721 result = XGetWindowProperty (x_current_display, requestor_window, | |
722 selection, 0L, 10000000L, False, | |
723 event->property, &type, &format, | |
724 &items, &bytes_left, | |
725 (unsigned char **) &increment_nbytes); | |
726 if (result == Success) | |
727 { | |
728 XPropertyEvent property_event; | |
729 | |
730 total_size = *increment_nbytes; | |
731 increment_value = (unsigned char *) alloca (total_size); | |
732 increment_ptr = increment_value; | |
733 | |
734 XDeleteProperty (x_current_display, event->requestor, | |
735 event->property); | |
736 XFlush (x_current_display); | |
737 XFree ((char *) increment_nbytes); | |
738 | |
739 do | |
740 { /* NOTE: this blocks. */ | |
741 XWindowEvent (x_current_display, requestor_window, | |
742 PropertyChangeMask, | |
743 (XEvent *) &property_event); | |
744 | |
745 if (property_event.atom == selection | |
746 && property_event.state == PropertyNewValue) | |
747 do | |
748 { | |
749 result = XGetWindowProperty (x_current_display, | |
750 requestor_window, | |
751 selection, 0L, | |
752 10000000L, True, | |
753 AnyPropertyType, | |
754 &type, &format, | |
755 &items, &bytes_left, | |
756 &data); | |
757 if (result == Success && type == XA_STRING | |
758 && format == 8) | |
759 { | |
760 bcopy (data, increment_ptr, items); | |
761 increment_ptr += items; | |
762 } | |
763 } | |
764 while (bytes_left); | |
765 | |
766 } | |
767 while (increment_ptr < (increment_value + total_size)); | |
768 | |
769 return make_string (increment_value, | |
770 (increment_ptr - increment_value)); | |
771 } | |
772 } | |
773 | |
774 return Qnil; | |
775 } | |
776 | |
1268
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
777 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
778 /* Cut buffer management. */ |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
779 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
780 DEFUN ("x-get-cut-buffer", Fx_get_cut_buffer, Sx_get_cut_buffer, 0, 1, "", |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
781 "Return the value of cut buffer N, or nil if it is unset.\n\ |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
782 If N is omitted, it defaults to zero.\n\ |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
783 Note that cut buffers have some problems that selections don't; try to\n\ |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
784 write your code to use cut buffers only for backward compatibility,\n\ |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
785 and use selections for the serious work.") |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
786 (n) |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
787 Lisp_Object n; |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
788 { |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
789 int buf_num; |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
790 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
791 if (NILP (n)) |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
792 buf_num = 0; |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
793 else |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
794 { |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
795 CHECK_NUMBER (n, 0); |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
796 buf_num = XINT (n); |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
797 } |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
798 |
1602
f0c4c8771cd4
* xselect.c (Fx_get_cut_buffer): Correct check for buf_num in
Jim Blandy <jimb@redhat.com>
parents:
1529
diff
changeset
|
799 if (buf_num < 0 || buf_num >= NUM_CUT_BUFFERS) |
f0c4c8771cd4
* xselect.c (Fx_get_cut_buffer): Correct check for buf_num in
Jim Blandy <jimb@redhat.com>
parents:
1529
diff
changeset
|
800 error ("cut buffer numbers must be from zero to seven"); |
1268
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
801 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
802 { |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
803 Lisp_Object value; |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
804 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
805 /* Note that no PropertyNotify events will be processed while |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
806 input is blocked. */ |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
807 BLOCK_INPUT; |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
808 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
809 if (cut_buffer_cached & (1 << buf_num)) |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
810 value = XVECTOR (cut_buffer_value)->contents[buf_num]; |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
811 else |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
812 { |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
813 /* Our cache is invalid; retrieve the property's value from |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
814 the server. */ |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
815 int buf_len; |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
816 char *buf = XFetchBuffer (x_current_display, &buf_len, buf_num); |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
817 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
818 if (buf_len == 0) |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
819 value = Qnil; |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
820 else |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
821 value = make_string (buf, buf_len); |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
822 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
823 XVECTOR (cut_buffer_value)->contents[buf_num] = value; |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
824 cut_buffer_cached |= (1 << buf_num); |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
825 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
826 XFree (buf); |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
827 } |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
828 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
829 UNBLOCK_INPUT; |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
830 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
831 return value; |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
832 } |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
833 } |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
834 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
835 DEFUN ("x-set-cut-buffer", Fx_set_cut_buffer, Sx_set_cut_buffer, 2, 2, "", |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
836 "Set the value of cut buffer N to STRING.\n\ |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
837 Note that cut buffers have some problems that selections don't; try to\n\ |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
838 write your code to use cut buffers only for backward compatibility,\n\ |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
839 and use selections for the serious work.") |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
840 (n, string) |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
841 Lisp_Object n, string; |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
842 { |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
843 int buf_num; |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
844 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
845 CHECK_NUMBER (n, 0); |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
846 CHECK_STRING (string, 1); |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
847 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
848 buf_num = XINT (n); |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
849 |
1602
f0c4c8771cd4
* xselect.c (Fx_get_cut_buffer): Correct check for buf_num in
Jim Blandy <jimb@redhat.com>
parents:
1529
diff
changeset
|
850 if (buf_num < 0 || buf_num >= NUM_CUT_BUFFERS) |
f0c4c8771cd4
* xselect.c (Fx_get_cut_buffer): Correct check for buf_num in
Jim Blandy <jimb@redhat.com>
parents:
1529
diff
changeset
|
851 error ("cut buffer numbers must be from zero to seven"); |
1268
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
852 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
853 BLOCK_INPUT; |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
854 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
855 /* DECwindows and some other servers don't seem to like setting |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
856 properties to values larger than about 20k. For very large |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
857 values, they signal an error, but for intermediate values they |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
858 just seem to hang. |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
859 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
860 We could just truncate the request, but it's better to let the |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
861 user know that the strategy he/she's using isn't going to work |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
862 than to have it work partially, but incorrectly. */ |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
863 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
864 if (XSTRING (string)->size == 0 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
865 || XSTRING (string)->size > MAX_SELECTION (x_current_display)) |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
866 { |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
867 XStoreBuffer (x_current_display, (char *) 0, 0, buf_num); |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
868 string = Qnil; |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
869 } |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
870 else |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
871 { |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
872 XStoreBuffer (x_current_display, |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
873 (char *) XSTRING (string)->data, XSTRING (string)->size, |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
874 buf_num); |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
875 } |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
876 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
877 XVECTOR (cut_buffer_value)->contents[buf_num] = string; |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
878 cut_buffer_cached |= (1 << buf_num); |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
879 cut_buffer_just_set |= (1 << buf_num); |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
880 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
881 UNBLOCK_INPUT; |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
882 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
883 return string; |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
884 } |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
885 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
886 /* Ask the server to send us an event if any cut buffer is modified. */ |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
887 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
888 void |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
889 x_watch_cut_buffer_cache () |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
890 { |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
891 XSelectInput (x_current_display, ROOT_WINDOW, PropertyChangeMask); |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
892 } |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
893 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
894 /* The server has told us that a cut buffer has been modified; deal with that. |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
895 Note that this function is called at interrupt level. */ |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
896 void |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
897 x_invalidate_cut_buffer_cache (XPropertyEvent *event) |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
898 { |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
899 int i; |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
900 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
901 /* See which cut buffer this is about, if any. */ |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
902 for (i = 0; i < NUM_CUT_BUFFERS; i++) |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
903 if (event->atom == cut_buffer_atom[i]) |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
904 { |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
905 int mask = (1 << i); |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
906 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
907 if (cut_buffer_just_set & mask) |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
908 cut_buffer_just_set &= ~mask; |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
909 else |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
910 cut_buffer_cached &= ~mask; |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
911 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
912 break; |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
913 } |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
914 } |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
915 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
916 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
917 /* Bureaucracy. */ |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
918 |
159 | 919 void |
920 syms_of_xselect () | |
921 { | |
922 DEFVAR_LISP ("x-selection-value", &Vx_selection_value, | |
923 "The value of emacs' last cut-string."); | |
924 Vx_selection_value = Qnil; | |
925 | |
641 | 926 DEFVAR_LISP ("x-secondary-selection-value", &Vx_secondary_selection_value, |
927 "The value of emacs' last secondary cut-string."); | |
928 Vx_secondary_selection_value = Qnil; | |
929 | |
159 | 930 DEFVAR_LISP ("x-clipboard-value", &Vx_clipboard_value, |
931 "The string emacs last sent to the clipboard."); | |
932 Vx_clipboard_value = Qnil; | |
933 | |
641 | 934 Qprimary = intern ("primary"); |
935 staticpro (&Qprimary); | |
936 Qsecondary = intern ("secondary"); | |
937 staticpro (&Qsecondary); | |
938 Qclipboard = intern ("clipboard"); | |
939 staticpro (&Qclipboard); | |
940 | |
1821
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
941 defsubr (&Sx_set_selection); |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1602
diff
changeset
|
942 defsubr (&Sx_selection); |
1268
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
943 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
944 cut_buffer_value = Fmake_vector (make_number (NUM_CUT_BUFFERS), Qnil); |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
945 staticpro (&cut_buffer_value); |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
946 |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
947 defsubr (&Sx_get_cut_buffer); |
39c6e9d28de2
* xselect.c (Qcut_buffer0): Symbol removed; we're using a new
Jim Blandy <jimb@redhat.com>
parents:
1053
diff
changeset
|
948 defsubr (&Sx_set_cut_buffer); |
159 | 949 } |
950 #endif /* X11 */ |