C++ BVolume::GetName方法代码示例

// get_volume_info
bool
get_volume_info( BVolume& volume, BString& volumeName, bool& isCDROM, BString& deviceName )
{
    bool success = false;
    isCDROM = false;
    deviceName = "";
    volumeName = "";
    char name[B_FILE_NAME_LENGTH];
    if ( volume.GetName( name ) >= B_OK )    // disk is currently mounted
    {
        volumeName = name;
        dev_t dev = volume.Device();
        fs_info info;
        if ( fs_stat_dev( dev, &info ) == B_OK )
        {
            success = true;
            deviceName = info.device_name;
            if ( volume.IsReadOnly() )
            {
                int i_dev = open( info.device_name, O_RDONLY );
                if ( i_dev >= 0 )
                {
                    device_geometry g;
                    if ( ioctl( i_dev, B_GET_GEOMETRY, &g, sizeof( g ) ) >= 0 )
                        isCDROM = ( g.device_type == B_CD );
                    close( i_dev );
                }
            }
        }
     }
     return success;
}

void
IndexServer::AddVolume(const BVolume& volume)
{
	// ignore volumes like / or /dev
	if (volume.Capacity() == 0)
		return;
	
	// check if volume is already in our list
	for (int i = 0; i < fVolumeWatcherList.CountItems(); i++) {
		VolumeWatcher* current = fVolumeWatcherList.ItemAt(i);
		if (current->Volume() == volume)
			return;
	}

	char name[256];
	volume.GetName(name);
	STRACE("IndexServer::AddVolume %s\n", name);

	VolumeWatcher* watcher = new VolumeWatcher(volume);
/*	if (!watcher->Enabled()) {
		delete watcher;
		return;
	}*/
	fVolumeWatcherList.AddItem(watcher);
	_SetupVolumeWatcher(watcher);
	watcher->StartWatching();
}

void
ControlsView::VolumeTabView::AttachedToWindow()
{
	// Populate the menu with the persistent volumes.
	fVolumeRoster = new BVolumeRoster();

	BVolume tempVolume;
	while (fVolumeRoster->GetNextVolume(&tempVolume) == B_OK) {
		if (!tempVolume.IsPersistent())
			continue;

		char name[B_PATH_NAME_LENGTH];
		if (tempVolume.GetName(name) != B_OK)
			continue;

		if (strcmp(name, "system") == 0
			|| strcmp(name, "config") == 0) {
			// Don't include virtual volumes.
			continue;
		}

		BVolume* volume = new BVolume(tempVolume);
		VolumeView* volumeView = new VolumeView(name, volume);
		VolumeTab* volumeTab = new VolumeTab(volume);
		AddTab(volumeView, volumeTab);
	}

	// Begin watching mount and unmount events.
	fVolumeRoster->StartWatching(BMessenger(this));
}

bool
GeneralView::_CanFindServer(entry_ref* ref)
{
	// Try searching with be_roster
	if (be_roster->FindApp(kNotificationServerSignature, ref) == B_OK)
		return true;

	// Try with a query and take the first result
	BVolumeRoster vroster;
	BVolume volume;
	char volName[B_FILE_NAME_LENGTH];

	vroster.Rewind();

	while (vroster.GetNextVolume(&volume) == B_OK) {
		if ((volume.InitCheck() != B_OK) || !volume.KnowsQuery())
			continue;

		volume.GetName(volName);

		BQuery *query = new BQuery();
		query->SetPredicate("(BEOS:APP_SIG==\""kNotificationServerSignature"\")");
		query->SetVolume(&volume);
		query->Fetch();

		if (query->GetNextRef(ref) == B_OK)
			return true;
	}

	return false;
}

