reflexion 0.1.6 → 0.1.7

data/.doc/ext/reflex/style_length4.cpp

@@ -0,0 +1,192 @@
+#include "reflex/ruby/style_length.h"
+
+
+#include <rucy.h>
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+static Class cStyleLength4;
+
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::StyleLength4, cStyleLength4)
+
+#define THIS  to<Reflex::StyleLength4*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::StyleLength4, cStyleLength4, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Reflex::StyleLength4>(klass);
+}
+
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	CHECK;
+	*THIS = to<Reflex::StyleLength4&>(obj).copy();
+	return self;
+}
+
+static
+VALUE set_left(VALUE self, VALUE left)
+{
+	CHECK;
+	THIS->set_left(to<Reflex::StyleLength>(left));
+}
+
+static
+VALUE get_left(VALUE self)
+{
+	CHECK;
+	return value(THIS->left());
+}
+
+static
+VALUE set_top(VALUE self, VALUE top)
+{
+	CHECK;
+	THIS->set_top(to<Reflex::StyleLength>(top));
+}
+
+static
+VALUE get_top(VALUE self)
+{
+	CHECK;
+	return value(THIS->top());
+}
+
+static
+VALUE set_right(VALUE self, VALUE right)
+{
+	CHECK;
+	THIS->set_right(to<Reflex::StyleLength>(right));
+}
+
+static
+VALUE get_right(VALUE self)
+{
+	CHECK;
+	return value(THIS->right());
+}
+
+static
+VALUE set_bottom(VALUE self, VALUE bottom)
+{
+	CHECK;
+	THIS->set_bottom(to<Reflex::StyleLength>(bottom));
+}
+
+static
+VALUE get_bottom(VALUE self)
+{
+	CHECK;
+	return value(THIS->bottom());
+}
+
+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_length4 ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cStyleLength4 = rb_define_class_under(mReflex, "StyleLength4", rb_cObject);
+	rb_define_alloc_func(cStyleLength4, alloc);
+	rb_define_private_method(cStyleLength4, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	rb_define_method(cStyleLength4, "left=", RUBY_METHOD_FUNC(set_left), 1);
+	rb_define_method(cStyleLength4, "left", RUBY_METHOD_FUNC(get_left), 0);
+	rb_define_method(cStyleLength4, "top=", RUBY_METHOD_FUNC(set_top), 1);
+	rb_define_method(cStyleLength4, "top", RUBY_METHOD_FUNC(get_top), 0);
+	rb_define_method(cStyleLength4, "right=", RUBY_METHOD_FUNC(set_right), 1);
+	rb_define_method(cStyleLength4, "right", RUBY_METHOD_FUNC(get_right), 0);
+	rb_define_method(cStyleLength4, "bottom=", RUBY_METHOD_FUNC(set_bottom), 1);
+	rb_define_method(cStyleLength4, "bottom", RUBY_METHOD_FUNC(get_bottom), 0);
+	cStyleLength4.define_method("[]=", set_at);
+	cStyleLength4.define_method("[]",  get_at);
+}
+
+
+namespace Rucy
+{
+
+
+	template <> Reflex::StyleLength4
+	value_to<Reflex::StyleLength4> (Value value, bool convert)
+	{
+		if (convert && value.is_array())
+		{
+			Value* a = value.as_array();
+			switch (value.size())
+			{
+				case 1: return Reflex::StyleLength4(
+					to<Reflex::StyleLength>(a[0]));
+
+				case 2: return Reflex::StyleLength4(
+					to<Reflex::StyleLength>(a[0]),
+					to<Reflex::StyleLength>(a[1]));
+
+				case 3: return Reflex::StyleLength4(
+					to<Reflex::StyleLength>(a[0]),
+					to<Reflex::StyleLength>(a[1]),
+					to<Reflex::StyleLength>(a[2]));
+
+				case 4: return Reflex::StyleLength4(
+					to<Reflex::StyleLength>(a[0]),
+					to<Reflex::StyleLength>(a[1]),
+					to<Reflex::StyleLength>(a[2]),
+					to<Reflex::StyleLength>(a[3]));
+
+				default: argument_error(__FILE__, __LINE__);
+			}
+		}
+
+		return value_to<Reflex::StyleLength4&>(value, convert);
+	}
+
+
+}// Rucy
+
+
+namespace Reflex
+{
+
+
+	Class
+	style_length4_class ()
+	{
+		return cStyleLength4;
+	}
+
+
+}// Reflex

data/.doc/ext/reflex/update_event.cpp

@@ -0,0 +1,77 @@
+#include "reflex/ruby/event.h"
+
+
+#include <rucy.h>
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+static Class cUpdateEvent;
+
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::UpdateEvent, cUpdateEvent)
+
+#define THIS  to<Reflex::UpdateEvent*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::UpdateEvent, cUpdateEvent, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Reflex::UpdateEvent>(klass);
+}
+
+static
+VALUE initialize(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "UpdateEvent#initialize", argc, 0, 1);
+
+	THIS->dt = (argc >= 1) ? argv[0].as_f() : 0;
+
+	return rb_call_super(0, NULL);
+}
+
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	CHECK;
+	*THIS = to<Reflex::UpdateEvent&>(obj);
+	return self;
+}
+
+static
+VALUE dt(VALUE self)
+{
+	CHECK;
+	return value(THIS->dt);
+}
+
+
+void
+Init_update_event ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cUpdateEvent = mReflex.define_class("UpdateEvent", Reflex::event_class());
+	rb_define_alloc_func(cUpdateEvent, alloc);
+	rb_define_private_method(cUpdateEvent, "initialize", RUBY_METHOD_FUNC(initialize), -1);
+	rb_define_private_method(cUpdateEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	rb_define_method(cUpdateEvent, "dt", RUBY_METHOD_FUNC(dt), 0);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	update_event_class ()
+	{
+		return cUpdateEvent;
+	}
+
+
+}// Reflex