reflexion 0.1.20 → 0.1.24

data/ext/reflex/pointer.cpp

@@ -0,0 +1,170 @@
+#include "reflex/ruby/pointer.h"
+
+
+#include <rays/ruby/point.h>
+#include "defs.h"
+
+
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::Pointer)
+
+#define THIS  to<Reflex::Pointer*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::Pointer, self)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Reflex::Pointer>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEF8(initialize,
+	id, type, action, position, modifiers, click_count, drag, time)
+{
+	CHECK;
+
+	*THIS = Reflex::Pointer(
+		to<Reflex::Pointer::ID>(id),
+		to<uint>(type),
+		(Reflex::Pointer::Action) to<int>(action),
+		to<Rays::Point>(position),
+		to<uint>(modifiers),
+		to<uint>(click_count),
+		to<bool>(drag),
+		to<double>(time));
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize_copy, obj)
+{
+	CHECK;
+	*THIS = to<Reflex::Pointer&>(obj);
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_id)
+{
+	CHECK;
+	return value(THIS->id());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_type)
+{
+	CHECK;
+	return value(THIS->type());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_action)
+{
+	CHECK;
+	return value(THIS->action());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_position)
+{
+	CHECK;
+	return value(THIS->position());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_modifiers)
+{
+	CHECK;
+	return value(THIS->modifiers());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_click_count)
+{
+	CHECK;
+	return value(THIS->click_count());
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_drag)
+{
+	CHECK;
+	return value(THIS->is_drag());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_time)
+{
+	CHECK;
+	return value(THIS->time());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_prev)
+{
+	CHECK;
+	return value(THIS->prev());
+}
+RUCY_END
+
+
+static Class cPointer;
+
+void
+Init_pointer ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cPointer = mReflex.define_class("Pointer");
+	cPointer.define_alloc_func(alloc);
+	cPointer.define_private_method("initialize",      initialize);
+	cPointer.define_private_method("initialize_copy", initialize_copy);
+	cPointer.define_method("id",                 get_id);
+	cPointer.define_private_method("get_type",   get_type);
+	cPointer.define_private_method("get_action", get_action);
+	cPointer.define_method("position",           get_position);
+	cPointer.define_method("modifiers",          get_modifiers);
+	cPointer.define_method("click_count",        get_click_count);
+	cPointer.define_method("drag?",              is_drag);
+	cPointer.define_method("time",               get_time);
+	cPointer.define_method("prev",               get_prev);
+	cPointer.define_const("TYPE_NONE",    Reflex::Pointer::TYPE_NONE);
+	cPointer.define_const("MOUSE",        Reflex::Pointer::MOUSE);
+	cPointer.define_const("MOUSE_LEFT",   Reflex::Pointer::MOUSE_LEFT);
+	cPointer.define_const("MOUSE_RIGHT",  Reflex::Pointer::MOUSE_RIGHT);
+	cPointer.define_const("MOUSE_MIDDLE", Reflex::Pointer::MOUSE_MIDDLE);
+	cPointer.define_const("TOUCH",        Reflex::Pointer::TOUCH);
+	cPointer.define_const("PEN",          Reflex::Pointer::PEN);
+	cPointer.define_const("ACTION_NONE", Reflex::Pointer::ACTION_NONE);
+	cPointer.define_const("DOWN",        Reflex::Pointer::DOWN);
+	cPointer.define_const("UP",          Reflex::Pointer::UP);
+	cPointer.define_const("MOVE",        Reflex::Pointer::MOVE);
+	cPointer.define_const("CANCEL",      Reflex::Pointer::CANCEL);
+	cPointer.define_const("STAY",        Reflex::Pointer::STAY);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	pointer_class ()
+	{
+		return cPointer;
+	}
+
+
+}// Reflex

data/ext/reflex/pointer_event.cpp

@@ -1,7 +1,9 @@
 #include "reflex/ruby/event.h"
 
 
+#include <vector>
 #include <rays/ruby/point.h>
+#include "reflex/ruby/pointer.h"
 #include "defs.h"
 
 
@@ -20,23 +22,18 @@ RUCY_DEF_ALLOC(alloc, klass)
 RUCY_END
 
 static
