unifying CFTypes

[wxWidgets.git] / src / mac / carbon / mimetmac.cpp
diff --git a/src/mac/carbon/mimetmac.cpp b/src/mac/carbon/mimetmac.cpp

index 61f059e992760cc20387adab8429858710bb1a78..ab3508000bcb6d6d2e775fc64afecf770d8401e1 100644 (file)
--- a/src/mac/carbon/mimetmac.cpp
+++ b/src/mac/carbon/mimetmac.cpp
@@ -1,6 +1,6 @@
  /////////////////////////////////////////////////////////////////////////////
  /////////////////////////////////////////////////////////////////////////////
-// Name:        mac/mimetype.cpp
-// Purpose:     Mac Carbon implementation for wx mime-related classes
+// Name:        src/mac/carbon/mimetype.cpp
+// Purpose:     Mac Carbon implementation for wx MIME-related classes
  // Author:      Ryan Norton
  // Modified by:
  // Created:     04/16/2005
  // Author:      Ryan Norton
  // Modified by:
  // Created:     04/16/2005
@@ -10,305 +10,317 @@
  /////////////////////////////////////////////////////////////////////////////
  
  //
  /////////////////////////////////////////////////////////////////////////////
  
  //
-//
-//  TODO:  Search Info[-macos](classic).plist dictionary in addition
+//  TODO: Search Info[-macos](classic).plist dictionary in addition
  //  to Internet Config database.
  //
  //  Maybe try a brainstorm a way to change the wxMimeTypesManager API
  //  to get info from a file instead/addition to current get all stuff
  //  to Internet Config database.
  //
  //  Maybe try a brainstorm a way to change the wxMimeTypesManager API
  //  to get info from a file instead/addition to current get all stuff
-//  API so that we can use Launch Services to get mime type info.
-//
-//     Implement geticon from one of the finder info functions - or
-//     use launch services and search that app's plist for the icon.
-//
-//     Put some special juice in for the print command.
+//  API so that we can use Launch Services to get MIME type info.
  //
  //
+//  Implement GetIcon from one of the FinderInfo functions - or
+//  use Launch Services and search that app's plist for the icon.
  //
  //
+//  Put some special juice in for the print command.
  //
  
  //
  
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-#pragma implementation "mimetype.h"
-#endif
-
  // for compilers that support precompilation, includes "wx.h".
  #include "wx/wxprec.h"
  
  #ifdef __BORLANDC__
  // for compilers that support precompilation, includes "wx.h".
  #include "wx/wxprec.h"
  
  #ifdef __BORLANDC__
-  #pragma hdrstop
+    #pragma hdrstop
  #endif
  
  #endif
  
-#ifndef WX_PRECOMP
-  #include "wx/string.h"
-  #if wxUSE_GUI
-    #include "wx/icon.h"
-  #endif
-#endif //WX_PRECOMP
+#if wxUSE_MIMETYPE
  
  
+#include "wx/mac/mimetype.h"
  
  
-#if wxUSE_MIMETYPE
+#ifndef WX_PRECOMP
+    #include "wx/dynarray.h"
+    #include "wx/string.h"
+    #include "wx/intl.h"
+    #include "wx/log.h"
+
+    #if wxUSE_GUI
+        #include "wx/icon.h"
+    #endif
+#endif
  
  
-#include "wx/log.h"
  #include "wx/file.h"
  #include "wx/file.h"
-#include "wx/intl.h"
-#include "wx/dynarray.h"
  #include "wx/confbase.h"
  
  #include "wx/confbase.h"
  
-#include "wx/mac/mimetype.h"
-#include "wx/mac/private.h" //wxMacMakeStringFromPascal
+#include "wx/mac/private.h"
  
  // other standard headers
  #include <ctype.h>
  
  // other standard headers
  #include <ctype.h>
-#include <InternetConfig.h> //For mime types
  
  
+#ifndef __DARWIN__
+    #include <InternetConfig.h>
+    #include <CoreServices.h>
+#endif
  
  
-/*   START CODE SAMPLE FROM TECHNOTE 1002 (http://developer.apple.com/technotes/tn/tn1002.html) */
+#ifndef __LP64__
+//   START CODE SAMPLE FROM TECHNOTE 1002 (http://developer.apple.com/technotes/tn/tn1002.html)
  
  
- /* IsRemoteVolume can be used to find out if the
-    volume referred to by vRefNum is a remote volume
-    located somewhere on a network. the volume's attribute
-    flags (copied from the GetVolParmsInfoBuffer structure)
-    are returned in the longword pointed to by vMAttrib. */
-OSErr IsRemoteVolume(short vRefNum, Boolean *isRemote, long *vMAttrib) {
+// IsRemoteVolume can be used to find out if the
+// volume referred to by vRefNum is a remote volume
+// located somewhere on a network. the volume's attribute
+// flags (copied from the GetVolParmsInfoBuffer structure)
+// are returned in the longword pointed to by vMAttrib.
+OSErr IsRemoteVolume(short vRefNum, Boolean *isRemote, long *vMAttrib)
+{
      HParamBlockRec volPB;
      GetVolParmsInfoBuffer volinfo;
      OSErr err;
      HParamBlockRec volPB;
      GetVolParmsInfoBuffer volinfo;
      OSErr err;
+
      volPB.ioParam.ioVRefNum = vRefNum;
      volPB.ioParam.ioNamePtr = NULL;
      volPB.ioParam.ioVRefNum = vRefNum;
      volPB.ioParam.ioNamePtr = NULL;
-    volPB.ioParam.ioBuffer = (Ptr) &volinfo;
+    volPB.ioParam.ioBuffer = (Ptr)&volinfo;
      volPB.ioParam.ioReqCount = sizeof(volinfo);
      volPB.ioParam.ioReqCount = sizeof(volinfo);
-    err = PBHGetVolParmsSync(&volPB);
-    if (err == noErr) {
+    err = PBHGetVolParmsSync( &volPB );
+    if (err == noErr)
+    {
          *isRemote = (volinfo.vMServerAdr != 0);
          *vMAttrib = volinfo.vMAttrib;
      }
          *isRemote = (volinfo.vMServerAdr != 0);
          *vMAttrib = volinfo.vMAttrib;
      }
+
      return err;
  }
  
      return err;
  }
  
-
-    /* BuildVolumeList fills the array pointed to by vols with
-    a list of the currently mounted volumes.  If includeRemote
-    is true, then remote server volumes will be included in
-    the list.  When remote server volumes are included in the
-    list, they will be added to the end of the list.  On entry,
-    *count should contain the size of the array pointed to by
-    vols.  On exit, *count will be set to the number of id numbers
-    placed in the array. If vMAttribMask is non-zero, then
-    only volumes with matching attributes are added to the
-    list of volumes. bits in the vMAttribMask should use the
-    same encoding as bits in the vMAttrib field of
-    the GetVolParmsInfoBuffer structure. */
+// BuildVolumeList fills the array pointed to by vols with
+// a list of the currently mounted volumes.  If includeRemote
+// is true, then remote server volumes will be included in
+// the list.  When remote server volumes are included in the
+// list, they will be added to the end of the list.  On entry,
+// *count should contain the size of the array pointed to by
+// vols.  On exit, *count will be set to the number of id numbers
+// placed in the array. If vMAttribMask is non-zero, then
+// only volumes with matching attributes are added to the
+// list of volumes. bits in the vMAttribMask should use the
+// same encoding as bits in the vMAttrib field of
+// the GetVolParmsInfoBuffer structure.
  OSErr BuildVolumeList(Boolean includeRemote, short *vols,
  OSErr BuildVolumeList(Boolean includeRemote, short *vols,
-        long *count, long vMAttribMask) {
+        long *count, long vMAttribMask)
+{
      HParamBlockRec volPB;
      Boolean isRemote;
      HParamBlockRec volPB;
      Boolean isRemote;
-    OSErr err;
+    OSErr err = noErr;
      long nlocal, nremote;
      long vMAttrib;
  
      long nlocal, nremote;
      long vMAttrib;
  
-        /* set up and check parameters */
+    // set up and check parameters
      volPB.volumeParam.ioNamePtr = NULL;
      nlocal = nremote = 0;
      volPB.volumeParam.ioNamePtr = NULL;
      nlocal = nremote = 0;
-    if (*count == 0) return noErr;
+    if (*count == 0)
+        return noErr;
  
  
-        /* iterate through volumes */
+    // iterate through volumes
      for (volPB.volumeParam.ioVolIndex = 1;
          PBHGetVInfoSync(&volPB) == noErr;
      for (volPB.volumeParam.ioVolIndex = 1;
          PBHGetVInfoSync(&volPB) == noErr;
-        volPB.volumeParam.ioVolIndex++) {
-
-                /* skip remote volumes, if necessary */
+        volPB.volumeParam.ioVolIndex++)
+    {
+        // skip remote volumes, if necessary
          err = IsRemoteVolume(volPB.volumeParam.ioVRefNum, &isRemote, &vMAttrib);
          err = IsRemoteVolume(volPB.volumeParam.ioVRefNum, &isRemote, &vMAttrib);
-        if (err != noErr) goto bail;
-        if ( ( includeRemote || ! isRemote )
-        && (vMAttrib & vMAttribMask) == vMAttribMask ) {
+        if (err != noErr)
+            goto bail;
  
  
-                /* add local volumes at the front, remote
-                volumes at the end */
+        if ((includeRemote || !isRemote) && ((vMAttrib & vMAttribMask) == vMAttribMask))
+        {
+            // add local volumes at the front; remote volumes at the end
              if (isRemote)
                  vols[nlocal + nremote++] = volPB.volumeParam.ioVRefNum;
              if (isRemote)
                  vols[nlocal + nremote++] = volPB.volumeParam.ioVRefNum;
-            else {
+            else
+            {
                  if (nremote > 0)
                  if (nremote > 0)
-                    BlockMoveData(vols+nlocal, vols+nlocal+1,
-                        nremote*sizeof(short));
+                    BlockMoveData(
+                        vols + nlocal,
+                        vols + nlocal + 1,
+                        nremote * sizeof(short) );
                  vols[nlocal++] = volPB.volumeParam.ioVRefNum;
              }
  
                  vols[nlocal++] = volPB.volumeParam.ioVRefNum;
              }
  
-                /* list full? */
-            if ((nlocal + nremote) >= *count) break;
+            // list full?
+            if ((nlocal + nremote) >= *count)
+                break;
          }
      }
          }
      }
+
  bail:
      *count = (nlocal + nremote);
  bail:
      *count = (nlocal + nremote);
+
      return err;
  }
  
  
      return err;
  }
  
  
-    /* FindApplication iterates through mounted volumes
-    searching for an application with the given creator
-    type.  If includeRemote is true, then remote volumes
-    will be searched (after local ones) for an application
-    with the creator type. */
-
+// FindApplication iterates through mounted volumes
+// searching for an application with the given creator
+// type.  If includeRemote is true, then remote volumes
+// will be searched (after local ones) for an application
+// with the creator type.
+//
+// Hacked to output to appName
+//
  #define kMaxVols 20
  
  #define kMaxVols 20
  
-/* Hacked to output to appName */
-
-OSErr FindApplication(OSType appCreator, Boolean includeRemote, Str255 appName, FSSpec* appSpec) {
+OSErr FindApplication(OSType appCreator, Boolean includeRemote, Str255 appName, FSSpec* appSpec)
+{
      short rRefNums[kMaxVols];
      long i, volCount;
      DTPBRec desktopPB;
      OSErr err;
      short rRefNums[kMaxVols];
      long i, volCount;
      DTPBRec desktopPB;
      OSErr err;
-    
-        /* get a list of volumes - with desktop files */
-    volCount = kMaxVols;
-    err = BuildVolumeList(includeRemote, rRefNums, &volCount,
-        (1<<bHasDesktopMgr) );
-    if (err != noErr) return err;
  
  
-        /* iterate through the list */
-    for (i=0; i<volCount; i++) {
+    // get a list of volumes - with desktop files
+    volCount = kMaxVols;
+    err = BuildVolumeList(includeRemote, rRefNums, &volCount, (1 << bHasDesktopMgr) );
+    if (err != noErr)
+        return err;
  
  
-            /* has a desktop file? */
+    // iterate through the list
+    for (i=0; i<volCount; i++)
+    {
+        // has a desktop file?
          desktopPB.ioCompletion = NULL;
          desktopPB.ioVRefNum = rRefNums[i];
          desktopPB.ioNamePtr = NULL;
          desktopPB.ioIndex = 0;
          desktopPB.ioCompletion = NULL;
          desktopPB.ioVRefNum = rRefNums[i];
          desktopPB.ioNamePtr = NULL;
          desktopPB.ioIndex = 0;
-        err = PBDTGetPath(&desktopPB);
-        if (err != noErr) continue;
+        err = PBDTGetPath( &desktopPB );
+        if (err != noErr)
+            continue;
  
  
-            /* has the correct app?? */
+        // has the correct app??
          desktopPB.ioFileCreator = appCreator;
          desktopPB.ioNamePtr = appName;
          desktopPB.ioFileCreator = appCreator;
          desktopPB.ioNamePtr = appName;
-        err = PBDTGetAPPLSync(&desktopPB);
-        if (err != noErr) continue;
+        err = PBDTGetAPPLSync( &desktopPB );
+        if (err != noErr)
+            continue;
  
  
-            /* make a file spec referring to it */
-        err = FSMakeFSSpec(rRefNums[i],
-              desktopPB.ioAPPLParID, appName,
-              appSpec);
-        if (err != noErr) continue;
+        // make a file spec referring to it
+        err = FSMakeFSSpec( rRefNums[i], desktopPB.ioAPPLParID, appName, appSpec );
+        if (err != noErr)
+            continue;
  
  
-           /* found it! */
+        // found it!
          return noErr;
          return noErr;
-
      }
      }
+
      return fnfErr;
  }
  
      return fnfErr;
  }
  
