src/mac/carbon/mimetmac.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        mac/mimetype.cpp
// Purpose:     Mac Carbon implementation for wx mime-related classes
// Author:      Ryan Norton
// Modified by:
// Created:     04/16/2005
// RCS-ID:      $Id$
// Copyright:   (c) 2005 Ryan Norton (<wxprojects@comcast.net>)
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#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__
  #pragma hdrstop
#endif

#ifndef WX_PRECOMP
  #include "wx/string.h"
  #if wxUSE_GUI
    #include "wx/icon.h"
  #endif
#endif //WX_PRECOMP


#if wxUSE_MIMETYPE

#include "wx/log.h"
#include "wx/file.h"
#include "wx/intl.h"
#include "wx/dynarray.h"
#include "wx/confbase.h"

#include "wx/mac/mimetype.h"
#include "wx/mac/private.h" //wxMacMakeStringFromPascal

// other standard headers
#include <ctype.h>
#include <InternetConfig.h> //For 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.
//
// 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
// High - which requires access to the database every time
//
// We want to be efficient (i.e. professional :) ) about it, so we use a combo of low
// and mid-level functions
//
// TODO: Should we call ICBegin/ICEnd?  Then where?
//

// in case we're compiling in non-GUI mode
class WXDLLEXPORT wxIcon;

bool wxFileTypeImpl::SetCommand(const wxString& cmd, const wxString& verb, bool overwriteprompt)
{
    return FALSE;
}

bool wxFileTypeImpl::SetDefaultIcon(const wxString& strIcon, int index)
{
    return FALSE;
}

bool wxFileTypeImpl::GetOpenCommand(wxString *openCmd,
                               const wxFileType::MessageParameters& params) const
{
    wxString cmd = GetCommand(wxT("open"));

    *openCmd = wxFileType::ExpandCommand(cmd, params);

    return !openCmd->empty();
}

bool
wxFileTypeImpl::GetPrintCommand(wxString *printCmd,
                                const wxFileType::MessageParameters& params)
                                const
{
    wxString cmd = GetCommand(wxT("print"));

    *printCmd = wxFileType::ExpandCommand(cmd, params);

    return !printCmd->empty();
}

/*   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) {
    HParamBlockRec volPB;
    GetVolParmsInfoBuffer volinfo;
    OSErr err;
    volPB.ioParam.ioVRefNum = vRefNum;
    volPB.ioParam.ioNamePtr = NULL;
    volPB.ioParam.ioBuffer = (Ptr) &volinfo;
    volPB.ioParam.ioReqCount = sizeof(volinfo);
    err = PBHGetVolParmsSync(&volPB);
    if (err == noErr) {
        *isRemote = (volinfo.vMServerAdr != 0);
        *vMAttrib = volinfo.vMAttrib;
    }
    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. */
OSErr BuildVolumeList(Boolean includeRemote, short *vols,
        long *count, long vMAttribMask) {
    HParamBlockRec volPB;
    Boolean isRemote;
    OSErr err;
    long nlocal, nremote;
    long vMAttrib;

        /* set up and check parameters */
    volPB.volumeParam.ioNamePtr = NULL;
    nlocal = nremote = 0;
    if (*count == 0) return noErr;

        /* iterate through volumes */
    for (volPB.volumeParam.ioVolIndex = 1;
        PBHGetVInfoSync(&volPB) == noErr;
        volPB.volumeParam.ioVolIndex++) {

                /* skip remote volumes, if necessary */
        err = IsRemoteVolume(volPB.volumeParam.ioVRefNum, &isRemote, &vMAttrib);
        if (err != noErr) goto bail;
        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;
            else {
                if (nremote > 0)
                    BlockMoveData(vols+nlocal, vols+nlocal+1,
                        nremote*sizeof(short));
                vols[nlocal++] = volPB.volumeParam.ioVRefNum;
            }

                /* list full? */
            if ((nlocal + nremote) >= *count) break;
        }
    }
