src/mac/carbon/mimetmac.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/mac/carbon/mimetype.cpp
   3 // Purpose:     Mac Carbon implementation for wx MIME-related classes
   4 // Author:      Ryan Norton
   5 // Modified by:
   6 // Created:     04/16/2005
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2005 Ryan Norton (<wxprojects@comcast.net>)
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 //
  13 //  TODO: Search Info[-macos](classic).plist dictionary in addition
  14 //  to Internet Config database.
  15 //
  16 //  Maybe try a brainstorm a way to change the wxMimeTypesManager API
  17 //  to get info from a file instead/addition to current get all stuff
  18 //  API so that we can use Launch Services to get MIME type info.
  19 //
  20 //  Implement GetIcon from one of the FinderInfo functions - or
  21 //  use Launch Services and search that app's plist for the icon.
  22 //
  23 //  Put some special juice in for the print command.
  24 //
  25
  26 // for compilers that support precompilation, includes "wx.h".
  27 #include "wx/wxprec.h"
  28
  29 #ifdef __BORLANDC__
  30     #pragma hdrstop
  31 #endif
  32
  33 #if wxUSE_MIMETYPE
  34
  35 #include "wx/mac/mimetype.h"
  36
  37 #ifndef WX_PRECOMP
  38     #include "wx/dynarray.h"
  39     #include "wx/string.h"
  40     #include "wx/intl.h"
  41     #include "wx/log.h"
  42
  43     #if wxUSE_GUI
  44         #include "wx/icon.h"
  45     #endif
  46 #endif
  47
  48 #include "wx/file.h"
  49 #include "wx/confbase.h"
  50
  51 #include "wx/mac/private.h"
  52
  53 // other standard headers
  54 #include <ctype.h>
  55
  56 #ifndef __DARWIN__
  57     #include <InternetConfig.h>
  58     #include <CoreServices.h>
  59 #endif
  60
  61 #ifndef __LP64__
  62 //   START CODE SAMPLE FROM TECHNOTE 1002 (http://developer.apple.com/technotes/tn/tn1002.html)
  63
  64 // IsRemoteVolume can be used to find out if the
  65 // volume referred to by vRefNum is a remote volume
  66 // located somewhere on a network. the volume's attribute
  67 // flags (copied from the GetVolParmsInfoBuffer structure)
  68 // are returned in the longword pointed to by vMAttrib.
  69 OSErr IsRemoteVolume(short vRefNum, Boolean *isRemote, long *vMAttrib)
  70 {
  71     HParamBlockRec volPB;
  72     GetVolParmsInfoBuffer volinfo;
  73     OSErr err;
  74
  75     volPB.ioParam.ioVRefNum = vRefNum;
  76     volPB.ioParam.ioNamePtr = NULL;
  77     volPB.ioParam.ioBuffer = (Ptr)&volinfo;
  78     volPB.ioParam.ioReqCount = sizeof(volinfo);
  79     err = PBHGetVolParmsSync( &volPB );
  80     if (err == noErr)
  81     {
  82         *isRemote = (volinfo.vMServerAdr != 0);
  83         *vMAttrib = volinfo.vMAttrib;
  84     }
  85
  86     return err;
  87 }
  88
  89 // BuildVolumeList fills the array pointed to by vols with
  90 // a list of the currently mounted volumes.  If includeRemote
  91 // is true, then remote server volumes will be included in
  92 // the list.  When remote server volumes are included in the
  93 // list, they will be added to the end of the list.  On entry,
  94 // *count should contain the size of the array pointed to by
  95 // vols.  On exit, *count will be set to the number of id numbers
  96 // placed in the array. If vMAttribMask is non-zero, then
  97 // only volumes with matching attributes are added to the
  98 // list of volumes. bits in the vMAttribMask should use the
  99 // same encoding as bits in the vMAttrib field of
 100 // the GetVolParmsInfoBuffer structure.
 101 OSErr BuildVolumeList(Boolean includeRemote, short *vols,
 102         long *count, long vMAttribMask)
 103 {
 104     HParamBlockRec volPB;
 105     Boolean isRemote;
 106     OSErr err = noErr;
 107     long nlocal, nremote;
 108     long vMAttrib;
 109
 110     // set up and check parameters
 111     volPB.volumeParam.ioNamePtr = NULL;
 112     nlocal = nremote = 0;
 113     if (*count == 0)
 114         return noErr;
 115
 116     // iterate through volumes
 117     for (volPB.volumeParam.ioVolIndex = 1;
 118         PBHGetVInfoSync(&volPB) == noErr;
 119         volPB.volumeParam.ioVolIndex++)
 120     {
 121         // skip remote volumes, if necessary
 122         err = IsRemoteVolume(volPB.volumeParam.ioVRefNum, &isRemote, &vMAttrib);
 123         if (err != noErr)
 124             goto bail;
 125
 126         if ((includeRemote || !isRemote) && ((vMAttrib & vMAttribMask) == vMAttribMask))
 127         {
 128             // add local volumes at the front; remote volumes at the end
 129             if (isRemote)
 130                 vols[nlocal + nremote++] = volPB.volumeParam.ioVRefNum;
 131             else
 132             {
 133                 if (nremote > 0)
 134                     BlockMoveData(
 135                         vols + nlocal,
 136                         vols + nlocal + 1,
 137                         nremote * sizeof(short) );
 138                 vols[nlocal++] = volPB.volumeParam.ioVRefNum;
 139             }
 140
 141             // list full?
 142             if ((nlocal + nremote) >= *count)
 143                 break;
 144         }
 145     }
 146
 147 bail:
 148     *count = (nlocal + nremote);
 149
 150     return err;
 151 }
 152
 153
 154 // FindApplication iterates through mounted volumes
 155 // searching for an application with the given creator
 156 // type.  If includeRemote is true, then remote volumes
 157 // will be searched (after local ones) for an application
 158 // with the creator type.
 159 //
 160 // Hacked to output to appName
 161 //
 162 #define kMaxVols 20
 163
 164 OSErr FindApplication(OSType appCreator, Boolean includeRemote, Str255 appName, FSSpec* appSpec)
 165 {
 166     short rRefNums[kMaxVols];
 167     long i, volCount;
 168     DTPBRec desktopPB;
 169     OSErr err;
 170
 171     // get a list of volumes - with desktop files
 172     volCount = kMaxVols;
 173     err = BuildVolumeList(includeRemote, rRefNums, &volCount, (1 << bHasDesktopMgr) );
 174     if (err != noErr)
 175         return err;
 176
 177     // iterate through the list
 178     for (i=0; i<volCount; i++)
 179     {
 180         // has a desktop file?
 181         desktopPB.ioCompletion = NULL;
 182         desktopPB.ioVRefNum = rRefNums[i];
 183         desktopPB.ioNamePtr = NULL;
 184         desktopPB.ioIndex = 0;
 185         err = PBDTGetPath( &desktopPB );
 186         if (err != noErr)
 187             continue;
 188
 189         // has the correct app??
 190         desktopPB.ioFileCreator = appCreator;
 191         desktopPB.ioNamePtr = appName;
 192         err = PBDTGetAPPLSync( &desktopPB );
 193         if (err != noErr)
 194             continue;
 195
 196         // make a file spec referring to it
 197         err = FSMakeFSSpec( rRefNums[i], desktopPB.ioAPPLParID, appName, appSpec );
 198         if (err != noErr)
 199             continue;
 200
 201         // found it!
 202         return noErr;
 203     }
 204
 205     return fnfErr;
 206 }
 207
 208 // END CODE SAMPLE FROM TECHNOTE 1002 (http://developer.apple.com/technotes/tn/tn1002.html)
 209
 210 // yeah, duplicated code
 211 pascal OSErr FSpGetFullPath( const FSSpec *spec,
 212     short *fullPathLength,
 213     Handle *fullPath )
 214 {
 215     OSErr result, realResult;
 216     FSSpec tempSpec;
 217     CInfoPBRec pb;
 218
 219     *fullPathLength = 0;
 220     *fullPath = NULL;
 221
 222     // default to noErr
 223     realResult = result = noErr;
 224
 225   // work around Nav Services "bug" (it returns invalid FSSpecs with empty names)
 226 #if 0
 227     if ( spec->name[0] == 0 )
 228     {
 229         result = FSMakeFSSpecCompat(spec->vRefNum, spec->parID, spec->name, &tempSpec);
 230     }
 231     else
 232     {
 233 #endif
 234
 235     // Make a copy of the input FSSpec that can be modified
 236     BlockMoveData( spec, &tempSpec, sizeof(FSSpec) );
 237
 238     if ( result == noErr )
 239     {
 240         if ( tempSpec.parID == fsRtParID )
 241         {
 242             // object is a volume
 243             // Add a colon to make it a full pathname
 244             ++tempSpec.name[0];
 245             tempSpec.name[tempSpec.name[0]] = ':';
 246
 247             // We're done
 248             result = PtrToHand(&tempSpec.name[1], fullPath, tempSpec.name[0]);
 249         }
 250         else
 251         {
 252             // object isn't a volume
 253
 254             // Is the object a file or a directory?
 255             pb.dirInfo.ioNamePtr = tempSpec.name;
 256             pb.dirInfo.ioVRefNum = tempSpec.vRefNum;
 257             pb.dirInfo.ioDrDirID = tempSpec.parID;
 258             pb.dirInfo.ioFDirIndex = 0;
 259             result = PBGetCatInfoSync( &pb );
 260
 261             // Allow file/directory name at end of path to not exist.
 262             realResult = result;
 263             if ((result == noErr) || (result == fnfErr))
 264             {
 265                 // if the object is a directory, append a colon so full pathname ends with colon
 266                 if ((result == noErr) && (pb.hFileInfo.ioFlAttrib & kioFlAttribDirMask) != 0)
 267                 {
 268                     ++tempSpec.name[0];
 269                     tempSpec.name[tempSpec.name[0]] = ':';
 270                 }
 271
 272                 // Put the object name in first
 273                 result = PtrToHand( &tempSpec.name[1], fullPath, tempSpec.name[0] );
 274                 if ( result == noErr )
 275                 {
 276                     // Get the ancestor directory names
 277                     pb.dirInfo.ioNamePtr = tempSpec.name;
 278                     pb.dirInfo.ioVRefNum = tempSpec.vRefNum;
 279                     pb.dirInfo.ioDrParID = tempSpec.parID;
 280
 281                     // loop until we have an error or find the root directory
 282                     do
 283                     {
 284                         pb.dirInfo.ioFDirIndex = -1;
 285                         pb.dirInfo.ioDrDirID = pb.dirInfo.ioDrParID;
 286                         result = PBGetCatInfoSync(&pb);
 287                         if ( result == noErr )
 288                         {
 289                             // Append colon to directory name
 290                             ++tempSpec.name[0];
 291                             tempSpec.name[tempSpec.name[0]] = ':';
 292
 293                             // Add directory name to beginning of fullPath
 294                             (void)Munger(*fullPath, 0, NULL, 0, &tempSpec.name[1], tempSpec.name[0]);
 295                             result = MemError();
 296                         }
 297                     }
 298                     while ( (result == noErr) && (pb.dirInfo.ioDrDirID != fsRtDirID) );
 299                 }
 300             }
 301         }
 302     }
 303
 304     if ( result == noErr )
 305     {
 306         // Return the length
 307         *fullPathLength = GetHandleSize( *fullPath );
 308         result = realResult;  // return realResult in case it was fnfErr
 309     }
 310     else
 311     {
 312         // Dispose of the handle and return NULL and zero length
 313         if ( *fullPath != NULL )
 314         {
 315             DisposeHandle( *fullPath );
 316            *fullPath = NULL;
 317         }
 318         *fullPathLength = 0;
 319     }
 320
 321     return result;
 322 }
 323 #endif // LP64
 324 //
 325 // On the mac there are two ways to open a file - one is through apple events and the
 326 // finder, another is through mime types.
 327 //
 328 // So, really there are two ways to implement wxFileType...
 329 //
 330 // Mime types are only available on OS 8.1+ through the InternetConfig API
 331 //
 332 // Much like the old-style file manager, it has 3 levels of flexibility for its methods -
 333 // Low - which means you have to iterate yourself through the mime database
 334 // Medium - which lets you sort of cache the database if you want to use lowlevel functions
 335 // High - which requires access to the database every time
 336 //
 337 // We want to be efficient (i.e. professional :) ) about it, so we use a combo of low
 338 // and mid-level functions
 339 //
 340 // TODO: Should we call ICBegin/ICEnd?  Then where?
 341 //
 342
 343 // debug helper
 344 inline void wxLogMimeDebug(const wxChar* WXUNUSED_UNLESS_DEBUG(szMsg), OSStatus WXUNUSED_UNLESS_DEBUG(status))
 345 {
 346     wxLogDebug(wxString::Format(wxT("%s  LINE:%i  OSERROR:%i"), szMsg, __LINE__, (int)status));
 347 }
 348
 349 // in case we're compiling in non-GUI mode
 350 class WXDLLIMPEXP_FWD_CORE wxIcon;
 351
 352 bool wxFileTypeImpl::SetCommand(const wxString& WXUNUSED(cmd), const wxString& WXUNUSED(verb), bool WXUNUSED(overwriteprompt))
 353 {
 354     wxASSERT_MSG( m_manager != NULL , wxT("Bad wxFileType") );
 355
 356     return false;
 357 }
 358
 359 bool wxFileTypeImpl::SetDefaultIcon(const wxString& WXUNUSED(strIcon), int WXUNUSED(index))
 360 {
 361     wxASSERT_MSG( m_manager != NULL , wxT("Bad wxFileType") );
 362
 363     return false;
 364 }
 365
 366 bool wxFileTypeImpl::GetOpenCommand(wxString *openCmd,
 367                                const wxFileType::MessageParameters& params) const
 368 {
 369     wxString cmd = GetCommand(wxT("open"));
 370
 371     *openCmd = wxFileType::ExpandCommand(cmd, params);
 372
 373     return !openCmd->empty();
 374 }
 375
 376 bool
 377 wxFileTypeImpl::GetPrintCommand(
 378     wxString *printCmd,
 379     const wxFileType::MessageParameters& params) const
 380 {
 381     wxString cmd = GetCommand(wxT("print"));
 382
 383     *printCmd = wxFileType::ExpandCommand(cmd, params);
 384
 385     return !printCmd->empty();
 386 }
 387
 388 //
 389 // Internet Config vs. Launch Services
 390 //
 391 // From OS 8 on there was internet config...
 392 // However, OSX and its finder does not use info
 393 // from Internet Config at all - the Internet Config
 394 // database ONLY CONTAINS APPS THAT ARE CLASSIC APPS
 395 // OR REGISTERED THROUGH INTERNET CONFIG
 396 //
 397 // Therefore on OSX in order for the open command to be useful
 398 // we need to go straight to launch services
 399 //
 400
 401 //on darwin, use launch services
 402
 403 #include <ApplicationServices/ApplicationServices.h>
 404
 405 wxString wxFileTypeImpl::GetCommand(const wxString& verb) const
 406 {
 407     wxASSERT_MSG( m_manager != NULL , wxT("Bad wxFileType") );
 408
 409     if (verb == wxT("open"))
 410     {
 411         ICMapEntry entry;
 412         ICGetMapEntry( (ICInstance) m_manager->m_hIC,
 413                        (Handle) m_manager->m_hDatabase,
 414                        m_lIndex, &entry);
 415
 416         wxString sCurrentExtension = wxMacMakeStringFromPascal(entry.extension);
 417         sCurrentExtension = sCurrentExtension.Right(sCurrentExtension.length()-1 );
 418
 419         //type, creator, ext, roles, outapp (FSRef), outappurl
 420         CFURLRef cfurlAppPath;
 421         OSStatus status = LSGetApplicationForInfo( kLSUnknownType,
 422             kLSUnknownCreator,
 423             wxMacCFStringHolder(sCurrentExtension, wxLocale::GetSystemEncoding()),
 424             kLSRolesAll,
 425             NULL,
 426             &cfurlAppPath );
 427
 428         if (status == noErr)
 429         {
 430             CFStringRef cfsUnixPath = CFURLCopyFileSystemPath(cfurlAppPath, kCFURLPOSIXPathStyle);
 431             CFRelease(cfurlAppPath);
 432
 433             // PHEW!  Success!
 434             // Since a filename might have spaces in it, so surround it with quotes
 435             if (cfsUnixPath)
 436             {
 437                 wxString resultStr;
 438
 439                 resultStr =
 440                     wxString(wxT("'"))
 441                     + wxMacCFStringHolder(cfsUnixPath).AsString(wxLocale::GetSystemEncoding())
 442                     + wxString(wxT("'"));
 443
 444                return resultStr;
 445             }
 446         }
 447         else
 448         {
 449             wxLogDebug(wxString::Format(wxT("%i - %s - %i"),
 450             __LINE__,
 451             wxT("LSGetApplicationForInfo failed."),
 452             (int)status));
 453         }
 454     }
 455
 456     return wxEmptyString;
 457 }
 458
 459 bool wxFileTypeImpl::GetDescription(wxString *desc) const
 460 {
 461     wxASSERT_MSG( m_manager != NULL , wxT("Bad wxFileType") );
 462
 463     ICMapEntry entry;
 464     ICGetMapEntry( (ICInstance) m_manager->m_hIC,
 465         (Handle) m_manager->m_hDatabase, m_lIndex, &entry );
 466
 467     *desc = wxMacMakeStringFromPascal( entry.entryName );
 468
 469     return true;
 470 }
 471
 472 bool wxFileTypeImpl::GetExtensions(wxArrayString& extensions)
 473 {
 474     wxASSERT_MSG( m_manager != NULL , wxT("Bad wxFileType") );
 475
 476     ICMapEntry entry;
 477     ICGetMapEntry( (ICInstance) m_manager->m_hIC,
 478         (Handle) m_manager->m_hDatabase, m_lIndex, &entry );
 479
 480     //entry has period in it
 481     wxString sCurrentExtension = wxMacMakeStringFromPascal( entry.extension );
 482     extensions.Add( sCurrentExtension.Right( sCurrentExtension.length() - 1 ) );
 483
 484     return true;
 485 }
 486
 487 bool wxFileTypeImpl::GetMimeType(wxString *mimeType) const
 488 {
 489     wxASSERT_MSG( m_manager != NULL , wxT("Bad wxFileType") );
 490
 491     ICMapEntry entry;
 492     ICGetMapEntry( (ICInstance) m_manager->m_hIC,
 493         (Handle) m_manager->m_hDatabase, m_lIndex, &entry );
 494
 495     *mimeType = wxMacMakeStringFromPascal(entry.MIMEType);
 496
 497     return true;
 498 }
 499
 500 bool wxFileTypeImpl::GetMimeTypes(wxArrayString& mimeTypes) const
 501 {
 502     wxString s;
 503
 504     if (GetMimeType(&s))
 505     {
 506         mimeTypes.Clear();
 507         mimeTypes.Add(s);
 508
 509         return true;
 510     }
 511
 512     return false;
 513 }
 514
 515 bool wxFileTypeImpl::GetIcon(wxIconLocation *WXUNUSED(icon)) const
 516 {
 517     wxASSERT_MSG( m_manager != NULL , wxT("Bad wxFileType") );
 518
 519     // no such file type or no value or incorrect icon entry
 520     return false;
 521 }
 522
 523 size_t wxFileTypeImpl::GetAllCommands(wxArrayString * verbs,
 524     wxArrayString * commands,
 525     const wxFileType::MessageParameters& params) const
 526 {
 527     wxASSERT_MSG( m_manager != NULL , wxT("Bad wxFileType") );
 528
 529     wxString sCommand;
 530     size_t ulCount = 0;
 531
 532     if (GetOpenCommand(&sCommand, params))
 533     {
 534         verbs->Add(wxString(wxT("open")));
 535         commands->Add(sCommand);
 536         ++ulCount;
 537     }
 538
 539     return ulCount;
 540 }
 541
 542 void wxMimeTypesManagerImpl::Initialize(int WXUNUSED(mailcapStyles), const wxString& WXUNUSED(extraDir))
 543 {
 544     wxASSERT_MSG(m_hIC == NULL, wxT("Already initialized wxMimeTypesManager!"));
 545
 546     // some apps (non-wx) use the 'plst' resource instead
 547 #if 0
 548     CFBundleRef cfbMain = CFBundleGetMainBundle();
 549     wxCFDictionary cfdInfo( CFBundleGetInfoDictionary(cfbMain), wxCF_RETAIN );
 550     wxString sLog;
 551     cfdInfo.PrintOut(sLog);
 552     wxLogDebug(sLog);
 553 #endif
 554
 555     // start Internet Config - log if there's an error
 556     // the second param is the signature of the application, also known
 557     // as resource ID 0.  However, as per some recent discussions, we may not
 558     // have a signature for this app, so a generic 'APPL' which is the executable
 559     // type will work for now.
 560     OSStatus status = ICStart( (ICInstance*)&m_hIC, 'APPL' );
 561
 562     if (status != noErr)
 563     {
 564         wxLogDebug(wxT("Could not initialize wxMimeTypesManager!"));
 565         wxFAIL;
 566         m_hIC = NULL;
 567
 568         return;
 569     }
 570
 571     ICAttr attr;
 572     m_hDatabase = (void**) NewHandle(0);
 573     status = ICFindPrefHandle( (ICInstance) m_hIC, kICMapping, &attr, (Handle) m_hDatabase );
 574
 575     //the database file can be corrupt (on OSX its
 576     //~/Library/Preferences/com.apple.internetconfig.plist)
 577     //- bail if it is
 578     if (status != noErr)
 579     {
 580         ClearData();
 581         wxLogDebug(wxT("Corrupt MIME database!"));
 582         return;
 583     }
 584
 585     //obtain the number of entries in the map
 586     status = ICCountMapEntries( (ICInstance) m_hIC, (Handle) m_hDatabase, &m_lCount );
 587     wxASSERT( status == noErr );
 588
 589 #if 0
 590     //debug stuff
 591     ICMapEntry entry;
 592     long pos;
 593
 594     for (long i = 1; i <= m_lCount; ++i)
 595     {
 596         OSStatus status = ICGetIndMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase, i, &pos, &entry );
 597
 598         if (status == noErr)
 599         {
 600             wxString sCreator = wxMacMakeStringFromPascal(entry.creatorAppName);
 601             wxString sCurrentExtension = wxMacMakeStringFromPascal(entry.extension);
 602             wxString sMIMEType = wxMacMakeStringFromPascal(entry.MIMEType);
 603
 604             wxFileTypeImpl impl;
 605             impl.Init(this, pos);
 606
 607             if (sMIMEType == wxT("text/html") && sCurrentExtension == wxT(".html"))
 608             {
 609                 wxString cmd;
 610
 611                 impl.GetOpenCommand( &cmd, wxFileType::MessageParameters (wxT("http://www.google.com")));
 612                 wxPrintf(wxT("APP: [%s]\n"), cmd.c_str());
 613             }
 614         }
 615     }
 616 #endif
 617 }
 618
 619 void wxMimeTypesManagerImpl::ClearData()
 620 {
 621     if (m_hIC != NULL)
 622     {
 623         DisposeHandle( (Handle)m_hDatabase );
 624
 625         // this can return an error, but we don't really care that much about it
 626         ICStop( (ICInstance)m_hIC );
 627         m_hIC = NULL;
 628     }
 629 }
 630
 631 //
 632 //  Q) Iterating through the map - why does it use if (err == noErr) instead of just asserting?
 633 //  A) Some intermediate indexes are bad while subsequent ones may be good.  Its wierd, I know.
 634 //
 635
 636 // extension -> file type
 637 wxFileType* wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& e)
 638 {
 639     wxASSERT_MSG( m_hIC != NULL, wxT("wxMimeTypesManager not Initialized!") );
 640
 641     //low level functions - iterate through the database
 642     ICMapEntry entry;
 643     long pos;
 644
 645     for (long i = 1; i <= m_lCount; ++i)
 646     {
 647         OSStatus status = ICGetIndMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase, i, &pos, &entry );
 648
 649         if (status == noErr)
 650         {
 651             wxString sCurrentExtension = wxMacMakeStringFromPascal(entry.extension);
 652             if ( sCurrentExtension.Right(sCurrentExtension.length() - 1) == e ) // entry has period in it
 653             {
 654                 wxFileType* pFileType = new wxFileType();
 655                 pFileType->m_impl->Init((wxMimeTypesManagerImpl*)this, pos);
 656
 657                 return pFileType;
 658             }
 659         }
 660     }
 661
 662     return NULL;
 663 }
 664
 665 // MIME type -> extension -> file type
 666 wxFileType* wxMimeTypesManagerImpl::GetFileTypeFromMimeType(const wxString& mimeType)
 667 {
 668     wxASSERT_MSG( m_hIC != NULL, wxT("wxMimeTypesManager not Initialized!") );
 669
 670     ICMapEntry entry;
 671     long pos;
 672
 673     // low level functions - iterate through the database
 674     for (long i = 1; i <= m_lCount; ++i)
 675     {
 676         OSStatus status = ICGetIndMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase, i, &pos, &entry );
 677         wxASSERT_MSG( status == noErr, wxString::Format(wxT("Error: %d"), (int)status) );
 678
 679         if (status == noErr)
 680         {
 681             if ( wxMacMakeStringFromPascal(entry.MIMEType) == mimeType)
 682             {
 683                 wxFileType* pFileType = new wxFileType();
 684                 pFileType->m_impl->Init((wxMimeTypesManagerImpl*)this, pos);
 685
 686                 return pFileType;
 687             }
 688         }
 689     }
 690
 691     return NULL;
 692 }
 693
 694 size_t wxMimeTypesManagerImpl::EnumAllFileTypes(wxArrayString& mimetypes)
 695 {
 696     wxASSERT_MSG( m_hIC != NULL, wxT("wxMimeTypesManager not Initialized!") );
 697
 698     ICMapEntry entry;
 699     long pos, lStartCount;
 700
 701     // low level functions - iterate through the database
 702     lStartCount = (long) mimetypes.GetCount();
 703     for (long i = 1; i <= m_lCount; ++i)
 704     {
 705         OSStatus status = ICGetIndMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase, i, &pos, &entry );
 706         if ( status == noErr )
 707             mimetypes.Add( wxMacMakeStringFromPascal(entry.MIMEType) );
 708     }
 709
 710     return mimetypes.GetCount() - lStartCount;
 711 }
 712
 713 pascal  OSStatus  MoreProcGetProcessTypeSignature(
 714     const ProcessSerialNumberPtr pPSN,
 715     OSType *pProcessType,
 716     OSType *pCreator)
 717 {
 718     OSStatus anErr = noErr;
 719     ProcessInfoRec infoRec;
 720     ProcessSerialNumber localPSN;
 721
 722     infoRec.processInfoLength = sizeof(ProcessInfoRec);
 723     infoRec.processName = NULL;
 724 #ifndef __LP64__
 725     infoRec.processAppSpec = NULL;
 726 #endif
 727
 728     if ( pPSN == NULL )
 729     {
 730         localPSN.highLongOfPSN = 0;
 731         localPSN.lowLongOfPSN  = kCurrentProcess;
 732     }
 733     else
 734     {
 735         localPSN = *pPSN;
 736     }
 737
 738     anErr = GetProcessInformation(&localPSN, &infoRec);
 739     if (anErr == noErr)
 740     {
 741         *pProcessType = infoRec.processType;
 742         *pCreator = infoRec.processSignature;
 743     }
 744
 745     return anErr;
 746 }
 747
 748 //
 749 //
 750 //  TODO: clean this up, its messy
 751 //
 752 //
 753 //
 754
 755 #include "wx/mac/corefoundation/cfstring.h"
 756
 757 #define wxCF_RELEASE true
 758 #define wxCF_RETAIN  false
 759
 760 // ----------------------------------------------------------------------------
 761 // wxCFDictionary
 762 // ----------------------------------------------------------------------------
 763
 764 class wxCFDictionary
 765 {
 766 public:
 767     wxCFDictionary(CFTypeRef ref, bool bRetain = wxCF_RELEASE)
 768     {
 769         m_cfmdRef = (CFMutableDictionaryRef) ref;
 770         if (bRetain == wxCF_RETAIN && ref)
 771             CFRetain(ref);
 772     }
 773
 774     wxCFDictionary(CFIndex cfiSize = 0)
 775     {
 776         CFDictionaryKeyCallBacks kcbs;
 777         CFDictionaryValueCallBacks vcbs;
 778         BuildKeyCallbacks(&kcbs);
 779         BuildValueCallbacks(&vcbs);
 780
 781         m_cfmdRef = CFDictionaryCreateMutable(
 782             kCFAllocatorDefault, cfiSize, &kcbs, &vcbs );
 783     }
 784
 785     ~wxCFDictionary()
 786     { Clear(); }
 787
 788     void Clear()
 789     {
 790         if (m_cfmdRef)
 791             CFRelease(m_cfmdRef);
 792     }
 793
 794     static const void* RetainProc(CFAllocatorRef, const void* v)
 795     { return (const void*) CFRetain(v); }
 796
 797     static void ReleaseProc(CFAllocatorRef, const void* v)
 798     { CFRelease(v); }
 799
 800     void MakeMutable(CFIndex cfiSize = 0)
 801     {
 802         CFDictionaryRef oldref = (CFDictionaryRef) m_cfmdRef;
 803
 804         m_cfmdRef = CFDictionaryCreateMutableCopy(
 805             kCFAllocatorDefault, cfiSize, oldref );
 806
 807         CFRelease( oldref );
 808     }
 809
 810     void BuildKeyCallbacks(CFDictionaryKeyCallBacks* pCbs)
 811     {
 812         pCbs->version = 0;
 813         pCbs->retain = RetainProc;
 814         pCbs->release = ReleaseProc;
 815         pCbs->copyDescription = NULL;
 816         pCbs->equal = NULL;
 817         pCbs->hash = NULL;
 818     }
 819
 820     void BuildValueCallbacks(CFDictionaryValueCallBacks* pCbs)
 821     {
 822         pCbs->version = 0;
 823         pCbs->retain = RetainProc;
 824         pCbs->release = ReleaseProc;
 825         pCbs->copyDescription = NULL;
 826         pCbs->equal = NULL;
 827     }
 828
 829     operator CFTypeRef () const
 830     { return (CFTypeRef)m_cfmdRef; }
 831
 832     CFDictionaryRef GetCFDictionary() const
 833     { return (CFDictionaryRef)m_cfmdRef; }
 834
 835     CFMutableDictionaryRef GetCFMutableDictionary()
 836     { return (CFMutableDictionaryRef) m_cfmdRef; }
 837
 838     CFTypeRef operator [] (CFTypeRef cftEntry) const
 839     {
 840         wxASSERT(IsValid());
 841         return (CFTypeRef) CFDictionaryGetValue((CFDictionaryRef)m_cfmdRef, cftEntry);
 842     }
 843
 844     CFIndex GetCount() const
 845     {
 846         wxASSERT(IsValid());
 847         return CFDictionaryGetCount((CFDictionaryRef)m_cfmdRef);
 848     }
 849
 850     void Add(CFTypeRef cftKey, CFTypeRef cftValue)
 851     {
 852         wxASSERT(IsValid());
 853         wxASSERT(Exists(cftKey) == false);
 854         CFDictionaryAddValue(m_cfmdRef, cftKey, cftValue);
 855     }
 856
 857     void Remove(CFTypeRef cftKey)
 858     {
 859         wxASSERT(IsValid());
 860         wxASSERT(Exists(cftKey));
 861         CFDictionaryRemoveValue(m_cfmdRef, cftKey);
 862     }
 863
 864     void Set(CFTypeRef cftKey, CFTypeRef cftValue)
 865     {
 866         wxASSERT(IsValid());
 867         wxASSERT(Exists(cftKey));
 868         CFDictionarySetValue(m_cfmdRef, cftKey, cftValue);
 869     }
 870
 871     bool Exists(CFTypeRef cftKey) const
 872     {
 873         wxASSERT(IsValid());
 874         return CFDictionaryContainsKey((CFDictionaryRef)m_cfmdRef, cftKey);
 875     }
 876
 877     bool IsOk() const
 878     { return m_cfmdRef != NULL; }
 879
 880     bool IsValid() const
 881     { return IsOk() && CFGetTypeID((CFTypeRef)m_cfmdRef) == CFDictionaryGetTypeID(); }
 882
 883     void PrintOut(wxString& sMessage)
 884     {
 885         PrintOutDictionary(sMessage, m_cfmdRef);
 886     }
 887
 888     static void PrintOutDictionary(wxString& sMessage, CFDictionaryRef cfdRef)
 889     {
 890         CFIndex cfiCount = CFDictionaryGetCount(cfdRef);
 891         CFTypeRef* pKeys = new CFTypeRef[cfiCount];
 892         CFTypeRef* pValues = new CFTypeRef[cfiCount];
 893
 894         CFDictionaryGetKeysAndValues(cfdRef, pKeys, pValues);
 895
 896         for (CFIndex i = 0; i < cfiCount; ++i)
 897         {
 898             wxString sKey = wxMacCFStringHolder(CFCopyTypeIDDescription(CFGetTypeID(pKeys[i]))).AsString();
 899             wxString sValue = wxMacCFStringHolder(CFCopyTypeIDDescription(CFGetTypeID(pValues[i]))).AsString();
 900
 901             sMessage <<
 902                 wxString::Format(wxT("[{#%d} Key : %s]"), (int) i,
 903                         sKey.c_str());
 904
 905             PrintOutType(sMessage, sKey, pKeys[i]);
 906
 907             sMessage <<
 908                 wxString::Format(wxT("\n\t[Value : %s]"),
 909                         sValue.c_str());
 910
 911             PrintOutType(sMessage, sValue, pValues[i]);
 912
 913             sMessage << wxT("\n");
 914         }
 915
 916         delete [] pKeys;
 917         delete [] pValues;
 918     }
 919
 920     static void PrintOutArray(wxString& sMessage, CFArrayRef cfaRef)
 921     {
 922         for (CFIndex i = 0; i < CFArrayGetCount(cfaRef); ++i)
 923         {
 924             wxString sValue = wxMacCFStringHolder(CFCopyTypeIDDescription(CFGetTypeID(
 925                 CFArrayGetValueAtIndex(cfaRef, i)
 926                 ))).AsString();
 927
 928             sMessage <<
 929                 wxString::Format(wxT("\t\t[{#%d} ArrayValue : %s]\n"), (int) i,
 930                         sValue.c_str());
 931
 932             PrintOutType(sMessage, sValue, CFArrayGetValueAtIndex(cfaRef, i));
 933         }
 934     }
 935
 936     static void PrintOutType(wxString& sMessage, const wxString& sValue, CFTypeRef cfRef)
 937     {
 938             sMessage << wxT(" {");
 939
 940             if (sValue == wxT("CFString"))
 941             {
 942                  sMessage << wxMacCFStringHolder((CFStringRef)cfRef, false).AsString();
 943             }
 944             else if (sValue == wxT("CFNumber"))
 945             {
 946                 int nOut;
 947                 CFNumberGetValue((CFNumberRef)cfRef, kCFNumberIntType, &nOut);
 948                 sMessage << nOut;
 949             }
 950             else if (sValue == wxT("CFDictionary"))
 951             {
 952                 PrintOutDictionary(sMessage, (CFDictionaryRef)cfRef);
 953             }
 954             else if (sValue == wxT("CFArray"))
 955             {
 956                 PrintOutArray(sMessage, (CFArrayRef)cfRef);
 957             }
 958             else if (sValue == wxT("CFBoolean"))
 959             {
 960                 sMessage << (cfRef == kCFBooleanTrue ? wxT("true") : wxT("false"));
 961             }
 962             else if (sValue == wxT("CFURL"))
 963             {
 964                 sMessage << wxMacCFStringHolder(CFURLCopyPath((CFURLRef) cfRef)).AsString();
 965             }
 966             else
 967             {
 968                 sMessage << wxT("*****UNKNOWN TYPE******");
 969             }
 970
 971             sMessage << wxT("} ");
 972     }
 973
 974 #if wxUSE_MIMETYPE
 975     void MakeValidXML();
 976 #endif
 977
 978     CFTypeRef WriteAsXML()
 979     {
 980         return CFPropertyListCreateXMLData(kCFAllocatorDefault, m_cfmdRef);
 981     }
 982
 983     bool ReadAsXML(CFTypeRef cfData, wxString* pErrorMsg = NULL)
 984     {
 985         Clear();
 986         CFStringRef cfsError=NULL;
 987         m_cfmdRef = (CFMutableDictionaryRef) CFPropertyListCreateFromXMLData(
 988                     kCFAllocatorDefault,
 989                     (CFDataRef)cfData,
 990                     kCFPropertyListMutableContainersAndLeaves,
 991                     &cfsError );
 992         if (cfsError)
 993         {
 994             if (pErrorMsg)
 995                 *pErrorMsg = wxMacCFStringHolder(cfsError).AsString();
 996             else
 997                 CFRelease(cfsError);
 998         }
 999
1000         return m_cfmdRef != NULL;
1001     }
1002
1003 private:
1004     CFMutableDictionaryRef m_cfmdRef;
1005 };
1006
1007 // ----------------------------------------------------------------------------
1008 // wxCFArray
1009 // ----------------------------------------------------------------------------
1010
1011 class wxCFArray
1012 {
1013 public:
1014     wxCFArray(CFTypeRef ref, bool bRetain = wxCF_RELEASE)
1015     {
1016         m_cfmaRef = (CFMutableArrayRef)ref;
1017         if (bRetain == wxCF_RETAIN && ref)
1018             CFRetain(ref);
1019     }
1020
1021     wxCFArray(CFIndex cfiSize = 0) : m_cfmaRef(NULL)
1022     { Create(cfiSize); }
1023
1024     ~wxCFArray()
1025     { Clear(); }
1026
1027     void MakeMutable(CFIndex cfiSize = 0)
1028     {
1029         wxASSERT(IsValid());
1030
1031         CFMutableArrayRef oldref = m_cfmaRef;
1032         m_cfmaRef = CFArrayCreateMutableCopy(
1033                 kCFAllocatorDefault,
1034                 cfiSize,
1035                 (CFArrayRef)oldref);
1036         CFRelease(oldref);
1037     }
1038
1039     void BuildCallbacks(CFArrayCallBacks* pCbs)
1040     {
1041         pCbs->version = 0;
1042         pCbs->retain = RetainProc;
1043         pCbs->release = ReleaseProc;
1044         pCbs->copyDescription = NULL;
1045         pCbs->equal = NULL;
1046     }
1047
1048     void Create(CFIndex cfiSize = 0)
1049     {
1050         Clear();
1051         CFArrayCallBacks cb;
1052         BuildCallbacks(&cb);
1053
1054         m_cfmaRef = CFArrayCreateMutable(kCFAllocatorDefault, cfiSize, &cb);
1055     }
1056
1057     void Clear()
1058     { if (m_cfmaRef) CFRelease(m_cfmaRef); }
1059
1060     static const void* RetainProc(CFAllocatorRef, const void* v)
1061     { return (const void*) CFRetain(v); }
1062
1063     static void ReleaseProc(CFAllocatorRef, const void* v)
1064     { CFRelease(v); }
1065
1066     operator CFTypeRef () const
1067     { return (CFTypeRef)m_cfmaRef; }
1068
1069     CFArrayRef GetCFArray() const
1070     { return (CFArrayRef)m_cfmaRef; }
1071
1072     CFMutableArrayRef GetCFMutableArray()
1073     { return (CFMutableArrayRef) m_cfmaRef; }
1074
1075     CFTypeRef operator [] (CFIndex cfiIndex) const
1076     {
1077         wxASSERT(IsValid());
1078         return (CFTypeRef) CFArrayGetValueAtIndex((CFArrayRef)m_cfmaRef, cfiIndex);
1079     }
1080
1081     CFIndex GetCount()
1082     {
1083         wxASSERT(IsValid());
1084         return CFArrayGetCount((CFArrayRef)m_cfmaRef);
1085     }
1086
1087     void Add(CFTypeRef cftValue)
1088     {
1089         wxASSERT(IsValid());
1090         CFArrayAppendValue(m_cfmaRef, cftValue);
1091     }
1092
1093     void Remove(CFIndex cfiIndex)
1094     {
1095         wxASSERT(IsValid());
1096         wxASSERT(cfiIndex < GetCount());
1097         CFArrayRemoveValueAtIndex(m_cfmaRef, cfiIndex);
1098     }
1099
1100     void Set(CFIndex cfiIndex, CFTypeRef cftValue)
1101     {
1102         wxASSERT(IsValid());
1103         wxASSERT(cfiIndex < GetCount());
1104         CFArraySetValueAtIndex(m_cfmaRef, cfiIndex, cftValue);
1105     }
1106
1107     bool IsOk() const
1108     { return m_cfmaRef != NULL; }
1109
1110     bool IsValid() const
1111     {
1112         return IsOk() && CFGetTypeID((CFTypeRef)m_cfmaRef) == CFArrayGetTypeID();
1113     }
1114
1115 #if wxUSE_MIMETYPE
1116     void MakeValidXML();
1117 #endif
1118
1119 private:
1120     CFMutableArrayRef m_cfmaRef;
1121 };
1122
1123 // ----------------------------------------------------------------------------
1124 // wxCFString
1125 // ----------------------------------------------------------------------------
1126
1127 class wxCFString
1128 {
1129 public:
1130     wxCFString(CFTypeRef ref, bool bRetain = wxCF_RELEASE) : m_Holder((CFStringRef)ref, bRetain == wxCF_RELEASE)
1131     {}
1132
1133     wxCFString(const wxChar* szString) : m_Holder(wxString(szString), wxLocale::GetSystemEncoding())
1134     {}
1135
1136     wxCFString(const wxString& sString) : m_Holder(sString, wxLocale::GetSystemEncoding())
1137     {}
1138
1139     virtual ~wxCFString() {}
1140
1141     operator CFTypeRef() const
1142     { return (CFTypeRef) ((CFStringRef) m_Holder); }
1143
1144     bool IsOk()
1145     { return ((CFTypeRef)(*this)) != NULL; }
1146
1147     wxString BuildWXString()
1148     { return m_Holder.AsString(); }
1149
1150 private:
1151     wxMacCFStringHolder m_Holder;
1152 };
1153
1154 // ----------------------------------------------------------------------------
1155 // wxCFNumber
1156 // ----------------------------------------------------------------------------
1157
1158 class wxCFNumber
1159 {
1160 public:
1161     wxCFNumber(int nValue)
1162     {
1163         m_cfnRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &nValue);
1164     }
1165
1166     wxCFNumber(CFTypeRef ref, bool bRetain = wxCF_RELEASE) : m_cfnRef((CFNumberRef)ref)
1167     {
1168         if (bRetain == wxCF_RETAIN && ref)
1169             CFRetain(ref);
1170     }
1171
1172     virtual ~wxCFNumber()
1173     {
1174         if (m_cfnRef)
1175             CFRelease(m_cfnRef);
1176     }
1177
1178     operator CFTypeRef() const
1179     { return (CFTypeRef) m_cfnRef; }
1180
1181     int GetValue()
1182     {
1183         int nOut;
1184         CFNumberGetValue( m_cfnRef, kCFNumberIntType, &nOut );
1185
1186         return nOut;
1187     }
1188
1189     bool IsOk()
1190     { return m_cfnRef != NULL; }
1191
1192 private:
1193     CFNumberRef m_cfnRef;
1194 };
1195
1196 // ----------------------------------------------------------------------------
1197 // wxCFURL
1198 // ----------------------------------------------------------------------------
1199
1200 class wxCFURL
1201 {
1202 public:
1203     wxCFURL(CFTypeRef ref = NULL, bool bRetain = wxCF_RELEASE) : m_cfurlRef((CFURLRef)ref)
1204     {
1205         if (bRetain == wxCF_RETAIN && ref)
1206             CFRetain(ref);
1207     }
1208
1209     wxCFURL(const wxCFString& URLString, CFTypeRef BaseURL = NULL)
1210     {
1211         Create(URLString, BaseURL);
1212     }
1213
1214     void Create(const wxCFString& URLString, CFTypeRef BaseURL = NULL)
1215     {
1216         m_cfurlRef = CFURLCreateWithString(
1217             kCFAllocatorDefault,
1218             (CFStringRef)(CFTypeRef)URLString,
1219             (CFURLRef) BaseURL);
1220     }
1221
1222     virtual ~wxCFURL()
1223     {
1224         if (m_cfurlRef)
1225             CFRelease(m_cfurlRef);
1226     }
1227
1228     wxString BuildWXString()
1229     {
1230         return wxCFString(CFURLCopyPath(m_cfurlRef)).BuildWXString();
1231     }
1232
1233     operator CFTypeRef() const
1234     { return (CFTypeRef)m_cfurlRef; }
1235
1236     bool IsOk()
1237     { return m_cfurlRef != NULL; }
1238
1239 private:
1240     CFURLRef m_cfurlRef;
1241 };
1242
1243 // ----------------------------------------------------------------------------
1244 // wxCFData
1245 // ----------------------------------------------------------------------------
1246
1247 #define wxCFDATA_RELEASEBUFFER  1
1248
1249 class wxCFData
1250 {
1251 public:
1252     wxCFData(CFTypeRef ref, bool bRetain = wxCF_RELEASE) : m_cfdaRef((CFDataRef)ref)
1253     {
1254         if (bRetain == wxCF_RETAIN && ref)
1255             CFRetain(ref);
1256     }
1257
1258     wxCFData(const UInt8* pBytes, CFIndex len, bool bKeep = wxCFDATA_RELEASEBUFFER)
1259     {
1260         if (bKeep == wxCFDATA_RELEASEBUFFER)
1261         {
1262             m_cfdaRef = CFDataCreateWithBytesNoCopy
1263                             (kCFAllocatorDefault, pBytes, len, kCFAllocatorDefault);
1264         }
1265         else
1266         {
1267             m_cfdaRef = CFDataCreate(kCFAllocatorDefault, pBytes, len);
1268         }
1269     }
1270
1271     virtual ~wxCFData()
1272     {
1273         if (m_cfdaRef)
1274             CFRelease(m_cfdaRef);
1275     }
1276
1277     const UInt8* GetValue()
1278     { return CFDataGetBytePtr(m_cfdaRef); }
1279
1280     CFIndex GetCount()
1281     { return CFDataGetLength(m_cfdaRef); }
1282
1283     operator CFTypeRef() const
1284     { return (CFTypeRef)m_cfdaRef; }
1285
1286     bool IsOk()
1287     { return m_cfdaRef != NULL; }
1288
1289 private:
1290     CFDataRef m_cfdaRef;
1291 };
1292
1293 void wxCFDictionary::MakeValidXML()
1294 {
1295         CFIndex cfiCount = GetCount();
1296         CFTypeRef* pKeys = new CFTypeRef[cfiCount];
1297         CFTypeRef* pValues = new CFTypeRef[cfiCount];
1298
1299         CFDictionaryGetKeysAndValues(m_cfmdRef, pKeys, pValues);
1300
1301         // for plist xml format, all dictionary keys must be cfstrings and
1302         // no values in the dictionary or subkeys/values can be NULL;
1303         // additionally, CFURLs are not allowed
1304         for (CFIndex i = 0; i < cfiCount; ++i)
1305         {
1306             // must be an array, dictionary, string, bool, or int and cannot be null
1307             // and dictionaries can only contain cfstring keys
1308             CFTypeRef cfRef = pValues[i];
1309             if (!pKeys[i] ||
1310                 CFGetTypeID(pKeys[i]) != CFStringGetTypeID() ||
1311                 !cfRef)
1312             {
1313                 Remove(pKeys[i]);
1314                 --i;
1315                 --cfiCount;
1316                 delete [] pKeys;
1317                 delete [] pValues;
1318                 pKeys = new CFTypeRef[cfiCount];
1319                 pValues = new CFTypeRef[cfiCount];
1320                 CFDictionaryGetKeysAndValues(m_cfmdRef, pKeys, pValues);
1321             }
1322             else if (CFGetTypeID(cfRef) == CFArrayGetTypeID())
1323             {
1324                 CFRetain(cfRef);
1325                 wxCFArray cfaCurrent(cfRef);
1326                 cfaCurrent.MakeMutable();
1327                 cfaCurrent.MakeValidXML();
1328                 Set(pKeys[i], cfaCurrent);
1329             }
1330             else if (CFGetTypeID(cfRef) == CFDictionaryGetTypeID())
1331             {
1332                 CFRetain(cfRef);
1333                 wxCFDictionary cfdCurrent(cfRef);
1334                 cfdCurrent.MakeMutable();
1335                 cfdCurrent.MakeValidXML();
1336                 Set(pKeys[i], cfdCurrent);
1337             }
1338             else if ( CFGetTypeID(cfRef) != CFStringGetTypeID() &&
1339                       CFGetTypeID(cfRef) != CFNumberGetTypeID() &&
1340                       CFGetTypeID(cfRef) != CFBooleanGetTypeID() )
1341             {
1342                 Remove(pKeys[i]);
1343                 --i;
1344                 --cfiCount;
1345                 delete [] pKeys;
1346                 delete [] pValues;
1347                 pKeys = new CFTypeRef[cfiCount];
1348                 pValues = new CFTypeRef[cfiCount];
1349                 CFDictionaryGetKeysAndValues(m_cfmdRef, pKeys, pValues);
1350             }
1351         }
1352
1353         delete [] pValues;
1354         delete [] pKeys;
1355 }
1356
1357 void wxCFArray::MakeValidXML()
1358 {
1359         for (CFIndex i = 0; i < GetCount(); ++i)
1360         {
1361             //must be an array, dictionary, string, bool, or int and cannot be null
1362             //and dictionaries can only contain cfstring keys
1363             CFTypeRef cfRef = (*this)[i];
1364             if (!cfRef)
1365             {
1366                 Remove(i);
1367                 --i;
1368             }
1369             else if (CFGetTypeID(cfRef) == CFArrayGetTypeID())
1370             {
1371                 CFRetain(cfRef);
1372                 wxCFArray cfaCurrent(cfRef);
1373                 cfaCurrent.MakeMutable();
1374                 cfaCurrent.MakeValidXML();
1375                 Set(i, cfaCurrent);
1376             }
1377             else if (CFGetTypeID(cfRef) == CFDictionaryGetTypeID())
1378             {
1379                 CFRetain(cfRef);
1380                 wxCFDictionary cfdCurrent(cfRef);
1381                 cfdCurrent.MakeMutable();
1382                 cfdCurrent.MakeValidXML();
1383                 Set(i, cfdCurrent);
1384             }
1385             else if ( CFGetTypeID(cfRef) != CFStringGetTypeID() &&
1386                       CFGetTypeID(cfRef) != CFNumberGetTypeID() &&
1387                       CFGetTypeID(cfRef) != CFBooleanGetTypeID() )
1388             {
1389                 Remove(i);
1390                 --i;
1391             }
1392         }
1393 }
1394
1395 //
1396 //
1397 //
1398 //  END TODO
1399 //
1400 //
1401 //
1402
1403 wxFileType* wxMimeTypesManagerImpl::Associate(const wxFileTypeInfo& ftInfo)
1404 {
1405     bool bInfoSuccess = false;
1406
1407     const wxArrayString& asExtensions = ftInfo.GetExtensions();
1408     size_t dwFoundIndex = 0;
1409     if (!asExtensions.GetCount())
1410     {
1411         wxLogDebug(wxT("Must have extension to associate with"));
1412     }
1413
1414     // Find and write to Info.plist in main bundle (note that some other
1415     // apps have theirs named differently, i.e. IE's is named Info-macos.plist
1416     // some apps (non-wx) use the 'plst' resource instead
1417     CFBundleRef cfbMain = CFBundleGetMainBundle();
1418     if (cfbMain)
1419     {
1420         UInt32 dwBundleType, dwBundleCreator;
1421         CFBundleGetPackageInfo(cfbMain, &dwBundleType, &dwBundleCreator);
1422
1423         // if launching terminal non-app, version will be 'BNDL' (generic bundle, maybe in other cases too),
1424         // which will give us the incorrect info.plist path
1425         // otherwise it will be 'APPL', or in the case of a framework, 'FMWK'
1426         if (dwBundleType == 'APPL')
1427         {
1428             wxCFURL cfurlBundleLoc((CFTypeRef)CFBundleCopyBundleURL(cfbMain));
1429 //             wxCFURL cfurlBundleLoc((CFTypeRef)CFBundleCopyExecutableURL(cfbMain));
1430             wxString sInfoPath;
1431 //            sInfoPath << wxT("file://");
1432             sInfoPath << cfurlBundleLoc.BuildWXString();
1433             sInfoPath << wxT("Contents/Info.plist");
1434
1435 //        wxCFDictionary cfdInfo( CFBundleGetInfoDictionary(cfbMain), wxCF_RETAIN );
1436             wxCFDictionary cfdInfo;
1437             bool bInfoOpenSuccess = false;
1438             wxFile indictfile;
1439             if (indictfile.Open(sInfoPath, wxFile::read))
1440             {
1441                 CFIndex cfiBufLen = (CFIndex) indictfile.Length();
1442                 const UInt8* pBuffer = new UInt8[cfiBufLen];
1443                 indictfile.Read((void*)pBuffer, cfiBufLen);
1444                 wxCFData cfdaInDict(pBuffer, cfiBufLen);
1445                 wxString sError;
1446                 bInfoOpenSuccess = cfdInfo.ReadAsXML(cfdaInDict, &sError);
1447                 if (!bInfoOpenSuccess)
1448                     wxLogDebug(sError);
1449                 indictfile.Close();
1450             }
1451
1452             if (bInfoOpenSuccess)
1453             {
1454                 cfdInfo.MakeMutable( cfdInfo.GetCount() + 1 );
1455
1456                 wxCFArray cfaDocTypes( cfdInfo[ wxCFString(wxT("CFBundleDocumentTypes")) ], wxCF_RETAIN );
1457
1458                 bool bAddDocTypesArrayToDictionary = !cfaDocTypes.IsOk();
1459                 if (bAddDocTypesArrayToDictionary)
1460                     cfaDocTypes.Create();
1461                 else
1462                     cfaDocTypes.MakeMutable( cfaDocTypes.GetCount() + 1 );
1463
1464                 bool bEntryFound = false;
1465
1466                 // search for duplicates
1467                 CFIndex i;
1468                 for (i = 0; i < cfaDocTypes.GetCount(); ++i)
1469                 {
1470                     wxCFDictionary cfdDocTypeEntry( cfaDocTypes[i], wxCF_RETAIN );
1471
1472                     // A lot of apps don't support MIME types for some reason
1473                     // so we go by extensions only
1474                     wxCFArray cfaExtensions( cfdDocTypeEntry[ wxCFString(wxT("CFBundleTypeExtensions")) ],
1475                                              wxCF_RETAIN );
1476
1477                     if (!cfaExtensions.IsOk())
1478                         continue;
1479
1480                     for (CFIndex iExt = 0; iExt < cfaExtensions.GetCount(); ++iExt)
1481                     {
1482                         for (size_t iWXExt = 0; iWXExt < asExtensions.GetCount(); ++iWXExt)
1483                         {
1484                             if (asExtensions[iWXExt] ==
1485                                     wxCFString(cfaExtensions[iExt], wxCF_RETAIN).BuildWXString())
1486                             {
1487                                 bEntryFound = true;
1488                                 dwFoundIndex = iWXExt;
1489
1490                                 break;
1491                             }
1492                         } //end of wxstring array
1493
1494                         if (bEntryFound)
1495                             break;
1496                     } //end for cf array
1497
1498                     if (bEntryFound)
1499                         break;
1500                 } //end for doctypes
1501
1502                 wxCFDictionary cfdNewEntry;
1503
1504                 if (!ftInfo.GetDescription().empty())
1505                 {
1506                     cfdNewEntry.Add( wxCFString(wxT("CFBundleTypeName")),
1507                                 wxCFString(ftInfo.GetDescription()) );
1508                 }
1509
1510                 if (!ftInfo.GetIconFile().empty())
1511                 {
1512                     cfdNewEntry.Add( wxCFString(wxT("CFBundleTypeIconFile")),
1513                                     wxCFString(ftInfo.GetIconFile()) );
1514                 }
1515
1516                 wxCFArray cfaOSTypes;
1517                 wxCFArray cfaExtensions;
1518                 wxCFArray cfaMimeTypes;
1519
1520                 //OSTypes is a cfarray of four-char-codes - '****' for unrestricted
1521                 cfaOSTypes.Add( wxCFString(wxT("****")) );
1522                 cfdNewEntry.Add( wxCFString(wxT("CFBundleTypeOSTypes")), cfaOSTypes );
1523
1524                 //'*' for unrestricted
1525                 if (ftInfo.GetExtensionsCount() != 0)
1526                 {
1527                     for (size_t iExtension = 0; iExtension < ftInfo.GetExtensionsCount(); ++iExtension)
1528                     {
1529                         cfaExtensions.Add( wxCFString( asExtensions[iExtension] ) );
1530                     }
1531
1532                     cfdNewEntry.Add( wxCFString(wxT("CFBundleTypeExtensions")), cfaExtensions );
1533                 }
1534
1535                 if (!ftInfo.GetMimeType().empty())
1536                 {
1537                     cfaMimeTypes.Add( wxCFString(ftInfo.GetMimeType()) );
1538                     cfdNewEntry.Add( wxCFString(wxT("CFBundleTypeMIMETypes")), cfaMimeTypes );
1539                 }
1540
1541                 // Editor - can perform all actions
1542                 // Viewer - all actions except manipulation/saving
1543                 // None - can perform no actions
1544                 cfdNewEntry.Add( wxCFString(wxT("CFBundleTypeRole")), wxCFString(wxT("Editor")) );
1545
1546                 // Is application bundled?
1547                 cfdNewEntry.Add( wxCFString(wxT("LSTypeIsPackage")), kCFBooleanTrue );
1548
1549                 if (bEntryFound)
1550                     cfaDocTypes.Set(i, cfdNewEntry);
1551                 else
1552                     cfaDocTypes.Add(cfdNewEntry);
1553
1554                 // set the doc types array in the muted dictionary
1555                 if (bAddDocTypesArrayToDictionary)
1556                     cfdInfo.Add(wxCFString(wxT("CFBundleDocumentTypes")), cfaDocTypes);
1557                 else
1558                     cfdInfo.Set(wxCFString(wxT("CFBundleDocumentTypes")), cfaDocTypes);
1559
1560                 cfdInfo.MakeValidXML();
1561
1562                 wxFile outdictfile;
1563                 if (outdictfile.Open(sInfoPath, wxFile::write))
1564                 {
1565                     wxCFData cfdaInfo(cfdInfo.WriteAsXML());
1566                     if (cfdaInfo.IsOk())
1567                     {
1568                         if (outdictfile.Write(cfdaInfo.GetValue(), cfdaInfo.GetCount()) !=
1569                             (wxFileOffset)cfdaInfo.GetCount())
1570                         {
1571                             wxLogDebug(wxT("error in writing to file"));
1572                         }
1573                         else
1574                         {
1575                             bInfoSuccess = true;
1576
1577 //#if defined(__DARWIN__)
1578 //                //force launch services to update its database for the finder
1579 //                OSStatus status = LSRegisterURL((CFURLRef)(CFTypeRef)cfurlBundleLoc, true);
1580 //                if (status != noErr)
1581 //                {
1582 //                    wxLogDebug(wxT("LSRegisterURL Failed."));
1583 //                }
1584 //#endif
1585                         }
1586                         outdictfile.Close();
1587                     }
1588                     else
1589                     {
1590                         outdictfile.Close();
1591                         wxLogDebug(wxT("Could not read in new dictionary"));
1592                     }
1593                 }
1594                 else
1595                 {
1596                     wxLogDebug(wxString(wxT("Could not open [")) +
1597                     sInfoPath + wxT("] for writing."));
1598                 }
1599             }
1600             else
1601             {
1602                 wxLogDebug(wxT("No info dictionary in main bundle"));
1603             }
1604         }
1605         else
1606         {
1607             wxLogDebug(wxT("Can only call associate from bundled app within XXX.app"));
1608         }
1609     }
1610     else
1611     {
1612         wxLogDebug(wxT("No main bundle"));
1613     }
1614
1615     if (!bInfoSuccess)
1616         return NULL;
1617
1618     // on mac you have to embed it into the mac's file reference resource ('FREF' I believe)
1619     // or, alternately, you could just add an entry to m_hDatabase, but you'd need to get
1620     // the app's signature somehow...
1621
1622     OSType processType, creator;
1623     OSStatus status = MoreProcGetProcessTypeSignature(NULL, &processType, &creator);
1624
1625     if (status == noErr)
1626     {
1627         Str255 psCreatorName;
1628 #ifndef __LP64__
1629         FSSpec dummySpec;
1630         status = FindApplication(creator, false, psCreatorName, &dummySpec);
1631 #else
1632         FSRef fsref;
1633         status = LSFindApplicationForInfo( creator, NULL, NULL, &fsref ,NULL);
1634         HFSUniStr255 name;
1635         status = FSGetCatalogInfo(&fsref, kFSCatInfoNone, NULL, &name, NULL, NULL);
1636         CFStringRef str = FSCreateStringFromHFSUniStr( 0 , &name );
1637         CFStringGetPascalString(str, psCreatorName, 256, CFStringGetSystemEncoding());
1638         CFRelease( str );
1639 #endif
1640
1641         if (status == noErr)
1642         {
1643             //get the file type if it exists -
1644             //if it really does then modify the database then save it,
1645             //otherwise we need to create a whole new entry
1646             wxFileType* pFileType = GetFileTypeFromExtension(asExtensions[dwFoundIndex]);
1647             if (pFileType)
1648             {
1649                 ICMapEntry entry;
1650                 ICGetMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase,
1651                     pFileType->m_impl->m_lIndex, &entry );
1652
1653                 memcpy(entry.creatorAppName, psCreatorName, sizeof(Str255));
1654                 entry.fileCreator = creator;
1655
1656                 status = ICSetMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase,
1657                     pFileType->m_impl->m_lIndex, &entry );
1658
1659                 //success
1660                 if (status == noErr)
1661                 {
1662                      return pFileType;
1663
1664                     //kICAttrNoChange means we don't care about attributes such as
1665                     //locking in the database
1666 //                    status = ICSetPrefHandle((ICInstance) m_hIC, kICMapping,
1667 //                                             kICAttrNoChange, (Handle) m_hDatabase);
1668 //                    if (status == noErr)
1669 //                        return pFileType;
1670 //                    else
1671 //                    {
1672 //                        wxLogDebug(wxString::Format(wxT("%i - %s"), (int)status, wxT("ICSetPrefHandle failed.")));
1673 //                    }
1674                 }
1675                 else
1676                 {
1677                     wxLogDebug(wxString::Format(wxT("%i - %s"), __LINE__, wxT("ICSetMapEntry failed.")));
1678                 }
1679
1680                 // failure - cleanup
1681                 delete pFileType;
1682             }
1683             else
1684             {
1685                 // TODO: Maybe force all 3 of these to be non-empty?
1686                 Str255 psExtension, psMimeType, psDescription;
1687
1688                 wxMacStringToPascal(wxString(wxT(".")) + ftInfo.GetExtensions()[0], psExtension);
1689                 wxMacStringToPascal(ftInfo.GetMimeType(), psMimeType);
1690                 wxMacStringToPascal(ftInfo.GetDescription(), psDescription);
1691
1692                 Str255 psPostCreatorName;
1693                 wxMacStringToPascal(wxEmptyString, psPostCreatorName);
1694
1695                 //add the entry to the database
1696                 ICMapEntry entry;
1697                 entry.totalLength = sizeof(ICMapEntry);
1698                 entry.fixedLength = kICMapFixedLength;
1699                 entry.version = 0;
1700                 entry.fileType = 0; //TODO:  File type?
1701                 entry.fileCreator = creator;
1702                 entry.postCreator = 0;
1703                 entry.flags = kICMapDataForkBit; //TODO:  Maybe resource is valid by default too?
1704                 PLstrcpy( entry.extension , psExtension ) ;
1705                 memcpy(entry.creatorAppName, psCreatorName, sizeof(Str255));
1706                 memcpy(entry.postAppName, psPostCreatorName, sizeof(Str255));
1707                 memcpy(entry.MIMEType, psMimeType, sizeof(Str255));
1708                 memcpy(entry.entryName, psDescription, sizeof(Str255));
1709
1710                 status = ICAddMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase, &entry);
1711                 if (status == noErr)
1712                 {
1713                     return GetFileTypeFromExtension(ftInfo.GetMimeType());
1714
1715 //                    kICAttrNoChange means we don't care about attributes such as
1716 //                    locking in the database
1717 //                    status = ICSetPrefHandle((ICInstance) m_hIC, kICMapping,
1718 //                                             kICAttrNoChange, (Handle) m_hDatabase);
1719
1720                     // return the entry in the database if successful
1721 //                    if (status == noErr)
1722 //                        return GetFileTypeFromExtension(ftInfo.GetMimeType());
1723 //                    else
1724 //                    {
1725 //                        wxLogDebug(wxString::Format(wxT("%i - %s"), __LINE__, wxT("ICSetPrefHandle failed.")));
1726  //                   }
1727                 }
1728                 else
1729                 {
1730                     wxLogDebug(wxString::Format(wxT("%i - %s"), __LINE__, wxT("ICAppMapEntry failed.")));
1731                 }
1732             }
1733         } // end if FindApplcation was successful
1734         else
1735         {
1736             wxLogDebug(wxString::Format(wxT("%i - %s"), __LINE__, wxT("FindApplication failed.")));
1737         }
1738     } // end if it could obtain app's signature
1739     else
1740     {
1741         wxLogDebug(wxString::Format(wxT("%i - %s"), __LINE__, wxT("GetProcessSignature failed.")));
1742     }
1743
1744     return NULL;
1745 }
1746
1747 bool
1748 wxMimeTypesManagerImpl::Unassociate(wxFileType *pFileType)
1749 {
1750     wxASSERT(pFileType);
1751     bool bInfoSuccess = false;
1752
1753     wxArrayString asExtensions;
1754     pFileType->GetExtensions(asExtensions);
1755
1756     if (!asExtensions.GetCount())
1757     {
1758         wxLogDebug(wxT("Must have extension to disassociate"));
1759         return false;
1760     }
1761
1762     // Find and write to Info.plist in main bundle (note that some other
1763     // apps have theirs named differently, i.e. IE's is named Info-macos.plist
1764     // some apps (non-wx) use the 'plst' resource instead
1765     CFBundleRef cfbMain = CFBundleGetMainBundle();
1766     if (cfbMain)
1767     {
1768         UInt32 dwBundleType, dwBundleCreator;
1769         CFBundleGetPackageInfo(cfbMain, &dwBundleType, &dwBundleCreator);
1770
1771         // if launching terminal non-app, version will be 'BNDL' (generic bundle, maybe in other cases too),
1772         // which will give us the incorrect info.plist path
1773         // otherwise it will be 'APPL', or in the case of a framework, 'FMWK'
1774         if (dwBundleType == 'APPL')
1775         {
1776
1777             wxCFURL cfurlBundleLoc((CFTypeRef)CFBundleCopyBundleURL(cfbMain));
1778 //             wxCFURL cfurlBundleLoc((CFTypeRef)CFBundleCopyExecutableURL(cfbMain));
1779             wxString sInfoPath;
1780 //            sInfoPath << wxT("file://");
1781             sInfoPath << cfurlBundleLoc.BuildWXString();
1782             sInfoPath << wxT("Contents/Info.plist");
1783
1784 //        wxCFDictionary cfdInfo( (CFTypeRef) CFBundleGetInfoDictionary(cfbMain), wxCF_RETAIN );
1785             wxCFDictionary cfdInfo;
1786             bool bInfoOpenSuccess = false;
1787             wxFile indictfile;
1788             if (indictfile.Open(sInfoPath, wxFile::read))
1789             {
1790                 CFIndex cfiBufLen = (CFIndex) indictfile.Length();
1791                 const UInt8* pBuffer = new UInt8[cfiBufLen];
1792                 indictfile.Read((void*)pBuffer, cfiBufLen);
1793                 wxCFData cfdaInDict(pBuffer, cfiBufLen);
1794                 wxString sError;
1795                 bInfoOpenSuccess = cfdInfo.ReadAsXML(cfdaInDict, &sError);
1796                 if (!bInfoOpenSuccess)
1797                     wxLogDebug(sError);
1798                 indictfile.Close();
1799             }
1800
1801             if (bInfoOpenSuccess)
1802             {
1803                 cfdInfo.MakeMutable( cfdInfo.GetCount() + 1 );
1804
1805                 wxCFArray cfaDocTypes( cfdInfo[ wxCFString(wxT("CFBundleDocumentTypes")) ], wxCF_RETAIN );
1806
1807                 if (cfaDocTypes.IsOk())
1808                 {
1809                     bool bEntryFound = false;
1810
1811                     //search for duplicate
1812                     CFIndex i;
1813                     for (i = 0; i < cfaDocTypes.GetCount(); ++i)
1814                     {
1815                         wxCFDictionary cfdDocTypeEntry( cfaDocTypes[i], wxCF_RETAIN );
1816
1817                         //A lot of apps dont do to mime types for some reason
1818                         //so we go by extensions only
1819                         wxCFArray cfaExtensions( cfdDocTypeEntry[ wxCFString(wxT("CFBundleTypeExtensions")) ],
1820                                         wxCF_RETAIN );
1821
1822                         if (!cfaExtensions.IsOk())
1823                             continue;
1824
1825                         for (CFIndex iExt = 0; iExt < cfaExtensions.GetCount(); ++iExt)
1826                         {
1827                             for (size_t iWXExt = 0; iWXExt < asExtensions.GetCount(); ++iWXExt)
1828                             {
1829                                 if (asExtensions[iWXExt] ==
1830                                     wxCFString(cfaExtensions[iExt], wxCF_RETAIN).BuildWXString())
1831                                 {
1832                                     bEntryFound = true;
1833                                     cfaDocTypes.Remove(i);
1834                                     cfdInfo.Set( wxCFString(wxT("CFBundleDocumentTypes")) , cfaDocTypes );
1835                                     break;
1836                                 }
1837                             } //end of wxstring array
1838
1839                             if (bEntryFound)
1840                                 break;
1841                         } //end for cf array
1842
1843                         if (bEntryFound)
1844                             break;
1845                     }//end for doctypes
1846
1847                     if (bEntryFound)
1848                     {
1849                         cfdInfo.MakeValidXML();
1850
1851                         wxFile outdictfile;
1852                         if (outdictfile.Open(sInfoPath, wxFile::write))
1853                         {
1854                             wxCFData cfdaInfo(cfdInfo.WriteAsXML());
1855                             if (cfdaInfo.IsOk())
1856                             {
1857                                 if (outdictfile.Write(cfdaInfo.GetValue(), cfdaInfo.GetCount()) !=
1858                                     (wxFileOffset)cfdaInfo.GetCount())
1859                                 {
1860                                     wxLogDebug(wxT("error in writing to file"));
1861                                 }
1862                                 else
1863                                 {
1864                                     bInfoSuccess = true;
1865
1866 //#if defined(__DARWIN__)
1867 //                //force launch services to update its database for the finder
1868 //                OSStatus status = LSRegisterURL((CFURLRef)(CFTypeRef)cfurlBundleLoc, true);
1869 //                if (status != noErr)
1870 //                {
1871 //                    wxLogDebug(wxT("LSRegisterURL Failed."));
1872 //                }
1873 //#endif
1874                                 }
1875                                 outdictfile.Close();
1876                             }
1877                             else
1878                             {
1879                                 outdictfile.Close();
1880                                 wxLogDebug(wxT("Could not read in new dictionary"));
1881                             }
1882                         }
1883                         else
1884                         {
1885                             wxLogDebug(
1886                                 wxString(wxT("Could not open [")) +
1887                                 sInfoPath + wxT("] for writing."));
1888                         }
1889                     }
1890                     else
1891                     {
1892                         wxLogDebug(wxT("Entry not found to remove"));
1893
1894                         wxString sPrintOut;
1895                         wxCFDictionary::PrintOutArray(sPrintOut, (CFArrayRef)(CFTypeRef)cfaDocTypes);
1896                         wxLogDebug(sPrintOut);
1897
1898                         for (size_t i = 0; i < asExtensions.GetCount(); ++i)
1899                             wxLogDebug(asExtensions[i]);
1900                     }
1901                 }
1902                 else
1903                 {
1904                     wxLogDebug(wxT("No doc types array found"));
1905                     wxString sPrintOut;  cfdInfo.PrintOut(sPrintOut);  wxLogDebug(sPrintOut);
1906                 }
1907             }
1908             else
1909             {
1910                 wxLogDebug(wxT("No info dictionary in main bundle"));
1911             }
1912         }
1913         else
1914         {
1915             wxLogDebug(wxT("Can only call associate from bundled app within XXX.app"));
1916         }
1917     }
1918     else
1919     {
1920         wxLogDebug(wxT("No main bundle"));
1921     }
1922
1923     if (!bInfoSuccess)
1924         return false;
1925
1926     // this should be as easy as removing the entry from the database
1927     // and then saving the database
1928     OSStatus status = ICDeleteMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase,
1929                             pFileType->m_impl->m_lIndex);
1930
1931     if (status == noErr)
1932     {
1933             return true;
1934
1935         //kICAttrNoChange means we don't care about attributes such as
1936         //locking in the database
1937 //        status = ICSetPrefHandle((ICInstance) m_hIC, kICMapping,
1938 //                    kICAttrNoChange, (Handle) m_hDatabase);
1939
1940 //        if (status == noErr)
1941 //        {
1942 //            return true;
1943 //        }
1944 //        else
1945 //        {
1946 //            wxLogDebug(wxString::Format(wxT("%i - %s"), __LINE__, wxT("ICSetPrefHandle failed.")));
1947 //        }
1948     }
1949     else
1950     {
1951         wxLogDebug(wxString::Format(wxT("%i - %s"), __LINE__, wxT("ICDeleteMapEntry failed.")));
1952     }
1953
1954     return false;
1955 }
1956
1957 #if 0
1958     CFWriteStreamRef cfwsInfo = CFWriteStreamCreateWithFile(
1959            kCFAllocatorDefault,
1960            (CFURLRef) (CFTypeRef)cfurlInfoLoc );
1961
1962 //     CFShow(cfdInfo);
1963         if (cfwsInfo)
1964         {
1965             Boolean bOpened = CFWriteStreamOpen(cfwsInfo);
1966             if (bOpened)
1967             {
1968                 CFStringRef cfsError;
1969                 CFIndex cfiWritten = CFPropertyListWriteToStream((CFPropertyListRef)(CFTypeRef)cfdInfo,
1970                                     cfwsInfo,
1971                                     kCFPropertyListXMLFormat_v1_0, //100
1972                                     &cfsError);
1973                 if (cfsError && cfiWritten == 0)
1974                 {
1975                     wxLogDebug(wxCFString(cfsError).BuildWXString());
1976                     wxString sMessage;
1977                     cfdInfo.PrintOut(sMessage);
1978                     wxLogDebug(sMessage);
1979                 }
1980                 else
1981                 {
1982                     bInfoSuccess = true;
1983 //#if defined(__DARWIN__)
1984 //                //force launch services to update its database for the finder
1985 //                OSStatus status = LSRegisterURL((CFURLRef)(CFTypeRef)cfurlBundleLoc, true);
1986 //                if (status != noErr)
1987 //                {
1988 //                    wxLogDebug(wxT("LSRegisterURL Failed."));
1989 //                }
1990 //#endif
1991                 }
1992
1993                 CFWriteStreamClose(cfwsInfo);
1994 #endif
1995
1996 #endif //wxUSE_MIMETYPE