-/*   END CODE SAMPLE FROM TECHNOTE 1002 (http://developer.apple.com/technotes/tn/tn1002.html) */
+// END CODE SAMPLE FROM TECHNOTE 1002 (http://developer.apple.com/technotes/tn/tn1002.html)
  
  
-//yeah, duplicated code
-pascal  OSErr  FSpGetFullPath(const FSSpec *spec,
-                 short *fullPathLength,
-                 Handle *fullPath)
+// yeah, duplicated code
+pascal OSErr FSpGetFullPath( const FSSpec *spec,
+    short *fullPathLength,
+    Handle *fullPath )
  {
  {
-  OSErr    result;
-  OSErr    realResult;
-  FSSpec    tempSpec;
-  CInfoPBRec  pb;
-  
-  *fullPathLength = 0;
-  *fullPath = NULL;
-  
-  
-  /* Default to noErr */
-  realResult = result = noErr;
-  
-  /* work around Nav Services "bug" (it returns invalid FSSpecs with empty names) */
-/*
-  if ( spec->name[0] == 0 )
-  {
-    result = FSMakeFSSpecCompat(spec->vRefNum, spec->parID, spec->name, &tempSpec);
-  }
-  else
-  {
-*/
-    /* Make a copy of the input FSSpec that can be modified */
-    BlockMoveData(spec, &tempSpec, sizeof(FSSpec));
-/*  }*/
-  
-  if ( result == noErr )
-  {
-    if ( tempSpec.parID == fsRtParID )
-    {
-      /* The object is a volume */
-      
-      /* Add a colon to make it a full pathname */
-      ++tempSpec.name[0];
-      tempSpec.name[tempSpec.name[0]] = ':';
-      
-      /* We're done */
-      result = PtrToHand(&tempSpec.name[1], fullPath, tempSpec.name[0]);
+    OSErr result, realResult;
+    FSSpec tempSpec;
+    CInfoPBRec pb;
+
+    *fullPathLength = 0;
+    *fullPath = NULL;
+
+    // default to noErr
+    realResult = result = noErr;
+
+  // work around Nav Services "bug" (it returns invalid FSSpecs with empty names)
+#if 0
+    if ( spec->name[0] == 0 )
+    {
+        result = FSMakeFSSpecCompat(spec->vRefNum, spec->parID, spec->name, &tempSpec);
      }
      else
      {
      }
      else
      {
-      /* The object isn't a volume */
-      
-      /* Is the object a file or a directory? */
-      pb.dirInfo.ioNamePtr = tempSpec.name;
-      pb.dirInfo.ioVRefNum = tempSpec.vRefNum;
-      pb.dirInfo.ioDrDirID = tempSpec.parID;
-      pb.dirInfo.ioFDirIndex = 0;
-      result = PBGetCatInfoSync(&pb);
-      /* Allow file/directory name at end of path to not exist. */
-      realResult = result;
-      if ( (result == noErr) || (result == fnfErr) )
-      {
-        /* if the object is a directory, append a colon so full pathname ends with colon */
-        if ( (result == noErr) && (pb.hFileInfo.ioFlAttrib & kioFlAttribDirMask) != 0 )
+#endif
+
+    // Make a copy of the input FSSpec that can be modified
+    BlockMoveData( spec, &tempSpec, sizeof(FSSpec) );
+
+    if ( result == noErr )
+    {
+        if ( tempSpec.parID == fsRtParID )
          {
          {
-          ++tempSpec.name[0];
-          tempSpec.name[tempSpec.name[0]] = ':';
+            // object is a volume
+            // Add a colon to make it a full pathname
+            ++tempSpec.name[0];
+            tempSpec.name[tempSpec.name[0]] = ':';
+
+            // We're done
+            result = PtrToHand(&tempSpec.name[1], fullPath, tempSpec.name[0]);
          }
          }
-        
-        /* Put the object name in first */
-        result = PtrToHand(&tempSpec.name[1], fullPath, tempSpec.name[0]);
-        if ( result == noErr )
+        else
          {
          {
-          /* Get the ancestor directory names */
-          pb.dirInfo.ioNamePtr = tempSpec.name;
-          pb.dirInfo.ioVRefNum = tempSpec.vRefNum;
-          pb.dirInfo.ioDrParID = tempSpec.parID;
-          do  /* loop until we have an error or find the root directory */
-          {
-            pb.dirInfo.ioFDirIndex = -1;
-            pb.dirInfo.ioDrDirID = pb.dirInfo.ioDrParID;
-            result = PBGetCatInfoSync(&pb);
-            if ( result == noErr )
+            // object isn't a volume
+
+            // Is the object a file or a directory?
+            pb.dirInfo.ioNamePtr = tempSpec.name;
+            pb.dirInfo.ioVRefNum = tempSpec.vRefNum;
+            pb.dirInfo.ioDrDirID = tempSpec.parID;
+            pb.dirInfo.ioFDirIndex = 0;
+            result = PBGetCatInfoSync( &pb );
+
+            // Allow file/directory name at end of path to not exist.
+            realResult = result;
+            if ((result == noErr) || (result == fnfErr))
              {
              {
-              /* Append colon to directory name */
-              ++tempSpec.name[0];
-              tempSpec.name[tempSpec.name[0]] = ':';
-              
-              /* Add directory name to beginning of fullPath */
-              (void) Munger(*fullPath, 0, NULL, 0, &tempSpec.name[1], tempSpec.name[0]);
-              result = MemError();
+                // if the object is a directory, append a colon so full pathname ends with colon
+                if ((result == noErr) && (pb.hFileInfo.ioFlAttrib & kioFlAttribDirMask) != 0)
+                {
+                    ++tempSpec.name[0];
+                    tempSpec.name[tempSpec.name[0]] = ':';
+                }
+
+                // Put the object name in first
+                result = PtrToHand( &tempSpec.name[1], fullPath, tempSpec.name[0] );
+                if ( result == noErr )
+                {
+                    // Get the ancestor directory names
+                    pb.dirInfo.ioNamePtr = tempSpec.name;
+                    pb.dirInfo.ioVRefNum = tempSpec.vRefNum;
+                    pb.dirInfo.ioDrParID = tempSpec.parID;
+
+                    // loop until we have an error or find the root directory
+                    do
+                    {
+                        pb.dirInfo.ioFDirIndex = -1;
+                        pb.dirInfo.ioDrDirID = pb.dirInfo.ioDrParID;
+                        result = PBGetCatInfoSync(&pb);
+                        if ( result == noErr )
+                        {
+                            // Append colon to directory name
+                            ++tempSpec.name[0];
+                            tempSpec.name[tempSpec.name[0]] = ':';
+
+                            // Add directory name to beginning of fullPath
+                            (void)Munger(*fullPath, 0, NULL, 0, &tempSpec.name[1], tempSpec.name[0]);
+                            result = MemError();
+                        }
+                    }
+                    while ( (result == noErr) && (pb.dirInfo.ioDrDirID != fsRtDirID) );
+                }
              }
              }
-          } while ( (result == noErr) && (pb.dirInfo.ioDrDirID != fsRtDirID) );
          }
          }
-      }
-    }
-  }
-  
-  if ( result == noErr )
-  {
-    /* Return the length */
-    *fullPathLength = GetHandleSize(*fullPath);
-    result = realResult;  /* return realResult in case it was fnfErr */
-  }
-  else
-  {
-    /* Dispose of the handle and return NULL and zero length */
-    if ( *fullPath != NULL )
-    {
-      DisposeHandle(*fullPath);
      }
      }
-    *fullPath = NULL;
-    *fullPathLength = 0;
-  }
-  
-  return ( result );
-}                
-                 
+
+    if ( result == noErr )
+    {
+        // Return the length
+        *fullPathLength = GetHandleSize( *fullPath );
+        result = realResult;  // return realResult in case it was fnfErr
+    }
+    else
+    {
+        // Dispose of the handle and return NULL and zero length
+        if ( *fullPath != NULL )
+        {
+            DisposeHandle( *fullPath );
+           *fullPath = NULL;
+        }
+        *fullPathLength = 0;
+    }
+
+    return result;
+}
+#endif // LP64
  //
  // On the mac there are two ways to open a file - one is through apple events and the
  // finder, another is through mime types.
  //
  // On the mac there are two ways to open a file - one is through apple events and the
  // finder, another is through mime types.
@@ -316,7 +328,7 @@ pascal  OSErr  FSpGetFullPath(const FSSpec *spec,
  // So, really there are two ways to implement wxFileType...
  //
  // Mime types are only available on OS 8.1+ through the InternetConfig API
  // So, really there are two ways to implement wxFileType...
  //
  // Mime types are only available on OS 8.1+ through the InternetConfig API
-// 
+//
  // Much like the old-style file manager, it has 3 levels of flexibility for its methods -
  // Low - which means you have to iterate yourself through the mime database
  // Medium - which lets you sort of cache the database if you want to use lowlevel functions
  // Much like the old-style file manager, it has 3 levels of flexibility for its methods -
  // Low - which means you have to iterate yourself through the mime database
  // Medium - which lets you sort of cache the database if you want to use lowlevel functions
@@ -329,26 +341,26 @@ pascal  OSErr  FSpGetFullPath(const FSSpec *spec,
  //
  
  // debug helper
  //
  
  // debug helper
-inline void wxLogMimeDebug(const wxChar* szMsg, OSStatus status)
+inline void wxLogMimeDebug(const wxChar* WXUNUSED_UNLESS_DEBUG(szMsg), OSStatus WXUNUSED_UNLESS_DEBUG(status))
  {
      wxLogDebug(wxString::Format(wxT("%s  LINE:%i  OSERROR:%i"), szMsg, __LINE__, (int)status));
  }
  
  // in case we're compiling in non-GUI mode
  {
      wxLogDebug(wxString::Format(wxT("%s  LINE:%i  OSERROR:%i"), szMsg, __LINE__, (int)status));
  }
  
  // in case we're compiling in non-GUI mode
-class WXDLLEXPORT wxIcon;
+class WXDLLIMPEXP_FWD_CORE wxIcon;
  
  
-bool wxFileTypeImpl::SetCommand(const wxString& cmd, const wxString& verb, bool overwriteprompt)
+bool wxFileTypeImpl::SetCommand(const wxString& WXUNUSED(cmd), const wxString& WXUNUSED(verb), bool WXUNUSED(overwriteprompt))
  {
      wxASSERT_MSG( m_manager != NULL , wxT("Bad wxFileType") );
  
  {
      wxASSERT_MSG( m_manager != NULL , wxT("Bad wxFileType") );
  
-    return FALSE;
+    return false;
  }
  
  }
  
-bool wxFileTypeImpl::SetDefaultIcon(const wxString& strIcon, int index)
+bool wxFileTypeImpl::SetDefaultIcon(const wxString& WXUNUSED(strIcon), int WXUNUSED(index))
  {
      wxASSERT_MSG( m_manager != NULL , wxT("Bad wxFileType") );
  
  {
      wxASSERT_MSG( m_manager != NULL , wxT("Bad wxFileType") );
  
-    return FALSE;
+    return false;
  }
  
  bool wxFileTypeImpl::GetOpenCommand(wxString *openCmd,
  }
  
  bool wxFileTypeImpl::GetOpenCommand(wxString *openCmd,
@@ -362,9 +374,9 @@ bool wxFileTypeImpl::GetOpenCommand(wxString *openCmd,
  }
  
  bool
  }
  
  bool
-wxFileTypeImpl::GetPrintCommand(wxString *printCmd,
-                                const wxFileType::MessageParameters& params)
-                                const
+wxFileTypeImpl::GetPrintCommand(
+    wxString *printCmd,
+    const wxFileType::MessageParameters& params) const
  {
      wxString cmd = GetCommand(wxT("print"));
  
  {
      wxString cmd = GetCommand(wxT("print"));
  
@@ -377,7 +389,7 @@ wxFileTypeImpl::GetPrintCommand(wxString *printCmd,
  // Internet Config vs. Launch Services
  //
  // From OS 8 on there was internet config...
  // Internet Config vs. Launch Services
  //
  // From OS 8 on there was internet config...
-// However, OSX and its finder does not use info 
+// However, OSX and its finder does not use info
  // from Internet Config at all - the Internet Config
  // database ONLY CONTAINS APPS THAT ARE CLASSIC APPS
  // OR REGISTERED THROUGH INTERNET CONFIG
  // from Internet Config at all - the Internet Config
  // database ONLY CONTAINS APPS THAT ARE CLASSIC APPS
  // OR REGISTERED THROUGH INTERNET CONFIG
@@ -386,172 +398,118 @@ wxFileTypeImpl::GetPrintCommand(wxString *printCmd,
  // we need to go straight to launch services
  //
  
  // we need to go straight to launch services
  //
  
-#if defined(__DARWIN__)
-
  //on darwin, use launch services
  //on darwin, use launch services
-#include "LaunchServices.h"
+
+#include <ApplicationServices/ApplicationServices.h>
  
  wxString wxFileTypeImpl::GetCommand(const wxString& verb) const
  {
      wxASSERT_MSG( m_manager != NULL , wxT("Bad wxFileType") );
  
  wxString wxFileTypeImpl::GetCommand(const wxString& verb) const
  {
      wxASSERT_MSG( m_manager != NULL , wxT("Bad wxFileType") );
-        
-    if(verb == wxT("open"))
+
+    if (verb == wxT("open"))
      {
          ICMapEntry entry;
      {
          ICMapEntry entry;
-        ICGetMapEntry( (ICInstance) m_manager->m_hIC, 
-                       (Handle) m_manager->m_hDatabase, 
+        ICGetMapEntry( (ICInstance) m_manager->m_hIC,
+                       (Handle) m_manager->m_hDatabase,
                         m_lIndex, &entry);
                         m_lIndex, &entry);
-        
+
          wxString sCurrentExtension = wxMacMakeStringFromPascal(entry.extension);
          wxString sCurrentExtension = wxMacMakeStringFromPascal(entry.extension);
-        sCurrentExtension = sCurrentExtension.Right(sCurrentExtension.Length()-1 );
+        sCurrentExtension = sCurrentExtension.Right(sCurrentExtension.length()-1 );
  
          //type, creator, ext, roles, outapp (FSRef), outappurl
          CFURLRef cfurlAppPath;
  
          //type, creator, ext, roles, outapp (FSRef), outappurl
          CFURLRef cfurlAppPath;
-        OSStatus status = LSGetApplicationForInfo (kLSUnknownType,
-            kLSUnknownCreator, 
-            wxMacCFStringHolder(sCurrentExtension, wxLocale::GetSystemEncoding()), 
-            kLSRolesAll, 
+        OSStatus status = LSGetApplicationForInfo( kLSUnknownType,
+            kLSUnknownCreator,
+            wxMacCFStringHolder(sCurrentExtension, wxLocale::GetSystemEncoding()),
+            kLSRolesAll,
              NULL,
              NULL,
-            &cfurlAppPath);
-        
-        if(status == noErr)
+            &cfurlAppPath );
+
+        if (status == noErr)
          {
              CFStringRef cfsUnixPath = CFURLCopyFileSystemPath(cfurlAppPath, kCFURLPOSIXPathStyle);
              CFRelease(cfurlAppPath);
          {
              CFStringRef cfsUnixPath = CFURLCopyFileSystemPath(cfurlAppPath, kCFURLPOSIXPathStyle);
              CFRelease(cfurlAppPath);
-                
-            //PHEW!  Success!
-            if(cfsUnixPath)
-                return wxMacCFStringHolder(cfsUnixPath).AsString(wxLocale::GetSystemEncoding());            
-        }
-        else
-        {
-            wxLogDebug(wxString::Format(wxT("%i - %s - %i"), 
-            __LINE__, 
-            wxT("LSGetApplicationForInfo failed."),
-            (int)status)); 
-        }
-    }
-    
-    return wxEmptyString;
-}
-
-#else //carbon/classic implementation
  
  
-wxString wxFileTypeImpl::GetCommand(const wxString& verb) const
-{
-    wxASSERT_MSG( m_manager != NULL , wxT("Bad wxFileType") );
-        
-    if(verb == wxT("open"))
-    {
-        ICMapEntry entry;
-        ICGetMapEntry( (ICInstance) m_manager->m_hIC, 
-                       (Handle) m_manager->m_hDatabase, 
-                       m_lIndex, &entry);
-        
-        //The entry in the mimetype database only contains the app
-        //that's registered - it may not exist... we need to remap the creator
-        //type and find the right application
-                
-        // THIS IS REALLY COMPLICATED :\.  There are a lot of conversions going
-        // on here.
-        Str255 outName;
-        FSSpec outSpec;
-        if(FindApplication(entry.fileCreator, false, outName, &outSpec) != noErr)
-            return wxEmptyString;
-            
-        Handle outPathHandle;
-        short outPathSize;
-        OSErr err = FSpGetFullPath(&outSpec, &outPathSize, &outPathHandle);
-        
-        if(err == noErr)
-        {
-            char* szPath = *outPathHandle;
-            wxString sClassicPath(szPath, wxConvLocal, outPathSize);
-#if defined(__DARWIN__)
-            //Classic Path --> Unix (OSX) Path
-            CFURLRef finalURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, 
-                        wxMacCFStringHolder(sClassicPath, wxLocale::GetSystemEncoding()), 
-                        kCFURLHFSPathStyle,
-                        false); //false == not a directory
-
-            //clean up memory from the classic path handle
-            DisposeHandle(outPathHandle);
-            
-            if(finalURL)
+            // PHEW!  Success!
+            // Since a filename might have spaces in it, so surround it with quotes
+            if (cfsUnixPath)
              {
              {
-                CFStringRef cfsUnixPath = CFURLCopyFileSystemPath(finalURL, kCFURLPOSIXPathStyle);
-                CFRelease(finalURL);
-                
-                //PHEW!  Success!
-                if(cfsUnixPath)
-                    return wxMacCFStringHolder(cfsUnixPath).AsString(wxLocale::GetSystemEncoding());
+                wxString resultStr;
+
+                resultStr =
+                    wxString(wxT("'"))
+                    + wxMacCFStringHolder(cfsUnixPath).AsString(wxLocale::GetSystemEncoding())
+                    + wxString(wxT("'"));
+
+               return resultStr;
              }
              }
-#else //classic HFS path acceptable
-            return sClassicPath;
-#endif
          }
          else
          {
          }
          else
          {
-            wxLogMimeDebug(wxT("FSpGetFullPath failed."), (OSStatus)err);
+            wxLogDebug(wxString::Format(wxT("%i - %s - %i"),
+            __LINE__,
+            wxT("LSGetApplicationForInfo failed."),
+            (int)status));
          }
      }
          }
      }
+
      return wxEmptyString;
  }
      return wxEmptyString;
  }
-#endif //!DARWIN
  
  bool wxFileTypeImpl::GetDescription(wxString *desc) const
  {
      wxASSERT_MSG( m_manager != NULL , wxT("Bad wxFileType") );
  
  bool wxFileTypeImpl::GetDescription(wxString *desc) const
  {
      wxASSERT_MSG( m_manager != NULL , wxT("Bad wxFileType") );
-    
+
      ICMapEntry entry;
      ICMapEntry entry;
-    ICGetMapEntry( (ICInstance) m_manager->m_hIC, 
-                   (Handle) m_manager->m_hDatabase, 
-                   m_lIndex, &entry);
-    
-    *desc = wxMacMakeStringFromPascal(entry.entryName);
+    ICGetMapEntry( (ICInstance) m_manager->m_hIC,
+        (Handle) m_manager->m_hDatabase, m_lIndex, &entry );
+
+    *desc = wxMacMakeStringFromPascal( entry.entryName );
+
      return true;
  }
  
  bool wxFileTypeImpl::GetExtensions(wxArrayString& extensions)
  {
      wxASSERT_MSG( m_manager != NULL , wxT("Bad wxFileType") );
      return true;
  }
  
  bool wxFileTypeImpl::GetExtensions(wxArrayString& extensions)
  {
      wxASSERT_MSG( m_manager != NULL , wxT("Bad wxFileType") );
-    
+
      ICMapEntry entry;
      ICMapEntry entry;
-    ICGetMapEntry( (ICInstance) m_manager->m_hIC, 
-                   (Handle) m_manager->m_hDatabase, 
-                   m_lIndex, &entry);
-    
+    ICGetMapEntry( (ICInstance) m_manager->m_hIC,
+        (Handle) m_manager->m_hDatabase, m_lIndex, &entry );
+
      //entry has period in it
      //entry has period in it
-    wxString sCurrentExtension = wxMacMakeStringFromPascal(entry.extension);
-    extensions.Add( sCurrentExtension.Right(sCurrentExtension.Length()-1) );
+    wxString sCurrentExtension = wxMacMakeStringFromPascal( entry.extension );
+    extensions.Add( sCurrentExtension.Right( sCurrentExtension.length() - 1 ) );
+
      return true;
  }
  
  bool wxFileTypeImpl::GetMimeType(wxString *mimeType) const
  {
      wxASSERT_MSG( m_manager != NULL , wxT("Bad wxFileType") );
      return true;
  }
  
  bool wxFileTypeImpl::GetMimeType(wxString *mimeType) const
  {
      wxASSERT_MSG( m_manager != NULL , wxT("Bad wxFileType") );
-    
+
      ICMapEntry entry;
      ICMapEntry entry;
-    ICGetMapEntry( (ICInstance) m_manager->m_hIC, 
-                   (Handle) m_manager->m_hDatabase, 
-                   m_lIndex, &entry);
-    
+    ICGetMapEntry( (ICInstance) m_manager->m_hIC,
+        (Handle) m_manager->m_hDatabase, m_lIndex, &entry );
+
      *mimeType = wxMacMakeStringFromPascal(entry.MIMEType);
      *mimeType = wxMacMakeStringFromPascal(entry.MIMEType);
+
      return true;
  }
  
  bool wxFileTypeImpl::GetMimeTypes(wxArrayString& mimeTypes) const
  {
      wxString s;
      return true;
  }
  
  bool wxFileTypeImpl::GetMimeTypes(wxArrayString& mimeTypes) const
  {
      wxString s;
-    
+
      if (GetMimeType(&s))
      {
          mimeTypes.Clear();
          mimeTypes.Add(s);
      if (GetMimeType(&s))
      {
          mimeTypes.Clear();
          mimeTypes.Add(s);
-        return TRUE;
+
+        return true;
      }
      }
-    else 
-        return FALSE;
+
+    return false;
  }
  
  bool wxFileTypeImpl::GetIcon(wxIconLocation *WXUNUSED(icon)) const
  }
  
  bool wxFileTypeImpl::GetIcon(wxIconLocation *WXUNUSED(icon)) const
@@ -559,55 +517,57 @@ bool wxFileTypeImpl::GetIcon(wxIconLocation *WXUNUSED(icon)) const
      wxASSERT_MSG( m_manager != NULL , wxT("Bad wxFileType") );
  
      // no such file type or no value or incorrect icon entry
      wxASSERT_MSG( m_manager != NULL , wxT("Bad wxFileType") );
  
      // no such file type or no value or incorrect icon entry
-    return FALSE;
+    return false;
  }
  
  }
  
-size_t wxFileTypeImpl::GetAllCommands(wxArrayString * verbs, wxArrayString * commands,
-                   const wxFileType::MessageParameters& params) const
+size_t wxFileTypeImpl::GetAllCommands(wxArrayString * verbs,
+    wxArrayString * commands,
+    const wxFileType::MessageParameters& params) const
  {
      wxASSERT_MSG( m_manager != NULL , wxT("Bad wxFileType") );
  
      wxString sCommand;
      size_t ulCount = 0;
  {
      wxASSERT_MSG( m_manager != NULL , wxT("Bad wxFileType") );
  
      wxString sCommand;
      size_t ulCount = 0;
-    
-    if(GetOpenCommand(&sCommand, params))
+
+    if (GetOpenCommand(&sCommand, params))
      {
          verbs->Add(wxString(wxT("open")));
          commands->Add(sCommand);
          ++ulCount;
      }
      {
          verbs->Add(wxString(wxT("open")));
          commands->Add(sCommand);
          ++ulCount;
      }
-    
+
      return ulCount;
  }
  
      return ulCount;
  }
  
-void wxMimeTypesManagerImpl::Initialize(int mailcapStyles, const wxString& extraDir)
+void wxMimeTypesManagerImpl::Initialize(int WXUNUSED(mailcapStyles), const wxString& WXUNUSED(extraDir))
  {
      wxASSERT_MSG(m_hIC == NULL, wxT("Already initialized wxMimeTypesManager!"));
  
  {
      wxASSERT_MSG(m_hIC == NULL, wxT("Already initialized wxMimeTypesManager!"));
  
-    //some apps (non-wx) use the 'plst' resource instead
-/*
+    // some apps (non-wx) use the 'plst' resource instead
+#if 0
      CFBundleRef cfbMain = CFBundleGetMainBundle();
      wxCFDictionary cfdInfo( CFBundleGetInfoDictionary(cfbMain), wxCF_RETAIN );
      wxString sLog;
      cfdInfo.PrintOut(sLog);
      wxLogDebug(sLog);
      CFBundleRef cfbMain = CFBundleGetMainBundle();
      wxCFDictionary cfdInfo( CFBundleGetInfoDictionary(cfbMain), wxCF_RETAIN );
      wxString sLog;
      cfdInfo.PrintOut(sLog);
      wxLogDebug(sLog);
-*/
+#endif
+
+    // start Internet Config - log if there's an error
+    // the second param is the signature of the application, also known
+    // as resource ID 0.  However, as per some recent discussions, we may not
+    // have a signature for this app, so a generic 'APPL' which is the executable
+    // type will work for now.
+    OSStatus status = ICStart( (ICInstance*)&m_hIC, 'APPL' );
  
  
-    //start internet config - log if there's an error
-    //the second param is the signature of the application, also known
-    //as resource ID 0.  However, as per some recent discussions, we may not
-    //have a signature for this app, so a generic 'APPL' which is the executable 
-    //type will work for now
-    OSStatus status = ICStart( (ICInstance*) &m_hIC, 'APPL'); 
-    
-    if(status != noErr)
+    if (status != noErr)
      {
          wxLogDebug(wxT("Could not initialize wxMimeTypesManager!"));
      {
          wxLogDebug(wxT("Could not initialize wxMimeTypesManager!"));
-        wxASSERT( false );
+        wxFAIL;
          m_hIC = NULL;
          m_hIC = NULL;
+
          return;
      }
          return;
      }
-    
+
      ICAttr attr;
      m_hDatabase = (void**) NewHandle(0);
      status = ICFindPrefHandle( (ICInstance) m_hIC, kICMapping, &attr, (Handle) m_hDatabase );
      ICAttr attr;
      m_hDatabase = (void**) NewHandle(0);
      status = ICFindPrefHandle( (ICInstance) m_hIC, kICMapping, &attr, (Handle) m_hDatabase );
@@ -615,55 +575,55 @@ void wxMimeTypesManagerImpl::Initialize(int mailcapStyles, const wxString& extra
      //the database file can be corrupt (on OSX its
      //~/Library/Preferences/com.apple.internetconfig.plist)
      //- bail if it is
      //the database file can be corrupt (on OSX its
      //~/Library/Preferences/com.apple.internetconfig.plist)
      //- bail if it is
-    if(status != noErr)
+    if (status != noErr)
      {
          ClearData();
      {
          ClearData();
-        wxLogDebug(wxT("Corrupt Mime Database!"));
+        wxLogDebug(wxT("Corrupt MIME database!"));
          return;
      }
  
      //obtain the number of entries in the map
      status = ICCountMapEntries( (ICInstance) m_hIC, (Handle) m_hDatabase, &m_lCount );
      wxASSERT( status == noErr );
          return;
      }
  
      //obtain the number of entries in the map
      status = ICCountMapEntries( (ICInstance) m_hIC, (Handle) m_hDatabase, &m_lCount );
      wxASSERT( status == noErr );
-    /*
+
+#if 0
      //debug stuff
      ICMapEntry entry;
      long pos;
      //debug stuff
      ICMapEntry entry;
      long pos;
-    
-    for(long i = 1; i <= m_lCount; ++i)
+
+    for (long i = 1; i <= m_lCount; ++i)
      {
      {
-        OSStatus status = ICGetIndMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase, i, &pos, &entry);
-        
-        if(status == noErr)
-        {       
+        OSStatus status = ICGetIndMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase, i, &pos, &entry );
+
+        if (status == noErr)
+        {
              wxString sCreator = wxMacMakeStringFromPascal(entry.creatorAppName);
              wxString sCurrentExtension = wxMacMakeStringFromPascal(entry.extension);
              wxString sMIMEType = wxMacMakeStringFromPascal(entry.MIMEType);
              wxString sCreator = wxMacMakeStringFromPascal(entry.creatorAppName);
              wxString sCurrentExtension = wxMacMakeStringFromPascal(entry.extension);
              wxString sMIMEType = wxMacMakeStringFromPascal(entry.MIMEType);
-            
+
              wxFileTypeImpl impl;
              impl.Init(this, pos);
              wxFileTypeImpl impl;
              impl.Init(this, pos);
-            
-            if(sMIMEType == wxT("text/html") && sCurrentExtension == wxT(".html"))
+
+            if (sMIMEType == wxT("text/html") && sCurrentExtension == wxT(".html"))
              {
                  wxString cmd;
              {
                  wxString cmd;
-                    impl.GetOpenCommand (&cmd, 
-        wxFileType::MessageParameters (wxT("http://www.google.com"), 
-                                       _T(""))); 
  
  
+                impl.GetOpenCommand( &cmd, wxFileType::MessageParameters (wxT("http://www.google.com")));
                  wxPrintf(wxT("APP: [%s]\n"), cmd.c_str());
              }
          }
      }
                  wxPrintf(wxT("APP: [%s]\n"), cmd.c_str());
              }
          }
      }
-        */
+#endif
  }
  
  void wxMimeTypesManagerImpl::ClearData()
  {
  }
  
  void wxMimeTypesManagerImpl::ClearData()
  {
-    if(m_hIC != NULL)
+    if (m_hIC != NULL)
      {
      {
-        DisposeHandle((Handle)m_hDatabase);
-        //this can return an error, but we don't really care that much about it
-        ICStop( (ICInstance) m_hIC );
+        DisposeHandle( (Handle)m_hDatabase );
+
+        // this can return an error, but we don't really care that much about it
+        ICStop( (ICInstance)m_hIC );
          m_hIC = NULL;
      }
  }
          m_hIC = NULL;
      }
  }
@@ -677,28 +637,29 @@ void wxMimeTypesManagerImpl::ClearData()
  wxFileType* wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& e)
  {
      wxASSERT_MSG( m_hIC != NULL, wxT("wxMimeTypesManager not Initialized!") );
  wxFileType* wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& e)
  {
      wxASSERT_MSG( m_hIC != NULL, wxT("wxMimeTypesManager not Initialized!") );
-    
-    //low level functions - iterate through the database    
+
+    //low level functions - iterate through the database
      ICMapEntry entry;
      long pos;
      ICMapEntry entry;
      long pos;
-    
-    for(long i = 1; i <= m_lCount; ++i)
+
+    for (long i = 1; i <= m_lCount; ++i)
      {
      {
-        OSStatus status = ICGetIndMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase, i, &pos, &entry);
-        
-        if(status == noErr)
-        {       
+        OSStatus status = ICGetIndMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase, i, &pos, &entry );
+
+        if (status == noErr)
+        {
              wxString sCurrentExtension = wxMacMakeStringFromPascal(entry.extension);
              wxString sCurrentExtension = wxMacMakeStringFromPascal(entry.extension);
-            if( sCurrentExtension.Right(sCurrentExtension.Length()-1) == e ) //entry has period in it
+            if ( sCurrentExtension.Right(sCurrentExtension.length() - 1) == e ) // entry has period in it
              {
                  wxFileType* pFileType = new wxFileType();
                  pFileType->m_impl->Init((wxMimeTypesManagerImpl*)this, pos);
              {
                  wxFileType* pFileType = new wxFileType();
                  pFileType->m_impl->Init((wxMimeTypesManagerImpl*)this, pos);
+
                  return pFileType;
              }
          }
      }
                  return pFileType;
              }
          }
      }
-    
-    return NULL;    
+
+    return NULL;
  }
  
  // MIME type -> extension -> file type
  }
  
  // MIME type -> extension -> file type
@@ -706,26 +667,27 @@ wxFileType* wxMimeTypesManagerImpl::GetFileTypeFromMimeType(const wxString& mime
  {
      wxASSERT_MSG( m_hIC != NULL, wxT("wxMimeTypesManager not Initialized!") );
  
  {
      wxASSERT_MSG( m_hIC != NULL, wxT("wxMimeTypesManager not Initialized!") );
  
-    //low level functions - iterate through the database    
      ICMapEntry entry;
      long pos;
      ICMapEntry entry;
      long pos;
-    
-    for(long i = 1; i <= m_lCount; ++i)
+
+    // low level functions - iterate through the database
+    for (long i = 1; i <= m_lCount; ++i)
      {
      {
-        OSStatus status = ICGetIndMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase, i, &pos, &entry);
+        OSStatus status = ICGetIndMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase, i, &pos, &entry );
          wxASSERT_MSG( status == noErr, wxString::Format(wxT("Error: %d"), (int)status) );
          wxASSERT_MSG( status == noErr, wxString::Format(wxT("Error: %d"), (int)status) );
-        
-        if(status == noErr)
-        {        
-            if( wxMacMakeStringFromPascal(entry.MIMEType) == mimeType)
+
+        if (status == noErr)
+        {
+            if ( wxMacMakeStringFromPascal(entry.MIMEType) == mimeType)
              {
                  wxFileType* pFileType = new wxFileType();
                  pFileType->m_impl->Init((wxMimeTypesManagerImpl*)this, pos);
              {
                  wxFileType* pFileType = new wxFileType();
                  pFileType->m_impl->Init((wxMimeTypesManagerImpl*)this, pos);
+
                  return pFileType;
              }
          }
      }
                  return pFileType;
              }
          }
      }
-    
+
      return NULL;
  }
  
      return NULL;
  }
  
@@ -733,52 +695,55 @@ size_t wxMimeTypesManagerImpl::EnumAllFileTypes(wxArrayString& mimetypes)
  {
      wxASSERT_MSG( m_hIC != NULL, wxT("wxMimeTypesManager not Initialized!") );
  
  {
      wxASSERT_MSG( m_hIC != NULL, wxT("wxMimeTypesManager not Initialized!") );
  
-    //low level functions - iterate through the database    
      ICMapEntry entry;
      ICMapEntry entry;
-    long pos;
-    
-    long lStartCount = (long) mimetypes.GetCount();
-    
-    for(long i = 1; i <= m_lCount; ++i)
+    long pos, lStartCount;
+
+    // low level functions - iterate through the database
+    lStartCount = (long) mimetypes.GetCount();
+    for (long i = 1; i <= m_lCount; ++i)
      {
      {
-        OSStatus status = ICGetIndMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase, i, &pos, &entry);
-        if( status == noErr )
+        OSStatus status = ICGetIndMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase, i, &pos, &entry );
+        if ( status == noErr )
              mimetypes.Add( wxMacMakeStringFromPascal(entry.MIMEType) );
      }
              mimetypes.Add( wxMacMakeStringFromPascal(entry.MIMEType) );
      }
-    
+
      return mimetypes.GetCount() - lStartCount;
  }
  
      return mimetypes.GetCount() - lStartCount;
  }
  
