status_t PoorManWindow::SaveConsole(BMessage* message, bool selection) { entry_ref ref; const char* name; BPath path; BEntry entry; status_t err = B_OK; FILE* f; err = message->FindRef("directory", &ref); if (err != B_OK) return err; err = message->FindString("name", &name); if (err != B_OK) return err; err = entry.SetTo(&ref); if (err != B_OK) return err; entry.GetPath(&path); path.Append(name); if (!(f = fopen(path.Path(), "w"))) return B_ERROR; if (!selection) { // write the data to the file err = fwrite(fLoggingView->Text(), 1, fLoggingView->TextLength(), f); } else { // find the selected text and write it to a file int32 start = 0, end = 0; fLoggingView->GetSelection(&start, &end); BString buffer; char * buffData = buffer.LockBuffer(end - start + 1); // copy the selected text from the TextView to the buffer fLoggingView->GetText(start, end - start, buffData); buffer.UnlockBuffer(end - start + 1); err = fwrite(buffer.String(), 1, end - start + 1, f); } fclose(f); return err; }
extern "C" void process_refs(entry_ref directoryRef, BMessage *msg, void *) { BDirectory directory(&directoryRef); if (directory.InitCheck() != B_OK) return; int32 errors = 0; entry_ref ref; int32 index; for (index = 0; msg->FindRef("refs", index, &ref) == B_OK; index ++) { BSymLink link(&ref); if (link.InitCheck() != B_OK || !link.IsSymLink()) { errors++; continue; } BEntry targetEntry; BPath path; if (link.MakeLinkedPath(&directory, &path) < B_OK || targetEntry.SetTo(path.Path()) != B_OK || targetEntry.GetParent(&targetEntry) != B_OK) { (new BAlert("Open Target Folder", "Cannot open target folder. Maybe this link is broken?", "OK", NULL, NULL, B_WIDTH_AS_USUAL, B_WARNING_ALERT))->Go(NULL); continue; } // create Tracker message... entry_ref target; targetEntry.GetRef(&target); BMessage message(B_REFS_RECEIVED); message.AddRef("refs", &target); // ...and send it BMessenger messenger("application/x-vnd.Be-TRAK"); messenger.SendMessage(&message); // TODO: select entry via scripting? } if (errors) { (new BAlert("Open Target Folder", "This add-on can only be used on symbolic links.\n" "It opens the folder of the link target in Tracker.", "OK"))->Go(NULL); } }
status_t ModuleManager::_GetAddOn(const char *name, ModuleAddOn **_addon) { // search list first for (int32 i = 0; ModuleAddOn *addon = fAddOns.ItemAt(i); i++) { BString addonName(addon->Name()); addonName << "/"; if (!strcmp(name, addon->Name()) || !strncmp(addonName.String(), name, addonName.Length())) { addon->Get(); *_addon = addon; return B_OK; } } // not in list yet, load from disk // iterate through module dirs for (int32 i = 0; gModuleDirs[i]; i++) { BPath path; if (path.SetTo(gModuleDirs[i]) == B_OK && path.SetTo(path.Path(), name) == B_OK) { BEntry entry; for (;;) { if (entry.SetTo(path.Path()) == B_OK && entry.Exists()) { // found an entry: if it is a file, try to load it if (entry.IsFile()) { ModuleAddOn *addon = new ModuleAddOn; if (addon->Load(path.Path(), gModuleDirs[i]) == B_OK) { status_t status = addon->Get(); if (status < B_OK) { delete addon; return status; } fAddOns.AddItem(addon); *_addon = addon; return B_OK; } delete addon; } break; } // chop off last path component if (path.GetParent(&path) != B_OK) break; } } } return B_ENTRY_NOT_FOUND; }
status_t DecorThemesAddon::RunPreferencesPanel() { status_t err; entry_ref ref; BEntry ent; err = ent.SetTo("/boot/beos/references/Appearance"); if (!err) { err = ent.GetRef(&ref); if (!err) { err = be_roster->Launch(&ref); } } return err; }
// Scans a directory and adds the entries it founds as strings to the // given list static int32 scan_directory(const char *directory, BList *list) { BEntry entry; BDirectory dir(SERIAL_DIR); char buf[B_OS_NAME_LENGTH]; ASSERT(list != NULL); while (dir.GetNextEntry(&entry) == B_OK) { entry.GetName(buf); list->AddItem(strdup(buf)); }; return list->CountItems(); }
/*! \brief Reinitializes the object to the entry referred to by the specified path rooted in the specified directory. \param dir the BDirectory, relative to which the entry's path name is given \param path the entry's path name relative to \a dir \return - \c B_OK: Everything went fine. - \c B_BAD_VALUE: \c NULL \a dir or \a path. - \c B_ENTRY_NOT_FOUND: The entry could not be found. - \c B_BUSY: The entry is locked. \todo Implemented using SetTo(BEntry*). Check, if necessary to reimplement! */ status_t BNode::SetTo(const BDirectory *dir, const char *path) { Unset(); status_t error = (dir && path ? B_OK : B_BAD_VALUE); if (error == B_OK && BPrivate::Storage::is_absolute_path(path)) error = B_BAD_VALUE; BEntry entry; if (error == B_OK) error = entry.SetTo(dir, path); if (error == B_OK) error = SetTo(&entry); fCStatus = error; return error; }
void InspectorApp::AddToTranslatorsList(const char *folder, int32 group) { BDirectory dir; if (dir.SetTo(folder) == B_OK) { BEntry ent; while (dir.GetNextEntry(&ent) == B_OK) { BPath path; if (ent.GetPath(&path) == B_OK) flstTranslators.AddItem( new BTranslatorItem(path.Leaf(), path.Path(), group)); } } }
/*! \brief Returns the mount point for the partition. If the partition is mounted this is the actual mount point. If it is not mounted, but contains a file system, derived from the partition name the name for a not yet existing directory in the root directory is constructed and the path to it returned. For partitions not containing a file system the method returns an error. \param mountPoint Pointer to the path to be set to refer the mount point (respectively potential mount point) of the partition. \return \c B_OK, if everything went fine, an error code otherwise. */ status_t BPartition::GetMountPoint(BPath* mountPoint) const { if (!mountPoint || !ContainsFileSystem()) return B_BAD_VALUE; // if the partition is mounted, return the actual mount point BVolume volume; if (GetVolume(&volume) == B_OK) { BDirectory dir; status_t error = volume.GetRootDirectory(&dir); if (error == B_OK) error = mountPoint->SetTo(&dir, NULL); return error; } // partition not mounted // get the volume name const char* volumeName = ContentName(); if (!volumeName || strlen(volumeName) == 0) volumeName = Name(); if (!volumeName || strlen(volumeName) == 0) volumeName = "unnamed volume"; // construct a path name from the volume name // replace '/'s and prepend a '/' BString mountPointPath(volumeName); mountPointPath.ReplaceAll('/', '-'); mountPointPath.Insert("/", 0); // make the name unique BString basePath(mountPointPath); int counter = 1; while (true) { BEntry entry; status_t error = entry.SetTo(mountPointPath.String()); if (error != B_OK) return error; if (!entry.Exists()) break; mountPointPath = basePath; mountPointPath << counter; counter++; } return mountPoint->SetTo(mountPointPath.String()); }
void ModulesView::PopulateScreenSaverList() { fListView->DeselectAll(); while (ScreenSaverItem* item = (ScreenSaverItem*)fListView->RemoveItem((int32)0)) { delete item; } // Blackness is a built-in screen saver fListView->AddItem(new ScreenSaverItem(B_TRANSLATE("Blackness"), "")); // Iterate over add-on directories, and add their files to the list view directory_which which[] = { B_BEOS_ADDONS_DIRECTORY, B_USER_ADDONS_DIRECTORY}; ScreenSaverItem* selectItem = NULL; for (uint32 i = 0; i < sizeof(which) / sizeof(which[0]); i++) { BPath basePath; find_directory(which[i], &basePath); basePath.Append("Screen Savers", true); BDirectory dir(basePath.Path()); BEntry entry; while (dir.GetNextEntry(&entry, true) == B_OK) { char name[B_FILE_NAME_LENGTH]; if (entry.GetName(name) != B_OK) continue; BPath path = basePath; path.Append(name); ScreenSaverItem* item = new ScreenSaverItem(name, path.Path()); fListView->AddItem(item); if (!strcmp(fSettings.ModuleName(), item->Text()) || (!strcmp(fSettings.ModuleName(), "") && !strcmp(item->Text(), B_TRANSLATE("Blackness")))) selectItem = item; } } fListView->SortItems(_CompareScreenSaverItems); fListView->Select(fListView->IndexOf(selectItem)); fListView->ScrollToSelection(); }
void IncludeSettingsView::AddRefsToList(BListView* list, BMessage* message, bool relative = false) { //XXX - it is possible for now to select only one directory each time. entry_ref ref; BEntry entry; BPath path; BString pathString; status_t err; int32 ref_num; bool relpath = false; ref_num = 0; //find boolean in the message err = message->FindBool("relpath", &relpath); if (err != B_OK) { DPRINT("IncludeSettingsView::AddRefsToList: boolean not found"); } //add this entry to the list view do { if ( (err = message->FindRef("refs", ref_num, &ref)) != B_OK ) { return; } entry.SetTo(&ref, true); //we return if for some strange reason the entry is unavailable if (entry.InitCheck() != B_OK) return; entry.GetPath(&path); //XXX - if "relative" convert path DPRINT("IncludeSettingsView::AddRefsToList: entry name = " << path.Path()); //convert path to relative if requested if (relpath) { //find the window we are attached to... DPRINT("IncludeSettingsView::AddRefsToList: add relative path"); TargetConfig* c = ((TargetSettingsWin*) Window() )->TConfig(); assert(c != NULL); //we *must* be attached to a window here c->RelPathToWorkingDir(path.Path(), &pathString); } else { DPRINT("IncludeSettingsView::AddRefsToList: add absolute path"); pathString = path.Path(); } list->AddItem(new BStringItem(pathString.String())); //tell the window that this view has changed CommunicateChanges(); ref_num++; } while (1); }
/* * This function is lifted from Simple Directmedia Layer (SDL): * https://www.libsdl.org/ ... this is zlib-licensed code, too. */ 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); continue; } /* if */ const int devfd = open(name, O_RDONLY); if (devfd < 0) continue; device_geometry g; const int rc = ioctl(devfd, B_GET_GEOMETRY, &g, sizeof (g)); close(devfd); if (rc < 0) continue; if (g.device_type != B_CD) continue; char mntpnt[B_FILE_NAME_LENGTH]; if (getMountPoint(name, mntpnt, sizeof (mntpnt))) callback(data, mntpnt); } /* while */ } /* tryDir */
status_t HModuleRoster::StartWatching( BPath *moduleDirectory ) { if( watching ) return B_ERROR; printf("Watching %s\n", moduleDirectory->Path()); BEntry entry; if( (entry.SetTo( moduleDirectory->Path() ) == B_OK)&& (entry.GetNodeRef( &watchedRef ) == B_OK) ) { watching = true; return watch_node( &watchedRef, B_WATCH_DIRECTORY, this ); } else return B_ERROR; }
/* AddFisrtInstanceAsRefToBMsg method adds refs of the files and folders of the "root" folder of the selected files to BMessage */ void FileTree::AddFisrtInstanceAsRefToBMsg(BMessage *objMsg) { FileTree *tmpTree; BEntry *objEntry = new BEntry(); entry_ref *file_ref = new entry_ref; for(int i = 0; i < Nodes->CountItems(); i++) { tmpTree = (FileTree*)Nodes->ItemAt(i); objEntry->SetTo(tmpTree->Path.String()); objEntry->GetRef(file_ref); objMsg->AddRef("refs", file_ref); } delete objEntry; }
void InfoBox::GetFolder(BDirectory dir) { int32 c=dir.CountEntries(); BEntry entry; if (c>0) for (int32 i=0; i<c; i++) { dir.GetNextEntry(&entry, true); if (entry.IsDirectory()) { folders++; GetFolder(BDirectory(&entry)); } else files++; } }
/*! \brief Returns whether this directory or any of its subdirectories at any level contain the entry referred to by the supplied path name. Only entries that match the node flavor specified by \a nodeFlags are considered. If the BDirectory is not properly initialized, the method returns \c false. A non-absolute path is considered relative to the current directory. \note R5's implementation always returns \c true given an absolute path or an unitialized directory. This implementation is not compatible with that behavior. Instead it converts the path into a BEntry and passes it to the other version of Contains(). \param path the entry's path name. May be relative to this directory or absolute. \param nodeFlags Any of the following: - \c B_FILE_NODE: The entry must be a file. - \c B_DIRECTORY_NODE: The entry must be a directory. - \c B_SYMLINK_NODE: The entry must be a symbolic link. - \c B_ANY_NODE: The entry may be of any kind. \return - \c true, if the entry exists, its kind does match \nodeFlags and the BDirectory is properly initialized and does contain the entry at any level, - \c false, otherwise */ bool BDirectory::Contains(const char *path, int32 nodeFlags) const { // check initialization and parameters if (InitCheck() != B_OK) return false; if (!path) return true; // mimic R5 behavior // turn the path into a BEntry and let the other version do the work BEntry entry; if (BPrivate::Storage::is_absolute_path(path)) entry.SetTo(path); else entry.SetTo(this, path); return Contains(&entry, nodeFlags); }
bool InitialIterator::GetTopEntry(BEntry& entry) { // If the user selected one or more files, we must look // at the "refs" inside the message that was passed into // our add-on's process_refs(). If the user didn't select // any files, we will simply read all the entries from the // current working directory. entry_ref fileRef; if (fSelectedFiles.FindRef("refs", fCurrentRef, &fileRef) == B_OK) { entry.SetTo(&fileRef, fRecurseLinks); ++fCurrentRef; return true; } else if (fCurrentRef > 0) { // when we get here, we have processed // all the refs from the message return false; } else if (fCurrentDir != NULL) { // examine the whole directory return fCurrentDir->GetNextEntry(&entry, fRecurseLinks) == B_OK; } return false; }
bool PanelView::DoesEntryExist(const char *filename) //////////////////////////////////////////////////////////////////////// { BEntry entry; entry.SetTo(filename); if (entry.InitCheck()==B_OK) { if (entry.Exists()) return true; else return false; } else return false; }
void DownloadProgressView::_StartNodeMonitor(const BEntry& entry) { node_ref nref; if (entry.GetNodeRef(&nref) == B_OK) watch_node(&nref, B_WATCH_ALL, this); }
bool BSlowContextMenu::StartBuildingItemList() { // return false when done building BEntry entry; if (fNavDir.device < 0 || entry.SetTo(&fNavDir) != B_OK || !entry.Exists()) return false; fIteratingDesktop = false; BDirectory parent; status_t err = entry.GetParent(&parent); fItemList = new BObjectList<BMenuItem>(50); // if ref is the root item then build list of volume root dirs fVolsOnly = (err == B_ENTRY_NOT_FOUND); if (fVolsOnly) return true; Model startModel(&entry, true); if (startModel.InitCheck() == B_OK) { if (!startModel.IsContainer()) return false; if (startModel.IsQuery()) fContainer = new QueryEntryListCollection(&startModel); else if (startModel.IsDesktop()) { fIteratingDesktop = true; fContainer = DesktopPoseView::InitDesktopDirentIterator(0, startModel.EntryRef()); AddRootItemsIfNeeded(); AddTrashItem(); } else fContainer = new DirectoryEntryList(*dynamic_cast<BDirectory *> (startModel.Node())); if (fContainer->InitCheck() != B_OK) return false; fContainer->Rewind(); } return true; }
/* * Given a local file path, * update the corresponding file on Dropbox */ void update_file_in_dropbox(const char * filepath, const char *parent_rev) { char * argv[4]; argv[0] = "db_put.py"; BString db_filepath = local_to_db_filepath(filepath); const char * tmp = db_filepath.String(); char not_const[db_filepath.CountChars()]; strcpy(not_const,tmp); argv[2] = not_const; char not_const2[strlen(filepath)]; strcpy(not_const2,filepath); argv[1] = not_const2; char not_const3[strlen(parent_rev)]; strcpy(not_const3,parent_rev); argv[3] = not_const3; BString *result = run_python_script(argv,4); BString *real_path = parse_path(result); BString *new_parent_rev = parse_parent_rev(result); delete result; printf("path:|%s|\nparent_rev:|%s|\n",real_path->String(),new_parent_rev->String()); BNode node = BNode(filepath); set_parent_rev(&node,new_parent_rev); delete new_parent_rev; BEntry entry = BEntry(filepath); BPath old_path; entry.GetPath(&old_path); BPath new_path = BPath(db_to_local_filepath(real_path->String()).String()); printf("Should I move %s to %s?\n", old_path.Path(), new_path.Path()); if(strcmp(new_path.Leaf(),old_path.Leaf()) != 0) { printf("moving %s to %s\n", old_path.Leaf(), new_path.Leaf()); BEntry entry = BEntry(old_path.Path()); //entry for local path status_t err = entry.Rename(new_path.Leaf(),true); if(err != B_OK) printf("error moving: %s\n",strerror(err)); } delete real_path; }
int32 add_query_menu_items(BMenu* menu, const char* attribute, uint32 what, const char* format, bool popup) { BVolume volume; BVolumeRoster().GetBootVolume(&volume); BQuery query; query.SetVolume(&volume); query.PushAttr(attribute); query.PushString("*"); query.PushOp(B_EQ); query.Fetch(); int32 index = 0; BEntry entry; while (query.GetNextEntry(&entry) == B_OK) { BFile file(&entry, B_READ_ONLY); if (file.InitCheck() == B_OK) { BMessage* message = new BMessage(what); entry_ref ref; entry.GetRef(&ref); message->AddRef("ref", &ref); BString value; if (file.ReadAttrString(attribute, &value) < B_OK) continue; message->AddString("attribute", value.String()); BString name; if (format != NULL) name.SetToFormat(format, value.String()); else name = value; if (index < 9 && !popup) menu->AddItem(new BMenuItem(name, message, '1' + index)); else menu->AddItem(new BMenuItem(name, message)); index++; } } return index; }
status_t InstalledPackageInfo::Uninstall() { if (fStatus != B_OK) return fStatus; BString *iter; uint32 i, count = fInstalledItems.CountItems(); BEntry entry; status_t ret; // Try to remove all entries that are present in the list for (i = 0; i < count; i++) { iter = static_cast<BString *>(fInstalledItems.ItemAt(count - i - 1)); fprintf(stderr, "Removing: %s (%ld/%ld)\n", iter->String(), i, count); ret = entry.SetTo(iter->String()); if (ret == B_BUSY) { // The entry's directory is locked - wait a few cycles for it to // unlock itself int32 tries = 0; for (tries = 0; tries < P_BUSY_TRIES; tries++) { ret = entry.SetTo(iter->String()); if (ret != B_BUSY) break; // Wait a moment usleep(1000); } } if (ret == B_ENTRY_NOT_FOUND) continue; else if (ret != B_OK) { fStatus = B_ERROR; return fStatus; } fprintf(stderr, "...we continue\n"); if (entry.Exists() && entry.Remove() != B_OK) { fprintf(stderr, "\n%s\n", strerror(ret)); fStatus = B_ERROR; return fStatus; } fInstalledItems.RemoveItem(count - i - 1); } if (entry.SetTo(fPathToInfo.Path()) != B_OK) { fStatus = B_ERROR; return fStatus; } if (entry.Exists() && entry.Remove() != B_OK) { fStatus = B_ERROR; return fStatus; } return fStatus; }
status_t TrashFile(BEntry *src) { // Move a file to the Trash. If the name exists, rename the entry before moving if(!src) return B_ERROR; status_t status; BPath path; BEntry dest; BString pathstr("/boot/home/Desktop/Trash/"); BDirectory dir(pathstr.String()); char newname[B_FILE_NAME_LENGTH]; src->GetName(newname); pathstr+=newname; dest.SetTo(pathstr.String()); GetValidName(&dest); dest.GetPath(&path); BPath srcpath; src->GetPath(&srcpath); BNode node(srcpath.Path()); if(node.InitCheck()==B_OK) { node.WriteAttr("_trk/original_path",B_STRING_TYPE,0, srcpath.Path(),strlen(srcpath.Path())+1); } status=src->MoveTo(&dir,path.Path(),false); if(status==B_CROSS_DEVICE_LINK) { BPath srcpath; src->GetPath(&srcpath); BString command("mv "),srcstring(srcpath.Path()),deststring(path.Path()); srcstring.CharacterEscape(" ",'\\'); deststring.CharacterEscape(" ",'\\'); command+=srcstring; command+=" "; command+=deststring; system(command.String()); } return status; }
/*! \brief Finds and loads the next add-on of an add-on subdirectory. \param directory The add-on directory. \param image Pointer to an image_id into which the image ID of the loaded add-on shall be written. \return - \c B_OK: Everything went fine. - \c B_ENTRY_NOT_FOUND: End of directory. - other error codes */ status_t BDiskDeviceRoster::_GetNextAddOn(BDirectory *directory, AddOnImage *image) { status_t error = (directory ? B_OK : B_ENTRY_NOT_FOUND); if (error == B_OK) { // iterate through the entry list and try to load the entries bool found = false; while (error == B_OK && !found) { BEntry entry; error = directory->GetNextEntry(&entry); BPath path; if (error == B_OK && entry.GetPath(&path) == B_OK) found = (image->Load(path.Path()) == B_OK); } } return error; }
void InfoStrView::OpenFolder (const char *path) const { /* This function opens a folder entry_ref through Tracker */ BEntry entry (path, true); entry_ref refToDir; entry.GetRef (&refToDir); if (entry.Exists() == true) { BMessage trakMsg (B_REFS_RECEIVED); trakMsg.AddRef ("refs", &refToDir); /* Just check if tracker is running */ if (be_roster->IsRunning (trackerSignature) == true) BMessenger(trackerSignature).SendMessage (&trakMsg); } }
bool SeqNavMenu::AddNextItem() { // limit nav menus to 500 items only if( mItems.size() >= 500 ) return false; BEntry entry; bool useLeafForLabel = true; if( IsPathMenu() ) { if( mDirectory.GetNextEntry( &entry ) != B_OK ) return false; } else if( IsPredicateMenu() ) { if( mQuery.GetNextEntry( &entry ) != B_OK ) return false; useLeafForLabel = false; } if( entry.InitCheck() != B_OK ) return false; AddEntry( entry, useLeafForLabel ); return true; }
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); } } } }
filter_result DCCFileFilter::HandleAlert (BMessage *msg) { BTextControl *text (dynamic_cast<BTextControl *>( panel->Window()->FindView ("text view"))); int32 which; msg->FindInt32 ("which", &which); if (which == 0 || text == 0) { return B_SKIP_MESSAGE; } entry_ref ref; panel->GetPanelDirectory (&ref); if (which == 2) { BDirectory dir (&ref); BFile file (&dir, text->Text(), B_READ_ONLY); BEntry entry (&dir, text->Text()); BPath path; off_t position; file.GetSize (&position); entry.GetPath (&path); send_msg.AddString ("path", path.Path()); send_msg.AddInt64 ("pos", position); send_msg.what = M_ADD_RESUME_DATA; } else { send_msg.AddRef ("directory", &ref); send_msg.AddString ("name", text->Text()); } panel->Messenger().SendMessage (&send_msg); BMessage cmsg (B_CANCEL); cmsg.AddPointer ("source", panel); panel->Messenger().SendMessage (&cmsg); return B_SKIP_MESSAGE; }
void LaunchDaemon::_ReadEntry(const char* context, BEntry& entry) { if (entry.IsDirectory()) _ReadDirectory(context, entry); else _ReadFile(context, entry); }
//------------------------------------------------------------------------------ bool is_asst_installed() { bool aInstalled = true; BEntry aEntry; try { aEntry.SetTo(asst_install_path(FOLDER_NAME_ASST_SPY).c_str(), true); if ( !aEntry.Exists() ) throw B_ERROR; aEntry.SetTo(asst_install_path(FOLDER_NAME_ASST_PASTE_SENDER).c_str(), true); if ( !aEntry.Exists() ) throw B_ERROR; } catch (...) { aInstalled = false; } return aInstalled; }