bail:
    *count = (nlocal + nremote);
    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. */

#define kMaxVols 20

/* Hacked to output to appName */

OSErr FindApplication(OSType appCreator, Boolean includeRemote, Str255 appName) {
    short rRefNums[kMaxVols];
    long i, volCount;
    DTPBRec desktopPB;
    OSErr err;
    FSSpec realappSpec;
    FSSpec *appSpec = &realappSpec;

        /* 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++) {

            /* has a desktop file? */
        desktopPB.ioCompletion = NULL;
        desktopPB.ioVRefNum = rRefNums[i];
        desktopPB.ioNamePtr = NULL;
        desktopPB.ioIndex = 0;
        err = PBDTGetPath(&desktopPB);
        if (err != noErr) continue;

            /* has the correct app?? */
        desktopPB.ioFileCreator = appCreator;
        desktopPB.ioNamePtr = appName;
        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;

           /* found it! */
        return noErr;

    }
    return fnfErr;
}

/*   END CODE SAMPLE FROM TECHNOTE 1002 (http://developer.apple.com/technotes/tn/tn1002.html) */

wxString wxFileTypeImpl::GetCommand(const wxString& verb) const
{
    if(!m_manager)
        return wxEmptyString;

    if(verb == wxT("open"))
    {
        ICMapEntry entry;
        OSStatus status = ICGetMapEntry( (ICInstance) m_manager->m_hIC,
                                     (Handle) m_manager->m_hDatabase,
                                     m_lIndex, &entry);
        wxASSERT( status == noErr );

        //Technote 1002 is a godsend in launching apps :)
        //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
        Str255 outName;
        if(FindApplication(entry.fileCreator, false, outName) != noErr)
            return wxEmptyString;

        //TODO: this is only partially correct -
        //it should go to the os-specific application path folder (using wxStdPaths maybe?),
        //then go to the bundled app and return that full path
        return wxMacMakeStringFromPascal(outName);
    }
    return wxEmptyString;
}

bool wxFileTypeImpl::GetExtensions(wxArrayString& extensions)
{
    if(!m_manager)
        return false;

    ICMapEntry entry;
    OSStatus status = ICGetMapEntry( (ICInstance) m_manager->m_hIC,
                                     (Handle) m_manager->m_hDatabase,
                                     m_lIndex, &entry);
    wxASSERT( status == noErr );

    //entry has period in it
    wxString sCurrentExtension = wxMacMakeStringFromPascal(entry.extension);
    extensions.Add( sCurrentExtension.Right(sCurrentExtension.Length()-1) );
    return true;
}

bool wxFileTypeImpl::GetMimeType(wxString *mimeType) const
{
    if(!m_manager)
        return false;

    ICMapEntry entry;
    OSStatus status = ICGetMapEntry( (ICInstance) m_manager->m_hIC,
                                     (Handle) m_manager->m_hDatabase,
                                     m_lIndex, &entry);
    wxASSERT( status == noErr );

    *mimeType = wxMacMakeStringFromPascal(entry.MIMEType);
    return true;
}

bool wxFileTypeImpl::GetMimeTypes(wxArrayString& mimeTypes) const
{
    wxString s;

    if (GetMimeType(&s))
    {
        mimeTypes.Clear();
        mimeTypes.Add(s);
        return TRUE;
    }
    else
        return FALSE;
}

bool wxFileTypeImpl::GetIcon(wxIconLocation *WXUNUSED(icon)) const
{
    // no such file type or no value or incorrect icon entry
    return FALSE;
}

bool wxFileTypeImpl::GetDescription(wxString *desc) const
{
    if(!m_manager)
        return false;

    ICMapEntry entry;
    OSStatus status = ICGetMapEntry( (ICInstance) m_manager->m_hIC,
                                     (Handle) m_manager->m_hDatabase,
                                     m_lIndex, &entry);
    wxASSERT( status == noErr );

    *desc = wxString((char*)entry.entryName, wxConvLocal);
    return true;
}

