]> git.saurik.com Git - wxWidgets.git/blame - src/osx/carbon/dataobj.cpp
Fix uninitialized variable warning in wxMSW wxFileSystemWatcher code.
[wxWidgets.git] / src / osx / carbon / dataobj.cpp
CommitLineData
489468fe 1///////////////////////////////////////////////////////////////////////////////
524c47aa 2// Name: src/osx/carbon/dataobj.cpp
489468fe
SC
3// Purpose: implementation of wxDataObject class
4// Author: Stefan Csomor
5// Modified by:
6// Created: 10/21/99
7// RCS-ID: $Id$
8// Copyright: (c) 1999 Stefan Csomor
9// Licence: wxWindows licence
10///////////////////////////////////////////////////////////////////////////////
11
12// For compilers that support precompilation, includes "wx.h".
13#include "wx/wxprec.h"
14
15#if wxUSE_DATAOBJ
16
17#include "wx/dataobj.h"
18
19#ifndef WX_PRECOMP
20 #include "wx/intl.h"
21 #include "wx/log.h"
22 #include "wx/dcmemory.h"
23 #include "wx/image.h"
24#endif
25
26#include "wx/mstream.h"
27#include "wx/metafile.h"
28#include "wx/tokenzr.h"
fb35086d 29#include "wx/filename.h"
489468fe 30
524c47aa 31#include "wx/osx/private.h"
489468fe 32
afd5d91c 33#if wxOSX_USE_COCOA_OR_CARBON
489468fe
SC
34 #include <QuickTime/QuickTime.h>
35#endif
36
489468fe
SC
37// ----------------------------------------------------------------------------
38// wxDataFormat
39// ----------------------------------------------------------------------------
40
41wxDataFormat::wxDataFormat()
42{
43 m_type = wxDF_INVALID;
44 m_format = 0;
45}
46
47wxDataFormat::wxDataFormat( wxDataFormatId vType )
48{
49 m_format = 0;
50 m_type = wxDF_INVALID;
51 SetType( vType );
52}
53
54wxDataFormat::wxDataFormat( const wxChar *zId )
55{
56 m_format = 0;
57 m_type = wxDF_INVALID;
58 SetId( zId );
59}
60
61wxDataFormat::wxDataFormat( const wxString& rId )
62{
63 m_format = 0;
64 m_type = wxDF_INVALID;
65 SetId( rId );
66}
67
68wxDataFormat::wxDataFormat(const wxDataFormat& rFormat)
69{
70 if ( rFormat.m_format )
71 m_format = (NativeFormat) CFStringCreateCopy(NULL, (CFStringRef)rFormat.m_format);
72 else
73 m_format = 0;
74 m_type = rFormat.m_type;
75 m_id = rFormat.m_id;
76}
77
78wxDataFormat::wxDataFormat( NativeFormat vFormat )
79{
80 m_format = 0;
81 m_type = wxDF_INVALID;
82 SetId( vFormat );
83}
84
85wxDataFormat::~wxDataFormat()
86{
87 if ( m_format != 0 )
88 {
89 CFRelease( (CFStringRef) m_format );
90 m_format = 0;
91 }
92}
93
94// in order to be correct for 10.3 we restrict to the available types there
95// http://developer.apple.com/qa/qa2005/qa1406.html
96// TODO : Use UTCoreTypes.h constants once we support 10.4+ only
97
98wxDataFormat& wxDataFormat::operator=(const wxDataFormat& rFormat)
99{
100 if ( m_format != 0 )
101 {
102 CFRelease( (CFStringRef) m_format );
103 m_format = 0;
104 }
105 if ( rFormat.m_format )
106 m_format = (NativeFormat) CFStringCreateCopy(NULL, (CFStringRef)rFormat.m_format);
107 m_type = rFormat.m_type;
108 m_id = rFormat.m_id;
109 return *this;
110}
111
112void wxDataFormat::SetType( wxDataFormatId dataType )
113{
114 m_type = dataType;
115 if ( m_format != 0 )
116 {
117 CFRelease( (CFStringRef) m_format );
118 m_format = 0;
119 }
120
121 switch (m_type)
122 {
123 case wxDF_TEXT:
2979ddbe 124 m_format = (long) CFStringCreateCopy( NULL, kUTTypePlainText );
489468fe
SC
125 break;
126
127 case wxDF_UNICODETEXT:
2979ddbe 128 m_format = (long) CFStringCreateCopy( NULL, kUTTypeUTF16PlainText );
489468fe
SC
129 break;
130
b8acf11e 131 case wxDF_HTML:
2979ddbe 132 m_format = (long) CFStringCreateCopy( NULL, kUTTypeHTML );
b8acf11e
RD
133 break;
134
489468fe 135 case wxDF_BITMAP:
2979ddbe 136 m_format = (long) CFStringCreateCopy( NULL, kUTTypeTIFF );
489468fe
SC
137 break;
138 case wxDF_METAFILE:
2979ddbe 139 m_format = (long) CFStringCreateCopy( NULL, kUTTypePDF );
489468fe
SC
140 break;
141
142 case wxDF_FILENAME:
2979ddbe 143 m_format = (long) CFStringCreateCopy( NULL, kUTTypeFileURL );
489468fe
SC
144 break;
145
146 default:
147 wxFAIL_MSG( wxT("invalid data format") );
148 break;
149 }
150}
151
152wxString wxDataFormat::GetId() const
153{
154 return wxCFStringRef(wxCFRetain((CFStringRef)m_format)).AsString();
155}
156
157void wxDataFormat::SetId( NativeFormat format )
158{
159 if ( m_format != 0 )
160 {
161 CFRelease( (CFStringRef) m_format );
162 m_format = 0;
163 }
164 m_format = (NativeFormat) CFStringCreateCopy(NULL, (CFStringRef)format);
2979ddbe 165 if ( UTTypeConformsTo( (CFStringRef)format, kUTTypeHTML ) )
b8acf11e
RD
166 {
167 m_type = wxDF_HTML;
168 }
2979ddbe 169 if ( UTTypeConformsTo( (CFStringRef)format, kUTTypeUTF16PlainText ) )
489468fe
SC
170 {
171 m_type = wxDF_UNICODETEXT;
90dad08e 172 }
2979ddbe 173 else if ( UTTypeConformsTo( (CFStringRef)format,kUTTypeUTF16ExternalPlainText ) )
90dad08e
SC
174 {
175 m_type = wxDF_UNICODETEXT;
03647350 176 }
2979ddbe
SC
177 else if ( UTTypeConformsTo( (CFStringRef)format,kUTTypeUTF8PlainText ) )
178 {
179 m_type = wxDF_UNICODETEXT;
180 }
181 else if ( UTTypeConformsTo( (CFStringRef)format, kUTTypePlainText ) )
489468fe
SC
182 {
183 m_type = wxDF_TEXT;
184 }
2979ddbe 185 else if ( UTTypeConformsTo( (CFStringRef)format, kUTTypeImage ) )
489468fe
SC
186 {
187 m_type = wxDF_BITMAP;
188 }
2979ddbe 189 else if ( UTTypeConformsTo( (CFStringRef)format, kUTTypePDF ) )
489468fe
SC
190 {
191 m_type = wxDF_METAFILE;
192 }
2979ddbe 193 else if ( UTTypeConformsTo( (CFStringRef)format, kUTTypeFileURL ) ||
fb35086d 194 UTTypeConformsTo( (CFStringRef)format, kPasteboardTypeFileURLPromise))
489468fe
SC
195 {
196 m_type = wxDF_FILENAME;
197 }
03647350 198 else
489468fe
SC
199 {
200 m_type = wxDF_PRIVATE;
201 m_id = wxCFStringRef( (CFStringRef) CFRetain((CFStringRef) format )).AsString();
202 }
203}
204
205void wxDataFormat::SetId( const wxString& zId )
206{
207 m_type = wxDF_PRIVATE;
208 m_id = zId;
209 if ( m_format != 0 )
210 {
211 CFRelease( (CFStringRef) m_format );
212 m_format = 0;
213 }
214 // since it is private, no need to conform to anything ...
215 m_format = (long) wxCFRetain( (CFStringRef) wxCFStringRef(m_id) );
216}
217
218bool wxDataFormat::operator==(const wxDataFormat& format) const
219{
220 if (IsStandard() || format.IsStandard())
221 return (format.m_type == m_type);
222 else
223 return ( UTTypeConformsTo( (CFStringRef) m_format , (CFStringRef) format.m_format ) );
224}
225
226//-------------------------------------------------------------------------
227// wxDataObject
228//-------------------------------------------------------------------------
229
230wxDataObject::wxDataObject()
231{
232}
233
234bool wxDataObject::IsSupportedFormat( const wxDataFormat& rFormat, Direction vDir ) const
235{
236 size_t nFormatCount = GetFormatCount( vDir );
237 bool found = false;
238
239 if (nFormatCount == 1)
240 {
241 found = (rFormat == GetPreferredFormat());
242 }
243 else
244 {
245 wxDataFormat *pFormats = new wxDataFormat[nFormatCount];
246 GetAllFormats( pFormats, vDir );
247
248 for (size_t n = 0; n < nFormatCount; n++)
249 {
250 if (pFormats[n] == rFormat)
251 {
252 found = true;
253 break;
254 }
255 }
256
257 delete [] pFormats;
258 }
259
260 return found;
261}
262
263void wxDataObject::AddToPasteboard( void * pb, int itemID )
264{
265 PasteboardRef pasteboard = (PasteboardRef) pb;
266 // get formats from wxDataObjects
267 wxDataFormat *array = new wxDataFormat[ GetFormatCount() ];
268 GetAllFormats( array );
269
270 for (size_t i = 0; i < GetFormatCount(); i++)
271 {
272 wxDataFormat thisFormat = array[ i ];
03647350
VZ
273
274 // add four bytes at the end for data objs like text that
489468fe
SC
275 // have a datasize = strlen but still need a buffer for the
276 // string including trailing zero
03647350 277
489468fe 278 size_t datasize = GetDataSize( thisFormat );
2979ddbe
SC
279 if ( datasize == wxCONV_FAILED && thisFormat.GetType() == wxDF_TEXT)
280 {
281 // conversion to local text failed, so we must use unicode
282 // if wxDF_UNICODETEXT is already on the 'todo' list, skip this iteration
283 // otherwise force it
284 size_t j = 0;
285 for (j = 0; j < GetFormatCount(); j++)
286 {
287 if ( array[j].GetType() == wxDF_UNICODETEXT )
288 break;
289 }
290 if ( j < GetFormatCount() )
291 continue;
292
293 thisFormat.SetType(wxDF_UNICODETEXT);
294 datasize = GetDataSize( thisFormat );
295 }
296
489468fe
SC
297 size_t sz = datasize + 4;
298 void* buf = malloc( sz );
299 if ( buf != NULL )
300 {
301 // empty the buffer because in some case GetDataHere does not fill buf
302 memset( buf, 0, sz );
2979ddbe 303 if ( GetDataHere( thisFormat, buf ) )
489468fe
SC
304 {
305 int counter = 1 ;
306 if ( thisFormat.GetType() == wxDF_FILENAME )
307 {
308 // the data is D-normalized UTF8 strings of filenames delimited with \n
309 char *fname = strtok((char*) buf,"\n");
310 while (fname != NULL)
311 {
312 // translate the filepath into a fileurl and put that into the pasteobard
313 CFStringRef path = CFStringCreateWithBytes(NULL,(UInt8*)fname,strlen(fname),kCFStringEncodingUTF8,false);
314 CFURLRef url = CFURLCreateWithFileSystemPath(NULL, path , kCFURLPOSIXPathStyle, false);
315 CFRelease(path);
316 CFDataRef data = CFURLCreateData(NULL,url,kCFStringEncodingUTF8,true);
317 CFRelease(url);
318 PasteboardPutItemFlavor( pasteboard, (PasteboardItemID) counter,
319 (CFStringRef) thisFormat.GetFormatId() , data, kPasteboardFlavorNoFlags);
320 CFRelease( data );
321 counter++;
322 fname = strtok (NULL,"\n");
323 }
03647350 324
489468fe
SC
325 }
326 else
327 {
328 CFDataRef data = CFDataCreate( kCFAllocatorDefault, (UInt8*)buf, datasize );
329 if ( thisFormat.GetType() == wxDF_TEXT )
330 PasteboardPutItemFlavor( pasteboard, (PasteboardItemID) itemID,
331 CFSTR("com.apple.traditional-mac-plain-text") , data, kPasteboardFlavorNoFlags);
332 else
333 PasteboardPutItemFlavor( pasteboard, (PasteboardItemID) itemID,
334 (CFStringRef) thisFormat.GetFormatId() , data, kPasteboardFlavorNoFlags);
335 CFRelease( data );
336 }
337 }
338 free( buf );
339 }
340 }
341
342 delete [] array;
343}
344
345bool wxDataObject::IsFormatInPasteboard( void * pb, const wxDataFormat &dataFormat )
346{
347 PasteboardRef pasteboard = (PasteboardRef) pb;
348 bool hasData = false;
349 OSStatus err = noErr;
350 ItemCount itemCount;
351
352 // we synchronize here once again, so we don't mind which flags get returned
353 PasteboardSynchronize( pasteboard );
354
355 err = PasteboardGetItemCount( pasteboard, &itemCount );
356 if ( err == noErr )
357 {
358 for( UInt32 itemIndex = 1; itemIndex <= itemCount && hasData == false ; itemIndex++ )
359 {
360 PasteboardItemID itemID;
361 CFArrayRef flavorTypeArray;
362 CFIndex flavorCount;
03647350 363
489468fe
SC
364 err = PasteboardGetItemIdentifier( pasteboard, itemIndex, &itemID );
365 if ( err != noErr )
366 continue;
03647350 367
489468fe
SC
368 err = PasteboardCopyItemFlavors( pasteboard, itemID, &flavorTypeArray );
369 if ( err != noErr )
370 continue;
03647350 371
489468fe 372 flavorCount = CFArrayGetCount( flavorTypeArray );
03647350 373
489468fe
SC
374 for( CFIndex flavorIndex = 0; flavorIndex < flavorCount && hasData == false ; flavorIndex++ )
375 {
376 CFStringRef flavorType;
03647350 377
489468fe
SC
378 flavorType = (CFStringRef)CFArrayGetValueAtIndex( flavorTypeArray,
379 flavorIndex );
03647350 380
489468fe
SC
381 wxDataFormat flavorFormat( (wxDataFormat::NativeFormat) flavorType );
382 if ( dataFormat == flavorFormat )
383 hasData = true;
384 else if ( dataFormat.GetType() == wxDF_UNICODETEXT && flavorFormat.GetType() == wxDF_TEXT )
385 hasData = true;
386 }
387 CFRelease (flavorTypeArray);
388 }
389 }
390
391 return hasData;
392}
393
394bool wxDataObject::GetFromPasteboard( void * pb )
395{
396 PasteboardRef pasteboard = (PasteboardRef) pb;
397 size_t formatcount = GetFormatCount() + 1;
398 wxDataFormat *array = new wxDataFormat[ formatcount ];
399 array[0] = GetPreferredFormat();
400 GetAllFormats( &array[1] );
401 ItemCount itemCount = 0;
402 wxString filenamesPassed;
403 bool transferred = false;
3c703700 404 bool pastelocationset = false;
489468fe
SC
405
406 // we synchronize here once again, so we don't mind which flags get returned
407 PasteboardSynchronize( pasteboard );
408
409 OSStatus err = PasteboardGetItemCount( pasteboard, &itemCount );
410 if ( err == noErr )
411 {
412 for (size_t i = 0; !transferred && i < formatcount; i++)
413 {
414 // go through the data in our order of preference
415 wxDataFormat dataFormat = array[ i ];
416
417 for( UInt32 itemIndex = 1; itemIndex <= itemCount && transferred == false ; itemIndex++ )
418 {
419 PasteboardItemID itemID = 0;
420 CFArrayRef flavorTypeArray = NULL;
421 CFIndex flavorCount = 0;
422
423 err = PasteboardGetItemIdentifier( pasteboard, itemIndex, &itemID );
424 if ( err != noErr )
425 continue;
426
427 err = PasteboardCopyItemFlavors( pasteboard, itemID, &flavorTypeArray );
428 if ( err != noErr )
429 continue;
03647350 430
489468fe
SC
431 flavorCount = CFArrayGetCount( flavorTypeArray );
432
433 for( CFIndex flavorIndex = 0; !transferred && flavorIndex < flavorCount ; flavorIndex++ )
434 {
435 CFStringRef flavorType;
436 CFDataRef flavorData;
437 CFIndex flavorDataSize;
03647350 438
489468fe
SC
439 flavorType = (CFStringRef)CFArrayGetValueAtIndex( flavorTypeArray,
440 flavorIndex );
441
442 wxDataFormat flavorFormat( (wxDataFormat::NativeFormat) flavorType );
03647350 443
489468fe
SC
444 if ( dataFormat == flavorFormat )
445 {
fb35086d
SC
446 if ( UTTypeConformsTo( (CFStringRef)flavorType, kPasteboardTypeFileURLPromise) )
447 {
3c703700
SC
448 if ( !pastelocationset )
449 {
450 wxString tempdir = wxFileName::GetTempDir() + wxFILE_SEP_PATH + "wxtemp.XXXXXX";
451 char* result = mkdtemp((char*)tempdir.fn_str().data());
452
453 if (!result)
454 continue;
455
456 wxCFRef<CFURLRef> dest(CFURLCreateFromFileSystemRepresentation(NULL,(const UInt8*)result,strlen(result),true));
457 PasteboardSetPasteLocation(pasteboard, dest);
458 pastelocationset = true;
459 }
fb35086d 460 }
2979ddbe
SC
461 else if ( flavorFormat.GetType() != wxDF_PRIVATE )
462 {
463 // indicate the expected format for the type, benefiting from native conversions eg utf8 -> utf16
464 flavorType = (CFStringRef) wxDataFormat( flavorFormat.GetType()).GetFormatId();
465 }
466
489468fe
SC
467 err = PasteboardCopyItemFlavorData( pasteboard, itemID, flavorType , &flavorData );
468 if ( err == noErr )
469 {
470 flavorDataSize = CFDataGetLength( flavorData );
471 if (dataFormat.GetType() == wxDF_FILENAME )
472 {
fb35086d 473 // revert the translation and decomposition to arrive at a proper utf8 string again
489468fe
SC
474 CFURLRef url = CFURLCreateWithBytes( kCFAllocatorDefault, CFDataGetBytePtr( flavorData ), flavorDataSize, kCFStringEncodingUTF8, NULL );
475 CFStringRef cfString = CFURLCopyFileSystemPath( url, kCFURLPOSIXPathStyle );
476 CFRelease( url );
477 CFMutableStringRef cfMutableString = CFStringCreateMutableCopy(NULL, 0, cfString);
478 CFRelease( cfString );
479 CFStringNormalize(cfMutableString,kCFStringNormalizationFormC);
480 wxString path = wxCFStringRef(cfMutableString).AsString();
481 if (!path.empty())
482 filenamesPassed += path + wxT("\n");
483 }
484 else
485 {
486 // because some data implementation expect trailing a trailing NUL, we add some headroom
487 void *buf = malloc( flavorDataSize + 4 );
488 if ( buf )
489 {
490 memset( buf, 0, flavorDataSize + 4 );
491 memcpy( buf, CFDataGetBytePtr( flavorData ), flavorDataSize );
03647350 492
489468fe
SC
493 if (dataFormat.GetType() == wxDF_TEXT)
494 wxMacConvertNewlines10To13( (char*) buf );
495 SetData( flavorFormat, flavorDataSize, buf );
496 transferred = true;
497 free( buf );
498 }
499 }
500 CFRelease (flavorData);
501 }
502 }
503 else if ( dataFormat.GetType() == wxDF_UNICODETEXT && flavorFormat.GetType() == wxDF_TEXT )
504 {
505 err = PasteboardCopyItemFlavorData( pasteboard, itemID, flavorType, &flavorData );
506 if ( err == noErr )
507 {
508 flavorDataSize = CFDataGetLength( flavorData );
509 void *asciibuf = malloc( flavorDataSize + 1 );
510 if ( asciibuf )
511 {
512 memset( asciibuf, 0, flavorDataSize + 1 );
513 memcpy( asciibuf, CFDataGetBytePtr( flavorData ), flavorDataSize );
514 CFRelease (flavorData);
515
516 SetData( wxDF_TEXT, flavorDataSize, asciibuf );
517 transferred = true;
518 free( asciibuf );
519 }
520 else
521 CFRelease (flavorData);
522 }
523 }
524 }
525 CFRelease( flavorTypeArray );
526 }
6636ef8d 527 if ( !filenamesPassed.empty() )
489468fe
SC
528 {
529 wxCharBuffer buf = filenamesPassed.fn_str();
530 SetData( wxDF_FILENAME, strlen( buf ), (const char*)buf );
531 transferred = true;
532 }
533 }
534 }
535 return transferred;
536}
537
538bool wxDataObject::HasDataInPasteboard( void * pb )
539{
540 PasteboardRef pasteboard = (PasteboardRef) pb;
541 size_t formatcount = GetFormatCount() + 1;
542 wxDataFormat *array = new wxDataFormat[ formatcount ];
543 array[0] = GetPreferredFormat();
544 GetAllFormats( &array[1] );
545 ItemCount itemCount = 0;
546 bool hasData = false;
547
548 // we synchronize here once again, so we don't mind which flags get returned
549 PasteboardSynchronize( pasteboard );
550
551 OSStatus err = PasteboardGetItemCount( pasteboard, &itemCount );
552 if ( err == noErr )
553 {
554 for (size_t i = 0; !hasData && i < formatcount; i++)
555 {
556 // go through the data in our order of preference
557 wxDataFormat dataFormat = array[ i ];
558
559 for( UInt32 itemIndex = 1; itemIndex <= itemCount && hasData == false ; itemIndex++ )
560 {
561 PasteboardItemID itemID = 0;
562 CFArrayRef flavorTypeArray = NULL;
563 CFIndex flavorCount = 0;
564
565 err = PasteboardGetItemIdentifier( pasteboard, itemIndex, &itemID );
566 if ( err != noErr )
567 continue;
568
569 err = PasteboardCopyItemFlavors( pasteboard, itemID, &flavorTypeArray );
570 if ( err != noErr )
571 continue;
03647350 572
489468fe
SC
573 flavorCount = CFArrayGetCount( flavorTypeArray );
574
575 for( CFIndex flavorIndex = 0; !hasData && flavorIndex < flavorCount ; flavorIndex++ )
576 {
577 CFStringRef flavorType;
03647350 578
489468fe
SC
579 flavorType = (CFStringRef)CFArrayGetValueAtIndex( flavorTypeArray,
580 flavorIndex );
581
582 wxDataFormat flavorFormat( (wxDataFormat::NativeFormat) flavorType );
03647350
VZ
583
584 if ( dataFormat == flavorFormat ||
c9e98a88 585 (dataFormat.GetType() == wxDF_UNICODETEXT && flavorFormat.GetType() == wxDF_TEXT) )
489468fe
SC
586 {
587 hasData = true;
588 }
589 }
590 CFRelease( flavorTypeArray );
591 }
592 }
593 }
594 return hasData;
595}
596
f31c06b3
SC
597#if wxOSX_USE_COCOA
598
599void wxDataObject::AddSupportedTypes( void* cfarray)
600{
601 wxDataFormat *array = new wxDataFormat[ GetFormatCount() ];
602 GetAllFormats( array );
603
604 for (size_t i = 0; i < GetFormatCount(); i++)
605 {
606 wxDataFormat dataFormat = array[ i ];
607
608 if ( dataFormat.GetType() == wxDF_UNICODETEXT || dataFormat.GetType() == wxDF_TEXT )
609 {
610 CFArrayAppendValue((CFMutableArrayRef)cfarray, kUTTypeUTF16PlainText);
611 CFArrayAppendValue((CFMutableArrayRef)cfarray, kUTTypePlainText);
612 }
613 else if ( dataFormat.GetType() == wxDF_FILENAME )
614 {
615 CFArrayAppendValue((CFMutableArrayRef)cfarray, kUTTypeFileURL);
616 CFArrayAppendValue((CFMutableArrayRef)cfarray, kPasteboardTypeFileURLPromise);
617 }
618 else if ( dataFormat.GetType() == wxDF_HTML )
619 {
620 CFArrayAppendValue((CFMutableArrayRef)cfarray, kUTTypeHTML);
621 }
622 else if ( dataFormat.GetType() == wxDF_BITMAP )
623 {
624 CFArrayAppendValue((CFMutableArrayRef)cfarray, kUTTypeTIFF);
625 CFArrayAppendValue((CFMutableArrayRef)cfarray, kUTTypePICT);
626 }
627 else if ( dataFormat.GetType() == wxDF_METAFILE )
628 {
629 CFArrayAppendValue((CFMutableArrayRef)cfarray, kUTTypePDF);
630 }
631 }
632 delete[] array;
633}
634
635#endif
636
489468fe
SC
637// ----------------------------------------------------------------------------
638// wxTextDataObject
639// ----------------------------------------------------------------------------
640
641#if wxUSE_UNICODE
642void wxTextDataObject::GetAllFormats(wxDataFormat *formats,
643 wxDataObjectBase::Direction WXUNUSED(dir)) const
644{
645 *formats++ = wxDataFormat( wxDF_TEXT );
646 *formats = wxDataFormat( wxDF_UNICODETEXT );
647}
648#endif
649
650// ----------------------------------------------------------------------------
651// wxFileDataObject
652// ----------------------------------------------------------------------------
653
654void wxFileDataObject::GetFileNames( wxCharBuffer &buf ) const
655{
656 wxString filenames;
657
658 for (size_t i = 0; i < m_filenames.GetCount(); i++)
659 {
660 filenames += m_filenames[i];
661 filenames += wxT('\n');
662 }
663
664 buf = filenames.fn_str();
665}
666
667bool wxFileDataObject::GetDataHere( void *pBuf ) const
668{
669 if (pBuf == NULL)
670 return false;
671
672 wxCharBuffer buf;
673 size_t buffLength;
674
675 GetFileNames( buf );
676 buffLength = strlen( buf );
677 memcpy( pBuf, (const char*)buf, buffLength + 1 );
678
679 return true;
680}
681
682size_t wxFileDataObject::GetDataSize() const
683{
684 wxCharBuffer buf;
685 size_t buffLength;
686
687 GetFileNames( buf );
688 buffLength = strlen( buf );
689 // terminating 0
690 return buffLength + 1;
691}
692
693bool wxFileDataObject::SetData( size_t WXUNUSED(nSize), const void *pBuf )
694{
695 wxString filenames;
696
697#if wxUSE_UNICODE
698 filenames = wxString( (const char*)pBuf, *wxConvFileName );
699#else
700 filenames = wxString (wxConvLocal.cWC2WX(wxConvFileName->cMB2WC( (const char*)pBuf)));
701#endif
702
703 m_filenames = wxStringTokenize( filenames, wxT("\n"), wxTOKEN_STRTOK );
704
705 return true;
706}
707
708void wxFileDataObject::AddFile( const wxString& rFilename )
709{
710 m_filenames.Add( rFilename );
711}
712
713// ----------------------------------------------------------------------------
714// wxBitmapDataObject
715// ----------------------------------------------------------------------------
716
717wxBitmapDataObject::wxBitmapDataObject()
718{
719 Init();
720}
721
722wxBitmapDataObject::wxBitmapDataObject( const wxBitmap& rBitmap )
723: wxBitmapDataObjectBase( rBitmap )
724{
725 Init();
726
a1b806b9 727 if (m_bitmap.IsOk())
489468fe 728 {
03647350 729 SetBitmap( rBitmap );
489468fe
SC
730 }
731}
732
733wxBitmapDataObject::~wxBitmapDataObject()
734{
735 Clear();
736}
737
738void wxBitmapDataObject::SetBitmap( const wxBitmap& rBitmap )
739{
740 Clear();
741 wxBitmapDataObjectBase::SetBitmap( rBitmap );
a1b806b9 742 if (m_bitmap.IsOk())
489468fe
SC
743 {
744 CGImageRef cgImageRef = (CGImageRef) m_bitmap.CreateCGImage();
745
746 CFMutableDataRef data = CFDataCreateMutable(kCFAllocatorDefault, 0);
747 CGImageDestinationRef destination = CGImageDestinationCreateWithData( data , kUTTypeTIFF , 1 , NULL );
748 if ( destination )
749 {
750 CGImageDestinationAddImage( destination, cgImageRef, NULL );
751 CGImageDestinationFinalize( destination );
752 CFRelease( destination );
753 }
754 m_pictHandle = NewHandle(CFDataGetLength(data));
755 if ( m_pictHandle )
756 {
757 memcpy( *(Handle)m_pictHandle, (const char *)CFDataGetBytePtr(data), CFDataGetLength(data) );
758 }
759 CFRelease( data );
760
761 CGImageRelease(cgImageRef);
762 }
763}
764
765void wxBitmapDataObject::Init()
766{
767 m_pictHandle = NULL;
768 m_pictCreated = false;
769}
770
771void wxBitmapDataObject::Clear()
772{
773 if (m_pictHandle != NULL)
774 {
775 DisposeHandle( (Handle) m_pictHandle );
776 m_pictHandle = NULL;
777 }
778 m_pictCreated = false;
779}
780
781bool wxBitmapDataObject::GetDataHere( void *pBuf ) const
782{
783 if (m_pictHandle == NULL)
784 {
785 wxFAIL_MSG( wxT("attempt to copy empty bitmap failed") );
786 return false;
787 }
788
789 if (pBuf == NULL)
790 return false;
791
792 memcpy( pBuf, *(Handle)m_pictHandle, GetHandleSize( (Handle)m_pictHandle ) );
793
794 return true;
795}
796
797size_t wxBitmapDataObject::GetDataSize() const
798{
799 if (m_pictHandle != NULL)
800 return GetHandleSize( (Handle)m_pictHandle );
801 else
802 return 0;
803}
804
805Handle MacCreateDataReferenceHandle(Handle theDataHandle)
806{
807 Handle dataRef = NULL;
808 OSErr err = noErr;
809
810 // Create a data reference handle for our data.
811 err = PtrToHand( &theDataHandle, &dataRef, sizeof(Handle));
812
813 return dataRef;
814}
815
816bool wxBitmapDataObject::SetData( size_t nSize, const void *pBuf )
817{
818 Clear();
819
820 if ((pBuf == NULL) || (nSize == 0))
821 return false;
822
823 Handle picHandle = NewHandle( nSize );
824 memcpy( *picHandle, pBuf, nSize );
825 m_pictHandle = picHandle;
826 CGImageRef cgImageRef = 0;
827
828 CFDataRef data = CFDataCreateWithBytesNoCopy( kCFAllocatorDefault, (const UInt8*) pBuf, nSize, kCFAllocatorNull);
829 CGImageSourceRef source = CGImageSourceCreateWithData( data, NULL );
830 if ( source )
831 {
832 cgImageRef = CGImageSourceCreateImageAtIndex(source, 0, NULL);
c9e98a88 833 CFRelease( source );
489468fe 834 }
489468fe
SC
835 CFRelease( data );
836
837 if ( cgImageRef )
838 {
839 m_bitmap.Create( CGImageGetWidth(cgImageRef) , CGImageGetHeight(cgImageRef) );
840 CGRect r = CGRectMake( 0 , 0 , CGImageGetWidth(cgImageRef) , CGImageGetHeight(cgImageRef) );
841 // since our context is upside down we dont use CGContextDrawImage
842 wxMacDrawCGImage( (CGContextRef) m_bitmap.GetHBITMAP() , &r, cgImageRef ) ;
843 CGImageRelease(cgImageRef);
844 cgImageRef = NULL;
845 }
846
a1b806b9 847 return m_bitmap.IsOk();
489468fe
SC
848}
849
850#endif