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

#ifndef PROPERTY_H
#define PROPERTY_H

#include <limits.h>

#include <Archivable.h>
#include <String.h>
#include <TypeConstants.h>

class PropertyAnimator;

// Property
class Property : public BArchivable {
 public:
								Property(uint32 identifier);
								Property(const Property& other);
								Property(BMessage* archive);
	virtual						~Property();

	// BArchivable interface
	virtual	status_t			Archive(BMessage* archive,
										bool deep = true) const;

	// Property
	virtual	Property*			Clone() const = 0;

	virtual	type_code			Type() const = 0;

	virtual	bool				SetValue(const char* value) = 0;
	virtual	bool				SetValue(const Property* other) = 0;
	virtual	void				GetValue(BString& string) = 0;

	// animation
	virtual	bool				InterpolateTo(const Property* other,
											  float scale);

	inline	uint32				Identifier() const
									{ return fIdentifier; }

			void				SetEditable(bool editable);
	inline	bool				IsEditable() const
									{ return fEditable; }

 private:
			uint32				fIdentifier;
			bool				fEditable;
};

// IntProperty
class IntProperty : public Property {
 public:
								IntProperty(uint32 identifier,
											int32 value = 0,
											int32 min = INT32_MIN,
											int32 max = INT32_MAX);
								IntProperty(const IntProperty& other);
								IntProperty(BMessage* archive);
	virtual						~IntProperty();

	virtual	status_t			Archive(BMessage* archive,
										bool deep = true) const;
	static	BArchivable*		Instantiate(BMessage* archive);

	virtual	Property*			Clone() const;

	virtual	type_code			Type() const
									{ return B_INT32_TYPE; }

	virtual	bool				SetValue(const char* value);
	virtual	bool				SetValue(const Property* other);
	virtual	void				GetValue(BString& string);

	virtual	bool				InterpolateTo(const Property* other,
											  float scale);

	// IntProperty
			bool				SetValue(int32 value);

	inline	int32				Value() const
									{ return fValue; }
	inline	int32				Min() const
									{ return fMin; }
	inline	int32				Max() const
									{ return fMax; }

 private:
			int32				fValue;
			int32				fMin;
			int32				fMax;
};

// FloatProperty
class FloatProperty : public Property {
 public:
								FloatProperty(uint32 identifier,
											  float value = 0.0,
											  float min = -1000000.0,
											  float max = 1000000.0);
								FloatProperty(const FloatProperty& other);
								FloatProperty(BMessage* archive);
	virtual						~FloatProperty();

	virtual	status_t			Archive(BMessage* archive,
										bool deep = true) const;
	static	BArchivable*		Instantiate(BMessage* archive);

	virtual	Property*			Clone() const;

	virtual	type_code			Type() const
									{ return B_FLOAT_TYPE; }

	virtual	bool				SetValue(const char* value);
	virtual	bool				SetValue(const Property* other);
	virtual	void				GetValue(BString& string);

	virtual	bool				InterpolateTo(const Property* other,
											  float scale);

	// FloatProperty
			bool				SetValue(float value);

	inline	float				Value() const
									{ return fValue; }
	inline	float				Min() const
									{ return fMin; }
	inline	float				Max() const
									{ return fMax; }

 private:
			float				fValue;
			float				fMin;
			float				fMax;
};

// UInt8Property
class UInt8Property : public Property {
 public:
								UInt8Property(uint32 identifier,
											  uint8 value = 255);
								UInt8Property(const UInt8Property& other);
								UInt8Property(BMessage* archive);
	virtual						~UInt8Property();

	virtual	status_t			Archive(BMessage* archive,
										bool deep = true) const;
	static	BArchivable*		Instantiate(BMessage* archive);

	virtual	Property*			Clone() const;

	virtual	type_code			Type() const
									{ return B_INT8_TYPE; }

	virtual	bool				SetValue(const char* value);
	virtual	bool				SetValue(const Property* other);
	virtual	void				GetValue(BString& string);

	virtual	bool				InterpolateTo(const Property* other,
											  float scale);

	// UInt8Property
			bool				SetValue(uint8 value);

	inline	uint8				Value() const
									{ return fValue; }

 private:
			uint8				fValue;
};

// BoolProperty
class BoolProperty : public Property {
 public:
								BoolProperty(uint32 identifier,
											 bool value = false);
								BoolProperty(const BoolProperty& other);
								BoolProperty(BMessage* archive);
	virtual						~BoolProperty();

	virtual	status_t			Archive(BMessage* archive,
										bool deep = true) const;
	static	BArchivable*		Instantiate(BMessage* archive);

	virtual	Property*			Clone() const;

	virtual	type_code			Type() const
									{ return B_BOOL_TYPE; }

	virtual	bool				SetValue(const char* value);
	virtual	bool				SetValue(const Property* other);
	virtual	void				GetValue(BString& string);

	virtual	bool				InterpolateTo(const Property* other,
											  float scale);

	// BoolProperty
			bool				SetValue(bool value);

	inline	bool				Value() const
									{ return fValue; }

 private:
			bool				fValue;
};

// StringProperty
class StringProperty : public Property {
 public:
								StringProperty(uint32 identifier,
											   const char* string);
								StringProperty(const StringProperty& other);
								StringProperty(BMessage* archive);
	virtual						~StringProperty();

	virtual	status_t			Archive(BMessage* archive,
										bool deep = true) const;
	static	BArchivable*		Instantiate(BMessage* archive);

	virtual	Property*			Clone() const;

	virtual	type_code			Type() const
									{ return B_STRING_TYPE; }

	virtual	bool				SetValue(const char* value);
	virtual	bool				SetValue(const Property* other);
	virtual	void				GetValue(BString& string);

	// StringProperty
	inline	const char*			Value() const
									{ return fValue.String(); }

 private:
			BString				fValue;
};

#endif // PROPERTY_H