reflexion 0.1.6 → 0.1.7

data/.doc/ext/reflex/selector.cpp

@@ -0,0 +1,135 @@
+#include "reflex/ruby/selector.h"
+
+
+#include <rucy.h>
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+static Class cSelector;
+
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::Selector, cSelector)
+
+#define THIS  to<Reflex::Selector*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::Selector, cSelector, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Reflex::Selector>(klass);
+}
+
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	CHECK;
+	*THIS = to<Reflex::Selector&>(obj);
+	return self;
+}
+
+static
+VALUE set_name(VALUE self, VALUE name)
+{
+	CHECK;
+	THIS->set_name(name.is_nil() ? NULL : name.c_str());
+}
+
+static
+VALUE get_name(VALUE self)
+{
+	CHECK;
+	return THIS->name() ? value(THIS->name()) : nil();
+}
+
+static
+VALUE add_tag(VALUE self, VALUE tag)
+{
+	CHECK;
+	THIS->add_tag(tag.c_str());
+}
+
+static
+VALUE remove_tag(VALUE self, VALUE tag)
+{
+	CHECK;
+	THIS->remove_tag(tag.c_str());
+}
+
+static
+VALUE each_tag(VALUE self)
+{
+	CHECK;
+
+	Value ret;
+	Reflex::Selector::iterator end = THIS->end();
+	for (Reflex::Selector::iterator it = THIS->begin(); it != end; ++it)
+		ret = rb_yield(value(*it));
+	return ret;
+}
+
+static
+VALUE match(VALUE self, VALUE selector)
+{
+	CHECK;
+	return value(THIS->match(to<Reflex::Selector&>(selector)));
+}
+
+static
+VALUE equal(VALUE self, VALUE selector)
+{
+	CHECK;
+	return value(*THIS == to<Reflex::Selector&>(selector));
+}
+
+
+void
+Init_selector ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cSelector = rb_define_class_under(mReflex, "Selector", rb_cObject);
+	rb_define_alloc_func(cSelector, alloc);
+	rb_define_private_method(cSelector, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	rb_define_method(cSelector, "name=", RUBY_METHOD_FUNC(set_name), 1);
+	rb_define_method(cSelector, "name", RUBY_METHOD_FUNC(get_name), 0);
+	rb_define_method(cSelector, "add_tag", RUBY_METHOD_FUNC(add_tag), 1);
+	rb_define_method(cSelector, "remove_tag", RUBY_METHOD_FUNC(remove_tag), 1);
+	rb_define_method(cSelector, "each_tag", RUBY_METHOD_FUNC(each_tag), 0);
+	rb_define_method(cSelector, "match", RUBY_METHOD_FUNC(match), 1);
+	cSelector.define_method("==", equal);
+}
+
+
+namespace Rucy
+{
+
+
+	template <> Reflex::Selector
+	value_to<Reflex::Selector> (Value value, bool convert)
+	{
+		if (convert && (value.is_s() || value.is_sym()))
+			return Reflex::Selector(value.c_str());
+
+		return value_to<Reflex::Selector&>(value, convert);
+	}
+
+
+}// Rucy
+
+
+namespace Reflex
+{
+
+
+	Class
+	selector_class ()
+	{
+		return cSelector;
+	}
+
+
+}// Reflex

data/.doc/ext/reflex/style.cpp

