← Back to branch summary

~ubuntu-branches/ubuntu/maverick/wxwidgets2.8/maverick-proposed

« back to all changes in this revision

Viewing changes to src/mac/carbon/dataobj.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Devid Filoni
  • Date: 2007-11-06 18:25:13 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20071106182513-809agqds6igh7mqo
Tags: 2.8.6.1-0ubuntu1
* New upstream version, based on the upstream tarball
  wxPython-src-2.8.6.1.tar.bz2, renamed debian to debian-upstream.
* Provide a get-orig-source target to do the repackaging.
* Fix "substvar-source-version-is-deprecated" lintian warnings.
* Remove duplicate Description field in debian/control.
* Add "\" at the end of line 8 in debian/python-wxtools.menu to fix
  "bad-test-in-menu-item" lintian error.
* Provide .xpm icons to fix "menu-icon-not-in-xpm-format" lintian errors,
  changed Icon field in debian/python-wxtools.menu.
* Fix "wrong-name-for-upstream-changelog" lintian warnings.
* Remove "Application;" from Categories field in debian/pycrust.desktop,
  debian/pyshell.desktop, debian/xrced.desktop.
* Switch "Apps" to "Applications" in debian/python-wxtools.menu to fix
  "menu-item-uses-apps-section" lintian warnings.
* Drop the icon extension from debian/pycrust.desktop,
  debian/pyshell.desktop, debian/xrced.desktop.
* Add dpatch support.
* Add "WX_CONFIG" patch.
* debian/rules:
  - added .xpm icons to install-gtk-py-tools target
  - added "docs/changes.txt" to dh_installchangelogs in binary-common target
  - added "\" at the end of "install-examples install-msw-dev
    install-msw-dbg install-headers-msw" line in .PHONY

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mac/carbon/dataobj.cpp
4
4
// Author:      Stefan Csomor
5
5
// Modified by:
6
6
// Created:     10/21/99
7
 
// RCS-ID:      $Id: dataobj.cpp,v 1.39 2006/10/21 16:39:41 VZ Exp $
 
7
// RCS-ID:      $Id: dataobj.cpp 49244 2007-10-19 14:46:03Z SC $
8
8
// Copyright:   (c) 1999 Stefan Csomor
9
9
// Licence:     wxWindows licence
10
10
///////////////////////////////////////////////////////////////////////////////
27
27
#include "wx/metafile.h"
28
28
#include "wx/tokenzr.h"
29
29
 
30
 
#include "wx/mac/private.h"
 
30
#include "wx/mac/uma.h"
31
31
 
32
 
#ifndef __DARWIN__
33
 
#include <Scrap.h>
 
32
#ifdef __DARWIN__
 
33
    #include <QuickTime/QuickTime.h>
34
34
#endif
35
35
 
36
36
 
46
46
 
47
47
wxDataFormat::wxDataFormat( wxDataFormatId vType )
48
48
{
 
49
    m_format = 0;
 
50
    m_type = wxDF_INVALID;
49
51
    SetType( vType );
50
52
}
51
53
 
52
54
wxDataFormat::wxDataFormat( const wxChar *zId )
53
55
{
 
56
    m_format = 0;
 
57
    m_type = wxDF_INVALID;
54
58
    SetId( zId );
55
59
}
56
60
 
57
61
wxDataFormat::wxDataFormat( const wxString& rId )
58
62
{
 
63
    m_format = 0;
 
64
    m_type = wxDF_INVALID;
59
65
    SetId( rId );
60
66
}
61
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
 
62
78
wxDataFormat::wxDataFormat( NativeFormat vFormat )
63
79
{
 
80
    m_format = 0;
 
81
    m_type = wxDF_INVALID;
64
82
    SetId( vFormat );
65
83
}
66
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
 
