Пример #1
0
QList<VolumeInfo>  RunInfo::mountedVolumes()
{
    QList<VolumeInfo> result;
    FSVolumeRefNum volume;
    FSVolumeInfo info;
    HFSUniStr255 volName;
    FSRef ref;
    int i = 0;

    while (FSGetVolumeInfo(kFSInvalidVolumeRefNum, ++i, &volume, kFSVolInfoFSInfo, &info, &volName, &ref) == 0) {
        UInt8 path[PATH_MAX + 1];
        if (FSRefMakePath(&ref, path, PATH_MAX) == 0) {
            FSGetVolumeInfo(volume, 0, 0, kFSVolInfoSizes, &info, 0, 0);

            VolumeInfo v;
            v.setSize(quint64(info.totalBytes));
            v.setAvailableSize(quint64(info.freeBytes));
            v.setMountPath(QString::fromLocal8Bit(reinterpret_cast< char* >(path)));

            struct statfs data;
            if (statfs(qPrintable(v.mountPath() + QLatin1String("/.")), &data) == 0) {
                v.setFileSystemType(QLatin1String(data.f_fstypename));
                v.setVolumeDescriptor(QLatin1String(data.f_mntfromname));
            }
            result.append(v);
        }
    }
    return result;
}
Пример #2
0
void QStorageInfoPrivate::retrieveLabel()
{
#if !defined(Q_OS_IOS)
	// deprecated since 10.8
	FSRef ref;
	FSPathMakeRef(reinterpret_cast<const UInt8*>(QFile::encodeName(rootPath).constData()),
	              &ref,
	              Q_NULLPTR);
	// deprecated since 10.8
	FSCatalogInfo catalogInfo;
	OSErr error;
	error = FSGetCatalogInfo(&ref, kFSCatInfoVolume, &catalogInfo, Q_NULLPTR, Q_NULLPTR, Q_NULLPTR);

	if (error != noErr)
	{
		return;
	}

	// deprecated (use CFURLCopyResourcePropertiesForKeys for 10.7 and higher)
	HFSUniStr255 volumeName;
	error = FSGetVolumeInfo(catalogInfo.volume,
	                        0,
	                        Q_NULLPTR,
	                        kFSVolInfoFSInfo,
	                        Q_NULLPTR,
	                        &volumeName,
	                        Q_NULLPTR);

	if (error == noErr)
	{
		name = QCFString(FSCreateStringFromHFSUniStr(Q_NULLPTR, &volumeName));
	}

#endif
}
Пример #3
0
static void nglSetPathVolumeFromRefNum(int32 volnum, nglPathVolume& rPath)
{
  // Get the volume Name:
  FSVolumeInfo info;
  HFSUniStr255 volumeName;
  FSRef root;

  FSGetVolumeInfo(volnum, 0, NULL, kFSVolInfoNone, &info, &volumeName, &root);

  // Fetch the name:

  rPath.mComment.Import((char*)volumeName.unicode, volumeName.length*2, eUCS2);
	// Then the root path:
	char path[1024];
  FSRefMakePath(&root, (UInt8*)path, 1024);
	rPath.mPath = path;

	// Get other infos:
	GetVolParmsInfoBuffer buf;
  UInt32 s = sizeof(buf);
	nglFSGetVolParms(volnum, s, &buf, &s);

  rPath.mType = nglPathVolume::eTypeHD;
  if (VolIsNetworkVolume(&buf))
	  rPath.mType = nglPathVolume::eTypeNetwork;

  rPath.mFlags = 0;
  if (VolIsEjectable(&buf))
    rPath.mFlags |= nglPathVolume::Removable;
}
Пример #4
0
uint gp_file_name_root(const char *fname, uint len)
{
        OSErr err = noErr;
        HFSUniStr255 volumeName;
        FSRef rootDirectory;
        int index, match;

    if (len > 0 && fname[0] == ':')
                return 0; /* A relative path, no root. */

        /* iterate over mounted volumes and compare our path */
        index = 1;
        while (err == noErr) {
                err = FSGetVolumeInfo (kFSInvalidVolumeRefNum, index,
                        NULL, kFSVolInfoNone, NULL, /* not interested in these fields */
                        &volumeName, &rootDirectory);
                if (err == nsvErr) return 0; /* no more volumes */
                if (err == noErr) {
                        match = compare_UniStr(volumeName, fname, len);
                        if (match > 0) {
                        /* include the separator if it's present  */
                                if (fname[match] == ':') return match + 1;
                                return match;
                        }
                }
                index++;
        }

        /* nothing matched */
    return 0;
}
Пример #5
0
OSErr MyGetVInfo(short drvNum, StringPtr volNamePtr, short *vRefNumPtr, double *freeBytesPtr)
{
	OSErr err = 0;
	
	if(volNamePtr) volNamePtr[0] = 0;
	if(vRefNumPtr) *vRefNumPtr = 0;
	if(freeBytesPtr) *freeBytesPtr = 0;
	#if TARGET_API_MAC_CARBON
	{
		FSVolumeRefNum volume = kFSInvalidVolumeRefNum; // to index through the volumes
		ItemCount volumeIndex = drvNum; // // hmmm... maybe the drvNum is the index into the drives
		FSVolumeRefNum actualVolume;
		FSVolumeInfoBitmap whichInfo;
		FSVolumeInfo info;
		HFSUniStr255 * volumeName = 0; // we don't ask for this info
		FSRef rootDirectoryFSRef; 

		
		// only ask for the sizes if we need to
		if(freeBytesPtr)
			whichInfo = kFSVolInfoSizes;
		else
			whichInfo = kFSVolInfoNone;
		
		memset(&info,0,sizeof(info));
		err = FSGetVolumeInfo (volume,volumeIndex,&actualVolume,whichInfo,&info,volumeName,&rootDirectoryFSRef);
		if(!err) {
			if(vRefNumPtr) *vRefNumPtr = actualVolume;
			if(freeBytesPtr) *freeBytesPtr = info.freeBytes;
			if(volNamePtr){
				FSSpec fsSpec;
				err = FSGetCatalogInfo(&rootDirectoryFSRef, 0,0,0,&fsSpec,0)  ;
				if(!err) {
					mypstrcpyJM(volNamePtr,(char*)fsSpec.name);
				}
			}
		}
	}
	#else // MACB4CARBON
	{
		char pStr[256];
		short vNum;
		long fBytes;
		
		err = GetVInfo(drvNum,(StringPtr)pStr,&vNum,&fBytes);
		if(!err) {
			if(volNamePtr) mypstrcpyJM(volNamePtr,pStr);
			if(vRefNumPtr) *vRefNumPtr = vNum;
			if(freeBytesPtr) *freeBytesPtr = fBytes;
		}
	}
	#endif
	
	return err;
}
Пример #6
0
QString Utils::filesystemName(QString path)
{
    QString name;
#if defined(Q_OS_WIN32)
    wchar_t volname[MAX_PATH+1];
    bool res = GetVolumeInformationW((LPTSTR)path.utf16(), volname, MAX_PATH+1,
            NULL, NULL, NULL, NULL, 0);
    if(res) {
        name = QString::fromWCharArray(volname);
    }
#endif
#if defined(Q_OS_MACX)
    // BSD label does not include folder.
    QString bsd = Utils::resolveDevicename(path).remove("/dev/");
    if(bsd.isEmpty()) {
        return name;
    }
    OSStatus result;
    ItemCount index = 1;

    do {
        FSVolumeRefNum volrefnum;
        HFSUniStr255 volname;

        result = FSGetVolumeInfo(kFSInvalidVolumeRefNum, index, &volrefnum,
                kFSVolInfoFSInfo, NULL, &volname, NULL);

        if(result == noErr) {
            GetVolParmsInfoBuffer volparms;
            HParamBlockRec hpb;
            hpb.ioParam.ioNamePtr = NULL;
            hpb.ioParam.ioVRefNum = volrefnum;
            hpb.ioParam.ioBuffer = (Ptr)&volparms;
            hpb.ioParam.ioReqCount = sizeof(volparms);

            if(PBHGetVolParmsSync(&hpb) == noErr) {
                if(volparms.vMServerAdr == 0) {
                    if(bsd == (char*)volparms.vMDeviceID) {
                        name = QString::fromUtf16((const ushort*)volname.unicode,
                                                  (int)volname.length);
                        break;
                    }
                }
            }
        }
        index++;
    } while(result == noErr);
#endif

    qDebug() << "[Utils] Volume name of" << path << "is" << name;
    return name;
}
Пример #7
0
void nglPathVolume::UpdateVolumes(std::list<nglPathVolume>& rVolumes)
{
  OSErr    result;
  uint volumeIndex = 1;

  /* Call FSGetVolumeInfo in loop to get all volumes starting with the first */
  do
  {
    FSVolumeRefNum refnum = 0;
    result = FSGetVolumeInfo(kFSInvalidVolumeRefNum, volumeIndex, &refnum, kFSVolInfoNone, NULL, NULL, NULL);
    if ( noErr == result )
    {
      // Found a new volume.
      AddVolume(rVolumes, refnum);
      ++volumeIndex;
    }
  } while ( noErr == result );
}
Пример #8
0
int DetectAudioCDVolumes(FSVolumeRefNum *volumes, int numVolumes)
{
    int volumeIndex;
    int cdVolumeCount = 0;
    OSStatus result = noErr;
    
    for (volumeIndex = 1; result == noErr || result != nsvErr; volumeIndex++)
    {
        FSVolumeRefNum  actualVolume;
        FSVolumeInfo    volumeInfo;
        
        memset (&volumeInfo, 0, sizeof(volumeInfo));
        
        result = FSGetVolumeInfo (kFSInvalidVolumeRefNum,
                                  volumeIndex,
                                  &actualVolume,
                                  kFSVolInfoFSInfo,
                                  &volumeInfo,
                                  NULL,
                                  NULL); 
         
        if (result == noErr)
        {
            if (volumeInfo.filesystemID == kAudioCDFilesystemID) 
            {
                if (volumes != NULL && cdVolumeCount < numVolumes)
                    volumes[cdVolumeCount] = actualVolume;
            
                cdVolumeCount++;
            }
        }
        else 
        {
            
            
        }
    }
        
    return cdVolumeCount;
}
Пример #9
0
/** Eject device from PC.
 *  Request the OS to eject the player.
 *  @param device mountpoint of the device
 *  @return true on success, fals otherwise.
 */
