reflexion 0.1.11 → 0.1.16

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

@@ -1,14 +1,10 @@
 #include "reflex/ruby/style.h"
 
 
-#include <rucy.h>
 #include "defs.h"
 
 
-using namespace Rucy;
-
-
-RUCY_DEFINE_VALUE_FROM_TO(Reflex::StyleLength)
+RUCY_DEFINE_VALUE_OR_ARRAY_FROM_TO(Reflex::StyleLength)
 
 #define THIS  to<Reflex::StyleLength*>(self)
 
@@ -21,61 +17,172 @@ VALUE alloc(VALUE klass)
 	return new_type<Reflex::StyleLength>(klass);
 }
 
-static
-VALUE setup_num(VALUE self, VALUE value, VALUE unit)
+static Reflex::StyleLength::Type
+str2type (const char* s)
 {
-	CHECK;
+	     if (strcasecmp(s, "px")   == 0) return Reflex::StyleLength::PIXEL;
+	else if (strcasecmp(s, "%")    == 0) return Reflex::StyleLength::PERCENT;
+	else if (strcasecmp(s, "fill") == 0) return Reflex::StyleLength::FILL;
+	else if (strcasecmp(s, "fit")  == 0) return Reflex::StyleLength::FIT;
+	else                                 return Reflex::StyleLength::NONE;
+}
 
-	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 const char*
+type2str (Reflex::StyleLength::Type type)
+{
+	switch (type)
+	{
+		case Reflex::StyleLength::PIXEL:   return "px";
+		case Reflex::StyleLength::PERCENT: return "%";
+		case Reflex::StyleLength::FILL:    return "fill";
+		case Reflex::StyleLength::FIT:     return "fit";
+		default:                           return NULL;
+	}
 }
 
-static
-VALUE setup_str(VALUE self, VALUE str)
+static bool
+get_default_value (
+	Reflex::StyleLength::Value* value, Reflex::StyleLength::Type type)
 {
-	CHECK;
-	THIS->reset(str.c_str());
+	assert(value);
+
+	switch (type)
+	{
+		case Reflex::StyleLength::FILL:
+			*value = 1;
+			break;
+
+		case Reflex::StyleLength::FIT:
+			*value = 1;
+			break;
+
+		default:
+			return false;
+	}
+
+	return true;
+}
+
+static bool
+scan_type_and_value (
+	Reflex::StyleLength::Type* type, Reflex::StyleLength::Value* value,
+	const char* str)
+{
+	assert(type && value);
+
+	if (!str || *str == '\0')
+		argument_error(__FILE__, __LINE__);
+
+	char buf[101];
+
+	if (sscanf(str, "%100s%f", buf, value) == 2)
+		argument_error(__FILE__, __LINE__);
+
+	int count = sscanf(str, "%f%100s", value, buf);
+	if (count == 2)
+	{
+		*type = str2type(buf);
+		return true;
+	}
+
+	count = sscanf(str, "%100s", buf);
+	if (count == 1)
+	{
+		*type = str2type(buf);
+		return get_default_value(value, *type);
+	}
+
+	return false;
 }
 
 static
-VALUE initialize_copy(VALUE self, VALUE obj)
+VALUE initialize(VALUE self)
 {
 	CHECK;
-	*THIS = to<Reflex::StyleLength&>(obj).copy();
-	return self;
+	check_arg_count(__FILE__, __LINE__, "StyleLength#initialize", argc, 0, 1);
+
+	if (argc == 0 || argv[0].is_nil())
+		THIS->reset();
+	else if (argv[0].is_i())
+		THIS->reset(Reflex::StyleLength::PIXEL, argv[0].as_i());
+	else if (argv[0].is_f())
+		THIS->reset(Reflex::StyleLength::PIXEL, argv[0].as_f());
+	else if (argv[0].is_s() || argv[0].is_sym())
+	{
+		Reflex::StyleLength::Type type   = Reflex::StyleLength::NONE;
+		Reflex::StyleLength::Value value = 0;
+		if (!scan_type_and_value(&type, &value, argv[0].c_str()))
+			argument_error(__FILE__, __LINE__);
+
+		THIS->reset(type, value);
+	}
 }
 
 static
-VALUE get_value(VALUE self)
+VALUE initialize_copy(VALUE self, VALUE obj)
 {
 	CHECK;
-	return value(THIS->value());
+	*THIS = to<Reflex::StyleLength&>(obj).copy();
+	return self;
 }
 
 static