size_t wxFileTypeImpl::GetAllCommands(wxArrayString * verbs, wxArrayString * commands,
                   const wxFileType::MessageParameters& params) const
{
    wxFAIL_MSG( _T("wxFileTypeImpl::GetAllCommands() not yet implemented") );
    return 0;
}

void wxMimeTypesManagerImpl::Initialize(int mailcapStyles, const wxString& extraDir)
{
    wxASSERT_MSG(m_hIC == NULL, wxT("Already initialized wxMimeTypesManager!"));

    //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)
    {
        wxLogSysError(wxT("Could not initialize wxMimeTypesManager!"));
        wxASSERT( false );
        return;
    }

    ICAttr attr;
    m_hDatabase = (void**) NewHandle(0);
    status = ICFindPrefHandle( (ICInstance) m_hIC, kICMapping, &attr, (Handle) m_hDatabase );

    //the database file can be corrupt (on OSX its
    //~/Library/Preferences/com.apple.internetconfig.plist)
    //- bail if it is
    if(status != noErr)
    {
        ClearData();
        wxLogSysError(wxT("Bad Mime Database!"));
        return;
    }

    //obtain the number of entries in the map
    status = ICCountMapEntries( (ICInstance) m_hIC, (Handle) m_hDatabase, &m_lCount );
    wxASSERT( status == noErr );
}

void wxMimeTypesManagerImpl::ClearData()
{
    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 );
        m_hIC = NULL;
    }
}

// extension -> file type
wxFileType* wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& e)
{
    wxASSERT_MSG( m_hIC != NULL, wxT("wxMimeTypesManager not Initialized!") );

//    ICMapEntry entry;
//    OSStatus status = ICMapEntriesFilename( (ICInstance) m_hIC, (Handle) m_hDatabase,
//                                            (unsigned char*) e.mb_str(wxConvLocal), &entry );

//    if (status != noErr)
//        return NULL; //err or ext not known
    //low level functions - iterate through the database
    ICMapEntry entry;
    wxFileType* pFileType;
    long pos;

    for(long i = 1; i <= m_lCount; ++i)
    {
        OSStatus status = ICGetIndMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase, i, &pos, &entry);

        if(status == noErr)
        {
            wxString sCurrentExtension = wxMacMakeStringFromPascal(entry.extension);
            if( sCurrentExtension.Right(sCurrentExtension.Length()-1) == e ) //entry has period in it
            {
                pFileType = new wxFileType();
                pFileType->m_impl->Init((wxMimeTypesManagerImpl*)this, pos);
                break;
            }
        }
    }

    return pFileType;
}

// MIME type -> extension -> file type
wxFileType* wxMimeTypesManagerImpl::GetFileTypeFromMimeType(const wxString& mimeType)
{
    wxASSERT_MSG( m_hIC != NULL, wxT("wxMimeTypesManager not Initialized!") );

    //low level functions - iterate through the database
    ICMapEntry entry;
    wxFileType* pFileType;

    long pos;

    for(long i = 1; i <= m_lCount; ++i)
    {
        OSStatus status = ICGetIndMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase, i, &pos, &entry);
        wxASSERT_MSG( status == noErr, wxString::Format(wxT("Error: %d"), (int)status) );

        if(status == noErr)
        {
            if( wxMacMakeStringFromPascal(entry.MIMEType) == mimeType)
            {
                pFileType = new wxFileType();
                pFileType->m_impl->Init((wxMimeTypesManagerImpl*)this, pos);
                break;
            }
        }
    }

    return pFileType;
}

size_t wxMimeTypesManagerImpl::EnumAllFileTypes(wxArrayString& mimetypes)
{
    wxASSERT_MSG( m_hIC != NULL, wxT("wxMimeTypesManager not Initialized!") );

    //low level functions - iterate through the database
    ICMapEntry entry;

    long pos;

    for(long i = 1; i <= m_lCount; ++i)
    {
        OSStatus status = ICGetIndMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase, i, &pos, &entry);
        if( status == noErr )
            mimetypes.Add( wxMacMakeStringFromPascal(entry.MIMEType) );
    }

    return m_lCount;
}

