haiku.git

/*
 * Copyright 2006, Haiku.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Stephan Aßmus <superstippi@gmx.de>
 */

#include "Property.h"

#include <new>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>

#include <Message.h>

#include "support.h"

using std::nothrow;

// constructor
Property::Property(uint32 identifier)
	: fIdentifier(identifier),
	  fEditable(true)
{
}

// constructor
Property::Property(const Property& other)
	: fIdentifier(other.fIdentifier),
	  fEditable(other.fEditable)
{
}

// constructor
Property::Property(BMessage* archive)
	: fIdentifier(0),
	  fEditable(true)
{
	if (!archive)
		return;

	if (archive->FindInt32("id", (int32*)&fIdentifier) < B_OK)
		fIdentifier = 0;
	if (archive->FindBool("editable", &fEditable) < B_OK)
		fEditable = true;
}

// destructor
Property::~Property()
{
}

// Archive
status_t
Property::Archive(BMessage* into, bool deep) const
{
	status_t ret = BArchivable::Archive(into, deep);

	if (ret == B_OK)
		ret = into->AddInt32("id", fIdentifier);

	if (ret == B_OK)
		ret = into->AddBool("editable", fEditable);

	// finish off
	if (ret >= B_OK)
		ret = into->AddString("class", "Property");

	return ret;
}

// #pragma mark -

// InterpolateTo
bool
Property::InterpolateTo(const Property* other, float scale)
{
	// some properties don't support this
	return false;
}

// SetEditable
void
Property::SetEditable(bool editable)
{
	fEditable = editable;
}

// #pragma mark -

// constructor
IntProperty::IntProperty(uint32 identifier, int32 value,
						 int32 min, int32 max)
	: Property(identifier),
	  fValue(value),
	  fMin(min),
	  fMax(max)
{
}

// constructor
IntProperty::IntProperty(const IntProperty& other)
	: Property(other),
	  fValue(other.fValue),
	  fMin(other.fMin),
	  fMax(other.fMax)
{
}

// constructor
IntProperty::IntProperty(BMessage* archive)
	: Property(archive),
	  fValue(0),
	  fMin(0),
	  fMax(0)
{
	if (!archive)
		return;

	if (archive->FindInt32("value", &fValue) < B_OK)
		fValue = 0;
	if (archive->FindInt32("min", &fMin) < B_OK)
		fMin = 0;
	if (archive->FindInt32("max", &fMax) < B_OK)
		fMax = 0;
}

// destructor
IntProperty::~IntProperty()
{
}

// Archive
status_t
IntProperty::Archive(BMessage* into, bool deep) const
{
	status_t ret = Property::Archive(into, deep);

	if (ret >= B_OK)
		ret = into->AddInt32("value", fValue);
	if (ret >= B_OK)
		ret = into->AddInt32("min", fMin);
	if (ret >= B_OK)
		ret = into->AddInt32("max", fMax);

	// finish off
	if (ret >= B_OK)
		ret = into->AddString("class", "IntProperty");

	return ret;
}

// Instantiate
BArchivable*
IntProperty::Instantiate(BMessage* archive)
{
	if (validate_instantiation(archive, "IntProperty"))
		return new IntProperty(archive);

	return NULL;
}

// Clone
Property*
IntProperty::Clone() const
{
	return new IntProperty(*this);
}

// SetValue
bool
IntProperty::SetValue(const char* value)
{
	return SetValue(atoi(value));
}

// SetValue
bool
IntProperty::SetValue(const Property* other)
{
	const IntProperty* i = dynamic_cast<const IntProperty*>(other);
	if (i) {
		return SetValue(i->Value());
	}
	return false;
}

// GetValue
void
IntProperty::GetValue(BString& string)
{
	string << fValue;
}

// InterpolateTo
bool
IntProperty::InterpolateTo(const Property* other, float scale)
{
	const IntProperty* i = dynamic_cast<const IntProperty*>(other);
	if (i) {
		return SetValue(fValue + (int32)((float)(i->Value()
												 - fValue) * scale + 0.5));
	}
	return false;
}

// SetValue
bool
IntProperty::SetValue(int32 value)
{
	// truncate
	if (value < fMin)
		value = fMin;
	if (value > fMax)
		value = fMax;

	if (value != fValue) {
		fValue = value;
		return true;
	}
	return false;
}

// #pragma mark -

// constructor
FloatProperty::FloatProperty(uint32 identifier, float value,
							 float min, float max)
	: Property(identifier),
	  fValue(value),
	  fMin(min),
	  fMax(max)
{
}

