reflexion 0.1.20 → 0.1.24

data/.doc/ext/reflex/scroll_event.cpp

@@ -23,12 +23,9 @@ VALUE initialize(VALUE self, VALUE x, VALUE y, VALUE z, VALUE dx, VALUE dy, VALU
 {
 	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);
 }
@@ -37,7 +34,7 @@ static
 VALUE initialize_copy(VALUE self, VALUE obj)
 {
 	CHECK;
-	*THIS = to<Reflex::ScrollEvent&>(obj);
+	*THIS = to<Reflex::ScrollEvent&>(obj).dup();
 	return self;
 }
 
@@ -45,56 +42,56 @@ static
 VALUE x(VALUE self)
 {
 	CHECK;
-	return value(THIS->x);
+	return value(THIS->scroll().x);
 }
 
 static
 VALUE y(VALUE self)
 {
 	CHECK;
-	return value(THIS->y);
+	return value(THIS->scroll().y);
 }
 
 static
 VALUE z(VALUE self)
 {
 	CHECK;
-	return value(THIS->z);
+	return value(THIS->scroll().z);
 }
 
 static
 VALUE dx(VALUE self)
 {
 	CHECK;
-	return value(THIS->dx);
+	return value(THIS->dscroll().x);
 }
 
 static
 VALUE dy(VALUE self)
 {
 	CHECK;
-	return value(THIS->dy);
+	return value(THIS->dscroll().y);
 }
 
 static
 VALUE dz(VALUE self)
 {
 	CHECK;
-	return value(THIS->dz);
+	return value(THIS->dscroll().z);
 }
 
 static
 VALUE scroll(VALUE self)
 {
 	CHECK;
-	return value(Rays::Point(THIS->x, THIS->y, THIS->z));
+	return value(THIS->scroll());
 }
 
 static
-VALUE delta(VALUE self)
+VALUE dscroll(VALUE self)
 {
 	CHECK;
-	return value(Rays::Point(THIS->dx, THIS->dy, THIS->dz));
+	return value(THIS->dscroll());
 }
 
 
@@ -116,7 +113,7 @@ Init_scroll_event ()
 	rb_define_method(cScrollEvent, "dy", RUBY_METHOD_FUNC(dy), 0);
 	rb_define_method(cScrollEvent, "dz", RUBY_METHOD_FUNC(dz), 0);
 	rb_define_method(cScrollEvent, "scroll", RUBY_METHOD_FUNC(scroll), 0);
-	rb_define_method(cScrollEvent, "delta", RUBY_METHOD_FUNC(delta), 0);
+	rb_define_method(cScrollEvent, "dscroll", RUBY_METHOD_FUNC(dscroll), 0);
 }
 
 

data/.doc/ext/reflex/selector.cpp

@@ -81,6 +81,13 @@ VALUE each_tag(VALUE self)
 	return ret;
 }
 
+static
+VALUE is_empty(VALUE self)
+{
+	CHECK;
+	return value(C_THIS->empty());
+}
+
 static
 VALUE contains(VALUE self, VALUE selector)
 {
@@ -113,6 +120,7 @@ Init_selector ()
 	rb_define_method(cSelector, "clear_tags", RUBY_METHOD_FUNC(clear_tags), 0);
 	cSelector.define_method("tag?",       has_tag);
 	rb_define_method(cSelector, "each_tag", RUBY_METHOD_FUNC(each_tag), 0);
+	cSelector.define_method("empty?",     is_empty);
 	rb_define_method(cSelector, "contains", RUBY_METHOD_FUNC(contains), 1);
 	cSelector.define_method("==", equal);
 }

data/.doc/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,12 @@ RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::Timer)
 #define CALL(fun) RUCY_CALL_SUPER(THIS, fun)
 
 
+static
+VALUE alloc(VALUE klass)
+{
+	Reflex::reflex_error(__FILE__, __LINE__, "can not instantiate Timer class.");
+}
+
 static
 VALUE stop(VALUE self)
 {
@@ -75,13 +82,14 @@ Init_timer ()
 	Module mReflex = rb_define_module("Reflex");
 
 	cTimer = rb_define_class_under(mReflex, "Timer", rb_cObject);
+	rb_define_alloc_func(cTimer, alloc);
 	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);
+	cTimer.define_method("finished?", is_finished);
 
 	define_selector_methods<Reflex::Timer>(cTimer);
 }

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

