]> git.saurik.com Git - wxWidgets.git/blob - src/gtk1/clipbrd.cpp
cleanup - reformat
[wxWidgets.git] / src / gtk1 / clipbrd.cpp
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
36 GdkAtom g_clipboardAtom = 0;
37 GdkAtom g_targetsAtom = 0;
38
39 #if defined(__WXGTK20__) && wxUSE_UNICODE
40 extern 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!)
46 static 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
61 struct _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
77 extern "C" {
78 static void
79 targets_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
139 extern "C" {
140 static void
141 selection_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
197 extern "C" {
198 static gint
199 selection_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
240 extern "C" {
241 static void
242 selection_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 #ifdef __WXGTK20__
278 // NB: GTK+ requires special treatment of UTF8_STRING data, the text
279 // would show as UTF-8 data interpreted as latin1 (?) in other
280 // GTK+ apps if we used gtk_selection_data_set()
281 if (format == wxDataFormat(wxDF_UNICODETEXT))
282 {
283 gtk_selection_data_set_text(
284 selection_data,
285 (const gchar*)d,
286 size-1 );
287 }
288 else
289 #endif
290 {
291 gtk_selection_data_set(
292 selection_data,
293 GDK_SELECTION_TYPE_STRING,
294 8*sizeof(gchar),
295 (unsigned char*) d,
296 size-1 );
297 }
298
299 free(d);
300 }
301 }
302
303 //-----------------------------------------------------------------------------
304 // wxClipboard
305 //-----------------------------------------------------------------------------
306
307 IMPLEMENT_DYNAMIC_CLASS(wxClipboard,wxObject)
308
309 wxClipboard::wxClipboard()
310 {
311 m_open = FALSE;
312 m_waiting = FALSE;
313
314 m_ownsClipboard = FALSE;
315 m_ownsPrimarySelection = FALSE;
316
317 m_data = (wxDataObject*) NULL;
318 m_receivedData = (wxDataObject*) NULL;
319
320 /* we use m_targetsWidget to query what formats are available */
321
322 m_targetsWidget = gtk_window_new( GTK_WINDOW_POPUP );
323 gtk_widget_realize( m_targetsWidget );
324
325 gtk_signal_connect( GTK_OBJECT(m_targetsWidget),
326 "selection_received",
327 GTK_SIGNAL_FUNC( targets_selection_received ),
328 (gpointer) this );
329
330 /* we use m_clipboardWidget to get and to offer data */
331
332 m_clipboardWidget = gtk_window_new( GTK_WINDOW_POPUP );
333 gtk_widget_realize( m_clipboardWidget );
334
335 gtk_signal_connect( GTK_OBJECT(m_clipboardWidget),
336 "selection_received",
337 GTK_SIGNAL_FUNC( selection_received ),
338 (gpointer) this );
339
340 gtk_signal_connect( GTK_OBJECT(m_clipboardWidget),
341 "selection_clear_event",
342 GTK_SIGNAL_FUNC( selection_clear_clip ),
343 (gpointer) NULL );
344
345 if (!g_clipboardAtom) g_clipboardAtom = gdk_atom_intern( "CLIPBOARD", FALSE );
346 if (!g_targetsAtom) g_targetsAtom = gdk_atom_intern ("TARGETS", FALSE);
347
348 m_formatSupported = FALSE;
349 m_targetRequested = 0;
350
351 m_usePrimary = FALSE;
352 }
353
354 wxClipboard::~wxClipboard()
355 {
356 Clear();
357
358 if (m_clipboardWidget) gtk_widget_destroy( m_clipboardWidget );
359 if (m_targetsWidget) gtk_widget_destroy( m_targetsWidget );
360 }
361
362 void wxClipboard::Clear()
363 {
364 if (m_data)
365 {
366 #if wxUSE_THREADS
367 /* disable GUI threads */
368 #endif
369
370 // As we have data we also own the clipboard. Once we no longer own
371 // it, clear_selection is called which will set m_data to zero
372 if (gdk_selection_owner_get( g_clipboardAtom ) == m_clipboardWidget->window)
373 {
374 m_waiting = TRUE;
375
376 gtk_selection_owner_set( (GtkWidget*) NULL, g_clipboardAtom,
377 (guint32) GDK_CURRENT_TIME );
378
379 while (m_waiting) gtk_main_iteration();
380 }
381
382 if (gdk_selection_owner_get( GDK_SELECTION_PRIMARY ) == m_clipboardWidget->window)
383 {
384 m_waiting = TRUE;
385
386 gtk_selection_owner_set( (GtkWidget*) NULL, GDK_SELECTION_PRIMARY,
387 (guint32) GDK_CURRENT_TIME );
388
389 while (m_waiting) gtk_main_iteration();
390 }
391
392 if (m_data)
393 {
394 delete m_data;
395 m_data = (wxDataObject*) NULL;
396 }
397
398 #if wxUSE_THREADS
399 /* re-enable GUI threads */
400 #endif
401 }
402
403 m_targetRequested = 0;
404 m_formatSupported = FALSE;
405 }
406
407 bool wxClipboard::Open()
408 {
409 wxCHECK_MSG( !m_open, FALSE, wxT("clipboard already open") );
410
411 m_open = TRUE;
412
413 return TRUE;
414 }
415
416 bool wxClipboard::SetData( wxDataObject *data )
417 {
418 wxCHECK_MSG( m_open, FALSE, wxT("clipboard not open") );
419
420 wxCHECK_MSG( data, FALSE, wxT("data is invalid") );
421
422 Clear();
423
424 return AddData( data );
425 }
426
427 bool wxClipboard::AddData( wxDataObject *data )
428 {
429 wxCHECK_MSG( m_open, FALSE, wxT("clipboard not open") );
430
431 wxCHECK_MSG( data, FALSE, wxT("data is invalid") );
432
433 // we can only store one wxDataObject
434 Clear();
435
436 m_data = data;
437
438 // get formats from wxDataObjects
439 wxDataFormat *array = new wxDataFormat[ m_data->GetFormatCount() ];
440 m_data->GetAllFormats( array );
441
442 // primary selection or clipboard
443 GdkAtom clipboard = m_usePrimary ? (GdkAtom)GDK_SELECTION_PRIMARY
444 : g_clipboardAtom;
445
446
447 for (size_t i = 0; i < m_data->GetFormatCount(); i++)
448 {
449 wxLogTrace( TRACE_CLIPBOARD,
450 wxT("wxClipboard now supports atom %s"),
451 array[i].GetId().c_str() );
452
453 // printf( "added %s\n",
454 // gdk_atom_name( array[i].GetFormatId() ) );
455
456 gtk_selection_add_target( GTK_WIDGET(m_clipboardWidget),
457 clipboard,
458 array[i],
459 0 ); /* what is info ? */
460 }
461
462 delete[] array;
463
464 gtk_signal_connect( GTK_OBJECT(m_clipboardWidget),
465 "selection_get",
466 GTK_SIGNAL_FUNC(selection_handler),
467 (gpointer) NULL );
468
469 #if wxUSE_THREADS
470 /* disable GUI threads */
471 #endif
472
473 /* Tell the world we offer clipboard data */
474 bool res = (gtk_selection_owner_set( m_clipboardWidget,
475 clipboard,
476 (guint32) GDK_CURRENT_TIME ));
477
478 if (m_usePrimary)
479 m_ownsPrimarySelection = res;
480 else
481 m_ownsClipboard = res;
482
483 #if wxUSE_THREADS
484 /* re-enable GUI threads */
485 #endif
486
487 return res;
488 }
489
490 void wxClipboard::Close()
491 {
492 wxCHECK_RET( m_open, wxT("clipboard not open") );
493
494 m_open = FALSE;
495 }
496
497 bool wxClipboard::IsOpened() const
498 {
499 return m_open;
500 }
501
502 bool wxClipboard::IsSupported( const wxDataFormat& format )
503 {
504 /* reentrance problems */
505 if (m_waiting) return FALSE;
506
507 /* store requested format to be asked for by callbacks */
508 m_targetRequested = format;
509
510 wxLogTrace( TRACE_CLIPBOARD,
511 wxT("wxClipboard:IsSupported: requested format: %s"),
512 format.GetId().c_str() );
513
514 wxCHECK_MSG( m_targetRequested, FALSE, wxT("invalid clipboard format") );
515
516 m_formatSupported = FALSE;
517
518 /* perform query. this will set m_formatSupported to
519 TRUE if m_targetRequested is supported.
520 also, we have to wait for the "answer" from the
521 clipboard owner which is an asynchronous process.
522 therefore we set m_waiting = TRUE here and wait
523 until the callback "targets_selection_received"
524 sets it to FALSE */
525
526 m_waiting = TRUE;
527
528 gtk_selection_convert( m_targetsWidget,
529 m_usePrimary ? (GdkAtom)GDK_SELECTION_PRIMARY
530 : g_clipboardAtom,
531 g_targetsAtom,
532 (guint32) GDK_CURRENT_TIME );
533
534 while (m_waiting) gtk_main_iteration();
535
536 #if defined(__WXGTK20__) && wxUSE_UNICODE
537 if (!m_formatSupported && format == wxDataFormat(wxDF_UNICODETEXT))
538 {
539 // Another try with plain STRING format
540 extern GdkAtom g_altTextAtom;
541 return IsSupported(g_altTextAtom);
542 }
543 #endif
544
545 return m_formatSupported;
546 }
547
548 bool wxClipboard::GetData( wxDataObject& data )
549 {
550 wxCHECK_MSG( m_open, FALSE, wxT("clipboard not open") );
551
552 /* get formats from wxDataObjects */
553 wxDataFormat *array = new wxDataFormat[ data.GetFormatCount() ];
554 data.GetAllFormats( array );
555
556 for (size_t i = 0; i < data.GetFormatCount(); i++)
557 {
558 wxDataFormat format( array[i] );
559
560 wxLogTrace( TRACE_CLIPBOARD,
561 wxT("wxClipboard::GetData: requested format: %s"),
562 format.GetId().c_str() );
563
564 /* is data supported by clipboard ? */
565
566 /* store requested format to be asked for by callbacks */
567 m_targetRequested = format;
568
569 wxCHECK_MSG( m_targetRequested, FALSE, wxT("invalid clipboard format") );
570
571 m_formatSupported = FALSE;
572
573 /* perform query. this will set m_formatSupported to
574 TRUE if m_targetRequested is supported.
575 also, we have to wait for the "answer" from the
576 clipboard owner which is an asynchronous process.
577 therefore we set m_waiting = TRUE here and wait
578 until the callback "targets_selection_received"
579 sets it to FALSE */
580
581 m_waiting = TRUE;
582
583 gtk_selection_convert( m_targetsWidget,
584 m_usePrimary ? (GdkAtom)GDK_SELECTION_PRIMARY
585 : g_clipboardAtom,
586 g_targetsAtom,
587 (guint32) GDK_CURRENT_TIME );
588
589 while (m_waiting) gtk_main_iteration();
590
591 if (!m_formatSupported) continue;
592
593 /* store pointer to data object to be filled up by callbacks */
594 m_receivedData = &data;
595
596 /* store requested format to be asked for by callbacks */
597 m_targetRequested = format;
598
599 wxCHECK_MSG( m_targetRequested, FALSE, wxT("invalid clipboard format") );
600
601 /* start query */
602 m_formatSupported = FALSE;
603
604 /* ask for clipboard contents. this will set
605 m_formatSupported to TRUE if m_targetRequested
606 is supported.
607 also, we have to wait for the "answer" from the
608 clipboard owner which is an asynchronous process.
609 therefore we set m_waiting = TRUE here and wait
610 until the callback "targets_selection_received"
611 sets it to FALSE */
612
613 m_waiting = TRUE;
614
615 wxLogTrace( TRACE_CLIPBOARD,
616 wxT("wxClipboard::GetData: format found, start convert") );
617
618 gtk_selection_convert( m_clipboardWidget,
619 m_usePrimary ? (GdkAtom)GDK_SELECTION_PRIMARY
620 : g_clipboardAtom,
621 m_targetRequested,
622 (guint32) GDK_CURRENT_TIME );
623
624 while (m_waiting) gtk_main_iteration();
625
626 /* this is a true error as we checked for the presence of such data before */
627 wxCHECK_MSG( m_formatSupported, FALSE, wxT("error retrieving data from clipboard") );
628
629 /* return success */
630 delete[] array;
631 return TRUE;
632 }
633
634 wxLogTrace( TRACE_CLIPBOARD,
635 wxT("wxClipboard::GetData: format not found") );
636
637 /* return failure */
638 delete[] array;
639 return FALSE;
640 }
641
642 #endif
643 // wxUSE_CLIPBOARD
644