67
112
void wxDataFormat::SetType( wxDataFormatId dataType )
68
113
{
69
114
    m_type = dataType;
 
115
    if ( m_format != 0 )
 
116
    {
 
117
        CFRelease( (CFStringRef) m_format );
 
118
        m_format = 0;
 
119
    }
70
120
 
71
121
    switch (m_type)
72
122
    {
73
123
    case wxDF_TEXT:
74
 
        m_format = kScrapFlavorTypeText;
 
124
        m_format = (long) CFStringCreateCopy( NULL, CFSTR("public.plain-text") );
75
125
        break;
76
126
 
77
127
    case wxDF_UNICODETEXT:
78
 
        m_format = kScrapFlavorTypeUnicode;
 
128
        m_format = (long) CFStringCreateCopy( NULL, CFSTR("public.utf16-plain-text") );
79
129
        break;
80
130
 
81
131
    case wxDF_BITMAP:
 
132
#if wxMAC_USE_CORE_GRAPHICS
 
133
        m_format = (long) CFStringCreateCopy( NULL, CFSTR("public.tiff") );
 
134
#else
 
135
        m_format = (long) CFStringCreateCopy( NULL, CFSTR("com.apple.pict") );
 
136
#endif
 
137
        break;
82
138
    case wxDF_METAFILE:
83
 
        m_format = kScrapFlavorTypePicture;
 
139
#if wxMAC_USE_CORE_GRAPHICS
 
140
        m_format = (long) CFStringCreateCopy( NULL, CFSTR("com.adobe.pdf") );
 
141
#else
 
142
        m_format = (long) CFStringCreateCopy( NULL, CFSTR("com.apple.pict") );
 
143
#endif
84
144
        break;
85
145
 
86
146
    case wxDF_FILENAME:
87
 
        m_format = kDragFlavorTypeHFS;
 
147
        m_format = (long) CFStringCreateCopy( NULL, CFSTR("public.file-url") );
88
148
        break;
89
149
 
90
150
    default:
91
151
       wxFAIL_MSG( wxT("invalid data format") );
92
 
 
93
 
       // NB: this translates to '????' ASCII but it can't be used in the code
94
 
       // because '??' will get parsed as a trigraph!
95
 
       m_format = 0x3f3f3f3f;
96
152
       break;
97
153
    }
98
154
}
107
163
 
108
164
void wxDataFormat::SetId( NativeFormat format )
109
165
{
110
 
    m_format = format;
111
 
 
112
 
    switch (m_format)
113
 
    {
114
 
    case kScrapFlavorTypeText:
 
166
    if ( m_format != 0 )
 
167
    {
 
168
        CFRelease( (CFStringRef) m_format );
 
169
        m_format = 0;
 
170
    }
 
171
    m_format = (NativeFormat) CFStringCreateCopy(NULL, (CFStringRef)format);
 
172
    if (  UTTypeConformsTo( (CFStringRef)format, CFSTR("public.utf16-plain-text") )  ) 
 
173
    {
 
174
        m_type = wxDF_UNICODETEXT;
 
175
    } 
 
176
    else if ( UTTypeConformsTo( (CFStringRef)format, CFSTR("public.plain-text") ) )
 
177
    {
115
178
        m_type = wxDF_TEXT;
116
 
        break;
117
 
 
118
 
    case kScrapFlavorTypeUnicode:
119
 
        m_type = wxDF_UNICODETEXT;
120
 
        break;
121
 
 
122
 
    case kScrapFlavorTypePicture:
 
179
    }
 
180
#if wxMAC_USE_CORE_GRAPHICS
 
181
    else if (  UTTypeConformsTo( (CFStringRef)format, CFSTR("public.tiff") )  ) 
 
182
    {
123
183
        m_type = wxDF_BITMAP;
124
 
        break;
125
 
 
126
 
    case kDragFlavorTypeHFS:
 
184
    }
 
185
    else if (  UTTypeConformsTo( (CFStringRef)format, CFSTR("com.adobe.pdf") )  ) 
 
186
    {
 
187
        m_type = wxDF_METAFILE;
 
188
    }
 
189
#else
 
190
    else if (  UTTypeConformsTo( (CFStringRef)format, CFSTR("com.apple.pict") )  ) 
 
191
    {
 
192
        m_type = wxDF_METAFILE;
 
193
    }
 
194
#endif
 
195
    else if (  UTTypeConformsTo( (CFStringRef)format, CFSTR("public.file-url") )  ) 
 
196
    {
127
197
        m_type = wxDF_FILENAME;
128
 
        break;
129
 
 
130
 
    default:
 
198
    }
 
199
    else 
 
200
    {
131
201
        m_type = wxDF_PRIVATE;
132
 
        char text[5];
133
 
        memcpy( text, (const char*)&format, 4 );
134
 
        text[4] = 0;
135
 
        m_id = wxString::FromAscii( text );
136
 
        break;
 
202
        m_id = wxMacCFStringHolder( (CFStringRef) CFRetain((CFStringRef) format )).AsString();
137
203
    }
138
204
}
139
205
 
141
207
{
142
208
    m_type = wxDF_PRIVATE;
143
209
    m_id = zId;
144
 
    m_format = 'WXPR';
 
210
    if ( m_format != 0 )
 
211
    {
 
212
        CFRelease( (CFStringRef) m_format );
 
213
        m_format = 0;
 
214
    }
 
215
    // since it is private, no need to conform to anything ...
 
216
    m_format = (long) wxMacCFStringHolder(m_id).Detach();
145
217
}
146
218
 
147
219
bool wxDataFormat::operator==(const wxDataFormat& format) const
148
220
{
149
221
    if (IsStandard() || format.IsStandard())
150
 
        return (format.m_type == m_type);
 
222
        return ( format.m_type == m_type );
151
223
    else
152
 
        return (m_id == format.m_id);
 
224
        return ( UTTypeConformsTo( (CFStringRef) m_format , (CFStringRef) format.m_format ) );
153
225
}
154
226
 
155
227
//-------------------------------------------------------------------------
189
261
    return found;
190
262
}
191
263
 
 
264
void wxDataObject::AddToPasteboard( void * pb, int itemID )
 
