X-Git-Url: https://git.pterodactylus.net/?a=blobdiff_plain;f=synfig-core%2Ftrunk%2Fsrc%2Fsynfig%2Fvalue.h;h=cc6cab9337fd7942af7e557a9962d60a1524a961;hb=756c0d29ac1742f231e6615f9a577e574e35a4af;hp=90c454f944f777df3165a11db4d658566864c821;hpb=00644fdca1f213c58b42e7ec396bd29a0e4f5a02;p=synfig.git

diff --git a/synfig-core/trunk/src/synfig/value.h b/synfig-core/trunk/src/synfig/value.h
index 90c454f..cc6cab9 100644
--- a/synfig-core/trunk/src/synfig/value.h
+++ b/synfig-core/trunk/src/synfig/value.h
@@ -2,10 +2,11 @@
 /*!	\file value.h
 **	\brief Template Header
 **
-**	$Id: value.h,v 1.1.1.1 2005/01/04 01:23:15 darco Exp $
+**	$Id$
 **
 **	\legal
 **	Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley
+**	Copyright (c) 2007, 2008 Chris Moore
 **
 **	This package is free software; you can redistribute it and/or
 **	modify it under the terms of the GNU General Public License as
@@ -66,7 +67,7 @@ class Segment;
 class Gradient;
 class BLinePoint;
 class Color;
-	
+
 /*!	\class ValueBase
 **	\todo writeme
 */
@@ -82,25 +83,25 @@ public:
 	enum Type
 	{
 		TYPE_NIL=0,			//!< Represents an empty value
-		
+
 		TYPE_BOOL,
 		TYPE_INTEGER,
 		TYPE_ANGLE,			//!< Angle
 
 		// All types after this point are larger than 32 bits
-		
+
 		TYPE_TIME,			//!< Time
 		TYPE_REAL,			//!< Real
 
 		// All types after this point are larger than 64 bits
-		
+
 		TYPE_VECTOR,		//!< Vector
 		TYPE_COLOR,			//!< Color
 		TYPE_SEGMENT,		//!< Segment
 		TYPE_BLINEPOINT,	//!< BLinePoint
 
 		// All types after this point require construction/destruction
-		
+
 		TYPE_LIST,			//!< List
 		TYPE_CANVAS,		//!< Canvas
 		TYPE_STRING,		//!< String
@@ -108,7 +109,7 @@ public:
 
 		TYPE_END			//!< Not a valid type, used for sanity checks
 	};
-	
+
 private:
 
 	typedef std::vector<ValueBase> list_type;
@@ -118,16 +119,16 @@ private:
 	*/
 
 protected:
-	
+
 	Type type;
 	void *data;
 	etl::reference_counter ref_count;
-	bool loop_;	
+	bool loop_;
 
 	/*
  --	** -- C O N S T R U C T O R S -----------------------------------
 	*/
-	
+
 public:
 
 	//! \writeme
@@ -144,7 +145,7 @@ public:
 
 	//! \writeme
 	~ValueBase();
-		
+
 	/*
  --	** -- O P E R A T O R S ---------------------------------------------------
 	*/
@@ -156,7 +157,7 @@ public:
 		{ set(x); return *this; }
 
 	//! \writeme
-	ValueBase& operator=(const ValueBase& x);	
+	ValueBase& operator=(const ValueBase& x);
 
 	//! \writeme
 	bool operator==(const ValueBase& rhs)const;
@@ -181,14 +182,14 @@ public:
 	bool get_loop()const { return loop_; }
 
 	//! \writeme
-	void set_loop(bool x) { loop_=x; }	
-		
+	void set_loop(bool x) { loop_=x; }
+
 	//! \writeme
 	bool empty()const;
 
 	//! \writeme
 	Type get_contained_type()const;
-	
+
 	//! Returns true if the contained value is defined and valid.
 	bool is_valid()const;
 
@@ -197,26 +198,37 @@ public:
 
 	//! Returns the type of the contained value
 	const Type & get_type()const { return type; }
-	
+
 	//! Checks the type of the parameter against itself. Returns true if they are of the same type.
 	template <class T> bool
-	same_as(const T &x)const
+	same_type_as(const T &x)const
 	{
 		const Type testtype(get_type(x));
-		
-		if(testtype==type)return true;
-		if(	(type==TYPE_REAL || type==TYPE_TIME) &&
-			(testtype==TYPE_REAL || testtype==TYPE_TIME) )
+
+		return same_type_as(type, testtype);
+	}
+
+	bool same_type_as(const Type testtype)const
+	{
+		return same_type_as(type, testtype);
+	}
+
+	//! Compares two types.  Returns true if they are the same type.
+	static bool same_type_as(const Type type1, const Type type2)
+	{
+		if (type1 == type2) return true;
+		if ((type1 == TYPE_REAL || type1 == TYPE_TIME) &&
+			(type2 == TYPE_REAL || type2 == TYPE_TIME))
 			return true;
 		return false;
 	}