-RUCY_DEF6(initialize, type, pointer_type, modifiers, count, drag, positions)
+RUCY_DEFN(initialize)
 {
 	CHECK;
 
-	int size = positions.size();
-	if (size <= 0 || Reflex::PointerEvent::MAX < size)
+	if (argc == 0)
 		argument_error(__FILE__, __LINE__);
 
-	THIS->type         = (Reflex::PointerEvent::Type) to<int>(type);
-	THIS->pointer_type = to<uint>(pointer_type);
-	THIS->modifiers    = to<uint>(modifiers);
-	THIS->count        = to<uint>(count);
-	THIS->drag         = to<bool>(drag);
-	THIS->size         = (size_t) size;
+	std::vector<Reflex::Pointer> pointers;
+	for (size_t i = 0; i < argc; ++i)
+		pointers.emplace_back(to<Reflex::Pointer&>(argv[i]));
 
-	for (int i = 0; i < size; ++i)
-		THIS->positions[i] = to<Rays::Point>(positions[i]);
+	*THIS = Reflex::PointerEvent(&pointers[0], pointers.size());
 
 	return rb_call_super(0, NULL);
 }
@@ -46,104 +43,58 @@ static
 RUCY_DEF1(initialize_copy, obj)
 {
 	CHECK;
-	*THIS = to<Reflex::PointerEvent&>(obj);
+	*THIS = to<Reflex::PointerEvent&>(obj).dup();
 	return self;
 }
 RUCY_END
 
 static
-RUCY_DEF0(type)
+RUCY_DEF0(get_size)
 {
 	CHECK;
-	return value(THIS->type);
+	return value(THIS->size());
 }
 RUCY_END
 
 static
-RUCY_DEF0(pointer_type)
+RUCY_DEF0(is_empty)
 {
 	CHECK;
-	return value(THIS->pointer_type);
+	return value(THIS->empty());
 }
 RUCY_END
 
 static
-RUCY_DEF0(size)
+RUCY_DEF0(is_captured)
 {
 	CHECK;
-	return value(THIS->size);
+	return value(THIS->is_captured());
 }
 RUCY_END
 
 static
-RUCY_DEF0(modifiers)
-{
-	CHECK;
-	return value(THIS->modifiers);
-}
-RUCY_END
-
-static
-RUCY_DEF0(count)
-{
-	CHECK;
-	return value(THIS->count);
-}
-RUCY_END
-
-static
-RUCY_DEF0(drag)
-{
-	CHECK;
-	return value(THIS->drag);
-}
-RUCY_END
-
-static
-RUCY_DEF0(capture)
-{
-	CHECK;
-	return value(THIS->capture);
-}
-RUCY_END
-
-static
-RUCY_DEF0(x)
-{
-	CHECK;
-	return value(THIS->x);
-}
-RUCY_END
-
-static
-RUCY_DEF0(y)
+RUCY_DEF1(get_at, index)
 {
 	CHECK;
-	return value(THIS->y);
-}
-RUCY_END
 
-static
-RUCY_DEFN(position)
-{
-	CHECK;
-	check_arg_count(__FILE__, __LINE__, "PointerEvent#position", argc, 0, 1);
+	int size = (int) THIS->size();
+	int i    = to<int>(index);
+	if (i < -size || size <= i)
+		return Qnil;
 
-	size_t index = argc >= 1 ? to<int>(argv[0]) : 0;
-	return value(THIS->position(index));
+	return value((*THIS)[i >= 0 ? i : i + size]);
 }
 RUCY_END
 
 static
-RUCY_DEF1(get_at, index)
+RUCY_DEF0(each)
 {
 	CHECK;
 
-	int i = to<int>(index);
-	if (i < 0 || THIS->size <= (size_t) i)
-		index_error(__FILE__, __LINE__);
-
-	return value((*THIS)[i]);
+	Value ret;
+	for (size_t i = 0, size = THIS->size(); i < size; ++i)
+		ret = rb_yield(value((*THIS)[i]));
+	return ret;
 }
 RUCY_END
 
@@ -159,27 +110,11 @@ Init_pointer_event ()
 	cPointerEvent.define_alloc_func(alloc);
 	cPointerEvent.define_private_method("initialize",      initialize);
 	cPointerEvent.define_private_method("initialize_copy", initialize_copy);