265
{
 
266
    PasteboardRef pasteboard = (PasteboardRef) pb;
 
267
   // get formats from wxDataObjects
 
268
    wxDataFormat *array = new wxDataFormat[ GetFormatCount() ];
 
269
    GetAllFormats( array );
 
270
 
 
271
    for (size_t i = 0; i < GetFormatCount(); i++)
 
272
    {
 
273
        wxDataFormat thisFormat = array[ i ];
 
274
    
 
275
        // add four bytes at the end for data objs like text that 
 
276
        // have a datasize = strlen but still need a buffer for the
 
277
        // string including trailing zero
 
278
        
 
279
        size_t datasize = GetDataSize( thisFormat );
 
280
        size_t sz = datasize + 4;
 
281
        void* buf = malloc( sz );
 
282
        if ( buf != NULL )
 
283
        {
 
284
            // empty the buffer because in some case GetDataHere does not fill buf
 
285
            memset( buf, 0, sz );
 
286
            if ( GetDataHere( array[ i ], buf ) )
 
287
            {
 
288
                int counter = 1 ;
 
289
                if ( thisFormat.GetType() == wxDF_FILENAME )
 
290
                {
 
291
                    // the data is D-normalized UTF8 strings of filenames delimited with \n
 
292
                    char *fname = strtok((char*) buf,"\n");
 
293
                    while (fname != NULL)
 
294
                    {
 
295
                        // translate the filepath into a fileurl and put that into the pasteobard
 
296
                        CFStringRef path = CFStringCreateWithBytes(NULL,(UInt8*)fname,strlen(fname),kCFStringEncodingUTF8,false);
 
297
                        CFURLRef url = CFURLCreateWithFileSystemPath(NULL, path , kCFURLPOSIXPathStyle, false);
 
298
                        CFRelease(path);
 
299
                        CFDataRef data = CFURLCreateData(NULL,url,kCFStringEncodingUTF8,true);
 
300
                        CFRelease(url);
 
301
                        PasteboardPutItemFlavor( pasteboard, (PasteboardItemID) counter,
 
302
                            (CFStringRef) thisFormat.GetFormatId() , data, kPasteboardFlavorNoFlags);
 
303
                        CFRelease( data );
 
304
                        counter++;
 
305
                        fname = strtok (NULL,"\n");
 
306
                    }
 
307
                    
 
308
                }
 
309
                else
 
310
                {
 
311
                    CFDataRef data = CFDataCreate( kCFAllocatorDefault, (UInt8*)buf, datasize );
 
312
                    if ( thisFormat.GetType() == wxDF_TEXT )
 
313
                         PasteboardPutItemFlavor( pasteboard, (PasteboardItemID) itemID,
 
314
                            CFSTR("com.apple.traditional-mac-plain-text") , data, kPasteboardFlavorNoFlags);
 
315
                    else
 
316
                        PasteboardPutItemFlavor( pasteboard, (PasteboardItemID) itemID,
 
317
                            (CFStringRef) thisFormat.GetFormatId() , data, kPasteboardFlavorNoFlags);
 
318
                    CFRelease( data );
 
319
                }
 
320
            }
 
321
            free( buf );
 
322
        }
 
323
    }
 
324
 
 
325
    delete [] array;
 
326
}
 