// constructor
FloatProperty::FloatProperty(const FloatProperty& other)
	: Property(other),
	  fValue(other.fValue),
	  fMin(other.fMin),
	  fMax(other.fMax)
{
}

// constructor
FloatProperty::FloatProperty(BMessage* archive)
	: Property(archive),
	  fValue(0.0),
	  fMin(0.0),
	  fMax(0.0)
{
	if (!archive)
		return;

	if (archive->FindFloat("value", &fValue) < B_OK)
		fValue = 0.0;
	if (archive->FindFloat("min", &fMin) < B_OK)
		fMin = 0.0;
	if (archive->FindFloat("max", &fMax) < B_OK)
		fMax = 0.0;
}

// destructor
FloatProperty::~FloatProperty()
{
}

// Archive
status_t
FloatProperty::Archive(BMessage* into, bool deep) const
{
	status_t ret = Property::Archive(into, deep);

	if (ret >= B_OK)
		ret = into->AddFloat("value", fValue);
	if (ret >= B_OK)
		ret = into->AddFloat("min", fMin);
	if (ret >= B_OK)
		ret = into->AddFloat("max", fMax);

	// finish off
	if (ret >= B_OK)
		ret = into->AddString("class", "FloatProperty");

	return ret;
}

// Instantiate
BArchivable*
FloatProperty::Instantiate(BMessage* archive)
{
	if (validate_instantiation(archive, "FloatProperty"))
		return new FloatProperty(archive);

	return NULL;
}

// Clone
Property*
FloatProperty::Clone() const
{
	return new FloatProperty(*this);
}

// SetValue
bool
FloatProperty::SetValue(const char* value)
{
	return SetValue(atof(value));
}

// SetValue
bool
FloatProperty::SetValue(const Property* other)
{
	const FloatProperty* f = dynamic_cast<const FloatProperty*>(other);
	if (f) {
		return SetValue(f->Value());
	}
	return false;
}

// GetValue
void
FloatProperty::GetValue(BString& string)
{
	append_float(string, fValue, 4);
}

// InterpolateTo
bool
FloatProperty::InterpolateTo(const Property* other, float scale)
{
	const FloatProperty* f = dynamic_cast<const FloatProperty*>(other);
	if (f) {
		return SetValue(fValue + (f->Value() - fValue) * scale);
	}
	return false;
}

// SetValue
bool
FloatProperty::SetValue(float value)
{
	// truncate
	if (value < fMin)
		value = fMin;
	if (value > fMax)
		value = fMax;

	if (value != fValue) {
		fValue = value;
		return true;
	}
	return false;
}

// #pragma mark -

// constructor
UInt8Property::UInt8Property(uint32 identifier, uint8 value)
	: Property(identifier),
	  fValue(value)
{
}

// constructor
UInt8Property::UInt8Property(const UInt8Property& other)
	: Property(other),
	  fValue(other.fValue)
{
}

// constructor
UInt8Property::UInt8Property(BMessage* archive)
	: Property(archive),
	  fValue(0)
{
	if (!archive)
		return;

	if (archive->FindInt8("value", (int8*)&fValue) < B_OK)
		fValue = 0;
}

// destructor
UInt8Property::~UInt8Property()
{
}

// Archive
status_t
UInt8Property::Archive(BMessage* into, bool deep) const
{
	status_t ret = Property::Archive(into, deep);

	if (ret >= B_OK)
		ret = into->AddInt8("value", fValue);

	// finish off
	if (ret >= B_OK)
		ret = into->AddString("class", "UInt8Property");

	return ret;
}

// Instantiate
BArchivable*
UInt8Property::Instantiate(BMessage* archive)
{
	if (validate_instantiation(archive, "UInt8Property"))
		return new UInt8Property(archive);

	return NULL;
}

// Clone
Property*
UInt8Property::Clone() const
{
	return new UInt8Property(*this);
}

// SetValue
bool
UInt8Property::SetValue(const char* value)
{
	return SetValue((uint8)max_c(0, min_c(255, atoi(value))));
}

// SetValue
bool
UInt8Property::SetValue(const Property* other)
{
	const UInt8Property* u = dynamic_cast<const UInt8Property*>(other);
	if (u) {
		return SetValue(u->Value());
	}
	return false;
}

// GetValue
void
UInt8Property::GetValue(BString& string)
{
	string << fValue;
}

