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