@@ -24,7 +24,7 @@ VALUE initialize(VALUE self, VALUE timer)
 {
 	CHECK;
 
-	THIS->timer = to<Reflex::Timer*>(timer);
+	*THIS = Reflex::TimerEvent(to<Reflex::Timer*>(timer));
 
 	return rb_call_super(0, NULL);
 }
@@ -33,7 +33,7 @@ static
 VALUE initialize_copy(VALUE self, VALUE obj)
 {
 	CHECK;
-	*THIS = to<Reflex::TimerEvent&>(obj);
+	*THIS = to<Reflex::TimerEvent&>(obj).dup();
 	return self;
 }
 
@@ -41,7 +41,7 @@ static
 VALUE timer(VALUE self)
 {
 	CHECK;
-	return value(THIS->timer);
+	return value(THIS->timer());
 }
 
 static
@@ -65,14 +65,6 @@ VALUE interval(VALUE self)
 	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)
 {
@@ -103,9 +95,8 @@ Init_timer_event ()
 	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);
+	cTimerEvent.define_method("finished?", is_finished);
 }
 
 

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

@@ -22,8 +22,9 @@ VALUE initialize(VALUE self, VALUE now, VALUE 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);
 }
@@ -32,7 +33,7 @@ static
 VALUE initialize_copy(VALUE self, VALUE obj)
 {
 	CHECK;
-	*THIS = to<Reflex::UpdateEvent&>(obj);
+	*THIS = to<Reflex::UpdateEvent&>(obj).dup();
 	return self;
 }
 
@@ -40,14 +41,14 @@ static
 VALUE now(VALUE self)
 {
 	CHECK;
-	return value(THIS->now);
+	return value(THIS->now());
 }
 
 static
 VALUE dt(VALUE self)
 {
 	CHECK;
-	return value(THIS->dt);
+	return value(THIS->dt());
 }
 
 

data/.doc/ext/reflex/view.cpp

@@ -120,6 +120,48 @@ VALUE update_layout(VALUE self)
 	return self;
 }
 
+static
+VALUE from_parent(VALUE self, VALUE point)
+{
+	CHECK;
+	return value(THIS->from_parent(to<Rays::Point>(point)));
+}
+
+static
+VALUE to_parent(VALUE self, VALUE point)
+{
+	CHECK;
+	return value(THIS->to_parent(to<Rays::Point>(point)));
+}
+
+static
+VALUE from_window(VALUE self, VALUE point)
+{
+	CHECK;
+	return value(THIS->from_window(to<Rays::Point>(point)));
+}
+
+static
+VALUE to_window(VALUE self, VALUE point)
+{
+	CHECK;
+	return value(THIS->to_window(to<Rays::Point>(point)));
+}
+
+static
+VALUE from_screen(VALUE self, VALUE point)
+{
+	CHECK;
+	return value(THIS->from_screen(to<Rays::Point>(point)));
+}
+
+static
+VALUE to_screen(VALUE self, VALUE point)
+{
+	CHECK;
+	return value(THIS->to_screen(to<Rays::Point>(point)));
+}
+
 static
 VALUE add_child(VALUE self, VALUE child)
 {
@@ -929,6 +971,13 @@ VALUE on_pointer_move(VALUE self, VALUE event)
 	CALL(on_pointer_move(to<Reflex::PointerEvent*>(event)));
 }
 
+static
+VALUE on_pointer_cancel(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_pointer_cancel(to<Reflex::PointerEvent*>(event)));
+}
+
 static
 VALUE on_wheel(VALUE self, VALUE event)
 {
@@ -991,6 +1040,13 @@ Init_view ()
 	rb_define_private_method(cView, "start_timer", RUBY_METHOD_FUNC(start_timer), -1);
 	rb_define_method(cView, "update_layout", RUBY_METHOD_FUNC(update_layout), 0);
 
+	rb_define_method(cView, "from_parent", RUBY_METHOD_FUNC(from_parent), 1);
+	rb_define_method(cView, "to_parent", RUBY_METHOD_FUNC(to_parent), 1);
+	rb_define_method(cView, "from_window", RUBY_METHOD_FUNC(from_window), 1);
+	rb_define_method(cView, "to_window", RUBY_METHOD_FUNC(to_window), 1);
+	rb_define_method(cView, "from_screen", RUBY_METHOD_FUNC(from_screen), 1);
+	rb_define_method(cView, "to_screen", RUBY_METHOD_FUNC(to_screen), 1);
+
 	rb_define_method(cView, "add_child", RUBY_METHOD_FUNC(add_child), 1);
 	rb_define_method(cView, "remove_child", RUBY_METHOD_FUNC(remove_child), 1);
 	rb_define_method(cView, "clear_children", RUBY_METHOD_FUNC(clear_children), 0);
@@ -1093,6 +1149,7 @@ Init_view ()
 	rb_define_method(cView, "on_pointer_down", RUBY_METHOD_FUNC(on_pointer_down), 1);
 	rb_define_method(cView, "on_pointer_up", RUBY_METHOD_FUNC(on_pointer_up), 1);
 	rb_define_method(cView, "on_pointer_move", RUBY_METHOD_FUNC(on_pointer_move), 1);
+	rb_define_method(cView, "on_pointer_cancel", RUBY_METHOD_FUNC(on_pointer_cancel), 1);
 	rb_define_method(cView, "on_wheel", RUBY_METHOD_FUNC(on_wheel), 1);
 	rb_define_method(cView, "on_capture", RUBY_METHOD_FUNC(on_capture), 1);
 	rb_define_method(cView, "on_timer", RUBY_METHOD_FUNC(on_timer), 1);

data/.doc/ext/reflex/wheel_event.cpp

@@ -19,13 +19,14 @@ VALUE alloc(VALUE klass)
 }
 
 static
