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