@@ -0,0 +1,253 @@
+#include "reflex/ruby/style.h"
+
+
+#include <rucy.h>
+#include "rays/ruby/color.h"
+#include "rays/ruby/image.h"
+#include "reflex/ruby/selector.h"
+#include "reflex/ruby/style_length.h"
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+static Class cStyle;
+
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::Style, cStyle)
+
+#define THIS  to<Reflex::Style*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::Style, cStyle, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Reflex::Style>(klass);
+}
+
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	CHECK;
+	*THIS = to<Reflex::Style&>(obj);
+	return self;
+}
+
+static
+VALUE set_name(VALUE self, VALUE name)
+{
+	CHECK;
+	THIS->set_name(name.is_nil() ? NULL : name.c_str());
+}
+
+static
+VALUE get_name(VALUE self)
+{
+	CHECK;
+	return THIS->name() ? value(THIS->name()) : nil();
+}
+
+static
+VALUE add_tag(VALUE self, VALUE tag)
+{
+	CHECK;
+	THIS->add_tag(tag.c_str());
+}
+
+static
+VALUE remove_tag(VALUE self, VALUE tag)
+{
+	CHECK;
+	THIS->remove_tag(tag.c_str());
+}
+
+static
+VALUE each_tag(VALUE self)
+{
+	CHECK;
+
+	Value ret;
+	Reflex::Style::tag_iterator end = THIS->tag_end();
+	for (Reflex::Style::tag_iterator it = THIS->tag_begin(); it != end; ++it)
+		ret = rb_yield(value(*it));
+	return ret;
+}
+
+static
+VALUE set_selector(VALUE self, VALUE selector)
+{
+	CHECK;
+	THIS->set_selector(to<Reflex::Selector>(selector));
+}
+
+static
+VALUE get_selector(VALUE self)
+{
+	CHECK;
+	return value(THIS->selector());
+}
+
+static
+VALUE set_flow(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Style#set_flow", argc, 1, 2);
+
+	THIS->set_flow(
+		argc >= 1 ? (Reflex::Style::Flow) argv[0].as_i() : Reflex::Style::FLOW_DOWN,
+		argc >= 2 ? (Reflex::Style::Flow) argv[1].as_i() : Reflex::Style::FLOW_NONE);
+}
+
+static
+VALUE get_flow(VALUE self)
+{
+	CHECK;
+	Reflex::Style::Flow main, sub;
+	THIS->get_flow(&main, &sub);
+	return array(main, sub);
+}
+
+static
+VALUE set_size(VALUE self, VALUE size)
+{
+	CHECK;
+	THIS->set_size(to<Reflex::StyleLength2>(size));
+}
+
+static
+VALUE get_size(VALUE self)
+{
+	CHECK;
+	return value(THIS->size());
+}
+
+static
+VALUE set_position(VALUE self, VALUE position)
+{
+	CHECK;
+	THIS->set_position(to<Reflex::StyleLength4>(position));
+}
+
+static
+VALUE get_position(VALUE self)
+{
+	CHECK;
+	return value(THIS->position());
+}
+
+static
+VALUE set_margin(VALUE self, VALUE margin)
+{
+	CHECK;
+	THIS->set_margin(to<Reflex::StyleLength4>(margin));
+}
+
+static
+VALUE get_margin(VALUE self)
+{
+	CHECK;
+	return value(THIS->margin());
+}
+
+static
+VALUE set_padding(VALUE self, VALUE padding)
+{
+	CHECK;
+	THIS->set_padding(to<Reflex::StyleLength4>(padding));
+}
+
+static
+VALUE get_padding(VALUE self)
+{
+	CHECK;
+	return value(THIS->padding());
+}
+
+static
+VALUE set_background_color(VALUE self, VALUE color)
+{
+	CHECK;
+	THIS->set_background_color(to<Reflex::Color&>(color));
+}
+
+static
+VALUE get_background_color(VALUE self)
+{
+	CHECK;
+	return value(THIS->background_color());
+}
+
+static
+VALUE set_background_image(VALUE self, VALUE image)
+{
+	CHECK;
+	THIS->set_background_image(to<Reflex::Image&>(image));
+}
+
+static
+VALUE get_background_image(VALUE self)
+{
+	CHECK;
+	return THIS->background_image() ? value(THIS->background_image()) : nil();
+}
+
+static
+VALUE equal(VALUE self, VALUE style)
+{
+	CHECK;
+	return value(*THIS == to<Reflex::Style&>(style));
+}
+
+
+void
+Init_style ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cStyle = rb_define_class_under(mReflex, "Style", rb_cObject);
+	rb_define_alloc_func(cStyle, alloc);
+	rb_define_private_method(cStyle, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	rb_define_method(cStyle, "name=", RUBY_METHOD_FUNC(set_name), 1);
+	rb_define_method(cStyle, "name", RUBY_METHOD_FUNC(get_name), 0);
+	rb_define_method(cStyle, "add_tag", RUBY_METHOD_FUNC(add_tag), 1);
+	rb_define_method(cStyle, "remove_tag", RUBY_METHOD_FUNC(remove_tag), 1);
+	rb_define_method(cStyle, "each_tag", RUBY_METHOD_FUNC(each_tag), 0);
+	rb_define_method(cStyle, "selector=", RUBY_METHOD_FUNC(set_selector), 1);
+	rb_define_method(cStyle, "selector", RUBY_METHOD_FUNC(get_selector), 0);
+	rb_define_method(cStyle, "set_flow", RUBY_METHOD_FUNC(set_flow), -1);
+	rb_define_method(cStyle, "get_flow", RUBY_METHOD_FUNC(get_flow), 0);
+	rb_define_method(cStyle, "size=", RUBY_METHOD_FUNC(set_size), 1);
+	rb_define_method(cStyle, "size", RUBY_METHOD_FUNC(get_size), 0);
+	rb_define_method(cStyle, "position=", RUBY_METHOD_FUNC(set_position), 1);
+	rb_define_method(cStyle, "position", RUBY_METHOD_FUNC(get_position), 0);
+	rb_define_method(cStyle, "margin=", RUBY_METHOD_FUNC(set_margin), 1);
+	rb_define_method(cStyle, "margin", RUBY_METHOD_FUNC(get_margin), 0);
+	rb_define_method(cStyle, "padding=", RUBY_METHOD_FUNC(set_padding), 1);
+	rb_define_method(cStyle, "padding", RUBY_METHOD_FUNC(get_padding), 0);
+	rb_define_method(cStyle, "background_color=", RUBY_METHOD_FUNC(set_background_color), 1);
+	rb_define_method(cStyle, "background_color", RUBY_METHOD_FUNC(get_background_color), 0);
+	rb_define_method(cStyle, "background_image=", RUBY_METHOD_FUNC(set_background_image), 1);
+	rb_define_method(cStyle, "background_image", RUBY_METHOD_FUNC(get_background_image), 0);
+	cStyle.define_method("==", equal);
+	cStyle.define_const("FLOW_NONE",  Reflex::Style::FLOW_NONE);
+	cStyle.define_const("FLOW_DOWN",  Reflex::Style::FLOW_DOWN);
+	cStyle.define_const("FLOW_RIGHT", Reflex::Style::FLOW_RIGHT);
+	cStyle.define_const("FLOW_UP",    Reflex::Style::FLOW_UP);
+	cStyle.define_const("FLOW_LEFT",  Reflex::Style::FLOW_LEFT);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	style_class ()
+	{
+		return cStyle;
+	}
+
+
+}// Reflex

