]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/dataobj.cpp
projects / wxWidgets.git / blob
? search:


db02431737fc45942e80cc4a0504bbb806cd882d
[wxWidgets.git] / src / gtk / dataobj.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/gtk/dataobj.cpp
3 // Purpose: wxDataObject class
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 #if wxUSE_DATAOBJ
14
15 #include "wx/dataobj.h"
16
17 #ifndef WX_PRECOMP
18 #include "wx/log.h"
19 #include "wx/app.h"
20 #include "wx/image.h"
21 #endif
22
23 #include "wx/mstream.h"
24 #include "wx/uri.h"
25
26 #include "wx/gtk/private.h"
27
28 //-------------------------------------------------------------------------
29 // global data
30 //-------------------------------------------------------------------------
31
32 GdkAtom g_textAtom = 0;
33 GdkAtom g_altTextAtom = 0;
34 GdkAtom g_pngAtom = 0;
35 GdkAtom g_fileAtom = 0;
36 GdkAtom g_htmlAtom = 0;
37
38 //-------------------------------------------------------------------------
39 // wxDataFormat
40 //-------------------------------------------------------------------------
41
42 wxDataFormat::wxDataFormat()
43 {
44 // do *not* call PrepareFormats() from here for 2 reasons:
45 //
46 // 1. we will have time to do it later because some other Set function
47 // must be called before we really need them
48 //
49 // 2. doing so prevents us from declaring global wxDataFormats because
50 // calling PrepareFormats (and thus gdk_atom_intern) before GDK is
51 // initialised will result in a crash
52 m_type = wxDF_INVALID;
53 m_format = (GdkAtom) 0;
54 }
55
56 wxDataFormat::wxDataFormat( wxDataFormatId type )
57 {
58 PrepareFormats();
59 SetType( type );
60 }
61
62 void wxDataFormat::InitFromString( const wxString &id )
63 {
64 PrepareFormats();
65 SetId( id );
66 }
67
68 wxDataFormat::wxDataFormat( NativeFormat format )
69 {
70 PrepareFormats();
71 SetId( format );
72 }
73
74 void wxDataFormat::SetType( wxDataFormatId type )
75 {
76 PrepareFormats();
77
78 m_type = type;
79
80 #if wxUSE_UNICODE
81 if (m_type == wxDF_UNICODETEXT)
82 m_format = g_textAtom;
83 else if (m_type == wxDF_TEXT)
84 m_format = g_altTextAtom;
85 #else // !wxUSE_UNICODE
86 // notice that we don't map wxDF_UNICODETEXT to g_textAtom here, this
87 // would lead the code elsewhere to treat data objects with this format as
88 // containing UTF-8 data which is not true
89 if (m_type == wxDF_TEXT)
90 m_format = g_textAtom;
91 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
92 else
93 if (m_type == wxDF_BITMAP)
94 m_format = g_pngAtom;
95 else
96 if (m_type == wxDF_FILENAME)
97 m_format = g_fileAtom;
98 else
99 if (m_type == wxDF_HTML)
100 m_format = g_htmlAtom;
101 else
102 {
103 wxFAIL_MSG( wxT("invalid dataformat") );
104 }
105 }
106
107 wxDataFormatId wxDataFormat::GetType() const
108 {
109 return m_type;
110 }
111
112 wxString wxDataFormat::GetId() const
113 {
114 wxGtkString atom_name(gdk_atom_name(m_format));
115 return wxString::FromAscii(atom_name);
116 }
117
118 void wxDataFormat::SetId( NativeFormat format )
119 {
120 PrepareFormats();
121 m_format = format;
122
123 if (m_format == g_textAtom)
124 #if wxUSE_UNICODE
125 m_type = wxDF_UNICODETEXT;
126 #else
127 m_type = wxDF_TEXT;
128 #endif
129 else
130 if (m_format == g_altTextAtom)
131 m_type = wxDF_TEXT;
132 else
133 if (m_format == g_pngAtom)
134 m_type = wxDF_BITMAP;
135 else
136 if (m_format == g_fileAtom)
137 m_type = wxDF_FILENAME;
138 else
139 if (m_format == g_htmlAtom)
140 m_type = wxDF_HTML;
141 else
142 m_type = wxDF_PRIVATE;
143 }
144
145 void wxDataFormat::SetId( const wxString& id )
146 {
147 PrepareFormats();
148 m_type = wxDF_PRIVATE;
149 m_format = gdk_atom_intern( id.ToAscii(), FALSE );
150 }
151
152 void wxDataFormat::PrepareFormats()
153 {
154 // VZ: GNOME included in RedHat 6.1 uses the MIME types below and not the
155 // atoms STRING and file:ALL as the old code was, but normal X apps
156 // use STRING for text selection when transferring the data via
157 // clipboard, for example, so do use STRING for now (GNOME apps will
158 // probably support STRING as well for compatibility anyhow), but use
159 // text/uri-list for file dnd because compatibility is not important
160 // here (with whom?)
161 if (!g_textAtom)
162 {
163 #if wxUSE_UNICODE
164 g_textAtom = gdk_atom_intern( "UTF8_STRING", FALSE );
165 g_altTextAtom = gdk_atom_intern( "STRING", FALSE );
166 #else
167 g_textAtom = gdk_atom_intern( "STRING" /* "text/plain" */, FALSE );
168 #endif
169 }
170 if (!g_pngAtom)
171 g_pngAtom = gdk_atom_intern( "image/png", FALSE );
172 if (!g_fileAtom)
173 g_fileAtom = gdk_atom_intern( "text/uri-list", FALSE );
174 if (!g_htmlAtom)
175 g_htmlAtom = gdk_atom_intern( "text/html", FALSE );
176 }
177
178 //-------------------------------------------------------------------------
179 // wxDataObject
180 //-------------------------------------------------------------------------
181
182 wxDataObject::wxDataObject()
183 {
184 }
185
186 wxDataObject::~wxDataObject()
187 {
188 // dtor is empty but needed for Darwin and AIX -- otherwise it doesn't link
189 }
190
191 bool wxDataObject::IsSupportedFormat(const wxDataFormat& format, Direction dir) const
192 {
193 size_t nFormatCount = GetFormatCount(dir);
194 if ( nFormatCount == 1 )
195 {
196 return format == GetPreferredFormat();
197 }
198 else
199 {
200 wxDataFormat *formats = new wxDataFormat[nFormatCount];
201 GetAllFormats(formats,dir);
202
203 size_t n;
204 for ( n = 0; n < nFormatCount; n++ )
205 {
206 if ( formats[n] == format )
207 break;
208 }
209
210 delete [] formats;
211
212 // found?
213 return n < nFormatCount;
214 }
215 }
216
217 // ----------------------------------------------------------------------------
218 // wxTextDataObject
219 // ----------------------------------------------------------------------------
220
221 #if wxUSE_UNICODE
222
223 void
224 wxTextDataObject::GetAllFormats(wxDataFormat *formats,
225 wxDataObjectBase::Direction WXUNUSED(dir)) const
226 {
227 *formats++ = GetPreferredFormat();
228 *formats = g_altTextAtom;
229 }
230
231 #endif // wxUSE_UNICODE
232
233 // ----------------------------------------------------------------------------
234 // wxFileDataObject
235 // ----------------------------------------------------------------------------
236
237 bool wxFileDataObject::GetDataHere(void *buf) const
238 {
239 wxString filenames;
240
241 for (size_t i = 0; i < m_filenames.GetCount(); i++)
242 {
243 filenames += wxT("file:");
244 filenames += m_filenames[i];
245 filenames += wxT("\r\n");
246 }
247
248 memcpy( buf, filenames.mbc_str(), filenames.length() + 1 );
249
250 return true;
251 }
252
253 size_t wxFileDataObject::GetDataSize() const
254 {
255 size_t res = 0;
256
257 for (size_t i = 0; i < m_filenames.GetCount(); i++)
258 {
259 // This is junk in UTF-8
260 res += m_filenames[i].length();
261 res += 5 + 2; // "file:" (5) + "\r\n" (2)
262 }
263
264 return res + 1;
265 }
266
267 bool wxFileDataObject::SetData(size_t WXUNUSED(size), const void *buf)
268 {
269 // we get data in the text/uri-list format, i.e. as a sequence of URIs
270 // (filenames prefixed by "file:") delimited by "\r\n". size includes
271 // the trailing zero (in theory, not for Nautilus in early GNOME
272 // versions).
273
274 m_filenames.Empty();
275
276 const gchar *nexttemp = (const gchar*) buf;
277 for ( ; ; )
278 {
279 int len = 0;
280 const gchar *temp = nexttemp;
281 for (;;)
282 {
283 if (temp[len] == 0)
284 {
285 if (len > 0)
286 {
287 // if an app omits '\r''\n'
288 nexttemp = temp+len;
289 break;
290 }
291
292 return true;
293 }
294 if (temp[len] == '\r')
295 {
296 if (temp[len+1] == '\n')
297 nexttemp = temp+len+2;
298 else
299 nexttemp = temp+len+1;
300 break;
301 }
302 len++;
303 }
304
305 if (len == 0)
306 break;
307
308 // required to give it a trailing zero
309 gchar *uri = g_strndup( temp, len );
310
311 gchar *fn = g_filename_from_uri( uri, NULL, NULL );
312
313 g_free( uri );
314
315 if (fn)
316 {
317 AddFile( wxConvFileName->cMB2WX( fn ) );
318 g_free( fn );
319 }
320 }
321
322 return true;
323 }
324
325 void wxFileDataObject::AddFile( const wxString &filename )
326 {
327 m_filenames.Add( filename );
328 }
329
330 // ----------------------------------------------------------------------------
331 // wxBitmapDataObject
332 // ----------------------------------------------------------------------------
333
334 wxBitmapDataObject::wxBitmapDataObject()
335 {
336 Init();
337 }
338
339 wxBitmapDataObject::wxBitmapDataObject( const wxBitmap& bitmap )
340 : wxBitmapDataObjectBase(bitmap)
341 {
342 Init();
343
344 DoConvertToPng();
345 }
346
347 wxBitmapDataObject::~wxBitmapDataObject()
348 {
349 Clear();
350 }
351
352 void wxBitmapDataObject::SetBitmap( const wxBitmap &bitmap )
353 {
354 ClearAll();
355
356 wxBitmapDataObjectBase::SetBitmap(bitmap);
357
358 DoConvertToPng();
359 }
360
361 bool wxBitmapDataObject::GetDataHere(void *buf) const
362 {
363 if ( !m_pngSize )
364 {
365 wxFAIL_MSG( wxT("attempt to copy empty bitmap failed") );
366
367 return false;
368 }
369
370 memcpy(buf, m_pngData, m_pngSize);
371
372 return true;
373 }
374
375 bool wxBitmapDataObject::SetData(size_t size, const void *buf)
376 {
377 Clear();
378
379 wxCHECK_MSG( wxImage::FindHandler(wxBITMAP_TYPE_PNG) != NULL,
380 false, wxT("You must call wxImage::AddHandler(new wxPNGHandler); to be able to use clipboard with bitmaps!") );
381
382 m_pngSize = size;
383 m_pngData = malloc(m_pngSize);
384
385 memcpy(m_pngData, buf, m_pngSize);
386
387 wxMemoryInputStream mstream((char*) m_pngData, m_pngSize);
388 wxImage image;
389 if ( !image.LoadFile( mstream, wxBITMAP_TYPE_PNG ) )
390 {
391 return false;
392 }
393
394 m_bitmap = wxBitmap(image);
395
396 return m_bitmap.IsOk();
397 }
398
399 void wxBitmapDataObject::DoConvertToPng()
400 {
401 if ( !m_bitmap.IsOk() )
402 return;
403
404 wxCHECK_RET( wxImage::FindHandler(wxBITMAP_TYPE_PNG) != NULL,
405 wxT("You must call wxImage::AddHandler(new wxPNGHandler); to be able to use clipboard with bitmaps!") );
406
407 wxImage image = m_bitmap.ConvertToImage();
408
409 wxCountingOutputStream count;
410 image.SaveFile(count, wxBITMAP_TYPE_PNG);
411
412 m_pngSize = count.GetSize() + 100; // sometimes the size seems to vary ???
413 m_pngData = malloc(m_pngSize);
414
415 wxMemoryOutputStream mstream((char*) m_pngData, m_pngSize);
416 image.SaveFile(mstream, wxBITMAP_TYPE_PNG);
417 }
418
419 // ----------------------------------------------------------------------------
420 // wxURLDataObject
421 // ----------------------------------------------------------------------------
422
423 class wxTextURIListDataObject : public wxDataObjectSimple
424 {
425 public:
426 wxTextURIListDataObject(const wxString& url)
427 : wxDataObjectSimple(wxDataFormat(g_fileAtom)),
428 m_url(url)
429 {
430 }
431
432 const wxString& GetURL() const { return m_url; }
433 void SetURL(const wxString& url) { m_url = url; }
434
435
436 virtual size_t GetDataSize() const
437 {
438 // It is not totally clear whether we should include "\r\n" at the end
439 // of the string if there is only one URL or not, but not doing it
440 // doesn't seem to create any problems, so keep things simple.
441 return strlen(m_url.utf8_str()) + 1;
442 }
443
444 virtual bool GetDataHere(void *buf) const
445 {
446 char* const dst = static_cast<char*>(buf);
447
448 strcpy(dst, m_url.utf8_str());
449
450 return true;
451 }
452
453 virtual bool SetData(size_t len, const void *buf)
454 {
455 const char* const src = static_cast<const char*>(buf);
456
457 // The string might be "\r\n"-terminated but this is not necessarily
458 // the case (e.g. when dragging an URL from Firefox, it isn't).
459 if ( len > 1 && src[len - 1] == '\n' )
460 {
461 if ( len > 2 && src[len - 2] == '\r' )
462 len--;
463
464 len--;
465 }
466
467 m_url = wxString::FromUTF8(src, len);
468
469 return true;
470 }
471
472 // Must provide overloads to avoid hiding them (and warnings about it)
473 virtual size_t GetDataSize(const wxDataFormat&) const
474 {
475 return GetDataSize();
476 }
477 virtual bool GetDataHere(const wxDataFormat&, void *buf) const
478 {
479 return GetDataHere(buf);
480 }
481 virtual bool SetData(const wxDataFormat&, size_t len, const void *buf)
482 {
483 return SetData(len, buf);
484 }
485
486 private:
487 wxString m_url;
488 };
489
490 wxURLDataObject::wxURLDataObject(const wxString& url) :
491 m_dobjURIList(new wxTextURIListDataObject(url)),
492 m_dobjText(new wxTextDataObject(url))
493 {
494 // Use both URL-specific format and a plain text one to ensure that URLs
495 // can be pasted into any application.
496 Add(m_dobjURIList, true /* preferred */);
497 Add(m_dobjText);
498 }
499
500 void wxURLDataObject::SetURL(const wxString& url)
501 {
502 m_dobjURIList->SetURL(url);
503 m_dobjText->SetText(url);
504 }
505
506 wxString wxURLDataObject::GetURL() const
507 {
508 if ( GetReceivedFormat() == g_fileAtom )
509 {
510 // If we received the URL as an URI, use it.
511 return m_dobjURIList->GetURL();
512 }
513 else // Otherwise we either got it as text or didn't get anything yet.
514 {
515 // In either case using the text format should be fine.
516 return m_dobjText->GetText();
517 }
518 }
519
520 #endif // wxUSE_DATAOBJ
wxWidgets (Impactor)