]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/gtk/clipbrd.cpp
Further sorting work using the sorting data model.
[wxWidgets.git] / src / gtk / clipbrd.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: gtk/clipbrd.cpp
3// Purpose:
4// Author: Robert Roebling
5// Id: $Id$
6// Copyright: (c) 1998 Robert Roebling
7// Licence: wxWindows licence
8/////////////////////////////////////////////////////////////////////////////
9
10// For compilers that support precompilation, includes "wx.h".
11#include "wx/wxprec.h"
12
13#include "wx/clipbrd.h"
14
15#if wxUSE_CLIPBOARD
16
17#include "wx/dataobj.h"
18#include "wx/utils.h"
19#include "wx/log.h"
20
21#include <glib.h>
22#include <gdk/gdk.h>
23#include <gtk/gtk.h>
24
25//-----------------------------------------------------------------------------
26// thread system
27//-----------------------------------------------------------------------------
28
29#if wxUSE_THREADS
30#endif
31
32//-----------------------------------------------------------------------------
33// data
34//-----------------------------------------------------------------------------
35
36GdkAtom g_clipboardAtom = 0;
37GdkAtom g_targetsAtom = 0;
38
39#if defined(__WXGTK20__) && wxUSE_UNICODE
40extern GdkAtom g_altTextAtom;
41#endif
42
43// the trace mask we use with wxLogTrace() - call
44// wxLog::AddTraceMask(TRACE_CLIPBOARD) to enable the trace messages from here
45// (there will be a *lot* of them!)
46static const wxChar *TRACE_CLIPBOARD = _T("clipboard");
47
48//-----------------------------------------------------------------------------
49// reminder
50//-----------------------------------------------------------------------------
51
52/* The contents of a selection are returned in a GtkSelectionData
53 structure. selection/target identify the request.
54 type specifies the type of the return; if length < 0, and
55 the data should be ignored. This structure has object semantics -
56 no fields should be modified directly, they should not be created
57 directly, and pointers to them should not be stored beyond the duration of
58 a callback. (If the last is changed, we'll need to add reference
59 counting)
60
61struct _GtkSelectionData
62{
63 GdkAtom selection;
64 GdkAtom target;
65 GdkAtom type;
66 gint format;
67 guchar *data;
68 gint length;
69};
70
71*/
72
73//-----------------------------------------------------------------------------
74// "selection_received" for targets
75//-----------------------------------------------------------------------------
76
77extern "C" {
78static void
79targets_selection_received( GtkWidget *WXUNUSED(widget),
80 GtkSelectionData *selection_data,
81 guint32 WXUNUSED(time),
82 wxClipboard *clipboard )
83{
84 if ( wxTheClipboard && selection_data->length > 0 )
85 {
86 // make sure we got the data in the correct form
87 GdkAtom type = selection_data->type;
88 if ( type != GDK_SELECTION_TYPE_ATOM )
89 {
90 if ( strcmp(gdk_atom_name(type), "TARGETS") )
91 {
92 wxLogTrace( TRACE_CLIPBOARD,
93 _T("got unsupported clipboard target") );
94
95 clipboard->m_waiting = FALSE;
96 return;
97 }
98 }
99
100#ifdef __WXDEBUG__
101 wxDataFormat clip( selection_data->selection );
102 wxLogTrace( TRACE_CLIPBOARD,
103 wxT("selection received for targets, clipboard %s"),
104 clip.GetId().c_str() );
105#endif // __WXDEBUG__
106
107 // the atoms we received, holding a list of targets (= formats)
108 GdkAtom *atoms = (GdkAtom *)selection_data->data;
109
110 for (unsigned int i=0; i<selection_data->length/sizeof(GdkAtom); i++)
111 {
112 wxDataFormat format( atoms[i] );
113
114 wxLogTrace( TRACE_CLIPBOARD,
115 wxT("selection received for targets, format %s"),
116 format.GetId().c_str() );
117
118// printf( "format %s requested %s\n",
119// gdk_atom_name( atoms[i] ),
120// gdk_atom_name( clipboard->m_targetRequested ) );
121
122 if (format == clipboard->m_targetRequested)
123 {
124 clipboard->m_waiting = FALSE;
125 clipboard->m_formatSupported = TRUE;
126 return;
127 }
128 }
129 }
130
131 clipboard->m_waiting = FALSE;
132}
133}
134
135//-----------------------------------------------------------------------------
136// "selection_received" for the actual data
137//-----------------------------------------------------------------------------
138
139extern "C" {
140static void
141selection_received( GtkWidget *WXUNUSED(widget),
142 GtkSelectionData *selection_data,
143 guint32 WXUNUSED(time),
144 wxClipboard *clipboard )
145{
146 if (!wxTheClipboard)
147 {
148 clipboard->m_waiting = FALSE;
149 return;
150 }
151
152 wxDataObject *data_object = clipboard->m_receivedData;
153
154 if (!data_object)
155 {
156 clipboard->m_waiting = FALSE;
157 return;
158 }
159
160 if (selection_data->length <= 0)
161 {
162 clipboard->m_waiting = FALSE;
163 return;
164 }
165
166 wxDataFormat format( selection_data->target );
167
168 // make sure we got the data in the correct format
169 if (!data_object->IsSupportedFormat( format ) )
170 {
171 clipboard->m_waiting = FALSE;
172 return;
173 }
174
175#if 0
176 This seems to cause problems somehow
177 // make sure we got the data in the correct form (selection type).
178 // if so, copy data to target object
179 if (selection_data->type != GDK_SELECTION_TYPE_STRING)
180 {
181 clipboard->m_waiting = FALSE;
182 return;
183 }
184#endif
185
186 data_object->SetData( format, (size_t) selection_data->length, (const char*) selection_data->data );
187
188 wxTheClipboard->m_formatSupported = TRUE;
189 clipboard->m_waiting = FALSE;
190}
191}
192
193//-----------------------------------------------------------------------------
194// "selection_clear"
195//-----------------------------------------------------------------------------
196
197extern "C" {
198static gint
199selection_clear_clip( GtkWidget *WXUNUSED(widget), GdkEventSelection *event )
200{
201 if (!wxTheClipboard) return TRUE;
202
203 if (event->selection == GDK_SELECTION_PRIMARY)
204 {
205 wxTheClipboard->m_ownsPrimarySelection = FALSE;
206 }
207 else
208 if (event->selection == g_clipboardAtom)
209 {
210 wxTheClipboard->m_ownsClipboard = FALSE;
211 }
212 else
213 {
214 wxTheClipboard->m_waiting = FALSE;
215 return FALSE;
216 }
217
218 if ((!wxTheClipboard->m_ownsPrimarySelection) &&
219 (!wxTheClipboard->m_ownsClipboard))
220 {
221 /* the clipboard is no longer in our hands. we can the delete clipboard data. */
222 if (wxTheClipboard->m_data)
223 {
224 wxLogTrace(TRACE_CLIPBOARD, wxT("wxClipboard will get cleared" ));
225
226 delete wxTheClipboard->m_data;
227 wxTheClipboard->m_data = (wxDataObject*) NULL;
228 }
229 }
230
231 wxTheClipboard->m_waiting = FALSE;
232 return TRUE;
233}
234}
235
236//-----------------------------------------------------------------------------
237// selection handler for supplying data
238//-----------------------------------------------------------------------------
239
240extern "C" {
241static void
242selection_handler( GtkWidget *WXUNUSED(widget),
243 GtkSelectionData *selection_data,
244 guint WXUNUSED(info),
245 guint WXUNUSED(time),
246 gpointer WXUNUSED(data) )
247{
248 if (!wxTheClipboard) return;
249
250 if (!wxTheClipboard->m_data) return;
251
252 wxDataObject *data = wxTheClipboard->m_data;
253
254 wxDataFormat format( selection_data->target );
255
256#ifdef __WXDEBUG__
257 wxLogTrace(TRACE_CLIPBOARD,
258 _T("clipboard data in format %s, GtkSelectionData is target=%s type=%s selection=%s"),
259 format.GetId().c_str(),
260 wxString::FromAscii(gdk_atom_name(selection_data->target)).c_str(),
261 wxString::FromAscii(gdk_atom_name(selection_data->type)).c_str(),
262 wxString::FromAscii(gdk_atom_name(selection_data->selection)).c_str()
263 );
264#endif
265
266 if (!data->IsSupportedFormat( format )) return;
267
268 int size = data->GetDataSize( format );
269
270 if (size == 0) return;
271
272 void *d = malloc(size);
273
274 // Text data will be in UTF8 in Unicode mode.
275 data->GetDataHere( selection_data->target, d );
276
277 // NB: GTK+ requires special treatment of UTF8_STRING data, the text
278 // would show as UTF-8 data interpreted as latin1 (?) in other
279 // GTK+ apps if we used gtk_selection_data_set()
280 if (format == wxDataFormat(wxDF_UNICODETEXT))
281 {
282 gtk_selection_data_set_text(
283 selection_data,
284 (const gchar*)d,
285 size-1 );
286 }
287 else
288 {
289 gtk_selection_data_set(
290 selection_data,
291 GDK_SELECTION_TYPE_STRING,
292 8*sizeof(gchar),
293 (unsigned char*) d,
294 size-1 );
295 }
296
297 free(d);
298}
299}
300
301//-----------------------------------------------------------------------------
302// wxClipboard
303//-----------------------------------------------------------------------------
304
305IMPLEMENT_DYNAMIC_CLASS(wxClipboard,wxObject)
306
307wxClipboard::wxClipboard()
308{
309 m_open = FALSE;
310 m_waiting = FALSE;
311
312 m_ownsClipboard = FALSE;
313 m_ownsPrimarySelection = FALSE;
314
315 m_data = (wxDataObject*) NULL;
316 m_receivedData = (wxDataObject*) NULL;
317
318 /* we use m_targetsWidget to query what formats are available */
319
320 m_targetsWidget = gtk_window_new( GTK_WINDOW_POPUP );
321 gtk_widget_realize( m_targetsWidget );
322
323 g_signal_connect (m_targetsWidget, "selection_received",
324 G_CALLBACK (targets_selection_received), this);
325
326 /* we use m_clipboardWidget to get and to offer data */
327
328 m_clipboardWidget = gtk_window_new( GTK_WINDOW_POPUP );
329 gtk_widget_realize( m_clipboardWidget );
330
331 g_signal_connect (m_clipboardWidget, "selection_received",
332 G_CALLBACK (selection_received), this);
333
334 g_signal_connect (m_clipboardWidget, "selection_clear_event",
335 G_CALLBACK (selection_clear_clip), NULL);
336
337 if (!g_clipboardAtom) g_clipboardAtom = gdk_atom_intern( "CLIPBOARD", FALSE );
338 if (!g_targetsAtom) g_targetsAtom = gdk_atom_intern ("TARGETS", FALSE);
339
340 m_formatSupported = FALSE;
341 m_targetRequested = 0;
342
343 m_usePrimary = FALSE;
344}
345
346wxClipboard::~wxClipboard()
347{
348 Clear();
349
350 if (m_clipboardWidget) gtk_widget_destroy( m_clipboardWidget );
351 if (m_targetsWidget) gtk_widget_destroy( m_targetsWidget );
352}
353
354void wxClipboard::Clear()
355{
356 if (m_data)
357 {
358#if wxUSE_THREADS
359 /* disable GUI threads */
360#endif
361
362 // As we have data we also own the clipboard. Once we no longer own
363 // it, clear_selection is called which will set m_data to zero
364 if (gdk_selection_owner_get( g_clipboardAtom ) == m_clipboardWidget->window)
365 {
366 m_waiting = TRUE;
367
368 gtk_selection_owner_set( (GtkWidget*) NULL, g_clipboardAtom,
369 (guint32) GDK_CURRENT_TIME );
370
371 while (m_waiting) gtk_main_iteration();
372 }
373
374 if (gdk_selection_owner_get( GDK_SELECTION_PRIMARY ) == m_clipboardWidget->window)
375 {
376 m_waiting = TRUE;
377
378 gtk_selection_owner_set( (GtkWidget*) NULL, GDK_SELECTION_PRIMARY,
379 (guint32) GDK_CURRENT_TIME );
380
381 while (m_waiting) gtk_main_iteration();
382 }
383
384 if (m_data)
385 {
386 delete m_data;
387 m_data = (wxDataObject*) NULL;
388 }
389
390#if wxUSE_THREADS
391 /* re-enable GUI threads */
392#endif
393 }
394
395 m_targetRequested = 0;
396 m_formatSupported = FALSE;
397}
398
399bool wxClipboard::Open()
400{
401 wxCHECK_MSG( !m_open, FALSE, wxT("clipboard already open") );
402
403 m_open = TRUE;
404
405 return TRUE;
406}
407
408bool wxClipboard::SetData( wxDataObject *data )
409{
410 wxCHECK_MSG( m_open, FALSE, wxT("clipboard not open") );
411
412 wxCHECK_MSG( data, FALSE, wxT("data is invalid") );
413
414 Clear();
415
416 return AddData( data );
417}
418
419bool wxClipboard::AddData( wxDataObject *data )
420{
421 wxCHECK_MSG( m_open, FALSE, wxT("clipboard not open") );
422
423 wxCHECK_MSG( data, FALSE, wxT("data is invalid") );
424
425 // we can only store one wxDataObject
426 Clear();
427
428 m_data = data;
429
430 // get formats from wxDataObjects
431 wxDataFormat *array = new wxDataFormat[ m_data->GetFormatCount() ];
432 m_data->GetAllFormats( array );
433
434 // primary selection or clipboard
435 GdkAtom clipboard = m_usePrimary ? (GdkAtom)GDK_SELECTION_PRIMARY
436 : g_clipboardAtom;
437
438
439 for (size_t i = 0; i < m_data->GetFormatCount(); i++)
440 {
441 wxLogTrace( TRACE_CLIPBOARD,
442 wxT("wxClipboard now supports atom %s"),
443 array[i].GetId().c_str() );
444
445// printf( "added %s\n",
446// gdk_atom_name( array[i].GetFormatId() ) );
447
448 gtk_selection_add_target( GTK_WIDGET(m_clipboardWidget),
449 clipboard,
450 array[i],
451 0 ); /* what is info ? */
452 }
453
454 delete[] array;
455
456 g_signal_connect (m_clipboardWidget, "selection_get",
457 G_CALLBACK (selection_handler), NULL);
458
459#if wxUSE_THREADS
460 /* disable GUI threads */
461#endif
462
463 /* Tell the world we offer clipboard data */
464 bool res = (gtk_selection_owner_set( m_clipboardWidget,
465 clipboard,
466 (guint32) GDK_CURRENT_TIME ));
467
468 if (m_usePrimary)
469 m_ownsPrimarySelection = res;
470 else
471 m_ownsClipboard = res;
472
473#if wxUSE_THREADS
474 /* re-enable GUI threads */
475#endif
476
477 return res;
478}
479
480void wxClipboard::Close()
481{
482 wxCHECK_RET( m_open, wxT("clipboard not open") );
483
484 m_open = FALSE;
485}
486
487bool wxClipboard::IsOpened() const
488{
489 return m_open;
490}
491
492bool wxClipboard::IsSupported( const wxDataFormat& format )
493{
494 /* reentrance problems */
495 if (m_waiting) return FALSE;
496
497 /* store requested format to be asked for by callbacks */
498 m_targetRequested = format;
499
500 wxLogTrace( TRACE_CLIPBOARD,
501 wxT("wxClipboard:IsSupported: requested format: %s"),
502 format.GetId().c_str() );
503
504 wxCHECK_MSG( m_targetRequested, FALSE, wxT("invalid clipboard format") );
505
506 m_formatSupported = FALSE;
507
508 /* perform query. this will set m_formatSupported to
509 TRUE if m_targetRequested is supported.
510 also, we have to wait for the "answer" from the
511 clipboard owner which is an asynchronous process.
512 therefore we set m_waiting = TRUE here and wait
513 until the callback "targets_selection_received"
514 sets it to FALSE */
515
516 m_waiting = TRUE;
517
518 gtk_selection_convert( m_targetsWidget,
519 m_usePrimary ? (GdkAtom)GDK_SELECTION_PRIMARY
520 : g_clipboardAtom,
521 g_targetsAtom,
522 (guint32) GDK_CURRENT_TIME );
523
524 while (m_waiting) gtk_main_iteration();
525
526#if defined(__WXGTK20__) && wxUSE_UNICODE
527 if (!m_formatSupported && format == wxDataFormat(wxDF_UNICODETEXT))
528 {
529 // Another try with plain STRING format
530 extern GdkAtom g_altTextAtom;
531 return IsSupported(g_altTextAtom);
532 }
533#endif
534
535 return m_formatSupported;
536}
537
538bool wxClipboard::GetData( wxDataObject& data )
539{
540 wxCHECK_MSG( m_open, FALSE, wxT("clipboard not open") );
541
542 /* get formats from wxDataObjects */
543 wxDataFormat *array = new wxDataFormat[ data.GetFormatCount() ];
544 data.GetAllFormats( array );
545
546 for (size_t i = 0; i < data.GetFormatCount(); i++)
547 {
548 wxDataFormat format( array[i] );
549
550 wxLogTrace( TRACE_CLIPBOARD,
551 wxT("wxClipboard::GetData: requested format: %s"),
552 format.GetId().c_str() );
553
554 /* is data supported by clipboard ? */
555
556 /* store requested format to be asked for by callbacks */
557 m_targetRequested = format;
558
559 wxCHECK_MSG( m_targetRequested, FALSE, wxT("invalid clipboard format") );
560
561 m_formatSupported = FALSE;
562
563 /* perform query. this will set m_formatSupported to
564 TRUE if m_targetRequested is supported.
565 also, we have to wait for the "answer" from the
566 clipboard owner which is an asynchronous process.
567 therefore we set m_waiting = TRUE here and wait
568 until the callback "targets_selection_received"
569 sets it to FALSE */
570
571 m_waiting = TRUE;
572
573 gtk_selection_convert( m_targetsWidget,
574 m_usePrimary ? (GdkAtom)GDK_SELECTION_PRIMARY
575 : g_clipboardAtom,
576 g_targetsAtom,
577 (guint32) GDK_CURRENT_TIME );
578
579 while (m_waiting) gtk_main_iteration();
580
581 if (!m_formatSupported) continue;
582
583 /* store pointer to data object to be filled up by callbacks */
584 m_receivedData = &data;
585
586 /* store requested format to be asked for by callbacks */
587 m_targetRequested = format;
588
589 wxCHECK_MSG( m_targetRequested, FALSE, wxT("invalid clipboard format") );
590
591 /* start query */
592 m_formatSupported = FALSE;
593
594 /* ask for clipboard contents. this will set
595 m_formatSupported to TRUE if m_targetRequested
596 is supported.
597 also, we have to wait for the "answer" from the
598 clipboard owner which is an asynchronous process.
599 therefore we set m_waiting = TRUE here and wait
600 until the callback "targets_selection_received"
601 sets it to FALSE */
602
603 m_waiting = TRUE;
604
605 wxLogTrace( TRACE_CLIPBOARD,
606 wxT("wxClipboard::GetData: format found, start convert") );
607
608 gtk_selection_convert( m_clipboardWidget,
609 m_usePrimary ? (GdkAtom)GDK_SELECTION_PRIMARY
610 : g_clipboardAtom,
611 m_targetRequested,
612 (guint32) GDK_CURRENT_TIME );
613
614 while (m_waiting) gtk_main_iteration();
615
616 /* this is a true error as we checked for the presence of such data before */
617 wxCHECK_MSG( m_formatSupported, FALSE, wxT("error retrieving data from clipboard") );
618
619 /* return success */
620 delete[] array;
621 return TRUE;
622 }
623
624 wxLogTrace( TRACE_CLIPBOARD,
625 wxT("wxClipboard::GetData: format not found") );
626
627 /* return failure */
628 delete[] array;
629 return FALSE;
630}
631
632#endif
633 // wxUSE_CLIPBOARD