327
 
 
328
bool wxDataObject::IsFormatInPasteboard( void * pb, const wxDataFormat &dataFormat )
 
329
{
 
330
    PasteboardRef pasteboard = (PasteboardRef) pb;
 
331
    bool hasData = false;
 
332
    OSStatus err = noErr;
 
333
    ItemCount itemCount;
 
334
 
 
335
    // we synchronize here once again, so we don't mind which flags get returned
 
336
    PasteboardSynchronize( pasteboard );
 
337
 
 
338
    err = PasteboardGetItemCount( pasteboard, &itemCount );
 
339
    if ( err == noErr )
 
340
    {
 
341
        for( UInt32 itemIndex = 1; itemIndex <= itemCount && hasData == false ; itemIndex++ )
 
342
        {
 
343
            PasteboardItemID    itemID;
 
344
            CFArrayRef          flavorTypeArray;
 
345
            CFIndex             flavorCount;
 
346
     
 
347
            err = PasteboardGetItemIdentifier( pasteboard, itemIndex, &itemID );
 
348
            if ( err != noErr )
 
349
                continue;
 
350
     
 
351
            err = PasteboardCopyItemFlavors( pasteboard, itemID, &flavorTypeArray );
 
352
            if ( err != noErr )
 
353
                continue;
 
354
     
 
355
            flavorCount = CFArrayGetCount( flavorTypeArray );
 
356
     
 
357
            for( CFIndex flavorIndex = 0; flavorIndex < flavorCount && hasData == false ; flavorIndex++ )
 
358
            {
 
359
                CFStringRef             flavorType;
 
360
     
 
361
                flavorType = (CFStringRef)CFArrayGetValueAtIndex( flavorTypeArray,
 
362
                                                                     flavorIndex );
 
363
                     
 
364
                wxDataFormat flavorFormat( (wxDataFormat::NativeFormat) flavorType );
 
365
                if ( dataFormat == flavorFormat )
 
366
                    hasData = true;
 
367
                else if (  dataFormat.GetType() == wxDF_UNICODETEXT && flavorFormat.GetType() == wxDF_TEXT )
 
368
                    hasData = true;
 
369
            }
 
370
            CFRelease (flavorTypeArray);
 
371
        }
 
372
    }
 
373
 
 
374
    return hasData;
 
375
}
 
376
 
 
377
bool wxDataObject::GetFromPasteboard( void * pb )
 