void PanelView::ReadDisks(void)
////////////////////////////////////////////////////////////////////////
{
	char drivename[256];
	char drivepath[256];

//	SetMousePointer(CR_HOURGLASS);
	MAINWINDOW->SetMousePointer(GenesisWindow::CR_HOURGLASS);

	CustomListItem *item;

	item = new CustomListItem("..",m_Path.String(),FT_DISKBACK, 0);
	item->AddIcon(m_ParentIcon);
	m_CustomListView->AddItem(item);
	item->SetHeight(15.0f);

	// Collect available volumes...
	BVolumeRoster *vr = new BVolumeRoster();
	if (vr)
	{
		BVolume v;
	
		while (vr->GetNextVolume(&v)==B_NO_ERROR)
		{
			if (v.GetName(drivename)==B_NO_ERROR)
			{
				if (strlen(drivename)>0)
				{
					BDirectory dir;
					BEntry entry;
					BPath path;
					v.GetRootDirectory(&dir);
					dir.GetEntry(&entry);
					entry.GetPath(&path);
					sprintf(drivepath,"%s",path.Path());
					item = new CustomListItem(drivename,drivepath,FT_DISKITEM,v.FreeBytes(),v.Capacity(),v.Device());
					m_CustomListView->AddItem(item);
					if (m_Setting_ShowIcons)
					{
						if (!item->GetIcon(&v))
							item->AddIcon(m_UnknownIcon);
						item->SetHeight(15.0f);
					}
				}
			}
		}

		delete vr;
	}

	m_CustomListView->DoSortList();

	m_CustomListView->Select(0,false);
//	SetMousePointer(CR_DEFAULT);
	MAINWINDOW->SetMousePointer(GenesisWindow::CR_DEFAULT);
}

void
NameAttributeText::ReadValue(BString *result)
{
#ifdef DEBUG
// x86 support :-)
	if ((modifiers() & B_CAPS_LOCK) != 0) {
		if (fModel->IsVolume()) {
			BVolumeRoster roster;
			roster.Rewind();
			BVolume volume;
			char device = 'A';
			while (roster.GetNextVolume(&volume) == B_OK) {
				char name[256];
				if (volume.GetName(name) == B_OK
					&& strcmp(name, fModel->Name()) == 0) {
					*result += device;
					*result += ':';
					fValueDirty = false;
					return;
				}
				device++;
			}
		}
		const char *modelName = fModel->Name();
		bool hasDot = strstr(".", modelName) != 0;
		for (int32 index = 0; index < 8; index++) {
			if (!modelName[index] || modelName[index] == '.')
				break;
			*result += toupper(modelName[index]);
		}
		if (hasDot) {
			modelName = strstr(".", modelName);
			for (int32 index = 0; index < 4; index++) {
				if (!modelName[index])
					break;
				*result += toupper(modelName[index]);
			}
		} else if (fModel->IsExecutable())
			*result += ".EXE";

	} else
#endif
	*result = fModel->Name();

	fValueDirty = false;
}

void
ControlsView::VolumeTabView::_AddVolume(dev_t device)
{
	// Make sure the volume is not already in the menu.
	for (int i = 0; VolumeTab* item = (VolumeTab*)TabAt(i); i++) {
		if (item->Volume()->Device() == device)
			return;
	}

	BVolume* volume = new BVolume(device);

	VolumeTab* item = new VolumeTab(volume);
	char name[B_PATH_NAME_LENGTH];
	volume->GetName(name);

	AddTab(new VolumeView(name, volume), item);
	Invalidate();
}

/*	isVolume
*	checks if selected file is a volume
*	if yes, returns true
*/	
bool
ProjectTypeSelector::isVolume()
{
	BString *SelectedFile = (BString*)FileList->FirstItem();
	BString SelectedFileTMP;
	BVolumeRoster objVolumeRoster;
	objVolumeRoster.Rewind();
	BVolume objVolume;
	char chVolumeName[B_FILE_NAME_LENGTH];
	
	SelectedFile->CopyInto(SelectedFileTMP, 0, (int)SelectedFile->Length());	
	SelectedFileTMP.RemoveAll("/");
	while(objVolumeRoster.GetNextVolume(&objVolume) != B_BAD_VALUE) {
		objVolume.GetName(chVolumeName);
		
		if(SelectedFileTMP.Compare(chVolumeName) == 0 && objVolume.IsReadOnly()) {
			fSizeOfFiles = objVolume.Capacity();
			return true;
		}
	}
	
	return false;
}