-
  pascal  OSStatus  MoreProcGetProcessTypeSignature(
  pascal  OSStatus  MoreProcGetProcessTypeSignature(
-            const ProcessSerialNumberPtr pPSN,
-            OSType *pProcessType,
-            OSType *pCreator)
+    const ProcessSerialNumberPtr pPSN,
+    OSType *pProcessType,
+    OSType *pCreator)
  {
  {
-  OSStatus      anErr = noErr;  
-  ProcessInfoRec    infoRec;
-  ProcessSerialNumber localPSN;
-  
-  infoRec.processInfoLength = sizeof(ProcessInfoRec);
-  infoRec.processName = nil;
-  infoRec.processAppSpec = nil;
-
-  if ( pPSN == nil ) {
-    localPSN.highLongOfPSN = 0;
-    localPSN.lowLongOfPSN  = kCurrentProcess;
-  } else {
-    localPSN = *pPSN;
-  }
-  
-  anErr = GetProcessInformation(&localPSN, &infoRec);
-  if (anErr == noErr)
-  {
-    *pProcessType = infoRec.processType;
-    *pCreator = infoRec.processSignature;
-  }
-  
-  return anErr;
-}//end MoreProcGetProcessTypeSignature
+    OSStatus anErr = noErr;
+    ProcessInfoRec infoRec;
+    ProcessSerialNumber localPSN;
+
+    infoRec.processInfoLength = sizeof(ProcessInfoRec);
+    infoRec.processName = NULL;
+#ifndef __LP64__
+    infoRec.processAppSpec = NULL;
+#endif
+
+    if ( pPSN == NULL )
+    {
+        localPSN.highLongOfPSN = 0;
+        localPSN.lowLongOfPSN  = kCurrentProcess;
+    }
+    else
+    {
+        localPSN = *pPSN;
+    }
+
+    anErr = GetProcessInformation(&localPSN, &infoRec);
+    if (anErr == noErr)
+    {
+        *pProcessType = infoRec.processType;
+        *pCreator = infoRec.processSignature;
+    }
+
+    return anErr;
+}
  
  //
  //
  
  //
  //