data/.doc/ext/reflex/style_length.cpp

@@ -0,0 +1,133 @@
+#include "reflex/ruby/style_length.h"
+
+
+#include <rucy.h>
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+static Class cStyleLength;
+
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::StyleLength, cStyleLength)
+
+#define THIS  to<Reflex::StyleLength*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::StyleLength, cStyleLength, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Reflex::StyleLength>(klass);
+}
+
+static
+VALUE setup_num(VALUE self, VALUE value, VALUE unit)
+{
+	CHECK;
+
+	const char* str = unit.as_s(true);
+	Reflex::StyleLength::Unit u = Reflex::StyleLength::NONE;
+	     if (strcasecmp(str, "px") == 0) u = Reflex::StyleLength::PIXEL;
+	else if (strcasecmp(str, "%")  == 0) u = Reflex::StyleLength::PERCENT;
+	else argument_error(__FILE__, __LINE__);
+	THIS->reset(value.as_f(true), u);
+}
+
+static
+VALUE setup_str(VALUE self, VALUE str)
+{
+	CHECK;
+	THIS->reset(str.c_str());
+}
+
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	CHECK;
+	*THIS = to<Reflex::StyleLength&>(obj).copy();
+	return self;
+}
+
+static
+VALUE get_value(VALUE self)
+{
+	CHECK;
+	return value(THIS->value());
+}
+
+static
+VALUE get_unit(VALUE self)
+{
+	CHECK;
+
+	RUCY_SYMBOL(pixel,   "px");
+	RUCY_SYMBOL(percent, "%");
+	switch (THIS->unit())
+	{
+		case Reflex::StyleLength::PIXEL:   return pixel.value();
+		case Reflex::StyleLength::PERCENT: return percent.value();
+		default:                           return nil();
+	}
+}
+
+static
+VALUE to_s(VALUE self)
+{
+	CHECK;
+	return value(THIS->to_s());
+}
+
+
+void
+Init_style_length ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cStyleLength = rb_define_class_under(mReflex, "StyleLength", rb_cObject);
+	rb_define_alloc_func(cStyleLength, alloc);
+	rb_define_private_method(cStyleLength, "setup_num", RUBY_METHOD_FUNC(setup_num), 2);
+	rb_define_private_method(cStyleLength, "setup_str", RUBY_METHOD_FUNC(setup_str), 1);
+	rb_define_private_method(cStyleLength, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	rb_define_method(cStyleLength, "value", RUBY_METHOD_FUNC(get_value), 0);
+	rb_define_method(cStyleLength, "unit", RUBY_METHOD_FUNC(get_unit), 0);
+	rb_define_method(cStyleLength, "to_s", RUBY_METHOD_FUNC(to_s), 0);
+}
+
+
+namespace Rucy
+{
+
+
+	template <> Reflex::StyleLength
+	value_to<Reflex::StyleLength> (Value value, bool convert)
+	{
+		if (convert)
+		{
+			     if (value.is_nil()) return Reflex::StyleLength();
+			else if (value.is_i())   return Reflex::StyleLength(value.as_i());
+			else if (value.is_f())   return Reflex::StyleLength(value.as_f());
+			else if (value.is_s())   return Reflex::StyleLength(value.c_str());
+		}
+
+		return value_to<Reflex::StyleLength&>(value, convert);
+	}
+
+
+}// Rucy
+
+
+namespace Reflex
+{
+
+
+	Class
+	style_length_class ()
+	{
+		return cStyleLength;
+	}
+
+
+}// Reflex

