コード例 #1
0
ファイル: filepath.c プロジェクト: karstenw/frontier
	boolean directorytopath ( const ptrfilespec fs, bigstring path ) {

		//
		// 2006-09-09 creedon: FSRef-ized
		//			       another way might be to use FSRefMakePath and then push insert the volume name on it
		//

		OSErr err;
		OSStatus status;
		FSRef volumesfsref;
		
		status = FSPathMakeRef ((UInt8 *)"/Volumes", &volumesfsref, NULL);
		
		if ((status == noErr) && (FSCompareFSRefs (&fs->ref, &volumesfsref) == noErr)) {	/* bail if fs is Volumes directory */
		
			setemptystring (path);
			
			return (true);
			}

		CFMutableStringRef ioPath = CFStringCreateMutable (NULL, 0);
		FSCatalogInfo catalogInfo;
		FSRef fsrefnomad = fs->ref;
		HFSUniStr255 names[100];
		int i, n;
		UniChar inSepChar = ':';
		
		err = noErr;

		clearbytes (&catalogInfo, longsizeof (catalogInfo));

		for (n = 0; err == noErr && catalogInfo.nodeID != fsRtDirID && n < 100; n++) {

			err = FSGetCatalogInfo (&fsrefnomad, kFSCatInfoNodeID, &catalogInfo, &names[n], NULL, &fsrefnomad);
			}
			
		if (err != noErr)
			return (false);
			
		for (i = n - 1; i >= 0; --i) {

			CFStringAppendCharacters (ioPath, names[i].unicode, names[i].length);
			
			CFStringAppendCharacters (ioPath, &inSepChar, 1);
			}
		
		boolean success = CFStringGetPascalString (ioPath, path, 256, kCFStringEncodingMacRoman);
		CFRelease(ioPath); //PBS 2/28/11: fixed memory leak
		return success;
	} // directorytopath
コード例 #2
0
ファイル: ftmac.c プロジェクト: 32767/libgdx
  static FT_Error
  FT_GetFileRef_From_Mac_ATS_Name( const char*  fontName,
                                   FSRef*       ats_font_ref,
                                   FT_Long*     face_index )
  {
    CFStringRef  cf_fontName;
    ATSFontRef   ats_font_id;


    *face_index = 0;

    cf_fontName = CFStringCreateWithCString( NULL, fontName,
                                             kCFStringEncodingMacRoman );
    ats_font_id = ATSFontFindFromName( cf_fontName,
                                       kATSOptionFlagsUnRestrictedScope );
    CFRelease( cf_fontName );

    if ( ats_font_id == 0 || ats_font_id == 0xFFFFFFFFUL )
      return FT_Err_Unknown_File_Format;

    if ( noErr != FT_ATSFontGetFileReference( ats_font_id, ats_font_ref ) )
      return FT_Err_Unknown_File_Format;

    /* face_index calculation by searching preceding fontIDs */
    /* with same FSRef                                       */
    {
      ATSFontRef  id2 = ats_font_id - 1;
      FSRef       ref2;


      while ( id2 > 0 )
      {
        if ( noErr != FT_ATSFontGetFileReference( id2, &ref2 ) )
          break;
        if ( noErr != FSCompareFSRefs( ats_font_ref, &ref2 ) )
          break;

        id2 --;
      }
      *face_index = ats_font_id - ( id2 + 1 );
    }

    return FT_Err_Ok;
  }