-	
-	
-	// === GET MEMBERS ========================================================	
+
+
+	// === GET MEMBERS ========================================================
 	template <typename T>
-	const T &get(const T& x)const
+	const T &get(const T& x __attribute__ ((unused)))const
 	{
-		assert(is_valid() && same_as(x));
+		assert(is_valid() && same_type_as(x));
 		return *static_cast<const T*>(data);
 	}
 	float get(const float &)const { return get(Real()); }
@@ -227,37 +239,38 @@ public:
 	const char* get(const char*)const;
 	const list_type& get_list()const { return get(list_type()); }
 	// ========================================================================
-	
-	
-	
-	// === PUT MEMBERS ========================================================	
+
+
+
+	// === PUT MEMBERS ========================================================
 	template <typename T>
 	void put(T* x)const
 	{
-		assert(same_as(*x));
+		assert(same_type_as(*x));
 		*x=*static_cast<const T*>(data);
 	}
 	void put(float* x)const { *x=get(Real()); }
 	void put(char** x)const;
 	// ========================================================================
 
-	
-	
-	// === SET MEMBERS ========================================================	
+
+
+	// === SET MEMBERS ========================================================
 	template <typename T> void set(const T& x) { _set(x); }
 	void set(const float &x) { _set(Real(x)); }
 	void set(const list_type &x);
-	void set(const char* x);	
+	void set(const char* x);
+	void set(char* x);
 	void set(Canvas*x);
 	void set(etl::loose_handle<Canvas> x);
 	void set(etl::handle<Canvas> x);
 	template <class T> void set(const std::vector<T> &x)
 		{ _set(list_type(x.begin(),x.end())); }
 	template <class T> void set(const std::list<T> &x)
-		{ _set(list_type(x.begin(),x.end())); }	
+		{ _set(list_type(x.begin(),x.end())); }
 	// ========================================================================
 
-		
+
 	/*
  --	** -- S T A T I C   F U N C T I O N S -------------------------------------
 	*/
@@ -267,35 +280,38 @@ public:
 	//!	Returns a string containing the name of the given Type
 	static String type_name(Type id);
 
+	//!	Returns a string containing the translated name of the given Type
+	static String type_local_name(Type id);
+
 	//!	Returns a the corresponding Type of the described type
 	static Type ident_type(const String &str);
 
 
-	// === GET TYPE MEMBERS ===================================================	
-	static const Type get_type(bool) { return TYPE_BOOL; }
-	static const Type get_type(int) { return TYPE_INTEGER; }
-	static const Type get_type(const Time&) { return TYPE_TIME; }
-	static const Type get_type(const Real&) { return TYPE_REAL; }
-	static const Type get_type(const float&) { return TYPE_REAL; }
-	static const Type get_type(const Vector&) { return TYPE_VECTOR; }
-	static const Type get_type(const Color&) { return TYPE_COLOR; }
-	static const Type get_type(const Segment&) { return TYPE_SEGMENT; }
-	static const Type get_type(const BLinePoint&) { return TYPE_BLINEPOINT; }
-	static const Type get_type(const String&) { return TYPE_STRING; }
-	static const Type get_type(const Gradient&) { return TYPE_GRADIENT; }
-	static const Type get_type(Canvas*) { return TYPE_CANVAS; }
-	static const Type get_type(const etl::handle<Canvas>&)
+	// === GET TYPE MEMBERS ===================================================
+	static Type get_type(bool) { return TYPE_BOOL; }
+	static Type get_type(int) { return TYPE_INTEGER; }
+	static Type get_type(const Time&) { return TYPE_TIME; }
+	static Type get_type(const Real&) { return TYPE_REAL; }
+	static Type get_type(const float&) { return TYPE_REAL; }
+	static Type get_type(const Vector&) { return TYPE_VECTOR; }
+	static Type get_type(const Color&) { return TYPE_COLOR; }
+	static Type get_type(const Segment&) { return TYPE_SEGMENT; }
+	static Type get_type(const BLinePoint&) { return TYPE_BLINEPOINT; }
+	static Type get_type(const String&) { return TYPE_STRING; }
+	static Type get_type(const Gradient&) { return TYPE_GRADIENT; }
+	static Type get_type(Canvas*) { return TYPE_CANVAS; }
+	static Type get_type(const etl::handle<Canvas>&)
 		{ return TYPE_CANVAS; }
