BMailFilterAction
RuleFilter::HeaderFetched(entry_ref& ref, BFile& file, BMessage& attributes)
{
// That field doesn't exist? NO match
if (fAttribute == "")
return B_NO_MAIL_ACTION;
attr_info info;
if (file.GetAttrInfo("Subject", &info) != B_OK
|| info.type != B_STRING_TYPE)
return B_NO_MAIL_ACTION;
BString data = attributes.GetString(fAttribute.String(), NULL);
if (data.IsEmpty() || !fMatcher.Match(data)) {
// We're not supposed to do anything
return B_NO_MAIL_ACTION;
}
switch (fAction) {
case ACTION_MOVE_TO:
{
BDirectory dir(fMoveTarget);
node_ref nodeRef;
status_t status = dir.GetNodeRef(&nodeRef);
if (status != B_OK)
return status;
ref.device = nodeRef.device;
ref.directory = nodeRef.node;
return B_MOVE_MAIL_ACTION;
}
case ACTION_DELETE_MESSAGE:
return B_DELETE_MAIL_ACTION;
case ACTION_SET_FLAGS_TO:
file.WriteAttrString("MAIL:filter_flags", &fSetFlags);
break;
case ACTION_REPLY_WITH:
file.WriteAttr("MAIL:reply_with", B_INT32_TYPE, 0, &fReplyAccount,
sizeof(int32));
break;
case ACTION_SET_AS_READ:
{
BInboundMailProtocol& protocol
= (BInboundMailProtocol&)fMailProtocol;
protocol.MarkMessageAsRead(ref, B_READ);
break;
}
default:
fprintf(stderr,"Unknown do_what: 0x%04x!\n", fAction);
}
return B_NO_MAIL_ACTION;
}
void
PersonView::SetAttribute(const char* attribute, bool update)
{
char* value = NULL;
attr_info info;
BFile* file = NULL;
if (fRef != NULL)
file = new(std::nothrow) BFile(fRef, B_READ_ONLY);
if (file != NULL && file->GetAttrInfo(attribute, &info) == B_OK) {
value = (char*)calloc(info.size, 1);
file->ReadAttr(attribute, B_STRING_TYPE, 0, value, info.size);
}
SetAttribute(attribute, value, update);
free(value);
delete file;
}
void PProjectWindow::ReadAttr(BFile& file, BMessage& settingsMsg)
{
char *fm = NULL;
try
{
attr_info ai;
if (file.GetAttrInfo("pe-prj-info", &ai) == B_NO_ERROR)
{
fm = (char *)malloc(ai.size);
FailNil(fm);
FailIOErr(file.ReadAttr("pe-prj-info", ai.type, 0, fm, ai.size));
FailOSErr(settingsMsg.Unflatten(fm));
}
}
catch (HErr& e) {}
if (fm)
free(fm);
}
void
TMailApp::RefsReceived(BMessage *msg)
{
bool have_names = false;
BString names;
char type[B_FILE_NAME_LENGTH];
int32 item = 0;
BFile file;
TMailWindow *window;
entry_ref ref;
//
// If a tracker window opened me, get a messenger from it.
//
BMessenger messenger;
if (msg->HasMessenger("TrackerViewToken"))
msg->FindMessenger("TrackerViewToken", &messenger);
while (msg->HasRef("refs", item)) {
msg->FindRef("refs", item++, &ref);
if ((window = FindWindow(ref)) != NULL)
window->Activate(true);
else {
file.SetTo(&ref, O_RDONLY);
if (file.InitCheck() == B_NO_ERROR) {
BNodeInfo node(&file);
node.GetType(type);
if (strcmp(type, B_MAIL_TYPE) == 0
|| strcmp(type, B_PARTIAL_MAIL_TYPE) == 0) {
window = NewWindow(&ref, NULL, false, &messenger);
window->Show();
} else if(strcmp(type, "application/x-person") == 0) {
/* Got a People contact info file, see if it has an Email address. */
BString name;
BString email;
attr_info info;
char *attrib;
if (file.GetAttrInfo("META:email", &info) == B_NO_ERROR) {
attrib = (char *) malloc(info.size + 1);
file.ReadAttr("META:email", B_STRING_TYPE, 0, attrib, info.size);
attrib[info.size] = 0; // Just in case it wasn't NUL terminated.
email << attrib;
free(attrib);
/* we got something... */
if (email.Length() > 0) {
/* see if we can get a username as well */
if(file.GetAttrInfo("META:name", &info) == B_NO_ERROR) {
attrib = (char *) malloc(info.size + 1);
file.ReadAttr("META:name", B_STRING_TYPE, 0, attrib, info.size);
attrib[info.size] = 0; // Just in case it wasn't NUL terminated.
name << "\"" << attrib << "\" ";
email.Prepend("<");
email.Append(">");
free(attrib);
}
if (names.Length() == 0) {
names << name << email;
} else {
names << ", " << name << email;
}
have_names = true;
email.SetTo("");
name.SetTo("");
}
}
}
else if (strcmp(type, kDraftType) == 0) {
window = NewWindow();
// If it's a draft message, open it
window->OpenMessage(&ref);
window->Show();
}
} /* end of else(file.InitCheck() == B_NO_ERROR */
}
}
if (have_names) {
window = NewWindow(NULL, names.String());
window->Show();
}
}
//---------------------------------------------------------------
// Copy File, not only data but also attributes ;-)
//---------------------------------------------------------------
void TJerFile::CopyFile( const char *sourcepath, const char *destinationpath )
{
BFile *source = 0L, *destination = 0L;
entry_ref ref;
uint8 data[2048];
int32 len = 2048;
char buf[B_ATTR_NAME_LENGTH];
void *buffer = NULL;
int32 lengthR,lengthW;
attr_info attribute;
BEntry entry( sourcepath );
if( B_OK == entry.InitCheck() )
{
if( B_OK == entry.GetRef( &ref ) )
{
source = new BFile( &ref ,B_READ_ONLY);
}
else
{
string truc("Error opening file in read only mode: ");
truc = truc + sourcepath;
GeneralException excep(truc.c_str(),"BJerFile::CopyFile");
throw(excep);
}
}
else
{
string truc("Error constructing file object: ");
truc = truc + sourcepath;
GeneralException excep(truc.c_str(),"BJerFile::CopyFile");
throw(excep);
}
entry.SetTo( destinationpath );
if( B_OK == entry.InitCheck() )
{
if( B_OK == entry.GetRef( &ref ) )
{
destination = new BFile( &ref ,B_READ_WRITE | B_CREATE_FILE | B_ERASE_FILE);
}
else
{
string truc("Error opening file in read write mode: ");
truc = truc + destinationpath;
GeneralException excep(truc.c_str(),"BJerFile::CopyFile");
throw(excep);
}
}
else
{
string truc("Error destination constructing file object: ");
truc = truc + destinationpath;
GeneralException excep(truc.c_str(),"BJerFile::CopyFile");
throw(excep);
}
if( source && destination )
{
BMessage *AMessage;
AMessage = new BMessage(B_UPDATE_STATUS_BAR);
AMessage->AddFloat("delta",1.0);
AMessage->AddString("text","Copy...");
AMessage->AddString("trailingtext",destinationpath);
MyInvoker.Invoke(AMessage);
delete AMessage;
while (source->GetNextAttrName(buf) == B_NO_ERROR)
{
source->GetAttrInfo(buf,&attribute);
if (buffer!=NULL)
{
free(buffer);
}
buffer = (void *)malloc(sizeof(char)*(attribute.size +1));
lengthR = source->ReadAttr(buf,attribute.type,0,buffer,attribute.size);
lengthW = destination->WriteAttr(buf,attribute.type,0,buffer,lengthR);
if (lengthR!=lengthW)
{
string truc("Error copying attribute for file : ");
truc = truc + destinationpath;
GeneralException excep(truc.c_str(),"BJerFile::CopyFile");
throw(excep);
}
switch(lengthR)
{
case B_ENTRY_NOT_FOUND:
{
GeneralException excep("The attribute doesn't exist.","BJerFile::CopyFile");
throw(excep);
break;
}
case B_FILE_ERROR :
{
GeneralException excep2("The object is uninitialized.","BJerFile::CopyFile");
throw(excep2);
break;
}
}
switch(lengthW)
{
case B_FILE_ERROR :
{
GeneralException excep3("This object is a read-only BFile.","BJerFile::CopyFile");
throw(excep3);
break;
}
case B_NOT_ALLOWED :
{
GeneralException excep4("The node is on a read-only volume.","BJerFile::CopyFile");
throw(excep4);
break;
}
case B_DEVICE_FULL :
{
GeneralException excep5("Out of disk space.","BJerFile::CopyFile");
throw(excep5);
break;
}
case B_NO_MEMORY :
{
GeneralException excep6("Not enough memory.","BJerFile::CopyFile");
throw(excep6);
break;
}
}
}
for( ;; )
{
len = source->Read( data, len );
if( len == 0 )
break;
destination->Write( data, len );
if( len != 2048 )
break;
}
//---------- freeing some resources...
delete source;
delete destination;
}
}
/*! \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
