]> git.saurik.com Git - wxWidgets.git/blob - src/osx/carbon/dataobj.cpp
new file added
[wxWidgets.git] / src / osx / carbon / dataobj.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/osx/carbon/dataobj.cpp
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"
29 #include "wx/filename.h"
30
31 #include "wx/osx/private.h"
32
33 #if wxOSX_USE_COCOA_OR_CARBON
34 #include <QuickTime/QuickTime.h>
35 #endif
36
37 // ----------------------------------------------------------------------------
38 // wxDataFormat
39 // ----------------------------------------------------------------------------
40
41 wxDataFormat::wxDataFormat()
42 {
43 m_type = wxDF_INVALID;
44 m_format = 0;
45 }
46
47 wxDataFormat::wxDataFormat( wxDataFormatId vType )
48 {
49 m_format = 0;
50 m_type = wxDF_INVALID;
51 SetType( vType );
52 }
53
54 wxDataFormat::wxDataFormat( const wxChar *zId )
55 {
56 m_format = 0;
57 m_type = wxDF_INVALID;
58 SetId( zId );
59 }
60
61 wxDataFormat::wxDataFormat( const wxString& rId )
62 {
63 m_format = 0;
64 m_type = wxDF_INVALID;
65 SetId( rId );
66 }
67
68 wxDataFormat::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
78 wxDataFormat::wxDataFormat( NativeFormat vFormat )
79 {
80 m_format = 0;
81 m_type = wxDF_INVALID;
82 SetId( vFormat );
83 }
84
85 wxDataFormat::~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
98 wxDataFormat& 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
112 void 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:
124 m_format = (long) CFStringCreateCopy( NULL, kUTTypePlainText );
125 break;
126
127 case wxDF_UNICODETEXT:
128 m_format = (long) CFStringCreateCopy( NULL, kUTTypeUTF16PlainText );
129 break;
130
131 case wxDF_HTML:
132 m_format = (long) CFStringCreateCopy( NULL, kUTTypeHTML );
133 break;
134
135 case wxDF_BITMAP:
136 m_format = (long) CFStringCreateCopy( NULL, kUTTypeTIFF );
137 break;
138 case wxDF_METAFILE:
139 m_format = (long) CFStringCreateCopy( NULL, kUTTypePDF );
140 break;
141
142 case wxDF_FILENAME:
143 m_format = (long) CFStringCreateCopy( NULL, kUTTypeFileURL );
144 break;
145
146 default:
147 wxFAIL_MSG( wxT("invalid data format") );
148 break;
149 }
150 }
151
152 wxString wxDataFormat::GetId() const
153 {
154 return wxCFStringRef(wxCFRetain((CFStringRef)m_format)).AsString();
155 }
156
157 void 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);
165 if ( UTTypeConformsTo( (CFStringRef)format, kUTTypeHTML ) )
166 {
167 m_type = wxDF_HTML;
168 }
169 if ( UTTypeConformsTo( (CFStringRef)format, kUTTypeUTF16PlainText ) )
170 {
171 m_type = wxDF_UNICODETEXT;
172 }
173 else if ( UTTypeConformsTo( (CFStringRef)format,kUTTypeUTF16ExternalPlainText ) )
174 {
175 m_type = wxDF_UNICODETEXT;
176 }
177 else if ( UTTypeConformsTo( (CFStringRef)format,kUTTypeUTF8PlainText ) )
178 {
179 m_type = wxDF_UNICODETEXT;
180 }
181 else if ( UTTypeConformsTo( (CFStringRef)format, kUTTypePlainText ) )
182 {
183 m_type = wxDF_TEXT;
184 }
185 else if ( UTTypeConformsTo( (CFStringRef)format, kUTTypeImage ) )
186 {
187 m_type = wxDF_BITMAP;
188 }
189 else if ( UTTypeConformsTo( (CFStringRef)format, kUTTypePDF ) )
190 {
191 m_type = wxDF_METAFILE;
192 }
193 else if ( UTTypeConformsTo( (CFStringRef)format, kUTTypeFileURL ) ||
194 UTTypeConformsTo( (CFStringRef)format, kPasteboardTypeFileURLPromise))
195 {
196 m_type = wxDF_FILENAME;
197 }
198 else
199 {
200 m_type = wxDF_PRIVATE;
201 m_id = wxCFStringRef( (CFStringRef) CFRetain((CFStringRef) format )).AsString();
202 }
203 }
204
205 void 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
218 bool 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
230 wxDataObject::wxDataObject()
231 {
232 }
233
234 bool 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
263 void 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 ];
273
274 // add four bytes at the end for data objs like text that
275 // have a datasize = strlen but still need a buffer for the
276 // string including trailing zero
277
278 size_t datasize = GetDataSize( thisFormat );
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
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 );
303 if ( GetDataHere( thisFormat, buf ) )
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 }
324
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
345 bool 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;
363
364 err = PasteboardGetItemIdentifier( pasteboard, itemIndex, &itemID );
365 if ( err != noErr )
366 continue;
367
368 err = PasteboardCopyItemFlavors( pasteboard, itemID, &flavorTypeArray );
369 if ( err != noErr )
370 continue;
371
372 flavorCount = CFArrayGetCount( flavorTypeArray );
373
374 for( CFIndex flavorIndex = 0; flavorIndex < flavorCount && hasData == false ; flavorIndex++ )
375 {
376 CFStringRef flavorType;
377
378 flavorType = (CFStringRef)CFArrayGetValueAtIndex( flavorTypeArray,
379 flavorIndex );
380
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
394 bool 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;
404 bool pastelocationset = false;
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;
430
431 flavorCount = CFArrayGetCount( flavorTypeArray );
432
433 for( CFIndex flavorIndex = 0; !transferred && flavorIndex < flavorCount ; flavorIndex++ )
434 {
435 CFStringRef flavorType;
436 CFDataRef flavorData;
437 CFIndex flavorDataSize;
438
439 flavorType = (CFStringRef)CFArrayGetValueAtIndex( flavorTypeArray,
440 flavorIndex );
441
442 wxDataFormat flavorFormat( (wxDataFormat::NativeFormat) flavorType );
443
444 if ( dataFormat == flavorFormat )
445 {
446 if ( UTTypeConformsTo( (CFStringRef)flavorType, kPasteboardTypeFileURLPromise) )
447 {
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 }
460 }
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
467 err = PasteboardCopyItemFlavorData( pasteboard, itemID, flavorType , &flavorData );
468 if ( err == noErr )
469 {
470 flavorDataSize = CFDataGetLength( flavorData );
471 if (dataFormat.GetType() == wxDF_FILENAME )
472 {
473 // revert the translation and decomposition to arrive at a proper utf8 string again
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 );
492
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 }
527 if ( !filenamesPassed.empty() )
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
538 bool 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;
572
573 flavorCount = CFArrayGetCount( flavorTypeArray );
574
575 for( CFIndex flavorIndex = 0; !hasData && flavorIndex < flavorCount ; flavorIndex++ )
576 {
577 CFStringRef flavorType;
578
579 flavorType = (CFStringRef)CFArrayGetValueAtIndex( flavorTypeArray,
580 flavorIndex );
581
582 wxDataFormat flavorFormat( (wxDataFormat::NativeFormat) flavorType );
583
584 if ( dataFormat == flavorFormat ||
585 (dataFormat.GetType() == wxDF_UNICODETEXT && flavorFormat.GetType() == wxDF_TEXT) )
586 {
587 hasData = true;
588 }
589 }
590 CFRelease( flavorTypeArray );
591 }
592 }
593 }
594 return hasData;
595 }
596
597 #if wxOSX_USE_COCOA
598
599 void 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
637 // ----------------------------------------------------------------------------
638 // wxTextDataObject
639 // ----------------------------------------------------------------------------
640
641 #if wxUSE_UNICODE
642 void 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
654 void 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
667 bool 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
682 size_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
693 bool 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
708 void wxFileDataObject::AddFile( const wxString& rFilename )
709 {
710 m_filenames.Add( rFilename );
711 }
712
713 // ----------------------------------------------------------------------------
714 // wxBitmapDataObject
715 // ----------------------------------------------------------------------------
716
717 wxBitmapDataObject::wxBitmapDataObject()
718 {
719 Init();
720 }
721
722 wxBitmapDataObject::wxBitmapDataObject( const wxBitmap& rBitmap )
723 : wxBitmapDataObjectBase( rBitmap )
724 {
725 Init();
726
727 if (m_bitmap.IsOk())
728 {
729 SetBitmap( rBitmap );
730 }
731 }
732
733 wxBitmapDataObject::~wxBitmapDataObject()
734 {
735 Clear();
736 }
737
738 void wxBitmapDataObject::SetBitmap( const wxBitmap& rBitmap )
739 {
740 Clear();
741 wxBitmapDataObjectBase::SetBitmap( rBitmap );
742 if (m_bitmap.IsOk())
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
765 void wxBitmapDataObject::Init()
766 {
767 m_pictHandle = NULL;
768 m_pictCreated = false;
769 }
770
771 void 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
781 bool 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
797 size_t wxBitmapDataObject::GetDataSize() const
798 {
799 if (m_pictHandle != NULL)
800 return GetHandleSize( (Handle)m_pictHandle );
801 else
802 return 0;
803 }
804
805 Handle 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
816 bool 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);
833 CFRelease( source );
834 }
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
847 return m_bitmap.IsOk();
848 }
849
850 #endif