bool duplicates_exist (const char * signature)
{
	BVolumeRoster	roster;
	BVolume			volume;
	BQuery			query;
	BString			query_string	=	"BEOS:APP_SIG=";
	BEntry			entry;
	mode_t			permissions;
	uid_t			owner;
	gid_t			group;
	int32			query_hits		=	0;
	
	query_string += signature;
	
	while (roster.GetNextVolume(& volume) == B_OK)
	{
		if (volume.KnowsQuery())
		{
			PRINT(("volume.KnowsQuery()\n"));
			
			char volname [B_FILE_NAME_LENGTH];
			volume.GetName(volname);
			PRINT(("volume: %s\n", volname));
			
			query.Clear();
			
			if (query.SetVolume(& volume) == B_OK)
			{
				PRINT(("query.SetVolume(& volume) == B_OK\n"));
			
				if (query.SetPredicate(query_string.String()) == B_OK)
				{
					PRINT(("query.SetPredicate(%s) == B_OK\n", query_string.String()));
				
					if (query.Fetch() == B_OK)
					{
						PRINT(("query.Fetch() == B_OK\n"));
					
						while (query.GetNextEntry(& entry) == B_OK)
						{
							PRINT(("query.GetNextEntry(& entry) == B_OK\n"));
							
							entry.GetPermissions(& permissions);
							entry.GetOwner(& owner);
							entry.GetGroup(& group);
							
							BPath path (& entry);

							// if (access(path.Path(), X_OK))

							if	(((owner == getuid()) && (permissions & S_IXUSR))
							||	((group == getgid()) && (permissions & S_IXGRP))
							||	(permissions & S_IXOTH))
							{
								PRINT(("path is executable: %s\n", path.Path()));
								query_hits++;
							}
							else
							{
								PRINT(("path is NOT executable: %s\n", path.Path()));
							}
						}
					}
				}
			}
		}
	
		fflush(stdout);
	}
	
	if (query_hits > 1)
		return true;
	else
		return false;
}

status_t
PackageView::_InstallTypeChanged(int32 index)
{
	if (index < 0)
		return B_ERROR;

	// Clear the choice list
	for (int32 i = fDestination->CountItems() - 1; i >= 0; i--) {
		BMenuItem* item = fDestination->RemoveItem(i);
		delete item;
	}

	fCurrentType = index;
	pkg_profile* profile = fInfo.GetProfile(index);

	if (profile == NULL)
		return B_ERROR;

	BString typeDescription = profile->description;
	if (typeDescription.IsEmpty())
		typeDescription = profile->name;

	fInstallTypeDescriptionView->SetText(typeDescription.String());

	BPath path;
	BVolume volume;

	if (profile->path_type == P_INSTALL_PATH) {
		BMenuItem* item = NULL;
		if (find_directory(B_SYSTEM_NONPACKAGED_DIRECTORY, &path) == B_OK) {
			dev_t device = dev_for_path(path.Path());
			if (volume.SetTo(device) == B_OK && !volume.IsReadOnly()
				&& path.Append("apps") == B_OK) {
				item = _AddDestinationMenuItem(path.Path(), volume.FreeBytes(),
					path.Path());
			}
		}

		if (item != NULL) {
			item->SetMarked(true);
			fCurrentPath.SetTo(path.Path());
			fDestination->AddSeparatorItem();
		}

		_AddMenuItem(B_TRANSLATE("Other" B_UTF8_ELLIPSIS),
			new BMessage(P_MSG_OPEN_PANEL), fDestination);

		fDestField->SetEnabled(true);
	} else if (profile->path_type == P_USER_PATH) {
		bool defaultPathSet = false;
		BVolumeRoster roster;

		while (roster.GetNextVolume(&volume) != B_BAD_VALUE) {
			BDirectory mountPoint;
			if (volume.IsReadOnly() || !volume.IsPersistent()
				|| volume.GetRootDirectory(&mountPoint) != B_OK) {
				continue;
			}

			if (path.SetTo(&mountPoint, NULL) != B_OK)
				continue;

			char volumeName[B_FILE_NAME_LENGTH];
			volume.GetName(volumeName);
	
			BMenuItem* item = _AddDestinationMenuItem(volumeName,
				volume.FreeBytes(), path.Path());

			// The first volume becomes the default element
			if (!defaultPathSet) {
				item->SetMarked(true);
				fCurrentPath.SetTo(path.Path());
				defaultPathSet = true;
			}
		}

		fDestField->SetEnabled(true);
	} else
		fDestField->SetEnabled(false);

	return B_OK;
}