// InterpolateTo
bool
UInt8Property::InterpolateTo(const Property* other, float scale)
{
	const UInt8Property* u = dynamic_cast<const UInt8Property*>(other);
	if (u) {
		return SetValue(fValue + (uint8)((float)(u->Value()
												 - fValue) * scale + 0.5));
	}
	return false;
}

// SetValue
bool
UInt8Property::SetValue(uint8 value)
{
	if (value != fValue) {
		fValue = value;
		return true;
	}
	return false;
}

// #pragma mark -

// constructor
BoolProperty::BoolProperty(uint32 identifier, bool value)
	: Property(identifier),
	  fValue(value)
{
}

// constructor
BoolProperty::BoolProperty(const BoolProperty& other)
	: Property(other),
	  fValue(other.fValue)
{
}

// constructor
BoolProperty::BoolProperty(BMessage* archive)
	: Property(archive),
	  fValue(false)
{
	if (!archive)
		return;

	if (archive->FindBool("value", &fValue) < B_OK)
		fValue = false;
}

// destructor
BoolProperty::~BoolProperty()
{
}

// Archive
status_t
BoolProperty::Archive(BMessage* into, bool deep) const
{
	status_t ret = Property::Archive(into, deep);

	if (ret >= B_OK)
		ret = into->AddBool("value", fValue);

	// finish off
	if (ret >= B_OK)
		ret = into->AddString("class", "BoolProperty");

	return ret;
}

// Instantiate
BArchivable*
BoolProperty::Instantiate(BMessage* archive)
{
	if (validate_instantiation(archive, "BoolProperty"))
		return new BoolProperty(archive);

	return NULL;
}

// Clone
Property*
BoolProperty::Clone() const
{
	return new BoolProperty(*this);
}

// SetValue
bool
BoolProperty::SetValue(const char* value)
{
	bool v;
	if (strcasecmp(value, "true") == 0)
		v = true;
	else if (strcasecmp(value, "on") == 0)
		v = true;
	else
		v = (bool)atoi(value);

	return SetValue(v);
}

// SetValue
bool
BoolProperty::SetValue(const Property* other)
{
	const BoolProperty* b = dynamic_cast<const BoolProperty*>(other);
	if (b) {
		return SetValue(b->Value());
	}
	return false;
}

// GetValue
void
BoolProperty::GetValue(BString& string)
{
	if (fValue)
		string << "on";
	else
		string << "off";
}

// InterpolateTo
bool
BoolProperty::InterpolateTo(const Property* other, float scale)
{
	const BoolProperty* b = dynamic_cast<const BoolProperty*>(other);
	if (b) {
		if (scale >= 0.5)
			return SetValue(b->Value());
	}
	return false;
}

// SetValue
bool
BoolProperty::SetValue(bool value)
{
	if (value != fValue) {
		fValue = value;
		return true;
	}
	return false;
}

// #pragma mark -

// constructor
StringProperty::StringProperty(uint32 identifier, const char* value)
	: Property(identifier),
	  fValue(value)
{
}

// constructor
StringProperty::StringProperty(const StringProperty& other)
	: Property(other),
	  fValue(other.fValue)
{
}

// constructor
StringProperty::StringProperty(BMessage* archive)
	: Property(archive),
	  fValue()
{
	if (!archive)
		return;

	if (archive->FindString("value", &fValue) < B_OK)
		fValue = "";
}

// destructor
StringProperty::~StringProperty()
{
}

// Archive
status_t
StringProperty::Archive(BMessage* into, bool deep) const
{
	status_t ret = Property::Archive(into, deep);

	if (ret >= B_OK)
		ret = into->AddString("value", fValue);

	// finish off
	if (ret >= B_OK)
		ret = into->AddString("class", "StringProperty");

	return ret;
}

// Instantiate
BArchivable*
StringProperty::Instantiate(BMessage* archive)
{
	if (validate_instantiation(archive, "StringProperty"))
		return new StringProperty(archive);

	return NULL;
}

// Clone
Property*
StringProperty::Clone() const
{
	return new StringProperty(*this);
}

// SetValue
bool
StringProperty::SetValue(const char* value)
{
	BString t(value);
	if (fValue != t) {
		fValue = t;
		return true;
	}
	return false;
}

// SetValue
bool
StringProperty::SetValue(const Property* other)
{
	const StringProperty* s = dynamic_cast<const StringProperty*>(other);
	if (s) {
		return SetValue(s->Value());
	}
	return false;
}

// GetValue
void
StringProperty::GetValue(BString& string)
{
	string << fValue;
}