-	cPointerEvent.define_method("type", type);
-	cPointerEvent.define_method("pointer_type", pointer_type);
-	cPointerEvent.define_method("size", size);
-	cPointerEvent.define_method("modifiers", modifiers);
-	cPointerEvent.define_method("count", count);
-	cPointerEvent.define_method("drag?", drag);
-	cPointerEvent.define_method("capture?", capture);
-	cPointerEvent.define_method("x", x);
-	cPointerEvent.define_method("y", y);
-	cPointerEvent.define_method("position", position);
-	cPointerEvent.define_method("[]", get_at);
-	cPointerEvent.define_const("TYPE_NONE", Reflex::PointerEvent::NONE);
-	cPointerEvent.define_const("TYPE_DOWN", Reflex::PointerEvent::DOWN);
-	cPointerEvent.define_const("TYPE_UP",   Reflex::PointerEvent::UP);
-	cPointerEvent.define_const("TYPE_MOVE", Reflex::PointerEvent::MOVE);
-	cPointerEvent.define_const("POINTER_NONE",         Reflex::POINTER_NONE);
-	cPointerEvent.define_const("POINTER_MOUSE_LEFT",   Reflex::POINTER_MOUSE_LEFT);
-	cPointerEvent.define_const("POINTER_MOUSE_RIGHT",  Reflex::POINTER_MOUSE_RIGHT);
-	cPointerEvent.define_const("POINTER_MOUSE_MIDDLE", Reflex::POINTER_MOUSE_MIDDLE);
-	cPointerEvent.define_const("POINTER_TOUCH",        Reflex::POINTER_TOUCH);
-	cPointerEvent.define_const("POINTER_PEN",          Reflex::POINTER_PEN);
+	cPointerEvent.define_method("size",      get_size);
+	cPointerEvent.define_method("empty?",    is_empty);
+	cPointerEvent.define_method("captured?", is_captured);
+	cPointerEvent.define_method("[]",        get_at);
+	cPointerEvent.define_method("each",      each);
 }
 
 

data/ext/reflex/scroll_event.cpp

@@ -24,12 +24,9 @@ RUCY_DEF6(initialize, x, y, z, dx, dy, dz)
 {
 	CHECK;
 
-	THIS->x  = to<coord>(x);
-	THIS->y  = to<coord>(y);
-	THIS->z  = to<coord>(z);
-	THIS->dx = to<coord>(dx);
-	THIS->dy = to<coord>(dy);
-	THIS->dz = to<coord>(dz);
+	*THIS = Reflex::ScrollEvent(
+		to<coord>( x), to<coord>( y), to<coord>( z),
+		to<coord>(dx), to<coord>(dy), to<coord>(dz));
 
 	return rb_call_super(0, NULL);
 }
@@ -39,7 +36,7 @@ static
 RUCY_DEF1(initialize_copy, obj)
 {
 	CHECK;
-	*THIS = to<Reflex::ScrollEvent&>(obj);
+	*THIS = to<Reflex::ScrollEvent&>(obj).dup();
 	return self;
 }
 RUCY_END
@@ -48,7 +45,7 @@ static
 RUCY_DEF0(x)
 {
 	CHECK;
-	return value(THIS->x);
+	return value(THIS->scroll().x);
 }
 RUCY_END
 
@@ -56,7 +53,7 @@ static
 RUCY_DEF0(y)
 {
 	CHECK;
-	return value(THIS->y);
+	return value(THIS->scroll().y);
 }
 RUCY_END
 
@@ -64,7 +61,7 @@ static
 RUCY_DEF0(z)
 {
 	CHECK;
-	return value(THIS->z);
+	return value(THIS->scroll().z);
 }
 RUCY_END
 
@@ -72,7 +69,7 @@ static
 RUCY_DEF0(dx)
 {
 	CHECK;
-	return value(THIS->dx);
+	return value(THIS->dscroll().x);
 }
 RUCY_END
 
@@ -80,7 +77,7 @@ static
 RUCY_DEF0(dy)
 {
 	CHECK;
-	return value(THIS->dy);
+	return value(THIS->dscroll().y);
 }
 RUCY_END
 
@@ -88,7 +85,7 @@ static
 RUCY_DEF0(dz)
 {
 	CHECK;
-	return value(THIS->dz);
+	return value(THIS->dscroll().z);
 }
 RUCY_END
 
@@ -96,15 +93,15 @@ static
 RUCY_DEF0(scroll)
 {
 	CHECK;
-	return value(Rays::Point(THIS->x, THIS->y, THIS->z));
+	return value(THIS->scroll());
 }
 RUCY_END
 
 static
-RUCY_DEF0(delta)
+RUCY_DEF0(dscroll)
 {
 	CHECK;
-	return value(Rays::Point(THIS->dx, THIS->dy, THIS->dz));
+	return value(THIS->dscroll());
 }
 RUCY_END
 
@@ -126,8 +123,8 @@ Init_scroll_event ()
 	cScrollEvent.define_method("dx", dx);
 	cScrollEvent.define_method("dy", dy);
 	cScrollEvent.define_method("dz", dz);
-	cScrollEvent.define_method("scroll", scroll);
-	cScrollEvent.define_method("delta", delta);
+	cScrollEvent.define_method( "scroll",  scroll);
+	cScrollEvent.define_method("dscroll", dscroll);
 }
 
 