status_t ExtractQueryVolumes(BNode *node, vollist *volumes) {
	int32 length = 0;
	char *attr = ReadAttribute(*node, kTrackerQueryVolume, &length);
	BVolumeRoster roster;

	if (attr == NULL) {
		roster.Rewind();
		BVolume vol;
		
		while (roster.GetNextVolume(&vol) == B_NO_ERROR) {
			if ((vol.IsPersistent() == true) && (vol.KnowsQuery() == true)) {
				volumes->push_back(vol);
			};
		};
	} else {
		BMessage msg;
		msg.Unflatten(attr);

//		!*YOINK*!d from that project... with the funny little doggie as a logo...
//		OpenTracker, that's it!
			
		time_t created;
		off_t capacity;
		
		for (int32 index = 0; msg.FindInt32("creationDate", index, &created) == B_OK;
			index++) {
			
			if ((msg.FindInt32("creationDate", index, &created) != B_OK)
				|| (msg.FindInt64("capacity", index, &capacity) != B_OK))
				return B_ERROR;
		
			BVolume volume;
			BString deviceName = "";
			BString volumeName = "";
			BString fshName = "";
		
			if (msg.FindString("deviceName", &deviceName) == B_OK
				&& msg.FindString("volumeName", &volumeName) == B_OK
				&& msg.FindString("fshName", &fshName) == B_OK) {
				// New style volume identifiers: We have a couple of characteristics,
				// and compute a score from them. The volume with the greatest score
				// (if over a certain threshold) is the one we're looking for. We
				// pick the first volume, in case there is more than one with the
				// same score.
				int foundScore = -1;
				roster.Rewind();
				
				char name[B_FILE_NAME_LENGTH];
				
				while (roster.GetNextVolume(&volume) == B_OK) {
					if (volume.IsPersistent() && volume.KnowsQuery()) {
						// get creation time and fs_info
						BDirectory root;
						volume.GetRootDirectory(&root);
						time_t cmpCreated;
						fs_info info;
						if (root.GetCreationTime(&cmpCreated) == B_OK
							&& fs_stat_dev(volume.Device(), &info) == 0) {
							// compute the score
							int score = 0;
		
							// creation time
							if (created == cmpCreated)
								score += 5;
							// capacity
							if (capacity == volume.Capacity())
								score += 4;
							// device name
							if (deviceName == info.device_name)
								score += 3;
							// volume name
							if (volumeName == info.volume_name)
								score += 2;
							// fsh name
							if (fshName == info.fsh_name)
								score += 1;
		
							// check score
							if (score >= 9 && score > foundScore) {
								volume.GetName(name);
								volumes->push_back(volume);
							}
						}
					}
				}
			} else {
				// Old style volume identifiers: We have only creation time and
				// capacity. Both must match.
				roster.Rewind();
				while (roster.GetNextVolume(&volume) == B_OK)
					if (volume.IsPersistent() && volume.KnowsQuery()) {
						BDirectory root;
						volume.GetRootDirectory(&root);
						time_t cmpCreated;
						root.GetCreationTime(&cmpCreated);
						if (created == cmpCreated && capacity == volume.Capacity()) {
							volumes->push_back(volume);
						}
					}
			}
//.........这里部分代码省略.........

    int
    getmntent_haiku(int* cookie, struct mnttab* mp)
    {
        static BLocker mntent_locker;
        mntent_locker.Lock();

        int ret = -1;
        BVolumeRoster roster;
        char buf[B_PATH_NAME_LENGTH];
        int buflen = 0;
        BVolume volume;
        BDirectory rootDir;
        BEntry rootDirEntry;
        BPath rootDirPath;

        roster.Rewind();
        for (int i = 0; i <= *cookie; i++)
            if (roster.GetNextVolume(&volume) != B_NO_ERROR)
                goto bail;

        // volume name
        volume.GetName(buf);
        buflen = strlen(buf);

        if (buflen == 0) {
            buflen = strlen(MNTENT_MP_UNKNOWN);
            strlcpy(buf, MNTENT_MP_UNKNOWN, buflen + 1);
        }

        mp->mnt_special = (char* )malloc(sizeof(char) * (buflen+1));
        strlcpy(mp->mnt_special, buf, buflen+1);

        // mount point
        if (volume.GetRootDirectory(&rootDir) != B_OK ||
                rootDir.GetEntry(&rootDirEntry) != B_OK   ||
                rootDirEntry.GetPath(&rootDirPath) != B_OK)
            goto bail;

        buflen = strlen(rootDirPath.Path());
        mp->mnt_mountp = (char* )malloc(sizeof(char) * (buflen+1));
        strlcpy(mp->mnt_mountp, rootDirPath.Path(), buflen + 1);

        // partition type.
        fs_info info;
        if (fs_stat_dev(volume.Device(), &info) != B_OK)
            goto bail;

        buflen = strlen(info.fsh_name);
        mp->mnt_fstype = (char* )malloc(sizeof(char) * (buflen+1));
        strlcpy(mp->mnt_fstype, info.fsh_name, buflen+1);

        // fs options. set default options for all file systems for now.
        buflen = strlen(MNTENT_MP_DEFAULT_OPTS);
        mp->mnt_mntopts = (char* )malloc(sizeof(char) * (buflen+2+1)); // extra space for ro/rw
        strlcpy(mp->mnt_mntopts, MNTENT_MP_DEFAULT_OPTS, buflen + 2 + 1);
        strcat(mp->mnt_mntopts, volume.IsReadOnly() ? ",ro":",rw");

        // mount time. no idea how i can get this. set it to 0 for now.
        buflen = 1;
        mp->mnt_time = (char* )malloc(sizeof(char) * (buflen+1));
        strlcpy(mp->mnt_time, "0", buflen + 1);

        (*cookie)++;
        ret = 0; /* success! */

bail:
        mntent_locker.Unlock();
        return ret;
    }

//.........这里部分代码省略.........
		fDevice = dev;
	}

	return B_OK;
#else // !HAVE_MNTENT_H
#ifdef _WIN32
	if (dev <= 0) {
		Unset();
	} else if (fDevice != dev) {
		if (dev > 26) return B_ENTRY_NOT_FOUND;

		DWORD driveMask = GetLogicalDrives();
		if (driveMask == 0) return B_ENTRY_NOT_FOUND;
		if (!(driveMask & (1UL << (dev - 1)))) return B_BAD_VALUE;

		if (fData == NULL) {
			if ((fData = new_dev_data()) == NULL) return B_NO_MEMORY;
		}

		char dirname[4] = "A:\\";
		*dirname += (dev - 1);

		BString nameStr;
		char nameBuf[301];
		bzero(nameBuf, 301);
		if (!(GetVolumeInformation(dirname, nameBuf, 300, NULL, NULL, NULL, NULL, 0) == 0 || nameBuf[0] == 0)) {
			WCHAR wStr[301];
			bzero(wStr, sizeof(WCHAR) * 301);
			MultiByteToWideChar(CP_ACP, 0, nameBuf, -1, wStr, 300);
			char *utf8Name = e_unicode_convert_to_utf8((const unichar*)wStr, -1);
			if (utf8Name != NULL) {
				nameStr.SetTo(utf8Name);
				free(utf8Name);
			}
		}
		if (nameStr.Length() <= 0) nameStr.SetTo(nameBuf);
		dirname[2] = '/';

		status_t status = set_dev_data((e_dev_data_t*)fData, nameStr.String(), dirname);

		if (status != B_OK) return status;

		fDevice = dev;
	}

	return B_OK;
#else // !_WIN32
#ifdef __BEOS__
	if (dev <= 0) {
		Unset();
	} else if (fDevice != dev) {
		if (fData == NULL)
			if ((fData = new_dev_data()) == NULL) return B_NO_MEMORY;

		BVolume vol;
		BVolumeRoster volRoster;
		BDirectory beDir;
		BEntry beEntry;
		BPath bePath;
		char volName[B_FILE_NAME_LENGTH + 1];
		bzero(volName, B_FILE_NAME_LENGTH + 1);

		e_dev_t tmp = dev;
		while (tmp > 0) {
			if (volRoster.GetNextVolume(&vol) != B_OK) return B_ENTRY_NOT_FOUND;
			if (--tmp > 0) continue;
			if (vol.GetRootDirectory(&beDir) != B_OK ||
			        beDir.GetEntry(&beEntry) != B_OK ||
			        beEntry.GetPath(&bePath) != B_OK) return B_ENTRY_NOT_FOUND;
			vol.GetName(volName);
		}

		status_t status = set_dev_data((e_dev_data_t*)fData, volName, bePath.Path());
		if (status != B_OK) return status;

		fDevice = dev;
	}

	return B_OK;
#else // !__BEOS__
#warning "fixme: BVolume::SetTo"
	if (dev <= 0) {
		Unset();
		return B_OK;
	} else if (fDevice != dev && dev == 1) {
		if (fData == NULL)
			if ((fData = new_dev_data()) == NULL) return B_NO_MEMORY;

		status_t status = set_dev_data((e_dev_data_t*)fData, "root", "/");
		if (status != B_OK) return status;

		fDevice = dev;
		return B_OK;
	}

	return B_ENTRY_NOT_FOUND;
#endif // __BEOS__
#endif // _WIN32
#endif // HAVE_MNTENT_H
}

bool 
FolderShaper::IsFolderUntouchable(uint32 purpose, const entry_ref * a_ref)
{
	// system directories
	if	(IsItThisFolder(a_ref, B_DESKTOP_DIRECTORY))				return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_TRASH_DIRECTORY))					return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_APPS_DIRECTORY))					return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_PREFERENCES_DIRECTORY))			return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_BEOS_DIRECTORY))					return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_BEOS_SYSTEM_DIRECTORY))			return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_BEOS_ADDONS_DIRECTORY))			return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_BEOS_BOOT_DIRECTORY))				return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_BEOS_FONTS_DIRECTORY))				return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_BEOS_LIB_DIRECTORY))				return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_BEOS_SERVERS_DIRECTORY))			return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_BEOS_APPS_DIRECTORY))				return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_BEOS_BIN_DIRECTORY))				return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_BEOS_ETC_DIRECTORY))				return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_BEOS_DOCUMENTATION_DIRECTORY))		return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_BEOS_PREFERENCES_DIRECTORY))		return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_SYSTEM_DIRECTORY))					return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_SYSTEM_ADDONS_DIRECTORY))			return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_SYSTEM_BOOT_DIRECTORY))			return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_SYSTEM_FONTS_DIRECTORY))			return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_SYSTEM_LIB_DIRECTORY))				return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_SYSTEM_SERVERS_DIRECTORY))			return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_SYSTEM_BIN_DIRECTORY))				return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_SYSTEM_ETC_DIRECTORY))				return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_SYSTEM_DOCUMENTATION_DIRECTORY))	return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_SYSTEM_SETTINGS_DIRECTORY))		return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_SYSTEM_DEVELOP_DIRECTORY))			return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_SYSTEM_LOG_DIRECTORY))				return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_SYSTEM_SPOOL_DIRECTORY))			return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_SYSTEM_TEMP_DIRECTORY))			return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_SYSTEM_VAR_DIRECTORY))				return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_USER_DIRECTORY))					return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_USER_CONFIG_DIRECTORY))			return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_USER_ADDONS_DIRECTORY))			return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_USER_BOOT_DIRECTORY))				return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_USER_FONTS_DIRECTORY))				return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_USER_LIB_DIRECTORY))				return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_USER_SETTINGS_DIRECTORY))			return SysDirMessage(a_ref);
	if	(IsItThisFolder(a_ref, B_USER_DESKBAR_DIRECTORY))			return SysDirMessage(a_ref);
	
	// volume roots
	BVolumeRoster	vol_roster;
	BVolume			volume;
	BDirectory		vol_dir;
	BEntry			vol_entry;
	entry_ref		vol_ref;
	
	
	while (vol_roster.GetNextVolume(& volume) == B_OK)
	{
		volume.GetRootDirectory(& vol_dir);
		
		vol_dir.GetEntry(& vol_entry);
		
		vol_entry.GetRef(& vol_ref);
		
		if (*a_ref == vol_ref)
			return VolRootMessage(a_ref);
	}
	
	// target does not support attributes
	if (volume.SetTo(a_ref->device) != B_OK)
	{
		// message
		return true;
	}

	if(! volume.KnowsAttr())
	{
		char volname[B_FILE_NAME_LENGTH];
		volume.GetName(volname);
	
		return NoAttributesMessage(purpose, a_ref, volname);
	}

	// and perhaps returns something for the BAlert
	
	return false;
}