-VALUE get_unit(VALUE self)
+VALUE get_type(VALUE self)
 {
 	CHECK;
 
 	RUCY_SYMBOL(pixel,   "px");
 	RUCY_SYMBOL(percent, "%");
-	switch (THIS->unit())
+	RUCY_SYMBOL(fill,    "fill");
+	RUCY_SYMBOL(fit,     "fit");
+	switch (THIS->type())
 	{
 		case Reflex::StyleLength::PIXEL:   return pixel.value();
 		case Reflex::StyleLength::PERCENT: return percent.value();
+		case Reflex::StyleLength::FILL:    return fill.value();
+		case Reflex::StyleLength::FIT:     return fit.value();
 		default:                           return nil();
 	}
 }
 
+static
+VALUE get_value(VALUE self)
+{
+	CHECK;
+	return value(THIS->value());
+}
+
+static bool
+has_default_value (const Reflex::StyleLength& length)
+{
+	Reflex::StyleLength::Value defval;
+	if (!get_default_value(&defval, length.type()))
+		return false;
+
+	return length.value() == defval;
+}
+
 static
 VALUE to_s(VALUE self)
 {
 	CHECK;
-	return value(THIS->to_s());
+
+	if (!*THIS)
+		return value("");
+
+	Reflex::String val;
+	if (has_default_value(*THIS))
+		val = "";
+	else if (fmod(THIS->value(), 1) == 0)
+		val = Xot::stringf("%d", (long) THIS->value());
+	else
+		val = Xot::stringf("%g", THIS->value());
+
+	const char* type = type2str(THIS->type());
+	if (!type)
+		invalid_state_error(__FILE__, __LINE__);
+
+	return value(val + type);
 }
 
 
@@ -88,11 +195,10 @@ Init_style_length ()
 
 	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", RUBY_METHOD_FUNC(initialize), -1);
 	rb_define_private_method(cStyleLength, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	rb_define_method(cStyleLength, "type", RUBY_METHOD_FUNC(get_type), 0);
 	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);
 }
 
@@ -102,17 +208,39 @@ namespace Rucy
 
 
 	template <> Reflex::StyleLength
-	value_to<Reflex::StyleLength> (Value value, bool convert)
+	value_to<Reflex::StyleLength> (int argc, const Value* argv, bool convert)
 	{
+		if (argc == 1 && argv->is_array())
+		{
+			argc = argv->size();
+			argv = argv->as_array();
+		}
+
+		assert(argc > 0 && argv);
+
 		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());
+			if (argv->is_nil())
+				return Reflex::StyleLength();
+			else if (argv->is_i())
+				return Reflex::StyleLength(Reflex::StyleLength::PIXEL, argv[0].as_i());
+			else if (argv->is_f())
+				return Reflex::StyleLength(Reflex::StyleLength::PIXEL, argv[0].as_f());
+			else if (argv->is_s() || argv->is_sym())
+			{
+				Reflex::StyleLength::Type type   = Reflex::StyleLength::NONE;
+				Reflex::StyleLength::Value value = 0;
+				if (!scan_type_and_value(&type, &value, argv[0].c_str()))
+					argument_error(__FILE__, __LINE__);
+
+				return Reflex::StyleLength(type, value);
+			}
 		}
 
-		return value_to<Reflex::StyleLength&>(value, convert);
+		if (argc != 1)
+			argument_error(__FILE__, __LINE__);
+
+		return value_to<Reflex::StyleLength&>(*argv, convert);
 	}
 
 

data/.doc/ext/reflex/timer.cpp