-VALUE initialize(VALUE self, VALUE dx, VALUE dy, VALUE dz)
+VALUE initialize(VALUE self, VALUE x, VALUE y, VALUE z, VALUE dx, VALUE dy, VALUE dz, VALUE modifiers)
 {
 	CHECK;
 
-	THIS->dx = to<coord>(dx);
-	THIS->dy = to<coord>(dy);
-	THIS->dz = to<coord>(dz);
+	*THIS = Reflex::WheelEvent(
+		to<coord>( x), to<coord>( y), to<coord>( z),
+		to<coord>(dx), to<coord>(dy), to<coord>(dz),
+		to<uint>(modifiers));
 
 	return rb_call_super(0, NULL);
 }
@@ -34,57 +35,71 @@ static
 VALUE initialize_copy(VALUE self, VALUE obj)
 {
 	CHECK;
-	*THIS = to<Reflex::WheelEvent&>(obj);
+	*THIS = to<Reflex::WheelEvent&>(obj).dup();
 	return self;
 }
 
 static
-VALUE dx(VALUE self)
+VALUE x(VALUE self)
 {
 	CHECK;
-	return value(THIS->dx);
+	return value(THIS->position().x);
 }
 
 static
-VALUE dy(VALUE self)
+VALUE y(VALUE self)
 {
 	CHECK;
-	return value(THIS->dy);
+	return value(THIS->position().y);
 }
 
 static
-VALUE dz(VALUE self)
+VALUE z(VALUE self)
 {
 	CHECK;
-	return value(THIS->dz);
+	return value(THIS->position().z);
 }
 
 static
-VALUE x(VALUE self)
+VALUE dx(VALUE self)
 {
 	CHECK;
-	return value(THIS->x);
+	return value(THIS->dposition().x);
 }
 
 static
-VALUE y(VALUE self)
+VALUE dy(VALUE self)
 {
 	CHECK;
-	return value(THIS->y);
+	return value(THIS->dposition().y);
 }
 
 static
-VALUE z(VALUE self)
+VALUE dz(VALUE self)
+{
+	CHECK;
+	return value(THIS->dposition().z);
+}
+
+static
+VALUE position(VALUE self)
+{
+	CHECK;
+	return value(THIS->position());
+}
+
+static
+VALUE dposition(VALUE self)
 {
 	CHECK;
-	return value(THIS->z);
+	return value(THIS->dposition());
 }
 
 static
 VALUE modifiers(VALUE self)
 {
 	CHECK;
-	return value(THIS->modifiers);
+	return value(THIS->modifiers());
 }
 
 
@@ -97,14 +112,16 @@ Init_wheel_event ()
 
 	cWheelEvent = mReflex.define_class("WheelEvent", Reflex::event_class());
 	rb_define_alloc_func(cWheelEvent, alloc);
