inline bool QStorageIterator::next()
{
BVolume volume;
if (m_volumeRoster.GetNextVolume(&volume) != B_OK)
return false;
BDirectory directory;
if (volume.GetRootDirectory(&directory) != B_OK)
return false;
const BPath path(&directory);
fs_info fsInfo;
memset(&fsInfo, 0, sizeof(fsInfo));
if (fs_stat_dev(volume.Device(), &fsInfo) != 0)
return false;
m_rootPath = path.Path();
m_fileSystemType = QByteArray(fsInfo.fsh_name);
const QByteArray deviceName(fsInfo.device_name);
m_device = (deviceName.isEmpty() ? QByteArray::number(qint32(volume.Device())) : deviceName);
return true;
}
void
BTrashWatcher::UpdateTrashIcons()
{
BVolume boot;
if (BVolumeRoster().GetBootVolume(&boot) != B_OK)
return;
BDirectory trashDir;
if (FSGetTrashDir(&trashDir, boot.Device()) == B_OK) {
// pull out the icons for the current trash state from resources and
// apply them onto the trash directory node
size_t largeSize = 0;
size_t smallSize = 0;
const void *largeData = GetTrackerResources()->LoadResource('ICON',
fTrashFull ? kResTrashFullIcon : kResTrashIcon, &largeSize);
const void *smallData = GetTrackerResources()->LoadResource('MICN',
fTrashFull ? kResTrashFullIcon : kResTrashIcon, &smallSize);
if (largeData)
trashDir.WriteAttr(kAttrLargeIcon, 'ICON', 0,
largeData, largeSize);
else
TRESPASS();
if (smallData)
trashDir.WriteAttr(kAttrMiniIcon, 'MICN', 0,
smallData, smallSize);
else
TRESPASS();
}
}
void
AutoMounter::GetSettings(BMessage *_DEVICE_MAP_ONLY(message))
{
#if _INCLUDES_CLASS_DEVICE_MAP
message->AddBool("checkRemovableOnly", fScanParams.removableOrUnknownOnly);
message->AddBool("checkCDs", fScanParams.checkCDROMs);
message->AddBool("checkFloppies", fScanParams.checkFloppies);
message->AddBool("checkOtherRemovables", fScanParams.checkOtherRemovable);
message->AddBool("autoMountRemovableOnly", fAutomountParams.mountRemovableDisksOnly);
message->AddBool("autoMountAll", fAutomountParams.mountAllFS);
message->AddBool("autoMountAllBFS", fAutomountParams.mountBFS);
message->AddBool("autoMountAllHFS", fAutomountParams.mountHFS);
message->AddBool("initialMountAll", fInitialMountAll);
message->AddBool("initialMountAllBFS", fInitialMountAllBFS);
message->AddBool("initialMountRestore", fInitialMountRestore);
message->AddBool("initialMountAllHFS", fInitialMountAllHFS);
message->AddBool("suspended", fSuspended);
// Save mounted volumes so we can optionally mount them on next
// startup
BVolumeRoster volumeRoster;
BVolume volume;
while (volumeRoster.GetNextVolume(&volume) == B_OK) {
fs_info info;
if (fs_stat_dev(volume.Device(), &info) == 0
&& info.flags & (B_FS_IS_REMOVABLE | B_FS_IS_PERSISTENT))
message->AddString(info.device_name, info.volume_name);
}
#endif
}
static char *getMountPoint(const char *devname, char *buf, size_t bufsize)
{
BVolumeRoster mounts;
BVolume vol;
mounts.Rewind();
while (mounts.GetNextVolume(&vol) == B_NO_ERROR)
{
fs_info fsinfo;
fs_stat_dev(vol.Device(), &fsinfo);
if (strcmp(devname, fsinfo.device_name) == 0)
{
BDirectory directory;
BEntry entry;
BPath path;
const char *str;
if ( (vol.GetRootDirectory(&directory) < B_OK) ||
(directory.GetEntry(&entry) < B_OK) ||
(entry.GetPath(&path) < B_OK) ||
( (str = path.Path()) == NULL) )
return NULL;
strncpy(buf, str, bufsize-1);
buf[bufsize-1] = '\0';
return buf;
} /* if */
} /* while */
return NULL;
} /* getMountPoint */
/*! \brief Finds a BPartition by BVolume.
*/
status_t
BDiskDeviceRoster::FindPartitionByVolume(const BVolume& volume,
BDiskDevice* device, BPartition** _partition)
{
class FindPartitionVisitor : public BDiskDeviceVisitor {
public:
FindPartitionVisitor(dev_t volume)
:
fVolume(volume)
{
}
virtual bool Visit(BDiskDevice* device)
{
return Visit(device, 0);
}
virtual bool Visit(BPartition* partition, int32 level)
{
BVolume volume;
return partition->GetVolume(&volume) == B_OK
&& volume.Device() == fVolume;
}
private:
dev_t fVolume;
} visitor(volume.Device());
if (VisitEachMountedPartition(&visitor, device, _partition))
return B_OK;
return B_ENTRY_NOT_FOUND;
}
bool
BNavMenu::StartBuildingItemList()
{
BEntry entry;
if (fNavDir.device < 0 || entry.SetTo(&fNavDir) != B_OK
|| !entry.Exists())
return false;
fItemList = new BObjectList<BMenuItem>(50);
fIteratingDesktop = false;
BDirectory parent;
status_t status = entry.GetParent(&parent);
// if ref is the root item then build list of volume root dirs
fFlags = uint8((fFlags & ~kVolumesOnly) | (status == B_ENTRY_NOT_FOUND ? kVolumesOnly : 0));
if (fFlags & kVolumesOnly)
return true;
Model startModel(&entry, true);
if (startModel.InitCheck() != B_OK || !startModel.IsContainer())
return false;
if (startModel.IsQuery())
fContainer = new QueryEntryListCollection(&startModel);
else if (FSIsDeskDir(&entry)) {
fIteratingDesktop = true;
fContainer = DesktopPoseView::InitDesktopDirentIterator(0, startModel.EntryRef());
AddRootItemsIfNeeded();
} else if (FSIsTrashDir(&entry)) {
// the trash window needs to display a union of all the
// trash folders from all the mounted volumes
BVolumeRoster volRoster;
volRoster.Rewind();
BVolume volume;
fContainer = new EntryIteratorList();
while (volRoster.GetNextVolume(&volume) == B_OK) {
if (!volume.IsPersistent())
continue;
BDirectory trashDir;
if (FSGetTrashDir(&trashDir, volume.Device()) == B_OK)
dynamic_cast<EntryIteratorList *>(fContainer)->
AddItem(new DirectoryEntryList(trashDir));
}
} else
fContainer = new DirectoryEntryList(*dynamic_cast<BDirectory *>
(startModel.Node()));
if (fContainer == NULL || fContainer->InitCheck() != B_OK)
return false;
fContainer->Rewind();
return true;
}
// 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;
}
int
getextmntent_haiku(int* cookie, struct extmnttab *mp, int len)
{
static BLocker extmntent_locker;
extmntent_locker.Lock();
BVolumeRoster roster;
BVolume volume;
int ret = -1;
roster.Rewind();
for (int i = 0; i <= *cookie; i++)
if (roster.GetNextVolume(&volume) != B_NO_ERROR)
return -1;
if (getmntent_haiku(cookie, (struct mnttab*)mp) == 0) {
mp->mnt_major = volume.Device();
mp->mnt_minor = volume.Device();
ret = 0;
}
extmntent_locker.Unlock();
return ret;
}
static char *getMountPoint(const char *devname)
{
BVolumeRoster mounts;
BVolume vol;
mounts.Rewind();
while (mounts.GetNextVolume(&vol) == B_NO_ERROR)
{
fs_info fsinfo;
fs_stat_dev(vol.Device(), &fsinfo);
if (strcmp(devname, fsinfo.device_name) == 0)
{
//char buf[B_FILE_NAME_LENGTH];
BDirectory directory;
BEntry entry;
BPath path;
status_t rc;
rc = vol.GetRootDirectory(&directory);
BAIL_IF_MACRO(rc < B_OK, strerror(rc), NULL);
rc = directory.GetEntry(&entry);
BAIL_IF_MACRO(rc < B_OK, strerror(rc), NULL);
rc = entry.GetPath(&path);
BAIL_IF_MACRO(rc < B_OK, strerror(rc), NULL);
const char *str = path.Path();
BAIL_IF_MACRO(str == NULL, ERR_OS_ERROR, NULL); /* ?! */
char *retval = (char *) allocator.Malloc(strlen(str) + 1);
BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);
strcpy(retval, str);
return(retval);
} /* if */
} /* while */
return(NULL);
} /* getMountPoint */
status_t
CDDBLookup::Lookup(CDDBServer& server, const char* path, bool dumpOnly,
bool verbose)
{
BVolumeRoster roster;
BVolume volume;
while (roster.GetNextVolume(&volume) == B_OK) {
fs_info info;
if (fs_stat_dev(volume.Device(), &info) != B_OK)
continue;
if (strcmp(path, info.device_name) == 0)
return Lookup(server, volume.Device(), dumpOnly, verbose);
}
return B_ENTRY_NOT_FOUND;
}
void
CDDBLookup::LookupAll(CDDBServer& server, bool dumpOnly, bool verbose)
{
BVolumeRoster roster;
BVolume volume;
while (roster.GetNextVolume(&volume) == B_OK) {
Lookup(server, volume.Device(), dumpOnly, verbose);
}
}
void
LiveQuery::_AddQuery(BVolume& volume, const char* predicate)
{
BMessage add(kMsgAddQuery);
add.AddInt32("volume", volume.Device());
add.AddString("predicate", predicate);
PostMessage(&add);
}
status_t TaskFS::SetUpMimeTyp(void)
{
status_t err;
//set the MimeType
BMimeType mime(TASK_MIMETYPE);
//later do better check
bool valid = mime.IsInstalled();
if (!valid) {
mime.Install();
mime.SetShortDescription(B_TRANSLATE_CONTEXT("Tasks",
"Short mimetype description"));
mime.SetLongDescription(B_TRANSLATE_CONTEXT("Tasks",
"Long mimetype description"));
//get the icon from our Ressources
BResources* res = BApplication::AppResources();
if (res != NULL){
size_t size;
const void* data = res->LoadResource(B_VECTOR_ICON_TYPE, "TASK_ICON", &size);
if (data!=NULL)
mime.SetIcon(reinterpret_cast<const uint8*>(data), size);
}
mime.SetPreferredApp(APP_SIG);
// add default task fields to meta-mime type
BMessage fields;
for (int32 i = 0; sDefaultAttributes[i].attribute; i++) {
fields.AddString("attr:public_name", sDefaultAttributes[i].name);
fields.AddString("attr:name", sDefaultAttributes[i].attribute);
fields.AddInt32("attr:type", sDefaultAttributes[i].type);
fields.AddString("attr:display_as", sDefaultAttributes[i].displayAs);
fields.AddBool("attr:viewable", sDefaultAttributes[i].isPublic);
fields.AddBool("attr:editable", sDefaultAttributes[i].editable);
fields.AddInt32("attr:width", sDefaultAttributes[i].width);
fields.AddInt32("attr:alignment", B_ALIGN_LEFT);
fields.AddBool("attr:extra", false);
}
mime.SetAttrInfo(&fields);
// create indices on all volumes for the found attributes.
int32 count = 8;
BVolumeRoster volumeRoster;
BVolume volume;
while (volumeRoster.GetNextVolume(&volume) == B_OK) {
for (int32 i = 0; i < count; i++) {
if (sDefaultAttributes[i].isPublic == true)
fs_create_index(volume.Device(), sDefaultAttributes[i].attribute,
sDefaultAttributes[i].type, 0);
}
}
}
else
err = B_OK;
return err;
}
status_t
CDDBQuery::_OpenContentFile(const int32 &discID)
{
// Makes sure that the lookup has a valid file to work with for the CD
// content. Returns true if there is an existing file, false if a lookup is
// required.
BFile file;
BString predicate;
predicate << "CD:key == " << discID;
entry_ref ref;
BVolumeRoster roster;
BVolume volume;
roster.Rewind();
while (roster.GetNextVolume(&volume) == B_OK) {
if (volume.IsReadOnly() || !volume.IsPersistent() || !volume.KnowsAttr()
|| !volume.KnowsQuery())
continue;
// make sure the volume we are looking at is indexed right
fs_create_index(volume.Device(), "CD:key", B_INT32_TYPE, 0);
BQuery query;
query.SetVolume(&volume);
query.SetPredicate(predicate.String());
if (query.Fetch() != B_OK)
continue;
if (query.GetNextRef(&ref) == B_OK)
break;
}
status_t status = fCDData.Load(ref);
if (status == B_NO_INIT) {
// We receive this error when the Load() function couldn't load the
// track times This just means that we get it from the SCSI data given
// to us in SetToCD
vector<CDAudioTime> times;
GetTrackTimes(&fSCSIData,times);
for (int32 i = 0; i < fCDData.CountTracks(); i++) {
CDAudioTime *item = fCDData.TrackTimeAt(i);
*item = times[i + 1] - times[i];
}
status = B_OK;
}
return status;
}
void
TTracker::InstallIndices()
{
BVolumeRoster roster;
BVolume volume;
roster.Rewind();
while (roster.GetNextVolume(&volume) == B_OK) {
if (volume.IsReadOnly() || !volume.IsPersistent()
|| !volume.KnowsAttr() || !volume.KnowsQuery())
continue;
InstallIndices(volume.Device());
}
}
void
BTrashWatcher::UpdateTrashIcons()
{
BVolumeRoster roster;
BVolume volume;
roster.Rewind();
BDirectory trashDir;
while (roster.GetNextVolume(&volume) == B_OK) {
if (FSGetTrashDir(&trashDir, volume.Device()) == B_OK) {
// pull out the icons for the current trash state from resources
// and apply them onto the trash directory node
size_t largeSize = 0;
size_t smallSize = 0;
const void* largeData
= GetTrackerResources()->LoadResource('ICON',
fTrashFull ? R_TrashFullIcon : R_TrashIcon, &largeSize);
const void* smallData
= GetTrackerResources()->LoadResource('MICN',
fTrashFull ? R_TrashFullIcon : R_TrashIcon, &smallSize);
#ifdef HAIKU_TARGET_PLATFORM_HAIKU
size_t vectorSize = 0;
const void* vectorData = GetTrackerResources()->LoadResource(
B_VECTOR_ICON_TYPE,
fTrashFull ? R_TrashFullIcon : R_TrashIcon, &vectorSize);
if (vectorData) {
trashDir.WriteAttr(kAttrIcon, B_VECTOR_ICON_TYPE, 0,
vectorData, vectorSize);
} else
TRESPASS();
#endif
if (largeData) {
trashDir.WriteAttr(kAttrLargeIcon, 'ICON', 0,
largeData, largeSize);
} else
TRESPASS();
if (smallData) {
trashDir.WriteAttr(kAttrMiniIcon, 'MICN', 0,
smallData, smallSize);
} else
TRESPASS();
}
}
}
CDDBDaemon::CDDBDaemon()
: BApplication("application/x-vnd.Haiku-cddb_daemon"),
fVolumeRoster(new BVolumeRoster)
{
fVolumeRoster->StartWatching();
BVolume volume;
printf("Checking currently mounted volumes ...\n");
while (fVolumeRoster->GetNextVolume(&volume) == B_OK) {
if (_Lookup(volume.Device()) != B_OK) {
continue;
}
}
printf("Checking complete. Listening for device mounts.\n");
}
void
TReplicantTray::InitAddOnSupport()
{
// list to maintain refs to each rep added/deleted
fItemList = new BList();
bool haveKey = false;
BPath path;
if (find_directory(B_USER_SETTINGS_DIRECTORY, &path, true) == B_OK) {
path.Append(kDeskbarSecurityCodeFile);
BFile file(path.Path(),B_READ_ONLY);
if (file.InitCheck() == B_OK
&& file.Read(&fDeskbarSecurityCode, sizeof(fDeskbarSecurityCode))
== sizeof(fDeskbarSecurityCode))
haveKey = true;
}
if (!haveKey) {
// create the security code
bigtime_t real = real_time_clock_usecs();
bigtime_t boot = system_time();
// two computers would have to have exactly matching clocks, and launch
// Deskbar at the exact same time into the bootsequence in order for
// their security-ID to be identical
fDeskbarSecurityCode = ((real & 0xffffffffULL) << 32)
| (boot & 0xffffffffULL);
if (find_directory (B_USER_SETTINGS_DIRECTORY, &path, true) == B_OK) {
path.Append(kDeskbarSecurityCodeFile);
BFile file(path.Path(), B_WRITE_ONLY | B_CREATE_FILE
| B_ERASE_FILE);
if (file.InitCheck() == B_OK)
file.Write(&fDeskbarSecurityCode, sizeof(fDeskbarSecurityCode));
}
}
// for each volume currently mounted
// index the volume with our indices
BVolumeRoster roster;
BVolume volume;
while (roster.GetNextVolume(&volume) == B_OK) {
fs_create_index(volume.Device(), kStatusPredicate, B_STRING_TYPE, 0);
RunAddOnQuery(&volume, kEnabledPredicate);
}
// we also watch for volumes mounted and unmounted
watch_node(NULL, B_WATCH_MOUNT | B_WATCH_ATTR, this, Window());
}
void
BTrashWatcher::WatchTrashDirs()
{
BVolumeRoster volRoster;
volRoster.Rewind();
BVolume volume;
while (volRoster.GetNextVolume(&volume) == B_OK) {
if (volume.IsReadOnly() || !volume.IsPersistent())
continue;
BDirectory trashDir;
if (FSGetTrashDir(&trashDir, volume.Device()) == B_OK) {
node_ref trash_node;
trashDir.GetNodeRef(&trash_node);
watch_node(&trash_node, B_WATCH_DIRECTORY, this);
fTrashNodeList.AddItem(new node_ref(trash_node));
}
}
}
bool
BTrashWatcher::CheckTrashDirs()
{
BVolumeRoster volRoster;
volRoster.Rewind();
BVolume volume;
while (volRoster.GetNextVolume(&volume) == B_OK) {
if (volume.IsReadOnly() || !volume.IsPersistent())
continue;
BDirectory trashDir;
FSGetTrashDir(&trashDir, volume.Device());
trashDir.Rewind();
BEntry entry;
if (trashDir.GetNextEntry(&entry) == B_OK)
return true;
}
return false;
}
void
AutoMounter::_GetSettings(BMessage *message)
{
message->MakeEmpty();
bool all, bfs, restore;
_FromMode(fNormalMode, all, bfs, restore);
message->AddBool("initialMountAll", all);
message->AddBool("initialMountAllBFS", bfs);
message->AddBool("initialMountRestore", restore);
_FromMode(fRemovableMode, all, bfs, restore);
message->AddBool("autoMountAll", all);
message->AddBool("autoMountAllBFS", bfs);
message->AddBool("ejectWhenUnmounting", fEjectWhenUnmounting);
// Save mounted volumes so we can optionally mount them on next
// startup
BVolumeRoster volumeRoster;
BVolume volume;
while (volumeRoster.GetNextVolume(&volume) == B_OK) {
fs_info info;
if (fs_stat_dev(volume.Device(), &info) == 0
&& (info.flags & (B_FS_IS_REMOVABLE | B_FS_IS_PERSISTENT)) != 0) {
message->AddString(info.device_name, info.volume_name);
BString mountFlagsKey(info.device_name);
mountFlagsKey << kMountFlagsKeyExtension;
uint32 mountFlags = 0;
if (volume.IsReadOnly())
mountFlags |= B_MOUNT_READ_ONLY;
message->AddInt32(mountFlagsKey.String(), mountFlags);
}
}
}
void
TTracker::ReadyToRun()
{
gStatusWindow = new BStatusWindow();
InitMimeTypes();
InstallDefaultTemplates();
InstallIndices();
HideVarDir();
fTrashWatcher = new BTrashWatcher();
fTrashWatcher->Run();
fClipboardRefsWatcher = new BClipboardRefsWatcher();
fClipboardRefsWatcher->Run();
fAutoMounter = new AutoMounter();
fAutoMounter->Run();
fTaskLoop = new StandAloneTaskLoop(true);
bool openDisksWindow = false;
// open desktop window
BContainerWindow *deskWindow = NULL;
BVolume bootVol;
BVolumeRoster().GetBootVolume(&bootVol);
BDirectory deskDir;
if (FSGetDeskDir(&deskDir, bootVol.Device()) == B_OK) {
// create desktop
BEntry entry;
deskDir.GetEntry(&entry);
Model *model = new Model(&entry);
if (model->InitCheck() == B_OK) {
AutoLock<WindowList> lock(&fWindowList);
deskWindow = new BDeskWindow(&fWindowList);
AutoLock<BWindow> windowLock(deskWindow);
deskWindow->CreatePoseView(model);
deskWindow->Init();
} else
delete model;
// open previously open windows
attr_info attrInfo;
if (!BootedInSafeMode()
&& deskDir.GetAttrInfo(kAttrOpenWindows, &attrInfo) == B_OK) {
char *buffer = (char *)malloc((size_t)attrInfo.size);
BMessage message;
if (deskDir.ReadAttr(kAttrOpenWindows, B_MESSAGE_TYPE, 0, buffer, (size_t)attrInfo.size)
== attrInfo.size
&& message.Unflatten(buffer) == B_OK) {
node_ref nodeRef;
deskDir.GetNodeRef(&nodeRef);
int32 stateMessageCounter = 0;
const char *path;
for (int32 outer = 0;message.FindString("paths", outer, &path) == B_OK;outer++) {
int8 flags = 0;
for (int32 inner = 0;message.FindInt8(path, inner, &flags) == B_OK;inner++) {
BEntry entry(path, true);
if (entry.InitCheck() == B_OK) {
Model *model = new Model(&entry);
if (model->InitCheck() == B_OK && model->IsContainer()) {
BMessage state;
bool restoreStateFromMessage = false;
if ((flags & kOpenWindowHasState) != 0
&& message.FindMessage("window state", stateMessageCounter++, &state) == B_OK)
restoreStateFromMessage = true;
if (restoreStateFromMessage)
OpenContainerWindow(model, 0, kOpen,
kRestoreWorkspace | (flags & kOpenWindowMinimized ? kIsHidden : 0U),
false, &state);
else
OpenContainerWindow(model, 0, kOpen,
kRestoreWorkspace | (flags & kOpenWindowMinimized ? kIsHidden : 0U));
} else
delete model;
}
}
}
if (message.HasBool("open_disks_window"))
openDisksWindow = true;
}
free(buffer);
}
}
// create model for root of everything
if (deskWindow) {
BEntry entry("/");
Model model(&entry);
if (model.InitCheck() == B_OK) {
if (TrackerSettings().ShowDisksIcon()) {
// add the root icon to desktop window
BMessage message;
message.what = B_NODE_MONITOR;
message.AddInt32("opcode", B_ENTRY_CREATED);
message.AddInt32("device", model.NodeRef()->device);
message.AddInt64("node", model.NodeRef()->node);
message.AddInt64("directory", model.EntryRef()->directory);
message.AddString("name", model.EntryRef()->name);
deskWindow->PostMessage(&message, deskWindow->PoseView());
}
if (openDisksWindow)
OpenContainerWindow(new Model(model), 0, kOpen, kRestoreWorkspace);
}
}
// kick off building the mime type list for find panels, etc.
fMimeTypeList = new MimeTypeList();
if (!BootedInSafeMode())
// kick of transient query killer
DeleteTransientQueriesTask::StartUpTransientQueryCleaner();
}
bool
TTracker::QuitRequested()
{
// don't allow user quitting
if (CurrentMessage() && CurrentMessage()->FindBool("shortcut"))
return false;
gStatusWindow->AttemptToQuit();
// try quitting the copy/move/empty trash threads
BVolume bootVolume;
DEBUG_ONLY(status_t err =) BVolumeRoster().GetBootVolume(&bootVolume);
ASSERT(err == B_OK);
BMessage message;
AutoLock<WindowList> lock(&fWindowList);
// save open windows in a message inside an attribute of the desktop
int32 count = fWindowList.CountItems();
for (int32 i = 0; i < count; i++) {
BContainerWindow *window = dynamic_cast<BContainerWindow *>
(fWindowList.ItemAt(i));
if (window && window->TargetModel() && !window->PoseView()->IsDesktopWindow()) {
if (window->TargetModel()->IsRoot())
message.AddBool("open_disks_window", true);
else {
BEntry entry;
BPath path;
const entry_ref *ref = window->TargetModel()->EntryRef();
if (entry.SetTo(ref) == B_OK && entry.GetPath(&path) == B_OK) {
int8 flags = window->IsMinimized() ? kOpenWindowMinimized : kOpenWindowNoFlags;
uint32 deviceFlags = GetVolumeFlags(window->TargetModel());
// save state for every window which is
// a) already open on another workspace
// b) on a volume not capable of writing attributes
if (window != FindContainerWindow(ref)
|| (deviceFlags & (B_FS_HAS_ATTR | B_FS_IS_READONLY)) != B_FS_HAS_ATTR) {
BMessage stateMessage;
window->SaveState(stateMessage);
window->SetSaveStateEnabled(false);
// This is to prevent its state to be saved to the node when closed.
message.AddMessage("window state", &stateMessage);
flags |= kOpenWindowHasState;
}
const char *target;
bool pathAlreadyExists = false;
for (int32 index = 0;message.FindString("paths", index, &target) == B_OK;index++) {
if (!strcmp(target,path.Path())) {
pathAlreadyExists = true;
break;
}
}
if (!pathAlreadyExists)
message.AddString("paths", path.Path());
message.AddInt8(path.Path(), flags);
}
}
}
}
lock.Unlock();
// write windows to open on disk
BDirectory deskDir;
if (!BootedInSafeMode() && FSGetDeskDir(&deskDir, bootVolume.Device()) == B_OK) {
// if message is empty, delete the corresponding attribute
if (message.CountNames(B_ANY_TYPE)) {
size_t size = (size_t)message.FlattenedSize();
char *buffer = new char[size];
message.Flatten(buffer, (ssize_t)size);
deskDir.WriteAttr(kAttrOpenWindows, B_MESSAGE_TYPE, 0, buffer, size);
delete [] buffer;
} else
deskDir.RemoveAttr(kAttrOpenWindows);
}
for (int32 count = 0; count == 50; count++) {
// wait 5 seconds for the copiing/moving to quit
if (gStatusWindow->AttemptToQuit())
break;
snooze(100000);
}
return _inherited::QuitRequested();
}
status_t
Settings::ReadSwapSettings()
{
void* settings = load_driver_settings(kVirtualMemorySettings);
if (settings == NULL)
return kErrorSettingsNotFound;
CObjectDeleter<void, status_t> settingDeleter(settings,
&unload_driver_settings);
const char* enabled = get_driver_parameter(settings, "vm", NULL, NULL);
const char* automatic = get_driver_parameter(settings, "swap_auto",
NULL, NULL);
const char* size = get_driver_parameter(settings, "swap_size", NULL, NULL);
const char* volume = get_driver_parameter(settings, "swap_volume_name",
NULL, NULL);
const char* device = get_driver_parameter(settings,
"swap_volume_device", NULL, NULL);
const char* filesystem = get_driver_parameter(settings,
"swap_volume_filesystem", NULL, NULL);
const char* capacity = get_driver_parameter(settings,
"swap_volume_capacity", NULL, NULL);
if (enabled == NULL || automatic == NULL || size == NULL || device == NULL
|| volume == NULL || capacity == NULL || filesystem == NULL)
return kErrorSettingsInvalid;
off_t volCapacity = atoll(capacity);
SetSwapEnabled(get_driver_boolean_parameter(settings,
"vm", true, false));
SetSwapAutomatic(get_driver_boolean_parameter(settings,
"swap_auto", true, false));
SetSwapSize(atoll(size));
int32 bestScore = -1;
dev_t bestVol = -1;
BVolume vol;
fs_info volStat;
BVolumeRoster roster;
while (roster.GetNextVolume(&vol) == B_OK) {
if (!vol.IsPersistent() || vol.IsReadOnly() || vol.IsRemovable()
|| vol.IsShared())
continue;
if (fs_stat_dev(vol.Device(), &volStat) == 0) {
int32 score = 0;
if (strcmp(volume, volStat.volume_name) == 0)
score += 4;
if (strcmp(device, volStat.device_name) == 0)
score += 3;
if (volCapacity == volStat.total_blocks * volStat.block_size)
score += 2;
if (strcmp(filesystem, volStat.fsh_name) == 0)
score += 1;
if (score >= 4 && score > bestScore) {
bestVol = vol.Device();
bestScore = score;
}
}
}
SetSwapVolume(bestVol);
fInitialSettings = fCurrentSettings;
if (bestVol < 0)
return kErrorVolumeNotFound;
return B_OK;
}
void PrefsWindow::MessageReceived(BMessage *msg)
{
switch (msg->what) {
case MSG_OK: { // "Start" button clicked
read_volumes_prefs();
read_memory_prefs();
read_graphics_prefs();
SavePrefs();
send_quit_on_close = false;
PostMessage(B_QUIT_REQUESTED);
be_app->PostMessage(ok_message);
break;
}
case MSG_CANCEL: // "Quit" button clicked
send_quit_on_close = false;
PostMessage(B_QUIT_REQUESTED);
be_app->PostMessage(B_QUIT_REQUESTED);
break;
case B_ABOUT_REQUESTED: { // "About" menu item selected
ShowAboutWindow();
break;
}
case MSG_ZAP_PRAM: // "Zap PRAM File" menu item selected
ZapPRAM();
break;
case MSG_VOLUME_INVOKED: { // Double-clicked on volume name, toggle read-only flag
int selected = volume_list->CurrentSelection();
if (selected >= 0) {
const char *str = PrefsFindString("disk", selected);
BStringItem *item = (BStringItem *)volume_list->RemoveItem(selected);
delete item;
char newstr[256];
if (str[0] == '*')
strcpy(newstr, str+1);
else {
strcpy(newstr, "*");
strcat(newstr, str);
}
PrefsReplaceString("disk", newstr, selected);
volume_list->AddItem(new BStringItem(newstr), selected);
volume_list->Select(selected);
}
break;
}
case MSG_ADD_VOLUME:
add_volume_panel->Show();
break;
case MSG_CREATE_VOLUME:
create_volume_panel->Show();
break;
case MSG_ADD_VOLUME_PANEL: {
entry_ref ref;
if (msg->FindRef("refs", &ref) == B_NO_ERROR) {
BEntry entry(&ref, true);
BPath path;
entry.GetPath(&path);
if (entry.IsFile()) {
PrefsAddString("disk", path.Path());
volume_list->AddItem(new BStringItem(path.Path()));
} else if (entry.IsDirectory()) {
BVolume volume;
if (path.Path()[0] == '/' && strchr(path.Path()+1, '/') == NULL && entry.GetVolume(&volume) == B_NO_ERROR) {
int32 i = 0;
dev_t d;
fs_info info;
while ((d = next_dev(&i)) >= 0) {
fs_stat_dev(d, &info);
if (volume.Device() == info.dev) {
PrefsAddString("disk", info.device_name);
volume_list->AddItem(new BStringItem(info.device_name));
}
}
}
}
}
break;
}
case MSG_CREATE_VOLUME_PANEL: {
entry_ref dir;
if (msg->FindRef("directory", &dir) == B_NO_ERROR) {
BEntry entry(&dir, true);
BPath path;
entry.GetPath(&path);
path.Append(msg->FindString("name"));
create_volume_panel->Window()->Lock();
BView *background = create_volume_panel->Window()->ChildAt(0);
NumberControl *v = (NumberControl *)background->FindView("hardfile_size");
int size = v->Value();
char cmd[1024];
sprintf(cmd, "dd if=/dev/zero \"of=%s\" bs=1024k count=%d", path.Path(), size);
int ret = system(cmd);
if (ret == 0) {
PrefsAddString("disk", path.Path());
volume_list->AddItem(new BStringItem(path.Path()));
} else {
sprintf(cmd, GetString(STR_CREATE_VOLUME_WARN), strerror(ret));
WarningAlert(cmd);
}
}
break;
}
case MSG_REMOVE_VOLUME: {
int selected = volume_list->CurrentSelection();
if (selected >= 0) {
PrefsRemoveItem("disk", selected);
BStringItem *item = (BStringItem *)volume_list->RemoveItem(selected);
delete item;
volume_list->Select(selected);
}
break;
}
case MSG_BOOT_ANY:
PrefsReplaceInt32("bootdriver", 0);
break;
case MSG_BOOT_CDROM:
PrefsReplaceInt32("bootdriver", CDROMRefNum);
break;
case MSG_NOCDROM:
PrefsReplaceBool("nocdrom", nocdrom_checkbox->Value() == B_CONTROL_ON);
break;
case MSG_VIDEO_WINDOW:
display_type = DISPLAY_WINDOW;
hide_show_graphics_ctrls();
break;
case MSG_VIDEO_SCREEN:
display_type = DISPLAY_SCREEN;
hide_show_graphics_ctrls();
break;
case MSG_REF_5HZ:
PrefsReplaceInt32("frameskip", 12);
break;
case MSG_REF_7_5HZ:
PrefsReplaceInt32("frameskip", 8);
break;
case MSG_REF_10HZ:
PrefsReplaceInt32("frameskip", 6);
break;
case MSG_REF_15HZ:
PrefsReplaceInt32("frameskip", 4);
break;
case MSG_REF_30HZ:
PrefsReplaceInt32("frameskip", 2);
break;
case MSG_NOSOUND:
PrefsReplaceBool("nosound", nosound_checkbox->Value() == B_CONTROL_ON);
break;
case MSG_SER_A: {
BMenuItem *source = NULL;
msg->FindPointer("source", (void **)&source);
if (source)
PrefsReplaceString("seriala", source->Label());
break;
}
case MSG_SER_B: {
BMenuItem *source = NULL;
msg->FindPointer("source", (void **)&source);
if (source)
PrefsReplaceString("serialb", source->Label());
break;
}
case MSG_ETHER:
if (ether_checkbox->Value() == B_CONTROL_ON)
PrefsReplaceString("ether", "yes");
else
PrefsRemoveItem("ether");
break;
case MSG_UDPTUNNEL:
PrefsReplaceBool("udptunnel", udptunnel_checkbox->Value() == B_CONTROL_ON);
hide_show_serial_ctrls();
break;
case MSG_RAMSIZE:
PrefsReplaceInt32("ramsize", ramsize_slider->Value() * 1024 * 1024);
break;
case MSG_MODELID_5:
PrefsReplaceInt32("modelid", 5);
break;
case MSG_MODELID_14:
PrefsReplaceInt32("modelid", 14);
break;
case MSG_CPU_68020:
PrefsReplaceInt32("cpu", 2);
PrefsReplaceBool("fpu", false);
break;
case MSG_CPU_68020_FPU:
PrefsReplaceInt32("cpu", 2);
PrefsReplaceBool("fpu", true);
break;
case MSG_CPU_68030:
PrefsReplaceInt32("cpu", 3);
PrefsReplaceBool("fpu", false);
break;
case MSG_CPU_68030_FPU:
PrefsReplaceInt32("cpu", 3);
PrefsReplaceBool("fpu", true);
break;
case MSG_CPU_68040:
PrefsReplaceInt32("cpu", 4);
PrefsReplaceBool("fpu", true);
break;
default: {
// Screen mode messages
if ((msg->what & 0xffff0000) == MSG_SCREEN_MODE) {
int m = msg->what & 0xffff;
uint32 mask = scr_mode[m].mode_mask;
for (int i=0; i<32; i++)
if (mask & (1 << i))
scr_mode_bit = i;
} else
BWindow::MessageReceived(msg);
}
}
}
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;
}
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);
}
virtual bool Visit(BPartition* partition, int32 level)
{
BVolume volume;
return partition->GetVolume(&volume) == B_OK
&& volume.Device() == fVolume;
}
void
TMailApp::ReadyToRun()
{
// Create needed indices for META:group, META:email, MAIL:draft,
// INDEX_SIGNATURE, INDEX_STATUS on the boot volume
BVolume volume;
BVolumeRoster().GetBootVolume(&volume);
fs_create_index(volume.Device(), "META:group", B_STRING_TYPE, 0);
fs_create_index(volume.Device(), "META:email", B_STRING_TYPE, 0);
fs_create_index(volume.Device(), "MAIL:draft", B_INT32_TYPE, 0);
fs_create_index(volume.Device(), INDEX_SIGNATURE, B_STRING_TYPE, 0);
fs_create_index(volume.Device(), INDEX_STATUS, B_STRING_TYPE, 0);
fs_create_index(volume.Device(), B_MAIL_ATTR_FLAGS, B_INT32_TYPE, 0);
// Start people queries
fPeopleQueryList.Init("META:email=**");
// Load dictionaries
BPath indexDir;
BPath dictionaryDir;
BPath userDictionaryDir;
BPath userIndexDir;
BPath dataPath;
BPath indexPath;
BDirectory directory;
BEntry entry;
// Locate dictionaries directory
find_directory(B_SYSTEM_DATA_DIRECTORY, &indexDir, true);
indexDir.Append("spell_check");
dictionaryDir = indexDir;
//Locate user dictionary directory
find_directory(B_USER_CONFIG_DIRECTORY, &userIndexDir, true);
userIndexDir.Append("data/spell_check");
userDictionaryDir = userIndexDir;
// Create directory if needed
directory.CreateDirectory(userIndexDir.Path(), NULL);
// Setup directory paths
indexDir.Append(kIndexDirectory);
dictionaryDir.Append(kDictDirectory);
userIndexDir.Append(kIndexDirectory);
userDictionaryDir.Append(kDictDirectory);
// Create directories if needed
directory.CreateDirectory(indexDir.Path(), NULL);
directory.CreateDirectory(dictionaryDir.Path(), NULL);
directory.CreateDirectory(userIndexDir.Path(), NULL);
directory.CreateDirectory(userDictionaryDir.Path(), NULL);
dataPath = dictionaryDir;
dataPath.Append("words");
// Only Load if Words Dictionary
if (BEntry(kWordsPath).Exists() || BEntry(dataPath.Path()).Exists()) {
// If "/boot/optional/goodies/words" exists but there is no
// system dictionary, copy words
if (!BEntry(dataPath.Path()).Exists() && BEntry(kWordsPath).Exists()) {
BFile words(kWordsPath, B_READ_ONLY);
BFile copy(dataPath.Path(), B_WRITE_ONLY | B_CREATE_FILE);
char buffer[4096];
ssize_t size;
while ((size = words.Read( buffer, 4096)) > 0)
copy.Write(buffer, size);
BNodeInfo(©).SetType("text/plain");
}
// Load dictionaries
directory.SetTo(dictionaryDir.Path());
BString leafName;
gUserDict = -1;
while (gDictCount < MAX_DICTIONARIES
&& directory.GetNextEntry(&entry) != B_ENTRY_NOT_FOUND) {
dataPath.SetTo(&entry);
indexPath = indexDir;
leafName.SetTo(dataPath.Leaf());
leafName.Append(kMetaphone);
indexPath.Append(leafName.String());
gWords[gDictCount] = new Words(dataPath.Path(), indexPath.Path(), true);
indexPath = indexDir;
leafName.SetTo(dataPath.Leaf());
leafName.Append(kExact);
indexPath.Append(leafName.String());
gExactWords[gDictCount] = new Words(dataPath.Path(), indexPath.Path(), false);
gDictCount++;
}
// Create user dictionary if it does not exist
dataPath = userDictionaryDir;
dataPath.Append("user");
if (!BEntry(dataPath.Path()).Exists()) {
BFile user(dataPath.Path(), B_WRITE_ONLY | B_CREATE_FILE);
BNodeInfo(&user).SetType("text/plain");
}
// Load user dictionary
if (BEntry(userDictionaryDir.Path()).Exists()) {
gUserDictFile = new BFile(dataPath.Path(), B_WRITE_ONLY | B_OPEN_AT_END);
gUserDict = gDictCount;
indexPath = userIndexDir;
leafName.SetTo(dataPath.Leaf());
leafName.Append(kMetaphone);
indexPath.Append(leafName.String());
gWords[gDictCount] = new Words(dataPath.Path(), indexPath.Path(), true);
indexPath = userIndexDir;
leafName.SetTo(dataPath.Leaf());
leafName.Append(kExact);
indexPath.Append(leafName.String());
gExactWords[gDictCount] = new Words(dataPath.Path(), indexPath.Path(), false);
gDictCount++;
}
}
// Create a new window if starting up without any extra arguments.
if (!fPrintHelpAndExit && !fWindowCount) {
TMailWindow *window;
window = NewWindow();
window->Show();
}
}
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);
}
}
}
};
};
return B_OK;
};
