bool
GeneralView::_CanFindServer(entry_ref* ref)
{
// Try searching with be_roster
if (be_roster->FindApp(kNotificationServerSignature, ref) == B_OK)
return true;
// Try with a query and take the first result
BVolumeRoster vroster;
BVolume volume;
char volName[B_FILE_NAME_LENGTH];
vroster.Rewind();
while (vroster.GetNextVolume(&volume) == B_OK) {
if ((volume.InitCheck() != B_OK) || !volume.KnowsQuery())
continue;
volume.GetName(volName);
BQuery *query = new BQuery();
query->SetPredicate("(BEOS:APP_SIG==\""kNotificationServerSignature"\")");
query->SetVolume(&volume);
query->Fetch();
if (query->GetNextRef(ref) == B_OK)
return true;
}
return false;
}
void
THeaderView::InitEmailCompletion()
{
// get boot volume
BVolume volume;
BVolumeRoster().GetBootVolume(&volume);
BQuery query;
query.SetVolume(&volume);
query.SetPredicate("META:email=**");
// Due to R5 BFS bugs, you need two stars, META:email=** for the query.
// META:email="*" will just return one entry and stop, same with
// META:email=* and a few other variations. Grumble.
query.Fetch();
entry_ref ref;
while (query.GetNextRef (&ref) == B_OK) {
BNode file;
if (file.SetTo(&ref) == B_OK) {
// Add the e-mail address as an auto-complete string.
BString email;
if (file.ReadAttrString("META:email", &email) >= B_OK)
fEmailList.AddChoice(email.String());
// Also add the quoted full name as an auto-complete string. Can't
// do unquoted since auto-complete isn't that smart, so the user
// will have to type a quote mark if he wants to select someone by
// name.
BString fullName;
if (file.ReadAttrString("META:name", &fullName) >= B_OK) {
if (email.FindFirst('<') < 0) {
email.ReplaceAll('>', '_');
email.Prepend("<");
email.Append(">");
}
fullName.ReplaceAll('\"', '_');
fullName.Prepend("\"");
fullName << "\" " << email;
fEmailList.AddChoice(fullName.String());
}
// support for 3rd-party People apps. Looks like a job for
// multiple keyword (so you can have several e-mail addresses in
// one attribute, perhaps comma separated) indices! Which aren't
// yet in BFS.
for (int16 i = 2; i < 6; i++) {
char attr[16];
sprintf(attr, "META:email%d", i);
if (file.ReadAttrString(attr, &email) >= B_OK)
fEmailList.AddChoice(email.String());
}
}
}
}
void
QueryView::GetInitialEntries()
{
fEntryCount = 0;
entry_ref ref;
// slaad
BNode n(&ref);
vollist vols;
ExtractQueryVolumes(&n, &vols);
vollist::iterator vIt;
for (vIt = vols.begin(); vIt != vols.end(); vIt++) {
BQuery *query = new BQuery();
query->SetVolume(&(*vIt));
query->SetPredicate(fPredicate.String());
query->SetTarget(this);
query->Fetch();
while( query->GetNextRef(&ref) == B_OK )
{
// eiman
BEntry entry(&ref);
node_ref node;
entry.GetNodeRef(&node);
BMessage msg;
msg.AddInt32("opcode",B_ENTRY_CREATED);
msg.AddString("name",ref.name);
msg.AddInt64("directory",ref.directory);
msg.AddInt32("device",ref.device);
msg.AddInt64("node",node.node);
if ( !ShouldIgnore(&msg) )
{
fEntryCount++;
}
}
fQueries.push_back(query);
};
#ifdef DEBUG
BeDC dc("QueryWatcher");
BString str;
str<<Name()<<" initial count: "<<fEntryCount;
dc.SendMessage(str.String());
#endif
UpdateDisplay();
}
void
POP3Protocol::CheckForDeletedMessages()
{
{
// Delete things from the manifest no longer on the server
BStringList list;
NotHere(fUniqueIDs, fManifest, &list);
fManifest.Remove(list);
}
if (!fSettings.FindBool("delete_remote_when_local")
|| fManifest.CountStrings() == 0)
return;
BStringList toDelete;
BStringList queryContents;
BVolumeRoster volumes;
BVolume volume;
while (volumes.GetNextVolume(&volume) == B_OK) {
BQuery fido;
entry_ref entry;
fido.SetVolume(&volume);
fido.PushAttr(B_MAIL_ATTR_ACCOUNT_ID);
fido.PushInt32(fAccountSettings.AccountID());
fido.PushOp(B_EQ);
fido.Fetch();
BString uid;
while (fido.GetNextRef(&entry) == B_OK) {
BNode(&entry).ReadAttrString("MAIL:unique_id", &uid);
queryContents.Add(uid);
}
}
NotHere(queryContents, fManifest, &toDelete);
for (int32 i = 0; i < toDelete.CountStrings(); i++) {
printf("delete mail on server uid %s\n", toDelete.StringAt(i).String());
Delete(fUniqueIDs.IndexOf(toDelete.StringAt(i)));
}
// Don't remove ids from fUniqueIDs, the indices have to stay the same when
// retrieving new messages.
fManifest.Remove(toDelete);
// TODO: at some point the purged manifest should be written to disk
// otherwise it will grow forever
}
status_t
CDDBQuery::_OpenContentFile(const int32 &discID)
{
// Makes sure that the lookup has a valid file to work with for the CD
// content. Returns true if there is an existing file, false if a lookup is
// required.
BFile file;
BString predicate;
predicate << "CD:key == " << discID;
entry_ref ref;
BVolumeRoster roster;
BVolume volume;
roster.Rewind();
while (roster.GetNextVolume(&volume) == B_OK) {
if (volume.IsReadOnly() || !volume.IsPersistent() || !volume.KnowsAttr()
|| !volume.KnowsQuery())
continue;
// make sure the volume we are looking at is indexed right
fs_create_index(volume.Device(), "CD:key", B_INT32_TYPE, 0);
BQuery query;
query.SetVolume(&volume);
query.SetPredicate(predicate.String());
if (query.Fetch() != B_OK)
continue;
if (query.GetNextRef(&ref) == B_OK)
break;
}
status_t status = fCDData.Load(ref);
if (status == B_NO_INIT) {
// We receive this error when the Load() function couldn't load the
// track times This just means that we get it from the SCSI data given
// to us in SetToCD
vector<CDAudioTime> times;
GetTrackTimes(&fSCSIData,times);
for (int32 i = 0; i < fCDData.CountTracks(); i++) {
CDAudioTime *item = fCDData.TrackTimeAt(i);
*item = times[i + 1] - times[i];
}
status = B_OK;
}
return status;
}
void
POP3Protocol::CheckForDeletedMessages()
{
{
//---Delete things from the manifest no longer on the server
BStringList temp;
fManifest.NotThere(fUniqueIDs, &temp);
fManifest -= temp;
}
if (!fSettings.FindBool("delete_remote_when_local")
|| fManifest.CountItems() == 0)
return;
BStringList to_delete;
BStringList query_contents;
BVolumeRoster volumes;
BVolume volume;
while (volumes.GetNextVolume(&volume) == B_OK) {
BQuery fido;
entry_ref entry;
fido.SetVolume(&volume);
fido.PushAttr(B_MAIL_ATTR_ACCOUNT_ID);
fido.PushInt32(fAccountSettings.AccountID());
fido.PushOp(B_EQ);
fido.Fetch();
BString uid;
while (fido.GetNextRef(&entry) == B_OK) {
BNode(&entry).ReadAttrString("MAIL:unique_id", &uid);
query_contents.AddItem(uid.String());
}
}
query_contents.NotHere(fManifest, &to_delete);
for (int32 i = 0; i < to_delete.CountItems(); i++) {
printf("delete mail on server uid %s\n", to_delete[i]);
Delete(fUniqueIDs.IndexOf(to_delete[i]));
}
//*(unique_ids) -= to_delete; --- This line causes bad things to
// happen (POP3 client uses the wrong indices to retrieve
// messages). Without it, bad things don't happen.
fManifest -= to_delete;
}
status_t
TeamWindow::_RetrieveMatchingSourceEntries(const BString& path,
BStringList* _entries)
{
BPath filePath(path);
status_t error = filePath.InitCheck();
if (error != B_OK)
return error;
_entries->MakeEmpty();
BQuery query;
BString predicate;
query.PushAttr("name");
query.PushString(filePath.Leaf());
query.PushOp(B_EQ);
error = query.GetPredicate(&predicate);
if (error != B_OK)
return error;
BVolumeRoster roster;
BVolume volume;
while (roster.GetNextVolume(&volume) == B_OK) {
if (!volume.KnowsQuery())
continue;
if (query.SetVolume(&volume) != B_OK)
continue;
error = query.SetPredicate(predicate.String());
if (error != B_OK)
continue;
if (query.Fetch() != B_OK)
continue;
entry_ref ref;
while (query.GetNextRef(&ref) == B_OK) {
filePath.SetTo(&ref);
_entries->Add(filePath.Path());
}
query.Clear();
}
return B_OK;
}
int
main(int argc, char* argv[])
{
team_info teamInfo;
int32 cookie = 0;
while (get_next_team_info(&cookie, &teamInfo) == B_OK) {
if (!strncmp(teamInfo.args, "/boot/beos/", 11)
|| !strncmp(teamInfo.args, "/boot/system/", 13)) {
// this is a system component and not worth to investigate
continue;
}
thread_info threadInfo;
int32 threadCookie = 0;
while (get_next_thread_info(teamInfo.team, &threadCookie, &threadInfo)
== B_OK) {
// search for the roster thread
if (!strcmp(threadInfo.name, "_roster_thread_")) {
port_id port = find_port("haiku-test:roster");
port_info portInfo;
if (get_port_info(port, &portInfo) == B_OK
&& portInfo.team == teamInfo.team) {
puts("The Haiku Registrar is already running.");
return 0;
}
}
}
}
// the Haiku registrar doesn't seem to run yet, change this
BPath currentPath(".");
BQuery query;
query.SetPredicate("name==test_registrar");
// search on current volume only
dev_t device = dev_for_path(".");
BVolume volume(device);
query.SetVolume(&volume);
query.Fetch();
entry_ref ref;
while (query.GetNextRef(&ref) == B_OK) {
BPath path(&ref);
if (path.InitCheck() != B_OK)
continue;
const char* registrarPath = path.Path();
const char* generatedPath = strstr(registrarPath, "generated");
if (generatedPath == NULL)
continue;
if (!strncmp(currentPath.Path(), registrarPath, generatedPath - registrarPath)) {
// gotcha!
if (launch_registrar(registrarPath) == B_OK)
return 0;
}
}
// As a fallback (maybe the volume does not support queries for example)
// try to find the test_registrar in the current folder...
BString registrarPath(argv[0]);
registrarPath.RemoveLast(__progname);
registrarPath.Append("test_registrar");
if (launch_registrar(registrarPath.String()) == B_OK)
return 0;
fprintf(stderr, "%s: Could not find the Haiku Registrar.\n"
" (This tool only works when used in the Haiku tree, but maybe\n"
" the registrar just needs to be built.)\n",
__progname);
return -1;
}
void
ApplicationTypesWindow::_RemoveUninstalled()
{
// Note: this runs in the looper's thread, which isn't that nice
int32 removed = 0;
volatile bool quit = false;
BWindow* progressWindow =
new ProgressWindow(
B_TRANSLATE("Removing uninstalled application types"),
fTypeListView->FullListCountItems(), &quit);
progressWindow->AddToSubset(this);
progressWindow->Show();
for (int32 i = fTypeListView->FullListCountItems(); i-- > 0 && !quit;) {
MimeTypeItem* item = dynamic_cast<MimeTypeItem*>
(fTypeListView->FullListItemAt(i));
progressWindow->PostMessage(B_UPDATE_STATUS_BAR);
if (item == NULL)
continue;
// search for application on all volumes
bool found = false;
BVolumeRoster volumeRoster;
BVolume volume;
while (volumeRoster.GetNextVolume(&volume) == B_OK) {
if (!volume.KnowsQuery())
continue;
BQuery query;
query.PushAttr("BEOS:APP_SIG");
query.PushString(item->Type());
query.PushOp(B_EQ);
query.SetVolume(&volume);
query.Fetch();
entry_ref ref;
if (query.GetNextRef(&ref) == B_OK) {
found = true;
break;
}
}
if (!found) {
BMimeType mimeType(item->Type());
mimeType.Delete();
removed++;
// We're blocking the message loop that received the MIME changes,
// so we dequeue all waiting messages from time to time
if (removed % 10 == 0)
UpdateIfNeeded();
}
}
progressWindow->PostMessage(B_QUIT_REQUESTED);
static BMessageFormat format(B_TRANSLATE("{0, plural, "
"one{# Application type could be removed} "
"other{# Application types could be removed}}"));
BString message;
format.Format(message, removed);
error_alert(message, B_OK, B_INFO_ALERT);
}
void
THeaderView::InitGroupCompletion()
{
// get boot volume
BVolume volume;
BVolumeRoster().GetBootVolume(&volume);
// Build a list of all unique groups and the addresses they expand to.
BQuery query;
query.SetVolume(&volume);
query.SetPredicate("META:group=**");
query.Fetch();
map<BString *, BString *, CompareBStrings> groupMap;
entry_ref ref;
BNode file;
while (query.GetNextRef(&ref) == B_OK) {
if (file.SetTo(&ref) != B_OK)
continue;
BString groups;
if (file.ReadAttrString("META:group", &groups) < B_OK || groups.Length() == 0)
continue;
BString address;
file.ReadAttrString("META:email", &address);
// avoid adding an empty address
if (address.Length() == 0)
continue;
char *group = groups.LockBuffer(groups.Length());
char *next = strchr(group, ',');
for (;;) {
if (next)
*next = 0;
while (*group && *group == ' ')
group++;
BString *groupString = new BString(group);
BString *addressListString = NULL;
// nobody is in this group yet, start it off
if (groupMap[groupString] == NULL) {
addressListString = new BString(*groupString);
addressListString->Append(" ");
groupMap[groupString] = addressListString;
} else {
addressListString = groupMap[groupString];
addressListString->Append(", ");
delete groupString;
}
// Append the user's address to the end of the string with the
// comma separated list of addresses. If not present, add the
// < and > brackets around the address.
if (address.FindFirst ('<') < 0) {
address.ReplaceAll ('>', '_');
address.Prepend ("<");
address.Append(">");
}
addressListString->Append(address);
if (!next)
break;
group = next + 1;
next = strchr(group, ',');
}
}
map<BString *, BString *, CompareBStrings>::iterator iter;
for (iter = groupMap.begin(); iter != groupMap.end();) {
BString *group = iter->first;
BString *addr = iter->second;
fEmailList.AddChoice(addr->String());
++iter;
groupMap.erase(group);
delete group;
delete addr;
}
}
/***********************************************************
* InitGUI
***********************************************************/
void
HAddressView::InitGUI()
{
float divider = StringWidth(_("Subject:")) + 20;
divider = max_c(divider , StringWidth(_("From:"))+20);
divider = max_c(divider , StringWidth(_("To:"))+20);
divider = max_c(divider , StringWidth(_("Bcc:"))+20);
BRect rect = Bounds();
rect.top += 5;
rect.left += 20 + divider;
rect.right = Bounds().right - 5;
rect.bottom = rect.top + 25;
BTextControl *ctrl;
ResourceUtils rutils;
const char* name[] = {"to","subject","from","cc","bcc"};
for(int32 i = 0;i < 5;i++)
{
ctrl = new BTextControl(BRect(rect.left,rect.top
,(i == 1)?rect.right+divider:rect.right
,rect.bottom)
,name[i],"","",NULL
,B_FOLLOW_LEFT_RIGHT|B_FOLLOW_TOP,B_WILL_DRAW|B_NAVIGABLE);
if(i == 1)
{
ctrl->SetLabel(_("Subject:"));
ctrl->SetDivider(divider);
ctrl->MoveBy(-divider,0);
}else{
ctrl->SetDivider(0);
}
BMessage *msg = new BMessage(M_MODIFIED);
msg->AddPointer("pointer",ctrl);
ctrl->SetModificationMessage(msg);
ctrl->SetEnabled(!fReadOnly);
AddChild(ctrl);
rect.OffsetBy(0,25);
switch(i)
{
case 0:
fTo = ctrl;
break;
case 1:
fSubject = ctrl;
break;
case 2:
fFrom = ctrl;
fFrom->SetEnabled(false);
fFrom->SetFlags(fFrom->Flags() & ~B_NAVIGABLE);
break;
case 3:
fCc = ctrl;
break;
case 4:
fBcc = ctrl;
break;
}
}
//
BRect menuRect= Bounds();
menuRect.top += 5;
menuRect.left += 22;
menuRect.bottom = menuRect.top + 25;
menuRect.right = menuRect.left + 16;
BMenu *toMenu = new BMenu(_("To:"));
BMenu *ccMenu = new BMenu(_("Cc:"));
BMenu *bccMenu = new BMenu(_("Bcc:"));
BQuery query;
BVolume volume;
BVolumeRoster().GetBootVolume(&volume);
query.SetVolume(&volume);
query.SetPredicate("((META:email=*)&&(BEOS:TYPE=application/x-person))");
if(!fReadOnly && query.Fetch() == B_OK)
{
BString addr[4],name,group,nick;
entry_ref ref;
BList peopleList;
while(query.GetNextRef(&ref) == B_OK)
{
BNode node(&ref);
if(node.InitCheck() != B_OK)
continue;
ReadNodeAttrString(&node,"META:name",&name);
ReadNodeAttrString(&node,"META:email",&addr[0]);
ReadNodeAttrString(&node,"META:email2",&addr[1]);
ReadNodeAttrString(&node,"META:email3",&addr[2]);
ReadNodeAttrString(&node,"META:email4",&addr[3]);
ReadNodeAttrString(&node,"META:group",&group);
ReadNodeAttrString(&node,"META:nickname",&nick);
for(int32 i = 0;i < 4;i++)
{
if(addr[i].Length() > 0)
{
if(nick.Length() > 0)
{
nick += " <";
nick += addr[i];
nick += ">";
fAddrList.AddItem(strdup(nick.String()));
}
fAddrList.AddItem(strdup(addr[i].String()));
BString title = name;
title << " <" << addr[i] << ">";
AddPersonToList(peopleList,title.String(),group.String());
}
}
}
// Sort people data
peopleList.SortItems(HAddressView::SortPeople);
// Build menus
BTextControl *control[3] = {fTo,fCc,fBcc};
BMenu *menus[3] = {toMenu,ccMenu,bccMenu};
int32 count = peopleList.CountItems();
PersonData *data;
bool needSeparator = false;
bool hasSeparator = false;
for(int32 k = 0;k < 3;k++)
{
for(int32 i = 0;i < count;i++)
{
BMessage *msg = new BMessage(M_ADDR_MSG);
msg->AddPointer("pointer",control[k]);
data = (PersonData*)peopleList.ItemAt(i);
msg->AddString("email",data->email);
if(needSeparator && !hasSeparator && strlen(data->group) == 0)
{
menus[k]->AddSeparatorItem();
hasSeparator = true;
}else
needSeparator = true;
AddPerson(menus[k],data->email,data->group,msg,0,0);
}
hasSeparator = false;
needSeparator = false;
}
// free all data
while(count > 0)
{
data = (PersonData*)peopleList.RemoveItem(--count);
free(data->email);
free(data->group);
delete data;
}
}
BMenuField *field = new BMenuField(menuRect,"ToMenu","",toMenu,
B_FOLLOW_TOP|B_FOLLOW_LEFT,B_WILL_DRAW);
field->SetDivider(0);
field->SetEnabled(!fReadOnly);
AddChild(field);
rect = menuRect;
rect.OffsetBy(0,28);
rect.left = Bounds().left + 5;
rect.right = rect.left + 16;
rect.top += 26;
rect.bottom = rect.top + 16;
ArrowButton *arrow = new ArrowButton(rect,"addr_arrow"
,new BMessage(M_EXPAND_ADDRESS));
AddChild(arrow);
//==================== From menu
BMenu *fromMenu = new BMenu(_("From:"));
BPath path;
::find_directory(B_USER_SETTINGS_DIRECTORY,&path);
path.Append(APP_NAME);
path.Append("Accounts");
BDirectory dir(path.Path());
BEntry entry;
status_t err = B_OK;
int32 account_count = 0;
while(err == B_OK)
{
if((err = dir.GetNextEntry(&entry)) == B_OK && !entry.IsDirectory())
{
char name[B_FILE_NAME_LENGTH+1];
entry.GetName(name);
BMessage *msg = new BMessage(M_ACCOUNT_CHANGE);
msg->AddString("name",name);
BMenuItem *item = new BMenuItem(name,msg);
fromMenu->AddItem(item);
item->SetTarget(this,Window());
account_count++;
}
}
if(account_count != 0)
{
int32 smtp_account;
((HApp*)be_app)->Prefs()->GetData("smtp_account",&smtp_account);
BMenuItem *item(NULL);
if(account_count > smtp_account)
item = fromMenu->ItemAt(smtp_account);
if(!item)
item = fromMenu->ItemAt(0);
if(item)
{
ChangeAccount(item->Label());
item->SetMarked(true);
}
}else{
(new BAlert("",_("Could not find mail accounts"),_("OK"),NULL,NULL,B_WIDTH_AS_USUAL,B_INFO_ALERT))->Go();
Window()->PostMessage(B_QUIT_REQUESTED);
}
fromMenu->SetRadioMode(true);
menuRect.OffsetBy(0,25*2);
field = new BMenuField(menuRect,"FromMenu","",fromMenu,
B_FOLLOW_TOP|B_FOLLOW_LEFT,B_WILL_DRAW);
field->SetDivider(0);
AddChild(field);
//=================== CC menu
menuRect.OffsetBy(0,25);
field = new BMenuField(menuRect,"CcMenu","",ccMenu,
B_FOLLOW_TOP|B_FOLLOW_LEFT,B_WILL_DRAW);
field->SetDivider(0);
field->SetEnabled(!fReadOnly);
AddChild(field);
//=================== BCC menu
menuRect.OffsetBy(0,25);
field = new BMenuField(menuRect,"BccMenu","",bccMenu,
B_FOLLOW_TOP|B_FOLLOW_LEFT,B_WILL_DRAW);
field->SetDivider(0);
field->SetEnabled(!fReadOnly);
AddChild(field);
}
/*! \brief Search the filesystem for additional categories.
* \details Starts a whole-filesystem query for the Event files with
* categories which may be copied to the system and not appear
* in the Categories' database.
*/
static
void SearchFilesystemForAdditionalCategories( void )
{
BQuery* categoryQuery = NULL; //!< The way to fill the previously-uncatched categories.
Category* pCategory = NULL; //!< Used to traverse the list of categories
status_t status; //!< Result of the last action.
ssize_t bytesTransferred; //!< Used in I/O operations
entry_ref fileToReadAttributesFrom; //!< This is the reference to file with unknown category.
BFile* file = NULL; //!< This file will be initialized with fileToGetTheAttributesFrom.
attr_info attribute_info; //!< Information about the attribute.
rgb_color catColor; //!< Category color
char buffer[ 255 ]; //!< I'll use this buffer to read Categories from files
categoryQuery = new BQuery();
if ( !categoryQuery ) {
/* Nothing to do */
return;
}
// For initialization of the BQuery, we need to find the Volume with user's data.
BVolumeRoster volumeRoster;
BVolume bootVolume;
volumeRoster.GetBootVolume( &bootVolume );
// Setting the query to look in the boot volume
categoryQuery->SetVolume( &bootVolume );
/* First item of the predicate is the type of the file.
*/
categoryQuery->PushAttr( "BEOS:TYPE" );
categoryQuery->PushString( kEventFileMIMEType );
categoryQuery->PushOp( B_EQ );
/* Check the category attribute type's name.
*/
int i = 0;
BString categoryAttributeInternalName;
while ( AttributesArray[ i ].internalName != 0 )
{
if ( strcmp( AttributesArray[ i ].humanReadableName, "Category" ) == 0 )
{
// Found the correct attribute! Now, let's take its internal name...
break;
}
++i;
}
/* Build the query predicate.
* This is meaningful only if global list of categories contains any items,
* and if we succeeded to find the attribute with human-readable name "Category".
*/
if ( ! global_ListOfCategories.IsEmpty() &&
( AttributesArray[ i ].internalName != NULL ) )
{
for ( int i = 0, limit = global_ListOfCategories.CountItems();
i < limit;
++i )
{
pCategory = ( Category* )global_ListOfCategories.ItemAt( i );
if ( !pCategory )
continue;
categoryQuery->PushAttr( AttributesArray[ i ].internalName );
categoryQuery->PushString( pCategory->categoryName.String(), true );
categoryQuery->PushOp( B_NE );
categoryQuery->PushOp( B_AND );
} // <-- end of "for ( all currently known categories )"
} // <-- end of "if ( there are any items in the list of known categories )"
/* The predicate that we currently have looks like this:
* ((( type is Eventual ) && ( category != "Cat1" )) && ( category != "Cat2" )) && ...
* The order does not matter, since we're using "AND".
*
* Well, let's fire and see what comes...
*/
categoryQuery->Fetch();
while ( ( status = categoryQuery->GetNextRef( &fileToReadAttributesFrom ) ) == B_OK )
{
// Successfully retrieved next entry
file = new BFile( &fileToReadAttributesFrom, B_READ_ONLY );
if ( !file || file->InitCheck() != B_OK )
continue;
status = file->GetAttrInfo( AttributesArray[ i ].internalName,
&attribute_info );
if ( status != B_OK )
continue;
status = file->ReadAttr( AttributesArray[ i ].internalName,
attribute_info.type,
0,
buffer,
( attribute_info.size > 255 ) ? 255 : attribute_info.size );
if ( status != B_OK )
continue;
// Succeeded to read the category name, it's in "buffer". Create the color...
catColor = CreateRandomColor();
// ...and add the category to the list of categories.
AddCategoryToGlobalList( BString( buffer ), catColor );
// We don't need the file anymore.
delete file;
}
delete categoryQuery;
} // <-- end of function SearchFilesystemForAdditionalCategories
void QueryLooper::MessageReceived(BMessage *msg) {
switch (msg->what) {
case B_QUERY_UPDATE: {
int32 opcode = 0;
entry_ref affected;
if (msg->FindInt32("opcode", &opcode) != B_OK) return;
switch (opcode) {
case B_ENTRY_CREATED: {
result r;
const char *name;
msg->FindInt32("device", &r.ref.device);
msg->FindInt64("directory", &r.ref.directory);
msg->FindString("name", &name);
r.ref.set_name(name);
msg->FindInt32("device", &r.nref.device);
msg->FindInt64("node", &r.nref.node);
fResults[r.ref] = r;
affected = r.ref;
} break;
case B_ENTRY_REMOVED: {
node_ref nref;
result_t::iterator rIt;
msg->FindInt32("device", &nref.device);
msg->FindInt64("node", &nref.node);
for (rIt = fResults.begin(); rIt != fResults.end(); rIt++) {
result r = rIt->second;
if (nref == r.nref) {
fResults.erase(r.ref);
affected = r.ref;
break;
};
};
} break;
};
if ((fNotify.IsValid()) && (fMsg != NULL)) {
BMessage notify(*fMsg);
notify.AddString("qlName", fName);
notify.AddRef("affected_ref", &affected);
if (opcode == B_ENTRY_CREATED) {
notify.AddInt32("query_what", Notifications::EntryAdded);
} else {
notify.AddInt32("query_what", Notifications::EntryRemoved);
};
#if B_BEOS_VERSION > B_BEOS_VERSION_5
fNotify.SendMessage(notify);
#else
fNotify.SendMessage(¬ify);
#endif
};
} break;
case msgInitialFetch: {
volume_t::iterator vIt;
for (vIt = fVolumes.begin(); vIt != fVolumes.end(); vIt++) {
BVolume vol = (*vIt);
BQuery *query = new BQuery();
query->SetPredicate(fPredicate.String());
query->SetTarget(this);
query->SetVolume(&vol);
query->Fetch();
entry_ref ref;
while (query->GetNextRef(&ref) == B_OK) {
BNode node(&ref);
result r;
r.ref = ref;
node.GetNodeRef(&r.nref);
fResults[ref] = r;
};
fQueries.push_back(query);
};
if ((fNotify.IsValid()) && (fMsg != NULL)) {
BMessage notify(*fMsg);
notify.AddString("qlName", fName);
notify.AddInt32("query_what", Notifications::InitialFetch);
#if B_BEOS_VERSION > B_BEOS_VERSION_5
fNotify.SendMessage(notify);
#else
fNotify.SendMessage(¬ify);
#endif
};
} break;
default: {
BLooper::MessageReceived(msg);
};
};
};
int
main()
{
team_info teamInfo;
int32 cookie = 0;
while (get_next_team_info(&cookie, &teamInfo) == B_OK) {
if (!strncmp(teamInfo.args, "/boot/beos/", 11)) {
// this is a system component and not worth to investigate
continue;
}
thread_info threadInfo;
int32 threadCookie = 0;
while (get_next_thread_info(teamInfo.team, &threadCookie, &threadInfo)
== B_OK) {
// search for the roster thread
if (!strcmp(threadInfo.name, "_roster_thread_")) {
port_id port = find_port("antares-test:roster");
port_info portInfo;
if (get_port_info(port, &portInfo) == B_OK
&& portInfo.team == teamInfo.team) {
puts("The Antares Registrar is already running.");
return 0;
}
}
}
}
// the Antares registrar doesn't seem to run yet, change this
BPath currentPath(".");
BQuery query;
query.SetPredicate("name==test_registrar");
// search on current volume only
dev_t device = dev_for_path(".");
BVolume volume(device);
query.SetVolume(&volume);
query.Fetch();
entry_ref ref;
while (query.GetNextRef(&ref) == B_OK) {
BPath path(&ref);
if (path.InitCheck() != B_OK)
continue;
const char* registrarPath = path.Path();
const char* generatedPath = strstr(registrarPath, "generated");
if (generatedPath == NULL)
continue;
if (!strncmp(currentPath.Path(), registrarPath, generatedPath - registrarPath)) {
// gotcha!
const char* args[] = { registrarPath, NULL };
thread_id thread = load_image(1, args, (const char**)environ);
if (thread < B_OK) {
fprintf(stderr, "%s: Could not start the registrar: %s\n",
__progname, strerror(thread));
return -1;
}
resume_thread(thread);
return 0;
}
}
fprintf(stderr, "%s: Could not find the Antares Registrar.\n"
" (This tool only works when used in the Antares tree, but maybe\n"
" the registrar just needs to be built.)\n",
__progname);
return -1;
}
