]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: src/gtk/clipbrd.cpp | |
3 | // Purpose: wxClipboard implementation for wxGTK | |
4 | // Author: Robert Roebling, Vadim Zeitlin | |
5 | // Id: $Id$ | |
6 | // Copyright: (c) 1998 Robert Roebling | |
7 | // (c) 2007 Vadim Zeitlin | |
8 | // Licence: wxWindows licence | |
9 | ///////////////////////////////////////////////////////////////////////////// | |
10 | ||
11 | // ============================================================================ | |
12 | // declarations | |
13 | // ============================================================================ | |
14 | ||
15 | // ---------------------------------------------------------------------------- | |
16 | // headers | |
17 | // ---------------------------------------------------------------------------- | |
18 | ||
19 | // For compilers that support precompilation, includes "wx.h". | |
20 | #include "wx/wxprec.h" | |
21 | ||
22 | #if wxUSE_CLIPBOARD | |
23 | ||
24 | #include "wx/clipbrd.h" | |
25 | ||
26 | #ifndef WX_PRECOMP | |
27 | #include "wx/app.h" | |
28 | #include "wx/log.h" | |
29 | #include "wx/utils.h" | |
30 | #include "wx/dataobj.h" | |
31 | #endif | |
32 | ||
33 | #include "wx/scopedarray.h" | |
34 | #include "wx/scopeguard.h" | |
35 | #include "wx/evtloop.h" | |
36 | ||
37 | #include "wx/gtk/private.h" | |
38 | ||
39 | typedef wxScopedArray<wxDataFormat> wxDataFormatArray; | |
40 | ||
41 | // ---------------------------------------------------------------------------- | |
42 | // data | |
43 | // ---------------------------------------------------------------------------- | |
44 | ||
45 | static GdkAtom g_clipboardAtom = 0; | |
46 | static GdkAtom g_targetsAtom = 0; | |
47 | static GdkAtom g_timestampAtom = 0; | |
48 | ||
49 | #if wxUSE_UNICODE | |
50 | extern GdkAtom g_altTextAtom; | |
51 | #endif | |
52 | ||
53 | // the trace mask we use with wxLogTrace() - call | |
54 | // wxLog::AddTraceMask(TRACE_CLIPBOARD) to enable the trace messages from here | |
55 | // (there will be a *lot* of them!) | |
56 | #define TRACE_CLIPBOARD wxT("clipboard") | |
57 | ||
58 | // ---------------------------------------------------------------------------- | |
59 | // wxClipboardSync: used to perform clipboard operations synchronously | |
60 | // ---------------------------------------------------------------------------- | |
61 | ||
62 | // constructing this object on stack will wait wait until the latest clipboard | |
63 | // operation is finished on block exit | |
64 | // | |
65 | // notice that there can be no more than one such object alive at any moment, | |
66 | // i.e. reentrancies are not allowed | |
67 | class wxClipboardSync | |
68 | { | |
69 | public: | |
70 | wxClipboardSync(wxClipboard& clipboard) | |
71 | { | |
72 | wxASSERT_MSG( !ms_clipboard, wxT("reentrancy in clipboard code") ); | |
73 | ms_clipboard = &clipboard; | |
74 | } | |
75 | ||
76 | ~wxClipboardSync() | |
77 | { | |
78 | #if wxUSE_CONSOLE_EVENTLOOP | |
79 | // ensure that there is a running event loop: this might not be the | |
80 | // case if we're called before the main event loop startup | |
81 | wxEventLoopGuarantor ensureEventLoop; | |
82 | #endif | |
83 | while (ms_clipboard) | |
84 | wxEventLoopBase::GetActive()->YieldFor(wxEVT_CATEGORY_CLIPBOARD); | |
85 | } | |
86 | ||
87 | // this method must be called by GTK+ callbacks to indicate that we got the | |
88 | // result for our clipboard operation | |
89 | static void OnDone(wxClipboard * WXUNUSED_UNLESS_DEBUG(clipboard)) | |
90 | { | |
91 | wxASSERT_MSG( clipboard == ms_clipboard, | |
92 | wxT("got notification for alien clipboard") ); | |
93 | ||
94 | ms_clipboard = NULL; | |
95 | } | |
96 | ||
97 | // this method should be called if it's possible that no async clipboard | |
98 | // operation is currently in progress (like it can be the case when the | |
99 | // clipboard is cleared but not because we asked about it), it should only | |
100 | // be called if such situation is expected -- otherwise call OnDone() which | |
101 | // would assert in this case | |
102 | static void OnDoneIfInProgress(wxClipboard *clipboard) | |
103 | { | |
104 | if ( ms_clipboard ) | |
105 | OnDone(clipboard); | |
106 | } | |
107 | ||
108 | private: | |
109 | static wxClipboard *ms_clipboard; | |
110 | ||
111 | wxDECLARE_NO_COPY_CLASS(wxClipboardSync); | |
112 | }; | |
113 | ||
114 | wxClipboard *wxClipboardSync::ms_clipboard = NULL; | |
115 | ||
116 | // ============================================================================ | |
117 | // clipboard callbacks implementation | |
118 | // ============================================================================ | |
119 | ||
120 | //----------------------------------------------------------------------------- | |
121 | // "selection_received" for targets | |
122 | //----------------------------------------------------------------------------- | |
123 | ||
124 | extern "C" { | |
125 | static void | |
126 | targets_selection_received( GtkWidget *WXUNUSED(widget), | |
127 | GtkSelectionData *selection_data, | |
128 | guint32 WXUNUSED(time), | |
129 | wxClipboard *clipboard ) | |
130 | { | |
131 | if ( !clipboard ) | |
132 | return; | |
133 | ||
134 | wxON_BLOCK_EXIT1(wxClipboardSync::OnDone, clipboard); | |
135 | ||
136 | if (!selection_data) | |
137 | return; | |
138 | ||
139 | const int selection_data_length = gtk_selection_data_get_length(selection_data); | |
140 | if (selection_data_length <= 0) | |
141 | return; | |
142 | ||
143 | // make sure we got the data in the correct form | |
144 | GdkAtom type = gtk_selection_data_get_data_type(selection_data); | |
145 | if ( type != GDK_SELECTION_TYPE_ATOM ) | |
146 | { | |
147 | if ( strcmp(wxGtkString(gdk_atom_name(type)), "TARGETS") != 0 ) | |
148 | { | |
149 | wxLogTrace( TRACE_CLIPBOARD, | |
150 | wxT("got unsupported clipboard target") ); | |
151 | ||
152 | return; | |
153 | } | |
154 | } | |
155 | ||
156 | // it's not really a format, of course, but we can reuse its GetId() method | |
157 | // to format this atom as string | |
158 | wxDataFormat clip(gtk_selection_data_get_selection(selection_data)); | |
159 | wxLogTrace( TRACE_CLIPBOARD, | |
160 | wxT("Received available formats for clipboard %s"), | |
161 | clip.GetId().c_str() ); | |
162 | ||
163 | // the atoms we received, holding a list of targets (= formats) | |
164 | const GdkAtom* const atoms = (GdkAtom*)gtk_selection_data_get_data(selection_data); | |
165 | for (size_t i = 0; i < selection_data_length / sizeof(GdkAtom); i++) | |
166 | { | |
167 | const wxDataFormat format(atoms[i]); | |
168 | ||
169 | wxLogTrace(TRACE_CLIPBOARD, wxT("\t%s"), format.GetId().c_str()); | |
170 | ||
171 | if ( clipboard->GTKOnTargetReceived(format) ) | |
172 | return; | |
173 | } | |
174 | } | |
175 | } | |
176 | ||
177 | bool wxClipboard::GTKOnTargetReceived(const wxDataFormat& format) | |
178 | { | |
179 | if ( format != m_targetRequested ) | |
180 | return false; | |
181 | ||
182 | m_formatSupported = true; | |
183 | return true; | |
184 | } | |
185 | ||
186 | //----------------------------------------------------------------------------- | |
187 | // "selection_received" for the actual data | |
188 | //----------------------------------------------------------------------------- | |
189 | ||
190 | extern "C" { | |
191 | static void | |
192 | selection_received( GtkWidget *WXUNUSED(widget), | |
193 | GtkSelectionData *selection_data, | |
194 | guint32 WXUNUSED(time), | |
195 | wxClipboard *clipboard ) | |
196 | { | |
197 | if ( !clipboard ) | |
198 | return; | |
199 | ||
200 | wxON_BLOCK_EXIT1(wxClipboardSync::OnDone, clipboard); | |
201 | ||
202 | if (!selection_data || gtk_selection_data_get_length(selection_data) <= 0) | |
203 | return; | |
204 | ||
205 | clipboard->GTKOnSelectionReceived(*selection_data); | |
206 | } | |
207 | } | |
208 | ||
209 | //----------------------------------------------------------------------------- | |
210 | // "selection_clear" | |
211 | //----------------------------------------------------------------------------- | |
212 | ||
213 | extern "C" { | |
214 | static gint | |
215 | selection_clear_clip( GtkWidget *WXUNUSED(widget), GdkEventSelection *event ) | |
216 | { | |
217 | wxClipboard * const clipboard = wxTheClipboard; | |
218 | if ( !clipboard ) | |
219 | return TRUE; | |
220 | ||
221 | // notice the use of OnDoneIfInProgress() here instead of just OnDone(): | |
222 | // it's perfectly possible that we're receiving this notification from GTK+ | |
223 | // even though we hadn't cleared the clipboard ourselves but because | |
224 | // another application (or even another window in the same program) | |
225 | // acquired it | |
226 | wxON_BLOCK_EXIT1(wxClipboardSync::OnDoneIfInProgress, clipboard); | |
227 | ||
228 | wxClipboard::Kind kind; | |
229 | if (event->selection == GDK_SELECTION_PRIMARY) | |
230 | { | |
231 | wxLogTrace(TRACE_CLIPBOARD, wxT("Lost primary selection" )); | |
232 | ||
233 | kind = wxClipboard::Primary; | |
234 | } | |
235 | else if (event->selection == g_clipboardAtom) | |
236 | { | |
237 | wxLogTrace(TRACE_CLIPBOARD, wxT("Lost clipboard" )); | |
238 | ||
239 | kind = wxClipboard::Clipboard; | |
240 | } | |
241 | else // some other selection, we're not concerned | |
242 | { | |
243 | return FALSE; | |
244 | } | |
245 | ||
246 | // the clipboard is no longer in our hands, we don't need data any more | |
247 | clipboard->GTKClearData(kind); | |
248 | ||
249 | return TRUE; | |
250 | } | |
251 | } | |
252 | ||
253 | //----------------------------------------------------------------------------- | |
254 | // selection handler for supplying data | |
255 | //----------------------------------------------------------------------------- | |
256 | ||
257 | extern "C" { | |
258 | static void | |
259 | selection_handler( GtkWidget *WXUNUSED(widget), | |
260 | GtkSelectionData *selection_data, | |
261 | guint WXUNUSED(info), | |
262 | guint WXUNUSED(time), | |
263 | gpointer signal_data ) | |
264 | { | |
265 | wxClipboard * const clipboard = wxTheClipboard; | |
266 | if ( !clipboard ) | |
267 | return; | |
268 | ||
269 | wxDataObject * const data = clipboard->GTKGetDataObject( | |
270 | gtk_selection_data_get_selection(selection_data)); | |
271 | if ( !data ) | |
272 | return; | |
273 | ||
274 | // ICCCM says that TIMESTAMP is a required atom. | |
275 | // In particular, it satisfies Klipper, which polls | |
276 | // TIMESTAMP to see if the clipboards content has changed. | |
277 | // It shall return the time which was used to set the data. | |
278 | if (gtk_selection_data_get_target(selection_data) == g_timestampAtom) | |
279 | { | |
280 | guint timestamp = GPOINTER_TO_UINT (signal_data); | |
281 | gtk_selection_data_set(selection_data, | |
282 | GDK_SELECTION_TYPE_INTEGER, | |
283 | 32, | |
284 | (guchar*)&(timestamp), | |
285 | sizeof(timestamp)); | |
286 | wxLogTrace(TRACE_CLIPBOARD, | |
287 | wxT("Clipboard TIMESTAMP requested, returning timestamp=%u"), | |
288 | timestamp); | |
289 | return; | |
290 | } | |
291 | ||
292 | wxDataFormat format(gtk_selection_data_get_target(selection_data)); | |
293 | ||
294 | wxLogTrace(TRACE_CLIPBOARD, | |
295 | wxT("clipboard data in format %s, GtkSelectionData is target=%s type=%s selection=%s timestamp=%u"), | |
296 | format.GetId().c_str(), | |
297 | wxString::FromAscii(wxGtkString(gdk_atom_name(gtk_selection_data_get_target(selection_data)))).c_str(), | |
298 | wxString::FromAscii(wxGtkString(gdk_atom_name(gtk_selection_data_get_data_type(selection_data)))).c_str(), | |
299 | wxString::FromAscii(wxGtkString(gdk_atom_name(gtk_selection_data_get_selection(selection_data)))).c_str(), | |
300 | GPOINTER_TO_UINT( signal_data ) | |
301 | ); | |
302 | ||
303 | if ( !data->IsSupportedFormat( format ) ) | |
304 | return; | |
305 | ||
306 | int size = data->GetDataSize( format ); | |
307 | if ( !size ) | |
308 | return; | |
309 | ||
310 | wxCharBuffer buf(size - 1); // it adds 1 internally (for NUL) | |
311 | ||
312 | // text data must be returned in UTF8 if format is wxDF_UNICODETEXT | |
313 | if ( !data->GetDataHere(format, buf.data()) ) | |
314 | return; | |
315 | ||
316 | // use UTF8_STRING format if requested in Unicode build but just plain | |
317 | // STRING one in ANSI or if explicitly asked in Unicode | |
318 | #if wxUSE_UNICODE | |
319 | if (format == wxDataFormat(wxDF_UNICODETEXT)) | |
320 | { | |
321 | gtk_selection_data_set_text( | |
322 | selection_data, | |
323 | (const gchar*)buf.data(), | |
324 | size ); | |
325 | } | |
326 | else | |
327 | #endif // wxUSE_UNICODE | |
328 | { | |
329 | gtk_selection_data_set( | |
330 | selection_data, | |
331 | format.GetFormatId(), | |
332 | 8*sizeof(gchar), | |
333 | (const guchar*)buf.data(), | |
334 | size ); | |
335 | } | |
336 | } | |
337 | } | |
338 | ||
339 | void wxClipboard::GTKOnSelectionReceived(const GtkSelectionData& sel) | |
340 | { | |
341 | wxCHECK_RET( m_receivedData, wxT("should be inside GetData()") ); | |
342 | ||
343 | const wxDataFormat format(gtk_selection_data_get_target(const_cast<GtkSelectionData*>(&sel))); | |
344 | wxLogTrace(TRACE_CLIPBOARD, wxT("Received selection %s"), | |
345 | format.GetId().c_str()); | |
346 | ||
347 | if ( !m_receivedData->IsSupportedFormat(format, wxDataObject::Set) ) | |
348 | return; | |
349 | ||
350 | m_receivedData->SetData(format, | |
351 | gtk_selection_data_get_length(const_cast<GtkSelectionData*>(&sel)), | |
352 | gtk_selection_data_get_data(const_cast<GtkSelectionData*>(&sel))); | |
353 | m_formatSupported = true; | |
354 | } | |
355 | ||
356 | //----------------------------------------------------------------------------- | |
357 | // asynchronous "selection_received" for targets | |
358 | //----------------------------------------------------------------------------- | |
359 | ||
360 | extern "C" { | |
361 | static void | |
362 | async_targets_selection_received( GtkWidget *WXUNUSED(widget), | |
363 | GtkSelectionData *selection_data, | |
364 | guint32 WXUNUSED(time), | |
365 | wxClipboard *clipboard ) | |
366 | { | |
367 | if ( !clipboard ) // Assert? | |
368 | return; | |
369 | ||
370 | if (!clipboard->m_sink) | |
371 | return; | |
372 | ||
373 | wxClipboardEvent *event = new wxClipboardEvent(wxEVT_CLIPBOARD_CHANGED); | |
374 | event->SetEventObject( clipboard ); | |
375 | ||
376 | int selection_data_length = 0; | |
377 | if (selection_data) | |
378 | selection_data_length = gtk_selection_data_get_length(selection_data); | |
379 | ||
380 | if (selection_data_length <= 0) | |
381 | { | |
382 | clipboard->m_sink->QueueEvent( event ); | |
383 | clipboard->m_sink.Release(); | |
384 | return; | |
385 | } | |
386 | ||
387 | // make sure we got the data in the correct form | |
388 | GdkAtom type = gtk_selection_data_get_data_type(selection_data); | |
389 | if ( type != GDK_SELECTION_TYPE_ATOM ) | |
390 | { | |
391 | if ( strcmp(wxGtkString(gdk_atom_name(type)), "TARGETS") != 0 ) | |
392 | { | |
393 | wxLogTrace( TRACE_CLIPBOARD, | |
394 | wxT("got unsupported clipboard target") ); | |
395 | ||
396 | clipboard->m_sink->QueueEvent( event ); | |
397 | clipboard->m_sink.Release(); | |
398 | return; | |
399 | } | |
400 | } | |
401 | ||
402 | // it's not really a format, of course, but we can reuse its GetId() method | |
403 | // to format this atom as string | |
404 | wxDataFormat clip(gtk_selection_data_get_selection(selection_data)); | |
405 | wxLogTrace( TRACE_CLIPBOARD, | |
406 | wxT("Received available formats for clipboard %s"), | |
407 | clip.GetId().c_str() ); | |
408 | ||
409 | // the atoms we received, holding a list of targets (= formats) | |
410 | const GdkAtom* const atoms = (GdkAtom*)gtk_selection_data_get_data(selection_data); | |
411 | for (size_t i = 0; i < selection_data_length / sizeof(GdkAtom); i++) | |
412 | { | |
413 | const wxDataFormat format(atoms[i]); | |
414 | ||
415 | wxLogTrace(TRACE_CLIPBOARD, wxT("\t%s"), format.GetId().c_str()); | |
416 | ||
417 | event->AddFormat( format ); | |
418 | } | |
419 | ||
420 | clipboard->m_sink->QueueEvent( event ); | |
421 | clipboard->m_sink.Release(); | |
422 | } | |
423 | } | |
424 | ||
425 | // ============================================================================ | |
426 | // wxClipboard implementation | |
427 | // ============================================================================ | |
428 | ||
429 | // ---------------------------------------------------------------------------- | |
430 | // wxClipboard ctor/dtor | |
431 | // ---------------------------------------------------------------------------- | |
432 | ||
433 | IMPLEMENT_DYNAMIC_CLASS(wxClipboard,wxObject) | |
434 | ||
435 | wxClipboard::wxClipboard() | |
436 | { | |
437 | m_idSelectionGetHandler = 0; | |
438 | ||
439 | m_open = false; | |
440 | ||
441 | m_dataPrimary = | |
442 | m_dataClipboard = | |
443 | m_receivedData = NULL; | |
444 | ||
445 | m_formatSupported = false; | |
446 | m_targetRequested = 0; | |
447 | ||
448 | // we use m_targetsWidget to query what formats are available | |
449 | m_targetsWidget = gtk_window_new( GTK_WINDOW_POPUP ); | |
450 | gtk_widget_realize( m_targetsWidget ); | |
451 | ||
452 | g_signal_connect (m_targetsWidget, "selection_received", | |
453 | G_CALLBACK (targets_selection_received), this); | |
454 | ||
455 | // we use m_targetsWidgetAsync to query what formats are available asynchronously | |
456 | m_targetsWidgetAsync = gtk_window_new( GTK_WINDOW_POPUP ); | |
457 | gtk_widget_realize( m_targetsWidgetAsync ); | |
458 | ||
459 | g_signal_connect (m_targetsWidgetAsync, "selection_received", | |
460 | G_CALLBACK (async_targets_selection_received), this); | |
461 | ||
462 | // we use m_clipboardWidget to get and to offer data | |
463 | m_clipboardWidget = gtk_window_new( GTK_WINDOW_POPUP ); | |
464 | gtk_widget_realize( m_clipboardWidget ); | |
465 | ||
466 | g_signal_connect (m_clipboardWidget, "selection_received", | |
467 | G_CALLBACK (selection_received), this); | |
468 | ||
469 | g_signal_connect (m_clipboardWidget, "selection_clear_event", | |
470 | G_CALLBACK (selection_clear_clip), NULL); | |
471 | ||
472 | // initialize atoms we use if not done yet | |
473 | if ( !g_clipboardAtom ) | |
474 | g_clipboardAtom = gdk_atom_intern( "CLIPBOARD", FALSE ); | |
475 | if ( !g_targetsAtom ) | |
476 | g_targetsAtom = gdk_atom_intern ("TARGETS", FALSE); | |
477 | if ( !g_timestampAtom ) | |
478 | g_timestampAtom = gdk_atom_intern ("TIMESTAMP", FALSE); | |
479 | } | |
480 | ||
481 | wxClipboard::~wxClipboard() | |
482 | { | |
483 | Clear(); | |
484 | ||
485 | gtk_widget_destroy( m_clipboardWidget ); | |
486 | gtk_widget_destroy( m_targetsWidget ); | |
487 | } | |
488 | ||
489 | // ---------------------------------------------------------------------------- | |
490 | // wxClipboard helper functions | |
491 | // ---------------------------------------------------------------------------- | |
492 | ||
493 | GdkAtom wxClipboard::GTKGetClipboardAtom() const | |
494 | { | |
495 | return m_usePrimary ? (GdkAtom)GDK_SELECTION_PRIMARY | |
496 | : g_clipboardAtom; | |
497 | } | |
498 | ||
499 | void wxClipboard::GTKClearData(Kind kind) | |
500 | { | |
501 | wxDataObject *&data = Data(kind); | |
502 | wxDELETE(data); | |
503 | } | |
504 | ||
505 | bool wxClipboard::SetSelectionOwner(bool set) | |
506 | { | |
507 | bool rc = gtk_selection_owner_set | |
508 | ( | |
509 | set ? m_clipboardWidget : NULL, | |
510 | GTKGetClipboardAtom(), | |
511 | (guint32)GDK_CURRENT_TIME | |
512 | ) != 0; | |
513 | ||
514 | if ( !rc ) | |
515 | { | |
516 | wxLogTrace(TRACE_CLIPBOARD, wxT("Failed to %sset selection owner"), | |
517 | set ? wxT("") : wxT("un")); | |
518 | } | |
519 | ||
520 | return rc; | |
521 | } | |
522 | ||
523 | void wxClipboard::AddSupportedTarget(GdkAtom atom) | |
524 | { | |
525 | gtk_selection_add_target | |
526 | ( | |
527 | m_clipboardWidget, | |
528 | GTKGetClipboardAtom(), | |
529 | atom, | |
530 | 0 // info (same as client data) unused | |
531 | ); | |
532 | } | |
533 | ||
534 | bool wxClipboard::IsSupportedAsync(wxEvtHandler *sink) | |
535 | { | |
536 | if (m_sink.get()) | |
537 | return false; // currently busy, come back later | |
538 | ||
539 | wxCHECK_MSG( sink, false, wxT("no sink given") ); | |
540 | ||
541 | m_sink = sink; | |
542 | gtk_selection_convert( m_targetsWidgetAsync, | |
543 | GTKGetClipboardAtom(), | |
544 | g_targetsAtom, | |
545 | (guint32) GDK_CURRENT_TIME ); | |
546 | ||
547 | return true; | |
548 | } | |
549 | ||
550 | bool wxClipboard::DoIsSupported(const wxDataFormat& format) | |
551 | { | |
552 | wxCHECK_MSG( format, false, wxT("invalid clipboard format") ); | |
553 | ||
554 | wxLogTrace(TRACE_CLIPBOARD, wxT("Checking if format %s is available"), | |
555 | format.GetId().c_str()); | |
556 | ||
557 | // these variables will be used by our GTKOnTargetReceived() | |
558 | m_targetRequested = format; | |
559 | m_formatSupported = false; | |
560 | ||
561 | // block until m_formatSupported is set from targets_selection_received | |
562 | // callback | |
563 | { | |
564 | wxClipboardSync sync(*this); | |
565 | ||
566 | gtk_selection_convert( m_targetsWidget, | |
567 | GTKGetClipboardAtom(), | |
568 | g_targetsAtom, | |
569 | (guint32) GDK_CURRENT_TIME ); | |
570 | } | |
571 | ||
572 | return m_formatSupported; | |
573 | } | |
574 | ||
575 | // ---------------------------------------------------------------------------- | |
576 | // wxClipboard public API implementation | |
577 | // ---------------------------------------------------------------------------- | |
578 | ||
579 | void wxClipboard::Clear() | |
580 | { | |
581 | gtk_selection_clear_targets( m_clipboardWidget, GTKGetClipboardAtom() ); | |
582 | ||
583 | if ( gdk_selection_owner_get(GTKGetClipboardAtom()) == | |
584 | gtk_widget_get_window(m_clipboardWidget) ) | |
585 | { | |
586 | wxClipboardSync sync(*this); | |
587 | ||
588 | // this will result in selection_clear_clip callback being called and | |
589 | // it will free our data | |
590 | SetSelectionOwner(false); | |
591 | } | |
592 | ||
593 | m_targetRequested = 0; | |
594 | m_formatSupported = false; | |
595 | } | |
596 | ||
597 | bool wxClipboard::Open() | |
598 | { | |
599 | wxCHECK_MSG( !m_open, false, wxT("clipboard already open") ); | |
600 | ||
601 | m_open = true; | |
602 | ||
603 | return true; | |
604 | } | |
605 | ||
606 | bool wxClipboard::SetData( wxDataObject *data ) | |
607 | { | |
608 | wxCHECK_MSG( m_open, false, wxT("clipboard not open") ); | |
609 | ||
610 | wxCHECK_MSG( data, false, wxT("data is invalid") ); | |
611 | ||
612 | Clear(); | |
613 | ||
614 | return AddData( data ); | |
615 | } | |
616 | ||
617 | bool wxClipboard::AddData( wxDataObject *data ) | |
618 | { | |
619 | wxCHECK_MSG( m_open, false, wxT("clipboard not open") ); | |
620 | ||
621 | wxCHECK_MSG( data, false, wxT("data is invalid") ); | |
622 | ||
623 | // we can only store one wxDataObject so clear the old one | |
624 | Clear(); | |
625 | ||
626 | Data() = data; | |
627 | ||
628 | // get formats from wxDataObjects | |
629 | const size_t count = data->GetFormatCount(); | |
630 | wxDataFormatArray formats(new wxDataFormat[count]); | |
631 | data->GetAllFormats(formats.get()); | |
632 | ||
633 | // always provide TIMESTAMP as a target, see comments in selection_handler | |
634 | // for explanation | |
635 | AddSupportedTarget(g_timestampAtom); | |
636 | ||
637 | for ( size_t i = 0; i < count; i++ ) | |
638 | { | |
639 | const wxDataFormat format(formats[i]); | |
640 | ||
641 | wxLogTrace(TRACE_CLIPBOARD, wxT("Adding support for %s"), | |
642 | format.GetId().c_str()); | |
643 | ||
644 | AddSupportedTarget(format); | |
645 | } | |
646 | ||
647 | if ( !m_idSelectionGetHandler ) | |
648 | { | |
649 | m_idSelectionGetHandler = g_signal_connect ( | |
650 | m_clipboardWidget, "selection_get", | |
651 | G_CALLBACK (selection_handler), | |
652 | GUINT_TO_POINTER (gtk_get_current_event_time()) ); | |
653 | } | |
654 | ||
655 | // tell the world we offer clipboard data | |
656 | return SetSelectionOwner(); | |
657 | } | |
658 | ||
659 | void wxClipboard::Close() | |
660 | { | |
661 | wxCHECK_RET( m_open, wxT("clipboard not open") ); | |
662 | ||
663 | m_open = false; | |
664 | } | |
665 | ||
666 | bool wxClipboard::IsOpened() const | |
667 | { | |
668 | return m_open; | |
669 | } | |
670 | ||
671 | bool wxClipboard::IsSupported( const wxDataFormat& format ) | |
672 | { | |
673 | if ( DoIsSupported(format) ) | |
674 | return true; | |
675 | ||
676 | #if wxUSE_UNICODE | |
677 | if ( format == wxDF_UNICODETEXT ) | |
678 | { | |
679 | // also with plain STRING format | |
680 | return DoIsSupported(g_altTextAtom); | |
681 | } | |
682 | #endif // wxUSE_UNICODE | |
683 | ||
684 | return false; | |
685 | } | |
686 | ||
687 | bool wxClipboard::GetData( wxDataObject& data ) | |
688 | { | |
689 | wxCHECK_MSG( m_open, false, wxT("clipboard not open") ); | |
690 | ||
691 | // get all supported formats from wxDataObjects: notice that we are setting | |
692 | // the object data, so we need them in "Set" direction | |
693 | const size_t count = data.GetFormatCount(wxDataObject::Set); | |
694 | wxDataFormatArray formats(new wxDataFormat[count]); | |
695 | data.GetAllFormats(formats.get(), wxDataObject::Set); | |
696 | ||
697 | for ( size_t i = 0; i < count; i++ ) | |
698 | { | |
699 | const wxDataFormat format(formats[i]); | |
700 | ||
701 | // is this format supported by clipboard ? | |
702 | if ( !DoIsSupported(format) ) | |
703 | continue; | |
704 | ||
705 | wxLogTrace(TRACE_CLIPBOARD, wxT("Requesting format %s"), | |
706 | format.GetId().c_str()); | |
707 | ||
708 | // these variables will be used by our GTKOnSelectionReceived() | |
709 | m_receivedData = &data; | |
710 | m_formatSupported = false; | |
711 | ||
712 | { | |
713 | wxClipboardSync sync(*this); | |
714 | ||
715 | gtk_selection_convert(m_clipboardWidget, | |
716 | GTKGetClipboardAtom(), | |
717 | format, | |
718 | (guint32) GDK_CURRENT_TIME ); | |
719 | } // wait until we get the results | |
720 | ||
721 | /* | |
722 | Normally this is a true error as we checked for the presence of such | |
723 | data before, but there are applications that may return an empty | |
724 | string (e.g. Gnumeric-1.6.1 on Linux if an empty cell is copied) | |
725 | which would produce a false error message here, so we check for the | |
726 | size of the string first. With ANSI, GetDataSize returns an extra | |
727 | value (for the closing null?), with unicode, the exact number of | |
728 | tokens is given (that is more than 1 for non-ASCII characters) | |
729 | (tested with Gnumeric-1.6.1 and OpenOffice.org-2.0.2) | |
730 | */ | |
731 | #if wxUSE_UNICODE | |
732 | if ( format != wxDF_UNICODETEXT || data.GetDataSize(format) > 0 ) | |
733 | #else // !UNICODE | |
734 | if ( format != wxDF_TEXT || data.GetDataSize(format) > 1 ) | |
735 | #endif // UNICODE / !UNICODE | |
736 | { | |
737 | wxCHECK_MSG( m_formatSupported, false, | |
738 | wxT("error retrieving data from clipboard") ); | |
739 | } | |
740 | ||
741 | return true; | |
742 | } | |
743 | ||
744 | wxLogTrace(TRACE_CLIPBOARD, wxT("GetData(): format not found")); | |
745 | ||
746 | return false; | |
747 | } | |
748 | ||
749 | wxDataObject* wxClipboard::GTKGetDataObject( GdkAtom atom ) | |
750 | { | |
751 | if ( atom == GDK_NONE ) | |
752 | return Data(); | |
753 | ||
754 | if ( atom == GDK_SELECTION_PRIMARY ) | |
755 | { | |
756 | wxLogTrace(TRACE_CLIPBOARD, wxT("Primary selection requested" )); | |
757 | ||
758 | return Data( wxClipboard::Primary ); | |
759 | } | |
760 | else if ( atom == g_clipboardAtom ) | |
761 | { | |
762 | wxLogTrace(TRACE_CLIPBOARD, wxT("Clipboard data requested" )); | |
763 | ||
764 | return Data( wxClipboard::Clipboard ); | |
765 | } | |
766 | else // some other selection, we're not concerned | |
767 | { | |
768 | return (wxDataObject*)NULL; | |
769 | } | |
770 | } | |
771 | ||
772 | #endif // wxUSE_CLIPBOARD |