reflexion 0.1.12 → 0.1.13

data/ext/reflex/rect_shape.cpp

@@ -1,28 +1,22 @@
-#include "reflex/ruby/shape_view.h"
+#include "reflex/ruby/shape.h"
 
 
-#include <rucy.h>
-#include <rays/ruby/point.h>
-
-
-using namespace Rucy;
-
-using Reflex::coord;
+#include "defs.h"
 
 
 RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::RectShape)
 
 #define THIS      to<Reflex::RectShape*>(self)
 
-#define CHECK     RUCY_CHECK_OBJECT(Reflex::RectShape, self)
+#define CHECK     RUCY_CHECK_OBJ(Reflex::RectShape, self)
 
-#define CALL(fun) RUCY_WRAPPER_CALL(Reflex::RectShape, THIS, fun)
+#define CALL(fun) RUCY_CALL_SUPER(THIS, fun)
 
 
 static
 RUCY_DEF_ALLOC(alloc, klass)
 {
-	return value(new Reflex::RubyShapeView<Reflex::RectShape>, klass);
+	return value(new Reflex::RubyShape<Reflex::RectShape>, klass);
 }
 RUCY_END
 
@@ -30,17 +24,16 @@ static
 RUCY_DEFN(set_round)
 {
 	CHECK;
-	check_arg_count(__FILE__, __LINE__, "RectShape#set_fill", argc, 1, 2);
+	check_arg_count(__FILE__, __LINE__, "RectShape#set_round", argc, 1, 4);
 
-	if (argc == 1 && argv[0].is_kind_of(Rays::point_class()))
-		THIS->set_round(to<Rays::Point&>(argv[0]));
+	if (argc == 1)
+		THIS->set_round(to<float>(argv[0]));
 	else
 	{
-		float w =               to<float>(argv[0]);
-		float h = (argc >= 2) ? to<float>(argv[1]) : 1;
-		THIS->set_round(w, h);
+		THIS->set_round(
+			to<float>(argv[0]), to<float>(argv[1]),
+			to<float>(argv[2]), to<float>(argv[3]));
 	}
-
 	return self;
 }
 RUCY_END
@@ -49,12 +42,99 @@ static
 RUCY_DEF0(get_round)
 {
 	CHECK;
-	return value(THIS->round());
+	return array(
+		value(THIS->round_left_top()),
+		value(THIS->round_right_top()),
+		value(THIS->round_left_bottom()),
+		value(THIS->round_right_bottom()));
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_round_left_top, round)
+{
+	CHECK;
+	THIS->set_round_left_top(to<coord>(round));
+	return round;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_round_left_top)
+{
+	CHECK;
+	return value(THIS->round_left_top());
 }
 RUCY_END
 
 static
-RUCY_DEF_clear_override_flags(cof, Reflex::RectShape);
+RUCY_DEF1(set_round_right_top, round)
+{
+	CHECK;
+	THIS->set_round_right_top(to<coord>(round));
+	return round;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_round_right_top)
+{
+	CHECK;
+	return value(THIS->round_right_top());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_round_left_bottom, round)
+{
+	CHECK;
+	THIS->set_round_left_bottom(to<coord>(round));
+	return round;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_round_left_bottom)
+{
+	CHECK;
+	return value(THIS->round_left_bottom());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_round_right_bottom, round)
+{
+	CHECK;
+	THIS->set_round_right_bottom(to<coord>(round));
+	return round;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_round_right_bottom)
+{
+	CHECK;
+	return value(THIS->round_right_bottom());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_nsegment, nsegment)
+{
+	CHECK;
+
+	THIS->set_nsegment(to<uint>(nsegment));
+	return nsegment;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_nsegment)
+{
+	CHECK;
+	return value(THIS->nsegment());
+}
+RUCY_END
 
 
 static Class cRectShape;
@@ -64,11 +144,20 @@ Init_rect_shape ()
 {
 	Module mReflex = define_module("Reflex");
 
-	cRectShape = mReflex.define_class("RectShape", Reflex::shape_view_class());
+	cRectShape = mReflex.define_class("RectShape", Reflex::shape_class());
 	cRectShape.define_alloc_func(alloc);
-	cRectShape.define_private_method("round=", set_round);
-	cRectShape.define_method(        "round",  get_round);
-	cRectShape.define_clear_override_flags(cof);
+	cRectShape.define_method("round=",              set_round);
+	cRectShape.define_method("round",               get_round);
+	cRectShape.define_method("round_left_top=",     set_round_left_top);
+	cRectShape.define_method("round_left_top",      get_round_left_top);
+	cRectShape.define_method("round_right_top=",    set_round_right_top);
+	cRectShape.define_method("round_right_top",     get_round_right_top);
+	cRectShape.define_method("round_left_bottom=",  set_round_left_bottom);
+	cRectShape.define_method("round_left_bottom",   get_round_left_bottom);
+	cRectShape.define_method("round_right_bottom=", set_round_right_bottom);
+	cRectShape.define_method("round_right_bottom",  get_round_right_bottom);
+	cRectShape.define_method("nsegment=", set_nsegment);
+	cRectShape.define_method("nsegment",  get_nsegment);
 }
 
 