-	static const Type get_type(const etl::loose_handle<Canvas>&)
-		{ return TYPE_CANVAS; }	
-	static const Type get_type(const list_type&) { return TYPE_LIST; }
-	template <class T> static const Type get_type(const std::vector<T> &x)
+	static Type get_type(const etl::loose_handle<Canvas>&)
+		{ return TYPE_CANVAS; }
+	static Type get_type(const list_type&) { return TYPE_LIST; }
+	template <class T> static Type get_type(const std::vector<T> &/*x*/)
 		{ return TYPE_LIST; }
-	template <class T> static const Type get_type(const std::list<T> &x)
+	template <class T> static Type get_type(const std::list<T> &/*x*/)
 		{ return TYPE_LIST; }
 	// ========================================================================
 
-		
+
 	/*
  --	** -- C A S T   O P E R A T O R S -----------------------------------------
 	*/
@@ -306,7 +322,7 @@ public:
 	//operator const Color&()const { return get(Color()); }
 	//operator const Real&()const { return get(Real()); }
 	//operator const Time&()const { return get(Time()); }
-	
+
 	operator const Vector&()const {  return get(Vector()); }
 	operator const BLinePoint&()const {  return get(BLinePoint()); }
 	//operator const int&()const {  return get(int()); }
@@ -325,13 +341,13 @@ public:
 	half get(const half &)const { return get(Real()); }
 	void put(half*x)const { *x=get(Real()); }
 	void set(const half &x) { _set(Real(x)); }
-	static const Type get_type(const half&) { return TYPE_REAL; }
+	static Type get_type(const half&) { return TYPE_REAL; }
 	operator half()const { return get(Real()); }
 #endif
-	
+
 #ifndef SYNFIG_NO_ANGLE
 	operator const Angle&()const { return get(Angle()); }
-	static const Type get_type(const Angle&) { return TYPE_ANGLE; }
+	static Type get_type(const Angle&) { return TYPE_ANGLE; }
 #endif
 
 	template <class T>
@@ -349,16 +365,16 @@ public:
 		return ret;
 	}
 
-	
+
 private:
-	
+
 	template <typename T> void
 	_set(const T& x)
 	{
 		const Type newtype(get_type(x));
-		
+
 		assert(newtype!=TYPE_NIL);
-		
+
 		if(newtype==type)
 		{
 			if(ref_count.unique())
@@ -373,7 +389,7 @@ private:
 		type=newtype;
 		ref_count.reset();
 		data=new T(x);
-	}	
+	}
 }; // END of class ValueBase
 
 
@@ -387,21 +403,21 @@ public:
 	Value(const T &x):ValueBase(x)
 	{
 	}
-	
+
 	Value(const ValueBase &x):ValueBase(x)
 	{
-		if(!x.same_as(T()))
+		if(!x.same_type_as(T()))
 			throw Exception::BadType("Value<T>(ValueBase): Type Mismatch");
 	}
-	
+
 	Value()
 	{
 	}
-	
+
 	T get()const { return ValueBase::get(T()); }
 
 	void put(T* x)const	{ ValueBase::put(x); }
-	
+
 	void set(const T& x) { ValueBase::operator=(x); }
 
 	Value<T>& operator=(const T& x) { set(x); return *this; }
@@ -410,11 +426,11 @@ public:
 
 	Value<T>& operator=(const ValueBase& x)
 	{
-		if(!x.same_as(T()))
+		if(!x.same_type_as(T()))
 			throw Exception::BadType("Value<T>(ValueBase): Type Mismatch");
 		return ValueBase::operator=(x);
 	}
-	
+
 }; // END of class Value
 
 /*
@@ -427,17 +443,17 @@ public:
 	}
 	Value(const ValueBase &x):ValueBase(x)
 	{
-		if(!x.same_as(T()))
+		if(!x.same_type_as(T()))
 			throw Exception::BadType("Value<T>(ValueBase): Type Mismatch");
 	}
 	Value()
 	{
 	}
-	
+
 	T get()const { return ValueBase::get(T()); }
 
 	void put(T* x)const	{ ValueBase::put(x); }
-	
+
 	void set(const T& x) { ValueBase::operator=(x); }
 
 	Value<T>& operator=(const T& x) { set(x); return *this; }
@@ -446,11 +462,11 @@ public:
 
 	Value<T>& operator=(const ValueBase& x)
 	{
-		if(!x.same_as(T()))
+		if(!x.same_type_as(T()))
 			throw Exception::BadType("Value<T>(ValueBase): Type Mismatch");
 		return ValueBase::operator=(x);
 	}
-	
+
 }; // END of class Value
 */