reflexion 0.1.6 → 0.1.7

data/ext/reflex/selector.cpp

@@ -0,0 +1,144 @@
+#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
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Reflex::Selector>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize_copy, obj)
+{
+	CHECK;
+	*THIS = to<Reflex::Selector&>(obj);
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_name, name)
+{
+	CHECK;
+	THIS->set_name(name.is_nil() ? NULL : name.c_str());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_name)
+{
+	CHECK;
+	return THIS->name() ? value(THIS->name()) : nil();
+}
+RUCY_END
+
+static
+RUCY_DEF1(add_tag, tag)
+{
+	CHECK;
+	THIS->add_tag(tag.c_str());
+}
+RUCY_END
+
+static
+RUCY_DEF1(remove_tag, tag)
+{
+	CHECK;
+	THIS->remove_tag(tag.c_str());
+}
+RUCY_END
+
+static
+RUCY_DEF0(each_tag)
+{
+	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;
+}
+RUCY_END
+
+static
+RUCY_DEF1(match, selector)
+{
+	CHECK;
+	return value(THIS->match(to<Reflex::Selector&>(selector)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(equal, selector)
+{
+	CHECK;
+	return value(*THIS == to<Reflex::Selector&>(selector));
+}
+RUCY_END
+
+
+void
+Init_selector ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cSelector = mReflex.define_class("Selector");
+	cSelector.define_alloc_func(alloc);
+	cSelector.define_private_method("initialize_copy", initialize_copy);
+	cSelector.define_method("name=", set_name);
+	cSelector.define_method("name",  get_name);
+	cSelector.define_method("add_tag",    add_tag);
+	cSelector.define_method("remove_tag", remove_tag);
+	cSelector.define_method("each_tag", each_tag);
+	cSelector.define_method("match", match);
+	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/ext/reflex/style.cpp

@@ -0,0 +1,277 @@
+#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
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Reflex::Style>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize_copy, obj)
+{
+	CHECK;
+	*THIS = to<Reflex::Style&>(obj);
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_name, name)
+{
+	CHECK;
+	THIS->set_name(name.is_nil() ? NULL : name.c_str());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_name)
+{
+	CHECK;
+	return THIS->name() ? value(THIS->name()) : nil();
+}
+RUCY_END
+
+static
+RUCY_DEF1(add_tag, tag)
+{
+	CHECK;
+	THIS->add_tag(tag.c_str());
+}
+RUCY_END
+
+static
+RUCY_DEF1(remove_tag, tag)
+{
+	CHECK;
+	THIS->remove_tag(tag.c_str());
+}
+RUCY_END
+
+static
+RUCY_DEF0(each_tag)
+{
+	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;
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_selector, selector)
+{
+	CHECK;
+	THIS->set_selector(to<Reflex::Selector>(selector));
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_selector)
+{
+	CHECK;
+	return value(THIS->selector());
+}
+RUCY_END
+
+static
+RUCY_DEFN(set_flow)
+{
+	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);
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_flow)
+{
+	CHECK;
+	Reflex::Style::Flow main, sub;
+	THIS->get_flow(&main, &sub);
+	return array(main, sub);
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_size, size)
+{
+	CHECK;
+	THIS->set_size(to<Reflex::StyleLength2>(size));
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_size)
+{
+	CHECK;
+	return value(THIS->size());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_position, position)
+{
+	CHECK;
+	THIS->set_position(to<Reflex::StyleLength4>(position));
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_position)
+{
+	CHECK;
+	return value(THIS->position());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_margin, margin)
+{
+	CHECK;
+	THIS->set_margin(to<Reflex::StyleLength4>(margin));
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_margin)
+{
+	CHECK;
+	return value(THIS->margin());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_padding, padding)
+{
+	CHECK;
+	THIS->set_padding(to<Reflex::StyleLength4>(padding));
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_padding)
+{
+	CHECK;
+	return value(THIS->padding());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_background_color, color)
+{
+	CHECK;
+	THIS->set_background_color(to<Reflex::Color&>(color));
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_background_color)
+{
+	CHECK;
+	return value(THIS->background_color());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_background_image, image)
+{
+	CHECK;
+	THIS->set_background_image(to<Reflex::Image&>(image));
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_background_image)
+{
+	CHECK;
+	return THIS->background_image() ? value(THIS->background_image()) : nil();
+}
+RUCY_END
+
+static
+RUCY_DEF1(equal, style)
+{
+	CHECK;
+	return value(*THIS == to<Reflex::Style&>(style));
+}
+RUCY_END
+
+
+void
+Init_style ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cStyle = mReflex.define_class("Style");
+	cStyle.define_alloc_func(alloc);
+	cStyle.define_private_method("initialize_copy", initialize_copy);
+	cStyle.define_method("name=", set_name);
+	cStyle.define_method("name",  get_name);
+	cStyle.define_method("add_tag",    add_tag);
+	cStyle.define_method("remove_tag", remove_tag);
+	cStyle.define_method("each_tag", each_tag);
+	cStyle.define_method("selector=", set_selector);
+	cStyle.define_method("selector", get_selector);
+	cStyle.define_method("set_flow", set_flow);
+	cStyle.define_method("get_flow", get_flow);
+	cStyle.define_method("size=", set_size);
+	cStyle.define_method("size",  get_size);
+	cStyle.define_method("position=", set_position);
+	cStyle.define_method("position",  get_position);
+	cStyle.define_method("margin=", set_margin);
+	cStyle.define_method("margin",  get_margin);
+	cStyle.define_method("padding=", set_padding);
+	cStyle.define_method("padding",  get_padding);
+	cStyle.define_method("background_color=", set_background_color);
+	cStyle.define_method("background_color",  get_background_color);
+	cStyle.define_method("background_image=", set_background_image);
+	cStyle.define_method("background_image",  get_background_image);
+	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/ext/reflex/style_length.cpp

@@ -0,0 +1,140 @@
+#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
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Reflex::StyleLength>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEF2(setup_num, 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);
+}
+RUCY_END
+
+static
+RUCY_DEF1(setup_str, str)
+{
+	CHECK;
+	THIS->reset(str.c_str());
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize_copy, obj)
+{
+	CHECK;
+	*THIS = to<Reflex::StyleLength&>(obj).copy();
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_value)
+{
+	CHECK;
+	return value(THIS->value());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_unit)
+{
+	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();
+	}
+}
+RUCY_END
+
+static
+RUCY_DEF0(to_s)
+{
+	CHECK;
+	return value(THIS->to_s());
+}
+RUCY_END
+
+
+void
+Init_style_length ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cStyleLength = mReflex.define_class("StyleLength");
+	cStyleLength.define_alloc_func(alloc);
+	cStyleLength.define_private_method("setup_num", setup_num);
+	cStyleLength.define_private_method("setup_str", setup_str);
+	cStyleLength.define_private_method("initialize_copy", initialize_copy);
+	cStyleLength.define_method("value",  get_value);
+	cStyleLength.define_method("unit",   get_unit);
+	cStyleLength.define_method("to_s", to_s);
+}
+
+
+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/ext/reflex/style_length2.cpp

@@ -0,0 +1,157 @@
+#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
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Reflex::StyleLength2>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize_copy, obj)
+{
+	CHECK;
+	*THIS = to<Reflex::StyleLength2&>(obj).copy();
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_width, width)
+{
+	CHECK;
+	THIS->set_width(to<Reflex::StyleLength>(width));
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_width)
+{
+	CHECK;
+	return value(THIS->width());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_height, height)
+{
+	CHECK;
+	THIS->set_height(to<Reflex::StyleLength>(height));
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_height)
+{
+	CHECK;
+	return value(THIS->height());
+}
+RUCY_END
+
+static
+RUCY_DEF2(set_at, index, 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);
+}
+RUCY_END
+
+static
+RUCY_DEF1(get_at, 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]);
+}
+RUCY_END
+
+
+void
+Init_style_length2 ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cStyleLength2 = mReflex.define_class("StyleLength2");
+	cStyleLength2.define_alloc_func(alloc);
+	cStyleLength2.define_private_method("initialize_copy", initialize_copy);
+	cStyleLength2.define_method("width=",  set_width);
+	cStyleLength2.define_method("width",   get_width);
+	cStyleLength2.define_method("height=", set_height);
+	cStyleLength2.define_method("height",  get_height);
+	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