/*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; }