bool Utils::ejectDevice(QString device)
{
#if defined(Q_OS_WIN32)
    /* See http://support.microsoft.com/kb/165721 on the procedure to eject a
     * device. */
    bool success = false;
    int i;
    HANDLE hdl;
    DWORD bytesReturned;
    TCHAR volume[8];

    /* CreateFile */
    _stprintf(volume, _TEXT("\\\\.\\%c:"), device.toLatin1().at(0));
    hdl = CreateFile(volume, GENERIC_READ | GENERIC_WRITE,
            FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
            OPEN_EXISTING, 0, NULL);
    if(hdl == INVALID_HANDLE_VALUE)
        return false;

    /* lock volume to make sure no other application is accessing the volume.
     * Try up to 10 times. */
    for(i = 0; i < 10; i++) {
        if(DeviceIoControl(hdl, FSCTL_LOCK_VOLUME,
                    NULL, 0, NULL, 0, &bytesReturned, NULL))
            break;
        /* short break before retry */
        Sleep(100);
    }
    if(i < 10) {
        /* successfully locked, now dismount */
        if(DeviceIoControl(hdl, FSCTL_DISMOUNT_VOLUME,
                    NULL, 0, NULL, 0, &bytesReturned, NULL)) {
            /* make sure media can be removed. */
            PREVENT_MEDIA_REMOVAL pmr;
            pmr.PreventMediaRemoval = false;
            if(DeviceIoControl(hdl, IOCTL_STORAGE_MEDIA_REMOVAL,
                        &pmr, sizeof(PREVENT_MEDIA_REMOVAL),
                        NULL, 0, &bytesReturned, NULL)) {
                /* eject the media */
                if(DeviceIoControl(hdl, IOCTL_STORAGE_EJECT_MEDIA,
                            NULL, 0, NULL, 0, &bytesReturned, NULL))
                    success = true;
            }
        }
    }
    /* close handle */
    CloseHandle(hdl);
    return success;

#endif
#if defined(Q_OS_MACX)
    // FIXME: FSUnmountVolumeSync is deprecated starting with 10.8.
    // Use DADiskUnmount / DiskArbitration framework eventually.
    // BSD label does not include folder.
    QString bsd = Utils::resolveDevicename(device).remove("/dev/");
    OSStatus result;
    ItemCount index = 1;
    bool found = false;

    do {
        FSVolumeRefNum volrefnum;

        result = FSGetVolumeInfo(kFSInvalidVolumeRefNum, index, &volrefnum,
                kFSVolInfoFSInfo, NULL, NULL, NULL);
        if(result == noErr) {
            GetVolParmsInfoBuffer volparms;
            /* See above -- PBHGetVolParmsSync() is not available for 64bit,
             * and FSGetVolumeParms() on 10.5+ only. */
#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1050
            if(FSGetVolumeParms(volrefnum, &volparms, sizeof(volparms)) == noErr)
#else
            HParamBlockRec hpb;
            hpb.ioParam.ioNamePtr = NULL;
            hpb.ioParam.ioVRefNum = volrefnum;
            hpb.ioParam.ioBuffer = (Ptr)&volparms;
            hpb.ioParam.ioReqCount = sizeof(volparms);
            if(PBHGetVolParmsSync(&hpb) == noErr)
#endif
            {
                if(volparms.vMServerAdr == 0) {
                    if(bsd == (char*)volparms.vMDeviceID) {
                        pid_t dissenter;
                        result = FSUnmountVolumeSync(volrefnum, 0, &dissenter);
                        found = true;
                        break;
                    }
                }
            }
        }
        index++;
    } while(result == noErr);
    if(result == noErr && found)
        return true;

#endif
#if defined(Q_OS_LINUX)
    (void)device;
#endif
    return false;
}
Пример #10
0
QString Utils::filesystemName(QString path)
{
    QString name;
#if defined(Q_OS_WIN32)
    wchar_t volname[MAX_PATH+1];
    bool res = GetVolumeInformationW((LPTSTR)path.utf16(), volname, MAX_PATH+1,
            NULL, NULL, NULL, NULL, 0);
    if(res) {
        name = QString::fromWCharArray(volname);
    }
#endif
#if defined(Q_OS_MACX)
    // BSD label does not include folder.
    QString bsd = Utils::resolveDevicename(path).remove("/dev/");
    if(bsd.isEmpty()) {
        return name;
    }
    OSStatus result;
    ItemCount index = 1;

    do {
        FSVolumeRefNum volrefnum;
        HFSUniStr255 volname;

        result = FSGetVolumeInfo(kFSInvalidVolumeRefNum, index, &volrefnum,
                kFSVolInfoFSInfo, NULL, &volname, NULL);

        if(result == noErr) {
            GetVolParmsInfoBuffer volparms;
            /* PBHGetVolParmsSync() is not available for 64bit while
            FSGetVolumeParms() is available in 10.5+. Thus we need to use
            PBHGetVolParmsSync() for 10.4, and that also requires 10.4 to
            always use 32bit.
            Qt 4 supports 32bit on 10.6 Cocoa only.
            */
#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1050
            if(FSGetVolumeParms(volrefnum, &volparms, sizeof(volparms)) == noErr)
#else
            HParamBlockRec hpb;
            hpb.ioParam.ioNamePtr = NULL;
            hpb.ioParam.ioVRefNum = volrefnum;
            hpb.ioParam.ioBuffer = (Ptr)&volparms;
            hpb.ioParam.ioReqCount = sizeof(volparms);
            if(PBHGetVolParmsSync(&hpb) == noErr)
#endif
            {
                if(volparms.vMServerAdr == 0) {
                    if(bsd == (char*)volparms.vMDeviceID) {
                        name = QString::fromUtf16((const ushort*)volname.unicode,
                                                  (int)volname.length);
                        break;
                    }
                }
            }
        }
        index++;
    } while(result == noErr);
#endif

    LOG_INFO() << "Volume name of" << path << "is" << name;
    return name;
}
Пример #11
0
int main(int argc, const char* argv[])
{
  kern_return_t kernResult;
  OSErr result = noErr;
  ItemCount volumeIndex;

  kernResult = IOMasterPort(MACH_PORT_NULL, &gMasterPort);
  if (KERN_SUCCESS != kernResult)
    printf("IOMasterPort returned %d\n", kernResult);

  // Iterate across all mounted volumes using FSGetVolumeInfo. This will return nsvErr
  // (no such volume) when volumeIndex becomes greater than the number of mounted volumes.
  for (volumeIndex = 1; result == noErr || result != nsvErr; volumeIndex++) {
    FSVolumeRefNum actualVolume;
    HFSUniStr255 volumeName;
    FSVolumeInfo volumeInfo;

    bzero((void*)&volumeInfo, sizeof(volumeInfo));

    // We're mostly interested in the volume reference number (actualVolume)
    result = FSGetVolumeInfo(kFSInvalidVolumeRefNum, volumeIndex, &actualVolume, kFSVolInfoFSInfo, &volumeInfo, &volumeName, NULL);

    if (result == noErr) {
      GetVolParmsInfoBuffer volumeParms;
      HParamBlockRec pb;

      // Use the volume reference number to retrieve the volume parameters. See the documentation
      // on PBHGetVolParmsSync for other possible ways to specify a volume.
      pb.ioParam.ioNamePtr = NULL;
      pb.ioParam.ioVRefNum = actualVolume;
      pb.ioParam.ioBuffer = (Ptr) & volumeParms;
      pb.ioParam.ioReqCount = sizeof(volumeParms);

      // A version 4 GetVolParmsInfoBuffer contains the BSD node name in the vMDeviceID field.
      // It is actually a char * value. This is mentioned in the header CoreServices/CarbonCore/Files.h.
      result = PBHGetVolParmsSync(&pb);

      if (result != noErr) {
        printf("PBHGetVolParmsSync returned %d\n", result);
      } else {
        // This code is just to convert the volume name from a HFSUniCharStr to
        // a plain C string so we can print it with printf. It'd be preferable to
        // use CoreFoundation to work with the volume name in its Unicode form.
        CFStringRef volNameAsCFString;
        char volNameAsCString[256];

        volNameAsCFString = CFStringCreateWithCharacters(kCFAllocatorDefault, volumeName.unicode, volumeName.length);

        // If the conversion to a C string fails, just treat it as a null string.
        if (!CFStringGetCString(volNameAsCFString, volNameAsCString, sizeof(volNameAsCString), kCFStringEncodingUTF8)) {
          volNameAsCString[0] = 0;
        }

        // The last parameter of this printf call is the BSD node name from the
        // GetVolParmsInfoBuffer struct.
        printf("Volume \"%s\" (vRefNum %d), BSD node /dev/%s, ", volNameAsCString, actualVolume, (char*)volumeParms.vMDeviceID);

        // Use the BSD node name to call I/O Kit and get additional information about the volume
        GetAdditionalVolumeInfo((char*)volumeParms.vMDeviceID);
      }
    }
  }

  return 0;
}
Пример #12
0
size_t wxGetAvailableDrives(wxArrayString &paths, wxArrayString &names, wxArrayInt &icon_ids)
{
#ifdef wxHAS_FILESYSTEM_VOLUMES

#ifdef __WXWINCE__
    // No logical drives; return "\"
    paths.Add(wxT("\\"));
    names.Add(wxT("\\"));
    icon_ids.Add(wxFileIconsTable::computer);
#elif defined(__WIN32__) && wxUSE_FSVOLUME
    // TODO: this code (using wxFSVolumeBase) should be used for all platforms
    //       but unfortunately wxFSVolumeBase is not implemented everywhere
    const wxArrayString as = wxFSVolumeBase::GetVolumes();

    for (size_t i = 0; i < as.GetCount(); i++)
    {
        wxString path = as[i];
        wxFSVolume vol(path);
        int imageId;
        switch (vol.GetKind())
        {
            case wxFS_VOL_FLOPPY:
                if ( (path == wxT("a:\\")) || (path == wxT("b:\\")) )
                    imageId = wxFileIconsTable::floppy;
                else
                    imageId = wxFileIconsTable::removeable;
                break;
            case wxFS_VOL_DVDROM:
            case wxFS_VOL_CDROM:
                imageId = wxFileIconsTable::cdrom;
                break;
            case wxFS_VOL_NETWORK:
                if (path[0] == wxT('\\'))
                    continue; // skip "\\computer\folder"
                imageId = wxFileIconsTable::drive;
                break;
            case wxFS_VOL_DISK:
            case wxFS_VOL_OTHER:
            default:
                imageId = wxFileIconsTable::drive;
                break;
        }
        paths.Add(path);
        names.Add(vol.GetDisplayName());
        icon_ids.Add(imageId);
    }
#elif defined(__OS2__)
    APIRET rc;
    ULONG ulDriveNum = 0;
    ULONG ulDriveMap = 0;
    rc = ::DosQueryCurrentDisk(&ulDriveNum, &ulDriveMap);
    if ( rc == 0)
    {
        size_t i = 0;
        while (i < 26)
        {
            if (ulDriveMap & ( 1 << i ))
            {
                const wxString path = wxFileName::GetVolumeString(
                                        'A' + i, wxPATH_GET_SEPARATOR);
                const wxString name = wxFileName::GetVolumeString(
                                        'A' + i, wxPATH_NO_SEPARATOR);

                // Note: If _filesys is unsupported by some compilers,
                //       we can always replace it by DosQueryFSAttach
                char filesysname[20];
#ifdef __WATCOMC__
                ULONG cbBuffer = sizeof(filesysname);
                PFSQBUFFER2 pfsqBuffer = (PFSQBUFFER2)filesysname;
                APIRET rc = ::DosQueryFSAttach(name.fn_str(),0,FSAIL_QUERYNAME,pfsqBuffer,&cbBuffer);
                if (rc != NO_ERROR)
                {
                    filesysname[0] = '\0';
                }
#else
                _filesys(name.fn_str(), filesysname, sizeof(filesysname));
#endif
                /* FAT, LAN, HPFS, CDFS, NFS */
                int imageId;
                if (path == wxT("A:\\") || path == wxT("B:\\"))
                    imageId = wxFileIconsTable::floppy;
                else if (!strcmp(filesysname, "CDFS"))
                    imageId = wxFileIconsTable::cdrom;
                else if (!strcmp(filesysname, "LAN") ||
                         !strcmp(filesysname, "NFS"))
                    imageId = wxFileIconsTable::drive;
                else
                    imageId = wxFileIconsTable::drive;
                paths.Add(path);
                names.Add(name);
                icon_ids.Add(imageId);
            }
            i ++;
        }
    }
#else // !__WIN32__, !__OS2__
    /* If we can switch to the drive, it exists. */
    for ( char drive = 'A'; drive <= 'Z'; drive++ )
    {
        const wxString
            path = wxFileName::GetVolumeString(drive, wxPATH_GET_SEPARATOR);

        if (wxIsDriveAvailable(path))
        {
            paths.Add(path);
            names.Add(wxFileName::GetVolumeString(drive, wxPATH_NO_SEPARATOR));
            icon_ids.Add(drive <= 2 ? wxFileIconsTable::floppy
                                    : wxFileIconsTable::drive);
        }
    }
#endif // __WIN32__/!__WIN32__

#elif defined(__WXMAC__) && wxOSX_USE_COCOA_OR_CARBON

    ItemCount volumeIndex = 1;
    OSErr err = noErr ;

    while( noErr == err )
    {
        HFSUniStr255 volumeName ;
        FSRef fsRef ;
        FSVolumeInfo volumeInfo ;
        err = FSGetVolumeInfo(0, volumeIndex, NULL, kFSVolInfoFlags , &volumeInfo , &volumeName, &fsRef);
        if( noErr == err )
        {
            wxString path = wxMacFSRefToPath( &fsRef ) ;
            wxString name = wxMacHFSUniStrToString( &volumeName ) ;

            if ( (volumeInfo.flags & kFSVolFlagSoftwareLockedMask) || (volumeInfo.flags & kFSVolFlagHardwareLockedMask) )
            {
                icon_ids.Add(wxFileIconsTable::cdrom);
            }
            else
            {
                icon_ids.Add(wxFileIconsTable::drive);
            }
            // todo other removable

            paths.Add(path);
            names.Add(name);
            volumeIndex++ ;
        }
    }

#elif defined(__UNIX__) || defined(__WXPALMOS__)
    paths.Add(wxT("/"));
    names.Add(wxT("/"));
    icon_ids.Add(wxFileIconsTable::computer);
#else
    #error "Unsupported platform in wxGenericDirCtrl!"
#endif
    wxASSERT_MSG( (paths.GetCount() == names.GetCount()), wxT("The number of paths and their human readable names should be equal in number."));
    wxASSERT_MSG( (paths.GetCount() == icon_ids.GetCount()), wxT("Wrong number of icons for available drives."));
    return paths.GetCount();
}
Пример #13
0
void CheckSaveFolder (FSRef *cartRef)
{
	OSStatus		err;
	Boolean			r;
	FSCatalogInfo	finfo;
	FSVolumeInfo	vinfo;
	FSRef			ref;
	CFURLRef		burl, purl;
	char			s[PATH_MAX + 1];

	switch (saveInROMFolder)
	{
		case 0: // Snes9x folder
			burl = CFBundleCopyBundleURL(CFBundleGetMainBundle());
			purl = CFURLCreateCopyDeletingLastPathComponent(kCFAllocatorDefault, burl);
			r    = CFURLGetFSRef(purl, &ref);
			CFRelease(purl);
			CFRelease(burl);
			break;

		case 1: // ROM folder
			err = FSGetCatalogInfo(cartRef, kFSCatInfoNone, NULL, NULL, NULL, &ref);
			break;

		case 2: // Application Support folder
			return;

		case 4: // Custom folder
			if (saveFolderPath == NULL)
			{
				saveInROMFolder = 2;
				return;
			}

			r = CFStringGetCString(saveFolderPath, s, PATH_MAX, kCFStringEncodingUTF8);
			err = FSPathMakeRef((unsigned char *) s, &ref, NULL);
			if (err)
			{
				AppearanceAlert(kAlertCautionAlert, kS9xMacAlertFolderNotFound, kS9xMacAlertFolderNotFoundHint);
				saveInROMFolder = 2;
				return;
			}

			break;
	}

	err = FSGetCatalogInfo(&ref, kFSCatInfoUserPrivs | kFSCatInfoVolume, &finfo, NULL, NULL, NULL);
	if (err == noErr)
	{
		if (finfo.userPrivileges & kioACUserNoMakeChangesMask)
		{
			AppearanceAlert(kAlertCautionAlert, kS9xMacAlertFolderFailToCreate, kS9xMacAlertFolderFailToCreateHint);
			saveInROMFolder = 2;
			return;
		}

		err = FSGetVolumeInfo(finfo.volume, 0, NULL, kFSVolInfoFlags, &vinfo, NULL, NULL);
		if (err == noErr)
		{
			if ((vinfo.flags & kFSVolFlagHardwareLockedMask) || (vinfo.flags & kFSVolFlagSoftwareLockedMask))
			{
				AppearanceAlert(kAlertCautionAlert, kS9xMacAlertFolderFailToCreate, kS9xMacAlertFolderFailToCreateHint);
				saveInROMFolder = 2;
				return;
			}
		}
	}

	if (err)
		saveInROMFolder = 2;
}
Пример #14
0
int ListTrackFiles (FSVolumeRefNum theVolume, FSRef *trackFiles, int numTracks)
{
    OSStatus        result = -1;
    FSIterator      iterator;
    ItemCount       actualObjects;
    FSRef           rootDirectory;
    FSRef           ref;
    HFSUniStr255    nameStr;
    
    result = FSGetVolumeInfo (theVolume,
                              0,
                              NULL,
                              kFSVolInfoFSInfo,
                              NULL,
                              NULL,
                              &rootDirectory); 
                                 
    if (result != noErr) {
        SDL_SetError ("ListTrackFiles: FSGetVolumeInfo returned %d", result);
        return result;
    }

    result = FSOpenIterator (&rootDirectory, kFSIterateFlat, &iterator);
    if (result == noErr) {
        do
        {
            result = FSGetCatalogInfoBulk (iterator, 1, &actualObjects,
                                           NULL, kFSCatInfoNone, NULL, &ref, NULL, &nameStr);
            if (result == noErr) {
                
                CFStringRef  name;
                name = CFStringCreateWithCharacters (NULL, nameStr.unicode, nameStr.length);
                
                
                if (CFStringHasSuffix (name, CFSTR(".aiff")) ||
                    CFStringHasSuffix (name, CFSTR(".cdda"))) {
                    
                    
                    int trackID = 0, i = 0;
                    while (i < nameStr.length && !isdigit(nameStr.unicode[i])) {
                        ++i;
                    }
                    while (i < nameStr.length && isdigit(nameStr.unicode[i])) {
                        trackID = 10 * trackID +(nameStr.unicode[i] - '0');
                        ++i;
                    }

                    #if DEBUG_CDROM
                    printf("Found AIFF for track %d: '%s'\n", trackID, 
                    CFStringGetCStringPtr (name, CFStringGetSystemEncoding()));
                    #endif
                    
                    
                    trackID--;
                    
                    assert(0 <= trackID && trackID <= SDL_MAX_TRACKS);
                    
                    if (trackID < numTracks)
                        memcpy (&trackFiles[trackID], &ref, sizeof(FSRef));
                }
                CFRelease (name);
            }
        } while(noErr == result);
        FSCloseIterator (iterator);
    }
    
    return 0;
}
Пример #15
0
int ReadTOCData (FSVolumeRefNum theVolume, SDL_CD *theCD)
{
    HFSUniStr255      dataForkName;
    OSStatus          theErr;
    FSIORefNum        forkRefNum;
    SInt64            forkSize;
    Ptr               forkData = 0;
    ByteCount         actualRead;
    CFDataRef         dataRef = 0;
    CFPropertyListRef propertyListRef = 0;
    FSRefParam      fsRefPB;
    FSRef           tocPlistFSRef;
    FSRef           rootRef;
    const char* error = "Unspecified Error";
    const UniChar uniName[] = { '.','T','O','C','.','p','l','i','s','t' };

    theErr = FSGetVolumeInfo(theVolume, 0, 0, kFSVolInfoNone, 0, 0, &rootRef);
    if(theErr != noErr) {
        error = "FSGetVolumeInfo";
        goto bail;
    }

    SDL_memset(&fsRefPB, '\0', sizeof (fsRefPB));

    
    fsRefPB.ref = &rootRef;
    fsRefPB.newRef = &tocPlistFSRef;
    fsRefPB.nameLength = sizeof (uniName) / sizeof (uniName[0]);
    fsRefPB.name = uniName;
    fsRefPB.textEncodingHint = kTextEncodingUnknown;

    theErr = PBMakeFSRefUnicodeSync (&fsRefPB);
    if(theErr != noErr) {
        error = "PBMakeFSRefUnicodeSync";
        goto bail;
    }
    
    

    theErr = FSGetDataForkName (&dataForkName);
    if (theErr != noErr) {
        error = "FSGetDataForkName";
        goto bail;
    }
    
    theErr = FSOpenFork (&tocPlistFSRef, dataForkName.length, dataForkName.unicode, fsRdPerm, &forkRefNum);
    if (theErr != noErr) {
        error = "FSOpenFork";
        goto bail;
    }
    
    theErr = FSGetForkSize (forkRefNum, &forkSize);
    if (theErr != noErr) {
        error = "FSGetForkSize";
        goto bail;
    }
    
    
    forkData = NewPtr (forkSize);
    if(forkData == NULL) {
        error = "NewPtr";
        goto bail;
    }
    
    theErr = FSReadFork (forkRefNum, fsFromStart, 0 , forkSize, forkData, &actualRead);
    if(theErr != noErr) {
        error = "FSReadFork";
        goto bail;
    }
    
    dataRef = CFDataCreate (kCFAllocatorDefault, (UInt8 *)forkData, forkSize);
    if(dataRef == 0) {
        error = "CFDataCreate";
        goto bail;
    }

    propertyListRef = CFPropertyListCreateFromXMLData (kCFAllocatorDefault,
                                                       dataRef,
                                                       kCFPropertyListImmutable,
                                                       NULL);
    if (propertyListRef == NULL) {
        error = "CFPropertyListCreateFromXMLData";
        goto bail;
    }

    
    
    
    if(CFGetTypeID(propertyListRef)== CFDictionaryGetTypeID())
    {
        CFDictionaryRef dictRef = (CFDictionaryRef)propertyListRef;
        
        CFDataRef   theRawTOCDataRef;
        CFArrayRef  theSessionArrayRef;
        CFIndex     numSessions;
        CFIndex     index;
        
        
        theRawTOCDataRef = (CFDataRef)CFDictionaryGetValue (dictRef, CFSTR(kRawTOCDataString));
        
        
        theSessionArrayRef = (CFArrayRef)CFDictionaryGetValue (dictRef, CFSTR(kSessionsString));
        
        
        numSessions = CFArrayGetCount (theSessionArrayRef);
        
        
        theCD->numtracks = 0;
        
        
        for(index = 0; index < numSessions; index++)
        {
            CFDictionaryRef theSessionDict;
            CFNumberRef     leadoutBlock;
            CFArrayRef      trackArray;
            CFIndex         numTracks;
            CFIndex         trackIndex;
            UInt32          value = 0;
            
            theSessionDict      = (CFDictionaryRef) CFArrayGetValueAtIndex (theSessionArrayRef, index);
            leadoutBlock        = (CFNumberRef) CFDictionaryGetValue (theSessionDict, CFSTR(kLeadoutBlockString));
            
            trackArray = (CFArrayRef)CFDictionaryGetValue (theSessionDict, CFSTR(kTrackArrayString));
            
            numTracks = CFArrayGetCount (trackArray);

            for(trackIndex = 0; trackIndex < numTracks; trackIndex++) {
                    
                CFDictionaryRef theTrackDict;
                CFNumberRef     trackNumber;
                CFNumberRef     sessionNumber;
                CFNumberRef     startBlock;
                CFBooleanRef    isDataTrack;
                UInt32          value;
                
                theTrackDict  = (CFDictionaryRef) CFArrayGetValueAtIndex (trackArray, trackIndex);
                
                trackNumber   = (CFNumberRef)  CFDictionaryGetValue (theTrackDict, CFSTR(kPointKeyString));
                sessionNumber = (CFNumberRef)  CFDictionaryGetValue (theTrackDict, CFSTR(kSessionNumberKeyString));
                startBlock    = (CFNumberRef)  CFDictionaryGetValue (theTrackDict, CFSTR(kStartBlockKeyString));
                isDataTrack   = (CFBooleanRef) CFDictionaryGetValue (theTrackDict, CFSTR(kDataKeyString));
                                                        
                
                int idx = theCD->numtracks++;

                CFNumberGetValue (trackNumber, kCFNumberSInt32Type, &value);
                theCD->track[idx].id = value;
                
                CFNumberGetValue (startBlock, kCFNumberSInt32Type, &value);
                theCD->track[idx].offset = value;

                theCD->track[idx].type = (isDataTrack == kCFBooleanTrue) ? SDL_DATA_TRACK : SDL_AUDIO_TRACK;

                
                if (trackIndex > 0) {
                    theCD->track[idx-1].length = theCD->track[idx].offset - theCD->track[idx-1].offset;
                }
            }
            
            
            CFNumberGetValue (leadoutBlock, kCFNumberSInt32Type, &value);
            
            theCD->track[theCD->numtracks-1].length = 
                value - theCD->track[theCD->numtracks-1].offset;

            
            theCD->track[theCD->numtracks].offset = value;
        }
    
    }

    theErr = 0;
    goto cleanup;
bail:
    SDL_SetError ("ReadTOCData: %s returned %d", error, theErr);
    theErr = -1;
cleanup:

    if (propertyListRef != NULL)
        CFRelease(propertyListRef);
    if (dataRef != NULL)
        CFRelease(dataRef);
    if (forkData != NULL)
        DisposePtr(forkData);
        
    FSCloseFork (forkRefNum);

    return theErr;
}