@@ -788,7 +753,6 @@ pascal  OSStatus  MoreProcGetProcessTypeSignature(
  //
  
  #include "wx/mac/corefoundation/cfstring.h"
  //
  
  #include "wx/mac/corefoundation/cfstring.h"
-#include "wx/intl.h" //wxLocale for wxCFString
  
  #define wxCF_RELEASE true
  #define wxCF_RETAIN  false
  
  #define wxCF_RELEASE true
  #define wxCF_RETAIN  false
@@ -803,10 +767,10 @@ public:
      wxCFDictionary(CFTypeRef ref, bool bRetain = wxCF_RELEASE)
      {
          m_cfmdRef = (CFMutableDictionaryRef) ref;
      wxCFDictionary(CFTypeRef ref, bool bRetain = wxCF_RELEASE)
      {
          m_cfmdRef = (CFMutableDictionaryRef) ref;
-        if(bRetain == wxCF_RETAIN && ref)
+        if (bRetain == wxCF_RETAIN && ref)
              CFRetain(ref);
      }
              CFRetain(ref);
      }
-    
+
      wxCFDictionary(CFIndex cfiSize = 0)
      {
          CFDictionaryKeyCallBacks kcbs;
      wxCFDictionary(CFIndex cfiSize = 0)
      {
          CFDictionaryKeyCallBacks kcbs;
@@ -815,34 +779,34 @@ public:
          BuildValueCallbacks(&vcbs);
  
          m_cfmdRef = CFDictionaryCreateMutable(
          BuildValueCallbacks(&vcbs);
  
          m_cfmdRef = CFDictionaryCreateMutable(
-            kCFAllocatorDefault, cfiSize, &kcbs, &vcbs);
-
+            kCFAllocatorDefault, cfiSize, &kcbs, &vcbs );
      }
      }
-    
-    ~wxCFDictionary() 
-    { Clear(); }
-    
+
+    ~wxCFDictionary()
+    { Clear(); }
+
      void Clear()
      void Clear()
-    {if(m_cfmdRef) CFRelease(m_cfmdRef);}
-    
+    {
+        if (m_cfmdRef)
+            CFRelease(m_cfmdRef);
+    }
+
      static const void* RetainProc(CFAllocatorRef, const void* v)
      static const void* RetainProc(CFAllocatorRef, const void* v)
-    {  return (const void*) CFRetain(v);       }
-    
+    { return (const void*) CFRetain(v); }
+
      static void ReleaseProc(CFAllocatorRef, const void* v)
      static void ReleaseProc(CFAllocatorRef, const void* v)
-    {  CFRelease(v);   }
+    { CFRelease(v); }
  
      void MakeMutable(CFIndex cfiSize = 0)
      {
          CFDictionaryRef oldref = (CFDictionaryRef) m_cfmdRef;
  
      void MakeMutable(CFIndex cfiSize = 0)
      {
          CFDictionaryRef oldref = (CFDictionaryRef) m_cfmdRef;
-                
+
          m_cfmdRef = CFDictionaryCreateMutableCopy(
          m_cfmdRef = CFDictionaryCreateMutableCopy(
-            kCFAllocatorDefault,
-            cfiSize, 
-            oldref);
-            
-        CFRelease(oldref);
+            kCFAllocatorDefault, cfiSize, oldref );
+
+        CFRelease( oldref );
      }
      }
-    
+
      void BuildKeyCallbacks(CFDictionaryKeyCallBacks* pCbs)
      {
          pCbs->version = 0;
      void BuildKeyCallbacks(CFDictionaryKeyCallBacks* pCbs)
      {
          pCbs->version = 0;
@@ -863,60 +827,59 @@ public:
      }
  
      operator CFTypeRef () const
      }
  
      operator CFTypeRef () const
-    {  return (CFTypeRef)m_cfmdRef;    }
-    
+    { return (CFTypeRef)m_cfmdRef; }
+
      CFDictionaryRef GetCFDictionary() const
      CFDictionaryRef GetCFDictionary() const
-    {  return (CFDictionaryRef)m_cfmdRef;      }
+    { return (CFDictionaryRef)m_cfmdRef; }
  
      CFMutableDictionaryRef GetCFMutableDictionary()
  
      CFMutableDictionaryRef GetCFMutableDictionary()
-    {  return (CFMutableDictionaryRef) m_cfmdRef;      }
+    { return (CFMutableDictionaryRef) m_cfmdRef; }
  
      CFTypeRef operator [] (CFTypeRef cftEntry) const
  
      CFTypeRef operator [] (CFTypeRef cftEntry) const
-    {  
+    {
          wxASSERT(IsValid());
          wxASSERT(IsValid());
-        return (CFTypeRef) CFDictionaryGetValue((CFDictionaryRef)m_cfmdRef, cftEntry); 
-    }    
-    
+        return (CFTypeRef) CFDictionaryGetValue((CFDictionaryRef)m_cfmdRef, cftEntry);
+    }
+
      CFIndex GetCount() const
      CFIndex GetCount() const
-    {  
+    {
          wxASSERT(IsValid());
          wxASSERT(IsValid());
-        return CFDictionaryGetCount((CFDictionaryRef)m_cfmdRef);       
+        return CFDictionaryGetCount((CFDictionaryRef)m_cfmdRef);
      }
      }
-    
+
      void Add(CFTypeRef cftKey, CFTypeRef cftValue)
      {
          wxASSERT(IsValid());
          wxASSERT(Exists(cftKey) == false);
      void Add(CFTypeRef cftKey, CFTypeRef cftValue)
      {
          wxASSERT(IsValid());
          wxASSERT(Exists(cftKey) == false);
-        CFDictionaryAddValue(m_cfmdRef, cftKey, cftValue);     
+        CFDictionaryAddValue(m_cfmdRef, cftKey, cftValue);
      }
      }
-    
+
      void Remove(CFTypeRef cftKey)
      void Remove(CFTypeRef cftKey)
-    {  
+    {
          wxASSERT(IsValid());
          wxASSERT(Exists(cftKey));
          wxASSERT(IsValid());
          wxASSERT(Exists(cftKey));
-        CFDictionaryRemoveValue(m_cfmdRef, cftKey);    
+        CFDictionaryRemoveValue(m_cfmdRef, cftKey);
      }
      }
-    
+
      void Set(CFTypeRef cftKey, CFTypeRef cftValue)
      void Set(CFTypeRef cftKey, CFTypeRef cftValue)
-    {  
+    {
          wxASSERT(IsValid());
          wxASSERT(Exists(cftKey));
          wxASSERT(IsValid());
          wxASSERT(Exists(cftKey));
-        CFDictionarySetValue(m_cfmdRef, cftKey, cftValue);     
+        CFDictionarySetValue(m_cfmdRef, cftKey, cftValue);
      }
      }
-    
+
      bool Exists(CFTypeRef cftKey) const
      {
          wxASSERT(IsValid());
      bool Exists(CFTypeRef cftKey) const
      {
          wxASSERT(IsValid());
-        return CFDictionaryContainsKey((CFDictionaryRef)m_cfmdRef, cftKey) == true;
+        return CFDictionaryContainsKey((CFDictionaryRef)m_cfmdRef, cftKey);
      }
      }
-    
-    bool IsOk() const {return m_cfmdRef != NULL;       }
+
+    bool IsOk() const
+    { return m_cfmdRef != NULL; }
  
      bool IsValid() const
  
      bool IsValid() const
-    {
-        return IsOk() && CFGetTypeID((CFTypeRef)m_cfmdRef) == CFDictionaryGetTypeID();
-    }
-    
+    { return IsOk() && CFGetTypeID((CFTypeRef)m_cfmdRef) == CFDictionaryGetTypeID(); }
+
      void PrintOut(wxString& sMessage)
      {
          PrintOutDictionary(sMessage, m_cfmdRef);
      void PrintOut(wxString& sMessage)
      {
          PrintOutDictionary(sMessage, m_cfmdRef);
@@ -929,75 +892,74 @@ public:
          CFTypeRef* pValues = new CFTypeRef[cfiCount];
  
          CFDictionaryGetKeysAndValues(cfdRef, pKeys, pValues);
          CFTypeRef* pValues = new CFTypeRef[cfiCount];
  
          CFDictionaryGetKeysAndValues(cfdRef, pKeys, pValues);
- 
-        for(CFIndex i = 0; i < cfiCount; ++i)
+
+        for (CFIndex i = 0; i < cfiCount; ++i)
          {
              wxString sKey = wxMacCFStringHolder(CFCopyTypeIDDescription(CFGetTypeID(pKeys[i]))).AsString();
              wxString sValue = wxMacCFStringHolder(CFCopyTypeIDDescription(CFGetTypeID(pValues[i]))).AsString();
          {
              wxString sKey = wxMacCFStringHolder(CFCopyTypeIDDescription(CFGetTypeID(pKeys[i]))).AsString();
              wxString sValue = wxMacCFStringHolder(CFCopyTypeIDDescription(CFGetTypeID(pValues[i]))).AsString();
-            
-            sMessage << 
+
+            sMessage <<
                  wxString::Format(wxT("[{#%d} Key : %s]"), (int) i,
                          sKey.c_str());
                  wxString::Format(wxT("[{#%d} Key : %s]"), (int) i,
                          sKey.c_str());
-            
+
              PrintOutType(sMessage, sKey, pKeys[i]);
              PrintOutType(sMessage, sKey, pKeys[i]);
-            
-            sMessage << 
-                wxString::Format(wxT("\n\t[Value : %s]"), 
+
+            sMessage <<
+                wxString::Format(wxT("\n\t[Value : %s]"),
                          sValue.c_str());
                          sValue.c_str());
-                        
+
              PrintOutType(sMessage, sValue, pValues[i]);
              PrintOutType(sMessage, sValue, pValues[i]);
-            
+
              sMessage << wxT("\n");
          }
              sMessage << wxT("\n");
          }
-        
-        delete[] pKeys;
-        delete[] pValues;
+
+        delete [] pKeys;
+        delete [] pValues;
      }
      }
-    
+
      static void PrintOutArray(wxString& sMessage, CFArrayRef cfaRef)
      {
      static void PrintOutArray(wxString& sMessage, CFArrayRef cfaRef)
      {
-    
-        for(CFIndex i = 0; i < CFArrayGetCount(cfaRef); ++i)
+        for (CFIndex i = 0; i < CFArrayGetCount(cfaRef); ++i)
          {
              wxString sValue = wxMacCFStringHolder(CFCopyTypeIDDescription(CFGetTypeID(
                  CFArrayGetValueAtIndex(cfaRef, i)
                  ))).AsString();
          {
              wxString sValue = wxMacCFStringHolder(CFCopyTypeIDDescription(CFGetTypeID(
                  CFArrayGetValueAtIndex(cfaRef, i)
                  ))).AsString();
-            
-            sMessage << 
+
+            sMessage <<
                  wxString::Format(wxT("\t\t[{#%d} ArrayValue : %s]\n"), (int) i,
                          sValue.c_str());
                  wxString::Format(wxT("\t\t[{#%d} ArrayValue : %s]\n"), (int) i,
                          sValue.c_str());
-            
+
              PrintOutType(sMessage, sValue, CFArrayGetValueAtIndex(cfaRef, i));
          }
      }
              PrintOutType(sMessage, sValue, CFArrayGetValueAtIndex(cfaRef, i));
          }
      }
-    
-    static void PrintOutType(wxString& sMessage, wxString sValue, CFTypeRef cfRef)
+
+    static void PrintOutType(wxString& sMessage, const wxString& sValue, CFTypeRef cfRef)
      {
              sMessage << wxT(" {");
      {
              sMessage << wxT(" {");
-                
-            if(sValue == wxT("CFString"))
+
+            if (sValue == wxT("CFString"))
              {
                   sMessage << wxMacCFStringHolder((CFStringRef)cfRef, false).AsString();
              }
              {
                   sMessage << wxMacCFStringHolder((CFStringRef)cfRef, false).AsString();
              }
-            else if(sValue == wxT("CFNumber"))
+            else if (sValue == wxT("CFNumber"))
              {
                  int nOut;
                  CFNumberGetValue((CFNumberRef)cfRef, kCFNumberIntType, &nOut);
                  sMessage << nOut;
              }
              {
                  int nOut;
                  CFNumberGetValue((CFNumberRef)cfRef, kCFNumberIntType, &nOut);
                  sMessage << nOut;
              }
-            else if(sValue == wxT("CFDictionary"))
+            else if (sValue == wxT("CFDictionary"))
              {
                  PrintOutDictionary(sMessage, (CFDictionaryRef)cfRef);
              }
              {
                  PrintOutDictionary(sMessage, (CFDictionaryRef)cfRef);
              }
-            else if(sValue == wxT("CFArray"))
+            else if (sValue == wxT("CFArray"))
              {
                  PrintOutArray(sMessage, (CFArrayRef)cfRef);
              }
              {
                  PrintOutArray(sMessage, (CFArrayRef)cfRef);
              }
-            else if(sValue == wxT("CFBoolean"))
+            else if (sValue == wxT("CFBoolean"))
              {
                  sMessage << (cfRef == kCFBooleanTrue ? wxT("true") : wxT("false"));
              }
              {
                  sMessage << (cfRef == kCFBooleanTrue ? wxT("true") : wxT("false"));
              }
-            else if(sValue == wxT("CFURL"))
+            else if (sValue == wxT("CFURL"))
              {
                  sMessage << wxMacCFStringHolder(CFURLCopyPath((CFURLRef) cfRef)).AsString();
              }
              {
                  sMessage << wxMacCFStringHolder(CFURLCopyPath((CFURLRef) cfRef)).AsString();
              }
@@ -1005,19 +967,19 @@ public:
              {
                  sMessage << wxT("*****UNKNOWN TYPE******");
              }
              {
                  sMessage << wxT("*****UNKNOWN TYPE******");
              }
-            
+
              sMessage << wxT("} ");
      }
              sMessage << wxT("} ");
      }
-    
+
  #if wxUSE_MIMETYPE
      void MakeValidXML();
  #endif
  #if wxUSE_MIMETYPE
      void MakeValidXML();
  #endif
-    
+
      CFTypeRef WriteAsXML()
      {
          return CFPropertyListCreateXMLData(kCFAllocatorDefault, m_cfmdRef);
      }
      CFTypeRef WriteAsXML()
      {
          return CFPropertyListCreateXMLData(kCFAllocatorDefault, m_cfmdRef);
      }
-    
+
      bool ReadAsXML(CFTypeRef cfData, wxString* pErrorMsg = NULL)
      {
          Clear();
      bool ReadAsXML(CFTypeRef cfData, wxString* pErrorMsg = NULL)
      {
          Clear();
@@ -1026,18 +988,19 @@ public:
                      kCFAllocatorDefault,
                      (CFDataRef)cfData,
                      kCFPropertyListMutableContainersAndLeaves,
                      kCFAllocatorDefault,
                      (CFDataRef)cfData,
                      kCFPropertyListMutableContainersAndLeaves,
-                    &cfsError  );
-        if(cfsError)
+                    &cfsError );
+        if (cfsError)
          {
          {
-            if(pErrorMsg)
+            if (pErrorMsg)
                  *pErrorMsg = wxMacCFStringHolder(cfsError).AsString();
              else
                  CFRelease(cfsError);
                  *pErrorMsg = wxMacCFStringHolder(cfsError).AsString();
              else
                  CFRelease(cfsError);
-        } 
+        }
  
          return m_cfmdRef != NULL;
      }
  
          return m_cfmdRef != NULL;
      }
