/*static*/ status_t
FSUtils::OpenSubDirectory(const BDirectory& baseDirectory,
const RelativePath& path, bool create, BDirectory& _directory)
{
// get a string for the path
BString pathString = path.ToString();
if (pathString.IsEmpty())
RETURN_ERROR(B_NO_MEMORY);
// If creating is not allowed, just try to open it.
if (!create)
RETURN_ERROR(_directory.SetTo(&baseDirectory, pathString));
// get an absolute path and create the subdirectory
BPath absolutePath;
status_t error = absolutePath.SetTo(&baseDirectory, pathString);
if (error != B_OK) {
ERROR("Volume::OpenSubDirectory(): failed to get absolute path "
"for subdirectory \"%s\": %s\n", pathString.String(),
strerror(error));
RETURN_ERROR(error);
}
error = create_directory(absolutePath.Path(),
S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
if (error != B_OK) {
ERROR("Volume::OpenSubDirectory(): failed to create "
"subdirectory \"%s\": %s\n", pathString.String(),
strerror(error));
RETURN_ERROR(error);
}
RETURN_ERROR(_directory.SetTo(&baseDirectory, pathString));
}
void
OpenWindow::CollectDevices(BMenu *menu, BEntry *startEntry)
{
BDirectory directory;
if (startEntry != NULL)
directory.SetTo(startEntry);
else
directory.SetTo("/dev/disk");
BEntry entry;
while (directory.GetNextEntry(&entry) == B_OK) {
if (entry.IsDirectory()) {
CollectDevices(menu, &entry);
continue;
}
entry_ref ref;
if (entry.GetRef(&ref) != B_OK)
continue;
BPath path;
if (entry.GetPath(&path) != B_OK)
continue;
BMessage *message = new BMessage(B_REFS_RECEIVED);
message->AddRef("refs", &ref);
menu->AddItem(new BMenuItem(path.Path(), message));
}
}
//---------------------- Private ---------------------------------//
status_t
JoyWin::_AddToList(BListView *list, uint32 command, const char* rootPath,
BEntry *rootEntry)
{
BDirectory root;
if ( rootEntry != NULL )
root.SetTo( rootEntry );
else if ( rootPath != NULL )
root.SetTo( rootPath );
else
return B_ERROR;
BEntry entry;
while ((root.GetNextEntry(&entry)) > B_ERROR ) {
if (entry.IsDirectory()) {
_AddToList(list, command, rootPath, &entry);
} else {
BPath path;
entry.GetPath(&path);
BString str(path.Path());
str.RemoveFirst(rootPath);
list->AddItem(new PortItem(str.String()));
}
}
return B_OK;
}
status_t
ThemeManager::SaveTheme(int32 id, bool excl)
{
FENTRY;
status_t err;
BString name, fname;
BPath path;
BDirectory dir;
BDirectory tdir;
BFile tfile;
BMessage names;
BString location;
BMessage *theme;
theme = ThemeAt(id);
if (!theme)
return EINVAL;
err = find_directory(B_USER_SETTINGS_DIRECTORY, &path);
if (err) return err;
path.Append(Z_THEMES_FOLDER_NAME);
err = dir.SetTo(path.Path());
if (err) return err;
err = ThemeName(id, name);
if (err) return err;
fname = name;
NormalizeThemeFolderName(fname);
err = ThemeLocation(id, location);
if (!err) {
if (location.FindFirst("/boot/beos") >= 0) {
PRINT(("trying to save theme '%s' to system dir!\n", name.String()));
return B_PERMISSION_DENIED;
}
}
path.Append(fname.String());
err = theme->ReplaceString(Z_THEME_LOCATION, path.Path());
if (err)
err = theme->AddString(Z_THEME_LOCATION, path.Path());
if (dir.CreateDirectory(fname.String(), NULL) < B_OK) {
if (excl)
return B_FILE_EXISTS;
}
err = tdir.SetTo(&dir, fname.String());
if (err) return err;
err = tdir.CreateFile(Z_THEME_FILE_NAME, &tfile);
if (err) return err;
BMessage tosave(*theme);
err = tosave.RemoveName(Z_THEME_LOCATION);
err = GetNames(names);
err = DumpMessageToStream(&tosave, tfile, 0, &names);
if (err) return err;
return B_OK;
}
status_t TaskFS::TaskToFile(Task *theTask, bool overwrite)
{
BFile taskFile;
BEntry entry;
status_t err;
TaskList *tskLst = theTask->GetTaskList();
BDirectory dir = BDirectory();
bool completed = theTask->IsCompleted();
uint32 priority = theTask->Priority();
time_t due = theTask->DueTime();
//first find directory.. then create files in this directory
if (tskLst!=NULL)
dir.SetTo(&tasksDir,tskLst->Name());
else
dir.SetTo(&tasksDir,".");
//first check if the File already exists..
//if not and overwrite is on check the ids..
// and search for the correspondending file...
if (dir.FindEntry(theTask->Title(),&entry) == B_OK) {
taskFile.SetTo((const BEntry*)&entry,B_READ_WRITE);
err = B_OK;
}
else {
entry_ref *ref= FileForId(theTask);
if (ref==NULL){
dir.CreateFile(theTask->Title(),&taskFile,overwrite);
dir.FindEntry(theTask->Title(),&entry);
}
else {
entry.SetTo(ref);
taskFile.SetTo((const BEntry*)ref,B_READ_WRITE);
}
}
if (taskFile.InitCheck() == B_OK){
taskFile.WriteAttr("META:completed",B_BOOL_TYPE, 0, &completed, sizeof(completed));
entry.Rename(theTask->Title());
taskFile.WriteAttrString("META:tasks",new BString(theTask->GetTaskList()->ID()));
taskFile.WriteAttrString("META:notes",new BString(theTask->Notes()));
taskFile.WriteAttr("META:priority", B_UINT32_TYPE, 0, &priority, sizeof(priority));
taskFile.WriteAttr("META:due", B_TIME_TYPE, 0, &due, sizeof(due));
taskFile.WriteAttrString("META:task_id", new BString(theTask->ID()));
taskFile.WriteAttrString("META:task_url",new BString(theTask->URL()));
}
else
err=B_ERROR;
return err;
}
status_t
ZKWindow::MakeSettingsFolder (void)
{
PRINT(("ZKWindow::MakeSettingsFolder()\n"));
status_t status;
BPath path;
if ((status = find_directory(B_USER_SETTINGS_DIRECTORY, & path)) != B_OK)
return status;
BEntry entry (path.Path());
// settings
if (entry.Exists() == false || entry.IsDirectory() == false)
return B_ERROR;
BDirectory mother (path.Path());
BDirectory baby;
// Kirilla
path.SetTo(path.Path(), "Kirilla");
entry.SetTo(path.Path());
if (! entry.Exists())
{
status = mother.CreateDirectory("Kirilla", & baby);
if (status != B_OK && status != B_FILE_EXISTS) return status;
}
else
if (! entry.IsDirectory())
return B_FILE_EXISTS;
if ((status = mother.SetTo(path.Path())) != B_OK) return status;
// ZooKeeper
path.SetTo(path.Path(), "ZooKeeper");
entry.SetTo(path.Path());
if (! entry.Exists())
{
status = mother.CreateDirectory("ZooKeeper", & baby);
if (status != B_OK && status != B_FILE_EXISTS) return status;
}
else
if (! entry.IsDirectory())
return B_FILE_EXISTS;
if ((status = mother.SetTo(path.Path())) != B_OK) return status;
entry.SetTo(path.Path());
if (entry.Exists() && entry.IsDirectory()) return B_OK;
else return B_ERROR;
}
void
PersonWindow::SaveAs()
{
char name[B_FILE_NAME_LENGTH];
_GetDefaultFileName(name);
if (fPanel == NULL) {
BMessenger target(this);
fPanel = new BFilePanel(B_SAVE_PANEL, &target);
BPath path;
find_directory(B_USER_DIRECTORY, &path, true);
BDirectory dir;
dir.SetTo(path.Path());
BEntry entry;
if (dir.FindEntry("people", &entry) == B_OK
|| (dir.CreateDirectory("people", &dir) == B_OK
&& dir.GetEntry(&entry) == B_OK)) {
fPanel->SetPanelDirectory(&entry);
}
}
if (fPanel->Window()->Lock()) {
fPanel->SetSaveText(name);
if (fPanel->Window()->IsHidden())
fPanel->Window()->Show();
else
fPanel->Window()->Activate();
fPanel->Window()->Unlock();
}
}
/*! Adds a menu populated with the keyboard layouts found in the passed
in directory to the passed in menu. Each subdirectory in the passed
in directory is added as a submenu recursively.
*/
void
KeymapWindow::_AddKeyboardLayoutMenu(BMenu* menu, BDirectory directory)
{
entry_ref ref;
while (directory.GetNextRef(&ref) == B_OK) {
if (menu->FindItem(ref.name) != NULL)
continue;
BDirectory subdirectory;
subdirectory.SetTo(&ref);
if (subdirectory.InitCheck() == B_OK) {
BMenu* submenu = new BMenu(B_TRANSLATE_NOCOLLECT(ref.name));
_AddKeyboardLayoutMenu(submenu, subdirectory);
menu->AddItem(submenu);
} else {
BMessage* message = new BMessage(kChangeKeyboardLayout);
message->AddRef("ref", &ref);
menu->AddItem(new BMenuItem(B_TRANSLATE_NOCOLLECT(ref.name),
message));
}
}
}
bool
AddOnManager::_FindEncoder(const media_format& format, const BPath& path,
entry_ref* _encoderRef)
{
node_ref nref;
BDirectory directory;
if (directory.SetTo(path.Path()) != B_OK
|| directory.GetNodeRef(&nref) != B_OK) {
return false;
}
encoder_info* info;
for (fEncoderList.Rewind(); fEncoderList.GetNext(&info);) {
if (info->ref.directory != nref.node)
continue;
// check if the encoder matches the supplied format
if (info->outputFormat.Matches(&format)) {
*_encoderRef = info->ref;
return true;
}
continue;
}
return false;
}
bool
AddOnManager::_FindDecoder(const media_format& format, const BPath& path,
entry_ref* _decoderRef)
{
node_ref nref;
BDirectory directory;
if (directory.SetTo(path.Path()) != B_OK
|| directory.GetNodeRef(&nref) != B_OK) {
return false;
}
decoder_info* info;
for (fDecoderList.Rewind(); fDecoderList.GetNext(&info);) {
if (info->ref.directory != nref.node)
continue;
media_format* decoderFormat;
for (info->formats.Rewind(); info->formats.GetNext(&decoderFormat);) {
// check if the decoder matches the supplied format
if (!decoderFormat->Matches(&format))
continue;
*_decoderRef = info->ref;
return true;
}
}
return false;
}
void
AddOnManager::RegisterAddOns()
{
// Check if add-ons are already registered.
if (!fReaderList.IsEmpty() || !fWriterList.IsEmpty()
|| !fDecoderList.IsEmpty() || !fEncoderList.IsEmpty()) {
return;
}
char** directories = NULL;
size_t directoryCount = 0;
if (find_paths_etc(get_architecture(), B_FIND_PATH_ADD_ONS_DIRECTORY,
"media/plugins", B_FIND_PATH_EXISTING_ONLY, &directories,
&directoryCount) != B_OK) {
return;
}
MemoryDeleter directoriesDeleter(directories);
BPath path;
for (uint i = 0; i < directoryCount; i++) {
BDirectory directory;
if (directory.SetTo(directories[i]) == B_OK) {
entry_ref ref;
while(directory.GetNextRef(&ref) == B_OK)
_RegisterAddOn(ref);
}
}
}
status_t TElementsSorter::EvaluateRef(entry_ref &ref)
{
struct stat st;
BEntry entry;
// Can we create a BEntry?
if (entry.SetTo(&ref, false) != B_OK)
return B_ERROR;
// Can we get a BStatable?
if (entry.GetStat(&st) != B_OK)
return B_ERROR;
// Is it a SymLink?
if (S_ISLNK(st.st_mode))
return HandleLink(ref, st);
// How about a File?
else if (S_ISREG(st.st_mode))
return HandleFile(ref, st);
// A Directory?
else if (S_ISDIR(st.st_mode)) {
BDirectory dir;
if (dir.SetTo(&ref) != B_OK)
return B_ERROR;
if (dir.IsRootDirectory())
return HandleVolume(ref, st, dir);
else
return HandleDirectory(ref, st, dir);
}
// No luck
return B_ERROR;
}
bool
AddOnManager::_FindDecoder(const media_format& format, const BPath& path,
xfer_entry_ref* _decoderRef)
{
node_ref nref;
BDirectory directory;
if (directory.SetTo(path.Path()) != B_OK
|| directory.GetNodeRef(&nref) != B_OK) {
return false;
}
decoder_info* info;
for (fDecoderList.Rewind(); fDecoderList.GetNext(&info);) {
if (info->ref.directory != nref.node)
continue;
media_format* decoderFormat;
for (info->formats.Rewind(); info->formats.GetNext(&decoderFormat);) {
// check if the decoder matches the supplied format
if (!decoderFormat->Matches(&format))
continue;
printf("AddOnManager::GetDecoderForFormat: found decoder %s/%s "
"for encoding %" B_PRIu32 "\n", path.Path(), info->ref.name,
decoderFormat->Encoding());
*_decoderRef = info->ref;
return true;
}
}
return false;
}
status_t PrintTransport::Open(BNode* printerFolder)
{
// already opened?
if (fDataIO != NULL) {
return B_ERROR;
}
// retrieve transport add-on name from printer folder attribute
BString transportName;
if (printerFolder->ReadAttrString("transport", &transportName) != B_OK) {
return B_ERROR;
}
// try first in user add-ons directory
BPath path;
find_directory(B_USER_ADDONS_DIRECTORY, &path);
path.Append("Print/transport");
path.Append(transportName.String());
fAddOnID = load_add_on(path.Path());
if (fAddOnID < 0) {
// on failure try in system add-ons directory
find_directory(B_BEOS_ADDONS_DIRECTORY, &path);
path.Append("Print/transport");
path.Append(transportName.String());
fAddOnID = load_add_on(path.Path());
}
if (fAddOnID < 0) {
// failed to load transport add-on
return B_ERROR;
}
// get init & exit proc
BDataIO* (*initProc)(BMessage*);
get_image_symbol(fAddOnID, "init_transport", B_SYMBOL_TYPE_TEXT, (void **) &initProc);
get_image_symbol(fAddOnID, "exit_transport", B_SYMBOL_TYPE_TEXT, (void **) &fExitProc);
if (initProc == NULL || fExitProc == NULL) {
// transport add-on has not the proper interface
return B_ERROR;
}
// now, initialize the transport add-on
node_ref ref;
BDirectory dir;
printerFolder->GetNodeRef(&ref);
dir.SetTo(&ref);
if (path.SetTo(&dir, NULL) != B_OK) {
return B_ERROR;
}
// request BDataIO object from transport add-on
BMessage input('TRIN');
input.AddString("printer_file", path.Path());
fDataIO = (*initProc)(&input);
return B_OK;
}
void
ModuleManager::_FindModules(BDirectory &dir, const char *moduleDir,
const char *suffix, module_name_list *list)
{
BEntry entry;
while (dir.GetNextEntry(&entry) == B_OK) {
if (entry.IsFile()) {
ModuleAddOn addon;
BPath path;
if (entry.GetPath(&path) == B_OK
&& addon.Load(path.Path(), moduleDir) == B_OK) {
module_info **infos = addon.ModuleInfos();
for (int32 i = 0; infos[i]; i++) {
if (infos[i]->name
&& _MatchSuffix(infos[i]->name, suffix))
list->names.insert(infos[i]->name);
}
}
} else if (entry.IsDirectory()) {
BDirectory subdir;
if (subdir.SetTo(&entry) == B_OK)
_FindModules(subdir, moduleDir, suffix, list);
}
}
}
void
KeymapWindow::_FillSystemMaps()
{
BListItem *item;
while ((item = fSystemListView->RemoveItem(static_cast<int32>(0))))
delete item;
// TODO: common keymaps!
BPath path;
if (find_directory(B_SYSTEM_DATA_DIRECTORY, &path) != B_OK)
return;
path.Append("Keymaps");
BDirectory directory;
entry_ref ref;
if (directory.SetTo(path.Path()) == B_OK) {
while (directory.GetNextRef(&ref) == B_OK) {
fSystemListView->AddItem(new KeymapListItem(ref));
}
}
fSystemListView->SortItems(&compare_key_list_items);
}
//! Sets the cursors to the defaults and saves them to CURSOR_SETTINGS_DIR/"d
void CursorManager::SetDefaults(void)
{
Lock();
CursorSet cs("Default");
cs.AddCursor(B_CURSOR_DEFAULT,default_cursor_data);
cs.AddCursor(B_CURSOR_TEXT,default_text_data);
cs.AddCursor(B_CURSOR_MOVE,default_move_data);
cs.AddCursor(B_CURSOR_DRAG,default_drag_data);
cs.AddCursor(B_CURSOR_RESIZE,default_resize_data);
cs.AddCursor(B_CURSOR_RESIZE_NWSE,default_resize_nwse_data);
cs.AddCursor(B_CURSOR_RESIZE_NESW,default_resize_nesw_data);
cs.AddCursor(B_CURSOR_RESIZE_NS,default_resize_ns_data);
cs.AddCursor(B_CURSOR_RESIZE_EW,default_resize_ew_data);
BDirectory dir;
if(dir.SetTo(CURSOR_SET_DIR)==B_ENTRY_NOT_FOUND)
create_directory(CURSOR_SET_DIR,0777);
BString string(CURSOR_SET_DIR);
string+="Default";
cs.Save(string.String(),B_CREATE_FILE | B_FAIL_IF_EXISTS);
SetCursorSet(string.String());
Unlock();
}
void
FileTypes::ArgvReceived(int32 argc, char **argv)
{
BMessage *message = CurrentMessage();
BDirectory currentDirectory;
if (message)
currentDirectory.SetTo(message->FindString("cwd"));
BMessage refs;
for (int i = 1 ; i < argc ; i++) {
BPath path;
if (argv[i][0] == '/')
path.SetTo(argv[i]);
else
path.SetTo(¤tDirectory, argv[i]);
status_t status;
entry_ref ref;
BEntry entry;
if ((status = entry.SetTo(path.Path(), false)) != B_OK
|| (status = entry.GetRef(&ref)) != B_OK) {
fprintf(stderr, "Could not open file \"%s\": %s\n",
path.Path(), strerror(status));
continue;
}
refs.AddRef("refs", &ref);
}
RefsReceived(&refs);
}
status_t
PathHandler::_GetClosest(const char* path, bool updatePath, node_ref& nodeRef)
{
BPath first(path);
BString missing;
while (true) {
// try to find the first part of the path that exists
BDirectory directory;
status_t status = directory.SetTo(first.Path());
if (status == B_OK) {
status = directory.GetNodeRef(&nodeRef);
if (status == B_OK) {
if (updatePath) {
// normalize path
status = fPath.SetTo(&directory, NULL, true);
if (status == B_OK) {
fPath.Append(missing.String());
fPathLength = strlen(fPath.Path());
}
}
return status;
}
}
if (updatePath) {
if (missing.Length() > 0)
missing.Prepend("/");
missing.Prepend(first.Leaf());
}
if (first.GetParent(&first) != B_OK)
return B_ERROR;
}
}
void
ServerApp::_LaunchAddOnServer()
{
// Try to launch media_addon_server by mime signature.
// If it fails (for example on the Live CD, where the executable
// hasn't yet been mimesetted), try from this application's
// directory
status_t err = be_roster->Launch(B_MEDIA_ADDON_SERVER_SIGNATURE);
if (err == B_OK)
return;
app_info info;
BEntry entry;
BDirectory dir;
entry_ref ref;
err = GetAppInfo(&info);
err |= entry.SetTo(&info.ref);
err |= entry.GetParent(&entry);
err |= dir.SetTo(&entry);
err |= entry.SetTo(&dir, "media_addon_server");
err |= entry.GetRef(&ref);
if (err == B_OK)
be_roster->Launch(&ref);
if (err == B_OK)
return;
(new BAlert("media_server", "Launching media_addon_server failed.\n\n"
"media_server will terminate", "OK"))->Go();
fprintf(stderr, "Launching media_addon_server (%s) failed: %s\n",
B_MEDIA_ADDON_SERVER_SIGNATURE, strerror(err));
exit(1);
}
static bool is_drive_mounted(const char *dev_name, char *mount_name)
{
int32 i = 0;
dev_t d;
fs_info info;
while ((d = next_dev(&i)) >= 0) {
fs_stat_dev(d, &info);
if (strcmp(dev_name, info.device_name) == 0) {
status_t err = -1;
BPath mount;
BDirectory dir;
BEntry entry;
node_ref node;
node.device = info.dev;
node.node = info.root;
err = dir.SetTo(&node);
if (!err)
err = dir.GetEntry(&entry);
if (!err)
err = entry.GetPath(&mount);
if (!err) {
strcpy(mount_name, mount.Path());
return true;
}
}
}
return false;
}
void
KeymapWindow::_FillUserMaps()
{
BListItem* item;
while ((item = fUserListView->RemoveItem(static_cast<int32>(0))))
delete item;
entry_ref ref;
_GetCurrentKeymap(ref);
fUserListView->AddItem(new KeymapListItem(ref, TR("(Current)")));
fCurrentMapName = _GetActiveKeymapName();
BPath path;
if (find_directory(B_USER_SETTINGS_DIRECTORY, &path) != B_OK)
return;
path.Append("Keymap");
BDirectory directory;
if (directory.SetTo(path.Path()) == B_OK) {
while (directory.GetNextRef(&ref) == B_OK) {
fUserListView->AddItem(new KeymapListItem(ref));
}
}
}
void
KeymapWindow::_AddKeyboardLayouts(BMenu* menu)
{
directory_which dataDirectories[] = {
B_USER_DATA_DIRECTORY,
B_COMMON_DATA_DIRECTORY,
B_BEOS_DATA_DIRECTORY
};
for (uint32 i = 0;
i < sizeof(dataDirectories) / sizeof(dataDirectories[0]); i++) {
BPath path;
if (find_directory(dataDirectories[i], &path) != B_OK)
continue;
path.Append("KeyboardLayouts");
BDirectory directory;
if (directory.SetTo(path.Path()) == B_OK) {
entry_ref ref;
while (directory.GetNextRef(&ref) == B_OK) {
if (menu->FindItem(ref.name) != NULL)
continue;
BMessage* message = new BMessage(kChangeKeyboardLayout);
message->AddRef("ref", &ref);
menu->AddItem(new BMenuItem(ref.name, message));
}
}
}
}
DecorManager::DecorManager()
: BLocker("DecorManager"),
fDecorList(0),
fCurrentDecor(NULL)
{
// Start with the default decorator - index is always 0
DecorInfo *defaultDecor = new DecorInfo(-1, "Default", NULL);
fDecorList.AddItem(defaultDecor);
// Add any on disk
RescanDecorators();
#if 0
// Find out which one should be the active one
BDirectory dir;
if (dir.SetTo(SERVER_SETTINGS_DIR) == B_ENTRY_NOT_FOUND)
create_directory(SERVER_SETTINGS_DIR, 0777);
BMessage settings;
BFile file(SERVER_SETTINGS_DIR "decorator_settings", B_READ_ONLY);
// Fallback to the default decorator if something goes wrong
if (file.InitCheck() == B_OK && settings.Unflatten(&file) == B_OK) {
BString itemtext;
if (settings.FindString("decorator", &itemtext) == B_OK) {
fCurrentDecor = _FindDecor(itemtext.String());
}
}
#endif
if (!fCurrentDecor)
fCurrentDecor = (DecorInfo*)fDecorList.ItemAt(0L);
}
/*
* This function is lifted from Simple Directmedia Layer (SDL):
* http://www.libsdl.org/
*/
static void tryDir(const char *d, PHYSFS_StringCallback callback, void *data)
{
BDirectory dir;
dir.SetTo(d);
if (dir.InitCheck() != B_NO_ERROR)
return;
dir.Rewind();
BEntry entry;
while (dir.GetNextEntry(&entry) >= 0)
{
BPath path;
const char *name;
entry_ref e;
if (entry.GetPath(&path) != B_NO_ERROR)
continue;
name = path.Path();
if (entry.GetRef(&e) != B_NO_ERROR)
continue;
if (entry.IsDirectory())
{
if (strcmp(e.name, "floppy") != 0)
tryDir(name, callback, data);
} /* if */
else
{
bool add_it = false;
int devfd;
device_geometry g;
if (strcmp(e.name, "raw") == 0) /* ignore partitions. */
{
int devfd = open(name, O_RDONLY);
if (devfd >= 0)
{
if (ioctl(devfd, B_GET_GEOMETRY, &g, sizeof(g)) >= 0)
{
if (g.device_type == B_CD)
{
char *mntpnt = getMountPoint(name);
if (mntpnt != NULL)
{
callback(data, mntpnt);
allocator.Free(mntpnt); /* !!! FIXME: lose this malloc! */
} /* if */
} /* if */
} /* if */
} /* if */
} /* if */
close(devfd);
} /* else */
} /* while */
} /* tryDir */
filter_result
DCCFileFilter::HandleButton (BMessage *)
{
filter_result result (B_DISPATCH_MESSAGE);
BTextControl *paneltext (dynamic_cast<BTextControl *>(
panel->Window()->FindView ("text view")));
if (paneltext)
{
BDirectory dir;
struct stat s;
entry_ref ref;
BEntry entry;
panel->GetPanelDirectory (&ref);
dir.SetTo (&ref);
if (entry.SetTo (&dir, paneltext->Text()) == B_NO_ERROR
&& entry.GetStat (&s) == B_NO_ERROR
&& S_ISREG (s.st_mode))
{
if (vision_app->GetBool ("dccAutoAccept"))
{
BMessage msg (M_FILE_PANEL_ALERT);
msg.AddInt32 ("which", 2);
panel->Window()->PostMessage (&msg);
result = B_SKIP_MESSAGE;
}
else
{
BString buffer;
BAlert *alert;
buffer << "The file \""
<< paneltext->Text()
<< "\" already exists in the specified folder. "
"Do you want to continue the transfer?";
alert = new BAlert (
"DCC Request",
buffer.String(),
"Cancel",
"Replace",
"Resume",
B_WIDTH_AS_USUAL,
B_OFFSET_SPACING,
B_WARNING_ALERT);
alert->Go (new BInvoker (
new BMessage (M_FILE_PANEL_ALERT),
panel->Window()));
result = B_SKIP_MESSAGE;
}
}
}
return result;
}
void
AddRefsToDeskbarMenu(const BMessage* m, entry_ref* subdirectory)
{
if (m) {
int32 count = 0;
uint32 type = 0;
entry_ref ref;
m->GetInfo("refs", &type, &count);
if (count <= 0)
return;
BPath path;
BSymLink link;
BDirectory dir;
if (subdirectory) {
ref = *subdirectory;
BEntry entry(&ref);
if (entry.Exists()) {
// if the ref is a file get the parent and convert it to a ref
if (entry.IsFile()) {
BEntry parent;
entry.GetParent(&parent);
parent.GetRef(&ref);
}
} else
return;
dir.SetTo(&ref);
} else {
if (find_directory(B_USER_DESKBAR_DIRECTORY, &path) == B_OK)
dir.SetTo(path.Path());
else
return;
}
for (long i = 0; i < count; i++) {
if (m->FindRef("refs", i, &ref) == B_NO_ERROR) {
BEntry entry(&ref);
entry.GetPath(&path);
dir.CreateSymLink(ref.name, path.Path(), &link);
}
}
}
}
void
EnsureTemplates(void)
{
// Because creating a new project depends on the existence of the Templates folder,
// make sure that we have some (very) basic templates to work with if the folder
// has been deleted.
DPath templatePath = gAppPath.GetFolder();
templatePath << "Templates";
bool missing = false;
BDirectory tempDir;
if (!BEntry(templatePath.GetFullPath()).Exists())
{
BDirectory appDir(gAppPath.GetFolder());
appDir.CreateDirectory("Templates", &tempDir);
missing = true;
}
else
{
tempDir.SetTo(templatePath.GetFullPath());
if (tempDir.CountEntries() == 0)
missing = true;
}
if (missing)
{
BDirectory dir;
tempDir.CreateDirectory("Empty Application", &dir);
tempDir.CreateDirectory("Kernel Driver", &dir);
tempDir.CreateDirectory("Shared Library or Addon", &dir);
tempDir.CreateDirectory("Static Library", &dir);
DPath filePath;
TextFile file;
filePath = templatePath;
filePath << "Empty Application/TEMPLATEINFO";
file.SetTo(filePath.GetFullPath(), B_CREATE_FILE | B_READ_WRITE);
file.WriteString("TYPE=Application\nLIB=B_BEOS_LIB_DIRECTORY/libsupc++.so\n");
filePath = templatePath;
filePath << "Kernel Driver/TEMPLATEINFO";
file.SetTo(filePath.GetFullPath(), B_CREATE_FILE | B_READ_WRITE);
file.WriteString("TYPE=Driver\n");
filePath = templatePath;
filePath << "Shared Library or Addon/TEMPLATEINFO";
file.SetTo(filePath.GetFullPath(), B_CREATE_FILE | B_READ_WRITE);
file.WriteString("TYPE=Shared\n");
filePath = templatePath;
filePath << "Static Library/TEMPLATEINFO";
file.SetTo(filePath.GetFullPath(), B_CREATE_FILE | B_READ_WRITE);
file.WriteString("TYPE=Static\n");
file.Unset();
}
}
status_t
ThemeManager::LoadThemes()
{
FENTRY;
int dirwhich;
BPath path;
BDirectory dir;
entry_ref ref;
status_t err;
for (dirwhich = 0; dirwhich < 2; dirwhich++) {
if (!dirwhich) /* find system settings dir */
err = find_directory(B_BEOS_ETC_DIRECTORY, &path);
else /* find user settings dir */
err = find_directory(B_USER_SETTINGS_DIRECTORY, &path);
if (err) return err;
err = dir.SetTo(path.Path());
if (err) return err;
BEntry ent;
if (dir.FindEntry(Z_THEMES_FOLDER_NAME, &ent) < B_OK) {
dir.CreateDirectory(Z_THEMES_FOLDER_NAME, NULL);
}
path.Append(Z_THEMES_FOLDER_NAME);
err = dir.SetTo(path.Path());
if (err) return err;
err = dir.Rewind();
if (err) return err;
while ((err = dir.GetNextRef(&ref)) == B_OK) {
BPath themepath(&ref);
BDirectory tdir(themepath.Path());
err = tdir.InitCheck();
if (err) /* not a dir */
continue;
err = LoadTheme(themepath.Path());
}
}
return B_OK;
}
status_t
GetSettingsDir(BDirectory &dir, BPath &path)
{
//BPath path;
status_t err;
// TODO: build list from text files
err = find_directory(B_USER_SETTINGS_DIRECTORY, &path, true);
if (err < B_OK)
return err;
dir.SetTo(path.Path());
if (!dir.Contains("pe"))
dir.CreateDirectory("pe", NULL);
path.Append("pe");
dir.SetTo(path.Path());
if (!dir.Contains("HeaderTemplates"))
dir.CreateDirectory("HeaderTemplates", NULL);
path.Append("HeaderTemplates");
dir.SetTo(path.Path());
return B_OK;
}