@@ -0,0 +1,101 @@
+#include "reflex/ruby/timer.h"
+
+
+#include "reflex/ruby/view.h"
+#include "reflex/ruby/selector.h"
+#include "defs.h"
+#include "selector.h"
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::Timer)
+
+#define THIS      to<Reflex::Timer*>(self)
+
+#define CHECK     RUCY_CHECK_OBJ(Reflex::Timer, self)
+
+#define CALL(fun) RUCY_CALL_SUPER(THIS, fun)
+
+
+static
+VALUE stop(VALUE self)
+{
+	CHECK;
+	THIS->stop();
+}
+
+static
+VALUE get_owner(VALUE self)
+{
+	CHECK;
+	return value(THIS->owner());
+}
+
+static
+VALUE get_id(VALUE self)
+{
+	CHECK;
+	return value(THIS->id());
+}
+
+static
+VALUE get_interval(VALUE self)
+{
+	CHECK;
+	return value(THIS->interval());
+}
+
+static
+VALUE set_count(VALUE self, VALUE count)
+{
+	CHECK;
+	THIS->set_count(to<int>(count));
+	return count;
+}
+
+static
+VALUE get_count(VALUE self)
+{
+	CHECK;
+	return value(THIS->count());
+}
+
+static
+VALUE is_finished(VALUE self)
+{
+	CHECK;
+	return value(THIS->is_finished());
+}
+
+
+static Class cTimer;
+
+void
+Init_timer ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cTimer = rb_define_class_under(mReflex, "Timer", rb_cObject);
+	rb_define_method(cTimer, "stop", RUBY_METHOD_FUNC(stop), 0);
+	rb_define_method(cTimer, "owner", RUBY_METHOD_FUNC(get_owner), 0);
+	rb_define_method(cTimer, "id", RUBY_METHOD_FUNC(get_id), 0);
+	rb_define_method(cTimer, "interval", RUBY_METHOD_FUNC(get_interval), 0);
+	rb_define_method(cTimer, "count=", RUBY_METHOD_FUNC(set_count), 1);
+	rb_define_method(cTimer, "count", RUBY_METHOD_FUNC(get_count), 0);
+	cTimer.define_method("finish?", is_finished);
+
+	define_selector_methods<Reflex::Timer>(cTimer);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	timer_class ()
+	{
+		return cTimer;
+	}
+
+
+}// Reflex

data/.doc/ext/reflex/timer_event.cpp

@@ -0,0 +1,123 @@
+#include "reflex/ruby/event.h"
+
+
+#include "reflex/ruby/timer.h"
+#include "reflex/ruby/view.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::TimerEvent)
+
+#define THIS  to<Reflex::TimerEvent*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::TimerEvent, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Reflex::TimerEvent>(klass);
+}
+
+static
+VALUE initialize(VALUE self, VALUE timer)
+{
+	CHECK;
+
+	THIS->timer = to<Reflex::Timer*>(timer);
+
+	return rb_call_super(0, NULL);
+}
+
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	CHECK;
+	*THIS = to<Reflex::TimerEvent&>(obj);
+	return self;
+}
+
+static
+VALUE timer(VALUE self)
+{
+	CHECK;
+	return value(THIS->timer);
+}
+
+static
+VALUE owner(VALUE self)
+{
+	CHECK;
+	return value(THIS->owner());
+}
+
+static
+VALUE id(VALUE self)
+{
+	CHECK;
+	return value(THIS->id());
+}
+
+static
+VALUE interval(VALUE self)
+{
+	CHECK;
+	return value(THIS->interval());
+}
+
+static
+VALUE set_count(VALUE self, VALUE count)
+{
+	CHECK;
+	THIS->set_count(to<int>(count));
+	return count;
+}
+
+static
+VALUE count(VALUE self)
+{
+	CHECK;
+	return value(THIS->count());
+}
+
+static
+VALUE is_finished(VALUE self)
+{
+	CHECK;
+	return value(THIS->is_finished());
+}
+
+
+static Class cTimerEvent;
+
+void
+Init_timer_event ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cTimerEvent = mReflex.define_class("TimerEvent", Reflex::event_class());
+	rb_define_alloc_func(cTimerEvent, alloc);
+	rb_define_private_method(cTimerEvent, "initialize", RUBY_METHOD_FUNC(initialize), 1);
+	rb_define_private_method(cTimerEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	rb_define_method(cTimerEvent, "timer", RUBY_METHOD_FUNC(timer), 0);
+	rb_define_method(cTimerEvent, "owner", RUBY_METHOD_FUNC(owner), 0);
+	rb_define_method(cTimerEvent, "id", RUBY_METHOD_FUNC(id), 0);
+	rb_define_method(cTimerEvent, "interval", RUBY_METHOD_FUNC(interval), 0);
+	rb_define_method(cTimerEvent, "count=", RUBY_METHOD_FUNC(set_count), 1);
+	rb_define_method(cTimerEvent, "count", RUBY_METHOD_FUNC(count), 0);
+	cTimerEvent.define_method("finish?", is_finished);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	timer_event_class ()
+	{
+		return cTimerEvent;
+	}
+
+
+}// Reflex