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