reflexion 0.1.6 → 0.1.7

data/src/style.cpp

@@ -0,0 +1,576 @@
+#include "reflex/style.h"
+
+
+#include <boost/noncopyable.hpp>
+#include "reflex/view.h"
+#include "reflex/exception.h"
+
+
+namespace Reflex
+{
+
+
+	template <typename T>
+	class StyleValue
+	{
+
+		typedef StyleValue<T> This;
+
+		typedef T Value;
+
+		class Wrapper : public boost::noncopyable, public Xot::RefCountable<>
+		{
+
+			public:
+
+				Wrapper () {}
+
+				Wrapper (const Value& value) : value(value) {}
+
+				void reset (const Value& value_) {value = value_;}
+
+				      Value& get ()       {return value;}
+
+				const Value& get () const {return value;}
+
+			private:
+
+				Value value;
+
+		};// Wrapper
+
+		public:
+
+			StyleValue ()
+			:	pwrapper(NULL)
+			{
+			}
+
+			StyleValue (const Value& value)
+			:	pwrapper(NULL)
+			{
+				operator=(value);
+			}
+
+			StyleValue (const This& obj)
+			:	pwrapper(NULL)
+			{
+				operator=(obj);
+			}
+
+			This& operator = (const Value& value)
+			{
+				reset(new Wrapper(value));
+				return *this;
+			}
+
+			This& operator = (const This& obj)
+			{
+				if (&obj != this) reset(obj.pwrapper);
+				return *this;
+			}
+
+			~StyleValue ()
+			{
+				clear();
+			}
+
+			void clear ()
+			{
+				reset();
+			}
+
+			Value& value (bool create = false)
+			{
+				Wrapper* p = pointer();
+				if (!p)
+				{
+					if (create)
+						p = reset(new Wrapper());
+					else
+						invalid_state_error(__FILE__, __LINE__);
+				}
+				return p->get();
+			}
+
+			const Value& value (bool create = false) const
+			{
+				return const_cast<This*>(this)->value(create);
+			}
+
+			void set_inherited (bool state = true)
+			{
+				if (pointer()) pwrapper = Xot::set_pointer_flag(pwrapper, state);
+			}
+
+			bool is_inherited () const
+			{
+				return get_pointer_flag(pwrapper);
+			}
+
+			operator bool () const {return pointer() != NULL;}
+
+			bool operator ! () const {return !operator bool();}
+
+		private:
+
+			Wrapper* pwrapper;
+
+			Wrapper* reset (Wrapper* ptr = NULL)
+			{
+				Wrapper* p = pointer();
+				if (ptr != p)
+				{
+					if (p) p->release();
+					pwrapper = p = ptr;
+					if (p) p->retain();
+				}
+				return p;
+			}
+
+			      Wrapper* pointer ()       {return Xot::set_pointer_flag(pwrapper, false);}
+
+			const Wrapper* pointer () const {return const_cast<StyleValue*>(this)->pointer();}
+
+	};// StyleValue
+
+
+	struct Style::Data : public Xot::RefCountable<>
+	{
+
+		typedef StyleValue<bool>         Bool;
+
+		typedef StyleValue<int>          Int;
+
+		typedef StyleValue<double>       Float;
+
+		typedef StyleValue<StyleLength>  Length;
+
+		typedef StyleValue<StyleLength2> Length2;
+
+		typedef StyleValue<StyleLength4> Length4;
+
+		typedef StyleValue<Rays::Color>  Color;
+
+		typedef StyleValue<Rays::Image>  Image;
+
+		View* owner;
+
+		Selector selector;
+
+		Int flow_main, flow_sub;
+
+		Length2 size;
+
+		Length4 position, offset, margin, padding;
+
+		Color background_color;
+
+		Image background_image;
+
+		Data () : owner(NULL) {}
+
+	};// Style::Data
+
+
+	namespace Zero
+	{
+
+		static const StyleLength  length;
+
+		static const StyleLength2 length2;
+
+		static const StyleLength4 length4;
+
+		static const Color        color(0);
+
+		static const Image        image;
+
+	}// Zero
+
+
+	static Style::Data*
+	get_data (Style* this_, bool create = false)
+	{
+		if (!this_)
+			argument_error(__FILE__, __LINE__);
+
+		if (create && !this_->ref)
+			this_->ref.reset(new Style::Data());
+
+		return this_->ref.get();
+	}
+
+	static const Style::Data*
+	get_data (const Style* this_)
+	{
+		return get_data(const_cast<Style*>(this_));
+	}
+
+
+	Style::Style (const char* name)
+	{
+		if (name) set_name(name);
+	}
+
+	Style::Style (const This& obj)
+	:	ref(obj.ref)
+	{
+	}
+
+	Style&
+	Style::operator = (const This& obj)
+	{
+		if (&obj != this) ref = obj.ref;
+		return *this;
+	}
+
+	Style::~Style ()
+	{
+	}
+
+	void
+	Style::set_name (const char* name)
+	{
+		get_data(this, true)->selector.set_name(name);
+	}
+
+	const char*
+	Style::name () const
+	{
+		const Data* data = get_data(this);
+		return data ? data->selector.name() : NULL;
+	}
+
+	void
+	Style::add_tag (const char* tag)
+	{
+		get_data(this, true)->selector.add_tag(tag);
+	}
+
+	void
+	Style::remove_tag (const char* tag)
+	{
+		Data* data = get_data(this);
+		if (!data) return;
+
+		data->selector.remove_tag(tag);
+	}
+
+	static Selector::TagSet empty_tags;
+
+	Selector::iterator
+	Style::tag_begin ()
+	{
+		Data* data = get_data(this);
+		return data ? data->selector.begin() : empty_tags.begin();
+	}
+
+	Selector::const_iterator
+	Style::tag_begin () const
+	{
+		const Data* data = get_data(this);
+		return data ? data->selector.begin() : empty_tags.begin();
+	}
+
+	Selector::iterator
+	Style::tag_end ()
+	{
+		Data* data = get_data(this);
+		return data ? data->selector.end() : empty_tags.end();
+	}
+
+	Selector::const_iterator
+	Style::tag_end () const
+	{
+		const Data* data = get_data(this);
+		return data ? data->selector.end() : empty_tags.end();
+	}
+
+	void
+	Style::set_selector (const Selector& selector)
+	{
+		get_data(this, true)->selector = selector;
+	}
+
+	Selector&
+	Style::selector ()
+	{
+		return get_data(this, true)->selector;
+	}
+
+	const Selector&
+	Style::selector () const
+	{
+		static const Selector EMPTY;
+
+		const Data* data = get_data(this);
+		return data ? data->selector : EMPTY;
+	}
+
+	enum FlowDir {FLOW_INVALID = 0, FLOW_H, FLOW_V};
+
+	static FlowDir
+	get_flow_dir (Style::Flow flow)
+	{
+		switch (flow)
+		{
+			case Style::FLOW_LEFT:
+			case Style::FLOW_RIGHT: return FLOW_H;
+			case Style::FLOW_UP:
+			case Style::FLOW_DOWN:  return FLOW_V;
+		}
+		return FLOW_INVALID;
+	}
+
+	void
+	Style::set_flow (Flow main, Flow sub)
+	{
+		if (
+			main <  FLOW_NONE || FLOW_LAST <= main ||
+			sub  <  FLOW_NONE || FLOW_LAST <= sub  ||
+			(main != FLOW_NONE && (get_flow_dir(main) == get_flow_dir(sub))) ||
+			(main == FLOW_NONE && sub != FLOW_NONE))
+		{
+			argument_error(__FILE__, __LINE__);
+		}
+
+		Data* data = get_data(this, true);
+		data->flow_main = main;
+		data->flow_sub  = sub;
+	}
+
+	void
+	Style::get_flow (Flow* main, Flow* sub) const
+	{
+		if (!main && !sub)
+			argument_error(__FILE__, __LINE__);
+
+		const Data* data = get_data(this);
+		if (!data || (!data->flow_main && !data->flow_sub))
+		{
+			if (main) *main = FLOW_DOWN;
+			if (sub)  *sub  = FLOW_NONE;
+		}
+		else if (data->flow_main && data->flow_sub)
+		{
+			if (main) *main = (Flow) data->flow_main.value();
+			if (sub)  *sub  = (Flow) data->flow_sub.value();
+		}
+		else
+			invalid_state_error(__FILE__, __LINE__);
+	}
+
+	void
+	Style::set_size (const StyleLength2& size)
+	{
+		get_data(this, true)->size = size;
+	}
+
+	void
+	Style::set_width (const StyleLength& width)
+	{
+		get_data(this, true)->size.value(true).set_width(width);
+	}
+
+	void
+	Style::set_height (const StyleLength& height)
+	{
+		get_data(this, true)->size.value(true).set_height(height);
+	}
+
+	const StyleLength2&
+	Style::size () const
+	{
+		const Data* data = get_data(this);
+		return data && data->size ? data->size.value() : Zero::length2;
+	}
+
+	void
+	Style::set_position (const StyleLength4& position)
+	{
+		get_data(this, true)->position = position;
+	}
+
+	void
+	Style::set_left (const StyleLength& left)
+	{
+		get_data(this, true)->position.value(true).set_left(left);
+	}
+
+	void
+	Style::set_top (const StyleLength& top)
+	{
+		get_data(this, true)->position.value(true).set_top(top);
+	}
+
+	void
+	Style::set_right (const StyleLength& right)
+	{
+		get_data(this, true)->position.value(true).set_right(right);
+	}
+
+	void
+	Style::set_bottom (const StyleLength& bottom)
+	{
+		get_data(this, true)->position.value(true).set_bottom(bottom);
+	}
+
+	const StyleLength4&
+	Style::position () const
+	{
+		const Data* data = get_data(this);
+		return data && data->position ? data->position.value() : Zero::length4;
+	}
+
+	void
+	Style::set_offset (const StyleLength4& offset)
+	{
+		get_data(this, true)->offset = offset;
+	}
+
+	void
+	Style::set_offset_left (const StyleLength& left)
+	{
+		get_data(this, true)->offset.value(true).set_left(left);
+	}
+
+	void
+	Style::set_offset_top (const StyleLength& top)
+	{
+		get_data(this, true)->offset.value(true).set_top(top);
+	}
+
+	void
+	Style::set_offset_right (const StyleLength& right)
+	{
+		get_data(this, true)->offset.value(true).set_right(right);
+	}
+
+	void
+	Style::set_offset_bottom (const StyleLength& bottom)
+	{
+		get_data(this, true)->offset.value(true).set_bottom(bottom);
+	}
+
+	const StyleLength4&
+	Style::offset () const
+	{
+		const Data* data = get_data(this);
+		return data && data->offset ? data->offset.value() : Zero::length4;
+	}
+
+	void
+	Style::set_margin (const StyleLength4& margin)
+	{
+		get_data(this, true)->margin = margin;
+	}
+
+	void
+	Style::set_margin_left (const StyleLength& left)
+	{
+		get_data(this, true)->margin.value(true).set_left(left);
+	}
+
+	void
+	Style::set_margin_top (const StyleLength& top)
+	{
+		get_data(this, true)->margin.value(true).set_top(top);
+	}
+
+	void
+	Style::set_margin_right (const StyleLength& right)
+	{
+		get_data(this, true)->margin.value(true).set_right(right);
+	}
+
+	void
+	Style::set_margin_bottom (const StyleLength& bottom)
+	{
+		get_data(this, true)->margin.value(true).set_bottom(bottom);
+	}
+
+	const StyleLength4&
+	Style::margin () const
+	{
+		const Data* data = get_data(this);
+		return data && data->margin ? data->margin.value() : Zero::length4;
+	}
+
+	void
+	Style::set_padding (const StyleLength4& padding)
+	{
+		get_data(this, true)->padding = padding;
+	}
+
+	void
+	Style::set_padding_left (const StyleLength& left)
+	{
+		get_data(this, true)->padding.value(true).set_left(left);
+	}
+
+	void
+	Style::set_padding_top (const StyleLength& top)
+	{
+		get_data(this, true)->padding.value(true).set_top(top);
+	}
+
+	void
+	Style::set_padding_right (const StyleLength& right)
+	{
+		get_data(this, true)->padding.value(true).set_right(right);
+	}
+
+	void
+	Style::set_padding_bottom (const StyleLength& bottom)
+	{
+		get_data(this, true)->padding.value(true).set_bottom(bottom);
+	}
+
+	const StyleLength4&
+	Style::padding () const
+	{
+		const Data* data = get_data(this);
+		return data && data->padding ? data->padding.value() : Zero::length4;
+	}
+
+	void
+	Style::set_background_color (const Color& value)
+	{
+		get_data(this, true)->background_color = value;
+	}
+
+	const Color&
+	Style::background_color () const
+	{
+		const Data* data = get_data(this);
+		return data && data->background_color ? data->background_color.value() : Zero::color;
+	}
+
+	void
+	Style::set_background_image (const Image& value)
+	{
+		get_data(this, true)->background_image = value;
+	}
+
+	const Image&
+	Style::background_image () const
+	{
+		const Data* data = get_data(this);
+		return data && data->background_image ? data->background_image.value() : Zero::image;
+	}
+
+	bool
+	operator == (const Style& lhs, const Style& rhs)
+	{
+		return lhs.ref == rhs.ref;
+	}
+
+	bool
+	operator != (const Style& lhs, const Style& rhs)
+	{
+		return !operator==(lhs, rhs);
+	}
+
+
+}// Reflex