- private:    
+
+private:
      CFMutableDictionaryRef m_cfmdRef;
  };
  
      CFMutableDictionaryRef m_cfmdRef;
  };
  
@@ -1051,28 +1014,28 @@ public:
      wxCFArray(CFTypeRef ref, bool bRetain = wxCF_RELEASE)
      {
          m_cfmaRef = (CFMutableArrayRef)ref;
      wxCFArray(CFTypeRef ref, bool bRetain = wxCF_RELEASE)
      {
          m_cfmaRef = (CFMutableArrayRef)ref;
-        if(bRetain == wxCF_RETAIN && ref)
+        if (bRetain == wxCF_RETAIN && ref)
              CFRetain(ref);
      }
              CFRetain(ref);
      }
-    
+
      wxCFArray(CFIndex cfiSize = 0) : m_cfmaRef(NULL)
      wxCFArray(CFIndex cfiSize = 0) : m_cfmaRef(NULL)
-    {  Create(cfiSize);        }
-    
-    ~wxCFArray() 
-    { Clear(); }
-    
+    { Create(cfiSize); }
+
+    ~wxCFArray()
+    { Clear(); }
+
      void MakeMutable(CFIndex cfiSize = 0)
      {
          wxASSERT(IsValid());
      void MakeMutable(CFIndex cfiSize = 0)
      {
          wxASSERT(IsValid());
-      
+
          CFMutableArrayRef oldref = m_cfmaRef;
          m_cfmaRef = CFArrayCreateMutableCopy(
                  kCFAllocatorDefault,
          CFMutableArrayRef oldref = m_cfmaRef;
          m_cfmaRef = CFArrayCreateMutableCopy(
                  kCFAllocatorDefault,
-                cfiSize, 
-                (CFArrayRef)oldref);    
+                cfiSize,
+                (CFArrayRef)oldref);
          CFRelease(oldref);
      }
          CFRelease(oldref);
      }
-    
+
      void BuildCallbacks(CFArrayCallBacks* pCbs)
      {
          pCbs->version = 0;
      void BuildCallbacks(CFArrayCallBacks* pCbs)
      {
          pCbs->version = 0;
@@ -1087,61 +1050,62 @@ public:
          Clear();
          CFArrayCallBacks cb;
          BuildCallbacks(&cb);
          Clear();
          CFArrayCallBacks cb;
          BuildCallbacks(&cb);
-        
+
          m_cfmaRef = CFArrayCreateMutable(kCFAllocatorDefault, cfiSize, &cb);
      }
          m_cfmaRef = CFArrayCreateMutable(kCFAllocatorDefault, cfiSize, &cb);
      }
-    
+
      void Clear()
      void Clear()
-    {if(m_cfmaRef) CFRelease(m_cfmaRef);}
-    
+    { if (m_cfmaRef) CFRelease(m_cfmaRef); }
+
      static const void* RetainProc(CFAllocatorRef, const void* v)
      static const void* RetainProc(CFAllocatorRef, const void* v)
-    {  return (const void*) CFRetain(v);       }
-    
+    { return (const void*) CFRetain(v); }
+
      static void ReleaseProc(CFAllocatorRef, const void* v)
      static void ReleaseProc(CFAllocatorRef, const void* v)
-    {  CFRelease(v);   }
-    
+    { CFRelease(v); }
+
      operator CFTypeRef () const
      operator CFTypeRef () const
-    {  return (CFTypeRef)m_cfmaRef;    }
-    
+    { return (CFTypeRef)m_cfmaRef; }
+
      CFArrayRef GetCFArray() const
      CFArrayRef GetCFArray() const
-    {  return (CFArrayRef)m_cfmaRef;   }
+    { return (CFArrayRef)m_cfmaRef; }
  
      CFMutableArrayRef GetCFMutableArray()
  
      CFMutableArrayRef GetCFMutableArray()
-    {  return (CFMutableArrayRef) m_cfmaRef;   }
+    { return (CFMutableArrayRef) m_cfmaRef; }
  
      CFTypeRef operator [] (CFIndex cfiIndex) const
  
      CFTypeRef operator [] (CFIndex cfiIndex) const
-    {  
+    {
          wxASSERT(IsValid());
          wxASSERT(IsValid());
-        return (CFTypeRef) CFArrayGetValueAtIndex((CFArrayRef)m_cfmaRef, cfiIndex);    
-    }    
-    
+        return (CFTypeRef) CFArrayGetValueAtIndex((CFArrayRef)m_cfmaRef, cfiIndex);
+    }
+
      CFIndex GetCount()
      CFIndex GetCount()
-    {  
+    {
          wxASSERT(IsValid());
          wxASSERT(IsValid());
-        return CFArrayGetCount((CFArrayRef)m_cfmaRef); 
+        return CFArrayGetCount((CFArrayRef)m_cfmaRef);
      }
      }
-    
+
      void Add(CFTypeRef cftValue)
      void Add(CFTypeRef cftValue)
-    {  
+    {
          wxASSERT(IsValid());
          wxASSERT(IsValid());
-        CFArrayAppendValue(m_cfmaRef, cftValue);       
+        CFArrayAppendValue(m_cfmaRef, cftValue);
      }
      }
-    
+
      void Remove(CFIndex cfiIndex)
      void Remove(CFIndex cfiIndex)
-    {  
+    {
          wxASSERT(IsValid());
          wxASSERT(cfiIndex < GetCount());
          wxASSERT(IsValid());
          wxASSERT(cfiIndex < GetCount());
-        CFArrayRemoveValueAtIndex(m_cfmaRef, cfiIndex);        
+        CFArrayRemoveValueAtIndex(m_cfmaRef, cfiIndex);
      }
      }
-    
+
      void Set(CFIndex cfiIndex, CFTypeRef cftValue)
      void Set(CFIndex cfiIndex, CFTypeRef cftValue)
-    {  
+    {
          wxASSERT(IsValid());
          wxASSERT(cfiIndex < GetCount());
          wxASSERT(IsValid());
          wxASSERT(cfiIndex < GetCount());
-        CFArraySetValueAtIndex(m_cfmaRef, cfiIndex, cftValue); 
+        CFArraySetValueAtIndex(m_cfmaRef, cfiIndex, cftValue);
      }
  
      }
  
-    bool IsOk() const {return m_cfmaRef != NULL;       }
+    bool IsOk() const
+    { return m_cfmaRef != NULL; }
  
      bool IsValid() const
      {
  
      bool IsValid() const
      {
@@ -1150,8 +1114,8 @@ public:
  
  #if wxUSE_MIMETYPE
      void MakeValidXML();
  
  #if wxUSE_MIMETYPE
      void MakeValidXML();
-#endif    
-    
+#endif
+
  private:
      CFMutableArrayRef m_cfmaRef;
  };
  private:
      CFMutableArrayRef m_cfmaRef;
  };
@@ -1160,24 +1124,28 @@ private:
  // wxCFString
  // ----------------------------------------------------------------------------
  
  // wxCFString
  // ----------------------------------------------------------------------------
  