378
{
 
379
    PasteboardRef pasteboard = (PasteboardRef) pb;
 
380
    size_t formatcount = GetFormatCount() + 1;
 
381
    wxDataFormat *array = new wxDataFormat[ formatcount ];
 
382
    array[0] = GetPreferredFormat();
 
383
    GetAllFormats( &array[1] );
 
384
    ItemCount itemCount = 0;
 
385
    wxString filenamesPassed;
 
386
    bool transferred = false;
 
387
 
 
388
    // we synchronize here once again, so we don't mind which flags get returned
 
389
    PasteboardSynchronize( pasteboard );
 
390
 
 
391
    OSStatus err = PasteboardGetItemCount( pasteboard, &itemCount );
 
392
    if ( err == noErr )
 
393
    {
 
394
        for (size_t i = 0; !transferred && i < formatcount; i++)
 
395
        {
 
396
            // go through the data in our order of preference
 
397
            wxDataFormat dataFormat = array[ i ];
 
398
 
 
399
            for( UInt32 itemIndex = 1; itemIndex <= itemCount && transferred == false ; itemIndex++ )
 
400
            {
 
401
                PasteboardItemID    itemID = 0;
 
402
                CFArrayRef          flavorTypeArray = NULL;
 
403
                CFIndex             flavorCount = 0;
 
404
 
 
405
                err = PasteboardGetItemIdentifier( pasteboard, itemIndex, &itemID );
 
406
                if ( err != noErr )
 
407
                    continue;
 
408
 
 
409
                err = PasteboardCopyItemFlavors( pasteboard, itemID, &flavorTypeArray );
 
410
                if ( err != noErr )
 
411
                    continue;
 
412
                    
 
413
                flavorCount = CFArrayGetCount( flavorTypeArray );
 
414
 
 
415
                for( CFIndex flavorIndex = 0; !transferred && flavorIndex < flavorCount ; flavorIndex++ )
 
416
                {
 
417
                    CFStringRef             flavorType;
 
418
                    CFDataRef               flavorData;
 
419
                    CFIndex                 flavorDataSize;
 
420
         
 
421
                    flavorType = (CFStringRef)CFArrayGetValueAtIndex( flavorTypeArray,
 
422
                                                                         flavorIndex );
 
423
 
 
424
                    wxDataFormat flavorFormat( (wxDataFormat::NativeFormat) flavorType );
 
425
 
 
426
                    if ( dataFormat == flavorFormat )
 
427
                    {
 
428
                        err = PasteboardCopyItemFlavorData( pasteboard, itemID, flavorType , &flavorData );
 
429
                        if ( err == noErr )
 
430
                        {
 
431
                            flavorDataSize = CFDataGetLength( flavorData );
 
432
                            if (dataFormat.GetType() == wxDF_FILENAME )
 
433
                            {
 
434
                                // revert the translation and decomposition to arrive at a proper utf8 string again
 
435
                                CFURLRef url = CFURLCreateWithBytes( kCFAllocatorDefault, CFDataGetBytePtr( flavorData ), flavorDataSize, kCFStringEncodingUTF8, NULL );
 
436
                                CFStringRef cfString = CFURLCopyFileSystemPath( url, kCFURLPOSIXPathStyle );
 
437
                                CFRelease( url );
 
438
                                CFMutableStringRef cfMutableString = CFStringCreateMutableCopy(NULL, 0, cfString);
 
439
                                CFRelease( cfString );
 
440
                                CFStringNormalize(cfMutableString,kCFStringNormalizationFormC);
 
441
                                wxString path = wxMacCFStringHolder(cfMutableString).AsString();
 
442
                                if (!path.empty())
 
443
                                    filenamesPassed += path + wxT("\n");
 
444
                            }
 
445
                            else
 
446
                            {
 
447
                                // because some data implementation expect trailing a trailing NUL, we add some headroom
 
448
                                void *buf = malloc( flavorDataSize + 4 );
 
449
                                if ( buf )
 
450
                                {
 
451
                                    memset( buf, 0, flavorDataSize + 4 );
 
452
                                    memcpy( buf, CFDataGetBytePtr( flavorData ), flavorDataSize );
 
453
 
 
454
                                    if (dataFormat.GetType() == wxDF_TEXT)
 
455
                                        wxMacConvertNewlines10To13( (char*) buf );
 
456
                                    SetData( flavorFormat, flavorDataSize, buf );
 
457
                                    transferred = true;
 
458
                                    free( buf );
 
459
                                }
 
460
                            }
 
461
                            CFRelease (flavorData);
 
462
                        }
 
463
                    }
 
464
                    else if ( dataFormat.GetType() == wxDF_UNICODETEXT && flavorFormat.GetType() == wxDF_TEXT )
 
465
                    {
 
466
                        err = PasteboardCopyItemFlavorData( pasteboard, itemID, flavorType, &flavorData );
 
467
                        if ( err == noErr )
 
468
                        {
 
469
                            flavorDataSize = CFDataGetLength( flavorData );
 
470
                            void *asciibuf = malloc( flavorDataSize + 1 );
 
471
                            if ( asciibuf )
 
472
                            {
 
473
                                memset( asciibuf, 0, flavorDataSize + 1 );
 
474
                                memcpy( asciibuf, CFDataGetBytePtr( flavorData ), flavorDataSize );
 
475
                                CFRelease (flavorData);
 
476
 
 
477
                                SetData( wxDF_TEXT, flavorDataSize, asciibuf );
 
478
                                transferred = true;
 
479
                                free( asciibuf );
 
480
                            }
 
481
                            else
 
482
                                CFRelease (flavorData);
 
483
                        }
 
484
                    }
 
485
                }
 
486
                CFRelease( flavorTypeArray );
 
487
            }
 
488
            if (filenamesPassed.length() > 0)
 
489
            {
 
490
                wxCharBuffer buf = filenamesPassed.fn_str();
 
491
                SetData( wxDF_FILENAME, strlen( buf ), (const char*)buf );
 
492
                transferred = true;
 
493
            }
 
494
        }
 
495
    }
 
496
    return transferred;
 
497
}
 