data/ext/reflex/reflex.cpp

@@ -1,15 +1,31 @@
-#include <rucy.h>
 #include "reflex/reflex.h"
+#include "reflex/ruby/view.h"
+#include "reflex/ruby/timer.h"
+#include "../../src/window.h"
+#include "../../src/timer.h"
 #include "defs.h"
 
 
-using namespace Rucy;
+static Reflex::View*
+create_root_view ()
+{
+	return new Reflex::RubyView<Reflex::View>;
+}
+
+static Reflex::Timer*
+create_timer ()
+{
+	return new Reflex::RubyTimer<Reflex::Timer>;
+}
 
 
 static
 RUCY_DEF0(init)
 {
 	Reflex::init();
+	Reflex::Window_set_create_root_view_fun(create_root_view);
+	Reflex::Timer_set_create_fun(create_timer);
+
 	return self;
 }
 RUCY_END
@@ -17,7 +33,10 @@ RUCY_END
 static
 RUCY_DEF0(fin)
 {
+	Reflex::Window_set_create_root_view_fun(NULL);
+	Reflex::Timer_set_create_fun(NULL);
 	Reflex::fin();
+
 	return self;
 }
 RUCY_END

data/ext/reflex/scroll_event.cpp

@@ -1,16 +1,10 @@
 #include "reflex/ruby/event.h"
 
 
-#include <rucy.h>
 #include "rays/ruby/point.h"
 #include "defs.h"
 
 
-using namespace Rucy;
-
-using Reflex::coord;
-
-
 RUCY_DEFINE_VALUE_FROM_TO(Reflex::ScrollEvent)
 
 #define THIS  to<Reflex::ScrollEvent*>(self)
@@ -125,7 +119,7 @@ Init_scroll_event ()
 
 	cScrollEvent = mReflex.define_class("ScrollEvent", Reflex::event_class());
 	cScrollEvent.define_alloc_func(alloc);
-	cScrollEvent.define_private_method("initialize", initialize);
+	cScrollEvent.define_private_method("initialize",      initialize);
 	cScrollEvent.define_private_method("initialize_copy", initialize_copy);
 	cScrollEvent.define_method("x", x);
 	cScrollEvent.define_method("y", y);

data/ext/reflex/selector.cpp

@@ -1,16 +1,13 @@
 #include "reflex/ruby/selector.h"
 
 
-#include <rucy.h>
 #include "defs.h"
 
 
-using namespace Rucy;
+RUCY_DEFINE_VALUE_OR_ARRAY_FROM_TO(Reflex::Selector)
 
-
-RUCY_DEFINE_VALUE_FROM_TO(Reflex::Selector)
-
-#define THIS  to<Reflex::Selector*>(self)
+#define   THIS to<      Reflex::Selector*>(self)
+#define C_THIS to<const Reflex::Selector*>(self)
 
 #define CHECK RUCY_CHECK_OBJ(Reflex::Selector, self)
 
@@ -43,7 +40,8 @@ static
 RUCY_DEF0(get_name)
 {
 	CHECK;
-	return THIS->name() ? value(THIS->name()) : nil();
+	const char* name = C_THIS->name();
+	return name ? value(name) : nil();
 }
 RUCY_END
 
@@ -63,14 +61,30 @@ RUCY_DEF1(remove_tag, tag)
 }
 RUCY_END
 
+static
+RUCY_DEF0(clear_tags)
+{
+	CHECK;
+	THIS->clear_tags();
+}
+RUCY_END
+
+static
+RUCY_DEF1(has_tag, tag)
+{
+	CHECK;
+	return value(C_THIS->has_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)
+	Reflex::Selector::const_iterator end = C_THIS->end();
+	for (Reflex::Selector::const_iterator it = C_THIS->begin(); it != end; ++it)
 		ret = rb_yield(value(*it));
 	return ret;
 }
@@ -80,7 +94,7 @@ static
 RUCY_DEF1(contains, selector)
 {
 	CHECK;
-	return value(THIS->contains(to<Reflex::Selector&>(selector)));
+	return value(C_THIS->contains(to<Reflex::Selector&>(selector)));
 }
 RUCY_END
 
@@ -88,7 +102,7 @@ static
 RUCY_DEF1(equal, selector)
 {
 	CHECK;
-	return value(*THIS == to<Reflex::Selector&>(selector));
+	return value(*C_THIS == to<const Reflex::Selector&>(selector));
 }
 RUCY_END
 
@@ -107,7 +121,9 @@ Init_selector ()
 	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("clear_tags", clear_tags);
+	cSelector.define_method("tag?",       has_tag);
+	cSelector.define_method("each_tag",   each_tag);
 	cSelector.define_method("contains", contains);
 	cSelector.define_method("==", equal);
 }
