reflexion 0.1.11 → 0.1.16

data/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)
 
@@ -22,66 +18,176 @@ RUCY_DEF_ALLOC(alloc, klass)
 }
 RUCY_END
 
-static
-RUCY_DEF2(setup_num, 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;
+	}
 }
-RUCY_END
 
-static
-RUCY_DEF1(setup_str, 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;
 }
-RUCY_END
 
 static
-RUCY_DEF1(initialize_copy, obj)
+RUCY_DEFN(initialize)
 {
 	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);
+	}
 }
 RUCY_END
 
 static
-RUCY_DEF0(get_value)
+RUCY_DEF1(initialize_copy, obj)
 {
 	CHECK;
-	return value(THIS->value());
+	*THIS = to<Reflex::StyleLength&>(obj).copy();
+	return self;
 }
 RUCY_END
 
 static
-RUCY_DEF0(get_unit)
+RUCY_DEF0(get_type)
 {
 	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();
 	}
 }
 RUCY_END
 
+static
+RUCY_DEF0(get_value)
+{
+	CHECK;
+	return value(THIS->value());
+}
+RUCY_END
+
+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
 RUCY_DEF0(to_s)
 {
 	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);
 }
 RUCY_END
 
@@ -95,11 +201,10 @@ Init_style_length ()
 
 	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",      initialize);
 	cStyleLength.define_private_method("initialize_copy", initialize_copy);
+	cStyleLength.define_method("type",   get_type);
 	cStyleLength.define_method("value",  get_value);
-	cStyleLength.define_method("unit",   get_unit);
 	cStyleLength.define_method("to_s", to_s);
 }
 
@@ -109,17 +214,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/ext/reflex/timer.cpp

@@ -0,0 +1,108 @@
+#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
+RUCY_DEF0(stop)
+{
+	CHECK;
+	THIS->stop();
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_owner)
+{
+	CHECK;
+	return value(THIS->owner());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_id)
+{
+	CHECK;
+	return value(THIS->id());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_interval)
+{
+	CHECK;
+	return value(THIS->interval());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_count, count)
+{
+	CHECK;
+	THIS->set_count(to<int>(count));
+	return count;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_count)
+{
+	CHECK;
+	return value(THIS->count());
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_finished)
+{
+	CHECK;
+	return value(THIS->is_finished());
+}
+RUCY_END
+
+
+static Class cTimer;
+
+void
+Init_timer ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cTimer = mReflex.define_class("Timer");
+	cTimer.define_method("stop", stop);
+	cTimer.define_method("owner", get_owner);
+	cTimer.define_method("id", get_id);
+	cTimer.define_method("interval", get_interval);
+	cTimer.define_method("count=", set_count);
+	cTimer.define_method("count",  get_count);
+	cTimer.define_method("finish?", is_finished);
+
+	define_selector_methods<Reflex::Timer>(cTimer);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	timer_class ()
+	{
+		return cTimer;
+	}
+
+
+}// Reflex

data/ext/reflex/timer_event.cpp

@@ -0,0 +1,133 @@
+#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
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Reflex::TimerEvent>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize, timer)
+{
+	CHECK;
+
+	THIS->timer = to<Reflex::Timer*>(timer);
+
+	return rb_call_super(0, NULL);
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize_copy, obj)
+{
+	CHECK;
+	*THIS = to<Reflex::TimerEvent&>(obj);
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(timer)
+{
+	CHECK;
+	return value(THIS->timer);
+}
+RUCY_END
+
+static
+RUCY_DEF0(owner)
+{
+	CHECK;
+	return value(THIS->owner());
+}
+RUCY_END
+
+static
+RUCY_DEF0(id)
+{
+	CHECK;
+	return value(THIS->id());
+}
+RUCY_END
+
+static
+RUCY_DEF0(interval)
+{
+	CHECK;
+	return value(THIS->interval());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_count, count)
+{
+	CHECK;
+	THIS->set_count(to<int>(count));
+	return count;
+}
+RUCY_END
+
+static
+RUCY_DEF0(count)
+{
+	CHECK;
+	return value(THIS->count());
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_finished)
+{
+	CHECK;
+	return value(THIS->is_finished());
+}
+RUCY_END
+
+
+static Class cTimerEvent;
+
+void
+Init_timer_event ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cTimerEvent = mReflex.define_class("TimerEvent", Reflex::event_class());
+	cTimerEvent.define_alloc_func(alloc);
+	cTimerEvent.define_private_method("initialize",      initialize);
+	cTimerEvent.define_private_method("initialize_copy", initialize_copy);
+	cTimerEvent.define_method("timer", timer);
+	cTimerEvent.define_method("owner", owner);
+	cTimerEvent.define_method("id", id);
+	cTimerEvent.define_method("interval", interval);
+	cTimerEvent.define_method("count=", set_count);
+	cTimerEvent.define_method("count",      count);
+	cTimerEvent.define_method("finish?", is_finished);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	timer_event_class ()
+	{
+		return cTimerEvent;
+	}
+
+
+}// Reflex