498
 
 
499
bool wxDataObject::HasDataInPasteboard( void * pb )
 
500
{
 
501
    PasteboardRef pasteboard = (PasteboardRef) pb;
 
502
    size_t formatcount = GetFormatCount() + 1;
 
503
    wxDataFormat *array = new wxDataFormat[ formatcount ];
 
504
    array[0] = GetPreferredFormat();
 
505
    GetAllFormats( &array[1] );
 
506
    ItemCount itemCount = 0;
 
507
    bool hasData = false;
 
508
 
 
509
    // we synchronize here once again, so we don't mind which flags get returned
 
510
    PasteboardSynchronize( pasteboard );
 
511
 
 
512
    OSStatus err = PasteboardGetItemCount( pasteboard, &itemCount );
 
513
    if ( err == noErr )
 
514
    {
 
515
        for (size_t i = 0; !hasData && i < formatcount; i++)
 
516
        {
 
517
            // go through the data in our order of preference
 
518
            wxDataFormat dataFormat = array[ i ];
 
519
 
 
520
            for( UInt32 itemIndex = 1; itemIndex <= itemCount && hasData == false ; itemIndex++ )
 
521
            {
 
522
                PasteboardItemID    itemID = 0;
 
523
                CFArrayRef          flavorTypeArray = NULL;
 
524
                CFIndex             flavorCount = 0;
 
525
 
 
526
                err = PasteboardGetItemIdentifier( pasteboard, itemIndex, &itemID );
 
527
                if ( err != noErr )
 
528
                    continue;
 
529
 
 
530
                err = PasteboardCopyItemFlavors( pasteboard, itemID, &flavorTypeArray );
 
531
                if ( err != noErr )
 
532
                    continue;
 
533
                    
 
534
                flavorCount = CFArrayGetCount( flavorTypeArray );
 
535
 
 
536
                for( CFIndex flavorIndex = 0; !hasData && flavorIndex < flavorCount ; flavorIndex++ )
 
537
                {
 
538
                    CFStringRef             flavorType;
 
539
          
 
540
                    flavorType = (CFStringRef)CFArrayGetValueAtIndex( flavorTypeArray,
 
541
                                                                         flavorIndex );
 
542
 
 
543
                    wxDataFormat flavorFormat( (wxDataFormat::NativeFormat) flavorType );
 
544
 
 
545
                    if ( dataFormat == flavorFormat || 
 
546
                        dataFormat.GetType() == wxDF_UNICODETEXT && flavorFormat.GetType() == wxDF_TEXT )
 
547
                    {
 
548
                        hasData = true;
 
549
                    }
 
550
                }
 
551
                CFRelease( flavorTypeArray );
 
552
            }
 
553
        }
 
554
    }
 
555
    return hasData;
 
556
}
 
