//---------------------- 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;
}
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
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));
}
}
uint64 PanelView::GetDirectorySize(const char *path)
////////////////////////////////////////////////////////////////////////
{
uint64 size = 0;
BDirectory *dir;
dir = new BDirectory(path);
if (dir)
{
BEntry entry;
if (dir->GetEntry(&entry)==B_OK)
{
while (dir->GetNextEntry(&entry)==B_OK)
{
BPath path;
entry.GetPath(&path);
if (entry.IsDirectory())
size += GetDirectorySize(path.Path());
else
{
struct stat statbuf;
entry.GetStat(&statbuf);
size += statbuf.st_size;
}
}
}
delete dir;
}
return size;
}
/*
* 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 */
// Scan directory for CD-ROM drives, add them to prefs
static void scan_for_cdrom_drives(const char *directory)
{
// Set directory
BDirectory dir;
dir.SetTo(directory);
if (dir.InitCheck() != B_NO_ERROR)
return;
dir.Rewind();
// Scan each entry
BEntry entry;
while (dir.GetNextEntry(&entry) >= 0) {
// Get path and ref for entry
BPath path;
if (entry.GetPath(&path) != B_NO_ERROR)
continue;
const char *name = path.Path();
entry_ref e;
if (entry.GetRef(&e) != B_NO_ERROR)
continue;
// Recursively enter subdirectories (except for floppy)
if (entry.IsDirectory()) {
if (!strcmp(e.name, "floppy"))
continue;
scan_for_cdrom_drives(name);
} else {
D(bug(" checking '%s'\n", name));
// Ignore partitions
if (strcmp(e.name, "raw"))
continue;
// Open device
int fd = open(name, O_RDONLY);
if (fd < 0)
continue;
// Get geometry and device type
device_geometry g;
if (ioctl(fd, B_GET_GEOMETRY, &g, sizeof(g)) < 0) {
close(fd);
continue;
}
// Insert to list if it is a CD drive
if (g.device_type == B_CD)
PrefsAddString("cdrom", name);
close(fd);
}
}
}
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));
}
}
}
/*
* 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 */
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 Scan a folder for all valid fonts
\param directoryPath Path of the folder to scan.
*/
status_t
FontManager::_ScanFontDirectory(font_directory& fontDirectory)
{
// This bad boy does all the real work. It loads each entry in the
// directory. If a valid font file, it adds both the family and the style.
BDirectory directory;
status_t status = directory.SetTo(&fontDirectory.directory);
if (status != B_OK)
return status;
BEntry entry;
while (directory.GetNextEntry(&entry) == B_OK) {
if (entry.IsDirectory()) {
// scan this directory recursively
font_directory* newDirectory;
if (_AddPath(entry, &newDirectory) == B_OK && newDirectory != NULL)
_ScanFontDirectory(*newDirectory);
continue;
}
// TODO: Commenting this out makes my "Unicode glyph lookup"
// work with our default fonts. The real fix is to select the
// Unicode char map (if supported), and/or adjust the
// utf8 -> glyph-index mapping everywhere to handle other
// char maps. We could also ignore fonts that don't support
// the Unicode lookup as a temporary "solution".
#if 0
FT_CharMap charmap = _GetSupportedCharmap(face);
if (!charmap) {
FT_Done_Face(face);
continue;
}
face->charmap = charmap;
#endif
_AddFont(fontDirectory, entry);
// takes over ownership of the FT_Face object
}
fontDirectory.revision = 1;
return B_OK;
}
void BeCheckersWindow::SavedGames(BListView *list) {
char name[B_FILE_NAME_LENGTH];
BEntry entry;
BDirectory dir;
BPath p;
find_directory(B_USER_DIRECTORY, &p);
p.Append(APP_SGP);
dir.SetTo(p.Path());
dir.Rewind();
while (dir.GetNextEntry(&entry) == B_OK) {
entry.GetName(name);
strtok(name, "."); // Strip the filename extension
list->AddItem(new BStringItem(name));
}
}
void PanelView::DeleteDirectory(const char *dirname)
////////////////////////////////////////////////////////////////////////
{
BDirectory *dir;
key_info keyinfo;
// Don't delete the parent directory!!!!!!
if (strlen(dirname)>=3)
{
int len = strlen(dirname);
if (dirname[len-1]=='.' && dirname[len-2]=='.' && dirname[len-3]=='/') return;
}
dir = new BDirectory(dirname);
if (dir)
{
BEntry entry;
if (dir->GetEntry(&entry)==B_OK)
{
while (dir->GetNextEntry(&entry)==B_OK)
{
get_key_info(&keyinfo);
if (keyinfo.key_states[0] & 0x40) // ESC
{
beep();
delete dir;
return;
}
BPath path;
entry.GetPath(&path);
if (entry.IsDirectory())
DeleteDirectory(path.Path());
entry.Remove();
}
}
delete dir;
}
}
// collect_folder_contents
void
collect_folder_contents( BDirectory& dir, BList& list, bool& deep, bool& asked, BEntry& entry )
{
while ( dir.GetNextEntry( &entry, true ) == B_OK )
{
if ( !entry.IsDirectory() )
{
BPath path;
// since the directory will give us the entries in reverse order,
// we put them each at the same index, effectively reversing the
// items while adding them
if ( entry.GetPath( &path ) == B_OK )
{
BString* string = new BString( path.Path() );
if ( !list.AddItem( string, 0 ) )
delete string; // at least don't leak
}
}
else
{
if ( !asked )
{
// ask user if we should parse sub-folders as well
BAlert* alert = new BAlert( "sub-folders?",
_("Open files from all sub-folders as well?"),
_("Cancel"), _("Open"), NULL, B_WIDTH_AS_USUAL,
B_IDEA_ALERT );
int32 buttonIndex = alert->Go();
deep = buttonIndex == 1;
asked = true;
// never delete BAlerts!!
}
if ( deep )
{
BDirectory subDir( &entry );
if ( subDir.InitCheck() == B_OK )
collect_folder_contents( subDir, list,
deep, asked, entry );
}
}
}
}
status_t HModuleRoster::LoadModules( BPath *moduleDirectory )
{
status_t status;
BDirectory dir;
if( (status = dir.SetTo( moduleDirectory->Path() )) == B_OK )
{
BEntry entry;
BPath modulePath;
while( dir.GetNextEntry( &entry, true ) != B_ENTRY_NOT_FOUND )
{
entry.GetPath( &modulePath );
LoadModule( &modulePath );
}
}
else
return status;
return B_OK;
}
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
delete_directory_path(char *path,bool recur)
{
BDirectory *dir;
BPath *pat,pt;
BEntry *ent;
if ((pat = create_path(path)))
{
if ((dir = create_mydir((char *)pat->Path())))
{
if (dir->Rewind() == B_OK)
{
if ((ent = new BEntry()))
{
while (dir->GetNextEntry(ent,false) == B_NO_ERROR)
{
if (ent->GetPath(&pt) == B_NO_ERROR)
{
if (recur)
{
if (ent->IsDirectory())
{
delete_directory_path((char *)pt.Path(),recur);
}
}
}
ent->Remove();
}
delete ent;
}
}
delete dir;
}
delete pat;
}
}
void
DialUpView::LoadInterfaces()
{
fInterfaceMenu->AddSeparatorItem();
fInterfaceMenu->AddItem(new BMenuItem(kLabelCreateNewInterface,
new BMessage(kMsgCreateNew)));
fDeleterItem = new BMenuItem(kLabelDeleteCurrent,
new BMessage(kMsgDeleteCurrent));
fInterfaceMenu->AddItem(fDeleterItem);
BDirectory settingsDirectory;
BEntry entry;
BPath path;
GetPPPDirectories(&settingsDirectory, NULL);
while(settingsDirectory.GetNextEntry(&entry) == B_OK) {
if(entry.IsFile()) {
entry.GetPath(&path);
AddInterface(path.Leaf(), true);
}
}
}
void
TMailApp::_CheckForSpamFilterExistence()
{
// Looks at the filter settings to see if the user is using a spam filter.
// If there is one there, set fShowSpamGUI to TRUE, otherwise to FALSE.
int32 addonNameIndex;
const char *addonNamePntr;
BDirectory inChainDir;
BPath path;
BEntry settingsEntry;
BFile settingsFile;
BMessage settingsMessage;
fShowSpamGUI = false;
if (find_directory(B_USER_SETTINGS_DIRECTORY, &path) != B_OK)
return;
// TODO use new settings
path.Append("Mail/chains/inbound");
if (inChainDir.SetTo(path.Path()) != B_OK)
return;
while (inChainDir.GetNextEntry (&settingsEntry, true /* traverse */) == B_OK) {
if (!settingsEntry.IsFile())
continue;
if (settingsFile.SetTo (&settingsEntry, B_READ_ONLY) != B_OK)
continue;
if (settingsMessage.Unflatten (&settingsFile) != B_OK)
continue;
for (addonNameIndex = 0; B_OK == settingsMessage.FindString (
"filter_addons", addonNameIndex, &addonNamePntr);
addonNameIndex++) {
if (strstr (addonNamePntr, "Spam Filter") != NULL) {
fShowSpamGUI = true; // Found it!
return;
}
}
}
}
//---------------------------------------------------------------------
// HandleDirectory
//---------------------------------------------------------------------
// iterate through the directory and pass the resulting
// refs and attempt to add the resulting file
//
status_t TQueueDialog::HandleDirectory(entry_ref &ref, struct stat &st, BDirectory &dir)
{
struct stat s;
BEntry entry;
dir.Rewind();
while (true)
{
if (dir.GetNextEntry(&entry) == B_OK)
{
entry.GetStat(&s);
entry_ref eRef;
entry.GetRef(&eRef);
// HandleFile(eRef, s);
EvaluateRef(eRef);
} else
break;
}
return B_ERROR;
}
void PrefsWindow::add_serial_names(BPopUpMenu *menu, uint32 msg)
{
BSerialPort *port = new BSerialPort;
char name[B_PATH_NAME_LENGTH];
for (int i=0; i<port->CountDevices(); i++) {
port->GetDeviceName(i, name);
menu->AddItem(new BMenuItem(name, new BMessage(msg)));
}
if (sys_info.platform_type == B_BEBOX_PLATFORM) {
BDirectory dir;
BEntry entry;
dir.SetTo("/dev/parallel");
if (dir.InitCheck() == B_NO_ERROR) {
dir.Rewind();
while (dir.GetNextEntry(&entry) >= 0) {
if (!entry.IsDirectory()) {
entry.GetName(name);
menu->AddItem(new BMenuItem(name, new BMessage(msg)));
}
}
}
}
delete port;
}
void
HWindow::SetupMenuField()
{
BMenuField* menufield = dynamic_cast<BMenuField*>(FindView("filemenu"));
if (menufield == NULL)
return;
BMenu* menu = menufield->Menu();
int32 count = fEventList->CountRows();
for (int32 i = 0; i < count; i++) {
HEventRow* row = (HEventRow*)fEventList->RowAt(i);
if (row == NULL)
continue;
BPath path(row->Path());
if (path.InitCheck() != B_OK)
continue;
if (menu->FindItem(path.Leaf()))
continue;
BMessage* msg = new BMessage(M_ITEM_MESSAGE);
entry_ref ref;
::get_ref_for_path(path.Path(), &ref);
msg->AddRef("refs", &ref);
menu->AddItem(new BMenuItem(path.Leaf(), msg), 0);
}
BPath path;
BDirectory dir;
BEntry entry;
BPath item_path;
status_t err = find_directory(B_BEOS_SOUNDS_DIRECTORY, &path);
if (err == B_OK)
err = dir.SetTo(path.Path());
while (err == B_OK) {
err = dir.GetNextEntry(&entry, true);
if (entry.InitCheck() != B_NO_ERROR)
break;
entry.GetPath(&item_path);
if (menu->FindItem(item_path.Leaf()))
continue;
BMessage* msg = new BMessage(M_ITEM_MESSAGE);
entry_ref ref;
::get_ref_for_path(item_path.Path(), &ref);
msg->AddRef("refs", &ref);
menu->AddItem(new BMenuItem(item_path.Leaf(), msg), 0);
}
err = find_directory(B_USER_SOUNDS_DIRECTORY, &path);
if (err == B_OK)
err = dir.SetTo(path.Path());
while (err == B_OK) {
err = dir.GetNextEntry(&entry, true);
if (entry.InitCheck() != B_NO_ERROR)
break;
entry.GetPath(&item_path);
if (menu->FindItem(item_path.Leaf()))
continue;
BMessage* msg = new BMessage(M_ITEM_MESSAGE);
entry_ref ref;
::get_ref_for_path(item_path.Path(), &ref);
msg->AddRef("refs", &ref);
menu->AddItem(new BMenuItem(item_path.Leaf(), msg), 0);
}
err = find_directory(B_COMMON_SOUNDS_DIRECTORY, &path);
if (err == B_OK)
err = dir.SetTo(path.Path());
while (err == B_OK) {
err = dir.GetNextEntry(&entry, true);
if (entry.InitCheck() != B_NO_ERROR)
break;
entry.GetPath(&item_path);
if (menu->FindItem(item_path.Leaf()))
continue;
BMessage* msg = new BMessage(M_ITEM_MESSAGE);
entry_ref ref;
::get_ref_for_path(item_path.Path(), &ref);
msg->AddRef("refs", &ref);
menu->AddItem(new BMenuItem(item_path.Leaf(), msg), 0);
}
}
/*! \brief Reads through the database and builds a complete set of installed types lists.
An initial set of cached messages are also created.
*/
status_t
InstalledTypes::_BuildInstalledTypesList()
{
status_t err = B_OK;
_Unset();
// Create empty "cached messages" so proper messages
// will be built up as we add new types
try {
fCachedMessage = new BMessage();
fCachedSupertypesMessage = new BMessage();
} catch (std::bad_alloc) {
err = B_NO_MEMORY;
}
BDirectory root;
if (!err)
err = root.SetTo(get_database_directory().c_str());
if (!err) {
root.Rewind();
while (true) {
BEntry entry;
err = root.GetNextEntry(&entry);
if (err) {
// If we've come to the end of list, it's not an error
if (err == B_ENTRY_NOT_FOUND)
err = B_OK;
break;
} else {
// Check that this entry is both a directory and a valid MIME string
char supertype[B_PATH_NAME_LENGTH];
if (entry.IsDirectory()
&& entry.GetName(supertype) == B_OK
&& BMimeType::IsValid(supertype))
{
// Make sure our string is all lowercase
BPrivate::Storage::to_lower(supertype);
// Add this supertype
std::map<std::string, Supertype>::iterator i;
if (_AddSupertype(supertype, i) != B_OK)
DBG(OUT("Mime::InstalledTypes::BuildInstalledTypesList() -- Error adding supertype '%s': 0x%lx\n",
supertype, err));
Supertype &supertypeRef = fSupertypes[supertype];
// Now iterate through this supertype directory and add
// all of its subtypes
BDirectory dir;
if (dir.SetTo(&entry) == B_OK) {
dir.Rewind();
while (true) {
BEntry subEntry;
err = dir.GetNextEntry(&subEntry);
if (err) {
// If we've come to the end of list, it's not an error
if (err == B_ENTRY_NOT_FOUND)
err = B_OK;
break;
} else {
// We need to preserve the case of the type name for
// queries, so we can't use the file name directly
BString type;
int32 subStart;
BNode node(&subEntry);
if (node.InitCheck() == B_OK
&& node.ReadAttrString(kTypeAttr, &type) >= B_OK
&& (subStart = type.FindFirst('/')) > 0) {
// Add the subtype
if (_AddSubtype(supertypeRef, type.String()
+ subStart + 1) != B_OK) {
DBG(OUT("Mime::InstalledTypes::BuildInstalledTypesList() -- Error adding subtype '%s/%s': 0x%lx\n",
supertype, type.String() + subStart + 1, err));
}
}
}
}
} else {
DBG(OUT("Mime::InstalledTypes::BuildInstalledTypesList(): "
"Failed opening supertype directory '%s'\n",
supertype));
}
}
}
}
} else {
DBG(OUT("Mime::InstalledTypes::BuildInstalledTypesList(): "
"Failed opening mime database directory '%s'\n",
get_database_directory().c_str()));
}
fHaveDoneFullBuild = true;
return err;
}
status_t
CDDBDaemon::_WriteCDData(dev_t device, QueryResponseData* diskData,
ReadResponseData* readResponse)
{
// Rename volume.
BVolume volume(device);
status_t result;
status_t error = B_OK;
BString name = diskData->artist << " - " << diskData->title;
name.ReplaceSet("/", " ");
if ((result = volume.SetName(name.String())) != B_OK) {
printf("Can't set volume name.\n");
return result;
}
// Rename tracks and add relevant Audio attributes.
BDirectory cddaRoot;
volume.GetRootDirectory(&cddaRoot);
BEntry entry;
int index = 0;
while (cddaRoot.GetNextEntry(&entry) == B_OK) {
TrackData* data = (TrackData*)((readResponse->tracks).ItemAt(index));
// Update name.
name = data->title;
name.ReplaceSet("/", " ");
if ((result = entry.Rename(name.String())) != B_OK) {
printf("Failed renaming entry at index %d to \"%s\".\n", index,
name.String());
error = result;
// User can benefit from continuing through all tracks.
// Report error later.
}
// Add relevant attributes. We consider an error here as non-fatal.
BNode node(&entry);
node.WriteAttr("Audio:Title", B_STRING_TYPE, 0, (data->title).String(),
(data->title).Length());
node.WriteAttr("Audio:Album", B_STRING_TYPE, 0,
(readResponse->title).String(),
(readResponse->title).Length());
node.WriteAttr("Audio:Genre", B_STRING_TYPE, 0,
(readResponse->genre).String(),
(readResponse->genre).Length());
node.WriteAttr("Audio:Year", B_INT32_TYPE, 0, &(readResponse->year),
sizeof(int32));
if (data->artist == "") {
node.WriteAttr("Audio:Artist", B_STRING_TYPE, 0,
(readResponse->artist).String(),
(readResponse->artist).Length());
} else {
node.WriteAttr("Audio:Artist", B_STRING_TYPE, 0,
(data->artist).String(), (data->artist).Length());
}
index++;
}
return error;
}
status_t
CDDBLookup::_WriteCDData(dev_t device, const QueryResponseData& diskData,
const ReadResponseData& readResponse)
{
// Rename volume.
BVolume volume(device);
status_t error = B_OK;
BString name = diskData.artist;
name += " - ";
name += diskData.title;
name.ReplaceSet("/", " ");
status_t result = volume.SetName(name.String());
if (result != B_OK) {
printf("Can't set volume name.\n");
return result;
}
// Rename tracks and add relevant Audio attributes.
BDirectory cddaRoot;
volume.GetRootDirectory(&cddaRoot);
BEntry entry;
int index = 0;
while (cddaRoot.GetNextEntry(&entry) == B_OK) {
TrackData* track = readResponse.tracks.ItemAt(index);
// Update name.
int trackNum = index + 1; // index=0 is actually Track 1
name.SetToFormat("%02d %s.wav", trackNum, track->title.String());
name.ReplaceSet("/", " ");
result = entry.Rename(name.String());
if (result != B_OK) {
fprintf(stderr, "%s: Failed renaming entry at index %d to "
"\"%s\".\n", kProgramName, index, name.String());
error = result;
// User can benefit from continuing through all tracks.
// Report error later.
}
// Add relevant attributes. We consider an error here as non-fatal.
BNode node(&entry);
node.WriteAttrString("Media:Title", &track->title);
node.WriteAttrString("Audio:Album", &readResponse.title);
if (readResponse.genre.Length() != 0)
node.WriteAttrString("Media:Genre", &readResponse.genre);
if (readResponse.year != 0) {
node.WriteAttr("Media:Year", B_INT32_TYPE, 0,
&readResponse.year, sizeof(int32));
}
if (track->artist == "")
node.WriteAttrString("Audio:Artist", &readResponse.artist);
else
node.WriteAttrString("Audio:Artist", &track->artist);
index++;
}
return error;
}
void
PairsView::_ReadRandomIcons()
{
// TODO: maybe read the icons only once at startup
// clean out any previous icons
for (int i = 0; i < fCardBitmaps.CountItems(); i++)
delete ((BBitmap*)fCardBitmaps.ItemAt(i));
fCardBitmaps.MakeEmpty();
BDirectory appsDirectory;
BDirectory prefsDirectory;
BPath path;
if (find_directory(B_BEOS_APPS_DIRECTORY, &path) == B_OK)
appsDirectory.SetTo(path.Path());
if (find_directory(B_BEOS_PREFERENCES_DIRECTORY, &path) == B_OK)
prefsDirectory.SetTo(path.Path());
// read vector icons from apps and prefs folder and put them
// into a BList as BBitmaps
BList bitmaps;
BEntry entry;
while (appsDirectory.GetNextEntry(&entry) == B_OK
|| prefsDirectory.GetNextEntry(&entry) == B_OK) {
BNode node(&entry);
BNodeInfo nodeInfo(&node);
if (nodeInfo.InitCheck() < B_OK)
continue;
uint8* data;
size_t size;
type_code type;
if (nodeInfo.GetIcon(&data, &size, &type) < B_OK)
continue;
if (type != B_VECTOR_ICON_TYPE) {
delete[] data;
continue;
}
BBitmap* bitmap = new BBitmap(
BRect(0, 0, kBitmapSize - 1, kBitmapSize - 1), 0, B_RGBA32);
if (BIconUtils::GetVectorIcon(data, size, bitmap) < B_OK) {
delete[] data;
delete bitmap;
continue;
}
delete[] data;
if (_HasBitmap(bitmaps, bitmap) || !bitmaps.AddItem(bitmap))
delete bitmap;
else if (bitmaps.CountItems() >= 128) {
// this is enough to choose from, stop eating memory...
break;
}
}
// pick random bitmaps from the ones we got in the list
srand((unsigned)time(0));
for (int i = 0; i < fNumOfCards / 2; i++) {
int32 index = rand() % bitmaps.CountItems();
BBitmap* bitmap = ((BBitmap*)bitmaps.RemoveItem(index));
if (bitmap == NULL) {
char buffer[512];
snprintf(buffer, sizeof(buffer), B_TRANSLATE("Pairs did not find "
"enough vector icons in the system; it needs at least %d."),
fNumOfCards / 2);
BString msgStr(buffer);
msgStr << "\n";
BAlert* alert = new BAlert("Fatal", msgStr.String(),
B_TRANSLATE("OK"), NULL, NULL, B_WIDTH_FROM_WIDEST,
B_STOP_ALERT);
alert->SetShortcut(0, B_ESCAPE);
alert->Go();
exit(1);
}
fCardBitmaps.AddItem(bitmap);
}
// delete the remaining bitmaps from the list
while (BBitmap* bitmap = (BBitmap*)bitmaps.RemoveItem(0L))
delete bitmap;
}
void PanelView::ReadDirectory(const char *itemname)
////////////////////////////////////////////////////////////////////////
{
BDirectory *dir;
CustomListItem *item;
stop_watching(this);
// SetMousePointer(CR_HOURGLASS);
MAINWINDOW->SetMousePointer(GenesisWindow::CR_HOURGLASS);
// If we are not in the root directory, simply start the dir with a '..' entry...
if (strcmp(m_Path.String(),"/")!=0)
{
item = new CustomListItem("..", m_Path.String(), FT_PARENT, 0);
m_CustomListView->AddItem(item);
if (m_Setting_ShowIcons)
{
item->AddIcon(m_ParentIcon);
item->SetHeight(15.0f);
}
}
dir = new BDirectory(m_Path.String());
if (dir)
{
BEntry entry;
if (dir->GetEntry(&entry)==B_OK)
{
while (dir->GetNextEntry(&entry)==B_OK)
{
AddDirectoryEntry(&entry);
}
}
delete dir;
}
m_CustomListView->DoSortList();
// Always select the first item in the list or the child where we came from...
if (itemname)
{
CustomListItem *item;
int n = m_CustomListView->CountItems();
for (int i=0;i<n;i++)
{
item = (CustomListItem *)m_CustomListView->ItemAt(i);
if (strcasecmp(itemname,item->m_FileName.String())==0)
{
m_CustomListView->Select(i,false);
m_CustomListView->ScrollToSelection();
break;
}
}
// When the given file disappeared, we have to select the first entry...
if (m_CustomListView->CountSelectedEntries(CT_WITHPARENT)==0)
m_CustomListView->Select(0,false);
}
else
m_CustomListView->Select(0,false);
m_CurrentTotalSize = m_CustomListView->GetCurrentTotalSize();
// Probably we have to update the path of the command line...
Parent()->Looper()->PostMessage(new BMessage(MSG_UPDATECOMMANDLINE_PATH)); // To update command line...
EnableMonitoring();
// SetMousePointer(CR_DEFAULT);
MAINWINDOW->SetMousePointer(GenesisWindow::CR_DEFAULT);
}
/*------------------------------------------------------------------------------*\
LoadAddons()
- loads all available filter-addons
\*------------------------------------------------------------------------------*/
void BmFilterList::LoadAddons() {
BDirectory addonDir;
BPath path;
BEntry entry;
status_t err;
BM_LOG2( BM_LogFilter, BmString("Start of LoadAddons() for FilterList"));
// determine the path to the user-config-directory:
if (find_directory( B_USER_ADDONS_DIRECTORY, &path) != B_OK)
BM_THROW_RUNTIME( "Sorry, could not determine user's addon-dir !?!");
BmString addonPath = BmString(BeamRoster->AppPath()) + "/add-ons/Filters";
SetupFolder( addonPath.String(), &addonDir);
// ...and scan through all its entries for filter-add-ons:
while ( addonDir.GetNextEntry( &entry, true) == B_OK) {
if (entry.IsFile()) {
char nameBuf[B_FILE_NAME_LENGTH];
entry.GetName( nameBuf);
// try to load addon:
const char** filterKinds;
const char** defaultFilterName;
BmFilterAddonDescr ao;
ao.name = nameBuf;
ao.name.CapitalizeEachWord();
entry.GetPath( &path);
if ((ao.image = load_add_on( path.Path())) < 0) {
BM_SHOWERR( BmString("Unable to load filter-addon\n\t")
<<ao.name<<"\n\nError:\n\t"<<strerror( ao.image));
continue;
}
if ((err = get_image_symbol(
ao.image, "InstantiateFilter", B_SYMBOL_TYPE_ANY,
(void**)&ao.instantiateFilterFunc
)) != B_OK) {
BM_SHOWERR( BmString("Unable to load filter-addon\n\t")
<<ao.name<<"\n\nMissing symbol 'InstantiateFilter'");
continue;
}
if ((err = get_image_symbol(
ao.image, "InstantiateFilterPrefs", B_SYMBOL_TYPE_ANY,
(void**)&ao.instantiateFilterPrefsFunc
)) != B_OK) {
BM_SHOWERR( BmString("Unable to load filter-addon\n\t")
<<ao.name
<<"\n\nMissing symbol 'InstantiateFilterPrefs'");
continue;
}
if ((err = get_image_symbol(
ao.image, "FilterKinds", B_SYMBOL_TYPE_ANY,
(void**)&filterKinds
)) != B_OK) {
BM_SHOWERR( BmString("Unable to load filter-addon\n\t")
<<ao.name<<"\n\nMissing symbol 'FilterKinds'");
continue;
}
if ((err = get_image_symbol(
ao.image, "DefaultFilterName", B_SYMBOL_TYPE_ANY,
(void**)&defaultFilterName
)) == B_OK)
ao.defaultFilterName = *defaultFilterName;
else
ao.defaultFilterName = "new filter";
#if 0
// we try to set TheBubbleHelper and TheLogHandler globals inside
// the addon to our current values:
BubbleHelper** bhPtr;
if (get_image_symbol( ao.image, "TheBubbleHelper", B_SYMBOL_TYPE_ANY,
(void**)&bhPtr) == B_OK) {
*bhPtr = TheBubbleHelper;
}
BmLogHandler** lhPtr;
if (get_image_symbol( ao.image, "TheLogHandler", B_SYMBOL_TYPE_ANY,
(void**)&lhPtr) == B_OK) {
*lhPtr = TheLogHandler;
}
#endif
// now we add the addon to our map (one entry per filter-kind):
while( *filterKinds) {
BmString kind(*filterKinds);
FilterAddonMap[*filterKinds++] = ao;
if (kind.ICompare("Spam") == 0) {
// a spam-filter requires two internal filters (learnAsSpam
// and learnAsTofu) which don't appear as part of filter-list:
mLearnAsSpamFilter
= new BmFilter( LEARN_AS_SPAM_NAME, "Spam", NULL);
BMessage learnAsSpamJob;
learnAsSpamJob.AddString("jobSpecifier", "LearnAsSpam");
mLearnAsSpamFilter->JobSpecifier(learnAsSpamJob);
mLearnAsTofuFilter
= new BmFilter( LEARN_AS_TOFU_NAME, "Spam", NULL);
BMessage learnAsTofuJob;
learnAsTofuJob.AddString("jobSpecifier", "LearnAsTofu");
mLearnAsTofuFilter->JobSpecifier(learnAsTofuJob);
}
}
BM_LOG( BM_LogFilter, BmString("Successfully loaded addon ")
<< ao.name);
}
}
BM_LOG2( BM_LogFilter, BmString("End of LoadAddons() for FilterList"));
}
void BeHappy::SearchAddOns()
{
// on vide les listes
{
BPath *p;
while ((p=(BPath*)addOnsPaths.RemoveItem((int32)0))!=NULL)
delete p;
BString *s;
while ((s=(BString*)addOnsNames.RemoveItem((int32)0))!=NULL)
delete s;
}
// d'abord on cherche le dossier
app_info myInfo;
be_app->GetAppInfo(&myInfo);
BEntry appEntry(&(myInfo.ref));
BDirectory addOnsDir;
appEntry.GetParent(&addOnsDir);
// parcours de tous les fichiers du dossier
if (addOnsDir.SetTo(&addOnsDir,"Add-ons")==B_OK)
{
BEntry addOn;
while (addOnsDir.GetNextEntry(&addOn,true) == B_OK)
{
BPath *addOnPath = new BPath;
addOn.GetPath(addOnPath);
// extraction du type MIME
{
BNode myNode(&addOn);
BNodeInfo myNodeInfo(&myNode);
char mimeType[256];
myNodeInfo.GetType(mimeType);
if (BString("application/x-vnd.Be-elfexecutable") != mimeType)
continue;
}
// on est sûrs que c'est un Add-on
BString *projName = new BString;
if (CheckAddOn(addOnPath->Path(),true,projName))
{
addOnsPaths.AddItem(addOnPath);
addOnsNames.AddItem(projName);
}
else
{
delete addOnPath;
delete projName;
}
// si c'est la première fois que SearchAddOns est appelé, on doit activer le node monitor
if (!addOnsSearched)
{
addOnsSearched = true;
node_ref myRef;
addOnsDir.GetNodeRef(&myRef);
watch_node(&myRef,B_WATCH_DIRECTORY,be_app_messenger);
}
}
}
else
{
BAlert *myAlert = new BAlert("BeHappy",T("Can't find Add-ons folder"),
"Quit",NULL,NULL,B_WIDTH_AS_USUAL,B_STOP_ALERT);
myAlert->Go();
PostMessage(B_QUIT_REQUESTED);
}
}
void
BL_CDEngine::SearchForCdPlayer(const char* aDirName)
{
BDirectory lDirectory;
if (lDirectory.SetTo(aDirName) != B_OK) {
return;
}
lDirectory.Rewind();
BEntry lEntry;
while(lDirectory.GetNextEntry(&lEntry) >= 0) {
BPath lPath;
if(lEntry.GetPath(&lPath) != B_OK) {
continue;
}
const char* lpName = lPath.Path();
entry_ref lRef;
if(lEntry.GetRef(&lRef) != B_OK) {
continue;
}
if(lEntry.IsDirectory()) {
// Ignore floppy. It's worth to explicitly check for the floppy
// device and ignore it, because opening it to get its geometry
// would just make a lot of noise, and not any sense.
if(strcmp(lRef.name, "floppy") == 0) {
continue;
}
SearchForCdPlayer(lpName);
} else {
// Ignore partitions.
if(strcmp(lRef.name, "raw") != 0) {
continue;
}
// Try to open the device.
int lDevice = open(lpName, O_RDONLY);
if(lDevice < 0) {
continue;
}
// Figure out is the device is a CD-ROM drive.
device_geometry lGeometry;
if(ioctl(lDevice,
B_GET_GEOMETRY,
&lGeometry,
sizeof(lGeometry)) < 0) {
close(lDevice);
continue;
}
// Hooray, we've found a CD-ROM drive.
if(lGeometry.device_type == B_CD) {
// Store the device's name in the list and close the device.
mpDevices->AddItem(strdup(lpName));
close(lDevice);
}
}
}
}
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();
}
}