data/ext/reflex/selector.cpp

@@ -90,6 +90,14 @@ RUCY_DEF0(each_tag)
 }
 RUCY_END
 
+static
+RUCY_DEF0(is_empty)
+{
+	CHECK;
+	return value(C_THIS->empty());
+}
+RUCY_END
+
 static
 RUCY_DEF1(contains, selector)
 {
@@ -124,6 +132,7 @@ Init_selector ()
 	cSelector.define_method("clear_tags", clear_tags);
 	cSelector.define_method("tag?",       has_tag);
 	cSelector.define_method("each_tag",   each_tag);
+	cSelector.define_method("empty?",     is_empty);
 	cSelector.define_method("contains", contains);
 	cSelector.define_method("==", equal);
 }

data/ext/reflex/timer.cpp

@@ -1,6 +1,7 @@
 #include "reflex/ruby/timer.h"
 
 
+#include "reflex/exception.h"
 #include "reflex/ruby/view.h"
 #include "reflex/ruby/selector.h"
 #include "defs.h"
@@ -16,6 +17,13 @@ RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::Timer)
 #define CALL(fun) RUCY_CALL_SUPER(THIS, fun)
 
 
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	Reflex::reflex_error(__FILE__, __LINE__, "can not instantiate Timer class.");
+}
+RUCY_END
+
 static
 RUCY_DEF0(stop)
 {
@@ -82,13 +90,14 @@ Init_timer ()
 	Module mReflex = define_module("Reflex");
 
 	cTimer = mReflex.define_class("Timer");
+	cTimer.define_alloc_func(alloc);
 	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);
+	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("finished?", is_finished);
 
 	define_selector_methods<Reflex::Timer>(cTimer);
 }

data/ext/reflex/timer_event.cpp

@@ -25,7 +25,7 @@ RUCY_DEF1(initialize, timer)
 {
 	CHECK;
 
-	THIS->timer = to<Reflex::Timer*>(timer);
+	*THIS = Reflex::TimerEvent(to<Reflex::Timer*>(timer));
 
 	return rb_call_super(0, NULL);
 }
@@ -35,7 +35,7 @@ static
 RUCY_DEF1(initialize_copy, obj)
 {
 	CHECK;
-	*THIS = to<Reflex::TimerEvent&>(obj);
+	*THIS = to<Reflex::TimerEvent&>(obj).dup();
 	return self;
 }
 RUCY_END
@@ -44,7 +44,7 @@ static
 RUCY_DEF0(timer)
 {
 	CHECK;
-	return value(THIS->timer);
+	return value(THIS->timer());
 }
 RUCY_END
 
@@ -72,15 +72,6 @@ RUCY_DEF0(interval)
 }
 RUCY_END
 
-static
-RUCY_DEF1(set_count, count)
-{
-	CHECK;
-	THIS->set_count(to<int>(count));
-	return count;
-}
-RUCY_END
-
 static
 RUCY_DEF0(count)
 {
@@ -109,13 +100,12 @@ Init_timer_event ()
 	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);
+	cTimerEvent.define_method("timer",     timer);
+	cTimerEvent.define_method("owner",     owner);
+	cTimerEvent.define_method("id",        id);
+	cTimerEvent.define_method("interval",  interval);
+	cTimerEvent.define_method("count",     count);
+	cTimerEvent.define_method("finished?", is_finished);
 }
 
 

data/ext/reflex/update_event.cpp

@@ -23,8 +23,9 @@ RUCY_DEF2(initialize, now, dt)
 {
 	CHECK;
 
-	THIS->now = to<double>(now);
-	THIS->dt  = to<float>(dt);
+	*THIS = Reflex::UpdateEvent(
+		to<double>(now),
+		to<float>(dt));
 
 	return rb_call_super(0, NULL);
 }
@@ -34,7 +35,7 @@ static
 RUCY_DEF1(initialize_copy, obj)
 {
 	CHECK;
-	*THIS = to<Reflex::UpdateEvent&>(obj);
+	*THIS = to<Reflex::UpdateEvent&>(obj).dup();
 	return self;
 }
 RUCY_END
@@ -43,7 +44,7 @@ static
 RUCY_DEF0(now)
 {
 	CHECK;
-	return value(THIS->now);
+	return value(THIS->now());
 }
 RUCY_END
 
@@ -51,7 +52,7 @@ static
 RUCY_DEF0(dt)
 {
 	CHECK;
-	return value(THIS->dt);
+	return value(THIS->dt());
 }
 RUCY_END