557
 
192
558
// ----------------------------------------------------------------------------
193
559
// wxTextDataObject
194
560
// ----------------------------------------------------------------------------
240
606
 
241
607
    GetFileNames( buf );
242
608
    buffLength = strlen( buf );
243
 
 
 
609
    // terminating 0
244
610
    return buffLength + 1;
245
611
}
246
612
 
280
646
 
281
647
    if (m_bitmap.Ok())
282
648
    {
 
649
#if wxMAC_USE_CORE_GRAPHICS
 
650
                SetBitmap( rBitmap );
 
651
#else
283
652
        m_pictHandle = m_bitmap.GetBitmapData()->GetPictHandle();
284
653
        m_pictCreated = false;
 
654
#endif
285
655
    }
286
656
}
287
657
 
296
666
    wxBitmapDataObjectBase::SetBitmap( rBitmap );
297
667
    if (m_bitmap.Ok())
298
668
    {
 
669
#if wxMAC_USE_CORE_GRAPHICS
 
670
        CGImageRef cgImageRef = (CGImageRef) m_bitmap.CGImageCreate();
 
671
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4
 
672
        if ( UMAGetSystemVersion() >= 0x1040 )
 
673
        {
 
674
            CFMutableDataRef data = CFDataCreateMutable(kCFAllocatorDefault, 0);
 
675
            CGImageDestinationRef destination = CGImageDestinationCreateWithData( data , kUTTypeTIFF , 1 , NULL );
 
676
            if ( destination )
 
677
            {
 
678
                CGImageDestinationAddImage( destination, cgImageRef, NULL );
 
679
                CGImageDestinationFinalize( destination );
 
680
                CFRelease( destination );
 
681
            }
 
682
            m_pictHandle = NewHandle(CFDataGetLength(data));
 
683
            if ( m_pictHandle )
 
684
            {
 
685
                memcpy( *(Handle)m_pictHandle, (const char *)CFDataGetBytePtr(data), CFDataGetLength(data) );
 
686
            }
 
687
            CFRelease( data );
 
688
        }
 
689
        else
 
690
#endif
 
691
#ifndef __LP64__
 
692
        {
 
693
            // export as TIFF
 
694
            GraphicsExportComponent exporter = 0;
 
695
            OSStatus err = OpenADefaultComponent(GraphicsExporterComponentType, kQTFileTypeTIFF, &exporter);
 
696
            if (noErr == err)
 
697
            {
 
698
                m_pictHandle = NewHandle(0);
 
699
                if ( m_pictHandle )
 
700
                {
 
701
                    err = GraphicsExportSetInputCGImage( exporter, cgImageRef);
 
702
                    err = GraphicsExportSetOutputHandle(exporter, (Handle)m_pictHandle);
 
703
                    err = GraphicsExportDoExport(exporter, NULL);
 
704
                }
 
705
                CloseComponent( exporter );
 
706
            }
 
707
        }
 
708
#endif
 
709
        CGImageRelease(cgImageRef);
 
710
#else
299
711
        m_pictHandle = m_bitmap.GetBitmapData()->GetPictHandle();
300
712
        m_pictCreated = false;
 
713
#endif
301
714
    }
302
715
}
303
716
 
311
724
{
312
725
    if (m_pictHandle != NULL)
313
726
    {
314
 
#ifndef __LP64__
 
727
#if wxMAC_USE_CORE_GRAPHICS
 
728
        DisposeHandle( (Handle) m_pictHandle );
 
729
#else
315
730
        if (m_pictCreated)
316
731
            KillPicture( (PicHandle)m_pictHandle );
317
732
#endif
318
733
        m_pictHandle = NULL;
319
734
    }
320
 
 
321
735
    m_pictCreated = false;
322
736
}
323
737
 