-class wxCFString 
+class wxCFString
  {
  public:
      wxCFString(CFTypeRef ref, bool bRetain = wxCF_RELEASE) : m_Holder((CFStringRef)ref, bRetain == wxCF_RELEASE)
  {
  public:
      wxCFString(CFTypeRef ref, bool bRetain = wxCF_RELEASE) : m_Holder((CFStringRef)ref, bRetain == wxCF_RELEASE)
-    {                  }
-    
+    {}
+
      wxCFString(const wxChar* szString) : m_Holder(wxString(szString), wxLocale::GetSystemEncoding())
      wxCFString(const wxChar* szString) : m_Holder(wxString(szString), wxLocale::GetSystemEncoding())
-    {                  }
-    
+    {}
+
      wxCFString(const wxString& sString) : m_Holder(sString, wxLocale::GetSystemEncoding())
      wxCFString(const wxString& sString) : m_Holder(sString, wxLocale::GetSystemEncoding())
-    {                  }
-    
+    {}
+
+    virtual ~wxCFString() {}
+
      operator CFTypeRef() const
      operator CFTypeRef() const
-    {return (CFTypeRef) (m_Holder.operator CFStringRef());     } //don't ask
-    
-    bool IsOk() { return ((CFTypeRef)(*this)) != NULL; }
-    
-    wxString BuildWXString() {return m_Holder.AsString();      }
+    { return (CFTypeRef) ((CFStringRef) m_Holder); }
+
+    bool IsOk()
+    { return ((CFTypeRef)(*this)) != NULL; }
+
+    wxString BuildWXString()
+    { return m_Holder.AsString(); }
  
  private:
      wxMacCFStringHolder m_Holder;
  
  private:
      wxMacCFStringHolder m_Holder;
@@ -1190,38 +1158,36 @@ private:
  class wxCFNumber
  {
  public:
  class wxCFNumber
  {
  public:
-    wxCFNumber(int nValue) 
+    wxCFNumber(int nValue)
      {
      {
-        m_cfnRef = CFNumberCreate(kCFAllocatorDefault,
-                                                                       kCFNumberIntType, &nValue);
+        m_cfnRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &nValue);
      }
      }
-    
+
      wxCFNumber(CFTypeRef ref, bool bRetain = wxCF_RELEASE) : m_cfnRef((CFNumberRef)ref)
      {
      wxCFNumber(CFTypeRef ref, bool bRetain = wxCF_RELEASE) : m_cfnRef((CFNumberRef)ref)
      {
-        if(bRetain == wxCF_RETAIN && ref)
+        if (bRetain == wxCF_RETAIN && ref)
              CFRetain(ref);
      }
              CFRetain(ref);
      }
-    
-    ~wxCFNumber()
-    {  if(m_cfnRef)         CFRelease(m_cfnRef);       }
-    
-    
+
+    virtual ~wxCFNumber()
+    {
+        if (m_cfnRef)
+            CFRelease(m_cfnRef);
+    }
+
      operator CFTypeRef() const
      operator CFTypeRef() const
-    {  return (CFTypeRef) m_cfnRef;    }
+    { return (CFTypeRef) m_cfnRef; }
  
      int GetValue()
  
      int GetValue()
-    {  
+    {
          int nOut;
          int nOut;
-        CFNumberGetValue(
-                               m_cfnRef,       
-                               kCFNumberIntType,
-                &nOut
-                               );
-                
+        CFNumberGetValue( m_cfnRef, kCFNumberIntType, &nOut );
+
          return nOut;
      }
  
          return nOut;
      }
  
-    bool IsOk() { return m_cfnRef != NULL;     }
+    bool IsOk()
+    { return m_cfnRef != NULL; }
  
  private:
      CFNumberRef m_cfnRef;
  
  private:
      CFNumberRef m_cfnRef;
@@ -1234,16 +1200,17 @@ private:
  class wxCFURL
  {
  public:
  class wxCFURL
  {
  public:
-    wxCFURL(CFTypeRef ref = NULL, bool bRetain = wxCF_RELEASE) : m_cfurlRef((CFURLRef)ref) 
+    wxCFURL(CFTypeRef ref = NULL, bool bRetain = wxCF_RELEASE) : m_cfurlRef((CFURLRef)ref)
      {
      {
-        if(bRetain == wxCF_RETAIN && ref)
+        if (bRetain == wxCF_RETAIN && ref)
              CFRetain(ref);
      }
              CFRetain(ref);
      }
+
      wxCFURL(const wxCFString& URLString, CFTypeRef BaseURL = NULL)
      {
          Create(URLString, BaseURL);
      }
      wxCFURL(const wxCFString& URLString, CFTypeRef BaseURL = NULL)
      {
          Create(URLString, BaseURL);
      }
-    
+
      void Create(const wxCFString& URLString, CFTypeRef BaseURL = NULL)
      {
          m_cfurlRef = CFURLCreateWithString(
      void Create(const wxCFString& URLString, CFTypeRef BaseURL = NULL)
      {
          m_cfurlRef = CFURLCreateWithString(
@@ -1251,18 +1218,24 @@ public:
              (CFStringRef)(CFTypeRef)URLString,
              (CFURLRef) BaseURL);
      }
              (CFStringRef)(CFTypeRef)URLString,
              (CFURLRef) BaseURL);
      }
-    
-    ~wxCFURL() {if(m_cfurlRef) CFRelease(m_cfurlRef);}
+
+    virtual ~wxCFURL()
+    {
+        if (m_cfurlRef)
+            CFRelease(m_cfurlRef);
+    }
  
      wxString BuildWXString()
      {
          return wxCFString(CFURLCopyPath(m_cfurlRef)).BuildWXString();
      }
  
      wxString BuildWXString()
      {
          return wxCFString(CFURLCopyPath(m_cfurlRef)).BuildWXString();
      }
-    
+
      operator CFTypeRef() const
      operator CFTypeRef() const
-    {  return (CFTypeRef)m_cfurlRef;   }
-    
-    bool IsOk()        {       return m_cfurlRef != NULL;      }
+    { return (CFTypeRef)m_cfurlRef; }
+
+    bool IsOk()
+    { return m_cfurlRef != NULL; }
+
  private:
      CFURLRef m_cfurlRef;
  };
  private:
      CFURLRef m_cfurlRef;
  };
@@ -1272,19 +1245,19 @@ private:
  // ----------------------------------------------------------------------------
  
  #define wxCFDATA_RELEASEBUFFER  1
  // ----------------------------------------------------------------------------
  
  #define wxCFDATA_RELEASEBUFFER  1
-#define wxCFDATA_RETAINBUFFER   0
  
  class wxCFData
  {
  public:
  
  class wxCFData
  {
  public:
-    wxCFData(CFTypeRef ref, bool bRetain = wxCF_RELEASE) : m_cfdaRef((CFDataRef)ref) 
+    wxCFData(CFTypeRef ref, bool bRetain = wxCF_RELEASE) : m_cfdaRef((CFDataRef)ref)
      {
      {
-        if(bRetain == wxCF_RETAIN && ref)
+        if (bRetain == wxCF_RETAIN && ref)
              CFRetain(ref);
      }
              CFRetain(ref);
      }
+
      wxCFData(const UInt8* pBytes, CFIndex len, bool bKeep = wxCFDATA_RELEASEBUFFER)
      {
      wxCFData(const UInt8* pBytes, CFIndex len, bool bKeep = wxCFDATA_RELEASEBUFFER)
      {
-        if(bKeep == wxCFDATA_RELEASEBUFFER)
+        if (bKeep == wxCFDATA_RELEASEBUFFER)
          {
              m_cfdaRef = CFDataCreateWithBytesNoCopy
                              (kCFAllocatorDefault, pBytes, len, kCFAllocatorDefault);
          {
              m_cfdaRef = CFDataCreateWithBytesNoCopy
                              (kCFAllocatorDefault, pBytes, len, kCFAllocatorDefault);
@@ -1294,22 +1267,25 @@ public:
              m_cfdaRef = CFDataCreate(kCFAllocatorDefault, pBytes, len);
          }
      }
              m_cfdaRef = CFDataCreate(kCFAllocatorDefault, pBytes, len);
          }
      }
-    ~wxCFData() {if(m_cfdaRef) CFRelease(m_cfdaRef);}
  
  
-    const UInt8* GetValue()
+    virtual ~wxCFData()
      {
      {
-        return CFDataGetBytePtr(m_cfdaRef);
+        if (m_cfdaRef)
+            CFRelease(m_cfdaRef);
      }
      }
-    
+
+    const UInt8* GetValue()
+    { return CFDataGetBytePtr(m_cfdaRef); }
+
      CFIndex GetCount()
      CFIndex GetCount()
-    {
-        return CFDataGetLength(m_cfdaRef);
-    }
-    
+    { return CFDataGetLength(m_cfdaRef); }
+
      operator CFTypeRef() const
      operator CFTypeRef() const
-    {  return (CFTypeRef)m_cfdaRef;    }
-    
-    bool IsOk()        {       return m_cfdaRef != NULL;       }
+    { return (CFTypeRef)m_cfdaRef; }
+
+    bool IsOk()
+    { return m_cfdaRef != NULL; }
+
  private:
      CFDataRef m_cfdaRef;
  };
  private:
      CFDataRef m_cfdaRef;
  };
@@ -1322,23 +1298,23 @@ void wxCFDictionary::MakeValidXML()
  
          CFDictionaryGetKeysAndValues(m_cfmdRef, pKeys, pValues);
  
  
          CFDictionaryGetKeysAndValues(m_cfmdRef, pKeys, pValues);
  
-        //for plist xml format all dictionary keys must be cfstrings and no values in 
-        //the dictionary or subkeys/values can be NULL
-        //Also, CFURLs are not allowed
-        for(CFIndex i = 0; i < cfiCount; ++i)
+        // for plist xml format, all dictionary keys must be cfstrings and
+        // no values in the dictionary or subkeys/values can be NULL;
+        // additionally, CFURLs are not allowed
+        for (CFIndex i = 0; i < cfiCount; ++i)
          {
          {
-            //must be an array, dictionary, string, bool, or int and cannot be null
-            //and dictionaries can only contain cfstring keys
+            // must be an array, dictionary, string, bool, or int and cannot be null
+            // and dictionaries can only contain cfstring keys
              CFTypeRef cfRef = pValues[i];
              CFTypeRef cfRef = pValues[i];
-            if(!pKeys[i] ||
-                CFGetTypeID(pKeys[i]) != CFStringGetTypeID() || 
+            if (!pKeys[i] ||
+                CFGetTypeID(pKeys[i]) != CFStringGetTypeID() ||
                  !cfRef)
              {
                  Remove(pKeys[i]);
                  --i;
                  --cfiCount;
                  !cfRef)
              {
                  Remove(pKeys[i]);
                  --i;
                  --cfiCount;
-                delete[] pKeys;
-                delete[] pValues;
+                delete [] pKeys;
+                delete [] pValues;
                  pKeys = new CFTypeRef[cfiCount];
                  pValues = new CFTypeRef[cfiCount];
                  CFDictionaryGetKeysAndValues(m_cfmdRef, pKeys, pValues);
                  pKeys = new CFTypeRef[cfiCount];
                  pValues = new CFTypeRef[cfiCount];
                  CFDictionaryGetKeysAndValues(m_cfmdRef, pKeys, pValues);
@@ -1359,33 +1335,33 @@ void wxCFDictionary::MakeValidXML()
                  cfdCurrent.MakeValidXML();
                  Set(pKeys[i], cfdCurrent);
              }
                  cfdCurrent.MakeValidXML();
                  Set(pKeys[i], cfdCurrent);
              }
-            else if( (         CFGetTypeID(cfRef) == CFStringGetTypeID() ||
-                        CFGetTypeID(cfRef) == CFNumberGetTypeID() ||
-                        CFGetTypeID(cfRef) == CFBooleanGetTypeID() ) == false )
+            else if ( CFGetTypeID(cfRef) != CFStringGetTypeID() &&
+                      CFGetTypeID(cfRef) != CFNumberGetTypeID() &&
+                      CFGetTypeID(cfRef) != CFBooleanGetTypeID() )
              {
                  Remove(pKeys[i]);
                  --i;
                  --cfiCount;
              {
                  Remove(pKeys[i]);
                  --i;
                  --cfiCount;
-                delete[] pKeys;
-                delete[] pValues;
+                delete [] pKeys;
+                delete [] pValues;
                  pKeys = new CFTypeRef[cfiCount];
                  pValues = new CFTypeRef[cfiCount];
                  CFDictionaryGetKeysAndValues(m_cfmdRef, pKeys, pValues);
                  pKeys = new CFTypeRef[cfiCount];
                  pValues = new CFTypeRef[cfiCount];
                  CFDictionaryGetKeysAndValues(m_cfmdRef, pKeys, pValues);
-            }                
+            }
          }
  
          }
  
-        delete[] pValues;
-        delete[] pKeys;
+        delete [] pValues;
+        delete [] pKeys;
  }
  
  void wxCFArray::MakeValidXML()
  {
  }
  
  void wxCFArray::MakeValidXML()
  {
-        for(CFIndex i = 0; i < GetCount(); ++i)
+        for (CFIndex i = 0; i < GetCount(); ++i)
          {
              //must be an array, dictionary, string, bool, or int and cannot be null
              //and dictionaries can only contain cfstring keys
              CFTypeRef cfRef = (*this)[i];
          {
              //must be an array, dictionary, string, bool, or int and cannot be null
              //and dictionaries can only contain cfstring keys
              CFTypeRef cfRef = (*this)[i];
-            if(!cfRef)
+            if (!cfRef)
              {
                  Remove(i);
                  --i;
              {
                  Remove(i);
                  --i;
@@ -1406,9 +1382,9 @@ void wxCFArray::MakeValidXML()
                  cfdCurrent.MakeValidXML();
                  Set(i, cfdCurrent);
              }
                  cfdCurrent.MakeValidXML();
                  Set(i, cfdCurrent);
              }
-            else if( (         CFGetTypeID(cfRef) == CFStringGetTypeID() ||
-                        CFGetTypeID(cfRef) == CFNumberGetTypeID() ||
-                        CFGetTypeID(cfRef) == CFBooleanGetTypeID() ) == false )
+            else if ( CFGetTypeID(cfRef) != CFStringGetTypeID() &&
+                      CFGetTypeID(cfRef) != CFNumberGetTypeID() &&
+                      CFGetTypeID(cfRef) != CFBooleanGetTypeID() )
              {
                  Remove(i);
                  --i;
              {
                  Remove(i);
                  --i;
@@ -1427,173 +1403,169 @@ void wxCFArray::MakeValidXML()
  wxFileType* wxMimeTypesManagerImpl::Associate(const wxFileTypeInfo& ftInfo)
  {
      bool bInfoSuccess = false;
  wxFileType* wxMimeTypesManagerImpl::Associate(const wxFileTypeInfo& ftInfo)
  {
      bool bInfoSuccess = false;
-    
-    const wxArrayString& asExtensions = ftInfo.GetExtensions();                
+
+    const wxArrayString& asExtensions = ftInfo.GetExtensions();
      size_t dwFoundIndex = 0;
      size_t dwFoundIndex = 0;
-    if(!asExtensions.GetCount())
+    if (!asExtensions.GetCount())
      {
          wxLogDebug(wxT("Must have extension to associate with"));
      }
      {
          wxLogDebug(wxT("Must have extension to associate with"));
      }
-    
-    //Find and write to Info.plist in main bundle (note that some other
-    //apps have theirs named differently, i.e. IE's is named Info-macos.plist
-    //some apps (non-wx) use the 'plst' resource instead
+
+    // Find and write to Info.plist in main bundle (note that some other
+    // apps have theirs named differently, i.e. IE's is named Info-macos.plist
+    // some apps (non-wx) use the 'plst' resource instead
      CFBundleRef cfbMain = CFBundleGetMainBundle();
      CFBundleRef cfbMain = CFBundleGetMainBundle();
-    if(cfbMain)
-    {  
+    if (cfbMain)
+    {
          UInt32 dwBundleType, dwBundleCreator;
          CFBundleGetPackageInfo(cfbMain, &dwBundleType, &dwBundleCreator);
          UInt32 dwBundleType, dwBundleCreator;
          CFBundleGetPackageInfo(cfbMain, &dwBundleType, &dwBundleCreator);
-                
-        //if launching terminal non-app version will be 'BNDL' (generic bundle, maybe in other cases too),
-        //which will give us the incorrect info.plist path
-        //otherwise it will be 'APPL', or in the case of a framework,
-        //'FMWK'
-        if(dwBundleType == 'APPL')
-        {
  
  
+        // if launching terminal non-app, version will be 'BNDL' (generic bundle, maybe in other cases too),
+        // which will give us the incorrect info.plist path
+        // otherwise it will be 'APPL', or in the case of a framework, 'FMWK'
+        if (dwBundleType == 'APPL')
+        {
              wxCFURL cfurlBundleLoc((CFTypeRef)CFBundleCopyBundleURL(cfbMain));
  //             wxCFURL cfurlBundleLoc((CFTypeRef)CFBundleCopyExecutableURL(cfbMain));
              wxString sInfoPath;
  //            sInfoPath << wxT("file://");
              sInfoPath << cfurlBundleLoc.BuildWXString();
              sInfoPath << wxT("Contents/Info.plist");
              wxCFURL cfurlBundleLoc((CFTypeRef)CFBundleCopyBundleURL(cfbMain));
  //             wxCFURL cfurlBundleLoc((CFTypeRef)CFBundleCopyExecutableURL(cfbMain));
              wxString sInfoPath;
  //            sInfoPath << wxT("file://");
              sInfoPath << cfurlBundleLoc.BuildWXString();
              sInfoPath << wxT("Contents/Info.plist");
-        
+
  //        wxCFDictionary cfdInfo( CFBundleGetInfoDictionary(cfbMain), wxCF_RETAIN );
              wxCFDictionary cfdInfo;
              bool bInfoOpenSuccess = false;
              wxFile indictfile;
  //        wxCFDictionary cfdInfo( CFBundleGetInfoDictionary(cfbMain), wxCF_RETAIN );
              wxCFDictionary cfdInfo;
              bool bInfoOpenSuccess = false;
              wxFile indictfile;
-            if(indictfile.Open(sInfoPath, wxFile::read));
+            if (indictfile.Open(sInfoPath, wxFile::read))
              {
                  CFIndex cfiBufLen = (CFIndex) indictfile.Length();
                  const UInt8* pBuffer = new UInt8[cfiBufLen];
                  indictfile.Read((void*)pBuffer, cfiBufLen);
                  wxCFData cfdaInDict(pBuffer, cfiBufLen);
                  wxString sError;
              {
                  CFIndex cfiBufLen = (CFIndex) indictfile.Length();
                  const UInt8* pBuffer = new UInt8[cfiBufLen];
                  indictfile.Read((void*)pBuffer, cfiBufLen);
                  wxCFData cfdaInDict(pBuffer, cfiBufLen);
                  wxString sError;
-                    bInfoOpenSuccess = cfdInfo.ReadAsXML(cfdaInDict, &sError);
-                if(!bInfoOpenSuccess)
+                bInfoOpenSuccess = cfdInfo.ReadAsXML(cfdaInDict, &sError);
+                if (!bInfoOpenSuccess)
                      wxLogDebug(sError);
                  indictfile.Close();
              }
                      wxLogDebug(sError);
                  indictfile.Close();
              }
-            if(bInfoOpenSuccess)
+
+            if (bInfoOpenSuccess)
              {
                  cfdInfo.MakeMutable( cfdInfo.GetCount() + 1 );
  
                  wxCFArray cfaDocTypes( cfdInfo[ wxCFString(wxT("CFBundleDocumentTypes")) ], wxCF_RETAIN );
              {
                  cfdInfo.MakeMutable( cfdInfo.GetCount() + 1 );
  
                  wxCFArray cfaDocTypes( cfdInfo[ wxCFString(wxT("CFBundleDocumentTypes")) ], wxCF_RETAIN );
-            
-                bool bAddDocTypesArrayToDictionary = cfaDocTypes.IsOk() == false;
-                if(bAddDocTypesArrayToDictionary)
+
+                bool bAddDocTypesArrayToDictionary = !cfaDocTypes.IsOk();
+                if (bAddDocTypesArrayToDictionary)
                      cfaDocTypes.Create();
                  else
                      cfaDocTypes.MakeMutable( cfaDocTypes.GetCount() + 1 );
                      cfaDocTypes.Create();
                  else
                      cfaDocTypes.MakeMutable( cfaDocTypes.GetCount() + 1 );
-                
+
                  bool bEntryFound = false;
                  bool bEntryFound = false;
-                
-                //search for duplicate
+
+                // search for duplicates
                  CFIndex i;
                  CFIndex i;
-                for(i = 0; i < cfaDocTypes.GetCount(); ++i)
+                for (i = 0; i < cfaDocTypes.GetCount(); ++i)
                  {
                      wxCFDictionary cfdDocTypeEntry( cfaDocTypes[i], wxCF_RETAIN );
                  {
                      wxCFDictionary cfdDocTypeEntry( cfaDocTypes[i], wxCF_RETAIN );
-                            
-                    //A lot of apps dont do to mime types for some reason
-                    //so we go by extensions only
-                    wxCFArray cfaExtensions( cfdDocTypeEntry[ wxCFString(wxT("CFBundleTypeExtensions")) ], 
+
+                    // A lot of apps don't support MIME types for some reason
+                    // so we go by extensions only
+                    wxCFArray cfaExtensions( cfdDocTypeEntry[ wxCFString(wxT("CFBundleTypeExtensions")) ],
                                               wxCF_RETAIN );
                                               wxCF_RETAIN );
-                                             
-                    if(cfaExtensions.IsOk() == false)
+
+                    if (!cfaExtensions.IsOk())
                          continue;
                          continue;
-                    
-                    for(CFIndex iExt = 0; iExt < cfaExtensions.GetCount(); ++iExt)
-                    {                        
+
+                    for (CFIndex iExt = 0; iExt < cfaExtensions.GetCount(); ++iExt)
+                    {
                          for (size_t iWXExt = 0; iWXExt < asExtensions.GetCount(); ++iWXExt)
                          {
                          for (size_t iWXExt = 0; iWXExt < asExtensions.GetCount(); ++iWXExt)
                          {
-                            if(asExtensions[iWXExt] == 
+                            if (asExtensions[iWXExt] ==
                                      wxCFString(cfaExtensions[iExt], wxCF_RETAIN).BuildWXString())
                              {
                                  bEntryFound = true;
                                  dwFoundIndex = iWXExt;
                                      wxCFString(cfaExtensions[iExt], wxCF_RETAIN).BuildWXString())
                              {
                                  bEntryFound = true;
                                  dwFoundIndex = iWXExt;
+
                                  break;
                              }
                                  break;
                              }
-                        }      //end of wxstring array
-                        
-                        if(bEntryFound)
+                        } //end of wxstring array
+
+                        if (bEntryFound)
                              break;
                              break;
-                    } //end for cf array                    
-                    
-                    if(bEntryFound)
+                    } //end for cf array
+
+                    if (bEntryFound)
                          break;
                          break;
-                }//end for doctypes
-                
+                } //end for doctypes
+
                  wxCFDictionary cfdNewEntry;
  
                  wxCFDictionary cfdNewEntry;
  
-                if(!ftInfo.GetDescription().empty())
+                if (!ftInfo.GetDescription().empty())
                  {
                  {
-                    cfdNewEntry.Add( wxCFString(wxT("CFBundleTypeName")), 
+                    cfdNewEntry.Add( wxCFString(wxT("CFBundleTypeName")),
                                  wxCFString(ftInfo.GetDescription()) );
                  }
                                  wxCFString(ftInfo.GetDescription()) );
                  }
-                    
-                if(!ftInfo.GetIconFile().empty())
+
+                if (!ftInfo.GetIconFile().empty())
                  {
                  {
-                    cfdNewEntry.Add( wxCFString(wxT("CFBundleTypeIconFile")), 
+                    cfdNewEntry.Add( wxCFString(wxT("CFBundleTypeIconFile")),
                                      wxCFString(ftInfo.GetIconFile()) );
                  }
                                      wxCFString(ftInfo.GetIconFile()) );
                  }
-                    
-                
+
                  wxCFArray cfaOSTypes;
                  wxCFArray cfaExtensions;
                  wxCFArray cfaMimeTypes;
                  wxCFArray cfaOSTypes;
                  wxCFArray cfaExtensions;
                  wxCFArray cfaMimeTypes;
-                    
-                
+
                  //OSTypes is a cfarray of four-char-codes - '****' for unrestricted
                  cfaOSTypes.Add( wxCFString(wxT("****")) );
                  cfdNewEntry.Add( wxCFString(wxT("CFBundleTypeOSTypes")), cfaOSTypes );
  
                  //OSTypes is a cfarray of four-char-codes - '****' for unrestricted
                  cfaOSTypes.Add( wxCFString(wxT("****")) );
                  cfdNewEntry.Add( wxCFString(wxT("CFBundleTypeOSTypes")), cfaOSTypes );
  
-                if(ftInfo.GetExtensionsCount() != 0) //'*' for unrestricted
+                //'*' for unrestricted
+                if (ftInfo.GetExtensionsCount() != 0)
                  {
                  {
-                    for(size_t iExtension = 0; iExtension < (size_t)ftInfo.GetExtensionsCount(); ++iExtension)
+                    for (size_t iExtension = 0; iExtension < ftInfo.GetExtensionsCount(); ++iExtension)
                      {
                          cfaExtensions.Add( wxCFString( asExtensions[iExtension] ) );
                      }
                      {
                          cfaExtensions.Add( wxCFString( asExtensions[iExtension] ) );
                      }
-                    
+
                      cfdNewEntry.Add( wxCFString(wxT("CFBundleTypeExtensions")), cfaExtensions );
                  }
                      cfdNewEntry.Add( wxCFString(wxT("CFBundleTypeExtensions")), cfaExtensions );
                  }
-                
-                if(!ftInfo.GetMimeType().empty())
+
+                if (!ftInfo.GetMimeType().empty())
                  {
                      cfaMimeTypes.Add( wxCFString(ftInfo.GetMimeType()) );
                      cfdNewEntry.Add( wxCFString(wxT("CFBundleTypeMIMETypes")), cfaMimeTypes );
                  }
                  {
                      cfaMimeTypes.Add( wxCFString(ftInfo.GetMimeType()) );
                      cfdNewEntry.Add( wxCFString(wxT("CFBundleTypeMIMETypes")), cfaMimeTypes );
                  }
-                
+
                  // Editor - can perform all actions
                  // Viewer - all actions except manipulation/saving
                  // None - can perform no actions
                  cfdNewEntry.Add( wxCFString(wxT("CFBundleTypeRole")), wxCFString(wxT("Editor")) );
                  // Editor - can perform all actions
                  // Viewer - all actions except manipulation/saving
                  // None - can perform no actions
                  cfdNewEntry.Add( wxCFString(wxT("CFBundleTypeRole")), wxCFString(wxT("Editor")) );
-                
+
                  // Is application bundled?
                  cfdNewEntry.Add( wxCFString(wxT("LSTypeIsPackage")), kCFBooleanTrue );
  
                  // Is application bundled?
                  cfdNewEntry.Add( wxCFString(wxT("LSTypeIsPackage")), kCFBooleanTrue );
  
-                if(bEntryFound)
+                if (bEntryFound)
                      cfaDocTypes.Set(i, cfdNewEntry);
                  else
                      cfaDocTypes.Add(cfdNewEntry);
                      cfaDocTypes.Set(i, cfdNewEntry);
                  else
                      cfaDocTypes.Add(cfdNewEntry);
-                    
-                //
+
                  // set the doc types array in the muted dictionary
                  // set the doc types array in the muted dictionary
-                //
-                
-                if(bAddDocTypesArrayToDictionary)
+                if (bAddDocTypesArrayToDictionary)
                      cfdInfo.Add(wxCFString(wxT("CFBundleDocumentTypes")), cfaDocTypes);
                  else
                      cfdInfo.Set(wxCFString(wxT("CFBundleDocumentTypes")), cfaDocTypes);
                      cfdInfo.Add(wxCFString(wxT("CFBundleDocumentTypes")), cfaDocTypes);
                  else
                      cfdInfo.Set(wxCFString(wxT("CFBundleDocumentTypes")), cfaDocTypes);
-                    
+
                  cfdInfo.MakeValidXML();
  
                  wxFile outdictfile;
                  cfdInfo.MakeValidXML();
  
                  wxFile outdictfile;
-                if(outdictfile.Open(sInfoPath, wxFile::write))
+                if (outdictfile.Open(sInfoPath, wxFile::write))
                  {
                      wxCFData cfdaInfo(cfdInfo.WriteAsXML());
                  {
                      wxCFData cfdaInfo(cfdInfo.WriteAsXML());
-                    if(cfdaInfo.IsOk())
+                    if (cfdaInfo.IsOk())
                      {
                      {
-                        if(outdictfile.Write(cfdaInfo.GetValue(), cfdaInfo.GetCount()) != 
+                        if (outdictfile.Write(cfdaInfo.GetValue(), cfdaInfo.GetCount()) !=
                              (wxFileOffset)cfdaInfo.GetCount())
                          {
                              wxLogDebug(wxT("error in writing to file"));
                              (wxFileOffset)cfdaInfo.GetCount())
                          {
                              wxLogDebug(wxT("error in writing to file"));
@@ -1601,10 +1573,11 @@ wxFileType* wxMimeTypesManagerImpl::Associate(const wxFileTypeInfo& ftInfo)
                          else
                          {
                              bInfoSuccess = true;
                          else
                          {
                              bInfoSuccess = true;
+
  //#if defined(__DARWIN__)
  //                //force launch services to update its database for the finder
  //                OSStatus status = LSRegisterURL((CFURLRef)(CFTypeRef)cfurlBundleLoc, true);
  //#if defined(__DARWIN__)
  //                //force launch services to update its database for the finder
  //                OSStatus status = LSRegisterURL((CFURLRef)(CFTypeRef)cfurlBundleLoc, true);
-//                if(status != noErr)
+//                if (status != noErr)
  //                {
  //                    wxLogDebug(wxT("LSRegisterURL Failed."));
  //                }
  //                {
  //                    wxLogDebug(wxT("LSRegisterURL Failed."));
  //                }
@@ -1620,7 +1593,7 @@ wxFileType* wxMimeTypesManagerImpl::Associate(const wxFileTypeInfo& ftInfo)
                  }
                  else
                  {
                  }
                  else
                  {
-                    wxLogDebug(wxString(wxT("Could not open [")) + 
+                    wxLogDebug(wxString(wxT("Could not open [")) +
                      sInfoPath + wxT("] for writing."));
                  }
              }
                      sInfoPath + wxT("] for writing."));
                  }
              }
@@ -1629,7 +1602,7 @@ wxFileType* wxMimeTypesManagerImpl::Associate(const wxFileTypeInfo& ftInfo)
                  wxLogDebug(wxT("No info dictionary in main bundle"));
              }
          }
                  wxLogDebug(wxT("No info dictionary in main bundle"));
              }
          }
-        else   
+        else
          {
              wxLogDebug(wxT("Can only call associate from bundled app within XXX.app"));
          }
          {
              wxLogDebug(wxT("Can only call associate from bundled app within XXX.app"));
          }
@@ -1639,79 +1612,85 @@ wxFileType* wxMimeTypesManagerImpl::Associate(const wxFileTypeInfo& ftInfo)
          wxLogDebug(wxT("No main bundle"));
      }
  
          wxLogDebug(wxT("No main bundle"));
      }
  
-#if defined(__DARWIN__)
-    if(!bInfoSuccess)
+    if (!bInfoSuccess)
          return NULL;
          return NULL;
-#endif
-    //on mac you have to embed it into the mac's file reference resource ('FREF' I believe)
-    //or, alternately, you could just add an entry to m_hDatabase, but you'd need to get
-    //the app's signature somehow...
  
  
-    OSType processType,
-           creator;
-    OSStatus status = MoreProcGetProcessTypeSignature(NULL,&processType, &creator);
-    
-    if(status == noErr)
+    // on mac you have to embed it into the mac's file reference resource ('FREF' I believe)
+    // or, alternately, you could just add an entry to m_hDatabase, but you'd need to get
+    // the app's signature somehow...
+
+    OSType processType, creator;
+    OSStatus status = MoreProcGetProcessTypeSignature(NULL, &processType, &creator);
+
+    if (status == noErr)
      {
          Str255 psCreatorName;
      {
          Str255 psCreatorName;
+#ifndef __LP64__
          FSSpec dummySpec;
          status = FindApplication(creator, false, psCreatorName, &dummySpec);
          FSSpec dummySpec;
          status = FindApplication(creator, false, psCreatorName, &dummySpec);
-        
-        if(status == noErr)
-        {
+#else
+        FSRef fsref;
+        status = LSFindApplicationForInfo( creator, NULL, NULL, &fsref ,NULL);
+        HFSUniStr255 name;
+        status = FSGetCatalogInfo(&fsref, kFSCatInfoNone, NULL, &name, NULL, NULL);
+        CFStringRef str = FSCreateStringFromHFSUniStr( 0 , &name );
+        CFStringGetPascalString(str, psCreatorName, 256, CFStringGetSystemEncoding());
+        CFRelease( str );
+#endif
  
  
-            //get the file type if it exists - 
+        if (status == noErr)
+        {
+            //get the file type if it exists -
              //if it really does then modify the database then save it,
              //otherwise we need to create a whole new entry
              wxFileType* pFileType = GetFileTypeFromExtension(asExtensions[dwFoundIndex]);
              //if it really does then modify the database then save it,
              //otherwise we need to create a whole new entry
              wxFileType* pFileType = GetFileTypeFromExtension(asExtensions[dwFoundIndex]);
-            if(pFileType)
+            if (pFileType)
              {
                  ICMapEntry entry;
              {
                  ICMapEntry entry;
-                ICGetMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase, 
-                                pFileType->m_impl->m_lIndex, &entry);
-                
-                memcpy(entry.creatorAppName, psCreatorName, sizeof(Str255)); 
+                ICGetMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase,
+                    pFileType->m_impl->m_lIndex, &entry );
+
+                memcpy(entry.creatorAppName, psCreatorName, sizeof(Str255));
                  entry.fileCreator = creator;
                  entry.fileCreator = creator;
-                    
-                status = ICSetMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase, 
-                                pFileType->m_impl->m_lIndex, &entry);
+
+                status = ICSetMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase,
+                    pFileType->m_impl->m_lIndex, &entry );
  
                  //success
  
                  //success
-                if(status == noErr)
+                if (status == noErr)
                  {
                  {
+                     return pFileType;
+
                      //kICAttrNoChange means we don't care about attributes such as
                      //locking in the database
                      //kICAttrNoChange means we don't care about attributes such as
                      //locking in the database
-//                    status = ICSetPrefHandle((ICInstance) m_hIC, kICMapping, 
+//                    status = ICSetPrefHandle((ICInstance) m_hIC, kICMapping,
  //                                             kICAttrNoChange, (Handle) m_hDatabase);
  //                                             kICAttrNoChange, (Handle) m_hDatabase);
-//                    if(status == noErr)
-                        return pFileType;
+//                    if (status == noErr)
+//                        return pFileType;
  //                    else
  //                    {
  //                    else
  //                    {
-//                        wxLogDebug(wxString::Format(wxT("%i - %s"), (int)status, wxT("ICSetPrefHandle failed."))); 
-       //             }
+//                        wxLogDebug(wxString::Format(wxT("%i - %s"), (int)status, wxT("ICSetPrefHandle failed.")));
+//                    }
                  }
                  }
-                else 
-                { 
-                    wxLogDebug(wxString::Format(wxT("%i - %s"), __LINE__, wxT("ICSetMapEntry failed."))); 
+                else
+                {
+                    wxLogDebug(wxString::Format(wxT("%i - %s"), __LINE__, wxT("ICSetMapEntry failed.")));
                  }
                  }
-                
-                //failure - cleanup
+
+                // failure - cleanup
                  delete pFileType;
              }
              else
              {
                  delete pFileType;
              }
              else
              {
-                //TODO: Maybe force all 3 of these to be non-empty?
-                Str255 psExtension;
-                Str255 psMimeType;
-                Str255 psDescription;
-                
-                wxMacStringToPascal(wxString(wxT(".")) + ftInfo.GetExtensions()[0],    psExtension);
-                wxMacStringToPascal(ftInfo.GetMimeType(),              psMimeType);
-                wxMacStringToPascal(ftInfo.GetDescription(),   psDescription);
+                // TODO: Maybe force all 3 of these to be non-empty?
+                Str255 psExtension, psMimeType, psDescription;
  
  
-                Str255 psPostCreatorName;
-                wxMacStringToPascal(wxT(""), psPostCreatorName);
+                wxMacStringToPascal(wxString(wxT(".")) + ftInfo.GetExtensions()[0], psExtension);
+                wxMacStringToPascal(ftInfo.GetMimeType(), psMimeType);
+                wxMacStringToPascal(ftInfo.GetDescription(), psDescription);
  
  
+                Str255 psPostCreatorName;
+                wxMacStringToPascal(wxEmptyString, psPostCreatorName);
  
                  //add the entry to the database
                  ICMapEntry entry;
  
                  //add the entry to the database
                  ICMapEntry entry;
@@ -1722,44 +1701,46 @@ wxFileType* wxMimeTypesManagerImpl::Associate(const wxFileTypeInfo& ftInfo)
                  entry.fileCreator = creator;
                  entry.postCreator = 0;
                  entry.flags = kICMapDataForkBit; //TODO:  Maybe resource is valid by default too?
                  entry.fileCreator = creator;
                  entry.postCreator = 0;
                  entry.flags = kICMapDataForkBit; //TODO:  Maybe resource is valid by default too?
-                entry.extension = psExtension;
+                PLstrcpy( entry.extension , psExtension ) ;
                  memcpy(entry.creatorAppName, psCreatorName, sizeof(Str255));
                  memcpy(entry.postAppName, psPostCreatorName, sizeof(Str255));
                  memcpy(entry.MIMEType, psMimeType, sizeof(Str255));
                  memcpy(entry.entryName, psDescription, sizeof(Str255));
                  memcpy(entry.creatorAppName, psCreatorName, sizeof(Str255));
                  memcpy(entry.postAppName, psPostCreatorName, sizeof(Str255));
                  memcpy(entry.MIMEType, psMimeType, sizeof(Str255));
                  memcpy(entry.entryName, psDescription, sizeof(Str255));
-                
+
                  status = ICAddMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase, &entry);
                  status = ICAddMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase, &entry);
-                
-                if(status == noErr)
+                if (status == noErr)
                  {
                  {
-                    //kICAttrNoChange means we don't care about attributes such as
-                    //locking in the database
-         //           status = ICSetPrefHandle((ICInstance) m_hIC, kICMapping, 
-           //                                  kICAttrNoChange, (Handle) m_hDatabase);
-                                             
-                    //return the entry in the database if successful
-             //       if(status == noErr)
-                        return GetFileTypeFromExtension(ftInfo.GetMimeType());
-             //       else 
-              //      { 
-               //         wxLogDebug(wxString::Format(wxT("%i - %s"), __LINE__, wxT("ICSetPrefHandle failed."))); 
-               //     }
+                    return GetFileTypeFromExtension(ftInfo.GetMimeType());
+
+//                    kICAttrNoChange means we don't care about attributes such as
+//                    locking in the database
+//                    status = ICSetPrefHandle((ICInstance) m_hIC, kICMapping,
+//                                             kICAttrNoChange, (Handle) m_hDatabase);
+
+                    // return the entry in the database if successful
+//                    if (status == noErr)
+//                        return GetFileTypeFromExtension(ftInfo.GetMimeType());
+//                    else
+//                    {
+//                        wxLogDebug(wxString::Format(wxT("%i - %s"), __LINE__, wxT("ICSetPrefHandle failed.")));
+ //                   }
                  }
                  }
-                else 
-                { 
-                    wxLogDebug(wxString::Format(wxT("%i - %s"), __LINE__, wxT("ICAppMapEntry failed."))); 
+                else
+                {
+                    wxLogDebug(wxString::Format(wxT("%i - %s"), __LINE__, wxT("ICAppMapEntry failed.")));
                  }
              }
                  }
              }
-        } //end if FindApplcation was successful
-        else 
-        { 
-            wxLogDebug(wxString::Format(wxT("%i - %s"), __LINE__, wxT("FindApplication failed."))); 
+        } // end if FindApplcation was successful
+        else
+        {
+            wxLogDebug(wxString::Format(wxT("%i - %s"), __LINE__, wxT("FindApplication failed.")));
          }
          }
-    } //end if it could obtain app's signature
-    else 
-    { 
-        wxLogDebug(wxString::Format(wxT("%i - %s"), __LINE__, wxT("GetProcessSignature failed."))); 
+    } // end if it could obtain app's signature
+    else
+    {
+        wxLogDebug(wxString::Format(wxT("%i - %s"), __LINE__, wxT("GetProcessSignature failed.")));
      }
      }
+
      return NULL;
  }
  
      return NULL;
  }
  
@@ -1768,30 +1749,29 @@ wxMimeTypesManagerImpl::Unassociate(wxFileType *pFileType)
  {
      wxASSERT(pFileType);
      bool bInfoSuccess = false;
  {
      wxASSERT(pFileType);
      bool bInfoSuccess = false;
-    
+
      wxArrayString asExtensions;
      wxArrayString asExtensions;
-    pFileType->GetExtensions(asExtensions);                
-    
-    if(!asExtensions.GetCount())
+    pFileType->GetExtensions(asExtensions);
+
+    if (!asExtensions.GetCount())
      {
          wxLogDebug(wxT("Must have extension to disassociate"));
      {
          wxLogDebug(wxT("Must have extension to disassociate"));
-        return FALSE;
+        return false;
      }
  
      }
  
-    //Find and write to Info.plist in main bundle (note that some other
-    //apps have theirs named differently, i.e. IE's is named Info-macos.plist
-    //some apps (non-wx) use the 'plst' resource instead
+    // Find and write to Info.plist in main bundle (note that some other
+    // apps have theirs named differently, i.e. IE's is named Info-macos.plist
+    // some apps (non-wx) use the 'plst' resource instead
      CFBundleRef cfbMain = CFBundleGetMainBundle();
      CFBundleRef cfbMain = CFBundleGetMainBundle();
-    if(cfbMain)
-    {  
+    if (cfbMain)
+    {
          UInt32 dwBundleType, dwBundleCreator;
          CFBundleGetPackageInfo(cfbMain, &dwBundleType, &dwBundleCreator);
          UInt32 dwBundleType, dwBundleCreator;
          CFBundleGetPackageInfo(cfbMain, &dwBundleType, &dwBundleCreator);
-                
-        //if launching terminal non-app version will be 'BNDL' (generic bundle, maybe in other cases too),
-        //which will give us the incorrect info.plist path
-        //otherwise it will be 'APPL', or in the case of a framework,
-        //'FMWK'
-        if(dwBundleType == 'APPL')
+
+        // if launching terminal non-app, version will be 'BNDL' (generic bundle, maybe in other cases too),
+        // which will give us the incorrect info.plist path
+        // otherwise it will be 'APPL', or in the case of a framework, 'FMWK'
+        if (dwBundleType == 'APPL')
          {
  
              wxCFURL cfurlBundleLoc((CFTypeRef)CFBundleCopyBundleURL(cfbMain));
          {
  
              wxCFURL cfurlBundleLoc((CFTypeRef)CFBundleCopyBundleURL(cfbMain));
@@ -1800,52 +1780,53 @@ wxMimeTypesManagerImpl::Unassociate(wxFileType *pFileType)
  //            sInfoPath << wxT("file://");
              sInfoPath << cfurlBundleLoc.BuildWXString();
              sInfoPath << wxT("Contents/Info.plist");
  //            sInfoPath << wxT("file://");
              sInfoPath << cfurlBundleLoc.BuildWXString();
              sInfoPath << wxT("Contents/Info.plist");
-        
+
  //        wxCFDictionary cfdInfo( (CFTypeRef) CFBundleGetInfoDictionary(cfbMain), wxCF_RETAIN );
              wxCFDictionary cfdInfo;
              bool bInfoOpenSuccess = false;
              wxFile indictfile;
  //        wxCFDictionary cfdInfo( (CFTypeRef) CFBundleGetInfoDictionary(cfbMain), wxCF_RETAIN );
              wxCFDictionary cfdInfo;
              bool bInfoOpenSuccess = false;
              wxFile indictfile;
-            if(indictfile.Open(sInfoPath, wxFile::read));
+            if (indictfile.Open(sInfoPath, wxFile::read))
              {
                  CFIndex cfiBufLen = (CFIndex) indictfile.Length();
                  const UInt8* pBuffer = new UInt8[cfiBufLen];
                  indictfile.Read((void*)pBuffer, cfiBufLen);
                  wxCFData cfdaInDict(pBuffer, cfiBufLen);
                  wxString sError;
              {
                  CFIndex cfiBufLen = (CFIndex) indictfile.Length();
                  const UInt8* pBuffer = new UInt8[cfiBufLen];
                  indictfile.Read((void*)pBuffer, cfiBufLen);
                  wxCFData cfdaInDict(pBuffer, cfiBufLen);
                  wxString sError;
-                    bInfoOpenSuccess = cfdInfo.ReadAsXML(cfdaInDict, &sError);
-                if(!bInfoOpenSuccess)
+                bInfoOpenSuccess = cfdInfo.ReadAsXML(cfdaInDict, &sError);
+                if (!bInfoOpenSuccess)
                      wxLogDebug(sError);
                  indictfile.Close();
              }
                      wxLogDebug(sError);
                  indictfile.Close();
              }
-            if(bInfoOpenSuccess)
+
+            if (bInfoOpenSuccess)
              {
                  cfdInfo.MakeMutable( cfdInfo.GetCount() + 1 );
  
                  wxCFArray cfaDocTypes( cfdInfo[ wxCFString(wxT("CFBundleDocumentTypes")) ], wxCF_RETAIN );
              {
                  cfdInfo.MakeMutable( cfdInfo.GetCount() + 1 );
  
                  wxCFArray cfaDocTypes( cfdInfo[ wxCFString(wxT("CFBundleDocumentTypes")) ], wxCF_RETAIN );
-                
-                if(cfaDocTypes.IsOk())
-                {                                     
+
+                if (cfaDocTypes.IsOk())
+                {
                      bool bEntryFound = false;
                      bool bEntryFound = false;
-                
+
                      //search for duplicate
                      CFIndex i;
                      //search for duplicate
                      CFIndex i;
-                    for(i = 0; i < cfaDocTypes.GetCount(); ++i)
+                    for (i = 0; i < cfaDocTypes.GetCount(); ++i)
                      {
                          wxCFDictionary cfdDocTypeEntry( cfaDocTypes[i], wxCF_RETAIN );
                      {
                          wxCFDictionary cfdDocTypeEntry( cfaDocTypes[i], wxCF_RETAIN );
-                                
+
                          //A lot of apps dont do to mime types for some reason
                          //so we go by extensions only
                          //A lot of apps dont do to mime types for some reason
                          //so we go by extensions only
-                        wxCFArray cfaExtensions( cfdDocTypeEntry[ wxCFString(wxT("CFBundleTypeExtensions")) ], 
+                        wxCFArray cfaExtensions( cfdDocTypeEntry[ wxCFString(wxT("CFBundleTypeExtensions")) ],
                                          wxCF_RETAIN );
                                          wxCF_RETAIN );
-                                             
-                        if(cfaExtensions.IsOk() == false)
+
+                        if (!cfaExtensions.IsOk())
                              continue;
                              continue;
-                    
-                        for(CFIndex iExt = 0; iExt < cfaExtensions.GetCount(); ++iExt)
-                        {                          
+
+                        for (CFIndex iExt = 0; iExt < cfaExtensions.GetCount(); ++iExt)
+                        {
                              for (size_t iWXExt = 0; iWXExt < asExtensions.GetCount(); ++iWXExt)
                              {
                              for (size_t iWXExt = 0; iWXExt < asExtensions.GetCount(); ++iWXExt)
                              {
-                                if(asExtensions[iWXExt] == 
+                                if (asExtensions[iWXExt] ==
                                      wxCFString(cfaExtensions[iExt], wxCF_RETAIN).BuildWXString())
                                  {
                                      bEntryFound = true;
                                      wxCFString(cfaExtensions[iExt], wxCF_RETAIN).BuildWXString())
                                  {
                                      bEntryFound = true;
@@ -1853,27 +1834,27 @@ wxMimeTypesManagerImpl::Unassociate(wxFileType *pFileType)
                                      cfdInfo.Set( wxCFString(wxT("CFBundleDocumentTypes")) , cfaDocTypes );
                                      break;
                                  }
                                      cfdInfo.Set( wxCFString(wxT("CFBundleDocumentTypes")) , cfaDocTypes );
                                      break;
                                  }
-                            }  //end of wxstring array
-                        
-                            if(bEntryFound)
+                            } //end of wxstring array
+
+                            if (bEntryFound)
                                  break;
                                  break;
-                        } //end for cf array                    
-                            
-                        if(bEntryFound)
+                        } //end for cf array
+
+                        if (bEntryFound)
                              break;
                      }//end for doctypes
                              break;
                      }//end for doctypes
-                                        
-                    if(bEntryFound)
+
+                    if (bEntryFound)
                      {
                          cfdInfo.MakeValidXML();
  
                          wxFile outdictfile;
                      {
                          cfdInfo.MakeValidXML();
  
                          wxFile outdictfile;
-                        if(outdictfile.Open(sInfoPath, wxFile::write))
+                        if (outdictfile.Open(sInfoPath, wxFile::write))
                          {
                              wxCFData cfdaInfo(cfdInfo.WriteAsXML());
                          {
                              wxCFData cfdaInfo(cfdInfo.WriteAsXML());
-                            if(cfdaInfo.IsOk())
+                            if (cfdaInfo.IsOk())
                              {
                              {
-                                if(outdictfile.Write(cfdaInfo.GetValue(), cfdaInfo.GetCount()) != 
+                                if (outdictfile.Write(cfdaInfo.GetValue(), cfdaInfo.GetCount()) !=
                                      (wxFileOffset)cfdaInfo.GetCount())
                                  {
                                      wxLogDebug(wxT("error in writing to file"));
                                      (wxFileOffset)cfdaInfo.GetCount())
                                  {
                                      wxLogDebug(wxT("error in writing to file"));
@@ -1881,10 +1862,11 @@ wxMimeTypesManagerImpl::Unassociate(wxFileType *pFileType)
                                  else
                                  {
                                      bInfoSuccess = true;
                                  else
                                  {
                                      bInfoSuccess = true;
+
  //#if defined(__DARWIN__)
  //                //force launch services to update its database for the finder
  //                OSStatus status = LSRegisterURL((CFURLRef)(CFTypeRef)cfurlBundleLoc, true);
  //#if defined(__DARWIN__)
  //                //force launch services to update its database for the finder
  //                OSStatus status = LSRegisterURL((CFURLRef)(CFTypeRef)cfurlBundleLoc, true);
-//                if(status != noErr)
+//                if (status != noErr)
  //                {
  //                    wxLogDebug(wxT("LSRegisterURL Failed."));
  //                }
  //                {
  //                    wxLogDebug(wxT("LSRegisterURL Failed."));
  //                }
@@ -1900,17 +1882,20 @@ wxMimeTypesManagerImpl::Unassociate(wxFileType *pFileType)
                          }
                          else
                          {
                          }
                          else
                          {
-                            wxLogDebug(wxString(wxT("Could not open [")) + 
-                            sInfoPath + wxT("] for writing."));
+                            wxLogDebug(
+                                wxString(wxT("Could not open [")) +
+                                sInfoPath + wxT("] for writing."));
                          }
                      }
                      else
                      {
                          wxLogDebug(wxT("Entry not found to remove"));
                          }
                      }
                      else
                      {
                          wxLogDebug(wxT("Entry not found to remove"));
-                        wxString sPrintOut;  
-                        wxCFDictionary::PrintOutArray(sPrintOut, (CFArrayRef)(CFTypeRef)cfaDocTypes);  
+
+                        wxString sPrintOut;
+                        wxCFDictionary::PrintOutArray(sPrintOut, (CFArrayRef)(CFTypeRef)cfaDocTypes);
                          wxLogDebug(sPrintOut);
                          wxLogDebug(sPrintOut);
-                        for(size_t i = 0; i < asExtensions.GetCount(); ++i)
+
+                        for (size_t i = 0; i < asExtensions.GetCount(); ++i)
                              wxLogDebug(asExtensions[i]);
                      }
                  }
                              wxLogDebug(asExtensions[i]);
                      }
                  }
@@ -1925,7 +1910,7 @@ wxMimeTypesManagerImpl::Unassociate(wxFileType *pFileType)
                  wxLogDebug(wxT("No info dictionary in main bundle"));
              }
          }
                  wxLogDebug(wxT("No info dictionary in main bundle"));
              }
          }
-        else   
+        else
          {
              wxLogDebug(wxT("Can only call associate from bundled app within XXX.app"));
          }
          {
              wxLogDebug(wxT("Can only call associate from bundled app within XXX.app"));
          }
@@ -1935,75 +1920,77 @@ wxMimeTypesManagerImpl::Unassociate(wxFileType *pFileType)
          wxLogDebug(wxT("No main bundle"));
      }
  
          wxLogDebug(wxT("No main bundle"));
      }
  
-#if defined(__DARWIN__)
-    if(!bInfoSuccess)
-        return FALSE;
-#endif
+    if (!bInfoSuccess)
+        return false;
  
  
-    //this should be as easy as removing the entry from the database and then saving 
-    //the database
-    OSStatus status = ICDeleteMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase, 
+    // this should be as easy as removing the entry from the database
+    // and then saving the database
+    OSStatus status = ICDeleteMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase,
                              pFileType->m_impl->m_lIndex);
                              pFileType->m_impl->m_lIndex);
-                                
-    if(status == noErr)
+
+    if (status == noErr)
      {
      {
+            return true;
+
          //kICAttrNoChange means we don't care about attributes such as
          //locking in the database
          //kICAttrNoChange means we don't care about attributes such as
          //locking in the database
-//        status = ICSetPrefHandle((ICInstance) m_hIC, kICMapping, 
+//        status = ICSetPrefHandle((ICInstance) m_hIC, kICMapping,
  //                    kICAttrNoChange, (Handle) m_hDatabase);
  //                    kICAttrNoChange, (Handle) m_hDatabase);
-            
-//        if(status == noErr)
-            return TRUE;
+
+//        if (status == noErr)
+//        {
+//            return true;
+//        }
  //        else
  //        else
-//        { 
-//            wxLogDebug(wxString::Format(wxT("%i - %s"), __LINE__, wxT("ICSetPrefHandle failed."))); 
+//        {
+//            wxLogDebug(wxString::Format(wxT("%i - %s"), __LINE__, wxT("ICSetPrefHandle failed.")));
  //        }
  //        }
-
      }
      else
      }
      else
-    { 
-        wxLogDebug(wxString::Format(wxT("%i - %s"), __LINE__, wxT("ICDeleteMapEntry failed."))); 
+    {
+        wxLogDebug(wxString::Format(wxT("%i - %s"), __LINE__, wxT("ICDeleteMapEntry failed.")));
      }
      }
-    
-    return FALSE;
+
+    return false;
  }
  }
-/*
-                    CFWriteStreamRef cfwsInfo = CFWriteStreamCreateWithFile(
-                                        kCFAllocatorDefault,
-                                        (CFURLRef) (CFTypeRef)cfurlInfoLoc     );
-                
-//                CFShow(cfdInfo);
-                    if(cfwsInfo)
-                    {
-                        Boolean bOpened = CFWriteStreamOpen(cfwsInfo);
-                        if(bOpened)
-                        {                         
-                            CFStringRef cfsError;
-                            CFIndex cfiWritten = CFPropertyListWriteToStream((CFPropertyListRef)(CFTypeRef)cfdInfo,
-                                                cfwsInfo,
-                                                kCFPropertyListXMLFormat_v1_0, //100
-                                                &cfsError);
-                            if(cfsError && cfiWritten == 0)
-                            {
-                                wxLogDebug(wxCFString(cfsError).BuildWXString());
-                                wxString sMessage;
-                                cfdInfo.PrintOut(sMessage);
-                                wxLogDebug(sMessage);
-                            }
-                            else
-                            {
-                                bInfoSuccess = true;
+
+#if 0
+    CFWriteStreamRef cfwsInfo = CFWriteStreamCreateWithFile(
+           kCFAllocatorDefault,
+           (CFURLRef) (CFTypeRef)cfurlInfoLoc );
+
+//     CFShow(cfdInfo);
+        if (cfwsInfo)
+        {
+            Boolean bOpened = CFWriteStreamOpen(cfwsInfo);
+            if (bOpened)
+            {
+                CFStringRef cfsError;
+                CFIndex cfiWritten = CFPropertyListWriteToStream((CFPropertyListRef)(CFTypeRef)cfdInfo,
+                                    cfwsInfo,
+                                    kCFPropertyListXMLFormat_v1_0, //100
+                                    &cfsError);
+                if (cfsError && cfiWritten == 0)
+                {
+                    wxLogDebug(wxCFString(cfsError).BuildWXString());
+                    wxString sMessage;
+                    cfdInfo.PrintOut(sMessage);
+                    wxLogDebug(sMessage);
+                }
+                else
+                {
+                    bInfoSuccess = true;
  //#if defined(__DARWIN__)
  //                //force launch services to update its database for the finder
  //                OSStatus status = LSRegisterURL((CFURLRef)(CFTypeRef)cfurlBundleLoc, true);
  //#if defined(__DARWIN__)
  //                //force launch services to update its database for the finder
  //                OSStatus status = LSRegisterURL((CFURLRef)(CFTypeRef)cfurlBundleLoc, true);
-//                if(status != noErr)
+//                if (status != noErr)
  //                {
  //                    wxLogDebug(wxT("LSRegisterURL Failed."));
  //                }
  //#endif
  //                {
  //                    wxLogDebug(wxT("LSRegisterURL Failed."));
  //                }
  //#endif
-                            }
-                    
-                            CFWriteStreamClose(cfwsInfo);
+                }
+
+                CFWriteStreamClose(cfwsInfo);
+#endif
  
  
-*/
-#endif //wxUSE_MIMETYPE
-\ No newline at end of file
+#endif //wxUSE_MIMETYPE