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
 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* szMsg, OSStatus 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 WXDLLEXPORT wxIcon;
 351
 352 bool wxFileTypeImpl::SetCommand(const wxString& cmd, const wxString& verb, bool overwriteprompt)
 353 {
 354     wxASSERT_MSG( m_manager != NULL , wxT("Bad wxFileType") );
 355
 356     return false;
 357 }
 358
 359 bool wxFileTypeImpl::SetDefaultIcon(const wxString& strIcon, int 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 #if defined(__DARWIN__)
 402
 403 //on darwin, use launch services
 404 #include <ApplicationServices/ApplicationServices.h>
 405
 406 wxString wxFileTypeImpl::GetCommand(const wxString& verb) const
 407 {
 408     wxASSERT_MSG( m_manager != NULL , wxT("Bad wxFileType") );
 409
 410     if (verb == wxT("open"))
 411     {
 412         ICMapEntry entry;
 413         ICGetMapEntry( (ICInstance) m_manager->m_hIC,
 414                        (Handle) m_manager->m_hDatabase,
 415                        m_lIndex, &entry);
 416
 417         wxString sCurrentExtension = wxMacMakeStringFromPascal(entry.extension);
 418         sCurrentExtension = sCurrentExtension.Right(sCurrentExtension.length()-1 );
 419
 420         //type, creator, ext, roles, outapp (FSRef), outappurl
 421         CFURLRef cfurlAppPath;
 422         OSStatus status = LSGetApplicationForInfo( kLSUnknownType,
 423             kLSUnknownCreator,
 424             wxMacCFStringHolder(sCurrentExtension, wxLocale::GetSystemEncoding()),
 425             kLSRolesAll,
 426             NULL,
 427             &cfurlAppPath );
 428
 429         if (status == noErr)
 430         {
 431             CFStringRef cfsUnixPath = CFURLCopyFileSystemPath(cfurlAppPath, kCFURLPOSIXPathStyle);
 432             CFRelease(cfurlAppPath);
 433
 434             // PHEW!  Success!
 435             // Since a filename might have spaces in it, so surround it with quotes
 436             if (cfsUnixPath)
 437             {
 438                 wxString resultStr;
 439
 440                 resultStr =
 441                     wxString(wxT("'"))
 442                     + wxMacCFStringHolder(cfsUnixPath).AsString(wxLocale::GetSystemEncoding())
 443                     + wxString(wxT("'"));
 444
 445                return resultStr;
 446             }
 447         }
 448         else
 449         {
 450             wxLogDebug(wxString::Format(wxT("%i - %s - %i"),
 451             __LINE__,
 452             wxT("LSGetApplicationForInfo failed."),
 453             (int)status));
 454         }
 455     }
 456
 457     return wxEmptyString;
 458 }
 459
 460 #else //carbon/classic implementation
 461
 462
 463 wxString wxFileTypeImpl::GetCommand(const wxString& verb) const
 464 {
 465     wxASSERT_MSG( m_manager != NULL , wxT("Bad wxFileType") );
 466
 467     if (verb == wxT("open"))
 468     {
 469         ICMapEntry entry;
 470         ICGetMapEntry( (ICInstance) m_manager->m_hIC,
 471                        (Handle) m_manager->m_hDatabase,
 472                        m_lIndex, &entry);
 473
 474         //The entry in the mimetype database only contains the app
 475         //that's registered - it may not exist... we need to remap the creator
 476         //type and find the right application
 477
 478         // THIS IS REALLY COMPLICATED :\.
 479         // There are a lot of conversions going on here.
 480         Str255 outName;
 481         FSSpec outSpec;
 482         OSErr err = FindApplication( entry.fileCreator, false, outName, &outSpec );
 483         if (err != noErr)
 484             return wxEmptyString;
 485
 486         Handle outPathHandle;
 487         short outPathSize;
 488         err = FSpGetFullPath( &outSpec, &outPathSize, &outPathHandle );
 489         if (err == noErr)
 490         {
 491             char* szPath = *outPathHandle;
 492             wxString sClassicPath(szPath, wxConvLocal, outPathSize);
 493
 494 #if defined(__DARWIN__)
 495             // Classic Path --> Unix (OSX) Path
 496             CFURLRef finalURL = CFURLCreateWithFileSystemPath(
 497                 kCFAllocatorDefault,
 498                 wxMacCFStringHolder(sClassicPath, wxLocale::GetSystemEncoding()),
 499                 kCFURLHFSPathStyle,
 500                 false ); //false == not a directory
 501
 502             //clean up memory from the classic path handle
 503             DisposeHandle( outPathHandle );
 504
 505             if (finalURL)
 506             {
 507                 CFStringRef cfsUnixPath = CFURLCopyFileSystemPath(finalURL, kCFURLPOSIXPathStyle);
 508                 CFRelease(finalURL);
 509
 510                 // PHEW!  Success!
 511                 if (cfsUnixPath)
 512                     return wxMacCFStringHolder(cfsUnixPath).AsString(wxLocale::GetSystemEncoding());
 513             }
 514 #else //classic HFS path acceptable
 515             return sClassicPath;
 516 #endif
 517         }
 518         else
 519         {
 520             wxLogMimeDebug(wxT("FSpGetFullPath failed."), (OSStatus)err);
 521         }
 522     }
 523
 524     return wxEmptyString;
 525 }
 526 #endif //!DARWIN
 527
 528 bool wxFileTypeImpl::GetDescription(wxString *desc) const
 529 {
 530     wxASSERT_MSG( m_manager != NULL , wxT("Bad wxFileType") );
 531
 532     ICMapEntry entry;
 533     ICGetMapEntry( (ICInstance) m_manager->m_hIC,
 534         (Handle) m_manager->m_hDatabase, m_lIndex, &entry );
 535
 536     *desc = wxMacMakeStringFromPascal( entry.entryName );
 537
 538     return true;
 539 }
 540
 541 bool wxFileTypeImpl::GetExtensions(wxArrayString& extensions)
 542 {
 543     wxASSERT_MSG( m_manager != NULL , wxT("Bad wxFileType") );
 544
 545     ICMapEntry entry;
 546     ICGetMapEntry( (ICInstance) m_manager->m_hIC,
 547         (Handle) m_manager->m_hDatabase, m_lIndex, &entry );
 548
 549     //entry has period in it
 550     wxString sCurrentExtension = wxMacMakeStringFromPascal( entry.extension );
 551     extensions.Add( sCurrentExtension.Right( sCurrentExtension.length() - 1 ) );
 552
 553     return true;
 554 }
 555
 556 bool wxFileTypeImpl::GetMimeType(wxString *mimeType) const
 557 {
 558     wxASSERT_MSG( m_manager != NULL , wxT("Bad wxFileType") );
 559
 560     ICMapEntry entry;
 561     ICGetMapEntry( (ICInstance) m_manager->m_hIC,
 562         (Handle) m_manager->m_hDatabase, m_lIndex, &entry );
 563
 564     *mimeType = wxMacMakeStringFromPascal(entry.MIMEType);
 565
 566     return true;
 567 }
 568
 569 bool wxFileTypeImpl::GetMimeTypes(wxArrayString& mimeTypes) const
 570 {
 571     wxString s;
 572
 573     if (GetMimeType(&s))
 574     {
 575         mimeTypes.Clear();
 576         mimeTypes.Add(s);
 577
 578         return true;
 579     }
 580
 581     return false;
 582 }
 583
 584 bool wxFileTypeImpl::GetIcon(wxIconLocation *WXUNUSED(icon)) const
 585 {
 586     wxASSERT_MSG( m_manager != NULL , wxT("Bad wxFileType") );
 587
 588     // no such file type or no value or incorrect icon entry
 589     return false;
 590 }
 591
 592 size_t wxFileTypeImpl::GetAllCommands(wxArrayString * verbs,
 593     wxArrayString * commands,
 594     const wxFileType::MessageParameters& params) const
 595 {
 596     wxASSERT_MSG( m_manager != NULL , wxT("Bad wxFileType") );
 597
 598     wxString sCommand;
 599     size_t ulCount = 0;
 600
 601     if (GetOpenCommand(&sCommand, params))
 602     {
 603         verbs->Add(wxString(wxT("open")));
 604         commands->Add(sCommand);
 605         ++ulCount;
 606     }
 607
 608     return ulCount;
 609 }
 610
 611 void wxMimeTypesManagerImpl::Initialize(int mailcapStyles, const wxString& extraDir)
 612 {
 613     wxASSERT_MSG(m_hIC == NULL, wxT("Already initialized wxMimeTypesManager!"));
 614
 615     // some apps (non-wx) use the 'plst' resource instead
 616 #if 0
 617     CFBundleRef cfbMain = CFBundleGetMainBundle();
 618     wxCFDictionary cfdInfo( CFBundleGetInfoDictionary(cfbMain), wxCF_RETAIN );
 619     wxString sLog;
 620     cfdInfo.PrintOut(sLog);
 621     wxLogDebug(sLog);
 622 #endif
 623
 624     // start Internet Config - log if there's an error
 625     // the second param is the signature of the application, also known
 626     // as resource ID 0.  However, as per some recent discussions, we may not
 627     // have a signature for this app, so a generic 'APPL' which is the executable
 628     // type will work for now.
 629     OSStatus status = ICStart( (ICInstance*)&m_hIC, 'APPL' );
 630
 631     if (status != noErr)
 632     {
 633         wxLogDebug(wxT("Could not initialize wxMimeTypesManager!"));
 634         wxFAIL;
 635         m_hIC = NULL;
 636
 637         return;
 638     }
 639
 640     ICAttr attr;
 641     m_hDatabase = (void**) NewHandle(0);
 642     status = ICFindPrefHandle( (ICInstance) m_hIC, kICMapping, &attr, (Handle) m_hDatabase );
 643
 644     //the database file can be corrupt (on OSX its
 645     //~/Library/Preferences/com.apple.internetconfig.plist)
 646     //- bail if it is
 647     if (status != noErr)
 648     {
 649         ClearData();
 650         wxLogDebug(wxT("Corrupt MIME database!"));
 651         return;
 652     }
 653
 654     //obtain the number of entries in the map
 655     status = ICCountMapEntries( (ICInstance) m_hIC, (Handle) m_hDatabase, &m_lCount );
 656     wxASSERT( status == noErr );
 657
 658 #if 0
 659     //debug stuff
 660     ICMapEntry entry;
 661     long pos;
 662
 663     for (long i = 1; i <= m_lCount; ++i)
 664     {
 665         OSStatus status = ICGetIndMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase, i, &pos, &entry );
 666
 667         if (status == noErr)
 668         {
 669             wxString sCreator = wxMacMakeStringFromPascal(entry.creatorAppName);
 670             wxString sCurrentExtension = wxMacMakeStringFromPascal(entry.extension);
 671             wxString sMIMEType = wxMacMakeStringFromPascal(entry.MIMEType);
 672
 673             wxFileTypeImpl impl;
 674             impl.Init(this, pos);
 675
 676             if (sMIMEType == wxT("text/html") && sCurrentExtension == wxT(".html"))
 677             {
 678                 wxString cmd;
 679
 680                 impl.GetOpenCommand( &cmd, wxFileType::MessageParameters (wxT("http://www.google.com")));
 681                 wxPrintf(wxT("APP: [%s]\n"), cmd.c_str());
 682             }
 683         }
 684     }
 685 #endif
 686 }
 687
 688 void wxMimeTypesManagerImpl::ClearData()
 689 {
 690     if (m_hIC != NULL)
 691     {
 692         DisposeHandle( (Handle)m_hDatabase );
 693
 694         // this can return an error, but we don't really care that much about it
 695         ICStop( (ICInstance)m_hIC );
 696         m_hIC = NULL;
 697     }
 698 }
 699
 700 //
 701 //  Q) Iterating through the map - why does it use if (err == noErr) instead of just asserting?
 702 //  A) Some intermediate indexes are bad while subsequent ones may be good.  Its wierd, I know.
 703 //
 704
 705 // extension -> file type
 706 wxFileType* wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& e)
 707 {
 708     wxASSERT_MSG( m_hIC != NULL, wxT("wxMimeTypesManager not Initialized!") );
 709
 710     //low level functions - iterate through the database
 711     ICMapEntry entry;
 712     long pos;
 713
 714     for (long i = 1; i <= m_lCount; ++i)
 715     {
 716         OSStatus status = ICGetIndMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase, i, &pos, &entry );
 717
 718         if (status == noErr)
 719         {
 720             wxString sCurrentExtension = wxMacMakeStringFromPascal(entry.extension);
 721             if ( sCurrentExtension.Right(sCurrentExtension.length() - 1) == e ) // entry has period in it
 722             {
 723                 wxFileType* pFileType = new wxFileType();
 724                 pFileType->m_impl->Init((wxMimeTypesManagerImpl*)this, pos);
 725
 726                 return pFileType;
 727             }
 728         }
 729     }
 730
 731     return NULL;
 732 }
 733
 734 // MIME type -> extension -> file type
 735 wxFileType* wxMimeTypesManagerImpl::GetFileTypeFromMimeType(const wxString& mimeType)
 736 {
 737     wxASSERT_MSG( m_hIC != NULL, wxT("wxMimeTypesManager not Initialized!") );
 738
 739     ICMapEntry entry;
 740     long pos;
 741
 742     // low level functions - iterate through the database
 743     for (long i = 1; i <= m_lCount; ++i)
 744     {
 745         OSStatus status = ICGetIndMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase, i, &pos, &entry );
 746         wxASSERT_MSG( status == noErr, wxString::Format(wxT("Error: %d"), (int)status) );
 747
 748         if (status == noErr)
 749         {
 750             if ( wxMacMakeStringFromPascal(entry.MIMEType) == mimeType)
 751             {
 752                 wxFileType* pFileType = new wxFileType();
 753                 pFileType->m_impl->Init((wxMimeTypesManagerImpl*)this, pos);
 754
 755                 return pFileType;
 756             }
 757         }
 758     }
 759
 760     return NULL;
 761 }
 762
 763 size_t wxMimeTypesManagerImpl::EnumAllFileTypes(wxArrayString& mimetypes)
 764 {
 765     wxASSERT_MSG( m_hIC != NULL, wxT("wxMimeTypesManager not Initialized!") );
 766
 767     ICMapEntry entry;
 768     long pos, lStartCount;
 769
 770     // low level functions - iterate through the database
 771     lStartCount = (long) mimetypes.GetCount();
 772     for (long i = 1; i <= m_lCount; ++i)
 773     {
 774         OSStatus status = ICGetIndMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase, i, &pos, &entry );
 775         if ( status == noErr )
 776             mimetypes.Add( wxMacMakeStringFromPascal(entry.MIMEType) );
 777     }
 778
 779     return mimetypes.GetCount() - lStartCount;
 780 }
 781
 782 pascal  OSStatus  MoreProcGetProcessTypeSignature(
 783     const ProcessSerialNumberPtr pPSN,
 784     OSType *pProcessType,
 785     OSType *pCreator)
 786 {
 787     OSStatus anErr = noErr;
 788     ProcessInfoRec infoRec;
 789     ProcessSerialNumber localPSN;
 790
 791     infoRec.processInfoLength = sizeof(ProcessInfoRec);
 792     infoRec.processName = NULL;
 793 #ifndef __LP64__
 794     infoRec.processAppSpec = NULL;
 795 #endif
 796
 797     if ( pPSN == NULL )
 798     {
 799         localPSN.highLongOfPSN = 0;
 800         localPSN.lowLongOfPSN  = kCurrentProcess;
 801     }
 802     else
 803     {
 804         localPSN = *pPSN;
 805     }
 806
 807     anErr = GetProcessInformation(&localPSN, &infoRec);
 808     if (anErr == noErr)
 809     {
 810         *pProcessType = infoRec.processType;
 811         *pCreator = infoRec.processSignature;
 812     }
 813
 814     return anErr;
 815 }
 816
 817 //
 818 //
 819 //  TODO: clean this up, its messy
 820 //
 821 //
 822 //
 823
 824 #include "wx/mac/corefoundation/cfstring.h"
 825
 826 #define wxCF_RELEASE true
 827 #define wxCF_RETAIN  false
 828
 829 // ----------------------------------------------------------------------------
 830 // wxCFDictionary
 831 // ----------------------------------------------------------------------------
 832
 833 class wxCFDictionary
 834 {
 835 public:
 836     wxCFDictionary(CFTypeRef ref, bool bRetain = wxCF_RELEASE)
 837     {
 838         m_cfmdRef = (CFMutableDictionaryRef) ref;
 839         if (bRetain == wxCF_RETAIN && ref)
 840             CFRetain(ref);
 841     }
 842
 843     wxCFDictionary(CFIndex cfiSize = 0)
 844     {
 845         CFDictionaryKeyCallBacks kcbs;
 846         CFDictionaryValueCallBacks vcbs;
 847         BuildKeyCallbacks(&kcbs);
 848         BuildValueCallbacks(&vcbs);
 849
 850         m_cfmdRef = CFDictionaryCreateMutable(
 851             kCFAllocatorDefault, cfiSize, &kcbs, &vcbs );
 852     }
 853
 854     ~wxCFDictionary()
 855     { Clear(); }
 856
 857     void Clear()
 858     {
 859         if (m_cfmdRef)
 860             CFRelease(m_cfmdRef);
 861     }
 862
 863     static const void* RetainProc(CFAllocatorRef, const void* v)
 864     { return (const void*) CFRetain(v); }
 865
 866     static void ReleaseProc(CFAllocatorRef, const void* v)
 867     { CFRelease(v); }
 868
 869     void MakeMutable(CFIndex cfiSize = 0)
 870     {
 871         CFDictionaryRef oldref = (CFDictionaryRef) m_cfmdRef;
 872
 873         m_cfmdRef = CFDictionaryCreateMutableCopy(
 874             kCFAllocatorDefault, cfiSize, oldref );
 875
 876         CFRelease( oldref );
 877     }
 878
 879     void BuildKeyCallbacks(CFDictionaryKeyCallBacks* pCbs)
 880     {
 881         pCbs->version = 0;
 882         pCbs->retain = RetainProc;
 883         pCbs->release = ReleaseProc;
 884         pCbs->copyDescription = NULL;
 885         pCbs->equal = NULL;
 886         pCbs->hash = NULL;
 887     }
 888
 889     void BuildValueCallbacks(CFDictionaryValueCallBacks* pCbs)
 890     {
 891         pCbs->version = 0;
 892         pCbs->retain = RetainProc;
 893         pCbs->release = ReleaseProc;
 894         pCbs->copyDescription = NULL;
 895         pCbs->equal = NULL;
 896     }
 897
 898     operator CFTypeRef () const
 899     { return (CFTypeRef)m_cfmdRef; }
 900
 901     CFDictionaryRef GetCFDictionary() const
 902     { return (CFDictionaryRef)m_cfmdRef; }
 903
 904     CFMutableDictionaryRef GetCFMutableDictionary()
 905     { return (CFMutableDictionaryRef) m_cfmdRef; }
 906
 907     CFTypeRef operator [] (CFTypeRef cftEntry) const
 908     {
 909         wxASSERT(IsValid());
 910         return (CFTypeRef) CFDictionaryGetValue((CFDictionaryRef)m_cfmdRef, cftEntry);
 911     }
 912
 913     CFIndex GetCount() const
 914     {
 915         wxASSERT(IsValid());
 916         return CFDictionaryGetCount((CFDictionaryRef)m_cfmdRef);
 917     }
 918
 919     void Add(CFTypeRef cftKey, CFTypeRef cftValue)
 920     {
 921         wxASSERT(IsValid());
 922         wxASSERT(Exists(cftKey) == false);
 923         CFDictionaryAddValue(m_cfmdRef, cftKey, cftValue);
 924     }
 925
 926     void Remove(CFTypeRef cftKey)
 927     {
 928         wxASSERT(IsValid());
 929         wxASSERT(Exists(cftKey));
 930         CFDictionaryRemoveValue(m_cfmdRef, cftKey);
 931     }
 932
 933     void Set(CFTypeRef cftKey, CFTypeRef cftValue)
 934     {
 935         wxASSERT(IsValid());
 936         wxASSERT(Exists(cftKey));
 937         CFDictionarySetValue(m_cfmdRef, cftKey, cftValue);
 938     }
 939
 940     bool Exists(CFTypeRef cftKey) const
 941     {
 942         wxASSERT(IsValid());
 943         return CFDictionaryContainsKey((CFDictionaryRef)m_cfmdRef, cftKey);
 944     }
 945
 946     bool IsOk() const
 947     { return m_cfmdRef != NULL; }
 948
 949     bool IsValid() const
 950     { return IsOk() && CFGetTypeID((CFTypeRef)m_cfmdRef) == CFDictionaryGetTypeID(); }
 951
 952     void PrintOut(wxString& sMessage)
 953     {
 954         PrintOutDictionary(sMessage, m_cfmdRef);
 955     }
 956
 957     static void PrintOutDictionary(wxString& sMessage, CFDictionaryRef cfdRef)
 958     {
 959         CFIndex cfiCount = CFDictionaryGetCount(cfdRef);
 960         CFTypeRef* pKeys = new CFTypeRef[cfiCount];
 961         CFTypeRef* pValues = new CFTypeRef[cfiCount];
 962
 963         CFDictionaryGetKeysAndValues(cfdRef, pKeys, pValues);
 964
 965         for (CFIndex i = 0; i < cfiCount; ++i)
 966         {
 967             wxString sKey = wxMacCFStringHolder(CFCopyTypeIDDescription(CFGetTypeID(pKeys[i]))).AsString();
 968             wxString sValue = wxMacCFStringHolder(CFCopyTypeIDDescription(CFGetTypeID(pValues[i]))).AsString();
 969
 970             sMessage <<
 971                 wxString::Format(wxT("[{#%d} Key : %s]"), (int) i,
 972                         sKey.c_str());
 973
 974             PrintOutType(sMessage, sKey, pKeys[i]);
 975
 976             sMessage <<
 977                 wxString::Format(wxT("\n\t[Value : %s]"),
 978                         sValue.c_str());
 979
 980             PrintOutType(sMessage, sValue, pValues[i]);
 981
 982             sMessage << wxT("\n");
 983         }
 984
 985         delete [] pKeys;
 986         delete [] pValues;
 987     }
 988
 989     static void PrintOutArray(wxString& sMessage, CFArrayRef cfaRef)
 990     {
 991         for (CFIndex i = 0; i < CFArrayGetCount(cfaRef); ++i)
 992         {
 993             wxString sValue = wxMacCFStringHolder(CFCopyTypeIDDescription(CFGetTypeID(
 994                 CFArrayGetValueAtIndex(cfaRef, i)
 995                 ))).AsString();
 996
 997             sMessage <<
 998                 wxString::Format(wxT("\t\t[{#%d} ArrayValue : %s]\n"), (int) i,
 999                         sValue.c_str());
1000
1001             PrintOutType(sMessage, sValue, CFArrayGetValueAtIndex(cfaRef, i));
1002         }
1003     }
1004
1005     static void PrintOutType(wxString& sMessage, const wxString& sValue, CFTypeRef cfRef)
1006     {
1007             sMessage << wxT(" {");
1008
1009             if (sValue == wxT("CFString"))
1010             {
1011                  sMessage << wxMacCFStringHolder((CFStringRef)cfRef, false).AsString();
1012             }
1013             else if (sValue == wxT("CFNumber"))
1014             {
1015                 int nOut;
1016                 CFNumberGetValue((CFNumberRef)cfRef, kCFNumberIntType, &nOut);
1017                 sMessage << nOut;
1018             }
1019             else if (sValue == wxT("CFDictionary"))
1020             {
1021                 PrintOutDictionary(sMessage, (CFDictionaryRef)cfRef);
1022             }
1023             else if (sValue == wxT("CFArray"))
1024             {
1025                 PrintOutArray(sMessage, (CFArrayRef)cfRef);
1026             }
1027             else if (sValue == wxT("CFBoolean"))
1028             {
1029                 sMessage << (cfRef == kCFBooleanTrue ? wxT("true") : wxT("false"));
1030             }
1031             else if (sValue == wxT("CFURL"))
1032             {
1033                 sMessage << wxMacCFStringHolder(CFURLCopyPath((CFURLRef) cfRef)).AsString();
1034             }
1035             else
1036             {
1037                 sMessage << wxT("*****UNKNOWN TYPE******");
1038             }
1039
1040             sMessage << wxT("} ");
1041     }
1042
1043 #if wxUSE_MIMETYPE
1044     void MakeValidXML();
1045 #endif
1046
1047     CFTypeRef WriteAsXML()
1048     {
1049         return CFPropertyListCreateXMLData(kCFAllocatorDefault, m_cfmdRef);
1050     }
1051
1052     bool ReadAsXML(CFTypeRef cfData, wxString* pErrorMsg = NULL)
1053     {
1054         Clear();
1055         CFStringRef cfsError=NULL;
1056         m_cfmdRef = (CFMutableDictionaryRef) CFPropertyListCreateFromXMLData(
1057                     kCFAllocatorDefault,
1058                     (CFDataRef)cfData,
1059                     kCFPropertyListMutableContainersAndLeaves,
1060                     &cfsError );
1061         if (cfsError)
1062         {
1063             if (pErrorMsg)
1064                 *pErrorMsg = wxMacCFStringHolder(cfsError).AsString();
1065             else
1066                 CFRelease(cfsError);
1067         }
1068
1069         return m_cfmdRef != NULL;
1070     }
1071
1072 private:
1073     CFMutableDictionaryRef m_cfmdRef;
1074 };
1075
1076 // ----------------------------------------------------------------------------
1077 // wxCFArray
1078 // ----------------------------------------------------------------------------
1079
1080 class wxCFArray
1081 {
1082 public:
1083     wxCFArray(CFTypeRef ref, bool bRetain = wxCF_RELEASE)
1084     {
1085         m_cfmaRef = (CFMutableArrayRef)ref;
1086         if (bRetain == wxCF_RETAIN && ref)
1087             CFRetain(ref);
1088     }
1089
1090     wxCFArray(CFIndex cfiSize = 0) : m_cfmaRef(NULL)
1091     { Create(cfiSize); }
1092
1093     ~wxCFArray()
1094     { Clear(); }
1095
1096     void MakeMutable(CFIndex cfiSize = 0)
1097     {
1098         wxASSERT(IsValid());
1099
1100         CFMutableArrayRef oldref = m_cfmaRef;
1101         m_cfmaRef = CFArrayCreateMutableCopy(
1102                 kCFAllocatorDefault,
1103                 cfiSize,
1104                 (CFArrayRef)oldref);
1105         CFRelease(oldref);
1106     }
1107
1108     void BuildCallbacks(CFArrayCallBacks* pCbs)
1109     {
1110         pCbs->version = 0;
1111         pCbs->retain = RetainProc;
1112         pCbs->release = ReleaseProc;
1113         pCbs->copyDescription = NULL;
1114         pCbs->equal = NULL;
1115     }
1116
1117     void Create(CFIndex cfiSize = 0)
1118     {
1119         Clear();
1120         CFArrayCallBacks cb;
1121         BuildCallbacks(&cb);
1122
1123         m_cfmaRef = CFArrayCreateMutable(kCFAllocatorDefault, cfiSize, &cb);
1124     }
1125
1126     void Clear()
1127     { if (m_cfmaRef) CFRelease(m_cfmaRef); }
1128
1129     static const void* RetainProc(CFAllocatorRef, const void* v)
1130     { return (const void*) CFRetain(v); }
1131
1132     static void ReleaseProc(CFAllocatorRef, const void* v)
1133     { CFRelease(v); }
1134
1135     operator CFTypeRef () const
1136     { return (CFTypeRef)m_cfmaRef; }
1137
1138     CFArrayRef GetCFArray() const
1139     { return (CFArrayRef)m_cfmaRef; }
1140
1141     CFMutableArrayRef GetCFMutableArray()
1142     { return (CFMutableArrayRef) m_cfmaRef; }
1143
1144     CFTypeRef operator [] (CFIndex cfiIndex) const
1145     {
1146         wxASSERT(IsValid());
1147         return (CFTypeRef) CFArrayGetValueAtIndex((CFArrayRef)m_cfmaRef, cfiIndex);
1148     }
1149
1150     CFIndex GetCount()
1151     {
1152         wxASSERT(IsValid());
1153         return CFArrayGetCount((CFArrayRef)m_cfmaRef);
1154     }
1155
1156     void Add(CFTypeRef cftValue)
1157     {
1158         wxASSERT(IsValid());
1159         CFArrayAppendValue(m_cfmaRef, cftValue);
1160     }
1161
1162     void Remove(CFIndex cfiIndex)
1163     {
1164         wxASSERT(IsValid());
1165         wxASSERT(cfiIndex < GetCount());
1166         CFArrayRemoveValueAtIndex(m_cfmaRef, cfiIndex);
1167     }
1168
1169     void Set(CFIndex cfiIndex, CFTypeRef cftValue)
1170     {
1171         wxASSERT(IsValid());
1172         wxASSERT(cfiIndex < GetCount());
1173         CFArraySetValueAtIndex(m_cfmaRef, cfiIndex, cftValue);
1174     }
1175
1176     bool IsOk() const
1177     { return m_cfmaRef != NULL; }
1178
1179     bool IsValid() const
1180     {
1181         return IsOk() && CFGetTypeID((CFTypeRef)m_cfmaRef) == CFArrayGetTypeID();
1182     }
1183
1184 #if wxUSE_MIMETYPE
1185     void MakeValidXML();
1186 #endif
1187
1188 private:
1189     CFMutableArrayRef m_cfmaRef;
1190 };
1191
1192 // ----------------------------------------------------------------------------
1193 // wxCFString
1194 // ----------------------------------------------------------------------------
1195
1196 class wxCFString
1197 {
1198 public:
1199     wxCFString(CFTypeRef ref, bool bRetain = wxCF_RELEASE) : m_Holder((CFStringRef)ref, bRetain == wxCF_RELEASE)
1200     {}
1201
1202     wxCFString(const wxChar* szString) : m_Holder(wxString(szString), wxLocale::GetSystemEncoding())
1203     {}
1204
1205     wxCFString(const wxString& sString) : m_Holder(sString, wxLocale::GetSystemEncoding())
1206     {}
1207
1208     virtual ~wxCFString() {}
1209
1210     operator CFTypeRef() const
1211     { return (CFTypeRef) ((CFStringRef) m_Holder); }
1212
1213     bool IsOk()
1214     { return ((CFTypeRef)(*this)) != NULL; }
1215
1216     wxString BuildWXString()
1217     { return m_Holder.AsString(); }
1218
1219 private:
1220     wxMacCFStringHolder m_Holder;
1221 };
1222
1223 // ----------------------------------------------------------------------------
1224 // wxCFNumber
1225 // ----------------------------------------------------------------------------
1226
1227 class wxCFNumber
1228 {
1229 public:
1230     wxCFNumber(int nValue)
1231     {
1232         m_cfnRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &nValue);
1233     }
1234
1235     wxCFNumber(CFTypeRef ref, bool bRetain = wxCF_RELEASE) : m_cfnRef((CFNumberRef)ref)
1236     {
1237         if (bRetain == wxCF_RETAIN && ref)
1238             CFRetain(ref);
1239     }
1240
1241     virtual ~wxCFNumber()
1242     {
1243         if (m_cfnRef)
1244             CFRelease(m_cfnRef);
1245     }
1246
1247     operator CFTypeRef() const
1248     { return (CFTypeRef) m_cfnRef; }
1249
1250     int GetValue()
1251     {
1252         int nOut;
1253         CFNumberGetValue( m_cfnRef, kCFNumberIntType, &nOut );
1254
1255         return nOut;
1256     }
1257
1258     bool IsOk()
1259     { return m_cfnRef != NULL; }
1260
1261 private:
1262     CFNumberRef m_cfnRef;
1263 };
1264
1265 // ----------------------------------------------------------------------------
1266 // wxCFURL
1267 // ----------------------------------------------------------------------------
1268
1269 class wxCFURL
1270 {
1271 public:
1272     wxCFURL(CFTypeRef ref = NULL, bool bRetain = wxCF_RELEASE) : m_cfurlRef((CFURLRef)ref)
1273     {
1274         if (bRetain == wxCF_RETAIN && ref)
1275             CFRetain(ref);
1276     }
1277
1278     wxCFURL(const wxCFString& URLString, CFTypeRef BaseURL = NULL)
1279     {
1280         Create(URLString, BaseURL);
1281     }
1282
1283     void Create(const wxCFString& URLString, CFTypeRef BaseURL = NULL)
1284     {
1285         m_cfurlRef = CFURLCreateWithString(
1286             kCFAllocatorDefault,
1287             (CFStringRef)(CFTypeRef)URLString,
1288             (CFURLRef) BaseURL);
1289     }
1290
1291     virtual ~wxCFURL()
1292     {
1293         if (m_cfurlRef)
1294             CFRelease(m_cfurlRef);
1295     }
1296
1297     wxString BuildWXString()
1298     {
1299         return wxCFString(CFURLCopyPath(m_cfurlRef)).BuildWXString();
1300     }
1301
1302     operator CFTypeRef() const
1303     { return (CFTypeRef)m_cfurlRef; }
1304
1305     bool IsOk()
1306     { return m_cfurlRef != NULL; }
1307
1308 private:
1309     CFURLRef m_cfurlRef;
1310 };
1311
1312 // ----------------------------------------------------------------------------
1313 // wxCFData
1314 // ----------------------------------------------------------------------------
1315
1316 #define wxCFDATA_RELEASEBUFFER  1
1317
1318 class wxCFData
1319 {
1320 public:
1321     wxCFData(CFTypeRef ref, bool bRetain = wxCF_RELEASE) : m_cfdaRef((CFDataRef)ref)
1322     {
1323         if (bRetain == wxCF_RETAIN && ref)
1324             CFRetain(ref);
1325     }
1326
1327     wxCFData(const UInt8* pBytes, CFIndex len, bool bKeep = wxCFDATA_RELEASEBUFFER)
1328     {
1329         if (bKeep == wxCFDATA_RELEASEBUFFER)
1330         {
1331             m_cfdaRef = CFDataCreateWithBytesNoCopy
1332                             (kCFAllocatorDefault, pBytes, len, kCFAllocatorDefault);
1333         }
1334         else
1335         {
1336             m_cfdaRef = CFDataCreate(kCFAllocatorDefault, pBytes, len);
1337         }
1338     }
1339
1340     virtual ~wxCFData()
1341     {
1342         if (m_cfdaRef)
1343             CFRelease(m_cfdaRef);
1344     }
1345
1346     const UInt8* GetValue()
1347     { return CFDataGetBytePtr(m_cfdaRef); }
1348
1349     CFIndex GetCount()
1350     { return CFDataGetLength(m_cfdaRef); }
1351
1352     operator CFTypeRef() const
1353     { return (CFTypeRef)m_cfdaRef; }
1354
1355     bool IsOk()
1356     { return m_cfdaRef != NULL; }
1357
1358 private:
1359     CFDataRef m_cfdaRef;
1360 };
1361
1362 void wxCFDictionary::MakeValidXML()
1363 {
1364         CFIndex cfiCount = GetCount();
1365         CFTypeRef* pKeys = new CFTypeRef[cfiCount];
1366         CFTypeRef* pValues = new CFTypeRef[cfiCount];
1367
1368         CFDictionaryGetKeysAndValues(m_cfmdRef, pKeys, pValues);
1369
1370         // for plist xml format, all dictionary keys must be cfstrings and
1371         // no values in the dictionary or subkeys/values can be NULL;
1372         // additionally, CFURLs are not allowed
1373         for (CFIndex i = 0; i < cfiCount; ++i)
1374         {
1375             // must be an array, dictionary, string, bool, or int and cannot be null
1376             // and dictionaries can only contain cfstring keys
1377             CFTypeRef cfRef = pValues[i];
1378             if (!pKeys[i] ||
1379                 CFGetTypeID(pKeys[i]) != CFStringGetTypeID() ||
1380                 !cfRef)
1381             {
1382                 Remove(pKeys[i]);
1383                 --i;
1384                 --cfiCount;
1385                 delete [] pKeys;
1386                 delete [] pValues;
1387                 pKeys = new CFTypeRef[cfiCount];
1388                 pValues = new CFTypeRef[cfiCount];
1389                 CFDictionaryGetKeysAndValues(m_cfmdRef, pKeys, pValues);
1390             }
1391             else if (CFGetTypeID(cfRef) == CFArrayGetTypeID())
1392             {
1393                 CFRetain(cfRef);
1394                 wxCFArray cfaCurrent(cfRef);
1395                 cfaCurrent.MakeMutable();
1396                 cfaCurrent.MakeValidXML();
1397                 Set(pKeys[i], cfaCurrent);
1398             }
1399             else if (CFGetTypeID(cfRef) == CFDictionaryGetTypeID())
1400             {
1401                 CFRetain(cfRef);
1402                 wxCFDictionary cfdCurrent(cfRef);
1403                 cfdCurrent.MakeMutable();
1404                 cfdCurrent.MakeValidXML();
1405                 Set(pKeys[i], cfdCurrent);
1406             }
1407             else if ( CFGetTypeID(cfRef) != CFStringGetTypeID() &&
1408                       CFGetTypeID(cfRef) != CFNumberGetTypeID() &&
1409                       CFGetTypeID(cfRef) != CFBooleanGetTypeID() )
1410             {
1411                 Remove(pKeys[i]);
1412                 --i;
1413                 --cfiCount;
1414                 delete [] pKeys;
1415                 delete [] pValues;
1416                 pKeys = new CFTypeRef[cfiCount];
1417                 pValues = new CFTypeRef[cfiCount];
1418                 CFDictionaryGetKeysAndValues(m_cfmdRef, pKeys, pValues);
1419             }
1420         }
1421
1422         delete [] pValues;
1423         delete [] pKeys;
1424 }
1425
1426 void wxCFArray::MakeValidXML()
1427 {
1428         for (CFIndex i = 0; i < GetCount(); ++i)
1429         {
1430             //must be an array, dictionary, string, bool, or int and cannot be null
1431             //and dictionaries can only contain cfstring keys
1432             CFTypeRef cfRef = (*this)[i];
1433             if (!cfRef)
1434             {
1435                 Remove(i);
1436                 --i;
1437             }
1438             else if (CFGetTypeID(cfRef) == CFArrayGetTypeID())
1439             {
1440                 CFRetain(cfRef);
1441                 wxCFArray cfaCurrent(cfRef);
1442                 cfaCurrent.MakeMutable();
1443                 cfaCurrent.MakeValidXML();
1444                 Set(i, cfaCurrent);
1445             }
1446             else if (CFGetTypeID(cfRef) == CFDictionaryGetTypeID())
1447             {
1448                 CFRetain(cfRef);
1449                 wxCFDictionary cfdCurrent(cfRef);
1450                 cfdCurrent.MakeMutable();
1451                 cfdCurrent.MakeValidXML();
1452                 Set(i, cfdCurrent);
1453             }
1454             else if ( CFGetTypeID(cfRef) != CFStringGetTypeID() &&
1455                       CFGetTypeID(cfRef) != CFNumberGetTypeID() &&
1456                       CFGetTypeID(cfRef) != CFBooleanGetTypeID() )
1457             {
1458                 Remove(i);
1459                 --i;
1460             }
1461         }
1462 }
1463
1464 //
1465 //
1466 //
1467 //  END TODO
1468 //
1469 //
1470 //
1471
1472 wxFileType* wxMimeTypesManagerImpl::Associate(const wxFileTypeInfo& ftInfo)
1473 {
1474     bool bInfoSuccess = false;
1475
1476     const wxArrayString& asExtensions = ftInfo.GetExtensions();
1477     size_t dwFoundIndex = 0;
1478     if (!asExtensions.GetCount())
1479     {
1480         wxLogDebug(wxT("Must have extension to associate with"));
1481     }
1482
1483     // Find and write to Info.plist in main bundle (note that some other
1484     // apps have theirs named differently, i.e. IE's is named Info-macos.plist
1485     // some apps (non-wx) use the 'plst' resource instead
1486     CFBundleRef cfbMain = CFBundleGetMainBundle();
1487     if (cfbMain)
1488     {
1489         UInt32 dwBundleType, dwBundleCreator;
1490         CFBundleGetPackageInfo(cfbMain, &dwBundleType, &dwBundleCreator);
1491
1492         // if launching terminal non-app, version will be 'BNDL' (generic bundle, maybe in other cases too),
1493         // which will give us the incorrect info.plist path
1494         // otherwise it will be 'APPL', or in the case of a framework, 'FMWK'
1495         if (dwBundleType == 'APPL')
1496         {
1497             wxCFURL cfurlBundleLoc((CFTypeRef)CFBundleCopyBundleURL(cfbMain));
1498 //             wxCFURL cfurlBundleLoc((CFTypeRef)CFBundleCopyExecutableURL(cfbMain));
1499             wxString sInfoPath;
1500 //            sInfoPath << wxT("file://");
1501             sInfoPath << cfurlBundleLoc.BuildWXString();
1502             sInfoPath << wxT("Contents/Info.plist");
1503
1504 //        wxCFDictionary cfdInfo( CFBundleGetInfoDictionary(cfbMain), wxCF_RETAIN );
1505             wxCFDictionary cfdInfo;
1506             bool bInfoOpenSuccess = false;
1507             wxFile indictfile;
1508             if (indictfile.Open(sInfoPath, wxFile::read))
1509             {
1510                 CFIndex cfiBufLen = (CFIndex) indictfile.Length();
1511                 const UInt8* pBuffer = new UInt8[cfiBufLen];
1512                 indictfile.Read((void*)pBuffer, cfiBufLen);
1513                 wxCFData cfdaInDict(pBuffer, cfiBufLen);
1514                 wxString sError;
1515                 bInfoOpenSuccess = cfdInfo.ReadAsXML(cfdaInDict, &sError);
1516                 if (!bInfoOpenSuccess)
1517                     wxLogDebug(sError);
1518                 indictfile.Close();
1519             }
1520
1521             if (bInfoOpenSuccess)
1522             {
1523                 cfdInfo.MakeMutable( cfdInfo.GetCount() + 1 );
1524
1525                 wxCFArray cfaDocTypes( cfdInfo[ wxCFString(wxT("CFBundleDocumentTypes")) ], wxCF_RETAIN );
1526
1527                 bool bAddDocTypesArrayToDictionary = !cfaDocTypes.IsOk();
1528                 if (bAddDocTypesArrayToDictionary)
1529                     cfaDocTypes.Create();
1530                 else
1531                     cfaDocTypes.MakeMutable( cfaDocTypes.GetCount() + 1 );
1532
1533                 bool bEntryFound = false;
1534
1535                 // search for duplicates
1536                 CFIndex i;
1537                 for (i = 0; i < cfaDocTypes.GetCount(); ++i)
1538                 {
1539                     wxCFDictionary cfdDocTypeEntry( cfaDocTypes[i], wxCF_RETAIN );
1540
1541                     // A lot of apps don't support MIME types for some reason
1542                     // so we go by extensions only
1543                     wxCFArray cfaExtensions( cfdDocTypeEntry[ wxCFString(wxT("CFBundleTypeExtensions")) ],
1544                                              wxCF_RETAIN );
1545
1546                     if (!cfaExtensions.IsOk())
1547                         continue;
1548
1549                     for (CFIndex iExt = 0; iExt < cfaExtensions.GetCount(); ++iExt)
1550                     {
1551                         for (size_t iWXExt = 0; iWXExt < asExtensions.GetCount(); ++iWXExt)
1552                         {
1553                             if (asExtensions[iWXExt] ==
1554                                     wxCFString(cfaExtensions[iExt], wxCF_RETAIN).BuildWXString())
1555                             {
1556                                 bEntryFound = true;
1557                                 dwFoundIndex = iWXExt;
1558
1559                                 break;
1560                             }
1561                         } //end of wxstring array
1562
1563                         if (bEntryFound)
1564                             break;
1565                     } //end for cf array
1566
1567                     if (bEntryFound)
1568                         break;
1569                 } //end for doctypes
1570
1571                 wxCFDictionary cfdNewEntry;
1572
1573                 if (!ftInfo.GetDescription().empty())
1574                 {
1575                     cfdNewEntry.Add( wxCFString(wxT("CFBundleTypeName")),
1576                                 wxCFString(ftInfo.GetDescription()) );
1577                 }
1578
1579                 if (!ftInfo.GetIconFile().empty())
1580                 {
1581                     cfdNewEntry.Add( wxCFString(wxT("CFBundleTypeIconFile")),
1582                                     wxCFString(ftInfo.GetIconFile()) );
1583                 }
1584
1585                 wxCFArray cfaOSTypes;
1586                 wxCFArray cfaExtensions;
1587                 wxCFArray cfaMimeTypes;
1588
1589                 //OSTypes is a cfarray of four-char-codes - '****' for unrestricted
1590                 cfaOSTypes.Add( wxCFString(wxT("****")) );
1591                 cfdNewEntry.Add( wxCFString(wxT("CFBundleTypeOSTypes")), cfaOSTypes );
1592
1593                 //'*' for unrestricted
1594                 if (ftInfo.GetExtensionsCount() != 0)
1595                 {
1596                     for (size_t iExtension = 0; iExtension < ftInfo.GetExtensionsCount(); ++iExtension)
1597                     {
1598                         cfaExtensions.Add( wxCFString( asExtensions[iExtension] ) );
1599                     }
1600
1601                     cfdNewEntry.Add( wxCFString(wxT("CFBundleTypeExtensions")), cfaExtensions );
1602                 }
1603
1604                 if (!ftInfo.GetMimeType().empty())
1605                 {
1606                     cfaMimeTypes.Add( wxCFString(ftInfo.GetMimeType()) );
1607                     cfdNewEntry.Add( wxCFString(wxT("CFBundleTypeMIMETypes")), cfaMimeTypes );
1608                 }
1609
1610                 // Editor - can perform all actions
1611                 // Viewer - all actions except manipulation/saving
1612                 // None - can perform no actions
1613                 cfdNewEntry.Add( wxCFString(wxT("CFBundleTypeRole")), wxCFString(wxT("Editor")) );
1614
1615                 // Is application bundled?
1616                 cfdNewEntry.Add( wxCFString(wxT("LSTypeIsPackage")), kCFBooleanTrue );
1617
1618                 if (bEntryFound)
1619                     cfaDocTypes.Set(i, cfdNewEntry);
1620                 else
1621                     cfaDocTypes.Add(cfdNewEntry);
1622
1623                 // set the doc types array in the muted dictionary
1624                 if (bAddDocTypesArrayToDictionary)
1625                     cfdInfo.Add(wxCFString(wxT("CFBundleDocumentTypes")), cfaDocTypes);
1626                 else
1627                     cfdInfo.Set(wxCFString(wxT("CFBundleDocumentTypes")), cfaDocTypes);
1628
1629                 cfdInfo.MakeValidXML();
1630
1631                 wxFile outdictfile;
1632                 if (outdictfile.Open(sInfoPath, wxFile::write))
1633                 {
1634                     wxCFData cfdaInfo(cfdInfo.WriteAsXML());
1635                     if (cfdaInfo.IsOk())
1636                     {
1637                         if (outdictfile.Write(cfdaInfo.GetValue(), cfdaInfo.GetCount()) !=
1638                             (wxFileOffset)cfdaInfo.GetCount())
1639                         {
1640                             wxLogDebug(wxT("error in writing to file"));
1641                         }
1642                         else
1643                         {
1644                             bInfoSuccess = true;
1645
1646 //#if defined(__DARWIN__)
1647 //                //force launch services to update its database for the finder
1648 //                OSStatus status = LSRegisterURL((CFURLRef)(CFTypeRef)cfurlBundleLoc, true);
1649 //                if (status != noErr)
1650 //                {
1651 //                    wxLogDebug(wxT("LSRegisterURL Failed."));
1652 //                }
1653 //#endif
1654                         }
1655                         outdictfile.Close();
1656                     }
1657                     else
1658                     {
1659                         outdictfile.Close();
1660                         wxLogDebug(wxT("Could not read in new dictionary"));
1661                     }
1662                 }
1663                 else
1664                 {
1665                     wxLogDebug(wxString(wxT("Could not open [")) +
1666                     sInfoPath + wxT("] for writing."));
1667                 }
1668             }
1669             else
1670             {
1671                 wxLogDebug(wxT("No info dictionary in main bundle"));
1672             }
1673         }
1674         else
1675         {
1676             wxLogDebug(wxT("Can only call associate from bundled app within XXX.app"));
1677         }
1678     }
1679     else
1680     {
1681         wxLogDebug(wxT("No main bundle"));
1682     }
1683
1684 #if defined(__DARWIN__)
1685     if (!bInfoSuccess)
1686         return NULL;
1687 #endif
1688
1689     // on mac you have to embed it into the mac's file reference resource ('FREF' I believe)
1690     // or, alternately, you could just add an entry to m_hDatabase, but you'd need to get
1691     // the app's signature somehow...
1692
1693     OSType processType, creator;
1694     OSStatus status = MoreProcGetProcessTypeSignature(NULL, &processType, &creator);
1695
1696     if (status == noErr)
1697     {
1698         Str255 psCreatorName;
1699 #ifndef __LP64__
1700         FSSpec dummySpec;
1701         status = FindApplication(creator, false, psCreatorName, &dummySpec);
1702 #else
1703         FSRef fsref;
1704         status = LSFindApplicationForInfo( creator, NULL, NULL, &fsref ,NULL);
1705         HFSUniStr255 name;
1706         status = FSGetCatalogInfo(&fsref, kFSCatInfoNone, NULL, &name, NULL, NULL);
1707         CFStringRef str = FSCreateStringFromHFSUniStr( 0 , &name );
1708         CFStringGetPascalString(str, psCreatorName, 256, CFStringGetSystemEncoding());
1709         CFRelease( str );
1710 #endif
1711
1712         if (status == noErr)
1713         {
1714             //get the file type if it exists -
1715             //if it really does then modify the database then save it,
1716             //otherwise we need to create a whole new entry
1717             wxFileType* pFileType = GetFileTypeFromExtension(asExtensions[dwFoundIndex]);
1718             if (pFileType)
1719             {
1720                 ICMapEntry entry;
1721                 ICGetMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase,
1722                     pFileType->m_impl->m_lIndex, &entry );
1723
1724                 memcpy(entry.creatorAppName, psCreatorName, sizeof(Str255));
1725                 entry.fileCreator = creator;
1726
1727                 status = ICSetMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase,
1728                     pFileType->m_impl->m_lIndex, &entry );
1729
1730                 //success
1731                 if (status == noErr)
1732                 {
1733                      return pFileType;
1734
1735                     //kICAttrNoChange means we don't care about attributes such as
1736                     //locking in the database
1737 //                    status = ICSetPrefHandle((ICInstance) m_hIC, kICMapping,
1738 //                                             kICAttrNoChange, (Handle) m_hDatabase);
1739 //                    if (status == noErr)
1740 //                        return pFileType;
1741 //                    else
1742 //                    {
1743 //                        wxLogDebug(wxString::Format(wxT("%i - %s"), (int)status, wxT("ICSetPrefHandle failed.")));
1744 //                    }
1745                 }
1746                 else
1747                 {
1748                     wxLogDebug(wxString::Format(wxT("%i - %s"), __LINE__, wxT("ICSetMapEntry failed.")));
1749                 }
1750
1751                 // failure - cleanup
1752                 delete pFileType;
1753             }
1754             else
1755             {
1756                 // TODO: Maybe force all 3 of these to be non-empty?
1757                 Str255 psExtension, psMimeType, psDescription;
1758
1759                 wxMacStringToPascal(wxString(wxT(".")) + ftInfo.GetExtensions()[0], psExtension);
1760                 wxMacStringToPascal(ftInfo.GetMimeType(), psMimeType);
1761                 wxMacStringToPascal(ftInfo.GetDescription(), psDescription);
1762
1763                 Str255 psPostCreatorName;
1764                 wxMacStringToPascal(wxEmptyString, psPostCreatorName);
1765
1766                 //add the entry to the database
1767                 ICMapEntry entry;
1768                 entry.totalLength = sizeof(ICMapEntry);
1769                 entry.fixedLength = kICMapFixedLength;
1770                 entry.version = 0;
1771                 entry.fileType = 0; //TODO:  File type?
1772                 entry.fileCreator = creator;
1773                 entry.postCreator = 0;
1774                 entry.flags = kICMapDataForkBit; //TODO:  Maybe resource is valid by default too?
1775                 PLstrcpy( entry.extension , psExtension ) ;
1776                 memcpy(entry.creatorAppName, psCreatorName, sizeof(Str255));
1777                 memcpy(entry.postAppName, psPostCreatorName, sizeof(Str255));
1778                 memcpy(entry.MIMEType, psMimeType, sizeof(Str255));
1779                 memcpy(entry.entryName, psDescription, sizeof(Str255));
1780
1781                 status = ICAddMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase, &entry);
1782                 if (status == noErr)
1783                 {
1784                     return GetFileTypeFromExtension(ftInfo.GetMimeType());
1785
1786 //                    kICAttrNoChange means we don't care about attributes such as
1787 //                    locking in the database
1788 //                    status = ICSetPrefHandle((ICInstance) m_hIC, kICMapping,
1789 //                                             kICAttrNoChange, (Handle) m_hDatabase);
1790
1791                     // return the entry in the database if successful
1792 //                    if (status == noErr)
1793 //                        return GetFileTypeFromExtension(ftInfo.GetMimeType());
1794 //                    else
1795 //                    {
1796 //                        wxLogDebug(wxString::Format(wxT("%i - %s"), __LINE__, wxT("ICSetPrefHandle failed.")));
1797  //                   }
1798                 }
1799                 else
1800                 {
1801                     wxLogDebug(wxString::Format(wxT("%i - %s"), __LINE__, wxT("ICAppMapEntry failed.")));
1802                 }
1803             }
1804         } // end if FindApplcation was successful
1805         else
1806         {
1807             wxLogDebug(wxString::Format(wxT("%i - %s"), __LINE__, wxT("FindApplication failed.")));
1808         }
1809     } // end if it could obtain app's signature
1810     else
1811     {
1812         wxLogDebug(wxString::Format(wxT("%i - %s"), __LINE__, wxT("GetProcessSignature failed.")));
1813     }
1814
1815     return NULL;
1816 }
1817
1818 bool
1819 wxMimeTypesManagerImpl::Unassociate(wxFileType *pFileType)
1820 {
1821     wxASSERT(pFileType);
1822     bool bInfoSuccess = false;
1823
1824     wxArrayString asExtensions;
1825     pFileType->GetExtensions(asExtensions);
1826
1827     if (!asExtensions.GetCount())
1828     {
1829         wxLogDebug(wxT("Must have extension to disassociate"));
1830         return false;
1831     }
1832
1833     // Find and write to Info.plist in main bundle (note that some other
1834     // apps have theirs named differently, i.e. IE's is named Info-macos.plist
1835     // some apps (non-wx) use the 'plst' resource instead
1836     CFBundleRef cfbMain = CFBundleGetMainBundle();
1837     if (cfbMain)
1838     {
1839         UInt32 dwBundleType, dwBundleCreator;
1840         CFBundleGetPackageInfo(cfbMain, &dwBundleType, &dwBundleCreator);
1841
1842         // if launching terminal non-app, version will be 'BNDL' (generic bundle, maybe in other cases too),
1843         // which will give us the incorrect info.plist path
1844         // otherwise it will be 'APPL', or in the case of a framework, 'FMWK'
1845         if (dwBundleType == 'APPL')
1846         {
1847
1848             wxCFURL cfurlBundleLoc((CFTypeRef)CFBundleCopyBundleURL(cfbMain));
1849 //             wxCFURL cfurlBundleLoc((CFTypeRef)CFBundleCopyExecutableURL(cfbMain));
1850             wxString sInfoPath;
1851 //            sInfoPath << wxT("file://");
1852             sInfoPath << cfurlBundleLoc.BuildWXString();
1853             sInfoPath << wxT("Contents/Info.plist");
1854
1855 //        wxCFDictionary cfdInfo( (CFTypeRef) CFBundleGetInfoDictionary(cfbMain), wxCF_RETAIN );
1856             wxCFDictionary cfdInfo;
1857             bool bInfoOpenSuccess = false;
1858             wxFile indictfile;
1859             if (indictfile.Open(sInfoPath, wxFile::read))
1860             {
1861                 CFIndex cfiBufLen = (CFIndex) indictfile.Length();
1862                 const UInt8* pBuffer = new UInt8[cfiBufLen];
1863                 indictfile.Read((void*)pBuffer, cfiBufLen);
1864                 wxCFData cfdaInDict(pBuffer, cfiBufLen);
1865                 wxString sError;
1866                 bInfoOpenSuccess = cfdInfo.ReadAsXML(cfdaInDict, &sError);
1867                 if (!bInfoOpenSuccess)
1868                     wxLogDebug(sError);
1869                 indictfile.Close();
1870             }
1871
1872             if (bInfoOpenSuccess)
1873             {
1874                 cfdInfo.MakeMutable( cfdInfo.GetCount() + 1 );
1875
1876                 wxCFArray cfaDocTypes( cfdInfo[ wxCFString(wxT("CFBundleDocumentTypes")) ], wxCF_RETAIN );
1877
1878                 if (cfaDocTypes.IsOk())
1879                 {
1880                     bool bEntryFound = false;
1881
1882                     //search for duplicate
1883                     CFIndex i;
1884                     for (i = 0; i < cfaDocTypes.GetCount(); ++i)
1885                     {
1886                         wxCFDictionary cfdDocTypeEntry( cfaDocTypes[i], wxCF_RETAIN );
1887
1888                         //A lot of apps dont do to mime types for some reason
1889                         //so we go by extensions only
1890                         wxCFArray cfaExtensions( cfdDocTypeEntry[ wxCFString(wxT("CFBundleTypeExtensions")) ],
1891                                         wxCF_RETAIN );
1892
1893                         if (!cfaExtensions.IsOk())
1894                             continue;
1895
1896                         for (CFIndex iExt = 0; iExt < cfaExtensions.GetCount(); ++iExt)
1897                         {
1898                             for (size_t iWXExt = 0; iWXExt < asExtensions.GetCount(); ++iWXExt)
1899                             {
1900                                 if (asExtensions[iWXExt] ==
1901                                     wxCFString(cfaExtensions[iExt], wxCF_RETAIN).BuildWXString())
1902                                 {
1903                                     bEntryFound = true;
1904                                     cfaDocTypes.Remove(i);
1905                                     cfdInfo.Set( wxCFString(wxT("CFBundleDocumentTypes")) , cfaDocTypes );
1906                                     break;
1907                                 }
1908                             } //end of wxstring array
1909
1910                             if (bEntryFound)
1911                                 break;
1912                         } //end for cf array
1913
1914                         if (bEntryFound)
1915                             break;
1916                     }//end for doctypes
1917
1918                     if (bEntryFound)
1919                     {
1920                         cfdInfo.MakeValidXML();
1921
1922                         wxFile outdictfile;
1923                         if (outdictfile.Open(sInfoPath, wxFile::write))
1924                         {
1925                             wxCFData cfdaInfo(cfdInfo.WriteAsXML());
1926                             if (cfdaInfo.IsOk())
1927                             {
1928                                 if (outdictfile.Write(cfdaInfo.GetValue(), cfdaInfo.GetCount()) !=
1929                                     (wxFileOffset)cfdaInfo.GetCount())
1930                                 {
1931                                     wxLogDebug(wxT("error in writing to file"));
1932                                 }
1933                                 else
1934                                 {
1935                                     bInfoSuccess = true;
1936
1937 //#if defined(__DARWIN__)
1938 //                //force launch services to update its database for the finder
1939 //                OSStatus status = LSRegisterURL((CFURLRef)(CFTypeRef)cfurlBundleLoc, true);
1940 //                if (status != noErr)
1941 //                {
1942 //                    wxLogDebug(wxT("LSRegisterURL Failed."));
1943 //                }
1944 //#endif
1945                                 }
1946                                 outdictfile.Close();
1947                             }
1948                             else
1949                             {
1950                                 outdictfile.Close();
1951                                 wxLogDebug(wxT("Could not read in new dictionary"));
1952                             }
1953                         }
1954                         else
1955                         {
1956                             wxLogDebug(
1957                                 wxString(wxT("Could not open [")) +
1958                                 sInfoPath + wxT("] for writing."));
1959                         }
1960                     }
1961                     else
1962                     {
1963                         wxLogDebug(wxT("Entry not found to remove"));
1964
1965                         wxString sPrintOut;
1966                         wxCFDictionary::PrintOutArray(sPrintOut, (CFArrayRef)(CFTypeRef)cfaDocTypes);
1967                         wxLogDebug(sPrintOut);
1968
1969                         for (size_t i = 0; i < asExtensions.GetCount(); ++i)
1970                             wxLogDebug(asExtensions[i]);
1971                     }
1972                 }
1973                 else
1974                 {
1975                     wxLogDebug(wxT("No doc types array found"));
1976                     wxString sPrintOut;  cfdInfo.PrintOut(sPrintOut);  wxLogDebug(sPrintOut);
1977                 }
1978             }
1979             else
1980             {
1981                 wxLogDebug(wxT("No info dictionary in main bundle"));
1982             }
1983         }
1984         else
1985         {
1986             wxLogDebug(wxT("Can only call associate from bundled app within XXX.app"));
1987         }
1988     }
1989     else
1990     {
1991         wxLogDebug(wxT("No main bundle"));
1992     }
1993
1994 #if defined(__DARWIN__)
1995     if (!bInfoSuccess)
1996         return false;
1997 #endif
1998
1999     // this should be as easy as removing the entry from the database
2000     // and then saving the database
2001     OSStatus status = ICDeleteMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase,
2002                             pFileType->m_impl->m_lIndex);
2003
2004     if (status == noErr)
2005     {
2006             return true;
2007
2008         //kICAttrNoChange means we don't care about attributes such as
2009         //locking in the database
2010 //        status = ICSetPrefHandle((ICInstance) m_hIC, kICMapping,
2011 //                    kICAttrNoChange, (Handle) m_hDatabase);
2012
2013 //        if (status == noErr)
2014 //        {
2015 //            return true;
2016 //        }
2017 //        else
2018 //        {
2019 //            wxLogDebug(wxString::Format(wxT("%i - %s"), __LINE__, wxT("ICSetPrefHandle failed.")));
2020 //        }
2021     }
2022     else
2023     {
2024         wxLogDebug(wxString::Format(wxT("%i - %s"), __LINE__, wxT("ICDeleteMapEntry failed.")));
2025     }
2026
2027     return false;
2028 }
2029
2030 #if 0
2031     CFWriteStreamRef cfwsInfo = CFWriteStreamCreateWithFile(
2032            kCFAllocatorDefault,
2033            (CFURLRef) (CFTypeRef)cfurlInfoLoc );
2034
2035 //     CFShow(cfdInfo);
2036         if (cfwsInfo)
2037         {
2038             Boolean bOpened = CFWriteStreamOpen(cfwsInfo);
2039             if (bOpened)
2040             {
2041                 CFStringRef cfsError;
2042                 CFIndex cfiWritten = CFPropertyListWriteToStream((CFPropertyListRef)(CFTypeRef)cfdInfo,
2043                                     cfwsInfo,
2044                                     kCFPropertyListXMLFormat_v1_0, //100
2045                                     &cfsError);
2046                 if (cfsError && cfiWritten == 0)
2047                 {
2048                     wxLogDebug(wxCFString(cfsError).BuildWXString());
2049                     wxString sMessage;
2050                     cfdInfo.PrintOut(sMessage);
2051                     wxLogDebug(sMessage);
2052                 }
2053                 else
2054                 {
2055                     bInfoSuccess = true;
2056 //#if defined(__DARWIN__)
2057 //                //force launch services to update its database for the finder
2058 //                OSStatus status = LSRegisterURL((CFURLRef)(CFTypeRef)cfurlBundleLoc, true);
2059 //                if (status != noErr)
2060 //                {
2061 //                    wxLogDebug(wxT("LSRegisterURL Failed."));
2062 //                }
2063 //#endif
2064                 }
2065
2066                 CFWriteStreamClose(cfwsInfo);
2067 #endif
2068
2069 #endif //wxUSE_MIMETYPE