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