@@ -118,12 +134,26 @@ namespace Rucy
 
 
 	template <> Reflex::Selector
-	value_to<Reflex::Selector> (Value value, bool convert)
+	value_to<Reflex::Selector> (int argc, const Value* argv, bool convert)
 	{
-		if (convert && (value.is_s() || value.is_sym()))
-			return Reflex::Selector(value.c_str());
+		if (argc == 1 && argv->is_array())
+		{
+			argc = argv->size();
+			argv = argv->as_array();
+		}
+
+		assert(argc > 0 && argv);
+
+		if (convert)
+		{
+			if (argc == 1 && (argv->is_s() || argv->is_sym()))
+				return Reflex::Selector(argv[0].c_str());
+		}
+
+		if (argc != 1)
+			argument_error(__FILE__, __LINE__);
 
-		return value_to<Reflex::Selector&>(value, convert);
+		return value_to<Reflex::Selector&>(*argv, convert);
 	}
 
 

data/ext/reflex/selector.h

@@ -0,0 +1,130 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_EXT_SELECTOR_H__
+#define __REFLEX_EXT_SELECTOR_H__
+
+
+#include <reflex/ruby/selector.h>
+
+
+template <typename T>
+static
+RUCY_DEF1(set_name, name)
+{
+	RUCY_CHECK_OBJ(T, self);
+	Reflex::HasSelector* this_ = Rucy::to<T*>(self);
+
+	this_->set_name(name.is_nil() ? NULL : name.c_str());
+}
+RUCY_END
+
+template <typename T>
+static
+RUCY_DEF0(get_name)
+{
+	RUCY_CHECK_OBJ(T, self);
+	const Reflex::HasSelector* this_ = Rucy::to<const T*>(self);
+
+	return this_->name() ? Rucy::value(this_->name()) : Rucy::nil();
+}
+RUCY_END
+
+template <typename T>
+static
+RUCY_DEF1(add_tag, tag)
+{
+	RUCY_CHECK_OBJ(T, self);
+	Reflex::HasSelector* this_ = Rucy::to<T*>(self);
+
+	this_->add_tag(tag.c_str());
+}
+RUCY_END
+
+template <typename T>
+static
+RUCY_DEF1(remove_tag, tag)
+{
+	RUCY_CHECK_OBJ(T, self);
+	Reflex::HasSelector* this_ = Rucy::to<T*>(self);
+
+	this_->remove_tag(tag.c_str());
+}
+RUCY_END
+
+template <typename T>
+static
+RUCY_DEF0(clear_tags)
+{
+	RUCY_CHECK_OBJ(T, self);
+	Reflex::HasSelector* this_ = Rucy::to<T*>(self);
+
+	this_->clear_tags();
+}
+RUCY_END
+
+template <typename T>
+static
+RUCY_DEF1(has_tag, tag)
+{
+	RUCY_CHECK_OBJ(T, self);
+	const Reflex::HasSelector* this_ = Rucy::to<const T*>(self);
+
+	return Rucy::value(this_->has_tag(tag.c_str()));
+}
+RUCY_END
+
+template <typename T>
+static
+RUCY_DEF0(each_tag)
+{
+	RUCY_CHECK_OBJ(T, self);
+	const Reflex::HasSelector* this_ = Rucy::to<const T*>(self);
+
+	Rucy::Value ret;
+	Reflex::Selector::const_iterator end = this_->tag_end();
+	for (Reflex::Selector::const_iterator it = this_->tag_begin(); it != end; ++it)
+		ret = rb_yield(Rucy::value(*it));
+	return ret;
+}
+RUCY_END
+
+template <typename T>
+static
+RUCY_DEF1(set_selector, selector)
+{
+	RUCY_CHECK_OBJ(T, self);
+	Reflex::HasSelector* this_ = Rucy::to<T*>(self);
+
+	this_->set_selector(Rucy::to<Reflex::Selector>(selector));
+}
+RUCY_END
+
+template <typename T>
+static
+RUCY_DEF0(get_selector)
+{
+	RUCY_CHECK_OBJ(T, self);
+	const Reflex::HasSelector* this_ = Rucy::to<const T*>(self);
+
+	return Rucy::value(this_->selector());
+}
+RUCY_END
+
+
+template <typename T>
+static void
+define_selector_methods (Rucy::Class klass)
+{
+	klass.define_method("name=", set_name<T>);
+	klass.define_method("name",  get_name<T>);
+	klass.define_method("add_tag",    add_tag<T>);
+	klass.define_method("remove_tag", remove_tag<T>);
+	klass.define_method("clear_tags", clear_tags<T>);
+	klass.define_method("tag?",       has_tag<T>);
+	klass.define_method("each_tag",   each_tag<T>);
+	klass.define_method("selector=", set_selector<T>);
+	klass.define_method("selector",  get_selector<T>);
+}
+
+
+#endif//EOH