345
759
        return 0;
346
760
}
347
761
 
 
762
Handle MacCreateDataReferenceHandle(Handle theDataHandle)
 
763
{
 
764
    Handle  dataRef = NULL;
 
765
    OSErr   err     = noErr;
 
766
 
 
767
    // Create a data reference handle for our data.
 
768
    err = PtrToHand( &theDataHandle, &dataRef, sizeof(Handle));
 
769
 
 
770
    return dataRef;
 
771
}
 
772
 
348
773
bool wxBitmapDataObject::SetData( size_t nSize, const void *pBuf )
349
774
{
350
775
    Clear();
352
777
    if ((pBuf == NULL) || (nSize == 0))
353
778
        return false;
354
779
 
 
780
#if wxMAC_USE_CORE_GRAPHICS
 
781
    Handle picHandle = NewHandle( nSize );
 
782
    memcpy( *picHandle, pBuf, nSize );
 
783
    m_pictHandle = picHandle;
 
784
    CGImageRef cgImageRef = 0;
 
785
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4
 
786
    if ( UMAGetSystemVersion() >= 0x1040 )
 
787
    {
 
788
        CFDataRef data = CFDataCreateWithBytesNoCopy( kCFAllocatorDefault, (const UInt8*) pBuf, nSize, kCFAllocatorNull);
 
789
        CGImageSourceRef source = CGImageSourceCreateWithData( data, NULL );
 
790
        if ( source )
 
791
        {
 
792
            cgImageRef = CGImageSourceCreateImageAtIndex(source, 0, NULL);
 
793
        }
 
794
        CFRelease( source );
 
795
        CFRelease( data );
 
796
    }
 
797
    else
 
798
#endif
 
799
#ifndef __LP64__
 
800
    {
 
801
        // import from TIFF
 
802
        GraphicsImportComponent importer = 0;
 
803
        OSStatus err = OpenADefaultComponent(GraphicsImporterComponentType, kQTFileTypeTIFF, &importer);
 
804
        if (noErr == err)
 
805
        {
 
806
            if ( picHandle )
 
807
            {
 
808
                ComponentResult result = GraphicsImportSetDataHandle(importer, picHandle);
 
809
                if ( result == noErr )
 
810
                {
 
811
                    Rect frame;
 
812
                    GraphicsImportGetNaturalBounds( importer, &frame );
 
813
                    GraphicsImportCreateCGImage( importer, &cgImageRef, kGraphicsImportCreateCGImageUsingCurrentSettings );
 
814
                }
 
815
            }
 
816
            CloseComponent( importer );
 
817
        }
 
818
    }
 
819
#endif
 
820
    if ( cgImageRef )
 
821
    {
 
822
        m_bitmap.Create( CGImageGetWidth(cgImageRef)  , CGImageGetHeight(cgImageRef) );
 
823
        CGRect r = CGRectMake( 0 , 0 , CGImageGetWidth(cgImageRef)  , CGImageGetHeight(cgImageRef) );
 
824
        // since our context is upside down we dont use CGContextDrawImage
 
825
        HIViewDrawCGImage( (CGContextRef) m_bitmap.GetHBITMAP() , &r, cgImageRef ) ;
 
826
        CGImageRelease(cgImageRef);
 
827
        cgImageRef = NULL;
 
828
    }
 
829
#else
355
830
    PicHandle picHandle = (PicHandle)NewHandle( nSize );
356
831
    memcpy( *picHandle, pBuf, nSize );
357
832
    m_pictHandle = picHandle;
358
 
 
359
833
    // ownership is transferred to the bitmap
360
834
    m_pictCreated = false;
361
835
#ifndef __LP64__
373
847
#endif
374
848
    mdc.SelectObject( wxNullBitmap );
375
849
#endif
 
850
#endif
376
851
 
377
852
    return m_bitmap.Ok();
378
853
}