data/.doc/ext/reflex/style_length2.cpp

@@ -0,0 +1,149 @@
+#include "reflex/ruby/style_length.h"
+
+
+#include <rucy.h>
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+static Class cStyleLength2;
+
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::StyleLength2, cStyleLength2)
+
+#define THIS  to<Reflex::StyleLength2*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::StyleLength2, cStyleLength2, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Reflex::StyleLength2>(klass);
+}
+
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	CHECK;
+	*THIS = to<Reflex::StyleLength2&>(obj).copy();
+	return self;
+}
+
+static
+VALUE set_width(VALUE self, VALUE width)
+{
+	CHECK;
+	THIS->set_width(to<Reflex::StyleLength>(width));
+}
+
+static
+VALUE get_width(VALUE self)
+{
+	CHECK;
+	return value(THIS->width());
+}
+
+static
+VALUE set_height(VALUE self, VALUE height)
+{
+	CHECK;
+	THIS->set_height(to<Reflex::StyleLength>(height));
+}
+
+static
+VALUE get_height(VALUE self)
+{
+	CHECK;
+	return value(THIS->height());
+}
+
+static
+VALUE set_at(VALUE self, VALUE index, VALUE length)
+{
+	CHECK;
+
+	int i = index.as_i(), size = (int) THIS->size();
+	while (i < 0) i += size;
+
+	if (i >= size)
+		index_error(__FILE__, __LINE__);
+
+	(*THIS)[i] = to<Reflex::StyleLength>(length);
+}
+
+static
+VALUE get_at(VALUE self, VALUE index)
+{
+	CHECK;
+
+	int i = index.as_i(), size = (int) THIS->size();
+	while (i < 0) i += size;
+
+	if (i >= size)
+		index_error(__FILE__, __LINE__);
+
+	return value((*THIS)[i]);
+}
+
+
+void
+Init_style_length2 ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cStyleLength2 = rb_define_class_under(mReflex, "StyleLength2", rb_cObject);
+	rb_define_alloc_func(cStyleLength2, alloc);
+	rb_define_private_method(cStyleLength2, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	rb_define_method(cStyleLength2, "width=", RUBY_METHOD_FUNC(set_width), 1);
+	rb_define_method(cStyleLength2, "width", RUBY_METHOD_FUNC(get_width), 0);
+	rb_define_method(cStyleLength2, "height=", RUBY_METHOD_FUNC(set_height), 1);
+	rb_define_method(cStyleLength2, "height", RUBY_METHOD_FUNC(get_height), 0);
+	cStyleLength2.define_method("[]=", set_at);
+	cStyleLength2.define_method("[]",  get_at);
+}
+
+
+namespace Rucy
+{
+
+
+	template <> Reflex::StyleLength2
+	value_to<Reflex::StyleLength2> (Value value, bool convert)
+	{
+		if (convert && value.is_array())
+		{
+			Value* a = value.as_array();
+			switch (value.size())
+			{
+				case 1: return Reflex::StyleLength2(
+					to<Reflex::StyleLength>(a[0]));
+
+				case 2: return Reflex::StyleLength2(
+					to<Reflex::StyleLength>(a[0]),
+					to<Reflex::StyleLength>(a[1]));
+
+				default: argument_error(__FILE__, __LINE__);
+			}
+		}
+
+		return value_to<Reflex::StyleLength2&>(value, convert);
+	}
+
+
+}// Rucy
+
+
+namespace Reflex
+{
+
+
+	Class
+	style_length2_class ()
+	{
+		return cStyleLength2;
+	}
+
+
+}// Reflex