]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/gtk/clipbrd.cpp
missing commit
[wxWidgets.git] / src / gtk / clipbrd.cpp
... / ...
CommitLineData
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
39typedef wxScopedArray<wxDataFormat> wxDataFormatArray;
40
41// ----------------------------------------------------------------------------
42// data
43// ----------------------------------------------------------------------------
44
45static GdkAtom g_clipboardAtom = 0;
46static GdkAtom g_targetsAtom = 0;
47static GdkAtom g_timestampAtom = 0;
48
49#if wxUSE_UNICODE
50extern 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
67class wxClipboardSync
68{
69public:
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
108private:
109 static wxClipboard *ms_clipboard;
110
111 wxDECLARE_NO_COPY_CLASS(wxClipboardSync);
112};
113
114wxClipboard *wxClipboardSync::ms_clipboard = NULL;
115
116// ============================================================================
117// clipboard callbacks implementation
118// ============================================================================
119
120//-----------------------------------------------------------------------------
121// "selection_received" for targets
122//-----------------------------------------------------------------------------
123
124extern "C" {
125static void
126targets_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
177bool 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
190extern "C" {
191static void
192selection_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
213extern "C" {
214static gint
215selection_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
257extern "C" {
258static void
259selection_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
339void 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
360extern "C" {
361static void
362async_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
433IMPLEMENT_DYNAMIC_CLASS(wxClipboard,wxObject)
434
435wxClipboard::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
481wxClipboard::~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
493GdkAtom wxClipboard::GTKGetClipboardAtom() const
494{
495 return m_usePrimary ? (GdkAtom)GDK_SELECTION_PRIMARY
496 : g_clipboardAtom;
497}
498
499void wxClipboard::GTKClearData(Kind kind)
500{
501 wxDataObject *&data = Data(kind);
502 wxDELETE(data);
503}
504
505bool 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
523void 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
534bool 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
550bool 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
579void 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
597bool wxClipboard::Open()
598{
599 wxCHECK_MSG( !m_open, false, wxT("clipboard already open") );
600
601 m_open = true;
602
603 return true;
604}
605
606bool 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
617bool 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
659void wxClipboard::Close()
660{
661 wxCHECK_RET( m_open, wxT("clipboard not open") );
662
663 m_open = false;
664}
665
666bool wxClipboard::IsOpened() const
667{
668 return m_open;
669}
670
671bool 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
687bool 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
749wxDataObject* 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