コード例 #3
0
OSStatus FindPIDForWoW(pid_t *pid) {
    CFURLRef outAppURL;
    OSErr err;
	err = LSFindApplicationForInfo(NULL,
								   (CFStringRef)@"com.blizzard.worldofwarcraft",
								   NULL,
								   NULL,
								   &outAppURL);
    err = 0;
	FSRef desired, found;
	ProcessSerialNumber psn = {0, kNoProcess};
    
	if (!CFURLGetFSRef(outAppURL, &desired)) return errFSBadFSRef;
	do {
		err = GetNextProcess(&psn);
		if (err) return err; // -600 = process not found
		err = GetProcessBundleLocation(&psn, &found);
	} while (err || FSCompareFSRefs(&desired, &found));
	err = GetProcessPID(&psn, pid);
	if (err) return err;
	return noErr;
}
コード例 #4
0
ファイル: ae.c プロジェクト: AdminCNP/appscript
static PyObject *AE_PSNDescForApplicationPath(PyObject* self, PyObject* args)
{
	ProcessSerialNumber psn = {0, kNoProcess};
	FSRef appRef, foundRef;
	AEDesc result;
	OSStatus err;
	
	if (!PyArg_ParseTuple(args, "O&", 
								AE_GetFSRef, &appRef))
		return NULL;
	while (1) {
		err = GetNextProcess(&psn);
		if (err) return AE_MacOSError(err);
		err = GetProcessBundleLocation(&psn, &foundRef);
		if (err == noErr && FSCompareFSRefs(&appRef, &foundRef) == noErr) break;
	}
	err = AECreateDesc(typeProcessSerialNumber,
	                   &psn, sizeof(psn),
	                   &result);
	if (err != noErr) return AE_MacOSError(err);
	return Py_BuildValue("O&",
	                     AE_AEDesc_New, &result);
}
コード例 #5
0
ファイル: platform_fonts.c プロジェクト: nunoneto/vlc
char* MacLegacy_Select( filter_t *p_filter, const char* psz_fontname,
                        bool b_bold, bool b_italic, int i_size, int *i_idx )
{
    VLC_UNUSED( b_bold );
    VLC_UNUSED( b_italic );
    VLC_UNUSED( i_size );
    FSRef ref;
    unsigned char path[MAXPATHLEN];
    char * psz_path;

    CFStringRef  cf_fontName;
    ATSFontRef   ats_font_id;

    *i_idx = 0;

    if( psz_fontname == NULL )
        return NULL;

    msg_Dbg( p_filter, "looking for %s", psz_fontname );
    cf_fontName = CFStringCreateWithCString( kCFAllocatorDefault, psz_fontname, kCFStringEncodingUTF8 );

    ats_font_id = ATSFontFindFromName( cf_fontName, kATSOptionFlagsIncludeDisabledMask );

    if ( ats_font_id == 0 || ats_font_id == 0xFFFFFFFFUL )
    {
        msg_Dbg( p_filter, "ATS couldn't find %s by name, checking family", psz_fontname );
        ats_font_id = ATSFontFamilyFindFromName( cf_fontName, kATSOptionFlagsDefault );

        if ( ats_font_id == 0 || ats_font_id == 0xFFFFFFFFUL )
        {
            msg_Dbg( p_filter, "ATS couldn't find either %s nor its family, checking PS name", psz_fontname );
            ats_font_id = ATSFontFindFromPostScriptName( cf_fontName, kATSOptionFlagsDefault );

            if ( ats_font_id == 0 || ats_font_id == 0xFFFFFFFFUL )
            {
                msg_Err( p_filter, "ATS couldn't find %s (no font name, family or PS name)", psz_fontname );
                CFRelease( cf_fontName );
                return NULL;
            }
        }
    }
    CFRelease( cf_fontName );

    if ( noErr != ATSFontGetFileReference( ats_font_id, &ref ) )
    {
        msg_Err( p_filter, "ATS couldn't get file ref for %s", psz_fontname );
        return NULL;
    }

    /* i_idx calculation by searching preceding fontIDs */
    /* with same FSRef                                       */
    {
        ATSFontRef  id2 = ats_font_id - 1;
        FSRef       ref2;

        while ( id2 > 0 )
        {
            if ( noErr != ATSFontGetFileReference( id2, &ref2 ) )
                break;
            if ( noErr != FSCompareFSRefs( &ref, &ref2 ) )
                break;

            id2 --;
        }
        *i_idx = ats_font_id - ( id2 + 1 );
    }

    if ( noErr != FSRefMakePath( &ref, path, sizeof(path) ) )
    {
        msg_Err( p_filter, "failure when getting path from FSRef" );
        return NULL;
    }
    msg_Dbg( p_filter, "found %s", path );

    psz_path = strdup( (char *)path );

    return psz_path;
}
コード例 #6
0
ファイル: main.c プロジェクト: Kentzo/Iceberg
void SplitForks(FSRef * inFileReference,FSRef * inParentReference,Boolean inFirstLevel)
{
	OSErr tErr;
	FSIterator tIterator;
	
	if (inFirstLevel==TRUE)
	{
		FSCatalogInfo tInfo;
		HFSUniStr255 tUnicodeFileName;
		
		// We need to split forks of the first level (and it allows us to check whether it's a folder or not)
		
		tErr=FSGetCatalogInfo(inFileReference,kFSCatInfoGettableInfo,&tInfo,&tUnicodeFileName,NULL,NULL);
		
		if (tErr==noErr)
		{
			// Check this is not a Hard Link
				
			if ((tInfo.nodeFlags & kFSNodeHardLinkMask)==0)
			{
				tErr=SplitFileIfNeeded(inFileReference,inParentReference,&tInfo,&tUnicodeFileName);
				
				if (tErr==noErr)
				{
					if (tInfo.nodeFlags & kFSNodeIsDirectoryMask)
					{
						// It's a folder
					
						// We need to proceed with the contents of the folder
					
						SplitForks(inFileReference,inParentReference,FALSE);
					}
				}
				else
				{
					exit(-1);
				}
			}
		}
		else
		{
			logerror("An error while getting Catalog Information for the File\n");
		}
		
		return;
	}
	
	tErr=FSOpenIterator(inFileReference,kFSIterateFlat,&tIterator);
	
	if (tErr==noErr)
	{
		ItemCount tLookForItems,tFoundItems;
		FSCatalogInfo * tFoundCatInfo;
		FSRef * tFoundReferences;
		HFSUniStr255 * tFoundFileNames;
		FSRef tPreviousCacheRef;
		Boolean tPreviousCacheRefSet=FALSE;
		
		tLookForItems=1;
			
		tFoundCatInfo=(FSCatalogInfo *) malloc(tLookForItems*sizeof(FSCatalogInfo));
			
		tFoundReferences=(FSRef *) malloc(tLookForItems*sizeof(FSRef));
		
		tFoundFileNames=(HFSUniStr255 *) malloc(tLookForItems*sizeof(HFSUniStr255));
		
		do
		{
			tErr=FSGetCatalogInfoBulk(tIterator, tLookForItems, &tFoundItems,
				NULL, kFSCatInfoGettableInfo, tFoundCatInfo,
				tFoundReferences, NULL, tFoundFileNames);
			
			if (tErr==noErr)
			{
				if (tPreviousCacheRefSet==TRUE)
				{
					if (FSCompareFSRefs(&tPreviousCacheRef,&tFoundReferences[0])==noErr)
					{
						// We need to skip the file since this is the one we processed previously
					
						continue;
					}
				}
				else
				{
					tPreviousCacheRefSet=TRUE;
				}
				
				tPreviousCacheRef=tFoundReferences[0];
				
				// Check this is not a Hard Link
				
				if ((tFoundCatInfo[0].nodeFlags & kFSNodeHardLinkMask)==0)
				{
					tErr=SplitFileIfNeeded(&tFoundReferences[0],inFileReference,&tFoundCatInfo[0],&tFoundFileNames[0]);
						
					if (tErr==noErr)
					{
						if (tFoundCatInfo[0].nodeFlags & kFSNodeIsDirectoryMask)
						{				
							// 2. We need to proceed with the contents of the folder
						
							SplitForks(&tFoundReferences[0],inFileReference,FALSE);
						}
					}
					else
					{
						exit(-1);
					}
				}
			}
			else
			{
				// A COMPLETER
			}
		}
		while (tErr==noErr);
		
		free(tFoundCatInfo);
		
		free(tFoundReferences);
		
		free(tFoundFileNames);
		
		FSCloseIterator (tIterator);
	}
	
	if (tErr!=noErr)
	{
		switch(tErr)
		{
			case errFSNoMoreItems:
				// No more items in the folder, this is perfectly ok
				break;
			case afpAccessDenied:
				break;
			default:
				// A COMPLETER
		
				break;
		}
	}
}