1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* vim:expandtab:shiftwidth=4:tabstop=4:
3 */
4 /* This Source Code Form is subject to the terms of the Mozilla Public
5 * License, v. 2.0. If a copy of the MPL was not distributed with this
6 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
7
8 #include "mozilla/ArrayUtils.h"
9
10 #include "nsArrayUtils.h"
11 #include "nsClipboard.h"
12 #include "nsClipboardX11.h"
13 #include "nsSupportsPrimitives.h"
14 #include "nsString.h"
15 #include "nsReadableUtils.h"
16 #include "nsPrimitiveHelpers.h"
17 #include "nsImageToPixbuf.h"
18 #include "nsStringStream.h"
19 #include "mozilla/RefPtr.h"
20 #include "mozilla/TimeStamp.h"
21 #include "WidgetUtilsGtk.h"
22
23 #include <gtk/gtk.h>
24
25 // For manipulation of the X event queue
26 #include <X11/Xlib.h>
27 #include <poll.h>
28 #include <gdk/gdkx.h>
29 #include <sys/time.h>
30 #include <sys/types.h>
31 #include <errno.h>
32 #include <unistd.h>
33 #include "X11UndefineNone.h"
34
35 using namespace mozilla;
36
HasSelectionSupport(void)37 bool nsRetrievalContextX11::HasSelectionSupport(void) {
38 // yeah, unix supports the selection clipboard on X11.
39 return true;
40 }
41
nsRetrievalContextX11()42 nsRetrievalContextX11::nsRetrievalContextX11()
43 : mState(INITIAL),
44 mClipboardRequestNumber(0),
45 mClipboardData(nullptr),
46 mClipboardDataLength(0),
47 mTargetMIMEType(gdk_atom_intern("TARGETS", FALSE)) {}
48
DispatchSelectionNotifyEvent(GtkWidget * widget,XEvent * xevent)49 static void DispatchSelectionNotifyEvent(GtkWidget* widget, XEvent* xevent) {
50 GdkEvent event = {};
51 event.selection.type = GDK_SELECTION_NOTIFY;
52 event.selection.window = gtk_widget_get_window(widget);
53 event.selection.selection =
54 gdk_x11_xatom_to_atom(xevent->xselection.selection);
55 event.selection.target = gdk_x11_xatom_to_atom(xevent->xselection.target);
56 event.selection.property = gdk_x11_xatom_to_atom(xevent->xselection.property);
57 event.selection.time = xevent->xselection.time;
58
59 gtk_widget_event(widget, &event);
60 }
61
DispatchPropertyNotifyEvent(GtkWidget * widget,XEvent * xevent)62 static void DispatchPropertyNotifyEvent(GtkWidget* widget, XEvent* xevent) {
63 GdkWindow* window = gtk_widget_get_window(widget);
64 if ((gdk_window_get_events(window)) & GDK_PROPERTY_CHANGE_MASK) {
65 GdkEvent event = {};
66 event.property.type = GDK_PROPERTY_NOTIFY;
67 event.property.window = window;
68 event.property.atom = gdk_x11_xatom_to_atom(xevent->xproperty.atom);
69 event.property.time = xevent->xproperty.time;
70 event.property.state = xevent->xproperty.state;
71
72 gtk_widget_event(widget, &event);
73 }
74 }
75
76 struct checkEventContext {
77 GtkWidget* cbWidget;
78 Atom selAtom;
79 };
80
checkEventProc(Display * display,XEvent * event,XPointer arg)81 static Bool checkEventProc(Display* display, XEvent* event, XPointer arg) {
82 checkEventContext* context = (checkEventContext*)arg;
83
84 if (event->xany.type == SelectionNotify ||
85 (event->xany.type == PropertyNotify &&
86 event->xproperty.atom == context->selAtom)) {
87 GdkWindow* cbWindow = gdk_x11_window_lookup_for_display(
88 gdk_x11_lookup_xdisplay(display), event->xany.window);
89 if (cbWindow) {
90 GtkWidget* cbWidget = nullptr;
91 gdk_window_get_user_data(cbWindow, (gpointer*)&cbWidget);
92 if (cbWidget && GTK_IS_WIDGET(cbWidget)) {
93 context->cbWidget = cbWidget;
94 return X11True;
95 }
96 }
97 }
98
99 return X11False;
100 }
101
WaitForX11Content()102 bool nsRetrievalContextX11::WaitForX11Content() {
103 if (mState == COMPLETED) { // the request completed synchronously
104 return true;
105 }
106
107 GdkDisplay* gdkDisplay = gdk_display_get_default();
108 // gdk_display_get_default() returns null on headless
109 if (mozilla::widget::GdkIsX11Display(gdkDisplay)) {
110 Display* xDisplay = GDK_DISPLAY_XDISPLAY(gdkDisplay);
111 checkEventContext context;
112 context.cbWidget = nullptr;
113 context.selAtom =
114 gdk_x11_atom_to_xatom(gdk_atom_intern("GDK_SELECTION", FALSE));
115
116 // Send X events which are relevant to the ongoing selection retrieval
117 // to the clipboard widget. Wait until either the operation completes, or
118 // we hit our timeout. All other X events remain queued.
119
120 int poll_result;
121
122 struct pollfd pfd;
123 pfd.fd = ConnectionNumber(xDisplay);
124 pfd.events = POLLIN;
125 TimeStamp start = TimeStamp::Now();
126
127 do {
128 XEvent xevent;
129
130 while (XCheckIfEvent(xDisplay, &xevent, checkEventProc,
131 (XPointer)&context)) {
132 if (xevent.xany.type == SelectionNotify)
133 DispatchSelectionNotifyEvent(context.cbWidget, &xevent);
134 else
135 DispatchPropertyNotifyEvent(context.cbWidget, &xevent);
136
137 if (mState == COMPLETED) {
138 return true;
139 }
140 }
141
142 TimeStamp now = TimeStamp::Now();
143 int timeout = std::max<int>(
144 0, kClipboardTimeout / 1000 - (now - start).ToMilliseconds());
145 poll_result = poll(&pfd, 1, timeout);
146 } while ((poll_result == 1 && (pfd.revents & (POLLHUP | POLLERR)) == 0) ||
147 (poll_result == -1 && errno == EINTR));
148 }
149 #ifdef DEBUG_CLIPBOARD
150 printf("exceeded clipboard timeout\n");
151 #endif
152 mState = TIMED_OUT;
153 return false;
154 }
155
156 // Call this when data has been retrieved.
Complete(ClipboardDataType aDataType,const void * aData,int aDataRequestNumber)157 void nsRetrievalContextX11::Complete(ClipboardDataType aDataType,
158 const void* aData,
159 int aDataRequestNumber) {
160 LOGCLIP(("nsRetrievalContextX11::Complete\n"));
161
162 if (mClipboardRequestNumber != aDataRequestNumber) {
163 NS_WARNING(
164 "nsRetrievalContextX11::Complete() got obsoleted clipboard data.");
165 return;
166 }
167
168 if (mState == INITIAL) {
169 mState = COMPLETED;
170
171 MOZ_ASSERT(mClipboardData == nullptr && mClipboardDataLength == 0,
172 "We're leaking clipboard data!");
173
174 switch (aDataType) {
175 case CLIPBOARD_TEXT: {
176 const char* text = static_cast<const char*>(aData);
177 if (text) {
178 mClipboardDataLength = sizeof(char) * (strlen(text) + 1);
179 mClipboardData = moz_xmalloc(mClipboardDataLength);
180 memcpy(mClipboardData, text, mClipboardDataLength);
181 }
182 } break;
183 case CLIPBOARD_TARGETS: {
184 const GtkSelectionData* selection =
185 static_cast<const GtkSelectionData*>(aData);
186
187 gint n_targets = 0;
188 GdkAtom* targets = nullptr;
189
190 if (!gtk_selection_data_get_targets(selection, &targets, &n_targets) ||
191 !n_targets) {
192 return;
193 }
194
195 mClipboardData = targets;
196 mClipboardDataLength = n_targets;
197 } break;
198 case CLIPBOARD_DATA: {
199 const GtkSelectionData* selection =
200 static_cast<const GtkSelectionData*>(aData);
201
202 gint dataLength = gtk_selection_data_get_length(selection);
203 if (dataLength > 0) {
204 mClipboardDataLength = dataLength;
205 mClipboardData = moz_xmalloc(dataLength);
206 memcpy(mClipboardData, gtk_selection_data_get_data(selection),
207 dataLength);
208 }
209 } break;
210 }
211 } else {
212 // Already timed out
213 MOZ_ASSERT(mState == TIMED_OUT);
214 }
215 }
216
clipboard_contents_received(GtkClipboard * clipboard,GtkSelectionData * selection_data,gpointer data)217 static void clipboard_contents_received(GtkClipboard* clipboard,
218 GtkSelectionData* selection_data,
219 gpointer data) {
220 int whichClipboard = GetGeckoClipboardType(clipboard);
221 LOGCLIP(("clipboard_contents_received (%s) callback\n",
222 whichClipboard == nsClipboard::kSelectionClipboard ? "primary"
223 : "clipboard"));
224
225 ClipboardRequestHandler* handler =
226 static_cast<ClipboardRequestHandler*>(data);
227 handler->Complete(selection_data);
228 delete handler;
229 }
230
clipboard_text_received(GtkClipboard * clipboard,const gchar * text,gpointer data)231 static void clipboard_text_received(GtkClipboard* clipboard, const gchar* text,
232 gpointer data) {
233 int whichClipboard = GetGeckoClipboardType(clipboard);
234 LOGCLIP(("clipboard_text_received (%s) callback\n",
235 whichClipboard == nsClipboard::kSelectionClipboard ? "primary"
236 : "clipboard"));
237
238 ClipboardRequestHandler* handler =
239 static_cast<ClipboardRequestHandler*>(data);
240 handler->Complete(text);
241 delete handler;
242 }
243
WaitForClipboardData(ClipboardDataType aDataType,GtkClipboard * clipboard,const char * aMimeType)244 bool nsRetrievalContextX11::WaitForClipboardData(ClipboardDataType aDataType,
245 GtkClipboard* clipboard,
246 const char* aMimeType) {
247 LOGCLIP(("nsRetrievalContextX11::WaitForClipboardData\n"));
248
249 mState = INITIAL;
250 NS_ASSERTION(!mClipboardData, "Leaking clipboard content!");
251
252 // Call ClipboardRequestHandler() with unique clipboard request number.
253 // The request number pairs gtk_clipboard_request_contents() data request
254 // with clipboard_contents_received() callback where the data
255 // is provided by Gtk.
256 mClipboardRequestNumber++;
257 ClipboardRequestHandler* handler =
258 new ClipboardRequestHandler(this, aDataType, mClipboardRequestNumber);
259
260 switch (aDataType) {
261 case CLIPBOARD_DATA:
262 gtk_clipboard_request_contents(clipboard,
263 gdk_atom_intern(aMimeType, FALSE),
264 clipboard_contents_received, handler);
265 break;
266 case CLIPBOARD_TEXT:
267 gtk_clipboard_request_text(clipboard, clipboard_text_received, handler);
268 break;
269 case CLIPBOARD_TARGETS:
270 gtk_clipboard_request_contents(clipboard, mTargetMIMEType,
271 clipboard_contents_received, handler);
272 break;
273 }
274
275 return WaitForX11Content();
276 }
277
GetTargets(int32_t aWhichClipboard,int * aTargetNums)278 GdkAtom* nsRetrievalContextX11::GetTargets(int32_t aWhichClipboard,
279 int* aTargetNums) {
280 LOGCLIP(("nsRetrievalContextX11::GetTargets(%s)\n",
281 aWhichClipboard == nsClipboard::kSelectionClipboard ? "primary"
282 : "clipboard"));
283
284 GtkClipboard* clipboard =
285 gtk_clipboard_get(GetSelectionAtom(aWhichClipboard));
286
287 if (!WaitForClipboardData(CLIPBOARD_TARGETS, clipboard)) {
288 LOGCLIP((" WaitForClipboardData() failed!\n"));
289 return nullptr;
290 }
291
292 *aTargetNums = mClipboardDataLength;
293 GdkAtom* targets = static_cast<GdkAtom*>(mClipboardData);
294
295 // We don't hold the target list internally but we transfer the ownership.
296 mClipboardData = nullptr;
297 mClipboardDataLength = 0;
298
299 LOGCLIP((" returned %d targets\n", *aTargetNums));
300 return targets;
301 }
302
GetClipboardData(const char * aMimeType,int32_t aWhichClipboard,uint32_t * aContentLength)303 const char* nsRetrievalContextX11::GetClipboardData(const char* aMimeType,
304 int32_t aWhichClipboard,
305 uint32_t* aContentLength) {
306 LOGCLIP(("nsRetrievalContextX11::GetClipboardData(%s)\n",
307 aWhichClipboard == nsClipboard::kSelectionClipboard ? "primary"
308 : "clipboard"));
309
310 GtkClipboard* clipboard;
311 clipboard = gtk_clipboard_get(GetSelectionAtom(aWhichClipboard));
312
313 if (!WaitForClipboardData(CLIPBOARD_DATA, clipboard, aMimeType))
314 return nullptr;
315
316 *aContentLength = mClipboardDataLength;
317 return static_cast<const char*>(mClipboardData);
318 }
319
GetClipboardText(int32_t aWhichClipboard)320 const char* nsRetrievalContextX11::GetClipboardText(int32_t aWhichClipboard) {
321 LOGCLIP(("nsRetrievalContextX11::GetClipboardText(%s)\n",
322 aWhichClipboard == nsClipboard::kSelectionClipboard ? "primary"
323 : "clipboard"));
324
325 GtkClipboard* clipboard;
326 clipboard = gtk_clipboard_get(GetSelectionAtom(aWhichClipboard));
327
328 if (!WaitForClipboardData(CLIPBOARD_TEXT, clipboard)) return nullptr;
329
330 return static_cast<const char*>(mClipboardData);
331 }
332
ReleaseClipboardData(const char * aClipboardData)333 void nsRetrievalContextX11::ReleaseClipboardData(const char* aClipboardData) {
334 LOGCLIP(("nsRetrievalContextX11::ReleaseClipboardData\n"));
335 NS_ASSERTION(aClipboardData == mClipboardData,
336 "Releasing unknown clipboard data!");
337 free((void*)aClipboardData);
338
339 mClipboardData = nullptr;
340 mClipboardDataLength = 0;
341 }
342