-	rb_define_private_method(cWheelEvent, "initialize", RUBY_METHOD_FUNC(initialize), 3);
+	rb_define_private_method(cWheelEvent, "initialize", RUBY_METHOD_FUNC(initialize), 7);
 	rb_define_private_method(cWheelEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
-	rb_define_method(cWheelEvent, "dx", RUBY_METHOD_FUNC(dx), 0);
-	rb_define_method(cWheelEvent, "dy", RUBY_METHOD_FUNC(dy), 0);
-	rb_define_method(cWheelEvent, "dz", RUBY_METHOD_FUNC(dz), 0);
 	rb_define_method(cWheelEvent, "x", RUBY_METHOD_FUNC(x), 0);
 	rb_define_method(cWheelEvent, "y", RUBY_METHOD_FUNC(y), 0);
 	rb_define_method(cWheelEvent, "z", RUBY_METHOD_FUNC(z), 0);
+	rb_define_method(cWheelEvent, "dx", RUBY_METHOD_FUNC(dx), 0);
+	rb_define_method(cWheelEvent, "dy", RUBY_METHOD_FUNC(dy), 0);
+	rb_define_method(cWheelEvent, "dz", RUBY_METHOD_FUNC(dz), 0);
+	rb_define_method(cWheelEvent, "position", RUBY_METHOD_FUNC(position), 0);
+	rb_define_method(cWheelEvent, "dposition", RUBY_METHOD_FUNC(dposition), 0);
 	rb_define_method(cWheelEvent, "modifiers", RUBY_METHOD_FUNC(modifiers), 0);
 }
 

data/.doc/ext/reflex/window.cpp

@@ -54,6 +54,20 @@ VALUE redraw(VALUE self)
 	return self;
 }
 
+static
+VALUE from_screen(VALUE self, VALUE point)
+{
+	CHECK;
+	return value(THIS->from_screen(to<Rays::Point>(point)));
+}
+
+static
+VALUE to_screen(VALUE self, VALUE point)
+{
+	CHECK;
+	return value(THIS->to_screen(to<Rays::Point>(point)));
+}
+
 static
 VALUE set_title(VALUE self, VALUE title)
 {
@@ -84,6 +98,21 @@ VALUE get_frame(VALUE self)
 	return value(THIS->frame());
 }
 
+static
+VALUE set_resizable(VALUE self, VALUE state)
+{
+	CHECK;
+	THIS->set_resizable(to<bool>(state));
+	return value(THIS->is_resizable());
+}
+
+static
+VALUE is_resizable(VALUE self)
+{
+	CHECK;
+	return value(THIS->is_resizable());
+}
+
 static
 VALUE hidden(VALUE self)
 {
@@ -214,6 +243,13 @@ VALUE on_pointer_move(VALUE self, VALUE event)
 	CALL(on_pointer_move(to<Reflex::PointerEvent*>(event)));
 }
 
+static
+VALUE on_pointer_cancel(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_pointer_cancel(to<Reflex::PointerEvent*>(event)));
+}
+
 static
 VALUE on_wheel(VALUE self, VALUE event)
 {
@@ -235,10 +271,14 @@ Init_window ()
 	rb_define_method(cWindow, "hide", RUBY_METHOD_FUNC(hide), 0);
 	rb_define_method(cWindow, "close", RUBY_METHOD_FUNC(close), 0);
 	rb_define_method(cWindow, "redraw", RUBY_METHOD_FUNC(redraw), 0);
+	rb_define_method(cWindow, "from_screen", RUBY_METHOD_FUNC(from_screen), 1);
+	rb_define_method(cWindow, "to_screen", RUBY_METHOD_FUNC(to_screen), 1);
 	rb_define_method(cWindow, "title=", RUBY_METHOD_FUNC(set_title), 1);
 	rb_define_method(cWindow, "title", RUBY_METHOD_FUNC(get_title), 0);
 	rb_define_method(cWindow, "frame=", RUBY_METHOD_FUNC(set_frame), -1);
 	rb_define_method(cWindow, "frame", RUBY_METHOD_FUNC(get_frame), 0);
+	rb_define_method(cWindow, "resizable=", RUBY_METHOD_FUNC(set_resizable), 1);
+	cWindow.define_method("resizable?",  is_resizable);
 	rb_define_method(cWindow, "hidden", RUBY_METHOD_FUNC(hidden), 0);
 	rb_define_method(cWindow, "root", RUBY_METHOD_FUNC(root), 0);
 	rb_define_method(cWindow, "focus", RUBY_METHOD_FUNC(focus), 0);
@@ -257,6 +297,7 @@ Init_window ()
 	rb_define_method(cWindow, "on_pointer_down", RUBY_METHOD_FUNC(on_pointer_down), 1);
 	rb_define_method(cWindow, "on_pointer_up", RUBY_METHOD_FUNC(on_pointer_up), 1);
 	rb_define_method(cWindow, "on_pointer_move", RUBY_METHOD_FUNC(on_pointer_move), 1);
+	rb_define_method(cWindow, "on_pointer_cancel", RUBY_METHOD_FUNC(on_pointer_cancel), 1);
 	rb_define_method(cWindow, "on_wheel", RUBY_METHOD_FUNC(on_wheel), 1);
 }
 

