/*
* this method is not currently being used, but it may be useful in the future...
*/
status_t
DefaultCatalog::ReadFromAttribute(const entry_ref &appOrAddOnRef)
{
BNode node;
status_t res = node.SetTo(&appOrAddOnRef);
if (res != B_OK)
return B_ENTRY_NOT_FOUND;
attr_info attrInfo;
res = node.GetAttrInfo(BLocaleRoster::kEmbeddedCatAttr, &attrInfo);
if (res != B_OK)
return B_NAME_NOT_FOUND;
if (attrInfo.type != B_MESSAGE_TYPE)
return B_BAD_TYPE;
size_t size = attrInfo.size;
auto_ptr<char> buf(new(std::nothrow) char [size]);
if (buf.get() == NULL)
return B_NO_MEMORY;
res = node.ReadAttr(BLocaleRoster::kEmbeddedCatAttr, B_MESSAGE_TYPE, 0,
buf.get(), size);
if (res < (ssize_t)size)
return res < B_OK ? res : B_BAD_DATA;
BMemoryIO memIO(buf.get(), size);
res = Unflatten(&memIO);
return res;
}
Preferences::Preferences(const char* name, const char* signature, bool doSave)
: BMessage('Pref'), BLocker("Preferences", true),
fSavePreferences(doSave)
{
fNewPreferences = false;
fSettingsFile = 0;
BPath prefpath;
fName = strdup(name);
if (signature)
fSignature = strdup(signature);
else
fSignature = NULL;
if (find_directory(B_USER_SETTINGS_DIRECTORY, &prefpath) == B_OK) {
BDirectory prefdir(prefpath.Path());
BEntry entry;
prefdir.FindEntry(fName, &entry);
BFile file(&entry, B_READ_ONLY);
if (file.InitCheck() == B_OK)
Unflatten(&file);
else
fNewPreferences = true;
}
}
bool
PSettings::Load(const char *file)
{
BFile out;
if(out.SetTo(file,B_READ_ONLY)!=B_OK)return false;
if(Unflatten(&out)!=B_OK)return false;
out.Unset();
return true;
}
status_t
BContactField::Unflatten(type_code code,
const void* buffer, ssize_t size)
{
if (buffer == NULL)
return B_BAD_VALUE;
BMemoryIO flatData(buffer, size);
return Unflatten(code, &flatData);
}
Prefs::Prefs()
{
// FindPath
find_directory(B_USER_SETTINGS_DIRECTORY, &fSavePath);
fSavePath.SetTo( fSavePath.Path(), PREFS_FILENAME );
// --- Einstellungen vornehmen
BFile file( fSavePath.Path(), B_READ_ONLY );
Unflatten( &file );
}
/*!
\brief Loads the data into the cursor set from a file
\param path Path of the file to load from.
\return
- \c B_OK: Everything went fine.
- \c B_BAD_VALUE: path is NULL
- \c other value: See BFile::SetTo and BMessage::Flatten return codes
*/
status_t
CursorSet::Load(const char *path)
{
if (!path)
return B_BAD_VALUE;
BFile file;
status_t status = file.SetTo(path, B_READ_ONLY);
if (status != B_OK)
return status;
return Unflatten(&file);
}
//
// TPreferences::TPreferences
//
// Open the settings file and read the data in.
//
TPreferences::TPreferences(char *filename) : BMessage('pref') {
BFile file;
status = find_directory(B_USER_SETTINGS_DIRECTORY, &path);
if (status != B_OK) {
return;
}
path.Append(filename);
status = file.SetTo(path.Path(), B_READ_ONLY);
if (status == B_OK) {
status = Unflatten(&file);
}
}
Preferences::Preferences(const entry_ref &ref, const char* signature, bool doSave)
: BMessage('Pref'), BLocker("Preferences", true),
fSavePreferences(doSave)
{
fSettingsFile = new entry_ref(ref);
fNewPreferences = false;
BPath prefpath;
fName = NULL;
if (signature)
fSignature = strdup(signature);
else
fSignature = NULL;
BFile file(fSettingsFile, B_READ_ONLY);
if (file.InitCheck() == B_OK)
Unflatten(&file);
else
fNewPreferences = true;
}
status_t
DefaultCatalog::ReadFromFile(const char *path)
{
if (!path)
path = fPath.String();
BFile catalogFile;
status_t res = catalogFile.SetTo(path, B_READ_ONLY);
if (res != B_OK)
return B_ENTRY_NOT_FOUND;
fPath = path;
off_t sz = 0;
res = catalogFile.GetSize(&sz);
if (res != B_OK) {
return res;
}
auto_ptr<char> buf(new(std::nothrow) char [sz]);
if (buf.get() == NULL)
return B_NO_MEMORY;
res = catalogFile.Read(buf.get(), sz);
if (res < B_OK)
return res;
if (res < sz)
return res;
BMemoryIO memIO(buf.get(), sz);
res = Unflatten(&memIO);
if (res == B_OK) {
// some information living in member variables needs to be copied
// to attributes. Although these attributes should have been written
// when creating the catalog, we make sure that they exist there:
UpdateAttributes(catalogFile);
}
return res;
}
status_t
DefaultCatalog::ReadFromResource(const entry_ref &appOrAddOnRef)
{
BFile file;
status_t res = file.SetTo(&appOrAddOnRef, B_READ_ONLY);
if (res != B_OK)
return B_ENTRY_NOT_FOUND;
BResources rsrc;
res = rsrc.SetTo(&file);
if (res != B_OK)
return res;
size_t sz;
const void *buf = rsrc.LoadResource('CADA', fLanguageName, &sz);
if (!buf)
return B_NAME_NOT_FOUND;
BMemoryIO memIO(buf, sz);
res = Unflatten(&memIO);
return res;
}
status_t SettingsFile::Load()
{
status_t ret;
BFile file(path.Path(), B_READ_ONLY);
ret = file.InitCheck();
if (ret != B_OK) {
return ret;
}
ret = file.Lock();
if (ret != B_OK) {
return ret;
}
ret = Unflatten(&file);
if (ret != B_OK) {
file.Unlock();
MakeEmpty();
return ret;
}
if (vision_app->fDebugSettings) PrintToStream();
/*
ret=file.RewindAttrs();
if (ret!=B_OK) {
file.Unlock();
MakeEmpty();
return ret;
}
char attr_name[B_ATTR_NAME_LENGTH];
while ((ret=file.GetNextAttrName(attr_name))!=B_ENTRY_NOT_FOUND) { // walk all the
attributes of the settings file
if (ret!=B_OK) {
file.Unlock();
return ret;
}
// found an attribute
attr_info ai;
ret=file.GetAttrInfo(attr_name,&ai);
if (ret!=B_OK) {
file.Unlock();
return ret;
}
switch (ai.type) {
case B_CHAR_TYPE :
case B_STRING_TYPE :
case B_BOOL_TYPE :
case B_INT8_TYPE :
case B_INT16_TYPE :
case B_INT32_TYPE :
case B_INT64_TYPE :
case B_UINT8_TYPE :
case B_UINT16_TYPE :
case B_UINT32_TYPE :
case B_UINT64_TYPE :
case B_FLOAT_TYPE :
case B_DOUBLE_TYPE :
case B_OFF_T_TYPE :
case B_SIZE_T_TYPE :
case B_SSIZE_T_TYPE :
case B_POINT_TYPE :
case B_RECT_TYPE :
case B_RGB_COLOR_TYPE :
case B_TIME_TYPE :
case B_MIME_TYPE : {
char*partial_name=strdup(attr_name);
if (partial_name==NULL) {
file.Unlock();
return B_NO_MEMORY;
}
ret=_ExtractAttribute(this,&file,attr_name,partial_name,&ai);
free(partial_name);
if (ret!=B_OK) {
file.Unlock();
return ret;
}
break;
}
}
}
*/
file.Unlock();
return B_OK;
}
Prefs::Prefs() {
BFile file = PrefsFile( B_READ_ONLY );
Unflatten( &file );
}
void Preferences::ReadSettings ()
{
/* Load "prefs" from the preferences file */
BFile file (prefsPath.Path(), B_READ_ONLY);
Unflatten (&file);
}
csEventFlattenerError csEventFlattener::Unflatten (iObjectRegistry *object_reg,
iEvent* event,
const char *buffer,
size_t length)
{
csMemFile b((char *)buffer, length, csMemFile::DISPOSITION_IGNORE);
uint8 ui8;
int8 i8;
uint16 ui16;
int16 i16;
uint32 ui32;
int32 i32;
uint64 ui64;
int64 i64;
double d;
char *name;
size_t size;
b.Read((char *)&ui32, sizeof(ui32)); // protocol version
ui32 = csLittleEndian::Convert (ui32);
if (ui32 != CS_CRYSTAL_PROTOCOL)
{
//csPrintf("protocol version invalid: %" PRIX32 "\n", ui32);
return csEventFlattenerErrorWrongFormat;
}
b.Read((char *)&ui64, sizeof(uint64)); // packet size
size = csLittleEndian::Convert (ui64);
b.Read((char *)&ui32, sizeof(uint32)); // iEvent.Time
event->Time = csLittleEndian::Convert (ui32);
b.Read((char *)&event->Broadcast, sizeof(uint8)); // iEvent.Broadcast flag
b.Read((char *)&ui16, sizeof(uint16)); // textual name length
ui16 = csLittleEndian::Convert (ui16);
char *buf = (char *) cs_malloc(ui16+1);
b.Read(buf, ui16); // textual name
buf[ui16] = '\0';
event->Name = csEventNameRegistry::GetID(object_reg, buf); // EventID
cs_free(buf);
while (b.GetPos() < size)
{
b.Read((char *)&ui16, sizeof(uint16));
ui16 = csLittleEndian::Convert (ui16);
name = new char[ui16+1];
b.Read(name, ui16);
name[ui16] = 0;
b.Read((char *)&ui8, sizeof(uint8));
switch(ui8)
{
case CS_DATATYPE_INT8:
b.Read((char *)&i8, sizeof(int8));
event->Add (name, i8);
break;
case CS_DATATYPE_UINT8:
b.Read((char *)&ui8, sizeof(uint8));
event->Add (name, ui8);
break;
case CS_DATATYPE_INT16:
b.Read((char *)&i16, sizeof(int16));
i16 = csLittleEndian::Convert (i16);
event->Add (name, i16);
break;
case CS_DATATYPE_UINT16:
b.Read((char *)&ui16, sizeof(uint16));
ui16 = csLittleEndian::Convert (ui16);
event->Add (name, ui16);
break;
case CS_DATATYPE_INT32:
b.Read((char *)&i32, sizeof(int32));
i32 = csLittleEndian::Convert (i32);
event->Add (name, i32);
break;
case CS_DATATYPE_UINT32:
b.Read((char *)&ui32, sizeof(uint32));
ui32 = csLittleEndian::Convert (ui32);
event->Add (name, ui32);
break;
case CS_DATATYPE_INT64:
b.Read((char *)&i64, sizeof(int64));
i64 = csLittleEndian::Convert (i64);
event->Add (name, i64);
break;
case CS_DATATYPE_UINT64:
b.Read((char *)&ui64, sizeof(uint64));
ui64 = csLittleEndian::Convert (ui64);
event->Add (name, ui64);
break;
case CS_DATATYPE_DOUBLE:
b.Read((char *)&i64, sizeof(int64));
d = csLongLongToDouble(i64);
event->Add (name, d);
break;
case CS_DATATYPE_DATABUFFER:
{
b.Read((char *)&ui64, sizeof(uint64));
ui64 = csLittleEndian::Convert (ui64);
char* data = new char[ui64];
b.Read(data, ui64);
event->Add (name, data, ui64);
delete[] data;
}
break;
case CS_DATATYPE_EVENT:
{
b.Read((char *)&ui64, sizeof (uint64));
ui64 = csLittleEndian::Convert (ui64);
csRef<iEvent> e;
e.AttachNew (new csEvent ());
event->Add (name, e);
csEventFlattenerError unflattenResult =
Unflatten (object_reg, e,
buffer+b.GetPos(), ui64);
if (unflattenResult != csEventFlattenerErrorNone)
{
delete[] name;
return unflattenResult;
}
b.SetPos (b.GetPos() + (size_t)ui64);
}
break;
default:
break;
}
delete[] name;
}
return csEventFlattenerErrorNone;
}