wxFileType *
wxMimeTypesManagerImpl::Associate(const wxFileTypeInfo& ftInfo)
{
    wxFAIL_MSG( _T("wxMimeTypesManagerImpl::Associate() not yet implemented") );
    //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...

    return NULL;
}

bool
wxMimeTypesManagerImpl::Unassociate(wxFileType *ft)
{
    //this should be as easy as removing the entry from the database and then saving
    //the database
    return FALSE;
}

#endif //wxUSE_MIMETYPE
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: mac/mimetype.cpp
	3	// Purpose: Mac Carbon implementation for wx mime-related classes
	4	// Author: Ryan Norton
	5	// Modified by:
	6	// Created: 04/16/2005
	7	// RCS-ID: $Id$
	8	// Copyright: (c) 2005 Ryan Norton (<wxprojects@comcast.net>)
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
	13	#pragma implementation "mimetype.h"
	14	#endif
	15
	16	// for compilers that support precompilation, includes "wx.h".
	17	#include "wx/wxprec.h"
	18
	19	#ifdef __BORLANDC__
	20	#pragma hdrstop
	21	#endif
	22
	23	#ifndef WX_PRECOMP
	24	#include "wx/string.h"
	25	#if wxUSE_GUI
	26	#include "wx/icon.h"
	27	#endif
	28	#endif //WX_PRECOMP
	29
	30
	31	#if wxUSE_MIMETYPE
	32
	33	#include "wx/log.h"
	34	#include "wx/file.h"
	35	#include "wx/intl.h"
	36	#include "wx/dynarray.h"
	37	#include "wx/confbase.h"
	38
	39	#include "wx/mac/mimetype.h"
	40	#include "wx/mac/private.h" //wxMacMakeStringFromPascal
	41
	42	// other standard headers
	43	#include <ctype.h>
	44	#include <InternetConfig.h> //For mime types
	45
	46	//
	47	// On the mac there are two ways to open a file - one is through apple events and the
	48	// finder, another is through mime types.
	49	//
	50	// So, really there are two ways to implement wxFileType...
	51	//
	52	// Mime types are only available on OS 8.1+ through the InternetConfig API
	53	//
	54	// Much like the old-style file manager, it has 3 levels of flexibility for its methods -
	55	// Low - which means you have to iterate yourself through the mime database
	56	// Medium - which lets you sort of cache the database if you want to use lowlevel functions
	57	// High - which requires access to the database every time
	58	//
	59	// We want to be efficient (i.e. professional :) ) about it, so we use a combo of low
	60	// and mid-level functions
	61	//
	62	// TODO: Should we call ICBegin/ICEnd? Then where?
	63	//
	64
	65	// in case we're compiling in non-GUI mode
	66	class WXDLLEXPORT wxIcon;
	67
	68	bool wxFileTypeImpl::SetCommand(const wxString& cmd, const wxString& verb, bool overwriteprompt)
	69	{
	70	return FALSE;
	71	}
	72
	73	bool wxFileTypeImpl::SetDefaultIcon(const wxString& strIcon, int index)
	74	{
	75	return FALSE;
	76	}
	77
	78	bool wxFileTypeImpl::GetOpenCommand(wxString *openCmd,
	79	const wxFileType::MessageParameters& params) const
	80	{
	81	wxString cmd = GetCommand(wxT("open"));
	82
	83	*openCmd = wxFileType::ExpandCommand(cmd, params);
	84
	85	return !openCmd->empty();
	86	}
	87
	88	bool
	89	wxFileTypeImpl::GetPrintCommand(wxString *printCmd,
	90	const wxFileType::MessageParameters& params)
	91	const
	92	{
	93	wxString cmd = GetCommand(wxT("print"));
	94
	95	*printCmd = wxFileType::ExpandCommand(cmd, params);
	96
	97	return !printCmd->empty();
	98	}
	99
	100	/* START CODE SAMPLE FROM TECHNOTE 1002 (http://developer.apple.com/technotes/tn/tn1002.html) */
	101
	102	/* IsRemoteVolume can be used to find out if the
	103	volume referred to by vRefNum is a remote volume
	104	located somewhere on a network. the volume's attribute
	105	flags (copied from the GetVolParmsInfoBuffer structure)
	106	are returned in the longword pointed to by vMAttrib. */
	107	OSErr IsRemoteVolume(short vRefNum, Boolean isRemote, long vMAttrib) {
	108	HParamBlockRec volPB;
	109	GetVolParmsInfoBuffer volinfo;
	110	OSErr err;
	111	volPB.ioParam.ioVRefNum = vRefNum;
	112	volPB.ioParam.ioNamePtr = NULL;
	113	volPB.ioParam.ioBuffer = (Ptr) &volinfo;
	114	volPB.ioParam.ioReqCount = sizeof(volinfo);
	115	err = PBHGetVolParmsSync(&volPB);
	116	if (err == noErr) {
	117	*isRemote = (volinfo.vMServerAdr != 0);
	118	*vMAttrib = volinfo.vMAttrib;
	119	}
	120	return err;
	121	}
	122
	123
	124	/* BuildVolumeList fills the array pointed to by vols with
	125	a list of the currently mounted volumes. If includeRemote
	126	is true, then remote server volumes will be included in
	127	the list. When remote server volumes are included in the
	128	list, they will be added to the end of the list. On entry,
	129	*count should contain the size of the array pointed to by
	130	vols. On exit, *count will be set to the number of id numbers
	131	placed in the array. If vMAttribMask is non-zero, then
	132	only volumes with matching attributes are added to the
	133	list of volumes. bits in the vMAttribMask should use the
	134	same encoding as bits in the vMAttrib field of
	135	the GetVolParmsInfoBuffer structure. */
	136	OSErr BuildVolumeList(Boolean includeRemote, short *vols,
	137	long *count, long vMAttribMask) {
	138	HParamBlockRec volPB;
	139	Boolean isRemote;
	140	OSErr err;
	141	long nlocal, nremote;
	142	long vMAttrib;
	143
	144	/* set up and check parameters */
	145	volPB.volumeParam.ioNamePtr = NULL;
	146	nlocal = nremote = 0;
	147	if (*count == 0) return noErr;
	148
	149	/* iterate through volumes */
	150	for (volPB.volumeParam.ioVolIndex = 1;
	151	PBHGetVInfoSync(&volPB) == noErr;
	152	volPB.volumeParam.ioVolIndex++) {
	153
	154	/* skip remote volumes, if necessary */
	155	err = IsRemoteVolume(volPB.volumeParam.ioVRefNum, &isRemote, &vMAttrib);
	156	if (err != noErr) goto bail;
	157	if ( ( includeRemote \|\| ! isRemote )
	158	&& (vMAttrib & vMAttribMask) == vMAttribMask ) {
	159
	160	/* add local volumes at the front, remote
	161	volumes at the end */
	162	if (isRemote)
	163	vols[nlocal + nremote++] = volPB.volumeParam.ioVRefNum;
	164	else {
	165	if (nremote > 0)
	166	BlockMoveData(vols+nlocal, vols+nlocal+1,
	167	nremote*sizeof(short));
	168	vols[nlocal++] = volPB.volumeParam.ioVRefNum;
	169	}
	170
	171	/* list full? */
	172	if ((nlocal + nremote) >= *count) break;
	173	}
	174	}
	175	bail:
	176	*count = (nlocal + nremote);
	177	return err;
	178	}
	179
	180
	181	/* FindApplication iterates through mounted volumes
	182	searching for an application with the given creator
	183	type. If includeRemote is true, then remote volumes
	184	will be searched (after local ones) for an application
	185	with the creator type. */
	186
	187	#define kMaxVols 20
	188
	189	/* Hacked to output to appName */
	190
	191	OSErr FindApplication(OSType appCreator, Boolean includeRemote, Str255 appName) {
	192	short rRefNums[kMaxVols];
	193	long i, volCount;
	194	DTPBRec desktopPB;
	195	OSErr err;
	196	FSSpec realappSpec;
	197	FSSpec *appSpec = &realappSpec;
	198
	199	/* get a list of volumes - with desktop files */
	200	volCount = kMaxVols;
	201	err = BuildVolumeList(includeRemote, rRefNums, &volCount,
	202	(1<<bHasDesktopMgr) );
	203	if (err != noErr) return err;
	204
	205	/* iterate through the list */
	206	for (i=0; i<volCount; i++) {
	207
	208	/* has a desktop file? */
	209	desktopPB.ioCompletion = NULL;
	210	desktopPB.ioVRefNum = rRefNums[i];
	211	desktopPB.ioNamePtr = NULL;
	212	desktopPB.ioIndex = 0;
	213	err = PBDTGetPath(&desktopPB);
	214	if (err != noErr) continue;
	215
	216	/* has the correct app?? */
	217	desktopPB.ioFileCreator = appCreator;
	218	desktopPB.ioNamePtr = appName;
	219	err = PBDTGetAPPLSync(&desktopPB);
	220	if (err != noErr) continue;
	221
	222	/* make a file spec referring to it */
	223	err = FSMakeFSSpec(rRefNums[i],
	224	desktopPB.ioAPPLParID, appName,
	225	appSpec);
	226	if (err != noErr) continue;
	227
	228	/* found it! */
	229	return noErr;
	230
	231	}
	232	return fnfErr;
	233	}
	234
	235	/* END CODE SAMPLE FROM TECHNOTE 1002 (http://developer.apple.com/technotes/tn/tn1002.html) */
	236
	237	wxString wxFileTypeImpl::GetCommand(const wxString& verb) const
	238	{
	239	if(!m_manager)
	240	return wxEmptyString;
	241
	242	if(verb == wxT("open"))
	243	{
	244	ICMapEntry entry;
	245	OSStatus status = ICGetMapEntry( (ICInstance) m_manager->m_hIC,
	246	(Handle) m_manager->m_hDatabase,
	247	m_lIndex, &entry);
	248	wxASSERT( status == noErr );
	249
	250	//Technote 1002 is a godsend in launching apps :)
	251	//The entry in the mimetype database only contains the app
	252	//that's registered - it may not exist... we need to remap the creator
	253	//type and find the right application
	254	Str255 outName;
	255	if(FindApplication(entry.fileCreator, false, outName) != noErr)
	256	return wxEmptyString;
	257
	258	//TODO: this is only partially correct -
	259	//it should go to the os-specific application path folder (using wxStdPaths maybe?),
	260	//then go to the bundled app and return that full path
	261	return wxMacMakeStringFromPascal(outName);
	262	}
	263	return wxEmptyString;
	264	}
	265
	266	bool wxFileTypeImpl::GetExtensions(wxArrayString& extensions)
	267	{
	268	if(!m_manager)
	269	return false;
	270
	271	ICMapEntry entry;
	272	OSStatus status = ICGetMapEntry( (ICInstance) m_manager->m_hIC,
	273	(Handle) m_manager->m_hDatabase,
	274	m_lIndex, &entry);
	275	wxASSERT( status == noErr );
	276
	277	//entry has period in it
	278	wxString sCurrentExtension = wxMacMakeStringFromPascal(entry.extension);
	279	extensions.Add( sCurrentExtension.Right(sCurrentExtension.Length()-1) );
	280	return true;
	281	}
	282
	283	bool wxFileTypeImpl::GetMimeType(wxString *mimeType) const
	284	{
	285	if(!m_manager)
	286	return false;
	287
	288	ICMapEntry entry;
	289	OSStatus status = ICGetMapEntry( (ICInstance) m_manager->m_hIC,
	290	(Handle) m_manager->m_hDatabase,
	291	m_lIndex, &entry);
	292	wxASSERT( status == noErr );
	293
	294	*mimeType = wxMacMakeStringFromPascal(entry.MIMEType);
	295	return true;
	296	}
	297
	298	bool wxFileTypeImpl::GetMimeTypes(wxArrayString& mimeTypes) const
	299	{
	300	wxString s;
	301
	302	if (GetMimeType(&s))
	303	{
	304	mimeTypes.Clear();
	305	mimeTypes.Add(s);
	306	return TRUE;
	307	}
	308	else
	309	return FALSE;
	310	}
	311
	312	bool wxFileTypeImpl::GetIcon(wxIconLocation *WXUNUSED(icon)) const
	313	{
	314	// no such file type or no value or incorrect icon entry
	315	return FALSE;
	316	}
	317
	318	bool wxFileTypeImpl::GetDescription(wxString *desc) const
	319	{
	320	if(!m_manager)
	321	return false;
	322
	323	ICMapEntry entry;
	324	OSStatus status = ICGetMapEntry( (ICInstance) m_manager->m_hIC,
	325	(Handle) m_manager->m_hDatabase,
	326	m_lIndex, &entry);
	327	wxASSERT( status == noErr );
	328
	329	desc = wxString((char)entry.entryName, wxConvLocal);
	330	return true;
	331	}
	332
	333	size_t wxFileTypeImpl::GetAllCommands(wxArrayString * verbs, wxArrayString * commands,
	334	const wxFileType::MessageParameters& params) const
	335	{
	336	wxFAIL_MSG( _T("wxFileTypeImpl::GetAllCommands() not yet implemented") );
	337	return 0;
	338	}
	339
	340	void wxMimeTypesManagerImpl::Initialize(int mailcapStyles, const wxString& extraDir)
	341	{
	342	wxASSERT_MSG(m_hIC == NULL, wxT("Already initialized wxMimeTypesManager!"));
	343
	344	//start internet config - log if there's an error
	345	//the second param is the signature of the application, also known
	346	//as resource ID 0. However, as per some recent discussions, we may not
	347	//have a signature for this app, so a generic 'APPL' which is the executable
	348	//type will work for now
	349	OSStatus status = ICStart( (ICInstance*) &m_hIC, 'APPL');
	350
	351	if(status != noErr)
	352	{
	353	wxLogSysError(wxT("Could not initialize wxMimeTypesManager!"));
	354	wxASSERT( false );
	355	return;
	356	}
	357
	358	ICAttr attr;
	359	m_hDatabase = (void**) NewHandle(0);
	360	status = ICFindPrefHandle( (ICInstance) m_hIC, kICMapping, &attr, (Handle) m_hDatabase );
	361
	362	//the database file can be corrupt (on OSX its
	363	//~/Library/Preferences/com.apple.internetconfig.plist)
	364	//- bail if it is
	365	if(status != noErr)
	366	{
	367	ClearData();
	368	wxLogSysError(wxT("Bad Mime Database!"));
	369	return;
	370	}
	371
	372	//obtain the number of entries in the map
	373	status = ICCountMapEntries( (ICInstance) m_hIC, (Handle) m_hDatabase, &m_lCount );
	374	wxASSERT( status == noErr );
	375	}
	376
	377	void wxMimeTypesManagerImpl::ClearData()
	378	{
	379	if(m_hIC != NULL)
	380	{
	381	DisposeHandle((Handle)m_hDatabase);
	382	//this can return an error, but we don't really care that much about it
	383	ICStop( (ICInstance) m_hIC );
	384	m_hIC = NULL;
	385	}
	386	}
	387
	388	// extension -> file type
	389	wxFileType* wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& e)
	390	{
	391	wxASSERT_MSG( m_hIC != NULL, wxT("wxMimeTypesManager not Initialized!") );
	392
	393	// ICMapEntry entry;
	394	// OSStatus status = ICMapEntriesFilename( (ICInstance) m_hIC, (Handle) m_hDatabase,
	395	// (unsigned char*) e.mb_str(wxConvLocal), &entry );
	396
	397	// if (status != noErr)
	398	// return NULL; //err or ext not known
	399	//low level functions - iterate through the database
	400	ICMapEntry entry;
	401	wxFileType* pFileType;
	402	long pos;
	403
	404	for(long i = 1; i <= m_lCount; ++i)
	405	{
	406	OSStatus status = ICGetIndMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase, i, &pos, &entry);
	407
	408	if(status == noErr)
	409	{
	410	wxString sCurrentExtension = wxMacMakeStringFromPascal(entry.extension);
	411	if( sCurrentExtension.Right(sCurrentExtension.Length()-1) == e ) //entry has period in it
	412	{
	413	pFileType = new wxFileType();
	414	pFileType->m_impl->Init((wxMimeTypesManagerImpl*)this, pos);
	415	break;
	416	}
	417	}
	418	}
	419
	420	return pFileType;
	421	}
	422
	423	// MIME type -> extension -> file type
	424	wxFileType* wxMimeTypesManagerImpl::GetFileTypeFromMimeType(const wxString& mimeType)
	425	{
	426	wxASSERT_MSG( m_hIC != NULL, wxT("wxMimeTypesManager not Initialized!") );
	427
	428	//low level functions - iterate through the database
	429	ICMapEntry entry;
	430	wxFileType* pFileType;
	431
	432	long pos;
	433
	434	for(long i = 1; i <= m_lCount; ++i)
	435	{
	436	OSStatus status = ICGetIndMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase, i, &pos, &entry);
	437	wxASSERT_MSG( status == noErr, wxString::Format(wxT("Error: %d"), (int)status) );
	438
	439	if(status == noErr)
	440	{
	441	if( wxMacMakeStringFromPascal(entry.MIMEType) == mimeType)
	442	{
	443	pFileType = new wxFileType();
	444	pFileType->m_impl->Init((wxMimeTypesManagerImpl*)this, pos);
	445	break;
	446	}
	447	}
	448	}
	449
	450	return pFileType;
	451	}
	452
	453	size_t wxMimeTypesManagerImpl::EnumAllFileTypes(wxArrayString& mimetypes)
	454	{
	455	wxASSERT_MSG( m_hIC != NULL, wxT("wxMimeTypesManager not Initialized!") );
	456
	457	//low level functions - iterate through the database
	458	ICMapEntry entry;
	459
	460	long pos;
	461
	462	for(long i = 1; i <= m_lCount; ++i)
	463	{
	464	OSStatus status = ICGetIndMapEntry( (ICInstance) m_hIC, (Handle) m_hDatabase, i, &pos, &entry);
	465	if( status == noErr )
	466	mimetypes.Add( wxMacMakeStringFromPascal(entry.MIMEType) );
	467	}
	468
	469	return m_lCount;
	470	}
	471
	472	wxFileType *
	473	wxMimeTypesManagerImpl::Associate(const wxFileTypeInfo& ftInfo)
	474	{
	475	wxFAIL_MSG( _T("wxMimeTypesManagerImpl::Associate() not yet implemented") );
	476	//on mac you have to embed it into the mac's file reference resource ('FREF' I believe)
	477	//or, alternately, you could just add an entry to m_hDatabase, but you'd need to get
	478	//the app's signature somehow...
	479
	480	return NULL;
	481	}
	482
	483	bool
	484	wxMimeTypesManagerImpl::Unassociate(wxFileType *ft)
	485	{
	486	//this should be as easy as removing the entry from the database and then saving
	487	//the database
	488	return FALSE;
	489	}
	490
	491	#endif //wxUSE_MIMETYPE