data/VERSION

@@ -1 +1 @@
-0.1.20
+0.1.24

data/ext/reflex/capture_event.cpp

@@ -24,8 +24,9 @@ RUCY_DEF2(initialize, begin, end)
 {
 	CHECK;
 
-	THIS->begin = to<uint>(begin);
-	THIS->end   = to<uint>(end);
+	*THIS = Reflex::CaptureEvent(
+		to<uint>(begin),
+		to<uint>(end));
 
 	return rb_call_super(0, NULL);
 }
@@ -35,7 +36,7 @@ static
 RUCY_DEF1(initialize_copy, obj)
 {
 	CHECK;
-	*THIS = to<Reflex::CaptureEvent&>(obj);
+	*THIS = to<Reflex::CaptureEvent&>(obj).dup();
 	return self;
 }
 RUCY_END
@@ -44,7 +45,7 @@ static
 RUCY_DEF0(begin)
 {
 	CHECK;
-	return value(THIS->begin);
+	return value(THIS->begin());
 }
 RUCY_END
 
@@ -52,7 +53,7 @@ static
 RUCY_DEF0(end)
 {
 	CHECK;
-	return value(THIS->end);
+	return value(THIS->end());
 }
 RUCY_END
 

data/ext/reflex/contact_event.cpp

@@ -3,6 +3,7 @@
 
 #include "reflex/ruby/shape.h"
 #include "reflex/ruby/view.h"
+#include "reflex/ruby/shape.h"
 #include "defs.h"
 
 
@@ -21,12 +22,13 @@ RUCY_DEF_ALLOC(alloc, klass)
 RUCY_END
 
 static
-RUCY_DEF2(initialize, type, shape)
+RUCY_DEF2(initialize, action, shape)
 {
 	CHECK;
 
-	THIS->type  = (Reflex::ContactEvent::Type) to<int>(type);
-	THIS->shape = to<Reflex::Shape*>(shape);
+	*THIS = Reflex::ContactEvent(
+		(Reflex::ContactEvent::Action) to<uint>(action),
+		to<Reflex::Shape*>(shape));
 
 	return rb_call_super(0, NULL);
 }
@@ -36,32 +38,32 @@ static
 RUCY_DEF1(initialize_copy, obj)
 {
 	CHECK;
-	*THIS = to<Reflex::ContactEvent&>(obj);
+	*THIS = to<Reflex::ContactEvent&>(obj).dup();
 	return self;
 }
 RUCY_END
 
 static
-RUCY_DEF0(type)
+RUCY_DEF0(get_action)
 {
 	CHECK;
-	return value(THIS->type);
+	return value(THIS->action());
 }
 RUCY_END
 
 static
-RUCY_DEF0(shape)
+RUCY_DEF0(get_shape)
 {
 	CHECK;
-	return value(THIS->shape);
+	return value(THIS->shape());
 }
 RUCY_END
 
 static
-RUCY_DEF0(view)
+RUCY_DEF0(get_view)
 {
 	CHECK;
-	return value(THIS->view);
+	return value(THIS->view());
 }
 RUCY_END
 
@@ -77,12 +79,12 @@ Init_contact_event ()
 	cContactEvent.define_alloc_func(alloc);
 	cContactEvent.define_private_method("initialize",      initialize);
 	cContactEvent.define_private_method("initialize_copy", initialize_copy);
-	cContactEvent.define_method("type",  type);
-	cContactEvent.define_method("shape", shape);
-	cContactEvent.define_method("view",  view);
-	cContactEvent.define_const("TYPE_NONE",  Reflex::ContactEvent::NONE);
-	cContactEvent.define_const("TYPE_BEGIN", Reflex::ContactEvent::BEGIN);
-	cContactEvent.define_const("TYPE_END",   Reflex::ContactEvent::END);
+	cContactEvent.define_method("action", get_action);
+	cContactEvent.define_method("shape",  get_shape);
+	cContactEvent.define_method("view",   get_view);
+	cContactEvent.define_const("ACTION_NONE", Reflex::ContactEvent::ACTION_NONE);
+	cContactEvent.define_const("BEGIN",       Reflex::ContactEvent::BEGIN);
+	cContactEvent.define_const("END",         Reflex::ContactEvent::END);
 }